[pcsx_rearmed.git] / plugins / spunull / spunull.c

/////////////////////////////////////////////////////////

#define PSE_LT_SPU                  4
#define PSE_SPU_ERR_SUCCESS         0
#define PSE_SPU_ERR                 -60
#define PSE_SPU_ERR_NOTCONFIGURED   PSE_SPU_ERR -1
#define PSE_SPU_ERR_INIT            PSE_SPU_ERR -2

/////////////////////////////////////////////////////////
// main emu calls:
// 0. Get type/name/version
// 1. Init
// 2. SetCallbacks
// 3. SetConfigFile
// 4. Open
// 5. Dma/register/xa calls...
// 6. Close
// 7. Shutdown
/////////////////////////////////////////////////////////

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "xa.h"
#include "register.h"
// some ms windows compatibility define
#undef CALLBACK
#define CALLBACK

////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////

const unsigned char version  = 1;
const unsigned char revision = 1;
const unsigned char build    = 1;
static char * libraryName    = "Pete's Null Audio Driver";
static char * libraryInfo    = "Pete's Null Audio Driver V1.1\nCoded by Pete Bernert\n"; 

////////////////////////////////////////////////////////////////////////

unsigned short  regArea[10000];                        // psx buffer
unsigned short  spuMem[256*1024];
unsigned char * spuMemC;
unsigned char * pSpuIrq=0;

unsigned short spuCtrl, spuStat, spuIrq=0;             // some vars to store psx reg infos
unsigned long  spuAddr=0xffffffff;                     // address into spu mem
char *         pConfigFile=0;

////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////

void (CALLBACK *irqCallback)(void)=0;                   // func of main emu, called on spu irq
void (CALLBACK *cddavCallback)(short, short)=0;

////////////////////////////////////////////////////////////////////////
// CODE AREA
////////////////////////////////////////////////////////////////////////

void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val, unsigned int cycles)
{
 unsigned long r=reg&0xfff;
 regArea[(r-0xc00)>>1] = val;

 if(r>=0x0c00 && r<0x0d80)
  {
   //int ch=(r>>4)-0xc0;
   switch(r&0x0f)
    {
     //------------------------------------------------// l volume
     case 0:                    
       //SetVolumeL(ch,val);
       return;
     //------------------------------------------------// r volume
     case 2:                                           
       //SetVolumeR(ch,val);
       return;
     //------------------------------------------------// pitch
     case 4:                                           
       //SetPitch(ch,val);
       return;
     //------------------------------------------------// start
     case 6:
       //s_chan[ch].pStart=spuMemC+((unsigned long) val<<3);
       return;
     //------------------------------------------------// adsr level 
     case 8:
       return;
     //------------------------------------------------// adsr rate 
     case 10:
      return;
     //------------------------------------------------// adsr volume
     case 12:
       return;
     //------------------------------------------------// loop adr
     case 14:                                          
       return;
     //------------------------------------------------//
    }
   return;
  }

 switch(r)
   {
    //-------------------------------------------------//
    case H_SPUaddr:
        spuAddr = (unsigned long) val<<3;
        return;
    //-------------------------------------------------//
    case H_SPUdata:
        spuMem[spuAddr>>1] = val;
        spuAddr+=2;
        if(spuAddr>0x7ffff) spuAddr=0;
        return;
    //-------------------------------------------------//
    case H_SPUctrl:
        spuCtrl=val;
        return;
    //-------------------------------------------------//
    case H_SPUstat:
        spuStat=val & 0xf800;
        return;
    //-------------------------------------------------//
    case H_SPUirqAddr:
        spuIrq = val;
        pSpuIrq=spuMemC+((unsigned long) val<<3);
        return;
    //-------------------------------------------------//
    case H_SPUon1:
        //SoundOn(0,16,val);
        return;
    //-------------------------------------------------//
    case H_SPUon2:
        //SoundOn(16,24,val);
        return;
    //-------------------------------------------------//
    case H_SPUoff1:
        //SoundOff(0,16,val);
        return;
    //-------------------------------------------------//
    case H_SPUoff2:
        //SoundOff(16,24,val);
        return;
    //-------------------------------------------------//
    case H_CDLeft:
        if(cddavCallback) cddavCallback(0,val);
        return;
    case H_CDRight:
        if(cddavCallback) cddavCallback(1,val);
        return;
    //-------------------------------------------------//
    case H_FMod1:
        //FModOn(0,16,val);
        return;
    //-------------------------------------------------//
    case H_FMod2:
        //FModOn(16,24,val);
        return;
    //-------------------------------------------------//
    case H_Noise1:
        //NoiseOn(0,16,val);
        return;
    //-------------------------------------------------//
    case H_Noise2:
        //NoiseOn(16,24,val);
        return;
    //-------------------------------------------------//
    case H_RVBon1:
        //ReverbOn(0,16,val);
        return;
    //-------------------------------------------------//
    case H_RVBon2:
        //ReverbOn(16,24,val);
        return;
    //-------------------------------------------------//
    case H_Reverb:
        return;
   }
}

////////////////////////////////////////////////////////////////////////\r

unsigned short CALLBACK SPUreadRegister(unsigned long reg, unsigned int cycles)
{
 unsigned long r=reg&0xfff;

 if(r>=0x0c00 && r<0x0d80)
  {
   switch(r&0x0f)
    {
     case 12:                                          // adsr vol
      {
       //int ch=(r>>4)-0xc0;
       static unsigned short adsr_dummy_vol=0;
       adsr_dummy_vol=!adsr_dummy_vol;
       return adsr_dummy_vol;
      }

     case 14:                                          // return curr loop adr
      {
       //int ch=(r>>4)-0xc0;        
       return 0;
      }
    }
  }

 switch(r)
  {
    case H_SPUctrl:
        return spuCtrl;

    case H_SPUstat:
        return spuStat;
        
    case H_SPUaddr:
        return (unsigned short)(spuAddr>>3);

    case H_SPUdata:
      {
       unsigned short s=spuMem[spuAddr>>1];
       spuAddr+=2;
       if(spuAddr>0x7ffff) spuAddr=0;
       return s;
      }

    case H_SPUirqAddr:
        return spuIrq;
  }
 return regArea[(r-0xc00)>>1];
}
 
////////////////////////////////////////////////////////////////////////

unsigned short CALLBACK SPUreadDMA(void)
{
 unsigned short s=spuMem[spuAddr>>1];
 spuAddr+=2;
 if(spuAddr>0x7ffff) spuAddr=0;
 return s;
}

////////////////////////////////////////////////////////////////////////

void CALLBACK SPUwriteDMA(unsigned short val)
{
 spuMem[spuAddr>>1] = val;                             // spu addr got by writeregister\r
 spuAddr+=2;                                           // inc spu addr
 if(spuAddr>0x7ffff) spuAddr=0;                        // wrap
}

////////////////////////////////////////////////////////////////////////

void CALLBACK SPUwriteDMAMem(unsigned short * pusPSXMem,int iSize,unsigned int cycles)
{
 int i;
 for(i=0;i<iSize;i++)
  {
   spuMem[spuAddr>>1] = *pusPSXMem++;                  // spu addr got by writeregister\r
   spuAddr+=2;                                         // inc spu addr
   if(spuAddr>0x7ffff) spuAddr=0;                      // wrap
  }
}

////////////////////////////////////////////////////////////////////////

void CALLBACK SPUreadDMAMem(unsigned short * pusPSXMem,int iSize,unsigned int cycles)
{
 int i;
 for(i=0;i<iSize;i++)
  {
   *pusPSXMem++=spuMem[spuAddr>>1];                    // spu addr got by writeregister
   spuAddr+=2;                                         // inc spu addr
   if(spuAddr>0x7ffff) spuAddr=0;                      // wrap
  }
}

////////////////////////////////////////////////////////////////////////
// XA AUDIO
////////////////////////////////////////////////////////////////////////

void CALLBACK SPUplayADPCMchannel(xa_decode_t *xap, unsigned int cycles, int is_start)
{
}

void CALLBACK SPUsetCDvol(unsigned char ll, unsigned char lr,
  unsigned char rl, unsigned char rr, unsigned int cycle)
{
}

////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
// INIT/EXIT STUFF
////////////////////////////////////////////////////////////////////////

long CALLBACK SPUinit(void)
{
 spuMemC=(unsigned char *)spuMem;                      // just small setup
 return 0;
}

////////////////////////////////////////////////////////////////////////

int bSPUIsOpen=0;

long CALLBACK SPUopen(void)
{
 if(bSPUIsOpen) return 0;

 bSPUIsOpen=1;

 //if(pConfigFile) ReadConfigFile(pConfigFile);

 return PSE_SPU_ERR_SUCCESS;        
}

////////////////////////////////////////////////////////////////////////

void SPUsetConfigFile(char * pCfg)
{
 pConfigFile=pCfg;
}

////////////////////////////////////////////////////////////////////////

long CALLBACK SPUclose(void)
{
 if(!bSPUIsOpen) return 0;
 bSPUIsOpen=0;
 return 0;
}

////////////////////////////////////////////////////////////////////////

long CALLBACK SPUshutdown(void)
{
 return 0;
}

////////////////////////////////////////////////////////////////////////
// MISC STUFF
////////////////////////////////////////////////////////////////////////

long CALLBACK SPUtest(void)
{
 return 0;
}

void SPUasync(unsigned int cycle, unsigned int flags)
{
}

int SPUplayCDDAchannel(short *pcm, int nbytes, unsigned int cycle, int is_start)
{
 return -1;
}

////////////////////////////////////////////////////////////////////////
// this functions will be called once, 
// passes a callback that should be called on SPU-IRQ

void CALLBACK SPUregisterCallback(void (CALLBACK *callback)(void))
{
 irqCallback = callback;
}

void CALLBACK SPUregisterCDDAVolume(void (CALLBACK *CDDAVcallback)(short, short))
{
 cddavCallback = CDDAVcallback;
}

////////////////////////////////////////////////////////////////////////\r

char * CALLBACK PSEgetLibName(void)
{
 return libraryName;
}

////////////////////////////////////////////////////////////////////////

unsigned long CALLBACK PSEgetLibType(void)
{
 return  PSE_LT_SPU;
}

////////////////////////////////////////////////////////////////////////\r

unsigned long CALLBACK PSEgetLibVersion(void)\r
{
 return version<<16|revision<<8|build;
}


char * SPUgetLibInfos(void)
{
 return libraryInfo;
}

////////////////////////////////////////////////////////////////////////\r

typedef struct\r
{
 char          szSPUName[8];
 unsigned long ulFreezeVersion;
 unsigned long ulFreezeSize;
 unsigned char cSPUPort[0x200];
 unsigned char cSPURam[0x80000];
 xa_decode_t   xaS;     
} SPUFreeze_t;

typedef struct
{
 unsigned long Future[256];

} SPUNULLFreeze_t;

////////////////////////////////////////////////////////////////////////\r

long CALLBACK SPUfreeze(unsigned long ulFreezeMode,SPUFreeze_t * pF,unsigned int cycles)
{
 int i;

 if(!pF) return 0;

 if(ulFreezeMode)
  {
   if(ulFreezeMode==1)
    memset(pF,0,sizeof(SPUFreeze_t)+sizeof(SPUNULLFreeze_t));

   strcpy(pF->szSPUName,"PBNUL");
   pF->ulFreezeVersion=1;
   pF->ulFreezeSize=sizeof(SPUFreeze_t)+sizeof(SPUNULLFreeze_t);

   if(ulFreezeMode==2) return 1;

   memcpy(pF->cSPURam,spuMem,0x80000);
   memcpy(pF->cSPUPort,regArea,0x200);
   // dummy:
   memset(&pF->xaS,0,sizeof(xa_decode_t));
   return 1;
  }

 if(ulFreezeMode!=0) return 0;

 memcpy(spuMem,pF->cSPURam,0x80000);
 memcpy(regArea,pF->cSPUPort,0x200);

 for(i=0;i<0x100;i++)
  {
   if(i!=H_SPUon1-0xc00 && i!=H_SPUon2-0xc00)
    SPUwriteRegister(0x1f801c00+i*2,regArea[i],cycles);
  }
 SPUwriteRegister(H_SPUon1,regArea[(H_SPUon1-0xc00)/2],cycles);
 SPUwriteRegister(H_SPUon2,regArea[(H_SPUon2-0xc00)/2],cycles);

 return 1;
}


//////////////////////////////////////////////////////////////////////// 
//////////////////////////////////////////////////////////////////////// 
//////////////////////////////////////////////////////////////////////// 
// UNUSED WINDOWS FUNCS... YOU SHOULDN'T USE THEM IN LINUX

long CALLBACK SPUconfigure(void)
{
 return 0;
}

void CALLBACK SPUabout(void)
{
}

//////////////////////////////////////////////////////////////////////// 
//////////////////////////////////////////////////////////////////////// 
//////////////////////////////////////////////////////////////////////// 
// OLD PSEMU 1 FUNCS... YOU SHOULDN'T USE THEM

unsigned short CALLBACK SPUgetOne(unsigned long val) 
{ 
 if(spuAddr!=0xffffffff) 
  { 
   return SPUreadDMA(); 
  } 
 if(val>=512*1024) val=512*1024-1; 
 return spuMem[val>>1]; 
} 
 
void CALLBACK SPUputOne(unsigned long val,unsigned short data) 
{ 
 if(spuAddr!=0xffffffff) 
  { 
   SPUwriteDMA(data); 
   return; 
  } 
 if(val>=512*1024) val=512*1024-1; 
 spuMem[val>>1] = data; 
} 
 
void CALLBACK SPUplaySample(unsigned char ch) 
{ 
} 
 
void CALLBACK SPUsetAddr(unsigned char ch, unsigned short waddr) 
{ 
 //s_chan[ch].pStart=spuMemC+((unsigned long) waddr<<3); 
} 
 
void CALLBACK SPUsetPitch(unsigned char ch, unsigned short pitch) 
{ 
 //SetPitch(ch,pitch); 
} 
 
void CALLBACK SPUsetVolumeL(unsigned char ch, short vol) 
{ 
 //SetVolumeL(ch,vol); 
} 
 
void CALLBACK SPUsetVolumeR(unsigned char ch, short vol) 
{ 
 //SetVolumeR(ch,vol); 
}                
 
void CALLBACK SPUstartChannels1(unsigned short channels) 
{ 
 //SoundOn(0,16,channels); 
} 
 
void CALLBACK SPUstartChannels2(unsigned short channels) 
{ 
 //SoundOn(16,24,channels); 
} 
 
void CALLBACK SPUstopChannels1(unsigned short channels) 
{ 
 //SoundOff(0,16,channels); 
} 
 
void CALLBACK SPUstopChannels2(unsigned short channels) 
{ 
 //SoundOff(16,24,channels); 
} 

void CALLBACK SPUregisterScheduleCb(void (CALLBACK *callback)(unsigned int))
{
}
Commit	Line	Data
0d464c77	1	/////////////////////////////////////////////////////////
	2
	3	#define PSE_LT_SPU 4
	4	#define PSE_SPU_ERR_SUCCESS 0
	5	#define PSE_SPU_ERR -60
	6	#define PSE_SPU_ERR_NOTCONFIGURED PSE_SPU_ERR -1
	7	#define PSE_SPU_ERR_INIT PSE_SPU_ERR -2
	8
	9	/////////////////////////////////////////////////////////
	10	// main emu calls:
	11	// 0. Get type/name/version
	12	// 1. Init
	13	// 2. SetCallbacks
	14	// 3. SetConfigFile
	15	// 4. Open
	16	// 5. Dma/register/xa calls...
	17	// 6. Close
	18	// 7. Shutdown
	19	/////////////////////////////////////////////////////////
	20
	21	#include <stdio.h>
	22	#include <stdlib.h>
	23	#include <string.h>
	24	#include "xa.h"
	25	#include "register.h"
	26	// some ms windows compatibility define
	27	#undef CALLBACK
	28	#define CALLBACK
	29
	30	////////////////////////////////////////////////////////////////////////
	31
	32	////////////////////////////////////////////////////////////////////////
	33
	34	const unsigned char version = 1;
	35	const unsigned char revision = 1;
	36	const unsigned char build = 1;
	37	static char * libraryName = "Pete's Null Audio Driver";
	38	static char * libraryInfo = "Pete's Null Audio Driver V1.1\nCoded by Pete Bernert\n";
	39
	40	////////////////////////////////////////////////////////////////////////
	41
	42	unsigned short regArea[10000]; // psx buffer
	43	unsigned short spuMem[256*1024];
	44	unsigned char * spuMemC;
	45	unsigned char * pSpuIrq=0;
	46
	47	unsigned short spuCtrl, spuStat, spuIrq=0; // some vars to store psx reg infos
	48	unsigned long spuAddr=0xffffffff; // address into spu mem
	49	char * pConfigFile=0;
	50
	51	////////////////////////////////////////////////////////////////////////
	52
	53	////////////////////////////////////////////////////////////////////////
	54
	55	void (CALLBACK *irqCallback)(void)=0; // func of main emu, called on spu irq
b64fb891	56	void (CALLBACK *cddavCallback)(short, short)=0;
0d464c77	57
	58	////////////////////////////////////////////////////////////////////////
	59	// CODE AREA
	60	////////////////////////////////////////////////////////////////////////
	61
650adfd2	62	void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val, unsigned int cycles)
0d464c77	63	{
	64	unsigned long r=reg&0xfff;
	65	regArea[(r-0xc00)>>1] = val;
	66
	67	if(r>=0x0c00 && r<0x0d80)
	68	{
	69	//int ch=(r>>4)-0xc0;
	70	switch(r&0x0f)
	71	{
	72	//------------------------------------------------// l volume
	73	case 0:
	74	//SetVolumeL(ch,val);
	75	return;
	76	//------------------------------------------------// r volume
	77	case 2:
	78	//SetVolumeR(ch,val);
	79	return;
	80	//------------------------------------------------// pitch
	81	case 4:
	82	//SetPitch(ch,val);
	83	return;
	84	//------------------------------------------------// start
	85	case 6:
	86	//s_chan[ch].pStart=spuMemC+((unsigned long) val<<3);
	87	return;
	88	//------------------------------------------------// adsr level
	89	case 8:
	90	return;
	91	//------------------------------------------------// adsr rate
	92	case 10:
	93	return;
	94	//------------------------------------------------// adsr volume
	95	case 12:
	96	return;
	97	//------------------------------------------------// loop adr
	98	case 14:
	99	return;
	100	//------------------------------------------------//
	101	}
	102	return;
	103	}
	104
	105	switch(r)
	106	{
	107	//-------------------------------------------------//
	108	case H_SPUaddr:
	109	spuAddr = (unsigned long) val<<3;
	110	return;
	111	//-------------------------------------------------//
	112	case H_SPUdata:
	113	spuMem[spuAddr>>1] = val;
	114	spuAddr+=2;
	115	if(spuAddr>0x7ffff) spuAddr=0;
	116	return;
	117	//-------------------------------------------------//
	118	case H_SPUctrl:
	119	spuCtrl=val;
	120	return;
	121	//-------------------------------------------------//
	122	case H_SPUstat:
	123	spuStat=val & 0xf800;
	124	return;
	125	//-------------------------------------------------//
	126	case H_SPUirqAddr:
127	spuIrq = val;
128	pSpuIrq=spuMemC+((unsigned long) val<<3);
129	return;
130	//-------------------------------------------------//
131	case H_SPUon1:
132	//SoundOn(0,16,val);
133	return;
134	//-------------------------------------------------//
135	case H_SPUon2:
136	//SoundOn(16,24,val);
137	return;
138	//-------------------------------------------------//
139	case H_SPUoff1:
140	//SoundOff(0,16,val);
141	return;
142	//-------------------------------------------------//
143	case H_SPUoff2:
144	//SoundOff(16,24,val);
145	return;
146	//-------------------------------------------------//
147	case H_CDLeft:
148	if(cddavCallback) cddavCallback(0,val);
149	return;
150	case H_CDRight:
151	if(cddavCallback) cddavCallback(1,val);
152	return;
153	//-------------------------------------------------//
154	case H_FMod1:
155	//FModOn(0,16,val);
156	return;
157	//-------------------------------------------------//
158	case H_FMod2:
159	//FModOn(16,24,val);
160	return;
161	//-------------------------------------------------//
162	case H_Noise1:
163	//NoiseOn(0,16,val);
164	return;
165	//-------------------------------------------------//
166	case H_Noise2:
167	//NoiseOn(16,24,val);
168	return;
169	//-------------------------------------------------//
170	case H_RVBon1:
171	//ReverbOn(0,16,val);
172	return;
173	//-------------------------------------------------//
174	case H_RVBon2:
175	//ReverbOn(16,24,val);
176	return;
177	//-------------------------------------------------//
178	case H_Reverb:
179	return;
180	}
181	}
182
183	////////////////////////////////////////////////////////////////////////\r
184
eedbe278	185	unsigned short CALLBACK SPUreadRegister(unsigned long reg, unsigned int cycles)
0d464c77	186	{
	187	unsigned long r=reg&0xfff;
	188
	189	if(r>=0x0c00 && r<0x0d80)
	190	{
	191	switch(r&0x0f)
	192	{
	193	case 12: // adsr vol
	194	{
	195	//int ch=(r>>4)-0xc0;
	196	static unsigned short adsr_dummy_vol=0;
	197	adsr_dummy_vol=!adsr_dummy_vol;
	198	return adsr_dummy_vol;
	199	}
	200
	201	case 14: // return curr loop adr
	202	{
	203	//int ch=(r>>4)-0xc0;
	204	return 0;
	205	}
	206	}
	207	}
	208
	209	switch(r)
	210	{
	211	case H_SPUctrl:
	212	return spuCtrl;
	213
	214	case H_SPUstat:
	215	return spuStat;
	216
	217	case H_SPUaddr:
	218	return (unsigned short)(spuAddr>>3);
	219
	220	case H_SPUdata:
	221	{
	222	unsigned short s=spuMem[spuAddr>>1];
	223	spuAddr+=2;
	224	if(spuAddr>0x7ffff) spuAddr=0;
	225	return s;
	226	}
	227
	228	case H_SPUirqAddr:
	229	return spuIrq;
	230	}
	231	return regArea[(r-0xc00)>>1];
	232	}
	233
	234	////////////////////////////////////////////////////////////////////////
	235
	236	unsigned short CALLBACK SPUreadDMA(void)
	237	{
	238	unsigned short s=spuMem[spuAddr>>1];
	239	spuAddr+=2;
	240	if(spuAddr>0x7ffff) spuAddr=0;
	241	return s;
	242	}
	243
	244	////////////////////////////////////////////////////////////////////////
	245
	246	void CALLBACK SPUwriteDMA(unsigned short val)
	247	{
	248	spuMem[spuAddr>>1] = val; // spu addr got by writeregister\r
	249	spuAddr+=2; // inc spu addr
250	if(spuAddr>0x7ffff) spuAddr=0; // wrap
251	}
252
253	////////////////////////////////////////////////////////////////////////
254
650adfd2	255	void CALLBACK SPUwriteDMAMem(unsigned short * pusPSXMem,int iSize,unsigned int cycles)
0d464c77	256	{
	257	int i;
	258	for(i=0;i<iSize;i++)
	259	{
	260	spuMem[spuAddr>>1] = *pusPSXMem++; // spu addr got by writeregister\r
	261	spuAddr+=2; // inc spu addr
	262	if(spuAddr>0x7ffff) spuAddr=0; // wrap
	263	}
	264	}
	265
	266	////////////////////////////////////////////////////////////////////////
	267
650adfd2	268	void CALLBACK SPUreadDMAMem(unsigned short * pusPSXMem,int iSize,unsigned int cycles)
0d464c77	269	{
	270	int i;
	271	for(i=0;i<iSize;i++)
	272	{
	273	*pusPSXMem++=spuMem[spuAddr>>1]; // spu addr got by writeregister
	274	spuAddr+=2; // inc spu addr
	275	if(spuAddr>0x7ffff) spuAddr=0; // wrap
	276	}
	277	}
	278
	279	////////////////////////////////////////////////////////////////////////
	280	// XA AUDIO
	281	////////////////////////////////////////////////////////////////////////
	282
eedbe278	283	void CALLBACK SPUplayADPCMchannel(xa_decode_t *xap, unsigned int cycles, int is_start)
0d464c77	284	{
	285	}
	286
38b8a211	287	void CALLBACK SPUsetCDvol(unsigned char ll, unsigned char lr,
	288	unsigned char rl, unsigned char rr, unsigned int cycle)
	289	{
	290	}
	291
0d464c77	292	////////////////////////////////////////////////////////////////////////
	293
	294	////////////////////////////////////////////////////////////////////////
	295	// INIT/EXIT STUFF
	296	////////////////////////////////////////////////////////////////////////
	297
	298	long CALLBACK SPUinit(void)
	299	{
	300	spuMemC=(unsigned char *)spuMem; // just small setup
	301	return 0;
	302	}
	303
	304	////////////////////////////////////////////////////////////////////////
	305
	306	int bSPUIsOpen=0;
	307
	308	long CALLBACK SPUopen(void)
	309	{
	310	if(bSPUIsOpen) return 0;
	311
	312	bSPUIsOpen=1;
	313
	314	//if(pConfigFile) ReadConfigFile(pConfigFile);
	315
	316	return PSE_SPU_ERR_SUCCESS;
	317	}
	318
	319	////////////////////////////////////////////////////////////////////////
	320
	321	void SPUsetConfigFile(char * pCfg)
	322	{
	323	pConfigFile=pCfg;
	324	}
	325
	326	////////////////////////////////////////////////////////////////////////
	327
	328	long CALLBACK SPUclose(void)
	329	{
	330	if(!bSPUIsOpen) return 0;
	331	bSPUIsOpen=0;
	332	return 0;
	333	}
	334
	335	////////////////////////////////////////////////////////////////////////
	336
	337	long CALLBACK SPUshutdown(void)
	338	{
	339	return 0;
	340	}
	341
	342	////////////////////////////////////////////////////////////////////////
	343	// MISC STUFF
	344	////////////////////////////////////////////////////////////////////////
	345
	346	long CALLBACK SPUtest(void)
	347	{
	348	return 0;
	349	}
	350
650adfd2	351	void SPUasync(unsigned int cycle, unsigned int flags)
0d464c77	352	{
	353	}
	354
eedbe278	355	int SPUplayCDDAchannel(short *pcm, int nbytes, unsigned int cycle, int is_start)
0d464c77	356	{
983a7cfd	357	return -1;
0d464c77	358	}
	359
	360	////////////////////////////////////////////////////////////////////////
	361	// this functions will be called once,
	362	// passes a callback that should be called on SPU-IRQ
	363
	364	void CALLBACK SPUregisterCallback(void (CALLBACK *callback)(void))
	365	{
	366	irqCallback = callback;
	367	}
	368
b64fb891	369	void CALLBACK SPUregisterCDDAVolume(void (CALLBACK *CDDAVcallback)(short, short))
0d464c77	370	{
	371	cddavCallback = CDDAVcallback;
	372	}
	373
	374	////////////////////////////////////////////////////////////////////////\r
	375
	376	char * CALLBACK PSEgetLibName(void)
	377	{
	378	return libraryName;
	379	}
	380
	381	////////////////////////////////////////////////////////////////////////
	382
	383	unsigned long CALLBACK PSEgetLibType(void)
	384	{
	385	return PSE_LT_SPU;
	386	}
	387
	388	////////////////////////////////////////////////////////////////////////\r
	389
	390	unsigned long CALLBACK PSEgetLibVersion(void)\r
	391	{
	392	return version<<16\|revision<<8\|build;
	393	}
	394
	395
	396	char * SPUgetLibInfos(void)
	397	{
	398	return libraryInfo;
	399	}
	400
	401	////////////////////////////////////////////////////////////////////////\r
	402
	403	typedef struct\r
	404	{
	405	char szSPUName[8];
	406	unsigned long ulFreezeVersion;
	407	unsigned long ulFreezeSize;
	408	unsigned char cSPUPort[0x200];
	409	unsigned char cSPURam[0x80000];
	410	xa_decode_t xaS;
	411	} SPUFreeze_t;
	412
	413	typedef struct
	414	{
	415	unsigned long Future[256];
	416
	417	} SPUNULLFreeze_t;
	418
	419	////////////////////////////////////////////////////////////////////////\r
	420
650adfd2	421	long CALLBACK SPUfreeze(unsigned long ulFreezeMode,SPUFreeze_t * pF,unsigned int cycles)
0d464c77	422	{
	423	int i;
	424
	425	if(!pF) return 0;
	426
	427	if(ulFreezeMode)
	428	{
	429	if(ulFreezeMode==1)
	430	memset(pF,0,sizeof(SPUFreeze_t)+sizeof(SPUNULLFreeze_t));
	431
	432	strcpy(pF->szSPUName,"PBNUL");
	433	pF->ulFreezeVersion=1;
	434	pF->ulFreezeSize=sizeof(SPUFreeze_t)+sizeof(SPUNULLFreeze_t);
	435
	436	if(ulFreezeMode==2) return 1;
	437
	438	memcpy(pF->cSPURam,spuMem,0x80000);
	439	memcpy(pF->cSPUPort,regArea,0x200);
	440	// dummy:
	441	memset(&pF->xaS,0,sizeof(xa_decode_t));
	442	return 1;
	443	}
	444
	445	if(ulFreezeMode!=0) return 0;
	446
	447	memcpy(spuMem,pF->cSPURam,0x80000);
	448	memcpy(regArea,pF->cSPUPort,0x200);
	449
	450	for(i=0;i<0x100;i++)
	451	{
	452	if(i!=H_SPUon1-0xc00 && i!=H_SPUon2-0xc00)
650adfd2	453	SPUwriteRegister(0x1f801c00+i*2,regArea[i],cycles);
0d464c77	454	}
650adfd2	455	SPUwriteRegister(H_SPUon1,regArea[(H_SPUon1-0xc00)/2],cycles);
650adfd2	456	SPUwriteRegister(H_SPUon2,regArea[(H_SPUon2-0xc00)/2],cycles);
0d464c77	457
	458	return 1;
	459	}
	460
	461
	462	////////////////////////////////////////////////////////////////////////
	463	////////////////////////////////////////////////////////////////////////
	464	////////////////////////////////////////////////////////////////////////
	465	// UNUSED WINDOWS FUNCS... YOU SHOULDN'T USE THEM IN LINUX
	466
	467	long CALLBACK SPUconfigure(void)
	468	{
	469	return 0;
	470	}
	471
	472	void CALLBACK SPUabout(void)
	473	{
	474	}
	475
	476	////////////////////////////////////////////////////////////////////////
	477	////////////////////////////////////////////////////////////////////////
	478	////////////////////////////////////////////////////////////////////////
	479	// OLD PSEMU 1 FUNCS... YOU SHOULDN'T USE THEM
	480
	481	unsigned short CALLBACK SPUgetOne(unsigned long val)
	482	{
	483	if(spuAddr!=0xffffffff)
	484	{
	485	return SPUreadDMA();
	486	}
	487	if(val>=5121024) val=5121024-1;
	488	return spuMem[val>>1];
	489	}
	490
	491	void CALLBACK SPUputOne(unsigned long val,unsigned short data)
	492	{
	493	if(spuAddr!=0xffffffff)
	494	{
	495	SPUwriteDMA(data);
	496	return;
	497	}
	498	if(val>=5121024) val=5121024-1;
	499	spuMem[val>>1] = data;
	500	}
	501
	502	void CALLBACK SPUplaySample(unsigned char ch)
	503	{
	504	}
	505
	506	void CALLBACK SPUsetAddr(unsigned char ch, unsigned short waddr)
	507	{
	508	//s_chan[ch].pStart=spuMemC+((unsigned long) waddr<<3);
	509	}
	510
	511	void CALLBACK SPUsetPitch(unsigned char ch, unsigned short pitch)
	512	{
	513	//SetPitch(ch,pitch);
	514	}
	515
	516	void CALLBACK SPUsetVolumeL(unsigned char ch, short vol)
	517	{
	518	//SetVolumeL(ch,vol);
	519	}
	520
521	void CALLBACK SPUsetVolumeR(unsigned char ch, short vol)
522	{
523	//SetVolumeR(ch,vol);
524	}
525
526	void CALLBACK SPUstartChannels1(unsigned short channels)
527	{
528	//SoundOn(0,16,channels);
529	}
530
531	void CALLBACK SPUstartChannels2(unsigned short channels)
532	{
533	//SoundOn(16,24,channels);
534	}
535
536	void CALLBACK SPUstopChannels1(unsigned short channels)
537	{
538	//SoundOff(0,16,channels);
539	}
540
541	void CALLBACK SPUstopChannels2(unsigned short channels)
542	{
543	//SoundOff(16,24,channels);
544	}
eedbe278 PC	545
	546	void CALLBACK SPUregisterScheduleCb(void (CALLBACK *callback)(unsigned int))
	547	{
	548	}