home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / server / ddx / cfb / cfbtileodd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-10  |  24.4 KB  |  1,063 lines
  1. /*
  2.  * Fill odd tiled rectangles and spans.
  3.  * no depth dependencies.
  4.  */
  5.  
  6. /*
  7. Copyright 1989 by the Massachusetts Institute of Technology
  8.  
  9. Permission to use, copy, modify, and distribute this software and its
  10. documentation for any purpose and without fee is hereby granted,
  11. provided that the above copyright notice appear in all copies and that
  12. both that copyright notice and this permission notice appear in
  13. supporting documentation, and that the name of M.I.T. not be used in
  14. advertising or publicity pertaining to distribution of the software
  15. without specific, written prior permission.  M.I.T. makes no
  16. representations about the suitability of this software for any
  17. purpose.  It is provided "as is" without express or implied warranty.
  18. */
  19.  
  20. /* $XConsortium: cfbtileodd.c,v 1.13 91/07/10 17:26:10 keith Exp $ */
  21.  
  22. #include "X.h"
  23. #include "Xmd.h"
  24. #include "servermd.h"
  25. #include "gcstruct.h"
  26. #include "window.h"
  27. #include "pixmapstr.h"
  28. #include "scrnintstr.h"
  29. #include "windowstr.h"
  30.  
  31. #include "cfb.h"
  32. #include "cfbmskbits.h"
  33. #include "cfb8bit.h"
  34.  
  35. #include "mergerop.h"
  36.  
  37. #define LastTileBits {\
  38.     tmp = bits; \
  39.     if (tileEndPart) \
  40.     bits = (*pSrc & tileEndMask) | BitRight (*pSrcLine, tileEndLeftShift); \
  41.     else \
  42.     bits = *pSrc; \
  43. }
  44.  
  45. #define ResetTileBits {\
  46.     pSrc = pSrcLine; \
  47.     nlwSrc = widthSrc;\
  48.     if (tileEndPart) { \
  49.     if (PPW - xoff + tileEndPart <= PPW) {\
  50.         bits = *pSrc++; \
  51.         nlwSrc--; \
  52.     } else \
  53.         bits = BitLeft(tmp, tileEndLeftShift) | \
  54.            BitRight(bits, tileEndRightShift); \
  55.     xoff = (xoff + xoffStep) & PIM; \
  56.     leftShift = xoff << (5-PWSH); \
  57.     rightShift = 32 - leftShift; \
  58.     }\
  59. }
  60.  
  61. #define NextTileBits {\
  62.     if (nlwSrc == 1) {\
  63.     LastTileBits\
  64.     } else { \
  65.         if (nlwSrc == 0) {\
  66.         ResetTileBits\
  67.         } \
  68.     if (nlwSrc == 1) {\
  69.         LastTileBits\
  70.     } else {\
  71.         tmp = bits; \
  72.         bits = *pSrc++; \
  73.     }\
  74.     }\
  75.     nlwSrc--; \
  76. }
  77.  
  78. void
  79. MROP_NAME(cfbFillBoxTileOdd) (pDrawable, nBox, pBox, tile, xrot, yrot, alu, planemask)
  80.     DrawablePtr        pDrawable;
  81.     int            nBox;    /* number of boxes to fill */
  82.     register BoxPtr pBox;    /* pointer to list of boxes to fill */
  83.     PixmapPtr        tile;    /* tile */
  84.     int            xrot, yrot;
  85.     int            alu;
  86.     unsigned long   planemask;
  87. {
  88.     int tileWidth;    /* width of tile in pixels */
  89.     int tileHeight;    /* height of the tile */
  90.     int widthSrc;
  91.  
  92.     int widthDst;        /* width in longwords of the dest pixmap */
  93.     int w;        /* width of current box */
  94.     int h;        /* height of current box */
  95.     unsigned long startmask;
  96.     unsigned long endmask;    /* masks for reggedy bits at either end of line */
  97.     int nlwMiddle;    /* number of longwords between sides of boxes */
  98.     int nlwSrc;        /* number of whole longwords in source */
  99.     
  100.     register int nlw;    /* loop version of nlwMiddle */
  101.     int srcy;        /* current tile y position */
  102.     int srcx;        /* current tile x position */
  103.     int xoffDst, xoffSrc;
  104.     int leftShift, rightShift;
  105.  
  106.     MROP_DECLARE_REG()
  107.  
  108.     unsigned long *pDstBase;    /* pointer to start of dest */
  109.     unsigned long *pDstLine;    /* poitner to start of dest box */
  110.     unsigned long *pSrcBase;    /* pointer to start of source */
  111.     unsigned long *pSrcLine;    /* pointer to start of source line */
  112.     register unsigned long *pDst;
  113.     register unsigned long *pSrc;
  114.     register unsigned long bits, tmp;
  115.     register int       nlwPart;
  116.     int xoffStart, xoff;
  117.     int leftShiftStart, rightShiftStart, nlwSrcStart;
  118.     unsigned long tileEndMask;
  119.     int tileEndLeftShift, tileEndRightShift;
  120.     int    xoffStep;
  121.     int tileEndPart;
  122.     int needFirst;
  123.     unsigned long   narrow[2];
  124.     unsigned long   narrowMask;
  125.     int        narrowShift;
  126.     Bool    narrowTile;
  127.  
  128.     MROP_INITIALIZE (alu, planemask)
  129.  
  130.     tileHeight = tile->drawable.height;
  131.     tileWidth = tile->drawable.width;
  132.     widthSrc = tile->devKind >> 2;
  133.     narrowTile = FALSE;
  134.     if (widthSrc == 1)
  135.     {
  136.     narrowShift = tileWidth;
  137.     narrowMask = cfbendpartial [tileWidth];
  138.     tileWidth *= 2;
  139.     widthSrc = 2;
  140.     narrowTile = TRUE;
  141.     }
  142.     pSrcBase = (unsigned long *)tile->devPrivate.ptr;
  143.  
  144.     cfbGetLongWidthAndPointer (pDrawable, widthDst, pDstBase)
  145.  
  146.     tileEndPart = tileWidth & PIM;
  147.     tileEndMask = cfbendpartial[tileEndPart];
  148.     tileEndLeftShift = (tileEndPart) << (5-PWSH);
  149.     tileEndRightShift = 32 - tileEndLeftShift;
  150.     xoffStep = PPW - tileEndPart;
  151.     /*
  152.      * current assumptions: tile > 32 bits wide.
  153.      */
  154.     while (nBox--)
  155.     {
  156.     w = pBox->x2 - pBox->x1;
  157.     h = pBox->y2 - pBox->y1;
  158.     modulus (pBox->x1 - xrot, tileWidth, srcx);
  159.     modulus (pBox->y1 - yrot, tileHeight, srcy);
  160.     xoffDst = pBox->x1 & PIM;
  161.     if (xoffDst + w < PPW)
  162.     {
  163.         maskpartialbits(pBox->x1, w, startmask);
  164.         endmask = 0;
  165.         nlwMiddle = 0;
  166.     }
  167.     else
  168.     {
  169.         maskbits (pBox->x1, w, startmask, endmask, nlwMiddle)
  170.     }
  171.     pDstLine = pDstBase + (pBox->y1 * widthDst) + (pBox->x1 >> PWSH);
  172.     pSrcLine = pSrcBase + (srcy * widthSrc);
  173.     xoffSrc = srcx & PIM;
  174.     if (xoffSrc >= xoffDst)
  175.     {
  176.         xoffStart = xoffSrc - xoffDst;
  177.         needFirst = 1;
  178.     }
  179.     else
  180.     {
  181.         xoffStart = PPW - (xoffDst - xoffSrc);
  182.         needFirst = 0;
  183.     }
  184.     leftShiftStart = (xoffStart) << (5-PWSH);
  185.     rightShiftStart = 32 - leftShiftStart;
  186.     nlwSrcStart = widthSrc - (srcx >> PWSH);
  187.     while (h--)
  188.     {
  189.         /* XXX only works when narrowShift >= PPW/2 */
  190.         if (narrowTile)
  191.         {
  192.         tmp = pSrcBase[srcy] & narrowMask; /* source width == 1 */
  193.         narrow[0] = tmp | SCRRIGHT (tmp, narrowShift);
  194.         narrow[1] = SCRLEFT (tmp, PPW - narrowShift) |
  195.                 SCRRIGHT(tmp, 2 * narrowShift - PPW);
  196.         pSrcLine = narrow;
  197.         }
  198.         xoff = xoffStart;
  199.         leftShift = leftShiftStart;
  200.         rightShift = rightShiftStart;
  201.         nlwSrc = nlwSrcStart;
  202.         pSrc = pSrcLine + (srcx >> PWSH);
  203.         pDst = pDstLine;
  204.         bits = 0;
  205.         if (needFirst)
  206.         {
  207.         NextTileBits
  208.         }
  209.         if (startmask)
  210.         {
  211.         NextTileBits
  212.         tmp = BitLeft(tmp, leftShift);
  213.          if (rightShift != 32)
  214.             tmp |= BitRight(bits,rightShift);
  215.         *pDst = MROP_MASK (tmp, *pDst, startmask);
  216.         ++pDst;
  217.         }
  218.         nlw = nlwMiddle;
  219.         while (nlw)
  220.         {
  221. #if MROP == Mcopy
  222.         if (nlwSrc > 1)
  223.         {
  224.             nlwPart = nlw;
  225.             if (nlwPart >= nlwSrc)
  226.             nlwPart = nlwSrc - 1;
  227.             nlw -= nlwPart;
  228.             nlwSrc -= nlwPart;
  229.             if (rightShift != 32)
  230.             {
  231.             while (nlwPart--)
  232.             {
  233.                 tmp = bits;
  234.                 bits = *pSrc++;
  235.                 *pDst = MROP_SOLID(BitLeft(tmp, leftShift) |
  236.                           BitRight (bits, rightShift),
  237.                           *pDst);
  238.                 ++pDst;
  239.             }
  240.             }
  241.             else
  242.             {
  243.             if (nlwPart)
  244.             {
  245.                 *pDst = MROP_SOLID (bits, *pDst);
  246.                 ++pDst;
  247.                 nlwPart--;
  248.                 while (nlwPart--)
  249.                 {
  250.                 *pDst = MROP_SOLID(*pSrc, *pDst);
  251.                 ++pDst; ++pSrc;
  252.                 }
  253.                 bits = *pSrc++;
  254.             }
  255.             }
  256.         }
  257.         else
  258. #endif
  259.         {
  260.             NextTileBits
  261.             if (rightShift != 32)
  262.             {
  263.             *pDst = MROP_SOLID(BitLeft(tmp, leftShift) |
  264.                        BitRight(bits, rightShift),
  265.                        *pDst);
  266.             }
  267.             else
  268.             {
  269.             *pDst = MROP_SOLID (tmp, *pDst);
  270.             }
  271.             ++pDst;
  272.             nlw--;
  273.         }
  274.         }
  275.         if (endmask)
  276.         {
  277.         NextTileBits
  278.         if (rightShift == 32)
  279.             bits = 0;
  280.         *pDst = MROP_MASK (BitLeft(tmp, leftShift) |
  281.                    BitRight(bits,rightShift),
  282.                    *pDst, endmask);
  283.         }
  284.         pDstLine += widthDst;
  285.         pSrcLine += widthSrc;
  286.         if (++srcy == tileHeight)
  287.         {
  288.         srcy = 0;
  289.         pSrcLine = pSrcBase;
  290.         }
  291.     }
  292.     pBox++;
  293.     }
  294. }
  295.  
  296. void
  297. MROP_NAME(cfbFillSpanTileOdd) (pDrawable, n, ppt, pwidth, tile, xrot, yrot, alu, planemask)
  298.     DrawablePtr    pDrawable;
  299.     int        n;
  300.     DDXPointPtr    ppt;
  301.     int        *pwidth;
  302.     PixmapPtr    tile;
  303.     int        xrot, yrot;
  304.     int        alu;
  305.     unsigned long   planemask;
  306. {
  307.     int tileWidth;    /* width of tile in pixels */
  308.     int tileHeight;    /* height of the tile */
  309.     int widthSrc;
  310.  
  311.     int widthDst;        /* width in longwords of the dest pixmap */
  312.     int w;        /* width of current span */
  313.     unsigned long startmask;
  314.     unsigned long endmask;    /* masks for reggedy bits at either end of line */
  315.     int nlwSrc;        /* number of whole longwords in source */
  316.     
  317.     register int nlw;    /* loop version of nlwMiddle */
  318.     int srcy;        /* current tile y position */
  319.     int srcx;        /* current tile x position */
  320.     int xoffDst, xoffSrc;
  321.     int leftShift, rightShift;
  322.  
  323.     MROP_DECLARE_REG()
  324.  
  325.     unsigned long *pDstBase;    /* pointer to start of dest */
  326.     unsigned long *pDstLine;    /* poitner to start of dest box */
  327.     unsigned long *pSrcBase;    /* pointer to start of source */
  328.     unsigned long *pSrcLine;    /* pointer to start of source line */
  329.     register unsigned long *pDst;
  330.     register unsigned long *pSrc;
  331.     register unsigned long bits, tmp;
  332.     register int       nlwPart;
  333.     int xoffStart, xoff;
  334.     int leftShiftStart, rightShiftStart, nlwSrcStart;
  335.     unsigned long tileEndMask;
  336.     int tileEndLeftShift, tileEndRightShift;
  337.     int    xoffStep;
  338.     int tileEndPart;
  339.     int needFirst;
  340.     unsigned long   narrow[2];
  341.     unsigned long   narrowMask;
  342.     int        narrowShift;
  343.     Bool    narrowTile;
  344.  
  345.     MROP_INITIALIZE (alu, planemask)
  346.  
  347.     tileHeight = tile->drawable.height;
  348.     tileWidth = tile->drawable.width;
  349.     widthSrc = tile->devKind >> 2;
  350.     narrowTile = FALSE;
  351.     if (widthSrc == 1)
  352.     {
  353.     narrowShift = tileWidth;
  354.     narrowMask = cfbendpartial [tileWidth];
  355.     tileWidth *= 2;
  356.     widthSrc = 2;
  357.     narrowTile = TRUE;
  358.     }
  359.     pSrcBase = (unsigned long *)tile->devPrivate.ptr;
  360.  
  361.     cfbGetLongWidthAndPointer (pDrawable, widthDst, pDstBase)
  362.  
  363.     tileEndPart = tileWidth & PIM;
  364.     tileEndMask = cfbendpartial[tileEndPart];
  365.     tileEndLeftShift = (tileEndPart) << (5-PWSH);
  366.     tileEndRightShift = 32 - tileEndLeftShift;
  367.     xoffStep = PPW - tileEndPart;
  368.     while (n--)
  369.     {
  370.     w = *pwidth++;
  371.     modulus (ppt->x - xrot, tileWidth, srcx);
  372.     modulus (ppt->y - yrot, tileHeight, srcy);
  373.     xoffDst = ppt->x & PIM;
  374.     if (xoffDst + w < PPW)
  375.     {
  376.         maskpartialbits(ppt->x, w, startmask);
  377.         endmask = 0;
  378.         nlw = 0;
  379.     }
  380.     else
  381.     {
  382.         maskbits (ppt->x, w, startmask, endmask, nlw)
  383.     }
  384.     pDstLine = pDstBase + (ppt->y * widthDst) + (ppt->x >> PWSH);
  385.     pSrcLine = pSrcBase + (srcy * widthSrc);
  386.     xoffSrc = srcx & PIM;
  387.     if (xoffSrc >= xoffDst)
  388.     {
  389.         xoffStart = xoffSrc - xoffDst;
  390.         needFirst = 1;
  391.     }
  392.     else
  393.     {
  394.         xoffStart = PPW - (xoffDst - xoffSrc);
  395.         needFirst = 0;
  396.     }
  397.     leftShiftStart = (xoffStart) << (5-PWSH);
  398.     rightShiftStart = 32 - leftShiftStart;
  399.     nlwSrcStart = widthSrc - (srcx >> PWSH);
  400.     /* XXX only works when narrowShift >= PPW/2 */
  401.     if (narrowTile)
  402.     {
  403.         tmp = pSrcBase[srcy] & narrowMask;    /* source width == 1 */
  404.         narrow[0] = tmp | SCRRIGHT (tmp, narrowShift);
  405.         narrow[1] = SCRLEFT (tmp, PPW - narrowShift) |
  406.             SCRRIGHT(tmp, 2 * narrowShift - PPW);
  407.         pSrcLine = narrow;
  408.     }
  409.     xoff = xoffStart;
  410.     leftShift = leftShiftStart;
  411.     rightShift = rightShiftStart;
  412.     nlwSrc = nlwSrcStart;
  413.     pSrc = pSrcLine + (srcx >> PWSH);
  414.     pDst = pDstLine;
  415.     bits = 0;
  416.     if (needFirst)
  417.     {
  418.         NextTileBits
  419.     }
  420.     if (startmask)
  421.     {
  422.         NextTileBits
  423.         tmp = BitLeft(tmp, leftShift);
  424.         if (rightShift != 32)
  425.         tmp |= BitRight(bits,rightShift);
  426.         *pDst = MROP_MASK (tmp, *pDst, startmask);
  427.         ++pDst;
  428.     }
  429.     while (nlw)
  430.     {
  431. #if MROP == Mcopy
  432.         if (nlwSrc > 1)
  433.         {
  434.         nlwPart = nlw;
  435.         if (nlwPart >= nlwSrc)
  436.             nlwPart = nlwSrc - 1;
  437.         nlw -= nlwPart;
  438.         nlwSrc -= nlwPart;
  439.         if (rightShift != 32)
  440.         {
  441.             while (nlwPart--)
  442.             {
  443.             tmp = bits;
  444.             bits = *pSrc++;
  445.             *pDst = MROP_SOLID(BitLeft(tmp, leftShift) |
  446.                       BitRight (bits, rightShift),
  447.                       *pDst);
  448.             ++pDst;
  449.             }
  450.         }
  451.         else
  452.         {
  453.             if (nlwPart)
  454.             {
  455.             *pDst = MROP_SOLID (bits, *pDst);
  456.             ++pDst;
  457.             nlwPart--;
  458.             while (nlwPart--)
  459.             {
  460.                 *pDst = MROP_SOLID(*pSrc, *pDst);
  461.                 ++pDst; ++pSrc;
  462.             }
  463.             bits = *pSrc++;
  464.             }
  465.         }
  466.         }
  467.         else
  468. #endif
  469.         {
  470.         NextTileBits
  471.         if (rightShift != 32)
  472.         {
  473.             *pDst = MROP_SOLID(BitLeft(tmp, leftShift) |
  474.                        BitRight(bits, rightShift),
  475.                        *pDst);
  476.             ++pDst;
  477.         }
  478.         else
  479.         {
  480.             *pDst = MROP_SOLID (tmp, *pDst);
  481.             ++pDst;
  482.         }
  483.         nlw--;
  484.         }
  485.     }
  486.     if (endmask)
  487.     {
  488.         NextTileBits
  489.         if (rightShift == 32)
  490.         bits = 0;
  491.         *pDst = MROP_MASK (BitLeft(tmp, leftShift) |
  492.                    BitRight(bits,rightShift),
  493.                    *pDst, endmask);
  494.     }
  495.     ppt++;
  496.     }
  497. }
  498.  
  499. # include "fastblt.h"
  500.  
  501. #define IncSrcPtr   psrc++; if (!--srcRemaining) { srcRemaining = widthSrc; psrc = psrcStart; }
  502.  
  503. MROP_NAME(cfbFillBoxTile32s) (pDrawable, nBox, pBox, tile, xrot, yrot, alu, planemask)
  504.     DrawablePtr        pDrawable;
  505.     int            nBox;    /* number of boxes to fill */
  506.     register BoxPtr pBox;    /* pointer to list of boxes to fill */
  507.     PixmapPtr        tile;    /* tile */
  508.     int            xrot, yrot;
  509.     int            alu;
  510.     unsigned long   planemask;
  511. {
  512.     int    tileWidth;    /* width of tile */
  513.     int tileHeight;    /* height of the tile */
  514.     int    widthSrc;    /* width in longwords of the source tile */
  515.  
  516.     int widthDst;    /* width in longwords of the dest pixmap */
  517.     int w;        /* width of current box */
  518.     int h;        /* height of current box */
  519.     unsigned long startmask;
  520.     unsigned long endmask;    /* masks for reggedy bits at either end of line */
  521.     int nlMiddle;    /* number of longwords between sides of boxes */
  522.     
  523.     register int nl;    /* loop version of nlMiddle */
  524.     int srcy;        /* current tile y position */
  525.     int srcx;        /* current tile x position */
  526.     int    srcRemaining;    /* number of longwords remaining in source */
  527.     int xoffDst, xoffSrc;
  528.     int    srcStart;    /* number of longwords source offset at left of box */
  529.     int    leftShift, rightShift;
  530.  
  531.     MROP_DECLARE_REG()
  532.  
  533.     unsigned long        *pdstBase;    /* pointer to start of dest */
  534.     unsigned long        *pdstLine;    /* poitner to start of dest box */
  535.     unsigned long        *psrcBase;    /* pointer to start of source */
  536.     unsigned long        *psrcLine;    /* pointer to fetch point of source */
  537.     unsigned long        *psrcStart;    /* pointer to start of source line */
  538.     register unsigned long  *pdst;
  539.     register unsigned long  *psrc;
  540.     register unsigned long  bits, bits1;
  541.     register int        nlTemp;
  542.  
  543.     MROP_INITIALIZE (alu, planemask)
  544.  
  545.     psrcBase = (unsigned long *)tile->devPrivate.ptr;
  546.     tileHeight = tile->drawable.height;
  547.     tileWidth = tile->drawable.width;
  548.     widthSrc = tileWidth >> PWSH;
  549.  
  550.     cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase)
  551.  
  552.     while (nBox--)
  553.     {
  554.     w = pBox->x2 - pBox->x1;
  555.     h = pBox->y2 - pBox->y1;
  556.  
  557.     /* set up source */
  558.     modulus (pBox->x1 - xrot, tileWidth, srcx);
  559.     modulus (pBox->y1 - yrot, tileHeight, srcy);
  560.     xoffSrc = srcx & PIM;
  561.     srcStart = (srcx >> PWSH);
  562.     psrcStart = psrcBase + (srcy * widthSrc);
  563.     psrcLine = psrcStart + srcStart;
  564.  
  565.     /* set up dest */
  566.     xoffDst = pBox->x1 & PIM;
  567.     pdstLine = pdstBase + (pBox->y1 * widthDst) + (pBox->x1 >> PWSH);
  568.     /* set up masks */
  569.     if (xoffDst + w < PPW)
  570.     {
  571.         maskpartialbits(pBox->x1, w, startmask);
  572.         endmask = 0;
  573.         nlMiddle = 0;
  574.     }
  575.     else
  576.     {
  577.         maskbits (pBox->x1, w, startmask, endmask, nlMiddle)
  578.     }
  579.  
  580.     if (xoffSrc == xoffDst)
  581.     {
  582.         while (h--)
  583.         {
  584.         psrc = psrcLine;
  585.         pdst = pdstLine;
  586.         srcRemaining = widthSrc - srcStart;
  587.         if (startmask)
  588.         {
  589.             *pdst = MROP_MASK (*psrc, *pdst, startmask);
  590.             pdst++;
  591.             IncSrcPtr
  592.         }
  593.         nlTemp = nlMiddle;
  594.         while (nlTemp)
  595.         {
  596.             nl = nlTemp;
  597.             if (nl > srcRemaining)
  598.             nl = srcRemaining;
  599.  
  600.             nlTemp -= nl;
  601.             srcRemaining -= nl;
  602.  
  603. #if MROP == Mcopy
  604. #ifdef LARGE_INSTRUCTION_CACHE
  605. #ifdef FAST_CONSTANT_OFFSET_MODE
  606.  
  607.             psrc += nl & (UNROLL-1);
  608.             pdst += nl & (UNROLL-1);
  609.  
  610. #define BodyOdd(n) pdst[-n] = MROP_SOLID (psrc[-n], pdst[-n]);
  611. #define BodyEven(n) pdst[-n] = MROP_SOLID (psrc[-n], pdst[-n]);
  612.  
  613. #define LoopReset \
  614. pdst += UNROLL; \
  615. psrc += UNROLL;
  616.  
  617. #else
  618.  
  619. #define BodyOdd(n)  *pdst = MROP_SOLID (*psrc, *pdst); pdst++; psrc++;
  620. #define BodyEven(n) BodyOdd(n)
  621.  
  622. #define LoopReset   ;
  623.  
  624. #endif
  625.             PackedLoop
  626.  
  627. #undef BodyOdd
  628. #undef BodyEven
  629. #undef LoopReset
  630.  
  631. #else
  632.             DuffL(nl, label1,
  633.                 *pdst = MROP_SOLID (*psrc, *pdst);
  634.                 pdst++; psrc++;)
  635. #endif
  636. #else
  637.             while (nl--) {
  638.                 *pdst = MROP_SOLID (*psrc, *pdst);
  639.                 pdst++; psrc++;
  640.             }
  641. #endif
  642.             if (!srcRemaining)
  643.             {
  644.             srcRemaining = widthSrc;
  645.             psrc = psrcStart;
  646.             }
  647.         }
  648.         if (endmask)
  649.         {
  650.             *pdst = MROP_MASK (*psrc, *pdst, endmask);
  651.         }
  652.         pdstLine += widthDst;
  653.         psrcLine += widthSrc;
  654.         psrcStart += widthSrc;
  655.         if (++srcy == tileHeight)
  656.         {
  657.             psrcStart = psrcBase;
  658.             psrcLine = psrcStart + srcStart;
  659.             srcy = 0;
  660.         }
  661.         }
  662.     }
  663.     else
  664.     {
  665.         if (xoffSrc > xoffDst)
  666.         {
  667.         leftShift = (xoffSrc - xoffDst) << (5 - PWSH);
  668.         rightShift = 32 - leftShift;
  669.         }
  670.         else
  671.         {
  672.         rightShift = (xoffDst - xoffSrc) << (5 - PWSH);
  673.         leftShift = 32 - rightShift;
  674.         }
  675.         while (h--)
  676.         {
  677.         psrc = psrcLine;
  678.         pdst = pdstLine;
  679.         bits = 0;
  680.         srcRemaining = widthSrc - srcStart;
  681.         if (xoffSrc > xoffDst)
  682.         {
  683.             bits = *psrc;
  684.             IncSrcPtr
  685.         }
  686.         if (startmask)
  687.         {
  688.             bits1 = BitLeft(bits,leftShift);
  689.             bits = *psrc;
  690.             IncSrcPtr
  691.             bits1 |= BitRight(bits,rightShift);
  692.             *pdst = MROP_MASK(bits1, *pdst, startmask);
  693.             pdst++;
  694.         }
  695.         nlTemp = nlMiddle;
  696.         while (nlTemp)
  697.         {
  698.             nl = nlTemp;
  699.             if (nl > srcRemaining)
  700.             nl = srcRemaining;
  701.  
  702.             nlTemp -= nl;
  703.             srcRemaining -= nl;
  704.     
  705. #if MROP == Mcopy
  706. #ifdef LARGE_INSTRUCTION_CACHE
  707.             bits1 = bits;
  708.     
  709. #ifdef FAST_CONSTANT_OFFSET_MODE
  710.     
  711.             psrc += nl & (UNROLL-1);
  712.             pdst += nl & (UNROLL-1);
  713.     
  714. #define BodyOdd(n) \
  715.     bits = psrc[-n]; \
  716.     pdst[-n] = MROP_SOLID(BitLeft(bits1, leftShift) | BitRight(bits, rightShift), pdst[-n]);
  717.     
  718. #define BodyEven(n) \
  719.     bits1 = psrc[-n]; \
  720.     pdst[-n] = MROP_SOLID(BitLeft(bits, leftShift) | BitRight(bits1, rightShift), pdst[-n]);
  721.     
  722. #define LoopReset \
  723.     pdst += UNROLL; \
  724.     psrc += UNROLL;
  725.     
  726. #else
  727.     
  728. #define BodyOdd(n) \
  729.     bits = *psrc++; \
  730.     *pdst = MROP_SOLID(BitLeft(bits1, leftShift) | BitRight(bits, rightShift), *pdst); \
  731.     pdst++;
  732.                   
  733. #define BodyEven(n) \
  734.     bits1 = *psrc++; \
  735.     *pdst = MROP_SOLID(BitLeft(bits, leftShift) | BitRight(bits1, rightShift), *pdst); \
  736.     pdst++;
  737.     
  738. #define LoopReset   ;
  739.     
  740. #endif    /* !FAST_CONSTANT_OFFSET_MODE */
  741.     
  742.             PackedLoop
  743.     
  744. #undef BodyOdd
  745. #undef BodyEven
  746. #undef LoopReset
  747.     
  748. #else
  749.             DuffL (nl,label2,
  750.                 bits1 = BitLeft(bits, leftShift);
  751.                 bits = *psrc++;
  752.                 *pdst = MROP_SOLID (bits1 | BitRight(bits, rightShift), *pdst);
  753.                 pdst++;
  754.             )
  755. #endif
  756. #else
  757.             while (nl--) {
  758.                 bits1 = BitLeft(bits, leftShift);
  759.                 bits = *psrc++;
  760.                 *pdst = MROP_SOLID (bits1 | BitRight(bits, rightShift), *pdst);
  761.                 pdst++;
  762.             }
  763. #endif
  764.             if (!srcRemaining)
  765.             {
  766.             srcRemaining = widthSrc;
  767.             psrc = psrcStart;
  768.             }
  769.         }
  770.  
  771.         if (endmask)
  772.         {
  773.             bits1 = BitLeft(bits, leftShift);
  774.             if (BitLeft(endmask, rightShift))
  775.             {
  776.             bits = *psrc;
  777.             bits1 |= BitRight(bits, rightShift);
  778.             }
  779.             *pdst = MROP_MASK (bits1, *pdst, endmask);
  780.         }
  781.         pdstLine += widthDst;
  782.         psrcLine += widthSrc;
  783.         psrcStart += widthSrc;
  784.         if (++srcy == tileHeight)
  785.         {
  786.             psrcStart = psrcBase;
  787.             psrcLine = psrcStart + srcStart;
  788.             srcy = 0;
  789.         }
  790.         }
  791.     }
  792.     pBox++;
  793.     }
  794. }
  795.  
  796. MROP_NAME(cfbFillSpanTile32s) (pDrawable, n, ppt, pwidth, tile, xrot, yrot, alu, planemask)
  797.     DrawablePtr    pDrawable;
  798.     int        n;
  799.     DDXPointPtr    ppt;
  800.     int        *pwidth;
  801.     PixmapPtr    tile;
  802.     int        xrot, yrot;
  803.     int        alu;
  804.     unsigned long   planemask;
  805. {
  806.     int    tileWidth;    /* width of tile */
  807.     int tileHeight;    /* height of the tile */
  808.     int    widthSrc;    /* width in longwords of the source tile */
  809.  
  810.     int widthDst;    /* width in longwords of the dest pixmap */
  811.     int w;        /* width of current box */
  812.     unsigned long startmask;
  813.     unsigned long endmask;    /* masks for reggedy bits at either end of line */
  814.     int nlMiddle;    /* number of longwords between sides of boxes */
  815.     
  816.     register int nl;    /* loop version of nlMiddle */
  817.     int srcy;        /* current tile y position */
  818.     int srcx;        /* current tile x position */
  819.     int    srcRemaining;    /* number of longwords remaining in source */
  820.     int xoffDst, xoffSrc;
  821.     int    srcStart;    /* number of longwords source offset at left of box */
  822.     int    leftShift, rightShift;
  823.  
  824.     MROP_DECLARE_REG()
  825.  
  826.     unsigned long        *pdstBase;    /* pointer to start of dest */
  827.     unsigned long        *pdstLine;    /* poitner to start of dest box */
  828.     unsigned long        *psrcBase;    /* pointer to start of source */
  829.     unsigned long        *psrcLine;    /* pointer to fetch point of source */
  830.     unsigned long        *psrcStart;    /* pointer to start of source line */
  831.     register unsigned long  *pdst;
  832.     register unsigned long  *psrc;
  833.     register unsigned long  bits, bits1;
  834.     register int        nlTemp;
  835.  
  836.     MROP_INITIALIZE (alu, planemask)
  837.  
  838.     psrcBase = (unsigned long *)tile->devPrivate.ptr;
  839.     tileHeight = tile->drawable.height;
  840.     tileWidth = tile->drawable.width;
  841.     widthSrc = tileWidth >> PWSH;
  842.  
  843.     cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase)
  844.  
  845.     while (n--)
  846.     {
  847.     w = *pwidth++;
  848.  
  849.     /* set up source */
  850.     modulus (ppt->x - xrot, tileWidth, srcx);
  851.     modulus (ppt->y - yrot, tileHeight, srcy);
  852.     xoffSrc = srcx & PIM;
  853.     srcStart = (srcx >> PWSH);
  854.     psrcStart = psrcBase + (srcy * widthSrc);
  855.     psrcLine = psrcStart + srcStart;
  856.  
  857.     /* set up dest */
  858.     xoffDst = ppt->x & PIM;
  859.     pdstLine = pdstBase + (ppt->y * widthDst) + (ppt->x >> PWSH);
  860.     /* set up masks */
  861.     if (xoffDst + w < PPW)
  862.     {
  863.         maskpartialbits(ppt->x, w, startmask);
  864.         endmask = 0;
  865.         nlMiddle = 0;
  866.     }
  867.     else
  868.     {
  869.         maskbits (ppt->x, w, startmask, endmask, nlMiddle)
  870.     }
  871.  
  872.     if (xoffSrc == xoffDst)
  873.     {
  874.         psrc = psrcLine;
  875.         pdst = pdstLine;
  876.         srcRemaining = widthSrc - srcStart;
  877.         if (startmask)
  878.         {
  879.         *pdst = MROP_MASK (*psrc, *pdst, startmask);
  880.         pdst++;
  881.         IncSrcPtr
  882.         }
  883.         nlTemp = nlMiddle;
  884.         while (nlTemp)
  885.         {
  886.         nl = nlTemp;
  887.         if (nl > srcRemaining)
  888.             nl = srcRemaining;
  889.  
  890.         nlTemp -= nl;
  891.         srcRemaining -= nl;
  892.  
  893. #if MROP == Mcopy
  894. #ifdef LARGE_INSTRUCTION_CACHE
  895. #ifdef FAST_CONSTANT_OFFSET_MODE
  896.  
  897.         psrc += nl & (UNROLL-1);
  898.         pdst += nl & (UNROLL-1);
  899.  
  900. #define BodyOdd(n) pdst[-n] = MROP_SOLID (psrc[-n], pdst[-n]);
  901. #define BodyEven(n) pdst[-n] = MROP_SOLID (psrc[-n], pdst[-n]);
  902.  
  903. #define LoopReset \
  904. pdst += UNROLL; \
  905. psrc += UNROLL;
  906.  
  907. #else
  908.  
  909. #define BodyOdd(n)  *pdst = MROP_SOLID (*psrc, *pdst); pdst++; psrc++;
  910. #define BodyEven(n) BodyOdd(n)
  911.  
  912. #define LoopReset   ;
  913.  
  914. #endif
  915.         PackedLoop
  916.  
  917. #undef BodyOdd
  918. #undef BodyEven
  919. #undef LoopReset
  920.  
  921. #else
  922.         DuffL(nl, label1,
  923.             *pdst = MROP_SOLID (*psrc, *pdst);
  924.             pdst++; psrc++;)
  925. #endif
  926. #else
  927.         while (nl--) {
  928.             *pdst = MROP_SOLID (*psrc, *pdst);
  929.             pdst++; psrc++;
  930.         }
  931. #endif
  932.         if (!srcRemaining)
  933.         {
  934.             srcRemaining = widthSrc;
  935.             psrc = psrcStart;
  936.         }
  937.         }
  938.         if (endmask)
  939.         {
  940.         *pdst = MROP_MASK (*psrc, *pdst, endmask);
  941.         }
  942.     }
  943.     else
  944.     {
  945.         if (xoffSrc > xoffDst)
  946.         {
  947.         leftShift = (xoffSrc - xoffDst) << (5 - PWSH);
  948.         rightShift = 32 - leftShift;
  949.         }
  950.         else
  951.         {
  952.         rightShift = (xoffDst - xoffSrc) << (5 - PWSH);
  953.         leftShift = 32 - rightShift;
  954.         }
  955.         psrc = psrcLine;
  956.         pdst = pdstLine;
  957.         bits = 0;
  958.         srcRemaining = widthSrc - srcStart;
  959.         if (xoffSrc > xoffDst)
  960.         {
  961.         bits = *psrc;
  962.         IncSrcPtr
  963.         }
  964.         if (startmask)
  965.         {
  966.         bits1 = BitLeft(bits,leftShift);
  967.         bits = *psrc;
  968.         IncSrcPtr
  969.         bits1 |= BitRight(bits,rightShift);
  970.         *pdst = MROP_MASK(bits1, *pdst, startmask);
  971.         pdst++;
  972.         }
  973.         nlTemp = nlMiddle;
  974.         while (nlTemp)
  975.         {
  976.         nl = nlTemp;
  977.         if (nl > srcRemaining)
  978.             nl = srcRemaining;
  979.  
  980.         nlTemp -= nl;
  981.         srcRemaining -= nl;
  982.  
  983. #if MROP == Mcopy
  984. #ifdef LARGE_INSTRUCTION_CACHE
  985.         bits1 = bits;
  986.  
  987. #ifdef FAST_CONSTANT_OFFSET_MODE
  988.  
  989.         psrc += nl & (UNROLL-1);
  990.         pdst += nl & (UNROLL-1);
  991.  
  992. #define BodyOdd(n) \
  993. bits = psrc[-n]; \
  994. pdst[-n] = MROP_SOLID(BitLeft(bits1, leftShift) | BitRight(bits, rightShift), pdst[-n]);
  995.  
  996. #define BodyEven(n) \
  997. bits1 = psrc[-n]; \
  998. pdst[-n] = MROP_SOLID(BitLeft(bits, leftShift) | BitRight(bits1, rightShift), pdst[-n]);
  999.  
  1000. #define LoopReset \
  1001. pdst += UNROLL; \
  1002. psrc += UNROLL;
  1003.  
  1004. #else
  1005.  
  1006. #define BodyOdd(n) \
  1007. bits = *psrc++; \
  1008. *pdst = MROP_SOLID(BitLeft(bits1, leftShift) | BitRight(bits, rightShift), *pdst); \
  1009. pdst++;
  1010.            
  1011. #define BodyEven(n) \
  1012. bits1 = *psrc++; \
  1013. *pdst = MROP_SOLID(BitLeft(bits, leftShift) | BitRight(bits1, rightShift), *pdst); \
  1014. pdst++;
  1015.  
  1016. #define LoopReset   ;
  1017.  
  1018. #endif    /* !FAST_CONSTANT_OFFSET_MODE */
  1019.  
  1020.         PackedLoop
  1021.  
  1022. #undef BodyOdd
  1023. #undef BodyEven
  1024. #undef LoopReset
  1025.  
  1026. #else
  1027.         DuffL (nl,label2,
  1028.             bits1 = BitLeft(bits, leftShift);
  1029.             bits = *psrc++;
  1030.             *pdst = MROP_SOLID (bits1 | BitRight(bits, rightShift), *pdst);
  1031.             pdst++;
  1032.         )
  1033. #endif
  1034. #else
  1035.         while (nl--) {
  1036.             bits1 = BitLeft(bits,leftShift);
  1037.             bits = *psrc++;
  1038.             *pdst = MROP_SOLID(bits1|BitRight(bits,rightShift), *pdst);
  1039.             pdst++;
  1040.         }
  1041. #endif
  1042.         if (!srcRemaining)
  1043.         {
  1044.             srcRemaining = widthSrc;
  1045.             psrc = psrcStart;
  1046.         }
  1047.         }
  1048.  
  1049.         if (endmask)
  1050.         {
  1051.         bits1 = BitLeft(bits, leftShift);
  1052.         if (BitLeft(endmask, rightShift))
  1053.         {
  1054.             bits = *psrc;
  1055.             bits1 |= BitRight(bits, rightShift);
  1056.         }
  1057.         *pdst = MROP_MASK (bits1, *pdst, endmask);
  1058.         }
  1059.     }
  1060.     ppt++;
  1061.     }
  1062. }
  1063.