X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?p=pcsx_rearmed.git;a=blobdiff_plain;f=plugins%2Fdfsound%2Ffreeze.c;h=3bdbab1bd0bf8fcc98bd747981f2148828d51243;hp=ec097c5be8139ed60fbdcbbba9dc6fe66777e425;hb=d9dcc8cb7803c89a528c8d808a429932673f8074;hpb=e4f075af4e4ba79332c72809d3bb4ba6e2895253 diff --git a/plugins/dfsound/freeze.c b/plugins/dfsound/freeze.c index ec097c5b..3bdbab1b 100644 --- a/plugins/dfsound/freeze.c +++ b/plugins/dfsound/freeze.c @@ -27,6 +27,24 @@ // freeze structs //////////////////////////////////////////////////////////////////////// +typedef struct +{ + int AttackModeExp; + int AttackTime; + int DecayTime; + int SustainLevel; + int SustainModeExp; + int SustainModeDec; + int SustainTime; + int ReleaseModeExp; + unsigned int ReleaseVal; + int ReleaseTime; + int ReleaseStartTime; + int ReleaseVol; + int lTime; + int lVolume; +} ADSRInfo; + typedef struct { int State; @@ -40,9 +58,9 @@ typedef struct int ReleaseModeExp; int ReleaseRate; int EnvelopeVol; - long lVolume; - long lDummy1; - long lDummy2; + int lVolume; + int lDummy1; + int lDummy2; } ADSRInfoEx_orig; typedef struct @@ -58,9 +76,9 @@ typedef struct int SB[32+32]; // Pete added another 32 dwords in 1.6 ... prevents overflow issues with gaussian/cubic interpolation (thanx xodnizel!), and can be used for even better interpolations, eh? :) int sval; - unsigned char * pStart; // start ptr into sound mem - unsigned char * pCurr; // current pos in sound mem - unsigned char * pLoop; // loop ptr in sound mem + int iStart; // start ptr into sound mem + int iCurr; // current pos in sound mem + int iLoop; // loop ptr in sound mem int bOn; // is channel active (sample playing?) int bStop; // is channel stopped (sample _can_ still be playing, ADSR Release phase) @@ -101,6 +119,7 @@ typedef struct typedef struct { unsigned short spuIrq; + unsigned short decode_pos; uint32_t pSpuIrq; uint32_t spuAddr; uint32_t dummy1; @@ -114,25 +133,23 @@ typedef struct //////////////////////////////////////////////////////////////////////// void LoadStateV5(SPUFreeze_t * pF); // newest version -void LoadStateUnknown(SPUFreeze_t * pF); // unknown format - -extern int lastch; +void LoadStateUnknown(SPUFreeze_t * pF, uint32_t cycles); // unknown format // we want to retain compatibility between versions, // so use original channel struct static void save_channel(SPUCHAN_orig *d, const SPUCHAN *s, int ch) { memset(d, 0, sizeof(*d)); - d->bNew = !!(dwNewChannel & (1<bNew = !!(spu.dwNewChannel & (1<iSBPos = s->iSBPos; d->spos = s->spos; d->sinc = s->sinc; - memcpy(d->SB, s->SB, sizeof(d->SB)); - d->pStart = (unsigned char *)((regAreaGet(ch,6)&~1)<<3); - d->pCurr = s->pCurr; - d->pLoop = s->pLoop; - d->bOn = !!(dwChannelOn & (1<bStop = s->bStop; + memcpy(d->SB, spu.SB + ch * SB_SIZE, sizeof(d->SB[0]) * SB_SIZE); + d->iStart = (regAreaGet(ch,6)&~1)<<3; + d->iCurr = 0; // set by the caller + d->iLoop = 0; // set by the caller + d->bOn = !!(spu.dwChannelOn & (1<bStop = s->ADSRX.State == ADSR_RELEASE; d->bReverb = s->bReverb; d->iActFreq = 1; d->iUsedFreq = 2; @@ -141,8 +158,8 @@ static void save_channel(SPUCHAN_orig *d, const SPUCHAN *s, int ch) d->bIgnoreLoop = (s->prevflags ^ 2) << 1; d->iRightVolume = s->iRightVolume; d->iRawPitch = s->iRawPitch; - d->s_1 = s->SB[27]; // yes it's reversed - d->s_2 = s->SB[26]; + d->s_1 = spu.SB[ch * SB_SIZE + 27]; // yes it's reversed + d->s_2 = spu.SB[ch * SB_SIZE + 26]; d->bRVBActive = s->bRVBActive; d->bNoise = s->bNoise; d->bFMod = s->bFMod; @@ -163,15 +180,15 @@ static void save_channel(SPUCHAN_orig *d, const SPUCHAN *s, int ch) static void load_channel(SPUCHAN *d, const SPUCHAN_orig *s, int ch) { memset(d, 0, sizeof(*d)); - if (s->bNew) dwNewChannel |= 1<bNew) spu.dwNewChannel |= 1<iSBPos = s->iSBPos; + if ((uint32_t)d->iSBPos >= 28) d->iSBPos = 27; d->spos = s->spos; d->sinc = s->sinc; - memcpy(d->SB, s->SB, sizeof(d->SB)); - d->pCurr = (void *)((long)s->pCurr & 0x7fff0); - d->pLoop = (void *)((long)s->pLoop & 0x7fff0); - if (s->bOn) dwChannelOn |= 1<bStop = s->bStop; + d->sinc_inv = 0; + memcpy(spu.SB + ch * SB_SIZE, s->SB, sizeof(spu.SB[0]) * SB_SIZE); + d->pCurr = (void *)((long)s->iCurr & 0x7fff0); + d->pLoop = (void *)((long)s->iLoop & 0x7fff0); d->bReverb = s->bReverb; d->iLeftVolume = s->iLeftVolume; d->iRightVolume = s->iRightVolume; @@ -181,6 +198,7 @@ static void load_channel(SPUCHAN *d, const SPUCHAN_orig *s, int ch) d->bFMod = s->bFMod; d->prevflags = (s->bIgnoreLoop >> 1) ^ 2; d->ADSRX.State = s->ADSRX.State; + if (s->bStop) d->ADSRX.State = ADSR_RELEASE; d->ADSRX.AttackModeExp = s->ADSRX.AttackModeExp; d->ADSRX.AttackRate = s->ADSRX.AttackRate; d->ADSRX.DecayRate = s->ADSRX.DecayRate; @@ -191,18 +209,31 @@ static void load_channel(SPUCHAN *d, const SPUCHAN_orig *s, int ch) d->ADSRX.ReleaseModeExp = s->ADSRX.ReleaseModeExp; d->ADSRX.ReleaseRate = s->ADSRX.ReleaseRate; d->ADSRX.EnvelopeVol = s->ADSRX.EnvelopeVol; + if (s->bOn) spu.dwChannelOn |= 1<ADSRX.EnvelopeVol = 0; +} + +// force load from regArea to variables +static void load_register(unsigned long reg, unsigned int cycles) +{ + unsigned short *r = &spu.regArea[((reg & 0xfff) - 0xc00) >> 1]; + *r ^= 1; + SPUwriteRegister(reg, *r ^ 1, cycles); } //////////////////////////////////////////////////////////////////////// // SPUFREEZE: called by main emu on savestate load/save //////////////////////////////////////////////////////////////////////// -long CALLBACK SPUfreeze(uint32_t ulFreezeMode,SPUFreeze_t * pF) +long CALLBACK SPUfreeze(uint32_t ulFreezeMode, SPUFreeze_t * pF, + uint32_t cycles) { int i;SPUOSSFreeze_t * pFO; if(!pF) return 0; // first check + do_samples(cycles, 1); + if(ulFreezeMode) // info or save? {//--------------------------------------------------// if(ulFreezeMode==1) @@ -214,34 +245,32 @@ long CALLBACK SPUfreeze(uint32_t ulFreezeMode,SPUFreeze_t * pF) if(ulFreezeMode==2) return 1; // info mode? ok, bye // save mode: - memcpy(pF->cSPURam,spuMem,0x80000); // copy common infos - memcpy(pF->cSPUPort,regArea,0x200); + memcpy(pF->cSPURam,spu.spuMem,0x80000); // copy common infos + memcpy(pF->cSPUPort,spu.regArea,0x200); - if(xapGlobal && XAPlay!=XAFeed) // some xa + if(spu.xapGlobal && spu.XAPlay!=spu.XAFeed) // some xa { - pF->xaS=*xapGlobal; + pF->xaS=*spu.xapGlobal; } else memset(&pF->xaS,0,sizeof(xa_decode_t)); // or clean xa pFO=(SPUOSSFreeze_t *)(pF+1); // store special stuff - pFO->spuIrq=spuIrq; - if(pSpuIrq) pFO->pSpuIrq = (unsigned long)pSpuIrq-(unsigned long)spuMemC; + pFO->spuIrq = spu.regArea[(H_SPUirqAddr - 0x0c00) / 2]; + if(spu.pSpuIrq) pFO->pSpuIrq = (unsigned long)spu.pSpuIrq-(unsigned long)spu.spuMemC; - pFO->spuAddr=spuAddr; + pFO->spuAddr=spu.spuAddr; if(pFO->spuAddr==0) pFO->spuAddr=0xbaadf00d; + pFO->decode_pos = spu.decode_pos; for(i=0;is_chan[i],&s_chan[i],i); - if(pFO->s_chan[i].pCurr) - pFO->s_chan[i].pCurr-=(unsigned long)spuMemC; - if(pFO->s_chan[i].pLoop) - pFO->s_chan[i].pLoop-=(unsigned long)spuMemC; + save_channel(&pFO->s_chan[i],&spu.s_chan[i],i); + if(spu.s_chan[i].pCurr) + pFO->s_chan[i].iCurr=spu.s_chan[i].pCurr-spu.spuMemC; + if(spu.s_chan[i].pLoop) + pFO->s_chan[i].iLoop=spu.s_chan[i].pLoop-spu.spuMemC; } return 1; @@ -250,36 +279,39 @@ long CALLBACK SPUfreeze(uint32_t ulFreezeMode,SPUFreeze_t * pF) if(ulFreezeMode!=0) return 0; // bad mode? bye - memcpy(spuMem,pF->cSPURam,0x80000); // get ram - memcpy(regArea,pF->cSPUPort,0x200); + memcpy(spu.spuMem,pF->cSPURam,0x80000); // get ram + memcpy(spu.regArea,pF->cSPUPort,0x200); + spu.bMemDirty = 1; if(pF->xaS.nsamples<=4032) // start xa again SPUplayADPCMchannel(&pF->xaS); - xapGlobal=0; + spu.xapGlobal=0; if(!strcmp(pF->szSPUName,"PBOSS") && pF->ulFreezeVersion==5) LoadStateV5(pF); - else LoadStateUnknown(pF); - - lastch = -1; + else LoadStateUnknown(pF, cycles); // repair some globals for(i=0;i<=62;i+=2) - SPUwriteRegister(H_Reverb+i,regArea[(H_Reverb+i-0xc00)>>1]); - SPUwriteRegister(H_SPUReverbAddr,regArea[(H_SPUReverbAddr-0xc00)>>1]); - SPUwriteRegister(H_SPUrvolL,regArea[(H_SPUrvolL-0xc00)>>1]); - SPUwriteRegister(H_SPUrvolR,regArea[(H_SPUrvolR-0xc00)>>1]); + load_register(H_Reverb+i, cycles); + load_register(H_SPUReverbAddr, cycles); + load_register(H_SPUrvolL, cycles); + load_register(H_SPUrvolR, cycles); - SPUwriteRegister(H_SPUctrl,(unsigned short)(regArea[(H_SPUctrl-0xc00)>>1]|0x4000)); - SPUwriteRegister(H_SPUstat,regArea[(H_SPUstat-0xc00)>>1]); - SPUwriteRegister(H_CDLeft,regArea[(H_CDLeft-0xc00)>>1]); - SPUwriteRegister(H_CDRight,regArea[(H_CDRight-0xc00)>>1]); + load_register(H_SPUctrl, cycles); + load_register(H_SPUstat, cycles); + load_register(H_CDLeft, cycles); + load_register(H_CDRight, cycles); // fix to prevent new interpolations from crashing - for(i=0;ispuIrq; - if(pFO->pSpuIrq) pSpuIrq = spuMemC+((long)pFO->pSpuIrq&0x7fff0); else pSpuIrq=NULL; + spu.pSpuIrq = spu.spuMemC + ((spu.regArea[(H_SPUirqAddr - 0x0c00) / 2] << 3) & ~0xf); if(pFO->spuAddr) { - spuAddr = pFO->spuAddr; - if (spuAddr == 0xbaadf00d) spuAddr = 0; + if (pFO->spuAddr == 0xbaadf00d) spu.spuAddr = 0; + else spu.spuAddr = pFO->spuAddr & 0x7fffe; } + spu.decode_pos = pFO->decode_pos & 0x1ff; - dwNewChannel=0; - dwChannelOn=0; - dwChannelDead=0; + spu.dwNewChannel=0; + spu.dwChannelOn=0; + spu.dwChannelDead=0; for(i=0;is_chan[i],i); + load_channel(&spu.s_chan[i],&pFO->s_chan[i],i); - s_chan[i].pCurr+=(unsigned long)spuMemC; - s_chan[i].pLoop+=(unsigned long)spuMemC; + spu.s_chan[i].pCurr+=(unsigned long)spu.spuMemC; + spu.s_chan[i].pLoop+=(unsigned long)spu.spuMemC; } } //////////////////////////////////////////////////////////////////////// -void LoadStateUnknown(SPUFreeze_t * pF) +void LoadStateUnknown(SPUFreeze_t * pF, uint32_t cycles) { int i; for(i=0;i