feat: work on spans instead of binary reader when decoding volumes

Author: Schnjan

src/PiWeb.Volume/Block/BlockInfo.cs

@@ -55,14 +55,13 @@ internal readonly record struct BlockInfo( ushort ValueCount, bool IsFirstValueS
 	#region methods
 
 	/// <summary>
-	/// Reads the <see cref="BlockInfo"/> from the specified <paramref name="reader"/>.
+	/// Reads the <see cref="BlockInfo"/> from the specified <paramref name="value"/>.
 	/// </summary>
-	public static BlockInfo Read( BinaryReader reader )
+	public static BlockInfo Create( ushort value )
 	{
-		var resultLength = reader.ReadUInt16();
-		var valueCount = resultLength & ValueCountMask;
-		var isFirstValueShort = ( resultLength & IsFirstValueShortMask ) >> IsFirstValueShortOffset;
-		var areOtherValuesShort = ( resultLength & AreOtherValuesShortMask ) >> AreOtherValuesShortOffset;
+		var valueCount = value & ValueCountMask;
+		var isFirstValueShort = ( value & IsFirstValueShortMask ) >> IsFirstValueShortOffset;
+		var areOtherValuesShort = ( value & AreOtherValuesShortMask ) >> AreOtherValuesShortOffset;
 
 		return new BlockInfo( (ushort)valueCount, isFirstValueShort > 0, areOtherValuesShort > 0 );
 	}

src/PiWeb.Volume/Block/BlockVolumeDecoder.cs

@@ -15,7 +15,6 @@ namespace Zeiss.PiWeb.Volume.Block;
 
 using System;
 using System.Buffers;
-using System.IO;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using System.Threading;
@@ -42,37 +41,49 @@ internal static void Decode( byte[] data,
 		IProgress<VolumeSliceDefinition>? progress = null,
 		CancellationToken ct = default )
 	{
-		var reader = new BinaryReader( new MemoryStream( data ) );
-		var (_, sizeX, sizeY, sizeZ, quantization) = BlockVolumeMetaData.Read( reader );
+		var header = BlockVolumeMetaData.Create( data );
+		var (_, sizeX, sizeY, sizeZ, quantization) = header;
 		var (bcx, bcy, bcz) = BlockVolume.GetBlockCount( sizeX, sizeY, sizeZ );
 		var blockCount = bcx * bcy;
 		var encodedBlockInfos = new EncodedBlockInfo[ blockCount ];
+		var position = BlockVolumeMetaData.HeaderLength;
+		var dataSpan = data.AsSpan();
+
+		Quantization.Invert( quantization );
 
 		for( ushort biz = 0; biz < bcz; biz++ )
 		{
 			ct.ThrowIfCancellationRequested();
 
-			var layerLength = reader.ReadInt32();
+			var layerLength = MemoryMarshal.Read<int>( dataSpan.Slice( position, sizeof( int ) ) );
+			position += sizeof( int );
 			if( layerPredicate?.Invoke( biz ) is false )
 			{
-				reader.BaseStream.Seek( layerLength, SeekOrigin.Current );
+				position += layerLength;
 				continue;
 			}
 
-			ReadBlockInfos( reader, blockCount, encodedBlockInfos );
+			ReadLayer( dataSpan, position, blockCount, encodedBlockInfos );
 			DecodeLayer( data, encodedBlockInfos, bcx, bcy, biz, quantization, blockPredicate, blockAction );
 
 			progress?.Report( new VolumeSliceDefinition( Direction.Z, (ushort)( biz * BlockVolume.N ) ) );
+
+			position += layerLength;
 		}
 	}
 
-	private static void ReadBlockInfos( BinaryReader reader, int blockCount, EncodedBlockInfo[] encodedBlockInfos )
+	private static void ReadLayer( ReadOnlySpan<byte> dataSpan, int position, int blockCount, EncodedBlockInfo[] encodedBlockInfos )
 	{
 		for( var i = 0; i < blockCount; i++ )
 		{
-			var encodedBlockInfo = EncodedBlockInfo.Read( reader );
-			reader.BaseStream.Seek( encodedBlockInfo.Info.Length, SeekOrigin.Current );
+			var value = MemoryMarshal.Read<ushort>( dataSpan[ position.. ] );
+
+			position += sizeof( ushort );
+
+			var encodedBlockInfo = new EncodedBlockInfo( position, BlockInfo.Create( value ) );
 			encodedBlockInfos[ i ] = encodedBlockInfo;
+
+			position += encodedBlockInfo.Info.Length;
 		}
 	}
 
@@ -203,23 +214,7 @@ private static void ReadBlock( ReadOnlySpan<byte> data, EncodedBlockInfo blockIn
 
 	#endregion
 
-	private readonly record struct EncodedBlockInfo( int StartIndex, BlockInfo Info )
-	{
-		#region methods
-
-		/// <summary>
-		/// Reads the encoded block info from the specified <paramref name="reader"/>
-		/// </summary>
-		public static EncodedBlockInfo Read( BinaryReader reader )
-		{
-			var info = BlockInfo.Read( reader );
-			var startIndex = (int)reader.BaseStream.Position;
-
-			return new EncodedBlockInfo( startIndex, info );
-		}
-
-		#endregion
-	}
+	private readonly record struct EncodedBlockInfo( int StartIndex, BlockInfo Info );
 
 	internal delegate void BlockAction( ReadOnlySpan<byte> data, BlockIndex index );
 

src/PiWeb.Volume/Block/BlockVolumeMetaData.cs

@@ -14,13 +14,14 @@ namespace Zeiss.PiWeb.Volume.Block;
 
 using System;
 using System.IO;
+using System.Runtime.InteropServices;
 
 #endregion
 
 /// <summary>
 /// Holds information that are needed to encode and decode a block volume.
 /// </summary>
-public readonly record struct BlockVolumeMetaData( uint Version, ushort SizeX, ushort SizeY, ushort SizeZ, double[] Quantization )
+public record BlockVolumeMetaData( uint Version, ushort SizeX, ushort SizeY, ushort SizeZ, double[] Quantization )
 {
 	#region methods
 
@@ -40,26 +41,37 @@ public void Write( BinaryWriter writer )
 	}
 
 	/// <summary>
-	/// Reads the metadata from the specified <paramref name="reader"/>
+	/// Reads the metadata from the specified <paramref name="data"/>
 	/// </summary>
-	public static BlockVolumeMetaData Read( BinaryReader reader )
+	public static BlockVolumeMetaData Create( ReadOnlySpan<byte> data )
 	{
-		var header = reader.ReadUInt32();
+		var position = 0;
+		var header = MemoryMarshal.Read<uint>( data[ position.. ] );
+		position += sizeof( uint );
 		if( header != BlockVolume.FileHeader )
 			throw new FormatException( $"Encountered unexpected file header 0x{header:x8}, expected 0x{BlockVolume.FileHeader:x8}" );
 
-		var version = reader.ReadUInt32();
+		var version = MemoryMarshal.Read<uint>( data[ position.. ] );
+		position += sizeof( uint );
 		if( version != BlockVolume.Version )
 			throw new FormatException( $"Encountered unexpected file header '{version}', expected {BlockVolume.Version}" );
 
-		var sizeX = reader.ReadUInt16();
-		var sizeY = reader.ReadUInt16();
-		var sizeZ = reader.ReadUInt16();
+		var sizeX = MemoryMarshal.Read<ushort>( data[ position.. ] );
+		position += sizeof( ushort );
+		var sizeY = MemoryMarshal.Read<ushort>( data[ position.. ] );
+		position += sizeof( ushort );
+		var sizeZ = MemoryMarshal.Read<ushort>( data[ position.. ] );
+		position += sizeof( ushort );
 
-		var quantization = Block.Quantization.Read( reader, true );
+		var quantization = MemoryMarshal.Cast<byte, double>( data.Slice( position, BlockVolume.N3 * sizeof( double ) ) );
 
-		return new BlockVolumeMetaData( version, sizeX, sizeY, sizeZ, quantization );
+		return new BlockVolumeMetaData( version, sizeX, sizeY, sizeZ, quantization.ToArray() );
 	}
 
 	#endregion
+
+	/// <summary>
+	/// The number of bytes the header consists of.
+	/// </summary>
+	public static int HeaderLength => 2 * sizeof( uint ) + 3 * sizeof( ushort ) + BlockVolume.N3 * sizeof( double );
 }

src/PiWeb.Volume/Block/Quantization.cs

@@ -30,20 +30,12 @@ internal static class Quantization
 	#region methods
 
 	/// <summary>
-	/// Reads a quantization matrix from the specified <paramref name="reader"/>
+	/// Invert a quantization matrix.
 	/// </summary>
-	public static double[] Read( BinaryReader reader, bool invert )
+	public static void Invert( double[] quantization )
 	{
-		var values = new double[ BlockVolume.N3 ];
-		_ = reader.Read( MemoryMarshal.Cast<double, byte>( values.AsSpan() ) );
-
-		if( !invert )
-			return values;
-
 		for( var i = 0; i < BlockVolume.N3; i++ )
-			values[ i ] = 1.0 / values[ i ];
-
-		return values;
+			quantization[ i ] = 1.0 / quantization[ i ];
 	}
 
 	/// <summary>