aaru-dps/Aaru
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.git synced 2025-12-16 19:24:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move to file scoped namespaces.

Browse Source
This commit is contained in:
Natalia Portillo
2022-03-06 13:29:37 +00:00
parent c7178d94c6
commit 3b6091c02c
119 changed files with 38048 additions and 38172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
Floppy/Amiga.cs
View File

@@ -33,38 +33,37 @@
using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices;
namespace Aaru.Decoders.Floppy
namespace Aaru.Decoders.Floppy;
/// <summary>Methods and structures for Commodore Amiga decoding</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
public static class Amiga
{
/// <summary>Methods and structures for Commodore Amiga decoding</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
public static class Amiga
public struct Sector
{
public struct Sector
{
/// <summary>Set to 0x00</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] zero;
/// <summary>Set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] sync;
/// <summary>Set to 0xFF</summary>
public byte amiga;
/// <summary>Track number</summary>
public byte track;
/// <summary>Sector number</summary>
public byte sector;
/// <summary>Remaining sectors til end of writing</summary>
public byte remaining;
/// <summary>OS dependent tag</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
public byte[] label;
/// <summary>Checksum from <see cref="amiga" /> to <see cref="label" /></summary>
public uint headerChecksum;
/// <summary>Checksum from <see cref="data" /></summary>
public uint dataChecksum;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 512)]
public byte[] data;
}
/// <summary>Set to 0x00</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] zero;
/// <summary>Set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] sync;
/// <summary>Set to 0xFF</summary>
public byte amiga;
/// <summary>Track number</summary>
public byte track;
/// <summary>Sector number</summary>
public byte sector;
/// <summary>Remaining sectors til end of writing</summary>
public byte remaining;
/// <summary>OS dependent tag</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
public byte[] label;
/// <summary>Checksum from <see cref="amiga" /> to <see cref="label" /></summary>
public uint headerChecksum;
/// <summary>Checksum from <see cref="data" /></summary>
public uint dataChecksum;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 512)]
public byte[] data;
}
}

1103
Floppy/Apple2.cs
View File

File diff suppressed because it is too large Load Diff

812
Floppy/AppleSony.cs
View File

@@ -37,477 +37,475 @@ using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
namespace Aaru.Decoders.Floppy
namespace Aaru.Decoders.Floppy;
// Information from:
// Inside Macintosh, Volume II, ISBN 0-201-17732-3
/// <summary>Methods and structures for Apple Sony GCR floppy decoding</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global"), SuppressMessage("ReSharper", "NotAccessedField.Global")]
public static class AppleSony
{
// Information from:
// Inside Macintosh, Volume II, ISBN 0-201-17732-3
/// <summary>Methods and structures for Apple Sony GCR floppy decoding</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global"), SuppressMessage("ReSharper", "NotAccessedField.Global")]
public static class AppleSony
public static byte[] DecodeSector(RawSector sector)
{
public static byte[] DecodeSector(RawSector sector)
if(sector.addressField.prologue[0] != 0xD5 ||
sector.addressField.prologue[1] != 0xAA ||
sector.addressField.prologue[2] != 0x96)
return null;
byte[] bf1 = new byte[175];
byte[] bf2 = new byte[175];
byte[] bf3 = new byte[175];
byte[] nib_data = sector.dataField.data;
var ms = new MemoryStream();
int j = 0;
byte w3 = 0;
for(int i = 0; i <= 174; i++)
{
if(sector.addressField.prologue[0] != 0xD5 ||
sector.addressField.prologue[1] != 0xAA ||
sector.addressField.prologue[2] != 0x96)
return null;
byte w4 = nib_data[j++];
byte w1 = nib_data[j++];
byte w2 = nib_data[j++];
byte[] bf1 = new byte[175];
byte[] bf2 = new byte[175];
byte[] bf3 = new byte[175];
byte[] nib_data = sector.dataField.data;
var ms = new MemoryStream();
if(i != 174)
w3 = nib_data[j++];
int j = 0;
byte w3 = 0;
for(int i = 0; i <= 174; i++)
{
byte w4 = nib_data[j++];
byte w1 = nib_data[j++];
byte w2 = nib_data[j++];
if(i != 174)
w3 = nib_data[j++];
bf1[i] = (byte)(((w1 & 0x3F) | ((w4 << 2) & 0xC0)) & 0x0F);
bf2[i] = (byte)(((w2 & 0x3F) | ((w4 << 4) & 0xC0)) & 0x0F);
bf3[i] = (byte)(((w3 & 0x3F) | ((w4 << 6) & 0xC0)) & 0x0F);
}
j = 0;
uint ck1 = 0;
uint ck2 = 0;
uint ck3 = 0;
while(true)
{
ck1 = (ck1 & 0xFF) << 1;
if((ck1 & 0x0100) > 0)
ck1++;
byte carry = (byte)((bf1[j] ^ ck1) & 0xFF);
ck3 += carry;
if((ck1 & 0x0100) > 0)
{
ck3++;
ck1 &= 0xFF;
}
ms.WriteByte(carry);
carry = (byte)((bf2[j] ^ ck3) & 0xFF);
ck2 += carry;
if(ck3 > 0xFF)
{
ck2++;
ck3 &= 0xFF;
}
ms.WriteByte(carry);
if(ms.Length == 524)
break;
carry = (byte)((bf3[j] ^ ck2) & 0xFF);
ck1 += carry;
if(ck2 > 0xFF)
{
ck1++;
ck2 &= 0xFF;
}
ms.WriteByte(carry);
j++;
}
return ms.ToArray();
// Not Apple Sony GCR?
bf1[i] = (byte)(((w1 & 0x3F) | ((w4 << 2) & 0xC0)) & 0x0F);
bf2[i] = (byte)(((w2 & 0x3F) | ((w4 << 4) & 0xC0)) & 0x0F);
bf3[i] = (byte)(((w3 & 0x3F) | ((w4 << 6) & 0xC0)) & 0x0F);
}
public static RawSector MarshalSector(byte[] data, int offset = 0) => MarshalSector(data, out _, offset);
j = 0;
uint ck1 = 0;
uint ck2 = 0;
uint ck3 = 0;
public static RawSector MarshalSector(byte[] data, out int endOffset, int offset = 0)
while(true)
{
endOffset = offset;
ck1 = (ck1 & 0xFF) << 1;
// Not an Apple ][ GCR sector
if(data == null ||
data.Length < 363)
return null;
if((ck1 & 0x0100) > 0)
ck1++;
int position = offset;
byte carry = (byte)((bf1[j] ^ ck1) & 0xFF);
ck3 += carry;
try
if((ck1 & 0x0100) > 0)
{
while(position < data.Length)
ck3++;
ck1 &= 0xFF;
}
ms.WriteByte(carry);
carry = (byte)((bf2[j] ^ ck3) & 0xFF);
ck2 += carry;
if(ck3 > 0xFF)
{
ck2++;
ck3 &= 0xFF;
}
ms.WriteByte(carry);
if(ms.Length == 524)
break;
carry = (byte)((bf3[j] ^ ck2) & 0xFF);
ck1 += carry;
if(ck2 > 0xFF)
{
ck1++;
ck2 &= 0xFF;
}
ms.WriteByte(carry);
j++;
}
return ms.ToArray();
// Not Apple Sony GCR?
}
public static RawSector MarshalSector(byte[] data, int offset = 0) => MarshalSector(data, out _, offset);
public static RawSector MarshalSector(byte[] data, out int endOffset, int offset = 0)
{
endOffset = offset;
// Not an Apple ][ GCR sector
if(data == null ||
data.Length < 363)
return null;
int position = offset;
try
{
while(position < data.Length)
{
// Prologue found
if(data[position] == 0xD5 &&
data[position + 1] == 0xAA &&
data[position + 2] == 0x96)
{
// Prologue found
if(data[position] == 0xD5 &&
data[position + 1] == 0xAA &&
data[position + 2] == 0x96)
// Epilogue not in correct position
if(data[position + 8] != 0xDE ||
data[position + 9] != 0xAA)
return null;
var sector = new RawSector
{
// Epilogue not in correct position
if(data[position + 8] != 0xDE ||
data[position + 9] != 0xAA)
return null;
var sector = new RawSector
{
addressField = new RawAddressField
{
prologue = new[]
{
data[position], data[position + 1], data[position + 2]
},
track = data[position + 3],
sector = data[position + 4],
side = data[position + 5],
format = (AppleEncodedFormat)data[position + 6],
checksum = data[position + 7],
epilogue = new[]
{
data[position + 8], data[position + 9]
}
}
};
position += 10;
int syncCount = 0;
bool onSync = false;
var gaps = new MemoryStream();
while(data[position] == 0xFF)
{
gaps.WriteByte(data[position]);
syncCount++;
onSync = syncCount >= 5;
position++;
}
// Lost sync
if(!onSync)
return null;
// Prologue not found
if(data[position] != 0xDE ||
data[position + 1] != 0xAA ||
data[position + 2] != 0xAD)
return null;
sector.innerGap = gaps.ToArray();
sector.dataField = new RawDataField
addressField = new RawAddressField
{
prologue = new[]
{
data[position], data[position + 1], data[position + 2]
},
spare = data[position + 3]
};
position += 4;
gaps = new MemoryStream();
// Read data until epilogue is found
while(data[position + 4] != 0xD5 ||
data[position + 5] != 0xAA)
{
gaps.WriteByte(data[position]);
position++;
// No space left for epilogue
if(position + 7 > data.Length)
return null;
track = data[position + 3],
sector = data[position + 4],
side = data[position + 5],
format = (AppleEncodedFormat)data[position + 6],
checksum = data[position + 7],
epilogue = new[]
{
data[position + 8], data[position + 9]
}
}
};
sector.dataField.data = gaps.ToArray();
sector.dataField.checksum = new byte[4];
sector.dataField.checksum[0] = data[position];
sector.dataField.checksum[1] = data[position + 2];
sector.dataField.checksum[2] = data[position + 3];
sector.dataField.checksum[3] = data[position + 4];
sector.dataField.epilogue = new byte[2];
sector.dataField.epilogue[0] = data[position + 5];
sector.dataField.epilogue[1] = data[position + 6];
position += 10;
int syncCount = 0;
bool onSync = false;
var gaps = new MemoryStream();
position += 7;
gaps = new MemoryStream();
// Read gap, if any
while(position < data.Length &&
data[position] == 0xFF)
{
gaps.WriteByte(data[position]);
position++;
}
// Reduces last sector gap so doesn't eat next tracks's gap
if(gaps.Length > 5)
{
gaps.SetLength(gaps.Length / 2);
position -= (int)gaps.Length;
}
sector.gap = gaps.ToArray();
// Return current position to be able to read separate sectors
endOffset = position;
return sector;
while(data[position] == 0xFF)
{
gaps.WriteByte(data[position]);
syncCount++;
onSync = syncCount >= 5;
position++;
}
if(data[position] == 0xFF)
// Lost sync
if(!onSync)
return null;
// Prologue not found
if(data[position] != 0xDE ||
data[position + 1] != 0xAA ||
data[position + 2] != 0xAD)
return null;
sector.innerGap = gaps.ToArray();
sector.dataField = new RawDataField
{
prologue = new[]
{
data[position], data[position + 1], data[position + 2]
},
spare = data[position + 3]
};
position += 4;
gaps = new MemoryStream();
// Read data until epilogue is found
while(data[position + 4] != 0xD5 ||
data[position + 5] != 0xAA)
{
gaps.WriteByte(data[position]);
position++;
// Found data that is not sync or a prologue
else
return null;
}
}
catch(IndexOutOfRangeException)
{
return null;
}
// No space left for epilogue
if(position + 7 > data.Length)
return null;
}
sector.dataField.data = gaps.ToArray();
sector.dataField.checksum = new byte[4];
sector.dataField.checksum[0] = data[position];
sector.dataField.checksum[1] = data[position + 2];
sector.dataField.checksum[2] = data[position + 3];
sector.dataField.checksum[3] = data[position + 4];
sector.dataField.epilogue = new byte[2];
sector.dataField.epilogue[0] = data[position + 5];
sector.dataField.epilogue[1] = data[position + 6];
position += 7;
gaps = new MemoryStream();
// Read gap, if any
while(position < data.Length &&
data[position] == 0xFF)
{
gaps.WriteByte(data[position]);
position++;
}
// Reduces last sector gap so doesn't eat next tracks's gap
if(gaps.Length > 5)
{
gaps.SetLength(gaps.Length / 2);
position -= (int)gaps.Length;
}
sector.gap = gaps.ToArray();
// Return current position to be able to read separate sectors
endOffset = position;
return sector;
}
if(data[position] == 0xFF)
position++;
// Found data that is not sync or a prologue
else
return null;
}
}
catch(IndexOutOfRangeException)
{
return null;
}
public static byte[] MarshalAddressField(RawAddressField addressField)
return null;
}
public static byte[] MarshalAddressField(RawAddressField addressField)
{
if(addressField == null)
return null;
var raw = new MemoryStream();
raw.Write(addressField.prologue, 0, addressField.prologue.Length);
raw.WriteByte(addressField.track);
raw.WriteByte(addressField.sector);
raw.WriteByte(addressField.side);
raw.WriteByte((byte)addressField.format);
raw.WriteByte(addressField.checksum);
return raw.ToArray();
}
public static byte[] MarshalSector(RawSector sector)
{
if(sector == null)
return null;
var raw = new MemoryStream();
raw.Write(sector.addressField.prologue, 0, sector.addressField.prologue.Length);
raw.WriteByte(sector.addressField.track);
raw.WriteByte(sector.addressField.sector);
raw.WriteByte(sector.addressField.side);
raw.WriteByte((byte)sector.addressField.format);
raw.WriteByte(sector.addressField.checksum);
raw.Write(sector.innerGap, 0, sector.innerGap.Length);
raw.Write(sector.dataField.prologue, 0, sector.dataField.prologue.Length);
raw.WriteByte(sector.dataField.spare);
raw.Write(sector.dataField.data, 0, sector.dataField.data.Length);
raw.Write(sector.dataField.checksum, 0, sector.dataField.checksum.Length);
raw.Write(sector.dataField.epilogue, 0, sector.dataField.epilogue.Length);
raw.Write(sector.gap, 0, sector.gap.Length);
return raw.ToArray();
}
public static RawTrack MarshalTrack(byte[] data, int offset = 0) => MarshalTrack(data, out _, offset);
public static RawTrack MarshalTrack(byte[] data, out int endOffset, int offset = 0)
{
int position = offset;
bool firstSector = true;
bool onSync = false;
var gaps = new MemoryStream();
int count = 0;
List<RawSector> sectors = new List<RawSector>();
byte trackNumber = 0;
byte sideNumber = 0;
endOffset = offset;
while(position < data.Length &&
data[position] == 0xFF)
{
if(addressField == null)
return null;
var raw = new MemoryStream();
raw.Write(addressField.prologue, 0, addressField.prologue.Length);
raw.WriteByte(addressField.track);
raw.WriteByte(addressField.sector);
raw.WriteByte(addressField.side);
raw.WriteByte((byte)addressField.format);
raw.WriteByte(addressField.checksum);
return raw.ToArray();
gaps.WriteByte(data[position]);
count++;
position++;
onSync = count >= 5;
}
public static byte[] MarshalSector(RawSector sector)
if(position >= data.Length)
return null;
if(!onSync)
return null;
while(position < data.Length)
{
int oldPosition = position;
RawSector sector = MarshalSector(data, out position, position);
if(sector == null)
return null;
break;
var raw = new MemoryStream();
raw.Write(sector.addressField.prologue, 0, sector.addressField.prologue.Length);
raw.WriteByte(sector.addressField.track);
raw.WriteByte(sector.addressField.sector);
raw.WriteByte(sector.addressField.side);
raw.WriteByte((byte)sector.addressField.format);
raw.WriteByte(sector.addressField.checksum);
raw.Write(sector.innerGap, 0, sector.innerGap.Length);
raw.Write(sector.dataField.prologue, 0, sector.dataField.prologue.Length);
raw.WriteByte(sector.dataField.spare);
raw.Write(sector.dataField.data, 0, sector.dataField.data.Length);
raw.Write(sector.dataField.checksum, 0, sector.dataField.checksum.Length);
raw.Write(sector.dataField.epilogue, 0, sector.dataField.epilogue.Length);
raw.Write(sector.gap, 0, sector.gap.Length);
return raw.ToArray();
}
public static RawTrack MarshalTrack(byte[] data, int offset = 0) => MarshalTrack(data, out _, offset);
public static RawTrack MarshalTrack(byte[] data, out int endOffset, int offset = 0)
{
int position = offset;
bool firstSector = true;
bool onSync = false;
var gaps = new MemoryStream();
int count = 0;
List<RawSector> sectors = new List<RawSector>();
byte trackNumber = 0;
byte sideNumber = 0;
endOffset = offset;
while(position < data.Length &&
data[position] == 0xFF)
if(firstSector)
{
gaps.WriteByte(data[position]);
count++;
position++;
onSync = count >= 5;
trackNumber = sector.addressField.track;
sideNumber = sector.addressField.side;
firstSector = false;
}
if(position >= data.Length)
return null;
if(!onSync)
return null;
while(position < data.Length)
if(sector.addressField.track != trackNumber ||
sector.addressField.side != sideNumber)
{
int oldPosition = position;
RawSector sector = MarshalSector(data, out position, position);
position = oldPosition;
if(sector == null)
break;
if(firstSector)
{
trackNumber = sector.addressField.track;
sideNumber = sector.addressField.side;
firstSector = false;
}
if(sector.addressField.track != trackNumber ||
sector.addressField.side != sideNumber)
{
position = oldPosition;
break;
}
sectors.Add(sector);
break;
}
if(sectors.Count == 0)
return null;
var track = new RawTrack
{
gap = gaps.ToArray(),
sectors = sectors.ToArray()
};
endOffset = position;
return track;
sectors.Add(sector);
}
public static byte[] MarshalTrack(RawTrack track)
if(sectors.Count == 0)
return null;
var track = new RawTrack
{
if(track == null)
return null;
gap = gaps.ToArray(),
sectors = sectors.ToArray()
};
var raw = new MemoryStream();
raw.Write(track.gap, 0, track.gap.Length);
endOffset = position;
foreach(byte[] rawSector in track.sectors.Select(MarshalSector))
raw.Write(rawSector, 0, rawSector.Length);
return track;
}
return raw.ToArray();
}
public static byte[] MarshalTrack(RawTrack track)
{
if(track == null)
return null;
public static List<RawTrack> MarshalDisk(byte[] data, int offset = 0) => MarshalDisk(data, out _, offset);
var raw = new MemoryStream();
raw.Write(track.gap, 0, track.gap.Length);
public static List<RawTrack> MarshalDisk(byte[] data, out int endOffset, int offset = 0)
foreach(byte[] rawSector in track.sectors.Select(MarshalSector))
raw.Write(rawSector, 0, rawSector.Length);
return raw.ToArray();
}
public static List<RawTrack> MarshalDisk(byte[] data, int offset = 0) => MarshalDisk(data, out _, offset);
public static List<RawTrack> MarshalDisk(byte[] data, out int endOffset, int offset = 0)
{
endOffset = offset;
List<RawTrack> tracks = new List<RawTrack>();
int position = offset;
RawTrack track = MarshalTrack(data, out position, position);
while(track != null)
{
endOffset = offset;
List<RawTrack> tracks = new List<RawTrack>();
int position = offset;
RawTrack track = MarshalTrack(data, out position, position);
while(track != null)
{
tracks.Add(track);
track = MarshalTrack(data, out position, position);
}
if(tracks.Count == 0)
return null;
endOffset = position;
return tracks;
tracks.Add(track);
track = MarshalTrack(data, out position, position);
}
public static byte[] MarshalDisk(List<RawTrack> disk) => MarshalDisk(disk.ToArray());
if(tracks.Count == 0)
return null;
public static byte[] MarshalDisk(RawTrack[] disk)
{
if(disk == null)
return null;
endOffset = position;
var raw = new MemoryStream();
return tracks;
}
foreach(byte[] rawTrack in disk.Select(MarshalTrack))
raw.Write(rawTrack, 0, rawTrack.Length);
public static byte[] MarshalDisk(List<RawTrack> disk) => MarshalDisk(disk.ToArray());
return raw.ToArray();
}
public static byte[] MarshalDisk(RawTrack[] disk)
{
if(disk == null)
return null;
public static bool IsAppleSonyGCR(byte[] data)
{
RawSector sector = MarshalSector(data, out int position);
var raw = new MemoryStream();
return sector != null && position != 0;
}
foreach(byte[] rawTrack in disk.Select(MarshalTrack))
raw.Write(rawTrack, 0, rawTrack.Length);
/// <summary>GCR-encoded Apple Sony GCR floppy track</summary>
public class RawTrack
{
/// <summary>Track preamble, set to self-sync 0xFF, 36 bytes</summary>
public byte[] gap;
public RawSector[] sectors;
}
return raw.ToArray();
}
/// <summary>GCR-encoded Apple Sony GCR floppy sector</summary>
public class RawSector
{
/// <summary>Address field</summary>
public RawAddressField addressField;
/// <summary>Data field</summary>
public RawDataField dataField;
/// <summary>Track preamble, set to self-sync 0xFF, unknown size</summary>
public byte[] gap;
/// <summary>Track preamble, set to self-sync 0xFF, 6 bytes</summary>
public byte[] innerGap;
}
public static bool IsAppleSonyGCR(byte[] data)
{
RawSector sector = MarshalSector(data, out int position);
/// <summary>GCR-encoded Apple Sony GCR floppy sector address field</summary>
public class RawAddressField
{
/// <summary>Checksum</summary>
public byte checksum;
/// <summary>Always 0xDE, 0xAA</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] epilogue;
/// <summary>Disk format</summary>
public AppleEncodedFormat format;
/// <summary>Always 0xD5, 0xAA, 0x96</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] prologue;
/// <summary>Encoded sector number</summary>
public byte sector;
/// <summary>Encoded side number</summary>
public byte side;
/// <summary>Encoded (decodedTrack &amp; 0x3F)</summary>
public byte track;
}
return sector != null && position != 0;
}
/// <summary>GCR-encoded Apple ][ GCR floppy sector data field</summary>
public class RawDataField
{
/// <summary>Checksum</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] checksum;
/// <summary>Encoded data bytes.</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 698)]
public byte[] data;
/// <summary>Always 0xDE, 0xAA</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] epilogue;
/// <summary>Always 0xD5, 0xAA, 0xAD</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] prologue;
/// <summary>Spare, usually <see cref="RawAddressField.sector" /></summary>
public byte spare;
}
/// <summary>GCR-encoded Apple Sony GCR floppy track</summary>
public class RawTrack
{
/// <summary>Track preamble, set to self-sync 0xFF, 36 bytes</summary>
public byte[] gap;
public RawSector[] sectors;
}
/// <summary>GCR-encoded Apple Sony GCR floppy sector</summary>
public class RawSector
{
/// <summary>Address field</summary>
public RawAddressField addressField;
/// <summary>Data field</summary>
public RawDataField dataField;
/// <summary>Track preamble, set to self-sync 0xFF, unknown size</summary>
public byte[] gap;
/// <summary>Track preamble, set to self-sync 0xFF, 6 bytes</summary>
public byte[] innerGap;
}
/// <summary>GCR-encoded Apple Sony GCR floppy sector address field</summary>
public class RawAddressField
{
/// <summary>Checksum</summary>
public byte checksum;
/// <summary>Always 0xDE, 0xAA</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] epilogue;
/// <summary>Disk format</summary>
public AppleEncodedFormat format;
/// <summary>Always 0xD5, 0xAA, 0x96</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] prologue;
/// <summary>Encoded sector number</summary>
public byte sector;
/// <summary>Encoded side number</summary>
public byte side;
/// <summary>Encoded (decodedTrack &amp; 0x3F)</summary>
public byte track;
}
/// <summary>GCR-encoded Apple ][ GCR floppy sector data field</summary>
public class RawDataField
{
/// <summary>Checksum</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] checksum;
/// <summary>Encoded data bytes.</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 698)]
public byte[] data;
/// <summary>Always 0xDE, 0xAA</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] epilogue;
/// <summary>Always 0xD5, 0xAA, 0xAD</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] prologue;
/// <summary>Spare, usually <see cref="RawAddressField.sector" /></summary>
public byte spare;
}
}

71
Floppy/Commodore.cs
View File

@@ -33,42 +33,41 @@
using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices;
namespace Aaru.Decoders.Floppy
{
/// <summary>Methods and structures for Commodore GCR floppy decoding</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
public static class Commodore
{
/// <summary>Decoded Commodore GCR sector header</summary>
public struct SectorHeader
{
/// <summary>Always 0x08</summary>
public byte id;
/// <summary>XOR of following fields</summary>
public byte checksum;
/// <summary>Sector number</summary>
public byte sector;
/// <summary>Track number</summary>
public byte track;
/// <summary>Format ID, unknown meaning</summary>
public ushort format;
/// <summary>Filled with 0x0F</summary>
public ushort fill;
}
namespace Aaru.Decoders.Floppy;
/// <summary>Decoded Commodore GCR sector data</summary>
public struct SectorData
{
/// <summary>Always 0x07</summary>
public byte id;
/// <summary>User data</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
public byte data;
/// <summary>XOR of <see cref="data" /></summary>
public byte checksum;
/// <summary>Filled with 0x0F</summary>
public ushort fill;
}
/// <summary>Methods and structures for Commodore GCR floppy decoding</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
public static class Commodore
{
/// <summary>Decoded Commodore GCR sector header</summary>
public struct SectorHeader
{
/// <summary>Always 0x08</summary>
public byte id;
/// <summary>XOR of following fields</summary>
public byte checksum;
/// <summary>Sector number</summary>
public byte sector;
/// <summary>Track number</summary>
public byte track;
/// <summary>Format ID, unknown meaning</summary>
public ushort format;
/// <summary>Filled with 0x0F</summary>
public ushort fill;
}
/// <summary>Decoded Commodore GCR sector data</summary>
public struct SectorData
{
/// <summary>Always 0x07</summary>
public byte id;
/// <summary>User data</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
public byte data;
/// <summary>XOR of <see cref="data" /></summary>
public byte checksum;
/// <summary>Filled with 0x0F</summary>
public ushort fill;
}
}

79
Floppy/Enums.cs
View File

@@ -32,47 +32,46 @@
using System.Diagnostics.CodeAnalysis;
namespace Aaru.Decoders.Floppy
namespace Aaru.Decoders.Floppy;
/// <summary>In-sector code for sector size</summary>
[SuppressMessage("ReSharper", "InconsistentNaming")]
public enum IBMSectorSizeCode : byte
{
/// <summary>In-sector code for sector size</summary>
[SuppressMessage("ReSharper", "InconsistentNaming")]
public enum IBMSectorSizeCode : byte
{
/// <summary>128 bytes/sector</summary>
EighthKilo = 0,
/// <summary>256 bytes/sector</summary>
QuarterKilo = 1,
/// <summary>512 bytes/sector</summary>
HalfKilo = 2,
/// <summary>1024 bytes/sector</summary>
Kilo = 3,
/// <summary>2048 bytes/sector</summary>
TwiceKilo = 4,
/// <summary>4096 bytes/sector</summary>
FriceKilo = 5,
/// <summary>8192 bytes/sector</summary>
TwiceFriceKilo = 6,
/// <summary>16384 bytes/sector</summary>
FricelyFriceKilo = 7
}
/// <summary>128 bytes/sector</summary>
EighthKilo = 0,
/// <summary>256 bytes/sector</summary>
QuarterKilo = 1,
/// <summary>512 bytes/sector</summary>
HalfKilo = 2,
/// <summary>1024 bytes/sector</summary>
Kilo = 3,
/// <summary>2048 bytes/sector</summary>
TwiceKilo = 4,
/// <summary>4096 bytes/sector</summary>
FriceKilo = 5,
/// <summary>8192 bytes/sector</summary>
TwiceFriceKilo = 6,
/// <summary>16384 bytes/sector</summary>
FricelyFriceKilo = 7
}
[SuppressMessage("ReSharper", "InconsistentNaming")]
public enum IBMIdType : byte
{
IndexMark = 0xFC, AddressMark = 0xFE, DataMark = 0xFB,
DeletedDataMark = 0xF8
}
[SuppressMessage("ReSharper", "InconsistentNaming")]
public enum IBMIdType : byte
{
IndexMark = 0xFC, AddressMark = 0xFE, DataMark = 0xFB,
DeletedDataMark = 0xF8
}
[SuppressMessage("ReSharper", "InconsistentNaming")]
public enum AppleEncodedFormat : byte
{
/// <summary>Disk is an Apple II 3.5" disk</summary>
AppleII = 0x96,
/// <summary>Disk is an Apple Lisa 3.5" disk</summary>
Lisa = 0x97,
/// <summary>Disk is an Apple Macintosh single-sided 3.5" disk</summary>
MacSingleSide = 0x9A,
/// <summary>Disk is an Apple Macintosh double-sided 3.5" disk</summary>
MacDoubleSide = 0xD9
}
[SuppressMessage("ReSharper", "InconsistentNaming")]
public enum AppleEncodedFormat : byte
{
/// <summary>Disk is an Apple II 3.5" disk</summary>
AppleII = 0x96,
/// <summary>Disk is an Apple Lisa 3.5" disk</summary>
Lisa = 0x97,
/// <summary>Disk is an Apple Macintosh single-sided 3.5" disk</summary>
MacSingleSide = 0x9A,
/// <summary>Disk is an Apple Macintosh double-sided 3.5" disk</summary>
MacDoubleSide = 0xD9
}

156
Floppy/ISO.cs
View File

@@ -33,89 +33,87 @@
using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices;
namespace Aaru.Decoders.Floppy
namespace Aaru.Decoders.Floppy;
// Information from:
// National Semiconductor PC87332VLJ datasheet
// SMsC FDC37C78 datasheet
// Intel 82078 datasheet
// Intel 82077AA datasheet
// Toshiba TC8566AF datasheet
// Fujitsu MB8876A datasheet
// ECMA-147
// ECMA-100
/// <summary>Methods and structures for ISO floppy decoding (also used by Atari ST and others)</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
public static class ISO
{
// Information from:
// National Semiconductor PC87332VLJ datasheet
// SMsC FDC37C78 datasheet
// Intel 82078 datasheet
// Intel 82077AA datasheet
// Toshiba TC8566AF datasheet
// Fujitsu MB8876A datasheet
// ECMA-147
// ECMA-100
/// <summary>Methods and structures for ISO floppy decoding (also used by Atari ST and others)</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
public static class ISO
/// <summary>ISO floppy track, also used by Atari ST and others</summary>
public struct Track
{
/// <summary>ISO floppy track, also used by Atari ST and others</summary>
public struct Track
{
/// <summary>Start of track, 32 bytes set to 0x4E</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
public byte[] innerGap;
/// <summary>Track sectors</summary>
public Sector[] sectors;
/// <summary>Undefined size</summary>
public byte[] gap;
}
/// <summary>Start of track, 32 bytes set to 0x4E</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
public byte[] innerGap;
/// <summary>Track sectors</summary>
public Sector[] sectors;
/// <summary>Undefined size</summary>
public byte[] gap;
}
/// <summary>Raw demodulated format for IBM System 34 floppies</summary>
public struct Sector
{
/// <summary>Sector address mark</summary>
public AddressMark addressMark;
/// <summary>22 bytes set to 0x4E, set to 0x22 on Commodore 1581</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 22)]
public byte[] innerGap;
/// <summary>Sector data block</summary>
public DataBlock dataBlock;
/// <summary>Variable bytes set to 0x4E, ECMA defines 54</summary>
public byte[] outerGap;
}
/// <summary>Raw demodulated format for IBM System 34 floppies</summary>
public struct Sector
{
/// <summary>Sector address mark</summary>
public AddressMark addressMark;
/// <summary>22 bytes set to 0x4E, set to 0x22 on Commodore 1581</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 22)]
public byte[] innerGap;
/// <summary>Sector data block</summary>
public DataBlock dataBlock;
/// <summary>Variable bytes set to 0x4E, ECMA defines 54</summary>
public byte[] outerGap;
}
/// <summary>Sector address mark for IBM System 34 floppies, contains sync word</summary>
public struct AddressMark
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] aone;
/// <summary>Set to <see cref="IBMIdType.AddressMark" /></summary>
public IBMIdType type;
/// <summary>Track number</summary>
public byte track;
/// <summary>Side number</summary>
public byte side;
/// <summary>Sector number</summary>
public byte sector;
/// <summary>
/// <see cref="IBMSectorSizeCode" />
/// </summary>
public IBMSectorSizeCode sectorSize;
/// <summary>CRC16 from <see cref="aone" /> to end of <see cref="sectorSize" /></summary>
public ushort crc;
}
/// <summary>Sector address mark for IBM System 34 floppies, contains sync word</summary>
public struct AddressMark
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] aone;
/// <summary>Set to <see cref="IBMIdType.AddressMark" /></summary>
public IBMIdType type;
/// <summary>Track number</summary>
public byte track;
/// <summary>Side number</summary>
public byte side;
/// <summary>Sector number</summary>
public byte sector;
/// <summary>
/// <see cref="IBMSectorSizeCode" />
/// </summary>
public IBMSectorSizeCode sectorSize;
/// <summary>CRC16 from <see cref="aone" /> to end of <see cref="sectorSize" /></summary>
public ushort crc;
}
/// <summary>Sector data block for IBM System 34 floppies</summary>
public struct DataBlock
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] aone;
/// <summary>Set to <see cref="IBMIdType.DataMark" /> or to <see cref="IBMIdType.DeletedDataMark" /></summary>
public IBMIdType type;
/// <summary>User data</summary>
public byte[] data;
/// <summary>CRC16 from <see cref="aone" /> to end of <see cref="data" /></summary>
public ushort crc;
}
/// <summary>Sector data block for IBM System 34 floppies</summary>
public struct DataBlock
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] aone;
/// <summary>Set to <see cref="IBMIdType.DataMark" /> or to <see cref="IBMIdType.DeletedDataMark" /></summary>
public IBMIdType type;
/// <summary>User data</summary>
public byte[] data;
/// <summary>CRC16 from <see cref="aone" /> to end of <see cref="data" /></summary>
public ushort crc;
}
}

190
Floppy/Perpendicular.cs
View File

@@ -33,107 +33,105 @@
using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices;
namespace Aaru.Decoders.Floppy
namespace Aaru.Decoders.Floppy;
// Information from:
// National Semiconductor PC87332VLJ datasheet
// SMsC FDC37C78 datasheet
// Intel 82078 datasheet
// Intel 82077AA datasheet
// Toshiba TC8566AF datasheet
// Fujitsu MB8876A datasheet
// ECMA-147
// ECMA-100
/// <summary>Methods and structures for perpendicular MFM floppy decoding</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
public static class Perpendicular
{
// Information from:
// National Semiconductor PC87332VLJ datasheet
// SMsC FDC37C78 datasheet
// Intel 82078 datasheet
// Intel 82077AA datasheet
// Toshiba TC8566AF datasheet
// Fujitsu MB8876A datasheet
// ECMA-147
// ECMA-100
/// <summary>Methods and structures for perpendicular MFM floppy decoding</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
public static class Perpendicular
/// <summary>Perpendicular floppy track</summary>
public struct Track
{
/// <summary>Perpendicular floppy track</summary>
public struct Track
{
/// <summary>Start of track</summary>
public TrackPreamble trackStart;
/// <summary>Track sectors</summary>
public Sector[] sectors;
/// <summary>Undefined size</summary>
public byte[] gap;
}
/// <summary>Start of track</summary>
public TrackPreamble trackStart;
/// <summary>Track sectors</summary>
public Sector[] sectors;
/// <summary>Undefined size</summary>
public byte[] gap;
}
/// <summary>Raw demodulated format for perpendicular floppies</summary>
public struct Sector
{
/// <summary>Sector address mark</summary>
public AddressMark addressMark;
/// <summary>41 bytes set to 0x4E</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 41)]
public byte[] innerGap;
/// <summary>Sector data block</summary>
public DataBlock dataBlock;
/// <summary>Variable-sized inter-sector gap, ECMA defines 83 bytes</summary>
public byte[] outerGap;
}
/// <summary>Raw demodulated format for perpendicular floppies</summary>
public struct Sector
{
/// <summary>Sector address mark</summary>
public AddressMark addressMark;
/// <summary>41 bytes set to 0x4E</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 41)]
public byte[] innerGap;
/// <summary>Sector data block</summary>
public DataBlock dataBlock;
/// <summary>Variable-sized inter-sector gap, ECMA defines 83 bytes</summary>
public byte[] outerGap;
}
/// <summary>Start of IBM PC MFM floppy track Used by IBM PC, Apple Macintosh (high-density only), and a lot others</summary>
public struct TrackPreamble
{
/// <summary>Gap from index pulse, 80 bytes set to 0x4E</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 80)]
public byte[] gap;
/// <summary>12 bytes set to 0x00</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xC2</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] ctwo;
/// <summary>Set to <see cref="IBMIdType.IndexMark" /></summary>
public IBMIdType type;
/// <summary>Gap until first sector, 50 bytes to 0x4E</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50)]
public byte[] gap1;
}
/// <summary>Start of IBM PC MFM floppy track Used by IBM PC, Apple Macintosh (high-density only), and a lot others</summary>
public struct TrackPreamble
{
/// <summary>Gap from index pulse, 80 bytes set to 0x4E</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 80)]
public byte[] gap;
/// <summary>12 bytes set to 0x00</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xC2</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] ctwo;
/// <summary>Set to <see cref="IBMIdType.IndexMark" /></summary>
public IBMIdType type;
/// <summary>Gap until first sector, 50 bytes to 0x4E</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50)]
public byte[] gap1;
}
/// <summary>Sector address mark for IBM System 34 floppies, contains sync word</summary>
public struct AddressMark
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] aone;
/// <summary>Set to <see cref="IBMIdType.AddressMark" /></summary>
public IBMIdType type;
/// <summary>Track number</summary>
public byte track;
/// <summary>Side number</summary>
public byte side;
/// <summary>Sector number</summary>
public byte sector;
/// <summary>
/// <see cref="IBMSectorSizeCode" />
/// </summary>
public IBMSectorSizeCode sectorSize;
/// <summary>CRC16 from <see cref="aone" /> to end of <see cref="sectorSize" /></summary>
public ushort crc;
}
/// <summary>Sector address mark for IBM System 34 floppies, contains sync word</summary>
public struct AddressMark
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] aone;
/// <summary>Set to <see cref="IBMIdType.AddressMark" /></summary>
public IBMIdType type;
/// <summary>Track number</summary>
public byte track;
/// <summary>Side number</summary>
public byte side;
/// <summary>Sector number</summary>
public byte sector;
/// <summary>
/// <see cref="IBMSectorSizeCode" />
/// </summary>
public IBMSectorSizeCode sectorSize;
/// <summary>CRC16 from <see cref="aone" /> to end of <see cref="sectorSize" /></summary>
public ushort crc;
}
/// <summary>Sector data block for IBM System 34 floppies</summary>
public struct DataBlock
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] aone;
/// <summary>Set to <see cref="IBMIdType.DataMark" /> or to <see cref="IBMIdType.DeletedDataMark" /></summary>
public IBMIdType type;
/// <summary>User data</summary>
public byte[] data;
/// <summary>CRC16 from <see cref="aone" /> to end of <see cref="data" /></summary>
public ushort crc;
}
/// <summary>Sector data block for IBM System 34 floppies</summary>
public struct DataBlock
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] aone;
/// <summary>Set to <see cref="IBMIdType.DataMark" /> or to <see cref="IBMIdType.DeletedDataMark" /></summary>
public IBMIdType type;
/// <summary>User data</summary>
public byte[] data;
/// <summary>CRC16 from <see cref="aone" /> to end of <see cref="data" /></summary>
public ushort crc;
}
}

190
Floppy/System34.cs
View File

@@ -33,107 +33,105 @@
using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices;
namespace Aaru.Decoders.Floppy
namespace Aaru.Decoders.Floppy;
// Information from:
// National Semiconductor PC87332VLJ datasheet
// SMsC FDC37C78 datasheet
// Intel 82078 datasheet
// Intel 82077AA datasheet
// Toshiba TC8566AF datasheet
// Fujitsu MB8876A datasheet
// ECMA-147
// ECMA-100
/// <summary>Methods and structures for IBM System 34 floppy decoding</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
public static class System34
{
// Information from:
// National Semiconductor PC87332VLJ datasheet
// SMsC FDC37C78 datasheet
// Intel 82078 datasheet
// Intel 82077AA datasheet
// Toshiba TC8566AF datasheet
// Fujitsu MB8876A datasheet
// ECMA-147
// ECMA-100
/// <summary>Methods and structures for IBM System 34 floppy decoding</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
public static class System34
/// <summary>Track format for IBM System 34 floppy Used by IBM PC, Apple Macintosh (high-density only), and a lot others</summary>
public struct Track
{
/// <summary>Track format for IBM System 34 floppy Used by IBM PC, Apple Macintosh (high-density only), and a lot others</summary>
public struct Track
{
/// <summary>Start of track</summary>
public TrackPreamble trackStart;
/// <summary>Track sectors</summary>
public Sector[] sectors;
/// <summary>Undefined size</summary>
public byte[] gap;
}
/// <summary>Start of track</summary>
public TrackPreamble trackStart;
/// <summary>Track sectors</summary>
public Sector[] sectors;
/// <summary>Undefined size</summary>
public byte[] gap;
}
/// <summary>Start of IBM PC MFM floppy track Used by IBM PC, Apple Macintosh (high-density only), and a lot others</summary>
public struct TrackPreamble
{
/// <summary>Gap from index pulse, 80 bytes set to 0x4E</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 80)]
public byte[] gap;
/// <summary>12 bytes set to 0x00</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xC2</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] ctwo;
/// <summary>Set to <see cref="IBMIdType.IndexMark" /></summary>
public IBMIdType type;
/// <summary>Gap until first sector, 50 bytes to 0x4E</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50)]
public byte[] gap1;
}
/// <summary>Start of IBM PC MFM floppy track Used by IBM PC, Apple Macintosh (high-density only), and a lot others</summary>
public struct TrackPreamble
{
/// <summary>Gap from index pulse, 80 bytes set to 0x4E</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 80)]
public byte[] gap;
/// <summary>12 bytes set to 0x00</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xC2</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] ctwo;
/// <summary>Set to <see cref="IBMIdType.IndexMark" /></summary>
public IBMIdType type;
/// <summary>Gap until first sector, 50 bytes to 0x4E</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50)]
public byte[] gap1;
}
/// <summary>Raw demodulated format for IBM System 34 floppies</summary>
public struct Sector
{
/// <summary>Sector address mark</summary>
public AddressMark addressMark;
/// <summary>22 bytes set to 0x4E, set to 0x22 on Commodore 1581</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 22)]
public byte[] innerGap;
/// <summary>Sector data block</summary>
public DataBlock dataBlock;
/// <summary>Variable bytes set to 0x4E, ECMA defines 54</summary>
public byte[] outerGap;
}
/// <summary>Raw demodulated format for IBM System 34 floppies</summary>
public struct Sector
{
/// <summary>Sector address mark</summary>
public AddressMark addressMark;
/// <summary>22 bytes set to 0x4E, set to 0x22 on Commodore 1581</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 22)]
public byte[] innerGap;
/// <summary>Sector data block</summary>
public DataBlock dataBlock;
/// <summary>Variable bytes set to 0x4E, ECMA defines 54</summary>
public byte[] outerGap;
}
/// <summary>Sector address mark for IBM System 34 floppies, contains sync word</summary>
public struct AddressMark
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] aone;
/// <summary>Set to <see cref="IBMIdType.AddressMark" /></summary>
public IBMIdType type;
/// <summary>Track number</summary>
public byte track;
/// <summary>Side number</summary>
public byte side;
/// <summary>Sector number</summary>
public byte sector;
/// <summary>
/// <see cref="IBMSectorSizeCode" />
/// </summary>
public IBMSectorSizeCode sectorSize;
/// <summary>CRC16 from <see cref="aone" /> to end of <see cref="sectorSize" /></summary>
public ushort crc;
}
/// <summary>Sector address mark for IBM System 34 floppies, contains sync word</summary>
public struct AddressMark
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] aone;
/// <summary>Set to <see cref="IBMIdType.AddressMark" /></summary>
public IBMIdType type;
/// <summary>Track number</summary>
public byte track;
/// <summary>Side number</summary>
public byte side;
/// <summary>Sector number</summary>
public byte sector;
/// <summary>
/// <see cref="IBMSectorSizeCode" />
/// </summary>
public IBMSectorSizeCode sectorSize;
/// <summary>CRC16 from <see cref="aone" /> to end of <see cref="sectorSize" /></summary>
public ushort crc;
}
/// <summary>Sector data block for IBM System 34 floppies</summary>
public struct DataBlock
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] aone;
/// <summary>Set to <see cref="IBMIdType.DataMark" /> or to <see cref="IBMIdType.DeletedDataMark" /></summary>
public IBMIdType type;
/// <summary>User data</summary>
public byte[] data;
/// <summary>CRC16 from <see cref="aone" /> to end of <see cref="data" /></summary>
public ushort crc;
}
/// <summary>Sector data block for IBM System 34 floppies</summary>
public struct DataBlock
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>3 bytes set to 0xA1</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] aone;
/// <summary>Set to <see cref="IBMIdType.DataMark" /> or to <see cref="IBMIdType.DeletedDataMark" /></summary>
public IBMIdType type;
/// <summary>User data</summary>
public byte[] data;
/// <summary>CRC16 from <see cref="aone" /> to end of <see cref="data" /></summary>
public ushort crc;
}
}

172
Floppy/System3740.cs
View File

@@ -33,98 +33,96 @@
using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices;
namespace Aaru.Decoders.Floppy
namespace Aaru.Decoders.Floppy;
// Information from:
// National Semiconductor PC87332VLJ datasheet
// SMsC FDC37C78 datasheet
// Intel 82078 datasheet
// Intel 82077AA datasheet
// Toshiba TC8566AF datasheet
// Fujitsu MB8876A datasheet
// ECMA-147
// ECMA-100
/// <summary>Methods and structures for IBM System 3740 floppy decoding</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
public static class System3740
{
// Information from:
// National Semiconductor PC87332VLJ datasheet
// SMsC FDC37C78 datasheet
// Intel 82078 datasheet
// Intel 82077AA datasheet
// Toshiba TC8566AF datasheet
// Fujitsu MB8876A datasheet
// ECMA-147
// ECMA-100
/// <summary>Methods and structures for IBM System 3740 floppy decoding</summary>
[SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "MemberCanBeInternal"),
SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
public static class System3740
/// <summary>Track format for IBM System 3740 floppy</summary>
public struct Track
{
/// <summary>Track format for IBM System 3740 floppy</summary>
public struct Track
{
/// <summary>Start of track</summary>
public TrackPreamble trackStart;
/// <summary>Track sectors</summary>
public Sector[] sectors;
/// <summary>Undefined size</summary>
public byte[] gap;
}
/// <summary>Start of track</summary>
public TrackPreamble trackStart;
/// <summary>Track sectors</summary>
public Sector[] sectors;
/// <summary>Undefined size</summary>
public byte[] gap;
}
/// <summary>Start of IBM PC FM floppy track</summary>
public struct TrackPreamble
{
/// <summary>Gap from index pulse, 80 bytes set to 0xFF</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 40)]
public byte[] gap;
/// <summary>6 bytes set to 0x00</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
public byte[] zero;
/// <summary>Set to <see cref="IBMIdType.IndexMark" /></summary>
public IBMIdType type;
/// <summary>Gap until first sector, 26 bytes to 0xFF</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 26)]
public byte[] gap1;
}
/// <summary>Start of IBM PC FM floppy track</summary>
public struct TrackPreamble
{
/// <summary>Gap from index pulse, 80 bytes set to 0xFF</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 40)]
public byte[] gap;
/// <summary>6 bytes set to 0x00</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
public byte[] zero;
/// <summary>Set to <see cref="IBMIdType.IndexMark" /></summary>
public IBMIdType type;
/// <summary>Gap until first sector, 26 bytes to 0xFF</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 26)]
public byte[] gap1;
}
/// <summary>Raw demodulated format for IBM System 3740 floppies</summary>
public struct Sector
{
/// <summary>Sector address mark</summary>
public AddressMark addressMark;
/// <summary>11 bytes set to 0xFF</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 11)]
public byte[] innerGap;
/// <summary>Sector data block</summary>
public DataBlock dataBlock;
/// <summary>Variable bytes set to 0xFF</summary>
public byte[] outerGap;
}
/// <summary>Raw demodulated format for IBM System 3740 floppies</summary>
public struct Sector
{
/// <summary>Sector address mark</summary>
public AddressMark addressMark;
/// <summary>11 bytes set to 0xFF</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 11)]
public byte[] innerGap;
/// <summary>Sector data block</summary>
public DataBlock dataBlock;
/// <summary>Variable bytes set to 0xFF</summary>
public byte[] outerGap;
}
/// <summary>Sector address mark for IBM System 3740 floppies, contains sync word</summary>
public struct AddressMark
{
/// <summary>6 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
public byte[] zero;
/// <summary>Set to <see cref="IBMIdType.AddressMark" /></summary>
public IBMIdType type;
/// <summary>Track number</summary>
public byte track;
/// <summary>Side number</summary>
public byte side;
/// <summary>Sector number</summary>
public byte sector;
/// <summary>
/// <see cref="IBMSectorSizeCode" />
/// </summary>
public IBMSectorSizeCode sectorSize;
/// <summary>CRC16 from <see cref="type" /> to end of <see cref="sectorSize" /></summary>
public ushort crc;
}
/// <summary>Sector address mark for IBM System 3740 floppies, contains sync word</summary>
public struct AddressMark
{
/// <summary>6 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
public byte[] zero;
/// <summary>Set to <see cref="IBMIdType.AddressMark" /></summary>
public IBMIdType type;
/// <summary>Track number</summary>
public byte track;
/// <summary>Side number</summary>
public byte side;
/// <summary>Sector number</summary>
public byte sector;
/// <summary>
/// <see cref="IBMSectorSizeCode" />
/// </summary>
public IBMSectorSizeCode sectorSize;
/// <summary>CRC16 from <see cref="type" /> to end of <see cref="sectorSize" /></summary>
public ushort crc;
}
/// <summary>Sector data block for IBM System 3740 floppies</summary>
public struct DataBlock
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>Set to <see cref="IBMIdType.DataMark" /> or to <see cref="IBMIdType.DeletedDataMark" /></summary>
public IBMIdType type;
/// <summary>User data</summary>
public byte[] data;
/// <summary>CRC16 from <see cref="type" /> to end of <see cref="data" /></summary>
public ushort crc;
}
/// <summary>Sector data block for IBM System 3740 floppies</summary>
public struct DataBlock
{
/// <summary>12 bytes set to 0</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] zero;
/// <summary>Set to <see cref="IBMIdType.DataMark" /> or to <see cref="IBMIdType.DeletedDataMark" /></summary>
public IBMIdType type;
/// <summary>User data</summary>
public byte[] data;
/// <summary>CRC16 from <see cref="type" /> to end of <see cref="data" /></summary>
public ushort crc;
}
}