State saving progress. Most core state seems to be saved/loaded correctly, not so for video yet unfortunately.

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@386 8ced0084-cf51-0410-be5f-012b33b47a6e

Source/Core/Core/Src/CoreTiming.cpp

@@ -20,6 +20,7 @@
 #include "Thread.h"
 #include "PowerPC/PowerPC.h"
 #include "CoreTiming.h"
+#include "StringUtil.h"
 
 // TODO(ector): Replace new/delete in this file with a simple memory pool
 // Don't expect a massive speedup though.
@@ -35,14 +36,16 @@ struct EventType
 
 std::vector<EventType> event_types;
 
-struct Event
+struct BaseEvent
 {
 	s64 time;
 	u64 userdata;
-	Event *next;
 	int type;
+//	Event *next;
 };
 
+typedef LinkedListItem<BaseEvent> Event;
+
 // STATE_TO_SAVE (how?)
 Event *first;
 Event *tsFirst;
@@ -55,6 +58,8 @@ s64 idledCycles;
 
 Common::CriticalSection externalEventSection;
 
+void (*advanceCallback)(int cyclesExecuted);
+
 int RegisterEvent(const char *name, TimedCallback callback)
 {
 	EventType type;
@@ -71,14 +76,72 @@ void UnregisterAllEvents()
 	event_types.clear();
 }
 
+void Init()
+{
+	downcount = maxSliceLength;
+	slicelength = maxSliceLength;
+	globalTimer = 0;
+	idledCycles = 0;
+}
+
+void Shutdown()
+{
+	ClearPendingEvents();
+	UnregisterAllEvents();
+}
+
 void DoState(PointerWrap &p)
 {
 	externalEventSection.Enter();
 	p.Do(downcount);
 	p.Do(slicelength);
-	p.Do(maxSliceLength);
 	p.Do(globalTimer);
 	p.Do(idledCycles);
+	// OK, here we're gonna need to specialize depending on the mode.
+	// Should do something generic to serialize linked lists.
+	switch (p.GetMode()) {
+	case PointerWrap::MODE_READ:
+		{
+		ClearPendingEvents();
+		if (first)
+			PanicAlert("Clear failed.");
+		int more_events = 0;
+		Event *prev = 0;
+		while (true) {
+			p.Do(more_events);
+			if (!more_events)
+				break;
+			Event *ev = new Event;
+			if (!prev)
+				first = ev;
+			else
+				prev->next = ev;
+			p.Do(ev->time);
+			p.Do(ev->type);
+			p.Do(ev->userdata);
+			ev->next = 0;
+			prev = ev;
+			ev = ev->next;
+		}
+		}
+		break;
+	case PointerWrap::MODE_MEASURE:
+	case PointerWrap::MODE_WRITE:
+		{
+		Event *ev = first;
+		int more_events = 1;
+		while (ev) {
+			p.Do(more_events);
+			p.Do(ev->time);
+			p.Do(ev->type);
+			p.Do(ev->userdata);
+			ev = ev->next;
+		}
+		more_events = 0;
+		p.Do(more_events);
+		break;
+		}
+	}
 	externalEventSection.Leave();
 }
 
@@ -106,14 +169,12 @@ void ScheduleEvent_Threadsafe(int cyclesIntoFuture, int event_type, u64 userdata
 	externalEventSection.Leave();
 }
 
-void Clear()
+void ClearPendingEvents()
 {
-	globalTimer = 0;
-	idledCycles = 0;
 	while (first)
 	{
 		Event *e = first->next;
-		delete [] first;
+		delete first;
 		first = e;
 	}
 }
@@ -172,9 +233,6 @@ void ScheduleEvent(int cyclesIntoFuture, int event_type, u64 userdata)
 	AddEventToQueue(ne);
 }
 
-void (*advanceCallback)(int cyclesExecuted);
-
-
 void RegisterAdvanceCallback(void (*callback)(int cyclesExecuted))
 {
 	advanceCallback = callback;
@@ -302,5 +360,23 @@ void Idle()
 	Advance();
 }
 
+std::string GetScheduledEventsSummary()
+{
+	Event *ptr = first;
+	std::string text = "Scheduled events\n";
+	text.reserve(1000);
+	while (ptr)
+	{
+		int t = ptr->type;
+		if (t < 0 || t >= event_types.size())
+			PanicAlert("Invalid event type %i", t);
+		const char *name = event_types[ptr->type].name;
+		if (!name)
+			name = "[unknown]";
+		text += StringFromFormat("%s : %i %08x%08x\n", event_types[ptr->type].name, ptr->time, ptr->userdata >> 32, ptr->userdata);
+		ptr = ptr->next;
+	}
+	return text;
+}
 
 }; // end of namespace

Source/Core/Core/Src/CoreTiming.h

@@ -25,11 +25,18 @@
 // callback. You then schedule events using the type id you get back.
 
 #include "Common.h"
+
+#include <string>
+
 #include "ChunkFile.h"
 
 namespace CoreTiming
 {
 
+
+void Init();
+void Shutdown();
+
 typedef void (*TimedCallback)(u64 userdata, int cyclesLate);
 
 u64 GetTicks();
@@ -58,13 +65,16 @@ void Advance();
 // Pretend that the main CPU has executed enough cycles to reach the next event.
 void Idle();
 
-// Clear all pending events. This should ONLY be done on exit.
-void Clear();
+// Clear all pending events. This should ONLY be done on exit or state load.
+void ClearPendingEvents();
+
 void LogPendingEvents();
 void SetMaximumSlice(int maximumSliceLength);
 
 void RegisterAdvanceCallback(void (*callback)(int cyclesExecuted));
 
+std::string GetScheduledEventsSummary();
+
 extern int downcount;
 extern int slicelength;
 

Source/Core/Core/Src/HW/HW.cpp

@@ -45,6 +45,8 @@ namespace HW
 {
 	void Init()
 	{
+		CoreTiming::Init();
+
 		Thunk_Init(); // not really hw, but this way we know it's inited first :P
 		State_Init();
 
@@ -83,8 +85,7 @@ namespace HW
 		
 		State_Shutdown();
 		Thunk_Shutdown();
-		
-		CoreTiming::UnregisterAllEvents();
+		CoreTiming::Shutdown();
 	}
 
 	void DoState(PointerWrap &p)
@@ -100,7 +101,6 @@ namespace HW
 		GPFifo::DoState(p);
 		ExpansionInterface::DoState(p);
 		AudioInterface::DoState(p);
-		CoreTiming::DoState(p);
         WII_IPCInterface::DoState(p);
 	}
 }

Source/Core/Core/Src/HW/SystemTimers.cpp

@@ -217,7 +217,6 @@ void Init()
 void Shutdown()
 {
 	Common::Timer::RestoreResolution();
-	CoreTiming::Clear();
 }
 
 }  // namespace

Source/Core/Core/Src/PowerPC/PowerPC.cpp

@@ -44,7 +44,6 @@ namespace PowerPC
 	void DoState(PointerWrap &p)
 	{
 		p.Do(ppcState);
-		p.Do(state);
 	}
 
 	void ResetRegisters()

Source/Core/Core/Src/State.cpp

@@ -41,7 +41,7 @@ void DoState(PointerWrap &p)
 	PowerPC::DoState(p);
 	HW::DoState(p);
 	CoreTiming::DoState(p);
-    PluginVideo::Video_DoState(p.GetPPtr(), p.GetMode());
+    // PluginVideo::Video_DoState(p.GetPPtr(), p.GetMode());
 }
 
 void SaveStateCallback(u64 userdata, int cyclesLate)
@@ -59,6 +59,7 @@ void SaveStateCallback(u64 userdata, int cyclesLate)
 	FILE *f = fopen(cur_filename.c_str(), "wb");
 	fwrite(buffer, sz, 1, f);
 	fclose(f);
+
 	delete [] buffer;
 
 	Core::DisplayMessage("Saved State", 2000);
@@ -68,17 +69,20 @@ void LoadStateCallback(u64 userdata, int cyclesLate)
 {
 	Jit64::ClearCache();
 
-	FILE *f = fopen(cur_filename.c_str(), "r");
+	FILE *f = fopen(cur_filename.c_str(), "rb");
 	fseek(f, 0, SEEK_END);
 	int sz = ftell(f);
 	fseek(f, 0, SEEK_SET);
 	u8 *buffer = new u8[sz];
-	fread(buffer, sz, 1, f);
+	int x;
+	if (x=fread(buffer, 1, sz, f) != sz)
+		PanicAlert("wtf? %d %d", x, sz);
 	fclose(f);
 
 	u8 *ptr = buffer;
 	PointerWrap p(&ptr, PointerWrap::MODE_READ);
 	DoState(p);
+	delete [] buffer;
 
 	Core::DisplayMessage("Loaded State", 2000);
 }