summaryrefslogtreecommitdiff
path: root/gs/src/gdevcdj.c
diff options
context:
space:
mode:
Diffstat (limited to 'gs/src/gdevcdj.c')
-rw-r--r--gs/src/gdevcdj.c3916
1 files changed, 3916 insertions, 0 deletions
diff --git a/gs/src/gdevcdj.c b/gs/src/gdevcdj.c
new file mode 100644
index 000000000..152a66da1
--- /dev/null
+++ b/gs/src/gdevcdj.c
@@ -0,0 +1,3916 @@
+/* Copyright (C) 1991, 1995, 1996, 1997 Aladdin Enterprises. All rights reserved.
+
+ This file is part of Aladdin Ghostscript.
+
+ Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND. No author
+ or distributor accepts any responsibility for the consequences of using it,
+ or for whether it serves any particular purpose or works at all, unless he
+ or she says so in writing. Refer to the Aladdin Ghostscript Free Public
+ License (the "License") for full details.
+
+ Every copy of Aladdin Ghostscript must include a copy of the License,
+ normally in a plain ASCII text file named PUBLIC. The License grants you
+ the right to copy, modify and redistribute Aladdin Ghostscript, but only
+ under certain conditions described in the License. Among other things, the
+ License requires that the copyright notice and this notice be preserved on
+ all copies.
+*/
+
+/* gdevcdj.c */
+/* H-P and Canon colour printer drivers */
+
+/****************************************************************
+ * The code in this file has gotten completely out of hand.
+ * Too many users have made too many "improvements" without
+ * regard to the overall structure; the last three "improvements"
+ * required me to spend several hours fixing each one so that
+ * the code worked again at all. For this reason, no further
+ * changes to this file will be accepted. I am planning eventually
+ * to get these drivers rewritten from scratch.
+ * L. Peter Deutsch
+ * Aladdin Enterprises
+ * February 28, 1996
+ ****************************************************************/
+
+/*
+ * Important compilation notes (YA).
+ *
+ * You may also try the cdj550cmyk driver after having defined
+ * USE_CDJ550_CMYK and added the needed definition in devs.mak. Not tried!
+ * (I have a BJC!) If you ty that, please report success/failure to me,
+ * Yves.Arrouye@imag.fr. Also note that modes descriptions of CMYK printing
+ * is done under the BJC section of devices.doc.
+ *
+ * CMYK to RGB conversion is made a la GhostScript unless you define
+ * the preprocessor symbol USE_ADOBE_CMYK_RGB.
+ *
+ * Ghostscript: R = (1.0 - C) * (1.0 - K)
+ * Adobe: R = 1.0 - min(1.0, C + K)
+ *
+ * (and similarly for G and B). Ghostscript claims its method achieves
+ * better results.
+ *
+ * For the BJC drivers, define BJC_DEFAULT_CENTEREDAREA if you want to
+ * have the same top and bottom margins (default to use the tallest
+ * imageable area available, usually with a top margin smaller than
+ * the bottom one). Defining USE_RECOMMENDED_MARGINS has the same
+ * effect and also sets these margins to 12.4 mm. Other compilation
+ * defines are explained in devices.doc.
+ *
+ * You can also define BJC_INIT_800_AS_600 to not use BJC-800-specific code
+ * in the page initialization sequence (normally not useful to you at all,
+ * just for my debugging of the driver margins).
+ *
+ */
+
+#include "std.h" /* to stop stdlib.h redefining types */
+#include <stdlib.h> /* for rand() */
+#include "gdevprn.h"
+#include "gdevpcl.h"
+#include "gsparam.h"
+#include "gsstate.h"
+
+/* Conversion stuff. */
+#include "gxlum.h"
+
+/* Canon stuff */
+
+#include "gdevbjc.h"
+
+/***
+ *** This file contains multiple drivers. The main body of code, and all
+ *** but the DesignJet driver, were contributed by George Cameron;
+ *** please contact g.cameron@biomed.abdn.ac.uk if you have questions.
+ * 1 - cdj500: HP DeskJet 500C
+ * 2 - cdj550: HP DeskJet 550C
+ * 3 - pjxl300: HP PaintJet XL300
+ * 4 - pj: HP PaintJet
+ * 5 - pjxl: HP PaintJet XL
+ * 6 - declj250: DEC LJ250
+ *** The DesignJet 650C driver was contributed by Koert Zeilstra;
+ *** please contact koert@zen.cais.com if you have questions.
+ * 7 - dnj650c HP DesignJet 650C
+ *** The LaserJet 4 driver with dithering was contributed by Eckhard
+ *** Rueggeberg; please contact eckhard@ts.go.dlr.de if you have questions.
+ * 8 - lj4dith: HP LaserJet 4 with dithering
+ *** The ESC/P driver (for Epson ESC/P compatible printers) was written by
+ *** Yoshio Kuniyoshi <yoshio@nak.math.keio.ac.jp>, but is not maintained at
+ *** the moment.
+ * 9 - esc/p: Epson ESC/P-compatible printers
+ *** The BJC600 driver (which also works for BJC4000) was written first
+ *** by Yoshio Kuniyoshi <yoshio@nak.math.keio.ac.jp> and later modified by
+ *** Yves Arrouye <Yves.Arrouye@imag.fr>. The current driver has been
+ *** completely rewritten by me (YA) for good color handling.
+ * 10 - bjc600: BJC 600//4000 printers
+ *** The BJC800 driver is based on the bjc600 one. By YA too.
+ * 11 - bjc800: BJC 800 printer
+ ***/
+
+/*
+ * All of the HP-like drivers have 8-bit (monochrome), 16-bit and 24-bit
+ * (colour) and for the DJ 550C 32-bit, (colour, cmyk mode)
+ * options in addition to the usual 1-bit and 3-bit modes
+ * It is also possible to set various printer-specific parameters
+ * from the gs command line, eg.
+ *
+ * gs -sDEVICE=cdj550 -dBitsPerPixel=16 -dDepletion=1 -dShingling=2 tiger.ps
+ *
+ * Please consult the appropriate section in the devices.doc file for
+ * further details on all these drivers.
+ *
+ * All of the BJC-like drivers have 1-bit and 8-bit monochrome modes, 8-bit,
+ * 16-bit, 24-bit and 32-bit colour cmyk mode (the 8-bit monochrome mode
+ * is called "4-bit". If you want to add a CMYK printer, look at the
+ * bjc6000/bjc800 devices declarations and initialization.
+ *
+ * If you want to support different color components for the same depth
+ * on a non-CMYK printer, look how this is done for CMYK printers in
+ * cdj_set_bpp.
+ *
+ */
+
+/*
+ * This taken from gsdparam.c. I hope it will be useable directly some day.
+ *
+ */
+
+#define BEGIN_ARRAY_PARAM(pread, pname, pa, psize, e)\
+ switch ( ncode = pread(plist, (oname = pname), &pa) )\
+ {\
+ case 0:\
+ if ( pa.size != psize )\
+ code = gs_error_rangecheck;\
+ else {
+/* The body of the processing code goes here. */
+/* If it succeeds, it should do a 'break'; */
+/* if it fails, it should set ecode and fall through. */
+#define END_PARAM(pa, e)\
+ }\
+ goto e;\
+ default:\
+ code = ncode;\
+e: param_signal_error(plist, oname, code);\
+ case 1:\
+ pa.data = 0; /* mark as not filled */\
+ }
+
+private int cdj_param_check_bytes(P5(gs_param_list *, gs_param_name, const byte *, uint, bool));
+private int cdj_param_check_float(P4(gs_param_list *, gs_param_name, floatp, bool));
+#define cdj_param_check_string(plist, pname, str, defined)\
+ cdj_param_check_bytes(plist, pname, (const byte *)str, strlen(str), defined)
+
+/*
+ * Drivers stuff.
+ *
+ */
+
+#define DESKJET_PRINT_LIMIT 0.04 /* 'real' top margin? */
+#define PAINTJET_PRINT_LIMIT 0.0 /* This is a guess.. */
+#define ESC_P_PRINT_LIMIT 0.335
+
+/* Margins are left, bottom, right, top. */
+#define DESKJET_MARGINS_LETTER 0.25, 0.50, 0.25, 0.167
+#define DESKJET_MARGINS_A4 0.125, 0.50, 0.143, 0.167
+#define LJET4_MARGINS 0.26, 0.0, 0.0, 0.0
+/* The PaintJet and DesignJet seem to have the same margins */
+/* regardless of paper size. */
+#define PAINTJET_MARGINS 0.167, 0.167, 0.167, 0.167
+#define DESIGNJET_MARGINS 0.167, 0.167, 0.167, 0.167
+
+/*
+ * With ESC/P commands, BJC-600 can print no more than 8 inches width.
+ * So it can't use full width of letter size paper. Since non printable
+ * left side area is 0.134 inch, we set up margins as follows.
+ *
+ * Note to readers: the bjc drivers series do *not* use ESC/P commands
+ * but raster ops. Configuration of these drivers can be done through
+ * the gdevbjc.h file.
+ *
+ */
+#define ESC_P_MARGINS_LETTER 0.134, 0.276+0.2, 0.366+0.01, 0.335
+#define ESC_P_MARGINS_A4 0.134, 0.276+0.2, 0.166+0.01, 0.335
+
+/* Define bits-per-pixel for generic drivers - default is 24-bit mode */
+#ifndef BITSPERPIXEL
+# define BITSPERPIXEL 24
+#endif
+
+#define W sizeof(word)
+#define I sizeof(int)
+
+
+#define invert_word(v)\
+ ((v) >> 24) + (((v) >> 8) & 0xff00L) +\
+ (((word)(v) << 8) & 0xff0000L) + ((word)(v) << 24)
+
+
+/* Printer types */
+#define DJ500C 0
+#define DJ550C 1
+#define PJXL300 2
+#define PJ180 3
+#define PJXL180 4
+#define DECLJ250 5
+#define DNJ650C 6
+#define LJ4DITH 7
+#define ESC_P 8
+#define BJC600 9
+#define BJC800 10
+
+/* No. of ink jets (used to minimise head movements) */
+#define HEAD_ROWS_MONO 50
+#define HEAD_ROWS_COLOUR 16
+
+/* Colour mapping procedures */
+private dev_proc_map_cmyk_color (gdev_cmyk_map_cmyk_color);
+private dev_proc_map_rgb_color (gdev_cmyk_map_rgb_color);
+private dev_proc_map_color_rgb (gdev_cmyk_map_color_rgb);
+
+private dev_proc_map_rgb_color (gdev_pcl_map_rgb_color);
+private dev_proc_map_color_rgb (gdev_pcl_map_color_rgb);
+
+/* Print-page, parameters and miscellaneous procedures */
+private dev_proc_open_device(dj500c_open);
+private dev_proc_open_device(dj550c_open);
+private dev_proc_open_device(dnj650c_open);
+private dev_proc_open_device(lj4dith_open);
+private dev_proc_open_device(pj_open);
+private dev_proc_open_device(pjxl_open);
+private dev_proc_open_device(pjxl300_open);
+private dev_proc_open_device(escp_open);
+private dev_proc_open_device(bjc_open);
+
+private dev_proc_print_page(declj250_print_page);
+private dev_proc_print_page(dj500c_print_page);
+private dev_proc_print_page(dj550c_print_page);
+private dev_proc_print_page(dnj650c_print_page);
+private dev_proc_print_page(lj4dith_print_page);
+private dev_proc_print_page(pj_print_page);
+private dev_proc_print_page(pjxl_print_page);
+private dev_proc_print_page(pjxl300_print_page);
+private dev_proc_print_page(escp_print_page);
+private dev_proc_print_page(bjc_print_page);
+
+private dev_proc_get_params(cdj_get_params);
+private dev_proc_get_params(pjxl_get_params);
+private dev_proc_get_params(bjc_get_params);
+#define ep_get_params cdj_get_params
+
+private dev_proc_put_params(cdj_put_params);
+private dev_proc_put_params(pj_put_params);
+private dev_proc_put_params(pjxl_put_params);
+private dev_proc_put_params(bjc_put_params);
+#define ep_put_params cdj_put_params
+
+/* The device descriptors */
+
+#define gx_prn_colour_device_common \
+ gx_prn_device_common; \
+ short cmyk; /* 0: not CMYK-capable, > 0: printing CMYK, */ \
+ /* < 0 : CMYK-capable, not printing CMYK */ \
+ uint default_depth; /* Used only for CMYK-capable printers now. */ \
+ uint correction
+
+typedef struct gx_device_cdj_s gx_device_cdj;
+struct gx_device_cdj_s {
+ gx_device_common;
+ gx_prn_colour_device_common;
+ int shingling; /* Interlaced, multi-pass printing */
+ int depletion; /* 'Intelligent' dot-removal */
+};
+
+typedef struct gx_device_pjxl_s gx_device_pjxl;
+struct gx_device_pjxl_s {
+ gx_device_common;
+ gx_prn_colour_device_common;
+ int printqual; /* Mechanical print quality */
+ int rendertype; /* Driver or printer dithering control */
+};
+
+typedef struct gx_device_hp_s gx_device_hp;
+struct gx_device_hp_s {
+ gx_device_common;
+ gx_prn_colour_device_common;
+};
+
+typedef struct gx_device_hp_s gx_device_pj;
+
+typedef struct gx_device_bjc600_s gx_device_bjc600;
+typedef struct gx_device_bjc800_s gx_device_bjc800;
+
+typedef struct gx_device_bjc800_s gx_device_bjc;
+
+#define bjc_params_common \
+ bool manualFeed; /* Use manual feed */ \
+ int mediaType; /* Cf. strings below */ \
+ bool mediaWeight_isSet; /* Say if weight is an integer or null */ \
+ int mediaWeight; /* Weigth of the media */ \
+ int printQuality; /* Cf. strings below */ \
+ bool ditheringType; /* Do dithering */ \
+ int colorComponents; /* The number of *desired* color comps */ \
+ int printColors /* 0: Transparent, \
+ 1: C, 2: M, 4: Y, 7: K (Color decomp). \
+ if > 8, print in black ink. */
+
+typedef struct {
+ bjc_params_common;
+
+ bool monochromePrint; /* Print with black only */
+} bjc600_params;
+
+typedef struct {
+ bjc_params_common;
+} bjc_params;
+
+typedef bjc_params bjc800_params;
+
+#define gx_bjc_device_common \
+ gx_device_common; \
+ gx_prn_colour_device_common; \
+ int ptype; \
+ float printLimit
+
+struct gx_device_bjc600_s {
+ gx_bjc_device_common;
+ bjc600_params bjc_p;
+};
+struct gx_device_bjc800_s {
+ gx_bjc_device_common;
+ bjc800_params bjc_p;
+};
+
+typedef struct {
+ gx_device_common;
+ gx_prn_colour_device_common;
+} gx_device_colour_prn;
+
+/* Use the cprn_device macro to access generic fields (like cmyk,
+ default_depth and correction), and specific macros for specific
+ devices. */
+
+#define cprn_device ((gx_device_colour_prn*) pdev)
+
+#define cdj ((gx_device_cdj *)pdev)
+#define pjxl ((gx_device_pjxl *)pdev)
+#define pj ((gx_device_pj *)pdev)
+
+#define bjc ((gx_device_bjc*) pdev)
+#define bjc600 ((gx_device_bjc600*) pdev)
+#define bjc800 ((gx_device_bjc800*) pdev)
+
+#define bjcparams (bjc->bjc_p)
+#define bjc600params (bjc600->bjc_p)
+#define bjc800params (bjc800->bjc_p)
+
+#define bjcversion(p) (((gx_device_bjc*) pdev)->ptype == BJC800 ? \
+ BJC_BJC800_VERSION : BJC_BJC600_VERSION)
+#define bjcversionstring(p) (((gx_device_bjc*) pdev)->ptype == BJC800 ? \
+ BJC_BJC800_VERSIONSTR : BJC_BJC600_VERSIONSTR)
+
+#define bjcthickpaper(l) \
+ (bjcparams.mediaWeight_isSet && bjcparams.mediaWeight > l)
+#define bjc600thickpaper() bjcthickpaper(BJC600_MEDIAWEIGHT_THICKLIMIT)
+#define bjc800thickpaper() bjcthickpaper(BJC800_MEDIAWEIGHT_THICKLIMIT)
+
+/* The basic structure for all printers. Note the presence of the cmyk, depth
+ and correct fields even if soem are not used by all printers. */
+
+#define prn_colour_device_body(dtype, procs, dname, w10, h10, xdpi, ydpi, lm, bm, rm, tm, ncomp, depth, mg, mc, dg, dc, print_page, cmyk, correct)\
+ prn_device_body(dtype, procs, dname, w10, h10, xdpi, ydpi, lm, bm, rm, tm, ncomp, depth, mg, mc, dg, dc, print_page), cmyk, depth /* default */, correct
+
+/* Note: the computation of color_info values here must match */
+/* the computation in the cdj_set_bpp procedure below. */
+
+#define prn_hp_colour_device(dtype, procs, dev_name, x_dpi, y_dpi, bpp, print_page, correct)\
+ prn_colour_device_body(dtype, procs, dev_name,\
+ DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS, x_dpi, y_dpi, 0, 0, 0, 0,\
+ (bpp == 32 ? 4 : (bpp == 1 || bpp == 8) ? 1 : 3), bpp,\
+ (bpp >= 8 ? 255 : 1), (bpp >= 8 ? 255 : bpp > 1 ? 1 : 0),\
+ (bpp >= 8 ? 5 : 2), (bpp >= 8 ? 5 : bpp > 1 ? 2 : 0),\
+ print_page, 0 /* cmyk */, correct)
+
+#define prn_cmyk_colour_device(dtype, procs, dev_name, x_dpi, y_dpi, bpp, print_page, correct)\
+ prn_colour_device_body(dtype, procs, dev_name,\
+ DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS, x_dpi, y_dpi, 0, 0, 0, 0,\
+ ((bpp == 1 || bpp == 4) ? 1 : 4), bpp,\
+ (bpp > 8 ? 255 : 1), (1 << (bpp >> 2)) - 1, /* max_gray, max_color */\
+ (bpp > 8 ? 5 : 2), (bpp > 8 ? 5 : bpp > 1 ? 2 : 0),\
+ print_page, 1 /* cmyk */, correct)
+
+#define bjc_device(dtype, p, d, x, y, b, pp, c) \
+ prn_cmyk_colour_device(dtype, p, d, x, y, b, pp, c)
+
+#define cdj_device(procs, dev_name, x_dpi, y_dpi, bpp, print_page, correction, shingling, depletion)\
+{ prn_hp_colour_device(gx_device_cdj, procs, dev_name, x_dpi, y_dpi, bpp, print_page, correction),\
+ shingling,\
+ depletion\
+}
+
+#define pjxl_device(procs, dev_name, x_dpi, y_dpi, bpp, print_page, printqual, rendertype)\
+{ prn_hp_colour_device(gx_device_pjxl, procs, dev_name, x_dpi, y_dpi, bpp, print_page, 0), \
+ printqual,\
+ rendertype\
+}
+
+#define pj_device(procs, dev_name, x_dpi, y_dpi, bpp, print_page)\
+{ prn_hp_colour_device(gx_device_pj, procs, dev_name, x_dpi, y_dpi, bpp, print_page, 0) }
+
+#define bjc600_device(procs, dev_name, x_dpi, y_dpi, bpp, print_page, t, mf, mt, mws, mw, pq, dt, cc, pc, mp) \
+{ bjc_device(gx_device_bjc600, procs, dev_name, x_dpi, y_dpi, bpp, print_page, 0),\
+ t, 0., { mf, mt, mws, mw, pq, dt, cc, pc, mp }\
+}
+#define bjc800_device(procs, dev_name, x_dpi, y_dpi, bpp, print_page, t, mf, mt, mws, mw, pq, dt, cc, pc) \
+{ bjc_device(gx_device_bjc800, procs, dev_name, x_dpi, y_dpi, bpp, print_page, 0),\
+ t, 0., { mf, mt, mws, mw, pq, dt, cc, pc }\
+}
+
+#define hp_colour_procs(proc_colour_open, proc_get_params, proc_put_params) {\
+ proc_colour_open,\
+ gx_default_get_initial_matrix,\
+ gx_default_sync_output,\
+ gdev_prn_output_page,\
+ gdev_prn_close,\
+ gdev_pcl_map_rgb_color,\
+ gdev_pcl_map_color_rgb,\
+ NULL, /* fill_rectangle */\
+ NULL, /* tile_rectangle */\
+ NULL, /* copy_mono */\
+ NULL, /* copy_color */\
+ NULL, /* draw_line */\
+ gx_default_get_bits,\
+ proc_get_params,\
+ proc_put_params\
+}
+
+#define cmyk_colour_procs(proc_colour_open, proc_get_params, proc_put_params) {\
+ proc_colour_open,\
+ gx_default_get_initial_matrix,\
+ gx_default_sync_output,\
+ gdev_prn_output_page,\
+ gdev_prn_close,\
+ NULL /* map_rgb_color */,\
+ gdev_cmyk_map_color_rgb,\
+ NULL /* fill_rectangle */,\
+ NULL /* tile_rectangle */,\
+ NULL /* copy_mono */,\
+ NULL /* copy_color */,\
+ NULL /* draw_line */,\
+ gx_default_get_bits,\
+ proc_get_params,\
+ proc_put_params,\
+ gdev_cmyk_map_cmyk_color\
+}
+
+private gx_device_procs cdj500_procs =
+hp_colour_procs(dj500c_open, cdj_get_params, cdj_put_params);
+
+private gx_device_procs cdj550_procs =
+hp_colour_procs(dj550c_open, cdj_get_params, cdj_put_params);
+
+#ifdef USE_CDJ550_CMYK
+private gx_device_procs cdj550cmyk_procs =
+cmyk_colour_procs(dj550c_open, cdj_get_params, cdj_put_params);
+#endif
+
+private gx_device_procs dnj650c_procs =
+hp_colour_procs(dnj650c_open, cdj_get_params, cdj_put_params);
+
+private gx_device_procs lj4dith_procs =
+hp_colour_procs(lj4dith_open, cdj_get_params, cdj_put_params);
+
+private gx_device_procs pj_procs =
+hp_colour_procs(pj_open, gdev_prn_get_params, pj_put_params);
+
+private gx_device_procs pjxl_procs =
+hp_colour_procs(pjxl_open, pjxl_get_params, pjxl_put_params);
+
+private gx_device_procs pjxl300_procs =
+hp_colour_procs(pjxl300_open, pjxl_get_params, pjxl_put_params);
+
+private gx_device_procs bjc_procs =
+cmyk_colour_procs(bjc_open, bjc_get_params, bjc_put_params);
+
+private gx_device_procs escp_procs =
+hp_colour_procs(escp_open, ep_get_params, ep_put_params);
+
+gx_device_cdj far_data gs_cdjmono_device =
+cdj_device(cdj500_procs, "cdjmono", 300, 300, 1,
+ dj500c_print_page, 4, 0, 1);
+
+gx_device_cdj far_data gs_cdeskjet_device =
+cdj_device(cdj500_procs, "cdeskjet", 300, 300, 3,
+ dj500c_print_page, 4, 2, 1);
+
+gx_device_cdj far_data gs_cdjcolor_device =
+cdj_device(cdj500_procs, "cdjcolor", 300, 300, 24,
+ dj500c_print_page, 4, 2, 1);
+
+gx_device_cdj far_data gs_cdj500_device =
+cdj_device(cdj500_procs, "cdj500", 300, 300, BITSPERPIXEL,
+ dj500c_print_page, 4, 2, 1);
+
+gx_device_cdj far_data gs_cdj550_device =
+cdj_device(cdj550_procs, "cdj550", 300, 300, BITSPERPIXEL,
+ dj550c_print_page, 0, 2, 1);
+
+#ifdef USE_CDJ550_CMYK
+gx_device_cdj far_data gs_cdj550cmyk_device = {
+ prn_cmyk_colour_device(cdj550cmyk_procs, "cdj550cmyk", 300, 300,
+ BITSPERPIXEL, dj550c_print_page, 0), 2, 1
+};
+#endif
+
+gx_device_pj far_data gs_declj250_device =
+pj_device(pj_procs, "declj250", 180, 180, BITSPERPIXEL,
+ declj250_print_page);
+
+gx_device_cdj far_data gs_dnj650c_device =
+cdj_device(dnj650c_procs, "dnj650c", 300, 300, BITSPERPIXEL,
+ dnj650c_print_page, 0, 2, 1);
+
+gx_device_cdj far_data gs_lj4dith_device =
+cdj_device(lj4dith_procs, "lj4dith", 600, 600, 8,
+ lj4dith_print_page, 4, 0, 1);
+
+gx_device_pj far_data gs_pj_device =
+pj_device(pj_procs, "pj", 180, 180, BITSPERPIXEL,
+ pj_print_page);
+
+gx_device_pjxl far_data gs_pjxl_device =
+pjxl_device(pjxl_procs, "pjxl", 180, 180, BITSPERPIXEL,
+ pjxl_print_page, 0, 0);
+
+gx_device_pjxl far_data gs_pjxl300_device =
+pjxl_device(pjxl300_procs, "pjxl300", 300, 300, BITSPERPIXEL,
+ pjxl300_print_page, 0, 0);
+
+gx_device_cdj far_data gs_escp_device =
+cdj_device(escp_procs, "escp", 360, 360, 8,
+ escp_print_page, 0, 0, 1);
+
+gx_device_cdj far_data gs_escpc_device =
+cdj_device(escp_procs, "escpc", 360, 360, 24,
+ escp_print_page, 0, 0, 1);
+
+/* Args of bjc drivers are manualFeed, mediaType, printQuality, printColor,
+ mediaWeight_isSet, mediaWeight, (monochromePrint) */
+
+gx_device_bjc600 far_data gs_bjc600_device =
+ bjc600_device(
+ bjc_procs,
+ BJC_BJC600,
+ BJC600_DEFAULT_RESOLUTION,
+ BJC600_DEFAULT_RESOLUTION,
+ BJC600_DEFAULT_BITSPERPIXEL,
+ bjc_print_page,
+ BJC600,
+ BJC600_DEFAULT_MANUALFEED,
+ BJC600_DEFAULT_MEDIATYPE,
+ BJC600_DEFAULT_SETMEDIAWEIGHT,
+ BJC600_DEFAULT_MEDIAWEIGHT,
+ BJC600_DEFAULT_PRINTQUALITY,
+ BJC600_DEFAULT_DITHERINGTYPE,
+ BJC600_DEFAULT_COLORCOMPONENTS,
+ BJC600_DEFAULT_PRINTCOLORS,
+ BJC600_DEFAULT_MONOCHROMEPRINT);
+
+gx_device_bjc800 far_data gs_bjc800_device =
+ bjc800_device(
+ bjc_procs,
+ BJC_BJC800,
+ BJC800_DEFAULT_RESOLUTION,
+ BJC800_DEFAULT_RESOLUTION,
+ BJC800_DEFAULT_BITSPERPIXEL,
+ bjc_print_page,
+ BJC800,
+ BJC800_DEFAULT_MANUALFEED,
+ BJC800_DEFAULT_MEDIATYPE,
+ BJC800_DEFAULT_SETMEDIAWEIGHT,
+ BJC800_DEFAULT_MEDIAWEIGHT,
+ BJC800_DEFAULT_PRINTQUALITY,
+ BJC800_DEFAULT_DITHERINGTYPE,
+ BJC600_DEFAULT_COLORCOMPONENTS,
+ BJC800_DEFAULT_PRINTCOLORS);
+
+/* Forward references */
+private int gdev_pcl_mode1compress(P3(const byte *, const byte *, byte *));
+private int gdev_pcl_mode9compress(P4(int, const byte *, const byte *, byte *));
+private int hp_colour_open(P2(gx_device *, int));
+private int hp_colour_print_page(P3(gx_device_printer *, FILE *, int));
+private int near cdj_put_param_int(P6(gs_param_list *, gs_param_name, int *, int, int, int));
+private uint gdev_prn_rasterwidth(P2(const gx_device_printer *, int));
+private int cdj_put_param_bpp(P5(gx_device *, gs_param_list *, int, int, int));
+private int cdj_set_bpp(P3(gx_device *, int, int));
+private void cdj_expand_line(P5(word *, int, short, int, int));
+private int bjc_fscmyk(P5(byte**, byte*[4][4], int**, int, int));
+
+/* String parameters manipulation */
+
+typedef struct {
+ const char* p_name;
+ int p_value;
+} stringParamDescription;
+
+private const byte* paramValueToString(P2(const stringParamDescription*, int));
+private int paramStringValue(P4(const stringParamDescription*,
+ const byte*, int, int*));
+
+private int put_param_string(P6(gs_param_list*, const byte*,
+ gs_param_string*, const stringParamDescription*, int *, int));
+private int get_param_string(P7(gs_param_list*, const byte*,
+ gs_param_string*, const stringParamDescription*, int, bool, int));
+
+/* Open the printer and set up the margins. */
+private int
+dj500c_open(gx_device *pdev)
+{ return hp_colour_open(pdev, DJ500C);
+}
+
+private int
+dj550c_open(gx_device *pdev)
+{ return hp_colour_open(pdev, DJ550C);
+}
+
+private int
+dnj650c_open(gx_device *pdev)
+{ return hp_colour_open(pdev, DNJ650C);
+}
+
+private int
+lj4dith_open(gx_device *pdev)
+{ return hp_colour_open(pdev, LJ4DITH);
+}
+
+private int
+pjxl300_open(gx_device *pdev)
+{ return hp_colour_open(pdev, PJXL300);
+}
+
+private int
+pj_open(gx_device *pdev)
+{ return hp_colour_open(pdev, PJ180);
+}
+
+private int
+pjxl_open(gx_device *pdev)
+{ return hp_colour_open(pdev, PJXL180);
+}
+
+private int
+escp_open(gx_device *pdev)
+{ return hp_colour_open(pdev, ESC_P);
+}
+
+private int
+bjc_open(gx_device *pdev)
+{ return hp_colour_open(pdev, bjc->ptype);
+}
+
+private int
+hp_colour_open(gx_device *pdev, int ptype)
+{ /* Change the margins if necessary. */
+ static const float dj_a4[4] = { DESKJET_MARGINS_A4 };
+ static const float dj_letter[4] = { DESKJET_MARGINS_LETTER };
+ static const float lj4_all[4] = { LJET4_MARGINS };
+ static const float pj_all[4] = { PAINTJET_MARGINS };
+ static const float dnj_all[4] = { DESIGNJET_MARGINS };
+ static const float ep_a4[4] = { ESC_P_MARGINS_A4 };
+ static const float ep_letter[4] = { ESC_P_MARGINS_LETTER };
+
+ static float bjc_a3[4] = { BJC_MARGINS_A3 }; /* Not const! */
+ static float bjc_letter[4] = { BJC_MARGINS_LETTER }; /* Not const! */
+ static float bjc_a4[4] = { BJC_MARGINS_A4 }; /* Not const! */
+
+ const float _ds *m = (float _ds*) 0;
+
+ /* Set up colour params if put_params has not already done so */
+ if (pdev->color_info.num_components == 0)
+ { int code = cdj_set_bpp(pdev, pdev->color_info.depth,
+ pdev->color_info.num_components);
+ if ( code < 0 )
+ return code;
+ }
+
+ switch (ptype) {
+ case DJ500C:
+ case DJ550C:
+ m = (gdev_pcl_paper_size(pdev) == PAPER_SIZE_A4 ? dj_a4 :
+ dj_letter);
+ break;
+ case DNJ650C:
+ m = dnj_all;
+ break;
+ case LJ4DITH:
+ m = lj4_all;
+ break;
+ case PJ180:
+ case PJXL300:
+ case PJXL180:
+ m = pj_all;
+ break;
+ case ESC_P:
+ m = (gdev_pcl_paper_size(pdev) == PAPER_SIZE_A4 ? ep_a4 :
+ ep_letter);
+ break;
+ case BJC600:
+ case BJC800:
+ switch (gdev_pcl_paper_size(pdev)) {
+ case PAPER_SIZE_LEGAL:
+ case PAPER_SIZE_LETTER:
+ m = bjc_letter;
+ break;
+
+ case PAPER_SIZE_A0:
+ case PAPER_SIZE_A1:
+ case PAPER_SIZE_A3:
+ m = bjc_a3;
+ break;
+
+ default:
+ m = bjc_a4;
+ }
+
+#ifndef USE_FIXED_MARGINS
+ if (ptype == BJC800) {
+ ((float _ds*) m)[1] = BJC_HARD_LOWER_LIMIT;
+ }
+#endif
+
+ bjc->printLimit = m[3]; /* The real hardware limit. */
+
+#ifdef BJC_DEFAULT_CENTEREDAREA
+ if (m[3] < m[1]) {
+ ((float _ds*) m)[3] = m[1]; /* Top margin = bottom one. */
+ } else {
+ ((float _ds*) m)[1] = m[3]; /* Bottom margin = top one. */
+ }
+#endif
+
+ break;
+
+ /*NOTREACHED*/
+
+ /*
+ * The margins must be set so that the resulting page length will be
+ * expressed exactly as a multiple of tenthes of inches.
+ *
+ */
+
+ /**/ {
+ float _ds *bjcm = (float _ds*) m;
+
+ byte pdimen = (byte)
+ (pdev->height / pdev->y_pixels_per_inch * 10.
+ - bjcm[3] * 10. - bjcm[1] * 10. + .5) + 1;
+ do {
+ --pdimen;
+ bjcm[1] = pdev->height / pdev->y_pixels_per_inch
+ - bjcm[3] - (float) pdimen / 10.;
+ } while (bjcm[1] < BJC_LOWER_LIMIT);
+ }
+
+ break;
+ }
+ gx_device_set_margins(pdev, m, true);
+ return gdev_prn_open(pdev);
+}
+
+/* Added parameters for DeskJet 5xxC */
+
+/* Get parameters. In addition to the standard and printer
+ * parameters, we supply shingling and depletion parameters,
+ * and control over the bits-per-pixel used in output rendering */
+private int
+cdj_get_params(gx_device *pdev, gs_param_list *plist)
+{ int code = gdev_prn_get_params(pdev, plist);
+ if ( code < 0 ||
+ (code = param_write_int(plist, "BlackCorrect", (int *)&cdj->correction)) < 0 ||
+ (code = param_write_int(plist, "Shingling", &cdj->shingling)) < 0 ||
+ (code = param_write_int(plist, "Depletion", &cdj->depletion)) < 0
+ )
+ return code;
+
+ return code;
+}
+
+/* Put parameters. */
+private int
+cdj_put_params(gx_device *pdev, gs_param_list *plist)
+{ int correction = cdj->correction;
+ int shingling = cdj->shingling;
+ int depletion = cdj->depletion;
+ int bpp = 0;
+ int code = 0;
+
+ code = cdj_put_param_int(plist, "BlackCorrect", &correction, 0, 9, code);
+ code = cdj_put_param_int(plist, "Shingling", &shingling, 0, 2, code);
+ code = cdj_put_param_int(plist, "Depletion", &depletion, 1, 3, code);
+ code = cdj_put_param_int(plist, "BitsPerPixel", &bpp, 1, 32, code);
+
+ if ( code < 0 )
+ return code;
+ code = cdj_put_param_bpp(pdev, plist, bpp, bpp, 0);
+ if ( code < 0 )
+ return code;
+
+ cdj->correction = correction;
+ cdj->shingling = shingling;
+ cdj->depletion = depletion;
+ return 0;
+}
+
+/* Added parameters for PaintJet XL and PaintJet XL300 */
+
+/* Get parameters. In addition to the standard and printer
+ * parameters, we supply print_quality and render_type
+ * parameters, together with bpp control. */
+private int
+pjxl_get_params(gx_device *pdev, gs_param_list *plist)
+{ int code = gdev_prn_get_params(pdev, plist);
+ if ( code < 0 ||
+ (code = param_write_int(plist, "PrintQuality", &pjxl->printqual)) < 0 ||
+ (code = param_write_int(plist, "RenderType", &pjxl->rendertype)) < 0
+ )
+ return code;
+
+ return code;
+}
+
+/* Put parameters. */
+private int
+pjxl_put_params(gx_device *pdev, gs_param_list *plist)
+{ int printqual = pjxl->printqual;
+ int rendertype = pjxl->rendertype;
+ int bpp = 0, real_bpp = 0;
+ int code = 0;
+
+ code = cdj_put_param_int(plist, "PrintQuality", &printqual, -1, 1, code);
+ code = cdj_put_param_int(plist, "RenderType", &rendertype, 0, 10, code);
+ code = cdj_put_param_int(plist, "BitsPerPixel", &bpp, 1, 32, code);
+
+ if ( code < 0 )
+ return code;
+ real_bpp = bpp;
+ if ( rendertype > 0 )
+ { /* If printer is doing the dithering, we must have a
+ * true-colour mode, ie. 16 or 24 bits per pixel */
+ if ( bpp > 0 && bpp < 16 )
+ real_bpp = 24;
+ }
+ code = cdj_put_param_bpp(pdev, plist, bpp, real_bpp, 0);
+ if ( code < 0 )
+ return code;
+
+ pjxl->printqual = printqual;
+ pjxl->rendertype = rendertype;
+ return 0;
+}
+
+/* Added parameters for PaintJet */
+
+/* Put parameters. In addition to the standard and printer */
+/* parameters, we allow control of the bits-per-pixel */
+private int
+pj_put_params(gx_device *pdev, gs_param_list *plist)
+{ int bpp = 0;
+ int code = cdj_put_param_int(plist, "BitsPerPixel", &bpp, 1, 32, 0);
+
+ if ( code < 0 )
+ return code;
+ return cdj_put_param_bpp(pdev, plist, bpp, bpp, 0);
+}
+
+private stringParamDescription bjc_processColorsStrings[] = {
+ { "DeviceGray", 1 },
+ { "DeviceRGB", 3 },
+ { "DeviceCMYK", 4 },
+ { 0 }
+};
+
+private stringParamDescription bjc_mediaTypeStrings[] = {
+ { "PlainPaper", BJC_MEDIA_PLAINPAPER },
+ { "CoatedPaper", BJC_MEDIA_COATEDPAPER },
+ { "TransparencyFilm", BJC_MEDIA_TRANSPARENCYFILM },
+ { "Envelope", BJC_MEDIA_ENVELOPE },
+ { "Card", BJC_MEDIA_CARD},
+ { "Other", BJC_MEDIA_OTHER },
+ { 0 }
+};
+
+private stringParamDescription bjc600_printQualityStrings[] = {
+ { "Normal", 0 },
+ { "High", 1 },
+ { "Draft", 2 },
+ { 0 }
+};
+
+private stringParamDescription bjc800_printQualityStrings[] = {
+ { "Normal", 0 },
+ { "High", 1 },
+ { "Low", 3 },
+ { "Draft", 4 },
+ { 0 },
+};
+
+private stringParamDescription bjc_ditheringTypeStrings[] = {
+ { "None", BJC_DITHER_NONE },
+ { "Floyd-Steinberg", BJC_DITHER_FS },
+ { 0 }
+};
+
+private int
+bjc_get_params(gx_device *pdev, gs_param_list *plist)
+{
+ int code = gdev_prn_get_params(pdev, plist);
+ int ncode;
+
+ gs_param_string pmedia;
+ gs_param_string pquality;
+ gs_param_string dithering;
+
+ if (code < 0) return_error(code);
+
+ if ((ncode = param_write_bool(plist, BJC_OPTION_MANUALFEED,
+ &bjcparams.manualFeed)) < 0) {
+ code = ncode;
+ }
+
+ code = get_param_string(plist, (unsigned char *)BJC_OPTION_MEDIATYPE, &pmedia,
+ bjc_mediaTypeStrings, bjcparams.mediaType, true, code);
+
+ code = get_param_string(plist, (unsigned char *)BJC_OPTION_PRINTQUALITY, &pquality,
+ (bjc->ptype == BJC800 ? bjc800_printQualityStrings :
+ bjc600_printQualityStrings), bjcparams.printQuality,
+ true, code);
+
+ code = get_param_string(plist, (unsigned char *)BJC_OPTION_DITHERINGTYPE, &dithering,
+ bjc_ditheringTypeStrings, bjcparams.ditheringType, true, code);
+
+ if ((ncode = param_write_int(plist, BJC_OPTION_PRINTCOLORS,
+ &bjcparams.printColors)) < 0) {
+ code = ncode;
+ }
+
+ if ((ncode = (bjcparams.mediaWeight_isSet ?
+ param_write_int(plist, BJC_OPTION_MEDIAWEIGHT,
+ &bjcparams.mediaWeight) :
+ param_write_null(plist, BJC_OPTION_MEDIAWEIGHT))) < 0) {
+ code = ncode;
+ }
+
+ if (bjc->ptype != BJC800) {
+ if ((ncode = param_write_bool(plist, BJC_OPTION_MONOCHROMEPRINT,
+ &bjc600params.monochromePrint)) < 0) {
+ code = ncode;
+ }
+ }
+
+ /**/ {
+ float version;
+ gs_param_string versionString;
+
+ bool bTrue = true;
+
+ version = bjcversion(pdev);
+ versionString.data = (byte *)bjcversionstring(pdev);
+
+ versionString.size = strlen((char *)versionString.data);
+ versionString.persistent = true;
+
+ if ((ncode = param_write_float(plist, BJC_DEVINFO_VERSION,
+ &version)) < 0) {
+ code = ncode;
+ }
+ if ((ncode = param_write_string(plist, BJC_DEVINFO_VERSIONSTRING,
+ &versionString)) < 0) {
+ code = ncode;
+ }
+
+ if ((ncode = param_write_bool(plist, BJC_DEVINFO_OUTPUTFACEUP,
+ &bTrue)) < 0) {
+ code = ncode;
+ }
+ }
+
+ return code;
+}
+
+/* Put properties for the bjc drivers. */
+
+private int
+bjc_put_params(gx_device *pdev, gs_param_list *plist)
+{
+ int bpp = 0, ccomps = 0;
+
+ int code = 0;
+ int ncode;
+
+ bool aBool = true;
+
+ const char* oname = (const char*) 0;
+
+ bjc600_params new600Params;
+ bjc800_params new800Params;
+
+ bjc_params* params;
+
+ gs_param_string pprocesscolors;
+ gs_param_string pmedia;
+ gs_param_string pquality;
+
+ gs_param_float_array hwra;
+
+ if (bjc->ptype != BJC800) {
+ new600Params = bjc600params;
+ params = (bjc_params*) &new600Params;
+ } else {
+ new800Params = bjc800params;
+ params = (bjc_params*) &new800Params;
+ }
+
+ if ((code = cdj_put_param_int(plist, "BitsPerPixel",
+ &bpp, 1, 32, code)) != 1) {
+ bpp = pdev->color_info.depth;
+ }
+
+ if ((code = put_param_string(plist, (unsigned char *)"ProcessColorModel",
+ &pprocesscolors, bjc_processColorsStrings, &ccomps, code)) != 1) {
+ ccomps = pdev->color_info.num_components;
+ }
+
+ if ((ncode = param_read_bool(plist, oname = BJC_OPTION_MANUALFEED,
+ &params->manualFeed)) < 0) {
+ param_signal_error(plist, oname, code = ncode);
+ }
+
+ code = put_param_string(plist, (unsigned char *)BJC_OPTION_MEDIATYPE, &pmedia,
+ bjc_mediaTypeStrings, &params->mediaType, code);
+
+ code = cdj_put_param_int(plist, BJC_OPTION_PRINTCOLORS,
+ &params->printColors, 0, 15, code);
+
+ code = put_param_string(plist, (unsigned char *)BJC_OPTION_PRINTQUALITY, &pquality,
+ (bjc->ptype == BJC800 ? bjc800_printQualityStrings :
+ bjc600_printQualityStrings), &params->printQuality, code);
+
+ switch (ncode = param_read_int(plist,
+ oname = BJC_OPTION_MEDIAWEIGHT, &params->mediaWeight)) {
+ case 0:
+ if (params->mediaWeight <= 0) {
+ ncode = gs_error_rangecheck;
+ } else {
+ params->mediaWeight_isSet = 1;
+ break;
+ }
+ goto mwe;
+
+ default:
+ if ((ncode = param_read_null(plist, oname)) == 0) {
+ params->mediaWeight_isSet = 0;
+ break;
+ }
+mwe: param_signal_error(plist, oname, code = ncode);
+
+ case 1:
+ break;
+ }
+
+ if (bjc->ptype != BJC800) {
+ bjc600_params* params600 = (bjc600_params*) params;
+ if ((ncode = param_read_bool(plist,
+ oname = BJC_OPTION_MONOCHROMEPRINT,
+ &params600->monochromePrint)) < 0) {
+ param_signal_error(plist, oname, code = ncode);
+ }
+ }
+
+ if ((ncode = cdj_param_check_float(plist, BJC_DEVINFO_VERSION,
+ bjcversion(pdev), true)) < 0) {
+ code = ncode;
+ }
+ if ((ncode = cdj_param_check_string(plist, BJC_DEVINFO_VERSIONSTRING,
+ bjcversionstring(pdev), true)) < 0) {
+ code = ncode;
+ }
+
+ if ((ncode = param_read_bool(plist, oname = BJC_DEVINFO_OUTPUTFACEUP,
+ &aBool)) < 0) {
+ param_signal_error(plist, oname, code = ncode);
+ } else if (aBool != true) {
+ param_signal_error(plist, oname, code = ncode = gs_error_rangecheck);
+ }
+
+ /* Check for invalid resolution. The array macros are taken from
+ gsdparam.c and modified to use oname, ncode and code instead
+ of param_name, code and ecode respectively. */
+
+ BEGIN_ARRAY_PARAM(param_read_float_array, "HWResolution", hwra, 2, hwre)
+ if ( hwra.data[0] <= 0 || hwra.data[1] <= 0 ||
+ hwra.data[0] != hwra.data[1] )
+ ncode = gs_error_rangecheck;
+ else {
+#ifdef BJC_STRICT
+ if (hwra.data[0] != BJC_RESOLUTION_LOW &&
+ hwra.data[0] != BJC_RESOLUTION_NORMAL &&
+ hwra.data[0] != BJC_RESOLUTION_HIGH) {
+ ncode = gs_error_rangecheck;
+ }
+#else
+ /* A small hack for checking resolution without logarithms. */
+
+ /**/ {
+ int n;
+
+ for (n = 0; n < 8 * sizeof(n) / BJC_RESOLUTION_BASE; ++n) {
+ float res = BJC_RESOLUTION_BASE * (1 << n);
+
+ if (res == hwra.data[0]) break;
+
+ if (res > hwra.data[0]) {
+ ncode = gs_error_rangecheck;
+ }
+ }
+
+ if (n == 8 * sizeof(n)) {
+ ncode = gs_error_rangecheck;
+ }
+ }
+#endif
+ if (ncode < 0) {
+ code = ncode;
+ } else {
+ break;
+ }
+ }
+ END_PARAM(hwra, hwre)
+
+ if ((ncode = cdj_put_param_bpp(pdev, plist, bpp, bpp, ccomps)) < 0) {
+ code = ncode;
+ }
+
+ if (code < 0)
+ return code;
+
+ if (bpp == 1) {
+ params->ditheringType = BJC_DITHER_NONE;
+ }
+
+ /* Write values that did change */
+
+ if (bjc->ptype != BJC800) {
+ bjc600params = new600Params;
+ } else {
+ bjc800params = new800Params;
+ }
+
+ return code;
+}
+
+/* ------ Internal routines ------ */
+
+/* The DeskJet500C can compress (mode 9) */
+private int
+dj500c_print_page(gx_device_printer * pdev, FILE * prn_stream)
+{
+ return hp_colour_print_page(pdev, prn_stream, DJ500C);
+}
+
+/* The DeskJet550C can compress (mode 9) */
+private int
+dj550c_print_page(gx_device_printer * pdev, FILE * prn_stream)
+{
+ return hp_colour_print_page(pdev, prn_stream, DJ550C);
+}
+
+/* The DesignJet650C can compress (mode 1) */
+private int
+dnj650c_print_page(gx_device_printer * pdev, FILE * prn_stream)
+{
+ return hp_colour_print_page(pdev, prn_stream, DNJ650C);
+}
+
+private int
+lj4dith_print_page(gx_device_printer * pdev, FILE * prn_stream)
+{
+ return hp_colour_print_page(pdev, prn_stream, LJ4DITH);
+}
+
+/* The PJXL300 can compress (modes 2 & 3) */
+private int
+pjxl300_print_page(gx_device_printer * pdev, FILE * prn_stream)
+{ int ret_code;
+ /* Ensure we're operating in PCL mode */
+ fputs("\033%-12345X@PJL enter language = PCL\n", prn_stream);
+ ret_code = hp_colour_print_page(pdev, prn_stream, PJXL300);
+ /* Reenter switch-configured language */
+ fputs("\033%-12345X", prn_stream);
+ return ret_code;
+}
+
+/* The PaintJet XL can compress (modes 2 & 3) */
+private int
+pjxl_print_page(gx_device_printer * pdev, FILE * prn_stream)
+{
+ return hp_colour_print_page(pdev, prn_stream, PJXL180);
+}
+
+/* The PaintJet can compress (mode 1) */
+private int
+pj_print_page(gx_device_printer * pdev, FILE * prn_stream)
+{
+ return hp_colour_print_page(pdev, prn_stream, PJ180);
+}
+
+/* The LJ250 can compress (mode 1) */
+private int
+declj250_print_page(gx_device_printer * pdev, FILE * prn_stream)
+{ int ret_code;
+ fputs("\033%8", prn_stream); /* Enter PCL emulation mode */
+ ret_code = hp_colour_print_page(pdev, prn_stream, DECLJ250);
+ fputs("\033%@", prn_stream); /* Exit PCL emulation mode */
+ return ret_code;
+}
+
+/* The BJC-600 cannot compress w/o raster image commands. */
+private int
+escp_print_page(gx_device_printer * pdev, FILE * prn_stream)
+{
+ return hp_colour_print_page(pdev, prn_stream, ESC_P);
+}
+
+/* The BJC-600 can compress w/ raster image commands. */
+private int
+bjc_print_page(gx_device_printer * pdev, FILE * prn_stream)
+{
+ return hp_colour_print_page(pdev, prn_stream, bjc->ptype);
+}
+
+/* MACROS FOR DITHERING (we use macros for compact source and faster code) */
+/* Floyd-Steinberg dithering. Often results in a dramatic improvement in
+ * subjective image quality, but can also produce dramatic increases in
+ * amount of printer data generated and actual printing time!! Mode 9 2D
+ * compression is still useful for fairly flat colour or blank areas but its
+ * compression is much less effective in areas where the dithering has
+ * effectively randomised the dot distribution. */
+
+#define SHIFT ((I * 8) - 13)
+#define RSHIFT ((I * 8) - 16)
+#define RANDOM (((rand() << RSHIFT) % (MAXVALUE / 2)) - MAXVALUE / 4);
+#define MINVALUE 0
+#define MAXVALUE (255 << SHIFT)
+#define THRESHOLD (128 << SHIFT)
+#define C 8
+
+#define FSdither(inP, out, errP, Err, Bit, Offset, Element)\
+ oldErr = Err;\
+ Err = (errP[Element] + ((Err * 7 + C) >> 4) + ((int)inP[Element] << SHIFT));\
+ if (Err > THRESHOLD) {\
+ out |= Bit;\
+ Err -= MAXVALUE;\
+ }\
+ errP[Element + Offset] += ((Err * 3 + C) >> 4);\
+ errP[Element] = ((Err * 5 + oldErr + C) >> 4);
+
+/* Here we rely on compiler optimisation to remove lines of the form
+ * (if (1 >= 4) {...}, ie. the constant boolean expressions */
+
+/* The original code is in the #else part. Since by default NEW_DITHER
+ is not defined, the old code is used. No enhancement is visible for the
+ bjc600 drivers with the new code, anyway :-( */
+
+#ifdef NEW_DITHER
+
+#define FSDline(scan, i, j, plane_size, cErr, mErr, yErr, kErr, cP, mP, yP, kP, n)\
+{\
+ if (scan == 0) { /* going_up */\
+ for (i = 0; i < plane_size; i++) {\
+ byte c, y, m, k, bitmask;\
+ int oldErr;\
+ bitmask = 0x80;\
+ for (c = m = y = k = 0; bitmask != 0; bitmask >>= 1) {\
+ if (n >= 4) {\
+ FSdither(dp, k, ep, kErr, bitmask, -n, 0);\
+ }\
+ if (n >= 3) {\
+ FSdither(dp, c, ep, cErr, bitmask, -n, n - 3);\
+ FSdither(dp, m, ep, mErr, bitmask, -n, n - 2);\
+ }\
+ FSdither(dp, y, ep, yErr, bitmask, -n, n - 1);\
+ dp += n, ep += n;\
+ }\
+ if (n >= 4)\
+ *kP++ = k;\
+ if (n >= 3) {\
+ *cP++ = c;\
+ *mP++ = m;\
+ }\
+ *yP++ = y;\
+ }\
+ } else { /* going_down */\
+ for (i = 0; i < plane_size; i++) {\
+ byte c, y, m, k, bitmask;\
+ int oldErr;\
+ bitmask = 0x01;\
+ for (c = m = y = k = 0; bitmask != 0; bitmask <<= 1) {\
+ dp -= n, ep -= n;\
+ FSdither(dp, y, ep, yErr, bitmask, n, n - 1);\
+ if (n >= 3) {\
+ FSdither(dp, m, ep, mErr, bitmask, n, n - 2);\
+ FSdither(dp, c, ep, cErr, bitmask, n, n - 3);\
+ }\
+ if (n >= 4) {\
+ FSdither(dp, k, ep, kErr, bitmask, n, 0);\
+ }\
+ }\
+ *--yP = y;\
+ if (n >= 3)\
+ { *--mP = m;\
+ *--cP = c;\
+ }\
+ if (n >= 4)\
+ *--kP = k;\
+ }\
+ }\
+}
+
+#else
+
+#define FSDline(scan, i, j, plane_size, cErr, mErr, yErr, kErr, cP, mP, yP, kP, n)\
+{\
+ if (scan == 0) { /* going_up */\
+ for (i = 0; i < plane_size; i++) {\
+ byte c, y, m, k, bitmask;\
+ int oldErr;\
+ bitmask = 0x80;\
+ for (c = m = y = k = 0; bitmask != 0; bitmask >>= 1) {\
+ if (n >= 4) {\
+ if (*dp) {\
+ FSdither(dp, k, ep, kErr, bitmask, -n, 0);\
+ cErr = mErr = yErr = 0;\
+ } else {\
+ FSdither(dp, c, ep, cErr, bitmask, -n, n - 3);\
+ FSdither(dp, m, ep, mErr, bitmask, -n, n - 2);\
+ FSdither(dp, y, ep, yErr, bitmask, -n, n - 1);\
+ }\
+ } else {\
+ if (n >= 3) {\
+ FSdither(dp, c, ep, cErr, bitmask, -n, n - 3);\
+ FSdither(dp, m, ep, mErr, bitmask, -n, n - 2);\
+ }\
+ FSdither(dp, y, ep, yErr, bitmask, -n, n - 1);\
+ }\
+ dp += n, ep += n;\
+ }\
+ if (n >= 4)\
+ *kP++ = k;\
+ if (n >= 3) {\
+ *cP++ = c;\
+ *mP++ = m;\
+ }\
+ *yP++ = y;\
+ }\
+ } else { /* going_down */\
+ for (i = 0; i < plane_size; i++) {\
+ byte c, y, m, k, bitmask;\
+ int oldErr;\
+ bitmask = 0x01;\
+ for (c = m = y = k = 0; bitmask != 0; bitmask <<= 1) {\
+ dp -= n, ep -= n;\
+ if (n >= 4) {\
+ if (*dp) {\
+ FSdither(dp, k, ep, kErr, bitmask, n, 0);\
+ cErr = mErr = yErr = 0;\
+ } else {\
+ FSdither(dp, y, ep, yErr, bitmask, n, n - 1);\
+ FSdither(dp, m, ep, mErr, bitmask, n, n - 2);\
+ FSdither(dp, c, ep, cErr, bitmask, n, n - 3);\
+ }\
+ } else {\
+ FSdither(dp, y, ep, yErr, bitmask, n, n - 1);\
+ if (n >= 3) {\
+ FSdither(dp, m, ep, mErr, bitmask, n, n - 2);\
+ FSdither(dp, c, ep, cErr, bitmask, n, n - 3);\
+ }\
+ }\
+ }\
+ *--yP = y;\
+ if (n >= 3)\
+ { *--mP = m;\
+ *--cP = c;\
+ }\
+ if (n >= 4)\
+ *--kP = k;\
+ }\
+ }\
+}
+
+#endif
+
+/* END MACROS FOR DITHERING */
+
+#define CPbit(inP, out, Bit, Element)\
+ if (inP[Element]) {\
+ out |= Bit;\
+ }
+
+#define COPYline(scan, i, j, plane_size, cP, mP, yP, kP, n)\
+{\
+ if (scan == 0) { /* going_up */\
+ for (i = 0; i < plane_size; i++) {\
+ byte c, y, m, k, bitmask;\
+ bitmask = 0x80;\
+ for (c = m = y = k = 0; bitmask != 0; bitmask >>= 1) {\
+ if (n >= 4) {\
+ CPbit(dp, k, bitmask, 0);\
+ } \
+ if (n >= 3) {\
+ CPbit(dp, c, bitmask, n - 3);\
+ CPbit(dp, m, bitmask, n - 2);\
+ }\
+ CPbit(dp, y, bitmask, n - 1);\
+ dp += n, ep += n;\
+ }\
+ if (n >= 4)\
+ *kP++ = k;\
+ if (n >= 3) {\
+ *cP++ = c;\
+ *mP++ = m;\
+ }\
+ *yP++ = y;\
+ }\
+ } else { /* going_down */\
+ for (i = 0; i < plane_size; i++) {\
+ byte c, y, m, k, bitmask;\
+ bitmask = 0x01;\
+ for (c = m = y = k = 0; bitmask != 0; bitmask <<= 1) {\
+ dp -= n, ep -= n;\
+ if (n >= 4) {\
+ CPbit(dp, k, bitmask, 0);\
+ }\
+ if (n >= 3) {\
+ CPbit(dp, m, bitmask, n - 2);\
+ CPbit(dp, c, bitmask, n - 3);\
+ }\
+ CPbit(dp, y, bitmask, n - 1);\
+ }\
+ *--yP = y;\
+ if (n >= 3)\
+ { *--mP = m;\
+ *--cP = c;\
+ }\
+ if (n >= 4)\
+ *--kP = k;\
+ }\
+ }\
+}
+
+/* Some convenient shorthand .. */
+#define x_dpi (pdev->x_pixels_per_inch)
+#define y_dpi (pdev->y_pixels_per_inch)
+#define CONFIG_16BIT "\033*v6W\000\003\000\005\006\005"
+#define CONFIG_24BIT "\033*v6W\000\003\000\010\010\010"
+
+/* To calculate buffer size as next greater multiple of both parameter and W */
+#define calc_buffsize(a, b) (((((a) + ((b) * W) - 1) / ((b) * W))) * W)
+
+
+/*
+ * Miscellaneous functions for Canon BJC-600 printers in raster command mode.
+ */
+#define fputshort(n, f) fputc((n)%256,f);fputc((n)/256,f)
+
+private int
+bjc_cmd(byte cmd, int argsize, byte* arg, gx_device_printer* pdev,
+ FILE* stream)
+{
+ fputs("\033(", stream);
+ putc(cmd, stream);
+ fputshort(argsize, stream);
+ fwrite(arg, sizeof(byte), argsize, stream);
+
+ return 0;
+}
+
+
+private int
+bjc_raster_cmd_sub(char c, int rastsize, byte* data, FILE* stream)
+{
+ fputs("\033(A", stream);
+ fputshort(rastsize + 1, stream);
+ putc(c, stream);
+ fwrite(data, sizeof(byte), rastsize, stream);
+ putc('\015', stream);
+
+ return 0;
+}
+
+private int
+bjc_raster_cmd(int c_id, int rastsize, byte* data, gx_device_printer* pdev,
+ FILE* stream)
+{
+ if (bjcparams.printColors == BJC_COLOR_ALLBLACK) {
+ bjc_raster_cmd_sub('K', rastsize, data, stream);
+ } else if (pdev->color_info.num_components == 1) {
+ if (bjcparams.printColors & BJC_COLOR_BLACK) {
+ bjc_raster_cmd_sub('K', rastsize, data, stream);
+ } else {
+ if (bjcparams.printColors & BJC_COLOR_YELLOW)
+ bjc_raster_cmd_sub('Y', rastsize, data, stream);
+ if (bjcparams.printColors & BJC_COLOR_MAGENTA)
+ bjc_raster_cmd_sub('M', rastsize, data, stream);
+ if (bjcparams.printColors & BJC_COLOR_CYAN)
+ bjc_raster_cmd_sub('C', rastsize, data, stream);
+ }
+ }else { /* Color decomposition */
+ private byte ymckCodes[] = {
+ BJC_COLOR_YELLOW,
+ BJC_COLOR_MAGENTA,
+ BJC_COLOR_CYAN,
+ BJC_COLOR_BLACK,
+ };
+
+ if (bjcparams.printColors & (int) ymckCodes[c_id]) {
+ bjc_raster_cmd_sub("YMCK"[c_id], rastsize, data, stream);
+ }
+ }
+
+ return 0;
+}
+
+private int
+bjc_init_page(gx_device_printer* pdev, FILE* stream)
+{
+ byte pagemargins[3], resolution[2], paperloading[2];
+
+ /* Compute page margins. */
+
+ pagemargins[0] = (byte) ((float) pdev->height / pdev->y_pixels_per_inch
+ * 10 + .5);
+ pagemargins[1] = (byte) 1;
+ pagemargins[2] = (byte) ((pdev->width / pdev->x_pixels_per_inch * 10) -
+ pdev->HWMargins[0] / 7.2 - pdev->HWMargins[2] / 7.2 + .5);
+
+ /* Cheat to keep margins into bounds (while waiting to have the right
+ margins for big papers. */
+
+ switch (bjc->ptype) {
+ case BJC800:
+ if (pagemargins[2] > 114) pagemargins[2] = 114;
+ break;
+
+ default:
+ if (pagemargins[2] > 80) pagemargins[2] = 80;
+ break;
+ }
+
+ /* Initialize resolution argument. */
+
+ resolution[0] = (byte) ((int)pdev->x_pixels_per_inch / 256);
+ resolution[1] = (byte) ((int)pdev->x_pixels_per_inch % 256);
+
+ /* Initialize paper loading argument. */
+
+ paperloading[0] = 0x10 + ((1 - bjcparams.manualFeed) << 2);
+ paperloading[1] = bjcparams.mediaType << 4;
+
+ /* Reinitialize printer in raster mode. */
+
+ fputs("\033[K", stream);
+ fputshort(2, stream);
+ fputc(0x00, stream);
+ fputc(0x0f, stream);
+
+ /* Set page mode on (ignore data at end of page) */
+
+ bjc_cmd('a', 1, (byte*) "\001", pdev, stream);
+
+ /* Set page margins */
+
+ bjc_cmd('g', 3, pagemargins, pdev, stream);
+
+ /* Set compression on (this is PackBits compression a la TIFF/Mac) */
+
+ bjc_cmd('b', 1, (byte*) "\001", pdev, stream);
+
+ /* Set paper loading. */
+
+ bjc_cmd('l', 2, paperloading, pdev, stream);
+
+ /* Set printing method. */
+
+#ifndef BJC_INIT_800_AS_600
+ if (bjc->ptype == BJC800) {
+#else
+ if (0) {
+#endif
+ byte printmode[2];
+
+ printmode[0] = bjcparams.printQuality;
+
+ /* Modes not used are 3 (CN, Color Normal) and 2 (TP+ (?)) */
+
+ switch (bjcparams.printQuality) {
+ case BJC_QUALITY_DRAFT:
+ printmode[0] = 4; /* Draft */
+ break;
+ }
+
+ printmode[1] = (bjcparams.mediaType >= BJC_MEDIA_ENVELOPE ? 1 :
+ bjc800thickpaper());
+
+ bjc_cmd('c', 2, printmode, pdev, stream);
+ } else /* BJC600 */ {
+ byte printmeth[3];
+
+ printmeth[0] = 0x10 + ((1 - bjcparams.manualFeed) << 2);
+ printmeth[1] = (bjcparams.mediaType << 4) + bjcparams.printQuality;
+ printmeth[2] = (bjcparams.printQuality == BJC_QUALITY_HIGH ?
+ 0x10 : 0) + (bjcparams.mediaType >= BJC_MEDIA_ENVELOPE ? 1 :
+ bjc600thickpaper());
+
+ bjc_cmd('c', 3, printmeth, pdev, stream);
+ }
+
+ /* Set raster resolution */
+
+ bjc_cmd('d', 2, resolution, pdev, stream);
+
+ return 0;
+}
+
+private int
+bjc_v_skip(int n, gx_device_printer* pdev, FILE* stream)
+{
+ if (n) {
+ fputs("\033(e", stream);
+ putc(2, stream);
+ putc(0, stream);
+ putc(n / 256, stream);
+ putc(n % 256, stream);
+ }
+
+ return 0;
+}
+
+private int
+bjc_finish_page(gx_device_printer* pdev, FILE* stream)
+{
+ bjc_cmd('a', 1, (byte*) "\000", pdev, stream);
+ bjc_cmd('b', 1, (byte*) "\000", pdev, stream);
+ fputc('\014', stream);
+ fputs("\033@", stream);
+
+ return 0;
+}
+
+/* 1D runlength compression for BJC-600
+ * this code is borrowed from gdevpcl.c:gdev_pcl_mode2compress.
+ */
+private int
+bjc_compress(const byte *row, const byte *end_row, byte *compressed)
+{
+ register const byte *exam = row;
+ register byte *cptr = compressed; /* output pointer into compressed bytes */
+
+
+ while ( exam < end_row ) {
+ /* Search ahead in the input looking for a run */
+ /* of at least 4 identical bytes. */
+ const byte *compr = exam;
+ const byte *end_dis;
+ const byte *next;
+ register byte test, test2;
+
+ test = *exam;
+ while ( exam < end_row ) {
+ test2 = *++exam;
+ if ( test == test2 )
+ break;
+ test = test2;
+ }
+
+
+ /* Find out how long the run is */
+ end_dis = exam - 1;
+ if ( exam == end_row ) { /* no run */
+ next = --end_row;
+ } else {
+
+ next = exam + 1;
+ while ( next < end_row && *next == test ) next++;
+ }
+
+
+ /* Now [compr..end_dis) should be encoded as dissimilar, */
+ /* and [end_dis..next) should be encoded as similar. */
+ /* Note that either of these ranges may be empty. */
+
+
+ for ( ; ; ) { /* Encode up to 128 dissimilar bytes */
+ uint count = end_dis - compr; /* uint for faster switch */
+ switch ( count ) { /* Use memcpy only if it's worthwhile. */
+ case 6: cptr[6] = compr[5];
+ case 5: cptr[5] = compr[4];
+ case 4: cptr[4] = compr[3];
+ case 3: cptr[3] = compr[2];
+ case 2: cptr[2] = compr[1];
+ case 1: cptr[1] = compr[0];
+ *cptr = count - 1;
+ cptr += count + 1;
+ case 0: /* all done */
+ break;
+ default:
+ if ( count > 128 ) count = 128;
+ *cptr++ = count - 1;
+ memcpy(cptr, compr, count);
+ cptr += count, compr += count;
+ continue;
+ }
+ break;
+ }
+
+
+ { /* Encode up to 128 similar bytes. */
+ /* Note that count may be <0 at end of row. */
+ int count = next - end_dis;
+ if (next < end_row || test != 0)
+ while ( count > 0 ) {
+
+ int this = (count > 128 ? 128 : count);
+ *cptr++ = 257 - this;
+ *cptr++ = (byte)test;
+ count -= this;
+ }
+ exam = next;
+ }
+ }
+ return cptr - compressed;
+}
+
+/*
+ * For the ESC/P mode, resolution is fixed as 360dpi and we must transform
+ * image data to serialized data.
+ */
+private word *ep_storage;
+private uint ep_storage_size_words;
+private byte *ep_raster_buf[4][BJC_HEAD_ROWS], *ep_print_buf;
+private int ep_num_comps, ep_plane_size, img_rows=BJC_HEAD_ROWS;
+
+
+#define row_bytes (img_rows / 8)
+#define row_words (row_bytes / sizeof(word))
+#define min_rows (32) /* for optimization of text image printing */
+
+
+private int
+ep_print_image(FILE *prn_stream, char cmd, byte *data, int size)
+{
+ static int ln_idx=0, vskip1=0, vskip2=0, real_rows;
+ int i;
+ static const char color[4] = {4,1,2,0};
+
+
+ switch (cmd) {
+ case 3: /* Black */
+ case 2: /* Cyan */
+ case 1: /* Magenta */
+ case 0: /* Yellow */
+ memcpy(ep_raster_buf[((int) cmd)][ln_idx+vskip2], data, size);
+ return 0;
+ case 'B': /* blank line skip */
+ if (!ln_idx) {
+ vskip1 += size;
+ } else if (size >= img_rows - (ln_idx+vskip2) || ln_idx+vskip2 >= min_rows) {
+ /* The 'I' cmd must precede 'B' cmd! */
+ vskip2 += size;
+ ep_print_image(prn_stream, 'F', 0, 0); /* flush and reset status */
+ } else {
+ vskip2 += size;
+ }
+ return 0;
+ case 'I': /* Increment index */
+ ln_idx += vskip2 + 1;
+ vskip2 = 0;
+ if (ln_idx < img_rows) return 0;
+ /* if ep_raster_buf filled up, then fall through here and flush buffer */
+ case 'F': /* flush print buffer */
+ if (!ln_idx) return 0; /* The end of the page. */
+
+
+ /* before print the image, perform vertical skip. */
+ while (vskip1 >= (255*2)) {
+ fputs("\033J\377", prn_stream); /* n/180in. feeding */
+ vskip1 -= (255*2);
+ }
+ if (vskip1 > 255) {
+ fputs("\033J\200", prn_stream);
+ vskip1 -= 256;
+ }
+ if (vskip1) {
+ /* n/360in. feeding */
+ fputs("\033|J", prn_stream); putc(0, prn_stream); putc(vskip1, prn_stream);
+ }
+
+
+ /* Optimize the number of nozzles to be used. */
+ if (ln_idx > 56) { /* use 64 nozzles */
+ real_rows = 64;
+ } else if (ln_idx > 48) { /* use 56 nozzles */
+ real_rows = 56;
+ } else if (ln_idx > 32) { /* use 48 nozzles */
+ real_rows = 48;
+ } else { /* use 32 nozzles */
+ real_rows = 32;
+ }
+
+
+ for (i = 0; i < ep_num_comps; i++) {
+ int lnum, hskip, print_size, img_rows;
+ byte *p0, *p1, *p2, *p3;
+ byte *inp, *inbuf, *outp, *outbuf;
+
+
+ img_rows = real_rows; /* Note that this img_rows is not the one that
+ * defined out of this function. */
+ outbuf = ep_print_buf;
+
+
+ /* Transpose raster image for serial printer image */
+ for (lnum=0; lnum < img_rows; lnum+=8, outbuf++) {
+ inbuf = inp = ep_raster_buf[i][lnum];
+ for (outp = outbuf; inp < inbuf+ep_plane_size; inp++, outp += img_rows) {
+ memflip8x8(inp, ep_plane_size, outp, row_bytes);
+ }
+ }
+
+
+ /* Set color */
+ if (ep_num_comps == 1) {
+ /* Don't set color (to enable user setting). */
+ putc('\015', prn_stream);
+ } else {
+ /* set color to one of CMYK. */
+ fputs("\015\033r", prn_stream);
+ putc(color[i], prn_stream);
+ }
+
+
+ *(outp = ep_print_buf + ep_plane_size * img_rows) = 1; /* sentinel */
+
+
+ p0 = p3 = ep_print_buf;
+
+
+ /* print image p0 to p1 and h skip p1 to p2 if p2<outp,
+ * then make p0=p2 and continue */
+ while (p0 < outp) {
+ static const word zeros[8] = {0,0,0,0,0,0,0,0};
+
+
+ if (p3 < outp) {
+ /* p1 is the head of running zeros. */
+ /* note that h skip unit is 1/180inch */
+ for (p1 = p3; !memcmp(p3, zeros, row_bytes*2); p3 += row_bytes*2);
+ /* p2 is the head of non zero image. */
+ p2 = p3;
+ redo:
+ for (p3 += row_bytes; memcmp(p3, zeros, row_bytes); p3 += row_bytes);
+ if (p3 < outp && memcmp(p3+row_bytes, zeros, row_bytes)) goto redo;
+ } else p1 = p2 = outp;
+
+
+ if (p0 < p1) { /* print the image between p0 and p1 */
+ print_size = ((p1 < outp) ? p1 : outp) - p0;
+ fputs("\033|B", prn_stream); putc(img_rows, prn_stream);
+ fputshort(print_size, prn_stream);
+ fwrite(p0, sizeof(byte), print_size, prn_stream);
+ }
+ if (p1 < p2) { /* skip running zeros from p1 to p2 */
+ hskip = (((p2 < outp) ? p2 : outp) - p1) / row_bytes / 2;
+ fputs("\033\\", prn_stream);
+ fputshort(hskip, prn_stream);
+ }
+ p0 = p2;
+ }
+ }
+ return ep_print_image(prn_stream, 'R', 0, vskip2 + ln_idx);
+ case 'R': /* Reset status */
+ ln_idx = 0;
+ vskip1 = size;
+ vskip2 = 0;
+ memset(ep_storage, 0, ep_storage_size_words * W);
+ return 0;
+ default: /* This should not happen */
+ fprintf(stderr, "ep_print_image: illegal command character `%c'.\n", cmd);
+ return 1;
+ }
+
+
+ /* NOT REACHED */
+}
+
+
+/* Send the page to the printer. Compress each scan line. */
+private int
+hp_colour_print_page(gx_device_printer * pdev, FILE * prn_stream, int ptype)
+{
+ uint raster_width = gdev_prn_rasterwidth(pdev, 1);
+/* int line_size = gdev_prn_rasterwidth(pdev, 0); */
+ int line_size = gdev_prn_raster(pdev);
+ int line_size_words = (line_size + W - 1) / W;
+ int paper_size = gdev_pcl_paper_size((gx_device *)pdev);
+ int num_comps = pdev->color_info.num_components;
+ int bits_per_pixel = pdev->color_info.depth;
+ int storage_bpp = bits_per_pixel;
+ int expanded_bpp = bits_per_pixel;
+ int plane_size, databuff_size;
+ int combined_escapes = 1;
+ int errbuff_size = 0;
+ int outbuff_size = 0;
+ int compression = 0;
+ int scan = 0;
+ int *errors[2];
+ const char *cid_string = (const char*) 0;
+ byte *data[4], *plane_data[4][4], *out_data;
+ byte *out_row, *out_row_alt;
+ word *storage;
+ uint storage_size_words;
+
+ /* Tricks and cheats ... */
+ switch (ptype) {
+ case DJ550C:
+ if (num_comps == 3 && !cprn_device->cmyk)
+ num_comps = 4; /* 4-component printing */
+ break;
+ case ESC_P:
+ if (bits_per_pixel == 24) /* prefer 3-component printing for bpp=24. */
+ num_comps = 3;
+ else
+ if (num_comps != 1)
+ num_comps = 4;
+ break;
+ case PJXL300:
+ case PJXL180:
+ if (pjxl->rendertype > 0) {
+ if (bits_per_pixel < 16)
+ pjxl->rendertype = 0;
+ else {
+ /* Control codes for CID sequence */
+ cid_string = (bits_per_pixel == 16) ? CONFIG_16BIT : CONFIG_24BIT;
+ /* Pretend we're a monobit device so we send the data out unchanged */
+ bits_per_pixel = storage_bpp = expanded_bpp = 1;
+ num_comps = 1;
+ }
+ }
+ break;
+ }
+
+ if (cprn_device->cmyk <= 0) {
+ if (storage_bpp == 8 && num_comps >= 3)
+ bits_per_pixel = expanded_bpp = 3; /* Only 3 bits of each byte used */
+ }
+
+ plane_size = calc_buffsize(line_size, storage_bpp);
+ ep_plane_size = plane_size;
+
+ if (bits_per_pixel == 1) { /* Data printed direct from i/p */
+ databuff_size = 0; /* so no data buffer required, */
+ outbuff_size = plane_size * 4; /* but need separate output buffers */
+ }
+
+ if (bits_per_pixel > 4) { /* Error buffer for FS dithering */
+ storage_bpp = expanded_bpp =
+ num_comps * 8; /* 8, 24 or 32 bits */
+
+ if (cprn_device->cmyk > 0) { /* Use CMYK dithering algorithm. */
+ errbuff_size = 4 * (5 + 1 + 1 + line_size + 1 + 2) * I;
+ } else { /* Use original (RGB) dithering. */
+ errbuff_size = /* 4n extra values for line ends */
+ calc_buffsize((plane_size * expanded_bpp + num_comps * 4) * I, 1);
+ }
+ }
+
+ databuff_size = plane_size * storage_bpp;
+
+ storage_size_words = ((plane_size + plane_size) * num_comps +
+ databuff_size + errbuff_size + outbuff_size) / W;
+
+ storage = (ulong *) gs_malloc(storage_size_words, W, "hp_colour_print_page");
+ ep_storage_size_words = (plane_size * (num_comps + 1)) / W * img_rows
+ + 16; /* Redundant space for sentinel and aligning. */
+ ep_storage = (word *) gs_malloc(ep_storage_size_words, W, "ep_print_buffer");
+
+ /*
+ * The principal data pointers are stored as pairs of values, with
+ * the selection being made by the 'scan' variable. The function of the
+ * scan variable is overloaded, as it controls both the alternating
+ * raster scan direction used in the Floyd-Steinberg dithering and also
+ * the buffer alternation required for line-difference compression.
+ *
+ * Thus, the number of pointers required is as follows:
+ *
+ * errors: 2 (scan direction only)
+ * data: 4 (scan direction and alternating buffers)
+ * plane_data: 4 (scan direction and alternating buffers)
+ */
+
+ if (storage == 0 || ep_storage == 0) /* can't allocate working area */
+ return_error(gs_error_VMerror);
+ else {
+ int i, j;
+ byte *p = out_data = out_row = (byte *)storage;
+ byte *ep_p = (byte *)ep_storage;
+ data[0] = data[1] = data[2] = p;
+ data[3] = p + databuff_size;
+ out_row_alt = out_row + plane_size * 2;
+ if (bits_per_pixel > 1) {
+ p += databuff_size;
+ }
+ if (bits_per_pixel > 4) {
+ errors[0] = (int *)p + num_comps * 2;
+ errors[1] = errors[0] + databuff_size;
+ p += errbuff_size;
+ }
+ for (i = 0; i < num_comps; i++) {
+ plane_data[0][i] = plane_data[2][i] = p;
+ p += plane_size;
+ }
+ for (i = 0; i < num_comps; i++) {
+ plane_data[1][i] = p;
+ plane_data[3][i] = p + plane_size;
+ p += plane_size;
+ }
+ if (bits_per_pixel == 1) {
+ out_data = out_row = p; /* size is outbuff_size * 4 */
+ out_row_alt = out_row + plane_size * 2;
+ data[1] += databuff_size; /* coincides with plane_data pointers */
+ data[3] += databuff_size;
+ }
+ for (i = 0; i < num_comps; i++) {
+ for (j = 0; j < img_rows; j++) {
+ ep_raster_buf[i][j] = ep_p;
+ ep_p += plane_size;
+ }
+ /* Make a sentinel and align to word size. */
+ ep_print_buf = (byte *)((word)(ep_p + sizeof(word)) & ~(sizeof(word)-1));
+ }
+ ep_num_comps = num_comps;
+ }
+
+ /* Initialize printer. */
+ if (ptype == BJC600 || ptype == BJC800) {
+ bjc_init_page(pdev, prn_stream);
+ } else {
+ if (ptype == LJ4DITH) {
+ fputs("\033*rB", prn_stream);
+ } else {
+ fputs("\033*rbC", prn_stream); /* End raster graphics */
+ }
+ fprintf(prn_stream, "\033*t%dR", (int)x_dpi);
+ /* Set resolution */
+ }
+
+ /* Clear temp storage */
+ memset(storage, 0, storage_size_words * W);
+
+#define DOFFSET (dev_t_margin(pdev) - DESKJET_PRINT_LIMIT) /* Print position */
+#define POFFSET (dev_t_margin(pdev) - PAINTJET_PRINT_LIMIT)
+#define EOFFSET (dev_t_margin(pdev) - ESC_P_PRINT_LIMIT)
+#define BOFFSET (dev_t_margin(pdev) - bjc->printLimit)
+ switch (ptype) {
+ case LJ4DITH:
+ /* Page size, orientation, top margin & perforation skip */
+ fprintf(prn_stream, "\033&l26A\033&l0o0e0L\033*r0F" );
+ fprintf(prn_stream, "\033*p0x0Y" ); /* These Offsets are hacked ! */
+ fprintf(prn_stream, "\033&u600D\033*r1A" );
+ /* Select data compression */
+ compression = 3;
+ combined_escapes = 0;
+ break;
+ case DJ500C:
+ case DJ550C:
+ /* Page size, orientation, top margin & perforation skip */
+ fprintf(prn_stream, "\033&l%daolE", paper_size);
+ /* Set depletion and shingling levels */
+ fprintf(prn_stream, "\033*o%dd%dQ", cdj->depletion, cdj->shingling);
+ /* Move to top left of printed area */
+ fprintf(prn_stream, "\033*p%dY", (int)(300 * DOFFSET));
+ /* Set number of planes ((-)1 is mono, (-)3 is (cmy)rgb, -4 is cmyk),
+ * and raster width, then start raster graphics */
+ fprintf(prn_stream, "\033*r%ds-%du0A", raster_width, num_comps);
+ /* Select data compression */
+ compression = 9;
+ break;
+ case DNJ650C:
+ fprintf (prn_stream, "\033%%0B"); /* Enter HPGL/2 mode */
+ fprintf (prn_stream, "BP5,1"); /* Turn off autorotation */
+ fprintf (prn_stream, "PS%d,%d",
+ (int)((pdev->height/pdev->y_pixels_per_inch)*1016),
+ (int)((pdev->width/pdev->x_pixels_per_inch)*1016)); /* Set length/width of page */
+ fprintf (prn_stream, "PU"); /* Pen up */
+ fprintf (prn_stream, "PA%d,%d", 0, 0); /* Move pen to upper-left */
+ fprintf (prn_stream, "\033%%1A"); /* Enter HP-RTL mode */
+ fprintf (prn_stream, "\033&a1N"); /* No negative motion - allow plotting
+ while receiving */
+ { static const char temp[] = {
+ 033, '*', 'v', '6', 'W',
+ 000 /* color model */,
+ 000 /* pixel encoding mode */,
+ 003 /* number of bits per index */,
+ 010 /* bits red */,
+ 010 /* bits green */,
+ 010 /* bits blue */
+ };
+ fwrite (temp, 1, sizeof(temp), prn_stream);
+ }
+
+ /* Set raster width */
+ fprintf(prn_stream, "\033*r%dS", raster_width);
+ /* Start raster graphics */
+ fprintf(prn_stream, "\033*r1A");
+
+ /* Select data compression */
+ compression = 1;
+ /* No combined escapes for raster transfers */
+ combined_escapes = 0;
+ break;
+ case PJXL300:
+ /* Page size, orientation, top margin & perforation skip */
+ fprintf(prn_stream, "\033&l%daolE", paper_size);
+ /* Set no-negative-motion mode, for faster (unbuffered) printing */
+ fprintf(prn_stream, "\033&a1N");
+ /* Set print quality */
+ fprintf(prn_stream, "\033*o%dQ", pjxl->printqual);
+ /* Move to top left of printed area */
+ fprintf(prn_stream, "\033*p%dY", (int)(300 * POFFSET));
+ /* Configure colour setup */
+ if (pjxl->rendertype > 0) {
+ /* Set render type */
+ fprintf(prn_stream, "\033*t%dJ", pjxl->rendertype);
+ /* Configure image data */
+ fputs(cid_string, prn_stream);
+ /* Set raster width, then start raster graphics */
+ fprintf(prn_stream, "\033*r%ds1A", raster_width);
+ } else {
+ /* Set number of planes (1 is mono, 3 is rgb),
+ * and raster width, then start raster graphics */
+ fprintf(prn_stream, "\033*r%ds-%du0A", raster_width, num_comps);
+ }
+ /* No combined escapes for raster transfers */
+ combined_escapes = 0;
+ break;
+ case PJXL180:
+ /* Page size, orientation, top margin & perforation skip */
+ fprintf(prn_stream, "\033&l%daolE", paper_size);
+ /* Set print quality */
+ fprintf(prn_stream, "\033*o%dQ", pjxl->printqual);
+ /* Move to top left of printed area */
+ fprintf(prn_stream, "\033*p%dY", (int)(180 * POFFSET));
+ /* Configure colour setup */
+ if (pjxl->rendertype > 0) {
+ /* Set render type */
+ fprintf(prn_stream, "\033*t%dJ", pjxl->rendertype);
+ /* Configure image data */
+ fputs(cid_string, prn_stream);
+ /* Set raster width, then start raster graphics */
+ fprintf(prn_stream, "\033*r%ds1A", raster_width);
+ } else {
+ /* Set number of planes (1 is mono, 3 is rgb),
+ * and raster width, then start raster graphics */
+ fprintf(prn_stream, "\033*r%ds%du0A", raster_width, num_comps);
+ }
+ break;
+ case PJ180:
+ case DECLJ250:
+ /* Disable perforation skip */
+ fprintf(prn_stream, "\033&lL");
+ /* Move to top left of printed area */
+ fprintf(prn_stream, "\033&a%dV", (int)(720 * POFFSET));
+ /* Set number of planes (1 is mono, 3 is rgb),
+ * and raster width, then start raster graphics */
+ fprintf(prn_stream, "\033*r%ds%du0A", raster_width, num_comps);
+ if (ptype == DECLJ250) {
+ /* No combined escapes for raster transfers */
+ combined_escapes = 0;
+ /* From here on, we're a standard Paintjet .. */
+ ptype = PJ180;
+ }
+ /* Select data compression */
+ compression = 1;
+ break;
+ case ESC_P:
+ /* Move to top left of printed area (must be modified for large movement(YK))*/
+ if ((int)(EOFFSET*360)) fprintf(prn_stream, "\033|J%c%c", 0, (int)(360*EOFFSET));
+ combined_escapes = 0;
+ break;
+ case BJC600:
+ case BJC800:
+ /* Move to top left of printed area */
+ bjc_v_skip((int)(pdev->HWResolution[1] * BOFFSET), pdev, prn_stream);
+ combined_escapes = 0;
+ compression = 2; /* BJC600 uses the same method as mode 2 compression */
+ break;
+ }
+
+ /* Unfortunately, the Paintjet XL300 PCL interpreter introduces a
+ * version of the PCL language which is different to all earlier HP
+ * colour and mono inkjets, in that it loses the very useful ability
+ * to use combined escape sequences with the raster transfer
+ * commands. In this respect, it is incompatible even with the older
+ * 180 dpi PaintJet and PaintJet XL printers! Another regrettable
+ * omission is that 'mode 9' compression is not supported, as this
+ * mode can give both computational and PCL file size advantages. */
+
+ if (combined_escapes) {
+ /* From now on, all escape commands start with \033*b, so we
+ * combine them (if the printer supports this). */
+ fputs("\033*b", prn_stream);
+ /* Set compression if the mode has been defined. */
+ if (compression)
+ fprintf(prn_stream, "%dm", compression);
+ }
+ else if (ptype == BJC600 || ptype == BJC800)
+ ; /* Currently, nothing to do. */
+ else
+ if (compression)
+ fprintf(prn_stream, "\033*b%dM", compression);
+
+ /* Send each scan line in turn */
+ {
+ int cErr, mErr, yErr, kErr;
+ int this_pass, lnum, i;
+ int start_rows;
+ int lend, num_blank_lines = 0;
+
+ word rmask = ~(word) 0 << ((-pdev->width * storage_bpp) & (W * 8 - 1));
+
+ lend = pdev->height - (dev_t_margin(pdev) + dev_b_margin(pdev)) * y_dpi;
+
+ switch (ptype) {
+ case BJC600:
+ case BJC800:
+ start_rows = BJC_HEAD_ROWS;
+ break;
+
+ /* Inhibit blank line printing for RGB-only printers, since in
+ * this case 'blank' means black! Also disabled for XL300 due to
+ * an obscure bug in the printer's firmware */
+
+ case PJ180:
+ case PJXL180:
+ case PJXL300:
+ start_rows = -1;
+ break;
+
+ default:
+ start_rows = (num_comps == 1) ? HEAD_ROWS_MONO - 1 :
+ HEAD_ROWS_COLOUR - 1;
+ break;
+ }
+
+ cErr = mErr = yErr = kErr = 0;
+
+ if (bits_per_pixel > 4) { /* Randomly seed initial error buffer */
+ if (cprn_device->cmyk > 0 && expanded_bpp == 32) {
+ bjc_fscmyk(data, plane_data, errors, plane_size, -1);
+ } else {
+ int *ep = errors[0];
+ for (i = 0; i < databuff_size; i++) {
+ *ep++ = RANDOM;
+ }
+ }
+ }
+
+ this_pass = start_rows;
+ for (lnum = 0; lnum < lend; lnum++) {
+ word *data_words = (word *)data[scan];
+ register word *end_data = data_words + line_size_words;
+
+ gdev_prn_copy_scan_lines(pdev, lnum, data[scan], line_size);
+
+ /* Mask off 1-bits beyond the line width. */
+ end_data[-1] &= rmask;
+
+ /* Remove trailing 0s. */
+ while (end_data > data_words && end_data[-1] == 0)
+ end_data--;
+ if (ptype != DNJ650C) /* DesignJet can't skip blank lines ? ? */
+ if (end_data == data_words) { /* Blank line */
+ num_blank_lines++;
+ continue;
+ }
+ /* Skip blank lines if any */
+ if (num_blank_lines > 0) {
+ if (ptype == ESC_P) {
+ ep_print_image(prn_stream, 'B', 0, num_blank_lines);
+ } else if (ptype == BJC600 || ptype == BJC800) {
+ bjc_v_skip(num_blank_lines, pdev, prn_stream);
+ } else if (num_blank_lines < this_pass) {
+ /* Moving down from current position
+ * causes head motion on the DeskJets, so
+ * if the number of lines is within the
+ * current pass of the print head, we're
+ * better off printing blanks. */
+ this_pass -= num_blank_lines;
+ if (combined_escapes) {
+ fputc('y', prn_stream); /* Clear current and seed rows */
+ for (; num_blank_lines; num_blank_lines--)
+ fputc('w', prn_stream);
+ } else {
+#if 0
+/**************** The following code has been proposed ****************/
+/**************** as a replacement: ****************/
+ fputs("\033*b1Y", prn_stream); /* Clear current and seed rows */
+ if ( num_blank_lines > 1 )
+ fprintf(prn_stream, "\033*b%dY", num_blank_lines - 1);
+ num_blank_lines = 0;
+#else
+ fputs("\033*bY", prn_stream); /* Clear current and seed rows */
+ if (ptype == DNJ650C) {
+ fprintf (prn_stream, "\033*b%dY", num_blank_lines);
+ num_blank_lines = 0;
+ }
+ else {
+ for (; num_blank_lines; num_blank_lines--)
+ fputs("\033*bW", prn_stream);
+ }
+#endif
+ }
+ } else {
+ if (combined_escapes)
+ fprintf(prn_stream, "%dy", num_blank_lines);
+ else
+ fprintf(prn_stream, "\033*b%dY", num_blank_lines);
+ }
+ memset(plane_data[1 - scan][0], 0, plane_size * num_comps);
+ num_blank_lines = 0;
+ this_pass = start_rows;
+ }
+ { /* Printing non-blank lines */
+ register byte *kP = plane_data[scan + 2][3];
+ register byte *cP = plane_data[scan + 2][2];
+ register byte *mP = plane_data[scan + 2][1];
+ register byte *yP = plane_data[scan + 2][0];
+ register byte *dp = data[scan + 2];
+ register int *ep = errors[scan];
+ int zero_row_count;
+ int i, j;
+ byte *odp;
+
+ if (this_pass)
+ this_pass--;
+ else
+ this_pass = start_rows;
+
+ if (expanded_bpp > bits_per_pixel) { /* Expand line if required */
+ cdj_expand_line(data_words, line_size,
+ cprn_device->cmyk,
+ bits_per_pixel, expanded_bpp);
+ }
+
+ /* In colour modes, we have some bit-shuffling to do before
+ * we can print the data; in FS mode we also have the
+ * dithering to take care of. */
+ switch (expanded_bpp) { /* Can be 1, 3, 8, 24 or 32 */
+ case 3:
+ /* Transpose the data to get pixel planes. */
+ for (i = 0, odp = plane_data[scan][0]; i < databuff_size;
+ i += 8, odp++) { /* The following is for 16-bit
+ * machines */
+#define spread3(c)\
+ { 0, c, c*0x100, c*0x101, c*0x10000L, c*0x10001L, c*0x10100L, c*0x10101L }
+ static ulong spr40[8] = spread3(0x40);
+ static ulong spr08[8] = spread3(8);
+ static ulong spr02[8] = spread3(2);
+ register byte *dp = data[scan] + i;
+ register ulong pword =
+ (spr40[dp[0]] << 1) +
+ (spr40[dp[1]]) +
+ (spr40[dp[2]] >> 1) +
+ (spr08[dp[3]] << 1) +
+ (spr08[dp[4]]) +
+ (spr08[dp[5]] >> 1) +
+ (spr02[dp[6]]) +
+ (spr02[dp[7]] >> 1);
+ odp[0] = (byte) (pword >> 16);
+ odp[plane_size] = (byte) (pword >> 8);
+ odp[plane_size * 2] = (byte) (pword);
+ }
+ break;
+
+ case 8:
+ switch (ptype) {
+ case BJC600:
+ case BJC800:
+ if (bjcparams.ditheringType == BJC_DITHER_NONE) {
+ COPYline(scan, i, j, plane_size, cP, mP, yP, kP, 1);
+ break;
+ }
+
+ default:
+ FSDline(scan, i, j, plane_size, cErr, mErr, yErr, kErr,
+ cP, mP, yP, kP, 1);
+ }
+ break;
+ case 24:
+ FSDline(scan, i, j, plane_size, cErr, mErr, yErr, kErr,
+ cP, mP, yP, kP, 3);
+ break;
+ case 32:
+ if (cprn_device->cmyk > 0) {
+ bjc_fscmyk(data, plane_data, errors, plane_size, scan);
+ } else {
+ FSDline(scan, i, j, plane_size, cErr, mErr, yErr, kErr,
+ cP, mP, yP, kP, 4);
+ }
+ break;
+
+ } /* switch(expanded_bpp) */
+
+ /* Make sure all black is in the k plane */
+
+ if (num_comps == 4 && (cprn_device->cmyk <= 0 || expanded_bpp != 32)) {
+ register word *kp = (word *)plane_data[scan][3];
+ register word *cp = (word *)plane_data[scan][2];
+ register word *mp = (word *)plane_data[scan][1];
+ register word *yp = (word *)plane_data[scan][0];
+ if (bits_per_pixel > 4) { /* Done as 4 planes */
+ for (i = 0; i < plane_size / W; i++) {
+ word bits = *cp & *mp & *yp;
+ *kp++ |= bits;
+ bits = ~bits;
+ *cp++ &= bits;
+ *mp++ &= bits;
+ *yp++ &= bits;
+ }
+ } else { /* This has really been done as 3 planes */
+ for (i = 0; i < plane_size / W; i++) {
+ word bits = *cp & *mp & *yp;
+ *kp++ = bits;
+ bits = ~bits;
+ *cp++ &= bits;
+ *mp++ &= bits;
+ *yp++ &= bits;
+ }
+ }
+ }
+
+ /* Transfer raster graphics in the order (K), C, M, Y */
+
+ for (zero_row_count = 0, i = num_comps - 1; i >= 0; i--) {
+ int output_plane = 1;
+ int out_count = 0;
+
+ switch (ptype) {
+ case DJ500C: /* Always compress using mode 9 */
+ case DJ550C:
+ out_count = gdev_pcl_mode9compress(plane_size,
+ plane_data[scan][i],
+ plane_data[1 - scan][i],
+ out_data);
+
+ /* This optimisation allows early termination of the
+ * row, but this doesn't work correctly in an alternating
+ * mode 2 / mode 3 regime, so we only use it with mode 9
+ * compression */
+ if (out_count == 0)
+ { output_plane = 0; /* No further output for this plane */
+ if (i == 0)
+ fputc('w', prn_stream);
+ else
+ zero_row_count++;
+ }
+ else
+ { for (; zero_row_count; zero_row_count--)
+ fputc('v', prn_stream);
+ }
+ break;
+ case PJ180:
+ case DNJ650C:
+ if (num_comps > 1)
+ { word *wp = (word *)plane_data[scan][i];
+ for (j = 0; j < plane_size / W; j++, wp++)
+ *wp = ~*wp;
+ }
+ out_count = gdev_pcl_mode1compress((const byte *)
+ plane_data[scan][i],
+ (const byte *)
+ plane_data[scan][i] + plane_size - 1,
+ out_data);
+ break;
+ case PJXL180: /* Need to invert data as CMY not supported */
+ if (num_comps > 1)
+ { word *wp = (word *)plane_data[scan][i];
+ for (j = 0; j < plane_size / W; j++, wp++)
+ *wp = ~*wp;
+ }
+ /* fall through .. */
+ case PJXL300: /* Compression modes 2 and 3 are both
+ * available. Try both and see which one
+ * produces the least output data. */
+ case LJ4DITH:
+ { const byte *plane = plane_data[scan][i];
+ byte *prev_plane = plane_data[1 - scan][i];
+ const word *row = (word *)plane;
+ const word *end_row = row + plane_size/W;
+ int count2 = gdev_pcl_mode2compress(row, end_row, out_row_alt);
+ int count3 = gdev_pcl_mode3compress(plane_size, plane, prev_plane, out_row);
+ int penalty = combined_escapes ? strlen("#m") : strlen("\033*b#M");
+ int penalty2 = (compression == 2 ? 0 : penalty);
+ int penalty3 = (compression == 3 ? 0 : penalty);
+
+ if (count3 + penalty3 < count2 + penalty2)
+ { if ( compression != 3 ) {
+ if (combined_escapes)
+ fputs("3m", prn_stream);
+ else
+ fputs("\033*b3M", prn_stream);
+ compression = 3;
+ }
+ out_data = out_row;
+ out_count = count3;
+ }
+ else
+ { if ( compression != 2 ) {
+ if (combined_escapes)
+ fputs("2m", prn_stream);
+ else
+ fputs("\033*b2M", prn_stream);
+ compression = 2;
+ }
+ out_data = out_row_alt;
+ out_count = count2;
+ }
+ }
+ break;
+ case BJC600:
+ case BJC800:
+ { const byte *plane = (byte *)plane_data[scan][i];
+ int count2 = bjc_compress(plane, plane + plane_size, out_row_alt);
+
+ out_data = out_row_alt;
+ out_count = count2;
+ }
+ break;
+ }
+ if (output_plane) {
+ if (combined_escapes)
+ fprintf(prn_stream, "%d%c", out_count, "wvvv"[i]);
+ else if (ptype == BJC600 || ptype == BJC800) {
+ if (out_count)
+ bjc_raster_cmd(num_comps == 1 ? 3 : i,
+ out_count, out_data, pdev, prn_stream);
+ if (i == 0) bjc_v_skip(1, pdev, prn_stream);
+ } else if (ptype == ESC_P)
+ ep_print_image(prn_stream, i, plane_data[scan][i], plane_size);
+ else
+ fprintf(prn_stream, "\033*b%d%c", out_count, "WVVV"[i]);
+ if (ptype < ESC_P)
+ fwrite(out_data, sizeof(byte), out_count, prn_stream);
+ }
+
+ } /* Transfer Raster Graphics ... */
+ if (ptype == ESC_P)
+ ep_print_image(prn_stream, 'I', 0, 0); /* increment line index */
+ scan = 1 - scan; /* toggle scan direction */
+ } /* Printing non-blank lines */
+ } /* for lnum ... */
+ } /* send each scan line in turn */
+
+ if (combined_escapes)
+ fputs("0M", prn_stream);
+
+ /* end raster graphics */
+ if (ptype == BJC600 || ptype == BJC800) {
+ bjc_finish_page(pdev, prn_stream);
+ }
+ else if (ptype != ESC_P)
+ fputs("\033*rbC\033E", prn_stream);
+
+ /* eject page */
+ if (ptype == PJ180)
+ fputc('\f', prn_stream);
+ else if (ptype == DNJ650C)
+ fputs ("\033*rC\033%0BPG;", prn_stream);
+ else if (ptype == BJC600 || ptype == BJC800)
+ ; /* Already done */
+ else if (ptype == ESC_P) {
+ ep_print_image(prn_stream, 'F', 0, 0); /* flush print buffer */
+ fputs("\014\033@", prn_stream); /* reset after eject page */
+ } else
+ fputs("\033&l0H", prn_stream);
+
+ /* free temporary storage */
+ gs_free((char *) ep_storage, ep_storage_size_words, W, "ep_print_buffer");
+ gs_free((char *) storage, storage_size_words, W, "hp_colour_print_page");
+
+ return 0;
+}
+
+/*
+ * Mode 9 2D compression for the HP DeskJet 5xxC. This mode can give
+ * very good compression ratios, especially if there are areas of flat
+ * colour (or blank areas), and so is 'highly recommended' for colour
+ * printing in particular because of the very large amounts of data which
+ * can be generated
+ */
+private int
+gdev_pcl_mode9compress(int bytecount, const byte * current, const byte * previous, byte * compressed)
+{
+ register const byte *cur = current;
+ register const byte *prev = previous;
+ register byte *out = compressed;
+ const byte *end = current + bytecount;
+
+ while (cur < end) { /* Detect a run of unchanged bytes. */
+ const byte *run = cur;
+ register const byte *diff;
+ int offset;
+ while (cur < end && *cur == *prev) {
+ cur++, prev++;
+ }
+ if (cur == end)
+ break; /* rest of row is unchanged */
+ /* Detect a run of changed bytes. */
+ /* We know that *cur != *prev. */
+ diff = cur;
+ do {
+ prev++;
+ cur++;
+ }
+ while (cur < end && *cur != *prev);
+ /* Now [run..diff) are unchanged, and */
+ /* [diff..cur) are changed. */
+ offset = diff - run;
+ {
+ const byte *stop_test = cur - 4;
+ int dissimilar, similar;
+
+ while (diff < cur) {
+ const byte *compr = diff;
+ const byte *next; /* end of run */
+ byte value = 0;
+ while (diff <= stop_test &&
+ ((value = *diff) != diff[1] ||
+ value != diff[2] ||
+ value != diff[3]))
+ diff++;
+
+ /* Find out how long the run is */
+ if (diff > stop_test) /* no run */
+ next = diff = cur;
+ else {
+ next = diff + 4;
+ while (next < cur && *next == value)
+ next++;
+ }
+
+#define MAXOFFSETU 15
+#define MAXCOUNTU 7
+ /* output 'dissimilar' bytes, uncompressed */
+ if ((dissimilar = diff - compr)) {
+ int temp, i;
+
+ if ((temp = --dissimilar) > MAXCOUNTU)
+ temp = MAXCOUNTU;
+ if (offset < MAXOFFSETU)
+ *out++ = (offset << 3) | (byte) temp;
+ else {
+ *out++ = (MAXOFFSETU << 3) | (byte) temp;
+ offset -= MAXOFFSETU;
+ while (offset >= 255) {
+ *out++ = 255;
+ offset -= 255;
+ }
+ *out++ = offset;
+ }
+ if (temp == MAXCOUNTU) {
+ temp = dissimilar - MAXCOUNTU;
+ while (temp >= 255) {
+ *out++ = 255;
+ temp -= 255;
+ }
+ *out++ = (byte) temp;
+ }
+ for (i = 0; i <= dissimilar; i++)
+ *out++ = *compr++;
+ offset = 0;
+ } /* end uncompressed */
+#define MAXOFFSETC 3
+#define MAXCOUNTC 31
+ /* output 'similar' bytes, run-length encoded */
+ if ((similar = next - diff)) {
+ int temp;
+
+ if ((temp = (similar -= 2)) > MAXCOUNTC)
+ temp = MAXCOUNTC;
+ if (offset < MAXOFFSETC)
+ *out++ = 0x80 | (offset << 5) | (byte) temp;
+ else {
+ *out++ = 0x80 | (MAXOFFSETC << 5) | (byte) temp;
+ offset -= MAXOFFSETC;
+ while (offset >= 255) {
+ *out++ = 255;
+ offset -= 255;
+ }
+ *out++ = offset;
+ }
+ if (temp == MAXCOUNTC) {
+ temp = similar - MAXCOUNTC;
+ while (temp >= 255) {
+ *out++ = 255;
+ temp -= 255;
+ }
+ *out++ = (byte) temp;
+ }
+ *out++ = value;
+ offset = 0;
+ } /* end compressed */
+ diff = next;
+ }
+ }
+ }
+ return out - compressed;
+}
+
+/*
+ * Row compression for the H-P PaintJet.
+ * Compresses data from row up to end_row, storing the result
+ * starting at compressed. Returns the number of bytes stored.
+ * The compressed format consists of a byte N followed by a
+ * data byte that is to be repeated N+1 times.
+ * In the worst case, the `compressed' representation is
+ * twice as large as the input.
+ * We complement the bytes at the same time, because
+ * we accumulated the image in complemented form.
+ */
+private int
+gdev_pcl_mode1compress(const byte *row, const byte *end_row, byte *compressed)
+{ register const byte *in = row;
+ register byte *out = compressed;
+ while ( in < end_row )
+ { byte test = *in++;
+ const byte *run = in;
+ while ( in < end_row && *in == test ) in++;
+ /* Note that in - run + 1 is the repetition count. */
+ while ( in - run > 255 )
+ { *out++ = 255;
+ *out++ = test;
+ run += 256;
+ }
+ *out++ = in - run;
+ *out++ = test;
+ }
+ return out - compressed;
+}
+
+/*
+ * Map a CMYK color to a color index. We just use depth / 4 bits per color
+ * to produce the color index.
+ *
+ * Important note: CMYK values are stored in the order K, C, M, Y because of
+ * the way the HP drivers work.
+ *
+ */
+
+#define gx_color_value_to_bits(cv, b) \
+ ((cv) >> (gx_color_value_bits - (b)))
+#define gx_bits_to_color_value(cv, b) \
+ ((cv) << (gx_color_value_bits - (b)))
+
+#define gx_cmyk_value_bits(c, m, y, k, b) \
+ ((gx_color_value_to_bits((k), (b)) << (3 * (b))) | \
+ (gx_color_value_to_bits((c), (b)) << (2 * (b))) | \
+ (gx_color_value_to_bits((m), (b)) << (b)) | \
+ (gx_color_value_to_bits((y), (b))))
+
+#define gx_value_cmyk_bits(v, c, m, y, k, b) \
+ (k) = gx_bits_to_color_value(((v) >> (3 * (b))) & ((1 << (b)) - 1), (b)), \
+ (c) = gx_bits_to_color_value(((v) >> (2 * (b))) & ((1 << (b)) - 1), (b)), \
+ (m) = gx_bits_to_color_value(((v) >> (b)) & ((1 << (b)) - 1), (b)), \
+ (y) = gx_bits_to_color_value((v) & ((1 << (b)) - 1), (b))
+
+private gx_color_index
+gdev_cmyk_map_cmyk_color(gx_device* pdev,
+ gx_color_value cyan, gx_color_value magenta, gx_color_value yellow,
+ gx_color_value black) {
+
+ gx_color_index color;
+
+ switch (pdev->color_info.depth) {
+ case 1:
+ color = (cyan | magenta | yellow | black) > gx_max_color_value / 2 ?
+ (gx_color_index) 1 : (gx_color_index) 0;
+ break;
+
+ default: {
+ int nbits = pdev->color_info.depth;
+
+ if (cyan == magenta && magenta == yellow) {
+
+ /* Convert CMYK to gray -- Red Book 6.2.2 */
+
+ float bpart = ((float) cyan) * (lum_red_weight / 100.) +
+ ((float) magenta) * (lum_green_weight / 100.) +
+ ((float) yellow) * (lum_blue_weight / 100.) +
+ (float) black;
+
+ cyan = magenta = yellow = (gx_color_index) 0;
+ black = (gx_color_index) (bpart > gx_max_color_value ?
+ gx_max_color_value : bpart);
+ }
+
+ color = gx_cmyk_value_bits(cyan, magenta, yellow, black,
+ nbits >> 2);
+ }
+ }
+
+ return color;
+}
+
+/* Mapping of RGB colors to gray values. */
+
+private gx_color_index
+gdev_cmyk_map_rgb_color(gx_device *pdev, gx_color_value r, gx_color_value g, gx_color_value b)
+{
+
+ if (gx_color_value_to_byte(r & g & b) == 0xff) {
+ return (gx_color_index) 0; /* White */
+ } else {
+ gx_color_value c = gx_max_color_value - r;
+ gx_color_value m = gx_max_color_value - g;
+ gx_color_value y = gx_max_color_value - b;
+
+ switch (pdev->color_info.depth) {
+ case 1:
+ return (c | m | y) > gx_max_color_value / 2 ?
+ (gx_color_index) 1 : (gx_color_index) 0;
+ /*NOTREACHED*/
+ break;
+
+ case 8:
+ return ((ulong) c * lum_red_weight * 10
+ + (ulong) m * lum_green_weight * 10
+ + (ulong) y * lum_blue_weight * 10)
+ >> (gx_color_value_bits + 2);
+ /*NOTREACHED*/
+ break;
+ }
+ }
+
+ return (gx_color_index) 0; /* This should never happen. */
+}
+
+/* Mapping of CMYK colors. */
+
+private int
+gdev_cmyk_map_color_rgb(gx_device *pdev, gx_color_index color, gx_color_value prgb[3])
+{
+ switch (pdev->color_info.depth) {
+ case 1:
+ prgb[0] = prgb[1] = prgb[2] = gx_max_color_value * (1 - color);
+ break;
+
+ case 8:
+ if (pdev->color_info.num_components == 1) {
+ gx_color_value value = (gx_color_value) color ^ 0xff;
+
+ prgb[0] = prgb[1] = prgb[2] = (value << 8) + value;
+
+ break;
+ }
+
+ default: {
+ unsigned long bcyan, bmagenta, byellow, black;
+ int nbits = pdev->color_info.depth;
+
+ gx_value_cmyk_bits(color, bcyan, bmagenta, byellow, black,
+ nbits >> 2);
+
+#ifdef USE_ADOBE_CMYK_RGB
+
+ /* R = 1.0 - min(1.0, C + K), etc. */
+
+ bcyan += black, bmagenta += black, byellow += black;
+ prgb[0] = (bcyan > gx_max_color_value ? (gx_color_value) 0 :
+ gx_max_color_value - bcyan);
+ prgb[1] = (bmagenta > gx_max_color_value ? (gx_color_value) 0 :
+ gx_max_color_value - bmagenta);
+ prgb[2] = (byellow > gx_max_color_value ? (gx_color_value) 0 :
+ gx_max_color_value - byellow);
+
+#else
+
+ /* R = (1.0 - C) * (1.0 - K), etc. */
+
+ prgb[0] = (gx_color_value)
+ ((ulong)(gx_max_color_value - bcyan) *
+ (gx_max_color_value - black) / gx_max_color_value);
+ prgb[1] = (gx_color_value)
+ ((ulong)(gx_max_color_value - bmagenta) *
+ (gx_max_color_value - black) / gx_max_color_value);
+ prgb[2] = (gx_color_value)
+ ((ulong)(gx_max_color_value - byellow) *
+ (gx_max_color_value - black) / gx_max_color_value);
+
+#endif
+
+ }
+ }
+
+ return 0;
+}
+
+/*
+ * Map a r-g-b color to a color index.
+ * We complement the colours, since we're using cmy anyway, and
+ * because the buffering routines expect white to be zero.
+ * Includes colour balancing, following HP recommendations, to try
+ * and correct the greenish cast resulting from an equal mix of the
+ * c, m, y, inks by reducing the cyan component to give a truer black.
+ */
+
+/* Simple black generation/under-color removal with BG(k) = UG(k) = k. YA. */
+
+#define bg_and_ucr(c, c_v, m, m_v, y, y_v, k) \
+ do { \
+ register byte cv = c_v, mv = m_v, yv = y_v, kv; \
+ \
+ kv = (cv > mv ? mv : cv); \
+ kv = (yv > k ? k : y); \
+ y = yv - kv; m = mv - kv; c = cv -kv; k = kv; \
+ } while (0)
+
+private gx_color_index
+gdev_pcl_map_rgb_color(gx_device *pdev, gx_color_value r,
+ gx_color_value g, gx_color_value b)
+{
+ if (gx_color_value_to_byte(r & g & b) == 0xff)
+ return (gx_color_index)0; /* white */
+ else {
+ int correction = cprn_device->correction;
+ gx_color_value c = gx_max_color_value - r;
+ gx_color_value m = gx_max_color_value - g;
+ gx_color_value y = gx_max_color_value - b;
+
+ /* Colour correction for better blacks when using the colour ink
+ * cartridge (on the DeskJet 500C only). We reduce the cyan component
+ * by some fraction (eg. 4/5) to correct the slightly greenish cast
+ * resulting from an equal mix of the three inks */
+ if (correction) {
+ ulong maxval, minval, range;
+
+ maxval = c >= m ? (c >= y ? c : y) : (m >= y ? m : y);
+ if (maxval > 0) {
+ minval = c <= m ? (c <= y ? c : y) : (m <= y? m : y);
+ range = maxval - minval;
+
+#define shift (gx_color_value_bits - 12)
+ c = ((c >> shift) * (range + (maxval * correction))) /
+ ((maxval * (correction + 1)) >> shift);
+ }
+ }
+
+ switch (pdev->color_info.depth) {
+ case 1:
+ return ((c | m | y) > gx_max_color_value / 2 ?
+ (gx_color_index)1 : (gx_color_index)0);
+ case 8:
+ if (pdev->color_info.num_components >= 3)
+#define gx_color_value_to_1bit(cv) ((cv) >> (gx_color_value_bits - 1))
+ return (gx_color_value_to_1bit(c) +
+ (gx_color_value_to_1bit(m) << 1) +
+ (gx_color_value_to_1bit(y) << 2));
+ else
+#define red_weight 306
+#define green_weight 601
+#define blue_weight 117
+ return ((((ulong)c * red_weight +
+ (ulong)m * green_weight +
+ (ulong)y * blue_weight)
+ >> (gx_color_value_bits + 2)));
+ case 16:
+#define gx_color_value_to_5bits(cv) ((cv) >> (gx_color_value_bits - 5))
+#define gx_color_value_to_6bits(cv) ((cv) >> (gx_color_value_bits - 6))
+ return (gx_color_value_to_5bits(y) +
+ (gx_color_value_to_6bits(m) << 5) +
+ (gx_color_value_to_5bits(c) << 11));
+ case 24:
+ return (gx_color_value_to_byte(y) +
+ (gx_color_value_to_byte(m) << 8) +
+ ((ulong)gx_color_value_to_byte(c) << 16));
+ case 32:
+ { return ((c == m && c == y) ? ((ulong)gx_color_value_to_byte(c) << 24)
+ : (gx_color_value_to_byte(y) +
+ (gx_color_value_to_byte(m) << 8) +
+ ((ulong)gx_color_value_to_byte(c) << 16)));
+ }
+ }
+ }
+ return (gx_color_index)0; /* This never happens */
+}
+
+/* Map a color index to a r-g-b color. */
+private int
+gdev_pcl_map_color_rgb(gx_device *pdev, gx_color_index color,
+ gx_color_value prgb[3])
+{
+ /* For the moment, we simply ignore any black correction */
+ switch (pdev->color_info.depth) {
+ case 1:
+ prgb[0] = prgb[1] = prgb[2] = -((gx_color_value)color ^ 1);
+ break;
+ case 8:
+ if (pdev->color_info.num_components >= 3)
+ { gx_color_value c = (gx_color_value)color ^ 7;
+ prgb[0] = -(c & 1);
+ prgb[1] = -((c >> 1) & 1);
+ prgb[2] = -(c >> 2);
+ }
+ else
+ { gx_color_value value = (gx_color_value)color ^ 0xff;
+ prgb[0] = prgb[1] = prgb[2] = (value << 8) + value;
+ }
+ break;
+ case 16:
+ { gx_color_value c = (gx_color_value)color ^ 0xffff;
+ ushort value = c >> 11;
+ prgb[0] = ((value << 11) + (value << 6) + (value << 1) +
+ (value >> 4)) >> (16 - gx_color_value_bits);
+ value = (c >> 6) & 0x3f;
+ prgb[1] = ((value << 10) + (value << 4) + (value >> 2))
+ >> (16 - gx_color_value_bits);
+ value = c & 0x1f;
+ prgb[2] = ((value << 11) + (value << 6) + (value << 1) +
+ (value >> 4)) >> (16 - gx_color_value_bits);
+ }
+ break;
+ case 24:
+ { gx_color_value c = (gx_color_value)color ^ 0xffffff;
+ prgb[0] = gx_color_value_from_byte(c >> 16);
+ prgb[1] = gx_color_value_from_byte((c >> 8) & 0xff);
+ prgb[2] = gx_color_value_from_byte(c & 0xff);
+ }
+ break;
+ case 32:
+#define gx_maxcol gx_color_value_from_byte(gx_color_value_to_byte(gx_max_color_value))
+ { gx_color_value w = gx_maxcol - gx_color_value_from_byte(color >> 24);
+ prgb[0] = w - gx_color_value_from_byte((color >> 16) & 0xff);
+ prgb[1] = w - gx_color_value_from_byte((color >> 8) & 0xff);
+ prgb[2] = w - gx_color_value_from_byte(color & 0xff);
+ }
+ break;
+ }
+ return 0;
+}
+
+/*
+ * Convert and expand scanlines:
+ *
+ * For devices with 3 components:
+ *
+ * (a) 16 -> 24 bit (1-stage)
+ * (b) 16 -> 32 bit (2-stage)
+ * or (c) 24 -> 32 bit (1-stage)
+ *
+ * For devices with 4 components:
+ *
+ * (a) 16 -> 32 bit (1-stage)
+ * (b) 8 -> 32 bit (2-stage)
+ * or (c) 24 -> 32 bit (1-stage)
+ *
+ */
+
+private void
+cdj_expand_line(word *line, int linesize, short cmyk, int bpp, int ebpp)
+{
+ int endline = linesize;
+ byte *start = (byte *)line;
+ register byte *in, *out;
+
+ if (cmyk > 0) {
+ if (bpp == 8) {
+ in = start + endline;
+ out = start + (endline *= 2);
+
+ while (in > start) {
+ register byte b0;
+ register byte bs0, bs1, bs2, bs3;
+
+ b0 = *--in;
+
+ bs0 = b0 & 0x03;
+ bs1 = (b0 >> 2) & 0x03;
+ bs2 = (b0 >> 4) & 0x03;
+ bs3 = (b0 >> 6) & 0x03;
+
+ *--out = (bs0 << 2) + bs0 + (bs1 << 6) + (bs1 << 4);
+ *--out = (bs2 << 2) + bs2 + (bs3 << 6) + (bs3 << 4);
+ }
+ }
+
+ if (bpp == 24) {
+ endline = (endline + 2) / 3;
+
+ in = start + endline * 3;
+ out = start + endline * 4;
+
+ while (in > start) {
+ register byte b0, b1, b2;
+
+ b0 = *--in;
+ b1 = *--in;
+ b2 = *--in;
+
+ *--out = (b0 << 2) + ((b0 >> 4) & 0x03);
+ *--out = ((b1 & 0x0f) << 4) + ((b0 >> 6) << 2)
+ + ((b1 >> 2) & 0x03);
+ *--out = ((b2 & 0x03) << 6) + ((b1 >> 4) << 2) + (b2 & 0x03);
+ *--out = (b2 & 0xfc) + ((b2 >> 6) & 0x03);
+ }
+ } else if (ebpp == 32) {
+ endline = (endline + 1) / 2;
+
+ in = start + endline * 2;
+ out = start + (endline *= 4);
+
+ while (in > start) {
+ register byte b0, b1;
+
+ b0 = *--in;
+ b1 = *--in;
+
+ *--out = (b0 << 4) + ((b0 >> 4) & 0x07);
+ *--out = (b0 & 0xf0) + ((b0 >> 4) & 0xf);
+ *--out = (b1 << 4) + ((b1 >> 4) & 0x0f);
+ *--out = (b1 & 0xf0) + ((b1 >> 4) & 0xf);
+ }
+ }
+ } else /* cmyk > 0 */ {
+ if (bpp == 16) /* 16 to 24 (cmy) if required */
+ { register byte b0, b1;
+ endline = ((endline + 1) / 2);
+ in = start + endline * 2;
+ out = start + (endline *= 3);
+
+ while (in > start)
+ { b0 = *--in;
+ b1 = *--in;
+ *--out = (b0 << 3) + ((b0 >> 2) & 0x7);
+ *--out = (b1 << 5) + ((b0 >> 3) & 0x1c) + ((b1 >> 1) & 0x3);
+ *--out = (b1 & 0xf8) + (b1 >> 5);
+ }
+ }
+
+ if (ebpp == 32) /* 24/32 (cmy) to 32 (cmyk) if required */
+ { register byte c, m, y;
+ endline = ((endline + 2) / 3);
+ in = start + endline * 3;
+ out = start + endline * 4;
+
+ while (in > start)
+ {
+ y = *--in;
+ m = *--in;
+ c = *--in;
+
+ if (c == y && c == m) {
+ *--out = 0, *--out = 0, *--out = 0;
+ *--out = c;
+ } else {
+ *--out = y, *--out = m, *--out = c;
+ *--out = 0;
+ }
+ }
+ }
+ }
+}
+
+private int near
+cdj_put_param_int(gs_param_list *plist, gs_param_name pname, int *pvalue,
+ int minval, int maxval, int ecode)
+{ int code, value;
+ switch ( code = param_read_int(plist, pname, &value) )
+ {
+ default:
+ return code;
+ case 1:
+ return ecode;
+ case 0:
+ if ( value < minval || value > maxval )
+ param_signal_error(plist, pname, gs_error_rangecheck);
+ *pvalue = value;
+ return (ecode < 0 ? ecode : 1);
+ }
+}
+
+private int
+cdj_set_bpp(gx_device *pdev, int bpp, int ccomps)
+{ gx_device_color_info *ci = &pdev->color_info;
+
+ if (ccomps && bpp == 0) {
+ if (cprn_device->cmyk) {
+ switch (ccomps) {
+ default:
+ return gs_error_rangecheck;
+ /*NOTREACHED*/
+ break;
+
+ case 1:
+ bpp = 1;
+ break;
+
+ case 3:
+ bpp = 24;
+ break;
+
+ case 4:
+ switch (ci->depth) {
+ case 8:
+ case 16:
+ case 24:
+ case 32:
+ break;
+
+ default:
+ bpp = cprn_device->default_depth;
+ break;
+ }
+ break;
+ }
+ }
+ }
+
+ if (bpp == 0) {
+ bpp = ci->depth; /* Use the current setting. */
+ }
+
+ if (cprn_device->cmyk < 0) {
+
+ /* Reset procedures because we may have been in another mode. */
+
+ dev_proc(pdev, map_cmyk_color) = gdev_cmyk_map_cmyk_color;
+ dev_proc(pdev, map_rgb_color) = NULL;
+ dev_proc(pdev, map_color_rgb) = gdev_cmyk_map_color_rgb;
+
+ if (pdev->is_open) gs_closedevice(pdev);
+ }
+
+ /* Check for valid bpp values */
+
+ switch ( bpp )
+ {
+ case 16:
+ case 32:
+ if (cprn_device->cmyk && ccomps && ccomps != 4) goto bppe;
+ break;
+
+ case 24:
+ if (!cprn_device->cmyk || ccomps == 0 || ccomps == 4) {
+ break;
+ } else if (ccomps == 1) {
+ goto bppe;
+ } else {
+
+ /* 3 components 24 bpp printing for CMYK device. */
+
+ cprn_device->cmyk = -1;
+ }
+ break;
+
+ case 8:
+ if (cprn_device->cmyk) {
+ if (ccomps) {
+ if (ccomps == 3) {
+ cprn_device->cmyk = -1;
+ bpp = 3;
+ } else if (ccomps != 1 && ccomps != 4) {
+ goto bppe;
+ }
+ }
+ if (ccomps != 1) break;
+ } else {
+ break;
+ }
+
+ case 1:
+ if (ccomps != 1) goto bppe;
+
+ if (cprn_device->cmyk && bpp != pdev->color_info.depth) {
+ dev_proc(pdev, map_cmyk_color) = NULL;
+ dev_proc(pdev, map_rgb_color) = gdev_cmyk_map_rgb_color;
+
+ if (pdev->is_open) {
+ gs_closedevice(pdev);
+ }
+ }
+ break;
+
+ case 3:
+ if (!cprn_device->cmyk) {
+ break;
+ }
+
+ default:
+bppe: return gs_error_rangecheck;
+ }
+
+
+ if (cprn_device->cmyk == -1) {
+ dev_proc(pdev, map_cmyk_color) = NULL;
+ dev_proc(pdev, map_rgb_color) = gdev_pcl_map_rgb_color;
+ dev_proc(pdev, map_color_rgb) = gdev_pcl_map_color_rgb;
+
+ if (pdev->is_open) {
+ gs_closedevice(pdev);
+ }
+ }
+
+ switch (ccomps) {
+ case 0:
+ break;
+
+ case 1:
+ if (bpp != 1 && bpp != 8) goto cce;
+ break;
+
+ case 4:
+ if (cprn_device->cmyk) {
+ if (bpp >= 8) break;
+ }
+
+ case 3:
+ if (bpp == 1 || bpp == 3 || bpp == 8 || bpp == 16
+ || bpp == 24 || bpp == 32) {
+ break;
+ }
+
+cce: default: return gs_error_rangecheck;
+ }
+
+ if (cprn_device->cmyk) {
+ if (cprn_device->cmyk > 0) {
+ ci->num_components = ccomps ? ccomps : (bpp < 8 ? 1 : 4);
+ } else {
+ ci->num_components = ccomps ? ccomps : (bpp < 8 ? 1 : 3);
+ }
+ if (bpp != 1 && ci->num_components == 1) { /* We do dithered grays. */
+ bpp = bpp < 8 ? 8 : bpp;
+ }
+
+ ci->max_color = (1 << (bpp >> 2)) - 1;
+ ci->max_gray = (bpp >= 8 ? 255 : 1);
+
+ if (ci->num_components == 1) {
+ ci->dither_grays = (bpp >= 8 ? 5 : 2);
+ ci->dither_colors = (bpp >= 8 ? 5 : bpp > 1 ? 2 : 0);
+ } else {
+ ci->dither_grays = (bpp > 8 ? 5 : 2);
+ ci->dither_colors = (bpp > 8 ? 5 : bpp > 1 ? 2 : 0);
+ }
+ } else {
+ ci->num_components = (bpp == 1 || bpp == 8 ? 1 : 3);
+ ci->max_color = (bpp >= 8 ? 255 : bpp > 1 ? 1 : 0);
+ ci->max_gray = (bpp >= 8 ? 255 : 1);
+ ci->dither_grays = (bpp >= 8 ? 5 : 2);
+ ci->dither_colors = (bpp >= 8 ? 5 : bpp > 1 ? 2 : 0);
+ }
+
+ ci->depth = ((bpp > 1) && (bpp < 8) ? 8 : bpp);
+
+ return 0;
+}
+
+/* new_bpp == save_bpp or new_bpp == 0 means don't change bpp.
+ ccomps == 0 means don't change number of color comps.
+ If new_bpp != 0, it must be the value of the BitsPerPixel element of
+ the plist; real_bpp may differ from new_bpp.
+*/
+private int
+cdj_put_param_bpp(gx_device *pdev, gs_param_list *plist, int new_bpp,
+ int real_bpp, int ccomps)
+{
+ if (new_bpp == 0 && ccomps == 0)
+ return gdev_prn_put_params(pdev, plist);
+ else
+ {
+ gx_device_color_info save_info;
+ int save_bpp;
+ int code;
+
+ save_info = pdev->color_info;
+ save_bpp = save_info.depth;
+#define save_ccomps save_info.num_components
+ if ( save_bpp == 8 && save_ccomps == 3 && !cprn_device->cmyk)
+ save_bpp = 3;
+ code = cdj_set_bpp(pdev, real_bpp, ccomps);
+ if ( code < 0 ) {
+ param_signal_error(plist, "BitsPerPixel", code);
+ param_signal_error(plist, "ProcessColorModel", code);
+ return code;
+ }
+ pdev->color_info.depth = new_bpp; /* cdj_set_bpp maps 3/6 to 8 */
+ code = gdev_prn_put_params(pdev, plist);
+ if ( code < 0 )
+ { cdj_set_bpp(pdev, save_bpp, save_ccomps);
+ return code;
+ }
+ cdj_set_bpp(pdev, real_bpp, ccomps); /* reset depth if needed */
+ if ((cdj->color_info.depth != save_bpp ||
+ (ccomps != 0 && ccomps != save_ccomps))
+ && pdev->is_open )
+ return gs_closedevice(pdev);
+ return 0;
+#undef save_ccomps
+ }
+}
+
+/* This returns either the number of pixels in a scan line, or the number
+ * of bytes required to store the line, both clipped to the page margins */
+private uint
+gdev_prn_rasterwidth(const gx_device_printer *pdev, int pixelcount)
+{
+ ulong raster_width =
+ pdev->width - pdev->x_pixels_per_inch * (dev_l_margin(pdev) + dev_r_margin(pdev));
+ return (pixelcount ?
+ (uint)raster_width :
+ (uint)((raster_width * pdev->color_info.depth + 7) >> 3));
+}
+
+/* Functions for manipulation params strings */
+
+private const byte*
+paramValueToString(const stringParamDescription* params, int value)
+{
+
+ for (; params->p_name; ++params) {
+ if (params->p_value == value) {
+ return (const byte *)params->p_name;
+ }
+ }
+
+ return (const byte*) 0;
+}
+
+private int
+paramStringValue(const stringParamDescription* params,
+ const byte* name, int namelen, int* value)
+{
+
+ for (; params->p_name; ++params) {
+ if (strncmp(params->p_name, (char *)name, namelen) == 0 &&
+ params->p_name[namelen] == 0) {
+ *value = params->p_value;
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+private int
+put_param_string(gs_param_list* plist,
+ const byte* pname, gs_param_string* pstring,
+ const stringParamDescription* params, int *pvalue, int code)
+{
+
+ int ncode;
+
+ if ((ncode = param_read_string(plist, (char *)pname, pstring)) < 0) {
+ param_signal_error(plist, (char *)pname, code = ncode);
+ } else if (ncode == 1) {
+ pstring->data = 0, pstring->size = 0;
+ } else {
+ int value = 0;
+
+ if (paramStringValue(params, pstring->data, pstring->size,
+ &value) == 0) {
+ param_signal_error(plist, (char *)pname, code = gs_error_rangecheck);
+ } else {
+ *pvalue = value;
+ }
+ }
+
+ return code;
+}
+
+private int
+get_param_string(gs_param_list* plist,
+ const byte* pname, gs_param_string* pstring,
+ const stringParamDescription* params, int pvalue, bool persist, int code)
+{
+
+ int ncode;
+
+ pstring->data = paramValueToString(params, pvalue);
+
+ if (pstring->data == (byte*) 0) {
+ param_signal_error(plist, (char *)pname, ncode = gs_error_unknownerror);
+ } else {
+ pstring->size = strlen((char *)pstring->data);
+ pstring->persistent = persist;
+ }
+
+ if ((ncode = param_write_string(plist, (char *)pname, pstring)) < 0) {
+ code = ncode;
+ }
+
+ return code;
+}
+
+/*
+ * This taken from gsdparam.c. I hope it will be useable directly some day.
+ *
+ */
+
+private int
+cdj_param_check_bytes(gs_param_list *plist, gs_param_name pname, const byte *str,
+ uint size, bool defined)
+{ int code;
+ gs_param_string new_value;
+ switch ( code = param_read_string(plist, pname, &new_value) )
+ {
+ case 0:
+ if ( defined && new_value.size == size &&
+ !memcmp((const char *)str, (const char *)new_value.data,
+ size)
+ )
+ break;
+ code = gs_note_error(gs_error_rangecheck);
+ goto e;
+ default:
+ if ( param_read_null(plist, pname) == 0 )
+ return 1;
+e: param_signal_error(plist, pname, code);
+ case 1:
+ ;
+ }
+ return code;
+}
+
+/* This is original code. */
+
+private int
+cdj_param_check_float(gs_param_list *plist, gs_param_name pname, floatp fval,
+ bool defined)
+{ int code;
+ float new_value;
+ switch ( code = param_read_float(plist, pname, &new_value) )
+ {
+ case 0:
+ if ( defined && new_value == fval)
+ break;
+ code = gs_note_error(gs_error_rangecheck);
+ goto e;
+ default:
+ if ( param_read_null(plist, pname) == 0 )
+ return 1;
+e: param_signal_error(plist, pname, code);
+ case 1:
+ ;
+ }
+ return code;
+}
+
+/* The following dithering algorithm has been kindly given to me (YA) by
+ * Klaus-Gunther Hess, I just adapted it for use with the code here. */
+
+/*
+
+(From KGH:)
+
+Just about the features of the code:
+
+ - Stored Color-Values are BYTES in the order C-M-Y-K.
+ (Indices need to change with gdevcdj.c)
+
+ - There are individual THRESHOLDs and SPOTSIZEs for
+ the color-components. The following relation should
+ be maintained:
+ SPOTSIZE = 2 * THRESHOLD + 1
+ (The internal calculation is dedicated for limiting
+ ink-density at the 720x720DpI-Resolution of the
+ Epson-Printers, without loss of dynamic color-range)
+
+ - In addition to that there are EMIN & EMAX-Values
+ for the components. The Values are computed from
+ the dithering-algorithm and can be replaced by
+ constants, if neither the implementation nor
+ THRESHOLD and SPOTSIZE can change.
+
+ - The algorithm is tuned for speed. (K-only, if gray-
+ levels are detected, with EMIN/EMAX-clipping of
+ stored CMY-Errors. [Notice: cerr, merr, yerr are
+ *not* reset to zero! Clearing them would cause
+ regular patterns & "Halos" to appear!])
+
+*/
+
+/*
+ * Macros, that represent the undisturbed dithering-algorithm
+ *
+ * FSerror: compute the desired Value
+ * FSdecide: decision based on the value computed by FSerror
+ * FSdiffuse: distribute remaining error among pixels
+ */
+
+#define FSerror(Val,Erow,Ecol) (Val + Erow + ((7 * Ecol)>>4))
+
+#define FSdecide(Error,Threshold,Spotsize,Pixel,Bit) \
+ if(Error > Threshold) {\
+ Pixel |= Bit;\
+ Error -= Spotsize;\
+ }
+
+#define FSdiffuse(Error,Erow,Ecol,Eprev)\
+ Eprev += (3 * Error + 8)>>4;\
+ Erow = (5 * Error + Ecol + 8)>>4;\
+ Ecol = Error;
+
+/*
+ * some aliases for values from the device-structure
+ */
+#define DIRECTION direction[0]
+#define CMYK_THRESHOLD(I) threshold[I]
+#define SPOTSIZE(I) spotsize[I]
+#define EMIN(I) emin[I]
+#define EMAX(I) emax[I]
+#define NPIXEL (plane_size * 8)
+
+#define IDX_C 1
+#define IDX_M 2
+#define IDX_Y 3
+#define IDX_K 0
+
+#define ODX_C 2
+#define ODX_M 1
+#define ODX_Y 0
+#define ODX_K 3
+
+private int
+bjc_fscmyk(byte** inplanes, byte* outplanes[4][4], int** errplanes,
+ int plane_size, int scan) {
+
+ byte* err = (byte*) errplanes[0];
+
+/* =========================================================== */
+ if(scan < 0) { /* scan < 0 -> initialize private buffer */
+/* =========================================================== */
+
+ int p,i,v;
+ int *direction,*threshold,*spotsize,*emin,*emax;
+ int *errv,*errc;
+/*
+ * allocate the error-buffer
+ */
+ /*KGHorig
+ i = 4 * (5 + 1 + 1 + sd->stc.prt_pixels + 1) * sizeof(errv[0]);
+ if((sd->stc.err_size < i) || (NULL == sd->stc.err)) {
+ if(NULL != sd->stc.err)
+ gs_free(sd->stc.err,sd->stc.err_size,1,"stcm/err");
+ sd->stc.err_size = i;
+ sd->stc.err = gs_malloc(sd->stc.err_size,1,"stcm/err");
+ if(sd->stc.err == NULL) return_error(gs_error_VMerror);
+ }
+ */
+
+ direction = (int *) err;
+ threshold = direction + 4;
+ spotsize = threshold + 4;
+ emin = spotsize + 4;
+ emax = emin + 4;
+ errc = emax + 4;
+ errv = errc + 2*4;
+/*
+ * compute initial values
+ */
+ DIRECTION = -1;
+ for(i = 0; i < 4; ++i) {
+ int j;
+ float maxv = 1.0;
+ /*KGHorig
+ if((sd->stc.xfer[i].size < 1) || (sd->stc.xfer[i].data == NULL)) {
+ maxv = 1.0;
+ } else {
+ maxv = 1.0/255.0;
+ for(j = 0; j < sd->stc.xfer[i].size; ++j)
+ if(maxv < sd->stc.xfer[i].data[j])
+ maxv = sd->stc.xfer[i].data[j];
+ }
+ */
+ CMYK_THRESHOLD(i) = 127.0 / maxv + 0.5;
+ SPOTSIZE(i) = ((int) CMYK_THRESHOLD(i)<<1)+1;
+ j = CMYK_THRESHOLD(i); /* Maximum Error-Value */
+ errc[3] = 0;
+ FSdiffuse(CMYK_THRESHOLD(i),errv[0],errc[0],errv[-4]);
+ FSdiffuse(CMYK_THRESHOLD(i),errv[0],errc[0],errv[-4]);
+ EMAX(i) = errv[0];
+ errc[0] = 0;
+ FSdiffuse((-CMYK_THRESHOLD(i)),errv[0],errc[0],errv[-4]);
+ FSdiffuse((-CMYK_THRESHOLD(i)),errv[0],errc[0],errv[-4]);
+ EMIN(i) = errv[0];
+ }
+
+#ifdef CDJ_DEBUG_FS
+ for(i = 0; i < 4; ++i) fprintf(stderr,
+ "CMYK_THRESHOLD(%d)=%5d, spotsize(%d)=%5d, emin(%d)=%5d, emax(%d)=%5d\n",
+ i,CMYK_THRESHOLD(i),i,SPOTSIZE(i),i,EMIN(i),i,EMAX(i));
+#endif
+
+ for(i = 0; i < 4; ++i) errc[i] = 0;
+
+ for(p = 0; p < NPIXEL; ++p) {
+ for(i = 0; i < 4; ++i) {
+ /*KHGOrig
+ if(sd->stc.flags & STCDFLAG0) v = 0;
+ */
+ if (0) v = 0; /* Must provide a default for that. */
+ else v = (rand() % SPOTSIZE(i)) - CMYK_THRESHOLD(i);
+ FSdiffuse(v,errv[i],errc[i],errv[i-4]);
+ }
+ errv += i;
+ }
+
+/* =========================================================== */
+ } else { /* scan >= 0 -> scanline-processing */
+/* =========================================================== */
+
+ int w,p,dir,thedir;
+ byte *out[4],pixel[4],bit;
+ /*KGHorig
+ int *width = outplanes[scan];
+ */
+ int *direction = (int *) err;
+ int *threshold = direction + 4;
+ int *spotsize = threshold + 4;
+ int *emin = spotsize + 4;
+ int *emax = emin + 4;
+ int *errc = emax + 4;
+ int *errv = errc + 2*4;
+ int kerr,cerr,merr,yerr;
+
+ byte* in;
+
+ /*KGHorig
+ if(sd->stc.flags & STCDFLAG1) {
+ */
+ if (0) { /* Eventually will provide a flag for this. */
+ cerr = merr = yerr = kerr = 0;
+ } else {
+ cerr = errc[0];
+ merr = errc[1];
+ yerr = errc[2];
+ kerr = errc[3];
+ }
+
+ out[0] = outplanes[scan + 2][ODX_C];
+ out[1] = outplanes[scan + 2][ODX_M];
+ out[2] = outplanes[scan + 2][ODX_Y];
+ out[3] = outplanes[scan + 2][ODX_K];
+ pixel[0] = pixel[1] = pixel[2] = pixel[3] = 0;
+
+ if(DIRECTION < 0) { /* scan == 0, run backward */
+ w = NPIXEL;
+ in = inplanes[2] + 4 * (NPIXEL - 1);
+ errv += (w-1)<<2;
+ dir = -4;
+ /*KGHorig
+ if(w > 8) for(p = 0; p < 4; ++p) out[p] += (w-1)>>3;
+ */
+ thedir = -1;
+ for (p = 0; p < 4; ++p) {
+ out[p] += plane_size - 1;
+ }
+ } else { /* run forward */
+ w = 1;
+ in = inplanes[3] - 4 * NPIXEL;
+ dir = 4;
+ thedir = 1;
+ for (p = 0; p < 4; ++p) {
+ out[p] -= plane_size;
+ }
+ } /* run backward/forward */
+
+ /*KGHorig
+ if(0 == (sd->stc.flags & STCDFLAG1)) DIRECTION = -DIRECTION;
+ */
+ if (1) DIRECTION = -DIRECTION; /* Scan in other direction. */
+
+ bit = 0x80>>((w-1) & 7);
+ w = (w+7)>>3;
+
+ for(p = NPIXEL; p; --p) { /* loop over pixels */
+
+ int cmy = in[IDX_C] | in[IDX_M] | in[IDX_Y];
+ int kv = FSerror(in[IDX_K],errv[3],kerr);
+ int cv;
+
+ FSdecide(kv,CMYK_THRESHOLD(3),SPOTSIZE(3),pixel[3],bit);
+
+ if(cmy) {
+
+ if(pixel[3] & bit) { /* black known to fire */
+
+ FSdiffuse(kv,errv[3],kerr,errv[3-dir]);
+
+ cv = FSerror(in[IDX_C],errv[0],cerr);
+ cv -= SPOTSIZE(0);
+ if ((cv+CMYK_THRESHOLD(0)) < 0) cv = -CMYK_THRESHOLD(0);
+ FSdiffuse(cv,errv[0],cerr,errv[0-dir]);
+
+ cv = FSerror(in[IDX_M],errv[1],merr);
+ cv -= SPOTSIZE(1);
+ if ((cv+CMYK_THRESHOLD(1)) < 0) cv = -CMYK_THRESHOLD(1);
+
+ FSdiffuse(cv,errv[1],merr,errv[1-dir]);
+
+ cv = FSerror(in[IDX_Y],errv[2],yerr);
+ cv -= SPOTSIZE(2);
+ if ((cv+CMYK_THRESHOLD(2)) < 0) cv = -CMYK_THRESHOLD(2);
+ FSdiffuse(cv,errv[2],yerr,errv[2-dir]);
+
+ } else {
+
+ cv = FSerror(in[IDX_C],errv[0],cerr);
+ FSdecide(cv,CMYK_THRESHOLD(0),SPOTSIZE(0),pixel[0],bit);
+ FSdiffuse(cv,errv[0],cerr,errv[0-dir]);
+
+ cv = FSerror(in[IDX_M],errv[1],merr);
+ FSdecide(cv,CMYK_THRESHOLD(1),SPOTSIZE(1),pixel[1],bit);
+ FSdiffuse(cv,errv[1],merr,errv[1-dir]);
+
+ cv = FSerror(in[IDX_Y],errv[2],yerr);
+ FSdecide(cv,CMYK_THRESHOLD(2),SPOTSIZE(2),pixel[2],bit);
+ FSdiffuse(cv,errv[2],yerr,errv[2-dir]);
+
+ if(pixel[0] & pixel[1] & pixel[2] & bit) {
+ pixel[0] &= ~bit;
+ pixel[1] &= ~bit;
+ pixel[2] &= ~bit;
+ pixel[3] |= bit;
+ kv -= SPOTSIZE(3);
+ if ((kv+CMYK_THRESHOLD(3)) < 0) kv = -CMYK_THRESHOLD(0);
+ FSdiffuse(kv,errv[3],kerr,errv[3-dir]);
+ }
+ }
+
+ } else {
+
+ FSdiffuse(kv,errv[3],kerr,errv[3-dir]);
+
+ if( errv[0] > EMAX(0)) errv[0] = EMAX(0);
+ else if(errv[0] < EMIN(0)) errv[0] = EMIN(0);
+
+ if( errv[1] > EMAX(1)) errv[1] = EMAX(1);
+ else if(errv[1] < EMIN(1)) errv[1] = EMIN(1);
+
+ if( errv[2] > EMAX(2)) errv[2] = EMAX(2);
+ else if(errv[2] < EMIN(2)) errv[2] = EMIN(2);
+
+ }
+
+/*
+ * Adjust indices
+ */
+ bit = dir > 0 ? (bit>>1) : (bit<<1);
+ if(bit == 0) {
+ /*KGHorig
+ if(((*out[0] = pixel[0]) != 0) && (width[0] < w)) width[0] = w;
+ if(((*out[1] = pixel[1]) != 0) && (width[1] < w)) width[1] = w;
+ if(((*out[2] = pixel[2]) != 0) && (width[2] < w)) width[2] = w;
+ if(((*out[3] = pixel[3]) != 0) && (width[3] < w)) width[3] = w;
+ */
+ *out[0] = pixel[0];
+ *out[1] = pixel[1];
+ *out[2] = pixel[2];
+ *out[3] = pixel[3];
+ out[0] += thedir; out[1] += thedir;
+ out[2] += thedir; out[3] += thedir;
+ pixel[0] = pixel[1] = pixel[2] = pixel[3] = 0;
+
+ if(dir > 0) bit = 0x80;
+ else bit = 0x01;
+ w += dir>>2;
+ }
+
+ in += dir;
+ errv += dir;
+ } /* loop over pixels */
+
+ /*KGHorig
+ if(0 == (sd->stc.flags & STCDFLAG1)) {
+ */
+ if (1) {
+ cerr = errc[0] = cerr;
+ merr = errc[1] = merr;
+ yerr = errc[2] = yerr;
+ kerr = errc[3] = kerr;
+ }
+
+/* =========================================================== */
+ } /* initialization or scanline-Processing */
+/* =========================================================== */
+
+ return 0;
+}
+
View Lorry Controller Status