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

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

Windows CE

开发平台：

C/C++

blit_sh3_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_sh3_fix.c 271 2005-08-09 08:31:35Z 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(SH3) 
  30. typedef struct stack
  31. {
  32. int EndOfRect;
  33. int EndOfLine;
  34. int DstNext;
  35. int SrcNext;
  36. int UVNext;
  37. int EndOfLineInc;
  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. // R0 lookup
  53. // R10 buffer_u
  54. // R11 buffer_v
  55. // R12 buffer_y1
  56. // R14 buffer_y2
  58. // R4  r / pal:dither acc
  59. // R5  g / pal:mask
  60. // R6  b / pal:mask
  61. // R8  y1
  62. // R9  y2
  64. // R2  tmp / pal:uv
  65. // R3  tmp 
  66. // R7  tmp / endofline 
  68. // R13 dest1
  69. // R1  pitch
  71. static NOINLINE void Fix_RGB_UV_LoadUV(blit_soft* p)
  72. {
  73. //set R4 =           RVMul*v + RAdd
  74. //set R5 = GUMul*u + GVMul*v + GAdd
  75. //set R6 = BUMul*u +           BAdd
  77. I2(MOVB_LDADD,R10,R2); //u
  78. I2(MOVB_LDADD,R11,R3); //v
  80. if (p->DstPalette)
  81. {
  82. I2(EXTUB,R2,R2);
  83. I2(EXTUB,R3,R3);
  84. I1(SHLR,R2);
  85. I1(SHLR,R3);
  86. I1(SHLL8,R2);
  87. I1(SHLL16,R3);
  88. I2(OR,R3,R2);
  89. }
  90. else
  91. {
  92. I1C(MOVI,R8,1);
  93. I1(SHLL8,R8);
  94. I2(ADD,R8,R2); //+=256
  95. I1(SHLL,R8);
  96. I2(ADD,R8,R3); //+=512
  98. I1(SHLL2,R2);
  99. I1(SHLL2,R3);
  101. I2(MOVW_LDR0,R2,R6);
  102. I2(MOVW_LDR0,R3,R4);
  104. I1C(ADDI,R2,2);
  105. I1C(ADDI,R3,2);
  107. I2(MOVW_LDR0,R2,R5);
  108. I2(MOVW_LDR0,R3,R9);
  110. I2(ADD,R9,R5);
  111. }
  112. }
  114. static NOINLINE void Fix_RGB_UV_Pixel(blit_soft* p, int Row)
  115. {
  116. //load Y
  117. if (p->SwapXY)
  118. {
  119. if (p->DirX>0)
  120. {
  121. I2(MOVB_LDADD,R14,R9); //y2
  122. I2(MOVB_LDADD,R12,R8); //y1
  123. }
  124. else
  125. {
  126. I2(MOVB_LDADD,R14,R8); //y1
  127. I2(MOVB_LDADD,R12,R9); //y2
  128. }
  129. }
  130. else
  131. {
  132. reg Y = (reg)(Row==0?R12:R14);
  133. if (p->DirX>0)
  134. {
  135. I2(MOVB_LDADD,Y,R8); //y1
  136. I2(MOVB_LDADD,Y,R9); //y2
  137. }
  138. else
  139. {
  140. I2(MOVB_LDADD,Y,R9); //y2
  141. I2(MOVB_LDADD,Y,R8); //y1
  142. }
  143. }
  145. if (p->DstPalette)
  146. {
  147. I2(EXTUB,R8,R8);
  148. I2(EXTUB,R9,R9);
  149. I1(SHLR,R8);
  150. I1(SHLR,R9);
  152. I1(SHLL16,R8);
  153. I1(SHLL16,R9);
  154. I1(SHLL8,R8);
  155. I1(SHLL8,R9);
  156. I2(OR,R2,R8);
  157. I2(OR,R2,R9);
  159. I2(ADD,R8,R4); //      yyvvuu00
  160. I2(MOV,R4,R3); 
  161. I2(MOV,R4,R7);
  162. I2(AND,R5,R3); // mask F0F00000
  163. I2(AND,R6,R7); // mask 0000F000
  164. I1(SHLR16,R3);
  165. I1(SHLR8,R7);
  166. I1(SHLR2,R3);
  167. I1(SHLL2,R7);
  168. I2(OR,R7,R3);
  169. I2(MOVL_LDR0,R3,R8);
  170. I2(SUB,R8,R4);
  172. I2(ADD,R9,R4); //      yyvvuu00
  173. I2(MOV,R4,R3); 
  174. I2(MOV,R4,R7);
  175. I2(AND,R5,R3); // mask F0F00000
  176. I2(AND,R6,R7); // mask 0000F000
  177. I1(SHLR16,R3);
  178. I1(SHLR8,R7);
  179. I1(SHLR2,R3);
  180. I1(SHLL2,R7);
  181. I2(OR,R7,R3);
  182. I2(MOVL_LDR0,R3,R9);
  183. I2(SUB,R9,R4);
  185. //Break();
  186. }
  187. else
  188. {
  189. I2(MOVB_LDR0,R8,R8);
  190. I2(MOVB_LDR0,R9,R9);
  192. I2(MOV,R4,R2);
  193. I2(ADD,R8,R2);
  194. I2(MOVB_LDR0,R2,R2);
  196. I2(MOV,R5,R3);
  197. I2(ADD,R8,R3);
  198. I2(MOVB_LDR0,R3,R3);
  200. I2(ADD,R6,R8);
  201. I2(MOVB_LDR0,R8,R8);
  203. IShift(R2,R7,p->DstPos[0]);
  204. IShift(R3,R7,p->DstPos[1]);
  205. IShift(R8,R7,p->DstPos[2]);
  207. I2(OR,R2,R8);
  208. I2(OR,R3,R8);
  210. I2(MOV,R4,R2);
  211. I2(ADD,R9,R2);
  212. I2(MOVB_LDR0,R2,R2);
  214. I2(MOV,R5,R3);
  215. I2(ADD,R9,R3);
  216. I2(MOVB_LDR0,R3,R3);
  218. I2(ADD,R6,R9);
  219. I2(MOVB_LDR0,R9,R9);
  221. IShift(R2,R7,p->DstPos[0]);
  222. IShift(R3,R7,p->DstPos[1]);
  223. IShift(R9,R7,p->DstPos[2]);
  225. I2(OR,R2,R9);
  226. I2(OR,R3,R9);
  228. if (!p->DstDoubleX && p->DstBPP <= 16)
  229. {
  230. I1(SHLL16,R9);
  231. I2(OR,R9,R8);
  232. }
  233. }
  234. }
  236. // R3,R2 for temp
  237. static NOINLINE void Write(blit_soft* p,reg Dst,reg A,reg B,bool_t Prepare)
  238. {
  239. switch (p->DstBPP)
  240. {
  241. case 8:
  242. if (p->DstDoubleX)
  243. {
  244. if (Prepare)
  245. {
  246. I2(EXTUB,B,B);
  247. I2(EXTUB,A,A);
  248. I1(SHLL16,B);
  249. I2(OR,B,A);
  250. I2(MOV,A,R3);
  251. I1(SHLL8,R3);
  252. I2(OR,R3,A);
  253. }
  254. I2(MOVL_ST,A,Dst);
  255. }
  256. else
  257. {
  258. if (Prepare)
  259. {
  260. I2(EXTUB,A,A);
  261. I1(SHLL8,B);
  262. I2(OR,B,A);
  263. }
  264. I2(MOVW_ST,A,Dst);
  265. }
  266. break;
  267. case 16:
  268. if (p->DstDoubleX)
  269. {
  270. if (Prepare)
  271. {
  272. I2(MOV,A,R3);
  273. I2(MOV,B,R2);
  274. I1(SHLL16,R3);
  275. I1(SHLL16,R2);
  276. I2(OR,R3,A);
  277. I2(OR,R2,B);
  278. }
  279. I2C(MOVL_STOFS,B,Dst,4);
  280. }
  281. I2C(MOVL_STOFS,A,Dst,0);
  282. break;
  283. }
  284. }
  286. void Fix_RGB_UV(blit_soft* p)
  287. {
  288. dyninst* Quit;
  289. dyninst* LoopYAddr;
  290. dyninst* Mask1;
  291. dyninst* Mask2;
  292. dyninst* LoopY;
  293. dyninst* LoopX;
  295. if (p->RScaleX == 8 || p->RScaleY == 8)
  296. p->DstAlignSize = 4;
  297. p->DstStepX = p->DirX * ((p->DstBPP*2) >> 3) << p->DstDoubleX;
  299. CodeBegin(7,OFS(stack,StackFrame));
  301. I2C(MOVL_LDOFS,R4,R0,OFS(blit_soft,LookUp_Data));
  302. if (!p->DstPalette)
  303. {
  304. CalcLookUp(p,0);
  305. I1C(ADDI,R0,64);
  306. I1C(ADDI,R0,64);
  307. }
  309. I2C(MOVL_LDOFS,R5,R13,0); //dst
  310. I2C(MOVL_LDOFS,R6,R10,4); //U
  311. I2C(MOVL_LDOFS,R6,R11,8); //V
  312. I2C(MOVL_LDOFS,R6,R12,0); //Y
  314. I2(MOV,R7,R1); //dstpitch
  316. I1C(MOVI,R2,OFS(stack,This));
  317. I2(ADD,SP,R2);
  318. I2C(MOVL_LDOFS,R2,R7,OFS(stack,SrcPitch)-OFS(stack,This));
  319. I2C(MOVL_LDOFS,R2,R5,OFS(stack,Height)-OFS(stack,This));
  320. I2C(MOVL_LDOFS,R2,R4,OFS(stack,Width)-OFS(stack,This));
  322. //SrcNext = 2*Src->Pitch - (Width >> SrcDoubleX)
  323. I2(MOV,R7,R2);
  324. I1(SHLL,R2);
  325. I2(MOV,R4,R3);
  326. IShift(R3,NONE,-p->SrcDoubleX);
  327. I2(SUB,R3,R2);
  328. I2C(MOVL_STOFS,R2,SP,OFS(stack,SrcNext));
  330. //UVNext = (Src->Pitch >> 1) - (Width >> SrcDoubleX >> 1);
  331. I2(MOV,R7,R2);
  332. I1(SHAR,R2);
  333. I2(MOV,R4,R3);
  334. IShift(R3,NONE,-p->SrcDoubleX-1);
  335. I2(SUB,R3,R2);
  336. I2C(MOVL_STOFS,R2,SP,OFS(stack,UVNext));
  338. if (p->DirX<0) //adjust reversed destination for block size
  339. I1C(ADDI,R13,p->DstStepX+(p->DstBPP >> 3));
  341. if (p->SwapXY)
  342. {
  343. I1C(MOVI,R3,p->DstBPP * p->DirX);
  344. I2(MULL,R3,R5); // p->DstBPP * p->DirX * Height
  345. I1C(MOVI,R2,-3);
  346. I1(STS_MACL,R3);
  347. I2(SHAD,R2,R3);
  348. I2(ADD,R13,R3);
  349. I2C(MOVL_STOFS,R3,SP,OFS(stack,EndOfRect));
  351. //DstNext = DstStepX - Width * DstPitch;
  352. I2(MULL,R1,R4);
  353. I1C(MOVI,R2,p->DstStepX);
  354. I1(STS_MACL,R3);
  355. I2(SUB,R3,R2);
  356. I2C(MOVL_STOFS,R2,SP,OFS(stack,DstNext));
  357. }
  358. else
  359. {
  360. I2(MULL,R1,R5); //Height * DstPitch
  361. I1(STS_MACL,R3);
  362. I2(ADD,R13,R3);
  363. I2C(MOVL_STOFS,R3,SP,OFS(stack,EndOfRect));
  365. //DstNext = ((DstPitch*2 << DstDoubleY) - DirX * Width << DstBPP2;
  366. I2(MOV,R1,R2);
  367. IShift(R2,NONE,p->DstDoubleY+1);
  368. I2(MOV,R4,R3);
  369. IShift(R3,NONE,p->DstBPP2);
  370. I2(p->DirX>0?SUB:ADD,R3,R2);
  371. I2C(MOVL_STOFS,R2,SP,OFS(stack,DstNext));
  372. }
  374. if (p->SwapXY)
  375. {
  376. I2(MULL,R1,R4); //width*dstpitch
  377. I1(STS_MACL,R3);
  378. I2(SUB,R1,R3); // - DstPitch
  379. }
  380. else
  381. {
  382. I2(MOV,R4,R3);
  383. IShift(R3,NONE,p->DstBPP2);
  384. if (p->DirX < 0)
  385. I2(NEG,R3,R3);
  386. I1C(ADDI,R3,-p->DstStepX); // -p->DstStepX
  387. }
  389. I2C(MOVL_STOFS,R3,SP,OFS(stack,EndOfLineInc));
  391. I2(MOV,R12,R14);
  392. I2(ADD,R7,R14);
  394. Quit = Label(0);
  395. LoopY = Label(1);
  396. LoopYAddr = ICode(LoopY,0);
  398. if (p->DstPalette)
  399. {
  400. Mask1 = InstCreate32(0xF0F00000,NONE,NONE,NONE,0,0);
  401. Mask2 = InstCreate32(0x0000F000,NONE,NONE,NONE,0,0);
  402. I1P(MOVL_PC,R5,Mask1,0);
  403. I1P(MOVL_PC,R6,Mask2,0);
  404. I1C(MOVI,R4,0);
  405. }
  407. // R3 = EndOfLineInc
  408. I2(MOV,R13,R7);
  409. I2(ADD,R3,R7);
  410. I2C(MOVL_STOFS,R7,SP,OFS(stack,EndOfLine));
  412. LoopX = Label(1);
  413. {
  414. Fix_RGB_UV_LoadUV(p);
  415. Fix_RGB_UV_Pixel(p,0);
  417. Write(p,R13,R8,R9,1);
  418. I2(ADD,R1,R13);
  420. if (p->DstDoubleY)
  421. {
  422. Write(p,R13,R8,R9,0);
  423. I2(ADD,R1,R13);
  424. }
  426. Fix_RGB_UV_Pixel(p,1);
  428. I2C(MOVL_LDOFS,SP,R7,OFS(stack,EndOfLine));
  430. Write(p,R13,R8,R9,1);
  432. if (p->DstDoubleY)
  433. {
  434. I2(ADD,R1,R13);
  435. Write(p,R13,R8,R9,0);
  436. }
  438. if (p->SwapXY)
  439. {
  440. I2(CMPEQ,R13,R7);
  441. I2(ADD,R1,R13);
  442. }
  443. else
  444. {
  445. I2(SUB,R1,R13);
  446. if (p->DstDoubleY)
  447. {
  448. I2(SUB,R1,R13);
  449. I2(SUB,R1,R13);
  450. }
  451. I2(CMPEQ,R13,R7);
  452. I1C(ADDI,R13,p->DstStepX);
  453. }
  455. DS(); I0P(BFS,LoopX);
  456. }
  458. I2C(MOVL_LDOFS,SP,R2,OFS(stack,SrcNext));
  459. I2C(MOVL_LDOFS,SP,R3,OFS(stack,DstNext));
  460. I2C(MOVL_LDOFS,SP,R9,OFS(stack,UVNext));
  461. I2C(MOVL_LDOFS,SP,R8,OFS(stack,EndOfRect));
  463. //increment pointers
  464. I2(ADD,R2,R12);
  465. I2(ADD,R2,R14);
  466. I2(ADD,R3,R13);
  468. I1P(MOVL_PC,R2,LoopYAddr,0);
  469. I2(ADD,R9,R10);
  470. I2(ADD,R9,R11);
  472. MB(); I2(CMPEQ,R13,R8);
  473. DS(); I0P(BTS,Quit);
  475. I2C(MOVL_LDOFS,SP,R3,OFS(stack,EndOfLineInc)); //prepare registers for next row
  476. DS(); I1(JMP,R2);
  478. InstPost(Quit);
  480. CodeEnd(7,OFS(stack,StackFrame));
  482. Align(4);
  483. InstPost(LoopYAddr);
  485. if (p->DstPalette)
  486. {
  487. InstPost(Mask1);
  488. InstPost(Mask2);
  489. }
  490. }
  492. #endif