// Copyright (C) 2004-2025 Artifex Software, Inc.
//
// This file is part of MuPDF.
//
// MuPDF is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
// details.
//
// You should have received a copy of the GNU Affero General Public License
// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
//
// Alternative licensing terms are available from the licensor.
// For commercial licensing, see <https://www.artifex.com/> or contact
// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
// CA 94129, USA, for further information.

#include "mupdf/fitz.h"

#include <limits.h>
#include <stdlib.h>
#include <string.h>

/* Lifted from ghostscript gdevjlm.h */
/*
 * The notion that there is such a thing as a "PCL printer" is a fiction: no
 * two "PCL" printers, even at the same PCL level, have identical command
 * sets. (The H-P documentation isn't fully accurate either; for example,
 * it doesn't reveal that the DeskJet printers implement anything beyond PCL
 * 3.)
 *
 * This file contains feature definitions for a generic monochrome PCL
 * driver (gdevdljm.c), and the specific feature values for all such
 * printers that Ghostscript currently supports.
 */

/* Printer spacing capabilities. Include at most one of these. */
#define PCL_NO_SPACING	0	/* no vertical spacing capability, must be 0 */
#define PCL3_SPACING	1	/* <ESC>*p+<n>Y (PCL 3) */
#define PCL4_SPACING	2	/* <ESC>*b<n>Y (PCL 4) */
#define PCL5_SPACING	4	/* <ESC>*b<n>Y and clear seed row (PCL 5) */
/* The following is only used internally. */
#define PCL_ANY_SPACING \
	(PCL3_SPACING | PCL4_SPACING | PCL5_SPACING)

/* Individual printer properties. Any subset of these may be included. */
#define PCL_MODE_2_COMPRESSION		8	/* compression mode 2 supported */
						/* (PCL 4) */
#define PCL_MODE_3_COMPRESSION		16	/* compression modes 2 & 3 supported */
						/* (PCL 5) */
#define PCL_END_GRAPHICS_DOES_RESET	32	/* <esc>*rB resets all parameters */
#define PCL_HAS_DUPLEX			64	/* <esc>&l<duplex>S supported */
#define PCL_CAN_SET_PAPER_SIZE		128	/* <esc>&l<sizecode>A supported */
#define PCL_CAN_PRINT_COPIES		256	/* <esc>&l<copies>X supported */
#define HACK__IS_A_LJET4PJL		512
#define HACK__IS_A_OCE9050		1024
#define PCL_HAS_ORIENTATION             2048
#define PCL_CAN_SET_CUSTOM_PAPER_SIZE   4096
#define PCL_HAS_RICOH_PAPER_SIZES       8192

/* Shorthands for the most common spacing/compression combinations. */
#define PCL_MODE0 PCL3_SPACING
#define PCL_MODE0NS PCL_NO_SPACING
#define PCL_MODE2 (PCL4_SPACING | PCL_MODE_2_COMPRESSION)
#define PCL_MODE2P (PCL_NO_SPACING | PCL_MODE_2_COMPRESSION)
#define PCL_MODE3 (PCL5_SPACING | PCL_MODE_3_COMPRESSION)
#define PCL_MODE3NS (PCL_NO_SPACING | PCL_MODE_3_COMPRESSION)

#define MIN_SKIP_LINES 7
static const char *const from2to3 = "\033*b3M";
static const char *const from3to2 = "\033*b2M";
static const int penalty_from2to3 = 5; /* strlen(from2to3); */
static const int penalty_from3to2 = 5; /* strlen(from3to2); */

/* Generic */
static const fz_pcl_options fz_pcl_options_generic =
{
	(PCL_MODE2 | PCL_END_GRAPHICS_DOES_RESET | PCL_CAN_SET_PAPER_SIZE | PCL_CAN_SET_CUSTOM_PAPER_SIZE),
	"\033&k1W\033*b2M",
	"\033&k1W\033*b2M"
};

/* H-P DeskJet */
static const fz_pcl_options fz_pcl_options_ljet4 =
{
	(PCL_MODE2 | PCL_END_GRAPHICS_DOES_RESET | PCL_CAN_SET_PAPER_SIZE),
	"\033&k1W\033*b2M",
	"\033&k1W\033*b2M"
};

/* H-P DeskJet 500 */
static const fz_pcl_options fz_pcl_options_dj500 =
{
	(PCL_MODE3 | PCL_END_GRAPHICS_DOES_RESET | PCL_CAN_SET_PAPER_SIZE),
	"\033&k1W",
	"\033&k1W"
};

/* Kyocera FS-600 */
static const fz_pcl_options fz_pcl_options_fs600 =
{
	(PCL_MODE3 | PCL_CAN_SET_PAPER_SIZE | PCL_CAN_PRINT_COPIES),
	"\033*r0F\033&u%dD",
	"\033*r0F\033&u%dD"
};

/* H-P original LaserJet */
/* H-P LaserJet Plus */
static const fz_pcl_options fz_pcl_options_lj =
{
	(PCL_MODE0),
	"\033*b0M",
	"\033*b0M"
};

/* H-P LaserJet IIp, IId */
static const fz_pcl_options fz_pcl_options_lj2 =
{
	(PCL_MODE2P | PCL_CAN_SET_PAPER_SIZE),
	"\033*r0F\033*b2M",
	"\033*r0F\033*b2M"
};

/* H-P LaserJet III* */
static const fz_pcl_options fz_pcl_options_lj3 =
{
	(PCL_MODE3 | PCL_CAN_SET_PAPER_SIZE | PCL_CAN_PRINT_COPIES),
	"\033&l-180u36Z\033*r0F",
	"\033&l-180u36Z\033*r0F"
};

/* H-P LaserJet IIId */
static const fz_pcl_options fz_pcl_options_lj3d =
{
	(PCL_MODE3 | PCL_HAS_DUPLEX | PCL_CAN_SET_PAPER_SIZE | PCL_CAN_PRINT_COPIES),
	"\033&l-180u36Z\033*r0F",
	"\033&l180u36Z\033*r0F"
};

/* H-P LaserJet 4 */
static const fz_pcl_options fz_pcl_options_lj4 =
{
	(PCL_MODE3 | PCL_CAN_SET_PAPER_SIZE | PCL_CAN_PRINT_COPIES),
	"\033&l-180u36Z\033*r0F\033&u%dD",
	"\033&l-180u36Z\033*r0F\033&u%dD"
};

/* H-P LaserJet 4 PL */
static const fz_pcl_options fz_pcl_options_lj4pl =
{
	(PCL_MODE3 | PCL_CAN_SET_PAPER_SIZE | PCL_CAN_PRINT_COPIES | HACK__IS_A_LJET4PJL),
	"\033&l-180u36Z\033*r0F\033&u%dD",
	"\033&l-180u36Z\033*r0F\033&u%dD"
};

/* H-P LaserJet 4d */
static const fz_pcl_options fz_pcl_options_lj4d =
{
	(PCL_MODE3 | PCL_HAS_DUPLEX | PCL_CAN_SET_PAPER_SIZE | PCL_CAN_PRINT_COPIES),
	"\033&l-180u36Z\033*r0F\033&u%dD",
	"\033&l180u36Z\033*r0F\033&u%dD"
};

/* H-P 2563B line printer */
static const fz_pcl_options fz_pcl_options_lp2563b =
{
	(PCL_MODE0NS | PCL_CAN_SET_PAPER_SIZE),
	"\033*b0M",
	"\033*b0M"
};

/* OCE 9050 line printer */
static const fz_pcl_options fz_pcl_options_oce9050 =
{
	(PCL_MODE3NS | PCL_CAN_SET_PAPER_SIZE | HACK__IS_A_OCE9050),
	"\033*b0M",
	"\033*b0M"
};

enum {
	eLetterPaper = 0,
	eLegalPaper,
	eA4Paper,
	eExecPaper,
	eLedgerPaper,
	eA3Paper,
	eCOM10Envelope,
	eMonarchEnvelope,
	eC5Envelope,
	eDLEnvelope,
	eJB4Paper,
	eJB5Paper,
	eB5Envelope,
	eB5Paper,                   /* 2.1 */
	eJPostcard,
	eJDoublePostcard,
	eA5Paper,
	eA6Paper,                   /* 2.0 */
	eJB6Paper,                  /* 2.0 */
	eJIS8K,                     /* 2.1 */
	eJIS16K,                    /* 2.1 */
	eJISExec,                   /* 2.1 */
	eDefaultPaperSize = 96,     /* 2.1 */
	eCustomPaperSize = 101,
	eB6JIS = 201,               /* non-standard, Ricoh printers */
	eC6Envelope = 202,          /* non-standard, Ricoh printers */
	e8Kai  = 203,               /* non-standard, Ricoh printers */
	e16Kai = 204,               /* non-standard, Ricoh printers */
	e12x18 = 205,               /* non-standard, Ricoh printers */
	e13x19_2 = 212,             /* non-standard, Ricoh printers */
	e13x19 = 213,               /* non-standard, Ricoh printers */
	e12_6x19_2 = 214,           /* non-standard, Ricoh printers */
	e12_6x18_5 = 215,           /* non-standard, Ricoh printers */
	e13x18  = 216,              /* non-standard, Ricoh printers */
	eSRA3 = 217,                /* non-standard, Ricoh printers */
	eSRA4 = 218,                /* non-standard, Ricoh printers */
	e226x310 = 219,             /* non-standard, Ricoh printers */
	e310x432 = 220,             /* non-standard, Ricoh printers */
	eEngQuatro = 221,           /* non-standard, Ricoh printers */
	e11x14 = 222,               /* non-standard, Ricoh printers */
	e11x15 = 223,               /* non-standard, Ricoh printers */
	e10x14 = 224,               /* non-standard, Ricoh printers */
};

static void copy_opts(fz_pcl_options *dst, const fz_pcl_options *src)
{
	if (dst)
		*dst = *src;
}

const char *fz_pcl_write_options_usage =
	"PCL output options:\n"
	"\tcolorspace=mono: render 1-bit black and white page\n"
	"\tcolorspace=rgb: render full color page\n"
	"\tpreset=generic|ljet4|dj500|fs600|lj|lj2|lj3|lj3d|lj4|lj4pl|lj4d|lp2563b|oce9050\n"
	"\tspacing=0: No vertical spacing capability\n"
	"\tspacing=1: PCL 3 spacing (<ESC>*p+<n>Y)\n"
	"\tspacing=2: PCL 4 spacing (<ESC>*b<n>Y)\n"
	"\tspacing=3: PCL 5 spacing (<ESC>*b<n>Y and clear seed row)\n"
	"\tmode2: Enable mode 2 graphics compression\n"
	"\tmode3: Enable mode 3 graphics compression\n"
	"\teog_reset: End of graphics (<ESC>*rB) resets all parameters\n"
	"\thas_duplex: Duplex supported (<ESC>&l<duplex>S)\n"
	"\thas_papersize: Papersize setting supported (<ESC>&l<sizecode>A)\n"
	"\thas_copies: Number of copies supported (<ESC>&l<copies>X)\n"
	"\tis_ljet4pjl: Disable/Enable HP 4PJL model-specific output\n"
	"\tis_oce9050: Disable/Enable Oce 9050 model-specific output\n"
	"\n";

void fz_pcl_preset(fz_context *ctx, fz_pcl_options *opts, const char *preset)
{
	if (preset == NULL || *preset == 0 || !strcmp(preset, "generic"))
		copy_opts(opts, &fz_pcl_options_generic);
	else if (!strcmp(preset, "ljet4"))
		copy_opts(opts, &fz_pcl_options_ljet4);
	else if (!strcmp(preset, "dj500"))
		copy_opts(opts, &fz_pcl_options_dj500);
	else if (!strcmp(preset, "fs600"))
		copy_opts(opts, &fz_pcl_options_fs600);
	else if (!strcmp(preset, "lj"))
		copy_opts(opts, &fz_pcl_options_lj);
	else if (!strcmp(preset, "lj2"))
		copy_opts(opts, &fz_pcl_options_lj2);
	else if (!strcmp(preset, "lj3"))
		copy_opts(opts, &fz_pcl_options_lj3);
	else if (!strcmp(preset, "lj3d"))
		copy_opts(opts, &fz_pcl_options_lj3d);
	else if (!strcmp(preset, "lj4"))
		copy_opts(opts, &fz_pcl_options_lj4);
	else if (!strcmp(preset, "lj4pl"))
		copy_opts(opts, &fz_pcl_options_lj4pl);
	else if (!strcmp(preset, "lj4d"))
		copy_opts(opts, &fz_pcl_options_lj4d);
	else if (!strcmp(preset, "lp2563b"))
		copy_opts(opts, &fz_pcl_options_lp2563b);
	else if (!strcmp(preset, "oce9050"))
		copy_opts(opts, &fz_pcl_options_oce9050);
	else
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "Unknown preset '%s'", preset);
}

void fz_init_pcl_options(fz_context *ctx, fz_pcl_options *opts)
{
	memset(opts, 0, sizeof *opts);

	fz_pcl_preset(ctx, opts, "generic");
}

fz_pcl_options *
fz_parse_pcl_options(fz_context *ctx, fz_pcl_options *opts, const char *args)
{
	fz_options *options = fz_new_options(ctx, args);
	fz_try(ctx)
	{
		fz_init_pcl_options(ctx, opts);
		fz_apply_pcl_options(ctx, opts, options);
		fz_throw_on_unused_options(ctx, options, "pcl");
	}
	fz_always(ctx)
		fz_drop_options(ctx, options);
	fz_catch(ctx)
		fz_rethrow(ctx);

	return opts;
}

void
fz_apply_pcl_options(fz_context *ctx, fz_pcl_options *opts, fz_options *args)
{
	const char *val;

	if (fz_lookup_option(ctx, args, "preset", &val))
		fz_pcl_preset(ctx, opts, val);

	if (fz_lookup_option(ctx, args, "spacing", &val))
	{
		switch (atoi(val))
		{
		case 0: opts->features &= ~PCL_ANY_SPACING; break;
		case 1: opts->features = (opts->features & ~PCL_ANY_SPACING) | PCL3_SPACING; break;
		case 2: opts->features = (opts->features & ~PCL_ANY_SPACING) | PCL4_SPACING; break;
		case 3: opts->features = (opts->features & ~PCL_ANY_SPACING) | PCL5_SPACING; break;
		default: fz_throw(ctx, FZ_ERROR_ARGUMENT, "Unsupported PCL spacing %d (0-3 only)", atoi(val));
		}
	}
	if (fz_lookup_option(ctx, args, "mode2", &val))
	{
		if (!strcmp(val, "no"))
			opts->features &= ~PCL_MODE_2_COMPRESSION;
		else if (!strcmp(val, "yes"))
			opts->features |= PCL_MODE_2_COMPRESSION;
		else
			fz_throw(ctx, FZ_ERROR_ARGUMENT, "Expected 'yes' or 'no' for mode2 value");
	}
	if (fz_lookup_option(ctx, args, "mode3", &val))
	{
		if (!strcmp(val, "no"))
			opts->features &= ~PCL_MODE_3_COMPRESSION;
		else if (!strcmp(val, "yes"))
			opts->features |= PCL_MODE_3_COMPRESSION;
		else
			fz_throw(ctx, FZ_ERROR_ARGUMENT, "Expected 'yes' or 'no' for mode3 value");
	}
	if (fz_lookup_option(ctx, args, "eog_reset", &val))
	{
		if (!strcmp(val, "no"))
			opts->features &= ~PCL_END_GRAPHICS_DOES_RESET;
		else if (!strcmp(val, "yes"))
			opts->features |= PCL_END_GRAPHICS_DOES_RESET;
		else
			fz_throw(ctx, FZ_ERROR_ARGUMENT, "Expected 'yes' or 'no' for eog_reset value");
	}
	if (fz_lookup_option(ctx, args, "has_duplex", &val))
	{
		if (!strcmp(val, "no"))
			opts->features &= ~PCL_HAS_DUPLEX;
		else if (!strcmp(val, "yes"))
			opts->features |= PCL_HAS_DUPLEX;
		else
			fz_throw(ctx, FZ_ERROR_ARGUMENT, "Expected 'yes' or 'no' for has_duplex value");
	}
	if (fz_lookup_option(ctx, args, "has_papersize", &val))
	{
		if (!strcmp(val, "no"))
			opts->features &= ~PCL_CAN_SET_PAPER_SIZE;
		else if (!strcmp(val, "yes"))
			opts->features |= PCL_CAN_SET_PAPER_SIZE;
		else
			fz_throw(ctx, FZ_ERROR_ARGUMENT, "Expected 'yes' or 'no' for has_papersize value");
	}
	if (fz_lookup_option(ctx, args, "has_copies", &val))
	{
		if (!strcmp(val, "no"))
			opts->features &= ~PCL_CAN_PRINT_COPIES;
		else if (!strcmp(val, "yes"))
			opts->features |= PCL_CAN_PRINT_COPIES;
		else
			fz_throw(ctx, FZ_ERROR_ARGUMENT, "Expected 'yes' or 'no' for has_papersize value");
	}
	if (fz_lookup_option(ctx, args, "is_ljet4pjl", &val))
	{
		if (!strcmp(val, "no"))
			opts->features &= ~HACK__IS_A_LJET4PJL;
		else if (!strcmp(val, "yes"))
			opts->features |= HACK__IS_A_LJET4PJL;
		else
			fz_throw(ctx, FZ_ERROR_ARGUMENT, "Expected 'yes' or 'no' for is_ljet4pjl value");
	}
	if (fz_lookup_option(ctx, args, "is_oce9050", &val))
	{
		if (!strcmp(val, "no"))
			opts->features &= ~HACK__IS_A_OCE9050;
		else if (!strcmp(val, "yes"))
			opts->features |= HACK__IS_A_OCE9050;
		else
			fz_throw(ctx, FZ_ERROR_ARGUMENT, "Expected 'yes' or 'no' for is_oce9050 value");
	}
	if (fz_lookup_option(ctx, args, "media_position", &val))
	{
		opts->media_position = fz_atoi(val);
		opts->media_position_set = 1;
	}

	fz_validate_options(ctx, args, "pcl");
}

static void
make_init(fz_pcl_options *pcl, char *buf, unsigned long len, const char *str, int res)
{
	int paper_source = -1;

	fz_snprintf(buf, len, str, res);

	if (pcl->manual_feed_set && pcl->manual_feed)
		paper_source = 2;
	else if (pcl->media_position_set && pcl->media_position >= 0)
		paper_source = pcl->media_position;
	if (paper_source >= 0)
	{
		char buf2[40];
		fz_snprintf(buf2, sizeof(buf2), "\033&l%dH", paper_source);
		strncat(buf, buf2, len);
	}
}

static void
pcl_header(fz_context *ctx, fz_output *out, fz_pcl_options *pcl, int num_copies, int xres, int yres, int w, int h)
{
	char odd_page_init[80];
	char even_page_init[80];

	make_init(pcl, odd_page_init, sizeof(odd_page_init), pcl->odd_page_init, xres);
	make_init(pcl, even_page_init, sizeof(even_page_init), pcl->even_page_init, xres);

	if (pcl->page_count == 0)
	{
		if (pcl->features & HACK__IS_A_LJET4PJL)
			fz_write_string(ctx, out, "\033%-12345X@PJL\r\n@PJL ENTER LANGUAGE = PCL\r\n");
		fz_write_string(ctx, out, "\033E"); /* reset printer */
		/* Reset the margins */
		/* ESC & l # E  =  Top Margin in decipoints */
		fz_write_string(ctx, out, "\033&l0E");
		/* ESC & l # U  =  Left (Long-Edge) offset registration */
		/* I don't like it that we have to hardcode -180 decipoints in here, but it seems to work. */
		fz_write_string(ctx, out, "\033&l-180U");
		/* ESC & l # Z  =  Top (Short-Edge) offset registration */
		fz_write_string(ctx, out, "\033&l0Z");
		/* If the printer supports it, set orientation */
		if (pcl->features & PCL_HAS_ORIENTATION)
		{
			fz_write_printf(ctx, out, "\033&l%dO", pcl->orientation);
		}
		/* If the printer supports it, set the paper size */
		/* based on the actual requested size. */
		if (pcl->features & PCL_CAN_SET_PAPER_SIZE)
		{
			/* It probably never hurts to define the page explicitly */
			{
				int decipointw = (w * 720 + (xres>>1)) / xres;
				int decipointh = (h * 720 + (yres>>1)) / yres;

				fz_write_printf(ctx, out, "\033&f%dI", decipointw);
				fz_write_printf(ctx, out, "\033&f%dJ", decipointh);
			}
			fz_write_printf(ctx, out, "\033&l%dA", pcl->paper_size);
		}
		/* If printer can duplex, set duplex mode appropriately. */
		if (pcl->features & PCL_HAS_DUPLEX)
		{
			if (pcl->duplex_set)
			{
				if (pcl->duplex)
				{
					if (!pcl->tumble)
						fz_write_string(ctx, out, "\033&l1S");
					else
						fz_write_string(ctx, out, "\033&l2S");
				}
				else
					fz_write_string(ctx, out, "\033&l0S");
			}
			else
			{
				/* default to duplex for this printer */
				fz_write_string(ctx, out, "\033&l1S");
			}
		}
	}

	/* Put out per-page initialization. */
	/* In duplex mode the sheet is already in process, so there are some
	 * commands which must not be sent to the printer for the 2nd page,
	 * as these commands will cause the printer to eject the sheet with
	 * only the 1st page printed. These commands are:
	 * \033&l%dA (setting paper size)
	 * \033&l%dH (setting paper tray)
	 * in simplex mode we set these parameters for each page,
	 * in duplex mode we set these parameters for each odd page
	 */

	if ((pcl->features & PCL_HAS_DUPLEX) && pcl->duplex_set && pcl->duplex)
	{
		/* We are printing duplex, so change margins as needed */
		if (((pcl->page_count/num_copies)%2) == 0)
		{
			if (pcl->page_count != 0 && (pcl->features & PCL_CAN_SET_PAPER_SIZE))
			{
				fz_write_printf(ctx, out, "\033&l%dA", pcl->paper_size);
			}
			fz_write_string(ctx, out, "\033&l0o0l0E");
			fz_write_string(ctx, out, odd_page_init);
		}
		else
			fz_write_string(ctx, out, even_page_init);
	}
	else
	{
		if (pcl->features & PCL_CAN_SET_PAPER_SIZE)
		{
			fz_write_printf(ctx, out, "\033&l%dA", pcl->paper_size);
		}
		fz_write_string(ctx, out, "\033&l0o0l0E");
		fz_write_string(ctx, out, odd_page_init);
	}

	fz_write_printf(ctx, out, "\033&l%dX", num_copies); /* # of copies */

	/* End raster graphics, position cursor at top. */
	fz_write_string(ctx, out, "\033*rB\033*p0x0Y");

	/* The DeskJet and DeskJet Plus reset everything upon */
	/* receiving \033*rB, so we must reinitialize graphics mode. */
	if (pcl->features & PCL_END_GRAPHICS_DOES_RESET)
	{
		fz_write_string(ctx, out, odd_page_init); /* Assume this does the right thing */
		fz_write_printf(ctx, out, "\033&l%dX", num_copies); /* # of copies */
	}

	/* Set resolution. */
	fz_write_printf(ctx, out, "\033*t%dR", xres);

	/* Raster units */
	/* 96,100,120,144,150,160,180,200,225,240,288,300,360,400,450,480,600,720,800,900,1200,1440,1800,2400,3600,7200 */
	/* FIXME: xres vs yres */
	fz_write_printf(ctx, out, "\033&u%dD", xres);

	pcl->page_count++;
}

typedef struct pcl_papersize_s
{
	int code;
	const char *text;
	int width;
	int height;
} pcl_papersize;

static const pcl_papersize papersizes[] =
{
	{ eLetterPaper,      "letter",       2550, 3300},
	{ eLegalPaper,       "legal",        2550, 4200},
	{ eA4Paper,          "a4",           2480, 3507},
	{ eExecPaper,        "executive",    2175, 3150},
	{ eLedgerPaper,      "ledger",       3300, 5100},
	{ eA3Paper,          "a3",           3507, 4960},
	{ eCOM10Envelope,    "com10",        1237, 2850},
	{ eMonarchEnvelope,  "monarch",      1162, 2250},
	{ eC5Envelope,       "c5",           1913, 2704},
	{ eDLEnvelope,       "dl",           1299, 2598},
	{ eJB4Paper,         "jisb4",        3035, 4299},
	{ eJB4Paper,         "jis b4",       3035, 4299},
	{ eJB5Paper,         "jisb5",        2150, 3035},
	{ eJB5Paper,         "jis b5",       2150, 3035},
	{ eB5Envelope,       "b5",           2078, 2952},
	{ eB5Paper,          "b5paper",      2150, 3035},
	{ eJPostcard,        "jpost",        1181, 1748},
	{ eJDoublePostcard,  "jpostd",       2362, 1748},
	{ eA5Paper,          "a5",           1748, 2480},
	{ eA6Paper,          "a6",           1240, 1748},
	{ eJB6Paper,         "jisb6",        1512, 2150},
	{ eJIS8K,            "jis8K",        3154, 4606},
	{ eJIS16K,           "jis16K",       2303, 3154},
	{ eJISExec,          "jisexec",      2551, 3898},
	{ eB6JIS,            "B6 (JIS)",     1512, 2150},
	{ eC6Envelope,       "C6",           1345, 1912},
	{ e8Kai,             "8Kai",         3154, 4608},
	{ e16Kai,            "16Kai",        2304, 3154},
	{ e12x18,            "12x18",        3600, 5400},
	{ e13x19_2,          "13x19.2",      3900, 5758},
	{ e13x19,            "13x19",        3900, 5700},
	{ e12_6x19_2,        "12.6x19.2",    3779, 5758},
	{ e12_6x18_5,        "12.6x18.5",    3779, 5550},
	{ e13x18,            "13x18",        3900, 5400},
	{ eSRA3,             "SRA3",         3779, 5316},
	{ eSRA4,             "SRA4",         2658, 3779},
	{ e226x310,          "226x310",      2670, 3662},
	{ e310x432,          "310x432",      3662, 5104},
	{ eEngQuatro,        "EngQuatro",    2400, 3000},
	{ e11x14,            "11x14",        3300, 4200},
	{ e11x15,            "11x15",        3300, 4500},
	{ e10x14,            "10x14",        3000, 4200}
};

static void guess_paper_size(fz_pcl_options *pcl, int w, int h, int xres, int yres)
{
	int size;
	int rotated = 0;

	/* If we've been given a paper size, live with it */
	if (pcl->paper_size != 0)
		return;

	w = w * 300 / xres;
	h = h * 300 / xres;

	/* Look for an exact match */
	for (size = 0; size < (int)nelem(papersizes); size++)
	{
		if (papersizes[size].code > eCustomPaperSize && (pcl->features & PCL_HAS_RICOH_PAPER_SIZES) == 0)
			continue;
		if (w == papersizes[size].width && h == papersizes[size].height)
			break;
		if ((pcl->features & PCL_HAS_ORIENTATION) && w == papersizes[size].height && h == papersizes[size].width)
		{
			rotated = 1;
			break;
		}
	}

	/* If we didn't find an exact match, find the smallest one that's
	 * larger. Consider orientation if our printer supports it. */
	if (size == nelem(papersizes))
	{
		if ((pcl->features & PCL_CAN_SET_CUSTOM_PAPER_SIZE) != 0)
		{
			/* Send it as a custom size */
			size = eCustomPaperSize;
		}
		else
		{
			/* Send the next larger one (minimise waste) */
			int i;
			int best_waste = INT_MAX;
			for (i = 0; i < (int)nelem(papersizes); i++)
			{
				int waste;
				if (papersizes[i].code > eCustomPaperSize && (pcl->features & PCL_HAS_RICOH_PAPER_SIZES) == 0)
					continue;
				waste = papersizes[i].width * papersizes[i].height - w * h;
				if (waste > best_waste)
					continue;
				if (w <= papersizes[i].width && h <= papersizes[i].height)
				{
					best_waste = waste;
					rotated = 0;
					size = i;
				}
				if ((pcl->features & PCL_HAS_ORIENTATION) && w <= papersizes[i].height && h <= papersizes[i].width)
				{
					best_waste = waste;
					rotated = 1;
					size = i;
				}
			}
		}
	}

	/* Now, size = The best size we have (or nelem(papersizes)) if it's too big */

	if (size < (int)nelem(papersizes))
		pcl->paper_size = papersizes[size].code;
	else
		pcl->paper_size = eCustomPaperSize; /* Custom */

	pcl->orientation = rotated;
}

/* Copy a line, returning true if the line was blank. */
static int
line_is_blank(unsigned char *dst, const unsigned char *sp, int w)
{
	int zero = 0;

	while (w-- > 0)
	{
		zero |= (*dst++ = *sp++);
		zero |= (*dst++ = *sp++);
		zero |= (*dst++ = *sp++);
	}

	return zero == 0;
}

static int
delta_compression(unsigned char *curr, unsigned char *prev, unsigned char *comp, int ds, int space)
{
	int left = space;
	int x = ds;

	while (x > 0)
	{
		/* Count matching bytes */
		int match = 0;
		int diff = 0;
		while (x > 0 && *curr == *prev)
		{
			curr++;
			prev++;
			match++;
			x--;
		}

		/* Count different bytes */
		while (x > 0 && *curr != *prev)
		{
			curr++;
			prev++;
			diff++;
			x--;
		}

		while (diff > 0)
		{
			int exts;
			int mini_diff = diff;
			if (mini_diff > 8)
				mini_diff = 8;

			exts = (match+255-31)/255;
			left -= 1 + mini_diff + exts;
			if (left < 0)
				return 0;
			*comp++ = ((mini_diff-1)<<5) | (match < 31 ? match : 31);
			if (exts > 0)
			{
				match -= 31;
				while (--exts)
				{
					*comp++ = 255;
					match -= 255;
				}
				*comp++ = match;
			}
			memcpy(comp, curr-diff, mini_diff);
			comp += mini_diff;

			match = 0;
			diff -= mini_diff;
		}
	}
	return space - left;
}

void
fz_write_pixmap_as_pcl(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, const fz_pcl_options *pcl)
{
	fz_band_writer *writer;

	if (!pixmap || !out)
		return;

	writer = fz_new_color_pcl_band_writer(ctx, out, pcl);
	fz_try(ctx)
	{
		fz_write_header(ctx, writer, pixmap->w, pixmap->h, pixmap->n, pixmap->alpha, pixmap->xres, pixmap->yres, 0, pixmap->colorspace, pixmap->seps);
		fz_write_band(ctx, writer, pixmap->stride, pixmap->h, pixmap->samples);
		fz_close_band_writer(ctx, writer);
	}
	fz_always(ctx)
		fz_drop_band_writer(ctx, writer);
	fz_catch(ctx)
		fz_rethrow(ctx);
}

typedef struct color_pcl_band_writer_s
{
	fz_band_writer super;
	fz_pcl_options options;
	unsigned char *linebuf;
	unsigned char compbuf[32768];
	unsigned char compbuf2[32768];
} color_pcl_band_writer;

static void
color_pcl_write_header(fz_context *ctx, fz_band_writer *writer_, fz_colorspace *cs)
{
	color_pcl_band_writer *writer = (color_pcl_band_writer *)writer_;
	fz_output *out = writer->super.out;
	int w = writer->super.w;
	int h = writer->super.h;
	int n = writer->super.n;
	int s = writer->super.s;
	int a = writer->super.alpha;
	int xres = writer->super.xres;
	int yres = writer->super.yres;

	if (a != 0)
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "color PCL cannot write alpha channel");
	if (s != 0)
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "color PCL cannot write spot colors");
	if (n != 3)
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "color PCL must be RGB");

	writer->linebuf = Memento_label(fz_malloc(ctx, w * 3 * 2), "color_pcl_linebuf");

	guess_paper_size(&writer->options, w, h, xres, yres);

	pcl_header(ctx, out, &writer->options, 1, xres, yres, w, h);

	/* Raster presentation */
	/* Print in orientation of the logical page */
	fz_write_string(ctx, out, "\033&r0F");

	/* Set color mode */
	fz_write_data(ctx, out, "\033*v6W"
		"\000"	/* Colorspace 0 = Device RGB */
		"\003"	/* Pixel encoding mode: 3 = Direct by Pixel*/
		"\000"	/* Bits per index: 0 = no palette */
		"\010"	/* Red bits */
		"\010"	/* Green bits */
		"\010",	/* Blue bits */
		11
		);

	/* Raster resolution */
	/* Supposed to be strictly 75, 100, 150, 200, 300, 600 */
	/* FIXME: xres vs yres */
	fz_write_printf(ctx, out, "\033*t%dR", xres);
}

static void flush_if_not_room(fz_context *ctx, fz_output *out, const unsigned char *comp, int *fill, int len)
{
	if (len + *fill >= 32767)
	{
		/* Can't fit any data, so flush */
		fz_write_printf(ctx, out, "\033*b%dW", *fill);
		fz_write_data(ctx, out, comp, *fill);
		*fill = 0;
	}
}

static void
color_pcl_compress_column(fz_context *ctx, color_pcl_band_writer *writer, const unsigned char *sp, int w, int h, int stride)
{
	fz_output *out = writer->super.out;
	int ss = w * 3;
	int seed_valid = 0;
	int fill = 0;
	int y = 0;
	unsigned char *prev = writer->linebuf + w * 3;
	unsigned char *curr = writer->linebuf;
	unsigned char *comp = writer->compbuf;
	unsigned char *comp2 = writer->compbuf2;

	while (y < h)
	{
		/* Skip over multiple blank lines */
		int blanks;
		do
		{
			blanks = 0;
			while (blanks < 32767 && y < h)
			{
				if (!line_is_blank(curr, sp, w))
					break;
				blanks++;
				y++;
				sp += stride;
			}

			if (blanks)
			{
				flush_if_not_room(ctx, out, comp, &fill, 3);
				comp[fill++] = 4; /* Empty row */
				comp[fill++] = blanks>>8;
				comp[fill++] = blanks & 0xFF;
				seed_valid = 0;
			}
		}
		while (blanks == 32767);

		if (y == h)
			break;

		/* So, at least 1 more line to copy, and it's in curr */
		if (seed_valid && memcmp(curr, prev, ss) == 0)
		{
			int count = 1;
			sp += stride;
			y++;
			while (count < 32767 && y < h)
			{
				if (memcmp(sp-stride, sp, ss) != 0)
					break;
				count++;
				sp += stride;
				y++;
			}
			flush_if_not_room(ctx, out, comp, &fill, 3);
			comp[fill++] = 5; /* Duplicate row */
			comp[fill++] = count>>8;
			comp[fill++] = count & 0xFF;
		}
		else
		{
			unsigned char *tmp;
			int len = 0;

			/* Compress the line into our fixed buffer. */
			if (seed_valid)
				len = delta_compression(curr, prev, comp2, ss, fz_mini(ss-1, 32767-3));

			if (len > 0)
			{
				/* Delta compression */
				flush_if_not_room(ctx, out, comp, &fill, len+3);
				comp[fill++] = 3; /* Delta compression */
				comp[fill++] = len>>8;
				comp[fill++] = len & 0xFF;
				memcpy(&comp[fill], comp2, len);
				fill += len;
			}
			else
			{
				flush_if_not_room(ctx, out, comp, &fill, 3 + ss);

				/* PCL requires that all rows MUST fit in at most 1 block, so
				 * we are carefully sending columns that are only so wide. */

				/* Unencoded */
				/* Transfer Raster Data: ss+3 bytes, 0 = Unencoded, count high, count low */
				comp[fill++] = 0;
				comp[fill++] = ss>>8;
				comp[fill++] = ss & 0xFF;
				memcpy(&comp[fill], curr, ss);
				fill += ss;
				seed_valid = 1;
			}

			/* curr becomes prev */
			tmp = prev; prev = curr; curr = tmp;
			sp += stride;
			y++;
		}
	}
	/* And flush */
	if (fill) {
		fz_write_printf(ctx, out, "\033*b%dW", fill);
		fz_write_data(ctx, out, comp, fill);
	}

	/* End Raster Graphics */
	fz_write_string(ctx, out, "\033*rC");
}

static void
color_pcl_write_band(fz_context *ctx, fz_band_writer *writer_, int stride, int band_start, int band_height, const unsigned char *sp)
{
	color_pcl_band_writer *writer = (color_pcl_band_writer *)writer_;
	fz_output *out = writer->super.out;
	int w = writer->super.w;
	int h = writer->super.h;
	int xres = writer->super.xres;
	int cw;
	int x;

	if (!out)
		return;

	if (band_start+band_height >= h)
		band_height = h - band_start;

	/* We have to specify image output size in decipoints (720dpi).
	 * Most usual PCL resolutions are a multiple of 75.
	 * Pick our maximum column size to be 10800 = 15*720 = 144*75
	 * to give us good results. 10800 * 3 = 32400 < 32760 */
	cw = 10800; /* Limited by how much rowdata we can send at once */
	if (cw > w)
		cw = w;

	for (x = 0; x*cw < w; x++)
	{
		int col_w = w - cw*x;
		if (col_w > cw)
			col_w = cw;

		/* Top left corner */
		fz_write_printf(ctx, out, "\033*p%dx%dY", x*cw, band_start);

		/* Raster height */
		fz_write_printf(ctx, out, "\033*r%dT", band_height);

		/* Raster width */
		fz_write_printf(ctx, out, "\033*r%dS", col_w);

		/* Destination height */
		fz_write_printf(ctx, out, "\033*t%dV", band_height*720/xres);

		/* Destination width */
		fz_write_printf(ctx, out, "\033*t%dH", col_w*720/xres);

		/* start raster graphics */
		/* 1 = start at cursor position */
		fz_write_string(ctx, out, "\033*r3A");

		/* Now output the actual bitmap */
		/* Adaptive Compression */
		fz_write_string(ctx, out, "\033*b5M");

		color_pcl_compress_column(ctx, writer, sp + x * cw * 3, col_w, band_height, stride);
	}
}

static void
color_pcl_write_trailer(fz_context *ctx, fz_band_writer *writer_)
{
}

static void
color_pcl_drop_band_writer(fz_context *ctx, fz_band_writer *writer_)
{
	color_pcl_band_writer *writer = (color_pcl_band_writer *)writer_;
	fz_free(ctx, writer->linebuf);
}

fz_band_writer *fz_new_color_pcl_band_writer(fz_context *ctx, fz_output *out, const fz_pcl_options *options)
{
	color_pcl_band_writer *writer = fz_new_band_writer(ctx, color_pcl_band_writer, out);

	writer->super.header = color_pcl_write_header;
	writer->super.band = color_pcl_write_band;
	writer->super.trailer = color_pcl_write_trailer;
	writer->super.drop = color_pcl_drop_band_writer;

	if (options)
		writer->options = *options;
	else
		fz_pcl_preset(ctx, &writer->options, "generic");

	return &writer->super;
}

/*
 * Mode 2 Row compression routine for the HP DeskJet & LaserJet IIp.
 * Compresses data from row up to end_row, storing the result
 * starting at out. Returns the number of bytes stored.
 * Runs of K<=127 literal bytes are encoded as K-1 followed by
 * the bytes; runs of 2<=K<=127 identical bytes are encoded as
 * 257-K followed by the byte.
 * In the worst case, the result is N+(N/127)+1 bytes long,
 * where N is the original byte count (end_row - row).
 */
static int
mode2compress(unsigned char *out, const unsigned char *in, int in_len)
{
	int x;
	int out_len = 0;
	int run;

	for (x = 0; x < in_len; x += run)
	{
		/* How far do we have to look to find a value that isn't repeated? */
		for (run = 1; run < 127 && x+run < in_len; run++)
			if (in[0] != in[run])
				break;
		if (run > 1)
		{
			/* We have a run of matching bytes */
			out[out_len++] = 257-run;
			out[out_len++] = in[0];
		}
		else
		{
			/* Now copy as many literals as possible. We only
			 * break the run at a length of 127, at the end,
			 * or where we have 3 repeated values. */
			int i;

			/* How many literals do we need to copy? */
			for (; run < 127 && x+run+2 < in_len; run++)
				if (in[run] == in[run+1] && in[run] == in[run+2])
					break;
			/* Don't leave stragglers at the end */
			if (x + run + 2 >= in_len)
			{
				run = in_len - x;
				if (run > 127)
					run = 127;
			}
			out[out_len++] = run-1;
			for (i = 0; i < run; i++)
			{
				out[out_len++] = in[i];
			}
		}
		in += run;
	}

	return out_len;
}

/*
 * Mode 3 compression routine for the HP LaserJet III family.
 * Compresses bytecount bytes starting at current, storing the result
 * in compressed, comparing against and updating previous.
 * Returns the number of bytes stored.	In the worst case,
 * the number of bytes is bytecount+(bytecount/8)+1.
 */
static int
mode3compress(unsigned char *out, const unsigned char *in, unsigned char *prev, int in_len)
{
	unsigned char *compressed = out;
	const unsigned char *cur = in;
	const unsigned char *end = in + in_len;

	while (cur < end) {		/* Detect a maximum run of unchanged bytes. */
		const unsigned char *run = cur;
		const unsigned char *diff;
		const unsigned char *stop;
		int offset, cbyte;

		while (cur < end && *cur == *prev) {
			cur++, prev++;
		}
		if (cur == end)
			break;		/* rest of row is unchanged */
		/* Detect a run of up to 8 changed bytes. */
		/* We know that *cur != *prev. */
		diff = cur;
		stop = (end - cur > 8 ? cur + 8 : end);
		do
		{
			*prev++ = *cur++;
		}
		while (cur < stop && *cur != *prev);
		/* Now [run..diff) are unchanged, and */
		/* [diff..cur) are changed. */
		/* Generate the command byte(s). */
		offset = diff - run;
		cbyte = (cur - diff - 1) << 5;
		if (offset < 31)
			*out++ = cbyte + offset;
		else {
			*out++ = cbyte + 31;
			offset -= 31;
			while (offset >= 255)
				*out++ = 255, offset -= 255;
			*out++ = offset;
		}
		/* Copy the changed data. */
		while (diff < cur)
			*out++ = *diff++;
	}
	return out - compressed;
}

void
fz_write_bitmap_as_pcl(fz_context *ctx, fz_output *out, const fz_bitmap *bitmap, const fz_pcl_options *pcl)
{
	fz_band_writer *writer;

	if (!bitmap || !out)
		return;

	writer = fz_new_mono_pcl_band_writer(ctx, out, pcl);
	fz_try(ctx)
	{
		fz_write_header(ctx, writer, bitmap->w, bitmap->h, 1, 0, bitmap->xres, bitmap->yres, 0, NULL, NULL);
		fz_write_band(ctx, writer, bitmap->stride, bitmap->h, bitmap->samples);
		fz_close_band_writer(ctx, writer);
	}
	fz_always(ctx)
		fz_drop_band_writer(ctx, writer);
	fz_catch(ctx)
		fz_rethrow(ctx);
}

typedef struct mono_pcl_band_writer_s
{
	fz_band_writer super;
	fz_pcl_options options;
	unsigned char *prev;
	unsigned char *mode2buf;
	unsigned char *mode3buf;
	int top_of_page;
	int num_blank_lines;
} mono_pcl_band_writer;

static void
mono_pcl_write_header(fz_context *ctx, fz_band_writer *writer_, fz_colorspace *cs)
{
	mono_pcl_band_writer *writer = (mono_pcl_band_writer *)writer_;
	fz_output *out = writer->super.out;
	int w = writer->super.w;
	int h = writer->super.h;
	int xres = writer->super.xres;
	int yres = writer->super.yres;
	int line_size;
	int max_mode_2_size;
	int max_mode_3_size;

	if (writer->super.alpha != 0)
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "mono PCL cannot write alpha channel");
	if (writer->super.s != 0)
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "mono PCL cannot write spot colors");
	if (writer->super.n != 1)
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "mono PCL must be grayscale");

	line_size = (w + 7)/8;
	max_mode_2_size = line_size + (line_size/127) + 1;
	max_mode_3_size = line_size + (line_size/8) + 1;

	writer->prev = fz_calloc(ctx, line_size, sizeof(unsigned char));
	writer->mode2buf = fz_calloc(ctx, max_mode_2_size, sizeof(unsigned char));
	writer->mode3buf = fz_calloc(ctx, max_mode_3_size, sizeof(unsigned char));
	writer->num_blank_lines = 0;
	writer->top_of_page = 1;

	guess_paper_size(&writer->options, w, h, xres, yres);

	if (writer->options.features & HACK__IS_A_OCE9050)
	{
		/* Enter HPGL/2 mode, begin plot, Initialise (start plot), Enter PCL mode */
		fz_write_string(ctx, out, "\033%1BBPIN;\033%1A");
	}

	pcl_header(ctx, out, &writer->options, 1, xres, yres, w, h);
}

static void
mono_pcl_write_band(fz_context *ctx, fz_band_writer *writer_, int ss, int band_start, int band_height, const unsigned char *data)
{
	mono_pcl_band_writer *writer = (mono_pcl_band_writer *)writer_;
	fz_output *out = writer->super.out;
	int w = writer->super.w;
	int yres = writer->super.yres;
	const unsigned char *out_data;
	int y, rmask, line_size;
	int num_blank_lines;
	int compression = -1;
	unsigned char *prev = NULL;
	unsigned char *mode2buf = NULL;
	unsigned char *mode3buf = NULL;
	int out_count;
	const fz_pcl_options *pcl;

	if (!out)
		return;

	num_blank_lines = writer->num_blank_lines;
	rmask = ~0 << (-w & 7);
	line_size = (w + 7)/8;
	prev = writer->prev;
	mode2buf = writer->mode2buf;
	mode3buf = writer->mode3buf;
	pcl = &writer->options;

	/* Transfer raster graphics. */
	for (y = 0; y < band_height; y++, data += ss)
	{
		const unsigned char *end_data = data + line_size;

		if ((end_data[-1] & rmask) == 0)
		{
			end_data--;
			while (end_data > data && end_data[-1] == 0)
				end_data--;
		}
		if (end_data == data)
		{
			/* Blank line */
			num_blank_lines++;
			continue;
		}

		/* We've reached a non-blank line. */
		/* Put out a spacing command if necessary. */
		if (writer->top_of_page)
		{
			writer->top_of_page = 0;
			/* We're at the top of a page. */
			if (pcl->features & PCL_ANY_SPACING)
			{
				if (num_blank_lines > 0)
					fz_write_printf(ctx, out, "\033*p+%dY", num_blank_lines);
				/* Start raster graphics. */
				fz_write_string(ctx, out, "\033*r1A");
			}
			else if (pcl->features & PCL_MODE_3_COMPRESSION)
			{
				/* Start raster graphics. */
				fz_write_string(ctx, out, "\033*r1A");
				for (; num_blank_lines; num_blank_lines--)
					fz_write_string(ctx, out, "\033*b0W");
			}
			else
			{
				/* Start raster graphics. */
				fz_write_string(ctx, out, "\033*r1A");
				for (; num_blank_lines; num_blank_lines--)
					fz_write_string(ctx, out, "\033*bW");
			}
		}

		/* Skip blank lines if any */
		else if (num_blank_lines != 0)
		{
			/* Moving down from current position causes head
			 * motion on the DeskJet, so if the number of lines
			 * is small, we're better off printing blanks.
			 *
			 * For Canon LBP4i and some others, <ESC>*b<n>Y
			 * doesn't properly clear the seed row if we are in
			 * compression mode 3.
			 */
			if ((num_blank_lines < MIN_SKIP_LINES && compression != 3) ||
					!(pcl->features & PCL_ANY_SPACING))
			{
				int mode_3ns = ((pcl->features & PCL_MODE_3_COMPRESSION) && !(pcl->features & PCL_ANY_SPACING));
				if (mode_3ns && compression != 2)
				{
					/* Switch to mode 2 */
					fz_write_string(ctx, out, from3to2);
					compression = 2;
				}
				if (pcl->features & PCL_MODE_3_COMPRESSION)
				{
					/* Must clear the seed row. */
					fz_write_string(ctx, out, "\033*b1Y");
					num_blank_lines--;
				}
				if (mode_3ns)
				{
					for (; num_blank_lines; num_blank_lines--)
						fz_write_string(ctx, out, "\033*b0W");
				}
				else
				{
					for (; num_blank_lines; num_blank_lines--)
						fz_write_string(ctx, out, "\033*bW");
				}
			}
			else if (pcl->features & PCL3_SPACING)
				fz_write_printf(ctx, out, "\033*p+%dY", num_blank_lines * yres);
			else
				fz_write_printf(ctx, out, "\033*b%dY", num_blank_lines);
			/* Clear the seed row (only matters for mode 3 compression). */
			memset(prev, 0, line_size);
		}
		num_blank_lines = 0;

		/* Choose the best compression mode for this particular line. */
		if (pcl->features & PCL_MODE_3_COMPRESSION)
		{
			/* Compression modes 2 and 3 are both available. Try
			 * both and see which produces the least output data.
			 */
			int count3 = mode3compress(mode3buf, data, prev, line_size);
			int count2 = mode2compress(mode2buf, data, line_size);
			int penalty3 = (compression == 3 ? 0 : penalty_from2to3);
			int penalty2 = (compression == 2 ? 0 : penalty_from3to2);

			if (count3 + penalty3 < count2 + penalty2)
			{
				if (compression != 3)
					fz_write_string(ctx, out, from2to3);
				compression = 3;
				out_data = (unsigned char *)mode3buf;
				out_count = count3;
			}
			else
			{
				if (compression != 2)
					fz_write_string(ctx, out, from3to2);
				compression = 2;
				out_data = (unsigned char *)mode2buf;
				out_count = count2;
			}
		}
		else if (pcl->features & PCL_MODE_2_COMPRESSION)
		{
			out_data = mode2buf;
			out_count = mode2compress(mode2buf, data, line_size);
		}
		else
		{
			out_data = data;
			out_count = line_size;
		}

		/* Transfer the data */
		fz_write_printf(ctx, out, "\033*b%dW", out_count);
		fz_write_data(ctx, out, out_data, out_count);
	}

	writer->num_blank_lines = num_blank_lines;
}

static void
mono_pcl_write_trailer(fz_context *ctx, fz_band_writer *writer_)
{
	mono_pcl_band_writer *writer = (mono_pcl_band_writer *)writer_;
	fz_output *out = writer->super.out;

	/* end raster graphics and eject page */
	fz_write_string(ctx, out, "\033*rB\f");

	if (writer->options.features & HACK__IS_A_OCE9050)
	{
		/* Pen up, pen select, advance full page, reset */
		fz_write_string(ctx, out, "\033%1BPUSP0PG;\033E");
	}
}

static void
mono_pcl_drop_band_writer(fz_context *ctx, fz_band_writer *writer_)
{
	mono_pcl_band_writer *writer = (mono_pcl_band_writer *)writer_;

	fz_free(ctx, writer->prev);
	fz_free(ctx, writer->mode2buf);
	fz_free(ctx, writer->mode3buf);
}

fz_band_writer *fz_new_mono_pcl_band_writer(fz_context *ctx, fz_output *out, const fz_pcl_options *options)
{
	mono_pcl_band_writer *writer = fz_new_band_writer(ctx, mono_pcl_band_writer, out);

	writer->super.header = mono_pcl_write_header;
	writer->super.band = mono_pcl_write_band;
	writer->super.trailer = mono_pcl_write_trailer;
	writer->super.drop = mono_pcl_drop_band_writer;

	if (options)
		writer->options = *options;
	else
		fz_pcl_preset(ctx, &writer->options, "generic");

	return &writer->super;
}

void
fz_save_pixmap_as_pcl(fz_context *ctx, fz_pixmap *pixmap, char *filename, int append, const fz_pcl_options *pcl)
{
	fz_output *out = fz_new_output_with_path(ctx, filename, append);
	fz_try(ctx)
	{
		fz_write_pixmap_as_pcl(ctx, out, pixmap, pcl);
		fz_close_output(ctx, out);
	}
	fz_always(ctx)
		fz_drop_output(ctx, out);
	fz_catch(ctx)
		fz_rethrow(ctx);
}

void
fz_save_bitmap_as_pcl(fz_context *ctx, fz_bitmap *bitmap, char *filename, int append, const fz_pcl_options *pcl)
{
	fz_output *out = fz_new_output_with_path(ctx, filename, append);
	fz_try(ctx)
	{
		fz_write_bitmap_as_pcl(ctx, out, bitmap, pcl);
		fz_close_output(ctx, out);
	}
	fz_always(ctx)
		fz_drop_output(ctx, out);
	fz_catch(ctx)
		fz_rethrow(ctx);
}

/* High-level document writer interface */

typedef struct
{
	fz_document_writer super;
	fz_draw_options draw;
	fz_pcl_options pcl;
	fz_pixmap *pixmap;
	int mono;
	fz_output *out;
} fz_pcl_writer;

static fz_device *
pcl_begin_page(fz_context *ctx, fz_document_writer *wri_, fz_rect mediabox)
{
	fz_pcl_writer *wri = (fz_pcl_writer*)wri_;
	return fz_new_draw_device_with_options(ctx, &wri->draw, mediabox, &wri->pixmap);
}

static void
pcl_end_page(fz_context *ctx, fz_document_writer *wri_, fz_device *dev)
{
	fz_pcl_writer *wri = (fz_pcl_writer*)wri_;
	fz_bitmap *bitmap = NULL;

	fz_var(bitmap);

	fz_try(ctx)
	{
		fz_close_device(ctx, dev);
		if (wri->mono)
		{
			bitmap = fz_new_bitmap_from_pixmap(ctx, wri->pixmap, NULL);
			fz_write_bitmap_as_pcl(ctx, wri->out, bitmap, &wri->pcl);
		}
		else
		{
			fz_write_pixmap_as_pcl(ctx, wri->out, wri->pixmap, &wri->pcl);
		}
	}
	fz_always(ctx)
	{
		fz_drop_device(ctx, dev);
		fz_drop_bitmap(ctx, bitmap);
		fz_drop_pixmap(ctx, wri->pixmap);
		wri->pixmap = NULL;
	}
	fz_catch(ctx)
		fz_rethrow(ctx);
}

static void
pcl_close_writer(fz_context *ctx, fz_document_writer *wri_)
{
	fz_pcl_writer *wri = (fz_pcl_writer*)wri_;
	fz_close_output(ctx, wri->out);
}

static void
pcl_drop_writer(fz_context *ctx, fz_document_writer *wri_)
{
	fz_pcl_writer *wri = (fz_pcl_writer*)wri_;
	fz_drop_pixmap(ctx, wri->pixmap);
	fz_drop_output(ctx, wri->out);
}

fz_document_writer *
fz_new_pcl_writer_with_output(fz_context *ctx, fz_output *out, const char *options_string)
{
	fz_options *options = NULL;
	fz_pcl_writer *wri = NULL;
	const char *val;

	fz_var(options);
	fz_var(wri);

	fz_try(ctx)
	{
		options = fz_new_options(ctx, options_string);
		wri = fz_new_derived_document_writer(ctx, fz_pcl_writer, pcl_begin_page, pcl_end_page, pcl_close_writer, pcl_drop_writer);
		fz_init_draw_options(ctx, &wri->draw);
		fz_init_pcl_options(ctx, &wri->pcl);
		fz_apply_draw_options(ctx, &wri->draw, options);
		fz_apply_pcl_options(ctx, &wri->pcl, options);
		if (fz_lookup_option(ctx, options, "colorspace", &val))
			if (!strcmp(val, "mono"))
				wri->mono = 1;
		wri->out = out;
		fz_throw_on_unused_options(ctx, options, "pcl");
	}
	fz_catch(ctx)
	{
		fz_drop_options(ctx, options);
		fz_drop_output(ctx, out);
		fz_free(ctx, wri);
		fz_rethrow(ctx);
	}

	return (fz_document_writer*)wri;
}

fz_document_writer *
fz_new_pcl_writer(fz_context *ctx, const char *path, const char *options)
{
	fz_output *out = fz_new_output_with_path(ctx, path ? path : "out.pcl", 0);
	return fz_new_pcl_writer_with_output(ctx, out, options);
}
