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

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

Windows CE

开发平台：

C/C++

pcm_sh3.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: pcm_sh3.c 304 2005-10-20 11:02:59Z 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 "pcm_soft.h"
  28. #if defined(SH3)
  30. typedef struct stack
  31. {
  32. int Step; //backup
  34. int StackFrame[7];
  36. void* this;    //R4
  37. char* Dst;    //R5
  38. char* Src;     //R6
  39. int DstLength; //R7
  40. pcmstate* State;
  41. int Volume;
  43. } stack;
  45. // R0 temp index
  46. // R13,R1 dither (or R13=shift,-shift) (or R1=volume)
  47. // R2,R3 value
  48. // R4 Min
  49. // R5 Max
  50. // R7 Step
  51. // R8 Pos
  52. // R9 SrcLeft
  53. // R10 SrcRight
  54. // R11 DstLeft
  55. // R12 DstRight
  56. // R14 DstLeftEnd
  58. void PCMLoop(pcm_soft* p,bool_t Speed)
  59. {
  60. bool_t SrcPacked = !(p->Src.Flags & PCM_PLANES) && p->Src.Channels==2;
  61. dyninst* Loop;
  62. reg Left;
  63. reg Right;
  64. reg Shift;
  66. if (!p->ActualDither && p->Shift)
  67. I1C(MOVI,R13,p->Shift);
  69. if (p->ActualDither)
  70. if (Speed)
  71. I2C(MOVL_STOFS,R7,SP,OFS(stack,Step)); // save backup
  72. else
  73. I1C(MOVI,R7,-p->Shift);
  75. Loop = Label(1);
  77. Left = R2;
  78. if (p->UseLeft)
  79. Right = R3;
  80. else
  81. Right = R2;
  83. if (Speed)
  84. {
  85. I2(MOV,R8,R0);
  86. IShift(R0,NONE,-8);
  87. IShift(R0,NONE,p->SrcShift);
  89. switch (p->Src.Bits)
  90. {
  91. case 8:
  92. if (p->UseLeft)
  93. I2(MOVB_LDR0,R9,Left);
  94. if (p->UseRight)
  95. I2(MOVB_LDR0,R10,Right);
  97. if (p->SrcUnsigned)
  98. {
  99. I2(EXTUB,R2,R2);
  100. if (p->SrcChannels>1)
  101. I2(EXTUB,R3,R3);
  102. }
  103. break;
  105. case 16:
  106. if (p->UseLeft)
  107. I2(MOVW_LDR0,R9,Left);
  108. if (p->UseRight)
  109. I2(MOVW_LDR0,R10,Right);
  111. if (p->SrcUnsigned)
  112. {
  113. I2(EXTUW,R2,R2);
  114. if (p->SrcChannels>1)
  115. I2(EXTUW,R3,R3);
  116. }
  117. break;
  119. case 32:
  120. if (p->UseLeft)
  121. I2(MOVL_LDR0,R9,Left);
  122. if (p->UseRight)
  123. I2(MOVL_LDR0,R10,Right);
  124. break;
  125. }
  127. I2(ADD,R7,R8);
  128. }
  129. else
  130. {
  131. switch (p->Src.Bits)
  132. {
  133. case 8:
  134. if (p->UseLeft)
  135. {
  136. I2(MOVB_LDADD,R9,Left);
  137. if (SrcPacked && !p->UseRight) I1C(ADDI,R9,1);
  138. }
  139. if (p->UseRight)
  140. if (SrcPacked)
  141. {
  142. if (!p->UseLeft) I1C(ADDI,R9,1);
  143. I2(MOVB_LDADD,R9,Right);
  144. }
  145. else
  146. I2(MOVB_LDADD,R10,Right);
  148. if (p->SrcUnsigned)
  149. {
  150. I2(EXTUB,R2,R2);
  151. if (p->SrcChannels>1)
  152. I2(EXTUB,R3,R3);
  153. }
  154. break;
  156. case 16:
  157. if (p->UseLeft)
  158. {
  159. I2(MOVW_LDADD,R9,Left);
  160. if (SrcPacked && !p->UseRight) I1C(ADDI,R9,2);
  161. }
  162. if (p->UseRight)
  163. if (SrcPacked)
  164. {
  165. if (!p->UseLeft) I1C(ADDI,R9,2);
  166. I2(MOVW_LDADD,R9,Right);
  167. }
  168. else
  169. I2(MOVW_LDADD,R10,Right);
  171. if (p->SrcUnsigned)
  172. {
  173. I2(EXTUW,R2,R2);
  174. if (p->SrcChannels>1)
  175. I2(EXTUW,R3,R3);
  176. }
  177. break;
  179. case 32:
  180. if (p->UseLeft)
  181. {
  182. I2(MOVL_LDADD,R9,Left);
  183. if (SrcPacked && !p->UseRight) I1C(ADDI,R9,4);
  184. }
  185. if (p->UseRight)
  186. if (SrcPacked)
  187. {
  188. if (!p->UseLeft) I1C(ADDI,R9,4);
  189. I2(MOVL_LDADD,R9,Right);
  190. }
  191. else
  192. I2(MOVL_LDADD,R10,Right);
  193. break;
  194. }
  195. }
  197. if (p->InstSrcUnsigned)
  198. {
  199. MB(); I1P(MOVL_PC,R0,p->InstSrcUnsigned,0);
  200. I2(SUB,R0,R2);
  201. if (p->SrcChannels>1)
  202. I2(SUB,R0,R3);
  203. }
  204. else
  205. if (p->SrcUnsigned == 128) 
  206. {
  207. I1C(ADDI,R2,-128);
  208. if (p->SrcChannels>1)
  209. I1C(ADDI,R3,-128);
  210. }
  212. if (p->Stereo)
  213. {
  214. if ((p->Src.Flags ^ p->Dst.Flags) & PCM_SWAPPEDSTEREO)
  215. {
  216. Left = R3;
  217. Right = R2;
  218. }
  219. else
  220. {
  221. Left = R2;
  222. Right = R3;
  223. }
  224. }
  225. else
  226. {
  227. if (p->Join)
  228. I2(ADD,R3,R2);
  229. Right = Left = R2;
  230. }
  233. if (p->ActualDither)
  234. {
  235. I2(ADD,R13,R2);
  236. I2(MOV,R2,R13);
  237. if (p->Stereo) 
  238. {
  239. I2(ADD,R1,R3);
  240. I2(MOV,R3,R1);
  241. }
  242. }
  244. if (p->Clip>0)
  245. {
  246. dyninst* ClipMin = Label(0);
  247. dyninst* ClipMax = Label(0);
  249. I2(CMPGT,R2,R4);
  250. I0P(BFS,ClipMin);
  251. I2(CMPGT,R5,R2); // delay slot
  252. I2(MOV,R4,R2);
  253. InstPost(ClipMin);
  255. I0P(BFS,ClipMax);
  256. I1C(ADDI,R11,1<<p->DstShift); // delay slot
  257. I2(MOV,R5,R2);
  258. InstPost(ClipMax);
  260. if (p->Stereo)
  261. {
  262. ClipMin = Label(0);
  263. ClipMax = Label(0);
  265. I2(CMPGT,R3,R4);
  266. I0P(BFS,ClipMin);
  267. I2(CMPGT,R5,R3); // delay slot
  268. I2(MOV,R4,R3);
  269. InstPost(ClipMin);
  271. I0P(BFS,ClipMax);
  272. I1C(ADDI,R12,1<<p->DstShift); // delay slot
  273. I2(MOV,R5,R3);
  274. InstPost(ClipMax);
  275. }
  276. else
  277. if (p->Dst.Channels>1)
  278. I1C(ADDI,R12,1<<p->DstShift); // delay slot
  279. }
  280. else
  281. {
  282. I1C(ADDI,R11,1<<p->DstShift);
  283. if (p->Dst.Channels>1)
  284. I1C(ADDI,R12,1<<p->DstShift);
  285. }
  287. I2(CMPEQ,R11,R14);
  289. if (p->Shift)
  290. {
  291. if (p->ActualDither)
  292. {
  293. I1C(MOVI,R0,p->Shift);
  294. Shift = R0;
  295. }
  296. else
  297. Shift = R13;
  298. I2(SHAD,Shift,R2);
  299. if (p->Stereo) I2(SHAD,Shift,R3);
  300. }
  302. if (p->ActualDither)
  303. {
  304. if (Speed)
  305. I1C(MOVI,R7,-p->Shift);
  307. I2(MOV,R2,R0);
  308. I2(SHAD,R7,R0);
  309. I2(SUB,R0,R13);
  310. if (p->Stereo)
  311. {
  312. I2(MOV,R3,R0);
  313. I2(SHAD,R7,R0);
  314. I2(SUB,R0,R1);
  315. }
  317. if (Speed)
  318. I2C(MOVL_LDOFS,SP,R7,OFS(stack,Step));
  319. }
  321. if (p->InstDstUnsigned)
  322. {
  323. MB(); I1P(MOVL_PC,R0,p->InstDstUnsigned,0);
  324. I1C(ADD,R0,Left);
  325. if (Left != Right)
  326. I1C(ADD,R0,Right);
  327. }
  328. else
  329. if (p->DstUnsigned == 128) 
  330. {
  331. // p->Dst.Bits=8 so doesn't matter if it's add or sub
  332. I1C(ADDI,Left,-128); 
  333. if (Left != Right)
  334. I1C(ADDI,Right,-128);
  335. }
  337. switch (p->Dst.Bits)
  338. {
  339. case 8:
  340. I2(MOVB_ST,Left,R11);
  341. if (p->Dst.Channels>1)
  342. I2(MOVB_ST,Right,R12);
  343. break;
  345. case 16:
  346. I2(MOVW_ST,Left,R11);
  347. if (p->Dst.Channels>1)
  348. I2(MOVW_ST,Right,R12);
  349. break;
  351. case 32:
  352. I2(MOVL_ST,Left,R11);
  353. if (p->Dst.Channels>1)
  354. I2(MOVL_ST,Right,R12);
  355. break;
  356. }
  358. DS(); I0P(BFS,Loop);
  360. if (p->ActualDither)
  361. {
  362. I2(MOV,SP,R0);
  363. I1C(ADDI,R0,OFS(stack,State));
  364. I2(MOVL_LD,R0,R4);
  366. I2C(MOVL_STOFS,R13,R4,OFS(pcmstate,Dither[0]));
  367. I2C(MOVL_STOFS,R1,R4,OFS(pcmstate,Dither[1]));
  368. }
  370. CodeEnd(7,OFS(stack,StackFrame));
  371. }
  373. void PCMCompile(pcm_soft* p)
  374. {
  375. dyninst* Speed;
  376. dyninst* Min = NULL;
  377. dyninst* Max = NULL;
  379. CodeBegin(7,OFS(stack,StackFrame));
  381. p->InstSrcUnsigned = NULL;
  382. p->InstDstUnsigned = NULL;
  384. if (p->SrcUnsigned && p->SrcUnsigned != 128)
  385. p->InstSrcUnsigned = InstCreate32(p->SrcUnsigned,NONE,NONE,NONE,0,0);
  386. if (p->DstUnsigned && p->DstUnsigned != 128)
  387. p->InstDstUnsigned = InstCreate32(p->DstUnsigned,NONE,NONE,NONE,0,0);
  389. // dst pointers
  390. I2C(MOVL_LDOFS,R5,R11,0);
  391. I1C(ADDI,R11,-(1<<p->DstShift)); // back one step
  393. if (p->Dst.Channels > 1)
  394. {
  395. if (p->Dst.Flags & PCM_PLANES)
  396. {
  397. I2C(MOVL_LDOFS,R5,R12,4);
  398. I1C(ADDI,R12,-(1<<p->DstShift)); // back one step
  399. }
  400. else
  401. {
  402. I2(MOV,R11,R12);
  403. I1C(ADDI,R12,1<<(p->DstShift-1));
  404. }
  405. }
  406. I2(MOV,R7,R14);
  407. I2(ADD,R11,R14); // dstend
  409. // src pointers
  410. I2C(MOVL_LDOFS,R6,R9,0);
  412. if (p->Src.Channels > 1)
  413. {
  414. if (p->Src.Flags & PCM_PLANES)
  415. I2C(MOVL_LDOFS,R6,R10,4);
  416. else
  417. {
  418. I2(MOV,R9,R10);
  419. I1C(ADDI,R10,p->Src.Bits>>3);
  420. }
  421. }
  423. I2(MOV,SP,R0);
  424. I1C(ADDI,R0,OFS(stack,State));
  425. I2(MOVL_LD,R0,R4);
  427. I2C(MOVL_LDOFS,R4,R7,OFS(pcmstate,Step));
  428. I2C(MOVL_LDOFS,R4,R8,OFS(pcmstate,Pos));
  430. /*
  431. if (p->UseVolume)
  432. {
  433. I1C(ADDI,R0,OFS(stack,Volume)-OFS(stack,State));
  434. I2(MOVL_LD,R0,R1);
  435. }
  436. */
  438. if (p->ActualDither)
  439. {
  440. I2C(MOVL_LDOFS,R4,R13,OFS(pcmstate,Dither[0]));
  441. I2C(MOVL_LDOFS,R4,R1,OFS(pcmstate,Dither[1]));
  442. }
  444. if (p->Clip>0)
  445. {
  446. Min = InstCreate32(p->MinLimit,NONE,NONE,NONE,0,0);
  447. Max = InstCreate32(p->MaxLimit,NONE,NONE,NONE,0,0);
  449. I1P(MOVL_PC,R4,Min,0);
  450. I1P(MOVL_PC,R5,Max,0);
  451. }
  453. Speed = Label(0);
  455. I1C(MOVI,R2,64);
  456. I1(SHLL2,R2);
  457. I2(CMPEQ,R2,R7);
  458. I0P(BF,Speed);
  460. PCMLoop(p,0);
  462. InstPost(Speed);
  464. PCMLoop(p,1);
  466. Align(4);
  467. if (Min) InstPost(Min);
  468. if (Max) InstPost(Max);
  469. if (p->InstSrcUnsigned) InstPost(p->InstSrcUnsigned);
  470. if (p->InstDstUnsigned) InstPost(p->InstDstUnsigned);
  471. }
  473. #endif