extern long SPUshutdown(void);
extern long SPUclose(void);
extern void SPUplaySample(unsigned char);
-extern void SPUwriteRegister(unsigned long, unsigned short);
+extern void SPUwriteRegister(unsigned long, unsigned short, unsigned int);
extern unsigned short SPUreadRegister(unsigned long);
extern void SPUwriteDMA(unsigned short);
extern unsigned short SPUreadDMA(void);
-extern void SPUwriteDMAMem(unsigned short *, int);
-extern void SPUreadDMAMem(unsigned short *, int);
+extern void SPUwriteDMAMem(unsigned short *, int, unsigned int);
+extern void SPUreadDMAMem(unsigned short *, int, unsigned int);
extern void SPUplayADPCMchannel(void *);
extern void SPUregisterCallback(void (*cb)(void));
extern void SPUregisterScheduleCb(void (*cb)(unsigned int));
extern long SPUconfigure(void);
extern long SPUtest(void);
extern void SPUabout(void);
-extern long SPUfreeze(unsigned int, void *);
-extern void SPUasync(unsigned int);
+extern long SPUfreeze(unsigned int, void *, unsigned int);
+extern void SPUasync(unsigned int, unsigned int);
extern int SPUplayCDDAchannel(short *, int);
/* PAD */
pc_hook_func_ret(long, GPU_dmaChain, (uint32_t *a0, int32_t a1), (a0, a1), PCNT_GPU)
pc_hook_func (GPU_updateLace, (void), (), PCNT_GPU)
-pc_hook_func (SPU_writeRegister, (unsigned long a0, unsigned short a1), (a0, a1), PCNT_SPU)
+pc_hook_func (SPU_writeRegister, (unsigned long a0, unsigned short a1, uint32_t a2), (a0, a1, a2), PCNT_SPU)
pc_hook_func_ret(unsigned short,SPU_readRegister, (unsigned long a0), (a0), PCNT_SPU)
pc_hook_func (SPU_writeDMA, (unsigned short a0), (a0), PCNT_SPU)
pc_hook_func_ret(unsigned short,SPU_readDMA, (void), (), PCNT_SPU)
-pc_hook_func (SPU_writeDMAMem, (unsigned short *a0, int a1), (a0, a1), PCNT_SPU)
-pc_hook_func (SPU_readDMAMem, (unsigned short *a0, int a1), (a0, a1), PCNT_SPU)
+pc_hook_func (SPU_writeDMAMem, (unsigned short *a0, int a1, uint32_t a2), (a0, a1, a2), PCNT_SPU)
+pc_hook_func (SPU_readDMAMem, (unsigned short *a0, int a1, uint32_t a2), (a0, a1, a2), PCNT_SPU)
pc_hook_func (SPU_playADPCMchannel, (void *a0), (a0), PCNT_SPU)
-pc_hook_func (SPU_async, (unsigned int a0), (a0), PCNT_SPU)
+pc_hook_func (SPU_async, (uint32_t a0, uint32_t a1), (a0, a1), PCNT_SPU)
pc_hook_func_ret(int, SPU_playCDDAchannel, (short *a0, int a1), (a0, a1), PCNT_SPU)
#define hook_it(name) { \
// spu
spufP = (SPUFreeze_t *) malloc(16);
- SPU_freeze(2, spufP);
+ SPU_freeze(2, spufP, psxRegs.cycle);
Size = spufP->Size; SaveFuncs.write(f, &Size, 4);
free(spufP);
spufP = (SPUFreeze_t *) malloc(Size);
- SPU_freeze(1, spufP);
+ SPU_freeze(1, spufP, psxRegs.cycle);
SaveFuncs.write(f, spufP, Size);
free(spufP);
SaveFuncs.read(f, &Size, 4);
spufP = (SPUFreeze_t *)malloc(Size);
SaveFuncs.read(f, spufP, Size);
- SPU_freeze(0, spufP);
+ SPU_freeze(0, spufP, psxRegs.cycle);
free(spufP);
sioFreeze(f, 0);
static void io_spu_write16(u32 value)
{
// meh
- SPU_writeRegister(address, value);
+ SPU_writeRegister(address, value, psxRegs.cycle);
}
static void io_spu_write32(u32 value)
SPUwriteRegister wfunc = SPU_writeRegister;
u32 a = address;
- wfunc(a, value & 0xffff);
- wfunc(a + 2, value >> 16);
+ wfunc(a, value & 0xffff, psxRegs.cycle);
+ wfunc(a + 2, value >> 16, psxRegs.cycle);
}
static u32 io_gpu_read_status(void)
typedef long (CALLBACK* SPUshutdown)(void); \r
typedef long (CALLBACK* SPUclose)(void); \r
typedef void (CALLBACK* SPUplaySample)(unsigned char); \r
-typedef void (CALLBACK* SPUwriteRegister)(unsigned long, unsigned short);\r
+typedef void (CALLBACK* SPUwriteRegister)(unsigned long, unsigned short, unsigned int);\r
typedef unsigned short (CALLBACK* SPUreadRegister)(unsigned long);\r
typedef void (CALLBACK* SPUwriteDMA)(unsigned short);\r
typedef unsigned short (CALLBACK* SPUreadDMA)(void);\r
-typedef void (CALLBACK* SPUwriteDMAMem)(unsigned short *, int);\r
-typedef void (CALLBACK* SPUreadDMAMem)(unsigned short *, int);\r
+typedef void (CALLBACK* SPUwriteDMAMem)(unsigned short *, int, unsigned int);\r
+typedef void (CALLBACK* SPUreadDMAMem)(unsigned short *, int, unsigned int);\r
typedef void (CALLBACK* SPUplayADPCMchannel)(xa_decode_t *);\r
typedef void (CALLBACK* SPUregisterCallback)(void (CALLBACK *callback)(void));\r
typedef void (CALLBACK* SPUregisterScheduleCb)(void (CALLBACK *callback)(unsigned int cycles_after));\r
xa_decode_t xa;\r
unsigned char *SPUInfo;\r
} SPUFreeze_t;\r
-typedef long (CALLBACK* SPUfreeze)(uint32_t, SPUFreeze_t *);\r
-typedef void (CALLBACK* SPUasync)(uint32_t);\r
+typedef long (CALLBACK* SPUfreeze)(uint32_t, SPUFreeze_t *, uint32_t);\r
+typedef void (CALLBACK* SPUasync)(uint32_t, uint32_t);\r
typedef int (CALLBACK* SPUplayCDDAchannel)(short *, int);\r
\r
// SPU function pointers\r
if( SPU_async )
{
- SPU_async( SpuUpdInterval[Config.PsxType] * rcnts[3].target );
+ SPU_async( cycle, 1 );
}
}
#endif
break;
}
- SPU_writeDMAMem(ptr, (bcr >> 16) * (bcr & 0xffff) * 2);
+ SPU_writeDMAMem(ptr, (bcr >> 16) * (bcr & 0xffff) * 2, psxRegs.cycle);
SPUDMA_INT((bcr >> 16) * (bcr & 0xffff) / 2);
return;
break;
}
size = (bcr >> 16) * (bcr & 0xffff) * 2;
- SPU_readDMAMem(ptr, size);
+ SPU_readDMAMem(ptr, size, psxRegs.cycle);
psxCpu->Clear(madr, size);
break;
default:
if (add>=0x1f801c00 && add<0x1f801e00) {
- SPU_writeRegister(add, value);
+ SPU_writeRegister(add, value, psxRegs.cycle);
return;
}
default:
// Dukes of Hazard 2 - car engine noise
if (add>=0x1f801c00 && add<0x1f801e00) {
- SPU_writeRegister(add, value&0xffff);
- SPU_writeRegister(add + 2, value>>16);
+ SPU_writeRegister(add, value&0xffff, psxRegs.cycle);
+ SPU_writeRegister(add + 2, value>>16, psxRegs.cycle);
return;
}
}
void spuUpdate() {
- SPU_async(psxRegs.cycle);
+ SPU_async(psxRegs.cycle, 0);
}
***************************************************************************/
#include <stdio.h>
+#include <string.h>
#define ALSA_PCM_NEW_HW_PARAMS_API
#define ALSA_PCM_NEW_SW_PARAMS_API
#include <alsa/asoundlib.h>
// FEED SOUND DATA
static void alsa_feed(void *pSound, int lBytes)
{
+ char sbuf[4096];
+
if (handle == NULL) return;
if (snd_pcm_state(handle) == SND_PCM_STATE_XRUN)
- snd_pcm_prepare(handle);
+ {
+ memset(sbuf, 0, sizeof(sbuf));
+ snd_pcm_prepare(handle);
+ snd_pcm_writei(handle, sbuf, sizeof(sbuf) / 4);
+ snd_pcm_writei(handle, sbuf, sizeof(sbuf) / 4);
+ }
snd_pcm_writei(handle,pSound, lBytes / 4);
}
// READ DMA (many values)\r
////////////////////////////////////////////////////////////////////////\r
\r
-void CALLBACK SPUreadDMAMem(unsigned short * pusPSXMem,int iSize)\r
+void CALLBACK SPUreadDMAMem(unsigned short *pusPSXMem, int iSize,\r
+ unsigned int cycles)\r
{\r
int i;\r
\r
+ do_samples_if_needed(cycles);\r
+\r
for(i=0;i<iSize;i++)\r
{\r
*pusPSXMem++=spuMem[spuAddr>>1]; // spu addr got by writeregister\r
// WRITE DMA (many values)\r
////////////////////////////////////////////////////////////////////////\r
\r
-void CALLBACK SPUwriteDMAMem(unsigned short * pusPSXMem,int iSize)\r
+void CALLBACK SPUwriteDMAMem(unsigned short *pusPSXMem, int iSize,\r
+ unsigned int cycles)\r
{\r
int i;\r
\r
- had_dma = 1;\r
+ do_samples_if_needed(cycles);\r
\r
if(spuAddr + iSize*2 < 0x80000)\r
{\r
// num of channels\r
#define MAXCHAN 24\r
\r
-// ~ FRAG_MSECS ms of data\r
// note: must be even due to the way reverb works now\r
-#define FRAG_MSECS 2\r
-#define NSSIZE ((44100 * FRAG_MSECS / 1000 + 1) & ~1)\r
+#define NSSIZE ((44100 / 50 + 16) & ~1)\r
\r
///////////////////////////////////////////////////////////\r
// struct defines\r
int iSBPos; // mixing stuff\r
int spos;\r
int sinc;\r
+ int sinc_inv;\r
\r
unsigned char * pCurr; // current pos in sound mem\r
unsigned char * pLoop; // loop ptr in sound mem\r
extern int iUseInterpolation;\r
// MISC\r
\r
-extern int had_dma;\r
extern int decode_pos;\r
\r
extern SPUCHAN s_chan[];\r
\r
extern int SSumR[];\r
extern int SSumL[];\r
-extern int iCycle;\r
extern short * pS;\r
\r
extern void (CALLBACK *cddavCallback)(unsigned short,unsigned short);\r
\r
+extern unsigned int cycles_played;\r
+\r
+void do_samples(unsigned int cycles_to);\r
+void schedule_next_irq(void);\r
+\r
+#define do_samples_if_needed(c) \\r
+ do { \\r
+ if ((int)((c) - cycles_played) >= 16 * 768) \\r
+ do_samples(c); \\r
+ } while (0)\r
+\r
#endif\r
\r
///////////////////////////////////////////////////////////\r
////////////////////////////////////////////////////////////////////////\r
\r
void LoadStateV5(SPUFreeze_t * pF); // newest version\r
-void LoadStateUnknown(SPUFreeze_t * pF); // unknown format\r
-\r
-extern int lastch;\r
+void LoadStateUnknown(SPUFreeze_t * pF, uint32_t cycles); // unknown format\r
\r
// we want to retain compatibility between versions,\r
// so use original channel struct\r
memset(d, 0, sizeof(*d));\r
if (s->bNew) dwNewChannel |= 1<<ch;\r
d->iSBPos = s->iSBPos;\r
+ if ((uint32_t)d->iSBPos >= 28) d->iSBPos = 27;\r
d->spos = s->spos;\r
d->sinc = s->sinc;\r
+ d->sinc_inv = 0;\r
memcpy(d->SB, s->SB, sizeof(d->SB));\r
d->pCurr = (void *)((long)s->iCurr & 0x7fff0);\r
d->pLoop = (void *)((long)s->iLoop & 0x7fff0);\r
else d->ADSRX.EnvelopeVol = 0;\r
}\r
\r
+// force load from regArea to variables\r
+static void load_register(unsigned long reg, unsigned int cycles)\r
+{\r
+ unsigned short *r = ®Area[((reg & 0xfff) - 0xc00) >> 1];\r
+ *r ^= 1;\r
+ SPUwriteRegister(reg, *r ^ 1, cycles);\r
+}\r
+\r
////////////////////////////////////////////////////////////////////////\r
// SPUFREEZE: called by main emu on savestate load/save\r
////////////////////////////////////////////////////////////////////////\r
\r
-long CALLBACK SPUfreeze(uint32_t ulFreezeMode,SPUFreeze_t * pF)\r
+long CALLBACK SPUfreeze(uint32_t ulFreezeMode, SPUFreeze_t * pF,\r
+ uint32_t cycles)\r
{\r
int i;SPUOSSFreeze_t * pFO;\r
\r
\r
if(ulFreezeMode==2) return 1; // info mode? ok, bye\r
// save mode:\r
+ do_samples(cycles);\r
+\r
memcpy(pF->cSPURam,spuMem,0x80000); // copy common infos\r
memcpy(pF->cSPUPort,regArea,0x200);\r
\r
\r
if(!strcmp(pF->szSPUName,"PBOSS") && pF->ulFreezeVersion==5)\r
LoadStateV5(pF);\r
- else LoadStateUnknown(pF);\r
-\r
- lastch = -1;\r
+ else LoadStateUnknown(pF, cycles);\r
\r
// repair some globals\r
for(i=0;i<=62;i+=2)\r
- SPUwriteRegister(H_Reverb+i,regArea[(H_Reverb+i-0xc00)>>1]);\r
- SPUwriteRegister(H_SPUReverbAddr,regArea[(H_SPUReverbAddr-0xc00)>>1]);\r
- SPUwriteRegister(H_SPUrvolL,regArea[(H_SPUrvolL-0xc00)>>1]);\r
- SPUwriteRegister(H_SPUrvolR,regArea[(H_SPUrvolR-0xc00)>>1]);\r
+ load_register(H_Reverb+i, cycles);\r
+ load_register(H_SPUReverbAddr, cycles);\r
+ load_register(H_SPUrvolL, cycles);\r
+ load_register(H_SPUrvolR, cycles);\r
\r
- SPUwriteRegister(H_SPUctrl,(unsigned short)(regArea[(H_SPUctrl-0xc00)>>1]|0x4000));\r
- SPUwriteRegister(H_SPUstat,regArea[(H_SPUstat-0xc00)>>1]);\r
- SPUwriteRegister(H_CDLeft,regArea[(H_CDLeft-0xc00)>>1]);\r
- SPUwriteRegister(H_CDRight,regArea[(H_CDRight-0xc00)>>1]);\r
+ load_register(H_SPUctrl, cycles);\r
+ load_register(H_SPUstat, cycles);\r
+ load_register(H_CDLeft, cycles);\r
+ load_register(H_CDRight, cycles);\r
\r
// fix to prevent new interpolations from crashing\r
for(i=0;i<MAXCHAN;i++) s_chan[i].SB[28]=0;\r
\r
ClearWorkingState();\r
+ cycles_played = cycles;\r
\r
return 1;\r
}\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
-void LoadStateUnknown(SPUFreeze_t * pF)\r
+void LoadStateUnknown(SPUFreeze_t * pF, uint32_t cycles)\r
{\r
int i;\r
\r
\r
for(i=0;i<0xc0;i++)\r
{\r
- SPUwriteRegister(0x1f801c00+i*2,regArea[i]);\r
+ load_register(0x1f801c00 + i*2, cycles);\r
}\r
}\r
\r
***************************************************************************/
#include <stdio.h>
+#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
static void oss_feed(void *buf, int bytes)
{
+ audio_buf_info info;
+ char sbuf[4096];
+
if(oss_audio_fd == -1) return;
+ if(ioctl(oss_audio_fd,SNDCTL_DSP_GETOSPACE,&info)==0)
+ {
+ if(info.fragments==info.fragstotal)
+ {
+ memset(sbuf, 0, sizeof(sbuf));
+ write(oss_audio_fd, sbuf, sizeof(sbuf));
+ write(oss_audio_fd, sbuf, sizeof(sbuf));
+ }
+ }
+
write(oss_audio_fd, buf, bytes);
}
// WRITE REGISTERS: called by main emu\r
////////////////////////////////////////////////////////////////////////\r
\r
-void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)\r
+static const uint32_t ignore_dupe[8] = {\r
+ // ch 0-15 c40 c80 cc0\r
+ 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f,\r
+ // ch 16-24 d40 control reverb\r
+ 0x7f7f7f7f, 0x7f7f7f7f, 0xff05ff0f, 0xffffffff\r
+};\r
+\r
+void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val,\r
+ unsigned int cycles)\r
{\r
- const unsigned long r=reg&0xfff;\r
- regArea[(r-0xc00)>>1] = val;\r
+ int r = reg & 0xfff;\r
+ int rofs = (r - 0xc00) >> 1;\r
+ int changed = regArea[rofs] != val;\r
+ regArea[rofs] = val;\r
+\r
+ if (!changed && (ignore_dupe[rofs >> 5] & (1 << (rofs & 0x1f))))\r
+ return;\r
+ // zero keyon/keyoff?\r
+ if (val == 0 && (r & 0xff8) == 0xd88)\r
+ return;\r
+\r
+ do_samples_if_needed(cycles);\r
\r
if(r>=0x0c00 && r<0x0d80) // some channel info?\r
{\r
//------------------------------------------------// pitch\r
case 4: \r
SetPitch(ch,val);\r
- break;\r
+ goto upd_irq;\r
//------------------------------------------------// start\r
case 6: \r
// taken from regArea later\r
//------------------------------------------------//\r
case 14: // loop?\r
s_chan[ch].pLoop=spuMemC+((val&~1)<<3);\r
- break;\r
+ goto upd_irq;\r
//------------------------------------------------//\r
}\r
return;\r
break;\r
//-------------------------------------------------//\r
case H_SPUctrl:\r
- if(!(spuCtrl & CTRL_IRQ))\r
+ if (!(spuCtrl & CTRL_IRQ)) {\r
spuStat&=~STAT_IRQ;\r
+ if (val & CTRL_IRQ)\r
+ schedule_next_irq();\r
+ }\r
spuCtrl=val;\r
break;\r
//-------------------------------------------------//\r
rvb.CurrAddr+=decode_pos/2;\r
}\r
}\r
- rvb.dirty = 1;\r
- break;\r
+ goto rvbd;\r
//-------------------------------------------------//\r
case H_SPUirqAddr:\r
spuIrq = val;\r
pSpuIrq=spuMemC+(((unsigned long) val<<3)&~0xf);\r
- break;\r
+ goto upd_irq;\r
//-------------------------------------------------//\r
case H_SPUrvolL:\r
rvb.VolLeft=val;\r
ReverbOn(16,24,val);\r
break;\r
//-------------------------------------------------//\r
- case H_Reverb+0 : rvb.FB_SRC_A=val*4; break;\r
- case H_Reverb+2 : rvb.FB_SRC_B=val*4; break;\r
- case H_Reverb+4 : rvb.IIR_ALPHA=(short)val; break;\r
- case H_Reverb+6 : rvb.ACC_COEF_A=(short)val; break;\r
- case H_Reverb+8 : rvb.ACC_COEF_B=(short)val; break;\r
- case H_Reverb+10 : rvb.ACC_COEF_C=(short)val; break;\r
- case H_Reverb+12 : rvb.ACC_COEF_D=(short)val; break;\r
- case H_Reverb+14 : rvb.IIR_COEF=(short)val; break;\r
- case H_Reverb+16 : rvb.FB_ALPHA=(short)val; break;\r
- case H_Reverb+18 : rvb.FB_X=(short)val; break;\r
- case H_Reverb+20 : rvb.IIR_DEST_A0=val*4; break;\r
- case H_Reverb+22 : rvb.IIR_DEST_A1=val*4; break;\r
- case H_Reverb+24 : rvb.ACC_SRC_A0=val*4; break;\r
- case H_Reverb+26 : rvb.ACC_SRC_A1=val*4; break;\r
- case H_Reverb+28 : rvb.ACC_SRC_B0=val*4; break;\r
- case H_Reverb+30 : rvb.ACC_SRC_B1=val*4; break;\r
- case H_Reverb+32 : rvb.IIR_SRC_A0=val*4; break;\r
- case H_Reverb+34 : rvb.IIR_SRC_A1=val*4; break;\r
- case H_Reverb+36 : rvb.IIR_DEST_B0=val*4; break;\r
- case H_Reverb+38 : rvb.IIR_DEST_B1=val*4; break;\r
- case H_Reverb+40 : rvb.ACC_SRC_C0=val*4; break;\r
- case H_Reverb+42 : rvb.ACC_SRC_C1=val*4; break;\r
- case H_Reverb+44 : rvb.ACC_SRC_D0=val*4; break;\r
- case H_Reverb+46 : rvb.ACC_SRC_D1=val*4; break;\r
- case H_Reverb+48 : rvb.IIR_SRC_B1=val*4; break;\r
- case H_Reverb+50 : rvb.IIR_SRC_B0=val*4; break;\r
- case H_Reverb+52 : rvb.MIX_DEST_A0=val*4; break;\r
- case H_Reverb+54 : rvb.MIX_DEST_A1=val*4; break;\r
- case H_Reverb+56 : rvb.MIX_DEST_B0=val*4; break;\r
- case H_Reverb+58 : rvb.MIX_DEST_B1=val*4; break;\r
- case H_Reverb+60 : rvb.IN_COEF_L=(short)val; break;\r
- case H_Reverb+62 : rvb.IN_COEF_R=(short)val; break;\r
+ case H_Reverb+0 : rvb.FB_SRC_A=val*4; goto rvbd;\r
+ case H_Reverb+2 : rvb.FB_SRC_B=val*4; goto rvbd;\r
+ case H_Reverb+4 : rvb.IIR_ALPHA=(short)val; goto rvbd;\r
+ case H_Reverb+6 : rvb.ACC_COEF_A=(short)val; goto rvbd;\r
+ case H_Reverb+8 : rvb.ACC_COEF_B=(short)val; goto rvbd;\r
+ case H_Reverb+10 : rvb.ACC_COEF_C=(short)val; goto rvbd;\r
+ case H_Reverb+12 : rvb.ACC_COEF_D=(short)val; goto rvbd;\r
+ case H_Reverb+14 : rvb.IIR_COEF=(short)val; goto rvbd;\r
+ case H_Reverb+16 : rvb.FB_ALPHA=(short)val; goto rvbd;\r
+ case H_Reverb+18 : rvb.FB_X=(short)val; goto rvbd;\r
+ case H_Reverb+20 : rvb.IIR_DEST_A0=val*4; goto rvbd;\r
+ case H_Reverb+22 : rvb.IIR_DEST_A1=val*4; goto rvbd;\r
+ case H_Reverb+24 : rvb.ACC_SRC_A0=val*4; goto rvbd;\r
+ case H_Reverb+26 : rvb.ACC_SRC_A1=val*4; goto rvbd;\r
+ case H_Reverb+28 : rvb.ACC_SRC_B0=val*4; goto rvbd;\r
+ case H_Reverb+30 : rvb.ACC_SRC_B1=val*4; goto rvbd;\r
+ case H_Reverb+32 : rvb.IIR_SRC_A0=val*4; goto rvbd;\r
+ case H_Reverb+34 : rvb.IIR_SRC_A1=val*4; goto rvbd;\r
+ case H_Reverb+36 : rvb.IIR_DEST_B0=val*4; goto rvbd;\r
+ case H_Reverb+38 : rvb.IIR_DEST_B1=val*4; goto rvbd;\r
+ case H_Reverb+40 : rvb.ACC_SRC_C0=val*4; goto rvbd;\r
+ case H_Reverb+42 : rvb.ACC_SRC_C1=val*4; goto rvbd;\r
+ case H_Reverb+44 : rvb.ACC_SRC_D0=val*4; goto rvbd;\r
+ case H_Reverb+46 : rvb.ACC_SRC_D1=val*4; goto rvbd;\r
+ case H_Reverb+48 : rvb.IIR_SRC_B1=val*4; goto rvbd;\r
+ case H_Reverb+50 : rvb.IIR_SRC_B0=val*4; goto rvbd;\r
+ case H_Reverb+52 : rvb.MIX_DEST_A0=val*4; goto rvbd;\r
+ case H_Reverb+54 : rvb.MIX_DEST_A1=val*4; goto rvbd;\r
+ case H_Reverb+56 : rvb.MIX_DEST_B0=val*4; goto rvbd;\r
+ case H_Reverb+58 : rvb.MIX_DEST_B1=val*4; goto rvbd;\r
+ case H_Reverb+60 : rvb.IN_COEF_L=(short)val; goto rvbd;\r
+ case H_Reverb+62 : rvb.IN_COEF_R=(short)val; goto rvbd;\r
}\r
+ return;\r
+\r
+upd_irq:\r
+ if (spuCtrl & CTRL_IRQ)\r
+ schedule_next_irq();\r
+ return;\r
\r
- if ((r & ~0x3f) == H_Reverb)\r
- rvb.dirty = 1; // recalculate on next update\r
+rvbd:\r
+ rvb.dirty = 1; // recalculate on next update\r
}\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
s_chan[ch].iRawPitch=NP;\r
s_chan[ch].sinc=(NP<<4)|8;\r
+ s_chan[ch].sinc_inv=0;\r
if(iUseInterpolation==1) s_chan[ch].SB[32]=1; // -> freq change in simple interpolation mode: set flag\r
}\r
\r
\r
///////////////////////////////////////////////////////////\r
\r
-void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val);\r
+void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val, unsigned int cycles);\r
\r
// HELPER FOR NEILL'S REVERB: re-inits our reverb mixing buf\r
////////////////////////////////////////////////////////////////////////\r
\r
-INLINE void InitREVERB(void)\r
+INLINE void InitREVERB(int ns_to)\r
{\r
- memset(sRVBStart,0,NSSIZE*2*4);\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// STORE REVERB\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-INLINE void StoreREVERB(int ch,int ns,int l,int r)\r
-{\r
- ns<<=1;\r
-\r
- sRVBStart[ns] +=l; // -> we mix all active reverb channels into an extra buffer\r
- sRVBStart[ns+1]+=r;\r
+ memset(sRVBStart,0,ns_to*sizeof(sRVBStart[0])*2);\r
}\r
\r
////////////////////////////////////////////////////////////////////////\r
////////////////////////////////////////////////////////////////////////\r
\r
// portions based on spu2-x from PCSX2\r
-static void MixREVERB(void)\r
+static void MixREVERB(int ns_to)\r
{\r
int l_old = rvb.iRVBLeft;\r
int r_old = rvb.iRVBRight;\r
int curr_addr = rvb.CurrAddr;\r
int space = 0x40000 - rvb.StartAddr;\r
- int l, r, ns;\r
+ int l = 0, r = 0, ns;\r
\r
- for (ns = 0; ns < NSSIZE*2; )\r
+ for (ns = 0; ns < ns_to * 2; )\r
{\r
int IIR_ALPHA = rvb.IIR_ALPHA;\r
int ACC0, ACC1, FB_A0, FB_A1, FB_B0, FB_B1;\r
rvb.CurrAddr = curr_addr;\r
}\r
\r
-static void MixREVERB_off(void)\r
+static void MixREVERB_off(int ns_to)\r
{\r
int l_old = rvb.iRVBLeft;\r
int r_old = rvb.iRVBRight;\r
int curr_addr = rvb.CurrAddr;\r
int space = 0x40000 - rvb.StartAddr;\r
- int l, r, ns;\r
+ int l = 0, r = 0, ns;\r
\r
- for (ns = 0; ns < NSSIZE*2; )\r
+ for (ns = 0; ns < ns_to * 2; )\r
{\r
l = (g_buffer(MIX_DEST_A0) + g_buffer(MIX_DEST_B0)) / 2;\r
r = (g_buffer(MIX_DEST_A1) + g_buffer(MIX_DEST_B1)) / 2;\r
rvb.dirty = 0;\r
}\r
\r
-INLINE void REVERBDo(void)\r
+INLINE void REVERBDo(int ns_to)\r
{\r
if (!rvb.StartAddr) // reverb is off\r
{\r
if (unlikely(rvb.dirty))\r
prepare_offsets();\r
\r
- MixREVERB();\r
+ MixREVERB(ns_to);\r
}\r
else if (rvb.VolLeft || rvb.VolRight)\r
{\r
if (unlikely(rvb.dirty))\r
prepare_offsets();\r
\r
- MixREVERB_off();\r
+ MixREVERB_off(ns_to);\r
}\r
else // -> reverb off\r
{\r
// reverb runs anyway\r
- rvb.CurrAddr += NSSIZE/2;\r
+ rvb.CurrAddr += ns_to / 2;\r
while (rvb.CurrAddr >= 0x40000)\r
rvb.CurrAddr -= 0x40000 - rvb.StartAddr;\r
}\r
#define PSXCLK 33868800 /* 33.8688 MHz */
+// intended to be ~1 frame
+#define IRQ_NEAR_BLOCKS 32
+
/*
#if defined (USEMACOSX)
static char * libraryName = N_("Mac OS X Sound");
void (CALLBACK *irqCallback)(void)=0; // func of main emu, called on spu irq
void (CALLBACK *cddavCallback)(unsigned short,unsigned short)=0;
+void (CALLBACK *scheduleCallback)(unsigned int)=0;
// certain globals (were local before, but with the new timeproc I need em global)
int ChanBuf[NSSIZE+3];
int SSumLR[(NSSIZE+3)*2];
int iFMod[NSSIZE];
-int iCycle = 0;
short * pS;
static int decode_dirty_ch;
int decode_pos;
-int had_dma;
-int lastch=-1; // last channel processed on spu irq in timer mode
-static int lastns=0; // last ns pos
-static int cycles_since_update;
+unsigned int cycles_played;
#define CDDA_BUFFER_SIZE (16384 * sizeof(uint32_t)) // must be power of 2
return ret;
}
+// if irq is going to trigger sooner than in upd_samples, set upd_samples
+static void scan_for_irq(int ch, unsigned int *upd_samples)
+{
+ int pos, sinc, sinc_inv, end;
+ unsigned char *block;
+ int flags;
+
+ block = s_chan[ch].pCurr;
+ pos = s_chan[ch].spos;
+ sinc = s_chan[ch].sinc;
+ end = pos + *upd_samples * sinc;
+
+ pos += (28 - s_chan[ch].iSBPos) << 16;
+ while (pos < end)
+ {
+ if (block == pSpuIrq)
+ break;
+ flags = block[1];
+ block += 16;
+ if (flags & 1) { // 1: stop/loop
+ block = s_chan[ch].pLoop;
+ if (block == pSpuIrq) // hack.. (see decode_block)
+ break;
+ }
+ pos += 28 << 16;
+ }
+
+ if (pos < end)
+ {
+ sinc_inv = s_chan[ch].sinc_inv;
+ if (sinc_inv == 0)
+ sinc_inv = s_chan[ch].sinc_inv = (0x80000000u / (uint32_t)sinc) << 1;
+
+ pos -= s_chan[ch].spos;
+ *upd_samples = (((uint64_t)pos * sinc_inv) >> 32) + 1;
+ //xprintf("ch%02d: irq sched: %3d %03d\n",
+ // ch, *upd_samples, *upd_samples * 60 * 263 / 44100);
+ }
+}
+
#define make_do_samples(name, fmod_code, interp_start, interp1_code, interp2_code, interp_end) \
-static int do_samples_##name(int ch, int ns, int ns_to) \
+static noinline int do_samples_##name(int ch, int ns, int ns_to) \
{ \
int sinc = s_chan[ch].sinc; \
int spos = s_chan[ch].spos; \
{ \
fmod_code; \
\
+ spos += sinc; \
while (spos >= 0x10000) \
{ \
- if(sbpos == 28) \
+ fa = SB[sbpos++]; \
+ if(sbpos >= 28) \
{ \
sbpos = 0; \
d = decode_block(ch); \
if(d) \
- ret = ns_to = ns + 1; \
+ ret = /*ns_to =*/ ns + 1; \
} \
\
- fa = SB[sbpos++]; \
interp1_code; \
spos -= 0x10000; \
} \
\
interp2_code; \
- spos += sinc; \
} \
\
s_chan[ch].sinc = sinc; \
make_do_samples(simple, , ,
simple_interp_store, simple_interp_get, )
-static int do_samples_noise(int ch, int ns, int ns_to)
+static noinline int do_samples_noise(int ch, int ns, int ns_to)
{
int level, shift, bit;
int ret = -1, d;
// 0x0800-0x0bff Voice 1
// 0x0c00-0x0fff Voice 3
-static void noinline do_decode_bufs(int which, int start, int count)
+static noinline void do_decode_bufs(int which, int start, int count)
{
const int *src = ChanBuf + start;
unsigned short *dst = &spuMem[0x800/2 + which*0x400/2];
// basically the whole sound processing is done in this fat func!
////////////////////////////////////////////////////////////////////////
-static int do_samples(int forced_updates)
+void do_samples(unsigned int cycles_to)
{
+ const int ns_from = 0;
+ int ns,ns_to,ns_len;
int volmult = iVolume;
- int ns,ns_from,ns_to,ns_len;
int ch,d,silentch;
- int bIRQReturn=0;
+ int cycle_diff;
- // ok, at the beginning we are looking if there is
- // enuff free place in the dsound/oss buffer to
- // fill in new data, or if there is a new channel to start.
- // if not, we return until enuff free place is available
- // /a new channel gets started
+ cycle_diff = cycles_to - cycles_played;
+ if (cycle_diff < -2*1048576 || cycle_diff > 2*1048576)
+ {
+ //xprintf("desync %u %d\n", cycles_to, cycle_diff);
+ cycles_played = cycles_to;
+ return;
+ }
- if(!forced_updates && out_current->busy()) // still enuff data in sound buffer?
- return 0;
+ if (cycle_diff < 2 * 768)
+ return;
- while(!bIRQReturn)
- {
- ns_from=0;
- ns_to=NSSIZE;
- ch=0;
- if(lastch>=0) // will be -1 if no continue is pending
- {
- ch=lastch; ns_from=lastns; lastch=-1; // -> setup all kind of vars to continue
- }
+ ns_to = (cycle_diff / 768 + 1) & ~1;
+ if (ns_to > NSSIZE) {
+ // should never happen
+ //xprintf("ns_to oflow %d %d\n", ns_to, NSSIZE);
+ ns_to = NSSIZE;
+ }
+
+ //////////////////////////////////////////////////////
+ // special irq handling in the decode buffers (0x0000-0x1000)
+ // we know:
+ // the decode buffers are located in spu memory in the following way:
+ // 0x0000-0x03ff CD audio left
+ // 0x0400-0x07ff CD audio right
+ // 0x0800-0x0bff Voice 1
+ // 0x0c00-0x0fff Voice 3
+ // and decoded data is 16 bit for one sample
+ // we assume:
+ // even if voices 1/3 are off or no cd audio is playing, the internal
+ // play positions will move on and wrap after 0x400 bytes.
+ // Therefore: we just need a pointer from spumem+0 to spumem+3ff, and
+ // increase this pointer on each sample by 2 bytes. If this pointer
+ // (or 0x400 offsets of this pointer) hits the spuirq address, we generate
+ // an IRQ.
+
+ if (unlikely((spuCtrl & CTRL_IRQ) && pSpuIrq && pSpuIrq < spuMemC+0x1000))
+ {
+ int irq_pos = (pSpuIrq - spuMemC) / 2 & 0x1ff;
+ int left = (irq_pos - decode_pos) & 0x1ff;
+ if (0 < left && left <= ns_to)
+ {
+ //xprintf("decoder irq %x\n", decode_pos);
+ do_irq();
+ ns_to = left;
+ }
+ }
+
+ InitREVERB(ns_to);
+ {
silentch=~(dwChannelOn|dwNewChannel);
//--------------------------------------------------//
//- main channel loop -//
//--------------------------------------------------//
{
- for(;ch<MAXCHAN;ch++) // loop em all... we will collect 1 ms of sound of each playing channel
+ for(ch=0;ch<MAXCHAN;ch++) // loop em all...
{
if(dwNewChannel&(1<<ch)) StartSound(ch); // start new sound
if(!(dwChannelOn&(1<<ch))) continue; // channel not playing? next
if(s_chan[ch].bNoise)
- d=do_samples_noise(ch, ns_from, ns_to);
+ do_samples_noise(ch, ns_from, ns_to);
else if(s_chan[ch].bFMod==2 || (s_chan[ch].bFMod==0 && iUseInterpolation==0))
- d=do_samples_noint(ch, ns_from, ns_to);
+ do_samples_noint(ch, ns_from, ns_to);
else if(s_chan[ch].bFMod==0 && iUseInterpolation==1)
- d=do_samples_simple(ch, ns_from, ns_to);
+ do_samples_simple(ch, ns_from, ns_to);
else
- d=do_samples_default(ch, ns_from, ns_to);
- if(d>=0)
- {
- bIRQReturn=1;
- lastch=ch;
- lastns=ns_to=d;
- }
+ do_samples_default(ch, ns_from, ns_to);
+
ns_len = ns_to - ns_from;
MixADSR(ch, ns_from, ns_to);
{
unsigned char *start = s_chan[ch].pCurr;
- // no need for bIRQReturn since the channel is silent
skip_block(ch);
if(start == s_chan[ch].pCurr || start - spuMemC < 0x1000)
{
}
}
- if(bIRQReturn) // special return for "spu irq - wait for cpu action"
- return 0;
-
if(unlikely(silentch & decode_dirty_ch & (1<<1))) // must clear silent channel decode buffers
{
memset(&spuMem[0x800/2], 0, 0x400);
//---------------------------------------------------//
// mix XA infos (if any)
- MixXA();
+ MixXA(ns_to);
///////////////////////////////////////////////////////
// mix all channels (including reverb) into one buffer
if(iUseReverb)
- REVERBDo();
+ REVERBDo(ns_to);
if((spuCtrl&0x4000)==0) // muted? (rare, don't optimize for this)
{
- memset(pS, 0, NSSIZE * 2 * sizeof(pS[0]));
- pS += NSSIZE*2;
+ memset(pS, 0, ns_to * 2 * sizeof(pS[0]));
+ pS += ns_to * 2;
}
else
- for (ns = 0; ns < NSSIZE*2; )
+ for (ns = 0; ns < ns_to * 2; )
{
d = SSumLR[ns]; SSumLR[ns] = 0;
d = d * volmult >> 10;
ns++;
}
- cycles_since_update -= PSXCLK / 44100 * NSSIZE;
+ cycles_played += ns_to * 768;
- //////////////////////////////////////////////////////
- // special irq handling in the decode buffers (0x0000-0x1000)
- // we know:
- // the decode buffers are located in spu memory in the following way:
- // 0x0000-0x03ff CD audio left
- // 0x0400-0x07ff CD audio right
- // 0x0800-0x0bff Voice 1
- // 0x0c00-0x0fff Voice 3
- // and decoded data is 16 bit for one sample
- // we assume:
- // even if voices 1/3 are off or no cd audio is playing, the internal
- // play positions will move on and wrap after 0x400 bytes.
- // Therefore: we just need a pointer from spumem+0 to spumem+3ff, and
- // increase this pointer on each sample by 2 bytes. If this pointer
- // (or 0x400 offsets of this pointer) hits the spuirq address, we generate
- // an IRQ. Only problem: the "wait for cpu" option is kinda hard to do here
- // in some of Peops timer modes. So: we ignore this option here (for now).
-
- if(unlikely((spuCtrl&CTRL_IRQ) && pSpuIrq && pSpuIrq<spuMemC+0x1000))
- {
- int irq_pos=(pSpuIrq-spuMemC)/2 & 0x1ff;
- if((decode_pos <= irq_pos && irq_pos < decode_pos+NSSIZE)
- || (decode_pos+NSSIZE > 0x200 && irq_pos < ((decode_pos+NSSIZE) & 0x1ff)))
- {
- //printf("decoder irq %x\n", decode_pos);
- do_irq();
- bIRQReturn = 1;
- }
- }
- decode_pos = (decode_pos + NSSIZE) & 0x1ff;
+ decode_pos = (decode_pos + ns_to) & 0x1ff;
+ }
+}
- InitREVERB();
+void schedule_next_irq(void)
+{
+ unsigned int upd_samples;
+ int ch;
- // feed the sound
- // wanna have around 1/60 sec (16.666 ms) updates
- if (iCycle++ >= 16/FRAG_MSECS)
- {
- out_current->feed(pSpuBuffer, (unsigned char *)pS - pSpuBuffer);
- pS = (short *)pSpuBuffer;
- iCycle = 0;
+ if (scheduleCallback == NULL)
+ return;
- if(!forced_updates && out_current->busy())
- break;
- }
+ upd_samples = 44100 / 50;
- if(forced_updates > 0)
- {
- forced_updates--;
- if(forced_updates == 0 && out_current->busy())
- break;
- }
+ for (ch = 0; ch < MAXCHAN; ch++)
+ {
+ if (dwChannelDead & (1 << ch))
+ continue;
+ if ((unsigned long)(pSpuIrq - s_chan[ch].pCurr) > IRQ_NEAR_BLOCKS * 16
+ && (unsigned long)(pSpuIrq - s_chan[ch].pLoop) > IRQ_NEAR_BLOCKS * 16)
+ continue;
- if(cycles_since_update <= -PSXCLK/60 / 4)
- break;
+ scan_for_irq(ch, &upd_samples);
}
- // this may cause desync, but help audio when the emu can't keep up..
- if(cycles_since_update < 0)
- cycles_since_update = 0;
+ if (unlikely(pSpuIrq < spuMemC + 0x1000))
+ {
+ int irq_pos = (pSpuIrq - spuMemC) / 2 & 0x1ff;
+ int left = (irq_pos - decode_pos) & 0x1ff;
+ if (0 < left && left < upd_samples) {
+ //xprintf("decode: %3d (%3d/%3d)\n", left, decode_pos, irq_pos);
+ upd_samples = left;
+ }
+ }
- return 0;
+ if (upd_samples < 44100 / 50)
+ scheduleCallback(upd_samples * 768);
}
// SPU ASYNC... even newer epsxe func
// 1 time every 'cycle' cycles... harhar
-// rearmed: called every 2ms now
+// rearmed: called dynamically now
-void CALLBACK SPUasync(unsigned long cycle)
+void CALLBACK SPUasync(unsigned int cycle, unsigned int flags)
{
- int forced_updates = 0;
- int do_update = 0;
+ do_samples(cycle);
- if(!bSpuInit) return; // -> no init, no call
+ if (spuCtrl & CTRL_IRQ)
+ schedule_next_irq();
- cycles_since_update += cycle;
+ if (flags & 1) {
+ out_current->feed(pSpuBuffer, (unsigned char *)pS - pSpuBuffer);
+ pS = (short *)pSpuBuffer;
- if(dwNewChannel || had_dma)
- {
- forced_updates = 1;
- do_update = 1;
- had_dma = 0;
+ if (0) {
+ if (!out_current->busy())
+ // cause more samples to be generated
+ // (and break some games because of bad sync)
+ cycles_played -= 44100 / 60 / 2 * 768;
}
-
- if(cycles_since_update > PSXCLK/60 * 5/4)
- do_update = 1;
-
- if(do_update)
- do_samples(forced_updates);
+ }
}
// SPU UPDATE... new epsxe func
void CALLBACK SPUupdate(void)
{
- SPUasync(0);
}
// XA AUDIO
// slow us down:
// s_chan[i].hMutex=CreateMutex(NULL,FALSE,NULL);
s_chan[i].ADSRX.SustainLevel = 0xf; // -> init sustain
+ s_chan[i].ADSRX.SustainIncrease = 1;
s_chan[i].pLoop=spuMemC;
s_chan[i].pCurr=spuMemC;
}
decode_pos = 0;
memset((void *)s_chan, 0, (MAXCHAN + 1) * sizeof(SPUCHAN));
pSpuIrq = 0;
- lastch = -1;
SetupStreams(); // prepare streaming
void CALLBACK SPUregisterScheduleCb(void (CALLBACK *callback)(unsigned int))
{
+ scheduleCallback = callback;
}
// COMMON PLUGIN INFO FUNCS
// MIX XA & CDDA
////////////////////////////////////////////////////////////////////////
-INLINE void MixXA(void)
+INLINE void MixXA(int ns_to)
{
int ns;
short l, r;
XARepeat--;
v = XALastVal;
- for(ns=0;ns<NSSIZE*2;)
+ for(ns = 0; ns < ns_to*2; )
{
if(XAPlay != XAFeed) v=*XAPlay++;
if(XAPlay == XAEnd) XAPlay=XAStart;
XALastVal = v;
}
- for(ns=0;ns<NSSIZE*2 && CDDAPlay!=CDDAFeed && (CDDAPlay!=CDDAEnd-1||CDDAFeed!=CDDAStart);)
+ for(ns = 0; ns < ns_to * 2 && CDDAPlay!=CDDAFeed && (CDDAPlay!=CDDAEnd-1||CDDAFeed!=CDDAStart);)
{
v=*CDDAPlay++;
if(CDDAPlay==CDDAEnd) CDDAPlay=CDDAStart;
// CODE AREA
////////////////////////////////////////////////////////////////////////
-void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)
+void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val, unsigned int cycles)
{
unsigned long r=reg&0xfff;
regArea[(r-0xc00)>>1] = val;
////////////////////////////////////////////////////////////////////////
-void CALLBACK SPUwriteDMAMem(unsigned short * pusPSXMem,int iSize)
+void CALLBACK SPUwriteDMAMem(unsigned short * pusPSXMem,int iSize,unsigned int cycles)
{
int i;
for(i=0;i<iSize;i++)
////////////////////////////////////////////////////////////////////////
-void CALLBACK SPUreadDMAMem(unsigned short * pusPSXMem,int iSize)
+void CALLBACK SPUreadDMAMem(unsigned short * pusPSXMem,int iSize,unsigned int cycles)
{
int i;
for(i=0;i<iSize;i++)
return 0;
}
-void SPUasync(unsigned int cycle)
+void SPUasync(unsigned int cycle, unsigned int flags)
{
}
////////////////////////////////////////////////////////////////////////\r
-long CALLBACK SPUfreeze(unsigned long ulFreezeMode,SPUFreeze_t * pF)
+long CALLBACK SPUfreeze(unsigned long ulFreezeMode,SPUFreeze_t * pF,unsigned int cycles)
{
int i;
for(i=0;i<0x100;i++)
{
if(i!=H_SPUon1-0xc00 && i!=H_SPUon2-0xc00)
- SPUwriteRegister(0x1f801c00+i*2,regArea[i]);
+ SPUwriteRegister(0x1f801c00+i*2,regArea[i],cycles);
}
- SPUwriteRegister(H_SPUon1,regArea[(H_SPUon1-0xc00)/2]);
- SPUwriteRegister(H_SPUon2,regArea[(H_SPUon2-0xc00)/2]);
+ SPUwriteRegister(H_SPUon1,regArea[(H_SPUon1-0xc00)/2],cycles);
+ SPUwriteRegister(H_SPUon2,regArea[(H_SPUon2-0xc00)/2],cycles);
return 1;
}
notaz.gp2x.de / pcsx_rearmed.git / commitdiff