Commit | Line | Data |
---|---|---|
ef79bbde P |
1 | /***************************************************************************\r |
2 | freeze.c - description\r | |
3 | -------------------\r | |
4 | begin : Wed May 15 2002\r | |
5 | copyright : (C) 2002 by Pete Bernert\r | |
6 | email : BlackDove@addcom.de\r | |
7 | ***************************************************************************/\r | |
8 | /***************************************************************************\r | |
9 | * *\r | |
10 | * This program is free software; you can redistribute it and/or modify *\r | |
11 | * it under the terms of the GNU General Public License as published by *\r | |
12 | * the Free Software Foundation; either version 2 of the License, or *\r | |
13 | * (at your option) any later version. See also the license.txt file for *\r | |
14 | * additional informations. *\r | |
15 | * *\r | |
16 | ***************************************************************************/\r | |
17 | \r | |
24dbf983 | 18 | #include <assert.h>\r |
ef79bbde P |
19 | #include "stdafx.h"\r |
20 | \r | |
21 | #define _IN_FREEZE\r | |
22 | \r | |
23 | #include "externals.h"\r | |
24 | #include "registers.h"\r | |
25 | #include "spu.h"\r | |
ef79bbde P |
26 | \r |
27 | ////////////////////////////////////////////////////////////////////////\r | |
28 | // freeze structs\r | |
29 | ////////////////////////////////////////////////////////////////////////\r | |
30 | \r | |
c668f248 | 31 | typedef struct\r |
32 | {\r | |
33 | int AttackModeExp;\r | |
34 | int AttackTime;\r | |
35 | int DecayTime;\r | |
36 | int SustainLevel;\r | |
37 | int SustainModeExp;\r | |
38 | int SustainModeDec;\r | |
39 | int SustainTime;\r | |
40 | int ReleaseModeExp;\r | |
41 | unsigned int ReleaseVal;\r | |
42 | int ReleaseTime;\r | |
43 | int ReleaseStartTime; \r | |
44 | int ReleaseVol; \r | |
45 | int lTime;\r | |
46 | int lVolume;\r | |
47 | } ADSRInfo;\r | |
48 | \r | |
6d866bb7 | 49 | typedef struct\r |
50 | {\r | |
51 | int State;\r | |
52 | int AttackModeExp;\r | |
53 | int AttackRate;\r | |
54 | int DecayRate;\r | |
55 | int SustainLevel;\r | |
56 | int SustainModeExp;\r | |
57 | int SustainIncrease;\r | |
58 | int SustainRate;\r | |
59 | int ReleaseModeExp;\r | |
60 | int ReleaseRate;\r | |
61 | int EnvelopeVol;\r | |
c668f248 | 62 | int lVolume;\r |
63 | int lDummy1;\r | |
64 | int lDummy2;\r | |
6d866bb7 | 65 | } ADSRInfoEx_orig;\r |
66 | \r | |
67 | typedef struct\r | |
68 | {\r | |
69 | // no mutexes used anymore... don't need them to sync access\r | |
70 | //HANDLE hMutex;\r | |
71 | \r | |
72 | int bNew; // start flag\r | |
73 | \r | |
74 | int iSBPos; // mixing stuff\r | |
75 | int spos;\r | |
76 | int sinc;\r | |
77 | 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? :)\r | |
78 | int sval;\r | |
79 | \r | |
8e1040b6 | 80 | int iStart; // start ptr into sound mem\r |
81 | int iCurr; // current pos in sound mem\r | |
82 | int iLoop; // loop ptr in sound mem\r | |
6d866bb7 | 83 | \r |
84 | int bOn; // is channel active (sample playing?)\r | |
85 | int bStop; // is channel stopped (sample _can_ still be playing, ADSR Release phase)\r | |
86 | int bReverb; // can we do reverb on this channel? must have ctrl register bit, to get active\r | |
87 | int iActFreq; // current psx pitch\r | |
88 | int iUsedFreq; // current pc pitch\r | |
89 | int iLeftVolume; // left volume\r | |
90 | int iLeftVolRaw; // left psx volume value\r | |
91 | int bIgnoreLoop; // ignore loop bit, if an external loop address is used\r | |
92 | int iMute; // mute mode\r | |
93 | int iRightVolume; // right volume\r | |
94 | int iRightVolRaw; // right psx volume value\r | |
95 | int iRawPitch; // raw pitch (0...3fff)\r | |
96 | int iIrqDone; // debug irq done flag\r | |
97 | int s_1; // last decoding infos\r | |
98 | int s_2;\r | |
99 | int bRVBActive; // reverb active flag\r | |
100 | int iRVBOffset; // reverb offset\r | |
101 | int iRVBRepeat; // reverb repeat\r | |
102 | int bNoise; // noise active flag\r | |
103 | int bFMod; // freq mod (0=off, 1=sound channel, 2=freq channel)\r | |
104 | int iRVBNum; // another reverb helper\r | |
105 | int iOldNoise; // old noise val for this channel \r | |
106 | ADSRInfo ADSR; // active ADSR settings\r | |
107 | ADSRInfoEx_orig ADSRX; // next ADSR settings (will be moved to active on sample start)\r | |
108 | } SPUCHAN_orig;\r | |
109 | \r | |
ef79bbde P |
110 | typedef struct\r |
111 | {\r | |
112 | char szSPUName[8];\r | |
113 | uint32_t ulFreezeVersion;\r | |
114 | uint32_t ulFreezeSize;\r | |
115 | unsigned char cSPUPort[0x200];\r | |
116 | unsigned char cSPURam[0x80000];\r | |
117 | xa_decode_t xaS; \r | |
118 | } SPUFreeze_t;\r | |
119 | \r | |
120 | typedef struct\r | |
121 | {\r | |
122 | unsigned short spuIrq;\r | |
0ad5d4a1 | 123 | unsigned short decode_pos;\r |
ef79bbde P |
124 | uint32_t pSpuIrq;\r |
125 | uint32_t spuAddr;\r | |
403a6290 | 126 | uint32_t rvb_cur;\r |
127 | uint16_t xa_left;\r | |
128 | uint16_t cdda_left;\r | |
129 | uint32_t cycles_played;\r | |
ef79bbde | 130 | \r |
6d866bb7 | 131 | SPUCHAN_orig s_chan[MAXCHAN]; \r |
ef79bbde P |
132 | \r |
133 | } SPUOSSFreeze_t;\r | |
134 | \r | |
135 | ////////////////////////////////////////////////////////////////////////\r | |
136 | \r | |
403a6290 | 137 | static SPUOSSFreeze_t * LoadStateV5(SPUFreeze_t * pF, uint32_t cycles);\r |
138 | static void LoadStateUnknown(SPUFreeze_t * pF, uint32_t cycles); // unknown format\r | |
ef79bbde | 139 | \r |
6d866bb7 | 140 | // we want to retain compatibility between versions,\r |
141 | // so use original channel struct\r | |
381ea103 | 142 | static void save_channel(SPUCHAN_orig *d, const SPUCHAN *s, int ch)\r |
6d866bb7 | 143 | {\r |
144 | memset(d, 0, sizeof(*d));\r | |
3154bfab | 145 | d->bNew = !!(spu.dwNewChannel & (1<<ch));\r |
6d866bb7 | 146 | d->iSBPos = s->iSBPos;\r |
147 | d->spos = s->spos;\r | |
148 | d->sinc = s->sinc;\r | |
24dbf983 | 149 | assert(sizeof(d->SB) >= sizeof(spu.sb[ch]));\r |
150 | memcpy(d->SB, &spu.sb[ch], sizeof(spu.sb[ch]));\r | |
a0d4a8f5 | 151 | d->iStart = (regAreaGetCh(ch, 6) & ~1) << 3;\r |
8e1040b6 | 152 | d->iCurr = 0; // set by the caller\r |
153 | d->iLoop = 0; // set by the caller\r | |
2daa7c1d | 154 | d->bOn = !!(spu.dwChannelsAudible & (1<<ch));\r |
9ad8abfa | 155 | d->bStop = s->ADSRX.State == ADSR_RELEASE;\r |
6d866bb7 | 156 | d->bReverb = s->bReverb;\r |
7e44d49d | 157 | d->iActFreq = 1;\r |
158 | d->iUsedFreq = 2;\r | |
6d866bb7 | 159 | d->iLeftVolume = s->iLeftVolume;\r |
e4f075af | 160 | // this one is nasty but safe, save compat is important\r |
161 | d->bIgnoreLoop = (s->prevflags ^ 2) << 1;\r | |
6d866bb7 | 162 | d->iRightVolume = s->iRightVolume;\r |
163 | d->iRawPitch = s->iRawPitch;\r | |
24dbf983 | 164 | d->s_1 = spu.sb[ch].SB[27]; // yes it's reversed\r |
165 | d->s_2 = spu.sb[ch].SB[26];\r | |
6d866bb7 | 166 | d->bRVBActive = s->bRVBActive;\r |
6d866bb7 | 167 | d->bNoise = s->bNoise;\r |
168 | d->bFMod = s->bFMod;\r | |
6d866bb7 | 169 | d->ADSRX.State = s->ADSRX.State;\r |
170 | d->ADSRX.AttackModeExp = s->ADSRX.AttackModeExp;\r | |
171 | d->ADSRX.AttackRate = s->ADSRX.AttackRate;\r | |
172 | d->ADSRX.DecayRate = s->ADSRX.DecayRate;\r | |
173 | d->ADSRX.SustainLevel = s->ADSRX.SustainLevel;\r | |
174 | d->ADSRX.SustainModeExp = s->ADSRX.SustainModeExp;\r | |
175 | d->ADSRX.SustainIncrease = s->ADSRX.SustainIncrease;\r | |
176 | d->ADSRX.SustainRate = s->ADSRX.SustainRate;\r | |
177 | d->ADSRX.ReleaseModeExp = s->ADSRX.ReleaseModeExp;\r | |
178 | d->ADSRX.ReleaseRate = s->ADSRX.ReleaseRate;\r | |
179 | d->ADSRX.EnvelopeVol = s->ADSRX.EnvelopeVol;\r | |
180 | d->ADSRX.lVolume = d->bOn; // hmh\r | |
181 | }\r | |
182 | \r | |
381ea103 | 183 | static void load_channel(SPUCHAN *d, const SPUCHAN_orig *s, int ch)\r |
6d866bb7 | 184 | {\r |
185 | memset(d, 0, sizeof(*d));\r | |
3154bfab | 186 | if (s->bNew) spu.dwNewChannel |= 1<<ch;\r |
6d866bb7 | 187 | d->iSBPos = s->iSBPos;\r |
650adfd2 | 188 | if ((uint32_t)d->iSBPos >= 28) d->iSBPos = 27;\r |
6d866bb7 | 189 | d->spos = s->spos;\r |
190 | d->sinc = s->sinc;\r | |
650adfd2 | 191 | d->sinc_inv = 0;\r |
24dbf983 | 192 | memcpy(&spu.sb[ch], s->SB, sizeof(spu.sb[ch]));\r |
2d724e28 | 193 | d->pCurr = (void *)((uintptr_t)s->iCurr & 0x7fff0);\r |
194 | d->pLoop = (void *)((uintptr_t)s->iLoop & 0x7fff0);\r | |
6d866bb7 | 195 | d->bReverb = s->bReverb;\r |
6d866bb7 | 196 | d->iLeftVolume = s->iLeftVolume;\r |
6d866bb7 | 197 | d->iRightVolume = s->iRightVolume;\r |
198 | d->iRawPitch = s->iRawPitch;\r | |
6d866bb7 | 199 | d->bRVBActive = s->bRVBActive;\r |
6d866bb7 | 200 | d->bNoise = s->bNoise;\r |
201 | d->bFMod = s->bFMod;\r | |
e4f075af | 202 | d->prevflags = (s->bIgnoreLoop >> 1) ^ 2;\r |
6d866bb7 | 203 | d->ADSRX.State = s->ADSRX.State;\r |
9ad8abfa | 204 | if (s->bStop) d->ADSRX.State = ADSR_RELEASE;\r |
6d866bb7 | 205 | d->ADSRX.AttackModeExp = s->ADSRX.AttackModeExp;\r |
206 | d->ADSRX.AttackRate = s->ADSRX.AttackRate;\r | |
207 | d->ADSRX.DecayRate = s->ADSRX.DecayRate;\r | |
208 | d->ADSRX.SustainLevel = s->ADSRX.SustainLevel;\r | |
209 | d->ADSRX.SustainModeExp = s->ADSRX.SustainModeExp;\r | |
210 | d->ADSRX.SustainIncrease = s->ADSRX.SustainIncrease;\r | |
211 | d->ADSRX.SustainRate = s->ADSRX.SustainRate;\r | |
212 | d->ADSRX.ReleaseModeExp = s->ADSRX.ReleaseModeExp;\r | |
213 | d->ADSRX.ReleaseRate = s->ADSRX.ReleaseRate;\r | |
214 | d->ADSRX.EnvelopeVol = s->ADSRX.EnvelopeVol;\r | |
2daa7c1d | 215 | if (s->bOn) spu.dwChannelsAudible |= 1<<ch;\r |
6f6fe969 | 216 | else d->ADSRX.EnvelopeVol = 0;\r |
6d866bb7 | 217 | }\r |
218 | \r | |
650adfd2 | 219 | // force load from regArea to variables\r |
220 | static void load_register(unsigned long reg, unsigned int cycles)\r | |
221 | {\r | |
3154bfab | 222 | unsigned short *r = &spu.regArea[((reg & 0xfff) - 0xc00) >> 1];\r |
650adfd2 | 223 | *r ^= 1;\r |
224 | SPUwriteRegister(reg, *r ^ 1, cycles);\r | |
225 | }\r | |
226 | \r | |
ef79bbde P |
227 | ////////////////////////////////////////////////////////////////////////\r |
228 | // SPUFREEZE: called by main emu on savestate load/save\r | |
229 | ////////////////////////////////////////////////////////////////////////\r | |
230 | \r | |
650adfd2 | 231 | long CALLBACK SPUfreeze(uint32_t ulFreezeMode, SPUFreeze_t * pF,\r |
232 | uint32_t cycles)\r | |
ef79bbde | 233 | {\r |
403a6290 | 234 | SPUOSSFreeze_t * pFO = NULL;\r |
235 | int i;\r | |
ef79bbde P |
236 | \r |
237 | if(!pF) return 0; // first check\r | |
238 | \r | |
239 | if(ulFreezeMode) // info or save?\r | |
240 | {//--------------------------------------------------//\r | |
403a6290 | 241 | int xa_left = 0, cdda_left = 0;\r |
242 | do_samples(cycles, 1);\r | |
243 | \r | |
ef79bbde P |
244 | if(ulFreezeMode==1) \r |
245 | memset(pF,0,sizeof(SPUFreeze_t)+sizeof(SPUOSSFreeze_t));\r | |
246 | \r | |
247 | strcpy(pF->szSPUName,"PBOSS");\r | |
248 | pF->ulFreezeVersion=5;\r | |
249 | pF->ulFreezeSize=sizeof(SPUFreeze_t)+sizeof(SPUOSSFreeze_t);\r | |
250 | \r | |
251 | if(ulFreezeMode==2) return 1; // info mode? ok, bye\r | |
252 | // save mode:\r | |
3154bfab | 253 | memcpy(pF->cSPURam,spu.spuMem,0x80000); // copy common infos\r |
254 | memcpy(pF->cSPUPort,spu.regArea,0x200);\r | |
ef79bbde | 255 | \r |
3154bfab | 256 | if(spu.xapGlobal && spu.XAPlay!=spu.XAFeed) // some xa\r |
ef79bbde | 257 | {\r |
403a6290 | 258 | xa_left = spu.XAFeed - spu.XAPlay;\r |
259 | if (xa_left < 0)\r | |
260 | xa_left = spu.XAEnd - spu.XAPlay + spu.XAFeed - spu.XAStart;\r | |
261 | pF->xaS = *spu.xapGlobal;\r | |
262 | }\r | |
263 | else if (spu.CDDAPlay != spu.CDDAFeed)\r | |
264 | {\r | |
265 | // abuse the xa struct to store leftover cdda samples\r | |
266 | unsigned int *p = spu.CDDAPlay;\r | |
267 | cdda_left = spu.CDDAFeed - spu.CDDAPlay;\r | |
268 | if (cdda_left < 0)\r | |
269 | cdda_left = spu.CDDAEnd - spu.CDDAPlay + spu.CDDAFeed - spu.CDDAStart;\r | |
270 | if (cdda_left > sizeof(pF->xaS.pcm) / 4)\r | |
271 | cdda_left = sizeof(pF->xaS.pcm) / 4;\r | |
272 | if (p + cdda_left <= spu.CDDAEnd)\r | |
273 | memcpy(pF->xaS.pcm, p, cdda_left * 4);\r | |
274 | else {\r | |
275 | memcpy(pF->xaS.pcm, p, (spu.CDDAEnd - p) * 4);\r | |
276 | memcpy((char *)pF->xaS.pcm + (spu.CDDAEnd - p) * 4, spu.CDDAStart,\r | |
277 | (cdda_left - (spu.CDDAEnd - p)) * 4);\r | |
278 | }\r | |
279 | pF->xaS.nsamples = 0;\r | |
ef79bbde | 280 | }\r |
403a6290 | 281 | else\r |
282 | memset(&pF->xaS,0,sizeof(xa_decode_t)); // or clean xa\r | |
ef79bbde P |
283 | \r |
284 | pFO=(SPUOSSFreeze_t *)(pF+1); // store special stuff\r | |
285 | \r | |
3154bfab | 286 | pFO->spuIrq = spu.regArea[(H_SPUirqAddr - 0x0c00) / 2];\r |
2d724e28 | 287 | if(spu.pSpuIrq) pFO->pSpuIrq = spu.pSpuIrq - spu.spuMemC;\r |
ef79bbde | 288 | \r |
3154bfab | 289 | pFO->spuAddr=spu.spuAddr;\r |
ef79bbde | 290 | if(pFO->spuAddr==0) pFO->spuAddr=0xbaadf00d;\r |
0ad5d4a1 | 291 | pFO->decode_pos = spu.decode_pos;\r |
403a6290 | 292 | pFO->rvb_cur = spu.rvb->CurrAddr;\r |
293 | pFO->xa_left = xa_left;\r | |
294 | pFO->cdda_left = cdda_left;\r | |
295 | pFO->cycles_played = spu.cycles_played;\r | |
ef79bbde P |
296 | \r |
297 | for(i=0;i<MAXCHAN;i++)\r | |
298 | {\r | |
5514a050 | 299 | save_channel(&pFO->s_chan[i],&spu.s_chan[i],i);\r |
300 | if(spu.s_chan[i].pCurr)\r | |
301 | pFO->s_chan[i].iCurr=spu.s_chan[i].pCurr-spu.spuMemC;\r | |
302 | if(spu.s_chan[i].pLoop)\r | |
303 | pFO->s_chan[i].iLoop=spu.s_chan[i].pLoop-spu.spuMemC;\r | |
ef79bbde P |
304 | }\r |
305 | \r | |
ef79bbde P |
306 | return 1;\r |
307 | //--------------------------------------------------//\r | |
308 | }\r | |
309 | \r | |
310 | if(ulFreezeMode!=0) return 0; // bad mode? bye\r | |
311 | \r | |
3154bfab | 312 | memcpy(spu.spuMem,pF->cSPURam,0x80000); // get ram\r |
313 | memcpy(spu.regArea,pF->cSPUPort,0x200);\r | |
0c1151fe | 314 | spu.bMemDirty = 1;\r |
ef79bbde | 315 | \r |
403a6290 | 316 | if (!strcmp(pF->szSPUName,"PBOSS") && pF->ulFreezeVersion==5)\r |
317 | pFO = LoadStateV5(pF, cycles);\r | |
650adfd2 | 318 | else LoadStateUnknown(pF, cycles);\r |
ef79bbde | 319 | \r |
403a6290 | 320 | spu.XAPlay = spu.XAFeed = spu.XAStart;\r |
321 | spu.CDDAPlay = spu.CDDAFeed = spu.CDDAStart;\r | |
322 | if (pFO && pFO->xa_left && pF->xaS.nsamples) { // start xa again\r | |
323 | FeedXA(&pF->xaS);\r | |
324 | spu.XAPlay = spu.XAFeed - pFO->xa_left;\r | |
325 | if (spu.XAPlay < spu.XAStart)\r | |
326 | spu.XAPlay = spu.XAStart;\r | |
327 | }\r | |
328 | else if (pFO && pFO->cdda_left) { // start cdda again\r | |
329 | FeedCDDA((void *)pF->xaS.pcm, pFO->cdda_left * 4);\r | |
330 | }\r | |
331 | \r | |
ef79bbde P |
332 | // repair some globals\r |
333 | for(i=0;i<=62;i+=2)\r | |
650adfd2 | 334 | load_register(H_Reverb+i, cycles);\r |
335 | load_register(H_SPUReverbAddr, cycles);\r | |
336 | load_register(H_SPUrvolL, cycles);\r | |
337 | load_register(H_SPUrvolR, cycles);\r | |
ef79bbde | 338 | \r |
650adfd2 | 339 | load_register(H_SPUctrl, cycles);\r |
340 | load_register(H_SPUstat, cycles);\r | |
341 | load_register(H_CDLeft, cycles);\r | |
342 | load_register(H_CDRight, cycles);\r | |
ef79bbde | 343 | \r |
6a3fa667 | 344 | if (spu.rvb->CurrAddr < spu.rvb->StartAddr)\r |
345 | spu.rvb->CurrAddr = spu.rvb->StartAddr;\r | |
ef79bbde | 346 | // fix to prevent new interpolations from crashing\r |
24dbf983 | 347 | spu.interpolation = -1;\r |
ef79bbde | 348 | \r |
6d75977b | 349 | ClearWorkingState();\r |
ef79bbde | 350 | \r |
c4c66b22 | 351 | if (spu.spuCtrl & CTRL_IRQ)\r |
352 | schedule_next_irq();\r | |
353 | \r | |
ef79bbde P |
354 | return 1;\r |
355 | }\r | |
356 | \r | |
357 | ////////////////////////////////////////////////////////////////////////\r | |
358 | \r | |
403a6290 | 359 | static SPUOSSFreeze_t * LoadStateV5(SPUFreeze_t * pF, uint32_t cycles)\r |
ef79bbde P |
360 | {\r |
361 | int i;SPUOSSFreeze_t * pFO;\r | |
362 | \r | |
363 | pFO=(SPUOSSFreeze_t *)(pF+1);\r | |
364 | \r | |
c4c66b22 | 365 | spu.pSpuIrq = spu.spuMemC + ((spu.regArea[(H_SPUirqAddr - 0x0c00) / 2] << 3) & ~0xf);\r |
ef79bbde P |
366 | \r |
367 | if(pFO->spuAddr)\r | |
368 | {\r | |
5514a050 | 369 | if (pFO->spuAddr == 0xbaadf00d) spu.spuAddr = 0;\r |
370 | else spu.spuAddr = pFO->spuAddr & 0x7fffe;\r | |
ef79bbde | 371 | }\r |
0ad5d4a1 | 372 | spu.decode_pos = pFO->decode_pos & 0x1ff;\r |
403a6290 | 373 | spu.rvb->CurrAddr = pFO->rvb_cur;\r |
374 | spu.cycles_played = pFO->cycles_played ? pFO->cycles_played : cycles;\r | |
ef79bbde | 375 | \r |
3154bfab | 376 | spu.dwNewChannel=0;\r |
2daa7c1d | 377 | spu.dwChannelsAudible=0;\r |
3154bfab | 378 | spu.dwChannelDead=0;\r |
ef79bbde P |
379 | for(i=0;i<MAXCHAN;i++)\r |
380 | {\r | |
5514a050 | 381 | load_channel(&spu.s_chan[i],&pFO->s_chan[i],i);\r |
ef79bbde | 382 | \r |
2d724e28 | 383 | spu.s_chan[i].pCurr+=(uintptr_t)spu.spuMemC;\r |
384 | spu.s_chan[i].pLoop+=(uintptr_t)spu.spuMemC;\r | |
ef79bbde | 385 | }\r |
403a6290 | 386 | return pFO;\r |
ef79bbde P |
387 | }\r |
388 | \r | |
389 | ////////////////////////////////////////////////////////////////////////\r | |
390 | \r | |
403a6290 | 391 | static void LoadStateUnknown(SPUFreeze_t * pF, uint32_t cycles)\r |
ef79bbde P |
392 | {\r |
393 | int i;\r | |
394 | \r | |
395 | for(i=0;i<MAXCHAN;i++)\r | |
396 | {\r | |
5514a050 | 397 | spu.s_chan[i].pLoop=spu.spuMemC;\r |
ef79bbde P |
398 | }\r |
399 | \r | |
3154bfab | 400 | spu.dwNewChannel=0;\r |
2daa7c1d | 401 | spu.dwChannelsAudible=0;\r |
3154bfab | 402 | spu.dwChannelDead=0;\r |
c4c66b22 | 403 | spu.pSpuIrq=spu.spuMemC;\r |
403a6290 | 404 | spu.cycles_played = cycles;\r |
ef79bbde P |
405 | \r |
406 | for(i=0;i<0xc0;i++)\r | |
407 | {\r | |
650adfd2 | 408 | load_register(0x1f801c00 + i*2, cycles);\r |
ef79bbde P |
409 | }\r |
410 | }\r | |
411 | \r | |
412 | ////////////////////////////////////////////////////////////////////////\r | |
403a6290 | 413 | // vim:shiftwidth=1:expandtab\r |