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

Move inner classes of Disc up a level, make Disc not partial

This commit is contained in:
YoshiRulz 2021-01-02 17:39:39 +10:00
parent e24c4c3971
commit 449130e081
No known key found for this signature in database
GPG Key ID: C4DE31C245353FB7
9 changed files with 492 additions and 505 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/BizHawk.Emulation.DiscSystem/Disc.cs
View File

@ -16,7 +16,7 @@ using System.Collections.Generic;
namespace BizHawk.Emulation.DiscSystem
{
public sealed partial class Disc : IDisposable
public sealed class Disc : IDisposable
{
/// <summary>
/// Automagically loads a disc, without any fine-tuned control at all

583
src/BizHawk.Emulation.DiscSystem/DiscFormats/Blobs/Blob_ECM.cs
View File

@ -32,339 +32,336 @@ using BizHawk.Common.NumberExtensions;
namespace BizHawk.Emulation.DiscSystem
{
public sealed partial class Disc
internal class Blob_ECM : IBlob
{
internal class Blob_ECM : IBlob
private FileStream stream;
public void Dispose()
{
private FileStream stream;
public void Dispose()
stream?.Dispose();
stream = null;
}
private class IndexEntry
{
public int Type;
public uint Number;
public long ECMOffset;
public long LogicalOffset;
}
/// <summary>
/// an index of blocks within the ECM file, for random-access.
/// itll be sorted by logical ordering, so you can binary search for the address you want
/// </summary>
private readonly List<IndexEntry> Index = new List<IndexEntry>();
/// <summary>
/// the ECMfile-provided EDC integrity checksum. not being used right now
/// </summary>
private int EDC;
public long Length;
public void Load(string path)
{
stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
//skip header
stream.Seek(4, SeekOrigin.Current);
long logOffset = 0;
for (; ; )
{
stream?.Dispose();
stream = null;
}
private class IndexEntry
{
public int Type;
public uint Number;
public long ECMOffset;
public long LogicalOffset;
}
/// <summary>
/// an index of blocks within the ECM file, for random-access.
/// itll be sorted by logical ordering, so you can binary search for the address you want
/// </summary>
private readonly List<IndexEntry> Index = new List<IndexEntry>();
/// <summary>
/// the ECMfile-provided EDC integrity checksum. not being used right now
/// </summary>
private int EDC;
public long Length;
public void Load(string path)
{
stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
//skip header
stream.Seek(4, SeekOrigin.Current);
long logOffset = 0;
for (; ; )
//read block count. this format is really stupid. maybe its good for detecting non-ecm files or something.
int b = stream.ReadByte();
if (b == -1) MisformedException();
int bytes = 1;
int T = b & 3;
long N = (b >> 2) & 0x1F;
int nbits = 5;
while (b.Bit(7))
{
//read block count. this format is really stupid. maybe its good for detecting non-ecm files or something.
int b = stream.ReadByte();
if (bytes == 5) MisformedException(); //if we're gonna need a 6th byte, this file is broken
b = stream.ReadByte();
bytes++;
if (b == -1) MisformedException();
int bytes = 1;
int T = b & 3;
long N = (b >> 2) & 0x1F;
int nbits = 5;
while (b.Bit(7))
{
if (bytes == 5) MisformedException(); //if we're gonna need a 6th byte, this file is broken
b = stream.ReadByte();
bytes++;
if (b == -1) MisformedException();
N |= (long)(b & 0x7F) << nbits;
nbits += 7;
}
//end of blocks section
if (N == 0xFFFFFFFF)
break;
//the 0x80000000 business is confusing, but this is almost positively an error
if (N >= 0x100000000)
MisformedException();
uint todo = (uint)N + 1;
IndexEntry ie = new IndexEntry
{
Number = todo,
ECMOffset = stream.Position,
LogicalOffset = logOffset,
Type = T
};
Index.Add(ie);
if (T == 0)
{
stream.Seek(todo, SeekOrigin.Current);
logOffset += todo;
}
else if (T == 1)
{
stream.Seek(todo * (2048 + 3), SeekOrigin.Current);
logOffset += todo * 2352;
}
else if (T == 2)
{
stream.Seek(todo * 2052, SeekOrigin.Current);
logOffset += todo * 2336;
}
else if (T == 3)
{
stream.Seek(todo * 2328, SeekOrigin.Current);
logOffset += todo * 2336;
}
else MisformedException();
N |= (long)(b & 0x7F) << nbits;
nbits += 7;
}
//TODO - endian bug. need an endian-independent binary reader with good license (miscutils is apache license)
//extension methods on binary reader wont suffice, we need something that lets you control the endianness used for reading. a complete replacement.
var br = new BinaryReader(stream);
EDC = br.ReadInt32();
//end of blocks section
if (N == 0xFFFFFFFF)
break;
Length = logOffset;
//the 0x80000000 business is confusing, but this is almost positively an error
if (N >= 0x100000000)
MisformedException();
uint todo = (uint)N + 1;
IndexEntry ie = new IndexEntry
{
Number = todo,
ECMOffset = stream.Position,
LogicalOffset = logOffset,
Type = T
};
Index.Add(ie);
if (T == 0)
{
stream.Seek(todo, SeekOrigin.Current);
logOffset += todo;
}
else if (T == 1)
{
stream.Seek(todo * (2048 + 3), SeekOrigin.Current);
logOffset += todo * 2352;
}
else if (T == 2)
{
stream.Seek(todo * 2052, SeekOrigin.Current);
logOffset += todo * 2336;
}
else if (T == 3)
{
stream.Seek(todo * 2328, SeekOrigin.Current);
logOffset += todo * 2336;
}
else MisformedException();
}
private void MisformedException()
//TODO - endian bug. need an endian-independent binary reader with good license (miscutils is apache license)
//extension methods on binary reader wont suffice, we need something that lets you control the endianness used for reading. a complete replacement.
var br = new BinaryReader(stream);
EDC = br.ReadInt32();
Length = logOffset;
}
private void MisformedException()
{
throw new InvalidOperationException("Mis-formed ECM file");
}
public static bool IsECM(string path)
{
using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
{
throw new InvalidOperationException("Mis-formed ECM file");
int e = fs.ReadByte();
int c = fs.ReadByte();
int m = fs.ReadByte();
int o = fs.ReadByte();
if (e != 'E' || c != 'C' || m != 'M' || o != 0)
return false;
}
public static bool IsECM(string path)
return true;
}
/// <summary>
/// finds the IndexEntry for the specified logical offset
/// </summary>
private int FindInIndex(long offset, int LastReadIndex)
{
//try to avoid searching the index. check the last index we we used.
for(int i=0;i<2;i++) //try 2 times
{
using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
IndexEntry last = Index[LastReadIndex];
if (LastReadIndex == Index.Count - 1)
{
int e = fs.ReadByte();
int c = fs.ReadByte();
int m = fs.ReadByte();
int o = fs.ReadByte();
if (e != 'E' || c != 'C' || m != 'M' || o != 0)
return false;
}
return true;
}
/// <summary>
/// finds the IndexEntry for the specified logical offset
/// </summary>
private int FindInIndex(long offset, int LastReadIndex)
{
//try to avoid searching the index. check the last index we we used.
for(int i=0;i<2;i++) //try 2 times
{
IndexEntry last = Index[LastReadIndex];
if (LastReadIndex == Index.Count - 1)
//byte_pos would have to be after the last entry
if (offset >= last.LogicalOffset)
{
//byte_pos would have to be after the last entry
if (offset >= last.LogicalOffset)
{
return LastReadIndex;
}
}
else
{
IndexEntry next = Index[LastReadIndex + 1];
if (offset >= last.LogicalOffset && offset < next.LogicalOffset)
{
return LastReadIndex;
}
//well, maybe we just advanced one sector. just try again one sector ahead
LastReadIndex++;
return LastReadIndex;
}
}
else
{
IndexEntry next = Index[LastReadIndex + 1];
if (offset >= last.LogicalOffset && offset < next.LogicalOffset)
{
return LastReadIndex;
}
//Console.WriteLine("binary searched"); //use this to check for mistaken LastReadIndex logic resulting in binary searches during sequential access
int listIndex = Index.LowerBoundBinarySearch(idx => idx.LogicalOffset, offset);
System.Diagnostics.Debug.Assert(listIndex < Index.Count);
//Console.WriteLine("byte_pos {0:X8} using index #{1} at offset {2:X8}", offset, listIndex, Index[listIndex].LogicalOffset);
return listIndex;
//well, maybe we just advanced one sector. just try again one sector ahead
LastReadIndex++;
}
}
private void Reconstruct(byte[] secbuf, int type)
//Console.WriteLine("binary searched"); //use this to check for mistaken LastReadIndex logic resulting in binary searches during sequential access
int listIndex = Index.LowerBoundBinarySearch(idx => idx.LogicalOffset, offset);
System.Diagnostics.Debug.Assert(listIndex < Index.Count);
//Console.WriteLine("byte_pos {0:X8} using index #{1} at offset {2:X8}", offset, listIndex, Index[listIndex].LogicalOffset);
return listIndex;
}
private void Reconstruct(byte[] secbuf, int type)
{
//sync
secbuf[0] = 0;
for (int i = 1; i <= 10; i++)
secbuf[i] = 0xFF;
secbuf[11] = 0x00;
//misc stuff
switch (type)
{
//sync
secbuf[0] = 0;
for (int i = 1; i <= 10; i++)
secbuf[i] = 0xFF;
secbuf[11] = 0x00;
//misc stuff
switch (type)
{
case 1:
//mode 1
secbuf[15] = 0x01;
//reserved
for (int i = 0x814; i <= 0x81B; i++)
secbuf[i] = 0x00;
break;
case 2:
case 3:
//mode 2
secbuf[15] = 0x02;
//flags - apparently CD XA specifies two copies of these 4bytes of flags. ECM didnt store the first copy; so we clone the second copy which was stored down to the spot for the first copy.
secbuf[0x10] = secbuf[0x14];
secbuf[0x11] = secbuf[0x15];
secbuf[0x12] = secbuf[0x16];
secbuf[0x13] = secbuf[0x17];
break;
}
//edc
switch (type)
{
case 1: ECM.PokeUint(secbuf, 0x810, ECM.EDC_Calc(secbuf, 0, 0x810)); break;
case 2: ECM.PokeUint(secbuf, 0x818, ECM.EDC_Calc(secbuf, 16, 0x808)); break;
case 3: ECM.PokeUint(secbuf, 0x92C, ECM.EDC_Calc(secbuf, 16, 0x91C)); break;
}
//ecc
switch (type)
{
case 1: ECM.ECC_Populate(secbuf, 0, secbuf, 0, false); break;
case 2: ECM.ECC_Populate(secbuf, 0, secbuf, 0, true); break;
}
case 1:
//mode 1
secbuf[15] = 0x01;
//reserved
for (int i = 0x814; i <= 0x81B; i++)
secbuf[i] = 0x00;
break;
case 2:
case 3:
//mode 2
secbuf[15] = 0x02;
//flags - apparently CD XA specifies two copies of these 4bytes of flags. ECM didnt store the first copy; so we clone the second copy which was stored down to the spot for the first copy.
secbuf[0x10] = secbuf[0x14];
secbuf[0x11] = secbuf[0x15];
secbuf[0x12] = secbuf[0x16];
secbuf[0x13] = secbuf[0x17];
break;
}
//we don't want to keep churning through this many big byte arrays while reading stuff, so we save a sector cache.
private readonly byte[] Read_SectorBuf = new byte[2352];
private int Read_LastIndex = 0;
public int Read(long byte_pos, byte[] buffer, int offset, int _count)
//edc
switch (type)
{
long remain = _count;
int completed = 0;
case 1: ECM.PokeUint(secbuf, 0x810, ECM.EDC_Calc(secbuf, 0, 0x810)); break;
case 2: ECM.PokeUint(secbuf, 0x818, ECM.EDC_Calc(secbuf, 16, 0x808)); break;
case 3: ECM.PokeUint(secbuf, 0x92C, ECM.EDC_Calc(secbuf, 16, 0x91C)); break;
}
//we take advantage of the fact that we pretty much always read one sector at a time.
//this would be really inefficient if we only read one byte at a time.
//on the other hand, just in case, we could keep a cache of the most recently decoded sector. that would be easy and would solve that problem (if we had it)
//ecc
switch (type)
{
case 1: ECM.ECC_Populate(secbuf, 0, secbuf, 0, false); break;
case 2: ECM.ECC_Populate(secbuf, 0, secbuf, 0, true); break;
}
while (remain > 0)
}
//we don't want to keep churning through this many big byte arrays while reading stuff, so we save a sector cache.
private readonly byte[] Read_SectorBuf = new byte[2352];
private int Read_LastIndex = 0;
public int Read(long byte_pos, byte[] buffer, int offset, int _count)
{
long remain = _count;
int completed = 0;
//we take advantage of the fact that we pretty much always read one sector at a time.
//this would be really inefficient if we only read one byte at a time.
//on the other hand, just in case, we could keep a cache of the most recently decoded sector. that would be easy and would solve that problem (if we had it)
while (remain > 0)
{
int listIndex = FindInIndex(byte_pos, Read_LastIndex);
IndexEntry ie = Index[listIndex];
Read_LastIndex = listIndex;
if (ie.Type == 0)
{
int listIndex = FindInIndex(byte_pos, Read_LastIndex);
//type 0 is special: its just a raw blob. so all we need to do is read straight out of the stream
long blockOffset = byte_pos - ie.LogicalOffset;
long bytesRemainInBlock = ie.Number - blockOffset;
IndexEntry ie = Index[listIndex];
Read_LastIndex = listIndex;
long todo = remain;
if (bytesRemainInBlock < todo)
todo = bytesRemainInBlock;
if (ie.Type == 0)
stream.Position = ie.ECMOffset + blockOffset;
while (todo > 0)
{
//type 0 is special: its just a raw blob. so all we need to do is read straight out of the stream
long blockOffset = byte_pos - ie.LogicalOffset;
long bytesRemainInBlock = ie.Number - blockOffset;
int toRead;
if (todo > int.MaxValue)
toRead = int.MaxValue;
else toRead = (int)todo;
long todo = remain;
if (bytesRemainInBlock < todo)
todo = bytesRemainInBlock;
int done = stream.Read(buffer, offset, toRead);
if (done != toRead)
return completed;
stream.Position = ie.ECMOffset + blockOffset;
while (todo > 0)
{
int toRead;
if (todo > int.MaxValue)
toRead = int.MaxValue;
else toRead = (int)todo;
int done = stream.Read(buffer, offset, toRead);
if (done != toRead)
return completed;
completed += done;
remain -= done;
todo -= done;
offset += done;
byte_pos += done;
}
//done reading the raw block; go back to check for another block
continue;
} //if(type 0)
else
{
//these are sector-based types. they have similar handling.
long blockOffset = byte_pos - ie.LogicalOffset;
//figure out which sector within the block we're in
int outSecSize;
int inSecSize;
int outSecOffset;
if (ie.Type == 1) { outSecSize = 2352; inSecSize = 2048; outSecOffset = 0; }
else if (ie.Type == 2) { outSecSize = 2336; inSecSize = 2052; outSecOffset = 16; }
else if (ie.Type == 3) { outSecSize = 2336; inSecSize = 2328; outSecOffset = 16; }
else throw new InvalidOperationException();
long secNumberInBlock = blockOffset / outSecSize;
long secOffsetInEcm = secNumberInBlock * outSecSize;
long bytesAskedIntoSector = blockOffset % outSecSize;
long bytesRemainInSector = outSecSize - bytesAskedIntoSector;
long todo = remain;
if (bytesRemainInSector < todo)
todo = bytesRemainInSector;
//move stream to beginning of this sector in ecm
stream.Position = ie.ECMOffset + inSecSize * secNumberInBlock;
//read and decode the sector
switch (ie.Type)
{
case 1:
//TODO - read first 3 bytes
if (stream.Read(Read_SectorBuf, 16, 2048) != 2048)
return completed;
Reconstruct(Read_SectorBuf, 1);
break;
case 2:
if (stream.Read(Read_SectorBuf, 20, 2052) != 2052)
return completed;
Reconstruct(Read_SectorBuf, 2);
break;
case 3:
if (stream.Read(Read_SectorBuf, 20, 2328) != 2328)
return completed;
Reconstruct(Read_SectorBuf, 3);
break;
}
//sector is decoded to 2352 bytes. Handling doesnt depend much on type from here
Array.Copy(Read_SectorBuf, (int)bytesAskedIntoSector + outSecOffset, buffer, offset, todo);
int done = (int)todo;
offset += done;
completed += done;
remain -= done;
todo -= done;
offset += done;
byte_pos += done;
}
} //not type 0
//done reading the raw block; go back to check for another block
continue;
} //if(type 0)
else
{
//these are sector-based types. they have similar handling.
} // while(Remain)
long blockOffset = byte_pos - ie.LogicalOffset;
return completed;
}
//figure out which sector within the block we're in
int outSecSize;
int inSecSize;
int outSecOffset;
if (ie.Type == 1) { outSecSize = 2352; inSecSize = 2048; outSecOffset = 0; }
else if (ie.Type == 2) { outSecSize = 2336; inSecSize = 2052; outSecOffset = 16; }
else if (ie.Type == 3) { outSecSize = 2336; inSecSize = 2328; outSecOffset = 16; }
else throw new InvalidOperationException();
long secNumberInBlock = blockOffset / outSecSize;
long secOffsetInEcm = secNumberInBlock * outSecSize;
long bytesAskedIntoSector = blockOffset % outSecSize;
long bytesRemainInSector = outSecSize - bytesAskedIntoSector;
long todo = remain;
if (bytesRemainInSector < todo)
todo = bytesRemainInSector;
//move stream to beginning of this sector in ecm
stream.Position = ie.ECMOffset + inSecSize * secNumberInBlock;
//read and decode the sector
switch (ie.Type)
{
case 1:
//TODO - read first 3 bytes
if (stream.Read(Read_SectorBuf, 16, 2048) != 2048)
return completed;
Reconstruct(Read_SectorBuf, 1);
break;
case 2:
if (stream.Read(Read_SectorBuf, 20, 2052) != 2052)
return completed;
Reconstruct(Read_SectorBuf, 2);
break;
case 3:
if (stream.Read(Read_SectorBuf, 20, 2328) != 2328)
return completed;
Reconstruct(Read_SectorBuf, 3);
break;
}
//sector is decoded to 2352 bytes. Handling doesnt depend much on type from here
Array.Copy(Read_SectorBuf, (int)bytesAskedIntoSector + outSecOffset, buffer, offset, todo);
int done = (int)todo;
offset += done;
completed += done;
remain -= done;
byte_pos += done;
} //not type 0
} // while(Remain)
return completed;
}
}
}

73
src/BizHawk.Emulation.DiscSystem/DiscFormats/Blobs/Blob_RawFile.cs
View File

@ -2,47 +2,44 @@
namespace BizHawk.Emulation.DiscSystem
{
public sealed partial class Disc
internal class Blob_RawFile : IBlob
{
internal class Blob_RawFile : IBlob
public string PhysicalPath
{
public string PhysicalPath
get => physicalPath;
set
{
get => physicalPath;
set
{
physicalPath = value;
length = new FileInfo(physicalPath).Length;
}
physicalPath = value;
length = new FileInfo(physicalPath).Length;
}
private string physicalPath;
private long length;
public long Offset = 0;
private BufferedStream fs;
public void Dispose()
{
fs?.Dispose();
fs = null;
}
public int Read(long byte_pos, byte[] buffer, int offset, int count)
{
//use quite a large buffer, because normally we will be reading these sequentially but in small chunks.
//this enhances performance considerably
//NOTE: wouldnt very large buffering create stuttering? this would depend on how it's implemented.
//really, we need a smarter asynchronous read-ahead buffer. that requires substantially more engineering, some kind of 'DiscUniverse' of carefully managed threads and such.
const int buffersize = 2352 * 75 * 2;
fs ??= new BufferedStream(new FileStream(physicalPath, FileMode.Open, FileAccess.Read, FileShare.Read), buffersize);
long target = byte_pos + Offset;
if (fs.Position != target)
fs.Position = target;
return fs.Read(buffer, offset, count);
}
public long Length => length;
}
private string physicalPath;
private long length;
public long Offset = 0;
private BufferedStream fs;
public void Dispose()
{
fs?.Dispose();
fs = null;
}
public int Read(long byte_pos, byte[] buffer, int offset, int count)
{
//use quite a large buffer, because normally we will be reading these sequentially but in small chunks.
//this enhances performance considerably
//NOTE: wouldnt very large buffering create stuttering? this would depend on how it's implemented.
//really, we need a smarter asynchronous read-ahead buffer. that requires substantially more engineering, some kind of 'DiscUniverse' of carefully managed threads and such.
const int buffersize = 2352 * 75 * 2;
fs ??= new BufferedStream(new FileStream(physicalPath, FileMode.Open, FileAccess.Read, FileShare.Read), buffersize);
long target = byte_pos + Offset;
if (fs.Position != target)
fs.Position = target;
return fs.Read(buffer, offset, count);
}
public long Length => length;
}
}
}

243
src/BizHawk.Emulation.DiscSystem/DiscFormats/Blobs/Blob_WaveFile.cs
View File

@ -4,141 +4,138 @@ using System.IO;
namespace BizHawk.Emulation.DiscSystem
{
public sealed partial class Disc
/// <summary>
/// TODO - double-check that riffmaster is not filling memory at load-time but reading through to the disk
/// TODO - clarify stream disposing semantics
/// </summary>
internal class Blob_WaveFile : IBlob
{
/// <summary>
/// TODO - double-check that riffmaster is not filling memory at load-time but reading through to the disk
/// TODO - clarify stream disposing semantics
/// </summary>
internal class Blob_WaveFile : IBlob
[Serializable]
public class Blob_WaveFile_Exception : Exception
{
[Serializable]
public class Blob_WaveFile_Exception : Exception
public Blob_WaveFile_Exception(string message)
: base(message)
{
public Blob_WaveFile_Exception(string message)
: base(message)
}
}
public Blob_WaveFile()
{
}
private class Blob_RawFile : IBlob
{
public string PhysicalPath
{
get => physicalPath;
set
{
physicalPath = value;
length = new FileInfo(physicalPath).Length;
}
}
public Blob_WaveFile()
{
}
private string physicalPath;
private long length;
private class Blob_RawFile : IBlob
{
public string PhysicalPath
{
get => physicalPath;
set
{
physicalPath = value;
length = new FileInfo(physicalPath).Length;
}
}
private string physicalPath;
private long length;
public readonly long Offset = 0;
private BufferedStream fs;
public void Dispose()
{
fs?.Dispose();
fs = null;
}
public int Read(long byte_pos, byte[] buffer, int offset, int count)
{
//use quite a large buffer, because normally we will be reading these sequentially but in small chunks.
//this enhances performance considerably
const int buffersize = 2352 * 75 * 2;
fs ??= new BufferedStream(new FileStream(physicalPath, FileMode.Open, FileAccess.Read, FileShare.Read), buffersize);
long target = byte_pos + Offset;
if (fs.Position != target)
fs.Position = target;
return fs.Read(buffer, offset, count);
}
public long Length => length;
}
public void Load(byte[] waveData)
{
}
public void Load(string wavePath)
{
var stream = new FileStream(wavePath, FileMode.Open, FileAccess.Read, FileShare.Read);
Load(stream);
}
/// <exception cref="Blob_WaveFile_Exception">not a valid RIFF WAVE file with exactly one data chunk containing two 16-bit PCM channels at 44.1 kHz</exception>
public void Load(Stream stream)
{
try
{
RiffSource = null;
var rm = new RiffMaster();
rm.LoadStream(stream);
RiffSource = rm;
//analyze the file to make sure its an OK wave file
if (rm.riff.type != "WAVE")
{
throw new Blob_WaveFile_Exception("Not a RIFF WAVE file");
}
if (!(rm.riff.subchunks.FirstOrDefault(chunk => chunk.tag == "fmt ") is RiffMaster.RiffSubchunk_fmt fmt))
{
throw new Blob_WaveFile_Exception("Not a valid RIFF WAVE file (missing fmt chunk");
}
var dataChunks = rm.riff.subchunks.Where(chunk => chunk.tag == "data").ToList();
if (dataChunks.Count != 1)
{
//later, we could make a Stream which would make an index of data chunks and walk around them
throw new Blob_WaveFile_Exception("Multi-data-chunk WAVE files not supported");
}
if (fmt.format_tag != RiffMaster.RiffSubchunk_fmt.FORMAT_TAG.WAVE_FORMAT_PCM)
{
throw new Blob_WaveFile_Exception("Not a valid PCM WAVE file (only PCM is supported)");
}
if (fmt.channels != 2 || fmt.bitsPerSample != 16 || fmt.samplesPerSec != 44100)
{
throw new Blob_WaveFile_Exception("Not a CDA format WAVE file (conversion not yet supported)");
}
//acquire the start of the data chunk
var dataChunk = (RiffMaster.RiffSubchunk) dataChunks[0];
waveDataStreamPos = dataChunk.Position;
mDataLength = dataChunk.Length;
}
catch(Exception)
{
Dispose();
throw;
}
}
public int Read(long byte_pos, byte[] buffer, int offset, int count)
{
RiffSource.BaseStream.Position = byte_pos + waveDataStreamPos;
return RiffSource.BaseStream.Read(buffer, offset, count);
}
private RiffMaster RiffSource;
private long waveDataStreamPos;
private long mDataLength;
public long Length => mDataLength;
public readonly long Offset = 0;
private BufferedStream fs;
public void Dispose()
{
RiffSource?.Dispose();
RiffSource = null;
fs?.Dispose();
fs = null;
}
public int Read(long byte_pos, byte[] buffer, int offset, int count)
{
//use quite a large buffer, because normally we will be reading these sequentially but in small chunks.
//this enhances performance considerably
const int buffersize = 2352 * 75 * 2;
fs ??= new BufferedStream(new FileStream(physicalPath, FileMode.Open, FileAccess.Read, FileShare.Read), buffersize);
long target = byte_pos + Offset;
if (fs.Position != target)
fs.Position = target;
return fs.Read(buffer, offset, count);
}
public long Length => length;
}
public void Load(byte[] waveData)
{
}
public void Load(string wavePath)
{
var stream = new FileStream(wavePath, FileMode.Open, FileAccess.Read, FileShare.Read);
Load(stream);
}
/// <exception cref="Blob_WaveFile_Exception">not a valid RIFF WAVE file with exactly one data chunk containing two 16-bit PCM channels at 44.1 kHz</exception>
public void Load(Stream stream)
{
try
{
RiffSource = null;
var rm = new RiffMaster();
rm.LoadStream(stream);
RiffSource = rm;
//analyze the file to make sure its an OK wave file
if (rm.riff.type != "WAVE")
{
throw new Blob_WaveFile_Exception("Not a RIFF WAVE file");
}
if (!(rm.riff.subchunks.FirstOrDefault(chunk => chunk.tag == "fmt ") is RiffMaster.RiffSubchunk_fmt fmt))
{
throw new Blob_WaveFile_Exception("Not a valid RIFF WAVE file (missing fmt chunk");
}
var dataChunks = rm.riff.subchunks.Where(chunk => chunk.tag == "data").ToList();
if (dataChunks.Count != 1)
{
//later, we could make a Stream which would make an index of data chunks and walk around them
throw new Blob_WaveFile_Exception("Multi-data-chunk WAVE files not supported");
}
if (fmt.format_tag != RiffMaster.RiffSubchunk_fmt.FORMAT_TAG.WAVE_FORMAT_PCM)
{
throw new Blob_WaveFile_Exception("Not a valid PCM WAVE file (only PCM is supported)");
}
if (fmt.channels != 2 || fmt.bitsPerSample != 16 || fmt.samplesPerSec != 44100)
{
throw new Blob_WaveFile_Exception("Not a CDA format WAVE file (conversion not yet supported)");
}
//acquire the start of the data chunk
var dataChunk = (RiffMaster.RiffSubchunk) dataChunks[0];
waveDataStreamPos = dataChunk.Position;
mDataLength = dataChunk.Length;
}
catch(Exception)
{
Dispose();
throw;
}
}
public int Read(long byte_pos, byte[] buffer, int offset, int count)
{
RiffSource.BaseStream.Position = byte_pos + waveDataStreamPos;
return RiffSource.BaseStream.Read(buffer, offset, count);
}
private RiffMaster RiffSource;
private long waveDataStreamPos;
private long mDataLength;
public long Length => mDataLength;
public void Dispose()
{
RiffSource?.Dispose();
RiffSource = null;
}
}
}

68
src/BizHawk.Emulation.DiscSystem/DiscFormats/Blobs/Blob_ZeroPadAdapter.cs
View File

@ -4,43 +4,39 @@ using System;
namespace BizHawk.Emulation.DiscSystem
{
public sealed partial class Disc : IDisposable
internal sealed class Blob_ZeroPadAdapter : IBlob
{
internal sealed class Blob_ZeroPadAdapter : IBlob
private readonly IBlob srcBlob;
private readonly long srcBlobLength;
public Blob_ZeroPadAdapter(IBlob srcBlob, long srcBlobLength)
{
this.srcBlob = srcBlob;
this.srcBlobLength = srcBlobLength;
}
public int Read(long byte_pos, byte[] buffer, int offset, int count)
{
int todo = count;
long end = byte_pos + todo;
if (end > srcBlobLength)
{
long temp = (int)(srcBlobLength - byte_pos);
if (temp > int.MaxValue)
throw new InvalidOperationException();
todo = (int)temp;
//zero-fill the unused part (just for safety's sake)
Array.Clear(buffer, offset + todo, count - todo);
}
srcBlob.Read(byte_pos, buffer, offset, todo);
//since it's zero padded, this never fails and always reads the requested amount
return count;
}
public void Dispose()
{
private readonly IBlob srcBlob;
private readonly long srcBlobLength;
public Blob_ZeroPadAdapter(IBlob srcBlob, long srcBlobLength)
{
this.srcBlob = srcBlob;
this.srcBlobLength = srcBlobLength;
}
public int Read(long byte_pos, byte[] buffer, int offset, int count)
{
int todo = count;
long end = byte_pos + todo;
if (end > srcBlobLength)
{
long temp = (int)(srcBlobLength - byte_pos);
if (temp > int.MaxValue)
throw new InvalidOperationException();
todo = (int)temp;
//zero-fill the unused part (just for safety's sake)
Array.Clear(buffer, offset + todo, count - todo);
}
srcBlob.Read(byte_pos, buffer, offset, todo);
//since it's zero padded, this never fails and always reads the requested amount
return count;
}
public void Dispose()
{
}
}
}
}
}

8
src/BizHawk.Emulation.DiscSystem/DiscFormats/CCD_format.cs
View File

@ -497,9 +497,9 @@ namespace BizHawk.Emulation.DiscSystem
var ecmPath = Path.ChangeExtension(imgPath, ".img.ecm");
if (File.Exists(ecmPath))
{
if (Disc.Blob_ECM.IsECM(ecmPath))
if (Blob_ECM.IsECM(ecmPath))
{
var ecm = new Disc.Blob_ECM();
var ecm = new Blob_ECM();
ecm.Load(ecmPath);
imgBlob = ecm;
imgLen = ecm.Length;
@ -509,7 +509,7 @@ namespace BizHawk.Emulation.DiscSystem
if (imgBlob == null)
{
if (!File.Exists(loadResults.ImgPath)) throw new CCDParseException("Malformed CCD format: nonexistent IMG file!");
var imgFile = new Disc.Blob_RawFile() { PhysicalPath = loadResults.ImgPath };
var imgFile = new Blob_RawFile() { PhysicalPath = loadResults.ImgPath };
imgLen = imgFile.Length;
imgBlob = imgFile;
}
@ -517,7 +517,7 @@ namespace BizHawk.Emulation.DiscSystem
//mount the SUB file
if (!File.Exists(loadResults.SubPath)) throw new CCDParseException("Malformed CCD format: nonexistent SUB file!");
var subFile = new Disc.Blob_RawFile() { PhysicalPath = loadResults.SubPath };
var subFile = new Blob_RawFile() { PhysicalPath = loadResults.SubPath };
subBlob = subFile;
disc.DisposableResources.Add(subBlob);
subLen = subFile.Length;

4
src/BizHawk.Emulation.DiscSystem/DiscFormats/CUE/CUE_Compile.cs
View File

@ -254,7 +254,7 @@ namespace BizHawk.Emulation.DiscSystem.CUE
//TODO - fix exception-throwing inside
//TODO - verify stream-disposing semantics
var fs = File.OpenRead(choice);
using var blob = new Disc.Blob_WaveFile();
using var blob = new Blob_WaveFile();
try
{
blob.Load(fs);
@ -272,7 +272,7 @@ namespace BizHawk.Emulation.DiscSystem.CUE
else if (blobPathExt == ".ECM")
{
cfi.Type = CompiledCueFileType.ECM;
if (!Disc.Blob_ECM.IsECM(choice))
if (!Blob_ECM.IsECM(choice))
{
Error($"an ECM file was specified or detected, but it isn't a valid ECM file: {Path.GetFileName(choice)}");
cfi.Type = CompiledCueFileType.Unknown;

10
src/BizHawk.Emulation.DiscSystem/DiscFormats/CUE/CUE_Load.cs
View File

@ -81,14 +81,14 @@ namespace BizHawk.Emulation.DiscSystem.CUE
case CompiledCueFileType.Unknown:
{
//raw files:
var blob = new Disc.Blob_RawFile { PhysicalPath = ccf.FullPath };
var blob = new Blob_RawFile { PhysicalPath = ccf.FullPath };
OUT_Disc.DisposableResources.Add(file_blob = blob);
bi.Length = blob.Length;
break;
}
case CompiledCueFileType.ECM:
{
var blob = new Disc.Blob_ECM();
var blob = new Blob_ECM();
OUT_Disc.DisposableResources.Add(file_blob = blob);
blob.Load(ccf.FullPath);
bi.Length = blob.Length;
@ -96,7 +96,7 @@ namespace BizHawk.Emulation.DiscSystem.CUE
}
case CompiledCueFileType.WAVE:
{
var blob = new Disc.Blob_WaveFile();
var blob = new Blob_WaveFile();
OUT_Disc.DisposableResources.Add(file_blob = blob);
blob.Load(ccf.FullPath);
bi.Length = blob.Length;
@ -111,7 +111,7 @@ namespace BizHawk.Emulation.DiscSystem.CUE
}
AudioDecoder dec = new AudioDecoder();
byte[] buf = dec.AcquireWaveData(ccf.FullPath);
var blob = new Disc.Blob_WaveFile();
var blob = new Blob_WaveFile();
OUT_Disc.DisposableResources.Add(file_blob = blob);
blob.Load(new MemoryStream(buf));
bi.Length = buf.Length;
@ -122,7 +122,7 @@ namespace BizHawk.Emulation.DiscSystem.CUE
} //switch(file type)
//wrap all the blobs with zero padding
bi.Blob = new Disc.Blob_ZeroPadAdapter(file_blob, bi.Length);
bi.Blob = new Blob_ZeroPadAdapter(file_blob, bi.Length);
}
}

6
src/BizHawk.Emulation.DiscSystem/DiscFormats/MDS_Format.cs
View File

@ -626,7 +626,7 @@ namespace BizHawk.Emulation.DiscSystem
//mount the file
if (mdfBlob == null)
{
var mdfFile = new Disc.Blob_RawFile() { PhysicalPath = file };
var mdfFile = new Blob_RawFile() { PhysicalPath = file };
mdfLen = mdfFile.Length;
mdfBlob = mdfFile;
}
@ -813,12 +813,12 @@ namespace BizHawk.Emulation.DiscSystem
CUE.SS_Base sBase = null;
// get the current blob from the BlobIndex
Disc.Blob_RawFile currBlob = (Disc.Blob_RawFile) BlobIndex[currBlobIndex];
Blob_RawFile currBlob = (Blob_RawFile) BlobIndex[currBlobIndex];
long currBlobLength = currBlob.Length;
long currBlobPosition = sector;
if (currBlobPosition == currBlobLength)
currBlobIndex++;
mdfBlob = disc.DisposableResources[currBlobIndex] as Disc.Blob_RawFile;
mdfBlob = disc.DisposableResources[currBlobIndex] as Blob_RawFile;
//int userSector = 2048;
switch (track.SectorSize)