com.wallstop-studios.unity-helpers 2.0.0-rc79 → 2.0.0-rc79.1

package/Runtime/Utils/LZMA.cs

@@ -0,0 +1,53 @@
+namespace WallstopStudios.UnityHelpers.Utils
+{
+    // LzmaHelper.cs - A wrapper for the LZMA SDK
+    using System;
+    using System.IO;
+    using System.Threading;
+    using SevenZip.Compression.LZMA;
+
+    public static class LZMA
+    {
+        private static readonly ThreadLocal<Decoder> Decoders = new(() => new Decoder());
+        private static readonly ThreadLocal<Encoder> Encoders = new(() => new Encoder());
+        private static readonly ThreadLocal<byte[]> Properties = new(() => new byte[5]);
+        private static readonly ThreadLocal<byte[]> FileLengths = new(() => new byte[8]);
+
+        public static byte[] Compress(byte[] input)
+        {
+            Encoder encoder = Encoders.Value;
+            using MemoryStream inStream = new(input, writable: false);
+            using MemoryStream outStream = new();
+            encoder.WriteCoderProperties(outStream);
+
+            // Write original file size
+            outStream.Write(BitConverter.GetBytes(inStream.Length), 0, 8);
+
+            // Compress the data
+            encoder.Code(inStream, outStream, inStream.Length, -1, null);
+            return outStream.ToArray();
+        }
+
+        public static byte[] Decompress(byte[] input)
+        {
+            Decoder decoder = Decoders.Value;
+            using MemoryStream inStream = new(input, writable: false);
+            using MemoryStream outStream = new();
+            // Read decoder properties
+            byte[] properties = Properties.Value;
+            Array.Clear(properties, 0, properties.Length);
+            inStream.Read(properties, 0, properties.Length);
+            decoder.SetDecoderProperties(properties);
+
+            // Read original file size
+            byte[] fileLengthBytes = FileLengths.Value;
+            Array.Clear(fileLengthBytes, 0, fileLengthBytes.Length);
+            inStream.Read(fileLengthBytes, 0, 8);
+            long fileLength = BitConverter.ToInt64(fileLengthBytes, 0);
+
+            // Decompress the data
+            decoder.Code(inStream, outStream, inStream.Length, fileLength, null);
+            return outStream.ToArray();
+        }
+    }
+}

package/Runtime/Utils/LZMA.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a40192abcf3c407080bcba2fc551e225
+timeCreated: 1756402526

package/Runtime/Utils/SevenZip/Common/CRC.cs

@@ -0,0 +1,61 @@
+// Common/CRC.cs
+
+namespace SevenZip
+{
+    class CRC
+    {
+        public static readonly uint[] Table;
+
+        static CRC()
+        {
+            Table = new uint[256];
+            const uint kPoly = 0xEDB88320;
+            for (uint i = 0; i < 256; i++)
+            {
+                uint r = i;
+                for (int j = 0; j < 8; j++)
+                    if ((r & 1) != 0)
+                        r = (r >> 1) ^ kPoly;
+                    else
+                        r >>= 1;
+                Table[i] = r;
+            }
+        }
+
+        uint _value = 0xFFFFFFFF;
+
+        public void Init()
+        {
+            _value = 0xFFFFFFFF;
+        }
+
+        public void UpdateByte(byte b)
+        {
+            _value = Table[(((byte)(_value)) ^ b)] ^ (_value >> 8);
+        }
+
+        public void Update(byte[] data, uint offset, uint size)
+        {
+            for (uint i = 0; i < size; i++)
+                _value = Table[(((byte)(_value)) ^ data[offset + i])] ^ (_value >> 8);
+        }
+
+        public uint GetDigest()
+        {
+            return _value ^ 0xFFFFFFFF;
+        }
+
+        static uint CalculateDigest(byte[] data, uint offset, uint size)
+        {
+            CRC crc = new CRC();
+            // crc.Init();
+            crc.Update(data, offset, size);
+            return crc.GetDigest();
+        }
+
+        static bool VerifyDigest(uint digest, byte[] data, uint offset, uint size)
+        {
+            return (CalculateDigest(data, offset, size) == digest);
+        }
+    }
+}

package/Runtime/Utils/SevenZip/Common/CRC.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3dc8670f79b8cc04ebf2dc9503c3b212
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Utils/SevenZip/Common/InBuffer.cs

@@ -0,0 +1,71 @@
+// InBuffer.cs
+
+namespace SevenZip.Buffer
+{
+    public class InBuffer
+    {
+        byte[] m_Buffer;
+        uint m_Pos;
+        uint m_Limit;
+        uint m_BufferSize;
+        System.IO.Stream m_Stream;
+        bool m_StreamWasExhausted;
+        ulong m_ProcessedSize;
+
+        public InBuffer(uint bufferSize)
+        {
+            m_Buffer = new byte[bufferSize];
+            m_BufferSize = bufferSize;
+        }
+
+        public void Init(System.IO.Stream stream)
+        {
+            m_Stream = stream;
+            m_ProcessedSize = 0;
+            m_Limit = 0;
+            m_Pos = 0;
+            m_StreamWasExhausted = false;
+        }
+
+        public bool ReadBlock()
+        {
+            if (m_StreamWasExhausted)
+                return false;
+            m_ProcessedSize += m_Pos;
+            int aNumProcessedBytes = m_Stream.Read(m_Buffer, 0, (int)m_BufferSize);
+            m_Pos = 0;
+            m_Limit = (uint)aNumProcessedBytes;
+            m_StreamWasExhausted = (aNumProcessedBytes == 0);
+            return (!m_StreamWasExhausted);
+        }
+
+        public void ReleaseStream()
+        {
+            // m_Stream.Close();
+            m_Stream = null;
+        }
+
+        public bool ReadByte(byte b) // check it
+        {
+            if (m_Pos >= m_Limit)
+                if (!ReadBlock())
+                    return false;
+            b = m_Buffer[m_Pos++];
+            return true;
+        }
+
+        public byte ReadByte()
+        {
+            // return (byte)m_Stream.ReadByte();
+            if (m_Pos >= m_Limit)
+                if (!ReadBlock())
+                    return 0xFF;
+            return m_Buffer[m_Pos++];
+        }
+
+        public ulong GetProcessedSize()
+        {
+            return m_ProcessedSize + m_Pos;
+        }
+    }
+}

package/Runtime/Utils/SevenZip/Common/InBuffer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d9ac1800f49f3ef49b15cedc6801f985
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Utils/SevenZip/Common/OutBuffer.cs

@@ -0,0 +1,65 @@
+// OutBuffer.cs
+
+namespace SevenZip.Buffer
+{
+    public class OutBuffer
+    {
+        byte[] m_Buffer;
+        uint m_Pos;
+        uint m_BufferSize;
+        System.IO.Stream m_Stream;
+        ulong m_ProcessedSize;
+
+        public OutBuffer(uint bufferSize)
+        {
+            m_Buffer = new byte[bufferSize];
+            m_BufferSize = bufferSize;
+        }
+
+        public void SetStream(System.IO.Stream stream)
+        {
+            m_Stream = stream;
+        }
+
+        public void FlushStream()
+        {
+            m_Stream.Flush();
+        }
+
+        public void CloseStream()
+        {
+            m_Stream.Close();
+        }
+
+        public void ReleaseStream()
+        {
+            m_Stream = null;
+        }
+
+        public void Init()
+        {
+            m_ProcessedSize = 0;
+            m_Pos = 0;
+        }
+
+        public void WriteByte(byte b)
+        {
+            m_Buffer[m_Pos++] = b;
+            if (m_Pos >= m_BufferSize)
+                FlushData();
+        }
+
+        public void FlushData()
+        {
+            if (m_Pos == 0)
+                return;
+            m_Stream.Write(m_Buffer, 0, (int)m_Pos);
+            m_Pos = 0;
+        }
+
+        public ulong GetProcessedSize()
+        {
+            return m_ProcessedSize + m_Pos;
+        }
+    }
+}

package/Runtime/Utils/SevenZip/Common/OutBuffer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 694fae53bf0755f4daf26b34bc69017c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Utils/SevenZip/Common.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1aabbf2e9b0c44cab7a350196de304ee
+timeCreated: 1756403037

package/Runtime/Utils/SevenZip/Compress/LZ/IMatchFinder.cs

@@ -0,0 +1,28 @@
+// IMatchFinder.cs
+
+using System;
+
+namespace SevenZip.Compression.LZ
+{
+    interface IInWindowStream
+    {
+        void SetStream(System.IO.Stream inStream);
+        void Init();
+        void ReleaseStream();
+        Byte GetIndexByte(Int32 index);
+        UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit);
+        UInt32 GetNumAvailableBytes();
+    }
+
+    interface IMatchFinder : IInWindowStream
+    {
+        void Create(
+            UInt32 historySize,
+            UInt32 keepAddBufferBefore,
+            UInt32 matchMaxLen,
+            UInt32 keepAddBufferAfter
+        );
+        UInt32 GetMatches(UInt32[] distances);
+        void Skip(UInt32 num);
+    }
+}

package/Runtime/Utils/SevenZip/Compress/LZ/IMatchFinder.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: faf30c7802a24124cb5e5942544e622c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: