X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=plugins%2Fdfsound%2Ffreeze.c;h=36b8995923829ee677865cdd7b3e1fbe57d3406a;hb=HEAD;hp=b865b84837ca6b81339b29be0453f21ac80893d0;hpb=3154bfab51566cbaa5bce3965d4c915bfb1b4f53;p=pcsx_rearmed.git diff --git a/plugins/dfsound/freeze.c b/plugins/dfsound/freeze.c index b865b848..36b89959 100644 --- a/plugins/dfsound/freeze.c +++ b/plugins/dfsound/freeze.c @@ -15,6 +15,7 @@ * * ***************************************************************************/ +#include #include "stdafx.h" #define _IN_FREEZE @@ -106,7 +107,7 @@ typedef struct ADSRInfoEx_orig ADSRX; // next ADSR settings (will be moved to active on sample start) } SPUCHAN_orig; -typedef struct +typedef struct SPUFreeze { char szSPUName[8]; uint32_t ulFreezeVersion; @@ -119,20 +120,30 @@ typedef struct typedef struct { unsigned short spuIrq; + unsigned short decode_pos; uint32_t pSpuIrq; uint32_t spuAddr; - uint32_t dummy1; - uint32_t dummy2; - uint32_t dummy3; + uint32_t rvb_cur; + uint16_t xa_left; + uint16_t cdda_left; + uint32_t cycles_played; SPUCHAN_orig s_chan[MAXCHAN]; + uint32_t cycles_dma_end; + uint32_t decode_dirty_ch; + uint32_t dwNoiseVal; + uint32_t dwNoiseCount; + uint32_t XARepeat; + uint32_t XALastVal; + uint32_t last_keyon_cycles; + } SPUOSSFreeze_t; //////////////////////////////////////////////////////////////////////// -void LoadStateV5(SPUFreeze_t * pF); // newest version -void LoadStateUnknown(SPUFreeze_t * pF, uint32_t cycles); // unknown format +static SPUOSSFreeze_t * LoadStateV5(SPUFreeze_t * pF, uint32_t cycles); +static void LoadStateUnknown(SPUFreeze_t * pF, uint32_t cycles); // unknown format // we want to retain compatibility between versions, // so use original channel struct @@ -143,12 +154,13 @@ static void save_channel(SPUCHAN_orig *d, const SPUCHAN *s, int ch) d->iSBPos = s->iSBPos; d->spos = s->spos; d->sinc = s->sinc; - memcpy(d->SB, s->SB, sizeof(d->SB)); - d->iStart = (regAreaGet(ch,6)&~1)<<3; + assert(sizeof(d->SB) >= sizeof(spu.sb[ch])); + memcpy(d->SB, &spu.sb[ch], sizeof(spu.sb[ch])); + d->iStart = (regAreaGetCh(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->bStop; + d->bOn = !!(spu.dwChannelsAudible & (1<bStop = s->ADSRX.State == ADSR_RELEASE; d->bReverb = s->bReverb; d->iActFreq = 1; d->iUsedFreq = 2; @@ -157,8 +169,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[27]; // yes it's reversed + d->s_2 = spu.sb[ch].SB[26]; d->bRVBActive = s->bRVBActive; d->bNoise = s->bNoise; d->bFMod = s->bFMod; @@ -185,10 +197,9 @@ static void load_channel(SPUCHAN *d, const SPUCHAN_orig *s, int ch) d->spos = s->spos; d->sinc = s->sinc; d->sinc_inv = 0; - memcpy(d->SB, s->SB, sizeof(d->SB)); - d->pCurr = (void *)((long)s->iCurr & 0x7fff0); - d->pLoop = (void *)((long)s->iLoop & 0x7fff0); - d->bStop = s->bStop; + memcpy(&spu.sb[ch], s->SB, sizeof(spu.sb[ch])); + d->pCurr = (void *)((uintptr_t)s->iCurr & 0x7fff0); + d->pLoop = (void *)((uintptr_t)s->iLoop & 0x7fff0); d->bReverb = s->bReverb; d->iLeftVolume = s->iLeftVolume; d->iRightVolume = s->iRightVolume; @@ -198,6 +209,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; @@ -208,7 +220,7 @@ 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<bOn) spu.dwChannelsAudible |= 1<ADSRX.EnvelopeVol = 0; } @@ -224,15 +236,19 @@ static void load_register(unsigned long reg, unsigned int cycles) // SPUFREEZE: called by main emu on savestate load/save //////////////////////////////////////////////////////////////////////// -long CALLBACK SPUfreeze(uint32_t ulFreezeMode, SPUFreeze_t * pF, - uint32_t cycles) +long CALLBACK SPUfreeze(unsigned int ulFreezeMode, SPUFreeze_t * pF, + unsigned int cycles) { - int i;SPUOSSFreeze_t * pFO; + SPUOSSFreeze_t * pFO = NULL; + int i; if(!pF) return 0; // first check if(ulFreezeMode) // info or save? {//--------------------------------------------------// + int xa_left = 0, cdda_left = 0; + do_samples(cycles, 1); + if(ulFreezeMode==1) memset(pF,0,sizeof(SPUFreeze_t)+sizeof(SPUOSSFreeze_t)); @@ -242,33 +258,66 @@ long CALLBACK SPUfreeze(uint32_t ulFreezeMode, SPUFreeze_t * pF, if(ulFreezeMode==2) return 1; // info mode? ok, bye // save mode: - do_samples(cycles); - + regAreaGet(H_SPUctrl) = spu.spuCtrl; + regAreaGet(H_SPUstat) = spu.spuStat; memcpy(pF->cSPURam,spu.spuMem,0x80000); // copy common infos memcpy(pF->cSPUPort,spu.regArea,0x200); if(spu.xapGlobal && spu.XAPlay!=spu.XAFeed) // some xa { - pF->xaS=*spu.xapGlobal; + xa_left = spu.XAFeed - spu.XAPlay; + if (xa_left < 0) + xa_left = spu.XAEnd - spu.XAPlay + spu.XAFeed - spu.XAStart; + pF->xaS = *spu.xapGlobal; + } + else if (spu.CDDAPlay != spu.CDDAFeed) + { + // abuse the xa struct to store leftover cdda samples + unsigned int *p = spu.CDDAPlay; + cdda_left = spu.CDDAFeed - spu.CDDAPlay; + if (cdda_left < 0) + cdda_left = spu.CDDAEnd - spu.CDDAPlay + spu.CDDAFeed - spu.CDDAStart; + if (cdda_left > sizeof(pF->xaS.pcm) / 4) + cdda_left = sizeof(pF->xaS.pcm) / 4; + if (p + cdda_left <= spu.CDDAEnd) + memcpy(pF->xaS.pcm, p, cdda_left * 4); + else { + memcpy(pF->xaS.pcm, p, (spu.CDDAEnd - p) * 4); + memcpy((char *)pF->xaS.pcm + (spu.CDDAEnd - p) * 4, spu.CDDAStart, + (cdda_left - (spu.CDDAEnd - p)) * 4); + } + pF->xaS.nsamples = 0; } - else - memset(&pF->xaS,0,sizeof(xa_decode_t)); // or clean xa + else + memset(&pF->xaS,0,sizeof(xa_decode_t)); // or clean xa pFO=(SPUOSSFreeze_t *)(pF+1); // store special stuff pFO->spuIrq = spu.regArea[(H_SPUirqAddr - 0x0c00) / 2]; - if(spu.pSpuIrq) pFO->pSpuIrq = (unsigned long)spu.pSpuIrq-(unsigned long)spu.spuMemC; + if(spu.pSpuIrq) pFO->pSpuIrq = spu.pSpuIrq - spu.spuMemC; pFO->spuAddr=spu.spuAddr; if(pFO->spuAddr==0) pFO->spuAddr=0xbaadf00d; + pFO->decode_pos = spu.decode_pos; + pFO->rvb_cur = spu.rvb->CurrAddr; + pFO->xa_left = xa_left; + pFO->cdda_left = cdda_left; + pFO->cycles_played = spu.cycles_played; + pFO->cycles_dma_end = spu.cycles_dma_end; + pFO->decode_dirty_ch = spu.decode_dirty_ch; + pFO->dwNoiseVal = spu.dwNoiseVal; + pFO->dwNoiseCount = spu.dwNoiseCount; + pFO->XARepeat = spu.XARepeat; + pFO->XALastVal = spu.XALastVal; + pFO->last_keyon_cycles = spu.last_keyon_cycles; for(i=0;is_chan[i],&s_chan[i],i); - if(s_chan[i].pCurr) - pFO->s_chan[i].iCurr=s_chan[i].pCurr-spu.spuMemC; - if(s_chan[i].pLoop) - pFO->s_chan[i].iLoop=s_chan[i].pLoop-spu.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; @@ -279,81 +328,118 @@ long CALLBACK SPUfreeze(uint32_t ulFreezeMode, SPUFreeze_t * pF, memcpy(spu.spuMem,pF->cSPURam,0x80000); // get ram memcpy(spu.regArea,pF->cSPUPort,0x200); + spu.bMemDirty = 1; + spu.spuCtrl = regAreaGet(H_SPUctrl); + spu.spuStat = regAreaGet(H_SPUstat); - if(pF->xaS.nsamples<=4032) // start xa again - SPUplayADPCMchannel(&pF->xaS); - - spu.xapGlobal=0; - - if(!strcmp(pF->szSPUName,"PBOSS") && pF->ulFreezeVersion==5) - LoadStateV5(pF); + if (!strcmp(pF->szSPUName,"PBOSS") && pF->ulFreezeVersion==5) + pFO = LoadStateV5(pF, cycles); else LoadStateUnknown(pF, cycles); + spu.XAPlay = spu.XAFeed = spu.XAStart; + spu.CDDAPlay = spu.CDDAFeed = spu.CDDAStart; + spu.cdClearSamples = 512; + if (pFO && pFO->xa_left && pF->xaS.nsamples) { // start xa again + FeedXA(&pF->xaS); + spu.XAPlay = spu.XAFeed - pFO->xa_left; + if (spu.XAPlay < spu.XAStart) + spu.XAPlay = spu.XAStart; + } + else if (pFO && pFO->cdda_left) { // start cdda again + FeedCDDA((void *)pF->xaS.pcm, pFO->cdda_left * 4); + } + + // not in old savestates + spu.cycles_dma_end = 0; + spu.decode_dirty_ch = spu.dwChannelsAudible & 0x0a; + spu.dwNoiseVal = 0; + spu.dwNoiseCount = 0; + spu.XARepeat = 0; + spu.XALastVal = 0; + spu.last_keyon_cycles = cycles - 16*786u; + if (pFO && pF->ulFreezeSize >= sizeof(*pF) + sizeof(*pFO)) { + spu.cycles_dma_end = pFO->cycles_dma_end; + spu.decode_dirty_ch = pFO->decode_dirty_ch; + spu.dwNoiseVal = pFO->dwNoiseVal; + spu.dwNoiseCount = pFO->dwNoiseCount; + spu.XARepeat = pFO->XARepeat; + spu.XALastVal = pFO->XALastVal; + spu.last_keyon_cycles = pFO->last_keyon_cycles; + } + // repair some globals for(i=0;i<=62;i+=2) load_register(H_Reverb+i, cycles); load_register(H_SPUReverbAddr, cycles); load_register(H_SPUrvolL, cycles); load_register(H_SPUrvolR, cycles); - - load_register(H_SPUctrl, cycles); - load_register(H_SPUstat, cycles); load_register(H_CDLeft, cycles); load_register(H_CDRight, cycles); + // reverb + spu.rvb->StartAddr = regAreaGet(H_SPUReverbAddr) << 2; + if (spu.rvb->CurrAddr < spu.rvb->StartAddr) + spu.rvb->CurrAddr = spu.rvb->StartAddr; // fix to prevent new interpolations from crashing - for(i=0;ipSpuIrq) spu.pSpuIrq = spu.spuMemC+((long)pFO->pSpuIrq&0x7fff0); else spu.pSpuIrq=NULL; + spu.pSpuIrq = spu.spuMemC + ((spu.regArea[(H_SPUirqAddr - 0x0c00) / 2] << 3) & ~0xf); if(pFO->spuAddr) { - spu.spuAddr = pFO->spuAddr; - if (spu.spuAddr == 0xbaadf00d) spu.spuAddr = 0; + if (pFO->spuAddr == 0xbaadf00d) spu.spuAddr = 0; + else spu.spuAddr = pFO->spuAddr & 0x7fffe; } + spu.decode_pos = pFO->decode_pos & 0x1ff; + spu.rvb->CurrAddr = pFO->rvb_cur; + spu.cycles_played = pFO->cycles_played ? pFO->cycles_played : cycles; spu.dwNewChannel=0; - spu.dwChannelOn=0; + spu.dwChannelsAudible=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)spu.spuMemC; - s_chan[i].pLoop+=(unsigned long)spu.spuMemC; + spu.s_chan[i].pCurr+=(uintptr_t)spu.spuMemC; + spu.s_chan[i].pLoop+=(uintptr_t)spu.spuMemC; } + + return pFO; } //////////////////////////////////////////////////////////////////////// -void LoadStateUnknown(SPUFreeze_t * pF, uint32_t cycles) +static void LoadStateUnknown(SPUFreeze_t * pF, uint32_t cycles) { int i; for(i=0;i