public IDjmainArchive Decode(IDjmainChunk chunk, DjmainDecodeOptions options)
{
if (chunk.Data.Length != 0x1000000)
{
throw new RhythmCodexException("Chunk length must be exactly 16mb (0x1000000 bytes)");
}
if (chunk.Format == DjmainChunkFormat.Unknown ||
!Enum.IsDefined(typeof(DjmainChunkFormat), chunk.Format))
{
throw new RhythmCodexException($"{nameof(chunk.Format)} is not recognized");
}
using (var stream = new ReadOnlyMemoryStream(chunk.Data))
{
var swappedStream = new ByteSwappedReadStream(stream);
var chartSoundMap = _offsetProvider.GetSampleChartMap(chunk.Format)
.Select((offset, index) => new KeyValuePair <int, int>(index, offset))
.ToDictionary(kv => kv.Key, kv => kv.Value);
var rawCharts = ExtractCharts(stream, chunk.Format).Where(c => c.Value != null).ToList();
var decodedCharts = DecodeCharts(rawCharts, chartSoundMap, chunk.Format);
var sounds = options.DisableAudio
? null
: DecodeSounds(swappedStream, chunk.Format, chartSoundMap, rawCharts, decodedCharts, options)
.ToDictionary(kv => kv.Key, kv => kv.Value.Select(s => s));
return(new DjmainArchive
{
RawCharts = rawCharts.ToDictionary(kv => kv.Key, kv => kv.Value),
Charts = decodedCharts?.Select(c => c.Value).ToList(),
Samples = sounds?.SelectMany(s => s.Value).Select(s => s.Value).ToList()
});
}
}
public SsqInfoChunk Decode(SsqChunk ssqChunk)
{
var text = new string[12];
var chunkMem = new ReadOnlyMemoryStream(ssqChunk.Data);
var reader = new BinaryReader(chunkMem, Encodings.CP1252);
var builder = new StringBuilder();
for (var i = 0; i < text.Length; i++)
{
while (true)
{
var c = reader.ReadChar();
if (c == 0)
{
break;
}
builder.Append(c);
}
text[i] = builder.ToString();
builder.Clear();
}
return(new SsqInfoChunk
{
Text = text,
Difficulties = reader.ReadBytes(10)
});
}
private IEnumerable <Step> ConvertInternal(byte[] data)
{
using (var mem = new ReadOnlyMemoryStream(data))
using (var reader = new BinaryReader(mem))
{
// skip metadata
reader.ReadInt32();
while (mem.Position < mem.Length - 7)
{
var metricOffset = reader.ReadInt32();
var rawPanels = reader.ReadInt32();
if (rawPanels == -1 || rawPanels == 0)
{
continue;
}
yield return(new Step
{
MetricOffset = metricOffset,
Panels = unchecked ((byte)CollapsePanels(rawPanels))
});
}
}
}
public IList <ISound> Decode(XaChunk chunk)
{
var sounds = new List <ISound>();
var buffer = new float[28];
var channels = 2;
var states = Enumerable.Range(0, channels).Select(i => new XaState()).ToList();
var samples = Enumerable.Range(0, channels).Select(i => new List <float>()).ToList();
using (var mem = new ReadOnlyMemoryStream(chunk.Data))
using (var reader = new BinaryReader(mem))
{
for (var offset = 0; offset < mem.Length - 0x7F; offset += 0x80)
{
var frame = reader.ReadBytes(0x80);
for (var c = 0; c < 8; c++)
{
DecodeFrame(frame, buffer, c, states[c % channels]);
samples[c % channels].AddRange(buffer);
}
}
}
sounds.Add(new Sound
{
Samples = samples.Select(s => new Sample {
Data = s
}).Cast <ISample>().ToList()
});
return(sounds);
}
private static void ParseTileAreaNode(OTBNode tileAreaNode, World world)
{
if (tileAreaNode == null)
{
throw new ArgumentNullException(nameof(tileAreaNode));
}
if (tileAreaNode.Type != OTBNodeType.TileArea)
{
throw new TFSWorldLoadingException();
}
var stream = new ReadOnlyMemoryStream(tileAreaNode.Data.Span);
var areaStartX = stream.ReadUInt16();
var areaStartY = stream.ReadUInt16();
var areaZ = stream.ReadByte();
var areaStartPosition = new Coordinate(
x: areaStartX,
y: areaStartY,
z: (sbyte)areaZ);
foreach (var tileNode in tileAreaNode.Children)
{
ParseTileNode(
tilesAreaStartPosition: areaStartPosition,
tileNode: tileNode,
world: world);
}
}
public Step2Chunk Read(Stream stream, int length)
{
var data = new BinaryReader(stream).ReadBytes(length);
using (var mem = new ReadOnlyMemoryStream(data))
using (var reader = new BinaryReader(mem))
{
var headerLength = reader.ReadInt32();
if (headerLength < 4 || (headerLength & 3) != 0 || (headerLength - 4) % 0x14 != 0)
{
throw new RhythmCodexException("Incorrect Step2 header.");
}
var metadataCount = (headerLength - 4) / 0x14;
var metadatas = new List <Step2Metadata>();
for (var i = 0; i < metadataCount; i++)
{
metadatas.Add(new Step2Metadata
{
Offset = reader.ReadInt32() - headerLength,
Length = reader.ReadInt32() * 4,
Reserved = reader.ReadInt32(),
Next1P = (reader.ReadInt32() - 4) / 0x14,
Next2P = (reader.ReadInt32() - 4) / 0x14
});
}
return(new Step2Chunk
{
Metadatas = metadatas,
Data = reader.ReadBytes(length - headerLength)
});
}
}
public async Task ValidatesReadArguments()
{
var buffer = Encoding.UTF8.GetBytes("some data");
var stream = new ReadOnlyMemoryStream(buffer);
stream.Seek(3, SeekOrigin.Begin);
var read = new byte[buffer.Length - stream.Position];
Assert.That(
async() => await stream.ReadAsync(read, 0, buffer.Length),
Throws.InstanceOf <ArgumentException>());
Assert.That(
async() => await stream.ReadAsync(null, 0, buffer.Length),
Throws.InstanceOf <ArgumentException>());
Assert.That(
async() => await stream.ReadAsync(read, -1, read.Length),
Throws.InstanceOf <ArgumentException>());
Assert.That(
async() => await stream.ReadAsync(read, 0, -1),
Throws.InstanceOf <ArgumentException>());
await stream.ReadAsync(read, 0, read.Length);
Assert.AreEqual(
new ReadOnlyMemory <byte>(buffer, 3, buffer.Length - 3).ToArray(),
read);
}
public void ReadByte_Throws_AfterReadingEntireBuffer(
[Values(10)] int bufferLength,
[Values(5)] int startPosition,
[Values(5)] int bytesToRead
)
{
// Working around the ref struct constraints
var reachedThrowLine = false;
Assert.Throws <InvalidOperationException>(() => {
var stream = new ReadOnlyMemoryStream(
buffer: new byte[bufferLength],
position: startPosition);
for (int i = 0; i < bytesToRead; i++)
{
stream.ReadByte();
}
reachedThrowLine = true;
stream.ReadByte();
});
Assert.True(reachedThrowLine);
}
internal static void SerializeObjectProtobuf(ArrayBufferWriter <byte> destination, object instance)
{
using (var mem = new ReadOnlyMemoryStream(destination.WrittenMemory))
{
ProtoBuf.Serializer.Serialize(mem, instance);
}
}
private IEnumerable <KeyValuePair <int, IDjmainSampleInfo> > ReadInternal(Stream stream)
{
var buffer = new byte[11];
using (var mem = new ReadOnlyMemoryStream(buffer))
{
var reader = new BinaryReader(mem);
for (var i = 0; i < _djmainConfiguration.MaxSampleDefinitions; i++)
{
reader.BaseStream.Position = 0;
var bytesRead = stream.Read(buffer, 0, 11);
if (bytesRead < 11)
{
yield break;
}
var result = new DjmainSampleInfo
{
Channel = reader.ReadByte(),
Frequency = reader.ReadUInt16(),
ReverbVolume = reader.ReadByte(),
Volume = reader.ReadByte(),
Panning = reader.ReadByte(),
Offset = reader.ReadUInt16() | ((uint)reader.ReadByte() << 16),
SampleType = reader.ReadByte(),
Flags = reader.ReadByte()
};
yield return(new KeyValuePair <int, IDjmainSampleInfo>(i, result));
}
}
}
public ISound Decode(BeatmaniaPcAudioEntry entry)
{
using (var wavDataMem = new ReadOnlyMemoryStream(entry.Data))
{
var result = _wavDecoder.Decode(wavDataMem);
var panning = entry.Panning;
if (panning > 0x7F || panning < 0x01)
{
panning = 0x40;
}
var volume = entry.Volume;
if (volume < 0x01)
{
volume = 0x01;
}
else if (volume > 0xFF)
{
volume = 0xFF;
}
result[NumericData.Panning] = (panning - 1.0d) / 126.0d;
result[NumericData.Volume] = BeatmaniaPcConstants.VolumeTable[volume];
result[NumericData.Channel] = entry.Channel;
result[NumericData.SourceVolume] = entry.Volume;
result[NumericData.SourcePanning] = entry.Panning;
return(result);
}
}
public static uint ReadUInt32(ReadOnlyMemoryStream input)
{
int result = 0;
int offset = 0;
for (; offset < 32; offset += 7)
{
int b = input.ReadByte();
if (b == -1)
{
throw Truncated;
}
result |= (b & 0x7f) << offset;
if ((b & 0x80) == 0)
{
return((uint)result);
}
}
// keep reading up to 64 bits
for (; offset < 64; offset += 7)
{
int b = input.ReadByte();
if (b == -1)
{
throw Truncated;
}
if ((b & 0x80) == 0)
{
return((uint)result);
}
}
throw Malformed;
}
private void ExtractTree()
{
var stream = new ReadOnlyMemoryStream(_serializedTreeData);
stream.Skip(4); // Skip indentifier
while (!stream.IsOver)
{
var currentMark = (OTBMarkupByte)stream.ReadByte();
if (currentMark < OTBMarkupByte.Escape)
{
// What is under Escape = 0xFD is just prop data. Just skip
continue;
}
switch (currentMark)
{
case OTBMarkupByte.Start:
var nodeType = (OTBNodeType)stream.ReadByte();
AddNodeBegin(stream.Position, nodeType);
break;
case OTBMarkupByte.End:
AddNodeEnd(stream.Position);
break;
case OTBMarkupByte.Escape:
stream.Skip();
break;
default:
throw new InvalidOperationException();
}
}
}
public IList <Timing> Convert(ReadOnlyMemory <byte> data)
{
using (var mem = new ReadOnlyMemoryStream(data))
using (var reader = new BinaryReader(mem))
{
var count = reader.ReadInt32();
var metricOffsets = Enumerable
.Range(0, count)
.Select(i => reader.ReadInt32())
.ToArray();
var linearOffsets = Enumerable
.Range(0, count)
.Select(i => reader.ReadInt32())
.ToArray();
return(Enumerable
.Range(0, count)
.Select(i => new Timing
{
LinearOffset = linearOffsets[i],
MetricOffset = metricOffsets[i]
})
.AsList());
}
}
public byte[] Decrypt(Stream source, long length)
{
if (length < 4)
{
throw new RhythmCodexException($"{nameof(length)} must be at least 4.");
}
var reader = new BinaryReader(source);
byte[] key;
BeatmaniaPcAudioEncryptionType encType;
var headerChars = reader.ReadChars(4);
var headerId = new string(headerChars);
switch (headerId)
{
case @"%eNc":
key = EncryptionKey9;
encType = BeatmaniaPcAudioEncryptionType.Standard;
break;
case @"%e10":
key = EncryptionKey10;
encType = BeatmaniaPcAudioEncryptionType.Standard;
break;
case @"%e11":
key = EncryptionKey11;
encType = BeatmaniaPcAudioEncryptionType.Standard;
break;
case @"%e12":
key = EncryptionKey11;
encType = BeatmaniaPcAudioEncryptionType.Partial;
break;
case @"%hid":
key = EncryptionKey11;
encType = BeatmaniaPcAudioEncryptionType.Partial;
break;
case @"%iO0":
key = EncryptionKey16;
encType = BeatmaniaPcAudioEncryptionType.Standard;
break;
default:
return(source.TryRead(4, (int)(length - 4)));
}
{
var filelength = reader.ReadInt32();
var fileExtraBytes = (8 - (filelength % 8)) % 8;
var data = reader.ReadBytes(filelength + fileExtraBytes);
reader.ReadBytes((int)(length - data.Length - 8));
using (var encodedDataMem = new ReadOnlyMemoryStream(data))
return(DecryptInternal(encodedDataMem, key, encType, data.Length));
}
}
public OTBParsingStream(ReadOnlySpan <byte> otbData)
{
UnderlayingStream = new ReadOnlyMemoryStream(otbData);
// The buffer must be at least as big as the largest non-string
// object we can parse. Currently it's a uint32.
_parsingBuffer = new byte[sizeof(UInt32)];
}
public int[] Decode8Bit(byte[] data, int stride, int height)
{
using (var stream = new ReadOnlyMemoryStream(data))
using (var reader = new BinaryReader(stream))
{
var size = height * stride;
return(reader.ReadBytes(size).Select(b => (int)b).ToArray());
}
}
protected override void CreateInternal(ReadOnlyMemory <byte> data)
{
Materials = new List <MeshMaterial>();
// Read the file.
// todo: Use spans instead of splits.
// https://en.wikipedia.org/wiki/Wavefront_.obj_file
var stream = new ReadOnlyMemoryStream(data);
var reader = new StreamReader(stream);
MeshMaterial currentMaterial = null;
while (!reader.EndOfStream)
{
string currentLine = reader.ReadLine();
if (string.IsNullOrEmpty(currentLine))
{
continue;
}
currentLine = currentLine.Trim();
if (currentLine == "" || currentLine[0] == '#')
{
continue; // Comment
}
string[] args = Regex.Replace(currentLine, @"\s+", " ").Split(' ');
string identifier = args[0];
switch (identifier)
{
case "newmtl":
{
var newMat = new MeshMaterial
{
Name = args[1]
};
currentMaterial = newMat;
Materials.Add(newMat);
break;
}
case "map_Kd" when currentMaterial != null:
{
string directory = AssetLoader.GetDirectoryName(Name);
string texturePath = AssetLoader.GetNonRelativePath(directory, AssetLoader.NameToEngineName(args[1]));
var texture = Engine.AssetLoader.Get <TextureAsset>(texturePath);
if (texture != null)
{
texture.Texture.Tile = true;
texture.Texture.Smooth = true;
currentMaterial.DiffuseTextureName = texturePath;
currentMaterial.DiffuseTexture = texture.Texture;
}
break;
}
}
}
}
public void BytesLeftToRead_ReturnsCorrectValueAfter_ReadByte()
{
var stream = new ReadOnlyMemoryStream(buffer: new byte[10]);
var oldLeft = stream.BytesLeftToRead;
stream.ReadByte();
var newLeft = stream.BytesLeftToRead;
Assert.True(oldLeft - newLeft == 1);
}
public void ValidatesPositionValue()
{
var buffer = Encoding.UTF8.GetBytes("some data");
var stream = new ReadOnlyMemoryStream(buffer);
Assert.That(
() => stream.Position = -1,
Throws.InstanceOf <ArgumentException>());
Assert.That(
() => stream.Position = (long)int.MaxValue + 1,
Throws.InstanceOf <ArgumentException>());
}
public void BytesLeftToRead_ReturnsCorrectValueAfter_Constructor(
[Values(0, 1, 1, 2, 2)] int bufferLength,
[Values(0, 0, 1, 0, 2)] int startPosition,
[Values(0, 1, 0, 2, 0)] int bytesLeft
)
{
var stream = new ReadOnlyMemoryStream(
buffer: new byte[bufferLength],
position: startPosition);
Assert.AreEqual(
expected: bytesLeft,
actual: stream.BytesLeftToRead);
}
public int[] Decode16Bit(byte[] data, int stride, int height)
{
using (var stream = new ReadOnlyMemoryStream(data))
using (var reader = new BinaryReader(stream))
{
var size = height * stride / 2;
var result = new int[size];
for (var i = 0; i < size; i++)
{
result[i] = reader.ReadUInt16();
}
return(result);
}
}
private IEnumerable <Timing> ConvertInternal(byte[] data)
{
using (var mem = new ReadOnlyMemoryStream(data))
using (var reader = new BinaryReader(mem))
{
while (mem.Position < mem.Length - 7)
{
yield return(new Timing
{
MetricOffset = reader.ReadInt32(),
LinearOffset = reader.ReadInt32()
});
}
}
}
public int[] Decode24Bit(byte[] data, int stride, int height)
{
using (var stream = new ReadOnlyMemoryStream(data))
using (var reader = new BinaryReader(stream))
{
var size = height * stride / 3;
var result = new int[size];
for (var i = 0; i < size; i++)
{
var pixels = reader.ReadBytes(3);
result[i] = pixels[0] | (pixels[1] << 8) | (pixels[2] << 16);
}
return(result);
}
}
public static byte[] Decode(ReadOnlyMemory <byte> fileData, out ImgBinFileHeader fileHeader)
{
fileHeader = new ImgBinFileHeader();
var stream = new ReadOnlyMemoryStream(fileData);
using var r = new BinaryReader(stream);
r.ReadChars(3); // Header
float width = r.ReadSingle();
float height = r.ReadSingle();
fileHeader.Size = new Vector2(width, height);
fileHeader.Format = (PixelFormat)r.ReadInt32();
return(fileData.Span.Slice((int)stream.Position).ToArray());
}
public async Task CanRead()
{
var buffer = Encoding.UTF8.GetBytes("some data");
var stream = new ReadOnlyMemoryStream(buffer);
var read = new byte[buffer.Length];
stream.Read(read, 0, buffer.Length);
Assert.AreEqual(buffer, read);
read = new byte[buffer.Length];
stream.Position = 0;
await stream.ReadAsync(read, 0, buffer.Length);
Assert.AreEqual(buffer, read);
}
/// <summary>
/// Parses data serialized as .otb and returns the deserialized .otb tree structure.
/// </summary>
/// <remarks>
/// Beware that some .otb serializers add a "format identifier" before the data.
/// Maps (worlds?), for instance, contain 4 "format identifier bytes" that should be skiped.
/// </remarks>
public static OTBNode DeserializeOTBData(ReadOnlyMemory <byte> serializedOTBData, int skipFirstBytes)
{
if (skipFirstBytes < 0)
{
throw new ArgumentOutOfRangeException();
}
var relevantData = serializedOTBData.Slice(skipFirstBytes);
var stream = new ReadOnlyMemoryStream(serializedOTBData);
var treeBuilder = new OTBTreeBuilder(serializedOTBData);
while (!stream.IsOver)
{
var currentMark = (OTBMarkupByte)stream.ReadByte();
if (currentMark < OTBMarkupByte.Escape)
{
// Since <see cref="OTBMarkupByte"/> can only have values Escape (0xFD), Start (0xFE) and
// End (0xFF), if currentMark < Escape, then it's just prop data
// and we can safely skip it.
continue;
}
switch (currentMark)
{
case OTBMarkupByte.Start:
var nodeType = (OTBNodeType)stream.ReadByte();
treeBuilder.AddNodeDataBegin(
start: stream.Position,
type: nodeType);
break;
case OTBMarkupByte.End:
treeBuilder.AddNodeEnd(stream.Position - 1);
break;
case OTBMarkupByte.Escape:
stream.Skip();
break;
default:
throw new InvalidOperationException();
}
}
return(treeBuilder.BuildTree());
}
private static void ParseOTBTreeRootNode(OTBNode rootNode, World world)
{
if (rootNode == null)
{
throw new ArgumentNullException(nameof(rootNode));
}
if (world == null)
{
throw new ArgumentNullException(nameof(world));
}
if (rootNode.Children.Count != 1)
{
throw new TFSWorldLoadingException();
}
var parsingStream = new ReadOnlyMemoryStream(rootNode.Data.Span); //new OTBParsingStream(rootNode.Data.Span);
var headerVersion = parsingStream.ReadUInt32();
if (headerVersion == 0 || headerVersion > 2)
{
throw new TFSWorldLoadingException();
}
var worldWidth = parsingStream.ReadUInt16();
var worldHeight = parsingStream.ReadUInt16();
var itemEncodingMajorVersion = parsingStream.ReadUInt32();
if (itemEncodingMajorVersion != SupportedItemEncodingMajorVersion)
{
throw new TFSWorldLoadingException();
}
var itemEncodingMinorVersion = parsingStream.ReadUInt32();
if (itemEncodingMinorVersion < SupportedItemEncodingMinorVersion)
{
throw new TFSWorldLoadingException();
}
Console.WriteLine($"OTBM header version: {headerVersion}");
Console.WriteLine($"World width: {worldWidth}");
Console.WriteLine($"World height: {worldHeight}");
Console.WriteLine($"Item encoding major version: {itemEncodingMajorVersion}");
Console.WriteLine($"Item encoding minor version: {itemEncodingMinorVersion}");
}
public IRiffFormat Decode(IRiffChunk chunk)
{
using (var stream = new ReadOnlyMemoryStream(chunk.Data))
using (var reader = new BinaryReader(stream))
{
return(new RiffFormat
{
Format = reader.ReadInt16(),
Channels = reader.ReadInt16(),
SampleRate = reader.ReadInt32(),
ByteRate = reader.ReadInt32(),
BlockAlign = reader.ReadInt16(),
BitsPerSample = reader.ReadInt16(),
ExtraData = reader.ReadBytes(chunk.Data.Length - 16)
});
}
}
public void UInt_WrittenAsVarint_IsSameUInt_When_ReadedBack()
{
Prop.ForAll <uint>(num =>
{
using (var wms = new WriteOnlyMemoryStream())
{
Varint.WriteUInt32(num, wms);
var varintBytes = wms.ToArray();
using (var ms = new ReadOnlyMemoryStream(varintBytes))
{
var readed = Varint.ReadUInt32(ms);
return(readed == num);
}
}
}).QuickCheckThrowOnFailure();
}
