1 files changed, 558 insertions, 608 deletions

diff --git a/source/pdf/pdf-op-buffer.c b/source/pdf/pdf-op-buffer.c
index e2bbd343..cdea4c78 100644
--- a/source/pdf/pdf-op-buffer.c
+++ b/source/pdf/pdf-op-buffer.c
@@ -1,939 +1,889 @@
-#include "pdf-interpret-imp.h"
+#include "mupdf/pdf.h"
 
-typedef struct pdf_buffer_state_s
+typedef struct pdf_output_processor_s pdf_output_processor;
+
+struct pdf_output_processor_s
 {
-	fz_context *ctx;
-	fz_buffer *buffer;
+	pdf_processor super;
 	fz_output *out;
-}
-pdf_buffer_state;
+	int extgstate;
+};
+
+/* general graphics state */
 
 static void
-put_hexstring(fz_context *ctx, fz_output *out, pdf_csi *csi)
+pdf_out_w(fz_context *ctx, pdf_processor *proc, float linewidth)
 {
-	int i;
-
-	fz_printf(ctx, out, "<");
-	for (i = 0; i < csi->string_len; i++)
-		fz_printf(ctx, out, "%02x", csi->string[i]);
-	fz_printf(ctx, out, ">");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	if (!((pdf_output_processor*)proc)->extgstate)
+		fz_printf(ctx, out, "%f w\n", linewidth);
 }
 
 static void
-put_string(fz_context *ctx, fz_output *out, pdf_csi *csi)
+pdf_out_j(fz_context *ctx, pdf_processor *proc, int linejoin)
 {
-	int i;
-
-	for (i=0; i < csi->string_len; i++)
-		if (csi->string[i] < 32 || csi->string[i] >= 127)
-			break;
-	if (i < csi->string_len)
-		put_hexstring(ctx, out, csi);
-	else
-	{
-		fz_printf(ctx, out, "(");
-		for (i = 0; i < csi->string_len; i++)
-		{
-			char c = csi->string[i];
-			switch (c)
-			{
-			case '(':
-				fz_printf(ctx, out, "\\(");
-				break;
-			case ')':
-				fz_printf(ctx, out, "\\)");
-				break;
-			case '\\':
-				fz_printf(ctx, out, "\\\\");
-				break;
-			default:
-				fz_printf(ctx, out, "%c", csi->string[i]);
-				break;
-			}
-		}
-		fz_printf(ctx, out, ")");
-	}
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	if (!((pdf_output_processor*)proc)->extgstate)
+		fz_printf(ctx, out, "%d j\n", linejoin);
 }
 
 static void
-put_string_or_obj(fz_context *ctx, fz_output *out, pdf_csi *csi)
+pdf_out_J(fz_context *ctx, pdf_processor *proc, int linecap)
 {
-	if (csi->string_len)
-		put_string(ctx, out, csi);
-	else
-		pdf_output_obj(ctx, out, csi->obj, 1);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	if (!((pdf_output_processor*)proc)->extgstate)
+		fz_printf(ctx, out, "%d J\n", linecap);
 }
 
 static void
-pdf_buffer_dquote(pdf_csi *csi, void *state_)
+pdf_out_M(fz_context *ctx, pdf_processor *proc, float a)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f ", csi->stack[0], csi->stack[1]);
-	put_string_or_obj(state->ctx, state->out, csi);
-	fz_printf(state->ctx, state->out, " \"\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	if (!((pdf_output_processor*)proc)->extgstate)
+		fz_printf(ctx, out, "%f M\n", a);
 }
 
 static void
-pdf_buffer_squote(pdf_csi *csi, void *state_)
+pdf_out_d(fz_context *ctx, pdf_processor *proc, pdf_obj *array, float phase)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	put_string_or_obj(state->ctx, state->out, csi);
-	fz_printf(state->ctx, state->out, " \'\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	if (!((pdf_output_processor*)proc)->extgstate)
+	{
+		pdf_output_obj(ctx, out, array, 1);
+		fz_printf(ctx, out, " %f d\n", phase);
+	}
 }
 
 static void
-pdf_buffer_B(pdf_csi *csi, void *state_)
+pdf_out_ri(fz_context *ctx, pdf_processor *proc, const char *intent)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "B\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	if (!((pdf_output_processor*)proc)->extgstate)
+		fz_printf(ctx, out, "/%s ri\n", intent);
 }
 
 static void
-pdf_buffer_Bstar(pdf_csi *csi, void *state_)
+pdf_out_i(fz_context *ctx, pdf_processor *proc, float flatness)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "B*\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	if (!((pdf_output_processor*)proc)->extgstate)
+		fz_printf(ctx, out, "%f i\n", flatness);
 }
 
 static void
-pdf_buffer_BDC(pdf_csi *csi, void *state_)
+pdf_out_gs_begin(fz_context *ctx, pdf_processor *proc, const char *name, pdf_obj *extgstate)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "/%s ", csi->name);
-	pdf_output_obj(state->ctx, state->out, csi->obj, 1);
-	fz_printf(state->ctx, state->out, " BDC\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	((pdf_output_processor*)proc)->extgstate = 1;
+	fz_printf(ctx, out, "/%s gs\n", name);
 }
 
 static void
-pdf_buffer_BI(pdf_csi *csi, void *state_)
+pdf_out_gs_end(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-	int len, i;
-	unsigned char *data;
-	fz_compressed_buffer *cbuf;
-	fz_buffer *buffer;
-	const char *match;
-	const char *match2;
-	pdf_obj *filter;
-	fz_context *ctx = csi->ctx;
-
-	if (csi->img == NULL)
-		return;
-	cbuf = csi->img->buffer;
-	if (cbuf == NULL)
-		return;
-	buffer = cbuf->buffer;
-	if (buffer == NULL)
-		return;
-
-	/* Tweak the /Filter entry in csi->obj to match the buffer params */
-	switch (cbuf->params.type)
-	{
-	case FZ_IMAGE_JPEG:
-		match = "DCTDecode";
-		match2 = "DCT";
-		break;
-	case FZ_IMAGE_FAX:
-		match = "CCITTFaxDecode";
-		match2 = "CCF";
-		break;
-	case FZ_IMAGE_RAW:
-		match = NULL;
-		match2 = NULL;
-		break;
-	case FZ_IMAGE_RLD:
-		match = "RunLengthDecode";
-		match2 = "RL";
-		break;
-	case FZ_IMAGE_FLATE:
-		match = "FlateDecode";
-		match2 = "Fl";
-		break;
-	case FZ_IMAGE_LZW:
-		match = "LZWDecode";
-		match2 = "LZW";
-		break;
-	default:
-		fz_warn(ctx, "Unsupported type (%d) of inline image", cbuf->params.type);
-		return;
-	}
-
-	filter = pdf_dict_gets(ctx, csi->obj, "Filter");
-	if (filter == NULL)
-		filter = pdf_dict_gets(ctx, csi->obj, "F");
-	if (match == NULL)
-	{
-		/* Remove any filter entry (e.g. Ascii85Decode) */
-		if (filter)
-		{
-			pdf_dict_dels(ctx, csi->obj, "Filter");
-			pdf_dict_dels(ctx, csi->obj, "F");
-		}
-		pdf_dict_dels(ctx, csi->obj, "DecodeParms");
-		pdf_dict_dels(ctx, csi->obj, "DP");
-	}
-	else if (pdf_is_array(ctx, filter))
-	{
-		int l = pdf_array_len(ctx, filter);
-		pdf_obj *o = (l == 0 ? NULL : pdf_array_get(ctx, filter, l-1));
-		const char *fil = pdf_to_name(ctx, o);
-
-		if (l == 0 || (strcmp(fil, match) && strcmp(fil, match2)))
-		{
-			fz_warn(ctx, "Unexpected Filter configuration in inline image");
-			return;
-		}
-		pdf_dict_puts(ctx, csi->obj, "F", o);
-
-		o = pdf_dict_gets(ctx, csi->obj, "DecodeParms");
-		if (o == NULL)
-			o = pdf_dict_gets(ctx, csi->obj, "DP");
-		if (o)
-		{
-			o = pdf_array_get(ctx, o, l-1);
-			if (o)
-				pdf_dict_puts(ctx, csi->obj, "DP", o);
-			else
-				pdf_dict_dels(ctx, csi->obj, "DP");
-			pdf_dict_dels(ctx, csi->obj, "DecodeParms");
-		}
-	}
-	else
-	{
-		/* It's a singleton. It must be correct */
-	}
-
-	fz_printf(state->ctx, state->out, "BI\n");
-
-	len = pdf_dict_len(ctx, csi->obj);
-	for (i = 0; i < len; i++)
-	{
-		pdf_output_obj(state->ctx, state->out, pdf_dict_get_key(ctx, csi->obj, i), 1);
-		pdf_output_obj(state->ctx, state->out, pdf_dict_get_val(ctx, csi->obj, i), 1);
-	}
-	fz_printf(state->ctx, state->out, "ID\n");
-
-	buffer = csi->img->buffer->buffer;
-	len = buffer->len;
-	data = buffer->data;
-	for (i = 0; i < len; i++)
-	{
-		fz_printf(state->ctx, state->out, "%c", data[i]);
-	}
-
-	fz_printf(state->ctx, state->out, "\nEI\n");
+	((pdf_output_processor*)proc)->extgstate = 0;
 }
 
+/* special graphics state */
+
 static void
-pdf_buffer_BMC(pdf_csi *csi, void *state_)
+pdf_out_q(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "/%s BMC\n", csi->name);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "q\n");
 }
 
 static void
-pdf_buffer_BT(pdf_csi *csi, void *state_)
+pdf_out_Q(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "BT\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "Q\n");
 }
 
 static void
-pdf_buffer_BX(pdf_csi *csi, void *state_)
+pdf_out_cm(fz_context *ctx, pdf_processor *proc, float a, float b, float c, float d, float e, float f)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "BX\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f %f %f %f %f cm\n", a, b, c, d, e, f);
 }
 
+/* path construction */
+
 static void
-pdf_buffer_CS(pdf_csi *csi, void *state_)
+pdf_out_m(fz_context *ctx, pdf_processor *proc, float x, float y)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "/%s CS\n", csi->name);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f m\n", x, y);
 }
 
 static void
-pdf_buffer_DP(pdf_csi *csi, void *state_)
+pdf_out_l(fz_context *ctx, pdf_processor *proc, float x, float y)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "/%s ", csi->name);
-	pdf_output_obj(state->ctx, state->out, csi->obj, 1);
-	fz_printf(state->ctx, state->out, " DP\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f l\n", x, y);
 }
 
 static void
-pdf_buffer_EMC(pdf_csi *csi, void *state_)
+pdf_out_c(fz_context *ctx, pdf_processor *proc, float x1, float y1, float x2, float y2, float x3, float y3)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "EMC\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f %f %f %f %f c\n", x1, y1, x2, y2, x3, y3);
 }
 
 static void
-pdf_buffer_ET(pdf_csi *csi, void *state_)
+pdf_out_v(fz_context *ctx, pdf_processor *proc, float x2, float y2, float x3, float y3)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "ET\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f %f %f v\n", x2, y2, x3, y3);
 }
 
 static void
-pdf_buffer_EX(pdf_csi *csi, void *state_)
+pdf_out_y(fz_context *ctx, pdf_processor *proc, float x1, float y1, float x3, float y3)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "EX\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f %f %f y\n", x1, y1, x3, y3);
 }
 
 static void
-pdf_buffer_F(pdf_csi *csi, void *state_)
+pdf_out_h(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "F\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "h\n");
 }
 
 static void
-pdf_buffer_G(pdf_csi *csi, void *state_)
+pdf_out_re(fz_context *ctx, pdf_processor *proc, float x, float y, float w, float h)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f G\n", csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f %f %f re\n", x, y, w, h);
 }
 
+/* path painting */
+
 static void
-pdf_buffer_J(pdf_csi *csi, void *state_)
+pdf_out_S(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%d J\n", (int)csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "S\n");
 }
 
 static void
-pdf_buffer_K(pdf_csi *csi, void *state_)
+pdf_out_s(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f %f %f K\n", csi->stack[0],
-		csi->stack[1], csi->stack[2], csi->stack[3]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "s\n");
 }
 
 static void
-pdf_buffer_M(pdf_csi *csi, void *state_)
+pdf_out_F(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f M\n", csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "F\n");
 }
 
 static void
-pdf_buffer_MP(pdf_csi *csi, void *state_)
+pdf_out_f(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "/%s MP\n", csi->name);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "f\n");
 }
 
 static void
-pdf_buffer_Q(pdf_csi *csi, void *state_)
+pdf_out_fstar(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "Q\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "f*\n");
 }
 
 static void
-pdf_buffer_RG(pdf_csi *csi, void *state_)
+pdf_out_B(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f %f RG\n", csi->stack[0], csi->stack[1], csi->stack[2]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "B\n");
 }
 
 static void
-pdf_buffer_S(pdf_csi *csi, void *state_)
+pdf_out_Bstar(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "S\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "B*\n");
 }
 
 static void
-pdf_buffer_SC(pdf_csi *csi, void *state_)
+pdf_out_b(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-	int i;
-
-	for (i = 0; i < csi->top; i++)
-		fz_printf(state->ctx, state->out, "%f ", csi->stack[i]);
-	fz_printf(state->ctx, state->out, "SC\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "b\n");
 }
 
 static void
-pdf_buffer_SCN(pdf_csi *csi, void *state_)
+pdf_out_bstar(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-	int i;
-
-	for (i = 0; i < csi->top; i++)
-		fz_printf(state->ctx, state->out, "%f ", csi->stack[i]);
-	if (csi->name[0])
-		fz_printf(state->ctx, state->out, "/%s ", csi->name);
-	fz_printf(state->ctx, state->out, "SCN\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "b*\n");
 }
 
 static void
-pdf_buffer_Tstar(pdf_csi *csi, void *state_)
+pdf_out_n(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "T*\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "n\n");
 }
 
+/* clipping paths */
+
 static void
-pdf_buffer_TD(pdf_csi *csi, void *state_)
+pdf_out_W(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f TD\n", csi->stack[0], csi->stack[1]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "W\n");
 }
 
 static void
-pdf_buffer_TJ(pdf_csi *csi, void *state_)
+pdf_out_Wstar(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	pdf_output_obj(state->ctx, state->out, csi->obj, 1);
-	fz_printf(state->ctx, state->out, " TJ\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "W*\n");
 }
 
+/* text objects */
+
 static void
-pdf_buffer_TL(pdf_csi *csi, void *state_)
+pdf_out_BT(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f TL\n", csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "BT\n");
 }
 
 static void
-pdf_buffer_Tc(pdf_csi *csi, void *state_)
+pdf_out_ET(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f Tc\n", csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "ET\n");
 }
 
+/* text state */
+
 static void
-pdf_buffer_Td(pdf_csi *csi, void *state_)
+pdf_out_Tc(fz_context *ctx, pdf_processor *proc, float charspace)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f Td\n", csi->stack[0], csi->stack[1]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f Tc\n", charspace);
 }
 
 static void
-pdf_buffer_Tj(pdf_csi *csi, void *state_)
+pdf_out_Tw(fz_context *ctx, pdf_processor *proc, float wordspace)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	put_string_or_obj(state->ctx, state->out, csi);
-	fz_printf(state->ctx, state->out, " Tj\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f Tw\n", wordspace);
 }
 
 static void
-pdf_buffer_Tm(pdf_csi *csi, void *state_)
+pdf_out_Tz(fz_context *ctx, pdf_processor *proc, float scale)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f %f %f %f %f Tm\n",
-		csi->stack[0], csi->stack[1], csi->stack[2],
-		csi->stack[3], csi->stack[4], csi->stack[5]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f Tz\n", scale);
 }
 
 static void
-pdf_buffer_Tr(pdf_csi *csi, void *state_)
+pdf_out_TL(fz_context *ctx, pdf_processor *proc, float leading)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f Tr\n", csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f TL\n", leading);
 }
 
 static void
-pdf_buffer_Ts(pdf_csi *csi, void *state_)
+pdf_out_Tf(fz_context *ctx, pdf_processor *proc, const char *name, pdf_font_desc *font, float size)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f Ts\n", csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	if (!((pdf_output_processor*)proc)->extgstate)
+		fz_printf(ctx, out, "/%s %f Tf\n", name, size);
 }
 
 static void
-pdf_buffer_Tw(pdf_csi *csi, void *state_)
+pdf_out_Tr(fz_context *ctx, pdf_processor *proc, int render)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f Tw\n", csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%d Tr\n", render);
 }
 
 static void
-pdf_buffer_Tz(pdf_csi *csi, void *state_)
+pdf_out_Ts(fz_context *ctx, pdf_processor *proc, float rise)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f Tz\n", csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f Ts\n", rise);
 }
 
+/* text positioning */
+
 static void
-pdf_buffer_W(pdf_csi *csi, void *state_)
+pdf_out_Td(fz_context *ctx, pdf_processor *proc, float tx, float ty)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "W\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f Td\n", tx, ty);
 }
 
 static void
-pdf_buffer_Wstar(pdf_csi *csi, void *state_)
+pdf_out_TD(fz_context *ctx, pdf_processor *proc, float tx, float ty)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "W*\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f TD\n", tx, ty);
 }
 
 static void
-pdf_buffer_b(pdf_csi *csi, void *state_)
+pdf_out_Tm(fz_context *ctx, pdf_processor *proc, float a, float b, float c, float d, float e, float f)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "b\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f %f %f %f %f Tm\n", a, b, c, d, e, f);
 }
 
 static void
-pdf_buffer_bstar(pdf_csi *csi, void *state_)
+pdf_out_Tstar(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "b*\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "T*\n");
 }
 
+/* text showing */
+
 static void
-pdf_buffer_c(pdf_csi *csi, void *state_)
+put_string(fz_context *ctx, fz_output *out, const unsigned char *str, int len)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
+	int i;
+
+	for (i = 0; i < len; ++i)
+		if (str[i] < 32 || str[i] >= 127)
+			break;
 
-	fz_printf(state->ctx, state->out, "%f %f %f %f %f %f c\n",
-		csi->stack[0], csi->stack[1], csi->stack[2],
-		csi->stack[3], csi->stack[4], csi->stack[5]);
+	if (i < len)
+	{
+		fz_printf(ctx, out, "<");
+		for (i = 0; i < len; ++i)
+			fz_printf(ctx, out, "%02x", str[i]);
+		fz_printf(ctx, out, ">");
+	}
+	else
+	{
+		fz_printf(ctx, out, "(");
+		for (i = 0; i < len; ++i)
+		{
+			unsigned char c = str[i];
+			if (c == '(' || c == ')' || c == '\\')
+				fz_putc(ctx, out, '\\');
+			fz_putc(ctx, out, c);
+		}
+		fz_printf(ctx, out, ")");
+	}
 }
 
 static void
-pdf_buffer_cm(pdf_csi *csi, void *state_)
+pdf_out_TJ(fz_context *ctx, pdf_processor *proc, pdf_obj *array)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f %f %f %f %f cm\n",
-		csi->stack[0], csi->stack[1], csi->stack[2],
-		csi->stack[3], csi->stack[4], csi->stack[5]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	pdf_output_obj(ctx, out, array, 1);
+	fz_printf(ctx, out, " TJ\n");
 }
 
 static void
-pdf_buffer_cs(pdf_csi *csi, void *state_)
+pdf_out_Tj(fz_context *ctx, pdf_processor *proc, char *str, int len)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "/%s cs\n", csi->name);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	put_string(ctx, out, (const unsigned char *)str, len);
+	fz_printf(ctx, out, " Tj\n");
 }
 
 static void
-pdf_buffer_d(pdf_csi *csi, void *state_)
+pdf_out_squote(fz_context *ctx, pdf_processor *proc, char *str, int len)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	pdf_output_obj(state->ctx, state->out, csi->obj, 1);
-	fz_printf(state->ctx, state->out, " %f d\n", csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	put_string(ctx, out, (const unsigned char *)str, len);
+	fz_printf(ctx, out, " '\n");
 }
 
 static void
-pdf_buffer_d0(pdf_csi *csi, void *state_)
+pdf_out_dquote(fz_context *ctx, pdf_processor *proc, float aw, float ac, char *str, int len)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f d0\n", csi->stack[0], csi->stack[1]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f ", aw, ac);
+	put_string(ctx, out, (const unsigned char *)str, len);
+	fz_printf(ctx, out, " \"\n");
 }
 
+/* type 3 fonts */
+
 static void
-pdf_buffer_d1(pdf_csi *csi, void *state_)
+pdf_out_d0(fz_context *ctx, pdf_processor *proc, float wx, float wy)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f %f %f %f %f d1\n",
-		csi->stack[0], csi->stack[1], csi->stack[2],
-		csi->stack[3], csi->stack[4], csi->stack[5]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f d0\n", wx, wy);
 }
 
 static void
-pdf_buffer_f(pdf_csi *csi, void *state_)
+pdf_out_d1(fz_context *ctx, pdf_processor *proc, float wx, float wy, float llx, float lly, float urx, float ury)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "f\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f %f %f %f %f d1\n", wx, wy, llx, lly, urx, ury);
 }
 
+/* color */
+
 static void
-pdf_buffer_fstar(pdf_csi *csi, void *state_)
+pdf_out_CS(fz_context *ctx, pdf_processor *proc, const char *name, fz_colorspace *cs)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "f*\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "/%s CS\n", name);
 }
 
 static void
-pdf_buffer_g(pdf_csi *csi, void *state_)
+pdf_out_cs(fz_context *ctx, pdf_processor *proc, const char *name, fz_colorspace *cs)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f g\n", csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "/%s cs\n", name);
 }
 
 static void
-pdf_buffer_h(pdf_csi *csi, void *state_)
+pdf_out_SC_pattern(fz_context *ctx, pdf_processor *proc, const char *name, pdf_pattern *pat, int n, float *color)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "h\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	int i;
+	for (i = 0; i < n; ++i)
+		fz_printf(ctx, out, "%f ", color[i]);
+	fz_printf(ctx, out, "/%s SCN\n", name);
 }
 
 static void
-pdf_buffer_i(pdf_csi *csi, void *state_)
+pdf_out_sc_pattern(fz_context *ctx, pdf_processor *proc, const char *name, pdf_pattern *pat, int n, float *color)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f i\n", csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	int i;
+	for (i = 0; i < n; ++i)
+		fz_printf(ctx, out, "%f ", color[i]);
+	fz_printf(ctx, out, "/%s scn\n", name);
 }
 
 static void
-pdf_buffer_j(pdf_csi *csi, void *state_)
+pdf_out_SC_shade(fz_context *ctx, pdf_processor *proc, const char *name, fz_shade *shade)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%d j\n", (int)csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "/%s SCN\n", name);
 }
 
 static void
-pdf_buffer_k(pdf_csi *csi, void *state_)
+pdf_out_sc_shade(fz_context *ctx, pdf_processor *proc, const char *name, fz_shade *shade)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f %f %f k\n", csi->stack[0],
-		csi->stack[1], csi->stack[2], csi->stack[3]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "/%s scn\n", name);
 }
 
 static void
-pdf_buffer_l(pdf_csi *csi, void *state_)
+pdf_out_SC_color(fz_context *ctx, pdf_processor *proc, int n, float *color)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f l\n", csi->stack[0], csi->stack[1]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	int i;
+	for (i = 0; i < n; ++i)
+		fz_printf(ctx, out, "%f ", color[i]);
+	fz_printf(ctx, out, "SCN\n");
 }
 
 static void
-pdf_buffer_m(pdf_csi *csi, void *state_)
+pdf_out_sc_color(fz_context *ctx, pdf_processor *proc, int n, float *color)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f m\n", csi->stack[0], csi->stack[1]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	int i;
+	for (i = 0; i < n; ++i)
+		fz_printf(ctx, out, "%f ", color[i]);
+	fz_printf(ctx, out, "scn\n");
 }
 
 static void
-pdf_buffer_n(pdf_csi *csi, void *state_)
+pdf_out_G(fz_context *ctx, pdf_processor *proc, float g)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "n\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f G\n", g);
 }
 
 static void
-pdf_buffer_q(pdf_csi *csi, void *state_)
+pdf_out_g(fz_context *ctx, pdf_processor *proc, float g)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "q\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f g\n", g);
 }
 
 static void
-pdf_buffer_re(pdf_csi *csi, void *state_)
+pdf_out_RG(fz_context *ctx, pdf_processor *proc, float r, float g, float b)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f %f %f re\n", csi->stack[0],
-		csi->stack[1], csi->stack[2], csi->stack[3]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f %f RG\n", r, g, b);
 }
 
 static void
-pdf_buffer_rg(pdf_csi *csi, void *state_)
+pdf_out_rg(fz_context *ctx, pdf_processor *proc, float r, float g, float b)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f %f rg\n",
-		csi->stack[0], csi->stack[1], csi->stack[2]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f %f rg\n", r, g, b);
 }
 
 static void
-pdf_buffer_ri(pdf_csi *csi, void *state_)
+pdf_out_K(fz_context *ctx, pdf_processor *proc, float c, float m, float y, float k)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "/%s ri\n", csi->name);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f %f %f K\n", c, m, y, k);
 }
 
 static void
-pdf_buffer_s(pdf_csi *csi, void *state_)
+pdf_out_k(fz_context *ctx, pdf_processor *proc, float c, float m, float y, float k)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "s\n");
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "%f %f %f %f k\n", c, m, y, k);
 }
 
+/* shadings, images, xobjects */
+
 static void
-pdf_buffer_sc(pdf_csi *csi, void *state_)
+pdf_out_BI(fz_context *ctx, pdf_processor *proc, fz_image *img)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_compressed_buffer *cbuf;
+	fz_buffer *buf;
 	int i;
 
-	for (i = 0; i < csi->top; i++)
-		fz_printf(state->ctx, state->out, "%f ", csi->stack[i]);
-	fz_printf(state->ctx, state->out, "sc\n");
-}
+	if (img == NULL)
+		return;
+	cbuf = img->buffer;
+	if (cbuf == NULL)
+		return;
+	buf = cbuf->buffer;
+	if (buf == NULL)
+		return;
 
-static void
-pdf_buffer_scn(pdf_csi *csi, void *state_)
-{
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-	int i;
+	fz_printf(ctx, out, "BI\n");
+	fz_printf(ctx, out, "/W %d\n", img->w);
+	fz_printf(ctx, out, "/H %d\n", img->h);
+	fz_printf(ctx, out, "/BPC %d\n", img->bpc);
+	if (img->imagemask)
+		fz_printf(ctx, out, "/IM true\n");
+	else if (img->colorspace == fz_device_gray(ctx))
+		fz_printf(ctx, out, "/CS/G\n");
+	else if (img->colorspace == fz_device_rgb(ctx))
+		fz_printf(ctx, out, "/CS/RGB\n");
+	else if (img->colorspace == fz_device_cmyk(ctx))
+		fz_printf(ctx, out, "/CS/CMYK\n");
+	else if (fz_colorspace_is_indexed(ctx, img->colorspace))
+		fz_printf(ctx, out, "/CS/I\n");
+	if (img->interpolate)
+		fz_printf(ctx, out, "/I true\n");
+	fz_printf(ctx, out, "/D[");
+	for (i = 0; i < img->n * 2; ++i)
+	{
+		if (i > 0)
+			fz_putc(ctx, out, ' ');
+		fz_printf(ctx, out, "%g", img->decode[i]);
+	}
+	fz_printf(ctx, out, "]\n");
 
-	for (i = 0; i < csi->top; i++)
-		fz_printf(state->ctx, state->out, "%f ", csi->stack[i]);
-	if (csi->name[0])
-		fz_printf(state->ctx, state->out, "/%s ", csi->name);
-	fz_printf(state->ctx, state->out, "scn\n");
-}
+	switch (cbuf->params.type)
+	{
+	default:
+		fz_throw(ctx, FZ_ERROR_GENERIC, "unknown compressed buffer type");
+		break;
 
-static void
-pdf_buffer_v(pdf_csi *csi, void *state_)
-{
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
+	case FZ_IMAGE_JPEG:
+		fz_printf(ctx, out, "/F/DCT\n");
+		if (cbuf->params.u.jpeg.color_transform != -1)
+			fz_printf(ctx, out, "/DP<</ColorTransform %d>>\n",
+				cbuf->params.u.jpeg.color_transform);
+		break;
+
+	case FZ_IMAGE_FAX:
+		fz_printf(ctx, out, "/F/CCF\n");
+		fz_printf(ctx, out, "/DP<<\n");
+		fz_printf(ctx, out, "/K %d\n", cbuf->params.u.fax.k);
+		if (cbuf->params.u.fax.columns != 1728)
+			fz_printf(ctx, out, "/Columns %d\n", cbuf->params.u.fax.columns);
+		if (cbuf->params.u.fax.rows > 0)
+			fz_printf(ctx, out, "/Rows %d\n", cbuf->params.u.fax.rows);
+		if (cbuf->params.u.fax.end_of_line)
+			fz_printf(ctx, out, "/EndOfLine true\n");
+		if (cbuf->params.u.fax.encoded_byte_align)
+			fz_printf(ctx, out, "/EncodedByteAlign true\n");
+		if (!cbuf->params.u.fax.end_of_block)
+			fz_printf(ctx, out, "/EndOfBlock false\n");
+		if (cbuf->params.u.fax.black_is_1)
+			fz_printf(ctx, out, "/BlackIs1 true\n");
+		if (cbuf->params.u.fax.damaged_rows_before_error > 0)
+			fz_printf(ctx, out, "/DamagedRowsBeforeError %d\n",
+				cbuf->params.u.fax.damaged_rows_before_error);
+		fz_printf(ctx, out, ">>\n");
+		break;
+
+	case FZ_IMAGE_RAW:
+		break;
+
+	case FZ_IMAGE_RLD:
+		fz_printf(ctx, out, "/F/RL\n");
+		break;
+
+	case FZ_IMAGE_FLATE:
+		fz_printf(ctx, out, "/F/Fl\n");
+		if (cbuf->params.u.flate.predictor > 1)
+		{
+			fz_printf(ctx, out, "/DP<<\n");
+			fz_printf(ctx, out, "/Predictor %d\n", cbuf->params.u.flate.predictor);
+			if (cbuf->params.u.flate.columns != 1)
+				fz_printf(ctx, out, "/Columns %d\n", cbuf->params.u.flate.columns);
+			if (cbuf->params.u.flate.colors != 1)
+				fz_printf(ctx, out, "/Colors %d\n", cbuf->params.u.flate.colors);
+			if (cbuf->params.u.flate.bpc != 8)
+				fz_printf(ctx, out, "/BitsPerComponent %d\n", cbuf->params.u.flate.bpc);
+			fz_printf(ctx, out, ">>\n");
+		}
+		break;
+
+	case FZ_IMAGE_LZW:
+		fz_printf(ctx, out, "/F/LZW\n");
+		if (cbuf->params.u.lzw.predictor > 1)
+		{
+			fz_printf(ctx, out, "/DP<<\n");
+			fz_printf(ctx, out, "/Predictor %d\n", cbuf->params.u.lzw.predictor);
+			if (cbuf->params.u.lzw.columns != 1)
+				fz_printf(ctx, out, "/Columns %d\n", cbuf->params.u.lzw.columns);
+			if (cbuf->params.u.lzw.colors != 1)
+				fz_printf(ctx, out, "/Colors %d\n", cbuf->params.u.lzw.colors);
+			if (cbuf->params.u.lzw.bpc != 8)
+				fz_printf(ctx, out, "/BitsPerComponent %d\n", cbuf->params.u.lzw.bpc);
+			if (cbuf->params.u.lzw.early_change != 1)
+				fz_printf(ctx, out, "/EarlyChange %d\n", cbuf->params.u.lzw.early_change);
+			fz_printf(ctx, out, ">>\n");
+		}
+		break;
+	}
 
-	fz_printf(state->ctx, state->out, "%f %f %f %f v\n", csi->stack[0],
-		csi->stack[1], csi->stack[2], csi->stack[3]);
+	fz_printf(ctx, out, "ID\n");
+	fz_write(ctx, out, buf->data, buf->len);
+	fz_printf(ctx, out, "\nEI\n");
 }
 
 static void
-pdf_buffer_w(pdf_csi *csi, void *state_)
+pdf_out_sh(fz_context *ctx, pdf_processor *proc, const char *name, fz_shade *shade)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f w\n", csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "/%s sh\n", name);
 }
 
 static void
-pdf_buffer_y(pdf_csi *csi, void *state_)
+pdf_out_Do_image(fz_context *ctx, pdf_processor *proc, const char *name, fz_image *image)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "%f %f %f %f y\n", csi->stack[0],
-		csi->stack[1], csi->stack[2], csi->stack[3]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "/%s Do\n", name);
 }
 
 static void
-pdf_buffer_Do(pdf_csi *csi, void *state_)
+pdf_out_Do_form(fz_context *ctx, pdf_processor *proc, const char *name, pdf_xobject *xobj, pdf_obj *page_resources)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "/%s Do\n", csi->name);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "/%s Do\n", name);
 }
 
+/* marked content */
+
 static void
-pdf_buffer_Tf(pdf_csi *csi, void *state_)
+pdf_out_MP(fz_context *ctx, pdf_processor *proc, const char *tag)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "/%s %f Tf\n", csi->name, csi->stack[0]);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "/%s MP\n", tag);
 }
 
 static void
-pdf_buffer_gs(pdf_csi *csi, void *state_)
+pdf_out_DP(fz_context *ctx, pdf_processor *proc, const char *tag, pdf_obj *properties)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "/%s gs\n", csi->name);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "/%s ", tag);
+	pdf_output_obj(ctx, out, properties, 1);
+	fz_printf(ctx, out, " DP\n");
 }
 
 static void
-pdf_buffer_sh(pdf_csi *csi, void *state_)
+pdf_out_BMC(fz_context *ctx, pdf_processor *proc, const char *tag)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_printf(state->ctx, state->out, "/%s sh\n", csi->name);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "/%s BMC\n", tag);
 }
 
 static void
-free_processor_buffer(pdf_csi *csi, void *state_)
+pdf_out_BDC(fz_context *ctx, pdf_processor *proc, const char *tag, pdf_obj *properties)
 {
-	pdf_buffer_state *state = (pdf_buffer_state *)state_;
-
-	fz_drop_output(state->ctx, state->out);
-	fz_free(state->ctx, state);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "/%s ", tag);
+	pdf_output_obj(ctx, out, properties, 1);
+	fz_printf(ctx, out, " BDC\n");
 }
 
 static void
-process_annot(pdf_csi *csi, void *state, pdf_obj *resources, pdf_annot *annot)
+pdf_out_EMC(fz_context *ctx, pdf_processor *proc)
 {
-	fz_context *ctx = csi->ctx;
-	pdf_xobject *xobj = annot->ap;
-
-	/* Avoid infinite recursion */
-	if (xobj == NULL || pdf_mark_obj(ctx, xobj->me))
-		return;
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "EMC\n");
+}
 
-	fz_try(ctx)
-	{
-		if (xobj->resources)
-			resources = xobj->resources;
+/* compatibility */
 
-		pdf_process_contents_object(csi, resources, xobj->contents);
-	}
-	fz_always(ctx)
-	{
-		pdf_unmark_obj(ctx, xobj->me);
-	}
-	fz_catch(ctx)
-	{
-		fz_rethrow(ctx);
-	}
+static void
+pdf_out_BX(fz_context *ctx, pdf_processor *proc)
+{
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "BX\n");
 }
 
 static void
-process_stream(pdf_csi *csi, void *state, pdf_lexbuf *buf)
+pdf_out_EX(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_process_stream(csi, buf);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_printf(ctx, out, "EX\n");
 }
 
 static void
-process_contents(pdf_csi *csi, void *state, pdf_obj *resources, pdf_obj *contents)
+pdf_drop_imp_output_processor(fz_context *ctx, pdf_processor *proc)
 {
-	pdf_process_contents_object(csi, resources, contents);
+	fz_output *out = ((pdf_output_processor*)proc)->out;
+	fz_drop_output(ctx, out);
 }
 
-static const pdf_processor pdf_processor_buffer =
+static pdf_processor *
+pdf_new_output_processor(fz_context *ctx, fz_output *out)
 {
+	pdf_output_processor *proc = pdf_new_processor(ctx, sizeof *proc);
 	{
-	pdf_buffer_dquote,
-	pdf_buffer_squote,
-	pdf_buffer_B,
-	pdf_buffer_Bstar,
-	pdf_buffer_BDC,
-	pdf_buffer_BI,
-	pdf_buffer_BMC,
-	pdf_buffer_BT,
-	pdf_buffer_BX,
-	pdf_buffer_CS,
-	pdf_buffer_DP,
-	pdf_buffer_EMC,
-	pdf_buffer_ET,
-	pdf_buffer_EX,
-	pdf_buffer_F,
-	pdf_buffer_G,
-	pdf_buffer_J,
-	pdf_buffer_K,
-	pdf_buffer_M,
-	pdf_buffer_MP,
-	pdf_buffer_Q,
-	pdf_buffer_RG,
-	pdf_buffer_S,
-	pdf_buffer_SC,
-	pdf_buffer_SCN,
-	pdf_buffer_Tstar,
-	pdf_buffer_TD,
-	pdf_buffer_TJ,
-	pdf_buffer_TL,
-	pdf_buffer_Tc,
-	pdf_buffer_Td,
-	pdf_buffer_Tj,
-	pdf_buffer_Tm,
-	pdf_buffer_Tr,
-	pdf_buffer_Ts,
-	pdf_buffer_Tw,
-	pdf_buffer_Tz,
-	pdf_buffer_W,
-	pdf_buffer_Wstar,
-	pdf_buffer_b,
-	pdf_buffer_bstar,
-	pdf_buffer_c,
-	pdf_buffer_cm,
-	pdf_buffer_cs,
-	pdf_buffer_d,
-	pdf_buffer_d0,
-	pdf_buffer_d1,
-	pdf_buffer_f,
-	pdf_buffer_fstar,
-	pdf_buffer_g,
-	pdf_buffer_h,
-	pdf_buffer_i,
-	pdf_buffer_j,
-	pdf_buffer_k,
-	pdf_buffer_l,
-	pdf_buffer_m,
-	pdf_buffer_n,
-	pdf_buffer_q,
-	pdf_buffer_re,
-	pdf_buffer_rg,
-	pdf_buffer_ri,
-	pdf_buffer_s,
-	pdf_buffer_sc,
-	pdf_buffer_scn,
-	pdf_buffer_v,
-	pdf_buffer_w,
-	pdf_buffer_y,
-	pdf_buffer_Do,
-	pdf_buffer_Tf,
-	pdf_buffer_gs,
-	pdf_buffer_sh,
-	free_processor_buffer
-	},
-	process_annot,
-	process_stream,
-	process_contents
-};
+		proc->super.drop_imp = pdf_drop_imp_output_processor;
+
+		/* general graphics state */
+		proc->super.op_w = pdf_out_w;
+		proc->super.op_j = pdf_out_j;
+		proc->super.op_J = pdf_out_J;
+		proc->super.op_M = pdf_out_M;
+		proc->super.op_d = pdf_out_d;
+		proc->super.op_ri = pdf_out_ri;
+		proc->super.op_i = pdf_out_i;
+		proc->super.op_gs_begin = pdf_out_gs_begin;
+		proc->super.op_gs_end = pdf_out_gs_end;
+
+		/* transparency graphics state */
+		proc->super.op_gs_BM = NULL;
+		proc->super.op_gs_CA = NULL;
+		proc->super.op_gs_ca = NULL;
+		proc->super.op_gs_SMask = NULL;
+
+		/* special graphics state */
+		proc->super.op_q = pdf_out_q;
+		proc->super.op_Q = pdf_out_Q;
+		proc->super.op_cm = pdf_out_cm;
+
+		/* path construction */
+		proc->super.op_m = pdf_out_m;
+		proc->super.op_l = pdf_out_l;
+		proc->super.op_c = pdf_out_c;
+		proc->super.op_v = pdf_out_v;
+		proc->super.op_y = pdf_out_y;
+		proc->super.op_h = pdf_out_h;
+		proc->super.op_re = pdf_out_re;
+
+		/* path painting */
+		proc->super.op_S = pdf_out_S;
+		proc->super.op_s = pdf_out_s;
+		proc->super.op_F = pdf_out_F;
+		proc->super.op_f = pdf_out_f;
+		proc->super.op_fstar = pdf_out_fstar;
+		proc->super.op_B = pdf_out_B;
+		proc->super.op_Bstar = pdf_out_Bstar;
+		proc->super.op_b = pdf_out_b;
+		proc->super.op_bstar = pdf_out_bstar;
+		proc->super.op_n = pdf_out_n;
+
+		/* clipping paths */
+		proc->super.op_W = pdf_out_W;
+		proc->super.op_Wstar = pdf_out_Wstar;
+
+		/* text objects */
+		proc->super.op_BT = pdf_out_BT;
+		proc->super.op_ET = pdf_out_ET;
+
+		/* text state */
+		proc->super.op_Tc = pdf_out_Tc;
+		proc->super.op_Tw = pdf_out_Tw;
+		proc->super.op_Tz = pdf_out_Tz;
+		proc->super.op_TL = pdf_out_TL;
+		proc->super.op_Tf = pdf_out_Tf;
+		proc->super.op_Tr = pdf_out_Tr;
+		proc->super.op_Ts = pdf_out_Ts;
+
+		/* text positioning */
+		proc->super.op_Td = pdf_out_Td;
+		proc->super.op_TD = pdf_out_TD;
+		proc->super.op_Tm = pdf_out_Tm;
+		proc->super.op_Tstar = pdf_out_Tstar;
+
+		/* text showing */
+		proc->super.op_TJ = pdf_out_TJ;
+		proc->super.op_Tj = pdf_out_Tj;
+		proc->super.op_squote = pdf_out_squote;
+		proc->super.op_dquote = pdf_out_dquote;
+
+		/* type 3 fonts */
+		proc->super.op_d0 = pdf_out_d0;
+		proc->super.op_d1 = pdf_out_d1;
+
+		/* color */
+		proc->super.op_CS = pdf_out_CS;
+		proc->super.op_cs = pdf_out_cs;
+		proc->super.op_SC_color = pdf_out_SC_color;
+		proc->super.op_sc_color = pdf_out_sc_color;
+		proc->super.op_SC_pattern = pdf_out_SC_pattern;
+		proc->super.op_sc_pattern = pdf_out_sc_pattern;
+		proc->super.op_SC_shade = pdf_out_SC_shade;
+		proc->super.op_sc_shade = pdf_out_sc_shade;
+
+		proc->super.op_G = pdf_out_G;
+		proc->super.op_g = pdf_out_g;
+		proc->super.op_RG = pdf_out_RG;
+		proc->super.op_rg = pdf_out_rg;
+		proc->super.op_K = pdf_out_K;
+		proc->super.op_k = pdf_out_k;
+
+		/* shadings, images, xobjects */
+		proc->super.op_BI = pdf_out_BI;
+		proc->super.op_sh = pdf_out_sh;
+		proc->super.op_Do_image = pdf_out_Do_image;
+		proc->super.op_Do_form = pdf_out_Do_form;
+
+		/* marked content */
+		proc->super.op_MP = pdf_out_MP;
+		proc->super.op_DP = pdf_out_DP;
+		proc->super.op_BMC = pdf_out_BMC;
+		proc->super.op_BDC = pdf_out_BDC;
+		proc->super.op_EMC = pdf_out_EMC;
+
+		/* compatibility */
+		proc->super.op_BX = pdf_out_BX;
+		proc->super.op_EX = pdf_out_EX;
+	}
 
-pdf_process *pdf_init_process_buffer(fz_context *ctx, pdf_process *process, fz_buffer *buffer)
-{
-	fz_output *out = fz_new_output_with_buffer(ctx, buffer);
-	pdf_buffer_state *p = NULL;
+	proc->out = out;
 
-	fz_var(p);
+	return (pdf_processor*)proc;
+}
 
+pdf_processor *
+pdf_new_buffer_processor(fz_context *ctx, fz_buffer *buffer)
+{
+	pdf_processor *proc;
+	fz_output *out = fz_new_output_with_buffer(ctx, buffer);
 	fz_try(ctx)
 	{
-		p = fz_malloc_struct(ctx, pdf_buffer_state);
-		p->buffer = buffer;
-		p->out = out;
-		p->ctx = ctx;
+		proc = pdf_new_output_processor(ctx, out);
 	}
 	fz_catch(ctx)
 	{
 		fz_drop_output(ctx, out);
 		fz_rethrow(ctx);
 	}
-
-	process->state = p;
-	process->processor = &pdf_processor_buffer;
-	return process;
+	return proc;
 }