/// <summary>
/// Writes data into the stream.
/// </summary>
/// <typeparam name="T">Type of the data</typeparam>
/// <param name="data">Data to be written</param>
public void Write <T>(ref T data) where T : unmanaged
{
Span <byte> buffer = MemoryMarshal.Cast <T, byte>(MemoryMarshal.CreateSpan(ref data, 1));
_activeStream.Write(buffer);
}
/// <summary>
/// Writes data to CPU mapped memory.
/// </summary>
/// <typeparam name="T">Type of the data being written</typeparam>
/// <param name="va">Virtual address to write the data into</param>
/// <param name="value">Data to be written</param>
/// <exception cref="InvalidMemoryRegionException">Throw for unhandled invalid or unmapped memory accesses</exception>
public void Write <T>(ulong va, T value) where T : unmanaged
{
Write(va, MemoryMarshal.Cast <T, byte>(MemoryMarshal.CreateSpan(ref value, 1)));
}
public PinnedConvertingMemoryManager(IPinnedMemoryOwner <TFrom> rooted)
{
_origin = (TTo *)rooted.Origin;
Length = MemoryMarshal.Cast <TFrom, TTo>(rooted.Memory.Span).Length;
}
/// <summary>
/// Reads data from GPU memory.
/// </summary>
/// <typeparam name="T">Type of the data to be read</typeparam>
/// <param name="address">GPU virtual address of the data</param>
/// <returns>Data at the memory location</returns>
public override T MemoryRead <T>(ulong address)
{
return(MemoryMarshal.Cast <byte, T>(_data.Span.Slice((int)address))[0]);
}
/// <summary>
/// Reads data from CPU mapped memory.
/// </summary>
/// <typeparam name="T">Type of the data being read</typeparam>
/// <param name="va">Virtual address of the data in memory</param>
/// <returns>The data</returns>
/// <exception cref="InvalidMemoryRegionException">Throw for unhandled invalid or unmapped memory accesses</exception>
public T Read <T>(ulong va) where T : unmanaged
{
return(MemoryMarshal.Cast <byte, T>(GetSpan(va, Unsafe.SizeOf <T>(), true))[0]);
}
public T MemoryRead <T>(ulong address) where T : unmanaged
{
return(MemoryMarshal.Cast <byte, T>(new ReadOnlySpan <byte>(_data).Slice((int)address))[0]);
}
public THashValue GetHashValue(string value)
{
ReadOnlySpan <byte> span = MemoryMarshal.Cast <char, byte>(value.AsSpan());
return(GetHashValue(span));
}
public bool Open(IFilter imageFilter)
{
Stream stream = imageFilter.GetDataForkStream();
stream.Seek(0, SeekOrigin.Begin);
if (stream.Length < 512)
{
return(false);
}
byte[] qHdrB = new byte[68];
stream.Read(qHdrB, 0, 68);
qHdr = Marshal.SpanToStructureLittleEndian <QedHeader>(qHdrB);
DicConsole.DebugWriteLine("QED plugin", "qHdr.magic = 0x{0:X8}", qHdr.magic);
DicConsole.DebugWriteLine("QED plugin", "qHdr.cluster_size = {0}", qHdr.cluster_size);
DicConsole.DebugWriteLine("QED plugin", "qHdr.table_size = {0}", qHdr.table_size);
DicConsole.DebugWriteLine("QED plugin", "qHdr.header_size = {0}", qHdr.header_size);
DicConsole.DebugWriteLine("QED plugin", "qHdr.features = {0}", qHdr.features);
DicConsole.DebugWriteLine("QED plugin", "qHdr.compat_features = {0}", qHdr.compat_features);
DicConsole.DebugWriteLine("QED plugin", "qHdr.autoclear_features = {0}", qHdr.autoclear_features);
DicConsole.DebugWriteLine("QED plugin", "qHdr.l1_table_offset = {0}", qHdr.l1_table_offset);
DicConsole.DebugWriteLine("QED plugin", "qHdr.image_size = {0}", qHdr.image_size);
DicConsole.DebugWriteLine("QED plugin", "qHdr.backing_file_offset = {0}", qHdr.backing_file_offset);
DicConsole.DebugWriteLine("QED plugin", "qHdr.backing_file_size = {0}", qHdr.backing_file_size);
if (qHdr.image_size <= 1)
{
throw new ArgumentOutOfRangeException(nameof(qHdr.image_size), "Image size is too small");
}
if (!IsPowerOfTwo(qHdr.cluster_size))
{
throw new ArgumentOutOfRangeException(nameof(qHdr.cluster_size), "Cluster size must be a power of 2");
}
if (qHdr.cluster_size < 4096 || qHdr.cluster_size > 67108864)
{
throw new ArgumentOutOfRangeException(nameof(qHdr.cluster_size),
"Cluster size must be between 4 Kbytes and 64 Mbytes");
}
if (!IsPowerOfTwo(qHdr.table_size))
{
throw new ArgumentOutOfRangeException(nameof(qHdr.table_size), "Table size must be a power of 2");
}
if (qHdr.table_size < 1 || qHdr.table_size > 16)
{
throw new ArgumentOutOfRangeException(nameof(qHdr.table_size),
"Table size must be between 1 and 16 clusters");
}
if ((qHdr.features & QED_FEATURE_MASK) > 0)
{
throw new ArgumentOutOfRangeException(nameof(qHdr.features),
$"Image uses unknown incompatible features {qHdr.features & QED_FEATURE_MASK:X}");
}
if ((qHdr.features & QED_FEATURE_BACKING_FILE) == QED_FEATURE_BACKING_FILE)
{
throw new NotImplementedException("Differencing images not yet supported");
}
clusterSectors = qHdr.cluster_size / 512;
tableSize = qHdr.cluster_size * qHdr.table_size / 8;
DicConsole.DebugWriteLine("QED plugin", "qHdr.clusterSectors = {0}", clusterSectors);
DicConsole.DebugWriteLine("QED plugin", "qHdr.tableSize = {0}", tableSize);
byte[] l1TableB = new byte[tableSize * 8];
stream.Seek((long)qHdr.l1_table_offset, SeekOrigin.Begin);
stream.Read(l1TableB, 0, (int)tableSize * 8);
DicConsole.DebugWriteLine("QED plugin", "Reading L1 table");
l1Table = MemoryMarshal.Cast <byte, ulong>(l1TableB).ToArray();
l1Mask = 0;
int c = 0;
clusterBits = Ctz32(qHdr.cluster_size);
l2Mask = (tableSize - 1) << clusterBits;
l1Shift = clusterBits + Ctz32(tableSize);
for (int i = 0; i < 64; i++)
{
l1Mask <<= 1;
if (c >= 64 - l1Shift)
{
continue;
}
l1Mask += 1;
c++;
}
sectorMask = 0;
for (int i = 0; i < clusterBits; i++)
{
sectorMask = (sectorMask << 1) + 1;
}
DicConsole.DebugWriteLine("QED plugin", "qHdr.clusterBits = {0}", clusterBits);
DicConsole.DebugWriteLine("QED plugin", "qHdr.l1Mask = {0:X}", l1Mask);
DicConsole.DebugWriteLine("QED plugin", "qHdr.l1Shift = {0}", l1Shift);
DicConsole.DebugWriteLine("QED plugin", "qHdr.l2Mask = {0:X}", l2Mask);
DicConsole.DebugWriteLine("QED plugin", "qHdr.sectorMask = {0:X}", sectorMask);
maxL2TableCache = MAX_CACHE_SIZE / tableSize;
maxClusterCache = MAX_CACHE_SIZE / qHdr.cluster_size;
imageStream = stream;
sectorCache = new Dictionary <ulong, byte[]>();
l2TableCache = new Dictionary <ulong, ulong[]>();
clusterCache = new Dictionary <ulong, byte[]>();
imageInfo.CreationTime = imageFilter.GetCreationTime();
imageInfo.LastModificationTime = imageFilter.GetLastWriteTime();
imageInfo.MediaTitle = Path.GetFileNameWithoutExtension(imageFilter.GetFilename());
imageInfo.Sectors = qHdr.image_size / 512;
imageInfo.SectorSize = 512;
imageInfo.XmlMediaType = XmlMediaType.BlockMedia;
imageInfo.MediaType = MediaType.GENERIC_HDD;
imageInfo.ImageSize = qHdr.image_size;
imageInfo.Cylinders = (uint)(imageInfo.Sectors / 16 / 63);
imageInfo.Heads = 16;
imageInfo.SectorsPerTrack = 63;
return(true);
}
/// <summary>
/// Construct a gravity model.
/// </summary>
/// <param name="name">the name of the model.</param>
/// <param name="path">directory for data file.</param>
/// <param name="Nmax">if non-negative, truncate the degree of the model this value.</param>
/// <param name="Mmax">if non-negative, truncate the order of the model this value.</param>
/// <remarks>
/// A filename is formed by appending ".egm" (World Gravity Model) to the <paramref name="name"/>.
/// If <paramref name="path"/> is specified (and is non-empty), then the file is loaded from directory, <paramref name="path"/>.
/// Otherwise the <paramref name="path"/> is given by <see cref="DefaultGravityPath"/>.
/// <para>
/// This file contains the metadata which specifies the properties of the model.
/// The coefficients for the spherical harmonic sums are obtained from a file obtained by appending ".cof"
/// to metadata file (so the filename ends in ".egm.cof").
/// </para>
/// <para>
/// If <paramref name="Nmax"/> ≥ 0 and <paramref name="Mmax"/> < 0, then <paramref name="Mmax"/> is set to <paramref name="Nmax"/>.
/// After the model is loaded, the maximum degree and order of the model can be found by the <see cref="Degree"/> and <see cref="Order"/> methods.
/// </para>
/// </remarks>
public GravityModel(string name, string path = "", int Nmax = -1, int Mmax = -1)
{
_name = name;
_dir = path;
_description = "NONE";
_amodel = double.NaN;
_GMmodel = double.NaN;
_zeta0 = 0;
_corrmult = 1;
_nmx = -1;
_mmx = -1;
_norm = Normalization.Full;
if (string.IsNullOrWhiteSpace(path))
{
_dir = DefaultGravityPath;
}
bool truncate = Nmax >= 0 || Mmax >= 0;
if (truncate)
{
if (Nmax >= 0 && Mmax < 0)
{
Mmax = Nmax;
}
if (Nmax < 0)
{
Nmax = int.MaxValue;
}
if (Mmax < 0)
{
Mmax = int.MaxValue;
}
}
ReadMetadata(_name, ref _filename, ref _name, ref _description, ref _date, ref _amodel, ref _GMmodel,
ref _zeta0, ref _corrmult, ref _norm, ref _id, ref _earth);
double[] _Cx, _Sx;
string coeff = _filename + ".cof";
using (var coeffstr = File.OpenRead(coeff))
{
Span <byte> id = stackalloc byte[idlength_];
if (coeffstr.Read(id) != idlength_)
{
throw new GeographicException("No header in " + coeff);
}
if (MemoryMarshal.Cast <char, byte>(_id.AsSpan()).SequenceEqual(id))
{
throw new GeographicException($"ID mismatch: {_id} vs {Encoding.ASCII.GetString(id.ToArray())}");
}
int N = 0, M = 0;
if (truncate)
{
N = Nmax; M = Mmax;
}
var scoeff = SphericalEngine.Coeff.FromStream(coeffstr, ref N, ref M, truncate);
_Cx = new double[scoeff.Cnm.Length];
_Sx = new double[scoeff.Snm.Length];
scoeff.Cnm.CopyTo(_Cx);
scoeff.Snm.CopyTo(_Sx);
if (!(N >= 0 && M >= 0))
{
throw new GeographicException("Degree and order must be at least 0");
}
if (_Cx[0] != 0)
{
throw new GeographicException("The degree 0 term should be zero");
}
_Cx[0] = 1; // Include the 1/r term in the sum
_gravitational = new SphericalHarmonic(_Cx, _Sx, N, N, M, _amodel, _norm);
if (truncate)
{
N = Nmax; M = Mmax;
}
scoeff = SphericalEngine.Coeff.FromStream(coeffstr, ref N, ref M, truncate);
double[] _CC, _CS;
if (N < 0)
{
N = M = 0;
_CC = new[] { 0d };
}
else
{
_CC = new double[scoeff.Cnm.Length];
scoeff.Cnm.CopyTo(_CC);
}
_CS = new double[scoeff.Snm.Length];
scoeff.Snm.CopyTo(_CS);
_CC[0] += _zeta0 / _corrmult;
_correction = new SphericalHarmonic(_CC, _CS, N, N, M, 1, _norm);
var pos = (int)coeffstr.Position;
coeffstr.Seek(0, SeekOrigin.End);
if (pos != coeffstr.Position)
{
throw new GeographicException("Extra data in " + coeff);
}
}
int nmx = _gravitational.Coefficients.Nmx;
_nmx = Max(nmx, _correction.Coefficients.Nmx);
_mmx = Max(_gravitational.Coefficients.Mmx,
_correction.Coefficients.Mmx);
// Adjust the normalization of the normal potential to match the model.
var mult = _earth._GM / _GMmodel;
var amult = Sq(_earth._a / _amodel);
// The 0th term in _zonal should be is 1 + _dzonal0. Instead set it to 1
// to give exact cancellation with the (0,0) term in the model and account
// for _dzonal0 separately.
var _zonal = new List <double> {
1
};
_dzonal0 = (_earth.MassConstant - _GMmodel) / _GMmodel;
for (int n = 2; n <= nmx; n += 2)
{
// Only include as many normal zonal terms as matter. Figuring the limit
// in this way works because the coefficients of the normal potential
// (which is smooth) decay much more rapidly that the corresponding
// coefficient of the model potential (which is bumpy). Typically this
// goes out to n = 18.
mult *= amult;
double
r = _Cx[n], // the model term
s = -mult *_earth.Jn(n) / Sqrt(2 * n + 1), // the normal term
t = r - s; // the difference
if (t == r) // the normal term is negligible
{
break;
}
_zonal.Add(0); // index = n - 1; the odd terms are 0
_zonal.Add(s);
}
int nmx1 = _zonal.Count - 1;
var za = _zonal.ToArray();
_disturbing = new SphericalHarmonic1(_Cx, _Sx,
_gravitational.Coefficients.N,
nmx, _gravitational.Coefficients.Mmx,
za,
za, // This is not accessed!
nmx1, nmx1, 0,
_amodel,
_norm);
}
public unsafe Span <T> GetDataBuffer <T>() where T : struct
{
return(MemoryMarshal.Cast <byte, T>(new Span <byte>(this.DataBufferPtr.ToPointer(), _byteCount)));
}
private static void Compress(ReadOnlySpan <byte> data, Span <ulong> state, ulong ivLow, ulong ivHigh, ulong finalizer)
{
var dataAsULong = MemoryMarshal.Cast <byte, ulong>(data);
var d0 = dataAsULong[0];
var d1 = dataAsULong[1];
var d2 = dataAsULong[2];
var d3 = dataAsULong[3];
var d4 = dataAsULong[4];
var d5 = dataAsULong[5];
var d6 = dataAsULong[6];
var d7 = dataAsULong[7];
var d8 = dataAsULong[8];
var d9 = dataAsULong[9];
var dA = dataAsULong[10];
var dB = dataAsULong[11];
var dC = dataAsULong[12];
var dD = dataAsULong[13];
var dE = dataAsULong[14];
var dF = dataAsULong[15];
var t0 = state[0];
var t1 = state[1];
var t2 = state[2];
var t3 = state[3];
var t4 = state[4];
var t5 = state[5];
var t6 = state[6];
var t7 = state[7];
var t8 = IV0;
var t9 = IV1;
var tA = IV2;
var tB = IV3;
var tC = (IV4 ^ ivLow);
var tD = (IV5 ^ ivHigh);
var tE = finalizer;
var tF = IV7;
// round 0
t0 += t4;
t0 += d0;
tC ^= t0;
tC = Operations.RotateRight(tC, 32);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 24);
t0 += t4;
t0 += d1;
tC ^= t0;
tC = Operations.RotateRight(tC, 16);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 63);
t1 += t5;
t1 += d2;
tD ^= t1;
tD = Operations.RotateRight(tD, 32);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 24);
t1 += t5;
t1 += d3;
tD ^= t1;
tD = Operations.RotateRight(tD, 16);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 63);
t2 += t6;
t2 += d4;
tE ^= t2;
tE = Operations.RotateRight(tE, 32);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 24);
t2 += t6;
t2 += d5;
tE ^= t2;
tE = Operations.RotateRight(tE, 16);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 63);
t3 += t7;
t3 += d6;
tF ^= t3;
tF = Operations.RotateRight(tF, 32);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 24);
t3 += t7;
t3 += d7;
tF ^= t3;
tF = Operations.RotateRight(tF, 16);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 63);
t0 += t5;
t0 += d8;
tF ^= t0;
tF = Operations.RotateRight(tF, 32);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 24);
t0 += t5;
t0 += d9;
tF ^= t0;
tF = Operations.RotateRight(tF, 16);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 63);
t1 += t6;
t1 += dA;
tC ^= t1;
tC = Operations.RotateRight(tC, 32);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 24);
t1 += t6;
t1 += dB;
tC ^= t1;
tC = Operations.RotateRight(tC, 16);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 63);
t2 += t7;
t2 += dC;
tD ^= t2;
tD = Operations.RotateRight(tD, 32);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 24);
t2 += t7;
t2 += dD;
tD ^= t2;
tD = Operations.RotateRight(tD, 16);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 63);
t3 += t4;
t3 += dE;
tE ^= t3;
tE = Operations.RotateRight(tE, 32);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 24);
t3 += t4;
t3 += dF;
tE ^= t3;
tE = Operations.RotateRight(tE, 16);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 63);
// round 1
t0 += t4;
t0 += dE;
tC ^= t0;
tC = Operations.RotateRight(tC, 32);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 24);
t0 += t4;
t0 += dA;
tC ^= t0;
tC = Operations.RotateRight(tC, 16);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 63);
t1 += t5;
t1 += d4;
tD ^= t1;
tD = Operations.RotateRight(tD, 32);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 24);
t1 += t5;
t1 += d8;
tD ^= t1;
tD = Operations.RotateRight(tD, 16);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 63);
t2 += t6;
t2 += d9;
tE ^= t2;
tE = Operations.RotateRight(tE, 32);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 24);
t2 += t6;
t2 += dF;
tE ^= t2;
tE = Operations.RotateRight(tE, 16);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 63);
t3 += t7;
t3 += dD;
tF ^= t3;
tF = Operations.RotateRight(tF, 32);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 24);
t3 += t7;
t3 += d6;
tF ^= t3;
tF = Operations.RotateRight(tF, 16);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 63);
t0 += t5;
t0 += d1;
tF ^= t0;
tF = Operations.RotateRight(tF, 32);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 24);
t0 += t5;
t0 += dC;
tF ^= t0;
tF = Operations.RotateRight(tF, 16);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 63);
t1 += t6;
t1 += d0;
tC ^= t1;
tC = Operations.RotateRight(tC, 32);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 24);
t1 += t6;
t1 += d2;
tC ^= t1;
tC = Operations.RotateRight(tC, 16);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 63);
t2 += t7;
t2 += dB;
tD ^= t2;
tD = Operations.RotateRight(tD, 32);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 24);
t2 += t7;
t2 += d7;
tD ^= t2;
tD = Operations.RotateRight(tD, 16);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 63);
t3 += t4;
t3 += d5;
tE ^= t3;
tE = Operations.RotateRight(tE, 32);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 24);
t3 += t4;
t3 += d3;
tE ^= t3;
tE = Operations.RotateRight(tE, 16);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 63);
// round 2
t0 += t4;
t0 += dB;
tC ^= t0;
tC = Operations.RotateRight(tC, 32);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 24);
t0 += t4;
t0 += d8;
tC ^= t0;
tC = Operations.RotateRight(tC, 16);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 63);
t1 += t5;
t1 += dC;
tD ^= t1;
tD = Operations.RotateRight(tD, 32);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 24);
t1 += t5;
t1 += d0;
tD ^= t1;
tD = Operations.RotateRight(tD, 16);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 63);
t2 += t6;
t2 += d5;
tE ^= t2;
tE = Operations.RotateRight(tE, 32);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 24);
t2 += t6;
t2 += d2;
tE ^= t2;
tE = Operations.RotateRight(tE, 16);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 63);
t3 += t7;
t3 += dF;
tF ^= t3;
tF = Operations.RotateRight(tF, 32);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 24);
t3 += t7;
t3 += dD;
tF ^= t3;
tF = Operations.RotateRight(tF, 16);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 63);
t0 += t5;
t0 += dA;
tF ^= t0;
tF = Operations.RotateRight(tF, 32);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 24);
t0 += t5;
t0 += dE;
tF ^= t0;
tF = Operations.RotateRight(tF, 16);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 63);
t1 += t6;
t1 += d3;
tC ^= t1;
tC = Operations.RotateRight(tC, 32);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 24);
t1 += t6;
t1 += d6;
tC ^= t1;
tC = Operations.RotateRight(tC, 16);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 63);
t2 += t7;
t2 += d7;
tD ^= t2;
tD = Operations.RotateRight(tD, 32);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 24);
t2 += t7;
t2 += d1;
tD ^= t2;
tD = Operations.RotateRight(tD, 16);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 63);
t3 += t4;
t3 += d9;
tE ^= t3;
tE = Operations.RotateRight(tE, 32);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 24);
t3 += t4;
t3 += d4;
tE ^= t3;
tE = Operations.RotateRight(tE, 16);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 63);
// round 3
t0 += t4;
t0 += d7;
tC ^= t0;
tC = Operations.RotateRight(tC, 32);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 24);
t0 += t4;
t0 += d9;
tC ^= t0;
tC = Operations.RotateRight(tC, 16);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 63);
t1 += t5;
t1 += d3;
tD ^= t1;
tD = Operations.RotateRight(tD, 32);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 24);
t1 += t5;
t1 += d1;
tD ^= t1;
tD = Operations.RotateRight(tD, 16);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 63);
t2 += t6;
t2 += dD;
tE ^= t2;
tE = Operations.RotateRight(tE, 32);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 24);
t2 += t6;
t2 += dC;
tE ^= t2;
tE = Operations.RotateRight(tE, 16);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 63);
t3 += t7;
t3 += dB;
tF ^= t3;
tF = Operations.RotateRight(tF, 32);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 24);
t3 += t7;
t3 += dE;
tF ^= t3;
tF = Operations.RotateRight(tF, 16);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 63);
t0 += t5;
t0 += d2;
tF ^= t0;
tF = Operations.RotateRight(tF, 32);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 24);
t0 += t5;
t0 += d6;
tF ^= t0;
tF = Operations.RotateRight(tF, 16);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 63);
t1 += t6;
t1 += d5;
tC ^= t1;
tC = Operations.RotateRight(tC, 32);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 24);
t1 += t6;
t1 += dA;
tC ^= t1;
tC = Operations.RotateRight(tC, 16);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 63);
t2 += t7;
t2 += d4;
tD ^= t2;
tD = Operations.RotateRight(tD, 32);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 24);
t2 += t7;
t2 += d0;
tD ^= t2;
tD = Operations.RotateRight(tD, 16);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 63);
t3 += t4;
t3 += dF;
tE ^= t3;
tE = Operations.RotateRight(tE, 32);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 24);
t3 += t4;
t3 += d8;
tE ^= t3;
tE = Operations.RotateRight(tE, 16);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 63);
// round 4
t0 += t4;
t0 += d9;
tC ^= t0;
tC = Operations.RotateRight(tC, 32);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 24);
t0 += t4;
t0 += d0;
tC ^= t0;
tC = Operations.RotateRight(tC, 16);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 63);
t1 += t5;
t1 += d5;
tD ^= t1;
tD = Operations.RotateRight(tD, 32);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 24);
t1 += t5;
t1 += d7;
tD ^= t1;
tD = Operations.RotateRight(tD, 16);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 63);
t2 += t6;
t2 += d2;
tE ^= t2;
tE = Operations.RotateRight(tE, 32);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 24);
t2 += t6;
t2 += d4;
tE ^= t2;
tE = Operations.RotateRight(tE, 16);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 63);
t3 += t7;
t3 += dA;
tF ^= t3;
tF = Operations.RotateRight(tF, 32);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 24);
t3 += t7;
t3 += dF;
tF ^= t3;
tF = Operations.RotateRight(tF, 16);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 63);
t0 += t5;
t0 += dE;
tF ^= t0;
tF = Operations.RotateRight(tF, 32);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 24);
t0 += t5;
t0 += d1;
tF ^= t0;
tF = Operations.RotateRight(tF, 16);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 63);
t1 += t6;
t1 += dB;
tC ^= t1;
tC = Operations.RotateRight(tC, 32);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 24);
t1 += t6;
t1 += dC;
tC ^= t1;
tC = Operations.RotateRight(tC, 16);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 63);
t2 += t7;
t2 += d6;
tD ^= t2;
tD = Operations.RotateRight(tD, 32);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 24);
t2 += t7;
t2 += d8;
tD ^= t2;
tD = Operations.RotateRight(tD, 16);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 63);
t3 += t4;
t3 += d3;
tE ^= t3;
tE = Operations.RotateRight(tE, 32);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 24);
t3 += t4;
t3 += dD;
tE ^= t3;
tE = Operations.RotateRight(tE, 16);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 63);
// round 5
t0 += t4;
t0 += d2;
tC ^= t0;
tC = Operations.RotateRight(tC, 32);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 24);
t0 += t4;
t0 += dC;
tC ^= t0;
tC = Operations.RotateRight(tC, 16);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 63);
t1 += t5;
t1 += d6;
tD ^= t1;
tD = Operations.RotateRight(tD, 32);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 24);
t1 += t5;
t1 += dA;
tD ^= t1;
tD = Operations.RotateRight(tD, 16);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 63);
t2 += t6;
t2 += d0;
tE ^= t2;
tE = Operations.RotateRight(tE, 32);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 24);
t2 += t6;
t2 += dB;
tE ^= t2;
tE = Operations.RotateRight(tE, 16);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 63);
t3 += t7;
t3 += d8;
tF ^= t3;
tF = Operations.RotateRight(tF, 32);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 24);
t3 += t7;
t3 += d3;
tF ^= t3;
tF = Operations.RotateRight(tF, 16);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 63);
t0 += t5;
t0 += d4;
tF ^= t0;
tF = Operations.RotateRight(tF, 32);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 24);
t0 += t5;
t0 += dD;
tF ^= t0;
tF = Operations.RotateRight(tF, 16);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 63);
t1 += t6;
t1 += d7;
tC ^= t1;
tC = Operations.RotateRight(tC, 32);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 24);
t1 += t6;
t1 += d5;
tC ^= t1;
tC = Operations.RotateRight(tC, 16);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 63);
t2 += t7;
t2 += dF;
tD ^= t2;
tD = Operations.RotateRight(tD, 32);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 24);
t2 += t7;
t2 += dE;
tD ^= t2;
tD = Operations.RotateRight(tD, 16);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 63);
t3 += t4;
t3 += d1;
tE ^= t3;
tE = Operations.RotateRight(tE, 32);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 24);
t3 += t4;
t3 += d9;
tE ^= t3;
tE = Operations.RotateRight(tE, 16);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 63);
// round 6
t0 += t4;
t0 += dC;
tC ^= t0;
tC = Operations.RotateRight(tC, 32);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 24);
t0 += t4;
t0 += d5;
tC ^= t0;
tC = Operations.RotateRight(tC, 16);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 63);
t1 += t5;
t1 += d1;
tD ^= t1;
tD = Operations.RotateRight(tD, 32);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 24);
t1 += t5;
t1 += dF;
tD ^= t1;
tD = Operations.RotateRight(tD, 16);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 63);
t2 += t6;
t2 += dE;
tE ^= t2;
tE = Operations.RotateRight(tE, 32);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 24);
t2 += t6;
t2 += dD;
tE ^= t2;
tE = Operations.RotateRight(tE, 16);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 63);
t3 += t7;
t3 += d4;
tF ^= t3;
tF = Operations.RotateRight(tF, 32);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 24);
t3 += t7;
t3 += dA;
tF ^= t3;
tF = Operations.RotateRight(tF, 16);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 63);
t0 += t5;
t0 += d0;
tF ^= t0;
tF = Operations.RotateRight(tF, 32);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 24);
t0 += t5;
t0 += d7;
tF ^= t0;
tF = Operations.RotateRight(tF, 16);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 63);
t1 += t6;
t1 += d6;
tC ^= t1;
tC = Operations.RotateRight(tC, 32);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 24);
t1 += t6;
t1 += d3;
tC ^= t1;
tC = Operations.RotateRight(tC, 16);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 63);
t2 += t7;
t2 += d9;
tD ^= t2;
tD = Operations.RotateRight(tD, 32);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 24);
t2 += t7;
t2 += d2;
tD ^= t2;
tD = Operations.RotateRight(tD, 16);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 63);
t3 += t4;
t3 += d8;
tE ^= t3;
tE = Operations.RotateRight(tE, 32);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 24);
t3 += t4;
t3 += dB;
tE ^= t3;
tE = Operations.RotateRight(tE, 16);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 63);
// round 7
t0 += t4;
t0 += dD;
tC ^= t0;
tC = Operations.RotateRight(tC, 32);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 24);
t0 += t4;
t0 += dB;
tC ^= t0;
tC = Operations.RotateRight(tC, 16);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 63);
t1 += t5;
t1 += d7;
tD ^= t1;
tD = Operations.RotateRight(tD, 32);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 24);
t1 += t5;
t1 += dE;
tD ^= t1;
tD = Operations.RotateRight(tD, 16);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 63);
t2 += t6;
t2 += dC;
tE ^= t2;
tE = Operations.RotateRight(tE, 32);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 24);
t2 += t6;
t2 += d1;
tE ^= t2;
tE = Operations.RotateRight(tE, 16);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 63);
t3 += t7;
t3 += d3;
tF ^= t3;
tF = Operations.RotateRight(tF, 32);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 24);
t3 += t7;
t3 += d9;
tF ^= t3;
tF = Operations.RotateRight(tF, 16);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 63);
t0 += t5;
t0 += d5;
tF ^= t0;
tF = Operations.RotateRight(tF, 32);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 24);
t0 += t5;
t0 += d0;
tF ^= t0;
tF = Operations.RotateRight(tF, 16);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 63);
t1 += t6;
t1 += dF;
tC ^= t1;
tC = Operations.RotateRight(tC, 32);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 24);
t1 += t6;
t1 += d4;
tC ^= t1;
tC = Operations.RotateRight(tC, 16);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 63);
t2 += t7;
t2 += d8;
tD ^= t2;
tD = Operations.RotateRight(tD, 32);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 24);
t2 += t7;
t2 += d6;
tD ^= t2;
tD = Operations.RotateRight(tD, 16);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 63);
t3 += t4;
t3 += d2;
tE ^= t3;
tE = Operations.RotateRight(tE, 32);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 24);
t3 += t4;
t3 += dA;
tE ^= t3;
tE = Operations.RotateRight(tE, 16);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 63);
// round 8
t0 += t4;
t0 += d6;
tC ^= t0;
tC = Operations.RotateRight(tC, 32);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 24);
t0 += t4;
t0 += dF;
tC ^= t0;
tC = Operations.RotateRight(tC, 16);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 63);
t1 += t5;
t1 += dE;
tD ^= t1;
tD = Operations.RotateRight(tD, 32);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 24);
t1 += t5;
t1 += d9;
tD ^= t1;
tD = Operations.RotateRight(tD, 16);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 63);
t2 += t6;
t2 += dB;
tE ^= t2;
tE = Operations.RotateRight(tE, 32);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 24);
t2 += t6;
t2 += d3;
tE ^= t2;
tE = Operations.RotateRight(tE, 16);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 63);
t3 += t7;
t3 += d0;
tF ^= t3;
tF = Operations.RotateRight(tF, 32);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 24);
t3 += t7;
t3 += d8;
tF ^= t3;
tF = Operations.RotateRight(tF, 16);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 63);
t0 += t5;
t0 += dC;
tF ^= t0;
tF = Operations.RotateRight(tF, 32);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 24);
t0 += t5;
t0 += d2;
tF ^= t0;
tF = Operations.RotateRight(tF, 16);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 63);
t1 += t6;
t1 += dD;
tC ^= t1;
tC = Operations.RotateRight(tC, 32);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 24);
t1 += t6;
t1 += d7;
tC ^= t1;
tC = Operations.RotateRight(tC, 16);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 63);
t2 += t7;
t2 += d1;
tD ^= t2;
tD = Operations.RotateRight(tD, 32);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 24);
t2 += t7;
t2 += d4;
tD ^= t2;
tD = Operations.RotateRight(tD, 16);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 63);
t3 += t4;
t3 += dA;
tE ^= t3;
tE = Operations.RotateRight(tE, 32);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 24);
t3 += t4;
t3 += d5;
tE ^= t3;
tE = Operations.RotateRight(tE, 16);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 63);
// round 9
t0 += t4;
t0 += dA;
tC ^= t0;
tC = Operations.RotateRight(tC, 32);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 24);
t0 += t4;
t0 += d2;
tC ^= t0;
tC = Operations.RotateRight(tC, 16);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 63);
t1 += t5;
t1 += d8;
tD ^= t1;
tD = Operations.RotateRight(tD, 32);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 24);
t1 += t5;
t1 += d4;
tD ^= t1;
tD = Operations.RotateRight(tD, 16);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 63);
t2 += t6;
t2 += d7;
tE ^= t2;
tE = Operations.RotateRight(tE, 32);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 24);
t2 += t6;
t2 += d6;
tE ^= t2;
tE = Operations.RotateRight(tE, 16);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 63);
t3 += t7;
t3 += d1;
tF ^= t3;
tF = Operations.RotateRight(tF, 32);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 24);
t3 += t7;
t3 += d5;
tF ^= t3;
tF = Operations.RotateRight(tF, 16);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 63);
t0 += t5;
t0 += dF;
tF ^= t0;
tF = Operations.RotateRight(tF, 32);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 24);
t0 += t5;
t0 += dB;
tF ^= t0;
tF = Operations.RotateRight(tF, 16);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 63);
t1 += t6;
t1 += d9;
tC ^= t1;
tC = Operations.RotateRight(tC, 32);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 24);
t1 += t6;
t1 += dE;
tC ^= t1;
tC = Operations.RotateRight(tC, 16);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 63);
t2 += t7;
t2 += d3;
tD ^= t2;
tD = Operations.RotateRight(tD, 32);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 24);
t2 += t7;
t2 += dC;
tD ^= t2;
tD = Operations.RotateRight(tD, 16);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 63);
t3 += t4;
t3 += dD;
tE ^= t3;
tE = Operations.RotateRight(tE, 32);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 24);
t3 += t4;
t3 += d0;
tE ^= t3;
tE = Operations.RotateRight(tE, 16);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 63);
// round 10
t0 += t4;
t0 += d0;
tC ^= t0;
tC = Operations.RotateRight(tC, 32);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 24);
t0 += t4;
t0 += d1;
tC ^= t0;
tC = Operations.RotateRight(tC, 16);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 63);
t1 += t5;
t1 += d2;
tD ^= t1;
tD = Operations.RotateRight(tD, 32);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 24);
t1 += t5;
t1 += d3;
tD ^= t1;
tD = Operations.RotateRight(tD, 16);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 63);
t2 += t6;
t2 += d4;
tE ^= t2;
tE = Operations.RotateRight(tE, 32);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 24);
t2 += t6;
t2 += d5;
tE ^= t2;
tE = Operations.RotateRight(tE, 16);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 63);
t3 += t7;
t3 += d6;
tF ^= t3;
tF = Operations.RotateRight(tF, 32);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 24);
t3 += t7;
t3 += d7;
tF ^= t3;
tF = Operations.RotateRight(tF, 16);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 63);
t0 += t5;
t0 += d8;
tF ^= t0;
tF = Operations.RotateRight(tF, 32);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 24);
t0 += t5;
t0 += d9;
tF ^= t0;
tF = Operations.RotateRight(tF, 16);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 63);
t1 += t6;
t1 += dA;
tC ^= t1;
tC = Operations.RotateRight(tC, 32);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 24);
t1 += t6;
t1 += dB;
tC ^= t1;
tC = Operations.RotateRight(tC, 16);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 63);
t2 += t7;
t2 += dC;
tD ^= t2;
tD = Operations.RotateRight(tD, 32);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 24);
t2 += t7;
t2 += dD;
tD ^= t2;
tD = Operations.RotateRight(tD, 16);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 63);
t3 += t4;
t3 += dE;
tE ^= t3;
tE = Operations.RotateRight(tE, 32);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 24);
t3 += t4;
t3 += dF;
tE ^= t3;
tE = Operations.RotateRight(tE, 16);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 63);
// round 11
t0 += t4;
t0 += dE;
tC ^= t0;
tC = Operations.RotateRight(tC, 32);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 24);
t0 += t4;
t0 += dA;
tC ^= t0;
tC = Operations.RotateRight(tC, 16);
t8 += tC;
t4 ^= t8;
t4 = Operations.RotateRight(t4, 63);
t1 += t5;
t1 += d4;
tD ^= t1;
tD = Operations.RotateRight(tD, 32);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 24);
t1 += t5;
t1 += d8;
tD ^= t1;
tD = Operations.RotateRight(tD, 16);
t9 += tD;
t5 ^= t9;
t5 = Operations.RotateRight(t5, 63);
t2 += t6;
t2 += d9;
tE ^= t2;
tE = Operations.RotateRight(tE, 32);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 24);
t2 += t6;
t2 += dF;
tE ^= t2;
tE = Operations.RotateRight(tE, 16);
tA += tE;
t6 ^= tA;
t6 = Operations.RotateRight(t6, 63);
t3 += t7;
t3 += dD;
tF ^= t3;
tF = Operations.RotateRight(tF, 32);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 24);
t3 += t7;
t3 += d6;
tF ^= t3;
tF = Operations.RotateRight(tF, 16);
tB += tF;
t7 ^= tB;
t7 = Operations.RotateRight(t7, 63);
t0 += t5;
t0 += d1;
tF ^= t0;
tF = Operations.RotateRight(tF, 32);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 24);
t0 += t5;
t0 += dC;
tF ^= t0;
tF = Operations.RotateRight(tF, 16);
tA += tF;
t5 ^= tA;
t5 = Operations.RotateRight(t5, 63);
t1 += t6;
t1 += d0;
tC ^= t1;
tC = Operations.RotateRight(tC, 32);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 24);
t1 += t6;
t1 += d2;
tC ^= t1;
tC = Operations.RotateRight(tC, 16);
tB += tC;
t6 ^= tB;
t6 = Operations.RotateRight(t6, 63);
t2 += t7;
t2 += dB;
tD ^= t2;
tD = Operations.RotateRight(tD, 32);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 24);
t2 += t7;
t2 += d7;
tD ^= t2;
tD = Operations.RotateRight(tD, 16);
t8 += tD;
t7 ^= t8;
t7 = Operations.RotateRight(t7, 63);
t3 += t4;
t3 += d5;
tE ^= t3;
tE = Operations.RotateRight(tE, 32);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 24);
t3 += t4;
t3 += d3;
tE ^= t3;
tE = Operations.RotateRight(tE, 16);
t9 += tE;
t4 ^= t9;
t4 = Operations.RotateRight(t4, 63);
state[0] ^= (t0 ^ t8);
state[1] ^= (t1 ^ t9);
state[2] ^= (t2 ^ tA);
state[3] ^= (t3 ^ tB);
state[4] ^= (t4 ^ tC);
state[5] ^= (t5 ^ tD);
state[6] ^= (t6 ^ tE);
state[7] ^= (t7 ^ tF);
}
public override void _Ready()
{
base._Ready();
var mesh = GD.Load <Mesh>("res://asset/fish/Fish1.obj");
var shader = GD.Load <Shader>("res://asset/fish/fish1.shader");
var diffuse = GD.Load <Texture>("res://asset/fish/Fish1-diffuse_base.png");
shader.SetDefaultTextureParam("texture_albedo", diffuse);
var mm = new MultiMesh();
mm.TransformFormat = MultiMesh.TransformFormatEnum.Transform3d;
mm.ColorFormat = MultiMesh.ColorFormatEnum.None;
mm.CustomDataFormat = MultiMesh.CustomDataFormatEnum.None;
this.Multimesh = new MultiMesh();
this.Multimesh.TransformFormat = MultiMesh.TransformFormatEnum.Transform3d;
this.Multimesh.CustomDataFormat = MultiMesh.CustomDataFormatEnum.Float;
this.Multimesh.Mesh = mesh;
//set shader
{
var shadMat = new ShaderMaterial();
shadMat.Shader = shader;
shadMat.SetShaderParam("texture_albedo", diffuse);
this.MaterialOverride = shadMat;
}
this.Multimesh.InstanceCount = 10000; //need to do this after setting the TransformFormat
//mm.InstanceCount = 1000;
//mm.VisibleInstanceCount = -1;
//set initial placement
var visibleCount = this.Multimesh.VisibleInstanceCount;
if (visibleCount == -1)
{
visibleCount = this.Multimesh.InstanceCount;
}
//this vector3 array is actually a transform array (4 vector 3's)
xforms = this.Multimesh.TransformArray;
//so lets cast it into that!
var spanV3 = new Span <Vector3>(xforms);
var spanXf = MemoryMarshal.Cast <Vector3, Transform>(spanV3);
//put all the fish into a grid
{
var seperationDistance = 5;
var dim = Math.Pow(visibleCount, 1.0 / 3);
GD.Print($"visibleCount={visibleCount}, xformsLen={xforms.Length}, dim={dim}");
var i = 0;
for (var x = 0; x < dim; x++)
{
for (var z = 0; z < dim; z++)
{
for (var y = 0; y < dim; y++)
{
if (i >= visibleCount)
{
break; //need this because of rounding with our dim variable.
}
var loc = new Vector3((x * seperationDistance), y * seperationDistance, z * seperationDistance);
spanXf[i].origin = loc; //loc offset 3 is the position in a transform. we could assign directly to array like this: //xforms[(i * 4) + 3] = loc;
//this.Multimesh.SetInstanceTransform(i, new Transform(Basis.Identity, loc)); //instead of updating 1 at a time, we update all after the loop is done.
i++;
}
}
}
}
this.Multimesh.TransformArray = xforms;
}
public bool Open(IFilter imageFilter)
{
Stream imageStream = imageFilter.GetDataForkStream();
byte[] header = new byte[512];
byte[] footer;
imageStream.Seek(0, SeekOrigin.Begin);
imageStream.Read(header, 0, 512);
if (imageStream.Length % 2 == 0)
{
footer = new byte[512];
imageStream.Seek(-512, SeekOrigin.End);
imageStream.Read(footer, 0, 512);
}
else
{
footer = new byte[511];
imageStream.Seek(-511, SeekOrigin.End);
imageStream.Read(footer, 0, 511);
}
uint headerChecksum = BigEndianBitConverter.ToUInt32(header, 0x40);
uint footerChecksum = BigEndianBitConverter.ToUInt32(footer, 0x40);
ulong headerCookie = BigEndianBitConverter.ToUInt64(header, 0);
ulong footerCookie = BigEndianBitConverter.ToUInt64(footer, 0);
header[0x40] = 0;
header[0x41] = 0;
header[0x42] = 0;
header[0x43] = 0;
footer[0x40] = 0;
footer[0x41] = 0;
footer[0x42] = 0;
footer[0x43] = 0;
uint headerCalculatedChecksum = VhdChecksum(header);
uint footerCalculatedChecksum = VhdChecksum(footer);
AaruConsole.DebugWriteLine("VirtualPC plugin", "Header checksum = 0x{0:X8}, calculated = 0x{1:X8}",
headerChecksum, headerCalculatedChecksum);
AaruConsole.DebugWriteLine("VirtualPC plugin", "Header checksum = 0x{0:X8}, calculated = 0x{1:X8}",
footerChecksum, footerCalculatedChecksum);
byte[] usableHeader;
uint usableChecksum;
if (headerCookie == IMAGE_COOKIE &&
headerChecksum == headerCalculatedChecksum)
{
usableHeader = header;
usableChecksum = headerChecksum;
}
else if (footerCookie == IMAGE_COOKIE &&
footerChecksum == footerCalculatedChecksum)
{
usableHeader = footer;
usableChecksum = footerChecksum;
}
else
{
throw new
ImageNotSupportedException("(VirtualPC plugin): Both header and footer are corrupt, image cannot be opened.");
}
thisFooter = new HardDiskFooter
{
Cookie = BigEndianBitConverter.ToUInt64(usableHeader, 0x00),
Features = BigEndianBitConverter.ToUInt32(usableHeader, 0x08),
Version = BigEndianBitConverter.ToUInt32(usableHeader, 0x0C),
Offset = BigEndianBitConverter.ToUInt64(usableHeader, 0x10),
Timestamp = BigEndianBitConverter.ToUInt32(usableHeader, 0x18),
CreatorApplication = BigEndianBitConverter.ToUInt32(usableHeader, 0x1C),
CreatorVersion = BigEndianBitConverter.ToUInt32(usableHeader, 0x20),
CreatorHostOs = BigEndianBitConverter.ToUInt32(usableHeader, 0x24),
OriginalSize = BigEndianBitConverter.ToUInt64(usableHeader, 0x28),
CurrentSize = BigEndianBitConverter.ToUInt64(usableHeader, 0x30),
DiskGeometry = BigEndianBitConverter.ToUInt32(usableHeader, 0x38),
DiskType = BigEndianBitConverter.ToUInt32(usableHeader, 0x3C), Checksum = usableChecksum,
UniqueId = BigEndianBitConverter.ToGuid(usableHeader, 0x44), SavedState = usableHeader[0x54],
Reserved = new byte[usableHeader.Length - 0x55]
};
Array.Copy(usableHeader, 0x55, thisFooter.Reserved, 0, usableHeader.Length - 0x55);
thisDateTime = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
thisDateTime = thisDateTime.AddSeconds(thisFooter.Timestamp);
var sha1Ctx = new Sha1Context();
sha1Ctx.Update(thisFooter.Reserved);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.cookie = 0x{0:X8}", thisFooter.Cookie);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.features = 0x{0:X8}", thisFooter.Features);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.version = 0x{0:X8}", thisFooter.Version);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.offset = {0}", thisFooter.Offset);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.timestamp = 0x{0:X8} ({1})", thisFooter.Timestamp,
thisDateTime);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.creatorApplication = 0x{0:X8} (\"{1}\")",
thisFooter.CreatorApplication,
Encoding.ASCII.GetString(BigEndianBitConverter.GetBytes(thisFooter.
CreatorApplication)));
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.creatorVersion = 0x{0:X8}",
thisFooter.CreatorVersion);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.creatorHostOS = 0x{0:X8} (\"{1}\")",
thisFooter.CreatorHostOs,
Encoding.ASCII.GetString(BigEndianBitConverter.
GetBytes(thisFooter.CreatorHostOs)));
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.originalSize = {0}", thisFooter.OriginalSize);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.currentSize = {0}", thisFooter.CurrentSize);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.diskGeometry = 0x{0:X8} (C/H/S: {1}/{2}/{3})",
thisFooter.DiskGeometry, (thisFooter.DiskGeometry & 0xFFFF0000) >> 16,
(thisFooter.DiskGeometry & 0xFF00) >> 8,
thisFooter.DiskGeometry & 0xFF);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.diskType = 0x{0:X8}", thisFooter.DiskType);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.checksum = 0x{0:X8}", thisFooter.Checksum);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.uniqueId = {0}", thisFooter.UniqueId);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.savedState = 0x{0:X2}", thisFooter.SavedState);
AaruConsole.DebugWriteLine("VirtualPC plugin", "footer.reserved's SHA1 = 0x{0}", sha1Ctx.End());
if (thisFooter.Version == VERSION1)
{
imageInfo.Version = "1.0";
}
else
{
throw new
ImageNotSupportedException($"(VirtualPC plugin): Unknown image type {thisFooter.DiskType} found. Please submit a bug with an example image.");
}
switch (thisFooter.CreatorApplication)
{
case CREATOR_QEMU:
{
imageInfo.Application = "QEMU";
// QEMU always set same version
imageInfo.ApplicationVersion = "Unknown";
break;
}
case CREATOR_VIRTUAL_BOX:
{
imageInfo.ApplicationVersion =
$"{(thisFooter.CreatorVersion & 0xFFFF0000) >> 16}.{thisFooter.CreatorVersion & 0x0000FFFF:D2}";
switch (thisFooter.CreatorHostOs)
{
case CREATOR_MACINTOSH:
case CREATOR_MACINTOSH_OLD:
imageInfo.Application = "VirtualBox for Mac";
break;
case CREATOR_WINDOWS:
// VirtualBox uses Windows creator for any other OS
imageInfo.Application = "VirtualBox";
break;
default:
imageInfo.Application =
$"VirtualBox for unknown OS \"{Encoding.ASCII.GetString(BigEndianBitConverter.GetBytes(thisFooter.CreatorHostOs))}\"";
break;
}
break;
}
case CREATOR_VIRTUAL_SERVER:
{
imageInfo.Application = "Microsoft Virtual Server";
switch (thisFooter.CreatorVersion)
{
case VERSION_VIRTUAL_SERVER2004:
imageInfo.ApplicationVersion = "2004";
break;
default:
imageInfo.ApplicationVersion = $"Unknown version 0x{thisFooter.CreatorVersion:X8}";
break;
}
break;
}
case CREATOR_VIRTUAL_PC:
{
switch (thisFooter.CreatorHostOs)
{
case CREATOR_MACINTOSH:
case CREATOR_MACINTOSH_OLD:
switch (thisFooter.CreatorVersion)
{
case VERSION_VIRTUAL_PC_MAC:
imageInfo.Application = "Connectix Virtual PC";
imageInfo.ApplicationVersion = "5, 6 or 7";
break;
default:
imageInfo.ApplicationVersion = $"Unknown version 0x{thisFooter.CreatorVersion:X8}";
break;
}
break;
case CREATOR_WINDOWS:
switch (thisFooter.CreatorVersion)
{
case VERSION_VIRTUAL_PC_MAC:
imageInfo.Application = "Connectix Virtual PC";
imageInfo.ApplicationVersion = "5, 6 or 7";
break;
case VERSION_VIRTUAL_PC2004:
imageInfo.Application = "Microsoft Virtual PC";
imageInfo.ApplicationVersion = "2004";
break;
case VERSION_VIRTUAL_PC2007:
imageInfo.Application = "Microsoft Virtual PC";
imageInfo.ApplicationVersion = "2007";
break;
default:
imageInfo.ApplicationVersion = $"Unknown version 0x{thisFooter.CreatorVersion:X8}";
break;
}
break;
default:
imageInfo.Application =
$"Virtual PC for unknown OS \"{Encoding.ASCII.GetString(BigEndianBitConverter.GetBytes(thisFooter.CreatorHostOs))}\"";
imageInfo.ApplicationVersion = $"Unknown version 0x{thisFooter.CreatorVersion:X8}";
break;
}
break;
}
case CREATOR_DISCIMAGECHEF:
{
imageInfo.Application = "DiscImageChef";
imageInfo.ApplicationVersion =
$"{(thisFooter.CreatorVersion & 0xFF000000) >> 24}.{(thisFooter.CreatorVersion & 0xFF0000) >> 16}.{(thisFooter.CreatorVersion & 0xFF00) >> 8}.{thisFooter.CreatorVersion & 0xFF}";
}
break;
case CREATOR_AARU:
{
imageInfo.Application = "Aaru";
imageInfo.ApplicationVersion =
$"{(thisFooter.CreatorVersion & 0xFF000000) >> 24}.{(thisFooter.CreatorVersion & 0xFF0000) >> 16}.{(thisFooter.CreatorVersion & 0xFF00) >> 8}.{thisFooter.CreatorVersion & 0xFF}";
}
break;
default:
{
imageInfo.Application =
$"Unknown application \"{Encoding.ASCII.GetString(BigEndianBitConverter.GetBytes(thisFooter.CreatorHostOs))}\"";
imageInfo.ApplicationVersion = $"Unknown version 0x{thisFooter.CreatorVersion:X8}";
break;
}
}
thisFilter = imageFilter;
imageInfo.ImageSize = thisFooter.CurrentSize;
imageInfo.Sectors = thisFooter.CurrentSize / 512;
imageInfo.SectorSize = 512;
imageInfo.CreationTime = imageFilter.GetCreationTime();
imageInfo.LastModificationTime = thisDateTime;
imageInfo.MediaTitle = Path.GetFileNameWithoutExtension(imageFilter.GetFilename());
imageInfo.Cylinders = (thisFooter.DiskGeometry & 0xFFFF0000) >> 16;
imageInfo.Heads = (thisFooter.DiskGeometry & 0xFF00) >> 8;
imageInfo.SectorsPerTrack = thisFooter.DiskGeometry & 0xFF;
if (thisFooter.DiskType == TYPE_DYNAMIC ||
thisFooter.DiskType == TYPE_DIFFERENCING)
{
imageStream.Seek((long)thisFooter.Offset, SeekOrigin.Begin);
byte[] dynamicBytes = new byte[1024];
imageStream.Read(dynamicBytes, 0, 1024);
uint dynamicChecksum = BigEndianBitConverter.ToUInt32(dynamicBytes, 0x24);
dynamicBytes[0x24] = 0;
dynamicBytes[0x25] = 0;
dynamicBytes[0x26] = 0;
dynamicBytes[0x27] = 0;
uint dynamicChecksumCalculated = VhdChecksum(dynamicBytes);
AaruConsole.DebugWriteLine("VirtualPC plugin",
"Dynamic header checksum = 0x{0:X8}, calculated = 0x{1:X8}", dynamicChecksum,
dynamicChecksumCalculated);
if (dynamicChecksum != dynamicChecksumCalculated)
{
throw new
ImageNotSupportedException("(VirtualPC plugin): Both header and footer are corrupt, image cannot be opened.");
}
thisDynamic = new DynamicDiskHeader
{
LocatorEntries = new ParentLocatorEntry[8], Reserved2 = new byte[256]
};
for (int i = 0; i < 8; i++)
{
thisDynamic.LocatorEntries[i] = new ParentLocatorEntry();
}
thisDynamic.Cookie = BigEndianBitConverter.ToUInt64(dynamicBytes, 0x00);
thisDynamic.DataOffset = BigEndianBitConverter.ToUInt64(dynamicBytes, 0x08);
thisDynamic.TableOffset = BigEndianBitConverter.ToUInt64(dynamicBytes, 0x10);
thisDynamic.HeaderVersion = BigEndianBitConverter.ToUInt32(dynamicBytes, 0x18);
thisDynamic.MaxTableEntries = BigEndianBitConverter.ToUInt32(dynamicBytes, 0x1C);
thisDynamic.BlockSize = BigEndianBitConverter.ToUInt32(dynamicBytes, 0x20);
thisDynamic.Checksum = dynamicChecksum;
thisDynamic.ParentId = BigEndianBitConverter.ToGuid(dynamicBytes, 0x28);
thisDynamic.ParentTimestamp = BigEndianBitConverter.ToUInt32(dynamicBytes, 0x38);
thisDynamic.Reserved = BigEndianBitConverter.ToUInt32(dynamicBytes, 0x3C);
thisDynamic.ParentName = Encoding.BigEndianUnicode.GetString(dynamicBytes, 0x40, 512);
for (int i = 0; i < 8; i++)
{
thisDynamic.LocatorEntries[i].PlatformCode =
BigEndianBitConverter.ToUInt32(dynamicBytes, 0x240 + 0x00 + (24 * i));
thisDynamic.LocatorEntries[i].PlatformDataSpace =
BigEndianBitConverter.ToUInt32(dynamicBytes, 0x240 + 0x04 + (24 * i));
thisDynamic.LocatorEntries[i].PlatformDataLength =
BigEndianBitConverter.ToUInt32(dynamicBytes, 0x240 + 0x08 + (24 * i));
thisDynamic.LocatorEntries[i].Reserved =
BigEndianBitConverter.ToUInt32(dynamicBytes, 0x240 + 0x0C + (24 * i));
thisDynamic.LocatorEntries[i].PlatformDataOffset =
BigEndianBitConverter.ToUInt64(dynamicBytes, 0x240 + 0x10 + (24 * i));
}
Array.Copy(dynamicBytes, 0x300, thisDynamic.Reserved2, 0, 256);
parentDateTime = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
parentDateTime = parentDateTime.AddSeconds(thisDynamic.ParentTimestamp);
sha1Ctx = new Sha1Context();
sha1Ctx.Update(thisDynamic.Reserved2);
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.cookie = 0x{0:X8}", thisDynamic.Cookie);
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.dataOffset = {0}", thisDynamic.DataOffset);
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.tableOffset = {0}", thisDynamic.TableOffset);
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.headerVersion = 0x{0:X8}",
thisDynamic.HeaderVersion);
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.maxTableEntries = {0}",
thisDynamic.MaxTableEntries);
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.blockSize = {0}", thisDynamic.BlockSize);
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.checksum = 0x{0:X8}", thisDynamic.Checksum);
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.parentID = {0}", thisDynamic.ParentId);
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.parentTimestamp = 0x{0:X8} ({1})",
thisDynamic.ParentTimestamp, parentDateTime);
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.reserved = 0x{0:X8}", thisDynamic.Reserved);
for (int i = 0; i < 8; i++)
{
AaruConsole.DebugWriteLine("VirtualPC plugin",
"dynamic.locatorEntries[{0}].platformCode = 0x{1:X8} (\"{2}\")", i,
thisDynamic.LocatorEntries[i].PlatformCode,
Encoding.ASCII.GetString(BigEndianBitConverter.GetBytes(thisDynamic.
LocatorEntries
[i].
PlatformCode)));
AaruConsole.DebugWriteLine("VirtualPC plugin",
"dynamic.locatorEntries[{0}].platformDataSpace = {1}", i,
thisDynamic.LocatorEntries[i].PlatformDataSpace);
AaruConsole.DebugWriteLine("VirtualPC plugin",
"dynamic.locatorEntries[{0}].platformDataLength = {1}", i,
thisDynamic.LocatorEntries[i].PlatformDataLength);
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.locatorEntries[{0}].reserved = 0x{1:X8}", i,
thisDynamic.LocatorEntries[i].Reserved);
AaruConsole.DebugWriteLine("VirtualPC plugin",
"dynamic.locatorEntries[{0}].platformDataOffset = {1}", i,
thisDynamic.LocatorEntries[i].PlatformDataOffset);
}
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.parentName = \"{0}\"", thisDynamic.ParentName);
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.reserved2's SHA1 = 0x{0}", sha1Ctx.End());
if (thisDynamic.HeaderVersion != VERSION1)
{
throw new
ImageNotSupportedException($"(VirtualPC plugin): Unknown image type {thisFooter.DiskType} found. Please submit a bug with an example image.");
}
DateTime startTime = DateTime.UtcNow;
blockAllocationTable = new uint[thisDynamic.MaxTableEntries];
// How many sectors uses the BAT
int batSectorCount = (int)Math.Ceiling(((double)thisDynamic.MaxTableEntries * 4) / 512);
byte[] bat = new byte[thisDynamic.MaxTableEntries * 4];
imageStream.Seek((long)thisDynamic.TableOffset, SeekOrigin.Begin);
imageStream.Read(bat, 0, batSectorCount);
ReadOnlySpan <byte> span = bat;
blockAllocationTable =
MemoryMarshal.Cast <byte, uint>(span).Slice(0, (int)thisDynamic.MaxTableEntries).ToArray();
for (int i = 0; i < blockAllocationTable.Length; i++)
{
blockAllocationTable[i] = Swapping.Swap(blockAllocationTable[i]);
}
DateTime endTime = DateTime.UtcNow;
AaruConsole.DebugWriteLine("VirtualPC plugin", "Filling the BAT took {0} seconds",
(endTime - startTime).TotalSeconds);
bitmapSize = (uint)Math.Ceiling((double)thisDynamic.BlockSize / 512
// 1 bit per sector on the bitmap
/ 8
// and aligned to 512 byte boundary
/ 512);
AaruConsole.DebugWriteLine("VirtualPC plugin", "Bitmap is {0} sectors", bitmapSize);
}
imageInfo.XmlMediaType = XmlMediaType.BlockMedia;
switch (thisFooter.DiskType)
{
case TYPE_FIXED:
case TYPE_DYNAMIC:
{
// Nothing to do here, really.
return(true);
}
case TYPE_DIFFERENCING:
{
locatorEntriesData = new byte[8][];
for (int i = 0; i < 8; i++)
{
if (thisDynamic.LocatorEntries[i].PlatformCode != 0x00000000)
{
locatorEntriesData[i] = new byte[thisDynamic.LocatorEntries[i].PlatformDataLength];
imageStream.Seek((long)thisDynamic.LocatorEntries[i].PlatformDataOffset, SeekOrigin.Begin);
imageStream.Read(locatorEntriesData[i], 0,
(int)thisDynamic.LocatorEntries[i].PlatformDataLength);
switch (thisDynamic.LocatorEntries[i].PlatformCode)
{
case PLATFORM_CODE_WINDOWS_ABSOLUTE:
case PLATFORM_CODE_WINDOWS_RELATIVE:
AaruConsole.DebugWriteLine("VirtualPC plugin",
"dynamic.locatorEntries[{0}] = \"{1}\"", i,
Encoding.ASCII.GetString(locatorEntriesData[i]));
break;
case PLATFORM_CODE_WINDOWS_ABSOLUTE_U:
case PLATFORM_CODE_WINDOWS_RELATIVE_U:
AaruConsole.DebugWriteLine("VirtualPC plugin",
"dynamic.locatorEntries[{0}] = \"{1}\"", i,
Encoding.BigEndianUnicode.
GetString(locatorEntriesData[i]));
break;
case PLATFORM_CODE_MACINTOSH_URI:
AaruConsole.DebugWriteLine("VirtualPC plugin",
"dynamic.locatorEntries[{0}] = \"{1}\"", i,
Encoding.UTF8.GetString(locatorEntriesData[i]));
break;
default:
AaruConsole.DebugWriteLine("VirtualPC plugin", "dynamic.locatorEntries[{0}] =", i);
PrintHex.PrintHexArray(locatorEntriesData[i], 64);
break;
}
}
}
int currentLocator = 0;
bool locatorFound = false;
string parentPath = null;
while (!locatorFound &&
currentLocator < 8)
{
switch (thisDynamic.LocatorEntries[currentLocator].PlatformCode)
{
case PLATFORM_CODE_WINDOWS_ABSOLUTE:
case PLATFORM_CODE_WINDOWS_RELATIVE:
parentPath = Encoding.ASCII.GetString(locatorEntriesData[currentLocator]);
break;
case PLATFORM_CODE_WINDOWS_ABSOLUTE_U:
case PLATFORM_CODE_WINDOWS_RELATIVE_U:
parentPath = Encoding.BigEndianUnicode.GetString(locatorEntriesData[currentLocator]);
break;
case PLATFORM_CODE_MACINTOSH_URI:
parentPath =
Uri.UnescapeDataString(Encoding.UTF8.GetString(locatorEntriesData[currentLocator]));
if (parentPath.StartsWith("file://localhost", StringComparison.InvariantCulture))
{
parentPath = parentPath.Remove(0, 16);
}
else
{
AaruConsole.DebugWriteLine("VirtualPC plugin",
"Unsupported protocol classified found in URI parent path: \"{0}\"",
parentPath);
parentPath = null;
}
break;
}
if (parentPath != null)
{
AaruConsole.DebugWriteLine("VirtualPC plugin", "Possible parent path: \"{0}\"", parentPath);
IFilter parentFilter =
new FiltersList().GetFilter(Path.Combine(imageFilter.GetParentFolder(), parentPath));
if (parentFilter != null)
{
locatorFound = true;
}
if (!locatorFound)
{
parentPath = null;
}
}
currentLocator++;
}
if (!locatorFound)
{
throw new
FileNotFoundException("(VirtualPC plugin): Cannot find parent file for differencing disk image");
}
{
parentImage = new Vhd();
IFilter parentFilter =
new FiltersList().GetFilter(Path.Combine(imageFilter.GetParentFolder(), parentPath));
if (parentFilter == null)
{
throw new ImageNotSupportedException("(VirtualPC plugin): Cannot find parent image filter");
}
/* PluginBase plugins = new PluginBase();
* plugins.RegisterAllPlugins();
* if (!plugins.ImagePluginsList.TryGetValue(Name.ToLower(), out parentImage))
* throw new SystemException("(VirtualPC plugin): Unable to open myself");*/
if (!parentImage.Identify(parentFilter))
{
throw new
ImageNotSupportedException("(VirtualPC plugin): Parent image is not a Virtual PC disk image");
}
if (!parentImage.Open(parentFilter))
{
throw new ImageNotSupportedException("(VirtualPC plugin): Cannot open parent disk image");
}
// While specification says that parent and child disk images should contain UUID relationship
// in reality it seems that old differencing disk images stored a parent UUID that, nonetheless
// the parent never stored itself. So the only real way to know that images are related is
// because the parent IS found and SAME SIZE. Ugly...
// More funny even, tested parent images show an empty host OS, and child images a correct one.
if (parentImage.Info.Sectors != imageInfo.Sectors)
{
throw new
ImageNotSupportedException("(VirtualPC plugin): Parent image is of different size");
}
}
return(true);
}
case TYPE_DEPRECATED1:
case TYPE_DEPRECATED2:
case TYPE_DEPRECATED3:
{
throw new
ImageNotSupportedException("(VirtualPC plugin): Deprecated image type found. Please submit a bug with an example image.");
}
default:
{
throw new
ImageNotSupportedException($"(VirtualPC plugin): Unknown image type {thisFooter.DiskType} found. Please submit a bug with an example image.");
}
}
}
public static UnicodeTrieHeader Parse(ReadOnlySpan <byte> data) => MemoryMarshal.Cast <byte, UnicodeTrieHeader>(data)[0];
/// <summary>
/// Copy image pixels to <paramref name="destination"/>.
/// </summary>
/// <param name="destination">The <see cref="Span{T}"/> of <see cref="byte"/> to copy image pixels to.</param>
public void CopyPixelDataTo(Span <byte> destination) => this.GetPixelMemoryGroup().CopyTo(MemoryMarshal.Cast <byte, TPixel>(destination));
/// <summary>
/// Writes the color palette to the stream. The color palette has 4 bytes for each entry.
/// </summary>
/// <typeparam name="TPixel">The type of the pixel.</typeparam>
/// <param name="stream">The <see cref="Stream"/> to write to.</param>
/// <param name="quantizedColorPalette">The color palette from the quantized image.</param>
/// <param name="colorPalette">A temporary byte span to write the color palette to.</param>
private void WriteColorPalette <TPixel>(Stream stream, ReadOnlySpan <TPixel> quantizedColorPalette, Span <byte> colorPalette)
where TPixel : unmanaged, IPixel <TPixel>
{
int quantizedColorBytes = quantizedColorPalette.Length * 4;
PixelOperations <TPixel> .Instance.ToBgra32(this.configuration, quantizedColorPalette, MemoryMarshal.Cast <byte, Bgra32>(colorPalette.Slice(0, quantizedColorBytes)));
Span <uint> colorPaletteAsUInt = MemoryMarshal.Cast <byte, uint>(colorPalette);
for (int i = 0; i < colorPaletteAsUInt.Length; i++)
{
colorPaletteAsUInt[i] = colorPaletteAsUInt[i] & 0x00FFFFFF; // Padding byte, always 0.
}
stream.Write(colorPalette);
}
/// <summary>
/// Updates host shaders based on the guest GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
private void UpdateShaderState(GpuState state)
{
ShaderAddresses addresses = new ShaderAddresses();
Span <ShaderAddresses> addressesSpan = MemoryMarshal.CreateSpan(ref addresses, 1);
Span <ulong> addressesArray = MemoryMarshal.Cast <ShaderAddresses, ulong>(addressesSpan);
ulong baseAddress = state.Get <GpuVa>(MethodOffset.ShaderBaseAddress).Pack();
for (int index = 0; index < 6; index++)
{
var shader = state.Get <ShaderState>(MethodOffset.ShaderState, index);
if (!shader.UnpackEnable() && index != 1)
{
continue;
}
addressesArray[index] = baseAddress + shader.Offset;
}
ShaderBundle gs = ShaderCache.GetGraphicsShader(state, addresses);
_vsUsesInstanceId = gs.Shaders[0]?.Info.UsesInstanceId ?? false;
int storageBufferBindingsCount = 0;
int uniformBufferBindingsCount = 0;
for (int stage = 0; stage < Constants.ShaderStages; stage++)
{
ShaderProgramInfo info = gs.Shaders[stage]?.Info;
_currentProgramInfo[stage] = info;
if (info == null)
{
TextureManager.SetGraphicsTextures(stage, Array.Empty <TextureBindingInfo>());
TextureManager.SetGraphicsImages(stage, Array.Empty <TextureBindingInfo>());
BufferManager.SetGraphicsStorageBufferBindings(stage, null);
BufferManager.SetGraphicsUniformBufferBindings(stage, null);
continue;
}
var textureBindings = new TextureBindingInfo[info.Textures.Count];
for (int index = 0; index < info.Textures.Count; index++)
{
var descriptor = info.Textures[index];
Target target = ShaderTexture.GetTarget(descriptor.Type);
textureBindings[index] = new TextureBindingInfo(
target,
descriptor.Binding,
descriptor.CbufSlot,
descriptor.HandleIndex,
descriptor.Flags);
}
TextureManager.SetGraphicsTextures(stage, textureBindings);
var imageBindings = new TextureBindingInfo[info.Images.Count];
for (int index = 0; index < info.Images.Count; index++)
{
var descriptor = info.Images[index];
Target target = ShaderTexture.GetTarget(descriptor.Type);
Format format = ShaderTexture.GetFormat(descriptor.Format);
imageBindings[index] = new TextureBindingInfo(
target,
format,
descriptor.Binding,
descriptor.CbufSlot,
descriptor.HandleIndex,
descriptor.Flags);
}
TextureManager.SetGraphicsImages(stage, imageBindings);
BufferManager.SetGraphicsStorageBufferBindings(stage, info.SBuffers);
BufferManager.SetGraphicsUniformBufferBindings(stage, info.CBuffers);
if (info.SBuffers.Count != 0)
{
storageBufferBindingsCount = Math.Max(storageBufferBindingsCount, info.SBuffers.Max(x => x.Binding) + 1);
}
if (info.CBuffers.Count != 0)
{
uniformBufferBindingsCount = Math.Max(uniformBufferBindingsCount, info.CBuffers.Max(x => x.Binding) + 1);
}
}
BufferManager.SetGraphicsStorageBufferBindingsCount(storageBufferBindingsCount);
BufferManager.SetGraphicsUniformBufferBindingsCount(uniformBufferBindingsCount);
_context.Renderer.Pipeline.SetProgram(gs.HostProgram);
}
/// <summary>Read an array of structures from RIFF chunk</summary>
public static void read <T>(this iRiffChunk chunk, T[] arr) where T : unmanaged
{
var span = MemoryMarshal.Cast <T, byte>(arr.AsSpan());
chunk.read(span);
}
public THashValue CombineHashValue(THashValue hash, string value)
{
ReadOnlySpan <byte> span = MemoryMarshal.Cast <char, byte>(value.AsSpan());
return(CombineHashValue(hash, span));
}
/// <summary>
/// Given the metadata for an event and an event payload, decode and deserialize the event payload.
/// </summary>
internal static object[] DecodePayload(ref EventSource.EventMetadata metadata, ReadOnlySpan <byte> payload)
{
ParameterInfo[] parameters = metadata.Parameters;
object[] decodedFields = new object[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
// It is possible that an older version of the event was emitted.
// If this happens, the payload might be missing arguments at the end.
// We can just leave these unset.
if (payload.Length <= 0)
{
break;
}
Type parameterType = parameters[i].ParameterType;
if (parameterType == typeof(IntPtr))
{
if (IntPtr.Size == 8)
{
decodedFields[i] = (IntPtr)BinaryPrimitives.ReadInt64LittleEndian(payload);
}
else
{
decodedFields[i] = (IntPtr)BinaryPrimitives.ReadInt32LittleEndian(payload);
}
payload = payload.Slice(IntPtr.Size);
}
else if (parameterType == typeof(int))
{
decodedFields[i] = BinaryPrimitives.ReadInt32LittleEndian(payload);
payload = payload.Slice(sizeof(int));
}
else if (parameterType == typeof(uint))
{
decodedFields[i] = BinaryPrimitives.ReadUInt32LittleEndian(payload);
payload = payload.Slice(sizeof(uint));
}
else if (parameterType == typeof(long))
{
decodedFields[i] = BinaryPrimitives.ReadInt64LittleEndian(payload);
payload = payload.Slice(sizeof(long));
}
else if (parameterType == typeof(ulong))
{
decodedFields[i] = BinaryPrimitives.ReadUInt64LittleEndian(payload);
payload = payload.Slice(sizeof(ulong));
}
else if (parameterType == typeof(byte))
{
decodedFields[i] = MemoryMarshal.Read <byte>(payload);
payload = payload.Slice(sizeof(byte));
}
else if (parameterType == typeof(sbyte))
{
decodedFields[i] = MemoryMarshal.Read <sbyte>(payload);
payload = payload.Slice(sizeof(sbyte));
}
else if (parameterType == typeof(short))
{
decodedFields[i] = BinaryPrimitives.ReadInt16LittleEndian(payload);
payload = payload.Slice(sizeof(short));
}
else if (parameterType == typeof(ushort))
{
decodedFields[i] = BinaryPrimitives.ReadUInt16LittleEndian(payload);
payload = payload.Slice(sizeof(ushort));
}
else if (parameterType == typeof(float))
{
decodedFields[i] = BitConverter.Int32BitsToSingle(BinaryPrimitives.ReadInt32LittleEndian(payload));
payload = payload.Slice(sizeof(float));
}
else if (parameterType == typeof(double))
{
decodedFields[i] = BitConverter.Int64BitsToDouble(BinaryPrimitives.ReadInt64LittleEndian(payload));
payload = payload.Slice(sizeof(double));
}
else if (parameterType == typeof(bool))
{
// The manifest defines a bool as a 32bit type (WIN32 BOOL), not 1 bit as CLR Does.
decodedFields[i] = (BinaryPrimitives.ReadInt32LittleEndian(payload) == 1);
payload = payload.Slice(sizeof(int));
}
else if (parameterType == typeof(Guid))
{
const int sizeOfGuid = 16;
decodedFields[i] = new Guid(payload.Slice(0, sizeOfGuid));
payload = payload.Slice(sizeOfGuid);
}
else if (parameterType == typeof(char))
{
decodedFields[i] = (char)BinaryPrimitives.ReadUInt16LittleEndian(payload);
payload = payload.Slice(sizeof(char));
}
else if (parameterType == typeof(string))
{
// Try to find null terminator (0x00) from the byte span
// NOTE: we do this by hand instead of using IndexOf because payload may be unaligned due to
// mixture of different types being stored in the same buffer. (see eventpipe.cpp:CopyData)
int byteCount = -1;
for (int j = 1; j < payload.Length; j += 2)
{
if (payload[j - 1] == (byte)(0) && payload[j] == (byte)(0))
{
byteCount = j + 1;
break;
}
}
ReadOnlySpan <char> charPayload;
if (byteCount < 0)
{
charPayload = MemoryMarshal.Cast <byte, char>(payload);
payload = default;
}
else
{
charPayload = MemoryMarshal.Cast <byte, char>(payload.Slice(0, byteCount - 2));
payload = payload.Slice(byteCount);
}
decodedFields[i] = BitConverter.IsLittleEndian ? new string(charPayload) : Encoding.Unicode.GetString(MemoryMarshal.Cast <char, byte>(charPayload));
}
else
{
Debug.Fail("Unsupported type encountered.");
}
}
return(decodedFields);
}
/// <summary>
/// Performs actual copy of the inline data after the transfer is finished.
/// </summary>
private void FinishTransfer()
{
var memoryManager = _channel.MemoryManager;
var data = MemoryMarshal.Cast <int, byte>(_buffer).Slice(0, _size);
if (_isLinear && _lineCount == 1)
{
memoryManager.WriteTrackedResource(_dstGpuVa, data);
_context.AdvanceSequence();
}
else
{
var dstCalculator = new OffsetCalculator(
_dstWidth,
_dstHeight,
_dstStride,
_isLinear,
_dstGobBlocksInY,
1);
int srcOffset = 0;
for (int y = _dstY; y < _dstY + _lineCount; y++)
{
int x1 = _dstX;
int x2 = _dstX + _lineLengthIn;
int x1Round = BitUtils.AlignUp(_dstX, 16);
int x2Trunc = BitUtils.AlignDown(x2, 16);
int x = x1;
if (x1Round <= x2)
{
for (; x < x1Round; x++, srcOffset++)
{
int dstOffset = dstCalculator.GetOffset(x, y);
ulong dstAddress = _dstGpuVa + (uint)dstOffset;
memoryManager.Write(dstAddress, data[srcOffset]);
}
}
for (; x < x2Trunc; x += 16, srcOffset += 16)
{
int dstOffset = dstCalculator.GetOffset(x, y);
ulong dstAddress = _dstGpuVa + (uint)dstOffset;
memoryManager.Write(dstAddress, MemoryMarshal.Cast <byte, Vector128 <byte> >(data.Slice(srcOffset, 16))[0]);
}
for (; x < x2; x++, srcOffset++)
{
int dstOffset = dstCalculator.GetOffset(x, y);
ulong dstAddress = _dstGpuVa + (uint)dstOffset;
memoryManager.Write(dstAddress, data[srcOffset]);
}
}
_context.AdvanceSequence();
}
_finished = true;
}
/// <summary>
/// Deserialize object of given type
/// </summary>
/// <param name="t">Target deserialized type</param>
/// <param name="stream">Stream to read from</param>
/// <returns>Deserialized object</returns>
/// <exception cref="ArgumentNullException"><paramref name="t"/> or <paramref name="stream"/> are null</exception>
public static object Deserialize(Type t, Stream stream)
{
if (t == null)
{
throw new ArgumentNullException(nameof(t));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (t == typeof(sbyte))
{
return((sbyte)stream.ReadByteOrThrow());
}
if (t == typeof(byte))
{
return(stream.ReadByteOrThrow());
}
if (t == typeof(short))
{
return(stream.ReadS16());
}
if (t == typeof(ushort))
{
return(stream.ReadU16());
}
if (t == typeof(int))
{
return(stream.ReadS32());
}
if (t == typeof(uint))
{
return(stream.ReadU32());
}
if (t == typeof(long))
{
return(stream.ReadS64());
}
if (t == typeof(ulong))
{
return(stream.ReadU64());
}
if (t == typeof(float))
{
return(stream.ReadSingle());
}
if (t == typeof(double))
{
return(stream.ReadDouble());
}
if (!t.IsValueType && stream.ReadByteOrThrow() == 0)
{
return(null);
}
if (t.IsEnum)
{
return(Deserialize(t.GetEnumUnderlyingType(), stream));
}
if (t == typeof(string))
{
return(stream.ReadCString());
}
if (t.IsArray)
{
var count = stream.ReadS32();
var t2 = t.GetElementType() ??
throw new Exception($"Element type for array not found in object of type {t}");
var vArray = Array.CreateInstance(t2, count);
if (vArray is sbyte[] vArrayS8)
{
stream.Read(MemoryMarshal.Cast <sbyte, byte>(vArrayS8));
}
else if (vArray is byte[] vArrayU8)
{
stream.Read(vArrayU8);
}
else if (vArray is short[] vArrayS16)
{
if (BitConverter.IsLittleEndian)
{
stream.Read(MemoryMarshal.Cast <short, byte>(vArrayS16));
}
else
{
for (var i = 0; i < count; i++)
{
vArrayS16.SetValue(stream.ReadS16(), i);
}
}
}
else if (vArray is ushort[] vArrayU16)
{
if (BitConverter.IsLittleEndian)
{
stream.Read(MemoryMarshal.Cast <ushort, byte>(vArrayU16));
}
else
{
for (var i = 0; i < count; i++)
{
vArrayU16.SetValue(stream.ReadU16(), i);
}
}
}
else if (vArray is int[] vArrayS32)
{
if (BitConverter.IsLittleEndian)
{
stream.Read(MemoryMarshal.Cast <int, byte>(vArrayS32));
}
else
{
for (var i = 0; i < count; i++)
{
vArrayS32.SetValue(stream.ReadS32(), i);
}
}
}
else if (vArray is uint[] vArrayU32)
{
if (BitConverter.IsLittleEndian)
{
stream.Read(MemoryMarshal.Cast <uint, byte>(vArrayU32));
}
else
{
for (var i = 0; i < count; i++)
{
vArrayU32.SetValue(stream.ReadU32(), i);
}
}
}
else if (vArray is long[] vArrayS64)
{
if (BitConverter.IsLittleEndian)
{
stream.Read(MemoryMarshal.Cast <long, byte>(vArrayS64));
}
else
{
for (var i = 0; i < count; i++)
{
vArrayS64.SetValue(stream.ReadS64(), i);
}
}
}
else if (vArray is ulong[] vArrayU64)
{
if (BitConverter.IsLittleEndian)
{
stream.Read(MemoryMarshal.Cast <ulong, byte>(vArrayU64));
}
else
{
for (var i = 0; i < count; i++)
{
vArrayU64.SetValue(stream.ReadU64(), i);
}
}
}
else if (vArray is float[] vArraySingle)
{
stream.Read(MemoryMarshal.Cast <float, byte>(vArraySingle));
}
else if (vArray is double[] vArrayDouble)
{
stream.Read(MemoryMarshal.Cast <double, byte>(vArrayDouble));
}
else
{
for (var i = 0; i < count; i++)
{
vArray.SetValue(Deserialize(t2, stream), i);
}
}
return(vArray);
}
var res = Activator.CreateInstance(t);
if (IsListType(t))
{
var vList = res as IList;
Debug.Assert(vList != null, nameof(vList) + " != null");
var count = stream.ReadS32();
var t2 = t.GetGenericArguments()[0];
for (var i = 0; i < count; i++)
{
vList.Add(Deserialize(t2, stream));
}
return(vList);
}
if (IsDictionaryType(t))
{
var vDict = res as IDictionary;
Debug.Assert(vDict != null, nameof(vDict) + " != null");
var count = stream.ReadS32();
var typeArgs = t.GetGenericArguments();
var t2 = typeArgs[0];
var t3 = typeArgs[1];
for (var i = 0; i < count; i++)
{
vDict.Add(Deserialize(t2, stream), Deserialize(t3, stream));
}
return(vDict);
}
var members = t.GetMembers();
if (t.GetCustomAttribute <CzCustomSerializeMembersAttribute>() != null)
{
var dict = CustomSerDict.GetOrAdd(t, GenerateCustomSerializeDict);
int tag;
do
{
tag = stream.ReadS32();
if (tag != -1)
{
TryDeserializeMember(dict[tag], stream, res);
}
} while (tag != -1);
}
else
{
foreach (var m in members)
{
TryDeserializeMember(m, stream, res);
}
}
return(res);
}
/// <summary>
/// Ensures that the texture bindings are visible to the host GPU.
/// Note: this actually performs the binding using the host graphics API.
/// </summary>
/// <param name="pool">The current texture pool</param>
/// <param name="stage">The shader stage using the textures to be bound</param>
/// <param name="stageIndex">The stage number of the specified shader stage</param>
private void CommitTextureBindings(TexturePool pool, ShaderStage stage, int stageIndex)
{
if (_textureBindings[stageIndex] == null)
{
return;
}
for (int index = 0; index < _textureBindings[stageIndex].Length; index++)
{
TextureBindingInfo binding = _textureBindings[stageIndex][index];
int packedId;
if (binding.IsBindless)
{
ulong address;
var bufferManager = _context.Methods.BufferManager;
if (_isCompute)
{
address = bufferManager.GetComputeUniformBufferAddress(binding.CbufSlot);
}
else
{
address = bufferManager.GetGraphicsUniformBufferAddress(stageIndex, binding.CbufSlot);
}
packedId = MemoryMarshal.Cast <byte, int>(_context.PhysicalMemory.GetSpan(address + (ulong)binding.CbufOffset * 4, 4))[0];
}
else
{
packedId = ReadPackedId(stageIndex, binding.Handle);
}
int textureId = UnpackTextureId(packedId);
int samplerId;
if (_samplerIndex == SamplerIndex.ViaHeaderIndex)
{
samplerId = textureId;
}
else
{
samplerId = UnpackSamplerId(packedId);
}
Texture texture = pool.Get(textureId);
ITexture hostTexture = texture?.GetTargetTexture(binding.Target);
if (_textureState[stageIndex][index].Texture != hostTexture || _rebind)
{
_textureState[stageIndex][index].Texture = hostTexture;
_context.Renderer.Pipeline.SetTexture(CurrentShaderMeta().GetTextureUnit(stage, index), hostTexture);
}
Sampler sampler = _samplerPool.Get(samplerId);
ISampler hostSampler = sampler?.HostSampler;
if (_textureState[stageIndex][index].Sampler != hostSampler || _rebind)
{
_textureState[stageIndex][index].Sampler = hostSampler;
_context.Renderer.Pipeline.SetSampler(CurrentShaderMeta().GetTextureUnit(stage, index), hostSampler);
}
}
}
/// <summary>
/// Serialize object to stream
/// </summary>
/// <param name="stream">Stream to write to</param>
/// <param name="value">Object to serialize</param>
/// <exception cref="ArgumentNullException"><paramref name="stream"/> is null</exception>
public static void Serialize(Stream stream, object value)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (value == null)
{
stream.WriteByte(0);
return;
}
switch (value)
{
case sbyte vSByte:
stream.WriteByte((byte)vSByte);
return;
case byte vByte:
stream.WriteByte(vByte);
return;
case short vShort:
vShort.WriteTo(stream);
return;
case ushort vUShort:
vUShort.WriteTo(stream);
return;
case int vInt:
vInt.WriteTo(stream);
return;
case uint vUInt:
vUInt.WriteTo(stream);
return;
case long vLong:
vLong.WriteTo(stream);
return;
case ulong vULong:
vULong.WriteTo(stream);
return;
case float vFloat:
vFloat.WriteTo(stream);
return;
case double vDouble:
vDouble.WriteTo(stream);
return;
}
var t = value.GetType();
if (!t.IsValueType)
{
stream.WriteByte(1);
}
if (t.IsEnum)
{
// ReSharper disable once TailRecursiveCall
Serialize(stream, Convert.ChangeType(value, t.GetEnumUnderlyingType(), null));
return;
}
if (value is string vString)
{
var arr = TextEncoding.GetBytes(vString);
stream.Write(arr, 0, arr.Length);
stream.WriteByte(0);
return;
}
if (value is Array vArray)
{
vArray.Length.WriteTo(stream);
if (vArray is sbyte[] vArrayS8)
{
stream.Write(MemoryMarshal.Cast <sbyte, byte>(vArrayS8));
}
else if (vArray is byte[] vArrayU8)
{
stream.Write(vArrayU8, 0, vArray.Length);
}
else if (vArray is short[] vArrayS16)
{
if (BitConverter.IsLittleEndian)
{
stream.Write(MemoryMarshal.Cast <short, byte>(vArrayS16));
}
else
{
foreach (var o in vArrayS16)
{
o.WriteTo(stream);
}
}
}
else if (vArray is ushort[] vArrayU16)
{
if (BitConverter.IsLittleEndian)
{
stream.Write(MemoryMarshal.Cast <ushort, byte>(vArrayU16));
}
else
{
foreach (var o in vArrayU16)
{
o.WriteTo(stream);
}
}
}
else if (vArray is int[] vArrayS32)
{
if (BitConverter.IsLittleEndian)
{
stream.Write(MemoryMarshal.Cast <int, byte>(vArrayS32));
}
else
{
foreach (var o in vArrayS32)
{
o.WriteTo(stream);
}
}
}
else if (vArray is uint[] vArrayU32)
{
if (BitConverter.IsLittleEndian)
{
stream.Write(MemoryMarshal.Cast <uint, byte>(vArrayU32));
}
else
{
foreach (var o in vArrayU32)
{
o.WriteTo(stream);
}
}
}
else if (vArray is long[] vArrayS64)
{
if (BitConverter.IsLittleEndian)
{
stream.Write(MemoryMarshal.Cast <long, byte>(vArrayS64));
}
else
{
foreach (var o in vArrayS64)
{
o.WriteTo(stream);
}
}
}
else if (vArray is ulong[] vArrayU64)
{
if (BitConverter.IsLittleEndian)
{
stream.Write(MemoryMarshal.Cast <ulong, byte>(vArrayU64));
}
else
{
foreach (var o in vArrayU64)
{
o.WriteTo(stream);
}
}
}
else if (vArray is float[] vArraySingle)
{
stream.Write(MemoryMarshal.Cast <float, byte>(vArraySingle));
}
else if (vArray is double[] vArrayDouble)
{
stream.Write(MemoryMarshal.Cast <double, byte>(vArrayDouble));
}
else
{
foreach (var o in vArray)
{
Serialize(stream, o);
}
}
return;
}
if (IsList(value))
{
var vList = value as IList;
Debug.Assert(vList != null, nameof(vList) + " != null");
vList.Count.WriteTo(stream);
foreach (var o in vList)
{
Serialize(stream, o);
}
return;
}
if (IsDictionary(value))
{
var vDict = value as IDictionary;
Debug.Assert(vDict != null, nameof(vDict) + " != null");
vDict.Count.WriteTo(stream);
foreach (var o in vDict.Keys)
{
Serialize(stream, o);
Serialize(stream, vDict[o]);
}
return;
}
var members = t.GetMembers();
if (t.GetCustomAttribute <CzCustomSerializeMembersAttribute>() != null)
{
foreach (var m in members)
{
if (m.GetCustomAttribute <CzSerializeAttribute>() is CzSerializeAttribute attrib)
{
TrySerializeMember(value, m, stream, attrib.Tag);
}
}
(-1).WriteTo(stream);
}
else
{
foreach (var m in members)
{
TrySerializeMember(value, m, stream);
}
}
}
/// <summary>
/// Reads data from CPU mapped memory, with read tracking
/// </summary>
/// <typeparam name="T">Type of the data being read</typeparam>
/// <param name="va">Virtual address of the data in memory</param>
/// <returns>The data</returns>
public T ReadTracked <T>(ulong va) where T : unmanaged
{
SignalMemoryTracking(va, (ulong)Unsafe.SizeOf <T>(), false);
return(MemoryMarshal.Cast <byte, T>(GetSpan(va, Unsafe.SizeOf <T>()))[0]);
}
public ShaderHeader(ReadOnlySpan <byte> code)
{
ReadOnlySpan <int> header = MemoryMarshal.Cast <byte, int>(code);
int commonWord0 = header[0];
int commonWord1 = header[1];
int commonWord2 = header[2];
int commonWord3 = header[3];
int commonWord4 = header[4];
SphType = commonWord0.Extract(0, 5);
Version = commonWord0.Extract(5, 5);
Stage = (ShaderStage)commonWord0.Extract(10, 4);
// Invalid.
if (Stage == ShaderStage.Compute)
{
Stage = ShaderStage.Vertex;
}
MrtEnable = commonWord0.Extract(14);
KillsPixels = commonWord0.Extract(15);
DoesGlobalStore = commonWord0.Extract(16);
SassVersion = commonWord0.Extract(17, 4);
DoesLoadOrStore = commonWord0.Extract(26);
DoesFp64 = commonWord0.Extract(27);
StreamOutMask = commonWord0.Extract(28, 4);
ShaderLocalMemoryLowSize = commonWord1.Extract(0, 24);
PerPatchAttributeCount = commonWord1.Extract(24, 8);
ShaderLocalMemoryHighSize = commonWord2.Extract(0, 24);
ThreadsPerInputPrimitive = commonWord2.Extract(24, 8);
ShaderLocalMemoryCrsSize = commonWord3.Extract(0, 24);
OutputTopology = (OutputTopology)commonWord3.Extract(24, 4);
MaxOutputVertexCount = commonWord4.Extract(0, 12);
StoreReqStart = commonWord4.Extract(12, 8);
StoreReqEnd = commonWord4.Extract(24, 8);
int type2OmapTarget = header[18];
int type2Omap = header[19];
OmapTargets = new OutputMapTarget[8];
for (int offset = 0; offset < OmapTargets.Length * 4; offset += 4)
{
OmapTargets[offset >> 2] = new OutputMapTarget(
type2OmapTarget.Extract(offset + 0),
type2OmapTarget.Extract(offset + 1),
type2OmapTarget.Extract(offset + 2),
type2OmapTarget.Extract(offset + 3));
}
OmapSampleMask = type2Omap.Extract(0);
OmapDepth = type2Omap.Extract(1);
}
public void Heightmap()
{
Span <byte> span = new byte[128];
span.Fill(0xFF);
Heightmap map = new Heightmap
{
XMin = 20,
XMax = 180,
XSpacing = 40,
YMin = 50,
YMax = 150,
YSpacing = 50,
Radius = 0,
NumX = 3,
NumY = 4,
ZCoordinates = new float[] {
10, 20, 30,
40, 50, 60,
70, 80, 90,
100, 110, 120
}
};
int bytesWritten = Writer.WriteHeightMap(span, map);
Assert.AreEqual(80, bytesWritten);
// Header
float xMin = MemoryMarshal.Read <float>(span);
Assert.AreEqual(20, xMin, 0.0001);
float xMax = MemoryMarshal.Read <float>(span.Slice(4, 4));
Assert.AreEqual(180, xMax, 0.0001);
float xSpacing = MemoryMarshal.Read <float>(span.Slice(8, 4));
Assert.AreEqual(40, xSpacing, 0.0001);
float yMin = MemoryMarshal.Read <float>(span.Slice(12, 4));
Assert.AreEqual(50, yMin, 0.0001);
float yMax = MemoryMarshal.Read <float>(span.Slice(16, 4));
Assert.AreEqual(150, yMax, 0.0001);
float ySpacing = MemoryMarshal.Read <float>(span.Slice(20, 4));
Assert.AreEqual(50, ySpacing, 0.0001);
float radius = MemoryMarshal.Read <float>(span.Slice(24, 4));
Assert.AreEqual(0, radius, 0.0001);
ushort numX = MemoryMarshal.Read <ushort>(span.Slice(28, 2));
Assert.AreEqual(3, numX);
ushort numY = MemoryMarshal.Read <ushort>(span.Slice(30, 2));
Assert.AreEqual(4, numY);
// Points
Span <float> zCoordinates = MemoryMarshal.Cast <byte, float>(span.Slice(32));
for (int i = 0; i < map.ZCoordinates.Length; i++)
{
Assert.AreEqual(zCoordinates[i], 10 * i + 10, 0.0001);
}
}
internal Interop.Crypto.X509VerifyStatusCode FindChainViaAia(
ref List <X509Certificate2> downloadedCerts)
{
IntPtr lastCert = IntPtr.Zero;
SafeX509StoreCtxHandle storeCtx = _storeCtx;
Interop.Crypto.X509VerifyStatusCode statusCode =
Interop.Crypto.X509VerifyStatusCode.X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT;
while (!IsCompleteChain(statusCode))
{
using (SafeX509Handle currentCert = Interop.Crypto.X509StoreCtxGetCurrentCert(storeCtx))
{
IntPtr currentHandle = currentCert.DangerousGetHandle();
// No progress was made, give up.
if (currentHandle == lastCert)
{
break;
}
lastCert = currentHandle;
ArraySegment <byte> authorityInformationAccess =
OpenSslX509CertificateReader.FindFirstExtension(
currentCert,
Oids.AuthorityInformationAccess);
if (authorityInformationAccess.Count == 0)
{
break;
}
X509Certificate2 downloaded = DownloadCertificate(
authorityInformationAccess,
ref _remainingDownloadTime);
// The AIA record is contained in a public structure, so no need to clear it.
CryptoPool.Return(authorityInformationAccess.Array, clearSize: 0);
if (downloaded == null)
{
break;
}
if (downloadedCerts == null)
{
downloadedCerts = new List <X509Certificate2>();
}
AddToStackAndUpRef(downloaded.Handle, _untrustedLookup);
downloadedCerts.Add(downloaded);
Interop.Crypto.X509StoreCtxRebuildChain(storeCtx);
statusCode = Interop.Crypto.X509StoreCtxGetError(storeCtx);
}
}
if (statusCode == Interop.Crypto.X509VerifyStatusCode.X509_V_OK && downloadedCerts != null)
{
using (SafeX509StackHandle chainStack = Interop.Crypto.X509StoreCtxGetChain(_storeCtx))
{
int chainSize = Interop.Crypto.GetX509StackFieldCount(chainStack);
Span <IntPtr> tempChain = stackalloc IntPtr[DefaultChainCapacity];
byte[] tempChainRent = null;
if (chainSize <= tempChain.Length)
{
tempChain = tempChain.Slice(0, chainSize);
}
else
{
int targetSize = checked (chainSize * IntPtr.Size);
tempChainRent = CryptoPool.Rent(targetSize);
tempChain = MemoryMarshal.Cast <byte, IntPtr>(tempChainRent.AsSpan(0, targetSize));
}
for (int i = 0; i < chainSize; i++)
{
tempChain[i] = Interop.Crypto.GetX509StackField(chainStack, i);
}
// In the average case we never made it here.
//
// Given that we made it here, in the average remaining case
// we are doing a one item for which will match in the second position
// of an (on-average) 3 item collection.
//
// The only case where this loop really matters is if downloading the
// certificate made an alternate chain better, which may have resulted in
// an extra download and made the first one not be involved any longer. In
// that case, it's a 2 item for loop matching against a three item set.
//
// So N*M is well contained.
for (int i = downloadedCerts.Count - 1; i >= 0; i--)
{
X509Certificate2 downloadedCert = downloadedCerts[i];
if (!tempChain.Contains(downloadedCert.Handle))
{
downloadedCert.Dispose();
downloadedCerts.RemoveAt(i);
}
}
if (downloadedCerts.Count == 0)
{
downloadedCerts = null;
}
if (tempChainRent != null)
{
CryptoPool.Return(tempChainRent);
}
}
}
return(statusCode);
}
public override Span <TTo> GetSpan() => MemoryMarshal.Cast <TFrom, TTo>(_unrooted.Memory.Span);
//
// Internal
//
internal static void HChaCha20(ReadOnlySpan <byte> key, ReadOnlySpan <byte> nonce, Span <byte> outKey)
{
// TODO: Could there be any unaligned memory access problems?
var keyU32 = MemoryMarshal.Cast <byte, uint>(key);
uint x00 = ChaCha20.InitialState0;
uint x01 = ChaCha20.InitialState1;
uint x02 = ChaCha20.InitialState2;
uint x03 = ChaCha20.InitialState3;
uint x04 = keyU32[0];
uint x05 = keyU32[1];
uint x06 = keyU32[2];
uint x07 = keyU32[3];
uint x08 = keyU32[4];
uint x09 = keyU32[5];
uint x10 = keyU32[6];
uint x11 = keyU32[7];
// TODO: Could there be any unaligned memory access problems?
var nonceU32 = MemoryMarshal.Cast <byte, uint>(nonce);
uint x12 = nonceU32[0];
uint x13 = nonceU32[1];
uint x14 = nonceU32[2];
uint x15 = nonceU32[3];
// TODO: This is exact the same code as in ChaCha20.ChaChaCore. Could we DRY this up?
for (var i = 0; i < ChaCha20.Rounds; i += 2)
{
x00 += x04;
x12 = ChaCha20.RotateLeft(x12 ^ x00, 16);
x08 += x12;
x04 = ChaCha20.RotateLeft(x04 ^ x08, 12);
x00 += x04;
x12 = ChaCha20.RotateLeft(x12 ^ x00, 8);
x08 += x12;
x04 = ChaCha20.RotateLeft(x04 ^ x08, 7);
x01 += x05;
x13 = ChaCha20.RotateLeft(x13 ^ x01, 16);
x09 += x13;
x05 = ChaCha20.RotateLeft(x05 ^ x09, 12);
x01 += x05;
x13 = ChaCha20.RotateLeft(x13 ^ x01, 8);
x09 += x13;
x05 = ChaCha20.RotateLeft(x05 ^ x09, 7);
x02 += x06;
x14 = ChaCha20.RotateLeft(x14 ^ x02, 16);
x10 += x14;
x06 = ChaCha20.RotateLeft(x06 ^ x10, 12);
x02 += x06;
x14 = ChaCha20.RotateLeft(x14 ^ x02, 8);
x10 += x14;
x06 = ChaCha20.RotateLeft(x06 ^ x10, 7);
x03 += x07;
x15 = ChaCha20.RotateLeft(x15 ^ x03, 16);
x11 += x15;
x07 = ChaCha20.RotateLeft(x07 ^ x11, 12);
x03 += x07;
x15 = ChaCha20.RotateLeft(x15 ^ x03, 8);
x11 += x15;
x07 = ChaCha20.RotateLeft(x07 ^ x11, 7);
x00 += x05;
x15 = ChaCha20.RotateLeft(x15 ^ x00, 16);
x10 += x15;
x05 = ChaCha20.RotateLeft(x05 ^ x10, 12);
x00 += x05;
x15 = ChaCha20.RotateLeft(x15 ^ x00, 8);
x10 += x15;
x05 = ChaCha20.RotateLeft(x05 ^ x10, 7);
x01 += x06;
x12 = ChaCha20.RotateLeft(x12 ^ x01, 16);
x11 += x12;
x06 = ChaCha20.RotateLeft(x06 ^ x11, 12);
x01 += x06;
x12 = ChaCha20.RotateLeft(x12 ^ x01, 8);
x11 += x12;
x06 = ChaCha20.RotateLeft(x06 ^ x11, 7);
x02 += x07;
x13 = ChaCha20.RotateLeft(x13 ^ x02, 16);
x08 += x13;
x07 = ChaCha20.RotateLeft(x07 ^ x08, 12);
x02 += x07;
x13 = ChaCha20.RotateLeft(x13 ^ x02, 8);
x08 += x13;
x07 = ChaCha20.RotateLeft(x07 ^ x08, 7);
x03 += x04;
x14 = ChaCha20.RotateLeft(x14 ^ x03, 16);
x09 += x14;
x04 = ChaCha20.RotateLeft(x04 ^ x09, 12);
x03 += x04;
x14 = ChaCha20.RotateLeft(x14 ^ x03, 8);
x09 += x14;
x04 = ChaCha20.RotateLeft(x04 ^ x09, 7);
}
var outKeyU32 = MemoryMarshal.Cast <byte, uint>(outKey);
outKeyU32[0] = x00;
outKeyU32[1] = x01;
outKeyU32[2] = x02;
outKeyU32[3] = x03;
outKeyU32[4] = x12;
outKeyU32[5] = x13;
outKeyU32[6] = x14;
outKeyU32[7] = x15;
}
