[patch] Path to put in the files/ subdirectory, adds Samsung GDI support

ghostscript-7.05.3-samsunggdi.diff (text/plain), 44.48 KB, created by Ray Heasman on 2002-09-12 10:48:20 UTC

diff -urN ghostscript-7.05.3-r1/work/espgs-7.05.3/Makefile.in master/work/espgs-7.05.3/Makefile.in
--- ghostscript-7.05.3-r1/work/espgs-7.05.3/Makefile.in	2002-04-23 08:18:45.000000000 -0700
+++ master/work/espgs-7.05.3/Makefile.in	2002-09-11 16:47:15.000000000 -0700
@@ -359,7 +359,7 @@
 DEVICE_DEVS3=@FILES@
 DEVICE_DEVS4=@PRINTERS@
 DEVICE_DEVS5=
-DEVICE_DEVS6=
+DEVICE_DEVS6=$(DD)gdi.dev
 DEVICE_DEVS7=
 DEVICE_DEVS8=
 DEVICE_DEVS9=
diff -urN ghostscript-7.05.3-r1/work/espgs-7.05.3/src/devs.mak master/work/espgs-7.05.3/src/devs.mak
--- ghostscript-7.05.3-r1/work/espgs-7.05.3/src/devs.mak	2002-04-23 04:58:38.000000000 -0700
+++ master/work/espgs-7.05.3/src/devs.mak	2002-09-11 16:46:34.000000000 -0700
@@ -15,6 +15,8 @@
 
 # $Id: devs.mak,v 1.6 2002/04/23 11:58:38 easysw Exp $
 # makefile for Aladdin's device drivers.
+# Modified April 12, 2002 to include support for Samsung SmartGDI printers.
+# Ramon Medina <[e-mail]>
 
 # Define the name of this makefile.
 DEVS_MAK=$(GLSRC)devs.mak
@@ -644,6 +646,20 @@
 # library.
 
 
+### ---------------- The Samsung SmartGDI laser printer devices --------- ###
+### Note : this driver is used by Samsung SmartGDI compatible printers.   ###
+###
+
+GDIMONO=$(GLOBJ)gdevgdi.$(OBJ) $(HPPCL)
+
+$(DD)gdi.dev : $(GDIMONO) $(GLD)page.dev
+	$(SETPDEV) $(DD)gdi $(GDIMONO)
+
+$(GLOBJ)gdevgdi.$(OBJ) : $(GLSRC)gdevgdi.c $(PDEVH) $(gdevpcl_h)
+	$(GLCC) $(GLO_)gdevgdi.$(OBJ) $(C_) $(GLSRC)gdevgdi.c
+
+
+
 ###### ------------------- High-level file formats ------------------- ######
 
 # Support for PostScript and PDF
diff -urN ghostscript-7.05.3-r1/work/espgs-7.05.3/src/gdevgdi.c master/work/espgs-7.05.3/src/gdevgdi.c
--- ghostscript-7.05.3-r1/work/espgs-7.05.3/src/gdevgdi.c	1969-12-31 16:00:00.000000000 -0800
+++ master/work/espgs-7.05.3/src/gdevgdi.c	2002-09-11 16:46:34.000000000 -0700
@@ -0,0 +1,1398 @@
+/*
+  This file is part of GNU Ghostscript.
+  
+  GNU Ghostscript 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 GNU
+  Ghostscript, 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 GNU Ghostscript 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.
+  
+  Aladdin Enterprises is not affiliated with the Free Software Foundation or
+  the GNU Project.  GNU Ghostscript, as distributed by Aladdin Enterprises,
+  does not depend on any other GNU software.
+*/
+
+/* gdevgdi.c */
+/* SAMSUNG GDI driver for Ghostscript */
+#include "gdevprn.h"
+#include "gdevpcl.h"
+
+
+/*
+ * You may select a default resolution of 300 or 600 DPI
+ * in the makefile, or an actual resolution
+ * on the gs command line.
+ *
+ * If the preprocessor symbol A4 is defined, the default paper size is
+ * the European A4 size; otherwise it is the U.S. letter size (8.5"x11").
+ *
+ * To determine the proper "margin" settings for your printer, see the
+ * file align.ps.
+ */
+
+/* Define the default, maximum resolutions. */
+#ifdef X_DPI
+#  define X_DPI2 X_DPI
+#else
+#  define X_DPI 300
+#  define X_DPI2 600
+#endif
+#ifdef Y_DPI
+#  define Y_DPI2 Y_DPI
+#else
+#  define Y_DPI 300
+#  define Y_DPI2 600
+#endif
+
+#define GDI_FALSE 0
+#define GDI_TRUE  1
+#define GDI_MAX_COUNT     31
+#define GDI_NO_REPEAT_IDX 0x80000000L
+#define GDI_DATA_LENGTH   11
+#define GDI_REPEAT_LENGTH 2
+#define GDI_BAND_HEIGHT   128
+#define GDI_MAX_BAND      66
+//#define GDI_BAND_WIDTH    4928
+//#define GDI_BAND_WIDTH_BYTES (((GDI_BAND_WIDTH + 31)/32)*4)
+
+#define GDI_PRE_COMP      2
+#define GDI_REAL_COMP     0
+
+#define GDI_COMP_NONE     0
+#define GDI_COMP_TIFF     3
+#define GDI_COMP_SCANLINE 4
+#define GDI_COMP_MODITIFF 6
+#define GDI_COMP_NOSEND   0x7f
+
+#define GDI_MARGINS_A4	        0.167, 0.167, 0.167, 0.167
+#define GDI_MARGINS_LETTER	0.167, 0.167, 0.167, 0.167
+//#define GDI_MARGINS_A4	0.0, 0.0, 0.0, 0.0
+//#define GDI_MARGINS_LETTER	0.0, 0.0, 0.0, 0.0
+
+/* The number of blank lines that make it worthwhile to reposition */
+/* the cursor. */
+#define MIN_SKIP_LINES 7
+
+/* We round up the LINE_SIZE to a multiple of a unsigned long for faster scanning. */
+#define W sizeof(word)
+
+int GDI_BAND_WIDTH[] = {4768, 4928};
+
+private int gdi_print_page(P2(gx_device_printer *pdev, FILE *prn_stream));
+private int gdi_open(P1(gx_device *pdev));
+private int gdi_close(P1(gx_device *pdev));
+
+/* The device descriptors */
+private dev_proc_open_device(gdi_open);
+private dev_proc_close_device(gdi_close);
+private dev_proc_print_page(gdi_print_page);
+
+private gx_device_procs prn_gdi_procs =
+    prn_params_procs(gdi_open, gdev_prn_output_page, gdi_close,
+		   gdev_prn_get_params, gdev_prn_put_params);
+
+gx_device_printer far_data gs_gdi_device =
+  prn_device(prn_gdi_procs, "gdi",
+	DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS, /* paper size (unit : 10/72 inch size) */
+	X_DPI2, Y_DPI2,
+	0.20, 0.25, 0.25, 0.25,		/* margins filled in by gdi_open */
+	1,                      /* color bit */ 
+        gdi_print_page);
+
+private FILE *WritePJLHeaderData(gx_device_printer *pdev, FILE *fp);
+private FILE *WriteBandHeader(FILE *fp, unsigned int usBandNo, 
+                     unsigned char ubCompMode, unsigned int usBandWidth, 
+                     unsigned int usBandHeight, unsigned long ulBandSize);
+private FILE *WriteTrailerData(FILE *fp);
+private unsigned long FrameTiffComp(unsigned char *pubDest, unsigned char *pubSrc, 
+                               unsigned int usTotalLines, unsigned int usBytesPerLine, 
+                               unsigned char ubMode);
+private unsigned int  FrameTiff_Comp(unsigned char *lpSrcBuf, unsigned char *lpTgtBuf, 
+                               unsigned int nSrcBytes);
+private unsigned int  PreTiffComp(unsigned char *lpSrcBuf, unsigned int nSrcBytes);
+private long bmp2run(unsigned char *out_buf, unsigned char *in_buf, unsigned int sizeY, unsigned int sizeX, unsigned char ubMode);
+
+#define ppdev ((gx_device_printer *)pdev)
+
+/* Open the printer, adjusting the margins if necessary. */
+private int
+gdi_open(gx_device *pdev)
+{	/* Change the margins if necessary. */
+	const float *m = 0;
+	bool move_origin = true;
+
+	static const float m_a4[4] = { GDI_MARGINS_A4 };
+	static const float m_letter[4] = { GDI_MARGINS_LETTER };
+	m = (gdev_pcl_paper_size(pdev) == PAPER_SIZE_A4 ? m_a4 :
+	     m_letter);
+	move_origin = false;
+	
+	if ( m != 0 )
+	  gx_device_set_margins(pdev, m, move_origin);
+
+	return gdev_prn_open(pdev);
+}
+
+/* gdi_close is only here to eject odd numbered pages in duplex mode. */
+private int
+gdi_close(gx_device *pdev)
+{	if ( ppdev->Duplex_set >= 0 && ppdev->Duplex )
+	  {	gdev_prn_open_printer(pdev, 1);
+		fputs("\033&l0H", ppdev->file) ;
+	  }
+	return gdev_prn_close(pdev);
+}
+
+#undef ppdev
+
+/* ------ Internal routines ------ */
+
+/* Samsung SmartGDI series compresses, and it needs a special sequence to */
+/* allow it to specify coordinates at 600 dpi. */
+/* It too needs its coordinate system translated slightly. */
+
+private int
+gdi_print_page(gx_device_printer *pdev, FILE *prn_stream)
+{
+        int band_width_bytes;
+        int band_height;
+        int code=0, i, j, y, num_rows=0, band_num=0;
+        int dots_per_inch = (int)pdev->y_pixels_per_inch;
+        int raster = gx_device_raster((gx_device *)pdev, true);
+        int real_line_width;
+        long ul_band_size, ul_comp_size, ul_tiff_size, ul_min_size;
+        byte *ibp=NULL, *obp=NULL, *tmp=NULL;
+	byte paper_type=0, compression_type;
+
+        switch (gdev_pcl_paper_size((gx_device*)pdev))
+	{
+	    case PAPER_SIZE_A4 :     paper_type = 0;
+	                             break;
+	    case PAPER_SIZE_LETTER : paper_type = 1;
+	                             break;
+	    case PAPER_SIZE_LEGAL :  paper_type = 1;
+	                             break;
+	    default:
+	                             paper_type = 1;
+				     break;
+	}
+	if (dots_per_inch == 600) { /* 600dpi */
+            band_width_bytes = (GDI_BAND_WIDTH[paper_type]+31)/32*4;
+            band_height      = GDI_BAND_HEIGHT;
+	} else {                    /* 300dpi */
+            band_width_bytes = (GDI_BAND_WIDTH[paper_type]+31)/32*4/2;
+            band_height      = GDI_BAND_HEIGHT*2;
+	}
+
+        ul_band_size = band_width_bytes * band_height;
+        ibp = (byte *)gs_malloc(ul_band_size, 1, "gdi_print_page");
+        obp = (byte *)gs_malloc(ul_band_size*13/10, 1, "gdi_print_page");
+        tmp = (byte *)gs_malloc(raster, 1, "gdi_print_page");
+
+        if (!ibp) return_error(gs_error_VMerror);
+        if (!obp) return_error(gs_error_VMerror);
+        if (!tmp) return_error(gs_error_VMerror);
+
+        if (ibp ==0 || obp == 0) return_error(gs_error_VMerror);
+
+        /* Header Output */
+        prn_stream = WritePJLHeaderData(pdev, prn_stream);
+        num_rows = dev_print_scan_lines(pdev);
+        band_num = (num_rows + band_height -1)/band_height;
+
+        if (raster > band_width_bytes)
+            real_line_width = band_width_bytes;
+        else 
+            real_line_width = raster;
+        
+        /* Real Data Output */ 
+	y = 0;
+        for (i=0; i< band_num; i++) {
+            memset(ibp, 0x00, ul_band_size);
+            memset(obp, 0x00, ul_band_size*13/10);
+            for (j=0; j<band_height; j++) {
+                memset(tmp, 0x00, raster);
+                //code = gdev_prn_copy_scan_lines(pdev, i*band_height+j, 
+		if (y == num_rows) break;
+                code = gdev_prn_copy_scan_lines(pdev, y++, 
+                                 (byte*)tmp, raster);
+                if (code < 0) break;
+                memcpy(ibp+j*band_width_bytes, tmp, real_line_width);
+            }
+
+	    if ( i>= GDI_MAX_BAND) continue;
+
+            /* Write Band Data 
+	       Because of Scanline compression, extract Scanline compression mode */
+            //ul_tiff_size = FrameTiffComp(obp, ibp, band_height, band_width_bytes, GDI_PRE_COMP);
+            //ul_scan_size = (unsigned long)bmp2run(obp, ibp, band_height, band_width_bytes, GDI_PRE_COMP);
+	    //ul_min_size =  (ul_scan_size > ul_tiff_size) ? ul_tiff_size : ul_scan_size;
+	    ul_min_size = ul_tiff_size;
+	    compression_type = GDI_COMP_MODITIFF;
+	    //compression_type =  (ul_scan_size > ul_tiff_size) ? GDI_COMP_MODITIFF : GDI_COMP_SCANLINE;
+            switch (compression_type) {
+	    case GDI_COMP_MODITIFF:
+                ul_comp_size = FrameTiffComp(obp, ibp, band_height, band_width_bytes, GDI_REAL_COMP);
+		break;
+	    case GDI_COMP_SCANLINE:
+                ul_comp_size = bmp2run(obp, ibp, band_height, band_width_bytes, GDI_REAL_COMP);
+	        break;
+	    default:
+                ul_comp_size = FrameTiffComp(obp, ibp, band_height, band_width_bytes, GDI_REAL_COMP);
+		compression_type = GDI_COMP_MODITIFF;
+		break;
+	    }
+
+            prn_stream = WriteBandHeader(prn_stream, i, compression_type, (band_width_bytes * 8),
+                                         band_height, ul_comp_size); 
+            //fprintf(prn_stream, "[%d] band, size : %d\n", i, ul_tiff_size);
+            fwrite(obp, ul_comp_size, 1, prn_stream);
+        }
+    
+        /* Trailer Output */
+        WriteTrailerData(prn_stream);
+        gs_free(ibp, ul_band_size, 1, "gdi_line_buffer");
+        gs_free(obp, ul_band_size*13/10, 1, "gdi_line_buffer");
+        gs_free(tmp, raster, 1, "gdi_line_buffer");
+        return code;
+}
+
+FILE *WritePJLHeaderData(gx_device_printer *pdev, FILE *fp)
+{
+  unsigned long ulSize;
+  unsigned char buffer[300];
+  int dots_per_inch = (int)pdev->y_pixels_per_inch;
+
+  strcpy(buffer, "\x1b%-12345X");
+  
+  // Paper Type
+  strcat(buffer, "@PJL SET PAPERTYPE = NORMAL ON\x0d\x0a");
+  //Density
+  strcat(buffer, "@PJL SET DENSITY = 1\x0d\x0a");
+  // Toner Save
+  strcat(buffer, "@PJL SET TONERSAVE = OFF\x0d\x0a");
+  // Enter Language SMART
+  strcat(buffer, "@PJL ENTER LANGUAGE = SMART\x0d\x0a");
+  // JobStart
+  strcat(buffer, "$PJL JOB START\x0d\x0a");
+
+  // Resolution
+  if (dots_per_inch == 600)
+      strcat(buffer, "$PJL RESOLUTION = 600\x0d\x0a");
+  else
+      strcat(buffer, "$PJL RESOLUTION = 300\x0d\x0a");
+
+  // Copies
+  strcat(buffer, "$PJL COPIES = 1\x0d\x0a");
+  // Paper Size
+  switch (gdev_pcl_paper_size((gx_device*)pdev)) 
+  {
+	case PAPER_SIZE_A4:
+  			strcat(buffer, "$PJL PAGE A4 AUTO\x0d\x0a");
+			break;
+	case PAPER_SIZE_LETTER:
+  			strcat(buffer, "$PJL PAGE LETTER AUTO\x0d\x0a");
+			break;
+	case PAPER_SIZE_LEGAL:
+  			strcat(buffer, "$PJL PAGE LEGAL AUTO\x0d\x0a");
+			break;
+	default:
+  			strcat(buffer, "$PJL PAGE LETTER AUTO\x0d\x0a");
+			break;
+  }
+  // bitmap start
+  strcat(buffer, "$PJL BITMAP START\x0d\x0a");
+  // write buffer to file.
+  ulSize = strlen(buffer);
+  fwrite(buffer, 1, ulSize, fp );
+  return(fp);
+} // WritePJLHeaderData()     
+
+
+FILE *WriteBandHeader
+(
+FILE *fp,
+unsigned int  usBandNo,
+unsigned char ubCompMode,
+unsigned int  usBandWidth,
+unsigned int  usBandHeight,
+unsigned long ulBandSize
+)
+{
+  unsigned char ubLeft=0;
+  unsigned int i = 0;
+  unsigned char buf[50];
+
+  memset(buf, 0x00, 50);
+
+  ulBandSize += 8;
+
+  // bandsize
+  buf[i++] = (unsigned char)((ulBandSize >> 24) & 0xff);
+  buf[i++] = (unsigned char)((ulBandSize >> 16) & 0xff);
+  buf[i++] = (unsigned char)((ulBandSize >> 8) & 0xff);
+  buf[i++] = (unsigned char)(ulBandSize & 0xff);
+  
+  // id                            
+  buf[i++] = (unsigned char)((usBandNo >> 8) & 0xff);
+  buf[i++] = (unsigned char)(usBandNo & 0xff);
+
+  // compress mode         
+  buf[i++] = (unsigned char)(ubCompMode & 0xff);
+
+  // ubLeft                  
+  buf[i++] = (unsigned char)(ubLeft & 0xff);
+
+  // height
+  buf[i++] = (unsigned char)((usBandHeight >> 8) & 0xff);
+  buf[i++] = (unsigned char)(usBandHeight & 0xff);
+
+  // width                     
+  buf[i++] = (unsigned char)((usBandWidth >> 8) & 0xff);
+  buf[i++] = (unsigned char)(usBandWidth & 0xff);
+
+  fwrite(buf, 1, i, fp);
+  return(fp);
+} // end of WriteBandHeader()
+
+FILE *WriteTrailerData(FILE *fp)
+{
+  unsigned long ulSize;
+  unsigned long buffer[200];
+
+  memset((char*)buffer, 0x00, 200);
+  strcpy((char*)buffer, "$PJL PRINT 4\x0d\x0a");
+  strcat((char*)buffer, "$PJL EOJ\x0d\x0a");
+  strcat((char*)buffer, "$PJL SYNC\x0d\x0a");
+  strcat((char*)buffer, "$PJL RELEASE 0 2047\x0d\x0a");
+  strcat((char*)buffer, "$PJL GARBAGE\x0d\x0a");
+  strcat((char*)buffer, "\x1b%-12345X\x0d\x0a");
+
+  ulSize = strlen((char*)buffer);
+  fwrite(buffer, 1, ulSize, fp);
+
+  return(fp);
+} // WriteTrailerData()
+
+unsigned long FrameTiffComp(unsigned char *pubDest, 
+                            unsigned char *pubSrc, 
+                            unsigned int usTotalLines, 
+                            unsigned int usBytesPerLine,
+                            unsigned char ubMode)
+{
+  unsigned char *TgtPtr, *SrcPtr;
+  unsigned int  usLineSize;
+  unsigned long ulret;
+  unsigned int  i;
+
+  SrcPtr = pubSrc;
+  TgtPtr = pubDest;
+  ulret = 0;
+
+  for (i = 0; i < usTotalLines; i++)
+  {
+    if (!(ubMode & 0x02)) //
+    {
+      usLineSize = FrameTiff_Comp(SrcPtr, TgtPtr, usBytesPerLine);
+    }
+    else
+    {
+      if(i == 0x253)
+      {
+        i = i;
+      }
+      usLineSize = PreTiffComp(SrcPtr, usBytesPerLine);
+    }
+    SrcPtr += usBytesPerLine;
+    TgtPtr += usLineSize;
+    ulret += usLineSize;
+  }
+
+  if (!(ubMode & 0x02)) //
+  {
+    switch (ulret%4)
+    {
+    case 1:
+      *TgtPtr++ = 0x00;
+      ulret++;
+    case 2:
+      *TgtPtr++ = 0x00;
+      ulret++;
+    case 3:
+      *TgtPtr++ = 0x00;
+      ulret++;
+    default:
+      break;
+    }
+  }
+  else
+  {
+    switch (ulret%4)
+    {
+    case 1:
+      ulret++;
+    case 2:
+      ulret++;
+    case 3:
+      ulret++;
+    default:
+      break;
+    }
+  }
+  return(ulret);
+}  // FrameTiffComp()
+
+unsigned int FrameTiff_Comp(unsigned char *lpSrcBuf, unsigned char *lpTgtBuf, unsigned int nSrcBytes)
+{
+  unsigned int usret;
+  unsigned int usCount, usEndCnt;
+  unsigned int usControl;
+  unsigned int usCnt;
+  unsigned char ubFirst, ubSecond, ubMisCnt;
+  unsigned char *pubDst, *pubSrc, *pubOrg;
+
+  pubDst = lpTgtBuf;
+  pubSrc = lpSrcBuf;
+  usCount = nSrcBytes;
+  while(1)
+  {
+    if(!usCount)
+    {
+      break;  /* exit while(1) loop */
+    }
+    else if (usCount == 1)
+    {
+      *pubDst++ = 0x00;
+      *pubDst++ = *pubSrc++;
+      break;
+    }
+
+    pubOrg = pubSrc;
+    ubFirst = *pubSrc++;
+    ubSecond = *pubSrc++;
+
+    if(ubFirst == ubSecond)  /* case of data match */
+    {
+      usEndCnt = usCount;
+      if (usCount > 16384)
+      {
+        usEndCnt = 16384;
+      }
+      usEndCnt = usCount - 2;
+      while (usEndCnt--)
+      {
+        if (ubFirst != *pubSrc++)
+        {
+          pubSrc--;
+          break;
+        }
+      } /* of while */
+
+      /* Save compressed data */
+      usCnt = (unsigned int) (pubSrc - pubOrg);
+      usCount -= usCnt;
+      usCnt -=2;
+      if (usCnt >= 64)
+      {
+        /* save control code code 1100 0000 0000 0000  | usCnt */
+        usCnt = (~usCnt & 0x3fff) | 0xc000;
+        *pubDst++ = (unsigned char)((usCnt & 0xff00) >> 8);
+        *pubDst++ = (unsigned char)(usCnt & 0x00ff);
+        *pubDst++ = ubFirst;
+      }
+      else
+      {
+        /* save control code 0100 0000 | (unsigned char)(usCnt) */
+        usCnt = (~usCnt & 0x7f);
+        *pubDst++ = (unsigned char)usCnt;
+        *pubDst++ = ubFirst;
+      }
+    } /* of if (ubFirst == ubSecond) */
+
+    else /* case of data mismatch */
+    {
+      ubMisCnt = 0;
+      if (usCount > 2)
+      {
+        usEndCnt = usCount;
+        if (usCount > 16384)
+        {
+          usEndCnt = 16384;
+        }
+        usEndCnt = usCount - 2;
+        // usEndCnt = usCount - 2; original
+        // 19990824 by LSM : for end file while (usEndCnt--)
+        while (usEndCnt--)
+        {
+          /* read next data */
+          ubFirst = ubSecond;
+          ubSecond = *pubSrc++; // read 3rd Data
+          if (ubFirst == ubSecond)
+          {
+            if (usEndCnt <= 1)
+            {
+              ubMisCnt = 2;
+              break;
+            }
+            else
+            {
+              ubSecond = *pubSrc++; // read 4th Data
+              usEndCnt--;
+              if (ubFirst == ubSecond)
+              {
+                ubMisCnt = 3;
+                break;
+              }
+            }
+          }
+        } /* of while */
+      } /* of if (usCount > 2) */
+      /* save data */
+      usControl = (unsigned int) (pubSrc - pubOrg);
+      usControl -= (unsigned int) ubMisCnt;
+      if (usControl > usCount)
+      {
+        usCount = usControl;
+      }
+      usCount -= usControl;
+      usCnt = usControl - 1;
+      if ( usCnt >= 64)
+      {
+        /* save control code 1000 0000 0000 0000 | usCnt */
+        usCnt = ((usCnt & 0xbfff) | 0x8000);
+        *pubDst++ = (unsigned char)((usCnt & 0xff00) >> 8);
+        *pubDst++ = (unsigned char)(usCnt & 0x00ff);
+      }
+      else
+      {
+        /* save control code 0000 0000 | (BYTE)usCnt */
+        /* and invert it */
+        *pubDst++ = (unsigned char)(usCnt & 0x003f);
+      }
+      pubSrc = pubOrg;
+      while (usControl--)
+      {
+        *pubDst++ = *pubSrc++;
+      } /* of while */
+    } /* of else */
+  } /* of while(1) */
+
+  usret = (unsigned int) (pubDst - lpTgtBuf);
+  return (usret);
+}
+
+unsigned int PreTiffComp(unsigned char *lpSrcBuf, unsigned int nSrcBytes)
+{
+  unsigned int usret =0;
+  unsigned int usCount, usEndCnt;
+  unsigned int usControl;
+  unsigned int usCnt;
+  unsigned char ubFirst, ubSecond, ubMisCnt;
+  unsigned char *pubSrc, *pubOrg;
+
+  pubSrc = lpSrcBuf;
+  usCount = nSrcBytes;
+  while(1)
+  {
+    if(!usCount)
+    {
+      break;  /* exit while(1) loop */
+    }
+    else if (usCount == 1)
+    {
+      usret +=2;
+      pubSrc++;
+      break;
+    }
+
+    pubOrg = pubSrc;
+    ubFirst = *pubSrc++;
+    ubSecond = *pubSrc++;
+
+    if(ubFirst == ubSecond)  /* case of data match */
+    {
+      usEndCnt = usCount;
+      if (usCount > 16384)
+      {
+        usEndCnt = 16384;
+      }
+      usEndCnt = usCount - 2;
+      while (usEndCnt--)
+      {
+        if (ubFirst != *pubSrc++)
+        {
+          pubSrc--;
+          break;
+        }
+      } /* of while */
+
+      /* Save compressed data */
+      usCnt = (unsigned int) (pubSrc - pubOrg);
+      usCount -= usCnt;
+      usCnt -=2;
+      if (usCnt >= 64)
+      {
+        /* save control code code 1100 0000 0000 0000  | usCnt */
+        usret +=3;
+      }
+      else
+      {
+        /* save control code 0100 0000 | (unsigned char)(usCnt) */
+        usret += 2;
+      }
+    } /* of if (ubFirst == ubSecond) */
+
+    else /* case of data mismatch */
+    {
+      ubMisCnt = 0;
+      if (usCount > 2)
+      {
+        usEndCnt = usCount;
+        if (usCount > 16384)
+        {
+          usEndCnt = 16384;
+        }
+        // usEndCnt = usCount - 2;
+        usEndCnt = usCount - 2;
+        // 19990824 by LSM : for Last file while (usEndCnt--)
+        while (usEndCnt--)
+        {
+          /* read next data */
+          ubFirst = ubSecond;
+          ubSecond = *pubSrc++; // read 3rd Data
+          if (ubFirst == ubSecond)
+          {
+            if (usEndCnt <= 1)
+            {
+              ubMisCnt = 2;
+              break;
+            }
+            else
+            {
+              ubSecond = *pubSrc++; // read 4th Data
+              usEndCnt--; // 19990824 by LSM
+              if (ubFirst == ubSecond)
+              {
+                ubMisCnt = 3;
+                break;
+              }
+            }
+          }
+        } /* of while */
+      } /* of if (usCount > 2) */
+      /* save data */
+      usControl = (unsigned int) (pubSrc - pubOrg);
+      usControl -= ubMisCnt;
+      // 19990824 by LSM : for fixing GPF on Photoshop
+      if (usControl > usCount)
+      {
+        usControl = usCount;
+      }
+      usCount -= usControl;
+      usCnt = usControl - 1;
+      if ( usCnt >= 64)
+      {
+        /* save control code 1000 0000 0000 0000 | usCnt */
+        usret += 2;
+      }
+      else
+      {
+        /* save control code 0000 0000 | (BYTE)usCnt */
+        /* and invert it */
+        usret++;
+      }
+      pubSrc = pubOrg;
+      while (usControl--)
+      {
+        usret++;
+        pubSrc++;
+      } /* of while */
+    } /* of else */
+  } /* of while(1) */
+  return (usret);
+}
+
+typedef struct 
+{
+  unsigned char ubDx;
+  unsigned char ubRl;
+  unsigned char ubLastBit;
+}   sc_tbl;
+
+static sc_tbl  gdi_ScanTbl[256] = {
+{ 8, 0, 0 }, { 7, 1, 1 }, { 6, 1, 0 }, { 6, 2, 1 },   // 0x00
+{ 5, 1, 0 }, { 0, 0, 1 }, { 5, 2, 0 }, { 5, 3, 1 }, 
+{ 4, 1, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 4, 2, 0 }, { 0, 0, 1 }, { 4, 3, 0 }, { 4, 4, 1 }, 
+{ 3, 1, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0x10
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 3, 2, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 3, 3, 0 }, { 0, 0, 1 }, { 3, 4, 0 }, { 3, 5, 1 }, 
+{ 2, 1, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0x20
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 2, 2, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0x30
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 2, 3, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 2, 4, 0 }, { 0, 0, 1 }, { 2, 5, 0 }, { 2, 6, 1 }, 
+{ 1, 1, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0x40
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0x50
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 1, 2, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0x60
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 1, 3, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0x70
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 1, 4, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 1, 5, 0 }, { 0, 0, 1 }, { 1, 6, 0 }, { 1, 7, 1 }, 
+{ 0, 1, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0x80
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0x90
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0xa0
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0xb0
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 2, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0xc0
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0xd0
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 3, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0xe0
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 4, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0xf0
+{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 5, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 }, 
+{ 0, 6, 0 }, { 0, 0, 1 }, { 0, 7, 0 }, { 0, 8, 1 }, 
+};
+
+static sc_tbl  gdi_ScanTbl4[16] = {
+{ 4, 0, 0 }, { 3, 1, 1 }, { 2, 1, 0 }, { 2, 2, 1 },   // 0x00
+{ 1, 1, 0 }, { 0, 0, 1 }, { 1, 2, 0 }, { 1, 3, 1 },   // 0x04
+{ 0, 1, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 1 },   // 0x08
+{ 0, 2, 0 }, { 0, 0, 1 }, { 0, 3, 0 }, { 0, 4, 1 }    // 0x0c
+};
+
+long SaveScanData( unsigned char *, unsigned short, unsigned short, unsigned short, unsigned short, unsigned short );
+long UpdateScanSize( unsigned char *, unsigned short, unsigned short, unsigned short, unsigned short, unsigned short );
+typedef long (*funcptr)( unsigned char *, unsigned short, unsigned short, unsigned short, unsigned short, unsigned short );
+
+funcptr UpdateScanLine[2] = { SaveScanData, UpdateScanSize };
+
+long Save6Bytes(unsigned char *out_buf, unsigned short usDy, unsigned short usRl, short sDx, unsigned short usWarp)
+{
+  unsigned long ultmp_dat;
+  long  lWarp, lDis;
+  unsigned short  ustmp_dat;
+
+  lWarp = (long)(usWarp << 3);
+  lDis  = ((long)usDy * lWarp) + (long)sDx;
+
+  // 1st, 2nd, 3rd & 4th byte
+  ultmp_dat = 0xc0000000;
+  if (lDis < 0)
+  {
+    ultmp_dat |= 0x20000000;
+  }
+  ultmp_dat |= (lDis & 0x1fffffff);
+  *out_buf++ = (unsigned char)((ultmp_dat & 0xff000000) >> 24);
+  *out_buf++ = (unsigned char)((ultmp_dat & 0xff0000) >> 16);
+  *out_buf++ = (unsigned char)((ultmp_dat & 0xff00) >> 8);
+  *out_buf++ = (unsigned char)(ultmp_dat & 0xff);
+
+  // 5th & 6th byte
+  ustmp_dat = 0xc000;
+  ustmp_dat |= (usRl & 0x3fff);
+  *out_buf++ = (unsigned char)((ustmp_dat & 0xff00) >> 8);
+  *out_buf++ = (unsigned char)(ustmp_dat & 0xff);
+
+  return(6);
+} // Save6Bytes()
+
+long  Save4Bytes(unsigned char *out_buf, unsigned short usDy, unsigned short usRl, short sDx)
+{
+  unsigned short  ustmp_dat;
+
+  // 1st & 2nd byte
+  ustmp_dat = 0x8000;
+  if (sDx < 0)
+  {
+    ustmp_dat |= 0x2000;
+  }
+  ustmp_dat |= (sDx & 0x1fff);
+  *out_buf++ = (unsigned char)((ustmp_dat & 0xff00) >> 8);
+  *out_buf++ = (unsigned char)(ustmp_dat & 0xff);
+
+  // 3rd & 4th byte
+  ustmp_dat = 0x8000;
+  ustmp_dat |= ((usDy & 0x03) << 12);
+  ustmp_dat |= (usRl & 0xfff);
+  *out_buf++ = (unsigned char)((ustmp_dat & 0xff00) >> 8);
+  *out_buf++ = (unsigned char)(ustmp_dat & 0xff);
+
+  return(4);
+}   // end of Save4Bytes()
+
+long  Save2Bytes(unsigned char *out_buf, unsigned short usDy, unsigned short usRl, short sDx)
+{
+  unsigned char ubtmp_dat;
+
+  // 1st byte
+  ubtmp_dat = 0x00;
+  if (usDy == 1)
+  {
+    ubtmp_dat |= 0x40;
+  }
+  ubtmp_dat |= (usRl & 0x3f);
+  *out_buf++ = ubtmp_dat;
+
+  // 2nd byte
+  if (sDx < 0)
+  {
+    ubtmp_dat = 0x80;
+  }
+  else
+  {
+    ubtmp_dat = 0x00;
+  }
+  ubtmp_dat |= ((unsigned char)sDx & 0x7f);
+  *out_buf++ = ubtmp_dat;
+  return(2);
+}   // end of Save2Bytes()
+
+long SaveScanData (unsigned char *out_buf, 
+                   unsigned short us1Cnt, 
+                   unsigned short usDy, 
+                   unsigned short usPosX10, 
+                   unsigned short usPosX01, 
+                   unsigned short usWarp)
+{
+  short   sDisX;
+  long  lRet;
+
+  sDisX = (int)usPosX01 - (int)usPosX10;
+
+  // 48 bit
+  if ( (usDy > 3) || (us1Cnt > 4095) ) 
+  {
+    Save6Bytes(out_buf, usDy, us1Cnt, sDisX, usWarp);
+    lRet = 6;
+  }
+  // 32 bit
+  else if ( (usDy > 1) || (us1Cnt > 63) || (sDisX > 127) || (sDisX < -128) ) 
+  {
+    Save4Bytes(out_buf, usDy, us1Cnt, sDisX);
+    lRet = 4;
+  }
+  // 16 bit
+  else 
+  {
+    Save2Bytes(out_buf, usDy, us1Cnt, sDisX);
+    lRet = 2;
+  }
+  return(lRet);
+} // end of SaveScanData()
+
+
+long UpdateScanSize (unsigned char *out_buf, 
+                     unsigned short us1Cnt, 
+                     unsigned short usDy, 
+                     unsigned short usPosX10, 
+                     unsigned short usPosX01, 
+                     unsigned short usWarp)
+{
+  short  sDisX;
+  long  lRet;
+
+  sDisX = usPosX01 - usPosX10;
+
+  // 48 bit
+  if ( (usDy > 3) || (us1Cnt > 4095) ) 
+  {
+    lRet = 6;
+  }
+  // 32 bit
+  else if ( (usDy > 1) || (us1Cnt > 63) || (sDisX > 127) || (sDisX < -128) )
+  {
+    lRet = 4;
+  }
+  // 16 bit
+  else
+  {
+    lRet = 2;
+  }
+  return(lRet);
+} // end of UpdateScanSize() by bglee 19981224
+
+long GetSimpleScan(unsigned char *out_buf,
+                   unsigned char ubSizeMode, 
+                   unsigned short  *us1Count, 
+                   unsigned short  *usDy, 
+                   unsigned short  *usPosX10, 
+                   unsigned short  *usPosX01, 
+                   unsigned short  usBytePos,
+                   unsigned char ubCrtByte,
+                   unsigned char ubSize,
+                   unsigned char ubPreBit,
+                   unsigned short  usWidth)
+{
+  long  lScanSize;
+  unsigned char ubDx, ubRl, ubLastBit;
+
+  lScanSize = 0;
+  if (ubSize == 8) 
+  {
+    ubDx = gdi_ScanTbl[ubCrtByte].ubDx;
+    ubRl = gdi_ScanTbl[ubCrtByte].ubRl;
+    ubLastBit = gdi_ScanTbl[ubCrtByte].ubLastBit;
+  }
+  else 
+  {
+    ubCrtByte &= 0x0f;
+    ubDx = gdi_ScanTbl4[ubCrtByte].ubDx;
+    ubRl = gdi_ScanTbl4[ubCrtByte].ubRl;
+    ubLastBit = gdi_ScanTbl4[ubCrtByte].ubLastBit;
+  }
+
+  
+  // 1 X 1 X
+  if (ubPreBit) 
+  {
+    // 1 0 1 X
+    if (ubDx) 
+    {
+      lScanSize += (*UpdateScanLine[ubSizeMode])(out_buf, *us1Count, *usDy, *usPosX10, *usPosX01, usWidth);
+      *usPosX10 = usBytePos - *us1Count;
+      *usPosX01 = usBytePos + ubDx;
+      *us1Count = ubRl;
+      *usDy = 0;
+      // 1 0 1 0
+      if (!ubLastBit) 
+      {
+        // 19990330 by bglee
+        out_buf = out_buf + lScanSize;
+        
+        lScanSize += (*UpdateScanLine[ubSizeMode])(out_buf, *us1Count, *usDy, *usPosX10, *usPosX01, usWidth);
+        *usPosX10 = *usPosX01 ;
+        *us1Count = 0;
+      }
+      // 1 0 1 1
+    }
+    // 1 1 1 X
+    else 
+    {
+      *us1Count += ubRl;
+      // 1 1 1 0
+      if (!ubLastBit) 
+      {
+        lScanSize += (*UpdateScanLine[ubSizeMode])(out_buf, *us1Count, *usDy, *usPosX10, *usPosX01, usWidth);
+        *usPosX10 = usBytePos + ubRl - *us1Count;
+        *us1Count = 0;
+        *usDy = 0;
+      }
+      // 1 1 1 1
+    }
+  }
+  // 0 X 1 X
+  else 
+  {
+    // 0 X 1 X
+    *usPosX01 = usBytePos + ubDx;
+    *us1Count += ubRl;
+    // 0 X 1 0
+    if (!ubLastBit) 
+    {
+      lScanSize += (*UpdateScanLine[ubSizeMode])(out_buf, *us1Count, *usDy, *usPosX10, *usPosX01, usWidth);
+      *usPosX10 = *usPosX01 + ubRl - *us1Count;
+      *us1Count = 0;
+      *usDy = 0;
+    }
+    // 0 X 1 1
+  }
+
+  return(lScanSize);
+} // end of GetSimpleScan() 
+
+
+long scan_map (unsigned char *in_buf, 
+               unsigned char *out_buf,
+               unsigned short usWidth, 
+               unsigned short usHeight, 
+               unsigned char ubMode) 
+{
+  unsigned int  i, j, k;
+  unsigned char ubPreBit, ubCrtByte;//, ubLastBit;
+  long  lScanSize, lTmp;
+  long lCrtSize;
+  unsigned short  us1Count;
+  unsigned short  usPosX01, usPosX10;
+  unsigned short  usDy, usBytePos;
+  unsigned char ubRevMode, ubSizeMode;
+  unsigned char ubTemp;
+
+  usDy = 0;
+  usPosX01 = usPosX10 = 0;
+  lScanSize = 0;
+  ubRevMode = ubMode & 0x01;
+  ubSizeMode = (ubMode & 0x02) >> 1;
+  for (i = 0; i < usHeight; i++) 
+  {
+    ubPreBit = 0;
+    us1Count = 0;
+    for (j = 0; j < usWidth; j++) 
+    {
+      ubCrtByte = *in_buf++;
+      if (ubRevMode)
+      {
+        ubCrtByte = ~ubCrtByte;
+      }
+
+      switch (ubCrtByte) 
+      {
+        case 0x00:
+          // 1 0
+          if (ubPreBit) 
+          {
+            lTmp = (*UpdateScanLine[ubSizeMode])(out_buf, us1Count, usDy, usPosX10, usPosX01, usWidth);
+            out_buf = out_buf + lTmp;
+            lScanSize += lTmp;
+            usPosX10 = (j << 3) - us1Count; /*by pkb*/
+            us1Count = 0;
+            usDy = 0;
+          }
+          // 0 0
+          break;
+
+        case 0xff:
+          // 1 1
+          if (ubPreBit)
+          {
+            us1Count += 8;
+          }
+          // 0 1
+          else 
+          {
+            us1Count = 8;
+            usPosX01 = (j << 3); 
+          }
+          break;
+
+        default:
+          // X X 1 X
+          if (gdi_ScanTbl[ubCrtByte].ubRl) 
+          {
+            usBytePos = (j << 3);
+            lTmp = GetSimpleScan(out_buf, ubSizeMode, &us1Count, &usDy, &usPosX10, &usPosX01, usBytePos, ubCrtByte, 8, ubPreBit, usWidth);
+            out_buf = out_buf + lTmp;
+            lScanSize += lTmp;
+          }
+          // complex pattern
+          else 
+          {
+            for (k = 0; k < 2; k++) 
+            { /*we calculate 4bit*/
+              ubTemp = (ubCrtByte >> (4 - (k * 4)) ) & 0x0f;
+              usBytePos = (j << 3) + (k << 2);
+              switch (ubTemp) 
+              {
+                case 0x00:
+                  // 1 0
+                  if (ubPreBit) 
+                  {
+                    lTmp = (*UpdateScanLine[ubSizeMode])(out_buf, us1Count, usDy, usPosX10, usPosX01, usWidth);
+                    out_buf = out_buf + lTmp;
+                    lScanSize += lTmp;
+                    usPosX10 = usBytePos -  us1Count; 
+                    us1Count = 0;
+                    usDy = 0;
+                  }
+                  // 0 0
+                  break;
+
+                case 0x0f:
+                  // 1 1
+                  if (ubPreBit)
+                  {
+                    us1Count += 4;
+                  }
+                  // 0 1
+                  else 
+                  {
+                    us1Count = 4;
+                    usPosX01 = (j << 3) + (k << 2); 
+                  }
+                  break;
+
+                case 0x05:
+                  // 1 0101
+                  if (ubPreBit) 
+                  {
+                    lTmp = (*UpdateScanLine[ubSizeMode])(out_buf, us1Count, usDy, usPosX10, usPosX01, usWidth);
+                    out_buf = out_buf + lTmp;
+                    lScanSize += lTmp;
+
+                    usPosX10 = usBytePos - us1Count;
+                    usDy = 0;
+                  }
+                  // 0 0101
+                  usPosX01 = usBytePos + 1;
+                  lTmp = (*UpdateScanLine[ubSizeMode])(out_buf, 1, usDy, usPosX10, usPosX01, usWidth);
+                  out_buf = out_buf + lTmp;
+                  lScanSize += lTmp;
+
+                  // next
+                  usPosX10 = 0;
+                  usPosX01 = 2;
+                  usDy = 0;
+                  us1Count = 1;
+                            break;
+
+                case 0x09:
+                  // 1 1001
+                  if (ubPreBit)
+                  {
+                    us1Count++;
+                  }
+                  // 0 1001
+                  else 
+                  {
+                    usPosX01 = usBytePos;
+                    us1Count = 1;
+                  }
+                  lTmp = (*UpdateScanLine[ubSizeMode])(out_buf, us1Count, usDy, usPosX10, usPosX01, usWidth);
+                  out_buf = out_buf + lTmp;
+                  lScanSize += lTmp;
+
+                  // next
+                  if (ubPreBit)
+                  {       
+                    usPosX10 = usBytePos - us1Count + 1;
+                    usPosX01 = usBytePos + 3;
+                  }
+                  else
+                  {
+                    usPosX10 = 0;
+                    usPosX01 = 3;
+                  } 
+                  usDy = 0;
+                  us1Count = 1;
+                  break;
+
+                case 0x0a:
+                  // 1 1010
+                  if (ubPreBit)
+                  {
+                    us1Count++;
+                  }
+                  // 0 1010
+                  else 
+                  {
+                    us1Count = 1;
+                    usPosX01 = usBytePos;
+                  }
+                  lTmp = (*UpdateScanLine[ubSizeMode])(out_buf, us1Count, usDy, usPosX10, usPosX01, usWidth);
+                  out_buf = out_buf + lTmp;
+                  lScanSize += lTmp;
+
+                  // next
+                  usPosX10 = usBytePos - us1Count + 1;
+                  usPosX01 = usBytePos + 2;
+                  lTmp = (*UpdateScanLine[ubSizeMode])(out_buf, 1, 0, usPosX10, usPosX01, usWidth);
+                  out_buf = out_buf + lTmp;
+                  lScanSize += lTmp;
+                  // next
+                  usPosX10 = usBytePos + 2;
+                  usDy = 0;
+                  us1Count = 0;
+                  break;
+
+                case 0x0b:
+                  // 1 1011
+                  if (ubPreBit)
+                  {
+                    us1Count++;
+                  }
+                  // 0 1011
+                  else 
+                  {
+                    us1Count = 1;
+                    usPosX01 = usBytePos;
+                  }
+                  lTmp = (*UpdateScanLine[ubSizeMode])(out_buf, us1Count, usDy, usPosX10, usPosX01, usWidth);
+                  out_buf = out_buf + lTmp;
+                  lScanSize += lTmp;
+
+                  // next
+                  if (ubPreBit)
+                  {       
+                    usPosX10 = usBytePos - us1Count + 1;
+                    usPosX01 = usBytePos + 2;
+                  }
+                  else
+                  {
+                    usPosX10 = 0;
+                    usPosX01 = 2;
+                  } 
+
+                  usDy = 0;
+                  us1Count = 2;
+                  break;
+
+                case 0x0d:
+                  // 1 1101
+                  if (ubPreBit)
+                  {
+                    us1Count += 2;
+                  }
+                  // 0 1101
+                  else 
+                  {
+                    us1Count = 2;
+                    usPosX01 = usBytePos;
+                  }
+                  lTmp = (*UpdateScanLine[ubSizeMode])(out_buf, us1Count, usDy, usPosX10, usPosX01, usWidth);
+                  out_buf = out_buf + lTmp;
+                  lScanSize += lTmp;
+
+                  // next
+                  if (ubPreBit)
+                  {
+                    usPosX10 = usBytePos - us1Count + 2;
+                    usPosX01 = usBytePos + 3;
+                  }
+                  else
+                  {                           
+                    usPosX10 = 0;
+                    usPosX01 = 3;
+                  } 
+                  usDy = 0;
+                  us1Count = 1;
+                  break;
+
+                default:
+                  // X X 1 X
+                  lTmp = GetSimpleScan(out_buf, ubSizeMode, &us1Count, &usDy, &usPosX10, &usPosX01, usBytePos, ubTemp, 4, ubPreBit, usWidth);
+                  out_buf = out_buf + lTmp;
+                  lScanSize += lTmp;
+                  break;
+              } // end of switch()
+              ubPreBit = ubTemp & 0x01;
+            } // end of k-loop
+          }
+          break;
+      } // end of switch()
+
+      ubPreBit = ubCrtByte & 0x01;
+    } /*for  usWidth */
+
+    if (us1Count) 
+    {
+      lTmp = (*UpdateScanLine[ubSizeMode])(out_buf, us1Count, usDy, usPosX10, usPosX01, usWidth);
+      out_buf = out_buf + lTmp;
+      lScanSize += lTmp;
+      usPosX10 = (j << 3) - us1Count;
+
+      us1Count = 0;
+      usDy = 0;
+      usPosX01 = 0;
+    }
+    usDy++;
+
+    // check size over
+    if ( (i % 5) == 4 ) 
+    {
+      lCrtSize = (long)((long)usWidth * (long)(i + 1));
+      if ( lScanSize >= lCrtSize )
+      {
+        return(-1);
+      }
+    }
+  }    /* for   usHeight */
+  lCrtSize = (long)((long)usWidth * (long)usHeight);
+  if ( (lScanSize + 4) >= lCrtSize )
+  {
+    lScanSize = -1;
+  }
+  return(lScanSize);
+} // end of scan_map() 
+
+/*****************************************************************
+ *  H : bmp2run
+ *  I : unsigned char *in_buf - input buffer pointer
+ *      unsigned char *out_buf - output buffer pointer
+ *      unsigned int  sizeX   - image width by byte
+ *      unsigned int  sizeY   - image height by scanline
+ *      unsigned char ubMode  - bit 0 & 1
+ *            0 0 - normal compression
+ *            0 1 - image reverse
+ *            1 X - you get scanline table size
+ *  O : unsigned long lScanSize - scanline table size
+ *  P : scanline table compression
+ ****************************************************************/
+long bmp2run(unsigned char *out_buf, unsigned char *in_buf, unsigned int sizeY, unsigned int sizeX, unsigned char ubMode)
+{    
+  unsigned char *tmp_buf1, *tmp_buf2;
+  long  scan_size;
+
+  //return(-1); // 19990323 by bglee - request from SM Lee
+  
+  tmp_buf1 = in_buf;
+  tmp_buf2 = out_buf;
+  scan_size = scan_map(tmp_buf1, tmp_buf2, sizeX, sizeY, ubMode);
+  if (scan_size == -1) 
+  {
+    return(-1);
+  }
+
+  if ( !(ubMode & 0x02) )  // real compression //---
+  {
+    out_buf = tmp_buf2 + scan_size;
+    *out_buf++ = 0x00;
+    *out_buf++ = 0x00;
+    scan_size += 2;
+    if (scan_size % 4) 
+    {
+      *out_buf++ = 0x00;
+      *out_buf++ = 0x00;
+      scan_size += 2;
+    }
+  }
+  else    // pre-compression
+  {
+    scan_size += 2;
+    if (scan_size % 4) 
+    {
+      scan_size += 2;
+    }
+  }
+  return(scan_size);                  
+}              
+
diff -urN ghostscript-7.05.3-r1/work/espgs-7.05.3/src/unix-gcc.mak master/work/espgs-7.05.3/src/unix-gcc.mak
--- ghostscript-7.05.3-r1/work/espgs-7.05.3/src/unix-gcc.mak	2002-04-23 04:58:48.000000000 -0700
+++ master/work/espgs-7.05.3/src/unix-gcc.mak	2002-09-11 16:46:34.000000000 -0700
@@ -15,6 +15,8 @@
 
 # $Id: unix-gcc.mak,v 1.4 2002/04/23 11:58:48 easysw Exp $
 # makefile for Unix/gcc/X11 configuration.
+# Modified April 12, 2002 to include support for Samsung SmartGDI printers.
+# Ramon Medina <[e-mail]>
 
 # ------------------------------- Options ------------------------------- #
 
@@ -366,7 +368,7 @@
 
 DEVICE_DEVS1=$(DD)bmpmono.dev $(DD)bmpgray.dev $(DD)bmpsep1.dev $(DD)bmpsep8.dev $(DD)bmp16.dev $(DD)bmp256.dev $(DD)bmp16m.dev $(DD)bmp32b.dev
 DEVICE_DEVS2=
-DEVICE_DEVS3=$(DD)deskjet.dev $(DD)djet500.dev $(DD)laserjet.dev $(DD)ljetplus.dev $(DD)ljet2p.dev $(DD)ljet3.dev $(DD)ljet3d.dev $(DD)ljet4.dev $(DD)ljet4d.dev $(DD)lj5mono.dev $(DD)lj5gray.dev
+DEVICE_DEVS3=$(DD)deskjet.dev $(DD)djet500.dev $(DD)laserjet.dev $(DD)ljetplus.dev $(DD)ljet2p.dev $(DD)ljet3.dev $(DD)ljet3d.dev $(DD)ljet4.dev $(DD)ljet4d.dev $(DD)lj5mono.dev $(DD)lj5gray.dev $(DD)gdi.dev
 DEVICE_DEVS4=$(DD)cdeskjet.dev $(DD)cdjcolor.dev $(DD)cdjmono.dev $(DD)cdj550.dev $(DD)pj.dev $(DD)pjxl.dev $(DD)pjxl300.dev
 DEVICE_DEVS5=$(DD)uniprint.dev $(DD)ijs.dev
 DEVICE_DEVS6=$(DD)bj10e.dev $(DD)bj200.dev $(DD)bjc600.dev $(DD)bjc800.dev