1 /* Copyright (C) 1990, 1995, 1997, 2000 Aladdin Enterprises. All rights reserved. 2 3 This software is provided AS-IS with no warranty, either express or 4 implied. 5 6 This software is distributed under license and may not be copied, 7 modified or distributed except as expressly authorized under the terms 8 of the license contained in the file LICENSE in this distribution. 9 10 For more information about licensing, please refer to 11 http://www.ghostscript.com/licensing/. For information on 12 commercial licensing, go to http://www.artifex.com/licensing/ or 13 contact Artifex Software, Inc., 101 Lucas Valley Road #110, 14 San Rafael, CA 94903, U.S.A., +1(415)492-9861. 15 */ 16 17 /* $Id: gdevbj10.c,v 1.9 2004/08/04 19:36:12 stefan Exp $*/ 18 /* Canon Bubble Jet BJ-10e, BJ200, and BJ300 printer driver */ 19 #include "gdevprn.h" 20 21 /* 22 * The following is taken from the BJ200 Programmer's manual. The top 23 * margin is 3mm (0.12"), and the bottom margin is 6.4mm (0.25"). The 24 * left and right margin depend on the type of paper -- US letter or 25 * A4 -- but ultimately rest on a print width of 203.2mm (8"). For letter 26 * paper, the left margin (and hence the right) is 6.4mm (0.25"), while 27 * for A4 paper, both are 3.4mm (0.13"). 28 * 29 * The bottom margin requires a bit of care. The image is printed 30 * as strips, each about 3.4mm wide. We can only attain the bottom 31 * margin if the final strip coincides with it. Note that each strip 32 * is generated using only 48 of the available 64 jets, and the absence 33 * of those bottom 16 jets makes our bottom margin, in effect, about 34 * 1.1mm (0.04") larger. 35 * 36 * The bj200 behaves, in effect, as though the origin were at the first 37 * printable position, rather than the top left corner of the page, so 38 * we add a translation to the initial matrix to compensate for this. 39 * 40 * Except for the details of getting the margins correct, the bj200 is 41 * no different from the bj10e, and uses the same routine to print each 42 * page. 43 * 44 * NOTE: The bj200 has a DIP switch called "Text scale mode" and if 45 * set, it allows the printer to get 66 lines on a letter-sized page 46 * by reducing the line spacing by a factor of 14/15. If this DIP 47 * switch is set, the page image printed by ghostscript will also be 48 * similarly squeezed. Thus text scale mode is something ghostscript 49 * would like to disable. 50 * 51 * According to the bj200 manual, which describes the bj10 commands, 52 * the printer can be reset either to the settings determined by the 53 * DIP switches, or to the factory defaults, and then some of those 54 * settings can be specifically overriden. Unfortunately, the text 55 * scale mode and horizontal print position (for letter vs A4 paper) 56 * can not be overriden. On my bj200, the factory settings are for 57 * no text scaling and letter paper, thus using the factory defaults 58 * also implies letter paper. I don't know if this is necessarily 59 * true for bj200's sold elsewhere, or for other printers that use 60 * the same command set. 61 * 62 * If your factory defaults are in fact the same, you can compile 63 * the driver with USE_FACTORY_DEFAULTS defined, in which case the 64 * printer will be reset to the factory defaults for letter paper, 65 * and reset to the DIP switch settings for A4 paper. In this case, 66 * with letter-sized paper, the text scale mode will be disabled. 67 * Further, by leaving the horizontal print position DIP switch set 68 * for A4 paper, gs will be able to print on either A4 or letter 69 * paper without changing the DIP switch. Since it's not clear that 70 * the factory defaults are universal, the default behaviour is not 71 * to define USE_FACTORY_DEFAULTS, and the printer will always be 72 * reset to the DIP switch defaults. 73 */ 74 75 /* 76 * According to md@duesti.fido.de (Matthias Duesterhoeft): 77 78 It is possible to use the printer Canon BJ-300 (and 330) with Ghostscript if 79 you use the driver for the Canon BJ-200. The Printer has to be set to 80 Proprinter Mode. Although it is possible to set the print quality with a DIP 81 switch, you should add the following to the already existing init-string: 82 1B 5B 64 01 00 80 (all numbers in hex) 83 This sets the print quality to letter quality. 84 85 The minimum margins are the following: 86 87 Portrait: 88 B5/A4: min. left and right margin: 3.4 mm (0.13") 89 Letter: min. left and right margin: 6.4 mm (0.25") 90 91 Landscape: 92 B4: min. left and right margin: 9.3 mm (0.37") 93 A3: min. left and right margin: 37.3 mm (1.47") 94 95 The recommended top margin is 12.7 mm (0.5"), although the printer is capable 96 to start at 0 mm. The recommended bottom margin is 25.4 mm (1"), but 12.7 mm 97 (0.5") are possible, too. If you ask me, don't use the recommended top and 98 bottom margins, use 0" and 0.5". 99 100 */ 101 102 #define BJ200_TOP_MARGIN 0.12 103 #define BJ200_BOTTOM_MARGIN 0.29 104 #define BJ200_LETTER_SIDE_MARGIN 0.25 105 #define BJ200_A4_SIDE_MARGIN 0.13 106 107 private dev_proc_open_device(bj200_open); 108 109 private dev_proc_print_page(bj10e_print_page); 110 111 private gx_device_procs prn_bj200_procs = 112 prn_procs(bj200_open, gdev_prn_output_page, gdev_prn_close); 113 114 const gx_device_printer far_data gs_bj200_device = 115 prn_device(prn_bj200_procs, "bj200", 116 DEFAULT_WIDTH_10THS, 117 DEFAULT_HEIGHT_10THS, 118 360, /* x_dpi */ 119 360, /* y_dpi */ 120 0, 0, 0, 0, /* margins filled in by bj200_open */ 121 1, bj10e_print_page); 122 123 /* 124 * (<simon@pogner.demon.co.uk>, aka <sjwright@cix.compulink.co.uk>): 125 * My bj10ex, which as far as I can tell is just like a bj10e, needs a 126 * bottom margin of 0.4" (actually, you must not print within 0.5" of 127 * the bottom; somewhere, an extra 0.1" is creeping in). 128 * 129 * (<jim.hague@acm.org>): 130 * I have a BJ10sx and the BJ10sx manual. This states that the top and 131 * bottom margins for the BJ10sx are 0.33" and 0.5". The latter may 132 * explain Simon's finding. The manual also instructs Win31 users to 133 * select 'BJ10e' as their driver, so presumably the margins will be 134 * identical and thus also correct for BJ10e. The values for the side 135 * margins given are identical to those above. 136 * 137 * As of 2nd Nov 2001 the BJ10 sx manual is at 138 * http://www.precision.com/Printer%20Manuals/Canon%20BJ-10sx%20Manual.pdf. 139 */ 140 141 #define BJ10E_TOP_MARGIN 0.33 142 #define BJ10E_BOTTOM_MARGIN (0.50 + 0.04) 143 144 private dev_proc_open_device(bj10e_open); 145 146 private gx_device_procs prn_bj10e_procs = 147 prn_procs(bj10e_open, gdev_prn_output_page, gdev_prn_close); 148 149 const gx_device_printer far_data gs_bj10e_device = 150 prn_device(prn_bj10e_procs, "bj10e", 151 DEFAULT_WIDTH_10THS, 152 DEFAULT_HEIGHT_10THS, 153 360, /* x_dpi */ 154 360, /* y_dpi */ 155 0,0,0,0, /* margins */ 156 1, bj10e_print_page); 157 158 /* 159 * Notes on the BJ10e/BJ200 command set. 160 * 161 162 According to the BJ200 manual, the "set initial condition" sequence (ESC [ 163 K) has 2 bytes which can override the DIP switches -- these are the last 2 164 bytes. Several bits are listed as "reserved" -- one or more may possibly 165 affect the sheet feeder. The first is referred to as <P1>, with the 166 following meaning: 167 1 0 168 bit 7 ignore/process P1 ignore process 169 bit 6 reserved 170 bit 5 alarm disabled enabled 171 bit 4 automatic CR CR+LF CR 172 bit 3 automatic LF CR+LF LF 173 bit 2 page length 12 inches 11 inches 174 bit 1 style for zero slashed not slashed 175 bit 0 character set set 2 set 1 176 177 The last byte is <P2>, with the following meaning: 178 1 0 179 bit 7 ignore/process P2 ignore process 180 bit 6 code page 850 437 181 bit 5 reserved 182 bit 4 reserved 183 bit 3 reserved 184 bit 2 reserved 185 bit 1 reserved 186 bit 0 reserved 187 188 The automatic CR setting is important to gs, but the rest shouldn't matter 189 (gs doesn't print characters or send LF, and it explicitly sets the page 190 length). The sequence ESC 5 <n> controls automatic CR -- if <n> is 0x00, 191 it is turned off (CR only) and if <n> is 0x01, it is turned on (CR + LF). 192 So we do following: Change the initialization string to so that the last 2 193 of the 9 bytes are \200 rather than \000. Then add 194 |* Turn off automatic carriage return, otherwise we get line feeds. *| 195 fwrite("\0335\000", 1, 3, prn_stream); 196 after the initialization. (Actually, instead of setting the last 2 bytes 197 to \200, we suppress them altogether by changing the byte count from \004 198 to \002 (the byte count is the 4th (low 8 bits) and 5th (high 8 bits) bytes 199 in the initialization sequence).) 200 201 */ 202 203 /* ------ Internal routines ------ */ 204 205 /* Open the printer, and set the margins. */ 206 private int 207 bj200_open(gx_device *pdev) 208 { 209 /* Change the margins according to the paper size. 210 The top and bottom margins don't seem to depend on the 211 page length, but on the paper handling mechanism; 212 The side margins do depend on the paper width, as the 213 printer centres the 8" print line on the page. */ 214 215 static const float a4_margins[4] = 216 { (float)BJ200_A4_SIDE_MARGIN, (float)BJ200_BOTTOM_MARGIN, 217 (float)BJ200_A4_SIDE_MARGIN, (float)BJ200_TOP_MARGIN 218 }; 219 static const float letter_margins[4] = 220 { (float)BJ200_LETTER_SIDE_MARGIN, (float)BJ200_BOTTOM_MARGIN, 221 (float)BJ200_LETTER_SIDE_MARGIN, (float)BJ200_TOP_MARGIN 222 }; 223 224 gx_device_set_margins(pdev, 225 (pdev->width / pdev->x_pixels_per_inch <= 8.4 ? 226 a4_margins : letter_margins), 227 true); 228 return gdev_prn_open(pdev); 229 } 230 231 private int 232 bj10e_open(gx_device *pdev) 233 { 234 /* See bj200_open() */ 235 static const float a4_margins[4] = 236 { (float)BJ200_A4_SIDE_MARGIN, (float)BJ10E_BOTTOM_MARGIN, 237 (float)BJ200_A4_SIDE_MARGIN, (float)BJ10E_TOP_MARGIN 238 }; 239 static const float letter_margins[4] = 240 { (float)BJ200_LETTER_SIDE_MARGIN, (float)BJ10E_BOTTOM_MARGIN, 241 (float)BJ200_LETTER_SIDE_MARGIN, (float)BJ10E_TOP_MARGIN 242 }; 243 244 gx_device_set_margins(pdev, 245 (pdev->width / pdev->x_pixels_per_inch <= 8.4 ? 246 a4_margins : letter_margins), 247 true); 248 return gdev_prn_open(pdev); 249 } 250 251 /* Send the page to the printer. */ 252 private int 253 bj10e_print_page(gx_device_printer *pdev, FILE *prn_stream) 254 { int line_size = gx_device_raster((gx_device *)pdev, 0); 255 int xres = (int)pdev->x_pixels_per_inch; 256 int yres = (int)pdev->y_pixels_per_inch; 257 int mode = (yres == 180 ? 258 (xres == 180 ? 11 : 12) : 259 (xres == 180 ? 14 : 16)); 260 int bytes_per_column = (yres == 180) ? 3 : 6; 261 int bits_per_column = bytes_per_column * 8; 262 int skip_unit = bytes_per_column * 3; 263 byte *in = (byte *)gs_malloc(pdev->memory, 8, line_size, "bj10e_print_page(in)"); 264 byte *out = (byte *)gs_malloc(pdev->memory, bits_per_column, line_size, "bj10e_print_page(out)"); 265 int lnum = 0; 266 int skip = 0; 267 int code = 0; 268 int last_row = dev_print_scan_lines(pdev); 269 int limit = last_row - bits_per_column; 270 271 if ( in == 0 || out == 0 ) 272 { code = gs_note_error(gs_error_VMerror); 273 goto fin; 274 } 275 276 /* Initialize the printer. */ 277 #ifdef USE_FACTORY_DEFAULTS 278 /* Check for U.S. letter vs. A4 paper. */ 279 fwrite(( pdev->width / pdev->x_pixels_per_inch <= 8.4 ? 280 "\033[K\002\000\000\044" /*A4--DIP switch defaults*/ : 281 "\033[K\002\000\004\044" /*letter--factory defaults*/ ), 282 1, 7, prn_stream); 283 #else 284 fwrite("\033[K\002\000\000\044", 1, 7, prn_stream); 285 #endif 286 287 /* Turn off automatic carriage return, otherwise we get line feeds. */ 288 fwrite("\0335\000", 1, 3, prn_stream); 289 290 /* Set vertical spacing. */ 291 fwrite("\033[\\\004\000\000\000", 1, 7, prn_stream); 292 fputc(yres & 0xff, prn_stream); 293 fputc(yres >> 8, prn_stream); 294 295 /* Set the page length. This is the printable length, in inches. */ 296 fwrite("\033C\000", 1, 3, prn_stream); 297 fputc((last_row + yres - 1)/yres, prn_stream); 298 299 /* Transfer pixels to printer. The last row we can print is defined 300 by "last_row". Only the bottom of the print head can print at the 301 bottom margin, and so we align the final printing pass. The print 302 head is kept from moving below "limit", which is exactly one pass 303 above the bottom margin. Once it reaches this limit, we make our 304 final printing pass of a full "bits_per_column" rows. */ 305 while ( lnum < last_row ) 306 { 307 byte *in_data; 308 byte *in_end = in + line_size; 309 byte *out_beg = out; 310 byte *out_end = out + bytes_per_column * pdev->width; 311 byte *outl = out; 312 int bnum; 313 314 /* Copy 1 scan line and test for all zero. */ 315 code = gdev_prn_get_bits(pdev, lnum, in, &in_data); 316 if ( code < 0 ) goto xit; 317 /* The mem... or str... functions should be faster than */ 318 /* the following code, but all systems seem to implement */ 319 /* them so badly that this code is faster. */ 320 { register const long *zip = (const long *)in_data; 321 register int zcnt = line_size; 322 register const byte *zipb; 323 for ( ; zcnt >= 4 * sizeof(long); zip += 4, zcnt -= 4 * sizeof(long) ) 324 { if ( zip[0] | zip[1] | zip[2] | zip[3] ) 325 goto notz; 326 } 327 zipb = (const byte *)zip; 328 while ( --zcnt >= 0 ) 329 { 330 if ( *zipb++ ) 331 goto notz; 332 } 333 /* Line is all zero, skip */ 334 lnum++; 335 skip++; 336 continue; 337 notz: ; 338 } 339 340 /* Vertical tab to the appropriate position. Note here that 341 we make sure we don't move below limit. */ 342 if ( lnum > limit ) 343 { skip -= (lnum - limit); 344 lnum = limit; 345 } 346 while ( skip > 255 ) 347 { fputs("\033J\377", prn_stream); 348 skip -= 255; 349 } 350 if ( skip ) 351 fprintf(prn_stream, "\033J%c", skip); 352 353 /* If we've printed as far as "limit", then reset "limit" 354 to "last_row" for the final printing pass. */ 355 if ( lnum == limit ) 356 limit = last_row; 357 skip = 0; 358 359 /* Transpose in blocks of 8 scan lines. */ 360 for ( bnum = 0; bnum < bits_per_column; bnum += 8 ) 361 { int lcnt = min(8, limit - lnum); 362 byte *inp = in; 363 byte *outp = outl; 364 lcnt = gdev_prn_copy_scan_lines(pdev, 365 lnum, in, lcnt * line_size); 366 if ( lcnt < 0 ) 367 { code = lcnt; 368 goto xit; 369 } 370 if ( lcnt < 8 ) 371 memset(in + lcnt * line_size, 0, 372 (8 - lcnt) * line_size); 373 for ( ; inp < in_end; inp++, outp += bits_per_column ) 374 { gdev_prn_transpose_8x8(inp, line_size, 375 outp, bytes_per_column); 376 } 377 outl++; 378 lnum += lcnt; 379 skip += lcnt; 380 } 381 382 /* Send the bits to the printer. We alternate horizontal 383 skips with the data. The horizontal skips are in units 384 of 1/120 inches, so we look at the data in groups of 385 3 columns, since 3/360 = 1/120, and 3/180 = 2/120. */ 386 outl = out; 387 do 388 { int count; 389 int n; 390 byte *out_ptr; 391 392 /* First look for blank groups of columns. */ 393 while(outl < out_end) 394 { n = count = min(out_end - outl, skip_unit); 395 out_ptr = outl; 396 while ( --count >= 0 ) 397 { if ( *out_ptr++ ) 398 break; 399 } 400 if ( count >= 0 ) 401 break; 402 else 403 outl = out_ptr; 404 } 405 if (outl >= out_end) 406 break; 407 if (outl > out_beg) 408 { count = (outl - out_beg) / skip_unit; 409 if ( xres == 180 ) count <<= 1; 410 fprintf(prn_stream, "\033d%c%c", 411 count & 0xff, count >> 8); 412 } 413 414 /* Next look for non-blank groups of columns. */ 415 out_beg = outl; 416 outl += n; 417 while(outl < out_end) 418 { n = count = min(out_end - outl, skip_unit); 419 out_ptr = outl; 420 while ( --count >= 0 ) 421 { if ( *out_ptr++ ) 422 break; 423 } 424 if ( count < 0 ) 425 break; 426 else 427 outl += n; 428 } 429 count = outl - out_beg + 1; 430 fprintf(prn_stream, "\033[g%c%c%c", 431 count & 0xff, count >> 8, mode); 432 fwrite(out_beg, 1, count - 1, prn_stream); 433 out_beg = outl; 434 outl += n; 435 } 436 while ( out_beg < out_end ); 437 438 fputc('\r', prn_stream); 439 } 440 441 /* Eject the page */ 442 xit: fputc(014, prn_stream); /* form feed */ 443 fflush(prn_stream); 444 fin: if ( out != 0 ) 445 gs_free(pdev->memory, (char *)out, bits_per_column, line_size, 446 "bj10e_print_page(out)"); 447 if ( in != 0 ) 448 gs_free(pdev->memory, (char *)in, 8, line_size, "bj10e_print_page(in)"); 449 return code; 450 } 451