PCE: convert states to Serializer implementation
This commit is contained in:
beirich
parent
d02eab8c2d
commit
8363d66f25
|
|
@ -214,147 +214,35 @@ namespace BizHawk.Emulation.Common.Components
|
|||
}
|
||||
}
|
||||
|
||||
public void SaveStateText(TextWriter writer)
|
||||
public void SyncState(Serializer ser)
|
||||
{
|
||||
writer.WriteLine("[PSG]");
|
||||
|
||||
writer.WriteLine("MainVolumeLeft {0:X2}", MainVolumeLeft);
|
||||
writer.WriteLine("MainVolumeRight {0:X2}", MainVolumeRight);
|
||||
writer.WriteLine("VoiceLatch {0}", VoiceLatch);
|
||||
writer.WriteLine("WaveTableWriteOffset {0:X2}", WaveTableWriteOffset);
|
||||
writer.WriteLine();
|
||||
ser.BeginSection("PSG");
|
||||
ser.Sync("MainVolumeLeft", ref MainVolumeLeft);
|
||||
ser.Sync("MainVolumeRight", ref MainVolumeRight);
|
||||
ser.Sync("VoiceLatch", ref VoiceLatch);
|
||||
ser.Sync("WaveTableWriteOffset", ref WaveTableWriteOffset);
|
||||
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
writer.WriteLine("[Channel{0}]", i + 1);
|
||||
writer.WriteLine("Frequency {0:X4}", Channels[i].Frequency);
|
||||
writer.WriteLine("Panning {0:X2}", Channels[i].Panning);
|
||||
writer.WriteLine("Volume {0:X2}", Channels[i].Volume);
|
||||
writer.WriteLine("Enabled {0}", Channels[i].Enabled);
|
||||
ser.BeginSection("Channel"+i);
|
||||
ser.Sync("Frequency", ref Channels[i].Frequency);
|
||||
ser.Sync("Panning", ref Channels[i].Panning);
|
||||
ser.Sync("Volume", ref Channels[i].Volume);
|
||||
ser.Sync("Enabled", ref Channels[i].Enabled);
|
||||
if (i.In(4, 5))
|
||||
{
|
||||
writer.WriteLine("NoiseChannel {0}", Channels[i].NoiseChannel);
|
||||
writer.WriteLine("NoiseFreq {0:X4}", Channels[i].NoiseFreq);
|
||||
ser.Sync("NoiseChannel", ref Channels[i].NoiseChannel);
|
||||
ser.Sync("NoiseFreq", ref Channels[i].NoiseFreq);
|
||||
}
|
||||
writer.WriteLine("DDA {0}", Channels[i].DDA);
|
||||
writer.WriteLine("DDAValue {0:X4}", Channels[i].DDAValue);
|
||||
writer.WriteLine("SampleOffset {0}", Channels[i].SampleOffset);
|
||||
writer.Write("Wave ");
|
||||
Channels[i].Wave.SaveAsHex(writer);
|
||||
writer.WriteLine("[/Channel{0}]\n", i + 1);
|
||||
|
||||
ser.Sync("DDA", ref Channels[i].DDA);
|
||||
ser.Sync("DDAValue", ref Channels[i].DDAValue);
|
||||
ser.Sync("SampleOffset", ref Channels[i].SampleOffset);
|
||||
ser.Sync("Wave", ref Channels[i].Wave, false);
|
||||
ser.EndSection();
|
||||
}
|
||||
|
||||
writer.WriteLine("[/PSG]\n");
|
||||
}
|
||||
|
||||
public void LoadStateText(TextReader reader)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
string[] args = reader.ReadLine().Split(' ');
|
||||
if (args[0].Trim() == "") continue;
|
||||
if (args[0] == "[/PSG]") break;
|
||||
if (args[0] == "MainVolumeLeft")
|
||||
MainVolumeLeft = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "MainVolumeRight")
|
||||
MainVolumeRight = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "VoiceLatch")
|
||||
VoiceLatch = byte.Parse(args[1]);
|
||||
else if (args[0] == "WaveTableWriteOffset")
|
||||
WaveTableWriteOffset = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "[Channel1]")
|
||||
LoadChannelStateText(reader, 0);
|
||||
else if (args[0] == "[Channel2]")
|
||||
LoadChannelStateText(reader, 1);
|
||||
else if (args[0] == "[Channel3]")
|
||||
LoadChannelStateText(reader, 2);
|
||||
else if (args[0] == "[Channel4]")
|
||||
LoadChannelStateText(reader, 3);
|
||||
else if (args[0] == "[Channel5]")
|
||||
LoadChannelStateText(reader, 4);
|
||||
else if (args[0] == "[Channel6]")
|
||||
LoadChannelStateText(reader, 5);
|
||||
else
|
||||
Console.WriteLine("Skipping unrecognized identifier " + args[0]);
|
||||
}
|
||||
}
|
||||
|
||||
void LoadChannelStateText(TextReader reader, int channel)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
string[] args = reader.ReadLine().Split(' ');
|
||||
if (args[0].Trim() == "") continue;
|
||||
if (args[0] == "[/Channel" + (channel + 1) + "]") break;
|
||||
if (args[0] == "Frequency")
|
||||
Channels[channel].Frequency = ushort.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "Panning")
|
||||
Channels[channel].Panning = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "Volume")
|
||||
Channels[channel].Volume = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "Enabled")
|
||||
Channels[channel].Enabled = bool.Parse(args[1]);
|
||||
else if (args[0] == "NoiseChannel")
|
||||
Channels[channel].NoiseChannel = bool.Parse(args[1]);
|
||||
else if (args[0] == "NoiseFreq")
|
||||
Channels[channel].NoiseFreq = ushort.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "DDA")
|
||||
Channels[channel].DDA = bool.Parse(args[1]);
|
||||
else if (args[0] == "DDAValue")
|
||||
Channels[channel].DDAValue = short.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "SampleOffset")
|
||||
Channels[channel].SampleOffset = float.Parse(args[1]);
|
||||
else if (args[0] == "Wave")
|
||||
Channels[channel].Wave.ReadFromHex(args[1]);
|
||||
else
|
||||
Console.WriteLine("Skipping unrecognized identifier " + args[0]);
|
||||
}
|
||||
}
|
||||
|
||||
public void SaveStateBinary(BinaryWriter writer)
|
||||
{
|
||||
writer.Write(MainVolumeLeft);
|
||||
writer.Write(MainVolumeRight);
|
||||
writer.Write(VoiceLatch);
|
||||
writer.Write(WaveTableWriteOffset);
|
||||
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
writer.Write(Channels[i].Frequency);
|
||||
writer.Write(Channels[i].Panning);
|
||||
writer.Write(Channels[i].Volume);
|
||||
writer.Write(Channels[i].Enabled);
|
||||
writer.Write(Channels[i].NoiseChannel);
|
||||
writer.Write(Channels[i].NoiseFreq);
|
||||
writer.Write(Channels[i].DDA);
|
||||
writer.Write(Channels[i].DDAValue);
|
||||
writer.Write(Channels[i].SampleOffset);
|
||||
for (int j = 0; j < 32; j++)
|
||||
writer.Write(Channels[i].Wave[j]);
|
||||
}
|
||||
}
|
||||
|
||||
public void LoadStateBinary(BinaryReader reader)
|
||||
{
|
||||
MainVolumeLeft = reader.ReadByte();
|
||||
MainVolumeRight = reader.ReadByte();
|
||||
VoiceLatch = reader.ReadByte();
|
||||
WaveTableWriteOffset = reader.ReadByte();
|
||||
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
Channels[i].Frequency = reader.ReadUInt16();
|
||||
Channels[i].Panning = reader.ReadByte();
|
||||
Channels[i].Volume = reader.ReadByte();
|
||||
Channels[i].Enabled = reader.ReadBoolean();
|
||||
Channels[i].NoiseChannel = reader.ReadBoolean();
|
||||
Channels[i].NoiseFreq = reader.ReadUInt16();
|
||||
Channels[i].DDA = reader.ReadBoolean();
|
||||
Channels[i].DDAValue = reader.ReadInt16();
|
||||
Channels[i].SampleOffset = reader.ReadSingle();
|
||||
for (int j = 0; j < 32; j++)
|
||||
Channels[i].Wave[j] = reader.ReadInt16();
|
||||
}
|
||||
ser.EndSection();
|
||||
}
|
||||
|
||||
class QueuedCommand
|
||||
|
|
|
|||
|
|
@ -68,160 +68,35 @@ namespace BizHawk.Emulation.Cores.Components.H6280
|
|||
public byte TimerValue;
|
||||
public bool TimerEnabled;
|
||||
|
||||
public void SaveStateText(TextWriter writer)
|
||||
public void SyncState(Serializer ser)
|
||||
{
|
||||
writer.WriteLine("[HuC6280]");
|
||||
writer.WriteLine("A {0:X2}", A);
|
||||
writer.WriteLine("X {0:X2}", X);
|
||||
writer.WriteLine("Y {0:X2}", Y);
|
||||
writer.WriteLine("P {0:X2}", P);
|
||||
writer.WriteLine("PC {0:X4}", PC);
|
||||
writer.WriteLine("S {0:X2}", S);
|
||||
writer.Write("MPR ");
|
||||
MPR.SaveAsHex(writer);
|
||||
writer.WriteLine("LagIFlag {0}", LagIFlag);
|
||||
writer.WriteLine("IRQ1Assert {0}", IRQ1Assert);
|
||||
writer.WriteLine("IRQ2Assert {0}", IRQ2Assert);
|
||||
writer.WriteLine("TimerAssert {0}", TimerAssert);
|
||||
writer.WriteLine("IRQControlByte {0:X2}", IRQControlByte);
|
||||
writer.WriteLine("IRQNextControlByte {0:X2}", IRQNextControlByte);
|
||||
writer.WriteLine("ExecutedCycles {0}", TotalExecutedCycles);
|
||||
writer.WriteLine("PendingCycles {0}", PendingCycles);
|
||||
writer.WriteLine("LowSpeed {0}", LowSpeed);
|
||||
writer.WriteLine("TimerTickCounter {0}", TimerTickCounter);
|
||||
writer.WriteLine("TimerReloadValue {0}", TimerReloadValue);
|
||||
writer.WriteLine("TimerValue {0}", TimerValue);
|
||||
writer.WriteLine("TimerEnabled {0}", TimerEnabled);
|
||||
writer.WriteLine("InBlockTransfer {0}", InBlockTransfer);
|
||||
writer.WriteLine("BTFrom {0}", btFrom);
|
||||
writer.WriteLine("BTTo {0}", btTo);
|
||||
writer.WriteLine("BTLen {0}", btLen);
|
||||
writer.WriteLine("BTAlternator {0}", btAlternator);
|
||||
writer.WriteLine("[/HuC6280]\n");
|
||||
}
|
||||
|
||||
public void LoadStateText(TextReader reader)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
string[] args = reader.ReadLine().Split(' ');
|
||||
if (args[0].Trim() == "") continue;
|
||||
if (args[0] == "[/HuC6280]") break;
|
||||
if (args[0] == "A")
|
||||
A = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "X")
|
||||
X = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "Y")
|
||||
Y = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "P")
|
||||
P = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "PC")
|
||||
PC = ushort.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "S")
|
||||
S = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "MPR")
|
||||
MPR.ReadFromHex(args[1]);
|
||||
else if (args[0] == "LagIFlag")
|
||||
LagIFlag = bool.Parse(args[1]);
|
||||
else if (args[0] == "IRQ1Assert")
|
||||
IRQ1Assert = bool.Parse(args[1]);
|
||||
else if (args[0] == "IRQ2Assert")
|
||||
IRQ2Assert = bool.Parse(args[1]);
|
||||
else if (args[0] == "TimerAssert")
|
||||
TimerAssert = bool.Parse(args[1]);
|
||||
else if (args[0] == "IRQControlByte")
|
||||
IRQControlByte = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "IRQNextControlByte")
|
||||
IRQNextControlByte = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "ExecutedCycles")
|
||||
TotalExecutedCycles = long.Parse(args[1]);
|
||||
else if (args[0] == "PendingCycles")
|
||||
PendingCycles = int.Parse(args[1]);
|
||||
else if (args[0] == "LowSpeed")
|
||||
LowSpeed = bool.Parse(args[1]);
|
||||
else if (args[0] == "TimerTickCounter")
|
||||
TimerTickCounter = int.Parse(args[1]);
|
||||
else if (args[0] == "TimerReloadValue")
|
||||
TimerReloadValue = byte.Parse(args[1]);
|
||||
else if (args[0] == "TimerValue")
|
||||
TimerValue = byte.Parse(args[1]);
|
||||
else if (args[0] == "TimerEnabled")
|
||||
TimerEnabled = bool.Parse(args[1]);
|
||||
else if (args[0] == "InBlockTransfer")
|
||||
InBlockTransfer = bool.Parse(args[1]);
|
||||
else if (args[0] == "BTFrom")
|
||||
btFrom = ushort.Parse(args[1]);
|
||||
else if (args[0] == "BTTo")
|
||||
btTo = ushort.Parse(args[1]);
|
||||
else if (args[0] == "BTLen")
|
||||
btLen = ushort.Parse(args[1]);
|
||||
else if (args[0] == "BTAlternator")
|
||||
btAlternator = int.Parse(args[1]);
|
||||
else
|
||||
Console.WriteLine("Skipping unrecognized identifier " + args[0]);
|
||||
}
|
||||
}
|
||||
|
||||
public void SaveStateBinary(BinaryWriter writer)
|
||||
{
|
||||
writer.Write(A);
|
||||
writer.Write(X);
|
||||
writer.Write(Y);
|
||||
writer.Write(P);
|
||||
writer.Write(PC);
|
||||
writer.Write(S);
|
||||
writer.Write(MPR);
|
||||
writer.Write(LagIFlag);
|
||||
writer.Write(IRQ1Assert);
|
||||
writer.Write(IRQ2Assert);
|
||||
writer.Write(TimerAssert);
|
||||
writer.Write(IRQControlByte);
|
||||
writer.Write(IRQNextControlByte);
|
||||
writer.Write(TotalExecutedCycles);
|
||||
writer.Write(PendingCycles);
|
||||
writer.Write(LowSpeed);
|
||||
|
||||
writer.Write(TimerTickCounter);
|
||||
writer.Write(TimerReloadValue);
|
||||
writer.Write(TimerValue);
|
||||
writer.Write(TimerEnabled);
|
||||
|
||||
writer.Write(InBlockTransfer);
|
||||
writer.Write(btFrom);
|
||||
writer.Write(btTo);
|
||||
writer.Write(btLen);
|
||||
writer.Write((byte)btAlternator);
|
||||
}
|
||||
|
||||
public void LoadStateBinary(BinaryReader reader)
|
||||
{
|
||||
A = reader.ReadByte();
|
||||
X = reader.ReadByte();
|
||||
Y = reader.ReadByte();
|
||||
P = reader.ReadByte();
|
||||
PC = reader.ReadUInt16();
|
||||
S = reader.ReadByte();
|
||||
MPR = reader.ReadBytes(8);
|
||||
LagIFlag = reader.ReadBoolean();
|
||||
IRQ1Assert = reader.ReadBoolean();
|
||||
IRQ2Assert = reader.ReadBoolean();
|
||||
TimerAssert = reader.ReadBoolean();
|
||||
IRQControlByte = reader.ReadByte();
|
||||
IRQNextControlByte = reader.ReadByte();
|
||||
TotalExecutedCycles = reader.ReadInt64();
|
||||
PendingCycles = reader.ReadInt32();
|
||||
LowSpeed = reader.ReadBoolean();
|
||||
|
||||
TimerTickCounter = reader.ReadInt32();
|
||||
TimerReloadValue = reader.ReadByte();
|
||||
TimerValue = reader.ReadByte();
|
||||
TimerEnabled = reader.ReadBoolean();
|
||||
|
||||
InBlockTransfer = reader.ReadBoolean();
|
||||
btFrom = reader.ReadUInt16();
|
||||
btTo = reader.ReadUInt16();
|
||||
btLen = reader.ReadUInt16();
|
||||
btAlternator = reader.ReadByte();
|
||||
ser.BeginSection("HuC6280");
|
||||
ser.Sync("A", ref A);
|
||||
ser.Sync("X", ref X);
|
||||
ser.Sync("Y", ref Y);
|
||||
ser.Sync("P", ref P);
|
||||
ser.Sync("PC", ref PC);
|
||||
ser.Sync("S", ref S);
|
||||
ser.Sync("MPR", ref MPR, false);
|
||||
ser.Sync("LagIFlag", ref LagIFlag);
|
||||
ser.Sync("IRQ1Assert", ref IRQ1Assert);
|
||||
ser.Sync("IRQ2Assert", ref IRQ2Assert);
|
||||
ser.Sync("TimerAssert", ref TimerAssert);
|
||||
ser.Sync("IRQControlByte", ref IRQControlByte);
|
||||
ser.Sync("IRQNextControlByte", ref IRQNextControlByte);
|
||||
ser.Sync("ExecutedCycles", ref TotalExecutedCycles);
|
||||
ser.Sync("PendingCycles", ref PendingCycles);
|
||||
ser.Sync("LowSpeed", ref LowSpeed);
|
||||
ser.Sync("TimerTickCounter", ref TimerTickCounter);
|
||||
ser.Sync("TimerReloadValue", ref TimerReloadValue);
|
||||
ser.Sync("TimerValue", ref TimerValue);
|
||||
ser.Sync("TimerEnabled", ref TimerEnabled);
|
||||
ser.Sync("InBlockTransfer", ref InBlockTransfer);
|
||||
ser.Sync("BTFrom", ref btFrom);
|
||||
ser.Sync("BTTo", ref btTo);
|
||||
ser.Sync("BTLen", ref btLen);
|
||||
ser.Sync("BTAlternator", ref btAlternator);
|
||||
ser.EndSection();
|
||||
}
|
||||
|
||||
// ==== Interrupts ====
|
||||
|
|
|
|||
|
|
@ -28,9 +28,9 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
|
||||
// ***************************************************************************
|
||||
|
||||
public bool AdpcmIsPlaying { get; private set; }
|
||||
public bool HalfReached { get; private set; }
|
||||
public bool EndReached { get; private set; }
|
||||
public bool AdpcmIsPlaying;
|
||||
public bool HalfReached;
|
||||
public bool EndReached;
|
||||
public bool AdpcmBusyWriting { get { return AdpcmCdDmaRequested; } }
|
||||
public bool AdpcmBusyReading { get { return ReadPending; } }
|
||||
public bool AdpcmCdDmaRequested { get { return (Port180B & 3) != 0; } }
|
||||
|
|
@ -321,162 +321,42 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
|
||||
// ***************************************************************************
|
||||
|
||||
public void SaveStateBinary(BinaryWriter writer)
|
||||
public void SyncState(Serializer ser)
|
||||
{
|
||||
writer.Write(RAM);
|
||||
writer.Write(IOAddress);
|
||||
writer.Write(AdpcmLength);
|
||||
writer.Write(ReadAddress);
|
||||
writer.Write((byte)ReadTimer);
|
||||
writer.Write(ReadBuffer);
|
||||
writer.Write(ReadPending);
|
||||
writer.Write(WriteAddress);
|
||||
writer.Write((byte)WriteTimer);
|
||||
writer.Write(WriteBuffer);
|
||||
writer.Write(WritePending);
|
||||
ser.BeginSection("ADPCM");
|
||||
ser.Sync("RAM", ref RAM, false);
|
||||
ser.Sync("IOAddress", ref IOAddress);
|
||||
ser.Sync("AdpcmLength", ref AdpcmLength);
|
||||
ser.Sync("ReadAddress", ref ReadAddress);
|
||||
ser.Sync("ReadTimer", ref ReadTimer);
|
||||
ser.Sync("ReadPending", ref ReadPending);
|
||||
ser.Sync("WriteAddress", ref WriteAddress);
|
||||
ser.Sync("WriteTimer", ref WriteTimer);
|
||||
ser.Sync("WriteBuffer", ref WriteBuffer);
|
||||
ser.Sync("WritePending", ref WritePending);
|
||||
|
||||
writer.Write(Port180B);
|
||||
writer.Write(Port180D);
|
||||
writer.Write(Port180E);
|
||||
ser.Sync("Port180B", ref Port180B);
|
||||
ser.Sync("Port180D", ref Port180D);
|
||||
ser.Sync("Port180E", ref port180E);
|
||||
|
||||
writer.Write(AdpcmIsPlaying);
|
||||
writer.Write(HalfReached);
|
||||
writer.Write(EndReached);
|
||||
ser.Sync("AdpcmIsPlaying", ref AdpcmIsPlaying);
|
||||
ser.Sync("HalfReached", ref HalfReached);
|
||||
ser.Sync("EndReached", ref EndReached);
|
||||
|
||||
writer.Write(Playback44khzTimer);
|
||||
writer.Write((ushort)playingSample);
|
||||
writer.Write(nextSampleTimer);
|
||||
writer.Write(nibble);
|
||||
writer.Write((byte)magnitude);
|
||||
}
|
||||
ser.Sync("Playback44khzTimer", ref Playback44khzTimer);
|
||||
ser.Sync("PlayingSample", ref playingSample);
|
||||
ser.Sync("NextSampleTimer", ref nextSampleTimer);
|
||||
ser.Sync("Nibble", ref nibble);
|
||||
ser.Sync("Magnitude", ref magnitude);
|
||||
ser.EndSection();
|
||||
|
||||
public void LoadStateBinary(BinaryReader reader)
|
||||
{
|
||||
RAM = reader.ReadBytes(0x10000);
|
||||
IOAddress = reader.ReadUInt16();
|
||||
AdpcmLength = reader.ReadUInt16();
|
||||
ReadAddress = reader.ReadUInt16();
|
||||
ReadTimer = reader.ReadByte();
|
||||
ReadBuffer = reader.ReadByte();
|
||||
ReadPending = reader.ReadBoolean();
|
||||
WriteAddress = reader.ReadUInt16();
|
||||
WriteTimer = reader.ReadByte();
|
||||
WriteBuffer = reader.ReadByte();
|
||||
WritePending = reader.ReadBoolean();
|
||||
|
||||
Port180B = reader.ReadByte();
|
||||
Port180D = reader.ReadByte();
|
||||
Port180E = reader.ReadByte();
|
||||
|
||||
AdpcmIsPlaying = reader.ReadBoolean();
|
||||
HalfReached = reader.ReadBoolean();
|
||||
EndReached = reader.ReadBoolean();
|
||||
|
||||
Playback44khzTimer = reader.ReadSingle();
|
||||
playingSample = reader.ReadUInt16();
|
||||
nextSampleTimer = reader.ReadSingle();
|
||||
nibble = reader.ReadBoolean();
|
||||
magnitude = reader.ReadByte();
|
||||
|
||||
pce.IntADPCM = HalfReached;
|
||||
pce.IntStop = EndReached;
|
||||
pce.RefreshIRQ2();
|
||||
}
|
||||
|
||||
public void SaveStateText(TextWriter writer)
|
||||
{
|
||||
writer.WriteLine("[ADPCM]");
|
||||
writer.Write("RAM ");
|
||||
RAM.SaveAsHex(writer);
|
||||
writer.WriteLine("IOAddress {0:X4}", IOAddress);
|
||||
writer.WriteLine("AdpcmLength {0:X4}", AdpcmLength);
|
||||
writer.WriteLine("ReadAddress {0:X4}", ReadAddress);
|
||||
writer.WriteLine("ReadTimer {0}", ReadTimer);
|
||||
writer.WriteLine("ReadBuffer {0:X2}", ReadBuffer);
|
||||
writer.WriteLine("ReadPending {0}", ReadPending);
|
||||
writer.WriteLine("WriteAddress {0:X4}", WriteAddress);
|
||||
writer.WriteLine("WriteTimer {0}", WriteTimer);
|
||||
writer.WriteLine("WriteBuffer {0:X2}", WriteBuffer);
|
||||
writer.WriteLine("WritePending {0}", WritePending);
|
||||
|
||||
writer.WriteLine("Port180B {0:X2}", Port180B);
|
||||
writer.WriteLine("Port180D {0:X2}", Port180D);
|
||||
writer.WriteLine("Port180E {0:X2}", Port180E);
|
||||
|
||||
writer.WriteLine("AdpcmIsPlaying {0}", AdpcmIsPlaying);
|
||||
writer.WriteLine("HalfReached {0}", HalfReached);
|
||||
writer.WriteLine("EndReached {0}", EndReached);
|
||||
|
||||
writer.WriteLine("Playback44khzTimer {0}", Playback44khzTimer);
|
||||
writer.WriteLine("PlayingSample {0:X4}", playingSample);
|
||||
writer.WriteLine("NextSampleTimer {0}", nextSampleTimer);
|
||||
writer.WriteLine("FirstNibble {0}", nibble);
|
||||
writer.WriteLine("Magnitude {0}", magnitude);
|
||||
writer.WriteLine("[/ADPCM]\n");
|
||||
}
|
||||
|
||||
public void LoadStateText(TextReader reader)
|
||||
{
|
||||
while (true)
|
||||
if (ser.IsReader)
|
||||
{
|
||||
string[] args = reader.ReadLine().Split(' ');
|
||||
if (args[0].Trim() == "") continue;
|
||||
if (args[0] == "[/ADPCM]") break;
|
||||
if (args[0] == "RAM")
|
||||
RAM.ReadFromHex(args[1]);
|
||||
else if (args[0] == "IOAddress")
|
||||
IOAddress = ushort.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "AdpcmLength")
|
||||
AdpcmLength = ushort.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "ReadAddress")
|
||||
ReadAddress = ushort.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "ReadTimer")
|
||||
ReadTimer = int.Parse(args[1]);
|
||||
else if (args[0] == "ReadBuffer")
|
||||
ReadBuffer = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "ReadPending")
|
||||
ReadPending = bool.Parse(args[1]);
|
||||
else if (args[0] == "WriteAddress")
|
||||
WriteAddress = ushort.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "WriteTimer")
|
||||
WriteTimer = int.Parse(args[1]);
|
||||
else if (args[0] == "WriteBuffer")
|
||||
WriteBuffer = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "WritePending")
|
||||
WritePending = bool.Parse(args[1]);
|
||||
|
||||
else if (args[0] == "Port180B")
|
||||
Port180B = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "Port180D")
|
||||
Port180D = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "Port180E")
|
||||
Port180E = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
|
||||
else if (args[0] == "AdpcmIsPlaying")
|
||||
AdpcmIsPlaying = bool.Parse(args[1]);
|
||||
else if (args[0] == "HalfReached")
|
||||
HalfReached = bool.Parse(args[1]);
|
||||
else if (args[0] == "EndReached")
|
||||
EndReached = bool.Parse(args[1]);
|
||||
|
||||
else if (args[0] == "Playback44khzTimer")
|
||||
Playback44khzTimer = float.Parse(args[1]);
|
||||
else if (args[0] == "PlayingSample")
|
||||
playingSample = ushort.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "NextSampleTimer")
|
||||
nextSampleTimer = float.Parse(args[1]);
|
||||
else if (args[0] == "FirstNibble")
|
||||
nibble = bool.Parse(args[1]);
|
||||
else if (args[0] == "Magnitude")
|
||||
magnitude = int.Parse(args[1]);
|
||||
|
||||
else
|
||||
Console.WriteLine("Skipping unrecognized identifier " + args[0]);
|
||||
Port180E = port180E;
|
||||
pce.IntADPCM = HalfReached;
|
||||
pce.IntStop = EndReached;
|
||||
pce.RefreshIRQ2();
|
||||
}
|
||||
|
||||
pce.IntADPCM = HalfReached;
|
||||
pce.IntStop = EndReached;
|
||||
pce.RefreshIRQ2();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -135,82 +135,27 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
return 0xFF;
|
||||
}
|
||||
|
||||
void SaveArcadeCardBinary(BinaryWriter writer)
|
||||
public void ArcadeCardSyncState(Serializer ser)
|
||||
{
|
||||
writer.Write(ShiftRegister);
|
||||
writer.Write(ShiftAmount);
|
||||
writer.Write(RotateAmount);
|
||||
ser.BeginSection("ArcadeCard");
|
||||
ser.Sync("ShiftRegister", ref ShiftRegister);
|
||||
ser.Sync("ShiftAmount", ref ShiftAmount);
|
||||
ser.Sync("RotateAmount", ref RotateAmount);
|
||||
|
||||
if (ArcadeCardRewindHack == false || ser.IsText)
|
||||
ser.Sync("ArcadeRAM", ref ArcadeRam, false);
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
writer.Write(ArcadePage[i].Control);
|
||||
writer.Write(ArcadePage[i].Base);
|
||||
writer.Write(ArcadePage[i].Offset);
|
||||
writer.Write(ArcadePage[i].IncrementValue);
|
||||
}
|
||||
if (ArcadeCardRewindHack == false)
|
||||
writer.Write(ArcadeRam);
|
||||
}
|
||||
ser.BeginSection("Page" + i);
|
||||
|
||||
void LoadArcadeCardBinary(BinaryReader reader)
|
||||
{
|
||||
ShiftRegister = reader.ReadInt32();
|
||||
ShiftAmount = reader.ReadByte();
|
||||
RotateAmount = reader.ReadByte();
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
ArcadePage[i].Control = reader.ReadByte();
|
||||
ArcadePage[i].Base = reader.ReadInt32();
|
||||
ArcadePage[i].Offset = reader.ReadUInt16();
|
||||
ArcadePage[i].IncrementValue = reader.ReadUInt16();
|
||||
}
|
||||
if (ArcadeCardRewindHack == false)
|
||||
ArcadeRam = reader.ReadBytes(0x200000);
|
||||
}
|
||||
|
||||
void SaveArcadeCardText(TextWriter writer)
|
||||
{
|
||||
writer.WriteLine("[ArcadeCard]");
|
||||
writer.WriteLine("ShiftRegister {0} ", ShiftRegister);
|
||||
writer.WriteLine("RotateAmount {0} ", ShiftAmount);
|
||||
writer.WriteLine("RotateAmount {0} ", RotateAmount);
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
writer.WriteLine("Control {0} {1:X2}", i, ArcadePage[i].Control);
|
||||
writer.WriteLine("Base {0} {1:X6}", i, ArcadePage[i].Base);
|
||||
writer.WriteLine("Offset {0} {1:X4}", i, ArcadePage[i].Offset);
|
||||
writer.WriteLine("Increment {0} {1:X4}", i, ArcadePage[i].IncrementValue);
|
||||
}
|
||||
writer.Write("RAM "); ArcadeRam.SaveAsHex(writer);
|
||||
writer.WriteLine("[/ArcadeCard]");
|
||||
writer.WriteLine();
|
||||
}
|
||||
|
||||
public void LoadArcadeCardText(TextReader reader)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
string[] args = reader.ReadLine().Split(' ');
|
||||
if (args[0].Trim() == "") continue;
|
||||
if (args[0] == "[/ArcadeCard]") break;
|
||||
if (args[0] == "ShiftRegister")
|
||||
ShiftRegister = int.Parse(args[1]);
|
||||
else if (args[0] == "ShiftAmount")
|
||||
ShiftAmount = byte.Parse(args[1]);
|
||||
else if (args[0] == "RotateAmount")
|
||||
RotateAmount = byte.Parse(args[1]);
|
||||
else if (args[0] == "RAM")
|
||||
ArcadeRam.ReadFromHex(args[1]);
|
||||
else if (args[0] == "Control")
|
||||
ArcadePage[int.Parse(args[1])].Control = byte.Parse(args[2], NumberStyles.HexNumber);
|
||||
else if (args[0] == "Base")
|
||||
ArcadePage[int.Parse(args[1])].Base = int.Parse(args[2], NumberStyles.HexNumber);
|
||||
else if (args[0] == "Offset")
|
||||
ArcadePage[int.Parse(args[1])].Offset = ushort.Parse(args[2], NumberStyles.HexNumber);
|
||||
else if (args[0] == "Increment")
|
||||
ArcadePage[int.Parse(args[1])].IncrementValue = ushort.Parse(args[2], NumberStyles.HexNumber);
|
||||
else
|
||||
Console.WriteLine("Skipping unrecognized identifier " + args[0]);
|
||||
ser.Sync("Control", ref ArcadePage[i].Control);
|
||||
ser.Sync("Base", ref ArcadePage[i].Base);
|
||||
ser.Sync("Offset", ref ArcadePage[i].Offset);
|
||||
ser.Sync("IncrementValue", ref ArcadePage[i].IncrementValue);
|
||||
ser.EndSection();
|
||||
}
|
||||
ser.EndSection();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -271,22 +271,22 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
|
||||
Cpu.ResetPC();
|
||||
SetupMemoryDomains();
|
||||
SetupStateBuff();
|
||||
}
|
||||
|
||||
int _lagcount = 0;
|
||||
int lagCount;
|
||||
int frame;
|
||||
bool lagged = true;
|
||||
bool islag = false;
|
||||
public int Frame { get; set; }
|
||||
public int LagCount { get { return _lagcount; } set { _lagcount = value; } }
|
||||
public bool IsLagFrame { get { return islag; } }
|
||||
bool isLag = false;
|
||||
public int Frame { get { return frame; } set { frame = value; } }
|
||||
public int LagCount { get { return lagCount; } set { lagCount = value; } }
|
||||
public bool IsLagFrame { get { return isLag; } }
|
||||
|
||||
public void ResetCounters()
|
||||
{
|
||||
// this should just be a public setter instead of a new method.
|
||||
Frame = 0;
|
||||
_lagcount = 0;
|
||||
islag = false;
|
||||
lagCount = 0;
|
||||
isLag = false;
|
||||
}
|
||||
|
||||
public void FrameAdvance(bool render, bool rendersound)
|
||||
|
|
@ -310,11 +310,11 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
|
||||
if (lagged)
|
||||
{
|
||||
_lagcount++;
|
||||
islag = true;
|
||||
lagCount++;
|
||||
isLag = true;
|
||||
}
|
||||
else
|
||||
islag = false;
|
||||
isLag = false;
|
||||
}
|
||||
|
||||
void CheckSpriteLimit()
|
||||
|
|
@ -364,238 +364,79 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
}
|
||||
public bool SaveRamModified { get; set; }
|
||||
|
||||
public void SaveStateText(TextWriter writer)
|
||||
public bool BinarySaveStatesPreferred { get { return false; } }
|
||||
public void SaveStateBinary(BinaryWriter bw) { SyncState(Serializer.CreateBinaryWriter(bw)); }
|
||||
public void LoadStateBinary(BinaryReader br) { SyncState(Serializer.CreateBinaryReader(br)); }
|
||||
public void SaveStateText(TextWriter tw) { SyncState(Serializer.CreateTextWriter(tw)); }
|
||||
public void LoadStateText(TextReader tr) { SyncState(Serializer.CreateTextReader(tr)); }
|
||||
|
||||
void SyncState(Serializer ser)
|
||||
{
|
||||
writer.WriteLine("[PCEngine]");
|
||||
writer.Write("RAM ");
|
||||
Ram.SaveAsHex(writer);
|
||||
if (PopulousRAM != null)
|
||||
{
|
||||
writer.Write("PopulousRAM ");
|
||||
PopulousRAM.SaveAsHex(writer);
|
||||
}
|
||||
if (BRAM != null)
|
||||
{
|
||||
writer.Write("BRAM ");
|
||||
BRAM.SaveAsHex(writer);
|
||||
}
|
||||
writer.WriteLine("Frame {0}", Frame);
|
||||
writer.WriteLine("Lag {0}", _lagcount);
|
||||
writer.WriteLine("IsLag {0}", islag);
|
||||
if (Cpu.ReadMemory21 == ReadMemorySF2)
|
||||
writer.WriteLine("SF2MapperLatch " + SF2MapperLatch);
|
||||
writer.WriteLine("IOBuffer {0:X2}", IOBuffer);
|
||||
writer.Write("CdIoPorts "); CdIoPorts.SaveAsHex(writer);
|
||||
writer.WriteLine("BramLocked {0}", BramLocked);
|
||||
writer.WriteLine();
|
||||
ser.BeginSection("PCEngine");
|
||||
Cpu.SyncState(ser);
|
||||
VCE.SyncState(ser);
|
||||
VDC1.SyncState(ser, 1);
|
||||
PSG.SyncState(ser);
|
||||
|
||||
if (SuperGrafx)
|
||||
{
|
||||
Cpu.SaveStateText(writer);
|
||||
VPC.SaveStateText(writer);
|
||||
VCE.SaveStateText(writer);
|
||||
VDC1.SaveStateText(writer, 1);
|
||||
VDC2.SaveStateText(writer, 2);
|
||||
PSG.SaveStateText(writer);
|
||||
}
|
||||
else
|
||||
{
|
||||
Cpu.SaveStateText(writer);
|
||||
VCE.SaveStateText(writer);
|
||||
VDC1.SaveStateText(writer, 1);
|
||||
PSG.SaveStateText(writer);
|
||||
VPC.SyncState(ser);
|
||||
VDC2.SyncState(ser, 2);
|
||||
}
|
||||
|
||||
if (TurboCD)
|
||||
{
|
||||
writer.Write("CDRAM "); CDRam.SaveAsHex(writer);
|
||||
ADPCM.SyncState(ser);
|
||||
CDAudio.SyncState(ser);
|
||||
SCSI.SyncState(ser);
|
||||
|
||||
ser.Sync("CDRAM", ref CDRam, false);
|
||||
if (SuperRam != null)
|
||||
{ writer.Write("SuperRAM "); SuperRam.SaveAsHex(writer); }
|
||||
|
||||
writer.WriteLine();
|
||||
SCSI.SaveStateText(writer);
|
||||
CDAudio.SaveStateText(writer);
|
||||
ADPCM.SaveStateText(writer);
|
||||
}
|
||||
if (ArcadeCard)
|
||||
SaveArcadeCardText(writer);
|
||||
|
||||
writer.WriteLine("[/PCEngine]");
|
||||
}
|
||||
|
||||
public void LoadStateText(TextReader reader)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
string[] args = reader.ReadLine().Split(' ');
|
||||
if (args[0].Trim() == "") continue;
|
||||
if (args[0] == "[PCEngine]") continue;
|
||||
if (args[0] == "[/PCEngine]") break;
|
||||
if (args[0] == "Frame")
|
||||
Frame = int.Parse(args[1]);
|
||||
else if (args[0] == "Lag")
|
||||
_lagcount = int.Parse(args[1]);
|
||||
else if (args[0] == "IsLag")
|
||||
islag = bool.Parse(args[1]);
|
||||
else if (args[0] == "SF2MapperLatch")
|
||||
SF2MapperLatch = byte.Parse(args[1]);
|
||||
else if (args[0] == "IOBuffer")
|
||||
IOBuffer = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "CdIoPorts")
|
||||
{ CdIoPorts.ReadFromHex(args[1]); RefreshIRQ2(); }
|
||||
else if (args[0] == "BramLocked")
|
||||
BramLocked = bool.Parse(args[1]);
|
||||
else if (args[0] == "RAM")
|
||||
Ram.ReadFromHex(args[1]);
|
||||
else if (args[0] == "BRAM")
|
||||
BRAM.ReadFromHex(args[1]);
|
||||
else if (args[0] == "CDRAM")
|
||||
CDRam.ReadFromHex(args[1]);
|
||||
else if (args[0] == "SuperRAM")
|
||||
SuperRam.ReadFromHex(args[1]);
|
||||
else if (args[0] == "PopulousRAM" && PopulousRAM != null)
|
||||
PopulousRAM.ReadFromHex(args[1]);
|
||||
else if (args[0] == "[HuC6280]")
|
||||
Cpu.LoadStateText(reader);
|
||||
else if (args[0] == "[PSG]")
|
||||
PSG.LoadStateText(reader);
|
||||
else if (args[0] == "[VCE]")
|
||||
VCE.LoadStateText(reader);
|
||||
else if (args[0] == "[VPC]")
|
||||
VPC.LoadStateText(reader);
|
||||
else if (args[0] == "[VDC1]")
|
||||
VDC1.LoadStateText(reader, 1);
|
||||
else if (args[0] == "[VDC2]")
|
||||
VDC2.LoadStateText(reader, 2);
|
||||
else if (args[0] == "[SCSI]")
|
||||
SCSI.LoadStateText(reader);
|
||||
else if (args[0] == "[CDAudio]")
|
||||
CDAudio.LoadStateText(reader);
|
||||
else if (args[0] == "[ADPCM]")
|
||||
ADPCM.LoadStateText(reader);
|
||||
else if (args[0] == "[ArcadeCard]")
|
||||
LoadArcadeCardText(reader);
|
||||
else
|
||||
Console.WriteLine("Skipping unrecognized identifier " + args[0]);
|
||||
}
|
||||
}
|
||||
|
||||
public void SaveStateBinary(BinaryWriter writer)
|
||||
{
|
||||
if (SuperGrafx == false)
|
||||
{
|
||||
writer.Write(Ram);
|
||||
writer.Write(CdIoPorts);
|
||||
writer.Write(BramLocked);
|
||||
if (BRAM != null)
|
||||
writer.Write(BRAM);
|
||||
if (PopulousRAM != null)
|
||||
writer.Write(PopulousRAM);
|
||||
if (SuperRam != null)
|
||||
writer.Write(SuperRam);
|
||||
if (TurboCD)
|
||||
{
|
||||
writer.Write(CDRam);
|
||||
ADPCM.SaveStateBinary(writer);
|
||||
CDAudio.SaveStateBinary(writer);
|
||||
SCSI.SaveStateBinary(writer);
|
||||
}
|
||||
ser.Sync("SuperRAM", ref SuperRam, false);
|
||||
if (ArcadeCard)
|
||||
SaveArcadeCardBinary(writer);
|
||||
writer.Write(Frame);
|
||||
writer.Write(_lagcount);
|
||||
writer.Write(SF2MapperLatch);
|
||||
writer.Write(IOBuffer);
|
||||
Cpu.SaveStateBinary(writer);
|
||||
VCE.SaveStateBinary(writer);
|
||||
VDC1.SaveStateBinary(writer);
|
||||
PSG.SaveStateBinary(writer);
|
||||
}
|
||||
else
|
||||
{
|
||||
writer.Write(Ram);
|
||||
writer.Write(Frame);
|
||||
writer.Write(_lagcount);
|
||||
writer.Write(IOBuffer);
|
||||
Cpu.SaveStateBinary(writer);
|
||||
VCE.SaveStateBinary(writer);
|
||||
VPC.SaveStateBinary(writer);
|
||||
VDC1.SaveStateBinary(writer);
|
||||
VDC2.SaveStateBinary(writer);
|
||||
PSG.SaveStateBinary(writer);
|
||||
ArcadeCardSyncState(ser);
|
||||
}
|
||||
|
||||
ser.Sync("RAM", ref Ram, false);
|
||||
ser.Sync("IOBuffer", ref IOBuffer);
|
||||
ser.Sync("CdIoPorts", ref CdIoPorts, false);
|
||||
ser.Sync("BramLocked", ref BramLocked);
|
||||
|
||||
ser.Sync("Frame", ref frame);
|
||||
ser.Sync("Lag", ref lagCount);
|
||||
ser.Sync("IsLag", ref isLag);
|
||||
if (Cpu.ReadMemory21 == ReadMemorySF2)
|
||||
ser.Sync("SF2MapperLatch", ref SF2MapperLatch);
|
||||
if (PopulousRAM != null)
|
||||
ser.Sync("PopulousRAM", ref PopulousRAM, false);
|
||||
if (BRAM != null)
|
||||
ser.Sync("BRAM", ref BRAM, false);
|
||||
|
||||
ser.EndSection();
|
||||
}
|
||||
|
||||
public void LoadStateBinary(BinaryReader reader)
|
||||
{
|
||||
if (SuperGrafx == false)
|
||||
{
|
||||
Ram = reader.ReadBytes(0x2000);
|
||||
CdIoPorts = reader.ReadBytes(16); RefreshIRQ2();
|
||||
BramLocked = reader.ReadBoolean();
|
||||
if (BRAM != null)
|
||||
BRAM = reader.ReadBytes(0x800);
|
||||
if (PopulousRAM != null)
|
||||
PopulousRAM = reader.ReadBytes(0x8000);
|
||||
if (SuperRam != null)
|
||||
SuperRam = reader.ReadBytes(0x30000);
|
||||
if (TurboCD)
|
||||
{
|
||||
CDRam = reader.ReadBytes(0x10000);
|
||||
ADPCM.LoadStateBinary(reader);
|
||||
CDAudio.LoadStateBinary(reader);
|
||||
SCSI.LoadStateBinary(reader);
|
||||
}
|
||||
if (ArcadeCard)
|
||||
LoadArcadeCardBinary(reader);
|
||||
Frame = reader.ReadInt32();
|
||||
_lagcount = reader.ReadInt32();
|
||||
SF2MapperLatch = reader.ReadByte();
|
||||
IOBuffer = reader.ReadByte();
|
||||
Cpu.LoadStateBinary(reader);
|
||||
VCE.LoadStateBinary(reader);
|
||||
VDC1.LoadStateBinary(reader);
|
||||
PSG.LoadStateBinary(reader);
|
||||
}
|
||||
else
|
||||
{
|
||||
Ram = reader.ReadBytes(0x8000);
|
||||
Frame = reader.ReadInt32();
|
||||
_lagcount = reader.ReadInt32();
|
||||
IOBuffer = reader.ReadByte();
|
||||
Cpu.LoadStateBinary(reader);
|
||||
VCE.LoadStateBinary(reader);
|
||||
VPC.LoadStateBinary(reader);
|
||||
VDC1.LoadStateBinary(reader);
|
||||
VDC2.LoadStateBinary(reader);
|
||||
PSG.LoadStateBinary(reader);
|
||||
}
|
||||
}
|
||||
|
||||
byte[] SaveStateBinaryBuff;
|
||||
void SetupStateBuff()
|
||||
{
|
||||
int buflen = 75908;
|
||||
if (SuperGrafx) buflen += 90700;
|
||||
if (BramEnabled) buflen += 2048;
|
||||
if (PopulousRAM != null) buflen += 0x8000;
|
||||
if (SuperRam != null) buflen += 0x30000;
|
||||
if (TurboCD) buflen += 0x20000 + 2165;
|
||||
if (ArcadeCard) buflen += 42;
|
||||
if (ArcadeCard && !ArcadeCardRewindHack) buflen += 0x200000;
|
||||
SaveStateBinaryBuff = new byte[buflen];
|
||||
Console.WriteLine("PCE: Internal savestate buff of {0} allocated", buflen);
|
||||
}
|
||||
|
||||
byte[] stateBuffer;
|
||||
public byte[] SaveStateBinary()
|
||||
{
|
||||
var stream = new MemoryStream(SaveStateBinaryBuff);
|
||||
var writer = new BinaryWriter(stream);
|
||||
SaveStateBinary(writer);
|
||||
writer.Close();
|
||||
return SaveStateBinaryBuff;
|
||||
}
|
||||
|
||||
public bool BinarySaveStatesPreferred { get { return false; } }
|
||||
if (stateBuffer == null)
|
||||
{
|
||||
var stream = new MemoryStream();
|
||||
var writer = new BinaryWriter(stream);
|
||||
SaveStateBinary(writer);
|
||||
stateBuffer = stream.ToArray();
|
||||
writer.Close();
|
||||
return stateBuffer;
|
||||
}
|
||||
else
|
||||
{
|
||||
var stream = new MemoryStream(stateBuffer);
|
||||
var writer = new BinaryWriter(stream);
|
||||
SaveStateBinary(writer);
|
||||
writer.Close();
|
||||
return stateBuffer;
|
||||
}
|
||||
}
|
||||
|
||||
void SetupMemoryDomains()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -113,21 +113,18 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
rst = value;
|
||||
}
|
||||
}
|
||||
public byte DataBits { get; set; } // data bits
|
||||
public byte DataBits;
|
||||
|
||||
enum BusPhase
|
||||
{
|
||||
BusFree,
|
||||
Command,
|
||||
DataIn,
|
||||
DataOut,
|
||||
MessageIn,
|
||||
MessageOut,
|
||||
Status
|
||||
}
|
||||
const byte BusPhase_BusFree = 0;
|
||||
const byte BusPhase_Command = 1;
|
||||
const byte BusPhase_DataIn = 2;
|
||||
const byte BusPhase_DataOut = 3;
|
||||
const byte BusPhase_MessageIn = 4;
|
||||
const byte BusPhase_MessageOut = 5;
|
||||
const byte BusPhase_Status = 6;
|
||||
|
||||
bool busPhaseChanged;
|
||||
BusPhase Phase = BusPhase.BusFree;
|
||||
byte Phase = BusPhase_BusFree;
|
||||
|
||||
bool MessageCompleted;
|
||||
bool StatusCompleted;
|
||||
|
|
@ -196,7 +193,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
DataReadInProgress = false;
|
||||
DataTransferWasDone = true;
|
||||
}
|
||||
SetPhase(BusPhase.DataIn);
|
||||
SetPhase(BusPhase_DataIn);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -207,20 +204,20 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
|
||||
if (SEL && !BSY)
|
||||
{
|
||||
SetPhase(BusPhase.Command);
|
||||
SetPhase(BusPhase_Command);
|
||||
}
|
||||
else if (ATN && !REQ && !ACK)
|
||||
{
|
||||
SetPhase(BusPhase.MessageOut);
|
||||
SetPhase(BusPhase_MessageOut);
|
||||
}
|
||||
else switch (Phase)
|
||||
{
|
||||
case BusPhase.Command: ThinkCommandPhase(); break;
|
||||
case BusPhase.DataIn: ThinkDataInPhase(); break;
|
||||
case BusPhase.DataOut: ThinkDataOutPhase(); break;
|
||||
case BusPhase.MessageIn: ThinkMessageInPhase(); break;
|
||||
case BusPhase.MessageOut: ThinkMessageOutPhase(); break;
|
||||
case BusPhase.Status: ThinkStatusPhase(); break;
|
||||
case BusPhase_Command: ThinkCommandPhase(); break;
|
||||
case BusPhase_DataIn: ThinkDataInPhase(); break;
|
||||
case BusPhase_DataOut: ThinkDataOutPhase(); break;
|
||||
case BusPhase_MessageIn: ThinkMessageInPhase(); break;
|
||||
case BusPhase_MessageOut: ThinkMessageOutPhase(); break;
|
||||
case BusPhase_Status: ThinkStatusPhase(); break;
|
||||
default: break;
|
||||
}
|
||||
} while (signalsChanged || busPhaseChanged);
|
||||
|
|
@ -235,7 +232,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
ACK = false;
|
||||
ATN = false;
|
||||
DataBits = 0;
|
||||
Phase = BusPhase.BusFree;
|
||||
Phase = BusPhase_BusFree;
|
||||
|
||||
CommandBuffer.Clear();
|
||||
DataIn.Clear();
|
||||
|
|
@ -298,7 +295,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
void ThinkDataOutPhase()
|
||||
{
|
||||
Console.WriteLine("*********** DATA OUT PHASE, DOES THIS HAPPEN? ****************");
|
||||
SetPhase(BusPhase.BusFree);
|
||||
SetPhase(BusPhase_BusFree);
|
||||
}
|
||||
|
||||
void ThinkMessageInPhase()
|
||||
|
|
@ -312,14 +309,14 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
if (!REQ && !ACK && MessageCompleted)
|
||||
{
|
||||
MessageCompleted = false;
|
||||
SetPhase(BusPhase.BusFree);
|
||||
SetPhase(BusPhase_BusFree);
|
||||
}
|
||||
}
|
||||
|
||||
void ThinkMessageOutPhase()
|
||||
{
|
||||
Console.WriteLine("******* IN MESSAGE OUT PHASE. DOES THIS EVER HAPPEN? ********");
|
||||
SetPhase(BusPhase.BusFree);
|
||||
SetPhase(BusPhase_BusFree);
|
||||
}
|
||||
|
||||
void ThinkStatusPhase()
|
||||
|
|
@ -333,7 +330,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
{
|
||||
StatusCompleted = false;
|
||||
DataBits = MessageValue;
|
||||
SetPhase(BusPhase.MessageIn);
|
||||
SetPhase(BusPhase_MessageIn);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -470,17 +467,17 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
case 1: // play in loop mode. I guess this constitues A-B looping
|
||||
pce.CDAudio.PlayStartingAtLba(audioStartLBA);
|
||||
pce.CDAudio.EndLBA = audioEndLBA;
|
||||
pce.CDAudio.PlayMode = CDAudio.PlaybackMode.LoopOnCompletion;
|
||||
pce.CDAudio.PlayMode = CDAudio.PlaybackMode_LoopOnCompletion;
|
||||
break;
|
||||
case 2: // Play audio, fire IRQ2 when end position reached, maybe
|
||||
pce.CDAudio.PlayStartingAtLba(audioStartLBA);
|
||||
pce.CDAudio.EndLBA = audioEndLBA;
|
||||
pce.CDAudio.PlayMode = CDAudio.PlaybackMode.CallbackOnCompletion;
|
||||
pce.CDAudio.PlayMode = CDAudio.PlaybackMode_CallbackOnCompletion;
|
||||
break;
|
||||
case 3: // Play normal
|
||||
pce.CDAudio.PlayStartingAtLba(audioStartLBA);
|
||||
pce.CDAudio.EndLBA = audioEndLBA;
|
||||
pce.CDAudio.PlayMode = CDAudio.PlaybackMode.StopOnCompletion;
|
||||
pce.CDAudio.PlayMode = CDAudio.PlaybackMode_StopOnCompletion;
|
||||
break;
|
||||
}
|
||||
SetStatusMessage(STATUS_GOOD, 0);
|
||||
|
|
@ -494,16 +491,16 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
|
||||
void CommandReadSubcodeQ()
|
||||
{
|
||||
bool playing = pce.CDAudio.Mode != CDAudio.CDAudioMode.Stopped;
|
||||
bool playing = pce.CDAudio.Mode != CDAudio.CDAudioMode_Stopped;
|
||||
var sectorEntry = disc.ReadLBA_SectorEntry(playing ? pce.CDAudio.CurrentSector : CurrentReadingSector);
|
||||
|
||||
DataIn.Clear();
|
||||
|
||||
switch (pce.CDAudio.Mode)
|
||||
{
|
||||
case CDAudio.CDAudioMode.Playing: DataIn.Enqueue(0); break;
|
||||
case CDAudio.CDAudioMode.Paused: DataIn.Enqueue(2); break;
|
||||
case CDAudio.CDAudioMode.Stopped: DataIn.Enqueue(3); break;
|
||||
case CDAudio.CDAudioMode_Playing: DataIn.Enqueue(0); break;
|
||||
case CDAudio.CDAudioMode_Paused: DataIn.Enqueue(2); break;
|
||||
case CDAudio.CDAudioMode_Stopped: DataIn.Enqueue(3); break;
|
||||
}
|
||||
|
||||
DataIn.Enqueue(sectorEntry.q_status); // I do not know what status is
|
||||
|
|
@ -516,7 +513,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
DataIn.Enqueue(sectorEntry.q_asec.BCDValue); // S(abs)
|
||||
DataIn.Enqueue(sectorEntry.q_aframe.BCDValue); // F(abs)
|
||||
|
||||
SetPhase(BusPhase.DataIn);
|
||||
SetPhase(BusPhase_DataIn);
|
||||
}
|
||||
|
||||
void CommandReadTOC()
|
||||
|
|
@ -528,7 +525,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
DataIn.Clear();
|
||||
DataIn.Enqueue(0x01);
|
||||
DataIn.Enqueue(((byte)disc.TOC.Sessions[0].Tracks.Count).BinToBCD());
|
||||
SetPhase(BusPhase.DataIn);
|
||||
SetPhase(BusPhase_DataIn);
|
||||
break;
|
||||
}
|
||||
case 1: // return total disc length in minutes/seconds/frames
|
||||
|
|
@ -542,7 +539,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
DataIn.Enqueue(m.BinToBCD());
|
||||
DataIn.Enqueue(s.BinToBCD());
|
||||
DataIn.Enqueue(f.BinToBCD());
|
||||
SetPhase(BusPhase.DataIn);
|
||||
SetPhase(BusPhase_DataIn);
|
||||
break;
|
||||
}
|
||||
case 2: // Return starting position of specified track in MSF format
|
||||
|
|
@ -574,7 +571,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
DataIn.Enqueue(0);
|
||||
else
|
||||
DataIn.Enqueue(4);
|
||||
SetPhase(BusPhase.DataIn);
|
||||
SetPhase(BusPhase_DataIn);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
|
|
@ -589,10 +586,10 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
StatusCompleted = false;
|
||||
MessageCompleted = false;
|
||||
DataBits = status == STATUS_GOOD ? (byte)0x00 : (byte)0x01;
|
||||
SetPhase(BusPhase.Status);
|
||||
SetPhase(BusPhase_Status);
|
||||
}
|
||||
|
||||
void SetPhase(BusPhase phase)
|
||||
void SetPhase(byte phase)
|
||||
{
|
||||
if (Phase == phase)
|
||||
return;
|
||||
|
|
@ -602,7 +599,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
|
||||
switch (phase)
|
||||
{
|
||||
case BusPhase.BusFree:
|
||||
case BusPhase_BusFree:
|
||||
BSY = false;
|
||||
MSG = false;
|
||||
CD = false;
|
||||
|
|
@ -610,42 +607,42 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
REQ = false;
|
||||
pce.IntDataTransferComplete = false;
|
||||
break;
|
||||
case BusPhase.Command:
|
||||
case BusPhase_Command:
|
||||
BSY = true;
|
||||
MSG = false;
|
||||
CD = true;
|
||||
IO = false;
|
||||
REQ = true;
|
||||
break;
|
||||
case BusPhase.DataIn:
|
||||
case BusPhase_DataIn:
|
||||
BSY = true;
|
||||
MSG = false;
|
||||
CD = false;
|
||||
IO = true;
|
||||
REQ = false;
|
||||
break;
|
||||
case BusPhase.DataOut:
|
||||
case BusPhase_DataOut:
|
||||
BSY = true;
|
||||
MSG = false;
|
||||
CD = false;
|
||||
IO = false;
|
||||
REQ = true;
|
||||
break;
|
||||
case BusPhase.MessageIn:
|
||||
case BusPhase_MessageIn:
|
||||
BSY = true;
|
||||
MSG = true;
|
||||
CD = true;
|
||||
IO = true;
|
||||
REQ = true;
|
||||
break;
|
||||
case BusPhase.MessageOut:
|
||||
case BusPhase_MessageOut:
|
||||
BSY = true;
|
||||
MSG = true;
|
||||
CD = true;
|
||||
IO = false;
|
||||
REQ = true;
|
||||
break;
|
||||
case BusPhase.Status:
|
||||
case BusPhase_Status:
|
||||
BSY = true;
|
||||
MSG = false;
|
||||
CD = true;
|
||||
|
|
@ -657,191 +654,43 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
|
||||
// ***************************************************************************
|
||||
|
||||
public void SaveStateBinary(BinaryWriter writer)
|
||||
public void SyncState(Serializer ser)
|
||||
{
|
||||
writer.Write(BSY);
|
||||
writer.Write(SEL);
|
||||
writer.Write(CD);
|
||||
writer.Write(IO);
|
||||
writer.Write(MSG);
|
||||
writer.Write(REQ);
|
||||
writer.Write(ACK);
|
||||
writer.Write(ATN);
|
||||
writer.Write(RST);
|
||||
writer.Write(DataBits);
|
||||
writer.Write((byte)Phase);
|
||||
ser.BeginSection("SCSI");
|
||||
ser.Sync("BSY", ref bsy);
|
||||
ser.Sync("SEL", ref sel);
|
||||
ser.Sync("CD", ref cd);
|
||||
ser.Sync("IO", ref io);
|
||||
ser.Sync("MSG", ref msg);
|
||||
ser.Sync("REQ", ref req);
|
||||
ser.Sync("ACK", ref ack);
|
||||
ser.Sync("ATN", ref atn);
|
||||
ser.Sync("RST", ref rst);
|
||||
ser.Sync("DataBits", ref DataBits);
|
||||
ser.Sync("Phase", ref Phase);
|
||||
|
||||
writer.Write(MessageCompleted);
|
||||
writer.Write(StatusCompleted);
|
||||
writer.Write(MessageValue);
|
||||
ser.Sync("MessageCompleted", ref MessageCompleted);
|
||||
ser.Sync("StatusCompleted", ref StatusCompleted);
|
||||
ser.Sync("MessageValue", ref MessageValue);
|
||||
|
||||
writer.Write(DataReadWaitTimer);
|
||||
writer.Write(DataReadInProgress);
|
||||
writer.Write(DataTransferWasDone);
|
||||
writer.Write(DataTransferInProgress);
|
||||
writer.Write(CurrentReadingSector);
|
||||
writer.Write((byte)SectorsLeftToRead);
|
||||
ser.Sync("DataReadWaitTimer", ref DataReadWaitTimer);
|
||||
ser.Sync("DataReadInProgress", ref DataReadInProgress);
|
||||
ser.Sync("DataTransferWasDone", ref DataTransferWasDone);
|
||||
ser.Sync("DataTransferInProgress", ref DataTransferInProgress);
|
||||
ser.Sync("CurrentReadingSector", ref CurrentReadingSector);
|
||||
ser.Sync("SectorsLeftToRead", ref SectorsLeftToRead);
|
||||
|
||||
writer.Write(CommandBuffer.buffer);
|
||||
writer.Write((byte)CommandBuffer.Position);
|
||||
ser.Sync("CommandBuffer", ref CommandBuffer.buffer, false);
|
||||
ser.Sync("CommandBufferPosition", ref CommandBuffer.Position);
|
||||
|
||||
writer.Write(DataIn.buffer);
|
||||
writer.Write((short)DataIn.head);
|
||||
writer.Write((short)DataIn.tail);
|
||||
writer.Write((short)DataIn.size);
|
||||
ser.Sync("DataInBuffer", ref DataIn.buffer, false);
|
||||
ser.Sync("DataInHead", ref DataIn.head);
|
||||
ser.Sync("DataInTail", ref DataIn.tail);
|
||||
ser.Sync("DataInSize", ref DataIn.size);
|
||||
|
||||
writer.Write(audioStartLBA);
|
||||
writer.Write(audioEndLBA);
|
||||
}
|
||||
|
||||
public void LoadStateBinary(BinaryReader reader)
|
||||
{
|
||||
BSY = reader.ReadBoolean();
|
||||
SEL = reader.ReadBoolean();
|
||||
CD = reader.ReadBoolean();
|
||||
IO = reader.ReadBoolean();
|
||||
MSG = reader.ReadBoolean();
|
||||
REQ = reader.ReadBoolean();
|
||||
ACK = reader.ReadBoolean();
|
||||
ATN = reader.ReadBoolean();
|
||||
RST = reader.ReadBoolean();
|
||||
DataBits = reader.ReadByte();
|
||||
Phase = (BusPhase)Enum.ToObject(typeof(BusPhase), reader.ReadByte());
|
||||
|
||||
MessageCompleted = reader.ReadBoolean();
|
||||
StatusCompleted = reader.ReadBoolean();
|
||||
MessageValue = reader.ReadByte();
|
||||
|
||||
DataReadWaitTimer = reader.ReadInt64();
|
||||
DataReadInProgress = reader.ReadBoolean();
|
||||
DataTransferWasDone = reader.ReadBoolean();
|
||||
DataTransferInProgress = reader.ReadBoolean();
|
||||
CurrentReadingSector = reader.ReadInt32();
|
||||
SectorsLeftToRead = reader.ReadByte();
|
||||
|
||||
CommandBuffer.buffer = reader.ReadBytes(10);
|
||||
CommandBuffer.Position = reader.ReadByte();
|
||||
|
||||
DataIn.buffer = reader.ReadBytes(2048);
|
||||
DataIn.head = reader.ReadInt16();
|
||||
DataIn.tail = reader.ReadInt16();
|
||||
DataIn.size = reader.ReadInt16();
|
||||
|
||||
audioStartLBA = reader.ReadInt32();
|
||||
audioEndLBA = reader.ReadInt32();
|
||||
}
|
||||
|
||||
public void SaveStateText(TextWriter writer)
|
||||
{
|
||||
writer.WriteLine("[SCSI]");
|
||||
writer.WriteLine("BSY {0}", BSY);
|
||||
writer.WriteLine("SEL {0}", SEL);
|
||||
writer.WriteLine("CD {0}", CD);
|
||||
writer.WriteLine("IO {0}", IO);
|
||||
writer.WriteLine("MSG {0}", MSG);
|
||||
writer.WriteLine("REQ {0}", REQ);
|
||||
writer.WriteLine("ACK {0}", ACK);
|
||||
writer.WriteLine("ATN {0}", ATN);
|
||||
writer.WriteLine("RST {0}", RST);
|
||||
writer.WriteLine("DataBits {0:X2}", DataBits);
|
||||
writer.WriteLine("BusPhase " + Enum.GetName(typeof(BusPhase), Phase));
|
||||
writer.WriteLine();
|
||||
writer.WriteLine("MessageCompleted {0}", MessageCompleted);
|
||||
writer.WriteLine("StatusCompleted {0}", StatusCompleted);
|
||||
writer.WriteLine("MessageValue {0}", MessageValue);
|
||||
writer.WriteLine();
|
||||
writer.WriteLine("DataReadWaitTimer {0}", DataReadWaitTimer);
|
||||
writer.WriteLine("DataReadInProgress {0}", DataReadInProgress);
|
||||
writer.WriteLine("DataTransferWasDone {0}", DataTransferWasDone);
|
||||
writer.WriteLine("DataTransferInProgress {0}", DataTransferInProgress);
|
||||
writer.WriteLine("CurrentReadingSector {0}", CurrentReadingSector);
|
||||
writer.WriteLine("SectorsLeftToRead {0}", SectorsLeftToRead);
|
||||
writer.WriteLine();
|
||||
writer.WriteLine("AudioStartLBA {0}", audioStartLBA);
|
||||
writer.WriteLine("AudioEndLBA {0}", audioEndLBA);
|
||||
writer.WriteLine();
|
||||
writer.Write("CommandBuffer "); CommandBuffer.buffer.SaveAsHex(writer);
|
||||
writer.WriteLine("CommandBufferPosition {0}", CommandBuffer.Position);
|
||||
writer.WriteLine();
|
||||
writer.Write("DataInBuffer "); DataIn.buffer.SaveAsHex(writer);
|
||||
writer.WriteLine("DataInHead {0}", DataIn.head);
|
||||
writer.WriteLine("DataInTail {0}", DataIn.tail);
|
||||
writer.WriteLine("DataInSize {0}", DataIn.size);
|
||||
writer.WriteLine("[/SCSI]\n");
|
||||
}
|
||||
|
||||
public void LoadStateText(TextReader reader)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
string[] args = reader.ReadLine().Split(' ');
|
||||
if (args[0].Trim() == "") continue;
|
||||
if (args[0] == "[/SCSI]") break;
|
||||
if (args[0] == "BSY")
|
||||
BSY = bool.Parse(args[1]);
|
||||
else if (args[0] == "SEL")
|
||||
SEL = bool.Parse(args[1]);
|
||||
else if (args[0] == "CD")
|
||||
CD = bool.Parse(args[1]);
|
||||
else if (args[0] == "IO")
|
||||
IO = bool.Parse(args[1]);
|
||||
else if (args[0] == "MSG")
|
||||
MSG = bool.Parse(args[1]);
|
||||
else if (args[0] == "REQ")
|
||||
REQ = bool.Parse(args[1]);
|
||||
else if (args[0] == "ACK")
|
||||
ACK = bool.Parse(args[1]);
|
||||
else if (args[0] == "ATN")
|
||||
ATN = bool.Parse(args[1]);
|
||||
else if (args[0] == "RST")
|
||||
RST = bool.Parse(args[1]);
|
||||
else if (args[0] == "DataBits")
|
||||
DataBits = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "BusPhase")
|
||||
Phase = (BusPhase)Enum.Parse(typeof(BusPhase), args[1]);
|
||||
|
||||
else if (args[0] == "MessageCompleted")
|
||||
MessageCompleted = bool.Parse(args[1]);
|
||||
else if (args[0] == "StatusCompleted")
|
||||
StatusCompleted = bool.Parse(args[1]);
|
||||
else if (args[0] == "MessageValue")
|
||||
MessageValue = byte.Parse(args[1]);
|
||||
|
||||
else if (args[0] == "DataReadWaitTimer")
|
||||
DataReadWaitTimer = long.Parse(args[1]);
|
||||
else if (args[0] == "DataReadInProgress")
|
||||
DataReadInProgress = bool.Parse(args[1]);
|
||||
else if (args[0] == "DataTransferWasDone")
|
||||
DataTransferWasDone = bool.Parse(args[1]);
|
||||
else if (args[0] == "DataTransferInProgress")
|
||||
DataTransferInProgress = bool.Parse(args[1]);
|
||||
else if (args[0] == "CurrentReadingSector")
|
||||
CurrentReadingSector = int.Parse(args[1]);
|
||||
else if (args[0] == "SectorsLeftToRead")
|
||||
SectorsLeftToRead = int.Parse(args[1]);
|
||||
|
||||
else if (args[0] == "AudioStartLBA")
|
||||
audioStartLBA = int.Parse(args[1]);
|
||||
else if (args[0] == "AudioEndLBA")
|
||||
audioEndLBA = int.Parse(args[1]);
|
||||
|
||||
else if (args[0] == "CommandBuffer")
|
||||
CommandBuffer.buffer.ReadFromHex(args[1]);
|
||||
else if (args[0] == "CommandBufferPosition")
|
||||
CommandBuffer.Position = int.Parse(args[1]);
|
||||
|
||||
else if (args[0] == "DataInBuffer")
|
||||
DataIn.buffer.ReadFromHex(args[1]);
|
||||
else if (args[0] == "DataInHead")
|
||||
DataIn.head = int.Parse(args[1]);
|
||||
else if (args[0] == "DataInTail")
|
||||
DataIn.tail = int.Parse(args[1]);
|
||||
else if (args[0] == "DataInSize")
|
||||
DataIn.size = int.Parse(args[1]);
|
||||
|
||||
else
|
||||
Console.WriteLine("Skipping unrecognized identifier " + args[0]);
|
||||
}
|
||||
ser.Sync("AudioStartLBA", ref audioStartLBA);
|
||||
ser.Sync("AudioEndLBA", ref audioEndLBA);
|
||||
ser.EndSection();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -15,23 +15,6 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
public byte CR;
|
||||
|
||||
public int NumberOfScanlines { get { return ((CR & 4) != 0) ? 263 : 262; } }
|
||||
public int DotClock
|
||||
{
|
||||
get
|
||||
{
|
||||
int clock = CR & 3;
|
||||
if (clock == 3)
|
||||
clock = 2;
|
||||
return clock;
|
||||
}
|
||||
}
|
||||
|
||||
// guess the dot clock affects wait states in combination with the dot with regs.
|
||||
// We dont currently emulate wait states, probably will have to eventually...
|
||||
|
||||
// Note: To keep the VCE class from needing a reference to the CPU, the 1-cycle access
|
||||
// penalty for the VCE is handled by the memory mappers.
|
||||
// One day I guess I could create an ICpu with a StealCycles method...
|
||||
|
||||
public void WriteVCE(int port, byte value)
|
||||
{
|
||||
|
|
@ -91,54 +74,17 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
Palette[slot] = Colors.ARGB(r, g, b);
|
||||
}
|
||||
|
||||
public void SaveStateText(TextWriter writer)
|
||||
public void SyncState(Serializer ser)
|
||||
{
|
||||
writer.WriteLine("[VCE]");
|
||||
writer.WriteLine("VceAddress {0:X4}", VceAddress);
|
||||
writer.WriteLine("CR {0}", CR);
|
||||
writer.Write("VceData ");
|
||||
VceData.SaveAsHex(writer);
|
||||
writer.WriteLine("[/VCE]\n");
|
||||
}
|
||||
ser.BeginSection("VCE");
|
||||
ser.Sync("VceAddress", ref VceAddress);
|
||||
ser.Sync("CR", ref CR);
|
||||
ser.Sync("VceData", ref VceData, false);
|
||||
ser.EndSection();
|
||||
|
||||
public void LoadStateText(TextReader reader)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
string[] args = reader.ReadLine().Split(' ');
|
||||
if (args[0].Trim() == "") continue;
|
||||
if (args[0] == "[/VCE]") break;
|
||||
if (args[0] == "VceAddress")
|
||||
VceAddress = ushort.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "CR")
|
||||
CR = byte.Parse(args[1]);
|
||||
else if (args[0] == "VceData")
|
||||
VceData.ReadFromHex(args[1]);
|
||||
else
|
||||
Console.WriteLine("Skipping unrecognized identifier " + args[0]);
|
||||
}
|
||||
|
||||
for (int i = 0; i < VceData.Length; i++)
|
||||
PrecomputePalette(i);
|
||||
}
|
||||
|
||||
public void SaveStateBinary(BinaryWriter writer)
|
||||
{
|
||||
writer.Write(VceAddress);
|
||||
writer.Write(CR);
|
||||
for (int i = 0; i < VceData.Length; i++)
|
||||
writer.Write(VceData[i]);
|
||||
}
|
||||
|
||||
public void LoadStateBinary(BinaryReader reader)
|
||||
{
|
||||
VceAddress = reader.ReadUInt16();
|
||||
CR = reader.ReadByte();
|
||||
for (int i = 0; i < VceData.Length; i++)
|
||||
{
|
||||
VceData[i] = reader.ReadUInt16();
|
||||
PrecomputePalette(i);
|
||||
}
|
||||
if (ser.IsReader)
|
||||
for (int i = 0; i < VceData.Length; i++)
|
||||
PrecomputePalette(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -300,131 +300,37 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
}
|
||||
}
|
||||
|
||||
public void SaveStateText(TextWriter writer, int vdcNo)
|
||||
public void SyncState(Serializer ser, int vdcNo)
|
||||
{
|
||||
writer.WriteLine("[VDC" + vdcNo + "]");
|
||||
writer.Write("VRAM ");
|
||||
VRAM.SaveAsHex(writer);
|
||||
writer.Write("SAT ");
|
||||
SpriteAttributeTable.SaveAsHex(writer);
|
||||
writer.Write("Registers ");
|
||||
Registers.SaveAsHex(writer);
|
||||
ser.BeginSection("VDC"+vdcNo);
|
||||
ser.Sync("VRAM", ref VRAM, false);
|
||||
ser.Sync("SAT", ref SpriteAttributeTable, false);
|
||||
ser.Sync("Registers", ref Registers, false);
|
||||
ser.Sync("RegisterLatch", ref RegisterLatch);
|
||||
ser.Sync("ReadBuffer", ref ReadBuffer);
|
||||
ser.Sync("StatusByte", ref StatusByte);
|
||||
|
||||
writer.WriteLine("RegisterLatch {0:X2}", RegisterLatch);
|
||||
writer.WriteLine("ReadBuffer {0:X4}", ReadBuffer);
|
||||
writer.WriteLine("StatusByte {0:X2}", StatusByte);
|
||||
ser.Sync("DmaRequested", ref DmaRequested);
|
||||
ser.Sync("SatDmaRequested", ref SatDmaRequested);
|
||||
ser.Sync("SatDmaPerformed", ref SatDmaPerformed);
|
||||
|
||||
writer.WriteLine("DmaRequested {0}", DmaRequested);
|
||||
writer.WriteLine("SatDmaRequested {0}", SatDmaRequested);
|
||||
writer.WriteLine("SatDmaPerformed {0}", SatDmaPerformed);
|
||||
ser.Sync("ScanLine", ref ScanLine);
|
||||
ser.Sync("BackgroundY", ref BackgroundY);
|
||||
ser.Sync("RCRCounter", ref RCRCounter);
|
||||
ser.Sync("ActiveLine", ref ActiveLine);
|
||||
ser.EndSection();
|
||||
|
||||
writer.WriteLine("ScanLine {0}", ScanLine);
|
||||
writer.WriteLine("BackgroundY {0}", BackgroundY);
|
||||
writer.WriteLine("RCRCounter {0}", RCRCounter);
|
||||
writer.WriteLine("ActiveLine {0}", ActiveLine);
|
||||
|
||||
writer.WriteLine("[/VDC" + vdcNo + "]\n");
|
||||
}
|
||||
|
||||
public void LoadStateText(TextReader reader, int vdcNo)
|
||||
{
|
||||
while (true)
|
||||
if (ser.IsReader)
|
||||
{
|
||||
string[] args = reader.ReadLine().Split(' ');
|
||||
if (args[0].Trim() == "") continue;
|
||||
if (args[0] == "[/VDC" + vdcNo + "]") break;
|
||||
if (args[0] == "VRAM")
|
||||
VRAM.ReadFromHex(args[1]);
|
||||
else if (args[0] == "SAT")
|
||||
SpriteAttributeTable.ReadFromHex(args[1]);
|
||||
else if (args[0] == "Registers")
|
||||
Registers.ReadFromHex(args[1]);
|
||||
else if (args[0] == "RegisterLatch")
|
||||
RegisterLatch = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "ReadBuffer")
|
||||
ReadBuffer = ushort.Parse(args[1], NumberStyles.HexNumber);
|
||||
else if (args[0] == "StatusByte")
|
||||
StatusByte = byte.Parse(args[1], NumberStyles.HexNumber);
|
||||
for (ushort i = 0; i < VRAM.Length; i++)
|
||||
{
|
||||
UpdatePatternData(i);
|
||||
UpdateSpriteData(i);
|
||||
}
|
||||
|
||||
else if (args[0] == "DmaRequested")
|
||||
DmaRequested = bool.Parse(args[1]);
|
||||
else if (args[0] == "SatDmaRequested")
|
||||
SatDmaRequested = bool.Parse(args[1]);
|
||||
else if (args[0] == "SatDmaPerformed")
|
||||
SatDmaPerformed = bool.Parse(args[1]);
|
||||
|
||||
else if (args[0] == "ScanLine")
|
||||
ScanLine = int.Parse(args[1]);
|
||||
else if (args[0] == "BackgroundY")
|
||||
BackgroundY = int.Parse(args[1]);
|
||||
else if (args[0] == "RCRCounter")
|
||||
RCRCounter = int.Parse(args[1]);
|
||||
else if (args[0] == "ActiveLine")
|
||||
ActiveLine = int.Parse(args[1]);
|
||||
|
||||
else
|
||||
Console.WriteLine("Skipping unrecognized identifier " + args[0]);
|
||||
CompleteMSBWrite(HDR);
|
||||
CompleteMSBWrite(VDW);
|
||||
}
|
||||
|
||||
for (ushort i = 0; i < VRAM.Length; i++)
|
||||
{
|
||||
UpdatePatternData(i);
|
||||
UpdateSpriteData(i);
|
||||
}
|
||||
|
||||
CompleteMSBWrite(HDR);
|
||||
CompleteMSBWrite(VDW);
|
||||
}
|
||||
|
||||
public void SaveStateBinary(BinaryWriter writer)
|
||||
{
|
||||
for (int i = 0; i < VRAM.Length; i++)
|
||||
writer.Write(VRAM[i]);
|
||||
for (int i = 0; i < SpriteAttributeTable.Length; i++)
|
||||
writer.Write(SpriteAttributeTable[i]);
|
||||
for (int i = 0; i < Registers.Length; i++)
|
||||
writer.Write(Registers[i]);
|
||||
writer.Write(RegisterLatch);
|
||||
writer.Write(ReadBuffer);
|
||||
writer.Write(StatusByte);
|
||||
|
||||
writer.Write(DmaRequested);
|
||||
writer.Write(SatDmaRequested);
|
||||
writer.Write(SatDmaPerformed);
|
||||
|
||||
writer.Write(ScanLine);
|
||||
writer.Write(BackgroundY);
|
||||
writer.Write(RCRCounter);
|
||||
writer.Write(ActiveLine);
|
||||
}
|
||||
|
||||
public void LoadStateBinary(BinaryReader reader)
|
||||
{
|
||||
for (ushort i = 0; i < VRAM.Length; i++)
|
||||
{
|
||||
VRAM[i] = reader.ReadUInt16();
|
||||
UpdatePatternData(i);
|
||||
UpdateSpriteData(i);
|
||||
}
|
||||
for (int i = 0; i < SpriteAttributeTable.Length; i++)
|
||||
SpriteAttributeTable[i] = reader.ReadUInt16();
|
||||
for (int i = 0; i < Registers.Length; i++)
|
||||
Registers[i] = reader.ReadUInt16();
|
||||
RegisterLatch = reader.ReadByte();
|
||||
ReadBuffer = reader.ReadUInt16();
|
||||
StatusByte = reader.ReadByte();
|
||||
|
||||
DmaRequested = reader.ReadBoolean();
|
||||
SatDmaRequested = reader.ReadBoolean();
|
||||
SatDmaPerformed = reader.ReadBoolean();
|
||||
|
||||
ScanLine = reader.ReadInt32();
|
||||
BackgroundY = reader.ReadInt32();
|
||||
RCRCounter = reader.ReadInt32();
|
||||
ActiveLine = reader.ReadInt32();
|
||||
|
||||
CompleteMSBWrite(HDR);
|
||||
CompleteMSBWrite(VDW);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -80,38 +80,14 @@ namespace BizHawk.Emulation.Cores.PCEngine
|
|||
}
|
||||
}
|
||||
|
||||
public void SaveStateBinary(BinaryWriter writer)
|
||||
public void SyncState(Serializer ser)
|
||||
{
|
||||
writer.Write(Registers);
|
||||
}
|
||||
ser.BeginSection("VPC");
|
||||
ser.Sync("Registers", ref Registers, false);
|
||||
ser.EndSection();
|
||||
|
||||
public void LoadStateBinary(BinaryReader reader)
|
||||
{
|
||||
Registers = reader.ReadBytes(7);
|
||||
WriteVPC(0x0E, Registers[6]);
|
||||
}
|
||||
|
||||
public void SaveStateText(TextWriter writer)
|
||||
{
|
||||
writer.WriteLine("[VPC]");
|
||||
writer.Write("Registers ");
|
||||
Registers.SaveAsHex(writer);
|
||||
writer.WriteLine("[/VPC]\n");
|
||||
}
|
||||
|
||||
public void LoadStateText(TextReader reader)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
string[] args = reader.ReadLine().Split(' ');
|
||||
if (args[0].Trim() == "") continue;
|
||||
if (args[0] == "[/VPC]") break;
|
||||
if (args[0] == "Registers")
|
||||
Registers.ReadFromHex(args[1]);
|
||||
else
|
||||
Console.WriteLine("Skipping unrecognized identifier " + args[0]);
|
||||
}
|
||||
WriteVPC(0x0E, Registers[6]);
|
||||
if (ser.IsReader)
|
||||
WriteVPC(0x0E, Registers[6]);
|
||||
}
|
||||
|
||||
// We use a single priority mode for the whole frame.
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
using System;
|
||||
using System.IO;
|
||||
|
||||
using BizHawk.Common;
|
||||
using BizHawk.Emulation.Common;
|
||||
|
||||
// The state of the cd player is quantized to the frame level.
|
||||
|
|
@ -12,26 +12,20 @@ namespace BizHawk.Emulation.DiscSystem
|
|||
{
|
||||
public sealed class CDAudio : ISoundProvider
|
||||
{
|
||||
public enum CDAudioMode
|
||||
{
|
||||
Stopped,
|
||||
Playing,
|
||||
Paused
|
||||
}
|
||||
public const byte CDAudioMode_Stopped = 0;
|
||||
public const byte CDAudioMode_Playing = 1;
|
||||
public const byte CDAudioMode_Paused = 2;
|
||||
|
||||
public enum PlaybackMode
|
||||
{
|
||||
StopOnCompletion,
|
||||
NextTrackOnCompletion,
|
||||
LoopOnCompletion,
|
||||
CallbackOnCompletion
|
||||
}
|
||||
public const byte PlaybackMode_StopOnCompletion = 0;
|
||||
public const byte PlaybackMode_NextTrackOnCompletion = 1;
|
||||
public const byte PlaybackMode_LoopOnCompletion = 2;
|
||||
public const byte PlaybackMode_CallbackOnCompletion = 3;
|
||||
|
||||
public Action CallbackAction = delegate { };
|
||||
|
||||
public Disc Disc;
|
||||
public CDAudioMode Mode = CDAudioMode.Stopped;
|
||||
public PlaybackMode PlayMode = PlaybackMode.LoopOnCompletion;
|
||||
public byte Mode = CDAudioMode_Stopped;
|
||||
public byte PlayMode = PlaybackMode_LoopOnCompletion;
|
||||
|
||||
public int MaxVolume { get; set; }
|
||||
public int LogicalVolume = 100;
|
||||
|
|
@ -62,7 +56,7 @@ namespace BizHawk.Emulation.DiscSystem
|
|||
PlayingTrack = track;
|
||||
CurrentSector = StartLBA;
|
||||
SectorOffset = 0;
|
||||
Mode = CDAudioMode.Playing;
|
||||
Mode = CDAudioMode_Playing;
|
||||
FadeOutOverFrames = 0;
|
||||
FadeOutFramesRemaining = 0;
|
||||
LogicalVolume = 100;
|
||||
|
|
@ -79,7 +73,7 @@ namespace BizHawk.Emulation.DiscSystem
|
|||
|
||||
CurrentSector = StartLBA;
|
||||
SectorOffset = 0;
|
||||
Mode = CDAudioMode.Playing;
|
||||
Mode = CDAudioMode_Playing;
|
||||
FadeOutOverFrames = 0;
|
||||
FadeOutFramesRemaining = 0;
|
||||
LogicalVolume = 100;
|
||||
|
|
@ -87,7 +81,7 @@ namespace BizHawk.Emulation.DiscSystem
|
|||
|
||||
public void Stop()
|
||||
{
|
||||
Mode = CDAudioMode.Stopped;
|
||||
Mode = CDAudioMode_Stopped;
|
||||
FadeOutOverFrames = 0;
|
||||
FadeOutFramesRemaining = 0;
|
||||
LogicalVolume = 100;
|
||||
|
|
@ -95,9 +89,9 @@ namespace BizHawk.Emulation.DiscSystem
|
|||
|
||||
public void Pause()
|
||||
{
|
||||
if (Mode != CDAudioMode.Playing)
|
||||
if (Mode != CDAudioMode_Playing)
|
||||
return;
|
||||
Mode = CDAudioMode.Paused;
|
||||
Mode = CDAudioMode_Paused;
|
||||
FadeOutOverFrames = 0;
|
||||
FadeOutFramesRemaining = 0;
|
||||
LogicalVolume = 100;
|
||||
|
|
@ -105,16 +99,16 @@ namespace BizHawk.Emulation.DiscSystem
|
|||
|
||||
public void Resume()
|
||||
{
|
||||
if (Mode != CDAudioMode.Paused)
|
||||
if (Mode != CDAudioMode_Paused)
|
||||
return;
|
||||
Mode = CDAudioMode.Playing;
|
||||
Mode = CDAudioMode_Playing;
|
||||
}
|
||||
|
||||
public void PauseResume()
|
||||
{
|
||||
if (Mode == CDAudioMode.Playing) Mode = CDAudioMode.Paused;
|
||||
else if (Mode == CDAudioMode.Paused) Mode = CDAudioMode.Playing;
|
||||
else if (Mode == CDAudioMode.Stopped) return;
|
||||
if (Mode == CDAudioMode_Playing) Mode = CDAudioMode_Paused;
|
||||
else if (Mode == CDAudioMode_Paused) Mode = CDAudioMode_Playing;
|
||||
else if (Mode == CDAudioMode_Stopped) return;
|
||||
}
|
||||
|
||||
public void FadeOut(int frames)
|
||||
|
|
@ -137,7 +131,7 @@ namespace BizHawk.Emulation.DiscSystem
|
|||
|
||||
public void GetSamples(short[] samples)
|
||||
{
|
||||
if (Mode != CDAudioMode.Playing)
|
||||
if (Mode != CDAudioMode_Playing)
|
||||
return;
|
||||
|
||||
if (FadeOutFramesRemaining > 0)
|
||||
|
|
@ -169,21 +163,21 @@ namespace BizHawk.Emulation.DiscSystem
|
|||
{
|
||||
switch (PlayMode)
|
||||
{
|
||||
case PlaybackMode.NextTrackOnCompletion:
|
||||
case PlaybackMode_NextTrackOnCompletion:
|
||||
PlayTrack(PlayingTrack + 1);
|
||||
break;
|
||||
|
||||
case PlaybackMode.StopOnCompletion:
|
||||
case PlaybackMode_StopOnCompletion:
|
||||
Stop();
|
||||
return;
|
||||
|
||||
case PlaybackMode.LoopOnCompletion:
|
||||
case PlaybackMode_LoopOnCompletion:
|
||||
CurrentSector = StartLBA;
|
||||
break;
|
||||
|
||||
case PlaybackMode.CallbackOnCompletion:
|
||||
case PlaybackMode_CallbackOnCompletion:
|
||||
CallbackAction();
|
||||
if (Mode != CDAudioMode.Playing)
|
||||
if (Mode != CDAudioMode_Playing)
|
||||
return;
|
||||
break;
|
||||
}
|
||||
|
|
@ -198,7 +192,7 @@ namespace BizHawk.Emulation.DiscSystem
|
|||
{
|
||||
get
|
||||
{
|
||||
if (Mode != CDAudioMode.Playing)
|
||||
if (Mode != CDAudioMode_Playing)
|
||||
return 0;
|
||||
|
||||
int offset = SectorOffset * 4;
|
||||
|
|
@ -211,7 +205,7 @@ namespace BizHawk.Emulation.DiscSystem
|
|||
{
|
||||
get
|
||||
{
|
||||
if (Mode != CDAudioMode.Playing)
|
||||
if (Mode != CDAudioMode_Playing)
|
||||
return 0;
|
||||
|
||||
int offset = SectorOffset * 4;
|
||||
|
|
@ -222,83 +216,23 @@ namespace BizHawk.Emulation.DiscSystem
|
|||
|
||||
public void DiscardSamples() { }
|
||||
|
||||
public void SaveStateText(TextWriter writer)
|
||||
public void SyncState(Serializer ser)
|
||||
{
|
||||
writer.WriteLine("[CDAudio]");
|
||||
writer.WriteLine("Mode " + Enum.GetName(typeof(CDAudioMode), Mode));
|
||||
writer.WriteLine("PlayMode " + Enum.GetName(typeof(PlaybackMode), PlayMode));
|
||||
writer.WriteLine("LogicalVolume {0}", LogicalVolume);
|
||||
writer.WriteLine("StartLBA {0}", StartLBA);
|
||||
writer.WriteLine("EndLBA {0}", EndLBA);
|
||||
writer.WriteLine("PlayingTrack {0}", PlayingTrack);
|
||||
writer.WriteLine("CurrentSector {0}", CurrentSector);
|
||||
writer.WriteLine("SectorOffset {0}", SectorOffset);
|
||||
writer.WriteLine("FadeOutOverFrames {0}", FadeOutOverFrames);
|
||||
writer.WriteLine("FadeOutFramesRemaining {0}", FadeOutFramesRemaining);
|
||||
writer.WriteLine("[/CDAudio]");
|
||||
writer.WriteLine();
|
||||
}
|
||||
ser.BeginSection("CDAudio");
|
||||
ser.Sync("Mode", ref Mode);
|
||||
ser.Sync("PlayMode", ref PlayMode);
|
||||
ser.Sync("LogicalVolume", ref LogicalVolume);
|
||||
ser.Sync("StartLBA", ref StartLBA);
|
||||
ser.Sync("EndLBA", ref EndLBA);
|
||||
ser.Sync("PlayingTrack", ref PlayingTrack);
|
||||
ser.Sync("CurrentSector", ref CurrentSector);
|
||||
ser.Sync("SectorOffset", ref SectorOffset);
|
||||
ser.Sync("FadeOutOverFrames", ref FadeOutOverFrames);
|
||||
ser.Sync("FadeOutFramesRemaining", ref FadeOutFramesRemaining);
|
||||
ser.EndSection();
|
||||
|
||||
public void LoadStateText(TextReader reader)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
string[] args = reader.ReadLine().Split(' ');
|
||||
if (args[0].Trim() == "") continue;
|
||||
if (args[0] == "[/CDAudio]") break;
|
||||
if (args[0] == "Mode")
|
||||
Mode = (CDAudioMode)Enum.Parse(typeof(CDAudioMode), args[1]);
|
||||
else if (args[0] == "PlayMode")
|
||||
PlayMode = (PlaybackMode)Enum.Parse(typeof(PlaybackMode), args[1]);
|
||||
else if (args[0] == "LogicalVolume")
|
||||
LogicalVolume = int.Parse(args[1]);
|
||||
else if (args[0] == "StartLBA")
|
||||
StartLBA = int.Parse(args[1]);
|
||||
else if (args[0] == "EndLBA")
|
||||
EndLBA = int.Parse(args[1]);
|
||||
else if (args[0] == "PlayingTrack")
|
||||
PlayingTrack = int.Parse(args[1]);
|
||||
else if (args[0] == "CurrentSector")
|
||||
CurrentSector = int.Parse(args[1]);
|
||||
else if (args[0] == "SectorOffset")
|
||||
SectorOffset = int.Parse(args[1]);
|
||||
else if (args[0] == "FadeOutOverFrames")
|
||||
FadeOutOverFrames = int.Parse(args[1]);
|
||||
else if (args[0] == "FadeOutFramesRemaining")
|
||||
FadeOutFramesRemaining = int.Parse(args[1]);
|
||||
|
||||
else
|
||||
Console.WriteLine("Skipping unrecognized identifier " + args[0]);
|
||||
}
|
||||
EnsureSector();
|
||||
}
|
||||
|
||||
public void SaveStateBinary(BinaryWriter writer)
|
||||
{
|
||||
writer.Write((byte)Mode);
|
||||
writer.Write((byte)PlayMode);
|
||||
writer.Write(LogicalVolume);
|
||||
writer.Write(CurrentSector);
|
||||
writer.Write(SectorOffset);
|
||||
writer.Write(StartLBA);
|
||||
writer.Write(EndLBA);
|
||||
writer.Write(PlayingTrack);
|
||||
writer.Write((short)FadeOutOverFrames);
|
||||
writer.Write((short)FadeOutFramesRemaining);
|
||||
}
|
||||
|
||||
public void LoadStateBinary(BinaryReader reader)
|
||||
{
|
||||
Mode = (CDAudioMode)reader.ReadByte();
|
||||
PlayMode = (PlaybackMode)reader.ReadByte();
|
||||
LogicalVolume = reader.ReadInt32();
|
||||
CurrentSector = reader.ReadInt32();
|
||||
SectorOffset = reader.ReadInt32();
|
||||
StartLBA = reader.ReadInt32();
|
||||
EndLBA = reader.ReadInt32();
|
||||
PlayingTrack = reader.ReadInt32();
|
||||
FadeOutOverFrames = reader.ReadInt16();
|
||||
FadeOutFramesRemaining = reader.ReadInt16();
|
||||
if (ser.IsReader)
|
||||
EnsureSector();
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue