Add in ISaveRam implementation for C64, using the deltas of disks.

Add in better docs for `DeltaSerializer`.
Fix C64 not remembering disk changes when swapping disks (swapping disks essentially just reset the disk previously)

Author: CasualPokePlayer

src/BizHawk.Client.Common/config/PathEntryCollection.cs

@@ -202,7 +202,7 @@ public void ResolveWithDefaults()
 
 			CommonEntriesFor(VSystemID.Raw.Arcade, basePath: Path.Combine(".", "Arcade")),
 
-			CommonEntriesFor(VSystemID.Raw.C64, basePath: Path.Combine(".", "C64"), omitSaveRAM: true),
+			CommonEntriesFor(VSystemID.Raw.C64, basePath: Path.Combine(".", "C64")),
 
 			CommonEntriesFor(VSystemID.Raw.ChannelF, basePath: Path.Combine(".", "Channel F"), omitSaveRAM: true),
 

src/BizHawk.Client.EmuHawk/MainForm.cs

@@ -26,6 +26,7 @@
 using BizHawk.Emulation.Cores;
 using BizHawk.Emulation.Cores.Arcades.MAME;
 using BizHawk.Emulation.Cores.Calculators.TI83;
+using BizHawk.Emulation.Cores.Computers.Commodore64;
 using BizHawk.Emulation.Cores.Consoles.NEC.PCE;
 using BizHawk.Emulation.Cores.Consoles.Nintendo.Ares64;
 using BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES;
@@ -1921,7 +1922,7 @@ private void LoadSaveRam()
 					byte[] sram;
 
 					// some cores might not know how big the saveram ought to be, so just send it the whole file
-					if (Emulator is MGBAHawk || Emulator is NeoGeoPort || (Emulator is NES && (Emulator as NES).BoardName == "FDS"))
+					if (Emulator is C64 or MGBAHawk or NeoGeoPort or NES { BoardName: "FDS" })
 					{
 						sram = File.ReadAllBytes(saveRamPath);
 					}

src/BizHawk.Common/DeltaSerializer.cs

@@ -5,30 +5,42 @@ namespace BizHawk.Common
 {
 	/// <summary>
 	/// Serializes deltas between data, mainly for ROM like structures which are actually writable, and therefore the differences need to be saved
-	/// Uses simple RLE encoding to keep the size down
+	/// Uses a simple delta format in order to keep size down
+	/// DELTA FORMAT DETAILS FOLLOWS
+	/// The format comprises of an indeterminate amount of blocks. These blocks start with a 4 byte header. This header is read as a native endian 32-bit two's complement signed integer.
+	/// If the header is positive, then the header indicates the amount of bytes which are identical between the original and current spans.
+	/// Positive headers are blocks by themselves, so the next header will proceed immediately after a positive header.
+	/// If the header is negative, then the header indicates the negation of the amount of bytes which differ between the original and current spans.
+	/// A negative header will have the negated header amount of bytes proceed it, which will be the bitwise XOR between the original and differing bytes.
+	/// A header of -0x80000000 is considered ill-formed.
+	/// This format does not stipulate requirements for whether blocks of non-differing bytes necessarily will use a positive header.
+	/// Thus, an implementation is free to use negative headers only, although without combination of positive headers, this will obviously not have great results wrt final size.
+	/// More practically, an implementation may want to avoid using positive headers when the block is rather small (e.g. smaller than the header itself, and thus not shrinking the result).
+	/// Subsequently, it may not mind putting some identical bytes within the negative header's block.
+	/// XORing the same values result in 0, so doing this will not leave trace of the original data.
 	/// </summary>
 	public static class DeltaSerializer
 	{
-		public static ReadOnlySpan<byte> GetDelta<T>(ReadOnlySpan<T> original, ReadOnlySpan<T> data)
+		public static ReadOnlySpan<byte> GetDelta<T>(ReadOnlySpan<T> original, ReadOnlySpan<T> current)
 			where T : unmanaged
 		{
 			var orignalAsBytes = MemoryMarshal.AsBytes(original);
-			var dataAsBytes = MemoryMarshal.AsBytes(data);
+			var currentAsBytes = MemoryMarshal.AsBytes(current);
 
-			if (orignalAsBytes.Length != dataAsBytes.Length)
+			if (orignalAsBytes.Length != currentAsBytes.Length)
 			{
-				throw new InvalidOperationException($"{nameof(orignalAsBytes.Length)} must equal {nameof(dataAsBytes.Length)}");
+				throw new InvalidOperationException($"{nameof(orignalAsBytes.Length)} must equal {nameof(currentAsBytes.Length)}");
 			}
 
 			var index = 0;
-			var end = dataAsBytes.Length;
+			var end = currentAsBytes.Length;
 			var ret = new byte[end + 4].AsSpan(); // worst case scenario size (i.e. everything is different)
 			var retSize = 0;
 
 			while (index < end)
 			{
 				var blockStart = index;
-				while (index < end && orignalAsBytes[index] == dataAsBytes[index])
+				while (index < end && orignalAsBytes[index] == currentAsBytes[index])
 				{
 					index++;
 				}
@@ -40,7 +52,7 @@ public static ReadOnlySpan<byte> GetDelta<T>(ReadOnlySpan<T> original, ReadOnlyS
 					var different = 0;
 					while (index < end && same < 8) // in case we hit end of span before, this does nothing and different is 0
 					{
-						if (orignalAsBytes[index] != dataAsBytes[index])
+						if (orignalAsBytes[index] != currentAsBytes[index])
 						{
 							different++;
 							same = 0; // note: same is set to 0 on first iteration
@@ -68,15 +80,15 @@ public static ReadOnlySpan<byte> GetDelta<T>(ReadOnlySpan<T> original, ReadOnlyS
 						retSize += 4;
 						for (var i = blockStart; i < index - same; i++)
 						{
-							ret[retSize++] = (byte)(orignalAsBytes[i] ^ dataAsBytes[i]);
+							ret[retSize++] = (byte)(orignalAsBytes[i] ^ currentAsBytes[i]);
 						}
 					}
 
 					if (same > 0) // same is 4-8, 8 indicates we hit the 8 same bytes threshold, 4-7 indicate hit end of span
 					{
 						if (same == 8)
 						{
-							while (index < end && orignalAsBytes[index] == dataAsBytes[index])
+							while (index < end && orignalAsBytes[index] == currentAsBytes[index])
 							{
 								index++;
 							}
@@ -97,19 +109,19 @@ public static ReadOnlySpan<byte> GetDelta<T>(ReadOnlySpan<T> original, ReadOnlyS
 			return ret.Slice(0, retSize);
 		}
 
-		public static void ApplyDelta<T>(ReadOnlySpan<T> original, Span<T> data, ReadOnlySpan<byte> delta)
+		public static void ApplyDelta<T>(ReadOnlySpan<T> original, Span<T> current, ReadOnlySpan<byte> delta)
 			where T : unmanaged
 		{
 			var orignalAsBytes = MemoryMarshal.AsBytes(original);
-			var dataAsBytes = MemoryMarshal.AsBytes(data);
+			var currentAsBytes = MemoryMarshal.AsBytes(current);
 
-			if (orignalAsBytes.Length != dataAsBytes.Length)
+			if (orignalAsBytes.Length != currentAsBytes.Length)
 			{
-				throw new InvalidOperationException($"{nameof(orignalAsBytes.Length)} must equal {nameof(dataAsBytes.Length)}");
+				throw new InvalidOperationException($"{nameof(orignalAsBytes.Length)} must equal {nameof(currentAsBytes.Length)}");
 			}
 
 			var dataPos = 0;
-			var dataEnd = dataAsBytes.Length;
+			var dataEnd = currentAsBytes.Length;
 			var deltaPos = 0;
 			var deltaEnd = delta.Length;
 
@@ -126,14 +138,14 @@ public static void ApplyDelta<T>(ReadOnlySpan<T> original, Span<T> data, ReadOnl
 				{
 					header = -header;
 
-					if (dataEnd - dataPos < header || deltaEnd - deltaPos < header)
+					if (header == int.MinValue || dataEnd - dataPos < header || deltaEnd - deltaPos < header)
 					{
 						throw new InvalidOperationException("Corrupt delta header!");
 					}
 
 					for (var i = 0; i < header; i++)
 					{
-						dataAsBytes[dataPos + i] = (byte)(orignalAsBytes[dataPos + i] ^ delta[deltaPos + i]);
+						currentAsBytes[dataPos + i] = (byte)(orignalAsBytes[dataPos + i] ^ delta[deltaPos + i]);
 					}
 
 					deltaPos += header;
@@ -145,7 +157,7 @@ public static void ApplyDelta<T>(ReadOnlySpan<T> original, Span<T> data, ReadOnl
 						throw new InvalidOperationException("Corrupt delta header!");
 					}
 
-					orignalAsBytes.Slice(dataPos, header).CopyTo(dataAsBytes.Slice(dataPos, header));
+					orignalAsBytes.Slice(dataPos, header).CopyTo(currentAsBytes.Slice(dataPos, header));
 				}
 
 				dataPos += header;

src/BizHawk.Common/Serializer.cs

@@ -748,18 +748,18 @@ public void SyncFixedString(string name, ref string val, int length)
 			}
 		}
 
-		public void SyncDelta<T>(string name, T[] original, T[] data)
+		public void SyncDelta<T>(string name, T[] original, T[] current)
 			where T : unmanaged
 		{
 			if (IsReader)
 			{
 				var delta = Array.Empty<byte>();
 				Sync(name, ref delta, useNull: false);
-				DeltaSerializer.ApplyDelta<T>(original, data, delta);
+				DeltaSerializer.ApplyDelta<T>(original, current, delta);
 			}
 			else
 			{
-				var delta = DeltaSerializer.GetDelta<T>(original, data).ToArray(); // TODO: don't create array here (need .net update to write span to binary writer)
+				var delta = DeltaSerializer.GetDelta<T>(original, current).ToArray(); // TODO: don't create array here (need .net update to write span to binary writer)
 				Sync(name, ref delta, useNull: false);
 			}
 		}

src/BizHawk.Emulation.Cores/Computers/Commodore64/C64.IStatable.cs

@@ -15,7 +15,8 @@ private void SyncState(Serializer ser)
 			ser.Sync(nameof(CurrentDisk), ref _currentDisk);
 			if (oldDisk != _currentDisk)
 			{
-				InitDisk();
+				// don't use InitDisk here, no need to load in soon to be overwritten deltas
+				InitMedia(_roms[_currentDisk]);
 			}
 			ser.Sync("PreviousDiskPressed", ref _prevPressed);
 			ser.Sync("NextDiskPressed", ref _nextPressed);

src/BizHawk.Emulation.Cores/Computers/Commodore64/C64.Motherboard.cs

@@ -129,7 +129,7 @@ public Motherboard(C64 c64, C64.VicType initRegion, C64.BorderType borderType, C
 			{
 				case C64.DiskDriveType.Commodore1541:
 				case C64.DiskDriveType.Commodore1541II:
-					DiskDrive = new Drive1541(ClockNumerator, ClockDenominator);
+					DiskDrive = new Drive1541(ClockNumerator, ClockDenominator, () => _c64.CurrentDisk);
 					Serial.Connect(DiskDrive);
 					break;
 			}

src/BizHawk.Emulation.Cores/Computers/Commodore64/C64.cs

@@ -30,6 +30,12 @@ public C64(CoreLoadParameters<C64Settings, C64SyncSettings> lp)
 			_cyclesPerFrame = _board.Vic.CyclesPerFrame;
 			_memoryCallbacks = new MemoryCallbackSystem(new[] { "System Bus" });
 
+			if (_board.DiskDrive != null)
+			{
+				_board.DiskDrive.InitSaveRam(_roms.Count);
+				ser.Register<ISaveRam>(_board.DiskDrive);
+			}
+
 			InitMedia(_roms[_currentDisk]);
 			HardReset();
 
@@ -172,6 +178,7 @@ public string BoardName
 
 		private void IncrementDisk()
 		{
+			_board.DiskDrive.SaveDeltas();
 			_currentDisk++;
 			if (CurrentDisk >= _roms.Count)
 			{
@@ -183,6 +190,7 @@ private void IncrementDisk()
 
 		private void DecrementDisk()
 		{
+			_board.DiskDrive.SaveDeltas();
 			_currentDisk--;
 			if (_currentDisk < 0)
 			{
@@ -195,12 +203,14 @@ private void DecrementDisk()
 		private void InitDisk()
 		{
 			InitMedia(_roms[_currentDisk]);
+			_board.DiskDrive.LoadDeltas();
 		}
 
 		public void SetDisk(int discNum)
 		{
 			if (_currentDisk != discNum)
 			{
+				_board.DiskDrive.SaveDeltas();
 				_currentDisk = discNum;
 				InitDisk();
 			}

src/BizHawk.Emulation.Cores/Computers/Commodore64/Media/Disk.cs

@@ -26,7 +26,6 @@ public Disk(int trackCapacity)
 			_tracks = new int[trackCapacity][];
 			FillMissingTracks();
 			_originalMedia = _tracks.Select(t => (int[])t.Clone()).ToArray();
-			_usedTracks = new bool[trackCapacity];
 			Valid = true;
 		}
 
@@ -49,7 +48,6 @@ public Disk(IList<byte[]> trackData, IList<int> trackNumbers, IList<int> trackDe
 			FillMissingTracks();
 			Valid = true;
 			_originalMedia = _tracks.Select(t => (int[])t.Clone()).ToArray();
-			_usedTracks = new bool[trackCapacity];
 		}
 
 		private int[] ConvertToFluxTransitions(int density, byte[] bytes, int fluxBitOffset)
@@ -135,29 +133,41 @@ private void FillMissingTracks()
 			}
 		}
 
-		public int[] GetDataForTrack(int halftrack)
+		public void AttachTracker(bool[] usedTracks)
 		{
-			_usedTracks[halftrack] = true; // TODO: probably can be smarter about this with the WriteProtected flag
-			return _tracks[halftrack];
+			if (_tracks.Length != usedTracks.Length)
+			{
+				throw new InvalidOperationException("track and tracker length mismatch! (this should be impossible, please report)");
+			}
+
+			_usedTracks = usedTracks;
 		}
 
-		public void SyncState(Serializer ser)
+		/// <summary>
+		/// Generic update of the deltas stored in Drive1541's ISaveRam implementation.
+		/// deltaUpdateCallback will be called for each track which has been possibly dirtied
+		/// </summary>
+		/// <param name="deltaUpdateCallback">callback</param>
+		public void DeltaUpdate(Action<int, int[], int[]> deltaUpdateCallback)
 		{
-			ser.Sync(nameof(WriteProtected), ref WriteProtected);
-			var oldUsedTracks = _usedTracks; // Sync changes reference if loading state (we don't care in the saving state case)
-			ser.Sync(nameof(_usedTracks), ref _usedTracks, useNull: false);
-
 			for (var i = 0; i < _tracks.Length; i++)
 			{
 				if (_usedTracks[i])
 				{
-					ser.SyncDelta($"MediaState{i}", _originalMedia[i], _tracks[i]);
-				}
-				else if (ser.IsReader && oldUsedTracks[i]) // _tracks[i] might be different, but in the state it wasn't, so just copy _originalMedia[i]
-				{
-					_originalMedia[i].AsSpan().CopyTo(_tracks[i]);
+					deltaUpdateCallback(i, _originalMedia[i], _tracks[i]);
 				}
 			}
 		}
+
+		public int[] GetDataForTrack(int halftrack)
+		{
+			_usedTracks[halftrack] = true;
+			return _tracks[halftrack];
+		}
+
+		public void SyncState(Serializer ser)
+		{
+			ser.Sync(nameof(WriteProtected), ref WriteProtected);
+		}
 	}
 }