/* Print one page in 24-bit RLE direct color format. */
static int
miff24_print_page(gx_device_printer * pdev, FILE * file)
{
int raster = gx_device_raster((gx_device *) pdev, true);
byte *line = gs_alloc_bytes(pdev->memory, raster, "miff line buffer");
int y;
int code = 0; /* return code */
if (line == 0) /* can't allocate line buffer */
return_error(gs_error_VMerror);
fputs("id=ImageMagick\n", file);
fputs("class=DirectClass\n", file);
fprintf(file, "columns=%d\n", pdev->width);
fputs("compression=RunlengthEncoded\n", file);
fprintf(file, "rows=%d\n", pdev->height);
fputs(":\n", file);
for (y = 0; y < pdev->height; ++y) {
byte *row;
byte *end;
code = gdev_prn_get_bits(pdev, y, line, &row);
if (code < 0)
break;
end = row + pdev->width * 3;
while (row < end) {
int count = 0;
while (count < 255 && row < end - 3 &&
row[0] == row[3] && row[1] == row[4] &&
row[2] == row[5]
)
++count, row += 3;
putc(row[0], file);
putc(row[1], file);
putc(row[2], file);
putc(count, file);
row += 3;
}
}
gs_free_object(pdev->memory, line, "miff line buffer");
return code;
}
/* Send the page to the printer. */
static int
atx_print_page(gx_device_printer *pdev, FILE *f, int max_width_bytes)
{
/*
* The page length command uses 16 bits to represent the length in
* units of 0.01", so the maximum representable page length is
* 655.35", including the unprintable top and bottom margins.
* Compute the maximum height of the printable area in pixels.
*/
float top_bottom_skip = (pdev->HWMargins[1] + pdev->HWMargins[3]) / 72.0;
int max_height = (int)(pdev->HWResolution[1] * 655 - top_bottom_skip);
int height = min(pdev->height, max_height);
int page_length_100ths =
(int)ceil((height / pdev->HWResolution[1] + top_bottom_skip) * 100);
gs_memory_t *mem = pdev->memory;
int raster = gx_device_raster((gx_device *)pdev, true);
byte *buf;
/*
* ATX_COMPRESSED_DATA only takes a 1-byte (word) count.
* Thus no compressed scan line can take more than 510 bytes.
*/
int compressed_raster = min(raster / 2, 510); /* require 50% compression */
byte *compressed;
int blank_lines, lnum;
int code = 0;
/* Enforce a minimum 3" page length. */
if (page_length_100ths < 300)
page_length_100ths = 300;
buf = gs_alloc_bytes(mem, raster, "atx_print_page(buf)");
compressed = gs_alloc_bytes(mem, compressed_raster,
"atx_print_page(compressed)");
if (buf == 0 || compressed == 0) {
code = gs_note_error(gs_error_VMerror);
goto done;
}
fput_atx_command(f, ATX_SET_PAGE_LENGTH, page_length_100ths);
for (blank_lines = 0, lnum = 0; lnum < height; ++lnum) {
byte *row;
byte *end;
int count;
gdev_prn_get_bits(pdev, lnum, buf, &row);
/* Find the end of the non-blank data. */
for (end = row + raster; end > row && end[-1] == 0 && end[-2] == 0; )
end -= 2;
if (end == row) { /* blank line */
++blank_lines;
continue;
}
if (blank_lines) { /* skip vertically */
fput_atx_command(f, ATX_VERTICAL_TAB, blank_lines + 1);
blank_lines = 0;
}
/* Truncate the line to the maximum printable width. */
if (end - row > max_width_bytes)
end = row + max_width_bytes;
count = atx_compress(row, end - row, compressed, compressed_raster);
if (count >= 0) { /* compressed line */
/*
* Note that since compressed_raster can't exceed 510, count
* can't exceed 510 either.
*/
fputs(ATX_COMPRESSED_DATA, f);
fputc(count / 2, f);
fwrite(compressed, 1, count, f);
} else { /* uncompressed line */
int num_bytes = end - row;
fput_atx_command(f, ATX_UNCOMPRESSED_DATA, num_bytes);
fwrite(row, 1, num_bytes, f);
}
}
#if 0 /**************** MAY NOT BE NEEDED ****************/
/* Enforce the minimum page length, and skip any final blank lines. */
{
int paper_length = (int)(pdev->HWResolution[1] * 3 + 0.5);
int printed_length = height - blank_lines;
if (height > paper_length)
paper_length = height;
if (printed_length < paper_length)
fput_atx_command(f, ATX_VERTICAL_TAB,
paper_length - printed_length + 1);
}
#endif
/* End the page. */
fputs(ATX_END_PAGE, f);
done:
gs_free_object(mem, compressed, "atx_print_page(compressed)");
gs_free_object(mem, buf, "atx_print_page(buf)");
return code;
}
/* Send the page to the printer. */
static int
bj10e_print_page(gx_device_printer *pdev, FILE *prn_stream)
{ int line_size = gx_device_raster((gx_device *)pdev, 0);
int xres = (int)pdev->x_pixels_per_inch;
int yres = (int)pdev->y_pixels_per_inch;
int mode = (yres == 180 ?
(xres == 180 ? 11 : 12) :
(xres == 180 ? 14 : 16));
int bytes_per_column = (yres == 180) ? 3 : 6;
int bits_per_column = bytes_per_column * 8;
int skip_unit = bytes_per_column * 3;
byte *in = (byte *)gs_malloc(pdev->memory, 8, line_size, "bj10e_print_page(in)");
byte *out = (byte *)gs_malloc(pdev->memory, bits_per_column, line_size, "bj10e_print_page(out)");
int lnum = 0;
int skip = 0;
int code = 0;
int last_row = dev_print_scan_lines(pdev);
int limit = last_row - bits_per_column;
if ( in == 0 || out == 0 )
{ code = gs_note_error(gs_error_VMerror);
goto fin;
}
/* Initialize the printer. */
#ifdef USE_FACTORY_DEFAULTS
/* Check for U.S. letter vs. A4 paper. */
fwrite(( pdev->width / pdev->x_pixels_per_inch <= 8.4 ?
"\033[K\002\000\000\044" /*A4--DIP switch defaults*/ :
"\033[K\002\000\004\044" /*letter--factory defaults*/ ),
1, 7, prn_stream);
#else
fwrite("\033[K\002\000\000\044", 1, 7, prn_stream);
#endif
/* Turn off automatic carriage return, otherwise we get line feeds. */
fwrite("\0335\000", 1, 3, prn_stream);
/* Set vertical spacing. */
fwrite("\033[\\\004\000\000\000", 1, 7, prn_stream);
fputc(yres & 0xff, prn_stream);
fputc(yres >> 8, prn_stream);
/* Set the page length. This is the printable length, in inches. */
fwrite("\033C\000", 1, 3, prn_stream);
fputc((last_row + yres - 1)/yres, prn_stream);
/* Transfer pixels to printer. The last row we can print is defined
by "last_row". Only the bottom of the print head can print at the
bottom margin, and so we align the final printing pass. The print
head is kept from moving below "limit", which is exactly one pass
above the bottom margin. Once it reaches this limit, we make our
final printing pass of a full "bits_per_column" rows. */
while ( lnum < last_row )
{
byte *in_data;
byte *in_end = in + line_size;
byte *out_beg = out;
byte *out_end = out + bytes_per_column * pdev->width;
byte *outl = out;
int bnum;
/* Copy 1 scan line and test for all zero. */
code = gdev_prn_get_bits(pdev, lnum, in, &in_data);
if ( code < 0 ) goto xit;
/* The mem... or str... functions should be faster than */
/* the following code, but all systems seem to implement */
/* them so badly that this code is faster. */
{ register const long *zip = (const long *)in_data;
register int zcnt = line_size;
register const byte *zipb;
for ( ; zcnt >= 4 * sizeof(long); zip += 4, zcnt -= 4 * sizeof(long) )
{ if ( zip[0] | zip[1] | zip[2] | zip[3] )
goto notz;
}
zipb = (const byte *)zip;
while ( --zcnt >= 0 )
{
if ( *zipb++ )
goto notz;
}
/* Line is all zero, skip */
lnum++;
skip++;
continue;
notz: ;
}
/* Vertical tab to the appropriate position. Note here that
we make sure we don't move below limit. */
if ( lnum > limit )
{ skip -= (lnum - limit);
lnum = limit;
}
while ( skip > 255 )
{ fputs("\033J\377", prn_stream);
skip -= 255;
}
if ( skip )
fprintf(prn_stream, "\033J%c", skip);
/* If we've printed as far as "limit", then reset "limit"
to "last_row" for the final printing pass. */
if ( lnum == limit )
limit = last_row;
skip = 0;
/* Transpose in blocks of 8 scan lines. */
for ( bnum = 0; bnum < bits_per_column; bnum += 8 )
{ int lcnt = min(8, limit - lnum);
byte *inp = in;
byte *outp = outl;
lcnt = gdev_prn_copy_scan_lines(pdev,
lnum, in, lcnt * line_size);
if ( lcnt < 0 )
{ code = lcnt;
goto xit;
}
if ( lcnt < 8 )
memset(in + lcnt * line_size, 0,
(8 - lcnt) * line_size);
for ( ; inp < in_end; inp++, outp += bits_per_column )
{ gdev_prn_transpose_8x8(inp, line_size,
outp, bytes_per_column);
}
outl++;
lnum += lcnt;
skip += lcnt;
}
/* Send the bits to the printer. We alternate horizontal
skips with the data. The horizontal skips are in units
of 1/120 inches, so we look at the data in groups of
3 columns, since 3/360 = 1/120, and 3/180 = 2/120. */
outl = out;
do
{ int count;
int n;
byte *out_ptr;
/* First look for blank groups of columns. */
while(outl < out_end)
{ n = count = min(out_end - outl, skip_unit);
out_ptr = outl;
while ( --count >= 0 )
{ if ( *out_ptr++ )
break;
}
if ( count >= 0 )
break;
else
outl = out_ptr;
}
if (outl >= out_end)
break;
if (outl > out_beg)
{ count = (outl - out_beg) / skip_unit;
if ( xres == 180 ) count <<= 1;
fprintf(prn_stream, "\033d%c%c",
count & 0xff, count >> 8);
}
/* Next look for non-blank groups of columns. */
out_beg = outl;
outl += n;
while(outl < out_end)
{ n = count = min(out_end - outl, skip_unit);
out_ptr = outl;
while ( --count >= 0 )
{ if ( *out_ptr++ )
break;
}
if ( count < 0 )
break;
else
outl += n;
}
count = outl - out_beg + 1;
fprintf(prn_stream, "\033[g%c%c%c",
count & 0xff, count >> 8, mode);
fwrite(out_beg, 1, count - 1, prn_stream);
out_beg = outl;
outl += n;
}
while ( out_beg < out_end );
fputc('\r', prn_stream);
}
/* Send the page to the printer. */
static int
bj10v_print_page(gx_device_printer *pdev, FILE *prn_stream)
{ int line_size = gdev_prn_raster((gx_device *)pdev);
int xres = pdev->x_pixels_per_inch;
int yres = pdev->y_pixels_per_inch;
char *mode = (yres == 180 ?
(xres == 180 ? "\052\047" : "\052\050") :
"|*");
int bits_per_column = 24 * (yres / 180);
int bytes_per_column = bits_per_column / 8;
int x_skip_unit = bytes_per_column * (xres / 180);
int y_skip_unit = (yres / 180);
byte *in = (byte *)gs_malloc(gs_lib_ctx_get_non_gc_memory_t(), 8, line_size, "bj10v_print_page(in)");
byte *out = (byte *)gs_malloc(gs_lib_ctx_get_non_gc_memory_t(), bits_per_column, line_size, "bj10v_print_page(out)");
int lnum = 0;
int y_skip = 0;
int code = 0;
int blank_lines = 0;
int bytes_per_data = ((xres == 360) && (yres == 360)) ? 1 : 3;
if ( in == 0 || out == 0 )
return -1;
/* Initialize the printer. */
prn_puts(pdev, "\033@");
/* Transfer pixels to printer */
while ( lnum < pdev->height )
{ byte *out_beg;
byte *out_end;
byte *outl, *outp;
byte *zp;
int count, bnum;
/* Copy 1 scan line and test for all zero. */
code = gdev_prn_get_bits(pdev, lnum + blank_lines, in, NULL);
if ( code < 0 ) goto xit;
/* The mem... or str... functions should be faster than */
/* the following code, but all systems seem to implement */
/* them so badly that this code is faster. */
{ register long *zip = (long *)in;
register int zcnt = line_size;
static const long zeroes[4] = { 0, 0, 0, 0 };
for ( ; zcnt >= 4 * sizeof(long); zip += 4, zcnt -= 4 * sizeof(long) )
{ if ( zip[0] | zip[1] | zip[2] | zip[3] )
goto notz;
}
if ( !memcmp(in, (const char *)zeroes, zcnt) )
{ /* Line is all zero, skip */
if (++blank_lines >= y_skip_unit) {
lnum += y_skip_unit;
y_skip++;
blank_lines = 0;
}
continue;
}
}
notz:
blank_lines = 0;
out_end = out + bytes_per_column * pdev->width;
/* Vertical tab to the appropriate position. */
while ( y_skip > 255 )
{ prn_puts(pdev, "\033J\377");
y_skip -= 255;
}
if ( y_skip ) {
prn_puts(pdev, "\033J");
prn_putc(pdev, y_skip);
}
/* Transpose in blocks of 8 scan lines. */
for ( bnum = 0, outl = out; bnum < bits_per_column; bnum += 8, lnum += 8 )
{ int lcnt = gdev_prn_copy_scan_lines(pdev,
lnum, in, 8 * line_size);
byte *inp = in;
if ( lcnt < 0 )
{ code = lcnt;
goto xit;
}
if ( lcnt < 8 )
memset(in + lcnt * line_size, 0,
(8 - lcnt) * line_size);
for (outp = outl ; inp < in + line_size; inp++, outp += bits_per_column )
{ memflip8x8(inp, line_size,
outp, bytes_per_column);
}
outl++;
}
/* Remove trailing 0s. */
/* Note that non zero byte always exists. */
outl = out_end;
while ( *--outl == 0 )
;
count = ((out_end - (outl + 1)) / bytes_per_column) * bytes_per_column;
out_end -= count;
*out_end = 1; /* sentinel */
for ( out_beg = outp = out; outp < out_end; )
{ /* Skip a run of leading 0s. */
/* At least 10 bytes are needed to make tabbing worth it. */
byte *zp = outp;
int x_skip;
while ( *outp == 0 )
outp++;
x_skip = ((outp - zp) / x_skip_unit) * x_skip_unit;
outp = zp + x_skip;
if (x_skip >= 10) {
/* Output preceding bit data. */
int bytes = zp - out_beg;
if (bytes > 0)
/* Only false at beginning of line. */
bj10v_output_run(out_beg, bytes / bytes_per_data, bytes,
mode, pdev);
/* Tab over to the appropriate position. */
{ int skip = x_skip / x_skip_unit;
prn_puts(pdev, "\033\\");
prn_putc(pdev, skip & 0xff);
prn_putc(pdev, skip >> 8);
}
out_beg = outp;
} else
outp += x_skip_unit;
}
static int
perm_print_page(gx_device_printer *pdev, FILE *pstream)
{
int y;
gx_device_perm_t * const dev = (gx_device_perm_t *)pdev;
int ncomp = dev->num_std_colorant_names;
int raw_raster = pdev->width * ncomp;
byte *raw_line;
byte *cooked_line;
byte *row;
int code = 0;
int mode = dev->mode;
int permute = dev->permute;
fprintf(pstream, "P6\n%d %d\n255\n", dev->width, dev->height);
raw_line = gs_alloc_bytes(pdev->memory, raw_raster, "perm_print_page");
cooked_line = gs_alloc_bytes(pdev->memory, dev->width * 3, "perm_print_page");
for (y = 0; y < dev->height; y++) {
int x;
code = gdev_prn_get_bits(pdev, y, raw_line, &row);
for (x = 0; x < dev->width; x++) {
int c, m, y, k;
int r, g, b;
if (mode == 0) {
if (permute) {
c = row[x * ncomp + 1];
m = row[x * ncomp + 3];
y = row[x * ncomp + 0];
k = row[x * ncomp + 5];
} else {
c = row[x * ncomp];
m = row[x * ncomp + 1];
y = row[x * ncomp + 2];
k = row[x * ncomp + 3];
}
} else /* if (mode == 1) */ {
if (permute) {
c = row[x * ncomp + 1];
m = row[x * ncomp + 3];
y = row[x * ncomp + 0];
k = 0;
} else {
c = row[x * ncomp];
m = row[x * ncomp + 1];
y = row[x * ncomp + 2];
k = 0;
}
}
r = (255 - c) * (255 - k) / 255;
g = (255 - m) * (255 - k) / 255;
b = (255 - y) * (255 - k) / 255;
cooked_line[x * 3] = r;
cooked_line[x * 3 + 1] = g;
cooked_line[x * 3 + 2] = b;
}
fwrite(cooked_line, 1, dev->width * 3, pstream);
}
gs_free_object(pdev->memory, cooked_line, "perm_print_page");
gs_free_object(pdev->memory, raw_line, "perm_print_page");
return code;
}
/* Send the page to the file. */
static int
jbig2_print_page(gx_device_printer * pdev, FILE * prn_stream)
{
gx_device_jbig2 *jdev = (gx_device_jbig2 *) pdev;
gs_memory_t *mem = jdev->memory;
int line_size = gdev_mem_bytes_per_scan_line((gx_device *) pdev);
byte *in = gs_alloc_bytes(mem, line_size, "jbig2_print_page(in)");
byte *fbuf = 0;
uint fbuf_size;
byte *jbuf = 0;
uint jbuf_size;
int lnum;
int code = 0;
stream_jbig2encode_state state;
stream fstrm, cstrm;
if (in == 0) {
code = gs_note_error(gs_error_VMerror);
goto fail;
}
/* Create the jbig2encode state. */
s_init_state((stream_state *)&state, &s_jbig2encode_template, 0);
if (state.templat->set_defaults)
(*state.templat->set_defaults) ((stream_state *) & state);
state.width = jdev->width;
state.height = jdev->height;
/* Set up the streams. */
fbuf_size = max(512 /* arbitrary */ , state.templat->min_out_size);
jbuf_size = state.templat->min_in_size;
if ((fbuf = gs_alloc_bytes(mem, fbuf_size, "jbig2_print_page(fbuf)")) == 0 ||
(jbuf = gs_alloc_bytes(mem, jbuf_size, "jbig2_print_page(jbuf)")) == 0
) {
code = gs_note_error(gs_error_VMerror);
goto done;
}
s_init(&fstrm, mem);
swrite_file(&fstrm, prn_stream, fbuf, fbuf_size);
s_init(&cstrm, mem);
s_std_init(&cstrm, jbuf, jbuf_size, &s_filter_write_procs,
s_mode_write);
cstrm.state = (stream_state *) & state;
cstrm.procs.process = state.templat->process;
cstrm.strm = &fstrm;
if (state.templat->init)
(*state.templat->init) (cstrm.state);
/* Copy the data to the output. */
for (lnum = 0; lnum < jdev->height; ++lnum) {
byte *data;
uint ignore_used;
if (cstrm.end_status) {
code = gs_note_error(gs_error_ioerror);
goto done;
}
gdev_prn_get_bits(pdev, lnum, in, &data);
sputs(&cstrm, data, state.stride, &ignore_used);
}
/* Wrap up. */
sclose(&cstrm);
sflush(&fstrm);
done:
gs_free_object(mem, jbuf, "jbig2_print_page(jbuf)");
gs_free_object(mem, fbuf, "jbig2_print_page(fbuf)");
gs_free_object(mem, in, "jbig2_print_page(in)");
return code;
fail:
gs_free_object(mem, in, "jbig2_print_page(in)");
return code;
}
/* Send the page to the printer. */
static int
sj48_print_page(gx_device_printer *pdev, FILE *prn_stream)
{ int line_size = gx_device_raster((gx_device *)pdev, 0);
int xres = pdev->x_pixels_per_inch;
int yres = pdev->y_pixels_per_inch;
int mode = (yres == 180 ?
(xres == 180 ? 39 : 40) :
(xres == 180 ? 71 : 72));
int bytes_per_column = (yres == 180) ? 3 : 6;
int bits_per_column = bytes_per_column * 8;
int skip_unit = bytes_per_column * (xres == 180 ? 1 : 2); /* Skips in step of 1/180" */
byte *in = (byte *)gs_malloc(pdev->memory, 8, line_size, "sj48_print_page(in)");
byte *out = (byte *)gs_malloc(pdev->memory, bits_per_column, line_size, "sj48_print_page(out)");
int lnum = 0;
int skip = 0;
int skips;
int code = 0;
int last_row = dev_print_scan_lines(pdev);
int limit = last_row - bits_per_column;
if ( in == 0 || out == 0 )
{ code = gs_error_VMerror;
gs_note_error(code);
goto fin;
}
/* Abort if the requested resolution is unsupported. */
if ((xres !=180 && xres != 360) || (yres !=180 && yres != 360))
{ code = gs_error_rangecheck;
gs_note_error(code);
goto fin;
}
/* Initialize the printer. */
fwrite("\033@\000\000", 1, 4, prn_stream); /* <Printer reset>, <0>, <0>. */
/* Transfer pixels to printer. The last row we can print is defined
by "last_row". Only the bottom of the print head can print at the
bottom margin, and so we align the final printing pass. The print
head is kept from moving below "limit", which is exactly one pass
above the bottom margin. Once it reaches this limit, we make our
final printing pass of a full "bits_per_column" rows. */
while ( lnum < last_row )
{
byte *in_data;
byte *in_end = in + line_size;
byte *out_beg = out;
byte *out_end = out + bytes_per_column * pdev->width;
byte *outl = out;
int bnum;
/* Copy 1 scan line and test for all zero. */
code = gdev_prn_get_bits(pdev, lnum, in, &in_data);
if ( code < 0 ) goto xit;
/* The mem... or str... functions should be faster than */
/* the following code, but all systems seem to implement */
/* them so badly that this code is faster. */
{ register const long *zip = (const long *)in_data;
register int zcnt = line_size;
register const byte *zipb;
for ( ; zcnt >= 4 * sizeof(long); zip += 4, zcnt -= 4 * sizeof(long) )
{ if ( zip[0] | zip[1] | zip[2] | zip[3] )
goto notz;
}
zipb = (const byte *)zip;
while ( --zcnt >= 0 )
{
if ( *zipb++ )
goto notz;
}
/* Line is all zero, skip */
lnum++;
skip++;
continue;
notz: ;
}
/* Vertical tab to the appropriate position. Note here that
we make sure we don't move below limit. */
if ( lnum > limit )
{ skip -= (limit - lnum);
lnum = limit;
}
/* The SJ48 can only skip in steps of 1/180" */
if (yres == 180) {
skips = skip;
} else {
if (skip & 1) {
skip--; /* Makes skip even. */
lnum--;
}
skips = skip/2;
}
while ( skips > 255 )
{ fputs("\033J\377", prn_stream);
skips -= 255;
}
if ( skips )
fprintf(prn_stream, "\033J%c", skips);
/* If we've printed as far as "limit", then reset "limit"
to "last_row" for the final printing pass. */
if ( lnum == limit )
limit = last_row;
skip = 0;
/* Transpose in blocks of 8 scan lines. */
for ( bnum = 0; bnum < bits_per_column; bnum += 8 )
{ int lcnt = min(8, limit - lnum);
byte *inp = in;
byte *outp = outl;
lcnt = gdev_prn_copy_scan_lines(pdev,
lnum, in, lcnt * line_size);
if ( lcnt < 0 )
{ code = lcnt;
goto xit;
}
if ( lcnt < 8 )
memset(in + lcnt * line_size, 0,
(8 - lcnt) * line_size);
for ( ; inp < in_end; inp++, outp += bits_per_column )
{ gdev_prn_transpose_8x8(inp, line_size,
outp, bytes_per_column);
}
outl++;
lnum += lcnt;
skip += lcnt;
}
/* Send the bits to the printer. We alternate horizontal
skips with the data. The horizontal skips are in units
of 1/180 inches, so we look at the data in groups of
1 or 2 columns depending on resolution (controlled
by skip_unit). */
outl = out;
do
{ int count;
int n;
byte *out_ptr;
/* First look for blank groups of columns. */
while(outl < out_end)
{ n = count = min(out_end - outl, skip_unit);
out_ptr = outl;
while ( --count >= 0 )
{ if ( *out_ptr++ )
break;
}
if ( count >= 0 )
break;
else
outl = out_ptr;
}
if (outl >= out_end)
break;
if (outl > out_beg)
{ count = (outl - out_beg) / skip_unit;
fprintf(prn_stream, "\033\\%c%c",
count & 0xff, count >> 8);
}
/* Next look for non-blank groups of columns. */
out_beg = outl;
outl += n;
while(outl < out_end)
{ n = count = min(out_end - outl, skip_unit);
out_ptr = outl;
while ( --count >= 0 )
{ if ( *out_ptr++ )
break;
}
if ( count < 0 )
break;
else
outl += n;
}
count = outl - out_beg;
{
/* What to transmit is the number of columns in the row.
Compare this with the <Esc>|*-command wich expects the
total number of bytes in the graphic row! */
int count1 = count/bytes_per_column;
fprintf(prn_stream, "\033*%c%c%c",
mode, count1 & 0xff, count1 >> 8);
}
fwrite(out_beg, 1, count, prn_stream);
out_beg = outl;
outl += n;
}
while ( out_beg < out_end );
fputc('\r', prn_stream);
skip = bits_per_column; /* <CR> only moves to the beginning of the row. */
}
/* Send the page to the printer. */
#define DD 0x40 /* double density flag */
static int
eps_print_page(gx_device_printer *pdev, FILE *prn_stream, int y_9pin_high,
const char *init_string, int init_length, const char *end_string,
int archaic, int tab_hiccup)
{
static const char graphics_modes_9[5] =
{
-1, 0 /*60*/, 1 /*120*/, 7 /*180*/, DD+3 /*240*/
};
static const char graphics_modes_24[7] =
{
-1, 32 /*60*/, 33 /*120*/, 39 /*180*/,
DD+35 /*240*/, -1, DD+40 /*360*/
};
int y_24pin = (y_9pin_high ? 0 : pdev->y_pixels_per_inch > 72);
int in_y_mult = ((y_24pin | y_9pin_high) ? 3 : 1);
int line_size = gdev_mem_bytes_per_scan_line((gx_device *)pdev);
/* Note that in_size is a multiple of 8. */
int in_size = line_size * (8 * in_y_mult);
byte *buf1 = (byte *)gs_malloc(pdev->memory, in_size, 1, "eps_print_page(buf1)");
byte *buf2 = (byte *)gs_malloc(pdev->memory, in_size, 1, "eps_print_page(buf2)");
byte *in = buf1;
byte *out = buf2;
int out_y_mult = (y_24pin ? 3 : 1);
int x_dpi = (int)pdev->x_pixels_per_inch;
char start_graphics =
(y_24pin ? graphics_modes_24 : graphics_modes_9)[x_dpi / 60];
int first_pass = (start_graphics & DD ? 1 : 0);
int last_pass = first_pass * (y_9pin_high == 2 ? 1 : 2);
int y_passes = (y_9pin_high ? 3 : 1);
int dots_per_space = x_dpi / 10; /* pica space = 1/10" */
int bytes_per_space = dots_per_space * out_y_mult;
int tab_min_pixels = x_dpi * MIN_TAB_10THS / 10;
int skip = 0, lnum = 0, pass, ypass;
/* Check allocations */
if ( buf1 == 0 || buf2 == 0 )
{ if ( buf1 )
gs_free(pdev->memory, (char *)buf1, in_size, 1, "eps_print_page(buf1)");
if ( buf2 )
gs_free(pdev->memory, (char *)buf2, in_size, 1, "eps_print_page(buf2)");
return_error(gs_error_VMerror);
}
/* Initialize the printer and reset the margins. */
fwrite(init_string, 1, init_length, prn_stream);
if ( init_string[init_length - 1] == 'Q' )
fputc((int)(pdev->width / pdev->x_pixels_per_inch * 10) + 2,
prn_stream);
/* Calculate the minimum tab distance. */
if ( tab_min_pixels < max(MIN_TAB_PIXELS, 3) )
tab_min_pixels = max(MIN_TAB_PIXELS, 3);
tab_min_pixels -= tab_min_pixels % 3; /* simplify life */
/* Print lines of graphics */
while ( lnum < pdev->height )
{
byte *in_data;
byte *inp;
byte *in_end;
byte *out_end;
byte *out_blk;
register byte *outp;
int lcnt;
/* Copy 1 scan line and test for all zero. */
gdev_prn_get_bits(pdev, lnum, in, &in_data);
if ( in_data[0] == 0 &&
!memcmp((char *)in_data, (char *)in_data + 1, line_size - 1)
)
{
lnum++;
skip += 3 / in_y_mult;
continue;
}
/* Vertical tab to the appropriate position. */
while ( skip > 255 )
{
fputs("\033J\377", prn_stream);
skip -= 255;
}
if ( skip )
{
fprintf(prn_stream, "\033J%c", skip);
}
/* Copy the the scan lines. */
lcnt = gdev_prn_copy_scan_lines(pdev, lnum, in, in_size);
if ( lcnt < 8 * in_y_mult )
{ /* Pad with lines of zeros. */
memset(in + lcnt * line_size, 0,
in_size - lcnt * line_size);
}
if ( y_9pin_high == 2 )
{ /* Force printing of every dot in one pass */
/* by reducing vertical resolution */
/* (ORing with the next line of data). */
/* This is necessary because some Epson compatibles */
/* can't print neighboring dots. */
int i;
for ( i = 0; i < line_size * in_y_mult; ++i )
in_data[i] |= in_data[i + line_size];
}
if ( y_9pin_high )
{ /* Shuffle the scan lines */
byte *p;
int i;
static const char index[] =
{ 0, 8, 16, 1, 9, 17,
2, 10, 18, 3, 11, 19,
4, 12, 20, 5, 13, 21,
6, 14, 22, 7, 15, 23
};
for ( i = 0; i < 24; i++ )
{
memcpy(out+(index[i]*line_size),
in+(i*line_size), line_size);
}
p = in;
in = out;
out = p;
}
for ( ypass = 0; ypass < y_passes; ypass++ )
{
for ( pass = first_pass; pass <= last_pass; pass++ )
{
/* We have to 'transpose' blocks of 8 pixels x 8 lines, */
/* because that's how the printer wants the data. */
/* If we are in a 24-pin mode, we have to transpose */
/* groups of 3 lines at a time. */
if ( pass == first_pass )
{
out_end = out;
inp = in;
in_end = inp + line_size;
if ( y_24pin )
{
for ( ; inp < in_end; inp++, out_end += 24 )
{
gdev_prn_transpose_8x8(inp, line_size, out_end, 3);
gdev_prn_transpose_8x8(inp + line_size * 8,
line_size, out_end + 1, 3);
gdev_prn_transpose_8x8(inp + line_size * 16,
line_size, out_end + 2, 3);
}
/* Remove trailing 0s. */
while ( out_end > out && out_end[-1] == 0 &&
out_end[-2] == 0 && out_end[-3] == 0)
{
out_end -= 3;
}
}
else
{
for ( ; inp < in_end; inp++, out_end += 8 )
{
gdev_prn_transpose_8x8(inp + (ypass * 8*line_size),
line_size, out_end, 1);
}
/* Remove trailing 0s. */
while ( out_end > out && out_end[-1] == 0 )
{
out_end--;
}
}
}
for ( out_blk = outp = out; outp < out_end; )
{
/* Skip a run of leading 0s. At least */
/* tab_min_pixels are needed to make tabbing */
/* worth it. We do everything by 3's to */
/* avoid having to make different cases */
/* for 9- and 24-pin. */
if ( !archaic &&
*outp == 0 && out_end - outp >= tab_min_pixels &&
(outp[1] | outp[2]) == 0 &&
!memcmp((char *)outp, (char *)outp + 3,
tab_min_pixels - 3)
)
{
byte *zp = outp;
int tpos;
byte *newp;
outp += tab_min_pixels;
while ( outp + 3 <= out_end &&
*outp == 0 &&
outp[1] == 0 && outp[2] == 0 )
{
outp += 3;
}
tpos = (outp - out) / bytes_per_space;
newp = out + tpos * bytes_per_space;
if ( newp > zp + 10 )
{
/* Output preceding bit data.*/
if ( zp > out_blk )
{
/* only false at beginning of line */
eps_output_run(out_blk, (int)(zp - out_blk),
out_y_mult, start_graphics,
prn_stream,
(y_9pin_high == 2 ?
(1 + ypass) & 1 : pass));
}
/* Tab over to the appropriate position. */
if ( tab_hiccup )
fputs("\010 ", prn_stream); /* bksp, space */
/* The following statement is broken up */
/* to work around a bug in emx/gcc. */
fprintf(prn_stream, "\033D%c", tpos);
fputc(0, prn_stream);
fputc('\t', prn_stream);
out_blk = outp = newp;
}
}
else
{
outp += out_y_mult;
}
}
if ( outp > out_blk )
{
eps_output_run(out_blk, (int)(outp - out_blk),
out_y_mult, start_graphics,
prn_stream,
(y_9pin_high == 2 ? (1 + ypass) & 1 : pass));
}
fputc('\r', prn_stream);
}
if ( ypass < y_passes - 1 )
fputs("\033J\001", prn_stream);
}
skip = 24 - y_passes + 1; /* no skip on last Y pass */
lnum += 8 * in_y_mult;
}
/* Eject the page and reinitialize the printer */
fputs(end_string, prn_stream);
fflush(prn_stream);
gs_free(pdev->memory, (char *)buf2, in_size, 1, "eps_print_page(buf2)");
gs_free(pdev->memory, (char *)buf1, in_size, 1, "eps_print_page(buf1)");
return 0;
}
