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

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

Windows CE

开发平台：

C/C++

blit_mips_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_mips_fix.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(MIPS) 
  30. typedef struct stack
  31. {
  32. int EndOfRect;
  33. int DstNext;
  34. int SrcNext; // SrcPitch for scale
  35. int UVNext;
  36. int EndOfLineInc;
  37. int Y,U,V;
  39. int StackFrame[7];
  41. void* This;   //R4
  42. char* Dst;    //R5
  43. char* Src;    //R6
  44. int DstPitch; //R7
  45. int SrcPitch;
  46. int Width; 
  47. int Height;
  48. int Src2SrcLast;
  49. } stack;
  51. // R10 buffer_u
  52. // R11 buffer_v
  53. // R12 buffer_y1
  54. // R14 buffer_y2
  56. // R20 buffer_u2 (scale)
  57. // R21 buffer_v2 (scale)
  58. // R22 pos (scale)
  60. // R17 radd / pal:accy
  61. // R18 gadd / pal:accu
  62. // R19 badd / pal:accv
  64. // R13 negsat / LookUp_Y / pal:lookup
  65. // R15 possat / LookUp_U / pal:U
  67. // R4  r
  68. // R5  g
  69. // R6  b
  70. // R8  y1/rgb out
  71. // R9  y2/(rgb2 out)
  73. // R16 tmp / LookUp_V / pal:V
  74. // R2  tmp
  75. // R3  tmp
  77. // R7  endofline
  78. // R24 dest
  79. // R25 pitch
  80. // R1  tmp dest
  82. static NOINLINE int ConstAdjust(int v)
  83. {
  84. if (v>0)
  85. return (v + 0x1000) >> (16-3);
  86. return -((-v + 0x1000) >> (16-3));
  87. }
  89. static NOINLINE void Fix_RGB_UV_LoadUV(blit_soft* p,int OfsUV,int OfsUV2)
  90. {
  91. if (p->DstPalette)
  92. {
  93. if (!p->Scale)
  94. {
  95. I2C(LBU,R15,R10,0); //u
  96. I2C(ADDIU,R10,R10,1);
  97. I2C(LBU,R16,R11,0); //v
  98. I2C(ADDIU,R11,R11,1);
  99. }
  100. else
  101. {
  102. reg U = R10;
  103. reg V = R11;
  104. reg U2 = R10;
  105. reg V2 = R11;
  107. if (p->SwapXY)
  108. {
  109. if (p->DirX<0)
  110. {
  111. U = R20;
  112. V = R21;
  113. }
  114. else
  115. {
  116. U2 = R20;
  117. V2 = R21;
  118. }
  119. }
  121. I2C(LBU,R2,U2,OfsUV2); //u2
  122. I2C(LBU,R3,V2,OfsUV2); //v2
  124. I2C(LBU,R15,U,OfsUV); //u
  125. I2C(LBU,R16,V,OfsUV); //v
  126. }
  127. }
  128. else
  129. if (p->ColorLookup)
  130. {
  131. //set R4 =           RVMul*v + RAdd
  132. //set R5 = GUMul*u + GVMul*v + GAdd
  133. //set R6 = BUMul*u +           BAdd
  135. I2C(LBU,R2,R10,0); //u
  136. I2C(LBU,R3,R11,0); //v
  138. I2C(SLL,R2,R2,3);
  139. I2C(SLL,R3,R3,3);
  141. I3(ADDU,R2,R2,R15); //LookUp_U + u
  142. I3(ADDU,R3,R3,R16); //LookUp_V + v
  144. I2C(LW,R8,R2,4);
  145. I2C(ADDIU,R10,R10,1);
  146. I2C(LW,R9,R3,4);
  147. I2C(ADDIU,R11,R11,1);
  148. I2C(LW,R6,R2,0);
  149. I3(ADDU,R5,R8,R9);
  150. I2C(LW,R4,R3,0);
  151. }
  152. else
  153. {
  154. reg v;
  155. bool_t Neg;
  157. if (!p->Scale)
  158. {
  159. I2C(LBU,R4,R10,0); //u
  160. I2C(LBU,R5,R11,0); //v
  162. I2C(ADDIU,R10,R10,1);
  163. I2C(ADDIU,R11,R11,1);
  165. I2C(SLL,R2,R4,16);
  166. I2C(SLL,R3,R5,16);
  167. }
  168. else
  169. {
  170. reg U = R10;
  171. reg V = R11;
  172. reg U2 = R10;
  173. reg V2 = R11;
  175. if (p->SwapXY)
  176. {
  177. if (p->DirX<0)
  178. {
  179. U = R20;
  180. V = R21;
  181. }
  182. else
  183. {
  184. U2 = R20;
  185. V2 = R21;
  186. }
  187. }
  189. I2C(LBU,R2,U2,OfsUV2); //u2
  190. I2C(LBU,R3,V2,OfsUV2); //v2
  192. I2C(LBU,R4,U,OfsUV); //u
  193. I2C(SLL,R2,R2,16);
  194. I2C(LBU,R5,V,OfsUV); //v
  195. I2C(SLL,R3,R3,16);
  196. }
  198. I3(OR,R2,R4,R2); // u | u
  199. I3(OR,R3,R5,R3); // v | v
  201. v = IMul(R2,ConstAdjust(p->_GUMul),R16,R4,R6,&Neg);
  202. I3(Neg?SUBU:ADDU,R5,R18,v);
  203. v = IMul(R3,ConstAdjust(p->_GVMul),R16,R4,R6,&Neg);
  204. I3(Neg?SUBU:ADDU,R5,R5,v);
  205. v = IMul(R3,ConstAdjust(p->_RVMul),R16,R4,R6,&Neg);
  206. I3(Neg?SUBU:ADDU,R4,R17,v);
  207. v = IMul(R2,ConstAdjust(p->_BUMul),R16,R3,R6,&Neg);
  208. I3(Neg?SUBU:ADDU,R6,R19,v);
  209. }
  210. }
  212. static NOINLINE void Fix_RGB_UV_Pixel(blit_soft* p, int Row, int Col)
  213. {
  214. int Shift;
  215. reg v;
  216. reg Y1,Y2;
  217. bool_t Neg;
  218. int OfsY;
  219. int OfsUV;
  220. int OfsY2;
  221. int OfsUV2;
  223. if (p->Scale)
  224. {
  225. OfsY = (Col * p->RScaleX) >> 4;
  226. OfsUV = (Col * p->RScaleX) >> (4+p->SrcUVX2);
  228. if (!p->SwapXY)
  229. {
  230. OfsY2 = ((Col+1) * p->RScaleX) >> 4;
  231. OfsUV2 = ((Col+1) * p->RScaleX) >> (4+p->SrcUVX2);
  232. }
  233. else
  234. {
  235. OfsY2 = OfsY;
  236. OfsUV2 = OfsUV;
  237. }
  239. Fix_RGB_UV_LoadUV(p,OfsUV,OfsUV2);
  240. }
  241. else
  242. {
  243. if (p->SwapXY)
  244. {
  245. OfsY = Row;
  246. OfsY2 = Row;
  247. }
  248. else
  249. {
  250. OfsY = 0;
  251. OfsY2 = 1;
  252. }
  253. }
  255. if (p->SwapXY)
  256. {
  257. Y1 = R12;
  258. Y2 = R14;
  259. }
  260. else
  261. Y1 = Y2 = (reg)(Row==0?R12:R14);
  263. //load Y
  264. if (p->DirX>0)
  265. {
  266. I2C(LBU,R9,Y2,OfsY2); //y2
  267. I2C(LBU,R8,Y1,OfsY);  //y1
  268. }
  269. else
  270. {
  271. I2C(LBU,R9,Y1,OfsY);  //y2
  272. I2C(LBU,R8,Y2,OfsY2); //y1
  273. }
  275. if (p->DstPalette)
  276. {
  277. I3(ADDU,R17,R17,R8);
  278. I3(ADDU,R18,R18,R15);
  279. I3(ADDU,R19,R19,R16);
  281. I2C(ANDI,R4,R17,0x1E0); 
  282. I2C(ANDI,R5,R18,0x1E0); 
  283. I2C(ANDI,R6,R19,0x1E0); 
  285. I2C(SLL,R4,R4,5); 
  286. I2C(SLL,R5,R5,1);
  287. I2C(SRL,R6,R6,3);
  289. I3(ADDU,R4,R4,R13);
  290. I3(ADDU,R4,R4,R5);
  291. I3(ADDU,R4,R4,R6);
  293. I2C(LBU,R8,R4,0);
  294. I2C(LBU,R6,R4,1);
  295. I2C(LBU,R5,R4,2);
  296. I2C(LBU,R4,R4,3);
  298. I3(SUBU,R17,R17,R6);
  299. I3(SUBU,R18,R18,R5);
  300. I3(SUBU,R19,R19,R4);
  302. I3(ADDU,R17,R17,R9);
  303. I3(ADDU,R18,R18,(reg)(p->Scale ? R2:R15));
  304. I3(ADDU,R19,R19,(reg)(p->Scale ? R3:R16));
  306. I2C(ANDI,R4,R17,0x1E0); 
  307. I2C(ANDI,R5,R18,0x1E0); 
  308. I2C(ANDI,R6,R19,0x1E0); 
  310. I2C(SLL,R4,R4,5); 
  311. I2C(SLL,R5,R5,1);
  312. I2C(SRL,R6,R6,3);
  314. I3(ADDU,R4,R4,R13);
  315. I3(ADDU,R4,R4,R5);
  316. I3(ADDU,R4,R4,R6);
  318. I2C(LBU,R9,R4,0);
  319. I2C(LBU,R6,R4,1);
  320. I2C(LBU,R5,R4,2);
  321. I2C(LBU,R4,R4,3);
  323. I3(SUBU,R17,R17,R6);
  324. I3(SUBU,R18,R18,R5);
  325. I3(SUBU,R19,R19,R4);
  326. }
  327. else
  328. if (p->ColorLookup)
  329. {
  330. I3(ADDU,R8,R8,R13); //LookUp_Y + y1
  331. I2C(LBU,R8,R8,0);
  333. I3(ADDU,R9,R9,R13); //LookUp_Y + y2
  334. I2C(LBU,R9,R9,0);
  336. I3(ADDU,R2,R4,R8);
  337. I2C(LBU,R2,R2,0);
  339. I3(ADDU,R3,R5,R8);
  340. I2C(LBU,R3,R3,0);
  342. I3(ADDU,R8,R6,R8);
  343. I2C(LBU,R8,R8,0);
  345. I2C(SLL,R2,R2,p->DstPos[0]);
  346. I2C(SLL,R3,R3,p->DstPos[1]);
  347. if (p->DstPos[2]) I2C(SLL,R8,R8,p->DstPos[2]);
  349. I3(OR,R8,R8,R2);
  350. I3(OR,R8,R8,R3);
  352. I3(ADDU,R2,R4,R9);
  353. I2C(LBU,R2,R2,0);
  355. I3(ADDU,R3,R5,R9);
  356. I2C(LBU,R3,R3,0);
  358. I3(ADDU,R9,R6,R9);
  359. I2C(LBU,R9,R9,0);
  361. if (p->DstDoubleX || p->DstBPP > 16)
  362. {
  363. I2C(SLL,R2,R2,p->DstPos[0]);
  364. I2C(SLL,R3,R3,p->DstPos[1]);
  365. if (p->DstPos[2]) I2C(SLL,R9,R9,p->DstPos[2]);
  367. I3(OR,R9,R9,R2);
  368. I3(OR,R9,R9,R3);
  369. }
  370. else
  371. {
  372. I2C(SLL,R2,R2,p->DstPos[0]+16);
  373. I2C(SLL,R3,R3,p->DstPos[1]+16);
  374. I2C(SLL,R9,R9,p->DstPos[2]+16);
  376. I3(OR,R8,R8,R2);
  377. I3(OR,R8,R8,R3);
  378. I3(OR,R8,R8,R9);
  379. }
  380. }
  381. else
  382. {
  383. I2C(SLL,R9,R9,16);
  384. I3(OR,R8,R8,R9); // y1 | y2
  386. v = IMul(R8,ConstAdjust(p->_YMul),R16,R3,R2,&Neg);
  388. I3(Neg?SUBU:ADDU,R8,R4,v);
  389. I3(Neg?SUBU:ADDU,R9,R5,v);
  390. I3(Neg?SUBU:ADDU,R16,R6,v);
  392. // negative sat and mask final rbg
  393. I3(NOR,R2,R8,R13);
  394. I2C(SRL,R3,R2,4+p->DstSize[0]);
  395. I3(SUBU,R2,R2,R3);
  396. I3(AND,R8,R8,R2);
  398. I3(NOR,R2,R9,R13);
  399. I2C(SRL,R3,R2,4+p->DstSize[1]);
  400. I3(SUBU,R2,R2,R3);
  401. I3(AND,R9,R9,R2);
  403. I3(NOR,R2,R16,R13);
  404. I2C(SRL,R3,R2,4+p->DstSize[2]);
  405. I3(SUBU,R2,R2,R3);
  406. I3(AND,R16,R16,R2);
  408. // positive sat
  409. I3(AND,R2,R8,R15);
  410. I2C(SRL,R3,R2,p->DstSize[0]);
  411. I3(SUBU,R2,R2,R3);
  412. I3(OR,R8,R8,R2);
  414. I3(AND,R2,R9,R15);
  415. I2C(SRL,R3,R2,p->DstSize[1]);
  416. I3(SUBU,R2,R2,R3);
  417. I3(OR,R9,R9,R2);
  419. I3(AND,R2,R16,R15);
  420. I2C(SRL,R3,R2,p->DstSize[2]);
  421. I3(SUBU,R2,R2,R3);
  422. I3(OR,R16,R16,R2);
  424. Shift = p->DstPos[0] + p->DstSize[0] - (8+3);
  425. if (Shift) I2C(SLL,R8,R8,Shift);
  426. Shift = p->DstPos[1] + p->DstSize[1] - (8+3);
  427. if (Shift) I2C(SLL,R9,R9,Shift);
  428. Shift = p->DstPos[2] + p->DstSize[2] - (8+3);
  429. if (Shift) I2C(SLL,R16,R16,Shift);
  431. I3(OR,R8,R8,R9);
  432. I3(OR,R8,R8,R16);
  433. }
  434. }
  436. // R3,R2 for temp
  437. static NOINLINE void Write(blit_soft* p,reg Dst,reg A,reg B,bool_t Prepare)
  438. {
  439. switch (p->DstBPP)
  440. {
  441. case 8:
  442. if (p->DstDoubleX)
  443. {
  444. if (Prepare)
  445. {
  446. I2C(SLL,R3,A,8);
  447. I3(OR,A,A,R3);
  448. I2C(SLL,R3,B,8);
  449. I3(OR,B,B,R3);
  450. I2C(SLL,R3,B,16);
  451. I3(OR,A,A,R3);
  452. }
  453. I2C(SW,A,Dst,0);
  454. }
  455. else
  456. {
  457. if (Prepare)
  458. {
  459. I2C(SLL,R3,B,8);
  460. I3(OR,A,A,R3);
  461. }
  462. I2C(SH,A,Dst,0);
  463. }
  464. break;
  466. case 16:
  467. if (p->Dst.Flags & PF_16BITACCESS)
  468. {
  469. if (p->DstDoubleX)
  470. {
  471. if (Prepare && !p->ColorLookup)
  472. I2C(SRL,B,A,16);
  474. I2C(SH,A,Dst,0);
  475. I2C(SH,A,Dst,2);
  476. I2C(SH,B,Dst,4);
  477. I2C(SH,B,Dst,6);
  478. }
  479. else
  480. {
  481. if (Prepare)
  482. I2C(SRL,B,A,16);
  484. I2C(SH,A,Dst,0);
  485. I2C(SH,B,Dst,2);
  486. }
  487. }
  488. else
  489. {
  490. if (p->DstDoubleX)
  491. {
  492. if (Prepare)
  493. {
  494. if (p->ColorLookup)
  495. {
  496. I2C(SLL,R3,A,16);
  497. I2C(SLL,R2,B,16);
  498. I3(OR,A,A,R3);
  499. I3(OR,B,B,R2);
  500. }
  501. else
  502. {
  503. I2C(SLL,R3,A,16);
  504. I2C(SRL,R2,A,16);
  505. I2C(SRL,A,R3,16);
  506. I2C(SLL,B,R2,16);
  507. I3(OR,A,A,R3);
  508. I3(OR,B,B,R2);
  509. }
  510. }
  511. I2C(SW,B,Dst,4);
  512. }
  513. I2C(SW,A,Dst,0);
  514. }
  515. break;
  516. case 24:
  517. if (p->DstDoubleX)
  518. {
  519. if (Prepare)
  520. {
  521. I2C(SLL,R3,A,24);
  522. I2C(SRL,R2,A,8);
  523. I3(OR,A,A,R3);
  524. I2C(SLL,R3,B,16);
  525. I3(OR,R3,R3,R2);
  526. I2C(SRL,R2,B,16);
  527. I2C(SLL,B,B,8);
  528. I3(OR,B,B,R2);
  529. }
  530. I2C(SW,A,Dst,0);
  531. I2C(SW,R3,Dst,4);
  532. I2C(SW,B,Dst,8);
  533. }
  534. else
  535. {
  536. if (Prepare)
  537. {
  538. I2C(SRL,R3,A,16);
  539. I2C(SLL,B,B,8);
  540. I3(OR,R3,R3,B);
  541. I2C(SRL,B,B,16);
  542. }
  543. I2C(SH,A,Dst,0);
  544. I2C(SH,R3,Dst,2);
  545. I2C(SH,B,Dst,4);
  546. }
  547. break;
  548. case 32:
  549. if (p->DstDoubleX)
  550. {
  551. I2C(SW,A,Dst,0);
  552. I2C(SW,A,Dst,4);
  553. I2C(SW,B,Dst,8);
  554. I2C(SW,B,Dst,12);
  555. }
  556. else
  557. {
  558. I2C(SW,A,Dst,0);
  559. I2C(SW,B,Dst,4);
  560. }
  561. break;
  562. }
  563. }
  565. void Fix_RGB_UV(blit_soft* p)
  566. {
  567. int Col,ColCount,i,RowStep;
  568. dyninst* LoopY;
  569. dyninst* LoopX;
  570. dyninst* EndOfLine;
  572. p->Scale = (boolmem_t)(!(p->RScaleX == 8 || p->RScaleX == 16) || 
  573. !(p->RScaleY == 8 || p->RScaleY == 16) ||
  574. p->SrcUVX2!=1 || p->SrcUVY2!=1);
  576. if (p->Scale)
  577. {
  578. p->DstDoubleX = p->DstDoubleY = 0;
  579. p->ColorLookup = 0;
  580. }
  582. if (p->RScaleX == 8 || p->RScaleY == 8)
  583. p->DstAlignSize = 4;
  584. p->DstStepX = p->DirX * ((p->DstBPP*2) >> 3) << p->DstDoubleX;
  586. CodeBegin(7,OFS(stack,StackFrame),0);
  588. if (p->DstPalette)
  589. {
  590. IConst(R17,0);
  591. IConst(R18,0);
  592. IConst(R19,0);
  593. I2C(LW,R13,R4,OFS(blit_soft,LookUp_Data));
  594. }
  595. else
  596. if (p->ColorLookup)
  597. {
  598. CalcLookUp(p,0);
  599. I2C(LW,R13,R4,OFS(blit_soft,LookUp_Data));
  600. I2C(ADDIU,R15,R13,p->LookUp_U);
  601. I2C(ADDIU,R16,R13,p->LookUp_V);
  602. }
  603. else
  604. {
  605. IConst(R17,(ConstAdjust(p->_RAdd) & 0xFFFF) * 0x10001);
  606. IConst(R18,(ConstAdjust(p->_GAdd) & 0xFFFF) * 0x10001);
  607. IConst(R19,(ConstAdjust(p->_BAdd) & 0xFFFF) * 0x10001);
  609. IConst(R15,0x01000100 << 3); //possat
  610. IConst(R13,0x7FFF7FFF); //negsat
  611. }
  613. I2C(LW,R24,R5,0); //Dst[0] RGB
  614. I2C(LW,R10,R6,4); //Src[1] U
  615. I2C(LW,R11,R6,8); //Src[2] V
  616. I2C(LW,R12,R6,0); //Src[0] Y
  617. I3(ADDU,R25,R7,ZERO); //DstPitch
  619. if (p->Scale)
  620. {
  621. I2C(SW,R10,SP,OFS(stack,U));
  622. I2C(SW,R11,SP,OFS(stack,V));
  623. I2C(SW,R12,SP,OFS(stack,Y));
  624. I2C(LW,R7,SP,OFS(stack,SrcPitch));
  625. }
  627. I2C(LW,R7,SP,OFS(stack,SrcPitch));
  628. I2C(LW,R5,SP,OFS(stack,Height));
  629. I2C(LW,R4,SP,OFS(stack,Width));
  631. if (!p->Scale)
  632. {
  633. //SrcNext = 2*Src->Pitch - (Width >> SrcDoubleX)
  634. I2C(SLL,R2,R7,1);
  635. if (p->SrcDoubleX)
  636. {
  637. I2C(SRL,R3,R4,p->SrcDoubleX);
  638. I3(SUBU,R2,R2,R3); 
  639. }
  640. else
  641. I3(SUBU,R2,R2,R4); 
  642. I2C(SW,R2,SP,OFS(stack,SrcNext));
  644. //UVNext = (Src->Pitch >> 1) - (Width >> SrcDoubleX >> 1);
  645. I2C(SRA,R2,R7,1);
  646. I2C(SRL,R3,R4,p->SrcDoubleX+1);
  647. I3(SUBU,R2,R2,R3); 
  648. I2C(SW,R2,SP,OFS(stack,UVNext));
  649. }
  650. else
  651. I2C(SW,R7,SP,OFS(stack,SrcNext));
  653. if (p->DirX<0) //adjust reversed destination for block size
  654. I2C(ADDIU,R24,R24,p->DstStepX+(p->DstBPP >> 3));
  656. if (p->SwapXY)
  657. {
  658. I2C(ADDIU,R3,ZERO,p->DstBPP * p->DirX);
  659. I2(MULT,R5,R3); // p->DstBPP * p->DirX * Height
  660. I1(MFLO,R3);
  661. I2C(SRA,R3,R3,3); // bits->byte
  662. I3(ADDU,R3,R3,R24);
  663. I2C(SW,R3,SP,OFS(stack,EndOfRect));
  665. //DstNext = DstStepX - Width * DstPitch;
  666. I2(MULT,R25,R4);
  667. I1(MFLO,R2);
  668. I2C(ADDIU,R3,ZERO,p->DstStepX);
  669. I3(SUBU,R3,R3,R2);
  670. I2C(SW,R3,SP,OFS(stack,DstNext));
  671. }
  672. else
  673. {
  674. I2(MULT,R5,R25); //Height * DstPitch
  675. I1(MFLO,R3);
  676. I3(ADDU,R3,R3,R24);
  677. I2C(SW,R3,SP,OFS(stack,EndOfRect));
  679. //DstNext = ((DstPitch*(Scale?1:2) << DstDoubleY) - DirX * Width << DstBPP2;
  680. I2C(SLL,R2,R25,p->DstDoubleY+(p->Scale?0:1));
  681. I2C(SLL,R3,R4,p->DstBPP2);
  682. I3(p->DirX>0?SUBU:ADDU,R2,R2,R3);
  683. I2C(SW,R2,SP,OFS(stack,DstNext));
  684. }
  686. if (p->SwapXY)
  687. {
  688. I2(MULT,R25,R4); // Width * DstPitch
  689. I1(MFLO,R4);
  690. }
  691. else
  692. {
  693. I2C(SLL,R4,R4,p->DstBPP2);
  694. if (p->DirX < 0)
  695. I3(SUBU,R4,ZERO,R4);
  696. }
  697. I2C(SW,R4,SP,OFS(stack,EndOfLineInc));
  699. if (p->Scale)
  700. I3(ADDU,R22,ZERO,ZERO); //pos=0
  701. else
  702. I3(ADDU,R14,R12,R7);
  704. ColCount = 32;
  705. for (i=1;i<16 && !(p->RScaleX & i);i<<=1)
  706. ColCount >>= 1;
  708. LoopY = Label(1);
  710. // R4 = EndOfLineInc
  711. I3(ADDU,R7,R24,R4);
  713. LoopX = Label(1);
  715. if (p->Scale)
  716. {
  717. EndOfLine = Label(0);
  719. if (p->SwapXY)
  720. {
  721. //we need next row in R14,R20,R21 (YUV)
  722. I2C(LW,R2,SP,OFS(stack,SrcNext)); //srcpitch
  724. //increment row of Y,U,V according to Pos -> Pos+RowStep*RScaleY
  725. I2C(ADDIU,R9,R22,p->RScaleY); //Pos += RScaleY
  726. I2C(SRL,R8,R22,4);
  727. I2C(SRL,R9,R9,4);
  729. // dY  = ((Pos+RowStep*RScaleY) >> 4) - (Pos >> 4);
  730. I3(SUBU,R4,R9,R8); 
  731. I2(MULT,R4,R2); // dY * SrcPitch
  732. I1(MFLO,R4);
  733. I3(ADDU,R14,R12,R4);
  735. // dUV = ((Pos+RowStep*RScaleY) >> (4+SrcUVY2)) - (Pos >> (4+SrcUVY2));
  736. if (p->SrcUVY2) I2C(SRL,R9,R9,p->SrcUVY2);
  737. if (p->SrcUVY2) I2C(SRL,R8,R8,p->SrcUVY2);
  738. I3(SUBU,R4,R9,R8); 
  739. I2(MULT,R4,R2); // dUV * (SrcPitch >> SrcUVX2)
  740. I1(MFLO,R4);
  741. if (p->SrcUVX2) I2C(SRA,R4,R4,p->SrcUVX2);
  742. I3(ADDU,R20,R10,R4);
  743. I3(ADDU,R21,R11,R4);
  744. }
  746. for (Col=0;Col<ColCount;)
  747. {
  748. Fix_RGB_UV_Pixel(p,0,Col);
  750. ++Col;
  751. if (!p->SwapXY)
  752. ++Col;
  754. Write(p,R24,R8,R9,1);
  756. if (p->SwapXY)
  757. I3(ADDU,R24,R24,R25);
  758. else
  759. I2C(ADDIU,R24,R24,p->DstStepX);
  761. if (Col == ColCount) 
  762. {
  763. //last item in block, increase source pointers
  765. I2C(ADDIU,R12,R12,(p->RScaleX * ColCount) >> 4);
  766. I2C(ADDIU,R10,R10,(p->RScaleX * ColCount) >> (4+p->SrcUVX2));
  767. I2C(ADDIU,R11,R11,(p->RScaleX * ColCount) >> (4+p->SrcUVX2));
  769. if (p->SwapXY)
  770. {
  771. I2C(ADDIU,R14,R14,(p->RScaleX * ColCount) >> 4);
  772. I2C(ADDIU,R20,R20,(p->RScaleX * ColCount) >> (4+p->SrcUVX2));
  773. I2C(ADDIU,R21,R21,(p->RScaleX * ColCount) >> (4+p->SrcUVX2));
  774. }
  776. DS(); I2P(BNE,R24,R7,LoopX);
  777. }
  778. else
  779. {
  780. I2P(BEQ,R24,R7,EndOfLine); // delay slot will be the next item
  781. }
  782. }
  784. InstPost(EndOfLine);
  786. I2C(LW,R2,SP,OFS(stack,SrcNext)); //srcpitch
  787. I2C(LW,R4,SP,OFS(stack,DstNext));
  788. I2C(LW,R5,SP,OFS(stack,EndOfRect));
  790. I2C(LW,R10,SP,OFS(stack,U));
  791. I2C(LW,R11,SP,OFS(stack,V));
  792. I2C(LW,R12,SP,OFS(stack,Y));
  794. //increment pointers
  795. I3(ADDU,R24,R24,R4);
  797. RowStep = (p->SwapXY) ? 2:1;
  799. //increment row of Y,U,V according to Pos -> Pos+RowStep*RScaleY
  800. I2C(SRL,R8,R22,4);
  801. I2C(ADDIU,R22,R22,RowStep*p->RScaleY); //Pos += RowStep*RScaleY
  802. I2C(SRL,R9,R22,4);
  804. // dY  = ((Pos+RowStep*RScaleY) >> 4) - (Pos >> 4);
  805. I3(SUBU,R4,R9,R8); 
  806. I2(MULT,R4,R2); // dY * SrcPitch
  807. I1(MFLO,R4);
  808. I3(ADDU,R12,R12,R4);
  810.     // dUV = ((Pos+RowStep*RScaleY) >> (4+SrcUVY2)) - (Pos >> (4+SrcUVY2));
  811. if (p->SrcUVY2) I2C(SRL,R9,R9,p->SrcUVY2);
  812. if (p->SrcUVY2) I2C(SRL,R8,R8,p->SrcUVY2);
  813. I3(SUBU,R4,R9,R8); 
  814. I2(MULT,R4,R2); // dUV * (SrcPitch >> SrcUVX2)
  815. I1(MFLO,R4);
  816. if (p->SrcUVX2) I2C(SRA,R4,R4,p->SrcUVX2);
  817. I3(ADDU,R10,R10,R4);
  818. I3(ADDU,R11,R11,R4);
  820. I2C(SW,R10,SP,OFS(stack,U));
  821. I2C(SW,R11,SP,OFS(stack,V));
  822. I2C(SW,R12,SP,OFS(stack,Y));
  823. }
  824. else
  825. {
  826. reg Dst;
  828. Fix_RGB_UV_LoadUV(p,0,0);
  829. Fix_RGB_UV_Pixel(p,0,0);
  831. Dst = R24;
  832. if (!p->SwapXY)
  833. Dst = R1;
  835. Write(p,R24,R8,R9,1);
  836. I3(ADDU,Dst,R24,R25);
  838. if (p->DstDoubleY)
  839. {
  840. Write(p,Dst,R8,R9,0);
  841. I3(ADDU,Dst,Dst,R25);
  842. }
  844. Fix_RGB_UV_Pixel(p,1,0);
  846. Write(p,Dst,R8,R9,1);
  848. if (p->DstDoubleY)
  849. {
  850. I3(ADDU,Dst,Dst,R25);
  851. Write(p,Dst,R8,R9,0);
  852. }
  854. if (p->SwapXY)
  855. I3(ADDU,Dst,Dst,R25);
  856. else
  857. I2C(ADDIU,R24,R24,p->DstStepX);
  859. I2C(ADDIU,R12,R12,2);
  860. I2C(ADDIU,R14,R14,2);
  862. DS(); I2P(BNE,R24,R7,LoopX);
  864. I2C(LW,R2,SP,OFS(stack,SrcNext));
  865. I2C(LW,R4,SP,OFS(stack,DstNext));
  866. I2C(LW,R6,SP,OFS(stack,UVNext));
  867. I2C(LW,R5,SP,OFS(stack,EndOfRect));
  869. //increment pointers
  870. I3(ADDU,R12,R12,R2);
  871. I3(ADDU,R14,R14,R2);
  872. I3(ADDU,R24,R24,R4);
  873. I3(ADDU,R10,R10,R6);
  874. I3(ADDU,R11,R11,R6);
  875. }
  877. //prepare registers for next row
  878. I2C(LW,R4,SP,OFS(stack,EndOfLineInc));
  880. DS(); I2P(BNE,R24,R5,LoopY);
  882. CodeEnd(7,OFS(stack,StackFrame),0);
  883. }
  885. #endif