daily update on 20240419 by nitload youmu, SSD merged into main stream
This commit is contained in:
YoumuLiu
@@ -0,0 +1,199 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="DataHead.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.Numerics;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Data
|
||||
{
|
||||
|
||||
[StructLayout(LayoutKind.Explicit, Size = 16)]
|
||||
public struct SSDSegmentHead
|
||||
{
|
||||
|
||||
[FieldOffset(0)] internal M128 data;
|
||||
[FieldOffset(12)] internal byte size;
|
||||
|
||||
[FieldOffset(0)] public int globalID;
|
||||
[FieldOffset(4)] public int nextID;
|
||||
|
||||
|
||||
[FieldOffset(8)] public int previousHash;
|
||||
[FieldOffset(13)] public byte selfDefine_1;
|
||||
[FieldOffset(14)] public byte selfDefine_2;
|
||||
[FieldOffset(15)] public byte selfDefine_3;
|
||||
|
||||
public int Size
|
||||
{
|
||||
get => ((int)size) + 1;
|
||||
set
|
||||
{
|
||||
if ((value > 256) || (value < 0))
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
size = (byte)(value - 1);
|
||||
}
|
||||
}
|
||||
|
||||
public unsafe byte[] GetBytes()
|
||||
{
|
||||
byte[] ret = new byte[16];
|
||||
fixed (Vector4* vptr = &data.vec)
|
||||
{
|
||||
byte* bptr = (byte*)vptr;
|
||||
for (int i = 0; i < 15; i++)
|
||||
{
|
||||
ret[i] = *bptr;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
public unsafe class SSDrawHead : IEnumerable<int>
|
||||
{
|
||||
|
||||
private List<int> freeSegments;
|
||||
private string name;
|
||||
|
||||
private List<(int, int)> segmentRange;
|
||||
internal SSDSegmentHead _head;
|
||||
|
||||
internal SSDrawHead(string name)
|
||||
{
|
||||
int hash;
|
||||
this.name = name;
|
||||
using (SHA256 sha256Hash = SHA256.Create())
|
||||
{
|
||||
byte[] bytes = sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(name));
|
||||
|
||||
hash = BitConverter.ToInt32(bytes, 0);
|
||||
}
|
||||
_head.previousHash = hash;
|
||||
segmentRange = new List<(int, int)>();
|
||||
freeSegments = new List<int>();
|
||||
}
|
||||
|
||||
public SSDrawHead()
|
||||
{
|
||||
segmentRange = new List<(int, int)>();
|
||||
freeSegments = new List<int>();
|
||||
}
|
||||
|
||||
public void AddSingleSegment(int id)
|
||||
{
|
||||
freeSegments.Add(id);
|
||||
}
|
||||
|
||||
public unsafe byte[] GetBytes(out int size)
|
||||
{
|
||||
byte[] namecode = Encoding.UTF8.GetBytes(name);
|
||||
size = 16 + 4 +
|
||||
(segmentRange.Count * 8) +
|
||||
(freeSegments.Count * 4) +
|
||||
namecode.Length;
|
||||
byte[] ret = new byte[size];
|
||||
fixed (byte* bptr = ret)
|
||||
{
|
||||
*(SSDSegmentHead*)bptr = _head;
|
||||
*(bptr + 16) = (byte)segmentRange.Count;
|
||||
*(bptr + 17) = (byte)namecode.Length;
|
||||
*(bptr + 18) = (byte)freeSegments.Count;
|
||||
int t = 20;
|
||||
for (int i = 0; i < segmentRange.Count; i++, t += 8)
|
||||
{
|
||||
*(int*)(bptr + t) = segmentRange[i].Item1;
|
||||
*(int*)(bptr + t + 4) = segmentRange[i].Item2;
|
||||
}
|
||||
for (int i = 0; i < freeSegments.Count; i++, t += 4)
|
||||
{
|
||||
*(int*)(bptr + t) = freeSegments[i];
|
||||
}
|
||||
for (int i = 0; i < namecode.Length; i++, t++)
|
||||
{
|
||||
*(bptr + t) = namecode[i];
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public void WriteRange(int begin, int end)
|
||||
{
|
||||
segmentRange.Add((begin, end));
|
||||
}
|
||||
|
||||
internal void MarkSegment(int id)
|
||||
{
|
||||
freeSegments.Add(id);
|
||||
}
|
||||
|
||||
IEnumerator IEnumerable.GetEnumerator()
|
||||
{
|
||||
foreach (var tuple in segmentRange)
|
||||
{
|
||||
for (int i = tuple.Item1; i <= tuple.Item2; i++)
|
||||
{
|
||||
yield return i;
|
||||
}
|
||||
}
|
||||
|
||||
foreach (var item in freeSegments)
|
||||
{
|
||||
yield return item;
|
||||
}
|
||||
}
|
||||
|
||||
IEnumerator<int> IEnumerable<int>.GetEnumerator()
|
||||
{
|
||||
foreach (var tuple in segmentRange)
|
||||
{
|
||||
for (int i = tuple.Item1; i <= tuple.Item2; i++)
|
||||
{
|
||||
yield return i;
|
||||
}
|
||||
}
|
||||
|
||||
foreach (var item in freeSegments)
|
||||
{
|
||||
yield return item;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="SSD.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Data.FileIO;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Data
|
||||
{
|
||||
public partial class SSD
|
||||
{
|
||||
|
||||
private SSDFolder _root;
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="SSDVirtualFolder.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Data.FileIO;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Data
|
||||
{
|
||||
public class SSDFolder: SSDSerializable
|
||||
{
|
||||
internal string _name;
|
||||
internal int _folderID;
|
||||
internal List<SSDraw> files;
|
||||
internal List<SSDFolder> folders;
|
||||
|
||||
public SSDFolder(string name)
|
||||
{
|
||||
if (name == "root")
|
||||
{
|
||||
throw new ArgumentNullException("Name cannot be root");
|
||||
}
|
||||
_name = name;
|
||||
folders = new List<SSDFolder>();
|
||||
|
||||
}
|
||||
|
||||
public override byte SSDTypeCode => SerializableTypeCode.VirtualFolder;
|
||||
|
||||
public override byte[] GetBytes()
|
||||
{
|
||||
List<byte> rawBytes =new List<byte>();
|
||||
byte[] size = new byte[5];
|
||||
List<int> fileid = new List<int>();
|
||||
fileid.Add(4);
|
||||
foreach (var item in files)
|
||||
{
|
||||
fileid.Add(item.)
|
||||
}
|
||||
|
||||
|
||||
return rawBytes.ToArray();
|
||||
}
|
||||
|
||||
public override byte[] GetBytes(out int length)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
internal override void BuildFromByteStream(byte[] stream)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,253 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="SSDraw.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Numerics;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
using System.Xml.Serialization;
|
||||
|
||||
namespace StgSharp.Data.FileIO
|
||||
{
|
||||
public class SSDraw
|
||||
{
|
||||
|
||||
public const string FileType = "ssdraw";
|
||||
|
||||
public const int SegmentCapacity = 16 * 16;
|
||||
|
||||
private SSDrawHead _head;
|
||||
private string _name;
|
||||
private SSDSegment currentSegment;
|
||||
private int previousHash;
|
||||
private List<SSDSegment> segments;
|
||||
|
||||
public int ID
|
||||
{
|
||||
get { return _head._head.globalID; }
|
||||
}
|
||||
|
||||
public SSDraw(string name)
|
||||
{
|
||||
_name = name;
|
||||
segments = new List<SSDSegment>();
|
||||
}
|
||||
|
||||
public void CreateRawFile(string outputFolder, bool rewrite)
|
||||
{
|
||||
string route =
|
||||
$"{(((outputFolder == string.Empty) ? " " : ($"{outputFolder}\\")))}{($"{_name}.{FileType}")}";
|
||||
if (File.Exists(route) && !rewrite)
|
||||
{
|
||||
throw new Exception("This SSDRAW has already existed.");
|
||||
}
|
||||
using (File.Create(route)) { }
|
||||
using (File.Open(route, FileMode.Truncate)) { }
|
||||
FileStream f = File.Open(route, FileMode.Open);
|
||||
int size = 0;
|
||||
f.Write(_head.GetBytes(out size), 0, size);
|
||||
foreach (var _head in segments)
|
||||
{
|
||||
f.Write(_head.GetBytes(), 0, 18 * 16);
|
||||
}
|
||||
f.Close();
|
||||
}
|
||||
|
||||
public static SSDraw readRaw(string route)
|
||||
{
|
||||
string[] routeFolders = route.Split('\\');
|
||||
if (!routeFolders.Last().Contains($".{FileType}"))
|
||||
{
|
||||
throw new Exception($"File to open is not a {FileType} file.");
|
||||
}
|
||||
|
||||
FileStream stream = File.Open(route, FileMode.Open);
|
||||
return new SSDraw(string.Empty);
|
||||
}
|
||||
|
||||
public void WriteRaw(byte[] dataStream)
|
||||
{
|
||||
previousHash = BuildRawHead(0);
|
||||
currentSegment = new SSDSegment(previousHash);
|
||||
int t = 0;
|
||||
for (int i = 0; i < dataStream.Length; i++, t++)
|
||||
{
|
||||
if (t == SegmentCapacity)
|
||||
{
|
||||
currentSegment.GetDataHash();
|
||||
currentSegment.Head.Size = 256;
|
||||
currentSegment.Head.globalID = i;
|
||||
segments.Add(currentSegment);
|
||||
previousHash = currentSegment.GetHashCode();
|
||||
currentSegment = new SSDSegment(previousHash);
|
||||
t = 0;
|
||||
}
|
||||
currentSegment[i] = dataStream[i];
|
||||
}
|
||||
currentSegment.FillRandomBytes(t);
|
||||
currentSegment.GetDataHash();
|
||||
currentSegment.Head.Size = t;
|
||||
segments.Add(currentSegment);
|
||||
|
||||
}
|
||||
|
||||
private int BuildRawHead(int beginID)
|
||||
{
|
||||
SSDrawHead rawHead = new SSDrawHead(_name);
|
||||
_head = rawHead;
|
||||
return rawHead.GetHashCode();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Explicit)]
|
||||
public unsafe struct SSDSegment
|
||||
{
|
||||
|
||||
[FieldOffset(16)] public fixed byte Data[16 * 16];
|
||||
[FieldOffset(12)] public int DataHash;
|
||||
[FieldOffset(0 * 16)] public SSDSegmentHead Head;
|
||||
[FieldOffset(8)] public int PreviousHash;
|
||||
|
||||
public SSDSegment(int previousHash)
|
||||
{
|
||||
this.PreviousHash = previousHash;
|
||||
}
|
||||
|
||||
public byte this[int index]
|
||||
{
|
||||
get
|
||||
{
|
||||
if (index > (16 * 14) - 1)
|
||||
{
|
||||
throw new IndexOutOfRangeException();
|
||||
}
|
||||
return Data[index];
|
||||
}
|
||||
|
||||
set
|
||||
{
|
||||
if (index > (16 * 14) - 1)
|
||||
{
|
||||
throw new IndexOutOfRangeException();
|
||||
}
|
||||
Data[index] = value;
|
||||
}
|
||||
}
|
||||
|
||||
public short Size => Head.size;
|
||||
|
||||
public void FillRandomBytes(int begin)
|
||||
{
|
||||
if (begin > 255)
|
||||
{
|
||||
return;
|
||||
}
|
||||
for (int i = begin; i < 255; i++)
|
||||
{
|
||||
Data[i] = 0; //TODO: 使用STGSHARP内部随机数工具处理它
|
||||
}
|
||||
}
|
||||
|
||||
public byte[] GetBytes()
|
||||
{
|
||||
byte[] ret = new byte[16 * 18];
|
||||
fixed (M128* mptr = &Head.data)
|
||||
{
|
||||
fixed (byte* aptr = ret)
|
||||
{
|
||||
Vector4* vsptr = (Vector4*)mptr;
|
||||
Vector4* vtptr = (Vector4*)aptr;
|
||||
for (int i = 0; i < 18; i++)
|
||||
{
|
||||
*(vtptr + i) = *(vsptr + i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
public int GetDataHash()
|
||||
{
|
||||
Vector4 v = Vector4.One;
|
||||
fixed (M128* mptr = &Head.data)
|
||||
{
|
||||
Vector4* vptr = (Vector4*)mptr;
|
||||
for (int i = 0; i < 16; i += 1)
|
||||
{
|
||||
v += (*vptr) * 31;
|
||||
}
|
||||
}
|
||||
M128 m = new M128(v);
|
||||
DataHash = m.vec.GetHashCode();
|
||||
return DataHash;
|
||||
}
|
||||
|
||||
public override int GetHashCode()
|
||||
{
|
||||
int ret = 17;
|
||||
fixed (M128* mptr = &Head.data)
|
||||
{
|
||||
Vector4* vptr = (Vector4*)mptr;
|
||||
for (int i = 0; i < 18; i++)
|
||||
{
|
||||
ret = (ret + (*vptr).GetHashCode()) * 31;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public unsafe T ReadData<T>(int index) where T : struct
|
||||
{
|
||||
fixed (byte* bptr = Data)
|
||||
{
|
||||
T* tptr = (T*)bptr;
|
||||
return *(tptr + index);
|
||||
}
|
||||
}
|
||||
public unsafe void WriteData<T>(int index, T value) where T : struct
|
||||
{
|
||||
fixed (byte* bptr = Data)
|
||||
{
|
||||
T* tptr = (T*)bptr;
|
||||
*(tptr + index) = value;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user