dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/plug-ins/print/print-escp2.c

4365 lines
119 KiB
C
Raw Blame History

/*
* "$Id$"
*
* Print plug-in EPSON ESC/P2 driver for the GIMP.
*
* Copyright 1997-2000 Michael Sweet (mike@easysw.com) and
* Robert Krawitz (rlk@alum.mit.edu)
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*
* This file must include only standard C header files. The core code must
* compile on generic platforms that don't support glib, gimp, gtk, etc.
*/
#ifndef WEAVETEST
#include "print.h"
#endif
#ifndef __GNUC__
# define inline
#endif /* !__GNUC__ */
/*#include <endian.h>*/
typedef enum {
COLOR_MONOCHROME,
COLOR_CMYK,
COLOR_CCMMYK
} colormode_t;
/*
* Mapping between color and linear index. The colors are
* black, magenta, cyan, yellow, light magenta, light cyan
*/
static const int color_indices[16] = { 0, 1, 2, -1,
3, -1, -1, -1,
-1, 4, 5, -1,
-1, -1, -1, -1 };
static const int colors[6] = { 0, 1, 2, 4, 1, 2 };
static const int densities[6] = { 0, 0, 0, 0, 1, 1 };
#ifndef WEAVETEST
static void
escp2_write_microweave(FILE *, const unsigned char *,
const unsigned char *, const unsigned char *,
const unsigned char *, const unsigned char *,
const unsigned char *, int, int, int, int, int,
int, int);
static void *initialize_weave(int jets, int separation, int oversample,
int horizontal, int vertical,
colormode_t colormode, int width, int linewidth,
int lineheight, int vertical_row_separation,
int first_line, int phys_lines, int strategy);
static void escp2_flush_all(void *, int model, int width, int hoffset,
int ydpi, int xdpi, int physical_xdpi, FILE *prn);
static void
escp2_write_weave(void *, FILE *, int, int, int, int, int, int, int,
const unsigned char *c, const unsigned char *m,
const unsigned char *y, const unsigned char *k,
const unsigned char *C, const unsigned char *M);
static void escp2_init_microweave(int);
static void escp2_free_microweave(void);
static void destroy_weave(void *);
/*
* We really need to get away from this silly static nonsense...
*/
#define PHYSICAL_BPI 720
#define MAX_OVERSAMPLED 4
#define MAX_BPP 2
#define BITS_PER_BYTE 8
#define COMPBUFWIDTH (PHYSICAL_BPI * MAX_OVERSAMPLED * MAX_BPP * \
MAX_CARRIAGE_WIDTH / BITS_PER_BYTE)
/*
* Printer capabilities.
*
* Various classes of printer capabilities are represented by bitmasks.
*/
typedef unsigned long long model_cap_t;
typedef unsigned long long model_featureset_t;
/*
* For each printer, we can select from a variety of dot sizes.
* For single dot size printers, the available sizes are usually 0,
* which is the "default", and some subset of 1-4. For simple variable
* dot size printers (with only one kind of variable dot size), the
* variable dot size is specified as 0x10. For newer printers, there
* is a choice of variable dot sizes available, 0x10, 0x11, and 0x12 in
* order of increasing size.
*
* Normally, we want to specify the smallest dot size that lets us achieve
* a density of less than .8 or thereabouts (above that we start to get
* some dither artifacts). This needs to be tested for each printer and
* resolution.
*
* An entry of -1 in a slot means that this resolution is not available.
*/
typedef struct escp2_dot_sizes
{
int dot_180;
int dot_360_microweave;
int dot_360;
int dot_720_microweave;
int dot_720;
int dot_1440_microweave;
int dot_1440;
} escp2_dot_size_t;
/*
* Specify the base density for each available resolution.
* This obviously depends upon the dot size. Experience suggests that
* variable dot size mode (0x10) on the 870 requires the density
* derived from the printer base and the resolution to be multiplied
* by 3.3. Using dot size 0x11 requires the density to be multiplied
* by 2.2.
*/
typedef struct escp2_densities
{
double d_180_180;
double d_360_360_micro;
double d_360_360;
double d_720_720_micro;
double d_720_720;
double d_1440_720_micro;
double d_1440_720;
double d_1440_1440;
double d_1440_2880;
} escp2_densities_t;
/*
* Definition of the multi-level inks available to a given printer.
* Each printer may use a different kind of ink droplet for variable
* and single drop size for each supported horizontal resolution and
* type of ink (4 or 6 color).
*
* Recall that 6 color ink is treated as simply another kind of
* multi-level ink, but the driver offers the user a choice of 4 and
* 6 color ink, so we need to define appropriate inksets for both
* kinds of ink.
*
* Stuff like the MIS 4 and 6 "color" monochrome inks doesn't fit into
* this model very nicely, so we'll either have to special case it
* or find some way of handling it in here.
*/
typedef struct escp2_variable_ink
{
simple_dither_range_t *range;
int count;
double density;
} escp2_variable_ink_t;
typedef struct escp2_variable_inkset
{
escp2_variable_ink_t *c;
escp2_variable_ink_t *m;
escp2_variable_ink_t *y;
escp2_variable_ink_t *k;
} escp2_variable_inkset_t;
typedef struct escp2_variable_inklist
{
escp2_variable_inkset_t *s_180_4;
escp2_variable_inkset_t *s_360_4;
escp2_variable_inkset_t *s_720_4;
escp2_variable_inkset_t *s_1440_4;
escp2_variable_inkset_t *s_180_6;
escp2_variable_inkset_t *s_360_6;
escp2_variable_inkset_t *s_720_6;
escp2_variable_inkset_t *s_1440_6;
escp2_variable_inkset_t *v_180_4;
escp2_variable_inkset_t *v_360_4;
escp2_variable_inkset_t *v_720_4;
escp2_variable_inkset_t *v_1440_4;
escp2_variable_inkset_t *v_180_6;
escp2_variable_inkset_t *v_360_6;
escp2_variable_inkset_t *v_720_6;
escp2_variable_inkset_t *v_1440_6;
} escp2_variable_inklist_t;
static simple_dither_range_t photo_dither_ranges[] =
{
{ 0.33, 0x1, 0, 1 },
{ 1.0, 0x1, 1, 1 }
};
static escp2_variable_ink_t photo_ink =
{
photo_dither_ranges,
sizeof(photo_dither_ranges) / sizeof(simple_dither_range_t),
.75
};
static simple_dither_range_t photo_6pl_dither_ranges[] =
{
{ 0.15, 0x1, 0, 1 },
{ 0.227, 0x2, 0, 2 },
/* { 0.333, 0x3, 0, 3 }, */
{ 0.45, 0x1, 1, 1 },
{ 0.68, 0x2, 1, 2 },
{ 1.0, 0x3, 1, 3 }
};
static escp2_variable_ink_t photo_6pl_ink =
{
photo_6pl_dither_ranges,
sizeof(photo_6pl_dither_ranges) / sizeof(simple_dither_range_t),
1.0
};
static simple_dither_range_t photo_pigment_dither_ranges[] =
{ /* MRS: Not calibrated! */
{ 0.15, 0x1, 0, 1 },
{ 0.227, 0x2, 0, 2 },
{ 0.5, 0x1, 1, 1 },
{ 1.0, 0x2, 1, 2 }
};
static escp2_variable_ink_t photo_pigment_ink =
{
photo_pigment_dither_ranges,
sizeof(photo_pigment_dither_ranges) / sizeof(simple_dither_range_t),
1.0
};
static simple_dither_range_t photo_4pl_dither_ranges[] =
{
{ 0.15, 0x1, 0, 1 },
{ 0.227, 0x2, 0, 2 },
/* { 0.333, 0x3, 0, 3 }, */
{ 0.45, 0x1, 1, 1 },
{ 0.68, 0x2, 1, 2 },
{ 1.0, 0x3, 1, 3 }
};
static escp2_variable_ink_t photo_4pl_ink =
{
photo_4pl_dither_ranges,
sizeof(photo_4pl_dither_ranges) / sizeof(simple_dither_range_t),
1.0
};
static simple_dither_range_t standard_6pl_dither_ranges[] =
{
{ 0.45, 0x1, 1, 1 },
{ 0.68, 0x2, 1, 2 },
{ 1.0, 0x3, 1, 3 }
};
static escp2_variable_ink_t standard_6pl_ink =
{
standard_6pl_dither_ranges,
sizeof(standard_6pl_dither_ranges) / sizeof(simple_dither_range_t),
1.0
};
static simple_dither_range_t standard_pigment_dither_ranges[] =
{ /* MRS: Not calibrated! */
{ 0.55, 0x1, 1, 1 },
{ 1.0, 0x2, 1, 2 }
};
static escp2_variable_ink_t standard_pigment_ink =
{
standard_pigment_dither_ranges,
sizeof(standard_pigment_dither_ranges) / sizeof(simple_dither_range_t),
1.0
};
static simple_dither_range_t standard_4pl_dither_ranges[] =
{
{ 0.45, 0x1, 1, 1 },
{ 0.68, 0x2, 1, 2 },
{ 1.0, 0x3, 1, 3 }
};
static escp2_variable_ink_t standard_4pl_ink =
{
standard_4pl_dither_ranges,
sizeof(standard_4pl_dither_ranges) / sizeof(simple_dither_range_t),
1.0
};
static simple_dither_range_t standard_3pl_dither_ranges[] =
{
{ 0.225, 0x1, 1, 1 },
{ 0.68, 0x2, 1, 2 },
{ 1.0, 0x3, 1, 3 }
};
static escp2_variable_ink_t standard_3pl_ink =
{
standard_3pl_dither_ranges,
sizeof(standard_3pl_dither_ranges) / sizeof(simple_dither_range_t),
1.0
};
static simple_dither_range_t photo_multishot_dither_ranges[] =
{
{ 0.1097, 0x1, 0, 1 },
{ 0.227, 0x2, 0, 2 },
/* { 0.333, 0x3, 0, 3 }, */
{ 0.28, 0x1, 1, 1 },
{ 0.58, 0x2, 1, 2 },
{ 0.85, 0x3, 1, 3 },
{ 1.0, 0x3, 1, 3 }
};
static escp2_variable_ink_t photo_multishot_ink =
{
photo_multishot_dither_ranges,
sizeof(photo_multishot_dither_ranges) / sizeof(simple_dither_range_t),
1.0
};
static simple_dither_range_t standard_multishot_dither_ranges[] =
{
{ 0.28, 0x1, 1, 1 },
{ 0.58, 0x2, 1, 2 },
{ 0.85, 0x3, 1, 3 },
{ 1.0, 0x3, 1, 3 }
};
static escp2_variable_ink_t standard_multishot_ink =
{
standard_multishot_dither_ranges,
sizeof(standard_multishot_dither_ranges) / sizeof(simple_dither_range_t),
1.0
};
static escp2_variable_inkset_t standard_inks =
{
NULL,
NULL,
NULL,
NULL
};
static escp2_variable_inkset_t photo_inks =
{
&photo_ink,
&photo_ink,
NULL,
NULL
};
static escp2_variable_inkset_t escp2_6pl_standard_inks =
{
&standard_6pl_ink,
&standard_6pl_ink,
&standard_6pl_ink,
&standard_6pl_ink
};
static escp2_variable_inkset_t escp2_6pl_photo_inks =
{
&photo_6pl_ink,
&photo_6pl_ink,
&standard_6pl_ink,
&standard_6pl_ink
};
static escp2_variable_inkset_t escp2_pigment_standard_inks =
{
&standard_pigment_ink,
&standard_pigment_ink,
&standard_pigment_ink,
&standard_pigment_ink
};
static escp2_variable_inkset_t escp2_pigment_photo_inks =
{
&photo_pigment_ink,
&photo_pigment_ink,
&standard_pigment_ink,
&standard_pigment_ink
};
static escp2_variable_inkset_t escp2_4pl_standard_inks =
{
&standard_4pl_ink,
&standard_4pl_ink,
&standard_4pl_ink,
&standard_4pl_ink
};
static escp2_variable_inkset_t escp2_4pl_photo_inks =
{
&photo_4pl_ink,
&photo_4pl_ink,
&standard_4pl_ink,
&standard_4pl_ink
};
static escp2_variable_inkset_t escp2_3pl_standard_inks =
{
&standard_3pl_ink,
&standard_3pl_ink,
&standard_3pl_ink,
&standard_3pl_ink
};
static escp2_variable_inkset_t escp2_multishot_standard_inks =
{
&standard_multishot_ink,
&standard_multishot_ink,
&standard_multishot_ink,
&standard_multishot_ink
};
static escp2_variable_inkset_t escp2_multishot_photo_inks =
{
&photo_multishot_ink,
&photo_multishot_ink,
&standard_multishot_ink,
&standard_multishot_ink
};
static escp2_variable_inklist_t simple_4color_inks =
{
&standard_inks,
&standard_inks,
&standard_inks,
&standard_inks,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL
};
static escp2_variable_inklist_t simple_6color_inks =
{
&standard_inks,
&standard_inks,
&standard_inks,
&standard_inks,
&photo_inks,
&photo_inks,
&photo_inks,
&photo_inks,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL
};
static escp2_variable_inklist_t variable_6pl_4color_inks =
{
&standard_inks,
&standard_inks,
&standard_inks,
&standard_inks,
NULL,
NULL,
NULL,
NULL,
&escp2_6pl_standard_inks,
&escp2_6pl_standard_inks,
&escp2_6pl_standard_inks,
&escp2_6pl_standard_inks,
NULL,
NULL,
NULL,
NULL
};
static escp2_variable_inklist_t variable_6pl_6color_inks =
{
&standard_inks,
&standard_inks,
&standard_inks,
&standard_inks,
&photo_inks,
&photo_inks,
&photo_inks,
&photo_inks,
&escp2_6pl_standard_inks,
&escp2_6pl_standard_inks,
&escp2_6pl_standard_inks,
&escp2_6pl_standard_inks,
&escp2_6pl_photo_inks,
&escp2_6pl_photo_inks,
&escp2_6pl_photo_inks,
&escp2_6pl_photo_inks
};
static escp2_variable_inklist_t variable_pigment_inks =
{
&standard_inks,
&standard_inks,
&standard_inks,
&standard_inks,
&photo_inks,
&photo_inks,
&photo_inks,
&photo_inks,
&escp2_pigment_standard_inks,
&escp2_pigment_standard_inks,
&escp2_pigment_standard_inks,
&escp2_pigment_standard_inks,
&escp2_pigment_photo_inks,
&escp2_pigment_photo_inks,
&escp2_pigment_photo_inks,
&escp2_pigment_photo_inks
};
static escp2_variable_inklist_t variable_3pl_inks =
{
&standard_inks,
&standard_inks,
&standard_inks,
&standard_inks,
NULL,
NULL,
NULL,
NULL,
&escp2_multishot_standard_inks,
&escp2_multishot_standard_inks,
&escp2_6pl_standard_inks,
&escp2_3pl_standard_inks,
NULL,
NULL,
NULL,
NULL
};
static escp2_variable_inklist_t variable_4pl_4color_inks =
{
&standard_inks,
&standard_inks,
&standard_inks,
&standard_inks,
NULL,
NULL,
NULL,
NULL,
&escp2_multishot_standard_inks,
&escp2_multishot_standard_inks,
&escp2_6pl_standard_inks,
&escp2_4pl_standard_inks,
NULL,
NULL,
NULL,
NULL
};
static escp2_variable_inklist_t variable_4pl_6color_inks =
{
&standard_inks,
&standard_inks,
&standard_inks,
&standard_inks,
&photo_inks,
&photo_inks,
&photo_inks,
&photo_inks,
&escp2_multishot_standard_inks,
&escp2_multishot_standard_inks,
&escp2_6pl_standard_inks,
&escp2_4pl_standard_inks,
&escp2_multishot_photo_inks,
&escp2_multishot_photo_inks,
&escp2_6pl_photo_inks,
&escp2_4pl_photo_inks
};
typedef struct escp2_printer
{
model_cap_t flags; /* Bitmask of flags, see below */
int nozzles; /* Number of nozzles per color */
int nozzle_separation; /* Separation between rows, in 1/720" */
int black_nozzles; /* Number of black nozzles (may be extra) */
int black_nozzle_separation; /* Separation between rows */
int xres; /* Normal distance between dots in */
/* softweave mode (inverse inches) */
int enhanced_xres; /* Distance between dots in highest */
/* quality modes */
int max_paper_width; /* Maximum paper width, in points*/
int max_paper_height; /* Maximum paper height, in points */
int left_margin; /* Left margin, points */
int right_margin; /* Right margin, points */
int top_margin; /* Absolute top margin, points */
int bottom_margin; /* Absolute bottom margin, points */
int separation_rows; /* Some printers require funky spacing */
/* arguments in microweave mode. */
int pseudo_separation_rows;/* Some printers require funky */
/* spacing arguments in softweave mode */
escp2_dot_size_t dot_sizes; /* Vector of dot sizes for resolutions */
escp2_densities_t densities; /* List of densities for each printer */
escp2_variable_inklist_t *inks; /* Choices of inks for this printer */
} escp2_printer_t;
#define MODEL_INIT_MASK 0xfull /* Is a special init sequence */
#define MODEL_INIT_STANDARD 0x0ull /* required for this printer, and if */
#define MODEL_INIT_900 0x1ull /* so, what */
#define MODEL_HASBLACK_MASK 0x10ull /* Can this printer print black ink */
#define MODEL_HASBLACK_YES 0x00ull /* when it is also printing color? */
#define MODEL_HASBLACK_NO 0x10ull /* Only the 1500 can't. */
#define MODEL_6COLOR_MASK 0x20ull /* Is this a 6-color printer? */
#define MODEL_6COLOR_NO 0x00ull
#define MODEL_6COLOR_YES 0x20ull
#define MODEL_1440DPI_MASK 0x40ull /* Can this printer do 1440x720 dpi? */
#define MODEL_1440DPI_NO 0x00ull
#define MODEL_1440DPI_YES 0x40ull
#define MODEL_GRAYMODE_MASK 0x80ull /* Does this printer support special */
#define MODEL_GRAYMODE_NO 0x00ull /* fast black printing? */
#define MODEL_GRAYMODE_YES 0x80ull
#define MODEL_720DPI_MODE_MASK 0x300ull /* Does this printer require old */
#define MODEL_720DPI_DEFAULT 0x000ull /* or new setting for printing */
#define MODEL_720DPI_600 0x100ull /* 720 dpi? Only matters for */
/* single dot size printers */
#define MODEL_VARIABLE_DOT_MASK 0xc00ull /* Does this printer support var */
#define MODEL_VARIABLE_NORMAL 0x000ull /* dot size printing? The newest */
#define MODEL_VARIABLE_4 0x400ull /* printers support multiple modes */
#define MODEL_VARIABLE_MULTI 0x800ull /* of variable dot sizes. */
#define MODEL_COMMAND_MASK 0xf000ull /* What general command set does */
#define MODEL_COMMAND_GENERIC 0x0000ull /* this printer use? */
#define MODEL_COMMAND_1998 0x1000ull
#define MODEL_COMMAND_1999 0x2000ull /* The 1999 series printers */
#define MODEL_INK_MASK 0x10000ull /* Does this printer support */
#define MODEL_INK_NORMAL 0x00000ull /* different types of inks? */
#define MODEL_INK_SELECTABLE 0x10000ull /* Only the Stylus Pro's do */
#define MODEL_ROLLFEED_MASK 0x20000ull /* Does this printer support */
#define MODEL_ROLLFEED_NO 0x00000ull /* a roll feed? */
#define MODEL_ROLLFEED_YES 0x20000ull
#define MODEL_ZEROMARGIN_MASK 0x40000ull /* Does this printer support */
#define MODEL_ZEROMARGIN_NO 0x00000ull /* zero margin mode? */
#define MODEL_ZEROMARGIN_YES 0x40000ull /* (print to the edge of the paper) */
#define INCH(x) (72 * x)
static escp2_printer_t model_capabilities[] =
{
/* FIRST GENERATION PRINTERS */
/* 0: Stylus Color */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_GENERIC | MODEL_GRAYMODE_YES | MODEL_1440DPI_NO
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
1, 1, 1, 1, 720, 720, INCH(17 / 2), INCH(14), 14, 14, 9, 49, 1, 0,
{ -2, -2, -1, -2, -1, -1, -1 },
{ 2.0, 1.3, 1.3, .568, 0, 0, 0, 0, 0 },
&simple_4color_inks
},
/* 1: Stylus Color Pro/Pro XL/400/500 */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_GENERIC | MODEL_GRAYMODE_NO | MODEL_1440DPI_NO
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
48, 6, 48, 6, 720, 720, INCH(17 / 2), INCH(14), 14, 14, 0, 30, 1, 0,
{ -2, -2, -1, -2, -1, -1, -1 },
{ 2.0, 1.3, 1.3, .631, 0, 0, 0, 0, 0 },
&simple_4color_inks
},
/* 2: Stylus Color 1500 */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_NO | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_GENERIC | MODEL_GRAYMODE_NO | MODEL_1440DPI_NO
| MODEL_ROLLFEED_YES | MODEL_ZEROMARGIN_NO),
1, 1, 1, 1, 720, 720, INCH(11), INCH(17), 14, 14, 9, 49, 1, 0,
{ -2, -2, -1, -2, -1, -1, -1 },
{ 2.0, 1.3, 1.3, .631, 0, 0, 0, 0, 0 },
&simple_4color_inks
},
/* 3: Stylus Color 600 */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_600 | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_GENERIC | MODEL_GRAYMODE_YES | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
32, 8, 32, 8, 720, 360, INCH(17 / 2), INCH(14), 8, 9, 0, 30, 1, 0,
{ 4, 4, -1, 2, 2, -1, 1 },
{ 2.0, 1.3, 1.3, .775, .775, .55, .55, .275, .138 },
&simple_4color_inks
},
/* 4: Stylus Color 800 */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_GENERIC | MODEL_GRAYMODE_YES | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
64, 4, 64, 4, 720, 360, INCH(17 / 2), INCH(14), 8, 9, 9, 40, 1, 4,
{ 3, 3, -1, 1, 1, -1, 4 },
{ 2.0, 1.3, 1.3, .775, .775, .55, .55, .275, .138 },
&simple_4color_inks
},
/* 5: Stylus Color 850 */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_GENERIC | MODEL_GRAYMODE_YES | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
64, 4, 128, 2, 720, 360, INCH(17 / 2), INCH(14), 9, 9, 9, 40, 1, 4,
{ 3, 3, -1, 1, 1, -1, 4 },
{ 2.0, 1.3, 1.3, .775, .775, .55, .55, .275, .138 },
&simple_4color_inks
},
/* 6: Stylus Color 1520 */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_GENERIC | MODEL_GRAYMODE_YES | MODEL_1440DPI_YES
| MODEL_ROLLFEED_YES | MODEL_ZEROMARGIN_NO),
64, 4, 64, 4, 720, 360, INCH(17), INCH(55), 8, 9, 9, 40, 1, 4,
{ 3, 3, -1, 1, 1, -1, 4 },
{ 2.0, 1.3, 1.3, .775, .775, .55, .55, .275, .138 },
&simple_4color_inks
},
/* SECOND GENERATION PRINTERS */
/* 7: Stylus Photo 700 */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_YES | MODEL_720DPI_600 | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_1998 | MODEL_GRAYMODE_NO | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
32, 8, 32, 8, 720, 360, INCH(17 / 2), INCH(14), 9, 9, 0, 30, 1, 0,
{ 3, 3, -1, -1, 1, -1, 4 },
{ 2.0, 1.3, 1.3, .775, .775, .55, .55, .275, .138 },
&simple_6color_inks
},
/* 8: Stylus Photo EX */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_YES | MODEL_720DPI_600 | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_1998 | MODEL_GRAYMODE_NO | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
32, 8, 32, 8, 720, 360, INCH(11), INCH(17), 9, 9, 0, 30, 1, 0,
{ 3, 3, -1, -1, 1, -1, 4 },
{ 2.0, 1.3, 1.3, .775, .775, .55, .55, .275, .138 },
&simple_6color_inks
},
/* 9: Stylus Photo */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_YES | MODEL_720DPI_600 | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_1998 | MODEL_GRAYMODE_NO | MODEL_1440DPI_NO
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
32, 8, 32, 8, 720, 360, INCH(17 / 2), INCH(14), 9, 9, 0, 30, 1, 0,
{ 3, 3, -1, -1, 1, -1, -1 },
{ 2.0, 1.3, 1.3, .775, .775, 0, 0, 0, 0 },
&simple_6color_inks
},
/* THIRD GENERATION PRINTERS */
/* 10: Stylus Color 440/460 */
/* Thorsten Schnier has confirmed that the separation is 8. Why on */
/* earth anyone would use 21 nozzles when designing a print head is */
/* completely beyond me, but there you are... */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_600 | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_YES | MODEL_1440DPI_NO
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
21, 8, 21, 8, 720, 720, INCH(17 / 2), INCH(14), 9, 9, 0, 9, 1, 0,
{ -1, 3, -1, 1, 1, -1, -1 },
{ 3.0, 2.0, 2.0, .900, .900, 0, 0, 0, 0 },
&simple_4color_inks
},
/* 11: Stylus Color 640 */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_600 | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_YES | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
32, 8, 64, 4, 720, 720, INCH(17 / 2), INCH(14), 9, 9, 0, 9, 1, 0,
{ -1, 3, -1, 1, 1, -1, 1 },
{ 3.0, 2.0, 2.0, .900, .900, .45, .45, .225, .113 },
&simple_4color_inks
},
/* 12: Stylus Color 740 */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_4
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_YES | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
48, 6, 144, 2, 360, 360, INCH(17 / 2), INCH(14), 9, 9, 0, 9, 1, 0,
{ -1, 4, 0x10, 3, 0x10, -1, 0x10 },
{ 2.0, 1.3, 2.0, .646, .710, .323, .365, .1825, .0913 },
&variable_6pl_4color_inks
},
/* 13: Stylus Color 900 */
/* Still need to figure out density for 3 pl drops! */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_4
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_YES | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
96, 4, 192, 2, 360, 180, INCH(17 / 2), INCH(44), 9, 9, 0, 9, 1, 0,
{ -1, 1, 0x11, 1, 0x10, -1, 0x10 },
{ 2.0, 1.3, 1.3, .646, .710, .323, .365, .1825, .0913 },
&variable_3pl_inks
},
/* 14: Stylus Photo 750 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_YES | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_4
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_NO | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
48, 6, 48, 6, 360, 360, INCH(17 / 2), INCH(44), 9, 9, 0, 9, 1, 0,
{ -1, 2, 0x10, 4, 0x10, -1, 0x10 },
{ 2.0, 1.3, 1.3, .646, .710, .323, .365, .1825, .0913 },
&variable_6pl_6color_inks
},
/* 15: Stylus Photo 1200 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_YES | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_4
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_NO | MODEL_1440DPI_YES
| MODEL_ROLLFEED_YES | MODEL_ZEROMARGIN_NO),
48, 6, 48, 6, 360, 360, INCH(13), INCH(44), 9, 9, 0, 9, 1, 0,
{ -1, 2, 0x10, 4, 0x10, -1, 0x10 },
{ 2.0, 1.3, 1.3, .646, .710, .323, .365, .1825, .0913 },
&variable_6pl_6color_inks
},
/* 16: Stylus Color 860 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_MULTI
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_YES | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
48, 6, 144, 2, 360, 360, INCH(17 / 2), INCH(14), 9, 9, 0, 9, 1, 0,
{ -1, 0, 0x12, 0, 0x11, -1, 0x10 },
{ 2.0, 1.3, 1.3, .431, .710, .216, .533, .2665, .1333 },
&variable_4pl_4color_inks
},
/* 17: Stylus Color 1160 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_MULTI
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_YES | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
48, 6, 144, 2, 360, 360, INCH(13), INCH(44), 9, 9, 0, 9, 1, 0,
{ -1, 0, 0x12, 0, 0x11, -1, 0x10 },
{ 2.0, 1.3, 1.3, .431, .710, .216, .533, .2665, .1333 },
&variable_4pl_4color_inks
},
/* 18: Stylus Color 660 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_600 | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_1998 | MODEL_GRAYMODE_YES | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
32, 8, 64, 4, 720, 720, INCH(17 / 2), INCH(44), 9, 9, 0, 9, 1, 8,
{ -1, 3, -1, 3, 0, -1, 0 },
{ 3.0, 2.0, 2.0, .646, .646, .323, .323, .1615, .0808 },
&simple_4color_inks
},
/* 19: Stylus Color 760 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_MULTI
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_YES | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
48, 6, 144, 2, 360, 360, INCH(17 / 2), INCH(14), 9, 9, 0, 9, 1, 0,
{ -1, 0, 0x12, 0, 0x11, -1, 0x10 },
{ 2.0, 1.3, 1.3, .431, .710, .216, .533, .2665, .1333 },
&variable_4pl_4color_inks
},
/* 20: Stylus Photo 720 (Australia) */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_YES | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_4
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_NO | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
32, 8, 32, 8, 360, 360, INCH(17 / 2), INCH(14), 9, 9, 0, 9, 1, 0,
{ -1, 2, 0x12, 4, 0x11, -1, 0x11 },
{ 2.0, 1.3, 1.3, .646, .710, .323, .365, .1825, .0913 },
&variable_6pl_6color_inks
},
/* 21: Stylus Color 480 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_4
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_NO | MODEL_1440DPI_NO
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
15, 6, 15, 6, 360, 360, INCH(17 / 2), INCH(14), 9, 9, 0, 9, 1, 0,
{ -1, -2, 0x13, -2, 0x10, -1, -1 },
{ 2.0, 1.3, 1.3, .646, .710, .323, .365, .1825, .0913 },
&variable_6pl_4color_inks
},
/* 22: Stylus Photo 870 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_YES | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_MULTI
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_NO | MODEL_1440DPI_YES
| MODEL_ROLLFEED_YES | MODEL_ZEROMARGIN_YES),
48, 6, 48, 6, 360, 360, INCH(17 / 2), INCH(44), 0, 0, 0, 9, 1, 0,
{ -1, 4, 0x12, 2, 0x11, -1, 0x10 },
{ 2.0, 1.3, 1.3, .431, .710, .216, .533, .2665, .1333 },
&variable_4pl_6color_inks
},
/* 23: Stylus Photo 1270 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_YES | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_MULTI
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_NO | MODEL_1440DPI_YES
| MODEL_ROLLFEED_YES | MODEL_ZEROMARGIN_YES),
48, 6, 48, 6, 360, 360, INCH(13), INCH(44), 0, 0, 0, 9, 1, 0,
{ -1, 4, 0x12, 2, 0x11, -1, 0x10 },
{ 2.0, 1.3, 1.3, .431, .710, .216, .533, .2665, .1333 },
&variable_4pl_6color_inks
},
/* 24: Stylus Color 3000 */
{
(MODEL_INIT_STANDARD | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_GENERIC | MODEL_GRAYMODE_YES | MODEL_1440DPI_YES
| MODEL_ROLLFEED_YES | MODEL_ZEROMARGIN_NO),
64, 4, 64, 4, 720, 360, INCH(17), INCH(55), 8, 9, 9, 40, 1, 4,
{ 3, 3, -1, 1, 1, -1, 4 },
{ 2.0, 1.3, 1.3, .775, .775, .55, .55, .275, .138 },
&simple_4color_inks
},
/* 25: Stylus Color 670 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_NO | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_MULTI
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_YES | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
32, 8, 64, 4, 360, 360, INCH(17 / 2), INCH(44), 9, 9, 0, 9, 1, 0,
{ -1, 3, 0x12, 3, 0x11, -1, 0x11 },
{ 2.0, 1.3, 1.3, .646, .710, .323, .365, .1825, .0913 },
&variable_6pl_4color_inks
},
/* 26: Stylus Photo 2000P */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_YES | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_4
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_NO | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
48, 6, 144, 2, 360, 360, INCH(17 / 2), INCH(44), 9, 9, 0, 9, 1, 0,
{ -1, 2, 0x11, 4, 0x10, -1, 0x10 },
{ 2.0, 1.3, 1.3, .775, .852, .388, .438, .219, .110 },
&variable_pigment_inks
},
/* 27: Stylus Pro 5000 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_YES | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_NO | MODEL_1440DPI_YES
| MODEL_ROLLFEED_NO | MODEL_ZEROMARGIN_NO),
64, 4, 64, 4, 360, 360, INCH(13), INCH(1200), 9, 9, 0, 9, 1, 0,
{ -1, 2, -1, 4, 0, 4, 0 },
{ 2.0, 1.3, 1.3, .646, .646, .323, .323, .1615, .0808 },
&simple_6color_inks
},
/* 28: Stylus Pro 7000 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_YES | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_NO | MODEL_1440DPI_YES
| MODEL_ROLLFEED_YES | MODEL_ZEROMARGIN_NO),
64, 4, 64, 4, 360, 360, INCH(24), INCH(1200), 9, 9, 0, 9, 1, 0,
{ -1, 2, -1, 4, 0, 4, 0 },
{ 2.0, 1.3, 1.3, .646, .646, .323, .323, .1615, .0808 },
&simple_6color_inks
},
/* 29: Stylus Pro 7500 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_SELECTABLE
| MODEL_6COLOR_YES | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_NO | MODEL_1440DPI_YES
| MODEL_ROLLFEED_YES | MODEL_ZEROMARGIN_NO),
64, 4, 64, 4, 360, 360, INCH(24), INCH(1200), 9, 9, 0, 9, 1, 0,
{ -1, 2, -1, 4, 0, 4, 0 },
{ 2.0, 1.3, 1.3, .646, .646, .323, .323, .1615, .0808 },
&simple_6color_inks
},
/* 30: Stylus Pro 9000 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_NORMAL
| MODEL_6COLOR_YES | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_NO | MODEL_1440DPI_YES
| MODEL_ROLLFEED_YES | MODEL_ZEROMARGIN_NO),
64, 4, 64, 4, 360, 360, INCH(44), INCH(1200), 9, 9, 0, 9, 1, 0,
{ -1, 2, -1, 4, 0, 4, 0 },
{ 2.0, 1.3, 1.3, .646, .646, .323, .323, .1615, .0808 },
&simple_6color_inks
},
/* 31: Stylus Pro 9500 */
{
(MODEL_INIT_900 | MODEL_HASBLACK_YES | MODEL_INK_SELECTABLE
| MODEL_6COLOR_YES | MODEL_720DPI_DEFAULT | MODEL_VARIABLE_NORMAL
| MODEL_COMMAND_1999 | MODEL_GRAYMODE_NO | MODEL_1440DPI_YES
| MODEL_ROLLFEED_YES | MODEL_ZEROMARGIN_NO),
64, 4, 64, 4, 360, 360, INCH(44), INCH(1200), 9, 9, 0, 9, 1, 0,
{ -1, 2, -1, 4, 0, 4, 0 },
{ 2.0, 1.3, 1.3, .646, .646, .323, .323, .1615, .0808 },
&simple_6color_inks
},
};
typedef struct escp_init
{
int model;
int output_type;
int ydpi;
int xdpi;
int use_softweave;
int page_length;
int page_width;
int page_top;
int page_bottom;
int nozzles;
int nozzle_separation;
int horizontal_passes;
int vertical_passes;
int vertical_oversample;
int bits;
const char *paper_type;
} escp_init_t;
typedef struct {
const char name[65];
int hres;
int vres;
int softweave;
int vertical_passes;
int vertical_oversample;
} res_t;
static const res_t escp2_reslist[] = {
{ "180 DPI", 180, 180, 0, 1, 1 },
{ "360 DPI", 360, 360, 0, 1, 1 },
{ "360 DPI Softweave", 360, 360, 1, 1, 1 },
{ "360 DPI High Quality", 360, 360, 1, 2, 1 },
{ "720 DPI Microweave", 720, 720, 0, 1, 1 },
{ "720 DPI Softweave", 720, 720, 1, 1, 1 },
{ "720 DPI High Quality", 720, 720, 1, 2, 1 },
{ "720 DPI Highest Quality", 720, 720, 1, 4, 1 },
{ "1440 x 720 DPI Microweave", 1440, 720, 0, 1, 1 },
{ "1440 x 720 DPI Softweave", 1440, 720, 1, 1, 1 },
{ "1440 x 720 DPI Highest Quality", 1440, 720, 1, 2, 1 },
{ "1440 x 1440 DPI Emulated", 1440, 1440, 1, 1, 2 },
{ "1440 x 2880 DPI Emulated", 1440, 2880, 1, 1, 4 },
{ "", 0, 0, 0, 0, 0 }
};
typedef struct {
const char name[65];
int is_color;
int variable_dot_size;
int dot_size_bits;
simple_dither_range_t *standard_dither;
simple_dither_range_t *photo_dither;
} ink_t;
typedef struct {
const char name[65];
int paper_feed_sequence;
int platen_gap;
double base_density;
double k_lower_scale;
double k_upper;
} paper_t;
static const paper_t escp2_paper_list[] = {
{ "Plain Paper", 1, 0, .5, .25, .5 },
{ "Plain Paper Fast Load", 5, 0, .5, .25, .5 },
{ "Postcard", 2, 0, .6, .25, .6 },
{ "Glossy Film", 3, 0, 1.0, 1.0, .999 },
{ "Transparencies", 3, 0, 1.0, 1.0, .999 },
{ "Envelopes", 4, 0, .5, .25, .5 },
{ "Back Light Film", 6, 0, 1.0, 1.0, .999 },
{ "Matte Paper", 7, 0, 1.0, 1.0, .999 },
{ "Inkjet Paper", 7, 0, .78, .25, .6 },
{ "Photo Quality Inkjet Paper", 7, 0, 1, 1.0, .999 },
{ "Photo Paper", 8, 0, 1, 1.0, .999 },
{ "Premium Glossy Photo Paper", 8, 0, .9, 1.0, .999 },
{ "Photo Quality Glossy Paper", 6, 0, 1.0, 1.0, .999 },
{ "Other", 0, 0, .5, .25, .5 },
};
static const int paper_type_count = sizeof(escp2_paper_list) / sizeof(paper_t);
static const paper_t *
get_media_type(const char *name)
{
int i;
for (i = 0; i < paper_type_count; i++)
{
if (!strcmp(name, escp2_paper_list[i].name))
return &(escp2_paper_list[i]);
}
return NULL;
}
static int
escp2_has_cap(int model, model_featureset_t featureset,
model_featureset_t class)
{
return ((model_capabilities[model].flags & featureset) == class);
}
static unsigned
escp2_nozzles(int model)
{
return (model_capabilities[model].nozzles);
}
static unsigned
escp2_black_nozzles(int model)
{
return (model_capabilities[model].black_nozzles);
}
static unsigned
escp2_nozzle_separation(int model)
{
return (model_capabilities[model].nozzle_separation);
}
static unsigned
escp2_black_nozzle_separation(int model)
{
return (model_capabilities[model].black_nozzle_separation);
}
static unsigned
escp2_separation_rows(int model)
{
return (model_capabilities[model].separation_rows);
}
static unsigned
escp2_xres(int model)
{
return (model_capabilities[model].xres);
}
static unsigned
escp2_enhanced_xres(int model)
{
return (model_capabilities[model].enhanced_xres);
}
static int
escp2_ink_type(int model, int resolution, int microweave)
{
if (microweave)
{
switch (resolution)
{
case 180:
return model_capabilities[model].dot_sizes.dot_180;
case 360:
return model_capabilities[model].dot_sizes.dot_360_microweave;
case 720:
return model_capabilities[model].dot_sizes.dot_720_microweave;
case 1440:
return model_capabilities[model].dot_sizes.dot_1440_microweave;
default:
return -1;
}
}
else
{
switch (resolution)
{
case 180:
return model_capabilities[model].dot_sizes.dot_180;
case 360:
return model_capabilities[model].dot_sizes.dot_360;
case 720:
return model_capabilities[model].dot_sizes.dot_720;
case 1440:
return model_capabilities[model].dot_sizes.dot_1440;
default:
return -1;
}
}
}
static double
escp2_density(int model, int xdpi, int ydpi, int microweave)
{
if (microweave)
{
switch (xdpi)
{
case 180:
return model_capabilities[model].densities.d_180_180;
case 360:
return model_capabilities[model].densities.d_360_360_micro;
case 720:
return model_capabilities[model].densities.d_720_720_micro;
case 1440:
return model_capabilities[model].densities.d_1440_720_micro;
}
}
switch (xdpi)
{
case 180:
return model_capabilities[model].densities.d_180_180;
case 360:
return model_capabilities[model].densities.d_360_360;
case 720:
return model_capabilities[model].densities.d_720_720;
case 1440:
switch (ydpi)
{
case 720:
return model_capabilities[model].densities.d_1440_720;
case 1440:
return model_capabilities[model].densities.d_1440_1440;
case 2880:
return model_capabilities[model].densities.d_1440_2880;
}
}
return 0;
}
static escp2_variable_inkset_t *
escp2_inks(int model, int xdpi, int colors, int bits)
{
escp2_variable_inklist_t *inks = model_capabilities[model].inks;
switch (bits)
{
case 1:
switch (colors)
{
case 1:
case 4:
switch (xdpi)
{
case 180:
return inks->s_180_4;
case 360:
return inks->s_360_4;
case 720:
return inks->s_720_4;
case 1440:
return inks->s_1440_4;
}
case 6:
switch (xdpi)
{
case 180:
return inks->s_180_6;
case 360:
return inks->s_360_6;
case 720:
return inks->s_720_6;
case 1440:
return inks->s_1440_6;
}
}
case 2:
switch (colors)
{
case 1:
case 4:
switch (xdpi)
{
case 180:
return inks->v_180_4;
case 360:
return inks->v_360_4;
case 720:
return inks->v_720_4;
case 1440:
return inks->v_1440_4;
}
case 6:
switch (xdpi)
{
case 180:
return inks->v_180_6;
case 360:
return inks->v_360_6;
case 720:
return inks->v_720_6;
case 1440:
return inks->v_1440_6;
}
}
}
return NULL;
}
static unsigned
escp2_max_paper_width(int model)
{
return (model_capabilities[model].max_paper_width);
}
static unsigned
escp2_max_paper_height(int model)
{
return (model_capabilities[model].max_paper_height);
}
static unsigned
escp2_left_margin(int model)
{
return (model_capabilities[model].left_margin);
}
static unsigned
escp2_right_margin(int model)
{
return (model_capabilities[model].right_margin);
}
static unsigned
escp2_top_margin(int model)
{
return (model_capabilities[model].top_margin);
}
static unsigned
escp2_bottom_margin(int model)
{
return (model_capabilities[model].bottom_margin);
}
static int
escp2_pseudo_separation_rows(int model)
{
return (model_capabilities[model].pseudo_separation_rows);
}
/*
* 'escp2_parameters()' - Return the parameter values for the given parameter.
*/
char ** /* O - Parameter values */
escp2_parameters(const printer_t *printer, /* I - Printer model */
char *ppd_file, /* I - PPD file (not used) */
char *name, /* I - Name of parameter */
int *count) /* O - Number of values */
{
int i;
int model = printer->model;
char **valptrs;
static const char *ink_types[] =
{
"Six Color Photo",
"Four Color Standard"
};
if (count == NULL)
return (NULL);
*count = 0;
if (name == NULL)
return (NULL);
if (strcmp(name, "PageSize") == 0)
{
unsigned int length_limit, width_limit;
const papersize_t *papersizes = get_papersizes();
valptrs = malloc(sizeof(char *) * known_papersizes());
*count = 0;
width_limit = escp2_max_paper_width(model);
length_limit = escp2_max_paper_height(model);
for (i = 0; i < known_papersizes(); i++)
{
if (strlen(papersizes[i].name) > 0 &&
papersizes[i].width <= width_limit &&
papersizes[i].length <= length_limit)
{
valptrs[*count] = malloc(strlen(papersizes[i].name) + 1);
strcpy(valptrs[*count], papersizes[i].name);
(*count)++;
}
}
return (valptrs);
}
else if (strcmp(name, "Resolution") == 0)
{
const res_t *res = &(escp2_reslist[0]);
valptrs = malloc(sizeof(char *) * sizeof(escp2_reslist) / sizeof(res_t));
*count = 0;
while(res->hres)
{
if (escp2_ink_type(model, res->hres, !res->softweave) != -1)
{
int nozzles = escp2_nozzles(model);
int xdpi = res->hres;
int physical_xdpi = xdpi > 720 ? escp2_enhanced_xres(model) :
escp2_xres(model);
int horizontal_passes = xdpi / physical_xdpi;
int oversample = horizontal_passes * res->vertical_passes
* res->vertical_oversample;
if (horizontal_passes < 1)
horizontal_passes = 1;
if (oversample < 1)
oversample = 1;
if (((horizontal_passes * res->vertical_passes) <= 8) &&
(! res->softweave || (nozzles > 1 && nozzles > oversample)))
{
valptrs[*count] = malloc(strlen(res->name) + 1);
strcpy(valptrs[*count], res->name);
(*count)++;
}
}
res++;
}
return (valptrs);
}
else if (strcmp(name, "InkType") == 0)
{
if (escp2_has_cap(model, MODEL_6COLOR_MASK, MODEL_6COLOR_NO))
return NULL;
else
{
int ninktypes = sizeof(ink_types) / sizeof(char *);
valptrs = malloc(sizeof(char *) * ninktypes);
for (i = 0; i < ninktypes; i++)
{
valptrs[i] = malloc(strlen(ink_types[i]) + 1);
strcpy(valptrs[i], ink_types[i]);
}
*count = ninktypes;
return valptrs;
}
}
else if (strcmp(name, "MediaType") == 0)
{
int nmediatypes = paper_type_count;
valptrs = malloc(sizeof(char *) * nmediatypes);
for (i = 0; i < nmediatypes; i++)
{
valptrs[i] = malloc(strlen(escp2_paper_list[i].name) + 1);
strcpy(valptrs[i], escp2_paper_list[i].name);
}
*count = nmediatypes;
return valptrs;
}
else
return (NULL);
}
/*
* 'escp2_imageable_area()' - Return the imageable area of the page.
*/
void
escp2_imageable_area(const printer_t *printer, /* I - Printer model */
const vars_t *v, /* I */
int *left, /* O - Left position in points */
int *right, /* O - Right position in points */
int *bottom, /* O - Bottom position in points */
int *top) /* O - Top position in points */
{
int width, length; /* Size of page */
default_media_size(printer, v, &width, &length);
*left = escp2_left_margin(printer->model);
*right = width - escp2_right_margin(printer->model);
*top = length - escp2_top_margin(printer->model);
*bottom = escp2_bottom_margin(printer->model);
}
void
escp2_limit(const printer_t *printer, /* I - Printer model */
const vars_t *v, /* I */
int *width, /* O - Left position in points */
int *length) /* O - Top position in points */
{
*width = escp2_max_paper_width(printer->model);
*length = escp2_max_paper_height(printer->model);
}
const char *
escp2_default_resolution(const printer_t *printer)
{
const res_t *res = &(escp2_reslist[0]);
while (res->hres)
{
if (escp2_ink_type(printer->model, res->hres, !res->softweave) != -1)
{
int nozzles = escp2_nozzles(printer->model);
int xdpi = res->hres;
int physical_xdpi = xdpi > 720 ?
escp2_enhanced_xres(printer->model) : escp2_xres(printer->model);
int horizontal_passes = xdpi / physical_xdpi;
int oversample = horizontal_passes * res->vertical_passes
* res->vertical_oversample;
if (horizontal_passes < 1)
horizontal_passes = 1;
if (oversample < 1)
oversample = 1;
if (((horizontal_passes * res->vertical_passes) <= 8) &&
(! res->softweave || (nozzles > 1 && nozzles > oversample)))
return res->name;
}
res++;
}
return NULL;
}
static void
escp2_reset_printer(FILE *prn, escp_init_t *init)
{
/*
* Hack that seems to be necessary for these silly things to recognize
* the input. It only needs to be done once per printer evidently, but
* it needs to be done.
*/
if (escp2_has_cap(init->model, MODEL_INIT_MASK, MODEL_INIT_900))
fprintf(prn, "%c%c%c\033\001@EJL 1284.4\n@EJL \n\033@", 0, 0, 0);
fputs("\033@", prn); /* ESC/P2 reset */
}
static void
escp2_set_remote_sequence(FILE *prn, escp_init_t *init)
{
/* Magic remote mode commands, whatever they do */
if (escp2_has_cap(init->model, MODEL_COMMAND_MASK, MODEL_COMMAND_1999))
{
int feed_sequence = 0;
const paper_t *p = get_media_type(init->paper_type);
if (p)
feed_sequence = p->paper_feed_sequence;
fprintf(prn, /* Enter remote mode */
"\033(R\010%c%cREMOTE1"
/* Function unknown */
"PM\002%c%c%c"
/* Set mechanism sequence */
"SN\003%c%c%c%c",
0, 0,
0, 0, 0,
0, 0, 0, feed_sequence);
if (escp2_has_cap(init->model, MODEL_ZEROMARGIN_MASK,
MODEL_ZEROMARGIN_YES))
fprintf(prn, /* Set zero-margin print mode */
"FP\003%c%c\260\377", 0, 0);
fprintf(prn, /* Exit remote mode */
"\033%c%c%c", 0, 0, 0);
}
}
static void
escp2_set_graphics_mode(FILE *prn, escp_init_t *init)
{
fwrite("\033(G\001\000\001", 6, 1, prn); /* Enter graphics mode */
}
static void
escp2_set_resolution(FILE *prn, escp_init_t *init)
{
if (!(escp2_has_cap(init->model, MODEL_VARIABLE_DOT_MASK,
MODEL_VARIABLE_NORMAL)) &&
init->use_softweave)
fprintf(prn, "\033(U\005%c%c%c%c%c%c", 0, 1440 / init->ydpi,
1440 / init->ydpi,
1440 / (init->ydpi * (init->horizontal_passes > 2 ? 2 : 1)),
1440 % 256, 1440 / 256);
else
fprintf(prn, "\033(U\001%c%c", 0, 3600 / init->ydpi);
}
static void
escp2_set_color(FILE *prn, escp_init_t *init)
{
if (escp2_has_cap(init->model, MODEL_GRAYMODE_MASK, MODEL_GRAYMODE_YES))
fprintf(prn, "\033(K\002%c%c%c", 0, 0,
(init->output_type == OUTPUT_GRAY ? 1 : 2));
}
static void
escp2_set_microweave(FILE *prn, escp_init_t *init)
{
fprintf(prn, "\033(i\001%c%c", 0,
(init->use_softweave || init->ydpi < 720) ? 0 : 1);
}
static void
escp2_set_printhead_speed(FILE *prn, escp_init_t *init)
{
if (init->horizontal_passes * init->vertical_passes *
init->vertical_oversample * escp2_xres(init->model) / 720 > 2)
{
fprintf(prn, "\033U%c", 1);
if (init->xdpi > 720) /* Slow mode if available */
fprintf(prn, "\033(s%c%c%c", 1, 0, 2);
}
else
fprintf(prn, "\033U%c", 0);
}
static void
escp2_set_dot_size(FILE *prn, escp_init_t *init)
{
/* Dot size */
int drop_size = escp2_ink_type(init->model, init->xdpi,
!init->use_softweave);
if (drop_size >= 0)
fprintf(prn, "\033(e\002%c%c%c", 0, 0, drop_size);
}
static void
escp2_set_page_length(FILE *prn, escp_init_t *init)
{
int l = init->ydpi * init->page_length / 72;
if (!(escp2_has_cap(init->model, MODEL_VARIABLE_DOT_MASK,
MODEL_VARIABLE_NORMAL)) &&
init->use_softweave)
fprintf(prn, "\033(C\004%c%c%c%c%c", 0,
l & 0xff, (l >> 8) & 0xff, (l >> 16) & 0xff, (l >> 24) & 0xff);
else
fprintf(prn, "\033(C\002%c%c%c", 0, l & 255, l >> 8);
}
static void
escp2_set_margins(FILE *prn, escp_init_t *init)
{
int l = init->ydpi * (init->page_length - init->page_bottom) / 72;
int t = init->ydpi * (init->page_length - init->page_top) / 72;
if (!(escp2_has_cap(init->model, MODEL_VARIABLE_DOT_MASK,
MODEL_VARIABLE_NORMAL)) &&
init->use_softweave)
{
if (escp2_has_cap(init->model, MODEL_6COLOR_MASK, MODEL_6COLOR_YES))
fprintf(prn, "\033(c\010%c%c%c%c%c%c%c%c%c", 0,
t & 0xff, t >> 8, (t >> 16) & 0xff, (t >> 24) & 0xff,
l & 0xff, l >> 8, (l >> 16) & 0xff, (l >> 24) & 0xff);
else
fprintf(prn, "\033(c\004%c%c%c%c%c", 0,
t & 0xff, t >> 8, l & 0xff, l >> 8);
}
else
fprintf(prn, "\033(c\004%c%c%c%c%c", 0,
t & 0xff, t >> 8, l & 0xff, l >> 8);
}
static void
escp2_set_form_factor(FILE *prn, escp_init_t *init)
{
int page_width = init->page_width * init->ydpi / 72;
int page_length = init->page_length * init->ydpi / 72;
if (escp2_has_cap(init->model, MODEL_ZEROMARGIN_MASK, MODEL_ZEROMARGIN_YES))
/* Make the page 2/10" wider (probably ignored by the printer anyway) */
page_width += 144 * 720 / init->xdpi;
if (escp2_has_cap(init->model, MODEL_COMMAND_MASK, MODEL_COMMAND_1999))
fprintf(prn, "\033(S\010%c%c%c%c%c%c%c%c%c", 0,
((page_width >> 0) & 0xff), ((page_width >> 8) & 0xff),
((page_width >> 16) & 0xff), ((page_width >> 24) & 0xff),
((page_length >> 0) & 0xff), ((page_length >> 8) & 0xff),
((page_length >> 16) & 0xff), ((page_length >> 24) & 0xff));
}
static void
escp2_set_printhead_resolution(FILE *prn, escp_init_t *init)
{
if (!(escp2_has_cap(init->model, MODEL_VARIABLE_DOT_MASK,
MODEL_VARIABLE_NORMAL)) &&
init->use_softweave)
{
/* Magic resolution cookie */
if (init->xdpi > 720)
{
if (init->output_type == OUTPUT_GRAY)
fprintf(prn, "\033(D%c%c%c%c%c%c", 4, 0, 14400 % 256, 14400 / 256,
escp2_black_nozzle_separation(init->model) * 14400 / 720,
14400 / escp2_enhanced_xres(init->model));
else
fprintf(prn, "\033(D%c%c%c%c%c%c", 4, 0, 14400 % 256, 14400 / 256,
escp2_nozzle_separation(init->model) * 14400 / 720,
14400 / escp2_enhanced_xres(init->model));
}
else
{
if (init->output_type == OUTPUT_GRAY)
fprintf(prn, "\033(D%c%c%c%c%c%c", 4, 0, 14400 % 256, 14400 / 256,
escp2_black_nozzle_separation(init->model) * 14400 / 720,
14400 / escp2_xres(init->model));
else
fprintf(prn, "\033(D%c%c%c%c%c%c", 4, 0, 14400 % 256, 14400 / 256,
escp2_nozzle_separation(init->model) * 14400 / 720,
14400 / escp2_xres(init->model));
}
}
}
static void
escp2_init_printer(FILE *prn, escp_init_t *init)
{
if (init->ydpi > 720)
init->ydpi = 720;
escp2_reset_printer(prn, init);
escp2_set_remote_sequence(prn, init);
escp2_set_graphics_mode(prn, init);
escp2_set_resolution(prn, init);
escp2_set_color(prn, init);
escp2_set_microweave(prn, init);
escp2_set_printhead_speed(prn, init);
escp2_set_dot_size(prn, init);
escp2_set_page_length(prn, init);
escp2_set_margins(prn, init);
escp2_set_form_factor(prn, init);
escp2_set_printhead_resolution(prn, init);
}
static void
escp2_deinit_printer(FILE *prn, escp_init_t *init)
{
fputs(/* Eject page */
"\014"
/* ESC/P2 reset */
"\033@", prn);
if (escp2_has_cap(init->model, MODEL_COMMAND_MASK, MODEL_COMMAND_1999)) {
fprintf(prn, /* Enter remote mode */
"\033(R\010%c%cREMOTE1"
/* Load settings from NVRAM */
"LD%c%c"
/* Exit remote mode */
"\033%c%c%c", 0, 0, 0, 0, 0, 0, 0);
}
}
/*
* 'escp2_print()' - Print an image to an EPSON printer.
*/
void
escp2_print(const printer_t *printer, /* I - Model */
int copies, /* I - Number of copies */
FILE *prn, /* I - File to print to */
Image image, /* I - Image to print */
const vars_t *v)
{
unsigned char *cmap = v->cmap;
int model = printer->model;
const char *resolution = v->resolution;
const char *media_type = v->media_type;
int output_type = v->output_type;
int orientation = v->orientation;
const char *ink_type = v->ink_type;
double scaling = v->scaling;
int top = v->top;
int left = v->left;
int y; /* Looping vars */
int xdpi, ydpi; /* Resolution */
int physical_ydpi;
int physical_xdpi;
int n; /* Output number */
unsigned short *out; /* Output pixels (16-bit) */
unsigned char *in, /* Input pixels */
*black, /* Black bitmap data */
*cyan, /* Cyan bitmap data */
*magenta, /* Magenta bitmap data */
*lcyan, /* Light cyan bitmap data */
*lmagenta, /* Light magenta bitmap data */
*yellow; /* Yellow bitmap data */
int page_left, /* Left margin of page */
page_right, /* Right margin of page */
page_top, /* Top of page */
page_bottom, /* Bottom of page */
page_width, /* Width of page */
page_height, /* Height of page */
page_length, /* True length of page */
out_width, /* Width of image on page */
out_height, /* Height of image on page */
out_bpp, /* Output bytes per pixel */
length, /* Length of raster data */
errdiv, /* Error dividend */
errmod, /* Error modulus */
errval, /* Current error value */
errline, /* Current raster line */
errlast; /* Last raster line loaded */
convert_t colorfunc = 0; /* Color conversion function... */
int image_height,
image_width,
image_bpp;
int use_softweave = 0;
int nozzles = 1;
int nozzle_separation = 1;
int horizontal_passes = 1;
int vertical_passes = 1;
int vertical_oversample = 1;
int use_6color = 0;
const res_t *res;
int bits;
void * weave = NULL;
void * dither;
colormode_t colormode = COLOR_CCMMYK;
int separation_rows = escp2_separation_rows(model);
int ink_spread;
vars_t nv;
escp_init_t init;
escp2_variable_inkset_t *inks;
const paper_t *pt;
double k_upper, k_lower;
memcpy(&nv, v, sizeof(vars_t));
if (escp2_has_cap(model, MODEL_6COLOR_MASK, MODEL_6COLOR_YES) &&
strcmp(ink_type, "Four Color Standard") != 0 &&
nv.image_type != IMAGE_MONOCHROME)
use_6color = 1;
if (nv.image_type == IMAGE_MONOCHROME)
{
colormode = COLOR_MONOCHROME;
output_type = OUTPUT_GRAY;
bits = 1;
}
else if (output_type == OUTPUT_GRAY)
colormode = COLOR_MONOCHROME;
else if (use_6color)
colormode = COLOR_CCMMYK;
else
colormode = COLOR_CMYK;
/*
* Setup a read-only pixel region for the entire image...
*/
Image_init(image);
image_height = Image_height(image);
image_width = Image_width(image);
image_bpp = Image_bpp(image);
/*
* Choose the correct color conversion function...
*/
colorfunc = choose_colorfunc(output_type, image_bpp, cmap, &out_bpp, &nv);
/*
* Compute the output size...
*/
escp2_imageable_area(printer, &nv, &page_left, &page_right,
&page_bottom, &page_top);
compute_page_parameters(page_right, page_left, page_top, page_bottom,
scaling, image_width, image_height, image,
&orientation, &page_width, &page_height,
&out_width, &out_height, &left, &top);
/*
* Recompute the image height and width. If the image has been
* rotated, these will change from previously.
*/
image_height = Image_height(image);
image_width = Image_width(image);
/*
* Figure out the output resolution...
*/
for (res = &escp2_reslist[0];;res++)
{
if (!strcmp(resolution, res->name))
{
use_softweave = res->softweave;
xdpi = res->hres;
ydpi = res->vres;
vertical_passes = res->vertical_passes;
vertical_oversample = res->vertical_oversample;
if (xdpi > 720)
physical_xdpi = escp2_enhanced_xres(model);
else
physical_xdpi = escp2_xres(model);
if (use_softweave)
horizontal_passes = xdpi / physical_xdpi;
else
horizontal_passes = xdpi / 720;
if (horizontal_passes == 0)
horizontal_passes = 1;
if (output_type == OUTPUT_GRAY)
{
nozzles = escp2_black_nozzles(model);
if (nozzles == 0)
{
nozzle_separation = escp2_nozzle_separation(model);
nozzles = escp2_nozzles(model);
}
else
nozzle_separation = escp2_black_nozzle_separation(model);
}
else
{
nozzle_separation = escp2_nozzle_separation(model);
nozzles = escp2_nozzles(model);
}
if (ydpi < 720)
nozzle_separation = nozzle_separation * ydpi / 720;
break;
}
else if (!strcmp(resolution, ""))
{
return;
}
}
if (!(escp2_has_cap(model, MODEL_VARIABLE_DOT_MASK, MODEL_VARIABLE_NORMAL))
&& use_softweave)
bits = 2;
else
bits = 1;
/*
* Let the user know what we're doing...
*/
Image_progress_init(image);
/*
* Send ESC/P2 initialization commands...
*/
default_media_size(printer, &nv, &n, &page_length);
#if 0
/*
* I believe that this code is no longer needed. I think I put it in
* a while back because our softweave pattern couldn't handle the top
* and bottom of the page. Lying to the printer about the length of
* the page would allow us to print the entire image. With our current
* weave code able to use the entire width of the permitted region,
* this hack shouldn't be needed any more.
*/
page_length += (39 + (escp2_nozzles(model) * 2) *
escp2_nozzle_separation(model)) / 10; /* Top and bottom */
page_top += (39 + (escp2_nozzles(model) * 2) *
escp2_nozzle_separation(model)) / 10;
#endif
init.model = model;
init.output_type = output_type;
init.ydpi = ydpi;
init.xdpi = xdpi;
init.use_softweave = use_softweave;
init.page_length = page_length;
init.page_width = page_width;
init.page_top = page_top;
init.page_bottom = page_bottom;
init.horizontal_passes = horizontal_passes;
init.vertical_passes = vertical_passes;
init.vertical_oversample = vertical_oversample;
init.bits = bits;
init.paper_type = media_type;
escp2_init_printer(prn, &init);
/*
* Convert image size to printer resolution...
*/
out_width = xdpi * out_width / 72;
out_height = ydpi * out_height / 72;
physical_ydpi = ydpi;
if (ydpi > 720)
physical_ydpi = 720;
left = physical_ydpi * left / 72;
/*
* Adjust for zero-margin printing...
*/
if (escp2_has_cap(model, MODEL_ZEROMARGIN_MASK, MODEL_ZEROMARGIN_YES))
{
/*
* In zero-margin mode, the origin is about 3/20" to the left of the
* paper's left edge.
*/
left += 92 * physical_ydpi / 720;
}
/*
* Allocate memory for the raster data...
*/
length = (out_width + 7) / 8;
if (output_type == OUTPUT_GRAY)
{
black = malloc(length * bits);
cyan = NULL;
magenta = NULL;
lcyan = NULL;
lmagenta = NULL;
yellow = NULL;
}
else
{
cyan = malloc(length * bits);
magenta = malloc(length * bits);
yellow = malloc(length * bits);
if (escp2_has_cap(model, MODEL_HASBLACK_MASK, MODEL_HASBLACK_YES))
black = malloc(length * bits);
else
black = NULL;
if (use_6color) {
lcyan = malloc(length * bits);
lmagenta = malloc(length * bits);
} else {
lcyan = NULL;
lmagenta = NULL;
}
}
if (use_softweave)
/* Epson printers are all 720 physical dpi */
weave = initialize_weave(nozzles, nozzle_separation, horizontal_passes,
vertical_passes, vertical_oversample, colormode,
bits,
out_width * escp2_xres(model) / physical_ydpi,
out_height, separation_rows,
top * physical_ydpi / 72,
page_height * physical_ydpi / 72, use_softweave);
else
escp2_init_microweave(top * ydpi / 72);
/*
* Compute the LUT. For now, it's 8 bit, but that may eventually
* sometimes change.
*/
pt = get_media_type(nv.media_type);
if (pt)
nv.density *= pt->base_density;
else
nv.density *= .5; /* Can't find paper type? Assume plain */
nv.density *= escp2_density(model, xdpi, ydpi, !use_softweave);
if (nv.density > 1.0)
nv.density = 1.0;
compute_lut(256, &nv);
/*
* Output the page...
*/
if (xdpi > ydpi)
dither = init_dither(image_width, out_width, 1, xdpi / ydpi, &nv);
else
dither = init_dither(image_width, out_width, ydpi / xdpi, 1, &nv);
dither_set_black_levels(dither, 1.0, 1.0, 1.0);
if (use_6color)
k_lower = .4 / bits + .1;
else
k_lower = .25 / bits;
if (pt)
{
k_lower *= pt->k_lower_scale;
k_upper = pt->k_upper;
}
else
{
k_lower *= .5;
k_upper = .5;
}
dither_set_black_lower(dither, k_lower);
dither_set_black_upper(dither, k_upper);
if (bits == 2)
{
if (use_6color)
dither_set_adaptive_divisor(dither, 8);
else
dither_set_adaptive_divisor(dither, 16);
}
else
dither_set_adaptive_divisor(dither, 4);
inks = escp2_inks(model, xdpi, use_6color ? 6 : 4, bits);
if (inks->c)
dither_set_c_ranges(dither, inks->c->count, inks->c->range,
inks->c->density * nv.density);
if (inks->m)
dither_set_m_ranges(dither, inks->m->count, inks->m->range,
inks->m->density * nv.density);
if (inks->y)
dither_set_y_ranges(dither, inks->y->count, inks->y->range,
inks->y->density * nv.density);
if (inks->k)
dither_set_k_ranges(dither, inks->k->count, inks->k->range,
inks->k->density * nv.density);
if (bits == 2)
{
if (use_6color)
dither_set_transition(dither, .7);
else
dither_set_transition(dither, .5);
}
if (!strcmp(nv.dither_algorithm, "Ordered"))
dither_set_transition(dither, 1);
switch (nv.image_type)
{
case IMAGE_LINE_ART:
dither_set_ink_spread(dither, 19);
break;
case IMAGE_SOLID_TONE:
dither_set_ink_spread(dither, 15);
break;
case IMAGE_CONTINUOUS:
ink_spread = 13;
if (ydpi > 720)
ink_spread++;
if (bits > 1)
ink_spread++;
dither_set_ink_spread(dither, ink_spread);
break;
}
dither_set_density(dither, nv.density);
in = malloc(image_width * image_bpp);
out = malloc(image_width * out_bpp * 2);
errdiv = image_height / out_height;
errmod = image_height % out_height;
errval = 0;
errlast = -1;
errline = 0;
QUANT(0);
for (y = 0; y < out_height; y ++)
{
int duplicate_line = 1;
if ((y & 63) == 0)
Image_note_progress(image, y, out_height);
if (errline != errlast)
{
errlast = errline;
duplicate_line = 0;
Image_get_row(image, in, errline);
(*colorfunc)(in, out, image_width, image_bpp, cmap, &nv);
}
QUANT(1);
if (nv.image_type == IMAGE_MONOCHROME)
dither_monochrome(out, y, dither, black, duplicate_line);
else if (output_type == OUTPUT_GRAY)
dither_black(out, y, dither, black, duplicate_line);
else
dither_cmyk(out, y, dither, cyan, lcyan, magenta, lmagenta,
yellow, 0, black, duplicate_line);
QUANT(2);
if (use_softweave)
escp2_write_weave(weave, prn, length, ydpi, model, out_width, left,
xdpi, physical_xdpi,
cyan, magenta, yellow, black, lcyan, lmagenta);
else
escp2_write_microweave(prn, black, cyan, magenta, yellow, lcyan,
lmagenta, length, xdpi, ydpi, model,
out_width, left, bits);
QUANT(3);
errval += errmod;
errline += errdiv;
if (errval >= out_height)
{
errval -= out_height;
errline ++;
}
QUANT(4);
}
Image_progress_conclude(image);
if (use_softweave)
escp2_flush_all(weave, model, out_width, left, ydpi, xdpi, physical_xdpi,
prn);
else
escp2_free_microweave();
QUANT(5);
free_dither(dither);
/*
* Cleanup...
*/
free_lut(&nv);
free(in);
free(out);
if (use_softweave)
destroy_weave(weave);
if (black != NULL)
free(black);
if (cyan != NULL)
{
free(cyan);
free(magenta);
free(yellow);
}
if (lcyan != NULL)
{
free(lcyan);
free(lmagenta);
}
escp2_deinit_printer(prn, &init);
#ifdef QUANTIFY
print_timers();
#endif
}
static void
escp2_fold(const unsigned char *line,
int single_length,
unsigned char *outbuf)
{
int i;
memset(outbuf, 0, single_length * 2);
for (i = 0; i < single_length; i++)
{
unsigned char l0 = line[0];
unsigned char l1 = line[single_length];
if (l0 || l1)
{
outbuf[0] =
((l0 & (1 << 7)) >> 1) +
((l0 & (1 << 6)) >> 2) +
((l0 & (1 << 5)) >> 3) +
((l0 & (1 << 4)) >> 4) +
((l1 & (1 << 7)) >> 0) +
((l1 & (1 << 6)) >> 1) +
((l1 & (1 << 5)) >> 2) +
((l1 & (1 << 4)) >> 3);
outbuf[1] =
((l0 & (1 << 3)) << 3) +
((l0 & (1 << 2)) << 2) +
((l0 & (1 << 1)) << 1) +
((l0 & (1 << 0)) << 0) +
((l1 & (1 << 3)) << 4) +
((l1 & (1 << 2)) << 3) +
((l1 & (1 << 1)) << 2) +
((l1 & (1 << 0)) << 1);
}
line++;
outbuf += 2;
}
}
static void
escp2_split_2_1(int length,
const unsigned char *in,
unsigned char *outhi,
unsigned char *outlo)
{
unsigned char *outs[2];
int i;
int row = 0;
int limit = length * 2;
outs[0] = outhi;
outs[1] = outlo;
memset(outs[1], 0, limit);
for (i = 0; i < limit; i++)
{
unsigned char inbyte = in[i];
outs[0][i] = 0;
if (inbyte == 0)
continue;
/* For some reason gcc isn't unrolling this, even with -funroll-loops */
if (inbyte & 1)
{
outs[row][i] |= 1 & inbyte;
row = row ^ 1;
}
if (inbyte & (1 << 1))
{
outs[row][i] |= (1 << 1) & inbyte;
row = row ^ 1;
}
if (inbyte & (1 << 2))
{
outs[row][i] |= (1 << 2) & inbyte;
row = row ^ 1;
}
if (inbyte & (1 << 3))
{
outs[row][i] |= (1 << 3) & inbyte;
row = row ^ 1;
}
if (inbyte & (1 << 4))
{
outs[row][i] |= (1 << 4) & inbyte;
row = row ^ 1;
}
if (inbyte & (1 << 5))
{
outs[row][i] |= (1 << 5) & inbyte;
row = row ^ 1;
}
if (inbyte & (1 << 6))
{
outs[row][i] |= (1 << 6) & inbyte;
row = row ^ 1;
}
if (inbyte & (1 << 7))
{
outs[row][i] |= (1 << 7) & inbyte;
row = row ^ 1;
}
}
}
static void
escp2_split_2_2(int length,
const unsigned char *in,
unsigned char *outhi,
unsigned char *outlo)
{
unsigned char *outs[2];
int i;
unsigned row = 0;
int limit = length * 2;
outs[0] = outhi;
outs[1] = outlo;
memset(outs[1], 0, limit);
for (i = 0; i < limit; i++)
{
unsigned char inbyte = in[i];
outs[0][i] = 0;
if (inbyte == 0)
continue;
/* For some reason gcc isn't unrolling this, even with -funroll-loops */
if (inbyte & 3)
{
outs[row][i] |= (3 & inbyte);
row = row ^ 1;
}
if (inbyte & (3 << 2))
{
outs[row][i] |= ((3 << 2) & inbyte);
row = row ^ 1;
}
if (inbyte & (3 << 4))
{
outs[row][i] |= ((3 << 4) & inbyte);
row = row ^ 1;
}
if (inbyte & (3 << 6))
{
outs[row][i] |= ((3 << 6) & inbyte);
row = row ^ 1;
}
}
}
static void
escp2_split_2(int length,
int bits,
const unsigned char *in,
unsigned char *outhi,
unsigned char *outlo)
{
if (bits == 2)
escp2_split_2_2(length, in, outhi, outlo);
else
escp2_split_2_1(length, in, outhi, outlo);
}
static void
escp2_split_4_1(int length,
const unsigned char *in,
unsigned char *out0,
unsigned char *out1,
unsigned char *out2,
unsigned char *out3)
{
unsigned char *outs[4];
int i;
int row = 0;
int limit = length * 2;
outs[0] = out0;
outs[1] = out1;
outs[2] = out2;
outs[3] = out3;
memset(outs[1], 0, limit);
memset(outs[2], 0, limit);
memset(outs[3], 0, limit);
for (i = 0; i < limit; i++)
{
unsigned char inbyte = in[i];
outs[0][i] = 0;
if (inbyte == 0)
continue;
/* For some reason gcc isn't unrolling this, even with -funroll-loops */
if (inbyte & 1)
{
outs[row][i] |= 1 & inbyte;
row = (row + 1) & 3;
}
if (inbyte & (1 << 1))
{
outs[row][i] |= (1 << 1) & inbyte;
row = (row + 1) & 3;
}
if (inbyte & (1 << 2))
{
outs[row][i] |= (1 << 2) & inbyte;
row = (row + 1) & 3;
}
if (inbyte & (1 << 3))
{
outs[row][i] |= (1 << 3) & inbyte;
row = (row + 1) & 3;
}
if (inbyte & (1 << 4))
{
outs[row][i] |= (1 << 4) & inbyte;
row = (row + 1) & 3;
}
if (inbyte & (1 << 5))
{
outs[row][i] |= (1 << 5) & inbyte;
row = (row + 1) & 3;
}
if (inbyte & (1 << 6))
{
outs[row][i] |= (1 << 6) & inbyte;
row = (row + 1) & 3;
}
if (inbyte & (1 << 7))
{
outs[row][i] |= (1 << 7) & inbyte;
row = (row + 1) & 3;
}
}
}
static void
escp2_split_4_2(int length,
const unsigned char *in,
unsigned char *out0,
unsigned char *out1,
unsigned char *out2,
unsigned char *out3)
{
unsigned char *outs[4];
int i;
int row = 0;
int limit = length * 2;
outs[0] = out0;
outs[1] = out1;
outs[2] = out2;
outs[3] = out3;
memset(outs[1], 0, limit);
memset(outs[2], 0, limit);
memset(outs[3], 0, limit);
for (i = 0; i < limit; i++)
{
unsigned char inbyte = in[i];
outs[0][i] = 0;
if (inbyte == 0)
continue;
/* For some reason gcc isn't unrolling this, even with -funroll-loops */
if (inbyte & 3)
{
outs[row][i] |= 3 & inbyte;
row = (row + 1) & 3;
}
if (inbyte & (3 << 2))
{
outs[row][i] |= (3 << 2) & inbyte;
row = (row + 1) & 3;
}
if (inbyte & (3 << 4))
{
outs[row][i] |= (3 << 4) & inbyte;
row = (row + 1) & 3;
}
if (inbyte & (3 << 6))
{
outs[row][i] |= (3 << 6) & inbyte;
row = (row + 1) & 3;
}
}
}
static void
escp2_split_4(int length,
int bits,
const unsigned char *in,
unsigned char *out0,
unsigned char *out1,
unsigned char *out2,
unsigned char *out3)
{
if (bits == 2)
escp2_split_4_2(length, in, out0, out1, out2, out3);
else
escp2_split_4_1(length, in, out0, out1, out2, out3);
}
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define SH20 0
#define SH21 8
#else
#define SH20 8
#define SH21 0
#endif
static void
escp2_unpack_2_1(int length,
const unsigned char *in,
unsigned char *out0,
unsigned char *out1)
{
unsigned char tempin,
bit,
temp0,
temp1;
for (bit = 128, temp0 = 0, temp1 = 0;
length > 0;
length --)
{
tempin = *in++;
if (tempin & 128)
temp0 |= bit;
if (tempin & 64)
temp1 |= bit;
bit >>= 1;
if (tempin & 32)
temp0 |= bit;
if (tempin & 16)
temp1 |= bit;
bit >>= 1;
if (tempin & 8)
temp0 |= bit;
if (tempin & 4)
temp1 |= bit;
bit >>= 1;
if (tempin & 2)
temp0 |= bit;
if (tempin & 1)
temp1 |= bit;
if (bit > 1)
bit >>= 1;
else
{
bit = 128;
*out0++ = temp0;
*out1++ = temp1;
temp0 = 0;
temp1 = 0;
}
}
if (bit < 128)
{
*out0++ = temp0;
*out1++ = temp1;
}
}
static void
escp2_unpack_2_2(int length,
const unsigned char *in,
unsigned char *out0,
unsigned char *out1)
{
unsigned char tempin,
shift,
temp0,
temp1;
length *= 2;
for (shift = 0, temp0 = 0, temp1 = 0;
length > 0;
length --)
{
/*
* Note - we can't use (tempin & N) >> (shift - M) since negative
* right-shifts are not always implemented.
*/
tempin = *in++;
if (tempin & 192)
temp0 |= (tempin & 192) >> shift;
if (tempin & 48)
temp1 |= ((tempin & 48) << 2) >> shift;
shift += 2;
if (tempin & 12)
temp0 |= ((tempin & 12) << 4) >> shift;
if (tempin & 3)
temp1 |= ((tempin & 3) << 6) >> shift;
if (shift < 6)
shift += 2;
else
{
shift = 0;
*out0++ = temp0;
*out1++ = temp1;
temp0 = 0;
temp1 = 0;
}
}
if (shift)
{
*out0++ = temp0;
*out1++ = temp1;
}
}
static void
escp2_unpack_2(int length,
int bits,
const unsigned char *in,
unsigned char *outlo,
unsigned char *outhi)
{
if (bits == 1)
escp2_unpack_2_1(length, in, outlo, outhi);
else
escp2_unpack_2_2(length, in, outlo, outhi);
}
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define SH40 0
#define SH41 8
#define SH42 16
#define SH43 24
#else
#define SH40 24
#define SH41 16
#define SH42 8
#define SH43 0
#endif
static void
escp2_unpack_4_1(int length,
const unsigned char *in,
unsigned char *out0,
unsigned char *out1,
unsigned char *out2,
unsigned char *out3)
{
unsigned char tempin,
bit,
temp0,
temp1,
temp2,
temp3;
for (bit = 128, temp0 = 0, temp1 = 0, temp2 = 0, temp3 = 0;
length > 0;
length --)
{
tempin = *in++;
if (tempin & 128)
temp0 |= bit;
if (tempin & 64)
temp1 |= bit;
if (tempin & 32)
temp2 |= bit;
if (tempin & 16)
temp3 |= bit;
bit >>= 1;
if (tempin & 8)
temp0 |= bit;
if (tempin & 4)
temp1 |= bit;
if (tempin & 2)
temp2 |= bit;
if (tempin & 1)
temp3 |= bit;
if (bit > 1)
bit >>= 1;
else
{
bit = 128;
*out0++ = temp0;
*out1++ = temp1;
*out2++ = temp2;
*out3++ = temp3;
temp0 = 0;
temp1 = 0;
temp2 = 0;
temp3 = 0;
}
}
if (bit < 128)
{
*out0++ = temp0;
*out1++ = temp1;
*out2++ = temp2;
*out3++ = temp3;
}
}
static void
escp2_unpack_4_2(int length,
const unsigned char *in,
unsigned char *out0,
unsigned char *out1,
unsigned char *out2,
unsigned char *out3)
{
unsigned char tempin,
shift,
temp0,
temp1,
temp2,
temp3;
length *= 2;
for (shift = 0, temp0 = 0, temp1 = 0, temp2 = 0, temp3 = 0;
length > 0;
length --)
{
/*
* Note - we can't use (tempin & N) >> (shift - M) since negative
* right-shifts are not always implemented.
*/
tempin = *in++;
if (tempin & 192)
temp0 |= (tempin & 192) >> shift;
if (tempin & 48)
temp1 |= ((tempin & 48) << 2) >> shift;
if (tempin & 12)
temp2 |= ((tempin & 12) << 4) >> shift;
if (tempin & 3)
temp3 |= ((tempin & 3) << 6) >> shift;
if (shift < 6)
shift += 2;
else
{
shift = 0;
*out0++ = temp0;
*out1++ = temp1;
*out2++ = temp2;
*out3++ = temp3;
temp0 = 0;
temp1 = 0;
temp2 = 0;
temp3 = 0;
}
}
if (shift)
{
*out0++ = temp0;
*out1++ = temp1;
*out2++ = temp2;
*out3++ = temp3;
}
}
static void
escp2_unpack_4(int length,
int bits,
const unsigned char *in,
unsigned char *out0,
unsigned char *out1,
unsigned char *out2,
unsigned char *out3)
{
if (bits == 1)
escp2_unpack_4_1(length, in, out0, out1, out2, out3);
else
escp2_unpack_4_2(length, in, out0, out1, out2, out3);
}
static void
escp2_unpack_8_1(int length,
const unsigned char *in,
unsigned char *out0,
unsigned char *out1,
unsigned char *out2,
unsigned char *out3,
unsigned char *out4,
unsigned char *out5,
unsigned char *out6,
unsigned char *out7)
{
unsigned char tempin,
bit,
temp0,
temp1,
temp2,
temp3,
temp4,
temp5,
temp6,
temp7;
for (bit = 128, temp0 = 0, temp1 = 0, temp2 = 0,
temp3 = 0, temp4 = 0, temp5 = 0, temp6 = 0, temp7 = 0;
length > 0;
length --)
{
tempin = *in++;
if (tempin & 128)
temp0 |= bit;
if (tempin & 64)
temp1 |= bit;
if (tempin & 32)
temp2 |= bit;
if (tempin & 16)
temp3 |= bit;
if (tempin & 8)
temp4 |= bit;
if (tempin & 4)
temp5 |= bit;
if (tempin & 2)
temp6 |= bit;
if (tempin & 1)
temp7 |= bit;
if (bit > 1)
bit >>= 1;
else
{
bit = 128;
*out0++ = temp0;
*out1++ = temp1;
*out2++ = temp2;
*out3++ = temp3;
*out4++ = temp4;
*out5++ = temp5;
*out6++ = temp6;
*out7++ = temp7;
temp0 = 0;
temp1 = 0;
temp2 = 0;
temp3 = 0;
temp4 = 0;
temp5 = 0;
temp6 = 0;
temp7 = 0;
}
}
if (bit < 128)
{
*out0++ = temp0;
*out1++ = temp1;
*out2++ = temp2;
*out3++ = temp3;
*out4++ = temp4;
*out5++ = temp5;
*out6++ = temp6;
*out7++ = temp7;
}
}
static void
escp2_unpack_8_2(int length,
const unsigned char *in,
unsigned char *out0,
unsigned char *out1,
unsigned char *out2,
unsigned char *out3,
unsigned char *out4,
unsigned char *out5,
unsigned char *out6,
unsigned char *out7)
{
unsigned char tempin,
shift,
temp0,
temp1,
temp2,
temp3,
temp4,
temp5,
temp6,
temp7;
for (shift = 0, temp0 = 0, temp1 = 0,
temp2 = 0, temp3 = 0, temp4 = 0, temp5 = 0, temp6 = 0, temp7 = 0;
length > 0;
length --)
{
/*
* Note - we can't use (tempin & N) >> (shift - M) since negative
* right-shifts are not always implemented.
*/
tempin = *in++;
if (tempin & 192)
temp0 |= (tempin & 192) >> shift;
if (tempin & 48)
temp1 |= ((tempin & 48) << 2) >> shift;
if (tempin & 12)
temp2 |= ((tempin & 12) << 4) >> shift;
if (tempin & 3)
temp3 |= ((tempin & 3) << 6) >> shift;
tempin = *in++;
if (tempin & 192)
temp4 |= (tempin & 192) >> shift;
if (tempin & 48)
temp5 |= ((tempin & 48) << 2) >> shift;
if (tempin & 12)
temp6 |= ((tempin & 12) << 4) >> shift;
if (tempin & 3)
temp7 |= ((tempin & 3) << 6) >> shift;
if (shift < 6)
shift += 2;
else
{
shift = 0;
*out0++ = temp0;
*out1++ = temp1;
*out2++ = temp2;
*out3++ = temp3;
*out4++ = temp4;
*out5++ = temp5;
*out6++ = temp6;
*out7++ = temp7;
temp0 = 0;
temp1 = 0;
temp2 = 0;
temp3 = 0;
temp4 = 0;
temp5 = 0;
temp6 = 0;
temp7 = 0;
}
}
if (shift)
{
*out0++ = temp0;
*out1++ = temp1;
*out2++ = temp2;
*out3++ = temp3;
*out4++ = temp4;
*out5++ = temp5;
*out6++ = temp6;
*out7++ = temp7;
}
}
static void
escp2_unpack_8(int length,
int bits,
const unsigned char *in,
unsigned char *out0,
unsigned char *out1,
unsigned char *out2,
unsigned char *out3,
unsigned char *out4,
unsigned char *out5,
unsigned char *out6,
unsigned char *out7)
{
if (bits == 1)
escp2_unpack_8_1(length, in, out0, out1, out2, out3,
out4, out5, out6, out7);
else
escp2_unpack_8_2(length, in, out0, out1, out2, out3,
out4, out5, out6, out7);
}
static int
escp2_pack(const unsigned char *line,
int length,
unsigned char *comp_buf,
unsigned char **comp_ptr)
{
const unsigned char *start; /* Start of compressed data */
unsigned char repeat; /* Repeating char */
int count; /* Count of compressed bytes */
int tcount; /* Temporary count < 128 */
int active = 0; /* Have we found data? */
/*
* Compress using TIFF "packbits" run-length encoding...
*/
(*comp_ptr) = comp_buf;
while (length > 0)
{
/*
* Get a run of non-repeated chars...
*/
start = line;
line += 2;
length -= 2;
while (length > 0 && (line[-2] != line[-1] || line[-1] != line[0]))
{
if (! active && (line[-2] || line[-1] || line[0]))
active = 1;
line ++;
length --;
}
line -= 2;
length += 2;
/*
* Output the non-repeated sequences (max 128 at a time).
*/
count = line - start;
while (count > 0)
{
tcount = count > 128 ? 128 : count;
(*comp_ptr)[0] = tcount - 1;
memcpy((*comp_ptr) + 1, start, tcount);
(*comp_ptr) += tcount + 1;
start += tcount;
count -= tcount;
}
if (length <= 0)
break;
/*
* Find the repeated sequences...
*/
start = line;
repeat = line[0];
if (repeat)
active = 1;
line ++;
length --;
while (length > 0 && *line == repeat)
{
line ++;
length --;
}
/*
* Output the repeated sequences (max 128 at a time).
*/
count = line - start;
while (count > 0)
{
tcount = count > 128 ? 128 : count;
(*comp_ptr)[0] = 1 - tcount;
(*comp_ptr)[1] = repeat;
(*comp_ptr) += 2;
count -= tcount;
}
}
return active;
}
static unsigned char *microweave_s = 0;
static unsigned char *microweave_comp_ptr[6][4];
static int microweave_setactive[6][4];
static int accumulated_spacing = 0;
static int last_color = -1;
#define MICRO_S(c, l) (microweave_s + COMPBUFWIDTH * (l) + COMPBUFWIDTH * (c) * 4)
static void
escp2_init_microweave(int top)
{
if (!microweave_s)
microweave_s = malloc(6 * 4 * COMPBUFWIDTH);
accumulated_spacing = top;
}
static void
escp2_free_microweave()
{
if (microweave_s)
{
free(microweave_s);
microweave_s = NULL;
}
}
static int
escp2_do_microweave_pack(const unsigned char *line,
int length,
int oversample,
int bits,
int color)
{
static unsigned char *pack_buf = NULL;
static unsigned char *s[4] = { NULL, NULL, NULL, NULL };
const unsigned char *in;
int i;
int retval = 0;
if (!pack_buf)
pack_buf = malloc(COMPBUFWIDTH);
for (i = 0; i < oversample; i++)
{
if (!s[i])
s[i] = malloc(COMPBUFWIDTH);
}
if (!line ||
(line[0] == 0 && memcmp(line, line + 1, (bits * length) - 1) == 0))
{
for (i = 0; i < 4; i++)
microweave_setactive[color][i] = 0;
return 0;
}
if (bits == 1)
in = line;
else
{
escp2_fold(line, length, pack_buf);
in = pack_buf;
}
switch (oversample)
{
case 1:
memcpy(s[0], in, bits * length);
break;
case 2:
escp2_unpack_2(length, bits, in, s[0], s[1]);
break;
case 4:
escp2_unpack_4(length, bits, in, s[0], s[1], s[2], s[3]);
break;
}
for (i = 0; i < oversample; i++)
{
microweave_setactive[color][i] =
escp2_pack(s[i], length * bits, MICRO_S(color, i),
&(microweave_comp_ptr[color][i]));
retval |= microweave_setactive[color][i];
}
return retval;
}
static void
escp2_write_microweave(FILE *prn, /* I - Print file or command */
const unsigned char *k, /* I - Output bitmap data */
const unsigned char *c, /* I - Output bitmap data */
const unsigned char *m, /* I - Output bitmap data */
const unsigned char *y, /* I - Output bitmap data */
const unsigned char *lc, /* I - Output bitmap data */
const unsigned char *lm, /* I - Output bitmap data */
int length, /* I - Length of bitmap data */
int xdpi, /* I - Horizontal resolution */
int ydpi, /* I - Vertical resolution */
int model, /* I - Printer model */
int width, /* I - Printed width */
int offset, /* I - Offset from left side */
int bits)
{
int i, j;
int oversample = 1;
int gsetactive = 0;
if (xdpi > 720)
oversample = xdpi / 720;
gsetactive |= escp2_do_microweave_pack(k, length, oversample, bits, 0);
gsetactive |= escp2_do_microweave_pack(m, length, oversample, bits, 1);
gsetactive |= escp2_do_microweave_pack(c, length, oversample, bits, 2);
gsetactive |= escp2_do_microweave_pack(y, length, oversample, bits, 3);
gsetactive |= escp2_do_microweave_pack(lm, length, oversample, bits, 4);
gsetactive |= escp2_do_microweave_pack(lc, length, oversample, bits, 5);
if (!gsetactive)
{
accumulated_spacing++;
return;
}
for (i = 0; i < oversample; i++)
{
for (j = 0; j < 6; j++)
{
if (!microweave_setactive[j][i])
continue;
if (accumulated_spacing > 0)
fprintf(prn, "\033(v\002%c%c%c", 0, accumulated_spacing % 256,
(accumulated_spacing >> 8) % 256);
accumulated_spacing = 0;
/*
* Set the print head position.
*/
if (escp2_has_cap(model, MODEL_1440DPI_MASK, MODEL_1440DPI_YES) &&
xdpi > 720)
{
if (!escp2_has_cap(model, MODEL_VARIABLE_DOT_MASK,
MODEL_VARIABLE_NORMAL))
{
if (((offset * xdpi / 1440) + i) > 0)
fprintf(prn, "\033($%c%c%c%c%c%c", 4, 0,
((offset * xdpi / 1440) + i) & 255,
(((offset * xdpi / 1440) + i) >> 8) & 255,
(((offset * xdpi / 1440) + i) >> 16) & 255,
(((offset * xdpi / 1440) + i) >> 24) & 255);
}
else
{
if (((offset * 1440 / ydpi) + i) > 0)
fprintf(prn, "\033(\\%c%c%c%c%c%c", 4, 0, 160, 5,
((offset * 1440 / ydpi) + i) & 255,
((offset * 1440 / ydpi) + i) >> 8);
}
}
else
{
if (offset > 0)
fprintf(prn, "\033\\%c%c", offset & 255, offset >> 8);
}
if (j != last_color)
{
if (escp2_has_cap(model, MODEL_6COLOR_MASK, MODEL_6COLOR_YES))
fprintf(prn, "\033(r\002%c%c%c", 0, densities[j], colors[j]);
else
fprintf(prn, "\033r%c", colors[j]);
last_color = j;
}
/*
* Send a line of raster graphics...
*/
switch (ydpi) /* Raster graphics header */
{
case 180 :
fwrite("\033.\001\024\024\001", 6, 1, prn);
break;
case 360 :
fwrite("\033.\001\012\012\001", 6, 1, prn);
break;
case 720 :
if (escp2_has_cap(model, MODEL_720DPI_MODE_MASK,
MODEL_720DPI_600))
fwrite("\033.\001\050\005\001", 6, 1, prn);
else
fwrite("\033.\001\005\005\001", 6, 1, prn);
break;
}
putc(width & 255, prn); /* Width of raster line in pixels */
putc(width >> 8, prn);
fwrite(MICRO_S(j, i), microweave_comp_ptr[j][i] - MICRO_S(j, i),
1, prn);
putc('\r', prn);
}
}
accumulated_spacing++;
}
/*
* "Soft" weave
*
* The Epson Stylus Color/Photo printers don't have memory to print
* using all of the nozzles in the print head. For example, the Stylus Photo
* 700/EX has 32 nozzles. At 720 dpi, with an 8" wide image, a single line
* requires (8 * 720 * 6 / 8) bytes, or 4320 bytes (because the Stylus Photo
* printers have 6 ink colors). To use 32 nozzles would require 138240 bytes.
* It's actually worse than that, though, because the nozzles are spaced 8
* rows apart. Therefore, in order to store enough data to permit sending the
* page as a simple raster, the printer would require enough memory to store
* 256 rows, or 1105920 bytes. Considering that the Photo EX can print
* 11" wide, we're looking at more like 1.5 MB. In fact, these printers are
* capable of 1440 dpi horizontal resolution. This would require 3 MB. The
* printers actually have 64K-256K.
*
* With the newer (740/750 and later) printers it's even worse, since these
* printers support multiple dot sizes. But that's neither here nor there.
*
* Older Epson printers had a mode called MicroWeave (tm). In this mode, the
* host fed the printer individual rows of dots, and the printer bundled them
* up and sent them to the print head in the correct order to achieve high
* quality. This MicroWeave mode still works in new printers, but the
* implementation is very minimal: the printer uses exactly one nozzle of
* each color (the first one). This makes printing extremely slow (more than
* 30 minutes for one 8.5x11" page), although the quality is extremely high
* with no visible banding whatsoever. It's not good for the print head,
* though, since no ink is flowing through the other nozzles. This leads to
* drying of ink and possible permanent damage to the print head.
*
* By the way, although the Epson manual says that microweave mode should be
* used at 720 dpi, 360 dpi continues to work in much the same way. At 360
* dpi, data is fed to the printer one row at a time on all Epson printers.
* The pattern that the printer uses to print is very prone to banding.
* However, 360 dpi is inherently a low quality mode; if you're using it,
* presumably you don't much care about quality.
*
* Printers from roughly the Stylus Color 600 and later do not have the
* capability to do MicroWeave correctly. Instead, the host must arrange
* the output in the order that it will be sent to the print head. This
* is a very complex process; the jets in the print head are spaced more
* than one row (1/720") apart, so we can't simply send consecutive rows
* of dots to the printer. Instead, we have to pass e. g. the first, ninth,
* 17th, 25th... rows in order for them to print in the correct position on
* the paper. This interleaving process is called "soft" weaving.
*
* This decision was probably made to save money on memory in the printer.
* It certainly makes the driver code far more complicated than it would
* be if the printer could arrange the output. Is that a bad thing?
* Usually this takes far less CPU time than the dithering process, and it
* does allow us more control over the printing process, e. g. to reduce
* banding. Conceivably, we could even use this ability to map out bad
* jets.
*
* Interestingly, apparently the Windows (and presumably Macintosh) drivers
* for most or all Epson printers still list a "microweave" mode.
* Experiments have demonstrated that this does not in fact use the
* "microweave" mode of the printer. Possibly it does nothing, or it uses
* a different weave pattern from what the non-"microweave" mode does.
* This is unnecessarily confusing.
*
* What makes this interesting is that there are many different ways of
* of accomplishing this goal. The naive way would be to divide the image
* up into groups of 256 rows, and print all the mod8=0 rows in the first pass,
* mod8=1 rows in the second, and so forth. The problem with this approach
* is that the individual ink jets are not perfectly uniform; some emit
* slightly bigger or smaller drops than others. Since each group of 8
* adjacent rows is printed with the same nozzle, that means that there will
* be distinct streaks of lighter and darker bands within the image (8 rows
* is 1/90", which is visible; 1/720" is not). Possibly worse is that these
* patterns will repeat every 256 rows. This creates banding patterns that
* are about 1/3" wide.
*
* So we have to do something to break up this patterning.
*
* Epson does not publish the weaving algorithms that they use in their
* bundled drivers. Indeed, their developer web site
* (http://www.ercipd.com/isv/edr_docs.htm) does not even describe how to
* do this weaving at all; it says that the only way to achieve 720 dpi
* is to use MicroWeave. It does note (correctly) that 1440 dpi horizontal
* can only be achieved by the driver (i. e. in software). The manual
* actually makes it fairly clear how to do this (it requires two passes
* with horizontal head movement between passes), and it is presumably
* possible to do this with MicroWeave.
*
* The information about how to do this is apparently available under NDA.
* It's actually easy enough to reverse engineer what's inside a print file
* with a simple Perl script. There are presumably other printer commands
* that are not documented and may not be as easy to reverse engineer.
*
* I considered a few algorithms to perform the weave. The first one I
* devised let me use only (jets - distance_between_jets + 1) nozzles, or
* 25. This is OK in principle, but it's slower than using all nozzles.
* By playing around with it some more, I came up with an algorithm that
* lets me use all of the nozzles, except near the top and bottom of the
* page.
*
* This still produces some banding, though. Even better quality can be
* achieved by using multiple nozzles on the same line. How do we do this?
* In 1440x720 mode, we're printing two output lines at the same vertical
* position. However, if we want four passes, we have to effectively print
* each line twice. Actually doing this would increase the density, so
* what we do is print half the dots on each pass. This produces near-perfect
* output, and it's far faster than using (pseudo) "MicroWeave".
*
* The current algorithm is not completely general. The number of passes
* is limited to (nozzles / gap). On the Photo EX class printers, that limits
* it to 4 -- 32 nozzles, an inter-nozzle gap of 8 lines. Furthermore, there
* are a number of routines that are only coded up to 8 passes. Fortunately,
* this is enough passes to get rid of most banding. What's left is a very
* fine pattern that is sometimes described as "corduroy", since the pattern
* looks like that kind of fabric.
*
* Newer printers (those that support variable dot sizes, such as the 740,
* 1200, etc.) have an additional complication: when used in softweave mode,
* they operate at 360 dpi horizontal resolution. This requires FOUR passes
* to achieve 1440x720 dpi. Thus, to enable us to break up each row
* into separate sub-rows, we have to actually print each row eight times.
* Fortunately, all such printers have 48 nozzles and a gap of 6 rows,
* except for the high-speed 900, which uses 96 nozzles and a gap of 2 rows.
*
* I cannot let this entirely pass without commenting on the Stylus Color 440.
* This is a very low-end printer with 21 (!) nozzles and a separation of 8.
* The weave routine works correctly with single-pass printing, which is enough
* to minimally achieve 720 dpi output (it's physically a 720 dpi printer).
* However, the routine does not work correctly at more than one pass per row.
* Therefore, this printer bands badly.
*
* Yet another complication is how to get near the top and bottom of the page.
* This algorithm lets us print to within one head width of the top of the
* page, and a bit more than one head width from the bottom. That leaves a
* lot of blank space. Doing the weave properly outside of this region is
* increasingly difficult as we get closer to the edge of the paper; in the
* interior region, any nozzle can print any line, but near the top and
* bottom edges, only some nozzles can print. We've handled this for now by
* using the naive way mentioned above near the borders, and switching over
* to the high quality method in the interior. Unfortunately, this means
* that the quality is quite visibly degraded near the top and bottom of the
* page. Algorithms that degrade more gracefully are more complicated.
* Epson does not advertise that the printers can print at the very top of the
* page, although in practice most or all of them can. I suspect that the
* quality that can be achieved very close to the top is poor enough that
* Epson does not want to allow printing there. That is a valid decision,
* although we have taken another approach.
*
* To compute the weave information, we need to start with the following
* information:
*
* 1) The number of jets the print head has for each color;
*
* 2) The separation in rows between the jets;
*
* 3) The horizontal resolution of the printer;
*
* 4) The desired horizontal resolution of the output;
*
* 5) The desired extra passes to reduce banding.
*
* As discussed above, each row is actually printed in one or more passes
* of the print head; we refer to these as subpasses. For example, if we're
* printing at 1440(h)x720(v) on a printer with true horizontal resolution of
* 360 dpi, and we wish to print each line twice with different nozzles
* to reduce banding, we need to use 8 subpasses. The dither routine
* will feed us a complete row of bits for each color; we have to split that
* up, first by round robining the bits to ensure that they get printed at
* the right micro-position, and then to split up the bits that are actually
* turned on into two equal chunks to reduce banding.
*
* Given the above information, and the desired row index and subpass (which
* together form a line number), we can compute:
*
* 1) Which pass this line belongs to. Passes are numbered consecutively,
* and each pass must logically (see #3 below) start at no smaller a row
* number than the previous pass, as the printer cannot advance by a
* negative amount.
*
* 2) Which jet will print this line.
*
* 3) The "logical" first line of this pass. That is, what line would be
* printed by jet 0 in this pass. This number may be less than zero.
* If it is, there are ghost lines that don't actually contain any data.
* The difference between the logical first line of this pass and the
* logical first line of the preceding pass tells us how many lines must
* be advanced.
*
* 4) The "physical" first line of this pass. That is, the first line index
* that is actually printed in this pass. This information lets us know
* when we must prepare this pass.
*
* 5) The last line of this pass. This lets us know when we must actually
* send this pass to the printer.
*
* 6) The number of ghost rows this pass contains. We must still send the
* ghost data to the printer, so this lets us know how much data we must
* fill in prior to the start of the pass.
*
* The bookkeeping to keep track of all this stuff is quite hairy, and needs
* to be documented separately.
*
* The routine initialize_weave calculates the basic parameters, given
* the number of jets and separation between jets, in rows.
*
* -- Robert Krawitz <rlk@alum.mit.edu) November 3, 1999
*/
#endif /* !WEAVETEST */
typedef struct /* Weave parameters for a specific row */
{
int row; /* Absolute row # */
int pass; /* Computed pass # */
int jet; /* Which physical nozzle we're using */
int missingstartrows; /* Phantom rows (nonexistent rows that */
/* would be printed by nozzles lower than */
/* the first nozzle we're using this pass; */
/* with the current algorithm, always zero */
int logicalpassstart; /* Offset in rows (from start of image) */
/* that the printer must be for this row */
/* to print correctly with the specified jet */
int physpassstart; /* Offset in rows to the first row printed */
/* in this pass. Currently always equal to */
/* logicalpassstart */
int physpassend; /* Offset in rows (from start of image) to */
/* the last row that will be printed this */
/* pass (assuming that we're printing a full */
/* pass). */
} weave_t;
typedef struct /* Weave parameters for a specific pass */
{
int pass; /* Absolute pass number */
int missingstartrows; /* All other values the same as weave_t */
int logicalpassstart;
int physpassstart;
int physpassend;
int subpass;
} pass_t;
typedef union { /* Offsets from the start of each line */
unsigned long v[6]; /* (really pass) */
struct {
unsigned long k;
unsigned long m;
unsigned long c;
unsigned long y;
unsigned long M;
unsigned long C;
} p;
} lineoff_t;
typedef union { /* Is this line active? */
char v[6]; /* (really pass) */
struct {
char k;
char m;
char c;
char y;
char M;
char C;
} p;
} lineactive_t;
typedef union { /* Base pointers for each pass */
unsigned char *v[6];
struct {
unsigned char *k;
unsigned char *m;
unsigned char *c;
unsigned char *y;
unsigned char *M;
unsigned char *C;
} p;
} linebufs_t;
typedef struct {
linebufs_t *linebases; /* Base address of each row buffer */
lineoff_t *lineoffsets; /* Offsets within each row buffer */
lineactive_t *lineactive; /* Does this line have anything printed? */
int *linecounts; /* How many rows we've printed this pass */
pass_t *passes; /* Circular list of pass numbers */
int last_pass_offset; /* Starting row (offset from the start of */
/* the page) of the most recently printed */
/* pass (so we can determine how far to */
/* advance the paper) */
int last_pass; /* Number of the most recently printed pass */
int jets; /* Number of jets per color */
int separation; /* Offset from one jet to the next in rows */
void *weaveparm; /* Weave calculation parameter block */
int horizontal_weave; /* Number of horizontal passes required */
/* This is > 1 for some of the ultra-high */
/* resolution modes */
int vertical_subpasses; /* Number of passes per line (for better */
/* quality) */
int vmod; /* Number of banks of passes */
int oversample; /* Excess precision per row */
int ncolors; /* How many colors (1, 4, or 6) */
int horizontal_width; /* Line width in output pixels */
int vertical_height; /* Image height in output pixels */
int firstline; /* Actual first line (referenced to paper) */
int bitwidth; /* Bits per pixel */
int lineno;
int vertical_oversample; /* Vertical oversampling */
int current_vertical_subpass;
int separation_rows; /* Vertical spacing between rows. */
/* This is used for the 1520/3000, which */
/* use a funny value for the "print density */
/* in the vertical direction". */
int last_color;
} escp2_softweave_t;
#ifndef WEAVETEST
static inline int
get_color_by_params(int plane, int density)
{
if (plane > 4 || plane < 0 || density > 1 || density < 0)
return -1;
return color_indices[density * 8 + plane];
}
#endif
/*
* Initialize the weave parameters
*
* Rules:
*
* 1) Currently, osample * v_subpasses * v_subsample <= 8, and no one
* of these variables may exceed 4.
*
* 2) first_line >= 0
*
* 3) line_height < physlines
*
* 4) phys_lines >= 2 * jets * sep
*/
static void *
initialize_weave(int jets, /* Width of print head */
int sep, /* Separation in rows between jets */
int osample, /* Horizontal oversample */
int v_subpasses, /* Vertical passes */
int v_subsample, /* Vertical oversampling */
colormode_t colormode, /* mono, 4 color, 6 color */
int width, /* bits/pixel */
int linewidth, /* Width of a line, in pixels */
int lineheight, /* Number of lines that will be printed */
int separation_rows, /* Vertical spacing adjustment */
/* for weird printers (1520/3000, */
/* although they don't seem to do softweave */
/* anyway) */
int first_line, /* First line that will be printed on page */
int phys_lines, /* Total height of the page in rows */
int weave_strategy) /* Which weaving pattern to use */
{
int i;
escp2_softweave_t *sw = malloc(sizeof (escp2_softweave_t));
if (sw == 0)
return sw;
if (jets < 1)
jets = 1;
if (jets == 1 || sep < 1)
sep = 1;
if (v_subpasses < 1)
v_subpasses = 1;
sw->separation = sep;
sw->jets = jets;
sw->horizontal_weave = osample;
sw->vertical_oversample = v_subsample;
sw->vertical_subpasses = v_subpasses;
sw->oversample = osample * v_subpasses * v_subsample;
sw->firstline = first_line;
sw->lineno = first_line;
if (sw->oversample > jets) {
fprintf(stderr, "Weave error: oversample (%d) > jets (%d)\n",
sw->oversample, jets);
free(sw);
return 0;
}
sw->weaveparm = initialize_weave_params(sw->separation, sw->jets,
sw->oversample, first_line,
first_line + lineheight - 1,
phys_lines, weave_strategy);
/*
* The value of vmod limits how many passes may be unfinished at a time.
* If pass x is not yet printed, pass x+vmod cannot be started.
*/
sw->vmod = 2 * sw->separation * sw->oversample;
sw->separation_rows = separation_rows;
sw->bitwidth = width;
sw->last_pass_offset = 0;
sw->last_pass = -1;
sw->current_vertical_subpass = 0;
sw->last_color = -1;
switch (colormode)
{
case COLOR_MONOCHROME:
sw->ncolors = 1;
break;
case COLOR_CMYK:
sw->ncolors = 4;
break;
case COLOR_CCMMYK:
default:
sw->ncolors = 6;
break;
}
/*
* It's possible for the "compression" to actually expand the line by
* one part in 128.
*/
sw->horizontal_width = (linewidth + 128 + 7) * 129 / 128;
sw->vertical_height = lineheight;
sw->lineoffsets = malloc(sw->vmod * sizeof(lineoff_t));
memset(sw->lineoffsets, 0, sw->vmod * sizeof(lineoff_t));
sw->lineactive = malloc(sw->vmod * sizeof(lineactive_t));
sw->linebases = malloc(sw->vmod * sizeof(linebufs_t));
sw->passes = malloc(sw->vmod * sizeof(pass_t));
sw->linecounts = malloc(sw->vmod * sizeof(int));
memset(sw->linecounts, 0, sw->vmod * sizeof(int));
for (i = 0; i < sw->vmod; i++)
{
int j;
sw->passes[i].pass = -1;
for (j = 0; j < sw->ncolors; j++)
{
sw->linebases[i].v[j] =
malloc(jets * sw->bitwidth * sw->horizontal_width / 8);
}
}
return (void *) sw;
}
static void
destroy_weave(void *vsw)
{
int i, j;
escp2_softweave_t *sw = (escp2_softweave_t *) vsw;
free(sw->linecounts);
free(sw->passes);
free(sw->lineactive);
free(sw->lineoffsets);
for (i = 0; i < sw->vmod; i++)
{
for (j = 0; j < sw->ncolors; j++)
{
free(sw->linebases[i].v[j]);
}
}
free(sw->linebases);
destroy_weave_params(sw->weaveparm);
free(vsw);
}
static void
weave_parameters_by_row(const escp2_softweave_t *sw, int row,
int vertical_subpass, weave_t *w)
{
static const escp2_softweave_t *scache = 0;
static weave_t wcache;
static int rcache = -2;
static int vcache = -2;
int jetsused;
if (scache == sw && rcache == row && vcache == vertical_subpass)
{
memcpy(w, &wcache, sizeof(weave_t));
return;
}
scache = sw;
rcache = row;
vcache = vertical_subpass;
w->row = row;
calculate_row_parameters(sw->weaveparm, row, vertical_subpass,
&w->pass, &w->jet, &w->logicalpassstart,
&w->missingstartrows, &jetsused);
w->physpassstart = w->logicalpassstart + sw->separation * w->missingstartrows;
w->physpassend = w->physpassstart + sw->separation * (jetsused - 1);
memcpy(&wcache, w, sizeof(weave_t));
#if 0
printf("row %d, jet %d of pass %d "
"(pos %d, start %d, end %d, missing rows %d\n",
w->row, w->jet, w->pass, w->logicalpassstart, w->physpassstart,
w->physpassend, w->missingstartrows);
#endif
}
#ifndef WEAVETEST
static lineoff_t *
get_lineoffsets(const escp2_softweave_t *sw, int row, int subpass)
{
weave_t w;
weave_parameters_by_row(sw, row, subpass, &w);
return &(sw->lineoffsets[w.pass % sw->vmod]);
}
static lineactive_t *
get_lineactive(const escp2_softweave_t *sw, int row, int subpass)
{
weave_t w;
weave_parameters_by_row(sw, row, subpass, &w);
return &(sw->lineactive[w.pass % sw->vmod]);
}
static int *
get_linecount(const escp2_softweave_t *sw, int row, int subpass)
{
weave_t w;
weave_parameters_by_row(sw, row, subpass, &w);
return &(sw->linecounts[w.pass % sw->vmod]);
}
static const linebufs_t *
get_linebases(const escp2_softweave_t *sw, int row, int subpass)
{
weave_t w;
weave_parameters_by_row(sw, row, subpass, &w);
return &(sw->linebases[w.pass % sw->vmod]);
}
static pass_t *
get_pass_by_row(const escp2_softweave_t *sw, int row, int subpass)
{
weave_t w;
weave_parameters_by_row(sw, row, subpass, &w);
return &(sw->passes[w.pass % sw->vmod]);
}
static lineoff_t *
get_lineoffsets_by_pass(const escp2_softweave_t *sw, int pass)
{
return &(sw->lineoffsets[pass % sw->vmod]);
}
static lineactive_t *
get_lineactive_by_pass(const escp2_softweave_t *sw, int pass)
{
return &(sw->lineactive[pass % sw->vmod]);
}
static int *
get_linecount_by_pass(const escp2_softweave_t *sw, int pass)
{
return &(sw->linecounts[pass % sw->vmod]);
}
static const linebufs_t *
get_linebases_by_pass(const escp2_softweave_t *sw, int pass)
{
return &(sw->linebases[pass % sw->vmod]);
}
static pass_t *
get_pass_by_pass(const escp2_softweave_t *sw, int pass)
{
return &(sw->passes[pass % sw->vmod]);
}
/*
* If there are phantom rows at the beginning of a pass, fill them in so
* that the printer knows exactly what it doesn't have to print. We're
* using RLE compression here. Each line must be specified independently,
* so we have to compute how many full blocks (groups of 128 bytes, or 1024
* "off" pixels) and how much leftover is needed. Note that we can only
* RLE-encode groups of 2 or more bytes; single bytes must be specified
* with a count of 1.
*/
static void
fillin_start_rows(const escp2_softweave_t *sw, int row, int subpass,
int width, int missingstartrows)
{
lineoff_t *offsets = get_lineoffsets(sw, row, subpass);
const linebufs_t *bufs = get_linebases(sw, row, subpass);
int i = 0;
int k = 0;
int j;
width = sw->bitwidth * width * 8;
for (k = 0; k < missingstartrows; k++)
{
int bytes_to_fill = width;
int full_blocks = bytes_to_fill / (128 * 8);
int leftover = (7 + (bytes_to_fill % (128 * 8))) / 8;
int l = 0;
while (l < full_blocks)
{
for (j = 0; j < sw->ncolors; j++)
{
(bufs[0].v[j][2 * i]) = 129;
(bufs[0].v[j][2 * i + 1]) = 0;
}
i++;
l++;
}
if (leftover == 1)
{
for (j = 0; j < sw->ncolors; j++)
{
(bufs[0].v[j][2 * i]) = 1;
(bufs[0].v[j][2 * i + 1]) = 0;
}
i++;
}
else if (leftover > 0)
{
for (j = 0; j < sw->ncolors; j++)
{
(bufs[0].v[j][2 * i]) = 257 - leftover;
(bufs[0].v[j][2 * i + 1]) = 0;
}
i++;
}
}
for (j = 0; j < sw->ncolors; j++)
offsets[0].v[j] = 2 * i;
}
static void
initialize_row(const escp2_softweave_t *sw, int row, int width)
{
weave_t w;
int i;
for (i = 0; i < sw->oversample; i++)
{
weave_parameters_by_row(sw, row, i, &w);
if (w.physpassstart == row)
{
lineoff_t *lineoffs = get_lineoffsets(sw, row, i);
lineactive_t *lineactive = get_lineactive(sw, row, i);
int *linecount = get_linecount(sw, row, i);
int j;
pass_t *pass = get_pass_by_row(sw, row, i);
pass->pass = w.pass;
pass->missingstartrows = w.missingstartrows;
pass->logicalpassstart = w.logicalpassstart;
pass->physpassstart = w.physpassstart;
pass->physpassend = w.physpassend;
pass->subpass = i;
for (j = 0; j < sw->ncolors; j++)
{
if (lineoffs[0].v[j] != 0)
fprintf(stderr,
"WARNING: pass %d subpass %d row %d: lineoffs %ld\n",
w.pass, i, row, lineoffs[0].v[j]);
lineoffs[0].v[j] = 0;
lineactive[0].v[j] = 0;
}
if (*linecount != 0)
fprintf(stderr,
"WARNING: pass %d subpass %d row %d: linecount %d\n",
w.pass, i, row, *linecount);
*linecount = 0;
if (w.missingstartrows > 0)
fillin_start_rows(sw, row, i, width, w.missingstartrows);
}
}
}
/*
* A fair bit of this code is duplicated from escp2_write. That's rather
* a pity. It's also not correct for any but the 6-color printers. One of
* these days I'll unify it.
*/
static void
flush_pass(escp2_softweave_t *sw, int passno, int model, int width,
int hoffset, int ydpi, int xdpi, int physical_xdpi,
FILE *prn, int vertical_subpass)
{
int j;
lineoff_t *lineoffs = get_lineoffsets_by_pass(sw, passno);
lineactive_t *lineactive = get_lineactive_by_pass(sw, passno);
const linebufs_t *bufs = get_linebases_by_pass(sw, passno);
pass_t *pass = get_pass_by_pass(sw, passno);
int *linecount = get_linecount_by_pass(sw, passno);
int lwidth = (width + (sw->horizontal_weave - 1)) / sw->horizontal_weave;
int microoffset = vertical_subpass & (sw->horizontal_weave - 1);
if (ydpi > 720)
ydpi = 720;
for (j = 0; j < sw->ncolors; j++)
{
if (lineactive[0].v[j] == 0)
{
lineoffs[0].v[j] = 0;
continue;
}
if (pass->logicalpassstart > sw->last_pass_offset)
{
int advance = pass->logicalpassstart - sw->last_pass_offset -
(sw->separation_rows - 1);
int alo = advance % 256;
int ahi = advance / 256;
if (!escp2_has_cap(model, MODEL_VARIABLE_DOT_MASK,
MODEL_VARIABLE_NORMAL))
{
int a3 = (advance >> 16) % 256;
int a4 = (advance >> 24) % 256;
ahi = ahi % 256;
fprintf(prn, "\033(v\004%c%c%c%c%c", 0, alo, ahi, a3, a4);
}
else
fprintf(prn, "\033(v\002%c%c%c", 0, alo, ahi);
sw->last_pass_offset = pass->logicalpassstart;
}
if (last_color != j)
{
if (!escp2_has_cap(model, MODEL_VARIABLE_DOT_MASK,
MODEL_VARIABLE_NORMAL))
;
else if (escp2_has_cap(model, MODEL_6COLOR_MASK, MODEL_6COLOR_YES))
fprintf(prn, "\033(r\002%c%c%c", 0, densities[j], colors[j]);
else
fprintf(prn, "\033r%c", colors[j]);
last_color = j;
}
if (escp2_has_cap(model, MODEL_1440DPI_MASK, MODEL_1440DPI_YES))
{
/* FIXME need a more general way of specifying column */
/* separation */
if (escp2_has_cap(model, MODEL_COMMAND_MASK, MODEL_COMMAND_1999) &&
!(escp2_has_cap(model, MODEL_VARIABLE_DOT_MASK,
MODEL_VARIABLE_NORMAL)))
{
int pos = ((hoffset * xdpi / ydpi) + microoffset);
if (pos > 0)
fprintf(prn, "\033($%c%c%c%c%c%c", 4, 0,
pos & 255, (pos >> 8) & 255,
(pos >> 16) & 255, (pos >> 24) & 255);
}
else
{
int pos = ((hoffset * 1440 / ydpi) + microoffset);
if (pos > 0)
fprintf(prn, "\033(\\%c%c%c%c%c%c", 4, 0, 160, 5,
pos & 255, pos >> 8);
}
}
else
{
int pos = (hoffset + microoffset);
if (pos > 0)
fprintf(prn, "\033\\%c%c", pos & 255, pos >> 8);
}
if (!escp2_has_cap(model, MODEL_VARIABLE_DOT_MASK,
MODEL_VARIABLE_NORMAL))
{
int ncolor = (densities[j] << 4) | colors[j];
int nlines = *linecount + pass->missingstartrows;
int nwidth = sw->bitwidth * ((lwidth + 7) / 8);
fprintf(prn, "\033i%c%c%c%c%c%c%c", ncolor, 1, sw->bitwidth,
nwidth & 255, nwidth >> 8, nlines & 255, nlines >> 8);
}
else
{
int ydotsep = 3600 / ydpi;
int xdotsep = 3600 / physical_xdpi;
if (escp2_has_cap(model, MODEL_720DPI_MODE_MASK,
MODEL_720DPI_600))
fprintf(prn, "\033.%c%c%c%c", 1, 8 * ydotsep, xdotsep,
*linecount + pass->missingstartrows);
else if (escp2_pseudo_separation_rows(model) > 0)
fprintf(prn, "\033.%c%c%c%c", 1,
ydotsep * escp2_pseudo_separation_rows(model) , xdotsep,
*linecount + pass->missingstartrows);
else
fprintf(prn, "\033.%c%c%c%c", 1, ydotsep * sw->separation_rows,
xdotsep, *linecount + pass->missingstartrows);
putc(lwidth & 255, prn); /* Width of raster line in pixels */
putc(lwidth >> 8, prn);
}
fwrite(bufs[0].v[j], lineoffs[0].v[j], 1, prn);
lineoffs[0].v[j] = 0;
putc('\r', prn);
}
*linecount = 0;
sw->last_pass = pass->pass;
pass->pass = -1;
}
static void
add_to_row(escp2_softweave_t *sw, int row, unsigned char *buf, size_t nbytes,
int plane, int density, int setactive,
lineoff_t *lineoffs, lineactive_t *lineactive,
const linebufs_t *bufs)
{
int color = get_color_by_params(plane, density);
memcpy(bufs[0].v[color] + lineoffs[0].v[color], buf, nbytes);
lineoffs[0].v[color] += nbytes;
if (setactive)
lineactive[0].v[color] = 1;
}
static void
escp2_flush(void *vsw, int model, int width, int hoffset,
int ydpi, int xdpi, int physical_xdpi, FILE *prn)
{
escp2_softweave_t *sw = (escp2_softweave_t *) vsw;
while (1)
{
pass_t *pass = get_pass_by_pass(sw, sw->last_pass + 1);
/*
* This ought to be pass->physpassend > sw->lineno
* but that causes rubbish to be output for some reason.
*/
if (pass->pass < 0 || pass->physpassend >= sw->lineno)
return;
flush_pass(sw, pass->pass, model, width, hoffset, ydpi, xdpi,
physical_xdpi, prn, pass->subpass);
}
}
static void
escp2_flush_all(void *vsw, int model, int width, int hoffset,
int ydpi, int xdpi, int physical_xdpi, FILE *prn)
{
escp2_softweave_t *sw = (escp2_softweave_t *) vsw;
while (1)
{
pass_t *pass = get_pass_by_pass(sw, sw->last_pass + 1);
/*
* This ought to be pass->physpassend > sw->lineno
* but that causes rubbish to be output for some reason.
*/
if (pass->pass < 0)
return;
flush_pass(sw, pass->pass, model, width, hoffset, ydpi, xdpi,
physical_xdpi, prn, pass->subpass);
}
}
static void
finalize_row(escp2_softweave_t *sw, int row, int model, int width,
int hoffset, int ydpi, int xdpi, int physical_xdpi,
FILE *prn)
{
int i;
#if 0
printf("Finalizing row %d...\n", row);
#endif
for (i = 0; i < sw->oversample; i++)
{
weave_t w;
int *lines = get_linecount(sw, row, i);
weave_parameters_by_row(sw, row, i, &w);
(*lines)++;
if (w.physpassend == row)
{
#if 0
printf("Pass=%d, physpassend=%d, row=%d, lineno=%d, trying to flush...\n", w.pass, w.physpassend, row, sw->lineno);
#endif
escp2_flush(sw, model, width, hoffset, ydpi, xdpi, physical_xdpi, prn);
}
}
}
static void
escp2_write_weave(void * vsw,
FILE *prn, /* I - Print file or command */
int length, /* I - Length of bitmap data */
int ydpi, /* I - Vertical resolution */
int model, /* I - Printer model */
int width, /* I - Printed width */
int offset, /* I - Offset from left side of page */
int xdpi,
int physical_xdpi,
const unsigned char *c,
const unsigned char *m,
const unsigned char *y,
const unsigned char *k,
const unsigned char *C,
const unsigned char *M)
{
escp2_softweave_t *sw = (escp2_softweave_t *) vsw;
static unsigned char *s[8];
static unsigned char *fold_buf;
static unsigned char *comp_buf;
lineoff_t *lineoffs[8];
lineactive_t *lineactives[8];
const linebufs_t *bufs[8];
int xlength = (length + sw->horizontal_weave - 1) / sw->horizontal_weave;
unsigned char *comp_ptr;
int i, j;
int setactive;
int h_passes = sw->horizontal_weave * sw->vertical_subpasses;
const unsigned char *cols[6];
cols[0] = k;
cols[1] = m;
cols[2] = c;
cols[3] = y;
cols[4] = M;
cols[5] = C;
if (!fold_buf)
fold_buf = malloc(COMPBUFWIDTH);
if (!comp_buf)
comp_buf = malloc(COMPBUFWIDTH);
if (sw->current_vertical_subpass == 0)
initialize_row(sw, sw->lineno, xlength);
for (i = 0; i < h_passes; i++)
{
int cpass = sw->current_vertical_subpass * h_passes;
if (!s[i])
s[i] = malloc(COMPBUFWIDTH);
lineoffs[i] = get_lineoffsets(sw, sw->lineno, cpass + i);
lineactives[i] = get_lineactive(sw, sw->lineno, cpass + i);
bufs[i] = get_linebases(sw, sw->lineno, cpass + i);
}
for (j = 0; j < sw->ncolors; j++)
{
if (cols[j])
{
const unsigned char *in;
if (sw->bitwidth == 2)
{
escp2_fold(cols[j], length, fold_buf);
in = fold_buf;
}
else
in = cols[j];
if (h_passes > 1)
{
switch (sw->horizontal_weave)
{
case 2:
escp2_unpack_2(length, sw->bitwidth, in, s[0], s[1]);
break;
case 4:
escp2_unpack_4(length, sw->bitwidth, in,
s[0], s[1], s[2], s[3]);
break;
case 8:
escp2_unpack_8(length, sw->bitwidth, in,
s[0], s[1], s[2], s[3],
s[4], s[5], s[6], s[7]);
break;
}
switch (sw->vertical_subpasses)
{
case 4:
switch (sw->horizontal_weave)
{
case 1:
escp2_split_4(length, sw->bitwidth, in,
s[0], s[1], s[2], s[3]);
break;
case 2:
escp2_split_4(length, sw->bitwidth, s[0],
s[0], s[2], s[4], s[6]);
escp2_split_4(length, sw->bitwidth, s[1],
s[1], s[3], s[5], s[7]);
break;
}
break;
case 2:
switch (sw->horizontal_weave)
{
case 1:
escp2_split_2(xlength, sw->bitwidth, in, s[0], s[1]);
break;
case 2:
escp2_split_2(xlength, sw->bitwidth, s[0], s[0], s[2]);
escp2_split_2(xlength, sw->bitwidth, s[1], s[1], s[3]);
break;
case 4:
escp2_split_2(xlength, sw->bitwidth, s[0], s[0], s[4]);
escp2_split_2(xlength, sw->bitwidth, s[1], s[1], s[5]);
escp2_split_2(xlength, sw->bitwidth, s[2], s[2], s[6]);
escp2_split_2(xlength, sw->bitwidth, s[3], s[3], s[7]);
break;
}
break;
/* case 1 is taken care of because the various unpack */
/* functions will do the trick themselves */
}
for (i = 0; i < h_passes; i++)
{
setactive = escp2_pack(s[i], sw->bitwidth * xlength,
comp_buf, &comp_ptr);
add_to_row(sw, sw->lineno, comp_buf, comp_ptr - comp_buf,
colors[j], densities[j], setactive,
lineoffs[i], lineactives[i], bufs[i]);
}
}
else
{
setactive = escp2_pack(in, length * sw->bitwidth,
comp_buf, &comp_ptr);
add_to_row(sw, sw->lineno, comp_buf, comp_ptr - comp_buf,
colors[j], densities[j], setactive,
lineoffs[0], lineactives[0], bufs[0]);
}
}
}
sw->current_vertical_subpass++;
if (sw->current_vertical_subpass >= sw->vertical_oversample)
{
finalize_row(sw, sw->lineno, model, width, offset, ydpi, xdpi,
physical_xdpi, prn);
sw->lineno++;
sw->current_vertical_subpass = 0;
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink