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

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

Symbian

开发平台：

C/C++

core.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, generic version.
  41.  * This version is fairly optimized for ARMv4.
  42.  */
  44. #include "core.h"
  46. #if defined (_M_IX86) || (defined (_SYMBIAN) && defined (__WINS__))
  47. __inline int MULHI(int a, int b) {
  48. __asm mov eax, a
  49. __asm imul b
  50. __asm mov eax, edx
  51. }
  53. #elif defined (__CC_ARM)
  54. __inline int MULHI(int a, int b) {
  55. int low;
  56. __asm { smull low, a, b, a }
  57. return a;
  58. }
  60. #else
  61. /* a fast MULHI is important, so verify this compiles well */
  62. #define MULHI(a,b) ((int)(((__int64)(a) * (__int64)(b)) >> 32))
  63. #endif
  65. short *
  66. RATCoreMono(short *pcmptr, short *pcmend, short *outptr, state_t *s)
  67. {
  68. short *rwgptr, *lwgptr, *revptr;
  69. int acc;
  70. int i, sign;
  71. int *tab;
  73. rwgptr = s->rwing;
  74. lwgptr = s->lwing;
  75. pcmptr += s->offset;
  77. while (pcmptr < pcmend) {
  79. revptr = pcmptr - 1;
  80. acc = 1 << 14;
  82. /* FIR filter */
  83. for (i = s->nwing >> 1; i != 0; i--) {
  84. acc += (*pcmptr++) * (*lwgptr++);
  85. acc += (*pcmptr++) * (*lwgptr++);
  86. acc += (*revptr--) * (*rwgptr++);
  87. acc += (*revptr--) * (*rwgptr++);
  88. }
  89. if (s->nwing & 0x1) {
  90. acc += (*pcmptr++) * (*lwgptr++);
  91. acc += (*revptr--) * (*rwgptr++);
  92. }
  93. acc >>= 15;
  95. /* saturate */
  96. if ((sign = (acc >> 31)) != (acc >> 15))
  97. acc = sign ^ ((1<<15)-1);
  99. *outptr++ = (short) acc;
  101. /* step phase by N */
  102. tab = (rwgptr > s->stepNptr ? s->stepNbak : s->stepNfwd);
  103. rwgptr += tab[0];
  104. lwgptr += tab[1];
  105. pcmptr += tab[2];
  106. }
  108. s->offset = pcmptr - pcmend;
  109. s->rwing = rwgptr;
  110. s->lwing = lwgptr;
  112. return outptr;
  113. }
  115. short *
  116. RATCoreStereo(short *pcmptr, short *pcmend, short *outptr, state_t *s)
  117. {
  118. short *rwgptr, *lwgptr, *revptr;
  119. int acc0, acc1;
  120. int i, sign;
  121. int *tab;
  123. rwgptr = s->rwing;
  124. lwgptr = s->lwing;
  125. pcmptr += s->offset;
  127. while (pcmptr+1 < pcmend) {
  129. revptr = pcmptr - 1;
  130. acc0 = acc1 = 1 << 14;
  132. /* FIR filter */
  133. for (i = s->nwing >> 1; i != 0; i--) {
  134. acc0 += (*pcmptr++) * (*lwgptr);
  135. acc1 += (*pcmptr++) * (*lwgptr++);
  136. acc0 += (*pcmptr++) * (*lwgptr);
  137. acc1 += (*pcmptr++) * (*lwgptr++);
  138. acc1 += (*revptr--) * (*rwgptr);
  139. acc0 += (*revptr--) * (*rwgptr++);
  140. acc1 += (*revptr--) * (*rwgptr);
  141. acc0 += (*revptr--) * (*rwgptr++);
  142. }
  143. if (s->nwing & 0x1) {
  144. acc0 += (*pcmptr++) * (*lwgptr);
  145. acc1 += (*pcmptr++) * (*lwgptr++);
  146. acc1 += (*revptr--) * (*rwgptr);
  147. acc0 += (*revptr--) * (*rwgptr++);
  148. }
  149. acc0 >>= 15;
  150. acc1 >>= 15;
  152. /* saturate */
  153. if ((sign = (acc0 >> 31)) != (acc0 >> 15))
  154. acc0 = sign ^ ((1<<15)-1);
  155. if ((sign = (acc1 >> 31)) != (acc1 >> 15))
  156. acc1 = sign ^ ((1<<15)-1);
  158. *outptr++ = (short) acc0;
  159. *outptr++ = (short) acc1;
  161. /* step phase by N */
  162. tab = (rwgptr > s->stepNptr ? s->stepNbak : s->stepNfwd);
  163. rwgptr += tab[0];
  164. lwgptr += tab[1];
  165. pcmptr += tab[2];
  166. }
  168. s->offset = pcmptr - pcmend;
  169. s->rwing = rwgptr;
  170. s->lwing = lwgptr;
  172. return outptr;
  173. }
  175. short *
  176. ARBCoreMono(short *pcmptr, short *pcmend, short *outptr, state_t *s)
  177. {
  178. short *rwgptr, *lwgptr, *revptr;
  179. short *rwgptr1, *lwgptr1;
  180. int acc0, acc1;
  181. int pcmstep, i, sign;
  182. int *tab;
  183. uint phasef;
  185. rwgptr = s->rwing;
  186. lwgptr = s->lwing;
  187. phasef = s->phasef;
  188. pcmptr += s->offset;
  190. /* phase+1 */
  191. tab = (rwgptr >= s->step1ptr ? s->step1bak : s->step1fwd);
  192. rwgptr1 = rwgptr + tab[0];
  193. lwgptr1 = lwgptr + tab[1];
  194. pcmstep = tab[2];
  196. while (pcmptr+pcmstep < pcmend) {
  198. revptr = pcmptr - 1;
  199. acc0 = acc1 = 1 << 14;
  201. if (!pcmstep) {
  203. for (i = s->nwing; i != 0; i--) {
  204. register short pcm, rev;
  206. pcm = (*pcmptr++);
  207. rev = (*revptr--);
  209. acc0 += pcm * (*lwgptr++);
  210. acc1 += pcm * (*lwgptr1++);
  211. acc0 += rev * (*rwgptr++);
  212. acc1 += rev * (*rwgptr1++);
  213. }
  215. } else {
  217. for (i = s->nwing; i != 0; i--) {
  218. register short pcm0, pcm1;
  220. pcm0 = (*pcmptr++);
  221. pcm1 = *(pcmptr+0);
  223. acc0 += pcm0 * (*lwgptr++);
  224. acc1 += pcm1 * (*lwgptr1++);
  226. pcm1 = *(revptr+1);
  227. pcm0 = (*revptr--);
  229. acc0 += pcm0 * (*rwgptr++);
  230. acc1 += pcm1 * (*rwgptr1++);
  231. }
  232. }
  234. /* interpolate */
  235. acc0 = (acc0 >> 1) + MULHI(acc1 - acc0, phasef >> 1);
  236. acc0 >>= 14;
  238. /* saturate */
  239. if ((sign = (acc0 >> 31)) != (acc0 >> 15))
  240. acc0 = sign ^ ((1<<15)-1);
  242. *outptr++ = (short) acc0;
  244. /* step phase fraction */
  245. phasef += s->stepf;
  246. if (phasef < s->stepf) {
  247. rwgptr = rwgptr1;
  248. lwgptr = lwgptr1;
  249. pcmptr += pcmstep;
  250. }
  252. /* step phase by N */
  253. tab = (rwgptr > s->stepNptr ? s->stepNbak : s->stepNfwd);
  254. rwgptr += tab[0];
  255. lwgptr += tab[1];
  256. pcmptr += tab[2];
  258. /* phase+1 */
  259. tab = (rwgptr >= s->step1ptr ? s->step1bak : s->step1fwd);
  260. rwgptr1 = rwgptr + tab[0];
  261. lwgptr1 = lwgptr + tab[1];
  262. pcmstep = tab[2];
  263. }
  265. s->offset = pcmptr - pcmend;
  266. s->rwing = rwgptr;
  267. s->lwing = lwgptr;
  268. s->phasef = phasef;
  270. return outptr;
  271. }
  273. short *
  274. ARBCoreStereo(short *pcmptr, short *pcmend, short *outptr, state_t *s)
  275. {
  276. register short *rwgptr, *lwgptr, *revptr;
  277. register short *rwgptr1, *lwgptr1;
  278. register int acc0, acc1, acc2, acc3;
  279. int pcmstep, i, sign;
  280. int *tab;
  281. uint phasef;
  283. rwgptr = s->rwing;
  284. lwgptr = s->lwing;
  285. phasef = s->phasef;
  286. pcmptr += s->offset;
  288. /* phase+1 */
  289. tab = (rwgptr >= s->step1ptr ? s->step1bak : s->step1fwd);
  290. rwgptr1 = rwgptr + tab[0];
  291. lwgptr1 = lwgptr + tab[1];
  292. pcmstep = tab[2];
  294. while (pcmptr+pcmstep+1 < pcmend) {
  296. revptr = pcmptr - 1;
  297. acc0 = acc1 = acc2 = acc3 = 1 << 14;
  299. if (!pcmstep) {
  301. for (i = s->nwing; i != 0; i--) {
  302. register short pcm0, pcm1;
  304. pcm0 = (*pcmptr++);
  305. pcm1 = (*pcmptr++);
  307. acc0 += pcm0 * (*lwgptr);
  308. acc1 += pcm1 * (*lwgptr++);
  309. acc2 += pcm0 * (*lwgptr1);
  310. acc3 += pcm1 * (*lwgptr1++);
  312. pcm1 = (*revptr--);
  313. pcm0 = (*revptr--);
  315. acc3 += pcm1 * (*rwgptr1);
  316. acc2 += pcm0 * (*rwgptr1++);
  317. acc1 += pcm1 * (*rwgptr);
  318. acc0 += pcm0 * (*rwgptr++);
  319. }
  321. } else {
  323. for (i = s->nwing; i != 0; i--) {
  324. acc0 += (*pcmptr++) * (*lwgptr);
  325. acc1 += (*pcmptr++) * (*lwgptr++);
  326. acc2 += *(pcmptr+0) * (*lwgptr1);
  327. acc3 += *(pcmptr+1) * (*lwgptr1++);
  329. acc3 += *(revptr+2) * (*rwgptr1);
  330. acc2 += *(revptr+1) * (*rwgptr1++);
  331. acc1 += (*revptr--) * (*rwgptr);
  332. acc0 += (*revptr--) * (*rwgptr++);
  333. }
  334. }
  336. /* interpolate */
  337. acc0 = (acc0 >> 1) + MULHI(acc2 - acc0, phasef >> 1);
  338. acc0 >>= 14;
  339. acc1 = (acc1 >> 1) + MULHI(acc3 - acc1, phasef >> 1);
  340. acc1 >>= 14;
  342. /* saturate */
  343. if ((sign = (acc0 >> 31)) != (acc0 >> 15))
  344. acc0 = sign ^ ((1<<15)-1);
  345. if ((sign = (acc1 >> 31)) != (acc1 >> 15))
  346. acc1 = sign ^ ((1<<15)-1);
  348. *outptr++ = (short) acc0;
  349. *outptr++ = (short) acc1;
  351. /* step phase fraction */
  352. phasef += s->stepf;
  353. if (phasef < s->stepf) {
  354. rwgptr = rwgptr1;
  355. lwgptr = lwgptr1;
  356. pcmptr += pcmstep;
  357. }
  359. /* step phase by N */
  360. tab = (rwgptr > s->stepNptr ? s->stepNbak : s->stepNfwd);
  361. rwgptr += tab[0];
  362. lwgptr += tab[1];
  363. pcmptr += tab[2];
  365. /* phase+1 */
  366. tab = (rwgptr >= s->step1ptr ? s->step1bak : s->step1fwd);
  367. rwgptr1 = rwgptr + tab[0];
  368. lwgptr1 = lwgptr + tab[1];
  369. pcmstep = tab[2];
  370. }
  372. s->offset = pcmptr - pcmend;
  373. s->rwing = rwgptr;
  374. s->lwing = lwgptr;
  375. s->phasef = phasef;
  377. return outptr;
  378. }