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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
mmxresample.c
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：19k
源码类别：

Symbian

开发平台：

Visual C++

mmxresample.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: mmxresample.c,v 1.8.32.1 2004/07/09 02:01:17 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #ifdef _M_IX86
  52. /*
  53.  * Polyphase sampling rate conversion.
  54.  * by Ken Cooke
  55.  */
  56. #include "hlxclib/stdlib.h"
  57. #include "hlxclib/string.h"
  58. //#include <stdio.h>
  59. #include "allresamplers.h"
  61. /* leave a trace of the C source version in the object code */
  62. static const char VERSION[] = "$Revision: 1.8.32.1 $" ;
  64. #define CLIP(s) ((s) > 32767 ? 32767 : ((s) < -32768 ? -32768 : (s)))
  66. #define NWING 48
  67. #define NTAPS 96
  68. typedef short filtwing[NWING];
  70. #define PCMBUFLEN (NBLOCK + 2*NTAPS)
  71. #define ROFFSET (PCMBUFLEN / 2)
  72. #define RBYTEOFF (ROFFSET * 2)
  74. /* precomputed filter tables */
  75. #define HELIX_FEATURE_MMXFILTER_6_1
  76. #define HELIX_FEATURE_MMXFILTER_640_147
  77. #define HELIX_FEATURE_MMXFILTER_3_1
  78. #define HELIX_FEATURE_MMXFILTER_320_147
  79. #define HELIX_FEATURE_MMXFILTER_3_2
  80. #define HELIX_FEATURE_MMXFILTER_160_147
  81. #define HELIX_FEATURE_MMXFILTER_441_80
  82. #define HELIX_FEATURE_MMXFILTER_4_1
  83. #define HELIX_FEATURE_MMXFILTER_441_160
  84. #define HELIX_FEATURE_MMXFILTER_2_1
  85. #define HELIX_FEATURE_MMXFILTER_441_320
  86. #define HELIX_FEATURE_MMXFILTER_147_160
  88. #include "mmxfilters.c"
  89. //extern int updn_list[];
  90. //extern filtwing *filter_list[];
  91. //extern int *nextstate_list[];
  93. /* filter state */
  94. typedef struct {
  95. int up;
  96. int dn;
  97. int nchans;
  98. int phase;
  99. int offset;
  100. short *histbuf;
  101. short *pcmleft, *pcmrght;
  102. short *revbuf;
  103. short *revleft, *revrght;
  104. short *lwingptr;
  105. short *rwingptr;
  106. filtwing *filter;
  107. int *nextstate;
  108. } state_t;
  110. void *
  111. RAInitResamplerMMX(int inrate, int outrate, int nchans)
  112. {
  113. state_t *s;
  114. int divisor, up, dn;
  115. int idx;
  117. if (nchans != MONO && nchans != STEREO) {
  118. // printf("Error: must be mono or stereon");
  119. return NULL;
  120. }
  122. /* reduce to smallest fraction */
  123. divisor = gcd(inrate, outrate);
  124. up = outrate / divisor;
  125. dn = inrate / divisor;
  126. // printf("up = %d, down = %dn", up, dn);
  128. /* find corresponding filter in tables */
  129. for (idx = 0; updn_list[idx]; idx++)
  130. if (updn_list[idx] == ((up << 16) | dn))
  131. break;
  133. if (!updn_list[idx]) {
  134. // printf("Error: conversion by %d/%d not supportedn", up, dn);
  135. return NULL; /* unsupported rates */
  136. }
  138. /* malloc buffers */
  139. s = (state_t *) malloc(sizeof(state_t));
  140. if (s == NULL)
  141. return NULL;
  142. s->histbuf = (short *) calloc(PCMBUFLEN, sizeof(short));
  143. s->revbuf = (short *) calloc(PCMBUFLEN, sizeof(short));
  144. if (s->histbuf == NULL || s->revbuf == NULL)
  145. return NULL;
  147. /* filter init */
  148. s->filter = filter_list[idx];
  149. s->nextstate = nextstate_list[idx];
  150. s->up = up;
  151. s->dn = dn;
  152. s->nchans = nchans;
  153. s->phase = 0;
  154. s->offset = 0;
  155. s->pcmleft = s->histbuf + NTAPS;
  156. s->revleft = s->revbuf + NBLOCK/2;
  157. s->pcmrght = s->pcmleft + ROFFSET;
  158. s->revrght = s->revleft + ROFFSET;
  159. s->rwingptr = s->filter[0];
  160. s->lwingptr = s->filter[(s->nextstate[up-1]>>8) & 0xfff];
  162. return (void *) s;
  163. }
  165. void *
  166. RAInitResamplerCopyMMX(int nchans, void *inst)
  167. {
  168. state_t *s_in = (state_t *)inst;
  169. state_t *s_out = (state_t *) malloc(sizeof(state_t));
  171. if (s_in == NULL || s_out == NULL)
  172. return NULL;
  174. s_out->histbuf = (short *) calloc(PCMBUFLEN, sizeof(short));
  175. s_out->revbuf = (short *) calloc(PCMBUFLEN, sizeof(short));
  176. if (s_out->histbuf == NULL || s_out->revbuf == NULL)
  177. return NULL;
  179. /* filter init */
  180. s_out->filter = s_in->filter;
  181. s_out->nextstate = s_in->nextstate;
  182. s_out->up = s_in->up;
  183. s_out->dn = s_in->dn;
  184. s_out->nchans = nchans;
  185. s_out->phase = 0;
  186. s_out->offset = 0;
  187. s_out->pcmleft = s_out->histbuf + NTAPS;
  188. s_out->revleft = s_out->revbuf + NBLOCK/2;
  189. s_out->pcmrght = s_out->pcmleft + ROFFSET;
  190. s_out->revrght = s_out->revleft + ROFFSET;
  191. s_out->rwingptr = s_out->filter[0];
  192. s_out->lwingptr = s_out->filter[(s_out->nextstate[s_out->up-1]>>8) & 0xfff];
  194. return s_out ;
  195. }
  197. void
  198. RAFreeResamplerMMX(void *inst)
  199. {
  200. state_t *s = (state_t *)inst;
  202. if (s != NULL) {
  203. if (s->revbuf)
  204. free(s->revbuf);
  205. if (s->histbuf)
  206. free(s->histbuf);
  207. free(s);
  208. }
  209. }
  211. int
  212. RAResampleStereoMMX(void *inbuf, int insamps, tConverter *pCvt, short *outbuf, int outstride, void *inst)
  213. {
  214.     state_t *s = (state_t *)inst;
  215. short *pcmptr, *revptr, *pcmend;
  216. short *rwingptr, *lwingptr;
  217. int i, outsamps;
  218. /* local copies */
  219. filtwing *filter = s->filter;
  220. int *nextstate = s->nextstate;
  221. int phase = s->phase;
  222. int round13[2] = { 1<<13, 1<<13 };
  224. // TICK();
  225. // ASSERT(!(insamps & 0x1)); /* stereo must be even */
  227. outstride *= sizeof(short) ;
  229. // hack the state machine to point to pcmleft and pcmright buffers.
  230. pCvt->pStateMachine[0].incOutput = s->pcmrght - s->pcmleft ;
  231. pCvt->pStateMachine[1].incOutput = s->pcmleft - s->pcmrght + 1 ;
  232. insamps = 2*pCvt->pfCvt(s->pcmleft,inbuf,insamps,pCvt->pStateMachine) ;
  234. #if 0
  235. /* deinterleave new input */
  236. for (i = 0; i < insamps/2; i++) {
  237. s->pcmleft[i] = inbuf[0];
  238. s->pcmrght[i] = inbuf[1];
  239. inbuf += 2;
  240. }
  241. #endif
  242. /* create revbufs */
  243. for (i = -insamps/2; i < NTAPS; i++) {
  244. s->revleft[i] = s->pcmleft[-i-1];
  245. s->revrght[i] = s->pcmrght[-i-1];
  246. }
  248. /* restore filter state */
  249. pcmptr = s->pcmleft + s->offset - (NTAPS-1);
  250. revptr = s->revleft - s->offset - 1;
  251. pcmend = s->pcmleft + insamps/2 - (NTAPS-1);
  252. rwingptr = s->rwingptr;
  253. lwingptr = s->lwingptr;
  255. __asm {
  256. mov esi, pcmptr
  257. mov edi, revptr
  258. mov ebx, phase
  259. mov ecx, outbuf
  260. mov eax, rwingptr
  261. mov edx, lwingptr
  262. movq mm5, round13
  264. conv_loop: /* while (pcmptr < pcmend) */
  265. cmp esi, pcmend
  266. jae conv_done
  268. /* LEFT CHANNEL */
  270. /* prime */
  271. movq mm6, [esi+0]
  272. pmaddwd mm6, [eax+0]
  273. movq mm1, [edi+0]
  274. pmaddwd mm1, [edx+0]
  276. movq mm2, [esi+8]
  277. psrad mm6, 8
  278. pmaddwd mm2, [eax+8]
  279. //paddd mm6, mm0
  280. movq mm3, [edi+8]
  281. psrad mm1, 8
  282. pmaddwd mm3, [edx+8]
  283. paddd mm6, mm1
  285. movq mm0, [esi+16]
  286. psrad mm2, 6
  287. pmaddwd mm0, [eax+16]
  288. paddd mm6, mm2
  289. movq mm1, [edi+16]
  290. psrad mm3, 6
  291. pmaddwd mm1, [edx+16]
  292. paddd mm6, mm3
  294. movq mm2, [esi+24]
  295. psrad mm0, 4
  296. pmaddwd mm2, [eax+24]
  297. paddd mm6, mm0
  298. movq mm3, [edi+24]
  299. psrad mm1, 4
  300. pmaddwd mm3, [edx+24]
  301. paddd mm6, mm1
  303. movq mm0, [esi+32]
  304. psrad mm2, 3
  305. pmaddwd mm0, [eax+32]
  306. paddd mm6, mm2
  307. movq mm1, [edi+32]
  308. psrad mm3, 3
  309. pmaddwd mm1, [edx+32]
  310. paddd mm6, mm3
  312. movq mm2, [esi+40]
  313. psrad mm0, 2
  314. pmaddwd mm2, [eax+40]
  315. paddd mm6, mm0
  316. movq mm3, [edi+40]
  317. psrad mm1, 2
  318. pmaddwd mm3, [edx+40]
  319. paddd mm6, mm1
  321. movq mm0, [esi+48]
  322. psrad mm2, 1
  323. pmaddwd mm0, [eax+48]
  324. paddd mm6, mm2
  325. movq mm1, [edi+48]
  326. psrad mm3, 1
  327. pmaddwd mm1, [edx+48]
  328. paddd mm6, mm3
  330. /* acc shift */
  331. psrad mm6, 8
  333. movq mm2, [esi+56]
  334. psrad mm0, 8
  335. pmaddwd mm2, [eax+56]
  336. paddd mm6, mm0
  337. movq mm3, [edi+56]
  338. psrad mm1, 8
  339. pmaddwd mm3, [edx+56]
  340. paddd mm6, mm1
  342. movq mm0, [esi+64]
  343. psrad mm2, 7
  344. pmaddwd mm0, [eax+64]
  345. paddd mm6, mm2
  346. movq mm1, [edi+64]
  347. psrad mm3, 7
  348. pmaddwd mm1, [edx+64]
  349. paddd mm6, mm3
  351. movq mm2, [esi+72]
  352. psrad mm0, 6
  353. pmaddwd mm2, [eax+72]
  354. paddd mm6, mm0
  355. movq mm3, [edi+72]
  356. psrad mm1, 6
  357. pmaddwd mm3, [edx+72]
  358. paddd mm6, mm1
  360. movq mm0, [esi+80]
  361. psrad mm2, 5
  362. pmaddwd mm0, [eax+80]
  363. paddd mm6, mm2
  364. movq mm1, [edi+80]
  365. psrad mm3, 5
  366. pmaddwd mm1, [edx+80]
  367. paddd mm6, mm3
  369. movq mm2, [esi+88]
  370. psrad mm0, 4
  371. pmaddwd mm2, [eax+88]
  372. paddd mm6, mm0
  373. movq mm3, [edi+88]
  374. psrad mm1, 4
  375. pmaddwd mm3, [edx+88]
  376. paddd mm6, mm1
  378. /* flush */
  379. psrad mm2, 1
  380. paddd mm6, mm2
  381. psrad mm3, 1
  382. paddd mm6, mm3
  384. /* RIGHT CHANNEL */
  386. /* prime */
  387. movq mm7, [esi+RBYTEOFF+0]
  388. pmaddwd mm7, [eax+0]
  389. movq mm1, [edi+RBYTEOFF+0]
  390. pmaddwd mm1, [edx+0]
  392. movq mm2, [esi+RBYTEOFF+8]
  393. psrad mm7, 8
  394. pmaddwd mm2, [eax+8]
  395. //paddd mm7, mm0
  396. movq mm3, [edi+RBYTEOFF+8]
  397. psrad mm1, 8
  398. pmaddwd mm3, [edx+8]
  399. paddd mm7, mm1
  401. movq mm0, [esi+RBYTEOFF+16]
  402. psrad mm2, 6
  403. pmaddwd mm0, [eax+16]
  404. paddd mm7, mm2
  405. movq mm1, [edi+RBYTEOFF+16]
  406. psrad mm3, 6
  407. pmaddwd mm1, [edx+16]
  408. paddd mm7, mm3
  410. movq mm2, [esi+RBYTEOFF+24]
  411. psrad mm0, 4
  412. pmaddwd mm2, [eax+24]
  413. paddd mm7, mm0
  414. movq mm3, [edi+RBYTEOFF+24]
  415. psrad mm1, 4
  416. pmaddwd mm3, [edx+24]
  417. paddd mm7, mm1
  419. movq mm0, [esi+RBYTEOFF+32]
  420. psrad mm2, 3
  421. pmaddwd mm0, [eax+32]
  422. paddd mm7, mm2
  423. movq mm1, [edi+RBYTEOFF+32]
  424. psrad mm3, 3
  425. pmaddwd mm1, [edx+32]
  426. paddd mm7, mm3
  428. movq mm2, [esi+RBYTEOFF+40]
  429. psrad mm0, 2
  430. pmaddwd mm2, [eax+40]
  431. paddd mm7, mm0
  432. movq mm3, [edi+RBYTEOFF+40]
  433. psrad mm1, 2
  434. pmaddwd mm3, [edx+40]
  435. paddd mm7, mm1
  437. movq mm0, [esi+RBYTEOFF+48]
  438. psrad mm2, 1
  439. pmaddwd mm0, [eax+48]
  440. paddd mm7, mm2
  441. movq mm1, [edi+RBYTEOFF+48]
  442. psrad mm3, 1
  443. pmaddwd mm1, [edx+48]
  444. paddd mm7, mm3
  446. /* acc shift */
  447. psrad mm7, 8
  449. movq mm2, [esi+RBYTEOFF+56]
  450. psrad mm0, 8
  451. pmaddwd mm2, [eax+56]
  452. paddd mm7, mm0
  453. movq mm3, [edi+RBYTEOFF+56]
  454. psrad mm1, 8
  455. pmaddwd mm3, [edx+56]
  456. paddd mm7, mm1
  458. movq mm0, [esi+RBYTEOFF+64]
  459. psrad mm2, 7
  460. pmaddwd mm0, [eax+64]
  461. paddd mm7, mm2
  462. movq mm1, [edi+RBYTEOFF+64]
  463. psrad mm3, 7
  464. pmaddwd mm1, [edx+64]
  465. paddd mm7, mm3
  467. movq mm2, [esi+RBYTEOFF+72]
  468. psrad mm0, 6
  469. pmaddwd mm2, [eax+72]
  470. paddd mm7, mm0
  471. movq mm3, [edi+RBYTEOFF+72]
  472. psrad mm1, 6
  473. pmaddwd mm3, [edx+72]
  474. paddd mm7, mm1
  476. movq mm0, [esi+RBYTEOFF+80]
  477. psrad mm2, 5
  478. pmaddwd mm0, [eax+80]
  479. paddd mm7, mm2
  480. movq mm1, [edi+RBYTEOFF+80]
  481. psrad mm3, 5
  482. pmaddwd mm1, [edx+80]
  483. paddd mm7, mm3
  485. movq mm2, [esi+RBYTEOFF+88]
  486. psrad mm0, 4
  487. pmaddwd mm2, [eax+88]
  488. paddd mm7, mm0
  489. movq mm3, [edi+RBYTEOFF+88]
  490. psrad mm1, 4
  491. pmaddwd mm3, [edx+88]
  492. paddd mm7, mm1
  494. /* flush */
  495. psrad mm2, 1
  496. paddd mm7, mm2
  497. psrad mm3, 1
  498. paddd mm7, mm3
  500. /* BOTH CHANNELS */
  502. /* horizontal add */
  503. movq mm0, mm6
  504. punpckhdq mm6, mm7
  505. punpckldq mm0, mm7
  506. paddd mm6, mm0
  508. /* round, shift, clip */
  509. paddd mm6, mm5
  510. psrad mm6, 14
  511. packssdw mm6, mm6
  513. /* bump to next state */
  514. mov edx, nextstate
  515. mov ebx, [edx+4*ebx] // phase = nextstate[phase]
  517. lea edx, [ebx+ebx]
  518. and edx, 0xff<<1
  519. add esi, edx // pcmptr += pcmstep
  520. sub edi, edx // revptr -= pcmstep
  522. mov edx, ebx
  523. shr ebx, 20 // phase
  525. shr edx, 3
  526. and edx, 0xfff<<5 // 32 * idx
  527. lea edx, [edx+2*edx] // 96 * idx
  528. add edx, filter // lwingptr = filter[idx]
  530. movd [ecx], mm6 // *outptr++
  532. // add ecx, 4
  533. add   ecx,outstride
  535. lea eax, [ebx+2*ebx] // 3 * idx
  536. shl eax, 5 // 96 * idx
  537. add eax, filter // rwingptr = filter[idx]
  538. jmp conv_loop
  540. conv_done:
  541. sub ecx, outbuf // outsamps = outptr - outbuf
  542. shr ecx, 1
  543. mov outsamps, ecx
  545. mov pcmptr, esi
  546. mov revptr, edi
  547. mov phase, ebx
  548. mov rwingptr, eax
  549. mov lwingptr, edx
  550. emms
  551. }
  553. /* save filter state */
  554. s->phase = phase;
  555. s->offset = pcmptr - pcmend;
  556. s->rwingptr = rwingptr;
  557. s->lwingptr = lwingptr;
  559. memmove(s->pcmleft-NTAPS, s->pcmleft-NTAPS + insamps/2, NTAPS * sizeof(short));
  560. memmove(s->pcmrght-NTAPS, s->pcmrght-NTAPS + insamps/2, NTAPS * sizeof(short));
  562. // TOCK(outsamps);
  563. return outsamps;
  564. }
  566. int
  567. RAResampleMonoMMX(void *inbuf, int insamps, tConverter *pCvt, short *outbuf, int outstride, void *inst)
  568. {
  569.     state_t *s = (state_t *)inst;
  570. short *pcmptr, *revptr, *pcmend;
  571. short *rwingptr, *lwingptr;
  572. int i, outsamps;
  573. /* local copies */
  574. filtwing *filter = s->filter;
  575. int *nextstate = s->nextstate;
  576. int phase = s->phase;
  577. int round13[2] = { 1<<13, 1<<13 };
  579. // TICK();
  581. outstride *= sizeof(short) ;
  583. /* copy/convert new input */
  584. insamps = pCvt->pfCvt(s->pcmleft,inbuf,insamps,pCvt->pStateMachine) ;
  586. /* create revbuf */
  587. for (i = -insamps; i < NTAPS; i++)
  588. s->revrght[i] = s->pcmleft[-i-1];
  590. /* restore filter state */
  591. pcmptr = s->pcmleft + s->offset - (NTAPS-1);
  592. revptr = s->revrght - s->offset - 1;
  593. pcmend = s->pcmleft + insamps - (NTAPS-1);
  594. rwingptr = s->rwingptr;
  595. lwingptr = s->lwingptr;
  597. __asm {
  598. mov esi, pcmptr
  599. mov edi, revptr
  600. mov ebx, phase
  601. mov ecx, outbuf
  602. mov eax, rwingptr
  603. mov edx, lwingptr
  604. movq mm5, round13
  606. conv_loop: /* while (pcmptr < pcmend) */
  607. cmp esi, pcmend
  608. jae conv_done
  610. /* prime */
  611. movq mm7, [esi+0]
  612. pmaddwd mm7, [eax+0]
  613. movq mm1, [edi+0]
  614. pmaddwd mm1, [edx+0]
  616. movq mm2, [esi+8]
  617. psrad mm7, 8
  618. pmaddwd mm2, [eax+8]
  619. //paddd mm7, mm0
  620. movq mm3, [edi+8]
  621. psrad mm1, 8
  622. pmaddwd mm3, [edx+8]
  623. paddd mm7, mm1
  625. /* kernel */
  626. movq mm0, [esi+16]
  627. psrad mm2, 6
  628. pmaddwd mm0, [eax+16]
  629. paddd mm7, mm2
  630. movq mm1, [edi+16]
  631. psrad mm3, 6
  632. pmaddwd mm1, [edx+16]
  633. paddd mm7, mm3
  635. movq mm2, [esi+24]
  636. psrad mm0, 4
  637. pmaddwd mm2, [eax+24]
  638. paddd mm7, mm0
  639. movq mm3, [edi+24]
  640. psrad mm1, 4
  641. pmaddwd mm3, [edx+24]
  642. paddd mm7, mm1
  643. /* end kernel */
  645. movq mm0, [esi+32]
  646. psrad mm2, 3
  647. pmaddwd mm0, [eax+32]
  648. paddd mm7, mm2
  649. movq mm1, [edi+32]
  650. psrad mm3, 3
  651. pmaddwd mm1, [edx+32]
  652. paddd mm7, mm3
  654. movq mm2, [esi+40]
  655. psrad mm0, 2
  656. pmaddwd mm2, [eax+40]
  657. paddd mm7, mm0
  658. movq mm3, [edi+40]
  659. psrad mm1, 2
  660. pmaddwd mm3, [edx+40]
  661. paddd mm7, mm1
  663. movq mm0, [esi+48]
  664. psrad mm2, 1
  665. pmaddwd mm0, [eax+48]
  666. paddd mm7, mm2
  667. movq mm1, [edi+48]
  668. psrad mm3, 1
  669. pmaddwd mm1, [edx+48]
  670. paddd mm7, mm3
  672. /* acc shift */
  673. psrad mm7, 8
  675. movq mm2, [esi+56]
  676. psrad mm0, 8
  677. pmaddwd mm2, [eax+56]
  678. paddd mm7, mm0
  679. movq mm3, [edi+56]
  680. psrad mm1, 8
  681. pmaddwd mm3, [edx+56]
  682. paddd mm7, mm1
  684. movq mm0, [esi+64]
  685. psrad mm2, 7
  686. pmaddwd mm0, [eax+64]
  687. paddd mm7, mm2
  688. movq mm1, [edi+64]
  689. psrad mm3, 7
  690. pmaddwd mm1, [edx+64]
  691. paddd mm7, mm3
  693. movq mm2, [esi+72]
  694. psrad mm0, 6
  695. pmaddwd mm2, [eax+72]
  696. paddd mm7, mm0
  697. movq mm3, [edi+72]
  698. psrad mm1, 6
  699. pmaddwd mm3, [edx+72]
  700. paddd mm7, mm1
  702. movq mm0, [esi+80]
  703. psrad mm2, 5
  704. pmaddwd mm0, [eax+80]
  705. paddd mm7, mm2
  706. movq mm1, [edi+80]
  707. psrad mm3, 5
  708. pmaddwd mm1, [edx+80]
  709. paddd mm7, mm3
  711. movq mm2, [esi+88]
  712. psrad mm0, 4
  713. pmaddwd mm2, [eax+88]
  714. paddd mm7, mm0
  715. movq mm3, [edi+88]
  716. psrad mm1, 4
  717. pmaddwd mm3, [edx+88]
  718. paddd mm7, mm1
  720. /* flush */
  721. psrad mm2, 1
  722. paddd mm7, mm2
  723. psrad mm3, 1
  724. paddd mm7, mm3
  726. /* horizontal add */
  727. movq mm0, mm7
  728. psrlq mm7, 32
  729. paddd mm7, mm0
  731. /* round, shift, clip */
  732. paddd mm7, mm5
  733. psrad mm7, 14
  734. packssdw mm7, mm7
  735. movd eax, mm7
  737. /* bump to next state */
  738. mov edx, nextstate
  739. mov ebx, [edx+4*ebx] // phase = nextstate[phase]
  741. lea edx, [ebx+ebx]
  742. and edx, 0xff<<1
  743. add esi, edx // pcmptr += pcmstep
  744. sub edi, edx // revptr -= pcmstep
  746. mov edx, ebx
  747. shr ebx, 20 // phase
  749. shr edx, 3
  750. and edx, 0xfff<<5 // 32 * idx
  751. lea edx, [edx+2*edx] // 96 * idx
  752. add edx, filter // lwingptr = filter[idx]
  754. mov word ptr [ecx], ax // *outptr++
  755. // add ecx, 2
  756. add   ecx, outstride
  758. lea eax, [ebx+2*ebx] // 3 * idx
  759. shl eax, 5 // 96 * idx
  760. add eax, filter // rwingptr = filter[idx]
  761. jmp conv_loop
  763. conv_done:
  764. sub ecx, outbuf // outsamps = outptr - outbuf
  765. shr ecx, 1
  766. mov outsamps, ecx
  768. mov pcmptr, esi
  769. mov revptr, edi
  770. mov phase, ebx
  771. mov rwingptr, eax
  772. mov lwingptr, edx
  773. emms
  774. }
  776. /* save filter state */
  777. s->phase = phase;
  778. s->offset = pcmptr - pcmend;
  779. s->rwingptr = rwingptr;
  780. s->lwingptr = lwingptr;
  782. memmove(s->pcmleft-NTAPS, s->pcmleft-NTAPS + insamps, NTAPS * sizeof(short));
  784. // TOCK(outsamps);
  785. return outsamps;
  786. }
  788. #include "mymath.h"
  790. int
  791. RAGetMaxOutputMMX(int insamps, void *inst)
  792. {
  793.     state_t *s = (state_t *)inst;
  794. int inframes, outframes, outsamps;
  796. inframes = (insamps + (s->nchans-1)) / s->nchans;
  797. outframes = (int) myCeil((double)inframes * s->up / s->dn);
  798. outsamps = outframes * s->nchans;
  800. return outsamps;
  801. }
  803. int
  804. RAGetMinInputMMX(int outsamps, void *inst)
  805. {
  806.     state_t *s = (state_t *)inst;
  807. int inframes, outframes, insamps;
  809. outframes = (outsamps + (s->nchans-1)) / s->nchans;
  810. inframes = (int) myCeil((double)outframes * s->dn / s->up);
  811. insamps = inframes * s->nchans;
  813. return insamps;
  814. }
  816. int
  817. RAGetDelayMMX(void *inst)
  818. {
  819. state_t *s = (state_t *)inst;
  820. return (int)(NWING * (float)s->up / s->dn) ;
  821. }
  823. #endif