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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
blit_wmmx_fix.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：21k
源码类别：

Windows CE

开发平台：

C/C++

blit_wmmx_fix.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: blit_wmmx_fix.c 271 2005-08-09 08:31:35Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common.h"
  25. #include "../dyncode/dyncode.h"
  26. #include "blit_soft.h"
  28. // RScale==16 && !SwapXY 8x2 -> 8x2
  29. // RScale==16 && SwapXY 2x8 -> 8x2
  30. // RScale==8  && !SwapXY 8x2 -> 16x4
  31. // RScale==8  && SwapXY 2x8 -> 16x4
  32. // RScale==32 && !SwapXY 16x4 -> 8x2
  33. // RScale==32 && SwapXY 4x16 -> 8x2
  35. #if defined(ARM) 
  37. typedef struct stack
  38. {
  39. int EndOfRect;
  40. int DstNext;
  41. int SrcNext;
  42. int UVNext;
  44. int StackFrame[STACKFRAME];
  46. //void* this   R0
  47. //char* Dst    R1
  48. //char* Src    R2
  49. //int DstPitch R3 can be signed
  50. int SrcPitch; //can be signed
  51. int Width; 
  52. int Height;
  53. int Src2SrcLast;
  54. } stack;
  56. // r0 bmask (if bpos!=0)
  57. // r1 temp
  58. // r2 dst1 (dst+dstpitch*DoubleY or dst+8*DoubleX*DirX)
  59. // r3 u (-=4 if !swapxy)
  60. // r4 v (-=4 if !swapxy)
  61. // r5..r7 temp
  62. // r8 endofline
  63. // r9 dst0
  64. // r10 dstpitch
  65. // r11 srcpitch
  66. // r12 y0
  67. // r14 y1 (y0+(srchalfy?2:1)*srcpitch)
  69. // wr0..wr2 r0,g0,b0 (from uv)
  70. // wr3..wr5 temp1 (r,g,b)
  71. // wr6..wr8 temp2 (r,g,b)
  72. // wr9,wr10 mask r,g
  73. // wr11 radd (if !dither)
  74. // wr12 gadd (if !dither)
  75. // wr13 badd (if !dither)
  76. // wr11 radd,gadd,badd (if dither)
  77. // wr12,wr13 dither
  78. // wr14 rvmul,gumul,gvmul,bumul
  79. // wr15 ymul
  81. // wcgr0 abs(rpos-8)
  82. // wcgr1 abs(gpos-8)
  83. // wcgr2 abs(bpos-8)
  84. // wcgr3 8 (if HalfMode)
  86. // using: wr0,wr1,wr2,wr6,wr7
  87. static void Fix_UVSwapXY(blit_soft* p,bool_t HalfMode,bool_t Part,bool_t Row,reg Src,reg Dst)
  88. {
  89. if (p->DstHalfY && Part)
  90. {
  91. Byte(); I3S(LDR_POSTSUB,R7,Src,R11,ASR,1); //3
  92. Byte(); I3S(LDR_POSTSUB,R1,Src,R11,ASR,1); //2
  93. Byte(); I3S(LDR_POSTSUB,R6,Src,R11,ASR,1); //1
  94. Byte(); I2C(LDR_POST,R5,Src,Row?1:-1); //0
  96. I2C(TINSRB,Dst,R7,p->DirX>0?7:1);
  97. I2C(TINSRB,Dst,R1,p->DirX>0?5:3);
  98. I2C(TINSRB,Dst,R6,p->DirX>0?3:5);
  99. I2C(TINSRB,Dst,R5,p->DirX>0?1:7);
  101. if (p->SrcHalfY)
  102. I3S(Row?SUB:ADD,Src,Src,R11,LSL,1); // 4 rows
  103. }
  104. else
  105. if (p->DstHalfY && !Part)
  106. {
  107. Byte(); I3S(LDR_POST,R5,Src,R11,ASR,1); //0
  108. Byte(); I3S(LDR_POST,R6,Src,R11,ASR,1); //1
  109. Byte(); I3S(LDR_POST,R1,Src,R11,ASR,1); //2
  110. Byte(); I2C(LDR_POST,R7,Src,1); //3
  112. I2C(TINSRB,Dst,R5,p->DirX>0?1:7);
  113. I2C(TINSRB,Dst,R6,p->DirX>0?3:5);
  114. I2C(TINSRB,Dst,R1,p->DirX>0?5:3);
  115. I2C(TINSRB,Dst,R7,p->DirX>0?7:1);
  116. }
  117. else
  118. {
  119. Byte(); I3S(LDR_POST,R5,Src,R11,ASR,1); //0
  120. Byte(); I3S(LDR_POST,R6,Src,R11,ASR,0); //1
  121. Byte(); I3S(LDR_POSTSUB,R7,Src,R11,ASR,1); //3
  122. Byte(); I3S(LDR_POSTSUB,R1,Src,R11,ASR,0); //2
  124. I2C(TINSRB,Dst,R5,p->DirX>0?1:3);
  125. I2C(TINSRB,Dst,R6,p->DirX>0?3:1);
  126. I2C(TINSRB,Dst,R7,p->DirX>0?7:5);
  127. I2C(TINSRB,Dst,R1,p->DirX>0?5:7);
  129. I2C(ADD,Src,Src,1);
  130. }
  131. }
  133. static void Fix_UV(blit_soft* p,bool_t HalfMode,bool_t Part,bool_t Row)
  134. {
  135. if (p->SwapXY)
  136. {
  137. Fix_UVSwapXY(p,HalfMode,Part,Row,R3,WR6);
  138. Fix_UVSwapXY(p,HalfMode,Part,Row,R4,WR7);
  139. }
  140. else
  141. {
  142. if (p->DstHalfY && Part)
  143. {
  144. // one uv row below
  145. MB(); I3S(ADD,R5,R3,R11,ASR,1);
  146. MB(); I3S(ADD,R6,R4,R11,ASR,1);
  147. MB(); I2C(WLDRW,WR6,R5,0);
  148. MB(); I2C(WLDRW,WR7,R6,0);
  149. }
  150. else
  151. {
  152. int Pre = (HalfMode && !p->SrcHalfX && Row)?0:4;
  153. MB(); I2C(WLDRW_PRE,WR6,R3,Pre);
  154. MB(); I2C(WLDRW_PRE,WR7,R4,Pre);
  155. }
  157. I3(WUNPCKILB,WR6,WR6,WR6);
  158. I3(WUNPCKILB,WR7,WR7,WR7);
  160. if (p->DirX<0)
  161. {
  162. I2C(WSHUFH,WR6,WR6,p->SrcHalfY?0x1B:0xB1); //swap order (2:2)
  163. I2C(WSHUFH,WR7,WR7,p->SrcHalfY?0x1B:0xB1); //swap order (2:2)
  164. }
  165. }
  167. if (HalfMode && !p->DstHalfX)
  168. {
  169. I3(Row==(p->DirX>0)?WUNPCKIHH:WUNPCKILH,WR6,WR6,WR6);
  170. I3(Row==(p->DirX>0)?WUNPCKIHH:WUNPCKILH,WR7,WR7,WR7);
  171. }
  173. //WR6 U
  174. //WR7 V
  176. I2C(WSHUFH,WR1,WR14,0x55); //gumul
  177. I3(WMULUM,WR1,WR1,WR6);
  178. I2C(WSHUFH,WR2,WR14,0xFF); //bumul
  179. I3(WMULUM,WR2,WR2,WR6);
  180. I2C(WSHUFH,WR6,WR14,0xAA); //gvmul
  181. I3(WMULUM,WR6,WR6,WR7);
  182. I2C(WSHUFH,WR0,WR14,0x00); //rvmul
  183. I3(WMULUM,WR0,WR0,WR7);
  184. I3((p->_GUMul<0)^(p->_GVMul<0)?WSUBH:WADDH,WR1,WR1,WR6);
  186. //WR0 R
  187. //WR1 G
  188. //WR2 B
  190. if (p->FX.Flags & BLITFX_DITHER)
  191. {
  192. I2C(WSHUFH,WR6,WR11,0x00); //radd
  193. I2C(WSHUFH,WR7,WR11,0x55); //gadd
  194. I3(p->_RVMul<0?WSUBH:WADDH,WR0,WR6,WR0);
  195. I2C(WSHUFH,WR6,WR11,0xAA); //badd
  196. I3(p->_GUMul<0?WSUBH:WADDH,WR1,WR7,WR1);
  197. I3(p->_BUMul<0?WSUBH:WADDH,WR2,WR6,WR2);
  198. }
  199. else
  200. {
  201. I3(p->_RVMul<0?WSUBH:WADDH,WR0,WR11,WR0);
  202. I3(p->_GUMul<0?WSUBH:WADDH,WR1,WR12,WR1);
  203. I3(p->_BUMul<0?WSUBH:WADDH,WR2,WR13,WR2);
  204. }
  205. }
  207. static void Fix_Y(blit_soft* p,bool_t Row,int Col,bool_t HalfMode)
  208. {
  209. // load to upper 8bits (doesn't matter what is in the lower 8 bits)
  210. // load y0 wr5
  211. // load y1 wr8
  212. reg Dither;
  213. int AddY;
  215. if (p->SwapXY)
  216. {
  217. Dither = (reg)(Col?WR13:WR12);
  219. if (p->ArithStretch && p->SrcHalfX && p->SrcHalfY)
  220. { 
  221. I3(LDR_POST,R5,R12,R11);
  222. I3(LDR_POST,R6,R12,R11);
  223. I3(LDR_POST,R7,R12,R11);
  224. I3(LDR_POST,R1,R12,R11);
  225. I2C(TINSRH,WR5,R5,p->DirX>0?0:3);
  226. I2C(TINSRH,WR6,R6,p->DirX>0?0:3);
  227. I2C(TINSRH,WR5,R7,p->DirX>0?1:2);
  228. I2C(TINSRH,WR6,R1,p->DirX>0?1:2);
  229. I3S(MOV,R5,NONE,R5,LSR,16);
  230. I3S(MOV,R6,NONE,R6,LSR,16);
  231. I3S(MOV,R7,NONE,R7,LSR,16);
  232. I3S(MOV,R1,NONE,R1,LSR,16);
  233. I2C(TINSRH,WR8,R5,p->DirX>0?0:3);
  234. I2C(TINSRH,WR7,R6,p->DirX>0?0:3);
  235. I2C(TINSRH,WR8,R7,p->DirX>0?1:2);
  236. I2C(TINSRH,WR7,R1,p->DirX>0?1:2);
  237. I3(LDR_POST,R5,R12,R11);
  238. I3(LDR_POST,R6,R12,R11);
  239. I3(LDR_POST,R7,R12,R11);
  240. I3(LDR_POST,R1,R12,R11);
  241. I2C(TINSRH,WR5,R5,p->DirX>0?2:1);
  242. I2C(TINSRH,WR6,R6,p->DirX>0?2:1);
  243. I2C(TINSRH,WR5,R7,p->DirX>0?3:0);
  244. I2C(TINSRH,WR6,R1,p->DirX>0?3:0);
  245. I3S(MOV,R5,NONE,R5,LSR,16);
  246. I3S(MOV,R6,NONE,R6,LSR,16);
  247. I3S(MOV,R7,NONE,R7,LSR,16);
  248. I3S(MOV,R1,NONE,R1,LSR,16);
  249. I2C(TINSRH,WR8,R5,p->DirX>0?2:1);
  250. I2C(TINSRH,WR7,R6,p->DirX>0?2:1);
  251. I2C(TINSRH,WR8,R7,p->DirX>0?3:0);
  252. I2C(TINSRH,WR7,R1,p->DirX>0?3:0);
  254. I3(WAVG2B,WR5,WR5,WR6);
  255. I3(WSLLHG,WR6,WR5,WCGR3);
  256. I3(WAVG2B,WR8,WR8,WR7);
  257. I3(WSLLHG,WR7,WR8,WCGR3);
  258. I3(WAVG2B,WR5,WR5,WR6);
  259. I3(WAVG2B,WR8,WR8,WR7);
  260. }
  261. else
  262. if (p->SrcHalfX)
  263. {
  264. reg Add = R11;
  265. if (p->SrcHalfY)
  266. {
  267. I3(ADD,R1,R11,R11);
  268. Add = R1;
  269. }
  271. I3(LDR_POST,R5,R12,Add);
  272. I3(LDR_POST,R6,R12,Add);
  273. I3(LDR_POST,R7,R12,Add);
  274. I3(LDR_POST,R1,R12,Add);
  275. I2C(TINSRH,WR5,R5,p->DirX>0?0:3);
  276. I2C(TINSRH,WR5,R6,p->DirX>0?1:2);
  277. I2C(TINSRH,WR5,R7,p->DirX>0?2:1);
  278. I2C(TINSRH,WR5,R1,p->DirX>0?3:0);
  279. I3S(MOV,R5,NONE,R5,LSR,16);
  280. I3S(MOV,R6,NONE,R6,LSR,16);
  281. I3S(MOV,R7,NONE,R7,LSR,16);
  282. I3S(MOV,R1,NONE,R1,LSR,16);
  283. I2C(TINSRH,WR8,R5,p->DirX>0?0:3);
  284. I2C(TINSRH,WR8,R6,p->DirX>0?1:2);
  285. I2C(TINSRH,WR8,R7,p->DirX>0?2:1);
  286. I2C(TINSRH,WR8,R1,p->DirX>0?3:0);
  287. }
  288. else
  289. {
  290. reg Add = R11;
  291. if (p->SrcHalfY)
  292. {
  293. I3(ADD,R1,R11,R11);
  294. Add = R1;
  295. }
  297. Half(); I3(LDR_POST,R5,R12,Add);
  298. Half(); I3(LDR_POST,R6,R12,Add);
  299. Half(); I3(LDR_POST,R7,R12,Add);
  300. Half(); I3(LDR_POST,R1,R12,Add);
  301. I2C(TINSRB,WR5,R5,p->DirX>0?1:7);
  302. I2C(TINSRH,WR8,R5,p->DirX>0?0:3);
  303. I2C(TINSRB,WR5,R6,p->DirX>0?3:5);
  304. I2C(TINSRH,WR8,R6,p->DirX>0?1:2);
  305. I2C(TINSRB,WR5,R7,p->DirX>0?5:3);
  306. I2C(TINSRH,WR8,R7,p->DirX>0?2:1);
  307. I2C(TINSRB,WR5,R1,p->DirX>0?7:1);
  308. I2C(TINSRH,WR8,R1,p->DirX>0?3:0);
  309. }
  311. if (Row)
  312. {
  313. I3S(SUB,R12,R12,R11,LSL,3+p->SrcHalfY);
  314. I2C(ADD,R12,R12,2 << p->SrcHalfX);
  315. }
  316. }
  317. else
  318. {
  319. Dither = WR12;
  320. if (p->ArithStretch && p->SrcHalfX && p->SrcHalfY)
  321. { 
  322. MB(); I3(ADD,R1,R12,R11);
  323. MB(); I3(ADD,R5,R14,R11);
  324. MB(); I2C(WLDRD_POST,WR5,R12,8);
  325. MB(); I2C(WLDRD,WR6,R1,0);
  326. MB(); I2C(WLDRD_POST,WR8,R14,8);
  327. MB(); I2C(WLDRD,WR7,R5,0);
  329. I3(WAVG2B,WR5,WR5,WR6);
  330. I3(WSLLHG,WR6,WR5,WCGR3);
  331. I3(WAVG2B,WR8,WR8,WR7);
  332. I3(WSLLHG,WR7,WR8,WCGR3);
  333. I3(WAVG2B,WR5,WR5,WR6);
  334. I3(WAVG2B,WR8,WR8,WR7);
  335. }
  336. else
  337. if (p->SrcHalfX)
  338. {
  339. MB(); I2C(WLDRD_POST,WR5,R12,8); // use only every second pixel
  340. MB(); I2C(WLDRD_POST,WR8,R14,8); // use only every second pixel
  341. }
  342. else
  343. {
  344. MB(); I2C(WLDRW_POST,WR5,R12,4);
  345. MB(); I2C(WLDRW_POST,WR8,R14,4);
  346. I3(WUNPCKILB,WR5,WR5,WR5);
  347. I3(WUNPCKILB,WR8,WR8,WR8);
  348. }
  350. if (p->DirX<0)
  351. {
  352. I2C(WSHUFH,WR8,WR8,0x1B); //swap order
  353. I2C(WSHUFH,WR5,WR5,0x1B); //swap order
  354. }
  355. }
  357. MB(); I3(WMULUM,WR5,WR5,WR15);
  358. MB(); I3(WMULUM,WR8,WR8,WR15);
  360. AddY = p->_YMul>=0?WADDH:WSUBH;
  362. if (HalfMode)
  363. {
  364. Fix_UV(p,HalfMode,0,Row); 
  366. I3(AddY,WR3,WR0,WR5);
  367. I3(AddY,WR4,WR1,WR5);
  368. I3(AddY,WR5,WR2,WR5);
  370. if (p->DstHalfY)
  371. Fix_UV(p,HalfMode,1,Row);
  373. I3(AddY,WR6,WR0,WR8);
  374. I3(AddY,WR7,WR1,WR8);
  375. I3(AddY,WR8,WR2,WR8);
  377. I3(WPACKHUS,WR3,WR3,WR6);
  378. I3(WPACKHUS,WR4,WR4,WR7);
  379. I3(WPACKHUS,WR5,WR5,WR8);
  380. }
  381. else
  382. {
  383. // WR0,WR1,WR2 already has UV information
  385. I3(Row?WUNPCKIHH:WUNPCKILH,WR6,WR0,WR0);
  386. I3(Row?WUNPCKIHH:WUNPCKILH,WR7,WR1,WR1);
  388. I3(AddY,WR3,WR6,WR5);
  389. I3(AddY,WR4,WR7,WR5);
  390. I3(AddY,WR6,WR6,WR8);
  391. I3(AddY,WR7,WR7,WR8);
  392. I3(WPACKHUS,WR3,WR3,WR6);
  393. I3(WPACKHUS,WR4,WR4,WR7);
  395. MB(); I3(Row?WUNPCKIHH:WUNPCKILH,WR6,WR2,WR2);
  396. I3(AddY,WR5,WR6,WR5);
  397. I3(AddY,WR8,WR6,WR8);
  398. I3(WPACKHUS,WR5,WR5,WR8);
  399. }
  401. if (p->FX.Flags & BLITFX_DITHER)
  402. {
  403. if (p->DstSize[0] > p->DitherSize || p->DstSize[1] > p->DitherSize || p->DstSize[2] > p->DitherSize)
  404. {
  405. MB(); I3(WXOR,WR6,WR6,WR6);
  406. I3(WAVG2B,WR6,WR6,Dither);
  407. }
  409. I3(WADDBUS,WR3,WR3,(reg)(p->DstSize[0] > p->DitherSize ? WR6:Dither));
  410. I3(WADDBUS,WR4,WR4,(reg)(p->DstSize[1] > p->DitherSize ? WR6:Dither));
  411. I3(WADDBUS,WR5,WR5,(reg)(p->DstSize[2] > p->DitherSize ? WR6:Dither));
  412. }
  414. if (p->DstPos[2]==0 && p->DstPos[0]+p->DstSize[0]==16)
  415. {
  416. // special optimized case for rgb565
  417. // (red and blue word mask in WR9)
  419. I3(WAND,WR4,WR4,WR10);
  420. I3(WSRLDG,WR5,WR5,WCGR2);
  422. I2(WUNPCKEHUB,WR7,WR4);
  423. I3(WUNPCKIHB,WR6,WR5,WR3);
  424. I3(WSLLWG,WR7,WR7,WCGR1);
  425. I3(WAND,WR6,WR6,WR9); 
  426. I3(WOR,WR6,WR6,WR7);
  428. I2(WUNPCKELUB,WR4,WR4);
  429. I3(WUNPCKILB,WR3,WR5,WR3);
  430. I3(WSLLWG,WR4,WR4,WCGR1);
  431. I3(WAND,WR3,WR3,WR9);
  432. I3(WOR,WR3,WR3,WR4);
  433. }
  434. else
  435. {
  436. if (p->DstPos[0]!=0) I3(WAND,WR3,WR3,WR9);
  437. if (p->DstPos[1]!=0) I3(WAND,WR4,WR4,WR10);
  438. if (p->DstPos[2]!=0) 
  439. {
  440. I2(TBCSTH,WR6,R0);
  441. I3(WAND,WR5,WR5,WR6);
  442. }
  444. I2(WUNPCKEHUB,WR6,WR3);
  445. I2(WUNPCKEHUB,WR7,WR4);
  446. I2(WUNPCKEHUB,WR8,WR5);
  448. if (p->DstPos[0]+p->DstSize[0]!=8) I3(p->DstPos[0]+p->DstSize[0]>8?WSLLWG:WSRLWG,WR6,WR6,WCGR0);
  449. if (p->DstPos[1]+p->DstSize[1]!=8) I3(p->DstPos[1]+p->DstSize[1]>8?WSLLWG:WSRLWG,WR7,WR7,WCGR1);
  450. if (p->DstPos[2]+p->DstSize[2]!=8) I3(p->DstPos[2]+p->DstSize[2]>8?WSLLWG:WSRLWG,WR8,WR8,WCGR2);
  452. I2(WUNPCKELUB,WR3,WR3);
  453. I2(WUNPCKELUB,WR4,WR4);
  454. I2(WUNPCKELUB,WR5,WR5);
  456. if (p->DstPos[0]+p->DstSize[0]!=8) I3(p->DstPos[0]+p->DstSize[0]>8?WSLLWG:WSRLWG,WR3,WR3,WCGR0);
  457. if (p->DstPos[1]+p->DstSize[1]!=8) I3(p->DstPos[1]+p->DstSize[1]>8?WSLLWG:WSRLWG,WR4,WR4,WCGR1);
  458. if (p->DstPos[2]+p->DstSize[2]!=8) I3(p->DstPos[2]+p->DstSize[2]>8?WSLLWG:WSRLWG,WR5,WR5,WCGR2);
  460. I3(WOR,WR6,WR6,WR7);
  461. I3(WOR,WR3,WR3,WR4);
  462. I3(WOR,WR6,WR6,WR8);
  463. I3(WOR,WR3,WR3,WR5);
  464. }
  466. if (p->DstDoubleX)
  467. {
  468. I2C(WSHUFH,WR7,WR6,0xFA); // 7 7 6 6
  469. I2C(WSHUFH,WR4,WR3,0xFA); // 3 3 2 2
  470. I2C(WSHUFH,WR6,WR6,0x50); // 5 5 4 4
  471. I2C(WSHUFH,WR3,WR3,0x50); // 1 1 0 0
  472. }
  474. if (p->SwapXY)
  475. {
  476. reg Dst = (reg)(Row?R2:R9);
  478. MB(); I3S(ADD,R1,Dst,R10,LSL,p->DstDoubleY);
  480. MB(); I2C(WSTRD,WR3,Dst,0);
  481. if (p->DstDoubleX)
  482. {
  483. MB(); I2C(WSTRD,WR4,Dst,8);
  484. }
  486. if (p->DstDoubleY)
  487. {
  488. MB(); I3(ADD,R5,Dst,R10);
  490. MB(); I2C(WSTRD,WR3,R5,0);
  491. if (p->DstDoubleX)
  492. {
  493. MB(); I2C(WSTRD,WR4,R5,8);
  494. }
  495. }
  497. MB(); I2C(WSTRD,WR6,R1,0);
  498. if (p->DstDoubleX)
  499. {
  500. MB(); I2C(WSTRD,WR7,R1,8);
  501. }
  503. if (p->DstDoubleY)
  504. {
  505. MB(); I3(ADD,R6,R1,R10);
  507. MB(); I2C(WSTRD,WR6,R6,0);
  508. if (p->DstDoubleX)
  509. {
  510. MB(); I2C(WSTRD,WR7,R6,8);
  511. }
  512. }
  514. MB(); I3S(ADD,Dst,Dst,R10,LSL,1+p->DstDoubleY);
  515. }
  516. else
  517. {
  518. if (p->DstDoubleY)
  519. {
  520. MB(); I3(ADD,R1,R2,R10);
  521. MB(); I3(ADD,R5,R9,R10);
  522. }
  524. if (p->DstDoubleX)
  525. {
  526. MB(); I2C(WSTRD_POST,WR6,R2,8);
  527. MB(); I2C(WSTRD_POST,WR3,R9,8);
  528. }
  529. else
  530. {
  531. MB(); I2C(WSTRD_POST,WR6,R2,8*p->DirX);
  532. MB(); I2C(WSTRD_POST,WR3,R9,8*p->DirX);
  533. }
  535. if (p->DstDoubleY)
  536. {
  537. MB(); I2C(WSTRD,WR6,R1,0);
  538. MB(); I2C(WSTRD,WR3,R5,0);
  539. }
  541. if (p->DstDoubleX)
  542. {
  543. MB(); I2C(WSTRD_POST,WR7,R2,p->DirX>0?8:-24);
  544. MB(); I2C(WSTRD_POST,WR4,R9,p->DirX>0?8:-24);
  546. if (p->DstDoubleY)
  547. {
  548. MB(); I2C(WSTRD,WR7,R1,8);
  549. MB(); I2C(WSTRD,WR4,R5,8);
  550. }
  551. }
  552. }
  553. }
  555. void WMMXFix_RGB_UV(blit_soft* p)
  556. {
  557. bool_t HalfMode = p->SrcHalfX || p->SrcHalfY;
  558. dyninst* LoopY;
  559. dyninst* LoopX;
  560. dyninst* EndLine;
  561. dyninst* Dither = NULL;
  563. p->SrcAlignPos = p->DstAlignPos = p->DstAlignSize = 8;
  564. if (p->RScaleX==8) p->DstAlignSize = 16;
  566. p->DstStepX = p->DirX * ((p->DstBPP*8) >> 3) << p->DstDoubleX;
  568. p->YMul = InstCreate16(abs(p->_YMul) >> 8,NONE,NONE,NONE,0,0);
  569. p->RVMul = InstCreate16(abs(p->_RVMul) >> 8,NONE,NONE,NONE,0,0);
  570. p->RAdd = InstCreate16((p->_RAdd) >> 16,NONE,NONE,NONE,0,0);
  571. p->GUMul = InstCreate16(abs(p->_GUMul) >> 8,NONE,NONE,NONE,0,0);
  572. p->GVMul = InstCreate16(abs(p->_GVMul) >> 8,NONE,NONE,NONE,0,0);
  573. p->GAdd = InstCreate16((p->_GAdd) >> 16,NONE,NONE,NONE,0,0);
  574. p->BUMul = InstCreate16(abs(p->_BUMul) >> 8,NONE,NONE,NONE,0,0);
  575. p->BAdd = InstCreate16((p->_BAdd) >> 16,NONE,NONE,NONE,0,0);
  577. CodeBegin();
  578. I2C(SUB,SP,SP,OFS(stack,StackFrame));
  580. I1P(WLDRD,WR11,p->RAdd,0);
  581. I1P(WLDRD,WR14,p->RVMul,0);
  583. I3(MOV,R10,NONE,R3); //DstPitch
  584. I2C(LDR,R9,R1,0); //Dst[0] RGB
  585. I2C(LDR,R3,R2,4); //Src[1] U
  586. I2C(LDR,R4,R2,8); //Src[2] V
  587. I2C(LDR,R12,R2,0); //Src[0] Y
  588. I2C(LDR,R11,SP,OFS(stack,SrcPitch));
  590. I2C(WSHUFH,WR15,WR11,0xFF); //ymul
  591. if (!(p->FX.Flags & BLITFX_DITHER))
  592. {
  593. I2C(WSHUFH,WR12,WR11,0x55); //gadd
  594. I2C(WSHUFH,WR13,WR11,0xAA); //badd
  595. I2C(WSHUFH,WR11,WR11,0x00); //radd
  596. }
  597. else
  598. {
  599. int i;
  600. static const uint8_t Matrix0[16] = 
  601. { 0,   8,  2, 10,
  602. 12,  4, 14,  6,
  603. 3,  11,  1,  9,
  604. 15,  7, 13,  5 };
  606. uint8_t Matrix[16];
  607. memcpy(Matrix,Matrix0,sizeof(Matrix));
  608. p->DitherSize = min(p->DstSize[0],min(p->DstSize[1],p->DstSize[2]));
  609. if (p->DitherSize>4)
  610. for (i=0;i<16;++i)
  611. Matrix[i] >>= p->DitherSize-4;
  613. // dither mask
  614. Dither = InstCreate(Matrix,16,NONE,NONE,NONE,0,0);
  615. I1P(WLDRD,WR12,Dither,0);
  616. I1P(WLDRD,WR13,Dither,8);
  617. }
  619.   I2C(LDR,R5,SP,OFS(stack,Height));
  620. I2C(LDR,R6,SP,OFS(stack,Width));
  622. //SrcNext = 2*(SrcHalfY?2:1)*(SwapXY?4:1)*Src->Pitch - (Width*(SrcHalfY?2:1) >> SrcDoubleX)
  623. I3S(MOV,R1,NONE,R11,LSL,1+p->SrcHalfY+p->SwapXY*2);
  624. I3S(SUB,R1,R1,R6,LSR,p->SrcDoubleX-p->SrcHalfX); 
  625. I2C(STR,R1,SP,OFS(stack,SrcNext));
  627. //UVNext = (Src->Pitch >> 1)*(SrcHalfY?2:1)*(SwapXY?4:1) - (Width*(SrcHalfY?2:1) >> SrcDoubleX >> 1);
  628. I3S(MOV,R2,NONE,R11,ASR,1-p->SrcHalfY-p->SwapXY*2);
  629. I3S(SUB,R2,R2,R6,LSR,p->SrcDoubleX+1-p->SrcHalfX); 
  630. I2C(STR,R2,SP,OFS(stack,UVNext));
  632. if (p->DirX<0) //adjust reversed destination for block size
  633. I2C(SUB,R9,R9,-(p->DstStepX >> 1)-(p->DstBPP >> 3));
  635. if (p->SwapXY)
  636. {
  637. // EndOfRect = Dst + ((Height * DstBPP * DirX) >> 3)
  638. I2C(MOV,R1,NONE,p->DstBPP * p->DirX);
  639. I3(MUL,R1,R5,R1);
  640. I3S(ADD,R1,R9,R1,ASR,3);
  641. I2C(STR,R1,SP,OFS(stack,EndOfRect));
  643. //DstNext = DstStepX - Width*DstPitch;
  644. MB(); I3(MUL,R2,R10,R6);
  645. I2C(MOV,R1,NONE,p->DstStepX); 
  646. I3(SUB,R1,R1,R2); 
  647. I2C(STR,R1,SP,OFS(stack,DstNext));
  648. }
  649. else
  650. {
  651. // EndOfRect = Dst + DstPitch * Height
  652. I3(MUL,R1,R10,R5);
  653. I3(ADD,R1,R9,R1);
  654. I2C(STR,R1,SP,OFS(stack,EndOfRect));
  656. //DstNext = ((DstPitch*2 << DstDoubleY) - DirX * Width << DstBPP2;
  657. I3S(MOV,R2,NONE,R10,LSL,p->DstDoubleY+1);
  658. I3S(p->DirX>0?SUB:ADD,R2,R2,R6,LSL,p->DstBPP2); 
  659. I2C(STR,R2,SP,OFS(stack,DstNext));
  660. }
  662. // setup shift registers
  663. // wcgr0 abs(rpos-8)
  664. // wcgr1 abs(gpos-8)
  665. // wcgr2 abs(bpos-8)
  666. // wcgr3 8 (if HalfMode)
  668. I2C(MOV,R5,NONE,abs(p->DstPos[0]+p->DstSize[0]-8));
  669. I2C(MOV,R6,NONE,abs(p->DstPos[1]+p->DstSize[1]-8));
  670. I2C(MOV,R7,NONE,abs(p->DstPos[2]+p->DstSize[2]-8));
  671. I2(TMCR,WCGR0,R5);
  672. I2(TMCR,WCGR1,R6);
  673. I2(TMCR,WCGR2,R7);
  675. if (HalfMode)
  676. {
  677. I2C(MOV,R1,NONE,8);
  678. I2(TMCR,WCGR3,R1);
  679. }
  681. // setup masks
  682. // r0 bmask (if bpos!=0)
  683. // wr9,wr10 mask r,g
  685. I2C(MOV,R1,NONE,((1 << p->DstSize[1])-1)<<(8-p->DstSize[1]));
  686. I2(TBCSTB,WR10,R1);
  688. if (p->DstPos[2]==0 && p->DstPos[0]+p->DstSize[0]==16)
  689. {
  690. // (red and blue word mask in R9)
  691. I2C(MOV,R1,NONE,((1 << p->DstSize[0])-1)<<(16-p->DstSize[0]));
  692. I2C(ORR,R1,R1,(1 << p->DstSize[2])-1);
  693. I2(TBCSTH,WR9,R1);
  694. }
  695. else
  696. {
  697. I2C(MOV,R1,NONE,((1 << p->DstSize[0])-1)<<(8-p->DstSize[0]));
  698. I2C(MOV,R0,NONE,((1 << p->DstSize[2])-1)<<(8-p->DstSize[2]));
  699. I2(TBCSTB,WR9,R1);
  700. }
  702. if (p->SwapXY)
  703. I2C(ADD,R2,R9,(8*p->DirX) << p->DstDoubleX);
  704. else
  705. I3S(ADD,R2,R9,R10,LSL,p->DstDoubleY);
  707. I3S(ADD,R14,R12,R11,LSL,p->SrcHalfY);
  708. if (!p->SwapXY)
  709. {
  710. I2C(SUB,R3,R3,4);
  711. I2C(SUB,R4,R4,4);
  712. }
  714. I2C(LDR,R5,SP,OFS(stack,Width));
  716. LoopY = Label(0);
  717. I0P(B,AL,LoopY);
  719. Align(8);
  721. InstPost(p->RVMul);
  722. InstPost(p->GUMul);
  723. InstPost(p->GVMul);
  724. InstPost(p->BUMul);
  726. InstPost(p->RAdd);
  727. InstPost(p->GAdd);
  728. InstPost(p->BAdd);
  729. InstPost(p->YMul);
  731. if (Dither)
  732. InstPost(Dither);
  733. InstPost(LoopY);
  735. if (p->SwapXY)
  736. {
  737. I3(MUL,R1,R10,R5); //dstpitch * width
  738. I3(ADD,R8,R9,R1);
  739. }
  740. else
  741. {
  742. if (p->DirX > 0)
  743. I3S(ADD,R8,R9,R5,LSL,p->DstBPP2);
  744. else
  745. I3S(SUB,R8,R9,R5,LSL,p->DstBPP2);
  746. }
  748. LoopX = Label(0);
  750. // preload
  751. if (!p->Slices)
  752. {
  753. dyninst* PreLoad1;
  754. dyninst* PreLoad2;
  755. dyninst* PreLoad3;
  756. dyninst* PreLoad4;
  757. int UVAdj = p->SwapXY?0:4;
  759. I3S(ADD,R1,R12,R5,ASR,(p->SrcDoubleX?1:0)-(p->SrcHalfX?1:0));
  760. I2C(ADD,R5,R12,32);
  761. I3(CMP,NONE,R5,R1);
  762. I0P(B,CS,LoopX);
  764. //y0
  765. PreLoad1 = Label(1);
  766. Byte(); I2C(LDR,R6,R5,-32);
  767. I2C(ADD,R5,R5,64);
  768. I3(CMP,NONE,R5,R1);
  769. Byte(); I2C(LDR,R7,R5,-64);
  770. I0P(B,CC,PreLoad1);
  772. I3(SUB,R1,R1,R12);
  773. I3(ADD,R1,R1,R14);
  774. I2C(ADD,R5,R14,32);
  776. //y1
  777. PreLoad2 = Label(1);
  778. Byte(); I2C(LDR,R6,R5,-32);
  779. I2C(ADD,R5,R5,64);
  780. I3(CMP,NONE,R5,R1);
  781. Byte(); I2C(LDR,R7,R5,-64);
  782. I0P(B,CC,PreLoad2);
  784. I3(SUB,R1,R1,R14);
  786. I3S(ADD,R1,R3,R1,ASR,p->SrcUVX2);
  788. I2C(ADD,R5,R3,32);
  789. I3(CMP,NONE,R5,R1);
  790. I0P(B,CS,LoopX);
  792. //u
  793. PreLoad3 = Label(1);
  794. Byte(); I2C(LDR,R6,R5,-32+UVAdj);
  795. I2C(ADD,R5,R5,64);
  796. I3(CMP,NONE,R5,R1);
  797. Byte(); I2C(LDR,R7,R5,-64+UVAdj);
  798. I0P(B,CC,PreLoad3);
  800. I3(SUB,R1,R1,R3);
  802. I3(ADD,R1,R1,R4);
  803. I2C(ADD,R5,R4,32);
  805. //v
  806. PreLoad4 = Label(1);
  807. Byte(); I2C(LDR,R6,R5,-32+UVAdj);
  808. I2C(ADD,R5,R5,64);
  809. I3(CMP,NONE,R5,R1);
  810. Byte(); I2C(LDR,R7,R5,-64+UVAdj);
  811. I0P(B,CC,PreLoad4);
  812. }
  813. else
  814. if (p->ARM5)
  815. {
  816. //preload next
  817. I3S(PLD,NONE,R12,R11,LSL,p->SrcHalfY+1); 
  818. I3S(PLD,NONE,R14,R11,LSL,p->SrcHalfY+1);
  819. I3S(PLD,NONE,R3,R11,ASR,p->SrcUVPitch2);
  820. I3S(PLD,NONE,R4,R11,ASR,p->SrcUVPitch2);
  821. }
  823. EndLine = Label(0);
  824. InstPost(LoopX);
  825. {
  826. if (!HalfMode) Fix_UV(p,0,0,0);
  827. Fix_Y(p,0,0,HalfMode);
  828. Fix_Y(p,1,0,HalfMode);
  830. if (p->SwapXY && (p->FX.Flags & BLITFX_DITHER))
  831. {
  832. I3(CMP,NONE,R9,R8);
  833. I0P(B,EQ,EndLine);
  835. if (!HalfMode) Fix_UV(p,0,0,0);
  836. Fix_Y(p,0,1,HalfMode);
  837. Fix_Y(p,1,1,HalfMode);
  838. }
  840. I3(CMP,NONE,R9,R8);
  841. I0P(B,NE,LoopX);
  842. }
  843. InstPost(EndLine);
  845. I2C(LDR,R5,SP,OFS(stack,SrcNext));
  846. I2C(LDR,R6,SP,OFS(stack,DstNext));
  847. I2C(LDR,R7,SP,OFS(stack,UVNext));
  848. I2C(LDR,R8,SP,OFS(stack,EndOfRect));
  850. //increment pointers
  851. I3(ADD,R12,R12,R5);
  852. I3(ADD,R14,R14,R5);
  853. I3(ADD,R2,R2,R6);
  854. I3(ADD,R9,R9,R6);
  855. I3(ADD,R3,R3,R7);
  856. I3(ADD,R4,R4,R7);
  858. if (!p->SwapXY && (p->FX.Flags & BLITFX_DITHER))
  859. {
  860. //swap WR12 and WR13
  861. I3(WOR,WR3,WR12,WR12);
  862. I3(WOR,WR12,WR13,WR13);
  863. I3(WOR,WR13,WR3,WR3);
  864. }
  866. //prepare registers for next row
  867. I2C(LDR,R5,SP,OFS(stack,Width));
  869. I3(CMP,NONE,R9,R8);
  870. I0P(B,NE,LoopY);
  872. I2C(ADD,SP,SP,OFS(stack,StackFrame));
  873. CodeEnd();
  874. }
  876. #endif