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

package/Runtime/{Protobuf-Net/System.Collections.Immutable.xml.meta → Utils/SevenZip/Compress/LZ.meta}

@@ -1,6 +1,7 @@
 fileFormatVersion: 2
-guid: 1cafb84e27fdef74a86d4be3a3f2ddde
-TextScriptImporter:
+guid: 74d9937e5aef2f34da3f14c03ba6fa06
+folderAsset: yes
+DefaultImporter:
   externalObjects: {}
   userData: 
   assetBundleName: 

package/Runtime/Utils/SevenZip/Compress/LZMA/LzmaBase.cs

@@ -0,0 +1,101 @@
+// LzmaBase.cs
+
+namespace SevenZip.Compression.LZMA
+{
+    internal abstract class Base
+    {
+        public const uint kNumRepDistances = 4;
+        public const uint kNumStates = 12;
+
+        // static byte []kLiteralNextStates  = {0, 0, 0, 0, 1, 2, 3, 4,  5,  6,   4, 5};
+        // static byte []kMatchNextStates    = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};
+        // static byte []kRepNextStates      = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};
+        // static byte []kShortRepNextStates = {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};
+
+        public struct State
+        {
+            public uint Index;
+
+            public void Init()
+            {
+                Index = 0;
+            }
+
+            public void UpdateChar()
+            {
+                if (Index < 4)
+                    Index = 0;
+                else if (Index < 10)
+                    Index -= 3;
+                else
+                    Index -= 6;
+            }
+
+            public void UpdateMatch()
+            {
+                Index = (uint)(Index < 7 ? 7 : 10);
+            }
+
+            public void UpdateRep()
+            {
+                Index = (uint)(Index < 7 ? 8 : 11);
+            }
+
+            public void UpdateShortRep()
+            {
+                Index = (uint)(Index < 7 ? 9 : 11);
+            }
+
+            public bool IsCharState()
+            {
+                return Index < 7;
+            }
+        }
+
+        public const int kNumPosSlotBits = 6;
+        public const int kDicLogSizeMin = 0;
+
+        // public const int kDicLogSizeMax = 30;
+        // public const uint kDistTableSizeMax = kDicLogSizeMax * 2;
+
+        public const int kNumLenToPosStatesBits = 2; // it's for speed optimization
+        public const uint kNumLenToPosStates = 1 << kNumLenToPosStatesBits;
+
+        public const uint kMatchMinLen = 2;
+
+        public static uint GetLenToPosState(uint len)
+        {
+            len -= kMatchMinLen;
+            if (len < kNumLenToPosStates)
+                return len;
+            return (uint)(kNumLenToPosStates - 1);
+        }
+
+        public const int kNumAlignBits = 4;
+        public const uint kAlignTableSize = 1 << kNumAlignBits;
+        public const uint kAlignMask = (kAlignTableSize - 1);
+
+        public const uint kStartPosModelIndex = 4;
+        public const uint kEndPosModelIndex = 14;
+        public const uint kNumPosModels = kEndPosModelIndex - kStartPosModelIndex;
+
+        public const uint kNumFullDistances = 1 << ((int)kEndPosModelIndex / 2);
+
+        public const uint kNumLitPosStatesBitsEncodingMax = 4;
+        public const uint kNumLitContextBitsMax = 8;
+
+        public const int kNumPosStatesBitsMax = 4;
+        public const uint kNumPosStatesMax = (1 << kNumPosStatesBitsMax);
+        public const int kNumPosStatesBitsEncodingMax = 4;
+        public const uint kNumPosStatesEncodingMax = (1 << kNumPosStatesBitsEncodingMax);
+
+        public const int kNumLowLenBits = 3;
+        public const int kNumMidLenBits = 3;
+        public const int kNumHighLenBits = 8;
+        public const uint kNumLowLenSymbols = 1 << kNumLowLenBits;
+        public const uint kNumMidLenSymbols = 1 << kNumMidLenBits;
+        public const uint kNumLenSymbols =
+            kNumLowLenSymbols + kNumMidLenSymbols + (1 << kNumHighLenBits);
+        public const uint kMatchMaxLen = kMatchMinLen + kNumLenSymbols - 1;
+    }
+}

package/Runtime/Utils/SevenZip/Compress/LZMA/LzmaBase.cs.meta

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

package/Runtime/Utils/SevenZip/Compress/LZMA/LzmaDecoder.cs

@@ -0,0 +1,464 @@
+// LzmaDecoder.cs
+
+using System;
+
+namespace SevenZip.Compression.LZMA
+{
+    using RangeCoder;
+
+    public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
+    {
+        class LenDecoder
+        {
+            BitDecoder m_Choice = new BitDecoder();
+            BitDecoder m_Choice2 = new BitDecoder();
+            BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
+            BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
+            BitTreeDecoder m_HighCoder = new BitTreeDecoder(Base.kNumHighLenBits);
+            uint m_NumPosStates = 0;
+
+            public void Create(uint numPosStates)
+            {
+                for (uint posState = m_NumPosStates; posState < numPosStates; posState++)
+                {
+                    m_LowCoder[posState] = new BitTreeDecoder(Base.kNumLowLenBits);
+                    m_MidCoder[posState] = new BitTreeDecoder(Base.kNumMidLenBits);
+                }
+                m_NumPosStates = numPosStates;
+            }
+
+            public void Init()
+            {
+                m_Choice.Init();
+                for (uint posState = 0; posState < m_NumPosStates; posState++)
+                {
+                    m_LowCoder[posState].Init();
+                    m_MidCoder[posState].Init();
+                }
+                m_Choice2.Init();
+                m_HighCoder.Init();
+            }
+
+            public uint Decode(RangeCoder.Decoder rangeDecoder, uint posState)
+            {
+                if (m_Choice.Decode(rangeDecoder) == 0)
+                    return m_LowCoder[posState].Decode(rangeDecoder);
+                else
+                {
+                    uint symbol = Base.kNumLowLenSymbols;
+                    if (m_Choice2.Decode(rangeDecoder) == 0)
+                        symbol += m_MidCoder[posState].Decode(rangeDecoder);
+                    else
+                    {
+                        symbol += Base.kNumMidLenSymbols;
+                        symbol += m_HighCoder.Decode(rangeDecoder);
+                    }
+                    return symbol;
+                }
+            }
+        }
+
+        class LiteralDecoder
+        {
+            struct Decoder2
+            {
+                BitDecoder[] m_Decoders;
+
+                public void Create()
+                {
+                    m_Decoders = new BitDecoder[0x300];
+                }
+
+                public void Init()
+                {
+                    for (int i = 0; i < 0x300; i++)
+                        m_Decoders[i].Init();
+                }
+
+                public byte DecodeNormal(RangeCoder.Decoder rangeDecoder)
+                {
+                    uint symbol = 1;
+                    do symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);
+                    while (symbol < 0x100);
+                    return (byte)symbol;
+                }
+
+                public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, byte matchByte)
+                {
+                    uint symbol = 1;
+                    do
+                    {
+                        uint matchBit = (uint)(matchByte >> 7) & 1;
+                        matchByte <<= 1;
+                        uint bit = m_Decoders[((1 + matchBit) << 8) + symbol].Decode(rangeDecoder);
+                        symbol = (symbol << 1) | bit;
+                        if (matchBit != bit)
+                        {
+                            while (symbol < 0x100)
+                                symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);
+                            break;
+                        }
+                    } while (symbol < 0x100);
+                    return (byte)symbol;
+                }
+            }
+
+            Decoder2[] m_Coders;
+            int m_NumPrevBits;
+            int m_NumPosBits;
+            uint m_PosMask;
+
+            public void Create(int numPosBits, int numPrevBits)
+            {
+                if (m_Coders != null && m_NumPrevBits == numPrevBits && m_NumPosBits == numPosBits)
+                    return;
+                m_NumPosBits = numPosBits;
+                m_PosMask = ((uint)1 << numPosBits) - 1;
+                m_NumPrevBits = numPrevBits;
+                uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
+                m_Coders = new Decoder2[numStates];
+                for (uint i = 0; i < numStates; i++)
+                    m_Coders[i].Create();
+            }
+
+            public void Init()
+            {
+                uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
+                for (uint i = 0; i < numStates; i++)
+                    m_Coders[i].Init();
+            }
+
+            uint GetState(uint pos, byte prevByte)
+            {
+                return ((pos & m_PosMask) << m_NumPrevBits)
+                    + (uint)(prevByte >> (8 - m_NumPrevBits));
+            }
+
+            public byte DecodeNormal(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte)
+            {
+                return m_Coders[GetState(pos, prevByte)].DecodeNormal(rangeDecoder);
+            }
+
+            public byte DecodeWithMatchByte(
+                RangeCoder.Decoder rangeDecoder,
+                uint pos,
+                byte prevByte,
+                byte matchByte
+            )
+            {
+                return m_Coders[GetState(pos, prevByte)]
+                    .DecodeWithMatchByte(rangeDecoder, matchByte);
+            }
+        };
+
+        LZ.OutWindow m_OutWindow = new LZ.OutWindow();
+        RangeCoder.Decoder m_RangeDecoder = new RangeCoder.Decoder();
+
+        BitDecoder[] m_IsMatchDecoders = new BitDecoder[
+            Base.kNumStates << Base.kNumPosStatesBitsMax
+        ];
+        BitDecoder[] m_IsRepDecoders = new BitDecoder[Base.kNumStates];
+        BitDecoder[] m_IsRepG0Decoders = new BitDecoder[Base.kNumStates];
+        BitDecoder[] m_IsRepG1Decoders = new BitDecoder[Base.kNumStates];
+        BitDecoder[] m_IsRepG2Decoders = new BitDecoder[Base.kNumStates];
+        BitDecoder[] m_IsRep0LongDecoders = new BitDecoder[
+            Base.kNumStates << Base.kNumPosStatesBitsMax
+        ];
+
+        BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[Base.kNumLenToPosStates];
+        BitDecoder[] m_PosDecoders = new BitDecoder[
+            Base.kNumFullDistances - Base.kEndPosModelIndex
+        ];
+
+        BitTreeDecoder m_PosAlignDecoder = new BitTreeDecoder(Base.kNumAlignBits);
+
+        LenDecoder m_LenDecoder = new LenDecoder();
+        LenDecoder m_RepLenDecoder = new LenDecoder();
+
+        LiteralDecoder m_LiteralDecoder = new LiteralDecoder();
+
+        uint m_DictionarySize;
+        uint m_DictionarySizeCheck;
+
+        uint m_PosStateMask;
+
+        public Decoder()
+        {
+            m_DictionarySize = 0xFFFFFFFF;
+            for (int i = 0; i < Base.kNumLenToPosStates; i++)
+                m_PosSlotDecoder[i] = new BitTreeDecoder(Base.kNumPosSlotBits);
+        }
+
+        void SetDictionarySize(uint dictionarySize)
+        {
+            if (m_DictionarySize != dictionarySize)
+            {
+                m_DictionarySize = dictionarySize;
+                m_DictionarySizeCheck = Math.Max(m_DictionarySize, 1);
+                uint blockSize = Math.Max(m_DictionarySizeCheck, (1 << 12));
+                m_OutWindow.Create(blockSize);
+            }
+        }
+
+        void SetLiteralProperties(int lp, int lc)
+        {
+            if (lp > 8)
+                throw new InvalidParamException();
+            if (lc > 8)
+                throw new InvalidParamException();
+            m_LiteralDecoder.Create(lp, lc);
+        }
+
+        void SetPosBitsProperties(int pb)
+        {
+            if (pb > Base.kNumPosStatesBitsMax)
+                throw new InvalidParamException();
+            uint numPosStates = (uint)1 << pb;
+            m_LenDecoder.Create(numPosStates);
+            m_RepLenDecoder.Create(numPosStates);
+            m_PosStateMask = numPosStates - 1;
+        }
+
+        bool _solid = false;
+
+        void Init(System.IO.Stream inStream, System.IO.Stream outStream)
+        {
+            m_RangeDecoder.Init(inStream);
+            m_OutWindow.Init(outStream, _solid);
+
+            uint i;
+            for (i = 0; i < Base.kNumStates; i++)
+            {
+                for (uint j = 0; j <= m_PosStateMask; j++)
+                {
+                    uint index = (i << Base.kNumPosStatesBitsMax) + j;
+                    m_IsMatchDecoders[index].Init();
+                    m_IsRep0LongDecoders[index].Init();
+                }
+                m_IsRepDecoders[i].Init();
+                m_IsRepG0Decoders[i].Init();
+                m_IsRepG1Decoders[i].Init();
+                m_IsRepG2Decoders[i].Init();
+            }
+
+            m_LiteralDecoder.Init();
+            for (i = 0; i < Base.kNumLenToPosStates; i++)
+                m_PosSlotDecoder[i].Init();
+            // m_PosSpecDecoder.Init();
+            for (i = 0; i < Base.kNumFullDistances - Base.kEndPosModelIndex; i++)
+                m_PosDecoders[i].Init();
+
+            m_LenDecoder.Init();
+            m_RepLenDecoder.Init();
+            m_PosAlignDecoder.Init();
+        }
+
+        public void Code(
+            System.IO.Stream inStream,
+            System.IO.Stream outStream,
+            Int64 inSize,
+            Int64 outSize,
+            ICodeProgress progress
+        )
+        {
+            Init(inStream, outStream);
+
+            Base.State state = new Base.State();
+            state.Init();
+            uint rep0 = 0,
+                rep1 = 0,
+                rep2 = 0,
+                rep3 = 0;
+
+            UInt64 nowPos64 = 0;
+            UInt64 outSize64 = (UInt64)outSize;
+            if (nowPos64 < outSize64)
+            {
+                if (
+                    m_IsMatchDecoders[state.Index << Base.kNumPosStatesBitsMax]
+                        .Decode(m_RangeDecoder) != 0
+                )
+                    throw new DataErrorException();
+                state.UpdateChar();
+                byte b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, 0, 0);
+                m_OutWindow.PutByte(b);
+                nowPos64++;
+            }
+            while (nowPos64 < outSize64)
+            {
+                // UInt64 next = Math.Min(nowPos64 + (1 << 18), outSize64);
+                // while(nowPos64 < next)
+                {
+                    uint posState = (uint)nowPos64 & m_PosStateMask;
+                    if (
+                        m_IsMatchDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState]
+                            .Decode(m_RangeDecoder) == 0
+                    )
+                    {
+                        byte b;
+                        byte prevByte = m_OutWindow.GetByte(0);
+                        if (!state.IsCharState())
+                            b = m_LiteralDecoder.DecodeWithMatchByte(
+                                m_RangeDecoder,
+                                (uint)nowPos64,
+                                prevByte,
+                                m_OutWindow.GetByte(rep0)
+                            );
+                        else
+                            b = m_LiteralDecoder.DecodeNormal(
+                                m_RangeDecoder,
+                                (uint)nowPos64,
+                                prevByte
+                            );
+                        m_OutWindow.PutByte(b);
+                        state.UpdateChar();
+                        nowPos64++;
+                    }
+                    else
+                    {
+                        uint len;
+                        if (m_IsRepDecoders[state.Index].Decode(m_RangeDecoder) == 1)
+                        {
+                            if (m_IsRepG0Decoders[state.Index].Decode(m_RangeDecoder) == 0)
+                            {
+                                if (
+                                    m_IsRep0LongDecoders[
+                                        (state.Index << Base.kNumPosStatesBitsMax) + posState
+                                    ]
+                                        .Decode(m_RangeDecoder) == 0
+                                )
+                                {
+                                    state.UpdateShortRep();
+                                    m_OutWindow.PutByte(m_OutWindow.GetByte(rep0));
+                                    nowPos64++;
+                                    continue;
+                                }
+                            }
+                            else
+                            {
+                                UInt32 distance;
+                                if (m_IsRepG1Decoders[state.Index].Decode(m_RangeDecoder) == 0)
+                                {
+                                    distance = rep1;
+                                }
+                                else
+                                {
+                                    if (m_IsRepG2Decoders[state.Index].Decode(m_RangeDecoder) == 0)
+                                        distance = rep2;
+                                    else
+                                    {
+                                        distance = rep3;
+                                        rep3 = rep2;
+                                    }
+                                    rep2 = rep1;
+                                }
+                                rep1 = rep0;
+                                rep0 = distance;
+                            }
+                            len =
+                                m_RepLenDecoder.Decode(m_RangeDecoder, posState)
+                                + Base.kMatchMinLen;
+                            state.UpdateRep();
+                        }
+                        else
+                        {
+                            rep3 = rep2;
+                            rep2 = rep1;
+                            rep1 = rep0;
+                            len = Base.kMatchMinLen + m_LenDecoder.Decode(m_RangeDecoder, posState);
+                            state.UpdateMatch();
+                            uint posSlot = m_PosSlotDecoder[Base.GetLenToPosState(len)]
+                                .Decode(m_RangeDecoder);
+                            if (posSlot >= Base.kStartPosModelIndex)
+                            {
+                                int numDirectBits = (int)((posSlot >> 1) - 1);
+                                rep0 = ((2 | (posSlot & 1)) << numDirectBits);
+                                if (posSlot < Base.kEndPosModelIndex)
+                                    rep0 += BitTreeDecoder.ReverseDecode(
+                                        m_PosDecoders,
+                                        rep0 - posSlot - 1,
+                                        m_RangeDecoder,
+                                        numDirectBits
+                                    );
+                                else
+                                {
+                                    rep0 += (
+                                        m_RangeDecoder.DecodeDirectBits(
+                                            numDirectBits - Base.kNumAlignBits
+                                        ) << Base.kNumAlignBits
+                                    );
+                                    rep0 += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);
+                                }
+                            }
+                            else
+                                rep0 = posSlot;
+                        }
+                        if (
+                            rep0 >= m_OutWindow.TrainSize + nowPos64
+                            || rep0 >= m_DictionarySizeCheck
+                        )
+                        {
+                            if (rep0 == 0xFFFFFFFF)
+                                break;
+                            throw new DataErrorException();
+                        }
+                        m_OutWindow.CopyBlock(rep0, len);
+                        nowPos64 += len;
+                    }
+                }
+            }
+            m_OutWindow.Flush();
+            m_OutWindow.ReleaseStream();
+            m_RangeDecoder.ReleaseStream();
+        }
+
+        public void SetDecoderProperties(byte[] properties)
+        {
+            if (properties.Length < 5)
+                throw new InvalidParamException();
+            int lc = properties[0] % 9;
+            int remainder = properties[0] / 9;
+            int lp = remainder % 5;
+            int pb = remainder / 5;
+            if (pb > Base.kNumPosStatesBitsMax)
+                throw new InvalidParamException();
+            UInt32 dictionarySize = 0;
+            for (int i = 0; i < 4; i++)
+                dictionarySize += ((UInt32)(properties[1 + i])) << (i * 8);
+            SetDictionarySize(dictionarySize);
+            SetLiteralProperties(lp, lc);
+            SetPosBitsProperties(pb);
+        }
+
+        public bool Train(System.IO.Stream stream)
+        {
+            _solid = true;
+            return m_OutWindow.Train(stream);
+        }
+
+        /*
+        public override bool CanRead { get { return true; }}
+        public override bool CanWrite { get { return true; }}
+        public override bool CanSeek { get { return true; }}
+        public override long Length { get { return 0; }}
+        public override long Position
+        {
+            get { return 0;	}
+            set { }
+        }
+        public override void Flush() { }
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            return 0;
+        }
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+        }
+        public override long Seek(long offset, System.IO.SeekOrigin origin)
+        {
+            return 0;
+        }
+        public override void SetLength(long value) {}
+        */
+    }
+}

package/Runtime/Utils/SevenZip/Compress/LZMA/LzmaDecoder.cs.meta

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