prnt/hpijs/ljfastraster.cpp

   1 /*****************************************************************************\
   2   ljfastraster.cpp : Implimentation for the LJFastRaster class
   3
   4   Copyright (c) 1996 - 2001, Hewlett-Packard Co.
   5   All rights reserved.
   6
   7   Redistribution and use in source and binary forms, with or without
   8   modification, are permitted provided that the following conditions
   9   are met:
  10   1. Redistributions of source code must retain the above copyright
  11      notice, this list of conditions and the following disclaimer.
  12   2. Redistributions in binary form must reproduce the above copyright
  13      notice, this list of conditions and the following disclaimer in the
  14      documentation and/or other materials provided with the distribution.
  15   3. Neither the name of Hewlett-Packard nor the names of its
  16      contributors may be used to endorse or promote products derived
  17      from this software without specific prior written permission.
  18
  19   THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
  20   WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  22   NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  24   TO, PATENT INFRINGEMENT; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  25   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  26   ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 \*****************************************************************************/
  30
  31
  32 #ifdef APDK_LJFASTRASTER
  33
  34 #include "header.h"
  35 #include "ljfastraster.h"
  36 #include "printerproxy.h"
  37
  38 APDK_BEGIN_NAMESPACE
  39
  40 #define INDY_STRIP_HEIGHT       128                     // Indy strips can't cross 128 boundary
  41
  42 extern uint32_t ulMapDJ600_CCM_K[ 9 * 9 * 9 ];
  43
  44 BYTE FrBeginSessionSeq[]                                = {0xC0, 0x00, 0xF8, 0x86, 0xC0, 0x03, 0xF8, 0x8F, 0xD1, 0x58,
  45                                                                                     0x02, 0x58, 0x02, 0xF8, 0x89, 0x41};
  46 BYTE FrFeedOrientationSeq[]                             = {0xC0, 0x00  , 0xF8, 0x28 };
  47 //                                                                                         |fd ori enum|       |ori cmd|
  48 BYTE FrPaperSizeSeq[]                                   = {0xC0,  0x00      ,0xF8, 0x25};
  49 //                                                                                         |pap siz enum|     |pap sz cmd|
  50 BYTE FrMedSourceSeq[]                                   = {0xC0,  0x00      ,0xF8, 0x26        };
  51 //                                                                                         |Med src enum|     |Med src cmd|
  52 BYTE FrMedDestinationSeq[]                              = {0xC0,  0x00        ,0xF8 , 0x24      };
  53 //                                                                                         |Med Dest enum|      |Med src cmd|
  54 BYTE FrBeginPageSeq[]                               = {0x43, 0xD3, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x2A, 0x75, 0xC0, 0x07,0xF8, 0x03, 0x6A,
  55                                                                                         0xC0, 0xCC, 0xF8, 0x2C, 0x7B,
  56                                                                                         0xD3, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x4C, 0x6B};
  57
  58 BYTE FrBeginImageSeq[]                              = {0xC2, 0x00, 0x40, 0x70, 0x68, 0xF8, 0x91, 0xC1};
  59
  60 BYTE FrVU_ver_TagSeq[]                                  = {0xC2, 0x00, 0x00, 0x04, 0x00 , 0xF8, 0x95                      };
  61 //                                                                                              |endian alignd         |  |Fr_ver_ tag|
  62 BYTE FrDataLengthSeq[]                                  = {0xC2, 0x86, 0x0A, 0x00, 0x00, 0xF8, 0x92       };
  63 //                                                                                                                                                        | VU data length|
  64 BYTE FrVenUniqSeq[]                                             = {0x46};
  65 BYTE FrVUExtn_3Seq[]                                    = {0xC2, 0x11, 0x20, 0x70, 0x68                 ,0xF8, 0x91     };
  66 //                                                                                              |endian alignd Fr rd img tag|     |VU extensn|
  67 BYTE FrOpenDataSourceSeq[]              = {0xC0, 0x00, 0xF8, 0x88, 0xC0, 0x01, 0xF8, 0x82, 0x48};
  68
  69 BYTE FrEndPageSeq[]                                             =  {0x44};
  70 BYTE FrEndSessionSeq[]                                  =  {0x42};
  71 BYTE FrCloseDataSourceSeq[]                             =  {0x49};
  72 // PJL level commands..
  73
  74 //**JETLIB ENTRIES
  75
  76 const char *ccpPJLStartJob                              = "\033%-12345X";
  77 const char *ccpPJLExitSeq                               = "\033%-12345X@PJL EOJ\012\033%-12345X";
  78 const char *ccpPJLSetRes                                = "@PJL SET RESOLUTION=600\012";
  79 const char *ccpPCLEnterXL                               = "@PJL ENTER LANGUAGE=PCLXL\012";
  80 const char *ccpPJLSetTO                             = "@PJL SET TIMEOUT=900\012";
  81 const char *ccpUEL                      = "\033%-12345X";
  82 const char *ccpPJLComment                               = ") HP-PCL XL;2;0;Comment\012";
  83 const char *ccpPJLSet1BPP                               = "@PJL SET BITSPERPIXEL=1\012";
  84 const char *ccpPJLSetECONOMODE                  = "@PJL SET ECONOMODE=OFF\012";
  85 const char *ccpPJLSetTimeStamp                  = "@PJL SET JOBATTR=";
  86
  87 //**END JETLIB ENTRIES
  88
  89
  90 LJFastRaster::LJFastRaster (SystemServices* pSS, int numfonts, BOOL proto)
  91     : Printer(pSS, numfonts, proto)
  92 {
  93
  94     if ((!proto) && (IOMode.bDevID))
  95     {
  96         constructor_error = VerifyPenInfo();
  97         CERRCHECK;
  98     }
  99     else ePen = BLACK_PEN;    // matches default mode
 100
 101     pMode[DEFAULTMODE_INDEX] = new LJFastRasterNormalMode ();
 102     pMode[GRAYMODE_INDEX]    = new LJFastRasterDraftMode ();
 103     //pMode[DEFAULTMODE_INDEX]   = pMode[GRAYMODE_INDEX];
 104     ModeCount = 2;
 105
 106     CMYMap = NULL;
 107     m_bJobStarted = FALSE;
 108 #ifdef  APDK_AUTODUPLEX
 109     m_bRotateBackPage = FALSE;  // Lasers don't require back side image to be rotated
 110 #endif
 111
 112     m_iYPos = 0;
 113     m_bStartPageNotSent = TRUE;
 114
 115     DBG1("LJFastRaster created\n");
 116 }
 117
 118 LJFastRaster::~LJFastRaster ()
 119 {
 120     DISPLAY_STATUS  eDispStatus;
 121     if (IOMode.bStatus && m_bJobStarted)
 122     {
 123         for (int i = 0; i < 5; i++)
 124         {
 125             pSS->BusyWait (2000);
 126             eDispStatus = ParseError (0);
 127             if (eDispStatus == DISPLAY_PRINTING_COMPLETE)
 128             {
 129                 pSS->DisplayPrinterStatus (eDispStatus);
 130                 break;
 131             }
 132         }
 133     }
 134 }
 135
 136 LJFastRasterNormalMode::LJFastRasterNormalMode ()
 137 : GrayMode(ulMapDJ600_CCM_K)
 138 {
 139     ResolutionX[0] = 600;
 140     ResolutionY[0] = 600;
 141     BaseResX = BaseResY = 600;
 142
 143     MixedRes = FALSE;
 144
 145         theQuality = qualityNormal;
 146
 147     pmQuality = QUALITY_NORMAL;
 148
 149 #if defined(APDK_VIP_COLORFILTERING)
 150     Config.bErnie = FALSE; // Raghu
 151 #endif
 152
 153 #ifdef APDK_AUTODUPLEX
 154     bDuplexCapable = TRUE;
 155 #endif
 156
 157     bFontCapable = FALSE;
 158 }
 159
 160 LJFastRasterDraftMode::LJFastRasterDraftMode ()
 161 : GrayMode(ulMapDJ600_CCM_K)
 162 {
 163     ResolutionX[0] = 600;
 164     ResolutionY[0] = 600;
 165     BaseResX = BaseResY = 600;
 166
 167     MixedRes = FALSE;
 168
 169         theQuality = qualityDraft;
 170
 171     pmQuality = QUALITY_DRAFT;
 172
 173 #if defined(APDK_VIP_COLORFILTERING)
 174     Config.bErnie = FALSE; // Raghu
 175 #endif
 176
 177 #ifdef APDK_AUTODUPLEX
 178     bDuplexCapable = TRUE;
 179 #endif
 180
 181     bFontCapable = FALSE;
 182 }
 183
 184 HeaderLJFastRaster::HeaderLJFastRaster (Printer* p, PrintContext* pc)
 185     : Header(p,pc)
 186 {
 187         SetLastBand(FALSE);
 188 }
 189
 190 DRIVER_ERROR HeaderLJFastRaster::Send ()
 191 {
 192     StartSend ();
 193
 194     return NO_ERROR;
 195 }
 196
 197 DRIVER_ERROR HeaderLJFastRaster::StartSend ()
 198 {
 199     DRIVER_ERROR    err = NO_ERROR;
 200     char            res[64];
 201
 202         err = thePrinter->Send ((const BYTE*)ccpPJLStartJob, strlen (ccpPJLStartJob));
 203         ERRCHECK;
 204
 205         //Set the resolution to 600
 206         err = thePrinter->Send ((const BYTE*)ccpPJLSetRes, strlen (ccpPJLSetRes));
 207         ERRCHECK;
 208
 209         err = thePrinter->Send ((const BYTE*)ccpPJLSet1BPP, strlen (ccpPJLSet1BPP));
 210         ERRCHECK;
 211
 212     QUALITY_MODE    eQ = QUALITY_NORMAL;
 213     COLORMODE       eC;
 214     MEDIATYPE       eM;
 215     BOOL            bD;
 216
 217     thePrintContext->GetPrintModeSettings (eQ, eM, eC, bD);
 218
 219     strcpy (res, "@PJL SET ECONOMODE=");
 220
 221     if (eQ == QUALITY_DRAFT)
 222     {
 223         strcat (res, "ON\015\012");
 224     }
 225     else
 226     {
 227         strcat (res, "OFF\015\012");
 228     }
 229     err = thePrinter->Send ((const BYTE *) res, strlen (res));
 230     ERRCHECK;
 231
 232
 233         //Send the time out command
 234         err = thePrinter->Send ((const BYTE*)ccpPJLSetTO, strlen (ccpPJLSetTO));
 235         ERRCHECK;
 236
 237         //send the mojave PCL_XL_ENTER_LANG command
 238         err = thePrinter->Send ((const BYTE*)ccpPCLEnterXL, strlen (ccpPCLEnterXL));
 239         ERRCHECK;
 240
 241         //send the comment string
 242         err = thePrinter->Send ((const BYTE*)ccpPJLComment, strlen (ccpPJLComment));
 243         ERRCHECK;
 244
 245         err = thePrinter->Send ((const BYTE*)FrBeginSessionSeq,sizeof(FrBeginSessionSeq));
 246         ERRCHECK;
 247
 248         //** VU command to enable PCL-XL
 249         err = thePrinter->Send ((const BYTE*)FrVUExtn_3Seq,sizeof(FrVUExtn_3Seq));
 250         ERRCHECK;
 251         err = thePrinter->Send ((const BYTE*)FrVenUniqSeq,sizeof(FrVenUniqSeq));
 252         ERRCHECK;
 253
 254     //----------------------------------------------------------------
 255     // Open a data source, which will be kept open for the life
 256     // of the session.  Any operators that need embedded data will
 257     // use this data source.
 258     //----------------------------------------------------------------
 259         err = thePrinter->Send ((const BYTE*)FrOpenDataSourceSeq,sizeof(FrOpenDataSourceSeq));
 260         ERRCHECK;
 261
 262     return err;
 263 }
 264
 265 int HeaderLJFastRaster::FrPaperToMediaSize(PAPER_SIZE psize)
 266 {
 267     switch(psize)
 268     {
 269     case LETTER:        return 0;    break;
 270     case LEGAL:         return 1;     break;
 271     case A4:            return 2;          break;
 272     case B4:            return 10;          break;
 273     case B5:            return 11;          break;
 274     case OUFUKU:        return 14;      break;
 275     case HAGAKI:        return 14;      break;
 276         case A6:            return 17;      break;
 277 #ifdef APDK_EXTENDED_MEDIASIZE
 278     case A3:        return 5;      break;
 279     case A5:        return 16;      break;
 280     case LEDGER:        return 4;      break;
 281     case EXECUTIVE:     return 3;   break;
 282     case CUSTOM_SIZE:   return 96;      break;
 283         case ENVELOPE_NO_10: return 6;    break;
 284         case ENVELOPE_A2:    return 6;       break;
 285         case ENVELOPE_C6:    return 8;       break;
 286         case ENVELOPE_DL:    return 9;       break;
 287 #endif
 288     default:            return 0;    break;
 289     }
 290 }
 291
 292 DRIVER_ERROR HeaderLJFastRaster::StartPage ()
 293 {
 294     DRIVER_ERROR err;
 295     BYTE    szCustomSize[16];
 296
 297         /* Orienatation: is FrFeedOrientationSeq[1]. Can take the following values:
 298                 Portrait                                : 0x00
 299                 Landscape:                              : 0x01
 300                 Reversed    Portrait    : 0x02
 301                 Reversed    Landscape   : 0x03
 302                 Image           Orientataion: 0x04
 303         */
 304         err = thePrinter->Send ((const BYTE*)FrFeedOrientationSeq,sizeof(FrFeedOrientationSeq));
 305         ERRCHECK;
 306
 307         //Put the papersize into the FrPaperSizeSeq[]
 308         PAPER_SIZE ps = thePrintContext->GetPaperSize ();
 309         int msizeCode = FrPaperToMediaSize(ps);
 310         FrPaperSizeSeq[1] = (BYTE) msizeCode;
 311 #ifdef APDK_EXTENDED_MEDIASIZE
 312         if(msizeCode == 96 || msizeCode == 17) //Custom paper size or A6
 313         {
 314         union
 315         {
 316             float       fValue;
 317             uint32_t    uiValue;
 318         } LJFUnion;
 319         uint32_t    uiXsize;
 320         uint32_t    uiYsize;
 321         int         k = 0;
 322         LJFUnion.fValue = (float) thePrintContext->PhysicalPageSizeX ();
 323         uiXsize = LJFUnion.uiValue;
 324         LJFUnion.fValue = (float) thePrintContext->PhysicalPageSizeY ();
 325         uiYsize = LJFUnion.uiValue;
 326         szCustomSize[k++] = 0xD5;
 327         szCustomSize[k++] = (BYTE) (uiXsize & 0x000000FF);
 328         szCustomSize[k++] = (BYTE) ((uiXsize & 0x0000FF00) >> 8);
 329         szCustomSize[k++] = (BYTE) ((uiXsize & 0x00FF0000) >> 16);
 330         szCustomSize[k++] = (BYTE) ((uiXsize & 0xFF000000) >> 24);
 331         szCustomSize[k++] = (BYTE) (uiYsize & 0x000000FF);
 332         szCustomSize[k++] = (BYTE) ((uiYsize & 0x0000FF00) >> 8);
 333         szCustomSize[k++] = (BYTE) ((uiYsize & 0x00FF0000) >> 16);
 334         szCustomSize[k++] = (BYTE) ((uiYsize & 0xFF000000) >> 24);
 335         szCustomSize[k++] = 0xF8;
 336         szCustomSize[k++] = 0x2F;
 337         err = thePrinter->Send ((const BYTE *) szCustomSize, k);
 338                 ERRCHECK;
 339
 340
 341                 BYTE FrCustomMediaSeq[] = {0xC0,0x00, 0xF8, 0x30};
 342                 err = thePrinter->Send ((const BYTE *)FrCustomMediaSeq, sizeof(FrCustomMediaSeq));
 343                 ERRCHECK;
 344         }
 345         else
 346 #endif
 347         {
 348                 err = thePrinter->Send ((const BYTE*)FrPaperSizeSeq,sizeof(FrPaperSizeSeq));
 349                 ERRCHECK;
 350         }
 351
 352         err = thePrinter->Send ((const BYTE *)FrBeginPageSeq, sizeof(FrBeginPageSeq));
 353         ERRCHECK;
 354
 355         bLastBand = FALSE;
 356
 357     return err;
 358 }
 359
 360 DRIVER_ERROR HeaderLJFastRaster::EndPage ()
 361 {
 362     DRIVER_ERROR err;
 363
 364     // 0x44 - end page
 365         err = thePrinter->Send ((const BYTE*)FrEndPageSeq,sizeof(FrEndPageSeq));
 366         ERRCHECK;
 367
 368     return err;
 369 }
 370
 371 DRIVER_ERROR HeaderLJFastRaster::EndJob ()
 372 {
 373     DRIVER_ERROR    err = NO_ERROR;
 374
 375         err = thePrinter->Send((const BYTE*)FrCloseDataSourceSeq, sizeof(FrCloseDataSourceSeq));
 376         ERRCHECK;
 377
 378         err = thePrinter->Send((const BYTE*)FrEndSessionSeq, sizeof(FrEndSessionSeq));
 379         ERRCHECK;
 380
 381         err = thePrinter->Send((const BYTE*)ccpPJLExitSeq, strlen (ccpPJLExitSeq));
 382         ERRCHECK;
 383
 384     return err;
 385 }
 386
 387 DRIVER_ERROR HeaderLJFastRaster::FormFeed ()
 388 {
 389         DRIVER_ERROR    err = NO_ERROR;
 390     LJFastRaster    *pFRPrinter = (LJFastRaster *) thePrinter;
 391
 392         bLastBand = TRUE;
 393
 394         err = EndPage ();
 395
 396         pFRPrinter->m_bStartPageNotSent = TRUE;
 397         return err;
 398 }
 399
 400 DRIVER_ERROR HeaderLJFastRaster::SendCAPy (unsigned int iAbsY)
 401 {
 402     return NO_ERROR;
 403 }
 404
 405 #define         FAST_RASTER_HEADERSIZE  25
 406
 407 //** Faster Raster Path Header address values
 408
 409 #define         BASE_ADDRESS                                    0
 410 #define         PAGE_NUM_ADDRESS                                1
 411 #define         RESOLUTION_ADDRESS_HI                   2
 412 #define         RESOLUTION_ADDRESS_LO                   3
 413 #define         COMPRESSION_ADDRESS_HI                  4
 414 #define         COMPRESSION_ADDRESS_LO                  5
 415 #define         COLOR_PLANE_SPECIFIER_ADDRESS   6
 416 #define         COMPRESSION_RATIO                               7
 417 #define         PRODUCT_ID                                              8
 418 #define         IMAGE_SIZE_ADDRESS_HIWORD_HI    12
 419 #define         IMAGE_SIZE_ADDRESS_HIWORD_LO    13
 420 #define         IMAGE_SIZE_ADDRESS_LOWORD_HI    14
 421 #define         IMAGE_SIZE_ADDRESS_LOWORD_LO    15
 422 #define         IMAGE_WIDTH_ADDRESS_HI                  16
 423 #define         IMAGE_WIDTH_ADDRESS_LO                  17
 424 #define         IMAGE_HEIGTH_ADDRESS_HI                 18
 425 #define         IMAGE_HEIGTH_ADDRESS_LO                 19
 426 #define         ABS_X_ADDRESS_HI                                20
 427 #define         ABS_X_ADDRESS_LO                                21
 428 #define         ABS_Y_ADDRESS_HI                                22
 429 #define         ABS_Y_ADDRESS_LO                                23
 430 #define         BIT_DEPTH_ADDRESS                               24
 431
 432 #define eK 3
 433 typedef enum
 434 {
 435         eDelta32,
 436         eDeltaPlus = 24,
 437         eFX = 18,
 438         eRAW = 2
 439 } CompressionMethod;
 440
 441 #define         KILOBYTE 1024
 442 #define         MAX_IMAGE 200*KILOBYTE
 443
 444 DRIVER_ERROR LJFastRaster::Encapsulate (const RASTERDATA* InputRaster, BOOL bLastPlane)
 445 {
 446     BYTE    res[64];
 447     DRIVER_ERROR    err = NO_ERROR;
 448
 449         //** form FR header
 450         unsigned char   pucHeader[FAST_RASTER_HEADERSIZE];
 451         long lImageWidth = ((ModeDeltaPlus*)m_pCompressor)->inputsize;
 452         long lResolution = 600;
 453         long lBlockOffset = ((((ModeDeltaPlus*)m_pCompressor)->m_lPrinterRasterRow + 127) / 128) * 128 - 128;
 454         long lBitDepth = 1;
 455         long lBlockHeight = ((ModeDeltaPlus*)m_pCompressor)->m_lCurrBlockHeight;
 456
 457         WORD wTemp = LOWORD (lBlockOffset);
 458         BYTE byHIByte = 0;
 459         BYTE byLOByte = 0;
 460
 461     memset (pucHeader, 0, FAST_RASTER_HEADERSIZE);
 462
 463         pucHeader[ABS_X_ADDRESS_HI] = 0;
 464         pucHeader[ABS_X_ADDRESS_LO] = 0;
 465         pucHeader[ABS_Y_ADDRESS_HI] = HIBYTE (wTemp);
 466         pucHeader[ABS_Y_ADDRESS_LO] = LOBYTE (wTemp);
 467
 468         pucHeader[BASE_ADDRESS] = 0;
 469         pucHeader[PAGE_NUM_ADDRESS] = 1;
 470
 471         wTemp = (WORD) (lResolution );
 472         byHIByte = HIBYTE (wTemp);
 473         byLOByte = LOBYTE (wTemp);
 474         pucHeader[RESOLUTION_ADDRESS_HI] = byHIByte;
 475         pucHeader[RESOLUTION_ADDRESS_LO] = byLOByte;
 476
 477         wTemp = ((ModeDeltaPlus*)m_pCompressor)->m_bCompressed ? (WORD)eDeltaPlus : (WORD)eRAW;
 478         byHIByte = HIBYTE (wTemp);
 479         byLOByte = LOBYTE (wTemp);
 480         pucHeader[COMPRESSION_ADDRESS_HI] = byHIByte;
 481         pucHeader[COMPRESSION_ADDRESS_LO] = byLOByte;
 482
 483         pucHeader[COLOR_PLANE_SPECIFIER_ADDRESS]        = (BYTE)eK;
 484         pucHeader[COMPRESSION_RATIO]                            = (BYTE)ceil (((ModeDeltaPlus*)m_pCompressor)->m_fRatio);
 485         wTemp = HIWORD (InputRaster->rastersize[COLORTYPE_COLOR]);
 486         byHIByte = HIBYTE (wTemp);
 487         byLOByte = LOBYTE (wTemp);
 488         pucHeader[IMAGE_SIZE_ADDRESS_HIWORD_HI] = byHIByte;
 489         pucHeader[IMAGE_SIZE_ADDRESS_HIWORD_LO] = byLOByte;
 490
 491         wTemp = LOWORD (InputRaster->rastersize[COLORTYPE_COLOR]);
 492         byHIByte = HIBYTE (wTemp);
 493         byLOByte = LOBYTE (wTemp);
 494         pucHeader[IMAGE_SIZE_ADDRESS_LOWORD_HI] = byHIByte;
 495         pucHeader[IMAGE_SIZE_ADDRESS_LOWORD_LO] = byLOByte;
 496
 497         wTemp = LOWORD (lImageWidth*8);
 498         byHIByte = HIBYTE (wTemp);
 499         byLOByte = LOBYTE (wTemp);
 500
 501         pucHeader[IMAGE_WIDTH_ADDRESS_HI] = byHIByte;
 502         pucHeader[IMAGE_WIDTH_ADDRESS_LO] = byLOByte;
 503
 504         wTemp = LOWORD (lBlockHeight);
 505         byHIByte = HIBYTE (wTemp);
 506         byLOByte = LOBYTE (wTemp);
 507         pucHeader[IMAGE_HEIGTH_ADDRESS_HI] = byHIByte;
 508         pucHeader[IMAGE_HEIGTH_ADDRESS_LO] = byLOByte;
 509
 510         wTemp = LOWORD (lBitDepth);
 511         pucHeader[BIT_DEPTH_ADDRESS] = LOBYTE (wTemp);
 512
 513     unsigned int   ulVUDataLength = (int)(InputRaster->rastersize[COLORTYPE_COLOR] + FAST_RASTER_HEADERSIZE);
 514
 515         BYTE FrEnterFRModeSeq[] = {0xC2, 0x06, 0x20, 0x70,0x68, 0xF8, 0x91, 0xC2};
 516         err = Send ((const BYTE *)FrEnterFRModeSeq, sizeof(FrEnterFRModeSeq));
 517         ERRCHECK;
 518     res[0] = (BYTE) (ulVUDataLength & 0xFF);
 519     res[1] = (BYTE) ((ulVUDataLength & 0x0000FF00) >> 8);
 520     res[2] = (BYTE) ((ulVUDataLength & 0x00FF0000) >> 16);
 521     res[3] = (BYTE) ((ulVUDataLength & 0xFF000000) >> 24);
 522     res[4] = 0xF8;
 523     res[5] = 0x92;
 524     res[6] = 0x46;
 525     err = Send (res, 7);
 526         ERRCHECK;
 527
 528         //** now embed raster data, header and all
 529     err = Send (pucHeader, FAST_RASTER_HEADERSIZE);
 530         ERRCHECK;
 531     err = Send (InputRaster->rasterdata[COLORTYPE_COLOR],
 532                             InputRaster->rastersize[COLORTYPE_COLOR]);
 533     return err;
 534 }
 535
 536 Header* LJFastRaster::SelectHeader (PrintContext *pc)
 537 {
 538     phLJFastRaster = new HeaderLJFastRaster (this, pc);
 539         return phLJFastRaster;
 540 }
 541
 542 DRIVER_ERROR LJFastRaster::VerifyPenInfo()
 543 {
 544     ePen = BLACK_PEN;
 545     return NO_ERROR;
 546 }
 547
 548 DRIVER_ERROR LJFastRaster::ParsePenInfo(PEN_TYPE& ePen, BOOL QueryPrinter)
 549 {
 550     ePen = BOTH_PENS;
 551
 552     return NO_ERROR;
 553 }
 554
 555 Compressor* LJFastRaster::CreateCompressor (unsigned int RasterSize)
 556 {
 557     m_pCompressor = new ModeDeltaPlus (pSS, this, RasterSize);
 558         return m_pCompressor;
 559 }
 560
 561 /*
 562  *  Function name: ParseError
 563  *
 564  *  Owner: Darrell Walker
 565  *
 566  *  Purpose:  To determine what error state the printer is in.
 567  *
 568  *  Called by: Send()
 569  *
 570  *  Parameters on entry: status_reg is the contents of the centronics
 571  *                      status register (at the time the error was
 572  *                      detected)
 573  *
 574  *  Parameters on exit: unchanged
 575  *
 576  *  Return Values: The proper DISPLAY_STATUS to reflect the printer
 577  *              error state.
 578  *
 579  */
 580 DISPLAY_STATUS LJFastRaster::ParseError(BYTE status_reg)
 581 {
 582     DBG1("LJFastRaster: parsing error info\n");
 583
 584     DRIVER_ERROR err = NO_ERROR;
 585     BYTE    szReadBuff[256];
 586     DWORD   iReadCount = 256;
 587     DISPLAY_STATUS  eStatus = (DISPLAY_STATUS) status_reg;
 588     char    *tmpStr;
 589     int     iErrorCode;
 590
 591     if (!IOMode.bDevID)
 592         return eStatus;
 593
 594     memset (szReadBuff, 0, 256);
 595     err = pSS->FromDevice (szReadBuff, &iReadCount);
 596     if (err == NO_ERROR && iReadCount == 0)
 597         return eStatus;
 598
 599     if (strstr ((char *) szReadBuff, "JOB"))
 600     {
 601         if (!(tmpStr = strstr ((char *) szReadBuff, "NAME")))
 602             return DISPLAY_PRINTING;
 603         tmpStr += 6;
 604         while (*tmpStr < '0' || *tmpStr > '9')
 605             tmpStr++;
 606         sscanf (tmpStr, "%d", &iErrorCode);
 607         if (iErrorCode != (long) (this))
 608             return DISPLAY_PRINTING;
 609     }
 610
 611     if (strstr ((char *) szReadBuff, "END"))
 612     {
 613         return DISPLAY_PRINTING_COMPLETE;
 614     }
 615
 616
 617     if (strstr ((char *) szReadBuff, "CANCEL"))
 618         return DISPLAY_PRINTING_CANCELED;
 619
 620     if (!(tmpStr = strstr ((char *) szReadBuff, "CODE")))
 621         return eStatus;
 622
 623     tmpStr += 4;
 624     while (*tmpStr < '0' || *tmpStr > '9')
 625         tmpStr++;
 626     sscanf (tmpStr, "%d", &iErrorCode);
 627
 628     if (iErrorCode < 32000)
 629         return DISPLAY_PRINTING;
 630
 631     if (iErrorCode == 40010 || iErrorCode == 40020)
 632         return DISPLAY_NO_PENS;     // Actually, out of toner
 633
 634     if (iErrorCode == 40021)
 635         return DISPLAY_TOP_COVER_OPEN;
 636
 637     if ((iErrorCode / 100) == 419)
 638         return DISPLAY_OUT_OF_PAPER;
 639
 640     if ((iErrorCode / 1000) == 42 || iErrorCode == 40022)
 641     {
 642         DBG1("Paper Jammed\n");
 643         return DISPLAY_PAPER_JAMMED;
 644     }
 645
 646     if (iErrorCode > 40049 && iErrorCode < 41000)
 647     {
 648         DBG1("IO trap\n");
 649         return DISPLAY_ERROR_TRAP;
 650     }
 651
 652     if (iErrorCode == 40079)
 653         return DISPLAY_OFFLINE;
 654
 655     return DISPLAY_ERROR_TRAP;
 656 }
 657
 658
 659 //--------------------------------------------------------------------
 660 // Function:    ModeDeltaPlus::ModeDeltaPlus
 661 //
 662 // Release:     [PROTO4_1]
 663 //
 664 // Description: Preferred ctor
 665 //
 666 // Input:        padMultiple - the fBufferDataLength returned from
 667 //                             GetRow must be divisible by this value.
 668 //
 669 // Modifies:     fpBuffer
 670 //
 671 // Precond:      None
 672 //
 673 // Postcond:     None
 674 //
 675 // Returns:      None
 676 //
 677 // Created:            11/07/96 cal
 678 // Last Modified:      5/020/01 DG
 679 //--------------------------------------------------------------------
 680 ModeDeltaPlus::ModeDeltaPlus
 681 (
 682         SystemServices* pSys,
 683     Printer* pPrinter,
 684     unsigned int PlaneSize
 685 ) :
 686     Compressor(pSys, PlaneSize, TRUE),
 687     thePrinter(pPrinter),    // needed by Flush
 688     pbyInputImageBuffer (NULL),
 689     pbySeedRow (NULL)
 690 {
 691     if (constructor_error != NO_ERROR)  // if error in base constructor
 692     {
 693         return;
 694     }
 695
 696         inputsize = PlaneSize / (MAXCOLORPLANES * MAXCOLORDEPTH * MAXCOLORROWS);
 697     inputsize = ((inputsize + 7) / 8) * 8;
 698
 699         // allocate a 2X compression buffer..
 700         compressBuf = (BYTE*)pSS->AllocMem(2 * INDY_STRIP_HEIGHT * inputsize);
 701         if (compressBuf == NULL)
 702     {
 703                 constructor_error = ALLOCMEM_ERROR;
 704     }
 705         memset (compressBuf, 0x00, 2 * INDY_STRIP_HEIGHT * inputsize);
 706
 707         pbyInputImageBuffer = (BYTE*)pSS->AllocMem(INDY_STRIP_HEIGHT * inputsize);
 708         if (pbyInputImageBuffer == NULL)
 709                 constructor_error=ALLOCMEM_ERROR;
 710         memset(pbyInputImageBuffer, 0x00, INDY_STRIP_HEIGHT * inputsize);
 711
 712     pbySeedRow = (HPUInt8*) pSS->AllocMem (inputsize * sizeof (HPUInt8));
 713     if (pbySeedRow == NULL)
 714     {
 715         constructor_error = ALLOCMEM_ERROR;
 716     }
 717     memset (pbySeedRow, 0, inputsize * sizeof (HPUInt8));
 718
 719         m_lCurrCDRasterRow      = 0;
 720         //m_lPrinterRasterRow = (((LJFastRaster*)thePrinter)->phLJFastRaster)->thePrintContext->PrintableStartY() * 600;
 721
 722         m_lPrinterRasterRow = 0;
 723
 724         iRastersReady = 0;
 725
 726         m_bCompressed = FALSE;
 727         m_compressedsize = 0;
 728         m_fRatio = 0;
 729 } // ModeDeltaPlus::ModeDeltaPlus
 730
 731
 732 //--------------------------------------------------------------------
 733 // Function:    ModeDeltaPlus::~ModeDeltaPlus
 734 //
 735 // Release:     [PROTO4_1]
 736 //
 737 // Description: Destructor.
 738 //
 739 // Input:       None
 740 //
 741 // Modifies:    fpBuffer - deletes the buffer
 742 //              ?? - deletes other buffer(s)??
 743 //
 744 // Precond:     None
 745 //
 746 // Postcond:    None
 747 //
 748 // Returns:     None
 749 //
 750 // Created:            11/07/96 cal
 751 // Last Modified:      5/020/01 DG
 752 //--------------------------------------------------------------------
 753 ModeDeltaPlus::~ModeDeltaPlus ()
 754 {
 755         if (pbyInputImageBuffer)
 756         {
 757                 pSS->FreeMem (pbyInputImageBuffer);
 758                 pbyInputImageBuffer = NULL;
 759         }
 760     if (pbySeedRow)
 761     {
 762         pSS->FreeMem (pbySeedRow);
 763         pbySeedRow = NULL;
 764     }
 765
 766 } // ModeDeltaPlus::~ModeDeltaPlus
 767
 768 /*
 769  * The maximum width of a line, which is limited by the amount of hardware
 770  * buffer space allocated to storing the seedrow.
 771  */
 772 #define ROW_LIMIT 7040
 773 /*
 774  * The maximum number of literals in a single command, not counting the first
 775  * pixel.  This is limited by the hardware buffer used to store a literal
 776  * string.  For real images, I expect a value of 64 would be a suitable
 777  * minimum.  The minimum compression ratio will be bounded by this.  Note also
 778  * that the software does not need any buffer for this, so there need be no
 779  * limit at all on a purely software implementation.  For the sake of enabling
 780  * a hardware implementation, I would strongly recommend leaving it in and set
 781  * to some reasonable value (say 1023 or 255).
 782  */
 783 #define LITERAL_LIMIT 511
 784
 785 /* These are set up this way to make it easy to change the predictions. */
 786 #define LTEST_W            col > 0
 787 #define LVAL_W(col)        cur_row[col-1]
 788 #define LTEST_NW           col > 0
 789 #define LVAL_NW(col)       seedrow[col-1]
 790 #define LTEST_WW           col > 1
 791 #define LVAL_WW(col)       cur_row[col-2]
 792 #define LTEST_NWW          col > 1
 793 #define LVAL_NWW(col)      seedrow[col-2]
 794 #define LTEST_NE           (col+1) < row_width
 795 #define LVAL_NE(col)       seedrow[col+1]
 796 #define LTEST_NEWCOL       1
 797 #define LVAL_NEWCOL(col)   new_color
 798 #define LTEST_CACHE        1
 799 #define LVAL_CACHE(col)    cache
 800
 801 #define LOC1TEST      LTEST_NE
 802 #define LOC1VAL(col)  LVAL_NE(col)
 803 #define LOC2TEST      LTEST_NW
 804 #define LOC2VAL(col)  LVAL_NW(col)
 805 #define LOC3TEST      LTEST_NEWCOL
 806 #define LOC3VAL(col)  LVAL_NEWCOL(col)
 807
 808
 809 #define check(condition) if (!(condition)) return 0
 810
 811 #define write_comp_byte(val)           \
 812    check(outptr < pastoutmem);         \
 813    *outptr++ = (HPUInt8) val;
 814
 815 #define read_byte(val)                 \
 816    check(inmem < pastinmem);           \
 817    val = *inmem++;
 818
 819 #define encode_count(count, over, mem)         \
 820    if (count >= over)                          \
 821    {                                           \
 822       count -= over;                           \
 823       if (count <= (uint32_t) 253)               \
 824       {                                        \
 825          check(mem < pastoutmem);              \
 826          *mem++ = (HPUInt8) count;               \
 827       }                                        \
 828       else if (count <= (uint32_t) (254 + 255) ) \
 829       {                                        \
 830          check((mem+1) < pastoutmem);          \
 831          check( count >= 254 );                \
 832          check( (count - 254) <= 255 );        \
 833          *mem++ = (HPUInt8) 0xFE;                \
 834          *mem++ = (HPUInt8) (count - 254);       \
 835       }                                        \
 836       else                                     \
 837       {                                        \
 838          check((mem+2) < pastoutmem);          \
 839          check( count >= 255 );                \
 840          check( (count - 255) <= 65535 );      \
 841          count -= 255;                         \
 842          *mem++ = (HPUInt8) 0xFF;                \
 843          *mem++ = (HPUInt8) (count >> 8);        \
 844          *mem++ = (HPUInt8) (count & 0xFF);      \
 845       }                                        \
 846    }
 847 #define decode_count(count, over)              \
 848    if (count >= over)                          \
 849    {                                           \
 850       read_byte(inval);                        \
 851       count += (uint32_t) inval;                 \
 852       if (inval == (HPUInt8) 0xFE)               \
 853       {                                        \
 854          read_byte(inval);                     \
 855          count += (uint32_t) inval;              \
 856       }                                        \
 857       else if (inval == (HPUInt8) 0xFF)          \
 858       {                                        \
 859          read_byte(inval);                     \
 860          count += (((uint32_t) inval) << 8);     \
 861          read_byte(inval);                     \
 862          count += (uint32_t) inval;              \
 863       }                                        \
 864    }
 865
 866 #define bytes_for_count(count, over) \
 867   ( (count >= 255) ? 3 : (count >= over) ? 1 : 0 )
 868
 869
 870 /* The number of bytes we should be greater than to call memset/memcpy */
 871 #define memutil_thresh 15
 872
 873 HPUInt8* ModeDeltaPlus::encode_header(HPUInt8* outptr, const HPUInt8* pastoutmem, uint32_t isrun, uint32_t location, uint32_t seedrow_count, uint32_t run_count, const HPUInt8 new_color)
 874 {
 875     uint32_t byte;
 876
 877     check (location < 4);
 878     check( (isrun == 0) || (isrun == 1) );
 879
 880     /* encode "literal" in command byte */
 881     byte = (isrun << 7) | (location << 5);
 882
 883     /* write out number of seedrow bytes to copy */
 884     if (seedrow_count > 2)
 885         byte |= (0x03 << 3);
 886     else
 887         byte |= (seedrow_count << 3);
 888
 889     if (run_count > 6)
 890         byte |= 0x07;
 891     else
 892         byte |= run_count;
 893
 894     /* write out command byte */
 895     write_comp_byte(byte);
 896
 897     /* macro to write count if it's 3 or more */
 898     encode_count( seedrow_count, 3, outptr );
 899
 900     /* if required, write out color of first pixel */
 901     if (location == 0)
 902     {
 903         write_comp_byte( new_color );
 904     }
 905
 906     /* macro to write count if it's 7 or more */
 907     encode_count( run_count, 7, outptr );
 908
 909     return outptr;
 910 }
 911
 912 /******************************************************************************/
 913 /*                                COMPRESSION                                 */
 914 /******************************************************************************/
 915 BOOL ModeDeltaPlus::Compress (HPUInt8   *outmem,
 916                               uint32_t  *outlen,
 917                               const     HPUInt8     *inmem,
 918                               const     uint32_t    row_width,
 919                               const     uint32_t    inheight,
 920                               uint32_t  horz_ht_dist)
 921 {
 922         register    HPUInt8     *outptr = outmem;
 923         register    uint32_t    col;
 924     const       HPUInt8     *seedrow;
 925     uint32_t                seedrow_count = 0;
 926     uint32_t                location = 0;
 927     HPUInt8                 new_color = (HPUInt8) 0xFF;
 928     const       HPUInt8     *cur_row;
 929     uint32_t                            row;
 930     const       HPUInt8     *pastoutmem = outmem + *outlen;
 931     uint32_t                do_word_copies;
 932     /* Halftone distance must be 1-32 (but allow 0 == 1) */
 933     if (horz_ht_dist > 32)
 934     {
 935         return FALSE;
 936     }
 937     if (horz_ht_dist < 1)
 938     {
 939        horz_ht_dist = 1;
 940     }
 941
 942     seedrow = pbySeedRow;
 943     do_word_copies = ((row_width % 4) == 0);
 944
 945     for (row = 0; row < inheight; row++)
 946     {
 947         cur_row = inmem + (row * row_width);
 948
 949         col = 0;
 950         while (col < row_width)
 951         {
 952             /* First look for seedrow copy */
 953             seedrow_count = 0;
 954             if (do_word_copies)
 955             {
 956                 /* Try a fast word-based search */
 957                 while ( ((col & 3) != 0) &&
 958                         (col < row_width) &&
 959                         (cur_row[col] == seedrow[col]) )
 960                 {
 961                     seedrow_count++;
 962                     col++;
 963                 }
 964                 if ( (col & 3) == 0)
 965                 {
 966                     while ( ((col+3) < row_width) &&
 967                             *((const uint32_t*) (cur_row + col)) == *((const uint32_t*) (seedrow + col)) )
 968                     {
 969                         seedrow_count += 4;
 970                         col += 4;
 971                     }
 972                 }
 973             }
 974             while ( (col < row_width) && (cur_row[col] == seedrow[col]) )
 975             {
 976                seedrow_count++;
 977                col++;
 978             }
 979
 980             /* It is possible that we have hit the end of the line already. */
 981             if (col == row_width)
 982             {
 983                 /* encode pure seed run as fake run */
 984                 outptr = encode_header(outptr, pastoutmem, 1 /*run*/, 1 /*location*/, seedrow_count, 0 /*runcount*/, (HPUInt8) 0 /*color*/);
 985                 /* exit the while loop for this row */
 986                 break;
 987             }
 988             check(col < row_width);
 989
 990
 991             /* determine the prediction for the current pixel */
 992             if ( (LOC1TEST) && (cur_row[col] == LOC1VAL(col)) )
 993                 location = 1;
 994             else if ( (LOC2TEST) && (cur_row[col] == LOC2VAL(col)) )
 995                 location = 2;
 996             else if ( (LOC3TEST) && (cur_row[col] == LOC3VAL(col)) )
 997                 location = 3;
 998             else
 999             {
1000                 location = 0;
1001                 new_color = cur_row[col];
1002             }
1003
1004
1005             /* Look for a run */
1006             if (
1007                  ((col+1) < row_width)
1008                  &&
1009                  ((col+1) >= horz_ht_dist)
1010                  &&
1011                  (cur_row[col+1-horz_ht_dist] == cur_row[col+1])
1012                )
1013             {
1014                 /* We found a run.  Determine the length. */
1015                 uint32_t run_count = 0;   /* Actually 2 */
1016                 col++;
1017                 while ( ((col+1) < row_width) && (cur_row[col+1-horz_ht_dist] == cur_row[col+1]) )
1018                 {
1019                    run_count++;
1020                    col++;
1021                 }
1022                 col++;
1023                 outptr = encode_header(outptr, pastoutmem, 1 /*run*/, location, seedrow_count, run_count, new_color);
1024             }
1025
1026             else
1027
1028             /* We didn't find a run.  Encode literal(s). */
1029             {
1030                 uint32_t replacement_count = 0;   /* Actually 1 */
1031                 const HPUInt8* byte_array = cur_row + col + 1;
1032                 uint32_t i;
1033                 col++;
1034                 /*
1035                  * The (col+1) in this test is used because there is no need to
1036                  * check for literal breaks if this is the last byte of the row.
1037                  * Instead we just tack it on to our literal count at the end.
1038                  */
1039                 while ( (col+1) < row_width )
1040                 {
1041                     /*
1042                      * All cases that will break with 1 unit saved.  This
1043                      * should be the best breaking spots, since we will always
1044                      * gain with the break, but never break for no gain.  This
1045                      * leads to longer strings which is good for decomp speed.
1046                      */
1047                     if (
1048                          /* Seedrow ... */
1049                          (
1050                            (cur_row[col] == seedrow[col])
1051                            &&
1052                            (
1053                              /* 2 seedrows */
1054                              (
1055                                (cur_row[col+1] == seedrow[col+1])
1056                              )
1057                              ||
1058                              /* seedrow and predict */
1059                              (
1060                                (cur_row[col+1] == LVAL_NW(col+1))
1061                                ||
1062                                (cur_row[col+1] == LVAL_NEWCOL(col+1))
1063                              )
1064                              ||
1065                              (
1066                                ((col+2) < row_width)
1067                                &&
1068                                (
1069                                  /* seedrow and run */
1070                                  (\r
1071                                    ((col + 2) >= horz_ht_dist) &&
1072                                    (cur_row[col+2-horz_ht_dist] == cur_row[col+2])\r
1073                                  )
1074                                  ||
1075                                  /* seedrow and northeast predict */
1076                                  (cur_row[col+1] == LVAL_NE(col+1))
1077                                )
1078                              )
1079                            )
1080                          )
1081                          ||
1082                          /* Run ... */
1083                          (
1084                            (cur_row[col] != seedrow[col])
1085                            &&
1086                            ((col + 1) >= horz_ht_dist)
1087                            &&
1088                            (cur_row[col+1-horz_ht_dist] == cur_row[col+1])
1089                            &&
1090                            (
1091                              /* Run of 3 or more */
1092                              (
1093                                ((col+2) < row_width)
1094                                &&
1095                                ((col + 2) >= horz_ht_dist)
1096                                &&
1097                                (cur_row[col+2-horz_ht_dist] == cur_row[col+2])
1098                              )
1099                              ||
1100                              /* Predict first unit of run */
1101                              (cur_row[col] == LVAL_NE(col))
1102                              ||
1103                              (cur_row[col] == LVAL_NW(col))
1104                              ||
1105                              (cur_row[col] == LVAL_NEWCOL(col))
1106                            )
1107                          )
1108                        )
1109                         break;
1110
1111                     /* limited hardware buffer */
1112                     if (replacement_count >= LITERAL_LIMIT)
1113                         break;
1114
1115                     /* add another literal to the list */
1116                     replacement_count++;
1117                     col++;
1118                 }
1119
1120                 /* If almost at end of block, just extend the literal by one */
1121                 if ( (col+1) == row_width ) {
1122                    replacement_count++;
1123                    col++;
1124                 }
1125
1126                 outptr = encode_header(outptr, pastoutmem, 0 /*not run*/, location, seedrow_count, replacement_count, new_color);
1127
1128                 /* Copy bytes from the byte array.  If rc was 1, then we will
1129                  * have encoded a zero in the command byte, so nothing will be
1130                  * copied here (the 1 indicates the first pixel, which was
1131                  * written above or was predicted.  If rc is between 2 and 7,
1132                  * then a value between 1 and 6 will have been written in the
1133                  * command byte, and we will copy it directly.  If 8 or more,
1134                  * then we encode more counts, then finally copy all the values
1135                  * from byte_array.
1136                  */
1137
1138                 if (replacement_count > 0)
1139                 {
1140                     /* Now insert rc bytes of data from byte_array */
1141                     if (replacement_count > memutil_thresh)
1142                     {
1143                         check( (outptr + replacement_count) <= pastoutmem );
1144                         memcpy(outptr, byte_array, (size_t) replacement_count);
1145                         outptr += replacement_count;
1146                     }
1147                     else
1148                     {
1149                         for (i = 0; i < replacement_count; i++)
1150                         {
1151                             write_comp_byte( byte_array[i] );
1152                         }
1153                     }
1154                 }
1155             }
1156
1157         } /* end of column */
1158
1159         /* save current row as next row's seed row */
1160         seedrow = cur_row;
1161
1162     } /* end of row */
1163
1164     check( outptr <= pastoutmem );
1165     if (outptr > pastoutmem)
1166     {
1167        /* We're in big trouble -- we wrote PAST the end of their memory! */
1168        *outlen = 0;
1169        return 0;
1170     }
1171
1172     *outlen = (uint32_t) (outptr - outmem);
1173
1174     return 1;
1175 } /* end of deltaplus_compress2 */
1176
1177
1178 BOOL ModeDeltaPlus::Process
1179 (
1180     RASTERDATA* input
1181 )
1182 {
1183         DRIVER_ERROR            err = NO_ERROR;
1184
1185     if (input==NULL ||
1186                 (input->rasterdata[COLORTYPE_COLOR]==NULL && input->rasterdata[COLORTYPE_BLACK]==NULL))    // flushing pipeline
1187     {
1188         return FALSE;
1189     }
1190         if (input->rasterdata[COLORTYPE_COLOR])
1191         {
1192                 if (m_lCurrCDRasterRow < INDY_STRIP_HEIGHT )
1193                 {
1194                         //Copy the data to m_SourceBitmap
1195                         memcpy(pbyInputImageBuffer + m_lCurrCDRasterRow * inputsize, input->rasterdata[COLORTYPE_COLOR], input->rastersize[COLORTYPE_COLOR]);
1196                         m_lCurrCDRasterRow ++;
1197                 }
1198                 if (m_lCurrCDRasterRow == INDY_STRIP_HEIGHT || ((LJFastRaster*)thePrinter)->phLJFastRaster->IsLastBand())
1199                 {
1200                         if (((LJFastRaster*)thePrinter)->m_bStartPageNotSent)
1201                         {
1202                                 err = (((LJFastRaster*)thePrinter)->phLJFastRaster)->StartPage();
1203                                 ((LJFastRaster*)thePrinter)->m_bStartPageNotSent = FALSE;
1204                                                 m_lPrinterRasterRow = 0;
1205                         }
1206
1207                         m_compressedsize = 2 * inputsize * INDY_STRIP_HEIGHT;
1208             BOOL bRet = Compress (compressBuf,
1209                                   &m_compressedsize,
1210                                   pbyInputImageBuffer,
1211                                   inputsize,
1212                                   m_lCurrCDRasterRow,
1213                                   16
1214                                   );
1215                         if (!bRet)
1216                         {
1217                                 memcpy (compressBuf, pbyInputImageBuffer, inputsize * INDY_STRIP_HEIGHT);
1218                                 m_compressedsize = inputsize * INDY_STRIP_HEIGHT;
1219                         }
1220                         else
1221                         {
1222                                 m_bCompressed = TRUE;
1223                                 //m_fRatio = (float)m_compressedsize / (float)(inputsize * INDY_STRIP_HEIGHT);
1224                         }
1225
1226                         memset(pbyInputImageBuffer, 0x00, inputsize * INDY_STRIP_HEIGHT);
1227
1228                         m_lPrinterRasterRow += m_lCurrCDRasterRow;
1229                         m_lCurrBlockHeight = m_lCurrCDRasterRow;
1230                         m_lCurrCDRasterRow = 0;
1231                         iRastersReady = 1;
1232
1233                         ((LJFastRaster*)thePrinter)->phLJFastRaster->SetLastBand(FALSE);
1234                 }
1235                 else
1236                 {
1237                         return FALSE;
1238                 }
1239         }
1240         return TRUE;
1241 } //Process
1242
1243 BYTE* ModeDeltaPlus::NextOutputRaster(COLORTYPE color)
1244 // since we return 1-for-1, just return result first call
1245 {
1246         if (iRastersReady==0)
1247                 return (BYTE*)NULL;
1248
1249         if (color == COLORTYPE_BLACK)
1250         {
1251                 return (BYTE*)NULL;
1252         }
1253         else
1254         {
1255                 iRastersReady=0;
1256                 return compressBuf;
1257         }
1258 }
1259
1260 unsigned int ModeDeltaPlus::GetOutputWidth(COLORTYPE  color)
1261 {
1262         if (color == COLORTYPE_COLOR)
1263         {
1264                 return m_compressedsize;
1265         }
1266         else
1267         {
1268                 return 0;
1269         }
1270 } //GetOutputWidth
1271
1272 APDK_END_NAMESPACE
1273
1274 #endif  // defined APDK_LJFASTRASTER