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

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

Windows CE

开发平台：

C/C++

blit_arm_rgb16.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_arm_rgb16.c 339 2005-11-15 11:22:45Z 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. #if defined(ARM) 
  30. // R0..R6 temporary
  31. // R7 Pos(when Stretch)
  32. // R8 Src2SrcLast (when Diff)
  33. // R8 Src0 (when Stretch)
  34. // R9 Src
  35. // R10 EndOfLine 
  36. // R11 Dst
  37. // R12 DstPitch
  38. // R14 SrcPitch 
  39. // R14 Src1 (when Stretch)
  41. typedef struct stack
  42. {
  43. int EndOfRect; 
  44. int DstNext; 
  45. int SrcNext;
  46. void* Palette;
  48. int StackFrame[STACKFRAME];
  50. //void* this   R0
  51. //char* Dst    R1
  52. //char* Src    R2
  53. //int DstPitch R3 can be signed
  54. int SrcPitch;
  55. int Width; 
  56. int Height;
  57. int Src2SrcLast;
  58. } stack;
  60. void RGB_4X2(blit_soft* p)
  61. {
  62. if (p->RealOnlyDiff)
  63. {
  64. p->Skip = Label(0);
  66. I3(LDR,R4,R9,R8);
  67. I3(LDR_POST,R0,R9,R14);
  69. I3(LDR,R6,R9,R8);
  70. I2C(LDR_POST,R2,R9,4);
  72. I3(LDR,R5,R9,R8);
  73. I3(LDR_POSTSUB,R3,R9,R14);
  75. I3(CMP,NONE,R0,R4);
  76. C(EQ); I3(CMP,NONE,R2,R6);
  78. I3(LDR,R6,R9,R8);
  79. I2C(LDR_POST,R1,R9,4);
  81. C(EQ); I3(CMP,NONE,R3,R5);
  82. C(EQ); I3(CMP,NONE,R1,R6);
  84. C(EQ);
  85. if (p->SwapXY)
  86. I3S(ADD,R11,R11,R12,LSL,2+p->DstDoubleY);
  87. else
  88. I2C(ADD,R11,R11,(2*4*p->DirX)<<p->DstDoubleX);
  90. I0P(B,EQ,p->Skip);
  91. }
  93. if (p->DstDoubleX && p->DstDoubleY)
  94. {
  95. //todo...
  96. }
  97. else
  98. {
  99. if (p->SwapXY)
  100. {
  101. if (p->RealOnlyDiff)
  102. I2C(SUB,R9,R9,8);
  104. Half(); I3(LDR_POST,R0,R9,R14);
  105. Half(); I2C(LDR_POST,R1,R9,2);
  107. Half(); I3(LDR_POSTSUB,R3,R9,R14);
  108. Half(); I2C(LDR_POST,R2,R9,2);
  110. if (p->DirX>0)
  111. {
  112. I3S(ORR,R4,R0,R1,LSL,16);
  113. I3S(ORR,R5,R2,R3,LSL,16);
  114. }
  115. else
  116. {
  117. I3S(ORR,R4,R1,R0,LSL,16);
  118. I3S(ORR,R5,R3,R2,LSL,16);
  119. }
  121. MB(); Half(); I3(LDR_POST,R0,R9,R14);
  122. MB(); Half(); I2C(LDR_POST,R1,R9,2);
  124. MB(); Half(); I3(LDR_POSTSUB,R3,R9,R14);
  125. MB(); Half(); I2C(LDR_POST,R2,R9,2);
  127. if (p->DirX>0)
  128. {
  129. I3S(ORR,R1,R0,R1,LSL,16);
  130. I3S(ORR,R3,R2,R3,LSL,16);
  131. }
  132. else
  133. {
  134. I3S(ORR,R1,R1,R0,LSL,16);
  135. I3S(ORR,R3,R3,R2,LSL,16);
  136. }
  138. I3(STR_POST,R4,R11,R12);
  139. I3(STR_POST,R5,R11,R12);
  140. I3(STR_POST,R1,R11,R12);
  141. I3(STR_POST,R3,R11,R12);
  142. }
  143. else
  144. {
  145. if (!p->RealOnlyDiff)
  146. {
  147. I3(LDR_POST,R0,R9,R14);
  148. I2C(LDR_POST,R2,R9,4);
  149. I3(LDR_POSTSUB,R3,R9,R14);
  150. I2C(LDR_POST,R1,R9,4);
  151. }
  152. if (p->DirX<0)
  153. {
  154. I3S(MOV,R0,NONE,R0,ROR,16);
  155. I3S(MOV,R1,NONE,R1,ROR,16);
  156. I3S(MOV,R2,NONE,R2,ROR,16);
  157. I3S(MOV,R3,NONE,R3,ROR,16);
  158. }
  160. I3(STR_POST,R0,R11,R12);
  161. I2C(STR_POST,R2,R11,4*p->DirX);
  162. I3(STR_POSTSUB,R3,R11,R12);
  163. I2C(STR_POST,R1,R11,4*p->DirX);
  164. }
  165. }
  167. if (p->RealOnlyDiff)
  168. InstPost(p->Skip);
  169. }
  171. void RGB_Read(blit_soft* p,reg RGB,reg Src,int Inc)
  172. {
  173. int Type[4];
  174. int IncByte[4];
  175. reg Tmp = R6;
  176. int i,j;
  177. bool_t First;
  179. if (p->Src.BitCount==p->Dst.BitCount && (p->Src.BitCount!=8 || !p->LookUp) &&
  180. p->Src.BitMask[0] == p->Dst.BitMask[0] &&
  181. p->Src.BitMask[1] == p->Dst.BitMask[1] &&
  182. p->Src.BitMask[2] == p->Dst.BitMask[2])
  183. {
  184. switch (p->Src.BitCount)
  185. {
  186. case 8:
  187. Byte(); I2C(LDR_POST,RGB,Src,Inc); 
  188. break;
  189. case 16:
  190. Half(); I2C(LDR_POST,RGB,Src,Inc*2); 
  191. break;
  192. case 32:
  193. I2C(LDR_POST,RGB,Src,Inc*4); 
  194. break;
  195. }
  196. }
  197. else
  198. {
  199. switch (p->Src.BitCount)
  200. {
  201. case 8:
  202. if (p->LookUp)
  203. {
  204. I1P(MOV,Tmp,p->LookUp,0);
  205. Byte(); I2C(LDR_POST,RGB,Src,Inc);
  206. switch (p->Dst.BitCount)
  207. {
  208. case 8:
  209. Byte(); I3(LDR,RGB,Tmp,RGB); 
  210. break;
  211. case 16:
  212. I3(ADD,RGB,RGB,RGB);
  213. Half(); I3(LDR,RGB,Tmp,RGB);
  214. break;
  215. case 32:
  216. I3S(LDR,RGB,Tmp,RGB,LSL,2);
  217. break;
  218. }
  219. }
  220. break;
  222. case 16:
  223. Half(); I2C(LDR_POST,RGB,Src,Inc*2);
  225. for (i=0;i<3;++i)
  226. {
  227. j = min(p->DstSize[i],p->SrcSize[i]);
  228. I2C(AND,Tmp,RGB,((1<<j)-1) << (p->SrcSize[i]+p->SrcPos[i]-j));
  229. I3S(ORR,RGB,RGB,Tmp,LSL,16-p->SrcSize[i]-p->SrcPos[i]+p->DstSize[i]+p->DstPos[i]);
  230. }
  232. I3S(MOV,RGB,NONE,RGB,LSR,16);
  233. break;
  235. case 32:
  236. case 24:
  238. for (j=0;j<3;++j)
  239. IncByte[j] = 1;
  240. IncByte[3] = (Inc-1) * (p->SrcBPP/8) + (p->Src.BitCount==32);
  242. for (j=0;j<4;++j)
  243. {
  244. Type[j] = -1;
  245. for (i=0;i<3;++i)
  246. if (p->SrcPos[i]==j*8)
  247. Type[j] = i;
  249. if (Type[j]<0)
  250. {
  251. // merge IncByte to previous
  252. for (i=j-1;i>=0;--i)
  253. if (Type[i]>=0 || IncByte[i])
  254. {
  255. IncByte[i] += IncByte[j];
  256. IncByte[j] = 0;
  257. break;
  258. }
  259. }
  260. }
  262. First = 1;
  263. for (j=0;j<4;++j)
  264. {
  265. i = Type[j];
  266. if (i>=0)
  267. {
  268. Byte(); I2C(LDR_POST,Tmp,Src,IncByte[j]);
  269. I2C(AND,Tmp,Tmp,((1 << p->DstSize[i])-1) << (8-p->DstSize[i]));
  270. if (First)
  271. {
  272. I3S(MOV,RGB,NONE,Tmp,LSR,8-p->DstPos[i]-p->DstSize[i]);
  273. First = 0;
  274. }
  275. else
  276. I3S(ORR,RGB,RGB,Tmp,LSR,8-p->DstPos[i]-p->DstSize[i]);
  277. }
  278. else if (IncByte[j]>0)
  279. I2C(ADD,Src,Src,IncByte[j]);
  280. }
  282. break;
  283. }
  284. }
  285. }
  287. void RGB_4X2S(blit_soft* p,int* Inc)
  288. {
  289. if (p->SwapXY)
  290. {
  291. RGB_Read(p,R0,R8,Inc[0]);
  292. RGB_Read(p,R1,R14,Inc[0]);
  293. RGB_Read(p,R2,R8,Inc[1]);
  294. RGB_Read(p,R3,R14,Inc[1]);
  296. if (p->DirX>0)
  297. {
  298. I3S(ORR,R4,R0,R1,LSL,16);
  299. I3S(ORR,R5,R2,R3,LSL,16);
  300. }
  301. else
  302. {
  303. I3S(ORR,R4,R1,R0,LSL,16);
  304. I3S(ORR,R5,R3,R2,LSL,16);
  305. }
  307. RGB_Read(p,R0,R8,Inc[2]);
  308. RGB_Read(p,R1,R14,Inc[2]);
  309. RGB_Read(p,R2,R8,Inc[3]);
  310. RGB_Read(p,R3,R14,Inc[3]);
  312. if (p->DirX>0)
  313. {
  314. I3S(ORR,R1,R0,R1,LSL,16);
  315. I3S(ORR,R3,R2,R3,LSL,16);
  316. }
  317. else
  318. {
  319. I3S(ORR,R1,R1,R0,LSL,16);
  320. I3S(ORR,R3,R3,R2,LSL,16);
  321. }
  323. I3(STR_POST,R4,R11,R12);
  324. I3(STR_POST,R5,R11,R12);
  325. I3(STR_POST,R1,R11,R12);
  326. I3(STR_POST,R3,R11,R12);
  327. }
  328. else
  329. {
  330. RGB_Read(p,R0,R8,Inc[0]);
  331. RGB_Read(p,R1,R8,Inc[1]);
  332. RGB_Read(p,R2,R8,Inc[2]);
  333. RGB_Read(p,R3,R8,Inc[3]);
  335. if (p->DirX>0)
  336. {
  337. I3S(ORR,R4,R0,R1,LSL,16);
  338. I3S(ORR,R5,R2,R3,LSL,16);
  339. }
  340. else
  341. {
  342. I3S(ORR,R4,R1,R0,LSL,16);
  343. I3S(ORR,R5,R3,R2,LSL,16);
  344. }
  346. RGB_Read(p,R0,R14,Inc[0]);
  347. RGB_Read(p,R1,R14,Inc[1]);
  348. RGB_Read(p,R2,R14,Inc[2]);
  349. RGB_Read(p,R3,R14,Inc[3]);
  351. if (p->DirX>0)
  352. {
  353. I3S(ORR,R1,R0,R1,LSL,16);
  354. I3S(ORR,R3,R2,R3,LSL,16);
  355. }
  356. else
  357. {
  358. I3S(ORR,R1,R1,R0,LSL,16);
  359. I3S(ORR,R3,R3,R2,LSL,16);
  360. }
  362. I3(STR_POST,R4,R11,R12);
  363. I2C(STR_POST,R1,R11,4*p->DirX);
  364. I3(STR_POSTSUB,R3,R11,R12);
  365. I2C(STR_POST,R5,R11,4*p->DirX);
  366. }
  367. }
  369. void Any_RGB_RGB(blit_soft* p)
  370. {
  371. dyninst* LoopX;
  372. dyninst* LoopY;
  373. dyninst* EndOfLine;
  374. bool_t Stretch;
  375. bool_t Same = 
  376. p->Src.BitCount==p->Dst.BitCount && 
  377. p->Src.BitMask[0] == p->Dst.BitMask[0] &&
  378. p->Src.BitMask[1] == p->Dst.BitMask[1] &&
  379. p->Src.BitMask[2] == p->Dst.BitMask[2];
  381. Stretch = p->RScaleX!=16 || p->RScaleY!=16 || !Same;
  383. p->RealOnlyDiff = (boolmem_t)(p->OnlyDiff && !Stretch);
  384. p->Caps = 0;
  385. p->DstAlignSize = 4;
  387. if (p->SrcDoubleX && !Stretch)
  388. p->DstAlignSize = 8;
  390. p->LookUp = NULL;
  391. if (p->Src.Palette)
  392. CalcPalRGBLookUp(p);
  394. if (p->LookUp_Data)
  395. {
  396. p->LookUp = InstCreate(p->LookUp_Data,p->LookUp_Size,NONE,NONE,NONE,0,0);
  397. free(p->LookUp_Data);
  398. p->LookUp_Data = NULL;
  399. }
  401. CodeBegin();
  402. I2C(SUB,SP,SP,OFS(stack,StackFrame));
  404. I2C(LDR,R11,R1,0);//Dst[0]
  405. I2C(LDR,R9,R2,0); //Src[0]
  407. if (p->DirX<0)
  408. {
  409. //adjust reversed destination for block size
  410. I2C(SUB,R11,R11,2);
  411. }
  413. I3(MOV,R12,NONE,R3); //DstPitch
  415. I2C(LDR,R2,SP,OFS(stack,Height));
  416. I2C(LDR,R1,SP,OFS(stack,Width));
  418. if (!Stretch)
  419. {
  420. //SrcNext = 2*Src->Pitch - SrcWidth << (SrcBPP2+SrcDoubleX)
  421. I2C(LDR,R14,SP,OFS(stack,SrcPitch));
  422. I3S(MOV,R3,NONE,R1,LSL,p->SrcDoubleX+p->SrcBPP2);
  423. I3S(RSB,R0,R3,R14,LSL,1); 
  424. I2C(STR,R0,SP,OFS(stack,SrcNext));
  425. }
  427. if (p->SwapXY)
  428. {
  429. //EndOfRect = Dst + Height*2*DirX
  430. I3S(p->DirX<0?SUB:ADD,R0,R11,R2,LSL,p->DstBPP2);
  431. I2C(STR,R0,SP,OFS(stack,EndOfRect));
  433. //DstNext = 2*(DstBPP/8)*DirX - Width*Dst->Pitch
  434. I3(MUL,R3,R1,R12);
  435. I2C(MOV,R0,NONE,2*p->DirX*(p->DstBPP/8));
  436. I3(SUB,R0,R0,R3);
  437. I2C(STR,R0,SP,OFS(stack,DstNext));
  438. }
  439. else
  440. {
  441. I3(MUL,R0,R12,R2); //DstPitch * Height
  442. I3(ADD,R0,R11,R0);
  443. I2C(STR,R0,SP,OFS(stack,EndOfRect));
  445. //DstNext = 2*Dst->Pitch - DirX*Width*(DstBPP/8)
  446. I3(ADD,R3,R1,R1);
  447. I3S(p->DirX<0?ADD:RSB,R0,R3,R12,LSL,p->DstBPP2); 
  448. I2C(STR,R0,SP,OFS(stack,DstNext));
  449. }
  451. if (p->RealOnlyDiff)
  452. I2C(LDR,R8,SP,OFS(stack,Src2SrcLast));
  454. if (Stretch)
  455. I2C(MOV,R7,NONE,0); //Pos
  457. I2C(LDR,R0,SP,OFS(stack,Width));
  458. LoopY = Label(1);
  460. //R0 width
  461. if (p->SwapXY)
  462. {
  463. I3(MUL,R10,R12,R0); //R12=DstPitch
  464. I3(ADD,R10,R11,R10);
  465. }
  466. else
  467. I3S(p->DirX>0?ADD:SUB,R10,R11,R0,LSL,1);
  469. if (Stretch)
  470. {
  471. int Col,i,ColCount;
  473. I3(MOV,R8,NONE,R9); //Src0
  475. I2C(LDR,R6,SP,OFS(stack,SrcPitch));
  476. I3S(MOV,R4,NONE,R7,LSR,4);
  477. I2C(ADD,R0,R7,p->RScaleY);
  478. I3S(RSB,R4,R4,R0,LSR,4);
  479. I3(MUL,R4,R6,R4);
  480. I3(ADD,R14,R9,R4); //Src1
  482. EndOfLine = Label(0);
  483. LoopX = Label(1);
  485. ColCount = 16;
  486. for (i=1;i<4 && !(p->RScaleX & i);i<<=1)
  487. ColCount >>= 1;
  489. for (Col=0;Col<ColCount;Col+=4)
  490. {
  491. int Inc[4];
  492. for (i=0;i<4;++i)
  493. Inc[i] = (((Col+i+1) * p->RScaleX) >> 4) - (((Col+i) * p->RScaleX) >> 4);
  495. RGB_4X2S(p,Inc);
  497. I3(CMP,NONE,R10,R11);
  498. if (Col+4 >= ColCount) 
  499. I0P(B,NE,LoopX);
  500. else
  501. I0P(B,EQ,EndOfLine);
  502. }
  504. InstPost(EndOfLine);
  506. I2C(LDR,R6,SP,OFS(stack,SrcPitch));
  507. I3S(MOV,R4,NONE,R7,LSR,4);
  508. I2C(ADD,R7,R7,2*p->RScaleY);
  509. I3S(RSB,R4,R4,R7,LSR,4);
  510. I3(MUL,R4,R6,R4);
  511. I3(ADD,R9,R9,R4); //add 2 lines
  512. }
  513. else
  514. {
  515. LoopX = Label(1);
  516. RGB_4X2(p);
  517. I3(CMP,NONE,R10,R11);
  518. I0P(B,NE,LoopX);
  519. I2C(LDR,R0,SP,OFS(stack,SrcNext));
  520. I3(ADD,R9,R9,R0);
  521. }
  523. I2C(LDR,R1,SP,OFS(stack,DstNext));
  524. I2C(LDR,R2,SP,OFS(stack,EndOfRect));
  525. I2C(LDR,R0,SP,OFS(stack,Width)); // needed for next EndOfLine
  526. I3(ADD,R11,R11,R1);
  527. I3(CMP,NONE,R2,R11);
  528. I0P(B,NE,LoopY);
  530. I2C(ADD,SP,SP,OFS(stack,StackFrame));
  531. CodeEnd();
  533. if (p->LookUp)
  534. {
  535. Align(16);
  536. InstPost(p->LookUp);
  537. }
  538. }
  540. #endif