ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

file reorganisation and removal of obsolete stuff

This commit is contained in:
Asnivor 2018-02-16 10:14:02 +00:00
parent a3dc506c06
commit 50d28c9627
32 changed files with 12 additions and 4483 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
BizHawk.Emulation.Cores/BizHawk.Emulation.Cores.csproj
View File

@ -256,22 +256,11 @@
<Compile Include="Computers\Commodore64\MOS\Vic.VideoProvider.cs" />
<Compile Include="Computers\Commodore64\SaveState.cs" />
<Compile Include="Computers\Commodore64\User\UserPortDevice.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\AY38912.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Buzzer.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\SoundOuput\AY38912.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\SoundOuput\Buzzer.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Datacorder\DatacorderDevice.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\DefaultTapeProvider.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Interfaces\IKeyboard.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Interfaces\ISaveToTapeProvider.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Interfaces\ISupportsTapeBlockPlayback.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Interfaces\ISupportsTapeBlockSetPlayback.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Interfaces\ITapeContentProvider.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Interfaces\ITapeData.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Interfaces\ITapeDataSerialization.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Interfaces\ITapeProvider.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\KempstonJoystick.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\TapeBlockSetPlayer.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\TapeDataBlockPlayer.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\TapeFilePlayer.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Input\IKeyboard.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Input\KempstonJoystick.cs" />
<Compile Include="Computers\SinclairSpectrum\Machine\ULABase.cs" />
<Compile Include="Computers\SinclairSpectrum\Machine\ZXSpectrum128K\ZX128.ULA.cs" />
<Compile Include="Computers\SinclairSpectrum\Machine\ZXSpectrum16K\ZX16.cs" />
@ -288,7 +277,6 @@
<Compile Include="Computers\SinclairSpectrum\Machine\SpectrumBase.Input.cs" />
<Compile Include="Computers\SinclairSpectrum\Machine\SpectrumBase.Port.cs" />
<Compile Include="Computers\SinclairSpectrum\Machine\SpectrumBase.Memory.cs" />
<Compile Include="Computers\SinclairSpectrum\Machine\SpectrumBase.Sound.cs" />
<Compile Include="Computers\SinclairSpectrum\Machine\ZXSpectrum128KPlus2\ZX128Plus2.cs" />
<Compile Include="Computers\SinclairSpectrum\Machine\ZXSpectrum128KPlus3\ZX128Plus3.cs" />
<Compile Include="Computers\SinclairSpectrum\Machine\ZXSpectrum128KPlus3\ZX128Plus3.Memory.cs" />
@ -298,20 +286,8 @@
<Compile Include="Computers\SinclairSpectrum\Machine\ZXSpectrum128K\ZX128.Port.cs" />
<Compile Include="Computers\SinclairSpectrum\Machine\ZXSpectrum48K\ZX48.cs" />
<Compile Include="Computers\SinclairSpectrum\Machine\ZXSpectrum48K\ZX48.Memory.cs" />
<Compile Include="Computers\SinclairSpectrum\Media\Tape\TAP\TapDataBlock.cs" />
<Compile Include="Computers\SinclairSpectrum\Media\Tape\TAP\TapPlayer.cs" />
<Compile Include="Computers\SinclairSpectrum\Media\Tape\TAP\TapReader.cs" />
<Compile Include="Computers\SinclairSpectrum\Media\Tape\TZX\BlockAbstraction.cs" />
<Compile Include="Computers\SinclairSpectrum\Media\Tape\TZX\DataBlocks.cs" />
<Compile Include="Computers\SinclairSpectrum\Media\Tape\TZX\Info.cs" />
<Compile Include="Computers\SinclairSpectrum\Media\Tape\TZX\Types.cs" />
<Compile Include="Computers\SinclairSpectrum\Media\Tape\TZX\TzxException.cs" />
<Compile Include="Computers\SinclairSpectrum\Media\Tape\TZX\TzxHeader.cs" />
<Compile Include="Computers\SinclairSpectrum\Media\Tape\TZX\TzxPlayer.cs" />
<Compile Include="Computers\SinclairSpectrum\Media\Tape\TZX\TzxReader.cs" />
<Compile Include="Computers\SinclairSpectrum\Pulse.cs" />
<Compile Include="Computers\SinclairSpectrum\RomData.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Tape.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\SoundOuput\Pulse.cs" />
<Compile Include="Computers\SinclairSpectrum\Hardware\Rom\RomData.cs" />
<Compile Include="Computers\SinclairSpectrum\ZXSpectrum.Controllers.cs" />
<Compile Include="Computers\SinclairSpectrum\ZXSpectrum.cs" />
<Compile Include="Computers\SinclairSpectrum\ZXSpectrum.IDebuggable.cs" />

135
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/DefaultTapeProvider.cs
View File

@ -1,135 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
public class DefaultTapeProvider : ITapeProvider
{
public const string RESOURCE_FOLDER = "TzxResources";
public const string DEFAULT_SAVE_FILE_DIR = @"C:\Temp\ZxSpectrumSavedFiles";
public const string DEFAULT_NAME = "SavedFile";
public const string DEFAULT_EXT = ".tzx";
private string _suggestedName;
private string _fullFileName;
private int _dataBlockCount;
private byte[] _file;
/// <summary>
/// The directory files should be saved to
/// </summary>
public string SaveFileFolder { get; }
public DefaultTapeProvider(byte[] file, string saveFolder = null)
{
SaveFileFolder = string.IsNullOrWhiteSpace(saveFolder)
? DEFAULT_SAVE_FILE_DIR
: saveFolder;
_file = file;
}
/// <summary>
/// The component provider should be able to reset itself
/// </summary>
///
public void Reset()
{
_dataBlockCount = 0;
_suggestedName = null;
_fullFileName = null;
}
/// <summary>
/// Tha tape set to load the content from
/// </summary>
public string TapeSetName { get; set; }
/// <summary>
/// Gets a binary reader that provider TZX content
/// </summary>
/// <returns>BinaryReader instance to obtain the content from</returns>
public BinaryReader GetTapeContent()
{
Stream stream = new MemoryStream(_file);
var reader = new BinaryReader(stream);
return reader;
}
/// <summary>
/// Creates a tape file with the specified name
/// </summary>
/// <returns></returns>
public void CreateTapeFile()
{
//Reset();
}
/// <summary>
/// This method sets the name of the file according to the
/// Spectrum SAVE HEADER information
/// </summary>
/// <param name="name"></param>
public void SetName(string name)
{
_suggestedName = name;
}
/// <summary>
/// Appends the TZX block to the tape file
/// </summary>
/// <param name="block"></param>
public void SaveTapeBlock(ITapeDataSerialization block)
{
if (_dataBlockCount == 0)
{
if (!Directory.Exists(SaveFileFolder))
{
Directory.CreateDirectory(SaveFileFolder);
}
var baseFileName = $"{_suggestedName ?? DEFAULT_NAME}_{DateTime.Now:yyyyMMdd_HHmmss}{DEFAULT_EXT}";
_fullFileName = Path.Combine(SaveFileFolder, baseFileName);
using (var writer = new BinaryWriter(File.Create(_fullFileName)))
{
var header = new TzxHeader();
header.WriteTo(writer);
}
}
_dataBlockCount++;
var stream = File.Open(_fullFileName, FileMode.Append);
using (var writer = new BinaryWriter(stream))
{
block.WriteTo(writer);
}
}
/// <summary>
/// The tape provider can finalize the tape when all
/// TZX blocks are written.
/// </summary>
public void FinalizeTapeFile()
{
}
/// <summary>
/// Obtains the specified resource stream ot the given assembly
/// </summary>
/// <param name="asm">Assembly to get the resource stream from</param>
/// <param name="resourceName">Resource name</param>
private static Stream GetFileResource(Assembly asm, string resourceName)
{
var resourceFullName = $"{asm.GetName().Name}.{RESOURCE_FOLDER}.{resourceName}";
return asm.GetManifestResourceStream(resourceFullName);
}
}
}

0
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Interfaces/IKeyboard.cs → BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Input/IKeyboard.cs
View File

0
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/KempstonJoystick.cs → BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Input/KempstonJoystick.cs
View File

35
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Interfaces/ISaveToTapeProvider.cs
View File

@ -1,35 +0,0 @@

namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This interface describes the behavior of an object that
/// provides tape content
/// </summary>
public interface ISaveToTapeProvider
{
/// <summary>
/// Creates a tape file with the specified name
/// </summary>
/// <returns></returns>
void CreateTapeFile();
/// <summary>
/// This method sets the name of the file according to the
/// Spectrum SAVE HEADER information
/// </summary>
/// <param name="name"></param>
void SetName(string name);
/// <summary>
/// Appends the tape block to the tape file
/// </summary>
/// <param name="block"></param>
void SaveTapeBlock(ITapeDataSerialization block);
/// <summary>
/// The tape provider can finalize the tape when all
/// tape blocks are written.
/// </summary>
void FinalizeTapeFile();
}
}

43
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Interfaces/ISupportsTapeBlockPlayback.cs
View File

@ -1,43 +0,0 @@
using BizHawk.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This interface represents that the implementing class supports
/// emulating tape playback of a single tape block
/// </summary>
public interface ISupportsTapeBlockPlayback
{
/// <summary>
/// The current playing phase
/// </summary>
PlayPhase PlayPhase { get; }
/// <summary>
/// The tact count of the CPU when playing starts
/// </summary>
long StartCycle { get; }
/// <summary>
/// Initializes the player
/// </summary>
void InitPlay(long startCycle);
/// <summary>
/// Gets the EAR bit value for the specified tact
/// </summary>
/// <param name="currentCycle">Tacts to retrieve the EAR bit</param>
/// <returns>
/// The EAR bit value to play back
/// </returns>
bool GetEarBit(long currentCycle);
void SyncState(Serializer ser);
}
}

21
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Interfaces/ISupportsTapeBlockSetPlayback.cs
View File

@ -1,21 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This interface represents that the implementing class supports
/// emulating tape playback of a set of subsequent tape blocks
/// </summary>
public interface ISupportsTapeBlockSetPlayback : ISupportsTapeBlockPlayback
{
/// <summary>
/// Moves the player to the next playable block
/// </summary>
/// <param name="currentCycle">Tacts time to start the next block</param>
void NextBlock(long currentCycle);
}
}

25
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Interfaces/ITapeContentProvider.cs
View File

@ -1,25 +0,0 @@

using System.IO;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This interface describes the behavior of an object that
/// provides tape content
/// </summary>
public interface ITapeContentProvider
{
/// <summary>
/// Tha tape set to load the content from
/// </summary>
string TapeSetName { get; set; }
/// <summary>
/// Gets a binary reader that provides tape content
/// </summary>
/// <returns>BinaryReader instance to obtain the content from</returns>
BinaryReader GetTapeContent();
void Reset();
}
}

24
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Interfaces/ITapeData.cs
View File

@ -1,24 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// Represetns the data in the tape
/// </summary>
public interface ITapeData
{
/// <summary>
/// Block Data
/// </summary>
byte[] Data { get; }
/// <summary>
/// Pause after this block (given in milliseconds)
/// </summary>
ushort PauseAfter { get; }
}
}

27
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Interfaces/ITapeDataSerialization.cs
View File

@ -1,27 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// Defines the serialization operations of a TZX record
/// </summary>
public interface ITapeDataSerialization
{
/// <summary>
/// Reads the content of the block from the specified binary stream.
/// </summary>
/// <param name="reader">Stream to read the block from</param>
void ReadFrom(BinaryReader reader);
/// <summary>
/// Writes the content of the block to the specified binary stream.
/// </summary>
/// <param name="writer">Stream to write the block to</param>
void WriteTo(BinaryWriter writer);
}
}

53
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Interfaces/ITapeProvider.cs
View File

@ -1,53 +0,0 @@
using System.IO;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This interface describes the behavior of an object that
/// provides TZX tape content
/// </summary>
public interface ITapeProvider
{
/// <summary>
/// Tha tape set to load the content from
/// </summary>
string TapeSetName { get; set; }
/// <summary>
/// Gets a binary reader that provider TZX content
/// </summary>
/// <returns>BinaryReader instance to obtain the content from</returns>
BinaryReader GetTapeContent();
/// <summary>
/// Creates a tape file with the specified name
/// </summary>
/// <returns></returns>
void CreateTapeFile();
/// <summary>
/// This method sets the name of the file according to the
/// Spectrum SAVE HEADER information
/// </summary>
/// <param name="name"></param>
void SetName(string name);
/// <summary>
/// Appends the TZX block to the tape file
/// </summary>
/// <param name="block"></param>
void SaveTapeBlock(ITapeDataSerialization block);
/// <summary>
/// The tape provider can finalize the tape when all
/// TZX blocks are written.
/// </summary>
void FinalizeTapeFile();
/// <summary>
/// Provider can reset itself
/// </summary>
void Reset();
}
}

0
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/RomData.cs → BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Rom/RomData.cs
View File

0
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/AY38912.cs → BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/SoundOuput/AY38912.cs
View File

0
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Buzzer.cs → BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/SoundOuput/Buzzer.cs
View File

0
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Pulse.cs → BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/SoundOuput/Pulse.cs
View File

814
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Tape.cs
View File

@ -1,814 +0,0 @@
using BizHawk.Common;
using BizHawk.Emulation.Cores.Components.Z80A;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/*
* Much of the TAPE implementation has been taken from: https://github.com/Dotneteer/spectnetide
*
* MIT License
Copyright (c) 2017 Istvan Novak
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
*/
/// <summary>
/// Represents the tape device (or DATACORDER as AMSTRAD liked to call it)
/// </summary>
public class Tape
{
private SpectrumBase _machine { get; set; }
private Z80A _cpu { get; set; }
private Buzzer _buzzer { get; set; }
private TapeOperationMode _currentMode;
private TapeFilePlayer _tapePlayer;
private bool _micBitState;
private long _lastMicBitActivityCycle;
private SavePhase _savePhase;
private int _pilotPulseCount;
private int _bitOffset;
private byte _dataByte;
private int _dataLength;
private byte[] _dataBuffer;
private int _dataBlockCount;
private MicPulseType _prevDataPulse;
/// <summary>
/// Number of tacts after save mod can be exited automatically
/// </summary>
public const int SAVE_STOP_SILENCE = 17500000;
/// <summary>
/// The address of the ERROR routine in the Spectrum ROM
/// </summary>
public const ushort ERROR_ROM_ADDRESS = 0x0008;
/// <summary>
/// The maximum distance between two scans of the EAR bit
/// </summary>
public const int MAX_TACT_JUMP = 10000;
/// <summary>
/// The width tolerance of save pulses
/// </summary>
public const int SAVE_PULSE_TOLERANCE = 24;
/// <summary>
/// Minimum number of pilot pulses before SYNC1
/// </summary>
public const int MIN_PILOT_PULSE_COUNT = 3000;
/// <summary>
/// Lenght of the data buffer to allocate for the SAVE operation
/// </summary>
public const int DATA_BUFFER_LENGTH = 0x10000;
/// <summary>
/// Gets the tape content provider
/// </summary>
public ITapeProvider TapeProvider { get; }
/// <summary>
/// The TapeFilePlayer that can playback tape content
/// </summary>
public TapeFilePlayer TapeFilePlayer => _tapePlayer;
/// <summary>
/// The current operation mode of the tape
/// </summary>
public TapeOperationMode CurrentMode => _currentMode;
private bool _fastLoad = false;
public virtual void Init(SpectrumBase machine)
{
_machine = machine;
_cpu = _machine.CPU;
_buzzer = machine.BuzzerDevice;
Reset();
}
public Tape(ITapeProvider tapeProvider)
{
TapeProvider = tapeProvider;
}
public virtual void Reset()
{
TapeProvider?.Reset();
_tapePlayer = null;
_currentMode = TapeOperationMode.Passive;
_savePhase = SavePhase.None;
_micBitState = true;
}
public void CPUFrameCompleted()
{
SetTapeMode();
if (CurrentMode == TapeOperationMode.Load
&& _fastLoad
&& TapeFilePlayer != null
&& TapeFilePlayer.PlayPhase != PlayPhase.Completed
&& _cpu.RegPC == 1529) //_machine.RomData.LoadBytesRoutineAddress)
{
if (FastLoadFromTzx())
{
//FastLoadCompleted?.Invoke(this, EventArgs.Empty);
}
}
}
/// <summary>
/// Sets the current tape mode according to the current PC register
/// and the MIC bit state
/// </summary>
public void SetTapeMode()
{
switch (_currentMode)
{
case TapeOperationMode.Passive:
if (_cpu.RegPC == 1523) // _machine.RomData.LoadBytesRoutineAddress) //1529
{
EnterLoadMode();
}
else if (_cpu.RegPC == 2416) // _machine.RomData.SaveBytesRoutineAddress)
{
EnterSaveMode();
}
var res = _cpu.RegPC;
var res2 = _machine.Spectrum.RegPC;
return;
case TapeOperationMode.Save:
if (_cpu.RegPC == ERROR_ROM_ADDRESS
|| (int)(_cpu.TotalExecutedCycles - _lastMicBitActivityCycle) > SAVE_STOP_SILENCE)
{
LeaveSaveMode();
}
return;
case TapeOperationMode.Load:
if ((_tapePlayer?.Eof ?? false) || _cpu.RegPC == ERROR_ROM_ADDRESS)
{
LeaveLoadMode();
}
return;
}
}
/// <summary>
/// Puts the device in save mode. From now on, every MIC pulse is recorded
/// </summary>
private void EnterSaveMode()
{
_currentMode = TapeOperationMode.Save;
_savePhase = SavePhase.None;
_micBitState = true;
_lastMicBitActivityCycle = _cpu.TotalExecutedCycles;
_pilotPulseCount = 0;
_prevDataPulse = MicPulseType.None;
_dataBlockCount = 0;
TapeProvider?.CreateTapeFile();
}
/// <summary>
/// Leaves the save mode. Stops recording MIC pulses
/// </summary>
private void LeaveSaveMode()
{
_currentMode = TapeOperationMode.Passive;
TapeProvider?.FinalizeTapeFile();
}
/// <summary>
/// Puts the device in load mode. From now on, EAR pulses are played by a device
/// </summary>
private void EnterLoadMode()
{
_currentMode = TapeOperationMode.Load;
var contentReader = TapeProvider?.GetTapeContent();
if (contentReader == null) return;
// --- Play the content
_tapePlayer = new TapeFilePlayer(contentReader);
_tapePlayer.ReadContent();
_tapePlayer.InitPlay(_cpu.TotalExecutedCycles);
_buzzer.SetTapeMode(true);
}
/// <summary>
/// Leaves the load mode. Stops the device that playes EAR pulses
/// </summary>
private void LeaveLoadMode()
{
_currentMode = TapeOperationMode.Passive;
_tapePlayer = null;
TapeProvider?.Reset();
_buzzer.SetTapeMode(false);
}
/// <summary>
/// Loads the next TZX player block instantly without emulation
/// EAR bit processing
/// </summary>
/// <returns>True, if fast load is operative</returns>
private bool FastLoadFromTzx()
{
var c = _machine.Spectrum;
var blockType = TapeFilePlayer.CurrentBlock.GetType();
bool canFlash = TapeFilePlayer.CurrentBlock is ITapeData;
// --- Check, if we can load the current block in a fast way
if (!(TapeFilePlayer.CurrentBlock is ITapeData)
|| TapeFilePlayer.PlayPhase == PlayPhase.Completed)
{
// --- We cannot play this block
return false;
}
var currentData = TapeFilePlayer.CurrentBlock as ITapeData;
var regs = _cpu.Regs;
//regs.AF = regs._AF_;
//c.Set16BitAF(c.Get16BitAF_());
_cpu.A = _cpu.A_s;
_cpu.F = _cpu.F_s;
// --- Check if the operation is LOAD or VERIFY
var isVerify = (c.RegAF & 0xFF01) == 0xFF00;
// --- At this point IX contains the address to load the data,
// --- DE shows the #of bytes to load. A contains 0x00 for header,
// --- 0xFF for data block
var data = currentData.Data;
if (data[0] != regs[_cpu.A])
{
// --- This block has a different type we're expecting
regs[_cpu.A] = (byte)(regs[_cpu.A] ^ regs[_cpu.L]);
regs[_cpu.F] &= (byte)ZXSpectrum.FlagsResetMask.Z;
regs[_cpu.F] &= (byte)ZXSpectrum.FlagsResetMask.C;
c.RegPC = _machine.RomData.LoadBytesInvalidHeaderAddress;
// --- Get the next block
TapeFilePlayer.NextBlock(_cpu.TotalExecutedCycles);
return true;
}
// --- It is time to load the block
var curIndex = 1;
//var memory = _machine.me MemoryDevice;
regs[_cpu.H] = regs[_cpu.A];
while (c.RegDE > 0)
{
var de16 = c.RegDE;
var ix16 = c.RegIX;
if (curIndex > data.Length - 1)
{
// --- No more data to read
//break;
}
regs[_cpu.L] = data[curIndex];
if (isVerify && regs[_cpu.L] != _machine.ReadBus(c.RegIX))
{
// --- Verify failed
regs[_cpu.A] = (byte)(_machine.ReadBus(c.RegIX) ^ regs[_cpu.L]);
regs[_cpu.F] &= (byte)ZXSpectrum.FlagsResetMask.Z;
regs[_cpu.F] &= (byte)ZXSpectrum.FlagsResetMask.C;
c.RegPC = _machine.RomData.LoadBytesInvalidHeaderAddress;
return true;
}
// --- Store the loaded data byte
_machine.WriteBus(c.RegIX, (byte)regs[_cpu.L]);
regs[_cpu.H] ^= regs[_cpu.L];
curIndex++;
//regs.IX++;
//c.Set16BitIX((ushort)((int)c.Get16BitIX() + 1));
c.RegIX++;
//regs.DE--;
//c.Set16BitDE((ushort)((int)c.Get16BitDE() - 1));
//_cpu.Regs[_cpu.E]--;
c.RegDE--;
var te = c.RegDE;
}
// --- Check the parity byte at the end of the data stream
if (curIndex > data.Length - 1 || regs[_cpu.H] != data[curIndex])
{
// --- Carry is reset to sign an error
regs[_cpu.F] &= (byte)ZXSpectrum.FlagsResetMask.C;
}
else
{
// --- Carry is set to sign success
regs[_cpu.F] |= (byte)ZXSpectrum.FlagsSetMask.C;
}
c.RegPC = _machine.RomData.LoadBytesResumeAddress;
// --- Get the next block
TapeFilePlayer.NextBlock(_cpu.TotalExecutedCycles);
return true;
}
/// <summary>
/// the EAR bit read from tape
/// </summary>
/// <param name="cpuCycles"></param>
/// <returns></returns>
public virtual bool GetEarBit(int cpuCycles)
{
if (_currentMode != TapeOperationMode.Load)
{
return true;
}
var earBit = _tapePlayer?.GetEarBit(cpuCycles) ?? true;
_buzzer.ProcessPulseValue(true, earBit);
return earBit;
}
/// <summary>
/// Processes the mic bit change
/// </summary>
/// <param name="micBit"></param>
public virtual void ProcessMicBit(bool micBit)
{
if (_currentMode != TapeOperationMode.Save
|| _micBitState == micBit)
{
return;
}
var length = _cpu.TotalExecutedCycles - _lastMicBitActivityCycle;
// --- Classify the pulse by its width
var pulse = MicPulseType.None;
if (length >= TapeDataBlockPlayer.BIT_0_PL - SAVE_PULSE_TOLERANCE
&& length <= TapeDataBlockPlayer.BIT_0_PL + SAVE_PULSE_TOLERANCE)
{
pulse = MicPulseType.Bit0;
}
else if (length >= TapeDataBlockPlayer.BIT_1_PL - SAVE_PULSE_TOLERANCE
&& length <= TapeDataBlockPlayer.BIT_1_PL + SAVE_PULSE_TOLERANCE)
{
pulse = MicPulseType.Bit1;
}
if (length >= TapeDataBlockPlayer.PILOT_PL - SAVE_PULSE_TOLERANCE
&& length <= TapeDataBlockPlayer.PILOT_PL + SAVE_PULSE_TOLERANCE)
{
pulse = MicPulseType.Pilot;
}
else if (length >= TapeDataBlockPlayer.SYNC_1_PL - SAVE_PULSE_TOLERANCE
&& length <= TapeDataBlockPlayer.SYNC_1_PL + SAVE_PULSE_TOLERANCE)
{
pulse = MicPulseType.Sync1;
}
else if (length >= TapeDataBlockPlayer.SYNC_2_PL - SAVE_PULSE_TOLERANCE
&& length <= TapeDataBlockPlayer.SYNC_2_PL + SAVE_PULSE_TOLERANCE)
{
pulse = MicPulseType.Sync2;
}
else if (length >= TapeDataBlockPlayer.TERM_SYNC - SAVE_PULSE_TOLERANCE
&& length <= TapeDataBlockPlayer.TERM_SYNC + SAVE_PULSE_TOLERANCE)
{
pulse = MicPulseType.TermSync;
}
else if (length < TapeDataBlockPlayer.SYNC_1_PL - SAVE_PULSE_TOLERANCE)
{
pulse = MicPulseType.TooShort;
}
else if (length > TapeDataBlockPlayer.PILOT_PL + 2 * SAVE_PULSE_TOLERANCE)
{
pulse = MicPulseType.TooLong;
}
_micBitState = micBit;
_lastMicBitActivityCycle = _cpu.TotalExecutedCycles;
// --- Lets process the pulse according to the current SAVE phase and pulse width
var nextPhase = SavePhase.Error;
switch (_savePhase)
{
case SavePhase.None:
if (pulse == MicPulseType.TooShort || pulse == MicPulseType.TooLong)
{
nextPhase = SavePhase.None;
}
else if (pulse == MicPulseType.Pilot)
{
_pilotPulseCount = 1;
nextPhase = SavePhase.Pilot;
}
break;
case SavePhase.Pilot:
if (pulse == MicPulseType.Pilot)
{
_pilotPulseCount++;
nextPhase = SavePhase.Pilot;
}
else if (pulse == MicPulseType.Sync1 && _pilotPulseCount >= MIN_PILOT_PULSE_COUNT)
{
nextPhase = SavePhase.Sync1;
}
break;
case SavePhase.Sync1:
if (pulse == MicPulseType.Sync2)
{
nextPhase = SavePhase.Sync2;
}
break;
case SavePhase.Sync2:
if (pulse == MicPulseType.Bit0 || pulse == MicPulseType.Bit1)
{
// --- Next pulse starts data, prepare for receiving it
_prevDataPulse = pulse;
nextPhase = SavePhase.Data;
_bitOffset = 0;
_dataByte = 0;
_dataLength = 0;
_dataBuffer = new byte[DATA_BUFFER_LENGTH];
}
break;
case SavePhase.Data:
if (pulse == MicPulseType.Bit0 || pulse == MicPulseType.Bit1)
{
if (_prevDataPulse == MicPulseType.None)
{
// --- We are waiting for the second half of the bit pulse
_prevDataPulse = pulse;
nextPhase = SavePhase.Data;
}
else if (_prevDataPulse == pulse)
{
// --- We received a full valid bit pulse
nextPhase = SavePhase.Data;
_prevDataPulse = MicPulseType.None;
// --- Add this bit to the received data
_bitOffset++;
_dataByte = (byte)(_dataByte * 2 + (pulse == MicPulseType.Bit0 ? 0 : 1));
if (_bitOffset == 8)
{
// --- We received a full byte
_dataBuffer[_dataLength++] = _dataByte;
_dataByte = 0;
_bitOffset = 0;
}
}
}
else if (pulse == MicPulseType.TermSync)
{
// --- We received the terminating pulse, the datablock has been completed
nextPhase = SavePhase.None;
_dataBlockCount++;
// --- Create and save the data block
var dataBlock = new TzxStandardSpeedDataBlock
{
Data = _dataBuffer,
DataLength = (ushort)_dataLength
};
// --- If this is the first data block, extract the name from the header
if (_dataBlockCount == 1 && _dataLength == 0x13)
{
// --- It's a header!
var sb = new StringBuilder(16);
for (var i = 2; i <= 11; i++)
{
sb.Append((char)_dataBuffer[i]);
}
var name = sb.ToString().TrimEnd();
TapeProvider?.SetName(name);
}
TapeProvider?.SaveTapeBlock(dataBlock);
}
break;
}
_savePhase = nextPhase;
}
public void SyncState(Serializer ser)
{
ser.BeginSection("TapeDevice");
ser.Sync("_micBitState", ref _micBitState);
ser.Sync("_lastMicBitActivityCycle", ref _lastMicBitActivityCycle);
ser.Sync("_pilotPulseCount", ref _pilotPulseCount);
ser.Sync("_bitOffset", ref _bitOffset);
ser.Sync("_dataByte", ref _dataByte);
ser.Sync("_dataLength", ref _dataLength);
ser.Sync("_dataBlockCount", ref _dataBlockCount);
ser.Sync("_dataBuffer", ref _dataBuffer, false);
ser.SyncEnum<TapeOperationMode>("_currentMode", ref _currentMode);
ser.SyncEnum<SavePhase>("_savePhase", ref _savePhase);
ser.SyncEnum<MicPulseType>("_prevDataPulse", ref _prevDataPulse);
ser.EndSection();
}
}
/// <summary>
/// This enum represents the operation mode of the tape
/// </summary>
public enum TapeOperationMode : byte
{
/// <summary>
/// The tape device is passive
/// </summary>
Passive = 0,
/// <summary>
/// The tape device is saving information (MIC pulses)
/// </summary>
Save,
/// <summary>
/// The tape device generates EAR pulses from a player
/// </summary>
Load
}
/// <summary>
/// This class represents a spectrum tape header
/// </summary>
public class SpectrumTapeHeader
{
private const int HEADER_LEN = 19;
private const int TYPE_OFFS = 1;
private const int NAME_OFFS = 2;
private const int NAME_LEN = 10;
private const int DATA_LEN_OFFS = 12;
private const int PAR1_OFFS = 14;
private const int PAR2_OFFS = 16;
private const int CHK_OFFS = 18;
/// <summary>
/// The bytes of the header
/// </summary>
public byte[] HeaderBytes { get; }
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object" /> class.
/// </summary>
public SpectrumTapeHeader()
{
HeaderBytes = new byte[HEADER_LEN];
for (var i = 0; i < HEADER_LEN; i++) HeaderBytes[i] = 0x00;
CalcChecksum();
}
/// <summary>
/// Initializes a new instance with the specified header data.
/// </summary>
/// <param name="header">Header data</param>
public SpectrumTapeHeader(byte[] header)
{
if (header == null) throw new ArgumentNullException(nameof(header));
if (header.Length != HEADER_LEN)
{
throw new ArgumentException($"Header must be exactly {HEADER_LEN} bytes long");
}
HeaderBytes = new byte[HEADER_LEN];
header.CopyTo(HeaderBytes, 0);
CalcChecksum();
}
/// <summary>
/// Gets or sets the type of the header
/// </summary>
public byte Type
{
get { return HeaderBytes[TYPE_OFFS]; }
set
{
HeaderBytes[TYPE_OFFS] = (byte)(value & 0x03);
CalcChecksum();
}
}
/// <summary>
/// Gets or sets the program name
/// </summary>
public string Name
{
get
{
var name = new StringBuilder(NAME_LEN + 4);
for (var i = NAME_OFFS; i < NAME_OFFS + NAME_LEN; i++)
{
name.Append((char)HeaderBytes[i]);
}
return name.ToString().TrimEnd();
}
set
{
if (value == null) throw new ArgumentNullException(nameof(value));
if (value.Length > NAME_LEN) value = value.Substring(0, NAME_LEN);
else if (value.Length < NAME_LEN) value = value.PadRight(NAME_LEN, ' ');
for (var i = NAME_OFFS; i < NAME_OFFS + NAME_LEN; i++)
{
HeaderBytes[i] = (byte)value[i - NAME_OFFS];
}
CalcChecksum();
}
}
/// <summary>
/// Gets or sets the Data Length
/// </summary>
public ushort DataLength
{
get { return GetWord(DATA_LEN_OFFS); }
set { SetWord(DATA_LEN_OFFS, value); }
}
/// <summary>
/// Gets or sets Parameter1
/// </summary>
public ushort Parameter1
{
get { return GetWord(PAR1_OFFS); }
set { SetWord(PAR1_OFFS, value); }
}
/// <summary>
/// Gets or sets Parameter2
/// </summary>
public ushort Parameter2
{
get { return GetWord(PAR2_OFFS); }
set { SetWord(PAR2_OFFS, value); }
}
/// <summary>
/// Gets the value of checksum
/// </summary>
public byte Checksum => HeaderBytes[CHK_OFFS];
/// <summary>
/// Calculate the checksum
/// </summary>
private void CalcChecksum()
{
var chk = 0x00;
for (var i = 0; i < HEADER_LEN - 1; i++) chk ^= HeaderBytes[i];
HeaderBytes[CHK_OFFS] = (byte)chk;
}
/// <summary>
/// Gets the word value from the specified offset
/// </summary>
private ushort GetWord(int offset) =>
(ushort)(HeaderBytes[offset] + 256 * HeaderBytes[offset + 1]);
/// <summary>
/// Sets the word value at the specified offset
/// </summary>
private void SetWord(int offset, ushort value)
{
HeaderBytes[offset] = (byte)(value & 0xff);
HeaderBytes[offset + 1] = (byte)(value >> 8);
CalcChecksum();
}
}
/// <summary>
/// This enum defines the MIC pulse types according to their widths
/// </summary>
public enum MicPulseType : byte
{
/// <summary>
/// No pulse information
/// </summary>
None = 0,
/// <summary>
/// Too short to be a valid pulse
/// </summary>
TooShort,
/// <summary>
/// Too long to be a valid pulse
/// </summary>
TooLong,
/// <summary>
/// PILOT pulse (Length: 2168 cycles)
/// </summary>
Pilot,
/// <summary>
/// SYNC1 pulse (Length: 667 cycles)
/// </summary>
Sync1,
/// <summary>
/// SYNC2 pulse (Length: 735 cycles)
/// </summary>
Sync2,
/// <summary>
/// BIT0 pulse (Length: 855 cycles)
/// </summary>
Bit0,
/// <summary>
/// BIT1 pulse (Length: 1710 cycles)
/// </summary>
Bit1,
/// <summary>
/// TERM_SYNC pulse (Length: 947 cycles)
/// </summary>
TermSync
}
/// <summary>
/// Represents the playing phase of the current block
/// </summary>
public enum PlayPhase
{
/// <summary>
/// The player is passive
/// </summary>
None = 0,
/// <summary>
/// Pilot signals
/// </summary>
Pilot,
/// <summary>
/// Sync signals at the end of the pilot
/// </summary>
Sync,
/// <summary>
/// Bits in the data block
/// </summary>
Data,
/// <summary>
/// Short terminating sync signal before pause
/// </summary>
TermSync,
/// <summary>
/// Pause after the data block
/// </summary>
Pause,
/// <summary>
/// The entire block has been played back
/// </summary>
Completed
}
/// <summary>
/// This enumeration defines the phases of the SAVE operation
/// </summary>
public enum SavePhase : byte
{
/// <summary>No SAVE operation is in progress</summary>
None = 0,
/// <summary>Emitting PILOT impulses</summary>
Pilot,
/// <summary>Emitting SYNC1 impulse</summary>
Sync1,
/// <summary>Emitting SYNC2 impulse</summary>
Sync2,
/// <summary>Emitting BIT0/BIT1 impulses</summary>
Data,
/// <summary>Unexpected pulse detected</summary>
Error
}
}

143
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/TapeBlockSetPlayer.cs
View File

@ -1,143 +0,0 @@
using BizHawk.Common;
using System.Collections.Generic;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This class is responsible to "play" a tape file.
/// </summary>
public class TapeBlockSetPlayer : ISupportsTapeBlockSetPlayback
{
/// <summary>
/// All data blocks that can be played back
/// </summary>
public List<ISupportsTapeBlockPlayback> DataBlocks { get; }
/// <summary>
/// Signs that the player completed playing back the file
/// </summary>
private bool eof;
public bool Eof
{
get { return eof; }
set { eof = value; }
}
/// <summary>
/// Gets the currently playing block's index
/// </summary>
private int currentBlockIndex;
public int CurrentBlockIndex
{
get { return currentBlockIndex; }
set { currentBlockIndex = value; }
}
/// <summary>
/// The current playable block
/// </summary>
private ISupportsTapeBlockPlayback currentBlock;
public ISupportsTapeBlockPlayback CurrentBlock
{
get { return DataBlocks[CurrentBlockIndex]; }
//set { currentBlock = value; }
}
/// <summary>
/// The current playing phase
/// </summary>
private PlayPhase playPhase;
public PlayPhase PlayPhase
{
get { return playPhase; }
set { playPhase = value; }
}
/// <summary>
/// The cycle count of the CPU when playing starts
/// </summary>
private long startCycle;
public long StartCycle
{
get { return startCycle; }
set { startCycle = value; }
}
public TapeBlockSetPlayer(List<ISupportsTapeBlockPlayback> dataBlocks)
{
DataBlocks = dataBlocks;
Eof = dataBlocks.Count == 0;
}
/// <summary>
/// Initializes the player
/// </summary>
public void InitPlay(long startTact)
{
CurrentBlockIndex = -1;
NextBlock(startTact);
PlayPhase = PlayPhase.None;
StartCycle = startTact;
}
/// <summary>
/// Gets the EAR bit value for the specified cycle
/// </summary>
/// <param name="currentCycle">Cycles to retrieve the EAR bit</param>
/// <returns>
/// A tuple of the EAR bit and a flag that indicates it is time to move to the next block
/// </returns>
public bool GetEarBit(long currentCycle)
{
// --- Check for EOF
if (CurrentBlockIndex == DataBlocks.Count - 1
&& (CurrentBlock.PlayPhase == PlayPhase.Pause || CurrentBlock.PlayPhase == PlayPhase.Completed))
{
Eof = true;
}
if (CurrentBlockIndex >= DataBlocks.Count || CurrentBlock == null)
{
// --- After all playable block played back, there's nothing more to do
PlayPhase = PlayPhase.Completed;
return true;
}
var earbit = CurrentBlock.GetEarBit(currentCycle);
if (CurrentBlock.PlayPhase == PlayPhase.Completed)
{
NextBlock(currentCycle);
}
return earbit;
}
/// <summary>
/// Moves the current block index to the next playable block
/// </summary>
/// <param name="currentCycle">Cycles time to start the next block</param>
public void NextBlock(long currentCycle)
{
if (CurrentBlockIndex >= DataBlocks.Count - 1)
{
PlayPhase = PlayPhase.Completed;
Eof = true;
return;
}
CurrentBlockIndex++;
CurrentBlock.InitPlay(currentCycle);
}
public void SyncState(Serializer ser)
{
ser.BeginSection("TapeBlockSetPlayer");
ser.Sync("eof", ref eof);
ser.Sync("currentBlockIndex", ref currentBlockIndex);
ser.SyncEnum<PlayPhase>("playPhase", ref playPhase);
ser.Sync("startCycle", ref startCycle);
currentBlock.SyncState(ser);
ser.EndSection();
}
}
}

279
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/TapeDataBlockPlayer.cs
View File

@ -1,279 +0,0 @@

using BizHawk.Common;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// Represents the standard speed data block in a tape file
/// </summary>
public class TapeDataBlockPlayer : ISupportsTapeBlockPlayback, ITapeData
{
/// <summary>
/// Pause after this block (default: 1000ms)
/// </summary>
private ushort pauseAfter;
public ushort PauseAfter
{
get { return pauseAfter; }
}
/// <summary>
/// Block Data
/// </summary>
private byte[] data;
public byte[] Data
{
get { return data; }
}
/// <summary>
/// Initializes a new instance
/// </summary>
public TapeDataBlockPlayer(byte[] _data, ushort _pauseAfter)
{
pauseAfter = _pauseAfter;
data = _data;
}
/// <summary>
/// Pilot pulse length
/// </summary>
public const int PILOT_PL = 2168;
/// <summary>
/// Pilot pulses in the ROM header block
/// </summary>
public const int HEADER_PILOT_COUNT = 8063;
/// <summary>
/// Pilot pulses in the ROM data block
/// </summary>
public const int DATA_PILOT_COUNT = 3223;
/// <summary>
/// Sync 1 pulse length
/// </summary>
public const int SYNC_1_PL = 667;
/// <summary>
/// Sync 2 pulse lenth
/// </summary>
public const int SYNC_2_PL = 735;
/// <summary>
/// Bit 0 pulse length
/// </summary>
public const int BIT_0_PL = 855;
/// <summary>
/// Bit 1 pulse length
/// </summary>
public const int BIT_1_PL = 1710;
/// <summary>
/// End sync pulse length
/// </summary>
public const int TERM_SYNC = 947;
/// <summary>
/// 1 millisecond pause
/// </summary>
public const int PAUSE_MS = 3500;
private int _pilotEnds;
private int _sync1Ends;
private int _sync2Ends;
private int _bitStarts;
private int _bitPulseLength;
private bool _currentBit;
private long _termSyncEnds;
private long _pauseEnds;
/// <summary>
/// The index of the currently playing byte
/// </summary>
private int byteIndex;
public int ByteIndex
{
get { return byteIndex; }
set { byteIndex = value; }
}
/// <summary>
/// The mask of the currently playing bit in the current byte
/// </summary>
private byte bitMask;
public byte BitMask
{
get { return bitMask; }
set { bitMask = value; }
}
/// <summary>
/// The current playing phase
/// </summary>
private PlayPhase playPhase;
public PlayPhase PlayPhase
{
get { return playPhase; }
set { playPhase = value; }
}
/// <summary>
/// The cycle count of the CPU when playing starts
/// </summary>
private long startCycle;
public long StartCycle
{
get { return startCycle; }
set { startCycle = value; }
}
/// <summary>
/// Last cycle queried
/// </summary>
private long lastCycle;
public long LastCycle
{
get { return lastCycle; }
set { lastCycle = value; }
}
/// <summary>
/// Initializes the player
/// </summary>
public void InitPlay(long startTact)
{
PlayPhase = PlayPhase.Pilot;
StartCycle = LastCycle = startTact;
_pilotEnds = ((Data[0] & 0x80) == 0 ? HEADER_PILOT_COUNT : DATA_PILOT_COUNT) * PILOT_PL;
_sync1Ends = _pilotEnds + SYNC_1_PL;
_sync2Ends = _sync1Ends + SYNC_2_PL;
ByteIndex = 0;
BitMask = 0x80;
}
/// <summary>
/// Gets the EAR bit value for the specified cycle
/// </summary>
/// <param name="currentCycle">Tacts to retrieve the EAR bit</param>
/// <returns>
/// The EAR bit value to play back
/// </returns>
public bool GetEarBit(long currentCycle)
{
var pos = (int)(currentCycle - StartCycle);
LastCycle = currentCycle;
if (PlayPhase == PlayPhase.Pilot || PlayPhase == PlayPhase.Sync)
{
// --- Generate the appropriate pilot or sync EAR bit
if (pos <= _pilotEnds)
{
// --- Alternating pilot pulses
return (pos / PILOT_PL) % 2 == 0;
}
if (pos <= _sync1Ends)
{
// --- 1st sync pulse
PlayPhase = PlayPhase.Sync;
return false;
}
if (pos <= _sync2Ends)
{
// --- 2nd sync pulse
PlayPhase = PlayPhase.Sync;
return true;
}
PlayPhase = PlayPhase.Data;
_bitStarts = _sync2Ends;
_currentBit = (Data[ByteIndex] & BitMask) != 0;
_bitPulseLength = _currentBit ? BIT_1_PL : BIT_0_PL;
}
if (PlayPhase == PlayPhase.Data)
{
// --- Data block playback
// --- Generate current bit pulse
var bitPos = pos - _bitStarts;
if (bitPos < _bitPulseLength)
{
// --- First pulse of the bit
return false;
}
if (bitPos < 2 * _bitPulseLength)
{
// --- Second pulse of the bit
return true;
}
// --- Move to the next bit, or byte
if ((BitMask >>= 1) == 0)
{
BitMask = 0x80;
ByteIndex++;
}
// --- Prepare the next bit
if (ByteIndex < Data.Length)
{
_bitStarts += 2 * _bitPulseLength;
_currentBit = (Data[ByteIndex] & BitMask) != 0;
_bitPulseLength = _currentBit ? BIT_1_PL : BIT_0_PL;
// --- We're in the first pulse of the next bit
return false;
}
// --- We've played back all data bytes, send terminating pulse
PlayPhase = PlayPhase.TermSync;
_termSyncEnds = currentCycle + TERM_SYNC;
return false;
}
if (PlayPhase == PlayPhase.TermSync)
{
if (currentCycle < _termSyncEnds)
{
return false;
}
// --- We've played back all data, not, it's pause time
PlayPhase = PlayPhase.Pause;
_pauseEnds = currentCycle + PAUSE_MS * PauseAfter;
return true;
}
// --- We need to produce pause signs
if (currentCycle > _pauseEnds)
{
PlayPhase = PlayPhase.Completed;
}
return true;
}
public void SyncState(Serializer ser)
{
ser.BeginSection("TapeDataBlockPlayer");
ser.Sync("pauseAfter", ref pauseAfter);
ser.Sync("data", ref data, false);
ser.Sync("_pilotEnds", ref _pilotEnds);
ser.Sync("_sync1Ends", ref _sync1Ends);
ser.Sync("_sync2Ends", ref _sync2Ends);
ser.Sync("_bitStarts", ref _bitStarts);
ser.Sync("_bitPulseLength", ref _bitPulseLength);
ser.Sync("_currentBit", ref _currentBit);
ser.Sync("_termSyncEnds", ref _termSyncEnds);
ser.Sync("_pauseEnds", ref _pauseEnds);
ser.Sync("byteIndex", ref byteIndex);
ser.Sync("bitMask", ref bitMask);
ser.SyncEnum<PlayPhase>("playPhase", ref playPhase);
ser.Sync("startCycle", ref startCycle);
ser.Sync("lastCycle", ref lastCycle);
ser.EndSection();
}
}
}

128
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/TapeFilePlayer.cs
View File

@ -1,128 +0,0 @@
using BizHawk.Common;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This class recognizes .TZX and .TAP files, and playes back
/// the content accordingly.
/// </summary>
public class TapeFilePlayer : ISupportsTapeBlockPlayback
{
private readonly BinaryReader _reader;
private TapeBlockSetPlayer _player;
private int _numberOfDataBlocks;
/// <summary>
/// Data blocks to play back
/// </summary>
public List<ISupportsTapeBlockPlayback> DataBlocks { get; private set; }
/// <summary>
/// Signs that the player completed playing back the file
/// </summary>
public bool Eof => _player.Eof;
/// <summary>
/// Initializes the player from the specified reader
/// </summary>
/// <param name="reader">BinaryReader instance to get tape file data from</param>
public TapeFilePlayer(BinaryReader reader)
{
_reader = reader;
}
/// <summary>
/// Reads in the content of the tape file so that it can be played
/// </summary>
/// <returns>True, if read was successful; otherwise, false</returns>
public bool ReadContent()
{
// --- First try TzxReader
var tzxReader = new TzxReader(_reader);
var readerFound = false;
try
{
readerFound = tzxReader.ReadContent();
}
catch (Exception)
{
// --- This exception is intentionally ingnored
}
if (readerFound)
{
// --- This is a .TZX format
DataBlocks = tzxReader.DataBlocks.Where(b => b is ISupportsTapeBlockPlayback)
.Cast<ISupportsTapeBlockPlayback>()
.ToList();
_player = new TapeBlockSetPlayer(DataBlocks);
return true;
}
// --- Let's assume .TAP tap format
_reader.BaseStream.Seek(0, SeekOrigin.Begin);
var tapReader = new TapReader(_reader);
readerFound = tapReader.ReadContent();
DataBlocks = tapReader.DataBlocks.Cast<ISupportsTapeBlockPlayback>()
.ToList();
_player = new TapeBlockSetPlayer(DataBlocks);
return readerFound;
}
/// <summary>
/// Gets the currently playing block's index
/// </summary>
public int CurrentBlockIndex => _player.CurrentBlockIndex;
/// <summary>
/// The current playable block
/// </summary>
public ISupportsTapeBlockPlayback CurrentBlock => _player.CurrentBlock;
/// <summary>
/// The current playing phase
/// </summary>
public PlayPhase PlayPhase => _player.PlayPhase;
/// <summary>
/// The tact count of the CPU when playing starts
/// </summary>
public long StartCycle => _player.StartCycle;
/// <summary>
/// Initializes the player
/// </summary>
public void InitPlay(long startCycle)
{
_player.InitPlay(startCycle);
}
/// <summary>
/// Gets the EAR bit value for the specified cycle
/// </summary>
/// <param name="currentCycle">Tacts to retrieve the EAR bit</param>
/// <returns>
/// A tuple of the EAR bit and a flag that indicates it is time to move to the next block
/// </returns>
public bool GetEarBit(long currentCycle) => _player.GetEarBit(currentCycle);
/// <summary>
/// Moves the current block index to the next playable block
/// </summary>
/// <param name="currentTact">Tacts time to start the next block</param>
public void NextBlock(long currentCycle) => _player.NextBlock(currentCycle);
public void SyncState(Serializer ser)
{
ser.BeginSection("TapeFilePlayer");
ReadContent();
ser.Sync("_numberOfDataBlocks", ref _numberOfDataBlocks);
_player.SyncState(ser);
ser.EndSection();
}
}
}

17
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Machine/SpectrumBase.Sound.cs
View File

@ -1,17 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// The abstract class that all emulated models will inherit from
/// * Sound *
/// </summary>
public abstract partial class SpectrumBase
{
}
}

105
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Tape/TAP/TapDataBlock.cs
View File

@ -1,105 +0,0 @@

using BizHawk.Common;
using System.IO;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This class describes a TAP Block
/// </summary>
public sealed class TapDataBlock :
ITapeData,
ITapeDataSerialization,
ISupportsTapeBlockPlayback
{
private TapeDataBlockPlayer _player;
/// <summary>
/// Block Data
/// </summary>
private byte[] data;
public byte[] Data
{
get { return data; }
set { data = value; }
}
/// <summary>
/// Pause after this block (given in milliseconds)
/// </summary>
public ushort PauseAfter => 1000;
/// <summary>
/// Reads the content of the block from the specified binary stream.
/// </summary>
/// <param name="reader">Stream to read the block from</param>
public void ReadFrom(BinaryReader reader)
{
var length = reader.ReadUInt16();
Data = reader.ReadBytes(length);
}
/// <summary>
/// Writes the content of the block to the specified binary stream.
/// </summary>
/// <param name="writer">Stream to write the block to</param>
public void WriteTo(BinaryWriter writer)
{
writer.Write((ushort)Data.Length);
writer.Write(Data);
}
/// <summary>
/// The index of the currently playing byte
/// </summary>
/// <remarks>This proprty is made public for test purposes</remarks>
public int ByteIndex => _player.ByteIndex;
/// <summary>
/// The mask of the currently playing bit in the current byte
/// </summary>
public byte BitMask => _player.BitMask;
/// <summary>
/// The current playing phase
/// </summary>
public PlayPhase PlayPhase => _player.PlayPhase;
/// <summary>
/// The tact count of the CPU when playing starts
/// </summary>
public long StartCycle => _player.StartCycle;
/// <summary>
/// Last tact queried
/// </summary>
public long LastCycle => _player.LastCycle;
/// <summary>
/// Initializes the player
/// </summary>
public void InitPlay(long startTact)
{
_player = new TapeDataBlockPlayer(Data, PauseAfter);
_player.InitPlay(startTact);
}
/// <summary>
/// Gets the EAR bit value for the specified tact
/// </summary>
/// <param name="currentTact">Tacts to retrieve the EAR bit</param>
/// <returns>
/// The EAR bit value to play back
/// </returns>
public bool GetEarBit(long currentTact) => _player.GetEarBit(currentTact);
public void SyncState(Serializer ser)
{
ser.BeginSection("TapDataBlock");
ser.Sync("data", ref data, false);
ser.EndSection();
}
}
}

96
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Tape/TAP/TapPlayer.cs
View File

@ -1,96 +0,0 @@

using BizHawk.Common;
using System.Collections.Generic;
using System.IO;
using System.Linq;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This class is responsible to "play" a TAP file.
/// </summary>
public class TapPlayer : TapReader, ISupportsTapeBlockPlayback
{
private TapeBlockSetPlayer _player;
/// <summary>
/// Signs that the player completed playing back the file
/// </summary>
public bool Eof => _player.Eof;
/// <summary>
/// Initializes the player from the specified reader
/// </summary>
/// <param name="reader">BinaryReader instance to get TZX file data from</param>
public TapPlayer(BinaryReader reader) : base(reader)
{
}
/// <summary>
/// Reads in the content of the TZX file so that it can be played
/// </summary>
/// <returns>True, if read was successful; otherwise, false</returns>
public override bool ReadContent()
{
var success = base.ReadContent();
var blocks = DataBlocks.Cast<ISupportsTapeBlockPlayback>()
.ToList();
_player = new TapeBlockSetPlayer(blocks);
return success;
}
/// <summary>
/// Gets the currently playing block's index
/// </summary>
public int CurrentBlockIndex => _player.CurrentBlockIndex;
/// <summary>
/// The current playable block
/// </summary>
public ISupportsTapeBlockPlayback CurrentBlock => _player.CurrentBlock;
/// <summary>
/// The current playing phase
/// </summary>
public PlayPhase PlayPhase => _player.PlayPhase;
/// <summary>
/// The tact count of the CPU when playing starts
/// </summary>
public long StartCycle => _player.StartCycle;
/// <summary>
/// Initializes the player
/// </summary>
public void InitPlay(long startCycle)
{
_player.InitPlay(startCycle);
}
/// <summary>
/// Gets the EAR bit value for the specified tact
/// </summary>
/// <param name="currentCycle">Tacts to retrieve the EAR bit</param>
/// <returns>
/// A tuple of the EAR bit and a flag that indicates it is time to move to the next block
/// </returns>
public bool GetEarBit(long currentCycle) => _player.GetEarBit(currentCycle);
/// <summary>
/// Moves the current block index to the next playable block
/// </summary>
/// <param name="currentCycle">Tacts time to start the next block</param>
public void NextBlock(long currentCycle) => _player.NextBlock(currentCycle);
public void SyncState(Serializer ser)
{
ser.BeginSection("TapePlayer");
_player.SyncState(ser);
ser.EndSection();
}
}
}

52
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Tape/TAP/TapReader.cs
View File

@ -1,52 +0,0 @@

using System.Collections.Generic;
using System.IO;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This class reads a TAP file
/// </summary>
public class TapReader
{
private readonly BinaryReader _reader;
/// <summary>
/// Data blocks of this TZX file
/// </summary>
public IList<TapDataBlock> DataBlocks { get; }
/// <summary>
/// Initializes the player from the specified reader
/// </summary>
/// <param name="reader"></param>
public TapReader(BinaryReader reader)
{
_reader = reader;
DataBlocks = new List<TapDataBlock>();
}
/// <summary>
/// Reads in the content of the TZX file so that it can be played
/// </summary>
/// <returns>True, if read was successful; otherwise, false</returns>
public virtual bool ReadContent()
{
try
{
while (_reader.BaseStream.Position != _reader.BaseStream.Length)
{
var tapBlock = new TapDataBlock();
tapBlock.ReadFrom(_reader);
DataBlocks.Add(tapBlock);
}
return true;
}
catch
{
// --- This exception is intentionally ignored
return false;
}
}
}
}

172
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Tape/TZX/BlockAbstraction.cs
View File

@ -1,172 +0,0 @@

using System;
using System.IO;
using System.Text;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This class describes a TZX Block
/// </summary>
public abstract class TzxDataBlockBase : ITapeDataSerialization
{
/// <summary>
/// The ID of the block
/// </summary>
public abstract int BlockId { get; }
/// <summary>
/// Reads the content of the block from the specified binary stream.
/// </summary>
/// <param name="reader">Stream to read the block from</param>
public abstract void ReadFrom(BinaryReader reader);
/// <summary>
/// Writes the content of the block to the specified binary stream.
/// </summary>
/// <param name="writer">Stream to write the block to</param>
public abstract void WriteTo(BinaryWriter writer);
/// <summary>
/// Override this method to check the content of the block
/// </summary>
public virtual bool IsValid => true;
/// <summary>
/// Reads the specified number of words from the reader.
/// </summary>
/// <param name="reader">Reader to obtain the input from</param>
/// <param name="count">Number of words to get</param>
/// <returns>Word array read from the input</returns>
public static ushort[] ReadWords(BinaryReader reader, int count)
{
var result = new ushort[count];
var bytes = reader.ReadBytes(2 * count);
for (var i = 0; i < count; i++)
{
result[i] = (ushort)(bytes[i * 2] + bytes[i * 2 + 1] << 8);
}
return result;
}
/// <summary>
/// Writes the specified array of words to the writer
/// </summary>
/// <param name="writer">Output</param>
/// <param name="words">Word array</param>
public static void WriteWords(BinaryWriter writer, ushort[] words)
{
foreach (var word in words)
{
writer.Write(word);
}
}
/// <summary>
/// Converts the provided bytes to an ASCII string
/// </summary>
/// <param name="bytes">Bytes to convert</param>
/// <param name="offset">First byte offset</param>
/// <param name="count">Number of bytes</param>
/// <returns>ASCII string representation</returns>
public static string ToAsciiString(byte[] bytes, int offset = 0, int count = -1)
{
if (count < 0) count = bytes.Length - offset;
var sb = new StringBuilder();
for (var i = offset; i < count; i++)
{
sb.Append(Convert.ToChar(bytes[i]));
}
return sb.ToString();
}
}
/// <summary>
/// Base class for all TZX block type with data length of 3 bytes
/// </summary>
public abstract class Tzx3ByteDataBlockBase : TzxDataBlockBase
{
/// <summary>
/// Used bits in the last byte (other bits should be 0)
/// </summary>
/// <remarks>
/// (e.g. if this is 6, then the bits used(x) in the last byte are:
/// xxxxxx00, where MSb is the leftmost bit, LSb is the rightmost bit)
/// </remarks>
public byte LastByteUsedBits { get; set; }
/// <summary>
/// Lenght of block data
/// </summary>
public byte[] DataLength { get; set; }
/// <summary>
/// Block Data
/// </summary>
public byte[] Data { get; set; }
/// <summary>
/// Override this method to check the content of the block
/// </summary>
public override bool IsValid => GetLength() == Data.Length;
/// <summary>
/// Calculates data length
/// </summary>
protected int GetLength()
{
return DataLength[0] + DataLength[1] << 8 + DataLength[2] << 16;
}
}
/// <summary>
/// This class represents a TZX data block with empty body
/// </summary>
public abstract class TzxBodylessDataBlockBase : TzxDataBlockBase
{
/// <summary>
/// Reads the content of the block from the specified binary stream.
/// </summary>
/// <param name="reader">Stream to read the block from</param>
public override void ReadFrom(BinaryReader reader)
{
}
/// <summary>
/// Writes the content of the block to the specified binary stream.
/// </summary>
/// <param name="writer">Stream to write the block to</param>
public override void WriteTo(BinaryWriter writer)
{
}
}
/// <summary>
/// This class represents a deprecated block
/// </summary>
public abstract class TzxDeprecatedDataBlockBase : TzxDataBlockBase
{
/// <summary>
/// Reads through the block infromation, and does not store it
/// </summary>
/// <param name="reader">Stream to read the block from</param>
public abstract void ReadThrough(BinaryReader reader);
/// <summary>
/// Reads the content of the block from the specified binary stream.
/// </summary>
/// <param name="reader">Stream to read the block from</param>
public override void ReadFrom(BinaryReader reader)
{
}
/// <summary>
/// Writes the content of the block to the specified binary stream.
/// </summary>
/// <param name="writer">Stream to write the block to</param>
public override void WriteTo(BinaryWriter writer)
{
throw new InvalidOperationException("Deprecated TZX data blocks cannot be written.");
}
}
}

1433
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Tape/TZX/DataBlocks.cs
View File

File diff suppressed because it is too large Load Diff

250
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Tape/TZX/Info.cs
View File

@ -1,250 +0,0 @@

using System.IO;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This blocks contains information about the hardware that the programs on this tape use.
/// </summary>
public class TzxHwInfo : ITapeDataSerialization
{
/// <summary>
/// Hardware type
/// </summary>
public byte HwType { get; set; }
/// <summary>
/// Hardwer Id
/// </summary>
public byte HwId { get; set; }
/// <summary>
/// Information about the tape
/// </summary>
/// <remarks>
/// 00 - The tape RUNS on this machine or with this hardware,
/// but may or may not use the hardware or special features of the machine.
/// 01 - The tape USES the hardware or special features of the machine,
/// such as extra memory or a sound chip.
/// 02 - The tape RUNS but it DOESN'T use the hardware
/// or special features of the machine.
/// 03 - The tape DOESN'T RUN on this machine or with this hardware.
/// </remarks>
public byte TapeInfo;
/// <summary>
/// Reads the content of the block from the specified binary stream.
/// </summary>
/// <param name="reader">Stream to read the block from</param>
public void ReadFrom(BinaryReader reader)
{
HwType = reader.ReadByte();
HwId = reader.ReadByte();
TapeInfo = reader.ReadByte();
}
/// <summary>
/// Writes the content of the block to the specified binary stream.
/// </summary>
/// <param name="writer">Stream to write the block to</param>
public void WriteTo(BinaryWriter writer)
{
writer.Write(HwType);
writer.Write(HwId);
writer.Write(TapeInfo);
}
}
/// <summary>
/// Symbol repetitions
/// </summary>
public struct TzxPrle
{
/// <summary>
/// Symbol represented
/// </summary>
public byte Symbol;
/// <summary>
/// Number of repetitions
/// </summary>
public ushort Repetitions;
}
/// <summary>
/// This block represents an extremely wide range of data encoding techniques.
/// </summary>
/// <remarks>
/// The basic idea is that each loading component (pilot tone, sync pulses, data)
/// is associated to a specific sequence of pulses, where each sequence (wave) can
/// contain a different number of pulses from the others. In this way we can have
/// a situation where bit 0 is represented with 4 pulses and bit 1 with 8 pulses.
/// </remarks>
public class TzxSymDef : ITapeDataSerialization
{
/// <summary>
/// Bit 0 - Bit 1: Starting symbol polarity
/// </summary>
/// <remarks>
/// 00: opposite to the current level (make an edge, as usual) - default
/// 01: same as the current level(no edge - prolongs the previous pulse)
/// 10: force low level
/// 11: force high level
/// </remarks>
public byte SymbolFlags;
/// <summary>
/// The array of pulse lengths
/// </summary>
public ushort[] PulseLengths;
public TzxSymDef(byte maxPulses)
{
PulseLengths = new ushort[maxPulses];
}
/// <summary>
/// Reads the content of the block from the specified binary stream.
/// </summary>
/// <param name="reader">Stream to read the block from</param>
public void ReadFrom(BinaryReader reader)
{
SymbolFlags = reader.ReadByte();
PulseLengths = TzxDataBlockBase.ReadWords(reader, PulseLengths.Length);
}
/// <summary>
/// Writes the content of the block to the specified binary stream.
/// </summary>
/// <param name="writer">Stream to write the block to</param>
public void WriteTo(BinaryWriter writer)
{
writer.Write(SymbolFlags);
TzxDataBlockBase.WriteWords(writer, PulseLengths);
}
}
/// <summary>
/// This is meant to identify parts of the tape, so you know where level 1 starts,
/// where to rewind to when the game ends, etc.
/// </summary>
/// <remarks>
/// This description is not guaranteed to be shown while the tape is playing,
/// but can be read while browsing the tape or changing the tape pointer.
/// </remarks>
public class TzxText : ITapeDataSerialization
{
/// <summary>
/// Text identification byte.
/// </summary>
/// <remarks>
/// 00 - Full title
/// 01 - Software house/publisher
/// 02 - Author(s)
/// 03 - Year of publication
/// 04 - Language
/// 05 - Game/utility type
/// 06 - Price
/// 07 - Protection scheme/loader
/// 08 - Origin
/// FF - Comment(s)
/// </remarks>
public byte Type { get; set; }
/// <summary>
/// Length of the description
/// </summary>
public byte Length { get; set; }
/// <summary>
/// The description bytes
/// </summary>
public byte[] TextBytes;
/// <summary>
/// The string form of description
/// </summary>
public string Text => TzxDataBlockBase.ToAsciiString(TextBytes);
/// <summary>
/// Reads the content of the block from the specified binary stream.
/// </summary>
/// <param name="reader">Stream to read the block from</param>
public void ReadFrom(BinaryReader reader)
{
Type = reader.ReadByte();
Length = reader.ReadByte();
TextBytes = reader.ReadBytes(Length);
}
/// <summary>
/// Writes the content of the block to the specified binary stream.
/// </summary>
/// <param name="writer">Stream to write the block to</param>
public void WriteTo(BinaryWriter writer)
{
writer.Write(Type);
writer.Write(Length);
writer.Write(TextBytes);
}
}
/// <summary>
/// This block represents select structure
/// </summary>
public class TzxSelect : ITapeDataSerialization
{
/// <summary>
/// Bit 0 - Bit 1: Starting symbol polarity
/// </summary>
/// <remarks>
/// 00: opposite to the current level (make an edge, as usual) - default
/// 01: same as the current level(no edge - prolongs the previous pulse)
/// 10: force low level
/// 11: force high level
/// </remarks>
public ushort BlockOffset;
/// <summary>
/// Length of the description
/// </summary>
public byte DescriptionLength { get; set; }
/// <summary>
/// The description bytes
/// </summary>
public byte[] Description;
/// <summary>
/// The string form of description
/// </summary>
public string DescriptionText => TzxDataBlockBase.ToAsciiString(Description);
public TzxSelect(byte length)
{
DescriptionLength = length;
}
/// <summary>
/// Reads the content of the block from the specified binary stream.
/// </summary>
/// <param name="reader">Stream to read the block from</param>
public void ReadFrom(BinaryReader reader)
{
BlockOffset = reader.ReadUInt16();
DescriptionLength = reader.ReadByte();
Description = reader.ReadBytes(DescriptionLength);
}
/// <summary>
/// Writes the content of the block to the specified binary stream.
/// </summary>
/// <param name="writer">Stream to write the block to</param>
public void WriteTo(BinaryWriter writer)
{
writer.Write(BlockOffset);
writer.Write(DescriptionLength);
writer.Write(Description);
}
}
}

282
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Tape/TZX/Types.cs
View File

@ -1,282 +0,0 @@

namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// Identified AD or DA converter types
/// </summary>
public enum TzxAdOrDaConverterType : byte
{
HarleySystemsAdc8P2 = 0x00,
BlackboardElectronics = 0x01
}
/// <summary>
/// Identified computer types
/// </summary>
public enum TzxComputerType : byte
{
ZxSpectrum16 = 0x00,
ZxSpectrum48OrPlus = 0x01,
ZxSpectrum48Issue1 = 0x02,
ZxSpectrum128 = 0x03,
ZxSpectrum128P2 = 0x04,
ZxSpectrum128P2AOr3 = 0x05,
Tc2048 = 0x06,
Ts2068 = 0x07,
Pentagon128 = 0x08,
SamCoupe = 0x09,
DidaktikM = 0x0A,
DidaktikGama = 0x0B,
Zx80 = 0x0C,
Zx81 = 0x0D,
ZxSpectrum128Spanish = 0x0E,
ZxSpectrumArabic = 0x0F,
Tk90X = 0x10,
Tk95 = 0x11,
Byte = 0x12,
Elwro800D3 = 0x13,
ZsScorpion256 = 0x14,
AmstradCpc464 = 0x15,
AmstradCpc664 = 0x16,
AmstradCpc6128 = 0x17,
AmstradCpc464P = 0x18,
AmstradCpc6128P = 0x19,
JupiterAce = 0x1A,
Enterprise = 0x1B,
Commodore64 = 0x1C,
Commodore128 = 0x1D,
InvesSpectrumP = 0x1E,
Profi = 0x1F,
GrandRomMax = 0x20,
Kay1024 = 0x21,
IceFelixHc91 = 0x22,
IceFelixHc2000 = 0x23,
AmaterskeRadioMistrum = 0x24,
Quorum128 = 0x25,
MicroArtAtm = 0x26,
MicroArtAtmTurbo2 = 0x27,
Chrome = 0x28,
ZxBadaloc = 0x29,
Ts1500 = 0x2A,
Lambda = 0x2B,
Tk65 = 0x2C,
Zx97 = 0x2D
}
/// <summary>
/// Identified digitizer types
/// </summary>
public enum TzxDigitizerType : byte
{
RdDigitalTracer = 0x00,
DkTronicsLightPen = 0x01,
MicrographPad = 0x02,
RomnticRobotVideoface = 0x03
}
/// <summary>
/// Identified EPROM programmer types
/// </summary>
public enum TzxEpromProgrammerType : byte
{
OrmeElectronics = 0x00
}
/// <summary>
/// Identified external storage types
/// </summary>
public enum TzxExternalStorageType : byte
{
ZxMicroDrive = 0x00,
OpusDiscovery = 0x01,
MgtDisciple = 0x02,
MgtPlusD = 0x03,
RobotronicsWafaDrive = 0x04,
TrDosBetaDisk = 0x05,
ByteDrive = 0x06,
Watsford = 0x07,
Fiz = 0x08,
Radofin = 0x09,
DidaktikDiskDrive = 0x0A,
BsDos = 0x0B,
ZxSpectrumP3DiskDrive = 0x0C,
JloDiskInterface = 0x0D,
TimexFdd3000 = 0x0E,
ZebraDiskDrive = 0x0F,
RamexMillenia = 0x10,
Larken = 0x11,
KempstonDiskInterface = 0x12,
Sandy = 0x13,
ZxSpectrumP3EHardDisk = 0x14,
ZxAtaSp = 0x15,
DivIde = 0x16,
ZxCf = 0x17
}
/// <summary>
/// Identified graphics types
/// </summary>
public enum TzxGraphicsType : byte
{
WrxHiRes = 0x00,
G007 = 0x01,
Memotech = 0x02,
LambdaColour = 0x03
}
/// <summary>
/// Represents the hardware types that can be defined
/// </summary>
public enum TzxHwType : byte
{
Computer = 0x00,
ExternalStorage = 0x01,
RomOrRamTypeAddOn = 0x02,
SoundDevice = 0x03,
JoyStick = 0x04,
Mouse = 0x05,
OtherController = 0x06,
SerialPort = 0x07,
ParallelPort = 0x08,
Printer = 0x09,
Modem = 0x0A,
Digitizer = 0x0B,
NetworkAdapter = 0x0C,
Keyboard = 0x0D,
AdOrDaConverter = 0x0E,
EpromProgrammer = 0x0F,
Graphics = 0x10
}
/// <summary>
/// Identified joystick types
/// </summary>
public enum TzxJoystickType
{
Kempston = 0x00,
ProtekCursor = 0x01,
Sinclair2Left = 0x02,
Sinclair1Right = 0x03,
Fuller = 0x04
}
/// <summary>
/// Identified keyboard and keypad types
/// </summary>
public enum TzxKeyboardType : byte
{
KeypadForZxSpectrum128K = 0x00
}
/// <summary>
/// Identified modem types
/// </summary>
public enum TzxModemTypes : byte
{
PrismVtx5000 = 0x00,
Westridge2050 = 0x01
}
/// <summary>
/// Identified mouse types
/// </summary>
public enum TzxMouseType : byte
{
AmxMouse = 0x00,
KempstonMouse = 0x01
}
/// <summary>
/// Identified network adapter types
/// </summary>
public enum TzxNetworkAdapterType : byte
{
ZxInterface1 = 0x00
}
/// <summary>
/// Identified other controller types
/// </summary>
public enum TzxOtherControllerType : byte
{
Trisckstick = 0x00,
ZxLightGun = 0x01,
ZebraGraphicTablet = 0x02,
DefnederLightGun = 0x03
}
/// <summary>
/// Identified parallel port types
/// </summary>
public enum TzxParallelPortType : byte
{
KempstonS = 0x00,
KempstonE = 0x01,
ZxSpectrum3P = 0x02,
Tasman = 0x03,
DkTronics = 0x04,
Hilderbay = 0x05,
InesPrinterface = 0x06,
ZxLprintInterface3 = 0x07,
MultiPrint = 0x08,
OpusDiscovery = 0x09,
Standard8255 = 0x0A
}
/// <summary>
/// Identified printer types
/// </summary>
public enum TzxPrinterType : byte
{
ZxPrinter = 0x00,
GenericPrinter = 0x01,
EpsonCompatible = 0x02
}
/// <summary>
/// Identifier ROM or RAM add-on types
/// </summary>
public enum TzxRomRamAddOnType : byte
{
SamRam = 0x00,
MultifaceOne = 0x01,
Multiface128K = 0x02,
MultifaceP3 = 0x03,
MultiPrint = 0x04,
Mb02 = 0x05,
SoftRom = 0x06,
Ram1K = 0x07,
Ram16K = 0x08,
Ram48K = 0x09,
Mem8To16KUsed = 0x0A
}
/// <summary>
/// Identified serial port types
/// </summary>
public enum TzxSerialPortType : byte
{
ZxInterface1 = 0x00,
ZxSpectrum128 = 0x01
}
/// <summary>
/// Identified sound device types
/// </summary>
public enum TzxSoundDeviceType : byte
{
ClassicAy = 0x00,
FullerBox = 0x01,
CurrahMicroSpeech = 0x02,
SpectDrum = 0x03,
MelodikAyAcbStereo = 0x04,
AyAbcStereo = 0x05,
RamMusinMachine = 0x06,
Covox = 0x07,
GeneralSound = 0x08,
IntecEdiB8001 = 0x09,
ZonXAy = 0x0A,
QuickSilvaAy = 0x0B,
JupiterAce = 0x0C
}
}

28
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Tape/TZX/TzxException.cs
View File

@ -1,28 +0,0 @@
using System;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This class represents a TZX-related exception
/// </summary>
public class TzxException : Exception
{
/// <summary>
/// Initializes the exception with the specified message
/// </summary>
/// <param name="message">Exception message</param>
public TzxException(string message) : base(message)
{
}
/// <summary>
/// Initializes the exception with the specified message
/// and inner exception
/// </summary>
/// <param name="message">Exception message</param>
/// <param name="innerException">Inner exception</param>
public TzxException(string message, Exception innerException) : base(message, innerException)
{
}
}
}

68
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Tape/TZX/TzxHeader.cs
View File

@ -1,68 +0,0 @@
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// Represents the header of the TZX file
/// </summary>
public class TzxHeader : TzxDataBlockBase
{
public static IReadOnlyList<byte> TzxSignature =
new ReadOnlyCollection<byte>(new byte[] { 0x5A, 0x58, 0x54, 0x61, 0x70, 0x65, 0x21 });
public byte[] Signature { get; private set; }
public byte Eot { get; private set; }
public byte MajorVersion { get; private set; }
public byte MinorVersion { get; private set; }
public TzxHeader(byte majorVersion = 1, byte minorVersion = 20)
{
Signature = TzxSignature.ToArray();
Eot = 0x1A;
MajorVersion = majorVersion;
MinorVersion = minorVersion;
}
/// <summary>
/// The ID of the block
/// </summary>
public override int BlockId => 0x00;
/// <summary>
/// Reads the content of the block from the specified binary stream.
/// </summary>
/// <param name="reader">Stream to read the block from</param>
public override void ReadFrom(BinaryReader reader)
{
Signature = reader.ReadBytes(7);
Eot = reader.ReadByte();
MajorVersion = reader.ReadByte();
MinorVersion = reader.ReadByte();
}
/// <summary>
/// Writes the content of the block to the specified binary stream.
/// </summary>
/// <param name="writer">Stream to write the block to</param>
public override void WriteTo(BinaryWriter writer)
{
writer.Write(Signature);
writer.Write(Eot);
writer.Write(MajorVersion);
writer.Write(MinorVersion);
}
#region Overrides of TzxDataBlockBase
/// <summary>
/// Override this method to check the content of the block
/// </summary>
public override bool IsValid => Signature.SequenceEqual(TzxSignature)
&& Eot == 0x1A
&& MajorVersion == 1;
#endregion
}
}

94
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Tape/TZX/TzxPlayer.cs
View File

@ -1,94 +0,0 @@
using BizHawk.Common;
using System.IO;
using System.Linq;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This class is responsible to "play" a TZX file.
/// </summary>
public class TzxPlayer : TzxReader, ISupportsTapeBlockPlayback
{
private TapeBlockSetPlayer _player;
/// <summary>
/// Signs that the player completed playing back the file
/// </summary>
public bool Eof => _player.Eof;
/// <summary>
/// Initializes the player from the specified reader
/// </summary>
/// <param name="reader">BinaryReader instance to get TZX file data from</param>
public TzxPlayer(BinaryReader reader) : base(reader)
{
}
/// <summary>
/// Reads in the content of the TZX file so that it can be played
/// </summary>
/// <returns>True, if read was successful; otherwise, false</returns>
public override bool ReadContent()
{
var success = base.ReadContent();
var blocks = DataBlocks.Where(b => b is ISupportsTapeBlockPlayback)
.Cast<ISupportsTapeBlockPlayback>()
.ToList();
_player = new TapeBlockSetPlayer(blocks);
return success;
}
/// <summary>
/// Gets the currently playing block's index
/// </summary>
public int CurrentBlockIndex => _player.CurrentBlockIndex;
/// <summary>
/// The current playable block
/// </summary>
public ISupportsTapeBlockPlayback CurrentBlock => _player.CurrentBlock;
/// <summary>
/// The current playing phase
/// </summary>
public PlayPhase PlayPhase => _player.PlayPhase;
/// <summary>
/// The tact count of the CPU when playing starts
/// </summary>
public long StartCycle => _player.StartCycle;
/// <summary>
/// Initializes the player
/// </summary>
public void InitPlay(long startTact)
{
_player.InitPlay(startTact);
}
/// <summary>
/// Gets the EAR bit value for the specified tact
/// </summary>
/// <param name="currentTact">Tacts to retrieve the EAR bit</param>
/// <returns>
/// A tuple of the EAR bit and a flag that indicates it is time to move to the next block
/// </returns>
public bool GetEarBit(long currentTact) => _player.GetEarBit(currentTact);
/// <summary>
/// Moves the current block index to the next playable block
/// </summary>
/// <param name="currentTact">Tacts time to start the next block</param>
public void NextBlock(long currentTact) => _player.NextBlock(currentTact);
public void SyncState(Serializer ser)
{
ser.BeginSection("TzxPlayer");
_player.SyncState(ser);
ser.EndSection();
}
}
}

125
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Tape/TZX/TzxReader.cs
View File

@ -1,125 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
/// <summary>
/// This class reads a TZX file
/// </summary>
public class TzxReader
{
private readonly BinaryReader _reader;
public static Dictionary<byte, Type> DataBlockTypes = new Dictionary<byte, Type>
{
{0x10, typeof(TzxStandardSpeedDataBlock)},
{0x11, typeof(TzxTurboSpeedDataBlock)},
{0x12, typeof(TzxPureToneDataBlock)},
{0x13, typeof(TzxPulseSequenceDataBlock)},
{0x14, typeof(TzxPureDataBlock)},
{0x15, typeof(TzxDirectRecordingDataBlock)},
{0x16, typeof(TzxC64RomTypeDataBlock)},
{0x17, typeof(TzxC64TurboTapeDataBlock)},
{0x18, typeof(TzxCswRecordingDataBlock)},
{0x19, typeof(TzxGeneralizedDataBlock)},
{0x20, typeof(TzxSilenceDataBlock)},
{0x21, typeof(TzxGroupStartDataBlock)},
{0x22, typeof(TzxGroupEndDataBlock)},
{0x23, typeof(TzxJumpDataBlock)},
{0x24, typeof(TzxLoopStartDataBlock)},
{0x25, typeof(TzxLoopEndDataBlock)},
{0x26, typeof(TzxCallSequenceDataBlock)},
{0x27, typeof(TzxReturnFromSequenceDataBlock)},
{0x28, typeof(TzxSelectDataBlock)},
{0x2A, typeof(TzxStopTheTape48DataBlock)},
{0x2B, typeof(TzxSetSignalLevelDataBlock)},
{0x30, typeof(TzxTextDescriptionDataBlock)},
{0x31, typeof(TzxMessageDataBlock)},
{0x32, typeof(TzxArchiveInfoDataBlock)},
{0x33, typeof(TzxHardwareInfoDataBlock)},
{0x34, typeof(TzxEmulationInfoDataBlock)},
{0x35, typeof(TzxCustomInfoDataBlock)},
{0x40, typeof(TzxSnapshotBlock)},
{0x5A, typeof(TzxGlueDataBlock)},
};
/// <summary>
/// Data blocks of this TZX file
/// </summary>
public IList<TzxDataBlockBase> DataBlocks { get; }
/// <summary>
/// Major version number of the file
/// </summary>
public byte MajorVersion { get; private set; }
/// <summary>
/// Minor version number of the file
/// </summary>
public byte MinorVersion { get; private set; }
/// <summary>
/// Initializes the player from the specified reader
/// </summary>
/// <param name="reader"></param>
public TzxReader(BinaryReader reader)
{
_reader = reader;
DataBlocks = new List<TzxDataBlockBase>();
}
/// <summary>
/// Reads in the content of the TZX file so that it can be played
/// </summary>
/// <returns>True, if read was successful; otherwise, false</returns>
public virtual bool ReadContent()
{
var header = new TzxHeader();
try
{
header.ReadFrom(_reader);
if (!header.IsValid)
{
throw new TzxException("Invalid TZX header");
}
MajorVersion = header.MajorVersion;
MinorVersion = header.MinorVersion;
while (_reader.BaseStream.Position != _reader.BaseStream.Length)
{
var blockType = _reader.ReadByte();
Type type;
if (!DataBlockTypes.TryGetValue(blockType, out type))
{
throw new TzxException($"Unkonwn TZX block type: {blockType}");
}
try
{
var block = Activator.CreateInstance(type) as TzxDataBlockBase;
if (block.GetType() == typeof(TzxDeprecatedDataBlockBase))
{
((TzxDeprecatedDataBlockBase)block as TzxDeprecatedDataBlockBase).ReadThrough(_reader);
}
else
{
block?.ReadFrom(_reader);
}
DataBlocks.Add(block);
}
catch (Exception ex)
{
throw new TzxException($"Cannot read TZX data block {type}.", ex);
}
}
return true;
}
catch
{
// --- This exception is intentionally ignored
return false;
}
}
}
}

10
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/readme.md
View File

@ -1,6 +1,6 @@
## ZXHawk
At this moment this is still *very* experimental and needs a lot more work.
At the moment this is very experimental and is still actively being worked on.
### Implemented and sorta working
* IEmulator
@ -13,21 +13,23 @@ At this moment this is still *very* experimental and needs a lot more work.
* Keyboard input (implementing IInputPollable)
* Kempston joystick (mapped to J1 currently)
* Tape device that will load spectrum games in realtime (*.tzx and *.tap)
* Most tape protection/loading schemes that I've tested are currently working (see caveat below)
* IStatable
* ISettable core settings
* IMemoryDomains (I think)
### Work in progress
* Exact emulator timings
* Floating memory bus emulation
* Tape auto-loading routines (currently you have to manually start and stop the virtual tape device)
* TASStudio (need to verify that this works as it should)
### Not working
* IDebuggable
* IDebuggable (probably IMemoryDomains is setup incorrectly)
* ZX Spectrum Plus3 emulation
* Default keyboard keymappings (you have to configure yourself in the core controller settings)
### Known bugs
* Audible 'popping' from the emulated buzzer after a load state operation
* Audible 'popping' from the emulated buzzer after a load state operation (maybe this is a normal thing)
* Speedlock tape protection scheme doesn't appear to load correctly
-Asnivor