Change to pass structures by reference rather than value.

This is faster on ARM in particular. The primary changes involve
fz_matrix, fz_rect and fz_bbox.

Rather than passing 'fz_rect r' into a function, we now consistently
pass 'const fz_rect *r'. Where a rect is passed in and modified, we
miss the 'const' off. Where possible, we return the pointer to the
modified structure to allow 'chaining' of expressions.

The basic upshot of this work is that we do far fewer copies of
rectangle/matrix structures, and all the copies we do are explicit.

This has opened the way to other optimisations, also performed in
this commit.

Rather than using expressions like:

   fz_concat(fz_scale(sx, sy), fz_translate(tx, ty))

we now have fz_pre_{scale,translate,rotate} functions. These
can be implemented much more efficiently than doing the fully
fledged matrix multiplication that fz_concat requires.

We add fz_rect_{min,max} functions to return pointers to the
min/max points of a rect. These can be used to in transformations
to directly manipulate values.

With a little casting in the path transformation code we can avoid
more needless copying.

We rename fz_widget_bbox to the more consistent fz_bound_widget.

61 files changed, 1962 insertions, 1573 deletions

diff --git a/apps/mudraw.c b/apps/mudraw.c
index 30ebda57..dd9386be 100644
--- a/apps/mudraw.c
+++ b/apps/mudraw.c
@@ -221,12 +221,13 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum)
 		}
 		for (;widget; widget = fz_next_widget(inter, widget))
 		{
-			fz_rect rect = fz_widget_bbox(widget);
-			int w = (rect.x1-rect.x0);
-			int h = (rect.y1-rect.y0);
-			int len;
+			fz_rect rect;
+			int w, h, len;
 			int type = fz_widget_get_type(widget);
 
+			fz_bound_widget(widget, &rect);
+			w = (rect.x1 - rect.x0);
+			h = (rect.y1 - rect.y0);
 			++mujstest_count;
 			switch (type)
 			{
@@ -312,7 +313,7 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum)
 		{
 			list = fz_new_display_list(ctx);
 			dev = fz_new_list_device(ctx, list);
-			fz_run_page(doc, page, dev, fz_identity, &cookie);
+			fz_run_page(doc, page, dev, &fz_identity, &cookie);
 		}
 		fz_always(ctx)
 		{
@@ -334,9 +335,9 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum)
 			dev = fz_new_trace_device(ctx);
 			fz_printf(out, "<page number=\"%d\">\n", pagenum);
 			if (list)
-				fz_run_display_list(list, dev, fz_identity, fz_infinite_rect, &cookie);
+				fz_run_display_list(list, dev, &fz_identity, &fz_infinite_rect, &cookie);
 			else
-				fz_run_page(doc, page, dev, fz_identity, &cookie);
+				fz_run_page(doc, page, dev, &fz_identity, &cookie);
 			fz_printf(out, "</page>\n");
 		}
 		fz_always(ctx)
@@ -360,12 +361,13 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum)
 
 		fz_try(ctx)
 		{
-			text = fz_new_text_page(ctx, fz_bound_page(doc, page));
+			fz_rect bounds;
+			text = fz_new_text_page(ctx, fz_bound_page(doc, page, &bounds));
 			dev = fz_new_text_device(ctx, sheet, text);
 			if (list)
-				fz_run_display_list(list, dev, fz_identity, fz_infinite_rect, &cookie);
+				fz_run_display_list(list, dev, &fz_identity, &fz_infinite_rect, &cookie);
 			else
-				fz_run_page(doc, page, dev, fz_identity, &cookie);
+				fz_run_page(doc, page, dev, &fz_identity, &cookie);
 			fz_free_device(dev);
 			dev = NULL;
 			if (showtext == TEXT_XML)
@@ -410,12 +412,11 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum)
 
 		fz_var(pix);
 
-		bounds = fz_bound_page(doc, page);
+		fz_bound_page(doc, page, &bounds);
 		zoom = resolution / 72;
-		ctm = fz_scale(zoom, zoom);
-		ctm = fz_concat(ctm, fz_rotate(rotation));
-		tbounds = fz_transform_rect(ctm, bounds);
-		ibounds = fz_round_rect(tbounds); /* convert to integers */
+		fz_pre_scale(fz_rotate(&ctm, rotation), zoom, zoom);
+		tbounds = bounds;
+		fz_round_rect(&ibounds, fz_transform_rect(&tbounds, &ctm));
 
 		/* Make local copies of our width/height */
 		w = width;
@@ -439,6 +440,7 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum)
 		{
 			float scalex = w / (tbounds.x1 - tbounds.x0);
 			float scaley = h / (tbounds.y1 - tbounds.y0);
+			fz_matrix scale_mat;
 
 			if (fit)
 			{
@@ -461,16 +463,18 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum)
 				else
 					scaley = scalex;
 			}
-			ctm = fz_concat(ctm, fz_scale(scalex, scaley));
-			tbounds = fz_transform_rect(ctm, bounds);
+			fz_scale(&scale_mat, scalex, scaley);
+			fz_concat(&ctm, &ctm, &scale_mat);
+			tbounds = bounds;
+			fz_transform_rect(&tbounds, &ctm);
 		}
-		ibounds = fz_round_rect(tbounds);
+		fz_round_rect(&ibounds, &tbounds);
 
 		/* TODO: banded rendering and multi-page ppm */
 
 		fz_try(ctx)
 		{
-			pix = fz_new_pixmap_with_bbox(ctx, colorspace, ibounds);
+			pix = fz_new_pixmap_with_bbox(ctx, colorspace, &ibounds);
 
 			if (savealpha)
 				fz_clear_pixmap(ctx, pix);
@@ -479,9 +483,9 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum)
 
 			dev = fz_new_draw_device(ctx, pix);
 			if (list)
-				fz_run_display_list(list, dev, ctm, tbounds, &cookie);
+				fz_run_display_list(list, dev, &ctm, &tbounds, &cookie);
 			else
-				fz_run_page(doc, page, dev, ctm, &cookie);
+				fz_run_page(doc, page, dev, &ctm, &cookie);
 			fz_free_device(dev);
 			dev = NULL;
 
diff --git a/apps/pdfapp.c b/apps/pdfapp.c
index 143a18c4..f9ee5406 100644
--- a/apps/pdfapp.c
+++ b/apps/pdfapp.c
@@ -98,9 +98,10 @@ void pdfapp_init(fz_context *ctx, pdfapp_t *app)
 #endif
 }
 
-void pdfapp_invert(pdfapp_t *app, fz_rect rect)
+void pdfapp_invert(pdfapp_t *app, const fz_rect *rect)
 {
-	fz_invert_pixmap_rect(app->image, fz_round_rect(rect));
+	fz_bbox b;
+	fz_invert_pixmap_rect(app->image, fz_round_rect(&b, rect));
 }
 
 static void event_cb(fz_doc_event *event, void *data)
@@ -390,12 +391,9 @@ int pdfapp_preclose(pdfapp_t *app)
 	return 1;
 }
 
-static fz_matrix pdfapp_viewctm(pdfapp_t *app)
+static void pdfapp_viewctm(fz_matrix *mat, pdfapp_t *app)
 {
-	fz_matrix ctm;
-	ctm = fz_scale(app->resolution/72.0f, app->resolution/72.0f);
-	ctm = fz_concat(ctm, fz_rotate(app->rotate));
-	return ctm;
+	fz_pre_rotate(fz_scale(mat, app->resolution/72.0f, app->resolution/72.0f), app->rotate);
 }
 
 static void pdfapp_panview(pdfapp_t *app, int newx, int newy)
@@ -461,7 +459,7 @@ static void pdfapp_loadpage(pdfapp_t *app)
 	{
 		app->page = fz_load_page(app->doc, app->pageno - 1);
 
-		app->page_bbox = fz_bound_page(app->doc, app->page);
+		fz_bound_page(app->doc, app->page, &app->page_bbox);
 	}
 	fz_catch(app->ctx)
 	{
@@ -475,13 +473,13 @@ static void pdfapp_loadpage(pdfapp_t *app)
 		/* Create display lists */
 		app->page_list = fz_new_display_list(app->ctx);
 		mdev = fz_new_list_device(app->ctx, app->page_list);
-		fz_run_page_contents(app->doc, app->page, mdev, fz_identity, &cookie);
+		fz_run_page_contents(app->doc, app->page, mdev, &fz_identity, &cookie);
 		fz_free_device(mdev);
 		mdev = NULL;
 		app->annotations_list = fz_new_display_list(app->ctx);
 		mdev = fz_new_list_device(app->ctx, app->annotations_list);
 		for (annot = fz_first_annot(app->doc, app->page); annot; annot = fz_next_annot(app->doc, annot))
-			fz_run_annot(app->doc, app->page, annot, mdev, fz_identity, &cookie);
+			fz_run_annot(app->doc, app->page, annot, mdev, &fz_identity, &cookie);
 		if (cookie.errors)
 		{
 			pdfapp_warn(app, "Errors found on page");
@@ -532,7 +530,7 @@ static void pdfapp_recreate_annotationslist(pdfapp_t *app)
 		app->annotations_list = fz_new_display_list(app->ctx);
 		mdev = fz_new_list_device(app->ctx, app->annotations_list);
 		for (annot = fz_first_annot(app->doc, app->page); annot; annot = fz_next_annot(app->doc, annot))
-			fz_run_annot(app->doc, app->page, annot, mdev, fz_identity, &cookie);
+			fz_run_annot(app->doc, app->page, annot, mdev, &fz_identity, &cookie);
 		if (cookie.errors)
 		{
 			pdfapp_warn(app, "Errors found on page");
@@ -558,23 +556,26 @@ static void pdfapp_updatepage(pdfapp_t *app)
 {
 	fz_interactive *idoc = fz_interact(app->doc);
 	fz_device *idev;
-	fz_matrix ctm = pdfapp_viewctm(app);
+	fz_matrix ctm;
 	fz_annot *annot;
 
+	pdfapp_viewctm(&ctm, app);
 	fz_update_page(idoc, app->page);
 	pdfapp_recreate_annotationslist(app);
 
 	while ((annot = fz_poll_changed_annot(idoc, app->page)) != NULL)
 	{
-		fz_rect bounds = fz_transform_rect(ctm, fz_bound_annot(app->doc, annot));
-		fz_bbox bbox = fz_round_rect(bounds);
-		fz_clear_pixmap_rect_with_value(app->ctx, app->image, 255, bbox);
-		idev = fz_new_draw_device_with_bbox(app->ctx, app->image, bbox);
+		fz_rect bounds;
+		fz_bbox ibounds;
+		fz_transform_rect(fz_bound_annot(app->doc, annot, &bounds), &ctm);
+		fz_round_rect(&ibounds, &bounds);
+		fz_clear_pixmap_rect_with_value(app->ctx, app->image, 255, &ibounds);
+		idev = fz_new_draw_device_with_bbox(app->ctx, app->image, &ibounds);
 
 		if (app->page_list)
-			fz_run_display_list(app->page_list, idev, ctm, bounds, NULL);
+			fz_run_display_list(app->page_list, idev, &ctm, &bounds, NULL);
 		if (app->annotations_list)
-			fz_run_display_list(app->annotations_list, idev, ctm, bounds, NULL);
+			fz_run_display_list(app->annotations_list, idev, &ctm, &bounds, NULL);
 
 		fz_free_device(idev);
 	}
@@ -591,7 +592,7 @@ static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repai
 	fz_colorspace *colorspace;
 	fz_matrix ctm;
 	fz_rect bounds;
-	fz_bbox bbox;
+	fz_bbox ibounds;
 	fz_cookie cookie = { 0 };
 
 	if (!app->nowaitcursor)
@@ -616,15 +617,15 @@ static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repai
 
 		/* Extract text */
 		app->page_sheet = fz_new_text_sheet(app->ctx);
-		app->page_text = fz_new_text_page(app->ctx, app->page_bbox);
+		app->page_text = fz_new_text_page(app->ctx, &app->page_bbox);
 
 		if (app->page_list || app->annotations_list)
 		{
 			tdev = fz_new_text_device(app->ctx, app->page_sheet, app->page_text);
 			if (app->page_list)
-				fz_run_display_list(app->page_list, tdev, fz_identity, fz_infinite_rect, &cookie);
+				fz_run_display_list(app->page_list, tdev, &fz_identity, &fz_infinite_rect, &cookie);
 			if (app->annotations_list)
-				fz_run_display_list(app->annotations_list, tdev, fz_identity, fz_infinite_rect, &cookie);
+				fz_run_display_list(app->annotations_list, tdev, &fz_identity, &fz_infinite_rect, &cookie);
 			fz_free_device(tdev);
 		}
 	}
@@ -647,9 +648,9 @@ static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repai
 			sprintf(buf, "%s%s", app->doctitle, buf2);
 		wintitle(app, buf);
 
-		ctm = pdfapp_viewctm(app);
-		bounds = fz_transform_rect(ctm, app->page_bbox);
-		bbox = fz_round_rect(bounds);
+		pdfapp_viewctm(&ctm, app);
+		bounds = app->page_bbox;
+		fz_round_rect(&ibounds, fz_transform_rect(&bounds, &ctm));
 
 		/* Draw */
 		if (app->image)
@@ -659,15 +660,15 @@ static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repai
 		else
 			colorspace = app->colorspace;
 		app->image = NULL;
-		app->image = fz_new_pixmap_with_bbox(app->ctx, colorspace, bbox);
+		app->image = fz_new_pixmap_with_bbox(app->ctx, colorspace, &ibounds);
 		fz_clear_pixmap_with_value(app->ctx, app->image, 255);
 		if (app->page_list || app->annotations_list)
 		{
 			idev = fz_new_draw_device(app->ctx, app->image);
 			if (app->page_list)
-				fz_run_display_list(app->page_list, idev, ctm, bounds, &cookie);
+				fz_run_display_list(app->page_list, idev, &ctm, &bounds, &cookie);
 			if (app->annotations_list)
-				fz_run_display_list(app->annotations_list, idev, ctm, bounds, &cookie);
+				fz_run_display_list(app->annotations_list, idev, &ctm, &bounds, &cookie);
 			fz_free_device(idev);
 		}
 		if (app->invert)
@@ -679,7 +680,7 @@ static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repai
 		fz_transition *new_trans;
 		app->new_image = app->image;
 		app->image = NULL;
-		app->image = fz_new_pixmap_with_bbox(app->ctx, colorspace, bbox);
+		app->image = fz_new_pixmap_with_bbox(app->ctx, colorspace, &ibounds);
 		app->duration = 0;
 		new_trans = fz_page_presentation(app->doc, app->page, &app->duration);
 		if (new_trans)
@@ -825,25 +826,25 @@ void pdfapp_inverthit(pdfapp_t *app)
 		return;
 
 	hitbox = fz_empty_rect;
-	ctm = pdfapp_viewctm(app);
+	pdfapp_viewctm(&ctm, app);
 
 	for (i = app->hit; i < app->hit + app->hitlen; i++)
 	{
 		bbox = bboxcharat(app->page_text, i);
-		if (fz_is_empty_rect(bbox))
+		if (fz_is_empty_rect(&bbox))
 		{
-			if (!fz_is_empty_rect(hitbox))
-				pdfapp_invert(app, fz_transform_rect(ctm, hitbox));
+			if (!fz_is_empty_rect(&hitbox))
+				pdfapp_invert(app, fz_transform_rect(&hitbox, &ctm));
 			hitbox = fz_empty_rect;
 		}
 		else
 		{
-			hitbox = fz_union_rect(hitbox, bbox);
+			fz_union_rect(&hitbox, &bbox);
 		}
 	}
 
-	if (!fz_is_empty_rect(hitbox))
-		pdfapp_invert(app, fz_transform_rect(ctm, hitbox));
+	if (!fz_is_empty_rect(&hitbox))
+		pdfapp_invert(app, fz_transform_rect(&hitbox, &ctm));
 }
 
 static int match(char *s, fz_text_page *page, int n)
@@ -1339,19 +1340,20 @@ void pdfapp_onkey(pdfapp_t *app, int c)
 void pdfapp_onmouse(pdfapp_t *app, int x, int y, int btn, int modifiers, int state)
 {
 	fz_context *ctx = app->ctx;
-	fz_bbox rect = fz_pixmap_bbox(app->ctx, app->image);
+	fz_bbox rect;
 	fz_link *link;
 	fz_matrix ctm;
 	fz_point p;
 	int processed = 0;
 
+	fz_pixmap_bbox(app->ctx, app->image, &rect);
 	p.x = x - app->panx + rect.x0;
 	p.y = y - app->pany + rect.y0;
 
-	ctm = pdfapp_viewctm(app);
-	ctm = fz_invert_matrix(ctm);
+	pdfapp_viewctm(&ctm, app);
+	fz_invert_matrix(&ctm, &ctm);
 
-	p = fz_transform_point(ctm, p);
+	fz_transform_point(&p, &ctm);
 
 	if (btn == 1 && (state == 1 || state == -1))
 	{
@@ -1466,7 +1468,8 @@ void pdfapp_onmouse(pdfapp_t *app, int x, int y, int btn, int modifiers, int sta
 		fz_annot *annot;
 		for (annot = fz_first_annot(app->doc, app->page); annot; annot = fz_next_annot(app->doc, annot))
 		{
-			fz_rect rect = fz_bound_annot(app->doc, annot);
+			fz_rect rect;
+			fz_bound_annot(app->doc, annot, &rect);
 			if (x >= rect.x0 && x < rect.x1)
 				if (y >= rect.y0 && y < rect.y1)
 					break;
@@ -1625,7 +1628,7 @@ void pdfapp_oncopy(pdfapp_t *app, unsigned short *ucsbuf, int ucslen)
 	int y0 = app->selr.y0;
 	int y1 = app->selr.y1;
 
-	ctm = pdfapp_viewctm(app);
+	pdfapp_viewctm(&ctm, app);
 
 	p = 0;
 
@@ -1650,7 +1653,7 @@ void pdfapp_oncopy(pdfapp_t *app, unsigned short *ucsbuf, int ucslen)
 				for (i = 0; i < span->len; i++)
 				{
 					hitbox = span->text[i].bbox;
-					hitbox = fz_transform_rect(ctm, hitbox);
+					fz_transform_rect(&hitbox, &ctm);
 					c = span->text[i].c;
 					if (c < 32)
 						c = '?';
diff --git a/apps/pdfapp.h b/apps/pdfapp.h
index 425ba93a..1ee51d45 100644
--- a/apps/pdfapp.h
+++ b/apps/pdfapp.h
@@ -139,7 +139,7 @@ void pdfapp_oncopy(pdfapp_t *app, unsigned short *ucsbuf, int ucslen);
 void pdfapp_onresize(pdfapp_t *app, int w, int h);
 void pdfapp_gotopage(pdfapp_t *app, int number);
 
-void pdfapp_invert(pdfapp_t *app, fz_rect rect);
+void pdfapp_invert(pdfapp_t *app, const fz_rect *rect);
 void pdfapp_inverthit(pdfapp_t *app);
 
 void pdfapp_postblit(pdfapp_t *app);
diff --git a/apps/pdfinfo.c b/apps/pdfinfo.c
index 3fab99c7..2d47456c 100644
--- a/apps/pdfinfo.c
+++ b/apps/pdfinfo.c
@@ -200,7 +200,7 @@ gatherdimensions(int page, pdf_obj *pageref, pdf_obj *pageobj)
 	if (!pdf_is_array(obj))
 		return;
 
-	bbox = pdf_to_rect(ctx, obj);
+	pdf_to_rect(ctx, obj, &bbox);
 
 	obj = pdf_dict_gets(pageobj, "UserUnit");
 	if (pdf_is_real(obj))
diff --git a/apps/win_main.c b/apps/win_main.c
index 3ae482ec..18c110eb 100644
--- a/apps/win_main.c
+++ b/apps/win_main.c
@@ -707,7 +707,7 @@ void winblit()
 	{
 		if (gapp.iscopying || justcopied)
 		{
-			pdfapp_invert(&gapp, gapp.selr);
+			pdfapp_invert(&gapp, &gapp.selr);
 			justcopied = 1;
 		}
 
@@ -747,7 +747,7 @@ void winblit()
 
 		if (gapp.iscopying || justcopied)
 		{
-			pdfapp_invert(&gapp, gapp.selr);
+			pdfapp_invert(&gapp, &gapp.selr);
 			justcopied = 1;
 		}
 	}
diff --git a/apps/x11_main.c b/apps/x11_main.c
index 9e35dafe..364013c8 100644
--- a/apps/x11_main.c
+++ b/apps/x11_main.c
@@ -444,7 +444,7 @@ static void winblit(pdfapp_t *app)
 
 	if (gapp.iscopying || justcopied)
 	{
-		pdfapp_invert(&gapp, gapp.selr);
+		pdfapp_invert(&gapp, &gapp.selr);
 		justcopied = 1;
 	}
 
@@ -487,7 +487,7 @@ static void winblit(pdfapp_t *app)
 
 	if (gapp.iscopying || justcopied)
 	{
-		pdfapp_invert(&gapp, gapp.selr);
+		pdfapp_invert(&gapp, &gapp.selr);
 		justcopied = 1;
 	}
 
diff --git a/cbz/mucbz.c b/cbz/mucbz.c
index 101a3d8d..05119938 100644
--- a/cbz/mucbz.c
+++ b/cbz/mucbz.c
@@ -436,25 +436,25 @@ cbz_free_page(cbz_document *doc, cbz_page *page)
 	fz_free(doc->ctx, page);
 }
 
-fz_rect
-cbz_bound_page(cbz_document *doc, cbz_page *page)
+fz_rect *
+cbz_bound_page(cbz_document *doc, cbz_page *page, fz_rect *bbox)
 {
 	cbz_image *image = page->image;
-	fz_rect bbox;
-	bbox.x0 = bbox.y0 = 0;
-	bbox.x1 = image->base.w * DPI / image->xres;
-	bbox.y1 = image->base.h * DPI / image->yres;
+	bbox->x0 = bbox->y0 = 0;
+	bbox->x1 = image->base.w * DPI / image->xres;
+	bbox->y1 = image->base.h * DPI / image->yres;
 	return bbox;
 }
 
 void
-cbz_run_page(cbz_document *doc, cbz_page *page, fz_device *dev, fz_matrix ctm, fz_cookie *cookie)
+cbz_run_page(cbz_document *doc, cbz_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie)
 {
+	fz_matrix local_ctm = *ctm;
 	cbz_image *image = page->image;
 	float w = image->base.w * DPI / image->xres;
 	float h = image->base.h * DPI / image->yres;
-	ctm = fz_concat(fz_scale(w, h), ctm);
-	fz_fill_image(dev, &image->base, ctm, 1);
+	fz_pre_scale(&local_ctm, w, h);
+	fz_fill_image(dev, &image->base, &local_ctm, 1);
 }
 
 static int
diff --git a/cbz/mucbz.h b/cbz/mucbz.h
index 24a40315..0dd47b6e 100644
--- a/cbz/mucbz.h
+++ b/cbz/mucbz.h
@@ -44,8 +44,8 @@ void cbz_close_document(cbz_document *doc);
 
 int cbz_count_pages(cbz_document *doc);
 cbz_page *cbz_load_page(cbz_document *doc, int number);
-fz_rect cbz_bound_page(cbz_document *doc, cbz_page *page);
+fz_rect *cbz_bound_page(cbz_document *doc, cbz_page *page, fz_rect *rect);
 void cbz_free_page(cbz_document *doc, cbz_page *page);
-void cbz_run_page(cbz_document *doc, cbz_page *page, fz_device *dev, fz_matrix ctm, fz_cookie *cookie);
+void cbz_run_page(cbz_document *doc, cbz_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie);
 
 #endif
diff --git a/draw/draw_affine.c b/draw/draw_affine.c
index 64234bf5..8943214f 100644
--- a/draw/draw_affine.c
+++ b/draw/draw_affine.c
@@ -463,175 +463,176 @@ fz_paint_affine_color_near(byte *dp, byte *sp, int sw, int sh, int u, int v, int
  */
 #define MY_EPSILON 0.001
 
-fz_matrix
-fz_gridfit_matrix(fz_matrix m)
+void
+fz_gridfit_matrix(fz_matrix *m)
 {
-	if (fabsf(m.b) < FLT_EPSILON && fabsf(m.c) < FLT_EPSILON)
+	if (fabsf(m->b) < FLT_EPSILON && fabsf(m->c) < FLT_EPSILON)
 	{
-		if (m.a > 0)
+		if (m->a > 0)
 		{
 			float f;
 			/* Adjust left hand side onto pixel boundary */
-			f = (float)(int)(m.e);
-			if (f - m.e > MY_EPSILON)
+			f = (float)(int)(m->e);
+			if (f - m->e > MY_EPSILON)
 				f -= 1.0; /* Ensure it moves left */
-			m.a += m.e - f; /* width gets wider as f <= m.e */
-			m.e = f;
+			m->a += m->e - f; /* width gets wider as f <= m.e */
+			m->e = f;
 			/* Adjust right hand side onto pixel boundary */
-			f = (float)(int)(m.a);
-			if (m.a - f > MY_EPSILON)
+			f = (float)(int)(m->a);
+			if (m->a - f > MY_EPSILON)
 				f += 1.0; /* Ensure it moves right */
-			m.a = f;
+			m->a = f;
 		}
-		else if (m.a < 0)
+		else if (m->a < 0)
 		{
 			float f;
 			/* Adjust right hand side onto pixel boundary */
-			f = (float)(int)(m.e);
-			if (m.e - f > MY_EPSILON)
+			f = (float)(int)(m->e);
+			if (m->e - f > MY_EPSILON)
 				f += 1.0; /* Ensure it moves right */
-			m.a += m.e - f; /* width gets wider (more -ve) */
-			m.e = f;
+			m->a += m->e - f; /* width gets wider (more -ve) */
+			m->e = f;
 			/* Adjust left hand side onto pixel boundary */
-			f = (float)(int)(m.a);
-			if (f - m.a > MY_EPSILON)
+			f = (float)(int)(m->a);
+			if (f - m->a > MY_EPSILON)
 				f -= 1.0; /* Ensure it moves left */
-			m.a = f;
+			m->a = f;
 		}
-		if (m.d > 0)
+		if (m->d > 0)
 		{
 			float f;
 			/* Adjust top onto pixel boundary */
-			f = (float)(int)(m.f);
-			if (f - m.f > MY_EPSILON)
+			f = (float)(int)(m->f);
+			if (f - m->f > MY_EPSILON)
 				f -= 1.0; /* Ensure it moves upwards */
-			m.d += m.f - f; /* width gets wider as f <= m.f */
-			m.f = f;
+			m->d += m->f - f; /* width gets wider as f <= m.f */
+			m->f = f;
 			/* Adjust bottom onto pixel boundary */
-			f = (float)(int)(m.d);
-			if (m.d - f > MY_EPSILON)
+			f = (float)(int)(m->d);
+			if (m->d - f > MY_EPSILON)
 				f += 1.0; /* Ensure it moves down */
-			m.d = f;
+			m->d = f;
 		}
-		else if (m.d < 0)
+		else if (m->d < 0)
 		{
 			float f;
 			/* Adjust bottom onto pixel boundary */
-			f = (float)(int)(m.f);
-			if (m.f - f > MY_EPSILON)
+			f = (float)(int)(m->f);
+			if (m->f - f > MY_EPSILON)
 				f += 1.0; /* Ensure it moves down */
-			m.d += m.f - f; /* width gets wider (more -ve) */
-			m.f = f;
+			m->d += m->f - f; /* width gets wider (more -ve) */
+			m->f = f;
 			/* Adjust top onto pixel boundary */
-			f = (float)(int)(m.d);
-			if (f - m.d > MY_EPSILON)
+			f = (float)(int)(m->d);
+			if (f - m->d > MY_EPSILON)
 				f -= 1.0; /* Ensure it moves up */
-			m.d = f;
+			m->d = f;
 		}
 	}
-	else if (fabsf(m.a) < FLT_EPSILON && fabsf(m.d) < FLT_EPSILON)
+	else if (fabsf(m->a) < FLT_EPSILON && fabsf(m->d) < FLT_EPSILON)
 	{
-		if (m.b > 0)
+		if (m->b > 0)
 		{
 			float f;
 			/* Adjust left hand side onto pixel boundary */
-			f = (float)(int)(m.f);
-			if (f - m.f > MY_EPSILON)
+			f = (float)(int)(m->f);
+			if (f - m->f > MY_EPSILON)
 				f -= 1.0; /* Ensure it moves left */
-			m.b += m.f - f; /* width gets wider as f <= m.f */
-			m.f = f;
+			m->b += m->f - f; /* width gets wider as f <= m.f */
+			m->f = f;
 			/* Adjust right hand side onto pixel boundary */
-			f = (float)(int)(m.b);
-			if (m.b - f > MY_EPSILON)
+			f = (float)(int)(m->b);
+			if (m->b - f > MY_EPSILON)
 				f += 1.0; /* Ensure it moves right */
-			m.b = f;
+			m->b = f;
 		}
-		else if (m.b < 0)
+		else if (m->b < 0)
 		{
 			float f;
 			/* Adjust right hand side onto pixel boundary */
-			f = (float)(int)(m.f);
-			if (m.f - f > MY_EPSILON)
+			f = (float)(int)(m->f);
+			if (m->f - f > MY_EPSILON)
 				f += 1.0; /* Ensure it moves right */
-			m.b += m.f - f; /* width gets wider (more -ve) */
-			m.f = f;
+			m->b += m->f - f; /* width gets wider (more -ve) */
+			m->f = f;
 			/* Adjust left hand side onto pixel boundary */
-			f = (float)(int)(m.b);
-			if (f - m.b > MY_EPSILON)
+			f = (float)(int)(m->b);
+			if (f - m->b > MY_EPSILON)
 				f -= 1.0; /* Ensure it moves left */
-			m.b = f;
+			m->b = f;
 		}
-		if (m.c > 0)
+		if (m->c > 0)
 		{
 			float f;
 			/* Adjust top onto pixel boundary */
-			f = (float)(int)(m.e);
-			if (f - m.e > MY_EPSILON)
+			f = (float)(int)(m->e);
+			if (f - m->e > MY_EPSILON)
 				f -= 1.0; /* Ensure it moves upwards */
-			m.c += m.e - f; /* width gets wider as f <= m.e */
-			m.e = f;
+			m->c += m->e - f; /* width gets wider as f <= m.e */
+			m->e = f;
 			/* Adjust bottom onto pixel boundary */
-			f = (float)(int)(m.c);
-			if (m.c - f > MY_EPSILON)
+			f = (float)(int)(m->c);
+			if (m->c - f > MY_EPSILON)
 				f += 1.0; /* Ensure it moves down */
-			m.c = f;
+			m->c = f;
 		}
-		else if (m.c < 0)
+		else if (m->c < 0)
 		{
 			float f;
 			/* Adjust bottom onto pixel boundary */
-			f = (float)(int)(m.e);
-			if (m.e - f > MY_EPSILON)
+			f = (float)(int)(m->e);
+			if (m->e - f > MY_EPSILON)
 				f += 1.0; /* Ensure it moves down */
-			m.c += m.e - f; /* width gets wider (more -ve) */
-			m.e = f;
+			m->c += m->e - f; /* width gets wider (more -ve) */
+			m->e = f;
 			/* Adjust top onto pixel boundary */
-			f = (float)(int)(m.c);
-			if (f - m.c > MY_EPSILON)
+			f = (float)(int)(m->c);
+			if (f - m->c > MY_EPSILON)
 				f -= 1.0; /* Ensure it moves up */
-			m.c = f;
+			m->c = f;
 		}
 	}
-	return m;
 }
 
 /* Draw an image with an affine transform on destination */
 
 static void
-fz_paint_image_imp(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, byte *color, int alpha)
+fz_paint_image_imp(fz_pixmap *dst, const fz_bbox *scissor, fz_pixmap *shape, fz_pixmap *img, const fz_matrix *ctm, byte *color, int alpha)
 {
 	byte *dp, *sp, *hp;
 	int u, v, fa, fb, fc, fd;
 	int x, y, w, h;
 	int sw, sh, n, hw;
-	fz_matrix inv;
 	fz_bbox bbox;
 	int dolerp;
 	void (*paintfn)(byte *dp, byte *sp, int sw, int sh, int u, int v, int fa, int fb, int w, int n, int alpha, byte *color, byte *hp);
+	fz_matrix local_ctm = *ctm;
+	fz_rect rect;
 
 	/* grid fit the image */
-	ctm = fz_gridfit_matrix(ctm);
+	fz_gridfit_matrix(&local_ctm);
 
 	/* turn on interpolation for upscaled and non-rectilinear transforms */
 	dolerp = 0;
-	if (!fz_is_rectilinear(ctm))
+	if (!fz_is_rectilinear(&local_ctm))
 		dolerp = 1;
-	if (sqrtf(ctm.a * ctm.a + ctm.b * ctm.b) > img->w)
+	if (sqrtf(local_ctm.a * local_ctm.a + local_ctm.b * local_ctm.b) > img->w)
 		dolerp = 1;
-	if (sqrtf(ctm.c * ctm.c + ctm.d * ctm.d) > img->h)
+	if (sqrtf(local_ctm.c * local_ctm.c + local_ctm.d * local_ctm.d) > img->h)
 		dolerp = 1;
 
 	/* except when we shouldn't, at large magnifications */
 	if (!img->interpolate)
 	{
-		if (sqrtf(ctm.a * ctm.a + ctm.b * ctm.b) > img->w * 2)
+		if (sqrtf(local_ctm.a * local_ctm.a + local_ctm.b * local_ctm.b) > img->w * 2)
 			dolerp = 0;
-		if (sqrtf(ctm.c * ctm.c + ctm.d * ctm.d) > img->h * 2)
+		if (sqrtf(local_ctm.c * local_ctm.c + local_ctm.d * local_ctm.d) > img->h * 2)
 			dolerp = 0;
 	}
 
-	bbox = fz_bbox_from_rect(fz_transform_rect(ctm, fz_unit_rect));
-	bbox = fz_intersect_bbox(bbox, scissor);
+	rect = fz_unit_rect;
+	fz_bbox_from_rect(&bbox, fz_transform_rect(&rect, &local_ctm));
+	fz_intersect_bbox(&bbox, scissor);
 
 	x = bbox.x0;
 	if (shape && shape->x > x)
@@ -651,22 +652,21 @@ fz_paint_image_imp(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap
 		return;
 
 	/* map from screen space (x,y) to image space (u,v) */
-	inv = fz_scale(1.0f / img->w, 1.0f / img->h);
-	inv = fz_concat(inv, ctm);
-	inv = fz_invert_matrix(inv);
+	fz_pre_scale(&local_ctm, 1.0f / img->w, 1.0f / img->h);
+	fz_invert_matrix(&local_ctm, &local_ctm);
 
-	fa = (int)(inv.a *= 65536.0f);
-	fb = (int)(inv.b *= 65536.0f);
-	fc = (int)(inv.c *= 65536.0f);
-	fd = (int)(inv.d *= 65536.0f);
-	inv.e *= 65536.0f;
-	inv.f *= 65536.0f;
+	fa = (int)(local_ctm.a *= 65536.0f);
+	fb = (int)(local_ctm.b *= 65536.0f);
+	fc = (int)(local_ctm.c *= 65536.0f);
+	fd = (int)(local_ctm.d *= 65536.0f);
+	local_ctm.e *= 65536.0f;
+	local_ctm.f *= 65536.0f;
 
 	/* Calculate initial texture positions. Do a half step to start. */
 	/* Bug 693021: Keep calculation in float for as long as possible to
 	 * avoid overflow. */
-	u = (int)((inv.a * x) + (inv.c * y) + inv.e + ((inv.a + inv.c) * .5f));
-	v = (int)((inv.b * x) + (inv.d * y) + inv.f + ((inv.b + inv.d) * .5f));
+	u = (int)((local_ctm.a * x) + (local_ctm.c * y) + local_ctm.e + ((local_ctm.a + local_ctm.c) * .5f));
+	v = (int)((local_ctm.b * x) + (local_ctm.d * y) + local_ctm.f + ((local_ctm.b + local_ctm.d) * .5f));
 
 	/* RJW: The following is voodoo. No idea why it works, but it gives
 	 * the best match between scaled/unscaled/interpolated/non-interpolated
@@ -731,14 +731,14 @@ fz_paint_image_imp(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap
 }
 
 void
-fz_paint_image_with_color(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, byte *color)
+fz_paint_image_with_color(fz_pixmap *dst, const fz_bbox *scissor, fz_pixmap *shape, fz_pixmap *img, const fz_matrix *ctm, byte *color)
 {
 	assert(img->n == 1);
 	fz_paint_image_imp(dst, scissor, shape, img, ctm, color, 255);
 }
 
 void
-fz_paint_image(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, int alpha)
+fz_paint_image(fz_pixmap *dst, const fz_bbox *scissor, fz_pixmap *shape, fz_pixmap *img, const fz_matrix *ctm, int alpha)
 {
 	assert(dst->n == img->n || (dst->n == 4 && img->n == 2));
 	fz_paint_image_imp(dst, scissor, shape, img, ctm, NULL, alpha);
diff --git a/draw/draw_blend.c b/draw/draw_blend.c
index e70699d4..1bbf1dd5 100644
--- a/draw/draw_blend.c
+++ b/draw/draw_blend.c
@@ -575,6 +575,7 @@ fz_blend_pixmap(fz_pixmap *dst, fz_pixmap *src, int alpha, int blendmode, int is
 {
 	unsigned char *sp, *dp;
 	fz_bbox bbox;
+	fz_bbox bbox2;
 	int x, y, w, h, n;
 
 	/* TODO: fix this hack! */
@@ -589,8 +590,9 @@ fz_blend_pixmap(fz_pixmap *dst, fz_pixmap *src, int alpha, int blendmode, int is
 		}
 	}
 
-	bbox = fz_pixmap_bbox_no_ctx(dst);
-	bbox = fz_intersect_bbox(bbox, fz_pixmap_bbox_no_ctx(src));
+	fz_pixmap_bbox_no_ctx(dst, &bbox);
+	fz_pixmap_bbox_no_ctx(src, &bbox2);
+	fz_intersect_bbox(&bbox, &bbox2);
 
 	x = bbox.x0;
 	y = bbox.y0;
diff --git a/draw/draw_device.c b/draw/draw_device.c
index e631e472..21fe71db 100644
--- a/draw/draw_device.c
+++ b/draw/draw_device.c
@@ -137,9 +137,9 @@ fz_knockout_begin(fz_draw_device *dev)
 
 	state = push_stack(dev);
 
-	bbox = fz_pixmap_bbox(dev->ctx, state->dest);
-	bbox = fz_intersect_bbox(bbox, state->scissor);
-	dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, bbox);
+	fz_pixmap_bbox(dev->ctx, state->dest, &bbox);
+	fz_intersect_bbox(&bbox, &state->scissor);
+	dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, &bbox);
 
 	if (isolated)
 	{
@@ -157,7 +157,7 @@ fz_knockout_begin(fz_draw_device *dev)
 				break;
 		}
 		if (prev)
-			fz_copy_pixmap_rect(ctx, dest, prev, bbox);
+			fz_copy_pixmap_rect(ctx, dest, prev, &bbox);
 		else
 			fz_clear_pixmap(ctx, dest);
 	}
@@ -170,7 +170,7 @@ fz_knockout_begin(fz_draw_device *dev)
 	}
 	else
 	{
-		shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+		shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 		fz_clear_pixmap(dev->ctx, shape);
 	}
 #ifdef DUMP_GROUP_BLENDS
@@ -238,7 +238,7 @@ static void fz_knockout_end(fz_draw_device *dev)
 }
 
 static void
-fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, fz_matrix ctm,
+fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_draw_device *dev = devp->user;
@@ -254,14 +254,13 @@ fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, fz_matrix ctm,
 	if (model == NULL)
 		model = fz_device_gray;
 
-	fz_reset_gel(dev->gel, state->scissor);
+	fz_reset_gel(dev->gel, &state->scissor);
 	fz_flatten_fill_path(dev->gel, path, ctm, flatness);
 	fz_sort_gel(dev->gel);
 
-	bbox = fz_bound_gel(dev->gel);
-	bbox = fz_intersect_bbox(bbox, state->scissor);
+	fz_intersect_bbox(fz_bound_gel(dev->gel, &bbox), &state->scissor);
 
-	if (fz_is_empty_rect(bbox))
+	if (fz_is_empty_rect(&bbox))
 		return;
 
 	if (state->blendmode & FZ_BLEND_KNOCKOUT)
@@ -272,15 +271,15 @@ fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, fz_matrix ctm,
 		colorbv[i] = colorfv[i] * 255;
 	colorbv[i] = alpha * 255;
 
-	fz_scan_convert(dev->gel, even_odd, bbox, state->dest, colorbv);
+	fz_scan_convert(dev->gel, even_odd, &bbox, state->dest, colorbv);
 	if (state->shape)
 	{
-		fz_reset_gel(dev->gel, state->scissor);
+		fz_reset_gel(dev->gel, &state->scissor);
 		fz_flatten_fill_path(dev->gel, path, ctm, flatness);
 		fz_sort_gel(dev->gel);
 
 		colorbv[0] = alpha * 255;
-		fz_scan_convert(dev->gel, even_odd, bbox, state->shape, colorbv);
+		fz_scan_convert(dev->gel, even_odd, &bbox, state->shape, colorbv);
 	}
 
 	if (state->blendmode & FZ_BLEND_KNOCKOUT)
@@ -288,7 +287,7 @@ fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, fz_matrix ctm,
 }
 
 static void
-fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
+fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_draw_device *dev = devp->user;
@@ -308,17 +307,16 @@ fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, fz_
 	if (linewidth * expansion < 0.1f)
 		linewidth = 1 / expansion;
 
-	fz_reset_gel(dev->gel, state->scissor);
+	fz_reset_gel(dev->gel, &state->scissor);
 	if (stroke->dash_len > 0)
 		fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth);
 	else
 		fz_flatten_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth);
 	fz_sort_gel(dev->gel);
 
-	bbox = fz_bound_gel(dev->gel);
-	bbox = fz_intersect_bbox(bbox, state->scissor);
+	fz_intersect_bbox(fz_bound_gel(dev->gel, &bbox), &state->scissor);
 
-	if (fz_is_empty_rect(bbox))
+	if (fz_is_empty_rect(&bbox))
 		return;
 
 	if (state->blendmode & FZ_BLEND_KNOCKOUT)
@@ -329,10 +327,10 @@ fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, fz_
 		colorbv[i] = colorfv[i] * 255;
 	colorbv[i] = alpha * 255;
 
-	fz_scan_convert(dev->gel, 0, bbox, state->dest, colorbv);
+	fz_scan_convert(dev->gel, 0, &bbox, state->dest, colorbv);
 	if (state->shape)
 	{
-		fz_reset_gel(dev->gel, state->scissor);
+		fz_reset_gel(dev->gel, &state->scissor);
 		if (stroke->dash_len > 0)
 			fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth);
 		else
@@ -340,7 +338,7 @@ fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, fz_
 		fz_sort_gel(dev->gel);
 
 		colorbv[0] = 255;
-		fz_scan_convert(dev->gel, 0, bbox, state->shape, colorbv);
+		fz_scan_convert(dev->gel, 0, &bbox, state->shape, colorbv);
 	}
 
 	if (state->blendmode & FZ_BLEND_KNOCKOUT)
@@ -348,7 +346,7 @@ fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, fz_
 }
 
 static void
-fz_draw_clip_path(fz_device *devp, fz_path *path, fz_rect rect, int even_odd, fz_matrix ctm)
+fz_draw_clip_path(fz_device *devp, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm)
 {
 	fz_draw_device *dev = devp->user;
 	float expansion = fz_matrix_expansion(ctm);
@@ -358,18 +356,21 @@ fz_draw_clip_path(fz_device *devp, fz_path *path, fz_rect rect, int even_odd, fz
 	fz_colorspace *model;
 	fz_context *ctx = dev->ctx;
 
-	fz_reset_gel(dev->gel, state->scissor);
+	fz_reset_gel(dev->gel, &state->scissor);
 	fz_flatten_fill_path(dev->gel, path, ctm, flatness);
 	fz_sort_gel(dev->gel);
 
 	state = push_stack(dev);
 	model = state->dest->colorspace;
 
-	bbox = fz_bound_gel(dev->gel);
-	bbox = fz_intersect_bbox(bbox, state->scissor);
-	bbox = fz_intersect_bbox(bbox, fz_bbox_from_rect(rect));
+	fz_intersect_bbox(fz_bound_gel(dev->gel, &bbox), &state->scissor);
+	if (rect)
+	{
+		fz_bbox bbox2;
+		fz_intersect_bbox(&bbox, fz_bbox_from_rect(&bbox2, rect));
+	}
 
-	if (fz_is_empty_rect(bbox) || fz_is_rect_gel(dev->gel))
+	if (fz_is_empty_rect(&bbox) || fz_is_rect_gel(dev->gel))
 	{
 		state[1].scissor = bbox;
 		state[1].mask = NULL;
@@ -381,17 +382,17 @@ fz_draw_clip_path(fz_device *devp, fz_path *path, fz_rect rect, int even_odd, fz
 
 	fz_try(ctx)
 	{
-		state[1].mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+		state[1].mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 		fz_clear_pixmap(dev->ctx, state[1].mask);
-		state[1].dest = fz_new_pixmap_with_bbox(dev->ctx, model, bbox);
+		state[1].dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox);
 		fz_clear_pixmap(dev->ctx, state[1].dest);
 		if (state[1].shape)
 		{
-			state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+			state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 			fz_clear_pixmap(dev->ctx, state[1].shape);
 		}
 
-		fz_scan_convert(dev->gel, even_odd, bbox, state[1].mask, NULL);
+		fz_scan_convert(dev->gel, even_odd, &bbox, state[1].mask, NULL);
 
 		state[1].blendmode |= FZ_BLEND_ISOLATED;
 		state[1].scissor = bbox;
@@ -406,7 +407,7 @@ fz_draw_clip_path(fz_device *devp, fz_path *path, fz_rect rect, int even_odd, fz
 }
 
 static void
-fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, fz_rect rect, fz_stroke_state *stroke, fz_matrix ctm)
+fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm)
 {
 	fz_draw_device *dev = devp->user;
 	float expansion = fz_matrix_expansion(ctm);
@@ -420,7 +421,7 @@ fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, fz_rect rect, fz_stroke
 	if (linewidth * expansion < 0.1f)
 		linewidth = 1 / expansion;
 
-	fz_reset_gel(dev->gel, state->scissor);
+	fz_reset_gel(dev->gel, &state->scissor);
 	if (stroke->dash_len > 0)
 		fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth);
 	else
@@ -430,24 +431,27 @@ fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, fz_rect rect, fz_stroke
 	state = push_stack(dev);
 	model = state->dest->colorspace;
 
-	bbox = fz_bound_gel(dev->gel);
-	bbox = fz_intersect_bbox(bbox, state->scissor);
-	bbox = fz_intersect_bbox(bbox, fz_bbox_from_rect(rect));
+	fz_intersect_bbox(fz_bound_gel(dev->gel, &bbox), &state->scissor);
+	if (rect)
+	{
+		fz_bbox bbox2;
+		fz_intersect_bbox(&bbox, fz_bbox_from_rect(&bbox2, rect));
+	}
 
 	fz_try(ctx)
 	{
-		state[1].mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+		state[1].mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 		fz_clear_pixmap(dev->ctx, state[1].mask);
-		state[1].dest = fz_new_pixmap_with_bbox(dev->ctx, model, bbox);
+		state[1].dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox);
 		fz_clear_pixmap(dev->ctx, state[1].dest);
 		if (state->shape)
 		{
-			state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+			state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 			fz_clear_pixmap(dev->ctx, state[1].shape);
 		}
 
-		if (!fz_is_empty_rect(bbox))
-			fz_scan_convert(dev->gel, 0, bbox, state[1].mask, NULL);
+		if (!fz_is_empty_rect(&bbox))
+			fz_scan_convert(dev->gel, 0, &bbox, state[1].mask, NULL);
 
 		state[1].blendmode |= FZ_BLEND_ISOLATED;
 		state[1].scissor = bbox;
@@ -463,15 +467,15 @@ fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, fz_rect rect, fz_stroke
 
 static void
 draw_glyph(unsigned char *colorbv, fz_pixmap *dst, fz_pixmap *msk,
-	int xorig, int yorig, fz_bbox scissor)
+	int xorig, int yorig, const fz_bbox *scissor)
 {
 	unsigned char *dp, *mp;
 	fz_bbox bbox;
 	int x, y, w, h;
 
-	bbox = fz_pixmap_bbox_no_ctx(msk);
-	bbox = fz_translate_bbox(bbox, xorig, yorig);
-	bbox = fz_intersect_bbox(bbox, scissor); /* scissor < dst */
+	fz_pixmap_bbox_no_ctx(msk, &bbox);
+	fz_translate_bbox(&bbox, xorig, yorig);
+	fz_intersect_bbox(&bbox, scissor); /* scissor < dst */
 	x = bbox.x0;
 	y = bbox.y0;
 	w = bbox.x1 - bbox.x0;
@@ -494,7 +498,7 @@ draw_glyph(unsigned char *colorbv, fz_pixmap *dst, fz_pixmap *msk,
 }
 
 static void
-fz_draw_fill_text(fz_device *devp, fz_text *text, fz_matrix ctm,
+fz_draw_fill_text(fz_device *devp, fz_text *text, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_draw_device *dev = devp->user;
@@ -527,7 +531,7 @@ fz_draw_fill_text(fz_device *devp, fz_text *text, fz_matrix ctm,
 
 		tm.e = text->items[i].x;
 		tm.f = text->items[i].y;
-		trm = fz_concat(tm, ctm);
+		fz_concat(&trm, &tm, ctm);
 		x = floorf(trm.e);
 		y = floorf(trm.f);
 
@@ -538,28 +542,28 @@ fz_draw_fill_text(fz_device *devp, fz_text *text, fz_matrix ctm,
 		scissor.x0 -= x; scissor.x1 -= x;
 		scissor.y0 -= y; scissor.y1 -= y;
 
-		glyph = fz_render_glyph(dev->ctx, text->font, gid, trunc_trm, model, scissor);
+		glyph = fz_render_glyph(dev->ctx, text->font, gid, &trunc_trm, model, scissor);
 		if (glyph)
 		{
 			if (glyph->n == 1)
 			{
-				draw_glyph(colorbv, state->dest, glyph, x, y, state->scissor);
+				draw_glyph(colorbv, state->dest, glyph, x, y, &state->scissor);
 				if (state->shape)
-					draw_glyph(&shapebv, state->shape, glyph, x, y, state->scissor);
+					draw_glyph(&shapebv, state->shape, glyph, x, y, &state->scissor);
 			}
 			else
 			{
-				fz_matrix ctm = {glyph->w, 0.0, 0.0, glyph->h, x + glyph->x, y + glyph->y};
-				fz_paint_image(state->dest, state->scissor, state->shape, glyph, ctm, alpha * 255);
+				fz_matrix tm = {glyph->w, 0.0, 0.0, glyph->h, x + glyph->x, y + glyph->y};
+				fz_paint_image(state->dest, &state->scissor, state->shape, glyph, &tm, alpha * 255);
 			}
 			fz_drop_pixmap(dev->ctx, glyph);
 		}
 		else
 		{
-			fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, trm);
+			fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, &trm);
 			if (path)
 			{
-				fz_draw_fill_path(devp, path, 0, fz_identity, colorspace, color, alpha);
+				fz_draw_fill_path(devp, path, 0, &fz_identity, colorspace, color, alpha);
 				fz_free_path(dev->ctx, path);
 			}
 			else
@@ -574,8 +578,9 @@ fz_draw_fill_text(fz_device *devp, fz_text *text, fz_matrix ctm,
 }
 
 static void
-fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
-	fz_colorspace *colorspace, float *color, float alpha)
+fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke,
+	const fz_matrix *ctm, fz_colorspace *colorspace,
+	float *color, float alpha)
 {
 	fz_draw_device *dev = devp->user;
 	unsigned char colorbv[FZ_MAX_COLORS + 1];
@@ -605,7 +610,7 @@ fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, fz_
 
 		tm.e = text->items[i].x;
 		tm.f = text->items[i].y;
-		trm = fz_concat(tm, ctm);
+		fz_concat(&trm, &tm, ctm);
 		x = floorf(trm.e);
 		y = floorf(trm.f);
 
@@ -616,20 +621,20 @@ fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, fz_
 		scissor.x0 -= x; scissor.x1 -= x;
 		scissor.y0 -= y; scissor.y1 -= y;
 
-		glyph = fz_render_stroked_glyph(dev->ctx, text->font, gid, trunc_trm, ctm, stroke, scissor);
+		glyph = fz_render_stroked_glyph(dev->ctx, text->font, gid, &trunc_trm, ctm, stroke, scissor);
 		if (glyph)
 		{
-			draw_glyph(colorbv, state->dest, glyph, x, y, state->scissor);
+			draw_glyph(colorbv, state->dest, glyph, x, y, &state->scissor);
 			if (state->shape)
-				draw_glyph(colorbv, state->shape, glyph, x, y, state->scissor);
+				draw_glyph(colorbv, state->shape, glyph, x, y, &state->scissor);
 			fz_drop_pixmap(dev->ctx, glyph);
 		}
 		else
 		{
-			fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, trm);
+			fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, &trm);
 			if (path)
 			{
-				fz_draw_stroke_path(devp, path, stroke, fz_identity, colorspace, color, alpha);
+				fz_draw_stroke_path(devp, path, stroke, &fz_identity, colorspace, color, alpha);
 				fz_free_path(dev->ctx, path);
 			}
 			else
@@ -644,7 +649,7 @@ fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, fz_
 }
 
 static void
-fz_draw_clip_text(fz_device *devp, fz_text *text, fz_matrix ctm, int accumulate)
+fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accumulate)
 {
 	fz_draw_device *dev = devp->user;
 	fz_context *ctx = dev->ctx;
@@ -666,8 +671,10 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, fz_matrix ctm, int accumulate)
 	if (accumulate == 0)
 	{
 		/* make the mask the exact size needed */
-		bbox = fz_bbox_from_rect(fz_bound_text(dev->ctx, text, ctm));
-		bbox = fz_intersect_bbox(bbox, state->scissor);
+		fz_rect rect;
+
+		fz_bbox_from_rect(&bbox, fz_bound_text(dev->ctx, text, ctm, &rect));
+		fz_intersect_bbox(&bbox, &state->scissor);
 	}
 	else
 	{
@@ -679,13 +686,13 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, fz_matrix ctm, int accumulate)
 	{
 		if (accumulate == 0 || accumulate == 1)
 		{
-			mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+			mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 			fz_clear_pixmap(dev->ctx, mask);
-			dest = fz_new_pixmap_with_bbox(dev->ctx, model, bbox);
+			dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox);
 			fz_clear_pixmap(dev->ctx, dest);
 			if (state->shape)
 			{
-				shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+				shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 				fz_clear_pixmap(dev->ctx, shape);
 			}
 			else
@@ -706,7 +713,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, fz_matrix ctm, int accumulate)
 			dev->top--;
 		}
 
-		if (!fz_is_empty_rect(bbox) && mask)
+		if (!fz_is_empty_rect(&bbox) && mask)
 		{
 			tm = text->trm;
 
@@ -718,7 +725,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, fz_matrix ctm, int accumulate)
 
 				tm.e = text->items[i].x;
 				tm.f = text->items[i].y;
-				trm = fz_concat(tm, ctm);
+				fz_concat(&trm, &tm, ctm);
 				x = floorf(trm.e);
 				y = floorf(trm.f);
 
@@ -726,17 +733,17 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, fz_matrix ctm, int accumulate)
 				trunc_trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX);
 				trunc_trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX);
 
-				glyph = fz_render_glyph(dev->ctx, text->font, gid, trunc_trm, model, bbox);
+				glyph = fz_render_glyph(dev->ctx, text->font, gid, &trunc_trm, model, bbox);
 				if (glyph)
 				{
-					draw_glyph(NULL, mask, glyph, x, y, bbox);
+					draw_glyph(NULL, mask, glyph, x, y, &bbox);
 					if (state[1].shape)
-						draw_glyph(NULL, state[1].shape, glyph, x, y, bbox);
+						draw_glyph(NULL, state[1].shape, glyph, x, y, &bbox);
 					fz_drop_pixmap(dev->ctx, glyph);
 				}
 				else
 				{
-					fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, trm);
+					fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, &trm);
 					if (path)
 					{
 						fz_pixmap *old_dest;
@@ -748,7 +755,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, fz_matrix ctm, int accumulate)
 						state[0].mask = NULL;
 						fz_try(ctx)
 						{
-							fz_draw_fill_path(devp, path, 0, fz_identity, fz_device_gray, &white, 1);
+							fz_draw_fill_path(devp, path, 0, &fz_identity, fz_device_gray, &white, 1);
 						}
 						fz_always(ctx)
 						{
@@ -778,7 +785,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, fz_matrix ctm, int accumulate)
 }
 
 static void
-fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
+fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm)
 {
 	fz_draw_device *dev = devp->user;
 	fz_context *ctx = dev->ctx;
@@ -789,20 +796,21 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke
 	int i, x, y, gid;
 	fz_draw_state *state = push_stack(dev);
 	fz_colorspace *model = state->dest->colorspace;
+	fz_rect rect;
 
 	/* make the mask the exact size needed */
-	bbox = fz_bbox_from_rect(fz_bound_text(dev->ctx, text, ctm));
-	bbox = fz_intersect_bbox(bbox, state->scissor);
+	fz_bbox_from_rect(&bbox, fz_bound_text(dev->ctx, text, ctm, &rect));
+	fz_intersect_bbox(&bbox, &state->scissor);
 
 	fz_try(ctx)
 	{
-		state[1].mask = mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+		state[1].mask = mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 		fz_clear_pixmap(dev->ctx, mask);
-		state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, model, bbox);
+		state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox);
 		fz_clear_pixmap(dev->ctx, dest);
 		if (state->shape)
 		{
-			state[1].shape = shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+			state[1].shape = shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 			fz_clear_pixmap(dev->ctx, shape);
 		}
 		else
@@ -814,7 +822,7 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke
 		dump_spaces(dev->top-1, "Clip (stroke text) begin\n");
 #endif
 
-		if (!fz_is_empty_rect(bbox))
+		if (!fz_is_empty_rect(&bbox))
 		{
 			tm = text->trm;
 
@@ -826,7 +834,7 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke
 
 				tm.e = text->items[i].x;
 				tm.f = text->items[i].y;
-				trm = fz_concat(tm, ctm);
+				fz_concat(&trm, &tm, ctm);
 				x = floorf(trm.e);
 				y = floorf(trm.f);
 
@@ -834,17 +842,17 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke
 				trunc_trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX);
 				trunc_trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX);
 
-				glyph = fz_render_stroked_glyph(dev->ctx, text->font, gid, trunc_trm, ctm, stroke, bbox);
+				glyph = fz_render_stroked_glyph(dev->ctx, text->font, gid, &trunc_trm, ctm, stroke, bbox);
 				if (glyph)
 				{
-					draw_glyph(NULL, mask, glyph, x, y, bbox);
+					draw_glyph(NULL, mask, glyph, x, y, &bbox);
 					if (shape)
-						draw_glyph(NULL, shape, glyph, x, y, bbox);
+						draw_glyph(NULL, shape, glyph, x, y, &bbox);
 					fz_drop_pixmap(dev->ctx, glyph);
 				}
 				else
 				{
-					fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, trm);
+					fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, &trm);
 					if (path)
 					{
 						fz_pixmap *old_dest;
@@ -856,7 +864,7 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke
 						state[0].mask = NULL;
 						fz_try(ctx)
 						{
-							fz_draw_stroke_path(devp, path, stroke, fz_identity, fz_device_gray, &white, 1);
+							fz_draw_stroke_path(devp, path, stroke, &fz_identity, fz_device_gray, &white, 1);
 						}
 						fz_always(ctx)
 						{
@@ -884,12 +892,12 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke
 }
 
 static void
-fz_draw_ignore_text(fz_device *dev, fz_text *text, fz_matrix ctm)
+fz_draw_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm)
 {
 }
 
 static void
-fz_draw_fill_shade(fz_device *devp, fz_shade *shade, fz_matrix ctm, float alpha)
+fz_draw_fill_shade(fz_device *devp, fz_shade *shade, const fz_matrix *ctm, float alpha)
 {
 	fz_draw_device *dev = devp->user;
 	fz_rect bounds;
@@ -900,11 +908,11 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, fz_matrix ctm, float alpha)
 	fz_draw_state *state = &dev->stack[dev->top];
 	fz_colorspace *model = state->dest->colorspace;
 
-	bounds = fz_bound_shade(dev->ctx, shade, ctm);
+	fz_bound_shade(dev->ctx, shade, ctm, &bounds);
 	scissor = state->scissor;
-	bbox = fz_intersect_bbox(fz_bbox_from_rect(bounds), scissor);
+	fz_intersect_bbox(fz_bbox_from_rect(&bbox, &bounds), &scissor);
 
-	if (fz_is_empty_rect(bbox))
+	if (fz_is_empty_rect(&bbox))
 		return;
 
 	if (!model)
@@ -921,11 +929,11 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, fz_matrix ctm, float alpha)
 
 	if (alpha < 1)
 	{
-		dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, bbox);
+		dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, &bbox);
 		fz_clear_pixmap(dev->ctx, dest);
 		if (shape)
 		{
-			shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+			shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 			fz_clear_pixmap(dev->ctx, shape);
 		}
 	}
@@ -962,9 +970,9 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, fz_matrix ctm, float alpha)
 		}
 	}
 
-	fz_paint_shade(dev->ctx, shade, ctm, dest, bbox);
+	fz_paint_shade(dev->ctx, shade, ctm, dest, &bbox);
 	if (shape)
-		fz_clear_pixmap_rect_with_value(dev->ctx, shape, 255, bbox);
+		fz_clear_pixmap_rect_with_value(dev->ctx, shape, 255, &bbox);
 
 	if (alpha < 1)
 	{
@@ -982,7 +990,7 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, fz_matrix ctm, float alpha)
 }
 
 static fz_pixmap *
-fz_transform_pixmap(fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int dy, int gridfit, fz_bbox *clip)
+fz_transform_pixmap(fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int dy, int gridfit, const fz_bbox *clip)
 {
 	fz_pixmap *scaled;
 	fz_context *ctx = dev->ctx;
@@ -992,7 +1000,7 @@ fz_transform_pixmap(fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x
 		/* Unrotated or X-flip or Y-flip or XY-flip */
 		fz_matrix m = *ctm;
 		if (gridfit)
-			m = fz_gridfit_matrix(m);
+			fz_gridfit_matrix(&m);
 		scaled = fz_scale_pixmap_cached(ctx, image, m.e, m.f, m.a, m.d, clip, dev->cache_x, dev->cache_y);
 		if (!scaled)
 			return NULL;
@@ -1009,7 +1017,7 @@ fz_transform_pixmap(fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x
 		fz_matrix m = *ctm;
 		fz_bbox rclip;
 		if (gridfit)
-			m = fz_gridfit_matrix(m);
+			fz_gridfit_matrix(&m);
 		if (clip)
 		{
 			rclip.x0 = clip->y0;
@@ -1017,7 +1025,7 @@ fz_transform_pixmap(fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x
 			rclip.x1 = clip->y1;
 			rclip.y1 = clip->x1;
 		}
-		scaled = fz_scale_pixmap_cached(ctx, image, m.f, m.e, m.b, m.c, (clip ? &rclip : 0), dev->cache_x, dev->cache_y);
+		scaled = fz_scale_pixmap_cached(ctx, image, m.f, m.e, m.b, m.c, (clip ? &rclip : NULL), dev->cache_x, dev->cache_y);
 		if (!scaled)
 			return NULL;
 		ctm->b = scaled->w;
@@ -1038,7 +1046,7 @@ fz_transform_pixmap(fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x
 }
 
 static void
-fz_draw_fill_image(fz_device *devp, fz_image *image, fz_matrix ctm, float alpha)
+fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float alpha)
 {
 	fz_draw_device *dev = devp->user;
 	fz_pixmap *converted = NULL;
@@ -1050,9 +1058,10 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, fz_matrix ctm, float alpha)
 	fz_context *ctx = dev->ctx;
 	fz_draw_state *state = &dev->stack[dev->top];
 	fz_colorspace *model = state->dest->colorspace;
-	fz_bbox clip = fz_pixmap_bbox(ctx, state->dest);
+	fz_bbox clip;
+	fz_matrix local_ctm = *ctm;
 
-	clip = fz_intersect_bbox(clip, state->scissor);
+	fz_intersect_bbox(fz_pixmap_bbox(ctx, state->dest, &clip), &state->scissor);
 
 	fz_var(scaled);
 
@@ -1065,8 +1074,8 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, fz_matrix ctm, float alpha)
 	if (image->w == 0 || image->h == 0)
 		return;
 
-	dx = sqrtf(ctm.a * ctm.a + ctm.b * ctm.b);
-	dy = sqrtf(ctm.c * ctm.c + ctm.d * ctm.d);
+	dx = sqrtf(local_ctm.a * local_ctm.a + local_ctm.b * local_ctm.b);
+	dy = sqrtf(local_ctm.c * local_ctm.c + local_ctm.d * local_ctm.d);
 
 	pixmap = fz_image_to_pixmap(ctx, image, dx, dy);
 	orig_pixmap = pixmap;
@@ -1086,7 +1095,9 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, fz_matrix ctm, float alpha)
 
 		if (pixmap->colorspace != model && !after)
 		{
-			converted = fz_new_pixmap_with_bbox(ctx, model, fz_pixmap_bbox(ctx, pixmap));
+			fz_bbox bbox;
+			fz_pixmap_bbox(ctx, pixmap, &bbox);
+			converted = fz_new_pixmap_with_bbox(ctx, model, &bbox);
 			fz_convert_pixmap(ctx, converted, pixmap);
 			pixmap = converted;
 		}
@@ -1094,7 +1105,7 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, fz_matrix ctm, float alpha)
 		if (dx < pixmap->w && dy < pixmap->h)
 		{
 			int gridfit = alpha == 1.0f && !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3);
-			scaled = fz_transform_pixmap(dev, pixmap, &ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip);
+			scaled = fz_transform_pixmap(dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip);
 			if (!scaled)
 			{
 				if (dx < 1)
@@ -1116,13 +1127,15 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, fz_matrix ctm, float alpha)
 			}
 			else
 			{
-				converted = fz_new_pixmap_with_bbox(ctx, model, fz_pixmap_bbox(ctx, pixmap));
+				fz_bbox bbox;
+				fz_pixmap_bbox(ctx, pixmap, &bbox);
+				converted = fz_new_pixmap_with_bbox(ctx, model, &bbox);
 				fz_convert_pixmap(ctx, converted, pixmap);
 				pixmap = converted;
 			}
 		}
 
-		fz_paint_image(state->dest, state->scissor, state->shape, pixmap, ctm, alpha * 255);
+		fz_paint_image(state->dest, &state->scissor, state->shape, pixmap, &local_ctm, alpha * 255);
 
 		if (state->blendmode & FZ_BLEND_KNOCKOUT)
 			fz_knockout_end(dev);
@@ -1140,7 +1153,7 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, fz_matrix ctm, float alpha)
 }
 
 static void
-fz_draw_fill_image_mask(fz_device *devp, fz_image *image, fz_matrix ctm,
+fz_draw_fill_image_mask(fz_device *devp, fz_image *image, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_draw_device *dev = devp->user;
@@ -1154,15 +1167,17 @@ fz_draw_fill_image_mask(fz_device *devp, fz_image *image, fz_matrix ctm,
 	fz_context *ctx = dev->ctx;
 	fz_draw_state *state = &dev->stack[dev->top];
 	fz_colorspace *model = state->dest->colorspace;
-	fz_bbox clip = fz_pixmap_bbox(ctx, state->dest);
+	fz_bbox clip;
+	fz_matrix local_ctm = *ctm;
 
-	clip = fz_intersect_bbox(clip, state->scissor);
+	fz_pixmap_bbox(ctx, state->dest, &clip);
+	fz_intersect_bbox(&clip, &state->scissor);
 
 	if (image->w == 0 || image->h == 0)
 		return;
 
-	dx = sqrtf(ctm.a * ctm.a + ctm.b * ctm.b);
-	dy = sqrtf(ctm.c * ctm.c + ctm.d * ctm.d);
+	dx = sqrtf(local_ctm.a * local_ctm.a + local_ctm.b * local_ctm.b);
+	dy = sqrtf(local_ctm.c * local_ctm.c + local_ctm.d * local_ctm.d);
 	pixmap = fz_image_to_pixmap(ctx, image, dx, dy);
 	orig_pixmap = pixmap;
 
@@ -1174,7 +1189,7 @@ fz_draw_fill_image_mask(fz_device *devp, fz_image *image, fz_matrix ctm,
 		if (dx < pixmap->w && dy < pixmap->h)
 		{
 			int gridfit = alpha == 1.0f && !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3);
-			scaled = fz_transform_pixmap(dev, pixmap, &ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip);
+			scaled = fz_transform_pixmap(dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip);
 			if (!scaled)
 			{
 				if (dx < 1)
@@ -1192,7 +1207,7 @@ fz_draw_fill_image_mask(fz_device *devp, fz_image *image, fz_matrix ctm,
 			colorbv[i] = colorfv[i] * 255;
 		colorbv[i] = alpha * 255;
 
-		fz_paint_image_with_color(state->dest, state->scissor, state->shape, pixmap, ctm, colorbv);
+		fz_paint_image_with_color(state->dest, &state->scissor, state->shape, pixmap, &local_ctm, colorbv);
 
 		if (scaled)
 			fz_drop_pixmap(dev->ctx, scaled);
@@ -1211,7 +1226,7 @@ fz_draw_fill_image_mask(fz_device *devp, fz_image *image, fz_matrix ctm,
 }
 
 static void
-fz_draw_clip_image_mask(fz_device *devp, fz_image *image, fz_rect rect, fz_matrix ctm)
+fz_draw_clip_image_mask(fz_device *devp, fz_image *image, const fz_rect *rect, const fz_matrix *ctm)
 {
 	fz_draw_device *dev = devp->user;
 	fz_context *ctx = dev->ctx;
@@ -1225,9 +1240,12 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, fz_rect rect, fz_matri
 	int dx, dy;
 	fz_draw_state *state = push_stack(dev);
 	fz_colorspace *model = state->dest->colorspace;
-	fz_bbox clip = fz_pixmap_bbox(ctx, state->dest);
+	fz_bbox clip;
+	fz_matrix local_ctm = *ctm;
+	fz_rect urect;
 
-	clip = fz_intersect_bbox(clip, state->scissor);
+	fz_pixmap_bbox(ctx, state->dest, &clip);
+	fz_intersect_bbox(&clip, &state->scissor);
 
 	fz_var(mask);
 	fz_var(dest);
@@ -1249,26 +1267,31 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, fz_rect rect, fz_matri
 	dump_spaces(dev->top-1, "Clip (image mask) begin\n");
 #endif
 
-	bbox = fz_bbox_from_rect(fz_transform_rect(ctm, fz_unit_rect));
-	bbox = fz_intersect_bbox(bbox, state->scissor);
-	bbox = fz_intersect_bbox(bbox, fz_bbox_from_rect(rect));
+	urect = fz_unit_rect;
+	fz_bbox_from_rect(&bbox, fz_transform_rect(&urect, &local_ctm));
+	fz_intersect_bbox(&bbox, &state->scissor);
+	if (rect)
+	{
+		fz_bbox bbox2;
+		fz_intersect_bbox(&bbox, fz_bbox_from_rect(&bbox2, rect));
+	}
 
-	dx = sqrtf(ctm.a * ctm.a + ctm.b * ctm.b);
-	dy = sqrtf(ctm.c * ctm.c + ctm.d * ctm.d);
+	dx = sqrtf(local_ctm.a * local_ctm.a + local_ctm.b * local_ctm.b);
+	dy = sqrtf(local_ctm.c * local_ctm.c + local_ctm.d * local_ctm.d);
 
 	fz_try(ctx)
 	{
 		pixmap = fz_image_to_pixmap(ctx, image, dx, dy);
 		orig_pixmap = pixmap;
 
-		state[1].mask = mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+		state[1].mask = mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 		fz_clear_pixmap(dev->ctx, mask);
 
-		state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, model, bbox);
+		state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox);
 		fz_clear_pixmap(dev->ctx, dest);
 		if (state->shape)
 		{
-			state[1].shape = shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+			state[1].shape = shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 			fz_clear_pixmap(dev->ctx, shape);
 		}
 
@@ -1278,7 +1301,7 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, fz_rect rect, fz_matri
 		if (dx < pixmap->w && dy < pixmap->h)
 		{
 			int gridfit = !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3);
-			scaled = fz_transform_pixmap(dev, pixmap, &ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip);
+			scaled = fz_transform_pixmap(dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip);
 			if (!scaled)
 			{
 				if (dx < 1)
@@ -1290,7 +1313,7 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, fz_rect rect, fz_matri
 			if (scaled)
 				pixmap = scaled;
 		}
-		fz_paint_image(mask, bbox, state->shape, pixmap, ctm, 255);
+		fz_paint_image(mask, &bbox, state->shape, pixmap, &local_ctm, 255);
 	}
 	fz_always(ctx)
 	{
@@ -1356,7 +1379,7 @@ fz_draw_pop_clip(fz_device *devp)
 }
 
 static void
-fz_draw_begin_mask(fz_device *devp, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *colorfv)
+fz_draw_begin_mask(fz_device *devp, const fz_rect *rect, int luminosity, fz_colorspace *colorspace, float *colorfv)
 {
 	fz_draw_device *dev = devp->user;
 	fz_pixmap *dest;
@@ -1365,12 +1388,11 @@ fz_draw_begin_mask(fz_device *devp, fz_rect rect, int luminosity, fz_colorspace
 	fz_pixmap *shape = state->shape;
 	fz_context *ctx = dev->ctx;
 
-	bbox = fz_bbox_from_rect(rect);
-	bbox = fz_intersect_bbox(bbox, state->scissor);
+	fz_intersect_bbox(fz_bbox_from_rect(&bbox, rect), &state->scissor);
 
 	fz_try(ctx)
 	{
-		state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, fz_device_gray, bbox);
+		state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, fz_device_gray, &bbox);
 		if (state->shape)
 		{
 			/* FIXME: If we ever want to support AIS true, then
@@ -1446,8 +1468,8 @@ fz_draw_end_mask(fz_device *devp)
 	state[1].mask = NULL;
 
 	/* create new dest scratch buffer */
-	bbox = fz_pixmap_bbox(ctx, temp);
-	dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, bbox);
+	fz_pixmap_bbox(ctx, temp, &bbox);
+	dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, &bbox);
 	fz_clear_pixmap(dev->ctx, dest);
 
 	/* push soft mask as clip mask */
@@ -1458,14 +1480,14 @@ fz_draw_end_mask(fz_device *devp)
 	 * clip mask when we pop. So create a new shape now. */
 	if (state[0].shape)
 	{
-		state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+		state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 		fz_clear_pixmap(dev->ctx, state[1].shape);
 	}
 	state[1].scissor = bbox;
 }
 
 static void
-fz_draw_begin_group(fz_device *devp, fz_rect rect, int isolated, int knockout, int blendmode, float alpha)
+fz_draw_begin_group(fz_device *devp, const fz_rect *rect, int isolated, int knockout, int blendmode, float alpha)
 {
 	fz_draw_device *dev = devp->user;
 	fz_bbox bbox;
@@ -1478,12 +1500,11 @@ fz_draw_begin_group(fz_device *devp, fz_rect rect, int isolated, int knockout, i
 		fz_knockout_begin(dev);
 
 	state = push_stack(dev);
-	bbox = fz_bbox_from_rect(rect);
-	bbox = fz_intersect_bbox(bbox, state->scissor);
+	fz_intersect_bbox(fz_bbox_from_rect(&bbox, rect), &state->scissor);
 
 	fz_try(ctx)
 	{
-		state[1].dest = dest = fz_new_pixmap_with_bbox(ctx, model, bbox);
+		state[1].dest = dest = fz_new_pixmap_with_bbox(ctx, model, &bbox);
 
 #ifndef ATTEMPT_KNOCKOUT_AND_ISOLATED
 		knockout = 0;
@@ -1496,7 +1517,7 @@ fz_draw_begin_group(fz_device *devp, fz_rect rect, int isolated, int knockout, i
 		}
 		else
 		{
-			fz_copy_pixmap_rect(dev->ctx, dest, state[0].dest, bbox);
+			fz_copy_pixmap_rect(dev->ctx, dest, state[0].dest, &bbox);
 		}
 
 		if (blendmode == 0 && alpha == 1.0 && isolated)
@@ -1507,7 +1528,7 @@ fz_draw_begin_group(fz_device *devp, fz_rect rect, int isolated, int knockout, i
 		}
 		else
 		{
-			state[1].shape = shape = fz_new_pixmap_with_bbox(ctx, NULL, bbox);
+			state[1].shape = shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox);
 			fz_clear_pixmap(dev->ctx, shape);
 		}
 
@@ -1586,7 +1607,7 @@ fz_draw_end_group(fz_device *devp)
 }
 
 static void
-fz_draw_begin_tile(fz_device *devp, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
+fz_draw_begin_tile(fz_device *devp, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm)
 {
 	fz_draw_device *dev = devp->user;
 	fz_pixmap *dest = NULL;
@@ -1595,6 +1616,7 @@ fz_draw_begin_tile(fz_device *devp, fz_rect area, fz_rect view, float xstep, flo
 	fz_context *ctx = dev->ctx;
 	fz_draw_state *state = &dev->stack[dev->top];
 	fz_colorspace *model = state->dest->colorspace;
+	fz_rect local_view = *view;
 
 	/* area, view, xstep, ystep are in pattern space */
 	/* ctm maps from pattern space to device space */
@@ -1603,7 +1625,7 @@ fz_draw_begin_tile(fz_device *devp, fz_rect area, fz_rect view, float xstep, flo
 		fz_knockout_begin(dev);
 
 	state = push_stack(dev);
-	bbox = fz_bbox_from_rect(fz_transform_rect(ctm, view));
+	fz_bbox_from_rect(&bbox, fz_transform_rect(&local_view, ctm));
 	/* We should never have a bbox that entirely covers our destination.
 	 * If we do, then the check for only 1 tile being visible above has
 	 * failed. Actually, this *can* fail due to the round_rect, at extreme
@@ -1613,19 +1635,19 @@ fz_draw_begin_tile(fz_device *devp, fz_rect area, fz_rect view, float xstep, flo
 	 */
 	fz_try(ctx)
 	{
-		state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, model, bbox);
+		state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox);
 		fz_clear_pixmap(ctx, dest);
 		shape = state[0].shape;
 		if (shape)
 		{
-			state[1].shape = shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
+			state[1].shape = shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox);
 			fz_clear_pixmap(ctx, shape);
 		}
 		state[1].blendmode |= FZ_BLEND_ISOLATED;
 		state[1].xstep = xstep;
 		state[1].ystep = ystep;
-		state[1].area = fz_bbox_from_rect(area);
-		state[1].ctm = ctm;
+		fz_bbox_from_rect(&state[1].area, area);
+		state[1].ctm = *ctm;
 #ifdef DUMP_GROUP_BLENDS
 		dump_spaces(dev->top-1, "Tile begin\n");
 #endif
@@ -1665,12 +1687,11 @@ fz_draw_end_tile(fz_device *devp)
 
 	/* Fudge the scissor bbox a little to allow for inaccuracies in the
 	 * matrix inversion. */
-	scissor_tmp = fz_rect_from_bbox(state[0].scissor);
-	scissor_tmp = fz_expand_rect(scissor_tmp, 1);
-	scissor_tmp = fz_transform_rect(fz_invert_matrix(ctm), scissor_tmp);
-	scissor = fz_bbox_from_rect(scissor_tmp);
-	area = fz_intersect_bbox(area, scissor);
+	fz_rect_from_bbox(&scissor_tmp, &state[0].scissor);
+	fz_transform_rect(fz_expand_rect(&scissor_tmp, 1), fz_invert_matrix(&ttm, &ctm));
+	fz_intersect_bbox(&area, fz_bbox_from_rect(&scissor, &scissor_tmp));
 
+	/* FIXME: area is a bbox, so FP not appropriate here */
 	x0 = floorf(area.x0 / xstep);
 	y0 = floorf(area.y0 / ystep);
 	x1 = ceilf(area.x1 / xstep);
@@ -1699,7 +1720,8 @@ fz_draw_end_tile(fz_device *devp)
 	{
 		for (x = x0; x < x1; x++)
 		{
-			ttm = fz_concat(fz_translate(x * xstep, y * ystep), ctm);
+			ttm = ctm;
+			fz_pre_translate(&ttm, x * xstep, y * ystep);
 			state[1].dest->x = ttm.e;
 			state[1].dest->y = ttm.f;
 			if (state[1].dest->x > 0 && state[1].dest->x + state[1].dest->w < 0)
@@ -1709,7 +1731,8 @@ fz_draw_end_tile(fz_device *devp)
 			fz_paint_pixmap_with_bbox(state[0].dest, state[1].dest, 255, state[0].scissor);
 			if (state[1].shape)
 			{
-				ttm = fz_concat(fz_translate(x * xstep, y * ystep), shapectm);
+				ttm = shapectm;
+				fz_pre_translate(&ttm, x * xstep, y * ystep);
 				state[1].shape->x = ttm.e;
 				state[1].shape->y = ttm.f;
 				fz_paint_pixmap_with_bbox(state[0].shape, state[1].shape, 255, state[0].scissor);
@@ -1829,19 +1852,19 @@ fz_new_draw_device(fz_context *ctx, fz_pixmap *dest)
 }
 
 fz_device *
-fz_new_draw_device_with_bbox(fz_context *ctx, fz_pixmap *dest, fz_bbox clip)
+fz_new_draw_device_with_bbox(fz_context *ctx, fz_pixmap *dest, const fz_bbox *clip)
 {
 	fz_device *dev = fz_new_draw_device(ctx, dest);
 	fz_draw_device *ddev = dev->user;
 
-	if (clip.x0 > ddev->stack[0].scissor.x0)
-		ddev->stack[0].scissor.x0 = clip.x0;
-	if (clip.x1 < ddev->stack[0].scissor.x1)
-		ddev->stack[0].scissor.x1 = clip.x1;
-	if (clip.y0 > ddev->stack[0].scissor.y0)
-		ddev->stack[0].scissor.y0 = clip.y0;
-	if (clip.y1 < ddev->stack[0].scissor.y1)
-		ddev->stack[0].scissor.y1 = clip.y1;
+	if (clip->x0 > ddev->stack[0].scissor.x0)
+		ddev->stack[0].scissor.x0 = clip->x0;
+	if (clip->x1 < ddev->stack[0].scissor.x1)
+		ddev->stack[0].scissor.x1 = clip->x1;
+	if (clip->y0 > ddev->stack[0].scissor.y0)
+		ddev->stack[0].scissor.y0 = clip->y0;
+	if (clip->y1 < ddev->stack[0].scissor.y1)
+		ddev->stack[0].scissor.y1 = clip->y1;
 	return dev;
 }
 
diff --git a/draw/draw_edge.c b/draw/draw_edge.c
index 6c22aa73..dca6a648 100644
--- a/draw/draw_edge.c
+++ b/draw/draw_edge.c
@@ -203,7 +203,7 @@ fz_new_gel(fz_context *ctx)
 }
 
 void
-fz_reset_gel(fz_gel *gel, fz_bbox clip)
+fz_reset_gel(fz_gel *gel, const fz_bbox *clip)
 {
 	fz_aa_context *ctxaa = gel->ctx->aa;
 
@@ -213,10 +213,10 @@ fz_reset_gel(fz_gel *gel, fz_bbox clip)
 		gel->clip.x1 = gel->clip.y1 = BBOX_MIN;
 	}
 	else {
-		gel->clip.x0 = clip.x0 * fz_aa_hscale;
-		gel->clip.x1 = clip.x1 * fz_aa_hscale;
-		gel->clip.y0 = clip.y0 * fz_aa_vscale;
-		gel->clip.y1 = clip.y1 * fz_aa_vscale;
+		gel->clip.x0 = clip->x0 * fz_aa_hscale;
+		gel->clip.x1 = clip->x1 * fz_aa_hscale;
+		gel->clip.y0 = clip->y0 * fz_aa_vscale;
+		gel->clip.y1 = clip->y1 * fz_aa_vscale;
 	}
 
 	gel->bbox.x0 = gel->bbox.y0 = BBOX_MAX;
@@ -235,17 +235,21 @@ fz_free_gel(fz_gel *gel)
 	fz_free(gel->ctx, gel);
 }
 
-fz_bbox
-fz_bound_gel(fz_gel *gel)
+fz_bbox *
+fz_bound_gel(const fz_gel *gel, fz_bbox *bbox)
 {
-	fz_bbox bbox;
 	fz_aa_context *ctxaa = gel->ctx->aa;
 	if (gel->len == 0)
-		return fz_empty_bbox;
-	bbox.x0 = fz_idiv(gel->bbox.x0, fz_aa_hscale);
-	bbox.y0 = fz_idiv(gel->bbox.y0, fz_aa_vscale);
-	bbox.x1 = fz_idiv(gel->bbox.x1, fz_aa_hscale) + 1;
-	bbox.y1 = fz_idiv(gel->bbox.y1, fz_aa_vscale) + 1;
+	{
+		*bbox = fz_empty_bbox;
+	}
+	else
+	{
+		bbox->x0 = fz_idiv(gel->bbox.x0, fz_aa_hscale);
+		bbox->y0 = fz_idiv(gel->bbox.y0, fz_aa_vscale);
+		bbox->x1 = fz_idiv(gel->bbox.x1, fz_aa_hscale) + 1;
+		bbox->y1 = fz_idiv(gel->bbox.y1, fz_aa_vscale) + 1;
+	}
 	return bbox;
 }
 
@@ -666,7 +670,7 @@ static inline void blit_aa(fz_pixmap *dst, int x, int y,
 }
 
 static void
-fz_scan_convert_aa(fz_gel *gel, int eofill, fz_bbox clip,
+fz_scan_convert_aa(fz_gel *gel, int eofill, const fz_bbox *clip,
 	fz_pixmap *dst, unsigned char *color)
 {
 	unsigned char *alphas;
@@ -682,14 +686,14 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, fz_bbox clip,
 
 	int xofs = xmin * fz_aa_hscale;
 
-	int skipx = clip.x0 - xmin;
-	int clipn = clip.x1 - clip.x0;
+	int skipx = clip->x0 - xmin;
+	int clipn = clip->x1 - clip->x0;
 
 	if (gel->len == 0)
 		return;
 
-	assert(clip.x0 >= xmin);
-	assert(clip.x1 <= xmax);
+	assert(clip->x0 >= xmin);
+	assert(clip->x1 <= xmax);
 
 	alphas = fz_malloc_no_throw(ctx, xmax - xmin + 1);
 	deltas = fz_malloc_no_throw(ctx, (xmax - xmin + 1) * sizeof(int));
@@ -719,7 +723,7 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, fz_bbox clip,
 	yd = fz_idiv(y, fz_aa_vscale);
 
 	/* Quickly skip to the start of the clip region */
-	while (yd < clip.y0 && (gel->alen > 0 || e < gel->len))
+	while (yd < clip->y0 && (gel->alen > 0 || e < gel->len))
 	{
 		/* rh = remaining height = number of subscanlines left to be
 		 * inserted into the current scanline, which will be plotted
@@ -738,14 +742,14 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, fz_bbox clip,
 			yd++;
 		}
 		/* Skip any whole scanlines we can */
-		while (yd < clip.y0 && h0 >= fz_aa_vscale)
+		while (yd < clip->y0 && h0 >= fz_aa_vscale)
 		{
 			h0 -= fz_aa_vscale;
 			yd++;
 		}
 		/* If we haven't hit the start of the clip region, then we
 		 * have less than a scanline left. */
-		if (yd < clip.y0)
+		if (yd < clip->y0)
 		{
 			h0 = 0;
 		}
@@ -770,7 +774,7 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, fz_bbox clip,
 			memset(deltas, 0, (skipx + clipn) * sizeof(int));
 		}
 		yd = yc;
-		if (yd >= clip.y1)
+		if (yd >= clip->y1)
 			break;
 
 		/* height = The number of subscanlines with identical edge
@@ -792,7 +796,7 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, fz_bbox clip,
 				blit_aa(dst, xmin + skipx, yd, alphas + skipx, clipn, color);
 				memset(deltas, 0, (skipx + clipn) * sizeof(int));
 				yd++;
-				if (yd >= clip.y1)
+				if (yd >= clip->y1)
 					break;
 				h0 -= rh;
 			}
@@ -812,7 +816,7 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, fz_bbox clip,
 					 * to recalculate deltas here. */
 					blit_aa(dst, xmin + skipx, yd, alphas + skipx, clipn, color);
 					yd++;
-					if (yd >= clip.y1)
+					if (yd >= clip->y1)
 						goto clip_ended;
 					h0 -= fz_aa_vscale;
 				}
@@ -836,7 +840,7 @@ advance:
 		y += height;
 	}
 
-	if (yd < clip.y1)
+	if (yd < clip->y1)
 	{
 		undelta_aa(ctxaa, alphas, deltas, skipx + clipn);
 		blit_aa(dst, xmin + skipx, yd, alphas + skipx, clipn, color);
@@ -851,7 +855,7 @@ clip_ended:
  */
 
 static inline void blit_sharp(int x0, int x1, int y,
-	fz_bbox clip, fz_pixmap *dst, unsigned char *color)
+	const fz_bbox *clip, fz_pixmap *dst, unsigned char *color)
 {
 	unsigned char *dp;
 	x0 = fz_clampi(x0, dst->x, dst->x + dst->w);
@@ -867,7 +871,7 @@ static inline void blit_sharp(int x0, int x1, int y,
 }
 
 static inline void non_zero_winding_sharp(fz_gel *gel, int y,
-	fz_bbox clip, fz_pixmap *dst, unsigned char *color)
+	const fz_bbox *clip, fz_pixmap *dst, unsigned char *color)
 {
 	int winding = 0;
 	int x = 0;
@@ -883,7 +887,7 @@ static inline void non_zero_winding_sharp(fz_gel *gel, int y,
 }
 
 static inline void even_odd_sharp(fz_gel *gel, int y,
-	fz_bbox clip, fz_pixmap *dst, unsigned char *color)
+	const fz_bbox *clip, fz_pixmap *dst, unsigned char *color)
 {
 	int even = 0;
 	int x = 0;
@@ -899,7 +903,7 @@ static inline void even_odd_sharp(fz_gel *gel, int y,
 }
 
 static void
-fz_scan_convert_sharp(fz_gel *gel, int eofill, fz_bbox clip,
+fz_scan_convert_sharp(fz_gel *gel, int eofill, const fz_bbox *clip,
 	fz_pixmap *dst, unsigned char *color)
 {
 	int e = 0;
@@ -909,16 +913,16 @@ fz_scan_convert_sharp(fz_gel *gel, int eofill, fz_bbox clip,
 	gel->alen = 0;
 
 	/* Skip any lines before the clip region */
-	if (y < clip.y0)
+	if (y < clip->y0)
 	{
 		while (gel->alen > 0 || e < gel->len)
 		{
 			height = insert_active(gel, y, &e);
 			y += height;
-			if (y >= clip.y0)
+			if (y >= clip->y0)
 			{
-				height -= y - clip.y0;
-				y = clip.y0;
+				height -= y - clip->y0;
+				y = clip->y0;
 				break;
 			}
 		}
@@ -934,8 +938,8 @@ fz_scan_convert_sharp(fz_gel *gel, int eofill, fz_bbox clip,
 		else
 		{
 			int h;
-			if (height >= clip.y1 - y)
-				height = clip.y1 - y;
+			if (height >= clip->y1 - y)
+				height = clip->y1 - y;
 
 			h = height;
 			while (h--)
@@ -947,7 +951,7 @@ fz_scan_convert_sharp(fz_gel *gel, int eofill, fz_bbox clip,
 				y++;
 			}
 		}
-		if (y >= clip.y1)
+		if (y >= clip->y1)
 			break;
 
 		advance_active(gel, height);
@@ -955,7 +959,7 @@ fz_scan_convert_sharp(fz_gel *gel, int eofill, fz_bbox clip,
 }
 
 void
-fz_scan_convert(fz_gel *gel, int eofill, fz_bbox clip,
+fz_scan_convert(fz_gel *gel, int eofill, const fz_bbox *clip,
 	fz_pixmap *dst, unsigned char *color)
 {
 	fz_aa_context *ctxaa = gel->ctx->aa;
diff --git a/draw/draw_glyph.c b/draw/draw_glyph.c
index de2f47c2..3ad2f10f 100644
--- a/draw/draw_glyph.c
+++ b/draw/draw_glyph.c
@@ -95,7 +95,7 @@ fz_keep_glyph_cache(fz_context *ctx)
 }
 
 fz_pixmap *
-fz_render_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz_stroke_state *stroke, fz_bbox scissor)
+fz_render_stroked_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm, const fz_matrix *ctm, fz_stroke_state *stroke, fz_bbox scissor)
 {
 	if (font->ft_face)
 	{
@@ -116,13 +116,14 @@ fz_render_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm,
 		This must not be inserted into the cache.
  */
 fz_pixmap *
-fz_render_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix ctm, fz_colorspace *model, fz_bbox scissor)
+fz_render_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *ctm, fz_colorspace *model, fz_bbox scissor)
 {
 	fz_glyph_cache *cache;
 	fz_glyph_key key;
 	fz_pixmap *val;
 	float size = fz_matrix_expansion(ctm);
 	int do_cache;
+	fz_matrix local_ctm = *ctm;
 
 	if (size <= MAX_GLYPH_SIZE)
 	{
@@ -141,16 +142,16 @@ fz_render_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix ctm, fz_color
 	memset(&key, 0, sizeof key);
 	key.font = font;
 	key.gid = gid;
-	key.a = ctm.a * 65536;
-	key.b = ctm.b * 65536;
-	key.c = ctm.c * 65536;
-	key.d = ctm.d * 65536;
-	key.e = (ctm.e - floorf(ctm.e)) * 256;
-	key.f = (ctm.f - floorf(ctm.f)) * 256;
+	key.a = local_ctm.a * 65536;
+	key.b = local_ctm.b * 65536;
+	key.c = local_ctm.c * 65536;
+	key.d = local_ctm.d * 65536;
+	key.e = (local_ctm.e - floorf(local_ctm.e)) * 256;
+	key.f = (local_ctm.f - floorf(local_ctm.f)) * 256;
 	key.aa = fz_aa_level(ctx);
 
-	ctm.e = floorf(ctm.e) + key.e / 256.0f;
-	ctm.f = floorf(ctm.f) + key.f / 256.0f;
+	local_ctm.e = floorf(local_ctm.e) + key.e / 256.0f;
+	local_ctm.f = floorf(local_ctm.f) + key.f / 256.0f;
 
 	fz_lock(ctx, FZ_LOCK_GLYPHCACHE);
 	val = fz_hash_find(ctx, cache->hash, &key);
@@ -165,7 +166,7 @@ fz_render_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix ctm, fz_color
 	{
 		if (font->ft_face)
 		{
-			val = fz_render_ft_glyph(ctx, font, gid, ctm, key.aa);
+			val = fz_render_ft_glyph(ctx, font, gid, &local_ctm, key.aa);
 		}
 		else if (font->t3procs)
 		{
@@ -179,7 +180,7 @@ fz_render_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix ctm, fz_color
 			 * abandon ours, and use the one there already.
 			 */
 			fz_unlock(ctx, FZ_LOCK_GLYPHCACHE);
-			val = fz_render_t3_glyph(ctx, font, gid, ctm, model, scissor);
+			val = fz_render_t3_glyph(ctx, font, gid, &local_ctm, model, scissor);
 			fz_lock(ctx, FZ_LOCK_GLYPHCACHE);
 		}
 		else
diff --git a/draw/draw_mesh.c b/draw/draw_mesh.c
index 03d187f7..343e9302 100644
--- a/draw/draw_mesh.c
+++ b/draw/draw_mesh.c
@@ -213,14 +213,14 @@ static inline void step_edge(int *ael, int *del, int n)
 }
 
 static void
-fz_paint_triangle(fz_pixmap *pix, float *av, float *bv, float *cv, int n, fz_bbox bbox)
+fz_paint_triangle(fz_pixmap *pix, float *av, float *bv, float *cv, int n, const fz_bbox *bbox)
 {
 	float poly[MAXV][MAXN];
 	float temp[MAXV][MAXN];
-	float cx0 = bbox.x0;
-	float cy0 = bbox.y0;
-	float cx1 = bbox.x1;
-	float cy1 = bbox.y1;
+	float cx0 = bbox->x0;
+	float cy0 = bbox->y0;
+	float cx1 = bbox->x1;
+	float cy1 = bbox->y1;
 
 	int gel[MAXV][MAXN];
 	int ael[2][MAXN];
@@ -307,7 +307,7 @@ struct paint_tri_data
 	fz_context *ctx;
 	fz_shade *shade;
 	fz_pixmap *dest;
-	fz_bbox bbox;
+	const fz_bbox *bbox;
 };
 
 static void
@@ -349,7 +349,7 @@ do_paint_tri(void *arg, fz_vertex *av, fz_vertex *bv, fz_vertex *cv)
 }
 
 void
-fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox)
+fz_paint_shade(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_pixmap *dest, const fz_bbox *bbox)
 {
 	unsigned char clut[256][FZ_MAX_COLORS];
 	fz_pixmap *temp = NULL;
@@ -357,13 +357,14 @@ fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_pixmap *dest,
 	float color[FZ_MAX_COLORS];
 	struct paint_tri_data ptd;
 	int i, k;
+	fz_matrix local_ctm;
 
 	fz_var(temp);
 	fz_var(conv);
 
 	fz_try(ctx)
 	{
-		ctm = fz_concat(shade->matrix, ctm);
+		fz_concat(&local_ctm, &shade->matrix, ctm);
 
 		if (shade->use_function)
 		{
@@ -390,7 +391,7 @@ fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_pixmap *dest,
 		ptd.shade = shade;
 		ptd.bbox = bbox;
 
-		fz_process_mesh(ctx, shade, ctm, &do_paint_tri, &ptd);
+		fz_process_mesh(ctx, shade, &local_ctm, &do_paint_tri, &ptd);
 
 		if (shade->use_function)
 		{
diff --git a/draw/draw_paint.c b/draw/draw_paint.c
index 4c99dc7d..2862b892 100644
--- a/draw/draw_paint.c
+++ b/draw/draw_paint.c
@@ -379,11 +379,14 @@ fz_paint_pixmap_with_bbox(fz_pixmap *dst, fz_pixmap *src, int alpha, fz_bbox bbo
 {
 	unsigned char *sp, *dp;
 	int x, y, w, h, n;
+	fz_bbox bbox2;
 
 	assert(dst->n == src->n);
 
-	bbox = fz_intersect_bbox(bbox, fz_pixmap_bbox_no_ctx(dst));
-	bbox = fz_intersect_bbox(bbox, fz_pixmap_bbox_no_ctx(src));
+	fz_pixmap_bbox_no_ctx(dst, &bbox2);
+	fz_intersect_bbox(&bbox, &bbox2);
+	fz_pixmap_bbox_no_ctx(src, &bbox2);
+	fz_intersect_bbox(&bbox, &bbox2);
 
 	x = bbox.x0;
 	y = bbox.y0;
@@ -409,12 +412,14 @@ fz_paint_pixmap(fz_pixmap *dst, fz_pixmap *src, int alpha)
 {
 	unsigned char *sp, *dp;
 	fz_bbox bbox;
+	fz_bbox bbox2;
 	int x, y, w, h, n;
 
 	assert(dst->n == src->n);
 
-	bbox = fz_pixmap_bbox_no_ctx(dst);
-	bbox = fz_intersect_bbox(bbox, fz_pixmap_bbox_no_ctx(src));
+	fz_pixmap_bbox_no_ctx(dst, &bbox);
+	fz_pixmap_bbox_no_ctx(src, &bbox2);
+	fz_intersect_bbox(&bbox, &bbox2);
 
 	x = bbox.x0;
 	y = bbox.y0;
@@ -439,15 +444,17 @@ void
 fz_paint_pixmap_with_mask(fz_pixmap *dst, fz_pixmap *src, fz_pixmap *msk)
 {
 	unsigned char *sp, *dp, *mp;
-	fz_bbox bbox;
+	fz_bbox bbox, bbox2;
 	int x, y, w, h, n;
 
 	assert(dst->n == src->n);
 	assert(msk->n == 1);
 
-	bbox = fz_pixmap_bbox_no_ctx(dst);
-	bbox = fz_intersect_bbox(bbox, fz_pixmap_bbox_no_ctx(src));
-	bbox = fz_intersect_bbox(bbox, fz_pixmap_bbox_no_ctx(msk));
+	fz_pixmap_bbox_no_ctx(dst, &bbox);
+	fz_pixmap_bbox_no_ctx(src, &bbox2);
+	fz_intersect_bbox(&bbox, &bbox2);
+	fz_pixmap_bbox_no_ctx(msk, &bbox2);
+	fz_intersect_bbox(&bbox, &bbox2);
 
 	x = bbox.x0;
 	y = bbox.y0;
diff --git a/draw/draw_path.c b/draw/draw_path.c
index 9996c182..2a0c20ab 100644
--- a/draw/draw_path.c
+++ b/draw/draw_path.c
@@ -3,7 +3,7 @@
 #define MAX_DEPTH 8
 
 static void
-line(fz_gel *gel, fz_matrix *ctm, float x0, float y0, float x1, float y1)
+line(fz_gel *gel, const fz_matrix *ctm, float x0, float y0, float x1, float y1)
 {
 	float tx0 = ctm->a * x0 + ctm->c * y0 + ctm->e;
 	float ty0 = ctm->b * x0 + ctm->d * y0 + ctm->f;
@@ -13,7 +13,7 @@ line(fz_gel *gel, fz_matrix *ctm, float x0, float y0, float x1, float y1)
 }
 
 static void
-bezier(fz_gel *gel, fz_matrix *ctm, float flatness,
+bezier(fz_gel *gel, const fz_matrix *ctm, float flatness,
 	float xa, float ya,
 	float xb, float yb,
 	float xc, float yc,
@@ -67,7 +67,7 @@ bezier(fz_gel *gel, fz_matrix *ctm, float flatness,
 }
 
 void
-fz_flatten_fill_path(fz_gel *gel, fz_path *path, fz_matrix ctm, float flatness)
+fz_flatten_fill_path(fz_gel *gel, fz_path *path, const fz_matrix *ctm, float flatness)
 {
 	float x1, y1, x2, y2, x3, y3;
 	float cx = 0;
@@ -83,7 +83,7 @@ fz_flatten_fill_path(fz_gel *gel, fz_path *path, fz_matrix ctm, float flatness)
 		case FZ_MOVETO:
 			/* implicit closepath before moveto */
 			if (cx != bx || cy != by)
-				line(gel, &ctm, cx, cy, bx, by);
+				line(gel, ctm, cx, cy, bx, by);
 			x1 = path->items[i++].v;
 			y1 = path->items[i++].v;
 			cx = bx = x1;
@@ -93,7 +93,7 @@ fz_flatten_fill_path(fz_gel *gel, fz_path *path, fz_matrix ctm, float flatness)
 		case FZ_LINETO:
 			x1 = path->items[i++].v;
 			y1 = path->items[i++].v;
-			line(gel, &ctm, cx, cy, x1, y1);
+			line(gel, ctm, cx, cy, x1, y1);
 			cx = x1;
 			cy = y1;
 			break;
@@ -105,13 +105,13 @@ fz_flatten_fill_path(fz_gel *gel, fz_path *path, fz_matrix ctm, float flatness)
 			y2 = path->items[i++].v;
 			x3 = path->items[i++].v;
 			y3 = path->items[i++].v;
-			bezier(gel, &ctm, flatness, cx, cy, x1, y1, x2, y2, x3, y3, 0);
+			bezier(gel, ctm, flatness, cx, cy, x1, y1, x2, y2, x3, y3, 0);
 			cx = x3;
 			cy = y3;
 			break;
 
 		case FZ_CLOSE_PATH:
-			line(gel, &ctm, cx, cy, bx, by);
+			line(gel, ctm, cx, cy, bx, by);
 			cx = bx;
 			cy = by;
 			break;
@@ -119,13 +119,13 @@ fz_flatten_fill_path(fz_gel *gel, fz_path *path, fz_matrix ctm, float flatness)
 	}
 
 	if (cx != bx || cy != by)
-		line(gel, &ctm, cx, cy, bx, by);
+		line(gel, ctm, cx, cy, bx, by);
 }
 
 struct sctx
 {
 	fz_gel *gel;
-	fz_matrix *ctm;
+	const fz_matrix *ctm;
 	float flatness;
 
 	int linejoin;
@@ -541,14 +541,14 @@ fz_stroke_bezier(struct sctx *s,
 }
 
 void
-fz_flatten_stroke_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm, float flatness, float linewidth)
+fz_flatten_stroke_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, float flatness, float linewidth)
 {
 	struct sctx s;
 	fz_point p0, p1, p2, p3;
 	int i;
 
 	s.gel = gel;
-	s.ctm = &ctm;
+	s.ctm = ctm;
 	s.flatness = flatness;
 
 	s.linejoin = stroke->linejoin;
@@ -747,7 +747,7 @@ fz_dash_bezier(struct sctx *s,
 }
 
 void
-fz_flatten_dash_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm, float flatness, float linewidth)
+fz_flatten_dash_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, float flatness, float linewidth)
 {
 	struct sctx s;
 	fz_point p0, p1, p2, p3, beg;
@@ -755,7 +755,7 @@ fz_flatten_dash_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, fz_mat
 	int i;
 
 	s.gel = gel;
-	s.ctm = &ctm;
+	s.ctm = ctm;
 	s.flatness = flatness;
 
 	s.linejoin = stroke->linejoin;
@@ -780,7 +780,7 @@ fz_flatten_dash_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, fz_mat
 	phase_len = 0;
 	for (i = 0; i < stroke->dash_len; i++)
 		phase_len += stroke->dash_list[i];
-	max_expand = fz_max(fz_max(fz_abs(ctm.a),fz_abs(ctm.b)),fz_max(fz_abs(ctm.c),fz_abs(ctm.d)));
+	max_expand = fz_matrix_max_expansion(ctm);
 	if (phase_len < 0.01f || phase_len * max_expand < 0.5f)
 	{
 		fz_flatten_stroke_path(gel, path, stroke, ctm, flatness, linewidth);
diff --git a/draw/draw_scale.c b/draw/draw_scale.c
index 93d2219a..e20cc46d 100644
--- a/draw/draw_scale.c
+++ b/draw/draw_scale.c
@@ -1244,7 +1244,7 @@ fz_scale_pixmap(fz_context *ctx, fz_pixmap *src, float x, float y, float w, floa
 }
 
 fz_pixmap *
-fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_bbox *clip, fz_scale_cache *cache_x, fz_scale_cache *cache_y)
+fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, const fz_bbox *clip, fz_scale_cache *cache_x, fz_scale_cache *cache_y)
 {
 	fz_scale_filter *filter = &fz_scale_filter_simple;
 	fz_weights *contrib_rows = NULL;
diff --git a/draw/draw_simple_scale.c b/draw/draw_simple_scale.c
index 0096d93d..d624aa57 100644
--- a/draw/draw_simple_scale.c
+++ b/draw/draw_simple_scale.c
@@ -1220,7 +1220,7 @@ fz_scale_pixmap(fz_context *ctx, fz_pixmap *src, float x, float y, float w, floa
 }
 
 fz_pixmap *
-fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_bbox *clip, fz_scale_cache *cache_x, fz_scale_cache *cache_y)
+fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, const fz_bbox *clip, fz_scale_cache *cache_x, fz_scale_cache *cache_y)
 {
 	fz_scale_filter *filter = &fz_scale_filter_simple;
 	fz_weights *contrib_rows = NULL;
diff --git a/fitz/base_geometry.c b/fitz/base_geometry.c
index 9fc29217..8b9cf4c8 100644
--- a/fitz/base_geometry.c
+++ b/fitz/base_geometry.c
@@ -25,43 +25,63 @@
 
 const fz_matrix fz_identity = { 1, 0, 0, 1, 0, 0 };
 
-fz_matrix
-fz_concat(fz_matrix one, fz_matrix two)
+fz_matrix *
+fz_concat(fz_matrix *dst, const fz_matrix *one, const fz_matrix *two)
 {
-	fz_matrix dst;
-	dst.a = one.a * two.a + one.b * two.c;
-	dst.b = one.a * two.b + one.b * two.d;
-	dst.c = one.c * two.a + one.d * two.c;
-	dst.d = one.c * two.b + one.d * two.d;
-	dst.e = one.e * two.a + one.f * two.c + two.e;
-	dst.f = one.e * two.b + one.f * two.d + two.f;
+	fz_matrix dst2;
+	dst2.a = one->a * two->a + one->b * two->c;
+	dst2.b = one->a * two->b + one->b * two->d;
+	dst2.c = one->c * two->a + one->d * two->c;
+	dst2.d = one->c * two->b + one->d * two->d;
+	dst2.e = one->e * two->a + one->f * two->c + two->e;
+	dst2.f = one->e * two->b + one->f * two->d + two->f;
+	*dst = dst2;
 	return dst;
 }
 
-fz_matrix
-fz_scale(float sx, float sy)
+fz_matrix *
+fz_scale(fz_matrix *m, float sx, float sy)
 {
-	fz_matrix m;
-	m.a = sx; m.b = 0;
-	m.c = 0; m.d = sy;
-	m.e = 0; m.f = 0;
+	m->a = sx; m->b = 0;
+	m->c = 0; m->d = sy;
+	m->e = 0; m->f = 0;
 	return m;
 }
 
-fz_matrix
-fz_shear(float h, float v)
+fz_matrix *
+fz_pre_scale(fz_matrix *mat, float sx, float sy)
 {
-	fz_matrix m;
-	m.a = 1; m.b = v;
-	m.c = h; m.d = 1;
-	m.e = 0; m.f = 0;
-	return m;
+	mat->a *= sx;
+	mat->b *= sx;
+	mat->c *= sy;
+	mat->d *= sy;
+	return mat;
+}
+
+fz_matrix *
+fz_shear(fz_matrix *mat, float h, float v)
+{
+	mat->a = 1; mat->b = v;
+	mat->c = h; mat->d = 1;
+	mat->e = 0; mat->f = 0;
+	return mat;
+}
+
+fz_matrix *
+fz_pre_shear(fz_matrix *mat, float h, float v)
+{
+	float a = mat->a;
+	float b = mat->b;
+	mat->a += v * mat->c;
+	mat->b += v * mat->d;
+	mat->c += h * a;
+	mat->d += h * b;
+	return mat;
 }
 
-fz_matrix
-fz_rotate(float theta)
+fz_matrix *
+fz_rotate(fz_matrix *m, float theta)
 {
-	fz_matrix m;
 	float s;
 	float c;
 
@@ -96,86 +116,148 @@ fz_rotate(float theta)
 		c = cosf(theta * (float)M_PI / 180);
 	}
 
-	m.a = c; m.b = s;
-	m.c = -s; m.d = c;
-	m.e = 0; m.f = 0;
+	m->a = c; m->b = s;
+	m->c = -s; m->d = c;
+	m->e = 0; m->f = 0;
+	return m;
+}
+
+fz_matrix *
+fz_pre_rotate(fz_matrix *m, float theta)
+{
+	while (theta < 0)
+		theta += 360;
+	while (theta >= 360)
+		theta -= 360;
+
+	if (fabsf(0 - theta) < FLT_EPSILON)
+	{
+		/* Nothing to do */
+	}
+	else if (fabsf(90.0f - theta) < FLT_EPSILON)
+	{
+		float a = m->a;
+		float b = m->b;
+		m->a = m->c;
+		m->b = m->d;
+		m->c = -a;
+		m->d = -b;
+	}
+	else if (fabsf(180.0f - theta) < FLT_EPSILON)
+	{
+		m->a = -m->a;
+		m->b = -m->b;
+		m->c = -m->c;
+		m->d = -m->d;
+	}
+	else if (fabsf(270.0f - theta) < FLT_EPSILON)
+	{
+		float a = m->a;
+		float b = m->b;
+		m->a = -m->c;
+		m->b = -m->d;
+		m->c = a;
+		m->d = b;
+	}
+	else
+	{
+		float s = sinf(theta * (float)M_PI / 180);
+		float c = cosf(theta * (float)M_PI / 180);
+		float a = m->a;
+		float b = m->b;
+		m->a = c * a + s * m->c;
+		m->b = c * b + s * m->d;
+		m->c =-s * a + c * m->c;
+		m->d =-s * b + c * m->d;
+	}
+
 	return m;
 }
 
-fz_matrix
-fz_translate(float tx, float ty)
+fz_matrix *
+fz_translate(fz_matrix *m, float tx, float ty)
 {
-	fz_matrix m;
-	m.a = 1; m.b = 0;
-	m.c = 0; m.d = 1;
-	m.e = tx; m.f = ty;
+	m->a = 1; m->b = 0;
+	m->c = 0; m->d = 1;
+	m->e = tx; m->f = ty;
 	return m;
 }
 
-fz_matrix
-fz_invert_matrix(fz_matrix src)
+fz_matrix *
+fz_pre_translate(fz_matrix *mat, float tx, float ty)
 {
-	float det = src.a * src.d - src.b * src.c;
+	mat->e += tx * mat->a + ty * mat->c;
+	mat->f += tx * mat->b + ty * mat->d;
+	return mat;
+}
+
+fz_matrix *
+fz_invert_matrix(fz_matrix *dst, const fz_matrix *src)
+{
+	/* Be careful to cope with dst == src */
+	float a = src->a;
+	float det = a * src->d - src->b * src->c;
 	if (det < -FLT_EPSILON || det > FLT_EPSILON)
 	{
-		fz_matrix dst;
 		float rdet = 1 / det;
-		dst.a = src.d * rdet;
-		dst.b = -src.b * rdet;
-		dst.c = -src.c * rdet;
-		dst.d = src.a * rdet;
-		dst.e = -src.e * dst.a - src.f * dst.c;
-		dst.f = -src.e * dst.b - src.f * dst.d;
-		return dst;
+		dst->a = src->d * rdet;
+		dst->b = -src->b * rdet;
+		dst->c = -src->c * rdet;
+		dst->d = a * rdet;
+		a = -src->e * dst->a - src->f * dst->c;
+		dst->f = -src->e * dst->b - src->f * dst->d;
+		dst->e = a;
 	}
-	return src;
+	else
+		*dst = *src;
+	return dst;
 }
 
 int
-fz_is_rectilinear(fz_matrix m)
+fz_is_rectilinear(const fz_matrix *m)
 {
-	return (fabsf(m.b) < FLT_EPSILON && fabsf(m.c) < FLT_EPSILON) ||
-		(fabsf(m.a) < FLT_EPSILON && fabsf(m.d) < FLT_EPSILON);
+	return (fabsf(m->b) < FLT_EPSILON && fabsf(m->c) < FLT_EPSILON) ||
+		(fabsf(m->a) < FLT_EPSILON && fabsf(m->d) < FLT_EPSILON);
 }
 
 float
-fz_matrix_expansion(fz_matrix m)
+fz_matrix_expansion(const fz_matrix *m)
 {
-	return sqrtf(fabsf(m.a * m.d - m.b * m.c));
+	return sqrtf(fabsf(m->a * m->d - m->b * m->c));
 }
 
 float
-fz_matrix_max_expansion(fz_matrix m)
+fz_matrix_max_expansion(const fz_matrix *m)
 {
-	float max = fabsf(m.a);
-	float x = fabsf(m.b);
+	float max = fabsf(m->a);
+	float x = fabsf(m->b);
 	if (max < x)
 		max = x;
-	x = fabsf(m.c);
+	x = fabsf(m->c);
 	if (max < x)
 		max = x;
-	x = fabsf(m.d);
+	x = fabsf(m->d);
 	if (max < x)
 		max = x;
 	return max;
 }
 
-fz_point
-fz_transform_point(fz_matrix m, fz_point p)
+fz_point *
+fz_transform_point(fz_point *p, const fz_matrix *m)
 {
-	fz_point t;
-	t.x = p.x * m.a + p.y * m.c + m.e;
-	t.y = p.x * m.b + p.y * m.d + m.f;
-	return t;
+	float x = p->x;
+	p->x = x * m->a + p->y * m->c + m->e;
+	p->y = x * m->b + p->y * m->d + m->f;
+	return p;
 }
 
-fz_point
-fz_transform_vector(fz_matrix m, fz_point p)
+fz_point *
+fz_transform_vector(fz_point *p, const fz_matrix *m)
 {
-	fz_point t;
-	t.x = p.x * m.a + p.y * m.c;
-	t.y = p.x * m.b + p.y * m.d;
-	return t;
+	float x = p->x;
+	p->x = x * m->a + p->y * m->c;
+	p->y = x * m->b + p->y * m->d;
+	return p;
 }
 
 /* Rectangles and bounding boxes */
@@ -192,161 +274,195 @@ const fz_bbox fz_infinite_bbox = { 1, 1, -1, -1 };
 const fz_bbox fz_empty_bbox = { 0, 0, 0, 0 };
 const fz_bbox fz_unit_bbox = { 0, 0, 1, 1 };
 
-fz_bbox
-fz_bbox_from_rect(fz_rect a)
+fz_bbox *
+fz_bbox_from_rect(fz_bbox *b, const fz_rect *r)
 {
-	fz_bbox b;
-
-	a.x0 = floorf(a.x0);
-	a.y0 = floorf(a.y0);
-	a.x1 = ceilf(a.x1);
-	a.y1 = ceilf(a.y1);
+	int i;
 
-	/* check for integer overflow */
-	b.x0 = fz_clamp(a.x0, MIN_SAFE_INT, MAX_SAFE_INT);
-	b.y0 = fz_clamp(a.y0, MIN_SAFE_INT, MAX_SAFE_INT);
-	b.x1 = fz_clamp(a.x1, MIN_SAFE_INT, MAX_SAFE_INT);
-	b.y1 = fz_clamp(a.y1, MIN_SAFE_INT, MAX_SAFE_INT);
+	i = floorf(r->x0);
+	b->x0 = fz_clamp(i, MIN_SAFE_INT, MAX_SAFE_INT);
+	i = floorf(r->y0);
+	b->y0 = fz_clamp(i, MIN_SAFE_INT, MAX_SAFE_INT);
+	i = ceilf(r->x1);
+	b->x1 = fz_clamp(i, MIN_SAFE_INT, MAX_SAFE_INT);
+	i = ceilf(r->y1);
+	b->y1 = fz_clamp(i, MIN_SAFE_INT, MAX_SAFE_INT);
 
 	return b;
 }
 
-fz_rect
-fz_rect_from_bbox(fz_bbox a)
+fz_rect *
+fz_rect_from_bbox(fz_rect *r, const fz_bbox *a)
 {
-	fz_rect b;
-	b.x0 = a.x0;
-	b.y0 = a.y0;
-	b.x1 = a.x1;
-	b.y1 = a.y1;
-	return b;
+	r->x0 = a->x0;
+	r->y0 = a->y0;
+	r->x1 = a->x1;
+	r->y1 = a->y1;
+	return r;
 }
 
-fz_bbox
-fz_round_rect(fz_rect a)
+fz_bbox *
+fz_round_rect(fz_bbox *b, const fz_rect *r)
 {
-	fz_bbox b;
-
-	a.x0 = floorf(a.x0 + 0.001);
-	a.y0 = floorf(a.y0 + 0.001);
-	a.x1 = ceilf(a.x1 - 0.001);
-	a.y1 = ceilf(a.y1 - 0.001);
+	int i;
 
-	/* check for integer overflow */
-	b.x0 = fz_clamp(a.x0, MIN_SAFE_INT, MAX_SAFE_INT);
-	b.y0 = fz_clamp(a.y0, MIN_SAFE_INT, MAX_SAFE_INT);
-	b.x1 = fz_clamp(a.x1, MIN_SAFE_INT, MAX_SAFE_INT);
-	b.y1 = fz_clamp(a.y1, MIN_SAFE_INT, MAX_SAFE_INT);
+	i = floorf(r->x0 + 0.001);
+	b->x0 = fz_clamp(i, MIN_SAFE_INT, MAX_SAFE_INT);
+	i = floorf(r->y0 + 0.001);
+	b->y0 = fz_clamp(i, MIN_SAFE_INT, MAX_SAFE_INT);
+	i = ceilf(r->x1 - 0.001);
+	b->x1 = fz_clamp(i, MIN_SAFE_INT, MAX_SAFE_INT);
+	i = ceilf(r->y1 - 0.001);
+	b->y1 = fz_clamp(i, MIN_SAFE_INT, MAX_SAFE_INT);
 
 	return b;
 }
 
-fz_rect
-fz_intersect_rect(fz_rect a, fz_rect b)
+fz_rect *
+fz_intersect_rect(fz_rect *a, const fz_rect *b)
 {
-	fz_rect r;
 	/* Check for empty box before infinite box */
-	if (fz_is_empty_rect(a)) return fz_empty_rect;
-	if (fz_is_empty_rect(b)) return fz_empty_rect;
-	if (fz_is_infinite_rect(a)) return b;
+	if (fz_is_empty_rect(a)) return a;
+	if (fz_is_empty_rect(b)) {
+		*a = fz_empty_rect;
+		return a;
+	}
 	if (fz_is_infinite_rect(b)) return a;
-	r.x0 = fz_max(a.x0, b.x0);
-	r.y0 = fz_max(a.y0, b.y0);
-	r.x1 = fz_min(a.x1, b.x1);
-	r.y1 = fz_min(a.y1, b.y1);
-	return (r.x1 < r.x0 || r.y1 < r.y0) ? fz_empty_rect : r;
+	if (fz_is_infinite_rect(a)) {
+		*a = *b;
+		return a;
+	}
+	if (a->x0 < b->x0)
+		a->x0 = b->x0;
+	if (a->y0 < b->y0)
+		a->y0 = b->y0;
+	if (a->x1 > b->x1)
+		a->x1 = b->x1;
+	if (a->y1 > b->y1)
+		a->y1 = b->y1;
+	if (a->x1 < a->x0 || a->y1 < a->y0)
+		*a = fz_empty_rect;
+	return a;
 }
 
-fz_bbox
-fz_intersect_bbox(fz_bbox a, fz_bbox b)
+fz_bbox *
+fz_intersect_bbox(fz_bbox *a, const fz_bbox *b)
 {
-	fz_bbox r;
 	/* Check for empty box before infinite box */
-	if (fz_is_empty_rect(a)) return fz_empty_bbox;
-	if (fz_is_empty_rect(b)) return fz_empty_bbox;
-	if (fz_is_infinite_rect(a)) return b;
+	if (fz_is_empty_rect(a)) return a;
+	if (fz_is_empty_rect(b))
+	{
+		*a = fz_empty_bbox;
+		return a;
+	}
 	if (fz_is_infinite_rect(b)) return a;
-	r.x0 = fz_maxi(a.x0, b.x0);
-	r.y0 = fz_maxi(a.y0, b.y0);
-	r.x1 = fz_mini(a.x1, b.x1);
-	r.y1 = fz_mini(a.y1, b.y1);
-	return (r.x1 < r.x0 || r.y1 < r.y0) ? fz_empty_bbox : r;
+	if (fz_is_infinite_rect(a))
+	{
+		*a = *b;
+		return a;
+	}
+	if (a->x0 < b->x0)
+		a->x0 = b->x0;
+	if (a->y0 < b->y0)
+		a->y0 = b->y0;
+	if (a->x1 > b->x1)
+		a->x1 = b->x1;
+	if (a->y1 > b->y1)
+		a->y1 = b->y1;
+	if (a->x1 < a->x0 || a->y1 < a->y0)
+		*a = fz_empty_bbox;
+	return a;
 }
 
-fz_rect
-fz_union_rect(fz_rect a, fz_rect b)
+fz_rect *
+fz_union_rect(fz_rect *a, const fz_rect *b)
 {
-	fz_rect r;
 	/* Check for empty box before infinite box */
-	if (fz_is_empty_rect(a)) return b;
 	if (fz_is_empty_rect(b)) return a;
+	if (fz_is_empty_rect(a)) {
+		*a = *b;
+		return a;
+	}
 	if (fz_is_infinite_rect(a)) return a;
-	if (fz_is_infinite_rect(b)) return b;
-	r.x0 = fz_min(a.x0, b.x0);
-	r.y0 = fz_min(a.y0, b.y0);
-	r.x1 = fz_max(a.x1, b.x1);
-	r.y1 = fz_max(a.y1, b.y1);
-	return r;
+	if (fz_is_infinite_rect(b)) {
+		*a = *b;
+		return a;
+	}
+	if (a->x0 > b->x0)
+		a->x0 = b->x0;
+	if (a->y0 > b->y0)
+		a->y0 = b->y0;
+	if (a->x1 < b->x1)
+		a->x1 = b->x1;
+	if (a->y1 < b->y1)
+		a->y1 = b->y1;
+	return a;
 }
 
-fz_rect
-fz_transform_rect(fz_matrix m, fz_rect r)
+fz_bbox *
+fz_translate_bbox(fz_bbox *a, int xoff, int yoff)
 {
-	fz_point s, t, u, v;
+	int t;
 
-	if (fz_is_infinite_rect(r))
-		return r;
-
-	s.x = r.x0; s.y = r.y0;
-	t.x = r.x0; t.y = r.y1;
-	u.x = r.x1; u.y = r.y1;
-	v.x = r.x1; v.y = r.y0;
-	s = fz_transform_point(m, s);
-	t = fz_transform_point(m, t);
-	u = fz_transform_point(m, u);
-	v = fz_transform_point(m, v);
-	r.x0 = MIN4(s.x, t.x, u.x, v.x);
-	r.y0 = MIN4(s.y, t.y, u.y, v.y);
-	r.x1 = MAX4(s.x, t.x, u.x, v.x);
-	r.y1 = MAX4(s.y, t.y, u.y, v.y);
-	return r;
-}
-
-fz_rect
-fz_translate_rect(fz_rect a, float xoff, float yoff)
-{
-	fz_rect b;
 	if (fz_is_empty_rect(a)) return a;
 	if (fz_is_infinite_rect(a)) return a;
-	b.x0 = a.x0 + xoff;
-	b.y0 = a.y0 + yoff;
-	b.x1 = a.x1 + xoff;
-	b.y1 = a.y1 + yoff;
-	return b;
+	a->x0 = ADD_WITH_SAT(t, a->x0, xoff);
+	a->y0 = ADD_WITH_SAT(t, a->y0, yoff);
+	a->x1 = ADD_WITH_SAT(t, a->x1, xoff);
+	a->y1 = ADD_WITH_SAT(t, a->y1, yoff);
+	return a;
 }
 
-fz_bbox
-fz_translate_bbox(fz_bbox a, int xoff, int yoff)
+fz_rect *
+fz_transform_rect(fz_rect *r, const fz_matrix *m)
 {
-	fz_bbox b;
-	if (fz_is_empty_rect(a)) return a;
-	if (fz_is_infinite_rect(a)) return a;
-	ADD_WITH_SAT(b.x0, a.x0, xoff);
-	ADD_WITH_SAT(b.y0, a.y0, yoff);
-	ADD_WITH_SAT(b.x1, a.x1, xoff);
-	ADD_WITH_SAT(b.y1, a.y1, yoff);
-	return b;
+	fz_point s, t, u, v;
+
+	if (fz_is_infinite_rect(r))
+		return r;
+
+	if (fabsf(m->b) < FLT_EPSILON && fabsf(m->c) < FLT_EPSILON)
+	{
+		if (m->a < 0)
+		{
+			float f = r->x0;
+			r->x0 = r->x1;
+			r->x1 = f;
+		}
+		if (m->d < 0)
+		{
+			float f = r->y0;
+			r->y0 = r->y1;
+			r->y1 = f;
+		}
+		fz_transform_point(fz_rect_min(r), m);
+		fz_transform_point(fz_rect_max(r), m);
+		return r;
+	}
+
+	s.x = r->x0; s.y = r->y0;
+	t.x = r->x0; t.y = r->y1;
+	u.x = r->x1; u.y = r->y1;
+	v.x = r->x1; v.y = r->y0;
+	fz_transform_point(&s, m);
+	fz_transform_point(&t, m);
+	fz_transform_point(&u, m);
+	fz_transform_point(&v, m);
+	r->x0 = MIN4(s.x, t.x, u.x, v.x);
+	r->y0 = MIN4(s.y, t.y, u.y, v.y);
+	r->x1 = MAX4(s.x, t.x, u.x, v.x);
+	r->y1 = MAX4(s.y, t.y, u.y, v.y);
+	return r;
 }
 
-fz_rect
-fz_expand_rect(fz_rect a, float expand)
+fz_rect *
+fz_expand_rect(fz_rect *a, float expand)
 {
-	fz_rect b;
 	if (fz_is_empty_rect(a)) return a;
 	if (fz_is_infinite_rect(a)) return a;
-	b.x0 = a.x0 - expand;
-	b.y0 = a.y0 - expand;
-	b.x1 = a.x1 + expand;
-	b.y1 = a.y1 + expand;
-	return b;
+	a->x0 -= expand;
+	a->y0 -= expand;
+	a->x1 += expand;
+	a->y1 += expand;
+	return a;
 }
diff --git a/fitz/dev_bbox.c b/fitz/dev_bbox.c
index 6c910afb..14372abe 100644
--- a/fitz/dev_bbox.c
+++ b/fitz/dev_bbox.c
@@ -3,57 +3,64 @@
 /* TODO: add clip stack and use to intersect bboxes */
 
 static void
-fz_bbox_fill_path(fz_device *dev, fz_path *path, int even_odd, fz_matrix ctm,
+fz_bbox_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_rect *result = dev->user;
-	*result = fz_union_rect(*result, fz_bound_path(dev->ctx, path, NULL, ctm));
+	fz_rect r;
+	fz_union_rect(result, fz_bound_path(dev->ctx, path, NULL, ctm, &r));
 }
 
 static void
-fz_bbox_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
-	fz_colorspace *colorspace, float *color, float alpha)
+fz_bbox_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke,
+	const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_rect *result = dev->user;
-	*result = fz_union_rect(*result, fz_bound_path(dev->ctx, path, stroke, ctm));
+	fz_rect r;
+	fz_union_rect(result, fz_bound_path(dev->ctx, path, stroke, ctm, &r));
 }
 
 static void
-fz_bbox_fill_text(fz_device *dev, fz_text *text, fz_matrix ctm,
+fz_bbox_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_rect *result = dev->user;
-	*result = fz_union_rect(*result, fz_bound_text(dev->ctx, text, ctm));
+	fz_rect r;
+	fz_union_rect(result, fz_bound_text(dev->ctx, text, ctm, &r));
 }
 
 static void
-fz_bbox_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
-	fz_colorspace *colorspace, float *color, float alpha)
+fz_bbox_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke,
+	const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_rect *result = dev->user;
-	*result = fz_union_rect(*result, fz_bound_text(dev->ctx, text, ctm));
+	fz_rect r;
+	fz_union_rect(result, fz_bound_text(dev->ctx, text, ctm, &r));
 }
 
 static void
-fz_bbox_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha)
+fz_bbox_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha)
 {
 	fz_rect *result = dev->user;
-	*result = fz_union_rect(*result, fz_bound_shade(dev->ctx, shade, ctm));
+	fz_rect r;
+	fz_union_rect(result, fz_bound_shade(dev->ctx, shade, ctm, &r));
 }
 
 static void
-fz_bbox_fill_image(fz_device *dev, fz_image *image, fz_matrix ctm, float alpha)
+fz_bbox_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha)
 {
 	fz_rect *result = dev->user;
-	*result = fz_union_rect(*result, fz_transform_rect(ctm, fz_unit_rect));
+	fz_rect r = fz_unit_rect;
+	fz_union_rect(result, fz_transform_rect(&r, ctm));
 }
 
 static void
-fz_bbox_fill_image_mask(fz_device *dev, fz_image *image, fz_matrix ctm,
+fz_bbox_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_rect *result = dev->user;
-	*result = fz_union_rect(*result, fz_transform_rect(ctm, fz_unit_rect));
+	fz_rect r = fz_unit_rect;
+	fz_union_rect(result, fz_transform_rect(&r, ctm));
 }
 
 fz_device *
diff --git a/fitz/dev_list.c b/fitz/dev_list.c
index 2e6822e3..68cdf20a 100644
--- a/fitz/dev_list.c
+++ b/fitz/dev_list.c
@@ -65,7 +65,7 @@ struct fz_display_list_s
 enum { ISOLATED = 1, KNOCKOUT = 2 };
 
 static fz_display_node *
-fz_new_display_node(fz_context *ctx, fz_display_command cmd, fz_matrix ctm,
+fz_new_display_node(fz_context *ctx, fz_display_command cmd, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_display_node *node;
@@ -78,7 +78,7 @@ fz_new_display_node(fz_context *ctx, fz_display_command cmd, fz_matrix ctm,
 	node->item.path = NULL;
 	node->stroke = NULL;
 	node->flag = 0;
-	node->ctm = ctm;
+	node->ctm = *ctm;
 	if (colorspace)
 	{
 		node->colorspace = fz_keep_colorspace(ctx, colorspace);
@@ -149,7 +149,7 @@ fz_append_display_node(fz_display_list *list, fz_display_node *node)
 			{
 				if (update)
 				{
-					*update = fz_intersect_rect(*update, list->stack[list->top].rect);
+					fz_intersect_rect(update, &list->stack[list->top].rect);
 					node->rect = *update;
 				}
 				else
@@ -161,7 +161,7 @@ fz_append_display_node(fz_display_list *list, fz_display_node *node)
 		/* fallthrough */
 	default:
 		if (list->top > 0 && list->tiled == 0 && list->top <= STACK_SIZE)
-			list->stack[list->top-1].rect = fz_union_rect(list->stack[list->top-1].rect, node->rect);
+			fz_union_rect(&list->stack[list->top-1].rect, &node->rect);
 		break;
 	}
 	if (!list->first)
@@ -220,7 +220,7 @@ fz_free_display_node(fz_context *ctx, fz_display_node *node)
 }
 
 static void
-fz_list_fill_path(fz_device *dev, fz_path *path, int even_odd, fz_matrix ctm,
+fz_list_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_display_node *node;
@@ -228,7 +228,7 @@ fz_list_fill_path(fz_device *dev, fz_path *path, int even_odd, fz_matrix ctm,
 	node = fz_new_display_node(ctx, FZ_CMD_FILL_PATH, ctm, colorspace, color, alpha);
 	fz_try(ctx)
 	{
-		node->rect = fz_bound_path(dev->ctx, path, NULL, ctm);
+		fz_bound_path(dev->ctx, path, NULL, ctm, &node->rect);
 		node->item.path = fz_clone_path(dev->ctx, path);
 		node->flag = even_odd;
 	}
@@ -241,15 +241,15 @@ fz_list_fill_path(fz_device *dev, fz_path *path, int even_odd, fz_matrix ctm,
 }
 
 static void
-fz_list_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
-	fz_colorspace *colorspace, float *color, float alpha)
+fz_list_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke,
+	const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_display_node *node;
 	fz_context *ctx = dev->ctx;
 	node = fz_new_display_node(ctx, FZ_CMD_STROKE_PATH, ctm, colorspace, color, alpha);
 	fz_try(ctx)
 	{
-		node->rect = fz_bound_path(dev->ctx, path, stroke, ctm);
+		fz_bound_path(dev->ctx, path, stroke, ctm, &node->rect);
 		node->item.path = fz_clone_path(dev->ctx, path);
 		node->stroke = fz_keep_stroke_state(dev->ctx, stroke);
 	}
@@ -262,15 +262,16 @@ fz_list_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_m
 }
 
 static void
-fz_list_clip_path(fz_device *dev, fz_path *path, fz_rect rect, int even_odd, fz_matrix ctm)
+fz_list_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm)
 {
 	fz_display_node *node;
 	fz_context *ctx = dev->ctx;
 	node = fz_new_display_node(ctx, FZ_CMD_CLIP_PATH, ctm, NULL, NULL, 0);
 	fz_try(ctx)
 	{
-		node->rect = fz_bound_path(dev->ctx, path, NULL, ctm);
-		node->rect = fz_intersect_rect(node->rect, rect);
+		fz_bound_path(dev->ctx, path, NULL, ctm, &node->rect);
+		if (rect)
+			fz_intersect_rect(&node->rect, rect);
 		node->item.path = fz_clone_path(dev->ctx, path);
 		node->flag = even_odd;
 	}
@@ -283,15 +284,16 @@ fz_list_clip_path(fz_device *dev, fz_path *path, fz_rect rect, int even_odd, fz_
 }
 
 static void
-fz_list_clip_stroke_path(fz_device *dev, fz_path *path, fz_rect rect, fz_stroke_state *stroke, fz_matrix ctm)
+fz_list_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm)
 {
 	fz_display_node *node;
 	fz_context *ctx = dev->ctx;
 	node = fz_new_display_node(ctx, FZ_CMD_CLIP_STROKE_PATH, ctm, NULL, NULL, 0);
 	fz_try(ctx)
 	{
-		node->rect = fz_bound_path(dev->ctx, path, stroke, ctm);
-		node->rect = fz_intersect_rect(node->rect, rect);
+		fz_bound_path(dev->ctx, path, stroke, ctm, &node->rect);
+		if (rect)
+			fz_intersect_rect(&node->rect, rect);
 		node->item.path = fz_clone_path(dev->ctx, path);
 		node->stroke = fz_keep_stroke_state(dev->ctx, stroke);
 	}
@@ -304,7 +306,7 @@ fz_list_clip_stroke_path(fz_device *dev, fz_path *path, fz_rect rect, fz_stroke_
 }
 
 static void
-fz_list_fill_text(fz_device *dev, fz_text *text, fz_matrix ctm,
+fz_list_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_display_node *node;
@@ -312,7 +314,7 @@ fz_list_fill_text(fz_device *dev, fz_text *text, fz_matrix ctm,
 	node = fz_new_display_node(ctx, FZ_CMD_FILL_TEXT, ctm, colorspace, color, alpha);
 	fz_try(ctx)
 	{
-		node->rect = fz_bound_text(dev->ctx, text, ctm);
+		fz_bound_text(dev->ctx, text, ctm, &node->rect);
 		node->item.text = fz_clone_text(dev->ctx, text);
 	}
 	fz_catch(ctx)
@@ -324,7 +326,7 @@ fz_list_fill_text(fz_device *dev, fz_text *text, fz_matrix ctm,
 }
 
 static void
-fz_list_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
+fz_list_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_display_node *node;
@@ -333,8 +335,8 @@ fz_list_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_m
 	node->item.text = NULL;
 	fz_try(ctx)
 	{
-		node->rect = fz_bound_text(dev->ctx, text, ctm);
-		node->rect = fz_adjust_rect_for_stroke(node->rect, stroke, ctm);
+		fz_bound_text(dev->ctx, text, ctm, &node->rect);
+		fz_adjust_rect_for_stroke(&node->rect, stroke, ctm);
 		node->item.text = fz_clone_text(dev->ctx, text);
 		node->stroke = fz_keep_stroke_state(dev->ctx, stroke);
 	}
@@ -347,14 +349,14 @@ fz_list_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_m
 }
 
 static void
-fz_list_clip_text(fz_device *dev, fz_text *text, fz_matrix ctm, int accumulate)
+fz_list_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate)
 {
 	fz_display_node *node;
 	fz_context *ctx = dev->ctx;
 	node = fz_new_display_node(ctx, FZ_CMD_CLIP_TEXT, ctm, NULL, NULL, 0);
 	fz_try(ctx)
 	{
-		node->rect = fz_bound_text(dev->ctx, text, ctm);
+		fz_bound_text(dev->ctx, text, ctm, &node->rect);
 		node->item.text = fz_clone_text(dev->ctx, text);
 		node->flag = accumulate;
 		/* when accumulating, be conservative about culling */
@@ -370,15 +372,15 @@ fz_list_clip_text(fz_device *dev, fz_text *text, fz_matrix ctm, int accumulate)
 }
 
 static void
-fz_list_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
+fz_list_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm)
 {
 	fz_display_node *node;
 	fz_context *ctx = dev->ctx;
 	node = fz_new_display_node(ctx, FZ_CMD_CLIP_STROKE_TEXT, ctm, NULL, NULL, 0);
 	fz_try(ctx)
 	{
-		node->rect = fz_bound_text(dev->ctx, text, ctm);
-		node->rect = fz_adjust_rect_for_stroke(node->rect, stroke, ctm);
+		fz_bound_text(dev->ctx, text, ctm, &node->rect);
+		fz_adjust_rect_for_stroke(&node->rect, stroke, ctm);
 		node->item.text = fz_clone_text(dev->ctx, text);
 		node->stroke = fz_keep_stroke_state(dev->ctx, stroke);
 	}
@@ -391,14 +393,14 @@ fz_list_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke,
 }
 
 static void
-fz_list_ignore_text(fz_device *dev, fz_text *text, fz_matrix ctm)
+fz_list_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm)
 {
 	fz_display_node *node;
 	fz_context *ctx = dev->ctx;
 	node = fz_new_display_node(ctx, FZ_CMD_IGNORE_TEXT, ctm, NULL, NULL, 0);
 	fz_try(ctx)
 	{
-		node->rect = fz_bound_text(dev->ctx, text, ctm);
+		fz_bound_text(dev->ctx, text, ctm, &node->rect);
 		node->item.text = fz_clone_text(dev->ctx, text);
 	}
 	fz_catch(ctx)
@@ -413,59 +415,63 @@ static void
 fz_list_pop_clip(fz_device *dev)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(dev->ctx, FZ_CMD_POP_CLIP, fz_identity, NULL, NULL, 0);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_POP_CLIP, &fz_identity, NULL, NULL, 0);
 	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha)
+fz_list_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha)
 {
 	fz_display_node *node;
 	fz_context *ctx = dev->ctx;
 	node = fz_new_display_node(ctx, FZ_CMD_FILL_SHADE, ctm, NULL, NULL, alpha);
-	node->rect = fz_bound_shade(ctx, shade, ctm);
+	fz_bound_shade(ctx, shade, ctm, &node->rect);
 	node->item.shade = fz_keep_shade(ctx, shade);
 	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_fill_image(fz_device *dev, fz_image *image, fz_matrix ctm, float alpha)
+fz_list_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha)
 {
 	fz_display_node *node;
 	node = fz_new_display_node(dev->ctx, FZ_CMD_FILL_IMAGE, ctm, NULL, NULL, alpha);
-	node->rect = fz_transform_rect(ctm, fz_unit_rect);
+	node->rect = fz_unit_rect;
+	fz_transform_rect(&node->rect, ctm);
 	node->item.image = fz_keep_image(dev->ctx, image);
 	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_fill_image_mask(fz_device *dev, fz_image *image, fz_matrix ctm,
+fz_list_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_display_node *node;
 	node = fz_new_display_node(dev->ctx, FZ_CMD_FILL_IMAGE_MASK, ctm, colorspace, color, alpha);
-	node->rect = fz_transform_rect(ctm, fz_unit_rect);
+	node->rect = fz_unit_rect;
+	fz_transform_rect(&node->rect, ctm);
 	node->item.image = fz_keep_image(dev->ctx, image);
 	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_clip_image_mask(fz_device *dev, fz_image *image, fz_rect rect, fz_matrix ctm)
+fz_list_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm)
 {
 	fz_display_node *node;
 	node = fz_new_display_node(dev->ctx, FZ_CMD_CLIP_IMAGE_MASK, ctm, NULL, NULL, 0);
-	node->rect = fz_transform_rect(ctm, fz_unit_rect);
-	node->rect = fz_intersect_rect(node->rect, rect);
+	node->rect = fz_unit_rect;
+	fz_transform_rect(&node->rect, ctm);
+	if (rect)
+		fz_intersect_rect(&node->rect, rect);
 	node->item.image = fz_keep_image(dev->ctx, image);
 	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_begin_mask(fz_device *dev, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *color)
+fz_list_begin_mask(fz_device *dev, const fz_rect *rect, int luminosity, fz_colorspace *colorspace, float *color)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(dev->ctx, FZ_CMD_BEGIN_MASK, fz_identity, colorspace, color, 0);
-	node->rect = rect;
+	node = fz_new_display_node(dev->ctx, FZ_CMD_BEGIN_MASK, &fz_identity, colorspace, color, 0);
+	node->rect = *rect;
 	node->flag = luminosity;
 	fz_append_display_node(dev->user, node);
 }
@@ -474,16 +480,16 @@ static void
 fz_list_end_mask(fz_device *dev)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(dev->ctx, FZ_CMD_END_MASK, fz_identity, NULL, NULL, 0);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_END_MASK, &fz_identity, NULL, NULL, 0);
 	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_begin_group(fz_device *dev, fz_rect rect, int isolated, int knockout, int blendmode, float alpha)
+fz_list_begin_group(fz_device *dev, const fz_rect *rect, int isolated, int knockout, int blendmode, float alpha)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(dev->ctx, FZ_CMD_BEGIN_GROUP, fz_identity, NULL, NULL, alpha);
-	node->rect = rect;
+	node = fz_new_display_node(dev->ctx, FZ_CMD_BEGIN_GROUP, &fz_identity, NULL, NULL, alpha);
+	node->rect = *rect;
 	node->item.blendmode = blendmode;
 	node->flag |= isolated ? ISOLATED : 0;
 	node->flag |= knockout ? KNOCKOUT : 0;
@@ -494,22 +500,22 @@ static void
 fz_list_end_group(fz_device *dev)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(dev->ctx, FZ_CMD_END_GROUP, fz_identity, NULL, NULL, 0);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_END_GROUP, &fz_identity, NULL, NULL, 0);
 	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_begin_tile(fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
+fz_list_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm)
 {
 	fz_display_node *node;
 	node = fz_new_display_node(dev->ctx, FZ_CMD_BEGIN_TILE, ctm, NULL, NULL, 0);
-	node->rect = area;
+	node->rect = *area;
 	node->color[0] = xstep;
 	node->color[1] = ystep;
-	node->color[2] = view.x0;
-	node->color[3] = view.y0;
-	node->color[4] = view.x1;
-	node->color[5] = view.y1;
+	node->color[2] = view->x0;
+	node->color[3] = view->y0;
+	node->color[4] = view->x1;
+	node->color[5] = view->y1;
 	fz_append_display_node(dev->user, node);
 }
 
@@ -517,7 +523,7 @@ static void
 fz_list_end_tile(fz_device *dev)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(dev->ctx, FZ_CMD_END_TILE, fz_identity, NULL, NULL, 0);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_END_TILE, &fz_identity, NULL, NULL, 0);
 	fz_append_display_node(dev->user, node);
 }
 
@@ -585,7 +591,7 @@ fz_free_display_list(fz_context *ctx, fz_display_list *list)
 }
 
 void
-fz_run_display_list(fz_display_list *list, fz_device *dev, fz_matrix top_ctm, fz_rect scissor, fz_cookie *cookie)
+fz_run_display_list(fz_display_list *list, fz_device *dev, const fz_matrix *top_ctm, const fz_rect *scissor, fz_cookie *cookie)
 {
 	fz_display_node *node;
 	fz_matrix ctm;
@@ -619,7 +625,9 @@ fz_run_display_list(fz_display_list *list, fz_device *dev, fz_matrix top_ctm, fz
 		}
 		else
 		{
-			empty = fz_is_empty_rect(fz_intersect_rect(fz_transform_rect(top_ctm, node->rect), scissor));
+			fz_rect rect = node->rect;
+			fz_intersect_rect(fz_transform_rect(&rect, top_ctm), scissor);
+			empty = fz_is_empty_rect(&rect);
 		}
 
 		if (clipped || empty)
@@ -655,63 +663,66 @@ fz_run_display_list(fz_display_list *list, fz_device *dev, fz_matrix top_ctm, fz
 		}
 
 visible:
-		ctm = fz_concat(node->ctm, top_ctm);
+		fz_concat(&ctm, &node->ctm, top_ctm);
 
 		fz_try(ctx)
 		{
 			switch (node->cmd)
 			{
 			case FZ_CMD_FILL_PATH:
-				fz_fill_path(dev, node->item.path, node->flag, ctm,
+				fz_fill_path(dev, node->item.path, node->flag, &ctm,
 					node->colorspace, node->color, node->alpha);
 				break;
 			case FZ_CMD_STROKE_PATH:
-				fz_stroke_path(dev, node->item.path, node->stroke, ctm,
+				fz_stroke_path(dev, node->item.path, node->stroke, &ctm,
 					node->colorspace, node->color, node->alpha);
 				break;
 			case FZ_CMD_CLIP_PATH:
 			{
-				fz_rect trect = fz_transform_rect(top_ctm, node->rect);
-				fz_clip_path(dev, node->item.path, trect, node->flag, ctm);
+				fz_rect rect = node->rect;
+				fz_transform_rect(&rect, top_ctm);
+				fz_clip_path(dev, node->item.path, &rect, node->flag, &ctm);
 				break;
 			}
 			case FZ_CMD_CLIP_STROKE_PATH:
 			{
-				fz_rect trect = fz_transform_rect(top_ctm, node->rect);
-				fz_clip_stroke_path(dev, node->item.path, trect, node->stroke, ctm);
+				fz_rect rect = node->rect;
+				fz_transform_rect(&rect, top_ctm);
+				fz_clip_stroke_path(dev, node->item.path, &rect, node->stroke, &ctm);
 				break;
 			}
 			case FZ_CMD_FILL_TEXT:
-				fz_fill_text(dev, node->item.text, ctm,
+				fz_fill_text(dev, node->item.text, &ctm,
 					node->colorspace, node->color, node->alpha);
 				break;
 			case FZ_CMD_STROKE_TEXT:
-				fz_stroke_text(dev, node->item.text, node->stroke, ctm,
+				fz_stroke_text(dev, node->item.text, node->stroke, &ctm,
 					node->colorspace, node->color, node->alpha);
 				break;
 			case FZ_CMD_CLIP_TEXT:
-				fz_clip_text(dev, node->item.text, ctm, node->flag);
+				fz_clip_text(dev, node->item.text, &ctm, node->flag);
 				break;
 			case FZ_CMD_CLIP_STROKE_TEXT:
-				fz_clip_stroke_text(dev, node->item.text, node->stroke, ctm);
+				fz_clip_stroke_text(dev, node->item.text, node->stroke, &ctm);
 				break;
 			case FZ_CMD_IGNORE_TEXT:
-				fz_ignore_text(dev, node->item.text, ctm);
+				fz_ignore_text(dev, node->item.text, &ctm);
 				break;
 			case FZ_CMD_FILL_SHADE:
-				fz_fill_shade(dev, node->item.shade, ctm, node->alpha);
+				fz_fill_shade(dev, node->item.shade, &ctm, node->alpha);
 				break;
 			case FZ_CMD_FILL_IMAGE:
-				fz_fill_image(dev, node->item.image, ctm, node->alpha);
+				fz_fill_image(dev, node->item.image, &ctm, node->alpha);
 				break;
 			case FZ_CMD_FILL_IMAGE_MASK:
-				fz_fill_image_mask(dev, node->item.image, ctm,
+				fz_fill_image_mask(dev, node->item.image, &ctm,
 					node->colorspace, node->color, node->alpha);
 				break;
 			case FZ_CMD_CLIP_IMAGE_MASK:
 			{
-				fz_rect trect = fz_transform_rect(top_ctm, node->rect);
-				fz_clip_image_mask(dev, node->item.image, trect, ctm);
+				fz_rect rect = node->rect;
+				fz_transform_rect(&rect, top_ctm);
+				fz_clip_image_mask(dev, node->item.image, &rect, &ctm);
 				break;
 			}
 			case FZ_CMD_POP_CLIP:
@@ -719,8 +730,9 @@ visible:
 				break;
 			case FZ_CMD_BEGIN_MASK:
 			{
-				fz_rect trect = fz_transform_rect(top_ctm, node->rect);
-				fz_begin_mask(dev, trect, node->flag, node->colorspace, node->color);
+				fz_rect rect = node->rect;
+				fz_transform_rect(&rect, top_ctm);
+				fz_begin_mask(dev, &rect, node->flag, node->colorspace, node->color);
 				break;
 			}
 			case FZ_CMD_END_MASK:
@@ -728,8 +740,9 @@ visible:
 				break;
 			case FZ_CMD_BEGIN_GROUP:
 			{
-				fz_rect trect = fz_transform_rect(top_ctm, node->rect);
-				fz_begin_group(dev, trect,
+				fz_rect rect = node->rect;
+				fz_transform_rect(&rect, top_ctm);
+				fz_begin_group(dev, &rect,
 					(node->flag & ISOLATED) != 0, (node->flag & KNOCKOUT) != 0,
 					node->item.blendmode, node->alpha);
 				break;
@@ -745,7 +758,7 @@ visible:
 				rect.y0 = node->color[3];
 				rect.x1 = node->color[4];
 				rect.y1 = node->color[5];
-				fz_begin_tile(dev, node->rect, rect, node->color[0], node->color[1], ctm);
+				fz_begin_tile(dev, &node->rect, &rect, node->color[0], node->color[1], &ctm);
 				break;
 			}
 			case FZ_CMD_END_TILE:
diff --git a/fitz/dev_null.c b/fitz/dev_null.c
index e3d28fe4..14625342 100644
--- a/fitz/dev_null.c
+++ b/fitz/dev_null.c
@@ -23,7 +23,7 @@ fz_free_device(fz_device *dev)
 }
 
 void
-fz_fill_path(fz_device *dev, fz_path *path, int even_odd, fz_matrix ctm,
+fz_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	if (dev->error_depth)
@@ -33,7 +33,7 @@ fz_fill_path(fz_device *dev, fz_path *path, int even_odd, fz_matrix ctm,
 }
 
 void
-fz_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
+fz_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	if (dev->error_depth)
@@ -43,7 +43,7 @@ fz_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_matrix
 }
 
 void
-fz_clip_path(fz_device *dev, fz_path *path, fz_rect rect, int even_odd, fz_matrix ctm)
+fz_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm)
 {
 	fz_context *ctx = dev->ctx;
 
@@ -67,7 +67,7 @@ fz_clip_path(fz_device *dev, fz_path *path, fz_rect rect, int even_odd, fz_matri
 }
 
 void
-fz_clip_stroke_path(fz_device *dev, fz_path *path, fz_rect rect, fz_stroke_state *stroke, fz_matrix ctm)
+fz_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm)
 {
 	fz_context *ctx = dev->ctx;
 
@@ -91,7 +91,7 @@ fz_clip_stroke_path(fz_device *dev, fz_path *path, fz_rect rect, fz_stroke_state
 }
 
 void
-fz_fill_text(fz_device *dev, fz_text *text, fz_matrix ctm,
+fz_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	if (dev->error_depth)
@@ -101,7 +101,7 @@ fz_fill_text(fz_device *dev, fz_text *text, fz_matrix ctm,
 }
 
 void
-fz_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
+fz_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	if (dev->error_depth)
@@ -111,7 +111,7 @@ fz_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix
 }
 
 void
-fz_clip_text(fz_device *dev, fz_text *text, fz_matrix ctm, int accumulate)
+fz_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate)
 {
 	fz_context *ctx = dev->ctx;
 
@@ -138,7 +138,7 @@ fz_clip_text(fz_device *dev, fz_text *text, fz_matrix ctm, int accumulate)
 }
 
 void
-fz_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
+fz_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm)
 {
 	fz_context *ctx = dev->ctx;
 
@@ -162,7 +162,7 @@ fz_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_m
 }
 
 void
-fz_ignore_text(fz_device *dev, fz_text *text, fz_matrix ctm)
+fz_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm)
 {
 	if (dev->error_depth)
 		return;
@@ -184,7 +184,7 @@ fz_pop_clip(fz_device *dev)
 }
 
 void
-fz_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha)
+fz_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha)
 {
 	if (dev->error_depth)
 		return;
@@ -193,7 +193,7 @@ fz_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha)
 }
 
 void
-fz_fill_image(fz_device *dev, fz_image *image, fz_matrix ctm, float alpha)
+fz_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha)
 {
 	if (dev->error_depth)
 		return;
@@ -202,7 +202,7 @@ fz_fill_image(fz_device *dev, fz_image *image, fz_matrix ctm, float alpha)
 }
 
 void
-fz_fill_image_mask(fz_device *dev, fz_image *image, fz_matrix ctm,
+fz_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	if (dev->error_depth)
@@ -212,7 +212,7 @@ fz_fill_image_mask(fz_device *dev, fz_image *image, fz_matrix ctm,
 }
 
 void
-fz_clip_image_mask(fz_device *dev, fz_image *image, fz_rect rect, fz_matrix ctm)
+fz_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm)
 {
 	fz_context *ctx = dev->ctx;
 
@@ -236,7 +236,7 @@ fz_clip_image_mask(fz_device *dev, fz_image *image, fz_rect rect, fz_matrix ctm)
 }
 
 void
-fz_begin_mask(fz_device *dev, fz_rect area, int luminosity, fz_colorspace *colorspace, float *bc)
+fz_begin_mask(fz_device *dev, const fz_rect *area, int luminosity, fz_colorspace *colorspace, float *bc)
 {
 	fz_context *ctx = dev->ctx;
 
@@ -272,7 +272,7 @@ fz_end_mask(fz_device *dev)
 }
 
 void
-fz_begin_group(fz_device *dev, fz_rect area, int isolated, int knockout, int blendmode, float alpha)
+fz_begin_group(fz_device *dev, const fz_rect *area, int isolated, int knockout, int blendmode, float alpha)
 {
 	fz_context *ctx = dev->ctx;
 
@@ -309,7 +309,7 @@ fz_end_group(fz_device *dev)
 }
 
 void
-fz_begin_tile(fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
+fz_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm)
 {
 	fz_context *ctx = dev->ctx;
 
diff --git a/fitz/dev_text.c b/fitz/dev_text.c
index 9748485c..6b5ba5d8 100644
--- a/fitz/dev_text.c
+++ b/fitz/dev_text.c
@@ -74,7 +74,7 @@ fz_lookup_text_style_imp(fz_context *ctx, fz_text_sheet *sheet,
 }
 
 static fz_text_style *
-fz_lookup_text_style(fz_context *ctx, fz_text_sheet *sheet, fz_text *text, fz_matrix *ctm,
+fz_lookup_text_style(fz_context *ctx, fz_text_sheet *sheet, fz_text *text, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha, fz_stroke_state *stroke)
 {
 	float size = 1.0f;
@@ -86,17 +86,17 @@ fz_lookup_text_style(fz_context *ctx, fz_text_sheet *sheet, fz_text *text, fz_ma
 		fz_matrix trm;
 		tm.e = 0;
 		tm.f = 0;
-		trm = fz_concat(tm, *ctm);
-		size = fz_matrix_expansion(trm);
+		fz_concat(&trm, &tm, ctm);
+		size = fz_matrix_expansion(&trm);
 	}
 	return fz_lookup_text_style_imp(ctx, sheet, size, font, wmode, 0);
 }
 
 fz_text_page *
-fz_new_text_page(fz_context *ctx, fz_rect mediabox)
+fz_new_text_page(fz_context *ctx, const fz_rect *mediabox)
 {
 	fz_text_page *page = fz_malloc(ctx, sizeof(*page));
-	page->mediabox = mediabox;
+	page->mediabox = *mediabox;
 	page->len = 0;
 	page->cap = 0;
 	page->blocks = NULL;
@@ -134,7 +134,7 @@ append_char(fz_context *ctx, fz_text_span *span, int c, fz_rect bbox)
 		span->text = fz_resize_array(ctx, span->text, new_cap, sizeof(*span->text));
 		span->cap = new_cap;
 	}
-	span->bbox = fz_union_rect(span->bbox, bbox);
+	fz_union_rect(&span->bbox, &bbox);
 	span->text[span->len].c = c;
 	span->text[span->len].bbox = bbox;
 	span->len++;
@@ -160,7 +160,7 @@ append_span(fz_context *ctx, fz_text_line *line, fz_text_span *span)
 		line->spans = fz_resize_array(ctx, line->spans, new_cap, sizeof(*line->spans));
 		line->cap = new_cap;
 	}
-	line->bbox = fz_union_rect(line->bbox, span->bbox);
+	fz_union_rect(&line->bbox, &span->bbox);
 	line->spans[line->len++] = *span;
 }
 
@@ -181,7 +181,7 @@ append_line(fz_context *ctx, fz_text_block *block, fz_text_line *line)
 		block->lines = fz_resize_array(ctx, block->lines, new_cap, sizeof *block->lines);
 		block->cap = new_cap;
 	}
-	block->bbox = fz_union_rect(block->bbox, line->bbox);
+	fz_union_rect(&block->bbox, &line->bbox);
 	block->lines[block->len++] = *line;
 }
 
@@ -299,7 +299,7 @@ fz_add_text_char(fz_context *ctx, fz_text_device *dev, fz_text_style *style, int
 }
 
 static void
-fz_text_extract(fz_context *ctx, fz_text_device *dev, fz_text *text, fz_matrix ctm, fz_text_style *style)
+fz_text_extract(fz_context *ctx, fz_text_device *dev, fz_text *text, const fz_matrix *ctm, fz_text_style *style)
 {
 	fz_point *pen = &dev->point;
 	fz_font *font = text->font;
@@ -330,7 +330,7 @@ fz_text_extract(fz_context *ctx, fz_text_device *dev, fz_text *text, fz_matrix c
 		descender = (float)face->descender / face->units_per_EM;
 		fz_unlock(ctx, FZ_LOCK_FREETYPE);
 	}
-	else if (font->t3procs && !fz_is_empty_rect(font->bbox))
+	else if (font->t3procs && !fz_is_empty_rect(&font->bbox))
 	{
 		ascender = font->bbox.y1;
 		descender = font->bbox.y0;
@@ -351,21 +351,21 @@ fz_text_extract(fz_context *ctx, fz_text_device *dev, fz_text *text, fz_matrix c
 
 	tm.e = 0;
 	tm.f = 0;
-	trm = fz_concat(tm, ctm);
+	fz_concat(&trm, &tm, ctm);
 
-	dir = fz_transform_vector(trm, dir);
+	fz_transform_vector(&dir, &trm);
 	dist = sqrtf(dir.x * dir.x + dir.y * dir.y);
 	ndir.x = dir.x / dist;
 	ndir.y = dir.y / dist;
 
-	size = fz_matrix_expansion(trm);
+	size = fz_matrix_expansion(&trm);
 
 	for (i = 0; i < text->len; i++)
 	{
 		/* Calculate new pen location and delta */
 		tm.e = text->items[i].x;
 		tm.f = text->items[i].y;
-		trm = fz_concat(tm, ctm);
+		fz_concat(&trm, &tm, ctm);
 
 		delta.x = pen->x - trm.e;
 		delta.y = pen->y - trm.f;
@@ -390,7 +390,7 @@ fz_text_extract(fz_context *ctx, fz_text_device *dev, fz_text *text, fz_matrix c
 					spacerect.y0 = descender;
 					spacerect.x1 = 0;
 					spacerect.y1 = ascender;
-					spacerect = fz_transform_rect(trm, spacerect);
+					fz_transform_rect(&spacerect, &trm);
 					fz_add_text_char(ctx, dev, style, ' ', spacerect);
 					dev->lastchar = ' ';
 				}
@@ -433,7 +433,7 @@ fz_text_extract(fz_context *ctx, fz_text_device *dev, fz_text *text, fz_matrix c
 			rect.y1 = ascender;
 		}
 
-		rect = fz_transform_rect(trm, rect);
+		fz_transform_rect(&rect, &trm);
 		pen->x = trm.e + dir.x * adv;
 		pen->y = trm.f + dir.y * adv;
 
@@ -462,49 +462,49 @@ fz_text_extract(fz_context *ctx, fz_text_device *dev, fz_text *text, fz_matrix c
 }
 
 static void
-fz_text_fill_text(fz_device *dev, fz_text *text, fz_matrix ctm,
+fz_text_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_text_device *tdev = dev->user;
 	fz_text_style *style;
-	style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, &ctm, colorspace, color, alpha, NULL);
+	style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, ctm, colorspace, color, alpha, NULL);
 	fz_text_extract(dev->ctx, tdev, text, ctm, style);
 }
 
 static void
-fz_text_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
+fz_text_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_text_device *tdev = dev->user;
 	fz_text_style *style;
-	style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, &ctm, colorspace, color, alpha, stroke);
+	style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, ctm, colorspace, color, alpha, stroke);
 	fz_text_extract(dev->ctx, tdev, text, ctm, style);
 }
 
 static void
-fz_text_clip_text(fz_device *dev, fz_text *text, fz_matrix ctm, int accumulate)
+fz_text_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate)
 {
 	fz_text_device *tdev = dev->user;
 	fz_text_style *style;
-	style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, &ctm, NULL, NULL, 0, NULL);
+	style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, ctm, NULL, NULL, 0, NULL);
 	fz_text_extract(dev->ctx, tdev, text, ctm, style);
 }
 
 static void
-fz_text_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
+fz_text_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm)
 {
 	fz_text_device *tdev = dev->user;
 	fz_text_style *style;
-	style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, &ctm, NULL, NULL, 0, stroke);
+	style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, ctm, NULL, NULL, 0, stroke);
 	fz_text_extract(dev->ctx, tdev, text, ctm, style);
 }
 
 static void
-fz_text_ignore_text(fz_device *dev, fz_text *text, fz_matrix ctm)
+fz_text_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm)
 {
 	fz_text_device *tdev = dev->user;
 	fz_text_style *style;
-	style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, &ctm, NULL, NULL, 0, NULL);
+	style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, ctm, NULL, NULL, 0, NULL);
 	fz_text_extract(dev->ctx, tdev, text, ctm, style);
 }
 
diff --git a/fitz/dev_trace.c b/fitz/dev_trace.c
index 78533cf4..c3c17021 100644
--- a/fitz/dev_trace.c
+++ b/fitz/dev_trace.c
@@ -1,17 +1,17 @@
 #include "fitz-internal.h"
 
 static void
-fz_trace_matrix(fz_matrix ctm)
+fz_trace_matrix(const fz_matrix *ctm)
 {
 	printf(" matrix=\"%g %g %g %g %g %g\"",
-		ctm.a, ctm.b, ctm.c, ctm.d, ctm.e, ctm.f);
+		ctm->a, ctm->b, ctm->c, ctm->d, ctm->e, ctm->f);
 }
 
 static void
-fz_trace_trm(fz_matrix trm)
+fz_trace_trm(const fz_matrix *trm)
 {
 	printf(" trm=\"%g %g %g %g\"",
-		trm.a, trm.b, trm.c, trm.d);
+		trm->a, trm->b, trm->c, trm->d);
 }
 
 static void
@@ -67,7 +67,7 @@ fz_trace_path(fz_path *path, int indent)
 }
 
 static void
-fz_trace_fill_path(fz_device *dev, fz_path *path, int even_odd, fz_matrix ctm,
+fz_trace_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	printf("<fill_path");
@@ -83,7 +83,7 @@ fz_trace_fill_path(fz_device *dev, fz_path *path, int even_odd, fz_matrix ctm,
 }
 
 static void
-fz_trace_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
+fz_trace_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	int i;
@@ -112,7 +112,7 @@ fz_trace_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_
 }
 
 static void
-fz_trace_clip_path(fz_device *dev, fz_path *path, fz_rect rect, int even_odd, fz_matrix ctm)
+fz_trace_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm)
 {
 	printf("<clip_path");
 	if (even_odd)
@@ -120,13 +120,13 @@ fz_trace_clip_path(fz_device *dev, fz_path *path, fz_rect rect, int even_odd, fz
 	else
 		printf(" winding=\"nonzero\"");
 	fz_trace_matrix(ctm);
-	printf(" contentbbox=\"%g %g %g %g\">\n", rect.x0, rect.y0, rect.x1, rect.y1);
+	printf(" contentbbox=\"%g %g %g %g\">\n", rect->x0, rect->y0, rect->x1, rect->y1);
 	fz_trace_path(path, 0);
 	printf("</clip_path>\n");
 }
 
 static void
-fz_trace_clip_stroke_path(fz_device *dev, fz_path *path, fz_rect rect, fz_stroke_state *stroke, fz_matrix ctm)
+fz_trace_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm)
 {
 	printf("<clip_stroke_path");
 	fz_trace_matrix(ctm);
@@ -136,67 +136,67 @@ fz_trace_clip_stroke_path(fz_device *dev, fz_path *path, fz_rect rect, fz_stroke
 }
 
 static void
-fz_trace_fill_text(fz_device *dev, fz_text *text, fz_matrix ctm,
+fz_trace_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	printf("<fill_text font=\"%s\" wmode=\"%d\"", text->font->name, text->wmode);
 	fz_trace_color(colorspace, color, alpha);
 	fz_trace_matrix(ctm);
-	fz_trace_trm(text->trm);
+	fz_trace_trm(&text->trm);
 	printf(">\n");
 	fz_print_text(dev->ctx, stdout, text);
 	printf("</fill_text>\n");
 }
 
 static void
-fz_trace_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
+fz_trace_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	printf("<stroke_text font=\"%s\" wmode=\"%d\"", text->font->name, text->wmode);
 	fz_trace_color(colorspace, color, alpha);
 	fz_trace_matrix(ctm);
-	fz_trace_trm(text->trm);
+	fz_trace_trm(&text->trm);
 	printf(">\n");
 	fz_print_text(dev->ctx, stdout, text);
 	printf("</stroke_text>\n");
 }
 
 static void
-fz_trace_clip_text(fz_device *dev, fz_text *text, fz_matrix ctm, int accumulate)
+fz_trace_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate)
 {
 	printf("<clip_text font=\"%s\" wmode=\"%d\"", text->font->name, text->wmode);
 	printf(" accumulate=\"%d\"", accumulate);
 	fz_trace_matrix(ctm);
-	fz_trace_trm(text->trm);
+	fz_trace_trm(&text->trm);
 	printf(">\n");
 	fz_print_text(dev->ctx, stdout, text);
 	printf("</clip_text>\n");
 }
 
 static void
-fz_trace_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
+fz_trace_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm)
 {
 	printf("<clip_stroke_text font=\"%s\" wmode=\"%d\"", text->font->name, text->wmode);
 	fz_trace_matrix(ctm);
-	fz_trace_trm(text->trm);
+	fz_trace_trm(&text->trm);
 	printf(">\n");
 	fz_print_text(dev->ctx, stdout, text);
 	printf("</clip_stroke_text>\n");
 }
 
 static void
-fz_trace_ignore_text(fz_device *dev, fz_text *text, fz_matrix ctm)
+fz_trace_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm)
 {
 	printf("<ignore_text font=\"%s\" wmode=\"%d\"", text->font->name, text->wmode);
 	fz_trace_matrix(ctm);
-	fz_trace_trm(text->trm);
+	fz_trace_trm(&text->trm);
 	printf(">\n");
 	fz_print_text(dev->ctx, stdout, text);
 	printf("</ignore_text>\n");
 }
 
 static void
-fz_trace_fill_image(fz_device *dev, fz_image *image, fz_matrix ctm, float alpha)
+fz_trace_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha)
 {
 	printf("<fill_image alpha=\"%g\"", alpha);
 	fz_trace_matrix(ctm);
@@ -205,7 +205,7 @@ fz_trace_fill_image(fz_device *dev, fz_image *image, fz_matrix ctm, float alpha)
 }
 
 static void
-fz_trace_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha)
+fz_trace_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha)
 {
 	printf("<fill_shade alpha=\"%g\"", alpha);
 	fz_trace_matrix(ctm);
@@ -213,7 +213,8 @@ fz_trace_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha)
 }
 
 static void
-fz_trace_fill_image_mask(fz_device *dev, fz_image *image, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha)
+fz_trace_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm,
+fz_colorspace *colorspace, float *color, float alpha)
 {
 	printf("<fill_image_mask");
 	fz_trace_matrix(ctm);
@@ -223,7 +224,7 @@ fz_trace_fill_image_mask(fz_device *dev, fz_image *image, fz_matrix ctm, fz_colo
 }
 
 static void
-fz_trace_clip_image_mask(fz_device *dev, fz_image *image, fz_rect rect, fz_matrix ctm)
+fz_trace_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm)
 {
 	printf("<clip_image_mask");
 	fz_trace_matrix(ctm);
@@ -238,10 +239,10 @@ fz_trace_pop_clip(fz_device *dev)
 }
 
 static void
-fz_trace_begin_mask(fz_device *dev, fz_rect bbox, int luminosity, fz_colorspace *colorspace, float *color)
+fz_trace_begin_mask(fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, float *color)
 {
 	printf("<mask bbox=\"%g %g %g %g\" s=\"%s\"",
-		bbox.x0, bbox.y0, bbox.x1, bbox.y1,
+		bbox->x0, bbox->y0, bbox->x1, bbox->y1,
 		luminosity ? "luminosity" : "alpha");
 	printf(">\n");
 }
@@ -253,10 +254,10 @@ fz_trace_end_mask(fz_device *dev)
 }
 
 static void
-fz_trace_begin_group(fz_device *dev, fz_rect bbox, int isolated, int knockout, int blendmode, float alpha)
+fz_trace_begin_group(fz_device *dev, const fz_rect *bbox, int isolated, int knockout, int blendmode, float alpha)
 {
 	printf("<group bbox=\"%g %g %g %g\" isolated=\"%d\" knockout=\"%d\" blendmode=\"%s\" alpha=\"%g\">\n",
-		bbox.x0, bbox.y0, bbox.x1, bbox.y1,
+		bbox->x0, bbox->y0, bbox->x1, bbox->y1,
 		isolated, knockout, fz_blendmode_name(blendmode), alpha);
 }
 
@@ -267,11 +268,11 @@ fz_trace_end_group(fz_device *dev)
 }
 
 static void
-fz_trace_begin_tile(fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
+fz_trace_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm)
 {
 	printf("<tile");
-	printf(" area=\"%g %g %g %g\"", area.x0, area.y0, area.x1, area.y1);
-	printf(" view=\"%g %g %g %g\"", view.x0, view.y0, view.x1, view.y1);
+	printf(" area=\"%g %g %g %g\"", area->x0, area->y0, area->x1, area->y1);
+	printf(" view=\"%g %g %g %g\"", view->x0, view->y0, view->x1, view->y1);
 	printf(" xstep=\"%g\" ystep=\"%g\"", xstep, ystep);
 	fz_trace_matrix(ctm);
 	printf(">\n");
diff --git a/fitz/doc_document.c b/fitz/doc_document.c
index 15605109..14e6da9d 100644
--- a/fitz/doc_document.c
+++ b/fitz/doc_document.c
@@ -129,12 +129,14 @@ fz_load_links(fz_document *doc, fz_page *page)
 	return NULL;
 }
 
-fz_rect
-fz_bound_page(fz_document *doc, fz_page *page)
+fz_rect *
+fz_bound_page(fz_document *doc, fz_page *page, fz_rect *r)
 {
-	if (doc && doc->bound_page && page)
-		return doc->bound_page(doc, page);
-	return fz_empty_rect;
+	if (doc && doc->bound_page && page && r)
+		return doc->bound_page(doc, page, r);
+	if (r)
+		*r = fz_empty_rect;
+	return r;
 }
 
 fz_annot *
@@ -153,30 +155,32 @@ fz_next_annot(fz_document *doc, fz_annot *annot)
 	return NULL;
 }
 
-fz_rect
-fz_bound_annot(fz_document *doc, fz_annot *annot)
+fz_rect *
+fz_bound_annot(fz_document *doc, fz_annot *annot, fz_rect *rect)
 {
-	if (doc && doc->bound_annot && annot)
-		return doc->bound_annot(doc, annot);
-	return fz_empty_rect;
+	if (doc && doc->bound_annot && annot && rect)
+		return doc->bound_annot(doc, annot, rect);
+	if (rect)
+		*rect = fz_empty_rect;
+	return rect;
 }
 
 void
-fz_run_page_contents(fz_document *doc, fz_page *page, fz_device *dev, fz_matrix transform, fz_cookie *cookie)
+fz_run_page_contents(fz_document *doc, fz_page *page, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie)
 {
 	if (doc && doc->run_page_contents && page)
 		doc->run_page_contents(doc, page, dev, transform, cookie);
 }
 
 void
-fz_run_annot(fz_document *doc, fz_page *page, fz_annot *annot, fz_device *dev, fz_matrix transform, fz_cookie *cookie)
+fz_run_annot(fz_document *doc, fz_page *page, fz_annot *annot, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie)
 {
 	if (doc && doc->run_annot && page && annot)
 		doc->run_annot(doc, page, annot, dev, transform, cookie);
 }
 
 void
-fz_run_page(fz_document *doc, fz_page *page, fz_device *dev, fz_matrix transform, fz_cookie *cookie)
+fz_run_page(fz_document *doc, fz_page *page, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie)
 {
 	fz_annot *annot;
 
diff --git a/fitz/doc_link.c b/fitz/doc_link.c
index 53fe4328..17211d2e 100644
--- a/fitz/doc_link.c
+++ b/fitz/doc_link.c
@@ -24,7 +24,7 @@ fz_free_link_dest(fz_context *ctx, fz_link_dest *dest)
 }
 
 fz_link *
-fz_new_link(fz_context *ctx, fz_rect bbox, fz_link_dest dest)
+fz_new_link(fz_context *ctx, const fz_rect *bbox, fz_link_dest dest)
 {
 	fz_link *link;
 
@@ -39,7 +39,7 @@ fz_new_link(fz_context *ctx, fz_rect bbox, fz_link_dest dest)
 		fz_rethrow(ctx);
 	}
 	link->dest = dest;
-	link->rect = bbox;
+	link->rect = *bbox;
 	link->next = NULL;
 	return link;
 }
diff --git a/fitz/doc_search.c b/fitz/doc_search.c
index 76e5e9dc..66f0d496 100644
--- a/fitz/doc_search.c
+++ b/fitz/doc_search.c
@@ -42,9 +42,10 @@ static int charat(fz_text_page *page, int idx)
 	return textcharat(page, idx).c;
 }
 
-static fz_rect bboxat(fz_text_page *page, int idx)
+static fz_rect *bboxat(fz_text_page *page, int idx, fz_rect *bbox)
 {
-	return textcharat(page, idx).bbox;
+	*bbox = textcharat(page, idx).bbox;
+	return bbox;
 }
 
 static int textlen(fz_text_page *page)
@@ -105,22 +106,23 @@ fz_search_text_page(fz_context *ctx, fz_text_page *text, char *needle, fz_rect *
 			fz_rect linebox = fz_empty_rect;
 			for (i = 0; i < n; i++)
 			{
-				fz_rect charbox = bboxat(text, pos + i);
-				if (!fz_is_empty_rect(charbox))
+				fz_rect charbox;
+				bboxat(text, pos + i, &charbox);
+				if (!fz_is_empty_rect(&charbox))
 				{
 					if (charbox.y0 != linebox.y0 || fz_abs(charbox.x0 - linebox.x1) > 5)
 					{
-						if (!fz_is_empty_rect(linebox) && hit_count < hit_max)
+						if (!fz_is_empty_rect(&linebox) && hit_count < hit_max)
 							hit_bbox[hit_count++] = linebox;
 						linebox = charbox;
 					}
 					else
 					{
-						linebox = fz_union_rect(linebox, charbox);
+						fz_union_rect(&linebox, &charbox);
 					}
 				}
 			}
-			if (!fz_is_empty_rect(linebox) && hit_count < hit_max)
+			if (!fz_is_empty_rect(&linebox) && hit_count < hit_max)
 				hit_bbox[hit_count++] = linebox;
 		}
 	}
@@ -158,18 +160,18 @@ fz_highlight_selection(fz_context *ctx, fz_text_page *page, fz_rect rect, fz_rec
 					{
 						if (charbox.y0 != linebox.y0 || fz_abs(charbox.x0 - linebox.x1) > 5)
 						{
-							if (!fz_is_empty_rect(linebox) && hit_count < hit_max)
+							if (!fz_is_empty_rect(&linebox) && hit_count < hit_max)
 								hit_bbox[hit_count++] = linebox;
 							linebox = charbox;
 						}
 						else
 						{
-							linebox = fz_union_rect(linebox, charbox);
+							fz_union_rect(&linebox, &charbox);
 						}
 					}
 				}
 			}
-			if (!fz_is_empty_rect(linebox) && hit_count < hit_max)
+			if (!fz_is_empty_rect(&linebox) && hit_count < hit_max)
 				hit_bbox[hit_count++] = linebox;
 		}
 	}
diff --git a/fitz/fitz-internal.h b/fitz/fitz-internal.h
index 7e817190..cc8efafe 100644
--- a/fitz/fitz-internal.h
+++ b/fitz/fitz-internal.h
@@ -300,8 +300,8 @@ static inline int fz_mul255(int a, int b)
  * AMOUNT (in the 0...256 range). */
 #define FZ_BLEND(SRC, DST, AMOUNT) ((((SRC)-(DST))*(AMOUNT) + ((DST)<<8))>>8)
 
-fz_matrix fz_gridfit_matrix(fz_matrix m);
-float fz_matrix_max_expansion(fz_matrix m);
+void fz_gridfit_matrix(fz_matrix *m);
+float fz_matrix_max_expansion(const fz_matrix *m);
 
 /*
  * Basic crypto functions.
@@ -872,7 +872,7 @@ struct fz_pixmap_s
 
 void fz_free_pixmap_imp(fz_context *ctx, fz_storable *pix);
 
-void fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, fz_bbox r);
+void fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, const fz_bbox *r);
 void fz_premultiply_pixmap(fz_context *ctx, fz_pixmap *pix);
 fz_pixmap *fz_alpha_from_gray(fz_context *ctx, fz_pixmap *gray, int luminosity);
 unsigned int fz_pixmap_size(fz_context *ctx, fz_pixmap *pix);
@@ -883,11 +883,11 @@ typedef struct fz_scale_cache_s fz_scale_cache;
 
 fz_scale_cache *fz_new_scale_cache(fz_context *ctx);
 void fz_free_scale_cache(fz_context *ctx, fz_scale_cache *cache);
-fz_pixmap *fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_bbox *clip, fz_scale_cache *cache_x, fz_scale_cache *cache_y);
+fz_pixmap *fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, const fz_bbox *clip, fz_scale_cache *cache_x, fz_scale_cache *cache_y);
 
 void fz_subsample_pixmap(fz_context *ctx, fz_pixmap *tile, int factor);
 
-fz_bbox fz_pixmap_bbox_no_ctx(fz_pixmap *src);
+fz_bbox *fz_pixmap_bbox_no_ctx(fz_pixmap *src, fz_bbox *bbox);
 
 typedef struct fz_compression_params_s fz_compression_params;
 
@@ -1049,7 +1049,7 @@ struct fz_font_s
 	float *t3widths; /* has 256 entries if used */
 	char *t3flags; /* has 256 entries if used */
 	void *t3doc; /* a pdf_document for the callback */
-	void (*t3run)(void *doc, void *resources, fz_buffer *contents, fz_device *dev, fz_matrix ctm, void *gstate, int nestedDepth);
+	void (*t3run)(void *doc, void *resources, fz_buffer *contents, fz_device *dev, const fz_matrix *ctm, void *gstate, int nestedDepth);
 	void (*t3freeres)(void *doc, void *resources);
 
 	fz_rect bbox;	/* font bbox is used only for t3 fonts */
@@ -1068,7 +1068,7 @@ void fz_new_font_context(fz_context *ctx);
 fz_font_context *fz_keep_font_context(fz_context *ctx);
 void fz_drop_font_context(fz_context *ctx);
 
-fz_font *fz_new_type3_font(fz_context *ctx, char *name, fz_matrix matrix);
+fz_font *fz_new_type3_font(fz_context *ctx, char *name, const fz_matrix *matrix);
 
 fz_font *fz_new_font_from_memory(fz_context *ctx, char *name, unsigned char *data, int len, int index, int use_glyph_bbox);
 fz_font *fz_new_font_from_file(fz_context *ctx, char *name, char *path, int index, int use_glyph_bbox);
@@ -1077,7 +1077,7 @@ fz_font *fz_keep_font(fz_context *ctx, fz_font *font);
 void fz_drop_font(fz_context *ctx, fz_font *font);
 
 void fz_set_font_bbox(fz_context *ctx, fz_font *font, float xmin, float ymin, float xmax, float ymax);
-fz_rect fz_bound_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm);
+fz_rect *fz_bound_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm, fz_rect *r);
 int fz_glyph_cacheable(fz_context *ctx, fz_font *font, int gid);
 
 #ifndef NDEBUG
@@ -1157,12 +1157,12 @@ void fz_curvetoy(fz_context*,fz_path*, float, float, float, float);
 void fz_closepath(fz_context*,fz_path*);
 void fz_free_path(fz_context *ctx, fz_path *path);
 
-void fz_transform_path(fz_context *ctx, fz_path *path, fz_matrix transform);
+void fz_transform_path(fz_context *ctx, fz_path *path, const fz_matrix *transform);
 
 fz_path *fz_clone_path(fz_context *ctx, fz_path *old);
 
-fz_rect fz_bound_path(fz_context *ctx, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm);
-fz_rect fz_adjust_rect_for_stroke(fz_rect r, fz_stroke_state *stroke, fz_matrix ctm);
+fz_rect *fz_bound_path(fz_context *ctx, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, fz_rect *r);
+fz_rect *fz_adjust_rect_for_stroke(fz_rect *r, fz_stroke_state *stroke, const fz_matrix *ctm);
 
 fz_stroke_state *fz_new_stroke_state(fz_context *ctx);
 fz_stroke_state *fz_new_stroke_state_with_len(fz_context *ctx, int len);
@@ -1184,14 +1184,14 @@ fz_glyph_cache *fz_keep_glyph_cache(fz_context *ctx);
 void fz_drop_glyph_cache_context(fz_context *ctx);
 void fz_purge_glyph_cache(fz_context *ctx);
 
-fz_path *fz_outline_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm);
-fz_path *fz_outline_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix ctm);
-fz_pixmap *fz_render_ft_glyph(fz_context *ctx, fz_font *font, int cid, fz_matrix trm, int aa);
-fz_pixmap *fz_render_t3_glyph(fz_context *ctx, fz_font *font, int cid, fz_matrix trm, fz_colorspace *model, fz_bbox scissor);
-fz_pixmap *fz_render_ft_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz_stroke_state *state);
-fz_pixmap *fz_render_glyph(fz_context *ctx, fz_font*, int, fz_matrix, fz_colorspace *model, fz_bbox scissor);
-fz_pixmap *fz_render_stroked_glyph(fz_context *ctx, fz_font*, int, fz_matrix, fz_matrix, fz_stroke_state *stroke, fz_bbox scissor);
-void fz_render_t3_glyph_direct(fz_context *ctx, fz_device *dev, fz_font *font, int gid, fz_matrix trm, void *gstate, int nestedDepth);
+fz_path *fz_outline_ft_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm);
+fz_path *fz_outline_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *ctm);
+fz_pixmap *fz_render_ft_glyph(fz_context *ctx, fz_font *font, int cid, const fz_matrix *trm, int aa);
+fz_pixmap *fz_render_t3_glyph(fz_context *ctx, fz_font *font, int cid, const fz_matrix *trm, fz_colorspace *model, fz_bbox scissor);
+fz_pixmap *fz_render_ft_stroked_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm, const fz_matrix *ctm, fz_stroke_state *state);
+fz_pixmap *fz_render_glyph(fz_context *ctx, fz_font*, int, const fz_matrix *, fz_colorspace *model, fz_bbox scissor);
+fz_pixmap *fz_render_stroked_glyph(fz_context *ctx, fz_font*, int, const fz_matrix *, const fz_matrix *, fz_stroke_state *stroke, fz_bbox scissor);
+void fz_render_t3_glyph_direct(fz_context *ctx, fz_device *dev, fz_font *font, int gid, const fz_matrix *trm, void *gstate, int nestedDepth);
 void fz_prepare_t3_glyph(fz_context *ctx, fz_font *font, int gid, int nestedDepth);
 
 typedef enum
@@ -1243,10 +1243,10 @@ struct fz_text_s
 	fz_text_item *items;
 };
 
-fz_text *fz_new_text(fz_context *ctx, fz_font *face, fz_matrix trm, int wmode);
+fz_text *fz_new_text(fz_context *ctx, fz_font *face, const fz_matrix *trm, int wmode);
 void fz_add_text(fz_context *ctx, fz_text *text, int gid, int ucs, float x, float y);
 void fz_free_text(fz_context *ctx, fz_text *text);
-fz_rect fz_bound_text(fz_context *ctx, fz_text *text, fz_matrix ctm);
+fz_rect *fz_bound_text(fz_context *ctx, fz_text *text, const fz_matrix *ctm, fz_rect *r);
 fz_text *fz_clone_text(fz_context *ctx, fz_text *old);
 void fz_print_text(fz_context *ctx, FILE *out, fz_text*);
 
@@ -1317,8 +1317,8 @@ fz_shade *fz_keep_shade(fz_context *ctx, fz_shade *shade);
 void fz_drop_shade(fz_context *ctx, fz_shade *shade);
 void fz_free_shade_imp(fz_context *ctx, fz_storable *shade);
 
-fz_rect fz_bound_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm);
-void fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox);
+fz_rect *fz_bound_shade(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_rect *r);
+void fz_paint_shade(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_pixmap *dest, const fz_bbox *bbox);
 
 /*
  *	Handy routine for processing mesh based shades
@@ -1342,7 +1342,7 @@ struct fz_mesh_processor_s {
 	void *process_arg;
 };
 
-void fz_process_mesh(fz_context *ctx, fz_shade *shade, fz_matrix ctm,
+void fz_process_mesh(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm,
 			fz_mesh_process_fn *process, void *process_arg);
 
 #ifndef NDEBUG
@@ -1357,17 +1357,17 @@ typedef struct fz_gel_s fz_gel;
 
 fz_gel *fz_new_gel(fz_context *ctx);
 void fz_insert_gel(fz_gel *gel, float x0, float y0, float x1, float y1);
-void fz_reset_gel(fz_gel *gel, fz_bbox clip);
+void fz_reset_gel(fz_gel *gel, const fz_bbox *clip);
 void fz_sort_gel(fz_gel *gel);
-fz_bbox fz_bound_gel(fz_gel *gel);
+fz_bbox *fz_bound_gel(const fz_gel *gel, fz_bbox *bbox);
 void fz_free_gel(fz_gel *gel);
 int fz_is_rect_gel(fz_gel *gel);
 
-void fz_scan_convert(fz_gel *gel, int eofill, fz_bbox clip, fz_pixmap *pix, unsigned char *colorbv);
+void fz_scan_convert(fz_gel *gel, int eofill, const fz_bbox *clip, fz_pixmap *pix, unsigned char *colorbv);
 
-void fz_flatten_fill_path(fz_gel *gel, fz_path *path, fz_matrix ctm, float flatness);
-void fz_flatten_stroke_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm, float flatness, float linewidth);
-void fz_flatten_dash_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm, float flatness, float linewidth);
+void fz_flatten_fill_path(fz_gel *gel, fz_path *path, const fz_matrix *ctm, float flatness);
+void fz_flatten_stroke_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, float flatness, float linewidth);
+void fz_flatten_dash_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, float flatness, float linewidth);
 
 /*
  * The device interface.
@@ -1407,55 +1407,55 @@ struct fz_device_s
 	void (*free_user)(fz_device *);
 	fz_context *ctx;
 
-	void (*fill_path)(fz_device *, fz_path *, int even_odd, fz_matrix, fz_colorspace *, float *color, float alpha);
-	void (*stroke_path)(fz_device *, fz_path *, fz_stroke_state *, fz_matrix, fz_colorspace *, float *color, float alpha);
-	void (*clip_path)(fz_device *, fz_path *, fz_rect rect, int even_odd, fz_matrix);
-	void (*clip_stroke_path)(fz_device *, fz_path *, fz_rect rect, fz_stroke_state *, fz_matrix);
+	void (*fill_path)(fz_device *, fz_path *, int even_odd, const fz_matrix *, fz_colorspace *, float *color, float alpha);
+	void (*stroke_path)(fz_device *, fz_path *, fz_stroke_state *, const fz_matrix *, fz_colorspace *, float *color, float alpha);
+	void (*clip_path)(fz_device *, fz_path *, const fz_rect *rect, int even_odd, const fz_matrix *);
+	void (*clip_stroke_path)(fz_device *, fz_path *, const fz_rect *rect, fz_stroke_state *, const fz_matrix *);
 
-	void (*fill_text)(fz_device *, fz_text *, fz_matrix, fz_colorspace *, float *color, float alpha);
-	void (*stroke_text)(fz_device *, fz_text *, fz_stroke_state *, fz_matrix, fz_colorspace *, float *color, float alpha);
-	void (*clip_text)(fz_device *, fz_text *, fz_matrix, int accumulate);
-	void (*clip_stroke_text)(fz_device *, fz_text *, fz_stroke_state *, fz_matrix);
-	void (*ignore_text)(fz_device *, fz_text *, fz_matrix);
+	void (*fill_text)(fz_device *, fz_text *, const fz_matrix *, fz_colorspace *, float *color, float alpha);
+	void (*stroke_text)(fz_device *, fz_text *, fz_stroke_state *, const fz_matrix *, fz_colorspace *, float *color, float alpha);
+	void (*clip_text)(fz_device *, fz_text *, const fz_matrix *, int accumulate);
+	void (*clip_stroke_text)(fz_device *, fz_text *, fz_stroke_state *, const fz_matrix *);
+	void (*ignore_text)(fz_device *, fz_text *, const fz_matrix *);
 
-	void (*fill_shade)(fz_device *, fz_shade *shd, fz_matrix ctm, float alpha);
-	void (*fill_image)(fz_device *, fz_image *img, fz_matrix ctm, float alpha);
-	void (*fill_image_mask)(fz_device *, fz_image *img, fz_matrix ctm, fz_colorspace *, float *color, float alpha);
-	void (*clip_image_mask)(fz_device *, fz_image *img, fz_rect rect, fz_matrix ctm);
+	void (*fill_shade)(fz_device *, fz_shade *shd, const fz_matrix *ctm, float alpha);
+	void (*fill_image)(fz_device *, fz_image *img, const fz_matrix *ctm, float alpha);
+	void (*fill_image_mask)(fz_device *, fz_image *img, const fz_matrix *ctm, fz_colorspace *, float *color, float alpha);
+	void (*clip_image_mask)(fz_device *, fz_image *img, const fz_rect *rect, const fz_matrix *ctm);
 
 	void (*pop_clip)(fz_device *);
 
-	void (*begin_mask)(fz_device *, fz_rect, int luminosity, fz_colorspace *, float *bc);
+	void (*begin_mask)(fz_device *, const fz_rect *, int luminosity, fz_colorspace *, float *bc);
 	void (*end_mask)(fz_device *);
-	void (*begin_group)(fz_device *, fz_rect, int isolated, int knockout, int blendmode, float alpha);
+	void (*begin_group)(fz_device *, const fz_rect *, int isolated, int knockout, int blendmode, float alpha);
 	void (*end_group)(fz_device *);
 
-	void (*begin_tile)(fz_device *, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm);
+	void (*begin_tile)(fz_device *, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm);
 	void (*end_tile)(fz_device *);
 
 	int error_depth;
 	char errmess[256];
 };
 
-void fz_fill_path(fz_device *dev, fz_path *path, int even_odd, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha);
-void fz_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha);
-void fz_clip_path(fz_device *dev, fz_path *path, fz_rect rect, int even_odd, fz_matrix ctm);
-void fz_clip_stroke_path(fz_device *dev, fz_path *path, fz_rect rect, fz_stroke_state *stroke, fz_matrix ctm);
-void fz_fill_text(fz_device *dev, fz_text *text, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha);
-void fz_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha);
-void fz_clip_text(fz_device *dev, fz_text *text, fz_matrix ctm, int accumulate);
-void fz_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm);
-void fz_ignore_text(fz_device *dev, fz_text *text, fz_matrix ctm);
+void fz_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha);
+void fz_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha);
+void fz_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm);
+void fz_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm);
+void fz_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha);
+void fz_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha);
+void fz_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate);
+void fz_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm);
+void fz_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm);
 void fz_pop_clip(fz_device *dev);
-void fz_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha);
-void fz_fill_image(fz_device *dev, fz_image *image, fz_matrix ctm, float alpha);
-void fz_fill_image_mask(fz_device *dev, fz_image *image, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha);
-void fz_clip_image_mask(fz_device *dev, fz_image *image, fz_rect rect, fz_matrix ctm);
-void fz_begin_mask(fz_device *dev, fz_rect area, int luminosity, fz_colorspace *colorspace, float *bc);
+void fz_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha);
+void fz_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha);
+void fz_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha);
+void fz_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm);
+void fz_begin_mask(fz_device *dev, const fz_rect *area, int luminosity, fz_colorspace *colorspace, float *bc);
 void fz_end_mask(fz_device *dev);
-void fz_begin_group(fz_device *dev, fz_rect area, int isolated, int knockout, int blendmode, float alpha);
+void fz_begin_group(fz_device *dev, const fz_rect *area, int isolated, int knockout, int blendmode, float alpha);
 void fz_end_group(fz_device *dev);
-void fz_begin_tile(fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm);
+void fz_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm);
 void fz_end_tile(fz_device *dev);
 
 fz_device *fz_new_device(fz_context *ctx, void *user);
@@ -1476,8 +1476,8 @@ void fz_paint_solid_color(unsigned char * restrict dp, int n, int w, unsigned ch
 void fz_paint_span(unsigned char * restrict dp, unsigned char * restrict sp, int n, int w, int alpha);
 void fz_paint_span_with_color(unsigned char * restrict dp, unsigned char * restrict mp, int n, int w, unsigned char *color);
 
-void fz_paint_image(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, int alpha);
-void fz_paint_image_with_color(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, unsigned char *colorbv);
+void fz_paint_image(fz_pixmap *dst, const fz_bbox *scissor, fz_pixmap *shape, fz_pixmap *img, const fz_matrix *ctm, int alpha);
+void fz_paint_image_with_color(fz_pixmap *dst, const fz_bbox *scissor, fz_pixmap *shape, fz_pixmap *img, const fz_matrix *ctm, unsigned char *colorbv);
 
 void fz_paint_pixmap(fz_pixmap *dst, fz_pixmap *src, int alpha);
 void fz_paint_pixmap_with_mask(fz_pixmap *dst, fz_pixmap *src, fz_pixmap *msk);
@@ -1523,9 +1523,9 @@ struct fz_document_s
 	int (*count_pages)(fz_document *doc);
 	fz_page *(*load_page)(fz_document *doc, int number);
 	fz_link *(*load_links)(fz_document *doc, fz_page *page);
-	fz_rect (*bound_page)(fz_document *doc, fz_page *page);
-	void (*run_page_contents)(fz_document *doc, fz_page *page, fz_device *dev, fz_matrix transform, fz_cookie *cookie);
-	void (*run_annot)(fz_document *doc, fz_page *page, fz_annot *annot, fz_device *dev, fz_matrix transform, fz_cookie *cookie);
+	fz_rect *(*bound_page)(fz_document *doc, fz_page *page, fz_rect *);
+	void (*run_page_contents)(fz_document *doc, fz_page *page, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie);
+	void (*run_annot)(fz_document *doc, fz_page *page, fz_annot *annot, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie);
 	void (*free_page)(fz_document *doc, fz_page *page);
 	int (*meta)(fz_document *doc, int key, void *ptr, int size);
 	fz_transition *(*page_presentation)(fz_document *doc, fz_page *page, float *duration);
@@ -1533,7 +1533,7 @@ struct fz_document_s
 	void (*write)(fz_document *doc, char *filename, fz_write_options *opts);
 	fz_annot *(*first_annot)(fz_document *doc, fz_page *page);
 	fz_annot *(*next_annot)(fz_document *doc, fz_annot *annot);
-	fz_rect (*bound_annot)(fz_document *doc, fz_annot *annot);
+	fz_rect *(*bound_annot)(fz_document *doc, fz_annot *annot, fz_rect *rect);
 };
 
 #endif
diff --git a/fitz/fitz.h b/fitz/fitz.h
index b606491a..926943f6 100644
--- a/fitz/fitz.h
+++ b/fitz/fitz.h
@@ -748,6 +748,22 @@ struct fz_rect_s
 };
 
 /*
+	fz_rect_min: get the minimum point from a rectangle as an fz_point.
+*/
+static inline fz_point *fz_rect_min(fz_rect *f)
+{
+	return (fz_point *)(void *)&f->x0;
+}
+
+/*
+	fz_rect_max: get the maximum point from a rectangle as an fz_point.
+*/
+static inline fz_point *fz_rect_max(fz_rect *f)
+{
+	return (fz_point *)(void *)&f->x1;
+}
+
+/*
 	fz_bbox is a rectangle using integers instead of floats.
 
 	It's used in the draw device and for pixmap dimensions.
@@ -789,7 +805,7 @@ extern const fz_bbox fz_infinite_bbox;
 
 	An empty rectangle is defined as one whose area is zero.
 */
-#define fz_is_empty_rect(r) ((r).x0 == (r).x1 || (r).y0 == (r).y1)
+#define fz_is_empty_rect(r) ((r)->x0 == (r)->x1 || (r)->y0 == (r)->y1)
 
 /*
 	fz_is_infinite: Check if rectangle is infinite.
@@ -797,7 +813,7 @@ extern const fz_bbox fz_infinite_bbox;
 	An infinite rectangle is defined as one where either of the
 	two relationships between corner coordinates are not true.
 */
-#define fz_is_infinite_rect(r) ((r).x0 > (r).x1 || (r).y0 > (r).y1)
+#define fz_is_infinite_rect(r) ((r)->x0 > (r)->x1 || (r)->y0 > (r)->y1)
 
 /*
 	fz_matrix is a a row-major 3x3 matrix used for representing
@@ -824,40 +840,87 @@ struct fz_matrix_s
 */
 extern const fz_matrix fz_identity;
 
+static inline fz_matrix *fz_copy_matrix(fz_matrix *m, const fz_matrix *s)
+{
+	*m = *s;
+	return m;
+}
+
 /*
 	fz_concat: Multiply two matrices.
 
 	The order of the two matrices are important since matrix
 	multiplication is not commutative.
 
+	Returns result.
+
 	Does not throw exceptions.
 */
-fz_matrix fz_concat(fz_matrix left, fz_matrix right);
+fz_matrix *fz_concat(fz_matrix *result, const fz_matrix *left, const fz_matrix *right);
 
 /*
 	fz_scale: Create a scaling matrix.
 
 	The returned matrix is of the form [ sx 0 0 sy 0 0 ].
 
+	m: Pointer to the matrix to populate
+
+	sx, sy: Scaling factors along the X- and Y-axes. A scaling
+	factor of 1.0 will not cause any scaling along the relevant
+	axis.
+
+	Returns m.
+
+	Does not throw exceptions.
+*/
+fz_matrix *fz_scale(fz_matrix *m, float sx, float sy);
+
+/*
+	fz_pre_scale: Scale a matrix by premultiplication.
+
+	m: Pointer to the matrix to scale
+
 	sx, sy: Scaling factors along the X- and Y-axes. A scaling
 	factor of 1.0 will not cause any scaling along the relevant
 	axis.
 
+	Returns m (updated).
+
 	Does not throw exceptions.
 */
-fz_matrix fz_scale(float sx, float sy);
+fz_matrix *fz_pre_scale(fz_matrix *m, float sx, float sy);
 
 /*
 	fz_shear: Create a shearing matrix.
 
 	The returned matrix is of the form [ 1 sy sx 1 0 0 ].
 
+	m: pointer to place to store returned matrix
+
+	sx, sy: Shearing factors. A shearing factor of 0.0 will not
+	cause any shearing along the relevant axis.
+
+	Returns m.
+
+	Does not throw exceptions.
+*/
+fz_matrix *fz_shear(fz_matrix *m, float sx, float sy);
+
+/*
+	fz_pre_shear: Premultiply a matrix with a shearing matrix.
+
+	The shearing matrix is of the form [ 1 sy sx 1 0 0 ].
+
+	m: pointer to matrix to premultiply
+
 	sx, sy: Shearing factors. A shearing factor of 0.0 will not
 	cause any shearing along the relevant axis.
 
+	Returns m (updated).
+
 	Does not throw exceptions.
 */
-fz_matrix fz_shear(float sx, float sy);
+fz_matrix *fz_pre_shear(fz_matrix *m, float sx, float sy);
 
 /*
 	fz_rotate: Create a rotation matrix.
@@ -865,36 +928,80 @@ fz_matrix fz_shear(float sx, float sy);
 	The returned matrix is of the form
 	[ cos(deg) sin(deg) -sin(deg) cos(deg) 0 0 ].
 
+	m: Pointer to place to store matrix
+
 	degrees: Degrees of counter clockwise rotation. Values less
 	than zero and greater than 360 are handled as expected.
 
+	Returns m.
+
 	Does not throw exceptions.
 */
-fz_matrix fz_rotate(float degrees);
+fz_matrix *fz_rotate(fz_matrix *m, float degrees);
+
+/*
+	fz_pre_rotate: Rotate a transformation by premultiplying.
+
+	The premultiplied matrix is of the form
+	[ cos(deg) sin(deg) -sin(deg) cos(deg) 0 0 ].
+
+	m: Pointer to matrix to premultiply.
+
+	degrees: Degrees of counter clockwise rotation. Values less
+	than zero and greater than 360 are handled as expected.
+
+	Returns m (updated).
+
+	Does not throw exceptions.
+*/
+fz_matrix *fz_pre_rotate(fz_matrix *m, float degrees);
 
 /*
 	fz_translate: Create a translation matrix.
 
 	The returned matrix is of the form [ 1 0 0 1 tx ty ].
 
+	m: A place to store the created matrix.
+
+	tx, ty: Translation distances along the X- and Y-axes. A
+	translation of 0 will not cause any translation along the
+	relevant axis.
+
+	Returns m.
+
+	Does not throw exceptions.
+*/
+fz_matrix *fz_translate(fz_matrix *m, float tx, float ty);
+
+/*
+	fz_pre_translate: Translate a matrix by premultiplication.
+
+	m: The matrix to translate
+
 	tx, ty: Translation distances along the X- and Y-axes. A
 	translation of 0 will not cause any translation along the
 	relevant axis.
 
+	Returns m.
+
 	Does not throw exceptions.
 */
-fz_matrix fz_translate(float tx, float ty);
+fz_matrix *fz_pre_translate(fz_matrix *m, float tx, float ty);
 
 /*
 	fz_invert_matrix: Create an inverse matrix.
 
+	inverse: Place to store inverse matrix.
+
 	matrix: Matrix to invert. A degenerate matrix, where the
 	determinant is equal to zero, can not be inverted and the
 	original matrix is returned instead.
 
+	Returns inverse.
+
 	Does not throw exceptions.
 */
-fz_matrix fz_invert_matrix(fz_matrix matrix);
+fz_matrix *fz_invert_matrix(fz_matrix *inverse, const fz_matrix *matrix);
 
 /*
 	fz_is_rectilinear: Check if a transformation is rectilinear.
@@ -906,54 +1013,71 @@ fz_matrix fz_invert_matrix(fz_matrix matrix);
 
 	Does not throw exceptions.
 */
-int fz_is_rectilinear(fz_matrix m);
+int fz_is_rectilinear(const fz_matrix *m);
 
 /*
 	fz_matrix_expansion: Calculate average scaling factor of matrix.
 */
-float fz_matrix_expansion(fz_matrix m); /* sumatrapdf */
+float fz_matrix_expansion(const fz_matrix *m); /* sumatrapdf */
 
 /*
 	fz_intersect_rect: Compute intersection of two rectangles.
 
-	Compute the largest axis-aligned rectangle that covers the
-	area covered by both given rectangles. If either rectangle is
-	empty then the intersection is also empty. If either rectangle
-	is infinite then the intersection is simply the non-infinite
-	rectangle. Should both rectangles be infinite, then the
-	intersection is also infinite.
+	Given two rectangles, update the first to be the smallest
+	axis-aligned rectangle that covers the area covered by both
+	given rectangles. If either rectangle is empty then the
+	intersection is also empty. If either rectangle is infinite
+	then the intersection is simply the non-infinite rectangle.
+	Should both rectangles be infinite, then the intersection is
+	also infinite.
 
 	Does not throw exceptions.
 */
-fz_rect fz_intersect_rect(fz_rect a, fz_rect b);
-fz_bbox fz_intersect_bbox(fz_bbox a, fz_bbox b);
+fz_rect *fz_intersect_rect(fz_rect *a, const fz_rect *b);
+
+/*
+	fz_intersect_bbox: Compute intersection of two bounding boxes.
+
+	Similar to fz_intersect_rect but operates on two bounding
+	boxes instead of two rectangles.
+
+	Does not throw exceptions.
+*/
+fz_bbox *fz_intersect_bbox(fz_bbox *a, const fz_bbox *b);
 
 /*
 	fz_union_rect: Compute union of two rectangles.
 
-	Compute the smallest axis-aligned rectangle that encompasses
-	both given rectangles. If either rectangle is infinite then
-	the union is also infinite. If either rectangle is empty then
-	the union is simply the non-empty rectangle. Should both
-	rectangles be empty, then the union is also empty.
+	Given two rectangles, update the first to be the smallest
+	axis-aligned rectangle that encompasses both given rectangles.
+	If either rectangle is infinite then the union is also infinite.
+	If either rectangle is empty then the union is simply the
+	non-empty rectangle. Should both rectangles be empty, then the
+	union is also empty.
 
 	Does not throw exceptions.
 */
-fz_rect fz_union_rect(fz_rect a, fz_rect b);
+fz_rect *fz_union_rect(fz_rect *a, const fz_rect *b);
 
 /*
 	fz_bbox_from_rect: Convert a rect into the minimal bounding box
 	that covers the rectangle.
 
+	bbox: Place to store the returned bbox.
+
+	rect: The rectangle to convert to a bbox.
+
 	Coordinates in a bounding box are integers, so rounding of the
 	rects coordinates takes place. The top left corner is rounded
 	upwards and left while the bottom right corner is rounded
 	downwards and to the right.
 
+	Returns bbox (updated).
+
 	Does not throw exceptions.
 */
 
-fz_bbox fz_bbox_from_rect(fz_rect rect);
+fz_bbox *fz_bbox_from_rect(fz_bbox *bbox, const fz_rect *rect);
 
 /*
 	fz_round_rect: Round rectangle coordinates.
@@ -963,7 +1087,7 @@ fz_bbox fz_bbox_from_rect(fz_rect rect);
 	upwards and left while the bottom right corner is rounded
 	downwards and to the right.
 
-	This differs from fz_bbox_from_rect, in that fz_rect_covering_rect
+	This differs from fz_bbox_from_rect, in that fz_bbox_from_rect
 	slavishly follows the numbers (i.e any slight over/under calculations
 	can cause whole extra pixels to be added). fz_round_rect
 	allows for a small amount of rounding error when calculating
@@ -971,26 +1095,48 @@ fz_bbox fz_bbox_from_rect(fz_rect rect);
 
 	Does not throw exceptions.
 */
-fz_bbox fz_round_rect(fz_rect rect);
+fz_bbox *fz_round_rect(fz_bbox *bbox, const fz_rect *rect);
 
-fz_rect fz_rect_from_bbox(fz_bbox rect);
+/*
+	fz_rect_from_bbox: Convert a bbox into a rect.
+
+	For our purposes, a rect can represent all the values we meet in
+	a bbox, so nothing can go wrong.
+
+	rect: A place to store the generated rectangle.
+
+	bbox: The bbox to convert.
+
+	Returns rect (updated).
+
+	Does not throw exceptions.
+*/
+fz_rect *fz_rect_from_bbox(fz_rect *rect, const fz_bbox *bbox);
 
 /*
 	fz_expand_rect: Expand a bbox by a given amount in all directions.
 
 	Does not throw exceptions.
 */
-fz_rect fz_expand_rect(fz_rect b, float expand);
+fz_rect *fz_expand_rect(fz_rect *b, float expand);
 
 /*
-	fz_translate_rect: Translate bounding box.
+	fz_translate_bbox: Translate bounding box.
 
 	Translate a bbox by a given x and y offset. Allows for overflow.
 
 	Does not throw exceptions.
 */
-fz_rect fz_translate_rect(fz_rect a, float xoff, float yoff);
-fz_bbox fz_translate_bbox(fz_bbox a, int xoff, int yoff);
+fz_bbox *fz_translate_bbox(fz_bbox *a, int xoff, int yoff);
+
+/*
+	fz_translate_rect: Translate rectangle.
+
+	Translate a rectangle by a given x and y offset. Allows for overflow.
+
+	Does not throw exceptions.
+*/
+fz_rect *fz_translate_rect(fz_rect *a, int xoff, int yoff);
 
 /*
 	fz_transform_point: Apply a transformation to a point.
@@ -999,9 +1145,13 @@ fz_bbox fz_translate_bbox(fz_bbox a, int xoff, int yoff);
 	fz_scale, fz_rotate and fz_translate for how to create a
 	matrix.
 
+	point: Pointer to point to update.
+
+	Returns transform (unchanged).
+
 	Does not throw exceptions.
 */
-fz_point fz_transform_point(fz_matrix transform, fz_point point);
+fz_point *fz_transform_point(fz_point *point, const fz_matrix *transform);
 
 /*
 	fz_transform_vector: Apply a transformation to a vector.
@@ -1010,9 +1160,11 @@ fz_point fz_transform_point(fz_matrix transform, fz_point point);
 	fz_scale and fz_rotate for how to create a matrix. Any
 	translation will be ignored.
 
+	vector: Pointer to vector to update.
+
 	Does not throw exceptions.
 */
-fz_point fz_transform_vector(fz_matrix transform, fz_point vector);
+fz_point *fz_transform_vector(fz_point *vector, const fz_matrix *transform);
 
 /*
 	fz_transform_rect: Apply a transform to a rectangle.
@@ -1031,7 +1183,7 @@ fz_point fz_transform_vector(fz_matrix transform, fz_point vector);
 
 	Does not throw exceptions.
 */
-fz_rect fz_transform_rect(fz_matrix transform, fz_rect rect);
+fz_rect *fz_transform_rect(fz_rect *rect, const fz_matrix *transform);
 
 /*
 	fz_buffer is a wrapper around a dynamically allocated array of bytes.
@@ -1263,7 +1415,7 @@ typedef struct fz_pixmap_s fz_pixmap;
 /*
 	fz_pixmap_bbox: Return the bounding box for a pixmap.
 */
-fz_bbox fz_pixmap_bbox(fz_context *ctx, fz_pixmap *pix);
+fz_bbox *fz_pixmap_bbox(fz_context *ctx, fz_pixmap *pix, fz_bbox *bbox);
 
 /*
 	fz_pixmap_width: Return the width of the pixmap in pixels.
@@ -1307,7 +1459,7 @@ fz_pixmap *fz_new_pixmap(fz_context *ctx, fz_colorspace *cs, int w, int h);
 	Returns a pointer to the new pixmap. Throws exception on failure to
 	allocate.
 */
-fz_pixmap *fz_new_pixmap_with_bbox(fz_context *ctx, fz_colorspace *colorspace, fz_bbox bbox);
+fz_pixmap *fz_new_pixmap_with_bbox(fz_context *ctx, fz_colorspace *colorspace, const fz_bbox *bbox);
 
 /*
 	fz_new_pixmap_with_data: Create a new pixmap, with it's origin at
@@ -1346,7 +1498,7 @@ fz_pixmap *fz_new_pixmap_with_data(fz_context *ctx, fz_colorspace *colorspace, i
 	Returns a pointer to the new pixmap. Throws exception on failure to
 	allocate.
 */
-fz_pixmap *fz_new_pixmap_with_bbox_and_data(fz_context *ctx, fz_colorspace *colorspace, fz_bbox rect, unsigned char *samples);
+fz_pixmap *fz_new_pixmap_with_bbox_and_data(fz_context *ctx, fz_colorspace *colorspace, const fz_bbox *rect, unsigned char *samples);
 
 /*
 	fz_keep_pixmap: Take a reference to a pixmap.
@@ -1414,7 +1566,7 @@ void fz_clear_pixmap_with_value(fz_context *ctx, fz_pixmap *pix, int value);
 
 	Does not throw exceptions.
 */
-void fz_clear_pixmap_rect_with_value(fz_context *ctx, fz_pixmap *pix, int value, fz_bbox r);
+void fz_clear_pixmap_rect_with_value(fz_context *ctx, fz_pixmap *pix, int value, const fz_bbox *r);
 
 /*
 	fz_clear_pixmap_with_value: Sets all components (including alpha) of
@@ -1441,7 +1593,7 @@ void fz_invert_pixmap(fz_context *ctx, fz_pixmap *pix);
 
 	Does not throw exceptions.
 */
-void fz_invert_pixmap_rect(fz_pixmap *image, fz_bbox rect);
+void fz_invert_pixmap_rect(fz_pixmap *image, const fz_bbox *rect);
 
 /*
 	fz_gamma_pixmap: Apply gamma correction to a pixmap. All components
@@ -1642,7 +1794,7 @@ fz_device *fz_new_draw_device(fz_context *ctx, fz_pixmap *dest);
 	clip: Bounding box to restrict any marking operations of the
 	draw device.
 */
-fz_device *fz_new_draw_device_with_bbox(fz_context *ctx, fz_pixmap *dest, fz_bbox clip);
+fz_device *fz_new_draw_device_with_bbox(fz_context *ctx, fz_pixmap *dest, const fz_bbox *clip);
 
 /*
 	Text extraction device: Used for searching, format conversion etc.
@@ -1781,7 +1933,7 @@ void fz_free_text_sheet(fz_context *ctx, fz_text_sheet *sheet);
 	The text page is filled out by the text device to contain the blocks,
 	lines and spans of text on the page.
 */
-fz_text_page *fz_new_text_page(fz_context *ctx, fz_rect mediabox);
+fz_text_page *fz_new_text_page(fz_context *ctx, const fz_rect *mediabox);
 void fz_free_text_page(fz_context *ctx, fz_text_page *page);
 
 typedef struct fz_output_s fz_output;
@@ -1967,7 +2119,7 @@ fz_device *fz_new_list_device(fz_context *ctx, fz_display_list *list);
 	progress information back to the caller. The fields inside
 	cookie are continually updated while the page is being run.
 */
-void fz_run_display_list(fz_display_list *list, fz_device *dev, fz_matrix ctm, fz_rect area, fz_cookie *cookie);
+void fz_run_display_list(fz_display_list *list, fz_device *dev, const fz_matrix *ctm, const fz_rect *area, fz_cookie *cookie);
 
 /*
 	fz_free_display_list: Frees a display list.
@@ -2126,7 +2278,7 @@ struct fz_link_s
 	fz_link *next;
 };
 
-fz_link *fz_new_link(fz_context *ctx, fz_rect bbox, fz_link_dest dest);
+fz_link *fz_new_link(fz_context *ctx, const fz_rect *bbox, fz_link_dest dest);
 fz_link *fz_keep_link(fz_context *ctx, fz_link *link);
 
 /*
@@ -2345,7 +2497,7 @@ fz_link *fz_load_links(fz_document *doc, fz_page *page);
 
 	Does not throw exceptions.
 */
-fz_rect fz_bound_page(fz_document *doc, fz_page *page);
+fz_rect *fz_bound_page(fz_document *doc, fz_page *page, fz_rect *rect);
 
 /*
 	fz_annot: opaque pointer to annotation details.
@@ -2371,7 +2523,7 @@ fz_annot *fz_next_annot(fz_document *doc, fz_annot *annot);
 
 	Does not throw exceptions.
 */
-fz_rect fz_bound_annot(fz_document *doc, fz_annot *annot);
+fz_rect *fz_bound_annot(fz_document *doc, fz_annot *annot, fz_rect *rect);
 
 /*
 	fz_run_page: Run a page through a device.
@@ -2392,7 +2544,7 @@ fz_rect fz_bound_annot(fz_document *doc, fz_annot *annot);
 	fields inside cookie are continually updated while the page is
 	rendering.
 */
-void fz_run_page(fz_document *doc, fz_page *page, fz_device *dev, fz_matrix transform, fz_cookie *cookie);
+void fz_run_page(fz_document *doc, fz_page *page, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie);
 
 /*
 	fz_run_page_contents: Run a page through a device. Just the main
@@ -2414,7 +2566,7 @@ void fz_run_page(fz_document *doc, fz_page *page, fz_device *dev, fz_matrix tran
 	fields inside cookie are continually updated while the page is
 	rendering.
 */
-void fz_run_page_contents(fz_document *doc, fz_page *page, fz_device *dev, fz_matrix transform, fz_cookie *cookie);
+void fz_run_page_contents(fz_document *doc, fz_page *page, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie);
 
 /*
 	fz_run_annot: Run an annotation through a device.
@@ -2437,7 +2589,7 @@ void fz_run_page_contents(fz_document *doc, fz_page *page, fz_device *dev, fz_ma
 	fields inside cookie are continually updated while the page is
 	rendering.
 */
-void fz_run_annot(fz_document *doc, fz_page *page, fz_annot *annot, fz_device *dev, fz_matrix transform, fz_cookie *cookie);
+void fz_run_annot(fz_document *doc, fz_page *page, fz_annot *annot, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie);
 
 /*
 	fz_free_page: Free a loaded page.
@@ -2677,9 +2829,9 @@ fz_widget *fz_next_widget(fz_interactive *idoc, fz_widget *previous);
 int fz_widget_get_type(fz_widget *widget);
 
 /*
-	fz_widget_bbox: get the bounding box of a widget.
+	fz_bound_widget: get the bounding box of a widget.
 */
-fz_rect fz_widget_bbox(fz_widget *widget);
+fz_rect *fz_bound_widget(fz_widget *widget, fz_rect *);
 
 /*
 	fz_text_widget_text: Get the text currently displayed in
diff --git a/fitz/image_save.c b/fitz/image_save.c
index 95be1cd3..4f006f18 100644
--- a/fitz/image_save.c
+++ b/fitz/image_save.c
@@ -10,7 +10,8 @@ void fz_write_pixmap(fz_context *ctx, fz_pixmap *img, char *file, int rgb)
 
 	if (rgb && img->colorspace && img->colorspace != fz_device_rgb)
 	{
-		converted = fz_new_pixmap_with_bbox(ctx, fz_device_rgb, fz_pixmap_bbox(ctx, img));
+		fz_bbox bbox;
+		converted = fz_new_pixmap_with_bbox(ctx, fz_device_rgb, fz_pixmap_bbox(ctx, img, &bbox));
 		fz_convert_pixmap(ctx, converted, img);
 		img = converted;
 	}
diff --git a/fitz/res_font.c b/fitz/res_font.c
index 3638c476..e4882640 100644
--- a/fitz/res_font.c
+++ b/fitz/res_font.c
@@ -321,8 +321,8 @@ fz_new_font_from_memory(fz_context *ctx, char *name, unsigned char *data, int le
 	return font;
 }
 
-static fz_matrix
-fz_adjust_ft_glyph_width(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
+static fz_matrix *
+fz_adjust_ft_glyph_width(fz_context *ctx, fz_font *font, int gid, fz_matrix *trm)
 {
 	/* Fudge the font matrix to stretch the glyph if we've substituted the font. */
 	if (font->ft_substitute && font->width_table && gid < font->width_count)
@@ -351,7 +351,7 @@ fz_adjust_ft_glyph_width(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
 		else
 			scale = 1;
 
-		return fz_concat(fz_scale(scale, 1), trm);
+		fz_pre_scale(trm, scale, 1);
 	}
 
 	return trm;
@@ -402,20 +402,21 @@ fz_copy_ft_bitmap(fz_context *ctx, int left, int top, FT_Bitmap *bitmap)
 
 /* The glyph cache lock is always taken when this is called. */
 fz_pixmap *
-fz_render_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, int aa)
+fz_render_ft_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm, int aa)
 {
 	FT_Face face = font->ft_face;
 	FT_Matrix m;
 	FT_Vector v;
 	FT_Error fterr;
 	fz_pixmap *result;
+	fz_matrix local_trm = *trm;
 
 	float strength = fz_matrix_expansion(trm) * 0.02f;
 
-	trm = fz_adjust_ft_glyph_width(ctx, font, gid, trm);
+	fz_adjust_ft_glyph_width(ctx, font, gid, &local_trm);
 
 	if (font->ft_italic)
-		trm = fz_concat(fz_shear(SHEAR, 0), trm);
+		fz_pre_shear(&local_trm, SHEAR, 0);
 
 	/*
 	Freetype mutilates complex glyphs if they are loaded
@@ -425,12 +426,12 @@ fz_render_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, int a
 	into FT_Set_Char_Size instead
 	*/
 
-	m.xx = trm.a * 64; /* should be 65536 */
-	m.yx = trm.b * 64;
-	m.xy = trm.c * 64;
-	m.yy = trm.d * 64;
-	v.x = trm.e * 64;
-	v.y = trm.f * 64;
+	m.xx = local_trm.a * 64; /* should be 65536 */
+	m.yx = local_trm.b * 64;
+	m.xy = local_trm.c * 64;
+	m.yy = local_trm.d * 64;
+	v.x = local_trm.e * 64;
+	v.y = local_trm.f * 64;
 
 	fz_lock(ctx, FZ_LOCK_FREETYPE);
 	fterr = FT_Set_Char_Size(face, 65536, 65536, 72, 72); /* should be 64, 64 */
@@ -441,11 +442,11 @@ fz_render_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, int a
 	if (aa == 0)
 	{
 		/* enable grid fitting for non-antialiased rendering */
-		float scale = fz_matrix_expansion(trm);
-		m.xx = trm.a * 65536 / scale;
-		m.xy = trm.b * 65536 / scale;
-		m.yx = trm.c * 65536 / scale;
-		m.yy = trm.d * 65536 / scale;
+		float scale = fz_matrix_expansion(&local_trm);
+		m.xx = local_trm.a * 65536 / scale;
+		m.xy = local_trm.b * 65536 / scale;
+		m.yx = local_trm.c * 65536 / scale;
+		m.yy = local_trm.d * 65536 / scale;
 		v.x = 0;
 		v.y = 0;
 
@@ -506,7 +507,7 @@ retry_unhinted:
 }
 
 fz_pixmap *
-fz_render_ft_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz_stroke_state *state)
+fz_render_ft_stroked_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm, const fz_matrix *ctm, fz_stroke_state *state)
 {
 	FT_Face face = font->ft_face;
 	float expansion = fz_matrix_expansion(ctm);
@@ -519,18 +520,19 @@ fz_render_ft_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix tr
 	FT_BitmapGlyph bitmap;
 	fz_pixmap *pixmap;
 	FT_Stroker_LineJoin line_join;
+	fz_matrix local_trm = *trm;
 
-	trm = fz_adjust_ft_glyph_width(ctx, font, gid, trm);
+	fz_adjust_ft_glyph_width(ctx, font, gid, &local_trm);
 
 	if (font->ft_italic)
-		trm = fz_concat(fz_shear(SHEAR, 0), trm);
+		fz_pre_shear(&local_trm, SHEAR, 0);
 
-	m.xx = trm.a * 64; /* should be 65536 */
-	m.yx = trm.b * 64;
-	m.xy = trm.c * 64;
-	m.yy = trm.d * 64;
-	v.x = trm.e * 64;
-	v.y = trm.f * 64;
+	m.xx = local_trm.a * 64; /* should be 65536 */
+	m.yx = local_trm.b * 64;
+	m.xy = local_trm.c * 64;
+	m.yy = local_trm.d * 64;
+	v.x = local_trm.e * 64;
+	v.y = local_trm.f * 64;
 
 	fz_lock(ctx, FZ_LOCK_FREETYPE);
 	fterr = FT_Set_Char_Size(face, 65536, 65536, 72, 72); /* should be 64, 64 */
@@ -614,32 +616,32 @@ fz_render_ft_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix tr
 	return pixmap;
 }
 
-static fz_rect
-fz_bound_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
+static fz_rect *
+fz_bound_ft_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm, fz_rect *bounds)
 {
 	FT_Face face = font->ft_face;
 	FT_Error fterr;
 	FT_BBox cbox;
 	FT_Matrix m;
 	FT_Vector v;
-	fz_rect bounds;
 
 	// TODO: refactor loading into fz_load_ft_glyph
 	// TODO: cache results
 
 	float strength = fz_matrix_expansion(trm) * 0.02f;
+	fz_matrix local_trm = *trm;
 
-	trm = fz_adjust_ft_glyph_width(ctx, font, gid, trm);
+	fz_adjust_ft_glyph_width(ctx, font, gid, &local_trm);
 
 	if (font->ft_italic)
-		trm = fz_concat(fz_shear(SHEAR, 0), trm);
+		fz_pre_shear(&local_trm, SHEAR, 0);
 
-	m.xx = trm.a * 64; /* should be 65536 */
-	m.yx = trm.b * 64;
-	m.xy = trm.c * 64;
-	m.yy = trm.d * 64;
-	v.x = trm.e * 64;
-	v.y = trm.f * 64;
+	m.xx = local_trm.a * 64; /* should be 65536 */
+	m.yx = local_trm.b * 64;
+	m.xy = local_trm.c * 64;
+	m.yy = local_trm.d * 64;
+	v.x = local_trm.e * 64;
+	v.y = local_trm.f * 64;
 
 	fz_lock(ctx, FZ_LOCK_FREETYPE);
 	fterr = FT_Set_Char_Size(face, 65536, 65536, 72, 72); /* should be 64, 64 */
@@ -652,8 +654,8 @@ fz_bound_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
 	{
 		fz_warn(ctx, "freetype load glyph (gid %d): %s", gid, ft_error_string(fterr));
 		fz_unlock(ctx, FZ_LOCK_FREETYPE);
-		bounds.x0 = bounds.x1 = trm.e;
-		bounds.y0 = bounds.y1 = trm.f;
+		bounds->x0 = bounds->x1 = local_trm.e;
+		bounds->y0 = bounds->y1 = local_trm.f;
 		return bounds;
 	}
 
@@ -665,15 +667,15 @@ fz_bound_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
 
 	FT_Outline_Get_CBox(&face->glyph->outline, &cbox);
 	fz_unlock(ctx, FZ_LOCK_FREETYPE);
-	bounds.x0 = cbox.xMin / 64.0f;
-	bounds.y0 = cbox.yMin / 64.0f;
-	bounds.x1 = cbox.xMax / 64.0f;
-	bounds.y1 = cbox.yMax / 64.0f;
+	bounds->x0 = cbox.xMin / 64.0f;
+	bounds->y0 = cbox.yMin / 64.0f;
+	bounds->x1 = cbox.xMax / 64.0f;
+	bounds->y1 = cbox.yMax / 64.0f;
 
 	if (fz_is_empty_rect(bounds))
 	{
-		bounds.x0 = bounds.x1 = trm.e;
-		bounds.y0 = bounds.y1 = trm.f;
+		bounds->x0 = bounds->x1 = local_trm.e;
+		bounds->y0 = bounds->y1 = local_trm.f;
 	}
 
 	return bounds;
@@ -743,25 +745,26 @@ static const FT_Outline_Funcs outline_funcs = {
 };
 
 fz_path *
-fz_outline_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
+fz_outline_ft_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm)
 {
 	struct closure cc;
 	FT_Face face = font->ft_face;
 	FT_Matrix m;
 	FT_Vector v;
 	int fterr;
+	fz_matrix local_trm = *trm;
 
 	float strength = fz_matrix_expansion(trm) * 0.02f;
 
-	trm = fz_adjust_ft_glyph_width(ctx, font, gid, trm);
+	fz_adjust_ft_glyph_width(ctx, font, gid, &local_trm);
 
 	if (font->ft_italic)
-		trm = fz_concat(fz_shear(SHEAR, 0), trm);
+		fz_pre_shear(&local_trm, SHEAR, 0);
 
-	m.xx = trm.a * 64; /* should be 65536 */
-	m.yx = trm.b * 64;
-	m.xy = trm.c * 64;
-	m.yy = trm.d * 64;
+	m.xx = local_trm.a * 64; /* should be 65536 */
+	m.yx = local_trm.b * 64;
+	m.xy = local_trm.c * 64;
+	m.yy = local_trm.d * 64;
 	v.x = 0;
 	v.y = 0;
 
@@ -790,8 +793,8 @@ fz_outline_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
 	{
 		cc.ctx = ctx;
 		cc.path = fz_new_path(ctx);
-		cc.x = trm.e;
-		cc.y = trm.f;
+		cc.x = local_trm.e;
+		cc.y = local_trm.f;
 		fz_moveto(ctx, cc.path, cc.x, cc.y);
 		FT_Outline_Decompose(&face->glyph->outline, &outline_funcs, &cc);
 		fz_closepath(ctx, cc.path);
@@ -814,7 +817,7 @@ fz_outline_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
  */
 
 fz_font *
-fz_new_type3_font(fz_context *ctx, char *name, fz_matrix matrix)
+fz_new_type3_font(fz_context *ctx, char *name, const fz_matrix *matrix)
 {
 	fz_font *font;
 	int i;
@@ -825,7 +828,7 @@ fz_new_type3_font(fz_context *ctx, char *name, fz_matrix matrix)
 	font->t3widths = fz_malloc_array(ctx, 256, sizeof(float));
 	font->t3flags = fz_malloc_array(ctx, 256, sizeof(char));
 
-	font->t3matrix = matrix;
+	font->t3matrix = *matrix;
 	for (i = 0; i < 256; i++)
 	{
 		font->t3procs[i] = NULL;
@@ -861,28 +864,30 @@ fz_prepare_t3_glyph(fz_context *ctx, fz_font *font, int gid, int nested_depth)
 			FZ_DEVFLAG_LINEJOIN_UNDEFINED |
 			FZ_DEVFLAG_MITERLIMIT_UNDEFINED |
 			FZ_DEVFLAG_LINEWIDTH_UNDEFINED;
-	font->t3run(font->t3doc, font->t3resources, contents, dev, fz_identity, NULL, 0);
+	font->t3run(font->t3doc, font->t3resources, contents, dev, &fz_identity, NULL, 0);
 	font->t3flags[gid] = dev->flags;
 	fz_free_device(dev);
 }
 
-static fz_rect
-fz_bound_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
+static fz_rect *
+fz_bound_t3_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm, fz_rect *bounds)
 {
 	fz_display_list *list;
 	fz_matrix ctm;
-	fz_rect bounds;
 	fz_device *dev;
 
 	list = font->t3lists[gid];
 	if (!list)
-		return fz_transform_rect(trm, fz_empty_rect);
+	{
+		*bounds = fz_empty_rect;
+		return fz_transform_rect(bounds, trm);
+	}
 
-	ctm = fz_concat(font->t3matrix, trm);
-	dev = fz_new_bbox_device(ctx, &bounds);
+	fz_concat(&ctm, &font->t3matrix, trm);
+	dev = fz_new_bbox_device(ctx, bounds);
 	fz_try(ctx)
 	{
-		fz_run_display_list(list, dev, ctm, fz_infinite_rect, NULL);
+		fz_run_display_list(list, dev, &ctm, &fz_infinite_rect, NULL);
 	}
 	fz_always(ctx)
 	{
@@ -897,7 +902,7 @@ fz_bound_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
 }
 
 fz_pixmap *
-fz_render_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_colorspace *model, fz_bbox scissor)
+fz_render_t3_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm, fz_colorspace *model, fz_bbox scissor)
 {
 	fz_display_list *list;
 	fz_matrix ctm;
@@ -931,17 +936,16 @@ fz_render_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_co
 		model = NULL; /* Treat as masked */
 	}
 
-	bounds = fz_bound_glyph(ctx, font, gid, trm);
-	bounds = fz_expand_rect(bounds, 1);
-	bbox = fz_bbox_from_rect(bounds);
-	bbox = fz_intersect_bbox(bbox, scissor);
+	fz_expand_rect(fz_bound_glyph(ctx, font, gid, trm, &bounds), 1);
+	fz_bbox_from_rect(&bbox, &bounds);
+	fz_intersect_bbox(&bbox, &scissor);
 
-	glyph = fz_new_pixmap_with_bbox(ctx, model ? model : fz_device_gray, bbox);
+	glyph = fz_new_pixmap_with_bbox(ctx, model ? model : fz_device_gray, &bbox);
 	fz_clear_pixmap(ctx, glyph);
 
-	ctm = fz_concat(font->t3matrix, trm);
+	fz_concat(&ctm, &font->t3matrix, trm);
 	dev = fz_new_draw_device_type3(ctx, glyph);
-	fz_run_display_list(list, dev, ctm, fz_infinite_rect, NULL);
+	fz_run_display_list(list, dev, &ctm, &fz_infinite_rect, NULL);
 	fz_free_device(dev);
 
 	if (!model)
@@ -956,7 +960,7 @@ fz_render_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_co
 }
 
 void
-fz_render_t3_glyph_direct(fz_context *ctx, fz_device *dev, fz_font *font, int gid, fz_matrix trm, void *gstate, int nested_depth)
+fz_render_t3_glyph_direct(fz_context *ctx, fz_device *dev, fz_font *font, int gid, const fz_matrix *trm, void *gstate, int nested_depth)
 {
 	fz_matrix ctm;
 	void *contents;
@@ -981,8 +985,8 @@ fz_render_t3_glyph_direct(fz_context *ctx, fz_device *dev, fz_font *font, int gi
 		fz_warn(ctx, "type3 glyph doesn't specify masked or colored");
 	}
 
-	ctm = fz_concat(font->t3matrix, trm);
-	font->t3run(font->t3doc, font->t3resources, contents, dev, ctm, gstate, nested_depth);
+	fz_concat(&ctm, &font->t3matrix, trm);
+	font->t3run(font->t3doc, font->t3resources, contents, dev, &ctm, gstate, nested_depth);
 }
 
 #ifndef NDEBUG
@@ -1013,29 +1017,33 @@ fz_print_font(fz_context *ctx, FILE *out, fz_font *font)
 }
 #endif
 
-fz_rect
-fz_bound_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
+fz_rect *
+fz_bound_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm, fz_rect *rect)
 {
 	if (font->bbox_table && gid < font->bbox_count)
 	{
-		if (fz_is_infinite_rect(font->bbox_table[gid]))
+		if (fz_is_infinite_rect(&font->bbox_table[gid]))
 		{
 			if (font->ft_face)
-				font->bbox_table[gid] = fz_bound_ft_glyph(ctx, font, gid, fz_identity);
+				fz_bound_ft_glyph(ctx, font, gid, &fz_identity, &font->bbox_table[gid]);
 			else if (font->t3lists)
-				font->bbox_table[gid] = fz_bound_t3_glyph(ctx, font, gid, fz_identity);
+				fz_bound_t3_glyph(ctx, font, gid, &fz_identity, &font->bbox_table[gid]);
 			else
 				font->bbox_table[gid] = fz_empty_rect;
 		}
-		return fz_transform_rect(trm, font->bbox_table[gid]);
+		*rect = font->bbox_table[gid];
+	}
+	else
+	{
+		/* fall back to font bbox */
+		*rect = font->bbox;
 	}
 
-	/* fall back to font bbox */
-	return fz_transform_rect(trm, font->bbox);
+	return fz_transform_rect(rect, trm);
 }
 
 fz_path *
-fz_outline_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix ctm)
+fz_outline_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *ctm)
 {
 	if (!font->ft_face)
 	{
diff --git a/fitz/res_path.c b/fitz/res_path.c
index 0f18b482..8bb5d778 100644
--- a/fitz/res_path.c
+++ b/fitz/res_path.c
@@ -243,36 +243,41 @@ fz_closepath(fz_context *ctx, fz_path *path)
 	path->items[path->len++].k = FZ_CLOSE_PATH;
 }
 
-static inline fz_rect bound_expand(fz_rect r, fz_point p)
+static inline fz_rect *bound_expand(fz_rect *r, const fz_point *p)
 {
-	if (p.x < r.x0) r.x0 = p.x;
-	if (p.y < r.y0) r.y0 = p.y;
-	if (p.x > r.x1) r.x1 = p.x;
-	if (p.y > r.y1) r.y1 = p.y;
+	if (p->x < r->x0) r->x0 = p->x;
+	if (p->y < r->y0) r->y0 = p->y;
+	if (p->x > r->x1) r->x1 = p->x;
+	if (p->y > r->y1) r->y1 = p->y;
 	return r;
 }
 
-fz_rect
-fz_bound_path(fz_context *ctx, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm)
+fz_rect *
+fz_bound_path(fz_context *ctx, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, fz_rect *r)
 {
 	fz_point p;
-	fz_rect r;
 	int i = 0;
 
 	/* If the path is empty, return the empty rectangle here - don't wait
 	 * for it to be expanded in the stroked case below. */
 	if (path->len == 0)
-		return fz_empty_rect;
+	{
+		*r = fz_empty_rect;
+		return r;
+	}
 	/* A path must start with a moveto - and if that's all there is
 	 * then the path is empty. */
 	if (path->len == 3)
-		return fz_empty_rect;
+	{
+		*r = fz_empty_rect;
+		return r;
+	}
 
 	p.x = path->items[1].v;
 	p.y = path->items[2].v;
-	p = fz_transform_point(ctm, p);
-	r.x0 = r.x1 = p.x;
-	r.y0 = r.y1 = p.y;
+	fz_transform_point(&p, ctm);
+	r->x0 = r->x1 = p.x;
+	r->y0 = r->y1 = p.y;
 
 	while (i < path->len)
 	{
@@ -281,13 +286,13 @@ fz_bound_path(fz_context *ctx, fz_path *path, fz_stroke_state *stroke, fz_matrix
 		case FZ_CURVETO:
 			p.x = path->items[i++].v;
 			p.y = path->items[i++].v;
-			r = bound_expand(r, fz_transform_point(ctm, p));
+			bound_expand(r, fz_transform_point(&p, ctm));
 			p.x = path->items[i++].v;
 			p.y = path->items[i++].v;
-			r = bound_expand(r, fz_transform_point(ctm, p));
+			bound_expand(r, fz_transform_point(&p, ctm));
 			p.x = path->items[i++].v;
 			p.y = path->items[i++].v;
-			r = bound_expand(r, fz_transform_point(ctm, p));
+			bound_expand(r, fz_transform_point(&p, ctm));
 			break;
 		case FZ_MOVETO:
 			if (i + 2 == path->len)
@@ -300,7 +305,7 @@ fz_bound_path(fz_context *ctx, fz_path *path, fz_stroke_state *stroke, fz_matrix
 		case FZ_LINETO:
 			p.x = path->items[i++].v;
 			p.y = path->items[i++].v;
-			r = bound_expand(r, fz_transform_point(ctm, p));
+			bound_expand(r, fz_transform_point(&p, ctm));
 			break;
 		case FZ_CLOSE_PATH:
 			break;
@@ -309,14 +314,14 @@ fz_bound_path(fz_context *ctx, fz_path *path, fz_stroke_state *stroke, fz_matrix
 
 	if (stroke)
 	{
-		r = fz_adjust_rect_for_stroke(r, stroke, ctm);
+		fz_adjust_rect_for_stroke(r, stroke, ctm);
 	}
 
 	return r;
 }
 
-fz_rect
-fz_adjust_rect_for_stroke(fz_rect r, fz_stroke_state *stroke, fz_matrix ctm)
+fz_rect *
+fz_adjust_rect_for_stroke(fz_rect *r, fz_stroke_state *stroke, const fz_matrix *ctm)
 {
 	float expand;
 
@@ -330,17 +335,16 @@ fz_adjust_rect_for_stroke(fz_rect r, fz_stroke_state *stroke, fz_matrix ctm)
 	if ((stroke->linejoin == FZ_LINEJOIN_MITER || stroke->linejoin == FZ_LINEJOIN_MITER_XPS) && stroke->miterlimit > 1)
 		expand *= stroke->miterlimit;
 
-	r.x0 -= expand;
-	r.y0 -= expand;
-	r.x1 += expand;
-	r.y1 += expand;
+	r->x0 -= expand;
+	r->y0 -= expand;
+	r->x1 += expand;
+	r->y1 += expand;
 	return r;
 }
 
 void
-fz_transform_path(fz_context *ctx, fz_path *path, fz_matrix ctm)
+fz_transform_path(fz_context *ctx, fz_path *path, const fz_matrix *ctm)
 {
-	fz_point p;
 	int k, i = 0;
 
 	while (i < path->len)
@@ -350,21 +354,13 @@ fz_transform_path(fz_context *ctx, fz_path *path, fz_matrix ctm)
 		case FZ_CURVETO:
 			for (k = 0; k < 3; k++)
 			{
-				p.x = path->items[i].v;
-				p.y = path->items[i+1].v;
-				p = fz_transform_point(ctm, p);
-				path->items[i].v = p.x;
-				path->items[i+1].v = p.y;
+				fz_transform_point((fz_point *)(void *)&path->items[i].v, ctm);
 				i += 2;
 			}
 			break;
 		case FZ_MOVETO:
 		case FZ_LINETO:
-			p.x = path->items[i].v;
-			p.y = path->items[i+1].v;
-			p = fz_transform_point(ctm, p);
-			path->items[i].v = p.x;
-			path->items[i+1].v = p.y;
+			fz_transform_point((fz_point *)(void *)&path->items[i].v, ctm);
 			i += 2;
 			break;
 		case FZ_CLOSE_PATH:
diff --git a/fitz/res_pixmap.c b/fitz/res_pixmap.c
index c498f974..53d0116a 100644
--- a/fitz/res_pixmap.c
+++ b/fitz/res_pixmap.c
@@ -83,42 +83,41 @@ fz_new_pixmap(fz_context *ctx, fz_colorspace *colorspace, int w, int h)
 }
 
 fz_pixmap *
-fz_new_pixmap_with_bbox(fz_context *ctx, fz_colorspace *colorspace, fz_bbox r)
+fz_new_pixmap_with_bbox(fz_context *ctx, fz_colorspace *colorspace, const fz_bbox *r)
 {
-	fz_pixmap *pixmap = fz_new_pixmap(ctx, colorspace, r.x1 - r.x0, r.y1 - r.y0);
-	pixmap->x = r.x0;
-	pixmap->y = r.y0;
+	fz_pixmap *pixmap;
+	pixmap = fz_new_pixmap(ctx, colorspace, r->x1 - r->x0, r->y1 - r->y0);
+	pixmap->x = r->x0;
+	pixmap->y = r->y0;
 	return pixmap;
 }
 
 fz_pixmap *
-fz_new_pixmap_with_bbox_and_data(fz_context *ctx, fz_colorspace *colorspace, fz_bbox r, unsigned char *samples)
+fz_new_pixmap_with_bbox_and_data(fz_context *ctx, fz_colorspace *colorspace, const fz_bbox *r, unsigned char *samples)
 {
-	fz_pixmap *pixmap = fz_new_pixmap_with_data(ctx, colorspace, r.x1 - r.x0, r.y1 - r.y0, samples);
-	pixmap->x = r.x0;
-	pixmap->y = r.y0;
+	fz_pixmap *pixmap = fz_new_pixmap_with_data(ctx, colorspace, r->x1 - r->x0, r->y1 - r->y0, samples);
+	pixmap->x = r->x0;
+	pixmap->y = r->y0;
 	return pixmap;
 }
 
-fz_bbox
-fz_pixmap_bbox(fz_context *ctx, fz_pixmap *pix)
+fz_bbox *
+fz_pixmap_bbox(fz_context *ctx, fz_pixmap *pix, fz_bbox *bbox)
 {
-	fz_bbox bbox;
-	bbox.x0 = pix->x;
-	bbox.y0 = pix->y;
-	bbox.x1 = pix->x + pix->w;
-	bbox.y1 = pix->y + pix->h;
+	bbox->x0 = pix->x;
+	bbox->y0 = pix->y;
+	bbox->x1 = pix->x + pix->w;
+	bbox->y1 = pix->y + pix->h;
 	return bbox;
 }
 
-fz_bbox
-fz_pixmap_bbox_no_ctx(fz_pixmap *pix)
+fz_bbox *
+fz_pixmap_bbox_no_ctx(fz_pixmap *pix, fz_bbox *bbox)
 {
-	fz_bbox bbox;
-	bbox.x0 = pix->x;
-	bbox.y0 = pix->y;
-	bbox.x1 = pix->x + pix->w;
-	bbox.y1 = pix->y + pix->h;
+	bbox->x0 = pix->x;
+	bbox->y0 = pix->y;
+	bbox->x1 = pix->x + pix->w;
+	bbox->y1 = pix->y + pix->h;
 	return bbox;
 }
 
@@ -164,23 +163,25 @@ fz_clear_pixmap_with_value(fz_context *ctx, fz_pixmap *pix, int value)
 }
 
 void
-fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, fz_bbox r)
+fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, const fz_bbox *b)
 {
 	const unsigned char *srcp;
 	unsigned char *destp;
 	int x, y, w, destspan, srcspan;
+	fz_bbox local_b, bb;
 
-	r = fz_intersect_bbox(r, fz_pixmap_bbox(ctx, dest));
-	r = fz_intersect_bbox(r, fz_pixmap_bbox(ctx, src));
-	w = r.x1 - r.x0;
-	y = r.y1 - r.y0;
+	local_b = *b;
+	fz_intersect_bbox(&local_b, fz_pixmap_bbox(ctx, dest, &bb));
+	fz_intersect_bbox(&local_b, fz_pixmap_bbox(ctx, src, &bb));
+	w = local_b.x1 - local_b.x0;
+	y = local_b.y1 - local_b.y0;
 	if (w <= 0 || y <= 0)
 		return;
 
 	srcspan = src->w * src->n;
-	srcp = src->samples + (unsigned int)(srcspan * (r.y0 - src->y) + src->n * (r.x0 - src->x));
+	srcp = src->samples + (unsigned int)(srcspan * (local_b.y0 - src->y) + src->n * (local_b.x0 - src->x));
 	destspan = dest->w * dest->n;
-	destp = dest->samples + (unsigned int)(destspan * (r.y0 - dest->y) + dest->n * (r.x0 - dest->x));
+	destp = dest->samples + (unsigned int)(destspan * (local_b.y0 - dest->y) + dest->n * (local_b.x0 - dest->x));
 
 	if (src->n == dest->n)
 	{
@@ -264,19 +265,21 @@ fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, fz_bbox r)
 }
 
 void
-fz_clear_pixmap_rect_with_value(fz_context *ctx, fz_pixmap *dest, int value, fz_bbox r)
+fz_clear_pixmap_rect_with_value(fz_context *ctx, fz_pixmap *dest, int value, const fz_bbox *b)
 {
 	unsigned char *destp;
 	int x, y, w, k, destspan;
+	fz_bbox bb;
+	fz_bbox local_b = *b;
 
-	r = fz_intersect_bbox(r, fz_pixmap_bbox(ctx, dest));
-	w = r.x1 - r.x0;
-	y = r.y1 - r.y0;
+	fz_intersect_bbox(&local_b, fz_pixmap_bbox(ctx, dest, &bb));
+	w = local_b.x1 - local_b.x0;
+	y = local_b.y1 - local_b.y0;
 	if (w <= 0 || y <= 0)
 		return;
 
 	destspan = dest->w * dest->n;
-	destp = dest->samples + (unsigned int)(destspan * (r.y0 - dest->y) + dest->n * (r.x0 - dest->x));
+	destp = dest->samples + (unsigned int)(destspan * (local_b.y0 - dest->y) + dest->n * (local_b.x0 - dest->x));
 	if (value == 255)
 		do
 		{
@@ -344,10 +347,11 @@ fz_alpha_from_gray(fz_context *ctx, fz_pixmap *gray, int luminosity)
 	fz_pixmap *alpha;
 	unsigned char *sp, *dp;
 	int len;
+	fz_bbox bbox;
 
 	assert(gray->n == 2);
 
-	alpha = fz_new_pixmap_with_bbox(ctx, NULL, fz_pixmap_bbox(ctx, gray));
+	alpha = fz_new_pixmap_with_bbox(ctx, NULL, fz_pixmap_bbox(ctx, gray, &bbox));
 	dp = alpha->samples;
 	sp = gray->samples;
 	if (!luminosity)
@@ -380,16 +384,15 @@ fz_invert_pixmap(fz_context *ctx, fz_pixmap *pix)
 	}
 }
 
-void fz_invert_pixmap_rect(fz_pixmap *image, fz_bbox r)
+void fz_invert_pixmap_rect(fz_pixmap *image, const fz_bbox *rect)
 {
 	unsigned char *p;
-	int x0, x1, y0, y1;
 	int x, y, n;
 
-	x0 = fz_clampi(r.x0 - image->x, 0, image->w - 1);
-	x1 = fz_clampi(r.x1 - image->x, 0, image->w - 1);
-	y0 = fz_clampi(r.y0 - image->y, 0, image->h - 1);
-	y1 = fz_clampi(r.y1 - image->y, 0, image->h - 1);
+	int x0 = fz_clampi(rect->x0 - image->x, 0, image->w - 1);
+	int x1 = fz_clampi(rect->x1 - image->x, 0, image->w - 1);
+	int y0 = fz_clampi(rect->y0 - image->y, 0, image->h - 1);
+	int y1 = fz_clampi(rect->y1 - image->y, 0, image->h - 1);
 
 	for (y = y0; y < y1; y++)
 	{
diff --git a/fitz/res_shade.c b/fitz/res_shade.c
index 15f631da..1d09c354 100644
--- a/fitz/res_shade.c
+++ b/fitz/res_shade.c
@@ -16,7 +16,7 @@ paint_quad(fz_mesh_processor *painter, fz_vertex *v0, fz_vertex *v1, fz_vertex *
 }
 
 static void
-fz_mesh_type1_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_processor *painter)
+fz_mesh_type1_process(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter)
 {
 	float *p = shade->u.f.fn_vals;
 	int xdivs = shade->u.f.xdivs;
@@ -31,8 +31,9 @@ fz_mesh_type1_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_p
 	fz_vertex *v = vs[0];
 	fz_vertex *vn = vs[1];
 	int n = shade->colorspace->n;
+	fz_matrix local_ctm;
 
-	ctm = fz_concat(shade->u.f.matrix, ctm);
+	fz_concat(&local_ctm, &shade->u.f.matrix, ctm);
 
 	y = y0;
 	for (yy = 0; yy < ydivs; yy++)
@@ -41,22 +42,22 @@ fz_mesh_type1_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_p
 
 		x = x0;
 		v[0].p.x = x; v[0].p.y = y;
-		v[0].p = fz_transform_point(ctm, v[0].p);
+		fz_transform_point(&v[0].p, &local_ctm);
 		memcpy(v[0].c, p, n*sizeof(float));
 		p += n;
 		v[1].p.x = x; v[1].p.y = yn;
-		v[1].p = fz_transform_point(ctm, v[1].p);
+		fz_transform_point(&v[1].p, &local_ctm);
 		memcpy(v[1].c, p + xdivs*n, n*sizeof(float));
 		for (xx = 0; xx < xdivs; xx++)
 		{
 			x = x0 + (x1 - x0) * (xx + 1) / xdivs;
 
 			vn[0].p.x = x; vn[0].p.y = y;
-			vn[0].p = fz_transform_point(ctm, vn[0].p);
+			fz_transform_point(&vn[0].p, &local_ctm);
 			memcpy(vn[0].c, p, n*sizeof(float));
 			p += n;
 			vn[1].p.x = x; vn[1].p.y = yn;
-			vn[1].p = fz_transform_point(ctm, vn[1].p);
+			fz_transform_point(&vn[1].p, &local_ctm);
 			memcpy(vn[1].c, p + xdivs*n, n*sizeof(float));
 
 			paint_quad(painter, &v[0], &vn[0], &vn[1], &v[1]);
@@ -79,7 +80,7 @@ fz_point_on_circle(fz_point p, float r, float theta)
 }
 
 static void
-fz_mesh_type2_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_processor *painter)
+fz_mesh_type2_process(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter)
 {
 	fz_point p0, p1, dir;
 	fz_vertex v0, v1, v2, v3;
@@ -92,9 +93,9 @@ fz_mesh_type2_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_p
 	p1.y = shade->u.l_or_r.coords[1][1];
 	dir.x = p0.y - p1.y;
 	dir.y = p1.x - p0.x;
-	p0 = fz_transform_point(ctm, p0);
-	p1 = fz_transform_point(ctm, p1);
-	dir = fz_transform_vector(ctm, dir);
+	fz_transform_point(&p0, ctm);
+	fz_transform_point(&p1, ctm);
+	fz_transform_vector(&dir, ctm);
 	theta = atan2f(dir.y, dir.x);
 
 	v0.p = fz_point_on_circle(p0, HUGENUM, theta);
@@ -146,7 +147,7 @@ fz_mesh_type2_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_p
 #define RADSEGS 32 /* how many segments to generate for radial meshes */
 
 static void
-fz_paint_annulus(fz_matrix ctm,
+fz_paint_annulus(const fz_matrix *ctm,
 		fz_point p0, float r0, float c0,
 		fz_point p1, float r1, float c1,
 		fz_mesh_processor *painter)
@@ -169,14 +170,14 @@ fz_paint_annulus(fz_matrix ctm,
 		b2.p = fz_point_on_circle(p1, r1, theta - i * step);
 		b3.p = fz_point_on_circle(p1, r1, theta - i * step - step);
 
-		t0.p = fz_transform_point(ctm, t0.p);
-		t1.p = fz_transform_point(ctm, t1.p);
-		t2.p = fz_transform_point(ctm, t2.p);
-		t3.p = fz_transform_point(ctm, t3.p);
-		b0.p = fz_transform_point(ctm, b0.p);
-		b1.p = fz_transform_point(ctm, b1.p);
-		b2.p = fz_transform_point(ctm, b2.p);
-		b3.p = fz_transform_point(ctm, b3.p);
+		fz_transform_point(&t0.p, ctm);
+		fz_transform_point(&t1.p, ctm);
+		fz_transform_point(&t2.p, ctm);
+		fz_transform_point(&t3.p, ctm);
+		fz_transform_point(&b0.p, ctm);
+		fz_transform_point(&b1.p, ctm);
+		fz_transform_point(&b2.p, ctm);
+		fz_transform_point(&b3.p, ctm);
 
 		t0.c[0] = c0;
 		t1.c[0] = c0;
@@ -193,7 +194,7 @@ fz_paint_annulus(fz_matrix ctm,
 }
 
 static void
-fz_mesh_type3_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_processor *painter)
+fz_mesh_type3_process(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter)
 {
 	fz_point p0, p1;
 	float r0, r1;
@@ -247,7 +248,7 @@ static inline float read_sample(fz_stream *stream, int bits, float min, float ma
 }
 
 static void
-fz_mesh_type4_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_processor *painter)
+fz_mesh_type4_process(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter)
 {
 	fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer);
 	fz_vertex v[4];
@@ -274,7 +275,7 @@ fz_mesh_type4_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_p
 			flag = fz_read_bits(stream, bpflag);
 			vd->p.x = read_sample(stream, bpcoord, x0, x1);
 			vd->p.y = read_sample(stream, bpcoord, y0, y1);
-			vd->p = fz_transform_point(ctm, vd->p);
+			fz_transform_point(&vd->p, ctm);
 			for (i = 0; i < ncomp; i++)
 				vd->c[i] = read_sample(stream, bpcomp, c0[i], c1[i]);
 
@@ -286,14 +287,14 @@ fz_mesh_type4_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_p
 				fz_read_bits(stream, bpflag);
 				vb->p.x = read_sample(stream, bpcoord, x0, x1);
 				vb->p.y = read_sample(stream, bpcoord, y0, y1);
-				vb->p = fz_transform_point(ctm, vb->p);
+				fz_transform_point(&vb->p, ctm);
 				for (i = 0; i < ncomp; i++)
 					vb->c[i] = read_sample(stream, bpcomp, c0[i], c1[i]);
 
 				fz_read_bits(stream, bpflag);
 				vc->p.x = read_sample(stream, bpcoord, x0, x1);
 				vc->p.y = read_sample(stream, bpcoord, y0, y1);
-				vc->p = fz_transform_point(ctm, vc->p);
+				fz_transform_point(&vc->p, ctm);
 				for (i = 0; i < ncomp; i++)
 					vc->c[i] = read_sample(stream, bpcomp, c0[i], c1[i]);
 
@@ -326,7 +327,7 @@ fz_mesh_type4_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_p
 }
 
 static void
-fz_mesh_type5_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_processor *painter)
+fz_mesh_type5_process(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter)
 {
 	fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer);
 	fz_vertex *buf = NULL;
@@ -360,7 +361,7 @@ fz_mesh_type5_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_p
 			{
 				buf[i].p.x = read_sample(stream, bpcoord, x0, x1);
 				buf[i].p.y = read_sample(stream, bpcoord, y0, y1);
-				buf[i].p = fz_transform_point(ctm, buf[i].p);
+				fz_transform_point(&buf[i].p, ctm);
 				for (k = 0; k < ncomp; k++)
 					buf[i].c[k] = read_sample(stream, bpcomp, c0[k], c1[k]);
 			}
@@ -643,7 +644,7 @@ make_tensor_patch(tensor_patch *p, int type, fz_point *pt)
 #define SUBDIV 3 /* how many levels to subdivide patches */
 
 static void
-fz_mesh_type6_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_processor *painter)
+fz_mesh_type6_process(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter)
 {
 	fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer);
 	int haspatch, hasprevpatch;
@@ -690,7 +691,7 @@ fz_mesh_type6_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_p
 			{
 				v[i].x = read_sample(stream, bpcoord, x0, x1);
 				v[i].y = read_sample(stream, bpcoord, y0, y1);
-				v[i] = fz_transform_point(ctm, v[i]);
+				fz_transform_point(&v[i], ctm);
 			}
 
 			for (i = startcolor; i < 4; i++)
@@ -771,7 +772,7 @@ fz_mesh_type6_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_p
 }
 
 static void
-fz_mesh_type7_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_processor *painter)
+fz_mesh_type7_process(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter)
 {
 	fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer);
 	int bpflag = shade->u.m.bpflag;
@@ -818,7 +819,7 @@ fz_mesh_type7_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_p
 			{
 				v[i].x = read_sample(stream, bpcoord, x0, x1);
 				v[i].y = read_sample(stream, bpcoord, y0, y1);
-				v[i] = fz_transform_point(ctm, v[i]);
+				fz_transform_point(&v[i], ctm);
 			}
 
 			for (i = startcolor; i < 4; i++)
@@ -899,7 +900,7 @@ fz_mesh_type7_process(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_mesh_p
 }
 
 void
-fz_process_mesh(fz_context *ctx, fz_shade *shade, fz_matrix ctm,
+fz_process_mesh(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm,
 		fz_mesh_process_fn *process, void *process_arg)
 {
 	fz_mesh_processor painter;
@@ -988,24 +989,26 @@ bound_tri(void *arg, fz_vertex *v1, fz_vertex *v2, fz_vertex *v3)
 	if (v3->p.y > bmd->rect.y1) bmd->rect.y1 = v3->p.y;
 }
 
-fz_rect
-fz_bound_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm)
+fz_rect *
+fz_bound_shade(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_rect *s)
 {
-	fz_rect s;
+	fz_matrix local_ctm;
 	struct bound_mesh_data bmd;
 
-	ctm = fz_concat(shade->matrix, ctm);
-	s = fz_transform_rect(ctm, shade->bbox);
+	fz_concat(&local_ctm, &shade->matrix, ctm);
+	*s = shade->bbox;
+	fz_transform_rect(s, &local_ctm);
 	if (shade->type == FZ_LINEAR)
-		return fz_intersect_rect(s, fz_infinite_rect);
+		return s;
 	if (shade->type == FZ_RADIAL)
-		return fz_intersect_rect(s, fz_infinite_rect);
+		return s;
 
 	bmd.rect = fz_empty_rect;
 	bmd.first = 1;
-	fz_process_mesh(ctx, shade, ctm, &bound_tri, &bmd);
+	fz_process_mesh(ctx, shade, &local_ctm, &bound_tri, &bmd);
 
-	return fz_intersect_rect(s, bmd.rect);
+	fz_intersect_rect(s, &bmd.rect);
+	return s;
 }
 
 #ifndef NDEBUG
diff --git a/fitz/res_text.c b/fitz/res_text.c
index 2bef6d4a..09a658b1 100644
--- a/fitz/res_text.c
+++ b/fitz/res_text.c
@@ -1,13 +1,13 @@
 #include "fitz-internal.h"
 
 fz_text *
-fz_new_text(fz_context *ctx, fz_font *font, fz_matrix trm, int wmode)
+fz_new_text(fz_context *ctx, fz_font *font, const fz_matrix *trm, int wmode)
 {
 	fz_text *text;
 
 	text = fz_malloc_struct(ctx, fz_text);
 	text->font = fz_keep_font(ctx, font);
-	text->trm = trm;
+	text->trm = *trm;
 	text->wmode = wmode;
 	text->len = 0;
 	text->cap = 0;
@@ -52,16 +52,18 @@ fz_clone_text(fz_context *ctx, fz_text *old)
 	return text;
 }
 
-fz_rect
-fz_bound_text(fz_context *ctx, fz_text *text, fz_matrix ctm)
+fz_rect *
+fz_bound_text(fz_context *ctx, fz_text *text, const fz_matrix *ctm, fz_rect *bbox)
 {
 	fz_matrix tm, trm;
-	fz_rect bbox;
 	fz_rect gbox;
 	int i;
 
 	if (text->len == 0)
-		return fz_empty_rect;
+	{
+		*bbox = fz_empty_rect;
+		return bbox;
+	}
 
 	// TODO: stroke state
 
@@ -69,8 +71,8 @@ fz_bound_text(fz_context *ctx, fz_text *text, fz_matrix ctm)
 
 	tm.e = text->items[0].x;
 	tm.f = text->items[0].y;
-	trm = fz_concat(tm, ctm);
-	bbox = fz_bound_glyph(ctx, text->font, text->items[0].gid, trm);
+	fz_concat(&trm, &tm, ctm);
+	fz_bound_glyph(ctx, text->font, text->items[0].gid, &trm, bbox);
 
 	for (i = 1; i < text->len; i++)
 	{
@@ -78,21 +80,21 @@ fz_bound_text(fz_context *ctx, fz_text *text, fz_matrix ctm)
 		{
 			tm.e = text->items[i].x;
 			tm.f = text->items[i].y;
-			trm = fz_concat(tm, ctm);
-			gbox = fz_bound_glyph(ctx, text->font, text->items[i].gid, trm);
+			fz_concat(&trm, &tm, ctm);
+			fz_bound_glyph(ctx, text->font, text->items[i].gid, &trm, &gbox);
 
-			bbox.x0 = fz_min(bbox.x0, gbox.x0);
-			bbox.y0 = fz_min(bbox.y0, gbox.y0);
-			bbox.x1 = fz_max(bbox.x1, gbox.x1);
-			bbox.y1 = fz_max(bbox.y1, gbox.y1);
+			bbox->x0 = fz_min(bbox->x0, gbox.x0);
+			bbox->y0 = fz_min(bbox->y0, gbox.y0);
+			bbox->x1 = fz_max(bbox->x1, gbox.x1);
+			bbox->y1 = fz_max(bbox->y1, gbox.y1);
 		}
 	}
 
 	/* Compensate for the glyph cache limited positioning precision */
-	bbox.x0 -= 1;
-	bbox.y0 -= 1;
-	bbox.x1 += 1;
-	bbox.y1 += 1;
+	bbox->x0 -= 1;
+	bbox->y0 -= 1;
+	bbox->x1 += 1;
+	bbox->y1 += 1;
 
 	return bbox;
 }
diff --git a/pdf/mupdf-internal.h b/pdf/mupdf-internal.h
index 6ac228ef..0c070206 100644
--- a/pdf/mupdf-internal.h
+++ b/pdf/mupdf-internal.h
@@ -284,7 +284,7 @@ struct pdf_xobject_s
 };
 
 pdf_xobject *pdf_load_xobject(pdf_document *doc, pdf_obj *obj);
-pdf_obj *pdf_new_xobject(pdf_document *doc, fz_rect bbox, fz_matrix mat);
+pdf_obj *pdf_new_xobject(pdf_document *doc, const fz_rect *bbox, const fz_matrix *mat);
 pdf_xobject *pdf_keep_xobject(fz_context *ctx, pdf_xobject *xobj);
 void pdf_drop_xobject(fz_context *ctx, pdf_xobject *xobj);
 void pdf_update_xobject_contents(pdf_document *xref, pdf_xobject *form, fz_buffer *buffer);
@@ -485,7 +485,7 @@ void pdf_drop_font(fz_context *ctx, pdf_font_desc *font);
 void pdf_print_font(fz_context *ctx, pdf_font_desc *fontdesc);
 #endif
 
-fz_rect pdf_measure_text(fz_context *ctx, pdf_font_desc *fontdesc, unsigned char *buf, int len);
+fz_rect *pdf_measure_text(fz_context *ctx, pdf_font_desc *fontdesc, unsigned char *buf, int len, fz_rect *rect);
 float pdf_text_stride(fz_context *ctx, pdf_font_desc *fontdesc, float fontsize, unsigned char *buf, int len, float room, int *count);
 
 /*
@@ -512,7 +512,7 @@ pdf_obj *pdf_lookup_dest(pdf_document *doc, pdf_obj *needle);
 pdf_obj *pdf_lookup_name(pdf_document *doc, char *which, pdf_obj *needle);
 pdf_obj *pdf_load_name_tree(pdf_document *doc, char *which);
 
-fz_link *pdf_load_link_annots(pdf_document *, pdf_obj *annots, fz_matrix page_ctm);
+fz_link *pdf_load_link_annots(pdf_document *, pdf_obj *annots, const fz_matrix *page_ctm);
 
 pdf_annot *pdf_load_annots(pdf_document *, pdf_obj *annots, pdf_page *page);
 void pdf_update_annot(pdf_document *, pdf_annot *annot);
@@ -557,7 +557,7 @@ struct pdf_page_s
  * Content stream parsing
  */
 
-void pdf_run_glyph(pdf_document *doc, pdf_obj *resources, fz_buffer *contents, fz_device *dev, fz_matrix ctm, void *gstate, int nestedDepth);
+void pdf_run_glyph(pdf_document *doc, pdf_obj *resources, fz_buffer *contents, fz_device *dev, const fz_matrix *ctm, void *gstate, int nestedDepth);
 
 /*
  * PDF interface to store
diff --git a/pdf/mupdf.h b/pdf/mupdf.h
index 27bd1644..16a3053d 100644
--- a/pdf/mupdf.h
+++ b/pdf/mupdf.h
@@ -22,8 +22,8 @@ pdf_obj *pdf_new_string(fz_context *ctx, const char *str, int len);
 pdf_obj *pdf_new_indirect(fz_context *ctx, int num, int gen, void *doc);
 pdf_obj *pdf_new_array(fz_context *ctx, int initialcap);
 pdf_obj *pdf_new_dict(fz_context *ctx, int initialcap);
-pdf_obj *pdf_new_rect(fz_context *ctx, fz_rect rect);
-pdf_obj *pdf_new_matrix(fz_context *ctx, fz_matrix mtx);
+pdf_obj *pdf_new_rect(fz_context *ctx, const fz_rect *rect);
+pdf_obj *pdf_new_matrix(fz_context *ctx, const fz_matrix *mtx);
 pdf_obj *pdf_copy_array(fz_context *ctx, pdf_obj *array);
 pdf_obj *pdf_copy_dict(fz_context *ctx, pdf_obj *dict);
 
@@ -95,8 +95,8 @@ unsigned short *pdf_to_ucs2(pdf_document *xref, pdf_obj *src); /* sumatrapdf */
 pdf_obj *pdf_to_utf8_name(pdf_document *xref, pdf_obj *src);
 char *pdf_from_ucs2(pdf_document *xref, unsigned short *str);
 
-fz_rect pdf_to_rect(fz_context *ctx, pdf_obj *array);
-fz_matrix pdf_to_matrix(fz_context *ctx, pdf_obj *array);
+fz_rect *pdf_to_rect(fz_context *ctx, pdf_obj *array, fz_rect *rect);
+fz_matrix *pdf_to_matrix(fz_context *ctx, pdf_obj *array, fz_matrix *mat);
 
 int pdf_count_objects(pdf_document *doc);
 pdf_obj *pdf_resolve_indirect(pdf_obj *ref);
@@ -141,7 +141,7 @@ void pdf_update_stream(pdf_document *xref, int num, fz_buffer *buf);
 	new pdf content. WARNING: this device is work in progress. It doesn't
 	currently support all rendering cases.
 */
-fz_device *pdf_new_pdf_device(pdf_document *doc, pdf_obj *contents, pdf_obj *resources, fz_matrix ctm);
+fz_device *pdf_new_pdf_device(pdf_document *doc, pdf_obj *contents, pdf_obj *resources, const fz_matrix *ctm);
 
 /*
 	pdf_write_document: Write out the document to a file with all changes finalised.
@@ -235,7 +235,7 @@ fz_link *pdf_load_links(pdf_document *doc, pdf_page *page);
 
 	Does not throw exceptions.
 */
-fz_rect pdf_bound_page(pdf_document *doc, pdf_page *page);
+fz_rect *pdf_bound_page(pdf_document *doc, pdf_page *page, fz_rect *);
 
 /*
 	pdf_free_page: Frees a page and its resources.
@@ -265,7 +265,7 @@ pdf_annot *pdf_next_annot(pdf_document *doc, pdf_annot *annot);
 
 	Does not throw exceptions.
 */
-fz_rect pdf_bound_annot(pdf_document *doc, pdf_annot *annot);
+fz_rect *pdf_bound_annot(pdf_document *doc, pdf_annot *annot, fz_rect *rect);
 
 /*
 	pdf_run_page: Interpret a loaded page and render it on a device.
@@ -277,9 +277,9 @@ fz_rect pdf_bound_annot(pdf_document *doc, pdf_annot *annot);
 	ctm: A transformation matrix applied to the objects on the page,
 	e.g. to scale or rotate the page contents as desired.
 */
-void pdf_run_page(pdf_document *doc, pdf_page *page, fz_device *dev, fz_matrix ctm, fz_cookie *cookie);
+void pdf_run_page(pdf_document *doc, pdf_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie);
 
-void pdf_run_page_with_usage(pdf_document *doc, pdf_page *page, fz_device *dev, fz_matrix ctm, char *event, fz_cookie *cookie);
+void pdf_run_page_with_usage(pdf_document *doc, pdf_page *page, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie);
 
 /*
 	pdf_run_page_contents: Interpret a loaded page and render it on a device.
@@ -292,7 +292,7 @@ void pdf_run_page_with_usage(pdf_document *doc, pdf_page *page, fz_device *dev,
 	ctm: A transformation matrix applied to the objects on the page,
 	e.g. to scale or rotate the page contents as desired.
 */
-void pdf_run_page_contents(pdf_document *xref, pdf_page *page, fz_device *dev, fz_matrix ctm, fz_cookie *cookie);
+void pdf_run_page_contents(pdf_document *xref, pdf_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie);
 
 /*
 	pdf_run_annot: Interpret an annotation and render it on a device.
@@ -306,7 +306,7 @@ void pdf_run_page_contents(pdf_document *xref, pdf_page *page, fz_device *dev, f
 	ctm: A transformation matrix applied to the objects on the page,
 	e.g. to scale or rotate the page contents as desired.
 */
-void pdf_run_annot(pdf_document *xref, pdf_page *page, pdf_annot *annot, fz_device *dev, fz_matrix ctm, fz_cookie *cookie);
+void pdf_run_annot(pdf_document *xref, pdf_page *page, pdf_annot *annot, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie);
 
 /*
 	Metadata interface.
diff --git a/pdf/pdf_annot.c b/pdf/pdf_annot.c
index 3ba37da7..32de1eb9 100644
--- a/pdf/pdf_annot.c
+++ b/pdf/pdf_annot.c
@@ -243,7 +243,7 @@ pdf_parse_action(pdf_document *xref, pdf_obj *action)
 }
 
 static fz_link *
-pdf_load_link(pdf_document *xref, pdf_obj *dict, fz_matrix page_ctm)
+pdf_load_link(pdf_document *xref, pdf_obj *dict, const fz_matrix *page_ctm)
 {
 	pdf_obj *dest = NULL;
 	pdf_obj *action;
@@ -256,11 +256,11 @@ pdf_load_link(pdf_document *xref, pdf_obj *dict, fz_matrix page_ctm)
 
 	obj = pdf_dict_gets(dict, "Rect");
 	if (obj)
-		bbox = pdf_to_rect(ctx, obj);
+		pdf_to_rect(ctx, obj, &bbox);
 	else
 		bbox = fz_empty_rect;
 
-	bbox = fz_transform_rect(page_ctm, bbox);
+	fz_transform_rect(&bbox, page_ctm);
 
 	obj = pdf_dict_gets(dict, "Dest");
 	if (obj)
@@ -279,11 +279,11 @@ pdf_load_link(pdf_document *xref, pdf_obj *dict, fz_matrix page_ctm)
 	}
 	if (ld.kind == FZ_LINK_NONE)
 		return NULL;
-	return fz_new_link(ctx, bbox, ld);
+	return fz_new_link(ctx, &bbox, ld);
 }
 
 fz_link *
-pdf_load_link_annots(pdf_document *xref, pdf_obj *annots, fz_matrix page_ctm)
+pdf_load_link_annots(pdf_document *xref, pdf_obj *annots, const fz_matrix *page_ctm)
 {
 	fz_link *link, *head, *tail;
 	pdf_obj *obj;
@@ -332,12 +332,11 @@ pdf_free_annot(fz_context *ctx, pdf_annot *annot)
 static void
 pdf_transform_annot(pdf_annot *annot)
 {
-	fz_matrix matrix = annot->ap->matrix;
 	fz_rect bbox = annot->ap->bbox;
 	fz_rect rect = annot->rect;
 	float w, h, x, y;
 
-	bbox = fz_transform_rect(matrix, bbox);
+	fz_transform_rect(&bbox, &annot->ap->matrix);
 	if (bbox.x1 == bbox.x0)
 		w = 0;
 	else
@@ -349,7 +348,7 @@ pdf_transform_annot(pdf_annot *annot)
 	x = rect.x0 - bbox.x0;
 	y = rect.y0 - bbox.y0;
 
-	annot->matrix = fz_concat(fz_scale(w, h), fz_translate(x, y));
+	fz_pre_scale(fz_translate(&annot->matrix, x, y), w, h);
 }
 
 pdf_annot *
@@ -402,8 +401,9 @@ pdf_load_annots(pdf_document *xref, pdf_obj *annots, pdf_page *page)
 			annot = fz_malloc_struct(ctx, pdf_annot);
 			annot->page = page;
 			annot->obj = pdf_keep_obj(obj);
-			annot->rect = pdf_to_rect(ctx, rect);
-			annot->pagerect = fz_transform_rect(page->ctm, annot->rect);
+			pdf_to_rect(ctx, rect, &annot->rect);
+			annot->pagerect = annot->rect;
+			fz_transform_rect(&annot->pagerect, &page->ctm);
 			annot->ap = NULL;
 			annot->type = pdf_field_type(xref, obj);
 
@@ -501,12 +501,17 @@ pdf_next_annot(pdf_document *doc, pdf_annot *annot)
 	return annot ? annot->next : NULL;
 }
 
-fz_rect
-pdf_bound_annot(pdf_document *doc, pdf_annot *annot)
+fz_rect *
+pdf_bound_annot(pdf_document *doc, pdf_annot *annot, fz_rect *rect)
 {
+	if (rect == NULL)
+		return NULL;
+
 	if (annot)
-		return annot->pagerect;
-	return fz_empty_rect;
+		*rect = annot->pagerect;
+	else
+		*rect = fz_empty_rect;
+	return rect;
 }
 
 pdf_annot *
@@ -541,7 +546,7 @@ pdf_create_annot(pdf_document *doc, pdf_page *page, fz_annot_type type)
 		}
 
 		pdf_dict_puts_drop(annot_obj, "Subtype", pdf_new_name(ctx, type_str));
-		pdf_dict_puts_drop(annot_obj, "Rect", pdf_new_rect(ctx, rect));
+		pdf_dict_puts_drop(annot_obj, "Rect", pdf_new_rect(ctx, &rect));
 
 		annot = fz_malloc_struct(ctx, pdf_annot);
 		annot->page = page;
@@ -588,20 +593,21 @@ void
 pdf_set_annot_appearance(pdf_document *doc, pdf_annot *annot, fz_display_list *disp_list)
 {
 	fz_context *ctx = doc->ctx;
-	fz_matrix ctm = fz_invert_matrix(annot->page->ctm);
+	fz_matrix ctm;
 	fz_rect rect;
 	fz_matrix mat = fz_identity;
 	fz_device *dev = fz_new_bbox_device(ctx, &rect);
 
+	fz_invert_matrix(&ctm, &annot->page->ctm);
 	fz_try(ctx)
 	{
 		pdf_obj *ap_obj;
 
-		fz_run_display_list(disp_list, dev, ctm, fz_infinite_rect, NULL);
+		fz_run_display_list(disp_list, dev, &ctm, &fz_infinite_rect, NULL);
 		fz_free_device(dev);
 		dev = NULL;
 
-		pdf_dict_puts_drop(annot->obj, "Rect", pdf_new_rect(ctx, rect));
+		pdf_dict_puts_drop(annot->obj, "Rect", pdf_new_rect(ctx, &rect));
 
 		/* See if there is a current normal appearance */
 		ap_obj = pdf_dict_getp(annot->obj, "AP/N");
@@ -610,13 +616,13 @@ pdf_set_annot_appearance(pdf_document *doc, pdf_annot *annot, fz_display_list *d
 
 		if (ap_obj == NULL)
 		{
-			ap_obj = pdf_new_xobject(doc, rect, mat);
+			ap_obj = pdf_new_xobject(doc, &rect, &mat);
 			pdf_dict_putp_drop(annot->obj, "AP/N", ap_obj);
 		}
 		else
 		{
-			pdf_dict_puts_drop(ap_obj, "Rect", pdf_new_rect(ctx, rect));
-			pdf_dict_puts_drop(ap_obj, "Matrix", pdf_new_matrix(ctx, mat));
+			pdf_dict_puts_drop(ap_obj, "Rect", pdf_new_rect(ctx, &rect));
+			pdf_dict_puts_drop(ap_obj, "Matrix", pdf_new_matrix(ctx, &mat));
 		}
 
 		/* Remove annot reference to the xobject and don't recreate it
@@ -625,10 +631,11 @@ pdf_set_annot_appearance(pdf_document *doc, pdf_annot *annot, fz_display_list *d
 		annot->ap = NULL;
 
 		annot->rect = rect;
-		annot->pagerect = fz_transform_rect(annot->page->ctm, rect);
+		annot->pagerect = rect;
+		fz_transform_rect(&annot->pagerect, &annot->page->ctm);
 
-		dev = pdf_new_pdf_device(doc, ap_obj, pdf_dict_gets(ap_obj, "Resources"), mat);
-		fz_run_display_list(disp_list, dev, ctm, fz_infinite_rect, NULL);
+		dev = pdf_new_pdf_device(doc, ap_obj, pdf_dict_gets(ap_obj, "Resources"), &mat);
+		fz_run_display_list(disp_list, dev, &ctm, &fz_infinite_rect, NULL);
 		fz_free_device(dev);
 
 		doc->dirty = 1;
diff --git a/pdf/pdf_colorspace.c b/pdf/pdf_colorspace.c
index 1f83c906..30a45bde 100644
--- a/pdf/pdf_colorspace.c
+++ b/pdf/pdf_colorspace.c
@@ -183,6 +183,7 @@ pdf_expand_indexed_pixmap(fz_context *ctx, fz_pixmap *src)
 	unsigned char *s, *d;
 	int y, x, k, n, high;
 	unsigned char *lookup;
+	fz_bbox bbox;
 
 	assert(src->colorspace->to_rgb == indexed_to_rgb);
 	assert(src->n == 2);
@@ -192,7 +193,7 @@ pdf_expand_indexed_pixmap(fz_context *ctx, fz_pixmap *src)
 	lookup = idx->lookup;
 	n = idx->base->n;
 
-	dst = fz_new_pixmap_with_bbox(ctx, idx->base, fz_pixmap_bbox(ctx, src));
+	dst = fz_new_pixmap_with_bbox(ctx, idx->base, fz_pixmap_bbox(ctx, src, &bbox));
 	s = src->samples;
 	d = dst->samples;
 
diff --git a/pdf/pdf_device.c b/pdf/pdf_device.c
index 9d76b645..aea5593f 100644
--- a/pdf/pdf_device.c
+++ b/pdf/pdf_device.c
@@ -398,16 +398,16 @@ pdf_dev_path(pdf_device *pdev, fz_path *path)
 }
 
 static void
-pdf_dev_ctm(pdf_device *pdev, fz_matrix ctm)
+pdf_dev_ctm(pdf_device *pdev, const fz_matrix *ctm)
 {
 	fz_matrix inverse;
 	gstate *gs = CURRENT_GSTATE(pdev);
 
-	if (memcmp(&gs->ctm, &ctm, sizeof(ctm)) == 0)
+	if (memcmp(&gs->ctm, ctm, sizeof(ctm)) == 0)
 		return;
-	inverse = fz_invert_matrix(gs->ctm);
-	inverse = fz_concat(ctm, inverse);
-	memcpy(&gs->ctm, &ctm, sizeof(ctm));
+	fz_invert_matrix(&inverse, &gs->ctm);
+	fz_concat(&inverse, ctm, &inverse);
+	memcpy(&gs->ctm, ctm, sizeof(*ctm));
 	fz_buffer_printf(pdev->ctx, gs->buf, "%f %f %f %f %f %f cm\n", inverse.a, inverse.b, inverse.c, inverse.d, inverse.e, inverse.f);
 }
 
@@ -588,7 +588,7 @@ pdf_dev_font(pdf_device *pdev, fz_font *font, float size)
 }
 
 static void
-pdf_dev_tm(pdf_device *pdev, fz_matrix *tm)
+pdf_dev_tm(pdf_device *pdev, const fz_matrix *tm)
 {
 	gstate *gs = CURRENT_GSTATE(pdev);
 
@@ -662,7 +662,7 @@ pdf_dev_text(pdf_device *pdev, fz_text *text)
 	trunc_trm.d = trm.d;
 	trunc_trm.e = 0;
 	trunc_trm.f = 0;
-	inverse = fz_invert_matrix(trunc_trm);
+	fz_invert_matrix(&inverse, &trunc_trm);
 
 	for (i=0; i < text->len; i++)
 	{
@@ -670,7 +670,7 @@ pdf_dev_text(pdf_device *pdev, fz_text *text)
 		fz_point delta;
 		delta.x = it->x - trm.e;
 		delta.y = it->y - trm.f;
-		delta = fz_transform_point(inverse, delta);
+		fz_transform_point(&delta, &inverse);
 		if (delta.x != 0 || delta.y != 0)
 		{
 			fz_buffer_printf(pdev->ctx, gs->buf, "%g %g Td ", delta.x, delta.y);
@@ -698,7 +698,7 @@ pdf_dev_trm(pdf_device *pdev, int trm)
 }
 
 static void
-pdf_dev_begin_text(pdf_device *pdev, fz_matrix *tm, int trm)
+pdf_dev_begin_text(pdf_device *pdev, const fz_matrix *tm, int trm)
 {
 	pdf_dev_trm(pdev, trm);
 	if (!pdev->in_text)
@@ -728,7 +728,7 @@ pdf_dev_end_text(pdf_device *pdev)
 }
 
 static int
-pdf_dev_new_form(pdf_obj **form_ref, pdf_device *pdev, fz_rect bbox, int isolated, int knockout, int blendmode, float alpha, fz_colorspace *colorspace)
+pdf_dev_new_form(pdf_obj **form_ref, pdf_device *pdev, const fz_rect *bbox, int isolated, int knockout, int blendmode, float alpha, fz_colorspace *colorspace)
 {
 	fz_context *ctx = pdev->ctx;
 	int num;
@@ -825,7 +825,7 @@ pdf_dev_new_form(pdf_obj **form_ref, pdf_device *pdev, fz_rect bbox, int isolate
 /* Entry points */
 
 static void
-pdf_dev_fill_path(fz_device *dev, fz_path *path, int even_odd, fz_matrix ctm,
+pdf_dev_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	pdf_device *pdev = dev->user;
@@ -840,7 +840,7 @@ pdf_dev_fill_path(fz_device *dev, fz_path *path, int even_odd, fz_matrix ctm,
 }
 
 static void
-pdf_dev_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
+pdf_dev_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	pdf_device *pdev = dev->user;
@@ -856,7 +856,7 @@ pdf_dev_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_m
 }
 
 static void
-pdf_dev_clip_path(fz_device *dev, fz_path *path, fz_rect rect, int even_odd, fz_matrix ctm)
+pdf_dev_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm)
 {
 	pdf_device *pdev = dev->user;
 	gstate *gs;
@@ -870,7 +870,7 @@ pdf_dev_clip_path(fz_device *dev, fz_path *path, fz_rect rect, int even_odd, fz_
 }
 
 static void
-pdf_dev_clip_stroke_path(fz_device *dev, fz_path *path, fz_rect rect, fz_stroke_state *stroke, fz_matrix ctm)
+pdf_dev_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm)
 {
 	pdf_device *pdev = dev->user;
 	gstate *gs;
@@ -888,7 +888,7 @@ pdf_dev_clip_stroke_path(fz_device *dev, fz_path *path, fz_rect rect, fz_stroke_
 }
 
 static void
-pdf_dev_fill_text(fz_device *dev, fz_text *text, fz_matrix ctm,
+pdf_dev_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	pdf_device *pdev = dev->user;
@@ -900,7 +900,7 @@ pdf_dev_fill_text(fz_device *dev, fz_text *text, fz_matrix ctm,
 }
 
 static void
-pdf_dev_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
+pdf_dev_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	pdf_device *pdev = dev->user;
@@ -912,7 +912,7 @@ pdf_dev_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_m
 }
 
 static void
-pdf_dev_clip_text(fz_device *dev, fz_text *text, fz_matrix ctm, int accumulate)
+pdf_dev_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate)
 {
 	pdf_device *pdev = dev->user;
 	gstate *gs = CURRENT_GSTATE(pdev);
@@ -923,7 +923,7 @@ pdf_dev_clip_text(fz_device *dev, fz_text *text, fz_matrix ctm, int accumulate)
 }
 
 static void
-pdf_dev_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
+pdf_dev_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm)
 {
 	pdf_device *pdev = dev->user;
 	gstate *gs = CURRENT_GSTATE(pdev);
@@ -934,7 +934,7 @@ pdf_dev_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke,
 }
 
 static void
-pdf_dev_ignore_text(fz_device *dev, fz_text *text, fz_matrix ctm)
+pdf_dev_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm)
 {
 	pdf_device *pdev = dev->user;
 	gstate *gs = CURRENT_GSTATE(pdev);
@@ -945,23 +945,26 @@ pdf_dev_ignore_text(fz_device *dev, fz_text *text, fz_matrix ctm)
 }
 
 static void
-pdf_dev_fill_image(fz_device *dev, fz_image *image, fz_matrix ctm, float alpha)
+pdf_dev_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha)
 {
 	pdf_device *pdev = (pdf_device *)dev->user;
 	int num;
 	gstate *gs = CURRENT_GSTATE(pdev);
+	fz_matrix local_ctm = *ctm;
 
 	pdf_dev_end_text(pdev);
 	num = send_image(pdev, image, 0, 0);
 	fz_buffer_printf(dev->ctx, gs->buf, "q\n");
 	pdf_dev_alpha(pdev, alpha, 0);
 	/* PDF images are upside down, so fiddle the ctm */
-	pdf_dev_ctm(pdev, fz_concat(fz_concat(fz_translate(0, -1), fz_scale(1,-1)), ctm));
+	fz_pre_scale(&local_ctm, 1, -1);
+	fz_pre_translate(&local_ctm, 0, -1);
+	pdf_dev_ctm(pdev, &local_ctm);
 	fz_buffer_printf(dev->ctx, gs->buf, "/Img%d Do Q\n", num);
 }
 
 static void
-pdf_dev_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha)
+pdf_dev_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha)
 {
 	pdf_device *pdev = (pdf_device *)dev->user;
 
@@ -970,12 +973,13 @@ pdf_dev_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha)
 }
 
 static void
-pdf_dev_fill_image_mask(fz_device *dev, fz_image *image, fz_matrix ctm,
+pdf_dev_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm,
 fz_colorspace *colorspace, float *color, float alpha)
 {
 	pdf_device *pdev = (pdf_device *)dev->user;
 	gstate *gs = CURRENT_GSTATE(pdev);
 	int num;
+	fz_matrix local_ctm = *ctm;
 
 	pdf_dev_end_text(pdev);
 	num = send_image(pdev, image, 1, 0);
@@ -983,12 +987,14 @@ fz_colorspace *colorspace, float *color, float alpha)
 	pdf_dev_alpha(pdev, alpha, 0);
 	pdf_dev_color(pdev, colorspace, color, 0);
 	/* PDF images are upside down, so fiddle the ctm */
-	pdf_dev_ctm(pdev, fz_concat(fz_concat(fz_translate(0, -1), fz_scale(1,-1)), ctm));
+	fz_pre_scale(&local_ctm, 1, -1);
+	fz_pre_translate(&local_ctm, 0, -1);
+	pdf_dev_ctm(pdev, &local_ctm);
 	fz_buffer_printf(dev->ctx, gs->buf, "/Img%d Do Q\n", num);
 }
 
 static void
-pdf_dev_clip_image_mask(fz_device *dev, fz_image *image, fz_rect rect, fz_matrix ctm)
+pdf_dev_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm)
 {
 	pdf_device *pdev = (pdf_device *)dev->user;
 
@@ -1008,7 +1014,7 @@ pdf_dev_pop_clip(fz_device *dev)
 }
 
 static void
-pdf_dev_begin_mask(fz_device *dev, fz_rect bbox, int luminosity, fz_colorspace *colorspace, float *color)
+pdf_dev_begin_mask(fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, float *color)
 {
 	pdf_device *pdev = (pdf_device *)dev->user;
 	fz_context *ctx = pdev->ctx;
@@ -1093,7 +1099,7 @@ pdf_dev_end_mask(fz_device *dev)
 }
 
 static void
-pdf_dev_begin_group(fz_device *dev, fz_rect bbox, int isolated, int knockout, int blendmode, float alpha)
+pdf_dev_begin_group(fz_device *dev, const fz_rect *bbox, int isolated, int knockout, int blendmode, float alpha)
 {
 	pdf_device *pdev = (pdf_device *)dev->user;
 	fz_context *ctx = pdev->ctx;
@@ -1132,7 +1138,7 @@ pdf_dev_end_group(fz_device *dev)
 }
 
 static void
-pdf_dev_begin_tile(fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
+pdf_dev_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm)
 {
 	pdf_device *pdev = (pdf_device *)dev->user;
 
@@ -1187,7 +1193,7 @@ pdf_dev_free_user(fz_device *dev)
 	fz_free(ctx, pdev);
 }
 
-fz_device *pdf_new_pdf_device(pdf_document *doc, pdf_obj *contents, pdf_obj *resources, fz_matrix ctm)
+fz_device *pdf_new_pdf_device(pdf_document *doc, pdf_obj *contents, pdf_obj *resources, const fz_matrix *ctm)
 {
 	fz_context *ctx = doc->ctx;
 	pdf_device *pdev = fz_malloc_struct(ctx, pdf_device);
@@ -1201,7 +1207,7 @@ fz_device *pdf_new_pdf_device(pdf_document *doc, pdf_obj *contents, pdf_obj *res
 		pdev->resources = pdf_keep_obj(resources);
 		pdev->gstates = fz_malloc_struct(ctx, gstate);
 		pdev->gstates[0].buf = fz_new_buffer(ctx, 256);
-		pdev->gstates[0].ctm = ctm;
+		pdev->gstates[0].ctm = *ctm;
 		pdev->gstates[0].colorspace[0] = fz_device_gray;
 		pdev->gstates[0].colorspace[1] = fz_device_gray;
 		pdev->gstates[0].color[0][0] = 1;
diff --git a/pdf/pdf_font.c b/pdf/pdf_font.c
index ebb157b5..d3f25304 100644
--- a/pdf/pdf_font.c
+++ b/pdf/pdf_font.c
@@ -1192,23 +1192,23 @@ pdf_print_font(fz_context *ctx, pdf_font_desc *fontdesc)
 }
 #endif
 
-fz_rect pdf_measure_text(fz_context *ctx, pdf_font_desc *fontdesc, unsigned char *buf, int len)
+fz_rect *pdf_measure_text(fz_context *ctx, pdf_font_desc *fontdesc, unsigned char *buf, int len, fz_rect *acc)
 {
 	pdf_hmtx h;
 	int gid;
 	int i;
 	float x = 0.0;
-	fz_rect acc = fz_empty_rect;
 	fz_rect bbox;
 
+	*acc = fz_empty_rect;
 	for (i = 0; i < len; i++)
 	{
 		gid = pdf_font_cid_to_gid(ctx, fontdesc, buf[i]);
 		h = pdf_lookup_hmtx(ctx, fontdesc, buf[i]);
-		bbox = fz_bound_glyph(ctx, fontdesc->font, gid, fz_identity);
+		fz_bound_glyph(ctx, fontdesc->font, gid, &fz_identity, &bbox);
 		bbox.x0 += x;
 		bbox.x1 += x;
-		acc = fz_union_rect(acc, bbox);
+		fz_union_rect(acc, &bbox);
 		x += h.w / 1000.0;
 	}
 
diff --git a/pdf/pdf_form.c b/pdf/pdf_form.c
index e92ba738..bdab08e7 100644
--- a/pdf/pdf_form.c
+++ b/pdf/pdf_form.c
@@ -114,15 +114,15 @@ static void account_for_rot(fz_rect *rect, fz_matrix *mat, int rot)
 		*mat = fz_identity;
 		break;
 	case 90:
-		*mat = fz_concat(fz_rotate(rot), fz_translate(width, 0));
+		fz_pre_rotate(fz_translate(mat, width, 0), rot);
 		rect->x1 = height;
 		rect->y1 = width;
 		break;
 	case 180:
-		*mat = fz_concat(fz_rotate(rot), fz_translate(width, height));
+		fz_pre_rotate(fz_translate(mat, width, height), rot);
 		break;
 	case 270:
-		*mat = fz_concat(fz_rotate(rot), fz_translate(0, height));
+		fz_pre_rotate(fz_translate(mat, 0, height), rot);
 		rect->x1 = height;
 		rect->y1 = width;
 		break;
@@ -427,14 +427,14 @@ static void fzbuf_print_da(fz_context *ctx, fz_buffer *fzbuf, da_info *di)
 	}
 }
 
-static fz_rect measure_text(pdf_document *doc, font_info *font_rec, const fz_matrix *tm, char *text)
+static fz_rect *measure_text(pdf_document *doc, font_info *font_rec, const fz_matrix *tm, char *text, fz_rect *bbox)
 {
-	fz_rect bbox = pdf_measure_text(doc->ctx, font_rec->font, (unsigned char *)text, strlen(text));
+	pdf_measure_text(doc->ctx, font_rec->font, (unsigned char *)text, strlen(text), bbox);
 
-	bbox.x0 *= font_rec->da_rec.font_size * tm->a;
-	bbox.y0 *= font_rec->da_rec.font_size * tm->d;
-	bbox.x1 *= font_rec->da_rec.font_size * tm->a;
-	bbox.y1 *= font_rec->da_rec.font_size * tm->d;
+	bbox->x0 *= font_rec->da_rec.font_size * tm->a;
+	bbox->y0 *= font_rec->da_rec.font_size * tm->d;
+	bbox->x1 *= font_rec->da_rec.font_size * tm->a;
+	bbox->y1 *= font_rec->da_rec.font_size * tm->d;
 
 	return bbox;
 }
@@ -463,7 +463,7 @@ static void fzbuf_print_color(fz_context *ctx, fz_buffer *fzbuf, pdf_obj *arr, i
 	}
 }
 
-static void fzbuf_print_text(fz_context *ctx, fz_buffer *fzbuf, fz_rect *clip, pdf_obj *col, font_info *font_rec, fz_matrix *tm, char *text)
+static void fzbuf_print_text(fz_context *ctx, fz_buffer *fzbuf, const fz_rect *clip, pdf_obj *col, font_info *font_rec, const fz_matrix *tm, char *text)
 {
 	fz_buffer_printf(ctx, fzbuf, fmt_q);
 	if (clip)
@@ -495,7 +495,7 @@ static void fzbuf_print_text(fz_context *ctx, fz_buffer *fzbuf, fz_rect *clip, p
 	fz_buffer_printf(ctx, fzbuf, fmt_Q);
 }
 
-static fz_buffer *create_text_buffer(fz_context *ctx, fz_rect *clip, text_widget_info *info, fz_matrix *tm, char *text)
+static fz_buffer *create_text_buffer(fz_context *ctx, const fz_rect *clip, text_widget_info *info, const fz_matrix *tm, char *text)
 {
 	fz_buffer *fzbuf = fz_new_buffer(ctx, 0);
 
@@ -514,15 +514,16 @@ static fz_buffer *create_text_buffer(fz_context *ctx, fz_rect *clip, text_widget
 	return fzbuf;
 }
 
-static fz_buffer *create_aligned_text_buffer(pdf_document *doc, fz_rect *clip, text_widget_info *info, fz_matrix *tm, char *text)
+static fz_buffer *create_aligned_text_buffer(pdf_document *doc, const fz_rect *clip, text_widget_info *info, const fz_matrix *tm, char *text)
 {
 	fz_context *ctx = doc->ctx;
 	fz_matrix atm = *tm;
 
 	if (info->q != Q_Left)
 	{
-		fz_rect rect = measure_text(doc, &info->font_rec, tm, text);
+		fz_rect rect;
 
+		measure_text(doc, &info->font_rec, tm, text, &rect);
 		atm.e -= info->q == Q_Right ? rect.x1 : (rect.x1 - rect.x0) / 2;
 	}
 
@@ -545,7 +546,7 @@ static void measure_ascent_descent(pdf_document *doc, font_info *finf, char *tex
 		strcpy(testtext, "My");
 		strcat(testtext, text);
 		tinf.da_rec.font_size = 1;
-		bbox = measure_text(doc, &tinf, &fz_identity, testtext);
+		measure_text(doc, &tinf, &fz_identity, testtext, &bbox);
 		*descent = -bbox.y0;
 		*ascent = bbox.y1;
 	}
@@ -725,7 +726,7 @@ static void text_splitter_retry(text_splitter *splitter)
 	}
 }
 
-static void fzbuf_print_text_start(fz_context *ctx, fz_buffer *fzbuf, fz_rect *clip, pdf_obj *col, font_info *font, fz_matrix *tm)
+static void fzbuf_print_text_start(fz_context *ctx, fz_buffer *fzbuf, const fz_rect *clip, pdf_obj *col, font_info *font, const fz_matrix *tm)
 {
 	fz_buffer_printf(ctx, fzbuf, fmt_Tx_BMC);
 	fz_buffer_printf(ctx, fzbuf, fmt_q);
@@ -773,7 +774,7 @@ static void fzbuf_print_text_word(fz_context *ctx, fz_buffer *fzbuf, float x, fl
 	fz_buffer_printf(ctx, fzbuf, ") Tj\n");
 }
 
-static fz_buffer *create_text_appearance(pdf_document *doc, fz_rect *bbox, fz_matrix *oldtm, text_widget_info *info, char *text)
+static fz_buffer *create_text_appearance(pdf_document *doc, const fz_rect *bbox, const fz_matrix *oldtm, text_widget_info *info, char *text)
 {
 	fz_context *ctx = doc->ctx;
 	int fontsize;
@@ -880,9 +881,7 @@ static fz_buffer *create_text_appearance(pdf_document *doc, fz_rect *bbox, fz_ma
 			float char_width = pdf_text_stride(ctx, info->font_rec.font, fontsize, (unsigned char *)"M", 1, FLT_MAX, NULL);
 			float init_skip = (comb_width - char_width)/2.0;
 
-			tm = fz_identity;
-			tm.e = rect.x0;
-			tm.f = rect.y1 - (height+(ascent-descent)*fontsize)/2.0;
+			fz_translate(&tm, rect.x0, rect.y1 - (height+(ascent-descent)*fontsize)/2.0);
 
 			fzbuf = fz_new_buffer(ctx, 0);
 
@@ -901,9 +900,7 @@ static fz_buffer *create_text_appearance(pdf_document *doc, fz_rect *bbox, fz_ma
 			}
 			else
 			{
-				tm = fz_identity;
-				tm.e = rect.x0;
-				tm.f = rect.y1 - (height+(ascent-descent)*fontsize)/2.0;
+				fz_translate(&tm, rect.x0, rect.y1 - (height+(ascent-descent)*fontsize)/2.0);
 
 				switch(info->q)
 				{
@@ -914,7 +911,7 @@ static fz_buffer *create_text_appearance(pdf_document *doc, fz_rect *bbox, fz_ma
 
 			if (variable)
 			{
-				tbox = measure_text(doc, &info->font_rec, &tm, text);
+				measure_text(doc, &info->font_rec, &tm, text, &tbox);
 
 				if (tbox.x1 - tbox.x0 > width)
 				{
@@ -1082,7 +1079,8 @@ static int get_matrix(pdf_document *doc, pdf_xobject *form, int q, fz_matrix *mt
 
 		if (found)
 		{
-			fz_rect bbox = pdf_to_rect(ctx, pdf_dict_gets(form->contents, "BBox"));
+			fz_rect bbox;
+			pdf_to_rect(ctx, pdf_dict_gets(form->contents, "BBox"), &bbox);
 
 			switch (q)
 			{
@@ -1163,7 +1161,7 @@ static pdf_xobject *load_or_create_form(pdf_document *doc, pdf_obj *obj, fz_rect
 	fz_try(ctx)
 	{
 		rot = pdf_to_int(pdf_dict_getp(obj, "MK/R"));
-		*rect = pdf_to_rect(ctx, pdf_dict_gets(obj, "Rect"));
+		pdf_to_rect(ctx, pdf_dict_gets(obj, "Rect"), rect);
 		rect->x1 -= rect->x0;
 		rect->y1 -= rect->y0;
 		rect->x0 = rect->y0 = 0;
@@ -1179,7 +1177,7 @@ static pdf_xobject *load_or_create_form(pdf_document *doc, pdf_obj *obj, fz_rect
 		formobj = pdf_dict_gets(ap, dn);
 		if (formobj == NULL)
 		{
-			formobj = pdf_new_xobject(doc, *rect, mat);
+			formobj = pdf_new_xobject(doc, rect, &mat);
 			pdf_dict_puts_drop(ap, dn, formobj);
 			create_form = 1;
 		}
@@ -1476,8 +1474,8 @@ static void update_pushbutton_appearance(pdf_document *doc, pdf_obj *obj)
 			clip.y1 -= btotal;
 
 			get_font_info(doc, form->resources, da, &font_rec);
-			bounds = measure_text(doc, &font_rec, &fz_identity, text);
-			mat = fz_translate((rect.x1 - bounds.x1)/2, (rect.y1 - bounds.y1)/2);
+			measure_text(doc, &font_rec, &fz_identity, text, &bounds);
+			fz_translate(&mat, (rect.x1 - bounds.x1)/2, (rect.y1 - bounds.y1)/2);
 			fzbuf_print_text(ctx, fzbuf, &clip, NULL, &font_rec, &mat, text);
 		}
 
@@ -2591,11 +2589,15 @@ void pdf_field_set_text_color(pdf_document *doc, pdf_obj *field, pdf_obj *col)
 	}
 }
 
-fz_rect fz_widget_bbox(fz_widget *widget)
+fz_rect *fz_bound_widget(fz_widget *widget, fz_rect *rect)
 {
 	pdf_annot *annot = (pdf_annot *)widget;
 
-	return annot->pagerect;
+	if (rect == NULL)
+		return NULL;
+	*rect = annot->pagerect; 
+
+	return rect;
 }
 
 char *pdf_text_widget_text(pdf_document *doc, fz_widget *tw)
diff --git a/pdf/pdf_interpret.c b/pdf/pdf_interpret.c
index 5f4fffc1..3021196c 100644
--- a/pdf/pdf_interpret.c
+++ b/pdf/pdf_interpret.c
@@ -108,8 +108,8 @@ struct pdf_csi_s
 };
 
 static void pdf_run_contents_object(pdf_csi *csi, pdf_obj *rdb, pdf_obj *contents);
-static void pdf_run_xobject(pdf_csi *csi, pdf_obj *resources, pdf_xobject *xobj, fz_matrix transform);
-static void pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, fz_rect area, int what);
+static void pdf_run_xobject(pdf_csi *csi, pdf_obj *resources, pdf_xobject *xobj, const fz_matrix *transform);
+static void pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, const fz_rect *area, int what);
 
 static int
 ocg_intents_include(pdf_ocg_descriptor *desc, char *name)
@@ -324,7 +324,7 @@ pdf_is_hidden_ocg(pdf_obj *ocg, pdf_csi *csi, pdf_obj *rdb)
  */
 
 static void
-pdf_begin_group(pdf_csi *csi, fz_rect bbox)
+pdf_begin_group(pdf_csi *csi, const fz_rect *bbox)
 {
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 	fz_context *ctx = csi->dev->ctx;
@@ -332,17 +332,18 @@ pdf_begin_group(pdf_csi *csi, fz_rect bbox)
 	if (gstate->softmask)
 	{
 		pdf_xobject *softmask = gstate->softmask;
-		fz_rect bbox = fz_transform_rect(gstate->softmask_ctm, softmask->bbox);
+		fz_rect mask_bbox = softmask->bbox;
 		fz_matrix save_ctm = gstate->ctm;
 
+		fz_transform_rect(&mask_bbox, &gstate->softmask_ctm);
 		gstate->softmask = NULL;
 		gstate->ctm = gstate->softmask_ctm;
 
-		fz_begin_mask(csi->dev, bbox, gstate->luminosity,
+		fz_begin_mask(csi->dev, &mask_bbox, gstate->luminosity,
 			softmask->colorspace, gstate->softmask_bc);
 		fz_try(ctx)
 		{
-			pdf_run_xobject(csi, NULL, softmask, fz_identity);
+			pdf_run_xobject(csi, NULL, softmask, &fz_identity);
 		}
 		fz_catch(ctx)
 		{
@@ -385,11 +386,11 @@ pdf_show_shade(pdf_csi *csi, fz_shade *shd)
 	if (csi->in_hidden_ocg > 0)
 		return;
 
-	bbox = fz_bound_shade(ctx, shd, gstate->ctm);
+	fz_bound_shade(ctx, shd, &gstate->ctm, &bbox);
 
-	pdf_begin_group(csi, bbox);
+	pdf_begin_group(csi, &bbox);
 
-	fz_fill_shade(csi->dev, shd, gstate->ctm, gstate->fill.alpha);
+	fz_fill_shade(csi->dev, shd, &gstate->ctm, gstate->fill.alpha);
 
 	pdf_end_group(csi);
 }
@@ -405,20 +406,21 @@ pdf_show_image(pdf_csi *csi, fz_image *image)
 		return;
 
 	/* PDF has images bottom-up, so flip them right side up here */
-	image_ctm = fz_concat(fz_scale(1, -1), fz_translate(0, 1));
-	image_ctm = fz_concat(image_ctm, gstate->ctm);
+	image_ctm = gstate->ctm;
+	fz_pre_scale(fz_pre_translate(&image_ctm, 0, 1), 1, -1);
 
-	bbox = fz_transform_rect(image_ctm, fz_unit_rect);
+	bbox = fz_unit_rect;
+	fz_transform_rect(&bbox, &image_ctm);
 
 	if (image->mask)
 	{
 		/* apply blend group even though we skip the soft mask */
 		if (gstate->blendmode)
-			fz_begin_group(csi->dev, bbox, 0, 0, gstate->blendmode, 1);
-		fz_clip_image_mask(csi->dev, image->mask, bbox, image_ctm);
+			fz_begin_group(csi->dev, &bbox, 0, 0, gstate->blendmode, 1);
+		fz_clip_image_mask(csi->dev, image->mask, &bbox, &image_ctm);
 	}
 	else
-		pdf_begin_group(csi, bbox);
+		pdf_begin_group(csi, &bbox);
 
 	if (!image->colorspace)
 	{
@@ -428,22 +430,22 @@ pdf_show_image(pdf_csi *csi, fz_image *image)
 		case PDF_MAT_NONE:
 			break;
 		case PDF_MAT_COLOR:
-			fz_fill_image_mask(csi->dev, image, image_ctm,
+			fz_fill_image_mask(csi->dev, image, &image_ctm,
 				gstate->fill.colorspace, gstate->fill.v, gstate->fill.alpha);
 			break;
 		case PDF_MAT_PATTERN:
 			if (gstate->fill.pattern)
 			{
-				fz_clip_image_mask(csi->dev, image, bbox, image_ctm);
-				pdf_show_pattern(csi, gstate->fill.pattern, bbox, PDF_FILL);
+				fz_clip_image_mask(csi->dev, image, &bbox, &image_ctm);
+				pdf_show_pattern(csi, gstate->fill.pattern, &bbox, PDF_FILL);
 				fz_pop_clip(csi->dev);
 			}
 			break;
 		case PDF_MAT_SHADE:
 			if (gstate->fill.shade)
 			{
-				fz_clip_image_mask(csi->dev, image, bbox, image_ctm);
-				fz_fill_shade(csi->dev, gstate->fill.shade, gstate->ctm, gstate->fill.alpha);
+				fz_clip_image_mask(csi->dev, image, &bbox, &image_ctm);
+				fz_fill_shade(csi->dev, gstate->fill.shade, &gstate->ctm, gstate->fill.alpha);
 				fz_pop_clip(csi->dev);
 			}
 			break;
@@ -451,7 +453,7 @@ pdf_show_image(pdf_csi *csi, fz_image *image)
 	}
 	else
 	{
-		fz_fill_image(csi->dev, image, image_ctm, gstate->fill.alpha);
+		fz_fill_image(csi->dev, image, &image_ctm, gstate->fill.alpha);
 	}
 
 	if (image->mask)
@@ -493,15 +495,12 @@ pdf_show_path(pdf_csi *csi, int doclose, int dofill, int dostroke, int even_odd)
 		if (doclose)
 			fz_closepath(ctx, path);
 
-		if (dostroke)
-			bbox = fz_bound_path(ctx, path, gstate->stroke_state, gstate->ctm);
-		else
-			bbox = fz_bound_path(ctx, path, NULL, gstate->ctm);
+		fz_bound_path(ctx, path, (dostroke ? gstate->stroke_state : NULL), &gstate->ctm, &bbox);
 
 		if (csi->clip)
 		{
 			gstate->clip_depth++;
-			fz_clip_path(csi->dev, path, fz_infinite_rect, csi->clip_even_odd, gstate->ctm);
+			fz_clip_path(csi->dev, path, NULL, csi->clip_even_odd, &gstate->ctm);
 			csi->clip = 0;
 		}
 
@@ -509,7 +508,7 @@ pdf_show_path(pdf_csi *csi, int doclose, int dofill, int dostroke, int even_odd)
 			dostroke = dofill = 0;
 
 		if (dofill || dostroke)
-			pdf_begin_group(csi, bbox);
+			pdf_begin_group(csi, &bbox);
 
 		if (dofill)
 		{
@@ -518,22 +517,22 @@ pdf_show_path(pdf_csi *csi, int doclose, int dofill, int dostroke, int even_odd)
 			case PDF_MAT_NONE:
 				break;
 			case PDF_MAT_COLOR:
-				fz_fill_path(csi->dev, path, even_odd, gstate->ctm,
+				fz_fill_path(csi->dev, path, even_odd, &gstate->ctm,
 					gstate->fill.colorspace, gstate->fill.v, gstate->fill.alpha);
 				break;
 			case PDF_MAT_PATTERN:
 				if (gstate->fill.pattern)
 				{
-					fz_clip_path(csi->dev, path, fz_infinite_rect, even_odd, gstate->ctm);
-					pdf_show_pattern(csi, gstate->fill.pattern, bbox, PDF_FILL);
+					fz_clip_path(csi->dev, path, NULL, even_odd, &gstate->ctm);
+					pdf_show_pattern(csi, gstate->fill.pattern, &bbox, PDF_FILL);
 					fz_pop_clip(csi->dev);
 				}
 				break;
 			case PDF_MAT_SHADE:
 				if (gstate->fill.shade)
 				{
-					fz_clip_path(csi->dev, path, fz_infinite_rect, even_odd, gstate->ctm);
-					fz_fill_shade(csi->dev, gstate->fill.shade, csi->top_ctm, gstate->fill.alpha);
+					fz_clip_path(csi->dev, path, NULL, even_odd, &gstate->ctm);
+					fz_fill_shade(csi->dev, gstate->fill.shade, &csi->top_ctm, gstate->fill.alpha);
 					fz_pop_clip(csi->dev);
 				}
 				break;
@@ -547,22 +546,22 @@ pdf_show_path(pdf_csi *csi, int doclose, int dofill, int dostroke, int even_odd)
 			case PDF_MAT_NONE:
 				break;
 			case PDF_MAT_COLOR:
-				fz_stroke_path(csi->dev, path, gstate->stroke_state, gstate->ctm,
+				fz_stroke_path(csi->dev, path, gstate->stroke_state, &gstate->ctm,
 					gstate->stroke.colorspace, gstate->stroke.v, gstate->stroke.alpha);
 				break;
 			case PDF_MAT_PATTERN:
 				if (gstate->stroke.pattern)
 				{
-					fz_clip_stroke_path(csi->dev, path, bbox, gstate->stroke_state, gstate->ctm);
-					pdf_show_pattern(csi, gstate->stroke.pattern, bbox, PDF_STROKE);
+					fz_clip_stroke_path(csi->dev, path, &bbox, gstate->stroke_state, &gstate->ctm);
+					pdf_show_pattern(csi, gstate->stroke.pattern, &bbox, PDF_STROKE);
 					fz_pop_clip(csi->dev);
 				}
 				break;
 			case PDF_MAT_SHADE:
 				if (gstate->stroke.shade)
 				{
-					fz_clip_stroke_path(csi->dev, path, bbox, gstate->stroke_state, gstate->ctm);
-					fz_fill_shade(csi->dev, gstate->stroke.shade, csi->top_ctm, gstate->stroke.alpha);
+					fz_clip_stroke_path(csi->dev, path, &bbox, gstate->stroke_state, &gstate->ctm);
+					fz_fill_shade(csi->dev, gstate->stroke.shade, &csi->top_ctm, gstate->stroke.alpha);
 					fz_pop_clip(csi->dev);
 				}
 				break;
@@ -620,16 +619,18 @@ pdf_flush_text(pdf_csi *csi)
 
 	fz_try(ctx)
 	{
-		fz_rect tb = fz_transform_rect(gstate->ctm, csi->text_bbox);
+		fz_rect tb = csi->text_bbox;
+
+		fz_transform_rect(&tb, &gstate->ctm);
 
 		/* Don't bother sending a text group with nothing in it */
 		if (text->len == 0)
 			break;
 
-		pdf_begin_group(csi, tb);
+		pdf_begin_group(csi, &tb);
 
 		if (doinvisible)
-			fz_ignore_text(csi->dev, text, gstate->ctm);
+			fz_ignore_text(csi->dev, text, &gstate->ctm);
 
 		if (dofill)
 		{
@@ -638,22 +639,22 @@ pdf_flush_text(pdf_csi *csi)
 			case PDF_MAT_NONE:
 				break;
 			case PDF_MAT_COLOR:
-				fz_fill_text(csi->dev, text, gstate->ctm,
+				fz_fill_text(csi->dev, text, &gstate->ctm,
 					gstate->fill.colorspace, gstate->fill.v, gstate->fill.alpha);
 				break;
 			case PDF_MAT_PATTERN:
 				if (gstate->fill.pattern)
 				{
-					fz_clip_text(csi->dev, text, gstate->ctm, 0);
-					pdf_show_pattern(csi, gstate->fill.pattern, tb, PDF_FILL);
+					fz_clip_text(csi->dev, text, &gstate->ctm, 0);
+					pdf_show_pattern(csi, gstate->fill.pattern, &tb, PDF_FILL);
 					fz_pop_clip(csi->dev);
 				}
 				break;
 			case PDF_MAT_SHADE:
 				if (gstate->fill.shade)
 				{
-					fz_clip_text(csi->dev, text, gstate->ctm, 0);
-					fz_fill_shade(csi->dev, gstate->fill.shade, csi->top_ctm, gstate->fill.alpha);
+					fz_clip_text(csi->dev, text, &gstate->ctm, 0);
+					fz_fill_shade(csi->dev, gstate->fill.shade, &csi->top_ctm, gstate->fill.alpha);
 					fz_pop_clip(csi->dev);
 				}
 				break;
@@ -667,22 +668,22 @@ pdf_flush_text(pdf_csi *csi)
 			case PDF_MAT_NONE:
 				break;
 			case PDF_MAT_COLOR:
-				fz_stroke_text(csi->dev, text, gstate->stroke_state, gstate->ctm,
+				fz_stroke_text(csi->dev, text, gstate->stroke_state, &gstate->ctm,
 					gstate->stroke.colorspace, gstate->stroke.v, gstate->stroke.alpha);
 				break;
 			case PDF_MAT_PATTERN:
 				if (gstate->stroke.pattern)
 				{
-					fz_clip_stroke_text(csi->dev, text, gstate->stroke_state, gstate->ctm);
-					pdf_show_pattern(csi, gstate->stroke.pattern, tb, PDF_STROKE);
+					fz_clip_stroke_text(csi->dev, text, gstate->stroke_state, &gstate->ctm);
+					pdf_show_pattern(csi, gstate->stroke.pattern, &tb, PDF_STROKE);
 					fz_pop_clip(csi->dev);
 				}
 				break;
 			case PDF_MAT_SHADE:
 				if (gstate->stroke.shade)
 				{
-					fz_clip_stroke_text(csi->dev, text, gstate->stroke_state, gstate->ctm);
-					fz_fill_shade(csi->dev, gstate->stroke.shade, csi->top_ctm, gstate->stroke.alpha);
+					fz_clip_stroke_text(csi->dev, text, gstate->stroke_state, &gstate->ctm);
+					fz_fill_shade(csi->dev, gstate->stroke.shade, &csi->top_ctm, gstate->stroke.alpha);
 					fz_pop_clip(csi->dev);
 				}
 				break;
@@ -693,7 +694,7 @@ pdf_flush_text(pdf_csi *csi)
 		{
 			if (csi->accumulate < 2)
 				gstate->clip_depth++;
-			fz_clip_text(csi->dev, text, gstate->ctm, csi->accumulate);
+			fz_clip_text(csi->dev, text, &gstate->ctm, csi->accumulate);
 			csi->accumulate = 2;
 		}
 
@@ -756,9 +757,9 @@ pdf_show_char(pdf_csi *csi, int cid)
 		tsm.f -= v.y * gstate->size * 0.001f;
 	}
 
-	trm = fz_concat(tsm, csi->tm);
+	fz_concat(&trm, &tsm, &csi->tm);
 
-	bbox = fz_bound_glyph(ctx, fontdesc->font, gid, trm);
+	fz_bound_glyph(ctx, fontdesc->font, gid, &trm, &bbox);
 	/* Compensate for the glyph cache limited positioning precision */
 	bbox.x0 -= 1;
 	bbox.y0 -= 1;
@@ -782,7 +783,7 @@ pdf_show_char(pdf_csi *csi, int cid)
 	{
 		pdf_flush_text(csi);
 
-		csi->text = fz_new_text(ctx, fontdesc->font, trm, fontdesc->wmode);
+		csi->text = fz_new_text(ctx, fontdesc->font, &trm, fontdesc->wmode);
 		csi->text->trm.e = 0;
 		csi->text->trm.f = 0;
 		csi->text_mode = gstate->render;
@@ -794,12 +795,13 @@ pdf_show_char(pdf_csi *csi, 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(trm, gstate->ctm);
-		fz_render_t3_glyph_direct(ctx, csi->dev, fontdesc->font, gid, composed, gstate, csi->nested_depth);
+		fz_matrix composed;
+		fz_concat(&composed, &trm, &gstate->ctm);
+		fz_render_t3_glyph_direct(ctx, csi->dev, fontdesc->font, gid, &composed, gstate, csi->nested_depth);
 	}
 	else
 	{
-		csi->text_bbox = fz_union_rect(csi->text_bbox, bbox);
+		fz_union_rect(&csi->text_bbox, &bbox);
 
 		/* add glyph to textobject */
 		fz_add_text(ctx, csi->text, gid, ucsbuf[0], trm.e, trm.f);
@@ -814,14 +816,14 @@ pdf_show_char(pdf_csi *csi, int cid)
 		h = pdf_lookup_hmtx(ctx, fontdesc, cid);
 		w0 = h.w * 0.001f;
 		tx = (w0 * gstate->size + gstate->char_space) * gstate->scale;
-		csi->tm = fz_concat(fz_translate(tx, 0), csi->tm);
+		fz_pre_translate(&csi->tm, tx, 0);
 	}
 
 	if (fontdesc->wmode == 1)
 	{
 		w1 = v.w * 0.001f;
 		ty = w1 * gstate->size + gstate->char_space;
-		csi->tm = fz_concat(fz_translate(0, ty), csi->tm);
+		fz_pre_translate(&csi->tm, 0, ty);
 	}
 }
 
@@ -839,9 +841,9 @@ pdf_show_space(pdf_csi *csi, float tadj)
 	}
 
 	if (fontdesc->wmode == 0)
-		csi->tm = fz_concat(fz_translate(tadj * gstate->scale, 0), csi->tm);
+		fz_pre_translate(&csi->tm, tadj * gstate->scale, 0);
 	else
-		csi->tm = fz_concat(fz_translate(0, tadj), csi->tm);
+		fz_pre_translate(&csi->tm, 0, tadj);
 }
 
 static void
@@ -903,9 +905,9 @@ pdf_show_text(pdf_csi *csi, pdf_obj *text)
  */
 
 static void
-pdf_init_gstate(fz_context *ctx, pdf_gstate *gs, fz_matrix ctm)
+pdf_init_gstate(fz_context *ctx, pdf_gstate *gs, const fz_matrix *ctm)
 {
-	gs->ctm = ctm;
+	gs->ctm = *ctm;
 	gs->clip_depth = 0;
 
 	gs->stroke_state = fz_new_stroke_state(ctx);
@@ -984,7 +986,7 @@ copy_state(fz_context *ctx, pdf_gstate *gs, pdf_gstate *old)
 
 
 static pdf_csi *
-pdf_new_csi(pdf_document *xref, fz_device *dev, fz_matrix ctm, char *event, fz_cookie *cookie, pdf_gstate *gstate, int nested)
+pdf_new_csi(pdf_document *xref, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie, pdf_gstate *gstate, int nested)
 {
 	pdf_csi *csi;
 	fz_context *ctx = dev->ctx;
@@ -1019,7 +1021,7 @@ pdf_new_csi(pdf_document *xref, fz_device *dev, fz_matrix ctm, char *event, fz_c
 		csi->gcap = 64;
 		csi->gstate = fz_malloc_array(ctx, csi->gcap, sizeof(pdf_gstate));
 
-		csi->top_ctm = ctm;
+		csi->top_ctm = *ctm;
 		csi->nested_depth = nested;
 		pdf_init_gstate(ctx, &csi->gstate[0], ctm);
 		if (gstate)
@@ -1266,7 +1268,7 @@ pdf_unset_pattern(pdf_csi *csi, int what)
  */
 
 static void
-pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, fz_rect area, int what)
+pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, const fz_rect *area, int what)
 {
 	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gstate;
@@ -1274,6 +1276,7 @@ pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, fz_rect area, int what)
 	fz_matrix oldtopctm;
 	int x0, y0, x1, y1;
 	int oldtop;
+	fz_rect local_area;
 
 	pdf_gsave(csi);
 	gstate = csi->gstate + csi->gtop;
@@ -1308,22 +1311,23 @@ pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, fz_rect area, int what)
 		gstate->softmask = NULL;
 	}
 
-	ptm = fz_concat(pat->matrix, csi->top_ctm);
-	invptm = fz_invert_matrix(ptm);
+	fz_concat(&ptm, &pat->matrix, &csi->top_ctm);
+	fz_invert_matrix(&invptm, &ptm);
 
 	/* patterns are painted using the ctm in effect at the beginning
 	 * of the content stream. area = bbox of shape to be filled in
 	 * device space. Map it back to pattern space. */
-	area = fz_transform_rect(invptm, area);
+	local_area = *area;
+	fz_transform_rect(&local_area, &invptm);
 
 	/* When calculating the number of tiles required, we adjust by a small
 	 * amount to allow for rounding errors. By choosing this amount to be
 	 * smaller than 1/256, we guarantee we won't cause problems that will
 	 * be visible even under our most extreme antialiasing. */
-	x0 = floorf((area.x0 - pat->bbox.x0) / pat->xstep + 0.001);
-	y0 = floorf((area.y0 - pat->bbox.y0) / pat->ystep + 0.001);
-	x1 = ceilf((area.x1 - pat->bbox.x0) / pat->xstep - 0.001);
-	y1 = ceilf((area.y1 - pat->bbox.y0) / pat->ystep - 0.001);
+	x0 = floorf((local_area.x0 - pat->bbox.x0) / pat->xstep + 0.001);
+	y0 = floorf((local_area.y0 - pat->bbox.y0) / pat->ystep + 0.001);
+	x1 = ceilf((local_area.x1 - pat->bbox.x0) / pat->xstep - 0.001);
+	y1 = ceilf((local_area.y1 - pat->bbox.y0) / pat->ystep - 0.001);
 
 	oldtopctm = csi->top_ctm;
 	oldtop = csi->gtop;
@@ -1334,7 +1338,7 @@ pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, fz_rect area, int what)
 	if (0)
 #endif
 	{
-		fz_begin_tile(csi->dev, area, pat->bbox, pat->xstep, pat->ystep, ptm);
+		fz_begin_tile(csi->dev, &local_area, &pat->bbox, pat->xstep, pat->ystep, &ptm);
 		gstate->ctm = ptm;
 		csi->top_ctm = gstate->ctm;
 		pdf_gsave(csi);
@@ -1351,7 +1355,8 @@ pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, fz_rect area, int what)
 		{
 			for (x = x0; x < x1; x++)
 			{
-				gstate->ctm = fz_concat(fz_translate(x * pat->xstep, y * pat->ystep), ptm);
+				gstate->ctm = ptm;
+				fz_pre_translate(&gstate->ctm, x * pat->xstep, y * pat->ystep);
 				csi->top_ctm = gstate->ctm;
 				pdf_gsave(csi);
 				fz_try(ctx)
@@ -1378,13 +1383,14 @@ pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, fz_rect area, int what)
 }
 
 static void
-pdf_run_xobject(pdf_csi *csi, pdf_obj *resources, pdf_xobject *xobj, fz_matrix transform)
+pdf_run_xobject(pdf_csi *csi, pdf_obj *resources, pdf_xobject *xobj, const fz_matrix *transform)
 {
 	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gstate = NULL;
 	fz_matrix oldtopctm;
 	int oldtop = 0;
 	int popmask;
+	fz_matrix local_transform = *transform;
 
 	/* Avoid infinite recursion */
 	if (xobj == NULL || pdf_obj_mark(xobj->me))
@@ -1403,25 +1409,27 @@ pdf_run_xobject(pdf_csi *csi, pdf_obj *resources, pdf_xobject *xobj, fz_matrix t
 		popmask = 0;
 
 		/* apply xobject's transform matrix */
-		transform = fz_concat(xobj->matrix, transform);
-		gstate->ctm = fz_concat(transform, gstate->ctm);
+		fz_concat(&local_transform, &xobj->matrix, &local_transform);
+		fz_concat(&gstate->ctm, &local_transform, &gstate->ctm);
 
 		/* apply soft mask, create transparency group and reset state */
 		if (xobj->transparency)
 		{
+			fz_rect bbox = xobj->bbox;
+			fz_transform_rect(&bbox, &gstate->ctm);
 			if (gstate->softmask)
 			{
 				pdf_xobject *softmask = gstate->softmask;
-				fz_rect bbox = fz_transform_rect(gstate->ctm, xobj->bbox);
+
 
 				gstate->softmask = NULL;
 				popmask = 1;
 
-				fz_begin_mask(csi->dev, bbox, gstate->luminosity,
+				fz_begin_mask(csi->dev, &bbox, gstate->luminosity,
 					softmask->colorspace, gstate->softmask_bc);
 				fz_try(ctx)
 				{
-					pdf_run_xobject(csi, resources, softmask, fz_identity);
+					pdf_run_xobject(csi, resources, softmask, &fz_identity);
 				}
 				fz_catch(ctx)
 				{
@@ -1436,8 +1444,7 @@ pdf_run_xobject(pdf_csi *csi, pdf_obj *resources, pdf_xobject *xobj, fz_matrix t
 				pdf_drop_xobject(ctx, softmask);
 			}
 
-			fz_begin_group(csi->dev,
-				fz_transform_rect(gstate->ctm, xobj->bbox),
+			fz_begin_group(csi->dev, &bbox,
 				xobj->isolated, xobj->knockout, gstate->blendmode, gstate->fill.alpha);
 
 			gstate->blendmode = 0;
@@ -1609,7 +1616,7 @@ pdf_run_extgstate(pdf_csi *csi, pdf_obj *rdb, pdf_obj *extgstate)
 				if (!colorspace)
 					colorspace = fz_device_gray;
 
-				gstate->softmask_ctm = fz_concat(xobj->matrix, gstate->ctm);
+				fz_concat(&gstate->softmask_ctm, &xobj->matrix, &gstate->ctm);
 				gstate->softmask = xobj;
 				for (k = 0; k < colorspace->n; k++)
 					gstate->softmask_bc[k] = 0;
@@ -1854,7 +1861,7 @@ static void pdf_run_Do(pdf_csi *csi, pdf_obj *rdb)
 
 		fz_try(ctx)
 		{
-			pdf_run_xobject(csi, xobj->resources, xobj, fz_identity);
+			pdf_run_xobject(csi, xobj->resources, xobj, &fz_identity);
 		}
 		fz_always(ctx)
 		{
@@ -2108,19 +2115,16 @@ static void pdf_run_Ts(pdf_csi *csi)
 
 static void pdf_run_Td(pdf_csi *csi)
 {
-	fz_matrix m = fz_translate(csi->stack[0], csi->stack[1]);
-	csi->tlm = fz_concat(m, csi->tlm);
+	fz_pre_translate(&csi->tlm, csi->stack[0], csi->stack[1]);
 	csi->tm = csi->tlm;
 }
 
 static void pdf_run_TD(pdf_csi *csi)
 {
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
-	fz_matrix m;
 
 	gstate->leading = -csi->stack[1];
-	m = fz_translate(csi->stack[0], csi->stack[1]);
-	csi->tlm = fz_concat(m, csi->tlm);
+	fz_pre_translate(&csi->tlm, csi->stack[0], csi->stack[1]);
 	csi->tm = csi->tlm;
 }
 
@@ -2138,8 +2142,7 @@ static void pdf_run_Tm(pdf_csi *csi)
 static void pdf_run_Tstar(pdf_csi *csi)
 {
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
-	fz_matrix m = fz_translate(0, -gstate->leading);
-	csi->tlm = fz_concat(m, csi->tlm);
+	fz_pre_translate(&csi->tlm, 0, -gstate->leading);
 	csi->tm = csi->tlm;
 }
 
@@ -2205,7 +2208,7 @@ static void pdf_run_cm(pdf_csi *csi)
 	m.e = csi->stack[4];
 	m.f = csi->stack[5];
 
-	gstate->ctm = fz_concat(m, gstate->ctm);
+	fz_concat(&gstate->ctm, &m, &gstate->ctm);
 }
 
 static void pdf_run_d(pdf_csi *csi)
@@ -2428,11 +2431,9 @@ static void pdf_run_y(pdf_csi *csi)
 
 static void pdf_run_squote(pdf_csi *csi)
 {
-	fz_matrix m;
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 
-	m = fz_translate(0, -gstate->leading);
-	csi->tlm = fz_concat(m, csi->tlm);
+	fz_pre_translate(&csi->tlm, 0, -gstate->leading);
 	csi->tm = csi->tlm;
 
 	if (csi->string_len)
@@ -2443,14 +2444,12 @@ static void pdf_run_squote(pdf_csi *csi)
 
 static void pdf_run_dquote(pdf_csi *csi)
 {
-	fz_matrix m;
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 
 	gstate->word_space = csi->stack[0];
 	gstate->char_space = csi->stack[1];
 
-	m = fz_translate(0, -gstate->leading);
-	csi->tlm = fz_concat(m, csi->tlm);
+	fz_pre_translate(&csi->tlm, 0, -gstate->leading);
 	csi->tm = csi->tlm;
 
 	if (csi->string_len)
@@ -2866,17 +2865,21 @@ pdf_run_contents_buffer(pdf_csi *csi, pdf_obj *rdb, fz_buffer *contents)
 	}
 }
 
-static void pdf_run_page_contents_with_usage(pdf_document *xref, pdf_page *page, fz_device *dev, fz_matrix ctm, char *event, fz_cookie *cookie)
+static void pdf_run_page_contents_with_usage(pdf_document *xref, pdf_page *page, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie)
 {
 	fz_context *ctx = dev->ctx;
 	pdf_csi *csi;
+	fz_matrix local_ctm;
 
-	ctm = fz_concat(page->ctm, ctm);
+	fz_concat(&local_ctm, &page->ctm, ctm);
 
 	if (page->transparency)
-		fz_begin_group(dev, fz_transform_rect(ctm, page->mediabox), 1, 0, 0, 1);
+	{
+		fz_rect mediabox = page->mediabox;
+		fz_begin_group(dev, fz_transform_rect(&mediabox, &local_ctm), 1, 0, 0, 1);
+	}
 
-	csi = pdf_new_csi(xref, dev, ctm, event, cookie, NULL, 0);
+	csi = pdf_new_csi(xref, dev, &local_ctm, event, cookie, NULL, 0);
 	fz_try(ctx)
 	{
 		pdf_run_contents_object(csi, page->resources, page->contents);
@@ -2894,18 +2897,19 @@ static void pdf_run_page_contents_with_usage(pdf_document *xref, pdf_page *page,
 		fz_end_group(dev);
 }
 
-void pdf_run_page_contents(pdf_document *xref, pdf_page *page, fz_device *dev, fz_matrix ctm, fz_cookie *cookie)
+void pdf_run_page_contents(pdf_document *xref, pdf_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie)
 {
 	pdf_run_page_contents_with_usage(xref, page, dev, ctm, "View", cookie);
 }
 
-static void pdf_run_annot_with_usage(pdf_document *xref, pdf_page *page, pdf_annot *annot, fz_device *dev, fz_matrix ctm, char *event, fz_cookie *cookie)
+static void pdf_run_annot_with_usage(pdf_document *xref, pdf_page *page, pdf_annot *annot, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie)
 {
 	fz_context *ctx = dev->ctx;
 	pdf_csi *csi;
 	int flags;
+	fz_matrix local_ctm;
 
-	ctm = fz_concat(page->ctm, ctm);
+	fz_concat(&local_ctm, &page->ctm, ctm);
 
 	flags = pdf_to_int(pdf_dict_gets(annot->obj, "F"));
 
@@ -2919,12 +2923,12 @@ static void pdf_run_annot_with_usage(pdf_document *xref, pdf_page *page, pdf_ann
 	if (!strcmp(event, "View") && (flags & (1 << 5))) /* NoView */
 		return;
 
-	csi = pdf_new_csi(xref, dev, ctm, event, cookie, NULL, 0);
+	csi = pdf_new_csi(xref, dev, &local_ctm, event, cookie, NULL, 0);
 	if (!pdf_is_hidden_ocg(pdf_dict_gets(annot->obj, "OC"), csi, page->resources))
 	{
 		fz_try(ctx)
 		{
-			pdf_run_xobject(csi, page->resources, annot->ap, annot->matrix);
+			pdf_run_xobject(csi, page->resources, annot->ap, &annot->matrix);
 		}
 		fz_catch(ctx)
 		{
@@ -2935,12 +2939,12 @@ static void pdf_run_annot_with_usage(pdf_document *xref, pdf_page *page, pdf_ann
 	pdf_free_csi(csi);
 }
 
-void pdf_run_annot(pdf_document *xref, pdf_page *page, pdf_annot *annot, fz_device *dev, fz_matrix ctm, fz_cookie *cookie)
+void pdf_run_annot(pdf_document *xref, pdf_page *page, pdf_annot *annot, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie)
 {
 	pdf_run_annot_with_usage(xref, page, annot, dev, ctm, "View", cookie);
 }
 
-static void pdf_run_page_annots_with_usage(pdf_document *xref, pdf_page *page, fz_device *dev, fz_matrix ctm, char *event, fz_cookie *cookie)
+static void pdf_run_page_annots_with_usage(pdf_document *xref, pdf_page *page, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie)
 {
 	pdf_annot *annot;
 
@@ -2967,20 +2971,20 @@ static void pdf_run_page_annots_with_usage(pdf_document *xref, pdf_page *page, f
 }
 
 void
-pdf_run_page_with_usage(pdf_document *xref, pdf_page *page, fz_device *dev, fz_matrix ctm, char *event, fz_cookie *cookie)
+pdf_run_page_with_usage(pdf_document *xref, pdf_page *page, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie)
 {
 	pdf_run_page_contents_with_usage(xref, page, dev, ctm, event, cookie);
 	pdf_run_page_annots_with_usage(xref, page, dev, ctm, event, cookie);
 }
 
 void
-pdf_run_page(pdf_document *xref, pdf_page *page, fz_device *dev, fz_matrix ctm, fz_cookie *cookie)
+pdf_run_page(pdf_document *xref, pdf_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie)
 {
 	pdf_run_page_with_usage(xref, page, dev, ctm, "View", cookie);
 }
 
 void
-pdf_run_glyph(pdf_document *xref, pdf_obj *resources, fz_buffer *contents, fz_device *dev, fz_matrix ctm, void *gstate, int nested_depth)
+pdf_run_glyph(pdf_document *xref, pdf_obj *resources, fz_buffer *contents, fz_device *dev, const fz_matrix *ctm, void *gstate, int nested_depth)
 {
 	pdf_csi *csi = pdf_new_csi(xref, dev, ctm, "View", NULL, gstate, nested_depth+1);
 	fz_context *ctx = xref->ctx;
diff --git a/pdf/pdf_object.c b/pdf/pdf_object.c
index 8a2d71fc..a2d9d37b 100644
--- a/pdf/pdf_object.c
+++ b/pdf/pdf_object.c
@@ -575,7 +575,7 @@ pdf_array_contains(pdf_obj *arr, pdf_obj *obj)
 	return 0;
 }
 
-pdf_obj *pdf_new_rect(fz_context *ctx, fz_rect rect)
+pdf_obj *pdf_new_rect(fz_context *ctx, const fz_rect *rect)
 {
 	pdf_obj *arr = NULL;
 	pdf_obj *item = NULL;
@@ -586,22 +586,22 @@ pdf_obj *pdf_new_rect(fz_context *ctx, fz_rect rect)
 	{
 		arr = pdf_new_array(ctx, 4);
 
-		item = pdf_new_real(ctx, rect.x0);
+		item = pdf_new_real(ctx, rect->x0);
 		pdf_array_push(arr, item);
 		pdf_drop_obj(item);
 		item = NULL;
 
-		item = pdf_new_real(ctx, rect.y0);
+		item = pdf_new_real(ctx, rect->y0);
 		pdf_array_push(arr, item);
 		pdf_drop_obj(item);
 		item = NULL;
 
-		item = pdf_new_real(ctx, rect.x1);
+		item = pdf_new_real(ctx, rect->x1);
 		pdf_array_push(arr, item);
 		pdf_drop_obj(item);
 		item = NULL;
 
-		item = pdf_new_real(ctx, rect.y1);
+		item = pdf_new_real(ctx, rect->y1);
 		pdf_array_push(arr, item);
 		pdf_drop_obj(item);
 		item = NULL;
@@ -616,7 +616,7 @@ pdf_obj *pdf_new_rect(fz_context *ctx, fz_rect rect)
 	return arr;
 }
 
-pdf_obj *pdf_new_matrix(fz_context *ctx, fz_matrix mtx)
+pdf_obj *pdf_new_matrix(fz_context *ctx, const fz_matrix *mtx)
 {
 	pdf_obj *arr = NULL;
 	pdf_obj *item = NULL;
@@ -627,32 +627,32 @@ pdf_obj *pdf_new_matrix(fz_context *ctx, fz_matrix mtx)
 	{
 		arr = pdf_new_array(ctx, 6);
 
-		item = pdf_new_real(ctx, mtx.a);
+		item = pdf_new_real(ctx, mtx->a);
 		pdf_array_push(arr, item);
 		pdf_drop_obj(item);
 		item = NULL;
 
-		item = pdf_new_real(ctx, mtx.b);
+		item = pdf_new_real(ctx, mtx->b);
 		pdf_array_push(arr, item);
 		pdf_drop_obj(item);
 		item = NULL;
 
-		item = pdf_new_real(ctx, mtx.c);
+		item = pdf_new_real(ctx, mtx->c);
 		pdf_array_push(arr, item);
 		pdf_drop_obj(item);
 		item = NULL;
 
-		item = pdf_new_real(ctx, mtx.d);
+		item = pdf_new_real(ctx, mtx->d);
 		pdf_array_push(arr, item);
 		pdf_drop_obj(item);
 		item = NULL;
 
-		item = pdf_new_real(ctx, mtx.e);
+		item = pdf_new_real(ctx, mtx->e);
 		pdf_array_push(arr, item);
 		pdf_drop_obj(item);
 		item = NULL;
 
-		item = pdf_new_real(ctx, mtx.f);
+		item = pdf_new_real(ctx, mtx->f);
 		pdf_array_push(arr, item);
 		pdf_drop_obj(item);
 		item = NULL;
diff --git a/pdf/pdf_page.c b/pdf/pdf_page.c
index a071732a..a3627176 100644
--- a/pdf/pdf_page.c
+++ b/pdf/pdf_page.c
@@ -339,8 +339,8 @@ pdf_load_page(pdf_document *xref, int number)
 	pdf_annot *annot;
 	pdf_obj *pageobj, *pageref, *obj;
 	fz_rect mediabox, cropbox, realbox;
-	fz_matrix ctm;
 	float userunit;
+	fz_matrix mat;
 
 	pdf_load_page_tree(xref);
 	if (number < 0 || number >= xref->page_len)
@@ -363,8 +363,8 @@ pdf_load_page(pdf_document *xref, int number)
 	else
 		userunit = 1;
 
-	mediabox = pdf_to_rect(ctx, pdf_dict_gets(pageobj, "MediaBox"));
-	if (fz_is_empty_rect(mediabox))
+	pdf_to_rect(ctx, pdf_dict_gets(pageobj, "MediaBox"), &mediabox);
+	if (fz_is_empty_rect(&mediabox))
 	{
 		fz_warn(ctx, "cannot find page size for page %d", number + 1);
 		mediabox.x0 = 0;
@@ -373,9 +373,9 @@ pdf_load_page(pdf_document *xref, int number)
 		mediabox.y1 = 792;
 	}
 
-	cropbox = pdf_to_rect(ctx, pdf_dict_gets(pageobj, "CropBox"));
-	if (!fz_is_empty_rect(cropbox))
-		mediabox = fz_intersect_rect(mediabox, cropbox);
+	pdf_to_rect(ctx, pdf_dict_gets(pageobj, "CropBox"), &cropbox);
+	if (!fz_is_empty_rect(&cropbox))
+		fz_intersect_rect(&mediabox, &cropbox);
 
 	page->mediabox.x0 = fz_min(mediabox.x0, mediabox.x1) * userunit;
 	page->mediabox.y0 = fz_min(mediabox.y0, mediabox.y1) * userunit;
@@ -398,16 +398,16 @@ pdf_load_page(pdf_document *xref, int number)
 	if (page->rotate > 360)
 		page->rotate = 0;
 
-	ctm = fz_concat(fz_rotate(-page->rotate), fz_scale(1, -1));
-	realbox = fz_transform_rect(ctm, page->mediabox);
-	ctm = fz_concat(ctm, fz_scale(userunit, userunit));
-	ctm = fz_concat(ctm, fz_translate(-realbox.x0, -realbox.y0));
-	page->ctm = ctm;
+	fz_pre_rotate(fz_scale(&page->ctm, 1, -1), -page->rotate);
+	realbox = page->mediabox;
+	fz_transform_rect(&realbox, &page->ctm);
+	fz_pre_scale(fz_translate(&mat, -realbox.x0, -realbox.y0), userunit, userunit);
+	fz_concat(&page->ctm, &page->ctm, &mat);
 
 	obj = pdf_dict_gets(pageobj, "Annots");
 	if (obj)
 	{
-		page->links = pdf_load_link_annots(xref, obj, page->ctm);
+		page->links = pdf_load_link_annots(xref, obj, &page->ctm);
 		page->annots = pdf_load_annots(xref, obj, page);
 	}
 
@@ -445,13 +445,15 @@ pdf_load_page(pdf_document *xref, int number)
 	return page;
 }
 
-fz_rect
-pdf_bound_page(pdf_document *xref, pdf_page *page)
+fz_rect *
+pdf_bound_page(pdf_document *xref, pdf_page *page, fz_rect *bounds)
 {
-	fz_rect bounds, mediabox = fz_transform_rect(fz_rotate(page->rotate), page->mediabox);
-	bounds.x0 = bounds.y0 = 0;
-	bounds.x1 = mediabox.x1 - mediabox.x0;
-	bounds.y1 = mediabox.y1 - mediabox.y0;
+	fz_matrix mtx;
+	fz_rect mediabox = page->mediabox;
+	fz_transform_rect(&mediabox, fz_rotate(&mtx, page->rotate));
+	bounds->x0 = bounds->y0 = 0;
+	bounds->x1 = mediabox.x1 - mediabox.x0;
+	bounds->y1 = mediabox.y1 - mediabox.y0;
 	return bounds;
 }
 
diff --git a/pdf/pdf_parse.c b/pdf/pdf_parse.c
index 58165894..365c9ffd 100644
--- a/pdf/pdf_parse.c
+++ b/pdf/pdf_parse.c
@@ -1,31 +1,29 @@
 #include "fitz-internal.h"
 #include "mupdf-internal.h"
 
-fz_rect
-pdf_to_rect(fz_context *ctx, pdf_obj *array)
+fz_rect *
+pdf_to_rect(fz_context *ctx, pdf_obj *array, fz_rect *r)
 {
-	fz_rect r;
 	float a = pdf_to_real(pdf_array_get(array, 0));
 	float b = pdf_to_real(pdf_array_get(array, 1));
 	float c = pdf_to_real(pdf_array_get(array, 2));
 	float d = pdf_to_real(pdf_array_get(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);
+	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;
 }
 
-fz_matrix
-pdf_to_matrix(fz_context *ctx, pdf_obj *array)
+fz_matrix *
+pdf_to_matrix(fz_context *ctx, pdf_obj *array, fz_matrix *m)
 {
-	fz_matrix m;
-	m.a = pdf_to_real(pdf_array_get(array, 0));
-	m.b = pdf_to_real(pdf_array_get(array, 1));
-	m.c = pdf_to_real(pdf_array_get(array, 2));
-	m.d = pdf_to_real(pdf_array_get(array, 3));
-	m.e = pdf_to_real(pdf_array_get(array, 4));
-	m.f = pdf_to_real(pdf_array_get(array, 5));
+	m->a = pdf_to_real(pdf_array_get(array, 0));
+	m->b = pdf_to_real(pdf_array_get(array, 1));
+	m->c = pdf_to_real(pdf_array_get(array, 2));
+	m->d = pdf_to_real(pdf_array_get(array, 3));
+	m->e = pdf_to_real(pdf_array_get(array, 4));
+	m->f = pdf_to_real(pdf_array_get(array, 5));
 	return m;
 }
 
diff --git a/pdf/pdf_pattern.c b/pdf/pdf_pattern.c
index af96c2d5..5647106b 100644
--- a/pdf/pdf_pattern.c
+++ b/pdf/pdf_pattern.c
@@ -58,11 +58,11 @@ pdf_load_pattern(pdf_document *xref, pdf_obj *dict)
 	pat->ystep = pdf_to_real(pdf_dict_gets(dict, "YStep"));
 
 	obj = pdf_dict_gets(dict, "BBox");
-	pat->bbox = pdf_to_rect(ctx, obj);
+	pdf_to_rect(ctx, obj, &pat->bbox);
 
 	obj = pdf_dict_gets(dict, "Matrix");
 	if (obj)
-		pat->matrix = pdf_to_matrix(ctx, obj);
+		pdf_to_matrix(ctx, obj, &pat->matrix);
 	else
 		pat->matrix = fz_identity;
 
diff --git a/pdf/pdf_shade.c b/pdf/pdf_shade.c
index 95726975..2eee5168 100644
--- a/pdf/pdf_shade.c
+++ b/pdf/pdf_shade.c
@@ -69,10 +69,11 @@ pdf_load_function_based_shading(fz_shade *shade, pdf_document *xref, pdf_obj *di
 		y1 = pdf_to_real(pdf_array_get(obj, 3));
 	}
 
-	matrix = fz_identity;
 	obj = pdf_dict_gets(dict, "Matrix");
 	if (obj)
-		matrix = pdf_to_matrix(ctx, obj);
+		pdf_to_matrix(ctx, obj, &matrix);
+	else
+		matrix = fz_identity;
 	shade->u.f.matrix = matrix;
 	shade->u.f.xdivs = FUNSEGS;
 	shade->u.f.ydivs = FUNSEGS;
@@ -312,7 +313,7 @@ pdf_load_type7_shade(fz_shade *shade, pdf_document *xref, pdf_obj *dict,
 /* Load all of the shading dictionary parameters, then switch on the shading type. */
 
 static fz_shade *
-pdf_load_shading_dict(pdf_document *xref, pdf_obj *dict, fz_matrix transform)
+pdf_load_shading_dict(pdf_document *xref, pdf_obj *dict, const fz_matrix *transform)
 {
 	fz_shade *shade = NULL;
 	pdf_function *func[FZ_MAX_COLORS] = { NULL };
@@ -334,7 +335,7 @@ pdf_load_shading_dict(pdf_document *xref, pdf_obj *dict, fz_matrix transform)
 		shade->type = FZ_MESH_TYPE4;
 		shade->use_background = 0;
 		shade->use_function = 0;
-		shade->matrix = transform;
+		shade->matrix = *transform;
 		shade->bbox = fz_infinite_rect;
 
 		shade->colorspace = NULL;
@@ -359,9 +360,7 @@ pdf_load_shading_dict(pdf_document *xref, pdf_obj *dict, fz_matrix transform)
 
 		obj = pdf_dict_gets(dict, "BBox");
 		if (pdf_is_array(obj))
-		{
-			shade->bbox = pdf_to_rect(ctx, obj);
-		}
+			pdf_to_rect(ctx, obj, &shade->bbox);
 
 		obj = pdf_dict_gets(dict, "Function");
 		if (pdf_is_dict(obj))
@@ -469,7 +468,7 @@ pdf_load_shading(pdf_document *xref, pdf_obj *dict)
 	{
 		obj = pdf_dict_gets(dict, "Matrix");
 		if (obj)
-			mat = pdf_to_matrix(ctx, obj);
+			pdf_to_matrix(ctx, obj, &mat);
 		else
 			mat = fz_identity;
 
@@ -486,13 +485,13 @@ pdf_load_shading(pdf_document *xref, pdf_obj *dict)
 		if (!obj)
 			fz_throw(ctx, "syntaxerror: missing shading dictionary");
 
-		shade = pdf_load_shading_dict(xref, obj, mat);
+		shade = pdf_load_shading_dict(xref, obj, &mat);
 	}
 
 	/* Naked shading dictionary */
 	else
 	{
-		shade = pdf_load_shading_dict(xref, dict, fz_identity);
+		shade = pdf_load_shading_dict(xref, dict, &fz_identity);
 	}
 
 	pdf_store_item(ctx, dict, shade, fz_shade_size(shade));
diff --git a/pdf/pdf_type3.c b/pdf/pdf_type3.c
index d96a160a..8dd780dd 100644
--- a/pdf/pdf_type3.c
+++ b/pdf/pdf_type3.c
@@ -2,7 +2,7 @@
 #include "mupdf-internal.h"
 
 static void
-pdf_run_glyph_func(void *doc, void *rdb, fz_buffer *contents, fz_device *dev, fz_matrix ctm, void *gstate, int nested_depth)
+pdf_run_glyph_func(void *doc, void *rdb, fz_buffer *contents, fz_device *dev, const fz_matrix *ctm, void *gstate, int nested_depth)
 {
 	pdf_run_glyph(doc, (pdf_obj *)rdb, contents, dev, ctm, gstate, nested_depth);
 }
@@ -44,13 +44,12 @@ pdf_load_type3_font(pdf_document *xref, pdf_obj *rdb, pdf_obj *dict)
 		fontdesc = pdf_new_font_desc(ctx);
 
 		obj = pdf_dict_gets(dict, "FontMatrix");
-		matrix = pdf_to_matrix(ctx, obj);
+		pdf_to_matrix(ctx, obj, &matrix);
 
 		obj = pdf_dict_gets(dict, "FontBBox");
-		bbox = pdf_to_rect(ctx, obj);
-		bbox = fz_transform_rect(matrix, bbox);
+		fz_transform_rect(pdf_to_rect(ctx, obj, &bbox), &matrix);
 
-		fontdesc->font = fz_new_type3_font(ctx, buf, matrix);
+		fontdesc->font = fz_new_type3_font(ctx, buf, &matrix);
 		fontdesc->size += sizeof(fz_font) + 256 * (sizeof(fz_buffer*) + sizeof(float));
 
 		fz_set_font_bbox(ctx, fontdesc->font, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
diff --git a/pdf/pdf_xobject.c b/pdf/pdf_xobject.c
index 17d8300f..a334392f 100644
--- a/pdf/pdf_xobject.c
+++ b/pdf/pdf_xobject.c
@@ -60,11 +60,11 @@ pdf_load_xobject(pdf_document *xref, pdf_obj *dict)
 	fz_try(ctx)
 	{
 		obj = pdf_dict_gets(dict, "BBox");
-		form->bbox = pdf_to_rect(ctx, obj);
+		pdf_to_rect(ctx, obj, &form->bbox);
 
 		obj = pdf_dict_gets(dict, "Matrix");
 		if (obj)
-			form->matrix = pdf_to_matrix(ctx, obj);
+			pdf_to_matrix(ctx, obj, &form->matrix);
 		else
 			form->matrix = fz_identity;
 
@@ -111,7 +111,7 @@ pdf_load_xobject(pdf_document *xref, pdf_obj *dict)
 }
 
 pdf_obj *
-pdf_new_xobject(pdf_document *xref, fz_rect bbox, fz_matrix mat)
+pdf_new_xobject(pdf_document *xref, const fz_rect *bbox, const fz_matrix *mat)
 {
 	int idict_num;
 	pdf_obj *idict = NULL;
@@ -185,9 +185,9 @@ pdf_new_xobject(pdf_document *xref, fz_rect bbox, fz_matrix mat)
 		form->me = NULL;
 		form->iteration = 0;
 
-		form->bbox = bbox;
+		form->bbox = *bbox;
 
-		form->matrix = mat;
+		form->matrix = *mat;
 
 		form->isolated = 0;
 		form->knockout = 0;
diff --git a/pdf/pdf_xref_aux.c b/pdf/pdf_xref_aux.c
index 22f21b1f..58335a4e 100644
--- a/pdf/pdf_xref_aux.c
+++ b/pdf/pdf_xref_aux.c
@@ -9,12 +9,12 @@
 	resulting executables.
 */
 
-static void pdf_run_page_contents_shim(fz_document *doc, fz_page *page, fz_device *dev, fz_matrix transform, fz_cookie *cookie)
+static void pdf_run_page_contents_shim(fz_document *doc, fz_page *page, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie)
 {
 	pdf_run_page_contents((pdf_document*)doc, (pdf_page*)page, dev, transform, cookie);
 }
 
-static void pdf_run_annot_shim(fz_document *doc, fz_page *page, fz_annot *annot, fz_device *dev, fz_matrix transform, fz_cookie *cookie)
+static void pdf_run_annot_shim(fz_document *doc, fz_page *page, fz_annot *annot, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie)
 {
 	pdf_run_annot((pdf_document*)doc, (pdf_page*)page, (pdf_annot *)annot, dev, transform, cookie);
 }
diff --git a/win32/libmupdf.vcproj b/win32/libmupdf.vcproj
index cee47cb5..9edcfeff 100644
--- a/win32/libmupdf.vcproj
+++ b/win32/libmupdf.vcproj
@@ -633,6 +633,10 @@
 			Name="xps"
 			>
 			<File
+				RelativePath="..\xps\muxps-internal.h"
+				>
+			</File>
+			<File
 				RelativePath="..\xps\muxps.h"
 				>
 			</File>
diff --git a/xps/muxps-internal.h b/xps/muxps-internal.h
index fab90963..438f5f13 100644
--- a/xps/muxps-internal.h
+++ b/xps/muxps-internal.h
@@ -74,13 +74,13 @@ void xps_free_page_list(xps_document *doc);
 int xps_count_pages(xps_document *doc);
 xps_page *xps_load_page(xps_document *doc, int number);
 fz_link *xps_load_links(xps_document *doc, xps_page *page);
-fz_rect xps_bound_page(xps_document *doc, xps_page *page);
+fz_rect *xps_bound_page(xps_document *doc, xps_page *page, fz_rect *rect);
 void xps_free_page(xps_document *doc, xps_page *page);
 
 fz_outline *xps_load_outline(xps_document *doc);
 
 int xps_lookup_link_target(xps_document *doc, char *target_uri);
-void xps_add_link(xps_document *doc, fz_rect area, char *base_uri, char *target_uri);
+void xps_add_link(xps_document *doc, const fz_rect *area, char *base_uri, char *target_uri);
 /*
  * Images, fonts, and colorspaces.
  */
@@ -139,31 +139,29 @@ void xps_print_resource_dictionary(xps_resource *dict);
  * Fixed page/graphics parsing.
  */
 
-void xps_run_page(xps_document *doc, xps_page *page, fz_device *dev, fz_matrix ctm, fz_cookie *cookie);
+void xps_parse_fixed_page(xps_document *doc, const fz_matrix *ctm, xps_page *page);
+void xps_parse_canvas(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_path(xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_solid_color_brush(xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_image_brush(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(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(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(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node);
 
-void xps_parse_fixed_page(xps_document *doc, fz_matrix ctm, xps_page *page);
-void xps_parse_canvas(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_path(xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_glyphs(xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_solid_color_brush(xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_image_brush(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_visual_brush(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_linear_gradient_brush(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_radial_gradient_brush(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
-
-void xps_parse_tiling_brush(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *root, void(*func)(xps_document*, fz_matrix, fz_rect, char*, xps_resource*, fz_xml*, void*), void *user);
+void xps_parse_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root, void(*func)(xps_document*, const fz_matrix *, const fz_rect *, char*, xps_resource*, fz_xml*, void*), void *user);
 
 void xps_parse_matrix_transform(xps_document *doc, fz_xml *root, fz_matrix *matrix);
 void xps_parse_render_transform(xps_document *doc, char *text, fz_matrix *matrix);
 void xps_parse_rectangle(xps_document *doc, char *text, fz_rect *rect);
 
-void xps_begin_opacity(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_begin_opacity(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_end_opacity(xps_document *doc, char *base_uri, xps_resource *dict, char *opacity_att, fz_xml *opacity_mask_tag);
 
-void xps_parse_brush(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_element(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_element(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node);
 
-void xps_clip(xps_document *doc, fz_matrix ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag);
+void xps_clip(xps_document *doc, const fz_matrix *ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag);
 
 fz_xml *xps_lookup_alternate_content(fz_xml *node);
 
diff --git a/xps/muxps.h b/xps/muxps.h
index 86e50cfb..cb17c8b4 100644
--- a/xps/muxps.h
+++ b/xps/muxps.h
@@ -44,8 +44,8 @@ void xps_close_document(xps_document *doc);
 
 int xps_count_pages(xps_document *doc);
 xps_page *xps_load_page(xps_document *doc, int number);
-fz_rect xps_bound_page(xps_document *doc, xps_page *page);
-void xps_run_page(xps_document *doc, xps_page *page, fz_device *dev, fz_matrix ctm, fz_cookie *cookie);
+fz_rect *xps_bound_page(xps_document *doc, xps_page *page, fz_rect *rect);
+void xps_run_page(xps_document *doc, xps_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie);
 fz_link *xps_load_links(xps_document *doc, xps_page *page);
 void xps_free_page(xps_document *doc, xps_page *page);
 
diff --git a/xps/xps_common.c b/xps/xps_common.c
index ef254f36..640ea47a 100644
--- a/xps/xps_common.c
+++ b/xps/xps_common.c
@@ -29,7 +29,7 @@ xps_lookup_alternate_content(fz_xml *node)
 }
 
 void
-xps_parse_brush(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node)
+xps_parse_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node)
 {
 	if (doc->cookie && doc->cookie->abort)
 		return;
@@ -47,7 +47,7 @@ xps_parse_brush(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri,
 }
 
 void
-xps_parse_element(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node)
+xps_parse_element(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node)
 {
 	if (doc->cookie && doc->cookie->abort)
 		return;
@@ -67,7 +67,7 @@ xps_parse_element(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri
 }
 
 void
-xps_begin_opacity(xps_document *doc, fz_matrix ctm, fz_rect area,
+xps_begin_opacity(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)
 {
diff --git a/xps/xps_doc.c b/xps/xps_doc.c
index 4fefceb3..84d7bbd1 100644
--- a/xps/xps_doc.c
+++ b/xps/xps_doc.c
@@ -78,7 +78,7 @@ xps_add_fixed_document(xps_document *doc, char *name)
 }
 
 void
-xps_add_link(xps_document *doc, fz_rect area, char *base_uri, char *target_uri)
+xps_add_link(xps_document *doc, const fz_rect *area, char *base_uri, char *target_uri)
 {
 	int len;
 	char *buffer = NULL;
@@ -506,13 +506,12 @@ xps_load_page(xps_document *doc, int number)
 	return NULL;
 }
 
-fz_rect
-xps_bound_page(xps_document *doc, xps_page *page)
+fz_rect *
+xps_bound_page(xps_document *doc, xps_page *page, fz_rect *bounds)
 {
-	fz_rect bounds;
-	bounds.x0 = bounds.y0 = 0;
-	bounds.x1 = page->width * 72.0f / 96.0f;
-	bounds.y1 = page->height * 72.0f / 96.0f;
+	bounds->x0 = bounds->y0 = 0;
+	bounds->x1 = page->width * 72.0f / 96.0f;
+	bounds->y1 = page->height * 72.0f / 96.0f;
 	return bounds;
 }
 
diff --git a/xps/xps_glyphs.c b/xps/xps_glyphs.c
index cdc7b159..1838167e 100644
--- a/xps/xps_glyphs.c
+++ b/xps/xps_glyphs.c
@@ -252,7 +252,7 @@ xps_parse_glyph_metrics(char *s, float *advance, float *uofs, float *vofs)
  * Calculate metrics for positioning.
  */
 static fz_text *
-xps_parse_glyphs_imp(xps_document *doc, fz_matrix ctm,
+xps_parse_glyphs_imp(xps_document *doc, const fz_matrix *ctm,
 	fz_font *font, float size, float originx, float originy,
 	int is_sideways, int bidi_level,
 	char *indices, char *unicode)
@@ -278,11 +278,13 @@ xps_parse_glyphs_imp(xps_document *doc, fz_matrix ctm,
 	}
 
 	if (is_sideways)
-		tm = fz_concat(fz_scale(-size, size), fz_rotate(90));
+	{
+		fz_pre_scale(fz_rotate(&tm, 90), -size, size);
+	}
 	else
-		tm = fz_scale(size, -size);
+		fz_scale(&tm, size, -size);
 
-	text = fz_new_text(doc->ctx, font, tm, is_sideways);
+	text = fz_new_text(doc->ctx, font, &tm, is_sideways);
 
 	while ((us && un > 0) || (is && *is))
 	{
@@ -369,7 +371,7 @@ xps_parse_glyphs_imp(xps_document *doc, fz_matrix ctm,
 }
 
 void
-xps_parse_glyphs(xps_document *doc, fz_matrix ctm,
+xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm,
 		char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	fz_xml *node;
@@ -416,6 +418,8 @@ xps_parse_glyphs(xps_document *doc, fz_matrix ctm,
 	fz_text *text;
 	fz_rect area;
 
+	fz_matrix local_ctm = *ctm;
+
 	/*
 	 * Extract attributes and extended attributes.
 	 */
@@ -557,24 +561,24 @@ xps_parse_glyphs(xps_document *doc, fz_matrix ctm,
 			xps_parse_render_transform(doc, transform_att, &transform);
 		if (transform_tag)
 			xps_parse_matrix_transform(doc, transform_tag, &transform);
-		ctm = fz_concat(transform, ctm);
+		fz_concat(&local_ctm, &transform, &local_ctm);
 	}
 
 	if (clip_att || clip_tag)
-		xps_clip(doc, ctm, dict, clip_att, clip_tag);
+		xps_clip(doc, &local_ctm, dict, clip_att, clip_tag);
 
 	font_size = fz_atof(font_size_att);
 
-	text = xps_parse_glyphs_imp(doc, ctm, font, font_size,
+	text = xps_parse_glyphs_imp(doc, &local_ctm, font, font_size,
 			fz_atof(origin_x_att), fz_atof(origin_y_att),
 			is_sideways, bidi_level, indices_att, unicode_att);
 
-	area = fz_bound_text(doc->ctx, text, ctm);
+	fz_bound_text(doc->ctx, text, &local_ctm, &area);
 
 	if (navigate_uri_att)
-		xps_add_link(doc, area, base_uri, navigate_uri_att);
+		xps_add_link(doc, &area, base_uri, navigate_uri_att);
 
-	xps_begin_opacity(doc, ctm, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
+	xps_begin_opacity(doc, &local_ctm, &area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
 
 	/* If it's a solid color brush fill/stroke do a simple fill */
 
@@ -595,7 +599,7 @@ xps_parse_glyphs(xps_document *doc, fz_matrix ctm,
 			samples[0] *= fz_atof(fill_opacity_att);
 		xps_set_color(doc, colorspace, samples);
 
-		fz_fill_text(doc->dev, text, ctm,
+		fz_fill_text(doc->dev, text, &local_ctm,
 			doc->colorspace, doc->color, doc->alpha);
 	}
 
@@ -603,8 +607,8 @@ xps_parse_glyphs(xps_document *doc, fz_matrix ctm,
 
 	if (fill_tag)
 	{
-		fz_clip_text(doc->dev, text, ctm, 0);
-		xps_parse_brush(doc, ctm, area, fill_uri, dict, fill_tag);
+		fz_clip_text(doc->dev, text, &local_ctm, 0);
+		xps_parse_brush(doc, &local_ctm, &area, fill_uri, dict, fill_tag);
 		fz_pop_clip(doc->dev);
 	}
 
diff --git a/xps/xps_gradient.c b/xps/xps_gradient.c
index a0b342bc..04438df8 100644
--- a/xps/xps_gradient.c
+++ b/xps/xps_gradient.c
@@ -202,7 +202,7 @@ xps_sample_gradient_stops(fz_shade *shade, struct stop *stops, int count)
  */
 
 static void
-xps_draw_one_radial_gradient(xps_document *doc, fz_matrix ctm,
+xps_draw_one_radial_gradient(xps_document *doc, const fz_matrix *ctm,
 	struct stop *stops, int count,
 	int extend,
 	float x0, float y0, float r0,
@@ -241,7 +241,7 @@ xps_draw_one_radial_gradient(xps_document *doc, fz_matrix ctm,
  */
 
 static void
-xps_draw_one_linear_gradient(xps_document *doc, fz_matrix ctm,
+xps_draw_one_linear_gradient(xps_document *doc, const fz_matrix *ctm,
 	struct stop *stops, int count,
 	int extend,
 	float x0, float y0, float x1, float y1)
@@ -290,7 +290,7 @@ static inline float point_inside_circle(float px, float py, float x, float y, fl
 }
 
 static void
-xps_draw_radial_gradient(xps_document *doc, fz_matrix ctm, fz_rect area,
+xps_draw_radial_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
 	struct stop *stops, int count,
 	fz_xml *root, int spread)
 {
@@ -300,6 +300,9 @@ xps_draw_radial_gradient(xps_document *doc, fz_matrix ctm, fz_rect area,
 	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");
@@ -325,7 +328,9 @@ xps_draw_radial_gradient(xps_document *doc, fz_matrix ctm, fz_rect area,
 
 	/* scale the ctm to make ellipses */
 	if (fz_abs(xrad) > FLT_EPSILON)
-		ctm = fz_concat(fz_scale(1, yrad / xrad), ctm);
+	{
+		fz_pre_scale(&local_ctm, 1, yrad/xrad);
+	}
 
 	if (yrad != 0.0)
 	{
@@ -337,16 +342,16 @@ xps_draw_radial_gradient(xps_document *doc, fz_matrix ctm, fz_rect area,
 	r0 = 0;
 	r1 = xrad;
 
-	area = fz_transform_rect(fz_invert_matrix(ctm), area);
-	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));
+	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));
 
 	if (spread == SPREAD_REPEAT)
 	{
 		for (i = ma - 1; i >= 0; i--)
-			xps_draw_one_radial_gradient(doc, ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad);
+			xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad);
 	}
 	else if (spread == SPREAD_REFLECT)
 	{
@@ -354,13 +359,13 @@ xps_draw_radial_gradient(xps_document *doc, fz_matrix ctm, fz_rect area,
 			ma++;
 		for (i = ma - 2; i >= 0; i -= 2)
 		{
-			xps_draw_one_radial_gradient(doc, ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad);
-			xps_draw_one_radial_gradient(doc, ctm, stops, count, 0, x0, y0, r0 + (i + 2) * xrad, x1, y1, r1 + i * xrad);
+			xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad);
+			xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 0, x0, y0, r0 + (i + 2) * xrad, x1, y1, r1 + i * xrad);
 		}
 	}
 	else
 	{
-		xps_draw_one_radial_gradient(doc, ctm, stops, count, 1, x0, y0, r0, x1, y1, r1);
+		xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 1, x0, y0, r0, x1, y1, r1);
 	}
 }
 
@@ -370,7 +375,7 @@ xps_draw_radial_gradient(xps_document *doc, fz_matrix ctm, fz_rect area,
  */
 
 static void
-xps_draw_linear_gradient(xps_document *doc, fz_matrix ctm, fz_rect area,
+xps_draw_linear_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
 	struct stop *stops, int count,
 	fz_xml *root, int spread)
 {
@@ -378,6 +383,8 @@ xps_draw_linear_gradient(xps_document *doc, fz_matrix ctm, fz_rect area,
 	int i, mi, ma;
 	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");
@@ -391,15 +398,15 @@ xps_draw_linear_gradient(xps_document *doc, fz_matrix ctm, fz_rect area,
 		xps_parse_point(end_point_att, &x1, &y1);
 
 	p1.x = x0; p1.y = y0; p2.x = x1; p2.y = y1;
-	area = fz_transform_rect(fz_invert_matrix(ctm), area);
+	fz_transform_rect(&local_area, fz_invert_matrix(&inv, ctm));
 	x = p2.x - p1.x; y = p2.y - p1.y;
-	k = ((area.x0 - p1.x) * x + (area.y0 - p1.y) * y) / (x * x + y * y);
+	k = ((local_area.x0 - p1.x) * x + (local_area.y0 - p1.y) * y) / (x * x + y * y);
 	mi = floorf(k); ma = ceilf(k);
-	k = ((area.x1 - p1.x) * x + (area.y0 - p1.y) * y) / (x * x + y * y);
+	k = ((local_area.x1 - p1.x) * x + (local_area.y0 - p1.y) * y) / (x * x + y * y);
 	mi = fz_mini(mi, floorf(k)); ma = fz_maxi(ma, ceilf(k));
-	k = ((area.x0 - p1.x) * x + (area.y1 - p1.y) * y) / (x * x + y * y);
+	k = ((local_area.x0 - p1.x) * x + (local_area.y1 - p1.y) * y) / (x * x + y * y);
 	mi = fz_mini(mi, floorf(k)); ma = fz_maxi(ma, ceilf(k));
-	k = ((area.x1 - p1.x) * x + (area.y1 - p1.y) * y) / (x * x + y * y);
+	k = ((local_area.x1 - p1.x) * x + (local_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;
 
@@ -430,9 +437,9 @@ xps_draw_linear_gradient(xps_document *doc, fz_matrix ctm, fz_rect area,
  */
 
 static void
-xps_parse_gradient_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
+xps_parse_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
 	char *base_uri, xps_resource *dict, fz_xml *root,
-	void (*draw)(xps_document *, fz_matrix, fz_rect, struct stop *, int, fz_xml *, int))
+	void (*draw)(xps_document *, const fz_matrix*, const fz_rect *, struct stop *, int, fz_xml *, int))
 {
 	fz_xml *node;
 
@@ -486,7 +493,7 @@ xps_parse_gradient_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
 		xps_parse_render_transform(doc, transform_att, &transform);
 	if (transform_tag)
 		xps_parse_matrix_transform(doc, transform_tag, &transform);
-	ctm = fz_concat(transform, ctm);
+	fz_concat(&transform, &transform, ctm);
 
 	if (!stop_tag) {
 		fz_warn(doc->ctx, "missing gradient stops tag");
@@ -500,22 +507,22 @@ xps_parse_gradient_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
 		return;
 	}
 
-	xps_begin_opacity(doc, ctm, area, base_uri, dict, opacity_att, NULL);
+	xps_begin_opacity(doc, &transform, area, base_uri, dict, opacity_att, NULL);
 
-	draw(doc, ctm, area, stop_list, stop_count, root, spread_method);
+	draw(doc, &transform, area, stop_list, stop_count, root, spread_method);
 
 	xps_end_opacity(doc, base_uri, dict, opacity_att, NULL);
 }
 
 void
-xps_parse_linear_gradient_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
+xps_parse_linear_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
 	char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	xps_parse_gradient_brush(doc, ctm, area, base_uri, dict, root, xps_draw_linear_gradient);
 }
 
 void
-xps_parse_radial_gradient_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
+xps_parse_radial_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
 	char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	xps_parse_gradient_brush(doc, ctm, area, base_uri, dict, root, xps_draw_radial_gradient);
diff --git a/xps/xps_image.c b/xps/xps_image.c
index ee20543d..449b5dda 100644
--- a/xps/xps_image.c
+++ b/xps/xps_image.c
@@ -74,19 +74,21 @@ xps_load_image(fz_context *ctx, byte *buf, int len)
 	return &image->base;
 }
 
+/* FIXME: area unused! */
 static void
-xps_paint_image_brush(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict,
+xps_paint_image_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict,
 	fz_xml *root, void *vimage)
 {
 	xps_image *image = vimage;
 	float xs, ys;
+	fz_matrix local_ctm = *ctm;
 
 	if (image->xres == 0 || image->yres == 0)
 		return;
 	xs = image->base.w * 96 / image->xres;
 	ys = image->base.h * 96 / image->yres;
-	ctm = fz_concat(fz_scale(xs, ys), ctm);
-	fz_fill_image(doc->dev, &image->base, ctm, doc->opacity[doc->opacity_top]);
+	fz_pre_scale(&local_ctm, xs, ys);
+	fz_fill_image(doc->dev, &image->base, &local_ctm, doc->opacity[doc->opacity_top]);
 }
 
 static xps_part *
@@ -140,7 +142,7 @@ xps_find_image_brush_source_part(xps_document *doc, char *base_uri, fz_xml *root
 }
 
 void
-xps_parse_image_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
+xps_parse_image_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
 	char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	xps_part *part;
diff --git a/xps/xps_path.c b/xps/xps_path.c
index 838bb123..ff5fb6be 100644
--- a/xps/xps_path.c
+++ b/xps/xps_path.c
@@ -44,7 +44,7 @@ xps_parse_point(char *s_in, float *x, float *y)
  * calculated by th0, and on exit, a point is generated for us at th0.
  */
 static void
-xps_draw_arc_segment(fz_context *doc, fz_path *path, fz_matrix mtx, float th0, float th1, int iscw)
+xps_draw_arc_segment(fz_context *doc, fz_path *path, const fz_matrix *mtx, float th0, float th1, int iscw)
 {
 	float t, d;
 	fz_point p;
@@ -60,7 +60,7 @@ xps_draw_arc_segment(fz_context *doc, fz_path *path, fz_matrix mtx, float th0, f
 		{
 			p.x = cosf(t);
 			p.y = sinf(t);
-			p = fz_transform_point(mtx, p);
+			fz_transform_point(&p, mtx);
 			fz_lineto(doc, path, p.x, p.y);
 		}
 	}
@@ -71,7 +71,7 @@ xps_draw_arc_segment(fz_context *doc, fz_path *path, fz_matrix mtx, float th0, f
 		{
 			p.x = cosf(t);
 			p.y = sinf(t);
-			p = fz_transform_point(mtx, p);
+			fz_transform_point(&p, mtx);
 			fz_lineto(doc, path, p.x, p.y);
 		}
 	}
@@ -139,8 +139,8 @@ xps_draw_arc(fz_context *doc, fz_path *path,
 	else
 		sign = -1;
 
-	rotmat = fz_rotate(rotation_angle);
-	revmat = fz_rotate(-rotation_angle);
+	fz_rotate(&rotmat, rotation_angle);
+	fz_rotate(&revmat, -rotation_angle);
 
 	/* http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes */
 	/* Conversion from endpoint to center parameterization */
@@ -157,7 +157,7 @@ xps_draw_arc(fz_context *doc, fz_path *path,
 	/* F.6.5.1 */
 	pt.x = (x1 - x2) / 2;
 	pt.y = (y1 - y2) / 2;
-	pt = fz_transform_vector(revmat, pt);
+	fz_transform_vector(&pt, &revmat);
 	x1t = pt.x;
 	y1t = pt.y;
 
@@ -183,7 +183,7 @@ xps_draw_arc(fz_context *doc, fz_path *path,
 	/* F.6.5.3 */
 	pt.x = cxt;
 	pt.y = cyt;
-	pt = fz_transform_vector(rotmat, pt);
+	fz_transform_vector(&pt, &rotmat);
 	cx = pt.x + (x1 + x2) / 2;
 	cy = pt.y + (y1 + y2) / 2;
 
@@ -206,11 +206,8 @@ xps_draw_arc(fz_context *doc, fz_path *path,
 			dth -= (((float)M_PI / 180) * 360);
 	}
 
-	mtx = fz_identity;
-	mtx = fz_concat(fz_translate(cx, cy), mtx);
-	mtx = fz_concat(fz_rotate(rotation_angle), mtx);
-	mtx = fz_concat(fz_scale(rx, ry), mtx);
-	xps_draw_arc_segment(doc, path, mtx, th1, th1 + dth, is_clockwise);
+	fz_pre_scale(fz_pre_rotate(fz_translate(&mtx, cx, cy), rotation_angle), rx, ry);
+	xps_draw_arc_segment(doc, path, &mtx, th1, th1 + dth, is_clockwise);
 
 	fz_lineto(doc, path, point_x, point_y);
 }
@@ -751,7 +748,7 @@ xps_parse_path_geometry(xps_document *doc, xps_resource *dict, fz_xml *root, int
 	}
 
 	if (transform_att || transform_tag)
-		fz_transform_path(doc->ctx, path, transform);
+		fz_transform_path(doc->ctx, path, &transform);
 
 	return path;
 }
@@ -770,7 +767,7 @@ xps_parse_line_cap(char *attr)
 }
 
 void
-xps_clip(xps_document *doc, fz_matrix ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag)
+xps_clip(xps_document *doc, const fz_matrix *ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag)
 {
 	fz_path *path;
 	int fill_rule = 0;
@@ -781,7 +778,7 @@ xps_clip(xps_document *doc, fz_matrix ctm, xps_resource *dict, char *clip_att, f
 		path = xps_parse_path_geometry(doc, dict, clip_tag, 0, &fill_rule);
 	else
 		path = fz_new_path(doc->ctx);
-	fz_clip_path(doc->dev, path, fz_infinite_rect, fill_rule == 0, ctm);
+	fz_clip_path(doc->dev, path, NULL, fill_rule == 0, ctm);
 	fz_free_path(doc->ctx, path);
 }
 
@@ -791,7 +788,7 @@ xps_clip(xps_document *doc, fz_matrix ctm, xps_resource *dict, char *clip_att, f
  */
 
 void
-xps_parse_path(xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *dict, fz_xml *root)
+xps_parse_path(xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	fz_xml *node;
 
@@ -836,6 +833,7 @@ xps_parse_path(xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *d
 	fz_rect area;
 	int fill_rule;
 	int dash_len = 0;
+	fz_matrix local_ctm;
 
 	/*
 	 * Extract attributes and extended attributes.
@@ -972,10 +970,10 @@ xps_parse_path(xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *d
 		xps_parse_render_transform(doc, transform_att, &transform);
 	if (transform_tag)
 		xps_parse_matrix_transform(doc, transform_tag, &transform);
-	ctm = fz_concat(transform, ctm);
+	fz_concat(&local_ctm, &transform, ctm);
 
 	if (clip_att || clip_tag)
-		xps_clip(doc, ctm, dict, clip_att, clip_tag);
+		xps_clip(doc, &local_ctm, dict, clip_att, clip_tag);
 
 	fill_rule = 0;
 	if (data_att)
@@ -991,17 +989,20 @@ xps_parse_path(xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *d
 
 	if (stroke_att || stroke_tag)
 	{
-		area = fz_bound_path(doc->ctx, stroke_path, stroke, ctm);
-		if (stroke_path != path && (fill_att || fill_tag))
-			area = fz_union_rect(area, fz_bound_path(doc->ctx, path, NULL, ctm));
+		fz_bound_path(doc->ctx, stroke_path, stroke, &local_ctm, &area);
+		if (stroke_path != path && (fill_att || fill_tag)) {
+			fz_rect bounds;
+			fz_bound_path(doc->ctx, path, NULL, &local_ctm, &bounds);
+			fz_union_rect(&area, &bounds);
+		}
 	}
 	else
-		area = fz_bound_path(doc->ctx, path, NULL, ctm);
+		fz_bound_path(doc->ctx, path, NULL, &local_ctm, &area);
 
 	if (navigate_uri_att)
-		xps_add_link(doc, area, base_uri, navigate_uri_att);
+		xps_add_link(doc, &area, base_uri, navigate_uri_att);
 
-	xps_begin_opacity(doc, ctm, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
+	xps_begin_opacity(doc, &local_ctm, &area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
 
 	if (fill_att)
 	{
@@ -1010,14 +1011,14 @@ xps_parse_path(xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *d
 			samples[0] *= fz_atof(fill_opacity_att);
 		xps_set_color(doc, colorspace, samples);
 
-		fz_fill_path(doc->dev, path, fill_rule == 0, ctm,
+		fz_fill_path(doc->dev, path, fill_rule == 0, &local_ctm,
 			doc->colorspace, doc->color, doc->alpha);
 	}
 
 	if (fill_tag)
 	{
-		fz_clip_path(doc->dev, path, fz_infinite_rect, fill_rule == 0, ctm);
-		xps_parse_brush(doc, ctm, area, fill_uri, dict, fill_tag);
+		fz_clip_path(doc->dev, path, NULL, fill_rule == 0, &local_ctm);
+		xps_parse_brush(doc, &local_ctm, &area, fill_uri, dict, fill_tag);
 		fz_pop_clip(doc->dev);
 	}
 
@@ -1028,14 +1029,14 @@ xps_parse_path(xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *d
 			samples[0] *= fz_atof(stroke_opacity_att);
 		xps_set_color(doc, colorspace, samples);
 
-		fz_stroke_path(doc->dev, stroke_path, stroke, ctm,
+		fz_stroke_path(doc->dev, stroke_path, stroke, &local_ctm,
 			doc->colorspace, doc->color, doc->alpha);
 	}
 
 	if (stroke_tag)
 	{
-		fz_clip_stroke_path(doc->dev, stroke_path, fz_infinite_rect, stroke, ctm);
-		xps_parse_brush(doc, ctm, area, stroke_uri, dict, stroke_tag);
+		fz_clip_stroke_path(doc->dev, stroke_path, NULL, stroke, &local_ctm);
+		xps_parse_brush(doc, &local_ctm, &area, stroke_uri, dict, stroke_tag);
 		fz_pop_clip(doc->dev);
 	}
 
diff --git a/xps/xps_tile.c b/xps/xps_tile.c
index e8c0b263..15fad420 100644
--- a/xps/xps_tile.c
+++ b/xps/xps_tile.c
@@ -15,26 +15,26 @@ struct closure
 	xps_resource *dict;
 	fz_xml *root;
 	void *user;
-	void (*func)(xps_document*, fz_matrix, fz_rect, char*, xps_resource*, fz_xml*, void*);
+	void (*func)(xps_document*, const fz_matrix *, const fz_rect *, char*, xps_resource*, fz_xml*, void*);
 };
 
 static void
-xps_paint_tiling_brush_clipped(xps_document *doc, fz_matrix ctm, fz_rect viewbox, struct closure *c)
+xps_paint_tiling_brush_clipped(xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, struct closure *c)
 {
 	fz_path *path = fz_new_path(doc->ctx);
-	fz_moveto(doc->ctx, path, viewbox.x0, viewbox.y0);
-	fz_lineto(doc->ctx, path, viewbox.x0, viewbox.y1);
-	fz_lineto(doc->ctx, path, viewbox.x1, viewbox.y1);
-	fz_lineto(doc->ctx, path, viewbox.x1, viewbox.y0);
+	fz_moveto(doc->ctx, path, viewbox->x0, viewbox->y0);
+	fz_lineto(doc->ctx, path, viewbox->x0, viewbox->y1);
+	fz_lineto(doc->ctx, path, viewbox->x1, viewbox->y1);
+	fz_lineto(doc->ctx, path, viewbox->x1, viewbox->y0);
 	fz_closepath(doc->ctx, path);
-	fz_clip_path(doc->dev, path, fz_infinite_rect, 0, ctm);
+	fz_clip_path(doc->dev, path, NULL, 0, ctm);
 	fz_free_path(doc->ctx, path);
 	c->func(doc, ctm, viewbox, c->base_uri, c->dict, c->root, c->user);
 	fz_pop_clip(doc->dev);
 }
 
 static void
-xps_paint_tiling_brush(xps_document *doc, fz_matrix ctm, fz_rect viewbox, int tile_mode, struct closure *c)
+xps_paint_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, int tile_mode, struct closure *c)
 {
 	fz_matrix ttm;
 
@@ -42,30 +42,30 @@ xps_paint_tiling_brush(xps_document *doc, fz_matrix ctm, fz_rect viewbox, int ti
 
 	if (tile_mode == TILE_FLIP_X || tile_mode == TILE_FLIP_X_Y)
 	{
-		ttm = fz_concat(fz_translate(viewbox.x1 * 2, 0), ctm);
-		ttm = fz_concat(fz_scale(-1, 1), ttm);
-		xps_paint_tiling_brush_clipped(doc, ttm, viewbox, c);
+		ttm = *ctm;
+		fz_pre_scale(fz_pre_translate(&ttm, viewbox->x1 * 2, 0), -1, 1);
+		xps_paint_tiling_brush_clipped(doc, &ttm, viewbox, c);
 	}
 
 	if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y)
 	{
-		ttm = fz_concat(fz_translate(0, viewbox.y1 * 2), ctm);
-		ttm = fz_concat(fz_scale(1, -1), ttm);
-		xps_paint_tiling_brush_clipped(doc, ttm, viewbox, c);
+		ttm = *ctm;
+		fz_pre_scale(fz_pre_translate(&ttm, 0, viewbox->y1 * 2), 1, -1);
+		xps_paint_tiling_brush_clipped(doc, &ttm, viewbox, c);
 	}
 
 	if (tile_mode == TILE_FLIP_X_Y)
 	{
-		ttm = fz_concat(fz_translate(viewbox.x1 * 2, viewbox.y1 * 2), ctm);
-		ttm = fz_concat(fz_scale(-1, -1), ttm);
-		xps_paint_tiling_brush_clipped(doc, ttm, viewbox, c);
+		ttm = *ctm;
+		fz_pre_scale(fz_pre_translate(&ttm, viewbox->x1 * 2, viewbox->y1 * 2), -1, -1);
+		xps_paint_tiling_brush_clipped(doc, &ttm, viewbox, c);
 	}
 }
 
 void
-xps_parse_tiling_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
+xps_parse_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
 	char *base_uri, xps_resource *dict, fz_xml *root,
-	void (*func)(xps_document*, fz_matrix, fz_rect, char*, xps_resource*, fz_xml*, void*), void *user)
+	void (*func)(xps_document*, const fz_matrix*, const fz_rect*, char*, xps_resource*, fz_xml*, void*), void *user)
 {
 	fz_xml *node;
 	struct closure c;
@@ -116,7 +116,7 @@ xps_parse_tiling_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
 		xps_parse_render_transform(doc, transform_att, &transform);
 	if (transform_tag)
 		xps_parse_matrix_transform(doc, transform_tag, &transform);
-	ctm = fz_concat(transform, ctm);
+	fz_concat(&transform, &transform, ctm);
 
 	viewbox = fz_unit_rect;
 	if (viewbox_att)
@@ -163,21 +163,22 @@ xps_parse_tiling_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
 	if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y)
 		ystep *= 2;
 
-	xps_begin_opacity(doc, ctm, area, base_uri, dict, opacity_att, NULL);
+	xps_begin_opacity(doc, &transform, area, base_uri, dict, opacity_att, NULL);
 
-	ctm = fz_concat(fz_translate(viewport.x0, viewport.y0), ctm);
-	ctm = fz_concat(fz_scale(xscale, yscale), ctm);
-	ctm = fz_concat(fz_translate(-viewbox.x0, -viewbox.y0), ctm);
+	fz_pre_translate(&transform, viewport.x0, viewport.y0);
+	fz_pre_scale(&transform, xscale, yscale);
+	fz_pre_translate(&transform, -viewbox.x0, -viewbox.y0);
 
 	if (tile_mode != TILE_NONE)
 	{
 		int x0, y0, x1, y1;
-		fz_matrix invctm = fz_invert_matrix(ctm);
-		area = fz_transform_rect(invctm, area);
-		x0 = floorf(area.x0 / xstep);
-		y0 = floorf(area.y0 / ystep);
-		x1 = ceilf(area.x1 / xstep);
-		y1 = ceilf(area.y1 / ystep);
+		fz_matrix invctm;
+		fz_rect local_area = *area;
+		area = fz_transform_rect(&local_area, fz_invert_matrix(&invctm, &transform));
+		x0 = floorf(local_area.x0 / xstep);
+		y0 = floorf(local_area.y0 / ystep);
+		x1 = ceilf(local_area.x1 / xstep);
+		y1 = ceilf(local_area.y1 / ystep);
 
 #ifdef TILE
 		if ((x1 - x0) * (y1 - y0) > 1)
@@ -188,8 +189,8 @@ xps_parse_tiling_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
 			fz_rect bigview = viewbox;
 			bigview.x1 = bigview.x0 + xstep;
 			bigview.y1 = bigview.y0 + ystep;
-			fz_begin_tile(doc->dev, area, bigview, xstep, ystep, ctm);
-			xps_paint_tiling_brush(doc, ctm, viewbox, tile_mode, &c);
+			fz_begin_tile(doc->dev, &local_area, &bigview, xstep, ystep, &transform);
+			xps_paint_tiling_brush(doc, &transform, &viewbox, tile_mode, &c);
 			fz_end_tile(doc->dev);
 		}
 		else
@@ -199,29 +200,30 @@ xps_parse_tiling_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
 			{
 				for (x = x0; x < x1; x++)
 				{
-					fz_matrix ttm = fz_concat(fz_translate(xstep * x, ystep * y), ctm);
-					xps_paint_tiling_brush(doc, ttm, viewbox, tile_mode, &c);
+					fz_matrix ttm = transform;
+					fz_pre_translate(&ttm, xstep * x, ystep * y);
+					xps_paint_tiling_brush(doc, &ttm, &viewbox, tile_mode, &c);
 				}
 			}
 		}
 	}
 	else
 	{
-		xps_paint_tiling_brush(doc, ctm, viewbox, tile_mode, &c);
+		xps_paint_tiling_brush(doc, &transform, &viewbox, tile_mode, &c);
 	}
 
 	xps_end_opacity(doc, base_uri, dict, opacity_att, NULL);
 }
 
 static void
-xps_paint_visual_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
+xps_paint_visual_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
 	char *base_uri, xps_resource *dict, fz_xml *root, void *visual_tag)
 {
 	xps_parse_element(doc, ctm, area, base_uri, dict, (fz_xml *)visual_tag);
 }
 
 void
-xps_parse_visual_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
+xps_parse_visual_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
 	char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	fz_xml *node;
@@ -249,7 +251,7 @@ xps_parse_visual_brush(xps_document *doc, fz_matrix ctm, fz_rect area,
 }
 
 void
-xps_parse_canvas(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *root)
+xps_parse_canvas(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	xps_resource *new_dict = NULL;
 	fz_xml *node;
@@ -310,19 +312,19 @@ xps_parse_canvas(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri,
 		xps_parse_render_transform(doc, transform_att, &transform);
 	if (transform_tag)
 		xps_parse_matrix_transform(doc, transform_tag, &transform);
-	ctm = fz_concat(transform, ctm);
+	fz_concat(&transform, &transform, ctm);
 
 	if (navigate_uri_att)
 		xps_add_link(doc, area, base_uri, navigate_uri_att);
 
 	if (clip_att || clip_tag)
-		xps_clip(doc, ctm, dict, clip_att, clip_tag);
+		xps_clip(doc, &transform, dict, clip_att, clip_tag);
 
-	xps_begin_opacity(doc, ctm, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
+	xps_begin_opacity(doc, &transform, 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(doc, ctm, area, base_uri, dict, node);
+		xps_parse_element(doc, &transform, area, base_uri, dict, node);
 	}
 
 	xps_end_opacity(doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
@@ -335,13 +337,14 @@ xps_parse_canvas(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri,
 }
 
 void
-xps_parse_fixed_page(xps_document *doc, fz_matrix ctm, xps_page *page)
+xps_parse_fixed_page(xps_document *doc, const fz_matrix *ctm, xps_page *page)
 {
 	fz_xml *node;
 	xps_resource *dict;
 	char base_uri[1024];
 	fz_rect area;
 	char *s;
+	fz_matrix scm;
 
 	fz_strlcpy(base_uri, page->name, sizeof base_uri);
 	s = strrchr(base_uri, '/');
@@ -356,7 +359,8 @@ xps_parse_fixed_page(xps_document *doc, fz_matrix ctm, xps_page *page)
 	if (!page->root)
 		return;
 
-	area = fz_transform_rect(fz_scale(page->width, page->height), fz_unit_rect);
+	area = fz_unit_rect;
+	fz_transform_rect(&area, fz_scale(&scm, page->width, page->height));
 
 	for (node = fz_xml_down(page->root); node; node = fz_xml_next(node))
 	{
@@ -367,7 +371,7 @@ xps_parse_fixed_page(xps_document *doc, fz_matrix ctm, xps_page *page)
 			else
 				dict = xps_parse_resource_dictionary(doc, base_uri, fz_xml_down(node));
 		}
-		xps_parse_element(doc, ctm, area, base_uri, dict, node);
+		xps_parse_element(doc, ctm, &area, base_uri, dict, node);
 	}
 
 	if (dict)
@@ -375,16 +379,15 @@ xps_parse_fixed_page(xps_document *doc, fz_matrix ctm, xps_page *page)
 }
 
 void
-xps_run_page(xps_document *doc, xps_page *page, fz_device *dev, fz_matrix ctm, fz_cookie *cookie)
+xps_run_page(xps_document *doc, xps_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie)
 {
-	fz_matrix page_ctm;
+	fz_matrix page_ctm = *ctm;
 
-	page_ctm = fz_scale(72.0f / 96.0f, 72.0f / 96.0f);
-	ctm = fz_concat(page_ctm, ctm);
+	fz_pre_scale(&page_ctm, 72.0f / 96.0f, 72.0f / 96.0f);
 
 	doc->cookie = cookie;
 	doc->dev = dev;
-	xps_parse_fixed_page(doc, ctm, page);
+	xps_parse_fixed_page(doc, &page_ctm, page);
 	doc->cookie = NULL;
 	doc->dev = NULL;
 	page->links_resolved = 1;