GB, GBA: Improve savestate loading in new timing system

src/gb/audio.c

@@ -964,7 +964,6 @@ void GBAudioPSGDeserialize(struct GBAudio* audio, const struct GBSerializedPSGSt
 	audio->ch1.envelope.nextStep = GBSerializedAudioEnvelopeGetNextStep(ch1Flags);
 	audio->ch1.sweep.realFrequency = GBSerializedAudioEnvelopeGetFrequency(ch1Flags);
 	LOAD_32LE(when, 0, &state->ch1.nextEvent);
-	mTimingDeschedule(audio->timing, &audio->ch1Event);
 	if (audio->ch1.envelope.dead < 2 && audio->playingCh1) {
 		mTimingSchedule(audio->timing, &audio->ch1Event, when);
 	}
@@ -976,7 +975,6 @@ void GBAudioPSGDeserialize(struct GBAudio* audio, const struct GBSerializedPSGSt
 	audio->ch2.control.length = GBSerializedAudioEnvelopeGetLength(ch2Flags);
 	audio->ch2.envelope.nextStep = GBSerializedAudioEnvelopeGetNextStep(ch2Flags);
 	LOAD_32LE(when, 0, &state->ch2.nextEvent);
-	mTimingDeschedule(audio->timing, &audio->ch2Event);
 	if (audio->ch2.envelope.dead < 2 && audio->playingCh2) {
 		mTimingSchedule(audio->timing, &audio->ch2Event, when);
 	}
@@ -986,7 +984,6 @@ void GBAudioPSGDeserialize(struct GBAudio* audio, const struct GBSerializedPSGSt
 	memcpy(audio->ch3.wavedata32, state->ch3.wavebanks, sizeof(audio->ch3.wavedata32));
 	LOAD_16LE(audio->ch3.length, 0, &state->ch3.length);
 	LOAD_32LE(when, 0, &state->ch3.nextEvent);
-	mTimingDeschedule(audio->timing, &audio->ch3Event);
 	if (audio->playingCh3) {
 		mTimingSchedule(audio->timing, &audio->ch3Event, when);
 	}
@@ -1002,7 +999,6 @@ void GBAudioPSGDeserialize(struct GBAudio* audio, const struct GBSerializedPSGSt
 	audio->ch4.envelope.nextStep = GBSerializedAudioEnvelopeGetNextStep(ch4Flags);
 	LOAD_32LE(audio->ch4.lfsr, 0, &state->ch4.lfsr);
 	LOAD_32LE(when, 0, &state->ch4.nextEvent);
-	mTimingDeschedule(audio->timing, &audio->ch4Event);
 	if (audio->ch4.envelope.dead < 2 && audio->playingCh4) {
 		mTimingSchedule(audio->timing, &audio->ch4Event, when);
 	}
@@ -1017,6 +1013,5 @@ void GBAudioDeserialize(struct GBAudio* audio, const struct GBSerializedState* s
 	GBAudioPSGDeserialize(audio, &state->audio.psg, &state->audio.flags);
 	uint32_t when;
 	LOAD_32LE(when, 0, &state->audio.nextSample);
-	mTimingDeschedule(audio->timing, &audio->sampleEvent);
 	mTimingSchedule(audio->timing, &audio->sampleEvent, when);
 }

src/gb/memory.c

@@ -630,12 +630,10 @@ void GBMemoryDeserialize(struct GB* gb, const struct GBSerializedState* state) {
 
 	uint32_t when;
 	LOAD_32LE(when, 0, &state->memory.dmaNext);
-	mTimingDeschedule(&gb->timing, &memory->dmaEvent);
 	if (memory->dmaRemaining) {
 		mTimingSchedule(&gb->timing, &memory->dmaEvent, when);
 	}
 	LOAD_32LE(when, 0, &state->memory.hdmaNext);
-	mTimingDeschedule(&gb->timing, &memory->hdmaEvent);
 	if (memory->hdmaRemaining) {
 		mTimingSchedule(&gb->timing, &memory->hdmaEvent, when);
 	}

src/gb/serialize.c

@@ -170,14 +170,13 @@ bool GBDeserialize(struct GB* gb, const struct GBSerializedState* state) {
 
 	uint32_t when;
 	LOAD_32LE(when, 0, &state->cpu.eiPending);
-	mTimingDeschedule(&gb->timing, &gb->eiPending);
 	if (GBSerializedCpuFlagsIsEiPending(flags)) {
 		mTimingSchedule(&gb->timing, &gb->eiPending, when);
 	}
 
 	LOAD_32LE(gb->cpu->cycles, 0, &state->cpu.cycles);
 	LOAD_32LE(gb->cpu->nextEvent, 0, &state->cpu.nextEvent);
-	LOAD_32LE(gb->timing.masterCycles, 0, &state->masterCycles);
+	gb->timing.root = NULL;
 
 	gb->model = state->model;
 

src/gb/timer.c

@@ -109,13 +109,11 @@ void GBTimerDeserialize(struct GBTimer* timer, const struct GBSerializedState* s
 
 	uint32_t when;
 	LOAD_32LE(when, 0, &state->timer.nextEvent);
-	mTimingDeschedule(&timer->p->timing, &timer->event);
 	mTimingSchedule(&timer->p->timing, &timer->event, when);
 
 	GBSerializedTimerFlags flags;
 	LOAD_32LE(flags, 0, &state->timer.flags);
 
-	mTimingDeschedule(&timer->p->timing, &timer->irq);
 	if (GBSerializedTimerFlagsIsIrqPending(flags)) {
 		LOAD_32LE(when, 0, &state->timer.nextIRQ);
 		mTimingSchedule(&timer->p->timing, &timer->irq, when);

src/gb/video.c

@@ -550,12 +550,10 @@ void GBVideoDeserialize(struct GBVideo* video, const struct GBSerializedState* s
 	}
 
 	uint32_t when;
-	mTimingDeschedule(&video->p->timing, &video->modeEvent);
 	if (!GBSerializedVideoFlagsIsNotModeEventScheduled(flags)) {
 		LOAD_32LE(when, 0, &state->video.nextMode);
 		mTimingSchedule(&video->p->timing, &video->modeEvent, when);
 	}
-	mTimingDeschedule(&video->p->timing, &video->frameEvent);
 	if (!GBSerializedVideoFlagsIsNotFrameEventScheduled(flags)) {
 		LOAD_32LE(when, 0, &state->video.nextFrame);
 		mTimingSchedule(&video->p->timing, &video->frameEvent, when);

src/gba/audio.c

@@ -344,7 +344,6 @@ void GBAAudioDeserialize(struct GBAAudio* audio, const struct GBASerializedState
 
 	uint32_t when;
 	LOAD_32(when, 0, &state->audio.nextSample);
-	mTimingDeschedule(&audio->p->timing, &audio->sampleEvent);
 	mTimingSchedule(&audio->p->timing, &audio->sampleEvent, when);
 }
 

src/gba/io.c

@@ -956,7 +956,6 @@ void GBAIODeserialize(struct GBA* gba, const struct GBASerializedState* state) {
 			gba->timers[i].lastEvent = when + mTimingCurrentTime(&gba->timing);
 		}
 		LOAD_32(when, 0, &state->timers[i].nextEvent);
-		mTimingDeschedule(&gba->timing, &gba->timers[i].event);
 		if (GBATimerFlagsIsEnable(gba->timers[i].flags)) {
 			mTimingSchedule(&gba->timing, &gba->timers[i].event, when);
 		}

src/gba/savedata.c

@@ -548,7 +548,6 @@ void GBASavedataDeserialize(struct GBASavedata* savedata, const struct GBASerial
 	if (GBASerializedSavedataFlagsIsDustSettling(flags)) {
 		uint32_t when;
 		LOAD_32(when, 0, &state->savedata.settlingDust);
-		mTimingDeschedule(savedata->timing, &savedata->dust);
 		mTimingSchedule(savedata->timing, &savedata->dust, when);
 	}
 }

src/gba/serialize.c

@@ -146,7 +146,7 @@ bool GBADeserialize(struct GBA* gba, const struct GBASerializedState* state) {
 	if (error) {
 		return false;
 	}
-	LOAD_32(gba->timing.masterCycles, 0, &state->masterCycles);
+	gba->timing.root = NULL;
 	size_t i;
 	for (i = 0; i < 16; ++i) {
 		LOAD_32(gba->cpu->gprs[i], i * sizeof(gba->cpu->gprs[0]), state->cpu.gprs);

src/gba/video.c

@@ -324,7 +324,6 @@ void GBAVideoDeserialize(struct GBAVideo* video, const struct GBASerializedState
 	} else {
 		video->event.callback = _startHblank;
 	}
-	mTimingDeschedule(&video->p->timing, &video->event);
 	mTimingSchedule(&video->p->timing, &video->event, when);
 
 	LOAD_16(video->vcount, REG_VCOUNT, state->io);