开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
vd.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：26k
源码类别：

多媒体编程

开发平台：

Visual C++

vd.cpp：源码内容
  1. // VirtualDub - Video processing and capture application
  2. // Copyright (C) 1998-2001 Avery Lee
  3. //
  4. // This program is free software; you can redistribute it and/or modify
  5. // it under the terms of the GNU General Public License as published by
  6. // the Free Software Foundation; either version 2 of the License, or
  7. // (at your option) any later version.
  8. //
  9. // This program is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. // GNU General Public License for more details.
  13. //
  14. // You should have received a copy of the GNU General Public License
  15. // along with this program; if not, write to the Free Software
  16. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17. //
  18. //  Notes: 
  19. //  - BitBltFromI420ToRGB is from VirtualDub
  20. // - The core assembly function of CCpuID is from DVD2AVI
  21. // (- vd.cpp/h should be renamed to something more sensible already :)
  24. #include "stdafx.h"
  25. #include "vd.h"
  27. #pragma warning(disable : 4799) // no emms... blahblahblah
  29. #define ReadTSC( x ) __asm cpuid 
  30. __asm rdtsc 
  31. __asm mov dword ptr x,eax 
  32. __asm mov dword ptr x+4,edx
  34. CCpuID::CCpuID()
  35. {
  36. DWORD flags = 0;
  38. __asm
  39. {
  40. mov eax, 1
  41. cpuid
  42. test edx, 0x00800000 // STD MMX
  43. jz TEST_SSE
  44. or [flags], 1
  45. TEST_SSE:
  46. test edx, 0x02000000 // STD SSE
  47. jz TEST_SSE2
  48. or [flags], 2
  49. or [flags], 4
  50. TEST_SSE2:
  51. test edx, 0x04000000 // SSE2
  52. jz TEST_3DNOW
  53. or [flags], 8
  54. TEST_3DNOW:
  55. mov eax, 0x80000001
  56. cpuid
  57. test edx, 0x80000000 // 3D NOW
  58. jz TEST_SSEMMX
  59. or [flags], 16
  60. TEST_SSEMMX:
  61. test edx, 0x00400000 // SSE MMX
  62. jz TEST_END
  63. or [flags], 2
  64. TEST_END:
  65. }
  67. m_flags = (flag_t)flags;
  68. }
  70. CCpuID g_cpuid;
  72. void memcpy_accel(void* dst, const void* src, size_t len)
  73. {
  74. if((g_cpuid.m_flags & CCpuID::sse2) && len >= 128 
  75. && !((DWORD)src&15) && !((DWORD)dst&15))
  76. {
  77. __asm
  78. {
  79. mov     esi, dword ptr [src]
  80. mov     edi, dword ptr [dst]
  81. mov     ecx, len
  82. shr     ecx, 7
  83. memcpy_accel_sse2_loop:
  84. prefetchnta [esi+16*8]
  85. movdqa xmm0, [esi]
  86. movdqa xmm1, [esi+16*1]
  87. movdqa xmm2, [esi+16*2]
  88. movdqa xmm3, [esi+16*3]
  89. movdqa xmm4, [esi+16*4]
  90. movdqa xmm5, [esi+16*5]
  91. movdqa xmm6, [esi+16*6]
  92. movdqa xmm7, [esi+16*7]
  93. movntps [edi], xmm0
  94. movntps [edi+16*1], xmm1
  95. movntps [edi+16*2], xmm2
  96. movntps [edi+16*3], xmm3
  97. movntps [edi+16*4], xmm4
  98. movntps [edi+16*5], xmm5
  99. movntps [edi+16*6], xmm6
  100. movntps [edi+16*7], xmm7
  101. add esi, 128
  102. add edi, 128
  103. dec ecx
  104. jnz memcpy_accel_sse2_loop
  105. mov     ecx, len
  106. and     ecx, 127
  107. cmp     ecx, 0
  108. je memcpy_accel_sse2_end
  109. memcpy_accel_sse2_loop2:
  110. mov dl, byte ptr[esi] 
  111. mov byte ptr[edi], dl
  112. inc esi
  113. inc edi
  114. dec ecx
  115. jne memcpy_accel_sse2_loop2
  116. memcpy_accel_sse2_end:
  117. emms
  118. sfence
  119. }
  120. }
  121. else if((g_cpuid.m_flags & CCpuID::ssefpu) && len >= 128 
  122. && !((DWORD)src&15) && !((DWORD)dst&15))
  123. {
  124. __asm
  125. {
  126. mov     esi, dword ptr [src]
  127. mov     edi, dword ptr [dst]
  128. mov     ecx, len
  129. shr     ecx, 7
  130. memcpy_accel_sse_loop:
  131. prefetchnta [esi+16*8]
  132. movaps xmm0, [esi]
  133. movaps xmm1, [esi+16*1]
  134. movaps xmm2, [esi+16*2]
  135. movaps xmm3, [esi+16*3]
  136. movaps xmm4, [esi+16*4]
  137. movaps xmm5, [esi+16*5]
  138. movaps xmm6, [esi+16*6]
  139. movaps xmm7, [esi+16*7]
  140. movntps [edi], xmm0
  141. movntps [edi+16*1], xmm1
  142. movntps [edi+16*2], xmm2
  143. movntps [edi+16*3], xmm3
  144. movntps [edi+16*4], xmm4
  145. movntps [edi+16*5], xmm5
  146. movntps [edi+16*6], xmm6
  147. movntps [edi+16*7], xmm7
  148. add esi, 128
  149. add edi, 128
  150. dec ecx
  151. jnz memcpy_accel_sse_loop
  152. mov     ecx, len
  153. and     ecx, 127
  154. cmp     ecx, 0
  155. je memcpy_accel_sse_end
  156. memcpy_accel_sse_loop2:
  157. mov dl, byte ptr[esi] 
  158. mov byte ptr[edi], dl
  159. inc esi
  160. inc edi
  161. dec ecx
  162. jne memcpy_accel_sse_loop2
  163. memcpy_accel_sse_end:
  164. emms
  165. sfence
  166. }
  167. }
  168. else if((g_cpuid.m_flags & CCpuID::mmx) && len >= 64
  169. && !((DWORD)src&7) && !((DWORD)dst&7))
  170. {
  171. __asm 
  172. {
  173. mov     esi, dword ptr [src]
  174. mov     edi, dword ptr [dst]
  175. mov     ecx, len
  176. shr     ecx, 6
  177. memcpy_accel_mmx_loop:
  178. movq    mm0, qword ptr [esi]
  179. movq    mm1, qword ptr [esi+8*1]
  180. movq    mm2, qword ptr [esi+8*2]
  181. movq    mm3, qword ptr [esi+8*3]
  182. movq    mm4, qword ptr [esi+8*4]
  183. movq    mm5, qword ptr [esi+8*5]
  184. movq    mm6, qword ptr [esi+8*6]
  185. movq    mm7, qword ptr [esi+8*7]
  186. movq    qword ptr [edi], mm0
  187. movq    qword ptr [edi+8*1], mm1
  188. movq    qword ptr [edi+8*2], mm2
  189. movq    qword ptr [edi+8*3], mm3
  190. movq    qword ptr [edi+8*4], mm4
  191. movq    qword ptr [edi+8*5], mm5
  192. movq    qword ptr [edi+8*6], mm6
  193. movq    qword ptr [edi+8*7], mm7
  194. add     esi, 64
  195. add     edi, 64
  196. dec ecx
  197. jnz memcpy_accel_mmx_loop
  198. mov     ecx, len
  199. and     ecx, 63
  200. cmp     ecx, 0
  201. je memcpy_accel_mmx_end
  202. memcpy_accel_mmx_loop2:
  203. mov dl, byte ptr [esi] 
  204. mov byte ptr [edi], dl
  205. inc esi
  206. inc edi
  207. dec ecx
  208. jne memcpy_accel_mmx_loop2
  209. memcpy_accel_mmx_end:
  210. emms
  211. }
  212. }
  213. else
  214. {
  215. memcpy(dst, src, len);
  216. }
  217. }
  219. bool BitBltFromI420ToI420(int w, int h, BYTE* dsty, BYTE* dstu, BYTE* dstv, int dstpitch, BYTE* srcy, BYTE* srcu, BYTE* srcv, int srcpitch)
  220. {
  221. if(w&1) return(false);
  223. int pitch = min(abs(srcpitch), abs(dstpitch));
  225. for(int y = 0; y < h; y++, srcy += srcpitch, dsty += dstpitch)
  226. memcpy_accel(dsty, srcy, pitch);
  228. srcpitch >>= 1;
  229. dstpitch >>= 1;
  231. pitch = min(abs(srcpitch), abs(dstpitch));
  233. for(int y = 0; y < h; y+=2, srcu += srcpitch, dstu += dstpitch)
  234. memcpy_accel(dstu, srcu, pitch);
  236. for(int y = 0; y < h; y+=2, srcv += srcpitch, dstv += dstpitch)
  237. memcpy_accel(dstv, srcv, pitch);
  239. return(true);
  240. }
  242. bool BitBltFromYUY2ToYUY2(int w, int h, BYTE* dst, int dstpitch, BYTE* src, int srcpitch)
  243. {
  244. int pitch = min(abs(srcpitch), abs(dstpitch));
  246. for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)
  247. memcpy_accel(dst, src, pitch);
  249. return(true);
  250. }
  252. extern "C" void asm_YUVtoRGB32_row(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
  253. extern "C" void asm_YUVtoRGB24_row(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
  254. extern "C" void asm_YUVtoRGB16_row(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
  255. extern "C" void asm_YUVtoRGB32_row_MMX(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
  256. extern "C" void asm_YUVtoRGB24_row_MMX(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
  257. extern "C" void asm_YUVtoRGB16_row_MMX(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
  258. extern "C" void asm_YUVtoRGB32_row_ISSE(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
  259. extern "C" void asm_YUVtoRGB24_row_ISSE(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
  260. extern "C" void asm_YUVtoRGB16_row_ISSE(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
  262. bool BitBltFromI420ToRGB(int w, int h, BYTE* dst, int dstpitch, int dbpp, BYTE* srcy, BYTE* srcu, BYTE* srcv, int srcpitch)
  263. {
  264. if(w<=0 || h<=0 || (w&1) || (h&1))
  265. return(false);
  267. void (*asm_YUVtoRGB_row)(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width) = NULL;;
  269. if((g_cpuid.m_flags & CCpuID::ssefpu) && !(w&7))
  270. {
  271. switch(dbpp)
  272. {
  273. case 16: asm_YUVtoRGB_row = asm_YUVtoRGB16_row/*_ISSE*/; break; // TODO: fix _ISSE (555->565)
  274. case 24: asm_YUVtoRGB_row = asm_YUVtoRGB24_row_ISSE; break;
  275. case 32: asm_YUVtoRGB_row = asm_YUVtoRGB32_row_ISSE; break;
  276. }
  277. }
  278. else if((g_cpuid.m_flags & CCpuID::mmx) && !(w&7))
  279. {
  280. switch(dbpp)
  281. {
  282. case 16: asm_YUVtoRGB_row = asm_YUVtoRGB16_row/*_MMX*/; break; // TODO: fix _MMX (555->565)
  283. case 24: asm_YUVtoRGB_row = asm_YUVtoRGB24_row_MMX; break;
  284. case 32: asm_YUVtoRGB_row = asm_YUVtoRGB32_row_MMX; break;
  285. }
  286. }
  287. else
  288. {
  289. switch(dbpp)
  290. {
  291. case 16: asm_YUVtoRGB_row = asm_YUVtoRGB16_row; break;
  292. case 24: asm_YUVtoRGB_row = asm_YUVtoRGB24_row; break;
  293. case 32: asm_YUVtoRGB_row = asm_YUVtoRGB32_row; break;
  294. }
  295. }
  297. if(!asm_YUVtoRGB_row) 
  298. return(false);
  300. do
  301. {
  302. asm_YUVtoRGB_row(dst + dstpitch, dst, srcy + srcpitch, srcy, srcu, srcv, w/2);
  304. dst += 2*dstpitch;
  305. srcy += srcpitch*2;
  306. srcu += srcpitch/2;
  307. srcv += srcpitch/2;
  308. }
  309. while(h -= 2);
  311. if(g_cpuid.m_flags & CCpuID::mmx)
  312. __asm emms
  314. if(g_cpuid.m_flags & CCpuID::ssefpu)
  315. __asm sfence
  317. return true;
  318. }
  320. static void yuvtoyuy2row_c(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width)
  321. {
  322. WORD* dstw = (WORD*)dst;
  323. for(; width > 1; width -= 2)
  324. {
  325. *dstw++ = (*srcu++<<8)|*srcy++;
  326. *dstw++ = (*srcv++<<8)|*srcy++;
  327. }
  328. }
  330. static void __declspec(naked) yuvtoyuy2row_MMX(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width)
  331. {
  332. __asm {
  333. push ebp
  334. push edi
  335. push esi
  336. push ebx
  338. mov edi, [esp+20] // dst
  339. mov ebp, [esp+24] // srcy
  340. mov ebx, [esp+28] // srcu
  341. mov esi, [esp+32] // srcv
  342. mov ecx, [esp+36] // width
  344. shr ecx, 3
  346. yuvtoyuy2row_loop:
  348. movd mm0, [ebx]
  349. punpcklbw mm0, [esi]
  351. movq mm1, [ebp]
  352. movq mm2, mm1
  353. punpcklbw mm1, mm0
  354. punpckhbw mm2, mm0
  356. movq [edi], mm1
  357. movq [edi+8], mm2
  359. add ebp, 8
  360. add ebx, 4
  361. add esi, 4
  362.         add edi, 16
  364. dec ecx
  365. jnz yuvtoyuy2row_loop
  367. pop ebx
  368. pop esi
  369. pop edi
  370. pop ebp
  371. ret
  372. };
  373. }
  375. static void yuvtoyuy2row_avg_c(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width, DWORD pitchuv)
  376. {
  377. WORD* dstw = (WORD*)dst;
  378. for(; width > 1; width -= 2, srcu++, srcv++)
  379. {
  380. *dstw++ = (((srcu[0]+srcu[pitchuv])>>1)<<8)|*srcy++;
  381. *dstw++ = (((srcv[0]+srcv[pitchuv])>>1)<<8)|*srcy++;
  382. }
  383. }
  385. static void __declspec(naked) yuvtoyuy2row_avg_MMX(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width, DWORD pitchuv)
  386. {
  387. static const __int64 mask = 0x7f7f7f7f7f7f7f7fi64;
  389. __asm {
  390. push ebp
  391. push edi
  392. push esi
  393. push ebx
  395. movq mm7, mask
  397. mov edi, [esp+20] // dst
  398. mov ebp, [esp+24] // srcy
  399. mov ebx, [esp+28] // srcu
  400. mov esi, [esp+32] // srcv
  401. mov ecx, [esp+36] // width
  402. mov eax, [esp+40] // pitchuv
  404. shr ecx, 3
  406. yuvtoyuy2row_avg_loop:
  408. movd mm0, [ebx]
  409. punpcklbw mm0, [esi]
  410. movq mm1, mm0
  412. movd mm2, [ebx + eax]
  413. punpcklbw mm2, [esi + eax]
  414. movq mm3, mm2
  416. // (x+y)>>1 == (x&y)+((x^y)>>1)
  418. pand mm0, mm2
  419. pxor mm1, mm3
  420. psrlq mm1, 1
  421. pand mm1, mm7
  422. paddb mm0, mm1
  424. movq mm1, [ebp]
  425. movq mm2, mm1
  426. punpcklbw mm1, mm0
  427. punpckhbw mm2, mm0
  429. movq [edi], mm1
  430. movq [edi+8], mm2
  432. add ebp, 8
  433. add ebx, 4
  434. add esi, 4
  435.         add edi, 16
  437. dec ecx
  438. jnz yuvtoyuy2row_avg_loop
  440. pop ebx
  441. pop esi
  442. pop edi
  443. pop ebp
  444. ret
  445. };
  446. }
  448. bool BitBltFromI420ToYUY2(int w, int h, BYTE* dst, int dstpitch, BYTE* srcy, BYTE* srcu, BYTE* srcv, int srcpitch)
  449. {
  450. if(w<=0 || h<=0 || (w&1) || (h&1))
  451. return(false);
  453. if(srcpitch == 0) srcpitch = w;
  455. void (*yuvtoyuy2row)(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width) = NULL;
  456. void (*yuvtoyuy2row_avg)(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width, DWORD pitchuv) = NULL;
  458. if((g_cpuid.m_flags & CCpuID::mmx) && !(w&7))
  459. {
  460. yuvtoyuy2row = yuvtoyuy2row_MMX;
  461. yuvtoyuy2row_avg = yuvtoyuy2row_avg_MMX;
  462. }
  463. else
  464. {
  465. yuvtoyuy2row = yuvtoyuy2row_c;
  466. yuvtoyuy2row_avg = yuvtoyuy2row_avg_c;
  467. }
  469. if(!yuvtoyuy2row) 
  470. return(false);
  472. do
  473. {
  474. yuvtoyuy2row(dst, srcy, srcu, srcv, w);
  475. yuvtoyuy2row_avg(dst + dstpitch, srcy + srcpitch, srcu, srcv, w, srcpitch/2);
  477. dst += 2*dstpitch;
  478. srcy += srcpitch*2;
  479. srcu += srcpitch/2;
  480. srcv += srcpitch/2;
  481. }
  482. while((h -= 2) > 2);
  484. yuvtoyuy2row(dst, srcy, srcu, srcv, w);
  485. yuvtoyuy2row(dst + dstpitch, srcy + srcpitch, srcu, srcv, w);
  487. if(g_cpuid.m_flags & CCpuID::mmx)
  488. __asm emms
  490. return(true);
  491. }
  493. bool BitBltFromRGBToRGB(int w, int h, BYTE* dst, int dstpitch, int dbpp, BYTE* src, int srcpitch, int sbpp)
  494. {
  495. if(dbpp == sbpp)
  496. {
  497. int bytes = w*dbpp>>3;
  498. for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)
  499. memcpy_accel(dst, src, bytes);
  500. return(true);
  501. }
  503. if(sbpp != 16 && sbpp != 24 && sbpp != 32
  504. || dbpp != 16 && dbpp != 24 && dbpp != 32)
  505. return(false);
  507. if(dbpp == 16)
  508. {
  509. for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)
  510. {
  511. if(sbpp == 24)
  512. {
  513. BYTE* s = (BYTE*)src;
  514. WORD* d = (WORD*)dst;
  515. for(int x = 0; x < w; x++, s+=3, d++)
  516. *d = (WORD)(((*((DWORD*)s)>>8)&0xf800)|((*((DWORD*)s)>>5)&0x07e0)|((*((DWORD*)s)>>3)&0x1f));
  517. }
  518. else if(sbpp == 32)
  519. {
  520. DWORD* s = (DWORD*)src;
  521. WORD* d = (WORD*)dst;
  522. for(int x = 0; x < w; x++, s++, d++)
  523. *d = (WORD)(((*s>>8)&0xf800)|((*s>>5)&0x07e0)|((*s>>3)&0x1f));
  524. }
  525. }
  526. }
  527. else if(dbpp == 24)
  528. {
  529. for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)
  530. {
  531. if(sbpp == 16)
  532. {
  533. WORD* s = (WORD*)src;
  534. BYTE* d = (BYTE*)dst;
  535. for(int x = 0; x < w; x++, s++, d+=3)
  536. { // not tested, r-g-b might be in reverse
  537. d[0] = (*s&0x001f)<<3;
  538. d[1] = (*s&0x07e0)<<5;
  539. d[2] = (*s&0xf800)<<8;
  540. }
  541. }
  542. else if(sbpp == 32)
  543. {
  544. BYTE* s = (BYTE*)src;
  545. BYTE* d = (BYTE*)dst;
  546. for(int x = 0; x < w; x++, s+=4, d+=3)
  547. {d[0] = s[0]; d[1] = s[1]; d[2] = s[2];}
  548. }
  549. }
  550. }
  551. else if(dbpp == 32)
  552. {
  553. for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)
  554. {
  555. if(sbpp == 16)
  556. {
  557. WORD* s = (WORD*)src;
  558. DWORD* d = (DWORD*)dst;
  559. for(int x = 0; x < w; x++, s++, d++)
  560. *d = ((*s&0xf800)<<8)|((*s&0x07e0)<<5)|((*s&0x001f)<<3);
  561. }
  562. else if(sbpp == 24)
  563. {
  564. BYTE* s = (BYTE*)src;
  565. DWORD* d = (DWORD*)dst;
  566. for(int x = 0; x < w; x++, s+=3, d++)
  567. *d = *((DWORD*)s)&0xffffff;
  568. }
  569. }
  570. }
  572. return(true);
  573. }
  575. static void asm_blend_row_clipped_c(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)
  576. {
  577. BYTE* src2 = src + srcpitch;
  578. do {*dst++ = (*src++ + *src2++ + 1) >> 1;}
  579. while(w--);
  580. }
  582. static void asm_blend_row_c(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)
  583. {
  584. BYTE* src2 = src + srcpitch;
  585. BYTE* src3 = src2 + srcpitch;
  586. do {*dst++ = (*src++ + (*src2++ << 1) + *src3++ + 2) >> 2;}
  587. while(w--);
  588. }
  590. static void __declspec(naked) asm_blend_row_clipped_MMX(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)
  591. {
  592. static const __int64 _x0001000100010001 = 0x0001000100010001;
  594. __asm {
  595. push ebp
  596. push edi
  597. push esi
  598. push ebx
  600. mov edi,[esp+20]
  601. mov esi,[esp+24]
  602. sub edi,esi
  603. mov ebp,[esp+28]
  604. mov edx,[esp+32]
  606. shr ebp, 3
  608. movq mm6, _x0001000100010001
  609. pxor mm7, mm7
  611. xloop:
  612. movq mm0, [esi]
  613. movq mm3, mm0
  614. punpcklbw mm0, mm7
  615. punpckhbw mm3, mm7
  617. movq mm1, [esi+edx]
  618. movq mm4, mm1
  619. punpcklbw mm1, mm7
  620. punpckhbw mm4, mm7
  622. paddw mm1, mm0
  623. paddw mm1, mm6
  624. psrlw mm1, 1
  626. paddw mm4, mm3
  627. paddw mm4, mm6
  628. psrlw mm4, 1
  630. add esi, 8
  631. packuswb mm1, mm4
  632. movq [edi+esi-8], mm1
  634. dec ebp
  635. jne xloop
  637. pop ebx
  638. pop esi
  639. pop edi
  640. pop ebp
  641. ret
  642. };
  643. }
  645. static void __declspec(naked) asm_blend_row_MMX(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)
  646. {
  647. static const __int64 mask0 = 0xfcfcfcfcfcfcfcfci64;
  648. static const __int64 mask1 = 0x7f7f7f7f7f7f7f7fi64;
  649. static const __int64 mask2 = 0x3f3f3f3f3f3f3f3fi64;
  650. static const __int64 _x0002000200020002 = 0x0002000200020002;
  652. __asm {
  653. push ebp
  654. push edi
  655. push esi
  656. push ebx
  658. mov edi, [esp+20]
  659. mov esi, [esp+24]
  660. sub edi, esi
  661. mov ebp, [esp+28]
  662. mov edx, [esp+32]
  664. shr ebp, 3
  666. movq mm6, _x0002000200020002
  667. pxor mm7, mm7
  669. xloop:
  670. movq mm0, [esi]
  671. movq mm3, mm0
  672. punpcklbw mm0, mm7
  673. punpckhbw mm3, mm7
  675. movq mm1, [esi+edx]
  676. movq mm4, mm1
  677. punpcklbw mm1, mm7
  678. punpckhbw mm4, mm7
  680. movq mm2, [esi+edx*2]
  681. movq mm5, mm2
  682. punpcklbw mm2, mm7
  683. punpckhbw mm5, mm7
  685. psllw mm1, 1
  686. paddw mm1, mm0
  687. paddw mm1, mm2
  688. paddw mm1, mm6
  689. psrlw mm1, 2
  691. psllw mm4, 1
  692. paddw mm4, mm3
  693. paddw mm4, mm5
  694. paddw mm4, mm6
  695. psrlw mm4, 2
  697. add esi, 8
  698. packuswb mm1, mm4
  699. movq [edi+esi-8], mm1
  701. dec ebp
  702. jne xloop
  704. // sadly the original code makes a lot of visible banding artifacts on yuv
  705. // (it seems those shiftings without rounding introduce too much error)
  706. /*
  707. mov edi,[esp+20]
  708. mov esi,[esp+24]
  709. sub edi,esi
  710. mov ebp,[esp+28]
  711. mov edx,[esp+32]
  713. movq mm5,mask0
  714. movq mm6,mask1
  715. movq mm7,mask2
  716. shr ebp,1
  717. jz oddpart
  719. xloop:
  720. movq mm2,[esi]
  721. movq mm0,mm5
  723. movq mm1,[esi+edx]
  724. pand mm0,mm2
  726. psrlq mm1,1
  727. movq mm2,[esi+edx*2]
  729. psrlq mm2,2
  730. pand mm1,mm6
  732. psrlq mm0,2
  733. pand mm2,mm7
  735. paddb mm0,mm1
  736. add esi,8
  738. paddb mm0,mm2
  739. dec ebp
  741. movq [edi+esi-8],mm0
  742. jne xloop
  744. oddpart:
  745. test byte ptr [esp+28],1
  746. jz nooddpart
  748. mov ecx,[esi]
  749. mov eax,0fcfcfcfch
  750. mov ebx,[esi+edx]
  751. and eax,ecx
  752. shr ebx,1
  753. mov ecx,[esi+edx*2]
  754. shr ecx,2
  755. and ebx,07f7f7f7fh
  756. shr eax,2
  757. and ecx,03f3f3f3fh
  758. add eax,ebx
  759. add eax,ecx
  760. mov [edi+esi],eax
  762. nooddpart:
  763. */
  764. pop ebx
  765. pop esi
  766. pop edi
  767. pop ebp
  768. ret
  769. };
  770. }
  772. __declspec(align(16)) static BYTE const_1_16_bytes[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
  774. static void asm_blend_row_SSE2(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)
  775. {
  776. __asm
  777. {
  778. mov edx, srcpitch
  779. mov esi, src
  780. mov edi, dst
  781. sub edi, esi
  782. mov ecx, w
  783. mov ebx, ecx
  784. shr ecx, 4
  785. and ebx, 15
  787. movdqa xmm7, [const_1_16_bytes] 
  789. asm_blend_row_SSE2_loop:
  790. movdqa xmm0, [esi]
  791. movdqa xmm1, [esi+edx]
  792. movdqa xmm2, [esi+edx*2]
  793. pavgb xmm0, xmm1
  794. pavgb xmm2, xmm1
  795. psubusb xmm0, xmm7
  796. pavgb xmm0, xmm2
  797. movdqa [esi+edi], xmm0
  798. add esi, 16
  799. dec ecx
  800. jnz asm_blend_row_SSE2_loop
  802. test ebx,15
  803. jz asm_blend_row_SSE2_end
  805. mov ecx, ebx
  806. xor ax, ax
  807. xor bx, bx
  808. xor dx, dx
  809. asm_blend_row_SSE2_loop2:
  810. mov al, [esi]
  811. mov bl, [esi+edx]
  812. mov dl, [esi+edx*2]
  813. add ax, bx
  814. inc ax
  815. shr ax, 1
  816. add dx, bx
  817. inc dx
  818. shr dx, 1
  819. add ax, dx
  820. shr ax, 1
  821. mov [esi+edi], al
  822. inc esi
  823. dec ecx
  824. jnz asm_blend_row_SSE2_loop2
  826. asm_blend_row_SSE2_end:
  827. }
  828. }
  830. static void asm_blend_row_clipped_SSE2(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)
  831. {
  832. __asm
  833. {
  834. mov edx, srcpitch
  835. mov esi, src
  836. mov edi, dst
  837. sub edi, esi
  838. mov ecx, w
  839. mov ebx, ecx
  840. shr ecx, 4
  841. and ebx, 15
  843. movdqa xmm7, [const_1_16_bytes] 
  845. asm_blend_row_clipped_SSE2_loop:
  846. movdqa xmm0, [esi]
  847. movdqa xmm1, [esi+edx]
  848. pavgb xmm0, xmm1
  849. movdqa [esi+edi], xmm0
  850. add esi, 16
  851. dec ecx
  852. jnz asm_blend_row_clipped_SSE2_loop
  854. test ebx,15
  855. jz asm_blend_row_clipped_SSE2_end
  857. mov ecx, ebx
  858. xor ax, ax
  859. xor bx, bx
  860. asm_blend_row_clipped_SSE2_loop2:
  861. mov al, [esi]
  862. mov bl, [esi+edx]
  863. add ax, bx
  864. inc ax
  865. shr ax, 1
  866. mov [esi+edi], al
  867. inc esi
  868. dec ecx
  869. jnz asm_blend_row_clipped_SSE2_loop2
  871. asm_blend_row_clipped_SSE2_end:
  872. }
  873. }
  875. void DeinterlaceBlend(BYTE* dst, BYTE* src, DWORD rowbytes, DWORD h, DWORD dstpitch, DWORD srcpitch)
  876. {
  877. void (*asm_blend_row_clipped)(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch) = NULL;
  878. void (*asm_blend_row)(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch) = NULL;
  880. if((g_cpuid.m_flags & CCpuID::sse2) && !((DWORD)src&0xf) && !((DWORD)dst&0xf) && !(srcpitch&0xf))
  881. {
  882. asm_blend_row_clipped = asm_blend_row_clipped_SSE2;
  883. asm_blend_row = asm_blend_row_SSE2;
  884. }
  885. else if(g_cpuid.m_flags & CCpuID::mmx)
  886. {
  887. asm_blend_row_clipped = asm_blend_row_clipped_MMX;
  888. asm_blend_row = asm_blend_row_MMX;
  889. }
  890. else
  891. {
  892. asm_blend_row_clipped = asm_blend_row_clipped_c;
  893. asm_blend_row = asm_blend_row_c;
  894. }
  896. if(!asm_blend_row_clipped)
  897. return;
  899. asm_blend_row_clipped(dst, src, rowbytes, srcpitch);
  901. if((h -= 2) > 0) do
  902. {
  903. dst += dstpitch;
  904. asm_blend_row(dst, src, rowbytes, srcpitch);
  905.         src += srcpitch;
  906. }
  907. while(--h);
  909. asm_blend_row_clipped(dst + dstpitch, src, rowbytes, srcpitch);
  911. if(g_cpuid.m_flags & CCpuID::mmx)
  912. __asm emms
  913. }
  915. void AvgLines8(BYTE* dst, DWORD h, DWORD pitch)
  916. {
  917. if(h <= 1) return;
  919. BYTE* s = dst;
  920. BYTE* d = dst + (h-2)*pitch;
  922. for(; s < d; s += pitch*2)
  923. {
  924. BYTE* tmp = s;
  926. if((g_cpuid.m_flags & CCpuID::sse2) && !((DWORD)tmp&0xf) && !((DWORD)pitch&0xf))
  927. {
  928. __asm
  929. {
  930. mov esi, tmp
  931. mov ebx, pitch
  933. mov ecx, ebx
  934. shr ecx, 4
  936. AvgLines8_sse2_loop:
  937. movdqa xmm0, [esi]
  938. pavgb xmm0, [esi+ebx*2]
  939. movdqa [esi+ebx], xmm0
  940. add esi, 16
  942. dec ecx
  943. jnz AvgLines8_sse2_loop
  945. mov tmp, esi
  946. }
  948. for(int i = pitch&7; i--; tmp++)
  949. {
  950. tmp[pitch] = (tmp[0] + tmp[pitch<<1] + 1) >> 1;
  951. }
  952. }
  953. else if(g_cpuid.m_flags & CCpuID::mmx)
  954. {
  955. __asm
  956. {
  957. mov esi, tmp
  958. mov ebx, pitch
  960. mov ecx, ebx
  961. shr ecx, 3
  963. pxor mm7, mm7
  964. AvgLines8_mmx_loop:
  965. movq mm0, [esi]
  966. movq mm1, mm0
  968. punpcklbw mm0, mm7
  969. punpckhbw mm1, mm7
  971. movq mm2, [esi+ebx*2]
  972. movq mm3, mm2
  974. punpcklbw mm2, mm7
  975. punpckhbw mm3, mm7
  977. paddw mm0, mm2
  978. psrlw mm0, 1
  980. paddw mm1, mm3
  981. psrlw mm1, 1
  983. packuswb mm0, mm1
  985. movq [esi+ebx], mm0
  987. lea esi, [esi+8]
  989. dec ecx
  990. jnz AvgLines8_mmx_loop
  992. mov tmp, esi
  993. }
  995. for(int i = pitch&7; i--; tmp++)
  996. {
  997. tmp[pitch] = (tmp[0] + tmp[pitch<<1] + 1) >> 1;
  998. }
  999. }
  1000. else
  1001. {
  1002. for(int i = pitch; i--; tmp++)
  1003. {
  1004. tmp[pitch] = (tmp[0] + tmp[pitch<<1] + 1) >> 1;
  1005. }
  1006. }
  1007. }
  1009. if(!(h&1) && h >= 2)
  1010. {
  1011. dst += (h-2)*pitch;
  1012. memcpy_accel(dst + pitch, dst, pitch);
  1013. }
  1015. __asm emms;
  1016. }
  1018. void AvgLines555(BYTE* dst, DWORD h, DWORD pitch)
  1019. {
  1020. if(h <= 1) return;
  1022. unsigned __int64 __0x7c007c007c007c00 = 0x7c007c007c007c00;
  1023. unsigned __int64 __0x03e003e003e003e0 = 0x03e003e003e003e0;
  1024. unsigned __int64 __0x001f001f001f001f = 0x001f001f001f001f;
  1026. BYTE* s = dst;
  1027. BYTE* d = dst + (h-2)*pitch;
  1029. for(; s < d; s += pitch*2)
  1030. {
  1031. BYTE* tmp = s;
  1033. __asm
  1034. {
  1035. mov esi, tmp
  1036. mov ebx, pitch
  1038. mov ecx, ebx
  1039. shr ecx, 3
  1041. movq mm6, __0x03e003e003e003e0
  1042. movq mm7, __0x001f001f001f001f
  1044. AvgLines555_loop:
  1045. movq mm0, [esi]
  1046. movq mm1, mm0
  1047. movq mm2, mm0
  1049. psrlw mm0, 10 // red1 bits: mm0 = 001f001f001f001f
  1050. pand mm1, mm6 // green1 bits: mm1 = 03e003e003e003e0
  1051. pand mm2, mm7 // blue1 bits: mm2 = 001f001f001f001f
  1053. movq mm3, [esi+ebx*2]
  1054. movq mm4, mm3
  1055. movq mm5, mm3
  1057. psrlw mm3, 10 // red2 bits: mm3 = 001f001f001f001f
  1058. pand mm4, mm6 // green2 bits: mm4 = 03e003e003e003e0
  1059. pand mm5, mm7 // blue2 bits: mm5 = 001f001f001f001f
  1061. paddw mm0, mm3
  1062. psrlw mm0, 1 // (red1+red2)/2
  1063. psllw mm0, 10 // red bits at 7c007c007c007c00
  1065. paddw mm1, mm4
  1066. psrlw mm1, 1 // (green1+green2)/2
  1067. pand mm1, mm6 // green bits at 03e003e003e003e0
  1069. paddw mm2, mm5
  1070. psrlw mm2, 1 // (blue1+blue2)/2
  1071. // blue bits at 001f001f001f001f (no need to pand, lower bits were discareded)
  1073. por mm0, mm1
  1074. por mm0, mm2
  1076. movq [esi+ebx], mm0
  1078. lea esi, [esi+8]
  1080. dec ecx
  1081. jnz AvgLines555_loop
  1083. mov tmp, esi
  1084. }
  1086. for(int i = (pitch&7)>>1; i--; tmp++)
  1087. {
  1088. tmp[pitch] = 
  1089. ((((*tmp&0x7c00) + (tmp[pitch<<1]&0x7c00)) >> 1)&0x7c00)|
  1090. ((((*tmp&0x03e0) + (tmp[pitch<<1]&0x03e0)) >> 1)&0x03e0)|
  1091. ((((*tmp&0x001f) + (tmp[pitch<<1]&0x001f)) >> 1)&0x001f);
  1092. }
  1093. }
  1095. if(!(h&1) && h >= 2)
  1096. {
  1097. dst += (h-2)*pitch;
  1098. memcpy_accel(dst + pitch, dst, pitch);
  1099. }
  1101. __asm emms;
  1102. }
  1104. void AvgLines565(BYTE* dst, DWORD h, DWORD pitch)
  1105. {
  1106. if(h <= 1) return;
  1108. unsigned __int64 __0xf800f800f800f800 = 0xf800f800f800f800;
  1109. unsigned __int64 __0x07e007e007e007e0 = 0x07e007e007e007e0;
  1110. unsigned __int64 __0x001f001f001f001f = 0x001f001f001f001f;
  1112. BYTE* s = dst;
  1113. BYTE* d = dst + (h-2)*pitch;
  1115. for(; s < d; s += pitch*2)
  1116. {
  1117. WORD* tmp = (WORD*)s;
  1119. __asm
  1120. {
  1121. mov esi, tmp
  1122. mov ebx, pitch
  1124. mov ecx, ebx
  1125. shr ecx, 3
  1127. movq mm6, __0x07e007e007e007e0
  1128. movq mm7, __0x001f001f001f001f
  1130. AvgLines565_loop:
  1131. movq mm0, [esi]
  1132. movq mm1, mm0
  1133. movq mm2, mm0
  1135. psrlw mm0, 11 // red1 bits: mm0 = 001f001f001f001f
  1136. pand mm1, mm6 // green1 bits: mm1 = 07e007e007e007e0
  1137. pand mm2, mm7 // blue1 bits: mm2 = 001f001f001f001f
  1139. movq mm3, [esi+ebx*2]
  1140. movq mm4, mm3
  1141. movq mm5, mm3
  1143. psrlw mm3, 11 // red2 bits: mm3 = 001f001f001f001f
  1144. pand mm4, mm6 // green2 bits: mm4 = 07e007e007e007e0
  1145. pand mm5, mm7 // blue2 bits: mm5 = 001f001f001f001f
  1147. paddw mm0, mm3
  1148. psrlw mm0, 1 // (red1+red2)/2
  1149. psllw mm0, 11 // red bits at f800f800f800f800
  1151. paddw mm1, mm4
  1152. psrlw mm1, 1 // (green1+green2)/2
  1153. pand mm1, mm6 // green bits at 03e003e003e003e0
  1155. paddw mm2, mm5
  1156. psrlw mm2, 1 // (blue1+blue2)/2
  1157. // blue bits at 001f001f001f001f (no need to pand, lower bits were discareded)
  1159. por mm0, mm1
  1160. por mm0, mm2
  1162. movq [esi+ebx], mm0
  1164. lea esi, [esi+8]
  1166. dec ecx
  1167. jnz AvgLines565_loop
  1169. mov tmp, esi
  1170. }
  1172. for(int i = (pitch&7)>>1; i--; tmp++)
  1173. {
  1174. tmp[pitch] = 
  1175. ((((*tmp&0xf800) + (tmp[pitch<<1]&0xf800)) >> 1)&0xf800)|
  1176. ((((*tmp&0x07e0) + (tmp[pitch<<1]&0x07e0)) >> 1)&0x07e0)|
  1177. ((((*tmp&0x001f) + (tmp[pitch<<1]&0x001f)) >> 1)&0x001f);
  1178. }
  1179. }
  1181. if(!(h&1) && h >= 2)
  1182. {
  1183. dst += (h-2)*pitch;
  1184. memcpy_accel(dst + pitch, dst, pitch);
  1185. }
  1187. __asm emms;
  1188. }
  1190. extern "C" void mmx_YUY2toRGB24(const BYTE* src, BYTE* dst, const BYTE* src_end, int src_pitch, int row_size, bool rec709);
  1191. extern "C" void mmx_YUY2toRGB32(const BYTE* src, BYTE* dst, const BYTE* src_end, int src_pitch, int row_size, bool rec709);
  1193. bool BitBltFromYUY2ToRGB(int w, int h, BYTE* dst, int dstpitch, int dbpp, BYTE* src, int srcpitch)
  1194. {
  1195. void (* YUY2toRGB)(const BYTE* src, BYTE* dst, const BYTE* src_end, int src_pitch, int row_size, bool rec709) = NULL;
  1197. if(g_cpuid.m_flags & CCpuID::mmx)
  1198. {
  1199. YUY2toRGB = 
  1200. dbpp == 32 ? mmx_YUY2toRGB32 :
  1201. dbpp == 24 ? mmx_YUY2toRGB24 :
  1202. // dbpp == 16 ? mmx_YUY2toRGB16 : // TODO
  1203. NULL;
  1204. }
  1205. else
  1206. {
  1207. // TODO
  1208. }
  1210. if(!YUY2toRGB) return(false);
  1212. YUY2toRGB(src, dst, src + h*srcpitch, srcpitch, w, false);
  1214. return(true);
  1215. }