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

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

Windows CE

开发平台：

C/C++

blit_arm_half.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_half.c 543 2006-01-07 22:06:24Z 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. // DstAlignSize 4
  29. // DstAlignPos  4
  30. // SrcAlignPos  2
  32. #if defined(ARM) 
  34. typedef struct stack
  35. {
  36. int EndOfLine;
  37. int EndOfRect;
  38. int DstPitch; 
  39. int DstNext;
  40. int SrcNext;
  41. int UVNext;
  43. int StackFrame[STACKFRAME];
  45. //void* this   R0
  46. //char* Dst    R1
  47. //char* Src    R2
  48. //int DstPitch R3 can be signed
  49. int SrcPitch; //can be signed
  50. int Width; 
  51. int Height;
  52. int Src2SrcLast;
  53. } stack;
  55. // R0 result RGB
  56. // R1..R3 R,G,B accumulator
  57. // R4..R6 temporary
  58. // R7 EndOfLine
  59. // R8 DstPitch
  60. // R9 Dst
  61. // R10 U
  62. // R11 V
  63. // R12 Y
  64. // R14 UVPitch (same as YPitch/2)
  66. static NOINLINE void Half_RGB_UV_Pixel(blit_soft* p, int No)
  67. {
  68. bool_t NextSub;
  69. bool_t NextX;
  71. int SatBit = p->QAdd ? 32 : 24;
  72. int RPos = p->DstPos[0];
  73. int GPos = p->DstPos[1];
  74. int BPos = p->DstPos[2];
  75. int NextLoad;
  77. // 3 <- 2
  78. // |    ^
  79. // v |
  80. // 0 -> 1
  82. switch (No)
  83. {
  84. default:
  85. case 0: NextSub = 0; NextX = 1; p->Upper = 0; break;
  86. case 1: NextSub = 1; NextX = 0; p->Upper = 1; break;
  87. case 2: NextSub = 1; NextX = 1; p->Upper = 1; break;
  88. case 3: NextSub = 0; NextX = 0; p->Upper = 0; break;
  89. }
  91. if (p->DirX<0)
  92. p->Upper = !p->Upper;
  93. if (p->SwapXY)
  94. {
  95. if (!NextX) NextSub = !NextSub;
  96. NextX = !NextX;
  97. }
  99. if (p->Upper && p->DstBPP<=16)
  100. {
  101. RPos += p->DstBPP;
  102. GPos += p->DstBPP;
  103. BPos += p->DstBPP;
  104. }
  106. if (p->FX.Flags & BLITFX_DITHER)
  107. {
  108. IConst(R4,p->_RAdd);
  109. IConst(R5,p->_GAdd);
  110. IConst(R6,p->_BAdd);
  111. I3S(ADD,R1,R4,R1,LSR,32-SatBit+p->DstSize[0]);
  112. I3S(ADD,R2,R5,R2,LSR,32-SatBit+p->DstSize[1]);
  113. I3S(ADD,R3,R6,R3,LSR,32-SatBit+p->DstSize[2]);
  114. }
  115. else
  116. {
  117. IConst(R1,p->_RAdd);
  118. IConst(R2,p->_GAdd);
  119. IConst(R3,p->_BAdd);
  120. }
  122. NextLoad = NextSub ? LDR_POSTSUB : LDR_POST;
  123. if (p->ArithStretch)
  124. {
  125. // sum a 2x2 block of Y
  126. if (NextX)
  127. {
  128. MB(); Byte(); I3S(LDR_POST,R4,R12,R14,LSL,1);   //y00
  129. MB(); Byte(); I2C(LDR_POST,R6,R12,1);   //y10
  130. MB(); Byte(); I3S(LDR_POSTSUB,R5,R12,R14,LSL,1);  //y11
  132. I3(ADD,R4,R4,R6);
  133. Byte(); I2C(NextLoad,R6,R12,NextSub?3:1);   //y01
  134. I3(ADD,R4,R4,R5);
  135. I3(ADD,R4,R4,R6);
  136. }
  137. else
  138. {
  139. MB(); Byte(); I2C(LDR_POST,R4,R12,1); //y00
  140. MB(); Byte(); I3S(LDR_POST,R6,R12,R14,LSL,1); //y01
  141. MB(); Byte(); I2C(LDR_POSTSUB,R5,R12,1); //y11
  143. I3(ADD,R4,R4,R6);
  144. Byte(); I3S(NextLoad,R6,R12,R14,LSL,1);     //y10
  145. I3(ADD,R4,R4,R5);
  146. if (NextSub) I3S(SUB,R12,R12,R14,LSL,2);
  147. I3(ADD,R4,R4,R6);
  148. }
  150. MB(); IConst(R5,p->_YMul >> 2);
  151. }
  152. else
  153. {
  154. MB(); Byte(); 
  155. if (NextX)
  156. I2C(NextLoad,R4,R12,2);   //y
  157. else
  158. I3S(NextLoad,R4,R12,R14,LSL,2); //y
  159. IConst(R5,p->_YMul);
  160. }
  162. I4(MLA,R1,R5,R4,R1);
  163. I4(MLA,R2,R5,R4,R2);
  164. I4(MLA,R3,R5,R4,R3);
  166. if (NextX)
  167. {
  168. MB(); Byte(); I2C(NextLoad,R6,R11,1); //v
  169. MB(); Byte(); I2C(NextLoad,R4,R10,1); //u
  170. }
  171. else
  172. {
  173. MB(); Byte(); I3(NextLoad,R6,R11,R14); //v
  174. MB(); Byte(); I3(NextLoad,R4,R10,R14); //u
  175. }
  176. IConst(R5,p->_GVMul);
  177. I4(MLA,R2,R5,R6,R2);
  178. IConst(R5,p->_RVMul);
  179. I4(MLA,R1,R5,R6,R1);
  180. IConst(R5,p->_GUMul);
  181. I4(MLA,R2,R5,R4,R2);
  182. IConst(R5,p->_BUMul);
  183. I4(MLA,R3,R5,R4,R3);
  185. if (p->QAdd)
  186. {
  187. I3(QDADD,R1,R1,R1);
  188. I3(QDADD,R2,R2,R2);
  189. I3(QDADD,R3,R3,R3);
  190. }
  191. else
  192. {
  193. I2C(TST,NONE,R1,0xFF000000);
  194. C(NE);I2C(MVN,R1,NONE,0xFF000000);
  195. C(MI);I2C(MOV,R1,NONE,0x00000000);
  196. I2C(TST,NONE,R2,0xFF000000);
  197. C(NE);I2C(MVN,R2,NONE,0xFF000000);
  198. C(MI);I2C(MOV,R2,NONE,0x00000000);
  199. I2C(TST,NONE,R3,0xFF000000);
  200. C(NE);I2C(MVN,R3,NONE,0xFF000000);
  201. C(MI);I2C(MOV,R3,NONE,0x00000000);
  202. }
  204. if (p->InvertMask && p->Pos<0)
  205. {
  206. p->Pos = RPos;
  207. MB(); I1P(LDR,R0,p->InvertMask,0);
  208. }
  209. if (p->Pos!=RPos && p->Pos>=0) I3S(MOV,R0,NONE,R0,ROR,RPos-p->Pos);
  210. I3S(p->Pos<0?MOV:EOR,R0,(reg)(p->Pos<0?NONE:R0),R1,LSR,SatBit-p->DstSize[0]);
  211. I3S(MOV,R5,NONE,R2,LSR,SatBit-p->DstSize[1]);
  212. I3S(MOV,R0,NONE,R0,ROR,BPos-RPos);
  213. I3S(EOR,R0,R0,R5,ROR,BPos-GPos);
  214. I3S(EOR,R0,R0,R3,LSR,SatBit-p->DstSize[2]);
  215. p->Pos = BPos;
  217. if (p->FX.Flags & BLITFX_DITHER)
  218. {
  219. MB(); I3S(MOV,R1,NONE,R1,LSL,32-SatBit+p->DstSize[0]);
  220. MB(); I3S(MOV,R2,NONE,R2,LSL,32-SatBit+p->DstSize[1]);
  221. MB(); I3S(MOV,R3,NONE,R3,LSL,32-SatBit+p->DstSize[2]);
  222. }
  223. }
  225. void Half_RGB_UV(blit_soft* p)
  226. {
  227. dyninst* LoopY;
  228. dyninst* LoopX;
  229. int Invert = 0;
  230. int Mask = 0;
  232. p->DstAlignPos = p->DstAlignSize = 4;
  234. p->DstStepX = p->DirX * ((p->DstBPP*2) >> 3);
  236. p->PalPtr = NULL;
  237. p->DiffMask = NULL;
  238. p->InvertMask = NULL;
  240. if (p->Dst.Flags & PF_INVERTED)
  241. Invert = -1;
  243. if (p->QAdd)
  244. {
  245. int Mask2;
  246. int i,Shift;
  248. for (i=0;i<3;++i)
  249. Mask |= 1 << (p->DstPos[i] + p->DstSize[i] - 1);
  251. Mask2 = Mask;
  252. Shift = 0;
  253. if (p->DstBPP <= 16)
  254. {
  255. if (p->DirX<0) Shift = p->DstBPP;
  256. Mask2 |= Mask << p->DstBPP;
  257. }
  259. Invert ^= RotateRight(Mask2,Shift+p->DstPos[0]);
  260. }
  262. if (Invert)
  263. p->InvertMask = InstCreate32(Invert,NONE,NONE,NONE,0,0);
  265. if (p->OnlyDiff)
  266. {
  267. int Mask = 0x03030303;
  268. if (!p->ArithStretch)
  269. Mask &= ~0x00FF0000; //lose Y3
  270. p->DiffMask = InstCreate32(Mask,NONE,NONE,NONE,0,0);
  271. }
  273. CodeBegin();
  274. I2C(SUB,SP,SP,OFS(stack,StackFrame));
  276. I2C(LDR,R9,R1,0);  //Dst[0] RGB
  277. I2C(LDR,R10,R2,4); //Src[1] U
  278. I2C(LDR,R11,R2,8); //Src[2] V
  279. I2C(LDR,R12,R2,0); //Src[0] Y
  280. I2C(STR,R3,SP,OFS(stack,DstPitch));
  281. I3(MOV,R8,NONE,R3); //DstPitch
  283. I2C(LDR,R14,SP,OFS(stack,SrcPitch));
  284. I2C(LDR,R0,SP,OFS(stack,Height));
  285. I2C(LDR,R4,SP,OFS(stack,Width));
  287. //SrcNext = 4*Src->Pitch - (Width << 1)
  288. I3S(MOV,R1,NONE,R14,LSL,2);
  289. I3S(SUB,R1,R1,R4,LSL,1); 
  290. I2C(STR,R1,SP,OFS(stack,SrcNext));
  292. //UVNext = (Src->Pitch) - (Width << 1 >> 1);
  293. I3(SUB,R2,R14,R4); 
  294. I2C(STR,R2,SP,OFS(stack,UVNext));
  296. I3S(MOV,R14,NONE,R14,ASR,1);
  298. if (p->DirX<0 && p->DstBPP==16) //adjust reversed destination for block size
  299. I2C(SUB,R9,R9,-p->DstStepX-(p->DstBPP >> 3));
  301. if (p->SwapXY)
  302. {
  303. //EndOfRect = Dst + (Height * DstBPP * DirX) >> 3;
  304. I2C(MOV,R1,NONE,p->DstBPP * p->DirX);
  305. I3(MUL,R0,R1,R0);
  306. I3S(ADD,R0,R9,R0,ASR,3);
  307. I2C(STR,R0,SP,OFS(stack,EndOfRect));
  309. //DstNext = DstStepX - Width*DstPitch;
  310. MB(); I3(MUL,R2,R8,R4);
  311. I2C(MOV,R0,NONE,p->DstStepX);
  312. I3(SUB,R0,R0,R2); 
  313. I2C(STR,R0,SP,OFS(stack,DstNext));
  314. }
  315. else
  316. {
  317. //EndOfRect = Dst + DstPitch * Height
  318. I3(MUL,R0,R8,R0);
  319. I3(ADD,R0,R9,R0);
  320. I2C(STR,R0,SP,OFS(stack,EndOfRect));
  322. //DstNext = DstPitch*2 - DirX * Width << DstBPP2;
  323. I3S(MOV,R2,NONE,R8,LSL,1);
  324. I3S(p->DirX>0?SUB:ADD,R2,R2,R4,LSL,p->DstBPP2); 
  325. I2C(STR,R2,SP,OFS(stack,DstNext));
  326. }
  328. if (p->FX.Flags & BLITFX_DITHER)
  329. {
  330. I2C(MVN,R1,NONE,0x80000000);
  331. I2C(MVN,R2,NONE,0x80000000);
  332. I2C(MVN,R3,NONE,0x80000000);
  333. }
  335. if (!p->SwapXY) // starting in second row
  336. {
  337. I3(ADD,R10,R10,R14);
  338. I3(ADD,R11,R11,R14);
  339. I3S(ADD,R12,R12,R14,LSL,2);
  340. }
  342. // R8 DstPitch
  343. // R4 Width
  345. LoopY = Label(1);
  347. if (p->SwapXY)
  348. {
  349. I3(MUL,R4,R8,R4); //R8=dstpitch
  350. I3(ADD,R7,R9,R4);
  351. }
  352. else
  353. {
  354. if (p->DirX > 0)
  355. I3S(ADD,R7,R9,R4,LSL,p->DstBPP2);
  356. else
  357. I3S(SUB,R7,R9,R4,LSL,p->DstBPP2);
  358. }
  360.     if (p->OnlyDiff)
  361. {
  362. if (p->FX.Flags & BLITFX_DITHER)
  363. I2C(STR,R7,SP,OFS(stack,EndOfLine)); //needed for restoring
  364. MB(); I1P(LDR,R5,p->DiffMask,0);
  365. MB(); I2C(LDR,R6,SP,OFS(stack,Src2SrcLast));
  366. p->Skip = Label(0);
  367. }
  369. LoopX = Label(1);
  370. {
  371. if (p->OnlyDiff)
  372. {
  373. // R0 temp
  374. // R1..R3 R,G,B accumulator (if dither)
  375. // R4 temp
  376. // R5 DiffMask
  377. // R6 Src2SrcLast
  378. // R7 EndOfLine
  379. // R8 DstPitch
  380. // R9 Dst
  381. // R10 U (second row when not SwapXY)
  382. // R11 V (second row when not SwapXY)
  383. // R12 Y (second double row when not SwapXY)
  384. // R14 UVPitch (same as YPitch/2)
  386. int LoadSub = p->SwapXY?LDR_POST:LDR_POSTSUB;
  387. int LoadAdd = p->SwapXY?LDR_POSTSUB:LDR_POST;
  388. reg RA=R0,RB=R4,RC,RD;
  390. if (p->FX.Flags & BLITFX_DITHER)
  391. {
  392. RC=R7; //will be restored
  393. RD=R8; //will be restored
  394. }
  395. else
  396. {
  397. RC=R1;
  398. RD=R2;
  399. }
  401. I3(LDR,RA,R12,R6);
  402. I3S(LoadSub,RB,R12,R14,LSL,2);
  403. I3(EOR,RA,RA,RB);
  405. if (p->ArithStretch)
  406. {
  407. MB(); I3(LDR,RC,R12,R6);
  408. MB(); I3S(LDR_POST,RD,R12,R14,LSL,1);
  409. I3(EOR,RC,RC,RD);
  410. I3(ORR,RA,RA,RC);
  412. MB(); I3(LDR,RB,R12,R6);
  413. MB(); I3S(LoadAdd,RD,R12,R14,LSL,2);
  414. I3(EOR,RB,RB,RD);
  415. I3(ORR,RA,RA,RB);
  417. MB(); I3(LDR,RC,R12,R6);
  418. MB(); I3S(LDR_POSTSUB,RD,R12,R14,LSL,1);
  419. I3(EOR,RC,RC,RD);
  420. I3(ORR,RA,RA,RC);
  422. I3S(BIC,RA,RA,R5,LSL,1); //lose 1 bit from Y (additionaly to DiffMask)
  423. }
  424. else
  425. {
  426. MB(); I3(LDR,RC,R12,R6);
  427. MB(); I3S(LoadAdd,RD,R12,R14,LSL,2);
  428. I3(EOR,RC,RC,RD);
  429. I3(ORR,RA,RA,RC);
  431. I2C(BIC,RA,RA,0xFF00); //lose Y1 (Y3 is masked out in DiffMask already)
  432. }
  434. MB(); Half(); I3(LDR,RB,R10,R6);
  435. MB(); Half(); I3(LoadSub,RD,R10,R14);
  436. I3(EOR,RB,RB,RD);
  437. I3(ORR,RA,RA,RB);
  439. MB(); Half(); I3(LDR,RC,R10,R6);
  440. MB(); Half(); I3(LoadAdd,RD,R10,R14);
  441. I3(EOR,RC,RC,RD);
  442. I3(ORR,RA,RA,RC);
  444. MB(); Half(); I3(LDR,RB,R11,R6);
  445. MB(); Half(); I3(LoadSub,RD,R11,R14);
  446. I3(EOR,RB,RB,RD);
  447. I3(ORR,RA,RA,RB);
  449. MB(); Half(); I3(LDR,RC,R11,R6);
  450. MB(); Half(); I3(LoadAdd,RD,R11,R14);
  451. I3(EOR,RC,RC,RD);
  452. I3(ORR,RA,RA,RC);
  454. S(); I3(BIC,RA,RA,R5);
  456. if (p->FX.Flags & BLITFX_DITHER) // restore R7,R8
  457. {
  458. MB(); I2C(LDR,R8,SP,OFS(stack,DstPitch));
  459. MB(); I2C(LDR,R7,SP,OFS(stack,EndOfLine));
  460. }
  462. if (p->SwapXY)
  463. {
  464. C(EQ); I3S(ADD,R9,R9,R8,LSL,1);
  465. }
  466. else
  467. {
  468. C(EQ); I2C(ADD,R9,R9,p->DstStepX);
  469. }
  471. I0P(B,EQ,p->Skip);
  472. }
  474. p->Pos = -1;
  476. Half_RGB_UV_Pixel(p,0);
  478. Half_RGB_UV_Pixel(p,1);
  479. if (p->Pos) 
  480. I3S(MOV,R0,NONE,R0,ROR,-p->Pos);
  482. if (p->DstBPP==8) Half();
  483. if (p->SwapXY)
  484. I3(STR_POST,R0,R9,R8);
  485. else
  486. I3(STR,R0,R9,R8);
  488. p->Pos = -1;
  489. Half_RGB_UV_Pixel(p,2);
  491. Half_RGB_UV_Pixel(p,3);
  492. if (p->Pos) 
  493. I3S(MOV,R0,NONE,R0,ROR,-p->Pos);
  495. if (p->DstBPP==8) Half();
  496. if (p->SwapXY)
  497. I3(STR_POST,R0,R9,R8);
  498. else
  499. I2C(STR_POST,R0,R9,p->DstStepX);
  501. if (p->OnlyDiff)
  502. {
  503. MB(); I1P(LDR,R5,p->DiffMask,0);
  504. MB(); I2C(LDR,R6,SP,OFS(stack,Src2SrcLast));
  505. InstPost(p->Skip);
  506. }
  508. I3(CMP,NONE,R9,R7);
  509. I2C(ADD,R12,R12,4);
  510. I2C(ADD,R10,R10,2);
  511. I2C(ADD,R11,R11,2);
  512. I0P(B,NE,LoopX);
  513. }
  515. I2C(LDR,R0,SP,OFS(stack,SrcNext));
  516. I2C(LDR,R4,SP,OFS(stack,DstNext));
  517. I2C(LDR,R6,SP,OFS(stack,UVNext));
  518. I2C(LDR,R5,SP,OFS(stack,EndOfRect));
  520. //increment pointers
  521. I3(ADD,R12,R12,R0);
  522. I3(ADD,R9,R9,R4);
  523. I3(ADD,R10,R10,R6);
  524. I3(ADD,R11,R11,R6);
  526. //prepare registers for next row
  527. I2C(LDR,R4,SP,OFS(stack,Width));
  529. I3(CMP,NONE,R9,R5);
  530. I0P(B,NE,LoopY);
  532. I2C(ADD,SP,SP,OFS(stack,StackFrame));
  533. CodeEnd();
  535. if (p->InvertMask) InstPost(p->InvertMask);
  536. if (p->DiffMask) InstPost(p->DiffMask);
  537. if (p->PalPtr) InstPost(p->PalPtr);
  538. }
  540. #endif