Pass rects by value: device and document interface.

34 files changed, 273 insertions, 303 deletions

diff --git a/source/fitz/bbox-device.c b/source/fitz/bbox-device.c
index 9492a2da..6760ced5 100644
--- a/source/fitz/bbox-device.c
+++ b/source/fitz/bbox-device.c
@@ -82,31 +82,31 @@ fz_bbox_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_mat
 }
 
 static void
-fz_bbox_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, const fz_rect *scissor)
+fz_bbox_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, fz_rect scissor)
 {
 	fz_bbox_add_rect(ctx, dev, fz_bound_path(ctx, path, NULL, ctm), 1);
 }
 
 static void
-fz_bbox_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+fz_bbox_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	fz_bbox_add_rect(ctx, dev, fz_bound_path(ctx, path, stroke, ctm), 1);
 }
 
 static void
-fz_bbox_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, const fz_rect *scissor)
+fz_bbox_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, fz_rect scissor)
 {
 	fz_bbox_add_rect(ctx, dev, fz_bound_text(ctx, text, NULL, ctm), 1);
 }
 
 static void
-fz_bbox_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+fz_bbox_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	fz_bbox_add_rect(ctx, dev, fz_bound_text(ctx, text, stroke, ctm), 1);
 }
 
 static void
-fz_bbox_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, const fz_rect *scissor)
+fz_bbox_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, fz_rect scissor)
 {
 	fz_bbox_add_rect(ctx, dev, fz_transform_rect(fz_unit_rect, ctm), 1);
 }
@@ -122,10 +122,10 @@ fz_bbox_pop_clip(fz_context *ctx, fz_device *dev)
 }
 
 static void
-fz_bbox_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *rect, int luminosity, fz_colorspace *colorspace, const float *color, const fz_color_params *color_params)
+fz_bbox_begin_mask(fz_context *ctx, fz_device *dev, fz_rect rect, int luminosity, fz_colorspace *colorspace, const float *color, const fz_color_params *color_params)
 {
 	fz_bbox_device *bdev = (fz_bbox_device*)dev;
-	fz_bbox_add_rect(ctx, dev, *rect, 1);
+	fz_bbox_add_rect(ctx, dev, rect, 1);
 	bdev->ignore++;
 }
 
@@ -138,9 +138,9 @@ fz_bbox_end_mask(fz_context *ctx, fz_device *dev)
 }
 
 static void
-fz_bbox_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *rect, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
+fz_bbox_begin_group(fz_context *ctx, fz_device *dev, fz_rect rect, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
 {
-	fz_bbox_add_rect(ctx, dev, *rect, 1);
+	fz_bbox_add_rect(ctx, dev, rect, 1);
 }
 
 static void
@@ -150,10 +150,10 @@ fz_bbox_end_group(fz_context *ctx, fz_device *dev)
 }
 
 static int
-fz_bbox_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, fz_matrix ctm, int id)
+fz_bbox_begin_tile(fz_context *ctx, fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm, int id)
 {
 	fz_bbox_device *bdev = (fz_bbox_device*)dev;
-	fz_bbox_add_rect(ctx, dev, fz_transform_rect(*area, ctm), 0);
+	fz_bbox_add_rect(ctx, dev, fz_transform_rect(area, ctm), 0);
 	bdev->ignore++;
 	return 0;
 }
diff --git a/source/fitz/device.c b/source/fitz/device.c
index cad71a6a..d024b4f5 100644
--- a/source/fitz/device.c
+++ b/source/fitz/device.c
@@ -85,7 +85,7 @@ fz_disable_device_hints(fz_context *ctx, fz_device *dev, int hints)
 }
 
 static void
-push_clip_stack(fz_context *ctx, fz_device *dev, const fz_rect *rect, int flags)
+push_clip_stack(fz_context *ctx, fz_device *dev, fz_rect rect, int flags)
 {
 	if (dev->container_len == dev->container_cap)
 	{
@@ -96,10 +96,10 @@ push_clip_stack(fz_context *ctx, fz_device *dev, const fz_rect *rect, int flags)
 		dev->container_cap = newmax;
 	}
 	if (dev->container_len == 0)
-		dev->container[0].scissor = *rect;
+		dev->container[0].scissor = rect;
 	else
 	{
-		dev->container[dev->container_len].scissor = fz_intersect_rect(dev->container[dev->container_len-1].scissor, *rect);
+		dev->container[dev->container_len].scissor = fz_intersect_rect(dev->container[dev->container_len-1].scissor, rect);
 	}
 	dev->container[dev->container_len].flags = flags;
 	dev->container[dev->container_len].user = 0;
@@ -134,7 +134,7 @@ fz_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_st
 }
 
 void
-fz_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, const fz_rect *scissor)
+fz_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, fz_rect scissor)
 {
 	if (dev->error_depth)
 	{
@@ -146,13 +146,9 @@ fz_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd,
 	{
 		if (dev->hints & FZ_MAINTAIN_CONTAINER_STACK)
 		{
-			if (scissor == NULL)
-			{
-				fz_rect bbox = fz_bound_path(ctx, path, NULL, ctm);
-				push_clip_stack(ctx, dev, &bbox, fz_device_container_stack_is_clip_path);
-			}
-			else
-				push_clip_stack(ctx, dev, scissor, fz_device_container_stack_is_clip_path);
+			fz_rect bbox = fz_bound_path(ctx, path, NULL, ctm);
+			bbox = fz_intersect_rect(bbox, scissor);
+			push_clip_stack(ctx, dev, bbox, fz_device_container_stack_is_clip_path);
 		}
 		if (dev->clip_path)
 			dev->clip_path(ctx, dev, path, even_odd, ctm, scissor);
@@ -166,7 +162,7 @@ fz_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd,
 }
 
 void
-fz_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+fz_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	if (dev->error_depth)
 	{
@@ -178,13 +174,9 @@ fz_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const
 	{
 		if (dev->hints & FZ_MAINTAIN_CONTAINER_STACK)
 		{
-			if (scissor == NULL)
-			{
-				fz_rect bbox = fz_bound_path(ctx, path, stroke, ctm);
-				push_clip_stack(ctx, dev, &bbox, fz_device_container_stack_is_clip_stroke_path);
-			}
-			else
-				push_clip_stack(ctx, dev, scissor, fz_device_container_stack_is_clip_stroke_path);
+			fz_rect bbox = fz_bound_path(ctx, path, stroke, ctm);
+			bbox = fz_intersect_rect(bbox, scissor);
+			push_clip_stack(ctx, dev, bbox, fz_device_container_stack_is_clip_stroke_path);
 		}
 		if (dev->clip_stroke_path)
 			dev->clip_stroke_path(ctx, dev, path, stroke, ctm, scissor);
@@ -218,7 +210,7 @@ fz_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_st
 }
 
 void
-fz_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, const fz_rect *scissor)
+fz_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, fz_rect scissor)
 {
 	if (dev->error_depth)
 	{
@@ -230,13 +222,9 @@ fz_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm
 	{
 		if (dev->hints & FZ_MAINTAIN_CONTAINER_STACK)
 		{
-			if (scissor == NULL)
-			{
-				fz_rect bbox = fz_bound_text(ctx, text, NULL, ctm);
-				push_clip_stack(ctx, dev, &bbox, fz_device_container_stack_is_clip_text);
-			}
-			else
-				push_clip_stack(ctx, dev, scissor, fz_device_container_stack_is_clip_text);
+			fz_rect bbox = fz_bound_text(ctx, text, NULL, ctm);
+			bbox = fz_intersect_rect(bbox, scissor);
+			push_clip_stack(ctx, dev, bbox, fz_device_container_stack_is_clip_text);
 		}
 		if (dev->clip_text)
 			dev->clip_text(ctx, dev, text, ctm, scissor);
@@ -250,7 +238,7 @@ fz_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm
 }
 
 void
-fz_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+fz_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	if (dev->error_depth)
 	{
@@ -262,13 +250,9 @@ fz_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const
 	{
 		if (dev->hints & FZ_MAINTAIN_CONTAINER_STACK)
 		{
-			if (scissor == NULL)
-			{
-				fz_rect bbox = fz_bound_text(ctx, text, stroke, ctm);
-				push_clip_stack(ctx, dev, &bbox, fz_device_container_stack_is_clip_stroke_text);
-			}
-			else
-				push_clip_stack(ctx, dev, scissor, fz_device_container_stack_is_clip_stroke_text);
+			fz_rect bbox = fz_bound_text(ctx, text, stroke, ctm);
+			bbox = fz_intersect_rect(bbox, scissor);
+			push_clip_stack(ctx, dev, bbox, fz_device_container_stack_is_clip_stroke_text);
 		}
 		if (dev->clip_stroke_text)
 			dev->clip_stroke_text(ctx, dev, text, stroke, ctm, scissor);
@@ -335,7 +319,7 @@ fz_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix c
 }
 
 void
-fz_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, const fz_rect *scissor)
+fz_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, fz_rect scissor)
 {
 	if (dev->error_depth)
 	{
@@ -347,13 +331,9 @@ fz_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix c
 	{
 		if (dev->hints & FZ_MAINTAIN_CONTAINER_STACK)
 		{
-			if (scissor == NULL)
-			{
-				fz_rect bbox = fz_transform_rect(fz_unit_rect, ctm);
-				push_clip_stack(ctx, dev, &bbox, fz_device_container_stack_is_clip_image_mask);
-			}
-			else
-				push_clip_stack(ctx, dev, scissor, fz_device_container_stack_is_clip_image_mask);
+			fz_rect bbox = fz_transform_rect(fz_unit_rect, ctm);
+			bbox = fz_intersect_rect(bbox, scissor);
+			push_clip_stack(ctx, dev, bbox, fz_device_container_stack_is_clip_image_mask);
 		}
 		if (dev->clip_image_mask)
 			dev->clip_image_mask(ctx, dev, image, ctm, scissor);
@@ -367,7 +347,7 @@ fz_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix c
 }
 
 void
-fz_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *area, int luminosity, fz_colorspace *colorspace, const float *bc, const fz_color_params *color_params)
+fz_begin_mask(fz_context *ctx, fz_device *dev, fz_rect area, int luminosity, fz_colorspace *colorspace, const float *bc, const fz_color_params *color_params)
 {
 	if (dev->error_depth)
 	{
@@ -417,7 +397,7 @@ fz_end_mask(fz_context *ctx, fz_device *dev)
 }
 
 void
-fz_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *area, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
+fz_begin_group(fz_context *ctx, fz_device *dev, fz_rect area, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
 {
 	if (dev->error_depth)
 	{
@@ -457,13 +437,13 @@ fz_end_group(fz_context *ctx, fz_device *dev)
 }
 
 void
-fz_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, fz_matrix ctm)
+fz_begin_tile(fz_context *ctx, fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
 {
 	(void)fz_begin_tile_id(ctx, dev, area, view, xstep, ystep, ctm, 0);
 }
 
 int
-fz_begin_tile_id(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, fz_matrix ctm, int id)
+fz_begin_tile_id(fz_context *ctx, fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm, int id)
 {
 	int ret = 0;
 
@@ -534,10 +514,10 @@ void fz_end_layer(fz_context *ctx, fz_device *dev)
 		dev->end_layer(ctx, dev);
 }
 
-const fz_rect *
+fz_rect
 fz_device_current_scissor(fz_context *ctx, fz_device *dev)
 {
 	if (dev->container_len > 0)
-		return &dev->container[dev->container_len-1].scissor;
-	return &fz_infinite_rect;
+		return dev->container[dev->container_len-1].scissor;
+	return fz_infinite_rect;
 }
diff --git a/source/fitz/draw-device.c b/source/fitz/draw-device.c
index d31fa9d8..21e898c0 100644
--- a/source/fitz/draw-device.c
+++ b/source/fitz/draw-device.c
@@ -732,7 +732,7 @@ fz_draw_stroke_path(fz_context *ctx, fz_device *devp, const fz_path *path, const
 }
 
 static void
-fz_draw_clip_path(fz_context *ctx, fz_device *devp, const fz_path *path, int even_odd, fz_matrix in_ctm, const fz_rect *scissor)
+fz_draw_clip_path(fz_context *ctx, fz_device *devp, const fz_path *path, int even_odd, fz_matrix in_ctm, fz_rect scissor)
 {
 	fz_draw_device *dev = (fz_draw_device*)devp;
 	fz_matrix ctm = fz_concat(in_ctm, dev->transform);
@@ -754,9 +754,9 @@ fz_draw_clip_path(fz_context *ctx, fz_device *devp, const fz_path *path, int eve
 	STACK_PUSHED("clip path");
 	model = state->dest->colorspace;
 
-	if (scissor)
+	if (!fz_is_infinite_rect(scissor))
 	{
-		bbox = fz_irect_from_rect(fz_transform_rect(*scissor, dev->transform));
+		bbox = fz_irect_from_rect(fz_transform_rect(scissor, dev->transform));
 		bbox = fz_intersect_irect(bbox, fz_pixmap_bbox(ctx, state->dest));
 		bbox = fz_intersect_irect(bbox, state->scissor);
 	}
@@ -806,7 +806,7 @@ fz_draw_clip_path(fz_context *ctx, fz_device *devp, const fz_path *path, int eve
 }
 
 static void
-fz_draw_clip_stroke_path(fz_context *ctx, fz_device *devp, const fz_path *path, const fz_stroke_state *stroke, fz_matrix in_ctm, const fz_rect *scissor)
+fz_draw_clip_stroke_path(fz_context *ctx, fz_device *devp, const fz_path *path, const fz_stroke_state *stroke, fz_matrix in_ctm, fz_rect scissor)
 {
 	fz_draw_device *dev = (fz_draw_device*)devp;
 	fz_matrix ctm = fz_concat(in_ctm, dev->transform);
@@ -835,9 +835,9 @@ fz_draw_clip_stroke_path(fz_context *ctx, fz_device *devp, const fz_path *path,
 	STACK_PUSHED("clip stroke");
 	model = state->dest->colorspace;
 
-	if (scissor)
+	if (!fz_is_infinite_rect(scissor))
 	{
-		bbox = fz_irect_from_rect(fz_transform_rect(*scissor, dev->transform));
+		bbox = fz_irect_from_rect(fz_transform_rect(scissor, dev->transform));
 		bbox = fz_intersect_irect(bbox, fz_pixmap_bbox(ctx, state->dest));
 		bbox = fz_intersect_irect(bbox, state->scissor);
 	}
@@ -1140,7 +1140,7 @@ fz_draw_stroke_text(fz_context *ctx, fz_device *devp, const fz_text *text, const
 }
 
 static void
-fz_draw_clip_text(fz_context *ctx, fz_device *devp, const fz_text *text, fz_matrix in_ctm, const fz_rect *scissor)
+fz_draw_clip_text(fz_context *ctx, fz_device *devp, const fz_text *text, fz_matrix in_ctm, fz_rect scissor)
 {
 	fz_draw_device *dev = (fz_draw_device*)devp;
 	fz_matrix ctm = fz_concat(in_ctm, dev->transform);
@@ -1164,9 +1164,9 @@ fz_draw_clip_text(fz_context *ctx, fz_device *devp, const fz_text *text, fz_matr
 	/* make the mask the exact size needed */
 	bbox = fz_irect_from_rect(fz_bound_text(ctx, text, NULL, ctm));
 	bbox = fz_intersect_irect(bbox, state->scissor);
-	if (scissor)
+	if (!fz_is_infinite_rect(scissor))
 	{
-		fz_rect tscissor = fz_transform_rect(*scissor, dev->transform);
+		fz_rect tscissor = fz_transform_rect(scissor, dev->transform);
 		bbox = fz_intersect_irect(bbox, fz_irect_from_rect(tscissor));
 	}
 
@@ -1278,7 +1278,7 @@ fz_draw_clip_text(fz_context *ctx, fz_device *devp, const fz_text *text, fz_matr
 }
 
 static void
-fz_draw_clip_stroke_text(fz_context *ctx, fz_device *devp, const fz_text *text, const fz_stroke_state *stroke, fz_matrix in_ctm, const fz_rect *scissor)
+fz_draw_clip_stroke_text(fz_context *ctx, fz_device *devp, const fz_text *text, const fz_stroke_state *stroke, fz_matrix in_ctm, fz_rect scissor)
 {
 	fz_draw_device *dev = (fz_draw_device*)devp;
 	fz_matrix ctm = fz_concat(in_ctm, dev->transform);
@@ -1300,9 +1300,9 @@ fz_draw_clip_stroke_text(fz_context *ctx, fz_device *devp, const fz_text *text,
 	/* make the mask the exact size needed */
 	bbox = fz_irect_from_rect(fz_bound_text(ctx, text, stroke, ctm));
 	bbox = fz_intersect_irect(bbox, state->scissor);
-	if (scissor)
+	if (!fz_is_infinite_rect(scissor))
 	{
-		fz_rect tscissor = fz_transform_rect(*scissor, dev->transform);
+		fz_rect tscissor = fz_transform_rect(scissor, dev->transform);
 		bbox = fz_intersect_irect(bbox, fz_irect_from_rect(tscissor));
 	}
 
@@ -1542,7 +1542,7 @@ fz_draw_fill_shade(fz_context *ctx, fz_device *devp, fz_shade *shade, fz_matrix
 	else
 		eop = NULL;
 
-	fz_paint_shade(ctx, shade, colorspace, ctm, dest, color_params, &bbox, eop);
+	fz_paint_shade(ctx, shade, colorspace, ctm, dest, color_params, bbox, eop);
 	if (shape)
 		fz_clear_pixmap_rect_with_value(ctx, shape, 255, bbox);
 	if (group_alpha)
@@ -1938,7 +1938,7 @@ fz_draw_fill_image_mask(fz_context *ctx, fz_device *devp, fz_image *image, fz_ma
 }
 
 static void
-fz_draw_clip_image_mask(fz_context *ctx, fz_device *devp, fz_image *image, fz_matrix in_ctm, const fz_rect *scissor)
+fz_draw_clip_image_mask(fz_context *ctx, fz_device *devp, fz_image *image, fz_matrix in_ctm, fz_rect scissor)
 {
 	fz_draw_device *dev = (fz_draw_device*)devp;
 	fz_matrix local_ctm = fz_concat(in_ctm, dev->transform);
@@ -1973,9 +1973,9 @@ fz_draw_clip_image_mask(fz_context *ctx, fz_device *devp, fz_image *image, fz_ma
 
 	bbox = fz_irect_from_rect(fz_transform_rect(fz_unit_rect, local_ctm));
 	bbox = fz_intersect_irect(bbox, state->scissor);
-	if (scissor)
+	if (!fz_is_infinite_rect(scissor))
 	{
-		fz_rect tscissor = fz_transform_rect(*scissor, dev->transform);
+		fz_rect tscissor = fz_transform_rect(scissor, dev->transform);
 		bbox = fz_intersect_irect(bbox, fz_irect_from_rect(tscissor));
 	}
 
@@ -2114,7 +2114,7 @@ fz_draw_pop_clip(fz_context *ctx, fz_device *devp)
 }
 
 static void
-fz_draw_begin_mask(fz_context *ctx, fz_device *devp, const fz_rect *rect, int luminosity, fz_colorspace *colorspace_in, const float *colorfv, const fz_color_params *color_params)
+fz_draw_begin_mask(fz_context *ctx, fz_device *devp, fz_rect area, int luminosity, fz_colorspace *colorspace_in, const float *colorfv, const fz_color_params *color_params)
 {
 	fz_draw_device *dev = (fz_draw_device*)devp;
 	fz_pixmap *dest;
@@ -2135,7 +2135,7 @@ fz_draw_begin_mask(fz_context *ctx, fz_device *devp, const fz_rect *rect, int lu
 		color_params = fz_default_color_params(ctx);
 
 	STACK_PUSHED("mask");
-	trect = fz_transform_rect(*rect, dev->transform);
+	trect = fz_transform_rect(area, dev->transform);
 	bbox = fz_intersect_irect(fz_irect_from_rect(trect), state->scissor);
 
 	/* Reset the blendmode for the mask rendering. In particular,
@@ -2273,7 +2273,7 @@ fz_draw_end_mask(fz_context *ctx, fz_device *devp)
 }
 
 static void
-fz_draw_begin_group(fz_context *ctx, fz_device *devp, const fz_rect *rect, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
+fz_draw_begin_group(fz_context *ctx, fz_device *devp, fz_rect area, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
 {
 	fz_draw_device *dev = (fz_draw_device*)devp;
 	fz_irect bbox;
@@ -2293,7 +2293,7 @@ fz_draw_begin_group(fz_context *ctx, fz_device *devp, const fz_rect *rect, fz_co
 
 	state = push_stack(ctx, dev);
 	STACK_PUSHED("group");
-	trect = fz_transform_rect(*rect, dev->transform);
+	trect = fz_transform_rect(area, dev->transform);
 	bbox = fz_intersect_irect(fz_irect_from_rect(trect), state->scissor);
 
 	fz_try(ctx)
@@ -2581,7 +2581,7 @@ fz_tile_size(fz_context *ctx, tile_record *tile)
 }
 
 static int
-fz_draw_begin_tile(fz_context *ctx, fz_device *devp, const fz_rect *area, const fz_rect *view, float xstep, float ystep, fz_matrix in_ctm, int id)
+fz_draw_begin_tile(fz_context *ctx, fz_device *devp, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix in_ctm, int id)
 {
 	fz_draw_device *dev = (fz_draw_device*)devp;
 	fz_matrix ctm = fz_concat(in_ctm, dev->transform);
@@ -2603,7 +2603,7 @@ fz_draw_begin_tile(fz_context *ctx, fz_device *devp, const fz_rect *area, const
 
 	state = push_stack(ctx, dev);
 	STACK_PUSHED("tile");
-	local_view = fz_transform_rect(*view, ctm);
+	local_view = fz_transform_rect(view, ctm);
 	bbox = fz_irect_from_rect(local_view);
 	/* 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
@@ -2636,7 +2636,7 @@ fz_draw_begin_tile(fz_context *ctx, fz_device *devp, const fz_rect *area, const
 			state[1].ystep = ystep;
 			state[1].id = id;
 			state[1].encache = 0;
-			state[1].area = fz_irect_from_rect(*area);
+			state[1].area = fz_irect_from_rect(area);
 			state[1].ctm = ctm;
 #ifdef DUMP_GROUP_BLENDS
 			dump_spaces(dev->top-1, "Tile begin (cached)\n");
@@ -2670,7 +2670,7 @@ fz_draw_begin_tile(fz_context *ctx, fz_device *devp, const fz_rect *area, const
 		state[1].ystep = ystep;
 		state[1].id = id;
 		state[1].encache = 1;
-		state[1].area = fz_irect_from_rect(*area);
+		state[1].area = fz_irect_from_rect(area);
 		state[1].ctm = ctm;
 #ifdef DUMP_GROUP_BLENDS
 		dump_spaces(dev->top-1, "Tile begin\n");
@@ -3215,7 +3215,7 @@ fz_parse_draw_options(fz_context *ctx, fz_draw_options *opts, const char *args)
 }
 
 fz_device *
-fz_new_draw_device_with_options(fz_context *ctx, const fz_draw_options *opts, const fz_rect *mediabox, fz_pixmap **pixmap)
+fz_new_draw_device_with_options(fz_context *ctx, const fz_draw_options *opts, fz_rect mediabox, fz_pixmap **pixmap)
 {
 	float x_zoom = opts->x_resolution / 72.0f;
 	float y_zoom = opts->y_resolution / 72.0f;
@@ -3231,7 +3231,7 @@ fz_new_draw_device_with_options(fz_context *ctx, const fz_draw_options *opts, co
 	fz_set_rasterizer_text_aa_level(ctx, &aa, opts->text);
 
 	transform = fz_pre_rotate(fz_scale(x_zoom, y_zoom), opts->rotate);
-	bounds = *mediabox;
+	bounds = mediabox;
 	ibounds = fz_round_rect(fz_transform_rect(bounds, transform));
 
 	/* If width or height are set, we may need to adjust the transform */
@@ -3257,7 +3257,7 @@ fz_new_draw_device_with_options(fz_context *ctx, const fz_draw_options *opts, co
 		if (scalex != 1 || scaley != 1)
 		{
 			transform = fz_pre_scale(transform, scalex, scaley);
-			bounds = *mediabox;
+			bounds = mediabox;
 			ibounds = fz_round_rect(fz_transform_rect(bounds, transform));
 		}
 	}
diff --git a/source/fitz/draw-mesh.c b/source/fitz/draw-mesh.c
index 3b08c1e1..adc9aa1f 100644
--- a/source/fitz/draw-mesh.c
+++ b/source/fitz/draw-mesh.c
@@ -99,7 +99,7 @@ static inline void step_edge(edge_data *edge, int n)
 }
 
 static void
-fz_paint_triangle(fz_pixmap *pix, float *v[3], int n, const fz_irect *bbox)
+fz_paint_triangle(fz_pixmap *pix, float *v[3], int n, fz_irect bbox)
 {
 	edge_data e0, e1;
 	int top, mid, bot;
@@ -113,19 +113,19 @@ fz_paint_triangle(fz_pixmap *pix, float *v[3], int n, const fz_irect *bbox)
 	if (v[top][1] == v[bot][1]) return;
 
 	/* Test if the triangle is completely outside the scissor rect */
-	if (v[bot][1] < bbox->y0) return;
-	if (v[top][1] > bbox->y1) return;
+	if (v[bot][1] < bbox.y0) return;
+	if (v[top][1] > bbox.y1) return;
 
 	/* Magic! Ensure that mid/top/bot are all different */
 	mid = 3^top^bot;
 
 	assert(top != bot && top != mid && mid != bot);
 
-	minx = fz_maxi(bbox->x0, pix->x);
-	maxx = fz_mini(bbox->x1, pix->x + pix->w);
+	minx = fz_maxi(bbox.x0, pix->x);
+	maxx = fz_mini(bbox.x1, pix->x + pix->w);
 
-	y = ceilf(fz_max(bbox->y0, v[top][1]));
-	y1 = ceilf(fz_min(bbox->y1, v[mid][1]));
+	y = ceilf(fz_max(bbox.y0, v[top][1]));
+	y1 = ceilf(fz_min(bbox.y1, v[mid][1]));
 
 	n -= 2;
 	prepare_edge(v[top], v[bot], &e0, y, n);
@@ -143,7 +143,7 @@ fz_paint_triangle(fz_pixmap *pix, float *v[3], int n, const fz_irect *bbox)
 		while (y < y1);
 	}
 
-	y1 = ceilf(fz_min(bbox->y1, v[bot][1]));
+	y1 = ceilf(fz_min(bbox.y1, v[bot][1]));
 	if (y < y1)
 	{
 		prepare_edge(v[mid], v[bot], &e1, y, n);
@@ -165,7 +165,7 @@ struct paint_tri_data
 {
 	const fz_shade *shade;
 	fz_pixmap *dest;
-	const fz_irect *bbox;
+	fz_irect bbox;
 	fz_color_converter cc;
 };
 
@@ -211,7 +211,7 @@ do_paint_tri(fz_context *ctx, void *arg, fz_vertex *av, fz_vertex *bv, fz_vertex
 }
 
 void
-fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_colorspace *colorspace, fz_matrix ctm, fz_pixmap *dest, const fz_color_params *color_params, const fz_irect *bbox, const fz_overprint *op)
+fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_colorspace *colorspace, fz_matrix ctm, fz_pixmap *dest, const fz_color_params *color_params, fz_irect bbox, const fz_overprint *op)
 {
 	unsigned char clut[256][FZ_MAX_COLORS];
 	fz_pixmap *temp = NULL;
@@ -234,9 +234,8 @@ fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_colorspace *colorspace, fz_m
 
 		if (shade->use_function)
 		{
-			/* We need to use alpha = 1 here, because the shade might not fill
-			 * the bbox. */
-			temp = fz_new_pixmap_with_bbox(ctx, fz_device_gray(ctx), *bbox, NULL, 1);
+			/* We need to use alpha = 1 here, because the shade might not fill the bbox. */
+			temp = fz_new_pixmap_with_bbox(ctx, fz_device_gray(ctx), bbox, NULL, 1);
 			fz_clear_pixmap(ctx, temp);
 		}
 		else
@@ -275,7 +274,7 @@ fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_colorspace *colorspace, fz_m
 				int n = fz_colorspace_n(ctx, colorspace);
 
 				/* alpha = 1 here for the same reason as earlier */
-				conv = fz_new_pixmap_with_bbox(ctx, colorspace, *bbox, NULL, 1);
+				conv = fz_new_pixmap_with_bbox(ctx, colorspace, bbox, NULL, 1);
 				d = conv->samples;
 				while (hh--)
 				{
@@ -322,7 +321,7 @@ fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_colorspace *colorspace, fz_m
 				}
 				fz_drop_color_converter(ctx, &cc);
 
-				conv = fz_new_pixmap_with_bbox(ctx, dest->colorspace, *bbox, dest->seps, 1);
+				conv = fz_new_pixmap_with_bbox(ctx, dest->colorspace, bbox, dest->seps, 1);
 				d = conv->samples;
 				da = conv->alpha;
 				while (hh--)
diff --git a/source/fitz/font.c b/source/fitz/font.c
index f24d639b..97c5347e 100644
--- a/source/fitz/font.c
+++ b/source/fitz/font.c
@@ -1307,7 +1307,7 @@ fz_bound_t3_glyph(fz_context *ctx, fz_font *font, int gid)
 	dev = fz_new_bbox_device(ctx, &font->bbox_table[gid]);
 	fz_try(ctx)
 	{
-		fz_run_display_list(ctx, list, dev, font->t3matrix, &fz_infinite_rect, NULL);
+		fz_run_display_list(ctx, list, dev, font->t3matrix, fz_infinite_rect, NULL);
 		fz_close_device(ctx, dev);
 	}
 	fz_always(ctx)
@@ -1401,7 +1401,7 @@ fz_run_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_devic
 		return;
 
 	ctm = fz_concat(font->t3matrix, trm);
-	fz_run_display_list(ctx, list, dev, ctm, &fz_infinite_rect, NULL);
+	fz_run_display_list(ctx, list, dev, ctm, fz_infinite_rect, NULL);
 }
 
 fz_pixmap *
@@ -1791,9 +1791,9 @@ fz_buffer **fz_font_t3_procs(fz_context *ctx, fz_font *font)
 	return font ? font->t3procs : NULL;
 }
 
-fz_rect *fz_font_bbox(fz_context *ctx, fz_font *font)
+fz_rect fz_font_bbox(fz_context *ctx, fz_font *font)
 {
-	return font ? &font->bbox : NULL;
+	return font->bbox;
 }
 
 void *fz_font_ft_face(fz_context *ctx, fz_font *font)
diff --git a/source/fitz/image.c b/source/fitz/image.c
index 7936adf8..79f7bfee 100644
--- a/source/fitz/image.c
+++ b/source/fitz/image.c
@@ -1145,7 +1145,7 @@ display_list_image_get_pixmap(fz_context *ctx, fz_image *image_, fz_irect *subar
 	dev = fz_new_draw_device(ctx, ctm, pix);
 	fz_try(ctx)
 	{
-		fz_run_display_list(ctx, image->list, dev, fz_identity, NULL, NULL);
+		fz_run_display_list(ctx, image->list, dev, fz_identity, fz_infinite_rect, NULL);
 		fz_close_device(ctx, dev);
 	}
 	fz_always(ctx)
diff --git a/source/fitz/list-device.c b/source/fitz/list-device.c
index 88ad2110..072ce1d5 100644
--- a/source/fitz/list-device.c
+++ b/source/fitz/list-device.c
@@ -703,11 +703,10 @@ fz_list_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const
 }
 
 static void
-fz_list_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, const fz_rect *scissor)
+fz_list_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, fz_rect scissor)
 {
 	fz_rect rect = fz_bound_path(ctx, path, NULL, ctm);
-	if (scissor)
-		rect = fz_intersect_rect(rect, *scissor);
+	rect = fz_intersect_rect(rect, scissor);
 	fz_append_display_node(
 		ctx,
 		dev,
@@ -725,11 +724,10 @@ fz_list_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even
 }
 
 static void
-fz_list_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+fz_list_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	fz_rect rect = fz_bound_path(ctx, path, stroke, ctm);
-	if (scissor)
-		rect = fz_intersect_rect(rect, *scissor);
+	rect = fz_intersect_rect(rect, scissor);
 	fz_append_display_node(
 		ctx,
 		dev,
@@ -807,14 +805,13 @@ fz_list_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const
 }
 
 static void
-fz_list_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, const fz_rect *scissor)
+fz_list_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, fz_rect scissor)
 {
 	fz_text *cloned_text = fz_keep_text(ctx, text);
 	fz_try(ctx)
 	{
 		fz_rect rect = fz_bound_text(ctx, text, NULL, ctm);
-		if (scissor)
-			rect = fz_intersect_rect(rect, *scissor);
+		rect = fz_intersect_rect(rect, scissor);
 		fz_append_display_node(
 			ctx,
 			dev,
@@ -838,14 +835,13 @@ fz_list_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matri
 }
 
 static void
-fz_list_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+fz_list_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	fz_text *cloned_text = fz_keep_text(ctx, text);
 	fz_try(ctx)
 	{
 		fz_rect rect = fz_bound_text(ctx, text, stroke, ctm);
-		if (scissor)
-			rect = fz_intersect_rect(rect, *scissor);
+		rect = fz_intersect_rect(rect, scissor);
 		fz_append_display_node(
 			ctx,
 			dev,
@@ -1006,14 +1002,13 @@ fz_list_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_mat
 }
 
 static void
-fz_list_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, const fz_rect *scissor)
+fz_list_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, fz_rect scissor)
 {
 	fz_image *image2 = fz_keep_image(ctx, image);
 	fz_try(ctx)
 	{
 		fz_rect rect = fz_transform_rect(fz_unit_rect, ctm);
-		if (scissor)
-			rect = fz_intersect_rect(rect, *scissor);
+		rect = fz_intersect_rect(rect, scissor);
 		fz_append_display_node(
 			ctx,
 			dev,
@@ -1037,14 +1032,14 @@ fz_list_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_mat
 }
 
 static void
-fz_list_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *rect, int luminosity, fz_colorspace *colorspace, const float *color, const fz_color_params *color_params)
+fz_list_begin_mask(fz_context *ctx, fz_device *dev, fz_rect rect, int luminosity, fz_colorspace *colorspace, const float *color, const fz_color_params *color_params)
 {
 	fz_append_display_node(
 		ctx,
 		dev,
 		FZ_CMD_BEGIN_MASK,
 		(!!luminosity) | fz_pack_color_params(color_params), /* flags */
-		rect,
+		&rect,
 		NULL, /* path */
 		color,
 		colorspace,
@@ -1075,7 +1070,7 @@ fz_list_end_mask(fz_context *ctx, fz_device *dev)
 }
 
 static void
-fz_list_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *rect, fz_colorspace *colorspace, int isolated, int knockout, int blendmode, float alpha)
+fz_list_begin_group(fz_context *ctx, fz_device *dev, fz_rect rect, fz_colorspace *colorspace, int isolated, int knockout, int blendmode, float alpha)
 {
 	int flags;
 
@@ -1094,7 +1089,7 @@ fz_list_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *rect, fz_col
 			dev,
 			FZ_CMD_BEGIN_GROUP,
 			flags,
-			rect,
+			&rect,
 			NULL, /* path */
 			NULL, /* color */
 			NULL, /* colorspace */
@@ -1141,20 +1136,20 @@ struct fz_list_tile_data_s
 };
 
 static int
-fz_list_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, fz_matrix ctm, int id)
+fz_list_begin_tile(fz_context *ctx, fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm, int id)
 {
 	fz_list_tile_data tile;
 
 	tile.xstep = xstep;
 	tile.ystep = ystep;
-	tile.view = *view;
+	tile.view = view;
 	tile.id = id;
 	fz_append_display_node(
 		ctx,
 		dev,
 		FZ_CMD_BEGIN_TILE,
 		0, /* flags */
-		area,
+		&area,
 		NULL, /* path */
 		NULL, /* color */
 		NULL, /* colorspace */
@@ -1476,7 +1471,7 @@ int fz_display_list_is_empty(fz_context *ctx, const fz_display_list *list)
 }
 
 void
-fz_run_display_list(fz_context *ctx, fz_display_list *list, fz_device *dev, fz_matrix top_ctm, const fz_rect *scissor, fz_cookie *cookie)
+fz_run_display_list(fz_context *ctx, fz_display_list *list, fz_device *dev, fz_matrix top_ctm, fz_rect scissor, fz_cookie *cookie)
 {
 	fz_display_node *node;
 	fz_display_node *node_end;
@@ -1502,9 +1497,6 @@ fz_run_display_list(fz_context *ctx, fz_display_list *list, fz_device *dev, fz_m
 
 	fz_var(colorspace);
 
-	if (!scissor)
-		scissor = &fz_infinite_rect;
-
 	if (cookie)
 	{
 		cookie->progress_max = list->len;
@@ -1669,7 +1661,7 @@ fz_run_display_list(fz_context *ctx, fz_display_list *list, fz_device *dev, fz_m
 		}
 		else
 		{
-			empty = fz_is_empty_rect(fz_intersect_rect(trans_rect, *scissor));
+			empty = fz_is_empty_rect(fz_intersect_rect(trans_rect, scissor));
 		}
 
 		if (clipped || empty)
@@ -1716,10 +1708,10 @@ visible:
 				fz_stroke_path(ctx, dev, path, stroke, trans_ctm, colorspace, color, alpha, &color_params);
 				break;
 			case FZ_CMD_CLIP_PATH:
-				fz_clip_path(ctx, dev, path, n.flags, trans_ctm, &trans_rect);
+				fz_clip_path(ctx, dev, path, n.flags, trans_ctm, trans_rect);
 				break;
 			case FZ_CMD_CLIP_STROKE_PATH:
-				fz_clip_stroke_path(ctx, dev, path, stroke, trans_ctm, &trans_rect);
+				fz_clip_stroke_path(ctx, dev, path, stroke, trans_ctm, trans_rect);
 				break;
 			case FZ_CMD_FILL_TEXT:
 				fz_unpack_color_params(&color_params, n.flags);
@@ -1730,10 +1722,10 @@ visible:
 				fz_stroke_text(ctx, dev, *(fz_text **)node, stroke, trans_ctm, colorspace, color, alpha, &color_params);
 				break;
 			case FZ_CMD_CLIP_TEXT:
-				fz_clip_text(ctx, dev, *(fz_text **)node, trans_ctm, &trans_rect);
+				fz_clip_text(ctx, dev, *(fz_text **)node, trans_ctm, trans_rect);
 				break;
 			case FZ_CMD_CLIP_STROKE_TEXT:
-				fz_clip_stroke_text(ctx, dev, *(fz_text **)node, stroke, trans_ctm, &trans_rect);
+				fz_clip_stroke_text(ctx, dev, *(fz_text **)node, stroke, trans_ctm, trans_rect);
 				break;
 			case FZ_CMD_IGNORE_TEXT:
 				fz_ignore_text(ctx, dev, *(fz_text **)node, trans_ctm);
@@ -1751,20 +1743,20 @@ visible:
 				fz_fill_image_mask(ctx, dev, *(fz_image **)node, trans_ctm, colorspace, color, alpha, &color_params);
 				break;
 			case FZ_CMD_CLIP_IMAGE_MASK:
-				fz_clip_image_mask(ctx, dev, *(fz_image **)node, trans_ctm, &trans_rect);
+				fz_clip_image_mask(ctx, dev, *(fz_image **)node, trans_ctm, trans_rect);
 				break;
 			case FZ_CMD_POP_CLIP:
 				fz_pop_clip(ctx, dev);
 				break;
 			case FZ_CMD_BEGIN_MASK:
 				fz_unpack_color_params(&color_params, n.flags);
-				fz_begin_mask(ctx, dev, &trans_rect, n.flags, colorspace, color, &color_params);
+				fz_begin_mask(ctx, dev, trans_rect, n.flags, colorspace, color, &color_params);
 				break;
 			case FZ_CMD_END_MASK:
 				fz_end_mask(ctx, dev);
 				break;
 			case FZ_CMD_BEGIN_GROUP:
-				fz_begin_group(ctx, dev, &trans_rect, *(fz_colorspace **)node, (n.flags & ISOLATED) != 0, (n.flags & KNOCKOUT) != 0, (n.flags>>2), alpha);
+				fz_begin_group(ctx, dev, trans_rect, *(fz_colorspace **)node, (n.flags & ISOLATED) != 0, (n.flags & KNOCKOUT) != 0, (n.flags>>2), alpha);
 				break;
 			case FZ_CMD_END_GROUP:
 				fz_end_group(ctx, dev);
@@ -1776,7 +1768,7 @@ visible:
 				fz_rect tile_rect;
 				tiled++;
 				tile_rect = data->view;
-				cached = fz_begin_tile_id(ctx, dev, &rect, &tile_rect, data->xstep, data->ystep, trans_ctm, data->id);
+				cached = fz_begin_tile_id(ctx, dev, rect, tile_rect, data->xstep, data->ystep, trans_ctm, data->id);
 				if (cached)
 					tile_skip_depth = 1;
 				break;
diff --git a/source/fitz/output-cbz.c b/source/fitz/output-cbz.c
index 1eb0e473..7acf3157 100644
--- a/source/fitz/output-cbz.c
+++ b/source/fitz/output-cbz.c
@@ -20,7 +20,7 @@ struct fz_cbz_writer_s
 };
 
 static fz_device *
-cbz_begin_page(fz_context *ctx, fz_document_writer *wri_, const fz_rect *mediabox)
+cbz_begin_page(fz_context *ctx, fz_document_writer *wri_, fz_rect mediabox)
 {
 	fz_cbz_writer *wri = (fz_cbz_writer*)wri_;
 	return fz_new_draw_device_with_options(ctx, &wri->options, mediabox, &wri->pixmap);
@@ -105,7 +105,7 @@ struct fz_pixmap_writer_s
 };
 
 static fz_device *
-pixmap_begin_page(fz_context *ctx, fz_document_writer *wri_, const fz_rect *mediabox)
+pixmap_begin_page(fz_context *ctx, fz_document_writer *wri_, fz_rect mediabox)
 {
 	fz_pixmap_writer *wri = (fz_pixmap_writer*)wri_;
 	return fz_new_draw_device_with_options(ctx, &wri->options, mediabox, &wri->pixmap);
diff --git a/source/fitz/output-pcl.c b/source/fitz/output-pcl.c
index 4b885fe3..c25c59ff 100644
--- a/source/fitz/output-pcl.c
+++ b/source/fitz/output-pcl.c
@@ -1419,7 +1419,7 @@ struct fz_pcl_writer_s
 };
 
 static fz_device *
-pcl_begin_page(fz_context *ctx, fz_document_writer *wri_, const fz_rect *mediabox)
+pcl_begin_page(fz_context *ctx, fz_document_writer *wri_, fz_rect mediabox)
 {
 	fz_pcl_writer *wri = (fz_pcl_writer*)wri_;
 	return fz_new_draw_device_with_options(ctx, &wri->draw, mediabox, &wri->pixmap);
diff --git a/source/fitz/output-pclm.c b/source/fitz/output-pclm.c
index f3aa2ec2..8d1e11c6 100644
--- a/source/fitz/output-pclm.c
+++ b/source/fitz/output-pclm.c
@@ -324,7 +324,7 @@ struct fz_pclm_writer_s
 };
 
 static fz_device *
-pclm_begin_page(fz_context *ctx, fz_document_writer *wri_, const fz_rect *mediabox)
+pclm_begin_page(fz_context *ctx, fz_document_writer *wri_, fz_rect mediabox)
 {
 	fz_pclm_writer *wri = (fz_pclm_writer*)wri_;
 	return fz_new_draw_device_with_options(ctx, &wri->draw, mediabox, &wri->pixmap);
diff --git a/source/fitz/output-ps.c b/source/fitz/output-ps.c
index b270fcd4..a06c0006 100644
--- a/source/fitz/output-ps.c
+++ b/source/fitz/output-ps.c
@@ -290,7 +290,7 @@ struct fz_ps_writer_s
 };
 
 static fz_device *
-ps_begin_page(fz_context *ctx, fz_document_writer *wri_, const fz_rect *mediabox)
+ps_begin_page(fz_context *ctx, fz_document_writer *wri_, fz_rect mediabox)
 {
 	fz_ps_writer *wri = (fz_ps_writer*)wri_;
 	wri->count++;
diff --git a/source/fitz/output-pwg.c b/source/fitz/output-pwg.c
index 42ad4a1f..fbbf9e79 100644
--- a/source/fitz/output-pwg.c
+++ b/source/fitz/output-pwg.c
@@ -410,7 +410,7 @@ struct fz_pwg_writer_s
 };
 
 static fz_device *
-pwg_begin_page(fz_context *ctx, fz_document_writer *wri_, const fz_rect *mediabox)
+pwg_begin_page(fz_context *ctx, fz_document_writer *wri_, fz_rect mediabox)
 {
 	fz_pwg_writer *wri = (fz_pwg_writer*)wri_;
 	return fz_new_draw_device_with_options(ctx, &wri->draw, mediabox, &wri->pixmap);
diff --git a/source/fitz/output-svg.c b/source/fitz/output-svg.c
index 2bafda75..92d158e9 100644
--- a/source/fitz/output-svg.c
+++ b/source/fitz/output-svg.c
@@ -27,13 +27,13 @@ const char *fz_svg_write_options_usage =
 	;
 
 static fz_device *
-svg_begin_page(fz_context *ctx, fz_document_writer *wri_, const fz_rect *mediabox)
+svg_begin_page(fz_context *ctx, fz_document_writer *wri_, fz_rect mediabox)
 {
 	fz_svg_writer *wri = (fz_svg_writer*)wri_;
 	char path[PATH_MAX];
 
-	float w = mediabox->x1 - mediabox->x0;
-	float h = mediabox->y1 - mediabox->y0;
+	float w = mediabox.x1 - mediabox.x0;
+	float h = mediabox.y1 - mediabox.y0;
 
 	wri->count += 1;
 
diff --git a/source/fitz/stext-device.c b/source/fitz/stext-device.c
index 346d9bc2..0ba944d4 100644
--- a/source/fitz/stext-device.c
+++ b/source/fitz/stext-device.c
@@ -148,9 +148,9 @@ add_char_to_line(fz_context *ctx, fz_stext_page *page, fz_stext_line *line, fz_m
 	}
 	else
 	{
-		fz_rect *bbox = fz_font_bbox(ctx, font);
-		a.x = bbox->x1;
-		d.x = bbox->x0;
+		fz_rect bbox = fz_font_bbox(ctx, font);
+		a.x = bbox.x1;
+		d.x = bbox.x0;
 		a.y = 0;
 		d.y = 0;
 	}
@@ -516,7 +516,7 @@ fz_stext_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const
 }
 
 static void
-fz_stext_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, const fz_rect *scissor)
+fz_stext_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, fz_rect scissor)
 {
 	fz_stext_device *tdev = (fz_stext_device*)dev;
 	fz_text_span *span;
@@ -526,7 +526,7 @@ fz_stext_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matr
 }
 
 static void
-fz_stext_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+fz_stext_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	fz_stext_device *tdev = (fz_stext_device*)dev;
 	fz_text_span *span;
@@ -567,7 +567,7 @@ fz_stext_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *img, fz_matr
 }
 
 static fz_image *
-fz_new_image_from_shade(fz_context *ctx, fz_shade *shade, fz_matrix *in_out_ctm, const fz_color_params *color_params, const fz_rect *scissor)
+fz_new_image_from_shade(fz_context *ctx, fz_shade *shade, fz_matrix *in_out_ctm, const fz_color_params *color_params, fz_rect scissor)
 {
 	fz_matrix ctm = *in_out_ctm;
 	fz_pixmap *pix;
@@ -576,7 +576,7 @@ fz_new_image_from_shade(fz_context *ctx, fz_shade *shade, fz_matrix *in_out_ctm,
 	fz_irect bbox;
 
 	bounds = fz_bound_shade(ctx, shade, ctm);
-	bounds = fz_intersect_rect(bounds, *scissor);
+	bounds = fz_intersect_rect(bounds, scissor);
 	bbox = fz_irect_from_rect(bounds);
 
 	pix = fz_new_pixmap_with_bbox(ctx, fz_device_rgb(ctx), bbox, NULL, !shade->use_background);
@@ -586,7 +586,7 @@ fz_new_image_from_shade(fz_context *ctx, fz_shade *shade, fz_matrix *in_out_ctm,
 			fz_fill_pixmap_with_color(ctx, pix, shade->colorspace, shade->background, color_params);
 		else
 			fz_clear_pixmap(ctx, pix);
-		fz_paint_shade(ctx, shade, NULL, ctm, pix, color_params, &bbox, NULL);
+		fz_paint_shade(ctx, shade, NULL, ctm, pix, color_params, bbox, NULL);
 		img = fz_new_image_from_pixmap(ctx, pix, NULL);
 	}
 	fz_always(ctx)
@@ -607,7 +607,7 @@ static void
 fz_stext_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha, const fz_color_params *color_params)
 {
 	fz_matrix local_ctm = ctm;
-	const fz_rect *scissor = fz_device_current_scissor(ctx, dev);
+	fz_rect scissor = fz_device_current_scissor(ctx, dev);
 	fz_image *image = fz_new_image_from_shade(ctx, shade, &local_ctm, color_params, scissor);
 	fz_try(ctx)
 		fz_stext_fill_image(ctx, dev, image, local_ctm, alpha, color_params);
diff --git a/source/fitz/stext-output.c b/source/fitz/stext-output.c
index d949f2d8..154dfedb 100644
--- a/source/fitz/stext-output.c
+++ b/source/fitz/stext-output.c
@@ -455,7 +455,7 @@ struct fz_text_writer_s
 };
 
 static fz_device *
-text_begin_page(fz_context *ctx, fz_document_writer *wri_, const fz_rect *mediabox)
+text_begin_page(fz_context *ctx, fz_document_writer *wri_, fz_rect mediabox)
 {
 	fz_text_writer *wri = (fz_text_writer*)wri_;
 
@@ -465,7 +465,7 @@ text_begin_page(fz_context *ctx, fz_document_writer *wri_, const fz_rect *mediab
 		wri->page = NULL;
 	}
 
-	wri->page = fz_new_stext_page(ctx, *mediabox);
+	wri->page = fz_new_stext_page(ctx, mediabox);
 	return fz_new_stext_device(ctx, wri->page, &wri->opts);
 }
 
diff --git a/source/fitz/svg-device.c b/source/fitz/svg-device.c
index ec3441a3..17a35f7c 100644
--- a/source/fitz/svg-device.c
+++ b/source/fitz/svg-device.c
@@ -617,7 +617,7 @@ svg_dev_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const
 }
 
 static void
-svg_dev_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, const fz_rect *scissor)
+svg_dev_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, fz_rect scissor)
 {
 	svg_device *sdev = (svg_device*)dev;
 	fz_output *out;
@@ -637,7 +637,7 @@ svg_dev_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even
 }
 
 static void
-svg_dev_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+svg_dev_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	svg_device *sdev = (svg_device*)dev;
 
@@ -718,7 +718,7 @@ svg_dev_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const
 }
 
 static void
-svg_dev_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, const fz_rect *scissor)
+svg_dev_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, fz_rect scissor)
 {
 	svg_device *sdev = (svg_device*)dev;
 	fz_output *out = sdev->out;
@@ -758,7 +758,7 @@ svg_dev_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matri
 }
 
 static void
-svg_dev_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+svg_dev_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	svg_device *sdev = (svg_device*)dev;
 
@@ -919,7 +919,7 @@ svg_dev_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, fz_matrix c
 
 	fz_try(ctx)
 	{
-		fz_paint_shade(ctx, shade, NULL, ctm, pix, color_params, &bbox, NULL);
+		fz_paint_shade(ctx, shade, NULL, ctm, pix, color_params, bbox, NULL);
 		buf = fz_new_buffer_from_pixmap_as_png(ctx, pix, color_params);
 		if (alpha != 1.0f)
 			fz_write_printf(ctx, out, "<g opacity=\"%g\">\n", alpha);
@@ -966,7 +966,7 @@ svg_dev_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_mat
 }
 
 static void
-svg_dev_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, const fz_rect *scissor)
+svg_dev_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, fz_rect scissor)
 {
 	svg_device *sdev = (svg_device*)dev;
 	fz_output *out;
@@ -999,7 +999,7 @@ svg_dev_pop_clip(fz_context *ctx, fz_device *dev)
 }
 
 static void
-svg_dev_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, const float *color, const fz_color_params *color_params)
+svg_dev_begin_mask(fz_context *ctx, fz_device *dev, fz_rect bbox, int luminosity, fz_colorspace *colorspace, const float *color, const fz_color_params *color_params)
 {
 	svg_device *sdev = (svg_device*)dev;
 	fz_output *out;
@@ -1028,7 +1028,7 @@ svg_dev_end_mask(fz_context *ctx, fz_device *dev)
 }
 
 static void
-svg_dev_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *bbox, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
+svg_dev_begin_group(fz_context *ctx, fz_device *dev, fz_rect bbox, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
 {
 	svg_device *sdev = (svg_device*)dev;
 	fz_output *out = sdev->out;
@@ -1050,7 +1050,7 @@ svg_dev_end_group(fz_context *ctx, fz_device *dev)
 }
 
 static int
-svg_dev_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, fz_matrix ctm, int id)
+svg_dev_begin_tile(fz_context *ctx, fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm, int id)
 {
 	svg_device *sdev = (svg_device*)dev;
 	fz_output *out;
@@ -1066,8 +1066,8 @@ svg_dev_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const f
 	}
 	num = sdev->num_tiles++;
 	t = &sdev->tiles[num];
-	t->area = *area;
-	t->view = *view;
+	t->area = area;
+	t->view = view;
 	t->ctm = ctm;
 	t->pattern = sdev->id++;
 	t->step.x = xstep;
diff --git a/source/fitz/test-device.c b/source/fitz/test-device.c
index ce8923a4..8d069f69 100644
--- a/source/fitz/test-device.c
+++ b/source/fitz/test-device.c
@@ -381,7 +381,7 @@ fz_test_fill_image_mask(fz_context *ctx, fz_device *dev_, fz_image *image, fz_ma
 }
 
 static void
-fz_test_clip_path(fz_context *ctx, fz_device *dev_, const fz_path *path, int even_odd, fz_matrix ctm, const fz_rect *scissor)
+fz_test_clip_path(fz_context *ctx, fz_device *dev_, const fz_path *path, int even_odd, fz_matrix ctm, fz_rect scissor)
 {
 	fz_test_device *dev = (fz_test_device*)dev_;
 
@@ -389,7 +389,7 @@ fz_test_clip_path(fz_context *ctx, fz_device *dev_, const fz_path *path, int eve
 }
 
 static void
-fz_test_clip_stroke_path(fz_context *ctx, fz_device *dev_, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+fz_test_clip_stroke_path(fz_context *ctx, fz_device *dev_, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	fz_test_device *dev = (fz_test_device*)dev_;
 
@@ -397,7 +397,7 @@ fz_test_clip_stroke_path(fz_context *ctx, fz_device *dev_, const fz_path *path,
 }
 
 static void
-fz_test_clip_text(fz_context *ctx, fz_device *dev_, const fz_text *text, fz_matrix ctm, const fz_rect *scissor)
+fz_test_clip_text(fz_context *ctx, fz_device *dev_, const fz_text *text, fz_matrix ctm, fz_rect scissor)
 {
 	fz_test_device *dev = (fz_test_device*)dev_;
 
@@ -405,7 +405,7 @@ fz_test_clip_text(fz_context *ctx, fz_device *dev_, const fz_text *text, fz_matr
 }
 
 static void
-fz_test_clip_stroke_text(fz_context *ctx, fz_device *dev_, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+fz_test_clip_stroke_text(fz_context *ctx, fz_device *dev_, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	fz_test_device *dev = (fz_test_device*)dev_;
 
@@ -421,7 +421,7 @@ fz_test_ignore_text(fz_context *ctx, fz_device *dev_, const fz_text *text, fz_ma
 }
 
 static void
-fz_test_clip_image_mask(fz_context *ctx, fz_device *dev_, fz_image *img, fz_matrix ctm, const fz_rect *scissor)
+fz_test_clip_image_mask(fz_context *ctx, fz_device *dev_, fz_image *img, fz_matrix ctm, fz_rect scissor)
 {
 	fz_test_device *dev = (fz_test_device*)dev_;
 
@@ -437,7 +437,7 @@ fz_test_pop_clip(fz_context *ctx, fz_device *dev_)
 }
 
 static void
-fz_test_begin_mask(fz_context *ctx, fz_device *dev_, const fz_rect *rect, int luminosity, fz_colorspace *cs, const float *bc, const fz_color_params *color_params)
+fz_test_begin_mask(fz_context *ctx, fz_device *dev_, fz_rect rect, int luminosity, fz_colorspace *cs, const float *bc, const fz_color_params *color_params)
 {
 	fz_test_device *dev = (fz_test_device*)dev_;
 
@@ -453,7 +453,7 @@ fz_test_end_mask(fz_context *ctx, fz_device *dev_)
 }
 
 static void
-fz_test_begin_group(fz_context *ctx, fz_device *dev_, const fz_rect *rect, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
+fz_test_begin_group(fz_context *ctx, fz_device *dev_, fz_rect rect, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
 {
 	fz_test_device *dev = (fz_test_device*)dev_;
 
@@ -469,7 +469,7 @@ fz_test_end_group(fz_context *ctx, fz_device *dev_)
 }
 
 static int
-fz_test_begin_tile(fz_context *ctx, fz_device *dev_, const fz_rect *area, const fz_rect *view, float xstep, float ystep, fz_matrix ctm, int id)
+fz_test_begin_tile(fz_context *ctx, fz_device *dev_, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm, int id)
 {
 	fz_test_device *dev = (fz_test_device*)dev_;
 
diff --git a/source/fitz/trace-device.c b/source/fitz/trace-device.c
index b89661ad..1d94412b 100644
--- a/source/fitz/trace-device.c
+++ b/source/fitz/trace-device.c
@@ -162,7 +162,7 @@ fz_trace_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const
 }
 
 static void
-fz_trace_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, const fz_rect *scissor)
+fz_trace_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, fz_rect scissor)
 {
 	fz_output *out = ((fz_trace_device*)dev)->out;
 	fz_write_printf(ctx, out, "<clip_path");
@@ -177,7 +177,7 @@ fz_trace_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int eve
 }
 
 static void
-fz_trace_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+fz_trace_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	fz_output *out = ((fz_trace_device*)dev)->out;
 	fz_write_printf(ctx, out, "<clip_stroke_path");
@@ -214,7 +214,7 @@ fz_trace_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const
 }
 
 static void
-fz_trace_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, const fz_rect *scissor)
+fz_trace_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, fz_rect scissor)
 {
 	fz_output *out = ((fz_trace_device*)dev)->out;
 	fz_write_printf(ctx, out, "<clip_text");
@@ -225,7 +225,7 @@ fz_trace_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matr
 }
 
 static void
-fz_trace_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+fz_trace_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	fz_output *out = ((fz_trace_device*)dev)->out;
 	fz_write_printf(ctx, out, "<clip_stroke_text");
@@ -278,7 +278,7 @@ fz_trace_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_ma
 }
 
 static void
-fz_trace_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, const fz_rect *scissor)
+fz_trace_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, fz_rect scissor)
 {
 	fz_output *out = ((fz_trace_device*)dev)->out;
 	fz_write_printf(ctx, out, "<clip_image_mask");
@@ -295,11 +295,11 @@ fz_trace_pop_clip(fz_context *ctx, fz_device *dev)
 }
 
 static void
-fz_trace_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, const float *color, const fz_color_params *color_params)
+fz_trace_begin_mask(fz_context *ctx, fz_device *dev, fz_rect bbox, int luminosity, fz_colorspace *colorspace, const float *color, const fz_color_params *color_params)
 {
 	fz_output *out = ((fz_trace_device*)dev)->out;
 	fz_write_printf(ctx, out, "<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");
 	fz_write_printf(ctx, out, ">\n");
 }
@@ -312,11 +312,11 @@ fz_trace_end_mask(fz_context *ctx, fz_device *dev)
 }
 
 static void
-fz_trace_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *bbox, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
+fz_trace_begin_group(fz_context *ctx, fz_device *dev, fz_rect bbox, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
 {
 	fz_output *out = ((fz_trace_device*)dev)->out;
 	fz_write_printf(ctx, out, "<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);
 }
 
@@ -328,12 +328,12 @@ fz_trace_end_group(fz_context *ctx, fz_device *dev)
 }
 
 static int
-fz_trace_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, fz_matrix ctm, int id)
+fz_trace_begin_tile(fz_context *ctx, fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm, int id)
 {
 	fz_output *out = ((fz_trace_device*)dev)->out;
 	fz_write_printf(ctx, out, "<tile id=\"%d\"", id);
-	fz_write_printf(ctx, out, " area=\"%g %g %g %g\"", area->x0, area->y0, area->x1, area->y1);
-	fz_write_printf(ctx, out, " view=\"%g %g %g %g\"", view->x0, view->y0, view->x1, view->y1);
+	fz_write_printf(ctx, out, " area=\"%g %g %g %g\"", area.x0, area.y0, area.x1, area.y1);
+	fz_write_printf(ctx, out, " view=\"%g %g %g %g\"", view.x0, view.y0, view.x1, view.y1);
 	fz_write_printf(ctx, out, " xstep=\"%g\" ystep=\"%g\"", xstep, ystep);
 	fz_trace_matrix(ctx, out, ctm);
 	fz_write_printf(ctx, out, ">\n");
diff --git a/source/fitz/util.c b/source/fitz/util.c
index 4e1f4e1e..aea89144 100644
--- a/source/fitz/util.c
+++ b/source/fitz/util.c
@@ -119,7 +119,7 @@ fz_new_pixmap_from_display_list(fz_context *ctx, fz_display_list *list, fz_matri
 	fz_try(ctx)
 	{
 		dev = fz_new_draw_device(ctx, ctm, pix);
-		fz_run_display_list(ctx, list, dev, fz_identity, NULL, NULL);
+		fz_run_display_list(ctx, list, dev, fz_identity, fz_infinite_rect, NULL);
 		fz_close_device(ctx, dev);
 	}
 	fz_always(ctx)
@@ -275,7 +275,7 @@ fz_new_stext_page_from_display_list(fz_context *ctx, fz_display_list *list, cons
 	fz_try(ctx)
 	{
 		dev = fz_new_stext_device(ctx, text, options);
-		fz_run_display_list(ctx, list, dev, fz_identity, NULL, NULL);
+		fz_run_display_list(ctx, list, dev, fz_identity, fz_infinite_rect, NULL);
 		fz_close_device(ctx, dev);
 	}
 	fz_always(ctx)
diff --git a/source/fitz/writer.c b/source/fitz/writer.c
index 1e9652da..ada07089 100644
--- a/source/fitz/writer.c
+++ b/source/fitz/writer.c
@@ -185,7 +185,7 @@ fz_drop_document_writer(fz_context *ctx, fz_document_writer *wri)
 }
 
 fz_device *
-fz_begin_page(fz_context *ctx, fz_document_writer *wri, const fz_rect *mediabox)
+fz_begin_page(fz_context *ctx, fz_document_writer *wri, fz_rect mediabox)
 {
 	if (!wri)
 		return NULL;
diff --git a/source/pdf/pdf-device.c b/source/pdf/pdf-device.c
index 97621b49..8d079689 100644
--- a/source/pdf/pdf-device.c
+++ b/source/pdf/pdf-device.c
@@ -526,7 +526,7 @@ pdf_dev_end_text(fz_context *ctx, pdf_device *pdev)
 }
 
 static int
-pdf_dev_new_form(fz_context *ctx, pdf_obj **form_ref, pdf_device *pdev, const fz_rect *bbox, int isolated, int knockout, float alpha, fz_colorspace *colorspace)
+pdf_dev_new_form(fz_context *ctx, pdf_obj **form_ref, pdf_device *pdev, fz_rect bbox, int isolated, int knockout, float alpha, fz_colorspace *colorspace)
 {
 	pdf_document *doc = pdev->doc;
 	int num;
@@ -605,7 +605,7 @@ pdf_dev_new_form(fz_context *ctx, pdf_obj **form_ref, pdf_device *pdev, const fz
 		pdf_dict_put(ctx, form, PDF_NAME(Subtype), PDF_NAME(Form));
 		pdf_dict_put(ctx, form, PDF_NAME(Group), group_ref);
 		pdf_dict_put_int(ctx, form, PDF_NAME(FormType), 1);
-		pdf_dict_put_rect(ctx, form, PDF_NAME(BBox), *bbox);
+		pdf_dict_put_rect(ctx, form, PDF_NAME(BBox), bbox);
 		*form_ref = pdf_add_object(ctx, doc, form);
 	}
 	fz_always(ctx)
@@ -662,7 +662,7 @@ pdf_dev_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const
 }
 
 static void
-pdf_dev_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, const fz_rect *scissor)
+pdf_dev_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, fz_rect scissor)
 {
 	pdf_device *pdev = (pdf_device*)dev;
 	gstate *gs;
@@ -676,7 +676,7 @@ pdf_dev_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even
 }
 
 static void
-pdf_dev_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+pdf_dev_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	pdf_device *pdev = (pdf_device*)dev;
 	gstate *gs;
@@ -731,7 +731,7 @@ pdf_dev_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const
 }
 
 static void
-pdf_dev_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, const fz_rect *scissor)
+pdf_dev_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, fz_rect scissor)
 {
 	pdf_device *pdev = (pdf_device*)dev;
 	fz_text_span *span;
@@ -745,7 +745,7 @@ pdf_dev_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matri
 }
 
 static void
-pdf_dev_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, const fz_rect *scissor)
+pdf_dev_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor)
 {
 	pdf_device *pdev = (pdf_device*)dev;
 	fz_text_span *span;
@@ -871,7 +871,7 @@ pdf_dev_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_mat
 }
 
 static void
-pdf_dev_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, const fz_rect *scissor)
+pdf_dev_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, fz_rect scissor)
 {
 	pdf_device *pdev = (pdf_device*)dev;
 
@@ -891,7 +891,7 @@ pdf_dev_pop_clip(fz_context *ctx, fz_device *dev)
 }
 
 static void
-pdf_dev_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, const float *color, const fz_color_params *color_params)
+pdf_dev_begin_mask(fz_context *ctx, fz_device *dev, fz_rect bbox, int luminosity, fz_colorspace *colorspace, const float *color, const fz_color_params *color_params)
 {
 	pdf_device *pdev = (pdf_device*)dev;
 	pdf_document *doc = pdev->doc;
@@ -975,7 +975,7 @@ pdf_dev_end_mask(fz_context *ctx, fz_device *dev)
 }
 
 static void
-pdf_dev_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *bbox, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
+pdf_dev_begin_group(fz_context *ctx, fz_device *dev, fz_rect bbox, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
 {
 	pdf_device *pdev = (pdf_device*)dev;
 	pdf_document *doc = pdev->doc;
@@ -1029,7 +1029,7 @@ pdf_dev_end_group(fz_context *ctx, fz_device *dev)
 }
 
 static int
-pdf_dev_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, fz_matrix ctm, int id)
+pdf_dev_begin_tile(fz_context *ctx, fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm, int id)
 {
 	pdf_device *pdev = (pdf_device*)dev;
 
@@ -1078,7 +1078,7 @@ pdf_dev_drop_device(fz_context *ctx, fz_device *dev)
 	fz_free(ctx, pdev->gstates);
 }
 
-fz_device *pdf_new_pdf_device(fz_context *ctx, pdf_document *doc, fz_matrix topctm, const fz_rect *mediabox, pdf_obj *resources, fz_buffer *buf)
+fz_device *pdf_new_pdf_device(fz_context *ctx, pdf_document *doc, fz_matrix topctm, fz_rect mediabox, pdf_obj *resources, fz_buffer *buf)
 {
 	pdf_device *dev = fz_new_derived_device(ctx, pdf_device);
 
@@ -1145,10 +1145,9 @@ fz_device *pdf_new_pdf_device(fz_context *ctx, pdf_document *doc, fz_matrix topc
 	return (fz_device*)dev;
 }
 
-fz_device *pdf_page_write(fz_context *ctx, pdf_document *doc,
-	const fz_rect *mediabox, pdf_obj **presources, fz_buffer **pcontents)
+fz_device *pdf_page_write(fz_context *ctx, pdf_document *doc, fz_rect mediabox, pdf_obj **presources, fz_buffer **pcontents)
 {
-	fz_matrix pagectm = { 1, 0, 0, -1, -mediabox->x0, mediabox->y1 };
+	fz_matrix pagectm = { 1, 0, 0, -1, -mediabox.x0, mediabox.y1 };
 	*presources = pdf_new_dict(ctx, doc, 0);
 	*pcontents = fz_new_buffer(ctx, 0);
 	return pdf_new_pdf_device(ctx, doc, pagectm, mediabox, *presources, *pcontents);
diff --git a/source/pdf/pdf-op-run.c b/source/pdf/pdf-op-run.c
index b08657a6..0bd4ec21 100644
--- a/source/pdf/pdf-op-run.c
+++ b/source/pdf/pdf-op-run.c
@@ -139,7 +139,7 @@ begin_softmask(fz_context *ctx, pdf_run_processor *pr, softmask_save *save)
 
 	fz_try(ctx)
 	{
-		fz_begin_mask(ctx, pr->dev, &mask_bbox, gstate->luminosity, mask_colorspace, gstate->softmask_bc, &gstate->fill.color_params);
+		fz_begin_mask(ctx, pr->dev, mask_bbox, gstate->luminosity, mask_colorspace, gstate->softmask_bc, &gstate->fill.color_params);
 		pdf_run_xobject(ctx, pr, softmask, save->page_resources, fz_identity, 1);
 	}
 	fz_always(ctx)
@@ -177,7 +177,7 @@ end_softmask(fz_context *ctx, pdf_run_processor *pr, softmask_save *save)
 }
 
 static pdf_gstate *
-pdf_begin_group(fz_context *ctx, pdf_run_processor *pr, const fz_rect *bbox, softmask_save *softmask)
+pdf_begin_group(fz_context *ctx, pdf_run_processor *pr, fz_rect bbox, softmask_save *softmask)
 {
 	pdf_gstate *gstate = begin_softmask(ctx, pr, softmask);
 
@@ -210,7 +210,7 @@ pdf_show_shade(fz_context *ctx, pdf_run_processor *pr, fz_shade *shd)
 
 	bbox = fz_bound_shade(ctx, shd, gstate->ctm);
 
-	gstate = pdf_begin_group(ctx, pr, &bbox, &softmask);
+	gstate = pdf_begin_group(ctx, pr, bbox, &softmask);
 
 	/* FIXME: The gstate->ctm in the next line may be wrong; maybe
 	 * it should be the parent gstates ctm? */
@@ -341,7 +341,7 @@ pdf_grestore(fz_context *ctx, pdf_run_processor *pr)
 }
 
 static void
-pdf_show_pattern(fz_context *ctx, pdf_run_processor *pr, pdf_pattern *pat, pdf_gstate *pat_gstate, const fz_rect *area, int what)
+pdf_show_pattern(fz_context *ctx, pdf_run_processor *pr, pdf_pattern *pat, pdf_gstate *pat_gstate, fz_rect area, int what)
 {
 	pdf_gstate *gstate;
 	int gparent_save;
@@ -403,7 +403,7 @@ pdf_show_pattern(fz_context *ctx, pdf_run_processor *pr, pdf_pattern *pat, pdf_g
 		/* patterns are painted using the parent_ctm. area = bbox of
 		 * shape to be filled in device space. Map it back to pattern
 		 * space. */
-		local_area = fz_transform_rect(*area, invptm);
+		local_area = fz_transform_rect(area, invptm);
 
 		fx0 = (local_area.x0 - pat->bbox.x0) / pat->xstep;
 		fy0 = (local_area.y0 - pat->bbox.y0) / pat->ystep;
@@ -428,7 +428,7 @@ pdf_show_pattern(fz_context *ctx, pdf_run_processor *pr, pdf_pattern *pat, pdf_g
 		if (0)
 #endif
 		{
-			int cached = fz_begin_tile_id(ctx, pr->dev, &local_area, &pat->bbox, pat->xstep, pat->ystep, ptm, id);
+			int cached = fz_begin_tile_id(ctx, pr->dev, local_area, pat->bbox, pat->xstep, pat->ystep, ptm, id);
 			if (cached)
 			{
 				fz_end_tile(ctx, pr->dev);
@@ -499,7 +499,7 @@ pdf_show_pattern(fz_context *ctx, pdf_run_processor *pr, pdf_pattern *pat, pdf_g
 }
 
 static void
-pdf_show_image_imp(fz_context *ctx, pdf_run_processor *pr, fz_image *image, fz_matrix image_ctm, fz_rect *bbox)
+pdf_show_image_imp(fz_context *ctx, pdf_run_processor *pr, fz_image *image, fz_matrix image_ctm, fz_rect bbox)
 {
 	pdf_gstate *gstate = pr->gstate + pr->gtop;
 
@@ -552,10 +552,10 @@ pdf_show_image(fz_context *ctx, pdf_run_processor *pr, fz_image *image)
 	if (image->mask && gstate->blendmode)
 	{
 		/* apply blend group even though we skip the soft mask */
-		fz_begin_group(ctx, pr->dev, &bbox, NULL, 0, 0, gstate->blendmode, 1);
+		fz_begin_group(ctx, pr->dev, bbox, NULL, 0, 0, gstate->blendmode, 1);
 
 		fz_try(ctx)
-			fz_clip_image_mask(ctx, pr->dev, image->mask, image_ctm, &bbox);
+			fz_clip_image_mask(ctx, pr->dev, image->mask, image_ctm, bbox);
 		fz_catch(ctx)
 		{
 			fz_end_group(ctx, pr->dev);
@@ -563,7 +563,7 @@ pdf_show_image(fz_context *ctx, pdf_run_processor *pr, fz_image *image)
 		}
 
 		fz_try(ctx)
-			pdf_show_image_imp(ctx, pr, image, image_ctm, &bbox);
+			pdf_show_image_imp(ctx, pr, image, image_ctm, bbox);
 		fz_always(ctx)
 		{
 			fz_pop_clip(ctx, pr->dev);
@@ -574,9 +574,9 @@ pdf_show_image(fz_context *ctx, pdf_run_processor *pr, fz_image *image)
 	}
 	else if (image->mask)
 	{
-		fz_clip_image_mask(ctx, pr->dev, image->mask, image_ctm, &bbox);
+		fz_clip_image_mask(ctx, pr->dev, image->mask, image_ctm, bbox);
 		fz_try(ctx)
-			pdf_show_image_imp(ctx, pr, image, image_ctm, &bbox);
+			pdf_show_image_imp(ctx, pr, image, image_ctm, bbox);
 		fz_always(ctx)
 			fz_pop_clip(ctx, pr->dev);
 		fz_catch(ctx)
@@ -586,10 +586,10 @@ pdf_show_image(fz_context *ctx, pdf_run_processor *pr, fz_image *image)
 	{
 		softmask_save softmask = { NULL };
 
-		gstate = pdf_begin_group(ctx, pr, &bbox, &softmask);
+		gstate = pdf_begin_group(ctx, pr, bbox, &softmask);
 
 		fz_try(ctx)
-			pdf_show_image_imp(ctx, pr, image, image_ctm, &bbox);
+			pdf_show_image_imp(ctx, pr, image, image_ctm, bbox);
 		fz_always(ctx)
 			pdf_end_group(ctx, pr, &softmask);
 		fz_catch(ctx)
@@ -633,7 +633,7 @@ pdf_show_path(fz_context *ctx, pdf_run_processor *pr, int doclose, int dofill, i
 			dostroke = dofill = 0;
 
 		if (dofill || dostroke)
-			gstate = pdf_begin_group(ctx, pr, &bbox, &softmask);
+			gstate = pdf_begin_group(ctx, pr, bbox, &softmask);
 
 		if (dofill && dostroke)
 		{
@@ -649,7 +649,7 @@ pdf_show_path(fz_context *ctx, pdf_run_processor *pr, int doclose, int dofill, i
 			else
 			{
 				knockout_group = 1;
-				fz_begin_group(ctx, pr->dev, &bbox, NULL, 0, 1, FZ_BLEND_NORMAL, 1);
+				fz_begin_group(ctx, pr->dev, bbox, NULL, 0, 1, FZ_BLEND_NORMAL, 1);
 			}
 		}
 
@@ -666,15 +666,15 @@ pdf_show_path(fz_context *ctx, pdf_run_processor *pr, int doclose, int dofill, i
 			case PDF_MAT_PATTERN:
 				if (gstate->fill.pattern)
 				{
-					fz_clip_path(ctx, pr->dev, path, even_odd, gstate->ctm, &bbox);
-					pdf_show_pattern(ctx, pr, gstate->fill.pattern, &pr->gstate[gstate->fill.gstate_num], &bbox, PDF_FILL);
+					fz_clip_path(ctx, pr->dev, path, even_odd, gstate->ctm, bbox);
+					pdf_show_pattern(ctx, pr, gstate->fill.pattern, &pr->gstate[gstate->fill.gstate_num], bbox, PDF_FILL);
 					fz_pop_clip(ctx, pr->dev);
 				}
 				break;
 			case PDF_MAT_SHADE:
 				if (gstate->fill.shade)
 				{
-					fz_clip_path(ctx, pr->dev, path, even_odd, gstate->ctm, &bbox);
+					fz_clip_path(ctx, pr->dev, path, even_odd, gstate->ctm, bbox);
 					/* The cluster and page 2 of patterns.pdf shows that fz_fill_shade should NOT be called with gstate->ctm. */
 					fz_fill_shade(ctx, pr->dev, gstate->fill.shade, pr->gstate[gstate->fill.gstate_num].ctm, gstate->fill.alpha, &gstate->fill.color_params);
 					fz_pop_clip(ctx, pr->dev);
@@ -696,15 +696,15 @@ pdf_show_path(fz_context *ctx, pdf_run_processor *pr, int doclose, int dofill, i
 			case PDF_MAT_PATTERN:
 				if (gstate->stroke.pattern)
 				{
-					fz_clip_stroke_path(ctx, pr->dev, path, gstate->stroke_state, gstate->ctm, &bbox);
-					pdf_show_pattern(ctx, pr, gstate->stroke.pattern, &pr->gstate[gstate->stroke.gstate_num], &bbox, PDF_STROKE);
+					fz_clip_stroke_path(ctx, pr->dev, path, gstate->stroke_state, gstate->ctm, bbox);
+					pdf_show_pattern(ctx, pr, gstate->stroke.pattern, &pr->gstate[gstate->stroke.gstate_num], bbox, PDF_STROKE);
 					fz_pop_clip(ctx, pr->dev);
 				}
 				break;
 			case PDF_MAT_SHADE:
 				if (gstate->stroke.shade)
 				{
-					fz_clip_stroke_path(ctx, pr->dev, path, gstate->stroke_state, gstate->ctm, &bbox);
+					fz_clip_stroke_path(ctx, pr->dev, path, gstate->stroke_state, gstate->ctm, bbox);
 					fz_fill_shade(ctx, pr->dev, gstate->stroke.shade, pr->gstate[gstate->stroke.gstate_num].ctm, gstate->stroke.alpha, &gstate->stroke.color_params);
 					fz_pop_clip(ctx, pr->dev);
 				}
@@ -722,7 +722,7 @@ pdf_show_path(fz_context *ctx, pdf_run_processor *pr, int doclose, int dofill, i
 		{
 			gstate = pr->gstate + pr->gtop; /* in case it was changed by pdf_begin_group */
 			gstate->clip_depth++;
-			fz_clip_path(ctx, pr->dev, path, pr->clip_even_odd, gstate->ctm, &bbox);
+			fz_clip_path(ctx, pr->dev, path, pr->clip_even_odd, gstate->ctm, bbox);
 			pr->clip = 0;
 		}
 	}
@@ -783,7 +783,7 @@ pdf_flush_text(fz_context *ctx, pdf_run_processor *pr)
 			break;
 
 		if (dofill || dostroke)
-			gstate = pdf_begin_group(ctx, pr, &tb, &softmask);
+			gstate = pdf_begin_group(ctx, pr, tb, &softmask);
 
 		if (dofill && dostroke)
 		{
@@ -799,7 +799,7 @@ pdf_flush_text(fz_context *ctx, pdf_run_processor *pr)
 			else
 			{
 				knockout_group = 1;
-				fz_begin_group(ctx, pr->dev, &tb, NULL, 0, 1, FZ_BLEND_NORMAL, 1);
+				fz_begin_group(ctx, pr->dev, tb, NULL, 0, 1, FZ_BLEND_NORMAL, 1);
 			}
 		}
 
@@ -819,15 +819,15 @@ pdf_flush_text(fz_context *ctx, pdf_run_processor *pr)
 			case PDF_MAT_PATTERN:
 				if (gstate->fill.pattern)
 				{
-					fz_clip_text(ctx, pr->dev, text, gstate->ctm, &tb);
-					pdf_show_pattern(ctx, pr, gstate->fill.pattern, &pr->gstate[gstate->fill.gstate_num], &tb, PDF_FILL);
+					fz_clip_text(ctx, pr->dev, text, gstate->ctm, tb);
+					pdf_show_pattern(ctx, pr, gstate->fill.pattern, &pr->gstate[gstate->fill.gstate_num], tb, PDF_FILL);
 					fz_pop_clip(ctx, pr->dev);
 				}
 				break;
 			case PDF_MAT_SHADE:
 				if (gstate->fill.shade)
 				{
-					fz_clip_text(ctx, pr->dev, text, gstate->ctm, &tb);
+					fz_clip_text(ctx, pr->dev, text, gstate->ctm, tb);
 					/* Page 2 of patterns.pdf shows that fz_fill_shade should NOT be called with gstate->ctm */
 					fz_fill_shade(ctx, pr->dev, gstate->fill.shade, pr->gstate[gstate->fill.gstate_num].ctm, gstate->fill.alpha, &gstate->fill.color_params);
 					fz_pop_clip(ctx, pr->dev);
@@ -849,15 +849,15 @@ pdf_flush_text(fz_context *ctx, pdf_run_processor *pr)
 			case PDF_MAT_PATTERN:
 				if (gstate->stroke.pattern)
 				{
-					fz_clip_stroke_text(ctx, pr->dev, text, gstate->stroke_state, gstate->ctm, &tb);
-					pdf_show_pattern(ctx, pr, gstate->stroke.pattern, &pr->gstate[gstate->stroke.gstate_num], &tb, PDF_STROKE);
+					fz_clip_stroke_text(ctx, pr->dev, text, gstate->stroke_state, gstate->ctm, tb);
+					pdf_show_pattern(ctx, pr, gstate->stroke.pattern, &pr->gstate[gstate->stroke.gstate_num], tb, PDF_STROKE);
 					fz_pop_clip(ctx, pr->dev);
 				}
 				break;
 			case PDF_MAT_SHADE:
 				if (gstate->stroke.shade)
 				{
-					fz_clip_stroke_text(ctx, pr->dev, text, gstate->stroke_state, gstate->ctm, &tb);
+					fz_clip_stroke_text(ctx, pr->dev, text, gstate->stroke_state, gstate->ctm, tb);
 					fz_fill_shade(ctx, pr->dev, gstate->stroke.shade, pr->gstate[gstate->stroke.gstate_num].ctm, gstate->stroke.alpha, &gstate->stroke.color_params);
 					fz_pop_clip(ctx, pr->dev);
 				}
@@ -874,7 +874,7 @@ pdf_flush_text(fz_context *ctx, pdf_run_processor *pr)
 		if (doclip)
 		{
 			gstate->clip_depth++;
-			fz_clip_text(ctx, pr->dev, text, gstate->ctm, &tb);
+			fz_clip_text(ctx, pr->dev, text, gstate->ctm, tb);
 		}
 	}
 	fz_always(ctx)
@@ -1253,7 +1253,7 @@ pdf_run_xobject(fz_context *ctx, pdf_run_processor *proc, pdf_obj *xobj, pdf_obj
 			cleanup_state = 2;
 			if (isolated)
 				cs = pdf_xobject_colorspace(ctx, xobj);
-			fz_begin_group(ctx, pr->dev, &bbox,
+			fz_begin_group(ctx, pr->dev, bbox,
 					cs,
 					(is_smask ? 1 : isolated),
 					pdf_xobject_knockout(ctx, xobj),
diff --git a/source/pdf/pdf-run.c b/source/pdf/pdf-run.c
index ae936253..5e4badf3 100644
--- a/source/pdf/pdf-run.c
+++ b/source/pdf/pdf-run.c
@@ -78,7 +78,7 @@ pdf_run_page_contents_with_usage(fz_context *ctx, pdf_document *doc, pdf_page *p
 			else
 				colorspace = fz_keep_colorspace(ctx, fz_default_output_intent(ctx, default_cs));
 
-			fz_begin_group(ctx, dev, &mediabox, colorspace, 1, 0, 0, 1);
+			fz_begin_group(ctx, dev, mediabox, colorspace, 1, 0, 0, 1);
 			fz_drop_colorspace(ctx, colorspace);
 			colorspace = NULL;
 		}
diff --git a/source/pdf/pdf-write.c b/source/pdf/pdf-write.c
index 63863104..f1f49299 100644
--- a/source/pdf/pdf-write.c
+++ b/source/pdf/pdf-write.c
@@ -3286,11 +3286,11 @@ struct pdf_writer_s
 };
 
 static fz_device *
-pdf_writer_begin_page(fz_context *ctx, fz_document_writer *wri_, const fz_rect *mediabox)
+pdf_writer_begin_page(fz_context *ctx, fz_document_writer *wri_, fz_rect mediabox)
 {
 	pdf_writer *wri = (pdf_writer*)wri_;
-	wri->mediabox = *mediabox;
-	return pdf_page_write(ctx, wri->pdf, &wri->mediabox, &wri->resources, &wri->contents);
+	wri->mediabox = mediabox;
+	return pdf_page_write(ctx, wri->pdf, wri->mediabox, &wri->resources, &wri->contents);
 }
 
 static void
diff --git a/source/tools/muconvert.c b/source/tools/muconvert.c
index e68a77c7..4a0e99de 100644
--- a/source/tools/muconvert.c
+++ b/source/tools/muconvert.c
@@ -76,7 +76,7 @@ static void runpage(int number)
 	fz_try(ctx)
 	{
 		mediabox = fz_bound_page(ctx, page);
-		dev = fz_begin_page(ctx, out, &mediabox);
+		dev = fz_begin_page(ctx, out, mediabox);
 		fz_run_page(ctx, page, dev, fz_identity, NULL);
 	}
 	fz_always(ctx)
diff --git a/source/tools/mudraw.c b/source/tools/mudraw.c
index 828db0d0..cbd605b7 100644
--- a/source/tools/mudraw.c
+++ b/source/tools/mudraw.c
@@ -461,7 +461,7 @@ file_level_trailers(fz_context *ctx)
 
 }
 
-static void drawband(fz_context *ctx, fz_page *page, fz_display_list *list, fz_matrix ctm, const fz_rect *tbounds, fz_cookie *cookie, int band_start, fz_pixmap *pix, fz_bitmap **bit)
+static void drawband(fz_context *ctx, fz_page *page, fz_display_list *list, fz_matrix ctm, fz_rect tbounds, fz_cookie *cookie, int band_start, fz_pixmap *pix, fz_bitmap **bit)
 {
 	fz_device *dev = NULL;
 
@@ -538,7 +538,7 @@ static void dodrawpage(fz_context *ctx, fz_page *page, fz_display_list *list, in
 			if (lowmemory)
 				fz_enable_device_hints(ctx, dev, FZ_NO_CACHE);
 			if (list)
-				fz_run_display_list(ctx, list, dev, fz_identity, &fz_infinite_rect, cookie);
+				fz_run_display_list(ctx, list, dev, fz_identity, fz_infinite_rect, cookie);
 			else
 				fz_run_page(ctx, page, dev, fz_identity, cookie);
 			fz_write_printf(ctx, out, "</page>\n");
@@ -578,7 +578,7 @@ static void dodrawpage(fz_context *ctx, fz_page *page, fz_display_list *list, in
 			if (lowmemory)
 				fz_enable_device_hints(ctx, dev, FZ_NO_CACHE);
 			if (list)
-				fz_run_display_list(ctx, list, dev, ctm, &fz_infinite_rect, cookie);
+				fz_run_display_list(ctx, list, dev, ctm, fz_infinite_rect, cookie);
 			else
 				fz_run_page(ctx, page, dev, ctm, cookie);
 			fz_close_device(ctx, dev);
@@ -629,9 +629,9 @@ static void dodrawpage(fz_context *ctx, fz_page *page, fz_display_list *list, in
 		{
 			pdf_obj *page_obj;
 
-			dev = pdf_page_write(ctx, pdfout, &mediabox, &resources, &contents);
+			dev = pdf_page_write(ctx, pdfout, mediabox, &resources, &contents);
 			if (list)
-				fz_run_display_list(ctx, list, dev, fz_identity, NULL, cookie);
+				fz_run_display_list(ctx, list, dev, fz_identity, fz_infinite_rect, cookie);
 			else
 				fz_run_page(ctx, page, dev, fz_identity, cookie);
 			fz_close_device(ctx, dev);
@@ -686,7 +686,7 @@ static void dodrawpage(fz_context *ctx, fz_page *page, fz_display_list *list, in
 			if (lowmemory)
 				fz_enable_device_hints(ctx, dev, FZ_NO_CACHE);
 			if (list)
-				fz_run_display_list(ctx, list, dev, ctm, &tbounds, cookie);
+				fz_run_display_list(ctx, list, dev, ctm, tbounds, cookie);
 			else
 				fz_run_page(ctx, page, dev, ctm, cookie);
 			fz_close_device(ctx, dev);
@@ -880,7 +880,7 @@ static void dodrawpage(fz_context *ctx, fz_page *page, fz_display_list *list, in
 					cookie->errors += w->cookie.errors;
 				}
 				else
-					drawband(ctx, page, list, ctm, &tbounds, cookie, band * band_height, pix, &bit);
+					drawband(ctx, page, list, ctm, tbounds, cookie, band * band_height, pix, &bit);
 
 				if (output)
 				{
@@ -1115,7 +1115,7 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum)
 		fz_try(ctx)
 		{
 			if (list)
-				fz_run_display_list(ctx, list, dev, fz_identity, &fz_infinite_rect, NULL);
+				fz_run_display_list(ctx, list, dev, fz_identity, fz_infinite_rect, NULL);
 			else
 				fz_run_page(ctx, page, dev, fz_identity, &cookie);
 			fz_close_device(ctx, dev);
@@ -1314,7 +1314,7 @@ static void worker_thread(void *arg)
 		mu_wait_semaphore(&me->start);
 		DEBUG_THREADS(("Worker %d woken for band %d\n", me->num, me->band));
 		if (me->band >= 0)
-			drawband(me->ctx, NULL, me->list, me->ctm, &me->tbounds, &me->cookie, me->band * band_height, me->pix, &me->bit);
+			drawband(me->ctx, NULL, me->list, me->ctm, me->tbounds, &me->cookie, me->band * band_height, me->pix, &me->bit);
 		DEBUG_THREADS(("Worker %d completed band %d\n", me->num, me->band));
 		mu_trigger_semaphore(&me->stop);
 	}
diff --git a/source/tools/muraster.c b/source/tools/muraster.c
index 71e8dead..628229ae 100644
--- a/source/tools/muraster.c
+++ b/source/tools/muraster.c
@@ -522,7 +522,7 @@ static int gettime(void)
 	return (now.tv_sec - first.tv_sec) * 1000 + (now.tv_usec - first.tv_usec) / 1000;
 }
 
-static int drawband(fz_context *ctx, fz_page *page, fz_display_list *list, fz_matrix ctm, const fz_rect *tbounds, fz_cookie *cookie, int band_start, fz_pixmap *pix, fz_bitmap **bit)
+static int drawband(fz_context *ctx, fz_page *page, fz_display_list *list, fz_matrix ctm, fz_rect tbounds, fz_cookie *cookie, int band_start, fz_pixmap *pix, fz_bitmap **bit)
 {
 	fz_device *dev = NULL;
 
diff --git a/source/tools/murun.c b/source/tools/murun.c
index b2a12484..c6ad673f 100644
--- a/source/tools/murun.c
+++ b/source/tools/murun.c
@@ -835,7 +835,7 @@ js_dev_fill_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_
 
 static void
 js_dev_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm,
-	const fz_rect *scissor)
+	fz_rect scissor)
 {
 	js_State *J = ((js_device*)dev)->J;
 	if (js_try(J))
@@ -874,7 +874,7 @@ js_dev_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path,
 
 static void
 js_dev_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke,
-	fz_matrix ctm, const fz_rect *scissor)
+	fz_matrix ctm, fz_rect scissor)
 {
 	js_State *J = ((js_device*)dev)->J;
 	if (js_try(J))
@@ -930,7 +930,7 @@ js_dev_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const f
 }
 
 static void
-js_dev_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, const fz_rect *scissor)
+js_dev_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, fz_rect scissor)
 {
 	js_State *J = ((js_device*)dev)->J;
 	if (js_try(J))
@@ -947,7 +947,7 @@ js_dev_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix
 
 static void
 js_dev_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke,
-	fz_matrix ctm, const fz_rect *scissor)
+	fz_matrix ctm, fz_rect scissor)
 {
 	js_State *J = ((js_device*)dev)->J;
 	if (js_try(J))
@@ -1035,7 +1035,7 @@ js_dev_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matr
 }
 
 static void
-js_dev_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, const fz_rect *scissor)
+js_dev_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, fz_rect scissor)
 {
 	js_State *J = ((js_device*)dev)->J;
 	if (js_try(J))
@@ -1065,7 +1065,7 @@ js_dev_pop_clip(fz_context *ctx, fz_device *dev)
 }
 
 static void
-js_dev_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int luminosity,
+js_dev_begin_mask(fz_context *ctx, fz_device *dev, fz_rect bbox, int luminosity,
 	fz_colorspace *colorspace, const float *color, const fz_color_params *color_params)
 {
 	js_State *J = ((js_device*)dev)->J;
@@ -1073,7 +1073,7 @@ js_dev_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int lumi
 		rethrow_as_fz(J);
 	if (js_hasproperty(J, -1, "beginMask")) {
 		js_copy(J, -2);
-		ffi_pushrect(J, *bbox);
+		ffi_pushrect(J, bbox);
 		js_pushboolean(J, luminosity);
 		ffi_pushcolor(J, colorspace, color, 1);
 		ffi_pushcolorparams(J, color_params);
@@ -1098,7 +1098,7 @@ js_dev_end_mask(fz_context *ctx, fz_device *dev)
 }
 
 static void
-js_dev_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *bbox,
+js_dev_begin_group(fz_context *ctx, fz_device *dev, fz_rect bbox,
 	fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha)
 {
 	js_State *J = ((js_device*)dev)->J;
@@ -1106,7 +1106,7 @@ js_dev_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *bbox,
 		rethrow_as_fz(J);
 	if (js_hasproperty(J, -1, "beginGroup")) {
 		js_copy(J, -2);
-		ffi_pushrect(J, *bbox);
+		ffi_pushrect(J, bbox);
 		js_pushboolean(J, isolated);
 		js_pushboolean(J, knockout);
 		js_pushliteral(J, fz_blendmode_name(blendmode));
@@ -1132,7 +1132,7 @@ js_dev_end_group(fz_context *ctx, fz_device *dev)
 }
 
 static int
-js_dev_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view,
+js_dev_begin_tile(fz_context *ctx, fz_device *dev, fz_rect area, fz_rect view,
 	float xstep, float ystep, fz_matrix ctm, int id)
 {
 	js_State *J = ((js_device*)dev)->J;
@@ -1141,8 +1141,8 @@ js_dev_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz
 	if (js_hasproperty(J, -1, "beginTile")) {
 		int n;
 		js_copy(J, -2);
-		ffi_pushrect(J, *area);
-		ffi_pushrect(J, *view);
+		ffi_pushrect(J, area);
+		ffi_pushrect(J, view);
 		js_pushnumber(J, xstep);
 		js_pushnumber(J, ystep);
 		ffi_pushmatrix(J, ctm);
@@ -1286,7 +1286,7 @@ static void ffi_Device_clipPath(js_State *J)
 	int even_odd = js_toboolean(J, 2);
 	fz_matrix ctm = ffi_tomatrix(J, 3);
 	fz_try(ctx)
-		fz_clip_path(ctx, dev, path, even_odd, ctm, NULL);
+		fz_clip_path(ctx, dev, path, even_odd, ctm, fz_infinite_rect);
 	fz_catch(ctx)
 		rethrow(J);
 }
@@ -1299,7 +1299,7 @@ static void ffi_Device_clipStrokePath(js_State *J)
 	fz_stroke_state stroke = ffi_tostroke(J, 2);
 	fz_matrix ctm = ffi_tomatrix(J, 3);
 	fz_try(ctx)
-		fz_clip_stroke_path(ctx, dev, path, &stroke, ctm, NULL);
+		fz_clip_stroke_path(ctx, dev, path, &stroke, ctm, fz_infinite_rect);
 	fz_catch(ctx)
 		rethrow(J);
 }
@@ -1340,7 +1340,7 @@ static void ffi_Device_clipText(js_State *J)
 	fz_text *text = js_touserdata(J, 1, "fz_text");
 	fz_matrix ctm = ffi_tomatrix(J, 2);
 	fz_try(ctx)
-		fz_clip_text(ctx, dev, text, ctm, NULL);
+		fz_clip_text(ctx, dev, text, ctm, fz_infinite_rect);
 	fz_catch(ctx)
 		rethrow(J);
 }
@@ -1353,7 +1353,7 @@ static void ffi_Device_clipStrokeText(js_State *J)
 	fz_stroke_state stroke = ffi_tostroke(J, 2);
 	fz_matrix ctm = ffi_tomatrix(J, 3);
 	fz_try(ctx)
-		fz_clip_stroke_text(ctx, dev, text, &stroke, ctm, NULL);
+		fz_clip_stroke_text(ctx, dev, text, &stroke, ctm, fz_infinite_rect);
 	fz_catch(ctx)
 		rethrow(J);
 }
@@ -1419,7 +1419,7 @@ static void ffi_Device_clipImageMask(js_State *J)
 	fz_image *image = js_touserdata(J, 1, "fz_image");
 	fz_matrix ctm = ffi_tomatrix(J, 2);
 	fz_try(ctx)
-		fz_clip_image_mask(ctx, dev, image, ctm, NULL);
+		fz_clip_image_mask(ctx, dev, image, ctm, fz_infinite_rect);
 	fz_catch(ctx)
 		rethrow(J);
 }
@@ -1443,7 +1443,7 @@ static void ffi_Device_beginMask(js_State *J)
 	struct color c = ffi_tocolor(J, 3);
 	fz_color_params *color_params = ffi_tocolorparams(J, 6);
 	fz_try(ctx)
-		fz_begin_mask(ctx, dev, &area, luminosity, c.colorspace, c.color, color_params);
+		fz_begin_mask(ctx, dev, area, luminosity, c.colorspace, c.color, color_params);
 	fz_catch(ctx)
 		rethrow(J);
 }
@@ -1468,7 +1468,7 @@ static void ffi_Device_beginGroup(js_State *J)
 	int blendmode = fz_lookup_blendmode(js_tostring(J, 4));
 	float alpha = js_tonumber(J, 5);
 	fz_try(ctx)
-		fz_begin_group(ctx, dev, &area, NULL, isolated, knockout, blendmode, alpha);
+		fz_begin_group(ctx, dev, area, NULL, isolated, knockout, blendmode, alpha);
 	fz_catch(ctx)
 		rethrow(J);
 }
@@ -1495,7 +1495,7 @@ static void ffi_Device_beginTile(js_State *J)
 	int id = js_tonumber(J, 6);
 	int n = 0;
 	fz_try(ctx)
-		n = fz_begin_tile_id(ctx, dev, &area, &view, xstep, ystep, ctm, id);
+		n = fz_begin_tile_id(ctx, dev, area, view, xstep, ystep, ctm, id);
 	fz_catch(ctx)
 		rethrow(J);
 	js_pushnumber(J, n);
@@ -2731,14 +2731,14 @@ static void ffi_DisplayList_run(js_State *J)
 	if (js_isuserdata(J, 1, "fz_device")) {
 		device = js_touserdata(J, 1, "fz_device");
 		fz_try(ctx)
-			fz_run_display_list(ctx, list, device, ctm, NULL, NULL);
+			fz_run_display_list(ctx, list, device, ctm, fz_infinite_rect, NULL);
 		fz_catch(ctx)
 			rethrow(J);
 	} else {
 		device = new_js_device(ctx, J);
 		js_copy(J, 1);
 		fz_try(ctx) {
-			fz_run_display_list(ctx, list, device, ctm, NULL, NULL);
+			fz_run_display_list(ctx, list, device, ctm, fz_infinite_rect, NULL);
 			fz_close_device(ctx, device);
 		}
 		fz_always(ctx)
@@ -2923,7 +2923,7 @@ static void ffi_DocumentWriter_beginPage(js_State *J)
 	fz_device *device = NULL;
 
 	fz_try(ctx)
-		device = fz_begin_page(ctx, wri, &mediabox);
+		device = fz_begin_page(ctx, wri, mediabox);
 	fz_catch(ctx)
 		rethrow(J);
 
diff --git a/source/tools/mutrace.c b/source/tools/mutrace.c
index c9e988b9..5d179b36 100644
--- a/source/tools/mutrace.c
+++ b/source/tools/mutrace.c
@@ -51,7 +51,7 @@ static void runpage(fz_context *ctx, fz_document *doc, int number)
 		if (use_display_list)
 		{
 			list = fz_new_display_list_from_page(ctx, page);
-			fz_run_display_list(ctx, list, dev, fz_identity, NULL, NULL);
+			fz_run_display_list(ctx, list, dev, fz_identity, fz_infinite_rect, NULL);
 		}
 		else
 		{
diff --git a/source/tools/pdfposter.c b/source/tools/pdfposter.c
index 387d8cae..1ec70460 100644
--- a/source/tools/pdfposter.c
+++ b/source/tools/pdfposter.c
@@ -23,7 +23,7 @@ static void usage(void)
 }
 
 static void
-intersect_box(fz_context *ctx, pdf_document *doc, pdf_obj *page, pdf_obj *box_name, const fz_rect *mb)
+intersect_box(fz_context *ctx, pdf_document *doc, pdf_obj *page, pdf_obj *box_name, fz_rect mb)
 {
 	pdf_obj *box = pdf_dict_get(ctx, page, box_name);
 	pdf_obj *newbox;
@@ -37,14 +37,14 @@ intersect_box(fz_context *ctx, pdf_document *doc, pdf_obj *page, pdf_obj *box_na
 	old_rect.x1 = pdf_array_get_real(ctx, box, 2);
 	old_rect.y1 = pdf_array_get_real(ctx, box, 3);
 
-	if (old_rect.x0 < mb->x0)
-		old_rect.x0 = mb->x0;
-	if (old_rect.y0 < mb->y0)
-		old_rect.y0 = mb->y0;
-	if (old_rect.x1 > mb->x1)
-		old_rect.x1 = mb->x1;
-	if (old_rect.y1 > mb->y1)
-		old_rect.y1 = mb->y1;
+	if (old_rect.x0 < mb.x0)
+		old_rect.x0 = mb.x0;
+	if (old_rect.y0 < mb.y0)
+		old_rect.y0 = mb.y0;
+	if (old_rect.x1 > mb.x1)
+		old_rect.x1 = mb.x1;
+	if (old_rect.y1 > mb.y1)
+		old_rect.y1 = mb.y1;
 
 	newbox = pdf_new_array(ctx, doc, 4);
 	pdf_array_push_real(ctx, newbox, old_rect.x0);
@@ -139,10 +139,10 @@ static void decimatepages(fz_context *ctx, pdf_document *doc)
 				pdf_dict_put(ctx, newpageobj, PDF_NAME(Parent), pages);
 				pdf_dict_put_drop(ctx, newpageobj, PDF_NAME(MediaBox), newmediabox);
 
-				intersect_box(ctx, doc, newpageobj, PDF_NAME(CropBox), &mb);
-				intersect_box(ctx, doc, newpageobj, PDF_NAME(BleedBox), &mb);
-				intersect_box(ctx, doc, newpageobj, PDF_NAME(TrimBox), &mb);
-				intersect_box(ctx, doc, newpageobj, PDF_NAME(ArtBox), &mb);
+				intersect_box(ctx, doc, newpageobj, PDF_NAME(CropBox), mb);
+				intersect_box(ctx, doc, newpageobj, PDF_NAME(BleedBox), mb);
+				intersect_box(ctx, doc, newpageobj, PDF_NAME(TrimBox), mb);
+				intersect_box(ctx, doc, newpageobj, PDF_NAME(ArtBox), mb);
 
 				/* Store page object in new kids array */
 				pdf_drop_obj(ctx, newpageobj);
diff --git a/source/xps/xps-common.c b/source/xps/xps-common.c
index 75baa2bf..0e895885 100644
--- a/source/xps/xps-common.c
+++ b/source/xps/xps-common.c
@@ -109,7 +109,7 @@ xps_begin_opacity(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect are
 
 	if (opacity_mask_tag)
 	{
-		fz_begin_mask(ctx, dev, &area, 0, NULL, NULL, NULL);
+		fz_begin_mask(ctx, dev, area, 0, NULL, NULL, NULL);
 		xps_parse_brush(ctx, doc, ctm, area, base_uri, dict, opacity_mask_tag);
 		fz_end_mask(ctx, dev);
 	}
diff --git a/source/xps/xps-glyphs.c b/source/xps/xps-glyphs.c
index de9b4f45..75d49e68 100644
--- a/source/xps/xps-glyphs.c
+++ b/source/xps/xps-glyphs.c
@@ -613,7 +613,7 @@ xps_parse_glyphs(fz_context *ctx, xps_document *doc, fz_matrix ctm,
 
 	if (fill_tag)
 	{
-		fz_clip_text(ctx, dev, text, ctm, &area);
+		fz_clip_text(ctx, dev, text, ctm, area);
 		xps_parse_brush(ctx, doc, ctm, area, fill_uri, dict, fill_tag);
 		fz_pop_clip(ctx, dev);
 	}
diff --git a/source/xps/xps-path.c b/source/xps/xps-path.c
index 42ecd2b1..d1d80b23 100644
--- a/source/xps/xps-path.c
+++ b/source/xps/xps-path.c
@@ -767,7 +767,7 @@ xps_clip(fz_context *ctx, xps_document *doc, fz_matrix ctm, xps_resource *dict,
 		path = xps_parse_path_geometry(ctx, doc, dict, clip_tag, 0, &fill_rule);
 	else
 		path = fz_new_path(ctx);
-	fz_clip_path(ctx, dev, path, fill_rule == 0, ctm, NULL);
+	fz_clip_path(ctx, dev, path, fill_rule == 0, ctm, fz_infinite_rect);
 	fz_drop_path(ctx, path);
 }
 
@@ -1007,7 +1007,7 @@ xps_parse_path(fz_context *ctx, xps_document *doc, fz_matrix ctm, char *base_uri
 
 		if (fill_tag)
 		{
-			fz_clip_path(ctx, dev, path, fill_rule == 0, ctm, &area);
+			fz_clip_path(ctx, dev, path, fill_rule == 0, ctm, area);
 			xps_parse_brush(ctx, doc, ctm, area, fill_uri, dict, fill_tag);
 			fz_pop_clip(ctx, dev);
 		}
@@ -1024,7 +1024,7 @@ xps_parse_path(fz_context *ctx, xps_document *doc, fz_matrix ctm, char *base_uri
 
 		if (stroke_tag)
 		{
-			fz_clip_stroke_path(ctx, dev, stroke_path, stroke, ctm, &area);
+			fz_clip_stroke_path(ctx, dev, stroke_path, stroke, ctm, area);
 			xps_parse_brush(ctx, doc, ctm, area, stroke_uri, dict, stroke_tag);
 			fz_pop_clip(ctx, dev);
 		}
diff --git a/source/xps/xps-tile.c b/source/xps/xps-tile.c
index 83903dd2..7def81c9 100644
--- a/source/xps/xps-tile.c
+++ b/source/xps/xps-tile.c
@@ -33,7 +33,7 @@ xps_paint_tiling_brush_clipped(fz_context *ctx, xps_document *doc, fz_matrix ctm
 	fz_lineto(ctx, path, viewbox.x1, viewbox.y1);
 	fz_lineto(ctx, path, viewbox.x1, viewbox.y0);
 	fz_closepath(ctx, path);
-	fz_clip_path(ctx, dev, path, 0, ctm, NULL);
+	fz_clip_path(ctx, dev, path, 0, ctm, fz_infinite_rect);
 	fz_drop_path(ctx, path);
 	c->func(ctx, doc, ctm, viewbox, c->base_uri, c->dict, c->root, c->user);
 	fz_pop_clip(ctx, dev);
@@ -183,7 +183,7 @@ xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rec
 			fz_rect bigview = viewbox;
 			bigview.x1 = bigview.x0 + xstep;
 			bigview.y1 = bigview.y0 + ystep;
-			fz_begin_tile(ctx, dev, &area, &bigview, xstep, ystep, ctm);
+			fz_begin_tile(ctx, dev, area, bigview, xstep, ystep, ctm);
 			xps_paint_tiling_brush(ctx, doc, ctm, viewbox, tile_mode, &c);
 			fz_end_tile(ctx, dev);
 		}