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

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

Windows CE

开发平台：

C/C++

pcm_arm.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_arm.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(ARM)
  30. typedef struct stack
  31. {
  32. int StackFrame[STACKFRAME];
  34. //void* this   R0
  35. //plane Dst    R1
  36. //plane Src    R2
  37. //int DstLength R3
  38. pcmstate* State;
  39. int Volume;
  41. } stack;
  43. // R0,R1 dither 
  44. // R2,R3 value
  45. // R4 Min
  46. // R5 Max
  47. // R6 tmp
  48. // R7 Step
  49. // R8 Pos
  50. // R9 SrcLeft
  51. // R10 SrcRight
  52. // R11 DstLeft
  53. // R12 DstRight
  54. // R14 DstLeftEnd
  56. void PCMLoop(pcm_soft* p,bool_t Speed)
  57. {
  58. dyninst* Loop;
  59. reg Left;
  60. reg Right;
  62. Loop = Label(1);
  64. Left = R2;
  65. if (p->UseLeft)
  66. Right = R3;
  67. else
  68. Right = R2;
  70. if (Speed)
  71. {
  72. I3S(MOV,R3,NONE,R8,LSR,8);
  74. switch (p->Src.Bits)
  75. {
  76. case 8:
  77. if (p->SrcUnsigned)
  78. {
  79. if (p->UseLeft)
  80. {
  81. Byte(); I3S(LDR,Left,R9,R3,LSL,p->SrcShift);
  82. }
  83. if (p->UseRight)
  84. {
  85. Byte(); I3S(LDR,Right,R10,R3,LSL,p->SrcShift);
  86. }
  87. }
  88. else
  89. {
  90. I3S(MOV,R3,NONE,R3,LSL,p->SrcShift);
  91. if (p->UseLeft)
  92. {
  93. SByte(); I3(LDR,Left,R9,R3);
  94. }
  95. if (p->UseRight)
  96. {
  97. SByte(); I3(LDR,Right,R10,R3);
  98. }
  99. }
  100. break;
  102. case 16:
  103. I3S(MOV,R3,NONE,R3,LSL,p->SrcShift);
  104. if (p->UseLeft)
  105. {
  106. if (p->SrcUnsigned || p->SrcSwap) Half(); else SHalf();
  107. I3(LDR,Left,R9,R3);
  108. if (p->SrcSwap)
  109. {
  110. I3S(MOV,R6,NONE,Left,LSL,24);
  111. I3S(MOV,Left,NONE,Left,LSR,8);
  112. if (p->SrcUnsigned)
  113. I3S(ORR,Left,Left,R6,LSR,16);
  114. else
  115. I3S(ORR,Left,Left,R6,ASR,16);
  116. }
  117. }
  118. if (p->UseRight)
  119. {
  120. if (p->SrcUnsigned || p->SrcSwap) Half(); else SHalf();
  121. I3(LDR,Right,R10,R3);
  122. if (p->SrcSwap)
  123. {
  124. I3S(MOV,R6,NONE,Right,LSL,24);
  125. I3S(MOV,Right,NONE,Right,LSR,8);
  126. if (p->SrcUnsigned)
  127. I3S(ORR,Right,Right,R6,LSR,16);
  128. else
  129. I3S(ORR,Right,Right,R6,ASR,16);
  130. }
  131. }
  132. break;
  134. case 32:
  135. if (p->UseLeft)
  136. I3S(LDR,Left,R9,R3,LSL,p->SrcShift);
  137. if (p->UseRight)
  138. I3S(LDR,Right,R10,R3,LSL,p->SrcShift);
  139. break;
  140. }
  141. I3(ADD,R8,R8,R7);
  142. }
  143. else
  144. {
  145. switch (p->Src.Bits)
  146. {
  147. case 8:
  148. if (p->UseLeft)
  149. {
  150. if (p->SrcUnsigned) Byte(); else SByte();
  151. I2C(LDR_POST,Left,R9,1<<p->SrcShift);
  152. }
  153. if (p->UseRight)
  154. {
  155. if (p->SrcUnsigned) Byte(); else SByte();
  156. I2C(LDR_POST,Right,R10,1<<p->SrcShift);
  157. }
  158. break;
  160. case 16:
  161. if (p->UseLeft)
  162. {
  163. if (p->SrcUnsigned || p->SrcSwap) Half(); else SHalf();
  164. I2C(LDR_POST,Left,R9,1<<p->SrcShift);
  165. if (p->SrcSwap)
  166. {
  167. I3S(MOV,R6,NONE,Left,LSL,24);
  168. I3S(MOV,Left,NONE,Left,LSR,8);
  169. if (p->SrcUnsigned)
  170. I3S(ORR,Left,Left,R6,LSR,16);
  171. else
  172. I3S(ORR,Left,Left,R6,ASR,16);
  173. }
  174. }
  175. if (p->UseRight)
  176. {
  177. if (p->SrcUnsigned || p->SrcSwap) Half(); else SHalf();
  178. I2C(LDR_POST,Right,R10,1<<p->SrcShift);
  179. if (p->SrcSwap)
  180. {
  181. I3S(MOV,R6,NONE,Right,LSL,24);
  182. I3S(MOV,Right,NONE,Right,LSR,8);
  183. if (p->SrcUnsigned)
  184. I3S(ORR,Right,Right,R6,LSR,16);
  185. else
  186. I3S(ORR,Right,Right,R6,ASR,16);
  187. }
  188. }
  189. break;
  191. case 32:
  192. if (p->UseLeft)
  193. I2C(LDR_POST,Left,R9,1<<p->SrcShift);
  194. if (p->UseRight)
  195. I2C(LDR_POST,Right,R10,1<<p->SrcShift);
  196. break;
  197. }
  198. }
  200. if (p->SrcUnsigned) 
  201. {
  202. I2C(SUB,R2,R2,p->SrcUnsigned);
  203. if (p->SrcChannels>1)
  204. I2C(SUB,R3,R3,p->SrcUnsigned);
  205. }
  207. if (p->Stereo)
  208. {
  209. if ((p->Src.Flags ^ p->Dst.Flags) & PCM_SWAPPEDSTEREO)
  210. {
  211. Left = R3;
  212. Right = R2;
  213. }
  214. else
  215. {
  216. Left = R2;
  217. Right = R3;
  218. }
  219. }
  220. else
  221. {
  222. if (p->Join)
  223. I3(ADD,R2,R2,R3);
  224. Right = Left = R2;
  225. }
  227. if (p->ActualDither)
  228. {
  229. I3(ADD,R2,R2,R0);
  230. I3(MOV,R0,NONE,R2);
  231. if (p->Stereo) 
  232. {
  233. I3(ADD,R3,R3,R1);
  234. I3(MOV,R1,NONE,R3);
  235. }
  236. }
  238. if (p->UseVolume)
  239. {
  240. if (p->Src.Bits >= 23)
  241. I3S(MOV,R2,NONE,R2,ASR,8);
  242. I3(MUL,R2,R0,R2);
  244. if (p->Stereo)
  245. {
  246. if (p->Src.Bits >= 23)
  247. I3S(MOV,R3,NONE,R3,ASR,8);
  248. I3(MUL,R3,R0,R3);
  249. }
  250. }
  252. if (p->Clip>0)
  253. {
  254. I3(CMP,NONE,R2,R4);
  255. C(LT); I3(MOV,R2,NONE,R4);
  256. I3(CMP,NONE,R2,R5);
  257. C(GT); I3(MOV,R2,NONE,R5);
  259. if (p->Stereo)
  260. {
  261. I3(CMP,NONE,R3,R4);
  262. C(LT); I3(MOV,R3,NONE,R4);
  263. I3(CMP,NONE,R3,R5);
  264. C(GT); I3(MOV,R3,NONE,R5);
  265. }
  266. }
  268. if (p->Shift)
  269. {
  270. I3S(MOV,R2,NONE,R2,ASR,-p->Shift);
  271. if (p->Stereo) I3S(MOV,R3,NONE,R3,ASR,-p->Shift);
  272. }
  274. #ifdef TARGET_PALMOS
  275. if (p->LifeDriveFix)
  276. {
  277. I3S(ADD,R6,R2,R1,LSL,1);
  278. I3S(CMP,NONE,R6,R1,LSL,2);
  279. C(LS); I2C(ORR,R2,R2,R0);
  280. if (p->Stereo)
  281. {
  282. I3S(ADD,R6,R3,R1,LSL,1);
  283. I3S(CMP,NONE,R6,R1,LSL,2);
  284. C(LS); I3(ORR,R3,R3,R0);
  285. }
  286. }
  287. #endif
  289. if (p->ActualDither)
  290. {
  291. I3S(SUB,R0,R0,R2,ASR,p->Shift);
  292. if (p->Stereo) I3S(SUB,R1,R1,R3,ASR,p->Shift);
  293. }
  295. if (p->DstUnsigned) 
  296. {
  297. I2C(ADD,Left,Left,p->DstUnsigned);
  298. if (Left != Right)
  299. I2C(ADD,Right,Right,p->DstUnsigned);
  300. }
  302. switch (p->Dst.Bits)
  303. {
  304. case 8:
  305. Byte(); I2C(STR_POST,Left,R11,1<<p->DstShift);
  306. if (p->Dst.Channels>1)
  307. {
  308. Byte(); I2C(STR_POST,Right,R12,1<<p->DstShift);
  309. }
  310. break;
  312. case 16:
  313. Half(); I2C(STR_POST,Left,R11,1<<p->DstShift);
  314. if (p->Dst.Channels>1)
  315. {
  316. Half(); I2C(STR_POST,Right,R12,1<<p->DstShift);
  317. }
  318. break;
  320. case 32:
  321. I2C(STR_POST,Left,R11,1<<p->DstShift);
  322. if (p->Dst.Channels>1)
  323. I2C(STR_POST,Right,R12,1<<p->DstShift);
  324. break;
  325. }
  327. I3(CMP,NONE,R11,R14);
  328. I0P(B,NE,Loop);
  330. if (p->ActualDither)
  331. {
  332. I2C(LDR,R4,SP,OFS(stack,State));
  333. I2C(STR,R0,R4,OFS(pcmstate,Dither[0]));
  334. I2C(STR,R1,R4,OFS(pcmstate,Dither[1]));
  335. }
  337. CodeEnd();
  338. }
  340. void PCMCompile(pcm_soft* p)
  341. {
  342. dyninst* Speed;
  343. dyninst* Min = NULL;
  344. dyninst* Max = NULL;
  346. CodeBegin();
  348. // dst pointers
  349. I2C(LDR,R11,R1,0);
  350. if (p->Dst.Channels > 1)
  351. {
  352. if (p->Dst.Flags & PCM_PLANES)
  353. I2C(LDR,R12,R1,4);
  354. else
  355. I2C(ADD,R12,R11,1<<(p->DstShift-1));
  356. }
  357. I3(ADD,R14,R11,R3); // dstend
  359. // src pointers
  360. I2C(LDR,R9,R2,0);
  361. if (p->Src.Channels > 1)
  362. {
  363. if (p->Src.Flags & PCM_PLANES)
  364. I2C(LDR,R10,R2,4);
  365. else
  366. I2C(ADD,R10,R9,p->Src.Bits>>3);
  367. }
  369. I2C(LDR,R4,SP,OFS(stack,State));
  371. I2C(LDR,R7,R4,OFS(pcmstate,Step));
  372. I2C(LDR,R8,R4,OFS(pcmstate,Pos));
  374. #ifdef TARGET_PALMOS
  375. if (p->LifeDriveFix)
  376. {
  377. I2C(LDR,R1,SP,OFS(stack,Volume));
  378. I2C(MOV,R0,NONE,63);
  379. I2C(CMP,NONE,R1,25);
  380. C(GT); I2C(MOV,R0,NONE,31);
  381. I2C(CMP,NONE,R1,50);
  382. C(GT); I2C(MOV,R0,NONE,15);
  383. I2C(CMP,NONE,R1,100);
  384. C(GT); I2C(MOV,R0,NONE,7);
  385. I2C(CMP,NONE,R1,200);
  386. C(GT); I2C(MOV,R0,NONE,3);
  387. I2C(ADD,R1,R0,1);
  388. }
  389. #endif
  391. if (p->UseVolume)
  392. I2C(LDR,R0,SP,OFS(stack,Volume));
  394. if (p->ActualDither)
  395. {
  396. I2C(LDR,R0,R4,OFS(pcmstate,Dither[0]));
  397. I2C(LDR,R1,R4,OFS(pcmstate,Dither[1]));
  398. }
  400. if (p->Clip>0)
  401. {
  402. Min = InstCreate32(p->MinLimit,NONE,NONE,NONE,0,0);
  403. Max = InstCreate32(p->MaxLimit,NONE,NONE,NONE,0,0);
  405. I1P(LDR,R4,Min,0);
  406. I1P(LDR,R5,Max,0);
  407. }
  409. Speed = Label(0);
  410. I2C(CMP,NONE,R7,256);
  411. I0P(B,NE,Speed);
  413. PCMLoop(p,0);
  415. InstPost(Speed);
  417. PCMLoop(p,1);
  419. if (Min) InstPost(Min);
  420. if (Max) InstPost(Max);
  421. }
  424. #endif