cleanup
[pcsx_rearmed.git] / plugins / dfsound / xa.c
1 /***************************************************************************
2                             xa.c  -  description
3                              -------------------
4     begin                : Wed May 15 2002
5     copyright            : (C) 2002 by Pete Bernert
6     email                : BlackDove@addcom.de
7  ***************************************************************************/
8 /***************************************************************************
9  *                                                                         *
10  *   This program is free software; you can redistribute it and/or modify  *
11  *   it under the terms of the GNU General Public License as published by  *
12  *   the Free Software Foundation; either version 2 of the License, or     *
13  *   (at your option) any later version. See also the license.txt file for *
14  *   additional informations.                                              *
15  *                                                                         *
16  ***************************************************************************/
17
18 #include "stdafx.h"
19 #define _IN_XA
20 #include <stdint.h>
21
22 // will be included from spu.c
23 #ifdef _IN_SPU
24
25 ////////////////////////////////////////////////////////////////////////
26 // XA GLOBALS
27 ////////////////////////////////////////////////////////////////////////
28
29 static int gauss_ptr = 0;
30 static int gauss_window[8] = {0, 0, 0, 0, 0, 0, 0, 0};
31
32 #define gvall0 gauss_window[gauss_ptr]
33 #define gvall(x) gauss_window[(gauss_ptr+x)&3]
34 #define gvalr0 gauss_window[4+gauss_ptr]
35 #define gvalr(x) gauss_window[4+((gauss_ptr+x)&3)]
36
37 ////////////////////////////////////////////////////////////////////////
38 // MIX XA & CDDA
39 ////////////////////////////////////////////////////////////////////////
40
41 INLINE void MixXA(int *SSumLR, int ns_to, int decode_pos)
42 {
43  int cursor = decode_pos;
44  int ns;
45  short l, r;
46  uint32_t v;
47
48  if(spu.XAPlay != spu.XAFeed || spu.XARepeat > 0)
49  {
50   if(spu.XAPlay == spu.XAFeed)
51    spu.XARepeat--;
52
53   v = spu.XALastVal;
54   for(ns = 0; ns < ns_to*2; )
55    {
56     if(spu.XAPlay != spu.XAFeed) v=*spu.XAPlay++;
57     if(spu.XAPlay == spu.XAEnd) spu.XAPlay=spu.XAStart;
58
59     l = ((int)(short)v * spu.iLeftXAVol) >> 15;
60     r = ((int)(short)(v >> 16) * spu.iLeftXAVol) >> 15;
61     SSumLR[ns++] += l;
62     SSumLR[ns++] += r;
63
64     spu.spuMem[cursor] = v;
65     spu.spuMem[cursor + 0x400/2] = v >> 16;
66     cursor = (cursor + 1) & 0x1ff;
67    }
68   spu.XALastVal = v;
69  }
70
71  for(ns = 0; ns < ns_to * 2 && spu.CDDAPlay!=spu.CDDAFeed && (spu.CDDAPlay!=spu.CDDAEnd-1||spu.CDDAFeed!=spu.CDDAStart);)
72   {
73    v=*spu.CDDAPlay++;
74    if(spu.CDDAPlay==spu.CDDAEnd) spu.CDDAPlay=spu.CDDAStart;
75
76    l = ((int)(short)v * spu.iLeftXAVol) >> 15;
77    r = ((int)(short)(v >> 16) * spu.iLeftXAVol) >> 15;
78    SSumLR[ns++] += l;
79    SSumLR[ns++] += r;
80
81    spu.spuMem[cursor] = v;
82    spu.spuMem[cursor + 0x400/2] = v >> 16;
83    cursor = (cursor + 1) & 0x1ff;
84   }
85 }
86
87 ////////////////////////////////////////////////////////////////////////
88 // small linux time helper... only used for watchdog
89 ////////////////////////////////////////////////////////////////////////
90
91 static unsigned long timeGetTime_spu()
92 {
93 #if defined(NO_OS)
94  return 0;
95 #elif defined(_WIN32)
96  return GetTickCount();
97 #else
98  struct timeval tv;
99  gettimeofday(&tv, 0);                                 // well, maybe there are better ways
100  return tv.tv_sec * 1000 + tv.tv_usec/1000;            // to do that, but at least it works
101 #endif
102 }
103
104 ////////////////////////////////////////////////////////////////////////
105 // FEED XA 
106 ////////////////////////////////////////////////////////////////////////
107
108 INLINE void FeedXA(xa_decode_t *xap)
109 {
110  int sinc,spos,i,iSize,iPlace,vl,vr;
111
112  if(!spu.bSPUIsOpen) return;
113
114  spu.xapGlobal = xap;                                  // store info for save states
115  spu.XARepeat  = 100;                                  // set up repeat
116
117 #if 0//def XA_HACK
118  iSize=((45500*xap->nsamples)/xap->freq);              // get size
119 #else
120  iSize=((44100*xap->nsamples)/xap->freq);              // get size
121 #endif
122  if(!iSize) return;                                    // none? bye
123
124  if(spu.XAFeed<spu.XAPlay) iPlace=spu.XAPlay-spu.XAFeed; // how much space in my buf?
125  else              iPlace=(spu.XAEnd-spu.XAFeed) + (spu.XAPlay-spu.XAStart);
126
127  if(iPlace==0) return;                                 // no place at all
128
129  //----------------------------------------------------//
130  if(spu_config.iXAPitch)                               // pitch change option?
131   {
132    static DWORD dwLT=0;
133    static DWORD dwFPS=0;
134    static int   iFPSCnt=0;
135    static int   iLastSize=0;
136    static DWORD dwL1=0;
137    DWORD dw=timeGetTime_spu(),dw1,dw2;
138
139    iPlace=iSize;
140
141    dwFPS+=dw-dwLT;iFPSCnt++;
142
143    dwLT=dw;
144                                        
145    if(iFPSCnt>=10)
146     {
147      if(!dwFPS) dwFPS=1;
148      dw1=1000000/dwFPS; 
149      if(dw1>=(dwL1-100) && dw1<=(dwL1+100)) dw1=dwL1;
150      else dwL1=dw1;
151      dw2=(xap->freq*100/xap->nsamples);
152      if((!dw1)||((dw2+100)>=dw1)) iLastSize=0;
153      else
154       {
155        iLastSize=iSize*dw2/dw1;
156        if(iLastSize>iPlace) iLastSize=iPlace;
157        iSize=iLastSize;
158       }
159      iFPSCnt=0;dwFPS=0;
160     }
161    else
162     {
163      if(iLastSize) iSize=iLastSize;
164     }
165   }
166  //----------------------------------------------------//
167
168  spos=0x10000L;
169  sinc = (xap->nsamples << 16) / iSize;                 // calc freq by num / size
170
171  if(xap->stereo)
172 {
173    uint32_t * pS=(uint32_t *)xap->pcm;
174    uint32_t l=0;
175
176    if(spu_config.iXAPitch)
177     {
178      int32_t l1,l2;short s;
179      for(i=0;i<iSize;i++)
180       {
181        if(spu_config.iUseInterpolation==2)
182         {
183          while(spos>=0x10000L)
184           {
185            l = *pS++;
186            gauss_window[gauss_ptr] = (short)LOWORD(l);
187            gauss_window[4+gauss_ptr] = (short)HIWORD(l);
188            gauss_ptr = (gauss_ptr+1) & 3;
189            spos -= 0x10000L;
190           }
191          vl = (spos >> 6) & ~3;
192          vr=(gauss[vl]*gvall0)&~2047;
193          vr+=(gauss[vl+1]*gvall(1))&~2047;
194          vr+=(gauss[vl+2]*gvall(2))&~2047;
195          vr+=(gauss[vl+3]*gvall(3))&~2047;
196          l= (vr >> 11) & 0xffff;
197          vr=(gauss[vl]*gvalr0)&~2047;
198          vr+=(gauss[vl+1]*gvalr(1))&~2047;
199          vr+=(gauss[vl+2]*gvalr(2))&~2047;
200          vr+=(gauss[vl+3]*gvalr(3))&~2047;
201          l |= vr << 5;
202         }
203        else
204         {
205          while(spos>=0x10000L)
206           {
207            l = *pS++;
208            spos -= 0x10000L;
209           }
210         }
211
212        s=(short)LOWORD(l);
213        l1=s;
214        l1=(l1*iPlace)/iSize;
215        ssat32_to_16(l1);
216        s=(short)HIWORD(l);
217        l2=s;
218        l2=(l2*iPlace)/iSize;
219        ssat32_to_16(l2);
220        l=(l1&0xffff)|(l2<<16);
221
222        *spu.XAFeed++=l;
223
224        if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
225        if(spu.XAFeed==spu.XAPlay)
226         {
227          if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
228          break;
229         }
230
231        spos += sinc;
232       }
233     }
234    else
235     {
236      for(i=0;i<iSize;i++)
237       {
238        if(spu_config.iUseInterpolation==2)
239         {
240          while(spos>=0x10000L)
241           {
242            l = *pS++;
243            gauss_window[gauss_ptr] = (short)LOWORD(l);
244            gauss_window[4+gauss_ptr] = (short)HIWORD(l);
245            gauss_ptr = (gauss_ptr+1) & 3;
246            spos -= 0x10000L;
247           }
248          vl = (spos >> 6) & ~3;
249          vr=(gauss[vl]*gvall0)&~2047;
250          vr+=(gauss[vl+1]*gvall(1))&~2047;
251          vr+=(gauss[vl+2]*gvall(2))&~2047;
252          vr+=(gauss[vl+3]*gvall(3))&~2047;
253          l= (vr >> 11) & 0xffff;
254          vr=(gauss[vl]*gvalr0)&~2047;
255          vr+=(gauss[vl+1]*gvalr(1))&~2047;
256          vr+=(gauss[vl+2]*gvalr(2))&~2047;
257          vr+=(gauss[vl+3]*gvalr(3))&~2047;
258          l |= vr << 5;
259         }
260        else
261         {
262          while(spos>=0x10000L)
263           {
264            l = *pS++;
265            spos -= 0x10000L;
266           }
267         }
268
269        *spu.XAFeed++=l;
270
271        if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
272        if(spu.XAFeed==spu.XAPlay)
273         {
274          if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
275          break;
276         }
277
278        spos += sinc;
279       }
280     }
281   }
282  else
283   {
284    unsigned short * pS=(unsigned short *)xap->pcm;
285    uint32_t l;short s=0;
286
287    if(spu_config.iXAPitch)
288     {
289      int32_t l1;
290      for(i=0;i<iSize;i++)
291       {
292        if(spu_config.iUseInterpolation==2)
293         {
294          while(spos>=0x10000L)
295           {
296            gauss_window[gauss_ptr] = (short)*pS++;
297            gauss_ptr = (gauss_ptr+1) & 3;
298            spos -= 0x10000L;
299           }
300          vl = (spos >> 6) & ~3;
301          vr=(gauss[vl]*gvall0)&~2047;
302          vr+=(gauss[vl+1]*gvall(1))&~2047;
303          vr+=(gauss[vl+2]*gvall(2))&~2047;
304          vr+=(gauss[vl+3]*gvall(3))&~2047;
305          l1=s= vr >> 11;
306          l1 &= 0xffff;
307         }
308        else
309         {
310          while(spos>=0x10000L)
311           {
312            s = *pS++;
313            spos -= 0x10000L;
314           }
315          l1=s;
316         }
317
318        l1=(l1*iPlace)/iSize;
319        ssat32_to_16(l1);
320        l=(l1&0xffff)|(l1<<16);
321        *spu.XAFeed++=l;
322
323        if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
324        if(spu.XAFeed==spu.XAPlay)
325         {
326          if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
327          break;
328         }
329
330        spos += sinc;
331       }
332     }
333    else
334     {
335      for(i=0;i<iSize;i++)
336       {
337        if(spu_config.iUseInterpolation==2)
338         {
339          while(spos>=0x10000L)
340           {
341            gauss_window[gauss_ptr] = (short)*pS++;
342            gauss_ptr = (gauss_ptr+1) & 3;
343            spos -= 0x10000L;
344           }
345          vl = (spos >> 6) & ~3;
346          vr=(gauss[vl]*gvall0)&~2047;
347          vr+=(gauss[vl+1]*gvall(1))&~2047;
348          vr+=(gauss[vl+2]*gvall(2))&~2047;
349          vr+=(gauss[vl+3]*gvall(3))&~2047;
350          l=s= vr >> 11;
351         }
352        else
353         {
354          while(spos>=0x10000L)
355           {
356            s = *pS++;
357            spos -= 0x10000L;
358           }
359          l=s;
360         }
361
362        l &= 0xffff;
363        *spu.XAFeed++=(l|(l<<16));
364
365        if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
366        if(spu.XAFeed==spu.XAPlay)
367         {
368          if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
369          break;
370         }
371
372        spos += sinc;
373       }
374     }
375   }
376 }
377
378 ////////////////////////////////////////////////////////////////////////
379 // FEED CDDA
380 ////////////////////////////////////////////////////////////////////////
381
382 INLINE int FeedCDDA(unsigned char *pcm, int nBytes)
383 {
384  int space;
385  space=(spu.CDDAPlay-spu.CDDAFeed-1)*4 & (CDDA_BUFFER_SIZE - 1);
386  if(space<nBytes)
387   return 0x7761; // rearmed_wait
388
389  while(nBytes>0)
390   {
391    if(spu.CDDAFeed==spu.CDDAEnd) spu.CDDAFeed=spu.CDDAStart;
392    space=(spu.CDDAPlay-spu.CDDAFeed-1)*4 & (CDDA_BUFFER_SIZE - 1);
393    if(spu.CDDAFeed+space/4>spu.CDDAEnd)
394     space=(spu.CDDAEnd-spu.CDDAFeed)*4;
395    if(space>nBytes)
396     space=nBytes;
397
398    memcpy(spu.CDDAFeed,pcm,space);
399    spu.CDDAFeed+=space/4;
400    nBytes-=space;
401    pcm+=space;
402   }
403
404  return 0x676f; // rearmed_go
405 }
406
407 #endif