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

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

Windows CE

开发平台：

C/C++

blit_arm_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_arm_fix.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. #if defined(ARM) 
  30. typedef struct stack
  31. {
  32. int EndOfLine;
  33. int EndOfRect;
  34. int DstPitch; 
  35. int DstNext;
  36. int YNext;
  37. int UVNext;
  39. int StackFrame[STACKFRAME];
  41. //void* this   R0
  42. //char* Dst    R1
  43. //char* Src    R2
  44. //int DstPitch R3 can be signed
  45. int SrcPitch; //can be signed
  46. int Width; 
  47. int Height;
  48. int Src2SrcLast;
  49. } stack;
  51. static NOINLINE void Fix_RGB_UV_LoadUV(blit_soft* p)
  52. {
  53. //set R4 =           RVMul*v + RAdd
  54. //set R5 = GUMul*u + GVMul*v + GAdd
  55. //set R6 = BUMul*u +           BAdd
  57. if (p->Dither)
  58. {
  59. //R0,R4,R8 for temporary
  60. //R5(DiffMask),R6(Src2SrcLast),R7(EndOfLine)
  62. if (p->OnlyDiff)
  63. {
  64. Half(); I3(LDR,R8,R12,R6);
  65. Half(); I2C(LDR_POST,R0,R12,2);
  66. Half(); I3(LDR,R4,R14,R6);
  67. //xscale stall
  68. I3(EOR,R8,R8,R0);
  69. Half(); I2C(LDR_POST,R0,R14,2);
  70. S(); I3(TST,NONE,R8,R5);
  71. C(EQ); Byte(); I3(LDR,R8,R10,R6);
  72. C(EQ); I3(EOR,R4,R4,R0);
  73. Byte(); I2C(LDR_POST,R0,R10,1); //u
  74. C(EQ); S(); I3(TST,NONE,R4,R5);
  75. C(EQ); Byte(); I3(LDR,R4,R11,R6);
  76. C(EQ); I3(EOR,R8,R8,R0);
  77. Byte(); I2C(LDR_POST,R0,R11,1); //v
  78. C(EQ); S(); I3(TST,NONE,R8,R5);
  79. //xscale stall
  81. C(EQ); I3(EOR,R4,R4,R0);
  82. C(EQ); S(); I3(TST,NONE,R4,R5);
  84. if (p->SwapXY)
  85. {
  86. MB(); I2C(LDR,R8,SP,OFS(stack,DstPitch));
  87. C(EQ); I3S(ADD,R9,R9,R8,LSL,1+p->DstDoubleY);
  88. }
  89. else
  90. {
  91. C(EQ); I2C(ADD,R9,R9,p->DstStepX);
  92. }
  93. I0P(B,EQ,p->Skip);
  95. // R0=v
  96. if (p->ColorLookup)
  97. {
  98. Byte(); I2C(LDR,R5,R10,-1);   //u
  99. I1P(MOV,R8,p->LookUp,0);
  100. }
  101. }
  102. else
  103. {
  104. Byte(); I2C(LDR_POST,R0,R11,1); //v
  105. if (p->ColorLookup)
  106. {
  107. Byte(); I2C(LDR_POST,R5,R10,1); //u
  108. }
  109. }
  111. if (!p->ColorLookup)
  112. {
  113. I1P(LDR,R5,p->GAdd,0);
  114. I1P(LDR,R8,p->GVMul,0);
  115. I1P(LDR,R4,p->RAdd,0);
  116. I1P(LDR,R6,p->RVMul,0);
  117. I4(MLA,R5,R8,R0,R5);
  119. Byte(); 
  120. if (p->OnlyDiff) //already incremented
  121. I2C(LDR,R8,R10,-1);   //u
  122. else
  123. I2C(LDR_POST,R8,R10,1); //u
  125. I4(MLA,R4,R6,R0,R4);
  126. I1P(LDR,R7,p->GUMul,0);
  127. I1P(LDR,R6,p->BAdd,0);
  128. I1P(LDR,R0,p->BUMul,0);
  129. I4(MLA,R5,R7,R8,R5);
  131. //R7 Y read will moveback here (this will prevent stall by R0)
  133. I4(MLA,R6,R0,R8,R6);
  134. I1P(LDR,R8,p->YMul,0); //restore R8
  135. }
  136. else
  137. {
  138. I2C(ADD,R0,R0,p->LookUp_V);
  139. I3S(LDR,R4,R8,R0,LSL,2); // RVMul+RAdd | GVMul+GAdd
  140. I2C(ADD,R5,R5,p->LookUp_U);
  141. I3S(LDR,R6,R8,R5,LSL,2); // BUMul | GUMul
  142. I3S(MOV,R5,NONE,R4,LSL,16); 
  143. I3S(ADD,R5,R5,R6,LSL,16); // GUMul+GVMul+GAdd | 0000
  144. }
  145. }
  146. else
  147. {
  148. //R0,R1,R2,R3,R4 for temporary
  149. //R5(DiffMask),R6(Src2SrcLast),R7(EndOfLine)
  151. if (p->OnlyDiff)
  152. {
  153. Half(); I3(LDR,R0,R12,R6);
  154. Half(); I2C(LDR_POST,R1,R12,2);
  155. Half(); I3(LDR,R4,R14,R6);
  156. Half(); I2C(LDR_POST,R2,R14,2);
  157. I3(EOR,R0,R0,R1);
  158. S(); I3(TST,NONE,R0,R5);
  159. I3(EOR,R4,R4,R2);
  160. C(EQ); S(); I3(TST,NONE,R4,R5);
  162. C(EQ); Byte(); I3(LDR,R0,R10,R6);
  163. Byte(); I2C(LDR_POST,R1,R10,1); //u
  164. C(EQ); Byte(); I3(LDR,R4,R11,R6);
  165. Byte(); I2C(LDR_POST,R2,R11,1); //v
  166. C(EQ); I3(EOR,R0,R0,R1);
  167. C(EQ); S(); I3(TST,NONE,R0,R5);
  168. C(EQ); I3(EOR,R4,R4,R2);
  169. C(EQ); S(); I3(TST,NONE,R4,R5);
  171. if (p->SwapXY)
  172. {
  173. MB(); I2C(LDR,R3,SP,OFS(stack,DstPitch));
  174. C(EQ); I3S(ADD,R9,R9,R3,LSL,1+p->DstDoubleY);
  175. }
  176. else
  177. {
  178. C(EQ); I2C(ADD,R9,R9,p->DstStepX);
  179. }
  180. I0P(B,EQ,p->Skip);
  181. }
  182. else
  183. {
  184. Byte(); I2C(LDR_POST,R1,R10,1); //u
  185. Byte(); I2C(LDR_POST,R2,R11,1); //v
  186. }
  188. if (!p->ColorLookup)
  189. {
  190. I1P(LDR,R5,p->GAdd,0);
  191. I1P(LDR,R0,p->GVMul,0);
  192. I1P(LDR,R4,p->RAdd,0);
  193. I1P(LDR,R7,p->RVMul,0);
  194. I1P(LDR,R6,p->BAdd,0);
  195. I4(MLA,R5,R0,R2,R5); 
  196. I1P(LDR,R0,p->BUMul,0);
  197. I1P(LDR,R3,p->GUMul,0);
  198. I4(MLA,R4,R7,R2,R4); 
  199. I4(MLA,R6,R0,R1,R6); 
  200. I4(MLA,R5,R3,R1,R5); 
  201. }
  202. else
  203. {
  204. I2C(ADD,R1,R1,p->LookUp_U);
  205. I2C(ADD,R2,R2,p->LookUp_V);
  206. I3S(LDR,R6,R8,R1,LSL,2); // BUMul+BAdd | GUMul
  207. I3S(LDR,R4,R8,R2,LSL,2); // RVMul+RAdd | GVMul+GAdd
  208. //double xscale stall
  209. I3S(MOV,R5,NONE,R6,LSL,16); 
  210. I3S(ADD,R5,R5,R4,LSL,16); // GUMul+GVMul+GAdd | 0000
  211. }
  212. }
  213. }
  215. void Fix_RGB_UV_Pixel(blit_soft* p, int Col, int Row)
  216. {
  217. int SatBitR = p->QAdd ? 32 : 24;
  218. int SatBitG = SatBitR;
  219. int SatBitB = SatBitR;
  220. int RPos = p->DstPos[0];
  221. int GPos = p->DstPos[1];
  222. int BPos = p->DstPos[2];
  224. p->Upper = (p->DirX<0) ^ (Col>0);
  226. if (p->Upper && p->DstBPP==8 && p->DstDoubleX)
  227. {
  228. RPos += 16;
  229. GPos += 16;
  230. BPos += 16;
  231. }
  232. else
  233. if (p->Upper && p->DstBPP<=16)
  234. {
  235. RPos += p->DstBPP;
  236. GPos += p->DstBPP;
  237. BPos += p->DstBPP;
  238. }
  240. //load Y
  241. MB();
  242. Byte(); 
  244. if (p->OnlyDiff) //is R12,R14 already incremented?
  245. {
  246. if (p->SwapXY)
  247. I2C(LDR,R7,(reg)(Col==0?R12:R14),-2+Row);
  248. else
  249. I2C(LDR,R7,(reg)(Row==0?R14:R12),-2+Col);
  250. }
  251. else
  252. if (p->SwapXY)
  253. I2C(LDR_POST,R7,(reg)(Col==0?R12:R14),1);
  254. else
  255. I2C(LDR_POST,R7,(reg)(Row==0?R14:R12),1);
  257. if (p->Dither)
  258. {
  259. if (!p->ColorLookup)
  260. {
  261. I3S(ADD,R1,R4,R1,LSR,32-SatBitR+p->DstSize[0]);
  262. I3S(ADD,R2,R5,R2,LSR,32-SatBitG+p->DstSize[1]);
  263. I3S(ADD,R3,R6,R3,LSR,32-SatBitB+p->DstSize[2]);
  264. I4(MLA,R1,R8,R7,R1);
  265. I4(MLA,R2,R8,R7,R2);
  266. I4(MLA,R3,R8,R7,R3);
  267. }
  268. else
  269. {
  270. I3S(ADD,R1,R4,R1,LSL,16+LOOKUP_FIX-p->DstSize[0]);
  271. I3S(LDR,R7,R8,R7,LSL,2); // YMul * y
  272. I3S(ADD,R2,R5,R2,LSL,16+LOOKUP_FIX-p->DstSize[1]);
  273. I3S(ADD,R3,R6,R3,LSL,16+LOOKUP_FIX-p->DstSize[2]);
  274. I3(ADD,R1,R7,R1);
  275. I3(ADD,R2,R7,R2);
  276. I3(ADD,R3,R7,R3);
  277. Byte(); I3S(LDR,R1,R8,R1,LSR,16+LOOKUP_FIX); //sat and 8bit ror (8-RSize)
  278. Byte(); I3S(LDR,R2,R8,R2,LSR,16+LOOKUP_FIX); //sat and 8bit ror (8-GSize)
  279. Byte(); I3S(LDR,R3,R8,R3,LSR,16+LOOKUP_FIX); //sat and 8bit ror (8-BSize)
  281. // R1 = Dither[8-RSize] | Value[RSize]
  282. // R2 = Dither[8-GSize] | Value[GSize]
  283. // R3 = Dither[8-BSize] | Value[BSize]
  285. RPos += p->DstSize[0]; // LSB part -> MSB part
  286. GPos += p->DstSize[1]; // LSB part -> MSB part
  287. BPos += p->DstSize[2]; // LSB part -> MSB part
  289. SatBitR = 2*p->DstSize[0] - 32;
  290. SatBitG = 2*p->DstSize[1] - 32;
  291. SatBitB = 2*p->DstSize[2] - 32;
  292. }
  293. }
  294. else
  295. {
  296. if (!p->ColorLookup)
  297. {
  298. I4(MLA,R1,R8,R7,R4);
  299. I4(MLA,R2,R8,R7,R5);
  300. I4(MLA,R3,R8,R7,R6);
  301. }
  302. else
  303. {
  304. I3S(LDR,R7,R8,R7,LSL,2); // YMul * y
  305. I3(ADD,R1,R7,R4);
  306. I3(ADD,R2,R7,R5);
  307. I3(ADD,R3,R7,R6);
  308. Byte(); I3S(LDR,R1,R8,R1,LSR,16+LOOKUP_FIX); // sat to 8bit
  309. Byte(); I3S(LDR,R2,R8,R2,LSR,16+LOOKUP_FIX); // sat to 8bit
  310. Byte(); I3S(LDR,R3,R8,R3,LSR,16+LOOKUP_FIX); // sat to 8bit
  311. SatBitR = SatBitB = SatBitG = 8;
  312. }
  313. }
  315. if (!p->ColorLookup)
  316. {
  317. if (p->QAdd)
  318. {
  319. I3(QDADD,R1,R1,R1);
  320. I3(QDADD,R2,R2,R2);
  321. I3(QDADD,R3,R3,R3);
  322. }
  323. else
  324. {
  325. I2C(TST,NONE,R1,0xFF000000);
  326. C(NE);I2C(MVN,R1,NONE,0xFF000000);
  327. C(MI);I2C(MOV,R1,NONE,0x00000000);
  328. I2C(TST,NONE,R2,0xFF000000);
  329. C(NE);I2C(MVN,R2,NONE,0xFF000000);
  330. C(MI);I2C(MOV,R2,NONE,0x00000000);
  331. I2C(TST,NONE,R3,0xFF000000);
  332. C(NE);I2C(MVN,R3,NONE,0xFF000000);
  333. C(MI);I2C(MOV,R3,NONE,0x00000000);
  334. }
  335. }
  337. if (p->InvertMask && p->Pos<0)
  338. {
  339. p->Pos = RPos;
  340. MB(); I1P(LDR,R0,p->InvertMask,0);
  341. }
  342. if (p->Pos!=RPos && p->Pos>=0) I3S(MOV,R0,NONE,R0,ROR,RPos-p->Pos);
  343. I3S(p->Pos<0?MOV:EOR,R0,(reg)(p->Pos<0?NONE:R0),R1,LSR,SatBitR-p->DstSize[0]);
  344. I3S(MOV,R7,NONE,R2,LSR,SatBitG-p->DstSize[1]);
  345. I3S(MOV,R0,NONE,R0,ROR,BPos-RPos);
  346. I3S(EOR,R0,R0,R7,ROR,BPos-GPos);
  347. I3S(EOR,R0,R0,R3,LSR,SatBitB-p->DstSize[2]);
  348. p->Pos = BPos;
  350. if (p->Dither && !p->ColorLookup)
  351. {
  352. MB(); I3S(MOV,R1,NONE,R1,LSL,32-SatBitR+p->DstSize[0]);
  353. MB(); I3S(MOV,R2,NONE,R2,LSL,32-SatBitG+p->DstSize[1]);
  354. MB(); I3S(MOV,R3,NONE,R3,LSL,32-SatBitB+p->DstSize[2]);
  355. }
  356. }
  358. void Fix_RGB_UV(blit_soft* p)
  359. {
  360. dyninst* LoopY;
  361. dyninst* LoopX;
  362. int Invert = 0;
  363. int Mask = 0;
  365. p->DstAlignSize = 4;
  366. p->Dither = (boolmem_t)((p->FX.Flags & BLITFX_DITHER)!=0);
  367. if (p->DstDoubleX || p->DstDoubleY || p->DstBPP>16)
  368. p->Dither = 0;
  370. p->DstStepX = p->DirX * ((p->DstBPP*2) >> 3) << p->DstDoubleX;
  371. p->LookUp = NULL;
  372. p->PalPtr = NULL;
  373. p->DiffMask = NULL;
  374. p->InvertMask = NULL;
  376. if (p->Dst.Flags & PF_INVERTED)
  377. Invert = -1;
  379. if (p->ColorLookup)
  380. {
  381. CalcLookUp(p,p->Dither);
  382. p->LookUp = InstCreate(p->LookUp_Data,p->LookUp_Size,NONE,NONE,NONE,0,0);
  383. free(p->LookUp_Data);
  384. p->LookUp_Data = NULL;
  385. }
  387. if (p->QAdd)
  388. {
  389. int Mask2;
  390. int i,Shift;
  392. for (i=0;i<3;++i)
  393. Mask |= 1 << (p->DstPos[i] + p->DstSize[i] -1);
  395. Mask2 = Mask;
  396. Shift = 0;
  397. if (p->DstBPP==8 && p->DstDoubleX)
  398. Mask2 |= Mask << 16;
  399. else
  400. if (p->DstBPP <= 16)
  401. {
  402. if (p->DirX<0) Shift = p->DstBPP;
  403. Mask2 |= Mask << p->DstBPP;
  404. }
  406. Invert ^= RotateRight(Mask2,Shift+p->DstPos[0]);
  407. }
  409. p->YMul = InstCreate32(p->_YMul,NONE,NONE,NONE,0,0);
  410. p->RVMul = InstCreate32(p->_RVMul,NONE,NONE,NONE,0,0);
  411. p->RAdd = InstCreate32(p->_RAdd,NONE,NONE,NONE,0,0);
  412. p->GUMul = InstCreate32(p->_GUMul,NONE,NONE,NONE,0,0);
  413. p->GVMul = InstCreate32(p->_GVMul,NONE,NONE,NONE,0,0);
  414. p->GAdd = InstCreate32(p->_GAdd,NONE,NONE,NONE,0,0);
  415. p->BUMul = InstCreate32(p->_BUMul,NONE,NONE,NONE,0,0);
  416. p->BAdd = InstCreate32(p->_BAdd,NONE,NONE,NONE,0,0);
  418. if (Invert)
  419. p->InvertMask = InstCreate32(Invert,NONE,NONE,NONE,0,0);
  421. if (p->OnlyDiff)
  422. p->DiffMask = InstCreate32(0xFCFCFCFC,NONE,NONE,NONE,0,0);
  424. CodeBegin();
  425. I2C(SUB,SP,SP,OFS(stack,StackFrame));
  427. I2C(LDR,R9,R1,0); //Dst[0] RGB
  428. I2C(LDR,R10,R2,4); //Src[1] U
  429. I2C(LDR,R11,R2,8); //Src[2] V
  430. I2C(LDR,R12,R2,0); //Src[0] Y
  431. I2C(STR,R3,SP,OFS(stack,DstPitch));
  433. I3(MOV,R6,NONE,R3); //DstPitch
  434. I2C(LDR,R7,SP,OFS(stack,SrcPitch));
  435. I2C(LDR,R0,SP,OFS(stack,Height));
  436. I2C(LDR,R4,SP,OFS(stack,Width));
  438. if (!p->ColorLookup)
  439. I1P(LDR,R8,p->YMul,0);
  440. else
  441. I1P(MOV,R8,p->LookUp,0);
  443. //YNext = 2*Src->Pitch - (Width >> SrcDoubleX)
  444. I3S(MOV,R1,NONE,R7,LSL,1);
  445. I3S(SUB,R1,R1,R4,LSR,p->SrcDoubleX); 
  446. I2C(STR,R1,SP,OFS(stack,YNext));
  448. //UVNext = (Src->Pitch >> 1) - (Width >> SrcDoubleX >> 1);
  449. I3S(MOV,R2,NONE,R7,ASR,1);
  450. I3S(SUB,R2,R2,R4,LSR,p->SrcDoubleX+1); 
  451. I2C(STR,R2,SP,OFS(stack,UVNext));
  453. if (p->DirX<0 && p->DstBPP==16) //adjust reversed destination for block size
  454. I2C(SUB,R9,R9,-p->DstStepX-(p->DstBPP >> 3));
  455. if (p->DstBPP==32)
  456. I2C(ADD,R9,R9,p->DstStepX/2);
  458. if (p->SwapXY)
  459. {
  460. // EndOfRect = Dst + ((Height * DstBPP * DirX) >> 3) - (DstPitch << DstDoubleY)
  461. I3S(SUB,R9,R9,R6,LSL,p->DstDoubleY);
  462. I2C(MOV,R1,NONE,p->DstBPP * p->DirX);
  463. I3(MUL,R0,R1,R0);
  464. I3S(ADD,R0,R9,R0,ASR,3);
  465. I2C(STR,R0,SP,OFS(stack,EndOfRect));
  467. //DstNext = DstStepX - Width*DstPitch;
  468. MB(); I3(MUL,R2,R6,R4);
  469. I2C(MOV,R0,NONE,p->DstStepX); 
  470. I3(SUB,R0,R0,R2); 
  471. I2C(STR,R0,SP,OFS(stack,DstNext));
  472. }
  473. else
  474. {
  475. // EndOfRect = Dst + DstPitch * Height
  476. I3(MUL,R0,R6,R0);
  477. I3(ADD,R0,R9,R0);
  478. I2C(STR,R0,SP,OFS(stack,EndOfRect));
  480. //DstNext = ((DstPitch*2 << DstDoubleY) - DirX * Width << DstBPP2;
  481. I3S(MOV,R2,NONE,R6,LSL,p->DstDoubleY+1);
  482. I3S(p->DirX>0?SUB:ADD,R2,R2,R4,LSL,p->DstBPP2); 
  483. I2C(STR,R2,SP,OFS(stack,DstNext));
  484. }
  485. I3(ADD,R14,R12,R7);
  487. if (p->Dither)
  488. {
  489. if (!p->ColorLookup)
  490. {
  491. I2C(MVN,R1,NONE,0x80000000);
  492. I2C(MVN,R2,NONE,0x80000000);
  493. I2C(MVN,R3,NONE,0x80000000);
  494. }
  495. else
  496. {
  497. I2C(MOV,R1,NONE,0x80);
  498. I2C(MOV,R2,NONE,0x80);
  499. I2C(MOV,R3,NONE,0x80);
  500. }
  501. }
  503. LoopY = Label(1);
  505. if (p->SwapXY)
  506. {
  507. I3(MUL,R0,R6,R4); //R6=dstpitch
  508. I3(ADD,R7,R9,R0);
  509. }
  510. else
  511. {
  512. if (p->DirX > 0)
  513. I3S(ADD,R7,R9,R4,LSL,p->DstBPP2);
  514. else
  515. I3S(SUB,R7,R9,R4,LSL,p->DstBPP2);
  516. }
  517. I2C(STR,R7,SP,OFS(stack,EndOfLine));
  519. // preload
  520. if (p->ARM5) // not needed for non slices mode, but testing show it didn't help on ARM4
  521. {
  522. if (!p->Slices)
  523. {
  524. //R4 width
  525. //R0,R7,R5,R6 tmp
  527. dyninst* PreLoadEnd = Label(0);
  528. dyninst* PreLoad1;
  529. dyninst* PreLoad2;
  530. dyninst* PreLoad3;
  531. dyninst* PreLoad4;
  533. I3S(ADD,R0,R12,R4,ASR,(p->SrcDoubleX?1:0)-(p->SrcHalfX?1:0));
  534. I2C(ADD,R5,R12,32);
  535. I3(CMP,NONE,R5,R0);
  536. I0P(B,CS,PreLoadEnd);
  538. //y0
  539. PreLoad1 = Label(1);
  540. Byte(); I2C(LDR,R6,R5,-32);
  541. I2C(ADD,R5,R5,64);
  542. I3(CMP,NONE,R5,R0);
  543. Byte(); I2C(LDR,R7,R5,-64);
  544. I0P(B,CC,PreLoad1);
  546. I3S(ADD,R0,R14,R4,ASR,(p->SrcDoubleX?1:0)-(p->SrcHalfX?1:0));
  547. I2C(ADD,R5,R14,32);
  549. //y1
  550. PreLoad2 = Label(1);
  551. Byte(); I2C(LDR,R6,R5,-32);
  552. I2C(ADD,R5,R5,64);
  553. I3(CMP,NONE,R5,R0);
  554. Byte(); I2C(LDR,R7,R5,-64);
  555. I0P(B,CC,PreLoad2);
  557. I3S(ADD,R0,R10,R4,ASR,(p->SrcDoubleX?1:0)-(p->SrcHalfX?1:0)+p->SrcUVX2);
  558. I2C(ADD,R5,R10,32);
  559. I3(CMP,NONE,R5,R0);
  560. I0P(B,CS,PreLoadEnd);
  562. //u
  563. PreLoad3 = Label(1);
  564. Byte(); I2C(LDR,R6,R5,-32);
  565. I2C(ADD,R5,R5,64);
  566. I3(CMP,NONE,R5,R0);
  567. Byte(); I2C(LDR,R7,R5,-64);
  568. I0P(B,CC,PreLoad3);
  570. I3S(ADD,R0,R11,R4,ASR,(p->SrcDoubleX?1:0)-(p->SrcHalfX?1:0)+p->SrcUVX2);
  571. I2C(ADD,R5,R11,32);
  573. //v
  574. PreLoad4 = Label(1);
  575. Byte(); I2C(LDR,R6,R5,-32);
  576. I2C(ADD,R5,R5,64);
  577. I3(CMP,NONE,R5,R0);
  578. Byte(); I2C(LDR,R7,R5,-64);
  579. I0P(B,CC,PreLoad4);
  581. if (p->OnlyDiff) //restore R7
  582. I2C(LDR,R7,SP,OFS(stack,EndOfLine));
  584. InstPost(PreLoadEnd);
  585. }
  586. else
  587. {
  588. //preload next
  589. MB(); I2C(LDR,R6,SP,OFS(stack,SrcPitch));
  590. I3S(PLD,NONE,R12,R6,LSL,1);
  591. I3S(PLD,NONE,R14,R6,LSL,1);
  592. I3S(PLD,NONE,R10,R6,ASR,p->SrcUVPitch2);
  593. I3S(PLD,NONE,R11,R6,ASR,p->SrcUVPitch2);
  594. }
  595. }
  597.     if (p->OnlyDiff)
  598. {
  599. MB(); I1P(LDR,R5,p->DiffMask,0);
  600. MB(); I2C(LDR,R6,SP,OFS(stack,Src2SrcLast));
  601. p->Skip = Label(0);
  602. }
  604. LoopX = Label(1);
  605. {
  606. int PitchDouble;
  607. reg Pitch;
  609. Fix_RGB_UV_LoadUV(p);
  611. p->Pos = -1;
  613. Fix_RGB_UV_Pixel(p,0,0);
  614. if (p->DstBPP==32)
  615. {
  616. if (p->Pos)
  617. I3S(MOV,R0,NONE,R0,ROR,-p->Pos);
  619. assert(!p->DstDoubleX && !p->DstDoubleY);
  620. MB(); I2C(LDR,R1,SP,OFS(stack,DstPitch));
  621. I2C(ADD,R1,R1,-p->DstStepX/2);
  622. I3(STR,R0,R9,R1);
  623. p->Pos = -1;
  624. }
  626. Fix_RGB_UV_Pixel(p,1,0);
  627. if (p->Pos) 
  628. I3S(MOV,R0,NONE,R0,ROR,-p->Pos);
  630. Pitch = (reg)(p->Dither ? R7:R1);
  631. MB(); I2C(LDR,Pitch,SP,OFS(stack,DstPitch));
  633. if (p->DstBPP==8 && p->DstDoubleX) 
  634. I3S(ORR,R0,R0,R0,LSL,8);
  636. if (p->DstBPP==16 && p->DstDoubleX) 
  637. {
  638. I2C(ADD,R9,R9,4);
  639. I3S(MOV,R3,NONE,R0,LSR,16);
  640. I3S(MOV,R0,NONE,R0,LSL,16);
  641. I3S(ORR,R3,R3,R3,LSL,16);
  642. I3S(ORR,R0,R0,R0,LSR,16);
  644. if (p->DstDoubleY)
  645. {
  646. I3S(ADD,R2,Pitch,Pitch,LSL,1); //R2=3*DstPitch
  647. I3(STR,R3,R9,R2);
  648. }
  649. I3S(STR,R3,R9,Pitch,LSL,p->DstDoubleY);
  650. I2C(SUB,R9,R9,4);
  651. }
  653. if (p->DstDoubleY)
  654. {
  655. I3S(ADD,R2,Pitch,Pitch,LSL,1); //R2=3*DstPitch
  656. if (p->DstBPP==8 && !p->DstDoubleX) Half();
  657. I3(STR,R0,R9,R2);
  658. }
  660. PitchDouble = p->DstDoubleY;
  661. if (p->DstBPP==8 && !p->DstDoubleX) 
  662. {
  663. if (PitchDouble) // can't use STR with Half() and LSL,#1 at the same time
  664. {
  665. PitchDouble = 0;
  666. I3(ADD,Pitch,Pitch,Pitch);
  667. }
  668. Half();
  669. }
  670. I3S(STR,R0,R9,Pitch,LSL,PitchDouble);
  671. if (p->SwapXY)
  672. I3S(ADD,R9,R9,Pitch,LSL,1+PitchDouble);
  674. p->Pos = -1;
  675. Fix_RGB_UV_Pixel(p,0,1);
  676. if (p->DstBPP==32)
  677. {
  678. if (p->Pos)
  679. I3S(MOV,R0,NONE,R0,ROR,-p->Pos);
  681. assert(!p->DstDoubleX && !p->DstDoubleY);
  682. I2C(STR,R0,R9,-p->DstStepX/2);
  683. p->Pos = -1;
  684. }
  686. Fix_RGB_UV_Pixel(p,1,1);
  687. if (p->Pos) 
  688. I3S(MOV,R0,NONE,R0,ROR,-p->Pos);
  690. if (p->DstBPP==8 && p->DstDoubleX) 
  691. I3S(ORR,R0,R0,R0,LSL,8);
  693. if (p->DstDoubleY)
  694. {
  695. MB(); I2C(LDR,R1,SP,OFS(stack,DstPitch));
  696. }
  698. if (p->DstBPP==16 && p->DstDoubleX) 
  699. {
  700. I3S(MOV,R3,NONE,R0,LSR,16);
  701. I3S(MOV,R0,NONE,R0,LSL,16);
  702. I3S(ORR,R3,R3,R3,LSL,16);
  703. I3S(ORR,R0,R0,R0,LSR,16);
  705. if (p->DstDoubleY)
  706. {
  707. I2C(ADD,R2,R1,4); //DstPitch+4
  708. I3(STR,R3,R9,R2);
  709. }
  710. I2C(STR,R3,R9,4);
  711. }
  713. if (p->DstDoubleY)
  714. {
  715. if (p->DstBPP==8 && !p->DstDoubleX) Half();
  716. I3(STR,R0,R9,R1);
  717. }
  719. if (p->DstBPP==8 && !p->DstDoubleX) Half();
  720. if (p->SwapXY)
  721. I2(STR,R0,R9);
  722. else
  723. I2C(STR_POST,R0,R9,p->DstStepX);
  725. MB(); I2C(LDR,R7,SP,OFS(stack,EndOfLine));
  726. if (p->OnlyDiff)
  727. {
  728. MB(); I1P(LDR,R5,p->DiffMask,0);
  729. MB(); I2C(LDR,R6,SP,OFS(stack,Src2SrcLast));
  730. InstPost(p->Skip);
  731. }
  733. I3(CMP,NONE,R9,R7);
  734. I0P(B,NE,LoopX);
  735. }
  737. I2C(LDR,R0,SP,OFS(stack,YNext));
  738. I2C(LDR,R4,SP,OFS(stack,DstNext));
  739. I2C(LDR,R6,SP,OFS(stack,UVNext));
  740. I2C(LDR,R5,SP,OFS(stack,EndOfRect));
  742. //increment pointers
  743. I3(ADD,R12,R12,R0);
  744. I3(ADD,R14,R14,R0);
  745. I3(ADD,R9,R9,R4);
  746. I3(ADD,R10,R10,R6);
  747. I3(ADD,R11,R11,R6);
  749. //prepare registers for next row
  750. if (p->SwapXY) I2C(LDR,R6,SP,OFS(stack,DstPitch));
  751. I2C(LDR,R4,SP,OFS(stack,Width));
  753. I3(CMP,NONE,R9,R5);
  754. I0P(B,NE,LoopY);
  756. I2C(ADD,SP,SP,OFS(stack,StackFrame));
  757. CodeEnd();
  759. InstPost(p->YMul);
  760. InstPost(p->RVMul);
  761. InstPost(p->RAdd);
  762. InstPost(p->GUMul);
  763. InstPost(p->GVMul);
  764. InstPost(p->GAdd);
  765. InstPost(p->BUMul);
  766. InstPost(p->BAdd);
  767. if (p->InvertMask) InstPost(p->InvertMask);
  768. if (p->DiffMask) InstPost(p->DiffMask);
  769. if (p->PalPtr) InstPost(p->PalPtr);
  770. if (p->LookUp)
  771. {
  772. Align(16);
  773. InstPost(p->LookUp);
  774. }
  775. }
  777. #endif