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