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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
core_ARMv5E.c
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：12k
源码类别：

Symbian

开发平台：

C/C++

core_ARMv5E.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. /*
  36.  * Fixed-point sampling rate conversion library
  37.  * Developed by Ken Cooke (kenc@real.com)
  38.  * May 2003
  39.  *
  40.  * Core filtering functions, ARMv5E version.
  41.  * This version requires an XScale, ARM9E, ARM10E, etc.
  42.  * NOTE: intended to be compiled with ARM ADS1.2 or equivalent.
  43.  */
  45. #include "core.h"
  47. #define ASSERT(x) { while (!(x)) ; }
  49. __inline int MULHI(int a, int b) {
  50. int low;
  51. __asm { SMULL low, a, b, a }
  52. return a;
  53. }
  55. short *
  56. RATCoreMono(short *pcmptr, short *pcmend, short *outptr, state_t *s)
  57. {
  58. short *rwgptr, *lwgptr, *revptr;
  59. int acc;
  60. int i;
  61. int *tab;
  63. rwgptr = s->rwing;
  64. lwgptr = s->lwing;
  65. pcmptr += s->offset;
  67. /* these must be word-aligned */
  68. ASSERT(((int)rwgptr & 0x3) == 0);
  69. ASSERT(((int)lwgptr & 0x3) == 0);
  71. while (pcmptr < pcmend) {
  73. revptr = pcmptr - 1;
  74. acc = 1 << 14;
  76. /* FIR filter */
  77. for (i = s->nwing >> 1; i != 0; i--) {
  78. register int pcm0, pcm1, rev0, rev1, lwg, rwg;
  79. __asm {
  80. LDRH pcm0, [pcmptr],#2
  81. LDR lwg,  [lwgptr],#4
  82. LDRH pcm1, [pcmptr],#2
  83. LDRH rev1, [revptr],#-2
  84. LDR rwg,  [rwgptr],#4
  85. LDRH rev0, [revptr],#-2
  87. SMLABB acc, pcm0, lwg, acc
  88. SMLABT acc, pcm1, lwg, acc
  89. SMLABB acc, rev1, rwg, acc
  90. SMLABT acc, rev0, rwg, acc
  91. }
  92. }
  93. if (s->nwing & 0x1) {
  94. register int pcm, rev, lwg, rwg;
  95. __asm {
  96. LDRH pcm, [pcmptr],#2
  97. LDRH lwg, [lwgptr],#2
  98. LDRH rev, [revptr],#-2
  99. LDRH rwg, [rwgptr],#2
  101. SMLABB acc, pcm, lwg, acc
  102. SMLABB acc, rev, rwg, acc
  103. }
  104. }
  106. /* saturate */
  107. __asm { QADD acc, acc, acc }
  109. *outptr++ = (short) (acc >> 16);
  111. /* step phase by N */
  112. tab = (rwgptr > s->stepNptr ? s->stepNbak : s->stepNfwd);
  113. rwgptr += tab[0];
  114. lwgptr += tab[1];
  115. pcmptr += tab[2];
  116. }
  118. s->offset = pcmptr - pcmend;
  119. s->rwing = rwgptr;
  120. s->lwing = lwgptr;
  122. return outptr;
  123. }
  125. short *
  126. RATCoreStereo(short *pcmptr, short *pcmend, short *outptr, state_t *s)
  127. {
  128. short *rwgptr, *lwgptr, *revptr;
  129. int acc0, acc1;
  130. int i;
  131. int *tab;
  133. rwgptr = s->rwing;
  134. lwgptr = s->lwing;
  135. pcmptr += s->offset;
  137. /* these must be word-aligned */
  138. ASSERT(((int)rwgptr & 0x3) == 0);
  139. ASSERT(((int)lwgptr & 0x3) == 0);
  140. ASSERT(((int)pcmptr & 0x3) == 0);
  142. while (pcmptr+1 < pcmend) {
  144. revptr = pcmptr - 2;
  145. acc0 = acc1 = 1 << 14;
  147. /* FIR filter */
  148. for (i = s->nwing >> 1; i != 0; i--) {
  149. register int pcm0, pcm1, rev0, rev1, lwg, rwg;
  150. __asm {
  151. LDR pcm0, [pcmptr],#4
  152. LDR lwg,  [lwgptr],#4
  153. LDR pcm1, [pcmptr],#4
  154. LDR rev1, [revptr],#-4
  155. LDR rwg,  [rwgptr],#4
  156. LDR rev0, [revptr],#-4
  158. SMLABB acc0, pcm0, lwg, acc0
  159. SMLATB acc1, pcm0, lwg, acc1
  160. SMLABT acc0, pcm1, lwg, acc0
  161. SMLATT acc1, pcm1, lwg, acc1
  163. SMLATB acc1, rev1, rwg, acc1
  164. SMLABB acc0, rev1, rwg, acc0
  165. SMLATT acc1, rev0, rwg, acc1
  166. SMLABT acc0, rev0, rwg, acc0
  167. }
  168. }
  169. if (s->nwing & 0x1) {
  170. register int pcm, rev, lwg, rwg;
  171. __asm {
  172. LDR pcm, [pcmptr],#4
  173. LDRH lwg, [lwgptr],#2
  174. LDR rev, [revptr],#-4
  175. LDRH rwg, [rwgptr],#2
  177. SMLABB acc0, pcm, lwg, acc0
  178. SMLATB acc1, pcm, lwg, acc1
  179. SMLATB acc1, rev, rwg, acc1
  180. SMLABB acc0, rev, rwg, acc0
  181. }
  182. }
  184. /* saturate */
  185. __asm { QADD acc0, acc0, acc0 }
  186. __asm { QADD acc1, acc1, acc1 }
  188. *outptr++ = (short) (acc0 >> 16);
  189. *outptr++ = (short) (acc1 >> 16);
  191. /* step phase by N */
  192. tab = (rwgptr > s->stepNptr ? s->stepNbak : s->stepNfwd);
  193. rwgptr += tab[0];
  194. lwgptr += tab[1];
  195. pcmptr += tab[2];
  196. }
  198. s->offset = pcmptr - pcmend;
  199. s->rwing = rwgptr;
  200. s->lwing = lwgptr;
  202. return outptr;
  203. }
  205. short *
  206. ARBCoreMono(short *pcmptr, short *pcmend, short *outptr, state_t *s)
  207. {
  208. register short *rwgptr, *lwgptr, *revptr;
  209. register short *rwgptr1, *lwgptr1;
  210. register int acc0, acc1;
  211. int pcmstep, i;
  212. int *tab;
  213. uint phasef;
  215. rwgptr = s->rwing;
  216. lwgptr = s->lwing;
  217. phasef = s->phasef;
  218. pcmptr += s->offset;
  220. /* phase+1 */
  221. tab = (rwgptr >= s->step1ptr ? s->step1bak : s->step1fwd);
  222. rwgptr1 = rwgptr + tab[0];
  223. lwgptr1 = lwgptr + tab[1];
  224. pcmstep = tab[2];
  226. /* these must be word-aligned */
  227. ASSERT(((int)rwgptr & 0x3) == 0);
  228. ASSERT(((int)lwgptr & 0x3) == 0);
  229. ASSERT(((int)rwgptr1 & 0x3) == 0);
  230. ASSERT(((int)lwgptr1 & 0x3) == 0);
  232. while (pcmptr+pcmstep < pcmend) {
  234. revptr = pcmptr - 1;
  235. acc0 = acc1 = 1 << 14;
  237. if (!pcmstep) {
  239. for (i = s->nwing >> 1; i != 0; i--) {
  240. register int pcm0, pcm1, wng0, wng1;
  241. __asm {
  242. LDRH pcm0, [pcmptr],#2
  243. LDRH pcm1, [pcmptr],#2
  244. LDR wng0, [lwgptr],#4
  245. LDR wng1, [lwgptr1],#4
  247. SMLABB acc0, pcm0, wng0, acc0
  248. SMLABB acc1, pcm0, wng1, acc1
  249. SMLABT acc0, pcm1, wng0, acc0
  250. SMLABT acc1, pcm1, wng1, acc1
  252. LDRH pcm1, [revptr],#-2
  253. LDRH pcm0, [revptr],#-2
  254. LDR wng0, [rwgptr],#4
  255. LDR wng1, [rwgptr1],#4
  257. SMLABB acc0, pcm1, wng0, acc0
  258. SMLABB acc1, pcm1, wng1, acc1
  259. SMLABT acc0, pcm0, wng0, acc0
  260. SMLABT acc1, pcm0, wng1, acc1
  261. }
  262. }
  263. if (s->nwing & 0x1) {
  264. register int pcm, wng0, wng1;
  265. __asm {
  266. LDRH pcm,  [pcmptr],#2
  267. LDRH wng0, [lwgptr],#2
  268. LDRH wng1, [lwgptr1],#2
  270. SMLABB acc0, pcm, wng0, acc0
  271. SMLABB acc1, pcm, wng1, acc1
  273. LDRH pcm,  [revptr],#-2
  274. LDRH wng0, [rwgptr],#2
  275. LDRH wng1, [rwgptr1],#2
  277. SMLABB acc0, pcm, wng0, acc0
  278. SMLABB acc1, pcm, wng1, acc1
  279. }
  280. }
  282. } else {
  284. for (i = s->nwing >> 1; i != 0; i--) {
  285. register int pcm0, pcm1, pcm2, wng0, wng1;
  286. __asm {
  287. LDRH pcm0, [pcmptr],#2
  288. LDRH pcm1, [pcmptr],#2
  289. LDRH pcm2, [pcmptr,#0]
  290. LDR wng0, [lwgptr],#4
  291. LDR wng1, [lwgptr1],#4
  293. SMLABB acc0, pcm0, wng0, acc0
  294. SMLABB acc1, pcm1, wng1, acc1
  295. SMLABT acc0, pcm1, wng0, acc0
  296. SMLABT acc1, pcm2, wng1, acc1
  298. LDRH pcm2, [revptr,#2]
  299. LDRH pcm1, [revptr],#-2
  300. LDRH pcm0, [revptr],#-2
  301. LDR wng0, [rwgptr],#4
  302. LDR wng1, [rwgptr1],#4
  304. SMLABB acc0, pcm1, wng0, acc0
  305. SMLABB acc1, pcm2, wng1, acc1
  306. SMLABT acc0, pcm0, wng0, acc0
  307. SMLABT acc1, pcm1, wng1, acc1
  308. }
  309. }
  310. if (s->nwing & 0x1) {
  311. register int pcm0, pcm1, wng0, wng1;
  312. __asm {
  313. LDRH pcm0, [pcmptr],#2
  314. LDRH pcm1, [pcmptr,#0]
  315. LDRH wng0, [lwgptr],#2
  316. LDRH wng1, [lwgptr1],#2
  318. SMLABB acc0, pcm0, wng0, acc0
  319. SMLABB acc1, pcm1, wng1, acc1
  321. LDRH pcm1, [revptr,#2]
  322. LDRH pcm0, [revptr],#-2
  323. LDRH wng0, [rwgptr],#2
  324. LDRH wng1, [rwgptr1],#2
  326. SMLABB acc0, pcm0, wng0, acc0
  327. SMLABB acc1, pcm1, wng1, acc1
  328. }
  329. }
  330. }
  332. /* interpolate and saturate */
  333. acc1 = MULHI(acc1 - acc0, phasef >> 1);
  334. __asm { QDADD acc0, acc0, acc1 }
  335. __asm { QADD  acc0, acc0, acc0 }
  337. *outptr++ = (short) (acc0 >> 16);
  339. /* step phase fraction */
  340. phasef += s->stepf;
  341. if (phasef < s->stepf) {
  342. rwgptr = rwgptr1;
  343. lwgptr = lwgptr1;
  344. pcmptr += pcmstep;
  345. }
  347. /* step phase by N */
  348. tab = (rwgptr > s->stepNptr ? s->stepNbak : s->stepNfwd);
  349. rwgptr += tab[0];
  350. lwgptr += tab[1];
  351. pcmptr += tab[2];
  353. /* phase+1 */
  354. tab = (rwgptr >= s->step1ptr ? s->step1bak : s->step1fwd);
  355. rwgptr1 = rwgptr + tab[0];
  356. lwgptr1 = lwgptr + tab[1];
  357. pcmstep = tab[2];
  358. }
  360. s->offset = pcmptr - pcmend;
  361. s->rwing = rwgptr;
  362. s->lwing = lwgptr;
  363. s->phasef = phasef;
  365. return outptr;
  366. }
  368. short *
  369. ARBCoreStereo(short *pcmptr, short *pcmend, short *outptr, state_t *s)
  370. {
  371. register short *rwgptr, *lwgptr, *revptr;
  372. register short *rwgptr1, *lwgptr1;
  373. register int acc0, acc1, acc2, acc3;
  374. int pcmstep, i;
  375. int *tab;
  376. uint phasef;
  378. rwgptr = s->rwing;
  379. lwgptr = s->lwing;
  380. phasef = s->phasef;
  381. pcmptr += s->offset;
  383. /* phase+1 */
  384. tab = (rwgptr >= s->step1ptr ? s->step1bak : s->step1fwd);
  385. rwgptr1 = rwgptr + tab[0];
  386. lwgptr1 = lwgptr + tab[1];
  387. pcmstep = tab[2];
  389. /* these must be word-aligned */
  390. ASSERT(((int)rwgptr & 0x3) == 0);
  391. ASSERT(((int)lwgptr & 0x3) == 0);
  392. ASSERT(((int)rwgptr1 & 0x3) == 0);
  393. ASSERT(((int)lwgptr1 & 0x3) == 0);
  394. ASSERT(((int)pcmptr & 0x3) == 0);
  396. while (pcmptr+pcmstep+1 < pcmend) {
  398. revptr = pcmptr - 2;
  399. acc0 = acc1 = acc2 = acc3 = 1 << 14;
  401. if (!pcmstep) {
  403. for (i = s->nwing; i != 0; i--) {
  404. register int pcm, wng, tmp;
  405. __asm {
  406. LDRH wng, [lwgptr],#2
  407. LDRH tmp, [lwgptr1],#2
  408. LDR pcm, [pcmptr],#4
  409. ORR wng, wng, tmp,LSL#16
  411. SMLABB acc0, pcm, wng, acc0
  412. SMLATB acc1, pcm, wng, acc1
  413. SMLABT acc2, pcm, wng, acc2
  414. SMLATT acc3, pcm, wng, acc3
  416. LDRH wng, [rwgptr],#2
  417. LDRH tmp, [rwgptr1],#2
  418. LDR pcm, [revptr],#-4
  419. ORR wng, wng, tmp,LSL#16
  421. SMLABB acc0, pcm, wng, acc0
  422. SMLATB acc1, pcm, wng, acc1
  423. SMLABT acc2, pcm, wng, acc2
  424. SMLATT acc3, pcm, wng, acc3
  425. }
  426. }
  428. } else {
  430. for (i = s->nwing; i != 0; i--) {
  431. register int pcm0, pcm1, wng, tmp;
  432. __asm {
  433. LDRH wng,  [lwgptr],#2
  434. LDRH tmp,  [lwgptr1],#2
  435. LDR pcm0, [pcmptr],#4
  436. LDR pcm1, [pcmptr,#0]
  437. ORR wng, wng, tmp,LSL#16
  439. SMLABB acc0, pcm0, wng, acc0
  440. SMLATB acc1, pcm0, wng, acc1
  441. SMLABT acc2, pcm1, wng, acc2
  442. SMLATT acc3, pcm1, wng, acc3
  444. LDRH wng,  [rwgptr],#2
  445. LDRH tmp,  [rwgptr1],#2
  446. LDR pcm1, [revptr,#4]
  447. LDR pcm0, [revptr],#-4
  448. ORR wng, wng, tmp,LSL#16
  450. SMLABB acc0, pcm0, wng, acc0
  451. SMLATB acc1, pcm0, wng, acc1
  452. SMLABT acc2, pcm1, wng, acc2
  453. SMLATT acc3, pcm1, wng, acc3
  454. }
  455. }
  456. }
  458. /* interpolate and saturate */
  459. acc2 = MULHI(acc2 - acc0, phasef >> 1);
  460. __asm { QDADD acc0, acc0, acc2 }
  461. __asm { QADD  acc0, acc0, acc0 }
  463. acc3 = MULHI(acc3 - acc1, phasef >> 1);
  464. __asm { QDADD acc1, acc1, acc3 }
  465. __asm { QADD  acc1, acc1, acc1 }
  467. *outptr++ = (short) (acc0 >> 16);
  468. *outptr++ = (short) (acc1 >> 16);
  470. /* step phase fraction */
  471. phasef += s->stepf;
  472. if (phasef < s->stepf) {
  473. rwgptr = rwgptr1;
  474. lwgptr = lwgptr1;
  475. pcmptr += pcmstep;
  476. }
  478. /* step phase by N */
  479. tab = (rwgptr > s->stepNptr ? s->stepNbak : s->stepNfwd);
  480. rwgptr += tab[0];
  481. lwgptr += tab[1];
  482. pcmptr += tab[2];
  484. /* phase+1 */
  485. tab = (rwgptr >= s->step1ptr ? s->step1bak : s->step1fwd);
  486. rwgptr1 = rwgptr + tab[0];
  487. lwgptr1 = lwgptr + tab[1];
  488. pcmstep = tab[2];
  489. }
  491. s->offset = pcmptr - pcmend;
  492. s->rwing = rwgptr;
  493. s->lwing = lwgptr;
  494. s->phasef = phasef;
  496. return outptr;
  497. }