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

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

多媒体编程

开发平台：

Visual C++

x86.cpp：源码内容
  1. /* 
  2.  * Copyright (C) 2003-2005 Gabest
  3.  * http://www.gabest.org
  4.  *
  5.  *  This Program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2, or (at your option)
  8.  *  any later version.
  9.  *   
  10.  *  This Program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13.  *  GNU General Public License for more details.
  14.  *   
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with GNU Make; see the file COPYING.  If not, write to
  17.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  18.  *  http://www.gnu.org/copyleft/gpl.html
  19.  *
  20.  */
  22. #include "stdafx.h"
  23. #include "GSTables.h"
  24. #include "x86.h"
  26. // unswizzling
  28. void __fastcall unSwizzleBlock32_c(BYTE* src, BYTE* dst, int dstpitch)
  29. {
  30. DWORD* s = &columnTable32[0][0];
  32. for(int j = 0; j < 8; j++, s += 8, dst += dstpitch)
  33. for(int i = 0; i < 8; i++)
  34. ((DWORD*)dst)[i] = ((DWORD*)src)[s[i]];
  35. }
  37. void __fastcall unSwizzleBlock16_c(BYTE* src, BYTE* dst, int dstpitch)
  38. {
  39. DWORD* s = &columnTable16[0][0];
  41. for(int j = 0; j < 8; j++, s += 16, dst += dstpitch)
  42. for(int i = 0; i < 16; i++)
  43. ((WORD*)dst)[i] = ((WORD*)src)[s[i]];
  44. }
  46. void __fastcall unSwizzleBlock8_c(BYTE* src, BYTE* dst, int dstpitch)
  47. {
  48. DWORD* s = &columnTable8[0][0];
  50. for(int j = 0; j < 16; j++, s += 16, dst += dstpitch)
  51. for(int i = 0; i < 16; i++)
  52. dst[i] = src[s[i]];
  53. }
  55. void __fastcall unSwizzleBlock4_c(BYTE* src, BYTE* dst, int dstpitch)
  56. {
  57. DWORD* s = &columnTable4[0][0];
  59. for(int j = 0; j < 16; j++, s += 32, dst += dstpitch)
  60. {
  61. for(int i = 0; i < 32; i++)
  62. {
  63. DWORD addr = s[i];
  64. BYTE c = (src[addr>>1] >> ((addr&1) << 2)) & 0x0f;
  65. int shift = (i&1) << 2;
  66. dst[i >> 1] = (dst[i >> 1] & (0xf0 >> shift)) | (c << shift);
  67. }
  68. }
  69. }
  71. void __fastcall unSwizzleBlock8HP_c(BYTE* src, BYTE* dst, int dstpitch)
  72. {
  73. DWORD* s = &columnTable32[0][0];
  75. for(int j = 0; j < 8; j++, s += 8, dst += dstpitch)
  76. for(int i = 0; i < 8; i++)
  77. dst[i] = (BYTE)(((DWORD*)src)[s[i]]>>24);
  78. }
  80. void __fastcall unSwizzleBlock4HLP_c(BYTE* src, BYTE* dst, int dstpitch)
  81. {
  82. DWORD* s = &columnTable32[0][0];
  84. for(int j = 0; j < 8; j++, s += 8, dst += dstpitch)
  85. for(int i = 0; i < 8; i++)
  86. dst[i] = (BYTE)(((DWORD*)src)[s[i]]>>24)&0xf;
  87. }
  89. void __fastcall unSwizzleBlock4HHP_c(BYTE* src, BYTE* dst, int dstpitch)
  90. {
  91. DWORD* s = &columnTable32[0][0];
  93. for(int j = 0; j < 8; j++, s += 8, dst += dstpitch)
  94. for(int i = 0; i < 8; i++)
  95. dst[i] = (BYTE)(((DWORD*)src)[s[i]]>>28);
  96. }
  98. void __fastcall unSwizzleBlock4P_c(BYTE* src, BYTE* dst, int dstpitch)
  99. {
  100. DWORD* s = &columnTable4[0][0];
  102. for(int j = 0; j < 16; j++, s += 32, dst += dstpitch)
  103. {
  104. for(int i = 0; i < 32; i++)
  105. {
  106. DWORD addr = s[i];
  107. dst[i] = (src[addr>>1] >> ((addr&1) << 2)) & 0x0f;
  108. }
  109. }
  110. }
  112. // swizzling
  114. void __fastcall SwizzleBlock32_c(BYTE* dst, BYTE* src, int srcpitch, DWORD WriteMask)
  115. {
  116. DWORD* d = &columnTable32[0][0];
  118. if(WriteMask == 0xffffffff)
  119. {
  120. for(int j = 0; j < 8; j++, d += 8, src += srcpitch)
  121. for(int i = 0; i < 8; i++)
  122. ((DWORD*)dst)[d[i]] = ((DWORD*)src)[i];
  123. }
  124. else
  125. {
  126. for(int j = 0; j < 8; j++, d += 8, src += srcpitch)
  127. for(int i = 0; i < 8; i++)
  128. ((DWORD*)dst)[d[i]] = (((DWORD*)dst)[d[i]] & ~WriteMask) | (((DWORD*)src)[i] & WriteMask);
  129. }
  130. }
  132. void __fastcall SwizzleBlock16_c(BYTE* dst, BYTE* src, int srcpitch)
  133. {
  134. DWORD* d = &columnTable16[0][0];
  136. for(int j = 0; j < 8; j++, d += 16, src += srcpitch)
  137. for(int i = 0; i < 16; i++)
  138. ((WORD*)dst)[d[i]] = ((WORD*)src)[i];
  139. }
  141. void __fastcall SwizzleBlock8_c(BYTE* dst, BYTE* src, int srcpitch)
  142. {
  143. DWORD* d = &columnTable8[0][0];
  145. for(int j = 0; j < 16; j++, d += 16, src += srcpitch)
  146. for(int i = 0; i < 16; i++)
  147. dst[d[i]] = src[i];
  148. }
  150. void __fastcall SwizzleBlock4_c(BYTE* dst, BYTE* src, int srcpitch)
  151. {
  152. DWORD* d = &columnTable4[0][0];
  154. for(int j = 0; j < 16; j++, d += 32, src += srcpitch)
  155. {
  156. for(int i = 0; i < 32; i++)
  157. {
  158. DWORD addr = d[i];
  159. BYTE c = (src[i>>1] >> ((i&1) << 2)) & 0x0f;
  160. DWORD shift = (addr&1) << 2;
  161. dst[addr >> 1] = (dst[addr >> 1] & (0xf0 >> shift)) | (c << shift);
  162. }
  163. }
  164. }
  166. // column swizzling (TODO: sse2)
  168. void __fastcall SwizzleColumn32_c(int y, BYTE* dst, BYTE* src, int srcpitch, DWORD WriteMask)
  169. {
  170. DWORD* d = &columnTable32[((y/2)&3)*2][0];
  172. if(WriteMask == 0xffffffff)
  173. {
  174. for(int j = 0; j < 2; j++, d += 8, src += srcpitch)
  175. for(int i = 0; i < 8; i++)
  176. ((DWORD*)dst)[d[i]] = ((DWORD*)src)[i];
  177. }
  178. else
  179. {
  180. for(int j = 0; j < 2; j++, d += 8, src += srcpitch)
  181. for(int i = 0; i < 8; i++)
  182. ((DWORD*)dst)[d[i]] = (((DWORD*)dst)[d[i]] & ~WriteMask) | (((DWORD*)src)[i] & WriteMask);
  183. }
  184. }
  186. void __fastcall SwizzleColumn16_c(int y, BYTE* dst, BYTE* src, int srcpitch)
  187. {
  188. DWORD* d = &columnTable16[((y/2)&3)*2][0];
  190. for(int j = 0; j < 2; j++, d += 16, src += srcpitch)
  191. for(int i = 0; i < 16; i++)
  192. ((WORD*)dst)[d[i]] = ((WORD*)src)[i];
  193. }
  195. void __fastcall SwizzleColumn8_c(int y, BYTE* dst, BYTE* src, int srcpitch)
  196. {
  197. DWORD* d = &columnTable8[((y/4)&3)*4][0];
  199. for(int j = 0; j < 4; j++, d += 16, src += srcpitch)
  200. for(int i = 0; i < 16; i++)
  201. dst[d[i]] = src[i];
  202. }
  204. void __fastcall SwizzleColumn4_c(int y, BYTE* dst, BYTE* src, int srcpitch)
  205. {
  206. DWORD* d = &columnTable4[y&(3<<2)][0]; // ((y/4)&3)*4
  208. for(int j = 0; j < 4; j++, d += 32, src += srcpitch)
  209. {
  210. for(int i = 0; i < 32; i++)
  211. {
  212. DWORD addr = d[i];
  213. BYTE c = (src[i>>1] >> ((i&1) << 2)) & 0x0f;
  214. DWORD shift = (addr&1) << 2;
  215. dst[addr >> 1] = (dst[addr >> 1] & (0xf0 >> shift)) | (c << shift);
  216. }
  217. }
  218. }
  220. //
  222. #if defined(_M_AMD64) || _M_IX86_FP >= 2
  224. static __m128i s_zero = _mm_setzero_si128();
  225. static __m128i s_bgrm = _mm_set1_epi32(0x00ffffff);
  226. static __m128i s_am = _mm_set1_epi32(0x00008000);
  227. static __m128i s_bm = _mm_set1_epi32(0x00007c00);
  228. static __m128i s_gm = _mm_set1_epi32(0x000003e0);
  229. static __m128i s_rm = _mm_set1_epi32(0x0000001f);
  231. void __fastcall ExpandBlock24_sse2(DWORD* src, DWORD* dst, int dstpitch, GIFRegTEXA* pTEXA)
  232. {
  233. __m128i TA0 = _mm_set1_epi32((DWORD)pTEXA->TA0 << 24);
  235. if(!pTEXA->AEM)
  236. {
  237. for(int j = 0; j < 8; j++, src += 8, dst += dstpitch>>2)
  238. {
  239. for(int i = 0; i < 8; i += 4)
  240. {
  241. __m128i c = _mm_load_si128((__m128i*)&src[i]);
  242. c = _mm_and_si128(c, s_bgrm);
  243. c = _mm_or_si128(c, TA0);
  244. _mm_store_si128((__m128i*)&dst[i], c);
  245. }
  246. }
  247. }
  248. else
  249. {
  250. for(int j = 0; j < 8; j++, src += 8, dst += dstpitch>>2)
  251. {
  252. for(int i = 0; i < 8; i += 4)
  253. {
  254. __m128i c = _mm_load_si128((__m128i*)&src[i]);
  255. c = _mm_and_si128(c, s_bgrm);
  256. __m128i a = _mm_andnot_si128(_mm_cmpeq_epi32(c, s_zero), TA0);
  257. c = _mm_or_si128(c, a);
  258. _mm_store_si128((__m128i*)&dst[i], c);
  259. }
  260. }
  261. }
  262. }
  264. void __fastcall ExpandBlock16_sse2(WORD* src, DWORD* dst, int dstpitch, GIFRegTEXA* pTEXA)
  265. {
  266. __m128i TA0 = _mm_set1_epi32((DWORD)pTEXA->TA0 << 24);
  267. __m128i TA1 = _mm_set1_epi32((DWORD)pTEXA->TA1 << 24);
  268. __m128i a, b, g, r;
  270. if(!pTEXA->AEM)
  271. {
  272. for(int j = 0; j < 8; j++, src += 16, dst += dstpitch>>2)
  273. {
  274. for(int i = 0; i < 16; i += 8)
  275. {
  276. __m128i c = _mm_load_si128((__m128i*)&src[i]);
  278. __m128i cl = _mm_unpacklo_epi16(c, s_zero);
  279. __m128i ch = _mm_unpackhi_epi16(c, s_zero);
  281. __m128i alm = _mm_cmplt_epi32(cl, s_am);
  282. __m128i ahm = _mm_cmplt_epi32(ch, s_am);
  284. // lo
  286. b = _mm_slli_epi32(_mm_and_si128(cl, s_bm), 9);
  287. g = _mm_slli_epi32(_mm_and_si128(cl, s_gm), 6);
  288. r = _mm_slli_epi32(_mm_and_si128(cl, s_rm), 3);
  289. a = _mm_or_si128(_mm_and_si128(alm, TA0), _mm_andnot_si128(alm, TA1));
  291. cl = _mm_or_si128(_mm_or_si128(a, b), _mm_or_si128(g, r));
  293. _mm_store_si128((__m128i*)&dst[i], cl);
  295. // hi
  297. b = _mm_slli_epi32(_mm_and_si128(ch, s_bm), 9);
  298. g = _mm_slli_epi32(_mm_and_si128(ch, s_gm), 6);
  299. r = _mm_slli_epi32(_mm_and_si128(ch, s_rm), 3);
  300. a = _mm_or_si128(_mm_and_si128(ahm, TA0), _mm_andnot_si128(ahm, TA1));
  302. ch = _mm_or_si128(_mm_or_si128(a, b), _mm_or_si128(g, r));
  304. _mm_store_si128((__m128i*)&dst[i+4], ch);
  305. }
  306. }
  307. }
  308. else
  309. {
  310. for(int j = 0; j < 8; j++, src += 16, dst += dstpitch>>2)
  311. {
  312. for(int i = 0; i < 16; i += 8)
  313. {
  314. __m128i c = _mm_load_si128((__m128i*)&src[i]);
  316. __m128i cl = _mm_unpacklo_epi16(c, s_zero);
  317. __m128i ch = _mm_unpackhi_epi16(c, s_zero);
  319. __m128i alm = _mm_cmplt_epi32(cl, s_am);
  320. __m128i ahm = _mm_cmplt_epi32(ch, s_am);
  322. __m128i trm = _mm_cmpeq_epi16(c, s_zero);
  323. __m128i trlm = _mm_unpacklo_epi16(trm, trm);
  324. __m128i trhm = _mm_unpackhi_epi16(trm, trm);
  326. // lo
  328. b = _mm_slli_epi32(_mm_and_si128(cl, s_bm), 9);
  329. g = _mm_slli_epi32(_mm_and_si128(cl, s_gm), 6);
  330. r = _mm_slli_epi32(_mm_and_si128(cl, s_rm), 3);
  331. a = _mm_or_si128(_mm_and_si128(alm, TA0), _mm_andnot_si128(alm, TA1));
  332. a = _mm_andnot_si128(trlm, a);
  334. cl = _mm_or_si128(_mm_or_si128(a, b), _mm_or_si128(g, r));
  336. _mm_store_si128((__m128i*)&dst[i], cl);
  338. // hi
  340. b = _mm_slli_epi32(_mm_and_si128(ch, s_bm), 9);
  341. g = _mm_slli_epi32(_mm_and_si128(ch, s_gm), 6);
  342. r = _mm_slli_epi32(_mm_and_si128(ch, s_rm), 3);
  343. a = _mm_or_si128(_mm_and_si128(ahm, TA0), _mm_andnot_si128(ahm, TA1));
  344. a = _mm_andnot_si128(trhm, a);
  346. ch = _mm_or_si128(_mm_or_si128(a, b), _mm_or_si128(g, r));
  348. _mm_store_si128((__m128i*)&dst[i+4], ch);
  349. }
  350. }
  351. }
  352. }
  354. void __fastcall Expand16_sse2(WORD* src, DWORD* dst, int w, GIFRegTEXA* pTEXA)
  355. {
  356. ASSERT(!(w&7));
  358. __m128i TA0 = _mm_set1_epi32((DWORD)pTEXA->TA0 << 24);
  359. __m128i TA1 = _mm_set1_epi32((DWORD)pTEXA->TA1 << 24);
  360. __m128i a, b, g, r;
  362. if(!pTEXA->AEM)
  363. {
  364. for(int i = 0; i < w; i += 8)
  365. {
  366. __m128i c = _mm_load_si128((__m128i*)&src[i]);
  368. __m128i cl = _mm_unpacklo_epi16(c, s_zero);
  369. __m128i ch = _mm_unpackhi_epi16(c, s_zero);
  371. __m128i alm = _mm_cmplt_epi32(cl, s_am);
  372. __m128i ahm = _mm_cmplt_epi32(ch, s_am);
  374. // lo
  376. b = _mm_slli_epi32(_mm_and_si128(cl, s_bm), 9);
  377. g = _mm_slli_epi32(_mm_and_si128(cl, s_gm), 6);
  378. r = _mm_slli_epi32(_mm_and_si128(cl, s_rm), 3);
  379. a = _mm_or_si128(_mm_and_si128(alm, TA0), _mm_andnot_si128(alm, TA1));
  381. cl = _mm_or_si128(_mm_or_si128(a, b), _mm_or_si128(g, r));
  383. _mm_store_si128((__m128i*)&dst[i], cl);
  385. // hi
  387. b = _mm_slli_epi32(_mm_and_si128(ch, s_bm), 9);
  388. g = _mm_slli_epi32(_mm_and_si128(ch, s_gm), 6);
  389. r = _mm_slli_epi32(_mm_and_si128(ch, s_rm), 3);
  390. a = _mm_or_si128(_mm_and_si128(ahm, TA0), _mm_andnot_si128(ahm, TA1));
  392. ch = _mm_or_si128(_mm_or_si128(a, b), _mm_or_si128(g, r));
  394. _mm_store_si128((__m128i*)&dst[i+4], ch);
  395. }
  396. }
  397. else
  398. {
  399. for(int i = 0; i < w; i += 8)
  400. {
  401. __m128i c = _mm_load_si128((__m128i*)&src[i]);
  403. __m128i cl = _mm_unpacklo_epi16(c, s_zero);
  404. __m128i ch = _mm_unpackhi_epi16(c, s_zero);
  406. __m128i alm = _mm_cmplt_epi32(cl, s_am);
  407. __m128i ahm = _mm_cmplt_epi32(ch, s_am);
  409. __m128i trm = _mm_cmpeq_epi16(c, s_zero);
  410. __m128i trlm = _mm_unpacklo_epi16(trm, trm);
  411. __m128i trhm = _mm_unpackhi_epi16(trm, trm);
  413. // lo
  415. b = _mm_slli_epi32(_mm_and_si128(cl, s_bm), 9);
  416. g = _mm_slli_epi32(_mm_and_si128(cl, s_gm), 6);
  417. r = _mm_slli_epi32(_mm_and_si128(cl, s_rm), 3);
  418. a = _mm_or_si128(_mm_and_si128(alm, TA0), _mm_andnot_si128(alm, TA1));
  419. a = _mm_andnot_si128(trlm, a);
  421. cl = _mm_or_si128(_mm_or_si128(a, b), _mm_or_si128(g, r));
  423. _mm_store_si128((__m128i*)&dst[i], cl);
  425. // hi
  427. b = _mm_slli_epi32(_mm_and_si128(ch, s_bm), 9);
  428. g = _mm_slli_epi32(_mm_and_si128(ch, s_gm), 6);
  429. r = _mm_slli_epi32(_mm_and_si128(ch, s_rm), 3);
  430. a = _mm_or_si128(_mm_and_si128(ahm, TA0), _mm_andnot_si128(ahm, TA1));
  431. a = _mm_andnot_si128(trhm, a);
  433. ch = _mm_or_si128(_mm_or_si128(a, b), _mm_or_si128(g, r));
  435. _mm_store_si128((__m128i*)&dst[i+4], ch);
  436. }
  437. }
  438. }
  440. #endif
  442. void __fastcall ExpandBlock24_c(DWORD* src, DWORD* dst, int dstpitch, GIFRegTEXA* pTEXA)
  443. {
  444. DWORD TA0 = (DWORD)pTEXA->TA0 << 24;
  446. if(!pTEXA->AEM)
  447. {
  448. for(int j = 0; j < 8; j++, src += 8, dst += dstpitch>>2)
  449. for(int i = 0; i < 8; i++)
  450. dst[i] = TA0 | (src[i]&0xffffff);
  451. }
  452. else
  453. {
  454. for(int j = 0; j < 8; j++, src += 8, dst += dstpitch>>2)
  455. for(int i = 0; i < 8; i++)
  456. dst[i] = ((src[i]&0xffffff) ? TA0 : 0) | (src[i]&0xffffff);
  457. }
  458. }
  460. void __fastcall ExpandBlock16_c(WORD* src, DWORD* dst, int dstpitch, GIFRegTEXA* pTEXA)
  461. {
  462. DWORD TA0 = (DWORD)pTEXA->TA0 << 24;
  463. DWORD TA1 = (DWORD)pTEXA->TA1 << 24;
  465. if(!pTEXA->AEM)
  466. {
  467. for(int j = 0; j < 8; j++, src += 16, dst += dstpitch>>2)
  468. for(int i = 0; i < 16; i++)
  469. dst[i] = ((src[i]&0x8000) ? TA1 : TA0)
  470. | ((src[i]&0x7c00) << 9) | ((src[i]&0x03e0) << 6) | ((src[i]&0x001f) << 3);
  471. }
  472. else
  473. {
  474. for(int j = 0; j < 8; j++, src += 16, dst += dstpitch>>2)
  475. for(int i = 0; i < 16; i++)
  476. dst[i] = ((src[i]&0x8000) ? TA1 : src[i] ? TA0 : 0)
  477. | ((src[i]&0x7c00) << 9) | ((src[i]&0x03e0) << 6) | ((src[i]&0x001f) << 3);
  478. }
  479. }
  481. void __fastcall Expand16_c(WORD* src, DWORD* dst, int w, GIFRegTEXA* pTEXA)
  482. {
  483. DWORD TA0 = (DWORD)pTEXA->TA0 << 24;
  484. DWORD TA1 = (DWORD)pTEXA->TA1 << 24;
  486. if(!pTEXA->AEM)
  487. {
  488. for(int i = 0; i < w; i++)
  489. dst[i] = ((src[i]&0x8000) ? TA1 : TA0)
  490. | ((src[i]&0x7c00) << 9) | ((src[i]&0x03e0) << 6) | ((src[i]&0x001f) << 3);
  491. }
  492. else
  493. {
  494. for(int i = 0; i < w; i++)
  495. dst[i] = ((src[i]&0x8000) ? TA1 : src[i] ? TA0 : 0)
  496. | ((src[i]&0x7c00) << 9) | ((src[i]&0x03e0) << 6) | ((src[i]&0x001f) << 3);
  497. }
  498. }
  500. //
  502. #if defined(_M_AMD64) || _M_IX86_FP >= 2
  504. static __m128 s_uvmin = _mm_set1_ps(+1e10);
  505. static __m128 s_uvmax = _mm_set1_ps(-1e10);
  507. void __fastcall UVMinMax_sse2(int nVertices, vertex_t* pVertices, uvmm_t* uv)
  508. {
  509. __m128 uvmin = s_uvmin;
  510. __m128 uvmax = s_uvmax;
  512. __m128* p = (__m128*)pVertices + 1;
  514. int i = 0;
  516. nVertices -= 5;
  518. for(; i < nVertices; i += 6) // 6 regs for loading, 2 regs for min/max
  519. {
  520. uvmin = _mm_min_ps(uvmin, p[(i+0)*2]);
  521. uvmax = _mm_max_ps(uvmax, p[(i+0)*2]);
  522. uvmin = _mm_min_ps(uvmin, p[(i+1)*2]);
  523. uvmax = _mm_max_ps(uvmax, p[(i+1)*2]);
  524. uvmin = _mm_min_ps(uvmin, p[(i+2)*2]);
  525. uvmax = _mm_max_ps(uvmax, p[(i+2)*2]);
  526. uvmin = _mm_min_ps(uvmin, p[(i+3)*2]);
  527. uvmax = _mm_max_ps(uvmax, p[(i+3)*2]);
  528. uvmin = _mm_min_ps(uvmin, p[(i+4)*2]);
  529. uvmax = _mm_max_ps(uvmax, p[(i+4)*2]);
  530. uvmin = _mm_min_ps(uvmin, p[(i+5)*2]);
  531. uvmax = _mm_max_ps(uvmax, p[(i+5)*2]);
  532. }
  534. nVertices += 5;
  536. for(; i < nVertices; i++)
  537. {
  538. uvmin = _mm_min_ps(uvmin, p[i*2]);
  539. uvmax = _mm_max_ps(uvmax, p[i*2]);
  540. }
  542. _mm_storeh_pi((__m64*)uv, uvmin);
  543. _mm_storeh_pi((__m64*)uv + 1, uvmax);
  544. }
  546. #endif
  548. void __fastcall UVMinMax_c(int nVertices, vertex_t* pVertices, uvmm_t* uv)
  549. {
  550. uv->umin = uv->vmin = +1e10;
  551. uv->umax = uv->vmax = -1e10;
  553. for(; nVertices-- > 0; pVertices++)
  554. {
  555. float u = pVertices->u;
  556. if(uv->umax < u) uv->umax = u;
  557. if(uv->umin > u) uv->umin = u;
  558. float v = pVertices->v;
  559. if(uv->vmax < v) uv->vmax = v;
  560. if(uv->vmin > v) uv->vmin = v;
  561. }
  562. }
  564. #if defined(_M_AMD64) || _M_IX86_FP >= 2
  566. static __m128i s_clut[64];
  568. void __fastcall WriteCLUT_T16_I8_CSM1_sse2(WORD* vm, WORD* clut)
  569. {
  570. __m128i* src = (__m128i*)vm;
  571. __m128i* dst = (__m128i*)clut;
  573. for(int i = 0; i < 32; i += 4)
  574. {
  575. __m128i r0 = _mm_load_si128(&src[i+0]);
  576. __m128i r1 = _mm_load_si128(&src[i+1]);
  577. __m128i r2 = _mm_load_si128(&src[i+2]);
  578. __m128i r3 = _mm_load_si128(&src[i+3]);
  580. __m128i r4 = _mm_unpacklo_epi16(r0, r1);
  581. __m128i r5 = _mm_unpackhi_epi16(r0, r1);
  582. __m128i r6 = _mm_unpacklo_epi16(r2, r3);
  583. __m128i r7 = _mm_unpackhi_epi16(r2, r3);
  585. r0 = _mm_unpacklo_epi32(r4, r6);
  586. r1 = _mm_unpackhi_epi32(r4, r6);
  587. r2 = _mm_unpacklo_epi32(r5, r7);
  588. r3 = _mm_unpackhi_epi32(r5, r7);
  590. r4 = _mm_unpacklo_epi16(r0, r1);
  591. r5 = _mm_unpackhi_epi16(r0, r1);
  592. r6 = _mm_unpacklo_epi16(r2, r3);
  593. r7 = _mm_unpackhi_epi16(r2, r3);
  595. _mm_store_si128(&dst[i+0], r4);
  596. _mm_store_si128(&dst[i+1], r6);
  597. _mm_store_si128(&dst[i+2], r5);
  598. _mm_store_si128(&dst[i+3], r7);
  599. }
  600. }
  602. void __fastcall WriteCLUT_T32_I8_CSM1_sse2(DWORD* vm, WORD* clut)
  603. {
  604. __m128i* src = (__m128i*)vm;
  605. __m128i* dst = s_clut;
  607. for(int j = 0; j < 64; j += 32, src += 32, dst += 32)
  608. {
  609. for(int i = 0; i < 16; i += 4)
  610. {
  611. __m128i r0 = _mm_load_si128(&src[i+0]);
  612. __m128i r1 = _mm_load_si128(&src[i+1]);
  613. __m128i r2 = _mm_load_si128(&src[i+2]);
  614. __m128i r3 = _mm_load_si128(&src[i+3]);
  616. _mm_store_si128(&dst[i*2+0], _mm_unpacklo_epi64(r0, r1));
  617. _mm_store_si128(&dst[i*2+1], _mm_unpacklo_epi64(r2, r3));
  618. _mm_store_si128(&dst[i*2+2], _mm_unpackhi_epi64(r0, r1));
  619. _mm_store_si128(&dst[i*2+3], _mm_unpackhi_epi64(r2, r3));
  621. __m128i r4 = _mm_load_si128(&src[i+0+16]);
  622. __m128i r5 = _mm_load_si128(&src[i+1+16]);
  623. __m128i r6 = _mm_load_si128(&src[i+2+16]);
  624. __m128i r7 = _mm_load_si128(&src[i+3+16]);
  626. _mm_store_si128(&dst[i*2+4], _mm_unpacklo_epi64(r4, r5));
  627. _mm_store_si128(&dst[i*2+5], _mm_unpacklo_epi64(r6, r7));
  628. _mm_store_si128(&dst[i*2+6], _mm_unpackhi_epi64(r4, r5));
  629. _mm_store_si128(&dst[i*2+7], _mm_unpackhi_epi64(r6, r7));
  630. }
  631. }
  633. for(int i = 0; i < 32; i++)
  634. {
  635. __m128i r0 = s_clut[i*2];
  636. __m128i r1 = s_clut[i*2+1];
  637. __m128i r2 = _mm_unpacklo_epi16(r0, r1);
  638. __m128i r3 = _mm_unpackhi_epi16(r0, r1);
  639. r0 = _mm_unpacklo_epi16(r2, r3);
  640. r1 = _mm_unpackhi_epi16(r2, r3);
  641. r2 = _mm_unpacklo_epi16(r0, r1);
  642. r3 = _mm_unpackhi_epi16(r0, r1);
  643. _mm_store_si128(&((__m128i*)clut)[i], r2);
  644. _mm_store_si128(&((__m128i*)clut)[i+32], r3);
  645. }
  646. }
  648. void __fastcall WriteCLUT_T16_I4_CSM1_sse2(WORD* vm, WORD* clut)
  649. {
  650. // TODO (probably not worth, _c is going to be just as fast)
  651. WriteCLUT_T16_I4_CSM1_c(vm, clut);
  652. }
  654. void __fastcall WriteCLUT_T32_I4_CSM1_sse2(DWORD* vm, WORD* clut)
  655. {
  656. __m128i* src = (__m128i*)vm;
  657. __m128i* dst = s_clut;
  659. __m128i r0 = _mm_load_si128(&src[0]);
  660. __m128i r1 = _mm_load_si128(&src[1]);
  661. __m128i r2 = _mm_load_si128(&src[2]);
  662. __m128i r3 = _mm_load_si128(&src[3]);
  664. _mm_store_si128(&dst[0], _mm_unpacklo_epi64(r0, r1));
  665. _mm_store_si128(&dst[1], _mm_unpacklo_epi64(r2, r3));
  666. _mm_store_si128(&dst[2], _mm_unpackhi_epi64(r0, r1));
  667. _mm_store_si128(&dst[3], _mm_unpackhi_epi64(r2, r3));
  669. for(int i = 0; i < 2; i++)
  670. {
  671. __m128i r0 = s_clut[i*2];
  672. __m128i r1 = s_clut[i*2+1];
  673. __m128i r2 = _mm_unpacklo_epi16(r0, r1);
  674. __m128i r3 = _mm_unpackhi_epi16(r0, r1);
  675. r0 = _mm_unpacklo_epi16(r2, r3);
  676. r1 = _mm_unpackhi_epi16(r2, r3);
  677. r2 = _mm_unpacklo_epi16(r0, r1);
  678. r3 = _mm_unpackhi_epi16(r0, r1);
  679. _mm_store_si128(&((__m128i*)clut)[i], r2);
  680. _mm_store_si128(&((__m128i*)clut)[i+32], r3);
  681. }
  682. }
  684. #endif
  686. void __fastcall WriteCLUT_T16_I8_CSM1_c(WORD* vm, WORD* clut)
  687. {
  688. const static DWORD map[] = 
  689. {
  690. 0, 2, 8, 10, 16, 18, 24, 26,
  691. 4, 6, 12, 14, 20, 22, 28, 30,
  692. 1, 3, 9, 11, 17, 19, 25, 27, 
  693. 5, 7, 13, 15, 21, 23, 29, 31
  694. };
  696. for(int j = 0; j < 8; j++, vm += 32, clut += 32) 
  697. {
  698. for(int i = 0; i < 32; i++)
  699. {
  700. clut[i] = vm[map[i]];
  701. }
  702. }
  703. }
  705. void __fastcall WriteCLUT_T32_I8_CSM1_c(DWORD* vm, WORD* clut)
  706. {
  707. const static DWORD map[] = 
  708. {
  709. 0, 1, 4, 5, 8, 9, 12, 13, 2, 3, 6, 7, 10, 11, 14, 15, 
  710. 64, 65, 68, 69, 72, 73, 76, 77, 66, 67, 70, 71, 74, 75, 78, 79, 
  711. 16, 17, 20, 21, 24, 25, 28, 29, 18, 19, 22, 23, 26, 27, 30, 31, 
  712. 80, 81, 84, 85, 88, 89, 92, 93, 82, 83, 86, 87, 90, 91, 94, 95, 
  713. 32, 33, 36, 37, 40, 41, 44, 45, 34, 35, 38, 39, 42, 43, 46, 47, 
  714. 96, 97, 100, 101, 104, 105, 108, 109, 98, 99, 102, 103, 106, 107, 110, 111, 
  715. 48, 49, 52, 53, 56, 57, 60, 61, 50, 51, 54, 55, 58, 59, 62, 63, 
  716. 112, 113, 116, 117, 120, 121, 124, 125, 114, 115, 118, 119, 122, 123, 126, 127
  717. };
  719. for(int j = 0; j < 2; j++, vm += 128, clut += 128)
  720. {
  721. for(int i = 0; i < 128; i++) 
  722. {
  723. DWORD dw = vm[map[i]];
  724. clut[i] = (WORD)(dw & 0xffff);
  725. clut[i+256] = (WORD)(dw >> 16);
  726. }
  727. }
  728. }
  730. void __fastcall WriteCLUT_T16_I4_CSM1_c(WORD* vm, WORD* clut)
  731. {
  732. const static DWORD map[] = 
  733. {
  734. 0, 2, 8, 10, 16, 18, 24, 26,
  735. 4, 6, 12, 14, 20, 22, 28, 30
  736. };
  738. for(int i = 0; i < 16; i++) 
  739. {
  740. clut[i] = vm[map[i]];
  741. }
  742. }
  744. void __fastcall WriteCLUT_T32_I4_CSM1_c(DWORD* vm, WORD* clut)
  745. {
  746. const static DWORD map[] = 
  747. {
  748. 0, 1, 4, 5, 8, 9, 12, 13,
  749. 2, 3, 6, 7, 10, 11, 14, 15
  750. };
  752. for(int i = 0; i < 16; i++) 
  753. {
  754. DWORD dw = vm[map[i]];
  755. clut[i] = (WORD)(dw & 0xffff);
  756. clut[i+256] = (WORD)(dw >> 16);
  757. }
  758. }
  760. //
  762. #if defined(_M_AMD64) || _M_IX86_FP >= 2
  764. extern "C" void __fastcall ReadCLUT32_T32_I8_sse2(WORD* src, DWORD* dst)
  765. {
  766. for(int i = 0; i < 256; i += 16)
  767. {
  768. ReadCLUT32_T32_I4_sse2(&src[i], &dst[i]); // going to be inlined nicely
  769. }
  770. }
  772. extern "C" void __fastcall ReadCLUT32_T32_I4_sse2(WORD* src, DWORD* dst)
  773. {
  774. __m128i r0 = ((__m128i*)src)[0];
  775. __m128i r1 = ((__m128i*)src)[1];
  776. __m128i r2 = ((__m128i*)src)[0+32];
  777. __m128i r3 = ((__m128i*)src)[1+32];
  778. _mm_store_si128(&((__m128i*)dst)[0], _mm_unpacklo_epi16(r0, r2));
  779. _mm_store_si128(&((__m128i*)dst)[1], _mm_unpackhi_epi16(r0, r2));
  780. _mm_store_si128(&((__m128i*)dst)[2], _mm_unpacklo_epi16(r1, r3));
  781. _mm_store_si128(&((__m128i*)dst)[3], _mm_unpackhi_epi16(r1, r3));
  782. }
  784. extern "C" void __fastcall ReadCLUT32_T16_I8_sse2(WORD* src, DWORD* dst)
  785. {
  786. for(int i = 0; i < 256; i += 16)
  787. {
  788. ReadCLUT32_T16_I4_sse2(&src[i], &dst[i]);
  789. }
  790. }
  792. extern "C" void __fastcall ReadCLUT32_T16_I4_sse2(WORD* src, DWORD* dst)
  793. {
  794. __m128i r0 = ((__m128i*)src)[0];
  795. __m128i r1 = ((__m128i*)src)[1];
  796. _mm_store_si128(&((__m128i*)dst)[0], _mm_unpacklo_epi16(r0, s_zero));
  797. _mm_store_si128(&((__m128i*)dst)[1], _mm_unpackhi_epi16(r0, s_zero));
  798. _mm_store_si128(&((__m128i*)dst)[2], _mm_unpacklo_epi16(r1, s_zero));
  799. _mm_store_si128(&((__m128i*)dst)[3], _mm_unpackhi_epi16(r1, s_zero));
  800. }
  802. #endif
  804. void __fastcall ReadCLUT32_T32_I8_c(WORD* src, DWORD* dst)
  805. {
  806. for(int i = 0; i < 256; i++)
  807. {
  808. dst[i] = ((DWORD)src[i+256] << 16) | src[i];
  809. }
  810. }
  812. void __fastcall ReadCLUT32_T32_I4_c(WORD* src, DWORD* dst)
  813. {
  814. for(int i = 0; i < 16; i++)
  815. {
  816. dst[i] = ((DWORD)src[i+256] << 16) | src[i];
  817. }
  818. }
  820. void __fastcall ReadCLUT32_T16_I8_c(WORD* src, DWORD* dst)
  821. {
  822. for(int i = 0; i < 256; i++)
  823. {
  824. dst[i] = (DWORD)src[i];
  825. }
  826. }
  828. void __fastcall ReadCLUT32_T16_I4_c(WORD* src, DWORD* dst)
  829. {
  830. for(int i = 0; i < 16; i++)
  831. {
  832. dst[i] = (DWORD)src[i];
  833. }
  834. }
  836. //