PageRenderTime 57ms CodeModel.GetById 16ms RepoModel.GetById 1ms app.codeStats 0ms

/src/dsutil/vd.cpp

https://bitbucket.org/Tomasen/splayer/
C++ | 1930 lines | 1485 code | 323 blank | 122 comment | 262 complexity | 8b2b4d09d447840566427cd560ac9037 MD5 | raw file
Possible License(s): GPL-2.0, CC-BY-SA-3.0, LGPL-2.0, LGPL-2.1, BSD-3-Clause, LGPL-3.0, AGPL-1.0 
    

  1. //	VirtualDub - Video processing and capture application

    2. 

  2. //	Copyright (C) 1998-2001 Avery Lee

    3. 

  3. //

    4. 

  4. //	This program is free software; you can redistribute it and/or modify

    5. 

  5. //	it under the terms of the GNU General Public License as published by

    6. 

  6. //	the Free Software Foundation; either version 2 of the License, or

    7. 

  7. //	(at your option) any later version.

    8. 

  8. //

    9. 

  9. //	This program is distributed in the hope that it will be useful,

    10. 

  10. //	but WITHOUT ANY WARRANTY; without even the implied warranty of

    11. 

  11. //	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12. 

  12. //	GNU General Public License for more details.

    13. 

  13. //

    14. 

  14. //	You should have received a copy of the GNU General Public License

    15. 

  15. //	along with this program; if not, write to the Free Software

    16. 

  16. //	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    17. 

  17. //

    18. 

  18. //  Notes: 

    19. 

  19. //  - BitBltFromI420ToRGB is from VirtualDub

    20. 

  20. //	- The core assembly function of CCpuID is from DVD2AVI

    21. 

  21. //  - sse2 yv12 to yuy2 conversion by Haali

    22. 

  22. //	(- vd.cpp/h should be renamed to something more sensible already :)

    23. 

  23. 

    24. 

  24. 

    25. 

  25. #include "stdafx.h"

    26. 

  26. #include "vd.h"

    27. 

  27. 

    28. 

  28. #include "..\svplib\svplib.h"

    29. 

  29. 

    30. 

  30. #undef  SVP_LogMsg5

    31. 

  31. #define SVP_LogMsg5 __noop

    32. 

  32. 

    33. 

  33. #pragma warning(disable : 4799) // no emms... blahblahblah

    34. 

  34. 

    35. 

  35. #ifdef _WIN64 // _WIN64

    36. 

  36. 

    37. 

  37. CCpuID g_cpuid;

    38. 

  38. 

    39. 

  39. CCpuID::CCpuID()

    40. 

  40. {

    41. 

  41. 	// TODOX64 : ??

    42. 

  42. 	m_flags = (flag_t)7;

    43. 

  43. }

    44. 

  44. 

    45. 

  45. static void yuvtoyuy2row_c(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width)

    46. 

  46. {

    47. 

  47. 	WORD* dstw = (WORD*)dst;

    48. 

  48. 	for(; width > 1; width -= 2)

    49. 

  49. 	{

    50. 

  50. 		*dstw++ = (*srcu++<<8)|*srcy++;

    51. 

  51. 		*dstw++ = (*srcv++<<8)|*srcy++;

    52. 

  52. 	}

    53. 

  53. }

    54. 

  54. 

    55. 

  55. static void yuvtoyuy2row_avg_c(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width, DWORD pitchuv)

    56. 

  56. {

    57. 

  57. 	WORD* dstw = (WORD*)dst;

    58. 

  58. 	for(; width > 1; width -= 2, srcu++, srcv++)

    59. 

  59. 	{

    60. 

  60. 		*dstw++ = (((srcu[0]+srcu[pitchuv])>>1)<<8)|*srcy++;

    61. 

  61. 		*dstw++ = (((srcv[0]+srcv[pitchuv])>>1)<<8)|*srcy++;

    62. 

  62. 	}

    63. 

  63. }

    64. 

  64. 

    65. 

  65. static void asm_blend_row_clipped_c(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)

    66. 

  66. {

    67. 

  67. 	BYTE* src2 = src + srcpitch;

    68. 

  68. 	do {*dst++ = (*src++ + *src2++ + 1) >> 1;}

    69. 

  69. 	while(w--);

    70. 

  70. }

    71. 

  71. 

    72. 

  72. static void asm_blend_row_c(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)

    73. 

  73. {

    74. 

  74. 	BYTE* src2 = src + srcpitch;

    75. 

  75. 	BYTE* src3 = src2 + srcpitch;

    76. 

  76. 	do {*dst++ = (*src++ + (*src2++ << 1) + *src3++ + 2) >> 2;}

    77. 

  77. 	while(w--);

    78. 

  78. }

    79. 

  79. 

    80. 

  80. bool BitBltFromI420ToI420(int w, int h, BYTE* dsty, BYTE* dstu, BYTE* dstv, int dstpitch, BYTE* srcy, BYTE* srcu, BYTE* srcv, int srcpitch)

    81. 

  81. {

    82. 

  82. 	if((w&1)) return(false);

    83. 

  83. 

    84. 

  84. 	if(w > 0 && w == srcpitch && w == dstpitch)

    85. 

  85. 	{

    86. 

  86. 		memcpy(dsty, srcy, h*srcpitch);

    87. 

  87. 		memcpy(dstu, srcu, h/2*srcpitch/2);

    88. 

  88. 		memcpy(dstv, srcv, h/2*srcpitch/2);

    89. 

  89. 	}

    90. 

  90. 	else

    91. 

  91. 	{

    92. 

  92. 		int pitch = min(abs(srcpitch), abs(dstpitch));

    93. 

  93. 

    94. 

  94. 		for(int y = 0; y < h; y++, srcy += srcpitch, dsty += dstpitch)

    95. 

  95. 			memcpy(dsty, srcy, pitch);

    96. 

  96. 

    97. 

  97. 		srcpitch >>= 1;

    98. 

  98. 		dstpitch >>= 1;

    99. 

  99. 

    100. 

  100. 		pitch = min(abs(srcpitch), abs(dstpitch));

    101. 

  101. 

    102. 

  102. 		for(int y = 0; y < h; y+=2, srcu += srcpitch, dstu += dstpitch)

    103. 

  103. 			memcpy(dstu, srcu, pitch);

    104. 

  104. 

    105. 

  105. 		for(int y = 0; y < h; y+=2, srcv += srcpitch, dstv += dstpitch)

    106. 

  106. 			memcpy(dstv, srcv, pitch);

    107. 

  107. 	}

    108. 

  108. 

    109. 

  109. 	return true;

    110. 

  110. }

    111. 

  111. 

    112. 

  112. bool BitBltFromI420ToYUY2(int w, int h, BYTE* dst, int dstpitch, BYTE* srcy, BYTE* srcu, BYTE* srcv, int srcpitch, bool fInterlaced)

    113. 

  113. {

    114. 

  114. 	if(w<=0 || h<=0 || (w&1) || (h&1))

    115. 

  115. 		return(false);

    116. 

  116. 

    117. 

  117. 	if(srcpitch == 0) srcpitch = w;

    118. 

  118. 

    119. 

  119. 	do

    120. 

  120. 	{

    121. 

  121. 		yuvtoyuy2row_c(dst, srcy, srcu, srcv, w);

    122. 

  122. 		yuvtoyuy2row_avg_c(dst + dstpitch, srcy + srcpitch, srcu, srcv, w, srcpitch/2);

    123. 

  123. 

    124. 

  124. 		dst += 2*dstpitch;

    125. 

  125. 		srcy += srcpitch*2;

    126. 

  126. 		srcu += srcpitch/2;

    127. 

  127. 		srcv += srcpitch/2;

    128. 

  128. 	}

    129. 

  129. 	while((h -= 2) > 2);

    130. 

  130. 

    131. 

  131. 	yuvtoyuy2row_c(dst, srcy, srcu, srcv, w);

    132. 

  132. 	yuvtoyuy2row_c(dst + dstpitch, srcy + srcpitch, srcu, srcv, w);

    133. 

  133. 

    134. 

  134. 	return(true);

    135. 

  135. }

    136. 

  136. 

    137. 

  137. bool BitBltFromYUY2ToYUY2(int w, int h, BYTE* dst, int dstpitch, BYTE* src, int srcpitch)

    138. 

  138. {

    139. 

  139. 	if(w > 0 && w == srcpitch && w == dstpitch)

    140. 

  140. 	{

    141. 

  141. 		memcpy(dst, src, h*srcpitch);

    142. 

  142. 	}

    143. 

  143. 	else

    144. 

  144. 	{

    145. 

  145. 		int pitch = min(abs(srcpitch), abs(dstpitch));

    146. 

  146. 

    147. 

  147. 		for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)

    148. 

  148. 			memcpy(dst, src, pitch);

    149. 

  149. 	}

    150. 

  150. 

    151. 

  151. 	return(true);

    152. 

  152. }

    153. 

  153. 

    154. 

  154. bool BitBltFromI420ToRGB(int w, int h, BYTE* dst, int dstpitch, int dbpp, BYTE* srcy, BYTE* srcu, BYTE* srcv, int srcpitch)

    155. 

  155. {

    156. 

  156. 	ASSERT(FALSE);

    157. 

  157. 	return false;

    158. 

  158. }

    159. 

  159. 

    160. 

  160. bool BitBltFromRGBToRGB(int w, int h, BYTE* dst, int dstpitch, int dbpp, BYTE* src, int srcpitch, int sbpp)

    161. 

  161. {

    162. 

  162. 	if(dbpp == sbpp)

    163. 

  163. 	{

    164. 

  164. 		int rowbytes = w*dbpp>>3;

    165. 

  165. 

    166. 

  166. 		if(rowbytes > 0 && rowbytes == srcpitch && rowbytes == dstpitch)

    167. 

  167. 		{

    168. 

  168. 			memcpy(dst, src, h*rowbytes);

    169. 

  169. 		}

    170. 

  170. 		else

    171. 

  171. 		{

    172. 

  172. 			for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)

    173. 

  173. 				memcpy(dst, src, rowbytes);

    174. 

  174. 		}

    175. 

  175. 

    176. 

  176. 		return(true);

    177. 

  177. 	}

    178. 

  178. 	

    179. 

  179. 	if(sbpp != 16 && sbpp != 24 && sbpp != 32

    180. 

  180. 	|| dbpp != 16 && dbpp != 24 && dbpp != 32)

    181. 

  181. 		return(false);

    182. 

  182. 

    183. 

  183. 	if(dbpp == 16)

    184. 

  184. 	{

    185. 

  185. 		for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)

    186. 

  186. 		{

    187. 

  187. 			if(sbpp == 24)

    188. 

  188. 			{

    189. 

  189. 				BYTE* s = (BYTE*)src;

    190. 

  190. 				WORD* d = (WORD*)dst;

    191. 

  191. 				for(int x = 0; x < w; x++, s+=3, d++)

    192. 

  192. 					*d = (WORD)(((*((DWORD*)s)>>8)&0xf800)|((*((DWORD*)s)>>5)&0x07e0)|((*((DWORD*)s)>>3)&0x1f));

    193. 

  193. 			}

    194. 

  194. 			else if(sbpp == 32)

    195. 

  195. 			{

    196. 

  196. 				DWORD* s = (DWORD*)src;

    197. 

  197. 				WORD* d = (WORD*)dst;

    198. 

  198. 				for(int x = 0; x < w; x++, s++, d++)

    199. 

  199. 					*d = (WORD)(((*s>>8)&0xf800)|((*s>>5)&0x07e0)|((*s>>3)&0x1f));

    200. 

  200. 			}

    201. 

  201. 		}

    202. 

  202. 	}

    203. 

  203. 	else if(dbpp == 24)

    204. 

  204. 	{

    205. 

  205. 		for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)

    206. 

  206. 		{

    207. 

  207. 			if(sbpp == 16)

    208. 

  208. 			{

    209. 

  209. 				WORD* s = (WORD*)src;

    210. 

  210. 				BYTE* d = (BYTE*)dst;

    211. 

  211. 				for(int x = 0; x < w; x++, s++, d+=3)

    212. 

  212. 				{	// not tested, r-g-b might be in reverse

    213. 

  213. 					d[0] = (*s&0x001f)<<3;

    214. 

  214. 					d[1] = (*s&0x07e0)<<5;

    215. 

  215. 					d[2] = (*s&0xf800)<<8;

    216. 

  216. 				}

    217. 

  217. 			}

    218. 

  218. 			else if(sbpp == 32)

    219. 

  219. 			{

    220. 

  220. 				BYTE* s = (BYTE*)src;

    221. 

  221. 				BYTE* d = (BYTE*)dst;

    222. 

  222. 				for(int x = 0; x < w; x++, s+=4, d+=3)

    223. 

  223. 					{d[0] = s[0]; d[1] = s[1]; d[2] = s[2];}

    224. 

  224. 			}

    225. 

  225. 		}

    226. 

  226. 	}

    227. 

  227. 	else if(dbpp == 32)

    228. 

  228. 	{

    229. 

  229. 		for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)

    230. 

  230. 		{

    231. 

  231. 			if(sbpp == 16)

    232. 

  232. 			{

    233. 

  233. 				WORD* s = (WORD*)src;

    234. 

  234. 				DWORD* d = (DWORD*)dst;

    235. 

  235. 				for(int x = 0; x < w; x++, s++, d++)

    236. 

  236. 					*d = ((*s&0xf800)<<8)|((*s&0x07e0)<<5)|((*s&0x001f)<<3);

    237. 

  237. 			}

    238. 

  238. 			else if(sbpp == 24)

    239. 

  239. 			{	

    240. 

  240. 				BYTE* s = (BYTE*)src;

    241. 

  241. 				DWORD* d = (DWORD*)dst;

    242. 

  242. 				for(int x = 0; x < w; x++, s+=3, d++)

    243. 

  243. 					*d = *((DWORD*)s)&0xffffff;

    244. 

  244. 			}

    245. 

  245. 		}

    246. 

  246. 	}

    247. 

  247. 

    248. 

  248. 	return(true);

    249. 

  249. }

    250. 

  250. 

    251. 

  251. bool BitBltFromYUY2ToRGB(int w, int h, BYTE* dst, int dstpitch, int dbpp, BYTE* src, int srcpitch)

    252. 

  252. {

    253. 

  253. 	ASSERT(FALSE);

    254. 

  254. 	return false;

    255. 

  255. }

    256. 

  256. 

    257. 

  257. void DeinterlaceBlend(BYTE* dst, BYTE* src, DWORD rowbytes, DWORD h, DWORD dstpitch, DWORD srcpitch)

    258. 

  258. {

    259. 

  259. 

    260. 

  260. 	asm_blend_row_clipped_c(dst, src, rowbytes, srcpitch);

    261. 

  261. 

    262. 

  262. 	if((h -= 2) > 0) do

    263. 

  263. 	{

    264. 

  264. 		dst += dstpitch;

    265. 

  265. 		asm_blend_row_c(dst, src, rowbytes, srcpitch);

    266. 

  266.         src += srcpitch;

    267. 

  267. 	}

    268. 

  268. 	while(--h);

    269. 

  269. 

    270. 

  270. 	asm_blend_row_clipped_c(dst + dstpitch, src, rowbytes, srcpitch);

    271. 

  271. 

    272. 

  272. }

    273. 

  273. 

    274. 

  274. void DeinterlaceBob(BYTE* dst, BYTE* src, DWORD rowbytes, DWORD h, DWORD dstpitch, DWORD srcpitch, bool topfield)

    275. 

  275. {

    276. 

  276. 	if(topfield)

    277. 

  277. 	{

    278. 

  278. 		BitBltFromRGBToRGB(rowbytes, h/2, dst, dstpitch*2, 8, src, srcpitch*2, 8);

    279. 

  279. 		AvgLines8(dst, h, dstpitch);

    280. 

  280. 	}

    281. 

  281. 	else

    282. 

  282. 	{

    283. 

  283. 		BitBltFromRGBToRGB(rowbytes, h/2, dst + dstpitch, dstpitch*2, 8, src + srcpitch, srcpitch*2, 8);

    284. 

  284. 		AvgLines8(dst + dstpitch, h-1, dstpitch);

    285. 

  285. 	}

    286. 

  286. }

    287. 

  287. 

    288. 

  288. void AvgLines8(BYTE* dst, DWORD h, DWORD pitch)

    289. 

  289. {

    290. 

  290. 	if(h <= 1) return;

    291. 

  291. 

    292. 

  292. 	BYTE* s = dst;

    293. 

  293. 	BYTE* d = dst + (h-2)*pitch;

    294. 

  294. 

    295. 

  295. 	for(; s < d; s += pitch*2)

    296. 

  296. 	{

    297. 

  297. 		BYTE* tmp = s;

    298. 

  298. 

    299. 

  299. 		{

    300. 

  300. 			for(int i = pitch; i--; tmp++)

    301. 

  301. 			{

    302. 

  302. 				tmp[pitch] = (tmp[0] + tmp[pitch<<1] + 1) >> 1;

    303. 

  303. 			}

    304. 

  304. 		}

    305. 

  305. 	}

    306. 

  306. 

    307. 

  307. 	if(!(h&1) && h >= 2)

    308. 

  308. 	{

    309. 

  309. 		dst += (h-2)*pitch;

    310. 

  310. 		memcpy(dst + pitch, dst, pitch);

    311. 

  311. 	}

    312. 

  312. 

    313. 

  313. }

    314. 

  314. 

    315. 

  315. #else // _WIN64

    316. 

  316. 

    317. 

  317. CCpuID::CCpuID()

    318. 

  318. {

    319. 

  319. 	DWORD flags = 0;

    320. 

  320. 

    321. 

  321. 	__asm

    322. 

  322. 	{

    323. 

  323. 		mov			eax, 1

    324. 

  324. 		cpuid

    325. 

  325. 		test		edx, 0x00800000		// STD MMX

    326. 

  326. 		jz			TEST_SSE

    327. 

  327. 		or			[flags], 1

    328. 

  328. TEST_SSE:

    329. 

  329. 		test		edx, 0x02000000		// STD SSE

    330. 

  330. 		jz			TEST_SSE2

    331. 

  331. 		or			[flags], 2

    332. 

  332. 		or			[flags], 4

    333. 

  333. TEST_SSE2:

    334. 

  334. 		test		edx, 0x04000000		// SSE2	

    335. 

  335. 		jz			TEST_3DNOW

    336. 

  336. 		or			[flags], 8

    337. 

  337. TEST_3DNOW:

    338. 

  338. 		mov			eax, 0x80000001

    339. 

  339. 		cpuid

    340. 

  340. 		test		edx, 0x80000000		// 3D NOW

    341. 

  341. 		jz			TEST_SSEMMX

    342. 

  342. 		or			[flags], 16

    343. 

  343. TEST_SSEMMX:

    344. 

  344. 		test		edx, 0x00400000		// SSE MMX

    345. 

  345. 		jz			TEST_END

    346. 

  346. 		or			[flags], 2

    347. 

  347. TEST_END:

    348. 

  348. 	}

    349. 

  349. 

    350. 

  350. 	m_flags = (flag_t)flags;

    351. 

  351. }

    352. 

  352. 

    353. 

  353. CCpuID g_cpuid;

    354. 

  354. 

    355. 

  355. void memcpy_accel(void* dst, const void* src, size_t len)

    356. 

  356. {

    357. 

  357. 	if((g_cpuid.m_flags & CCpuID::ssefpu) && len >= 128 

    358. 

  358. 		&& !((DWORD)src&15) && !((DWORD)dst&15))

    359. 

  359. 	{

    360. 

  360. 		__asm

    361. 

  361. 		{

    362. 

  362. 			mov     esi, dword ptr [src]

    363. 

  363. 			mov     edi, dword ptr [dst]

    364. 

  364. 			mov     ecx, len

    365. 

  365. 			shr     ecx, 7

    366. 

  366. 	memcpy_accel_sse_loop:

    367. 

  367. 			prefetchnta	[esi+16*8]

    368. 

  368. 			movaps		xmm0, [esi]

    369. 

  369. 			movaps		xmm1, [esi+16*1]

    370. 

  370. 			movaps		xmm2, [esi+16*2]

    371. 

  371. 			movaps		xmm3, [esi+16*3]

    372. 

  372. 			movaps		xmm4, [esi+16*4]

    373. 

  373. 			movaps		xmm5, [esi+16*5]

    374. 

  374. 			movaps		xmm6, [esi+16*6]

    375. 

  375. 			movaps		xmm7, [esi+16*7]

    376. 

  376. 			movntps		[edi], xmm0

    377. 

  377. 			movntps		[edi+16*1], xmm1

    378. 

  378. 			movntps		[edi+16*2], xmm2

    379. 

  379. 			movntps		[edi+16*3], xmm3

    380. 

  380. 			movntps		[edi+16*4], xmm4

    381. 

  381. 			movntps		[edi+16*5], xmm5

    382. 

  382. 			movntps		[edi+16*6], xmm6

    383. 

  383. 			movntps		[edi+16*7], xmm7

    384. 

  384. 			add			esi, 128

    385. 

  385. 			add			edi, 128

    386. 

  386. 			dec			ecx

    387. 

  387. 			jne			memcpy_accel_sse_loop

    388. 

  388. 			mov     ecx, len

    389. 

  389. 			and     ecx, 127

    390. 

  390. 			cmp     ecx, 0

    391. 

  391. 			je		memcpy_accel_sse_end

    392. 

  392. 	memcpy_accel_sse_loop2:

    393. 

  393. 			mov		dl, byte ptr[esi] 

    394. 

  394. 			mov		byte ptr[edi], dl

    395. 

  395. 			inc		esi

    396. 

  396. 			inc		edi

    397. 

  397. 			dec		ecx

    398. 

  398. 			jne		memcpy_accel_sse_loop2

    399. 

  399. 	memcpy_accel_sse_end:

    400. 

  400. 			emms

    401. 

  401. 			sfence

    402. 

  402. 		}

    403. 

  403. 	}

    404. 

  404. 	else if((g_cpuid.m_flags & CCpuID::mmx) && len >= 64

    405. 

  405. 		&& !((DWORD)src&7) && !((DWORD)dst&7))

    406. 

  406. 	{

    407. 

  407. 		__asm 

    408. 

  408. 		{

    409. 

  409. 			mov     esi, dword ptr [src]

    410. 

  410. 			mov     edi, dword ptr [dst]

    411. 

  411. 			mov     ecx, len

    412. 

  412. 			shr     ecx, 6

    413. 

  413. 	memcpy_accel_mmx_loop:

    414. 

  414. 			movq    mm0, qword ptr [esi]

    415. 

  415. 			movq    mm1, qword ptr [esi+8*1]

    416. 

  416. 			movq    mm2, qword ptr [esi+8*2]

    417. 

  417. 			movq    mm3, qword ptr [esi+8*3]

    418. 

  418. 			movq    mm4, qword ptr [esi+8*4]

    419. 

  419. 			movq    mm5, qword ptr [esi+8*5]

    420. 

  420. 			movq    mm6, qword ptr [esi+8*6]

    421. 

  421. 			movq    mm7, qword ptr [esi+8*7]

    422. 

  422. 			movq    qword ptr [edi], mm0

    423. 

  423. 			movq    qword ptr [edi+8*1], mm1

    424. 

  424. 			movq    qword ptr [edi+8*2], mm2

    425. 

  425. 			movq    qword ptr [edi+8*3], mm3

    426. 

  426. 			movq    qword ptr [edi+8*4], mm4

    427. 

  427. 			movq    qword ptr [edi+8*5], mm5

    428. 

  428. 			movq    qword ptr [edi+8*6], mm6

    429. 

  429. 			movq    qword ptr [edi+8*7], mm7

    430. 

  430. 			add     esi, 64

    431. 

  431. 			add     edi, 64

    432. 

  432. 			loop	memcpy_accel_mmx_loop

    433. 

  433. 			mov     ecx, len

    434. 

  434. 			and     ecx, 63

    435. 

  435. 			cmp     ecx, 0

    436. 

  436. 			je		memcpy_accel_mmx_end

    437. 

  437. 	memcpy_accel_mmx_loop2:

    438. 

  438. 			mov		dl, byte ptr [esi] 

    439. 

  439. 			mov		byte ptr [edi], dl

    440. 

  440. 			inc		esi

    441. 

  441. 			inc		edi

    442. 

  442. 			dec		ecx

    443. 

  443. 			jne		memcpy_accel_mmx_loop2

    444. 

  444. 	memcpy_accel_mmx_end:

    445. 

  445. 			emms

    446. 

  446. 		}

    447. 

  447. 	}

    448. 

  448. 	else

    449. 

  449. 	{

    450. 

  450. 		memcpy(dst, src, len);

    451. 

  451. 	}

    452. 

  452. }

    453. 

  453. 

    454. 

  454. static void yuvtoyuy2row_c(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width)

    455. 

  455. {

    456. 

  456. 	WORD* dstw = (WORD*)dst;

    457. 

  457. 	for(; width > 1; width -= 2)

    458. 

  458. 	{

    459. 

  459. 		*dstw++ = (*srcu++<<8)|*srcy++;

    460. 

  460. 		*dstw++ = (*srcv++<<8)|*srcy++;

    461. 

  461. 	}

    462. 

  462. }

    463. 

  463. 

    464. 

  464. static void yuvtoyuy2row_avg_c(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width, DWORD pitchuv)

    465. 

  465. {

    466. 

  466. 	WORD* dstw = (WORD*)dst;

    467. 

  467. 	for(; width > 1; width -= 2, srcu++, srcv++)

    468. 

  468. 	{

    469. 

  469. 		*dstw++ = (((srcu[0]+srcu[pitchuv])>>1)<<8)|*srcy++;

    470. 

  470. 		*dstw++ = (((srcv[0]+srcv[pitchuv])>>1)<<8)|*srcy++;

    471. 

  471. 	}

    472. 

  472. }

    473. 

  473. 

    474. 

  474. static void asm_blend_row_clipped_c(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)

    475. 

  475. {

    476. 

  476. 	BYTE* src2 = src + srcpitch;

    477. 

  477. 	do {*dst++ = (*src++ + *src2++ + 1) >> 1;}

    478. 

  478. 	while(w--);

    479. 

  479. }

    480. 

  480. 

    481. 

  481. static void asm_blend_row_c(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)

    482. 

  482. {

    483. 

  483. 	BYTE* src2 = src + srcpitch;

    484. 

  484. 	BYTE* src3 = src2 + srcpitch;

    485. 

  485. 	do {*dst++ = (*src++ + (*src2++ << 1) + *src3++ + 2) >> 2;}

    486. 

  486. 	while(w--);

    487. 

  487. }

    488. 

  488. 

    489. 

  489. bool BitBltFromI420ToI420(int w, int h, BYTE* dsty, BYTE* dstu, BYTE* dstv, int dstpitch, BYTE* srcy, BYTE* srcu, BYTE* srcv, int srcpitch)

    490. 

  490. {

    491. 

  491. 	if((w&1)) return(false);

    492. 

  492. 

    493. 

  493. 	//SVP_LogMsg5(L"h %d", h);

    494. 

  494. 	int orgh = h;

    495. 

  495. 	if(h&1){h--;}

    496. 

  496. 	

    497. 

  497. 

    498. 

  498. 	if(w > 0 && w == srcpitch && w == dstpitch)

    499. 

  499. 	{

    500. 

  500. 		memcpy_accel(dsty, srcy, orgh*srcpitch);

    501. 

  501. 		memcpy_accel(dstu, srcu, h*srcpitch/4);

    502. 

  502. 		memcpy_accel(dstv, srcv, h*srcpitch/4);

    503. 

  503. 	}

    504. 

  504. 	else

    505. 

  505. 	{

    506. 

  506. 		//return true;

    507. 

  507. 		int pitch = min(abs(srcpitch), abs(dstpitch));

    508. 

  508. 		SVP_LogMsg5(L"pitch %d %d %d",abs(srcpitch), abs(dstpitch),pitch);

    509. 

  509. 		//int fill = abs(dstpitch) - abs(srcpitch);

    510. 

  510. 		//if(fill <= 0) {fill = 0;}

    511. 

  511. 		if(0){

    512. 

  512. 			memset(dsty, 0x7f, orgh*dstpitch);

    513. 

  513. 			memset(dstu, 0xff,  h*dstpitch/4);

    514. 

  514. 			memset(dstv, 0xff,  h*dstpitch/4);

    515. 

  515. 			//return true;

    516. 

  516. 		}

    517. 

  517. 		for(int y = 0; y < orgh; y++, srcy += srcpitch, dsty += dstpitch){

    518. 

  518. 			memcpy_accel(dsty, srcy, pitch);

    519. 

  519. 			memset(dsty+pitch, 0x00, abs(dstpitch)-pitch);

    520. 

  520. 			//memcpy(dsty, srcy, pitch);

    521. 

  521. 		}

    522. 

  522. 

    523. 

  523. 		srcpitch >>= 1;

    524. 

  524. 		dstpitch >>= 1;

    525. 

  525. 

    526. 

  526. 		pitch = min(abs(srcpitch), abs(dstpitch));

    527. 

  527. 

    528. 

  528. 		//dstu-= dstpitch/2;

    529. 

  529. 		//dstv+= dstpitch/2;

    530. 

  530. 		//srcv-=srcpitch/2;

    531. 

  531. 		//srcu-=srcpitch/2;

    532. 

  532. 		for(int y = 0; y < h; y+=2, srcu += srcpitch, dstu += dstpitch){

    533. 

  533. 			memcpy_accel(dstu, srcu, pitch);

    534. 

  534.       memset(dstu+pitch, 0x80, abs(dstpitch)-pitch);

    535. 

  535. 			//memset(dstu, 0xff, abs(dstpitch));

    536. 

  536. 			//memcpy(dstu, srcu, pitch);

    537. 

  537. 		}

    538. 

  538. 		

    539. 

  539. 

    540. 

  540. 		for(int y = 0; y < h; y+=2, srcv += srcpitch, dstv += dstpitch)

    541. 

  541. 		{

    542. 

  542. 			//memset(dstv, 0xff, abs(dstpitch));

    543. 

  543. 			//memcpy(dstv, srcv, pitch);

    544. 

  544. 			memcpy_accel(dstv, srcv, pitch);

    545. 

  545.       memset(dstv+pitch, 0x80, abs(dstpitch)-pitch);

    546. 

  546. 			

    547. 

  547. 		}

    548. 

  548. 	}

    549. 

  549. 

    550. 

  550. 	return true;

    551. 

  551. }

    552. 

  552. 

    553. 

  553. 

    554. 

  554. bool BitBltFromYUY2ToYUY2(int w, int h, BYTE* dst, int dstpitch, BYTE* src, int srcpitch)

    555. 

  555. {

    556. 

  556. 	if(w > 0 && w == srcpitch && w == dstpitch)

    557. 

  557. 	{

    558. 

  558. 		memcpy_accel(dst, src, h*srcpitch);

    559. 

  559. 	}

    560. 

  560. 	else

    561. 

  561. 	{

    562. 

  562. 		int pitch = min(abs(srcpitch), abs(dstpitch));

    563. 

  563. 

    564. 

  564. 		for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)

    565. 

  565. 			memcpy_accel(dst, src, pitch);

    566. 

  566. 	}

    567. 

  567. 

    568. 

  568. 	return(true);

    569. 

  569. }

    570. 

  570. 

    571. 

  571. extern "C" void asm_YUVtoRGB32_row(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);

    572. 

  572. extern "C" void asm_YUVtoRGB24_row(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);

    573. 

  573. extern "C" void asm_YUVtoRGB16_row(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);

    574. 

  574. extern "C" void asm_YUVtoRGB32_row_MMX(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);

    575. 

  575. extern "C" void asm_YUVtoRGB24_row_MMX(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);

    576. 

  576. extern "C" void asm_YUVtoRGB16_row_MMX(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);

    577. 

  577. extern "C" void asm_YUVtoRGB32_row_ISSE(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);

    578. 

  578. extern "C" void asm_YUVtoRGB24_row_ISSE(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);

    579. 

  579. extern "C" void asm_YUVtoRGB16_row_ISSE(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);

    580. 

  580. 

    581. 

  581. bool BitBltFromI420ToRGB(int w, int h, BYTE* dst, int dstpitch, int dbpp, BYTE* srcy, BYTE* srcu, BYTE* srcv, int srcpitch)

    582. 

  582. {

    583. 

  583. 	if(h&1){h--;}

    584. 

  584. 	if(w<=0 || h<=0 || (w&1) || (h&1))

    585. 

  585. 		return(false);

    586. 

  586. 

    587. 

  587. 	void (*asm_YUVtoRGB_row)(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width) = NULL;;

    588. 

  588. 

    589. 

  589. 	if((g_cpuid.m_flags & CCpuID::ssefpu) && !(w&7))

    590. 

  590. 	{

    591. 

  591. 		switch(dbpp)

    592. 

  592. 		{

    593. 

  593. 		case 16: asm_YUVtoRGB_row = asm_YUVtoRGB16_row/*_ISSE*/; break; // TODO: fix _ISSE (555->565)

    594. 

  594. 		case 24: asm_YUVtoRGB_row = asm_YUVtoRGB24_row_ISSE; break;

    595. 

  595. 		case 32: asm_YUVtoRGB_row = asm_YUVtoRGB32_row_ISSE; break;

    596. 

  596. 		}

    597. 

  597. 	}

    598. 

  598. 	else if((g_cpuid.m_flags & CCpuID::mmx) && !(w&7))

    599. 

  599. 	{

    600. 

  600. 		switch(dbpp)

    601. 

  601. 		{

    602. 

  602. 		case 16: asm_YUVtoRGB_row = asm_YUVtoRGB16_row/*_MMX*/; break; // TODO: fix _MMX (555->565)

    603. 

  603. 		case 24: asm_YUVtoRGB_row = asm_YUVtoRGB24_row_MMX; break;

    604. 

  604. 		case 32: asm_YUVtoRGB_row = asm_YUVtoRGB32_row_MMX; break;

    605. 

  605. 		}

    606. 

  606. 	}

    607. 

  607. 	else

    608. 

  608. 	{

    609. 

  609. 		switch(dbpp)

    610. 

  610. 		{

    611. 

  611. 		case 16: asm_YUVtoRGB_row = asm_YUVtoRGB16_row; break;

    612. 

  612. 		case 24: asm_YUVtoRGB_row = asm_YUVtoRGB24_row; break;

    613. 

  613. 		case 32: asm_YUVtoRGB_row = asm_YUVtoRGB32_row; break;

    614. 

  614. 		}

    615. 

  615. 	}

    616. 

  616. 

    617. 

  617. 	if(!asm_YUVtoRGB_row) 

    618. 

  618. 		return(false);

    619. 

  619. 

    620. 

  620. 	do

    621. 

  621. 	{

    622. 

  622. 		asm_YUVtoRGB_row(dst + dstpitch, dst, srcy + srcpitch, srcy, srcu, srcv, w/2);

    623. 

  623. 

    624. 

  624. 		dst += 2*dstpitch;

    625. 

  625. 		srcy += srcpitch*2;

    626. 

  626. 		srcu += srcpitch/2;

    627. 

  627. 		srcv += srcpitch/2;

    628. 

  628. 	}

    629. 

  629. 	while(h -= 2);

    630. 

  630. 

    631. 

  631. 	if(g_cpuid.m_flags & CCpuID::mmx)

    632. 

  632. 		__asm emms

    633. 

  633. 

    634. 

  634. 	if(g_cpuid.m_flags & CCpuID::ssefpu)

    635. 

  635. 		__asm sfence

    636. 

  636. 

    637. 

  637. 	return true;

    638. 

  638. }

    639. 

  639. 

    640. 

  640. static void __declspec(naked) yuvtoyuy2row_MMX(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width)

    641. 

  641. {

    642. 

  642. 	__asm {

    643. 

  643. 		push	ebp

    644. 

  644. 		push	edi

    645. 

  645. 		push	esi

    646. 

  646. 		push	ebx

    647. 

  647. 

    648. 

  648. 		mov		edi, [esp+20] // dst

    649. 

  649. 		mov		ebp, [esp+24] // srcy

    650. 

  650. 		mov		ebx, [esp+28] // srcu

    651. 

  651. 		mov		esi, [esp+32] // srcv

    652. 

  652. 		mov		ecx, [esp+36] // width

    653. 

  653. 

    654. 

  654. 		shr		ecx, 3

    655. 

  655. 

    656. 

  656. yuvtoyuy2row_loop:

    657. 

  657. 

    658. 

  658. 		movd		mm0, [ebx]

    659. 

  659. 		punpcklbw	mm0, [esi]

    660. 

  660. 

    661. 

  661. 		movq		mm1, [ebp]

    662. 

  662. 		movq		mm2, mm1

    663. 

  663. 		punpcklbw	mm1, mm0

    664. 

  664. 		punpckhbw	mm2, mm0

    665. 

  665. 

    666. 

  666. 		movq		[edi], mm1

    667. 

  667. 		movq		[edi+8], mm2

    668. 

  668. 

    669. 

  669. 		add		ebp, 8

    670. 

  670. 		add		ebx, 4

    671. 

  671. 		add		esi, 4

    672. 

  672.         add		edi, 16

    673. 

  673. 

    674. 

  674. 		dec		ecx

    675. 

  675. 		jnz		yuvtoyuy2row_loop

    676. 

  676. 

    677. 

  677. 		pop		ebx

    678. 

  678. 		pop		esi

    679. 

  679. 		pop		edi

    680. 

  680. 		pop		ebp

    681. 

  681. 		ret

    682. 

  682. 	};

    683. 

  683. }

    684. 

  684. 

    685. 

  685. static void __declspec(naked) yuvtoyuy2row_avg_MMX(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width, DWORD pitchuv)

    686. 

  686. {

    687. 

  687. 	static const __int64 mask = 0x7f7f7f7f7f7f7f7fi64;

    688. 

  688. 

    689. 

  689. 	__asm {

    690. 

  690. 		push	ebp

    691. 

  691. 		push	edi

    692. 

  692. 		push	esi

    693. 

  693. 		push	ebx

    694. 

  694. 

    695. 

  695. 		movq	mm7, mask

    696. 

  696. 

    697. 

  697. 		mov		edi, [esp+20] // dst

    698. 

  698. 		mov		ebp, [esp+24] // srcy

    699. 

  699. 		mov		ebx, [esp+28] // srcu

    700. 

  700. 		mov		esi, [esp+32] // srcv

    701. 

  701. 		mov		ecx, [esp+36] // width

    702. 

  702. 		mov		eax, [esp+40] // pitchuv

    703. 

  703. 

    704. 

  704. 		shr		ecx, 3

    705. 

  705. 

    706. 

  706. yuvtoyuy2row_avg_loop:

    707. 

  707. 

    708. 

  708. 		movd		mm0, [ebx]

    709. 

  709. 		punpcklbw	mm0, [esi]

    710. 

  710. 		movq		mm1, mm0

    711. 

  711. 

    712. 

  712. 		movd		mm2, [ebx + eax]

    713. 

  713. 		punpcklbw	mm2, [esi + eax]

    714. 

  714. 		movq		mm3, mm2

    715. 

  715. 

    716. 

  716. 		// (x+y)>>1 == (x&y)+((x^y)>>1)

    717. 

  717. 

    718. 

  718. 		pand		mm0, mm2

    719. 

  719. 		pxor		mm1, mm3

    720. 

  720. 		psrlq		mm1, 1

    721. 

  721. 		pand		mm1, mm7

    722. 

  722. 		paddb		mm0, mm1

    723. 

  723. 

    724. 

  724. 		movq		mm1, [ebp]

    725. 

  725. 		movq		mm2, mm1

    726. 

  726. 		punpcklbw	mm1, mm0

    727. 

  727. 		punpckhbw	mm2, mm0

    728. 

  728. 

    729. 

  729. 		movq		[edi], mm1

    730. 

  730. 		movq		[edi+8], mm2

    731. 

  731. 

    732. 

  732. 		add		ebp, 8

    733. 

  733. 		add		ebx, 4

    734. 

  734. 		add		esi, 4

    735. 

  735.         add		edi, 16

    736. 

  736. 

    737. 

  737. 		dec		ecx

    738. 

  738. 		jnz		yuvtoyuy2row_avg_loop

    739. 

  739. 

    740. 

  740. 		pop		ebx

    741. 

  741. 		pop		esi

    742. 

  742. 		pop		edi

    743. 

  743. 		pop		ebp

    744. 

  744. 		ret

    745. 

  745. 	};

    746. 

  746. }

    747. 

  747. 

    748. 

  748. static void __declspec(naked) yv12_yuy2_row_sse2() {

    749. 

  749.   __asm {

    750. 

  750.     // ebx - Y

    751. 

  751.     // edx - U

    752. 

  752.     // esi - V

    753. 

  753.     // edi - dest

    754. 

  754.     // ecx - halfwidth

    755. 

  755.     xor     eax, eax

    756. 

  756. 

    757. 

  757. one:

    758. 

  758.     movdqa  xmm0, [ebx + eax*2]    // YYYYYYYY

    759. 

  759.     movdqa  xmm1, [ebx + eax*2 + 16]    // YYYYYYYY

    760. 

  760. 

    761. 

  761.     movdqa  xmm2, [edx + eax]      // UUUUUUUU

    762. 

  762.     movdqa  xmm3, [esi + eax]      // VVVVVVVV

    763. 

  763. 

    764. 

  764.     movdqa  xmm4, xmm2

    765. 

  765.     movdqa  xmm5, xmm0

    766. 

  766.     movdqa  xmm6, xmm1

    767. 

  767.     punpcklbw xmm2, xmm3          // VUVUVUVU

    768. 

  768.     punpckhbw xmm4, xmm3          // VUVUVUVU

    769. 

  769. 

    770. 

  770.     punpcklbw xmm0, xmm2          // VYUYVYUY

    771. 

  771.     punpcklbw xmm1, xmm4

    772. 

  772.     punpckhbw xmm5, xmm2

    773. 

  773.     punpckhbw xmm6, xmm4

    774. 

  774. 

    775. 

  775.     movntdq [edi + eax*4], xmm0

    776. 

  776.     movntdq [edi + eax*4 + 16], xmm5

    777. 

  777.     movntdq [edi + eax*4 + 32], xmm1

    778. 

  778.     movntdq [edi + eax*4 + 48], xmm6

    779. 

  779. 

    780. 

  780.     add     eax, 16

    781. 

  781.     cmp     eax, ecx

    782. 

  782. 

    783. 

  783.     jb      one

    784. 

  784. 

    785. 

  785.     ret

    786. 

  786.   };

    787. 

  787. }

    788. 

  788. 

    789. 

  789. static void __declspec(naked) yv12_yuy2_row_sse2_linear() {

    790. 

  790.   __asm {

    791. 

  791.     // ebx - Y

    792. 

  792.     // edx - U

    793. 

  793.     // esi - V

    794. 

  794.     // edi - dest

    795. 

  795.     // ecx - width

    796. 

  796.     // ebp - uv_stride

    797. 

  797.     xor     eax, eax

    798. 

  798. 

    799. 

  799. one:

    800. 

  800.     movdqa  xmm0, [ebx + eax*2]    // YYYYYYYY

    801. 

  801.     movdqa  xmm1, [ebx + eax*2 + 16]    // YYYYYYYY

    802. 

  802. 

    803. 

  803.     movdqa  xmm2, [edx]

    804. 

  804.     movdqa  xmm3, [esi]

    805. 

  805.     pavgb   xmm2, [edx + ebp]      // UUUUUUUU

    806. 

  806.     pavgb   xmm3, [esi + ebp]      // VVVVVVVV

    807. 

  807. 

    808. 

  808.     movdqa  xmm4, xmm2

    809. 

  809.     movdqa  xmm5, xmm0

    810. 

  810.     movdqa  xmm6, xmm1

    811. 

  811.     punpcklbw xmm2, xmm3          // VUVUVUVU

    812. 

  812.     punpckhbw xmm4, xmm3          // VUVUVUVU

    813. 

  813. 

    814. 

  814.     punpcklbw xmm0, xmm2          // VYUYVYUY

    815. 

  815.     punpcklbw xmm1, xmm4

    816. 

  816.     punpckhbw xmm5, xmm2

    817. 

  817.     punpckhbw xmm6, xmm4

    818. 

  818. 

    819. 

  819.     movntdq [edi + eax*4], xmm0

    820. 

  820.     movntdq [edi + eax*4 + 16], xmm5

    821. 

  821.     movntdq [edi + eax*4 + 32], xmm1

    822. 

  822.     movntdq [edi + eax*4 + 48], xmm6

    823. 

  823. 

    824. 

  824.     add     eax, 16

    825. 

  825.     add     edx, 16

    826. 

  826.     add     esi, 16

    827. 

  827.     cmp     eax, ecx

    828. 

  828. 

    829. 

  829.     jb      one

    830. 

  830. 

    831. 

  831.     ret

    832. 

  832.   };

    833. 

  833. }

    834. 

  834. 

    835. 

  835. static void __declspec(naked) yv12_yuy2_row_sse2_linear_interlaced() {

    836. 

  836.   __asm {

    837. 

  837.     // ebx - Y

    838. 

  838.     // edx - U

    839. 

  839.     // esi - V

    840. 

  840.     // edi - dest

    841. 

  841.     // ecx - width

    842. 

  842.     // ebp - uv_stride

    843. 

  843.     xor     eax, eax

    844. 

  844. 

    845. 

  845. one:

    846. 

  846.     movdqa  xmm0, [ebx + eax*2]    // YYYYYYYY

    847. 

  847.     movdqa  xmm1, [ebx + eax*2 + 16]    // YYYYYYYY

    848. 

  848. 

    849. 

  849.     movdqa  xmm2, [edx]

    850. 

  850.     movdqa  xmm3, [esi]

    851. 

  851.     pavgb   xmm2, [edx + ebp*2]      // UUUUUUUU

    852. 

  852.     pavgb   xmm3, [esi + ebp*2]      // VVVVVVVV

    853. 

  853. 

    854. 

  854.     movdqa  xmm4, xmm2

    855. 

  855.     movdqa  xmm5, xmm0

    856. 

  856.     movdqa  xmm6, xmm1

    857. 

  857.     punpcklbw xmm2, xmm3          // VUVUVUVU

    858. 

  858.     punpckhbw xmm4, xmm3          // VUVUVUVU

    859. 

  859. 

    860. 

  860.     punpcklbw xmm0, xmm2          // VYUYVYUY

    861. 

  861.     punpcklbw xmm1, xmm4

    862. 

  862.     punpckhbw xmm5, xmm2

    863. 

  863.     punpckhbw xmm6, xmm4

    864. 

  864. 

    865. 

  865.     movntdq [edi + eax*4], xmm0

    866. 

  866.     movntdq [edi + eax*4 + 16], xmm5

    867. 

  867.     movntdq [edi + eax*4 + 32], xmm1

    868. 

  868.     movntdq [edi + eax*4 + 48], xmm6

    869. 

  869. 

    870. 

  870.     add     eax, 16

    871. 

  871.     add     edx, 16

    872. 

  872.     add     esi, 16

    873. 

  873.     cmp     eax, ecx

    874. 

  874. 

    875. 

  875.     jb      one

    876. 

  876. 

    877. 

  877.     ret

    878. 

  878.   };

    879. 

  879. }

    880. 

  880. 

    881. 

  881. void __declspec(naked) yv12_yuy2_sse2(const BYTE *Y, const BYTE *U, const BYTE *V,

    882. 

  882.     int halfstride, unsigned halfwidth, unsigned height,

    883. 

  883.     BYTE *YUY2, int d_stride)

    884. 

  884. {

    885. 

  885.   __asm {

    886. 

  886.     push    ebx

    887. 

  887.     push    esi

    888. 

  888.     push    edi

    889. 

  889.     push    ebp

    890. 

  890. 

    891. 

  891.     mov     ebx, [esp + 20] // Y

    892. 

  892.     mov     edx, [esp + 24] // U

    893. 

  893.     mov     esi, [esp + 28] // V

    894. 

  894.     mov     edi, [esp + 44] // D

    895. 

  895.     mov     ebp, [esp + 32] // uv_stride

    896. 

  896.     mov     ecx, [esp + 36] // uv_width

    897. 

  897. 

    898. 

  898.     mov     eax, ecx

    899. 

  899.     add     eax, 15

    900. 

  900.     and     eax, 0xfffffff0

    901. 

  901.     sub     [esp + 32], eax

    902. 

  902. 

    903. 

  903.     cmp     dword ptr [esp + 40], 2

    904. 

  904.     jbe     last2

    905. 

  905. 

    906. 

  906. row:

    907. 

  907.     sub     dword ptr [esp + 40], 2

    908. 

  908.     call    yv12_yuy2_row_sse2

    909. 

  909. 

    910. 

  910.     lea     ebx, [ebx + ebp*2]

    911. 

  911.     add     edi, [esp + 48]

    912. 

  912. 

    913. 

  913.     call    yv12_yuy2_row_sse2_linear

    914. 

  914. 

    915. 

  915.     add     edx, [esp + 32]

    916. 

  916.     add     esi, [esp + 32]

    917. 

  917. 

    918. 

  918.     lea     ebx, [ebx + ebp*2]

    919. 

  919.     add     edi, [esp + 48]

    920. 

  920. 

    921. 

  921.     cmp     dword ptr [esp + 40], 2

    922. 

  922.     ja      row

    923. 

  923. 

    924. 

  924. last2:

    925. 

  925.     call    yv12_yuy2_row_sse2

    926. 

  926. 

    927. 

  927.     dec     dword ptr [esp + 40]

    928. 

  928.     jz      done

    929. 

  929. 

    930. 

  930.     lea     ebx, [ebx + ebp*2]

    931. 

  931.     add     edi, [esp + 48]

    932. 

  932.     call    yv12_yuy2_row_sse2

    933. 

  933. done:

    934. 

  934. 

    935. 

  935.     pop     ebp

    936. 

  936.     pop     edi

    937. 

  937.     pop     esi

    938. 

  938.     pop     ebx

    939. 

  939. 

    940. 

  940.     ret

    941. 

  941.   };

    942. 

  942. }

    943. 

  943. 

    944. 

  944. void __declspec(naked) yv12_yuy2_sse2_interlaced(const BYTE *Y, const BYTE *U, const BYTE *V,

    945. 

  945.     int halfstride, unsigned halfwidth, unsigned height,

    946. 

  946.     BYTE *YUY2, int d_stride)

    947. 

  947. {

    948. 

  948.   __asm {

    949. 

  949.     push    ebx

    950. 

  950.     push    esi

    951. 

  951.     push    edi

    952. 

  952.     push    ebp

    953. 

  953. 

    954. 

  954.     mov     ebx, [esp + 20] // Y

    955. 

  955.     mov     edx, [esp + 24] // U

    956. 

  956.     mov     esi, [esp + 28] // V

    957. 

  957.     mov     edi, [esp + 44] // D

    958. 

  958.     mov     ebp, [esp + 32] // uv_stride

    959. 

  959.     mov     ecx, [esp + 36] // uv_width

    960. 

  960. 

    961. 

  961.     mov     eax, ecx

    962. 

  962.     add     eax, 15

    963. 

  963.     and     eax, 0xfffffff0

    964. 

  964.     sub     [esp + 32], eax

    965. 

  965. 

    966. 

  966.     cmp     dword ptr [esp + 40], 4

    967. 

  967.     jbe     last4

    968. 

  968. 

    969. 

  969. row:

    970. 

  970.     sub     dword ptr [esp + 40], 4

    971. 

  971.     call    yv12_yuy2_row_sse2	// first row, first field

    972. 

  972. 

    973. 

  973.     lea     ebx, [ebx + ebp*2]

    974. 

  974.     add     edi, [esp + 48]

    975. 

  975. 

    976. 

  976.     add	    edx, ebp

    977. 

  977.     add	    esi, ebp

    978. 

  978. 

    979. 

  979.     call    yv12_yuy2_row_sse2	// first row, second field

    980. 

  980. 

    981. 

  981.     lea     ebx, [ebx + ebp*2]

    982. 

  982.     add     edi, [esp + 48]

    983. 

  983. 

    984. 

  984.     sub	    edx, ebp

    985. 

  985.     sub	    esi, ebp

    986. 

  986. 

    987. 

  987.     call    yv12_yuy2_row_sse2_linear_interlaced // second row, first field

    988. 

  988. 

    989. 

  989.     add     edx, [esp + 32]

    990. 

  990.     add     esi, [esp + 32]

    991. 

  991. 

    992. 

  992.     lea     ebx, [ebx + ebp*2]

    993. 

  993.     add     edi, [esp + 48]

    994. 

  994. 

    995. 

  995.     call    yv12_yuy2_row_sse2_linear_interlaced // second row, second field

    996. 

  996. 

    997. 

  997.     add     edx, [esp + 32]

    998. 

  998.     add     esi, [esp + 32]

    999. 

  999. 

    1000. 

  1000.     lea     ebx, [ebx + ebp*2]

    1001. 

  1001.     add     edi, [esp + 48]

    1002. 

  1002. 

    1003. 

  1003.     cmp     dword ptr [esp + 40], 4

    1004. 

  1004.     ja      row

    1005. 

  1005. 

    1006. 

  1006. last4:

    1007. 

  1007.     call    yv12_yuy2_row_sse2

    1008. 

  1008. 

    1009. 

  1009.     lea     ebx, [ebx + ebp*2]

    1010. 

  1010.     add     edi, [esp + 48]

    1011. 

  1011. 

    1012. 

  1012.     add     edx, ebp

    1013. 

  1013.     add     esi, ebp

    1014. 

  1014. 

    1015. 

  1015.     call    yv12_yuy2_row_sse2

    1016. 

  1016. 

    1017. 

  1017.     lea     ebx, [ebx + ebp*2]

    1018. 

  1018.     add     edi, [esp + 48]

    1019. 

  1019. 

    1020. 

  1020.     sub     edx, ebp

    1021. 

  1021.     sub     esi, ebp

    1022. 

  1022. 

    1023. 

  1023.     call    yv12_yuy2_row_sse2

    1024. 

  1024. 

    1025. 

  1025.     lea     ebx, [ebx + ebp*2]

    1026. 

  1026.     add     edi, [esp + 48]

    1027. 

  1027. 

    1028. 

  1028.     add     edx, ebp

    1029. 

  1029.     add     esi, ebp

    1030. 

  1030. 

    1031. 

  1031.     call    yv12_yuy2_row_sse2

    1032. 

  1032. 

    1033. 

  1033.     pop     ebp

    1034. 

  1034.     pop     edi

    1035. 

  1035.     pop     esi

    1036. 

  1036.     pop     ebx

    1037. 

  1037. 

    1038. 

  1038.     ret

    1039. 

  1039.   };

    1040. 

  1040. }

    1041. 

  1041. 

    1042. 

  1042. bool BitBltFromI420ToYUY2(int w, int h, BYTE* dst, int dstpitch, BYTE* srcy, BYTE* srcu, BYTE* srcv, int srcpitch, bool fInterlaced)

    1043. 

  1043. {

    1044. 

  1044. 	if(h&1){h--;}

    1045. 

  1045. 	if(w<=0 || h<=0 || (w&1) || (h&1))

    1046. 

  1046. 		return(false);

    1047. 

  1047. 

    1048. 

  1048. 	if(srcpitch == 0) srcpitch = w;

    1049. 

  1049. 

    1050. 

  1050. 	if((g_cpuid.m_flags & CCpuID::sse2) 

    1051. 

  1051.         && !((DWORD_PTR)srcy&15) && !((DWORD_PTR)srcu&15) && !((DWORD_PTR)srcv&15) && !(srcpitch&31) 

    1052. 

  1052.         && !((DWORD_PTR)dst&15) && !(dstpitch&15))

    1053. 

  1053. 	{

    1054. 

  1054. 		if(!fInterlaced) {

    1055. 

  1055. 			yv12_yuy2_sse2(srcy, srcu, srcv, srcpitch/2, w/2, h, dst, dstpitch);

    1056. 

  1056. 		}

    1057. 

  1057. 		else{

    1058. 

  1058. 			yv12_yuy2_sse2_interlaced(srcy, srcu, srcv, srcpitch/2, w/2, h, dst, dstpitch);

    1059. 

  1059. 		}

    1060. 

  1060. 		return true;

    1061. 

  1061. 	}

    1062. 

  1062. 	else

    1063. 

  1063. 	{

    1064. 

  1064. 		ASSERT(!fInterlaced);

    1065. 

  1065. 	}

    1066. 

  1066. 

    1067. 

  1067. 	void (*yuvtoyuy2row)(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width) = NULL;

    1068. 

  1068. 	void (*yuvtoyuy2row_avg)(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width, DWORD pitchuv) = NULL;

    1069. 

  1069. 

    1070. 

  1070. 	if((g_cpuid.m_flags & CCpuID::mmx) && !(w&7))

    1071. 

  1071. 	{

    1072. 

  1072. 		yuvtoyuy2row = yuvtoyuy2row_MMX;

    1073. 

  1073. 		yuvtoyuy2row_avg = yuvtoyuy2row_avg_MMX;

    1074. 

  1074. 	}

    1075. 

  1075. 	else

    1076. 

  1076. 	{

    1077. 

  1077. 		yuvtoyuy2row = yuvtoyuy2row_c;

    1078. 

  1078. 		yuvtoyuy2row_avg = yuvtoyuy2row_avg_c;

    1079. 

  1079. 	}

    1080. 

  1080. 

    1081. 

  1081. 	if(!yuvtoyuy2row) 

    1082. 

  1082. 		return(false);

    1083. 

  1083. 

    1084. 

  1084. 	do

    1085. 

  1085. 	{

    1086. 

  1086. 		yuvtoyuy2row(dst, srcy, srcu, srcv, w);

    1087. 

  1087. 		yuvtoyuy2row_avg(dst + dstpitch, srcy + srcpitch, srcu, srcv, w, srcpitch/2);

    1088. 

  1088. 

    1089. 

  1089. 		dst += 2*dstpitch;

    1090. 

  1090. 		srcy += srcpitch*2;

    1091. 

  1091. 		srcu += srcpitch/2;

    1092. 

  1092. 		srcv += srcpitch/2;

    1093. 

  1093. 	}

    1094. 

  1094. 	while((h -= 2) > 2);

    1095. 

  1095. 

    1096. 

  1096. 	yuvtoyuy2row(dst, srcy, srcu, srcv, w);

    1097. 

  1097. 	yuvtoyuy2row(dst + dstpitch, srcy + srcpitch, srcu, srcv, w);

    1098. 

  1098. 

    1099. 

  1099. 	if(g_cpuid.m_flags & CCpuID::mmx)

    1100. 

  1100. 		__asm emms

    1101. 

  1101. 

    1102. 

  1102. 	return(true);

    1103. 

  1103. }

    1104. 

  1104. bool BitBltFromRGBToYUY2(int w, int h, BYTE* dst, int dstpitch,  BYTE* src, int srcpitch, int sbpp){

    1105. 

  1105. 	return true;

    1106. 

  1106. }

    1107. 

  1107. bool BitBltFromRGBToRGB(int w, int h, BYTE* dst, int dstpitch, int dbpp, BYTE* src, int srcpitch, int sbpp, DWORD* palette)

    1108. 

  1108. {

    1109. 

  1109. 	//SVP_LogMsg5(L" rgb to rgb %d %d",dbpp , sbpp);

    1110. 

  1110. //	SVP_LogMsg5(L" rgb to rgb a %d %d %d %d %d %d",w , h,dstpitch,srcpitch,dbpp,sbpp );

    1111. 

  1111. 	if(dbpp == sbpp)

    1112. 

  1112. 	{

    1113. 

  1113. 		int rowbytes = w*dbpp>>3;

    1114. 

  1114. 		int y = 0;

    1115. 

  1115. 		__try{

    1116. 

  1116. 			if(h&1){h--;}

    1117. 

  1117. 			if(rowbytes > 0 && rowbytes == srcpitch && rowbytes == dstpitch)

    1118. 

  1118. 			{

    1119. 

  1119. 				memcpy_accel(dst, src, h*rowbytes);

    1120. 

  1120. 			}

    1121. 

  1121. 			else

    1122. 

  1122. 			{

    1123. 

  1123. 				for(y = 0; y < h; y++, src += srcpitch, dst += dstpitch)

    1124. 

  1124. 					memcpy_accel(dst, src,  rowbytes);

    1125. 

  1125. 			}

    1126. 

  1126. 		}__except(EXCEPTION_EXECUTE_HANDLER){

    1127. 

  1127. 			SVP_LogMsg5(L" rgb to rgb %d %d %d %d %d %d %d %d",w , h,dstpitch,srcpitch,dbpp,sbpp ,rowbytes, y);

    1128. 

  1128. 

    1129. 

  1129. 		}

    1130. 

  1130. 

    1131. 

  1131. 		return(true);

    1132. 

  1132. 	}

    1133. 

  1133. 	

    1134. 

  1134. 	if(sbpp != 16 && sbpp != 24 && sbpp != 32 && sbpp != 15 && sbpp != 8

    1135. 

  1135. 	|| dbpp != 16 && dbpp != 24 && dbpp != 32)

    1136. 

  1136. 		return(false);

    1137. 

  1137. 

    1138. 

  1138. 	

    1139. 

  1139. 	if(dbpp == 16)

    1140. 

  1140. 	{

    1141. 

  1141. 		for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)

    1142. 

  1142. 		{

    1143. 

  1143. 			if(sbpp == 8)

    1144. 

  1144. 			{

    1145. 

  1145. 				BYTE* s = (BYTE*)src;

    1146. 

  1146. 				WORD* d = (WORD*)dst;

    1147. 

  1147. 				if(palette){

    1148. 

  1148. 					for(int x = 0; x < w; x++, s++, d++)

    1149. 

  1149. 						*d =  (WORD)(((*((DWORD*)(palette[*s]))>>8)&0xf00)|((*((DWORD*)(palette[*s]))>>5)&0x03e0)|((*((DWORD*)(palette[*s]))>>3)&0x1f));

    1150. 

  1150. 				}else{

    1151. 

  1151. 					for(int x = 0; x < w; x++, s++, d++)

    1152. 

  1152. 						*d = ((*s&0xe0)<<16)|((*s&0x1c)<<11)|((*s&0x03)<<6);

    1153. 

  1153. 				}

    1154. 

  1154. 			}else if(sbpp == 15)

    1155. 

  1155. 			{

    1156. 

  1156. 				BYTE* s = (BYTE*)src;

    1157. 

  1157. 				WORD* d = (WORD*)dst;

    1158. 

  1158. 				for(int x = 0; x < w; x++, s+=3, d++)

    1159. 

  1159. 					*d = (WORD)(((*((DWORD*)s)>>9)&0x7c00)|((*((DWORD*)s)>>6)&0x03e0)|((*((DWORD*)s)>>3)&0x1f));

    1160. 

  1160. 

    1161. 

  1161. 			}else if(sbpp == 24)

    1162. 

  1162. 			{

    1163. 

  1163. 				BYTE* s = (BYTE*)src;

    1164. 

  1164. 				WORD* d = (WORD*)dst;

    1165. 

  1165. 				for(int x = 0; x < w; x++, s+=3, d++)

    1166. 

  1166. 					*d = (WORD)(((*((DWORD*)s)>>8)&0xf00)|((*((DWORD*)s)>>5)&0x03e0)|((*((DWORD*)s)>>3)&0x1f));

    1167. 

  1167. 			}

    1168. 

  1168. 			else if(sbpp == 32)

    1169. 

  1169. 			{

    1170. 

  1170. 				DWORD* s = (DWORD*)src;

    1171. 

  1171. 				WORD* d = (WORD*)dst;

    1172. 

  1172. 				for(int x = 0; x < w; x++, s++, d++)

    1173. 

  1173. 					*d = (WORD)(((*s>>8)&0xf800)|((*s>>5)&0x07e0)|((*s>>3)&0x1f));

    1174. 

  1174. 			}

    1175. 

  1175. 		}

    1176. 

  1176. 	}

    1177. 

  1177. 	else if(dbpp == 24)

    1178. 

  1178. 	{

    1179. 

  1179. 		for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)

    1180. 

  1180. 		{

    1181. 

  1181. 			if(sbpp == 8)

    1182. 

  1182. 			{

    1183. 

  1183. 				BYTE* s = (BYTE*)src;

    1184. 

  1184. 				BYTE* d = (BYTE*)dst;

    1185. 

  1185. 				if(palette){

    1186. 

  1186. 					for(int x = 0; x < w; x++, s++, d+=3){

    1187. 

  1187. 						d[0] = (palette[*s]&0xff0000) >> 16;

    1188. 

  1188. 						d[1] = (palette[*s]&0xff00) >> 8;

    1189. 

  1189. 						d[2] = palette[*s]&0xff;

    1190. 

  1190. 					}

    1191. 

  1191. 				}else{

    1192. 

  1192. 					for(int x = 0; x < w; x++, s++, d+=3)

    1193. 

  1193. 					{	// not tested, r-g-b might be in reverse

    1194. 

  1194. 						d[0] = (*s&0x03)<<6;

    1195. 

  1195. 						d[1] = (*s&0x1c)<<11;

    1196. 

  1196. 						d[2] = (*s&0xe0)<<16;

    1197. 

  1197. 					}

    1198. 

  1198. 				}

    1199. 

  1199. 				

    1200. 

  1200. 			}else if(sbpp == 15)

    1201. 

  1201. 			{

    1202. 

  1202. 				WORD* s = (WORD*)src;

    1203. 

  1203. 				BYTE* d = (BYTE*)dst;

    1204. 

  1204. 				for(int x = 0; x < w; x++, s++, d+=3)

    1205. 

  1205. 				{	// not tested, r-g-b might be in reverse

    1206. 

  1206. 					d[0] = (*s&0x001f)<<3;

    1207. 

  1207. 					d[1] = (*s&0x03e0)<<6;

    1208. 

  1208. 					d[2] = (*s&0x7c00)<<9;

    1209. 

  1209. 				}

    1210. 

  1210. 				

    1211. 

  1211. 			}else if(sbpp == 16)

    1212. 

  1212. 			{

    1213. 

  1213. 				WORD* s = (WORD*)src;

    1214. 

  1214. 				BYTE* d = (BYTE*)dst;

    1215. 

  1215. 				for(int x = 0; x < w; x++, s++, d+=3)

    1216. 

  1216. 				{	// not tested, r-g-b might be in reverse

    1217. 

  1217. 					d[0] = (*s&0x001f)<<3;

    1218. 

  1218. 					d[1] = (*s&0x07e0)<<5;

    1219. 

  1219. 					d[2] = (*s&0xf800)<<8;

    1220. 

  1220. 				}

    1221. 

  1221. 			}

    1222. 

  1222. 			else if(sbpp == 32)

    1223. 

  1223. 			{

    1224. 

  1224. 				BYTE* s = (BYTE*)src;

    1225. 

  1225. 				BYTE* d = (BYTE*)dst;

    1226. 

  1226. 				for(int x = 0; x < w; x++, s+=4, d+=3)

    1227. 

  1227. 					{d[0] = s[0]; d[1] = s[1]; d[2] = s[2];}

    1228. 

  1228. 			}

    1229. 

  1229. 		}

    1230. 

  1230. 	}

    1231. 

  1231. 	else if(dbpp == 32)

    1232. 

  1232. 	{

    1233. 

  1233. 		for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)

    1234. 

  1234. 		{

    1235. 

  1235. 			if(sbpp == 8)

    1236. 

  1236. 			{

    1237. 

  1237. 				BYTE* s = (BYTE*)src;

    1238. 

  1238. 				DWORD* d = (DWORD*)dst;

    1239. 

  1239. 				if(palette){

    1240. 

  1240. 					for(int x = 0; x < w; x++, s++, d++)

    1241. 

  1241. 						*d = palette[*s];

    1242. 

  1242. 				}else{

    1243. 

  1243. 					for(int x = 0; x < w; x++, s++, d++)

    1244. 

  1244. 						*d = ((*s&0xe0)<<16)|((*s&0x1c)<<11)|((*s&0x03)<<6);

    1245. 

  1245. 				}

    1246. 

  1246. 			}else if(sbpp == 15)

    1247. 

  1247. 			{

    1248. 

  1248. 				WORD* s = (WORD*)src;

    1249. 

  1249. 				DWORD* d = (DWORD*)dst;

    1250. 

  1250. 				for(int x = 0; x < w; x++, s++, d++)

    1251. 

  1251. 					*d = ((*s&0x7c00)<<9)|((*s&0x03e0)<<6)|((*s&0x001f)<<3);

    1252. 

  1252. 			}else if(sbpp == 16)

    1253. 

  1253. 			{

    1254. 

  1254. 				WORD* s = (WORD*)src;

    1255. 

  1255. 				DWORD* d = (DWORD*)dst;

    1256. 

  1256. 				for(int x = 0; x < w; x++, s++, d++)

    1257. 

  1257. 					*d = ((*s&0xf800)<<8)|((*s&0x07e0)<<5)|((*s&0x001f)<<3);

    1258. 

  1258. 			}

    1259. 

  1259. 			else if(sbpp == 24)

    1260. 

  1260. 			{	

    1261. 

  1261. 				BYTE* s = (BYTE*)src;

    1262. 

  1262. 				DWORD* d = (DWORD*)dst;

    1263. 

  1263. 				for(int x = 0; x < w; x++, s+=3, d++)

    1264. 

  1264. 					*d = *((DWORD*)s)&0xffffff;

    1265. 

  1265. 			}

    1266. 

  1266. 		}

    1267. 

  1267. 	}else{

    1268. 

  1268. 		//SVP_LogMsg5(L"None rgb to rgb");

    1269. 

  1269. 	}

    1270. 

  1270. 

    1271. 

  1271. 

    1272. 

  1272. 	return(true);

    1273. 

  1273. }

    1274. 

  1274. 

    1275. 

  1275. static void __declspec(naked) asm_blend_row_clipped_MMX(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)

    1276. 

  1276. {

    1277. 

  1277. 	static const __int64 _x0001000100010001 = 0x0001000100010001;

    1278. 

  1278. 

    1279. 

  1279. 	__asm {

    1280. 

  1280. 		push	ebp

    1281. 

  1281. 		push	edi

    1282. 

  1282. 		push	esi

    1283. 

  1283. 		push	ebx

    1284. 

  1284. 

    1285. 

  1285. 		mov		edi,[esp+20]

    1286. 

  1286. 		mov		esi,[esp+24]

    1287. 

  1287. 		sub		edi,esi

    1288. 

  1288. 		mov		ebp,[esp+28]

    1289. 

  1289. 		mov		edx,[esp+32]

    1290. 

  1290. 

    1291. 

  1291. 		shr		ebp, 3

    1292. 

  1292. 

    1293. 

  1293. 		movq	mm6, _x0001000100010001

    1294. 

  1294. 		pxor	mm7, mm7

    1295. 

  1295. 

    1296. 

  1296. xloop:

    1297. 

  1297. 		movq		mm0, [esi]

    1298. 

  1298. 		movq		mm3, mm0

    1299. 

  1299. 		punpcklbw	mm0, mm7

    1300. 

  1300. 		punpckhbw	mm3, mm7

    1301. 

  1301. 

    1302. 

  1302. 		movq		mm1, [esi+edx]

    1303. 

  1303. 		movq		mm4, mm1

    1304. 

  1304. 		punpcklbw	mm1, mm7

    1305. 

  1305. 		punpckhbw	mm4, mm7

    1306. 

  1306. 

    1307. 

  1307. 		paddw		mm1, mm0

    1308. 

  1308. 		paddw		mm1, mm6

    1309. 

  1309. 		psrlw		mm1, 1

    1310. 

  1310. 

    1311. 

  1311. 		paddw		mm4, mm3

    1312. 

  1312. 		paddw		mm4, mm6

    1313. 

  1313. 		psrlw		mm4, 1

    1314. 

  1314. 

    1315. 

  1315. 		add			esi, 8

    1316. 

  1316. 		packuswb	mm1, mm4

    1317. 

  1317. 		movq		[edi+esi-8], mm1

    1318. 

  1318. 

    1319. 

  1319. 		dec		ebp

    1320. 

  1320. 		jne		xloop

    1321. 

  1321. 

    1322. 

  1322. 		pop		ebx

    1323. 

  1323. 		pop		esi

    1324. 

  1324. 		pop		edi

    1325. 

  1325. 		pop		ebp

    1326. 

  1326. 		ret

    1327. 

  1327. 	};

    1328. 

  1328. }

    1329. 

  1329. 

    1330. 

  1330. static void __declspec(naked) asm_blend_row_MMX(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)

    1331. 

  1331. {

    1332. 

  1332. 	static const __int64 mask0 = 0xfcfcfcfcfcfcfcfci64;

    1333. 

  1333. 	static const __int64 mask1 = 0x7f7f7f7f7f7f7f7fi64;

    1334. 

  1334. 	static const __int64 mask2 = 0x3f3f3f3f3f3f3f3fi64;

    1335. 

  1335. 	static const __int64 _x0002000200020002 = 0x0002000200020002;

    1336. 

  1336. 

    1337. 

  1337. 	__asm {

    1338. 

  1338. 		push	ebp

    1339. 

  1339. 		push	edi

    1340. 

  1340. 		push	esi

    1341. 

  1341. 		push	ebx

    1342. 

  1342. 

    1343. 

  1343. 		mov		edi, [esp+20]

    1344. 

  1344. 		mov		esi, [esp+24]

    1345. 

  1345. 		sub		edi, esi

    1346. 

  1346. 		mov		ebp, [esp+28]

    1347. 

  1347. 		mov		edx, [esp+32]

    1348. 

  1348. 

    1349. 

  1349. 		shr		ebp, 3

    1350. 

  1350. 

    1351. 

  1351. 		movq	mm6, _x0002000200020002

    1352. 

  1352. 		pxor	mm7, mm7

    1353. 

  1353. 

    1354. 

  1354. xloop:

    1355. 

  1355. 		movq		mm0, [esi]

    1356. 

  1356. 		movq		mm3, mm0

    1357. 

  1357. 		punpcklbw	mm0, mm7

    1358. 

  1358. 		punpckhbw	mm3, mm7

    1359. 

  1359. 

    1360. 

  1360. 		movq		mm1, [esi+edx]

    1361. 

  1361. 		movq		mm4, mm1

    1362. 

  1362. 		punpcklbw	mm1, mm7

    1363. 

  1363. 		punpckhbw	mm4, mm7

    1364. 

  1364. 

    1365. 

  1365. 		movq		mm2, [esi+edx*2]

    1366. 

  1366. 		movq		mm5, mm2

    1367. 

  1367. 		punpcklbw	mm2, mm7

    1368. 

  1368. 		punpckhbw	mm5, mm7

    1369. 

  1369. 

    1370. 

  1370. 		psllw		mm1, 1

    1371. 

  1371. 		paddw		mm1, mm0

    1372. 

  1372. 		paddw		mm1, mm2

    1373. 

  1373. 		paddw		mm1, mm6

    1374. 

  1374. 		psrlw		mm1, 2

    1375. 

  1375. 

    1376. 

  1376. 		psllw		mm4, 1

    1377. 

  1377. 		paddw		mm4, mm3

    1378. 

  1378. 		paddw		mm4, mm5

    1379. 

  1379. 		paddw		mm4, mm6

    1380. 

  1380. 		psrlw		mm4, 2

    1381. 

  1381. 

    1382. 

  1382. 		add			esi, 8

    1383. 

  1383. 		packuswb	mm1, mm4

    1384. 

  1384. 		movq		[edi+esi-8], mm1

    1385. 

  1385. 

    1386. 

  1386. 		dec		ebp

    1387. 

  1387. 		jne		xloop

    1388. 

  1388. 

    1389. 

  1389. 		// sadly the original code makes a lot of visible banding artifacts on yuv

    1390. 

  1390. 		// (it seems those shiftings without rounding introduce too much error)

    1391. 

  1391. /*

    1392. 

  1392. 		mov		edi,[esp+20]

    1393. 

  1393. 		mov		esi,[esp+24]

    1394. 

  1394. 		sub		edi,esi

    1395. 

  1395. 		mov		ebp,[esp+28]

    1396. 

  1396. 		mov		edx,[esp+32]

    1397. 

  1397. 

    1398. 

  1398. 		movq	mm5,mask0

    1399. 

  1399. 		movq	mm6,mask1

    1400. 

  1400. 		movq	mm7,mask2

    1401. 

  1401. 		shr		ebp,1

    1402. 

  1402. 		jz		oddpart

    1403. 

  1403. 

    1404. 

  1404. xloop:

    1405. 

  1405. 		movq	mm2,[esi]

    1406. 

  1406. 		movq	mm0,mm5

    1407. 

  1407. 

    1408. 

  1408. 		movq	mm1,[esi+edx]

    1409. 

  1409. 		pand	mm0,mm2

    1410. 

  1410. 

    1411. 

  1411. 		psrlq	mm1,1

    1412. 

  1412. 		movq	mm2,[esi+edx*2]

    1413. 

  1413. 

    1414. 

  1414. 		psrlq	mm2,2

    1415. 

  1415. 		pand	mm1,mm6

    1416. 

  1416. 

    1417. 

  1417. 		psrlq	mm0,2

    1418. 

  1418. 		pand	mm2,mm7

    1419. 

  1419. 

    1420. 

  1420. 		paddb	mm0,mm1

    1421. 

  1421. 		add		esi,8

    1422. 

  1422. 

    1423. 

  1423. 		paddb	mm0,mm2

    1424. 

  1424. 		dec		ebp

    1425. 

  1425. 

    1426. 

  1426. 		movq	[edi+esi-8],mm0

    1427. 

  1427. 		jne		xloop

    1428. 

  1428. 

    1429. 

  1429. oddpart:

    1430. 

  1430. 		test	byte ptr [esp+28],1

    1431. 

  1431. 		jz		nooddpart

    1432. 

  1432. 

    1433. 

  1433. 		mov		ecx,[esi]

    1434. 

  1434. 		mov		eax,0fcfcfcfch

    1435. 

  1435. 		mov		ebx,[esi+edx]

    1436. 

  1436. 		and		eax,ecx

    1437. 

  1437. 		shr		ebx,1

    1438. 

  1438. 		mov		ecx,[esi+edx*2]

    1439. 

  1439. 		shr		ecx,2

    1440. 

  1440. 		and		ebx,07f7f7f7fh

    1441. 

  1441. 		shr		eax,2

    1442. 

  1442. 		and		ecx,03f3f3f3fh

    1443. 

  1443. 		add		eax,ebx

    1444. 

  1444. 		add		eax,ecx

    1445. 

  1445. 		mov		[edi+esi],eax

    1446. 

  1446. 

    1447. 

  1447. nooddpart:

    1448. 

  1448. */

    1449. 

  1449. 		pop		ebx

    1450. 

  1450. 		pop		esi

    1451. 

  1451. 		pop		edi

    1452. 

  1452. 		pop		ebp

    1453. 

  1453. 		ret

    1454. 

  1454. 	};

    1455. 

  1455. }

    1456. 

  1456. 

    1457. 

  1457. __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};

    1458. 

  1458. 

    1459. 

  1459. static void asm_blend_row_SSE2(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)

    1460. 

  1460. {

    1461. 

  1461. 	__asm

    1462. 

  1462. 	{

    1463. 

  1463. 		mov edx, srcpitch

    1464. 

  1464. 		mov esi, src

    1465. 

  1465. 		mov edi, dst

    1466. 

  1466. 		sub edi, esi

    1467. 

  1467. 		mov ecx, w

    1468. 

  1468. 		mov ebx, ecx

    1469. 

  1469. 		shr ecx, 4

    1470. 

  1470. 		and ebx, 15

    1471. 

  1471. 

    1472. 

  1472. 		movdqa xmm7, [const_1_16_bytes] 

    1473. 

  1473. 

    1474. 

  1474. asm_blend_row_SSE2_loop:

    1475. 

  1475. 		movdqa xmm0, [esi]

    1476. 

  1476. 		movdqa xmm1, [esi+edx]

    1477. 

  1477. 		movdqa xmm2, [esi+edx*2]

    1478. 

  1478. 		pavgb xmm0, xmm1

    1479. 

  1479. 		pavgb xmm2, xmm1

    1480. 

  1480. 		psubusb xmm0, xmm7

    1481. 

  1481. 		pavgb xmm0, xmm2

    1482. 

  1482. 		movdqa [esi+edi], xmm0

    1483. 

  1483. 		add esi, 16

    1484. 

  1484. 		dec	ecx

    1485. 

  1485. 		jnz asm_blend_row_SSE2_loop

    1486. 

  1486. 

    1487. 

  1487. 		test ebx,15

    1488. 

  1488. 		jz asm_blend_row_SSE2_end

    1489. 

  1489. 

    1490. 

  1490. 		mov ecx, ebx

    1491. 

  1491. 		xor ax, ax

    1492. 

  1492. 		xor bx, bx

    1493. 

  1493. 		xor dx, dx

    1494. 

  1494. asm_blend_row_SSE2_loop2:

    1495. 

  1495. 		mov al, [esi]

    1496. 

  1496. 		mov bl, [esi+edx]

    1497. 

  1497. 		mov dl, [esi+edx*2]

    1498. 

  1498. 		add ax, bx

    1499. 

  1499. 		inc ax

    1500. 

  1500. 		shr ax, 1

    1501. 

  1501. 		add dx, bx

    1502. 

  1502. 		inc dx

    1503. 

  1503. 		shr dx, 1

    1504. 

  1504. 		add ax, dx

    1505. 

  1505. 		shr ax, 1

    1506. 

  1506. 		mov [esi+edi], al

    1507. 

  1507. 		inc esi

    1508. 

  1508. 		dec	ecx

    1509. 

  1509. 		jnz asm_blend_row_SSE2_loop2

    1510. 

  1510. 

    1511. 

  1511. asm_blend_row_SSE2_end:

    1512. 

  1512. 	}

    1513. 

  1513. }

    1514. 

  1514. 

    1515. 

  1515. static void asm_blend_row_clipped_SSE2(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)

    1516. 

  1516. {

    1517. 

  1517. 	__asm

    1518. 

  1518. 	{

    1519. 

  1519. 		mov edx, srcpitch

    1520. 

  1520. 		mov esi, src

    1521. 

  1521. 		mov edi, dst

    1522. 

  1522. 		sub edi, esi

    1523. 

  1523. 		mov ecx, w

    1524. 

  1524. 		mov ebx, ecx

    1525. 

  1525. 		shr ecx, 4

    1526. 

  1526. 		and ebx, 15

    1527. 

  1527. 

    1528. 

  1528. 		movdqa xmm7, [const_1_16_bytes] 

    1529. 

  1529. 

    1530. 

  1530. asm_blend_row_clipped_SSE2_loop:

    1531. 

  1531. 		movdqa xmm0, [esi]

    1532. 

  1532. 		movdqa xmm1, [esi+edx]

    1533. 

  1533. 		pavgb xmm0, xmm1

    1534. 

  1534. 		movdqa [esi+edi], xmm0

    1535. 

  1535. 		add esi, 16

    1536. 

  1536. 		dec	ecx

    1537. 

  1537. 		jnz asm_blend_row_clipped_SSE2_loop

    1538. 

  1538. 

    1539. 

  1539. 		test ebx,15

    1540. 

  1540. 		jz asm_blend_row_clipped_SSE2_end

    1541. 

  1541. 

    1542. 

  1542. 		mov ecx, ebx

    1543. 

  1543. 		xor ax, ax

    1544. 

  1544. 		xor bx, bx

    1545. 

  1545. asm_blend_row_clipped_SSE2_loop2:

    1546. 

  1546. 		mov al, [esi]

    1547. 

  1547. 		mov bl, [esi+edx]

    1548. 

  1548. 		add ax, bx

    1549. 

  1549. 		inc ax

    1550. 

  1550. 		shr ax, 1

    1551. 

  1551. 		mov [esi+edi], al

    1552. 

  1552. 		inc esi

    1553. 

  1553. 		dec	ecx

    1554. 

  1554. 		jnz asm_blend_row_clipped_SSE2_loop2

    1555. 

  1555. 

    1556. 

  1556. asm_blend_row_clipped_SSE2_end:

    1557. 

  1557. 	}

    1558. 

  1558. }

    1559. 

  1559. 

    1560. 

  1560. void DeinterlaceBlend(BYTE* dst, BYTE* src, DWORD rowbytes, DWORD h, DWORD dstpitch, DWORD srcpitch)

    1561. 

  1561. {

    1562. 

  1562. 	void (*asm_blend_row_clipped)(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch) = NULL;

    1563. 

  1563. 	void (*asm_blend_row)(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch) = NULL;

    1564. 

  1564. 

    1565. 

  1565. 	if((g_cpuid.m_flags & CCpuID::sse2) && !((DWORD)src&0xf) && !((DWORD)dst&0xf) && !(srcpitch&0xf))

    1566. 

  1566. 	{

    1567. 

  1567. 		asm_blend_row_clipped = asm_blend_row_clipped_SSE2;

    1568. 

  1568. 		asm_blend_row = asm_blend_row_SSE2;

    1569. 

  1569. 	}

    1570. 

  1570. 	else if(g_cpuid.m_flags & CCpuID::mmx)

    1571. 

  1571. 	{

    1572. 

  1572. 		asm_blend_row_clipped = asm_blend_row_clipped_MMX;

    1573. 

  1573. 		asm_blend_row = asm_blend_row_MMX;

    1574. 

  1574. 	}

    1575. 

  1575. 	else

    1576. 

  1576. 	{

    1577. 

  1577. 		asm_blend_row_clipped = asm_blend_row_clipped_c;

    1578. 

  1578. 		asm_blend_row = asm_blend_row_c;

    1579. 

  1579. 	}

    1580. 

  1580. 

    1581. 

  1581. 	if(!asm_blend_row_clipped)

    1582. 

  1582. 		return;

    1583. 

  1583. 

    1584. 

  1584. 	asm_blend_row_clipped(dst, src, rowbytes, srcpitch);

    1585. 

  1585. 

    1586. 

  1586. 	if((h -= 2) > 0) do

    1587. 

  1587. 	{

    1588. 

  1588. 		dst += dstpitch;

    1589. 

  1589. 		asm_blend_row(dst, src, rowbytes, srcpitch);

    1590. 

  1590.         src += srcpitch;

    1591. 

  1591. 	}

    1592. 

  1592. 	while(--h);

    1593. 

  1593. 

    1594. 

  1594. 	asm_blend_row_clipped(dst + dstpitch, src, rowbytes, srcpitch);

    1595. 

  1595. 

    1596. 

  1596. 	if(g_cpuid.m_flags & CCpuID::mmx)

    1597. 

  1597. 		__asm emms

    1598. 

  1598. }

    1599. 

  1599. 

    1600. 

  1600. void DeinterlaceBob(BYTE* dst, BYTE* src, DWORD rowbytes, DWORD h, DWORD dstpitch, DWORD srcpitch, bool topfield)

    1601. 

  1601. {

    1602. 

  1602. 	if(topfield)

    1603. 

  1603. 	{

    1604. 

  1604. 		BitBltFromRGBToRGB(rowbytes, h/2, dst, dstpitch*2, 8, src, srcpitch*2, 8);

    1605. 

  1605. 		AvgLines8(dst, h, dstpitch);

    1606. 

  1606. 	}

    1607. 

  1607. 	else

    1608. 

  1608. 	{

    1609. 

  1609. 		BitBltFromRGBToRGB(rowbytes, h/2, dst + dstpitch, dstpitch*2, 8, src + srcpitch, srcpitch*2, 8);

    1610. 

  1610. 		AvgLines8(dst + dstpitch, h-1, dstpitch);

    1611. 

  1611. 	}

    1612. 

  1612. }

    1613. 

  1613. 

    1614. 

  1614. void AvgLines8(BYTE* dst, DWORD h, DWORD pitch)

    1615. 

  1615. {

    1616. 

  1616. 	if(h <= 1) return;

    1617. 

  1617. 

    1618. 

  1618. 	BYTE* s = dst;

    1619. 

  1619. 	BYTE* d = dst + (h-2)*pitch;

    1620. 

  1620. 

    1621. 

  1621. 	for(; s < d; s += pitch*2)

    1622. 

  1622. 	{

    1623. 

  1623. 		BYTE* tmp = s;

    1624. 

  1624. 

    1625. 

  1625. 		if((g_cpuid.m_flags & CCpuID::sse2) && !((DWORD)tmp&0xf) && !((DWORD)pitch&0xf))

    1626. 

  1626. 		{

    1627. 

  1627. 			__asm

    1628. 

  1628. 			{

    1629. 

  1629. 				mov		esi, tmp

    1630. 

  1630. 				mov		ebx, pitch

    1631. 

  1631. 

    1632. 

  1632. 				mov		ecx, ebx

    1633. 

  1633. 				shr		ecx, 4

    1634. 

  1634. 

    1635. 

  1635. AvgLines8_sse2_loop:

    1636. 

  1636. 				movdqa	xmm0, [esi]

    1637. 

  1637. 				pavgb	xmm0, [esi+ebx*2]

    1638. 

  1638. 				movdqa	[esi+ebx], xmm0

    1639. 

  1639. 				add		esi, 16

    1640. 

  1640. 

    1641. 

  1641. 				dec		ecx

    1642. 

  1642. 				jnz		AvgLines8_sse2_loop

    1643. 

  1643. 

    1644. 

  1644. 				mov		tmp, esi

    1645. 

  1645. 			}

    1646. 

  1646. 

    1647. 

  1647. 			for(int i = pitch&7; i--; tmp++)

    1648. 

  1648. 			{

    1649. 

  1649. 				tmp[pitch] = (tmp[0] + tmp[pitch<<1] + 1) >> 1;

    1650. 

  1650. 			}

    1651. 

  1651. 		}

    1652. 

  1652. 		else if(g_cpuid.m_flags & CCpuID::mmx)

    1653. 

  1653. 		{

    1654. 

  1654. 			__asm

    1655. 

  1655. 			{

    1656. 

  1656. 				mov		esi, tmp

    1657. 

  1657. 				mov		ebx, pitch

    1658. 

  1658. 

    1659. 

  1659. 				mov		ecx, ebx

    1660. 

  1660. 				shr		ecx, 3

    1661. 

  1661. 

    1662. 

  1662. 				pxor	mm7, mm7

    1663. 

  1663. AvgLines8_mmx_loop:

    1664. 

  1664. 				movq	mm0, [esi]

    1665. 

  1665. 				movq	mm1, mm0

    1666. 

  1666. 

    1667. 

  1667. 				punpcklbw	mm0, mm7

    1668. 

  1668. 				punpckhbw	mm1, mm7

    1669. 

  1669. 

    1670. 

  1670. 				movq	mm2, [esi+ebx*2]

    1671. 

  1671. 				movq	mm3, mm2

    1672. 

  1672. 

    1673. 

  1673. 				punpcklbw	mm2, mm7

    1674. 

  1674. 				punpckhbw	mm3, mm7

    1675. 

  1675. 

    1676. 

  1676. 				paddw	mm0, mm2

    1677. 

  1677. 				psrlw	mm0, 1

    1678. 

  1678. 

    1679. 

  1679. 				paddw	mm1, mm3

    1680. 

  1680. 				psrlw	mm1, 1

    1681. 

  1681. 

    1682. 

  1682. 				packuswb	mm0, mm1

    1683. 

  1683. 

    1684. 

  1684. 				movq	[esi+ebx], mm0

    1685. 

  1685. 

    1686. 

  1686. 				lea		esi, [esi+8]

    1687. 

  1687. 

    1688. 

  1688. 				dec		ecx

    1689. 

  1689. 				jnz		AvgLines8_mmx_loop

    1690. 

  1690. 

    1691. 

  1691. 				mov		tmp, esi

    1692. 

  1692. 			}

    1693. 

  1693. 

    1694. 

  1694. 			for(int i = pitch&7; i--; tmp++)

    1695. 

  1695. 			{

    1696. 

  1696. 				tmp[pitch] = (tmp[0] + tmp[pitch<<1] + 1) >> 1;

    1697. 

  1697. 			}

    1698. 

  1698. 		}

    1699. 

  1699. 		else

    1700. 

  1700. 		{

    1701. 

  1701. 			for(int i = pitch; i--; tmp++)

    1702. 

  1702. 			{

    1703. 

  1703. 				tmp[pitch] = (tmp[0] + tmp[pitch<<1] + 1) >> 1;

    1704. 

  1704. 			}

    1705. 

  1705. 		}

    1706. 

  1706. 	}

    1707. 

  1707. 

    1708. 

  1708. 	if(!(h&1) && h >= 2)

    1709. 

  1709. 	{

    1710. 

  1710. 		dst += (h-2)*pitch;

    1711. 

  1711. 		memcpy_accel(dst + pitch, dst, pitch);

    1712. 

  1712. 	}

    1713. 

  1713. 

    1714. 

  1714. 	__asm emms;

    1715. 

  1715. }

    1716. 

  1716. 

    1717. 

  1717. void AvgLines555(BYTE* dst, DWORD h, DWORD pitch)

    1718. 

  1718. {

    1719. 

  1719. 	if(h <= 1) return;

    1720. 

  1720. 

    1721. 

  1721. 	unsigned __int64 __0x7c007c007c007c00 = 0x7c007c007c007c00;

    1722. 

  1722. 	unsigned __int64 __0x03e003e003e003e0 = 0x03e003e003e003e0;

    1723. 

  1723. 	unsigned __int64 __0x001f001f001f001f = 0x001f001f001f001f;

    1724. 

  1724. 

    1725. 

  1725. 	BYTE* s = dst;

    1726. 

  1726. 	BYTE* d = dst + (h-2)*pitch;

    1727. 

  1727. 

    1728. 

  1728. 	for(; s < d; s += pitch*2)

    1729. 

  1729. 	{

    1730. 

  1730. 		BYTE* tmp = s;

    1731. 

  1731. 

    1732. 

  1732. 		__asm

    1733. 

  1733. 		{

    1734. 

  1734. 			mov		esi, tmp

    1735. 

  1735. 			mov		ebx, pitch

    1736. 

  1736. 

    1737. 

  1737. 			mov		ecx, ebx

    1738. 

  1738. 			shr		ecx, 3

    1739. 

  1739. 

    1740. 

  1740. 			movq	mm6, __0x03e003e003e003e0

    1741. 

  1741. 			movq	mm7, __0x001f001f001f001f

    1742. 

  1742. 

    1743. 

  1743. AvgLines555_loop:

    1744. 

  1744. 			movq	mm0, [esi]

    1745. 

  1745. 			movq	mm1, mm0

    1746. 

  1746. 			movq	mm2, mm0

    1747. 

  1747. 

    1748. 

  1748. 			psrlw	mm0, 10				// red1 bits: mm0 = 001f001f001f001f

    1749. 

  1749. 			pand	mm1, mm6			// green1 bits: mm1 = 03e003e003e003e0

    1750. 

  1750. 			pand	mm2, mm7			// blue1 bits: mm2 = 001f001f001f001f

    1751. 

  1751. 

    1752. 

  1752. 			movq	mm3, [esi+ebx*2]

    1753. 

  1753. 			movq	mm4, mm3

    1754. 

  1754. 			movq	mm5, mm3

    1755. 

  1755. 

    1756. 

  1756. 			psrlw	mm3, 10				// red2 bits: mm3 = 001f001f001f001f

    1757. 

  1757. 			pand	mm4, mm6			// green2 bits: mm4 = 03e003e003e003e0

    1758. 

  1758. 			pand	mm5, mm7			// blue2 bits: mm5 = 001f001f001f001f

    1759. 

  1759. 

    1760. 

  1760. 			paddw	mm0, mm3

    1761. 

  1761. 			psrlw	mm0, 1				// (red1+red2)/2

    1762. 

  1762. 			psllw	mm0, 10				// red bits at 7c007c007c007c00

    1763. 

  1763. 

    1764. 

  1764. 			paddw	mm1, mm4

    1765. 

  1765. 			psrlw	mm1, 1				// (green1+green2)/2

    1766. 

  1766. 			pand	mm1, mm6			// green bits at 03e003e003e003e0

    1767. 

  1767. 

    1768. 

  1768. 			paddw	mm2, mm5

    1769. 

  1769. 			psrlw	mm2, 1				// (blue1+blue2)/2

    1770. 

  1770. 										// blue bits at 001f001f001f001f (no need to pand, lower bits were discareded)

    1771. 

  1771. 

    1772. 

  1772. 			por		mm0, mm1

    1773. 

  1773. 			por		mm0, mm2

    1774. 

  1774. 

    1775. 

  1775. 			movq	[esi+ebx], mm0

    1776. 

  1776. 

    1777. 

  1777. 			lea		esi, [esi+8]

    1778. 

  1778. 

    1779. 

  1779. 			dec		ecx

    1780. 

  1780. 			jnz		AvgLines555_loop

    1781. 

  1781. 

    1782. 

  1782. 			mov		tmp, esi

    1783. 

  1783. 		}

    1784. 

  1784. 

    1785. 

  1785. 		for(int i = (pitch&7)>>1; i--; tmp++)

    1786. 

  1786. 		{

    1787. 

  1787. 			tmp[pitch] = 

    1788. 

  1788. 				((((*tmp&0x7c00) + (tmp[pitch<<1]&0x7c00)) >> 1)&0x7c00)|

    1789. 

  1789. 				((((*tmp&0x03e0) + (tmp[pitch<<1]&0x03e0)) >> 1)&0x03e0)|

    1790. 

  1790. 				((((*tmp&0x001f) + (tmp[pitch<<1]&0x001f)) >> 1)&0x001f);

    1791. 

  1791. 		}

    1792. 

  1792. 	}

    1793. 

  1793. 

    1794. 

  1794. 	if(!(h&1) && h >= 2)

    1795. 

  1795. 	{

    1796. 

  1796. 		dst += (h-2)*pitch;

    1797. 

  1797. 		memcpy_accel(dst + pitch, dst, pitch);

    1798. 

  1798. 	}

    1799. 

  1799. 

    1800. 

  1800. 	__asm emms;

    1801. 

  1801. }

    1802. 

  1802. 

    1803. 

  1803. void AvgLines565(BYTE* dst, DWORD h, DWORD pitch)

    1804. 

  1804. {

    1805. 

  1805. 	if(h <= 1) return;

    1806. 

  1806. 

    1807. 

  1807. 	unsigned __int64 __0xf800f800f800f800 = 0xf800f800f800f800;

    1808. 

  1808. 	unsigned __int64 __0x07e007e007e007e0 = 0x07e007e007e007e0;

    1809. 

  1809. 	unsigned __int64 __0x001f001f001f001f = 0x001f001f001f001f;

    1810. 

  1810. 

    1811. 

  1811. 	BYTE* s = dst;

    1812. 

  1812. 	BYTE* d = dst + (h-2)*pitch;

    1813. 

  1813. 

    1814. 

  1814. 	for(; s < d; s += pitch*2)

    1815. 

  1815. 	{

    1816. 

  1816. 		WORD* tmp = (WORD*)s;

    1817. 

  1817. 

    1818. 

  1818. 		__asm

    1819. 

  1819. 		{

    1820. 

  1820. 			mov		esi, tmp

    1821. 

  1821. 			mov		ebx, pitch

    1822. 

  1822. 

    1823. 

  1823. 			mov		ecx, ebx

    1824. 

  1824. 			shr		ecx, 3

    1825. 

  1825. 

    1826. 

  1826. 			movq	mm6, __0x07e007e007e007e0

    1827. 

  1827. 			movq	mm7, __0x001f001f001f001f

    1828. 

  1828. 

    1829. 

  1829. AvgLines565_loop:

    1830. 

  1830. 			movq	mm0, [esi]

    1831. 

  1831. 			movq	mm1, mm0

    1832. 

  1832. 			movq	mm2, mm0

    1833. 

  1833. 

    1834. 

  1834. 			psrlw	mm0, 11				// red1 bits: mm0 = 001f001f001f001f

    1835. 

  1835. 			pand	mm1, mm6			// green1 bits: mm1 = 07e007e007e007e0

    1836. 

  1836. 			pand	mm2, mm7			// blue1 bits: mm2 = 001f001f001f001f

    1837. 

  1837. 

    1838. 

  1838. 			movq	mm3, [esi+ebx*2]

    1839. 

  1839. 			movq	mm4, mm3

    1840. 

  1840. 			movq	mm5, mm3

    1841. 

  1841. 

    1842. 

  1842. 			psrlw	mm3, 11				// red2 bits: mm3 = 001f001f001f001f

    1843. 

  1843. 			pand	mm4, mm6			// green2 bits: mm4 = 07e007e007e007e0

    1844. 

  1844. 			pand	mm5, mm7			// blue2 bits: mm5 = 001f001f001f001f

    1845. 

  1845. 

    1846. 

  1846. 			paddw	mm0, mm3

    1847. 

  1847. 			psrlw	mm0, 1				// (red1+red2)/2

    1848. 

  1848. 			psllw	mm0, 11				// red bits at f800f800f800f800

    1849. 

  1849. 

    1850. 

  1850. 			paddw	mm1, mm4

    1851. 

  1851. 			psrlw	mm1, 1				// (green1+green2)/2

    1852. 

  1852. 			pand	mm1, mm6			// green bits at 03e003e003e003e0

    1853. 

  1853. 

    1854. 

  1854. 			paddw	mm2, mm5

    1855. 

  1855. 			psrlw	mm2, 1				// (blue1+blue2)/2

    1856. 

  1856. 										// blue bits at 001f001f001f001f (no need to pand, lower bits were discareded)

    1857. 

  1857. 

    1858. 

  1858. 			por		mm0, mm1

    1859. 

  1859. 			por		mm0, mm2

    1860. 

  1860. 

    1861. 

  1861. 			movq	[esi+ebx], mm0

    1862. 

  1862. 

    1863. 

  1863. 			lea		esi, [esi+8]

    1864. 

  1864. 

    1865. 

  1865. 			dec		ecx

    1866. 

  1866. 			jnz		AvgLines565_loop

    1867. 

  1867. 

    1868. 

  1868. 			mov		tmp, esi

    1869. 

  1869. 		}

    1870. 

  1870. 

    1871. 

  1871. 		for(int i = (pitch&7)>>1; i--; tmp++)

    1872. 

  1872. 		{

    1873. 

  1873. 			tmp[pitch] = 

    1874. 

  1874. 				((((*tmp&0xf800) + (tmp[pitch<<1]&0xf800)) >> 1)&0xf800)|

    1875. 

  1875. 				((((*tmp&0x07e0) + (tmp[pitch<<1]&0x07e0)) >> 1)&0x07e0)|

    1876. 

  1876. 				((((*tmp&0x001f) + (tmp[pitch<<1]&0x001f)) >> 1)&0x001f);

    1877. 

  1877. 		}

    1878. 

  1878. 	}

    1879. 

  1879. 

    1880. 

  1880. 	if(!(h&1) && h >= 2)

    1881. 

  1881. 	{

    1882. 

  1882. 		dst += (h-2)*pitch;

    1883. 

  1883. 		memcpy_accel(dst + pitch, dst, pitch);

    1884. 

  1884. 	}

    1885. 

  1885. 

    1886. 

  1886. 	__asm emms;

    1887. 

  1887. }

    1888. 

  1888. 

    1889. 

  1889. extern "C" void mmx_YUY2toRGB24(const BYTE* src, BYTE* dst, const BYTE* src_end, int src_pitch, int row_size, bool rec709);

    1890. 

  1890. extern "C" void mmx_YUY2toRGB32(const BYTE* src, BYTE* dst, const BYTE* src_end, int src_pitch, int row_size, bool rec709);

    1891. 

  1891. 

    1892. 

  1892. 

    1893. 

  1893. bool BitBltFromYUY2ToRGB(int w, int h, BYTE* dst, int dstpitch, int dbpp, BYTE* src, int srcpitch)

    1894. 

  1894. {

    1895. 

  1895. 	void (* YUY2toRGB)(const BYTE* src, BYTE* dst, const BYTE* src_end, int src_pitch, int row_size, bool rec709) = NULL;

    1896. 

  1896. 

    1897. 

  1897. 	if(g_cpuid.m_flags & CCpuID::mmx)

    1898. 

  1898. 	{

    1899. 

  1899. 		YUY2toRGB = 

    1900. 

  1900. 			dbpp == 32 ? mmx_YUY2toRGB32 :

    1901. 

  1901. 			dbpp == 24 ? mmx_YUY2toRGB24 :

    1902. 

  1902. 			// dbpp == 16 ? mmx_YUY2toRGB16 : // TODO

    1903. 

  1903. 			NULL;

    1904. 

  1904. 	}

    1905. 

  1905. 	else

    1906. 

  1906. 	{

    1907. 

  1907. 		// TODO

    1908. 

  1908. 	}

    1909. 

  1909. 

    1910. 

  1910. 	if(!YUY2toRGB)

    1911. 

  1911. 	{

    1912. 

  1912. 		if(dbpp == 16){

    1913. 

  1913. 			BYTE* tmp = (BYTE*) malloc( w*h*5) ;

    1914. 

  1914. 			if(tmp){

    1915. 

  1915. 				mmx_YUY2toRGB32(src, tmp, src + h*srcpitch, srcpitch, w, false);

    1916. 

  1916. 				BitBltFromRGBToRGB(w, h, dst, w*2, 16, tmp, w*4, 32 );

    1917. 

  1917. 				free(tmp);

    1918. 

  1918. 			}

    1919. 

  1919. 			return(true);

    1920. 

  1920. 		}else{

    1921. 

  1921. 			return(false);

    1922. 

  1922. 		}

    1923. 

  1923. 	}

    1924. 

  1924. 

    1925. 

  1925. 	YUY2toRGB(src, dst, src + h*srcpitch, srcpitch, w, false);

    1926. 

  1926. 

    1927. 

  1927. 	return(true);

    1928. 

  1928. }

    1929. 

  1929. 

    1930. 

  1930. #endif //_WIN64

    1931. 

  1931.