windows-server-2003/windows/core/ntgdi/gre/stretch.cxx

/******************************Module*Header*******************************\
* Module Name: stretch.cxx
*
* Internal DDAs for EngStretchBlt
*
* Created: 16-Feb-1993 15:35:02
* Author: Donald Sidoroff [donalds]
*
* Copyright (c) 1993-1999 Microsoft Corporation
\**************************************************************************/

#include "precomp.hxx"
#include "stretch.hxx"

#ifdef DBG_STRBLT
extern BOOL gflStrBlt;
#endif

static VOID STR_DIV(
DIV_T *pdt,
LONG   lNum,
LONG   lDen)
{
    if (lNum < 0)
    {
        lNum = - (lNum + 1);
        pdt->lQuo = lNum / lDen;
        pdt->lRem = lNum % lDen;
        pdt->lQuo = - (pdt->lQuo + 1);
        pdt->lRem = lDen - pdt->lRem - 1;
    }
    else
    {
        pdt->lQuo = lNum / lDen;
        pdt->lRem = lNum % lDen;
    }

#ifdef DBG_STRBLT
    if (gflStrBlt & STRBLT_SHOW_INIT)
    DbgPrint("%ld / %ld = %ld R %ld\n", lNum, lDen, pdt->lQuo, pdt->lRem);
#endif
}

/******************************Public*Routine******************************\
* VOID vInitStrDDA(pdda, prclScan, prclSrc, prclTrg)
*
* Initialize the DDA
*
* History:
*  16-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vInitStrDDA(
STRDDA *pdda,
RECTL  *prclScan,
RECTL  *prclSrc,
RECTL  *prclTrg)
{
    RECTL   rclScan;
    RECTL   rclSrc;

// If the source surface does not have a 0,0 origin, deal with it here.

    if ((prclSrc->left != 0) || (prclSrc->top != 0))
    {
        rclScan.left   = prclScan->left   - prclSrc->left;
        rclScan.top    = prclScan->top    - prclSrc->top;
        rclScan.right  = prclScan->right  - prclSrc->left;
        rclScan.bottom = prclScan->bottom - prclSrc->top;
    prclScan = &rclScan;

        rclSrc.left   = 0;
        rclSrc.top    = 0;
        rclSrc.right  = prclSrc->right - prclSrc->left;
        rclSrc.bottom = prclSrc->bottom - prclSrc->top;
        prclSrc = &rclSrc;
    }

#ifdef DBG_STRBLT
    if (gflStrBlt & STRBLT_SHOW_INIT)
    {
    DbgPrint("prclScan = [(%ld,%ld) (%ld,%ld)]\n",
          prclScan->left, prclScan->top, prclScan->right, prclScan->bottom);

        DbgPrint("prclSrc = [(%ld,%ld) (%ld,%ld)]\n",
                  prclSrc->left, prclSrc->top, prclSrc->right, prclSrc->bottom);

        DbgPrint("prclTrg = [(%ld,%ld) (%ld,%ld)]\n",
                  prclTrg->left, prclTrg->top, prclTrg->right, prclTrg->bottom);
    }
#endif

    pdda->plYStep = &pdda->al[prclSrc->right];

    DDA_STEP dQnext;    // increment on position of next pixel image
    DIV_T    Qnext;     // starting position of next pixel image
    LONG     lQ;        // current positon
    LONG     iLoop;
    LONG     j;


//
// x-coordinates
//

    STR_DIV(&dQnext.dt, prclTrg->right - prclTrg->left, prclSrc->right);
    dQnext.lDen = prclSrc->right;

    Qnext.lQuo = dQnext.dt.lQuo;
    Qnext.lRem = dQnext.dt.lRem + ((dQnext.lDen - 1)>>1);
    if (Qnext.lRem >= dQnext.lDen)
    {
        Qnext.lQuo += 1;
        Qnext.lRem -= dQnext.lDen;
    }

    for (lQ = 0, iLoop = 0; iLoop < prclScan->left; iLoop++)
    {
        lQ = Qnext.lQuo;
        DDA(&Qnext, &dQnext);
    }

    pdda->rcl.left = lQ + prclTrg->left;
    for (j = 0; iLoop < prclScan->right; iLoop++, j++)
    {
        pdda->al[j] = Qnext.lQuo - lQ;
        lQ = Qnext.lQuo;
        DDA(&Qnext, &dQnext);
    }
    pdda->rcl.right = lQ + prclTrg->left;

//
// y-coordinates
//
    STR_DIV(&dQnext.dt, prclTrg->bottom - prclTrg->top, prclSrc->bottom);
    dQnext.lDen = prclSrc->bottom;

    Qnext.lQuo = dQnext.dt.lQuo;
    Qnext.lRem = dQnext.dt.lRem + ((dQnext.lDen - 1)>>1);
    if (Qnext.lRem >= dQnext.lDen)
    {
        Qnext.lQuo += 1;
        Qnext.lRem -= dQnext.lDen;
    }

    for (lQ = 0, iLoop = 0; iLoop < prclScan->top; iLoop++)
    {
        lQ = Qnext.lQuo;
        DDA(&Qnext, &dQnext);
    }

    pdda->rcl.top = lQ + prclTrg->top;
    for (j = 0; iLoop < prclScan->bottom; iLoop++, j++)
    {
        pdda->plYStep[j] = Qnext.lQuo - lQ;
        lQ = Qnext.lQuo;
        DDA(&Qnext, &dQnext);
    }
    pdda->rcl.bottom = lQ + prclTrg->top;

#ifdef DBG_STRBLT
    if (gflStrBlt & STRBLT_SHOW_INIT)
        DbgPrint("XStep @%08lx, YStep @%08lx\n", (ULONG) pdda->al, (ULONG) pdda->plYStep);
#endif
}

/******************************Public*Routine******************************\
* VOID vInitBuffer(prun, ercl, iMode)
*
* Initialize the run buffer for overwrite modes
*
* History:
*  27-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vInitBuffer(
STRRUN *prun,
RECTL  *prcl,
ULONG   iOver)
{
    prun->xrl.xPos = prcl->left;
    prun->xrl.cRun = prcl->right - prcl->left;

    RtlFillMemoryUlong((VOID *) &prun->xrl.aul[0], prun->xrl.cRun << 2, iOver);
}

static ULONG gaulMaskEdge[] =
{
    0xFFFFFFFF, 0xFFFFFF7F, 0xFFFFFF3F, 0xFFFFFF1F,
    0xFFFFFF0F, 0xFFFFFF07, 0xFFFFFF03, 0xFFFFFF01,
    0xFFFFFF00, 0xFFFF7F00, 0xFFFF3F00, 0xFFFF1F00,
    0xFFFF0F00, 0xFFFF0700, 0xFFFF0300, 0xFFFF0100,
    0xFFFF0000, 0xFF7F0000, 0xFF3F0000, 0xFF1F0000,
    0xFF0F0000, 0xFF070000, 0xFF030000, 0xFF010000,
    0xFF000000, 0x7F000000, 0x3F000000, 0x1F000000,
    0x0F000000, 0x07000000, 0x03000000, 0x01000000
};

static ULONG gaulMaskMono[] =
{
    0x00000080, 0x00000040, 0x00000020, 0x00000010,
    0x00000008, 0x00000004, 0x00000002, 0x00000001,
    0x00008000, 0x00004000, 0x00002000, 0x00001000,
    0x00000800, 0x00000400, 0x00000200, 0x00000100,
    0x00800000, 0x00400000, 0x00200000, 0x00100000,
    0x00080000, 0x00040000, 0x00020000, 0x00010000,
    0x80000000, 0x40000000, 0x20000000, 0x10000000,
    0x08000000, 0x04000000, 0x02000000, 0x01000000
};

static ULONG gaulShftMono[] =
{
    0x00000007, 0x00000006, 0x00000005, 0x00000004,
    0x00000003, 0x00000002, 0x00000001, 0x00000000,
    0x0000000F, 0x0000000E, 0x0000000D, 0x0000000C,
    0x0000000B, 0x0000000A, 0x00000009, 0x00000008,
    0x00000017, 0x00000016, 0x00000015, 0x00000014,
    0x00000013, 0x00000012, 0x00000011, 0x00000010,
    0x0000001F, 0x0000001E, 0x0000001D, 0x0000001C,
    0x0000001B, 0x0000001A, 0x00000019, 0x00000018
};

static ULONG gaulMaskQuad[] =
{
    0x000000F0, 0x0000000F, 0x0000F000, 0x00000F00,
    0x00F00000, 0x000F0000, 0xF0000000, 0x0F000000
};

static ULONG gaulShftQuad[] =
{
    0x00000004, 0x00000000, 0x0000000C, 0x00000008,
    0x00000014, 0x00000010, 0x0000001C, 0x00000018
};

/******************************Public*Routine******************************\
* VOID vStrMirror01(pSurf)
*
* Mirror the 1BPP surface in X.
*
* History:
*  08-Mar-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vStrMirror01(SURFACE *pSurf)
{
    ULONG  *pulBase;
    ULONG  *pulSrc;
    ULONG  *pulTrg;
    ULONG   ulSrc;
    ULONG   ulTrg;
    ULONG   ulSwp;
    ULONG   ulTmp;
    LONG    cFlip;
    LONG    cLeft;
    LONG    cRght;
    LONG    iLeft;
    LONG    iRght;
    LONG    x;
    LONG    y;

    pulBase = (ULONG *) pSurf->pvScan0();
    cFlip   = pSurf->sizl().cx / 2;

    for (y = 0; y < pSurf->sizl().cy; y++)
    {
        iLeft  = 0;
        cLeft  = 0;
        iRght  = pSurf->sizl().cx - 1;
        cRght  = iRght >> 5;
        iRght &= 31;

        pulSrc = pulBase;
        pulTrg = pulSrc + cRght;

        ulSrc  = *pulSrc;
        ulTrg  = *pulTrg;

        for (x = 0; x < cFlip; x++)
        {
            if (cLeft == cRght)
            {
                ulSwp = (ulSrc & gaulMaskMono[iLeft]) >> gaulShftMono[iLeft];
                ulTmp = (ulSrc & gaulMaskMono[iRght]) >> gaulShftMono[iRght];
                ulSrc = (ulSrc & ~gaulMaskMono[iLeft]) | (ulTmp << gaulShftMono[iLeft]);
                ulSrc = (ulSrc & ~gaulMaskMono[iRght]) | (ulSwp << gaulShftMono[iRght]);
            }
            else
            {
                ulSwp = (ulSrc & gaulMaskMono[iLeft]) >> gaulShftMono[iLeft];
                ulTmp = (ulTrg & gaulMaskMono[iRght]) >> gaulShftMono[iRght];
                ulSrc = (ulSrc & ~gaulMaskMono[iLeft]) | (ulTmp << gaulShftMono[iLeft]);
                ulTrg = (ulTrg & ~gaulMaskMono[iRght]) | (ulSwp << gaulShftMono[iRght]);
            }

            iLeft++;
            iRght--;

            if (iLeft & 32)
            {
               *pulSrc = ulSrc;
                pulSrc++;
                cLeft++;

                if (cLeft == cRght)
                   *pulTrg = ulTrg;

                ulSrc = *pulSrc;
                iLeft = 0;
            }

            if (iRght < 0)
            {
               *pulTrg = ulTrg;
                pulTrg--;
                cRght--;

                if (cRght == cLeft)
                   *pulSrc = ulSrc;
                else
                    ulTrg = *pulTrg;

                iRght = 31;
            }
    }

       *pulSrc = ulSrc;

    if (cLeft != cRght)
       *pulTrg = ulTrg;

        pulBase = (ULONG *) (((BYTE *) pulBase) + pSurf->lDelta());
    }
}

/******************************Public*Routine******************************\
* VOID vStrMirror04(pSurf)
*
* Mirror the 4BPP surface in X.
*
* History:
*  08-Mar-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vStrMirror04(SURFACE *pSurf)
{
    ULONG  *pulBase;
    ULONG  *pulSrc;
    ULONG  *pulTrg;
    ULONG   ulSrc;
    ULONG   ulTrg;
    ULONG   ulSwp;
    ULONG   ulTmp;
    LONG    cFlip;
    LONG    cLeft;
    LONG    cRght;
    LONG    iLeft;
    LONG    iRght;
    LONG    x;
    LONG    y;

    pulBase = (ULONG *) pSurf->pvScan0();
    cFlip   = pSurf->sizl().cx / 2;

    for (y = 0; y < pSurf->sizl().cy; y++)
    {
        iLeft  = 0;
        cLeft  = 0;
        iRght  = pSurf->sizl().cx - 1;
        cRght  = iRght >> 3;
        iRght &= 7;

        pulSrc = pulBase;
        pulTrg = pulSrc + cRght;

        ulSrc  = *pulSrc;
        ulTrg  = *pulTrg;

        for (x = 0; x < cFlip; x++)
        {
            if (cLeft == cRght)
            {
                ulSwp = (ulSrc & gaulMaskQuad[iLeft]) >> gaulShftQuad[iLeft];
                ulTmp = (ulSrc & gaulMaskQuad[iRght]) >> gaulShftQuad[iRght];
                ulSrc = (ulSrc & ~gaulMaskQuad[iLeft]) | (ulTmp << gaulShftQuad[iLeft]);
                ulSrc = (ulSrc & ~gaulMaskQuad[iRght]) | (ulSwp << gaulShftQuad[iRght]);
            }
            else
            {
                ulSwp = (ulSrc & gaulMaskQuad[iLeft]) >> gaulShftQuad[iLeft];
                ulTmp = (ulTrg & gaulMaskQuad[iRght]) >> gaulShftQuad[iRght];
                ulSrc = (ulSrc & ~gaulMaskQuad[iLeft]) | (ulTmp << gaulShftQuad[iLeft]);
                ulTrg = (ulTrg & ~gaulMaskQuad[iRght]) | (ulSwp << gaulShftQuad[iRght]);
            }

            iLeft++;
            iRght--;

            if (iLeft & 8)
            {
               *pulSrc = ulSrc;
                pulSrc++;
                cLeft++;

                if (cLeft == cRght)
                   *pulTrg = ulTrg;

                ulSrc = *pulSrc;
                iLeft = 0;
            }

            if (iRght < 0)
            {
               *pulTrg = ulTrg;
                pulTrg--;
                cRght--;

                if (cRght == cLeft)
                   *pulSrc = ulSrc;
                else
                    ulTrg = *pulTrg;

                iRght = 7;
        }

       *pulSrc = ulSrc;

    if (cLeft != cRght)
       *pulTrg = ulTrg;

    }

        pulBase = (ULONG *) (((BYTE *) pulBase) + pSurf->lDelta());
    }
}

/******************************Public*Routine******************************\
* VOID vStrMirror08(pSurf)
*
* Mirror the 8BPP surface in X.
*
* History:
*  08-Mar-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vStrMirror08(SURFACE *pSurf)
{
    BYTE   *pjSrc;
    BYTE   *pjTrg;
    BYTE   *pjBase;
    BYTE    jTemp;
    LONG    cFlip;
    LONG    x;
    LONG    y;

    pjBase = (BYTE *) pSurf->pvScan0();
    cFlip  = pSurf->sizl().cx / 2;

    for (y = 0; y < pSurf->sizl().cy; y++)
    {
        pjSrc = pjBase;
        pjTrg = pjSrc + pSurf->sizl().cx - 1;

        for (x = 0; x < cFlip; x++)
        {
            jTemp = *pjSrc;
           *pjSrc = *pjTrg;
           *pjTrg =  jTemp;
            pjSrc++;
            pjTrg--;
        }

        pjBase += pSurf->lDelta();
    }
}

/******************************Public*Routine******************************\
* VOID vStrMirror16(pSurf)
*
* Mirror the 16BPP surface in X.
*
* History:
*  08-Mar-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vStrMirror16(SURFACE *pSurf)
{
    WORD   *pwSrc;
    WORD   *pwTrg;
    WORD   *pwBase;
    WORD    wTemp;
    LONG    cFlip;
    LONG    x;
    LONG    y;

    pwBase = (WORD *) pSurf->pvScan0();
    cFlip  = pSurf->sizl().cx / 2;

    for (y = 0; y < pSurf->sizl().cy; y++)
    {
        pwSrc = pwBase;
        pwTrg = pwSrc + pSurf->sizl().cx - 1;

        for (x = 0; x < cFlip; x++)
        {
            wTemp = *pwSrc;
           *pwSrc = *pwTrg;
           *pwTrg =  wTemp;
            pwSrc++;
            pwTrg--;
        }

        pwBase = (WORD *) (((BYTE *) pwBase) + pSurf->lDelta());
    }
}

/******************************Public*Routine******************************\
* VOID vStrMirror24(pSurf)
*
* Mirror the 24BPP surface in X.
*
* History:
*  08-Mar-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vStrMirror24(SURFACE *pSurf)
{
    RGBTRIPLE  *prgbSrc;
    RGBTRIPLE  *prgbTrg;
    RGBTRIPLE  *prgbBase;
    RGBTRIPLE   rgbTemp;
    LONG        cFlip;
    LONG        x;
    LONG        y;

    prgbBase = (RGBTRIPLE *) pSurf->pvScan0();
    cFlip    = pSurf->sizl().cx / 2;

    for (y = 0; y < pSurf->sizl().cy; y++)
    {
        prgbSrc = prgbBase;
        prgbTrg = prgbSrc + pSurf->sizl().cx - 1;

        for (x = 0; x < cFlip; x++)
        {
            rgbTemp = *prgbSrc;
           *prgbSrc = *prgbTrg;
           *prgbTrg =  rgbTemp;
            prgbSrc++;
            prgbTrg--;
        }

        prgbBase = (RGBTRIPLE *) (((BYTE *) prgbBase) + pSurf->lDelta());
    }
}

/******************************Public*Routine******************************\
* VOID vStrMirror32(pSurf)
*
* Mirror the 32BPP surface in X.
*
* History:
*  08-Mar-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vStrMirror32(SURFACE *pSurf)
{
    DWORD  *pdwSrc;
    DWORD  *pdwTrg;
    DWORD  *pdwBase;
    DWORD   dwTemp;
    LONG    cFlip;
    LONG    x;
    LONG    y;

    pdwBase = (DWORD *) pSurf->pvScan0();
    cFlip   = pSurf->sizl().cx / 2;

    for (y = 0; y < pSurf->sizl().cy; y++)
    {
        pdwSrc = pdwBase;
        pdwTrg = pdwSrc + pSurf->sizl().cx - 1;

        for (x = 0; x < cFlip; x++)
        {
            dwTemp = *pdwSrc;
           *pdwSrc = *pdwTrg;
           *pdwTrg =  dwTemp;
            pdwSrc++;
            pdwTrg--;
        }

        pdwBase = (DWORD *) (((BYTE *) pdwBase) + pSurf->lDelta());
    }
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead01AND(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, xlate colors, AND the pels and produce a run
* list for a row of a 1BPP surface.
*
* History:
*  27-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead01AND(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    ULONG   *pulSrc;
    ULONG    ulSrc;
    ULONG    iBlack;
    ULONG    iWhite;
    LONG     cLeft;
    LONG     iLeft;
    LONG     cnt;
    LONG     i;
    LONG     j;

    DONTUSE(pjMask);
    DONTUSE(xMask);

    cLeft = xLeft >> 5;             // Index of leftmost DWORD
    iLeft = xLeft & 31;             // Bits used in leftmost DWORD
    pulSrc = ((DWORD *) pjSrc) + cLeft;     // Adjust base address

// To prevent derefences of the XLATE, do it upfront.  We can easily do
// this on monochrome bitmaps.

    if (pxlo == NULL)
    {
    iBlack = 0;
    iWhite = 1;
    }
    else
    {
    iBlack = pxlo->pulXlate[0];
    iWhite = pxlo->pulXlate[1];
    }

    i = 0;
    j = 0;
    pxrl->xPos = pdda->rcl.left;
    pxrl->cRun = pdda->rcl.right - pxrl->xPos;
    ulSrc = *pulSrc;

    if (xLeft < xRght)
    {
        while (TRUE)
        {
            if (!(ulSrc & gaulMaskMono[iLeft]))
            {
                cnt = pdda->al[i++];

                if (!cnt)
                    pxrl->aul[j] &= iBlack;
                else
                    while (cnt--)
                        pxrl->aul[j++] &= iBlack;
            }
            else
            {
                cnt = pdda->al[i++];

                if (!cnt)
                    pxrl->aul[j] &= iWhite;
                else
                    while (cnt--)
                        pxrl->aul[j++] &= iWhite;
            }

            xLeft++;
            iLeft++;

            if (xLeft >= xRght)
                break;

            if (iLeft & 32)
            {
                pulSrc++;
                ulSrc = *pulSrc;
                iLeft = 0;
            }
        }
    }

    return((XRUNLEN *) &pxrl->aul[j]);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead04AND(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, xlate colors, AND the pels and produce a run
* list for a row of a 4BPP surface.
*
* History:
*  13-Apr-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead04AND(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    ULONG   *pulSrc;
    ULONG    ulSrc;
    ULONG    iColor;
    LONG     cLeft;
    LONG     iLeft;
    LONG     cnt;
    LONG     i;
    LONG     j;

    DONTUSE(pjMask);
    DONTUSE(xMask);

    cLeft  =  xLeft >> 3;                   // Index of leftmost DWORD
    iLeft  =  xLeft & 7;                    // Nybbles used in leftmost DWORD
    pulSrc =  ((DWORD *) pjSrc) + cLeft;    // Adjust base address
    ulSrc  = *pulSrc;

    i = 0;
    j = 0;
    pxrl->xPos = pdda->rcl.left;
    pxrl->cRun = pdda->rcl.right - pxrl->xPos;

    if (pxlo == NULL)
    {
        if (xLeft < xRght)
        {
            while (TRUE)
            {
                iColor = (ulSrc & gaulMaskQuad[iLeft]) >> gaulShftQuad[iLeft];

                cnt = pdda->al[i++];

                if (!cnt)
                    pxrl->aul[j] &= iColor;
                else
                    while (cnt--)
                        pxrl->aul[j++] &= iColor;

                xLeft++;
                iLeft++;

                if (xLeft >= xRght)
                    break;

                if (iLeft & 8)
                {
                    pulSrc++;
                    ulSrc = *pulSrc;
                    iLeft = 0;
                }
            }
        }
    }
    else
    {
        if (xLeft < xRght)
        {
            while (TRUE)
            {
                iColor = pxlo->pulXlate[(ulSrc & gaulMaskQuad[iLeft]) >> gaulShftQuad[iLeft]];

                cnt = pdda->al[i++];

                if (!cnt)
                    pxrl->aul[j] &= iColor;
                else
                    while (cnt--)
                        pxrl->aul[j++] &= iColor;

                xLeft++;
                iLeft++;

                if (xLeft >= xRght)
                    break;

                if (iLeft & 8)
                {
                    pulSrc++;
                    ulSrc = *pulSrc;
                    iLeft = 0;
                }
        }
    }
    }

    return((XRUNLEN *) &pxrl->aul[j]);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead08AND(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, xlate colors, AND the pels and produce a run
* list for a row of a 8BPP surface.
*
* History:
*  13-Apr-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead08AND(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    LONG     cnt;
    LONG     i;
    LONG     j;

    DONTUSE(pjMask);
    DONTUSE(xMask);

    pjSrc += xLeft;

    pxrl->xPos = pdda->rcl.left;
    pxrl->cRun = pdda->rcl.right - pdda->rcl.left;
    i = 0;
    j = 0;

    if (pxlo == NULL)
        while (xLeft != xRght)
        {
        cnt = pdda->al[i++];

        if (!cnt)
        pxrl->aul[j] &= *pjSrc;
        else
        while (cnt--)
            pxrl->aul[j++] &= *pjSrc;

            pjSrc++;
            xLeft++;
        }
    else
        while (xLeft != xRght)
    {
        cnt = pdda->al[i++];

        if (!cnt)
        pxrl->aul[j] &= pxlo->pulXlate[*pjSrc];
        else
        while (cnt--)
            pxrl->aul[j++] &= pxlo->pulXlate[*pjSrc];

            pjSrc++;
            xLeft++;
        }

    return((XRUNLEN *) &pxrl->aul[j]);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead16AND(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, xlate colors, AND the pels and produce a run
* list for a row of a 16BPP surface.
*
* History:
*  13-Apr-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead16AND(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    WORD    *pwSrc = (WORD *) pjSrc;
    ULONG    ulTmp;
    LONG     cnt;
    LONG     i;
    LONG     j;

    DONTUSE(pjMask);
    DONTUSE(xMask);

    pwSrc += xLeft;

    pxrl->xPos = pdda->rcl.left;
    pxrl->cRun = pdda->rcl.right - pdda->rcl.left;
    i = 0;
    j = 0;

    if (pxlo == NULL)
        while (xLeft != xRght)
        {
        cnt = pdda->al[i++];

        if (!cnt)
        pxrl->aul[j] &= *pwSrc;
        else
        while (cnt--)
            pxrl->aul[j++] &= *pwSrc;

        pwSrc++;
            xLeft++;
        }
    else
        while (xLeft != xRght)
        {
        cnt   = pdda->al[i++];
            ulTmp = ((XLATE *) pxlo)->ulTranslate((ULONG) *pwSrc);

        if (!cnt)
        pxrl->aul[j] &= ulTmp;
        else
        while (cnt--)
            pxrl->aul[j++] &= ulTmp;


            pwSrc++;
            xLeft++;
        }

    return((XRUNLEN *) &pxrl->aul[j]);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead24AND(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, xlate colors, AND the pels and produce a run
* list for a row of a 24BPP surface.
*
* History:
*  13-Apr-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead24AND(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN   *pxrl = &prun->xrl;
    RGBTRIPLE *prgbSrc = (RGBTRIPLE *) pjSrc;
    ULONG      ulTmp = 0;
    LONG       cnt;
    LONG       i;
    LONG       j;

    DONTUSE(pjMask);
    DONTUSE(xMask);

    prgbSrc += xLeft;

    pxrl->xPos = pdda->rcl.left;
    pxrl->cRun = pdda->rcl.right - pdda->rcl.left;
    i = 0;
    j = 0;

    if (pxlo == NULL)
        while (xLeft != xRght)
        {
            *((RGBTRIPLE *) &ulTmp) = *prgbSrc;

        cnt = pdda->al[i++];

        if (!cnt)
        pxrl->aul[j] &= ulTmp;
        else
        while (cnt--)
            pxrl->aul[j++] &= ulTmp;

            prgbSrc++;
            xLeft++;
        }
    else
        while (xLeft != xRght)
        {
        cnt = pdda->al[i++];

        *((RGBTRIPLE *) &ulTmp) = *prgbSrc;
            ulTmp = ((XLATE *) pxlo)->ulTranslate(ulTmp);

        if (!cnt)
        pxrl->aul[j] &= ulTmp;
        else
        while (cnt--)
            pxrl->aul[j++] &= ulTmp;

        prgbSrc++;
            xLeft++;
        }

    return((XRUNLEN *) &pxrl->aul[j]);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead32AND(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, xlate colors, AND the pels and produce a run
* list for a row of a 32BPP surface.
*
* History:
*  13-Apr-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead32AND(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    DWORD   *pdwSrc = (DWORD *) pjSrc;
    ULONG    ulTmp;
    LONG     cnt;
    LONG     i;
    LONG     j;

    DONTUSE(pjMask);
    DONTUSE(xMask);

    pdwSrc += xLeft;

    pxrl->xPos = pdda->rcl.left;
    pxrl->cRun = pdda->rcl.right - pdda->rcl.left;
    i = 0;
    j = 0;

    if (pxlo == NULL)
        while (xLeft != xRght)
        {
        cnt = pdda->al[i++];

        if (!cnt)
        pxrl->aul[j] &= *pdwSrc;
        else
        while (cnt--)
            pxrl->aul[j++] &= *pdwSrc;

            pdwSrc++;
            xLeft++;
        }
    else
        while (xLeft != xRght)
        {
            cnt = pdda->al[i++];
            ulTmp = ((XLATE *) pxlo)->ulTranslate((ULONG) *pdwSrc);

        if (!cnt)
        pxrl->aul[j] &= ulTmp;
        else
        while (cnt--)
            pxrl->aul[j++] &= ulTmp;

        pdwSrc++;
            xLeft++;
        }

    return((XRUNLEN *) &pxrl->aul[j]);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead01OR(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, xlate colors, OR the pels and produce a run
* list for a row of a 1BPP surface.
*
* History:
*  27-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead01OR(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    ULONG   *pulSrc;
    ULONG    ulSrc;
    ULONG    iBlack;
    ULONG    iWhite;
    LONG     cLeft;
    LONG     iLeft;
    LONG     cnt;
    LONG     i;
    LONG     j;

    DONTUSE(pjMask);
    DONTUSE(xMask);

    cLeft = xLeft >> 5;             // Index of leftmost DWORD
    iLeft = xLeft & 31;             // Bits used in leftmost DWORD
    pulSrc = ((DWORD *) pjSrc) + cLeft;     // Adjust base address

// To prevent derefences of the XLATE, do it upfront.  We can easily do
// this on monochrome bitmaps.

    if (pxlo ==  NULL)
    {
    iBlack = 0;
    iWhite = 1;
    }
    else
    {
    iBlack = pxlo->pulXlate[0];
    iWhite = pxlo->pulXlate[1];
    }

    i = 0;
    j = 0;
    pxrl->xPos = pdda->rcl.left;
    pxrl->cRun = pdda->rcl.right - pxrl->xPos;
    ulSrc = *pulSrc;

    if (xLeft < xRght)
    {
        while (TRUE)
        {
            if (!(ulSrc & gaulMaskMono[iLeft]))
            {
                cnt = pdda->al[i++];

                if (!cnt)
                    pxrl->aul[j] |= iBlack;
                else
                    while (cnt--)
                        pxrl->aul[j++] |= iBlack;
            }
            else
            {
                cnt = pdda->al[i++];

                if (!cnt)
                    pxrl->aul[j] |= iWhite;
                else
                    while (cnt--)
                        pxrl->aul[j++] |= iWhite;
            }

            xLeft++;
            iLeft++;

            if (xLeft >= xRght)
                break;

            if (iLeft & 32)
            {
                pulSrc++;
                ulSrc = *pulSrc;
                iLeft = 0;
            }
        }
    }

    return((XRUNLEN *) &pxrl->aul[j]);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead04OR(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, xlate colors, OR the pels and produce a run
* list for a row of a 4BPP surface.
*
* History:
*  13-Apr-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead04OR(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    ULONG   *pulSrc;
    ULONG    ulSrc;
    ULONG    iColor;
    LONG     cLeft;
    LONG     iLeft;
    LONG     cnt;
    LONG     i;
    LONG     j;

    DONTUSE(pjMask);
    DONTUSE(xMask);

    cLeft  =  xLeft >> 3;                   // Index of leftmost DWORD
    iLeft  =  xLeft & 7;                    // Nybbles used in leftmost DWORD
    pulSrc =  ((DWORD *) pjSrc) + cLeft;    // Adjust base address
    ulSrc  = *pulSrc;

    i = 0;
    j = 0;
    pxrl->xPos = pdda->rcl.left;
    pxrl->cRun = pdda->rcl.right - pxrl->xPos;

    if (pxlo == NULL)
    {
        if (xLeft < xRght)
        {
            while (TRUE)
            {
                iColor = (ulSrc & gaulMaskQuad[iLeft]) >> gaulShftQuad[iLeft];

                cnt = pdda->al[i++];

                if (!cnt)
                    pxrl->aul[j] |= iColor;
                else
                    while (cnt--)
                        pxrl->aul[j++] |= iColor;

                xLeft++;
                iLeft++;

                if (xLeft >= xRght)
                    break;

                if (iLeft & 8)
                {
                    pulSrc++;
                    ulSrc = *pulSrc;
                    iLeft = 0;
                }
            }
        }
    }
    else
    {
        if (xLeft < xRght)
        {
            while (TRUE)
            {
                iColor = pxlo->pulXlate[(ulSrc & gaulMaskQuad[iLeft]) >> gaulShftQuad[iLeft]];

                cnt = pdda->al[i++];

                if (!cnt)
                    pxrl->aul[j] |= iColor;
                else
                    while (cnt--)
                        pxrl->aul[j++] |= iColor;

                xLeft++;
                iLeft++;

                if (xLeft >= xRght)
                    break;

                if (iLeft & 8)
                {
                    pulSrc++;
                    ulSrc = *pulSrc;
                    iLeft = 0;
                }
            }
        }
    }

    return((XRUNLEN *) &pxrl->aul[j]);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead08OR(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, xlate colors, OR the pels and produce a run
* list for a row of a 8BPP surface.
*
* History:
*  13-Apr-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead08OR(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    LONG     cnt;
    LONG     i;
    LONG     j;

    DONTUSE(pjMask);
    DONTUSE(xMask);

    pjSrc += xLeft;

    pxrl->xPos = pdda->rcl.left;
    pxrl->cRun = pdda->rcl.right - pdda->rcl.left;
    i = 0;
    j = 0;

    if (pxlo == NULL)
        while (xLeft != xRght)
        {
        cnt = pdda->al[i++];

        if (!cnt)
        pxrl->aul[j] |= *pjSrc;
        else
        while (cnt--)
            pxrl->aul[j++] |= *pjSrc;

            pjSrc++;
            xLeft++;
        }
    else
        while (xLeft != xRght)
    {
        cnt = pdda->al[i++];

        if (!cnt)
        pxrl->aul[j] |= pxlo->pulXlate[*pjSrc];
        else
        while (cnt--)
            pxrl->aul[j++] |= pxlo->pulXlate[*pjSrc];

            pjSrc++;
            xLeft++;
        }

    return((XRUNLEN *) &pxrl->aul[j]);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead16OR(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, xlate colors, OR the pels and produce a run
* list for a row of a 16BPP surface.
*
* History:
*  13-Apr-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead16OR(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    WORD    *pwSrc = (WORD *) pjSrc;
    ULONG    ulTmp;
    LONG     cnt;
    LONG     i;
    LONG     j;

    DONTUSE(pjMask);
    DONTUSE(xMask);

    pwSrc += xLeft;

    pxrl->xPos = pdda->rcl.left;
    pxrl->cRun = pdda->rcl.right - pdda->rcl.left;
    i = 0;
    j = 0;

    if (pxlo == NULL)
        while (xLeft != xRght)
        {
        cnt = pdda->al[i++];

        if (!cnt)
        pxrl->aul[j] |= *pwSrc;
        else
        while (cnt--)
            pxrl->aul[j++] |= *pwSrc;

        pwSrc++;
            xLeft++;
        }
    else
        while (xLeft != xRght)
        {
        cnt   = pdda->al[i++];
            ulTmp = ((XLATE *) pxlo)->ulTranslate((ULONG) *pwSrc);

        if (!cnt)
        pxrl->aul[j] |= ulTmp;
        else
        while (cnt--)
            pxrl->aul[j++] |= ulTmp;


            pwSrc++;
            xLeft++;
        }

    return((XRUNLEN *) &pxrl->aul[j]);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead24OR(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, xlate colors, OR the pels and produce a run
* list for a row of a 24BPP surface.
*
* History:
*  13-Apr-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead24OR(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN   *pxrl = &prun->xrl;
    RGBTRIPLE *prgbSrc = (RGBTRIPLE *) pjSrc;
    ULONG      ulTmp = 0;
    LONG       cnt;
    LONG       i;
    LONG       j;

    DONTUSE(pjMask);
    DONTUSE(xMask);

    prgbSrc += xLeft;

    pxrl->xPos = pdda->rcl.left;
    pxrl->cRun = pdda->rcl.right - pdda->rcl.left;
    i = 0;
    j = 0;

    if (pxlo ==  NULL)
        while (xLeft != xRght)
        {
            *((RGBTRIPLE *) &ulTmp) = *prgbSrc;

        cnt = pdda->al[i++];

        if (!cnt)
        pxrl->aul[j] |= ulTmp;
        else
        while (cnt--)
            pxrl->aul[j++] |= ulTmp;

            prgbSrc++;
            xLeft++;
        }
    else
        while (xLeft != xRght)
        {
        cnt = pdda->al[i++];

        *((RGBTRIPLE *) &ulTmp) = *prgbSrc;
            ulTmp = ((XLATE *) pxlo)->ulTranslate(ulTmp);

        if (!cnt)
        pxrl->aul[j] |= ulTmp;
        else
        while (cnt--)
            pxrl->aul[j++] |= ulTmp;

        prgbSrc++;
            xLeft++;
        }

    return((XRUNLEN *) &pxrl->aul[j]);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead32OR(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, xlate colors, OR the pels and produce a run
* list for a row of a 32BPP surface.
*
* History:
*  13-Apr-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead32OR(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    DWORD   *pdwSrc = (DWORD *) pjSrc;
    ULONG    ulTmp;
    LONG     cnt;
    LONG     i;
    LONG     j;

    DONTUSE(pjMask);
    DONTUSE(xMask);

    pdwSrc += xLeft;

    pxrl->xPos = pdda->rcl.left;
    pxrl->cRun = pdda->rcl.right - pdda->rcl.left;
    i = 0;
    j = 0;

    if (pxlo == NULL)
        while (xLeft != xRght)
        {
        cnt = pdda->al[i++];

        if (!cnt)
        pxrl->aul[j] |= *pdwSrc;
        else
        while (cnt--)
            pxrl->aul[j++] |= *pdwSrc;

            pdwSrc++;
            xLeft++;
        }
    else
        while (xLeft != xRght)
        {
            cnt = pdda->al[i++];
            ulTmp = ((XLATE *) pxlo)->ulTranslate((ULONG) *pdwSrc);

        if (!cnt)
        pxrl->aul[j] |= ulTmp;
        else
        while (cnt--)
            pxrl->aul[j++] |= ulTmp;

        pdwSrc++;
            xLeft++;
        }

    return((XRUNLEN *) &pxrl->aul[j]);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead01(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, mask it, xlate colors and produce a run list
* for a row of a 1BPP surface.
*
* History:
*  16-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead01(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    ULONG   *pulMsk;
    ULONG   *pulSrc;
    ULONG    ulMsk;
    ULONG    ulSrc;
    ULONG    iBlack;
    ULONG    iWhite;
    LONG     xPos;
    LONG     cLeft;
    LONG     iLeft;
    LONG     iMask;
    LONG     cnt;
    LONG     i;
    LONG     j;

    cLeft  =  xLeft >> 5;                   // Index of leftmost DWORD
    iLeft  =  xLeft & 31;                   // Bits used in leftmost DWORD
    pulSrc =  ((DWORD *) pjSrc) + cLeft;    // Adjust base address
    ulSrc  = *pulSrc;

// To prevent derefences of the XLATE, do it upfront.  We can easily do
// this on monochrome bitmaps.

    if (pxlo == NULL)
    {
    iBlack = 0;
    iWhite = 1;
    }
    else
    {
    iBlack = pxlo->pulXlate[0];
    iWhite = pxlo->pulXlate[1];
    }

    if (pjMask == (BYTE *) NULL)
    {
    i = 0;
    j = 0;
        pxrl->xPos = pdda->rcl.left;
        pxrl->cRun = pdda->rcl.right - pxrl->xPos;

        if (xLeft < xRght)
        {
            while (TRUE)
            {
                if (ulSrc & gaulMaskMono[iLeft])
                    for (cnt = pdda->al[i++]; cnt; cnt--)
                        prun->xrl.aul[j++] = iWhite;
                else
                    for (cnt = pdda->al[i++]; cnt; cnt--)
                        prun->xrl.aul[j++] = iBlack;

                xLeft++;
                iLeft++;

                if (xLeft >= xRght)
                    break;

                if (iLeft & 32)
                {
                    pulSrc++;
                    ulSrc = *pulSrc;
                    iLeft = 0;
                }
            }
        }

        return((XRUNLEN *) &pxrl->aul[j]);
    }

// Compute initial state of mask

    pulMsk =  ((DWORD *) pjMask) + (xMask >> 5);
    iMask  =  xMask & 31;
    xPos   =  pdda->rcl.left;
    ulMsk  = *pulMsk;
    i = 0;
    j = 0;

    if (xLeft < xRght)
    {
        while (TRUE)
        {
            if (ulMsk & gaulMaskMono[iMask])
            {
                if (ulSrc & gaulMaskMono[iLeft])
                    for (cnt = pdda->al[i]; cnt; cnt--)
                        pxrl->aul[j++] = iWhite;
                else
                    for (cnt = pdda->al[i]; cnt; cnt--)
                        pxrl->aul[j++] = iBlack;
            }
            else
            {
                if (j > 0)
                {
                    pxrl->xPos = xPos;
                    pxrl->cRun = j;
                    pxrl = (XRUNLEN *) &pxrl->aul[j];
                    xPos += j;
                    j = 0;
                }

                xPos += pdda->al[i];
            }

            xLeft++;
            iLeft++;
            iMask++;
            i++;

            if (xLeft >= xRght)
                break;

            if (iLeft & 32)
            {
                pulSrc++;
                ulSrc = *pulSrc;
                iLeft = 0;
            }

            if (iMask & 32)
            {
                pulMsk++;
                ulMsk = *pulMsk;
                iMask = 0;
            }
        }
    }

    if (j > 0)
    {
        pxrl->xPos = xPos;
        pxrl->cRun = j;
        pxrl = (XRUNLEN *) &pxrl->aul[j];
    }

    return(pxrl);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead04(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, mask it, xlate colors and produce a run list
* for a row of a 4BPP surface.
*
* History:
*  16-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead04(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    ULONG   *pulMsk;
    ULONG   *pulSrc;
    ULONG    ulMsk;
    ULONG    ulSrc;
    ULONG    iColor;
    LONG     xPos;
    LONG     cLeft;
    LONG     iLeft;
    LONG     iMask;
    LONG     cnt;
    LONG     i;
    LONG     j;

    cLeft  =  xLeft >> 3;                   // Index of leftmost DWORD
    iLeft  =  xLeft & 7;                    // Nybbles used in leftmost DWORD
    pulSrc =  ((DWORD *) pjSrc) + cLeft;    // Adjust base address
    ulSrc  = *pulSrc;

    if (pjMask == (BYTE *) NULL)
    {
    i = 0;
    j = 0;
        pxrl->xPos = pdda->rcl.left;
        pxrl->cRun = pdda->rcl.right - pxrl->xPos;

        if (pxlo == NULL)
    {
            if (xLeft < xRght)
            {
                while (TRUE)
                {
                    iColor = (ulSrc & gaulMaskQuad[iLeft]) >> gaulShftQuad[iLeft];
                    for (cnt = pdda->al[i++]; cnt; cnt--)
                        pxrl->aul[j++] = iColor;

                    xLeft++;
                    iLeft++;

                    if (xLeft >= xRght)
                        break;

                    if (iLeft & 8)
                    {
                        pulSrc++;
                        ulSrc = *pulSrc;
                        iLeft = 0;
                    }
                }
            }
    }
    else
    {
            if (xLeft < xRght)
            {
                while (TRUE)
                {
                    iColor = pxlo->pulXlate[(ulSrc & gaulMaskQuad[iLeft]) >> gaulShftQuad[iLeft]];
                    for (cnt = pdda->al[i++]; cnt; cnt--)
                        pxrl->aul[j++] = iColor;

                    xLeft++;
                    iLeft++;

                    if (xLeft >= xRght)
                        break;

                    if (iLeft & 8)
                    {
                        pulSrc++;
                        ulSrc = *pulSrc;
                        iLeft = 0;
                    }
                }
        }
    }

        return((XRUNLEN *) &pxrl->aul[j]);
    }

// Compute initial state of mask

    pulMsk =  ((DWORD *) pjMask) + (xMask >> 5);
    iMask  =  xMask & 31;
    xPos   =  pdda->rcl.left;
    ulMsk  = *pulMsk;
    i = 0;
    j = 0;

    if (xLeft < xRght)
    {
        while (TRUE)
        {
            iColor = (ulSrc & gaulMaskQuad[iLeft]) >> gaulShftQuad[iLeft];
            if (pxlo != NULL)
                iColor = pxlo->pulXlate[iColor];

            if (ulMsk & gaulMaskMono[iMask])
            {
                for (cnt = pdda->al[i]; cnt; cnt--)
                    pxrl->aul[j++] = iColor;
            }
            else
            {
                if (j > 0)
                {
                    pxrl->xPos = xPos;
                    pxrl->cRun = j;
                    pxrl = (XRUNLEN *) &pxrl->aul[j];
                    xPos += j;
                    j = 0;
                }

                xPos += pdda->al[i];
            }

            xLeft++;
            iLeft++;
            iMask++;
            i++;

            if (xLeft >= xRght)
                break;

            if (iLeft & 8)
            {
                pulSrc++;
                ulSrc = *pulSrc;
                iLeft = 0;
            }

            if (iMask & 32)
            {
                pulMsk++;
                ulMsk = *pulMsk;
                iMask = 0;
            }
        }
    }

    if (j > 0)
    {
        pxrl->xPos = xPos;
        pxrl->cRun = j;
        pxrl = (XRUNLEN *) &pxrl->aul[j];
    }

    return(pxrl);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead08(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, mask it, xlate colors and produce a run list
* for a row of a 8BPP surface.
*
* History:
*  16-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead08(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    ULONG   *pulMsk;
    ULONG    ulMsk;
    ULONG    iColor;
    LONG     xPos;
    LONG     iMask;
    LONG     cnt;
    LONG     i;
    LONG     j;

    pjSrc += xLeft;

    if (pjMask == (BYTE *) NULL)
    {
        pxrl->xPos = pdda->rcl.left;
        pxrl->cRun = pdda->rcl.right - pdda->rcl.left;
        i = 0;
        j = 0;

        if (pxlo == NULL)
            while (xLeft != xRght)
            {
                for (cnt = pdda->al[i++]; cnt; cnt--)
                    pxrl->aul[j++] = *pjSrc;

                pjSrc++;
                xLeft++;
            }
        else
            while (xLeft != xRght)
            {
                for (cnt = pdda->al[i++]; cnt; cnt--)
                    pxrl->aul[j++] = pxlo->pulXlate[*pjSrc];
                pjSrc++;
                xLeft++;
            }

        return((XRUNLEN *) &pxrl->aul[j]);
    }

// Compute initial state of mask

    pulMsk =  ((DWORD *) pjMask) + (xMask >> 5);
    iMask  =  xMask & 31;
    xPos   =  pdda->rcl.left;
    ulMsk  = *pulMsk;
    i = 0;
    j = 0;


    if (xLeft < xRght)
    {
        while(TRUE) 
        {
            iColor = (DWORD) *pjSrc++;
            if (pxlo != NULL)
                iColor = pxlo->pulXlate[iColor];
    
            if (ulMsk & gaulMaskMono[iMask])
            {
                for (cnt = pdda->al[i]; cnt; cnt--)
                    pxrl->aul[j++] = iColor;
            }
            else
            {
                if (j > 0)
                {
                    pxrl->xPos = xPos;
                    pxrl->cRun = j;
                    pxrl = (XRUNLEN *) &pxrl->aul[j];
                    xPos += j;
                    j = 0;
                }
    
                xPos += pdda->al[i];
            }
    
            xLeft++;
            iMask++;
            i++;
            
            if(xLeft >= xRght) 
              break;
    
            if (iMask & 32)
            {
                pulMsk++;
                ulMsk = *pulMsk;
                iMask = 0;
            }
        }
    }

    if (j > 0)
    {
        pxrl->xPos = xPos;
        pxrl->cRun = j;
        pxrl = (XRUNLEN *) &pxrl->aul[j];
    }

    return(pxrl);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead16(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, mask it, xlate colors and produce a run list
* for a row of a 16BPP surface.
*
* History:
*  16-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead16(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    WORD    *pwSrc = (WORD *) pjSrc;
    ULONG   *pulMsk;
    ULONG    ulMsk;
    ULONG    ulTmp;
    ULONG    iColor;
    LONG     xPos;
    LONG     iMask;
    LONG     cnt;
    LONG     i;
    LONG     j;

    pwSrc += xLeft;

    if (pjMask == (BYTE *) NULL)
    {
        pxrl->xPos = pdda->rcl.left;
        pxrl->cRun = pdda->rcl.right - pdda->rcl.left;
        i = 0;
        j = 0;

        if (pxlo == NULL)
            while (xLeft != xRght)
            {
                for (cnt = pdda->al[i++]; cnt; cnt--)
                    pxrl->aul[j++] = *pwSrc;

                pwSrc++;
                xLeft++;
            }
        else
            while (xLeft != xRght)
            {
                cnt = pdda->al[i++];

                if (cnt)
                {
                    ulTmp = ((XLATE *) pxlo)->ulTranslate((ULONG) *pwSrc);

                    while (cnt--)
                        pxrl->aul[j++] = ulTmp;
                }

                pwSrc++;
                xLeft++;
            }

        return((XRUNLEN *) &pxrl->aul[j]);
    }

// Compute initial state of mask

    pulMsk =  ((DWORD *) pjMask) + (xMask >> 5);
    iMask  =  xMask & 31;
    xPos   =  pdda->rcl.left;
    ulMsk  = *pulMsk;
    i = 0;
    j = 0;

    if (xLeft < xRght)
    {
        while(TRUE)
        {
            iColor = (DWORD) *pwSrc++;
            if (pxlo != NULL)
                iColor = ((XLATE *) pxlo)->ulTranslate(iColor);
    
            if (ulMsk & gaulMaskMono[iMask])
            {
                for (cnt = pdda->al[i]; cnt; cnt--)
                    pxrl->aul[j++] = iColor;
            }
            else
            {
                if (j > 0)
                {
                    pxrl->xPos = xPos;
                    pxrl->cRun = j;
                    pxrl = (XRUNLEN *) &pxrl->aul[j];
                    xPos += j;
                    j = 0;
                }
    
                xPos += pdda->al[i];
            }
    
            xLeft++;
            iMask++;
            i++;
    
            if (xLeft >= xRght) 
              break;
    
            if (iMask & 32)
            {
                pulMsk++;
                ulMsk = *pulMsk;
                iMask = 0;
            }
        }
    }

    if (j > 0)
    {
        pxrl->xPos = xPos;
        pxrl->cRun = j;
        pxrl = (XRUNLEN *) &pxrl->aul[j];
    }

    return(pxrl);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead24(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, mask it, xlate colors and produce a run list
* for a row of a 24BPP surface.
*
* History:
*  16-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead24(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN   *pxrl = &prun->xrl;
    RGBTRIPLE *prgbSrc = (RGBTRIPLE *) pjSrc;
    ULONG     *pulMsk;
    ULONG      ulTmp = 0;
    ULONG      ulMsk;
    ULONG      iColor = 0;
    LONG       iMask;
    LONG       xPos;
    LONG       cnt;
    LONG       i;
    LONG       j;

    prgbSrc += xLeft;

    if (pjMask == (BYTE *) NULL)
    {
        pxrl->xPos = pdda->rcl.left;
        pxrl->cRun = pdda->rcl.right - pdda->rcl.left;
        i = 0;
        j = 0;

        if (pxlo == NULL)
            while (xLeft != xRght)
            {
                *((RGBTRIPLE *) &ulTmp) = *prgbSrc;

                for (cnt = pdda->al[i++]; cnt; cnt--)
                    pxrl->aul[j++] = ulTmp;

                prgbSrc++;
                xLeft++;
            }
        else
            while (xLeft != xRght)
            {
                cnt = pdda->al[i++];

                if (cnt)
                {
                    *((RGBTRIPLE *) &ulTmp) = *prgbSrc;
                    ulTmp = ((XLATE *) pxlo)->ulTranslate(ulTmp);

                    while (cnt--)
                        pxrl->aul[j++] = ulTmp;
                }

                prgbSrc++;
                xLeft++;
            }

        return((XRUNLEN *) &pxrl->aul[j]);
    }

// Compute initial state of mask

    pulMsk =  ((DWORD *) pjMask) + (xMask >> 5);
    iMask  =  xMask & 31;
    xPos   =  pdda->rcl.left;
    ulMsk  = *pulMsk;
    i = 0;
    j = 0;

    if (xLeft < xRght)
    {
        while (TRUE) 
        {
            *((RGBTRIPLE *) &iColor) = *prgbSrc++;
            if (pxlo != NULL)
                iColor = ((XLATE *) pxlo)->ulTranslate(iColor);
    
            if (ulMsk & gaulMaskMono[iMask])
            {
                for (cnt = pdda->al[i]; cnt; cnt--)
                    pxrl->aul[j++] = iColor;
            }
            else
            {
                if (j > 0)
                {
                    pxrl->xPos = xPos;
                    pxrl->cRun = j;
                    pxrl = (XRUNLEN *) &pxrl->aul[j];
                    xPos += j;
                    j = 0;
                }
    
                xPos += pdda->al[i];
            }
    
            xLeft++;
            iMask++;
            i++;
    
            if (xLeft >= xRght) 
              break;
    
            if (iMask & 32)
            {
                pulMsk++;
                ulMsk = *pulMsk;
                iMask = 0;
            }
        }
    }

    if (j > 0)
    {
        pxrl->xPos = xPos;
        pxrl->cRun = j;
        pxrl = (XRUNLEN *) &pxrl->aul[j];
    }

    return(pxrl);
}

/******************************Public*Routine******************************\
* XRUNLEN *pxrlStrRead32(prun, pjSrc, pjMask, pxlo, xLeft, xRght, xMask)
*
* Read the source, mask it, xlate colors and produce a run list
* for a row of a 32BPP surface.
*
* History:
*  16-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

XRUNLEN *pxrlStrRead32(
STRDDA   *pdda,
STRRUN   *prun,
BYTE     *pjSrc,
BYTE     *pjMask,
XLATEOBJ *pxlo,
LONG      xLeft,
LONG      xRght,
LONG      xMask)
{
    XRUNLEN *pxrl = &prun->xrl;
    DWORD   *pdwSrc = (DWORD *) pjSrc;
    ULONG   *pulMsk;
    ULONG    ulTmp;
    ULONG    ulMsk;
    ULONG    iColor;
    LONG     xPos;
    LONG     iMask;
    LONG     cnt;
    LONG     i;
    LONG     j;

    pdwSrc += xLeft;

    if (pjMask == (BYTE *) NULL)
    {
        pxrl->xPos = pdda->rcl.left;
        pxrl->cRun = pdda->rcl.right - pdda->rcl.left;
        i = 0;
        j = 0;

        if (pxlo == NULL)
            while (xLeft != xRght)
            {
                for (cnt = pdda->al[i++]; cnt; cnt--)
                    pxrl->aul[j++] = *pdwSrc;

                pdwSrc++;
                xLeft++;
            }
        else
            while (xLeft != xRght)
            {
                cnt = pdda->al[i++];

                if (cnt)
                {
                    ulTmp = ((XLATE *) pxlo)->ulTranslate((ULONG) *pdwSrc);

                    while (cnt--)
                        pxrl->aul[j++] = ulTmp;
                }

                pdwSrc++;
                xLeft++;
            }

        return((XRUNLEN *) &pxrl->aul[j]);
    }

// Compute initial state of mask

    pulMsk =  ((DWORD *) pjMask) + (xMask >> 5);
    iMask  =  xMask & 31;
    xPos   =  pdda->rcl.left;
    ulMsk  = *pulMsk;
    i = 0;
    j = 0;

    if (xLeft < xRght)
    {
        while (TRUE)
        {
            iColor = *pdwSrc++;
            if (pxlo != NULL)
                iColor = ((XLATE *) pxlo)->ulTranslate(iColor);
    
            if (ulMsk & gaulMaskMono[iMask])
            {
                for (cnt = pdda->al[i]; cnt; cnt--)
                    pxrl->aul[j++] = iColor;
            }
            else
            {
                if (j > 0)
                {
                    pxrl->xPos = xPos;
                    pxrl->cRun = j;
                    pxrl = (XRUNLEN *) &pxrl->aul[j];
                    xPos += j;
                    j = 0;
                }
    
                xPos += pdda->al[i];
            }
    
            xLeft++;
            iMask++;
            i++;
    
            if (xLeft >= xRght) 
              break;
    
            if (iMask & 32)
            {
                pulMsk++;
                ulMsk = *pulMsk;
                iMask = 0;
            }
        }
    }

    if (j > 0)
    {
        pxrl->xPos = xPos;
        pxrl->cRun = j;
        pxrl = (XRUNLEN *) &pxrl->aul[j];
    }

    return(pxrl);
}

/******************************Public*Routine******************************\
* VOID vStrWrite01(prun, prunEnd, pSurf, pco)
*
* Write the clipped run list of pels to the target 1BPP surface.
*
* History:
*  16-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vStrWrite01(
STRRUN  *prun,
XRUNLEN *pxrlEnd,
SURFACE *pSurf,
CLIPOBJ *pco)
{
    XRUNLEN *pxrl = &prun->xrl;
    DWORD   *pjBase;
    DWORD   *pjCurr;
    DWORD   *pjDraw;
    ULONG    ulTemp;
    ULONG    ulMask;
    LONG     xLeft;
    LONG     xRght;
    LONG     yCurr;
    LONG     cLeft;
    LONG     cRght;
    LONG     cByte;
    LONG     iMask;
    LONG     iLeft;
    LONG     iRght;
    LONG     iRep;
    LONG     jDraw;
    BOOL     bValid;

// There maybe no clipping.

    if (pco == (CLIPOBJ *) NULL)
    {
        pjBase = (DWORD *) ((BYTE *) pSurf->pvScan0() + pSurf->lDelta() * prun->yPos);
        jDraw = 0;

        while (pxrl != pxrlEnd)
        {
            xLeft = pxrl->xPos;
            xRght = pxrl->cRun + xLeft;

            pjDraw = pjCurr = pjBase + (xLeft >> 5);
         iMask = xLeft & 31;
            ulTemp = *pjDraw;

            if (xLeft < xRght)
            {
                while (TRUE)
                {
                    if (pxrl->aul[jDraw++])
                        ulTemp |=  gaulMaskMono[iMask];
                    else
                        ulTemp &= ~gaulMaskMono[iMask];

                    iMask++;
                    xLeft++;

                    if (xLeft >= xRght)
                        break;

                    if (iMask & 32)
                    {
                       *pjDraw = ulTemp;
                        pjDraw++;
                        ulTemp = *pjDraw;
                        iMask  = 0;
                    }
                }
            }

           *pjDraw = ulTemp;

            if (prun->cRep > 1)
            {
                iLeft = pxrl->xPos;
                iRght = pxrl->cRun + iLeft;
                cLeft = iLeft >> 5;
                cRght = iRght >> 5;
        iLeft &= 31;
                iRght &= 31;

                if (cLeft == cRght)
                {
                    ulMask = gaulMaskEdge[iLeft] & ~gaulMaskEdge[iRght];

                    for (iRep = 1; iRep < prun->cRep; iRep++)
                    {
                        pjDraw = (DWORD *) ((BYTE *) pjCurr + pSurf->lDelta());
                       *pjDraw = (*pjCurr & ulMask) | (*pjDraw & ~ulMask);
                        pjCurr = pjDraw;
                    }
                }
                else
                {
                    if (iLeft)
                    {
                        ulMask = ~gaulMaskEdge[iLeft];
                        ulTemp = *pjCurr & ~ulMask;

                        for (iRep = 1; iRep < prun->cRep; iRep++)
                        {
                            pjDraw = (DWORD *) ((BYTE *) pjCurr + pSurf->lDelta());
                           *pjDraw = ulTemp | (*pjDraw & ulMask);
                            pjCurr = pjDraw;
                        }

                        cLeft++;
                    }

                    if (cLeft != cRght)
                    {
                        pjCurr = pjBase + cLeft;
                        cByte = (cRght - cLeft) << 2;

                        for (iRep = 1; iRep < prun->cRep; iRep++)
                        {
                            pjDraw = (DWORD *) ((BYTE *) pjCurr + pSurf->lDelta());
                            RtlCopyMemory(pjDraw, pjCurr, cByte);
                            pjCurr = pjDraw;
                        }
                    }

                    if (iRght)
                    {
                        pjCurr = pjBase + cRght;
            ulMask = gaulMaskEdge[iRght];
                        ulTemp = *pjCurr & ~ulMask;

                        for (iRep = 1; iRep < prun->cRep; iRep++)
                        {
                            pjDraw = (DWORD *) ((BYTE *) pjCurr + pSurf->lDelta());
                           *pjDraw = ulTemp | (*pjDraw & ulMask);
                            pjCurr = pjDraw;
                        }
                    }
                }
            }

            pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
            jDraw = 0;
        }

        return;
    }

// Setup the clipping code.

    ((ECLIPOBJ *) pco)->cEnumStart(FALSE, CT_RECTANGLES, CD_ANY, 100);

    RECTL   rclClip;

    rclClip.left   = POS_INFINITY;
    rclClip.top    = POS_INFINITY;
    rclClip.right  = NEG_INFINITY;
    rclClip.bottom = NEG_INFINITY;

    yCurr = prun->yPos;
    iRep  = prun->cRep;
    ((ECLIPOBJ *) pco)->vFindScan(&rclClip, yCurr);
    pjBase = (DWORD *) ((BYTE *) pSurf->pvScan0() + pSurf->lDelta() * yCurr);

    while (iRep--)
    {
        if ((yCurr >= rclClip.top) && (yCurr < rclClip.bottom))
        {
            jDraw = 0;

            while (pxrl != pxrlEnd)
            {
                xLeft = pxrl->xPos;
                xRght = pxrl->cRun + xLeft;

                pjDraw = pjBase + (xLeft >> 5);
         iMask = xLeft & 31;

                bValid = ((xLeft >= 0) && (xLeft < pSurf->sizl().cx));
                ulTemp  = bValid ? *pjDraw : (ULONG) 0;

                while (xLeft < xRght)
                {
                    if ((xLeft < rclClip.left) || (xLeft >= rclClip.right))
                        ((ECLIPOBJ *) pco)->vFindSegment(&rclClip, xLeft, yCurr);

                    if ((xLeft >= rclClip.left) && (xLeft < rclClip.right))
                    {
                        if (pxrl->aul[jDraw])
                            ulTemp |=  gaulMaskMono[iMask];
                        else
                            ulTemp &= ~gaulMaskMono[iMask];
                    }

            iMask++;
                    xLeft++;
                    jDraw++;

            if (iMask & 32)
            {
            if (bValid)
                           *pjDraw = ulTemp;

            pjDraw++;
            iMask = 0;

                        bValid = ((xLeft >= 0) && (xLeft < pSurf->sizl().cx));
                        ulTemp = bValid ? *pjDraw : (ULONG) 0;
            }
                }

                if (bValid)
                   *pjDraw = ulTemp;

                pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
                jDraw = 0;
            }

            pxrl = &prun->xrl;
        }

        pjBase = (DWORD *) ((BYTE *) pjBase + pSurf->lDelta());
        yCurr++;

        if ((yCurr < rclClip.top) || (yCurr >= rclClip.bottom))
            ((ECLIPOBJ *) pco)->vFindScan(&rclClip, yCurr);
    }
}

/******************************Public*Routine******************************\
* VOID vStrWrite04(prun, prunEnd, pSurf, pco)
*
* Write the clipped run list of pels to the target 4BPP surface.
*
* History:
*  16-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vStrWrite04(
STRRUN  *prun,
XRUNLEN *pxrlEnd,
SURFACE *pSurf,
CLIPOBJ *pco)
{
    XRUNLEN *pxrl = &prun->xrl;
    DWORD   *pjBase;
    DWORD   *pjCurr;
    DWORD   *pjDraw;
    ULONG    ulTemp;
    ULONG    ulMask;
    ULONG    ulShft;
    LONG     xLeft;
    LONG     xRght;
    LONG     yCurr;
    LONG     cLeft;
    LONG     cRght;
    LONG     cByte;
    LONG     iMask;
    LONG     iLeft;
    LONG     iRght;
    LONG     iRep;
    LONG     jDraw;
    BOOL     bValid;

// There maybe no clipping.

    if (pco == (CLIPOBJ *) NULL)
    {
        pjBase = (DWORD *) ((BYTE *) pSurf->pvScan0() + pSurf->lDelta() * prun->yPos);
        jDraw = 0;

        while (pxrl != pxrlEnd)
        {
            xLeft = pxrl->xPos;
            xRght = pxrl->cRun + xLeft;

        pjDraw = pjCurr = pjBase + (xLeft >> 3);
            ulTemp = *pjDraw;
         iMask = xLeft & 7;

            if (xLeft < xRght)
            {
                while (TRUE)
                {
                    ulShft = gaulShftQuad[iMask];
                    ulMask = gaulMaskQuad[iMask];

                    ulTemp = (ULONG) ((ulTemp & ~ulMask) |
                                      ((pxrl->aul[jDraw++] << ulShft) & ulMask));

                    iMask++;
                    xLeft++;

                    if (xLeft >= xRght)
                        break;

                    if (iMask & 8)
                    {
                       *pjDraw = ulTemp;
                        pjDraw++;
                        ulTemp = *pjDraw;
                        iMask  = 0;
                    }
                }
            }

           *pjDraw = ulTemp;

            if (prun->cRep > 1)
            {
                iLeft = pxrl->xPos;
                iRght = pxrl->cRun + iLeft;
                cLeft = iLeft >> 3;
                cRght = iRght >> 3;
        iLeft = (iLeft & 7) << 2;
                iRght = (iRght & 7) << 2;

                if (cLeft == cRght)
                {
                    ulMask = gaulMaskEdge[iLeft] & ~gaulMaskEdge[iRght];

                    for (iRep = 1; iRep < prun->cRep; iRep++)
                    {
                        pjDraw = (DWORD *) ((BYTE *) pjCurr + pSurf->lDelta());
                       *pjDraw = (*pjCurr & ulMask) | (*pjDraw & ~ulMask);
                        pjCurr = pjDraw;
                    }
                }
                else
                {
                    if (iLeft)
                    {
                        ulMask = ~gaulMaskEdge[iLeft];
                        ulTemp = *pjCurr & ~ulMask;

                        for (iRep = 1; iRep < prun->cRep; iRep++)
                        {
                            pjDraw = (DWORD *) ((BYTE *) pjCurr + pSurf->lDelta());
                           *pjDraw = ulTemp | (*pjDraw & ulMask);
                            pjCurr = pjDraw;
                        }

                        cLeft++;
                    }

                    if (cLeft != cRght)
                    {
                        pjCurr = pjBase + cLeft;
                        cByte = (cRght - cLeft) << 2;

                        for (iRep = 1; iRep < prun->cRep; iRep++)
                        {
                            pjDraw = (DWORD *) ((BYTE *) pjCurr + pSurf->lDelta());
                            RtlCopyMemory(pjDraw, pjCurr, cByte);
                            pjCurr = pjDraw;
                        }
                    }

                    if (iRght)
                    {
                        pjCurr = pjBase + cRght;
            ulMask = gaulMaskEdge[iRght];
                        ulTemp = *pjCurr & ~ulMask;

                        for (iRep = 1; iRep < prun->cRep; iRep++)
                        {
                            pjDraw = (DWORD *) ((BYTE *) pjCurr + pSurf->lDelta());
                           *pjDraw = ulTemp | (*pjDraw & ulMask);
                            pjCurr = pjDraw;
                        }
                    }
                }
            }

            pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
            jDraw = 0;
        }

        return;
    }

// Setup the clipping code.

    ((ECLIPOBJ *) pco)->cEnumStart(FALSE, CT_RECTANGLES, CD_ANY, 100);

    RECTL   rclClip;

    rclClip.left   = POS_INFINITY;
    rclClip.top    = POS_INFINITY;
    rclClip.right  = NEG_INFINITY;
    rclClip.bottom = NEG_INFINITY;

    yCurr = prun->yPos;
    iRep  = prun->cRep;
    ((ECLIPOBJ *) pco)->vFindScan(&rclClip, yCurr);
    pjBase = (DWORD *) ((BYTE *) pSurf->pvScan0() + pSurf->lDelta() * yCurr);

    while (iRep--)
    {
        if ((yCurr >= rclClip.top) && (yCurr < rclClip.bottom))
        {
            jDraw = 0;

            while (pxrl != pxrlEnd)
            {
                xLeft = pxrl->xPos;
                xRght = pxrl->cRun + xLeft;

                pjDraw = pjBase + (xLeft >> 3);
         iMask = xLeft & 7;

                bValid = ((xLeft >= 0) && (xLeft < pSurf->sizl().cx));
                ulTemp  = bValid ? *pjDraw : (ULONG) 0;

                while (xLeft < xRght)
                {
                    if ((xLeft < rclClip.left) || (xLeft >= rclClip.right))
                        ((ECLIPOBJ *) pco)->vFindSegment(&rclClip, xLeft, yCurr);

                    if ((xLeft >= rclClip.left) && (xLeft < rclClip.right))
                    {
                        ulMask = gaulMaskQuad[iMask];
                        ulShft = gaulShftQuad[iMask];

                        ulTemp = (ULONG) ((ulTemp & ~ulMask) |
                                          ((pxrl->aul[jDraw] << ulShft) & ulMask));
                    }

            iMask++;
                    xLeft++;
                    jDraw++;

            if (iMask & 8)
            {
            if (bValid)
               *pjDraw = ulTemp;

            pjDraw++;
            iMask = 0;

                        bValid = ((xLeft >= 0) && (xLeft < pSurf->sizl().cx));
                        ulTemp = bValid ? *pjDraw : (ULONG) 0;
            }
                }

                if (bValid)
                   *pjDraw = ulTemp;

                pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
                jDraw = 0;
            }

            pxrl = &prun->xrl;
        }

        pjBase = (DWORD *) ((BYTE *) pjBase + pSurf->lDelta());
        yCurr++;

        if ((yCurr < rclClip.top) || (yCurr >= rclClip.bottom))
            ((ECLIPOBJ *) pco)->vFindScan(&rclClip, yCurr);
    }
}

/******************************Public*Routine******************************\
* VOID vStrWrite08(prun, prunEnd, pSurf, pco)
*
* Write the clipped run list of pels to the target 8BPP surface.
*
* History:
*  16-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vStrWrite08(
STRRUN  *prun,
XRUNLEN *pxrlEnd,
SURFACE *pSurf,
CLIPOBJ *pco)
{
    XRUNLEN *pxrl = &prun->xrl;
    BYTE    *pjBase;
    BYTE    *pjCurr;
    BYTE    *pjDraw;
    LONG     xLeft;
    LONG     xRght;
    LONG     yCurr;
    LONG     iTop;
    LONG     iBot;
    LONG     iRep;
    LONG     jLeft;
    LONG     jRght;
    LONG     jDraw;
    LONG     jByte;

// See if this can be handled without clipping.

    if (pco == (CLIPOBJ *) NULL)
    {
        pjBase = (BYTE *) pSurf->pvScan0() + pSurf->lDelta() * prun->yPos;

        while (pxrl != pxrlEnd)
        {
            xLeft = pxrl->xPos;
            xRght = pxrl->cRun + xLeft;
            jDraw = 0;

            pjDraw = pjCurr = pjBase + xLeft;

            while (xLeft < xRght)
            {
               *pjDraw++ = (BYTE) pxrl->aul[jDraw++];
                xLeft++;
            }

            for (jDraw = 1; jDraw < prun->cRep; jDraw++)
            {
                RtlCopyMemory(pjCurr + pSurf->lDelta(), pjCurr, pxrl->cRun);
                pjCurr += pSurf->lDelta();
            }

            pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
        }
        return;
    }

    RECTL   rclClip;

    if (pco->iDComplexity == DC_RECT)
    {
        rclClip = pco->rclBounds;

        iTop = prun->yPos;
        iBot = prun->yPos + prun->cRep;

        if ((iTop >= rclClip.bottom) || (iBot <= rclClip.top))
            return;

        iTop = iTop >= rclClip.top ? iTop : rclClip.top;
        iBot = iBot < rclClip.bottom ? iBot : rclClip.bottom;
        iRep = iBot - iTop;

        pjBase = (BYTE *) pSurf->pvScan0() + pSurf->lDelta() * iTop;

        while (pxrl != pxrlEnd)
        {
            xLeft = pxrl->xPos;
            xRght = pxrl->cRun + xLeft;

            if (xRght < rclClip.left)
            {
                pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
                continue;
            }

            if (xLeft >= rclClip.right)
                return;

            jLeft = xLeft >= rclClip.left ? xLeft : rclClip.left;
            jRght = xRght < rclClip.right ? xRght : rclClip.right;
            jByte = jRght - jLeft;

            pjDraw = pjCurr = pjBase + jLeft;
            jDraw  = jLeft - xLeft;

            while (jLeft < jRght)
            {
               *pjDraw++ = (BYTE) pxrl->aul[jDraw++];
                jLeft++;
            }

            for (jDraw = 1; jDraw < iRep; jDraw++)
            {
                RtlCopyMemory(pjCurr + pSurf->lDelta(), pjCurr, jByte);
                pjCurr += pSurf->lDelta();
            }

            pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
        }

        return;
    }

// There is complex clipping.  Set up the clipping code.

    ((ECLIPOBJ *) pco)->cEnumStart(FALSE, CT_RECTANGLES, CD_ANY, 100);

    rclClip.left   = POS_INFINITY;
    rclClip.top    = POS_INFINITY;
    rclClip.right  = NEG_INFINITY;
    rclClip.bottom = NEG_INFINITY;

    yCurr = prun->yPos;
    iRep  = prun->cRep;
    ((ECLIPOBJ *) pco)->vFindScan(&rclClip, yCurr);
    pjBase = (BYTE *) pSurf->pvScan0() + pSurf->lDelta() * yCurr;

    while (iRep--)
    {
        if ((yCurr >= rclClip.top) && (yCurr < rclClip.bottom))
        {
            jDraw = 0;

            while (pxrl != pxrlEnd)
            {
                xLeft = pxrl->xPos;
                xRght = pxrl->cRun + xLeft;

                pjDraw = pjCurr = pjBase + xLeft;

                while (xLeft < xRght)
                {
                    if ((xLeft < rclClip.left) || (xLeft >= rclClip.right))
                        ((ECLIPOBJ *) pco)->vFindSegment(&rclClip, xLeft, yCurr);

                    if ((xLeft >= rclClip.left) && (xLeft < rclClip.right))
                       *pjDraw = (BYTE) pxrl->aul[jDraw];

                    pjDraw++;
                    jDraw++;
                    xLeft++;
                }

                pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
                jDraw = 0;
            }

            pxrl = &prun->xrl;
        }

        pjBase += pSurf->lDelta();
        yCurr++;

        if ((yCurr < rclClip.top) || (yCurr >= rclClip.bottom))
            ((ECLIPOBJ *) pco)->vFindScan(&rclClip, yCurr);
    }
}

/******************************Public*Routine******************************\
* VOID vStrWrite16(prun, prunEnd, pSurf, pco)
*
* Write the clipped run list of pels to the target 16BPP surface.
*
* History:
*  16-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vStrWrite16(
STRRUN  *prun,
XRUNLEN *pxrlEnd,
SURFACE *pSurf,
CLIPOBJ *pco)
{
    XRUNLEN *pxrl = &prun->xrl;
    WORD    *pjBase;
    WORD    *pjCurr;
    WORD    *pjDraw;
    LONG     xLeft;
    LONG     xRght;
    LONG     yCurr;
    LONG     iTop;
    LONG     iBot;
    LONG     iRep;
    LONG     jLeft;
    LONG     jRght;
    LONG     jDraw;
    LONG     jByte;

// See if this can be handled without clipping.

    if (pco == (CLIPOBJ *) NULL)
    {
        pjBase = (WORD *) ((BYTE *) pSurf->pvScan0() + pSurf->lDelta() * prun->yPos);

        while (pxrl != pxrlEnd)
        {
            xLeft = pxrl->xPos;
            xRght = pxrl->cRun + xLeft;
            jDraw = 0;

            pjDraw = pjCurr = pjBase + xLeft;

            while (xLeft < xRght)
            {
               *pjDraw++ = (WORD) pxrl->aul[jDraw++];
                xLeft++;
            }

            for (jDraw = 1; jDraw < prun->cRep; jDraw++)
            {
                pjDraw = (WORD *) ((BYTE *) pjCurr + pSurf->lDelta());
                RtlCopyMemory(pjDraw, pjCurr, pxrl->cRun * 2);
                pjCurr = pjDraw;
            }

            pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
        }
        return;
    }

    RECTL   rclClip;

    if (pco->iDComplexity == DC_RECT)
    {
        rclClip = pco->rclBounds;

        iTop = prun->yPos;
        iBot = prun->yPos + prun->cRep;

        if ((iTop >= rclClip.bottom) || (iBot <= rclClip.top))
            return;

        iTop = iTop >= rclClip.top ? iTop : rclClip.top;
        iBot = iBot < rclClip.bottom ? iBot : rclClip.bottom;
        iRep = iBot - iTop;

        pjBase = (WORD *) ((BYTE *) pSurf->pvScan0() + pSurf->lDelta() * iTop);

        while (pxrl != pxrlEnd)
        {
            xLeft = pxrl->xPos;
            xRght = pxrl->cRun + xLeft;

            if (xRght < rclClip.left)
            {
                pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
                continue;
            }

            if (xLeft >= rclClip.right)
                return;

            jLeft = xLeft >= rclClip.left ? xLeft : rclClip.left;
            jRght = xRght < rclClip.right ? xRght : rclClip.right;
            jByte = jRght - jLeft;

            pjDraw = pjCurr = pjBase + jLeft;
            jDraw  = jLeft - xLeft;

            while (jLeft < jRght)
            {
               *pjDraw++ = (WORD) pxrl->aul[jDraw++];
                jLeft++;
            }

            for (jDraw = 1; jDraw < iRep; jDraw++)
            {
                pjDraw = (WORD *) ((BYTE *) pjCurr + pSurf->lDelta());
                RtlCopyMemory(pjDraw, pjCurr, jByte * 2);
                pjCurr = pjDraw;
            }

            pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
        }

        return;
    }

// There is complex clipping.  Set up the clipping code.

    ((ECLIPOBJ *) pco)->cEnumStart(FALSE, CT_RECTANGLES, CD_ANY, 100);

    rclClip.left   = POS_INFINITY;
    rclClip.top    = POS_INFINITY;
    rclClip.right  = NEG_INFINITY;
    rclClip.bottom = NEG_INFINITY;

    yCurr = prun->yPos;
    iRep  = prun->cRep;
    ((ECLIPOBJ *) pco)->vFindScan(&rclClip, yCurr);
    pjBase = (WORD *) ((BYTE *) pSurf->pvScan0() + pSurf->lDelta() * yCurr);

    while (iRep--)
    {
        if ((yCurr >= rclClip.top) && (yCurr < rclClip.bottom))
        {
            jDraw = 0;

            while (pxrl != pxrlEnd)
            {
                xLeft = pxrl->xPos;
                xRght = pxrl->cRun + xLeft;

                pjDraw = pjCurr = pjBase + xLeft;

                while (xLeft < xRght)
                {
                    if ((xLeft < rclClip.left) || (xLeft >= rclClip.right))
                        ((ECLIPOBJ *) pco)->vFindSegment(&rclClip, xLeft, yCurr);

                    if ((xLeft >= rclClip.left) && (xLeft < rclClip.right))
                       *pjDraw = (WORD) pxrl->aul[jDraw];

                    pjDraw++;
                    jDraw++;
                    xLeft++;
                }

                pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
                jDraw = 0;
            }

            pxrl = &prun->xrl;
        }

        pjBase = (WORD *) ((BYTE *) pjBase + pSurf->lDelta());
        yCurr++;

        if ((yCurr < rclClip.top) || (yCurr >= rclClip.bottom))
            ((ECLIPOBJ *) pco)->vFindScan(&rclClip, yCurr);
    }
}

/******************************Public*Routine******************************\
* VOID vStrWrite24(prun, prunEnd, pSurf, pco)
*
* Write the clipped run list of pels to the target 24BPP surface.
*
* History:
*  16-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vStrWrite24(
STRRUN  *prun,
XRUNLEN *pxrlEnd,
SURFACE *pSurf,
CLIPOBJ *pco)
{
    XRUNLEN   *pxrl = &prun->xrl;
    RGBTRIPLE *pjBase;
    RGBTRIPLE *pjCurr;
    RGBTRIPLE *pjDraw;
    LONG       xLeft;
    LONG       xRght;
    LONG       yCurr;
    LONG       iTop;
    LONG       iBot;
    LONG       iRep;
    LONG       jLeft;
    LONG       jRght;
    LONG       jDraw;
    LONG       jByte;

// See if this can be handled without clipping.

    if (pco == (CLIPOBJ *) NULL)
    {
        pjBase = (RGBTRIPLE *) ((BYTE *) pSurf->pvScan0() + pSurf->lDelta() * prun->yPos);

        while (pxrl != pxrlEnd)
        {
            xLeft = pxrl->xPos;
            xRght = pxrl->cRun + xLeft;
            jDraw = 0;

            pjDraw = pjCurr = pjBase + xLeft;

            while (xLeft < xRght)
            {
               *pjDraw++ = *((RGBTRIPLE *) &pxrl->aul[jDraw++]);
                xLeft++;
            }

            for (jDraw = 1; jDraw < prun->cRep; jDraw++)
            {
                pjDraw = (RGBTRIPLE *) ((BYTE *) pjCurr + pSurf->lDelta());
                RtlCopyMemory(pjDraw, pjCurr, pxrl->cRun * 3);
                pjCurr = pjDraw;
            }

            pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
        }
        return;
    }

    RECTL   rclClip;

    if (pco->iDComplexity == DC_RECT)
    {
        rclClip = pco->rclBounds;

        iTop = prun->yPos;
        iBot = prun->yPos + prun->cRep;

        if ((iTop >= rclClip.bottom) || (iBot <= rclClip.top))
            return;

        iTop = iTop >= rclClip.top ? iTop : rclClip.top;
        iBot = iBot < rclClip.bottom ? iBot : rclClip.bottom;
        iRep = iBot - iTop;

        pjBase = (RGBTRIPLE *) ((BYTE *) pSurf->pvScan0() + pSurf->lDelta() * iTop);

        while (pxrl != pxrlEnd)
        {
            xLeft = pxrl->xPos;
            xRght = pxrl->cRun + xLeft;

            if (xRght < rclClip.left)
            {
                pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
                continue;
            }

            if (xLeft >= rclClip.right)
                return;

            jLeft = xLeft >= rclClip.left ? xLeft : rclClip.left;
            jRght = xRght < rclClip.right ? xRght : rclClip.right;
            jByte = jRght - jLeft;

            pjDraw = pjCurr = pjBase + jLeft;
            jDraw  = jLeft - xLeft;

            while (jLeft < jRght)
            {
               *pjDraw++ = *((RGBTRIPLE *) &pxrl->aul[jDraw++]);
                jLeft++;
            }

            for (jDraw = 1; jDraw < iRep; jDraw++)
            {
                pjDraw = (RGBTRIPLE *) ((BYTE *) pjCurr + pSurf->lDelta());
                RtlCopyMemory(pjDraw, pjCurr, jByte * 3);
                pjCurr = pjDraw;
            }

            pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
        }

        return;
    }

// There is complex clipping.  Set up the clipping code.

    ((ECLIPOBJ *) pco)->cEnumStart(FALSE, CT_RECTANGLES, CD_ANY, 100);

    rclClip.left   = POS_INFINITY;
    rclClip.top    = POS_INFINITY;
    rclClip.right  = NEG_INFINITY;
    rclClip.bottom = NEG_INFINITY;

    yCurr = prun->yPos;
    iRep  = prun->cRep;
    ((ECLIPOBJ *) pco)->vFindScan(&rclClip, yCurr);
    pjBase = (RGBTRIPLE *) ((BYTE *) pSurf->pvScan0() + pSurf->lDelta() * yCurr);

    while (iRep--)
    {
        if ((yCurr >= rclClip.top) && (yCurr < rclClip.bottom))
        {
            jDraw = 0;

            while (pxrl != pxrlEnd)
            {
                xLeft = pxrl->xPos;
                xRght = pxrl->cRun + xLeft;

                pjDraw = pjCurr = pjBase + xLeft;

                while (xLeft < xRght)
                {
                    if ((xLeft < rclClip.left) || (xLeft >= rclClip.right))
                        ((ECLIPOBJ *) pco)->vFindSegment(&rclClip, xLeft, yCurr);

                    if ((xLeft >= rclClip.left) && (xLeft < rclClip.right))
                       *pjDraw = *((RGBTRIPLE *) &pxrl->aul[jDraw]);

                    pjDraw++;
                    jDraw++;
                    xLeft++;
                }

                pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
                jDraw = 0;
            }

            pxrl = &prun->xrl;
        }

        pjBase = (RGBTRIPLE *) ((BYTE *) pjBase + pSurf->lDelta());
        yCurr++;

        if ((yCurr < rclClip.top) || (yCurr >= rclClip.bottom))
            ((ECLIPOBJ *) pco)->vFindScan(&rclClip, yCurr);
    }
}

/******************************Public*Routine******************************\
* VOID vStrWrite32(prun, prunEnd, pSurf, pco)
*
* Write the clipped run list of pels to the target 32BPP surface.
*
* History:
*  16-Feb-1993 -by- Donald Sidoroff [donalds]
* Wrote it.
\**************************************************************************/

VOID vStrWrite32(
STRRUN  *prun,
XRUNLEN *pxrlEnd,
SURFACE *pSurf,
CLIPOBJ *pco)
{
    XRUNLEN *pxrl = &prun->xrl;
    DWORD   *pjBase;
    DWORD   *pjCurr;
    DWORD   *pjDraw;
    LONG     xLeft;
    LONG     xRght;
    LONG     yCurr;
    LONG     iTop;
    LONG     iBot;
    LONG     iRep;
    LONG     jLeft;
    LONG     jRght;
    LONG     jDraw;
    LONG     jByte;

// See if this can be handled without clipping.

    if (pco == (CLIPOBJ *) NULL)
    {
        pjBase = (DWORD *) ((BYTE *) pSurf->pvScan0() + pSurf->lDelta() * prun->yPos);

        while (pxrl != pxrlEnd)
        {
            xLeft = pxrl->xPos;
            xRght = pxrl->cRun + xLeft;
            jDraw = 0;

            pjDraw = pjCurr = pjBase + xLeft;

            while (xLeft < xRght)
            {
               *pjDraw++ = (DWORD) pxrl->aul[jDraw++];
                xLeft++;
            }

            for (jDraw = 1; jDraw < prun->cRep; jDraw++)
            {
                pjDraw = (DWORD *) ((BYTE *) pjCurr + pSurf->lDelta());
                RtlCopyMemory(pjDraw, pjCurr, pxrl->cRun * 4);
                pjCurr = pjDraw;
            }

            pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
        }
        return;
    }

    RECTL   rclClip;

    if (pco->iDComplexity == DC_RECT)
    {
        rclClip = pco->rclBounds;

        iTop = prun->yPos;
        iBot = prun->yPos + prun->cRep;

        if ((iTop >= rclClip.bottom) || (iBot <= rclClip.top))
            return;

        iTop = iTop >= rclClip.top ? iTop : rclClip.top;
        iBot = iBot < rclClip.bottom ? iBot : rclClip.bottom;
        iRep = iBot - iTop;

        pjBase = (DWORD *) ((BYTE *) pSurf->pvScan0() + pSurf->lDelta() * iTop);

        while (pxrl != pxrlEnd)
        {
            xLeft = pxrl->xPos;
            xRght = pxrl->cRun + xLeft;

            if (xRght < rclClip.left)
            {
                pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
                continue;
            }

            if (xLeft >= rclClip.right)
                return;

            jLeft = xLeft >= rclClip.left ? xLeft : rclClip.left;
            jRght = xRght < rclClip.right ? xRght : rclClip.right;
            jByte = jRght - jLeft;

            pjDraw = pjCurr = pjBase + jLeft;
            jDraw  = jLeft - xLeft;

            while (jLeft < jRght)
            {
               *pjDraw++ = (DWORD) pxrl->aul[jDraw++];
                jLeft++;
            }

            for (jDraw = 1; jDraw < iRep; jDraw++)
            {
                pjDraw = (DWORD *) ((BYTE *) pjCurr + pSurf->lDelta());
                RtlCopyMemory(pjDraw, pjCurr, jByte * 4);
                pjCurr = pjDraw;
            }

            pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
        }

        return;
    }

// There is complex clipping.  Set up the clipping code.

    ((ECLIPOBJ *) pco)->cEnumStart(FALSE, CT_RECTANGLES, CD_ANY, 100);

    rclClip.left   = POS_INFINITY;
    rclClip.top    = POS_INFINITY;
    rclClip.right  = NEG_INFINITY;
    rclClip.bottom = NEG_INFINITY;

    yCurr = prun->yPos;
    iRep  = prun->cRep;
    ((ECLIPOBJ *) pco)->vFindScan(&rclClip, yCurr);
    pjBase = (DWORD *) ((BYTE *) pSurf->pvScan0() + pSurf->lDelta() * yCurr);

    while (iRep--)
    {
        if ((yCurr >= rclClip.top) && (yCurr < rclClip.bottom))
        {
            jDraw = 0;

            while (pxrl != pxrlEnd)
            {
                xLeft = pxrl->xPos;
                xRght = pxrl->cRun + xLeft;

                pjDraw = pjCurr = pjBase + xLeft;

                while (xLeft < xRght)
                {
                    if ((xLeft < rclClip.left) || (xLeft >= rclClip.right))
                        ((ECLIPOBJ *) pco)->vFindSegment(&rclClip, xLeft, yCurr);

                    if ((xLeft >= rclClip.left) && (xLeft < rclClip.right))
                       *pjDraw = (DWORD) pxrl->aul[jDraw];

                    pjDraw++;
                    jDraw++;
                    xLeft++;
                }

                pxrl = (XRUNLEN *) &pxrl->aul[pxrl->cRun];
                jDraw = 0;
            }

            pxrl = &prun->xrl;
        }

        pjBase = (DWORD *) ((BYTE *) pjBase + pSurf->lDelta());
        yCurr++;

        if ((yCurr < rclClip.top) || (yCurr >= rclClip.bottom))
            ((ECLIPOBJ *) pco)->vFindScan(&rclClip, yCurr);
    }
}