home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 275 / DPCS0111DVD.ISO / Toolkit / Audio-Visual / VirtualDub / Source / VirtualDub-1.9.10-src.7z / src / Kasumi / source / uberblit_swizzle_x86.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-14  |  8.2 KB  |  401 lines
  1. #include "uberblit_swizzle_x86.h"
  2.  
  3. #ifdef VD_COMPILER_MSVC
  4.     #pragma warning(disable: 4799)    // warning C4799: function 'vdasm_extract_8in16_even_MMX' has no EMMS instruction
  5. #endif
  6.  
  7. void __declspec(naked) __fastcall vdasm_extract_8in16_even_MMX(void *dst, const void *src, uint32 count) {
  8.     __asm {
  9.         mov            eax, [esp+4]
  10.         pcmpeqb        mm2, mm2
  11.         psrlw        mm2, 8
  12.         sub            eax, 8
  13.         jc            xtra
  14. xloop:
  15.         movq        mm0, [edx]
  16.         movq        mm1, [edx+8]
  17.         pand        mm0, mm2
  18.         pand        mm1, mm2
  19.         packuswb    mm0, mm1
  20.         add            edx, 16
  21.         movq        [ecx], mm0
  22.         add            ecx, 8
  23.         sub            eax, 8
  24.         jns            xloop
  25. xtra:
  26.         add            eax, 8
  27.         jz            fin
  28.         push        ebx
  29. xtraloop:
  30.         mov            bl, [edx]
  31.         add            edx, 2
  32.         mov            [ecx], bl
  33.         add            ecx, 1
  34.         sub            eax, 1
  35.         jnz            xtraloop
  36.  
  37.         pop            ebx
  38. fin:
  39.         ret            4
  40.     }
  41. }
  42.  
  43. void __declspec(naked) __fastcall vdasm_extract_8in16_odd_MMX(void *dst, const void *src, uint32 count) {
  44.     __asm {
  45.         mov            eax, [esp+4]
  46.         sub            eax, 8
  47.         jc            xtra
  48. xloop:
  49.         movq        mm0, [edx]
  50.         movq        mm1, [edx+8]
  51.         psrlw        mm0, 8
  52.         psrlw        mm1, 8
  53.         add            edx, 16
  54.         packuswb    mm0, mm1
  55.         movq        [ecx], mm0
  56.         add            ecx, 8
  57.         sub            eax, 8
  58.         jns            xloop
  59. xtra:
  60.         add            eax, 8
  61.         jz            fin
  62.         push        ebx
  63. xtraloop:
  64.         mov            bl, [edx+1]
  65.         add            edx, 2
  66.         mov            [ecx], bl
  67.         add            ecx, 1
  68.         sub            eax, 1
  69.         jnz            xtraloop
  70.  
  71.         pop            ebx
  72. fin:
  73.         ret            4
  74.     }
  75. }
  76.  
  77. void __declspec(naked) __fastcall vdasm_extract_8in32_MMX(void *dst, const void *src, uint32 count, int byteshift) {
  78.     __asm {
  79.         movd        mm4, [esp+8]
  80.         pcmpeqb        mm5, mm5
  81.         pslld        mm4, 3
  82.         mov            eax, [esp+4]
  83.         psrld        mm5, 24
  84.         sub            eax, 8
  85.         jc            xtra
  86. xloop:
  87.         movq        mm0, [edx]
  88.         movq        mm1, [edx+8]
  89.         psrld        mm0, mm4
  90.         movq        mm2, [edx+16]
  91.         psrld        mm1, mm4
  92.         pand        mm0, mm5
  93.         movq        mm3, [edx+24]
  94.         psrld        mm2, mm4
  95.         pand        mm1, mm5
  96.         packssdw    mm0, mm1
  97.         psrld        mm3, mm4
  98.         pand        mm2, mm5
  99.         pand        mm3, mm5
  100.         add            edx, 32
  101.         packssdw    mm2, mm3
  102.         packuswb    mm0, mm2
  103.         movq        [ecx], mm0
  104.         add            ecx, 8
  105.         sub            eax, 8
  106.         jns            xloop
  107. xtra:
  108.         add            eax, 8
  109.         jz            fin
  110.         add            edx, dword ptr [esp+8]
  111.         push        ebx
  112. xtraloop:
  113.         mov            bl, [edx]
  114.         add            edx, 4
  115.         mov            [ecx], bl
  116.         add            ecx, 1
  117.         sub            eax, 1
  118.         jnz            xtraloop
  119.  
  120.         pop            ebx
  121. fin:
  122.         ret            8
  123.     }
  124. }
  125.  
  126. void __declspec(naked) __fastcall vdasm_swap_8in16_MMX(void *dst, const void *src, uint32 count) {
  127.     __asm {
  128.         mov            eax, [esp+4]
  129.         sub            eax, 8
  130.         js            xtra
  131. xloop:
  132.         movq        mm0, [edx]
  133.         add            edx, 8
  134.         movq        mm1, mm0
  135.         psllw        mm0, 8
  136.         psrlw        mm1, 8
  137.         paddb        mm0, mm1
  138.         movq        [ecx], mm0
  139.         add            ecx, 8
  140.         sub            eax, 8
  141.         jns            xloop
  142. xtra:
  143.         add            eax, 6
  144.         js            nopairs
  145.         push        ebx
  146. pairloop:
  147.         mov            bl, [edx]
  148.         mov            bh, [edx+1]
  149.         add            edx, 2
  150.         mov            [ecx], bh
  151.         mov            [ecx+1], bl
  152.         add            ecx, 2
  153.         sub            eax, 2
  154.         jns            pairloop
  155.         pop            ebx
  156. nopairs:
  157.         add            eax, 2
  158.         jz            noodd
  159.         mov            al, [edx]
  160.         mov            [ecx], al
  161. noodd:
  162.         ret            4
  163.     }
  164. }
  165.  
  166. void __declspec(naked) __fastcall vdasm_interleave_BGRG_MMX(void *dst, const void *srcR, const void *srcG, const void *srcB, uint32 count) {
  167.     __asm {
  168.         push        edi
  169.         push        esi
  170.         push        ebx
  171.         mov            esi, [esp+12+12]
  172.         mov            edi, [esp+8+12]
  173.         mov            ebx, [esp+4+12]
  174.         sub            esi, 4
  175.         jc            xtra
  176.         ; ecx = dst
  177.         ; edx = srcR
  178.         ; ebx = srcG
  179.         ; edi = srcB
  180. xloop:
  181.         movd        mm0, [edi]
  182.         movd        mm1, [edx]
  183.         punpcklbw    mm0, mm1
  184.         movq        mm1, [ebx]
  185.         movq        mm2, mm0
  186.         punpcklbw    mm0, mm1
  187.         add            edx, 4
  188.         punpckhbw    mm2, mm1
  189.         add            edi, 4
  190.         movq        [ecx], mm0
  191.         add            ebx, 8
  192.         movq        [ecx+8], mm2
  193.         add            ecx, 16
  194.         sub            esi, 4
  195.         jns            xloop
  196. xtra:
  197.         add            esi, 4
  198.         jz            fin
  199. xtraloop:
  200.         mov            al, [edi]
  201.         mov            [ecx], al
  202.         mov            al, [ebx]
  203.         mov            [ecx+1], al
  204.         mov            al, [edx]
  205.         mov            [ecx+2], al
  206.         mov            al, [ebx+1]
  207.         mov            [ecx+3], al
  208.         add            ebx, 2
  209.         add            edx, 1
  210.         add            edi, 1
  211.         add            ecx, 4
  212.         sub            esi, 1
  213.         jnz            xtraloop
  214. fin:
  215.         pop            ebx
  216.         pop            esi
  217.         pop            edi
  218.         ret            12
  219.     }
  220. }
  221.  
  222. void __declspec(naked) __fastcall vdasm_interleave_GBGR_MMX(void *dst, const void *srcR, const void *srcG, const void *srcB, uint32 count) {
  223.     __asm {
  224.         push        edi
  225.         push        esi
  226.         push        ebx
  227.         mov            esi, [esp+12+12]
  228.         mov            edi, [esp+8+12]
  229.         mov            ebx, [esp+4+12]
  230.         sub            esi, 4
  231.         jc            xtra
  232.         ; ecx = dst
  233.         ; edx = srcR
  234.         ; ebx = srcG
  235.         ; edi = srcB
  236. xloop:
  237.         movd        mm0, [edi]
  238.         movd        mm1, [edx]
  239.         punpcklbw    mm0, mm1
  240.         movq        mm2, [ebx]
  241.         movq        mm1, mm2
  242.         punpcklbw    mm2, mm0
  243.         add            edx, 4
  244.         punpckhbw    mm1, mm0
  245.         add            edi, 4
  246.         movq        [ecx], mm2
  247.         add            ebx, 8
  248.         movq        [ecx+8], mm1
  249.         add            ecx, 16
  250.         sub            esi, 4
  251.         jns            xloop
  252. xtra:
  253.         add            esi, 4
  254.         jz            fin
  255. xtraloop:
  256.         mov            al, [ebx]
  257.         mov            [ecx], al
  258.         mov            al, [edi]
  259.         mov            [ecx+1], al
  260.         mov            al, [ebx+1]
  261.         mov            [ecx+2], al
  262.         mov            al, [edx]
  263.         mov            [ecx+3], al
  264.         add            ebx, 2
  265.         add            edx, 1
  266.         add            edi, 1
  267.         add            ecx, 4
  268.         sub            esi, 1
  269.         jnz            xtraloop
  270. fin:
  271.         pop            ebx
  272.         pop            esi
  273.         pop            edi
  274.         ret            12
  275.     }
  276. }
  277.  
  278. void __declspec(naked) __fastcall vdasm_interleave_BR_MMX(void *dst, const void *srcB, const void *srcR, uint32 count) {
  279.     __asm {
  280.         push        edi
  281.         push        esi
  282.         push        ebx
  283.         mov            esi, [esp+8+12]
  284.         mov            ebx, [esp+4+12]
  285.         sub            esi, 8
  286.         jc            xtra
  287.         ; ecx = dst
  288.         ; edx = srcB
  289.         ; ebx = srcG
  290. xloop:
  291.         movq        mm0, [edx]
  292.         movq        mm1, [ebx]
  293.         movq        mm2, mm0
  294.         punpcklbw    mm0, mm1
  295.         punpckhbw    mm2, mm1
  296.         add            edx, 8
  297.         movq        [ecx], mm0
  298.         add            ebx, 8
  299.         movq        [ecx+8], mm2
  300.         add            ecx, 16
  301.         sub            esi, 8
  302.         jns            xloop
  303. xtra:
  304.         add            esi, 8
  305.         jz            fin
  306. xtraloop:
  307.         mov            al, [edx]
  308.         mov            [ecx], al
  309.         mov            al, [ebx]
  310.         mov            [ecx+1], al
  311.         add            ebx, 1
  312.         add            edx, 1
  313.         add            ecx, 2
  314.         sub            esi, 1
  315.         jnz            xtraloop
  316. fin:
  317.         pop            ebx
  318.         pop            esi
  319.         pop            edi
  320.         ret            8
  321.     }
  322. }
  323.  
  324. ///////////////////////////////////////////////////////////////////////////////
  325.  
  326. void VDPixmapGen_8In16_Even_MMX::Compute(void *dst, sint32 y) {
  327.     const uint8 *srcp = (const uint8 *)mpSrc->GetRow(y, mSrcIndex);
  328.  
  329.     vdasm_extract_8in16_even_MMX(dst, srcp, mWidth);
  330. }
  331.  
  332. void VDPixmapGen_8In16_Odd_MMX::Compute(void *dst, sint32 y) {
  333.     const uint8 *srcp = (const uint8 *)mpSrc->GetRow(y, mSrcIndex);
  334.  
  335.     vdasm_extract_8in16_odd_MMX(dst, srcp, mWidth);
  336. }
  337.  
  338. void VDPixmapGen_8In32_MMX::Compute(void *dst, sint32 y) {
  339.     const uint8 *srcp = (const uint8 *)mpSrc->GetRow(y, mSrcIndex);
  340.  
  341.     vdasm_extract_8in32_MMX(dst, srcp, mWidth, mOffset);
  342. }
  343.  
  344. void VDPixmapGen_Swap8In16_MMX::Compute(void *dst, sint32 y) {
  345.     const uint8 *src = (const uint8 *)mpSrc->GetRow(y, mSrcIndex);
  346.  
  347.     vdasm_swap_8in16_MMX(dst, src, mRowLength);
  348. }
  349.  
  350. void VDPixmapGen_B8x2_To_B8R8_MMX::Compute(void *dst0, sint32 y) {
  351.     uint8 *VDRESTRICT dst = (uint8 *VDRESTRICT)dst0;
  352.     const uint8 *VDRESTRICT srcCb = (const uint8 *VDRESTRICT)mpSrcCb->GetRow(y, mSrcIndexCb);
  353.     const uint8 *VDRESTRICT srcCr = (const uint8 *VDRESTRICT)mpSrcCr->GetRow(y, mSrcIndexCr);
  354.  
  355.     vdasm_interleave_BR_MMX(dst, srcCb, srcCr, mWidth);
  356. }
  357.  
  358. void VDPixmapGen_B8x3_To_G8B8_G8R8_MMX::Compute(void *VDRESTRICT dst0, sint32 y) {
  359.     uint8 *VDRESTRICT dst = (uint8 *VDRESTRICT)dst0;
  360.     const uint8 *VDRESTRICT srcY = (const uint8 *VDRESTRICT)mpSrcY->GetRow(y, mSrcIndexY);
  361.     const uint8 *VDRESTRICT srcCb = (const uint8 *VDRESTRICT)mpSrcCb->GetRow(y, mSrcIndexCb);
  362.     const uint8 *VDRESTRICT srcCr = (const uint8 *VDRESTRICT)mpSrcCr->GetRow(y, mSrcIndexCr);
  363.  
  364.     vdasm_interleave_GBGR_MMX(dst, srcCr, srcY, srcCb, mWidth >> 1);
  365.  
  366.     if (mWidth & 1) {
  367.         int w2 = mWidth >> 1;
  368.         srcY += mWidth;
  369.         srcCb += w2;
  370.         srcCr += w2;
  371.         dst += mWidth * 2;
  372.  
  373.         dst[-2] = srcY[-1];
  374.         dst[-1] = srcCb[0];
  375.         dst[ 0] = 0;            // must be zero for QuickTime compatibility
  376.         dst[ 1] = srcCr[0];
  377.     }
  378. }
  379.  
  380. void VDPixmapGen_B8x3_To_B8G8_R8G8_MMX::Compute(void *VDRESTRICT dst0, sint32 y) {
  381.     uint8 *VDRESTRICT dst = (uint8 *VDRESTRICT)dst0;
  382.     const uint8 *VDRESTRICT srcY = (const uint8 * VDRESTRICT)mpSrcY->GetRow(y, mSrcIndexY);
  383.     const uint8 *VDRESTRICT srcCb = (const uint8 * VDRESTRICT)mpSrcCb->GetRow(y, mSrcIndexCb);
  384.     const uint8 *VDRESTRICT srcCr = (const uint8 * VDRESTRICT)mpSrcCr->GetRow(y, mSrcIndexCr);
  385.  
  386.     vdasm_interleave_BGRG_MMX(dst, srcCr, srcY, srcCb, mWidth >> 1);
  387.  
  388.     if (mWidth & 1) {
  389.         int w2 = mWidth >> 1;
  390.         srcY += mWidth;
  391.         srcCb += w2;
  392.         srcCr += w2;
  393.         dst += mWidth * 2;
  394.  
  395.         dst[-2] = srcCb[0];
  396.         dst[-1] = srcY[-1];
  397.         dst[ 0] = srcCr[0];
  398.         dst[ 1] = 0;            // must be zero for QuickTime compatibility
  399.     }
  400. }
  401.