/*****************************************************************************\
  dj3320.cpp : Implimentation for the DJ3320 class

  Copyright (c) 2001 - 2015, HP Co.
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions
  are met:
  1. Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
  2. Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.
  3. Neither the name of HP nor the names of its
     contributors may be used to endorse or promote products derived
     from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  TO, PATENT INFRINGEMENT; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\***************************************************************************/

#ifdef APDK_DJ3320

#include "header.h"
#include "io_defs.h"
#include "dj3320.h"
#include "resources.h"
#include "printerproxy.h"

APDK_BEGIN_NAMESPACE
extern BYTE* GetHT3x3_4();
extern BYTE* GetHT6x6_4_970();
APDK_END_NAMESPACE

APDK_BEGIN_NAMESPACE

extern uint32_t ulMapDJ3320_K_3x3x1[9 * 9 * 9];
extern uint32_t ulMapDJ3320_K_6x6x1[9 * 9 * 9];
extern uint32_t ulMapDJ3320_CMY_3x3x1[9 * 9 * 9];
extern uint32_t ulMapDJ3320_CMY_6x6x1[9 * 9 * 9];
extern uint32_t ulMapDJ3320_KCMY_3x3x1[9 * 9 * 9];
extern uint32_t ulMapDJ3320_KCMY_6x6x1[9 * 9 * 9];
extern uint32_t ulMapDJ970_Gossimer_Normal_KCMY[ 9 * 9 * 9 ];

extern uint32_t ulMapDJ3600_KCMY_6x6x1[9 * 9 * 9];
extern uint32_t ulMapDJ3600_ClMlxx_6x6x1[9 * 9 * 9];
extern uint32_t ulMapDJ3600_KCMY_6x6x2[9 * 9 * 9];
extern uint32_t ulMapDJ3600_ClMlxx_6x6x2[9 * 9 * 9];
extern uint32_t ulMapDJ3600_KCMY_3x3x1[9 * 9 * 9];
extern uint32_t ulMapDJ3600_ClMlxx_3x3x1[9 * 9 * 9];

extern void AsciiHexToBinary(BYTE* dest, char* src, int count);

#define NULL 0
//#define DBG1(str)
//#define DBG2(str, i) {}
//#define DBG3(str, i, j) {}

DJ3320::DJ3320 (SystemServices* pSS, BOOL proto)
: Printer(pSS,NUM_DJ6XX_FONTS,proto), m_dsCurrentStatus(DISPLAY_PRINTING)
{

    pLDLEncap = NULL;
    m_iBytesPerSwing = 2;
    m_iLdlVersion = 1;
    m_iColorPenResolution = 300;
    m_iBlackPenResolution = 1200;
    m_iNumBlackNozzles    = 400;

    if (IOMode.bDevID)
    {
        bCheckForCancelButton = TRUE;
        constructor_error = VerifyPenInfo ();
        CERRCHECK;
//        pSS->GetVertAlignFromDevice();
    }
    else
        ePen = BOTH_PENS;    // matches default mode
    CMYMap = ulMapDJ3320_CMY_3x3x1;
    InitPrintModes ();

    if (pSendBuffer)
    {
        pSS->FreeMem (pSendBuffer);
    }
    pSendBuffer = pSS->AllocMem (iBuffSize);
    CNEWCHECK (pSendBuffer);
}

void    DJ3320::InitPrintModes ()
{
    if (ePen == BLACK_PEN || ePen == MDL_PEN)
    {
        pMode[GRAYMODE_INDEX]    = new DJ3320KDraftMode ();
        pMode[DEFAULTMODE_INDEX] = new DJ3320GrayMode (ePen);
        ModeCount = 2;
    }
    else if (ePen == BOTH_PENS)
    {
        pMode[GRAYMODE_INDEX]       = new DJ3320GrayMode (ePen);
        pMode[DEFAULTMODE_INDEX]    = new DJ3320NormalMode (ePen);
        pMode[SPECIALMODE_INDEX]    = new DJ3320PhotoMode ();
        pMode[SPECIALMODE_INDEX+1]  = new DJ3320KDraftMode ();
        pMode[SPECIALMODE_INDEX+2]  = new DJ3320DraftMode (ePen);
        ModeCount = 5;
    }
	else if (ePen == MDL_BOTH)
	{
		pMode[GRAYMODE_INDEX]       = new DJ3320GrayMode (ePen);
        pMode[DEFAULTMODE_INDEX]    = new DJ3600MDLNormalMode ();
        pMode[SPECIALMODE_INDEX]    = new DJ3320KDraftMode ();
		pMode[SPECIALMODE_INDEX+1]  = new DJ3600MDLDraftMode ();
		pMode[SPECIALMODE_INDEX+2]  = new DJ3600MDLPhotoMode ();
        ModeCount = 5;
	}
    else
    {
        pMode[DEFAULTMODE_INDEX]    = new DJ3320NormalMode (ePen);
        pMode[SPECIALMODE_INDEX]    = new DJ3320PhotoMode ();
        pMode[GRAYMODE_INDEX]       = new DJ3320DraftMode (ePen);
        ModeCount = 3;
    }
}

DRIVER_ERROR DJ3320::SetPens (PEN_TYPE eNewPen)
{
    if (eNewPen == ePen)
    {
        return NO_ERROR;
    }
    ASSERT (eNewPen <= MAX_PEN_TYPE);
    if (eNewPen > MAX_PEN_TYPE)
    {
        return UNSUPPORTED_PEN;
    }

    for (int i = 0; i < (int) ModeCount; i++)
    {
        if (pMode[i])
        {
            delete pMode[i];
            pMode[i] = NULL;
        }
    }
    ePen = eNewPen;
    InitPrintModes ();
    AdjustResolution ();

    return NO_ERROR;
} //SetPens

DJ3320::~DJ3320 ()
{
   if (ePen == COLOR_PEN && pMode[GRAYMODE_INDEX])
   {
        delete pMode[GRAYMODE_INDEX];
        pMode[GRAYMODE_INDEX] = NULL;
    }
    if (pLDLEncap)
        delete pLDLEncap;
    if (pSendBuffer)
        pSS->FreeMem ((BYTE *) pSendBuffer);
    pSendBuffer = NULL;
}

DJ3320GrayMode::DJ3320GrayMode (PEN_TYPE ePen) : PrintMode (ulMapDJ3320_K_6x6x1)
{
	if (ePen == MDL_BOTH)
	{
		cmap.ulMap2 = ulMapDJ3600_ClMlxx_6x6x1;
	}

    ColorDepth[K] = 1;
    dyeCount = 1;
    pmColor = GREY_K;
    CompatiblePens[1] = BLACK_PEN;
	CompatiblePens[2] = MDL_BOTH;
	CompatiblePens[3] = MDL_PEN;

    ResolutionX[0] = 600;
    ResolutionY[0] = 600;

    BaseResX = 600;
    BaseResY = 600;

    MixedRes = FALSE;
    bFontCapable = FALSE;
    Config.bCompress = FALSE;
}

DJ3320KDraftMode::DJ3320KDraftMode () : GrayMode (ulMapDJ3320_K_3x3x1)
{
    bFontCapable = FALSE;
    Config.bCompress = FALSE;
    theQuality = qualityDraft;
    pmQuality = QUALITY_DRAFT;
	CompatiblePens[2] = MDL_BOTH;
	CompatiblePens[3] = MDL_PEN;
}

DJ3320DraftMode::DJ3320DraftMode (PEN_TYPE ePen)
: PrintMode (ulMapDJ3320_KCMY_3x3x1)
{

    if (ePen == COLOR_PEN)
    {
        CompatiblePens[1] = ePen;
        cmap.ulMap1 = ulMapDJ3320_CMY_3x3x1;
        dyeCount = 3;
    }

    for (int i = 0; i < 4; i++)
    {
        ColorDepth[i] = 1;

        ResolutionX[i] = 300;
        ResolutionY[i] = 300;
    }
    MixedRes = FALSE;
    BaseResX = 300;
    BaseResY = 300;
    bFontCapable = FALSE;
    pmQuality = QUALITY_DRAFT;
    Config.bCompress = FALSE;

//    strcpy(ModeName, "Draft");
}

DJ3320NormalMode::DJ3320NormalMode (PEN_TYPE ePen)
: PrintMode (ulMapDJ3320_KCMY_6x6x1)
{

    if (ePen == COLOR_PEN)
    {
        CompatiblePens[1] = ePen;
        cmap.ulMap1 = ulMapDJ3320_CMY_6x6x1;
        dyeCount = 3;
    }

    for (int i = 0; i < 4; i++)
    {
        ColorDepth[i] = 1;

        ResolutionX[i] = 600;
        ResolutionY[i] = 600;
    }

    BaseResX = 600;
    BaseResY = 600;
    MixedRes = FALSE;

    bFontCapable = FALSE;
    Config.bCompress = FALSE;

//    strcpy(ModeName, "Normal");
}

DJ3320PhotoMode::DJ3320PhotoMode ()
: PrintMode (ulMapDJ970_Gossimer_Normal_KCMY)
{

    for (int i = 0; i < 4; i++)
    {
        ColorDepth[i] = 2;

        ResolutionX[i] = 600;
        ResolutionY[i] = 600;
    }
    ColorDepth[0] = 1;
    CompatiblePens[1] = COLOR_PEN;

    BaseResX = 600;
    BaseResY = 600;
    MixedRes = FALSE;

    ColorFEDTable = GetHT6x6_4_970 ();

    bFontCapable = FALSE;

    pmQuality = QUALITY_BEST;
    pmMediaType = MEDIA_PHOTO;

    medium = mediaGlossy;
    theQuality = qualityPresentation;

    Config.bCompress = FALSE;
}


//
// Plain Normal Print Mode for Photo and Color Pen
//
DJ3600MDLNormalMode::DJ3600MDLNormalMode()
: PrintMode( ulMapDJ3600_KCMY_6x6x1, ulMapDJ3600_ClMlxx_6x6x1 )
{
	dyeCount=6;
	CompatiblePens[0] = MDL_BOTH;

    for (int i = 0; i < 6; i++)
    {
        ColorDepth[i] = 1;

        ResolutionX[i] = 600;
        ResolutionY[i] = 600;
    }

    BaseResX = 600;
    BaseResY = 600;
    MixedRes = FALSE;

    bFontCapable = FALSE;
    Config.bCompress = FALSE;
}

//
// Photo Best Print Mode for Photo and Color Pen
//
DJ3600MDLPhotoMode::DJ3600MDLPhotoMode()
: PrintMode( ulMapDJ3600_KCMY_6x6x2, ulMapDJ3600_ClMlxx_6x6x2 )
{
	dyeCount=6;
	CompatiblePens[0] = MDL_BOTH;

    for (int i = 0; i < 6; i++)
    {
        ColorDepth[i] = 2;

        ResolutionX[i] = 600;
        ResolutionY[i] = 600;
    }

    BaseResX = 600;
    BaseResY = 600;
    MixedRes = FALSE;


    ColorFEDTable = (BYTE*) HT600x6004level3600_open;

    bFontCapable = FALSE;

    pmQuality = QUALITY_BEST;
    pmMediaType = MEDIA_PHOTO;

    medium = mediaGlossy;
    theQuality = qualityPresentation;
    Config.bCompress = FALSE;
}

//
// Draft Mode for Photo and Color Pen
//
DJ3600MDLDraftMode::DJ3600MDLDraftMode()
: PrintMode( ulMapDJ3600_KCMY_3x3x1, ulMapDJ3600_ClMlxx_3x3x1 )
{
	dyeCount=6;
	CompatiblePens[0] = MDL_BOTH;

    for (int i = 0; i < 6; i++)
    {
        ColorDepth[i] = 1;

        ResolutionX[i] = 300;
        ResolutionY[i] = 300;
    }

    BaseResX = 300;
    BaseResY = 300;
    MixedRes = FALSE;

    bFontCapable = FALSE;
	pmQuality = QUALITY_DRAFT;
    Config.bCompress = FALSE;
}

DRIVER_ERROR DJ3320::Encapsulate (const RASTERDATA *pRasterData, BOOL bLastPlane)
{
    return pLDLEncap->Encapsulate (pRasterData->rasterdata[COLORTYPE_COLOR], pRasterData->rastersize[COLORTYPE_COLOR], bLastPlane);
}

Header* DJ3320::SelectHeader(PrintContext* pc)
{
    pLDLEncap = new LDLEncap (this, pSS, pc);
    if (pLDLEncap)
        pLDLEncap->AllocateSwathBuffer ((pc->OutputPixelsPerRow ()) / 8 + 2);
    if (pLDLEncap->constructor_error != NO_ERROR)
        return NULL;

    return new Header3320 (this,pc);
}

/*
 *    Author: Don Castrapel
 */

DISPLAY_STATUS DJ3320::ParseError (BYTE byStatusReg)
{
    DRIVER_ERROR err = NO_ERROR;
    BYTE byDevIDBuffer[DevIDBuffSize];
    const char *pcStr = NULL;
    BYTE byStatus1, byStatus2;

    memset(byDevIDBuffer, 0, sizeof(byDevIDBuffer));
    byStatus1 = byStatus2 = 0;

    if (IOMode.bDevID)
    {
        // If a bi-di cable was plugged in and everything was OK, let's see if it's still
        // plugged in and everything is OK
        err = pSS->GetDeviceID (byDevIDBuffer, DevIDBuffSize, TRUE);
        if (err)
        {
            // job was bi-di but now something's messed up, probably cable unplugged
            m_dsCurrentStatus = DISPLAY_COMM_PROBLEM;
            return DISPLAY_COMM_PROBLEM;
        }
    }

    if (IOMode.bStatus)
    {
        if(pLDLEncap->bNewStatus)
        {
            pLDLEncap->bNewStatus = FALSE;

            // First 10 bytes of m_pbyReadBuff are packet header.  Status query from printer has $S:
            if ((pcStr = (char *) strstr((const char*)pLDLEncap->byStatusBuff + 10, "$S:")) == NULL)
            {
                m_dsCurrentStatus = DISPLAY_COMM_PROBLEM;
                return DISPLAY_COMM_PROBLEM;
            }

            // Point to first byte of Feature State.  Skip 3 bytes for "$S:", 2 for version
            pcStr += 5;
            byStatus1 = *pcStr;

            if (byStatus1 == '9')
            {
                iTotal_SLOW_POLL_Count = 0;
                m_dsCurrentStatus = DISPLAY_TOP_COVER_OPEN;
                return DISPLAY_TOP_COVER_OPEN;
            }

            // Point to Printer State.  Skip 14-byte Feature State
            pcStr += 14;
            byStatus1 = *pcStr++;
            byStatus2 = *pcStr++;

            // In any of the cases where we know what's wrong, reset the slow poll count, which we're
            // using as a "we know what's going on" variable, to 0 since we do know what's going on
            if ((byStatus1 == '0') && (byStatus2 == '5'))
            {
                // 05 = CNCL state
                iTotal_SLOW_POLL_Count = 0;
                m_dsCurrentStatus = DISPLAY_PRINTING_CANCELED;
                return DISPLAY_PRINTING_CANCELED;
            }
            if ((byStatus1 == '0') && (byStatus2 == '9'))
            {
                // 09 = OOP state
                iTotal_SLOW_POLL_Count = 0;
                m_dsCurrentStatus = DISPLAY_OUT_OF_PAPER_NEED_CONTINUE;
                return DISPLAY_OUT_OF_PAPER_NEED_CONTINUE;
            }
            if ((byStatus1 == '0') && (byStatus2 == 'E'))
            {
                // 0E = Paper jam
                iTotal_SLOW_POLL_Count = 0;
                m_dsCurrentStatus = DISPLAY_ERROR_TRAP;
                return DISPLAY_ERROR_TRAP;
            }
            if ((byStatus1 == '0') && (byStatus2 == 'F'))
            {
                // 0F = Carriage stall
                iTotal_SLOW_POLL_Count = 0;
                m_dsCurrentStatus = DISPLAY_ERROR_TRAP;
                return DISPLAY_ERROR_TRAP;
            }
            if ((byStatus1 == '1') && (byStatus2 == '0'))
            {
                // 10 = Paper stall
                iTotal_SLOW_POLL_Count = 0;
                m_dsCurrentStatus = DISPLAY_ERROR_TRAP;
                return DISPLAY_ERROR_TRAP;
            }

            // No problem detectable from status string.  Set default condition
            m_dsCurrentStatus = DISPLAY_PRINTING;
        }

        // VerifyPenInfo will handle prompting the user if this is a problem
        err = VerifyPenInfo();
        if(err)
            // VerifyPenInfo returned an error, which can only happen when ToDevice
            // or GetDeviceID returns an error. Either way, it's BAD_DEVICE_ID or
            // IO_ERROR, both unrecoverable.  This is probably due to the printer
            // being turned off during printing
            return DISPLAY_COMM_PROBLEM;
    }

    // Don't know what the problem is.  Increment wait count.  i_Total_SLOW_POLL_Count
    // really has no meaning for the DJ3320, but since it's a printer class variable
    // and it's not used for the DJ3320 we'll use it here rather than create another
    // printer class variable
    iTotal_SLOW_POLL_Count++;

    // If we've exceeded our wait time and we still don't know what's wrong, return
    // a communication problem
    if(iTotal_SLOW_POLL_Count >= ERROR_WAIT)
        return DISPLAY_BUSY;
    else
        return m_dsCurrentStatus;
}

/*
 *    Author: Don Castrapel
 */

DRIVER_ERROR DJ3320::Send (const BYTE* pWriteBuff, DWORD dwWriteCount)
{
    DRIVER_ERROR    err = NO_ERROR;
    DISPLAY_STATUS  eDisplayStatus = DISPLAY_PRINTING;
    DWORD           dwResidual = 0;
    DWORD           dwPrevResidual = 0;
    const BYTE      *pWritePos = NULL;
    BYTE            byPacketType = 0;
    BYTE            byCommandNumber = 0;
    BYTE            byCommandNumberOriginal = 0;
    BYTE            byCreditWaitCount = 0;
    BYTE            byCreditWaitCountOriginal = 0;
    BYTE            byIOWaitCount = 0;
    BOOL            bUpdateState = FALSE;
    BOOL            bCreditForCommand = FALSE;
    BOOL            bFlush = FALSE;
    BOOL            bOriginalRequest = TRUE;

    // DJ3400 doesn't use a staus reg, but we need one for the call to ParseError
    BYTE            byStatusReg = 0;

    // Buffering variables
    DWORD           BytesToWrite = dwWriteCount;
    DWORD           BytesToWriteOriginal = dwWriteCount;
    const BYTE      *pWriteBuffOriginal = pWriteBuff;
    const BYTE      *pBuffer = pWriteBuff;
    DWORD           dwWriteCountOriginal = dwWriteCount;
    DWORD           dwSendSize = dwWriteCount;

    // Retry, query, and cancel variables
    BOOL            bPrinterCancelButton = FALSE;
    BOOL            bCanceling = FALSE;
    BOOL            bCanceled = FALSE;

////////////////////////////////////////////////////////////////
#ifdef NULL_IO
    // test imaging speed independent of printer I/O, will not
    // send any data to the device
    return NO_ERROR;
#endif
////////////////////////////////////////////////////////////////

    if (!IOMode.bDevID)
    {
        return pSS->ToDevice (pWriteBuff, &dwSendSize);
    }

    if (ErrorTerminationState)
    {
        // Don't try any more I/O if we previously terminated in an error state
        return JOB_CANCELED;
    }

    // If EndJob is TRUE we don't want to return.  The Job destructor is the only place that sets this
    // boolean and we have to flush the buffer if EndJob is TRUE.
    if (!EndJob)
    {
        if (dwWriteCount == 0)
            // Don't bother processing an empty Send call
            return NO_ERROR;

        // Get Packet Type.  If Packet Type is a command, buffer it if buffering is turned on.  If it's
        // a different Packet Type, send it directly to the printer
        byPacketType = pWriteBuff[PACKET_TYPE_BYTE];

        // Get Command Number if packet is a command.  If it is then we need to check for credit
        // before we send the command
        if(!byPacketType)
        {
            byCommandNumber = pWriteBuff[COMMAND_NUMBER_BYTE];
            byCommandNumberOriginal = pWriteBuff[COMMAND_NUMBER_BYTE];
        }
    }
    else
    {
        // Just flush whatever is in the buffer
        bFlush = TRUE;
    }

    do
    {
        // If it's a command, check to see if we have credit for it.  If it's a special packet type,
        // we'll just send it directly to the printer
        if(!bCreditForCommand)
        {
            // Could be first time through do loop or could have not had credit and had to check.  We'll
            // always get here since we don't change bCreditForCommand until here.
            if (!byPacketType)
            {
                // Check to see if we have credit for this command
                if (pLDLEncap->piCreditCount[byCommandNumber] > 0)
                {
                    pLDLEncap->piCreditCount[byCommandNumber]--;
                    bCreditForCommand = TRUE;
                    byCreditWaitCount = 0;
                }
                else
                {
                    byCreditWaitCount++;

                    bUpdateState = pLDLEncap->UpdateState (FALSE);
                    if(bUpdateState)
                    {
                        pSS->BusyWait(0);
                        // Rechecking here will save us a trip through the do loop
                        if (pLDLEncap->piCreditCount[byCommandNumber] > 0)
                        {
                            pLDLEncap->piCreditCount[byCommandNumber]--;
                            bCreditForCommand = TRUE;
                            byCreditWaitCount = 0;
                        }
                    }
                }
            }
            else
            {
                // Special packet types get a free pass
                bCreditForCommand = TRUE;
            }
        } // if(!bCreditForCommand)

        // If we don't have credit for the current command we don't want to put it in the
        // buffer.  If, however, we have exceeded our credit wait limit and we need to check
        // for an error, we have to flush what's in our buffer
        if (bCreditForCommand || bFlush)
        {
            if (bCreditForCommand)
            {
                // We should bypass the buffering for a large Send, but don't lose what may
                // already be buffered
                if ((BytesToWrite >= (DWORD) iBuffSize) && (iCurrBuffSize == 0))
                {
                    pBuffer = pWriteBuff + (dwWriteCount - BytesToWrite);
                    dwSendSize = BytesToWrite;
                    BytesToWrite = 0;  // This is checked for at the end of the outer loop
                }
                else // We will buffer this data
                {
                    // If it'll fit then just copy everything to the buffer
                    if (BytesToWrite <= (DWORD) iBuffSize - iCurrBuffSize)
                    {
                        memcpy ((void*) (pSendBuffer + iCurrBuffSize),
                                (void*) (pWriteBuff + (dwWriteCount - BytesToWrite)),
                                BytesToWrite);
                        iCurrBuffSize += BytesToWrite;
                        BytesToWrite = 0;
                    }
                    else // Copy what we can into the buffer, we'll get the rest later
                    {
                        memcpy ((void*) (pSendBuffer + iCurrBuffSize),
                                (void*) (pWriteBuff + (dwWriteCount - BytesToWrite)),
                                iBuffSize - iCurrBuffSize);
                        BytesToWrite -= (iBuffSize - iCurrBuffSize);
                        iCurrBuffSize = iBuffSize;
                    }
                }

                // If this wasn't the original request, like a query, continue, prepare to
                // cancel, or cancel command, flush the buffer immediately
                if(!bOriginalRequest)
                {
                    bFlush = TRUE;
                }
            } // if (bCreditForCommand)

            // If the buffer is now full (ready-to-send) or if we're at the end of the job, or
            // if the Packet Type is not a command then send what we have in the buffer.
            // otherwise just break (the buffer isn't ready to send)
            if ((EndJob == FALSE) && (iCurrBuffSize != iBuffSize)  && (!byPacketType) && (!bFlush) )
            {
                // We're not ready to send yet.  Break out of do loop
                break;
            }
            else // Send this buffered data
            {
                if (bFlush)
                {
                    bFlush = FALSE;
                }
                pBuffer = pSendBuffer;
                dwSendSize = iCurrBuffSize;
            }

            // Initialize our 'residual' to the full send size
            dwResidual = dwSendSize;

            // Code to check to see if user has pressed cancel button.  DJ3320 front panel button, if
            // pressed during normal printing, will initiate a cancel in the printer.  This will cause the
            // printer to just throw away data but not notify the host.  We have to do that here if we
            // detect a cancel
            if(bCheckForCancelButton && (ulBytesSentSinceCancelCheck >= CANCEL_BUTTON_CHECK_THRESHOLD))
            {
                ulBytesSentSinceCancelCheck = 0;

                if(ParseError(byStatusReg) == DISPLAY_PRINTING_CANCELED)
                    bPrinterCancelButton = TRUE;
            }

            // If we have nothing to send, we need to bail to avoid spurious dialogs
            // at the end of the ::send function.  I'd prefer a solution where we don't
            // bail from a while loop but in practice this shouldn't have any ill effects.
            if (dwResidual <= 0)
            {
                return NO_ERROR;
            }

            // While still data to send in this request
            while (dwResidual > 0)
            {
                // WritePort overwrites request count, need to save
                dwPrevResidual = dwResidual;

                pWritePos = (const BYTE *) &(pBuffer[dwSendSize - dwResidual]);
                err = pSS->ToDevice (pWritePos, &dwResidual);

                if(err)
                {
                    ErrorTerminationState = TRUE;
                    return err;
                }

                // No more data to send this time
                if (dwResidual == 0)
                {
                    // For USB printer class drivers that have buffering we need to flush the buffer.
                    // If we are sending a special packet type and can't wait for a full buffer we have
                    // to flush
                    err = pSS->FlushIO ();
                    if (err)
                    {
                        ErrorTerminationState = TRUE;
                        return err;
                    }
                    // We successfully sent the entire non-original request, so reset to original
                    // request
                    if(!bOriginalRequest && !bCanceled)
                    {
                        pWriteBuff = pWriteBuffOriginal;
                        dwWriteCount = dwWriteCountOriginal;
                        BytesToWrite = BytesToWriteOriginal;
                        byCommandNumber = byCommandNumberOriginal;
                        bOriginalRequest = TRUE;
                        bCreditForCommand = FALSE;
                        byCreditWaitCount = byCreditWaitCountOriginal;
                        // We have to give the printer some time to update its status and send us a
                        // new status packet
                        pSS->BusyWait(500);
                    }
                    else
                    {
                        if(bOriginalRequest)
                        {
                            byIOWaitCount = 0;
                        }

                        iTotal_SLOW_POLL_Count = 0;
                    }

                    break; // Out of while loop
                }
                else
                {
                    if (dwPrevResidual == dwResidual)
                    {
                        // The I/O didn't take any data, increment count
                        byIOWaitCount++;
                    }
                    else
                    {
                        // The I/O took some data, although not the full request
                        if(bOriginalRequest)
                            byIOWaitCount = 0;
                    }
                }

                // If I/O hasn't finished after our timeout limit, we have to bail.
                if (byIOWaitCount >= IO_WAIT)
                {
                    ErrorTerminationState = TRUE;
                    pSS->DisplayPrinterStatus (DISPLAY_COMM_PROBLEM);
                    return IO_ERROR;
                }

                // Check for user cancel each time through loop
                if (pSS->BusyWait ((DWORD)0) == JOB_CANCELED)
                {
                    pSS->DisplayPrinterStatus (DISPLAY_PRINTING_CANCELED);
                }

            } // while (residual > 0)

            iCurrBuffSize = 0;

        } // if(bCreditForCommand || bFlush)
        else
        {
            // If we can't get credit and we've exceeded our wait limit, check for an error
            if (byCreditWaitCount >= CREDIT_WAIT)
            {
                if(!bOriginalRequest)
                {
                    // Something is wrong but we don't know what it is and we can't get credit
                    // to Query, Continue, Prepare to Cancel, or Cancel, so we have to bail
                    ErrorTerminationState = TRUE;
                    return JOB_CANCELED;
                }
                // Flush our internal buffer so that we can send command such as query or continue
                if (iCurrBuffSize)
                {
                    bFlush = TRUE;
                }
                else
                {
                    // See if we can find out what's wrong
                    eDisplayStatus = ParseError(byStatusReg);

                    // For recoverable cases such as out of paper or top cover open, we just want to
                    // display the error and break.  For non-recoverable cases we'll wait for the
                    // user to cancel the job and return.

                    // If the user terminated in an error state we have to send the CancelJob,
                    // unless the error state is a condition that would prevent a paper eject, such
                    // as paper jam or error trap.  In those cases we'll just return, since the
                    // user has to power cycle the printer before he can continue
                    switch (eDisplayStatus)
                    {
                        case DISPLAY_PRINTING_CANCELED:
                            // User canceled in an error condition, break from here and let check
                            // for cancel at end of do loop send Cancel Job to printer
                            pSS->DisplayPrinterStatus (eDisplayStatus);
                            ErrorTerminationState = TRUE;

                            break;

                        case DISPLAY_ERROR_TRAP:
                        case DISPLAY_COMM_PROBLEM:
                            // These are unrecoverable cases.  Don't let any more of this job be sent
                            // to the printer.  We can't even eject the page at the end of the job

                            ErrorTerminationState = TRUE;
                            pSS->DisplayPrinterStatus (eDisplayStatus);

                            // Wait for user to cancel the job, otherwise they might miss the
                            // error message
                            while (pSS->BusyWait ((DWORD) 500) != JOB_CANCELED)
                            {
                                // nothing....
                                ;
                            }

                            return IO_ERROR;

                        case DISPLAY_TOP_COVER_OPEN:
                            pSS->DisplayPrinterStatus(DISPLAY_TOP_COVER_OPEN);

                            err = NO_ERROR;

                            // Wait for top cover to close or user to cancel
                            while(eDisplayStatus == DISPLAY_TOP_COVER_OPEN && !err)
                            {
                                err = pSS->BusyWait((DWORD)500);
                                if(err == JOB_CANCELED)
                                {
                                    ErrorTerminationState = TRUE;
                                }

                                if(!err)
                                {
                                    bUpdateState = pLDLEncap->UpdateState(FALSE);
                                    if(bUpdateState)
                                    {
                                        eDisplayStatus = ParseError(byStatusReg);

                                        // Need to check for cancel here, because we could miss it if the
                                        // user presses cancel button then lifts lid or something
                                        if(eDisplayStatus == DISPLAY_PRINTING_CANCELED)
                                        {
                                            ErrorTerminationState = TRUE;
                                            bPrinterCancelButton = TRUE;
                                        }
                                    }
                                }
                            } // while(eDisplayStatus == DISPLAY_TOP_COVER_OPEN && !err)

                            if(!err && !bPrinterCancelButton)
                            {
                                pSS->DisplayPrinterStatus(DISPLAY_PRINTING);

                                // Give the printer some time to come back online
                                if(pSS->BusyWait((DWORD)1000) == JOB_CANCELED)
                                {
                                    ErrorTerminationState = TRUE;
                                }
                            }

                            break;

                        case DISPLAY_OUT_OF_PAPER_NEED_CONTINUE:
                            pSS->DisplayPrinterStatus (DISPLAY_OUT_OF_PAPER_NEED_CONTINUE);

                            err = NO_ERROR;

                            // Wait for user to add more paper and press resume button on printer or
                            // select CONTINUE button from host's error dialog
                            while(eDisplayStatus == DISPLAY_OUT_OF_PAPER_NEED_CONTINUE && !err)
                            {
                                err = pSS->BusyWait((DWORD)500);

                                if (err == JOB_CANCELED)
                                {
                                    ErrorTerminationState = TRUE;
                                }
                                else if(err == CONTINUE_FROM_BLOCK)
                                {
                                    // Setup CONTINUE command
                                    pWriteBuff = byContinue;
                                    dwWriteCount = sizeof(byContinue);
                                    BytesToWrite = sizeof(byContinue);
                                    byCommandNumber = COMMAND_CONTINUE;
                                    bOriginalRequest = FALSE;
                                    bCreditForCommand = FALSE;
                                    byCreditWaitCountOriginal = byCreditWaitCount;
                                    byCreditWaitCount = 0;
                                }
                                else
                                {
                                    bUpdateState = pLDLEncap->UpdateState(FALSE);
                                    if(bUpdateState)
                                    {
                                        eDisplayStatus = ParseError(byStatusReg);

                                        // Need to check for cancel here, because we could miss it if the
                                        // user presses cancel button then lifts lid or something
                                        if(eDisplayStatus == DISPLAY_PRINTING_CANCELED)
                                        {
                                            ErrorTerminationState = TRUE;
                                            bPrinterCancelButton = TRUE;
                                        }
                                    }
                                }
                            } // while(eDisplayStatus == DISPLAY_OUT_OF_PAPER_NEED_CONTINUE && !err)

                            if(!err && !bPrinterCancelButton)
                            {
                                pSS->DisplayPrinterStatus(DISPLAY_PRINTING);
                            }

                            break;

                        case DISPLAY_BUSY:
                            pSS->DisplayPrinterStatus(DISPLAY_BUSY);

                            if (pSS->BusyWait ((DWORD) 5000) == JOB_CANCELED)
                            {
                                ErrorTerminationState = TRUE;
                            }

                            break;

                        // Other cases need no special handling, display the error and try to continue
                        default:
                            pSS->DisplayPrinterStatus (eDisplayStatus);

                            if (pSS->BusyWait ((DWORD) 500) == JOB_CANCELED)
                            {
                                ErrorTerminationState = TRUE;
                            }

                            break;
                    } // switch(eDisplayStatus)
                } // else(iCurrBuffSize)
            } // if(byCreditWaitCount >= CREDIT_WAIT)
        } // else(bCreditForCommand || bFlush)

        if (pSS->BusyWait ((DWORD)0) == JOB_CANCELED || bPrinterCancelButton)
        {
            pSS->DisplayPrinterStatus(DISPLAY_PRINTING_CANCELED);

            // If there is anything waiting in the buffer, send it.  I/O may have had a full buffer and
            // may not have been able to buffer the full request for which we had credit, so if there
            // are still BytesToWrite and we have credit for the current command, we have to buffer
            // those and send them if we didn't terminate in an error condition.

            // Another possibility is that we don't have credit for the current command.  In that case
            // we don't want to wait for BytesToWrite to be 0 or we'll be in a deadlock.  We'll never
            // get credit for the command and thus BytesToWrite will never be 0.

            // We can only terminate in an error condition if we didn't have credit for the original
            // command, so in that case we only have to flush what's in the buffer and not worry about
            // the remaining BytesToWrite.

            // After we check for these conditions we can send the Prepare to Cancel and Cancel
            // Job commands
            if( (iCurrBuffSize || (BytesToWrite && bCreditForCommand && !ErrorTerminationState) ) &&
               !(bCanceling || bCanceled) )
            {
                bFlush = TRUE;
            }
            else if(!bCanceling)
            {
                pWriteBuff = byPrepareToCancel;
                dwWriteCount = sizeof(byPrepareToCancel);
                BytesToWrite = sizeof(byPrepareToCancel);
                byCommandNumber = COMMAND_PREPARE_TO_CANCEL;
                bOriginalRequest = FALSE;
                bCreditForCommand = FALSE;
                byCreditWaitCount = 0;
                bCanceling = TRUE;
            }
            else if(!bCanceled)
            {
                // pWriteBuff will only be equal to byPrepareToCancel when we've setup the Prepare to
                // Cancel command but haven't yet sent it to the printer
                if(pWriteBuff != byPrepareToCancel)
                {
                    pWriteBuff = pLDLEncap->pbyCancel;
                    dwWriteCount = sizeof(pLDLEncap->pbyCancel);
                    BytesToWrite = sizeof(pLDLEncap->pbyCancel);
                    byCommandNumber = COMMAND_CANCEL;
                    bOriginalRequest = FALSE;
                    bCreditForCommand = FALSE;
                    byCreditWaitCount = 0;
                    bCanceled = TRUE;
                }
            }
        }
    } while (BytesToWrite > 0);

    if (bCanceled)
    {
        // Ensure that display still says we're cancelling
        pSS->DisplayPrinterStatus(DISPLAY_PRINTING_CANCELED);
        ErrorTerminationState = TRUE;
        return JOB_CANCELED;
    }
    else
    {
        // Ensure any error message has been cleared
        pSS->DisplayPrinterStatus (DISPLAY_PRINTING);
        if (bCheckForCancelButton)
        {
            ulBytesSentSinceCancelCheck += dwWriteCount;
        }
        return NO_ERROR;
    }
}

DRIVER_ERROR DJ3320::ParsePenInfo (PEN_TYPE& ePen, BOOL QueryPrinter)
{

    char    *str;
    int     num_pens = 0;

    DRIVER_ERROR err = SetPenInfo (str, QueryPrinter);
    ERRCHECK;

    // the first byte indicates how many pens are supported
    if ((str[0] >= '0') && (str[0] <= '9'))
    {
        num_pens = str[0] - '0';
    }
    else if ((str[0] >= 'A') && (str[0] <= 'F'))
    {
        num_pens = 10 + (str[0] - 'A');
    }
    else
    {
        return BAD_DEVICE_ID;
    }

    if ((int) strlen (str) < (num_pens * 8))
    {
        return BAD_DEVICE_ID;
    }

    char    *p = str + 1;
    BYTE    penInfoBits[4];
/*
 *  Pen Type Info
 *
    Bit 31 (1 bit)

    1 if these fields describe a print head
    0 otherwise
    Bit 30 (1 bit)

    1 if these fields describe an ink supply
    0 otherwise

    Bits 29 .. 24 (6 bits) describes the pen/supply type:

    0 = none
    1 = black
    2 = CMY
    3 = KCM
    4 = Cyan
    5 = Meganta
    6 = Yellow
	7 = Cyan - low dye load 
    8 = Magenta - low dye load 
    9 = Yellow - low dye load (may never be used, but reserve space anyway) [def added Jun 3, 2002]
    10 = gGK - two shades of grey plus black; g=light grey, G=medium Grey, K=black  [added Sep 12, 02]
    11 .. 62 = reserved for future use
    63=Unknown
 */
    ePen = NO_PEN;

    for (int i = 0; i < num_pens; i++, p += 8)
    {
		AsciiHexToBinary (penInfoBits, p, 8);
        if ((penInfoBits[1] & 0xf8) == 0xf8)
        {
//          The high 5 bits in the 3rd and 4th nibble (second byte) identify the
//          installed pen. If all 5 bits are on, user has installed an incompatible pen.
            return UNSUPPORTED_PEN;
        }
        if ((penInfoBits[0] & 0x80) != 0x80)        // if Bit 31 is 0, this is not a pen
        {
            continue;
        }
        BYTE penColor = penInfoBits[0] & 0x3F;
        switch (penColor)
        {
            case 0:
            {
                break;
            }
            case 1:
                ePen = BLACK_PEN;
                break;
            case 2:
            {
                if (ePen == BLACK_PEN)
                {
                    ePen = BOTH_PENS;
                }
                else if (ePen == MDL_PEN)
                {
                    ePen = MDL_BOTH;
                }
                else
                {
                    ePen = COLOR_PEN;
                }
                break;
            }
            case 3:
                if (ePen == BLACK_PEN)
                {
                    ePen = MDL_AND_BLACK_PENS;
                }
                else if (ePen == COLOR_PEN)
                {
                    ePen = MDL_BOTH;
                }
                else if (ePen == BOTH_PENS)
                {
                    ePen = MDL_BLACK_AND_COLOR_PENS;
                }
                else
                {
                    ePen = MDL_PEN;
                }
                break;
            case 4:             // cyan pen
            case 5:             // magenta pen
            case 6:             // yellow pen
            case 7:             // low dye load cyan pen
            case 8:             // low dye load magenta pen
            case 9:             // low dye load yellow pen
                if (ePen == BLACK_PEN || ePen == BOTH_PENS)
                {
                    ePen = BOTH_PENS;
                }
                else
                {
                    ePen = COLOR_PEN;
                }
                break;
            default:
                ePen = UNKNOWN_PEN;
        }
    }

    return NO_ERROR;
}

DRIVER_ERROR DJ3320::VerifyPenInfo()
{

    DRIVER_ERROR err = NO_ERROR;

    if(IOMode.bDevID == FALSE)
        return err;

    ePen = NO_PEN;

    err = ParsePenInfo(ePen);
    ERRCHECK;

    while (ePen == NO_PEN)
    {
        err = ParsePenInfo (ePen);
        ERRCHECK;
        if (ePen == NO_PEN)
        {
            pSS->DisplayPrinterStatus (DISPLAY_NO_PENS);
            if (pSS->BusyWait (500) == JOB_CANCELED)
                return JOB_CANCELED;
        }

    }

    pSS->DisplayPrinterStatus (DISPLAY_PRINTING);

    return NO_ERROR;
}

DRIVER_ERROR DJ3320::CheckInkLevel()
{
    DRIVER_ERROR err;
    char* pStr;

    BYTE bDevIDBuff[DevIDBuffSize];

    if (!IOMode.bDevID)
    {
        return NO_ERROR;
    }

    err = pSS->GetDeviceID(bDevIDBuff, DevIDBuffSize, TRUE);
    if (err!=NO_ERROR)
    {
        return NO_ERROR;
    }

    if ( (pStr=(char *)strstr((const char*)bDevIDBuff+2,";S:")) == NULL )
    {
        return NO_ERROR;
    }

    pStr += 21;
    int     numPens = 0;
    if (*pStr > '0' && *pStr < '9')
    {
        numPens = *pStr - '0';
    }
    else if (*pStr > 'A' && *pStr < 'F')
    {
        numPens = *pStr - 'A';
    }
    else if (*pStr > 'a' && *pStr < 'f')
    {
        numPens = *pStr - 'a';
    }

    pStr++;

	BYTE    penInfoBits[4];
    BYTE    blackink = 0;
    BYTE    colorink = 0;
    BYTE    photoink = 0;
    BYTE    greyink = 0;
    for (int i = 0; i < numPens; i++, pStr += 8)
    {
        AsciiHexToBinary (penInfoBits, pStr, 8);

        if ((penInfoBits[0] & 0x80) != 0x80)        // if Bit 31 is 0, this is not a pen
        {
            continue;
        }
        int penColor = penInfoBits[0] & 0x3F;
        switch (penColor)
        {
            case 1:
                blackink =  penInfoBits[1] & 0x7;
                break;
            case 2:
                colorink =  penInfoBits[1] & 0x7;
                break;
            case 3:
                photoink =  penInfoBits[1] & 0x7;
                break;
            case 10:
                greyink =  penInfoBits[1] & 0x7;
                break;
            case 4:
            case 5:
            case 6:
            case 7:
            case 8:
            case 9:
                colorink = penInfoBits[1] & 0x7;   // REVISIT: these are C, M, Y respectively
                break;
            default:
                break;
        }
    }
    if (blackink < 2 && colorink < 2 && photoink < 2 && greyink < 2)
    {
        return NO_ERROR;
    }
    else if (blackink > 1 && colorink > 1 && photoink > 1)
    {
        return WARN_LOW_INK_COLOR_BLACK_PHOTO;
    }
    else if (greyink > 1 && colorink > 1 && photoink > 1)
    {
        return WARN_LOW_INK_COLOR_GREY_PHOTO;
    }
    else if (blackink > 1 && colorink > 1)
    {
        return WARN_LOW_INK_BOTH_PENS;
    }
    else if (blackink > 1 && photoink > 1)
    {
        return WARN_LOW_INK_BLACK_PHOTO;
    }
    else if (greyink > 1 && colorink > 1)
    {
        return WARN_LOW_INK_COLOR_GREY;
    }
    else if (greyink > 1 && photoink > 1)
    {
        return WARN_LOW_INK_GREY_PHOTO;
    }
    else if (colorink > 1 && photoink > 1)
    {
        return WARN_LOW_INK_COLOR_PHOTO;
    }
    else if (blackink > 1)
    {
        return WARN_LOW_INK_BLACK;
    }
    else if (colorink > 1)
    {
        return WARN_LOW_INK_COLOR;
    }
    else if (photoink > 1)
    {
        return WARN_LOW_INK_PHOTO;
    }
    else if (greyink > 1)
    {
        return WARN_LOW_INK_GREY;
	}
    else if (colorink > 1)
    {
        return WARN_LOW_INK_COLOR;
    }
	else
	{
		return NO_ERROR;
	}
} //CheckInkLevel


DRIVER_ERROR DJ3320::SkipRasters (int nBlankRasters)
{
    return (pLDLEncap->SetVerticalSkip (nBlankRasters));
}

DRIVER_ERROR DJ3320::CleanPen()
{
    return pLDLEncap->CleanPen ();
}

DRIVER_ERROR DJ3320::Flush (int FlushSize)
{
    pLDLEncap->Flush ();
    return NO_ERROR;
}

Header3320::Header3320 (Printer* p,PrintContext* pc)
    : Header(p,pc)
{

}

DRIVER_ERROR Header3320::FormFeed ()
{
    return (((DJ3320 *) thePrinter)->pLDLEncap->EndPage ());
}

DRIVER_ERROR Header3320::EndJob()
{
    ((DJ3320 *) thePrinter)->pLDLEncap->EndJob ();
    return NO_ERROR;
}

DRIVER_ERROR Header3320::Send ()
{

    DJ3320  *pXBow = (DJ3320 *) thePrinter;

    return (pXBow->pLDLEncap->StartJob ());

}

DRIVER_ERROR Header3320::SendCAPy (unsigned int iAbsY)
{
    return NO_ERROR;
}

LDLEncap::LDLEncap (DJ3320 *pPrinter, SystemServices *pSys, PrintContext *pc)
{

    constructor_error = NO_ERROR;
    piCreditCount = NULL;
    m_pSys = pSys;
    pPrinterXBow = pPrinter;
    m_iXResolution = pc->EffectiveResolutionX ();
    m_iYResolution = pc->EffectiveResolutionY ();
    m_pthisPC = pc;
    m_cPrintDirection = PRNDRN_LEFTTORIGHT;
    m_SwathData = NULL;
    m_sRefCount = 6;
    m_iBlankRasters = 0;
    m_iRasterCount = 0;
    m_iVertPosn = (int) (m_pthisPC->PrintableStartY () * DEVUNITS_XBOW);
    m_iNumColors = 4;
    m_iLeftMargin = (int) (m_pthisPC->PrintableStartX () * DEVUNITS_XBOW);

    ////////////////////////////////////////////////////////////////////////////////////
    float   fXOverSpray = 0.0;
    float   fYOverSpray = 0.0;
    float   fLeftOverSpray = 0.0;
    float   fTopOverSpray  = 0.0;
	FullbleedType   fbType;
    if (m_pthisPC->bDoFullBleed &&
        pPrinterXBow->FullBleedCapable (m_pthisPC->thePaperSize,
									  &fbType,
                                      &fXOverSpray, &fYOverSpray,
                                      &fLeftOverSpray, &fTopOverSpray))
    {

		/*
		 *      To get the printer to do fullbleed printing, move the vertical postion 
		 *      to cover the overspary. Overspray is needed to take care of
		 *      skew during paper pick. These values may be mech dependent.
		 *      Currently, supported only on PhotoSmart 100, Malibu. DJ3600 supports
		 *      fullbleed printing also. The current values for overspray are
		 *      0.059 inch for top, bottom and left edges and 0.079 for right edge.
		 */
		m_iVertPosn = (int) (-fTopOverSpray * DEVUNITS_XBOW);
		m_iLeftMargin = (int) (-fLeftOverSpray * DEVUNITS_XBOW);
    }

    m_bStartPageNotSent = TRUE;

    m_iNextRaster = 0;
    m_iNextColor  = 0;

    m_iBitDepth = 1;
    m_cPlaneNumber = 0;
    m_cPrintQuality = (BYTE) QUALITY_NORMAL;
    m_cMediaType    = (BYTE) MEDIA_PLAIN;

    BYTE    cm = COLOR;
    QUALITY_MODE cqm;
    MEDIATYPE cmt;
    COLORMODE ccm;
    BOOL cdt;
    DRIVER_ERROR err = m_pthisPC->GetPrintModeSettings (cqm, cmt, ccm, cdt);
    if (err == NO_ERROR)
    {
        if (cqm == QUALITY_BEST && cmt == MEDIA_PHOTO)
            m_iBitDepth = 2;
        m_cPrintQuality = (BYTE) cqm;
        m_cMediaType    = (BYTE) cmt;
        cm = (BYTE) ccm;
    }

    if (pPrinterXBow->ePen == BLACK_PEN || pPrinterXBow->ePen == MDL_PEN || cm == GREY_K)
        m_iNumColors = 1;
    else if (pPrinterXBow->ePen == COLOR_PEN || cm == GREY_CMY)
        m_iNumColors = 3;
	else if (pPrinterXBow->ePen == BOTH_PENS && m_iBitDepth == 2)
		m_iNumColors = 3;
	else if (pPrinterXBow->ePen == MDL_BOTH)
		m_iNumColors = 6;

    m_bBidirectionalPrintingOn = TRUE; //FALSE;

    UInt16 mem_needed =   SIZEOF_LDLHDR
                        + SIZEOF_LDL_PRTSWP_CMDOPT
                        + SIZEOF_LDL_PRTSWP_OPTFLDS
                        + 6 * SIZEOF_LDL_PRTSWP_COLROPT
                        + SIZEOF_LDL_COLROPT_ACTIVECOLR
                        + SIZEOF_LDLTERM;
    m_szCmdBuf = new BYTE[mem_needed];
    CNEWCHECK (m_szCmdBuf);

    m_bLittleEndian = TRUE;
    {
        union
        {
            short   a;
            char    b[2];
        }c;
        c.a = 0x1234;
        if (c.b[0] == 0x12)
            m_bLittleEndian = FALSE;
    }

    m_szCmdBuf[0] = FRAME_SYN;
    m_szCmdBuf[1] = 0;
    m_szCmdBuf[3] = 0;
    m_szCmdBuf[4] = 0;
    m_szCmdBuf[5] = 0;
    m_szCmdBuf[6] = 0;
    m_szCmdBuf[8] = 0;

    // Pacing and status handling data
    bNewStatus = FALSE;
    memset(byStatusBuff, 0, sizeof(byStatusBuff));

    m_pbyPacketBuff = NULL;
    m_pbyPacketBuff = pSys->AllocMem (MAX_PACKET_READ_SIZE);
    CNEWCHECK (m_pbyPacketBuff);

    m_dwPacketBuffSize = MAX_PACKET_READ_SIZE;

    // Setup Sync command
    pbySync = m_pSys->AllocMem(SYNCSIZE);
    CNEWCHECK(pbySync);

    memset(pbySync, 0, SYNCSIZE);
    memcpy(pbySync, bySync, sizeof(bySync));
    memset((pbySync + sizeof(bySync)), 0, SYNC_CMD_OPT_SIZE);
    pbySync[sizeof(bySync) + SYNC_CMD_OPT_SIZE] = FRAME_SYN;
    memset((pbySync + sizeof(bySync) + SYNC_CMD_OPT_SIZE + sizeof(FRAME_SYN)), 0, LDL_MAX_IMAGE_SIZE);

/*
 *  Alignment Values.
 *  Currently, only Black to Color Vertical Alignment value is used.
 *  This value should really be obtained by running the pen alignment test.
 *  A value of 12 device units seems to be a good default.
 */
	BYTE cVertAlign = 0;
	if (pPrinterXBow->ePen == BOTH_PENS)
	{
		if (pSys->GetVerticalAlignmentValue(&cVertAlign))
		{
			m_cKtoCVertAlign = cVertAlign;
		}
		else
		{
			m_cKtoCVertAlign = 12;
		}
	}
	else if (pPrinterXBow->ePen == MDL_BOTH)
	{
		if (pSys->GetVerticalAlignmentValue(&cVertAlign))
		{
			m_cPtoCVertAlign = cVertAlign;
		}
		else
		{
			m_cPtoCVertAlign = 6;
		}
	}
	else
	{
		m_cKtoCVertAlign = 12;
		m_cPtoCVertAlign = 6;
	}
}

void LDLEncap::AllocateSwathBuffer (unsigned int RasterSize)
{
    int size = RasterSize;
    size = (size / 8 + 1) * 8;
    m_iImageWidth = size;

    constructor_error = NO_ERROR;
    m_ldlCompressData = NULL;

#ifdef  APDK_LDL_COMPRESS
    if (pPrinterXBow->m_iLdlVersion == 1)
    {
        m_ldlCompressData = new comp_ptrs_t;
    }
#endif

    if (m_iBitDepth == 2)
    {
        size *= 2;
    }

    int     iSwings = pPrinterXBow->m_iBytesPerSwing / 2;
    int     iCompressBufSize = iSwings * LDL_MAX_IMAGE_SIZE+20;    // additional space for load sweep command
    m_szCompressBuf = new BYTE[iCompressBufSize];
    CNEWCHECK (iCompressBufSize);
    memset (m_szCompressBuf, 0, iCompressBufSize);

    BYTE    *p = NULL;
    int     iSwathBuffSize;

    m_sSwathHeight = SWATH_HEIGHT;

	/*
	 *  This swath buffer cannot be greater than the number of nozzles - 400 for black
	 *  and 100 for color - we can use.
	 */

    int    iAdjHeight = (pPrinterXBow->m_iNumBlackNozzles / 32) * 8;
    if (pPrinterXBow->ePen == BLACK_PEN)
    {
        m_sSwathHeight = m_sSwathHeight * 4;
        if (m_sSwathHeight * 1200 / m_iYResolution > pPrinterXBow->m_iNumBlackNozzles)
            m_sSwathHeight = m_iYResolution / 3;
    }
    else if (m_cPrintQuality != QUALITY_DRAFT && m_iYResolution > 300 && m_iNumColors > 1 && m_iBitDepth == 1) // Collie change
    {
        m_sSwathHeight = (m_sSwathHeight / 4) * 4 * 2;
        if (m_sSwathHeight > 200)
            m_sSwathHeight = 200;
    }

    else if (m_iBitDepth == 2)
        m_sSwathHeight = iAdjHeight * 4;

    if (m_cPrintQuality == QUALITY_NORMAL)
        m_sSwathHeight = iAdjHeight * 2;

    if (m_cPrintQuality == QUALITY_DRAFT && pPrinterXBow->ePen != BLACK_PEN)
    {
        m_sSwathHeight *= iSwings;
    }

    while (m_sSwathHeight > 16)
    {
        iSwathBuffSize = m_iNumColors * sizeof (BYTE *) +
                         m_iNumColors * m_sSwathHeight * sizeof (BYTE *) +
                         size * m_iNumColors * m_sSwathHeight;
        if ((p = m_pSys->AllocMem(iSwathBuffSize)) == NULL)
        {
            m_sSwathHeight = (m_sSwathHeight / 16) * 8;
            continue;
        }
        break;
    }
    if (m_sSwathHeight < 16)
    {
        m_sSwathHeight = 16;
        iSwathBuffSize = m_iNumColors * sizeof (BYTE *) +
                         m_iNumColors * m_sSwathHeight * sizeof (BYTE *) +
                         size * m_iNumColors * m_sSwathHeight;
        p = m_pSys->AllocMem(iSwathBuffSize);
        CNEWCHECK (p);
    }

    int     i;
    m_SwathData = (BYTE ***) p;
    for (i = 0; i < m_iNumColors; i++)
        m_SwathData[i] = (BYTE **) (p + sizeof (BYTE *) * m_iNumColors + i * m_sSwathHeight * sizeof (BYTE *));

    for (i = 0; i < m_iNumColors; i++)
    {
        p = (BYTE *) m_SwathData + sizeof (BYTE *) * m_iNumColors +
                m_iNumColors * m_sSwathHeight * sizeof (BYTE *) +
                size * m_sSwathHeight * i;
        for (int j = 0; j < m_sSwathHeight; j++)
        {
            memset (p, 0, size);
            m_SwathData[i][j] = p;
            p = p + size;
        }
    }

    if (m_cPrintQuality != QUALITY_DRAFT && m_iYResolution != 300)
    {
        m_iRasterCount = (m_sSwathHeight - m_sSwathHeight / (4*m_iBitDepth)) * m_iNumColors;
        m_iVertPosn -= (((m_sSwathHeight - m_sSwathHeight / (4*m_iBitDepth)) * 600 / m_iYResolution) * DEVUNITS_XBOW / 600);
    }
    m_cPassNumber = 0;

    float   fXOverSpray = 0.0;
    float   fYOverSpray = 0.0;
    float   fLeftOverSpray = 0.0;
    float   fTopOverSpray  = 0.0;
	FullbleedType   fbType;
    if (m_pthisPC->bDoFullBleed &&
        pPrinterXBow->FullBleedCapable (m_pthisPC->thePaperSize,
									  &fbType,
                                      &fXOverSpray, &fYOverSpray,
                                      &fLeftOverSpray, &fTopOverSpray))
	{
		if (m_iVertPosn < -850) m_iVertPosn = -850;
	}
	else
	{
		if (m_iVertPosn < -600) m_iVertPosn = -600;
	}
    if (m_iBitDepth == 2)
        m_iVertPosn += 6;
}

unsigned int LDLEncap::GetSwathWidth (int iStart, int iLast, int iWidth)
{
    int k;
    int i, j;
    for (i = iWidth - 1 /*sizeof (long)*/; i > -1; i--)
    {
        for (j = iStart; j < iLast; j++)
        {
            for (k = m_iRasterCount / m_iNumColors-1; k >= 0; k--)
            {

                if (m_SwathData[j][k][i])
                {
                    return (i+1);
                }
            }
        }
    }

    return 0;
}

void LDLEncap::Flush ()
{
//  if (m_iRasterCount)
//      Process (NULL, 0);
}

DRIVER_ERROR LDLEncap::SetVerticalSkip (int nBlankRasters)
{
    DRIVER_ERROR    err = NO_ERROR;
#if 0
    if (m_iRasterCount == 0)
    {
        m_iBlankRasters += nBlankRasters;
        return err;
    }
#endif
    int     iCount = m_iNumColors * m_iBitDepth;
    if (m_iBitDepth == 2 && m_iNumColors != 6)
        iCount++;

    while (nBlankRasters > 0)
    {
        for (int i = 0; i < iCount; i++)
        {
            err = Encapsulate (NULL, m_iImageWidth, 0);
            ERRCHECK;
        }
        nBlankRasters--;
    }
    return err;
}

BOOL LDLEncap::IsBlankRaster (BYTE *raster, int width)
{
    while (width > 0)
    {
        if (*raster)
            return FALSE;
        width--;
    }
    return FALSE;
}

DRIVER_ERROR LDLEncap::Encapsulate (const BYTE *input, DWORD size, BOOL bLastPlane)
{
    DRIVER_ERROR    err = NO_ERROR;
    int iPlaneNum = 0;
    if (size > (DWORD) m_iImageWidth)
        size = m_iImageWidth;
    if (m_iBitDepth == 2)
    {
		if (m_iNumColors != 6)
		{
			if (m_cPlaneNumber == 0)
			{
				m_cPlaneNumber++;
				return NO_ERROR;
			}
		}
        int iCPlane;
		if (m_iNumColors == 6)
		{
			iPlaneNum = m_cPlaneNumber % 2;
		}
		else
		{
			iPlaneNum = (m_cPlaneNumber + 1) % 2;
		}
        int iRowNum = (m_iRasterCount / 6) * 2 + iPlaneNum;
        iRowNum = m_iNextRaster;
		if (m_iNumColors == 6)
		{
			iCPlane = m_cPlaneNumber / 2;
		}
		else
		{
			iCPlane = (m_cPlaneNumber - 1) / 2;
		}
        if (iPlaneNum == 0)
        {
            if (!input)
                memset (m_SwathData[iCPlane][iRowNum], 0, m_iImageWidth * 2);
            else
                memcpy (m_SwathData[iCPlane][iRowNum], input, size);
        }
		if (m_iNumColors == 6)
		{
			m_cPlaneNumber = (m_cPlaneNumber + 1) % 12;
		}
		else
		{
			m_cPlaneNumber = (m_cPlaneNumber + 1) % 8;
		}

        if (iPlaneNum == 1)
        {
            // do the dotmapping here
            BYTE    cbyte1, cbyte2;
            BYTE    c1, c2;
            int     j = 0;
            BYTE    r1b1 = 0;
            BYTE    r1b2 = 0;
            BYTE    r2b1 = 0;
            BYTE    r2b2 = 0;
            BYTE    bitmask[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};

            // Collie changes
            int     iNextBitPos = m_iImageWidth;
            int     iJIncrement = 1;
            if (pPrinterXBow->m_iLdlVersion == 2)
            {
                iNextBitPos = 1;
                iJIncrement = 2;
            }

            memcpy (m_szCompressBuf, m_SwathData[iCPlane][m_iNextRaster], size);

            static  BYTE    rand_table[4][4] = {{0, 3, 1, 2},
                                                {3, 1, 2, 0},
                                                {1, 2, 0, 3},
                                                {2, 0, 3, 1}};

            BYTE    rt1, rt2;
            rt1 = iRowNum % 4;

            for (unsigned int i = 0; i < size; i++)
            {
                cbyte2 = m_szCompressBuf[i];
                cbyte1 = (input == NULL) ? 0 : input[i];

//              1200 dpi raster split into 2 600 dpi rasters

                r1b1 = 0;
                r1b2 = 0;
                r2b1 = 0;
                r2b2 = 0;

                for (int ibit = 0; ibit < 8; ibit++)
                {
                    c1 = (cbyte1 & bitmask[ibit]) ? 1 : 0;
                    c2 = (cbyte2 & bitmask[ibit]) ? 1 : 0;
                    c1 = 2 * c1 + c2;

                    rt2 = (i + ibit) % 4;
                    rt2 = rand_table[rt1][rt2];

                    if (c1 == 2)
                    {
                        if (rt2 == 0)
                        {
                            r1b1 = r1b1 | (0xff & (cbyte1 & bitmask[ibit]));
                            r2b2 = r2b2 | (0xff & bitmask[ibit]);
                        }
                        else if (rt2 == 1)
                        {
                            r1b2 = r1b2 | (0xff & bitmask[ibit]);
                            r2b1 = r2b1 | (0xff & bitmask[ibit]);
                        }

                        else if (rt2 == 2)
                        {
                            r1b1 = r1b1 | (0xff & bitmask[ibit]);
                            r2b1 = r2b1 | (0xff & bitmask[ibit]);
                        }
                        else if (rt2 == 3)
                        {
                            r1b2 = r1b2 | (0xff & bitmask[ibit]);
                            r2b2 = r2b2 | (0xff & bitmask[ibit]);
                        }

                    }
                    else if (c1 == 1)
                    {
                        if (rt2 == 0)
                            r1b1 = r1b1 | (0xff & bitmask[ibit]);
                        else if (rt2 == 1)
                            r1b2 = r1b2 | (0xff & bitmask[ibit]);
                        else if (rt2 == 2)
                            r2b1 = r2b1 | (0xff & bitmask[ibit]);
                        else
                            r2b2 = r2b2 | (0xff & bitmask[ibit]);

                    }
                    else if (c1 == 3)
                    {
                        r1b1 = r1b1 | (0xff & bitmask[ibit]);
                        r1b2 = r1b2 | (0xff & bitmask[ibit]);
                        r2b1 = r2b1 | (0xff & bitmask[ibit]);
                        r2b2 = r2b2 | (0xff & bitmask[ibit]);
                    }
                }
                m_SwathData[iCPlane][m_iNextRaster][j] = r1b1;
                m_SwathData[iCPlane][m_iNextRaster][j+iNextBitPos] = r1b2;
                m_SwathData[iCPlane][m_iNextRaster+1][j]   = r2b1;
                m_SwathData[iCPlane][m_iNextRaster+1][j+iNextBitPos] = r2b2;

                j += iJIncrement;
            }

			if (m_iNumColors == 6)
			{
				m_cPlaneNumber = m_cPlaneNumber % 12;
			}
			else
			{
				m_cPlaneNumber = m_cPlaneNumber % 7;
			}
        }
    }
    else
    {
        if (!input || size == 0)
            memset (m_SwathData[m_iNextColor][m_iNextRaster], 0, m_iImageWidth);
        else
            memcpy (m_SwathData[m_iNextColor][m_iNextRaster], input, size);
    }
    m_iRasterCount++;
    if (m_iBitDepth == 1 || (m_iBitDepth == 2 && iPlaneNum == 1))
        m_iNextColor++;
    if (m_iNextColor == m_iNumColors)
    {
        m_iNextColor = 0;
        if (m_iBitDepth == 2)
            m_iNextRaster += 2;
        else
            m_iNextRaster++;
    }
    if (m_iRasterCount < m_sSwathHeight * m_iNumColors)
        return NO_ERROR;

    if (m_bStartPageNotSent)
    {
        err = StartPage ();
        if (err != NO_ERROR)
            return err;
    }

    err = ProcessSwath (size);

    if (m_iNextRaster >= m_sSwathHeight)
    {
        m_iNextRaster = 0;
    }
    return err;
}

DRIVER_ERROR LDLEncap::ProcessSwath (int iCurRasterSize)
{

    DRIVER_ERROR    err = NO_ERROR;
    unsigned int    start = 0;
    int             size = 0;
    Int32           iVertPosn;
    Int16           sCurSwathHeight = m_iRasterCount / m_iNumColors;
    Int32           LeftEdge  = 0;
    int i;
    m_iVertPosn += ((m_iBlankRasters) * 600 / m_iYResolution) * DEVUNITS_XBOW / 600;
    m_iBlankRasters = 0;

    iVertPosn = m_iVertPosn;

    BOOL    bColorPresent = TRUE;
    BOOL    bBlackPresent = TRUE;
	BOOL    bPhotoPresent = TRUE;
    short   sColorSize = 0;

    int     StartColor = 0;
    int     LastColor  = 1;
    Int32   RightEdge;
    int     delta = 2;
    int     iColors = 0;
    UInt32  uiSwathSize = 0;

    int     iSwings = pPrinterXBow->m_iBytesPerSwing;

    if (m_iNumColors == 1)
	{
        bColorPresent = 0;
        bPhotoPresent = 0;
/* 
		if (pPrinterXBow->ePen == BLACK_PEN)
			bPhotoPresent = 0;
		else
			bBlackPresent = 0;
 */
	}
    if (m_iNumColors == 3)
	{
        bBlackPresent = 0;
		bPhotoPresent = 0;
	}
    if (m_iNumColors == 6)
	{
        bBlackPresent = 0;
	}
    if (m_iNumColors == 4)
	{
        bPhotoPresent = 0;
	}

    if (!m_bBidirectionalPrintingOn)
        m_cPrintDirection = PRNDRN_LEFTTORIGHT;

    Int16   j;
    int     n;
    int     count;
    int     iStartRaster = m_cPassNumber % (2 * m_iBitDepth);
    BYTE    mask = 0xFF;

    if (pPrinterXBow->m_iLdlVersion == 2)
    {
        iStartRaster = 0;   // Version 2 - REVISIT
    }

    if (m_cPrintQuality != QUALITY_DRAFT && m_iYResolution != 300)
    {
        if ((m_cPassNumber % (4 * m_iBitDepth)) < (2 * m_iBitDepth))
            mask = 0xAA;
        else
            mask = 0x55;
    }

/*
 *  Photo Swath
 */

    BYTE    csavMask = mask;

	Int16       iOffset = 0;

    if (m_sRefCount > 64000)
        m_sRefCount = 6;

    if (bPhotoPresent)
    {
		if (bColorPresent)
		{
			iColors = 6;
			LastColor = 6;
			StartColor = 0;
            if (pPrinterXBow->m_iLdlVersion == 1)
            {
			    // 1200 dpi split into two
			    size = GetSwathWidth (StartColor, LastColor, iCurRasterSize/* * m_iBitDepth*/);
            }
            else
            {
                size = GetSwathWidth (StartColor, LastColor, iCurRasterSize * m_iBitDepth);
            }
		}
		else
		{
			iColors = 1;
			LastColor = 1;
			StartColor = 0;
			// 1200 dpi split into two
			size = GetSwathWidth (StartColor, LastColor, iCurRasterSize/* * m_iBitDepth*/);
		}
    }

    if (bPhotoPresent && size)
    {
        if (size % iSwings)
            size = ((size/iSwings) + 1) * iSwings;
        if (pPrinterXBow->m_iLdlVersion == 1)
        {
            RightEdge = LeftEdge + (size * 8 * 600 / m_iXResolution - 1 * (600 / m_iYResolution)) *
                                    (DEVUNITS_XBOW / 600);
        }
        else
        {
            RightEdge = LeftEdge + (size * 8 * 600 / m_iXResolution - 1 * (600 / m_iYResolution)) *
                                    (DEVUNITS_XBOW / (600 * m_iBitDepth));
        }
        Int16   sLastNozzle;
        Int16   sFirstNozzle = 1;
        unsigned int    uSweepSize;
        int     jDelta = m_iYResolution / pPrinterXBow->m_iColorPenResolution;
        jDelta *= m_iBitDepth;

        uiSwathSize = size * iColors * sCurSwathHeight / jDelta;

        uSweepSize = sCurSwathHeight * iSwings / jDelta;
        n = LDL_MAX_IMAGE_SIZE / (uSweepSize);
        count = 0;

        if (m_iBitDepth == 2)
            iStartRaster = (4 - (iStartRaster+1)) % 4;

        if (pPrinterXBow->m_iLdlVersion == 2)
        {
            iStartRaster = 0;   // Collie - REVISIT
        }

        sLastNozzle = sFirstNozzle - 1 + sCurSwathHeight / jDelta;

        BYTE *cb = m_szCompressBuf + 16;    // load sweep command
        memset (m_szCompressBuf, 0x0, LDL_MAX_IMAGE_SIZE * (iSwings / 2));

        
		// 1200 dpi split into two
        int    ib = 0;

        if (m_iYResolution > 300 && m_cPrintQuality != QUALITY_DRAFT)
        {
            iOffset = (sCurSwathHeight / (4 * m_iBitDepth));
            iOffset = iOffset + iOffset * ((m_cPassNumber) % (4 * m_iBitDepth));
        }

        BYTE    cVertAlign = 0;

        if (bColorPresent)
        {
            cVertAlign = m_cPtoCVertAlign;
        }

        for (ib = 0; ib < (int) m_iBitDepth; ib++)
        {
            if (m_cPrintDirection == PRNDRN_RIGHTTOLEFT)
            {
                start = size - iSwings;
                delta = -iSwings;
            }
            else
            {
                start = 0;
                delta = iSwings;
            }

            err = PrintSweep (uiSwathSize, bColorPresent, FALSE, bPhotoPresent,
                              iVertPosn+cVertAlign, LeftEdge, RightEdge, m_cPrintDirection,
                              sFirstNozzle, sLastNozzle);
            ERRCHECK;

            i = start + ib * m_iImageWidth;     // 1200 dpi split into two
            for (int l = 0; l < size; l += iSwings)   // Collie
            {
				for (int k = StartColor+1; k < LastColor; k++)
				{
					mask = csavMask;
					for (j = iOffset + iStartRaster; j < sCurSwathHeight; j += jDelta)
					{
                        for (int is = 0; is < iSwings; is++)
                        {
						    *cb++ = m_SwathData[k][j][i+is]   & mask;
                        }
						mask = ~mask;
					}
					for (j = iStartRaster; j < iOffset; j += jDelta)
					{
                        for (int is = 0; is < iSwings; is++)
                        {
						    *cb++ = m_SwathData[k][j][i+is]   & mask;
                        }
						mask = ~mask;
					}

					count++;
					if (count == n)
					{
						err = LoadSweepData (m_szCompressBuf, (unsigned int) (cb - m_szCompressBuf-16));
						memset (m_szCompressBuf, 0, LDL_MAX_IMAGE_SIZE * (iSwings / 2));
						cb = m_szCompressBuf+16;
						count = 0;
						ERRCHECK;
					}
				}
				mask = csavMask;
				for (j = iOffset + iStartRaster; j < sCurSwathHeight; j += jDelta)
				{
                    for (int is = 0; is < iSwings; is++)
                    {
					    *cb++ = m_SwathData[0][j][i + is]   & mask;
                    }
					mask = ~mask;
				}
				for (j = iStartRaster; j < iOffset; j += jDelta)
				{
                    for (int is = 0; is < iSwings; is++)
                    {
					    *cb++ = m_SwathData[0][j][i + is]   & mask;
                    }
					mask = ~mask;
				}

				count++;
				if (count == n)
				{
					err = LoadSweepData (m_szCompressBuf, (unsigned int) (cb - m_szCompressBuf-16));
				    memset (m_szCompressBuf, 0, LDL_MAX_IMAGE_SIZE * (iSwings / 2));
					cb = m_szCompressBuf+16;
					count = 0;
					ERRCHECK;
				}
                i = i + delta;
            }
            if (count != 0)
            {
                err = LoadSweepData (m_szCompressBuf, (unsigned int) (cb - m_szCompressBuf-16));
                memset (m_szCompressBuf, 0, LDL_MAX_IMAGE_SIZE * (iSwings / 2));
                cb = m_szCompressBuf+16;
                count = 0;
                ERRCHECK;
            }

            if (m_bBidirectionalPrintingOn)
                m_cPrintDirection = (m_cPrintDirection + 1) % 2;

            if (pPrinterXBow->m_iLdlVersion == 2) // Collie
            {
                break;
            }
            LeftEdge += 2;
            RightEdge += 2;

        }   // 1200 dpi split into two - end of for ib = 0 loop

    }

/*
 *  Color Swath
 */
    if (!bPhotoPresent && bColorPresent)
    {
        iColors = 3;
        LastColor = 4;
        StartColor = 1;
        if (!bBlackPresent)
        {
            StartColor = 0;
            LastColor  = 3;
        }
        if (pPrinterXBow->m_iLdlVersion == 1)
        {
            // 1200 dpi split into two
            size = GetSwathWidth (StartColor, LastColor, iCurRasterSize/* * m_iBitDepth*/);
        }
        else
        {
            size = GetSwathWidth (StartColor, LastColor, iCurRasterSize * m_iBitDepth);
        }
        sColorSize = size;
    }
/*
 *  Check if RefCount is close to overflow of 65k.
 */

    if (!bPhotoPresent && bColorPresent && size)
    {
        if (size % iSwings)
            size = ((size / iSwings) + 1) * iSwings;

        if (pPrinterXBow->m_iLdlVersion == 1)
        {
            RightEdge = LeftEdge + (size * 8 * 600 / m_iXResolution - 1 * (600 / m_iYResolution)) *
                                    (DEVUNITS_XBOW / 600);
        }
        else
        {
            RightEdge = LeftEdge + (size * 8 * 600 / m_iXResolution - 1 * (600 / m_iYResolution)) *
                                    (DEVUNITS_XBOW / (600 * m_iBitDepth));
        }
        Int16   sLastNozzle;
        Int16   sFirstNozzle = 1;
        unsigned int    uSweepSize;
        int     jDelta = m_iYResolution / pPrinterXBow->m_iColorPenResolution;
        jDelta *= m_iBitDepth;

        uiSwathSize = size * iColors * sCurSwathHeight / jDelta;

        uSweepSize = sCurSwathHeight * iSwings / jDelta;
        n = LDL_MAX_IMAGE_SIZE / (uSweepSize);
        count = 0;

        if (m_iBitDepth == 2)
        {
            iStartRaster = (4 - (iStartRaster+1)) % 4;
            if (pPrinterXBow->m_iLdlVersion == 2)
            {
                iStartRaster = m_cPassNumber % (m_iBitDepth);
            }
        }

        sLastNozzle = sFirstNozzle - 1 + sCurSwathHeight / jDelta;

        BYTE *cb = m_szCompressBuf + 16;    // load sweep command
        memset (m_szCompressBuf, 0x0, LDL_MAX_IMAGE_SIZE * (iSwings / 2));


		// 1200 dpi split into two
        int    ib = 0;

        if (m_iYResolution > 300 && m_cPrintQuality != QUALITY_DRAFT)
        {
            iOffset = (sCurSwathHeight / (4 * m_iBitDepth));
            iOffset = iOffset + iOffset * ((m_cPassNumber) % (4 * m_iBitDepth));
        }

        for (ib = 0; ib < (int) m_iBitDepth; ib++)
        {
            if (m_cPrintDirection == PRNDRN_RIGHTTOLEFT)
            {
                start = size - iSwings;
                delta = -iSwings;
            }
            else
            {
                start = 0;
                delta = iSwings;
            }
            err = PrintSweep (uiSwathSize, bColorPresent, FALSE, FALSE,
                              iVertPosn, LeftEdge, RightEdge, m_cPrintDirection,
                              sFirstNozzle, sLastNozzle);
            ERRCHECK;

            i = start + ib * m_iImageWidth;     // 1200 dpi split into two
            for (int l = 0; l < size; l += iSwings)   // Collie
            {
                for (int k = StartColor; k < LastColor; k++)
                {
                    mask = csavMask;
                    for (j = iOffset + iStartRaster; j < sCurSwathHeight; j += jDelta)
                    {
                        for (int is = 0; is < iSwings; is++)
                        {
                            *cb++ = m_SwathData[k][j][i + is]   & mask;
                        }
                        mask = ~mask;
                    }
                    for (j = iStartRaster; j < iOffset; j += jDelta)
                    {
                        for (int is = 0; is < iSwings; is++)
                        {
                            *cb++ = m_SwathData[k][j][i + is]   & mask;
                        }
                        mask = ~mask;
                    }

                    count++;
                    if (count == n)
                    {
                        err = LoadSweepData (m_szCompressBuf, (unsigned int) (cb - m_szCompressBuf-16));
                        memset (m_szCompressBuf, 0, LDL_MAX_IMAGE_SIZE * (iSwings / 2));

                        cb = m_szCompressBuf+16;
                        count = 0;
                        ERRCHECK;
                    }

                }
                i = i + delta;

            }
            if (count != 0)
            {
                err = LoadSweepData (m_szCompressBuf, (unsigned int) (cb - m_szCompressBuf-16));
                memset (m_szCompressBuf, 0, LDL_MAX_IMAGE_SIZE * (iSwings / 2));

                cb = m_szCompressBuf+16;
                count = 0;
                ERRCHECK;
            }

            LeftEdge += 2;
            RightEdge += 2;

            if (m_bBidirectionalPrintingOn)
                m_cPrintDirection = (m_cPrintDirection + 1) % 2;
            if (pPrinterXBow->m_iLdlVersion == 2) // Collie
            {
                break;
            }

        }   // 1200 dpi split into two - end of for ib = 0 loop
    }

/*
 *  Black Swath
 */

    size = 0;
    if (bBlackPresent)
        size = GetSwathWidth (0, 1, iCurRasterSize);

    if (size % iSwings)
	    size = ((size/iSwings) + 1) * iSwings;

    RightEdge = LeftEdge + (size * 8 * 600 / m_iXResolution - 1 * (600 / m_iYResolution)) * DEVUNITS_XBOW/600;
	
    if (bBlackPresent && size && m_iBitDepth != 2 &&
        ((m_cPassNumber % 2) == 0 || m_cPrintQuality == QUALITY_DRAFT))
    {
        Int16   sLastNozzle = 0;
        Int16   sFirstNozzle = 1;

        int     xDelta = 0;
        BYTE    cVertAlign = 0;

        if (bColorPresent)
        {
            cVertAlign = m_cKtoCVertAlign;
        }

        if (bColorPresent && sColorSize && m_bBidirectionalPrintingOn)
            m_cPrintDirection = PRNDRN_RIGHTTOLEFT;
        if (m_cPrintDirection == PRNDRN_RIGHTTOLEFT)
        {
            start = size - iSwings;
            delta = -iSwings;
        }
        else
        {
            start = 0;
            delta = iSwings;
        }
        if (m_iYResolution == 300)
            xDelta = iSwings;
        uiSwathSize = ((size/iSwings) * sCurSwathHeight * iSwings * (600 * m_iBitDepth)/ m_iYResolution);

        if (pPrinterXBow->m_iLdlVersion == 2 && m_iNumColors != 1)
        {
            sFirstNozzle = 9;
        }

		err = PrintSweep (uiSwathSize, FALSE, bBlackPresent, FALSE,
						  (iVertPosn + cVertAlign), LeftEdge, RightEdge, m_cPrintDirection, sFirstNozzle, sLastNozzle);

        ERRCHECK;

        i = start;
        BYTE *cb = m_szCompressBuf+16;
        memset (m_szCompressBuf, 0x0, LDL_MAX_IMAGE_SIZE * (iSwings / 2));

        n = LDL_MAX_IMAGE_SIZE / (sCurSwathHeight * iSwings * 600 / m_iYResolution);
        count = 0;

        iOffset = 0;
        if (m_iYResolution > 300 && m_cPrintQuality != QUALITY_DRAFT)
        {
            iOffset = sCurSwathHeight / 4;
            iOffset = iOffset + iOffset * (m_cPassNumber % 4);
        }

        for (int l = 0; l < size; l += iSwings) // Collie
        {
            for (j = iOffset; j < sCurSwathHeight; j++)
            {
                for (int is = 0; is < iSwings; is++)
                {
                    *cb++ = m_SwathData[0][j][i + is]   & mask;
                }
                cb += xDelta;
            }
            for (j = 0; j < iOffset; j++)
            {
                for (int is = 0; is < iSwings; is++)
                {
                    *cb++ = m_SwathData[0][j][i + is]   & mask;
                }
                cb += xDelta;
            }

            count++;
            if (count == n)
            {
                err = LoadSweepData (m_szCompressBuf, (unsigned int) (cb - m_szCompressBuf-16));
                memset (m_szCompressBuf, 0, LDL_MAX_IMAGE_SIZE * (iSwings / 2));

                cb = m_szCompressBuf+16;
                count = 0;
                ERRCHECK;
            }
            i = i + delta;
        }
        if (count != 0)
        {
            err = LoadSweepData (m_szCompressBuf, (unsigned int) (cb - m_szCompressBuf-16));
            memset (m_szCompressBuf, 0, LDL_MAX_IMAGE_SIZE * (iSwings / 2));

            cb = m_szCompressBuf+16;
            count = 0;
            ERRCHECK;
        }

		if (m_bBidirectionalPrintingOn)
			m_cPrintDirection = (m_cPrintDirection + 1) % 2;
    }

    m_iRasterCount = 0;

    if (m_cPrintQuality != QUALITY_DRAFT && m_iYResolution != 300)
    {
        m_cPassNumber = (m_cPassNumber + 1) % (4 * m_iBitDepth);
        m_iVertPosn += ((((sCurSwathHeight/(4 * m_iBitDepth))) * 600 / m_iYResolution) * DEVUNITS_XBOW / 600) / m_iBitDepth;
		if (m_iBitDepth == 1)
        {
            if (m_cPassNumber % 2)
                m_iVertPosn += 4;
            else
                m_iVertPosn -= 4;
        }
        else
        {
            m_iVertPosn -= 2;
            if ((m_cPassNumber % 4) == 0)
                  m_iVertPosn += (DEVUNITS_XBOW / pPrinterXBow->m_iColorPenResolution);
        }
        m_iRasterCount = (sCurSwathHeight - sCurSwathHeight / (4 * m_iBitDepth)) * m_iNumColors;
    }
    else
    {
        m_iVertPosn += ((sCurSwathHeight * 4 * 600) / m_iYResolution);

    }

    return err;
}

void    LDLEncap::FillLidilHeader (void *pLidilHdr, int Command,
                                   UInt16 CmdLen, UInt16 DataLen = 0)
{

    int index = 1;
    m_szCmdBuf[0] = FRAME_SYN;
    WRITE16 (CmdLen);
    m_szCmdBuf[5] = (BYTE) Command;
    index = 6;
    WRITE16(m_sRefCount++);
    index = 8;
    WRITE16 (DataLen);

}

DRIVER_ERROR LDLEncap::PrintSweep (UInt32 SweepSize,
                           BOOL ColorPresent,
                           BOOL BlackPresent,
						   BOOL PhotoPresent,
                           Int32 VerticalPosition,
                           Int32 LeftEdge,
                           Int32 RightEdge,
                           char PrintDirection,
                           Int16 sFirstNozzle,
                           Int16 sLastNozzle)
{
    // determine how many colors will be generated
    UInt16 colorcount = 0;
    UInt32  uiAffectedColors = 0;
    if (ColorPresent == TRUE) colorcount += 3;
    if (BlackPresent == TRUE) colorcount++;
	if (PhotoPresent == TRUE) 
	{
		if (ColorPresent == FALSE)
			colorcount++;
		else
			colorcount+=3;
	}

    UInt16  mem_needed;
    if (pPrinterXBow->m_iLdlVersion == 1)
    {
        mem_needed =   SIZEOF_LDLHDR
                         + SIZEOF_LDL_PRTSWP_CMDOPT
                         + SIZEOF_LDL_PRTSWP_OPTFLDS
                         + SIZEOF_LDL_PRTSWP_COLROPT * colorcount
                         + SIZEOF_LDLTERM;
    
        if (colorcount != 0)
            mem_needed += SIZEOF_LDL_COLROPT_ACTIVECOLR;
    }
    else
    {
        mem_needed =   SIZEOF_LDLHDR
                         + SIZEOF_LDL_PRTSWP_CMDOPT + 7
                         + SIZEOF_LDL_PRTSWP_OPTFLDS
                         + SIZEOF_LDL_PRTSWP_COLROPT + 4
                         + SIZEOF_LDLTERM;
    }

    memset (m_szCmdBuf, 0, mem_needed);

    FillLidilHeader (NULL, eLDLPrintSweep, mem_needed);

    int     index = SIZEOF_LDLHDR;
    if (pPrinterXBow->m_iLdlVersion == 2)
    {
        m_szCmdBuf[index++] = 1;    // Version number
    }
    WRITE32 (SweepSize);
    WRITE32 (VerticalPosition);
    WRITE32 (m_iLeftMargin);
    if (pPrinterXBow->m_iLdlVersion == 1)
    {
        // LIDIL First Version
        m_szCmdBuf[index++] = SWINGFMT_UNCOMPRSS;
    }
    else
    {
        // LIDIL Second Version
        m_szCmdBuf[index++] = 1;
    }
    m_szCmdBuf[index++] = PrintDirection;
    if (pPrinterXBow->m_iLdlVersion == 2)
    {
        WRITE32 (0); // Shingle mask
    }
    WRITE32 (IPS_CARRSPEED|IPS_INIPRNSPEED|ACCURATEPOSN_NEEDED);
 // Carriage Speed - 25 for plain, 12 for photo
    if (m_cPrintQuality == QUALITY_BEST && m_cMediaType == MEDIA_PHOTO)
        m_szCmdBuf[index++] = 12;
    else
        m_szCmdBuf[index++] = 25;
    m_szCmdBuf[index++] = 4; // Initial Print Speed
    m_szCmdBuf[index++] = 1; // Need Accurate Position
    if (pPrinterXBow->m_iLdlVersion == 2)
    {
        m_szCmdBuf[index++] = 1; // Number of entries in the sweep
    }

    // fill in the color information
    if(colorcount == 0)
    {
        m_szCmdBuf[index++] = NO_ACTIVE_COLORS;
        m_szCmdBuf[index++] = FRAME_SYN;
        mem_needed = index;
    }
    else
    {
        // figure out what are the active colors and fill in the optional color fields.

        UInt16 colrpresent = 0;
        UInt16 colr_found=0;
        UInt16 colormask = 0x01;
        UInt16 offset = eLDLBlack;
        UInt16 iDataRes;
        UInt16 iPrintRes;
        uiAffectedColors = offset;
        if (BlackPresent == TRUE)
        {
            uiAffectedColors = 0x1;
        }
        if(BlackPresent == FALSE && PhotoPresent == FALSE)
        {
            offset = eLDLCyan;
            colormask=0x02;
            uiAffectedColors |= 0x0000000e;
        }
        else if (BlackPresent == FALSE && PhotoPresent == TRUE)
        {
			if (ColorPresent == TRUE)
			{
				offset = eLDLCyan;
				colormask=0x02;
                uiAffectedColors |= 0x0000007e;
			}
			else
			{
				offset = eLDLLoBlack;
				colormask=0x40;
                uiAffectedColors |= 0x00000070;
			}
        }

        int actv_colr_index = index;
        int iColorRes = 300;
        if (pPrinterXBow->m_iLdlVersion == 1)
        {
            index += 2;
        }
        else
        {
            iColorRes = 600;
        }
        for(UInt16 i = offset; colr_found < colorcount && i < eLDLMaxColor; i++)
        {
            colr_found++;
            colrpresent = colrpresent | colormask;

            if (pPrinterXBow->m_iLdlVersion == 2)
            {
                WRITE32 (uiAffectedColors);
            }
            WRITE32 (LeftEdge);
            WRITE32 (RightEdge);
            WRITE32 (LeftEdge);
            WRITE32 (RightEdge);

            if ((i == 0 && pPrinterXBow->m_iLdlVersion == 1) || (BlackPresent && pPrinterXBow->m_iLdlVersion == 2))
            {
                iDataRes = 600;
                iPrintRes = pPrinterXBow->m_iBlackPenResolution;
            }
            else
            {
                iDataRes  = iColorRes; // 300;
                iPrintRes = iColorRes; // 300;
            }
            WRITE16 (iDataRes);         // Vertical Data Resolution
            WRITE16 (iPrintRes);        // Vertical Print Resolution

            if (pPrinterXBow->m_iLdlVersion == 2)
            {
                WRITE16 (m_iXResolution * m_iBitDepth);   // Horizontal Data Resolution // Collie
            }
            else
            {
                WRITE16 (m_iXResolution);
            }

			if (m_iXResolution == 300)
			{
				WRITE16 (600);   // Force 2 drop for draft mode.
			}
            else
			{
                if (pPrinterXBow->m_iLdlVersion == 2)
                {
				    WRITE16 (m_iXResolution * m_iBitDepth);   // Horizontal Print Resolution // Collie
                }
                else
                {
                    WRITE16 (m_iXResolution);
                }
			}
            WRITE16 (sFirstNozzle);
            if (sLastNozzle == 0)
            {
                int     iTmp = m_iRasterCount / m_iNumColors;
                if (pPrinterXBow->m_iLdlVersion == 2)
                {
                    WRITE16 (sFirstNozzle - 1 + ((iTmp * iPrintRes) / (m_iYResolution * m_iBitDepth))); // Collie
                }
                else
                {
                    WRITE16 (sFirstNozzle - 1 + ((iTmp * iPrintRes) / (m_iYResolution)))
                }
            }
            else
            {
                WRITE16 (sLastNozzle);
            }

            m_szCmdBuf[index++] = 0;    // Vertical Alignment
            colormask = colormask << 1;
            if (pPrinterXBow->m_iLdlVersion == 2)
            {
                break;
            }

        }
        // write the active color field
        mem_needed = index;
        if (pPrinterXBow->m_iLdlVersion == 1)
        {
            index = actv_colr_index;
            WRITE16 (colrpresent);
            index = mem_needed;
        }

        if (pPrinterXBow->m_iLdlVersion == 2)
        {
            m_szCmdBuf[index++] = 0; // # of entries in the shingle array
        }
        m_szCmdBuf[index++] = FRAME_SYN;
        mem_needed = index;
    }

    // write out the data
    return (pPrinterXBow->Send (m_szCmdBuf, (DWORD) mem_needed));
}


DRIVER_ERROR LDLEncap::LoadSweepData (BYTE *imagedata, int imagesize)
{
    UInt16 mem_needed = SIZEOF_LDLHDR + SIZEOF_LDL_LDSWPDATA_CMDOPT
                                      + SIZEOF_LDLTERM;
    UInt16 diff=0;
    if(mem_needed < LDLPACKET_MINSIZE)
    {
        diff = LDLPACKET_MINSIZE - mem_needed;
        mem_needed = LDLPACKET_MINSIZE;
    }
    memset (m_szCmdBuf, 0, mem_needed);

    BYTE    *compressed_dataptr = imagedata;
    UInt16  compressed_size = imagesize;

#ifdef  APDK_LDL_COMPRESS
    if (m_ldlCompressData)
    {
  	    m_ldlCompressData->Init ((UInt16 *) (imagedata+16), imagesize);
	    CompressData ();
	    GetFrameInfo (&compressed_dataptr, &compressed_size);
    }
#endif

    FillLidilHeader (NULL, eLDLLoadSweepData, mem_needed, compressed_size);

    int     index = SIZEOF_LDLHDR;
    WRITE16 (imagesize);

    if(diff)
    {
        memset (m_szCmdBuf+index, 0xFF, diff);
        index += diff;
    }
    m_szCmdBuf[index++] = FRAME_SYN;

    memcpy (compressed_dataptr, m_szCmdBuf, 16);
    return (pPrinterXBow->Send (compressed_dataptr, (DWORD) compressed_size+16));
}

LDLEncap::~LDLEncap ()
{
    if (m_SwathData)
	// Camera change - allocation is now AllocMem instead of new
	//        delete [] (BYTE *) m_SwathData;
        m_pSys->FreeMem ((BYTE *) m_SwathData);
    if (m_szCmdBuf)
        delete [] m_szCmdBuf;
    if (m_szCompressBuf)
        delete [] m_szCompressBuf;
    if (piCreditCount)
        m_pSys->FreeMem ((BYTE *) piCreditCount);
    if (m_pbyPacketBuff)
        m_pSys->FreeMem ((BYTE *) m_pbyPacketBuff);
    if (pbySync)
        m_pSys->FreeMem ((BYTE *) pbySync);
#ifdef  APDK_LDL_COMPRESS
    if (m_ldlCompressData)
    {
        delete m_ldlCompressData;
        m_ldlCompressData = NULL;
    }
#endif
}

DRIVER_ERROR LDLEncap::StartJob ()
{
    DRIVER_ERROR err = NO_ERROR;
    BYTE *pby = NULL;
    BYTE by = 0;
    BOOL bCreditInitialized = FALSE;
    WORD wCreditWaitCount = 0;

    // Send Sync packet
    err = pPrinterXBow->Send (pbySync, (DWORD) SYNCSIZE);
    if(err)
    {
        return err;
    }

    // Send Sync Complete packet
    err = pPrinterXBow->Send (bySyncComplete, (DWORD) sizeof (bySyncComplete));
    if(err)
    {
        return err;
    }

    // Send Reset LIDIL packet
    err = pPrinterXBow->Send (byResetLIDIL, (DWORD) sizeof (byResetLIDIL));
    if(err)
    {
        return err;
    }

    if (pPrinterXBow->IOMode.bDevID)
    {
        // Enable pacing, get credit packet and update credit count
        err = pPrinterXBow->Send (byEnablePacing, (DWORD) sizeof (byEnablePacing));
        if (err)
        {
            return err;
        }

        while (!bCreditInitialized && wCreditWaitCount++ < CREDIT_WAIT)
        {
            bCreditInitialized = UpdateState (TRUE);
        }

        if (!bCreditInitialized)
        {
            return SYSTEM_ERROR;
        }
        else
        {
            // Send Enable On Change status packet.  We don't have to worry about flushing the buffer,
            // because the ::Send logic will do that for us.  If we run out of credit for a command, the
            // first thing that we do is flush the buffer.  If we haven't already sent the EOCQuery, it
            // will get sent then.
            err = pPrinterXBow->Send (byEOCStatusQuery, (DWORD) sizeof (byEOCStatusQuery));
            if (err)
            {
                return err;
            }
        }

        // Setup Cancel command.  It would be nice to do this in the LDLEncap constructor, but we have
        // to know the JobID before we can setup the cancel command.
        memcpy (pbyCancel, byPrepareToCancel, sizeof (byPrepareToCancel));
        pbyCancel[COMMAND_NUMBER_BYTE] = 0x00;
        pbyCancel[COMMAND_OPT_BYTE] = 0x02;

        pby = (BYTE*) &pPrinterXBow->pLDLEncap;
        if(m_bLittleEndian)
        {
            // Go to last byte of pLDLEncap in memory, since system is little endian
            pby += sizeof (pPrinterXBow->pLDLEncap) - 1;
        }

        for(by = 0; by < sizeof(pPrinterXBow->pLDLEncap); by++)
        {
            if(m_bLittleEndian)
                pbyCancel[by + COMMAND_OPT_BYTE + 1] = *pby--;
            else
                pbyCancel[by + COMMAND_OPT_BYTE + 1] = *pby++;
        }

        // Setup Query command
//        memcpy(byQuery, byEnableResponses, sizeof(byEnableResponses));
//        memcpy(byQuery + sizeof(byEnableResponses), byStatusQuery, sizeof(byStatusQuery));
//        memcpy(byQuery + (sizeof(byEnableResponses) + sizeof(byStatusQuery)),
//               byDisableResponses, sizeof(byDisableResponses));
    }

    UInt16 mem_needed = SIZEOF_LDLHDR + SIZEOF_LDL_JOB_CMDOPT + SIZEOF_LDLTERM;
    if (pPrinterXBow->m_iLdlVersion == 2)
    {
        mem_needed += 4;
    }

    FillLidilHeader (NULL, eLDLStartJob, mem_needed);

    // write in the job id
    int     index = SIZEOF_LDLHDR;
    m_szCmdBuf[index++] = OPERATION_STJOB;
    if (pPrinterXBow->IOMode.bDevID)
    {
        WRITE32 ((UInt32) this);
    }
    else
    {
        WRITE32 ((UInt32) 0xbadfad);    // for deterministic testing, des
    }

    if (pPrinterXBow->m_iLdlVersion == 2)
    {
        WRITE32 (0);    // Shingle Mask option
    }

    // add in sync frame.
    m_szCmdBuf[index++] = FRAME_SYN;

    // fill in the job header and write out the generated data
    err = pPrinterXBow->Send (m_szCmdBuf, (DWORD) mem_needed);
    ERRCHECK;

    err = StartPage ();
    ERRCHECK;

#if 0
	/*
	 *  Query printer if pens are aligned when both pens are present.
	 *  If so, set Bi-Directional printing on.
	 *  If m_bBierectionalPrintingOn is already set or current mode is
	 *  PhotoBest, don't query for pen alignment.
	 */
    if (m_bBidirectionalPrintingOn || m_cPrintQuality == QUALITY_NORMAL)
        return NO_ERROR;

    mem_needed = SIZEOF_LDLHDR + 2 + SIZEOF_LDLTERM;
    memset (m_szCmdBuf, 0, LDLPACKET_MINSIZE);
    for (index = mem_needed; index < LDLPACKET_MINSIZE; index++)
        m_szCmdBuf[index] = 0xFF;
    if (mem_needed < LDLPACKET_MINSIZE)
        mem_needed = LDLPACKET_MINSIZE;
    FillLidilHeader (NULL, eLDLQueryPrinter, mem_needed);
    index = SIZEOF_LDLHDR;
    m_szCmdBuf[index++] = 3;    // Pen Alignment   - is this the right command?
    m_szCmdBuf[index++] = 0;    // Query - Immediate response
    m_szCmdBuf[mem_needed-1] = FRAME_SYN;
    pPrinterXBow->Send (m_szCmdBuf, (DWORD) mem_needed);

    index = 0;
    if ((pSS->FromDevice ((char *) m_szCmdBuf, (WORD *) &index)) == NO_ERROR)
    {
//      what am I looking for here?
        index = SIZEOF_LDLHDR + 1;
//      2 bytes for color alignment, however, bits 7-15 are not used at present
        BYTE    bColor = m_szCmdBuf[index] & 0x7F;
        if ((bColor & 0x0F) == 0x0F ||      // bits 0 - 3 represent KCMY
            (bColor & 0x7E) == 0x7E)        // bits 4 - 6 represent cmk
            m_bBidirectionalPrintingOn = TRUE;
    }
#endif

    return err;
}


DRIVER_ERROR    LDLEncap::EndJob ()
{
    DRIVER_ERROR err = NO_ERROR;

    UInt16 mem_needed = SIZEOF_LDLHDR + SIZEOF_LDL_JOB_CMDOPT + SIZEOF_LDLTERM;

    FillLidilHeader (NULL, eLDLEndJob, mem_needed);

    int     index = SIZEOF_LDLHDR;
    m_szCmdBuf[index++] = OPERATION_ENDJOB;
    if (pPrinterXBow->IOMode.bDevID)
    {
        WRITE32 ((UInt32) this);
    }
    else
    {
        WRITE32 ((UInt32) 0xbadfad);    // for deterministic testing, des
    }

    m_szCmdBuf[index++] = FRAME_SYN;

    err = pPrinterXBow->Send (m_szCmdBuf, (DWORD) mem_needed);
    if(err)
    {
        return err;
    }

    // Send Sync packet
    err = pPrinterXBow->Send (pbySync, SYNCSIZE);
    if(err)
    {
        return err;
    }

    // Send Sync Complete packet
    err = pPrinterXBow->Send (bySyncComplete, (DWORD) sizeof (bySyncComplete));
    if(err)
    {
        return err;
    }

    // Send Reset LIDIL packet
    err = pPrinterXBow->Send (byResetLIDIL, (DWORD) sizeof (byResetLIDIL));
    if(err)
    {
        return err;
    }

    return NO_ERROR;
}

DRIVER_ERROR LDLEncap::StartPage ()
{

    //figure out how much memory we needed
    UInt16 colorcount = 0; //m_iNumColors;
    UInt32 mem_needed = SIZEOF_LDLHDR  + SIZEOF_LDL_LDPAGE_CMDOPT
                                       + SIZEOF_LDL_LDPAGE_OPTFLDS
                                       + SIZEOF_LDLTERM;

    memset (m_szCmdBuf, 0, mem_needed);

    FillLidilHeader (NULL, eLDLLoadPage, (UInt16) mem_needed);

    char    mediatype = MEDIATYPE_PLAIN;
    BYTE    quality   = (BYTE) QUALITYLEVEL_NORMAL;
    if (m_cPrintQuality == QUALITY_BEST && m_cMediaType == MEDIA_PHOTO)
    {
        mediatype = MEDIATYPE_PHOTO;
        quality   = (BYTE) QUALITYLEVEL_BEST;
    }
    else if (m_cPrintQuality == QUALITY_DRAFT)
        quality = (BYTE) QUALITYLEVEL_DRAFT;

    int     index = SIZEOF_LDLHDR;
    m_szCmdBuf[index++] = mediatype;
    m_szCmdBuf[index++] = MEDIASRC_MAINTRAY;
    m_szCmdBuf[index++] = MEDIADEST_MAINBIN;
    m_szCmdBuf[index++] = quality; //PrintQuality;
    m_szCmdBuf[index++] = SPECLOAD_NONE;

    Int32   iVal;
    iVal = (Int32) (m_pthisPC->PhysicalPageSizeX () * 1000);
    WRITE32 ((iVal * DEVUNITS_XBOW) / 1000);
    iVal = (Int32) (m_pthisPC->PhysicalPageSizeY () * 1000);
    WRITE32 ((iVal * DEVUNITS_XBOW) / 1000);

    WRITE32 (MEDIALD_SPEED|NEED_TO_SERVICE_PERIOD|MINTIME_BTW_SWEEP);

    // set up the option fields
    m_szCmdBuf[index++] = 4; // MediaLoadSpeed;
    m_szCmdBuf[index++] = 0; // NeedToServicePeriod;
    WRITE16 (200);           // MinTimeBetweenSweeps

    if (colorcount == 0)
    {
        m_szCmdBuf[index++] = FRAME_SYN;
    }

    m_bStartPageNotSent = FALSE;
    // write out the data
    return (pPrinterXBow->Send (m_szCmdBuf, (DWORD) mem_needed));
}

DRIVER_ERROR LDLEncap::Continue ()
{

    UInt16 mem_needed = SIZEOF_LDLHDR + 1
                        + SIZEOF_LDLTERM;
    int     index;
    memset (m_szCmdBuf, 0, LDLPACKET_MINSIZE);
    for (index = mem_needed; index < LDLPACKET_MINSIZE; index++)
        m_szCmdBuf[index] = 0xFF;
    if (mem_needed < LDLPACKET_MINSIZE)
        mem_needed = LDLPACKET_MINSIZE;
    FillLidilHeader (NULL, eLDLControl, mem_needed);
    index = SIZEOF_LDLHDR;
    m_szCmdBuf[index] = OPERATION_CONTINUE;
    m_szCmdBuf[mem_needed-1] = FRAME_SYN;
    return (pPrinterXBow->Send (m_szCmdBuf, (DWORD) mem_needed));
}

void LDLEncap::Cancel ()
{

    UInt16 mem_needed = SIZEOF_LDLHDR + SIZEOF_LDL_JOB_CMDOPT
                        + SIZEOF_LDLTERM;
    int     index;
    memset (m_szCmdBuf, 0, LDLPACKET_MINSIZE);
    for (index = mem_needed; index < LDLPACKET_MINSIZE; index++)
        m_szCmdBuf[index] = 0xFF;
    if (mem_needed < LDLPACKET_MINSIZE)
        mem_needed = LDLPACKET_MINSIZE;
    FillLidilHeader (NULL, eLDLControl, mem_needed);
    index = SIZEOF_LDLHDR;
    WRITE32 ((UInt32) this);
    m_szCmdBuf[index] = OPERATION_CANCJOB;
    m_szCmdBuf[mem_needed-1] = FRAME_SYN;
    pPrinterXBow->Send (m_szCmdBuf, (DWORD) mem_needed);
}

DRIVER_ERROR LDLEncap::CleanPen ()
{

    UInt16 mem_needed = SIZEOF_LDLHDR + 1 + 2
                        + SIZEOF_LDLTERM;
    int     index;
    short   sNumSpits = 32;
    memset (m_szCmdBuf, 0, LDLPACKET_MINSIZE);
    for (index = mem_needed; index < LDLPACKET_MINSIZE; index++)
        m_szCmdBuf[index] = 0xFF;
    if (mem_needed < LDLPACKET_MINSIZE)
        mem_needed = LDLPACKET_MINSIZE;
    FillLidilHeader (NULL, eLDLHandlePen, mem_needed);
    index = SIZEOF_LDLHDR;
    m_szCmdBuf[index++] = OPERATION_SPIT_PEN;
    WRITE16 (sNumSpits);
    m_szCmdBuf[mem_needed-1] = FRAME_SYN;
    pPrinterXBow->Send (m_szCmdBuf, (DWORD) mem_needed);

    return NO_ERROR;
}

DRIVER_ERROR LDLEncap::EndPage ()
{

    DRIVER_ERROR    err = NO_ERROR;
    int icount = 0;
    int iCurNumRasters = m_iRasterCount;
    if ((m_cPrintQuality == QUALITY_DRAFT || m_iYResolution == 300) && m_iRasterCount)
        icount = 1;
    else if (m_cPrintQuality != QUALITY_DRAFT)
    {
        icount = 4 * m_iBitDepth;
        iCurNumRasters = m_sSwathHeight * m_iNumColors;
    }

    int i, j, n;
    n = m_sSwathHeight / (4 * m_iBitDepth);

    n = n * (m_cPassNumber + 1) - m_iNextRaster;
    for (i = 0; i < m_iNumColors; i++)
    {
        for (j = 0; j < n; j++)
            memset (m_SwathData[i][m_iNextRaster+j], 0, m_iImageWidth * m_iBitDepth);
    }
    m_iNextRaster += n;
    n = m_sSwathHeight / (4 * m_iBitDepth);

    while (icount)
    {
        m_iRasterCount = iCurNumRasters;
        err = ProcessSwath (m_iImageWidth);
        if (err != NO_ERROR)
            break;
        icount--;
        if (m_iNextRaster >= m_sSwathHeight)
            m_iNextRaster = 0;
        for (i = 0; i < m_iNumColors; i++)
        {
            for (j = 0; j < n; j++)
                memset (m_SwathData[i][m_iNextRaster+j], 0, m_iImageWidth * m_iBitDepth);
        }
        m_iNextRaster += n;
    }

    UInt16 mem_needed = SIZEOF_LDLHDR
                        + SIZEOF_LDL_EJPAGE_CMDOPT
                        + SIZEOF_LDL_EJPAGE_OPTFLDS
                        + SIZEOF_LDLTERM;

    memset (m_szCmdBuf, 0, mem_needed);
    FillLidilHeader(NULL, eLDLEjectPage, mem_needed);

    int     index = SIZEOF_LDLHDR;
    WRITE32 (MEDIA_EJSPEED);

    m_szCmdBuf[index++] = 15;
    m_szCmdBuf[index++] = FRAME_SYN;

    if(err == NO_ERROR)
    {
        err = pPrinterXBow->Send (m_szCmdBuf, (DWORD) mem_needed);
    }

    m_sRefCount = 6;
    m_iBlankRasters = 0;
    m_iVertPosn = (int) (m_pthisPC->PrintableStartY () * DEVUNITS_XBOW);
    m_iRasterCount = 0;
    m_iNextRaster = 0;
    m_iNextColor  = 0;

	float   fXOverSpray = 0.0;
    float   fYOverSpray = 0.0;
    float   fLeftOverSpray = 0.0;
    float   fTopOverSpray  = 0.0;
	FullbleedType   fbType;
    if (m_pthisPC->bDoFullBleed &&
        pPrinterXBow->FullBleedCapable (m_pthisPC->thePaperSize,
									  &fbType,
                                      &fXOverSpray, &fYOverSpray,
                                      &fLeftOverSpray, &fTopOverSpray))
    {

		/*
		 *      To get the printer to do fullbleed printing, move the vertical postion 
		 *      to cover the overspary. Overspray is needed to take care of
		 *      skew during paper pick. These values may be mech dependent.
		 *      Currently, supported only on PhotoSmart 100, Malibu. DJ3600 supports
		 *      fullbleed printing also. The current values for overspray are
		 *      0.059 inch for top, bottom and left edges and 0.079 for right edge.
		 */
		m_iVertPosn = (int) (-fTopOverSpray * DEVUNITS_XBOW);
    }

    if (/*m_iYResolution != 300*/m_cPrintQuality != QUALITY_DRAFT)
        m_iRasterCount = (m_sSwathHeight - m_sSwathHeight / 4) * m_iNumColors;

    m_bStartPageNotSent = TRUE;

    if (m_cPrintQuality != QUALITY_DRAFT && m_iYResolution != 300)
    {
        m_iRasterCount = (m_sSwathHeight - m_sSwathHeight / (4*m_iBitDepth)) * m_iNumColors;
        m_iVertPosn -= (((m_sSwathHeight - m_sSwathHeight / (4*m_iBitDepth)) * 600 / m_iYResolution) * DEVUNITS_XBOW / 600);
    }
    m_cPassNumber = 0;

    if (m_pthisPC->bDoFullBleed &&
        pPrinterXBow->FullBleedCapable (m_pthisPC->thePaperSize,
									  &fbType,
                                      &fXOverSpray, &fYOverSpray,
                                      &fLeftOverSpray, &fTopOverSpray))
	{
		if (m_iVertPosn < -850) m_iVertPosn = -850;
	}
	else
	{
		if (m_iVertPosn < -600) m_iVertPosn = -600;
	}
    if (m_iBitDepth == 2)
        m_iVertPosn += 6;

    for (i = 0; i < m_iNumColors; i++)
    {
        for (int j = 0; j < m_sSwathHeight; j++)
        {
            memset (m_SwathData[i][j], 0, m_iImageWidth);
        }
    }

    return (err);
}

// This routine dynamically allocates memory in which to read bytes from the port.  We allocate
// memory in MAX_PACKET_READ_SIZE chunks, which we set in ldlencap.h to 256 bytes.  The minimum
// read size is the size of a printer packet, which is 64 bytes.  We shouldn't have to read more
// than 256 bytes from the port since we only are getting credit and status.  Developers may want
// to increase or decrease the MAX_PACKET_READ_SIZE for their particular system based upon whether
// memory is easier to get statically or dynamically.  For instance, a system with a lot of static
// memory may want to increase MAX_PACKET_READ_SIZE to 4096 to minimize reads.  A system with
// limited static memory may want to allocate memory in smaller chunks, so 256 may be better.  The
// developer may reduce the MAX_PACKET_READ_SIZE to as little as 64 if desired, but it must always
// be a multiple of 64.

/*
 *    Author: Don Castrapel
 */

BOOL LDLEncap::GetPackets(DWORD &dwBytesRead)
{
    DRIVER_ERROR err = NO_ERROR;
    DWORD dwReadSize = 0;
    WORD wPacketWaitCount = 0;
    BYTE *pbyPacketBuff = NULL;

    dwBytesRead = 0;

    if(m_pbyPacketBuff)
    {
        // If we've had to reallocate the packet read buffer because it was too small to hold a read,
        // let's deallocate it and start with the original size.  This will prevent us hanging onto
        // what could be a large chunk of memory while also not performing multiple allocs and deallocs
        // in the normal case where the buffer holds the entire read
        if(m_dwPacketBuffSize != MAX_PACKET_READ_SIZE)
        {
            m_pSys->FreeMem ((BYTE *) m_pbyPacketBuff);
            m_pbyPacketBuff = NULL;
            m_dwPacketBuffSize = 0;
        }
        else
            memset(m_pbyPacketBuff, 0, MAX_PACKET_READ_SIZE);
    }

    // Wait for packets
    while(!dwBytesRead && wPacketWaitCount++ < PACKET_WAIT)
    {
        if(m_pSys->BusyWait((DWORD)100) == JOB_CANCELED)
        {
            return FALSE;
        }

        dwReadSize = MAX_PACKET_READ_SIZE;

        do
        {
            // If we've done a read but it was not a multiple of MAX_PACKET_READ_SIZE, then we
            // didn't read the full request size last time.  That means that we read some bytes
            // but that the printer didn't have any more to send
            if(dwBytesRead % MAX_PACKET_READ_SIZE)
            {
                break; // Out of do loop
            }

            // FromDevice resets dwReadSize to the number of bytes read from the port
            dwReadSize = MAX_PACKET_READ_SIZE;

            if(!m_pbyPacketBuff)
            {
                // First read, allocate buffer to hold data
                m_pbyPacketBuff = m_pSys->AllocMem(MAX_PACKET_READ_SIZE);
                if(!m_pbyPacketBuff)
                {
                    return FALSE;
                }
                memset(m_pbyPacketBuff, 0, MAX_PACKET_READ_SIZE);
                m_dwPacketBuffSize = MAX_PACKET_READ_SIZE;
            }
            else if(dwBytesRead)
            {
                // We've already read some bytes, so allocate a temporary buffer to store
                // what we've read so far.  We'll copy what we've read into the temporary buffer,
                // delete the original buffer, reallocate a new buffer MAX_PACKET_READ_SIZE
                // bytes larger, read the temporary buffer back into the newly reallocated
                // buffer, then delete the temporary buffer
                pbyPacketBuff = m_pSys->AllocMem(dwBytesRead + MAX_PACKET_READ_SIZE);
                if(!pbyPacketBuff)
                {
                    return FALSE;
                }
                m_dwPacketBuffSize += MAX_PACKET_READ_SIZE;
                memset(pbyPacketBuff, 0, m_dwPacketBuffSize);

                memcpy(pbyPacketBuff, m_pbyPacketBuff, dwBytesRead);
                if(m_pbyPacketBuff)
                {
                    m_pSys->FreeMem((BYTE *)m_pbyPacketBuff);
                    m_pbyPacketBuff = NULL;
                }

                m_pbyPacketBuff = pbyPacketBuff;
            }

            err = m_pSys->FromDevice((m_pbyPacketBuff + dwBytesRead), &dwReadSize);
            if(err)
            {
                return FALSE;
            }
            dwBytesRead += dwReadSize;
        } while(!err && dwReadSize);
    } // while(!dwBytesRead && wPacketWaitCount++ < PACKET_WAIT)

    if(!dwBytesRead)
    {
        // No data to read from port
        return FALSE;
    }

    return TRUE;
}

/*
 *    Author: Don Castrapel
 */

BOOL LDLEncap::UpdateState(BOOL bInitialize)
{
//    DRIVER_ERROR err = NO_ERROR;
    BOOL bPacketsReceived = FALSE;
    BOOL bUpdatedState = FALSE;
    BYTE byPacketType = 0;
    BYTE byCommandNumber = 0;
    WORD wCommandLength = 0;
    WORD wDataLength = 0;
    WORD wReferenceNumber = 0;
    DWORD dwBytesRead = 0;
    DWORD dwBytesProcessed = 0;
    BYTE by = 0;

    // Read packets from port
    bPacketsReceived = GetPackets(dwBytesRead);
    if(!bPacketsReceived)
    {
        return FALSE;
    }

    while(dwBytesProcessed < dwBytesRead)
    {
        if(m_pbyPacketBuff[dwBytesProcessed] != '$')
        {
            return FALSE;
        }

        // Get packet type and command number, command length, data length
        byPacketType = m_pbyPacketBuff[PACKET_TYPE_BYTE + dwBytesProcessed];
        byCommandNumber = m_pbyPacketBuff[COMMAND_NUMBER_BYTE + dwBytesProcessed];
        wCommandLength = (m_pbyPacketBuff[COMMAND_LENGTH_BYTE + dwBytesProcessed] << 8) |
                          m_pbyPacketBuff[COMMAND_LENGTH_BYTE + 1 + dwBytesProcessed];
        wDataLength = (m_pbyPacketBuff[DATA_LENGTH_BYTE + dwBytesProcessed] << 8) |
                       m_pbyPacketBuff[DATA_LENGTH_BYTE + 1 + dwBytesProcessed];
        wReferenceNumber = (m_pbyPacketBuff[REFERENCE_NUMBER_BYTE + dwBytesProcessed] << 8) |
                            m_pbyPacketBuff[REFERENCE_NUMBER_BYTE + 1 + dwBytesProcessed];

        // We should only get packet type 16 (Response, Command Executed), packet type
        // 24 (Response, Auto), packet type 32 (Absolute Credit) or packet type 33
        // (Incremental Credit).

        // For credit packets, we'll update the credit.  Credit for each command number starts at
        // byte 12, or m_pbyPacketBuff[11].  Credit is a 2-byte signed value, so we have to multiply
        // the loop counter by 2 to get the right array index.  A byPacketType of 32 indicates
        // absolute credit, while a byPacketType value of 33 indicates incremental credit.

        // For a command executed packet, we'll switch again and do the appropriate thing based upon
        // the command number for which the printer generated the response packet
        switch(byPacketType)
        {
            case ABSOLUTE_CREDIT:
                if(bInitialize)
                {
                    // Get number of commands to allocate memory for CreditCount buffer.
                    // Byte 11(byReadBuff[10])
                    byNumberOfCommands = m_pbyPacketBuff[NUMBER_OF_COMMANDS_BYTE];

                    if(piCreditCount)
                    {
                        m_pSys->FreeMem((BYTE*)piCreditCount);
                    }
                    piCreditCount =
                        (short int *)(m_pSys->AllocMem(sizeof(short int) * byNumberOfCommands));
                    if(!piCreditCount)
                    {
                        return FALSE;
                    }
                    memset(piCreditCount, 0, (sizeof(short int) * byNumberOfCommands));
                }

                for(by = 0; by < byNumberOfCommands; by++)
                {
                    piCreditCount[by] = (m_pbyPacketBuff[by * 2 + CREDIT_BYTE + dwBytesProcessed] << 8) |
                                        (m_pbyPacketBuff[by * 2 + CREDIT_BYTE + 1 + dwBytesProcessed]);
                }

                bUpdatedState = TRUE;

                break;

            case INCREMENTAL_CREDIT:
                if(bInitialize)
                {
                    // If we're initializing we must wait for an absolute credit packet
                    break;
                }

                for(by = 0; by < byNumberOfCommands; by++)
                {
                    piCreditCount[by] += (m_pbyPacketBuff[by * 2 + CREDIT_BYTE + dwBytesProcessed] << 8) |
                                         (m_pbyPacketBuff[by * 2 + CREDIT_BYTE + 1 + dwBytesProcessed]);
                }

                bUpdatedState = TRUE;

                break;

/*          case RESPONSE_COMMAND_EXECUTED:
                if(bInitialize)
                {
                    // If we're initializing we must wait for an absolute credit packet
                    return FALSE;
                }

                // We should only get command number 5, which is the Query command
                switch(byCommandNumber)
                {
                    case COMMAND_QUERY:
                        // Copy status into LDLEncap's status buffer
                        memcpy(byStatusBuff, (m_pbyPacketBuff + dwBytesProcessed),
                              (wCommandLength + wDataLength));
                        bNewStatus = TRUE;

                        break;

                    default:
                        break;
                } // switch(byCommandNumber)

                break;*/

            case RESPONSE_AUTO:
                if(bInitialize)
                {
                    // If we're initializing we must wait for an absolute credit packet
                    break;
                }

                // We should only get reference number 1, which is what I set up for the
                // EOCStatusQuery command
                switch(wReferenceNumber)
                {
                    case AUTO_RESPONSE_STATUS:

                        // Copy status into LDLEncap's status buffer
                        memcpy(byStatusBuff, (m_pbyPacketBuff + dwBytesProcessed),
                              (wCommandLength + wDataLength));
                        bNewStatus = TRUE;
                        bUpdatedState = TRUE;

                        break;

                    default:

                        break;
                } // switch(wReferenceNumber)

                break;

            default:
                if(bInitialize)
                {
                    // If we're initializing we must wait for an absolute credit packet
                    break;
                }

                break;

        } // switch(byPacketType)

        dwBytesProcessed += (DWORD)(wCommandLength + wDataLength);
    } // while(dwBytesProcessed < dwBytesRead)

    return bUpdatedState;
}

#ifdef  APDK_LDL_COMPRESS

/*
 *  Compression Related
 *  Mark Lund
 */


///////////////////////////////////////////////////////////////////////
// Flush_Image
///////////////////////////////////////////////////////////////////////

UInt16 LDLEncap::FlushImage ()
{
    UInt16    command;
    UInt16    wsize;
    UInt16    bsize;
    UInt16    *from_ptr;
    int       index;

    wsize = m_ldlCompressData->image_cnt;
    bsize = 0;

    if (wsize)
    {
        from_ptr = m_ldlCompressData->image_ptr;

        command = FILL_IMAGE_CMD | (wsize-1);

        index = 0;
        WRITE16(command);
        if (m_bLittleEndian)
        {
            *m_ldlCompressData->out_ptr++ = (((UInt16) m_szCmdBuf[1]) << 8) | m_szCmdBuf[0];
        }
        else
        {
            *m_ldlCompressData->out_ptr++ = command;
        }
/*
        memcpy (m_ldlCompressData->out_ptr, from_ptr, sizeof (UInt16) * wsize);
        m_ldlCompressData->out_ptr += wsize;
*/
        for (UInt16 i = 0; i < wsize; i++)
        {
            *m_ldlCompressData->out_ptr++ = *from_ptr++;
        }
        bsize = ((m_ldlCompressData->image_cnt+1) * 2);
        m_ldlCompressData->out_cnt += bsize;

        m_ldlCompressData->image_cnt = 0;
    }

    return bsize;
}

///////////////////////////////////////////////////////////////////////
// Flush_Copy
///////////////////////////////////////////////////////////////////////
UInt16 LDLEncap::FlushCopy (UInt16 value)
{
    UInt16    command;
    UInt16    size;

    int       index;

    size = m_ldlCompressData->copy_cnt;

    if (size)
    {
        UInt16  *uP = m_ldlCompressData->out_ptr++;
        size = 2;
        if (value == 0)
        {
            command = FILL_0000_CMD | (m_ldlCompressData->copy_cnt-1);
        }
        else if (value == 0xFFFF)
        {
            command = FILL_FFFF_CMD | (m_ldlCompressData->copy_cnt-1);
        }
        else
        {
            command = FILL_NEXT_CMD | (m_ldlCompressData->copy_cnt-1);
//            index = 0;
//            WRITE16 (value);
            *m_ldlCompressData->out_ptr++ = value;
//            *m_ldlCompressData->out_ptr++ = (((UInt16) m_szCmdBuf[1]) << 8) | m_szCmdBuf[0];
            size = 4;
        }

        index = 0;
        WRITE16(command);
        if (m_bLittleEndian)
        {
            *uP = (((UInt16) m_szCmdBuf[1]) << 8) | m_szCmdBuf[0];
        }
        else
        {
            *uP = command;
        }

        m_ldlCompressData->out_cnt += size;
        m_ldlCompressData->copy_cnt = 0;
    }
    return size;
}

///////////////////////////////////////////////////////////////////////
// Compress_Data
///////////////////////////////////////////////////////////////////////
void LDLEncap::CompressData (Int16 compressionmode)
{
    Int16   i;
    UInt16  *in_ptr;
    UInt16  in;
    UInt16  last=0;
    UInt16  copy_item;
    UInt16  data_length;

    LDLCOMPMODE mode = IN_NOT;


    m_ldlCompressData->out_cnt = 0;
    m_ldlCompressData->image_cnt = 0;
    m_ldlCompressData->copy_cnt = 0;

    m_ldlCompressData->out_ptr = &m_ldlCompressData->out_array[8];
    data_length = m_ldlCompressData->data_length;

    if ((data_length & 1) != 0)
    {
    //    ErrorTrap((char *)"Data length is odd.");
    }

    copy_item = 0;
    in_ptr = &m_ldlCompressData->raw_data[0];

    for (i=0; i<data_length; i+=2)
    {
        in = *in_ptr;

        switch(mode)
        {
            case IN_NOT:
            {
                /* default the first entry to 'image' */
                last = in;
                m_ldlCompressData->image_ptr = in_ptr;
                m_ldlCompressData->image_cnt = 1;
                mode = IN_FIRST;
                break;
            }

            case IN_FIRST:
            {
#if ALLOW_FILL_NEXT_CMD
                if (last == in)
#else
                if ((last == in) && ((in==0xFFFF) || (in == 0)) )
#endif
                {
                    mode = IN_COPY;
                    m_ldlCompressData->copy_cnt = 2;
                    m_ldlCompressData->image_cnt = 0;
                    copy_item = in;
                }
                else
                {
                    mode = IN_IMAGE;
                    m_ldlCompressData->image_cnt++;
                    last = in;
                }
                break;
            }

            case IN_COPY:
            {
                if (last == in)
                {
                    m_ldlCompressData->copy_cnt++;
                }
                else
                {
                    /* revisit - could allow 2 words of copy if the data is
                    0000 or FFFF */

                    /* convert a copy cnt of 2 to an image */
                    UInt16 copy_count = m_ldlCompressData->copy_cnt;

                    if (copy_count <= m_ldlCompressData->run_length)
                    {
                        if (m_ldlCompressData->image_cnt == 0)
                        {
                            /* point the pointer to the first element */
                            m_ldlCompressData->image_ptr = in_ptr - copy_count;
                        }
                        m_ldlCompressData->image_cnt += (1+copy_count);
                     m_ldlCompressData->copy_cnt = 0;
                    }
                    else
                    {
                        /* have enough to be a legal copy */

                        (void) FlushImage ();

                        (void) FlushCopy (copy_item);

                        m_ldlCompressData->image_ptr = in_ptr;
                        m_ldlCompressData->image_cnt = 1;
                    }
                    mode = IN_IMAGE;
                    last = in;
                }
                break;
            }

            case IN_IMAGE:
            {
#if ALLOW_FILL_NEXT_CMD
                if (last == in)
#else
                if ((last == in) && ((in==0xFFFF) || (in == 0)) )
#endif
                {
                    m_ldlCompressData->image_cnt--;

                    mode = IN_COPY;
                    copy_item = in;
                    m_ldlCompressData->copy_cnt = 2;
                }
                else /* different */
                {
                    last = in;
                    m_ldlCompressData->image_cnt++;
                }
                break;
            }

            default:
            {
                break;
            }
        }
        in_ptr++;
    } /* next data - end of processing */

    /* flush out the remainder */

    switch(mode)
    {
        case IN_COPY:
        {
            /* have enough to be a legal copy */
            (void) FlushImage ();

            (void) FlushCopy (copy_item);
            break;
        }
        case IN_IMAGE:
        case IN_FIRST:
        {
            (void) FlushImage ();
            break;
        }
        default:
            break;
    }

    if (m_ldlCompressData->out_cnt > 2048+16)
    {
    //    ErrorTrap("out cnt too big");
    //    exit (-7);
    }
}

/////////////////////////////////////////////////////////////////////////////////
//GetFrameInfo 
/////////////////////////////////////////////////////////////////////////////////
BOOL LDLEncap::GetFrameInfo (BYTE **outdata, UInt16 *data_size)
{
    *outdata = (unsigned char *) &m_ldlCompressData->out_array[0];
    *data_size = m_ldlCompressData->out_cnt;
    return(TRUE);
}

/////////////////////////////////////////////////////////////////////////////////
//Init: to init/reinit the data structure. 
/////////////////////////////////////////////////////////////////////////////////
BOOL comp_ptrs_t::Init (UInt16 *data, UInt16 datasize)
{
	image_ptr   = data;
	raw_data    = data;
	data_length = datasize;

	run_length = MAX_RUNLENGTH;
	display = 0;

	return(TRUE);
}
#endif  // APDK_LDL_COMPRESS

APDK_END_NAMESPACE

#endif  // APDK_DJ3320