home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / Pascal / Snippets / PNL Libraries / Libraries / SpriteWorld / SpriteWorld files / Sources / BlitPixieAllBit.c < prev    next >
Encoding:
Text File  |  1996-10-25  |  39.7 KB  |  1,751 lines  |  [TEXT/KAHL]
  1. ///--------------------------------------------------------------------------------------
  2. //    BlitPixieAllBit.c
  3. //
  4. //  By Christofer Åkersten (chris@basesoft.se)
  5. //
  6. //    Ideas and code snippets from
  7. //        Tony Myles, Ben Sharpe, Brigham Stevens, Sean Callahan, and Joe Britt
  8. //
  9. //    Description: Implementation of a depth-independant BlitPixie
  10. ///--------------------------------------------------------------------------------------
  11.  
  12.  
  13. #ifndef __BLITPIXIE__
  14. #include "BlitPixie.h"
  15. #endif
  16.  
  17. #ifndef __SWCOMMON__
  18. #include "SWCommonHeaders.h"
  19. #endif
  20.  
  21. #ifndef __TOOLUTILS__
  22. #include <ToolUtils.h>
  23. #endif
  24.  
  25. #ifndef __OSUTILS__
  26. #include <OSUtils.h>
  27. #endif
  28.  
  29. #ifndef __QUICKDRAW__
  30. #include <Quickdraw.h>
  31. #endif
  32.  
  33. #ifndef __QDOFFSCREEN__
  34. #include <QDOffscreen.h>
  35. #endif
  36.  
  37. #ifndef __SPRITEFRAME__
  38. #include "SpriteFrame.h"
  39. #endif
  40.  
  41.  
  42. #define CLIP_RECT(r, r1, r2, interlaced) \
  43.     /* clip off the top so we don't write into random memory */ \
  44.     if (r2.top < r.top) { \
  45.         r1.top += r.top - r2.top; \
  46.         r2.top =  r.top; \
  47.     } \
  48.     /* clip off the bottom */ \
  49.     if (r2.bottom > r.bottom) {     \
  50.         r2.bottom = r.bottom;     \
  51.     }                             \
  52.     /* clip off the left */ \
  53.     if (r2.left < r.left) { \
  54.         r1.left += r.left - r2.left; \
  55.         r2.left = r.left; \
  56.     } \
  57.     /* clip off the right */ \
  58.     if (r2.right > r.right) { \
  59.         r2.right = r.right; \
  60.     } \
  61.     if (interlaced) { \
  62.         /* If first line is not on an even number, then skip it. */ \
  63.         if ((r2.top - r.top) & 1) { \
  64.             r1.top++; \
  65.             r2.top++; \
  66.         } \
  67.     } \
  68.     /* Make sure height is valid */ \
  69.     if (r2.bottom <= r2.top) \
  70.         return; \
  71.     /* Make sure width is valid */ \
  72.     if (r2.right <= r2.left) \
  73.         return;
  74.  
  75. const short bpla[] = {
  76.     5,
  77.     4,
  78.     0, 3,
  79.     0, 0, 0, 2,
  80.     0, 0, 0, 0, 0, 0, 0, 1,
  81.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  82.  
  83. #define BPL(f1, f2, b1, b2) \
  84.     if ((*f1->framePort->portPixMap)->pixelSize != (*f2->framePort->portPixMap)->pixelSize) \
  85.         return; \
  86.     b1 = bpla[(*f1->framePort->portPixMap)->pixelSize - 1]; \
  87.     b2 = 5 - b1;
  88.  
  89. #if !__MWERKS__
  90. #define Num(x) #(x)
  91. #else
  92. #define Num(x) %(x)
  93. #endif
  94.  
  95.  
  96. extern char gSWmmuMode;
  97.  
  98. ///--------------------------------------------------------------------------------------
  99. //        BlitPixieRectDrawProc
  100. ///--------------------------------------------------------------------------------------
  101. SW_FUNC void BlitPixieAllBitRectDrawProc(
  102.     FramePtr srcFrameP,
  103.     FramePtr dstFrameP,
  104.     Rect* srcRect,
  105.     Rect* dstRect)
  106. {
  107.     Rect srcBlitRect = *srcRect;
  108.     Rect dstBlitRect = *dstRect;
  109.     unsigned long numBytesPerRow;
  110.     SInt8 mmuMode;
  111.     short b1, b2;
  112.     
  113.     CLIP_RECT(dstFrameP->frameRect, srcBlitRect, dstBlitRect, false);
  114.     BPL(srcFrameP, dstFrameP, b1, b2);
  115.     if (gSWmmuMode != true32b) 
  116.     {
  117.         mmuMode = true32b;
  118.         SwapMMUMode(&mmuMode);
  119.     }
  120.     numBytesPerRow =
  121.         ((dstBlitRect.right - dstBlitRect.left) >> b1) * 4;
  122.         
  123.     BlitPixieAllBit(
  124.         (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  125.             (srcFrameP->scanLinePtrArray[srcBlitRect.top - srcFrameP->frameRect.top]) +
  126.             ((srcBlitRect.left >> b1) * 4)),
  127.         (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  128.             (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  129.             ((dstBlitRect.left >> b1) * 4)),
  130.         dstBlitRect.bottom - dstBlitRect.top,
  131.         numBytesPerRow,
  132.         srcFrameP->frameRowBytes - numBytesPerRow,
  133.         dstFrameP->frameRowBytes - numBytesPerRow,
  134.         (srcBlitRect.left << b2) & 0x1F,
  135.         (((dstFrameP->worldRectOffset + dstBlitRect.left) << b2) & 0x1F),
  136.         ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F);
  137.     if (gSWmmuMode != true32b) 
  138.     {
  139.         SwapMMUMode(&mmuMode);
  140.     }
  141. }
  142.  
  143. ///--------------------------------------------------------------------------------------
  144. //        BPAllBitInterlacedRectDrawProc
  145. ///--------------------------------------------------------------------------------------
  146. SW_FUNC void BPAllBitInterlacedRectDrawProc(
  147.     FramePtr srcFrameP,
  148.     FramePtr dstFrameP,
  149.     Rect* srcRect,
  150.     Rect* dstRect)
  151. {
  152.     Rect srcBlitRect = *srcRect;
  153.     Rect dstBlitRect = *dstRect;
  154.     unsigned long numBytesPerRow;
  155.     unsigned long numRowsToCopy;
  156.     SInt8 mmuMode;
  157.     short b1, b2;
  158.     
  159.     CLIP_RECT(dstFrameP->frameRect, srcBlitRect, dstBlitRect, true);
  160.     BPL(srcFrameP, dstFrameP, b1, b2);
  161.     // Is destBlitRect height an even number?
  162.     numRowsToCopy = dstBlitRect.bottom - dstBlitRect.top;        
  163.     numRowsToCopy = (numRowsToCopy >> 1) + (numRowsToCopy & 1);
  164.     if (numRowsToCopy < 1)
  165.         return;
  166.     if (gSWmmuMode != true32b) {
  167.         mmuMode = true32b;
  168.         SwapMMUMode(&mmuMode);
  169.     }
  170.     numBytesPerRow =
  171.         ((dstBlitRect.right - dstBlitRect.left) >> b1) * 4;
  172.     BlitPixieAllBit(
  173.         (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  174.             (srcFrameP->scanLinePtrArray[srcBlitRect.top - srcFrameP->frameRect.top]) +
  175.             ((srcBlitRect.left >> b1) * 4)),
  176.         (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  177.             (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  178.             ((dstBlitRect.left >> b1) * 4)),
  179.         numRowsToCopy,
  180.         numBytesPerRow,
  181.         (srcFrameP->frameRowBytes << 1) - numBytesPerRow,
  182.         (dstFrameP->frameRowBytes << 1) - numBytesPerRow,
  183.         (srcBlitRect.left << b2) & 0x1F,
  184.         (((dstFrameP->worldRectOffset + dstBlitRect.left) << b2) & 0x1F),
  185.         ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F);
  186.     if (gSWmmuMode != true32b) {
  187.         SwapMMUMode(&mmuMode);
  188.     }
  189. }
  190.  
  191. ///--------------------------------------------------------------------------------------
  192. //        BlitPixieAllBitMaskDrawProc
  193. ///--------------------------------------------------------------------------------------
  194. SW_FUNC void BlitPixieAllBitMaskDrawProc(
  195.     FramePtr srcFrameP,
  196.     FramePtr dstFrameP,
  197.     Rect *srcRect,
  198.     Rect *dstRect)
  199. {
  200.     Rect dstBlitRect = *dstRect;
  201.     Rect srcBlitRect = *srcRect;
  202.     unsigned long numBytesPerRow;
  203.     unsigned long srcBaseOffset;
  204.     SInt8 mmuMode;
  205.     short b1, b2;
  206.     
  207.     CLIP_RECT(dstFrameP->frameRect, srcBlitRect, dstBlitRect, false);
  208.     BPL(srcFrameP, dstFrameP, b1, b2);
  209.     if (gSWmmuMode != true32b) 
  210.     {
  211.         mmuMode = true32b;
  212.         SwapMMUMode(&mmuMode);
  213.     }
  214.     srcBaseOffset =
  215.         (srcFrameP->scanLinePtrArray[srcBlitRect.top - srcFrameP->frameRect.top]) +
  216.         ((srcBlitRect.left >> b1) * 4);
  217.     numBytesPerRow =
  218.         ((dstBlitRect.right - dstBlitRect.left) >> b1) * 4;
  219.     
  220.     if ( (*srcFrameP->framePort->portPixMap)->pixelSize < 16 )
  221.     {
  222.         BlitPixieAllBitMask(
  223.             (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  224.                 srcBaseOffset),
  225.             (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  226.                 (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  227.                 ((dstBlitRect.left >> b1) * 4)),
  228.             (PixelChunkPtr)(srcFrameP->maskBaseAddr +
  229.                 srcBaseOffset),
  230.             dstBlitRect.bottom - dstBlitRect.top,
  231.             numBytesPerRow,
  232.             srcFrameP->frameRowBytes - numBytesPerRow,
  233.             dstFrameP->frameRowBytes - numBytesPerRow,
  234.             (srcBlitRect.left << b2) & 0x1F,
  235.             (dstBlitRect.left << b2) & 0x1F,
  236.             ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F);
  237.     }
  238.     else
  239.     {
  240.         BlitPixieAllBitPartialMask(
  241.             (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  242.                 srcBaseOffset),
  243.             (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  244.                 (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  245.                 ((dstBlitRect.left >> b1) * 4)),
  246.             (PixelChunkPtr)(srcFrameP->maskBaseAddr +
  247.                 srcBaseOffset),
  248.             dstBlitRect.bottom - dstBlitRect.top,
  249.             numBytesPerRow,
  250.             srcFrameP->frameRowBytes - numBytesPerRow,
  251.             dstFrameP->frameRowBytes - numBytesPerRow,
  252.             (srcBlitRect.left << b2) & 0x1F,
  253.             (dstBlitRect.left << b2) & 0x1F,
  254.             ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F);
  255.     }
  256.     if (gSWmmuMode != true32b) {
  257.         SwapMMUMode(&mmuMode);
  258.     }
  259. }
  260.  
  261. ///--------------------------------------------------------------------------------------
  262. //        BlitPixieAllBitPartialMaskDrawProc
  263. ///--------------------------------------------------------------------------------------
  264. SW_FUNC void BlitPixieAllBitPartialMaskDrawProc(
  265.     FramePtr srcFrameP,
  266.     FramePtr dstFrameP,
  267.     Rect *srcRect,
  268.     Rect *dstRect)
  269. {
  270.     Rect dstBlitRect = *dstRect;
  271.     Rect srcBlitRect = *srcRect;
  272.     unsigned long numBytesPerRow;
  273.     unsigned long srcBaseOffset;
  274.     SInt8 mmuMode;
  275.     short b1, b2;
  276.     
  277.     CLIP_RECT(dstFrameP->frameRect, srcBlitRect, dstBlitRect, false);
  278.     BPL(srcFrameP, dstFrameP, b1, b2);
  279.     if (gSWmmuMode != true32b) 
  280.     {
  281.         mmuMode = true32b;
  282.         SwapMMUMode(&mmuMode);
  283.     }
  284.     srcBaseOffset =
  285.         (srcFrameP->scanLinePtrArray[srcBlitRect.top - srcFrameP->frameRect.top]) +
  286.         ((srcBlitRect.left >> b1) * 4);
  287.     numBytesPerRow =
  288.         ((dstBlitRect.right - dstBlitRect.left) >> b1) * 4;
  289.     BlitPixieAllBitPartialMask(
  290.         (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  291.             srcBaseOffset),
  292.         (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  293.             (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  294.             ((dstBlitRect.left >> b1) * 4)),
  295.         (PixelChunkPtr)(srcFrameP->maskBaseAddr +
  296.             srcBaseOffset),
  297.         dstBlitRect.bottom - dstBlitRect.top,
  298.         numBytesPerRow,
  299.         srcFrameP->frameRowBytes - numBytesPerRow,
  300.         dstFrameP->frameRowBytes - numBytesPerRow,
  301.         (srcBlitRect.left << b2) & 0x1F,
  302.         (dstBlitRect.left << b2) & 0x1F,
  303.         ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F);
  304.     if (gSWmmuMode != true32b) {
  305.         SwapMMUMode(&mmuMode);
  306.     }
  307. }
  308.  
  309. ///--------------------------------------------------------------------------------------
  310. //        BPAllBitInterlacedMaskDrawProc
  311. ///--------------------------------------------------------------------------------------
  312. SW_FUNC void BPAllBitInterlacedMaskDrawProc(
  313.     FramePtr srcFrameP,
  314.     FramePtr dstFrameP,
  315.     Rect* srcRect,
  316.     Rect* dstRect)
  317. {
  318.     Rect srcBlitRect = *srcRect;
  319.     Rect dstBlitRect = *dstRect;
  320.     unsigned long numBytesPerRow;
  321.     unsigned long numRowsToCopy;
  322.     unsigned long srcBaseOffset;
  323.     SInt8 mmuMode;
  324.     short b1, b2;
  325.     
  326.     CLIP_RECT(dstFrameP->frameRect, srcBlitRect, dstBlitRect, true);
  327.     BPL(srcFrameP, dstFrameP, b1, b2);
  328.     // Is destBlitRect height an even number?
  329.     numRowsToCopy = dstBlitRect.bottom - dstBlitRect.top;        
  330.     numRowsToCopy = (numRowsToCopy >> 1) + (numRowsToCopy & 1);
  331.     if (numRowsToCopy < 1)
  332.         return;
  333.     if (gSWmmuMode != true32b) {
  334.         mmuMode = true32b;
  335.         SwapMMUMode(&mmuMode);
  336.     }
  337.     srcBaseOffset =
  338.         (srcFrameP->scanLinePtrArray[srcBlitRect.top - srcFrameP->frameRect.top]) +
  339.         ((srcBlitRect.left >> b1) * 4);
  340.     numBytesPerRow =
  341.         ((dstBlitRect.right - dstBlitRect.left) >> b1) * 4;
  342.     
  343.     if ( (*srcFrameP->framePort->portPixMap)->pixelSize < 16 )
  344.     {
  345.         BlitPixieAllBitMask(
  346.             (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  347.                 srcBaseOffset),
  348.             (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  349.                 (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  350.                 ((dstBlitRect.left >> b1) * 4)),
  351.             (PixelChunkPtr)(srcFrameP->maskBaseAddr +
  352.                 srcBaseOffset),
  353.             numRowsToCopy,
  354.             numBytesPerRow,
  355.             (srcFrameP->frameRowBytes << 1) - numBytesPerRow,
  356.             (dstFrameP->frameRowBytes << 1) - numBytesPerRow,
  357.             (srcBlitRect.left << b2) & 0x1F,
  358.             (dstBlitRect.left << b2) & 0x1F,
  359.             ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F);
  360.     }
  361.     else
  362.     {
  363.         BlitPixieAllBitPartialMask(
  364.             (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  365.                 srcBaseOffset),
  366.             (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  367.                 (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  368.                 ((dstBlitRect.left >> b1) * 4)),
  369.             (PixelChunkPtr)(srcFrameP->maskBaseAddr +
  370.                 srcBaseOffset),
  371.             numRowsToCopy,
  372.             numBytesPerRow,
  373.             (srcFrameP->frameRowBytes << 1) - numBytesPerRow,
  374.             (dstFrameP->frameRowBytes << 1) - numBytesPerRow,
  375.             (srcBlitRect.left << b2) & 0x1F,
  376.             (dstBlitRect.left << b2) & 0x1F,
  377.             ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F);
  378.     }
  379.     if (gSWmmuMode != true32b) {
  380.         SwapMMUMode(&mmuMode);
  381.     }
  382. }
  383.  
  384. ///--------------------------------------------------------------------------------------
  385. //        BPAllBitInterlacedPartialMaskDrawProc
  386. ///--------------------------------------------------------------------------------------
  387. SW_FUNC void BPAllBitInterlacedPartialMaskDrawProc(
  388.     FramePtr srcFrameP,
  389.     FramePtr dstFrameP,
  390.     Rect* srcRect,
  391.     Rect* dstRect)
  392. {
  393.     Rect srcBlitRect = *srcRect;
  394.     Rect dstBlitRect = *dstRect;
  395.     unsigned long numBytesPerRow;
  396.     unsigned long numRowsToCopy;
  397.     unsigned long srcBaseOffset;
  398.     SInt8 mmuMode;
  399.     short b1, b2;
  400.     
  401.     CLIP_RECT(dstFrameP->frameRect, srcBlitRect, dstBlitRect, true);
  402.     BPL(srcFrameP, dstFrameP, b1, b2);
  403.     // Is destBlitRect height an even number?
  404.     numRowsToCopy = dstBlitRect.bottom - dstBlitRect.top;        
  405.     numRowsToCopy = (numRowsToCopy >> 1) + (numRowsToCopy & 1);
  406.     if (numRowsToCopy < 1)
  407.         return;
  408.     if (gSWmmuMode != true32b) {
  409.         mmuMode = true32b;
  410.         SwapMMUMode(&mmuMode);
  411.     }
  412.     srcBaseOffset =
  413.         (srcFrameP->scanLinePtrArray[srcBlitRect.top - srcFrameP->frameRect.top]) +
  414.         ((srcBlitRect.left >> b1) * 4);
  415.     numBytesPerRow =
  416.         ((dstBlitRect.right - dstBlitRect.left) >> b1) * 4;
  417.     BlitPixieAllBitPartialMask(
  418.         (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  419.             srcBaseOffset),
  420.         (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  421.             (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  422.             ((dstBlitRect.left >> b1) * 4)),
  423.         (PixelChunkPtr)(srcFrameP->maskBaseAddr +
  424.             srcBaseOffset),
  425.         numRowsToCopy,
  426.         numBytesPerRow,
  427.         (srcFrameP->frameRowBytes << 1) - numBytesPerRow,
  428.         (dstFrameP->frameRowBytes << 1) - numBytesPerRow,
  429.         (srcBlitRect.left << b2) & 0x1F,
  430.         (dstBlitRect.left << b2) & 0x1F,
  431.         ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F);
  432.     if (gSWmmuMode != true32b) {
  433.         SwapMMUMode(&mmuMode);
  434.     }
  435. }
  436.  
  437. #if !XSW_USE_C
  438.  
  439. #define srcExtraStartTemp    srcExtraStart
  440. #define dstExtraStartTemp    dstExtraStart
  441. #define dstExtraEndTemp        dstExtraEnd
  442. #define dstRowStrideTemp    dstRowStride
  443.  
  444. #define UNROLL(start, end) \
  445.     move.l    d1, d0; \
  446.     lsr.l    Num(4), d1; \
  447.     moveq    Num(0x0F), d2; \
  448.     and.l    d2, d0; \
  449.     \
  450.     lea        end, a0; \
  451.     lea        start, a1; \
  452.     sub.l    a0, a1; \
  453.     move.l    a1, d2; \
  454.     asr.l    Num(4), d2; \
  455.     mulu.l    d2, d0; \
  456.     add.l    d0, a0;
  457.  
  458. #define REPEAT(instr) \
  459.     instr; \
  460.     instr; \
  461.     instr; \
  462.     instr; \
  463.     instr; \
  464.     instr; \
  465.     instr; \
  466.     instr; \
  467.     instr; \
  468.     instr; \
  469.     instr; \
  470.     instr; \
  471.     instr; \
  472.     instr; \
  473.     instr; \
  474.     instr;
  475.  
  476. ///--------------------------------------------------------------------------------------
  477. //        BlitPixieAllBit
  478. ///--------------------------------------------------------------------------------------
  479. SW_ASM_FUNC void BlitPixieAllBit(
  480.     register PixelPtr srcPixelP,
  481.     register PixelPtr dstPixelP,
  482.     unsigned long rowsToCopy,
  483.     unsigned long numBytesPerRow,
  484.     register unsigned long srcRowStride,
  485.     register unsigned long dstRowStride,
  486.     register unsigned long srcExtraStart,
  487.     register unsigned long dstExtraStart,
  488.     register unsigned long dstExtraEnd)
  489. {
  490.         SW_ASM_BEGIN
  491.         
  492. #if __MWERKS__
  493.         fralloc +
  494. #endif
  495.         
  496.         move.l    numBytesPerRow, d1
  497.         lsr.l    Num(2), d1
  498.         beq        @VeryNarrow
  499.         
  500.         tst.l    srcExtraStart
  501.         bne        @SrcExtraStart
  502.         
  503.         tst.l    dstExtraStart
  504.         bne        @DstExtraStart
  505.         
  506.     @NoExtraStart:
  507.         tst.l    dstExtraEnd
  508.         beq        @EvenEven
  509.         bra        @EvenEvenExtra
  510.         
  511.     @DstExtraStart:
  512.         move.l    dstExtraStart, d0
  513.         and.l    Num(0x07), d0
  514.         beq        @ADstExtraStart
  515.         
  516.         tst.l    dstExtraEnd
  517.         beq        @EvenOdd
  518.         bra        @EvenOddExtra
  519.         
  520.     @ADstExtraStart:
  521.         move.l    dstExtraStart, d0
  522.         lsr.l    Num(3), d0
  523.         add.l    d0, dstPixelP
  524.         tst.l    dstExtraEnd
  525.         beq        @EvenEven
  526.         bra        @EvenEvenExtra
  527.         
  528.     @SrcExtraStart:
  529.         tst.l    dstExtraStart
  530.         bne        @SrcDstExtraStart
  531.     @NoDstExtraStart:
  532.         move.l    srcExtraStart, d0
  533.         and.l    Num(0x07), d0
  534.         beq        @ASrcExtraStart
  535.         
  536.         tst.l    dstExtraEnd
  537.         beq        @OddEven
  538.         bra        @OddEvenExtra
  539.         
  540.     @ASrcExtraStart:
  541.         move.l    srcExtraStart, d0
  542.         lsr.l    Num(3), d0
  543.         add.l    d0, srcPixelP
  544.         tst.l    dstExtraEnd
  545.         beq        @EvenEven
  546.         bra        @EvenEvenExtra
  547.         
  548.     @SrcDstExtraStart:
  549.         move.l    srcExtraStart, d0
  550.         and.l    Num(0x07), d0
  551.         beq        @ASrcDstExtraStart
  552.         move.l    dstExtraStart, d0
  553.         and.l    Num(0x07), d0
  554.         beq        @ADstSrcExtraStart
  555.         
  556.         tst.l    dstExtraEnd
  557.         beq        @OddOdd
  558.         bra        @OddOddExtra
  559.         
  560.     @ASrcDstExtraStart:
  561.         move.l    dstExtraStart, d0
  562.         and.l    Num(0x07), d0
  563.         beq        @AASrcDstExtraStart
  564.         
  565.         move.l    srcExtraStart, d0
  566.         lsr.l    Num(3), d0
  567.         add.l    d0, srcPixelP
  568.         tst.l    dstExtraEnd
  569.         beq        @EvenOdd
  570.         bra        @EvenOddExtra
  571.         
  572.     @ADstSrcExtraStart:
  573.         move.l    dstExtraStart, d0
  574.         lsr.l    Num(3), d0
  575.         add.l    d0, dstPixelP
  576.         tst.l    dstExtraEnd
  577.         beq        @OddEven
  578.         bra        @OddEvenExtra
  579.         
  580.     @AASrcDstExtraStart:
  581.         move.l    srcExtraStart, d0
  582.         lsr.l    Num(3), d0
  583.         add.l    d0, srcPixelP
  584.         move.l    dstExtraStart, d0
  585.         lsr.l    Num(3), d0
  586.         add.l    d0, dstPixelP
  587.         tst.l    dstExtraEnd
  588.         beq        @EvenEven
  589.         bra        @EvenEvenExtra
  590.         
  591.     @EvenEven:
  592. // START Even -> Even
  593.         UNROLL(@EE_ColLoop, @EE_ColLoop_End)
  594.         
  595.         move.l    rowsToCopy, d2
  596.     @EE_RowLoop:
  597.         move.l    d1, d0
  598.         jmp        (a0)
  599.     @EE_ColLoop:
  600. // BLIT
  601. #define    BLIT \
  602.         move.l    (srcPixelP)+, (dstPixelP)+;
  603.         REPEAT(BLIT)
  604. #undef    BLIT
  605.     @EE_ColLoop_End:
  606.         
  607.         subq.l    Num(1), d0
  608.         bpl        @EE_ColLoop
  609.         
  610.         adda.l    srcRowStride, srcPixelP
  611.         adda.l    dstRowStride, dstPixelP
  612.         
  613.         subq.l    Num(1), d2
  614.         bgt        @EE_RowLoop
  615. // STOP
  616.         bra        @Done
  617.     @EvenEvenExtra:
  618. // START Even -> Even + Extra
  619.         UNROLL(@EEE_ColLoop, @EEE_ColLoop_End)
  620.         
  621.         move.l    rowsToCopy, d2
  622.     @EEE_RowLoop:
  623.         move.l    d1, d0
  624.         jmp        (a0)
  625.     @EEE_ColLoop:
  626. // BLIT
  627. #define    BLIT \
  628.         move.l    (srcPixelP)+, (dstPixelP)+;
  629.         REPEAT(BLIT)
  630. #undef    BLIT
  631.     @EEE_ColLoop_End:
  632.         
  633.         subq.l    Num(1), d0
  634.         bpl        @EEE_ColLoop
  635. // BLIT EXTRA
  636.         bfextu    (srcPixelP){0:dstExtraEnd}, d0
  637.         bfins    d0, (dstPixelP){0:dstExtraEnd}
  638.         
  639.         adda.l    srcRowStride, srcPixelP
  640.         adda.l    dstRowStride, dstPixelP
  641.         
  642.         subq.l    Num(1), d2
  643.         bgt        @EEE_RowLoop
  644. // STOP
  645.         bra        @Done
  646.         
  647.     @EvenOdd:
  648. // START Even -> Odd
  649.         UNROLL(@EO_ColLoop, @EO_ColLoop_End)
  650.         
  651.         move.l    rowsToCopy, d2
  652.     @EO_RowLoop:
  653.         move.l    d1, d0
  654.         jmp        (a0)
  655.     @EO_ColLoop:
  656. // BLIT
  657. #define    BLIT \
  658.         move.l    (srcPixelP)+, srcExtraStartTemp; \
  659.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:0}; \
  660.         addq.l    Num(4), dstPixelP;
  661.         REPEAT(BLIT)
  662. #undef    BLIT
  663.     @EO_ColLoop_End:
  664.         
  665.         subq.l    Num(1), d0
  666.         bpl        @EO_ColLoop
  667.         
  668.         adda.l    srcRowStride, srcPixelP
  669.         adda.l    dstRowStride, dstPixelP
  670.         
  671.         subq.l    Num(1), d2
  672.         bgt        @EO_RowLoop
  673. // STOP
  674.         bra        @Done
  675.     @EvenOddExtra:
  676. // START Even -> Odd + Extra
  677.         UNROLL(@EOE_ColLoop, @EOE_ColLoop_End)
  678.         
  679.         move.l    rowsToCopy, d2
  680.     @EOE_RowLoop:
  681.         move.l    d1, d0
  682.         jmp        (a0)
  683.     @EOE_ColLoop:
  684. // BLIT
  685. #define    BLIT \
  686.         move.l    (srcPixelP)+, srcExtraStartTemp; \
  687.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:0}; \
  688.         addq.l    Num(4), dstPixelP;
  689.         REPEAT(BLIT)
  690. #undef    BLIT
  691.     @EOE_ColLoop_End:
  692.         
  693.         subq.l    Num(1), d0
  694.         bpl        @EOE_ColLoop
  695. //BLIT EXTRA
  696.         bfextu    (srcPixelP){0:dstExtraEnd}, srcExtraStartTemp
  697.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:dstExtraEnd}
  698.         
  699.         adda.l    srcRowStride, srcPixelP
  700.         adda.l    dstRowStride, dstPixelP
  701.         
  702.         subq.l    Num(1), d2
  703.         bgt        @EOE_RowLoop
  704. // STOP
  705.         bra        @Done
  706.         
  707.     @OddEven:
  708. // START Odd -> Even
  709.         UNROLL(@OE_ColLoop, @OE_ColLoop_End)
  710.         
  711.         move.l    rowsToCopy, d2
  712.     @OE_RowLoop:
  713.         move.l    d1, d0
  714.         jmp        (a0)
  715.     @OE_ColLoop:
  716. // BLIT
  717. #define    BLIT \
  718.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  719.         move.l    dstExtraStartTemp, (dstPixelP)+; \
  720.         addq.l    Num(4), srcPixelP;
  721.         REPEAT(BLIT)
  722. #undef    BLIT
  723.     @OE_ColLoop_End:
  724.         
  725.         subq.l    Num(1), d0
  726.         bpl        @OE_ColLoop
  727.         
  728.         adda.l    srcRowStride, srcPixelP
  729.         adda.l    dstRowStride, dstPixelP
  730.         
  731.         subq.l    Num(1), d2
  732.         bgt        @OE_RowLoop
  733. // STOP
  734.         bra        @Done
  735.     @OddEvenExtra:
  736. // START Odd -> Even + Extra
  737.         UNROLL(@OEE_ColLoop, @OEE_ColLoop_End)
  738.         
  739.         move.l    rowsToCopy, d2
  740.     @OEE_RowLoop:
  741.         move.l    d1, d0
  742.         jmp        (a0)
  743.     @OEE_ColLoop:
  744. // BLIT
  745. #define    BLIT \
  746.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  747.         move.l    dstExtraStartTemp, (dstPixelP)+; \
  748.         addq.l    Num(4), srcPixelP;
  749.         REPEAT(BLIT)
  750. #undef    BLIT
  751.     @OEE_ColLoop_End:
  752.         
  753.         subq.l    Num(1), d0
  754.         bpl        @OEE_ColLoop
  755. // BLIT EXTRA
  756.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, dstExtraStartTemp
  757.         bfins    dstExtraStartTemp, (dstPixelP){0:dstExtraEnd}
  758.         
  759.         adda.l    srcRowStride, srcPixelP
  760.         adda.l    dstRowStride, dstPixelP
  761.         
  762.         subq.l    Num(1), d2
  763.         bgt        @OEE_RowLoop
  764. // STOP
  765.         bra        @Done
  766.         
  767.     @OddOdd:
  768. // START Odd -> Odd
  769.         UNROLL(@OO_ColLoop, @OO_ColLoop_End)
  770.         
  771.         move.l    rowsToCopy, d2
  772.     @OO_RowLoop:
  773.         move.l    d1, d0
  774.         jmp        (a0)
  775.     @OO_ColLoop:
  776. // BLIT
  777. #define    BLIT \
  778.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraEndTemp; \
  779.         bfins    dstExtraEndTemp, (dstPixelP){dstExtraStart:0}; \
  780.         addq.l    Num(4), srcPixelP; \
  781.         addq.l    Num(4), dstPixelP;
  782.         REPEAT(BLIT)
  783. #undef    BLIT
  784.     @OO_ColLoop_End:
  785.         
  786.         subq.l    Num(1), d0
  787.         bpl        @OO_ColLoop
  788.         
  789.         adda.l    srcRowStride, srcPixelP
  790.         adda.l    dstRowStride, dstPixelP
  791.         
  792.         subq.l    Num(1), d2
  793.         bgt        @OO_RowLoop
  794. // STOP
  795.         bra        @Done
  796.     @OddOddExtra:
  797. // START Odd -> Odd + Extra
  798.         UNROLL(@OOE_ColLoop, @OOE_ColLoop_End)
  799.         
  800.     @OOE_RowLoop:
  801.         move.l    d1, d0
  802.         jmp        (a0)
  803.     @OOE_ColLoop:
  804. // BLIT
  805. #define    BLIT \
  806.         bfextu    (srcPixelP){srcExtraStart:0}, d2; \
  807.         bfins    d2, (dstPixelP){dstExtraStart:0}; \
  808.         addq.l    Num(4), srcPixelP; \
  809.         addq.l    Num(4), dstPixelP;
  810.         REPEAT(BLIT)
  811. #undef    BLIT
  812.     @OOE_ColLoop_End:
  813.         
  814.         subq.l    Num(1), d0
  815.         bpl        @OOE_ColLoop
  816. // BLIT EXTRA
  817.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d2
  818.         bfins    d2, (dstPixelP){dstExtraStart:dstExtraEnd}
  819.         
  820.         adda.l    srcRowStride, srcPixelP
  821.         adda.l    dstRowStride, dstPixelP
  822.         
  823.         subq.l    Num(1), rowsToCopy
  824.         bgt        @OOE_RowLoop
  825. // STOP
  826.         bra        @Done
  827.         
  828.     @VeryNarrow:
  829. // START Very Narrow
  830.         move.l    rowsToCopy, d2
  831.     @VN_RowLoop:
  832. // BLIT
  833.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d0
  834.         bfins    d0, (dstPixelP){dstExtraStart:dstExtraEnd}
  835.         
  836.         adda.l    srcRowStride, srcPixelP
  837.         adda.l    dstRowStride, dstPixelP
  838.         
  839.         subq.l    Num(1), d2
  840.         bgt        @VN_RowLoop
  841. // STOP
  842.         
  843.     @Done:
  844.         
  845. #if __MWERKS__
  846.         frfree
  847. #endif
  848.         
  849.         SW_ASM_END
  850. }
  851.  
  852. ///--------------------------------------------------------------------------------------
  853. //        BlitPixieAllBitMask
  854. ///--------------------------------------------------------------------------------------
  855. SW_ASM_FUNC void BlitPixieAllBitMask(
  856.     register PixelPtr srcPixelP,
  857.     register PixelPtr dstPixelP,
  858.     register PixelPtr maskPixelP,
  859.     unsigned long rowsToCopy,
  860.     unsigned long numBytesPerRow,
  861.     register unsigned long srcRowStride,
  862.     register unsigned long dstRowStride,
  863.     register unsigned long srcExtraStart,
  864.     register unsigned long dstExtraStart,
  865.     register unsigned long dstExtraEnd)
  866. {
  867.         SW_ASM_BEGIN
  868.         
  869. #if __MWERKS__
  870.         fralloc +
  871. #endif
  872.         
  873.         move.l    numBytesPerRow, d1
  874.         lsr.l    Num(2), d1
  875.         beq        @VeryNarrow
  876.         
  877.         tst.l    srcExtraStart
  878.         bne        @SrcExtraStart
  879.         
  880.         tst.l    dstExtraStart
  881.         bne        @DstExtraStart
  882.         
  883.     @NoExtraStart:
  884.         tst.l    dstExtraEnd
  885.         beq        @EvenEven
  886.         bra        @EvenEvenExtra
  887.         
  888.     @DstExtraStart:
  889.         move.l    dstExtraStart, d0
  890.         and.l    Num(0x07), d0
  891.         beq        @ADstExtraStart
  892.         
  893.         tst.l    dstExtraEnd
  894.         beq        @EvenOdd
  895.         bra        @EvenOddExtra
  896.         
  897.     @ADstExtraStart:
  898.         move.l    dstExtraStart, d0
  899.         lsr.l    Num(3), d0
  900.         add.l    d0, dstPixelP
  901.         tst.l    dstExtraEnd
  902.         beq        @EvenEven
  903.         bra        @EvenEvenExtra
  904.         
  905.     @SrcExtraStart:
  906.         tst.l    dstExtraStart
  907.         bne        @SrcDstExtraStart
  908.     @NoDstExtraStart:
  909.         move.l    srcExtraStart, d0
  910.         and.l    Num(0x07), d0
  911.         beq        @ASrcExtraStart
  912.         
  913.         tst.l    dstExtraEnd
  914.         beq        @OddEven
  915.         bra        @OddEvenExtra
  916.         
  917.     @ASrcExtraStart:
  918.         move.l    srcExtraStart, d0
  919.         lsr.l    Num(3), d0
  920.         add.l    d0, srcPixelP
  921.         add.l    d0, maskPixelP
  922.         tst.l    dstExtraEnd
  923.         beq        @EvenEven
  924.         bra        @EvenEvenExtra
  925.         
  926.     @SrcDstExtraStart:
  927.         move.l    srcExtraStart, d0
  928.         and.l    Num(0x07), d0
  929.         beq        @ASrcDstExtraStart
  930.         move.l    dstExtraStart, d0
  931.         and.l    Num(0x07), d0
  932.         beq        @ADstSrcExtraStart
  933.         
  934.         tst.l    dstExtraEnd
  935.         beq        @OddOdd
  936.         bra        @OddOddExtra
  937.         
  938.     @ASrcDstExtraStart:
  939.         move.l    dstExtraStart, d0
  940.         and.l    Num(0x07), d0
  941.         beq        @AASrcDstExtraStart
  942.         
  943.         move.l    srcExtraStart, d0
  944.         lsr.l    Num(3), d0
  945.         add.l    d0, srcPixelP
  946.         add.l    d0, maskPixelP
  947.         tst.l    dstExtraEnd
  948.         beq        @EvenOdd
  949.         bra        @EvenOddExtra
  950.         
  951.     @ADstSrcExtraStart:
  952.         move.l    dstExtraStart, d0
  953.         lsr.l    Num(3), d0
  954.         add.l    d0, dstPixelP
  955.         tst.l    dstExtraEnd
  956.         beq        @OddEven
  957.         bra        @OddEvenExtra
  958.         
  959.     @AASrcDstExtraStart:
  960.         move.l    srcExtraStart, d0
  961.         lsr.l    Num(3), d0
  962.         add.l    d0, srcPixelP
  963.         add.l    d0, maskPixelP
  964.         move.l    dstExtraStart, d0
  965.         lsr.l    Num(3), d0
  966.         add.l    d0, dstPixelP
  967.         tst.l    dstExtraEnd
  968.         beq        @EvenEven
  969.         bra        @EvenEvenExtra
  970.         
  971.     @EvenEven:
  972. // START Even -> Even
  973.         UNROLL(@EE_ColLoop, @EE_ColLoop_End)
  974.         
  975.         move.l    rowsToCopy, d2
  976.     @EE_RowLoop:
  977.         move.l    d1, d0
  978.         jmp        (a0)
  979.     @EE_ColLoop:
  980. // BLIT
  981. #define    BLIT \
  982.         move.l    (dstPixelP), dstExtraEndTemp; \
  983.         and.l    (maskPixelP)+, dstExtraEndTemp; \
  984.         or.l    (srcPixelP)+, dstExtraEndTemp; \
  985.         move.l    dstExtraEndTemp, (dstPixelP)+;
  986.         REPEAT(BLIT)
  987. #undef    BLIT
  988.     @EE_ColLoop_End:
  989.         
  990.         subq.l    Num(1), d0
  991.         bpl        @EE_ColLoop
  992.         
  993.         adda.l    srcRowStride, srcPixelP
  994.         adda.l    dstRowStride, dstPixelP
  995.         adda.l    srcRowStride, maskPixelP
  996.         
  997.         subq.l    Num(1), d2
  998.         bgt        @EE_RowLoop
  999. // STOP
  1000.         bra        @Done
  1001.     @EvenEvenExtra:
  1002. // START Even -> Even + Extra
  1003.         UNROLL(@EEE_ColLoop, @EEE_ColLoop_End)
  1004.         
  1005.         move.l    rowsToCopy, d2
  1006.     @EEE_RowLoop:
  1007.         move.l    d1, d0
  1008.         jmp        (a0)
  1009.     @EEE_ColLoop:
  1010. // BLIT
  1011. #define    BLIT \
  1012.         move.l    (dstPixelP), srcExtraStartTemp; \
  1013.         and.l    (maskPixelP)+, srcExtraStartTemp; \
  1014.         or.l    (srcPixelP)+, srcExtraStartTemp; \
  1015.         move.l    srcExtraStartTemp, (dstPixelP)+;
  1016.         REPEAT(BLIT)
  1017. #undef    BLIT
  1018.     @EEE_ColLoop_End:
  1019.         
  1020.         subq.l    Num(1), d0
  1021.         bpl        @EEE_ColLoop
  1022. // BLIT EXTRA
  1023.         bfextu    (dstPixelP){0:dstExtraEnd}, srcExtraStartTemp
  1024.         bfextu    (maskPixelP){0:dstExtraEnd}, dstExtraStartTemp
  1025.         and.l    dstExtraStartTemp, srcExtraStartTemp
  1026.         bfextu    (srcPixelP){0:dstExtraEnd}, dstExtraStartTemp
  1027.         or.l    dstExtraStartTemp, srcExtraStartTemp
  1028.         bfins    srcExtraStartTemp, (dstPixelP){0:dstExtraEnd}
  1029.         
  1030.         adda.l    srcRowStride, srcPixelP
  1031.         adda.l    dstRowStride, dstPixelP
  1032.         adda.l    srcRowStride, maskPixelP
  1033.         
  1034.         subq.l    Num(1), d2
  1035.         bgt        @EEE_RowLoop
  1036. // STOP
  1037.         bra        @Done
  1038.         
  1039.     @EvenOdd:
  1040. // START Even -> Odd
  1041.         UNROLL(@EO_ColLoop, @EO_ColLoop_End)
  1042.         
  1043.         move.l    rowsToCopy, d2
  1044.     @EO_RowLoop:
  1045.         move.l    d1, d0
  1046.         jmp        (a0)
  1047.     @EO_ColLoop:
  1048. // BLIT
  1049. #define    BLIT \
  1050.         bfextu    (dstPixelP){dstExtraStart:0}, srcExtraStartTemp; \
  1051.         and.l    (maskPixelP)+, srcExtraStartTemp; \
  1052.         or.l    (srcPixelP)+, srcExtraStartTemp; \
  1053.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:0}; \
  1054.         addq.l    Num(4), dstPixelP;
  1055.         REPEAT(BLIT)
  1056. #undef    BLIT
  1057.     @EO_ColLoop_End:
  1058.         
  1059.         subq.l    Num(1), d0
  1060.         bpl        @EO_ColLoop
  1061.         
  1062.         adda.l    srcRowStride, srcPixelP
  1063.         adda.l    dstRowStride, dstPixelP
  1064.         adda.l    srcRowStride, maskPixelP
  1065.         
  1066.         subq.l    Num(1), d2
  1067.         bgt        @EO_RowLoop
  1068. // STOP
  1069.         bra        @Done
  1070.     @EvenOddExtra:
  1071. // START Even -> Odd + Extra
  1072.         UNROLL(@EOE_ColLoop, @EOE_ColLoop_End)
  1073.         
  1074.         move.l    rowsToCopy, d2
  1075.     @EOE_RowLoop:
  1076.         move.l    d1, d0
  1077.         jmp        (a0)
  1078.     @EOE_ColLoop:
  1079. // BLIT
  1080. #define    BLIT \
  1081.         bfextu    (dstPixelP){dstExtraStart:0}, srcExtraStartTemp; \
  1082.         and.l    (maskPixelP)+, srcExtraStartTemp; \
  1083.         or.l    (srcPixelP)+, srcExtraStartTemp; \
  1084.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:0}; \
  1085.         addq.l    Num(4), dstPixelP;
  1086.         REPEAT(BLIT)
  1087. #undef    BLIT
  1088.     @EOE_ColLoop_End:
  1089.         
  1090.         subq.l    Num(1), d0
  1091.         bpl        @EOE_ColLoop
  1092. //BLIT EXTRA
  1093.         bfextu    (dstPixelP){dstExtraStart:dstExtraEnd}, srcExtraStartTemp
  1094.         bfextu    (maskPixelP){0:dstExtraEnd}, d0
  1095.         and.l    d0, srcExtraStartTemp
  1096.         bfextu    (srcPixelP){0:dstExtraEnd}, d0
  1097.         or.l    d0, srcExtraStartTemp
  1098.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:dstExtraEnd}
  1099.         
  1100.         adda.l    srcRowStride, srcPixelP
  1101.         adda.l    dstRowStride, dstPixelP
  1102.         adda.l    srcRowStride, maskPixelP
  1103.         
  1104.         subq.l    Num(1), d2
  1105.         bgt        @EOE_RowLoop
  1106. // STOP
  1107.         bra        @Done
  1108.         
  1109.     @OddEven:
  1110. // START Odd -> Even
  1111.         UNROLL(@OE_ColLoop, @OE_ColLoop_End)
  1112.         
  1113.         move.l    rowsToCopy, d2
  1114.     @OE_RowLoop:
  1115.         move.l    d1, d0
  1116.         jmp        (a0)
  1117.     @OE_ColLoop:
  1118. // BLIT
  1119. #define    BLIT \
  1120.         bfextu    (maskPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1121.         and.l    dstExtraStartTemp, (dstPixelP); \
  1122.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1123.         or.l    dstExtraStartTemp, (dstPixelP)+; \
  1124.         addq.l    Num(4), srcPixelP; \
  1125.         addq.l    Num(4), maskPixelP;
  1126.         REPEAT(BLIT)
  1127. #undef    BLIT
  1128.     @OE_ColLoop_End:
  1129.         
  1130.         subq.l    Num(1), d0
  1131.         bpl        @OE_ColLoop
  1132.         
  1133.         adda.l    srcRowStride, srcPixelP
  1134.         adda.l    dstRowStride, dstPixelP
  1135.         adda.l    srcRowStride, maskPixelP
  1136.         
  1137.         subq.l    Num(1), d2
  1138.         bgt        @OE_RowLoop
  1139. // STOP
  1140.         bra        @Done
  1141.     @OddEvenExtra:
  1142. // START Odd -> Even + Extra
  1143.         UNROLL(@OEE_ColLoop, @OEE_ColLoop_End)
  1144.         
  1145.         move.l    rowsToCopy, d2
  1146.     @OEE_RowLoop:
  1147.         move.l    d1, d0
  1148.         jmp        (a0)
  1149.     @OEE_ColLoop:
  1150. // BLIT
  1151. #define    BLIT \
  1152.         bfextu    (maskPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1153.         and.l    dstExtraStartTemp, (dstPixelP); \
  1154.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1155.         or.l    dstExtraStartTemp, (dstPixelP)+; \
  1156.         addq.l    Num(4), srcPixelP; \
  1157.         addq.l    Num(4), maskPixelP;
  1158.         REPEAT(BLIT)
  1159. #undef    BLIT
  1160.     @OEE_ColLoop_End:
  1161.         
  1162.         subq.l    Num(1), d0
  1163.         bpl        @OEE_ColLoop
  1164. // BLIT EXTRA
  1165.         bfextu    (dstPixelP){0:dstExtraEnd}, d0
  1166.         bfextu    (maskPixelP){srcExtraStart:dstExtraEnd}, dstExtraStartTemp
  1167.         and.l    dstExtraStartTemp, d0
  1168.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, dstExtraStartTemp
  1169.         or.l    dstExtraStartTemp, d0
  1170.         bfins    d0, (dstPixelP){0:dstExtraEnd}
  1171.         
  1172.         adda.l    srcRowStride, srcPixelP
  1173.         adda.l    dstRowStride, dstPixelP
  1174.         adda.l    srcRowStride, maskPixelP
  1175.         
  1176.         subq.l    Num(1), d2
  1177.         bgt        @OEE_RowLoop
  1178. // STOP
  1179.         bra        @Done
  1180.         
  1181.     @OddOdd:
  1182. // START Odd -> Odd
  1183.         UNROLL(@OO_ColLoop, @OO_ColLoop_End)
  1184.         
  1185.     @OO_RowLoop:
  1186.         move.l    d1, d0
  1187.         jmp        (a0)
  1188.     @OO_ColLoop:
  1189. // BLIT
  1190. #define    BLIT \
  1191.         bfextu    (dstPixelP){dstExtraStart:0}, dstExtraEndTemp; \
  1192.         bfextu    (maskPixelP){srcExtraStart:0}, d2; \
  1193.         and.l    d2, dstExtraEndTemp; \
  1194.         bfextu    (srcPixelP){srcExtraStart:0}, d2; \
  1195.         or.l    d2, dstExtraEndTemp; \
  1196.         bfins    dstExtraEndTemp, (dstPixelP){dstExtraStart:0}; \
  1197.         addq.l    Num(4), srcPixelP; \
  1198.         addq.l    Num(4), dstPixelP; \
  1199.         addq.l    Num(4), maskPixelP;
  1200.         REPEAT(BLIT)
  1201. #undef    BLIT
  1202.     @OO_ColLoop_End:
  1203.         
  1204.         subq.l    Num(1), d0
  1205.         bpl        @OO_ColLoop
  1206.         
  1207.         adda.l    srcRowStride, srcPixelP
  1208.         adda.l    dstRowStride, dstPixelP
  1209.         adda.l    srcRowStride, maskPixelP
  1210.         
  1211.         subq.l    Num(1), rowsToCopy
  1212.         bgt        @OO_RowLoop
  1213. // STOP
  1214.         bra        @Done
  1215.     @OddOddExtra:
  1216. // START Odd -> Odd + Extra
  1217.         UNROLL(@OOE_ColLoop, @OOE_ColLoop_End)
  1218.         
  1219.         move.l    d1, numBytesPerRow
  1220.     @OOE_RowLoop:
  1221.         move.l    numBytesPerRow, d0
  1222.         jmp        (a0)
  1223.     @OOE_ColLoop:
  1224. // BLIT
  1225. #define    BLIT \
  1226.         bfextu    (dstPixelP){dstExtraStart:0}, d1; \
  1227.         bfextu    (maskPixelP){srcExtraStart:0}, d2; \
  1228.         and.l    d2, d1; \
  1229.         bfextu    (srcPixelP){srcExtraStart:0}, d2; \
  1230.         or.l    d2, d1; \
  1231.         bfins    d1, (dstPixelP){dstExtraStart:0}; \
  1232.         addq.l    Num(4), srcPixelP; \
  1233.         addq.l    Num(4), dstPixelP; \
  1234.         addq.l    Num(4), maskPixelP;
  1235.         REPEAT(BLIT)
  1236. #undef    BLIT
  1237.     @OOE_ColLoop_End:
  1238.         
  1239.         subq.l    Num(1), d0
  1240.         bpl        @OOE_ColLoop
  1241. // BLIT EXTRA
  1242.         bfextu    (dstPixelP){dstExtraStart:dstExtraEnd}, d0
  1243.         bfextu    (maskPixelP){srcExtraStart:dstExtraEnd}, d2
  1244.         and.l    d2, d0
  1245.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d2
  1246.         or.l    d2, d0
  1247.         bfins    d0, (dstPixelP){dstExtraStart:dstExtraEnd}
  1248.         
  1249.         adda.l    srcRowStride, srcPixelP
  1250.         adda.l    dstRowStride, dstPixelP
  1251.         adda.l    srcRowStride, maskPixelP
  1252.         
  1253.         subq.l    Num(1), rowsToCopy
  1254.         bgt        @OOE_RowLoop
  1255. // STOP
  1256.         bra        @Done
  1257.         
  1258.     @VeryNarrow:
  1259. // START Very Narrow
  1260.         move.l    rowsToCopy, d2
  1261.     @VN_RowLoop:
  1262. // BLIT
  1263.         bfextu    (dstPixelP){dstExtraStart:dstExtraEnd}, d0
  1264.         bfextu    (maskPixelP){srcExtraStart:dstExtraEnd}, d1
  1265.         and.l    d1, d0
  1266.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d1
  1267.         or.l    d1, d0
  1268.         bfins    d0, (dstPixelP){dstExtraStart:dstExtraEnd}
  1269.         
  1270.         adda.l    srcRowStride, srcPixelP
  1271.         adda.l    dstRowStride, dstPixelP
  1272.         adda.l    srcRowStride, maskPixelP
  1273.         
  1274.         subq.l    Num(1), d2
  1275.         bgt        @VN_RowLoop
  1276. // STOP
  1277.         
  1278.     @Done:
  1279.         
  1280. #if __MWERKS__
  1281.         frfree
  1282. #endif
  1283.         
  1284.         SW_ASM_END
  1285. }
  1286.  
  1287. ///--------------------------------------------------------------------------------------
  1288. //        BlitPixieAllBitPartialMask
  1289. ///--------------------------------------------------------------------------------------
  1290. SW_ASM_FUNC void BlitPixieAllBitPartialMask(
  1291.     register PixelPtr srcPixelP,
  1292.     register PixelPtr dstPixelP,
  1293.     register PixelPtr maskPixelP,
  1294.     unsigned long rowsToCopy,
  1295.     unsigned long numBytesPerRow,
  1296.     register unsigned long srcRowStride,
  1297.     register unsigned long dstRowStride,
  1298.     register unsigned long srcExtraStart,
  1299.     register unsigned long dstExtraStart,
  1300.     register unsigned long dstExtraEnd)
  1301. {
  1302.         SW_ASM_BEGIN
  1303.         
  1304. #if __MWERKS__
  1305.         fralloc +
  1306. #endif
  1307.         
  1308.         move.l    numBytesPerRow, d1
  1309.         lsr.l    Num(2), d1
  1310.         beq        @VeryNarrow
  1311.         
  1312.         tst.l    srcExtraStart
  1313.         bne        @SrcExtraStart
  1314.         
  1315.         tst.l    dstExtraStart
  1316.         bne        @DstExtraStart
  1317.         
  1318.     @NoExtraStart:
  1319.         tst.l    dstExtraEnd
  1320.         beq        @EvenEven
  1321.         bra        @EvenEvenExtra
  1322.         
  1323.     @DstExtraStart:
  1324.         move.l    dstExtraStart, d0
  1325.         and.l    Num(0x07), d0
  1326.         beq        @ADstExtraStart
  1327.         
  1328.         tst.l    dstExtraEnd
  1329.         beq        @EvenOdd
  1330.         bra        @EvenOddExtra
  1331.         
  1332.     @ADstExtraStart:
  1333.         move.l    dstExtraStart, d0
  1334.         lsr.l    Num(3), d0
  1335.         add.l    d0, dstPixelP
  1336.         tst.l    dstExtraEnd
  1337.         beq        @EvenEven
  1338.         bra        @EvenEvenExtra
  1339.         
  1340.     @SrcExtraStart:
  1341.         tst.l    dstExtraStart
  1342.         bne        @SrcDstExtraStart
  1343.     @NoDstExtraStart:
  1344.         move.l    srcExtraStart, d0
  1345.         and.l    Num(0x07), d0
  1346.         beq        @ASrcExtraStart
  1347.         
  1348.         tst.l    dstExtraEnd
  1349.         beq        @OddEven
  1350.         bra        @OddEvenExtra
  1351.         
  1352.     @ASrcExtraStart:
  1353.         move.l    srcExtraStart, d0
  1354.         lsr.l    Num(3), d0
  1355.         add.l    d0, srcPixelP
  1356.         add.l    d0, maskPixelP
  1357.         tst.l    dstExtraEnd
  1358.         beq        @EvenEven
  1359.         bra        @EvenEvenExtra
  1360.         
  1361.     @SrcDstExtraStart:
  1362.         move.l    srcExtraStart, d0
  1363.         and.l    Num(0x07), d0
  1364.         beq        @ASrcDstExtraStart
  1365.         move.l    dstExtraStart, d0
  1366.         and.l    Num(0x07), d0
  1367.         beq        @ADstSrcExtraStart
  1368.         
  1369.         tst.l    dstExtraEnd
  1370.         beq        @OddOdd
  1371.         bra        @OddOddExtra
  1372.         
  1373.     @ASrcDstExtraStart:
  1374.         move.l    dstExtraStart, d0
  1375.         and.l    Num(0x07), d0
  1376.         beq        @AASrcDstExtraStart
  1377.         
  1378.         move.l    srcExtraStart, d0
  1379.         lsr.l    Num(3), d0
  1380.         add.l    d0, srcPixelP
  1381.         add.l    d0, maskPixelP
  1382.         tst.l    dstExtraEnd
  1383.         beq        @EvenOdd
  1384.         bra        @EvenOddExtra
  1385.         
  1386.     @ADstSrcExtraStart:
  1387.         move.l    dstExtraStart, d0
  1388.         lsr.l    Num(3), d0
  1389.         add.l    d0, dstPixelP
  1390.         tst.l    dstExtraEnd
  1391.         beq        @OddEven
  1392.         bra        @OddEvenExtra
  1393.         
  1394.     @AASrcDstExtraStart:
  1395.         move.l    srcExtraStart, d0
  1396.         lsr.l    Num(3), d0
  1397.         add.l    d0, srcPixelP
  1398.         add.l    d0, maskPixelP
  1399.         move.l    dstExtraStart, d0
  1400.         lsr.l    Num(3), d0
  1401.         add.l    d0, dstPixelP
  1402.         tst.l    dstExtraEnd
  1403.         beq        @EvenEven
  1404.         bra        @EvenEvenExtra
  1405.         
  1406.     @EvenEven:
  1407. // START Even -> Even
  1408.         UNROLL(@EE_ColLoop, @EE_ColLoop_End)
  1409.         
  1410.         move.l    rowsToCopy, d2
  1411.     @EE_RowLoop:
  1412.         move.l    d1, d0
  1413.         jmp        (a0)
  1414.     @EE_ColLoop:
  1415. // BLIT
  1416. #define    BLIT \
  1417.         move.l    (maskPixelP)+, dstExtraEndTemp; \
  1418.         and.l    dstExtraEndTemp, (dstPixelP); \
  1419.         not.l    dstExtraEndTemp; \
  1420.         and.l    (srcPixelP)+, dstExtraEndTemp; \
  1421.         or.l    dstExtraEndTemp, (dstPixelP)+;
  1422.         REPEAT(BLIT)
  1423. #undef    BLIT
  1424.     @EE_ColLoop_End:
  1425.         
  1426.         subq.l    Num(1), d0
  1427.         bpl        @EE_ColLoop
  1428.         
  1429.         adda.l    srcRowStride, srcPixelP
  1430.         adda.l    dstRowStride, dstPixelP
  1431.         adda.l    srcRowStride, maskPixelP
  1432.         
  1433.         subq.l    Num(1), d2
  1434.         bgt        @EE_RowLoop
  1435. // STOP
  1436.         bra        @Done
  1437.     @EvenEvenExtra:
  1438. // START Even -> Even + Extra
  1439.         UNROLL(@EEE_ColLoop, @EEE_ColLoop_End)
  1440.         
  1441.         move.l    rowsToCopy, d2
  1442.     @EEE_RowLoop:
  1443.         move.l    d1, d0
  1444.         jmp        (a0)
  1445.     @EEE_ColLoop:
  1446. // BLIT
  1447. #define    BLIT \
  1448.         move.l    (maskPixelP)+, srcExtraStartTemp; \
  1449.         and.l    srcExtraStartTemp, (dstPixelP); \
  1450.         not.l    srcExtraStartTemp; \
  1451.         and.l    (srcPixelP)+, srcExtraStartTemp; \
  1452.         or.l    srcExtraStartTemp, (dstPixelP)+;
  1453.         REPEAT(BLIT)
  1454. #undef    BLIT
  1455.     @EEE_ColLoop_End:
  1456.         
  1457.         subq.l    Num(1), d0
  1458.         bpl        @EEE_ColLoop
  1459. // BLIT EXTRA
  1460.         bfextu    (srcPixelP){0:dstExtraEnd}, d0
  1461.         bfextu    (dstPixelP){0:dstExtraEnd}, srcExtraStartTemp
  1462.         bfextu    (maskPixelP){0:dstExtraEnd}, dstExtraStartTemp
  1463.         and.l    dstExtraStartTemp, srcExtraStartTemp
  1464.         not.l    dstExtraStartTemp
  1465.         and.l    dstExtraStartTemp, d0
  1466.         or.l    srcExtraStartTemp, d0
  1467.         bfins    d0, (dstPixelP){0:dstExtraEnd}
  1468.         
  1469.         adda.l    srcRowStride, srcPixelP
  1470.         adda.l    dstRowStride, dstPixelP
  1471.         adda.l    srcRowStride, maskPixelP
  1472.         
  1473.         subq.l    Num(1), d2
  1474.         bgt        @EEE_RowLoop
  1475. // STOP
  1476.         bra        @Done
  1477.         
  1478.     @EvenOdd:
  1479. // START Even -> Odd
  1480.         UNROLL(@EO_ColLoop, @EO_ColLoop_End)
  1481.         
  1482.         move.l    rowsToCopy, d2
  1483.     @EO_RowLoop:
  1484.         move.l    d1, d0
  1485.         jmp        (a0)
  1486.     @EO_ColLoop:
  1487. // BLIT
  1488. #define    BLIT \
  1489.         move.l    (maskPixelP)+, dstExtraEndTemp; \
  1490.         bfextu    (dstPixelP){dstExtraStart:0}, srcExtraStartTemp; \
  1491.         and.l    dstExtraEndTemp, srcExtraStartTemp; \
  1492.         not.l    dstExtraEndTemp; \
  1493.         and.l    (srcPixelP)+, dstExtraEndTemp; \
  1494.         or.l    dstExtraEndTemp, srcExtraStartTemp; \
  1495.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:0}; \
  1496.         addq.l    Num(4), dstPixelP;
  1497.         REPEAT(BLIT)
  1498. #undef    BLIT
  1499.     @EO_ColLoop_End:
  1500.         
  1501.         subq.l    Num(1), d0
  1502.         bpl        @EO_ColLoop
  1503.         
  1504.         adda.l    srcRowStride, srcPixelP
  1505.         adda.l    dstRowStride, dstPixelP
  1506.         adda.l    srcRowStride, maskPixelP
  1507.         
  1508.         subq.l    Num(1), d2
  1509.         bgt        @EO_RowLoop
  1510. // STOP
  1511.         bra        @Done
  1512.     @EvenOddExtra:
  1513. // START Even -> Odd + Extra
  1514.         UNROLL(@EOE_ColLoop, @EOE_ColLoop_End)
  1515.         
  1516. //        move.l    rowsToCopy, d2
  1517.     @EOE_RowLoop:
  1518.         move.l    d1, d0
  1519.         jmp        (a0)
  1520.     @EOE_ColLoop:
  1521. // BLIT
  1522. #define    BLIT \
  1523.         move.l    (maskPixelP)+, d2; \
  1524.         bfextu    (dstPixelP){dstExtraStart:0}, srcExtraStartTemp; \
  1525.         and.l    d2, srcExtraStartTemp; \
  1526.         not.l    d2; \
  1527.         and.l    (srcPixelP)+, d2; \
  1528.         or.l    d2, srcExtraStartTemp; \
  1529.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:0}; \
  1530.         addq.l    Num(4), dstPixelP;
  1531.         REPEAT(BLIT)
  1532. #undef    BLIT
  1533.     @EOE_ColLoop_End:
  1534.         
  1535.         subq.l    Num(1), d0
  1536.         bpl        @EOE_ColLoop
  1537. //BLIT EXTRA
  1538.         bfextu    (srcPixelP){0:dstExtraEnd}, d0
  1539.         bfextu    (dstPixelP){dstExtraStart:dstExtraEnd}, srcExtraStartTemp
  1540.         bfextu    (maskPixelP){0:dstExtraEnd}, d2
  1541.         and.l    d2, srcExtraStartTemp
  1542.         not.l    d2
  1543.         and.l    d2, d0
  1544.         or.l    srcExtraStartTemp, d0
  1545.         bfins    d0, (dstPixelP){dstExtraStart:dstExtraEnd}
  1546.         
  1547.         adda.l    srcRowStride, srcPixelP
  1548.         adda.l    dstRowStride, dstPixelP
  1549.         adda.l    srcRowStride, maskPixelP
  1550.         
  1551.         subq.l    Num(1), rowsToCopy
  1552.         bgt        @EOE_RowLoop
  1553. // STOP
  1554.         bra        @Done
  1555.         
  1556.     @OddEven:
  1557. // START Odd -> Even
  1558.         UNROLL(@OE_ColLoop, @OE_ColLoop_End)
  1559.         
  1560.         move.l    rowsToCopy, d2
  1561.     @OE_RowLoop:
  1562.         move.l    d1, d0
  1563.         jmp        (a0)
  1564.     @OE_ColLoop:
  1565. // BLIT
  1566. #define    BLIT \
  1567.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1568.         bfextu    (maskPixelP){srcExtraStart:0}, dstExtraEndTemp; \
  1569.         and.l    dstExtraEndTemp, (dstPixelP); \
  1570.         not.l    dstExtraEndTemp; \
  1571.         and.l    dstExtraEndTemp, dstExtraStartTemp; \
  1572.         or.l    dstExtraStartTemp, (dstPixelP)+; \
  1573.         addq.l    Num(4), srcPixelP; \
  1574.         addq.l    Num(4), maskPixelP;
  1575.         REPEAT(BLIT)
  1576. #undef    BLIT
  1577.     @OE_ColLoop_End:
  1578.         
  1579.         subq.l    Num(1), d0
  1580.         bpl        @OE_ColLoop
  1581.         
  1582.         adda.l    srcRowStride, srcPixelP
  1583.         adda.l    dstRowStride, dstPixelP
  1584.         adda.l    srcRowStride, maskPixelP
  1585.         
  1586.         subq.l    Num(1), d2
  1587.         bgt        @OE_RowLoop
  1588. // STOP
  1589.         bra        @Done
  1590.     @OddEvenExtra:
  1591. // START Odd -> Even + Extra
  1592.         UNROLL(@OEE_ColLoop, @OEE_ColLoop_End)
  1593.         
  1594.     @OEE_RowLoop:
  1595.         move.l    d1, d0
  1596.         jmp        (a0)
  1597.     @OEE_ColLoop:
  1598. // BLIT
  1599. #define    BLIT \
  1600.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1601.         bfextu    (maskPixelP){srcExtraStart:0}, d2; \
  1602.         and.l    d2, (dstPixelP); \
  1603.         not.l    d2; \
  1604.         and.l    d2, dstExtraStartTemp; \
  1605.         or.l    dstExtraStartTemp, (dstPixelP)+; \
  1606.         addq.l    Num(4), srcPixelP; \
  1607.         addq.l    Num(4), maskPixelP;
  1608.         REPEAT(BLIT)
  1609. #undef    BLIT
  1610.     @OEE_ColLoop_End:
  1611.         
  1612.         subq.l    Num(1), d0
  1613.         bpl        @OEE_ColLoop
  1614. // BLIT EXTRA
  1615.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d0
  1616.         bfextu    (dstPixelP){0:dstExtraEnd}, dstExtraStartTemp
  1617.         bfextu    (maskPixelP){srcExtraStart:dstExtraEnd}, d2
  1618.         and.l    d2, dstExtraStartTemp
  1619.         not.l    d2
  1620.         and.l    d2, d0
  1621.         or.l    dstExtraStartTemp, d0
  1622.         bfins    d0, (dstPixelP){0:dstExtraEnd}
  1623.         
  1624.         adda.l    srcRowStride, srcPixelP
  1625.         adda.l    dstRowStride, dstPixelP
  1626.         adda.l    srcRowStride, maskPixelP
  1627.         
  1628.         subq.l    Num(1), rowsToCopy
  1629.         bgt        @OEE_RowLoop
  1630. // STOP
  1631.         bra        @Done
  1632.         
  1633.     @OddOdd:
  1634. // START Odd -> Odd
  1635.         UNROLL(@OO_ColLoop, @OO_ColLoop_End)
  1636.         
  1637.         move.l    d1, numBytesPerRow
  1638.     @OO_RowLoop:
  1639.         move.l    numBytesPerRow, d0
  1640.         jmp        (a0)
  1641.     @OO_ColLoop:
  1642. // BLIT
  1643. #define    BLIT \
  1644.         bfextu    (srcPixelP){srcExtraStart:0}, d1; \
  1645.         bfextu    (dstPixelP){dstExtraStart:0}, dstExtraEndTemp; \
  1646.         bfextu    (maskPixelP){srcExtraStart:0}, d2; \
  1647.         and.l    d2, dstExtraEndTemp; \
  1648.         not.l    d2; \
  1649.         and.l    d2, d1; \
  1650.         or.l    dstExtraEndTemp, d1; \
  1651.         bfins    d1, (dstPixelP){dstExtraStart:0}; \
  1652.         addq.l    Num(4), srcPixelP; \
  1653.         addq.l    Num(4), dstPixelP; \
  1654.         addq.l    Num(4), maskPixelP;
  1655.         REPEAT(BLIT)
  1656. #undef    BLIT
  1657.     @OO_ColLoop_End:
  1658.         
  1659.         subq.l    Num(1), d0
  1660.         bpl        @OO_ColLoop
  1661.         
  1662.         adda.l    srcRowStride, srcPixelP
  1663.         adda.l    dstRowStride, dstPixelP
  1664.         adda.l    srcRowStride, maskPixelP
  1665.         
  1666.         subq.l    Num(1), rowsToCopy
  1667.         bgt        @OO_RowLoop
  1668. // STOP
  1669.         bra        @Done
  1670.     @OddOddExtra:
  1671. // START Odd -> Odd + Extra
  1672.         UNROLL(@OOE_ColLoop, @OOE_ColLoop_End)
  1673.         
  1674.         move.l    d1, numBytesPerRow
  1675.         move.l    dstRowStride, -(sp)
  1676.     @OOE_RowLoop:
  1677.         move.l    numBytesPerRow, d0
  1678.         jmp        (a0)
  1679.     @OOE_ColLoop:
  1680. // BLIT
  1681. #define    BLIT \
  1682.         bfextu    (srcPixelP){srcExtraStart:0}, dstRowStrideTemp; \
  1683.         bfextu    (dstPixelP){dstExtraStart:0}, d1; \
  1684.         bfextu    (maskPixelP){srcExtraStart:0}, d2; \
  1685.         and.l    d2, d1; \
  1686.         not.l    d2; \
  1687.         and.l    d2, dstRowStrideTemp; \
  1688.         or.l    d1, dstRowStrideTemp; \
  1689.         bfins    dstRowStrideTemp, (dstPixelP){dstExtraStart:0}; \
  1690.         addq.l    Num(4), srcPixelP; \
  1691.         addq.l    Num(4), dstPixelP; \
  1692.         addq.l    Num(4), maskPixelP;
  1693.         REPEAT(BLIT)
  1694. #undef    BLIT
  1695.     @OOE_ColLoop_End:
  1696.         
  1697.         subq.l    Num(1), d0
  1698.         bpl        @OOE_ColLoop
  1699. // BLIT EXTRA
  1700.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d0
  1701.         bfextu    (dstPixelP){dstExtraStart:dstExtraEnd}, d1
  1702.         bfextu    (maskPixelP){srcExtraStart:dstExtraEnd}, d2
  1703.         and.l    d2, d1
  1704.         not.l    d2
  1705.         and.l    d2, d0
  1706.         or.l    d1, d0
  1707.         bfins    d0, (dstPixelP){dstExtraStart:dstExtraEnd}
  1708.         
  1709.         adda.l    srcRowStride, srcPixelP
  1710.         adda.l    (sp), dstPixelP
  1711.         adda.l    srcRowStride, maskPixelP
  1712.         
  1713.         subq.l    Num(1), rowsToCopy
  1714.         bgt        @OOE_RowLoop
  1715.         
  1716.         addq.l    Num(4), sp
  1717. // STOP
  1718.         bra        @Done
  1719.         
  1720.     @VeryNarrow:
  1721. // START Very Narrow
  1722.     @VN_RowLoop:
  1723. // BLIT
  1724.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d0
  1725.         bfextu    (dstPixelP){dstExtraStart:dstExtraEnd}, d1
  1726.         bfextu    (maskPixelP){srcExtraStart:dstExtraEnd}, d2
  1727.         and.l    d2, d1
  1728.         not.l    d2
  1729.         and.l    d2, d0
  1730.         or.l    d1, d0
  1731.         bfins    d0, (dstPixelP){dstExtraStart:dstExtraEnd}
  1732.         
  1733.         adda.l    srcRowStride, srcPixelP
  1734.         adda.l    dstRowStride, dstPixelP
  1735.         adda.l    srcRowStride, maskPixelP
  1736.         
  1737.         subq.l    Num(1), rowsToCopy
  1738.         bgt        @VN_RowLoop
  1739. // STOP
  1740.         
  1741.     @Done:
  1742.         
  1743. #if __MWERKS__
  1744.         frfree
  1745. #endif
  1746.         
  1747.         SW_ASM_END
  1748. }
  1749.  
  1750. #endif
  1751.