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

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

多媒体编程

开发平台：

Visual C++

GSLocalMemory.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.  * Special Notes: 
  21.  *
  22.  * Based on Page.c from GSSoft
  23.  * Copyright (C) 2002-2004 GSsoft Team
  24.  *
  25.  */
  26.  
  27. #include "StdAfx.h"
  28. #include "GSLocalMemory.h"
  29. #include "x86.h"
  31. //
  33. static class cdscd
  34. {
  35. CString toBin(UINT64 n, int bits)
  36. {
  37. CString str;
  38. while(bits-- > 0) str += n&(1i64<<bits) ? '1' : '0';
  39. return str;
  40. }
  41. public:
  43. cdscd()
  44. {
  45. return;
  46. /*
  47. union
  48. {
  49. struct {DWORD mant:23; DWORD exp:8; DWORD sign:1;} fi;
  50. DWORD i;
  51. float f;
  52. } nf, nf2;
  54. union
  55. {
  56. struct {UINT64 mant:52; UINT64 exp:11; UINT64 sign:1;} di;
  57. UINT64 i;
  58. double d;
  59. } nd;
  61. nd.di.mant = 0;
  62. nd.di.exp = 1023+128;
  63. nd.di.sign = 0;
  65. nd.d = pow(2.0, 128);
  67. TRACE(_T("%016I64x (%I64x:%I64x:%I64x), %fn"), nd.i, nd.di.sign, nd.di.exp, nd.di.mant, nd.d);
  68. */
  69. /*
  70. unsigned int control_word = 0;
  71. int err;
  73. // nd.d = 0;
  74. // TRACE(_T("%016I64x (%I64x:%I64x:%I64x), %fn"), nd.i, nd.di.sign, nd.di.exp, nd.di.mant, nd.d);
  76. // nf.f = nd.d;
  77. // TRACE(_T("%08x (%x:%x:%x), %fn"), nf.i, nf.fi.sign, nf.fi.exp, nf.fi.mant, nf.f);
  79. nf2.fi.sign = 0;
  80. nf2.fi.exp = 0x7f;
  81. nf2.fi.mant = 1;
  83. //err = _controlfp_s(&control_word, _RC_CHOP, _MCW_RC);
  85. nf.f = 0;
  87. for(int i = 0; i < 20; i++)
  88. {
  89. nd.d = (double)nf.f + (double)nf2.f;
  90. TRACE(_T("%016I64x (%I64x:%03I64x:%s), %fn"), nd.i, nd.di.sign, nd.di.exp, toBin(nd.di.mant, 52), nd.d);
  91. *((UINT64*)&nd.d) &= ~(1ui64<<(52-24));
  92. TRACE(_T("%016I64x (%I64x:%03I64x:%s), %fn"), nd.i, nd.di.sign, nd.di.exp, toBin(nd.di.mant, 52), nd.d);
  93. nf.f = (float)nd.d;
  94. TRACE(_T("%08x         (%x:%02x :%s                             ), %fn"), nf.i, nf.fi.sign, nf.fi.exp, toBin(nf.fi.mant, 23), nf.f);
  95. }
  96. */
  97. /*
  98. GSLocalMemory lm;
  100. for(int i = 0; i < 1024*1024; i++)
  101. ((DWORD*)lm.GetVM())[i] = rand()*0x12345678;
  104. GIFRegTEX0 TEX0;
  105. TEX0.TBP0 = 0;
  106. TEX0.TBW = 16;
  107. GIFRegTEXA TEXA;
  108. TEXA.AEM = 0; // 1
  110. __declspec(align(32)) static DWORD dst[1024*1024];
  112. for(int j = 0; j < 10; j++)
  113. {
  114. clock_t start = clock();
  116. for(int i = 0; i < 1000; i++)
  117. {
  118. lm.unSwizzleTexture32(CRect(0,0,1024,1024), (BYTE*)dst, 1024*4, TEX0, TEXA);
  119. }
  121. clock_t diff = clock() - start;
  123. CString str;
  124. str.Format(_T("%d"), diff);
  125. AfxMessageBox(str);
  126. }
  127. */
  128. /*
  129. __declspec(align(16)) static vertex_t v[100000];
  130. for(int i = 0; i < countof(v); i++)
  131. {
  132. v[i].u = 1.0f*rand() - RAND_MAX/2;
  133. v[i].v = 1.0f*rand() - RAND_MAX/2;
  134. }
  136. for(int j = 0; j < 10; j++)
  137. {
  138. clock_t start = clock();
  140. uvmm_t uvmm;
  141. for(int i = 0; i < 1000; i++)
  142. UVMinMax_sse2(countof(v), v, &uvmm);
  144. clock_t diff = clock() - start;
  146. CString str;
  147. str.Format(_T("%d, u %.2f %.2f, v %.2f %.2f"), diff, uvmm.umin, uvmm.umax, uvmm.vmin, uvmm.vmax);
  148. AfxMessageBox(str);
  149. }
  150. */
  151. /*
  152. GIFRegTEX0 TEX0;
  153. GIFRegTEXCLUT TEXCLUT;
  154. TEX0.PSM = PSM_PSMT8;
  155. TEX0.CLD = 1;
  156. TEX0.CSA = 0;
  157. TEX0.CPSM = PSM_PSMCT32; // PSM_PSMCT16S
  158. TEX0.CBP = 0;
  159. TEX0.CSM = 0; // 0
  160. TEXCLUT.CBW = 1;
  161. TEXCLUT.COU = 0;
  162. TEXCLUT.COV = 0;
  164. for(int j = 0; j < 10; j++)
  165. {
  166. clock_t start = clock();
  168. for(int i = 0; i < 10000000; i++)
  169. lm.WriteCLUT(TEX0, TEXCLUT);
  171. clock_t diff = clock() - start;
  173. CString str;
  174. str.Format(_T("%d"), diff);
  175. AfxMessageBox(str);
  176. }
  177. */
  178. /*
  179. GIFRegTEXA TEXA;
  180. TEXA.AEM = 0; // 1
  181. TEXA.TA0 = 0x7f;
  182. TEXA.TA1 = 0x80;
  184. int w = 1024*1024;
  186. WORD* src = (WORD*)lm.GetVM();
  187. DWORD* dst = (DWORD*)_aligned_malloc(w*4, 16);
  189. for(int j = 0; j < 10; j++)
  190. {
  191. clock_t start = clock();
  193. for(int i = 0; i < 1000; i++)
  194. {
  195. //Expand16_sse2(src, dst, w, &TEXA);
  196. Expand16_c(src, dst, w, &TEXA);
  197. }
  199. clock_t diff = clock() - start;
  201. CString str;
  202. str.Format(_T("%d"), diff);
  203. AfxMessageBox(str);
  204. }
  206. _aligned_free(dst);
  207. */
  208. }
  209. } sddscsd;
  211. //
  213. #define ASSERT_BLOCK(r, w, h) 
  214. ASSERT((r).Width() >= w && (r).Height() >= h && !((r).left&(w-1)) && !((r).top&(h-1)) && !((r).right&(w-1)) && !((r).bottom&(h-1))); 
  216. #if defined(_M_AMD64) || _M_IX86_FP >= 2
  217. #define BLOCK_PREFETCH(mem) 
  218. _mm_prefetch(&mem[16*0], _MM_HINT_T0); 
  219. _mm_prefetch(&mem[16*2], _MM_HINT_T0); 
  220. _mm_prefetch(&mem[16*4], _MM_HINT_T0); 
  221. _mm_prefetch(&mem[16*6], _MM_HINT_T0); 
  222. _mm_prefetch(&mem[16*8], _MM_HINT_T0); 
  223. _mm_prefetch(&mem[16*10], _MM_HINT_T0); 
  224. _mm_prefetch(&mem[16*12], _MM_HINT_T0); 
  225. _mm_prefetch(&mem[16*14], _MM_HINT_T0); 
  227. #define BLOCK_PREFETCH_32(x, y, w) {const char* next = (const char*)&m_vm32[blockAddress32(x + (w), y, TEX0.TBP0, TEX0.TBW)]; BLOCK_PREFETCH(next);}
  228. #define BLOCK_PREFETCH_16(x, y, w) {const char* next = (const char*)&m_vm16[blockAddress16(x + (w), y, TEX0.TBP0, TEX0.TBW)]; BLOCK_PREFETCH(next);}
  229. #define BLOCK_PREFETCH_16S(x, y, w) {const char* next = (const char*)&m_vm16[blockAddress16S(x + (w), y, TEX0.TBP0, TEX0.TBW)]; BLOCK_PREFETCH(next);}
  230. #define BLOCK_PREFETCH_8(x, y, w) {const char* next = (const char*)&m_vm8[blockAddress8(x + (w), y, TEX0.TBP0, TEX0.TBW)]; BLOCK_PREFETCH(next);}
  231. #define BLOCK_PREFETCH_4(x, y, w) {const char* next = (const char*)&m_vm8[blockAddress4(x + (w), y, TEX0.TBP0, TEX0.TBW)>>1]; BLOCK_PREFETCH(next);}
  232. #else 
  233. #define BLOCK_PREFETCH_32(x, y, w)
  234. #define BLOCK_PREFETCH_16(x, y, w)
  235. #define BLOCK_PREFETCH_16S(x, y, w)
  236. #define BLOCK_PREFETCH_8(x, y, w)
  237. #define BLOCK_PREFETCH_4(x, y, w)
  238. #endif
  240. #define FOREACH_BLOCK_START(r, w, h, t) 
  241. for(int y = (r).top; y < (r).bottom; y += (h)) 
  242. {  ASSERT_BLOCK(r, w, h); 
  243. BYTE* ptr = dst + (y-(r).top)*dstpitch; 
  244. for(int x = (r).left; x < (r).right; x += (w)) 
  245. { 
  246. BLOCK_PREFETCH_##t##(x + (w), y, w) 
  248. #define FOREACH_BLOCK_END }}
  250. //
  252. DWORD GSLocalMemory::pageOffset32[32][32][64];
  253. DWORD GSLocalMemory::pageOffset32Z[32][32][64];
  254. DWORD GSLocalMemory::pageOffset16[32][64][64];
  255. DWORD GSLocalMemory::pageOffset16S[32][64][64];
  256. DWORD GSLocalMemory::pageOffset16Z[32][64][64];
  257. DWORD GSLocalMemory::pageOffset16SZ[32][64][64];
  258. DWORD GSLocalMemory::pageOffset8[32][64][128];
  259. DWORD GSLocalMemory::pageOffset4[32][128][128];
  261. int GSLocalMemory::rowOffset32[2048];
  262. int GSLocalMemory::rowOffset32Z[2048];
  263. int GSLocalMemory::rowOffset16[2048];
  264. int GSLocalMemory::rowOffset16S[2048];
  265. int GSLocalMemory::rowOffset16Z[2048];
  266. int GSLocalMemory::rowOffset16SZ[2048];
  267. int GSLocalMemory::rowOffset8[2][2048];
  268. int GSLocalMemory::rowOffset4[2][2048];
  270. //
  272. DWORD GSLocalMemory::m_xtbl[1024];
  273. DWORD GSLocalMemory::m_ytbl[1024]; 
  275. //
  277. GSLocalMemory::psmtbl_t GSLocalMemory::m_psmtbl[64];
  279. //
  281. GSLocalMemory::GSLocalMemory()
  282. : m_fCLUTMayBeDirty(true)
  283. {
  284. int len = 1024*1024*4*2; // *2 for safety...
  286. m_vm8 = (BYTE*)_aligned_malloc(len, 16);
  287. memset(m_vm8, 0, len);
  289. m_pCLUT = (WORD*)_aligned_malloc(256*2*sizeof(WORD)*2, 16);
  290. m_pCLUT32 = (DWORD*)_aligned_malloc(256*sizeof(DWORD), 16);
  291. m_pCLUT64 = (UINT64*)_aligned_malloc(256*sizeof(UINT64), 16);
  293. for(int bp = 0; bp < 32; bp++)
  294. {
  295. for(int y = 0; y < 32; y++) for(int x = 0; x < 64; x++)
  296. {
  297. pageOffset32[bp][y][x] = pixelAddressOrg32(x, y, bp, 0);
  298. pageOffset32Z[bp][y][x] = pixelAddressOrg32Z(x, y, bp, 0);
  299. }
  301. for(int y = 0; y < 64; y++) for(int x = 0; x < 64; x++) 
  302. {
  303. pageOffset16[bp][y][x] = pixelAddressOrg16(x, y, bp, 0);
  304. pageOffset16S[bp][y][x] = pixelAddressOrg16S(x, y, bp, 0);
  305. pageOffset16Z[bp][y][x] = pixelAddressOrg16Z(x, y, bp, 0);
  306. pageOffset16SZ[bp][y][x] = pixelAddressOrg16SZ(x, y, bp, 0);
  307. }
  309. for(int y = 0; y < 64; y++) for(int x = 0; x < 128; x++)
  310. {
  311. pageOffset8[bp][y][x] = pixelAddressOrg8(x, y, bp, 0);
  312. }
  314. for(int y = 0; y < 128; y++) for(int x = 0; x < 128; x++)
  315. {
  316. pageOffset4[bp][y][x] = pixelAddressOrg4(x, y, bp, 0);
  317. }
  318. }
  320. {
  321. for(int x = 0; x < countof(rowOffset32); x++)
  322. rowOffset32[x] = (int)pixelAddress32(x, 0, 0, 32) - (int)pixelAddress32(0, 0, 0, 32);
  324. for(int x = 0; x < countof(rowOffset32Z); x++)
  325. rowOffset32Z[x] = (int)pixelAddress32Z(x, 0, 0, 32) - (int)pixelAddress32Z(0, 0, 0, 32);
  327. for(int x = 0; x < countof(rowOffset16); x++)
  328. rowOffset16[x] = (int)pixelAddress16(x, 0, 0, 32) - (int)pixelAddress16(0, 0, 0, 32);
  330. for(int x = 0; x < countof(rowOffset16S); x++)
  331. rowOffset16S[x] = (int)pixelAddress16S(x, 0, 0, 32) - (int)pixelAddress16S(0, 0, 0, 32);
  333. for(int x = 0; x < countof(rowOffset16Z); x++)
  334. rowOffset16Z[x] = (int)pixelAddress16Z(x, 0, 0, 32) - (int)pixelAddress16Z(0, 0, 0, 32);
  336. for(int x = 0; x < countof(rowOffset16SZ); x++)
  337. rowOffset16SZ[x] = (int)pixelAddress16SZ(x, 0, 0, 32) - (int)pixelAddress16SZ(0, 0, 0, 32);
  339. for(int x = 0; x < countof(rowOffset8[0]); x++)
  340. rowOffset8[0][x] = (int)pixelAddress8(x, 0, 0, 32) - (int)pixelAddress8(0, 0, 0, 32),
  341. rowOffset8[1][x] = (int)pixelAddress8(x, 2, 0, 32) - (int)pixelAddress8(0, 2, 0, 32);
  343. for(int x = 0; x < countof(rowOffset4[0]); x++)
  344. rowOffset4[0][x] = (int)pixelAddress4(x, 0, 0, 32) - (int)pixelAddress4(0, 0, 0, 32),
  345. rowOffset4[1][x] = (int)pixelAddress4(x, 2, 0, 32) - (int)pixelAddress4(0, 2, 0, 32);
  346. }
  348. for(int i = 0; i < countof(m_psmtbl); i++)
  349. {
  350. m_psmtbl[i].pa = &GSLocalMemory::pixelAddress32;
  351. m_psmtbl[i].ba = &GSLocalMemory::blockAddress32;
  352. m_psmtbl[i].pga = &GSLocalMemory::pageAddress32;
  353. m_psmtbl[i].rp = &GSLocalMemory::readPixel32;
  354. m_psmtbl[i].rpa = &GSLocalMemory::readPixel32;
  355. m_psmtbl[i].wp = &GSLocalMemory::writePixel32;
  356. m_psmtbl[i].wpa = &GSLocalMemory::writePixel32;
  357. m_psmtbl[i].rt = m_psmtbl[i].rtNP = m_psmtbl[i].rtP = &GSLocalMemory::readTexel32;
  358. m_psmtbl[i].rta = &GSLocalMemory::readTexel32;
  359. m_psmtbl[i].wfa = &GSLocalMemory::writePixel32;
  360. m_psmtbl[i].st = &GSLocalMemory::SwizzleTexture32;
  361. m_psmtbl[i].ust = m_psmtbl[i].ustP = m_psmtbl[i].ustNP = &GSLocalMemory::unSwizzleTexture32;
  362. m_psmtbl[i].bpp = m_psmtbl[i].trbpp = 32;
  363. m_psmtbl[i].pal = 0;
  364. m_psmtbl[i].bs = CSize(8, 8);
  365. for(int j = 0; j < 8; j++) m_psmtbl[i].rowOffset[j] = rowOffset32;
  366. }
  368. m_psmtbl[PSM_PSMCT16].pa = &GSLocalMemory::pixelAddress16;
  369. m_psmtbl[PSM_PSMCT16S].pa = &GSLocalMemory::pixelAddress16S;
  370. m_psmtbl[PSM_PSMT8].pa = &GSLocalMemory::pixelAddress8;
  371. m_psmtbl[PSM_PSMT4].pa = &GSLocalMemory::pixelAddress4;
  372. m_psmtbl[PSM_PSMZ32].pa = &GSLocalMemory::pixelAddress32Z;
  373. m_psmtbl[PSM_PSMZ24].pa = &GSLocalMemory::pixelAddress32Z;
  374. m_psmtbl[PSM_PSMZ16].pa = &GSLocalMemory::pixelAddress16Z;
  375. m_psmtbl[PSM_PSMZ16S].pa = &GSLocalMemory::pixelAddress16SZ;
  377. m_psmtbl[PSM_PSMCT16].ba = &GSLocalMemory::blockAddress16;
  378. m_psmtbl[PSM_PSMCT16S].ba = &GSLocalMemory::blockAddress16S;
  379. m_psmtbl[PSM_PSMT8].ba = &GSLocalMemory::blockAddress8;
  380. m_psmtbl[PSM_PSMT4].ba = &GSLocalMemory::blockAddress4;
  381. m_psmtbl[PSM_PSMZ32].ba = &GSLocalMemory::blockAddress32Z;
  382. m_psmtbl[PSM_PSMZ24].ba = &GSLocalMemory::blockAddress32Z;
  383. m_psmtbl[PSM_PSMZ16].ba = &GSLocalMemory::blockAddress16Z;
  384. m_psmtbl[PSM_PSMZ16S].ba = &GSLocalMemory::blockAddress16SZ;
  386. m_psmtbl[PSM_PSMCT16].pga = &GSLocalMemory::pageAddress16;
  387. m_psmtbl[PSM_PSMCT16S].pga = &GSLocalMemory::pageAddress16;
  388. m_psmtbl[PSM_PSMZ16].pga = &GSLocalMemory::pageAddress16;
  389. m_psmtbl[PSM_PSMZ16S].pga = &GSLocalMemory::pageAddress16;
  390. m_psmtbl[PSM_PSMT8].pga = &GSLocalMemory::pageAddress8;
  391. m_psmtbl[PSM_PSMT4].pga = &GSLocalMemory::pageAddress4;
  393. m_psmtbl[PSM_PSMCT24].rp = &GSLocalMemory::readPixel24;
  394. m_psmtbl[PSM_PSMCT16].rp = &GSLocalMemory::readPixel16;
  395. m_psmtbl[PSM_PSMCT16S].rp = &GSLocalMemory::readPixel16S;
  396. m_psmtbl[PSM_PSMT8].rp = &GSLocalMemory::readPixel8;
  397. m_psmtbl[PSM_PSMT4].rp = &GSLocalMemory::readPixel4;
  398. m_psmtbl[PSM_PSMT8H].rp = &GSLocalMemory::readPixel8H;
  399. m_psmtbl[PSM_PSMT4HL].rp = &GSLocalMemory::readPixel4HL;
  400. m_psmtbl[PSM_PSMT4HH].rp = &GSLocalMemory::readPixel4HH;
  401. m_psmtbl[PSM_PSMZ32].rp = &GSLocalMemory::readPixel32Z;
  402. m_psmtbl[PSM_PSMZ24].rp = &GSLocalMemory::readPixel24Z;
  403. m_psmtbl[PSM_PSMZ16].rp = &GSLocalMemory::readPixel16Z;
  404. m_psmtbl[PSM_PSMZ16S].rp = &GSLocalMemory::readPixel16SZ;
  406. m_psmtbl[PSM_PSMCT24].rpa = &GSLocalMemory::readPixel24;
  407. m_psmtbl[PSM_PSMCT16].rpa = &GSLocalMemory::readPixel16;
  408. m_psmtbl[PSM_PSMCT16S].rpa = &GSLocalMemory::readPixel16S;
  409. m_psmtbl[PSM_PSMT8].rpa = &GSLocalMemory::readPixel8;
  410. m_psmtbl[PSM_PSMT4].rpa = &GSLocalMemory::readPixel4;
  411. m_psmtbl[PSM_PSMT8H].rpa = &GSLocalMemory::readPixel8H;
  412. m_psmtbl[PSM_PSMT4HL].rpa = &GSLocalMemory::readPixel4HL;
  413. m_psmtbl[PSM_PSMT4HH].rpa = &GSLocalMemory::readPixel4HH;
  414. m_psmtbl[PSM_PSMZ32].rpa = &GSLocalMemory::readPixel32Z;
  415. m_psmtbl[PSM_PSMZ24].rpa = &GSLocalMemory::readPixel24Z;
  416. m_psmtbl[PSM_PSMZ16].rpa = &GSLocalMemory::readPixel16Z;
  417. m_psmtbl[PSM_PSMZ16S].rpa = &GSLocalMemory::readPixel16SZ;
  419. m_psmtbl[PSM_PSMCT32].wp = &GSLocalMemory::writePixel32;
  420. m_psmtbl[PSM_PSMCT24].wp = &GSLocalMemory::writePixel24;
  421. m_psmtbl[PSM_PSMCT16].wp = &GSLocalMemory::writePixel16;
  422. m_psmtbl[PSM_PSMCT16S].wp = &GSLocalMemory::writePixel16S;
  423. m_psmtbl[PSM_PSMT8].wp = &GSLocalMemory::writePixel8;
  424. m_psmtbl[PSM_PSMT4].wp = &GSLocalMemory::writePixel4;
  425. m_psmtbl[PSM_PSMT8H].wp = &GSLocalMemory::writePixel8H;
  426. m_psmtbl[PSM_PSMT4HL].wp = &GSLocalMemory::writePixel4HL;
  427. m_psmtbl[PSM_PSMT4HH].wp = &GSLocalMemory::writePixel4HH;
  428. m_psmtbl[PSM_PSMZ32].wp = &GSLocalMemory::writePixel32Z;
  429. m_psmtbl[PSM_PSMZ24].wp = &GSLocalMemory::writePixel24Z;
  430. m_psmtbl[PSM_PSMZ16].wp = &GSLocalMemory::writePixel16Z;
  431. m_psmtbl[PSM_PSMZ16S].wp = &GSLocalMemory::writePixel16SZ;
  433. m_psmtbl[PSM_PSMCT32].wpa = &GSLocalMemory::writePixel32;
  434. m_psmtbl[PSM_PSMCT24].wpa = &GSLocalMemory::writePixel24;
  435. m_psmtbl[PSM_PSMCT16].wpa = &GSLocalMemory::writePixel16;
  436. m_psmtbl[PSM_PSMCT16S].wpa = &GSLocalMemory::writePixel16S;
  437. m_psmtbl[PSM_PSMT8].wpa = &GSLocalMemory::writePixel8;
  438. m_psmtbl[PSM_PSMT4].wpa = &GSLocalMemory::writePixel4;
  439. m_psmtbl[PSM_PSMT8H].wpa = &GSLocalMemory::writePixel8H;
  440. m_psmtbl[PSM_PSMT4HL].wpa = &GSLocalMemory::writePixel4HL;
  441. m_psmtbl[PSM_PSMT4HH].wpa = &GSLocalMemory::writePixel4HH;
  442. m_psmtbl[PSM_PSMZ32].wpa = &GSLocalMemory::writePixel32Z;
  443. m_psmtbl[PSM_PSMZ24].wpa = &GSLocalMemory::writePixel24Z;
  444. m_psmtbl[PSM_PSMZ16].wpa = &GSLocalMemory::writePixel16Z;
  445. m_psmtbl[PSM_PSMZ16S].wpa = &GSLocalMemory::writePixel16SZ;
  447. m_psmtbl[PSM_PSMCT24].rt = &GSLocalMemory::readTexel24;
  448. m_psmtbl[PSM_PSMCT16].rt = &GSLocalMemory::readTexel16;
  449. m_psmtbl[PSM_PSMCT16S].rt = &GSLocalMemory::readTexel16S;
  450. m_psmtbl[PSM_PSMT8].rt = &GSLocalMemory::readTexel8;
  451. m_psmtbl[PSM_PSMT4].rt = &GSLocalMemory::readTexel4;
  452. m_psmtbl[PSM_PSMT8H].rt = &GSLocalMemory::readTexel8H;
  453. m_psmtbl[PSM_PSMT4HL].rt = &GSLocalMemory::readTexel4HL;
  454. m_psmtbl[PSM_PSMT4HH].rt = &GSLocalMemory::readTexel4HH;
  456. m_psmtbl[PSM_PSMCT24].rta = &GSLocalMemory::readTexel24;
  457. m_psmtbl[PSM_PSMCT16].rta = &GSLocalMemory::readTexel16;
  458. m_psmtbl[PSM_PSMCT16S].rta = &GSLocalMemory::readTexel16S;
  459. m_psmtbl[PSM_PSMT8].rta = &GSLocalMemory::readTexel8;
  460. m_psmtbl[PSM_PSMT4].rta = &GSLocalMemory::readTexel4;
  461. m_psmtbl[PSM_PSMT8H].rta = &GSLocalMemory::readTexel8H;
  462. m_psmtbl[PSM_PSMT4HL].rta = &GSLocalMemory::readTexel4HL;
  463. m_psmtbl[PSM_PSMT4HH].rta = &GSLocalMemory::readTexel4HH;
  465. m_psmtbl[PSM_PSMCT24].wfa = &GSLocalMemory::writePixel24;
  466. m_psmtbl[PSM_PSMCT16].wfa = &GSLocalMemory::writeFrame16;
  467. m_psmtbl[PSM_PSMCT16S].wfa = &GSLocalMemory::writeFrame16S;
  469. m_psmtbl[PSM_PSMCT16].rtP = &GSLocalMemory::readTexel16P;
  470. m_psmtbl[PSM_PSMCT16S].rtP = &GSLocalMemory::readTexel16SP;
  471. m_psmtbl[PSM_PSMT8].rtP = &GSLocalMemory::readTexel8P;
  472. m_psmtbl[PSM_PSMT4].rtP = &GSLocalMemory::readTexel4P;
  473. m_psmtbl[PSM_PSMT8H].rtP = &GSLocalMemory::readTexel8HP;
  474. m_psmtbl[PSM_PSMT4HL].rtP = &GSLocalMemory::readTexel4HLP;
  475. m_psmtbl[PSM_PSMT4HH].rtP = &GSLocalMemory::readTexel4HHP;
  477. m_psmtbl[PSM_PSMCT16].rtNP = &GSLocalMemory::readTexel16P;
  478. m_psmtbl[PSM_PSMCT16S].rtNP = &GSLocalMemory::readTexel16SP;
  479. m_psmtbl[PSM_PSMT8].rtNP = &GSLocalMemory::readTexel8;
  480. m_psmtbl[PSM_PSMT4].rtNP = &GSLocalMemory::readTexel4;
  481. m_psmtbl[PSM_PSMT8H].rtNP = &GSLocalMemory::readTexel8H;
  482. m_psmtbl[PSM_PSMT4HL].rtNP = &GSLocalMemory::readTexel4HL;
  483. m_psmtbl[PSM_PSMT4HH].rtNP = &GSLocalMemory::readTexel4HH;
  485. m_psmtbl[PSM_PSMCT24].st = &GSLocalMemory::SwizzleTexture24;
  486. m_psmtbl[PSM_PSMCT16].st = &GSLocalMemory::SwizzleTexture16;
  487. m_psmtbl[PSM_PSMCT16S].st = &GSLocalMemory::SwizzleTexture16S;
  488. m_psmtbl[PSM_PSMT8].st = &GSLocalMemory::SwizzleTexture8;
  489. m_psmtbl[PSM_PSMT4].st = &GSLocalMemory::SwizzleTexture4;
  490. m_psmtbl[PSM_PSMT8H].st = &GSLocalMemory::SwizzleTexture8H;
  491. m_psmtbl[PSM_PSMT4HL].st = &GSLocalMemory::SwizzleTexture4HL;
  492. m_psmtbl[PSM_PSMT4HH].st = &GSLocalMemory::SwizzleTexture4HH;
  494. m_psmtbl[PSM_PSMCT24].ust = &GSLocalMemory::unSwizzleTexture24;
  495. m_psmtbl[PSM_PSMCT16].ust = &GSLocalMemory::unSwizzleTexture16;
  496. m_psmtbl[PSM_PSMCT16S].ust = &GSLocalMemory::unSwizzleTexture16S;
  497. m_psmtbl[PSM_PSMT8].ust = &GSLocalMemory::unSwizzleTexture8;
  498. m_psmtbl[PSM_PSMT4].ust = &GSLocalMemory::unSwizzleTexture4;
  499. m_psmtbl[PSM_PSMT8H].ust = &GSLocalMemory::unSwizzleTexture8H;
  500. m_psmtbl[PSM_PSMT4HL].ust = &GSLocalMemory::unSwizzleTexture4HL;
  501. m_psmtbl[PSM_PSMT4HH].ust = &GSLocalMemory::unSwizzleTexture4HH;
  503. m_psmtbl[PSM_PSMCT16].ustP = &GSLocalMemory::unSwizzleTexture16P;
  504. m_psmtbl[PSM_PSMCT16S].ustP = &GSLocalMemory::unSwizzleTexture16SP;
  505. m_psmtbl[PSM_PSMT8].ustP = &GSLocalMemory::unSwizzleTexture8P;
  506. m_psmtbl[PSM_PSMT4].ustP = &GSLocalMemory::unSwizzleTexture4P;
  507. m_psmtbl[PSM_PSMT8H].ustP = &GSLocalMemory::unSwizzleTexture8HP;
  508. m_psmtbl[PSM_PSMT4HL].ustP = &GSLocalMemory::unSwizzleTexture4HLP;
  509. m_psmtbl[PSM_PSMT4HH].ustP = &GSLocalMemory::unSwizzleTexture4HHP;
  511. m_psmtbl[PSM_PSMCT16].ustNP = &GSLocalMemory::unSwizzleTexture16P;
  512. m_psmtbl[PSM_PSMCT16S].ustNP = &GSLocalMemory::unSwizzleTexture16SP;
  513. m_psmtbl[PSM_PSMT8].ustNP = &GSLocalMemory::unSwizzleTexture8NP;
  514. m_psmtbl[PSM_PSMT4].ustNP = &GSLocalMemory::unSwizzleTexture4NP;
  515. m_psmtbl[PSM_PSMT8H].ustNP = &GSLocalMemory::unSwizzleTexture8HNP;
  516. m_psmtbl[PSM_PSMT4HL].ustNP = &GSLocalMemory::unSwizzleTexture4HLNP;
  517. m_psmtbl[PSM_PSMT4HH].ustNP = &GSLocalMemory::unSwizzleTexture4HHNP;
  519. m_psmtbl[PSM_PSMT8].pal = m_psmtbl[PSM_PSMT8H].pal = 256;
  520. m_psmtbl[PSM_PSMT4].pal = m_psmtbl[PSM_PSMT4HL].pal = m_psmtbl[PSM_PSMT4HH].pal = 16;
  522. m_psmtbl[PSM_PSMCT16].bpp = m_psmtbl[PSM_PSMCT16S].bpp = 16;
  523. m_psmtbl[PSM_PSMT8].bpp = 8;
  524. m_psmtbl[PSM_PSMT4].bpp = 4;
  525. m_psmtbl[PSM_PSMZ16].bpp = m_psmtbl[PSM_PSMZ16S].bpp = 16;
  527. m_psmtbl[PSM_PSMCT24].trbpp = 24;
  528. m_psmtbl[PSM_PSMCT16].trbpp = m_psmtbl[PSM_PSMCT16S].trbpp = 16;
  529. m_psmtbl[PSM_PSMT8].trbpp = m_psmtbl[PSM_PSMT8H].trbpp = 8;
  530. m_psmtbl[PSM_PSMT4].trbpp = m_psmtbl[PSM_PSMT4HL].trbpp = m_psmtbl[PSM_PSMT4HH].trbpp = 4;
  531. m_psmtbl[PSM_PSMZ24].trbpp = 24;
  532. m_psmtbl[PSM_PSMZ16].trbpp = m_psmtbl[PSM_PSMZ16S].trbpp = 16;
  534. m_psmtbl[PSM_PSMCT16].bs = m_psmtbl[PSM_PSMCT16S].bs = CSize(16, 8);
  535. m_psmtbl[PSM_PSMT8].bs = CSize(16, 16);
  536. m_psmtbl[PSM_PSMT4].bs = CSize(32, 32);
  537. m_psmtbl[PSM_PSMZ16].bs = m_psmtbl[PSM_PSMZ16S].bs = CSize(16, 8);
  539. for(int i = 0; i < 8; i++) m_psmtbl[PSM_PSMCT16].rowOffset[i] = rowOffset16;
  540. for(int i = 0; i < 8; i++) m_psmtbl[PSM_PSMCT16S].rowOffset[i] = rowOffset16S;
  541. for(int i = 0; i < 8; i++) m_psmtbl[PSM_PSMT8].rowOffset[i] = rowOffset8[((i+2)>>2)&1];
  542. for(int i = 0; i < 8; i++) m_psmtbl[PSM_PSMT4].rowOffset[i] = rowOffset4[((i+2)>>2)&1];
  543. for(int i = 0; i < 8; i++) m_psmtbl[PSM_PSMZ32].rowOffset[i] = rowOffset32Z;
  544. for(int i = 0; i < 8; i++) m_psmtbl[PSM_PSMZ24].rowOffset[i] = rowOffset32Z;
  545. for(int i = 0; i < 8; i++) m_psmtbl[PSM_PSMZ16].rowOffset[i] = rowOffset16Z;
  546. for(int i = 0; i < 8; i++) m_psmtbl[PSM_PSMZ16S].rowOffset[i] = rowOffset16SZ;
  549. #ifdef _OPENMP
  550. // need real cpus, with HT it is only going to be slower now
  551. omp_set_num_threads(omp_get_num_procs());
  552. #endif
  554. /*
  555. // return; 
  556. // omp_set_num_threads(2);
  557. //
  558. {
  559. int tmpsize = 1024*1024*2;
  560. BYTE* tmp1 = new BYTE[tmpsize];
  561. BYTE* tmp2 = new BYTE[tmpsize];
  563. for(int i = 0; i < 1024*1024; i++)
  564. ((DWORD*)GetVM())[i] = rand()*0x12345678;
  566. GIFRegTEX0 TEX0;
  567. TEX0.TBP0 = 0;
  568. TEX0.TBW = 16;
  569. GIFRegTEXA TEXA;
  570. TEXA.AEM = 0; // 1
  572. __declspec(align(32)) static DWORD dst[1024*1024];
  574. int nthreads[] = {1,2,4,8};
  575. for(int j = 0; j < countof(nthreads); j++)
  576. {
  577. omp_set_num_threads(nthreads[j]);
  579. clock_t start = clock();
  581. for(int i = 0; i < 1000; i++)
  582. {
  583. unSwizzleTexture32(CRect(0,0,1024,1024), (BYTE*)dst, 1024*4, TEX0, TEXA);
  584. // for(int k = 0; k < tmpsize; k++) tmp2[k] = tmp1[k];
  585. }
  587. clock_t diff = clock() - start;
  589. CString str;
  590. str.Format(_T("%d threads: %d ms"), nthreads[j], diff);
  591. AfxMessageBox(str);
  592. }
  594. omp_set_num_threads(2);
  596. delete [] tmp1;
  597. delete [] tmp2;
  598. }
  599. */
  600. }
  602. GSLocalMemory::~GSLocalMemory()
  603. {
  604. _aligned_free(m_vm8);
  605. _aligned_free(m_pCLUT);
  606. _aligned_free(m_pCLUT32);
  607. _aligned_free(m_pCLUT64);
  608. }
  610. ////////////////////
  612. void GSLocalMemory::RoundDown(CSize& s, CSize bs)
  613. {
  614. s.cx &= ~(bs.cx-1);
  615. s.cy &= ~(bs.cy-1);
  616. }
  618. void GSLocalMemory::RoundUp(CSize& s, CSize bs)
  619. {
  620. s.cx = (s.cx + (bs.cx-1)) & ~(bs.cx-1);
  621. s.cy = (s.cy + (bs.cy-1)) & ~(bs.cy-1);
  622. }
  624. ////////////////////
  626. DWORD __fastcall GSLocalMemory::pageAddress32(int x, int y, DWORD bp, DWORD bw)
  627. {
  628. return ((bp >> 5) + (y >> 5) * bw + (x >> 6)) << 11; 
  629. }
  631. DWORD __fastcall GSLocalMemory::pageAddress16(int x, int y, DWORD bp, DWORD bw)
  632. {
  633. return ((bp >> 5) + (y >> 6) * bw + (x >> 6)) << 12;
  634. }
  636. DWORD __fastcall GSLocalMemory::pageAddress8(int x, int y, DWORD bp, DWORD bw)
  637. {
  638. return ((bp >> 5) + (y >> 6) * ((bw+1)>>1) + (x >> 7)) << 13; 
  639. }
  641. DWORD __fastcall GSLocalMemory::pageAddress4(int x, int y, DWORD bp, DWORD bw)
  642. {
  643. return ((bp >> 5) + (y >> 7) * ((bw+1)>>1) + (x >> 7)) << 14;
  644. }
  646. ////////////////////
  648. DWORD __fastcall GSLocalMemory::blockAddress32(int x, int y, DWORD bp, DWORD bw)
  649. {
  650. DWORD page = bp + (y & ~0x1f) * bw + ((x >> 1) & ~0x1f);
  651. DWORD block = blockTable32[(y >> 3) & 3][(x >> 3) & 7];
  652. return (page + block) << 6;
  653. }
  655. DWORD __fastcall GSLocalMemory::blockAddress16(int x, int y, DWORD bp, DWORD bw)
  656. {
  657. DWORD page = bp + ((y >> 1) & ~0x1f) * bw + ((x >> 1) & ~0x1f); 
  658. DWORD block = blockTable16[(y >> 3) & 7][(x >> 4) & 3];
  659. return (page + block) << 7;
  660. }
  662. DWORD __fastcall GSLocalMemory::blockAddress16S(int x, int y, DWORD bp, DWORD bw)
  663. {
  664. DWORD page = bp + ((y >> 1) & ~0x1f) * bw + ((x >> 1) & ~0x1f); 
  665. DWORD block = blockTable16S[(y >> 3) & 7][(x >> 4) & 3];
  666. return (page + block) << 7;
  667. }
  669. DWORD __fastcall GSLocalMemory::blockAddress8(int x, int y, DWORD bp, DWORD bw)
  670. {
  671. DWORD page = bp + ((y >> 1) & ~0x1f) * ((bw+1)>>1) + ((x >> 2) & ~0x1f); 
  672. DWORD block = blockTable8[(y >> 4) & 3][(x >> 4) & 7];
  673. return (page + block) << 8;
  674. }
  676. DWORD __fastcall GSLocalMemory::blockAddress4(int x, int y, DWORD bp, DWORD bw)
  677. {
  678. DWORD page = bp + ((y >> 2) & ~0x1f) * ((bw+1)>>1) + ((x >> 2) & ~0x1f); 
  679. DWORD block = blockTable4[(y >> 4) & 7][(x >> 5) & 3];
  680. return (page + block) << 9;
  681. }
  683. DWORD __fastcall GSLocalMemory::blockAddress32Z(int x, int y, DWORD bp, DWORD bw)
  684. {
  685. DWORD page = bp + (y & ~0x1f) * bw + ((x >> 1) & ~0x1f); 
  686. DWORD block = blockTable32Z[(y >> 3) & 3][(x >> 3) & 7];
  687. return (page + block) << 6;
  688. }
  690. DWORD __fastcall GSLocalMemory::blockAddress16Z(int x, int y, DWORD bp, DWORD bw)
  691. {
  692. DWORD page = bp + ((y >> 1) & ~0x1f) * bw + ((x >> 1) & ~0x1f); 
  693. DWORD block = blockTable16Z[(y >> 3) & 7][(x >> 4) & 3];
  694. return (page + block) << 7;
  695. }
  697. DWORD __fastcall GSLocalMemory::blockAddress16SZ(int x, int y, DWORD bp, DWORD bw)
  698. {
  699. DWORD page = bp + ((y >> 1) & ~0x1f) * bw + ((x >> 1) & ~0x1f); 
  700. DWORD block = blockTable16SZ[(y >> 3) & 7][(x >> 4) & 3];
  701. return (page + block) << 7;
  702. }
  704. ////////////////////
  706. DWORD __fastcall GSLocalMemory::pixelAddressOrg32(int x, int y, DWORD bp, DWORD bw)
  707. {
  708. // DWORD page = (bp >> 5) + (y >> 5) * bw + (x >> 6); 
  709. // DWORD block = (bp & 0x1f) + blockTable32[(y >> 3) & 3][(x >> 3) & 7];
  710. // DWORD word = (((page << 5) + block) << 6) + columnTable32[y & 7][x & 7];
  711. DWORD page = bp + (y & ~0x1f) * bw + ((x >> 1) & ~0x1f);
  712. DWORD block = blockTable32[(y >> 3) & 3][(x >> 3) & 7];
  713. DWORD word = ((page + block) << 6) + columnTable32[y & 7][x & 7];
  714. ASSERT(word < 1024*1024);
  715. return word;
  716. }
  718. DWORD __fastcall GSLocalMemory::pixelAddressOrg16(int x, int y, DWORD bp, DWORD bw)
  719. {
  720. // DWORD page = (bp >> 5) + (y >> 6) * bw + (x >> 6); 
  721. // DWORD block = (bp & 0x1f) + blockTable16[(y >> 3) & 7][(x >> 4) & 3];
  722. // DWORD word = (((page << 5) + block) << 7) + columnTable16[y & 7][x & 15];
  723. DWORD page = bp + ((y >> 1) & ~0x1f) * bw + ((x >> 1) & ~0x1f); 
  724. DWORD block = blockTable16[(y >> 3) & 7][(x >> 4) & 3];
  725. DWORD word = ((page + block) << 7) + columnTable16[y & 7][x & 15];
  726. ASSERT(word < 1024*1024*2);
  727. return word;
  728. }
  730. DWORD __fastcall GSLocalMemory::pixelAddressOrg16S(int x, int y, DWORD bp, DWORD bw)
  731. {
  732. // DWORD page = (bp >> 5) + (y >> 6) * bw + (x >> 6); 
  733. // DWORD block = (bp & 0x1f) + blockTable16S[(y >> 3) & 7][(x >> 4) & 3];
  734. // DWORD word = (((page << 5) + block) << 7) + columnTable16[y & 7][x & 15];
  735. DWORD page = bp + ((y >> 1) & ~0x1f) * bw + ((x >> 1) & ~0x1f); 
  736. DWORD block = blockTable16S[(y >> 3) & 7][(x >> 4) & 3];
  737. DWORD word = ((page + block) << 7) + columnTable16[y & 7][x & 15];
  738. ASSERT(word < 1024*1024*2);
  739. return word;
  740. }
  742. DWORD __fastcall GSLocalMemory::pixelAddressOrg8(int x, int y, DWORD bp, DWORD bw)
  743. {
  744. // DWORD page = (bp >> 5) + (y >> 6) * ((bw+1)>>1) + (x >> 7); 
  745. // DWORD block = (bp & 0x1f) + blockTable8[(y >> 4) & 3][(x >> 4) & 7];
  746. // DWORD word = (((page << 5) + block) << 8) + columnTable8[y & 15][x & 15];
  747. DWORD page = bp + ((y >> 1) & ~0x1f) * ((bw+1)>>1) + ((x >> 2) & ~0x1f); 
  748. DWORD block = blockTable8[(y >> 4) & 3][(x >> 4) & 7];
  749. DWORD word = ((page + block) << 8) + columnTable8[y & 15][x & 15];
  750. // ASSERT(word < 1024*1024*4);
  751. return word;
  752. }
  754. DWORD __fastcall GSLocalMemory::pixelAddressOrg4(int x, int y, DWORD bp, DWORD bw)
  755. {
  756. // DWORD page = (bp >> 5) + (y >> 7) * ((bw+1)>>1) + (x >> 7);
  757. // DWORD block = (bp & 0x1f) + blockTable4[(y >> 4) & 7][(x >> 5) & 3];
  758. // DWORD word = (((page << 5) + block) << 9) + columnTable4[y & 15][x & 31];
  759. DWORD page = bp + ((y >> 2) & ~0x1f) * ((bw+1)>>1) + ((x >> 2) & ~0x1f); 
  760. DWORD block = blockTable4[(y >> 4) & 7][(x >> 5) & 3];
  761. DWORD word = ((page + block) << 9) + columnTable4[y & 15][x & 31];
  762. ASSERT(word < 1024*1024*8);
  763. return word;
  764. }
  766. DWORD __fastcall GSLocalMemory::pixelAddressOrg32Z(int x, int y, DWORD bp, DWORD bw)
  767. {
  768. // DWORD page = (bp >> 5) + (y >> 5) * bw + (x >> 6); 
  769. // DWORD block = (bp & 0x1f) + blockTable32Z[(y >> 3) & 3][(x >> 3) & 7];
  770. // DWORD word = (((page << 5) + block) << 6) + ((y & 7) << 3) + (x & 7);
  771. DWORD page = bp + (y & ~0x1f) * bw + ((x >> 1) & ~0x1f); 
  772. DWORD block = blockTable32Z[(y >> 3) & 3][(x >> 3) & 7];
  773. DWORD word = ((page + block) << 6) + ((y & 7) << 3) + (x & 7);
  774. ASSERT(word < 1024*1024);
  775. return word;
  776. }
  778. DWORD __fastcall GSLocalMemory::pixelAddressOrg16Z(int x, int y, DWORD bp, DWORD bw)
  779. {
  780. // DWORD page = (bp >> 5) + (y >> 6) * bw + (x >> 6); 
  781. // DWORD block = (bp & 0x1f) + blockTable16Z[(y >> 3) & 7][(x >> 4) & 3];
  782. // DWORD word = (((page << 5) + block) << 7) + ((y & 7) << 4) + (x & 15);
  783. DWORD page = bp + ((y >> 1) & ~0x1f) * bw + ((x >> 1) & ~0x1f); 
  784. DWORD block = blockTable16Z[(y >> 3) & 7][(x >> 4) & 3];
  785. DWORD word = ((page + block) << 7) + ((y & 7) << 4) + (x & 15);
  786. ASSERT(word < 1024*1024*2);
  787. return word;
  788. }
  790. DWORD __fastcall GSLocalMemory::pixelAddressOrg16SZ(int x, int y, DWORD bp, DWORD bw)
  791. {
  792. // DWORD page = (bp >> 5) + (y >> 6) * bw + (x >> 6); 
  793. // DWORD block = (bp & 0x1f) + blockTable16SZ[(y >> 3) & 7][(x >> 4) & 3];
  794. // DWORD word = (((page << 5) + block) << 7) + ((y & 7) << 4) + (x & 15);
  795. DWORD page = bp + ((y >> 1) & ~0x1f) * bw + ((x >> 1) & ~0x1f); 
  796. DWORD block = blockTable16SZ[(y >> 3) & 7][(x >> 4) & 3];
  797. DWORD word = ((page + block) << 7) + ((y & 7) << 4) + (x & 15);
  798. ASSERT(word < 1024*1024*2);
  799. return word;
  800. }
  802. ////////////////////
  804. DWORD __fastcall GSLocalMemory::pixelAddress32(int x, int y, DWORD bp, DWORD bw)
  805. {
  806. DWORD page = (bp >> 5) + (y >> 5) * bw + (x >> 6); 
  807. DWORD word = (page << 11) + pageOffset32[bp & 0x1f][y & 0x1f][x & 0x3f];
  808. ASSERT(word < 1024*1024);
  809. return word;
  810. }
  812. DWORD __fastcall GSLocalMemory::pixelAddress16(int x, int y, DWORD bp, DWORD bw)
  813. {
  814. DWORD page = (bp >> 5) + (y >> 6) * bw + (x >> 6); 
  815. DWORD word = (page << 12) + pageOffset16[bp & 0x1f][y & 0x3f][x & 0x3f];
  816. ASSERT(word < 1024*1024*2);
  817. return word;
  818. }
  820. DWORD __fastcall GSLocalMemory::pixelAddress16S(int x, int y, DWORD bp, DWORD bw)
  821. {
  822. DWORD page = (bp >> 5) + (y >> 6) * bw + (x >> 6); 
  823. DWORD word = (page << 12) + pageOffset16S[bp & 0x1f][y & 0x3f][x & 0x3f];
  824. ASSERT(word < 1024*1024*2);
  825. return word;
  826. }
  828. DWORD __fastcall GSLocalMemory::pixelAddress8(int x, int y, DWORD bp, DWORD bw)
  829. {
  830. DWORD page = (bp >> 5) + (y >> 6) * ((bw+1)>>1) + (x >> 7); 
  831. DWORD word = (page << 13) + pageOffset8[bp & 0x1f][y & 0x3f][x & 0x7f];
  832. ASSERT(word < 1024*1024*4);
  833. return word;
  834. }
  836. DWORD __fastcall GSLocalMemory::pixelAddress4(int x, int y, DWORD bp, DWORD bw)
  837. {
  838. DWORD page = (bp >> 5) + (y >> 7) * ((bw+1)>>1) + (x >> 7);
  839. DWORD word = (page << 14) + pageOffset4[bp & 0x1f][y & 0x7f][x & 0x7f];
  840. ASSERT(word < 1024*1024*8);
  841. return word;
  842. }
  844. DWORD __fastcall GSLocalMemory::pixelAddress32Z(int x, int y, DWORD bp, DWORD bw)
  845. {
  846. DWORD page = (bp >> 5) + (y >> 5) * bw + (x >> 6); 
  847. DWORD word = (page << 11) + pageOffset32Z[bp & 0x1f][y & 0x1f][x & 0x3f];
  848. ASSERT(word < 1024*1024);
  849. return word;
  850. }
  852. DWORD __fastcall GSLocalMemory::pixelAddress16Z(int x, int y, DWORD bp, DWORD bw)
  853. {
  854. DWORD page = (bp >> 5) + (y >> 6) * bw + (x >> 6); 
  855. DWORD word = (page << 12) + pageOffset16Z[bp & 0x1f][y & 0x3f][x & 0x3f];
  856. ASSERT(word < 1024*1024*2);
  857. return word;
  858. }
  860. DWORD __fastcall GSLocalMemory::pixelAddress16SZ(int x, int y, DWORD bp, DWORD bw)
  861. {
  862. DWORD page = (bp >> 5) + (y >> 6) * bw + (x >> 6); 
  863. DWORD word = (page << 12) + pageOffset16SZ[bp & 0x1f][y & 0x3f][x & 0x3f];
  864. ASSERT(word < 1024*1024*2);
  865. return word;
  866. }
  868. ////////////////////
  870. void GSLocalMemory::writePixel32(int x, int y, DWORD c, DWORD bp, DWORD bw)
  871. {
  872. DWORD addr = pixelAddress32(x, y, bp, bw);
  873. m_vm32[addr] = c;
  874. }
  876. void GSLocalMemory::writePixel24(int x, int y, DWORD c, DWORD bp, DWORD bw)
  877. {
  878. DWORD addr = pixelAddress32(x, y, bp, bw);
  879. m_vm32[addr] = (m_vm32[addr] & 0xff000000) | (c & 0x00ffffff);
  880. }
  882. void GSLocalMemory::writePixel16(int x, int y, DWORD c, DWORD bp, DWORD bw)
  883. {
  884. DWORD addr = pixelAddress16(x, y, bp, bw);
  885. m_vm16[addr] = (WORD)c;
  886. }
  888. void GSLocalMemory::writePixel16S(int x, int y, DWORD c, DWORD bp, DWORD bw)
  889. {
  890. DWORD addr = pixelAddress16S(x, y, bp, bw);
  891. m_vm16[addr] = (WORD)c;
  892. }
  894. void GSLocalMemory::writePixel8(int x, int y, DWORD c, DWORD bp, DWORD bw)
  895. {
  896. DWORD addr = pixelAddress8(x, y, bp, bw);
  897. m_vm8[addr] = (BYTE)c;
  898. }
  900. void GSLocalMemory::writePixel8H(int x, int y, DWORD c, DWORD bp, DWORD bw)
  901. {
  902. DWORD addr = pixelAddress32(x, y, bp, bw);
  903. m_vm32[addr] = (m_vm32[addr] & 0x00ffffff) | (c << 24);
  904. }
  906. void GSLocalMemory::writePixel4(int x, int y, DWORD c, DWORD bp, DWORD bw)
  907. {
  908. DWORD addr = pixelAddress4(x, y, bp, bw);
  909. int shift = (addr&1) << 2; addr >>= 1;
  910. m_vm8[addr] = (BYTE)((m_vm8[addr] & (0xf0 >> shift)) | ((c & 0x0f) << shift));
  911. }
  913. void GSLocalMemory::writePixel4HL(int x, int y, DWORD c, DWORD bp, DWORD bw)
  914. {
  915. DWORD addr = pixelAddress32(x, y, bp, bw);
  916. m_vm32[addr] = (m_vm32[addr] & 0xf0ffffff) | ((c & 0x0f) << 24);
  917. }
  919. void GSLocalMemory::writePixel4HH(int x, int y, DWORD c, DWORD bp, DWORD bw)
  920. {
  921. DWORD addr = pixelAddress32(x, y, bp, bw);
  922. m_vm32[addr] = (m_vm32[addr] & 0x0fffffff) | ((c & 0x0f) << 28);
  923. }
  925. void GSLocalMemory::writePixel32Z(int x, int y, DWORD c, DWORD bp, DWORD bw)
  926. {
  927. DWORD addr = pixelAddress32Z(x, y, bp, bw);
  928. m_vm32[addr] = c;
  929. }
  931. void GSLocalMemory::writePixel24Z(int x, int y, DWORD c, DWORD bp, DWORD bw)
  932. {
  933. DWORD addr = pixelAddress32Z(x, y, bp, bw);
  934. m_vm32[addr] = (m_vm32[addr] & 0xff000000) | (c & 0x00ffffff);
  935. }
  937. void GSLocalMemory::writePixel16Z(int x, int y, DWORD c, DWORD bp, DWORD bw)
  938. {
  939. DWORD addr = pixelAddress16Z(x, y, bp, bw);
  940. m_vm16[addr] = (WORD)c;
  941. }
  943. void GSLocalMemory::writePixel16SZ(int x, int y, DWORD c, DWORD bp, DWORD bw)
  944. {
  945. DWORD addr = pixelAddress16SZ(x, y, bp, bw);
  946. m_vm16[addr] = (WORD)c;
  947. }
  949. ////////////////////
  951. void GSLocalMemory::writeFrame16(int x, int y, DWORD c, DWORD bp, DWORD bw)
  952. {
  953. c = ((c>>16)&0x8000)|((c>>9)&0x7c00)|((c>>6)&0x03e0)|((c>>3)&0x001f);
  954. writePixel16(x, y, c, bp, bw);
  955. }
  957. void GSLocalMemory::writeFrame16S(int x, int y, DWORD c, DWORD bp, DWORD bw)
  958. {
  959. c = ((c>>16)&0x8000)|((c>>9)&0x7c00)|((c>>6)&0x03e0)|((c>>3)&0x001f);
  960. writePixel16S(x, y, c, bp, bw);
  961. }
  963. ////////////////////
  965. DWORD GSLocalMemory::readPixel32(int x, int y, DWORD bp, DWORD bw)
  966. {
  967. return m_vm32[pixelAddress32(x, y, bp, bw)];
  968. }
  970. DWORD GSLocalMemory::readPixel24(int x, int y, DWORD bp, DWORD bw)
  971. {
  972. return m_vm32[pixelAddress32(x, y, bp, bw)] & 0x00ffffff;
  973. }
  975. DWORD GSLocalMemory::readPixel16(int x, int y, DWORD bp, DWORD bw)
  976. {
  977. return (DWORD)m_vm16[pixelAddress16(x, y, bp, bw)];
  978. }
  980. DWORD GSLocalMemory::readPixel16S(int x, int y, DWORD bp, DWORD bw)
  981. {
  982. return (DWORD)m_vm16[pixelAddress16S(x, y, bp, bw)];
  983. }
  985. DWORD GSLocalMemory::readPixel8(int x, int y, DWORD bp, DWORD bw)
  986. {
  987. return (DWORD)m_vm8[pixelAddress8(x, y, bp, bw)];
  988. }
  990. DWORD GSLocalMemory::readPixel8H(int x, int y, DWORD bp, DWORD bw)
  991. {
  992. return m_vm32[pixelAddress32(x, y, bp, bw)] >> 24;
  993. }
  995. DWORD GSLocalMemory::readPixel4(int x, int y, DWORD bp, DWORD bw)
  996. {
  997. DWORD addr = pixelAddress4(x, y, bp, bw);
  998. return (m_vm8[addr>>1] >> ((addr&1) << 2)) & 0x0f;
  999. }
  1001. DWORD GSLocalMemory::readPixel4HL(int x, int y, DWORD bp, DWORD bw)
  1002. {
  1003. return (m_vm32[pixelAddress32(x, y, bp, bw)] >> 24) & 0x0f;
  1004. }
  1006. DWORD GSLocalMemory::readPixel4HH(int x, int y, DWORD bp, DWORD bw)
  1007. {
  1008. return (m_vm32[pixelAddress32(x, y, bp, bw)] >> 28) & 0x0f;
  1009. }
  1011. DWORD GSLocalMemory::readPixel32Z(int x, int y, DWORD bp, DWORD bw)
  1012. {
  1013. return m_vm32[pixelAddress32Z(x, y, bp, bw)];
  1014. }
  1016. DWORD GSLocalMemory::readPixel24Z(int x, int y, DWORD bp, DWORD bw)
  1017. {
  1018. return m_vm32[pixelAddress32Z(x, y, bp, bw)] & 0x00ffffff;
  1019. }
  1021. DWORD GSLocalMemory::readPixel16Z(int x, int y, DWORD bp, DWORD bw)
  1022. {
  1023. return (DWORD)m_vm16[pixelAddress16Z(x, y, bp, bw)];
  1024. }
  1026. DWORD GSLocalMemory::readPixel16SZ(int x, int y, DWORD bp, DWORD bw)
  1027. {
  1028. return (DWORD)m_vm16[pixelAddress16SZ(x, y, bp, bw)];
  1029. }
  1031. ////////////////////
  1032. /*
  1033. void GSLocalMemory::writePixel32(DWORD addr, DWORD c)
  1034. {
  1035. m_vm32[addr] = c;
  1036. }
  1038. void GSLocalMemory::writePixel24(DWORD addr, DWORD c)
  1039. {
  1040. m_vm32[addr] = (m_vm32[addr] & 0xff000000) | (c & 0x00ffffff);
  1041. }
  1043. void GSLocalMemory::writePixel16(DWORD addr, DWORD c)
  1044. {
  1045. m_vm16[addr] = (WORD)c;
  1046. }
  1048. void GSLocalMemory::writePixel16S(DWORD addr, DWORD c)
  1049. {
  1050. m_vm16[addr] = (WORD)c;
  1051. }
  1053. void GSLocalMemory::writePixel8(DWORD addr, DWORD c)
  1054. {
  1055. m_vm8[addr] = (BYTE)c;
  1056. }
  1058. void GSLocalMemory::writePixel8H(DWORD addr, DWORD c)
  1059. {
  1060. m_vm32[addr] = (m_vm32[addr] & 0x00ffffff) | (c << 24);
  1061. }
  1063. void GSLocalMemory::writePixel4(DWORD addr, DWORD c)
  1064. {
  1065. int shift = (addr&1) << 2; addr >>= 1;
  1066. m_vm8[addr] = (BYTE)((m_vm8[addr] & (0xf0 >> shift)) | ((c & 0x0f) << shift));
  1067. }
  1069. void GSLocalMemory::writePixel4HL(DWORD addr, DWORD c)
  1070. {
  1071. m_vm32[addr] = (m_vm32[addr] & 0xf0ffffff) | ((c & 0x0f) << 24);
  1072. }
  1074. void GSLocalMemory::writePixel4HH(DWORD addr, DWORD c)
  1075. {
  1076. m_vm32[addr] = (m_vm32[addr] & 0x0fffffff) | ((c & 0x0f) << 28);
  1077. }
  1079. void GSLocalMemory::writePixel32Z(DWORD addr, DWORD c)
  1080. {
  1081. m_vm32[addr] = c;
  1082. }
  1084. void GSLocalMemory::writePixel24Z(DWORD addr, DWORD c)
  1085. {
  1086. m_vm32[addr] = (m_vm32[addr] & 0xff000000) | (c & 0x00ffffff);
  1087. }
  1089. void GSLocalMemory::writePixel16Z(DWORD addr, DWORD c)
  1090. {
  1091. m_vm16[addr] = (WORD)c;
  1092. }
  1094. void GSLocalMemory::writePixel16SZ(DWORD addr, DWORD c)
  1095. {
  1096. m_vm16[addr] = (WORD)c;
  1097. }
  1099. ////////////////////
  1101. void GSLocalMemory::writeFrame16(DWORD addr, DWORD c)
  1102. {
  1103. writePixel16(addr, ((c>>16)&0x8000)|((c>>9)&0x7c00)|((c>>6)&0x03e0)|((c>>3)&0x001f));
  1104. }
  1106. void GSLocalMemory::writeFrame16S(DWORD addr, DWORD c)
  1107. {
  1108. writePixel16S(addr, ((c>>16)&0x8000)|((c>>9)&0x7c00)|((c>>6)&0x03e0)|((c>>3)&0x001f));
  1109. }
  1111. ////////////////////
  1113. DWORD GSLocalMemory::readPixel32(DWORD addr)
  1114. {
  1115. return m_vm32[addr];
  1116. }
  1118. DWORD GSLocalMemory::readPixel24(DWORD addr)
  1119. {
  1120. return m_vm32[addr] & 0x00ffffff;
  1121. }
  1123. DWORD GSLocalMemory::readPixel16(DWORD addr)
  1124. {
  1125. return (DWORD)m_vm16[addr];
  1126. }
  1128. DWORD GSLocalMemory::readPixel16S(DWORD addr)
  1129. {
  1130. return (DWORD)m_vm16[addr];
  1131. }
  1133. DWORD GSLocalMemory::readPixel8(DWORD addr)
  1134. {
  1135. return (DWORD)m_vm8[addr];
  1136. }
  1138. DWORD GSLocalMemory::readPixel8H(DWORD addr)
  1139. {
  1140. return m_vm32[addr] >> 24;
  1141. }
  1143. DWORD GSLocalMemory::readPixel4(DWORD addr)
  1144. {
  1145. return (m_vm8[addr>>1] >> ((addr&1) << 2)) & 0x0f;
  1146. }
  1148. DWORD GSLocalMemory::readPixel4HL(DWORD addr)
  1149. {
  1150. return (m_vm32[addr] >> 24) & 0x0f;
  1151. }
  1153. DWORD GSLocalMemory::readPixel4HH(DWORD addr)
  1154. {
  1155. return (m_vm32[addr] >> 28) & 0x0f;
  1156. }
  1158. DWORD GSLocalMemory::readPixel32Z(DWORD addr)
  1159. {
  1160. return m_vm32[addr];
  1161. }
  1163. DWORD GSLocalMemory::readPixel24Z(DWORD addr)
  1164. {
  1165. return m_vm32[addr] & 0x00ffffff;
  1166. }
  1168. DWORD GSLocalMemory::readPixel16Z(DWORD addr)
  1169. {
  1170. return (DWORD)m_vm16[addr];
  1171. }
  1173. DWORD GSLocalMemory::readPixel16SZ(DWORD addr)
  1174. {
  1175. return (DWORD)m_vm16[addr];
  1176. }
  1177. */
  1178. ////////////////////
  1180. bool GSLocalMemory::FillRect(CRect& r, DWORD c, DWORD psm, DWORD fbp, DWORD fbw)
  1181. {
  1182. const psmtbl_t& tbl = m_psmtbl[psm];
  1184. writePixel wp = tbl.wp;
  1185. pixelAddress ba = tbl.ba;
  1187. int w = tbl.bs.cx;
  1188. int h = tbl.bs.cy;
  1189. int bpp = tbl.bpp;
  1191. int shift = 0;
  1193. switch(bpp)
  1194. {
  1195. case 32: shift = 0; break;
  1196. case 16: shift = 1; c = (c&0xffff)*0x00010001; break;
  1197. case 8: shift = 2; c = (c&0xff)*0x01010101; break;
  1198. case 4: shift = 3; c = (c&0xf)*0x11111111; break;
  1199. }
  1201. CRect clip((r.left+(w-1))&~(w-1), (r.top+(h-1))&~(h-1), r.right&~(w-1), r.bottom&~(h-1));
  1203. for(int y = r.top; y < clip.top; y++)
  1204. for(int x = r.left; x < r.right; x++)
  1205. (this->*wp)(x, y, c, fbp, fbw);
  1207. for(int y = clip.top; y < clip.bottom; y += h)
  1208. {
  1209. for(int ys = y, ye = y + h; ys < ye; ys++)
  1210. {
  1211. for(int x = r.left; x < clip.left; x++)
  1212. (this->*wp)(x, ys, c, fbp, fbw);
  1213. for(int x = clip.right; x < r.right; x++)
  1214. (this->*wp)(x, ys, c, fbp, fbw);
  1215. }
  1216. }
  1218. if(psm == PSM_PSMCT24 || psm == PSM_PSMZ24)
  1219. {
  1220. c &= 0x00ffffff;
  1221. for(int y = clip.top; y < clip.bottom; y += h)
  1222. {
  1223. for(int x = clip.left; x < clip.right; x += w)
  1224. {
  1225. DWORD* p = &m_vm32[ba(x, y, fbp, fbw)];
  1226. for(int i = 0; i < 64; i++)
  1227. p[i] = (p[i]&0xff000000) | c;
  1228. }
  1229. }
  1230. }
  1231. else
  1232. {
  1233. for(int y = clip.top; y < clip.bottom; y += h)
  1234. for(int x = clip.left; x < clip.right; x += w)
  1235. memsetd(&m_vm8[ba(x, y, fbp, fbw) << 2 >> shift], c, 64);
  1236. }
  1238. for(int y = clip.bottom; y < r.bottom; y++)
  1239. for(int x = r.left; x < r.right; x++)
  1240. (this->*wp)(x, y, c, fbp, fbw);
  1242. return(true);
  1243. }
  1245. ////////////////////
  1247. void GSLocalMemory::WriteCLUT(GIFRegTEX0 TEX0, GIFRegTEXCLUT TEXCLUT)
  1248. {
  1249. switch(TEX0.CLD)
  1250. {
  1251. default:
  1252. case 0: return;
  1253. case 1: break;
  1254. case 2: m_CBP[0] = TEX0.CBP; break;
  1255. case 3: m_CBP[1] = TEX0.CBP; break;
  1256. case 4: if(m_CBP[0] == TEX0.CBP) return; break;
  1257. case 5: if(m_CBP[1] == TEX0.CBP) return; break;
  1258. }
  1260. {
  1261. if(!m_fCLUTMayBeDirty && m_prevTEX0.i64 == TEX0.i64 && m_prevTEXCLUT.i64 == TEXCLUT.i64)
  1262. return;
  1264. m_prevTEX0 = TEX0;
  1265. m_prevTEXCLUT = TEXCLUT;
  1267. m_fCLUTMayBeDirty = false;
  1268. }
  1270. DWORD bp = TEX0.CBP;
  1271. DWORD bw = TEX0.CSM == 0 ? 1 : TEXCLUT.CBW;
  1273. WORD* pCLUT = m_pCLUT + (TEX0.CSA<<4);
  1275. // NOTE: TEX0.CPSM == PSM_PSMCT24 is non-standard, KH uses it
  1277. if(TEX0.CSM == 0)
  1278. {
  1279. if(TEX0.CPSM == PSM_PSMCT16 || TEX0.CPSM == PSM_PSMCT16S)
  1280. {
  1281. WORD* vm = &m_vm16[TEX0.CPSM == PSM_PSMCT16 ? blockAddress16(0, 0, bp, bw) : blockAddress16S(0, 0, bp, bw)];
  1283. if(TEX0.PSM == PSM_PSMT8 || TEX0.PSM == PSM_PSMT8H)
  1284. {
  1285. WriteCLUT_T16_I8_CSM1(vm, pCLUT);
  1286. }
  1287. else if(TEX0.PSM == PSM_PSMT4HH || TEX0.PSM == PSM_PSMT4HL || TEX0.PSM == PSM_PSMT4)
  1288. {
  1289. WriteCLUT_T16_I4_CSM1(vm, pCLUT);
  1290. }
  1291. }
  1292. else if(TEX0.CPSM == PSM_PSMCT32 || TEX0.CPSM == PSM_PSMCT24)
  1293. {
  1294. DWORD* vm = &m_vm32[blockAddress32(0, 0, bp, bw)];
  1296. if(TEX0.PSM == PSM_PSMT8 || TEX0.PSM == PSM_PSMT8H)
  1297. {
  1298. WriteCLUT_T32_I8_CSM1(vm, pCLUT);
  1299. }
  1300. else if(TEX0.PSM == PSM_PSMT4HH || TEX0.PSM == PSM_PSMT4HL || TEX0.PSM == PSM_PSMT4)
  1301. {
  1302. WriteCLUT_T32_I4_CSM1(vm, pCLUT);
  1303. }
  1304. }
  1305. }
  1306. else
  1307. {
  1308. readPixel rp = m_psmtbl[TEX0.CPSM].rp;
  1310. int nPaletteEntries = m_psmtbl[TEX0.PSM].pal;
  1312. ASSERT(nPaletteEntries == 0 || TEX0.CPSM == PSM_PSMCT16); // this is the only allowed format for CSM2, but we implement all of them, just in case...
  1314. if(TEX0.CPSM == PSM_PSMCT16 || TEX0.CPSM == PSM_PSMCT16S)
  1315. {
  1316. for(int i = 0; i < nPaletteEntries; i++)
  1317. {
  1318. pCLUT[i] = (WORD)(this->*rp)((TEXCLUT.COU<<4) + i, TEXCLUT.COV, bp, bw);
  1319. }
  1320. }
  1321. else if(TEX0.CPSM == PSM_PSMCT32 || TEX0.CPSM == PSM_PSMCT24)
  1322. {
  1323. for(int i = 0; i < nPaletteEntries; i++)
  1324. {
  1325. DWORD dw = (this->*rp)((TEXCLUT.COU<<4) + i, TEXCLUT.COV, bp, bw);
  1326. pCLUT[i] = (WORD)(dw & 0xffff);
  1327. pCLUT[i+256] = (WORD)(dw >> 16);
  1328. }
  1329. }
  1330. }
  1331. }
  1333. //
  1335. void GSLocalMemory::ReadCLUT(GIFRegTEX0 TEX0, GIFRegTEXA TEXA, DWORD* pCLUT32)
  1336. {
  1337. ASSERT(pCLUT32);
  1339. WORD* pCLUT = m_pCLUT + (TEX0.CSA<<4);
  1341. if(TEX0.CPSM == PSM_PSMCT32)
  1342. {
  1343. switch(TEX0.PSM)
  1344. {
  1345. case PSM_PSMT8:
  1346. case PSM_PSMT8H:
  1347. ReadCLUT32_T32_I8(pCLUT, pCLUT32);
  1348. break;
  1349. case PSM_PSMT4:
  1350. case PSM_PSMT4HL:
  1351. case PSM_PSMT4HH:
  1352. ReadCLUT32_T32_I4(pCLUT, pCLUT32);
  1353. break;
  1354. }
  1355. }
  1356. else if(TEX0.CPSM == PSM_PSMCT16 || TEX0.CPSM == PSM_PSMCT16S)
  1357. {
  1358. switch(TEX0.PSM)
  1359. {
  1360. case PSM_PSMT8:
  1361. case PSM_PSMT8H:
  1362. ReadCLUT32_T16_I8(pCLUT, pCLUT32);
  1363. break;
  1364. case PSM_PSMT4:
  1365. case PSM_PSMT4HL:
  1366. case PSM_PSMT4HH:
  1367. ReadCLUT32_T16_I4(pCLUT, pCLUT32);
  1368. break;
  1369. }
  1370. }
  1371. }
  1373. void GSLocalMemory::SetupCLUT(GIFRegTEX0 TEX0, GIFRegTEXA TEXA)
  1374. {
  1375. // TODO: cache m_pCLUT*
  1377. ReadCLUT(TEX0, TEXA, m_pCLUT32);
  1379. switch(TEX0.PSM)
  1380. {
  1381. case PSM_PSMT4:
  1382. case PSM_PSMT4HL:
  1383. case PSM_PSMT4HH:
  1384. // sse2?
  1385. if(TEX0.CPSM == PSM_PSMCT32)
  1386. {
  1387. for(int j = 0, k = 0; j < 16; j++)
  1388. for(int i = 0; i < 16; i++, k++)
  1389. m_pCLUT64[k] = ((UINT64)m_pCLUT32[j] << 32) | m_pCLUT32[i];
  1390. }
  1391. else
  1392. {
  1393. for(int j = 0, k = 0; j < 16; j++)
  1394. for(int i = 0; i < 16; i++, k++)
  1395. m_pCLUT64[k] = ((UINT64)m_pCLUT32[j] << 16) | (m_pCLUT32[i]&0xffff);
  1396. }
  1397. break;
  1398. }
  1399. }
  1401. //
  1403. void GSLocalMemory::ReadCLUT32(GIFRegTEX0 TEX0, GIFRegTEXA TEXA, DWORD* pCLUT32)
  1404. {
  1405. ASSERT(pCLUT32);
  1407. WORD* pCLUT = m_pCLUT + (TEX0.CSA<<4);
  1409. if(TEX0.CPSM == PSM_PSMCT32)
  1410. {
  1411. switch(TEX0.PSM)
  1412. {
  1413. case PSM_PSMT8:
  1414. case PSM_PSMT8H:
  1415. ReadCLUT32_T32_I8(pCLUT, pCLUT32);
  1416. break;
  1417. case PSM_PSMT4:
  1418. case PSM_PSMT4HL:
  1419. case PSM_PSMT4HH:
  1420. ReadCLUT32_T32_I4(pCLUT, pCLUT32);
  1421. break;
  1422. }
  1423. }
  1424. else if(TEX0.CPSM == PSM_PSMCT16 || TEX0.CPSM == PSM_PSMCT16S)
  1425. {
  1426. Expand16(pCLUT, pCLUT32, m_psmtbl[TEX0.PSM].pal, &TEXA);
  1427. }
  1428. }
  1430. void GSLocalMemory::SetupCLUT32(GIFRegTEX0 TEX0, GIFRegTEXA TEXA)
  1431. {
  1432. // TODO: cache m_pCLUT*
  1434. ReadCLUT32(TEX0, TEXA, m_pCLUT32);
  1436. switch(TEX0.PSM)
  1437. {
  1438. case PSM_PSMT4:
  1439. case PSM_PSMT4HL:
  1440. case PSM_PSMT4HH:
  1441. // sse2?
  1442. for(int j = 0, k = 0; j < 16; j++)
  1443. for(int i = 0; i < 16; i++, k++)
  1444. m_pCLUT64[k] = ((UINT64)m_pCLUT32[j] << 32) | m_pCLUT32[i];
  1445. break;
  1446. }
  1447. }
  1449. void GSLocalMemory::CopyCLUT32(DWORD* pCLUT32, int nPaletteEntries)
  1450. {
  1451. memcpy(pCLUT32, m_pCLUT32, sizeof(DWORD)*nPaletteEntries);
  1452. }
  1454. ////////////////////
  1456. DWORD GSLocalMemory::readTexel32(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1457. {
  1458. return m_vm32[pixelAddress32(x, y, TEX0.TBP0, TEX0.TBW)];
  1459. }
  1461. DWORD GSLocalMemory::readTexel24(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1462. {
  1463. return Expand24To32(m_vm32[pixelAddress32(x, y, TEX0.TBP0, TEX0.TBW)], TEX0.ai32[1]&4, TEXA);
  1464. }
  1466. DWORD GSLocalMemory::readTexel16(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1467. {
  1468. return Expand16To32(m_vm16[pixelAddress16(x, y, TEX0.TBP0, TEX0.TBW)], TEXA);
  1469. }
  1471. DWORD GSLocalMemory::readTexel16S(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1472. {
  1473. return Expand16To32(m_vm16[pixelAddress16S(x, y, TEX0.TBP0, TEX0.TBW)], TEXA);
  1474. }
  1476. DWORD GSLocalMemory::readTexel8(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1477. {
  1478. return m_pCLUT32[readPixel8(x, y, TEX0.TBP0, TEX0.TBW)];
  1479. }
  1481. DWORD GSLocalMemory::readTexel8H(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1482. {
  1483. return m_pCLUT32[readPixel8H(x, y, TEX0.TBP0, TEX0.TBW)];
  1484. }
  1486. DWORD GSLocalMemory::readTexel4(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1487. {
  1488. return m_pCLUT32[readPixel4(x, y, TEX0.TBP0, TEX0.TBW)];
  1489. }
  1491. DWORD GSLocalMemory::readTexel4HL(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1492. {
  1493. return m_pCLUT32[readPixel4HL(x, y, TEX0.TBP0, TEX0.TBW)];
  1494. }
  1496. DWORD GSLocalMemory::readTexel4HH(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1497. {
  1498. return m_pCLUT32[readPixel4HH(x, y, TEX0.TBP0, TEX0.TBW)];
  1499. }
  1501. ////////////////////
  1502. /*
  1503. DWORD GSLocalMemory::readTexel32(DWORD addr, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1504. {
  1505. return m_vm32[addr];
  1506. }
  1508. DWORD GSLocalMemory::readTexel24(DWORD addr, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1509. {
  1510. return Expand24To32(m_vm32[addr], TEX0.ai32[1]&4, TEXA);
  1511. }
  1513. DWORD GSLocalMemory::readTexel16(DWORD addr, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1514. {
  1515. return Expand16To32(m_vm16[addr], TEXA);
  1516. }
  1518. DWORD GSLocalMemory::readTexel16S(DWORD addr, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1519. {
  1520. return Expand16To32(m_vm16[addr], TEXA);
  1521. }
  1523. DWORD GSLocalMemory::readTexel8(DWORD addr, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1524. {
  1525. return m_pCLUT32[readPixel8(addr)];
  1526. }
  1528. DWORD GSLocalMemory::readTexel8H(DWORD addr, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1529. {
  1530. return m_pCLUT32[readPixel8H(addr)];
  1531. }
  1533. DWORD GSLocalMemory::readTexel4(DWORD addr, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1534. {
  1535. return m_pCLUT32[readPixel4(addr)];
  1536. }
  1538. DWORD GSLocalMemory::readTexel4HL(DWORD addr, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1539. {
  1540. return m_pCLUT32[readPixel4HL(addr)];
  1541. }
  1543. DWORD GSLocalMemory::readTexel4HH(DWORD addr, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  1544. {
  1545. return m_pCLUT32[readPixel4HH(addr)];
  1546. }
  1547. */
  1548. ////////////////////
  1550. static void SwizzleTextureStep(int& tx, int& ty, GIFRegTRXPOS& TRXPOS, GIFRegTRXREG& TRXREG)
  1551. {
  1552. // if(ty == TRXREG.RRH && tx == TRXPOS.DSAX) ASSERT(0);
  1554. if(++tx == TRXREG.RRW)
  1555. {
  1556. tx = TRXPOS.DSAX;
  1557. ty++;
  1558. }
  1559. }
  1561. #define IsTopLeftAligned(dsax, tx, ty, bw, bh) 
  1562. (((dsax) & ((bw)-1)) == 0 && ((tx) & ((bw)-1)) == 0 && (dsax) == (tx) && ((ty) & ((bh)-1)) == 0)
  1564. void GSLocalMemory::SwizzleTexture32(int& tx, int& ty, BYTE* src, int len, GIFRegBITBLTBUF& BITBLTBUF, GIFRegTRXPOS& TRXPOS, GIFRegTRXREG& TRXREG)
  1565. {
  1566. if(TRXREG.RRW == 0) return;
  1568. int tw = TRXREG.RRW, srcpitch = (TRXREG.RRW - TRXPOS.DSAX)*4;
  1569. int th = len / srcpitch;
  1571. bool fTopLeftAligned = IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 8, 8);
  1573. if(!fTopLeftAligned || (tw & 7) || (th & 7) || (len % srcpitch))
  1574. {
  1575. if(fTopLeftAligned && tw >= 8 && th >= 8)
  1576. {
  1577. int twa = tw & ~7;
  1578. int tha = th & ~7;
  1580. len -= tha * srcpitch;
  1581. th -= tha;
  1583. for(int j = 0; j < tha; j += 8)
  1584. {
  1585. for(int x = tx; x < twa; x += 8)
  1586. SwizzleBlock32u((BYTE*)&m_vm32[blockAddress32(x, ty, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx)*4, srcpitch);
  1588. for(int i = 0; i < 8; i++, ty++, src += srcpitch)
  1589. for(int x = twa; x < tw; x++)
  1590. writePixel32(x, ty, ((DWORD*)src)[x - tx], BITBLTBUF.DBP, BITBLTBUF.DBW);
  1591. }
  1592. }
  1594. if(len > 0 && tw >= 8 && th >= 2 && IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 8, 2))
  1595. {
  1596. int twa = tw & ~7;
  1597. int tha = th & ~1;
  1599. len -= tha * srcpitch;
  1600. th -= tha;
  1602. for(int j = 0; j < tha; j += 2)
  1603. {
  1604. for(int x = tx; x < twa; x += 8)
  1605. SwizzleColumn32(ty, (BYTE*)&m_vm32[blockAddress32(x, ty&~7, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx)*4, srcpitch);
  1607. for(int i = 0; i < 2; i++, ty++, src += srcpitch)
  1608. for(int x = twa; x < tw; x++)
  1609. writePixel32(x, ty, ((DWORD*)src)[x - tx], BITBLTBUF.DBP, BITBLTBUF.DBW);
  1610. }
  1611. }
  1613. SwizzleTextureX(tx, ty, src, len, BITBLTBUF, TRXPOS, TRXREG);
  1614. }
  1615. else
  1616. {
  1617. th += ty;
  1619. if((DWORD_PTR)src & 0xf)
  1620. {
  1621. for(int y = ty; y < th; y += 8, src += srcpitch*8)
  1622. for(int x = tx; x < tw; x += 8)
  1623. SwizzleBlock32u((BYTE*)&m_vm32[blockAddress32(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx)*4, srcpitch);
  1624. }
  1625. else
  1626. {
  1627. for(int y = ty; y < th; y += 8, src += srcpitch*8)
  1628. for(int x = tx; x < tw; x += 8)
  1629. SwizzleBlock32((BYTE*)&m_vm32[blockAddress32(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx)*4, srcpitch);
  1630. }
  1632. ty = th;
  1633. }
  1634. }
  1636. void GSLocalMemory::SwizzleTexture24(int& tx, int& ty, BYTE* src, int len, GIFRegBITBLTBUF& BITBLTBUF, GIFRegTRXPOS& TRXPOS, GIFRegTRXREG& TRXREG)
  1637. {
  1638. if(TRXREG.RRW == 0) return;
  1640. int tw = TRXREG.RRW, srcpitch = (TRXREG.RRW - TRXPOS.DSAX)*3;
  1641. int th = len / srcpitch;
  1643. bool fTopLeftAligned = IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 8, 8);
  1645. if(!fTopLeftAligned || (tw & 7) || (th & 7) || (len % srcpitch))
  1646. {
  1647. // TODO
  1649. SwizzleTextureX(tx, ty, src, len, BITBLTBUF, TRXPOS, TRXREG);
  1650. }
  1651. else
  1652. {
  1653. __declspec(align(16)) DWORD block[8*8];
  1655. th += ty;
  1657. for(int y = ty; y < th; y += 8, src += srcpitch*8)
  1658. {
  1659. for(int x = tx; x < tw; x += 8)
  1660. {
  1661. BYTE* s = src + (x - tx)*3;
  1662. DWORD* d = block;
  1664. for(int j = 0, diff = srcpitch - 8*3; j < 8; j++, s += diff, d += 8)
  1665. for(int i = 0; i < 8; i++, s += 3)
  1666. d[i] = (s[2]<<16)|(s[1]<<8)|s[0];
  1668. SwizzleBlock32((BYTE*)&m_vm32[blockAddress32(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)], (BYTE*)block, sizeof(block)/8, 0x00ffffff);
  1669. }
  1670. }
  1672. ty = th;
  1673. }
  1674. }
  1676. void GSLocalMemory::SwizzleTexture16(int& tx, int& ty, BYTE* src, int len, GIFRegBITBLTBUF& BITBLTBUF, GIFRegTRXPOS& TRXPOS, GIFRegTRXREG& TRXREG)
  1677. {
  1678. if(TRXREG.RRW == 0) return;
  1680. int tw = TRXREG.RRW, srcpitch = (TRXREG.RRW - TRXPOS.DSAX)*2;
  1681. int th = len / srcpitch;
  1683. bool fTopLeftAligned = IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 16, 8);
  1685. if(!fTopLeftAligned || (tw & 15) || (th & 7) || (len % srcpitch))
  1686. {
  1687. if(fTopLeftAligned && tw >= 16 && th >= 8)
  1688. {
  1689. int twa = tw & ~15;
  1690. int tha = th & ~7;
  1692. len -= tha * srcpitch;
  1693. th -= tha;
  1695. for(int j = 0; j < tha; j += 8)
  1696. {
  1697. for(int x = tx; x < twa; x += 16)
  1698. SwizzleBlock16u((BYTE*)&m_vm16[blockAddress16(x, ty, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx)*2, srcpitch);
  1700. for(int i = 0; i < 8; i++, ty++, src += srcpitch)
  1701. for(int x = twa; x < tw; x++)
  1702. writePixel16(x, ty, ((WORD*)src)[x - tx], BITBLTBUF.DBP, BITBLTBUF.DBW);
  1703. }
  1704. }
  1706. if(len > 0 && tw >= 16 && th >= 2 && IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 16, 2))
  1707. {
  1708. int twa = tw & ~15;
  1709. int tha = th & ~1;
  1711. len -= tha * srcpitch;
  1712. th -= tha;
  1714. for(int j = 0; j < tha; j += 2)
  1715. {
  1716. for(int x = tx; x < twa; x += 16)
  1717. SwizzleColumn16(ty, (BYTE*)&m_vm16[blockAddress16(x, ty&~7, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx)*2, srcpitch);
  1719. for(int i = 0; i < 2; i++, ty++, src += srcpitch)
  1720. for(int x = twa; x < tw; x++)
  1721. writePixel16(x, ty, ((WORD*)src)[x - tx], BITBLTBUF.DBP, BITBLTBUF.DBW);
  1722. }
  1723. }
  1725. SwizzleTextureX(tx, ty, src, len, BITBLTBUF, TRXPOS, TRXREG);
  1726. }
  1727. else
  1728. {
  1729. th += ty;
  1731. if((DWORD_PTR)src & 0xf)
  1732. {
  1733. for(int y = ty; y < th; y += 8, src += srcpitch*8)
  1734. for(int x = tx; x < tw; x += 16)
  1735. SwizzleBlock16u((BYTE*)&m_vm16[blockAddress16(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx)*2, srcpitch);
  1736. }
  1737. else
  1738. {
  1739. for(int y = ty; y < th; y += 8, src += srcpitch*8)
  1740. for(int x = tx; x < tw; x += 16)
  1741. SwizzleBlock16((BYTE*)&m_vm16[blockAddress16(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx)*2, srcpitch);
  1742. }
  1744. ty = th;
  1745. }
  1746. }
  1748. void GSLocalMemory::SwizzleTexture16S(int& tx, int& ty, BYTE* src, int len, GIFRegBITBLTBUF& BITBLTBUF, GIFRegTRXPOS& TRXPOS, GIFRegTRXREG& TRXREG)
  1749. {
  1750. if(TRXREG.RRW == 0) return;
  1752. int tw = TRXREG.RRW, srcpitch = (TRXREG.RRW - TRXPOS.DSAX)*2;
  1753. int th = len / srcpitch;
  1755. bool fTopLeftAligned = IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 16, 8);
  1757. if(!fTopLeftAligned || (tw & 15) || (th & 7) || (len % srcpitch))
  1758. {
  1759. if(fTopLeftAligned && tw >= 16 && th >= 8)
  1760. {
  1761. int twa = tw & ~15;
  1762. int tha = th & ~7;
  1764. len -= tha * srcpitch;
  1765. th -= tha;
  1767. for(int j = 0; j < tha; j += 8)
  1768. {
  1769. for(int x = tx; x < twa; x += 16)
  1770. SwizzleBlock16u((BYTE*)&m_vm16[blockAddress16S(x, ty, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx)*2, srcpitch);
  1772. for(int i = 0; i < 8; i++, ty++, src += srcpitch)
  1773. for(int x = twa; x < tw; x++)
  1774. writePixel16S(x, ty, ((WORD*)src)[x - tx], BITBLTBUF.DBP, BITBLTBUF.DBW);
  1775. }
  1776. }
  1778. if(len > 0 && tw >= 16 && th >= 2 && IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 16, 2))
  1779. {
  1780. int twa = tw & ~15;
  1781. int tha = th & ~1;
  1783. len -= tha * srcpitch;
  1784. th -= tha;
  1786. for(int j = 0; j < tha; j += 2)
  1787. {
  1788. for(int x = tx; x < twa; x += 16)
  1789. SwizzleColumn16(ty, (BYTE*)&m_vm16[blockAddress16S(x, ty&~7, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx)*2, srcpitch);
  1791. for(int i = 0; i < 2; i++, ty++, src += srcpitch)
  1792. for(int x = twa; x < tw; x++)
  1793. writePixel16S(x, ty, ((WORD*)src)[x - tx], BITBLTBUF.DBP, BITBLTBUF.DBW);
  1794. }
  1795. }
  1797. SwizzleTextureX(tx, ty, src, len, BITBLTBUF, TRXPOS, TRXREG);
  1798. }
  1799. else
  1800. {
  1801. th += ty;
  1803. if((DWORD_PTR)src & 0xf)
  1804. {
  1805. for(int y = ty; y < th; y += 8, src += srcpitch*8)
  1806. for(int x = tx; x < tw; x += 16)
  1807. SwizzleBlock16((BYTE*)&m_vm16[blockAddress16S(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx)*2, srcpitch);
  1808. }
  1809. else
  1810. {
  1811. for(int y = ty; y < th; y += 8, src += srcpitch*8)
  1812. for(int x = tx; x < tw; x += 16)
  1813. SwizzleBlock16((BYTE*)&m_vm16[blockAddress16S(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx)*2, srcpitch);
  1814. }
  1816. ty = th;
  1817. }
  1818. }
  1820. void GSLocalMemory::SwizzleTexture8(int& tx, int& ty, BYTE* src, int len, GIFRegBITBLTBUF& BITBLTBUF, GIFRegTRXPOS& TRXPOS, GIFRegTRXREG& TRXREG)
  1821. {
  1822. if(TRXREG.RRW == 0) return;
  1824. int tw = TRXREG.RRW, srcpitch = TRXREG.RRW - TRXPOS.DSAX;
  1825. int th = len / srcpitch;
  1827. bool fTopLeftAligned = IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 16, 16);
  1829. if(!fTopLeftAligned || (tw & 15) || (th & 15) || (len % srcpitch))
  1830. {
  1831. if(fTopLeftAligned && tw >= 16 && th >= 16)
  1832. {
  1833. int twa = tw & ~15;
  1834. int tha = th & ~15;
  1836. len -= tha * srcpitch;
  1837. th -= tha;
  1839. for(int j = 0; j < tha; j += 16)
  1840. {
  1841. for(int x = tx; x < twa; x += 16)
  1842. SwizzleBlock8u((BYTE*)&m_vm8[blockAddress8(x, ty, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx), srcpitch);
  1844. for(int i = 0; i < 16; i++, ty++, src += srcpitch)
  1845. for(int x = twa; x < tw; x++)
  1846. writePixel8(x, ty, src[x - tx], BITBLTBUF.DBP, BITBLTBUF.DBW);
  1847. }
  1848. }
  1850. if(len > 0 && tw >= 16 && th >= 4 && IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 16, 4))
  1851. {
  1852. int twa = tw & ~15;
  1853. int tha = th & ~3;
  1855. len -= tha * srcpitch;
  1856. th -= tha;
  1858. for(int j = 0; j < tha; j += 4)
  1859. {
  1860. for(int x = tx; x < twa; x += 16)
  1861. SwizzleColumn8(ty, (BYTE*)&m_vm8[blockAddress8(x, ty&~15, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx), srcpitch);
  1863. for(int i = 0; i < 4; i++, ty++, src += srcpitch)
  1864. for(int x = twa; x < tw; x++)
  1865. writePixel8(x, ty, src[x - tx], BITBLTBUF.DBP, BITBLTBUF.DBW);
  1866. }
  1867. }
  1869. SwizzleTextureX(tx, ty, src, len, BITBLTBUF, TRXPOS, TRXREG);
  1870. }
  1871. else
  1872. {
  1873. th += ty;
  1875. if((DWORD_PTR)src & 0xf)
  1876. {
  1877. for(int y = ty; y < th; y += 16, src += srcpitch*16)
  1878. for(int x = tx; x < tw; x += 16)
  1879. SwizzleBlock8u((BYTE*)&m_vm8[blockAddress8(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx), srcpitch);
  1880. }
  1881. else
  1882. {
  1883. for(int y = ty; y < th; y += 16, src += srcpitch*16)
  1884. for(int x = tx; x < tw; x += 16)
  1885. SwizzleBlock8((BYTE*)&m_vm8[blockAddress8(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)], src + (x - tx), srcpitch);
  1886. }
  1888. ty = th;
  1889. }
  1890. }
  1892. void GSLocalMemory::SwizzleTexture8H(int& tx, int& ty, BYTE* src, int len, GIFRegBITBLTBUF& BITBLTBUF, GIFRegTRXPOS& TRXPOS, GIFRegTRXREG& TRXREG)
  1893. {
  1894. if(TRXREG.RRW == 0) return;
  1896. int tw = TRXREG.RRW, srcpitch = TRXREG.RRW - TRXPOS.DSAX;
  1897. int th = len / srcpitch;
  1899. bool fTopLeftAligned = IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 8, 8);
  1901. if(!fTopLeftAligned || (tw & 7) || (th & 7) || (len % srcpitch))
  1902. {
  1903. // TODO
  1905. SwizzleTextureX(tx, ty, src, len, BITBLTBUF, TRXPOS, TRXREG);
  1906. }
  1907. else
  1908. {
  1909. __declspec(align(16)) DWORD block[8*8];
  1911. th += ty;
  1913. for(int y = ty; y < th; y += 8, src += srcpitch*8)
  1914. {
  1915. for(int x = tx; x < tw; x += 8)
  1916. {
  1917. BYTE* s = src + (x - tx);
  1918. DWORD* d = block;
  1920. for(int j = 0; j < 8; j++, s += srcpitch, d += 8)
  1921. for(int i = 0; i < 8; i++)
  1922. d[i] = s[i] << 24;
  1924. SwizzleBlock32((BYTE*)&m_vm32[blockAddress32(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)], (BYTE*)block, sizeof(block)/8, 0xff000000);
  1925. }
  1926. }
  1928. ty = th;
  1929. }
  1930. }
  1932. void GSLocalMemory::SwizzleTexture4(int& tx, int& ty, BYTE* src, int len, GIFRegBITBLTBUF& BITBLTBUF, GIFRegTRXPOS& TRXPOS, GIFRegTRXREG& TRXREG)
  1933. {
  1934. if(TRXREG.RRW == 0) return;
  1936. int tw = TRXREG.RRW, srcpitch = (TRXREG.RRW - TRXPOS.DSAX)/2;
  1937. int th = len / srcpitch;
  1939. bool fTopLeftAligned = IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 32, 16);
  1941. if(!fTopLeftAligned || (tw & 31) || (th & 15) || (len % srcpitch))
  1942. {
  1943. if(fTopLeftAligned && tw >= 32 && th >= 16)
  1944. {
  1945. int twa = tw & ~31;
  1946. int tha = th & ~15;
  1948. len -= tha * srcpitch;
  1949. th -= tha;
  1951. for(int j = 0; j < tha; j += 16)
  1952. {
  1953. for(int x = tx; x < twa; x += 32)
  1954. SwizzleBlock4u((BYTE*)&m_vm8[blockAddress4(x, ty, BITBLTBUF.DBP, BITBLTBUF.DBW)>>1], src + (x - tx)/2, srcpitch);
  1956. for(int i = 0; i < 16; i++, ty++, src += srcpitch)
  1957. {
  1958. BYTE* s = src + (twa - tx)/2;
  1960. for(int x = twa; x < tw; x += 2, s++)
  1961. {
  1962. writePixel4(x, ty, *s&0xf, BITBLTBUF.DBP, BITBLTBUF.DBW),
  1963. writePixel4(x+1, ty, *s>>4, BITBLTBUF.DBP, BITBLTBUF.DBW);
  1964. }
  1965. }
  1966. }
  1967. }
  1969. if(len > 0 && tw >= 32 && th >= 4 && IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 32, 4))
  1970. {
  1971. int twa = tw & ~31;
  1972. int tha = th & ~3;
  1974. len -= tha * srcpitch;
  1975. th -= tha;
  1977. for(int j = 0; j < tha; j += 4)
  1978. {
  1979. for(int x = tx; x < twa; x += 32)
  1980. SwizzleColumn4(ty, (BYTE*)&m_vm8[blockAddress4(x, ty&~15, BITBLTBUF.DBP, BITBLTBUF.DBW)>>1], src + (x - tx)/2, srcpitch);
  1982. for(int i = 0; i < 4; i++, ty++, src += srcpitch)
  1983. {
  1984. BYTE* s = src + (twa - tx)/2;
  1986. for(int x = twa; x < tw; x += 2, s++)
  1987. {
  1988. writePixel4(x, ty, *s&0xf, BITBLTBUF.DBP, BITBLTBUF.DBW),
  1989. writePixel4(x+1, ty, *s>>4, BITBLTBUF.DBP, BITBLTBUF.DBW);
  1990. }
  1991. }
  1992. }
  1993. }
  1995. SwizzleTextureX(tx, ty, src, len, BITBLTBUF, TRXPOS, TRXREG);
  1996. }
  1997. else
  1998. {
  1999. th += ty;
  2001. if((DWORD_PTR)src & 0xf)
  2002. {
  2003. for(int y = ty; y < th; y += 16, src += srcpitch*16)
  2004. for(int x = tx; x < tw; x += 32)
  2005. SwizzleBlock4u((BYTE*)&m_vm8[blockAddress4(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)>>1], src + (x - tx)/2, srcpitch);
  2006. }
  2007. else
  2008. {
  2009. for(int y = ty; y < th; y += 16, src += srcpitch*16)
  2010. for(int x = tx; x < tw; x += 32)
  2011. SwizzleBlock4((BYTE*)&m_vm8[blockAddress4(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)>>1], src + (x - tx)/2, srcpitch);
  2012. }
  2014. ty = th;
  2015. }
  2016. }
  2018. void GSLocalMemory::SwizzleTexture4HL(int& tx, int& ty, BYTE* src, int len, GIFRegBITBLTBUF& BITBLTBUF, GIFRegTRXPOS& TRXPOS, GIFRegTRXREG& TRXREG)
  2019. {
  2020. if(TRXREG.RRW == 0) return;
  2022. int tw = TRXREG.RRW, srcpitch = (TRXREG.RRW - TRXPOS.DSAX)/2;
  2023. int th = len / srcpitch;
  2025. bool fTopLeftAligned = IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 8, 8);
  2027. if(!fTopLeftAligned || (tw & 7) || (th & 7) || (len % srcpitch))
  2028. {
  2029. // TODO
  2031. SwizzleTextureX(tx, ty, src, len, BITBLTBUF, TRXPOS, TRXREG);
  2032. }
  2033. else
  2034. {
  2035. __declspec(align(16)) DWORD block[8*8];
  2037. th += ty;
  2039. for(int y = ty; y < th; y += 8, src += srcpitch*8)
  2040. {
  2041. for(int x = tx; x < tw; x += 8)
  2042. {
  2043. BYTE* s = src + (x - tx)/2;
  2044. DWORD* d = block;
  2046. for(int j = 0; j < 8; j++, s += srcpitch, d += 8)
  2047. for(int i = 0; i < 8/2; i++)
  2048. d[i*2] = (s[i]&0x0f) << 24, 
  2049. d[i*2+1] = (s[i]&0xf0) << 20;
  2051. SwizzleBlock32((BYTE*)&m_vm32[blockAddress32(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)], (BYTE*)block, sizeof(block)/8, 0x0f000000);
  2052. }
  2053. }
  2055. ty = th;
  2056. }
  2057. }
  2059. void GSLocalMemory::SwizzleTexture4HH(int& tx, int& ty, BYTE* src, int len, GIFRegBITBLTBUF& BITBLTBUF, GIFRegTRXPOS& TRXPOS, GIFRegTRXREG& TRXREG)
  2060. {
  2061. if(TRXREG.RRW == 0) return;
  2063. int tw = TRXREG.RRW, srcpitch = (TRXREG.RRW - TRXPOS.DSAX)/2;
  2064. int th = len / srcpitch;
  2066. bool fTopLeftAligned = IsTopLeftAligned(TRXPOS.DSAX, tx, ty, 8, 8);
  2068. if(!fTopLeftAligned || (tw & 7) || (th & 7) || (len % srcpitch))
  2069. {
  2070. // TODO
  2072. SwizzleTextureX(tx, ty, src, len, BITBLTBUF, TRXPOS, TRXREG);
  2073. }
  2074. else
  2075. {
  2076. __declspec(align(16)) DWORD block[8*8];
  2078. th += ty;
  2080. for(int y = ty; y < th; y += 8, src += srcpitch*8)
  2081. {
  2082. for(int x = tx; x < tw; x += 8)
  2083. {
  2084. BYTE* s = src + (x - tx)/2;
  2085. DWORD* d = block;
  2087. for(int j = 0; j < 8; j++, s += srcpitch, d += 8)
  2088. for(int i = 0; i < 8/2; i++)
  2089. d[i*2] = (s[i]&0x0f) << 28, 
  2090. d[i*2+1] = (s[i]&0xf0) << 24;
  2092. SwizzleBlock32((BYTE*)&m_vm32[blockAddress32(x, y, BITBLTBUF.DBP, BITBLTBUF.DBW)], (BYTE*)block, sizeof(block)/8, 0xf0000000);
  2093. }
  2094. }
  2096. ty = th;
  2097. }
  2098. }
  2100. void GSLocalMemory::SwizzleTextureX(int& tx, int& ty, BYTE* src, int len, GIFRegBITBLTBUF& BITBLTBUF, GIFRegTRXPOS& TRXPOS, GIFRegTRXREG& TRXREG)
  2101. {
  2102. if(len <= 0) return;
  2104. BYTE* pb = (BYTE*)src;
  2105. WORD* pw = (WORD*)src;
  2106. DWORD* pd = (DWORD*)src;
  2108. // if(ty >= (int)TRXREG.RRH) {ASSERT(0); return;}
  2110. switch(BITBLTBUF.DPSM)
  2111. {
  2112. case PSM_PSMCT32:
  2113. for(len /= 4; len-- > 0; SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), pd++)
  2114. writePixel32(tx, ty, *pd, BITBLTBUF.DBP, BITBLTBUF.DBW);
  2115. break;
  2116. case PSM_PSMCT24:
  2117. for(len /= 3; len-- > 0; SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), pb+=3)
  2118. writePixel24(tx, ty, *(DWORD*)pb, BITBLTBUF.DBP, BITBLTBUF.DBW);
  2119. break;
  2120. case PSM_PSMCT16:
  2121. for(len /= 2; len-- > 0; SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), pw++)
  2122. writePixel16(tx, ty, *pw, BITBLTBUF.DBP, BITBLTBUF.DBW);
  2123. break;
  2124. case PSM_PSMCT16S:
  2125. for(len /= 2; len-- > 0; SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), pw++)
  2126. writePixel16S(tx, ty, *pw, BITBLTBUF.DBP, BITBLTBUF.DBW);
  2127. break;
  2128. case PSM_PSMT8:
  2129. for(; len-- > 0; SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), pb++)
  2130. writePixel8(tx, ty, *pb, BITBLTBUF.DBP, BITBLTBUF.DBW);
  2131. break;
  2132. case PSM_PSMT4:
  2133. for(; len-- > 0; SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), pb++)
  2134. writePixel4(tx, ty, *pb&0xf, BITBLTBUF.DBP, BITBLTBUF.DBW),
  2135. writePixel4(tx+1, ty, *pb>>4, BITBLTBUF.DBP, BITBLTBUF.DBW);
  2136. break;
  2137. case PSM_PSMT8H:
  2138. for(; len-- > 0; SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), pb++)
  2139. writePixel8H(tx, ty, *pb, BITBLTBUF.DBP, BITBLTBUF.DBW);
  2140. break;
  2141. case PSM_PSMT4HL:
  2142. for(; len-- > 0; SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), pb++)
  2143. writePixel4HL(tx, ty, *pb&0xf, BITBLTBUF.DBP, BITBLTBUF.DBW),
  2144. writePixel4HL(tx+1, ty, *pb>>4, BITBLTBUF.DBP, BITBLTBUF.DBW);
  2145. break;
  2146. case PSM_PSMT4HH:
  2147. for(; len-- > 0; SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), pb++)
  2148. writePixel4HH(tx, ty, *pb&0xf, BITBLTBUF.DBP, BITBLTBUF.DBW),
  2149. writePixel4HH(tx+1, ty, *pb>>4, BITBLTBUF.DBP, BITBLTBUF.DBW);
  2150. break;
  2151. case PSM_PSMZ32:
  2152. for(len /= 4; len-- > 0; SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), pd++)
  2153. writePixel32Z(tx, ty, *pd, BITBLTBUF.DBP, BITBLTBUF.DBW);
  2154. break;
  2155. case PSM_PSMZ24:
  2156. for(len /= 3; len-- > 0; SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), pb+=3)
  2157. writePixel24Z(tx, ty, *(DWORD*)pb, BITBLTBUF.DBP, BITBLTBUF.DBW);
  2158. break;
  2159. case PSM_PSMZ16:
  2160. for(len /= 2; len-- > 0; SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), pw++)
  2161. writePixel16Z(tx, ty, *pw, BITBLTBUF.DBP, BITBLTBUF.DBW);
  2162. break;
  2163. case PSM_PSMZ16S:
  2164. for(len /= 2; len-- > 0; SwizzleTextureStep(tx, ty, TRXPOS, TRXREG), pw++)
  2165. writePixel16SZ(tx, ty, *pw, BITBLTBUF.DBP, BITBLTBUF.DBW);
  2166. break;
  2167. }
  2168. }
  2170. ///////////////////
  2172. void GSLocalMemory::unSwizzleTexture32(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2173. {
  2174. #pragma omp parallel
  2175. {
  2176. #pragma omp for
  2177. FOREACH_BLOCK_START(r, 8, 8, 32)
  2178. {
  2179. unSwizzleBlock32((BYTE*)&m_vm32[blockAddress32(x, y, TEX0.TBP0, TEX0.TBW)], ptr + (x-r.left)*4, dstpitch);
  2180. }
  2181. FOREACH_BLOCK_END
  2182. }
  2183. }
  2185. void GSLocalMemory::unSwizzleTexture24(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2186. {
  2187. #pragma omp parallel
  2188. {
  2189. #pragma omp for
  2190. FOREACH_BLOCK_START(r, 8, 8, 32)
  2191. {
  2192. __declspec(align(16)) DWORD block[8*8];
  2193. unSwizzleBlock32((BYTE*)&m_vm32[blockAddress32(x, y, TEX0.TBP0, TEX0.TBW)], (BYTE*)block, sizeof(block)/8);
  2194. ExpandBlock24(block, (DWORD*)ptr + (x-r.left), dstpitch, &TEXA);
  2195. }
  2196. FOREACH_BLOCK_END
  2197. }
  2198. }
  2200. void GSLocalMemory::unSwizzleTexture16(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2201. {
  2202. #pragma omp parallel
  2203. {
  2204. #pragma omp for
  2205. FOREACH_BLOCK_START(r, 16, 8, 16)
  2206. {
  2207. __declspec(align(16)) WORD block[16*8];
  2208. unSwizzleBlock16((BYTE*)&m_vm16[blockAddress16(x, y, TEX0.TBP0, TEX0.TBW)], (BYTE*)block, sizeof(block)/8);
  2209. ExpandBlock16(block, (DWORD*)ptr + (x-r.left), dstpitch, &TEXA);
  2210. }
  2211. FOREACH_BLOCK_END
  2212. }
  2213. }
  2215. void GSLocalMemory::unSwizzleTexture16S(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2216. {
  2217. #pragma omp parallel
  2218. {
  2219. #pragma omp for
  2220. FOREACH_BLOCK_START(r, 16, 8, 16S)
  2221. {
  2222. __declspec(align(16)) WORD block[16*8];
  2223. unSwizzleBlock16((BYTE*)&m_vm16[blockAddress16S(x, y, TEX0.TBP0, TEX0.TBW)], (BYTE*)block, sizeof(block)/8);
  2224. ExpandBlock16(block, (DWORD*)ptr + (x-r.left), dstpitch, &TEXA);
  2225. }
  2226. FOREACH_BLOCK_END
  2227. }
  2228. }
  2230. void GSLocalMemory::unSwizzleTexture8(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2231. {
  2232. #pragma omp parallel
  2233. {
  2234. #pragma omp for
  2235. FOREACH_BLOCK_START(r, 16, 16, 8)
  2236. {
  2237. __declspec(align(16)) BYTE block[16*16];
  2238. unSwizzleBlock8((BYTE*)&m_vm8[blockAddress8(x, y, TEX0.TBP0, TEX0.TBW)], (BYTE*)block, sizeof(block)/16);
  2240. BYTE* s = block;
  2241. BYTE* d = ptr + (x-r.left)*4;
  2243. for(int j = 0; j < 16; j++, s += 16, d += dstpitch)
  2244. for(int i = 0; i < 16; i++)
  2245. ((DWORD*)d)[i] = m_pCLUT32[s[i]];
  2246. }
  2247. FOREACH_BLOCK_END
  2248. }
  2249. }
  2251. void GSLocalMemory::unSwizzleTexture8H(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2252. {
  2253. #pragma omp parallel
  2254. {
  2255. #pragma omp for
  2256. FOREACH_BLOCK_START(r, 8, 8, 32)
  2257. {
  2258. __declspec(align(16)) DWORD block[8*8];
  2259. unSwizzleBlock32((BYTE*)&m_vm32[blockAddress32(x, y, TEX0.TBP0, TEX0.TBW)], (BYTE*)block, sizeof(block)/8);
  2261. DWORD* s = block;
  2262. BYTE* d = ptr + (x-r.left)*4;
  2264. for(int j = 0; j < 8; j++, s += 8, d += dstpitch)
  2265. for(int i = 0; i < 8; i++)
  2266. ((DWORD*)d)[i] = m_pCLUT32[s[i] >> 24];
  2267. }
  2268. FOREACH_BLOCK_END
  2269. }
  2270. }
  2272. void GSLocalMemory::unSwizzleTexture4(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2273. {
  2274. #pragma omp parallel
  2275. {
  2276. #pragma omp for
  2277. FOREACH_BLOCK_START(r, 32, 16, 4)
  2278. {
  2279. __declspec(align(16)) BYTE block[(32/2)*16];
  2280. unSwizzleBlock4((BYTE*)&m_vm8[blockAddress4(x, y, TEX0.TBP0, TEX0.TBW)>>1], (BYTE*)block, sizeof(block)/16);
  2282. BYTE* s = block;
  2283. BYTE* d = ptr + (x-r.left)*4;
  2285. for(int j = 0; j < 16; j++, s += 32/2, d += dstpitch)
  2286. for(int i = 0; i < 32/2; i++)
  2287. ((UINT64*)d)[i] = m_pCLUT64[s[i]];
  2288. }
  2289. FOREACH_BLOCK_END
  2290. }
  2291. }
  2293. void GSLocalMemory::unSwizzleTexture4HL(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2294. {
  2295. #pragma omp parallel
  2296. {
  2297. #pragma omp for
  2298. FOREACH_BLOCK_START(r, 8, 8, 32)
  2299. {
  2300. __declspec(align(16)) DWORD block[8*8];
  2301. unSwizzleBlock32((BYTE*)&m_vm32[blockAddress32(x, y, TEX0.TBP0, TEX0.TBW)], (BYTE*)block, sizeof(block)/8);
  2303. DWORD* s = block;
  2304. BYTE* d = ptr + (x-r.left)*4;
  2306. for(int j = 0; j < 8; j++, s += 8, d += dstpitch)
  2307. for(int i = 0; i < 8; i++)
  2308. ((DWORD*)d)[i] = m_pCLUT32[(s[i] >> 24)&0x0f];
  2309. }
  2310. FOREACH_BLOCK_END
  2311. }
  2312. }
  2314. void GSLocalMemory::unSwizzleTexture4HH(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2315. {
  2316. #pragma omp parallel
  2317. {
  2318. #pragma omp for
  2319. FOREACH_BLOCK_START(r, 8, 8, 32)
  2320. {
  2321. __declspec(align(16)) DWORD block[8*8];
  2322. unSwizzleBlock32((BYTE*)&m_vm32[blockAddress32(x, y, TEX0.TBP0, TEX0.TBW)], (BYTE*)block, sizeof(block)/8);
  2324. DWORD* s = block;
  2325. BYTE* d = ptr + (x-r.left)*4;
  2327. for(int j = 0; j < 8; j++, s += 8, d += dstpitch)
  2328. for(int i = 0; i < 8; i++)
  2329. ((DWORD*)d)[i] = m_pCLUT32[s[i] >> 28];
  2330. }
  2331. FOREACH_BLOCK_END
  2332. }
  2333. }
  2335. ///////////////////
  2337. void GSLocalMemory::ReadTexture(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA, GIFRegCLAMP& CLAMP)
  2338. {
  2339. unSwizzleTexture st = m_psmtbl[TEX0.PSM].ust;
  2340. readTexel rt = m_psmtbl[TEX0.PSM].rt;
  2341. CSize bs = m_psmtbl[TEX0.PSM].bs;
  2343. if(r.Width() < bs.cx || r.Height() < bs.cy 
  2344. || (r.left & (bs.cx-1)) || (r.top & (bs.cy-1)) 
  2345. || (r.right & (bs.cx-1)) || (r.bottom & (bs.cy-1)) 
  2346. || (CLAMP.WMS&2) || (CLAMP.WMT&2))
  2347. {
  2348. ReadTexture<DWORD>(r, dst, dstpitch, TEX0, TEXA, CLAMP, rt, st);
  2349. }
  2350. else
  2351. {
  2352. (this->*st)(r, dst, dstpitch, TEX0, TEXA);
  2353. }
  2354. }
  2356. ////////////////////
  2358. DWORD GSLocalMemory::readTexel16P(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2359. {
  2360. return readPixel16(x, y, TEX0.TBP0, TEX0.TBW);
  2361. }
  2363. DWORD GSLocalMemory::readTexel16SP(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2364. {
  2365. return readPixel16S(x, y, TEX0.TBP0, TEX0.TBW);
  2366. }
  2368. DWORD GSLocalMemory::readTexel8P(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2369. {
  2370. return readPixel8(x, y, TEX0.TBP0, TEX0.TBW);
  2371. }
  2373. DWORD GSLocalMemory::readTexel8HP(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2374. {
  2375. return readPixel8H(x, y, TEX0.TBP0, TEX0.TBW);
  2376. }
  2378. DWORD GSLocalMemory::readTexel4P(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2379. {
  2380. return readPixel4(x, y, TEX0.TBP0, TEX0.TBW);
  2381. }
  2383. DWORD GSLocalMemory::readTexel4HLP(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2384. {
  2385. return readPixel4HL(x, y, TEX0.TBP0, TEX0.TBW);
  2386. }
  2388. DWORD GSLocalMemory::readTexel4HHP(int x, int y, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2389. {
  2390. return readPixel4HH(x, y, TEX0.TBP0, TEX0.TBW);
  2391. }
  2393. ///////////////////
  2395. void GSLocalMemory::unSwizzleTexture16P(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2396. {
  2397. #pragma omp parallel
  2398. {
  2399. #pragma omp for
  2400. FOREACH_BLOCK_START(r, 16, 8, 16)
  2401. {
  2402. unSwizzleBlock16((BYTE*)&m_vm16[blockAddress16(x, y, TEX0.TBP0, TEX0.TBW)], ptr + (x-r.left)*2, dstpitch);
  2403. }
  2404. FOREACH_BLOCK_END
  2405. }
  2406. }
  2408. void GSLocalMemory::unSwizzleTexture16SP(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2409. {
  2410. #pragma omp parallel
  2411. {
  2412. #pragma omp for
  2413. FOREACH_BLOCK_START(r, 16, 8, 16S)
  2414. {
  2415. unSwizzleBlock16((BYTE*)&m_vm16[blockAddress16S(x, y, TEX0.TBP0, TEX0.TBW)], ptr + (x-r.left)*2, dstpitch);
  2416. }
  2417. FOREACH_BLOCK_END
  2418. }
  2419. }
  2421. void GSLocalMemory::unSwizzleTexture8P(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2422. {
  2423. #pragma omp parallel
  2424. {
  2425. #pragma omp for
  2426. FOREACH_BLOCK_START(r, 16, 16, 8)
  2427. {
  2428. unSwizzleBlock8((BYTE*)&m_vm8[blockAddress8(x, y, TEX0.TBP0, TEX0.TBW)], ptr + (x-r.left), dstpitch);
  2429. }
  2430. FOREACH_BLOCK_END
  2431. }
  2432. }
  2434. void GSLocalMemory::unSwizzleTexture8HP(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2435. {
  2436. #pragma omp parallel
  2437. {
  2438. #pragma omp for
  2439. FOREACH_BLOCK_START(r, 8, 8, 32)
  2440. {
  2441. unSwizzleBlock8HP((BYTE*)&m_vm32[blockAddress32(x, y, TEX0.TBP0, TEX0.TBW)], ptr + (x-r.left), dstpitch);
  2442. }
  2443. FOREACH_BLOCK_END
  2444. }
  2445. }
  2447. void GSLocalMemory::unSwizzleTexture4P(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2448. {
  2449. #pragma omp parallel
  2450. {
  2451. #pragma omp for
  2452. FOREACH_BLOCK_START(r, 32, 16, 4)
  2453. {
  2454. unSwizzleBlock4P((BYTE*)&m_vm8[blockAddress4(x, y, TEX0.TBP0, TEX0.TBW)>>1], ptr + (x-r.left), dstpitch);
  2455. }
  2456. FOREACH_BLOCK_END
  2457. }
  2458. }
  2460. void GSLocalMemory::unSwizzleTexture4HLP(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2461. {
  2462. #pragma omp parallel
  2463. {
  2464. #pragma omp for
  2465. FOREACH_BLOCK_START(r, 8, 8, 32)
  2466. {
  2467. unSwizzleBlock4HLP((BYTE*)&m_vm32[blockAddress32(x, y, TEX0.TBP0, TEX0.TBW)], ptr + (x-r.left), dstpitch);
  2468. }
  2469. FOREACH_BLOCK_END
  2470. }
  2471. }
  2473. void GSLocalMemory::unSwizzleTexture4HHP(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2474. {
  2475. #pragma omp parallel
  2476. {
  2477. #pragma omp for
  2478. FOREACH_BLOCK_START(r, 8, 8, 32)
  2479. {
  2480. unSwizzleBlock4HHP((BYTE*)&m_vm32[blockAddress32(x, y, TEX0.TBP0, TEX0.TBW)], ptr + (x-r.left), dstpitch);
  2481. }
  2482. FOREACH_BLOCK_END
  2483. }
  2484. }
  2486. ///////////////////
  2488. void GSLocalMemory::ReadTextureP(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA, GIFRegCLAMP& CLAMP)
  2489. {
  2490. unSwizzleTexture st = m_psmtbl[TEX0.PSM].ustP;
  2491. readTexel rt = m_psmtbl[TEX0.PSM].rtP;
  2492. CSize bs = m_psmtbl[TEX0.PSM].bs;
  2494. if(r.Width() < bs.cx || r.Height() < bs.cy 
  2495. || (r.left & (bs.cx-1)) || (r.top & (bs.cy-1)) 
  2496. || (r.right & (bs.cx-1)) || (r.bottom & (bs.cy-1)) 
  2497. || (CLAMP.WMS&2) || (CLAMP.WMT&2))
  2498. {
  2499. switch(TEX0.PSM)
  2500. {
  2501. default:
  2502. case PSM_PSMCT32:
  2503. case PSM_PSMCT24:
  2504. ReadTexture<DWORD>(r, dst, dstpitch, TEX0, TEXA, CLAMP, rt, st);
  2505. break;
  2506. case PSM_PSMCT16:
  2507. case PSM_PSMCT16S:
  2508. ReadTexture<WORD>(r, dst, dstpitch, TEX0, TEXA, CLAMP, rt, st);
  2509. break;
  2510. case PSM_PSMT8:
  2511. case PSM_PSMT8H:
  2512. case PSM_PSMT4:
  2513. case PSM_PSMT4HL:
  2514. case PSM_PSMT4HH:
  2515. ReadTexture<BYTE>(r, dst, dstpitch, TEX0, TEXA, CLAMP, rt, st);
  2516. break;
  2517. }
  2518. }
  2519. else
  2520. {
  2521. (this->*st)(r, dst, dstpitch, TEX0, TEXA);
  2522. }
  2523. }
  2525. ///////////////////
  2527. void GSLocalMemory::unSwizzleTexture8NP(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2528. {
  2529. #pragma omp parallel
  2530. {
  2531. #pragma omp for
  2532. FOREACH_BLOCK_START(r, 16, 16, 8)
  2533. {
  2534. __declspec(align(16)) BYTE block[16*16];
  2535. unSwizzleBlock8((BYTE*)&m_vm8[blockAddress8(x, y, TEX0.TBP0, TEX0.TBW)], (BYTE*)block, sizeof(block)/16);
  2537. BYTE* s = block;
  2539. if(TEX0.CPSM == PSM_PSMCT32)
  2540. {
  2541. BYTE* d = ptr + (x-r.left)*4;
  2542. for(int j = 0; j < 16; j++, s += 16, d += dstpitch)
  2543. for(int i = 0; i < 16; i++)
  2544. ((DWORD*)d)[i] = m_pCLUT32[s[i]];
  2545. }
  2546. else
  2547. {
  2548. BYTE* d = ptr + (x-r.left)*2;
  2549. for(int j = 0; j < 16; j++, s += 16, d += dstpitch)
  2550. for(int i = 0; i < 16; i++)
  2551. ((WORD*)d)[i] = (WORD)m_pCLUT32[s[i]];
  2552. }
  2553. }
  2554. FOREACH_BLOCK_END
  2555. }
  2556. }
  2558. void GSLocalMemory::unSwizzleTexture8HNP(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2559. {
  2560. #pragma omp parallel
  2561. {
  2562. #pragma omp for
  2563. FOREACH_BLOCK_START(r, 8, 8, 32)
  2564. {
  2565. __declspec(align(16)) DWORD block[8*8];
  2566. unSwizzleBlock32((BYTE*)&m_vm32[blockAddress32(x, y, TEX0.TBP0, TEX0.TBW)], (BYTE*)block, sizeof(block)/8);
  2568. DWORD* s = block;
  2570. if(TEX0.CPSM == PSM_PSMCT32)
  2571. {
  2572. BYTE* d = ptr + (x-r.left)*4;
  2573. for(int j = 0; j < 8; j++, s += 8, d += dstpitch)
  2574. for(int i = 0; i < 8; i++)
  2575. ((DWORD*)d)[i] = m_pCLUT32[s[i] >> 24];
  2576. }
  2577. else
  2578. {
  2579. BYTE* d = ptr + (x-r.left)*2;
  2580. for(int j = 0; j < 8; j++, s += 8, d += dstpitch)
  2581. for(int i = 0; i < 8; i++)
  2582. ((WORD*)d)[i] = (WORD)m_pCLUT32[s[i] >> 24];
  2583. }
  2584. }
  2585. FOREACH_BLOCK_END
  2586. }
  2587. }
  2589. void GSLocalMemory::unSwizzleTexture4NP(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2590. {
  2591. #pragma omp parallel
  2592. {
  2593. #pragma omp for
  2594. FOREACH_BLOCK_START(r, 32, 16, 4)
  2595. {
  2596. __declspec(align(16)) BYTE block[(32/2)*16];
  2597. unSwizzleBlock4((BYTE*)&m_vm8[blockAddress4(x, y, TEX0.TBP0, TEX0.TBW)>>1], (BYTE*)block, sizeof(block)/16);
  2599. BYTE* s = block;
  2601. if(TEX0.CPSM == PSM_PSMCT32)
  2602. {
  2603. BYTE* d = ptr + (x-r.left)*4;
  2604. for(int j = 0; j < 16; j++, s += 32/2, d += dstpitch)
  2605. for(int i = 0; i < 32/2; i++)
  2606. ((UINT64*)d)[i] = m_pCLUT64[s[i]];
  2607. }
  2608. else
  2609. {
  2610. BYTE* d = ptr + (x-r.left)*2;
  2611. for(int j = 0; j < 16; j++, s += 32/2, d += dstpitch)
  2612. for(int i = 0; i < 32/2; i++)
  2613. ((DWORD*)d)[i] = (DWORD)m_pCLUT64[s[i]];
  2614. }
  2615. }
  2616. FOREACH_BLOCK_END
  2617. }
  2618. }
  2620. void GSLocalMemory::unSwizzleTexture4HLNP(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2621. {
  2622. #pragma omp parallel
  2623. {
  2624. #pragma omp for
  2625. FOREACH_BLOCK_START(r, 8, 8, 32)
  2626. {
  2627. __declspec(align(16)) DWORD block[8*8];
  2628. unSwizzleBlock32((BYTE*)&m_vm32[blockAddress32(x, y, TEX0.TBP0, TEX0.TBW)], (BYTE*)block, sizeof(block)/8);
  2630. DWORD* s = block;
  2632. if(TEX0.CPSM == PSM_PSMCT32)
  2633. {
  2634. BYTE* d = ptr + (x-r.left)*4;
  2635. for(int j = 0; j < 8; j++, s += 8, d += dstpitch)
  2636. for(int i = 0; i < 8; i++)
  2637. ((DWORD*)d)[i] = m_pCLUT32[(s[i] >> 24)&0x0f];
  2638. }
  2639. else
  2640. {
  2641. BYTE* d = ptr + (x-r.left)*2;
  2642. for(int j = 0; j < 8; j++, s += 8, d += dstpitch)
  2643. for(int i = 0; i < 8; i++)
  2644. ((WORD*)d)[i] = (WORD)m_pCLUT32[(s[i] >> 24)&0x0f];
  2645. }
  2646. }
  2647. FOREACH_BLOCK_END
  2648. }
  2649. }
  2651. void GSLocalMemory::unSwizzleTexture4HHNP(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA)
  2652. {
  2653. #pragma omp parallel
  2654. {
  2655. #pragma omp for
  2656. FOREACH_BLOCK_START(r, 8, 8, 32)
  2657. {
  2658. __declspec(align(16)) DWORD block[8*8];
  2659. unSwizzleBlock32((BYTE*)&m_vm32[blockAddress32(x, y, TEX0.TBP0, TEX0.TBW)], (BYTE*)block, sizeof(block)/8);
  2661. DWORD* s = block;
  2663. if(TEX0.CPSM == PSM_PSMCT32)
  2664. {
  2665. BYTE* d = ptr + (x-r.left)*4;
  2666. for(int j = 0; j < 8; j++, s += 8, d += dstpitch)
  2667. for(int i = 0; i < 8; i++)
  2668. ((DWORD*)d)[i] = m_pCLUT32[s[i] >> 28];
  2669. }
  2670. else
  2671. {
  2672. BYTE* d = ptr + (x-r.left)*2;
  2673. for(int j = 0; j < 8; j++, s += 8, d += dstpitch)
  2674. for(int i = 0; i < 8; i++)
  2675. ((WORD*)d)[i] = (WORD)m_pCLUT32[s[i] >> 28];
  2676. }
  2677. }
  2678. FOREACH_BLOCK_END
  2679. }
  2680. }
  2682. ///////////////////
  2684. void GSLocalMemory::ReadTextureNP(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA, GIFRegCLAMP& CLAMP)
  2685. {
  2686. unSwizzleTexture st = m_psmtbl[TEX0.PSM].ustNP;
  2687. readTexel rt = m_psmtbl[TEX0.PSM].rtNP;
  2689. CSize bs = m_psmtbl[TEX0.PSM].bs;
  2691. if(r.Width() < bs.cx || r.Height() < bs.cy 
  2692. || (r.left & (bs.cx-1)) || (r.top & (bs.cy-1)) 
  2693. || (r.right & (bs.cx-1)) || (r.bottom & (bs.cy-1)) 
  2694. || (CLAMP.WMS&2) || (CLAMP.WMT&2))
  2695. {
  2696. switch(TEX0.PSM)
  2697. {
  2698. default:
  2699. case PSM_PSMCT32:
  2700. case PSM_PSMCT24:
  2701. ReadTexture<DWORD>(r, dst, dstpitch, TEX0, TEXA, CLAMP, rt, st);
  2702. break;
  2703. case PSM_PSMCT16:
  2704. case PSM_PSMCT16S:
  2705. ReadTexture<WORD>(r, dst, dstpitch, TEX0, TEXA, CLAMP, rt, st);
  2706. break;
  2707. case PSM_PSMT8:
  2708. case PSM_PSMT8H:
  2709. case PSM_PSMT4:
  2710. case PSM_PSMT4HL:
  2711. case PSM_PSMT4HH:
  2712. switch(TEX0.CPSM)
  2713. {
  2714. default:
  2715. case PSM_PSMCT32:
  2716. ReadTexture<DWORD>(r, dst, dstpitch, TEX0, TEXA, CLAMP, rt, st);
  2717. break;
  2718. case PSM_PSMCT16:
  2719. case PSM_PSMCT16S:
  2720. ReadTexture<WORD>(r, dst, dstpitch, TEX0, TEXA, CLAMP, rt, st);
  2721. break;
  2722. }
  2723. break;
  2724. }
  2725. }
  2726. else
  2727. {
  2728. (this->*st)(r, dst, dstpitch, TEX0, TEXA);
  2729. }
  2730. }
  2732. //
  2734. template<typename DstT> 
  2735. void GSLocalMemory::ReadTexture(const CRect& r, BYTE* dst, int dstpitch, GIFRegTEX0& TEX0, GIFRegTEXA& TEXA, GIFRegCLAMP& CLAMP, readTexel rt, unSwizzleTexture st)
  2736. {
  2737. // this function is not thread safe!
  2739. CSize bs = m_psmtbl[TEX0.PSM].bs;
  2741. CRect cr(
  2742. (r.left + (bs.cx-1)) & ~(bs.cx-1), 
  2743. (r.top + (bs.cy-1)) & ~(bs.cy-1), 
  2744. r.right & ~(bs.cx-1), 
  2745. r.bottom & ~(bs.cy-1));
  2747. bool fAligned = ((DWORD_PTR)(dst + (cr.left-r.left)*sizeof(DstT)) & 0xf) == 0;
  2749. if((CLAMP.WMS&2) || (CLAMP.WMT&2))
  2750. {
  2751. DWORD wms = CLAMP.WMS, wmt = CLAMP.WMT;
  2752. DWORD minu = CLAMP.MINU, maxu = CLAMP.MAXU;
  2753. DWORD minv = CLAMP.MINV, maxv = CLAMP.MAXV;
  2755. switch(wms)
  2756. {
  2757. default: for(int x = r.left; x < r.right; x++) m_xtbl[x] = x; break;
  2758. case 2: for(int x = r.left; x < r.right; x++) m_xtbl[x] = x < minu ? minu : x > maxu ? maxu : x; break;
  2759. case 3: for(int x = r.left; x < r.right; x++) m_xtbl[x] = (x & minu) | maxu; break;
  2760. }
  2762. switch(wmt)
  2763. {
  2764. default: for(int y = r.top; y < r.bottom; y++) m_ytbl[y] = y; break;
  2765. case 2: for(int y = r.top; y < r.bottom; y++) m_ytbl[y] = y < minv ? minv : y > maxv ? maxv : y;  break;
  2766. case 3: for(int y = r.top; y < r.bottom; y++) m_ytbl[y] = (y & minv) | maxv; break;
  2767. }
  2769. if(fAligned && wms <= 2 && wmt <= 2)
  2770. {
  2771. // TODO: read clamped areas only once
  2773. for(int y = r.top; y < cr.top; y++, dst += dstpitch)
  2774. for(int x = r.left, i = 0; x < r.right; x++, i++)
  2775. ((DstT*)dst)[i] = (DstT)(this->*rt)(m_xtbl[x], m_ytbl[y], TEX0, TEXA);
  2777. if(!cr.IsRectEmpty())
  2778. (this->*st)(cr, dst + (cr.left - r.left)*sizeof(DstT), dstpitch, TEX0, TEXA);
  2780. for(int y = cr.top; y < cr.bottom; y++, dst += dstpitch)
  2781. {
  2782. for(int x = r.left, i = 0; x < cr.left; x++, i++)
  2783. ((DstT*)dst)[i] = (DstT)(this->*rt)(m_xtbl[x], m_ytbl[y], TEX0, TEXA);
  2784. for(int x = cr.right, i = x - r.left; x < r.right; x++, i++)
  2785. ((DstT*)dst)[i] = (DstT)(this->*rt)(m_xtbl[x], m_ytbl[y], TEX0, TEXA);
  2786. }
  2788. for(int y = cr.bottom; y < r.bottom; y++, dst += dstpitch)
  2789. for(int x = r.left, i = 0; x < r.right; x++, i++)
  2790. ((DstT*)dst)[i] = (DstT)(this->*rt)(m_xtbl[x], m_ytbl[y], TEX0, TEXA);
  2791. }
  2792. else
  2793. {
  2794. for(int y = r.top; y < r.bottom; y++, dst += dstpitch)
  2795. for(int x = r.left, i = 0; x < r.right; x++, i++)
  2796. ((DstT*)dst)[i] = (DstT)(this->*rt)(m_xtbl[x], m_ytbl[y], TEX0, TEXA);
  2797. }
  2798. }
  2799. else
  2800. {
  2801. if(fAligned)
  2802. {
  2803. for(int y = r.top; y < cr.top; y++, dst += dstpitch)
  2804. for(int x = r.left, i = 0; x < r.right; x++, i++)
  2805. ((DstT*)dst)[i] = (DstT)(this->*rt)(x, y, TEX0, TEXA);
  2807. if(!cr.IsRectEmpty())
  2808. (this->*st)(cr, dst + (cr.left - r.left)*sizeof(DstT), dstpitch, TEX0, TEXA);
  2810. for(int y = cr.top; y < cr.bottom; y++, dst += dstpitch)
  2811. {
  2812. for(int x = r.left, i = 0; x < cr.left; x++, i++)
  2813. ((DstT*)dst)[i] = (DstT)(this->*rt)(x, y, TEX0, TEXA);
  2814. for(int x = cr.right, i = x - r.left; x < r.right; x++, i++)
  2815. ((DstT*)dst)[i] = (DstT)(this->*rt)(x, y, TEX0, TEXA);
  2816. }
  2818. for(int y = cr.bottom; y < r.bottom; y++, dst += dstpitch)
  2819. for(int x = r.left, i = 0; x < r.right; x++, i++)
  2820. ((DstT*)dst)[i] = (DstT)(this->*rt)(x, y, TEX0, TEXA);
  2821. }
  2822. else
  2823. {
  2824. for(int y = r.top; y < r.bottom; y++, dst += dstpitch)
  2825. for(int x = r.left, i = 0; x < r.right; x++, i++)
  2826. ((DstT*)dst)[i] = (DstT)(this->*rt)(x, y, TEX0, TEXA);
  2827. }
  2828. }
  2829. }
  2831. //
  2833. HRESULT GSLocalMemory::SaveBMP(IDirect3DDevice9* pDev, LPCTSTR fn, DWORD bp, DWORD bw, DWORD psm, int w, int h)
  2834. {
  2835. CComPtr<IDirect3DTexture9> pTexture;
  2836. D3DLOCKED_RECT lr;
  2837. HRESULT hr = pDev->CreateTexture(w, h, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &pTexture, NULL);
  2838. if(FAILED(hr) || FAILED(pTexture->LockRect(0, &lr, NULL, 0))) return E_FAIL;
  2840. readTexel rt = m_psmtbl[psm].rt;
  2841. GIFRegTEX0 TEX0;
  2842. TEX0.TBP0 = bp;
  2843. TEX0.TBW = bw;
  2844. TEX0.PSM = psm;
  2845. GIFRegTEXA TEXA;
  2846. TEXA.AEM = 0;
  2847. TEXA.TA0 = 0;
  2848. TEXA.TA1 = 0x80;
  2850. BYTE* p = (BYTE*)lr.pBits;
  2852. for(int j = 0; j < h; j++, p += lr.Pitch)
  2853. for(int i = 0; i < w; i++)
  2854. ((DWORD*)p)[i] = (this->*rt)(i, j, TEX0, TEXA);
  2856. pTexture->UnlockRect(0);
  2858. return D3DXSaveTextureToFile(fn, D3DXIFF_BMP, pTexture, NULL);
  2859. }