[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"
#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 ns_to, int decode_pos)
{
 int cursor = decode_pos;
 int ns;
 short l, r;
 uint32_t v;

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

  v = spu.XALastVal;
  for(ns = 0; ns < ns_to*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;
    SSumLR[ns++] += l;
    SSumLR[ns++] += r;

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

 for(ns = 0; ns < ns_to * 2 && spu.CDDAPlay!=spu.CDDAFeed && (spu.CDDAPlay!=spu.CDDAEnd-1||spu.CDDAFeed!=spu.CDDAStart);)
  {
   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;
   SSumLR[ns++] += l;
   SSumLR[ns++] += r;

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

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

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
}

////////////////////////////////////////////////////////////////////////
// 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  = 100;                                  // 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(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;
    }
  }
 //----------------------------------------------------//

 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(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)&~2047;
         vr+=(gauss[vl+1]*gvall(1))&~2047;
         vr+=(gauss[vl+2]*gvall(2))&~2047;
         vr+=(gauss[vl+3]*gvall(3))&~2047;
         l= (vr >> 11) & 0xffff;
         vr=(gauss[vl]*gvalr0)&~2047;
         vr+=(gauss[vl+1]*gvalr(1))&~2047;
         vr+=(gauss[vl+2]*gvalr(2))&~2047;
         vr+=(gauss[vl+3]*gvalr(3))&~2047;
         l |= vr << 5;
        }
       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
    {
     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)&~2047;
         vr+=(gauss[vl+1]*gvall(1))&~2047;
         vr+=(gauss[vl+2]*gvall(2))&~2047;
         vr+=(gauss[vl+3]*gvall(3))&~2047;
         l= (vr >> 11) & 0xffff;
         vr=(gauss[vl]*gvalr0)&~2047;
         vr+=(gauss[vl+1]*gvalr(1))&~2047;
         vr+=(gauss[vl+2]*gvalr(2))&~2047;
         vr+=(gauss[vl+3]*gvalr(3))&~2047;
         l |= vr << 5;
        }
       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(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)&~2047;
         vr+=(gauss[vl+1]*gvall(1))&~2047;
         vr+=(gauss[vl+2]*gvall(2))&~2047;
         vr+=(gauss[vl+3]*gvall(3))&~2047;
         l1=s= vr >> 11;
         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
    {
     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)&~2047;
         vr+=(gauss[vl+1]*gvall(1))&~2047;
         vr+=(gauss[vl+2]*gvall(2))&~2047;
         vr+=(gauss[vl+3]*gvall(3))&~2047;
         l=s= vr >> 11;
        }
       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
Commit	Line	Data
ef79bbde P	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
ef79bbde P	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
215ff9e6	41	INLINE void MixXA(int ns_to, int decode_pos)
ef79bbde	42	{
215ff9e6	43	int cursor = decode_pos;
ef79bbde	44	int ns;
efce366c	45	short l, r;
efce366c	46	uint32_t v;
ef79bbde	47
3154bfab	48	if(spu.XAPlay != spu.XAFeed \|\| spu.XARepeat > 0)
efce366c	49	{
3154bfab	50	if(spu.XAPlay == spu.XAFeed)
3154bfab	51	spu.XARepeat--;
efce366c	52
3154bfab	53	v = spu.XALastVal;
650adfd2	54	for(ns = 0; ns < ns_to*2; )
efce366c	55	{
3154bfab	56	if(spu.XAPlay != spu.XAFeed) v=*spu.XAPlay++;
3154bfab	57	if(spu.XAPlay == spu.XAEnd) spu.XAPlay=spu.XAStart;
efce366c	58
3154bfab	59	l = ((int)(short)v * spu.iLeftXAVol) >> 15;
3154bfab	60	r = ((int)(short)(v >> 16) * spu.iLeftXAVol) >> 15;
efce366c	61	SSumLR[ns++] += l;
efce366c	62	SSumLR[ns++] += r;
1d753163	63
3154bfab	64	spu.spuMem[cursor] = v;
3154bfab	65	spu.spuMem[cursor + 0x400/2] = v >> 16;
efce366c	66	cursor = (cursor + 1) & 0x1ff;
efce366c	67	}
3154bfab	68	spu.XALastVal = v;
efce366c	69	}
ef79bbde	70
3154bfab	71	for(ns = 0; ns < ns_to * 2 && spu.CDDAPlay!=spu.CDDAFeed && (spu.CDDAPlay!=spu.CDDAEnd-1\|\|spu.CDDAFeed!=spu.CDDAStart);)
ef79bbde	72	{
3154bfab	73	v=*spu.CDDAPlay++;
3154bfab	74	if(spu.CDDAPlay==spu.CDDAEnd) spu.CDDAPlay=spu.CDDAStart;
efce366c	75
3154bfab	76	l = ((int)(short)v * spu.iLeftXAVol) >> 15;
3154bfab	77	r = ((int)(short)(v >> 16) * spu.iLeftXAVol) >> 15;
efce366c	78	SSumLR[ns++] += l;
efce366c	79	SSumLR[ns++] += r;
1d753163	80
3154bfab	81	spu.spuMem[cursor] = v;
3154bfab	82	spu.spuMem[cursor + 0x400/2] = v >> 16;
efce366c	83	cursor = (cursor + 1) & 0x1ff;
ef79bbde P	84	}
	85	}
	86
	87	////////////////////////////////////////////////////////////////////////
	88	// small linux time helper... only used for watchdog
	89	////////////////////////////////////////////////////////////////////////
	90
f05d6ca2	91	static unsigned long timeGetTime_spu()
ef79bbde	92	{
de4a0279	93	#if defined(NO_OS)
	94	return 0;
	95	#elif defined(_WIN32)
003cfc63	96	return GetTickCount();
003cfc63	97	#else
ef79bbde P	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
003cfc63	101	#endif
ef79bbde P	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
3154bfab	112	if(!spu.bSPUIsOpen) return;
ef79bbde	113
3154bfab	114	spu.xapGlobal = xap; // store info for save states
3154bfab	115	spu.XARepeat = 100; // set up repeat
ef79bbde	116
97ea4077	117	#if 0//def XA_HACK
ef79bbde P	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
3154bfab	124	if(spu.XAFeed<spu.XAPlay) iPlace=spu.XAPlay-spu.XAFeed; // how much space in my buf?
3154bfab	125	else iPlace=(spu.XAEnd-spu.XAFeed) + (spu.XAPlay-spu.XAStart);
ef79bbde P	126
	127	if(iPlace==0) return; // no place at all
	128
	129	//----------------------------------------------------//
3154bfab	130	if(spu_config.iXAPitch) // pitch change option?
ef79bbde P	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
3154bfab	176	if(spu_config.iXAPitch)
ef79bbde P	177	{
	178	int32_t l1,l2;short s;
	179	for(i=0;i<iSize;i++)
	180	{
3154bfab	181	if(spu_config.iUseInterpolation==2)
ef79bbde P	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;
381ea103	215	ssat32_to_16(l1);
ef79bbde P	216	s=(short)HIWORD(l);
	217	l2=s;
	218	l2=(l2*iPlace)/iSize;
381ea103	219	ssat32_to_16(l2);
ef79bbde P	220	l=(l1&0xffff)\|(l2<<16);
ef79bbde P	221
3154bfab	222	*spu.XAFeed++=l;
ef79bbde	223
3154bfab	224	if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
3154bfab	225	if(spu.XAFeed==spu.XAPlay)
ef79bbde	226	{
3154bfab	227	if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
ef79bbde P	228	break;
	229	}
	230
	231	spos += sinc;
	232	}
	233	}
	234	else
	235	{
	236	for(i=0;i<iSize;i++)
	237	{
3154bfab	238	if(spu_config.iUseInterpolation==2)
ef79bbde P	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
3154bfab	269	*spu.XAFeed++=l;
ef79bbde	270
3154bfab	271	if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
3154bfab	272	if(spu.XAFeed==spu.XAPlay)
ef79bbde	273	{
3154bfab	274	if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
ef79bbde P	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
3154bfab	287	if(spu_config.iXAPitch)
ef79bbde P	288	{
	289	int32_t l1;
	290	for(i=0;i<iSize;i++)
	291	{
3154bfab	292	if(spu_config.iUseInterpolation==2)
ef79bbde P	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;
381ea103	319	ssat32_to_16(l1);
ef79bbde	320	l=(l1&0xffff)\|(l1<<16);
3154bfab	321	*spu.XAFeed++=l;
ef79bbde	322
3154bfab	323	if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
3154bfab	324	if(spu.XAFeed==spu.XAPlay)
ef79bbde	325	{
3154bfab	326	if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
ef79bbde P	327	break;
	328	}
	329
	330	spos += sinc;
	331	}
	332	}
	333	else
	334	{
	335	for(i=0;i<iSize;i++)
	336	{
3154bfab	337	if(spu_config.iUseInterpolation==2)
ef79bbde P	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;
ef79bbde P	351	}
	352	else
	353	{
	354	while(spos>=0x10000L)
	355	{
	356	s = *pS++;
	357	spos -= 0x10000L;
	358	}
	359	l=s;
	360	}
	361
9098b863	362	l &= 0xffff;
3154bfab	363	*spu.XAFeed++=(l\|(l<<16));
ef79bbde	364
3154bfab	365	if(spu.XAFeed==spu.XAEnd) spu.XAFeed=spu.XAStart;
3154bfab	366	if(spu.XAFeed==spu.XAPlay)
ef79bbde	367	{
3154bfab	368	if(spu.XAPlay!=spu.XAStart) spu.XAFeed=spu.XAPlay-1;
ef79bbde P	369	break;
	370	}
	371
	372	spos += sinc;
	373	}
	374	}
	375	}
	376	}
	377
	378	////////////////////////////////////////////////////////////////////////
	379	// FEED CDDA
	380	////////////////////////////////////////////////////////////////////////
	381
983a7cfd	382	INLINE int FeedCDDA(unsigned char *pcm, int nBytes)
ef79bbde	383	{
983a7cfd	384	int space;
3154bfab	385	space=(spu.CDDAPlay-spu.CDDAFeed-1)*4 & (CDDA_BUFFER_SIZE - 1);
983a7cfd	386	if(space<nBytes)
	387	return 0x7761; // rearmed_wait
	388
ef79bbde P	389	while(nBytes>0)
ef79bbde P	390	{
3154bfab	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;
983a7cfd	395	if(space>nBytes)
	396	space=nBytes;
	397
3154bfab	398	memcpy(spu.CDDAFeed,pcm,space);
3154bfab	399	spu.CDDAFeed+=space/4;
983a7cfd	400	nBytes-=space;
983a7cfd	401	pcm+=space;
ef79bbde	402	}
983a7cfd	403
983a7cfd	404	return 0x676f; // rearmed_go
ef79bbde P	405	}
	406
	407	#endif