home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1999 Spring / macformat-077.iso / Shareware Plus / Development / SpriteWorld 2.2 / SpriteWorld files / Sources / BlitPixieAllBit.c < prev    next >
Encoding:
Text File  |  1999-01-14  |  50.0 KB  |  2,078 lines  |  [TEXT/CWIE]
  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-independent BlitPixie
  10. //
  11. //
  12. //  Simple PPC Version by Brian Roddy.  Note PPC version only deals properly with 8-bit
  13. //  color or higher.  Lower bit depths will work but will be misaligned.  This is because
  14. //  lower depth blitters require a bunch of bit shifting and aligning which I'm too 
  15. //  lazy to write.  Besides, PPC handles 8-bit fast enough that you probably won't 
  16. //  need to use less than 256 colors.
  17. //
  18. //    Anders Björklund cleaned up the mess that Brian left :-)
  19. //    It has the same limits as above, though.
  20. //
  21. ///--------------------------------------------------------------------------------------
  22.  
  23.  
  24. #ifndef __BLITPIXIE__
  25. #include "BlitPixie.h"
  26. #endif
  27.  
  28. #ifndef __SWCOMMON__
  29. #include "SWCommonHeaders.h"
  30. #endif
  31.  
  32. #ifndef __SPRITEWORLDUTILS__
  33. #include "SpriteWorldUtils.h"
  34. #endif
  35.  
  36. #ifndef __TOOLUTILS__
  37. #include <ToolUtils.h>
  38. #endif
  39.  
  40. #ifndef __OSUTILS__
  41. #include <OSUtils.h>
  42. #endif
  43.  
  44. #ifndef __QUICKDRAW__
  45. #include <Quickdraw.h>
  46. #endif
  47.  
  48. #ifndef __QDOFFSCREEN__
  49. #include <QDOffscreen.h>
  50. #endif
  51.  
  52. #ifndef __SPRITEFRAME__
  53. #include "SpriteFrame.h"
  54. #endif
  55.  
  56.  
  57. const short bpla[] = {
  58.     5,
  59.     4,
  60.     0, 3,
  61.     0, 0, 0, 2,
  62.     0, 0, 0, 0, 0, 0, 0, 1,
  63.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  64.  
  65. //BITSHIFT PER LONGWORD
  66. #define BPL(f1, f2, b1, b2) \
  67.     { \
  68.         int pixelSize = (*f1->framePort->portPixMap)->pixelSize; \
  69.         if (pixelSize != (*f2->framePort->portPixMap)->pixelSize) \
  70.             return; \
  71.         b1 = bpla[pixelSize - 1]; \
  72.         b2 = 5 - b1; \
  73.     }
  74.  
  75. //    i.e:
  76. //    Depth=1        b1=5    b2=0        (32 pixels per long, 1 bit per pixel)
  77. //    Depth=2        b1=4    b2=1        (16 pixels per long, 2 bits per pixel)
  78. //    Depth=4        b1=3    b2=2        (8 pixels per long, 4 bits per pixel)
  79. //    Depth=8        b1=2    b2=3        (4 pixels per long, 8 bits per pixel)
  80. //    Depth=16    b1=1    b2=4        (2 pixels per long, 16 bits per pixel)
  81. //    Depth=32    b1=0    b2=5        (1 pixel per long, 32 bits per pixel)
  82.  
  83. //    generic all-bit routine:
  84. //void BlitPixieAllBit(
  85. //        PixelPtr srcPixelP,                start of first pixel (aligned left to longword boundary)
  86. //        PixelPtr dstPixelP,                
  87. //        long rowsToCopy,                number of rows
  88. //        long numBytesPerRow,            number of bytes per row, always a multiple of four
  89. //        unsigned long srcRowStride,        offset from end of line to next row / rowbytes on PPC
  90. //        unsigned long dstRowStride,
  91. //        unsigned long srcExtraStart,    bits to copy/shift before longs (maximum 31 bits)
  92. //        unsigned long dstExtraStart,    
  93. //        unsigned long dstExtraEnd);        bits to copy/shift after longs
  94.  
  95.  
  96.  
  97. extern SInt8     gSWmmuMode;
  98.  
  99.  
  100. ///--------------------------------------------------------------------------------------
  101. //        BlitPixieRectDrawProc
  102. ///--------------------------------------------------------------------------------------
  103. SW_FUNC void BlitPixieAllBitRectDrawProc(
  104.     FramePtr srcFrameP,
  105.     FramePtr dstFrameP,
  106.     Rect* srcRect,
  107.     Rect* dstRect)
  108. {
  109.     Rect srcBlitRect = *srcRect;
  110.     Rect dstBlitRect = *dstRect;
  111.     unsigned long numBytesPerRow;
  112.     short b1, b2;
  113.     
  114.     SW_ASSERT(srcFrameP->isFrameLocked && dstFrameP->isFrameLocked);
  115.     
  116.     BP_CLIP_RECT(dstFrameP->frameRect, srcBlitRect, dstBlitRect);
  117.     BPL(srcFrameP, dstFrameP, b1, b2);
  118.     START_32_BIT_MODE
  119.     
  120.     numBytesPerRow =
  121.         ((dstBlitRect.right - dstBlitRect.left) >> b1) * sizeof(long);
  122.             
  123.     BlitPixieAllBit(
  124.         (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  125.             (srcFrameP->scanLinePtrArray[srcBlitRect.top - srcFrameP->frameRect.top]) +
  126.             ((srcBlitRect.left >> b1) * sizeof(long))),
  127.         (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  128.             (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  129.             ((dstBlitRect.left >> b1) * sizeof(long))),
  130.         dstBlitRect.bottom - dstBlitRect.top,
  131.         numBytesPerRow,
  132.         #if SW_PPC
  133.         srcFrameP->frameRowBytes,
  134.         dstFrameP->frameRowBytes,
  135.         #else
  136.         srcFrameP->frameRowBytes - numBytesPerRow,
  137.         dstFrameP->frameRowBytes - numBytesPerRow,
  138.         #endif
  139.         (srcBlitRect.left << b2) & 0x1F,
  140.         ((dstFrameP->worldRectOffset << b2) & 0x1F) + ((dstBlitRect.left << b2) & 0x1F),
  141.         ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F
  142.         );
  143.  
  144.     END_32_BIT_MODE
  145. }
  146.  
  147. ///--------------------------------------------------------------------------------------
  148. //        BPAllBitInterlacedRectDrawProc
  149. ///--------------------------------------------------------------------------------------
  150. SW_FUNC void BPAllBitInterlacedRectDrawProc(
  151.     FramePtr srcFrameP,
  152.     FramePtr dstFrameP,
  153.     Rect* srcRect,
  154.     Rect* dstRect)
  155. {
  156.     Rect srcBlitRect = *srcRect;
  157.     Rect dstBlitRect = *dstRect;
  158.     unsigned long numBytesPerRow;
  159.     unsigned long numRowsToCopy;
  160.     short b1, b2;
  161.     
  162.     SW_ASSERT(srcFrameP->isFrameLocked && dstFrameP->isFrameLocked);
  163.     
  164.     BP_CLIP_RECT_INTERLACED(dstFrameP->frameRect, srcBlitRect, dstBlitRect);
  165.     BPL(srcFrameP, dstFrameP, b1, b2);
  166.     // Is destBlitRect height an even number?
  167.     numRowsToCopy = dstBlitRect.bottom - dstBlitRect.top;        
  168.     numRowsToCopy = (numRowsToCopy >> 1) + (numRowsToCopy & 1);
  169.     if (numRowsToCopy < 1)
  170.         return;
  171.     
  172.     START_32_BIT_MODE
  173.  
  174.     numBytesPerRow =
  175.         ((dstBlitRect.right - dstBlitRect.left) >> b1) * sizeof(long);
  176.     BlitPixieAllBit(
  177.         (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  178.             (srcFrameP->scanLinePtrArray[srcBlitRect.top - srcFrameP->frameRect.top]) +
  179.             ((srcBlitRect.left >> b1) * sizeof(long))),
  180.         (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  181.             (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  182.             ((dstBlitRect.left >> b1) * sizeof(long))),
  183.         numRowsToCopy,
  184.         numBytesPerRow,
  185.         #if SW_PPC
  186.         (srcFrameP->frameRowBytes << 1),
  187.         (dstFrameP->frameRowBytes << 1),
  188.         #else
  189.         (srcFrameP->frameRowBytes << 1) - numBytesPerRow,
  190.         (dstFrameP->frameRowBytes << 1) - numBytesPerRow,
  191.         #endif
  192.         (srcBlitRect.left << b2) & 0x1F,
  193.         ((dstFrameP->worldRectOffset << b2) & 0x1F) + ((dstBlitRect.left << b2) & 0x1F),
  194.         ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F
  195.         );
  196.  
  197.     END_32_BIT_MODE
  198. }
  199.  
  200. ///--------------------------------------------------------------------------------------
  201. //        BlitPixieAllBitMaskDrawProc
  202. ///--------------------------------------------------------------------------------------
  203. SW_FUNC void BlitPixieAllBitMaskDrawProc(
  204.     FramePtr srcFrameP,
  205.     FramePtr dstFrameP,
  206.     Rect *srcRect,
  207.     Rect *dstRect)
  208. {
  209.     Rect dstBlitRect = *dstRect;
  210.     Rect srcBlitRect = *srcRect;
  211.     unsigned long numBytesPerRow;
  212.     unsigned long srcBaseOffset;
  213.     short b1, b2;
  214.     
  215.     SW_ASSERT(srcFrameP->isFrameLocked && dstFrameP->isFrameLocked);
  216.     SW_ASSERT(srcFrameP->maskPort != NULL);
  217.     
  218.     BP_CLIP_RECT(dstFrameP->frameRect, srcBlitRect, dstBlitRect);
  219.     BPL(srcFrameP, dstFrameP, b1, b2);
  220.     START_32_BIT_MODE
  221.     
  222.     srcBaseOffset =
  223.         (srcFrameP->scanLinePtrArray[srcBlitRect.top - srcFrameP->frameRect.top]) +
  224.         ((srcBlitRect.left >> b1) * sizeof(long));
  225.     numBytesPerRow =
  226.         ((dstBlitRect.right - dstBlitRect.left) >> b1) * sizeof(long);
  227.     
  228.     if ( (*srcFrameP->framePort->portPixMap)->pixelSize < 16 )
  229.     {
  230.         BlitPixieAllBitMask(
  231.             (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  232.                 srcBaseOffset),
  233.             (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  234.                 (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  235.                 ((dstBlitRect.left >> b1) * sizeof(long))),
  236.             (PixelChunkPtr)(srcFrameP->maskBaseAddr +
  237.                 srcBaseOffset),
  238.             dstBlitRect.bottom - dstBlitRect.top,
  239.             numBytesPerRow,
  240.             #if SW_PPC
  241.             srcFrameP->frameRowBytes,
  242.             dstFrameP->frameRowBytes,
  243.             #else
  244.             srcFrameP->frameRowBytes - numBytesPerRow,
  245.             dstFrameP->frameRowBytes - numBytesPerRow,
  246.             #endif
  247.             (srcBlitRect.left << b2) & 0x1F,
  248.             (((dstFrameP->worldRectOffset + dstBlitRect.left) << b2) & 0x1F),
  249.             ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F
  250.             );
  251.     }
  252.     else
  253.     {
  254.         BlitPixieAllBitPartialMask(
  255.             (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  256.                 srcBaseOffset),
  257.             (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  258.                 (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  259.                 ((dstBlitRect.left >> b1) * sizeof(long))),
  260.             (PixelChunkPtr)(srcFrameP->maskBaseAddr +
  261.                 srcBaseOffset),
  262.             dstBlitRect.bottom - dstBlitRect.top,
  263.             numBytesPerRow,
  264.             #if SW_PPC
  265.             srcFrameP->frameRowBytes,
  266.             dstFrameP->frameRowBytes,
  267.             #else
  268.             srcFrameP->frameRowBytes - numBytesPerRow,
  269.             dstFrameP->frameRowBytes - numBytesPerRow,
  270.             #endif
  271.             (srcBlitRect.left << b2) & 0x1F,
  272.             (((dstFrameP->worldRectOffset + dstBlitRect.left) << b2) & 0x1F),
  273.             ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F
  274.             );
  275.     }
  276.     
  277.     END_32_BIT_MODE
  278. }
  279.  
  280. ///--------------------------------------------------------------------------------------
  281. //        BlitPixieAllBitPartialMaskDrawProc
  282. ///--------------------------------------------------------------------------------------
  283. SW_FUNC void BlitPixieAllBitPartialMaskDrawProc(
  284.     FramePtr srcFrameP,
  285.     FramePtr dstFrameP,
  286.     Rect *srcRect,
  287.     Rect *dstRect)
  288. {
  289.     Rect dstBlitRect = *dstRect;
  290.     Rect srcBlitRect = *srcRect;
  291.     unsigned long numBytesPerRow;
  292.     unsigned long srcBaseOffset;
  293.     short b1, b2;
  294.     
  295.     SW_ASSERT(srcFrameP->isFrameLocked && dstFrameP->isFrameLocked);
  296.     SW_ASSERT(srcFrameP->maskPort != NULL);
  297.     
  298.     BP_CLIP_RECT(dstFrameP->frameRect, srcBlitRect, dstBlitRect);
  299.     BPL(srcFrameP, dstFrameP, b1, b2);
  300.     START_32_BIT_MODE
  301.     
  302.     srcBaseOffset =
  303.         (srcFrameP->scanLinePtrArray[srcBlitRect.top - srcFrameP->frameRect.top]) +
  304.         ((srcBlitRect.left >> b1) * sizeof(long));
  305.     numBytesPerRow =
  306.         ((dstBlitRect.right - dstBlitRect.left) >> b1) * sizeof(long);
  307.     BlitPixieAllBitPartialMask(
  308.         (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  309.             srcBaseOffset),
  310.         (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  311.             (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  312.             ((dstBlitRect.left >> b1) * sizeof(long))),
  313.         (PixelChunkPtr)(srcFrameP->maskBaseAddr +
  314.             srcBaseOffset),
  315.         dstBlitRect.bottom - dstBlitRect.top,
  316.         numBytesPerRow,
  317.         #if SW_PPC
  318.         srcFrameP->frameRowBytes,
  319.         dstFrameP->frameRowBytes,
  320.         #else
  321.         srcFrameP->frameRowBytes - numBytesPerRow,
  322.         dstFrameP->frameRowBytes - numBytesPerRow,
  323.         #endif
  324.         (srcBlitRect.left << b2) & 0x1F,
  325.         (((dstFrameP->worldRectOffset + dstBlitRect.left) << b2) & 0x1F),
  326.         ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F
  327.         );
  328.         
  329.     END_32_BIT_MODE
  330. }
  331.  
  332. ///--------------------------------------------------------------------------------------
  333. //        BPAllBitInterlacedMaskDrawProc
  334. ///--------------------------------------------------------------------------------------
  335. SW_FUNC void BPAllBitInterlacedMaskDrawProc(
  336.     FramePtr srcFrameP,
  337.     FramePtr dstFrameP,
  338.     Rect* srcRect,
  339.     Rect* dstRect)
  340. {
  341.     Rect srcBlitRect = *srcRect;
  342.     Rect dstBlitRect = *dstRect;
  343.     unsigned long numBytesPerRow;
  344.     unsigned long numRowsToCopy;
  345.     unsigned long srcBaseOffset;
  346.     short b1, b2;
  347.     
  348.     SW_ASSERT(srcFrameP->isFrameLocked && dstFrameP->isFrameLocked);
  349.     SW_ASSERT(srcFrameP->maskPort != NULL);
  350.     
  351.     BP_CLIP_RECT_INTERLACED(dstFrameP->frameRect, srcBlitRect, dstBlitRect);
  352.     BPL(srcFrameP, dstFrameP, b1, b2);
  353.     // Is destBlitRect height an even number?
  354.     numRowsToCopy = dstBlitRect.bottom - dstBlitRect.top;        
  355.     numRowsToCopy = (numRowsToCopy >> 1) + (numRowsToCopy & 1);
  356.     if (numRowsToCopy < 1)
  357.         return;
  358.     START_32_BIT_MODE
  359.     
  360.     srcBaseOffset =
  361.         (srcFrameP->scanLinePtrArray[srcBlitRect.top - srcFrameP->frameRect.top]) +
  362.         ((srcBlitRect.left >> b1) * sizeof(long));
  363.     numBytesPerRow =
  364.         ((dstBlitRect.right - dstBlitRect.left) >> b1) * sizeof(long);
  365.     
  366.     if ( (*srcFrameP->framePort->portPixMap)->pixelSize < 16 )
  367.     {
  368.         BlitPixieAllBitMask(
  369.             (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  370.                 srcBaseOffset),
  371.             (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  372.                 (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  373.                 ((dstBlitRect.left >> b1) * sizeof(long))),
  374.             (PixelChunkPtr)(srcFrameP->maskBaseAddr +
  375.                 srcBaseOffset),
  376.             numRowsToCopy,
  377.             numBytesPerRow,
  378.             #if SW_PPC
  379.             (srcFrameP->frameRowBytes << 1),
  380.             (dstFrameP->frameRowBytes << 1),
  381.             #else
  382.             (srcFrameP->frameRowBytes << 1) - numBytesPerRow,
  383.             (dstFrameP->frameRowBytes << 1) - numBytesPerRow,
  384.             #endif
  385.             (srcBlitRect.left << b2) & 0x1F,
  386.             (((dstFrameP->worldRectOffset + dstBlitRect.left) << b2) & 0x1F),
  387.             ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F
  388.             );
  389.     }
  390.     else
  391.     {
  392.         BlitPixieAllBitPartialMask(
  393.             (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  394.                 srcBaseOffset),
  395.             (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  396.                 (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  397.                 ((dstBlitRect.left >> b1) * sizeof(long))),
  398.             (PixelChunkPtr)(srcFrameP->maskBaseAddr +
  399.                 srcBaseOffset),
  400.             numRowsToCopy,
  401.             numBytesPerRow,
  402.             #if SW_PPC
  403.             (srcFrameP->frameRowBytes << 1),
  404.             (dstFrameP->frameRowBytes << 1),
  405.             #else
  406.             (srcFrameP->frameRowBytes << 1) - numBytesPerRow,
  407.             (dstFrameP->frameRowBytes << 1) - numBytesPerRow,
  408.             #endif
  409.             (srcBlitRect.left << b2) & 0x1F,
  410.             (((dstFrameP->worldRectOffset + dstBlitRect.left) << b2) & 0x1F),
  411.             ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F
  412.             );
  413.     }
  414.     
  415.     END_32_BIT_MODE
  416. }
  417.  
  418. ///--------------------------------------------------------------------------------------
  419. //        BPAllBitInterlacedPartialMaskDrawProc
  420. ///--------------------------------------------------------------------------------------
  421. SW_FUNC void BPAllBitInterlacedPartialMaskDrawProc(
  422.     FramePtr srcFrameP,
  423.     FramePtr dstFrameP,
  424.     Rect* srcRect,
  425.     Rect* dstRect)
  426. {
  427.     Rect srcBlitRect = *srcRect;
  428.     Rect dstBlitRect = *dstRect;
  429.     unsigned long numBytesPerRow;
  430.     unsigned long numRowsToCopy;
  431.     unsigned long srcBaseOffset;
  432.     short b1, b2;
  433.     
  434.     SW_ASSERT(srcFrameP->isFrameLocked && dstFrameP->isFrameLocked);
  435.     SW_ASSERT(srcFrameP->maskPort != NULL);
  436.     
  437.     BP_CLIP_RECT_INTERLACED(dstFrameP->frameRect, srcBlitRect, dstBlitRect);
  438.     BPL(srcFrameP, dstFrameP, b1, b2);
  439.     // Is destBlitRect height an even number?
  440.     numRowsToCopy = dstBlitRect.bottom - dstBlitRect.top;        
  441.     numRowsToCopy = (numRowsToCopy >> 1) + (numRowsToCopy & 1);
  442.     if (numRowsToCopy < 1)
  443.         return;
  444.     START_32_BIT_MODE
  445.     
  446.     srcBaseOffset =
  447.         (srcFrameP->scanLinePtrArray[srcBlitRect.top - srcFrameP->frameRect.top]) +
  448.         ((srcBlitRect.left >> b1) * sizeof(long));
  449.     numBytesPerRow =
  450.         ((dstBlitRect.right - dstBlitRect.left) >> b1) * sizeof(long);
  451.     BlitPixieAllBitPartialMask(
  452.         (PixelChunkPtr)(srcFrameP->frameBaseAddr +
  453.             srcBaseOffset),
  454.         (PixelChunkPtr)(dstFrameP->frameBaseAddr +
  455.             (dstFrameP->scanLinePtrArray[dstBlitRect.top]) +
  456.             ((dstBlitRect.left >> b1) * sizeof(long))),
  457.         (PixelChunkPtr)(srcFrameP->maskBaseAddr +
  458.             srcBaseOffset),
  459.         numRowsToCopy,
  460.         numBytesPerRow,
  461.         #if SW_PPC
  462.         (srcFrameP->frameRowBytes << 1),
  463.         (dstFrameP->frameRowBytes << 1),
  464.         #else
  465.         (srcFrameP->frameRowBytes << 1) - numBytesPerRow,
  466.         (dstFrameP->frameRowBytes << 1) - numBytesPerRow,
  467.         #endif
  468.         (srcBlitRect.left << b2) & 0x1F,
  469.         (((dstFrameP->worldRectOffset + dstBlitRect.left) << b2) & 0x1F),
  470.         ((dstBlitRect.right - dstBlitRect.left) << b2) & 0x1F
  471.         );
  472.     END_32_BIT_MODE
  473. }
  474.  
  475. #pragma mark -
  476.  
  477. #pragma mark *** PowerPC:
  478. #if SW_PPC
  479.  
  480.  
  481. // Power PC Blitters
  482. // Note we do no bit aligniment, so we only handle 8-bit or higher color.
  483. // Lower color will work but will misalign copying of the sprites.
  484. // To write one that works, you need to use the srcExtraStart and dstExtraStart
  485. // to figure out how many bits you need to shift the source and the destination
  486. // before you copy the bits.  Then use dstExtraEnd to figure out how many extra
  487. // bits you need to copy at the end.
  488.  
  489. ///--------------------------------------------------------------------------------------
  490. //        BlitPixieAllBit
  491. ///--------------------------------------------------------------------------------------
  492. // Since this blit routine just does straight copying and requires no boolean operations, 
  493. // we can make use of the floating point registers on the Power PC.  This means we
  494. // can blit a double, 8 bytes at a time, rather than a long.  This makes the blitter 
  495. // faster.  We could speed this up even more by unrolling the loop for big blits, 
  496. // but it would make the code much less readable.
  497. // Unfortunately, this function reqires that the src and dest pointers be 4-byte
  498. // aligned for doubles to be used or else alignment has to be done in hardware on the 
  499. // PPC601 (still faster) or in software (argh) on the PPC604 which will probably be 
  500. // slower though I haven't tested it yet.
  501.  
  502. void BlitPixieAllBit(
  503.     register PixelPtr srcPixelPTemp,
  504.     register PixelPtr dstPixelPTemp,
  505.     unsigned long rowsToCopy,
  506.     unsigned long numBytesPerRow,
  507.     register unsigned long srcOffset,
  508.     register unsigned long dstOffset,
  509.     register unsigned long srcExtraStart,
  510.     register unsigned long dstExtraStart,
  511.     register unsigned long dstExtraEnd)
  512. {
  513.     if ((srcExtraStart & 16) != 0)
  514.             ((unsigned short *) srcPixelPTemp)++;
  515.     if ((srcExtraStart & 8) != 0)
  516.         ((unsigned char *) srcPixelPTemp)++;
  517.     
  518.     if ((dstExtraStart & 8) != 0)
  519.         ((unsigned char *) dstPixelPTemp)++;
  520.     if ((dstExtraStart & 16) != 0)
  521.         ((unsigned short *) dstPixelPTemp)++;
  522.     
  523.     if (((unsigned long)srcPixelPTemp & 3) || ((unsigned long)dstPixelPTemp & 3)) {
  524.         register long index;
  525.         register PixelChunkPtr srcPixelP = srcPixelPTemp;
  526.         register PixelChunkPtr dstPixelP = dstPixelPTemp;
  527.         register PixelChunkPtr startSrcPixelP;
  528.         register PixelChunkPtr startDstPixelP;
  529.         
  530.         startSrcPixelP = srcPixelP;
  531.         startDstPixelP = dstPixelP;
  532.  
  533.         while (rowsToCopy--)
  534.         {
  535.             register int fourblits = (numBytesPerRow >> 2);
  536.             
  537.             srcPixelP = startSrcPixelP;
  538.             dstPixelP = startDstPixelP;
  539.             
  540.             for (index = 0; index < fourblits; index++)
  541.             {
  542.                 register unsigned long temp1;
  543.                 
  544.                 temp1 = srcPixelP[index];
  545.                 dstPixelP[index] = temp1;
  546.             }
  547.             srcPixelP += fourblits;
  548.             dstPixelP += fourblits;
  549.             
  550.             if ((dstExtraEnd & 16) != 0)
  551.                 *((unsigned short *) dstPixelP)++ = *((unsigned short *) srcPixelP)++;
  552.             if ((dstExtraEnd & 8) != 0)
  553.                 *((unsigned char *)dstPixelP)++ = *((unsigned char *)srcPixelP)++;
  554.     
  555.                 // bump to next row    
  556.             (char *)startSrcPixelP += srcOffset;
  557.             (char *)startDstPixelP += dstOffset;
  558.         }
  559.     } else {
  560.         register long index;
  561.         register double *startSrcPixelP;
  562.         register double *startDstPixelP;
  563.         register double *srcPixelP = (double *)srcPixelPTemp;
  564.         register double *dstPixelP = (double *)dstPixelPTemp;
  565.  
  566.         startSrcPixelP = srcPixelP;
  567.         startDstPixelP = dstPixelP;
  568.  
  569.         while (rowsToCopy--)
  570.         {
  571.             register int eightblits = (numBytesPerRow >> 3);
  572.             
  573.             srcPixelP = startSrcPixelP;
  574.             dstPixelP = startDstPixelP;
  575.                         
  576.             for (index = 0; index < eightblits; index++)
  577.             {
  578.                 dstPixelP[index] = srcPixelP[index];
  579.             }
  580.             srcPixelP += eightblits;
  581.             dstPixelP += eightblits;
  582.             if (numBytesPerRow & 0x4)
  583.                 *((unsigned long *) dstPixelP)++ = *((unsigned long *) srcPixelP)++;
  584.  
  585.             if ((dstExtraEnd & 16) != 0)
  586.                 *((unsigned short *) dstPixelP)++ = *((unsigned short *) srcPixelP)++;
  587.             if ((dstExtraEnd & 8) != 0)
  588.                 *((unsigned char *)dstPixelP)++ = *((unsigned char *)srcPixelP)++;
  589.  
  590.                 // bump to next row    
  591.             (char *)startSrcPixelP += srcOffset;
  592.             (char *)startDstPixelP += dstOffset;
  593.         }
  594.     }
  595. }
  596.  
  597.  
  598.  
  599. ///--------------------------------------------------------------------------------------
  600. //        BlitPixieAllBitMask
  601. ///--------------------------------------------------------------------------------------
  602. void BlitPixieAllBitMask(
  603.     register PixelPtr srcPixelP,
  604.     register PixelPtr dstPixelP,
  605.     register PixelPtr maskPixelP,
  606.     unsigned long rowsToCopy,
  607.     unsigned long numBytesPerRow,
  608.     register unsigned long srcRowStride,
  609.     register unsigned long dstRowStride,
  610.     register unsigned long srcExtraStart,
  611.     register unsigned long dstExtraStart,
  612.     register unsigned long dstExtraEnd)
  613. {
  614.     long index;
  615.     PixelPtr startSrcPixelP = srcPixelP;
  616.     PixelPtr startDstPixelP = dstPixelP;
  617.     PixelPtr startMaskPixelP = maskPixelP;
  618.         
  619.     if ((srcExtraStart & 16) != 0)
  620.     {
  621.         ((unsigned short *) startSrcPixelP)++;
  622.         ((unsigned short *) startMaskPixelP)++;
  623.     }
  624.     if ((srcExtraStart & 8) != 0)
  625.     {
  626.         ((unsigned char *) startSrcPixelP)++;
  627.         ((unsigned char *) startMaskPixelP)++;
  628.     }
  629.     
  630.     if ((dstExtraStart & 8) != 0)
  631.         ((unsigned char *) startDstPixelP)++;
  632.     if ((dstExtraStart & 16) != 0)
  633.         ((unsigned short *) startDstPixelP)++;
  634.     
  635.     while (rowsToCopy--)    
  636.     {
  637.         register fourblits = (numBytesPerRow >> 2);
  638.         
  639.         srcPixelP = startSrcPixelP;
  640.         dstPixelP = startDstPixelP;
  641.         maskPixelP = startMaskPixelP;
  642.                 
  643.         for (index = 0; index < fourblits; index++)
  644.         {
  645.             dstPixelP[index] = dstPixelP[index] & maskPixelP[index] | srcPixelP[index];
  646.         }
  647.         srcPixelP += fourblits;
  648.         dstPixelP += fourblits;
  649.         maskPixelP += fourblits;
  650.     
  651.         if ((dstExtraEnd & 16) != 0)
  652.         {
  653.             register unsigned short temp1;
  654.             
  655.             temp1 = (*((unsigned short *) dstPixelP)) & (*((unsigned short *) maskPixelP)++) |
  656.             *((unsigned short *) srcPixelP)++;
  657.             
  658.             (*((unsigned short *) dstPixelP)++) = temp1;
  659.         }
  660.         if ((dstExtraEnd & 8) != 0)
  661.         {
  662.             register unsigned char temp1;
  663.             
  664.             temp1 = (*((unsigned char *) dstPixelP)) & (*((unsigned char *) maskPixelP)++) |
  665.             *((unsigned char *) srcPixelP)++;
  666.             
  667.             (*((unsigned char *) dstPixelP)++) = temp1;
  668.         }
  669.  
  670.             // bump to next row
  671.         startSrcPixelP = (PixelPtr)(((char*)startSrcPixelP) + srcRowStride);
  672.         startDstPixelP = (PixelPtr)(((char*)startDstPixelP) + dstRowStride);
  673.         startMaskPixelP = (PixelPtr)(((char*)startMaskPixelP) + srcRowStride);
  674.     }
  675. }
  676.  
  677. ///--------------------------------------------------------------------------------------
  678. //        BlitPixieAllBitPartialMask
  679. ///--------------------------------------------------------------------------------------
  680. void BlitPixieAllBitPartialMask(
  681.     register PixelPtr srcPixelP,
  682.     register PixelPtr dstPixelP,
  683.     register PixelPtr maskPixelP,
  684.     unsigned long rowsToCopy,
  685.     unsigned long numBytesPerRow,
  686.     register unsigned long srcRowStride,
  687.     register unsigned long dstRowStride,
  688.     register unsigned long srcExtraStart,
  689.     register unsigned long dstExtraStart,
  690.     register unsigned long dstExtraEnd)
  691. {
  692.     long index;
  693.     PixelPtr startSrcPixelP = srcPixelP;
  694.     PixelPtr startDstPixelP = dstPixelP;
  695.     PixelPtr startMaskPixelP = maskPixelP;
  696.         
  697.     if ((srcExtraStart & 16) != 0)
  698.     {
  699.         ((unsigned short *) startSrcPixelP)++;
  700.         ((unsigned short *) startMaskPixelP)++;
  701.     }
  702.     if ((srcExtraStart & 8) != 0)
  703.     {
  704.         ((unsigned char *) startSrcPixelP)++;
  705.         ((unsigned char *) startMaskPixelP)++;
  706.     }
  707.  
  708.     if ((dstExtraStart & 8) != 0)
  709.         ((unsigned char *) startDstPixelP)++;
  710.     if ((dstExtraStart & 16) != 0)
  711.         ((unsigned short *) startDstPixelP)++;
  712.         
  713.     while (rowsToCopy--)    
  714.     {
  715.         register fourblits = (numBytesPerRow >> 2);
  716.         
  717.         srcPixelP = startSrcPixelP;
  718.         dstPixelP = startDstPixelP;
  719.         maskPixelP = startMaskPixelP;
  720.                 
  721.         for (index = 0; index < fourblits; index++)
  722.         {
  723.             dstPixelP[index] = dstPixelP[index] & maskPixelP[index] | 
  724.                 ( (~maskPixelP[index] )& srcPixelP[index]);
  725.         }
  726.         srcPixelP += fourblits;
  727.         dstPixelP += fourblits;
  728.         maskPixelP += fourblits;
  729.  
  730.         if ((dstExtraEnd & 16) != 0)
  731.         {
  732.             register unsigned short temp1;
  733.             
  734.             temp1 = (*((unsigned short *) dstPixelP)) & (*((unsigned short *) maskPixelP)) |
  735.             (~(*((unsigned short *) maskPixelP)++) &
  736.             *((unsigned short *) srcPixelP)++);
  737.                 
  738.             (*((unsigned short *) dstPixelP)++) = temp1;
  739.         }
  740.         if ((dstExtraEnd & 8) != 0)
  741.         {
  742.             register unsigned char temp1;
  743.             
  744.             temp1 = (*((unsigned char *) dstPixelP)) & (*((unsigned char *) maskPixelP)) |
  745.             (~(*((unsigned char *) maskPixelP)++) &
  746.             *((unsigned char *) srcPixelP)++);
  747.                 
  748.             (*((unsigned char *) dstPixelP)++) = temp1;
  749.         }
  750.         
  751.             // bump to next row
  752.         startSrcPixelP = (PixelPtr)(((char*)startSrcPixelP) + srcRowStride);
  753.         startDstPixelP = (PixelPtr)(((char*)startDstPixelP) + dstRowStride);
  754.         startMaskPixelP = (PixelPtr)(((char*)startMaskPixelP) + srcRowStride);
  755.     }
  756. }
  757.  
  758. #pragma mark *** 680X0:
  759. #else    /* #if SW_PPC */
  760.  
  761. #if !__MWERKS__
  762. #define Num(x) #(x)
  763. #else
  764. #define Num(x) %(x)
  765. #endif
  766.  
  767. #define srcExtraStartTemp    srcExtraStart
  768. #define dstExtraStartTemp    dstExtraStart
  769. #define dstExtraEndTemp        dstExtraEnd
  770. #define dstRowStrideTemp    dstRowStride
  771.  
  772. #define UNROLL(start, end) \
  773.     move.l    d1, d0; \
  774.     lsr.l    Num(4), d1; \
  775.     moveq    Num(0x0F), d2; \
  776.     and.l    d2, d0; \
  777.     \
  778.     lea        end, a0; \
  779.     lea        start, a1; \
  780.     sub.l    a0, a1; \
  781.     move.l    a1, d2; \
  782.     asr.l    Num(4), d2; \
  783.     mulu.l    d2, d0; \
  784.     add.l    d0, a0;
  785.  
  786. #define REPEAT(instr) \
  787.     instr; \
  788.     instr; \
  789.     instr; \
  790.     instr; \
  791.     instr; \
  792.     instr; \
  793.     instr; \
  794.     instr; \
  795.     instr; \
  796.     instr; \
  797.     instr; \
  798.     instr; \
  799.     instr; \
  800.     instr; \
  801.     instr; \
  802.     instr;
  803.  
  804. ///--------------------------------------------------------------------------------------
  805. //        BlitPixieAllBit
  806. ///--------------------------------------------------------------------------------------
  807. SW_ASM_FUNC void BlitPixieAllBit(
  808.     register PixelPtr srcPixelP,
  809.     register PixelPtr dstPixelP,
  810.     unsigned long rowsToCopy,
  811.     unsigned long numBytesPerRow,
  812.     register unsigned long srcRowStride,
  813.     register unsigned long dstRowStride,
  814.     register unsigned long srcExtraStart,
  815.     register unsigned long dstExtraStart,
  816.     register unsigned long dstExtraEnd)
  817. {
  818.         SW_ASM_BEGIN
  819.         
  820. #if __MWERKS__
  821.         fralloc +
  822. #endif
  823.         
  824.         move.l    numBytesPerRow, d1
  825.         lsr.l    Num(2), d1
  826.         beq        @VeryNarrow
  827.         
  828.         tst.l    srcExtraStart
  829.         bne        @SrcExtraStart
  830.         
  831.         tst.l    dstExtraStart
  832.         bne        @DstExtraStart
  833.         
  834.     @NoExtraStart:
  835.         tst.l    dstExtraEnd
  836.         beq        @EvenEven
  837.         bra        @EvenEvenExtra
  838.         
  839.     @DstExtraStart:
  840.         move.l    dstExtraStart, d0
  841.         and.l    Num(0x07), d0
  842.         beq        @ADstExtraStart
  843.         
  844.         tst.l    dstExtraEnd
  845.         beq        @EvenOdd
  846.         bra        @EvenOddExtra
  847.         
  848.     @ADstExtraStart:
  849.         move.l    dstExtraStart, d0
  850.         lsr.l    Num(3), d0
  851.         add.l    d0, dstPixelP
  852.         tst.l    dstExtraEnd
  853.         beq        @EvenEven
  854.         bra        @EvenEvenExtra
  855.         
  856.     @SrcExtraStart:
  857.         tst.l    dstExtraStart
  858.         bne        @SrcDstExtraStart
  859.     @NoDstExtraStart:
  860.         move.l    srcExtraStart, d0
  861.         and.l    Num(0x07), d0
  862.         beq        @ASrcExtraStart
  863.         
  864.         tst.l    dstExtraEnd
  865.         beq        @OddEven
  866.         bra        @OddEvenExtra
  867.         
  868.     @ASrcExtraStart:
  869.         move.l    srcExtraStart, d0
  870.         lsr.l    Num(3), d0
  871.         add.l    d0, srcPixelP
  872.         tst.l    dstExtraEnd
  873.         beq        @EvenEven
  874.         bra        @EvenEvenExtra
  875.         
  876.     @SrcDstExtraStart:
  877.         move.l    srcExtraStart, d0
  878.         and.l    Num(0x07), d0
  879.         beq        @ASrcDstExtraStart
  880.         move.l    dstExtraStart, d0
  881.         and.l    Num(0x07), d0
  882.         beq        @ADstSrcExtraStart
  883.         
  884.         tst.l    dstExtraEnd
  885.         beq        @OddOdd
  886.         bra        @OddOddExtra
  887.         
  888.     @ASrcDstExtraStart:
  889.         move.l    dstExtraStart, d0
  890.         and.l    Num(0x07), d0
  891.         beq        @AASrcDstExtraStart
  892.         
  893.         move.l    srcExtraStart, d0
  894.         lsr.l    Num(3), d0
  895.         add.l    d0, srcPixelP
  896.         tst.l    dstExtraEnd
  897.         beq        @EvenOdd
  898.         bra        @EvenOddExtra
  899.         
  900.     @ADstSrcExtraStart:
  901.         move.l    dstExtraStart, d0
  902.         lsr.l    Num(3), d0
  903.         add.l    d0, dstPixelP
  904.         tst.l    dstExtraEnd
  905.         beq        @OddEven
  906.         bra        @OddEvenExtra
  907.         
  908.     @AASrcDstExtraStart:
  909.         move.l    srcExtraStart, d0
  910.         lsr.l    Num(3), d0
  911.         add.l    d0, srcPixelP
  912.         move.l    dstExtraStart, d0
  913.         lsr.l    Num(3), d0
  914.         add.l    d0, dstPixelP
  915.         tst.l    dstExtraEnd
  916.         beq        @EvenEven
  917.         bra        @EvenEvenExtra
  918.         
  919.     @EvenEven:
  920. // START Even -> Even
  921.         UNROLL(@EE_ColLoop, @EE_ColLoop_End)
  922.         
  923.         move.l    rowsToCopy, d2
  924.     @EE_RowLoop:
  925.         move.l    d1, d0
  926.         jmp        (a0)
  927.     @EE_ColLoop:
  928. // BLIT
  929. #define    BLIT \
  930.         move.l    (srcPixelP)+, (dstPixelP)+;
  931.         REPEAT(BLIT)
  932. #undef    BLIT
  933.     @EE_ColLoop_End:
  934.         
  935.         subq.l    Num(1), d0
  936.         bpl        @EE_ColLoop
  937.         
  938.         adda.l    srcRowStride, srcPixelP
  939.         adda.l    dstRowStride, dstPixelP
  940.         
  941.         subq.l    Num(1), d2
  942.         bgt        @EE_RowLoop
  943. // STOP
  944.         bra        @Done
  945.     @EvenEvenExtra:
  946. // START Even -> Even + Extra
  947.         UNROLL(@EEE_ColLoop, @EEE_ColLoop_End)
  948.         
  949.         move.l    rowsToCopy, d2
  950.     @EEE_RowLoop:
  951.         move.l    d1, d0
  952.         jmp        (a0)
  953.     @EEE_ColLoop:
  954. // BLIT
  955. #define    BLIT \
  956.         move.l    (srcPixelP)+, (dstPixelP)+;
  957.         REPEAT(BLIT)
  958. #undef    BLIT
  959.     @EEE_ColLoop_End:
  960.         
  961.         subq.l    Num(1), d0
  962.         bpl        @EEE_ColLoop
  963. // BLIT EXTRA
  964.         bfextu    (srcPixelP){0:dstExtraEnd}, d0
  965.         bfins    d0, (dstPixelP){0:dstExtraEnd}
  966.         
  967.         adda.l    srcRowStride, srcPixelP
  968.         adda.l    dstRowStride, dstPixelP
  969.         
  970.         subq.l    Num(1), d2
  971.         bgt        @EEE_RowLoop
  972. // STOP
  973.         bra        @Done
  974.         
  975.     @EvenOdd:
  976. // START Even -> Odd
  977.         UNROLL(@EO_ColLoop, @EO_ColLoop_End)
  978.         
  979.         move.l    rowsToCopy, d2
  980.     @EO_RowLoop:
  981.         move.l    d1, d0
  982.         jmp        (a0)
  983.     @EO_ColLoop:
  984. // BLIT
  985. #define    BLIT \
  986.         move.l    (srcPixelP)+, srcExtraStartTemp; \
  987.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:0}; \
  988.         addq.l    Num(4), dstPixelP;
  989.         REPEAT(BLIT)
  990. #undef    BLIT
  991.     @EO_ColLoop_End:
  992.         
  993.         subq.l    Num(1), d0
  994.         bpl        @EO_ColLoop
  995.         
  996.         adda.l    srcRowStride, srcPixelP
  997.         adda.l    dstRowStride, dstPixelP
  998.         
  999.         subq.l    Num(1), d2
  1000.         bgt        @EO_RowLoop
  1001. // STOP
  1002.         bra        @Done
  1003.     @EvenOddExtra:
  1004. // START Even -> Odd + Extra
  1005.         UNROLL(@EOE_ColLoop, @EOE_ColLoop_End)
  1006.         
  1007.         move.l    rowsToCopy, d2
  1008.     @EOE_RowLoop:
  1009.         move.l    d1, d0
  1010.         jmp        (a0)
  1011.     @EOE_ColLoop:
  1012. // BLIT
  1013. #define    BLIT \
  1014.         move.l    (srcPixelP)+, srcExtraStartTemp; \
  1015.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:0}; \
  1016.         addq.l    Num(4), dstPixelP;
  1017.         REPEAT(BLIT)
  1018. #undef    BLIT
  1019.     @EOE_ColLoop_End:
  1020.         
  1021.         subq.l    Num(1), d0
  1022.         bpl        @EOE_ColLoop
  1023. //BLIT EXTRA
  1024.         bfextu    (srcPixelP){0:dstExtraEnd}, srcExtraStartTemp
  1025.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:dstExtraEnd}
  1026.         
  1027.         adda.l    srcRowStride, srcPixelP
  1028.         adda.l    dstRowStride, dstPixelP
  1029.         
  1030.         subq.l    Num(1), d2
  1031.         bgt        @EOE_RowLoop
  1032. // STOP
  1033.         bra        @Done
  1034.         
  1035.     @OddEven:
  1036. // START Odd -> Even
  1037.         UNROLL(@OE_ColLoop, @OE_ColLoop_End)
  1038.         
  1039.         move.l    rowsToCopy, d2
  1040.     @OE_RowLoop:
  1041.         move.l    d1, d0
  1042.         jmp        (a0)
  1043.     @OE_ColLoop:
  1044. // BLIT
  1045. #define    BLIT \
  1046.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1047.         move.l    dstExtraStartTemp, (dstPixelP)+; \
  1048.         addq.l    Num(4), srcPixelP;
  1049.         REPEAT(BLIT)
  1050. #undef    BLIT
  1051.     @OE_ColLoop_End:
  1052.         
  1053.         subq.l    Num(1), d0
  1054.         bpl        @OE_ColLoop
  1055.         
  1056.         adda.l    srcRowStride, srcPixelP
  1057.         adda.l    dstRowStride, dstPixelP
  1058.         
  1059.         subq.l    Num(1), d2
  1060.         bgt        @OE_RowLoop
  1061. // STOP
  1062.         bra        @Done
  1063.     @OddEvenExtra:
  1064. // START Odd -> Even + Extra
  1065.         UNROLL(@OEE_ColLoop, @OEE_ColLoop_End)
  1066.         
  1067.         move.l    rowsToCopy, d2
  1068.     @OEE_RowLoop:
  1069.         move.l    d1, d0
  1070.         jmp        (a0)
  1071.     @OEE_ColLoop:
  1072. // BLIT
  1073. #define    BLIT \
  1074.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1075.         move.l    dstExtraStartTemp, (dstPixelP)+; \
  1076.         addq.l    Num(4), srcPixelP;
  1077.         REPEAT(BLIT)
  1078. #undef    BLIT
  1079.     @OEE_ColLoop_End:
  1080.         
  1081.         subq.l    Num(1), d0
  1082.         bpl        @OEE_ColLoop
  1083. // BLIT EXTRA
  1084.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, dstExtraStartTemp
  1085.         bfins    dstExtraStartTemp, (dstPixelP){0:dstExtraEnd}
  1086.         
  1087.         adda.l    srcRowStride, srcPixelP
  1088.         adda.l    dstRowStride, dstPixelP
  1089.         
  1090.         subq.l    Num(1), d2
  1091.         bgt        @OEE_RowLoop
  1092. // STOP
  1093.         bra        @Done
  1094.         
  1095.     @OddOdd:
  1096. // START Odd -> Odd
  1097.         UNROLL(@OO_ColLoop, @OO_ColLoop_End)
  1098.         
  1099.         move.l    rowsToCopy, d2
  1100.     @OO_RowLoop:
  1101.         move.l    d1, d0
  1102.         jmp        (a0)
  1103.     @OO_ColLoop:
  1104. // BLIT
  1105. #define    BLIT \
  1106.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraEndTemp; \
  1107.         bfins    dstExtraEndTemp, (dstPixelP){dstExtraStart:0}; \
  1108.         addq.l    Num(4), srcPixelP; \
  1109.         addq.l    Num(4), dstPixelP;
  1110.         REPEAT(BLIT)
  1111. #undef    BLIT
  1112.     @OO_ColLoop_End:
  1113.         
  1114.         subq.l    Num(1), d0
  1115.         bpl        @OO_ColLoop
  1116.         
  1117.         adda.l    srcRowStride, srcPixelP
  1118.         adda.l    dstRowStride, dstPixelP
  1119.         
  1120.         subq.l    Num(1), d2
  1121.         bgt        @OO_RowLoop
  1122. // STOP
  1123.         bra        @Done
  1124.     @OddOddExtra:
  1125. // START Odd -> Odd + Extra
  1126.         UNROLL(@OOE_ColLoop, @OOE_ColLoop_End)
  1127.         
  1128.     @OOE_RowLoop:
  1129.         move.l    d1, d0
  1130.         jmp        (a0)
  1131.     @OOE_ColLoop:
  1132. // BLIT
  1133. #define    BLIT \
  1134.         bfextu    (srcPixelP){srcExtraStart:0}, d2; \
  1135.         bfins    d2, (dstPixelP){dstExtraStart:0}; \
  1136.         addq.l    Num(4), srcPixelP; \
  1137.         addq.l    Num(4), dstPixelP;
  1138.         REPEAT(BLIT)
  1139. #undef    BLIT
  1140.     @OOE_ColLoop_End:
  1141.         
  1142.         subq.l    Num(1), d0
  1143.         bpl        @OOE_ColLoop
  1144. // BLIT EXTRA
  1145.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d2
  1146.         bfins    d2, (dstPixelP){dstExtraStart:dstExtraEnd}
  1147.         
  1148.         adda.l    srcRowStride, srcPixelP
  1149.         adda.l    dstRowStride, dstPixelP
  1150.         
  1151.         subq.l    Num(1), rowsToCopy
  1152.         bgt        @OOE_RowLoop
  1153. // STOP
  1154.         bra        @Done
  1155.         
  1156.     @VeryNarrow:
  1157. // START Very Narrow
  1158.         move.l    rowsToCopy, d2
  1159.     @VN_RowLoop:
  1160. // BLIT
  1161.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d0
  1162.         bfins    d0, (dstPixelP){dstExtraStart:dstExtraEnd}
  1163.         
  1164.         adda.l    srcRowStride, srcPixelP
  1165.         adda.l    dstRowStride, dstPixelP
  1166.         
  1167.         subq.l    Num(1), d2
  1168.         bgt        @VN_RowLoop
  1169. // STOP
  1170.         
  1171.     @Done:
  1172.         
  1173. #if __MWERKS__
  1174.         frfree
  1175. #endif
  1176.         
  1177.         SW_ASM_END
  1178. }
  1179.  
  1180. ///--------------------------------------------------------------------------------------
  1181. //        BlitPixieAllBitMask
  1182. ///--------------------------------------------------------------------------------------
  1183. SW_ASM_FUNC void BlitPixieAllBitMask(
  1184.     register PixelPtr srcPixelP,
  1185.     register PixelPtr dstPixelP,
  1186.     register PixelPtr maskPixelP,
  1187.     unsigned long rowsToCopy,
  1188.     unsigned long numBytesPerRow,
  1189.     register unsigned long srcRowStride,
  1190.     register unsigned long dstRowStride,
  1191.     register unsigned long srcExtraStart,
  1192.     register unsigned long dstExtraStart,
  1193.     register unsigned long dstExtraEnd)
  1194. {
  1195.         SW_ASM_BEGIN
  1196.         
  1197. #if __MWERKS__
  1198.         fralloc +
  1199. #endif
  1200.         
  1201.         move.l    numBytesPerRow, d1
  1202.         lsr.l    Num(2), d1
  1203.         beq        @VeryNarrow
  1204.         
  1205.         tst.l    srcExtraStart
  1206.         bne        @SrcExtraStart
  1207.         
  1208.         tst.l    dstExtraStart
  1209.         bne        @DstExtraStart
  1210.         
  1211.     @NoExtraStart:
  1212.         tst.l    dstExtraEnd
  1213.         beq        @EvenEven
  1214.         bra        @EvenEvenExtra
  1215.         
  1216.     @DstExtraStart:
  1217.         move.l    dstExtraStart, d0
  1218.         and.l    Num(0x07), d0
  1219.         beq        @ADstExtraStart
  1220.         
  1221.         tst.l    dstExtraEnd
  1222.         beq        @EvenOdd
  1223.         bra        @EvenOddExtra
  1224.         
  1225.     @ADstExtraStart:
  1226.         move.l    dstExtraStart, d0
  1227.         lsr.l    Num(3), d0
  1228.         add.l    d0, dstPixelP
  1229.         tst.l    dstExtraEnd
  1230.         beq        @EvenEven
  1231.         bra        @EvenEvenExtra
  1232.         
  1233.     @SrcExtraStart:
  1234.         tst.l    dstExtraStart
  1235.         bne        @SrcDstExtraStart
  1236.     @NoDstExtraStart:
  1237.         move.l    srcExtraStart, d0
  1238.         and.l    Num(0x07), d0
  1239.         beq        @ASrcExtraStart
  1240.         
  1241.         tst.l    dstExtraEnd
  1242.         beq        @OddEven
  1243.         bra        @OddEvenExtra
  1244.         
  1245.     @ASrcExtraStart:
  1246.         move.l    srcExtraStart, d0
  1247.         lsr.l    Num(3), d0
  1248.         add.l    d0, srcPixelP
  1249.         add.l    d0, maskPixelP
  1250.         tst.l    dstExtraEnd
  1251.         beq        @EvenEven
  1252.         bra        @EvenEvenExtra
  1253.         
  1254.     @SrcDstExtraStart:
  1255.         move.l    srcExtraStart, d0
  1256.         and.l    Num(0x07), d0
  1257.         beq        @ASrcDstExtraStart
  1258.         move.l    dstExtraStart, d0
  1259.         and.l    Num(0x07), d0
  1260.         beq        @ADstSrcExtraStart
  1261.         
  1262.         tst.l    dstExtraEnd
  1263.         beq        @OddOdd
  1264.         bra        @OddOddExtra
  1265.         
  1266.     @ASrcDstExtraStart:
  1267.         move.l    dstExtraStart, d0
  1268.         and.l    Num(0x07), d0
  1269.         beq        @AASrcDstExtraStart
  1270.         
  1271.         move.l    srcExtraStart, d0
  1272.         lsr.l    Num(3), d0
  1273.         add.l    d0, srcPixelP
  1274.         add.l    d0, maskPixelP
  1275.         tst.l    dstExtraEnd
  1276.         beq        @EvenOdd
  1277.         bra        @EvenOddExtra
  1278.         
  1279.     @ADstSrcExtraStart:
  1280.         move.l    dstExtraStart, d0
  1281.         lsr.l    Num(3), d0
  1282.         add.l    d0, dstPixelP
  1283.         tst.l    dstExtraEnd
  1284.         beq        @OddEven
  1285.         bra        @OddEvenExtra
  1286.         
  1287.     @AASrcDstExtraStart:
  1288.         move.l    srcExtraStart, d0
  1289.         lsr.l    Num(3), d0
  1290.         add.l    d0, srcPixelP
  1291.         add.l    d0, maskPixelP
  1292.         move.l    dstExtraStart, d0
  1293.         lsr.l    Num(3), d0
  1294.         add.l    d0, dstPixelP
  1295.         tst.l    dstExtraEnd
  1296.         beq        @EvenEven
  1297.         bra        @EvenEvenExtra
  1298.         
  1299.     @EvenEven:
  1300. // START Even -> Even
  1301.         UNROLL(@EE_ColLoop, @EE_ColLoop_End)
  1302.         
  1303.         move.l    rowsToCopy, d2
  1304.     @EE_RowLoop:
  1305.         move.l    d1, d0
  1306.         jmp        (a0)
  1307.     @EE_ColLoop:
  1308. // BLIT
  1309. #define    BLIT \
  1310.         move.l    (dstPixelP), dstExtraEndTemp; \
  1311.         and.l    (maskPixelP)+, dstExtraEndTemp; \
  1312.         or.l    (srcPixelP)+, dstExtraEndTemp; \
  1313.         move.l    dstExtraEndTemp, (dstPixelP)+;
  1314.         REPEAT(BLIT)
  1315. #undef    BLIT
  1316.     @EE_ColLoop_End:
  1317.         
  1318.         subq.l    Num(1), d0
  1319.         bpl        @EE_ColLoop
  1320.         
  1321.         adda.l    srcRowStride, srcPixelP
  1322.         adda.l    dstRowStride, dstPixelP
  1323.         adda.l    srcRowStride, maskPixelP
  1324.         
  1325.         subq.l    Num(1), d2
  1326.         bgt        @EE_RowLoop
  1327. // STOP
  1328.         bra        @Done
  1329.     @EvenEvenExtra:
  1330. // START Even -> Even + Extra
  1331.         UNROLL(@EEE_ColLoop, @EEE_ColLoop_End)
  1332.         
  1333.         move.l    rowsToCopy, d2
  1334.     @EEE_RowLoop:
  1335.         move.l    d1, d0
  1336.         jmp        (a0)
  1337.     @EEE_ColLoop:
  1338. // BLIT
  1339. #define    BLIT \
  1340.         move.l    (dstPixelP), srcExtraStartTemp; \
  1341.         and.l    (maskPixelP)+, srcExtraStartTemp; \
  1342.         or.l    (srcPixelP)+, srcExtraStartTemp; \
  1343.         move.l    srcExtraStartTemp, (dstPixelP)+;
  1344.         REPEAT(BLIT)
  1345. #undef    BLIT
  1346.     @EEE_ColLoop_End:
  1347.         
  1348.         subq.l    Num(1), d0
  1349.         bpl        @EEE_ColLoop
  1350. // BLIT EXTRA
  1351.         bfextu    (dstPixelP){0:dstExtraEnd}, srcExtraStartTemp
  1352.         bfextu    (maskPixelP){0:dstExtraEnd}, dstExtraStartTemp
  1353.         and.l    dstExtraStartTemp, srcExtraStartTemp
  1354.         bfextu    (srcPixelP){0:dstExtraEnd}, dstExtraStartTemp
  1355.         or.l    dstExtraStartTemp, srcExtraStartTemp
  1356.         bfins    srcExtraStartTemp, (dstPixelP){0:dstExtraEnd}
  1357.         
  1358.         adda.l    srcRowStride, srcPixelP
  1359.         adda.l    dstRowStride, dstPixelP
  1360.         adda.l    srcRowStride, maskPixelP
  1361.         
  1362.         subq.l    Num(1), d2
  1363.         bgt        @EEE_RowLoop
  1364. // STOP
  1365.         bra        @Done
  1366.         
  1367.     @EvenOdd:
  1368. // START Even -> Odd
  1369.         UNROLL(@EO_ColLoop, @EO_ColLoop_End)
  1370.         
  1371.         move.l    rowsToCopy, d2
  1372.     @EO_RowLoop:
  1373.         move.l    d1, d0
  1374.         jmp        (a0)
  1375.     @EO_ColLoop:
  1376. // BLIT
  1377. #define    BLIT \
  1378.         bfextu    (dstPixelP){dstExtraStart:0}, srcExtraStartTemp; \
  1379.         and.l    (maskPixelP)+, srcExtraStartTemp; \
  1380.         or.l    (srcPixelP)+, srcExtraStartTemp; \
  1381.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:0}; \
  1382.         addq.l    Num(4), dstPixelP;
  1383.         REPEAT(BLIT)
  1384. #undef    BLIT
  1385.     @EO_ColLoop_End:
  1386.         
  1387.         subq.l    Num(1), d0
  1388.         bpl        @EO_ColLoop
  1389.         
  1390.         adda.l    srcRowStride, srcPixelP
  1391.         adda.l    dstRowStride, dstPixelP
  1392.         adda.l    srcRowStride, maskPixelP
  1393.         
  1394.         subq.l    Num(1), d2
  1395.         bgt        @EO_RowLoop
  1396. // STOP
  1397.         bra        @Done
  1398.     @EvenOddExtra:
  1399. // START Even -> Odd + Extra
  1400.         UNROLL(@EOE_ColLoop, @EOE_ColLoop_End)
  1401.         
  1402.         move.l    rowsToCopy, d2
  1403.     @EOE_RowLoop:
  1404.         move.l    d1, d0
  1405.         jmp        (a0)
  1406.     @EOE_ColLoop:
  1407. // BLIT
  1408. #define    BLIT \
  1409.         bfextu    (dstPixelP){dstExtraStart:0}, srcExtraStartTemp; \
  1410.         and.l    (maskPixelP)+, srcExtraStartTemp; \
  1411.         or.l    (srcPixelP)+, srcExtraStartTemp; \
  1412.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:0}; \
  1413.         addq.l    Num(4), dstPixelP;
  1414.         REPEAT(BLIT)
  1415. #undef    BLIT
  1416.     @EOE_ColLoop_End:
  1417.         
  1418.         subq.l    Num(1), d0
  1419.         bpl        @EOE_ColLoop
  1420. //BLIT EXTRA
  1421.         bfextu    (dstPixelP){dstExtraStart:dstExtraEnd}, srcExtraStartTemp
  1422.         bfextu    (maskPixelP){0:dstExtraEnd}, d0
  1423.         and.l    d0, srcExtraStartTemp
  1424.         bfextu    (srcPixelP){0:dstExtraEnd}, d0
  1425.         or.l    d0, srcExtraStartTemp
  1426.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:dstExtraEnd}
  1427.         
  1428.         adda.l    srcRowStride, srcPixelP
  1429.         adda.l    dstRowStride, dstPixelP
  1430.         adda.l    srcRowStride, maskPixelP
  1431.         
  1432.         subq.l    Num(1), d2
  1433.         bgt        @EOE_RowLoop
  1434. // STOP
  1435.         bra        @Done
  1436.         
  1437.     @OddEven:
  1438. // START Odd -> Even
  1439.         UNROLL(@OE_ColLoop, @OE_ColLoop_End)
  1440.         
  1441.         move.l    rowsToCopy, d2
  1442.     @OE_RowLoop:
  1443.         move.l    d1, d0
  1444.         jmp        (a0)
  1445.     @OE_ColLoop:
  1446. // BLIT
  1447. #define    BLIT \
  1448.         bfextu    (maskPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1449.         and.l    dstExtraStartTemp, (dstPixelP); \
  1450.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1451.         or.l    dstExtraStartTemp, (dstPixelP)+; \
  1452.         addq.l    Num(4), srcPixelP; \
  1453.         addq.l    Num(4), maskPixelP;
  1454.         REPEAT(BLIT)
  1455. #undef    BLIT
  1456.     @OE_ColLoop_End:
  1457.         
  1458.         subq.l    Num(1), d0
  1459.         bpl        @OE_ColLoop
  1460.         
  1461.         adda.l    srcRowStride, srcPixelP
  1462.         adda.l    dstRowStride, dstPixelP
  1463.         adda.l    srcRowStride, maskPixelP
  1464.         
  1465.         subq.l    Num(1), d2
  1466.         bgt        @OE_RowLoop
  1467. // STOP
  1468.         bra        @Done
  1469.     @OddEvenExtra:
  1470. // START Odd -> Even + Extra
  1471.         UNROLL(@OEE_ColLoop, @OEE_ColLoop_End)
  1472.         
  1473.         move.l    rowsToCopy, d2
  1474.     @OEE_RowLoop:
  1475.         move.l    d1, d0
  1476.         jmp        (a0)
  1477.     @OEE_ColLoop:
  1478. // BLIT
  1479. #define    BLIT \
  1480.         bfextu    (maskPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1481.         and.l    dstExtraStartTemp, (dstPixelP); \
  1482.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1483.         or.l    dstExtraStartTemp, (dstPixelP)+; \
  1484.         addq.l    Num(4), srcPixelP; \
  1485.         addq.l    Num(4), maskPixelP;
  1486.         REPEAT(BLIT)
  1487. #undef    BLIT
  1488.     @OEE_ColLoop_End:
  1489.         
  1490.         subq.l    Num(1), d0
  1491.         bpl        @OEE_ColLoop
  1492. // BLIT EXTRA
  1493.         bfextu    (dstPixelP){0:dstExtraEnd}, d0
  1494.         bfextu    (maskPixelP){srcExtraStart:dstExtraEnd}, dstExtraStartTemp
  1495.         and.l    dstExtraStartTemp, d0
  1496.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, dstExtraStartTemp
  1497.         or.l    dstExtraStartTemp, d0
  1498.         bfins    d0, (dstPixelP){0:dstExtraEnd}
  1499.         
  1500.         adda.l    srcRowStride, srcPixelP
  1501.         adda.l    dstRowStride, dstPixelP
  1502.         adda.l    srcRowStride, maskPixelP
  1503.         
  1504.         subq.l    Num(1), d2
  1505.         bgt        @OEE_RowLoop
  1506. // STOP
  1507.         bra        @Done
  1508.         
  1509.     @OddOdd:
  1510. // START Odd -> Odd
  1511.         UNROLL(@OO_ColLoop, @OO_ColLoop_End)
  1512.         
  1513.     @OO_RowLoop:
  1514.         move.l    d1, d0
  1515.         jmp        (a0)
  1516.     @OO_ColLoop:
  1517. // BLIT
  1518. #define    BLIT \
  1519.         bfextu    (dstPixelP){dstExtraStart:0}, dstExtraEndTemp; \
  1520.         bfextu    (maskPixelP){srcExtraStart:0}, d2; \
  1521.         and.l    d2, dstExtraEndTemp; \
  1522.         bfextu    (srcPixelP){srcExtraStart:0}, d2; \
  1523.         or.l    d2, dstExtraEndTemp; \
  1524.         bfins    dstExtraEndTemp, (dstPixelP){dstExtraStart:0}; \
  1525.         addq.l    Num(4), srcPixelP; \
  1526.         addq.l    Num(4), dstPixelP; \
  1527.         addq.l    Num(4), maskPixelP;
  1528.         REPEAT(BLIT)
  1529. #undef    BLIT
  1530.     @OO_ColLoop_End:
  1531.         
  1532.         subq.l    Num(1), d0
  1533.         bpl        @OO_ColLoop
  1534.         
  1535.         adda.l    srcRowStride, srcPixelP
  1536.         adda.l    dstRowStride, dstPixelP
  1537.         adda.l    srcRowStride, maskPixelP
  1538.         
  1539.         subq.l    Num(1), rowsToCopy
  1540.         bgt        @OO_RowLoop
  1541. // STOP
  1542.         bra        @Done
  1543.     @OddOddExtra:
  1544. // START Odd -> Odd + Extra
  1545.         UNROLL(@OOE_ColLoop, @OOE_ColLoop_End)
  1546.         
  1547.         move.l    d1, numBytesPerRow
  1548.     @OOE_RowLoop:
  1549.         move.l    numBytesPerRow, d0
  1550.         jmp        (a0)
  1551.     @OOE_ColLoop:
  1552. // BLIT
  1553. #define    BLIT \
  1554.         bfextu    (dstPixelP){dstExtraStart:0}, d1; \
  1555.         bfextu    (maskPixelP){srcExtraStart:0}, d2; \
  1556.         and.l    d2, d1; \
  1557.         bfextu    (srcPixelP){srcExtraStart:0}, d2; \
  1558.         or.l    d2, d1; \
  1559.         bfins    d1, (dstPixelP){dstExtraStart:0}; \
  1560.         addq.l    Num(4), srcPixelP; \
  1561.         addq.l    Num(4), dstPixelP; \
  1562.         addq.l    Num(4), maskPixelP;
  1563.         REPEAT(BLIT)
  1564. #undef    BLIT
  1565.     @OOE_ColLoop_End:
  1566.         
  1567.         subq.l    Num(1), d0
  1568.         bpl        @OOE_ColLoop
  1569. // BLIT EXTRA
  1570.         bfextu    (dstPixelP){dstExtraStart:dstExtraEnd}, d0
  1571.         bfextu    (maskPixelP){srcExtraStart:dstExtraEnd}, d2
  1572.         and.l    d2, d0
  1573.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d2
  1574.         or.l    d2, d0
  1575.         bfins    d0, (dstPixelP){dstExtraStart:dstExtraEnd}
  1576.         
  1577.         adda.l    srcRowStride, srcPixelP
  1578.         adda.l    dstRowStride, dstPixelP
  1579.         adda.l    srcRowStride, maskPixelP
  1580.         
  1581.         subq.l    Num(1), rowsToCopy
  1582.         bgt        @OOE_RowLoop
  1583. // STOP
  1584.         bra        @Done
  1585.         
  1586.     @VeryNarrow:
  1587. // START Very Narrow
  1588.         move.l    rowsToCopy, d2
  1589.     @VN_RowLoop:
  1590. // BLIT
  1591.         bfextu    (dstPixelP){dstExtraStart:dstExtraEnd}, d0
  1592.         bfextu    (maskPixelP){srcExtraStart:dstExtraEnd}, d1
  1593.         and.l    d1, d0
  1594.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d1
  1595.         or.l    d1, d0
  1596.         bfins    d0, (dstPixelP){dstExtraStart:dstExtraEnd}
  1597.         
  1598.         adda.l    srcRowStride, srcPixelP
  1599.         adda.l    dstRowStride, dstPixelP
  1600.         adda.l    srcRowStride, maskPixelP
  1601.         
  1602.         subq.l    Num(1), d2
  1603.         bgt        @VN_RowLoop
  1604. // STOP
  1605.         
  1606.     @Done:
  1607.         
  1608. #if __MWERKS__
  1609.         frfree
  1610. #endif
  1611.         
  1612.         SW_ASM_END
  1613. }
  1614.  
  1615. ///--------------------------------------------------------------------------------------
  1616. //        BlitPixieAllBitPartialMask
  1617. ///--------------------------------------------------------------------------------------
  1618. SW_ASM_FUNC void BlitPixieAllBitPartialMask(
  1619.     register PixelPtr srcPixelP,
  1620.     register PixelPtr dstPixelP,
  1621.     register PixelPtr maskPixelP,
  1622.     unsigned long rowsToCopy,
  1623.     unsigned long numBytesPerRow,
  1624.     register unsigned long srcRowStride,
  1625.     register unsigned long dstRowStride,
  1626.     register unsigned long srcExtraStart,
  1627.     register unsigned long dstExtraStart,
  1628.     register unsigned long dstExtraEnd)
  1629. {
  1630.         SW_ASM_BEGIN
  1631.         
  1632. #if __MWERKS__
  1633.         fralloc +
  1634. #endif
  1635.         
  1636.         move.l    numBytesPerRow, d1
  1637.         lsr.l    Num(2), d1
  1638.         beq        @VeryNarrow
  1639.         
  1640.         tst.l    srcExtraStart
  1641.         bne        @SrcExtraStart
  1642.         
  1643.         tst.l    dstExtraStart
  1644.         bne        @DstExtraStart
  1645.         
  1646.     @NoExtraStart:
  1647.         tst.l    dstExtraEnd
  1648.         beq        @EvenEven
  1649.         bra        @EvenEvenExtra
  1650.         
  1651.     @DstExtraStart:
  1652.         move.l    dstExtraStart, d0
  1653.         and.l    Num(0x07), d0
  1654.         beq        @ADstExtraStart
  1655.         
  1656.         tst.l    dstExtraEnd
  1657.         beq        @EvenOdd
  1658.         bra        @EvenOddExtra
  1659.         
  1660.     @ADstExtraStart:
  1661.         move.l    dstExtraStart, d0
  1662.         lsr.l    Num(3), d0
  1663.         add.l    d0, dstPixelP
  1664.         tst.l    dstExtraEnd
  1665.         beq        @EvenEven
  1666.         bra        @EvenEvenExtra
  1667.         
  1668.     @SrcExtraStart:
  1669.         tst.l    dstExtraStart
  1670.         bne        @SrcDstExtraStart
  1671.     @NoDstExtraStart:
  1672.         move.l    srcExtraStart, d0
  1673.         and.l    Num(0x07), d0
  1674.         beq        @ASrcExtraStart
  1675.         
  1676.         tst.l    dstExtraEnd
  1677.         beq        @OddEven
  1678.         bra        @OddEvenExtra
  1679.         
  1680.     @ASrcExtraStart:
  1681.         move.l    srcExtraStart, d0
  1682.         lsr.l    Num(3), d0
  1683.         add.l    d0, srcPixelP
  1684.         add.l    d0, maskPixelP
  1685.         tst.l    dstExtraEnd
  1686.         beq        @EvenEven
  1687.         bra        @EvenEvenExtra
  1688.         
  1689.     @SrcDstExtraStart:
  1690.         move.l    srcExtraStart, d0
  1691.         and.l    Num(0x07), d0
  1692.         beq        @ASrcDstExtraStart
  1693.         move.l    dstExtraStart, d0
  1694.         and.l    Num(0x07), d0
  1695.         beq        @ADstSrcExtraStart
  1696.         
  1697.         tst.l    dstExtraEnd
  1698.         beq        @OddOdd
  1699.         bra        @OddOddExtra
  1700.         
  1701.     @ASrcDstExtraStart:
  1702.         move.l    dstExtraStart, d0
  1703.         and.l    Num(0x07), d0
  1704.         beq        @AASrcDstExtraStart
  1705.         
  1706.         move.l    srcExtraStart, d0
  1707.         lsr.l    Num(3), d0
  1708.         add.l    d0, srcPixelP
  1709.         add.l    d0, maskPixelP
  1710.         tst.l    dstExtraEnd
  1711.         beq        @EvenOdd
  1712.         bra        @EvenOddExtra
  1713.         
  1714.     @ADstSrcExtraStart:
  1715.         move.l    dstExtraStart, d0
  1716.         lsr.l    Num(3), d0
  1717.         add.l    d0, dstPixelP
  1718.         tst.l    dstExtraEnd
  1719.         beq        @OddEven
  1720.         bra        @OddEvenExtra
  1721.         
  1722.     @AASrcDstExtraStart:
  1723.         move.l    srcExtraStart, d0
  1724.         lsr.l    Num(3), d0
  1725.         add.l    d0, srcPixelP
  1726.         add.l    d0, maskPixelP
  1727.         move.l    dstExtraStart, d0
  1728.         lsr.l    Num(3), d0
  1729.         add.l    d0, dstPixelP
  1730.         tst.l    dstExtraEnd
  1731.         beq        @EvenEven
  1732.         bra        @EvenEvenExtra
  1733.         
  1734.     @EvenEven:
  1735. // START Even -> Even
  1736.         UNROLL(@EE_ColLoop, @EE_ColLoop_End)
  1737.         
  1738.         move.l    rowsToCopy, d2
  1739.     @EE_RowLoop:
  1740.         move.l    d1, d0
  1741.         jmp        (a0)
  1742.     @EE_ColLoop:
  1743. // BLIT
  1744. #define    BLIT \
  1745.         move.l    (maskPixelP)+, dstExtraEndTemp; \
  1746.         and.l    dstExtraEndTemp, (dstPixelP); \
  1747.         not.l    dstExtraEndTemp; \
  1748.         and.l    (srcPixelP)+, dstExtraEndTemp; \
  1749.         or.l    dstExtraEndTemp, (dstPixelP)+;
  1750.         REPEAT(BLIT)
  1751. #undef    BLIT
  1752.     @EE_ColLoop_End:
  1753.         
  1754.         subq.l    Num(1), d0
  1755.         bpl        @EE_ColLoop
  1756.         
  1757.         adda.l    srcRowStride, srcPixelP
  1758.         adda.l    dstRowStride, dstPixelP
  1759.         adda.l    srcRowStride, maskPixelP
  1760.         
  1761.         subq.l    Num(1), d2
  1762.         bgt        @EE_RowLoop
  1763. // STOP
  1764.         bra        @Done
  1765.     @EvenEvenExtra:
  1766. // START Even -> Even + Extra
  1767.         UNROLL(@EEE_ColLoop, @EEE_ColLoop_End)
  1768.         
  1769.         move.l    rowsToCopy, d2
  1770.     @EEE_RowLoop:
  1771.         move.l    d1, d0
  1772.         jmp        (a0)
  1773.     @EEE_ColLoop:
  1774. // BLIT
  1775. #define    BLIT \
  1776.         move.l    (maskPixelP)+, srcExtraStartTemp; \
  1777.         and.l    srcExtraStartTemp, (dstPixelP); \
  1778.         not.l    srcExtraStartTemp; \
  1779.         and.l    (srcPixelP)+, srcExtraStartTemp; \
  1780.         or.l    srcExtraStartTemp, (dstPixelP)+;
  1781.         REPEAT(BLIT)
  1782. #undef    BLIT
  1783.     @EEE_ColLoop_End:
  1784.         
  1785.         subq.l    Num(1), d0
  1786.         bpl        @EEE_ColLoop
  1787. // BLIT EXTRA
  1788.         bfextu    (srcPixelP){0:dstExtraEnd}, d0
  1789.         bfextu    (dstPixelP){0:dstExtraEnd}, srcExtraStartTemp
  1790.         bfextu    (maskPixelP){0:dstExtraEnd}, dstExtraStartTemp
  1791.         and.l    dstExtraStartTemp, srcExtraStartTemp
  1792.         not.l    dstExtraStartTemp
  1793.         and.l    dstExtraStartTemp, d0
  1794.         or.l    srcExtraStartTemp, d0
  1795.         bfins    d0, (dstPixelP){0:dstExtraEnd}
  1796.         
  1797.         adda.l    srcRowStride, srcPixelP
  1798.         adda.l    dstRowStride, dstPixelP
  1799.         adda.l    srcRowStride, maskPixelP
  1800.         
  1801.         subq.l    Num(1), d2
  1802.         bgt        @EEE_RowLoop
  1803. // STOP
  1804.         bra        @Done
  1805.         
  1806.     @EvenOdd:
  1807. // START Even -> Odd
  1808.         UNROLL(@EO_ColLoop, @EO_ColLoop_End)
  1809.         
  1810.         move.l    rowsToCopy, d2
  1811.     @EO_RowLoop:
  1812.         move.l    d1, d0
  1813.         jmp        (a0)
  1814.     @EO_ColLoop:
  1815. // BLIT
  1816. #define    BLIT \
  1817.         move.l    (maskPixelP)+, dstExtraEndTemp; \
  1818.         bfextu    (dstPixelP){dstExtraStart:0}, srcExtraStartTemp; \
  1819.         and.l    dstExtraEndTemp, srcExtraStartTemp; \
  1820.         not.l    dstExtraEndTemp; \
  1821.         and.l    (srcPixelP)+, dstExtraEndTemp; \
  1822.         or.l    dstExtraEndTemp, srcExtraStartTemp; \
  1823.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:0}; \
  1824.         addq.l    Num(4), dstPixelP;
  1825.         REPEAT(BLIT)
  1826. #undef    BLIT
  1827.     @EO_ColLoop_End:
  1828.         
  1829.         subq.l    Num(1), d0
  1830.         bpl        @EO_ColLoop
  1831.         
  1832.         adda.l    srcRowStride, srcPixelP
  1833.         adda.l    dstRowStride, dstPixelP
  1834.         adda.l    srcRowStride, maskPixelP
  1835.         
  1836.         subq.l    Num(1), d2
  1837.         bgt        @EO_RowLoop
  1838. // STOP
  1839.         bra        @Done
  1840.     @EvenOddExtra:
  1841. // START Even -> Odd + Extra
  1842.         UNROLL(@EOE_ColLoop, @EOE_ColLoop_End)
  1843.         
  1844. //        move.l    rowsToCopy, d2
  1845.     @EOE_RowLoop:
  1846.         move.l    d1, d0
  1847.         jmp        (a0)
  1848.     @EOE_ColLoop:
  1849. // BLIT
  1850. #define    BLIT \
  1851.         move.l    (maskPixelP)+, d2; \
  1852.         bfextu    (dstPixelP){dstExtraStart:0}, srcExtraStartTemp; \
  1853.         and.l    d2, srcExtraStartTemp; \
  1854.         not.l    d2; \
  1855.         and.l    (srcPixelP)+, d2; \
  1856.         or.l    d2, srcExtraStartTemp; \
  1857.         bfins    srcExtraStartTemp, (dstPixelP){dstExtraStart:0}; \
  1858.         addq.l    Num(4), dstPixelP;
  1859.         REPEAT(BLIT)
  1860. #undef    BLIT
  1861.     @EOE_ColLoop_End:
  1862.         
  1863.         subq.l    Num(1), d0
  1864.         bpl        @EOE_ColLoop
  1865. //BLIT EXTRA
  1866.         bfextu    (srcPixelP){0:dstExtraEnd}, d0
  1867.         bfextu    (dstPixelP){dstExtraStart:dstExtraEnd}, srcExtraStartTemp
  1868.         bfextu    (maskPixelP){0:dstExtraEnd}, d2
  1869.         and.l    d2, srcExtraStartTemp
  1870.         not.l    d2
  1871.         and.l    d2, d0
  1872.         or.l    srcExtraStartTemp, d0
  1873.         bfins    d0, (dstPixelP){dstExtraStart:dstExtraEnd}
  1874.         
  1875.         adda.l    srcRowStride, srcPixelP
  1876.         adda.l    dstRowStride, dstPixelP
  1877.         adda.l    srcRowStride, maskPixelP
  1878.         
  1879.         subq.l    Num(1), rowsToCopy
  1880.         bgt        @EOE_RowLoop
  1881. // STOP
  1882.         bra        @Done
  1883.         
  1884.     @OddEven:
  1885. // START Odd -> Even
  1886.         UNROLL(@OE_ColLoop, @OE_ColLoop_End)
  1887.         
  1888.         move.l    rowsToCopy, d2
  1889.     @OE_RowLoop:
  1890.         move.l    d1, d0
  1891.         jmp        (a0)
  1892.     @OE_ColLoop:
  1893. // BLIT
  1894. #define    BLIT \
  1895.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1896.         bfextu    (maskPixelP){srcExtraStart:0}, dstExtraEndTemp; \
  1897.         and.l    dstExtraEndTemp, (dstPixelP); \
  1898.         not.l    dstExtraEndTemp; \
  1899.         and.l    dstExtraEndTemp, dstExtraStartTemp; \
  1900.         or.l    dstExtraStartTemp, (dstPixelP)+; \
  1901.         addq.l    Num(4), srcPixelP; \
  1902.         addq.l    Num(4), maskPixelP;
  1903.         REPEAT(BLIT)
  1904. #undef    BLIT
  1905.     @OE_ColLoop_End:
  1906.         
  1907.         subq.l    Num(1), d0
  1908.         bpl        @OE_ColLoop
  1909.         
  1910.         adda.l    srcRowStride, srcPixelP
  1911.         adda.l    dstRowStride, dstPixelP
  1912.         adda.l    srcRowStride, maskPixelP
  1913.         
  1914.         subq.l    Num(1), d2
  1915.         bgt        @OE_RowLoop
  1916. // STOP
  1917.         bra        @Done
  1918.     @OddEvenExtra:
  1919. // START Odd -> Even + Extra
  1920.         UNROLL(@OEE_ColLoop, @OEE_ColLoop_End)
  1921.         
  1922.     @OEE_RowLoop:
  1923.         move.l    d1, d0
  1924.         jmp        (a0)
  1925.     @OEE_ColLoop:
  1926. // BLIT
  1927. #define    BLIT \
  1928.         bfextu    (srcPixelP){srcExtraStart:0}, dstExtraStartTemp; \
  1929.         bfextu    (maskPixelP){srcExtraStart:0}, d2; \
  1930.         and.l    d2, (dstPixelP); \
  1931.         not.l    d2; \
  1932.         and.l    d2, dstExtraStartTemp; \
  1933.         or.l    dstExtraStartTemp, (dstPixelP)+; \
  1934.         addq.l    Num(4), srcPixelP; \
  1935.         addq.l    Num(4), maskPixelP;
  1936.         REPEAT(BLIT)
  1937. #undef    BLIT
  1938.     @OEE_ColLoop_End:
  1939.         
  1940.         subq.l    Num(1), d0
  1941.         bpl        @OEE_ColLoop
  1942. // BLIT EXTRA
  1943.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d0
  1944.         bfextu    (dstPixelP){0:dstExtraEnd}, dstExtraStartTemp
  1945.         bfextu    (maskPixelP){srcExtraStart:dstExtraEnd}, d2
  1946.         and.l    d2, dstExtraStartTemp
  1947.         not.l    d2
  1948.         and.l    d2, d0
  1949.         or.l    dstExtraStartTemp, d0
  1950.         bfins    d0, (dstPixelP){0:dstExtraEnd}
  1951.         
  1952.         adda.l    srcRowStride, srcPixelP
  1953.         adda.l    dstRowStride, dstPixelP
  1954.         adda.l    srcRowStride, maskPixelP
  1955.         
  1956.         subq.l    Num(1), rowsToCopy
  1957.         bgt        @OEE_RowLoop
  1958. // STOP
  1959.         bra        @Done
  1960.         
  1961.     @OddOdd:
  1962. // START Odd -> Odd
  1963.         UNROLL(@OO_ColLoop, @OO_ColLoop_End)
  1964.         
  1965.         move.l    d1, numBytesPerRow
  1966.     @OO_RowLoop:
  1967.         move.l    numBytesPerRow, d0
  1968.         jmp        (a0)
  1969.     @OO_ColLoop:
  1970. // BLIT
  1971. #define    BLIT \
  1972.         bfextu    (srcPixelP){srcExtraStart:0}, d1; \
  1973.         bfextu    (dstPixelP){dstExtraStart:0}, dstExtraEndTemp; \
  1974.         bfextu    (maskPixelP){srcExtraStart:0}, d2; \
  1975.         and.l    d2, dstExtraEndTemp; \
  1976.         not.l    d2; \
  1977.         and.l    d2, d1; \
  1978.         or.l    dstExtraEndTemp, d1; \
  1979.         bfins    d1, (dstPixelP){dstExtraStart:0}; \
  1980.         addq.l    Num(4), srcPixelP; \
  1981.         addq.l    Num(4), dstPixelP; \
  1982.         addq.l    Num(4), maskPixelP;
  1983.         REPEAT(BLIT)
  1984. #undef    BLIT
  1985.     @OO_ColLoop_End:
  1986.         
  1987.         subq.l    Num(1), d0
  1988.         bpl        @OO_ColLoop
  1989.         
  1990.         adda.l    srcRowStride, srcPixelP
  1991.         adda.l    dstRowStride, dstPixelP
  1992.         adda.l    srcRowStride, maskPixelP
  1993.         
  1994.         subq.l    Num(1), rowsToCopy
  1995.         bgt        @OO_RowLoop
  1996. // STOP
  1997.         bra        @Done
  1998.     @OddOddExtra:
  1999. // START Odd -> Odd + Extra
  2000.         UNROLL(@OOE_ColLoop, @OOE_ColLoop_End)
  2001.         
  2002.         move.l    d1, numBytesPerRow
  2003.         move.l    dstRowStride, -(sp)
  2004.     @OOE_RowLoop:
  2005.         move.l    numBytesPerRow, d0
  2006.         jmp        (a0)
  2007.     @OOE_ColLoop:
  2008. // BLIT
  2009. #define    BLIT \
  2010.         bfextu    (srcPixelP){srcExtraStart:0}, dstRowStrideTemp; \
  2011.         bfextu    (dstPixelP){dstExtraStart:0}, d1; \
  2012.         bfextu    (maskPixelP){srcExtraStart:0}, d2; \
  2013.         and.l    d2, d1; \
  2014.         not.l    d2; \
  2015.         and.l    d2, dstRowStrideTemp; \
  2016.         or.l    d1, dstRowStrideTemp; \
  2017.         bfins    dstRowStrideTemp, (dstPixelP){dstExtraStart:0}; \
  2018.         addq.l    Num(4), srcPixelP; \
  2019.         addq.l    Num(4), dstPixelP; \
  2020.         addq.l    Num(4), maskPixelP;
  2021.         REPEAT(BLIT)
  2022. #undef    BLIT
  2023.     @OOE_ColLoop_End:
  2024.         
  2025.         subq.l    Num(1), d0
  2026.         bpl        @OOE_ColLoop
  2027. // BLIT EXTRA
  2028.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d0
  2029.         bfextu    (dstPixelP){dstExtraStart:dstExtraEnd}, d1
  2030.         bfextu    (maskPixelP){srcExtraStart:dstExtraEnd}, d2
  2031.         and.l    d2, d1
  2032.         not.l    d2
  2033.         and.l    d2, d0
  2034.         or.l    d1, d0
  2035.         bfins    d0, (dstPixelP){dstExtraStart:dstExtraEnd}
  2036.         
  2037.         adda.l    srcRowStride, srcPixelP
  2038.         adda.l    (sp), dstPixelP
  2039.         adda.l    srcRowStride, maskPixelP
  2040.         
  2041.         subq.l    Num(1), rowsToCopy
  2042.         bgt        @OOE_RowLoop
  2043.         
  2044.         addq.l    Num(4), sp
  2045. // STOP
  2046.         bra        @Done
  2047.         
  2048.     @VeryNarrow:
  2049. // START Very Narrow
  2050.     @VN_RowLoop:
  2051. // BLIT
  2052.         bfextu    (srcPixelP){srcExtraStart:dstExtraEnd}, d0
  2053.         bfextu    (dstPixelP){dstExtraStart:dstExtraEnd}, d1
  2054.         bfextu    (maskPixelP){srcExtraStart:dstExtraEnd}, d2
  2055.         and.l    d2, d1
  2056.         not.l    d2
  2057.         and.l    d2, d0
  2058.         or.l    d1, d0
  2059.         bfins    d0, (dstPixelP){dstExtraStart:dstExtraEnd}
  2060.         
  2061.         adda.l    srcRowStride, srcPixelP
  2062.         adda.l    dstRowStride, dstPixelP
  2063.         adda.l    srcRowStride, maskPixelP
  2064.         
  2065.         subq.l    Num(1), rowsToCopy
  2066.         bgt        @VN_RowLoop
  2067. // STOP
  2068.         
  2069.     @Done:
  2070.         
  2071. #if __MWERKS__
  2072.         frfree
  2073. #endif
  2074.         
  2075.         SW_ASM_END
  2076. }
  2077.  
  2078. #endif    /* #if SW_PPC */