Add warning context.

54 files changed, 366 insertions, 364 deletions

diff --git a/apps/pdfapp.c b/apps/pdfapp.c
index 36985010..c992b504 100644
--- a/apps/pdfapp.c
+++ b/apps/pdfapp.c
@@ -239,7 +239,7 @@ void pdfapp_close(pdfapp_t *app)
 		app->xps = NULL;
 	}
 
-	fz_flush_warnings();
+	fz_flush_warnings(app->ctx);
 }
 
 static fz_matrix pdfapp_viewctm(pdfapp_t *app)
@@ -426,7 +426,7 @@ static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repai
 		wincursor(app, ARROW);
 	}
 
-	fz_flush_warnings();
+	fz_flush_warnings(app->ctx);
 }
 
 static void pdfapp_gotouri(pdfapp_t *app, fz_obj *uri)
diff --git a/apps/pdfclean.c b/apps/pdfclean.c
index a1e70a1a..4b5fa139 100644
--- a/apps/pdfclean.c
+++ b/apps/pdfclean.c
@@ -782,7 +782,7 @@ int main(int argc, char **argv)
 	fz_free(xref->ctx, renumbermap);
 
 	pdf_free_xref(xref);
-	fz_flush_warnings();
+	fz_flush_warnings(ctx);
 	fz_free_context(ctx);
 	return 0;
 }
diff --git a/apps/pdfdraw.c b/apps/pdfdraw.c
index a088a938..c65ef059 100644
--- a/apps/pdfdraw.c
+++ b/apps/pdfdraw.c
@@ -256,7 +256,7 @@ static void drawpage(pdf_xref *xref, int pagenum)
 
 	pdf_age_store(ctx, xref->store, 3);
 
-	fz_flush_warnings();
+	fz_flush_warnings(ctx);
 }
 
 static void drawrange(pdf_xref *xref, char *range)
@@ -407,9 +407,7 @@ int main(int argc, char **argv)
 	}
 
 	fz_free_glyph_cache(ctx, glyphcache);
-
-	fz_flush_warnings();
-
+	fz_flush_warnings(ctx);
 	fz_free_context(ctx);
 	return 0;
 }
diff --git a/apps/pdfextract.c b/apps/pdfextract.c
index f59f7df8..7e09226e 100644
--- a/apps/pdfextract.c
+++ b/apps/pdfextract.c
@@ -129,7 +129,7 @@ static void savefont(fz_obj *dict, int num)
 
 	if (!stream)
 	{
-		fz_warn("Unhandled font type");
+		fz_warn(ctx, "Unhandled font type");
 		return;
 	}
 
@@ -221,7 +221,7 @@ int main(int argc, char **argv)
 	}
 
 	pdf_free_xref(xref);
-	fz_flush_warnings();
+	fz_flush_warnings(ctx);
 	fz_free_context(ctx);
 	return 0;
 }
diff --git a/apps/pdfinfo.c b/apps/pdfinfo.c
index 3e403b08..d2aa0bb4 100644
--- a/apps/pdfinfo.c
+++ b/apps/pdfinfo.c
@@ -251,7 +251,7 @@ gatherfonts(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 		fontdict = fz_dict_get_val(dict, i);
 		if (!fz_is_dict(fontdict))
 		{
-			fz_warn("not a font dict (%d %d R)", fz_to_num(fontdict), fz_to_gen(fontdict));
+			fz_warn(ctx, "not a font dict (%d %d R)", fz_to_num(fontdict), fz_to_gen(fontdict));
 			continue;
 		}
 
@@ -300,7 +300,7 @@ gatherimages(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 		imagedict = fz_dict_get_val(dict, i);
 		if (!fz_is_dict(imagedict))
 		{
-			fz_warn("not an image dict (%d %d R)", fz_to_num(imagedict), fz_to_gen(imagedict));
+			fz_warn(ctx, "not an image dict (%d %d R)", fz_to_num(imagedict), fz_to_gen(imagedict));
 			continue;
 		}
 
@@ -371,7 +371,7 @@ gatherforms(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 		xobjdict = fz_dict_get_val(dict, i);
 		if (!fz_is_dict(xobjdict))
 		{
-			fz_warn("not a xobject dict (%d %d R)", fz_to_num(xobjdict), fz_to_gen(xobjdict));
+			fz_warn(ctx, "not a xobject dict (%d %d R)", fz_to_num(xobjdict), fz_to_gen(xobjdict));
 			continue;
 		}
 
@@ -422,7 +422,7 @@ gatherpsobjs(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 		xobjdict = fz_dict_get_val(dict, i);
 		if (!fz_is_dict(xobjdict))
 		{
-			fz_warn("not a xobject dict (%d %d R)", fz_to_num(xobjdict), fz_to_gen(xobjdict));
+			fz_warn(ctx, "not a xobject dict (%d %d R)", fz_to_num(xobjdict), fz_to_gen(xobjdict));
 			continue;
 		}
 
@@ -464,14 +464,14 @@ gathershadings(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 		shade = fz_dict_get_val(dict, i);
 		if (!fz_is_dict(shade))
 		{
-			fz_warn("not a shading dict (%d %d R)", fz_to_num(shade), fz_to_gen(shade));
+			fz_warn(ctx, "not a shading dict (%d %d R)", fz_to_num(shade), fz_to_gen(shade));
 			continue;
 		}
 
 		type = fz_dict_gets(shade, "ShadingType");
 		if (!fz_is_int(type) || fz_to_int(type) < 1 || fz_to_int(type) > 7)
 		{
-			fz_warn("not a shading type (%d %d R)", fz_to_num(shade), fz_to_gen(shade));
+			fz_warn(ctx, "not a shading type (%d %d R)", fz_to_num(shade), fz_to_gen(shade));
 			type = NULL;
 		}
 
@@ -511,14 +511,14 @@ gatherpatterns(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 		patterndict = fz_dict_get_val(dict, i);
 		if (!fz_is_dict(patterndict))
 		{
-			fz_warn("not a pattern dict (%d %d R)", fz_to_num(patterndict), fz_to_gen(patterndict));
+			fz_warn(ctx, "not a pattern dict (%d %d R)", fz_to_num(patterndict), fz_to_gen(patterndict));
 			continue;
 		}
 
 		type = fz_dict_gets(patterndict, "PatternType");
 		if (!fz_is_int(type) || fz_to_int(type) < 1 || fz_to_int(type) > 2)
 		{
-			fz_warn("not a pattern type (%d %d R)", fz_to_num(patterndict), fz_to_gen(patterndict));
+			fz_warn(ctx, "not a pattern type (%d %d R)", fz_to_num(patterndict), fz_to_gen(patterndict));
 			type = NULL;
 		}
 
@@ -527,14 +527,14 @@ gatherpatterns(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 			paint = fz_dict_gets(patterndict, "PaintType");
 			if (!fz_is_int(paint) || fz_to_int(paint) < 1 || fz_to_int(paint) > 2)
 			{
-				fz_warn("not a pattern paint type (%d %d R)", fz_to_num(patterndict), fz_to_gen(patterndict));
+				fz_warn(ctx, "not a pattern paint type (%d %d R)", fz_to_num(patterndict), fz_to_gen(patterndict));
 				paint = NULL;
 			}
 
 			tiling = fz_dict_gets(patterndict, "TilingType");
 			if (!fz_is_int(tiling) || fz_to_int(tiling) < 1 || fz_to_int(tiling) > 3)
 			{
-				fz_warn("not a pattern tiling type (%d %d R)", fz_to_num(patterndict), fz_to_gen(patterndict));
+				fz_warn(ctx, "not a pattern tiling type (%d %d R)", fz_to_num(patterndict), fz_to_gen(patterndict));
 				tiling = NULL;
 			}
 		}
diff --git a/apps/pdfshow.c b/apps/pdfshow.c
index fc391b58..fb4bebd1 100644
--- a/apps/pdfshow.c
+++ b/apps/pdfshow.c
@@ -239,7 +239,7 @@ int main(int argc, char **argv)
 	}
 
 	pdf_free_xref(xref);
-	fz_flush_warnings();
+	fz_flush_warnings(ctx);
 	fz_free_context(ctx);
 	return 0;
 }
diff --git a/draw/draw_device.c b/draw/draw_device.c
index 3e289f3e..a8da9e19 100644
--- a/draw/draw_device.c
+++ b/draw/draw_device.c
@@ -100,7 +100,7 @@ static void fz_knockout_begin(fz_draw_device *dev)
 
 	if (dev->top == STACK_SIZE)
 	{
-		fz_warn("assert: too many buffers on stack");
+		fz_warn(dev->ctx, "assert: too many buffers on stack");
 		return;
 	}
 
@@ -160,7 +160,7 @@ static void fz_knockout_end(fz_draw_device *dev)
 
 	if (dev->top == STACK_SIZE)
 	{
-		fz_warn("assert: too many buffers on stack");
+		fz_warn(dev->ctx, "assert: too many buffers on stack");
 		return;
 	}
 
@@ -237,7 +237,7 @@ fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, fz_matrix ctm,
 	if (dev->blendmode & FZ_BLEND_KNOCKOUT)
 		fz_knockout_begin(dev);
 
-	fz_convert_color(colorspace, color, model, colorfv);
+	fz_convert_color(dev->ctx, colorspace, color, model, colorfv);
 	for (i = 0; i < model->n; i++)
 		colorbv[i] = colorfv[i] * 255;
 	colorbv[i] = alpha * 255;
@@ -290,7 +290,7 @@ fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, fz_
 	if (dev->blendmode & FZ_BLEND_KNOCKOUT)
 		fz_knockout_begin(dev);
 
-	fz_convert_color(colorspace, color, model, colorfv);
+	fz_convert_color(dev->ctx, colorspace, color, model, colorfv);
 	for (i = 0; i < model->n; i++)
 		colorbv[i] = colorfv[i] * 255;
 	colorbv[i] = alpha * 255;
@@ -325,7 +325,7 @@ fz_draw_clip_path(fz_device *devp, fz_path *path, fz_rect *rect, int even_odd, f
 
 	if (dev->top == STACK_SIZE)
 	{
-		fz_warn("assert: too many buffers on stack");
+		fz_warn(dev->ctx, "assert: too many buffers on stack");
 		return;
 	}
 
@@ -396,7 +396,7 @@ fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, fz_rect *rect, fz_strok
 
 	if (dev->top == STACK_SIZE)
 	{
-		fz_warn("assert: too many buffers on stack");
+		fz_warn(dev->ctx, "assert: too many buffers on stack");
 		return;
 	}
 
@@ -498,7 +498,7 @@ fz_draw_fill_text(fz_device *devp, fz_text *text, fz_matrix ctm,
 	if (dev->blendmode & FZ_BLEND_KNOCKOUT)
 		fz_knockout_begin(dev);
 
-	fz_convert_color(colorspace, color, model, colorfv);
+	fz_convert_color(dev->ctx, colorspace, color, model, colorfv);
 	for (i = 0; i < model->n; i++)
 		colorbv[i] = colorfv[i] * 255;
 	colorbv[i] = alpha * 255;
@@ -557,7 +557,7 @@ fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, fz_
 	if (dev->blendmode & FZ_BLEND_KNOCKOUT)
 		fz_knockout_begin(dev);
 
-	fz_convert_color(colorspace, color, model, colorfv);
+	fz_convert_color(dev->ctx, colorspace, color, model, colorfv);
 	for (i = 0; i < model->n; i++)
 		colorbv[i] = colorfv[i] * 255;
 	colorbv[i] = alpha * 255;
@@ -609,7 +609,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, fz_matrix ctm, int accumulate)
 
 	if (dev->top == STACK_SIZE)
 	{
-		fz_warn("assert: too many buffers on stack");
+		fz_warn(dev->ctx, "assert: too many buffers on stack");
 		return;
 	}
 
@@ -702,7 +702,7 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke
 
 	if (dev->top == STACK_SIZE)
 	{
-		fz_warn("assert: too many buffers on stack");
+		fz_warn(dev->ctx, "assert: too many buffers on stack");
 		return;
 	}
 
@@ -794,7 +794,7 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, fz_matrix ctm, float alpha)
 
 	if (!model)
 	{
-		fz_warn("cannot render shading directly to an alpha mask");
+		fz_warn(dev->ctx, "cannot render shading directly to an alpha mask");
 		return;
 	}
 
@@ -811,7 +811,7 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, fz_matrix ctm, float alpha)
 	{
 		unsigned char *s;
 		int x, y, n, i;
-		fz_convert_color(shade->colorspace, shade->background, model, colorfv);
+		fz_convert_color(dev->ctx, shade->colorspace, shade->background, model, colorfv);
 		for (i = 0; i < model->n; i++)
 			colorbv[i] = colorfv[i] * 255;
 		colorbv[i] = 255;
@@ -906,7 +906,7 @@ fz_draw_fill_image(fz_device *devp, fz_pixmap *image, fz_matrix ctm, float alpha
 
 	if (!model)
 	{
-		fz_warn("cannot render image directly to an alpha mask");
+		fz_warn(dev->ctx, "cannot render image directly to an alpha mask");
 		return;
 	}
 
@@ -1011,7 +1011,7 @@ fz_draw_fill_image_mask(fz_device *devp, fz_pixmap *image, fz_matrix ctm,
 			image = scaled;
 	}
 
-	fz_convert_color(colorspace, color, model, colorfv);
+	fz_convert_color(dev->ctx, colorspace, color, model, colorfv);
 	for (i = 0; i < model->n; i++)
 		colorbv[i] = colorfv[i] * 255;
 	colorbv[i] = alpha * 255;
@@ -1037,7 +1037,7 @@ fz_draw_clip_image_mask(fz_device *devp, fz_pixmap *image, fz_rect *rect, fz_mat
 
 	if (dev->top == STACK_SIZE)
 	{
-		fz_warn("assert: too many buffers on stack");
+		fz_warn(dev->ctx, "assert: too many buffers on stack");
 		return;
 	}
 
@@ -1180,7 +1180,7 @@ fz_draw_begin_mask(fz_device *devp, fz_rect rect, int luminosity, fz_colorspace
 
 	if (dev->top == STACK_SIZE)
 	{
-		fz_warn("assert: too many buffers on stack");
+		fz_warn(dev->ctx, "assert: too many buffers on stack");
 		return;
 	}
 
@@ -1203,7 +1203,7 @@ fz_draw_begin_mask(fz_device *devp, fz_rect rect, int luminosity, fz_colorspace
 		float bc;
 		if (!colorspace)
 			colorspace = fz_device_gray;
-		fz_convert_color(colorspace, colorfv, fz_device_gray, &bc);
+		fz_convert_color(dev->ctx, colorspace, colorfv, fz_device_gray, &bc);
 		fz_clear_pixmap_with_color(dest, bc * 255);
 		if (shape)
 			fz_clear_pixmap_with_color(shape, 255);
@@ -1242,7 +1242,7 @@ fz_draw_end_mask(fz_device *devp)
 
 	if (dev->top == STACK_SIZE)
 	{
-		fz_warn("assert: too many buffers on stack");
+		fz_warn(dev->ctx, "assert: too many buffers on stack");
 		return;
 	}
 
@@ -1299,7 +1299,7 @@ fz_draw_begin_group(fz_device *devp, fz_rect rect, int isolated, int knockout, i
 
 	if (dev->top == STACK_SIZE)
 	{
-		fz_warn("assert: too many buffers on stack");
+		fz_warn(dev->ctx, "assert: too many buffers on stack");
 		return;
 	}
 
@@ -1429,7 +1429,7 @@ fz_draw_begin_tile(fz_device *devp, fz_rect area, fz_rect view, float xstep, flo
 
 	if (dev->top == STACK_SIZE)
 	{
-		fz_warn("assert: too many buffers on stack");
+		fz_warn(dev->ctx, "assert: too many buffers on stack");
 		return;
 	}
 
@@ -1516,7 +1516,7 @@ fz_draw_free_user(fz_device *devp)
 	fz_draw_device *dev = devp->user;
 	/* TODO: pop and free the stacks */
 	if (dev->top > 0)
-		fz_warn("items left on stack in draw device: %d", dev->top);
+		fz_warn(dev->ctx, "items left on stack in draw device: %d", dev->top);
 	fz_free_gel(dev->gel);
 	fz_free(devp->ctx, dev);
 }
diff --git a/draw/draw_edge.c b/draw/draw_edge.c
index d9372cfb..e6408bf3 100644
--- a/draw/draw_edge.c
+++ b/draw/draw_edge.c
@@ -65,7 +65,7 @@ void
 fz_set_aa_level(int level)
 {
 #ifdef AA_BITS
-	fz_warn("anti-aliasing was compiled with a fixed precision of %d bits", fz_aa_level);
+	fz_warn(ctx, "anti-aliasing was compiled with a fixed precision of %d bits", fz_aa_level);
 #else
 	if (level > 6)
 	{
diff --git a/draw/draw_glyph.c b/draw/draw_glyph.c
index 1d94f767..6cb1518a 100644
--- a/draw/draw_glyph.c
+++ b/draw/draw_glyph.c
@@ -59,7 +59,7 @@ void
 fz_free_glyph_cache(fz_context *ctx, fz_glyph_cache *cache)
 {
 	fz_evict_glyph_cache(ctx, cache);
-	fz_free_hash(ctx, cache->hash);
+	fz_free_hash(cache->hash);
 	fz_free(ctx, cache);
 }
 
@@ -81,7 +81,7 @@ fz_render_glyph(fz_context *ctx, fz_glyph_cache *cache, fz_font *font, int gid,
 	if (size > MAX_FONT_SIZE)
 	{
 		/* TODO: this case should be handled by rendering glyph as a path fill */
-		fz_warn("font size too large (%g), not rendering glyph", size);
+		fz_warn(ctx, "font size too large (%g), not rendering glyph", size);
 		return NULL;
 	}
 
@@ -112,7 +112,7 @@ fz_render_glyph(fz_context *ctx, fz_glyph_cache *cache, fz_font *font, int gid,
 	}
 	else
 	{
-		fz_warn("assert: uninitialized font structure");
+		fz_warn(ctx, "assert: uninitialized font structure");
 		return NULL;
 	}
 
@@ -123,7 +123,7 @@ fz_render_glyph(fz_context *ctx, fz_glyph_cache *cache, fz_font *font, int gid,
 			if (cache->total + val->w * val->h > MAX_CACHE_SIZE)
 				fz_evict_glyph_cache(ctx, cache);
 			fz_keep_font(key.font);
-			fz_hash_insert(ctx, cache->hash, &key, val);
+			fz_hash_insert(cache->hash, &key, val);
 			cache->total += val->w * val->h;
 			return fz_keep_pixmap(val);
 		}
diff --git a/draw/draw_mesh.c b/draw/draw_mesh.c
index 6df30307..ef4ed95b 100644
--- a/draw/draw_mesh.c
+++ b/draw/draw_mesh.c
@@ -481,7 +481,7 @@ fz_paint_radial(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox)
 }
 
 static void
-fz_paint_mesh(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox)
+fz_paint_mesh(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox)
 {
 	float tri[3][MAXN];
 	fz_point p;
@@ -509,7 +509,7 @@ fz_paint_mesh(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox)
 				tri[k][2] = *mesh++ * 255;
 			else
 			{
-				fz_convert_color(shade->colorspace, mesh, dest->colorspace, tri[k] + 2);
+				fz_convert_color(ctx, shade->colorspace, mesh, dest->colorspace, tri[k] + 2);
 				for (i = 0; i < dest->colorspace->n; i++)
 					tri[k][i + 2] *= 255;
 				mesh += shade->colorspace->n;
@@ -533,7 +533,7 @@ fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_pixmap *dest,
 	{
 		for (i = 0; i < 256; i++)
 		{
-			fz_convert_color(shade->colorspace, shade->function[i], dest->colorspace, color);
+			fz_convert_color(ctx, shade->colorspace, shade->function[i], dest->colorspace, color);
 			for (k = 0; k < dest->colorspace->n; k++)
 				clut[i][k] = color[k] * 255;
 			clut[i][k] = shade->function[i][shade->colorspace->n] * 255;
@@ -551,7 +551,7 @@ fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_pixmap *dest,
 	{
 	case FZ_LINEAR: fz_paint_linear(shade, ctm, temp, bbox); break;
 	case FZ_RADIAL: fz_paint_radial(shade, ctm, temp, bbox); break;
-	case FZ_MESH: fz_paint_mesh(shade, ctm, temp, bbox); break;
+	case FZ_MESH: fz_paint_mesh(ctx, shade, ctm, temp, bbox); break;
 	}
 
 	if (shade->use_function)
diff --git a/draw/draw_path.c b/draw/draw_path.c
index efa881ef..ca33f5f2 100644
--- a/draw/draw_path.c
+++ b/draw/draw_path.c
@@ -542,10 +542,7 @@ fz_flatten_stroke_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, fz_m
 	i = 0;
 
 	if (path->len > 0 && path->items[0].k != FZ_MOVETO)
-	{
-		fz_warn("assert: path must begin with moveto");
 		return;
-	}
 
 	p0.x = p0.y = 0;
 
@@ -750,10 +747,7 @@ fz_flatten_dash_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, fz_mat
 	s.cap = stroke->start_cap;
 
 	if (path->len > 0 && path->items[0].k != FZ_MOVETO)
-	{
-		fz_warn("assert: path must begin with moveto");
 		return;
-	}
 
 	phase_len = 0;
 	for (i = 0; i < stroke->dash_len; i++)
diff --git a/fitz/base_context.c b/fitz/base_context.c
index bce0cba1..66811cf9 100644
--- a/fitz/base_context.c
+++ b/fitz/base_context.c
@@ -33,6 +33,7 @@ fz_new_context(void)
 	ctx = malloc(sizeof(fz_context));
 	if (!ctx)
 		return NULL;
+	memset(ctx, 0, sizeof *ctx);
 
 	ctx->error = malloc(sizeof(fz_error_context));
 	if (!ctx->error)
@@ -40,6 +41,12 @@ fz_new_context(void)
 	ctx->error->top = -1;
 	ctx->error->message[0] = 0;
 
+	ctx->warn = malloc(sizeof(fz_warn_context));
+	if (!ctx->warn)
+		goto cleanup;
+	ctx->warn->message[0] = 0;
+	ctx->warn->count = 0;
+
 	/* New initialisation calls for context entries go here */
 
 	return ctx;
diff --git a/fitz/base_error.c b/fitz/base_error.c
index 6963a69b..3ef69a60 100644
--- a/fitz/base_error.c
+++ b/fitz/base_error.c
@@ -1,40 +1,34 @@
 #include "fitz.h"
 
-/* Warning context
- * TODO: move into fz_context
- */
-enum { LINE_LEN = 160, LINE_COUNT = 25 };
+/* Warning context */
 
-static char warn_message[LINE_LEN] = "";
-static int warn_count = 0;
-
-void fz_flush_warnings(void)
+void fz_flush_warnings(fz_context *ctx)
 {
-	if (warn_count > 1)
-		fprintf(stderr, "warning: ... repeated %d times ...\n", warn_count);
-	warn_message[0] = 0;
-	warn_count = 0;
+	if (ctx->warn->count > 1)
+		fprintf(stderr, "warning: ... repeated %d times ...\n", ctx->warn->count);
+	ctx->warn->message[0] = 0;
+	ctx->warn->count = 0;
 }
 
-void fz_warn(char *fmt, ...)
+void fz_warn(fz_context *ctx, char *fmt, ...)
 {
 	va_list ap;
-	char buf[LINE_LEN];
+	char buf[sizeof ctx->warn->message];
 
 	va_start(ap, fmt);
 	vsnprintf(buf, sizeof buf, fmt, ap);
 	va_end(ap);
 
-	if (!strcmp(buf, warn_message))
+	if (!strcmp(buf, ctx->warn->message))
 	{
-		warn_count++;
+		ctx->warn->count++;
 	}
 	else
 	{
-		fz_flush_warnings();
+		fz_flush_warnings(ctx);
 		fprintf(stderr, "warning: %s\n", buf);
-		fz_strlcpy(warn_message, buf, sizeof warn_message);
-		warn_count = 1;
+		fz_strlcpy(ctx->warn->message, buf, sizeof ctx->warn->message);
+		ctx->warn->count = 1;
 	}
 }
 
@@ -87,43 +81,29 @@ void fz_rethrow(fz_context *ctx)
 
 /* Deprecated error bubbling */
 
-static char error_message[LINE_COUNT][LINE_LEN];
-static int error_count = 0;
-
 static void
 fz_emit_error(char what, char *location, char *message)
 {
-	fz_flush_warnings();
-
 	fprintf(stderr, "%c %s%s\n", what, location, message);
-
-	if (error_count < LINE_COUNT)
-	{
-		fz_strlcpy(error_message[error_count], location, LINE_LEN);
-		fz_strlcat(error_message[error_count], message, LINE_LEN);
-		error_count++;
-	}
 }
 
 int
 fz_get_error_count(void)
 {
-	return error_count;
+	return 0;
 }
 
 char *
 fz_get_error_line(int n)
 {
-	return error_message[n];
+	return "";
 }
 
 fz_error
 fz_error_make_imp(const char *file, int line, const char *func, char *fmt, ...)
 {
 	va_list ap;
-	char one[LINE_LEN], two[LINE_LEN];
-
-	error_count = 0;
+	char one[256], two[256];
 
 	snprintf(one, sizeof one, "%s:%d: %s(): ", file, line, func);
 	va_start(ap, fmt);
@@ -139,7 +119,7 @@ fz_error
 fz_error_note_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...)
 {
 	va_list ap;
-	char one[LINE_LEN], two[LINE_LEN];
+	char one[256], two[256];
 
 	snprintf(one, sizeof one, "%s:%d: %s(): ", file, line, func);
 	va_start(ap, fmt);
@@ -155,7 +135,7 @@ void
 fz_error_handle_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...)
 {
 	va_list ap;
-	char one[LINE_LEN], two[LINE_LEN];
+	char one[256], two[256];
 
 	snprintf(one, sizeof one, "%s:%d: %s(): ", file, line, func);
 	va_start(ap, fmt);
@@ -169,9 +149,7 @@ fz_error
 fz_error_make_impx(char *fmt, ...)
 {
 	va_list ap;
-	char buf[LINE_LEN];
-
-	error_count = 0;
+	char buf[256];
 
 	va_start(ap, fmt);
 	vsnprintf(buf, sizeof buf, fmt, ap);
@@ -186,7 +164,7 @@ fz_error
 fz_error_note_impx(fz_error cause, char *fmt, ...)
 {
 	va_list ap;
-	char buf[LINE_LEN];
+	char buf[256];
 
 	va_start(ap, fmt);
 	vsnprintf(buf, sizeof buf, fmt, ap);
@@ -201,7 +179,7 @@ void
 fz_error_handle_impx(fz_error cause, char *fmt, ...)
 {
 	va_list ap;
-	char buf[LINE_LEN];
+	char buf[256];
 
 	va_start(ap, fmt);
 	vsnprintf(buf, sizeof buf, fmt, ap);
diff --git a/fitz/base_hash.c b/fitz/base_hash.c
index 43bdf2d1..d6ff8ca0 100644
--- a/fitz/base_hash.c
+++ b/fitz/base_hash.c
@@ -19,6 +19,7 @@ struct fz_hash_entry_s
 
 struct fz_hash_table_s
 {
+	fz_context *ctx;
 	int keylen;
 	int size;
 	int load;
@@ -49,10 +50,12 @@ fz_new_hash_table(fz_context *ctx, int initialsize, int keylen)
 	assert(keylen <= MAX_KEY_LEN);
 
 	table = fz_malloc(ctx, sizeof(fz_hash_table));
+	table->ctx = ctx;
 	table->keylen = keylen;
 	table->size = initialsize;
 	table->load = 0;
 	table->ents = fz_malloc_array(ctx, table->size, sizeof(fz_hash_entry));
+	memset(table->ents, 0, sizeof(fz_hash_entry) * table->size);
 
 	return table;
 }
@@ -83,14 +86,14 @@ fz_hash_get_val(fz_hash_table *table, int idx)
 }
 
 void
-fz_free_hash(fz_context *ctx, fz_hash_table *table)
+fz_free_hash(fz_hash_table *table)
 {
-	fz_free(ctx, table->ents);
-	fz_free(ctx, table);
+	fz_free(table->ctx, table->ents);
+	fz_free(table->ctx, table);
 }
 
 static void
-fz_resize_hash(fz_context *ctx, fz_hash_table *table, int newsize)
+fz_resize_hash(fz_hash_table *table, int newsize)
 {
 	fz_hash_entry *oldents = table->ents;
 	int oldsize = table->size;
@@ -99,11 +102,11 @@ fz_resize_hash(fz_context *ctx, fz_hash_table *table, int newsize)
 
 	if (newsize < oldload * 8 / 10)
 	{
-		fz_error_make("assert: resize hash too small");
+		fz_warn(table->ctx, "assert: resize hash too small");
 		return;
 	}
 
-	table->ents = fz_malloc_array(ctx, newsize, sizeof(fz_hash_entry));
+	table->ents = fz_malloc_array(table->ctx, newsize, sizeof(fz_hash_entry));
 	memset(table->ents, 0, sizeof(fz_hash_entry) * newsize);
 	table->size = newsize;
 	table->load = 0;
@@ -112,11 +115,11 @@ fz_resize_hash(fz_context *ctx, fz_hash_table *table, int newsize)
 	{
 		if (oldents[i].val)
 		{
-			fz_hash_insert(ctx, table, oldents[i].key, oldents[i].val);
+			fz_hash_insert(table, oldents[i].key, oldents[i].val);
 		}
 	}
 
-	fz_free(ctx, oldents);
+	fz_free(table->ctx, oldents);
 }
 
 void *
@@ -139,7 +142,7 @@ fz_hash_find(fz_hash_table *table, void *key)
 }
 
 void
-fz_hash_insert(fz_context *ctx, fz_hash_table *table, void *key, void *val)
+fz_hash_insert(fz_hash_table *table, void *key, void *val)
 {
 	fz_hash_entry *ents;
 	unsigned size;
@@ -147,7 +150,7 @@ fz_hash_insert(fz_context *ctx, fz_hash_table *table, void *key, void *val)
 
 	if (table->load > table->size * 8 / 10)
 	{
-		fz_resize_hash(ctx, table, table->size * 2);
+		fz_resize_hash(table, table->size * 2);
 	}
 
 	ents = table->ents;
@@ -165,7 +168,7 @@ fz_hash_insert(fz_context *ctx, fz_hash_table *table, void *key, void *val)
 		}
 
 		if (memcmp(key, ents[pos].key, table->keylen) == 0)
-			fz_warn("assert: overwrite hash slot");
+			fz_warn(table->ctx, "assert: overwrite hash slot");
 
 		pos = (pos + 1) % size;
 	}
@@ -183,7 +186,7 @@ fz_hash_remove(fz_hash_table *table, void *key)
 	{
 		if (!ents[pos].val)
 		{
-			fz_warn("assert: remove inexistant hash entry");
+			fz_warn(table->ctx, "assert: remove inexistant hash entry");
 			return;
 		}
 
diff --git a/fitz/base_object.c b/fitz/base_object.c
index fd8339a4..fae4b1b4 100644
--- a/fitz/base_object.c
+++ b/fitz/base_object.c
@@ -404,7 +404,7 @@ fz_copy_array(fz_context *ctx, fz_obj *obj)
 	int n;
 
 	if (fz_is_indirect(obj) || !fz_is_array(obj))
-		fz_warn("assert: not an array (%s)", fz_objkindstr(obj));
+		fz_warn(obj->ctx, "assert: not an array (%s)", fz_objkindstr(obj));
 
 	new = fz_new_array(ctx, fz_array_len(obj));
 	n = fz_array_len(obj);
@@ -443,11 +443,11 @@ fz_array_put(fz_obj *obj, int i, fz_obj *item)
 	obj = fz_resolve_indirect(obj);
 
 	if (!fz_is_array(obj))
-		fz_warn("assert: not an array (%s)", fz_objkindstr(obj));
+		fz_warn(obj->ctx, "assert: not an array (%s)", fz_objkindstr(obj));
 	else if (i < 0)
-		fz_warn("assert: index %d < 0", i);
+		fz_warn(obj->ctx, "assert: index %d < 0", i);
 	else if (i >= obj->u.a.len)
-		fz_warn("assert: index %d > length %d", i, obj->u.a.len);
+		fz_warn(obj->ctx, "assert: index %d > length %d", i, obj->u.a.len);
 	else
 	{
 		if (obj->u.a.items[i])
@@ -462,7 +462,7 @@ fz_array_push(fz_obj *obj, fz_obj *item)
 	obj = fz_resolve_indirect(obj);
 
 	if (!fz_is_array(obj))
-		fz_warn("assert: not an array (%s)", fz_objkindstr(obj));
+		fz_warn(obj->ctx, "assert: not an array (%s)", fz_objkindstr(obj));
 	else
 	{
 		if (obj->u.a.len + 1 > obj->u.a.cap)
@@ -484,7 +484,7 @@ fz_array_insert(fz_obj *obj, fz_obj *item)
 	obj = fz_resolve_indirect(obj);
 
 	if (!fz_is_array(obj))
-		fz_warn("assert: not an array (%s)", fz_objkindstr(obj));
+		fz_warn(obj->ctx, "assert: not an array (%s)", fz_objkindstr(obj));
 	else
 	{
 		if (obj->u.a.len + 1 > obj->u.a.cap)
@@ -542,7 +542,7 @@ fz_copy_dict(fz_context *ctx, fz_obj *obj)
 	int i, n;
 
 	if (fz_is_indirect(obj) || !fz_is_dict(obj))
-		fz_error_make("assert: not a dict (%s)", fz_objkindstr(obj));
+		fz_warn(ctx, "assert: not a dict (%s)", fz_objkindstr(obj));
 
 	n = fz_dict_len(obj);
 	new = fz_new_dict(ctx, n);
@@ -665,7 +665,7 @@ fz_dict_put(fz_obj *obj, fz_obj *key, fz_obj *val)
 
 	if (!fz_is_dict(obj))
 	{
-		fz_warn("assert: not a dict (%s)", fz_objkindstr(obj));
+		fz_warn(obj->ctx, "assert: not a dict (%s)", fz_objkindstr(obj));
 		return;
 	}
 
@@ -673,13 +673,13 @@ fz_dict_put(fz_obj *obj, fz_obj *key, fz_obj *val)
 		s = fz_to_name(key);
 	else
 	{
-		fz_warn("assert: key is not a name (%s)", fz_objkindstr(obj));
+		fz_warn(obj->ctx, "assert: key is not a name (%s)", fz_objkindstr(obj));
 		return;
 	}
 
 	if (!val)
 	{
-		fz_warn("assert: val does not exist for key (%s)", s);
+		fz_warn(obj->ctx, "assert: val does not exist for key (%s)", s);
 		return;
 	}
 
@@ -726,7 +726,7 @@ fz_dict_dels(fz_obj *obj, char *key)
 	obj = fz_resolve_indirect(obj);
 
 	if (!fz_is_dict(obj))
-		fz_warn("assert: not a dict (%s)", fz_objkindstr(obj));
+		fz_warn(obj->ctx, "assert: not a dict (%s)", fz_objkindstr(obj));
 	else
 	{
 		int i = fz_dict_finds(obj, key);
@@ -747,7 +747,7 @@ fz_dict_del(fz_obj *obj, fz_obj *key)
 	if (fz_is_name(key))
 		fz_dict_dels(obj, fz_to_name(key));
 	else
-		fz_warn("assert: key is not a name (%s)", fz_objkindstr(obj));
+		fz_warn(obj->ctx, "assert: key is not a name (%s)", fz_objkindstr(obj));
 }
 
 void
diff --git a/fitz/dev_text.c b/fitz/dev_text.c
index bbc8efcb..2e63aa9d 100644
--- a/fitz/dev_text.c
+++ b/fitz/dev_text.c
@@ -239,7 +239,7 @@ fz_text_extract_span(fz_context *ctx, fz_text_span **last, fz_text *text, fz_mat
 	{
 		err = FT_Set_Char_Size(font->ft_face, 64, 64, 72, 72);
 		if (err)
-			fz_warn("freetype set character size: %s", ft_error_string(err));
+			fz_warn(ctx, "freetype set character size: %s", ft_error_string(err));
 		ascender = (float)face->ascender / face->units_per_EM;
 		descender = (float)face->descender / face->units_per_EM;
 	}
diff --git a/fitz/filt_basic.c b/fitz/filt_basic.c
index 32fce6f2..0842ec36 100644
--- a/fitz/filt_basic.c
+++ b/fitz/filt_basic.c
@@ -227,7 +227,7 @@ read_a85d(fz_stream *stm, unsigned char *buf, int len)
 		{
 			c = fz_read_byte(state->chain);
 			if (c != '>')
-				fz_warn("bad eod marker in a85d");
+				fz_warn(stm->ctx, "bad eod marker in a85d");
 
 			switch (count) {
 			case 0:
diff --git a/fitz/filt_dctd.c b/fitz/filt_dctd.c
index 7efbac91..fb0e77e7 100644
--- a/fitz/filt_dctd.c
+++ b/fitz/filt_dctd.c
@@ -52,7 +52,7 @@ static boolean fill_input_buffer(j_decompress_ptr cinfo)
 	if (src->bytes_in_buffer == 0)
 	{
 		static unsigned char eoi[2] = { 0xFF, JPEG_EOI };
-		fz_warn("premature end of file in jpeg");
+		fz_warn(state->ctx, "premature end of file in jpeg");
 		src->next_input_byte = eoi;
 		src->bytes_in_buffer = 2;
 	}
@@ -187,7 +187,7 @@ close_dctd(fz_stream *stm)
 	if (setjmp(state->jb))
 	{
 		state->chain->rp = state->chain->wp - state->cinfo.src->bytes_in_buffer;
-		fz_warn("jpeg error: %s", state->msg);
+		fz_warn(state->ctx, "jpeg error: %s", state->msg);
 		goto skip;
 	}
 
diff --git a/fitz/filt_flate.c b/fitz/filt_flate.c
index d9ac44e6..11100c94 100644
--- a/fitz/filt_flate.c
+++ b/fitz/filt_flate.c
@@ -49,12 +49,12 @@ read_flated(fz_stream *stm, unsigned char *outbuf, int outlen)
 		}
 		else if (code == Z_BUF_ERROR)
 		{
-			fz_warn("premature end of data in flate filter");
+			fz_warn(stm->ctx, "premature end of data in flate filter");
 			return outlen - zp->avail_out;
 		}
 		else if (code == Z_DATA_ERROR && zp->avail_in == 0)
 		{
-			fz_warn("ignoring zlib error: %s", zp->msg);
+			fz_warn(stm->ctx, "ignoring zlib error: %s", zp->msg);
 			return outlen - zp->avail_out;
 		}
 		else if (code != Z_OK)
@@ -74,7 +74,7 @@ close_flated(fz_stream *stm)
 
 	code = inflateEnd(&state->z);
 	if (code != Z_OK)
-		fz_warn("zlib error: inflateEnd: %s", state->z.msg);
+		fz_warn(stm->ctx, "zlib error: inflateEnd: %s", state->z.msg);
 
 	fz_close(state->chain);
 	fz_free(stm->ctx, state);
@@ -97,7 +97,7 @@ fz_open_flated(fz_stream *chain)
 
 	code = inflateInit(&state->z);
 	if (code != Z_OK)
-		fz_warn("zlib error: inflateInit: %s", state->z.msg);
+		fz_warn(chain->ctx, "zlib error: inflateInit: %s", state->z.msg);
 
 	return fz_new_stream(chain->ctx, state, read_flated, close_flated);
 }
diff --git a/fitz/filt_jpxd.c b/fitz/filt_jpxd.c
index 07d6a572..d0d6cdef 100644
--- a/fitz/filt_jpxd.c
+++ b/fitz/filt_jpxd.c
@@ -93,7 +93,7 @@ fz_load_jpx_image(fz_context *ctx, fz_pixmap **imgp, unsigned char *data, int si
 		}
 		else
 		{
-			fz_warn("jpx file and dict colorspaces do not match");
+			fz_warn(ctx, "jpx file and dict colorspaces do not match");
 			defcs = NULL;
 		}
 	}
diff --git a/fitz/filt_lzwd.c b/fitz/filt_lzwd.c
index 17d41d94..76cad305 100644
--- a/fitz/filt_lzwd.c
+++ b/fitz/filt_lzwd.c
@@ -104,7 +104,7 @@ read_lzwd(fz_stream *stm, unsigned char *buf, int len)
 			else if (code == next_code)
 				table[next_code].value = table[next_code].first_char;
 			else
-				fz_warn("out of range code encountered in lzw decode");
+				fz_warn(stm->ctx, "out of range code encountered in lzw decode");
 
 			next_code ++;
 
diff --git a/fitz/filt_predict.c b/fitz/filt_predict.c
index 266cc033..ed0d6d98 100644
--- a/fitz/filt_predict.c
+++ b/fitz/filt_predict.c
@@ -213,7 +213,7 @@ fz_open_predict(fz_stream *chain, fz_obj *params)
 		state->predictor != 12 && state->predictor != 13 &&
 		state->predictor != 14 && state->predictor != 15)
 	{
-		fz_warn("invalid predictor: %d", state->predictor);
+		fz_warn(ctx, "invalid predictor: %d", state->predictor);
 		state->predictor = 1;
 	}
 
diff --git a/fitz/fitz.h b/fitz/fitz.h
index a15304b7..048e1c35 100644
--- a/fitz/fitz.h
+++ b/fitz/fitz.h
@@ -121,9 +121,6 @@ typedef int fz_error;
 
 #define fz_okay ((fz_error)0)
 
-void fz_warn(char *fmt, ...) __printflike(1, 2);
-void fz_flush_warnings(void);
-
 fz_error fz_error_make_imp(const char *file, int line, const char *func, char *fmt, ...) __printflike(4, 5);
 fz_error fz_error_note_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...) __printflike(5, 6);
 void fz_error_handle_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...) __printflike(5, 6);
@@ -136,12 +133,20 @@ void fz_error_handle_impx(fz_error cause, char *fmt, ...) __printflike(2, 3);
 int fz_get_error_count(void);
 char *fz_get_error_line(int n);
 
-/* Context types */
+/* Contexts */
 
+typedef struct fz_alloc_context_s fz_alloc_context;
 typedef struct fz_error_context_s fz_error_context;
+typedef struct fz_warn_context_s fz_warn_context;
 typedef struct fz_context_s fz_context;
 
-/* Exception context */
+struct fz_alloc_context_s
+{
+	void *user;
+	void *(*malloc)(void *, unsigned int);
+	void *(*realloc)(void *, void *, unsigned int);
+	void *(*free)(void *, void *, unsigned int);
+};
 
 struct fz_error_context_s
 {
@@ -166,14 +171,22 @@ struct fz_error_context_s
 	if (ctx->error->stack[ctx->error->top--].failed)
 
 void fz_push_try(fz_error_context *ex);
-void fz_throw(fz_context *, char *, ...);
+void fz_throw(fz_context *, char *, ...) __printflike(2, 3);
 void fz_rethrow(fz_context *);
 
-/* Fitz per-thread context */
+struct fz_warn_context_s
+{
+	char message[256];
+	int count;
+};
+
+void fz_warn(fz_context *ctx, char *fmt, ...) __printflike(2, 3);
+void fz_flush_warnings(fz_context *ctx);
 
 struct fz_context_s
 {
 	fz_error_context *error;
+	fz_warn_context *warn;
 };
 
 fz_context *fz_new_context(void);
@@ -224,10 +237,10 @@ typedef struct fz_hash_table_s fz_hash_table;
 fz_hash_table *fz_new_hash_table(fz_context *ctx, int initialsize, int keylen);
 void fz_debug_hash(fz_hash_table *table);
 void fz_empty_hash(fz_hash_table *table);
-void fz_free_hash(fz_context *ctx, fz_hash_table *table);
+void fz_free_hash(fz_hash_table *table);
 
 void *fz_hash_find(fz_hash_table *table, void *key);
-void fz_hash_insert(fz_context *ctx, fz_hash_table *table, void *key, void *val);
+void fz_hash_insert(fz_hash_table *table, void *key, void *val);
 void fz_hash_remove(fz_hash_table *table, void *key);
 
 int fz_hash_len(fz_hash_table *table);
@@ -746,8 +759,8 @@ struct fz_colorspace_s
 	int refs;
 	char name[16];
 	int n;
-	void (*to_rgb)(fz_colorspace *, float *src, float *rgb);
-	void (*from_rgb)(fz_colorspace *, float *rgb, float *dst);
+	void (*to_rgb)(fz_context *ctx, fz_colorspace *, float *src, float *rgb);
+	void (*from_rgb)(fz_context *ctx, fz_colorspace *, float *rgb, float *dst);
 	void (*free_data)(fz_context *Ctx, fz_colorspace *);
 	void *data;
 };
@@ -756,7 +769,7 @@ fz_colorspace *fz_new_colorspace(fz_context *ctx, char *name, int n);
 fz_colorspace *fz_keep_colorspace(fz_colorspace *colorspace);
 void fz_drop_colorspace(fz_context *ctx, fz_colorspace *colorspace);
 
-void fz_convert_color(fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *dstv);
+void fz_convert_color(fz_context *ctx, fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *dstv);
 void fz_convert_pixmap(fz_context *ctx, fz_pixmap *src, fz_pixmap *dst);
 
 fz_colorspace *fz_find_device_colorspace(char *name);
diff --git a/fitz/res_colorspace.c b/fitz/res_colorspace.c
index 3f5cd47e..85556b62 100644
--- a/fitz/res_colorspace.c
+++ b/fitz/res_colorspace.c
@@ -40,14 +40,14 @@ fz_drop_colorspace(fz_context *ctx, fz_colorspace *cs)
 
 /* Device colorspace definitions */
 
-static void gray_to_rgb(fz_colorspace *cs, float *gray, float *rgb)
+static void gray_to_rgb(fz_context *ctx, fz_colorspace *cs, float *gray, float *rgb)
 {
 	rgb[0] = gray[0];
 	rgb[1] = gray[0];
 	rgb[2] = gray[0];
 }
 
-static void rgb_to_gray(fz_colorspace *cs, float *rgb, float *gray)
+static void rgb_to_gray(fz_context *ctx, fz_colorspace *cs, float *rgb, float *gray)
 {
 	float r = rgb[0];
 	float g = rgb[1];
@@ -55,28 +55,28 @@ static void rgb_to_gray(fz_colorspace *cs, float *rgb, float *gray)
 	gray[0] = r * 0.3f + g * 0.59f + b * 0.11f;
 }
 
-static void rgb_to_rgb(fz_colorspace *cs, float *rgb, float *xyz)
+static void rgb_to_rgb(fz_context *ctx, fz_colorspace *cs, float *rgb, float *xyz)
 {
 	xyz[0] = rgb[0];
 	xyz[1] = rgb[1];
 	xyz[2] = rgb[2];
 }
 
-static void bgr_to_rgb(fz_colorspace *cs, float *bgr, float *rgb)
+static void bgr_to_rgb(fz_context *ctx, fz_colorspace *cs, float *bgr, float *rgb)
 {
 	rgb[0] = bgr[2];
 	rgb[1] = bgr[1];
 	rgb[2] = bgr[0];
 }
 
-static void rgb_to_bgr(fz_colorspace *cs, float *rgb, float *bgr)
+static void rgb_to_bgr(fz_context *ctx, fz_colorspace *cs, float *rgb, float *bgr)
 {
 	bgr[0] = rgb[2];
 	bgr[1] = rgb[1];
 	bgr[2] = rgb[0];
 }
 
-static void cmyk_to_rgb(fz_colorspace *cs, float *cmyk, float *rgb)
+static void cmyk_to_rgb(fz_context *ctx, fz_colorspace *cs, float *cmyk, float *rgb)
 {
 #ifdef SLOWCMYK /* from poppler */
 	float c = cmyk[0], m = cmyk[1], y = cmyk[2], k = cmyk[3];
@@ -139,7 +139,7 @@ static void cmyk_to_rgb(fz_colorspace *cs, float *cmyk, float *rgb)
 #endif
 }
 
-static void rgb_to_cmyk(fz_colorspace *cs, float *rgb, float *cmyk)
+static void rgb_to_cmyk(fz_context *ctx, fz_colorspace *cs, float *rgb, float *cmyk)
 {
 	float c, m, y, k;
 	c = 1 - rgb[0];
@@ -173,7 +173,7 @@ fz_find_device_colorspace(char *name)
 		return fz_device_bgr;
 	if (!strcmp(name, "DeviceCMYK"))
 		return fz_device_cmyk;
-	fz_warn("unknown device colorspace: %s", name);
+	assert(!"unknown device colorspace");
 	return NULL;
 }
 
@@ -299,7 +299,7 @@ static void fast_cmyk_to_gray(fz_pixmap *src, fz_pixmap *dst)
 	}
 }
 
-static void fast_cmyk_to_rgb(fz_pixmap *src, fz_pixmap *dst)
+static void fast_cmyk_to_rgb(fz_context *ctx, fz_pixmap *src, fz_pixmap *dst)
 {
 	unsigned char *s = src->samples;
 	unsigned char *d = dst->samples;
@@ -312,7 +312,7 @@ static void fast_cmyk_to_rgb(fz_pixmap *src, fz_pixmap *dst)
 		cmyk[1] = s[1] / 255.0f;
 		cmyk[2] = s[2] / 255.0f;
 		cmyk[3] = s[3] / 255.0f;
-		cmyk_to_rgb(NULL, cmyk, rgb);
+		cmyk_to_rgb(ctx, NULL, cmyk, rgb);
 		d[0] = rgb[0] * 255;
 		d[1] = rgb[1] * 255;
 		d[2] = rgb[2] * 255;
@@ -327,7 +327,7 @@ static void fast_cmyk_to_rgb(fz_pixmap *src, fz_pixmap *dst)
 	}
 }
 
-static void fast_cmyk_to_bgr(fz_pixmap *src, fz_pixmap *dst)
+static void fast_cmyk_to_bgr(fz_context *ctx, fz_pixmap *src, fz_pixmap *dst)
 {
 	unsigned char *s = src->samples;
 	unsigned char *d = dst->samples;
@@ -340,7 +340,7 @@ static void fast_cmyk_to_bgr(fz_pixmap *src, fz_pixmap *dst)
 		cmyk[1] = s[1] / 255.0f;
 		cmyk[2] = s[2] / 255.0f;
 		cmyk[3] = s[3] / 255.0f;
-		cmyk_to_rgb(NULL, cmyk, rgb);
+		cmyk_to_rgb(ctx, NULL, cmyk, rgb);
 		d[0] = rgb[2] * 255;
 		d[1] = rgb[1] * 255;
 		d[2] = rgb[0] * 255;
@@ -403,7 +403,7 @@ fz_std_conv_pixmap(fz_context *ctx, fz_pixmap *src, fz_pixmap *dst)
 				srcv[1] = *s++ - 128;
 				srcv[2] = *s++ - 128;
 
-				fz_convert_color(ss, srcv, ds, dstv);
+				fz_convert_color(ctx, ss, srcv, ds, dstv);
 
 				for (k = 0; k < dstn; k++)
 					*d++ = dstv[k] * 255;
@@ -423,7 +423,7 @@ fz_std_conv_pixmap(fz_context *ctx, fz_pixmap *src, fz_pixmap *dst)
 				for (k = 0; k < srcn; k++)
 					srcv[k] = *s++ / 255.0f;
 
-				fz_convert_color(ss, srcv, ds, dstv);
+				fz_convert_color(ctx, ss, srcv, ds, dstv);
 
 				for (k = 0; k < dstn; k++)
 					*d++ = dstv[k] * 255;
@@ -441,7 +441,7 @@ fz_std_conv_pixmap(fz_context *ctx, fz_pixmap *src, fz_pixmap *dst)
 		for (i = 0; i < 256; i++)
 		{
 			srcv[0] = i / 255.0f;
-			fz_convert_color(ss, srcv, ds, dstv);
+			fz_convert_color(ctx, ss, srcv, ds, dstv);
 			for (k = 0; k < dstn; k++)
 				lookup[i * dstn + k] = dstv[k] * 255;
 		}
@@ -482,18 +482,18 @@ fz_std_conv_pixmap(fz_context *ctx, fz_pixmap *src, fz_pixmap *dst)
 				{
 					for (k = 0; k < srcn; k++)
 						srcv[k] = *s++ / 255.0f;
-					fz_convert_color(ss, srcv, ds, dstv);
+					fz_convert_color(ctx, ss, srcv, ds, dstv);
 					for (k = 0; k < dstn; k++)
 						*d++ = dstv[k] * 255;
 
-					fz_hash_insert(ctx, lookup, s - srcn, d - dstn);
+					fz_hash_insert(lookup, s - srcn, d - dstn);
 
 					*d++ = *s++;
 				}
 			}
 		}
 
-		fz_free_hash(ctx, lookup);
+		fz_free_hash(lookup);
 	}
 }
 
@@ -536,8 +536,8 @@ fz_convert_pixmap(fz_context *ctx, fz_pixmap *sp, fz_pixmap *dp)
 	else if (ss == fz_device_cmyk)
 	{
 		if (ds == fz_device_gray) fast_cmyk_to_gray(sp, dp);
-		else if (ds == fz_device_bgr) fast_cmyk_to_bgr(sp, dp);
-		else if (ds == fz_device_rgb) fast_cmyk_to_rgb(sp, dp);
+		else if (ds == fz_device_bgr) fast_cmyk_to_bgr(ctx, sp, dp);
+		else if (ds == fz_device_rgb) fast_cmyk_to_rgb(ctx, sp, dp);
 		else fz_std_conv_pixmap(ctx, sp, dp);
 	}
 
@@ -547,7 +547,7 @@ fz_convert_pixmap(fz_context *ctx, fz_pixmap *sp, fz_pixmap *dp)
 /* Convert a single color */
 
 static void
-fz_std_conv_color(fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *dstv)
+fz_std_conv_color(fz_context *ctx, fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *dstv)
 {
 	float rgb[3];
 	int i;
@@ -555,8 +555,8 @@ fz_std_conv_color(fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *
 	if (srcs != dsts)
 	{
 		assert(srcs->to_rgb && dsts->from_rgb);
-		srcs->to_rgb(srcs, srcv, rgb);
-		dsts->from_rgb(dsts, rgb, dstv);
+		srcs->to_rgb(ctx, srcs, srcv, rgb);
+		dsts->from_rgb(ctx, dsts, rgb, dstv);
 		for (i = 0; i < dsts->n; i++)
 			dstv[i] = CLAMP(dstv[i], 0, 1);
 	}
@@ -568,7 +568,7 @@ fz_std_conv_color(fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *
 }
 
 void
-fz_convert_color(fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
+fz_convert_color(fz_context *ctx, fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
 {
 	if (ss == fz_device_gray)
 	{
@@ -586,7 +586,7 @@ fz_convert_color(fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
 			dv[3] = sv[0];
 		}
 		else
-			fz_std_conv_color(ss, sv, ds, dv);
+			fz_std_conv_color(ctx, ss, sv, ds, dv);
 	}
 
 	else if (ss == fz_device_rgb)
@@ -613,7 +613,7 @@ fz_convert_color(fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
 			dv[3] = k;
 		}
 		else
-			fz_std_conv_color(ss, sv, ds, dv);
+			fz_std_conv_color(ctx, ss, sv, ds, dv);
 	}
 
 	else if (ss == fz_device_bgr)
@@ -640,7 +640,7 @@ fz_convert_color(fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
 			dv[3] = k;
 		}
 		else
-			fz_std_conv_color(ss, sv, ds, dv);
+			fz_std_conv_color(ctx, ss, sv, ds, dv);
 	}
 
 	else if (ss == fz_device_cmyk)
@@ -655,7 +655,7 @@ fz_convert_color(fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
 		else if (ds == fz_device_rgb)
 		{
 #ifdef SLOWCMYK
-			cmyk_to_rgb(NULL, sv, dv);
+			cmyk_to_rgb(ctx, NULL, sv, dv);
 #else
 			dv[0] = 1 - MIN(sv[0] + sv[3], 1);
 			dv[1] = 1 - MIN(sv[1] + sv[3], 1);
@@ -666,7 +666,7 @@ fz_convert_color(fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
 		{
 #ifdef SLOWCMYK
 			float rgb[3];
-			cmyk_to_rgb(NULL, sv, rgb);
+			cmyk_to_rgb(ctx, NULL, sv, rgb);
 			dv[0] = rgb[2];
 			dv[1] = rgb[1];
 			dv[2] = rgb[0];
@@ -677,9 +677,9 @@ fz_convert_color(fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
 #endif
 		}
 		else
-			fz_std_conv_color(ss, sv, ds, dv);
+			fz_std_conv_color(ctx, ss, sv, ds, dv);
 	}
 
 	else
-		fz_std_conv_color(ss, sv, ds, dv);
+		fz_std_conv_color(ctx, ss, sv, ds, dv);
 }
diff --git a/fitz/res_font.c b/fitz/res_font.c
index 0ef7bf20..47e22ff1 100644
--- a/fitz/res_font.c
+++ b/fitz/res_font.c
@@ -4,7 +4,7 @@
 #include FT_FREETYPE_H
 #include FT_STROKER_H
 
-static void fz_finalize_freetype(void);
+static void fz_finalize_freetype(fz_context *ctx);
 
 static fz_font *
 fz_new_font(fz_context *ctx, char *name)
@@ -77,8 +77,8 @@ fz_drop_font(fz_context *ctx, fz_font *font)
 		{
 			fterr = FT_Done_Face((FT_Face)font->ft_face);
 			if (fterr)
-				fz_warn("freetype finalizing face: %s", ft_error_string(fterr));
-			fz_finalize_freetype();
+				fz_warn(ctx, "freetype finalizing face: %s", ft_error_string(fterr));
+			fz_finalize_freetype(ctx);
 		}
 
 		if (font->ft_file)
@@ -137,7 +137,7 @@ char *ft_error_string(int err)
 }
 
 static fz_error
-fz_init_freetype(void)
+fz_init_freetype(fz_context *ctx)
 {
 	int fterr;
 	int maj, min, pat;
@@ -157,7 +157,7 @@ fz_init_freetype(void)
 	{
 		fterr = FT_Done_FreeType(fz_ftlib);
 		if (fterr)
-			fz_warn("freetype finalizing: %s", ft_error_string(fterr));
+			fz_warn(ctx, "freetype finalizing: %s", ft_error_string(fterr));
 		return fz_error_make("freetype version too old: %d.%d.%d", maj, min, pat);
 	}
 
@@ -166,7 +166,7 @@ fz_init_freetype(void)
 }
 
 static void
-fz_finalize_freetype(void)
+fz_finalize_freetype(fz_context *ctx)
 {
 	int fterr;
 
@@ -174,7 +174,7 @@ fz_finalize_freetype(void)
 	{
 		fterr = FT_Done_FreeType(fz_ftlib);
 		if (fterr)
-			fz_warn("freetype finalizing: %s", ft_error_string(fterr));
+			fz_warn(ctx, "freetype finalizing: %s", ft_error_string(fterr));
 		fz_ftlib = NULL;
 	}
 }
@@ -187,7 +187,7 @@ fz_new_font_from_file(fz_context *ctx, fz_font **fontp, char *path, int index)
 	fz_font *font;
 	int fterr;
 
-	error = fz_init_freetype();
+	error = fz_init_freetype(ctx);
 	if (error)
 		return fz_error_note(error, "cannot init freetype library");
 
@@ -214,7 +214,7 @@ fz_new_font_from_memory(fz_context *ctx, fz_font **fontp, unsigned char *data, i
 	fz_font *font;
 	int fterr;
 
-	error = fz_init_freetype();
+	error = fz_init_freetype(ctx);
 	if (error)
 		return fz_error_note(error, "cannot init freetype library");
 
@@ -234,7 +234,7 @@ fz_new_font_from_memory(fz_context *ctx, fz_font **fontp, unsigned char *data, i
 }
 
 static fz_matrix
-fz_adjust_ft_glyph_width(fz_font *font, int gid, fz_matrix trm)
+fz_adjust_ft_glyph_width(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
 {
 	/* Fudge the font matrix to stretch the glyph if we've substituted the font. */
 	if (font->ft_substitute && gid < font->width_count)
@@ -247,12 +247,12 @@ fz_adjust_ft_glyph_width(fz_font *font, int gid, fz_matrix trm)
 		/* TODO: use FT_Get_Advance */
 		fterr = FT_Set_Char_Size(font->ft_face, 1000, 1000, 72, 72);
 		if (fterr)
-			fz_warn("freetype setting character size: %s", ft_error_string(fterr));
+			fz_warn(ctx, "freetype setting character size: %s", ft_error_string(fterr));
 
 		fterr = FT_Load_Glyph(font->ft_face, gid,
 			FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP | FT_LOAD_IGNORE_TRANSFORM);
 		if (fterr)
-			fz_warn("freetype failed to load glyph: %s", ft_error_string(fterr));
+			fz_warn(ctx, "freetype failed to load glyph: %s", ft_error_string(fterr));
 
 		realw = ((FT_Face)font->ft_face)->glyph->metrics.horiAdvance;
 		subw = font->width_table[gid];
@@ -318,7 +318,7 @@ fz_render_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
 	FT_Vector v;
 	FT_Error fterr;
 
-	trm = fz_adjust_ft_glyph_width(font, gid, trm);
+	trm = fz_adjust_ft_glyph_width(ctx, font, gid, trm);
 
 	if (font->ft_italic)
 		trm = fz_concat(fz_shear(0.3f, 0), trm);
@@ -340,7 +340,7 @@ fz_render_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
 
 	fterr = FT_Set_Char_Size(face, 65536, 65536, 72, 72); /* should be 64, 64 */
 	if (fterr)
-		fz_warn("freetype setting character size: %s", ft_error_string(fterr));
+		fz_warn(ctx, "freetype setting character size: %s", ft_error_string(fterr));
 	FT_Set_Transform(face, &m, &v);
 
 	if (fz_get_aa_level() == 0)
@@ -356,11 +356,11 @@ fz_render_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
 
 		fterr = FT_Set_Char_Size(face, 64 * scale, 64 * scale, 72, 72);
 		if (fterr)
-			fz_warn("freetype setting character size: %s", ft_error_string(fterr));
+			fz_warn(ctx, "freetype setting character size: %s", ft_error_string(fterr));
 		FT_Set_Transform(face, &m, &v);
 		fterr = FT_Load_Glyph(face, gid, FT_LOAD_NO_BITMAP | FT_LOAD_TARGET_MONO);
 		if (fterr)
-			fz_warn("freetype load glyph (gid %d): %s", gid, ft_error_string(fterr));
+			fz_warn(ctx, "freetype load glyph (gid %d): %s", gid, ft_error_string(fterr));
 	}
 	else if (font->ft_hint)
 	{
@@ -373,14 +373,14 @@ fz_render_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
 		*/
 		fterr = FT_Load_Glyph(face, gid, FT_LOAD_NO_BITMAP);
 		if (fterr)
-			fz_warn("freetype load glyph (gid %d): %s", gid, ft_error_string(fterr));
+			fz_warn(ctx, "freetype load glyph (gid %d): %s", gid, ft_error_string(fterr));
 	}
 	else
 	{
 		fterr = FT_Load_Glyph(face, gid, FT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING);
 		if (fterr)
 		{
-			fz_warn("freetype load glyph (gid %d): %s", gid, ft_error_string(fterr));
+			fz_warn(ctx, "freetype load glyph (gid %d): %s", gid, ft_error_string(fterr));
 			return NULL;
 		}
 	}
@@ -395,7 +395,7 @@ fz_render_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm)
 	fterr = FT_Render_Glyph(face->glyph, fz_get_aa_level() > 0 ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO);
 	if (fterr)
 	{
-		fz_warn("freetype render glyph (gid %d): %s", gid, ft_error_string(fterr));
+		fz_warn(ctx, "freetype render glyph (gid %d): %s", gid, ft_error_string(fterr));
 		return NULL;
 	}
 
@@ -416,7 +416,7 @@ fz_render_ft_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix tr
 	FT_BitmapGlyph bitmap;
 	fz_pixmap *pixmap;
 
-	trm = fz_adjust_ft_glyph_width(font, gid, trm);
+	trm = fz_adjust_ft_glyph_width(ctx, font, gid, trm);
 
 	if (font->ft_italic)
 		trm = fz_concat(fz_shear(0.3f, 0), trm);
@@ -431,7 +431,7 @@ fz_render_ft_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix tr
 	fterr = FT_Set_Char_Size(face, 65536, 65536, 72, 72); /* should be 64, 64 */
 	if (fterr)
 	{
-		fz_warn("FT_Set_Char_Size: %s", ft_error_string(fterr));
+		fz_warn(ctx, "FT_Set_Char_Size: %s", ft_error_string(fterr));
 		return NULL;
 	}
 
@@ -440,14 +440,14 @@ fz_render_ft_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix tr
 	fterr = FT_Load_Glyph(face, gid, FT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING);
 	if (fterr)
 	{
-		fz_warn("FT_Load_Glyph(gid %d): %s", gid, ft_error_string(fterr));
+		fz_warn(ctx, "FT_Load_Glyph(gid %d): %s", gid, ft_error_string(fterr));
 		return NULL;
 	}
 
 	fterr = FT_Stroker_New(fz_ftlib, &stroker);
 	if (fterr)
 	{
-		fz_warn("FT_Stroker_New: %s", ft_error_string(fterr));
+		fz_warn(ctx, "FT_Stroker_New: %s", ft_error_string(fterr));
 		return NULL;
 	}
 
@@ -456,7 +456,7 @@ fz_render_ft_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix tr
 	fterr = FT_Get_Glyph(face->glyph, &glyph);
 	if (fterr)
 	{
-		fz_warn("FT_Get_Glyph: %s", ft_error_string(fterr));
+		fz_warn(ctx, "FT_Get_Glyph: %s", ft_error_string(fterr));
 		FT_Stroker_Done(stroker);
 		return NULL;
 	}
@@ -464,7 +464,7 @@ fz_render_ft_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix tr
 	fterr = FT_Glyph_Stroke(&glyph, stroker, 1);
 	if (fterr)
 	{
-		fz_warn("FT_Glyph_Stroke: %s", ft_error_string(fterr));
+		fz_warn(ctx, "FT_Glyph_Stroke: %s", ft_error_string(fterr));
 		FT_Done_Glyph(glyph);
 		FT_Stroker_Done(stroker);
 		return NULL;
@@ -475,7 +475,7 @@ fz_render_ft_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix tr
 	fterr = FT_Glyph_To_Bitmap(&glyph, fz_get_aa_level() > 0 ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO, 0, 1);
 	if (fterr)
 	{
-		fz_warn("FT_Glyph_To_Bitmap: %s", ft_error_string(fterr));
+		fz_warn(ctx, "FT_Glyph_To_Bitmap: %s", ft_error_string(fterr));
 		FT_Done_Glyph(glyph);
 		return NULL;
 	}
@@ -539,17 +539,17 @@ fz_render_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_co
 	if (dev->flags & FZ_CHARPROC_MASK)
 	{
 		if (dev->flags & FZ_CHARPROC_COLOR)
-			fz_warn("type3 glyph claims to be both masked and colored");
+			fz_warn(ctx, "type3 glyph claims to be both masked and colored");
 		model = NULL;
 	}
 	else if (dev->flags & FZ_CHARPROC_COLOR)
 	{
 		if (model == NULL)
-			fz_warn("colored type3 glyph wanted in masked context");
+			fz_warn(ctx, "colored type3 glyph wanted in masked context");
 	}
 	else
 	{
-		fz_warn("type3 glyph doesn't specify masked or colored");
+		fz_warn(ctx, "type3 glyph doesn't specify masked or colored");
 		model = NULL; /* Treat as masked */
 	}
 
diff --git a/fitz/res_path.c b/fitz/res_path.c
index af5d9f43..cea720e9 100644
--- a/fitz/res_path.c
+++ b/fitz/res_path.c
@@ -60,7 +60,7 @@ fz_lineto(fz_context *ctx, fz_path *path, float x, float y)
 {
 	if (path->len == 0)
 	{
-		fz_warn("lineto with no current point");
+		fz_warn(ctx, "lineto with no current point");
 		return;
 	}
 	grow_path(ctx, path, 3);
@@ -77,7 +77,7 @@ fz_curveto(fz_context *ctx, fz_path *path,
 {
 	if (path->len == 0)
 	{
-		fz_warn("curveto with no current point");
+		fz_warn(ctx, "curveto with no current point");
 		return;
 	}
 	grow_path(ctx, path, 7);
@@ -96,7 +96,7 @@ fz_curvetov(fz_context *ctx, fz_path *path, float x2, float y2, float x3, float
 	float x1, y1;
 	if (path->len == 0)
 	{
-		fz_warn("curvetov with no current point");
+		fz_warn(ctx, "curvetov with no current point");
 		return;
 	}
 	x1 = path->items[path->len-2].v;
@@ -115,7 +115,7 @@ fz_closepath(fz_context *ctx, fz_path *path)
 {
 	if (path->len == 0)
 	{
-		fz_warn("closepath with no current point");
+		fz_warn(ctx, "closepath with no current point");
 		return;
 	}
 	grow_path(ctx, path, 1);
diff --git a/fitz/res_pixmap.c b/fitz/res_pixmap.c
index 040ec386..a34933f5 100644
--- a/fitz/res_pixmap.c
+++ b/fitz/res_pixmap.c
@@ -49,7 +49,7 @@ fz_new_pixmap_with_limit(fz_context *ctx, fz_colorspace *colorspace, int w, int
 	int size = w * h * n;
 	if (fz_memory_used + size > fz_memory_limit)
 	{
-		fz_warn("pixmap memory exceeds soft limit %dM + %dM > %dM",
+		fz_warn(ctx, "pixmap memory exceeds soft limit %dM + %dM > %dM",
 			fz_memory_used/(1<<20), size/(1<<20), fz_memory_limit/(1<<20));
 		return NULL;
 	}
diff --git a/fitz/stm_open.c b/fitz/stm_open.c
index f06bdc50..18079f4b 100644
--- a/fitz/stm_open.c
+++ b/fitz/stm_open.c
@@ -64,7 +64,7 @@ static void seek_file(fz_stream *stm, int offset, int whence)
 {
 	int n = lseek(*(int*)stm->state, offset, whence);
 	if (n < 0)
-		fz_warn("cannot lseek: %s", strerror(errno));
+		fz_warn(stm->ctx, "cannot lseek: %s", strerror(errno));
 	stm->pos = n;
 	stm->rp = stm->bp;
 	stm->wp = stm->bp;
@@ -74,7 +74,7 @@ static void close_file(fz_stream *stm)
 {
 	int n = close(*(int*)stm->state);
 	if (n < 0)
-		fz_warn("close error: %s", strerror(errno));
+		fz_warn(stm->ctx, "close error: %s", strerror(errno));
 	fz_free(stm->ctx, stm->state);
 }
 
diff --git a/fitz/stm_read.c b/fitz/stm_read.c
index 062916c5..23f758eb 100644
--- a/fitz/stm_read.c
+++ b/fitz/stm_read.c
@@ -192,11 +192,11 @@ fz_seek(fz_stream *stm, int offset, int whence)
 		if (whence == 0)
 			offset -= fz_tell(stm);
 		if (offset < 0)
-			fz_warn("cannot seek backwards");
+			fz_warn(stm->ctx, "cannot seek backwards");
 		/* dog slow, but rare enough */
 		while (offset-- > 0)
 			fz_read_byte(stm);
 	}
 	else
-		fz_warn("cannot seek");
+		fz_warn(stm->ctx, "cannot seek");
 }
diff --git a/pdf/mupdf.h b/pdf/mupdf.h
index c2e651cc..779fb976 100644
--- a/pdf/mupdf.h
+++ b/pdf/mupdf.h
@@ -161,7 +161,7 @@ void pdf_age_store(fz_context *ctx, pdf_store *store, int maxage);
 typedef struct pdf_function_s pdf_function;
 
 fz_error pdf_load_function(pdf_function **func, pdf_xref *xref, fz_obj *ref);
-void pdf_eval_function(pdf_function *func, float *in, int inlen, float *out, int outlen);
+void pdf_eval_function(fz_context *ctx, pdf_function *func, float *in, int inlen, float *out, int outlen);
 pdf_function *pdf_keep_function(pdf_function *func);
 void pdf_drop_function(fz_context *ctx, pdf_function *func);
 
@@ -272,7 +272,7 @@ int pdf_get_wmode(pdf_cmap *cmap);
 void pdf_set_wmode(pdf_cmap *cmap, int wmode);
 void pdf_set_usecmap(fz_context *ctx, pdf_cmap *cmap, pdf_cmap *usecmap);
 
-void pdf_add_codespace(pdf_cmap *cmap, int low, int high, int n);
+void pdf_add_codespace(fz_context *ctx, pdf_cmap *cmap, int low, int high, int n);
 void pdf_map_range_to_table(fz_context *ctx, pdf_cmap *cmap, int low, int *map, int len);
 void pdf_map_range_to_range(fz_context *ctx, pdf_cmap *cmap, int srclo, int srchi, int dstlo);
 void pdf_map_one_to_many(fz_context *ctx, pdf_cmap *cmap, int one, int *many, int len);
diff --git a/pdf/pdf_cmap.c b/pdf/pdf_cmap.c
index 3de3346b..8ae40fc5 100644
--- a/pdf/pdf_cmap.c
+++ b/pdf/pdf_cmap.c
@@ -161,11 +161,11 @@ pdf_debug_cmap(pdf_cmap *cmap)
  * multi-byte encoded strings.
  */
 void
-pdf_add_codespace(pdf_cmap *cmap, int low, int high, int n)
+pdf_add_codespace(fz_context *ctx, pdf_cmap *cmap, int low, int high, int n)
 {
 	if (cmap->codespace_len + 1 == nelem(cmap->codespace))
 	{
-		fz_warn("assert: too many code space ranges");
+		fz_warn(ctx, "assert: too many code space ranges");
 		return;
 	}
 
@@ -183,7 +183,7 @@ add_table(fz_context *ctx, pdf_cmap *cmap, int value)
 {
 	if (cmap->tlen == USHRT_MAX)
 	{
-		fz_warn("cmap table is full; ignoring additional entries");
+		fz_warn(ctx, "cmap table is full; ignoring additional entries");
 		return;
 	}
 	if (cmap->tlen + 1 > cmap->tcap)
@@ -229,7 +229,7 @@ pdf_map_range_to_table(fz_context *ctx, pdf_cmap *cmap, int low, int *table, int
 	int high = low + len;
 	int offset = cmap->tlen;
 	if (cmap->tlen + len >= USHRT_MAX)
-		fz_warn("cannot map range to table; table is full");
+		fz_warn(ctx, "cannot map range to table; table is full");
 	else
 	{
 		for (i = 0; i < len; i++)
@@ -263,7 +263,7 @@ pdf_map_one_to_many(fz_context *ctx, pdf_cmap *cmap, int low, int *values, int l
 
 	if (len > 8)
 	{
-		fz_warn("one to many mapping is too large (%d); truncating", len);
+		fz_warn(ctx, "one to many mapping is too large (%d); truncating", len);
 		len = 8;
 	}
 
@@ -271,12 +271,12 @@ pdf_map_one_to_many(fz_context *ctx, pdf_cmap *cmap, int low, int *values, int l
 		values[0] >= 0xD800 && values[0] <= 0xDBFF &&
 		values[1] >= 0xDC00 && values[1] <= 0xDFFF)
 	{
-		fz_warn("ignoring surrogate pair mapping in cmap");
+		fz_warn(ctx, "ignoring surrogate pair mapping in cmap");
 		return;
 	}
 
 	if (cmap->tlen + len + 1 >= USHRT_MAX)
-		fz_warn("cannot map one to many; table is full");
+		fz_warn(ctx, "cannot map one to many; table is full");
 	else
 	{
 		offset = cmap->tlen;
@@ -311,7 +311,7 @@ pdf_sort_cmap(fz_context *ctx, pdf_cmap *cmap)
 
 	if (cmap->tlen == USHRT_MAX)
 	{
-		fz_warn("cmap table is full; will not combine ranges");
+		fz_warn(ctx, "cmap table is full; will not combine ranges");
 		return;
 	}
 
@@ -398,7 +398,7 @@ pdf_sort_cmap(fz_context *ctx, pdf_cmap *cmap)
 
 	cmap->rlen = a - cmap->ranges + 1;
 
-	fz_flush_warnings();
+	fz_flush_warnings(ctx);
 }
 
 /*
diff --git a/pdf/pdf_cmap_load.c b/pdf/pdf_cmap_load.c
index 4329ad19..c962c6ca 100644
--- a/pdf/pdf_cmap_load.c
+++ b/pdf/pdf_cmap_load.c
@@ -86,7 +86,7 @@ pdf_new_identity_cmap(fz_context *ctx, int wmode, int bytes)
 {
 	pdf_cmap *cmap = pdf_new_cmap(ctx);
 	sprintf(cmap->cmap_name, "Identity-%c", wmode ? 'V' : 'H');
-	pdf_add_codespace(cmap, 0x0000, 0xffff, bytes);
+	pdf_add_codespace(ctx, cmap, 0x0000, 0xffff, bytes);
 	pdf_map_range_to_range(ctx, cmap, 0x0000, 0xffff, 0);
 	pdf_sort_cmap(ctx, cmap);
 	pdf_set_wmode(cmap, wmode);
diff --git a/pdf/pdf_cmap_parse.c b/pdf/pdf_cmap_parse.c
index 1e71e176..d048271f 100644
--- a/pdf/pdf_cmap_parse.c
+++ b/pdf/pdf_cmap_parse.c
@@ -78,7 +78,7 @@ pdf_parse_cmap_name(pdf_cmap *cmap, fz_stream *file)
 	if (tok == PDF_TOK_NAME)
 		fz_strlcpy(cmap->cmap_name, buf, sizeof(cmap->cmap_name));
 	else
-		fz_warn("expected name after CMapName in cmap");
+		fz_warn(file->ctx, "expected name after CMapName in cmap");
 
 	return fz_okay;
 }
@@ -98,7 +98,7 @@ pdf_parse_wmode(pdf_cmap *cmap, fz_stream *file)
 	if (tok == PDF_TOK_INT)
 		pdf_set_wmode(cmap, atoi(buf));
 	else
-		fz_warn("expected integer after WMode in cmap");
+		fz_warn(file->ctx, "expected integer after WMode in cmap");
 
 	return fz_okay;
 }
@@ -130,7 +130,7 @@ pdf_parse_codespace_range(pdf_cmap *cmap, fz_stream *file)
 			if (tok == PDF_TOK_STRING)
 			{
 				hi = pdf_code_from_string(buf, len);
-				pdf_add_codespace(cmap, lo, hi, len);
+				pdf_add_codespace(file->ctx, cmap, lo, hi, len);
 			}
 			else break;
 		}
diff --git a/pdf/pdf_colorspace.c b/pdf/pdf_colorspace.c
index 1a2e79b3..4c4368cc 100644
--- a/pdf/pdf_colorspace.c
+++ b/pdf/pdf_colorspace.c
@@ -30,7 +30,7 @@ static inline float fung(float x)
 }
 
 static void
-lab_to_rgb(fz_colorspace *cs, float *lab, float *rgb)
+lab_to_rgb(fz_context *ctx, fz_colorspace *cs, float *lab, float *rgb)
 {
 	/* input is in range (0..100, -128..127, -128..127) not (0..1, 0..1, 0..1) */
 	float lstar, astar, bstar, l, m, n, x, y, z, r, g, b;
@@ -52,9 +52,9 @@ lab_to_rgb(fz_colorspace *cs, float *lab, float *rgb)
 }
 
 static void
-rgb_to_lab(fz_colorspace *cs, float *rgb, float *lab)
+rgb_to_lab(fz_context *ctx, fz_colorspace *cs, float *rgb, float *lab)
 {
-	fz_warn("cannot convert into L*a*b colorspace");
+	fz_warn(ctx, "cannot convert into L*a*b colorspace");
 	lab[0] = rgb[0];
 	lab[1] = rgb[1];
 	lab[2] = rgb[2];
@@ -72,12 +72,12 @@ struct separation
 };
 
 static void
-separation_to_rgb(fz_colorspace *cs, float *color, float *rgb)
+separation_to_rgb(fz_context *ctx, fz_colorspace *cs, float *color, float *rgb)
 {
 	struct separation *sep = cs->data;
 	float alt[FZ_MAX_COLORS];
-	pdf_eval_function(sep->tint, color, cs->n, alt, sep->base->n);
-	sep->base->to_rgb(sep->base, alt, rgb);
+	pdf_eval_function(ctx, sep->tint, color, cs->n, alt, sep->base->n);
+	sep->base->to_rgb(ctx, sep->base, alt, rgb);
 }
 
 static void
@@ -145,7 +145,7 @@ struct indexed
 };
 
 static void
-indexed_to_rgb(fz_colorspace *cs, float *color, float *rgb)
+indexed_to_rgb(fz_context *ctx, fz_colorspace *cs, float *color, float *rgb)
 {
 	struct indexed *idx = cs->data;
 	float alt[FZ_MAX_COLORS];
@@ -154,7 +154,7 @@ indexed_to_rgb(fz_colorspace *cs, float *color, float *rgb)
 	i = CLAMP(i, 0, idx->high);
 	for (k = 0; k < idx->base->n; k++)
 		alt[k] = idx->lookup[i * idx->base->n + k] / 255.0f;
-	idx->base->to_rgb(idx->base, alt, rgb);
+	idx->base->to_rgb(ctx, idx->base, alt, rgb);
 }
 
 static void
diff --git a/pdf/pdf_crypt.c b/pdf/pdf_crypt.c
index 7d5b7902..523fabc1 100644
--- a/pdf/pdf_crypt.c
+++ b/pdf/pdf_crypt.c
@@ -191,7 +191,7 @@ pdf_new_crypt(fz_context *ctx, pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 		memcpy(crypt->u, fz_to_str_buf(obj), 48);
 	else if (fz_is_string(obj) && fz_to_str_len(obj) < 32)
 	{
-		fz_warn("encryption password key too short (%d)", fz_to_str_len(obj));
+		fz_warn(ctx, "encryption password key too short (%d)", fz_to_str_len(obj));
 		memcpy(crypt->u, fz_to_str_buf(obj), fz_to_str_len(obj));
 	}
 	else
@@ -242,7 +242,7 @@ pdf_new_crypt(fz_context *ctx, pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 			crypt->id = fz_keep_obj(obj);
 	}
 	else
-		fz_warn("missing file identifier, may not be able to do decryption");
+		fz_warn(ctx, "missing file identifier, may not be able to do decryption");
 
 	*cryptp = crypt;
 	return fz_okay;
@@ -298,7 +298,7 @@ pdf_parse_crypt_filter(fz_context *ctx, pdf_crypt_filter *cf, fz_obj *cf_obj, ch
 		else if (!strcmp(fz_to_name(obj), "AESV3"))
 			cf->method = PDF_CRYPT_AESV3;
 		else
-			fz_error_make("unknown encryption method: %s", fz_to_name(obj));
+			fz_warn(ctx, "unknown encryption method: %s", fz_to_name(obj));
 	}
 
 	obj = fz_dict_gets(dict, "Length");
@@ -731,7 +731,7 @@ pdf_crypt_obj_imp(fz_context *ctx, pdf_crypt *crypt, fz_obj *obj, unsigned char
 		if (crypt->strf.method == PDF_CRYPT_AESV2 || crypt->strf.method == PDF_CRYPT_AESV3)
 		{
 			if (n & 15 || n < 32)
-				fz_warn("invalid string length for aes encryption");
+				fz_warn(ctx, "invalid string length for aes encryption");
 			else
 			{
 				unsigned char iv[16];
@@ -741,7 +741,7 @@ pdf_crypt_obj_imp(fz_context *ctx, pdf_crypt *crypt, fz_obj *obj, unsigned char
 				aes_crypt_cbc(&aes, AES_DECRYPT, n - 16, iv, s + 16, s);
 				/* delete space used for iv and padding bytes at end */
 				if (s[n - 17] < 1 || s[n - 17] > 16)
-					fz_warn("aes padding out of range");
+					fz_warn(ctx, "aes padding out of range");
 				else
 					fz_set_str_len(obj, n - 16 - s[n - 17]);
 			}
diff --git a/pdf/pdf_font.c b/pdf/pdf_font.c
index e1cae007..2bb69528 100644
--- a/pdf/pdf_font.c
+++ b/pdf/pdf_font.c
@@ -144,14 +144,14 @@ pdf_font_cid_to_gid(pdf_font_desc *fontdesc, int cid)
 	return cid;
 }
 
-static int ft_width(pdf_font_desc *fontdesc, int cid)
+static int ft_width(fz_context *ctx, pdf_font_desc *fontdesc, int cid)
 {
 	int gid = ft_cid_to_gid(fontdesc, cid);
 	int fterr = FT_Load_Glyph(fontdesc->font->ft_face, gid,
 			FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP | FT_LOAD_IGNORE_TRANSFORM);
 	if (fterr)
 	{
-		fz_warn("freetype load glyph (gid %d): %s", gid, ft_error_string(fterr));
+		fz_warn(ctx, "freetype load glyph (gid %d): %s", gid, ft_error_string(fterr));
 		return 0;
 	}
 	return ((FT_Face)fontdesc->font->ft_face)->glyph->advance.x;
@@ -448,7 +448,7 @@ pdf_load_simple_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict)
 				break;
 		if (cp936fonts[i])
 		{
-			fz_warn("workaround for S22PDF lying about chinese font encodings");
+			fz_warn(ctx, "workaround for S22PDF lying about chinese font encodings");
 			pdf_drop_font(ctx, fontdesc);
 			fontdesc = pdf_new_font_desc(ctx);
 			error = pdf_load_font_descriptor(fontdesc, xref, descriptor, "Adobe-GB1", cp936fonts[i+1]);
@@ -499,10 +499,10 @@ pdf_load_simple_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict)
 	{
 		fterr = FT_Set_Charmap(face, cmap);
 		if (fterr)
-			fz_warn("freetype could not set cmap: %s", ft_error_string(fterr));
+			fz_warn(ctx, "freetype could not set cmap: %s", ft_error_string(fterr));
 	}
 	else
-		fz_warn("freetype could not find any cmaps");
+		fz_warn(ctx, "freetype could not find any cmaps");
 
 	etable = fz_malloc_array(ctx, 256, sizeof(unsigned short));
 	for (i = 0; i < 256; i++)
@@ -633,7 +633,7 @@ pdf_load_simple_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict)
 			{
 				fterr = FT_Get_Glyph_Name(face, etable[i], ebuffer[i], 32);
 				if (fterr)
-					fz_warn("freetype get glyph name (gid %d): %s", etable[i], ft_error_string(fterr));
+					fz_warn(ctx, "freetype get glyph name (gid %d): %s", etable[i], ft_error_string(fterr));
 				if (ebuffer[i][0])
 					estrings[i] = ebuffer[i];
 			}
@@ -679,10 +679,10 @@ skip_encoding:
 	{
 		fterr = FT_Set_Char_Size(face, 1000, 1000, 72, 72);
 		if (fterr)
-			fz_warn("freetype set character size: %s", ft_error_string(fterr));
+			fz_warn(ctx, "freetype set character size: %s", ft_error_string(fterr));
 		for (i = 0; i < 256; i++)
 		{
-			pdf_add_hmtx(ctx, fontdesc, i, i, ft_width(fontdesc, i));
+			pdf_add_hmtx(ctx, fontdesc, i, i, ft_width(ctx, fontdesc, i));
 		}
 	}
 
@@ -1112,17 +1112,17 @@ pdf_load_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *rdb, fz_obj *di
 		error = pdf_load_type3_font(fontdescp, xref, rdb, dict);
 	else if (charprocs)
 	{
-		fz_warn("unknown font format, guessing type3.");
+		fz_warn(ctx, "unknown font format, guessing type3.");
 		error = pdf_load_type3_font(fontdescp, xref, rdb, dict);
 	}
 	else if (dfonts)
 	{
-		fz_warn("unknown font format, guessing type0.");
+		fz_warn(ctx, "unknown font format, guessing type0.");
 		error = pdf_load_type0_font(fontdescp, xref, dict);
 	}
 	else
 	{
-		fz_warn("unknown font format, guessing type1 or truetype.");
+		fz_warn(ctx, "unknown font format, guessing type1 or truetype.");
 		error = pdf_load_simple_font(fontdescp, xref, dict);
 	}
 	if (error)
diff --git a/pdf/pdf_function.c b/pdf/pdf_function.c
index 50b09926..9078c65a 100644
--- a/pdf/pdf_function.c
+++ b/pdf/pdf_function.c
@@ -295,7 +295,7 @@ ps_index(ps_stack *st, int n)
 }
 
 static void
-ps_run(psobj *code, ps_stack *st, int pc)
+ps_run(fz_context *ctx, psobj *code, ps_stack *st, int pc)
 {
 	int i1, i2;
 	float r1, r2;
@@ -642,16 +642,16 @@ ps_run(psobj *code, ps_stack *st, int pc)
 			case PS_OP_IF:
 				b1 = ps_pop_bool(st);
 				if (b1)
-					ps_run(code, st, code[pc + 1].u.block);
+					ps_run(ctx, code, st, code[pc + 1].u.block);
 				pc = code[pc + 2].u.block;
 				break;
 
 			case PS_OP_IFELSE:
 				b1 = ps_pop_bool(st);
 				if (b1)
-					ps_run(code, st, code[pc + 1].u.block);
+					ps_run(ctx, code, st, code[pc + 1].u.block);
 				else
-					ps_run(code, st, code[pc + 0].u.block);
+					ps_run(ctx, code, st, code[pc + 0].u.block);
 				pc = code[pc + 2].u.block;
 				break;
 
@@ -659,13 +659,13 @@ ps_run(psobj *code, ps_stack *st, int pc)
 				return;
 
 			default:
-				fz_warn("foreign operator in calculator function");
+				fz_warn(ctx, "foreign operator in calculator function");
 				return;
 			}
 			break;
 
 		default:
-			fz_warn("foreign object in calculator function");
+			fz_warn(ctx, "foreign object in calculator function");
 			return;
 		}
 	}
@@ -866,7 +866,7 @@ load_postscript_func(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num,
 }
 
 static void
-eval_postscript_func(pdf_function *func, float *in, float *out)
+eval_postscript_func(fz_context *ctx, pdf_function *func, float *in, float *out)
 {
 	ps_stack st;
 	float x;
@@ -880,7 +880,7 @@ eval_postscript_func(pdf_function *func, float *in, float *out)
 		ps_push_real(&st, x);
 	}
 
-	ps_run(func->u.p.code, &st, 0);
+	ps_run(ctx, func->u.p.code, &st, 0);
 
 	for (i = func->n - 1; i >= 0; i--)
 	{
@@ -896,13 +896,13 @@ eval_postscript_func(pdf_function *func, float *in, float *out)
 static fz_error
 load_sample_func(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int gen)
 {
+	fz_context *ctx = xref->ctx;
 	fz_error error;
 	fz_stream *stream;
 	fz_obj *obj;
 	int samplecount;
 	int bps;
 	int i;
-	fz_context *ctx = xref->ctx;
 
 	func->u.sa.samples = NULL;
 
@@ -1040,7 +1040,7 @@ interpolate_sample(pdf_function *func, int *scale, int *e0, int *e1, float *efra
 }
 
 static void
-eval_sample_func(pdf_function *func, float *in, float *out)
+eval_sample_func(fz_context *ctx, pdf_function *func, float *in, float *out)
 {
 	int e0[MAXM], e1[MAXM], scale[MAXM];
 	float efrac[MAXM];
@@ -1155,7 +1155,7 @@ load_exponential_func(fz_context *ctx, pdf_function *func, fz_obj *dict)
 }
 
 static void
-eval_exponential_func(pdf_function *func, float in, float *out)
+eval_exponential_func(fz_context *ctx, pdf_function *func, float in, float *out)
 {
 	float x = in;
 	float tmp;
@@ -1166,7 +1166,7 @@ eval_exponential_func(pdf_function *func, float in, float *out)
 	/* constraint */
 	if ((func->u.e.n != (int)func->u.e.n && x < 0) || (func->u.e.n < 0 && x == 0))
 	{
-		fz_warn("constraint error");
+		fz_warn(ctx, "constraint error");
 		return;
 	}
 
@@ -1186,6 +1186,7 @@ eval_exponential_func(pdf_function *func, float in, float *out)
 static fz_error
 load_stitching_func(pdf_function *func, pdf_xref *xref, fz_obj *dict)
 {
+	fz_context *ctx = xref->ctx;
 	pdf_function **funcs;
 	fz_error error;
 	fz_obj *obj;
@@ -1193,7 +1194,6 @@ load_stitching_func(pdf_function *func, pdf_xref *xref, fz_obj *dict)
 	fz_obj *num;
 	int k;
 	int i;
-	fz_context *ctx = xref->ctx;
 
 	func->u.st.k = 0;
 
@@ -1247,7 +1247,7 @@ load_stitching_func(pdf_function *func, pdf_xref *xref, fz_obj *dict)
 
 		if (k != 1 && (func->domain[0][0] > func->u.st.bounds[0] ||
 			func->domain[0][1] < func->u.st.bounds[k-2]))
-			fz_warn("malformed shading function bounds (domain mismatch), proceeding anyway.");
+			fz_warn(ctx, "malformed shading function bounds (domain mismatch), proceeding anyway.");
 	}
 
 	obj = fz_dict_gets(dict, "Encode");
@@ -1267,7 +1267,7 @@ load_stitching_func(pdf_function *func, pdf_xref *xref, fz_obj *dict)
 }
 
 static void
-eval_stitching_func(pdf_function *func, float in, float *out)
+eval_stitching_func(fz_context *ctx, pdf_function *func, float in, float *out)
 {
 	float low, high;
 	int k = func->u.st.k;
@@ -1305,7 +1305,7 @@ eval_stitching_func(pdf_function *func, float in, float *out)
 
 	in = lerp(in, low, high, func->u.st.encode[i*2+0], func->u.st.encode[i*2+1]);
 
-	pdf_eval_function(func->u.st.funcs[i], &in, 1, out, func->n);
+	pdf_eval_function(ctx, func->u.st.funcs[i], &in, 1, out, func->n);
 }
 
 /*
@@ -1350,11 +1350,11 @@ pdf_drop_function(fz_context *ctx, pdf_function *func)
 fz_error
 pdf_load_function(pdf_function **funcp, pdf_xref *xref, fz_obj *dict)
 {
+	fz_context *ctx = xref->ctx;
 	fz_error error;
 	pdf_function *func;
 	fz_obj *obj;
 	int i;
-	fz_context *ctx = xref->ctx;
 
 	if ((*funcp = pdf_find_item(ctx, xref->store, (pdf_store_drop_fn *)pdf_drop_function, dict)))
 	{
@@ -1452,27 +1452,27 @@ pdf_load_function(pdf_function **funcp, pdf_xref *xref, fz_obj *dict)
 }
 
 void
-pdf_eval_function(pdf_function *func, float *in, int inlen, float *out, int outlen)
+pdf_eval_function(fz_context *ctx, pdf_function *func, float *in, int inlen, float *out, int outlen)
 {
 	memset(out, 0, sizeof(float) * outlen);
 
 	if (inlen != func->m)
 	{
-		fz_warn("tried to evaluate function with wrong number of inputs");
+		fz_warn(ctx, "tried to evaluate function with wrong number of inputs");
 		return;
 	}
 	if (func->n != outlen)
 	{
-		fz_warn("tried to evaluate function with wrong number of outputs");
+		fz_warn(ctx, "tried to evaluate function with wrong number of outputs");
 		return;
 	}
 
 	switch(func->type)
 	{
-	case SAMPLE: eval_sample_func(func, in, out); break;
-	case EXPONENTIAL: eval_exponential_func(func, *in, out); break;
-	case STITCHING: eval_stitching_func(func, *in, out); break;
-	case POSTSCRIPT: eval_postscript_func(func, in, out); break;
+	case SAMPLE: eval_sample_func(ctx, func, in, out); break;
+	case EXPONENTIAL: eval_exponential_func(ctx, func, *in, out); break;
+	case STITCHING: eval_stitching_func(ctx, func, *in, out); break;
+	case POSTSCRIPT: eval_postscript_func(ctx, func, in, out); break;
 	}
 }
 
diff --git a/pdf/pdf_image.c b/pdf/pdf_image.c
index c5242b72..31104b9f 100644
--- a/pdf/pdf_image.c
+++ b/pdf/pdf_image.c
@@ -210,7 +210,7 @@ pdf_load_image_imp(fz_pixmap **imgp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict,
 		if (tlen < 0)
 			fz_error_handle(tlen, "ignoring error at end of image");
 		if (tlen > 0)
-			fz_warn("ignoring garbage at end of image");
+			fz_warn(ctx, "ignoring garbage at end of image");
 	}
 
 	fz_close(stm);
@@ -218,7 +218,7 @@ pdf_load_image_imp(fz_pixmap **imgp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict,
 	/* Pad truncated images */
 	if (len < stride * h)
 	{
-		fz_warn("padding truncated image (%d 0 R)", fz_to_num(dict));
+		fz_warn(ctx, "padding truncated image (%d 0 R)", fz_to_num(dict));
 		memset(samples + len, 0, stride * h - len);
 	}
 
diff --git a/pdf/pdf_interpret.c b/pdf/pdf_interpret.c
index e3272edf..cc320894 100644
--- a/pdf/pdf_interpret.c
+++ b/pdf/pdf_interpret.c
@@ -254,10 +254,10 @@ static void pdf_show_clip(pdf_csi *csi, int even_odd)
 static void
 pdf_show_path(pdf_csi *csi, int doclose, int dofill, int dostroke, int even_odd)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 	fz_path *path;
 	fz_rect bbox;
-	fz_context *ctx = csi->dev->ctx;
 
 	path = csi->path;
 	csi->path = fz_new_path(ctx);
@@ -452,6 +452,7 @@ pdf_flush_text(pdf_csi *csi)
 static void
 pdf_show_char(pdf_csi *csi, int cid)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 	pdf_font_desc *fontdesc = gstate->font;
 	fz_matrix tsm, trm;
@@ -462,7 +463,6 @@ pdf_show_char(pdf_csi *csi, int cid)
 	int ucsbuf[8];
 	int ucslen;
 	int i;
-	fz_context *ctx = csi->dev->ctx;
 
 	tsm.a = gstate->size * gstate->scale;
 	tsm.b = 0;
@@ -540,12 +540,13 @@ pdf_show_char(pdf_csi *csi, int cid)
 static void
 pdf_show_space(pdf_csi *csi, float tadj)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 	pdf_font_desc *fontdesc = gstate->font;
 
 	if (!fontdesc)
 	{
-		fz_warn("cannot draw text since font and size not set");
+		fz_warn(ctx, "cannot draw text since font and size not set");
 		return;
 	}
 
@@ -558,6 +559,7 @@ pdf_show_space(pdf_csi *csi, float tadj)
 static void
 pdf_show_string(pdf_csi *csi, unsigned char *buf, int len)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 	pdf_font_desc *fontdesc = gstate->font;
 	unsigned char *end = buf + len;
@@ -565,7 +567,7 @@ pdf_show_string(pdf_csi *csi, unsigned char *buf, int len)
 
 	if (!fontdesc)
 	{
-		fz_warn("cannot draw text since font and size not set");
+		fz_warn(ctx, "cannot draw text since font and size not set");
 		return;
 	}
 
@@ -576,7 +578,7 @@ pdf_show_string(pdf_csi *csi, unsigned char *buf, int len)
 		if (cid >= 0)
 			pdf_show_char(csi, cid);
 		else
-			fz_warn("cannot encode character with code point %#x", cpt);
+			fz_warn(ctx, "cannot encode character with code point %#x", cpt);
 		if (cpt == 32)
 			pdf_show_space(csi, gstate->word_space);
 	}
@@ -733,11 +735,12 @@ pdf_drop_material(fz_context *ctx, pdf_material *mat)
 static void
 pdf_gsave(pdf_csi *csi)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gs = csi->gstate + csi->gtop;
 
 	if (csi->gtop == nelem(csi->gstate) - 1)
 	{
-		fz_warn("gstate overflow in content stream");
+		fz_warn(ctx, "gstate overflow in content stream");
 		return;
 	}
 
@@ -756,13 +759,13 @@ pdf_gsave(pdf_csi *csi)
 static void
 pdf_grestore(pdf_csi *csi)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gs = csi->gstate + csi->gtop;
 	int clip_depth = gs->clip_depth;
-	fz_context *ctx = csi->dev->ctx;
 
 	if (csi->gtop == 0)
 	{
-		fz_warn("gstate underflow in content stream");
+		fz_warn(ctx, "gstate underflow in content stream");
 		return;
 	}
 
@@ -816,6 +819,7 @@ pdf_free_csi(pdf_csi *csi)
 static void
 pdf_set_colorspace(pdf_csi *csi, int what, fz_colorspace *colorspace)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gs = csi->gstate + csi->gtop;
 	pdf_material *mat;
 
@@ -823,7 +827,7 @@ pdf_set_colorspace(pdf_csi *csi, int what, fz_colorspace *colorspace)
 
 	mat = what == PDF_FILL ? &gs->fill : &gs->stroke;
 
-	fz_drop_colorspace(csi->dev->ctx, mat->colorspace);
+	fz_drop_colorspace(ctx, mat->colorspace);
 
 	mat->kind = PDF_MAT_COLOR;
 	mat->colorspace = fz_keep_colorspace(colorspace);
@@ -837,6 +841,7 @@ pdf_set_colorspace(pdf_csi *csi, int what, fz_colorspace *colorspace)
 static void
 pdf_set_color(pdf_csi *csi, int what, float *v)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gs = csi->gstate + csi->gtop;
 	pdf_material *mat;
 	int i;
@@ -859,13 +864,14 @@ pdf_set_color(pdf_csi *csi, int what, float *v)
 			mat->v[i] = v[i];
 		break;
 	default:
-		fz_warn("color incompatible with material");
+		fz_warn(ctx, "color incompatible with material");
 	}
 }
 
 static void
 pdf_set_shade(pdf_csi *csi, int what, fz_shade *shade)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gs = csi->gstate + csi->gtop;
 	pdf_material *mat;
 
@@ -874,7 +880,7 @@ pdf_set_shade(pdf_csi *csi, int what, fz_shade *shade)
 	mat = what == PDF_FILL ? &gs->fill : &gs->stroke;
 
 	if (mat->shade)
-		fz_drop_shade(csi->dev->ctx, mat->shade);
+		fz_drop_shade(ctx, mat->shade);
 
 	mat->kind = PDF_MAT_SHADE;
 	mat->shade = fz_keep_shade(shade);
@@ -883,6 +889,7 @@ pdf_set_shade(pdf_csi *csi, int what, fz_shade *shade)
 static void
 pdf_set_pattern(pdf_csi *csi, int what, pdf_pattern *pat, float *v)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gs = csi->gstate + csi->gtop;
 	pdf_material *mat;
 
@@ -891,7 +898,7 @@ pdf_set_pattern(pdf_csi *csi, int what, pdf_pattern *pat, float *v)
 	mat = what == PDF_FILL ? &gs->fill : &gs->stroke;
 
 	if (mat->pattern)
-		pdf_drop_pattern(csi->dev->ctx, mat->pattern);
+		pdf_drop_pattern(ctx, mat->pattern);
 
 	mat->kind = PDF_MAT_PATTERN;
 	if (pat)
@@ -906,13 +913,14 @@ pdf_set_pattern(pdf_csi *csi, int what, pdf_pattern *pat, float *v)
 static void
 pdf_unset_pattern(pdf_csi *csi, int what)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gs = csi->gstate + csi->gtop;
 	pdf_material *mat;
 	mat = what == PDF_FILL ? &gs->fill : &gs->stroke;
 	if (mat->kind == PDF_MAT_PATTERN)
 	{
 		if (mat->pattern)
-			pdf_drop_pattern(csi->dev->ctx, mat->pattern);
+			pdf_drop_pattern(ctx, mat->pattern);
 		mat->pattern = NULL;
 		mat->kind = PDF_MAT_COLOR;
 	}
@@ -925,13 +933,13 @@ pdf_unset_pattern(pdf_csi *csi, int what)
 static void
 pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, fz_rect area, int what)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gstate;
 	fz_matrix ptm, invptm;
 	fz_matrix oldtopctm;
 	fz_error error;
 	int x0, y0, x1, y1;
 	int oldtop;
-	fz_context *ctx = csi->dev->ctx;
 
 	pdf_gsave(csi);
 	gstate = csi->gstate + csi->gtop;
@@ -1030,12 +1038,12 @@ cleanup:
 static fz_error
 pdf_run_xobject(pdf_csi *csi, fz_obj *resources, pdf_xobject *xobj, fz_matrix transform)
 {
+	fz_context *ctx = csi->dev->ctx;
 	fz_error error;
 	pdf_gstate *gstate;
 	fz_matrix oldtopctm;
 	int oldtop;
 	int popmask;
-	fz_context *ctx = csi->dev->ctx;
 
 	pdf_gsave(csi);
 
@@ -1121,10 +1129,10 @@ pdf_run_xobject(pdf_csi *csi, fz_obj *resources, pdf_xobject *xobj, fz_matrix tr
 static fz_error
 pdf_run_extgstate(pdf_csi *csi, fz_obj *rdb, fz_obj *extgstate)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 	fz_colorspace *colorspace;
 	int i, k, n;
-	fz_context *ctx = csi->dev->ctx;
 
 	pdf_flush_text(csi);
 
@@ -1255,7 +1263,7 @@ pdf_run_extgstate(pdf_csi *csi, fz_obj *rdb, fz_obj *extgstate)
 		else if (!strcmp(s, "TR"))
 		{
 			if (fz_is_name(val) && strcmp(fz_to_name(val), "Identity"))
-				fz_warn("ignoring transfer function");
+				fz_warn(ctx, "ignoring transfer function");
 		}
 	}
 
@@ -1272,13 +1280,13 @@ static void pdf_run_BDC(pdf_csi *csi)
 
 static fz_error pdf_run_BI(pdf_csi *csi, fz_obj *rdb, fz_stream *file)
 {
+	fz_context *ctx = csi->dev->ctx;
 	int ch;
 	fz_error error;
 	char *buf = csi->xref->scratch;
 	int buflen = sizeof(csi->xref->scratch);
 	fz_pixmap *img;
 	fz_obj *obj;
-	fz_context *ctx = csi->dev->ctx;
 
 	error = pdf_parse_dict(&obj, csi->xref, file, buf, buflen);
 	if (error)
@@ -1338,10 +1346,10 @@ static void pdf_run_Bstar(pdf_csi *csi)
 
 static fz_error pdf_run_cs_imp(pdf_csi *csi, fz_obj *rdb, int what)
 {
+	fz_context *ctx = csi->dev->ctx;
 	fz_colorspace *colorspace;
 	fz_obj *obj, *dict;
 	fz_error error;
-	fz_context *ctx = csi->dev->ctx;
 
 	if (!strcmp(csi->name, "Pattern"))
 	{
@@ -1397,11 +1405,11 @@ static void pdf_run_DP(pdf_csi *csi)
 
 static fz_error pdf_run_Do(pdf_csi *csi, fz_obj *rdb)
 {
+	fz_context *ctx = csi->dev->ctx;
 	fz_obj *dict;
 	fz_obj *obj;
 	fz_obj *subtype;
 	fz_error error;
-	fz_context *ctx = csi->dev->ctx;
 
 	dict = fz_dict_gets(rdb, "XObject");
 	if (!dict)
@@ -1455,7 +1463,7 @@ static fz_error pdf_run_Do(pdf_csi *csi, fz_obj *rdb)
 
 	else if (!strcmp(fz_to_name(subtype), "PS"))
 	{
-		fz_warn("ignoring XObject with subtype PS");
+		fz_warn(ctx, "ignoring XObject with subtype PS");
 	}
 
 	else
@@ -1535,12 +1543,12 @@ static void pdf_run_S(pdf_csi *csi)
 
 static fz_error pdf_run_SC_imp(pdf_csi *csi, fz_obj *rdb, int what, pdf_material *mat)
 {
+	fz_context *ctx = csi->dev->ctx;
 	fz_error error;
 	fz_obj *patterntype;
 	fz_obj *dict;
 	fz_obj *obj;
 	int kind;
-	fz_context *ctx = csi->dev->ctx;
 
 	kind = mat->kind;
 	if (csi->name[0])
@@ -1643,11 +1651,11 @@ static void pdf_run_TL(pdf_csi *csi)
 
 static fz_error pdf_run_Tf(pdf_csi *csi, fz_obj *rdb)
 {
+	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 	fz_error error;
 	fz_obj *dict;
 	fz_obj *obj;
-	fz_context *ctx = csi->dev->ctx;
 
 	gstate->size = csi->stack[0];
 	if (gstate->font)
@@ -1889,8 +1897,8 @@ static void pdf_run_q(pdf_csi *csi)
 
 static void pdf_run_re(pdf_csi *csi)
 {
-	float x, y, w, h;
 	fz_context *ctx = csi->dev->ctx;
+	float x, y, w, h;
 
 	x = csi->stack[0];
 	y = csi->stack[1];
@@ -1921,11 +1929,11 @@ static void pdf_run(pdf_csi *csi)
 
 static fz_error pdf_run_sh(pdf_csi *csi, fz_obj *rdb)
 {
+	fz_context *ctx = csi->dev->ctx;
 	fz_obj *dict;
 	fz_obj *obj;
 	fz_shade *shd;
 	fz_error error;
-	fz_context *ctx = csi->dev->ctx;
 
 	dict = fz_dict_gets(rdb, "Shading");
 	if (!dict)
@@ -2013,6 +2021,7 @@ static void pdf_run_dquote(pdf_csi *csi)
 static fz_error
 pdf_run_keyword(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf)
 {
+	fz_context *ctx = csi->dev->ctx;
 	fz_error error;
 	int key;
 
@@ -2123,7 +2132,7 @@ pdf_run_keyword(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf)
 	case A('y'): pdf_run_y(csi); break;
 	default:
 		if (!csi->xbalance)
-			fz_warn("unknown keyword: '%s'", buf);
+			fz_warn(ctx, "unknown keyword: '%s'", buf);
 		break;
 	}
 
@@ -2133,9 +2142,9 @@ pdf_run_keyword(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf)
 static fz_error
 pdf_run_stream(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf, int buflen)
 {
+	fz_context *ctx = csi->dev->ctx;
 	fz_error error;
 	int tok, len, in_array;
-	fz_context *ctx = csi->dev->ctx;
 
 	/* make sure we have a clean slate if we come here from flush_text */
 	pdf_clear_stack(csi);
@@ -2168,7 +2177,7 @@ pdf_run_stream(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf, int buflen
 			else if (tok == PDF_TOK_KEYWORD)
 			{
 				if (!strcmp(buf, "Tw") || !strcmp(buf, "Tc"))
-					fz_warn("ignoring keyword '%s' inside array", buf);
+					fz_warn(ctx, "ignoring keyword '%s' inside array", buf);
 				else
 					return fz_error_make("syntax error in array");
 			}
diff --git a/pdf/pdf_lex.c b/pdf/pdf_lex.c
index 84f584b0..d34b2b6f 100644
--- a/pdf/pdf_lex.c
+++ b/pdf/pdf_lex.c
@@ -333,7 +333,7 @@ lex_hex_string(fz_stream *f, char *buf, int n)
 		case EOF:
 			goto end;
 		default:
-			fz_warn("ignoring invalid character in hex string: '%c'", c);
+			fz_warn(f->ctx, "ignoring invalid character in hex string: '%c'", c);
 		}
 	}
 end:
diff --git a/pdf/pdf_page.c b/pdf/pdf_page.c
index 7c8fb88e..9c67edf0 100644
--- a/pdf/pdf_page.c
+++ b/pdf/pdf_page.c
@@ -83,7 +83,7 @@ pdf_load_page_tree_node(pdf_xref *xref, fz_obj *node, struct info info)
 
 		if (xref->page_len == xref->page_cap)
 		{
-			fz_warn("found more pages than expected");
+			fz_warn(ctx, "found more pages than expected");
 			xref->page_cap ++;
 			xref->page_refs = fz_resize_array(ctx, xref->page_refs, xref->page_cap, sizeof(fz_obj*));
 			xref->page_objs = fz_resize_array(ctx, xref->page_objs, xref->page_cap, sizeof(fz_obj*));
@@ -263,7 +263,7 @@ pdf_load_page_contents(fz_buffer **bufp, pdf_xref *xref, fz_obj *obj)
 	}
 	else
 	{
-		fz_warn("page contents missing, leaving page blank");
+		fz_warn(ctx, "page contents missing, leaving page blank");
 		*bufp = fz_new_buffer(ctx, 0);
 	}
 
@@ -302,7 +302,7 @@ pdf_load_page(pdf_page **pagep, pdf_xref *xref, int number)
 	bbox = fz_round_rect(pdf_to_rect(ctx, obj));
 	if (fz_is_empty_rect(pdf_to_rect(ctx, obj)))
 	{
-		fz_warn("cannot find page size for page %d", number + 1);
+		fz_warn(ctx, "cannot find page size for page %d", number + 1);
 		bbox.x0 = 0;
 		bbox.y0 = 0;
 		bbox.x1 = 612;
@@ -323,7 +323,7 @@ pdf_load_page(pdf_page **pagep, pdf_xref *xref, int number)
 
 	if (page->mediabox.x1 - page->mediabox.x0 < 1 || page->mediabox.y1 - page->mediabox.y0 < 1)
 	{
-		fz_warn("invalid page size in page %d", number + 1);
+		fz_warn(ctx, "invalid page size in page %d", number + 1);
 		page->mediabox = fz_unit_rect;
 	}
 
diff --git a/pdf/pdf_parse.c b/pdf/pdf_parse.c
index b1f22e46..5a243289 100644
--- a/pdf/pdf_parse.c
+++ b/pdf/pdf_parse.c
@@ -581,7 +581,7 @@ skip:
 		{
 			c = fz_peek_byte(file);
 			if (c != '\n')
-				fz_warn("line feed missing after stream begin marker (%d %d R)", num, gen);
+				fz_warn(ctx, "line feed missing after stream begin marker (%d %d R)", num, gen);
 			else
 				fz_read_byte(file);
 		}
@@ -593,7 +593,7 @@ skip:
 	}
 	else
 	{
-		fz_warn("expected 'endobj' or 'stream' keyword (%d %d R)", num, gen);
+		fz_warn(ctx, "expected 'endobj' or 'stream' keyword (%d %d R)", num, gen);
 		stm_ofs = 0;
 	}
 
diff --git a/pdf/pdf_repair.c b/pdf/pdf_repair.c
index 461fd4de..969683d4 100644
--- a/pdf/pdf_repair.c
+++ b/pdf/pdf_repair.c
@@ -119,7 +119,7 @@ atobjend:
 		if (error)
 			return fz_error_note(error, "cannot scan for endobj token");
 		if (tok != PDF_TOK_ENDOBJ)
-			fz_warn("object missing 'endobj' token");
+			fz_warn(file->ctx, "object missing 'endobj' token");
 	}
 
 	return fz_okay;
diff --git a/pdf/pdf_shade.c b/pdf/pdf_shade.c
index 45fefba5..1c8897f6 100644
--- a/pdf/pdf_shade.c
+++ b/pdf/pdf_shade.c
@@ -322,7 +322,7 @@ pdf_make_tensor_patch(pdf_tensor_patch *p, int type, fz_point *pt)
 /* Sample various functions into lookup tables */
 
 static void
-pdf_sample_composite_shade_function(fz_shade *shade, pdf_function *func, float t0, float t1)
+pdf_sample_composite_shade_function(fz_context *ctx, fz_shade *shade, pdf_function *func, float t0, float t1)
 {
 	int i;
 	float t;
@@ -330,13 +330,13 @@ pdf_sample_composite_shade_function(fz_shade *shade, pdf_function *func, float t
 	for (i = 0; i < 256; i++)
 	{
 		t = t0 + (i / 255.0f) * (t1 - t0);
-		pdf_eval_function(func, &t, 1, shade->function[i], shade->colorspace->n);
+		pdf_eval_function(ctx, func, &t, 1, shade->function[i], shade->colorspace->n);
 		shade->function[i][shade->colorspace->n] = 1;
 	}
 }
 
 static void
-pdf_sample_component_shade_function(fz_shade *shade, int funcs, pdf_function **func, float t0, float t1)
+pdf_sample_component_shade_function(fz_context *ctx, fz_shade *shade, int funcs, pdf_function **func, float t0, float t1)
 {
 	int i, k;
 	float t;
@@ -345,19 +345,19 @@ pdf_sample_component_shade_function(fz_shade *shade, int funcs, pdf_function **f
 	{
 		t = t0 + (i / 255.0f) * (t1 - t0);
 		for (k = 0; k < funcs; k++)
-			pdf_eval_function(func[k], &t, 1, &shade->function[i][k], 1);
+			pdf_eval_function(ctx, func[k], &t, 1, &shade->function[i][k], 1);
 		shade->function[i][k] = 1;
 	}
 }
 
 static void
-pdf_sample_shade_function(fz_shade *shade, int funcs, pdf_function **func, float t0, float t1)
+pdf_sample_shade_function(fz_context *ctx, fz_shade *shade, int funcs, pdf_function **func, float t0, float t1)
 {
 	shade->use_function = 1;
 	if (funcs == 1)
-		pdf_sample_composite_shade_function(shade, func[0], t0, t1);
+		pdf_sample_composite_shade_function(ctx, shade, func[0], t0, t1);
 	else
-		pdf_sample_component_shade_function(shade, funcs, func, t0, t1);
+		pdf_sample_component_shade_function(ctx, shade, funcs, func, t0, t1);
 }
 
 /* Type 1-3 -- Function-based, axial and radial shadings */
@@ -413,7 +413,7 @@ pdf_load_function_based_shading(fz_shade *shade, pdf_xref *xref, fz_obj *dict, p
 
 				fv[0] = v[i].x;
 				fv[1] = v[i].y;
-				pdf_eval_function(func, fv, 2, v[i].c, shade->colorspace->n);
+				pdf_eval_function(ctx, func, fv, 2, v[i].c, shade->colorspace->n);
 
 				pt.x = v[i].x;
 				pt.y = v[i].y;
@@ -460,7 +460,7 @@ pdf_load_axial_shading(fz_shade *shade, pdf_xref *xref, fz_obj *dict, int funcs,
 		e1 = fz_to_bool(fz_array_get(obj, 1));
 	}
 
-	pdf_sample_shade_function(shade, funcs, func, d0, d1);
+	pdf_sample_shade_function(ctx, shade, funcs, func, d0, d1);
 
 	shade->type = FZ_LINEAR;
 
@@ -513,7 +513,7 @@ pdf_load_radial_shading(fz_shade *shade, pdf_xref *xref, fz_obj *dict, int funcs
 		e1 = fz_to_bool(fz_array_get(obj, 1));
 	}
 
-	pdf_sample_shade_function(shade, funcs, func, d0, d1);
+	pdf_sample_shade_function(ctx, shade, funcs, func, d0, d1);
 
 	shade->type = FZ_RADIAL;
 
@@ -606,19 +606,19 @@ static void
 pdf_load_type4_shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict,
 	int funcs, pdf_function **func, fz_stream *stream)
 {
+	fz_context *ctx = xref->ctx;
 	struct mesh_params p;
 	struct vertex va, vb, vc, vd;
 	int ncomp;
 	int flag;
 	int i;
-	fz_context *ctx = xref->ctx;
 
 	pdf_load_mesh_params(xref, dict, &p);
 
 	if (funcs > 0)
 	{
 		ncomp = 1;
-		pdf_sample_shade_function(shade, funcs, func, p.c0[0], p.c1[0]);
+		pdf_sample_shade_function(ctx, shade, funcs, func, p.c0[0], p.c1[0]);
 	}
 	else
 		ncomp = shade->colorspace->n;
@@ -671,19 +671,19 @@ static void
 pdf_load_type5_shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict,
 	int funcs, pdf_function **func, fz_stream *stream)
 {
+	fz_context *ctx = xref->ctx;
 	struct mesh_params p;
 	struct vertex *buf, *ref;
 	int first;
 	int ncomp;
 	int i, k;
-	fz_context *ctx = xref->ctx;
 
 	pdf_load_mesh_params(xref, dict, &p);
 
 	if (funcs > 0)
 	{
 		ncomp = 1;
-		pdf_sample_shade_function(shade, funcs, func, p.c0[0], p.c1[0]);
+		pdf_sample_shade_function(ctx, shade, funcs, func, p.c0[0], p.c1[0]);
 	}
 	else
 		ncomp = shade->colorspace->n;
@@ -721,20 +721,20 @@ static void
 pdf_load_type6_shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict,
 	int funcs, pdf_function **func, fz_stream *stream)
 {
+	fz_context *ctx = xref->ctx;
 	struct mesh_params p;
 	int haspatch, hasprevpatch;
 	float prevc[4][FZ_MAX_COLORS];
 	fz_point prevp[12];
 	int ncomp;
 	int i, k;
-	fz_context *ctx = xref->ctx;
 
 	pdf_load_mesh_params(xref, dict, &p);
 
 	if (funcs > 0)
 	{
 		ncomp = 1;
-		pdf_sample_shade_function(shade, funcs, func, p.c0[0], p.c1[0]);
+		pdf_sample_shade_function(ctx, shade, funcs, func, p.c0[0], p.c1[0]);
 	}
 	else
 		ncomp = shade->colorspace->n;
@@ -840,20 +840,20 @@ static void
 pdf_load_type7_shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict,
 	int funcs, pdf_function **func, fz_stream *stream)
 {
+	fz_context *ctx = xref->ctx;
 	struct mesh_params p;
 	int haspatch, hasprevpatch;
 	float prevc[4][FZ_MAX_COLORS];
 	fz_point prevp[16];
 	int ncomp;
 	int i, k;
-	fz_context *ctx = xref->ctx;
 
 	pdf_load_mesh_params(xref, dict, &p);
 
 	if (funcs > 0)
 	{
 		ncomp = 1;
-		pdf_sample_shade_function(shade, funcs, func, p.c0[0], p.c1[0]);
+		pdf_sample_shade_function(ctx, shade, funcs, func, p.c0[0], p.c1[0]);
 	}
 	else
 		ncomp = shade->colorspace->n;
@@ -1122,7 +1122,7 @@ pdf_load_shading(fz_shade **shadep, pdf_xref *xref, fz_obj *dict)
 		{
 			if (fz_dict_gets(obj, "CA") || fz_dict_gets(obj, "ca"))
 			{
-				fz_warn("shading with alpha not supported");
+				fz_warn(ctx, "shading with alpha not supported");
 			}
 		}
 
diff --git a/pdf/pdf_store.c b/pdf/pdf_store.c
index c8b8ba1c..4d20e859 100644
--- a/pdf/pdf_store.c
+++ b/pdf/pdf_store.c
@@ -56,7 +56,7 @@ pdf_store_item(fz_context *ctx, pdf_store *store, pdf_store_keep_fn *keep_func,
 		refkey.drop_func = drop_func;
 		refkey.num = fz_to_num(key);
 		refkey.gen = fz_to_gen(key);
-		fz_hash_insert(ctx, store->hash, &refkey, item);
+		fz_hash_insert(store->hash, &refkey, item);
 	}
 	else
 	{
@@ -191,7 +191,7 @@ void
 pdf_free_store(fz_context *ctx, pdf_store *store)
 {
 	pdf_age_store(ctx, store, 0);
-	fz_free_hash(ctx, store->hash);
+	fz_free_hash(store->hash);
 	fz_free(ctx, store);
 }
 
diff --git a/pdf/pdf_stream.c b/pdf/pdf_stream.c
index ccf96da9..c7259bc3 100644
--- a/pdf/pdf_stream.c
+++ b/pdf/pdf_stream.c
@@ -119,7 +119,7 @@ build_filter(fz_stream *chain, pdf_xref * xref, fz_obj * f, fz_obj * p, int num,
 
 		if (!xref->crypt)
 		{
-			fz_warn("crypt filter in unencrypted document");
+			fz_warn(ctx, "crypt filter in unencrypted document");
 			return chain;
 		}
 
@@ -130,7 +130,7 @@ build_filter(fz_stream *chain, pdf_xref * xref, fz_obj * f, fz_obj * p, int num,
 		return chain;
 	}
 
-	fz_warn("unknown filter name (%s)", s);
+	fz_warn(ctx, "unknown filter name (%s)", s);
 	return chain;
 }
 
diff --git a/pdf/pdf_type3.c b/pdf/pdf_type3.c
index b6306b47..d2523ae6 100644
--- a/pdf/pdf_type3.c
+++ b/pdf/pdf_type3.c
@@ -121,7 +121,7 @@ pdf_load_type3_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *rdb, fz_o
 	if (fontdesc->font->t3resources)
 		fz_keep_obj(fontdesc->font->t3resources);
 	if (!fontdesc->font->t3resources)
-		fz_warn("no resource dictionary for type 3 font!");
+		fz_warn(ctx, "no resource dictionary for type 3 font!");
 
 	fontdesc->font->t3xref = xref;
 	fontdesc->font->t3run = pdf_run_glyph_func;
diff --git a/pdf/pdf_xref.c b/pdf/pdf_xref.c
index b514c193..37bbc977 100644
--- a/pdf/pdf_xref.c
+++ b/pdf/pdf_xref.c
@@ -213,14 +213,14 @@ pdf_read_old_xref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 		/* broken pdfs where the section is not on a separate line */
 		if (s && *s != '\0')
 		{
-			fz_warn("broken xref section. proceeding anyway.");
+			fz_warn(xref->ctx, "broken xref section. proceeding anyway.");
 			fz_seek(xref->file, -(2 + (int)strlen(s)), 1);
 		}
 
 		/* broken pdfs where size in trailer undershoots entries in xref sections */
 		if (ofs + len > xref->len)
 		{
-			fz_warn("broken xref section, proceeding anyway.");
+			fz_warn(xref->ctx, "broken xref section, proceeding anyway.");
 			pdf_resize_xref(xref, ofs + len);
 		}
 
@@ -908,7 +908,7 @@ pdf_update_object(pdf_xref *xref, int num, int gen, fz_obj *newobj)
 
 	if (num < 0 || num >= xref->len)
 	{
-		fz_warn("object out of range (%d %d R); xref size %d", num, gen, xref->len);
+		fz_warn(xref->ctx, "object out of range (%d %d R); xref size %d", num, gen, xref->len);
 		return;
 	}
 
diff --git a/xps/xps_common.c b/xps/xps_common.c
index 894a4941..5fb1db31 100644
--- a/xps/xps_common.c
+++ b/xps/xps_common.c
@@ -22,7 +22,7 @@ xps_parse_brush(xps_context *ctx, fz_matrix ctm, fz_rect area, char *base_uri, x
 	else if (!strcmp(xml_tag(node), "RadialGradientBrush"))
 		xps_parse_radial_gradient_brush(ctx, ctm, area, base_uri, dict, node);
 	else
-		fz_warn("unknown brush tag: %s", xml_tag(node));
+		fz_warn(ctx->ctx, "unknown brush tag: %s", xml_tag(node));
 }
 
 void
@@ -230,7 +230,7 @@ xps_parse_color(xps_context *ctx, char *base_uri, char *string,
 		profile = strchr(buf, ' ');
 		if (!profile)
 		{
-			fz_warn("cannot find icc profile uri in '%s'", string);
+			fz_warn(ctx->ctx, "cannot find icc profile uri in '%s'", string);
 			return;
 		}
 
@@ -238,7 +238,7 @@ xps_parse_color(xps_context *ctx, char *base_uri, char *string,
 		p = strchr(profile, ' ');
 		if (!p)
 		{
-			fz_warn("cannot find component values in '%s'", profile);
+			fz_warn(ctx->ctx, "cannot find component values in '%s'", profile);
 			return;
 		}
 
diff --git a/xps/xps_glyphs.c b/xps/xps_glyphs.c
index d5b3ea23..9dfd165e 100644
--- a/xps/xps_glyphs.c
+++ b/xps/xps_glyphs.c
@@ -113,7 +113,7 @@ xps_deobfuscate_font_resource(xps_context *ctx, xps_part *part)
 
 	if (i != 32)
 	{
-		fz_warn("cannot extract GUID from obfuscated font part name");
+		fz_warn(ctx->ctx, "cannot extract GUID from obfuscated font part name");
 		return;
 	}
 
@@ -128,7 +128,7 @@ xps_deobfuscate_font_resource(xps_context *ctx, xps_part *part)
 }
 
 static void
-xps_select_best_font_encoding(fz_font *font)
+xps_select_best_font_encoding(xps_context *ctx, fz_font *font)
 {
 	static struct { int pid, eid; } xps_cmap_list[] =
 	{
@@ -160,7 +160,7 @@ xps_select_best_font_encoding(fz_font *font)
 		}
 	}
 
-	fz_warn("cannot find a suitable cmap");
+	fz_warn(ctx->ctx, "cannot find a suitable cmap");
 }
 
 /*
@@ -267,7 +267,7 @@ xps_parse_glyphs_imp(xps_context *ctx, fz_matrix ctm,
 	int un = 0;
 
 	if (!unicode && !indices)
-		fz_warn("glyphs element with neither characters nor indices");
+		fz_warn(ctx->ctx, "glyphs element with neither characters nor indices");
 
 	if (us)
 	{
@@ -456,7 +456,7 @@ xps_parse_glyphs(xps_context *ctx, fz_matrix ctm,
 	 */
 
 	if (!font_size_att || !font_uri_att || !origin_x_att || !origin_y_att) {
-		fz_warn("missing attributes in glyphs element");
+		fz_warn(ctx->ctx, "missing attributes in glyphs element");
 		return;
 	}
 
@@ -486,7 +486,7 @@ xps_parse_glyphs(xps_context *ctx, fz_matrix ctm,
 	{
 		part = xps_read_part(ctx, partname);
 		if (!part) {
-			fz_warn("cannot find font resource part '%s'", partname);
+			fz_warn(ctx->ctx, "cannot find font resource part '%s'", partname);
 			return;
 		}
 
@@ -503,7 +503,7 @@ xps_parse_glyphs(xps_context *ctx, fz_matrix ctm,
 			return;
 		}
 
-		xps_select_best_font_encoding(font);
+		xps_select_best_font_encoding(ctx, font);
 
 		xps_insert_font(ctx, part->name, font);
 
diff --git a/xps/xps_gradient.c b/xps/xps_gradient.c
index 4dcf1ef8..19424f9b 100644
--- a/xps/xps_gradient.c
+++ b/xps/xps_gradient.c
@@ -61,7 +61,7 @@ xps_parse_gradient_stops(xps_context *ctx, char *base_uri, xml_element *node,
 
 				xps_parse_color(ctx, base_uri, color, &colorspace, sample);
 
-				fz_convert_color(colorspace, sample + 1, fz_device_rgb, rgb);
+				fz_convert_color(ctx->ctx, colorspace, sample + 1, fz_device_rgb, rgb);
 
 				stops[count].r = rgb[0];
 				stops[count].g = rgb[1];
@@ -76,7 +76,7 @@ xps_parse_gradient_stops(xps_context *ctx, char *base_uri, xml_element *node,
 
 	if (count == 0)
 	{
-		fz_warn("gradient brush has no gradient stops");
+		fz_warn(ctx->ctx, "gradient brush has no gradient stops");
 		stops[0].offset = 0;
 		stops[0].r = 0;
 		stops[0].g = 0;
@@ -91,7 +91,7 @@ xps_parse_gradient_stops(xps_context *ctx, char *base_uri, xml_element *node,
 	}
 
 	if (count == maxcount)
-		fz_warn("gradient brush exceeded maximum number of gradient stops");
+		fz_warn(ctx->ctx, "gradient brush exceeded maximum number of gradient stops");
 
 	/* Postprocess to make sure the range of offsets is 0.0 to 1.0 */
 
@@ -425,14 +425,14 @@ xps_parse_gradient_brush(xps_context *ctx, fz_matrix ctm, fz_rect area,
 	ctm = fz_concat(transform, ctm);
 
 	if (!stop_tag) {
-		fz_warn("missing gradient stops tag");
+		fz_warn(ctx->ctx, "missing gradient stops tag");
 		return;
 	}
 
 	stop_count = xps_parse_gradient_stops(ctx, base_uri, stop_tag, stop_list, MAX_STOPS);
 	if (stop_count == 0)
 	{
-		fz_warn("no gradient stops found");
+		fz_warn(ctx->ctx, "no gradient stops found");
 		return;
 	}
 
diff --git a/xps/xps_image.c b/xps/xps_image.c
index e3570ffb..28cadecf 100644
--- a/xps/xps_image.c
+++ b/xps/xps_image.c
@@ -110,7 +110,7 @@ xps_parse_image_brush(xps_context *ctx, fz_matrix ctm, fz_rect area,
 
 	part = xps_find_image_brush_source_part(ctx, base_uri, root);
 	if (!part) {
-		fz_warn("cannot find image source");
+		fz_warn(ctx, "cannot find image source");
 		return;
 	}
 
diff --git a/xps/xps_path.c b/xps/xps_path.c
index 28548c56..fcc6f571 100644
--- a/xps/xps_path.c
+++ b/xps/xps_path.c
@@ -468,7 +468,7 @@ xps_parse_arc_segment(fz_context *ctx, fz_path *path, xml_element *root, int str
 
 	if (!point_att || !size_att || !rotation_angle_att || !is_large_arc_att || !sweep_direction_att)
 	{
-		fz_warn("ArcSegment element is missing attributes");
+		fz_warn(ctx, "ArcSegment element is missing attributes");
 		return;
 	}
 
@@ -506,7 +506,7 @@ xps_parse_poly_quadratic_bezier_segment(fz_context *ctx, fz_path *path, xml_elem
 
 	if (!points_att)
 	{
-		fz_warn("PolyQuadraticBezierSegment element has no points");
+		fz_warn(ctx, "PolyQuadraticBezierSegment element has no points");
 		return;
 	}
 
@@ -555,7 +555,7 @@ xps_parse_poly_bezier_segment(fz_context *ctx, fz_path *path, xml_element *root,
 
 	if (!points_att)
 	{
-		fz_warn("PolyBezierSegment element has no points");
+		fz_warn(ctx, "PolyBezierSegment element has no points");
 		return;
 	}
 
@@ -595,7 +595,7 @@ xps_parse_poly_line_segment(fz_context *ctx, fz_path *path, xml_element *root, i
 
 	if (!points_att)
 	{
-		fz_warn("PolyLineSegment element has no points");
+		fz_warn(ctx, "PolyLineSegment element has no points");
 		return;
 	}
 
diff --git a/xps/xps_tiff.c b/xps/xps_tiff.c
index a777fdaa..f970f153 100644
--- a/xps/xps_tiff.c
+++ b/xps/xps_tiff.c
@@ -683,7 +683,7 @@ xps_read_tiff_tag(struct tiff *tiff, unsigned offset)
 		break;
 
 	case JPEGTables:
-		fz_warn("jpeg tables in tiff not implemented");
+		fz_warn(tiff->ctx, "jpeg tables in tiff not implemented");
 		tiff->jpegtables = tiff->bp + value;
 		tiff->jpegtableslen = count;
 		break;