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

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

Windows CE

开发平台：

C/C++

blit_arm_yuv.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_yuv.c 375 2005-12-02 09:34:27Z 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 8
  29. // DstAlignPos  8
  30. // SrcAlignPos  8
  32. #if defined(ARM) 
  34. // R0..R4 temporary
  35. // R5 DiffMask (when Diff)
  36. // R6 Src2SrcLast (when Diff)
  37. // R5 7F7F7F7F (when !Diff and HalfY and !HalfX)
  38. // R7 Src
  39. // R8 MaskCarry (when Brightness != 0)
  40. // R9 Add32 (when Brightness != 0)
  41. // R10 EndOfLine (Src)
  42. // R11 Dst
  43. // R12 DstPitch
  44. // R14 SrcPitch
  46. typedef struct stack
  47. {
  48. int Dst[3];
  49. int Src[3];
  50. int EndOfRect;
  51. int DstNext[2]; 
  52. int SrcNext[2];
  53. int SaveR0;
  55. int StackFrame[STACKFRAME];
  57. //void* this   R0
  58. //char* Dst    R1
  59. //char* Src    R2
  60. //int DstPitch R3 can be signed
  61. int SrcPitch;
  62. int Width; 
  63. int Height;
  64. int Src2SrcLast;
  65. } stack;
  67. static void NOINLINE SetDither(blit_soft* p,int Pos,int Part,int Plane)
  68. {
  69. if (Plane==0 && (p->FX.Flags & BLITFX_DITHER) && p->SrcYUV)
  70. {
  71. // dither matrix:
  72. // 0 2
  73. // 3 1
  75. int Ofs;
  76. if (Pos & 8)
  77. Ofs = Part?2:0;
  78. else
  79. Ofs = Part?1:3;
  81. if (Ofs != p->LookUpOfs)
  82. {
  83. I2C(ADD,R8,R8,Ofs-p->LookUpOfs);
  84. p->LookUpOfs = Ofs;
  85. }
  86. }
  87. }
  89. static NOINLINE int YUV_4(blit_soft* p, int Reg,int Pos,int Plane)
  90. {
  91. reg RA = (reg)Reg;
  92. reg RB = R4;
  93. reg RC = R0;
  94. reg RD = R9;
  96. if (p->SwapXY)
  97. {
  98. if (Reg != R0)
  99. {
  100. if (!p->SrcYUV || (Plane!=0 && (p->HalfX || p->HalfY)))
  101. I2C(LDR,R0,SP,OFS(stack,SaveR0));
  102. else
  103. I2(LDR,R0,R7);
  104. }
  106. if (p->LookUp)
  107. {
  108. I2C(AND,RB,R2,0xFF << Pos);
  109. I2C(AND,RC,R0,0xFF << Pos);
  110. SetDither(p,Pos,1,Plane);
  111. Byte(); I3S(LDR,RB,R8,RB,LSR,Pos);
  112. I2C(AND,RD,R1,0xFF << Pos);
  113. Byte(); I3S(LDR,RC,R8,RC,LSR,Pos);
  114. I3S(MOV,RB,NONE,RB,LSR,-(p->DirX<0?8:16));
  115. I3S(ORR,RB,RB,RC,LSR,-(p->DirX<0?24:0));
  116. I2C(AND,RC,R3,0xFF << Pos);
  117. SetDither(p,Pos,0,Plane);
  118. Byte(); I3S(LDR,RD,R8,RD,LSR,Pos);
  119. Byte(); I3S(LDR,RC,R8,RC,LSR,Pos);
  120. I3S(ORR,RB,RB,RD,LSR,-(p->DirX<0?16:8));
  121. I3S(ORR,RB,RB,RC,LSR,-(p->DirX<0?0:24));
  122. }
  123. else
  124. {
  125. I2C(AND,RB,R2,0xFF << Pos);
  126. I3S(MOV,RB,NONE,RB,LSR,Pos-(p->DirX<0?8:16));
  127. I2C(AND,RC,R0,0xFF << Pos);
  128. I3S(ORR,RB,RB,RC,LSR,Pos-(p->DirX<0?24:0));
  129. I2C(AND,RC,R1,0xFF << Pos);
  130. I3S(ORR,RB,RB,RC,LSR,Pos-(p->DirX<0?16:8));
  131. I2C(AND,RC,R3,0xFF << Pos);
  132. I3S(ORR,RB,RB,RC,LSR,Pos-(p->DirX<0?0:24));
  133. }
  134. RA=RB;
  135. }
  136. else
  137. if (p->DirX<0)
  138. {
  139. if (p->LookUp)
  140. {
  141. I2C(AND,RB,RA,0xFF00);
  142. SetDither(p,Pos,1,Plane);
  143. Byte(); I3S(LDR,RD,R8,RA,LSR,24);
  144. Byte(); I3S(LDR,RB,R8,RB,LSR,8);
  145. I3S(MOV,RA,NONE,RA,ROR,24);
  146. I3S(ORR,RD,RD,RB,LSL,16);
  147. SetDither(p,Pos,0,Plane);
  148. Byte(); I3S(LDR,RB,R8,RA,LSR,24);
  149. I2C(AND,RA,RA,0xFF00);
  150. Byte(); I3S(LDR,RA,R8,RA,LSR,8);
  151. I3S(ORR,RD,RD,RB,LSL,8);
  152. I3S(ORR,RD,RD,RA,LSL,24);
  153. RA = RD;
  154. }
  155. else
  156. if (RA == RC)
  157. {
  158. // only RA and RB
  159. I3S(MOV,RB,NONE,RA,LSR,24);
  160. I3S(ORR,RB,RB,RA,LSL,24);
  161. I3S(MOV,RA,NONE,RA,ROR,16);
  162. I3S(MOV,RB,NONE,RB,ROR,16);
  163. I3S(ORR,RB,RB,RA,LSR,24);
  164. I3S(ORR,RB,RB,RA,LSL,24);
  165. I3S(MOV,RA,NONE,RB,ROR,16);
  166. }
  167. else
  168. {
  169. I2C(AND,RC,RA,0xFF00);
  170. I3S(MOV,RB,NONE,RA,LSL,24);
  171. I3S(ORR,RB,RB,RC,LSL,8);
  172. I2C(AND,RC,RA,0xFF0000);
  173. I3S(ORR,RB,RB,RA,LSR,24);
  174. I3S(ORR,RA,RB,RC,LSR,8);
  175. }
  176. }
  177. else
  178. {
  179. if (p->LookUp)
  180. {
  181. I2C(AND,RB,RA,0xFF00);
  182. SetDither(p,Pos,1,Plane);
  183. Byte(); I3S(LDR,RD,R8,RA,LSR,24);
  184. Byte(); I3S(LDR,RB,R8,RB,LSR,8);
  185. I3S(MOV,RA,NONE,RA,ROR,24);
  186. I3S(ORR,RB,RB,RD,LSL,16);
  187. SetDither(p,Pos,0,Plane);
  188. Byte(); I3S(LDR,RD,R8,RA,LSR,24);
  189. I2C(AND,RA,RA,0xFF00);
  190. Byte(); I3S(LDR,RA,R8,RA,LSR,8);
  191. I3S(ORR,RB,RB,RD,LSL,8);
  192. I3S(ORR,RA,RA,RB,LSL,8);
  193. }
  194. else
  195. {
  196. RB = R0;
  197. RC = R4;
  198. }
  199. }
  201. if (Plane==0 && p->FX.Brightness && !p->LookUp && p->SrcYUV)
  202. {
  203. if (p->FX.Brightness < 0)
  204. {
  205. I3(MVN,RB,NONE,RA);
  206. RA=RB;
  207. }
  208. I3(ADD,RC,RA,R9); //add32
  209. I3(BIC,RB,RA,RC);
  210. I3(AND,RB,RB,R8); //maskcarry
  211. I3S(MOV,RB,NONE,RB,LSR,7);
  212. I3S(SUB,RC,RC,RB,LSL,8);
  213. I3S(RSB,RB,RB,RB,LSL,8);
  214. I3(ORR,RB,RB,RC);
  215. if (p->FX.Brightness < 0)
  216. I3(MVN,RB,NONE,RB);
  217. RA=RB;
  218. }
  220. return RA;
  221. }
  223. static NOINLINE void YUV_4X4(blit_soft* p, int Plane)
  224. {
  225. int y;
  226. int UV = Plane != 0;
  227. int Rows = 2;
  228. int HalfX = UV ? p->HalfX:0;
  229. int HalfY = UV ? p->HalfY:0;
  230. int SrcUVX = UV?p->SrcUVX2:0;
  231. int SrcUVPitch = UV?p->SrcUVPitch2:0;
  232. int DstUVPitch = UV?p->DstUVPitch2:0;
  233. if (UV) Rows >>= p->SrcUVY2+p->HalfY;
  235. I2C(LDR,R7,SP,OFS(stack,Src[Plane]));
  236. I2C(LDR,R11,SP,OFS(stack,Dst[Plane]));
  238. for (y=0;y<Rows;++y)
  239. {
  240. reg RA,RWidth=R0;
  241. dyninst* LoopX = Label(0);
  243. MB(); I2C(LDR,R0,SP,OFS(stack,Width));
  244. if (p->SrcBPP2>0)
  245. {
  246. IMul(R1,R0,p->SrcBPP/8);
  247. RWidth = R1;
  248. }
  249. I3S(ADD,R10,R7,RWidth,LSR,SrcUVX); //end of line
  251. //preload
  252. if (!p->Slices)
  253. {
  254. dyninst* PreLoad1;
  255. dyninst* PreLoad2;
  256. dyninst* PreLoad3;
  257. dyninst* PreLoad4;
  259. I2C(ADD,R0,R7,32);
  260. I3(CMP,NONE,R0,R10);
  261. I0P(B,CS,LoopX);
  263. PreLoad1 = Label(1);
  264. Byte(); I2C(LDR,R2,R0,-32);
  265. I2C(ADD,R0,R0,64);
  266. I3(CMP,NONE,R0,R10);
  267. Byte(); I2C(LDR,R3,R0,-64);
  268. I0P(B,CC,PreLoad1);
  270. I3S(ADD,R7,R7,R14,ASR,SrcUVPitch-1);
  271. I3S(ADD,R10,R10,R14,ASR,SrcUVPitch-1);
  272. I2C(ADD,R0,R7,32);
  274. PreLoad2 = Label(1);
  275. Byte(); I2C(LDR,R2,R0,-32);
  276. I2C(ADD,R0,R0,64);
  277. I3(CMP,NONE,R0,R10);
  278. Byte(); I2C(LDR,R3,R0,-64);
  279. I0P(B,CC,PreLoad2);
  281. I3S(ADD,R7,R7,R14,ASR,SrcUVPitch);
  282. I3S(ADD,R10,R10,R14,ASR,SrcUVPitch);
  283. I2C(ADD,R0,R7,32);
  285. PreLoad3 = Label(1);
  286. Byte(); I2C(LDR,R2,R0,-32);
  287. I2C(ADD,R0,R0,64);
  288. I3(CMP,NONE,R0,R10);
  289. Byte(); I2C(LDR,R3,R0,-64);
  290. I0P(B,CC,PreLoad3);
  292. I3S(SUB,R7,R7,R14,ASR,SrcUVPitch-1);
  293. I3S(SUB,R10,R10,R14,ASR,SrcUVPitch-1);
  294. I2C(ADD,R0,R7,32);
  296. PreLoad4 = Label(1);
  297. Byte(); I2C(LDR,R2,R0,-32);
  298. I2C(ADD,R0,R0,64);
  299. I3(CMP,NONE,R0,R10);
  300. Byte(); I2C(LDR,R3,R0,-64);
  301. I0P(B,CC,PreLoad4);
  303. I3S(SUB,R7,R7,R14,ASR,SrcUVPitch);
  304. I3S(SUB,R10,R10,R14,ASR,SrcUVPitch);
  305. }
  306. else
  307. if (p->ARM5)
  308. {
  309. //preload next
  310. I3S(ADD,R0,R7,R14,ASR,SrcUVPitch-2);
  311. I3S(ADD,R1,R0,R14,ASR,SrcUVPitch-1);
  312. I2(PLD,NONE,R0);
  313. I2(PLD,NONE,R1);
  314. I3S(PLD,NONE,R0,R14,ASR,SrcUVPitch);
  315. I3S(PLD,NONE,R1,R14,ASR,SrcUVPitch);
  316. }
  318. InstPost(LoopX);
  320. if (p->RealOnlyDiff)
  321. {
  322. p->Skip = Label(0);
  324. I3(LDR,R4,R7,R6);
  325. I3S(LDR_POST,R0,R7,R14,ASR,SrcUVPitch-1);
  326. I3(LDR,R1,R7,R6);
  327. I3S(LDR_POST,R2,R7,R14,ASR,SrcUVPitch);
  328. I3(EOR,R4,R4,R0);
  329. S(); I3(BIC,R4,R4,R5);
  330. I3(LDR,R0,R7,R6);
  331. I3S(LDR_POSTSUB,R3,R7,R14,ASR,SrcUVPitch-1);
  332. I3(EOR,R1,R1,R2);
  333. S(); C(EQ); I3(BIC,R1,R1,R5);
  334. I3(LDR,R4,R7,R6);
  335. I3S(LDR_POSTSUB,R1,R7,R14,ASR,SrcUVPitch);
  336. I3(EOR,R0,R0,R3);
  337. S(); C(EQ); I3(BIC,R0,R0,R5);
  338. I2(LDR,R0,R7);
  339. I3(EOR,R4,R4,R1);
  340. S(); C(EQ); I3(BIC,R4,R4,R5);
  341. I0P(B,EQ,p->Skip);
  342. }
  343. else
  344. if (!p->SrcYUV && !p->LookUp)
  345. {
  346. int x,y;
  348. // r0,r2,r3,r1 (tmp r4,r5,r6)
  349. for (y=0;y<4;++y)
  350. {
  351. reg Out;
  352. switch (y)
  353. {
  354. case 1: Out = R1; break;
  355. case 2: Out = R2; break;
  356. case 3: Out = R3; break;
  357. default:Out = R0; break;
  358. }
  359. for (x=0;x<4;++x)
  360. {
  361. reg Val = (reg)(x?R4:Out);
  362. int ofs = ((p->SrcBPP/8) << HalfX)*x;
  363. switch (p->SrcBPP)
  364. {
  365. // 8bit handled by lookup (with normal YUV blitting)
  366. case 16:
  367. Half(); I2C(LDR,R4,R7,ofs);
  368. I2C(MOV,R5,NONE,((1 << p->SrcSize[1])-1) << (8-p->SrcSize[1]));
  369. I2C(MOV,R6,NONE,((1 << p->SrcSize[2])-1) << (8-p->SrcSize[2]));
  370. I3S(AND,R5,R5,R4,LSR,p->SrcPos[1]+p->SrcSize[1]-8);
  371. I3S(AND,R6,R6,R4,LSR,p->SrcPos[2]+p->SrcSize[2]-8);
  372. I2C(AND,R4,R4,p->Src.BitMask[0]);
  373. I3S(MOV,R4,NONE,R4,LSR,p->SrcPos[0]+p->SrcSize[0]-8);
  374. break;
  375. case 24:
  376. case 32:
  377. Byte(); I2C(LDR,R6,R7,ofs+(p->SrcPos[2]>>3));
  378. Byte(); I2C(LDR,R4,R7,ofs+(p->SrcPos[0]>>3));
  379. Byte(); I2C(LDR,R5,R7,ofs+(p->SrcPos[1]>>3));
  380. break;
  381. }
  383. // R4,R5,R6 r,g,b
  385. // Y = (2105*R + 4128*G + 802*B)/0x2000 + 16;
  386. // U = (-1212*R - 2384*G + 3596*B)/0x2000 + 128;
  387. // V = (3596*R - 3015*G - 582*B)/0x2000 + 128;
  389. switch (Plane)
  390. {
  391. case 0:
  392. // Y = (8*R + 16*G + 3*B)/32 + 16;
  393. I3S(ADD,R6,R6,R6,LSL,1);
  394. I3S(ADD,R4,R6,R4,LSL,3);
  395. I3S(ADD,R4,R4,R5,LSL,4);
  396. I3S(MOV,R4,NONE,R4,ASR,5);
  397. S(); I2C(ADD,Val,R4,16+p->FX.Brightness);
  398. if (p->FX.Brightness+16<0)
  399. { 
  400. C(MI);I2C(MOV,Val,NONE,0x00); 
  401. }
  402. if (p->FX.Brightness+16+215>=255)
  403. {
  404. I2C(CMP,NONE,Val,0xFF);
  405. C(GT);I2C(MOV,Val,NONE,0xFF);
  406. }
  407. break;
  408. case 1:
  409. // U = (-5*R - 9*G + 14*B)/32 + 128;
  410. I3S(RSB,R6,R6,R6,LSL,3);
  411. I3(ADD,R6,R6,R6);
  412. I3S(ADD,R4,R4,R4,LSL,2);
  413. I3S(ADD,R5,R5,R5,LSL,3);
  414. I3(SUB,R4,R6,R4);
  415. I3(SUB,R4,R4,R5);
  416. I3S(MOV,R4,NONE,R4,ASR,5);
  417. I2C(ADD,Val,R4,128);
  418. break;
  419. case 2:
  420. // V = (14*R - 12*G - 2*B)/32 + 128;
  421. I3(ADD,R6,R6,R6);
  422. I3S(RSB,R4,R4,R4,LSL,3);
  423. I3S(ADD,R5,R5,R5,LSL,1);
  424. I3S(RSB,R4,R6,R4,LSL,1);
  425. I3S(SUB,R4,R4,R5,LSL,2);
  426. I3S(MOV,R4,NONE,R4,ASR,5);
  427. I2C(ADD,Val,R4,128);
  428. break;
  429. }
  431. if (x>0)
  432. I3S(ORR,Out,Out,Val,LSL,x*8);
  433. }
  434. I3S(ADD,R7,R7,R14,ASR,SrcUVPitch-HalfY);
  435. }
  436. I3S(SUB,R7,R7,R14,ASR,SrcUVPitch-2-HalfY);
  437. }
  438. else
  439. {
  440. int mode = HalfX + 2*HalfY;
  441. int x = 2;
  443. if (!p->SrcYUV && mode==0)
  444. {
  445. //possible alignment problems...
  446. mode = 1;
  447. x = 1;
  448. }
  450. switch (mode)
  451. {
  452. case 0:
  453. I3S(LDR_POST,R0,R7,R14,ASR,SrcUVPitch-1);
  454. I3S(LDR_POST,R2,R7,R14,ASR,SrcUVPitch);
  455. I3S(LDR_POSTSUB,R3,R7,R14,ASR,SrcUVPitch-1);
  456. I3S(LDR_POSTSUB,R1,R7,R14,ASR,SrcUVPitch);
  457. break;
  458. case 1: // halfx (not average...)
  459. Byte(); I2C(LDR,R0,R7,3*x);
  460. Byte(); I2C(LDR,R4,R7,2*x);
  461. Byte(); I2C(LDR,R5,R7,1*x);
  462. Byte(); I3S(LDR_POST,R6,R7,R14,ASR,SrcUVPitch-1);
  463. I3S(ORR,R0,R4,R0,LSL,8);
  464. I3S(ORR,R0,R5,R0,LSL,8);
  465. I3S(ORR,R0,R6,R0,LSL,8);
  467. Byte(); I2C(LDR,R2,R7,3*x);
  468. Byte(); I2C(LDR,R4,R7,2*x);
  469. Byte(); I2C(LDR,R5,R7,1*x);
  470. Byte(); I3S(LDR_POST,R6,R7,R14,ASR,SrcUVPitch);
  471. I3S(ORR,R2,R4,R2,LSL,8);
  472. I3S(ORR,R2,R5,R2,LSL,8);
  473. I3S(ORR,R2,R6,R2,LSL,8);
  475. Byte(); I2C(LDR,R3,R7,3*x);
  476. Byte(); I2C(LDR,R4,R7,2*x);
  477. Byte(); I2C(LDR,R5,R7,1*x);
  478. Byte(); I3S(LDR_POSTSUB,R6,R7,R14,ASR,SrcUVPitch-1);
  479. I3S(ORR,R3,R4,R3,LSL,8);
  480. I3S(ORR,R3,R5,R3,LSL,8);
  481. I3S(ORR,R3,R6,R3,LSL,8);
  483. Byte(); I2C(LDR,R1,R7,3*x);
  484. Byte(); I2C(LDR,R4,R7,2*x);
  485. Byte(); I2C(LDR,R5,R7,1*x);
  486. Byte(); I3S(LDR_POSTSUB,R6,R7,R14,ASR,SrcUVPitch);
  487. I3S(ORR,R1,R4,R1,LSL,8);
  488. I3S(ORR,R1,R5,R1,LSL,8);
  489. I3S(ORR,R1,R6,R1,LSL,8);
  490. break;
  491. case 2: // halfy
  492. I3S(LDR,R4,R7,R14,ASR,SrcUVPitch);
  493. I3S(LDR_POST,R0,R7,R14,ASR,SrcUVPitch-1-1);
  495. I3S(LDR,R6,R7,R14,ASR,SrcUVPitch);
  496. I3S(LDR_POST,R2,R7,R14,ASR,SrcUVPitch-1);
  498. I3S(AND,R4,R5,R4,LSR,1);
  499. I3S(AND,R0,R5,R0,LSR,1);
  500. I3(ADD,R0,R0,R4);
  502. I3S(AND,R6,R5,R6,LSR,1);
  503. I3S(AND,R2,R5,R2,LSR,1);
  504. I3(ADD,R2,R2,R6);
  506. I3S(LDR,R4,R7,R14,ASR,SrcUVPitch);
  507. I3S(LDR_POSTSUB,R3,R7,R14,ASR,SrcUVPitch-1-1);
  509. I3S(LDR,R6,R7,R14,ASR,SrcUVPitch);
  510. I3S(LDR_POSTSUB,R1,R7,R14,ASR,SrcUVPitch-1);
  512. I3S(AND,R4,R5,R4,LSR,1);
  513. I3S(AND,R3,R5,R3,LSR,1);
  514. I3(ADD,R3,R3,R4);
  516. I3S(AND,R6,R5,R6,LSR,1);
  517. I3S(AND,R1,R5,R1,LSR,1);
  518. I3(ADD,R1,R1,R4);
  519. break;
  520. case 3: // halfx + halfy (no average..., used by palette mode as well)
  521. Byte(); I2C(LDR,R0,R7,6);
  522. Byte(); I2C(LDR,R4,R7,4);
  523. Byte(); I2C(LDR,R5,R7,2);
  524. Byte(); I3S(LDR_POST,R6,R7,R14,ASR,SrcUVPitch-1-1);
  525. I3S(ORR,R0,R4,R0,LSL,8);
  526. I3S(ORR,R0,R5,R0,LSL,8);
  527. I3S(ORR,R0,R6,R0,LSL,8);
  529. Byte(); I2C(LDR,R2,R7,6);
  530. Byte(); I2C(LDR,R4,R7,4);
  531. Byte(); I2C(LDR,R5,R7,2);
  532. Byte(); I3S(LDR_POST,R6,R7,R14,ASR,SrcUVPitch-1);
  533. I3S(ORR,R2,R4,R2,LSL,8);
  534. I3S(ORR,R2,R5,R2,LSL,8);
  535. I3S(ORR,R2,R6,R2,LSL,8);
  537. Byte(); I2C(LDR,R3,R7,6);
  538. Byte(); I2C(LDR,R4,R7,4);
  539. Byte(); I2C(LDR,R5,R7,2);
  540. Byte(); I3S(LDR_POSTSUB,R6,R7,R14,ASR,SrcUVPitch-1-1);
  541. I3S(ORR,R3,R4,R3,LSL,8);
  542. I3S(ORR,R3,R5,R3,LSL,8);
  543. I3S(ORR,R3,R6,R3,LSL,8);
  545. Byte(); I2C(LDR,R1,R7,6);
  546. Byte(); I2C(LDR,R4,R7,4);
  547. Byte(); I2C(LDR,R5,R7,2);
  548. Byte(); I3S(LDR_POSTSUB,R6,R7,R14,ASR,SrcUVPitch-1);
  549. I3S(ORR,R1,R4,R1,LSL,8);
  550. I3S(ORR,R1,R5,R1,LSL,8);
  551. I3S(ORR,R1,R6,R1,LSL,8);
  552. break;
  553. }
  554. }
  556. if (p->SwapXY && (HalfX || HalfY || !p->SrcYUV))
  557. I2C(STR,R0,SP,OFS(stack,SaveR0));
  559. RA = (reg)YUV_4(p,R0,0,Plane);
  560. I3S(STR_POST,RA,R11,R12,ASR,DstUVPitch-1);
  561. RA = (reg)YUV_4(p,R2,16,Plane);
  562. I3S(STR_POST,RA,R11,R12,ASR,DstUVPitch);
  563. RA = (reg)YUV_4(p,R3,24,Plane);
  564. I3S(STR_POSTSUB,RA,R11,R12,ASR,DstUVPitch-1);
  565. RA = (reg)YUV_4(p,R1,8,Plane);
  566. I3S(STR_POSTSUB,RA,R11,R12,ASR,DstUVPitch);
  568. if (p->LookUp && p->LookUpOfs)
  569. {
  570. I2C(SUB,R8,R8,p->LookUpOfs);
  571. p->LookUpOfs = 0;
  572. }
  574. if (p->RealOnlyDiff)
  575. InstPost(p->Skip);
  577. I2C(ADD,R7,R7,(4 << HalfX)*(p->SrcBPP/8));
  578. if (p->SwapXY)
  579. I3S(ADD,R11,R11,R12,ASR,DstUVPitch-2);
  580. else
  581. I2C(ADD,R11,R11,4*p->DirX);
  582. I3(CMP,NONE,R7,R10);
  583. I0P(B,NE,LoopX);
  585. I2C(LDR,R0,SP,OFS(stack,SrcNext[UV]));
  586. I2C(LDR,R1,SP,OFS(stack,DstNext[UV]));
  587. I3(ADD,R7,R7,R0);
  588. I3(ADD,R11,R11,R1);
  589. }
  591. I2C(STR,R7,SP,OFS(stack,Src[Plane]));
  592. I2C(STR,R11,SP,OFS(stack,Dst[Plane]));
  593. }
  595. void Fix_Any_YUV(blit_soft* p)
  596. {
  597. dyninst* Add32 = NULL;
  598. dyninst* MaskCarry = NULL;
  599. dyninst* LoopY;
  600. reg RSrcWidth;
  602. p->SrcAlignPos = p->DstAlignPos = p->DstAlignSize = 8;
  604. CodeBegin();
  605. I2C(SUB,SP,SP,OFS(stack,StackFrame));
  607. p->DiffMask = NULL;
  609. I2C(LDR,R6,R1,0);//Dst[0] U
  610. I2C(LDR,R7,R1,4);//Dst[1] V
  611. I2C(LDR,R8,R1,8);//Dst[2] Y
  613. I2C(LDR,R10,R2,0); //Src[0] U
  614. if (!p->SrcYUV)
  615. {
  616. I3(MOV,R11,NONE,R10);
  617. I3(MOV,R12,NONE,R10);
  618. p->SrcUVX2 = 0;
  619. p->SrcUVY2 = 0;
  620. p->SrcUVPitch2 = 0;
  621. p->Caps = VC_BRIGHTNESS;
  622. }
  623. else
  624. {
  625. I2C(LDR,R11,R2,4); //Src[1] V
  626. I2C(LDR,R12,R2,8); //Src[2] Y
  627. }
  629. if (p->DirX<0)
  630. {
  631. //adjust reversed destination for block size
  632. I2C(SUB,R6,R6,3);
  633. I2C(SUB,R7,R7,3);
  634. I2C(SUB,R8,R8,3);
  635. }
  637. I2C(STR,R6,SP,OFS(stack,Dst[0]));
  638. I2C(STR,R7,SP,OFS(stack,Dst[1]));
  639. I2C(STR,R8,SP,OFS(stack,Dst[2]));
  641. I2C(STR,R10,SP,OFS(stack,Src[0]));
  642. I2C(STR,R11,SP,OFS(stack,Src[1]));
  643. I2C(STR,R12,SP,OFS(stack,Src[2]));
  645. I3(MOV,R12,NONE,R3);  //DstPitch
  646. I2C(LDR,R14,SP,OFS(stack,SrcPitch));
  648. I2C(LDR,R2,SP,OFS(stack,Height));
  649. I2C(LDR,R1,SP,OFS(stack,Width));
  651. p->RealOnlyDiff = p->OnlyDiff;
  652. p->HalfX = (boolmem_t)(p->SrcUVX2+1 == p->DstUVX2);
  653. p->HalfY = (boolmem_t)(p->SrcUVY2+1 == p->DstUVY2);
  655. if (p->HalfX || p->HalfY)
  656. p->RealOnlyDiff = 0;
  658. if (p->RealOnlyDiff)
  659. {
  660. int Mask = 0x03030303;
  661. p->DiffMask = InstCreate32(Mask,NONE,NONE,NONE,0,0);
  662. I1P(LDR,R5,p->DiffMask,0);
  663. I2C(LDR,R6,SP,OFS(stack,Src2SrcLast));
  664. }
  665. else
  666. if ((p->HalfX + 2*p->HalfY)==2)
  667. {
  668. int Mask = 0x7F7F7F7F;
  669. p->DiffMask = InstCreate32(Mask,NONE,NONE,NONE,0,0);
  670. I1P(LDR,R5,p->DiffMask,0);
  671. }
  673. p->LookUp = NULL;
  674. if (p->SrcYUV)
  675. CalcYUVLookUp(p);
  676. else if (p->Src.Palette)
  677. CalcPalYUVLookUp(p);
  679. if (p->LookUp_Data)
  680. {
  681. p->LookUp = InstCreate(p->LookUp_Data,p->LookUp_Size,NONE,NONE,NONE,0,0);
  682. free(p->LookUp_Data);
  683. p->LookUp_Data = NULL;
  684. I1P(MOV,R8,p->LookUp,0);
  685. p->LookUpOfs = 0;
  686. }
  687. else
  688. if (p->FX.Brightness)
  689. {
  690. int i = p->FX.Brightness;
  691. if (i<0) i=-i;
  692. if (i>127) i=127;
  693. MaskCarry = InstCreate32(0x80808080U,NONE,NONE,NONE,0,0);
  694. Add32 = InstCreate32(0x01010101U * (uint8_t)i,NONE,NONE,NONE,0,0);
  695. I1P(LDR,R8,MaskCarry,0);
  696. I1P(LDR,R9,Add32,0);
  697. }
  699. //EndOfRect
  700. //DstNext[2] 
  701. //SrcNext[2]
  703. RSrcWidth = R1;
  704. if (p->SrcBPP2>0)
  705. {
  706. IMul(R3,R1,p->SrcBPP/8);
  707. RSrcWidth = R3;
  708. }
  710. //SrcYNext = 4*Src->Pitch - Width
  711. I3S(RSB,R0,RSrcWidth,R14,LSL,2); 
  712. I2C(STR,R0,SP,OFS(stack,SrcNext[0]));
  714. //SrcUVNext = (4 << HalfY)*(Src->Pitch >> SrcUVPitch2) - (Width >> SrcUVX)
  715. I3S(MOV,R0,NONE,R14,LSL,2+p->HalfY-p->SrcUVPitch2); 
  716. I3S(SUB,R0,R0,RSrcWidth,LSR,p->SrcUVX2); 
  717. I2C(STR,R0,SP,OFS(stack,SrcNext[1]));
  719. //EndOfRect = Src + Src->Pitch * Height
  720. I3(MUL,R0,R14,R2);
  721. I3(ADD,R0,R0,R10);
  722. I2C(STR,R0,SP,OFS(stack,EndOfRect));
  724. if (p->SwapXY)
  725. {
  726. //DstYNext = 4*DirX - Width*Dst->Pitch
  727. I3(MUL,R3,R1,R12);
  728. I2C(MOV,R0,NONE,4*p->DirX);
  729. I3(SUB,R0,R0,R3);
  730. I2C(STR,R0,SP,OFS(stack,DstNext[0]));
  732. //DstUVNext = 4*DirX - (Width >> DstUVY2)*(Dst->Pitch >> DstUVPitch2)
  733. if (p->DstUVY2+p->DstUVPitch2) I3S(MOV,R3,NONE,R3,ASR,p->DstUVY2+p->DstUVPitch2);
  734. I2C(MOV,R0,NONE,4*p->DirX);
  735. I3(SUB,R0,R0,R3);
  736. I2C(STR,R0,SP,OFS(stack,DstNext[1]));
  737. }
  738. else
  739. {
  740. //DstYNext = 4*Dst->Pitch - DirX * Width
  741. I3S(p->DirX<0?ADD:RSB,R0,R1,R12,LSL,2); 
  742. I2C(STR,R0,SP,OFS(stack,DstNext[0]));
  744. //DstUVNext = 4*Dst->Pitch >> DstUVPitch2 - DirX * (Width >> DstUVX2)
  745. I3S(MOV,R0,NONE,R12,LSL,2-p->DstUVPitch2);
  746. I3S(p->DirX<0?ADD:SUB,R0,R0,R1,LSR,p->DstUVX2); 
  747. I2C(STR,R0,SP,OFS(stack,DstNext[1]));
  748. }
  750. LoopY = Label(0);
  751. I0P(B,AL,LoopY);
  753. if (p->DiffMask) InstPost(p->DiffMask);
  754. if (Add32) InstPost(Add32);
  755. if (MaskCarry) InstPost(MaskCarry);
  756. if (p->LookUp)
  757. {
  758. Align(16);
  759. InstPost(p->LookUp);
  760. }
  762. InstPost(LoopY);
  763. {
  764. if (p->LookUp)
  765. I2C(ADD,R8,R8,256+4);
  766. YUV_4X4(p,1);
  767. if (p->LookUp)
  768. I2C(ADD,R8,R8,256);
  769. YUV_4X4(p,2);
  770. if (p->LookUp)
  771. I2C(SUB,R8,R8,256+256+4);
  772. YUV_4X4(p,0);
  774. MB(); I2C(LDR,R2,SP,OFS(stack,EndOfRect));
  775. I3(CMP,NONE,R2,R7);
  776. I0P(B,NE,LoopY);
  777. }
  779. I2C(ADD,SP,SP,OFS(stack,StackFrame));
  780. CodeEnd();
  781. }
  783. #endif