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

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

Windows CE

开发平台：

C/C++

blit_arm_stretch.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_stretch.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. //todo: ReUse with OnlyDiff condition. optimize IncPtr (change to pre increment)
  26. #include "../common.h"
  27. #include "../dyncode/dyncode.h"
  28. #include "blit_soft.h"
  30. #if defined(ARM)
  32. typedef struct stack
  33. {
  34. int InvertMask;
  35. int DiffMask;
  36. int PalPtr;
  37. int EndOfLine;
  38. int EndOfRect;
  39. int DstPitch;
  40. int DstNext;
  41. int Y;
  42. int U;
  43. int V;
  44. int Pos;
  45. int SaveR7; //onlydifference && dither
  46. int SaveR8; //onlydifference && dither
  48. int StackFrame[STACKFRAME];
  50. //void* this   R0
  51. //char* Dst    R1
  52. //char* Src    R2
  53. //int DstPitch R3
  54. int SrcPitch;
  55. int Width; 
  56. int Height;
  57. int Src2SrcLast;
  58. } stack;
  60. // palette
  61. // 
  63. // R0 result RGB
  64. // R1..R3 R,G,B accumulator
  65. // R4..R6 temporary
  67. // R9 Dst
  68. // R7 U+UVNextRow (when SwapXY)
  69. // R8 V+UVNextRow (when SwapXY)
  70. // R10 U
  71. // R11 V
  72. // R12 Y
  73. // R14 Y+YNextRow (when SwapXY)
  75. static NOINLINE void Inc_RGB_UV_Pixel(blit_soft* p, int dY, int dUV)
  76. {
  77. bool_t NextRow = (p->SwapXY) && (p->Upper == (p->DirX>0));
  78. reg Y,V,U;
  80. Y = (reg)(NextRow ? R14:R12);
  81. V = (reg)(NextRow ? R8:R11);
  82. U = (reg)(NextRow ? R7:R10);
  84. if (dY) I2C(ADD,Y,Y,dY);
  85. if (dUV) I2C(ADD,U,U,dUV);
  86. if (dUV) I2C(ADD,V,V,dUV);
  87. }
  89. static NOINLINE void Add_RGB_UV_Pixel(blit_soft* p, int Amount, int dY, int dUV, bool_t IncPtr)
  90. {
  91. assert(Amount>0 || !IncPtr);
  93. if (Amount)
  94. {
  95. int Load = IncPtr ? LDR_POST : LDR;
  96. reg Y,V,U;
  97. bool_t NextRow = (p->SwapXY) && (p->Upper == (p->DirX>0));
  99. Y = (reg)(NextRow ? R14:R12);
  100. V = (reg)(NextRow ? R8:R11);
  101. U = (reg)(NextRow ? R7:R10);
  103. if (p->DstPalette)
  104. {
  105. Byte(); I2C(Load,R4,Y,dY);  //y
  106. Byte(); I2C(Load,R6,V,dUV); //v
  107. Byte(); I2C(Load,R5,U,dUV); //u
  108. }
  109. else
  110. {
  111. Byte(); I2C(Load,R4,Y,dY); //y
  112. IConst(R5,(p->_YMul >> 8) * Amount);
  113. Byte(); I2C(Load,R6,V,dUV); //v
  114. I4(MLA,R1,R5,R4,R1);
  115. I4(MLA,R2,R5,R4,R2);
  116. I4(MLA,R3,R5,R4,R3);
  117. Byte(); I2C(Load,R4,U,dUV); //u
  118. IConst(R5,(p->_GVMul >> 8) * Amount);
  119. I4(MLA,R2,R5,R6,R2);
  120. IConst(R5,(p->_RVMul >> 8) * Amount);
  121. I4(MLA,R1,R5,R6,R1);
  122. IConst(R5,(p->_GUMul >> 8) * Amount);
  123. I4(MLA,R2,R5,R4,R2);
  124. IConst(R5,(p->_BUMul >> 8) * Amount);
  125. I4(MLA,R3,R5,R4,R3);
  126. }
  127. }
  128. }
  130. static NOINLINE void Stretch_RGB_UV_Pixel(blit_soft* p, int Col, int dY, int dUV)
  131. {
  132. int SatBit = p->QAdd ? 32 : 24;
  133. int RPos = p->DstPos[0];
  134. int GPos = p->DstPos[1];
  135. int BPos = p->DstPos[2];
  137. if (p->Upper && p->DstBPP<=16)
  138. {
  139. RPos += p->DstBPP;
  140. GPos += p->DstBPP;
  141. BPos += p->DstBPP;
  142. }
  144. if (!p->DstPalette)
  145. {
  146. if (p->Dither)
  147. {
  148. IConst(R4,p->_RAdd);
  149. IConst(R5,p->_GAdd);
  150. IConst(R6,p->_BAdd);
  151. I3S(ADD,R1,R4,R1,LSR,32-SatBit+p->DstSize[0]);
  152. I3S(ADD,R2,R5,R2,LSR,32-SatBit+p->DstSize[1]);
  153. I3S(ADD,R3,R6,R3,LSR,32-SatBit+p->DstSize[2]);
  154. }
  155. else
  156. {
  157. IConst(R1,p->_RAdd);
  158. IConst(R2,p->_GAdd);
  159. IConst(R3,p->_BAdd);
  160. }
  161. }
  163. if (p->ArithStretch)
  164. {
  165. int x = Col * p->RScaleX;
  167. Add_RGB_UV_Pixel(p,16*(16-(x & 15)),dY,dUV,!p->OnlyDiff);
  169. if (!p->OnlyDiff)
  170. {
  171. dY = -dY;
  172. dUV = -dUV;
  173. }
  175. ++dY;
  176. if (((x >> 4)&1) || p->SrcUVX2==0) //need UV increment?
  177. ++dUV;
  179. Add_RGB_UV_Pixel(p,16*(x & 15),dY,dUV,0);
  180. }
  181. else
  182. Add_RGB_UV_Pixel(p,256,dY,dUV,!p->OnlyDiff);
  184. if (p->DstPalette)
  185. {
  186. if (p->Dither)
  187. {
  188. I3S(ADD,R1,R1,R4,ROR,0);
  189. I3S(ADD,R2,R2,R5,ROR,0);
  190. I3S(ADD,R2,R2,R6,ROR,16);
  192. I2C(AND,R4,R1,0x1E0);
  193. I2C(AND,R5,R2,0x1E0);
  194. I2C(AND,R6,R2,0x1E00000);
  196. I3S(ADD,R0,R3,R4,LSL,5);
  197. I3S(ADD,R0,R0,R5,LSL,1);
  198. I3S(ADD,R0,R0,R6,LSR,3+16);
  200. Byte(); I2C(LDR,R4,R0,1);
  201. Byte(); I2C(LDR,R5,R0,2);
  202. Byte(); I2C(LDR,R6,R0,3);
  203. Byte(); I2C(LDR,R0,R0,0);
  205. I3S(SUB,R1,R1,R4,ROR,0);
  206. I3S(SUB,R2,R2,R5,ROR,0);
  207. I3S(SUB,R2,R2,R6,ROR,16);
  208. }
  209. else
  210. {
  211. I2C(AND,R4,R4,0x1E0);
  212. I2C(AND,R5,R5,0x1E0);
  213. I2C(AND,R6,R6,0x1E0);
  215. I3S(ADD,R0,R3,R4,LSL,5);
  216. I3S(ADD,R0,R0,R5,LSL,1);
  217. I3S(ADD,R0,R0,R6,LSR,3);
  219. Byte(); I2C(LDR,R0,R0,0);
  220. }
  221. p->Pos = 0;
  222. }
  223. else
  224. {
  225. if (p->QAdd)
  226. {
  227. I3(QDADD,R1,R1,R1);
  228. I3(QDADD,R2,R2,R2);
  229. I3(QDADD,R3,R3,R3);
  230. }
  231. else
  232. {
  233. I2C(TST,NONE,R1,0xFF000000);
  234. C(NE);I2C(MVN,R1,NONE,0xFF000000);
  235. C(MI);I2C(MOV,R1,NONE,0x00000000);
  236. I2C(TST,NONE,R2,0xFF000000);
  237. C(NE);I2C(MVN,R2,NONE,0xFF000000);
  238. C(MI);I2C(MOV,R2,NONE,0x00000000);
  239. I2C(TST,NONE,R3,0xFF000000);
  240. C(NE);I2C(MVN,R3,NONE,0xFF000000);
  241. C(MI);I2C(MOV,R3,NONE,0x00000000);
  242. }
  244. if (p->InvertMask && p->Pos<0)
  245. {
  246. p->Pos = RPos;
  247. MB(); I2C(LDR,R0,SP,OFS(stack,InvertMask));
  248. }
  249. if (p->Pos!=RPos && p->Pos>=0) I3S(MOV,R0,NONE,R0,ROR,RPos-p->Pos);
  250. I3S(p->Pos<0?MOV:EOR,R0,(reg)(p->Pos<0?NONE:R0),R1,LSR,SatBit-p->DstSize[0]);
  251. I3S(MOV,R4,NONE,R2,LSR,SatBit-p->DstSize[1]);
  252. I3S(MOV,R0,NONE,R0,ROR,BPos-RPos);
  253. I3S(EOR,R0,R0,R4,ROR,BPos-GPos);
  254. I3S(EOR,R0,R0,R3,LSR,SatBit-p->DstSize[2]);
  255. p->Pos = BPos;
  257. if (p->Dither)
  258. {
  259. MB(); I3S(MOV,R1,NONE,R1,LSL,32-SatBit+p->DstSize[0]);
  260. MB(); I3S(MOV,R2,NONE,R2,LSL,32-SatBit+p->DstSize[1]);
  261. MB(); I3S(MOV,R3,NONE,R3,LSL,32-SatBit+p->DstSize[2]);
  262. }
  263. }
  264. }
  266. void Stretch_RGB_UV(blit_soft* p)
  267. {
  268. bool_t Special;
  269. dyninst* LoopX;
  270. dyninst* LoopY;
  271. dyninst* EndOfLine;
  272. int i,Col,ColCount,RowStep;
  273. int Mask = 0;
  274. int Invert = 0;
  275. bool_t ReUse;
  276. bool_t NoInc;
  277. bool_t RegDirty; //R4,R5
  279. p->Dither = (boolmem_t)((p->DstBPP<=16) && (p->FX.Flags & BLITFX_DITHER)!=0);
  280. p->DstStepX = p->DirX * ((p->DstBPP*2) >> 3);
  281. p->PalPtr = NULL;
  282. p->DiffMask = NULL;
  283. p->InvertMask = NULL;
  285. if (p->Dst.Flags & PF_INVERTED)
  286. Invert = -1;
  288. CodeBegin();
  289. I2C(SUB,SP,SP,OFS(stack,StackFrame));
  291. I2C(LDR,R9,R1,0);  //Dst[0] RGB
  292. I2C(LDR,R10,R2,4); //Src[1] U
  293. I2C(LDR,R11,R2,8); //Src[2] V
  294. I2C(LDR,R12,R2,0); //Src[0] Y
  296. I2C(STR,R10,SP,OFS(stack,U));
  297. I2C(STR,R11,SP,OFS(stack,V));
  298. I2C(STR,R12,SP,OFS(stack,Y));
  300. ReUse = p->RScaleX<16 && !Invert && !p->OnlyDiff && (!p->OnlyDiff || !p->SwapXY) && (!p->DstPalette || !p->SwapXY) && !p->ArithStretch; //R0 is saved in loop and not ArithStretch
  302. if (p->QAdd && ReUse && !p->SwapXY)
  303. {
  304. p->QAdd = 0; // invert not supported with ReUse
  305. CalcColor(p);
  306. }
  308. if (p->QAdd)
  309. {
  310. int Mask2,Shift,i;
  312. for (i=0;i<3;++i)
  313. Mask |= 1 << (p->DstPos[i] + p->DstSize[i] - 1);
  315. Mask2 = Mask;
  316. Shift = 0;
  317. if (p->DstBPP <= 16)
  318. {
  319. if (p->DirX<0) Shift = p->DstBPP;
  320. Mask2 |= Mask << p->DstBPP;
  321. }
  323. Invert ^= RotateRight(Mask2,Shift+p->DstPos[0]);
  324. }
  326. if (Invert)
  327. {
  328. p->InvertMask = InstCreate32(Invert,NONE,NONE,NONE,0,0);
  329. MB(); I1P(LDR,R5,p->InvertMask,0);
  330. I2C(STR,R5,SP,OFS(stack,InvertMask));
  331. }
  333. if (p->OnlyDiff)
  334. {
  335. p->DiffMask = InstCreate32(0xFCFCFCFC,NONE,NONE,NONE,0,0);
  336. MB(); I1P(LDR,R4,p->DiffMask,0);
  337. I2C(STR,R4,SP,OFS(stack,DiffMask));
  338. }
  340. I2C(STR,R3,SP,OFS(stack,DstPitch));
  342. I3(MOV,R6,NONE,R3); //DstPitch
  343. I2C(LDR,R7,SP,OFS(stack,SrcPitch));
  344. I2C(LDR,R0,SP,OFS(stack,Height));
  345. I2C(LDR,R4,SP,OFS(stack,Width));
  347. if (p->DirX<0 && p->DstBPP==16) //adjust reversed destination for block size
  348. I2C(SUB,R9,R9,-p->DstStepX-(p->DstBPP >> 3));
  349. if ((p->DstPalette || p->DstBPP==32) && p->SwapXY)
  350. I2C(ADD,R9,R9,p->DstStepX/2);
  352. if (p->SwapXY)
  353. {
  354. I2C(MOV,R1,NONE,p->DstBPP * p->DirX);
  355. I3(MUL,R0,R1,R0);
  356. I3S(ADD,R0,R9,R0,ASR,3);
  357. I2C(STR,R0,SP,OFS(stack,EndOfRect));
  359. //DstNext = DstStepX - Width*DstPitch;
  360. MB(); I3(MUL,R2,R6,R4);
  361. I2C(MOV,R0,NONE,p->DstStepX);
  362. I3(SUB,R0,R0,R2); 
  363. I2C(STR,R0,SP,OFS(stack,DstNext));
  364. }
  365. else
  366. {
  367. I3(MUL,R0,R6,R0); //DstPitch * Height
  368. I3(ADD,R0,R9,R0);
  369. I2C(STR,R0,SP,OFS(stack,EndOfRect));
  371. //DstNext = DstPitch - DirX * Width << DstBPP2;
  372. I3S(p->DirX>0?SUB:ADD,R2,R6,R4,LSL,p->DstBPP2); 
  373. I2C(STR,R2,SP,OFS(stack,DstNext));
  374. }
  376. if (p->Dst.Flags & PF_PALETTE)
  377. {
  378. p->PalPtr = InstCreate32((int)p->LookUp_Data,NONE,NONE,NONE,0,0);
  379. MB(); I1P(LDR,R3,p->PalPtr,0);
  380. if (p->Dither)
  381. {
  382. I2C(MOV,R1,NONE,0);
  383. I2C(MOV,R2,NONE,0);
  384. }
  385. }
  386. else
  387. {
  388. if (p->Dither)
  389. {
  390. I2C(MVN,R1,NONE,0x80000000);
  391. I2C(MVN,R2,NONE,0x80000000);
  392. I2C(MVN,R3,NONE,0x80000000);
  393. }
  394. }
  396. I2C(MOV,R5,NONE,0); //Pos
  398. LoopY = Label(0);
  399. I0P(B,AL,LoopY);
  401. if (p->InvertMask) InstPost(p->InvertMask);
  402. if (p->DiffMask) InstPost(p->DiffMask);
  403. if (p->PalPtr) InstPost(p->PalPtr);
  405. ColCount = 32;
  406. for (i=1;i<16 && !(p->RScaleX & i);i<<=1)
  407. ColCount >>= 1;
  409. InstPost(LoopY);
  411. EndOfLine = Label(0);
  413. //R4 Width
  414. //R5 Pos
  415. //R7 SrcPitch
  417. if (p->SwapXY)
  418. {
  419. I3(MUL,R4,R6,R4); //R6=DstPitch
  420. I3(ADD,R4,R9,R4);
  421. }
  422. else
  423. {
  424. if (p->DirX > 0)
  425. I3S(ADD,R4,R9,R4,LSL,p->DstBPP2);
  426. else
  427. I3S(SUB,R4,R9,R4,LSL,p->DstBPP2);
  428. }
  429. I2C(STR,R4,SP,OFS(stack,EndOfLine));
  431. if (p->SwapXY)
  432. {
  433. //we need next row in R14,R7,R8 (YUV)
  435. IMul(R6,R5,p->RScaleY); //R6 = RScaleY*Pos
  436. I2C(ADD,R8,R6,p->RScaleY);//R8 = RScaleY*(Pos+1)
  438. // dY  = ((RScaleY * (Pos+1)) >> 4) - ((RScaleY * Pos) >> 4);
  439. I3S(MOV,R14,NONE,R8,LSR,4);
  440. I3S(SUB,R14,R14,R6,LSR,4);
  441. I3(MUL,R14,R7,R14);
  443. // dUV = ((RScaleY * (Pos+1)) >> (4+SrcUVY2)) - ((RScaleY * Pos) >> (4+SrcUVY2));
  444. I3S(MOV,R8,NONE,R8,LSR,4+p->SrcUVY2);
  445. I3S(SUB,R8,R8,R6,LSR,4+p->SrcUVY2);
  446. I3(MUL,R8,R7,R8);
  448. I3(ADD,R14,R12,R14);
  449. I3S(ADD,R7,R10,R8,ASR,p->SrcUVX2);
  450. I3S(ADD,R8,R11,R8,ASR,p->SrcUVX2);
  451. }
  453. I2C(STR,R5,SP,OFS(stack,Pos));
  455. // special case, when R7,R8 must be saved/restored and incremented separatly
  456. Special = p->OnlyDiff && (p->Dither) && (p->SwapXY);
  457. if (Special)
  458. {
  459. I2C(STR,R7,SP,OFS(stack,SaveR7));
  460. I2C(STR,R8,SP,OFS(stack,SaveR8));
  461. }
  463. if (p->OnlyDiff)
  464. {
  465. MB(); I2C(LDR,R5,SP,OFS(stack,DiffMask));
  466. MB(); I2C(LDR,R6,SP,OFS(stack,Src2SrcLast));
  467. }
  469. LoopX = Label(1);
  470. RegDirty = 1;
  471. NoInc = 0;
  473. for (Col=0;Col<ColCount;)
  474. {
  475. int x = (Col * p->RScaleX) >> 4;
  477. int IncY;
  478. int IncUV;
  479. int IncY2 = 0;
  480. int IncUV2 = 0;
  481. int Col1 = Col;
  482. int Col2 = Col;
  484. IncY = (((Col+1) * p->RScaleX) >> 4) - ((Col * p->RScaleX) >> 4);
  485. IncUV = (((Col+1) * p->RScaleX) >> (4+p->SrcUVX2)) - ((Col * p->RScaleX) >> (4+p->SrcUVX2));
  486. Col++;
  488. if (!(p->SwapXY))
  489. {
  490. IncY2 = (((Col+1) * p->RScaleX) >> 4) - ((Col * p->RScaleX) >> 4);
  491. IncUV2 = (((Col+1) * p->RScaleX) >> (4+p->SrcUVX2)) - ((Col * p->RScaleX) >> (4+p->SrcUVX2));
  493. Col2++;
  494. Col++;
  495. }
  496. else
  497. if (!p->OnlyDiff)
  498. {
  499. IncY2 = IncY;
  500. IncUV2 = IncUV;
  501. }
  503. if (p->OnlyDiff)
  504. {
  505. reg RC = (reg)(p->SwapXY ? R0 : R14);
  506. reg RA = (reg)(p->Dither ? R7 : R1);
  507. reg RB = (reg)(p->Dither ? R8 : R2);
  509. RegDirty = 1;
  510. p->Skip = Label(0);
  512. //RC,RA,RB,R4 for temporary
  513. //R5(DiffMask),R6(Src2SrcLast)
  515. if (p->SwapXY)
  516. {
  517. Byte(); I3(LDR,RC,R12,R6);
  518. Byte(); I2C(LDR_POST,RA,R12,IncY);
  519. Byte(); I3(LDR,R4,R14,R6);
  520. Byte(); I2C(LDR_POST,RB,R14,IncY);
  522. IncY = IncY2 = -IncY;
  523. }
  524. else
  525. {
  526. Byte(); I3(LDR,RC,R12,R6);
  527. Byte(); I2C(LDR_POST,RA,R12,IncY);
  528. Byte(); I3(LDR,R4,R12,R6);
  529. Byte(); I2C(LDR_POST,RB,R12,IncY2);
  531. IncY = -IncY-IncY2;
  532. IncY2 = -IncY2;
  533. }
  535. I3(EOR,RC,RC,RA);
  536. S(); I3(TST,NONE,RC,R5);
  537. I3(EOR,R4,R4,RB);
  538. C(EQ); S(); I3(TST,NONE,R4,R5);
  540. C(EQ); Byte(); I3(LDR,RC,R10,R6); //last u
  541. Byte(); I2C(LDR_POST,RA,R10,IncUV+IncUV2); //u
  542. C(EQ); Byte(); I3(LDR,R4,R11,R6); //last v
  543. Byte(); I2C(LDR_POST,RB,R11,IncUV+IncUV2); //v
  545. IncUV = -IncUV-IncUV2;
  547. if (Special) //R7,R8 not incremented, using direct position
  548. IncUV2 = x >> p->SrcUVX2;
  549. else
  550. if (p->SwapXY) //IncUV2 will increment R7,R8
  551. {
  552. I2C(ADD,R7,R7,-IncUV);
  553. I2C(ADD,R8,R8,-IncUV);
  554. IncUV2 = IncUV;
  555. }
  556. else
  557. IncUV2 = -IncUV2;
  559. C(EQ); I3(EOR,RC,RC,RA);
  560. C(EQ); S(); I3(TST,NONE,RC,R5);
  561. C(EQ); I3(EOR,R4,R4,RB);
  562. C(EQ); S(); I3(TST,NONE,R4,R5);
  564. C(EQ); I2C(LDR,R4,SP,OFS(stack,EndOfLine));
  566. #ifdef SHOWDIFF
  567. I2C(MVN,RC,NONE,0);
  568. if (DstBPP==8) Half();
  569. C(EQ); I2(STR,RC,R9);
  570. #endif
  572. if (p->SwapXY)
  573. {
  574. MB(); I2C(LDR,RC,SP,OFS(stack,DstPitch));
  575. C(EQ); I3(ADD,R9,R9,RC);
  576. }
  577. else
  578. {
  579. C(EQ); I2C(ADD,R9,R9,p->DstStepX);
  580. }
  581. I0P(B,EQ,p->Skip);
  583. if (Special)
  584. {
  585. I2C(LDR,R7,SP,OFS(stack,SaveR7));
  586. I2C(LDR,R8,SP,OFS(stack,SaveR8));
  587. }
  588. }
  590. p->Upper = p->DirX < 0;
  591. if (ReUse && NoInc)
  592. {
  593. p->Pos = 0;
  594. if (!p->SwapXY && p->DstBPP==16)
  595. I3S(MOV,R0,NONE,R0,LSL,p->Upper?16:-16);
  596. if (!p->OnlyDiff)
  597. Inc_RGB_UV_Pixel(p, IncY, IncUV);
  598. }
  599. else
  600. {
  601. p->Pos = -1;
  602. Stretch_RGB_UV_Pixel(p, Col1, IncY, IncUV);
  603. RegDirty = 1;
  604. }
  606. if (!p->SwapXY) 
  607. NoInc = !IncY && !IncUV;
  609. if (p->DstPalette)
  610. Byte();
  612. if (p->DstPalette || p->DstBPP==32)
  613. {
  614. if (p->DstBPP==32 && p->Pos)
  615. I3S(MOV,R0,NONE,R0,ROR,-p->Pos);
  616. if (p->SwapXY)
  617. I2C(STR,R0,R9,-p->DstStepX/2);
  618. else
  619. I2C(STR_POST,R0,R9,p->DstStepX/2);
  620. }
  622. p->Upper = p->DirX > 0;
  623. if (ReUse && NoInc)
  624. {
  625. if (!p->SwapXY && p->DstBPP==16)
  626. I3S(ORR,R0,R0,R0,ROR,16);
  627. if (!p->OnlyDiff)
  628. Inc_RGB_UV_Pixel(p, IncY2, IncUV2);
  629. }
  630. else
  631. {
  632. if (p->DstBPP!=16)
  633. p->Pos = -1;
  634. Stretch_RGB_UV_Pixel(p, Col2, IncY2, IncUV2);
  635. RegDirty = 1;
  636. }
  638. if (!p->SwapXY) 
  639. NoInc = !IncY2 && !IncUV2;
  640. else
  641. NoInc = !IncY && !IncUV;
  643. if (p->Pos) 
  644. I3S(MOV,R0,NONE,R0,ROR,-p->Pos);
  646. if (p->DstPalette || p->DstBPP==32)
  647. {
  648. if (p->SwapXY)
  649. {
  650. if (RegDirty) { MB(); I2C(LDR,R5,SP,OFS(stack,DstPitch)); }
  651. if (p->DstPalette) Byte(); 
  652. I3(STR_POST,R0,R9,R5);
  653. }
  654. else
  655. {
  656. if (p->DstPalette) Byte(); 
  657. I2C(STR_POST,R0,R9,p->DstStepX/2);
  658. }
  659. }
  660. else
  661. {
  662. if (p->SwapXY)
  663. {
  664. if (RegDirty) { MB(); I2C(LDR,R5,SP,OFS(stack,DstPitch)); }
  665. I3(STR_POST,R0,R9,R5);
  666. }
  667. else
  668. I2C(STR_POST,R0,R9,p->DstStepX);
  669. }
  671. if (RegDirty) { MB(); I2C(LDR,R4,SP,OFS(stack,EndOfLine)); }
  673. RegDirty = 0;
  675. if (p->OnlyDiff)
  676. {
  677. MB(); I2C(LDR,R5,SP,OFS(stack,DiffMask));
  678. MB(); I2C(LDR,R6,SP,OFS(stack,Src2SrcLast));
  679. InstPost(p->Skip);
  680. }
  682. I3(CMP,NONE,R9,R4);
  683. if (Col == ColCount) 
  684. {
  685. //last item in block
  686. if (Special) 
  687. {
  688. I2C(LDR,R7,SP,OFS(stack,SaveR7));
  689. I2C(LDR,R8,SP,OFS(stack,SaveR8));
  691. I2C(ADD,R7,R7,(p->RScaleX * ColCount) >> (4+p->SrcUVX2));
  692. I2C(ADD,R8,R8,(p->RScaleX * ColCount) >> (4+p->SrcUVX2));
  694. I2C(STR,R7,SP,OFS(stack,SaveR7));
  695. I2C(STR,R8,SP,OFS(stack,SaveR8));
  696. }
  697. I0P(B,NE,LoopX);
  698. }
  699. else
  700. I0P(B,EQ,EndOfLine);
  701. }
  703. InstPost(EndOfLine);
  705. I2C(LDR,R6,SP,OFS(stack,DstNext));
  706. I2C(LDR,R7,SP,OFS(stack,SrcPitch));
  707. I2C(LDR,R5,SP,OFS(stack,Pos));
  709. I2C(LDR,R12,SP,OFS(stack,Y));
  710. I2C(LDR,R10,SP,OFS(stack,U));
  711. I2C(LDR,R11,SP,OFS(stack,V));
  713. I3(ADD,R9,R9,R6);
  715. //increment row of Y,U,V according to Pos -> Pos+RowStep
  716. RowStep = (p->SwapXY) ? 2:1;
  718. //R4,R6,R8 for temporary
  719. IMul(R6,R5,p->RScaleY); //R6 = RScaleY*Pos
  720. I2C(ADD,R5,R5,RowStep);
  721. IMul(R8,R5,p->RScaleY); //R8 = RScaleY*(Pos+RowStep)
  723. // dY  = ((RScaleY * (Pos+RowStep)) >> 4) - ((RScaleY * Pos) >> 4);
  724. I3S(MOV,R4,NONE,R8,LSR,4);
  725. I3S(SUB,R4,R4,R6,LSR,4);
  726. I3(MUL,R4,R7,R4);
  728. // dUV = ((RScaleY * (Pos+RowStep)) >> (4+SrcUVY2)) - ((RScaleY * Pos) >> (4+SrcUVY2));
  729. I3S(MOV,R8,NONE,R8,LSR,4+p->SrcUVY2);
  730. I3S(SUB,R8,R8,R6,LSR,4+p->SrcUVY2);
  731. I3(MUL,R8,R7,R8);
  733. I3(ADD,R12,R12,R4);
  734. I3S(ADD,R10,R10,R8,ASR,p->SrcUVPitch2); 
  735. I3S(ADD,R11,R11,R8,ASR,p->SrcUVPitch2);
  737. I2C(STR,R12,SP,OFS(stack,Y));
  738. I2C(STR,R10,SP,OFS(stack,U));
  739. I2C(STR,R11,SP,OFS(stack,V));
  741. //prepare registers for next row
  742. if (p->SwapXY) I2C(LDR,R6,SP,OFS(stack,DstPitch));
  743. I2C(LDR,R4,SP,OFS(stack,Width));
  745. MB(); I2C(LDR,R0,SP,OFS(stack,EndOfRect));
  746. I3(CMP,NONE,R9,R0);
  747. I0P(B,NE,LoopY);
  749. I2C(ADD,SP,SP,OFS(stack,StackFrame));
  750. CodeEnd();
  751. }
  753. #endif