/* Copyright (C) 1998, 1999 Norihito Ohmori. Ghostscript printer driver for Canon LBP, BJC-680J and BJC-880J printers (LIPS II+/III/IVc/IV) This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. No author or distributor accepts responsibility to anyone for the consequences of using it or for whether it serves any particular purpose or works at all, unless he says so in writing. Refer to the GNU General Public License for full details. Everyone is granted permission to copy, modify and redistribute this software, but only under the conditions described in the GNU General Public License. A copy of this license is supposed to have been given to you along with this software so you can know your rights and responsibilities. It should be in a file named COPYING. Among other things, the copyright notice and this notice must be preserved on all copies. */ /*$Id: gdevl4r.c $ */ /* Raster Version of LIPS driver */ #include "gdevlprn.h" #include "gdevlips.h" /* The device descriptors */ private dev_proc_open_device(lips2p_open); private dev_proc_open_device(lips3_open); private dev_proc_open_device(bjc880j_open); private dev_proc_open_device(lips4_open); private dev_proc_close_device(lips_close); private dev_proc_print_page_copies(lips2p_print_page_copies); private dev_proc_print_page_copies(lips3_print_page_copies); private dev_proc_print_page_copies(bjc880j_print_page_copies); private dev_proc_print_page_copies(lips4_print_page_copies); private dev_proc_get_params(lips_get_params); private dev_proc_get_params(lips4_get_params); private dev_proc_put_params(lips_put_params); private dev_proc_put_params(lips4_put_params); #if 0 private dev_proc_image_out(lips_image_out); #endif private dev_proc_image_out(lips2p_image_out); private dev_proc_image_out(lips4_image_out); #define lips_device(dtype, procs, dname, xdpi, ydpi, lm, bm, rm, tm, color_bits,\ print_page_copies, image_out, cassetFeed, username)\ { std_device_std_color_full_body(dtype, &procs, dname,\ (int)((long)((DEFAULT_WIDTH_10THS) * (xdpi)) / 10),\ (int)((long)((DEFAULT_HEIGHT_10THS) * (ydpi)) / 10),\ xdpi, ydpi, color_bits,\ -(lm) * (xdpi), -(tm) * (ydpi),\ (lm) * 72.0, (bm) * 72.0,\ (rm) * 72.0, (tm) * 72.0\ ),\ lp_device_body_rest_(print_page_copies, image_out),\ cassetFeed, username, LIPS_PJL_DEFAULT,\ 0, 0, 0, 0, 0, 0, 0, -1\ } #define lips4_device(dtype, procs, dname, xdpi, ydpi, lm, bm, rm, tm, color_bits,\ print_page_copies, image_out, cassetFeed, username)\ { std_device_std_color_full_body(dtype, &procs, dname,\ (int)((long)((DEFAULT_WIDTH_10THS) * (xdpi)) / 10),\ (int)((long)((DEFAULT_HEIGHT_10THS) * (ydpi)) / 10),\ xdpi, ydpi, color_bits,\ -(lm) * (xdpi), -(tm) * (ydpi),\ (lm) * 72.0, (bm) * 72.0,\ (rm) * 72.0, (tm) * 72.0\ ),\ lp_duplex_device_body_rest_(print_page_copies, image_out),\ cassetFeed,\ username, LIPS_PJL_DEFAULT, 0, 0, 0, 0, 0, 0, 0, -1,\ 0, LIPS_NUP_DEFAULT, LIPS_FACEUP_DEFAULT,\ LIPS_MEDIATYPE_DEFAULT \ } typedef struct gx_device_lips_s gx_device_lips; struct gx_device_lips_s { gx_device_common; gx_prn_device_common; gx_lprn_device_common; lips_params_common; }; typedef struct gx_device_lips4_s gx_device_lips4; struct gx_device_lips4_s { gx_device_common; gx_prn_device_common; gx_lprn_device_common; lips_params_common; lips4_params_common; }; private gx_device_procs lips2p_prn_procs = prn_params_procs(lips2p_open, gdev_prn_output_page, lips_close, lips_get_params, lips_put_params); private gx_device_procs lips3_prn_procs = prn_params_procs(lips3_open, gdev_prn_output_page, lips_close, lips_get_params, lips_put_params); private gx_device_procs bjc880j_prn_color_procs = prn_params_procs(bjc880j_open, gdev_prn_output_page, lips_close, lips4_get_params, lips4_put_params); private gx_device_procs lips4_prn_procs = prn_params_procs(lips4_open, gdev_prn_output_page, lips_close, lips4_get_params, lips4_put_params); gx_device_lips far_data gs_lips2p_device = lips_device(gx_device_lips, lips2p_prn_procs, "lips2p", LIPS2P_DPI_DEFAULT, LIPS2P_DPI_DEFAULT, LIPS2P_LEFT_MARGIN_DEFAULT, LIPS2P_BOTTOM_MARGIN_DEFAULT, LIPS2P_RIGHT_MARGIN_DEFAULT, LIPS2P_TOP_MARGIN_DEFAULT, 1, lips2p_print_page_copies, lips2p_image_out, LIPS_CASSETFEED_DEFAULT, LIPS_USERNAME_DEFAULT); gx_device_lips far_data gs_lips3_device = lips_device(gx_device_lips, lips3_prn_procs, "lips3", LIPS3_DPI_DEFAULT, LIPS3_DPI_DEFAULT, LIPS3_LEFT_MARGIN_DEFAULT, LIPS3_BOTTOM_MARGIN_DEFAULT, LIPS3_RIGHT_MARGIN_DEFAULT, LIPS3_TOP_MARGIN_DEFAULT, 1, lips3_print_page_copies, lips2p_image_out, LIPS_CASSETFEED_DEFAULT, LIPS_USERNAME_DEFAULT); gx_device_lips4 far_data gs_bjc880j_device = lips4_device(gx_device_lips4, bjc880j_prn_color_procs, "bjc880j", BJC880J_DPI_DEFAULT, BJC880J_DPI_DEFAULT, BJC880J_LEFT_MARGIN_DEFAULT, BJC880J_BOTTOM_MARGIN_DEFAULT, BJC880J_RIGHT_MARGIN_DEFAULT, BJC880J_TOP_MARGIN_DEFAULT, 1, bjc880j_print_page_copies, lips4_image_out, LIPS_CASSETFEED_DEFAULT, LIPS_USERNAME_DEFAULT); gx_device_lips4 far_data gs_lips4_device = lips4_device(gx_device_lips4, lips4_prn_procs, "lips4", LIPS4_DPI_DEFAULT, LIPS4_DPI_DEFAULT, LIPS4_LEFT_MARGIN_DEFAULT, LIPS4_BOTTOM_MARGIN_DEFAULT, LIPS4_RIGHT_MARGIN_DEFAULT, LIPS4_TOP_MARGIN_DEFAULT, 1, lips4_print_page_copies, lips4_image_out, LIPS_CASSETFEED_DEFAULT, LIPS_USERNAME_DEFAULT); /* Printer types */ typedef enum { LIPS2P, LIPS3, BJC880J, LIPS4 } lips_printer_type; /* Forward references */ private void lips_job_start(gx_device_printer * dev, lips_printer_type ptype, FILE * fp, int num_copies); private void lips_job_end(gx_device_printer * pdev, FILE * fp); private int lips_open(gx_device * pdev, lips_printer_type ptype); private int lips4c_output_page(gx_device_printer * pdev, FILE * prn_stream); private int lips_delta_encode(byte * inBuff, byte * prevBuff, byte * outBuff, byte * diffBuff, int Length); private int lips_byte_cat(byte * TotalBuff, byte * Buff, int TotalLen, int Len); #if GS_VERSION_MAJOR >= 8 private int lips_print_page_copies(gx_device_printer * pdev, FILE * prn_stream, lips_printer_type ptype, int numcopies); private int lips_print_page_copies(gx_device_printer * pdev, FILE * prn_stream, lips_printer_type ptype, int numcopies); #else private int lips_print_page_copies(P4(gx_device_printer * pdev, FILE * prn_stream, lips_printer_type ptype, int numcopies)); private int lips_print_page_copies(P4(gx_device_printer * pdev, FILE * prn_stream, lips_printer_type ptype, int numcopies)); #endif private int lips4type_print_page_copies(gx_device_printer * pdev, FILE * prn_stream, int num_copies, int ptype); private int lips2p_open(gx_device * pdev) { return lips_open(pdev, LIPS2P); } private int lips3_open(gx_device * pdev) { return lips_open(pdev, LIPS3); } private int bjc880j_open(gx_device * pdev) { return lips_open(pdev, BJC880J); } private int lips4_open(gx_device * pdev) { return lips_open(pdev, LIPS4); } /* Open the printer, adjusting the margins if necessary. */ private int lips_open(gx_device * pdev, lips_printer_type ptype) { int width = pdev->MediaSize[0]; int height = pdev->MediaSize[1]; int xdpi = pdev->x_pixels_per_inch; int ydpi = pdev->y_pixels_per_inch; /* Paper Size Check */ if (width <= height) { /* portrait */ if ((width < LIPS_WIDTH_MIN || width > LIPS_WIDTH_MAX || height < LIPS_HEIGHT_MIN || height > LIPS_HEIGHT_MAX) && !(width == LIPS_LEDGER_WIDTH && height == LIPS_LEDGER_HEIGHT)) return_error(gs_error_rangecheck); } else { /* landscape */ if ((width < LIPS_HEIGHT_MIN || width > LIPS_HEIGHT_MAX || height < LIPS_WIDTH_MIN || height > LIPS_WIDTH_MAX) && !(width == LIPS_LEDGER_HEIGHT && height == LIPS_LEDGER_WIDTH)) return_error(gs_error_rangecheck); } /* Resolution Check */ if (xdpi != ydpi) return_error(gs_error_rangecheck); else if (ptype == LIPS2P) { /* LIPS II+ support DPI is 240x240 */ if (xdpi != LIPS2P_DPI_MAX) return_error(gs_error_rangecheck); } else if (ptype == LIPS3) { /* LIPS III supports DPI is 300x300 */ if (xdpi != LIPS3_DPI_MAX) return_error(gs_error_rangecheck); } else if (ptype == BJC880J) { if (xdpi < LIPS_DPI_MIN || xdpi > BJC880J_DPI_MAX) return_error(gs_error_rangecheck); } else { /* LIPS4 supprts DPI is 60x60 - 600x600 and 1200x1200 */ if ((xdpi < LIPS_DPI_MIN || xdpi > LIPS4_DPI_MAX) && xdpi != LIPS4_DPI_SUPERFINE) return_error(gs_error_rangecheck); } return gdev_prn_open(pdev); } private int lips_close(gx_device * pdev) { gx_device_printer *const ppdev = (gx_device_printer *) pdev; gx_device_lips *const lips = (gx_device_lips *) pdev; gdev_prn_open_printer(pdev, 1); fprintf(ppdev->file, "%c0J%c", LIPS_DCS, LIPS_ST); if (lips->pjl) fprintf(ppdev->file, "%c%%-12345X" "@PJL SET LPARM : LIPS SW2 = OFF\n" "@PJL EOJ\n" "%c%%-12345X", LIPS_ESC, LIPS_ESC); return gdev_prn_close(pdev); } /* Get properties for the lips drivers. */ private int lips_get_params(gx_device * pdev, gs_param_list * plist) { gx_device_lips *const lips = (gx_device_lips *) pdev; int code = lprn_get_params(pdev, plist); int ncode; gs_param_string usern; if (code < 0) return code; if ((ncode = param_write_int(plist, LIPS_OPTION_CASSETFEED, &lips->cassetFeed)) < 0) code = ncode; if ((ncode = param_write_bool(plist, LIPS_OPTION_PJL, &lips->pjl)) < 0) code = ncode; if ((ncode = param_write_int(plist, LIPS_OPTION_TONERDENSITY, &lips->toner_density)) < 0) code = ncode; if (lips->toner_saving_set >= 0 && (code = (lips->toner_saving_set ? param_write_bool(plist, LIPS_OPTION_TONERSAVING, &lips->toner_saving) : param_write_null(plist, LIPS_OPTION_TONERSAVING))) < 0) code = ncode; if (code < 0) return code; usern.data = (const byte *)lips->Username, usern.size = strlen(lips->Username), usern.persistent = false; return param_write_string(plist, LIPS_OPTION_USER_NAME, &usern); } private int lips4_get_params(gx_device * pdev, gs_param_list * plist) { gx_device_lips4 *const lips4 = (gx_device_lips4 *) pdev; int code = lips_get_params(pdev, plist); int ncode; gs_param_string pmedia; if (code < 0) return code; if ((ncode = param_write_int(plist, LIPS_OPTION_NUP, &lips4->nup)) < 0) code = ncode; if ((ncode = param_write_bool(plist, LIPS_OPTION_FACEUP, &lips4->faceup)) < 0) code = ncode; if (code < 0) return code; pmedia.data = (const byte *)lips4->mediaType, pmedia.size = strlen(lips4->mediaType), pmedia.persistent = false; return param_write_string(plist, LIPS_OPTION_MEDIATYPE, &pmedia); } /* Put properties for the lips drivers. */ private int lips_put_params(gx_device * pdev, gs_param_list * plist) { gx_device_lips *const lips = (gx_device_lips *) pdev; int ecode = 0; int code; gs_param_name param_name; int cass = lips->cassetFeed; bool pjl = lips->pjl; int toner_density = lips->toner_density; bool toner_saving = lips->toner_saving; bool toner_saving_set = lips->toner_saving_set; gs_param_string usern; switch (code = param_read_int(plist, (param_name = LIPS_OPTION_CASSETFEED), &cass)) { case 0: if (cass < -1 || cass > 17 || (cass > 3 && cass < 10)) ecode = gs_error_rangecheck; else break; goto casse; default: ecode = code; casse:param_signal_error(plist, param_name, ecode); case 1: break; } if ((code = param_read_bool(plist, (param_name = LIPS_OPTION_PJL), &pjl)) < 0) param_signal_error(plist, param_name, ecode = code); switch (code = param_read_int(plist, (param_name = LIPS_OPTION_TONERDENSITY), &toner_density)) { case 0: if (toner_density < 0 || toner_density > 8) ecode = gs_error_rangecheck; else break; goto tden; default: ecode = code; tden:param_signal_error(plist, param_name, ecode); case 1: break; } if (lips->toner_saving_set >= 0) switch (code = param_read_bool(plist, (param_name = LIPS_OPTION_TONERSAVING), &toner_saving)) { case 0: toner_saving_set = 1; break; default: if ((code = param_read_null(plist, param_name)) == 0) { toner_saving_set = 0; break; } ecode = code; param_signal_error(plist, param_name, ecode); case 1: break; } switch (code = param_read_string(plist, (param_name = LIPS_OPTION_USER_NAME), &usern)) { case 0: if (usern.size > LIPS_USERNAME_MAX) ecode = gs_error_limitcheck; else { /* Check the validity of ``User Name'' characters */ int i; for (i = 0; i < usern.size; i++) if (usern.data[i] < 0x20 || usern.data[i] > 0x7e /* && usern.data[i] < 0xa0) || usern.data[i] > 0xfe */ ) { ecode = gs_error_rangecheck; goto userne; } } break; goto userne; default: ecode = code; userne:param_signal_error(plist, param_name, ecode); case 1: usern.data = 0; break; } if (ecode < 0) return ecode; code = lprn_put_params(pdev, plist); if (code < 0) return code; lips->cassetFeed = cass; lips->pjl = pjl; lips->toner_density = toner_density; lips->toner_saving = toner_saving; lips->toner_saving_set = toner_saving_set; if (usern.data != 0 && bytes_compare(usern.data, usern.size, (const byte *)lips->Username, strlen(lips->Username)) ) { memcpy(lips->Username, usern.data, usern.size); lips->Username[usern.size] = 0; } return 0; } private int lips4_put_params(gx_device * pdev, gs_param_list * plist) { gx_device_lips4 *const lips4 = (gx_device_lips4 *) pdev; int ecode = 0; int code; gs_param_name param_name; gs_param_string pmedia; bool nup = lips4->nup; bool faceup = lips4->faceup; int old_bpp = pdev->color_info.depth; int bpp = 0; switch (code = param_read_int(plist, (param_name = LIPS_OPTION_NUP), &nup)) { case 0: if (nup != 1 && nup != 2 && nup != 4) ecode = gs_error_rangecheck; else break; goto nupe; default: ecode = code; nupe:param_signal_error(plist, param_name, ecode); case 1: break; } if ((code = param_read_bool(plist, (param_name = LIPS_OPTION_FACEUP), &faceup)) < 0) param_signal_error(plist, param_name, ecode = code); switch (code = param_read_string(plist, (param_name = LIPS_OPTION_MEDIATYPE), &pmedia)) { case 0: if (pmedia.size > LIPS_MEDIACHAR_MAX) ecode = gs_error_limitcheck; else { /* Check the validity of ``MediaType'' characters */ if (strcmp(pmedia.data, "PlainPaper") != 0 && strcmp(pmedia.data, "OHP") != 0 && strcmp(pmedia.data, "TransparencyFilm") != 0 && /* same as OHP */ strcmp(pmedia.data, "GlossyFilm") != 0 && strcmp(pmedia.data, "CardBoard") != 0 ) { ecode = gs_error_rangecheck; goto pmediae; } } break; goto pmediae; default: ecode = code; pmediae:param_signal_error(plist, param_name, ecode); case 1: pmedia.data = 0; break; } switch (code = param_read_int(plist, (param_name = "BitsPerPixel"), &bpp)) { case 0: if (bpp != 1 && bpp != 24) ecode = gs_error_rangecheck; else break; goto bppe; default: ecode = code; bppe:param_signal_error(plist, param_name, ecode); case 1: break; } if (bpp != 0) { pdev->color_info.depth = bpp; pdev->color_info.num_components = ((bpp == 1) ? 1 : 3); pdev->color_info.max_gray = (bpp >= 8 ? 255 : 1); pdev->color_info.max_color = (bpp >= 8 ? 255 : bpp > 1 ? 1 : 0); pdev->color_info.dither_grays = (bpp >= 8 ? 5 : 2); pdev->color_info.dither_colors = (bpp >= 8 ? 5 : bpp > 1 ? 2 : 0); dev_proc(pdev, map_rgb_color) = ((bpp == 1) ? gdev_prn_map_rgb_color : gx_default_rgb_map_rgb_color); } if (ecode < 0) return ecode; code = lips_put_params(pdev, plist); if (code < 0) return code; lips4->nup = nup; lips4->faceup = faceup; if (pmedia.data != 0 && bytes_compare(pmedia.data, pmedia.size, (const byte *)lips4->mediaType, strlen(lips4->mediaType)) ) { memcpy(lips4->mediaType, pmedia.data, pmedia.size); lips4->mediaType[pmedia.size] = 0; } if (bpp != 0 && bpp != old_bpp && pdev->is_open) return gs_closedevice(pdev); return 0; } /* ------ Internal routines ------ */ private int lips2p_print_page_copies(gx_device_printer * pdev, FILE * prn_stream, int num_copies) { return lips_print_page_copies(pdev, prn_stream, LIPS2P, num_copies); } private int lips3_print_page_copies(gx_device_printer * pdev, FILE * prn_stream, int num_copies) { return lips_print_page_copies(pdev, prn_stream, LIPS3, num_copies); } #define NUM_LINES 24 /* raster height */ #define NUM_LINES_4C 256 private int lips_print_page_copies(gx_device_printer * pdev, FILE * prn_stream, lips_printer_type ptype, int num_copies) { gx_device_lprn *const lprn = (gx_device_lprn *) pdev; int code = 0; int bpl = gdev_mem_bytes_per_scan_line(pdev); int maxY = lprn->BlockLine / lprn->nBh * lprn->nBh; /* Initialize printer. */ lips_job_start(pdev, ptype, prn_stream, num_copies); if (!(lprn->CompBuf = gs_malloc(bpl * 3 / 2 + 1, maxY, "(CompBuf)"))) return_error(gs_error_VMerror); lprn->NegativePrint = false; /* not support */ lprn->prev_x = lprn->prev_y = 0; code = lprn_print_image(pdev, prn_stream); if (code < 0) return code; gs_free(lprn->CompBuf, bpl * 3 / 2 + 1, maxY, "(CompBuf)"); /* eject page */ lips_job_end(pdev, prn_stream); return 0; } private int bjc880j_print_page_copies(gx_device_printer * pdev, FILE * prn_stream, int num_copies) { return lips4type_print_page_copies(pdev, prn_stream, num_copies, BJC880J); } private int lips4_print_page_copies(gx_device_printer * pdev, FILE * prn_stream, int num_copies) { return lips4type_print_page_copies(pdev, prn_stream, num_copies, LIPS4); } private int lips4type_print_page_copies(gx_device_printer * pdev, FILE * prn_stream, int num_copies, int ptype) { gx_device_lprn *const lprn = (gx_device_lprn *) pdev; int code = 0; int bpl = gdev_mem_bytes_per_scan_line(pdev); int maxY = lprn->BlockLine / lprn->nBh * lprn->nBh; /* Initialize printer. */ lips_job_start(pdev, ptype, prn_stream, num_copies); if (pdev->color_info.depth == 1) { if (!(lprn->CompBuf = gs_malloc(bpl * 3 / 2 + 1, maxY, "(CompBuf)"))) return_error(gs_error_VMerror); if (!(lprn->CompBuf2 = gs_malloc(bpl * 3 / 2 + 1, maxY, "(CompBuf2)"))) return_error(gs_error_VMerror); if (lprn->NegativePrint) { int rm = pdev->width - (dev_l_margin(pdev) + dev_r_margin(pdev)) * pdev->x_pixels_per_inch; int bm = pdev->height - (dev_t_margin(pdev) + dev_b_margin(pdev)) * pdev->y_pixels_per_inch; /* Draw black rectangle */ fprintf(prn_stream, "%c{%c%da%c%de%c;;;3}", LIPS_CSI, LIPS_CSI, rm, LIPS_CSI, bm, LIPS_CSI); fprintf(prn_stream, "%c%dj%c%dk", LIPS_CSI, rm, LIPS_CSI, bm); } lprn->prev_x = lprn->prev_y = 0; code = lprn_print_image(pdev, prn_stream); if (code < 0) return code; gs_free(lprn->CompBuf, bpl * 3 / 2 + 1, maxY, "(CompBuf)"); gs_free(lprn->CompBuf2, bpl * 3 / 2 + 1, maxY, "(CompBuf2)"); } else { code = lips4c_output_page(pdev, prn_stream); if (code < 0) return code; } /* eject page */ lips_job_end(pdev, prn_stream); return 0; } #if 0 /* Send the page to the printer. */ private int lips4c_print_page_copies(gx_device_printer * pdev, FILE * prn_stream, int num_copies) { int code; lips_job_start(pdev, BJC880J, prn_stream, num_copies); /* make output data */ code = lips4c_output_page(pdev, prn_stream); if (code < 0) return code; /* eject page */ lips_job_end(pdev, prn_stream); return 0; } #endif private void move_cap(gx_device_printer * pdev, FILE * prn_stream, int x, int y) { gx_device_lprn *const lprn = (gx_device_lprn *) pdev; if (x != lprn->prev_x) { if (x > lprn->prev_x) fprintf(prn_stream, "%c%da", LIPS_CSI, x - lprn->prev_x); else fprintf(prn_stream, "%c%dj", LIPS_CSI, lprn->prev_x - x); lprn->prev_x = x; } if (y != lprn->prev_y) { if (y > lprn->prev_y) fprintf(prn_stream, "%c%de", LIPS_CSI, y - lprn->prev_y); else fprintf(prn_stream, "%c%dk", LIPS_CSI, lprn->prev_y - y); lprn->prev_y = y; } } private void draw_bubble(FILE * prn_stream, int width, int height) { /* Draw a rectangle */ fprintf(prn_stream, "%c{%c%da%c%de%c}", LIPS_CSI, LIPS_CSI, width, LIPS_CSI, height, LIPS_CSI); fprintf(prn_stream, "%c%dj%c%dk", LIPS_CSI, width, LIPS_CSI, height); } #if 0 /* Non Compression Version of image_out */ private void lips_image_out(gx_device_printer * pdev, FILE * prn_stream, int x, int y, int width, int height) { gx_device_lprn *const lprn = (gx_device_lprn *) pdev; int i, j; byte *p; int maxY = lprn->BlockLine / lprn->nBh * lprn->nBh; move_cap(pdev, prn_stream, x, y); fprintf(prn_stream, "%c%d;%d;%d.r", LIPS_CSI, width / 8 * height, width / 8, (int)pdev->x_pixels_per_inch); for (i = 0; i < height; i++) { p = lprn->ImageBuf + ((i + y) % maxY) * raster; for (j = 0; j < width / 8; j++) { fputc(p[j + data_x], prn_stream); } } if (lprn->ShowBubble) draw_bubble(prn_stream, width, height); } #endif private void lips2p_image_out(gx_device_printer * pdev, FILE * prn_stream, int x, int y, int width, int height) { gx_device_lprn *const lprn = (gx_device_lprn *) pdev; int Len; char raw_str[32]; /* LIPS command header (uncompress) */ char comp_str[32]; /* LIPS command header (compress) */ move_cap(pdev, prn_stream, x, y); Len = lips_mode3format_encode(lprn->TmpBuf, lprn->CompBuf, width / 8 * height); sprintf(raw_str, "%c%d;%d;%d.r", LIPS_CSI, width / 8 * height, width / 8, (int)pdev->x_pixels_per_inch); sprintf(comp_str, "%c%d;%d;%d;9;%d.r", LIPS_CSI, Len, width / 8, (int)pdev->x_pixels_per_inch, height); if (Len < width / 8 * height - strlen(comp_str) + strlen(raw_str)) { fprintf(prn_stream, "%s", comp_str); fwrite(lprn->CompBuf, 1, Len, prn_stream); } else { /* compression result is bad. */ fprintf(prn_stream, "%s", raw_str); fwrite(lprn->TmpBuf, 1, width / 8 * height, prn_stream); } if (lprn->ShowBubble) draw_bubble(prn_stream, width, height); } private void lips4_image_out(gx_device_printer * pdev, FILE * prn_stream, int x, int y, int width, int height) { gx_device_lprn *const lprn = (gx_device_lprn *) pdev; int Len, Len_rle; char raw_str[32]; /* LIPS command header (uncompress) */ char comp_str[32]; /* LIPS command header (compress) */ move_cap(pdev, prn_stream, x, y); Len = lips_packbits_encode(lprn->TmpBuf, lprn->CompBuf, width / 8 * height); Len_rle = lips_rle_encode(lprn->TmpBuf, lprn->CompBuf2, width / 8 * height); sprintf(raw_str, "%c%d;%d;%d.r", LIPS_CSI, width / 8 * height, width / 8, (int)pdev->x_pixels_per_inch); if (Len < Len_rle) { sprintf(comp_str, "%c%d;%d;%d;11;%d.r", LIPS_CSI, Len, width / 8, (int)pdev->x_pixels_per_inch, height); if (Len < width / 8 * height - strlen(comp_str) + strlen(raw_str)) { fprintf(prn_stream, "%s", comp_str); fwrite(lprn->CompBuf, 1, Len, prn_stream); } else { /* compression result is bad. */ fprintf(prn_stream, "%s", raw_str); fwrite(lprn->TmpBuf, 1, width / 8 * height, prn_stream); } } else { sprintf(comp_str, "%c%d;%d;%d;10;%d.r", LIPS_CSI, Len, width / 8, (int)pdev->x_pixels_per_inch, height); if (Len_rle < width / 8 * height - strlen(comp_str) + strlen(raw_str)) { fprintf(prn_stream, "%s", comp_str); fwrite(lprn->CompBuf2, 1, Len, prn_stream); } else { /* compression result is bad. */ fprintf(prn_stream, "%s", raw_str); fwrite(lprn->TmpBuf, 1, width / 8 * height, prn_stream); } } if (lprn->ShowBubble) draw_bubble(prn_stream, width, height); } private int lips4c_write_raster(gx_device_printer * pdev, FILE * prn_stream, byte * pBuff, byte * prevBuff, byte * ComBuff, byte * TotalBuff, byte * diffBuff, int lnum, int raster_height) { int bits_per_pixel = pdev->color_info.depth; int num_components = bits_per_pixel > 8 ? 3 : 1; int nBytesPerLine = gdev_prn_raster(pdev); int Xpixel = nBytesPerLine / num_components; int TotalLen = 0; int num_zerobyte = 0; bool zerobyte_flag = false; int i, y, Len; for (i = 0; i < nBytesPerLine; i++) { *(prevBuff + i) = 0x00; /* initialize */ } for (y = lnum; y < lnum + raster_height; y++) { gdev_prn_copy_scan_lines(pdev, y, pBuff, nBytesPerLine); Len = lips_delta_encode(pBuff, prevBuff, ComBuff, diffBuff, Xpixel * num_components); if (Len == 2 && *ComBuff == 0x01) { if (zerobyte_flag == false) { zerobyte_flag = true; TotalLen = lips_byte_cat(TotalBuff, ComBuff, TotalLen, Len); } else { if (num_zerobyte > 255) { TotalLen = lips_byte_cat(TotalBuff, ComBuff, TotalLen, Len); } else { *(TotalBuff + TotalLen - 1) = num_zerobyte; } num_zerobyte++; } } else { TotalLen = lips_byte_cat(TotalBuff, ComBuff, TotalLen, Len); zerobyte_flag = false; num_zerobyte = 0; } } fprintf(prn_stream, "%c%d;%d;%d;12;%d;;%d;%d;;1.r", LIPS_CSI, TotalLen, Xpixel, (int)pdev->x_pixels_per_inch, raster_height, bits_per_pixel / num_components, num_components < 3 ? 0 : 10); fwrite(TotalBuff, 1, TotalLen, prn_stream); fputc(0x85, prn_stream); /* CR + LF */ return 0; } private int lips4c_output_page(gx_device_printer * pdev, FILE * prn_stream) { byte *pBuff, *ComBuff, *prevBuff, *TotalBuff, *diffBuff; int bits_per_pixel = pdev->color_info.depth; int num_components = bits_per_pixel > 8 ? 3 : 1; int nBytesPerLine = gdev_prn_raster(pdev); int Xpixel = nBytesPerLine / num_components; int lnum = 0; /* Memory Allocate */ if (!(pBuff = (byte *) gs_malloc(nBytesPerLine, sizeof(byte), "lips4c_compress_output_page(pBuff)"))) return_error(gs_error_VMerror); if (!(prevBuff = (byte *) gs_malloc(nBytesPerLine, sizeof(byte), "lips4c_compress_output_page(prevBuff)"))) return_error(gs_error_VMerror); if (!(ComBuff = (byte *) gs_malloc(Xpixel * num_components + (Xpixel * num_components + 127) * 129 / 128, sizeof(byte), "lips4c_compress_output_page(ComBuff)"))) return_error(gs_error_VMerror); if (!(TotalBuff = (byte *) gs_malloc((Xpixel * num_components + (Xpixel * num_components + 127) * 129 / 128) * NUM_LINES_4C, sizeof(byte), "lips4c_compress_output_page(TotalBuff)"))) return_error(gs_error_VMerror); if (!(diffBuff = (byte *) gs_malloc(Xpixel * num_components * 2, sizeof(byte), "lips_print_page"))) return_error(gs_error_VMerror); /* make output data */ while (lnum < pdev->height) { lips4c_write_raster(pdev, prn_stream, pBuff, prevBuff, ComBuff, TotalBuff, diffBuff, lnum, NUM_LINES_4C); lnum += NUM_LINES_4C; } if (pdev->height - (lnum - NUM_LINES_4C) > 0) { lips4c_write_raster(pdev, prn_stream, pBuff, prevBuff, ComBuff, TotalBuff, diffBuff, lnum - NUM_LINES_4C, pdev->height - (lnum - NUM_LINES_4C)); } /* Free Memory */ gs_free(pBuff, nBytesPerLine, sizeof(byte), "lips4c_compress_output_page(pBuff)"); gs_free(prevBuff, nBytesPerLine, sizeof(byte), "lips4c_compress_output_page(prevBuff)"); gs_free(ComBuff, Xpixel * num_components + (Xpixel * num_components + 127) * 129 / 128, sizeof(byte), "lips4c_compress_output_page(ComBuff)"); gs_free(TotalBuff, (Xpixel * num_components + (Xpixel * num_components + 127) * 129 / 128) * NUM_LINES_4C, sizeof(byte), "lips4c_compress_output_page(TotalBuff)"); gs_free(diffBuff, Xpixel * num_components * 2, sizeof(byte), "lips_print_page"); return 0; } private void lips_job_start(gx_device_printer * pdev, lips_printer_type ptype, FILE * prn_stream, int num_copies) { gx_device_lips *const lips = (gx_device_lips *) pdev; gx_device_lips4 *const lips4 = (gx_device_lips4 *) pdev; int prev_paper_size, prev_paper_width, prev_paper_height, paper_size; int width = pdev->MediaSize[0]; int height = pdev->MediaSize[1]; int tm, lm, rm, bm; if (pdev->PageCount == 0) { if (lips->pjl) { fprintf(prn_stream, "%c%%-12345X@PJL CJLMODE\n" "@PJL JOB\n", LIPS_ESC); if (ptype == LIPS4) { fprintf(prn_stream, "%c%%-12345X@PJL CJLMODE\n", LIPS_ESC); if ((int)pdev->x_pixels_per_inch == 1200) fprintf(prn_stream, "@PJL SET RESOLUTION = SUPERFINE\n"); else if ((int)pdev->x_pixels_per_inch == 600) fprintf(prn_stream, "@PJL SET RESOLUTION = FINE\n"); else if ((int)pdev->x_pixels_per_inch == 300) fprintf(prn_stream, "@PJL SET RESOLUTION = QUICK\n"); } if (lips->toner_density) fprintf(prn_stream, "@PJL SET TONER-DENSITY=%d\n", lips->toner_density); if (lips->toner_saving_set) { fprintf(prn_stream, "@PJL SET TONER-SAVING="); if (lips->toner_saving) fprintf(prn_stream, "ON\n"); else fprintf(prn_stream, "OFF\n"); } fprintf(prn_stream, "@PJL SET LPARM : LIPS SW2 = ON\n" "@PJL ENTER LANGUAGE = LIPS\n"); } fprintf(prn_stream, "%c%%@", LIPS_ESC); if (ptype == LIPS2P) fprintf(prn_stream, "%c21;%d;0J" LIPS2P_STRING LIPS_VERSION "%c", LIPS_DCS, (int)pdev->x_pixels_per_inch, LIPS_ST); else if (ptype == LIPS3) fprintf(prn_stream, "%c31;%d;0J" LIPS3_STRING LIPS_VERSION "%c", LIPS_DCS, (int)pdev->x_pixels_per_inch, LIPS_ST); else if (ptype == LIPS4) fprintf(prn_stream, "%c41;%d;0J" LIPS4_STRING LIPS_VERSION "%c", LIPS_DCS, (int)pdev->x_pixels_per_inch, LIPS_ST); else if (ptype == BJC880J) fprintf(prn_stream, "%c41;%d;0J" BJC880J_STRING LIPS_VERSION "%c", LIPS_DCS, (int)pdev->x_pixels_per_inch, LIPS_ST); if (ptype == LIPS4 || ptype == BJC880J) { if (pdev->color_info.depth == 24) fprintf(prn_stream, "%c1\"p", LIPS_CSI); else fprintf(prn_stream, "%c0\"p", LIPS_CSI); } fprintf(prn_stream, "%c<", LIPS_ESC); fprintf(prn_stream, "%c11h", LIPS_CSI); /* Size Unit Mode */ } /* */ /* Print Environment Setting */ /* */ /* Media Selection */ paper_size = lips_media_selection(width, height); if (ptype == BJC880J) { /* Paint Memory Mode Setting */ /* for BJC-680J/BJC-880J */ if (paper_size == B4_SIZE || paper_size == B4_SIZE + LANDSCAPE || paper_size == LEGAL_SIZE || paper_size == LEGAL_SIZE + LANDSCAPE) /* for BJC-880J */ fprintf(prn_stream, "%c3&z", LIPS_CSI); else if (paper_size == A3_SIZE || paper_size == A3_SIZE + LANDSCAPE || paper_size == LEDGER_SIZE || paper_size == LEDGER_SIZE + LANDSCAPE) /* for BJC-880J */ fprintf(prn_stream, "%c4&z", LIPS_CSI); else fprintf(prn_stream, "%c2&z", LIPS_CSI); } if (ptype == LIPS4) { if (strcmp(lips4->mediaType, "PlainPaper") == 0) fprintf(prn_stream, "%c20\'t", LIPS_CSI); else if (strcmp(lips4->mediaType, "OHP") == 0 || strcmp(lips4->mediaType, "TransparencyFilm") == 0) fprintf(prn_stream, "%c40\'t", LIPS_CSI); /* OHP mode (for LBP-2160) */ else if (strcmp(lips4->mediaType, "CardBoard") == 0) fprintf(prn_stream, "%c30\'t", LIPS_CSI); /* CardBoard mode (for LBP-2160) */ else if (strcmp(lips4->mediaType, "GlossyFilm") == 0) fprintf(prn_stream, "%c41\'t", LIPS_CSI); /* GlossyFile mode (for LBP-2160) */ } if (ptype == LIPS4 || ptype == BJC880J) { if (lips4->ManualFeed || (strcmp(lips4->mediaType, "PlainPaper") != 0 && strcmp(lips4->mediaType, LIPS_MEDIATYPE_DEFAULT) != 0)) { if (lips->prev_feed_mode != 10) fprintf(prn_stream, "%c10q", LIPS_CSI); lips->prev_feed_mode = 10; } else { if (lips->prev_feed_mode != lips->cassetFeed) fprintf(prn_stream, "%c%dq", LIPS_CSI, lips->cassetFeed); lips->prev_feed_mode = lips->cassetFeed; } } else if (lips->ManualFeed) { /* Use ManualFeed */ if (lips->prev_feed_mode != 1) fprintf(prn_stream, "%c1q", LIPS_CSI); lips->prev_feed_mode = 1; } else { if (lips->prev_feed_mode != lips->cassetFeed) fprintf(prn_stream, "%c%dq", LIPS_CSI, lips->cassetFeed); lips->prev_feed_mode = lips->cassetFeed; } /* Use Verious Paper Size */ prev_paper_size = lips->prev_paper_size; prev_paper_width = lips->prev_paper_width; prev_paper_height = lips->prev_paper_height; if (prev_paper_size != paper_size) { if (paper_size == USER_SIZE) { fprintf(prn_stream, "%c2 I", LIPS_CSI); fprintf(prn_stream, "%c80;%d;%dp", LIPS_CSI, /* modified by shige 06/27 2003 width * 10, height * 10); */ /* modified by shige 11/09 2003 height * 10, width * 10); */ (height * 10 > LIPS_HEIGHT_MAX_720)? LIPS_HEIGHT_MAX_720 : (height * 10), (width * 10 > LIPS_WIDTH_MAX_720)? LIPS_WIDTH_MAX_720 : (width * 10)); } else if (paper_size == USER_SIZE + LANDSCAPE) { fprintf(prn_stream, "%c2 I", LIPS_CSI); fprintf(prn_stream, "%c81;%d;%dp", LIPS_CSI, /* modified by shige 06/27 2003 width * 10, height * 10); */ /* modified by shige 11/09 2003 width * 10, height * 10); */ (width * 10 > LIPS_HEIGHT_MAX_720)? LIPS_HEIGHT_MAX_720 : (width * 10), (height * 10 > LIPS_WIDTH_MAX_720)? LIPS_WIDTH_MAX_720 : (height * 10)); } else { fprintf(prn_stream, "%c%dp", LIPS_CSI, paper_size); } } else if (paper_size == USER_SIZE) { if (prev_paper_width != width || prev_paper_height != height) { fprintf(prn_stream, "%c2 I", LIPS_CSI); fprintf(prn_stream, "%c80;%d;%dp", LIPS_CSI, /* modified by shige 06/27 2003 width * 10, height * 10); */ /* modified by shige 11/09 2003 height * 10, width * 10); */ (height * 10 > LIPS_HEIGHT_MAX_720)? LIPS_HEIGHT_MAX_720 : (height * 10), (width * 10 > LIPS_WIDTH_MAX_720)? LIPS_WIDTH_MAX_720 : (width * 10)); } } else if (paper_size == USER_SIZE + LANDSCAPE) { if (prev_paper_width != width || prev_paper_height != height) { fprintf(prn_stream, "%c2 I", LIPS_CSI); fprintf(prn_stream, "%c81;%d;%dp", LIPS_CSI, /* modified by shige 06/27 2003 height * 10, width * 10); */ /* modified by shige 11/09 2003 width * 10, height * 10); */ (width * 10 > LIPS_HEIGHT_MAX_720)? LIPS_HEIGHT_MAX_720 : (width * 10), (height * 10 > LIPS_WIDTH_MAX_720)? LIPS_WIDTH_MAX_720 : (height * 10)); } } /* desired number of copies */ if (num_copies > 255) num_copies = 255; if (lips->prev_num_copies != num_copies) { fprintf(prn_stream, "%c%dv", LIPS_CSI, num_copies); lips->prev_num_copies = num_copies; } if (ptype == LIPS4) { if (lips4->faceup) fprintf(prn_stream, "%c11;12;12~", LIPS_CSI); } if (ptype == LIPS4) { if (pdev->PageCount == 0) { /* N-up Printing */ if (lips4->nup != 1) { fprintf(prn_stream, "%c%d1;;%do", LIPS_CSI, lips4->nup, paper_size); } } /* Duplex mode */ { bool dup = lips4->Duplex; int dupset = lips4->Duplex_set; bool tum = lips4->Tumble; if (dupset && dup) { if (lips4->prev_duplex_mode == 0 || lips4->prev_duplex_mode == 1) fprintf(prn_stream, "%c2;#x", LIPS_CSI); /* duplex */ if (!tum) { /* long edge binding */ if (lips4->prev_duplex_mode != 2) fprintf(prn_stream, "%c0;#w", LIPS_CSI); lips4->prev_duplex_mode = 2; } else { /* short edge binding */ if (lips4->prev_duplex_mode != 3) fprintf(prn_stream, "%c2;#w", LIPS_CSI); lips4->prev_duplex_mode = 3; } } else if (dupset && !dup) { if (lips4->prev_duplex_mode != 1) fprintf(prn_stream, "%c0;#x", LIPS_CSI); /* simplex */ lips4->prev_duplex_mode = 1; } } } if (pdev->PageCount == 0) { /* Display text on printer panel */ fprintf(prn_stream, "%c2y%s%c", LIPS_DCS, lips->Username, LIPS_ST); fprintf(prn_stream, "%c11h", LIPS_CSI); /* Size Unit Mode */ fprintf(prn_stream, "%c?2;3h", LIPS_CSI); /* 2: Disable Auto FF */ /* 3: Disable Auto CAP Movement */ fprintf(prn_stream, "%c?1;4;5;6l", LIPS_CSI); /* 1: Disable Auto NF */ /* 4: Disable Auto LF at CR */ /* 5: Disable Auto CR at LF */ /* 6: Disable Auto CR at FF */ } if (prev_paper_size != paper_size || paper_size == USER_SIZE || paper_size == USER_SIZE + LANDSCAPE) { if (ptype == LIPS4 || ptype == BJC880J) { fprintf(prn_stream, "%c?7;%d I", LIPS_CSI, (int)pdev->x_pixels_per_inch); /* SelectSizeUnit */ } else { fprintf(prn_stream, "%c7 I", LIPS_CSI); /* SelectSizeUnit */ } if (ptype == LIPS4 || ptype == BJC880J) { if (pdev->color_info.depth == 24) fprintf(prn_stream, "%c%d G", LIPS_CSI, NUM_LINES_4C); /* VMI (dots) */ else fprintf(prn_stream, "%c%d G", LIPS_CSI, NUM_LINES); /* VMI (dots) */ } } if (prev_paper_size != paper_size) { /* Top Margin: 63/300 inch + 5 mm */ tm = (63. / 300. + 5. / MMETER_PER_INCH - dev_t_margin(pdev)) * pdev->x_pixels_per_inch; if (tm > 0) fprintf(prn_stream, "%c%dk", LIPS_CSI, tm); if (tm < 0) fprintf(prn_stream, "%c%de", LIPS_CSI, -tm); /* Left Margin: 5 mm left */ lm = (5. / MMETER_PER_INCH - dev_l_margin(pdev)) * pdev->x_pixels_per_inch; if (lm > 0) fprintf(prn_stream, "%c%dj", LIPS_CSI, lm); if (lm < 0) fprintf(prn_stream, "%c%da", LIPS_CSI, -lm); /* Set Top/Left Margins */ fprintf(prn_stream, "%c0;2t", LIPS_CSI); /* Bottom Margin: height */ bm = pdev->height - (dev_t_margin(pdev) + dev_b_margin(pdev)) * pdev->y_pixels_per_inch; fprintf(prn_stream, "%c%de", LIPS_CSI, bm); /* Right Margin: width */ rm = pdev->width - (dev_l_margin(pdev) + dev_r_margin(pdev)) * pdev->x_pixels_per_inch; fprintf(prn_stream, "%c%da", LIPS_CSI, rm); fprintf(prn_stream, "%c1;3t", LIPS_CSI); /* move CAP to (0, 0) */ fprintf(prn_stream, "%c%dk\r", LIPS_CSI, bm); } lips->prev_paper_size = paper_size; lips->prev_paper_width = width; lips->prev_paper_height = height; } private void lips_job_end(gx_device_printer * pdev, FILE * prn_stream) { /* Paper eject command */ fprintf(prn_stream, "\r%c", LIPS_FF); } private int lips_delta_compress(byte * inBuff, byte * prevBuff, byte * diffBuff, int Length); private int lips_delta_encode(byte * inBuff, byte * prevBuff, byte * outBuff, byte * diffBuff, int Length) { int i, j, k, com_size; com_size = lips_delta_compress(inBuff, prevBuff, diffBuff, Length); if (com_size < 0) { /* data is white raster */ *outBuff = 0x01; *(outBuff + 1) = 0000; for (k = 0; k < Length; k++) *(prevBuff + k) = 0000; return 2; } else if (com_size == 0) { /* data is the same raster */ *outBuff = 0000; return 1; } for (i = 0; i < com_size / 255; i++) { *(outBuff + i) = 0377; } *(outBuff + i) = (byte) (com_size % 255); for (j = 0; j < com_size; j++) { *(outBuff + i + j + 1) = *(diffBuff + j); } for (k = 0; k < Length; k++) *(prevBuff + k) = *(inBuff + k); return i + j + 1; } private int lips_delta_compress(byte * inBuff, byte * prevBuff, byte * diffBuff, int Length) { int i, j; bool zero_flag = TRUE; bool same_flag = TRUE; int num_bytes = 0; int num_commandbyte = 0; int size = 0; int offset = 0; for (i = 0; i < Length; i++) { if (*(inBuff + i) != 0x00) zero_flag = FALSE; /* Compare Buffer */ if (*(inBuff + i) != *(prevBuff + i)) { num_bytes++; if (same_flag == TRUE) { /* first byte is offset */ if (offset > 31) *(diffBuff + size) = 0037; else *(diffBuff + size) = offset; size++; num_commandbyte++; for (j = 0; j < (offset - 31) / 255; j++) { *(diffBuff + size) = 0377; size++; num_commandbyte++; } if ((offset - 31) % 255 >= 0) { *(diffBuff + size) = (offset - 31) % 255; size++; num_commandbyte++; } same_flag = FALSE; } } else { same_flag = TRUE; offset++; } if (num_bytes > 8) { /* write number of data for replace */ *(diffBuff + size - num_commandbyte) = *(diffBuff + size - num_commandbyte) | 0340; for (j = 0; j < 8; j++, size++) { *(diffBuff + size) = *(inBuff + i + j - 8); } /* offset is 0 */ *(diffBuff + size) = 0000; size++; num_bytes = 1; same_flag = FALSE; num_commandbyte = 1; } else if (same_flag == true && num_bytes > 0) { offset = 1; /* write number of data for replace */ *(diffBuff + size - num_commandbyte) = *(diffBuff + size - num_commandbyte) | ((num_bytes - 1) << 5); /* write a different bytes */ for (j = 0; j < num_bytes; j++, size++) { *(diffBuff + size) = *(inBuff + i + j - num_bytes); } num_bytes = 0; num_commandbyte = 0; } } if (num_bytes > 0) { /* write number of data for replace */ *(diffBuff + size - num_commandbyte) = *(diffBuff + size - num_commandbyte) | ((num_bytes - 1) << 5); for (j = 0; j < num_bytes; j++, size++) { *(diffBuff + size) = *(inBuff + i + j - num_bytes); } } if (zero_flag) return -1; return size; } /* This routine work like ``strcat'' */ private int lips_byte_cat(byte * TotalBuff, byte * Buff, int TotalLen, int Len) { int i; for (i = 0; i < Len; i++) *(TotalBuff + TotalLen + i) = *(Buff + i); return TotalLen + Len; }