1 /////////////////////////////////////////////////////////
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
9 /////////////////////////////////////////////////////////
11 // 0. Get type/name/version
16 // 5. Dma/register/xa calls...
19 /////////////////////////////////////////////////////////
26 // some ms windows compatibility define
30 ////////////////////////////////////////////////////////////////////////
32 ////////////////////////////////////////////////////////////////////////
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";
40 ////////////////////////////////////////////////////////////////////////
42 unsigned short regArea[10000]; // psx buffer
43 unsigned short spuMem[256*1024];
44 unsigned char * spuMemC;
45 unsigned char * pSpuIrq=0;
47 unsigned short spuCtrl, spuStat, spuIrq=0; // some vars to store psx reg infos
48 unsigned long spuAddr=0xffffffff; // address into spu mem
51 ////////////////////////////////////////////////////////////////////////
53 ////////////////////////////////////////////////////////////////////////
55 void (CALLBACK *irqCallback)(void)=0; // func of main emu, called on spu irq
56 void (CALLBACK *cddavCallback)(short, short)=0;
58 ////////////////////////////////////////////////////////////////////////
60 ////////////////////////////////////////////////////////////////////////
62 void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val, unsigned int cycles)
64 unsigned long r=reg&0xfff;
65 regArea[(r-0xc00)>>1] = val;
67 if(r>=0x0c00 && r<0x0d80)
72 //------------------------------------------------// l volume
76 //------------------------------------------------// r volume
80 //------------------------------------------------// pitch
84 //------------------------------------------------// start
86 //s_chan[ch].pStart=spuMemC+((unsigned long) val<<3);
88 //------------------------------------------------// adsr level
91 //------------------------------------------------// adsr rate
94 //------------------------------------------------// adsr volume
97 //------------------------------------------------// loop adr
100 //------------------------------------------------//
107 //-------------------------------------------------//
109 spuAddr = (unsigned long) val<<3;
111 //-------------------------------------------------//
113 spuMem[spuAddr>>1] = val;
115 if(spuAddr>0x7ffff) spuAddr=0;
117 //-------------------------------------------------//
121 //-------------------------------------------------//
123 spuStat=val & 0xf800;
125 //-------------------------------------------------//
128 pSpuIrq=spuMemC+((unsigned long) val<<3);
130 //-------------------------------------------------//
134 //-------------------------------------------------//
136 //SoundOn(16,24,val);
138 //-------------------------------------------------//
140 //SoundOff(0,16,val);
142 //-------------------------------------------------//
144 //SoundOff(16,24,val);
146 //-------------------------------------------------//
148 if(cddavCallback) cddavCallback(0,val);
151 if(cddavCallback) cddavCallback(1,val);
153 //-------------------------------------------------//
157 //-------------------------------------------------//
161 //-------------------------------------------------//
165 //-------------------------------------------------//
167 //NoiseOn(16,24,val);
169 //-------------------------------------------------//
171 //ReverbOn(0,16,val);
173 //-------------------------------------------------//
175 //ReverbOn(16,24,val);
177 //-------------------------------------------------//
183 ////////////////////////////////////////////////////////////////////////
\r
185 unsigned short CALLBACK SPUreadRegister(unsigned long reg, unsigned int cycles)
187 unsigned long r=reg&0xfff;
189 if(r>=0x0c00 && r<0x0d80)
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;
201 case 14: // return curr loop adr
203 //int ch=(r>>4)-0xc0;
218 return (unsigned short)(spuAddr>>3);
222 unsigned short s=spuMem[spuAddr>>1];
224 if(spuAddr>0x7ffff) spuAddr=0;
231 return regArea[(r-0xc00)>>1];
234 ////////////////////////////////////////////////////////////////////////
236 unsigned short CALLBACK SPUreadDMA(void)
238 unsigned short s=spuMem[spuAddr>>1];
240 if(spuAddr>0x7ffff) spuAddr=0;
244 ////////////////////////////////////////////////////////////////////////
246 void CALLBACK SPUwriteDMA(unsigned short val)
248 spuMem[spuAddr>>1] = val; // spu addr got by writeregister
\r
249 spuAddr+=2; // inc spu addr
250 if(spuAddr>0x7ffff) spuAddr=0; // wrap
253 ////////////////////////////////////////////////////////////////////////
255 void CALLBACK SPUwriteDMAMem(unsigned short * pusPSXMem,int iSize,unsigned int cycles)
260 spuMem[spuAddr>>1] = *pusPSXMem++; // spu addr got by writeregister
\r
261 spuAddr+=2; // inc spu addr
262 if(spuAddr>0x7ffff) spuAddr=0; // wrap
266 ////////////////////////////////////////////////////////////////////////
268 void CALLBACK SPUreadDMAMem(unsigned short * pusPSXMem,int iSize,unsigned int cycles)
273 *pusPSXMem++=spuMem[spuAddr>>1]; // spu addr got by writeregister
274 spuAddr+=2; // inc spu addr
275 if(spuAddr>0x7ffff) spuAddr=0; // wrap
279 ////////////////////////////////////////////////////////////////////////
281 ////////////////////////////////////////////////////////////////////////
283 void CALLBACK SPUplayADPCMchannel(xa_decode_t *xap, unsigned int cycles, int is_start)
287 void CALLBACK SPUsetCDvol(unsigned char ll, unsigned char lr,
288 unsigned char rl, unsigned char rr, unsigned int cycle)
292 ////////////////////////////////////////////////////////////////////////
294 ////////////////////////////////////////////////////////////////////////
296 ////////////////////////////////////////////////////////////////////////
298 long CALLBACK SPUinit(void)
300 spuMemC=(unsigned char *)spuMem; // just small setup
304 ////////////////////////////////////////////////////////////////////////
308 long CALLBACK SPUopen(void)
310 if(bSPUIsOpen) return 0;
314 //if(pConfigFile) ReadConfigFile(pConfigFile);
316 return PSE_SPU_ERR_SUCCESS;
319 ////////////////////////////////////////////////////////////////////////
321 void SPUsetConfigFile(char * pCfg)
326 ////////////////////////////////////////////////////////////////////////
328 long CALLBACK SPUclose(void)
330 if(!bSPUIsOpen) return 0;
335 ////////////////////////////////////////////////////////////////////////
337 long CALLBACK SPUshutdown(void)
342 ////////////////////////////////////////////////////////////////////////
344 ////////////////////////////////////////////////////////////////////////
346 long CALLBACK SPUtest(void)
351 void SPUasync(unsigned int cycle, unsigned int flags)
355 int SPUplayCDDAchannel(short *pcm, int nbytes, unsigned int cycle, int is_start)
360 ////////////////////////////////////////////////////////////////////////
361 // this functions will be called once,
362 // passes a callback that should be called on SPU-IRQ
364 void CALLBACK SPUregisterCallback(void (CALLBACK *callback)(void))
366 irqCallback = callback;
369 void CALLBACK SPUregisterCDDAVolume(void (CALLBACK *CDDAVcallback)(short, short))
371 cddavCallback = CDDAVcallback;
374 ////////////////////////////////////////////////////////////////////////
\r
376 char * CALLBACK PSEgetLibName(void)
381 ////////////////////////////////////////////////////////////////////////
383 unsigned long CALLBACK PSEgetLibType(void)
388 ////////////////////////////////////////////////////////////////////////
\r
390 unsigned long CALLBACK PSEgetLibVersion(void)
\r
392 return version<<16|revision<<8|build;
396 char * SPUgetLibInfos(void)
401 ////////////////////////////////////////////////////////////////////////
\r
406 unsigned long ulFreezeVersion;
407 unsigned long ulFreezeSize;
408 unsigned char cSPUPort[0x200];
409 unsigned char cSPURam[0x80000];
415 unsigned long Future[256];
419 ////////////////////////////////////////////////////////////////////////
\r
421 long CALLBACK SPUfreeze(unsigned long ulFreezeMode,SPUFreeze_t * pF,unsigned int cycles)
430 memset(pF,0,sizeof(SPUFreeze_t)+sizeof(SPUNULLFreeze_t));
432 strcpy(pF->szSPUName,"PBNUL");
433 pF->ulFreezeVersion=1;
434 pF->ulFreezeSize=sizeof(SPUFreeze_t)+sizeof(SPUNULLFreeze_t);
436 if(ulFreezeMode==2) return 1;
438 memcpy(pF->cSPURam,spuMem,0x80000);
439 memcpy(pF->cSPUPort,regArea,0x200);
441 memset(&pF->xaS,0,sizeof(xa_decode_t));
445 if(ulFreezeMode!=0) return 0;
447 memcpy(spuMem,pF->cSPURam,0x80000);
448 memcpy(regArea,pF->cSPUPort,0x200);
452 if(i!=H_SPUon1-0xc00 && i!=H_SPUon2-0xc00)
453 SPUwriteRegister(0x1f801c00+i*2,regArea[i],cycles);
455 SPUwriteRegister(H_SPUon1,regArea[(H_SPUon1-0xc00)/2],cycles);
456 SPUwriteRegister(H_SPUon2,regArea[(H_SPUon2-0xc00)/2],cycles);
462 ////////////////////////////////////////////////////////////////////////
463 ////////////////////////////////////////////////////////////////////////
464 ////////////////////////////////////////////////////////////////////////
465 // UNUSED WINDOWS FUNCS... YOU SHOULDN'T USE THEM IN LINUX
467 long CALLBACK SPUconfigure(void)
472 void CALLBACK SPUabout(void)
476 ////////////////////////////////////////////////////////////////////////
477 ////////////////////////////////////////////////////////////////////////
478 ////////////////////////////////////////////////////////////////////////
479 // OLD PSEMU 1 FUNCS... YOU SHOULDN'T USE THEM
481 unsigned short CALLBACK SPUgetOne(unsigned long val)
483 if(spuAddr!=0xffffffff)
487 if(val>=512*1024) val=512*1024-1;
488 return spuMem[val>>1];
491 void CALLBACK SPUputOne(unsigned long val,unsigned short data)
493 if(spuAddr!=0xffffffff)
498 if(val>=512*1024) val=512*1024-1;
499 spuMem[val>>1] = data;
502 void CALLBACK SPUplaySample(unsigned char ch)
506 void CALLBACK SPUsetAddr(unsigned char ch, unsigned short waddr)
508 //s_chan[ch].pStart=spuMemC+((unsigned long) waddr<<3);
511 void CALLBACK SPUsetPitch(unsigned char ch, unsigned short pitch)
513 //SetPitch(ch,pitch);
516 void CALLBACK SPUsetVolumeL(unsigned char ch, short vol)
518 //SetVolumeL(ch,vol);
521 void CALLBACK SPUsetVolumeR(unsigned char ch, short vol)
523 //SetVolumeR(ch,vol);
526 void CALLBACK SPUstartChannels1(unsigned short channels)
528 //SoundOn(0,16,channels);
531 void CALLBACK SPUstartChannels2(unsigned short channels)
533 //SoundOn(16,24,channels);
536 void CALLBACK SPUstopChannels1(unsigned short channels)
538 //SoundOff(0,16,channels);
541 void CALLBACK SPUstopChannels2(unsigned short channels)
543 //SoundOff(16,24,channels);
546 void CALLBACK SPUregisterScheduleCb(void (CALLBACK *callback)(unsigned int))