[pcsx_rearmed.git] / plugins / dfsound / xa.c

/***************************************************************************
                            xa.c  -  description
                             -------------------
    begin                : Wed May 15 2002
    copyright            : (C) 2002 by Pete Bernert
    email                : BlackDove@addcom.de
 ***************************************************************************/
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version. See also the license.txt file for *
 *   additional informations.                                              *
 *                                                                         *
 ***************************************************************************/

#include "stdafx.h"
#include "spu.h"
#define _IN_XA
#include <stdint.h>

// will be included from spu.c
#ifdef _IN_SPU

////////////////////////////////////////////////////////////////////////
// XA GLOBALS
////////////////////////////////////////////////////////////////////////

static int gauss_ptr = 0;
static int gauss_window[8] = {0, 0, 0, 0, 0, 0, 0, 0};

#define gvall0 gauss_window[gauss_ptr]
#define gvall(x) gauss_window[(gauss_ptr+x)&3]
#define gvalr0 gauss_window[4+gauss_ptr]
#define gvalr(x) gauss_window[4+((gauss_ptr+x)&3)]

////////////////////////////////////////////////////////////////////////
// MIX XA & CDDA
////////////////////////////////////////////////////////////////////////

INLINE void MixXA(int *SSumLR, int *RVB, int ns_to, int decode_pos)
{
 int cursor = decode_pos;
 int ns;
 short l, r;
 uint32_t v = spu.XALastVal;

 if(spu.XAPlay != spu.XAFeed || spu.XARepeat > 0)
 {
  if(spu.XAPlay == spu.XAFeed)
   spu.XARepeat--;

  for(ns = 0; ns < ns_to*2; ns += 2)
   {
    if(spu.XAPlay != spu.XAFeed) v=*spu.XAPlay++;
    if(spu.XAPlay == spu.XAEnd) spu.XAPlay=spu.XAStart;

    l = ((int)(short)v * spu.iLeftXAVol) >> 15;
    r = ((int)(short)(v >> 16) * spu.iLeftXAVol) >> 15;
    if (spu.spuCtrl & CTRL_CD)
    {
     SSumLR[ns+0] += l;
     SSumLR[ns+1] += r;
    }
    if (unlikely(spu.spuCtrl & CTRL_CDREVERB))
    {
     RVB[ns+0] += l;
     RVB[ns+1] += r;
    }

    spu.spuMem[cursor] = HTOLE16(v);
    spu.spuMem[cursor + 0x400/2] = HTOLE16(v >> 16);
    cursor = (cursor + 1) & 0x1ff;
   }
  spu.XALastVal = v;
 }
 // occasionally CDDAFeed underflows by a few samples due to poor timing,
 // hence this 'ns_to < 8'
 else if(spu.CDDAPlay != spu.CDDAFeed || ns_to < 8)
 {
  for(ns = 0; ns < ns_to*2; ns += 2)
   {
    if(spu.CDDAPlay != spu.CDDAFeed) v=*spu.CDDAPlay++;
    if(spu.CDDAPlay == spu.CDDAEnd) spu.CDDAPlay=spu.CDDAStart;

    l = ((int)(short)v * spu.iLeftXAVol) >> 15;
    r = ((int)(short)(v >> 16) * spu.iLeftXAVol) >> 15;
    if (spu.spuCtrl & CTRL_CD)
    {
     SSumLR[ns+0] += l;
     SSumLR[ns+1] += r;
    }
    if (unlikely(spu.spuCtrl & CTRL_CDREVERB))
    {
     RVB[ns+0] += l;
     RVB[ns+1] += r;
    }

    spu.spuMem[cursor] = HTOLE16(v);
    spu.spuMem[cursor + 0x400/2] = HTOLE16(v >> 16);
    cursor = (cursor + 1) & 0x1ff;
   }
  spu.XALastVal = v;
 }
 else
  spu.XALastVal = 0;
}

////////////////////////////////////////////////////////////////////////
// small linux time helper... only used for watchdog
////////////////////////////////////////////////////////////////////////

#if 0
static unsigned long timeGetTime_spu()
{
#if defined(NO_OS)
 return 0;
#elif defined(_WIN32)
 return GetTickCount();
#else
 struct timeval tv;
 gettimeofday(&tv, 0);                                 // well, maybe there are better ways
 return tv.tv_sec * 1000 + tv.tv_usec/1000;            // to do that, but at least it works
#endif
}
#endif

////////////////////////////////////////////////////////////////////////
// FEED XA 
////////////////////////////////////////////////////////////////////////

INLINE void FeedXA(xa_decode_t *xap)
{
 int sinc,spos,i,iSize,iPlace,vl,vr;

 if(!spu.bSPUIsOpen) return;

 spu.xapGlobal = xap;                                  // store info for save states
 spu.XARepeat  = 3;                                    // set up repeat

#if 0//def XA_HACK
 iSize=((45500*xap->nsamples)/xap->freq);              // get size
#else
 iSize=((44100*xap->nsamples)/xap->freq);              // get size
#endif
 if(!iSize) return;                                    // none? bye

 if(spu.XAFeed<spu.XAPlay) iPlace=spu.XAPlay-spu.XAFeed; // how much space in my buf?
 else              iPlace=(spu.XAEnd-spu.XAFeed) + (spu.XAPlay-spu.XAStart);

 if(iPlace==0) return;                                 // no place at all

 //----------------------------------------------------//
#if 0
 if(spu_config.iXAPitch)                               // pitch change option?
  {
   static DWORD dwLT=0;
   static DWORD dwFPS=0;
   static int   iFPSCnt=0;
   static int   iLastSize=0;
   static DWORD dwL1=0;
   DWORD dw=timeGetTime_spu(),dw1,dw2;

   iPlace=iSize;

   dwFPS+=dw-dwLT;iFPSCnt++;

   dwLT=dw;
                                       
   if(iFPSCnt>=10)
    {
     if(!dwFPS) dwFPS=1;
     dw1=1000000/dwFPS; 
     if(dw1>=(dwL1-100) && dw1<=(dwL1+100)) dw1=dwL1;
     else dwL1=dw1;
     dw2=(xap->freq*100/xap->nsamples);
     if((!dw1)||((dw2+100)>=dw1)) iLastSize=0;
     else
      {
       iLastSize=iSize*dw2/dw1;
       if(iLastSize>iPlace) iLastSize=iPlace;
       iSize=iLastSize;
      }
     iFPSCnt=0;dwFPS=0;
    }
   else
    {
     if(iLastSize) iSize=iLastSize;
    }
  }
#endif
 //----------------------------------------------------//

 spos=0x10000L;
 sinc = (xap->nsamples << 16) / iSize;                 // calc freq by num / size

 if(xap->stereo)
{
   uint32_t * pS=(uint32_t *)xap->pcm;
   uint32_t l=0;

#if 0
   if(spu_config.iXAPitch)
    {
     int32_t l1,l2;short s;
     for(i=0;i<iSize;i++)
      {
       if(spu_config.iUseInterpolation==2)
        {
         while(spos>=0x10000L)
          {
           l = *pS++;
           gauss_window[gauss_ptr] = (short)LOWORD(l);
           gauss_window[4+gauss_ptr] = (short)HIWORD(l);
           gauss_ptr = (gauss_ptr+1) & 3;
           spos -= 0x10000L;
          }
         vl = (spos >> 6) & ~3;
         vr=(gauss[vl]*gvall0) >> 15;
         vr+=(gauss[vl+1]*gvall(1)) >> 15;
         vr+=(gauss[vl+2]*gvall(2)) >> 15;
         vr+=(gauss[vl+3]*gvall(3)) >> 15;
         l= vr & 0xffff;
         vr=(gauss[vl]*gvalr0) >> 15;
         vr+=(gauss[vl+1]*gvalr(1)) >> 15;
         vr+=(gauss[vl+2]*gvalr(2)) >> 15;
         vr+=(gauss[vl+3]*gvalr(3)) >> 15;
         l |= vr << 16;
        }
       else
        {
         while(spos>=0x10000L)
          {
           l = *pS++;
           spos -= 0x10000L;
          }
        }

       s=(short)LOWORD(l);
       l1=s;
       l1=(l1*iPlace)/iSize;
       ssat32_to_16(l1);
       s=(short)HIWORD(l);
       l2=s;
       l2=(l2*iPlace)/iSize;
       ssat32_to_16(l2);
       l=(l1&0xffff)|(l2<<16);

       *spu.XAFeed++=l;

       if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
       if(spu.XAFeed==spu.XAPlay)
        {
         if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
         break;
        }

       spos += sinc;
      }
    }
   else
#endif
    {
     for(i=0;i<iSize;i++)
      {
       if(spu_config.iUseInterpolation==2)
        {
         while(spos>=0x10000L)
          {
           l = *pS++;
           gauss_window[gauss_ptr] = (short)LOWORD(l);
           gauss_window[4+gauss_ptr] = (short)HIWORD(l);
           gauss_ptr = (gauss_ptr+1) & 3;
           spos -= 0x10000L;
          }
         vl = (spos >> 6) & ~3;
         vr=(gauss[vl]*gvall0) >> 15;
         vr+=(gauss[vl+1]*gvall(1)) >> 15;
         vr+=(gauss[vl+2]*gvall(2)) >> 15;
         vr+=(gauss[vl+3]*gvall(3)) >> 15;
         l= vr & 0xffff;
         vr=(gauss[vl]*gvalr0) >> 15;
         vr+=(gauss[vl+1]*gvalr(1)) >> 15;
         vr+=(gauss[vl+2]*gvalr(2)) >> 15;
         vr+=(gauss[vl+3]*gvalr(3)) >> 15;
         l |= vr << 16;
        }
       else
        {
         while(spos>=0x10000L)
          {
           l = *pS++;
           spos -= 0x10000L;
          }
        }

       *spu.XAFeed++=l;

       if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
       if(spu.XAFeed==spu.XAPlay)
        {
         if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
         break;
        }

       spos += sinc;
      }
    }
  }
 else
  {
   unsigned short * pS=(unsigned short *)xap->pcm;
   uint32_t l;short s=0;

#if 0
   if(spu_config.iXAPitch)
    {
     int32_t l1;
     for(i=0;i<iSize;i++)
      {
       if(spu_config.iUseInterpolation==2)
        {
         while(spos>=0x10000L)
          {
           gauss_window[gauss_ptr] = (short)*pS++;
           gauss_ptr = (gauss_ptr+1) & 3;
           spos -= 0x10000L;
          }
         vl = (spos >> 6) & ~3;
         vr=(gauss[vl]*gvall0) >> 15;
         vr+=(gauss[vl+1]*gvall(1)) >> 15;
         vr+=(gauss[vl+2]*gvall(2)) >> 15;
         vr+=(gauss[vl+3]*gvall(3)) >> 15;
         l1=s= vr;
         l1 &= 0xffff;
        }
       else
        {
         while(spos>=0x10000L)
          {
           s = *pS++;
           spos -= 0x10000L;
          }
         l1=s;
        }

       l1=(l1*iPlace)/iSize;
       ssat32_to_16(l1);
       l=(l1&0xffff)|(l1<<16);
       *spu.XAFeed++=l;

       if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
       if(spu.XAFeed==spu.XAPlay)
        {
         if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
         break;
        }

       spos += sinc;
      }
    }
   else
#endif
    {
     for(i=0;i<iSize;i++)
      {
       if(spu_config.iUseInterpolation==2)
        {
         while(spos>=0x10000L)
          {
           gauss_window[gauss_ptr] = (short)*pS++;
           gauss_ptr = (gauss_ptr+1) & 3;
           spos -= 0x10000L;
          }
         vl = (spos >> 6) & ~3;
         vr=(gauss[vl]*gvall0) >> 15;
         vr+=(gauss[vl+1]*gvall(1)) >> 15;
         vr+=(gauss[vl+2]*gvall(2)) >> 15;
         vr+=(gauss[vl+3]*gvall(3)) >> 15;
         l=s= vr;
        }
       else
        {
         while(spos>=0x10000L)
          {
           s = *pS++;
           spos -= 0x10000L;
          }
         l=s;
        }

       l &= 0xffff;
       *spu.XAFeed++=(l|(l<<16));

       if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
       if(spu.XAFeed==spu.XAPlay)
        {
         if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
         break;
        }

       spos += sinc;
      }
    }
  }
}

////////////////////////////////////////////////////////////////////////
// FEED CDDA
////////////////////////////////////////////////////////////////////////

INLINE int FeedCDDA(unsigned char *pcm, int nBytes)
{
 int space;
 space=(spu.CDDAPlay-spu.CDDAFeed-1)*4 & (CDDA_BUFFER_SIZE - 1);
 if(space<nBytes)
  return 0x7761; // rearmed_wait

 while(nBytes>0)
  {
   if(spu.CDDAFeed==spu.CDDAEnd) spu.CDDAFeed=spu.CDDAStart;
   space=(spu.CDDAPlay-spu.CDDAFeed-1)*4 & (CDDA_BUFFER_SIZE - 1);
   if(spu.CDDAFeed+space/4>spu.CDDAEnd)
    space=(spu.CDDAEnd-spu.CDDAFeed)*4;
   if(space>nBytes)
    space=nBytes;

   memcpy(spu.CDDAFeed,pcm,space);
   spu.CDDAFeed+=space/4;
   nBytes-=space;
   pcm+=space;
  }

 return 0x676f; // rearmed_go
}

#endif
// vim:shiftwidth=1:expandtab
Commit	Line	Data
	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	INLINE void FeedXA(xa_decode_t *xap)
	134	{
	135	int sinc,spos,i,iSize,iPlace,vl,vr;
	136
	137	if(!spu.bSPUIsOpen) return;
	138
	139	spu.xapGlobal = xap; // store info for save states
	140	spu.XARepeat = 3; // set up repeat
	141
	142	#if 0//def XA_HACK
	143	iSize=((45500*xap->nsamples)/xap->freq); // get size
	144	#else
	145	iSize=((44100*xap->nsamples)/xap->freq); // get size
	146	#endif
	147	if(!iSize) return; // none? bye
	148
	149	if(spu.XAFeed<spu.XAPlay) iPlace=spu.XAPlay-spu.XAFeed; // how much space in my buf?
	150	else iPlace=(spu.XAEnd-spu.XAFeed) + (spu.XAPlay-spu.XAStart);
	151
	152	if(iPlace==0) return; // no place at all
	153
	154	//----------------------------------------------------//
	155	#if 0
	156	if(spu_config.iXAPitch) // pitch change option?
	157	{
	158	static DWORD dwLT=0;
	159	static DWORD dwFPS=0;
	160	static int iFPSCnt=0;
	161	static int iLastSize=0;
	162	static DWORD dwL1=0;
	163	DWORD dw=timeGetTime_spu(),dw1,dw2;
	164
	165	iPlace=iSize;
	166
	167	dwFPS+=dw-dwLT;iFPSCnt++;
	168
	169	dwLT=dw;
	170
	171	if(iFPSCnt>=10)
	172	{
	173	if(!dwFPS) dwFPS=1;
	174	dw1=1000000/dwFPS;
	175	if(dw1>=(dwL1-100) && dw1<=(dwL1+100)) dw1=dwL1;
	176	else dwL1=dw1;
	177	dw2=(xap->freq*100/xap->nsamples);
	178	if((!dw1)\|\|((dw2+100)>=dw1)) iLastSize=0;
	179	else
	180	{
	181	iLastSize=iSize*dw2/dw1;
	182	if(iLastSize>iPlace) iLastSize=iPlace;
	183	iSize=iLastSize;
	184	}
	185	iFPSCnt=0;dwFPS=0;
	186	}
	187	else
	188	{
	189	if(iLastSize) iSize=iLastSize;
	190	}
	191	}
	192	#endif
	193	//----------------------------------------------------//
	194
	195	spos=0x10000L;
	196	sinc = (xap->nsamples << 16) / iSize; // calc freq by num / size
	197
	198	if(xap->stereo)
	199	{
	200	uint32_t * pS=(uint32_t *)xap->pcm;
	201	uint32_t l=0;
	202
	203	#if 0
	204	if(spu_config.iXAPitch)
	205	{
	206	int32_t l1,l2;short s;
	207	for(i=0;i<iSize;i++)
	208	{
	209	if(spu_config.iUseInterpolation==2)
	210	{
	211	while(spos>=0x10000L)
	212	{
	213	l = *pS++;
	214	gauss_window[gauss_ptr] = (short)LOWORD(l);
	215	gauss_window[4+gauss_ptr] = (short)HIWORD(l);
	216	gauss_ptr = (gauss_ptr+1) & 3;
	217	spos -= 0x10000L;
	218	}
	219	vl = (spos >> 6) & ~3;
	220	vr=(gauss[vl]*gvall0) >> 15;
	221	vr+=(gauss[vl+1]*gvall(1)) >> 15;
	222	vr+=(gauss[vl+2]*gvall(2)) >> 15;
	223	vr+=(gauss[vl+3]*gvall(3)) >> 15;
	224	l= vr & 0xffff;
	225	vr=(gauss[vl]*gvalr0) >> 15;
	226	vr+=(gauss[vl+1]*gvalr(1)) >> 15;
	227	vr+=(gauss[vl+2]*gvalr(2)) >> 15;
	228	vr+=(gauss[vl+3]*gvalr(3)) >> 15;
	229	l \|= vr << 16;
	230	}
	231	else
	232	{
	233	while(spos>=0x10000L)
	234	{
	235	l = *pS++;
	236	spos -= 0x10000L;
	237	}
	238	}
	239
	240	s=(short)LOWORD(l);
	241	l1=s;
	242	l1=(l1*iPlace)/iSize;
	243	ssat32_to_16(l1);
	244	s=(short)HIWORD(l);
	245	l2=s;
	246	l2=(l2*iPlace)/iSize;
	247	ssat32_to_16(l2);
	248	l=(l1&0xffff)\|(l2<<16);
	249
	250	*spu.XAFeed++=l;
	251
	252	if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
	253	if(spu.XAFeed==spu.XAPlay)
	254	{
	255	if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
	256	break;
	257	}
	258
	259	spos += sinc;
	260	}
	261	}
	262	else
	263	#endif
	264	{
	265	for(i=0;i<iSize;i++)
	266	{
	267	if(spu_config.iUseInterpolation==2)
	268	{
	269	while(spos>=0x10000L)
	270	{
	271	l = *pS++;
	272	gauss_window[gauss_ptr] = (short)LOWORD(l);
	273	gauss_window[4+gauss_ptr] = (short)HIWORD(l);
	274	gauss_ptr = (gauss_ptr+1) & 3;
	275	spos -= 0x10000L;
	276	}
	277	vl = (spos >> 6) & ~3;
	278	vr=(gauss[vl]*gvall0) >> 15;
	279	vr+=(gauss[vl+1]*gvall(1)) >> 15;
	280	vr+=(gauss[vl+2]*gvall(2)) >> 15;
	281	vr+=(gauss[vl+3]*gvall(3)) >> 15;
	282	l= vr & 0xffff;
	283	vr=(gauss[vl]*gvalr0) >> 15;
	284	vr+=(gauss[vl+1]*gvalr(1)) >> 15;
	285	vr+=(gauss[vl+2]*gvalr(2)) >> 15;
	286	vr+=(gauss[vl+3]*gvalr(3)) >> 15;
	287	l \|= vr << 16;
	288	}
	289	else
	290	{
	291	while(spos>=0x10000L)
	292	{
	293	l = *pS++;
	294	spos -= 0x10000L;
	295	}
	296	}
	297
	298	*spu.XAFeed++=l;
	299
	300	if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
	301	if(spu.XAFeed==spu.XAPlay)
	302	{
	303	if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
	304	break;
	305	}
	306
	307	spos += sinc;
	308	}
	309	}
	310	}
	311	else
	312	{
	313	unsigned short * pS=(unsigned short *)xap->pcm;
	314	uint32_t l;short s=0;
	315
	316	#if 0
	317	if(spu_config.iXAPitch)
	318	{
	319	int32_t l1;
	320	for(i=0;i<iSize;i++)
	321	{
	322	if(spu_config.iUseInterpolation==2)
	323	{
	324	while(spos>=0x10000L)
	325	{
	326	gauss_window[gauss_ptr] = (short)*pS++;
	327	gauss_ptr = (gauss_ptr+1) & 3;
	328	spos -= 0x10000L;
	329	}
	330	vl = (spos >> 6) & ~3;
	331	vr=(gauss[vl]*gvall0) >> 15;
	332	vr+=(gauss[vl+1]*gvall(1)) >> 15;
	333	vr+=(gauss[vl+2]*gvall(2)) >> 15;
	334	vr+=(gauss[vl+3]*gvall(3)) >> 15;
	335	l1=s= vr;
	336	l1 &= 0xffff;
	337	}
	338	else
	339	{
	340	while(spos>=0x10000L)
	341	{
	342	s = *pS++;
	343	spos -= 0x10000L;
	344	}
	345	l1=s;
	346	}
	347
	348	l1=(l1*iPlace)/iSize;
	349	ssat32_to_16(l1);
	350	l=(l1&0xffff)\|(l1<<16);
	351	*spu.XAFeed++=l;
	352
	353	if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
	354	if(spu.XAFeed==spu.XAPlay)
	355	{
	356	if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
	357	break;
	358	}
	359
	360	spos += sinc;
	361	}
	362	}
	363	else
	364	#endif
	365	{
	366	for(i=0;i<iSize;i++)
	367	{
	368	if(spu_config.iUseInterpolation==2)
	369	{
	370	while(spos>=0x10000L)
	371	{
	372	gauss_window[gauss_ptr] = (short)*pS++;
	373	gauss_ptr = (gauss_ptr+1) & 3;
	374	spos -= 0x10000L;
	375	}
	376	vl = (spos >> 6) & ~3;
	377	vr=(gauss[vl]*gvall0) >> 15;
	378	vr+=(gauss[vl+1]*gvall(1)) >> 15;
	379	vr+=(gauss[vl+2]*gvall(2)) >> 15;
	380	vr+=(gauss[vl+3]*gvall(3)) >> 15;
	381	l=s= vr;
	382	}
	383	else
	384	{
	385	while(spos>=0x10000L)
	386	{
	387	s = *pS++;
	388	spos -= 0x10000L;
	389	}
	390	l=s;
	391	}
	392
	393	l &= 0xffff;
	394	*spu.XAFeed++=(l\|(l<<16));
	395
	396	if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
	397	if(spu.XAFeed==spu.XAPlay)
	398	{
	399	if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
	400	break;
	401	}
	402
	403	spos += sinc;
	404	}
	405	}
	406	}
	407	}
	408
	409	////////////////////////////////////////////////////////////////////////
	410	// FEED CDDA
	411	////////////////////////////////////////////////////////////////////////
	412
	413	INLINE int FeedCDDA(unsigned char *pcm, int nBytes)
	414	{
	415	int space;
	416	space=(spu.CDDAPlay-spu.CDDAFeed-1)*4 & (CDDA_BUFFER_SIZE - 1);
	417	if(space<nBytes)
	418	return 0x7761; // rearmed_wait
	419
	420	while(nBytes>0)
	421	{
	422	if(spu.CDDAFeed==spu.CDDAEnd) spu.CDDAFeed=spu.CDDAStart;
	423	space=(spu.CDDAPlay-spu.CDDAFeed-1)*4 & (CDDA_BUFFER_SIZE - 1);
	424	if(spu.CDDAFeed+space/4>spu.CDDAEnd)
	425	space=(spu.CDDAEnd-spu.CDDAFeed)*4;
	426	if(space>nBytes)
	427	space=nBytes;
	428
	429	memcpy(spu.CDDAFeed,pcm,space);
	430	spu.CDDAFeed+=space/4;
	431	nBytes-=space;
	432	pcm+=space;
	433	}
	434
	435	return 0x676f; // rearmed_go
	436	}
	437
	438	#endif
	439	// vim:shiftwidth=1:expandtab