From df178687ba17a773a1d8e204de10fed33faec0a9 Mon Sep 17 00:00:00 2001 From: CroakFang <1605296300@qq.com> Date: Tue, 13 Dec 2022 22:47:31 +0800 Subject: [PATCH 1/8] update --- Assets/Scenes/Version2.unity | 13 + Assets/Scripts/BaseNcoding.meta | 8 + Assets/Scripts/BaseNcoding/Base.cs | 184 ++++ Assets/Scripts/BaseNcoding/Base.cs.meta | 11 + Assets/Scripts/BaseNcoding/Base256.cs | 41 + Assets/Scripts/BaseNcoding/Base256.cs.meta | 11 + Assets/Scripts/BaseNcoding/Base32.cs | 203 +++++ Assets/Scripts/BaseNcoding/Base32.cs.meta | 11 + Assets/Scripts/BaseNcoding/Base64.cs | 170 ++++ Assets/Scripts/BaseNcoding/Base64.cs.meta | 11 + Assets/Scripts/BaseNcoding/Base85.cs | 181 ++++ Assets/Scripts/BaseNcoding/Base85.cs.meta | 11 + Assets/Scripts/BaseNcoding/Base91.cs | 99 +++ Assets/Scripts/BaseNcoding/Base91.cs.meta | 11 + Assets/Scripts/BaseNcoding/BaseBigN.cs | 261 ++++++ Assets/Scripts/BaseNcoding/BaseBigN.cs.meta | 11 + Assets/Scripts/BaseNcoding/BaseN.cs | 228 +++++ Assets/Scripts/BaseNcoding/BaseN.cs.meta | 11 + Assets/Scripts/BaseNcoding/StringGenerator.cs | 48 ++ .../BaseNcoding/StringGenerator.cs.meta | 11 + Assets/Scripts/LZ4.meta | 8 + Assets/Scripts/LZ4/LZ4Codec.Safe.cs | 757 ++++++++++++++++ Assets/Scripts/LZ4/LZ4Codec.Safe.cs.meta | 11 + Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs | 795 +++++++++++++++++ .../Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs.meta | 11 + Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs | 524 ++++++++++++ .../LZ4/LZ4Codec.Safe32HC.Dirty.cs.meta | 11 + Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs | 808 ++++++++++++++++++ .../Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs.meta | 11 + Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs | 526 ++++++++++++ .../LZ4/LZ4Codec.Safe64HC.Dirty.cs.meta | 11 + Assets/Scripts/LZ4/LZ4Codec.cs | 176 ++++ Assets/Scripts/LZ4/LZ4Codec.cs.meta | 11 + Assets/Scripts/LZ4/LZ4Util.cs | 129 +++ Assets/Scripts/LZ4/LZ4Util.cs.meta | 11 + Assets/Scripts/Test.cs | 40 + Assets/Scripts/Test.cs.meta | 11 + Packages/packages-lock.json | 24 +- ProjectSettings/PackageManagerSettings.asset | 2 +- ProjectSettings/ProjectVersion.txt | 4 +- 40 files changed, 5401 insertions(+), 15 deletions(-) create mode 100644 Assets/Scripts/BaseNcoding.meta create mode 100644 Assets/Scripts/BaseNcoding/Base.cs create mode 100644 Assets/Scripts/BaseNcoding/Base.cs.meta create mode 100644 Assets/Scripts/BaseNcoding/Base256.cs create mode 100644 Assets/Scripts/BaseNcoding/Base256.cs.meta create mode 100644 Assets/Scripts/BaseNcoding/Base32.cs create mode 100644 Assets/Scripts/BaseNcoding/Base32.cs.meta create mode 100644 Assets/Scripts/BaseNcoding/Base64.cs create mode 100644 Assets/Scripts/BaseNcoding/Base64.cs.meta create mode 100644 Assets/Scripts/BaseNcoding/Base85.cs create mode 100644 Assets/Scripts/BaseNcoding/Base85.cs.meta create mode 100644 Assets/Scripts/BaseNcoding/Base91.cs create mode 100644 Assets/Scripts/BaseNcoding/Base91.cs.meta create mode 100644 Assets/Scripts/BaseNcoding/BaseBigN.cs create mode 100644 Assets/Scripts/BaseNcoding/BaseBigN.cs.meta create mode 100644 Assets/Scripts/BaseNcoding/BaseN.cs create mode 100644 Assets/Scripts/BaseNcoding/BaseN.cs.meta create mode 100644 Assets/Scripts/BaseNcoding/StringGenerator.cs create mode 100644 Assets/Scripts/BaseNcoding/StringGenerator.cs.meta create mode 100644 Assets/Scripts/LZ4.meta create mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe.cs create mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe.cs.meta create mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs create mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs.meta create mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs create mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs.meta create mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs create mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs.meta create mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs create mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs.meta create mode 100644 Assets/Scripts/LZ4/LZ4Codec.cs create mode 100644 Assets/Scripts/LZ4/LZ4Codec.cs.meta create mode 100644 Assets/Scripts/LZ4/LZ4Util.cs create mode 100644 Assets/Scripts/LZ4/LZ4Util.cs.meta create mode 100644 Assets/Scripts/Test.cs create mode 100644 Assets/Scripts/Test.cs.meta diff --git a/Assets/Scenes/Version2.unity b/Assets/Scenes/Version2.unity index 119b79b..269dacf 100644 --- a/Assets/Scenes/Version2.unity +++ b/Assets/Scenes/Version2.unity @@ -30122,6 +30122,7 @@ GameObject: - component: {fileID: 1564959565} - component: {fileID: 1564959567} - component: {fileID: 1564959568} + - component: {fileID: 1564959569} m_Layer: 0 m_Name: ViewerMain m_TagString: Untagged @@ -30275,6 +30276,18 @@ MonoBehaviour: type: 2} AnimationCameraAnimator: {fileID: 1468470379} AnimationCamera: {fileID: 790387849} +--- !u!114 &1564959569 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1564959564} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 822adc4dd85200142901586dd5c697c6, type: 3} + m_Name: + m_EditorClassIdentifier: --- !u!1 &1566898429 GameObject: m_ObjectHideFlags: 0 diff --git a/Assets/Scripts/BaseNcoding.meta b/Assets/Scripts/BaseNcoding.meta new file mode 100644 index 0000000..1cf72b5 --- /dev/null +++ b/Assets/Scripts/BaseNcoding.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 8efe8ce6fc7c3d84db812df72e79c7ce +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/BaseNcoding/Base.cs b/Assets/Scripts/BaseNcoding/Base.cs new file mode 100644 index 0000000..8dd9dfc --- /dev/null +++ b/Assets/Scripts/BaseNcoding/Base.cs @@ -0,0 +1,184 @@ +using System; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; + +namespace BaseNcoding +{ + public abstract class Base + { + public uint CharsCount { get; } + + public double BitsPerChars => (double)BlockBitsCount / BlockCharsCount; + + public int BlockBitsCount { get; protected set; } + + public int BlockCharsCount { get; protected set; } + + public string Alphabet { get; } + + public char Special { get; } + + public abstract bool HasSpecial { get; } + + public Encoding Encoding { get; set; } + + public bool Parallel { get; set; } + + protected readonly int[] InvAlphabet; + + public Base(uint charsCount, string alphabet, char special, Encoding encoding = null, bool parallel = false) + { + if (alphabet.Length != charsCount) + throw new ArgumentException($"Base string should contain {charsCount} chars"); + + for (int i = 0; i < charsCount; i++) + for (int j = i + 1; j < charsCount; j++) + if (alphabet[i] == alphabet[j]) + throw new ArgumentException("Base string should contain distinct chars"); + + if (alphabet.Contains(special)) + throw new ArgumentException("Base string should not contain special char"); + + CharsCount = charsCount; + Alphabet = alphabet; + Special = special; + int bitsPerChar = LogBase2(charsCount); + BlockBitsCount = Lcm(bitsPerChar, 8); + BlockCharsCount = BlockBitsCount / bitsPerChar; + + InvAlphabet = new int[Alphabet.Max() + 1]; + + for (int i = 0; i < InvAlphabet.Length; i++) + InvAlphabet[i] = -1; + + for (int i = 0; i < charsCount; i++) + InvAlphabet[Alphabet[i]] = i; + + Encoding = encoding ?? Encoding.UTF8; + Parallel = parallel; + } + + public virtual string EncodeString(string data) + { + return Encode(Encoding.GetBytes(data)); + } + + public abstract string Encode(byte[] data); + + public string DecodeToString(string data) + { + return Encoding.GetString(Decode(Regex.Replace(data, @"\r\n?|\n", ""))); + } + + public abstract byte[] Decode(string data); + + /// + /// From: http://stackoverflow.com/a/600306/1046374 + /// + /// + /// + public static bool IsPowerOf2(uint x) + { + uint xint = x; + if (x - xint != 0) + return false; + + return (xint & (xint - 1)) == 0; + } + + /// + /// From: http://stackoverflow.com/a/13569863/1046374 + /// + public static int Lcm(int a, int b) + { + int num1, num2; + if (a > b) + { + num1 = a; + num2 = b; + } + else + { + num1 = b; + num2 = a; + } + + for (int i = 1; i <= num2; i++) + { + int mult = num1 * i; + if (mult % num2 == 0) + return mult; + } + + return num2; + } + + private static int LogBase2(uint x) + { + int r = 0; + while ((x >>= 1) != 0) + r++; + return r; + } + + private static int LogBaseN(uint x, uint n) + { + int r = 0; + while ((x /= n) != 0) + r++; + return r; + } + + public static int GetOptimalBitsCount2(uint charsCount, out uint charsCountInBits, + uint maxBitsCount = 64, bool base2BitsCount = false) + { + int result = 0; + charsCountInBits = 0; + int n1 = LogBase2(charsCount); + double charsCountLog = Math.Log(2, charsCount); + double maxRatio = 0; + + for (int n = n1; n <= maxBitsCount; n++) + { + if (base2BitsCount && n % 8 != 0) + continue; + + uint l1 = (uint)Math.Ceiling(n * charsCountLog); + double ratio = (double)n / l1; + if (ratio > maxRatio) + { + maxRatio = ratio; + result = n; + charsCountInBits = l1; + } + } + + return result; + } + + protected static int GetOptimalBitsCount(uint charsCount, out uint charsCountInBits, + uint maxBitsCount = 64, uint radix = 2) + { + int result = 0; + charsCountInBits = 0; + int n0 = LogBaseN(charsCount, radix); + double charsCountLog = Math.Log(radix, charsCount); + double maxRatio = 0; + + for (int n = n0; n <= maxBitsCount; n++) + { + uint k = (uint)Math.Ceiling(n * charsCountLog); + double ratio = (double)n / k; + if (ratio > maxRatio) + { + maxRatio = ratio; + result = n; + charsCountInBits = k; + } + } + + return result; + } + } +} diff --git a/Assets/Scripts/BaseNcoding/Base.cs.meta b/Assets/Scripts/BaseNcoding/Base.cs.meta new file mode 100644 index 0000000..904a5d4 --- /dev/null +++ b/Assets/Scripts/BaseNcoding/Base.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: dddac6b0e9d7d75489cf3110fcc3a611 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/BaseNcoding/Base256.cs b/Assets/Scripts/BaseNcoding/Base256.cs new file mode 100644 index 0000000..8a90ef2 --- /dev/null +++ b/Assets/Scripts/BaseNcoding/Base256.cs @@ -0,0 +1,41 @@ +using System.Text; + +namespace BaseNcoding +{ + public class Base256 : Base + { + public const string DefaultAlphabet = "!#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖרÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿĀāĂ㥹ĆćĈĉĊċČčĎďĐđĒēĔĕĖėĘęĚěĜĝĞğĠġĢģĤĥĦħĨĩĪīĬĭĮįİıIJijĴĵĶķĸĹĺĻļĽľĿŀŁł"; + public const char DefaultSpecial = (char)0; + + public override bool HasSpecial => false; + + public Base256(string alphabet = DefaultAlphabet, char special = DefaultSpecial, + Encoding textEncoding = null) + : base(256, alphabet, special, textEncoding) + { + } + + public override string Encode(byte[] data) + { + var result = new char[data.Length]; + + for (int i = 0; i < data.Length; i++) + result[i] = Alphabet[data[i]]; + + return new string(result); + } + + public override byte[] Decode(string data) + { + unchecked + { + byte[] result = new byte[data.Length]; + + for (int i = 0; i < data.Length; i++) + result[i] = (byte)InvAlphabet[data[i]]; + + return result; + } + } + } +} diff --git a/Assets/Scripts/BaseNcoding/Base256.cs.meta b/Assets/Scripts/BaseNcoding/Base256.cs.meta new file mode 100644 index 0000000..5d61cf6 --- /dev/null +++ b/Assets/Scripts/BaseNcoding/Base256.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b84ecd8bc32acb7448d64c9bb045948d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/BaseNcoding/Base32.cs b/Assets/Scripts/BaseNcoding/Base32.cs new file mode 100644 index 0000000..33b70ff --- /dev/null +++ b/Assets/Scripts/BaseNcoding/Base32.cs @@ -0,0 +1,203 @@ +using System.Text; + +namespace BaseNcoding +{ + public class Base32 : Base + { + public const string DefaultAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"; + public const char DefaultSpecial = '>'; + + public override bool HasSpecial => true; + + public Base32(string alphabet = DefaultAlphabet, char special = DefaultSpecial, Encoding textEncoding = null) + : base(32, alphabet, special, textEncoding) + { + } + + public override string Encode(byte[] data) + { + int dataLength = data.Length; + StringBuilder result = new StringBuilder((dataLength + 4) / 5 * 8); + + byte x1, x2; + int i; + + int length5 = (dataLength / 5) * 5; + for (i = 0; i < length5; i += 5) + { + x1 = data[i]; + result.Append(Alphabet[x1 >> 3]); + + x2 = data[i + 1]; + result.Append(Alphabet[((x1 << 2) & 0x1C) | (x2 >> 6)]); + result.Append(Alphabet[(x2 >> 1) & 0x1F]); + + x1 = data[i + 2]; + result.Append(Alphabet[((x2 << 4) & 0x10) | (x1 >> 4)]); + + x2 = data[i + 3]; + result.Append(Alphabet[((x1 << 1) & 0x1E) | (x2 >> 7)]); + result.Append(Alphabet[(x2 >> 2) & 0x1F]); + + x1 = data[i + 4]; + result.Append(Alphabet[((x2 << 3) & 0x18) | (x1 >> 5)]); + result.Append(Alphabet[x1 & 0x1F]); + } + + switch (dataLength - length5) + { + case 1: + x1 = data[i]; + result.Append(Alphabet[x1 >> 3]); + result.Append(Alphabet[(x1 << 2) & 0x1C]); + + result.Append(Special, 6); + break; + case 2: + x1 = data[i]; + result.Append(Alphabet[x1 >> 3]); + x2 = data[i + 1]; + result.Append(Alphabet[((x1 << 2) & 0x1C) | (x2 >> 6)]); + result.Append(Alphabet[(x2 >> 1) & 0x1F]); + result.Append(Alphabet[(x2 << 4) & 0x10]); + + result.Append(Special, 4); + break; + case 3: + x1 = data[i]; + result.Append(Alphabet[x1 >> 3]); + x2 = data[i + 1]; + result.Append(Alphabet[((x1 << 2) & 0x1C) | (x2 >> 6)]); + result.Append(Alphabet[(x2 >> 1) & 0x1F]); + x1 = data[i + 2]; + result.Append(Alphabet[((x2 << 4) & 0x10) | (x1 >> 4)]); + result.Append(Alphabet[(x1 << 1) & 0x1E]); + + result.Append(Special, 3); + break; + case 4: + x1 = data[i]; + result.Append(Alphabet[x1 >> 3]); + x2 = data[i + 1]; + result.Append(Alphabet[((x1 << 2) & 0x1C) | (x2 >> 6)]); + result.Append(Alphabet[(x2 >> 1) & 0x1F]); + x1 = data[i + 2]; + result.Append(Alphabet[((x2 << 4) & 0x10) | (x1 >> 4)]); + x2 = data[i + 3]; + result.Append(Alphabet[((x1 << 1) & 0x1E) | (x2 >> 7)]); + result.Append(Alphabet[(x2 >> 2) & 0x1F]); + result.Append(Alphabet[(x2 << 3) & 0x18]); + + result.Append(Special); + break; + } + + return result.ToString(); + } + + public override byte[] Decode(string data) + { + unchecked + { + if (string.IsNullOrEmpty(data)) + return new byte[0]; + + int additionalBytes = 0, diff = 0, tempLen = 0; + + + int lastSpecialInd = data.Length; + while (data[lastSpecialInd - 1] == Special) + lastSpecialInd--; + int tailLength = data.Length - lastSpecialInd; + + switch (tailLength) + { + case 6: + additionalBytes = 4; + break; + case 4: + additionalBytes = 3; + break; + case 3: + additionalBytes = 2; + break; + case 1: + additionalBytes = 1; + break; + } + + diff = tailLength - additionalBytes; + tailLength = additionalBytes; + tempLen = data.Length - diff; + + byte[] result = new byte[(tempLen + 7) / 8 * 5 - tailLength]; + int length5 = result.Length / 5 * 5; + int x1, x2, x3, x4, x5, x6, x7, x8; + + int i, srcInd = 0; + for (i = 0; i < length5; i += 5) + { + x1 = InvAlphabet[data[srcInd++]]; + x2 = InvAlphabet[data[srcInd++]]; + x3 = InvAlphabet[data[srcInd++]]; + x4 = InvAlphabet[data[srcInd++]]; + x5 = InvAlphabet[data[srcInd++]]; + x6 = InvAlphabet[data[srcInd++]]; + x7 = InvAlphabet[data[srcInd++]]; + x8 = InvAlphabet[data[srcInd++]]; + + result[i] = (byte)((x1 << 3) | ((x2 >> 2) & 0x07)); + result[i + 1] = (byte)((x2 << 6) | ((x3 << 1) & 0x3E) | ((x4 >> 4) & 0x01)); + result[i + 2] = (byte)((x4 << 4) | ((x5 >> 1) & 0xF)); + result[i + 3] = (byte)((x5 << 7) | ((x6 << 2) & 0x7C) | ((x7 >> 3) & 0x03)); + result[i + 4] = (byte)((x7 << 5) | (x8 & 0x1F)); + } + + switch (tailLength) + { + case 4: + x1 = InvAlphabet[data[srcInd++]]; + x2 = InvAlphabet[data[srcInd++]]; + result[i] = (byte)((x1 << 3) | ((x2 >> 2) & 0x07)); + break; + case 3: + x1 = InvAlphabet[data[srcInd++]]; + x2 = InvAlphabet[data[srcInd++]]; + x3 = InvAlphabet[data[srcInd++]]; + x4 = InvAlphabet[data[srcInd++]]; + + result[i] = (byte)((x1 << 3) | ((x2 >> 2) & 0x07)); + result[i + 1] = (byte)((x2 << 6) | ((x3 << 1) & 0x3E) | ((x4 >> 4) & 0x01)); + break; + case 2: + x1 = InvAlphabet[data[srcInd++]]; + x2 = InvAlphabet[data[srcInd++]]; + x3 = InvAlphabet[data[srcInd++]]; + x4 = InvAlphabet[data[srcInd++]]; + x5 = InvAlphabet[data[srcInd++]]; + + result[i] = (byte)((x1 << 3) | ((x2 >> 2) & 0x07)); + result[i + 1] = (byte)((x2 << 6) | ((x3 << 1) & 0x3E) | ((x4 >> 4) & 0x01)); + result[i + 2] = (byte)((x4 << 4) | ((x5 >> 1) & 0xF)); + break; + case 1: + x1 = InvAlphabet[data[srcInd++]]; + x2 = InvAlphabet[data[srcInd++]]; + x3 = InvAlphabet[data[srcInd++]]; + x4 = InvAlphabet[data[srcInd++]]; + x5 = InvAlphabet[data[srcInd++]]; + x6 = InvAlphabet[data[srcInd++]]; + x7 = InvAlphabet[data[srcInd++]]; + + result[i] = (byte)((x1 << 3) | ((x2 >> 2) & 0x07)); + result[i + 1] = (byte)((x2 << 6) | ((x3 << 1) & 0x3E) | ((x4 >> 4) & 0x01)); + result[i + 2] = (byte)((x4 << 4) | ((x5 >> 1) & 0xF)); + result[i + 3] = (byte)((x5 << 7) | ((x6 << 2) & 0x7C) | ((x7 >> 3) & 0x03)); + break; + } + + return result; + } + } + } +} diff --git a/Assets/Scripts/BaseNcoding/Base32.cs.meta b/Assets/Scripts/BaseNcoding/Base32.cs.meta new file mode 100644 index 0000000..b799a44 --- /dev/null +++ b/Assets/Scripts/BaseNcoding/Base32.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 126c83fbe81b32444ade8272d29789b1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/BaseNcoding/Base64.cs b/Assets/Scripts/BaseNcoding/Base64.cs new file mode 100644 index 0000000..302be4f --- /dev/null +++ b/Assets/Scripts/BaseNcoding/Base64.cs @@ -0,0 +1,170 @@ +using System; +using System.Text; + +namespace BaseNcoding +{ + public class Base64 : Base + { + public const string DefaultAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + public const char DefaultSpecial = '='; + + public override bool HasSpecial => true; + + public Base64(string alphabet = DefaultAlphabet, char special = DefaultSpecial, + Encoding textEncoding = null, bool parallel = false) + : base(64, alphabet, special, textEncoding, parallel) + { + } + + public override string Encode(byte[] data) + { + int resultLength = (data.Length + 2) / 3 * 4; + char[] result = new char[resultLength]; + + int length3 = data.Length / 3; + if (!Parallel) + { + EncodeBlock(data, result, 0, length3); + } + else + { + int processorCount = Math.Min(length3, Environment.ProcessorCount); + System.Threading.Tasks.Parallel.For(0, processorCount, i => + { + int beginInd = i * length3 / processorCount; + int endInd = (i + 1) * length3 / processorCount; + EncodeBlock(data, result, beginInd, endInd); + }); + } + + int ind; + int x1, x2; + int srcInd, dstInd; + switch (data.Length - length3 * 3) + { + case 1: + ind = length3; + srcInd = ind * 3; + dstInd = ind * 4; + x1 = data[srcInd]; + result[dstInd] = Alphabet[x1 >> 2]; + result[dstInd + 1] = Alphabet[(x1 << 4) & 0x30]; + result[dstInd + 2] = Special; + result[dstInd + 3] = Special; + break; + case 2: + ind = length3; + srcInd = ind * 3; + dstInd = ind * 4; + x1 = data[srcInd]; + x2 = data[srcInd + 1]; + result[dstInd] = Alphabet[x1 >> 2]; + result[dstInd + 1] = Alphabet[((x1 << 4) & 0x30) | (x2 >> 4)]; + result[dstInd + 2] = Alphabet[(x2 << 2) & 0x3C]; + result[dstInd + 3] = Special; + break; + } + + return new string(result); + } + + public override byte[] Decode(string data) + { + unchecked + { + if (string.IsNullOrEmpty(data)) + return new byte[0]; + + int lastSpecialInd = data.Length; + while (data[lastSpecialInd - 1] == Special) + lastSpecialInd--; + int tailLength = data.Length - lastSpecialInd; + + int resultLength = (data.Length + 3) / 4 * 3 - tailLength; + byte[] result = new byte[resultLength]; + + int length4 = (data.Length - tailLength) / 4; + if (!Parallel) + { + DecodeBlock(data, result, 0, length4); + } + else + { + int processorCount = Math.Min(length4, Environment.ProcessorCount); + System.Threading.Tasks.Parallel.For(0, processorCount, i => + { + int beginInd = i * length4 / processorCount; + int endInd = (i + 1) * length4 / processorCount; + DecodeBlock(data, result, beginInd, endInd); + }); + } + + int ind; + int x1, x2, x3; + int srcInd, dstInd; + switch (tailLength) + { + case 2: + ind = length4; + srcInd = ind * 4; + dstInd = ind * 3; + x1 = InvAlphabet[data[srcInd]]; + x2 = InvAlphabet[data[srcInd + 1]]; + result[dstInd] = (byte)((x1 << 2) | ((x2 >> 4) & 0x3)); + break; + case 1: + ind = length4; + srcInd = ind * 4; + dstInd = ind * 3; + x1 = InvAlphabet[data[srcInd]]; + x2 = InvAlphabet[data[srcInd + 1]]; + x3 = InvAlphabet[data[srcInd + 2]]; + result[dstInd] = (byte)((x1 << 2) | ((x2 >> 4) & 0x3)); + result[dstInd + 1] = (byte)((x2 << 4) | ((x3 >> 2) & 0xF)); + break; + } + + return result; + } + } + + private void EncodeBlock(byte[] src, char[] dst, int beginInd, int endInd) + { + for (int ind = beginInd; ind < endInd; ind++) + { + int srcInd = ind * 3; + int dstInd = ind * 4; + + byte x1 = src[srcInd]; + byte x2 = src[srcInd + 1]; + byte x3 = src[srcInd + 2]; + + dst[dstInd] = Alphabet[x1 >> 2]; + dst[dstInd + 1] = Alphabet[((x1 << 4) & 0x30) | (x2 >> 4)]; + dst[dstInd + 2] = Alphabet[((x2 << 2) & 0x3C) | (x3 >> 6)]; + dst[dstInd + 3] = Alphabet[x3 & 0x3F]; + } + } + + private void DecodeBlock(string src, byte[] dst, int beginInd, int endInd) + { + unchecked + { + for (int ind = beginInd; ind < endInd; ind++) + { + int srcInd = ind * 4; + int dstInd = ind * 3; + + int x1 = InvAlphabet[src[srcInd]]; + int x2 = InvAlphabet[src[srcInd + 1]]; + int x3 = InvAlphabet[src[srcInd + 2]]; + int x4 = InvAlphabet[src[srcInd + 3]]; + + dst[dstInd] = (byte)((x1 << 2) | ((x2 >> 4) & 0x3)); + dst[dstInd + 1] = (byte)((x2 << 4) | ((x3 >> 2) & 0xF)); + dst[dstInd + 2] = (byte)((x3 << 6) | (x4 & 0x3F)); + } + } + } + } +} diff --git a/Assets/Scripts/BaseNcoding/Base64.cs.meta b/Assets/Scripts/BaseNcoding/Base64.cs.meta new file mode 100644 index 0000000..a866f2e --- /dev/null +++ b/Assets/Scripts/BaseNcoding/Base64.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b591d6746a6fd9b45a0174c0c22d292b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/BaseNcoding/Base85.cs b/Assets/Scripts/BaseNcoding/Base85.cs new file mode 100644 index 0000000..ce385ae --- /dev/null +++ b/Assets/Scripts/BaseNcoding/Base85.cs @@ -0,0 +1,181 @@ +using System; +using System.IO; +using System.Text; + +namespace BaseNcoding +{ + public class Base85 : Base + { + public const string DefaultAlphabet = "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstu"; + public const char DefaultSpecial = (char)0; + private static readonly uint[] Pow85 = { 85 * 85 * 85 * 85, 85 * 85 * 85, 85 * 85, 85, 1 }; + + public const string Prefix = "<~"; + public const string Postfix = "~>"; + + public override bool HasSpecial => false; + + public bool PrefixPostfix { get; set; } + + public Base85(string alphabet = DefaultAlphabet, char special = DefaultSpecial, bool prefixPostfix = false, Encoding textEncoding = null) + : base(85, alphabet, special, textEncoding) + { + PrefixPostfix = prefixPostfix; + BlockBitsCount = 32; + BlockCharsCount = 5; + } + + public override string Encode(byte[] data) + { + unchecked + { + byte[] encodedBlock = new byte[5]; + int decodedBlockLength = 4; + int resultLength = data.Length * (encodedBlock.Length / decodedBlockLength); + if (PrefixPostfix) + resultLength += Prefix.Length + Postfix.Length; + char[] result = new char[resultLength]; + int resultInd = 0; + + if (PrefixPostfix) + CopyString(Prefix, result, ref resultInd); + + int count = 0; + uint tuple = 0; + foreach (byte b in data) + { + if (count >= decodedBlockLength - 1) + { + tuple |= b; + if (tuple == 0) + result[resultInd++] = 'z'; + else + EncodeBlock(encodedBlock.Length, result, ref resultInd, encodedBlock, tuple); + tuple = 0; + count = 0; + } + else + { + tuple |= (uint)(b << (24 - count * 8)); + count++; + } + } + + if (count > 0) + EncodeBlock(count + 1, result, ref resultInd, encodedBlock, tuple); + + if (PrefixPostfix) + CopyString(Postfix, result, ref resultInd); + + return new string(result); + } + } + + public override byte[] Decode(string data) + { + unchecked + { + string dataWithoutPrefixPostfix = data; + if (PrefixPostfix) + { + if (!dataWithoutPrefixPostfix.StartsWith(Prefix) || !dataWithoutPrefixPostfix.EndsWith(Postfix)) + { + throw new Exception("ASCII85 encoded data should begin with '" + Prefix + "' and end with '" + Postfix + "'"); + } + dataWithoutPrefixPostfix = dataWithoutPrefixPostfix.Substring(Prefix.Length, dataWithoutPrefixPostfix.Length - Prefix.Length - Postfix.Length); + } + + MemoryStream ms = new MemoryStream(); + int count = 0; + + uint tuple = 0; + int encodedBlockLength = 5; + byte[] decodedBlock = new byte[4]; + foreach (char c in dataWithoutPrefixPostfix) + { + bool processChar; + switch (c) + { + case 'z': + if (count != 0) + { + throw new Exception("The character 'z' is invalid inside an ASCII85 block."); + } + decodedBlock[0] = 0; + decodedBlock[1] = 0; + decodedBlock[2] = 0; + decodedBlock[3] = 0; + ms.Write(decodedBlock, 0, decodedBlock.Length); + processChar = false; + break; + default: + processChar = true; + break; + } + + if (processChar) + { + tuple += (uint)InvAlphabet[c] * Pow85[count]; + count++; + if (count == encodedBlockLength) + { + DecodeBlock(decodedBlock.Length, decodedBlock, tuple); + ms.Write(decodedBlock, 0, decodedBlock.Length); + tuple = 0; + count = 0; + } + } + } + + if (count != 0) + { + if (count == 1) + { + throw new Exception("The last block of ASCII85 data cannot be a single byte."); + } + count--; + tuple += Pow85[count]; + DecodeBlock(count, decodedBlock, tuple); + for (int i = 0; i < count; i++) + { + ms.WriteByte(decodedBlock[i]); + } + } + + return ms.ToArray(); + } + } + + private static void CopyString(string source, char[] dest, ref int destInd) + { + for (int i = 0; i < source.Length; i++) + dest[destInd++] = source[i]; + } + + private void EncodeBlock(int count, char[] result, ref int resultInd, byte[] encodedBlock, uint tuple) + { + unchecked + { + for (int i = encodedBlock.Length - 1; i >= 0; i--) + { + uint quotient = tuple % 85; + uint remainder = tuple - quotient * 85; + tuple = quotient; + encodedBlock[i] = (byte)remainder; + } + + for (int i = 0; i < count; i++) + result[resultInd++] = Alphabet[encodedBlock[i]]; + } + } + + private void DecodeBlock(int bytes, byte[] decodedBlock, uint tuple) + { + unchecked + { + for (int i = 0; i < bytes; i++) + decodedBlock[i] = (byte)(tuple >> 24 - i * 8); + } + } + } +} diff --git a/Assets/Scripts/BaseNcoding/Base85.cs.meta b/Assets/Scripts/BaseNcoding/Base85.cs.meta new file mode 100644 index 0000000..a3cfa13 --- /dev/null +++ b/Assets/Scripts/BaseNcoding/Base85.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bb00dc9d3e90a49439d967614c88ded8 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/BaseNcoding/Base91.cs b/Assets/Scripts/BaseNcoding/Base91.cs new file mode 100644 index 0000000..e1d1a8d --- /dev/null +++ b/Assets/Scripts/BaseNcoding/Base91.cs @@ -0,0 +1,99 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace BaseNcoding +{ + public class Base91 : Base + { + public const string DefaultAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&()*+,./:;<=>?@[]^_`{|}~\""; + public const char DefaultSpecial = (char)0; + + public override bool HasSpecial => false; + + public Base91(string alphabet = DefaultAlphabet, char special = DefaultSpecial, Encoding textEncoding = null) + : base(91, alphabet, special, textEncoding) + { + BlockBitsCount = 13; + BlockCharsCount = 2; + } + + public override string Encode(byte[] data) + { + StringBuilder result = new StringBuilder(data.Length); + + int ebq = 0, en = 0; + for (int i = 0; i < data.Length; ++i) + { + ebq |= (data[i] & 255) << en; + en += 8; + if (en > 13) + { + int ev = ebq & 8191; + + if (ev > 88) + { + ebq >>= 13; + en -= 13; + } + else + { + ev = ebq & 16383; + ebq >>= 14; + en -= 14; + } + + int quotient = Math.DivRem(ev, 91, out int remainder); + result.Append(Alphabet[remainder]); + result.Append(Alphabet[quotient]); + } + } + + if (en > 0) + { + int quotient = Math.DivRem(ebq, 91, out int remainder); + result.Append(Alphabet[remainder]); + if (en > 7 || ebq > 90) + result.Append(Alphabet[quotient]); + } + + return result.ToString(); + } + + public override byte[] Decode(string data) + { + unchecked + { + int dbq = 0, dn = 0, dv = -1; + + List result = new List(data.Length); + for (int i = 0; i < data.Length; ++i) + { + if (InvAlphabet[data[i]] == -1) + continue; + if (dv == -1) + dv = InvAlphabet[data[i]]; + else + { + dv += InvAlphabet[data[i]] * 91; + dbq |= dv << dn; + dn += (dv & 8191) > 88 ? 13 : 14; + do + { + result.Add((byte)dbq); + dbq >>= 8; + dn -= 8; + } + while (dn > 7); + dv = -1; + } + } + + if (dv != -1) + result.Add((byte)(dbq | dv << dn)); + + return result.ToArray(); + } + } + } +} diff --git a/Assets/Scripts/BaseNcoding/Base91.cs.meta b/Assets/Scripts/BaseNcoding/Base91.cs.meta new file mode 100644 index 0000000..b9ab053 --- /dev/null +++ b/Assets/Scripts/BaseNcoding/Base91.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 445180477b0318d48b58549426fd8ba9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/BaseNcoding/BaseBigN.cs b/Assets/Scripts/BaseNcoding/BaseBigN.cs new file mode 100644 index 0000000..a862647 --- /dev/null +++ b/Assets/Scripts/BaseNcoding/BaseBigN.cs @@ -0,0 +1,261 @@ +using System; +using System.Numerics; +using System.Text; + +namespace BaseNcoding +{ + public class BaseBigN : Base + { + private BigInteger[] _powN; + + public bool ReverseOrder { get; } + + public uint BlockMaxBitsCount { get; } + + public bool MaxCompression { get; } + + public override bool HasSpecial => false; + + public BaseBigN(string alphabet, uint blockMaxBitsCount = 64, + Encoding encoding = null, bool reverseOrder = false, bool parallel = false, + bool maxCompression = false) + : base((uint)alphabet.Length, alphabet, '\0', encoding, parallel) + { + BlockMaxBitsCount = blockMaxBitsCount; + BlockBitsCount = GetOptimalBitsCount(CharsCount, out var charsCountInBits, BlockMaxBitsCount, 2); + BlockCharsCount = (int)charsCountInBits; + + PreparePowN(BlockCharsCount); + + ReverseOrder = reverseOrder; + MaxCompression = maxCompression; + } + + public override string Encode(byte[] data) + { + if (data == null || data.Length == 0) + return ""; + + int blockBitsCount, blockCharsCount; + if (!MaxCompression) + { + blockBitsCount = BlockBitsCount; + blockCharsCount = BlockCharsCount; + } + else + { + blockBitsCount = data.Length * 8; + blockCharsCount = (int)Math.Ceiling(blockBitsCount * Math.Log(2, Alphabet.Length)); + PreparePowN(blockCharsCount); + } + + int data8 = data.Length * 8; + int mainBitsLength = data8 / blockBitsCount * blockBitsCount; + int tailBitsLength = data8 - mainBitsLength; + int mainCharsCount = mainBitsLength * blockCharsCount / blockBitsCount; + int tailCharsCount = (tailBitsLength * blockCharsCount + blockBitsCount - 1) / blockBitsCount; + int totalCharsCount = mainCharsCount + tailCharsCount; + int iterationCount = mainCharsCount / blockCharsCount; + + var result = new char[totalCharsCount]; + + if (!Parallel) + EncodeBlock(data, result, 0, iterationCount, blockBitsCount, blockCharsCount); + else + { + int processorCount = Math.Min(iterationCount, Environment.ProcessorCount); + System.Threading.Tasks.Parallel.For(0, processorCount, i => + { + int beginInd = i * iterationCount / processorCount; + int endInd = (i + 1) * iterationCount / processorCount; + EncodeBlock(data, result, beginInd, endInd, blockBitsCount, blockCharsCount); + }); + } + + if (tailBitsLength != 0) + { + BigInteger bits = GetBitsN(data, mainBitsLength, tailBitsLength); + BitsToChars(result, mainCharsCount, tailCharsCount, bits); + } + + return new string(result); + } + + public override byte[] Decode(string data) + { + if (string.IsNullOrEmpty(data)) + return new byte[0]; + + int blockBitsCount, blockCharsCount; + if (!MaxCompression) + { + blockBitsCount = BlockBitsCount; + blockCharsCount = BlockCharsCount; + } + else + { + blockCharsCount = data.Length; + blockBitsCount = (int)(blockCharsCount / Math.Log(2, Alphabet.Length)) / 8 * 8; + PreparePowN(blockCharsCount); + } + + int totalBitsLength = ((data.Length - 1) * blockBitsCount / blockCharsCount + 8) / 8 * 8; + int mainBitsLength = totalBitsLength / blockBitsCount * blockBitsCount; + int tailBitsLength = totalBitsLength - mainBitsLength; + int mainCharsCount = mainBitsLength * blockCharsCount / blockBitsCount; + int tailCharsCount = (tailBitsLength * blockCharsCount + blockBitsCount - 1) / blockBitsCount; + BigInteger tailBits = CharsToBits(data, mainCharsCount, tailCharsCount); + if (tailBits >> tailBitsLength != 0) + { + totalBitsLength += 8; + mainBitsLength = totalBitsLength / blockBitsCount * blockBitsCount; + tailBitsLength = totalBitsLength - mainBitsLength; + mainCharsCount = mainBitsLength * blockCharsCount / blockBitsCount; + tailCharsCount = (tailBitsLength * blockCharsCount + blockBitsCount - 1) / blockBitsCount; + } + int iterationCount = mainCharsCount / blockCharsCount; + + byte[] result = new byte[totalBitsLength / 8]; + + if (!Parallel) + { + DecodeBlock(data, result, 0, iterationCount, blockBitsCount, blockCharsCount); + } + else + { + int processorCount = Math.Min(iterationCount, Environment.ProcessorCount); + System.Threading.Tasks.Parallel.For(0, processorCount, i => + { + int beginInd = i * iterationCount / processorCount; + int endInd = (i + 1) * iterationCount / processorCount; + DecodeBlock(data, result, beginInd, endInd, blockBitsCount, blockCharsCount); + }); + } + + if (tailCharsCount != 0) + { + BigInteger bits = CharsToBits(data, mainCharsCount, tailCharsCount); + AddBitsN(result, bits, mainBitsLength, tailBitsLength); + } + + return result; + } + + private void EncodeBlock(byte[] src, char[] dst, int beginInd, int endInd, int blockBitsCount, int blockCharsCount) + { + for (int ind = beginInd; ind < endInd; ind++) + { + int charInd = ind * blockCharsCount; + int bitInd = ind * blockBitsCount; + BigInteger bits = GetBitsN(src, bitInd, blockBitsCount); + BitsToChars(dst, charInd, blockCharsCount, bits); + } + } + + private void DecodeBlock(string src, byte[] dst, int beginInd, int endInd, int blockBitsCount, int blockCharsCount) + { + for (int ind = beginInd; ind < endInd; ind++) + { + int charInd = ind * blockCharsCount; + int bitInd = ind * blockBitsCount; + BigInteger bits = CharsToBits(src, charInd, blockCharsCount); + AddBitsN(dst, bits, bitInd, blockBitsCount); + } + } + + private static BigInteger GetBitsN(byte[] data, int bitPos, int bitsCount) + { + BigInteger result = 0; + + int currentBytePos = Math.DivRem(bitPos, 8, out int currentBitInBytePos); + int shift = 8 - currentBitInBytePos; + int xLength = Math.Min(bitsCount, shift); + if (xLength != 0) + { + result = new BigInteger((data[currentBytePos] >> shift - xLength) & ((1 << shift) - 1)) << bitsCount - xLength; + + currentBytePos += Math.DivRem(currentBitInBytePos + xLength, 8, out currentBitInBytePos); + + int x2Length = bitsCount - xLength; + if (x2Length > 8) + x2Length = 8; + + while (x2Length > 0) + { + xLength += x2Length; + result |= (BigInteger)(data[currentBytePos] >> 8 - x2Length) << bitsCount - xLength; + + currentBytePos += Math.DivRem(currentBitInBytePos + x2Length, 8, out currentBitInBytePos); + + x2Length = bitsCount - xLength; + if (x2Length > 8) + x2Length = 8; + } + } + + return result; + } + + private static void AddBitsN(byte[] data, BigInteger value, int bitPos, int bitsCount) + { + int currentBytePos = Math.DivRem(bitPos, 8, out int currentBitInBytePos); + + int shift = 8 - currentBitInBytePos; + int xLength = Math.Min(bitsCount, shift); + if (xLength != 0) + { + data[currentBytePos] |= (byte) ((byte) (value >> bitsCount - shift) & ((1 << shift) - 1)); + + currentBytePos += Math.DivRem(currentBitInBytePos + xLength, 8, out currentBitInBytePos); + + int x2Length = bitsCount - xLength; + if (x2Length > 8) + x2Length = 8; + + while (x2Length > 0) + { + xLength += x2Length; + var bitsCountMinusXLength = bitsCount - xLength; + data[currentBytePos] |= (byte)((value >> (bitsCountMinusXLength - 8 + x2Length)) & 0xFF); + + currentBytePos += Math.DivRem(currentBitInBytePos + x2Length, 8, out currentBitInBytePos); + + x2Length = bitsCountMinusXLength; + if (x2Length > 8) + x2Length = 8; + } + } + } + + private void BitsToChars(char[] chars, int ind, int count, BigInteger block) + { + BigInteger quotient = block; + for (int i = 0; i < count; i++) + { + quotient = BigInteger.DivRem(quotient, CharsCount, out BigInteger remainder); + chars[ind + (!ReverseOrder ? i : count - 1 - i)] = Alphabet[(int)remainder]; + } + } + + private BigInteger CharsToBits(string data, int ind, int count) + { + BigInteger result = 0; + for (int i = 0; i < count; i++) + result += InvAlphabet[data[ind + (!ReverseOrder ? i : count - 1 - i)]] * _powN[_powN.Length - 1 - i]; + return result; + } + + private void PreparePowN(int blockCharsCount) + { + _powN = new BigInteger[blockCharsCount]; + BigInteger pow = 1; + for (int i = 0; i < blockCharsCount - 1; i++) + { + _powN[blockCharsCount - 1 - i] = pow; + pow *= CharsCount; + } + if (blockCharsCount > 0) + _powN[0] = pow; + } + } +} diff --git a/Assets/Scripts/BaseNcoding/BaseBigN.cs.meta b/Assets/Scripts/BaseNcoding/BaseBigN.cs.meta new file mode 100644 index 0000000..e383bc8 --- /dev/null +++ b/Assets/Scripts/BaseNcoding/BaseBigN.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0a06acee1a2bf3d4aae0b2a2b83cb5d4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/BaseNcoding/BaseN.cs b/Assets/Scripts/BaseNcoding/BaseN.cs new file mode 100644 index 0000000..6a1c011 --- /dev/null +++ b/Assets/Scripts/BaseNcoding/BaseN.cs @@ -0,0 +1,228 @@ +using System; +using System.Text; + +namespace BaseNcoding +{ + public class BaseN : Base + { + private readonly ulong[] _powN; + + public uint BlockMaxBitsCount { get; } + + public override bool HasSpecial => false; + + public bool ReverseOrder { get; } + + public BaseN(string alphabet, uint blockMaxBitsCount = 32, + Encoding encoding = null, bool reverseOrder = false, bool parallel = false) + : base((uint)alphabet.Length, alphabet, '\0', encoding, parallel) + { + BlockMaxBitsCount = blockMaxBitsCount; + BlockBitsCount = GetOptimalBitsCount(CharsCount, out var charsCountInBits, blockMaxBitsCount); + BlockCharsCount = (int)charsCountInBits; + _powN = new ulong[BlockCharsCount]; + ulong pow = 1; + for (int i = 0; i < BlockCharsCount - 1; i++) + { + _powN[BlockCharsCount - 1 - i] = pow; + pow *= CharsCount; + } + _powN[0] = pow; + ReverseOrder = reverseOrder; + } + + public override string Encode(byte[] data) + { + if (data == null || data.Length == 0) + return ""; + + int mainBitsLength = data.Length * 8 / BlockBitsCount * BlockBitsCount; + int tailBitsLength = data.Length * 8 - mainBitsLength; + int mainCharsCount = mainBitsLength * BlockCharsCount / BlockBitsCount; + int tailCharsCount = (tailBitsLength * BlockCharsCount + BlockBitsCount - 1) / BlockBitsCount; + int totalCharsCount = mainCharsCount + tailCharsCount; + int iterationCount = mainCharsCount / BlockCharsCount; + + var result = new char[totalCharsCount]; + + if (!Parallel) + { + EncodeBlock(data, result, 0, iterationCount); + } + else + { + int processorCount = Math.Min(iterationCount, Environment.ProcessorCount); + System.Threading.Tasks.Parallel.For(0, processorCount, i => + { + int beginInd = i * iterationCount / processorCount; + int endInd = (i + 1) * iterationCount / processorCount; + EncodeBlock(data, result, beginInd, endInd); + }); + } + + if (tailBitsLength != 0) + { + ulong bits = GetBits64(data, mainBitsLength, tailBitsLength); + BitsToChars(result, mainCharsCount, tailCharsCount, bits); + } + + return new string(result); + } + + public override byte[] Decode(string data) + { + if (string.IsNullOrEmpty(data)) + return new byte[0]; + + int totalBitsLength = ((data.Length - 1) * BlockBitsCount / BlockCharsCount + 8) / 8 * 8; + int mainBitsLength = totalBitsLength / BlockBitsCount * BlockBitsCount; + int tailBitsLength = totalBitsLength - mainBitsLength; + int mainCharsCount = mainBitsLength * BlockCharsCount / BlockBitsCount; + int tailCharsCount = (tailBitsLength * BlockCharsCount + BlockBitsCount - 1) / BlockBitsCount; + ulong tailBits = CharsToBits(data, mainCharsCount, tailCharsCount); + if (tailBits >> tailBitsLength != 0) + { + totalBitsLength += 8; + mainBitsLength = totalBitsLength / BlockBitsCount * BlockBitsCount; + tailBitsLength = totalBitsLength - mainBitsLength; + mainCharsCount = mainBitsLength * BlockCharsCount / BlockBitsCount; + tailCharsCount = (tailBitsLength * BlockCharsCount + BlockBitsCount - 1) / BlockBitsCount; + } + int iterationCount = mainCharsCount / BlockCharsCount; + + byte[] result = new byte[totalBitsLength / 8]; + + if (!Parallel) + { + DecodeBlock(data, result, 0, iterationCount); + } + else + { + int processorCount = Math.Min(iterationCount, Environment.ProcessorCount); + System.Threading.Tasks.Parallel.For(0, processorCount, i => + { + int beginInd = i * iterationCount / processorCount; + int endInd = (i + 1) * iterationCount / processorCount; + DecodeBlock(data, result, beginInd, endInd); + }); + } + + if (tailCharsCount != 0) + { + ulong bits = CharsToBits(data, mainCharsCount, tailCharsCount); + AddBits64(result, bits, mainBitsLength, tailBitsLength); + } + + return result; + } + + private void EncodeBlock(byte[] src, char[] dst, int beginInd, int endInd) + { + for (int ind = beginInd; ind < endInd; ind++) + { + int charInd = ind * BlockCharsCount; + int bitInd = ind * BlockBitsCount; + ulong bits = GetBits64(src, bitInd, BlockBitsCount); + BitsToChars(dst, charInd, BlockCharsCount, bits); + } + } + + private void DecodeBlock(string src, byte[] dst, int beginInd, int endInd) + { + for (int ind = beginInd; ind < endInd; ind++) + { + int charInd = ind * BlockCharsCount; + int bitInd = ind * BlockBitsCount; + ulong bits = CharsToBits(src, charInd, BlockCharsCount); + AddBits64(dst, bits, bitInd, BlockBitsCount); + } + } + + private static ulong GetBits64(byte[] data, int bitPos, int bitsCount) + { + ulong result = 0; + + int currentBytePos = Math.DivRem(bitPos, 8, out int currentBitInBytePos); + + int xLength = Math.Min(bitsCount, 8 - currentBitInBytePos); + if (xLength != 0) + { + result = ((ulong)data[currentBytePos] << 56 + currentBitInBytePos) >> 64 - xLength << bitsCount - xLength; + + currentBytePos += Math.DivRem(currentBitInBytePos + xLength, 8, out currentBitInBytePos); + + int x2Length = bitsCount - xLength; + if (x2Length > 8) + x2Length = 8; + + while (x2Length > 0) + { + xLength += x2Length; + result |= (ulong)data[currentBytePos] >> 8 - x2Length << bitsCount - xLength; + + currentBytePos += Math.DivRem(currentBitInBytePos + x2Length, 8, out currentBitInBytePos); + + x2Length = bitsCount - xLength; + if (x2Length > 8) + x2Length = 8; + } + } + + return result; + } + + private static void AddBits64(byte[] data, ulong value, int bitPos, int bitsCount) + { + unchecked + { + int currentBytePos = Math.DivRem(bitPos, 8, out int currentBitInBytePos); + + int xLength = Math.Min(bitsCount, 8 - currentBitInBytePos); + if (xLength != 0) + { + byte x1 = (byte)(value << 64 - bitsCount >> 56 + currentBitInBytePos); + data[currentBytePos] |= x1; + + currentBytePos += Math.DivRem(currentBitInBytePos + xLength, 8, out currentBitInBytePos); + + int x2Length = bitsCount - xLength; + if (x2Length > 8) + x2Length = 8; + + while (x2Length > 0) + { + xLength += x2Length; + byte x2 = (byte)(value >> bitsCount - xLength << 8 - x2Length); + data[currentBytePos] |= x2; + + currentBytePos += Math.DivRem(currentBitInBytePos + x2Length, 8, out currentBitInBytePos); + + x2Length = bitsCount - xLength; + if (x2Length > 8) + x2Length = 8; + } + } + } + } + + private void BitsToChars(char[] chars, int ind, int count, ulong block) + { + ulong result = block; + for (int i = 0; i < count; i++) + { + ulong quotient = result / CharsCount; + ulong remainder = result - quotient * CharsCount; + result = quotient; + chars[ind + (!ReverseOrder ? i : count - 1 - i)] = Alphabet[(int)remainder]; + } + } + + private ulong CharsToBits(string data, int ind, int count) + { + ulong result = 0; + for (int i = 0; i < count; i++) + result += (ulong)InvAlphabet[data[ind + (!ReverseOrder ? i : count - 1 - i)]] * _powN[BlockCharsCount - 1 - i]; + return result; + } + } +} diff --git a/Assets/Scripts/BaseNcoding/BaseN.cs.meta b/Assets/Scripts/BaseNcoding/BaseN.cs.meta new file mode 100644 index 0000000..4b0cada --- /dev/null +++ b/Assets/Scripts/BaseNcoding/BaseN.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8d996e73fb18bfd45be33725dcf13786 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/BaseNcoding/StringGenerator.cs b/Assets/Scripts/BaseNcoding/StringGenerator.cs new file mode 100644 index 0000000..339a396 --- /dev/null +++ b/Assets/Scripts/BaseNcoding/StringGenerator.cs @@ -0,0 +1,48 @@ +using System; +using System.Text; + +namespace BaseNcoding +{ + public static class StringGenerator + { + private const string LettersAndDigits = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; + + public static string GetAlphabet(int charsCount) + { + var result = new StringBuilder(charsCount); + int i = 0; + int count = 0; + do + { + char c = (char)i; + if (!char.IsControl(c) && !char.IsWhiteSpace(c)) + { + result.Append(c); + count++; + } + i++; + } + while (count < charsCount); + + return result.ToString(); + } + + public static string GetRandom(int size, bool onlyLettersAndDigits) + { + Random r = new Random(); + if (onlyLettersAndDigits) + { + var result = new char[size]; + for (int i = 0; i < size; i++) + result[i] = LettersAndDigits[r.Next(LettersAndDigits.Length)]; + return new string(result); + } + + var data = new byte[size]; + for (int i = 0; i < size; i++) + data[i] = (byte) r.Next(32, 127); + var encoding = new ASCIIEncoding(); + return encoding.GetString(data); + } + } +} diff --git a/Assets/Scripts/BaseNcoding/StringGenerator.cs.meta b/Assets/Scripts/BaseNcoding/StringGenerator.cs.meta new file mode 100644 index 0000000..df242cc --- /dev/null +++ b/Assets/Scripts/BaseNcoding/StringGenerator.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b72d6d0bcd1a9e846ad04cc26014bbcd +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/LZ4.meta b/Assets/Scripts/LZ4.meta new file mode 100644 index 0000000..50baab7 --- /dev/null +++ b/Assets/Scripts/LZ4.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: dbb2fcf97a52a74408ada473a663544b +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe.cs b/Assets/Scripts/LZ4/LZ4Codec.Safe.cs new file mode 100644 index 0000000..7b55e92 --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Codec.Safe.cs @@ -0,0 +1,757 @@ +#region license + +/* +Copyright (c) 2013, Milosz Krajewski +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided +that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this list of conditions + and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this list of conditions + and the following disclaimer in the documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#endregion + +using System; +using System.Diagnostics; + +// ReSharper disable CheckNamespace +// ReSharper disable InconsistentNaming + +namespace LZ4ps +{ + /// Safe LZ4 codec. + public static partial class LZ4Codec + { + #region Helper + + // ReSharper disable UnusedParameter.Local + + [Conditional("DEBUG")] + private static void Assert(bool condition, string errorMessage) + { + if (!condition) throw new ArgumentException(errorMessage); + Debug.Assert(condition, errorMessage); + } + + // ReSharper restore UnusedParameter.Local + + #endregion + + #region Byte manipulation + + // ReSharper disable RedundantCast + + internal static void Poke2(byte[] buffer, int offset, ushort value) + { + buffer[offset] = (byte)value; + buffer[offset + 1] = (byte)(value >> 8); + } + + internal static ushort Peek2(byte[] buffer, int offset) + { + // NOTE: It's faster than BitConverter.ToUInt16 (suprised? me too) + return (ushort)(((uint)buffer[offset]) | ((uint)buffer[offset + 1] << 8)); + } + + internal static uint Peek4(byte[] buffer, int offset) + { + // NOTE: It's faster than BitConverter.ToUInt32 (suprised? me too) + return + ((uint)buffer[offset]) | + ((uint)buffer[offset + 1] << 8) | + ((uint)buffer[offset + 2] << 16) | + ((uint)buffer[offset + 3] << 24); + } + + private static uint Xor4(byte[] buffer, int offset1, int offset2) + { + // return Peek4(buffer, offset1) ^ Peek4(buffer, offset2); + var value1 = + ((uint)buffer[offset1]) | + ((uint)buffer[offset1 + 1] << 8) | + ((uint)buffer[offset1 + 2] << 16) | + ((uint)buffer[offset1 + 3] << 24); + var value2 = + ((uint)buffer[offset2]) | + ((uint)buffer[offset2 + 1] << 8) | + ((uint)buffer[offset2 + 2] << 16) | + ((uint)buffer[offset2 + 3] << 24); + return value1 ^ value2; + } + + private static ulong Xor8(byte[] buffer, int offset1, int offset2) + { + // return Peek8(buffer, offset1) ^ Peek8(buffer, offset2); + var value1 = + ((ulong)buffer[offset1]) | + ((ulong)buffer[offset1 + 1] << 8) | + ((ulong)buffer[offset1 + 2] << 16) | + ((ulong)buffer[offset1 + 3] << 24) | + ((ulong)buffer[offset1 + 4] << 32) | + ((ulong)buffer[offset1 + 5] << 40) | + ((ulong)buffer[offset1 + 6] << 48) | + ((ulong)buffer[offset1 + 7] << 56); + var value2 = + ((ulong)buffer[offset2]) | + ((ulong)buffer[offset2 + 1] << 8) | + ((ulong)buffer[offset2 + 2] << 16) | + ((ulong)buffer[offset2 + 3] << 24) | + ((ulong)buffer[offset2 + 4] << 32) | + ((ulong)buffer[offset2 + 5] << 40) | + ((ulong)buffer[offset2 + 6] << 48) | + ((ulong)buffer[offset2 + 7] << 56); + return value1 ^ value2; + } + + private static bool Equal2(byte[] buffer, int offset1, int offset2) + { + // return Peek2(buffer, offset1) == Peek2(buffer, offset2); + if (buffer[offset1] != buffer[offset2]) return false; + return buffer[offset1 + 1] == buffer[offset2 + 1]; + } + + private static bool Equal4(byte[] buffer, int offset1, int offset2) + { + // return Peek4(buffer, offset1) == Peek4(buffer, offset2); + if (buffer[offset1] != buffer[offset2]) return false; + if (buffer[offset1 + 1] != buffer[offset2 + 1]) return false; + if (buffer[offset1 + 2] != buffer[offset2 + 2]) return false; + return buffer[offset1 + 3] == buffer[offset2 + 3]; + } + + // ReSharper restore RedundantCast + + #endregion + + #region Byte block copy + + private static void Copy4(byte[] buf, int src, int dst) + { + Assert(dst > src, "Copying backwards is not implemented"); + buf[dst + 3] = buf[src + 3]; + buf[dst + 2] = buf[src + 2]; + buf[dst + 1] = buf[src + 1]; + buf[dst] = buf[src]; + } + + private static void Copy8(byte[] buf, int src, int dst) + { + Assert(dst > src, "Copying backwards is not implemented"); + buf[dst + 7] = buf[src + 7]; + buf[dst + 6] = buf[src + 6]; + buf[dst + 5] = buf[src + 5]; + buf[dst + 4] = buf[src + 4]; + buf[dst + 3] = buf[src + 3]; + buf[dst + 2] = buf[src + 2]; + buf[dst + 1] = buf[src + 1]; + buf[dst] = buf[src]; + } + + private static void BlockCopy(byte[] src, int src_0, byte[] dst, int dst_0, int len) + { + Assert(src != dst, "BlockCopy does not handle copying to the same buffer"); + + if (len >= BLOCK_COPY_LIMIT) + { + Buffer.BlockCopy(src, src_0, dst, dst_0, len); + } + else + { + while (len >= 8) + { + dst[dst_0] = src[src_0]; + dst[dst_0 + 1] = src[src_0 + 1]; + dst[dst_0 + 2] = src[src_0 + 2]; + dst[dst_0 + 3] = src[src_0 + 3]; + dst[dst_0 + 4] = src[src_0 + 4]; + dst[dst_0 + 5] = src[src_0 + 5]; + dst[dst_0 + 6] = src[src_0 + 6]; + dst[dst_0 + 7] = src[src_0 + 7]; + len -= 8; + src_0 += 8; + dst_0 += 8; + } + + while (len >= 4) + { + dst[dst_0] = src[src_0]; + dst[dst_0 + 1] = src[src_0 + 1]; + dst[dst_0 + 2] = src[src_0 + 2]; + dst[dst_0 + 3] = src[src_0 + 3]; + len -= 4; + src_0 += 4; + dst_0 += 4; + } + + while (len-- > 0) + { + dst[dst_0++] = src[src_0++]; + } + } + } + + private static int WildCopy(byte[] src, int src_0, byte[] dst, int dst_0, int dst_end) + { + var len = dst_end - dst_0; + + Assert(src != dst, "BlockCopy does not handle copying to the same buffer"); + Assert(len > 0, "Length have to be greater than 0"); + + if (len >= BLOCK_COPY_LIMIT) + { + Buffer.BlockCopy(src, src_0, dst, dst_0, len); + } + else + { + // apparently (tested) this is an overkill + // it seems to be faster without this 8-byte loop + //while (len >= 8) + //{ + // dst[dst_0] = src[src_0]; + // dst[dst_0 + 1] = src[src_0 + 1]; + // dst[dst_0 + 2] = src[src_0 + 2]; + // dst[dst_0 + 3] = src[src_0 + 3]; + // dst[dst_0 + 4] = src[src_0 + 4]; + // dst[dst_0 + 5] = src[src_0 + 5]; + // dst[dst_0 + 6] = src[src_0 + 6]; + // dst[dst_0 + 7] = src[src_0 + 7]; + // len -= 8; src_0 += 8; dst_0 += 8; + //} + + while (len >= 4) + { + dst[dst_0] = src[src_0]; + dst[dst_0 + 1] = src[src_0 + 1]; + dst[dst_0 + 2] = src[src_0 + 2]; + dst[dst_0 + 3] = src[src_0 + 3]; + len -= 4; + src_0 += 4; + dst_0 += 4; + } + + while (len-- > 0) + { + dst[dst_0++] = src[src_0++]; + } + } + + return len; + } + + private static int SecureCopy(byte[] buffer, int src, int dst, int dst_end) + { + var diff = dst - src; + var length = dst_end - dst; + var len = length; + + Assert(diff >= 4, "Target must be at least 4 bytes further than source"); + Assert(BLOCK_COPY_LIMIT > 4, "This method requires BLOCK_COPY_LIMIT > 4"); + Assert(len > 0, "Length have to be greater than 0"); + + if (diff >= BLOCK_COPY_LIMIT) + { + if (diff >= length) + { + Buffer.BlockCopy(buffer, src, buffer, dst, length); + return length; // done + } + + do + { + Buffer.BlockCopy(buffer, src, buffer, dst, diff); + src += diff; + dst += diff; + len -= diff; + } while (len >= diff); + } + + // apparently (tested) this is an overkill + // it seems to be faster without this 8-byte loop + //while (len >= 8) + //{ + // buffer[dst] = buffer[src]; + // buffer[dst + 1] = buffer[src + 1]; + // buffer[dst + 2] = buffer[src + 2]; + // buffer[dst + 3] = buffer[src + 3]; + // buffer[dst + 4] = buffer[src + 4]; + // buffer[dst + 5] = buffer[src + 5]; + // buffer[dst + 6] = buffer[src + 6]; + // buffer[dst + 7] = buffer[src + 7]; + // dst += 8; src += 8; len -= 8; + //} + + while (len >= 4) + { + buffer[dst] = buffer[src]; + buffer[dst + 1] = buffer[src + 1]; + buffer[dst + 2] = buffer[src + 2]; + buffer[dst + 3] = buffer[src + 3]; + dst += 4; + src += 4; + len -= 4; + } + + while (len-- > 0) + { + buffer[dst++] = buffer[src++]; + } + + return length; // done + } + + #endregion + + #region Encode32 + + /// Encodes the specified input. + /// The input. + /// The input offset. + /// Length of the input. + /// The output. + /// The output offset. + /// Length of the output. + /// Number of bytes written. + public static int Encode32( + byte[] input, + int inputOffset, + int inputLength, + byte[] output, + int outputOffset, + int outputLength) + { + CheckArguments( + input, inputOffset, ref inputLength, + output, outputOffset, ref outputLength); + if (outputLength == 0) return 0; + + if (inputLength < LZ4_64KLIMIT) + { + var hashTable = new ushort[HASH64K_TABLESIZE]; + return LZ4_compress64kCtx_safe32(hashTable, input, output, inputOffset, outputOffset, inputLength, outputLength); + } + else + { + var hashTable = new int[HASH_TABLESIZE]; + return LZ4_compressCtx_safe32(hashTable, input, output, inputOffset, outputOffset, inputLength, outputLength); + } + } + + /// Encodes the specified input. + /// The input. + /// The input offset. + /// Length of the input. + /// Compressed buffer. + public static byte[] Encode32(byte[] input, int inputOffset, int inputLength) + { + if (inputLength < 0) inputLength = input.Length - inputOffset; + + if (input == null) throw new ArgumentNullException("input"); + if (inputOffset < 0 || inputOffset + inputLength > input.Length) + throw new ArgumentException("inputOffset and inputLength are invalid for given input"); + + var result = new byte[MaximumOutputLength(inputLength)]; + var length = Encode32(input, inputOffset, inputLength, result, 0, result.Length); + + if (length != result.Length) + { + if (length < 0) + throw new InvalidOperationException("Compression has been corrupted"); + var buffer = new byte[length]; + Buffer.BlockCopy(result, 0, buffer, 0, length); + return buffer; + } + return result; + } + + #endregion + + #region Encode64 + + /// Encodes the specified input. + /// The input. + /// The input offset. + /// Length of the input. + /// The output. + /// The output offset. + /// Length of the output. + /// Number of bytes written. + public static int Encode64( + byte[] input, + int inputOffset, + int inputLength, + byte[] output, + int outputOffset, + int outputLength) + { + CheckArguments( + input, inputOffset, ref inputLength, + output, outputOffset, ref outputLength); + if (outputLength == 0) return 0; + + if (inputLength < LZ4_64KLIMIT) + { + var hashTable = new ushort[HASH64K_TABLESIZE]; + return LZ4_compress64kCtx_safe64(hashTable, input, output, inputOffset, outputOffset, inputLength, outputLength); + } + else + { + var hashTable = new int[HASH_TABLESIZE]; + return LZ4_compressCtx_safe64(hashTable, input, output, inputOffset, outputOffset, inputLength, outputLength); + } + } + + /// Encodes the specified input. + /// The input. + /// The input offset. + /// Length of the input. + /// Compressed buffer. + public static byte[] Encode64(byte[] input, int inputOffset, int inputLength) + { + if (inputLength < 0) inputLength = input.Length - inputOffset; + + if (input == null) throw new ArgumentNullException("input"); + if (inputOffset < 0 || inputOffset + inputLength > input.Length) + throw new ArgumentException("inputOffset and inputLength are invalid for given input"); + + var result = new byte[MaximumOutputLength(inputLength)]; + var length = Encode64(input, inputOffset, inputLength, result, 0, result.Length); + + if (length != result.Length) + { + if (length < 0) + throw new InvalidOperationException("Compression has been corrupted"); + var buffer = new byte[length]; + Buffer.BlockCopy(result, 0, buffer, 0, length); + return buffer; + } + return result; + } + + #endregion + + #region Decode32 + + /// Decodes the specified input. + /// The input. + /// The input offset. + /// Length of the input. + /// The output. + /// The output offset. + /// Length of the output. + /// Set it to true if output length is known. + /// Number of bytes written. + public static int Decode32( + byte[] input, + int inputOffset, + int inputLength, + byte[] output, + int outputOffset, + int outputLength, + bool knownOutputLength) + { + CheckArguments( + input, inputOffset, ref inputLength, + output, outputOffset, ref outputLength); + + if (outputLength == 0) return 0; + + if (knownOutputLength) + { + var length = LZ4_uncompress_safe32(input, output, inputOffset, outputOffset, outputLength); + if (length != inputLength) + throw new ArgumentException("LZ4 block is corrupted, or invalid length has been given."); + return outputLength; + } + else + { + var length = LZ4_uncompress_unknownOutputSize_safe32(input, output, inputOffset, outputOffset, inputLength, outputLength); + if (length < 0) + throw new ArgumentException("LZ4 block is corrupted, or invalid length has been given."); + return length; + } + } + + /// Decodes the specified input. + /// The input. + /// The input offset. + /// Length of the input. + /// Length of the output. + /// Decompressed buffer. + public static byte[] Decode32(byte[] input, int inputOffset, int inputLength, int outputLength) + { + if (inputLength < 0) inputLength = input.Length - inputOffset; + + if (input == null) throw new ArgumentNullException("input"); + if (inputOffset < 0 || inputOffset + inputLength > input.Length) + throw new ArgumentException("inputOffset and inputLength are invalid for given input"); + + var result = new byte[outputLength]; + var length = Decode32(input, inputOffset, inputLength, result, 0, outputLength, true); + if (length != outputLength) + throw new ArgumentException("outputLength is not valid"); + return result; + } + + #endregion + + #region Decode64 + + /// Decodes the specified input. + /// The input. + /// The input offset. + /// Length of the input. + /// The output. + /// The output offset. + /// Length of the output. + /// Set it to true if output length is known. + /// Number of bytes written. + public static int Decode64( + byte[] input, + int inputOffset, + int inputLength, + byte[] output, + int outputOffset, + int outputLength, + bool knownOutputLength) + { + CheckArguments( + input, inputOffset, ref inputLength, + output, outputOffset, ref outputLength); + + if (outputLength == 0) return 0; + + if (knownOutputLength) + { + var length = LZ4_uncompress_safe64(input, output, inputOffset, outputOffset, outputLength); + if (length != inputLength) + throw new ArgumentException("LZ4 block is corrupted, or invalid length has been given."); + return outputLength; + } + else + { + var length = LZ4_uncompress_unknownOutputSize_safe64(input, output, inputOffset, outputOffset, inputLength, outputLength); + if (length < 0) + throw new ArgumentException("LZ4 block is corrupted, or invalid length has been given."); + return length; + } + } + + /// Decodes the specified input. + /// The input. + /// The input offset. + /// Length of the input. + /// Length of the output. + /// Decompressed buffer. + public static byte[] Decode64(byte[] input, int inputOffset, int inputLength, int outputLength) + { + if (inputLength < 0) inputLength = input.Length - inputOffset; + + if (input == null) throw new ArgumentNullException("input"); + if (inputOffset < 0 || inputOffset + inputLength > input.Length) + throw new ArgumentException("inputOffset and inputLength are invalid for given input"); + + var result = new byte[outputLength]; + var length = Decode64(input, inputOffset, inputLength, result, 0, outputLength, true); + if (length != outputLength) + throw new ArgumentException("outputLength is not valid"); + return result; + } + + #endregion + + #region HC utilities + + // ReSharper disable InconsistentNaming + + private class LZ4HC_Data_Structure + { + public byte[] src; + public int src_base; + public int src_end; + public int src_LASTLITERALS; + public byte[] dst; + public int dst_base; + public int dst_len; + public int dst_end; + public int[] hashTable; + public ushort[] chainTable; + public int nextToUpdate; + }; + + // ReSharper restore InconsistentNaming + + + private static LZ4HC_Data_Structure LZ4HC_Create(byte[] src, int src_0, int src_len, byte[] dst, int dst_0, int dst_len) + { + var hc4 = new LZ4HC_Data_Structure { + src = src, + src_base = src_0, + src_end = src_0 + src_len, + src_LASTLITERALS = (src_0 + src_len - LASTLITERALS), + dst = dst, + dst_base = dst_0, + dst_len = dst_len, + dst_end = dst_0 + dst_len, + hashTable = new int[HASHHC_TABLESIZE], + chainTable = new ushort[MAXD], + nextToUpdate = src_0 + 1, + }; + + var ct = hc4.chainTable; + for (var i = ct.Length - 1; i >= 0; i--) ct[i] = unchecked((ushort)-1); + + return hc4; + } + + #endregion + + #region Encode32HC + + private static int LZ4_compressHC_32( + byte[] input, int inputOffset, int inputLength, + byte[] output, int outputOffset, int outputLength) + { + return LZ4_compressHCCtx_32( + LZ4HC_Create( + input, inputOffset, inputLength, output, outputOffset, outputLength)); + } + + /// Encodes the specified input using HC codec. + /// The input. + /// The input offset. + /// Length of the input. + /// The output. + /// The output offset. + /// Length of the output. + /// Number of bytes written. NOTE: when output buffer is too small it returns negative value. + public static int Encode32HC( + byte[] input, + int inputOffset, + int inputLength, + byte[] output, + int outputOffset, + int outputLength) + { + if (inputLength == 0) return 0; + + CheckArguments( + input, inputOffset, ref inputLength, + output, outputOffset, ref outputLength); + + var length = LZ4_compressHC_32(input, inputOffset, inputLength, output, outputOffset, outputLength); + // NOTE: there is a potential problem here as original implementation returns 0 not -1 + return length <= 0 ? -1 : length; + } + + /// Encodes the specified input using HC codec. + /// The input. + /// The input offset. + /// Length of the input. + /// Buffer with compressed data (NOTE: it can be bigger than input). + public static byte[] Encode32HC( + byte[] input, int inputOffset, int inputLength) + { + if (inputLength == 0) return new byte[0]; + var outputLength = MaximumOutputLength(inputLength); + var result = new byte[outputLength]; + var length = Encode32HC(input, inputOffset, inputLength, result, 0, outputLength); + + if (length < 0) + throw new ArgumentException("Provided data seems to be corrupted."); + + if (length != outputLength) + { + var buffer = new byte[length]; + Buffer.BlockCopy(result, 0, buffer, 0, length); + result = buffer; + } + + return result; + } + + #endregion + + #region Encode64HC + + private static int LZ4_compressHC_64( + byte[] input, int inputOffset, int inputLength, + byte[] output, int outputOffset, int outputLength) + { + return LZ4_compressHCCtx_64( + LZ4HC_Create( + input, inputOffset, inputLength, output, outputOffset, outputLength)); + } + + /// Encodes the specified input using HC codec. + /// The input. + /// The input offset. + /// Length of the input. + /// The output. + /// The output offset. + /// Length of the output. + /// Number of bytes written. NOTE: when output buffer is too small it returns negative value. + public static int Encode64HC( + byte[] input, + int inputOffset, + int inputLength, + byte[] output, + int outputOffset, + int outputLength) + { + if (inputLength == 0) return 0; + + CheckArguments( + input, inputOffset, ref inputLength, + output, outputOffset, ref outputLength); + + var length = LZ4_compressHC_64(input, inputOffset, inputLength, output, outputOffset, outputLength); + // NOTE: there is a potential problem here as original implementation returns 0 not -1 + return length <= 0 ? -1 : length; + } + + /// Encodes the specified input using HC codec. + /// The input. + /// The input offset. + /// Length of the input. + /// Buffer with compressed data (NOTE: it can be bigger than input). + public static byte[] Encode64HC( + byte[] input, int inputOffset, int inputLength) + { + if (inputLength == 0) return new byte[0]; + var outputLength = MaximumOutputLength(inputLength); + var result = new byte[outputLength]; + var length = Encode64HC(input, inputOffset, inputLength, result, 0, outputLength); + + if (length < 0) + throw new ArgumentException("Provided data seems to be corrupted."); + + if (length != outputLength) + { + var buffer = new byte[length]; + Buffer.BlockCopy(result, 0, buffer, 0, length); + result = buffer; + } + + return result; + } + + #endregion + } +} + +// ReSharper restore InconsistentNaming +// ReSharper restore CheckNamespace diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe.cs.meta b/Assets/Scripts/LZ4/LZ4Codec.Safe.cs.meta new file mode 100644 index 0000000..c5fc009 --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Codec.Safe.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a2f5d2c7e152d8f43ab710530107c9ff +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs b/Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs new file mode 100644 index 0000000..85e7c49 --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs @@ -0,0 +1,795 @@ +#region LZ4 original + +/* + LZ4 - Fast LZ compression algorithm + Copyright (C) 2011-2012, Yann Collet. + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + You can contact the author at : + - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html + - LZ4 source repository : http://code.google.com/p/lz4/ +*/ + +#endregion + +#region LZ4 port + +/* +Copyright (c) 2013, Milosz Krajewski +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided +that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this list of conditions + and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this list of conditions + and the following disclaimer in the documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#endregion + +// ReSharper disable CheckNamespace +// ReSharper disable InconsistentNaming +// ReSharper disable TooWideLocalVariableScope +// ReSharper disable JoinDeclarationAndInitializer +// ReSharper disable RedundantIfElseBlock + +namespace LZ4ps +{ + public static partial class LZ4Codec + { + #region LZ4_compressCtx + + private static int LZ4_compressCtx_safe32( + int[] hash_table, + byte[] src, + byte[] dst, + int src_0, + int dst_0, + int src_len, + int dst_maxlen) + { + var debruijn32 = DEBRUIJN_TABLE_32; + int _i; + + // ---- preprocessed source start here ---- + // r93 + var src_p = src_0; + var src_base = src_0; + var src_anchor = src_p; + var src_end = src_p + src_len; + var src_mflimit = src_end - MFLIMIT; + + var dst_p = dst_0; + var dst_end = dst_p + dst_maxlen; + + var src_LASTLITERALS = src_end - LASTLITERALS; + var src_LASTLITERALS_1 = src_LASTLITERALS - 1; + + var src_LASTLITERALS_STEPSIZE_1 = src_LASTLITERALS - (STEPSIZE_32 - 1); + var dst_LASTLITERALS_1 = dst_end - (1 + LASTLITERALS); + var dst_LASTLITERALS_3 = dst_end - (2 + 1 + LASTLITERALS); + + int length; + + uint h, h_fwd; + + // Init + if (src_len < MINLENGTH) goto _last_literals; + + // First Byte + hash_table[(((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST)] = (src_p - src_base); + src_p++; + h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST); + + // Main Loop + while (true) + { + var findMatchAttempts = (1 << SKIPSTRENGTH) + 3; + var src_p_fwd = src_p; + int src_ref; + int dst_token; + + // Find a match + do + { + h = h_fwd; + var step = findMatchAttempts++ >> SKIPSTRENGTH; + src_p = src_p_fwd; + src_p_fwd = src_p + step; + + if (src_p_fwd > src_mflimit) goto _last_literals; + + h_fwd = (((Peek4(src, src_p_fwd)) * 2654435761u) >> HASH_ADJUST); + src_ref = src_base + hash_table[h]; + hash_table[h] = (src_p - src_base); + } while ((src_ref < src_p - MAX_DISTANCE) || (!Equal4(src, src_ref, src_p))); + + // Catch up + while ((src_p > src_anchor) && (src_ref > src_0) && (src[src_p - 1] == src[src_ref - 1])) + { + src_p--; + src_ref--; + } + + // Encode Literal length + length = (src_p - src_anchor); + dst_token = dst_p++; + + if (dst_p + length + (length >> 8) > dst_LASTLITERALS_3) return 0; // Check output limit + + if (length >= RUN_MASK) + { + var len = length - RUN_MASK; + dst[dst_token] = (RUN_MASK << ML_BITS); + if (len > 254) + { + do + { + dst[dst_p++] = 255; + len -= 255; + } while (len > 254); + dst[dst_p++] = (byte)len; + BlockCopy(src, src_anchor, dst, dst_p, length); + dst_p += length; + goto _next_match; + } + else + dst[dst_p++] = (byte)len; + } + else + { + dst[dst_token] = (byte)(length << ML_BITS); + } + + // Copy Literals + if (length > 0) + { + _i = dst_p + length; + WildCopy(src, src_anchor, dst, dst_p, _i); + dst_p = _i; + } + + _next_match: + // Encode Offset + Poke2(dst, dst_p, (ushort)(src_p - src_ref)); + dst_p += 2; + + // Start Counting + src_p += MINMATCH; + src_ref += MINMATCH; // MinMatch already verified + src_anchor = src_p; + + while (src_p < src_LASTLITERALS_STEPSIZE_1) + { + var diff = (int)Xor4(src, src_ref, src_p); + if (diff == 0) + { + src_p += STEPSIZE_32; + src_ref += STEPSIZE_32; + continue; + } + src_p += debruijn32[((uint)((diff) & -(diff)) * 0x077CB531u) >> 27]; + goto _endCount; + } + + if ((src_p < src_LASTLITERALS_1) && (Equal2(src, src_ref, src_p))) + { + src_p += 2; + src_ref += 2; + } + if ((src_p < src_LASTLITERALS) && (src[src_ref] == src[src_p])) src_p++; + + _endCount: + // Encode MatchLength + length = (src_p - src_anchor); + + if (dst_p + (length >> 8) > dst_LASTLITERALS_1) return 0; // Check output limit + + if (length >= ML_MASK) + { + dst[dst_token] += ML_MASK; + length -= ML_MASK; + for (; length > 509; length -= 510) + { + dst[dst_p++] = 255; + dst[dst_p++] = 255; + } + if (length > 254) + { + length -= 255; + dst[dst_p++] = 255; + } + dst[dst_p++] = (byte)length; + } + else + { + dst[dst_token] += (byte)length; + } + + // Test end of chunk + if (src_p > src_mflimit) + { + src_anchor = src_p; + break; + } + + // Fill table + hash_table[(((Peek4(src, src_p - 2)) * 2654435761u) >> HASH_ADJUST)] = (src_p - 2 - src_base); + + // Test next position + + h = (((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST); + src_ref = src_base + hash_table[h]; + hash_table[h] = (src_p - src_base); + + if ((src_ref > src_p - (MAX_DISTANCE + 1)) && (Equal4(src, src_ref, src_p))) + { + dst_token = dst_p++; + dst[dst_token] = 0; + goto _next_match; + } + + // Prepare next loop + src_anchor = src_p++; + h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST); + } + + _last_literals: + // Encode Last Literals + { + var lastRun = (src_end - src_anchor); + + if (dst_p + lastRun + 1 + ((lastRun + 255 - RUN_MASK) / 255) > dst_end) return 0; + + if (lastRun >= RUN_MASK) + { + dst[dst_p++] = (RUN_MASK << ML_BITS); + lastRun -= RUN_MASK; + for (; lastRun > 254; lastRun -= 255) dst[dst_p++] = 255; + dst[dst_p++] = (byte)lastRun; + } + else dst[dst_p++] = (byte)(lastRun << ML_BITS); + BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor); + dst_p += src_end - src_anchor; + } + + // End + return ((dst_p) - dst_0); + } + + #endregion + + #region LZ4_compress64kCtx + + private static int LZ4_compress64kCtx_safe32( + ushort[] hash_table, + byte[] src, + byte[] dst, + int src_0, + int dst_0, + int src_len, + int dst_maxlen) + { + var debruijn32 = DEBRUIJN_TABLE_32; + int _i; + + // ---- preprocessed source start here ---- + // r93 + var src_p = src_0; + var src_anchor = src_p; + var src_base = src_p; + var src_end = src_p + src_len; + var src_mflimit = src_end - MFLIMIT; + + var dst_p = dst_0; + var dst_end = dst_p + dst_maxlen; + + var src_LASTLITERALS = src_end - LASTLITERALS; + var src_LASTLITERALS_1 = src_LASTLITERALS - 1; + + var src_LASTLITERALS_STEPSIZE_1 = src_LASTLITERALS - (STEPSIZE_32 - 1); + var dst_LASTLITERALS_1 = dst_end - (1 + LASTLITERALS); + var dst_LASTLITERALS_3 = dst_end - (2 + 1 + LASTLITERALS); + + int len, length; + + uint h, h_fwd; + + // Init + if (src_len < MINLENGTH) goto _last_literals; + + // First Byte + src_p++; + h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH64K_ADJUST); + + // Main Loop + while (true) + { + var findMatchAttempts = (1 << SKIPSTRENGTH) + 3; + var src_p_fwd = src_p; + int src_ref; + int dst_token; + + // Find a match + do + { + h = h_fwd; + var step = findMatchAttempts++ >> SKIPSTRENGTH; + src_p = src_p_fwd; + src_p_fwd = src_p + step; + + if (src_p_fwd > src_mflimit) goto _last_literals; + + h_fwd = (((Peek4(src, src_p_fwd)) * 2654435761u) >> HASH64K_ADJUST); + src_ref = src_base + hash_table[h]; + hash_table[h] = (ushort)(src_p - src_base); + } while (!Equal4(src, src_ref, src_p)); + + // Catch up + while ((src_p > src_anchor) && (src_ref > src_0) && (src[src_p - 1] == src[src_ref - 1])) + { + src_p--; + src_ref--; + } + + // Encode Literal length + length = (src_p - src_anchor); + dst_token = dst_p++; + + if (dst_p + length + (length >> 8) > dst_LASTLITERALS_3) return 0; // Check output limit + + if (length >= RUN_MASK) + { + len = length - RUN_MASK; + dst[dst_token] = (RUN_MASK << ML_BITS); + if (len > 254) + { + do + { + dst[dst_p++] = 255; + len -= 255; + } while (len > 254); + dst[dst_p++] = (byte)len; + BlockCopy(src, src_anchor, dst, dst_p, length); + dst_p += length; + goto _next_match; + } + else + { + dst[dst_p++] = (byte)len; + } + } + else + { + dst[dst_token] = (byte)(length << ML_BITS); + } + + // Copy Literals + if (length > 0) + { + _i = dst_p + length; + WildCopy(src, src_anchor, dst, dst_p, _i); + dst_p = _i; + } + + _next_match: + // Encode Offset + Poke2(dst, dst_p, (ushort)(src_p - src_ref)); + dst_p += 2; + + // Start Counting + src_p += MINMATCH; + src_ref += MINMATCH; // MinMatch verified + src_anchor = src_p; + + while (src_p < src_LASTLITERALS_STEPSIZE_1) + { + var diff = (int)Xor4(src, src_ref, src_p); + if (diff == 0) + { + src_p += STEPSIZE_32; + src_ref += STEPSIZE_32; + continue; + } + src_p += debruijn32[((uint)((diff) & -(diff)) * 0x077CB531u) >> 27]; + goto _endCount; + } + + if ((src_p < src_LASTLITERALS_1) && (Equal2(src, src_ref, src_p))) + { + src_p += 2; + src_ref += 2; + } + if ((src_p < src_LASTLITERALS) && (src[src_ref] == src[src_p])) src_p++; + + _endCount: + + // Encode MatchLength + len = (src_p - src_anchor); + + if (dst_p + (len >> 8) > dst_LASTLITERALS_1) return 0; // Check output limit + + if (len >= ML_MASK) + { + dst[dst_token] += ML_MASK; + len -= ML_MASK; + for (; len > 509; len -= 510) + { + dst[dst_p++] = 255; + dst[dst_p++] = 255; + } + if (len > 254) + { + len -= 255; + dst[dst_p++] = 255; + } + dst[dst_p++] = (byte)len; + } + else + { + dst[dst_token] += (byte)len; + } + + // Test end of chunk + if (src_p > src_mflimit) + { + src_anchor = src_p; + break; + } + + // Fill table + hash_table[(((Peek4(src, src_p - 2)) * 2654435761u) >> HASH64K_ADJUST)] = (ushort)(src_p - 2 - src_base); + + // Test next position + + h = (((Peek4(src, src_p)) * 2654435761u) >> HASH64K_ADJUST); + src_ref = src_base + hash_table[h]; + hash_table[h] = (ushort)(src_p - src_base); + + if (Equal4(src, src_ref, src_p)) + { + dst_token = dst_p++; + dst[dst_token] = 0; + goto _next_match; + } + + // Prepare next loop + src_anchor = src_p++; + h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH64K_ADJUST); + } + + _last_literals: + // Encode Last Literals + var lastRun = (src_end - src_anchor); + if (dst_p + lastRun + 1 + (lastRun - RUN_MASK + 255) / 255 > dst_end) return 0; + if (lastRun >= RUN_MASK) + { + dst[dst_p++] = (RUN_MASK << ML_BITS); + lastRun -= RUN_MASK; + for (; lastRun > 254; lastRun -= 255) dst[dst_p++] = 255; + dst[dst_p++] = (byte)lastRun; + } + else + { + dst[dst_p++] = (byte)(lastRun << ML_BITS); + } + BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor); + dst_p += src_end - src_anchor; + + // End + return ((dst_p) - dst_0); + } + + #endregion + + #region LZ4_uncompress + + private static int LZ4_uncompress_safe32( + byte[] src, + byte[] dst, + int src_0, + int dst_0, + int dst_len) + { + var dec32table = DECODER_TABLE_32; + int _i; + + // ---- preprocessed source start here ---- + // r93 + var src_p = src_0; + int dst_ref; + + var dst_p = dst_0; + var dst_end = dst_p + dst_len; + int dst_cpy; + + var dst_LASTLITERALS = dst_end - LASTLITERALS; + var dst_COPYLENGTH = dst_end - COPYLENGTH; + var dst_COPYLENGTH_STEPSIZE_4 = dst_end - COPYLENGTH - (STEPSIZE_32 - 4); + + byte token; + + // Main Loop + while (true) + { + int length; + + // get runlength + token = src[src_p++]; + if ((length = (token >> ML_BITS)) == RUN_MASK) + { + int len; + for (; (len = src[src_p++]) == 255; length += 255) + { + /* do nothing */ + } + length += len; + } + + // copy literals + dst_cpy = dst_p + length; + + if (dst_cpy > dst_COPYLENGTH) + { + if (dst_cpy != dst_end) goto _output_error; // Error : not enough place for another match (min 4) + 5 literals + BlockCopy(src, src_p, dst, dst_p, length); + src_p += length; + break; // EOF + } + if (dst_p < dst_cpy) + { + _i = WildCopy(src, src_p, dst, dst_p, dst_cpy); + src_p += _i; + dst_p += _i; + } + src_p -= (dst_p - dst_cpy); + dst_p = dst_cpy; + + // get offset + dst_ref = (dst_cpy) - Peek2(src, src_p); + src_p += 2; + if (dst_ref < dst_0) goto _output_error; // Error : offset outside destination buffer + + // get matchlength + if ((length = (token & ML_MASK)) == ML_MASK) + { + for (; src[src_p] == 255; length += 255) src_p++; + length += src[src_p++]; + } + + // copy repeated sequence + if ((dst_p - dst_ref) < STEPSIZE_32) + { + const int dec64 = 0; + dst[dst_p + 0] = dst[dst_ref + 0]; + dst[dst_p + 1] = dst[dst_ref + 1]; + dst[dst_p + 2] = dst[dst_ref + 2]; + dst[dst_p + 3] = dst[dst_ref + 3]; + dst_p += 4; + dst_ref += 4; + dst_ref -= dec32table[dst_p - dst_ref]; + Copy4(dst, dst_ref, dst_p); + dst_p += STEPSIZE_32 - 4; + dst_ref -= dec64; + } + else + { + Copy4(dst, dst_ref, dst_p); + dst_p += 4; + dst_ref += 4; + } + dst_cpy = dst_p + length - (STEPSIZE_32 - 4); + + if (dst_cpy > dst_COPYLENGTH_STEPSIZE_4) + { + if (dst_cpy > dst_LASTLITERALS) goto _output_error; // Error : last 5 bytes must be literals + if (dst_p < dst_COPYLENGTH) + { + _i = SecureCopy(dst, dst_ref, dst_p, dst_COPYLENGTH); + dst_ref += _i; + dst_p += _i; + } + + while (dst_p < dst_cpy) dst[dst_p++] = dst[dst_ref++]; + dst_p = dst_cpy; + continue; + } + + if (dst_p < dst_cpy) + { + SecureCopy(dst, dst_ref, dst_p, dst_cpy); + } + dst_p = dst_cpy; // correction + } + + // end of decoding + return ((src_p) - src_0); + + // write overflow error detected + _output_error: + return (-((src_p) - src_0)); + } + + #endregion + + #region LZ4_uncompress_unknownOutputSize + + private static int LZ4_uncompress_unknownOutputSize_safe32( + byte[] src, + byte[] dst, + int src_0, + int dst_0, + int src_len, + int dst_maxlen) + { + var dec32table = DECODER_TABLE_32; + int _i; + + // ---- preprocessed source start here ---- + // r93 + var src_p = src_0; + var src_end = src_p + src_len; + int dst_ref; + + var dst_p = dst_0; + var dst_end = dst_p + dst_maxlen; + int dst_cpy; + + var src_LASTLITERALS_3 = (src_end - (2 + 1 + LASTLITERALS)); + var src_LASTLITERALS_1 = (src_end - (LASTLITERALS + 1)); + var dst_COPYLENGTH = (dst_end - COPYLENGTH); + var dst_COPYLENGTH_STEPSIZE_4 = (dst_end - (COPYLENGTH + (STEPSIZE_32 - 4))); + var dst_LASTLITERALS = (dst_end - LASTLITERALS); + var dst_MFLIMIT = (dst_end - MFLIMIT); + + // Special case + if (src_p == src_end) goto _output_error; // A correctly formed null-compressed LZ4 must have at least one byte (token=0) + + // Main Loop + while (true) + { + byte token; + int length; + + // get runlength + token = src[src_p++]; + if ((length = (token >> ML_BITS)) == RUN_MASK) + { + var s = 255; + while ((src_p < src_end) && (s == 255)) length += (s = src[src_p++]); + } + + // copy literals + dst_cpy = dst_p + length; + + if ((dst_cpy > dst_MFLIMIT) || (src_p + length > src_LASTLITERALS_3)) + { + if (dst_cpy > dst_end) goto _output_error; // Error : writes beyond output buffer + if (src_p + length != src_end) goto _output_error; // Error : LZ4 format requires to consume all input at this stage (no match within the last 11 bytes, and at least 8 remaining input bytes for another match+literals) + BlockCopy(src, src_p, dst, dst_p, length); + dst_p += length; + break; // Necessarily EOF, due to parsing restrictions + } + if (dst_p < dst_cpy) + { + _i = WildCopy(src, src_p, dst, dst_p, dst_cpy); + src_p += _i; + dst_p += _i; + } + src_p -= (dst_p - dst_cpy); + dst_p = dst_cpy; + + // get offset + dst_ref = (dst_cpy) - Peek2(src, src_p); + src_p += 2; + if (dst_ref < dst_0) goto _output_error; // Error : offset outside of destination buffer + + // get matchlength + if ((length = (token & ML_MASK)) == ML_MASK) + { + while (src_p < src_LASTLITERALS_1) // Error : a minimum input bytes must remain for LASTLITERALS + token + { + int s = src[src_p++]; + length += s; + if (s == 255) continue; + break; + } + } + + // copy repeated sequence + if (dst_p - dst_ref < STEPSIZE_32) + { + const int dec64 = 0; + dst[dst_p + 0] = dst[dst_ref + 0]; + dst[dst_p + 1] = dst[dst_ref + 1]; + dst[dst_p + 2] = dst[dst_ref + 2]; + dst[dst_p + 3] = dst[dst_ref + 3]; + dst_p += 4; + dst_ref += 4; + dst_ref -= dec32table[dst_p - dst_ref]; + Copy4(dst, dst_ref, dst_p); + dst_p += STEPSIZE_32 - 4; + dst_ref -= dec64; + } + else + { + Copy4(dst, dst_ref, dst_p); + dst_p += 4; + dst_ref += 4; + } + dst_cpy = dst_p + length - (STEPSIZE_32 - 4); + + if (dst_cpy > dst_COPYLENGTH_STEPSIZE_4) + { + if (dst_cpy > dst_LASTLITERALS) goto _output_error; // Error : last 5 bytes must be literals + if (dst_p < dst_COPYLENGTH) + { + _i = SecureCopy(dst, dst_ref, dst_p, dst_COPYLENGTH); + dst_ref += _i; + dst_p += _i; + } + + while (dst_p < dst_cpy) dst[dst_p++] = dst[dst_ref++]; + dst_p = dst_cpy; + continue; + } + + if (dst_p < dst_cpy) + { + SecureCopy(dst, dst_ref, dst_p, dst_cpy); + } + dst_p = dst_cpy; // correction + } + + // end of decoding + return ((dst_p) - dst_0); + + // write overflow error detected + _output_error: + return (-((src_p) - src_0)); + } + + #endregion + } +} + +// ReSharper restore RedundantIfElseBlock +// ReSharper restore JoinDeclarationAndInitializer +// ReSharper restore TooWideLocalVariableScope +// ReSharper restore InconsistentNaming +// ReSharper restore CheckNamespace diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs.meta b/Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs.meta new file mode 100644 index 0000000..7086673 --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8c5dc5c9f2a382b4db836cf150c3a176 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs b/Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs new file mode 100644 index 0000000..446bbfd --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs @@ -0,0 +1,524 @@ +#region LZ4 original + +/* + LZ4 - Fast LZ compression algorithm + Copyright (C) 2011-2012, Yann Collet. + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + You can contact the author at : + - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html + - LZ4 source repository : http://code.google.com/p/lz4/ +*/ + +#endregion + +#region LZ4 port + +/* +Copyright (c) 2013, Milosz Krajewski +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided +that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this list of conditions + and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this list of conditions + and the following disclaimer in the documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#endregion + +// ReSharper disable InconsistentNaming + +namespace LZ4ps +{ + public static partial class LZ4Codec + { + // Update chains up to ip (excluded) + private static void LZ4HC_Insert_32(LZ4HC_Data_Structure ctx, int src_p) + { + var chainTable = ctx.chainTable; + var hashTable = ctx.hashTable; + var nextToUpdate = ctx.nextToUpdate; + var src = ctx.src; + var src_base = ctx.src_base; + + while (nextToUpdate < src_p) + { + var p = nextToUpdate; + var delta = (p) - (hashTable[(((Peek4(src, p)) * 2654435761u) >> HASHHC_ADJUST)] + src_base); + if (delta > MAX_DISTANCE) delta = MAX_DISTANCE; + chainTable[(p) & MAXD_MASK] = (ushort)delta; + hashTable[(((Peek4(src, p)) * 2654435761u) >> HASHHC_ADJUST)] = ((p) - src_base); + nextToUpdate++; + } + + ctx.nextToUpdate = nextToUpdate; + } + + private static int LZ4HC_CommonLength_32(LZ4HC_Data_Structure ctx, int p1, int p2) + { + var debruijn32 = DEBRUIJN_TABLE_32; + var src = ctx.src; + var src_LASTLITERALS = ctx.src_LASTLITERALS; + + var p1t = p1; + + while (p1t < src_LASTLITERALS - (STEPSIZE_32 - 1)) + { + var diff = (int)Xor4(src, p2, p1t); + if (diff == 0) + { + p1t += STEPSIZE_32; + p2 += STEPSIZE_32; + continue; + } + p1t += debruijn32[((uint)((diff) & -(diff)) * 0x077CB531u) >> 27]; + return (p1t - p1); + } + if ((p1t < (src_LASTLITERALS - 1)) && (Equal2(src, p2, p1t))) + { + p1t += 2; + p2 += 2; + } + if ((p1t < src_LASTLITERALS) && (src[p2] == src[p1t])) p1t++; + return (p1t - p1); + } + + private static int LZ4HC_InsertAndFindBestMatch_32(LZ4HC_Data_Structure ctx, int src_p, ref int src_match) + { + var chainTable = ctx.chainTable; + var hashTable = ctx.hashTable; + var src = ctx.src; + var src_base = ctx.src_base; + + var nbAttempts = MAX_NB_ATTEMPTS; + int repl = 0, ml = 0; + ushort delta = 0; + + // HC4 match finder + LZ4HC_Insert_32(ctx, src_p); + var src_ref = (hashTable[(((Peek4(src, src_p)) * 2654435761u) >> HASHHC_ADJUST)] + src_base); + + + // Detect repetitive sequences of length <= 4 + if (src_ref >= src_p - 4) // potential repetition + { + if (Equal4(src, src_ref, src_p)) // confirmed + { + delta = (ushort)(src_p - src_ref); + repl = ml = LZ4HC_CommonLength_32(ctx, src_p + MINMATCH, src_ref + MINMATCH) + MINMATCH; + src_match = src_ref; + } + src_ref = ((src_ref) - chainTable[(src_ref) & MAXD_MASK]); + } + + while ((src_ref >= src_p - MAX_DISTANCE) && (nbAttempts != 0)) + { + nbAttempts--; + if (src[(src_ref + ml)] == src[(src_p + ml)]) + { + if (Equal4(src, src_ref, src_p)) + { + var mlt = LZ4HC_CommonLength_32(ctx, src_p + MINMATCH, src_ref + MINMATCH) + MINMATCH; + if (mlt > ml) + { + ml = mlt; + src_match = src_ref; + } + } + } + src_ref = ((src_ref) - chainTable[(src_ref) & MAXD_MASK]); + } + + + // Complete table + if (repl != 0) + { + var src_ptr = src_p; + + var end = src_p + repl - (MINMATCH - 1); + while (src_ptr < end - delta) + { + chainTable[(src_ptr) & MAXD_MASK] = delta; // Pre-Load + src_ptr++; + } + do + { + chainTable[(src_ptr) & MAXD_MASK] = delta; + hashTable[(((Peek4(src, src_ptr)) * 2654435761u) >> HASHHC_ADJUST)] = ((src_ptr) - src_base); // Head of chain + src_ptr++; + } while (src_ptr < end); + ctx.nextToUpdate = end; + } + + return ml; + } + + private static int LZ4HC_InsertAndGetWiderMatch_32( + LZ4HC_Data_Structure ctx, int src_p, int startLimit, int longest, ref int matchpos, ref int startpos) + { + var chainTable = ctx.chainTable; + var hashTable = ctx.hashTable; + var src = ctx.src; + var src_base = ctx.src_base; + var src_LASTLITERALS = ctx.src_LASTLITERALS; + var debruijn32 = DEBRUIJN_TABLE_32; + var nbAttempts = MAX_NB_ATTEMPTS; + var delta = (src_p - startLimit); + + // First Match + LZ4HC_Insert_32(ctx, src_p); + var src_ref = (hashTable[(((Peek4(src, src_p)) * 2654435761u) >> HASHHC_ADJUST)] + src_base); + + while ((src_ref >= src_p - MAX_DISTANCE) && (nbAttempts != 0)) + { + nbAttempts--; + if (src[(startLimit + longest)] == src[(src_ref - delta + longest)]) + { + if (Equal4(src, src_ref, src_p)) + { + var reft = src_ref + MINMATCH; + var ipt = src_p + MINMATCH; + var startt = src_p; + + while (ipt < src_LASTLITERALS - (STEPSIZE_32 - 1)) + { + var diff = (int)Xor4(src, reft, ipt); + if (diff == 0) + { + ipt += STEPSIZE_32; + reft += STEPSIZE_32; + continue; + } + ipt += debruijn32[((uint)((diff) & -(diff)) * 0x077CB531u) >> 27]; + goto _endCount; + } + if ((ipt < (src_LASTLITERALS - 1)) && (Equal2(src, reft, ipt))) + { + ipt += 2; + reft += 2; + } + if ((ipt < src_LASTLITERALS) && (src[reft] == src[ipt])) ipt++; + + _endCount: + reft = src_ref; + + while ((startt > startLimit) && (reft > src_base) && (src[startt - 1] == src[reft - 1])) + { + startt--; + reft--; + } + + if ((ipt - startt) > longest) + { + longest = (ipt - startt); + matchpos = reft; + startpos = startt; + } + } + } + src_ref = ((src_ref) - chainTable[(src_ref) & MAXD_MASK]); + } + + return longest; + } + + private static int LZ4_encodeSequence_32( + LZ4HC_Data_Structure ctx, ref int src_p, ref int dst_p, ref int src_anchor, int matchLength, int src_ref, int dst_end) + { + int len; + var src = ctx.src; + var dst = ctx.dst; + + // Encode Literal length + var length = src_p - src_anchor; + var dst_token = dst_p++; + if ((dst_p + length + (2 + 1 + LASTLITERALS) + (length >> 8)) > dst_end) return 1; // Check output limit + if (length >= RUN_MASK) + { + dst[dst_token] = (RUN_MASK << ML_BITS); + len = length - RUN_MASK; + for (; len > 254; len -= 255) dst[dst_p++] = 255; + dst[dst_p++] = (byte)len; + } + else + { + dst[dst_token] = (byte)(length << ML_BITS); + } + + // Copy Literals + if (length > 0) + { + var _i = dst_p + length; + src_anchor += WildCopy(src, src_anchor, dst, dst_p, _i); + dst_p = _i; + } + + // Encode Offset + Poke2(dst, dst_p, (ushort)(src_p - src_ref)); + dst_p += 2; + + // Encode MatchLength + len = (matchLength - MINMATCH); + if (dst_p + (1 + LASTLITERALS) + (length >> 8) > dst_end) return 1; // Check output limit + if (len >= ML_MASK) + { + dst[dst_token] += ML_MASK; + len -= ML_MASK; + for (; len > 509; len -= 510) + { + dst[(dst_p)++] = 255; + dst[(dst_p)++] = 255; + } + if (len > 254) + { + len -= 255; + dst[(dst_p)++] = 255; + } + dst[(dst_p)++] = (byte)len; + } + else + { + dst[dst_token] += (byte)len; + } + + // Prepare next loop + src_p += matchLength; + src_anchor = src_p; + + return 0; + } + + private static int LZ4_compressHCCtx_32(LZ4HC_Data_Structure ctx) + { + var src = ctx.src; + var dst = ctx.dst; + var src_0 = ctx.src_base; + var src_end = ctx.src_end; + var dst_0 = ctx.dst_base; + var dst_len = ctx.dst_len; + var dst_end = ctx.dst_end; + + var src_p = src_0; + var src_anchor = src_p; + var src_mflimit = src_end - MFLIMIT; + + var dst_p = dst_0; + + var src_ref = 0; + var start2 = 0; + var ref2 = 0; + var start3 = 0; + var ref3 = 0; + + src_p++; + + // Main Loop + while (src_p < src_mflimit) + { + var ml = LZ4HC_InsertAndFindBestMatch_32(ctx, src_p, ref src_ref); + if (ml == 0) + { + src_p++; + continue; + } + + // saved, in case we would skip too much + var start0 = src_p; + var ref0 = src_ref; + var ml0 = ml; + + _Search2: + var ml2 = src_p + ml < src_mflimit + ? LZ4HC_InsertAndGetWiderMatch_32(ctx, src_p + ml - 2, src_p + 1, ml, ref ref2, ref start2) + : ml; + + if (ml2 == ml) // No better match + { + if (LZ4_encodeSequence_32(ctx, ref src_p, ref dst_p, ref src_anchor, ml, src_ref, dst_end) != 0) return 0; + continue; + } + + if (start0 < src_p) + { + if (start2 < src_p + ml0) // empirical + { + src_p = start0; + src_ref = ref0; + ml = ml0; + } + } + + // Here, start0==ip + if ((start2 - src_p) < 3) // First Match too small : removed + { + ml = ml2; + src_p = start2; + src_ref = ref2; + goto _Search2; + } + + _Search3: + // Currently we have : + // ml2 > ml1, and + // ip1+3 <= ip2 (usually < ip1+ml1) + if ((start2 - src_p) < OPTIMAL_ML) + { + var new_ml = ml; + if (new_ml > OPTIMAL_ML) new_ml = OPTIMAL_ML; + if (src_p + new_ml > start2 + ml2 - MINMATCH) new_ml = (start2 - src_p) + ml2 - MINMATCH; + var correction = new_ml - (start2 - src_p); + if (correction > 0) + { + start2 += correction; + ref2 += correction; + ml2 -= correction; + } + } + // Now, we have start2 = ip+new_ml, with new_ml=min(ml, OPTIMAL_ML=18) + + var ml3 = start2 + ml2 < src_mflimit + ? LZ4HC_InsertAndGetWiderMatch_32(ctx, start2 + ml2 - 3, start2, ml2, ref ref3, ref start3) + : ml2; + + if (ml3 == ml2) // No better match : 2 sequences to encode + { + // ip & ref are known; Now for ml + if (start2 < src_p + ml) ml = (start2 - src_p); + // Now, encode 2 sequences + if (LZ4_encodeSequence_32(ctx, ref src_p, ref dst_p, ref src_anchor, ml, src_ref, dst_end) != 0) return 0; + src_p = start2; + if (LZ4_encodeSequence_32(ctx, ref src_p, ref dst_p, ref src_anchor, ml2, ref2, dst_end) != 0) return 0; + continue; + } + + if (start3 < src_p + ml + 3) // Not enough space for match 2 : remove it + { + if (start3 >= (src_p + ml)) // can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 + { + if (start2 < src_p + ml) + { + var correction = (src_p + ml - start2); + start2 += correction; + ref2 += correction; + ml2 -= correction; + if (ml2 < MINMATCH) + { + start2 = start3; + ref2 = ref3; + ml2 = ml3; + } + } + + if (LZ4_encodeSequence_32(ctx, ref src_p, ref dst_p, ref src_anchor, ml, src_ref, dst_end) != 0) return 0; + src_p = start3; + src_ref = ref3; + ml = ml3; + + start0 = start2; + ref0 = ref2; + ml0 = ml2; + goto _Search2; + } + + start2 = start3; + ref2 = ref3; + ml2 = ml3; + goto _Search3; + } + + // OK, now we have 3 ascending matches; let's write at least the first one + // ip & ref are known; Now for ml + if (start2 < src_p + ml) + { + if ((start2 - src_p) < ML_MASK) + { + if (ml > OPTIMAL_ML) ml = OPTIMAL_ML; + if (src_p + ml > start2 + ml2 - MINMATCH) ml = (start2 - src_p) + ml2 - MINMATCH; + var correction = ml - (start2 - src_p); + if (correction > 0) + { + start2 += correction; + ref2 += correction; + ml2 -= correction; + } + } + else + { + ml = (start2 - src_p); + } + } + if (LZ4_encodeSequence_32(ctx, ref src_p, ref dst_p, ref src_anchor, ml, src_ref, dst_end) != 0) return 0; + + src_p = start2; + src_ref = ref2; + ml = ml2; + + start2 = start3; + ref2 = ref3; + ml2 = ml3; + + goto _Search3; + } + + // Encode Last Literals + { + var lastRun = (src_end - src_anchor); + if ((dst_p - dst_0) + lastRun + 1 + ((lastRun + 255 - RUN_MASK) / 255) > (uint)dst_len) return 0; // Check output limit + if (lastRun >= RUN_MASK) + { + dst[dst_p++] = (RUN_MASK << ML_BITS); + lastRun -= RUN_MASK; + for (; lastRun > 254; lastRun -= 255) dst[dst_p++] = 255; + dst[dst_p++] = (byte)lastRun; + } + else + { + dst[dst_p++] = (byte)(lastRun << ML_BITS); + } + BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor); + dst_p += src_end - src_anchor; + } + + // End + return (dst_p - dst_0); + } + } +} + +// ReSharper restore InconsistentNaming diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs.meta b/Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs.meta new file mode 100644 index 0000000..f1a35b3 --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0cd0b555f5386b84b9fc6aea0b43418d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs b/Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs new file mode 100644 index 0000000..fbeee17 --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs @@ -0,0 +1,808 @@ +#region LZ4 original + +/* + LZ4 - Fast LZ compression algorithm + Copyright (C) 2011-2012, Yann Collet. + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + You can contact the author at : + - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html + - LZ4 source repository : http://code.google.com/p/lz4/ +*/ + +#endregion + +#region LZ4 port + +/* +Copyright (c) 2013, Milosz Krajewski +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided +that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this list of conditions + and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this list of conditions + and the following disclaimer in the documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#endregion + +// ReSharper disable CheckNamespace +// ReSharper disable InconsistentNaming +// ReSharper disable TooWideLocalVariableScope +// ReSharper disable JoinDeclarationAndInitializer +// ReSharper disable RedundantIfElseBlock + +namespace LZ4ps +{ + public static partial class LZ4Codec + { + #region LZ4_compressCtx + + private static int LZ4_compressCtx_safe64( + int[] hash_table, + byte[] src, + byte[] dst, + int src_0, + int dst_0, + int src_len, + int dst_maxlen) + { + var debruijn64 = DEBRUIJN_TABLE_64; + int _i; + + // ---- preprocessed source start here ---- + // r93 + var src_p = src_0; + var src_base = src_0; + var src_anchor = src_p; + var src_end = src_p + src_len; + var src_mflimit = src_end - MFLIMIT; + + var dst_p = dst_0; + var dst_end = dst_p + dst_maxlen; + + var src_LASTLITERALS = src_end - LASTLITERALS; + var src_LASTLITERALS_1 = src_LASTLITERALS - 1; + + var src_LASTLITERALS_3 = src_LASTLITERALS - 3; + + var src_LASTLITERALS_STEPSIZE_1 = src_LASTLITERALS - (STEPSIZE_64 - 1); + var dst_LASTLITERALS_1 = dst_end - (1 + LASTLITERALS); + var dst_LASTLITERALS_3 = dst_end - (2 + 1 + LASTLITERALS); + + int length; + + uint h, h_fwd; + + // Init + if (src_len < MINLENGTH) goto _last_literals; + + // First Byte + hash_table[(((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST)] = (src_p - src_base); + src_p++; + h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST); + + // Main Loop + while (true) + { + var findMatchAttempts = (1 << SKIPSTRENGTH) + 3; + var src_p_fwd = src_p; + int src_ref; + int dst_token; + + // Find a match + do + { + h = h_fwd; + var step = findMatchAttempts++ >> SKIPSTRENGTH; + src_p = src_p_fwd; + src_p_fwd = src_p + step; + + if (src_p_fwd > src_mflimit) goto _last_literals; + + h_fwd = (((Peek4(src, src_p_fwd)) * 2654435761u) >> HASH_ADJUST); + src_ref = src_base + hash_table[h]; + hash_table[h] = (src_p - src_base); + } while ((src_ref < src_p - MAX_DISTANCE) || (!Equal4(src, src_ref, src_p))); + + // Catch up + while ((src_p > src_anchor) && (src_ref > src_0) && (src[src_p - 1] == src[src_ref - 1])) + { + src_p--; + src_ref--; + } + + // Encode Literal length + length = (src_p - src_anchor); + dst_token = dst_p++; + + if (dst_p + length + (length >> 8) > dst_LASTLITERALS_3) return 0; // Check output limit + + if (length >= RUN_MASK) + { + var len = length - RUN_MASK; + dst[dst_token] = (RUN_MASK << ML_BITS); + if (len > 254) + { + do + { + dst[dst_p++] = 255; + len -= 255; + } while (len > 254); + dst[dst_p++] = (byte)len; + BlockCopy(src, src_anchor, dst, dst_p, length); + dst_p += length; + goto _next_match; + } + else + dst[dst_p++] = (byte)len; + } + else + { + dst[dst_token] = (byte)(length << ML_BITS); + } + + // Copy Literals + if (length > 0) + { + _i = dst_p + length; + WildCopy(src, src_anchor, dst, dst_p, _i); + dst_p = _i; + } + + _next_match: + // Encode Offset + Poke2(dst, dst_p, (ushort)(src_p - src_ref)); + dst_p += 2; + + // Start Counting + src_p += MINMATCH; + src_ref += MINMATCH; // MinMatch already verified + src_anchor = src_p; + + while (src_p < src_LASTLITERALS_STEPSIZE_1) + { + var diff = (long)Xor8(src, src_ref, src_p); + if (diff == 0) + { + src_p += STEPSIZE_64; + src_ref += STEPSIZE_64; + continue; + } + src_p += debruijn64[((ulong)((diff) & -(diff)) * 0x0218A392CDABBD3FL) >> 58]; + goto _endCount; + } + + if ((src_p < src_LASTLITERALS_3) && (Equal4(src, src_ref, src_p))) + { + src_p += 4; + src_ref += 4; + } + if ((src_p < src_LASTLITERALS_1) && (Equal2(src, src_ref, src_p))) + { + src_p += 2; + src_ref += 2; + } + if ((src_p < src_LASTLITERALS) && (src[src_ref] == src[src_p])) src_p++; + + _endCount: + // Encode MatchLength + length = (src_p - src_anchor); + + if (dst_p + (length >> 8) > dst_LASTLITERALS_1) return 0; // Check output limit + + if (length >= ML_MASK) + { + dst[dst_token] += ML_MASK; + length -= ML_MASK; + for (; length > 509; length -= 510) + { + dst[dst_p++] = 255; + dst[dst_p++] = 255; + } + if (length > 254) + { + length -= 255; + dst[dst_p++] = 255; + } + dst[dst_p++] = (byte)length; + } + else + { + dst[dst_token] += (byte)length; + } + + // Test end of chunk + if (src_p > src_mflimit) + { + src_anchor = src_p; + break; + } + + // Fill table + hash_table[(((Peek4(src, src_p - 2)) * 2654435761u) >> HASH_ADJUST)] = (src_p - 2 - src_base); + + // Test next position + + h = (((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST); + src_ref = src_base + hash_table[h]; + hash_table[h] = (src_p - src_base); + + if ((src_ref > src_p - (MAX_DISTANCE + 1)) && (Equal4(src, src_ref, src_p))) + { + dst_token = dst_p++; + dst[dst_token] = 0; + goto _next_match; + } + + // Prepare next loop + src_anchor = src_p++; + h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST); + } + + _last_literals: + // Encode Last Literals + { + var lastRun = (src_end - src_anchor); + + if (dst_p + lastRun + 1 + ((lastRun + 255 - RUN_MASK) / 255) > dst_end) return 0; + + if (lastRun >= RUN_MASK) + { + dst[dst_p++] = (RUN_MASK << ML_BITS); + lastRun -= RUN_MASK; + for (; lastRun > 254; lastRun -= 255) dst[dst_p++] = 255; + dst[dst_p++] = (byte)lastRun; + } + else dst[dst_p++] = (byte)(lastRun << ML_BITS); + BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor); + dst_p += src_end - src_anchor; + } + + // End + return (dst_p - dst_0); + } + + #endregion + + #region LZ4_compress64kCtx + + private static int LZ4_compress64kCtx_safe64( + ushort[] hash_table, + byte[] src, + byte[] dst, + int src_0, + int dst_0, + int src_len, + int dst_maxlen) + { + var debruijn64 = DEBRUIJN_TABLE_64; + int _i; + + // ---- preprocessed source start here ---- + // r93 + var src_p = src_0; + var src_anchor = src_p; + var src_base = src_p; + var src_end = src_p + src_len; + var src_mflimit = src_end - MFLIMIT; + + var dst_p = dst_0; + var dst_end = dst_p + dst_maxlen; + + var src_LASTLITERALS = src_end - LASTLITERALS; + var src_LASTLITERALS_1 = src_LASTLITERALS - 1; + + var src_LASTLITERALS_3 = src_LASTLITERALS - 3; + + var src_LASTLITERALS_STEPSIZE_1 = src_LASTLITERALS - (STEPSIZE_64 - 1); + var dst_LASTLITERALS_1 = dst_end - (1 + LASTLITERALS); + var dst_LASTLITERALS_3 = dst_end - (2 + 1 + LASTLITERALS); + + int len, length; + + uint h, h_fwd; + + // Init + if (src_len < MINLENGTH) goto _last_literals; + + // First Byte + src_p++; + h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH64K_ADJUST); + + // Main Loop + while (true) + { + var findMatchAttempts = (1 << SKIPSTRENGTH) + 3; + var src_p_fwd = src_p; + int src_ref; + int dst_token; + + // Find a match + do + { + h = h_fwd; + var step = findMatchAttempts++ >> SKIPSTRENGTH; + src_p = src_p_fwd; + src_p_fwd = src_p + step; + + if (src_p_fwd > src_mflimit) goto _last_literals; + + h_fwd = (((Peek4(src, src_p_fwd)) * 2654435761u) >> HASH64K_ADJUST); + src_ref = src_base + hash_table[h]; + hash_table[h] = (ushort)(src_p - src_base); + } while (!Equal4(src, src_ref, src_p)); + + // Catch up + while ((src_p > src_anchor) && (src_ref > src_0) && (src[src_p - 1] == src[src_ref - 1])) + { + src_p--; + src_ref--; + } + + // Encode Literal length + length = (src_p - src_anchor); + dst_token = dst_p++; + + if (dst_p + length + (length >> 8) > dst_LASTLITERALS_3) return 0; // Check output limit + + if (length >= RUN_MASK) + { + len = length - RUN_MASK; + dst[dst_token] = (RUN_MASK << ML_BITS); + if (len > 254) + { + do + { + dst[dst_p++] = 255; + len -= 255; + } while (len > 254); + dst[dst_p++] = (byte)len; + BlockCopy(src, src_anchor, dst, dst_p, length); + dst_p += length; + goto _next_match; + } + else + dst[dst_p++] = (byte)len; + } + else + { + dst[dst_token] = (byte)(length << ML_BITS); + } + + // Copy Literals + if (length > 0) /*?*/ + { + _i = dst_p + length; + WildCopy(src, src_anchor, dst, dst_p, _i); + dst_p = _i; + } + + _next_match: + // Encode Offset + Poke2(dst, dst_p, (ushort)(src_p - src_ref)); + dst_p += 2; + + // Start Counting + src_p += MINMATCH; + src_ref += MINMATCH; // MinMatch verified + src_anchor = src_p; + + while (src_p < src_LASTLITERALS_STEPSIZE_1) + { + var diff = (long)Xor8(src, src_ref, src_p); + if (diff == 0) + { + src_p += STEPSIZE_64; + src_ref += STEPSIZE_64; + continue; + } + src_p += debruijn64[((ulong)((diff) & -(diff)) * 0x0218A392CDABBD3FL) >> 58]; + goto _endCount; + } + + if ((src_p < src_LASTLITERALS_3) && (Equal4(src, src_ref, src_p))) + { + src_p += 4; + src_ref += 4; + } + if ((src_p < src_LASTLITERALS_1) && (Equal2(src, src_ref, src_p))) + { + src_p += 2; + src_ref += 2; + } + if ((src_p < src_LASTLITERALS) && (src[src_ref] == src[src_p])) src_p++; + + _endCount: + + // Encode MatchLength + len = (src_p - src_anchor); + + if (dst_p + (len >> 8) > dst_LASTLITERALS_1) return 0; // Check output limit + + if (len >= ML_MASK) + { + dst[dst_token] += ML_MASK; + len -= ML_MASK; + for (; len > 509; len -= 510) + { + dst[dst_p++] = 255; + dst[dst_p++] = 255; + } + if (len > 254) + { + len -= 255; + dst[dst_p++] = 255; + } + dst[dst_p++] = (byte)len; + } + else + { + dst[dst_token] += (byte)len; + } + + // Test end of chunk + if (src_p > src_mflimit) + { + src_anchor = src_p; + break; + } + + // Fill table + hash_table[(((Peek4(src, src_p - 2)) * 2654435761u) >> HASH64K_ADJUST)] = (ushort)(src_p - 2 - src_base); + + // Test next position + + h = (((Peek4(src, src_p)) * 2654435761u) >> HASH64K_ADJUST); + src_ref = src_base + hash_table[h]; + hash_table[h] = (ushort)(src_p - src_base); + + if (Equal4(src, src_ref, src_p)) + { + dst_token = dst_p++; + dst[dst_token] = 0; + goto _next_match; + } + + // Prepare next loop + src_anchor = src_p++; + h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH64K_ADJUST); + } + + _last_literals: + // Encode Last Literals + { + var lastRun = (src_end - src_anchor); + if (dst_p + lastRun + 1 + (lastRun - RUN_MASK + 255) / 255 > dst_end) return 0; + if (lastRun >= RUN_MASK) + { + dst[dst_p++] = (RUN_MASK << ML_BITS); + lastRun -= RUN_MASK; + for (; lastRun > 254; lastRun -= 255) dst[dst_p++] = 255; + dst[dst_p++] = (byte)lastRun; + } + else dst[dst_p++] = (byte)(lastRun << ML_BITS); + BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor); + dst_p += src_end - src_anchor; + } + + // End + return (dst_p - dst_0); + } + + #endregion + + #region LZ4_uncompress + + private static int LZ4_uncompress_safe64( + byte[] src, + byte[] dst, + int src_0, + int dst_0, + int dst_len) + { + var dec32table = DECODER_TABLE_32; + var dec64table = DECODER_TABLE_64; + int _i; + + // ---- preprocessed source start here ---- + // r93 + var src_p = src_0; + int dst_ref; + + var dst_p = dst_0; + var dst_end = dst_p + dst_len; + int dst_cpy; + + var dst_LASTLITERALS = dst_end - LASTLITERALS; + var dst_COPYLENGTH = dst_end - COPYLENGTH; + var dst_COPYLENGTH_STEPSIZE_4 = dst_end - COPYLENGTH - (STEPSIZE_64 - 4); + + uint token; + + // Main Loop + while (true) + { + int length; + + // get runlength + token = src[src_p++]; + if ((length = (byte)(token >> ML_BITS)) == RUN_MASK) + { + int len; + for (; (len = src[src_p++]) == 255; length += 255) + { + /* do nothing */ + } + length += len; + } + + // copy literals + dst_cpy = dst_p + length; + + if (dst_cpy > dst_COPYLENGTH) + { + if (dst_cpy != dst_end) goto _output_error; // Error : not enough place for another match (min 4) + 5 literals + BlockCopy(src, src_p, dst, dst_p, length); + src_p += length; + break; // EOF + } + if (dst_p < dst_cpy) /*?*/ + { + _i = WildCopy(src, src_p, dst, dst_p, dst_cpy); + src_p += _i; + dst_p += _i; + } + src_p -= (dst_p - dst_cpy); + dst_p = dst_cpy; + + // get offset + dst_ref = (dst_cpy) - Peek2(src, src_p); + src_p += 2; + if (dst_ref < dst_0) goto _output_error; // Error : offset outside destination buffer + + // get matchlength + if ((length = (byte)(token & ML_MASK)) == ML_MASK) + { + for (; src[src_p] == 255; length += 255) src_p++; + length += src[src_p++]; + } + + // copy repeated sequence + if ((dst_p - dst_ref) < STEPSIZE_64) + { + var dec64 = dec64table[dst_p - dst_ref]; + + dst[dst_p + 0] = dst[dst_ref + 0]; + dst[dst_p + 1] = dst[dst_ref + 1]; + dst[dst_p + 2] = dst[dst_ref + 2]; + dst[dst_p + 3] = dst[dst_ref + 3]; + dst_p += 4; + dst_ref += 4; + dst_ref -= dec32table[dst_p - dst_ref]; + Copy4(dst, dst_ref, dst_p); + dst_p += STEPSIZE_64 - 4; + dst_ref -= dec64; + } + else + { + Copy8(dst, dst_ref, dst_p); + dst_p += 8; + dst_ref += 8; + } + dst_cpy = dst_p + length - (STEPSIZE_64 - 4); + + if (dst_cpy > dst_COPYLENGTH_STEPSIZE_4) + { + if (dst_cpy > dst_LASTLITERALS) goto _output_error; // Error : last 5 bytes must be literals + if (dst_p < dst_COPYLENGTH) + { + _i = SecureCopy(dst, dst_ref, dst_p, dst_COPYLENGTH); + dst_ref += _i; + dst_p += _i; + } + + while (dst_p < dst_cpy) dst[dst_p++] = dst[dst_ref++]; + dst_p = dst_cpy; + continue; + } + + if (dst_p < dst_cpy) + { + SecureCopy(dst, dst_ref, dst_p, dst_cpy); + } + dst_p = dst_cpy; // correction + } + + // end of decoding + return ((src_p) - src_0); + + _output_error: + // write overflow error detected + return (-((src_p) - src_0)); + } + + #endregion + + #region LZ4_uncompress_unknownOutputSize + + private static int LZ4_uncompress_unknownOutputSize_safe64( + byte[] src, + byte[] dst, + int src_0, + int dst_0, + int src_len, + int dst_maxlen) + { + var dec32table = DECODER_TABLE_32; + var dec64table = DECODER_TABLE_64; + int _i; + + // ---- preprocessed source start here ---- + // r93 + var src_p = src_0; + var src_end = src_p + src_len; + int dst_ref; + + var dst_p = dst_0; + var dst_end = dst_p + dst_maxlen; + int dst_cpy; + + var src_LASTLITERALS_3 = (src_end - (2 + 1 + LASTLITERALS)); + var src_LASTLITERALS_1 = (src_end - (LASTLITERALS + 1)); + var dst_COPYLENGTH = (dst_end - COPYLENGTH); + var dst_COPYLENGTH_STEPSIZE_4 = (dst_end - (COPYLENGTH + (STEPSIZE_64 - 4))); + var dst_LASTLITERALS = (dst_end - LASTLITERALS); + var dst_MFLIMIT = (dst_end - MFLIMIT); + + // Special case + if (src_p == src_end) goto _output_error; // A correctly formed null-compressed LZ4 must have at least one byte (token=0) + + // Main Loop + while (true) + { + byte token; + int length; + + // get runlength + token = src[src_p++]; + if ((length = (token >> ML_BITS)) == RUN_MASK) + { + var s = 255; + while ((src_p < src_end) && (s == 255)) length += (s = src[src_p++]); + } + + // copy literals + dst_cpy = dst_p + length; + + if ((dst_cpy > dst_MFLIMIT) || (src_p + length > src_LASTLITERALS_3)) + { + if (dst_cpy > dst_end) goto _output_error; // Error : writes beyond output buffer + if (src_p + length != src_end) goto _output_error; // Error : LZ4 format requires to consume all input at this stage (no match within the last 11 bytes, and at least 8 remaining input bytes for another match+literals) + BlockCopy(src, src_p, dst, dst_p, length); + dst_p += length; + break; // Necessarily EOF, due to parsing restrictions + } + if (dst_p < dst_cpy) /*?*/ + { + _i = WildCopy(src, src_p, dst, dst_p, dst_cpy); + src_p += _i; + dst_p += _i; + } + src_p -= (dst_p - dst_cpy); + dst_p = dst_cpy; + + // get offset + dst_ref = (dst_cpy) - Peek2(src, src_p); + src_p += 2; + if (dst_ref < dst_0) goto _output_error; // Error : offset outside of destination buffer + + // get matchlength + if ((length = (token & ML_MASK)) == ML_MASK) + { + while (src_p < src_LASTLITERALS_1) // Error : a minimum input bytes must remain for LASTLITERALS + token + { + int s = src[src_p++]; + length += s; + if (s == 255) continue; + break; + } + } + + // copy repeated sequence + if (dst_p - dst_ref < STEPSIZE_64) + { + var dec64 = dec64table[dst_p - dst_ref]; + dst[dst_p + 0] = dst[dst_ref + 0]; + dst[dst_p + 1] = dst[dst_ref + 1]; + dst[dst_p + 2] = dst[dst_ref + 2]; + dst[dst_p + 3] = dst[dst_ref + 3]; + dst_p += 4; + dst_ref += 4; + dst_ref -= dec32table[dst_p - dst_ref]; + Copy4(dst, dst_ref, dst_p); + dst_p += STEPSIZE_64 - 4; + dst_ref -= dec64; + } + else + { + Copy8(dst, dst_ref, dst_p); + dst_p += 8; + dst_ref += 8; + } + dst_cpy = dst_p + length - (STEPSIZE_64 - 4); + + if (dst_cpy > dst_COPYLENGTH_STEPSIZE_4) + { + if (dst_cpy > dst_LASTLITERALS) goto _output_error; // Error : last 5 bytes must be literals + if (dst_p < dst_COPYLENGTH) + { + _i = SecureCopy(dst, dst_ref, dst_p, dst_COPYLENGTH); + dst_ref += _i; + dst_p += _i; + } + while (dst_p < dst_cpy) dst[dst_p++] = dst[dst_ref++]; + dst_p = dst_cpy; + continue; + } + + if (dst_p < dst_cpy) + { + SecureCopy(dst, dst_ref, dst_p, dst_cpy); + } + dst_p = dst_cpy; // correction + } + + // end of decoding + return ((dst_p) - dst_0); + + // write overflow error detected + _output_error: + return (-((src_p) - src_0)); + } + + #endregion + } +} + +// ReSharper restore RedundantIfElseBlock +// ReSharper restore JoinDeclarationAndInitializer +// ReSharper restore TooWideLocalVariableScope +// ReSharper restore InconsistentNaming +// ReSharper restore CheckNamespace diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs.meta b/Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs.meta new file mode 100644 index 0000000..bb791e8 --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 04fd67d662c762548a89d1fe5bf6cfcc +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs b/Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs new file mode 100644 index 0000000..8ff946c --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs @@ -0,0 +1,526 @@ +#region LZ4 original + +/* + LZ4 - Fast LZ compression algorithm + Copyright (C) 2011-2012, Yann Collet. + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + You can contact the author at : + - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html + - LZ4 source repository : http://code.google.com/p/lz4/ +*/ + +#endregion + +#region LZ4 port + +/* +Copyright (c) 2013, Milosz Krajewski +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided +that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this list of conditions + and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this list of conditions + and the following disclaimer in the documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#endregion + +// ReSharper disable InconsistentNaming + +namespace LZ4ps +{ + public static partial class LZ4Codec + { + private static void LZ4HC_Insert_64(LZ4HC_Data_Structure ctx, int src_p) + { + var chainTable = ctx.chainTable; + var hashTable = ctx.hashTable; + var src = ctx.src; + var src_base = ctx.src_base; + var nextToUpdate = ctx.nextToUpdate; + + while (nextToUpdate < src_p) + { + var p = nextToUpdate; + var delta = (p) - (hashTable[(((Peek4(src, p)) * 2654435761u) >> HASHHC_ADJUST)] + src_base); + if (delta > MAX_DISTANCE) delta = MAX_DISTANCE; + chainTable[(p) & MAXD_MASK] = (ushort)delta; + hashTable[(((Peek4(src, p)) * 2654435761u) >> HASHHC_ADJUST)] = ((p) - src_base); + nextToUpdate++; + } + + ctx.nextToUpdate = nextToUpdate; + } + + private static int LZ4HC_CommonLength_64(LZ4HC_Data_Structure ctx, int p1, int p2) + { + var debruijn64 = DEBRUIJN_TABLE_64; + var src = ctx.src; + var src_LASTLITERALS = ctx.src_LASTLITERALS; + var p1t = p1; + + while (p1t < src_LASTLITERALS - (STEPSIZE_64 - 1)) + { + var diff = (long)Xor8(src, p2, p1t); + if (diff == 0) + { + p1t += STEPSIZE_64; + p2 += STEPSIZE_64; + continue; + } + p1t += debruijn64[((ulong)((diff) & -(diff)) * 0x0218A392CDABBD3FL) >> 58]; + return (p1t - p1); + } + if ((p1t < (src_LASTLITERALS - 3)) && (Equal4(src, p2, p1t))) + { + p1t += 4; + p2 += 4; + } + if ((p1t < (src_LASTLITERALS - 1)) && (Equal2(src, p2, p1t))) + { + p1t += 2; + p2 += 2; + } + if ((p1t < src_LASTLITERALS) && (src[p2] == src[p1t])) p1t++; + return (p1t - p1); + } + + private static int LZ4HC_InsertAndFindBestMatch_64(LZ4HC_Data_Structure ctx, int src_p, ref int matchpos) + { + var chainTable = ctx.chainTable; + var hashTable = ctx.hashTable; + var src = ctx.src; + var src_base = ctx.src_base; + var nbAttempts = MAX_NB_ATTEMPTS; + int repl = 0, ml = 0; + ushort delta = 0; + + // HC4 match finder + LZ4HC_Insert_64(ctx, src_p); + var src_ref = (hashTable[(((Peek4(src, src_p)) * 2654435761u) >> HASHHC_ADJUST)] + src_base); + + // Detect repetitive sequences of length <= 4 + if (src_ref >= src_p - 4) // potential repetition + { + if (Equal4(src, src_ref, src_p)) // confirmed + { + delta = (ushort)(src_p - src_ref); + repl = ml = LZ4HC_CommonLength_64(ctx, src_p + MINMATCH, src_ref + MINMATCH) + MINMATCH; + matchpos = src_ref; + } + src_ref = ((src_ref) - chainTable[(src_ref) & MAXD_MASK]); + } + + + while ((src_ref >= src_p - MAX_DISTANCE) && (nbAttempts != 0)) + { + nbAttempts--; + if (src[src_ref + ml] == src[src_p + ml]) + { + if (Equal4(src, src_ref, src_p)) + { + var mlt = LZ4HC_CommonLength_64(ctx, src_p + MINMATCH, src_ref + MINMATCH) + MINMATCH; + if (mlt > ml) + { + ml = mlt; + matchpos = src_ref; + } + } + } + src_ref = ((src_ref) - chainTable[(src_ref) & MAXD_MASK]); + } + + + // Complete table + if (repl != 0) + { + var ptr = src_p; + + var end = src_p + repl - (MINMATCH - 1); + while (ptr < end - delta) + { + chainTable[(ptr) & MAXD_MASK] = delta; // Pre-Load + ptr++; + } + do + { + chainTable[(ptr) & MAXD_MASK] = delta; + hashTable[(((Peek4(src, ptr)) * 2654435761u) >> HASHHC_ADJUST)] = ((ptr) - src_base); // Head of chain + ptr++; + } while (ptr < end); + ctx.nextToUpdate = end; + } + + return ml; + } + + private static int LZ4HC_InsertAndGetWiderMatch_64(LZ4HC_Data_Structure ctx, int src_p, int startLimit, int longest, ref int matchpos, ref int startpos) + { + var debruijn64 = DEBRUIJN_TABLE_64; + var chainTable = ctx.chainTable; + var hashTable = ctx.hashTable; + var src = ctx.src; + var src_base = ctx.src_base; + var src_LASTLITERALS = ctx.src_LASTLITERALS; + var nbAttempts = MAX_NB_ATTEMPTS; + var delta = (src_p - startLimit); + + // First Match + LZ4HC_Insert_64(ctx, src_p); + var src_ref = (hashTable[(((Peek4(src, src_p)) * 2654435761u) >> HASHHC_ADJUST)] + src_base); + + while ((src_ref >= src_p - MAX_DISTANCE) && (nbAttempts != 0)) + { + nbAttempts--; + if (src[startLimit + longest] == src[src_ref - delta + longest]) + { + if (Equal4(src, src_ref, src_p)) + { + var reft = src_ref + MINMATCH; + var ipt = src_p + MINMATCH; + var startt = src_p; + + while (ipt < src_LASTLITERALS - (STEPSIZE_64 - 1)) + { + var diff = (long)Xor8(src, reft, ipt); + if (diff == 0) + { + ipt += STEPSIZE_64; + reft += STEPSIZE_64; + continue; + } + ipt += debruijn64[((ulong)((diff) & -(diff)) * 0x0218A392CDABBD3FL) >> 58]; + goto _endCount; + } + if ((ipt < (src_LASTLITERALS - 3)) && (Equal4(src, reft, ipt))) + { + ipt += 4; + reft += 4; + } + if ((ipt < (src_LASTLITERALS - 1)) && (Equal2(src, reft, ipt))) + { + ipt += 2; + reft += 2; + } + if ((ipt < src_LASTLITERALS) && (src[reft] == src[ipt])) ipt++; + + _endCount: + reft = src_ref; + + while ((startt > startLimit) && (reft > src_base) && (src[startt - 1] == src[reft - 1])) + { + startt--; + reft--; + } + + if ((ipt - startt) > longest) + { + longest = (ipt - startt); + matchpos = reft; + startpos = startt; + } + } + } + src_ref = ((src_ref) - chainTable[(src_ref) & MAXD_MASK]); + } + + return longest; + } + + private static int LZ4_encodeSequence_64(LZ4HC_Data_Structure ctx, ref int src_p, ref int dst_p, ref int src_anchor, int matchLength, int src_ref) + { + var src = ctx.src; + var dst = ctx.dst; + var dst_end = ctx.dst_end; + int len; + + // Encode Literal length + var length = (src_p - src_anchor); + var dst_token = (dst_p)++; + if ((dst_p + length + (2 + 1 + LASTLITERALS) + (length >> 8)) > dst_end) return 1; // Check output limit + if (length >= RUN_MASK) + { + dst[dst_token] = (RUN_MASK << ML_BITS); + len = length - RUN_MASK; + for (; len > 254; len -= 255) dst[dst_p++] = 255; + dst[dst_p++] = (byte)len; + } + else + { + dst[dst_token] = (byte)(length << ML_BITS); + } + + // Copy Literals + if (length > 0) + { + var _i = dst_p + length; + src_anchor += WildCopy(src, src_anchor, dst, dst_p, _i); + dst_p = _i; + } + + // Encode Offset + Poke2(dst, dst_p, (ushort)(src_p - src_ref)); + dst_p += 2; + + // Encode MatchLength + len = (matchLength - MINMATCH); + if (dst_p + (1 + LASTLITERALS) + (length >> 8) > dst_end) return 1; // Check output limit + if (len >= ML_MASK) + { + dst[dst_token] += ML_MASK; + len -= ML_MASK; + for (; len > 509; len -= 510) + { + dst[dst_p++] = 255; + dst[dst_p++] = 255; + } + if (len > 254) + { + len -= 255; + dst[dst_p++] = 255; + } + dst[dst_p++] = (byte)len; + } + else + { + dst[dst_token] += (byte)len; + } + + // Prepare next loop + src_p += matchLength; + src_anchor = src_p; + + return 0; + } + + private static int LZ4_compressHCCtx_64(LZ4HC_Data_Structure ctx) + { + var src = ctx.src; + var src_p = ctx.src_base; + var src_end = ctx.src_end; + var dst_0 = ctx.dst_base; + var src_anchor = src_p; + var src_mflimit = src_end - MFLIMIT; + var dst = ctx.dst; + var dst_len = ctx.dst_len; + var dst_p = ctx.dst_base; + + var xxx_ref = 0; + var start2 = 0; + var ref2 = 0; + var start3 = 0; + var ref3 = 0; + + src_p++; + + // Main Loop + while (src_p < src_mflimit) + { + var ml = LZ4HC_InsertAndFindBestMatch_64(ctx, src_p, ref xxx_ref); + if (ml == 0) + { + src_p++; + continue; + } + + // saved, in case we would skip too much + var start0 = src_p; + var ref0 = xxx_ref; + var ml0 = ml; + + _Search2: + var ml2 = src_p + ml < src_mflimit + ? LZ4HC_InsertAndGetWiderMatch_64(ctx, src_p + ml - 2, src_p + 1, ml, ref ref2, ref start2) + : ml; + + if (ml2 == ml) // No better match + { + if (LZ4_encodeSequence_64(ctx, ref src_p, ref dst_p, ref src_anchor, ml, xxx_ref) != 0) return 0; + continue; + } + + if (start0 < src_p) + { + if (start2 < src_p + ml0) // empirical + { + src_p = start0; + xxx_ref = ref0; + ml = ml0; + } + } + + // Here, start0==ip + if ((start2 - src_p) < 3) // First Match too small : removed + { + ml = ml2; + src_p = start2; + xxx_ref = ref2; + goto _Search2; + } + + _Search3: + // Currently we have : + // ml2 > ml1, and + // ip1+3 <= ip2 (usually < ip1+ml1) + if ((start2 - src_p) < OPTIMAL_ML) + { + var new_ml = ml; + if (new_ml > OPTIMAL_ML) new_ml = OPTIMAL_ML; + if (src_p + new_ml > start2 + ml2 - MINMATCH) new_ml = (start2 - src_p) + ml2 - MINMATCH; + var correction = new_ml - (start2 - src_p); + if (correction > 0) + { + start2 += correction; + ref2 += correction; + ml2 -= correction; + } + } + // Now, we have start2 = ip+new_ml, with new_ml=min(ml, OPTIMAL_ML=18) + + var ml3 = start2 + ml2 < src_mflimit + ? LZ4HC_InsertAndGetWiderMatch_64(ctx, start2 + ml2 - 3, start2, ml2, ref ref3, ref start3) + : ml2; + + if (ml3 == ml2) // No better match : 2 sequences to encode + { + // ip & ref are known; Now for ml + if (start2 < src_p + ml) ml = (start2 - src_p); + // Now, encode 2 sequences + if (LZ4_encodeSequence_64(ctx, ref src_p, ref dst_p, ref src_anchor, ml, xxx_ref) != 0) return 0; + src_p = start2; + if (LZ4_encodeSequence_64(ctx, ref src_p, ref dst_p, ref src_anchor, ml2, ref2) != 0) return 0; + continue; + } + + if (start3 < src_p + ml + 3) // Not enough space for match 2 : remove it + { + if (start3 >= (src_p + ml)) // can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 + { + if (start2 < src_p + ml) + { + var correction = (src_p + ml - start2); + start2 += correction; + ref2 += correction; + ml2 -= correction; + if (ml2 < MINMATCH) + { + start2 = start3; + ref2 = ref3; + ml2 = ml3; + } + } + + if (LZ4_encodeSequence_64(ctx, ref src_p, ref dst_p, ref src_anchor, ml, xxx_ref) != 0) return 0; + src_p = start3; + xxx_ref = ref3; + ml = ml3; + + start0 = start2; + ref0 = ref2; + ml0 = ml2; + goto _Search2; + } + + start2 = start3; + ref2 = ref3; + ml2 = ml3; + goto _Search3; + } + + // OK, now we have 3 ascending matches; let's write at least the first one + // ip & ref are known; Now for ml + if (start2 < src_p + ml) + { + if ((start2 - src_p) < ML_MASK) + { + if (ml > OPTIMAL_ML) ml = OPTIMAL_ML; + if (src_p + ml > start2 + ml2 - MINMATCH) ml = (start2 - src_p) + ml2 - MINMATCH; + var correction = ml - (start2 - src_p); + if (correction > 0) + { + start2 += correction; + ref2 += correction; + ml2 -= correction; + } + } + else + { + ml = (start2 - src_p); + } + } + if (LZ4_encodeSequence_64(ctx, ref src_p, ref dst_p, ref src_anchor, ml, xxx_ref) != 0) return 0; + + src_p = start2; + xxx_ref = ref2; + ml = ml2; + + start2 = start3; + ref2 = ref3; + ml2 = ml3; + + goto _Search3; + } + + // Encode Last Literals + { + var lastRun = (src_end - src_anchor); + if ((dst_p - dst_0) + lastRun + 1 + ((lastRun + 255 - RUN_MASK) / 255) > (uint)dst_len) return 0; // Check output limit + if (lastRun >= RUN_MASK) + { + dst[dst_p++] = (RUN_MASK << ML_BITS); + lastRun -= RUN_MASK; + for (; lastRun > 254; lastRun -= 255) dst[dst_p++] = 255; + dst[dst_p++] = (byte)lastRun; + } + else + { + dst[dst_p++] = (byte)(lastRun << ML_BITS); + } + BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor); + dst_p += src_end - src_anchor; + } + + // End + return (dst_p - dst_0); + } + } +} + +// ReSharper restore InconsistentNaming diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs.meta b/Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs.meta new file mode 100644 index 0000000..e6f49e8 --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c61e65caf96385a469be74084e2e1f00 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/LZ4/LZ4Codec.cs b/Assets/Scripts/LZ4/LZ4Codec.cs new file mode 100644 index 0000000..5cdf315 --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Codec.cs @@ -0,0 +1,176 @@ +#region license + +/* +Copyright (c) 2013, Milosz Krajewski +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided +that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this list of conditions + and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this list of conditions + and the following disclaimer in the documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#endregion + +using System; + +/* +NOTE: + This file is shared between LZ4pn and LZ4ps. + If you would like to modify this file please keep in mind that your changes will + affect both projects. + Use 'UNSAFE' conditional define to differentiate +*/ + +// ReSharper disable InconsistentNaming + +#if UNSAFE +namespace LZ4pn +#else +namespace LZ4ps +#endif +{ + public static partial class LZ4Codec + { + #region configuration + + /// + /// Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.) + /// Increasing memory usage improves compression ratio + /// Reduced memory usage can improve speed, due to cache effect + /// Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache + /// + private const int MEMORY_USAGE = 20; + + /// + /// Decreasing this value will make the algorithm skip faster data segments considered "incompressible" + /// This may decrease compression ratio dramatically, but will be faster on incompressible data + /// Increasing this value will make the algorithm search more before declaring a segment "incompressible" + /// This could improve compression a bit, but will be slower on incompressible data + /// The default value (6) is recommended + /// + private const int NOTCOMPRESSIBLE_DETECTIONLEVEL = 6; + +#if !UNSAFE + + /// Buffer length when Buffer.BlockCopy becomes faster than straight loop. + /// Please note that safe implementation REQUIRES it to be greater (not even equal) than 8. + private const int BLOCK_COPY_LIMIT = 16; + +#endif + + #endregion + + #region consts + + private const int MINMATCH = 4; + #pragma warning disable 162 + // ReSharper disable once UnreachableCode + private const int SKIPSTRENGTH = + NOTCOMPRESSIBLE_DETECTIONLEVEL > 2 + ? NOTCOMPRESSIBLE_DETECTIONLEVEL + : 2; + #pragma warning restore 162 + private const int COPYLENGTH = 8; + private const int LASTLITERALS = 5; + private const int MFLIMIT = COPYLENGTH + MINMATCH; + private const int MINLENGTH = MFLIMIT + 1; + private const int MAXD_LOG = 16; + private const int MAXD = 1 << MAXD_LOG; + private const int MAXD_MASK = MAXD - 1; + private const int MAX_DISTANCE = (1 << MAXD_LOG) - 1; + private const int ML_BITS = 4; + private const int ML_MASK = (1 << ML_BITS) - 1; + private const int RUN_BITS = 8 - ML_BITS; + private const int RUN_MASK = (1 << RUN_BITS) - 1; + private const int STEPSIZE_64 = 8; + private const int STEPSIZE_32 = 4; + + private const int LZ4_64KLIMIT = (1 << 16) + (MFLIMIT - 1); + + private const int HASH_LOG = MEMORY_USAGE - 2; + private const int HASH_TABLESIZE = 1 << HASH_LOG; + private const int HASH_ADJUST = (MINMATCH * 8) - HASH_LOG; + + private const int HASH64K_LOG = HASH_LOG + 1; + private const int HASH64K_TABLESIZE = 1 << HASH64K_LOG; + private const int HASH64K_ADJUST = (MINMATCH * 8) - HASH64K_LOG; + + private const int HASHHC_LOG = MAXD_LOG - 1; + private const int HASHHC_TABLESIZE = 1 << HASHHC_LOG; + private const int HASHHC_ADJUST = (MINMATCH * 8) - HASHHC_LOG; + //private const int HASHHC_MASK = HASHHC_TABLESIZE - 1; + + private static readonly int[] DECODER_TABLE_32 = { 0, 3, 2, 3, 0, 0, 0, 0 }; + private static readonly int[] DECODER_TABLE_64 = { 0, 0, 0, -1, 0, 1, 2, 3 }; + + private static readonly int[] DEBRUIJN_TABLE_32 = { + 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, + 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 + }; + + private static readonly int[] DEBRUIJN_TABLE_64 = { + 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, + 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, + 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, + 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 + }; + + private const int MAX_NB_ATTEMPTS = 256; + private const int OPTIMAL_ML = (ML_MASK - 1) + MINMATCH; + + #endregion + + #region public interface (common) + + /// Gets maximum the length of the output. + /// Length of the input. + /// Maximum number of bytes needed for compressed buffer. + public static int MaximumOutputLength(int inputLength) + { + return inputLength + (inputLength / 255) + 16; + } + + #endregion + + #region internal interface (common) + + internal static void CheckArguments( + byte[] input, int inputOffset, ref int inputLength, + byte[] output, int outputOffset, ref int outputLength) + { + if (inputLength < 0) inputLength = input.Length - inputOffset; + if (inputLength == 0) + { + outputLength = 0; + return; + } + + if (input == null) throw new ArgumentNullException("input"); + if (inputOffset < 0 || inputOffset + inputLength > input.Length) + throw new ArgumentException("inputOffset and inputLength are invalid for given input"); + + if (outputLength < 0) outputLength = output.Length - outputOffset; + if (output == null) throw new ArgumentNullException("output"); + if (outputOffset < 0 || outputOffset + outputLength > output.Length) + throw new ArgumentException("outputOffset and outputLength are invalid for given output"); + } + + #endregion + } +} + +// ReSharper restore InconsistentNaming \ No newline at end of file diff --git a/Assets/Scripts/LZ4/LZ4Codec.cs.meta b/Assets/Scripts/LZ4/LZ4Codec.cs.meta new file mode 100644 index 0000000..ea0b563 --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Codec.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 60265417a9a7cb346be1757b77ecdd37 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/LZ4/LZ4Util.cs b/Assets/Scripts/LZ4/LZ4Util.cs new file mode 100644 index 0000000..de805dc --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Util.cs @@ -0,0 +1,129 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.IO; +//using LZ4Sharp; +using LZ4ps; + +namespace LZ4 +{ + /// + /// 置換 + /// + public class LZ4Util + { + public static byte[] decompress(byte[] indata) + { + int m_curPos = 4; + int token = (int)(indata[m_curPos - 4] | (indata[m_curPos - 3] << 8) | (indata[m_curPos - 2] << 16) | (indata[m_curPos - 1] << 24)); + m_curPos += 4; + int decompSize = (int)(indata[m_curPos - 4] | (indata[m_curPos - 3] << 8) | (indata[m_curPos - 2] << 16) | (indata[m_curPos - 1] << 24)); + m_curPos += 4; + int compSize = (int)(indata[m_curPos - 4] | (indata[m_curPos - 3] << 8) | (indata[m_curPos - 2] << 16) | (indata[m_curPos - 1] << 24)); + m_curPos += 4; + int tmp4 = (int)(indata[m_curPos - 4] | (indata[m_curPos - 3] << 8) | (indata[m_curPos - 2] << 16) | (indata[m_curPos - 1] << 24)); + + //byte[] srcBytes = new byte[compSize]; + //Array.Copy(indata, 0x10, srcBytes, 0, compSize); + + if (IntPtr.Size == 4) + { + return LZ4Codec.Decode32(indata, 0x10, compSize, decompSize); + } + else + { + return LZ4Codec.Decode64(indata, 0x10, compSize, decompSize); + } + } + } + /* + public class LZ4Util + { + + public static byte[] decompress(byte[] indata) + { + LZ4.BinaryReader r = new LZ4.BinaryReader(indata); + + byte[] dec = decompress(r); + + return dec; + } + + public static byte[] decompress(BinaryReader r) + { + byte[] retArray; + var dataSize = 0; + var decompressedSize = 0; + + var token = 0; + var sqSize = 0; + var matchSize = 0; + var offset = 0; + var retCurPos = 0; + var endPos = 0; + + r.seekAbs(4); + decompressedSize = r.readIntLE(); + dataSize = r.readIntLE(); + endPos = dataSize + 16; + retArray = new byte[decompressedSize]; + + r.seekAbs(16); + + //Start reading sequences + while (true) + { + //read the LiteralSize and the MatchSize + token = r.readByte(); + sqSize = token >> 4; + matchSize = (token & 0x0F) + 4; + if (sqSize == 15) + sqSize += readAdditionalSize(r); + + //copy the literal + r.copyBytes(retArray, retCurPos, sqSize); + retCurPos += sqSize; + + if (r.getPos() >= endPos - 1) + break; + + //read the offset + offset = r.readShortLE(); + + //read the additional MatchSize + if (matchSize == 19) + matchSize += readAdditionalSize(r); + + //copy the match properly + if (matchSize > offset) + { + var matchPos = retCurPos - offset; + while (true) + { + Array.Copy(retArray, matchPos, retArray, retCurPos, offset); + retCurPos += offset; + matchSize -= offset; + if (matchSize < offset) + break; + } + } + Array.Copy(retArray, retCurPos - offset, retArray, retCurPos, matchSize); + retCurPos += matchSize; + } + + + return retArray; + } + + public static int readAdditionalSize(BinaryReader reader) + { + var size = reader.readByte(); + if (size == 255) + return size + readAdditionalSize(reader); + else + return size; + } + } + */ +} diff --git a/Assets/Scripts/LZ4/LZ4Util.cs.meta b/Assets/Scripts/LZ4/LZ4Util.cs.meta new file mode 100644 index 0000000..05ff99b --- /dev/null +++ b/Assets/Scripts/LZ4/LZ4Util.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a39980c7200b27b4b8357880848e8646 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/Test.cs b/Assets/Scripts/Test.cs new file mode 100644 index 0000000..5bc6597 --- /dev/null +++ b/Assets/Scripts/Test.cs @@ -0,0 +1,40 @@ +using BaseNcoding; +using System; +using System.Security.Cryptography; +using System.Text; +using UnityEngine; + +namespace Assets.Editor.RootMotion +{ + public class Test : MonoBehaviour + { + private void Start() + { + SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider(); + var str = CalHameString(sha, 1541716412357448819, 77, Encoding.UTF8.GetBytes("root")); + Debug.LogWarning($"{str} Length:{str.Length}"); + Debug.LogWarning($"{"FN4II57IWE274AT5R45G2UE7XVMFDPBD"} Length:{"FN4II57IWE274AT5R45G2UE7XVMFDPBD".Length}"); + } + + public byte[] CalHame(SHA1CryptoServiceProvider sha1, ulong checksum, ulong size, byte[] name) + { + if (name == null) return null; + byte[] allbyte = new byte[name.Length + 16]; + byte[] checksumByte = BitConverter.GetBytes(checksum); + byte[] sizeByte = BitConverter.GetBytes(size); + for(int i=0; i < 16; i++) + { + allbyte[i] = (i < 8 ? checksumByte[7 - i] : sizeByte[15 - i]); + } + Buffer.BlockCopy(name, 0, allbyte, 16, name.Length); + return sha1.ComputeHash(allbyte); + } + + public string CalHameString(SHA1CryptoServiceProvider sha1, ulong checksum, ulong size, byte[] name) + { + var bytes = CalHame(sha1, checksum, size, name); + Base32 base32 = new Base32(); + return base32.Encode(bytes); + } + } +} diff --git a/Assets/Scripts/Test.cs.meta b/Assets/Scripts/Test.cs.meta new file mode 100644 index 0000000..c617097 --- /dev/null +++ b/Assets/Scripts/Test.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 822adc4dd85200142901586dd5c697c6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Packages/packages-lock.json b/Packages/packages-lock.json index 99b6b22..1ebb68e 100644 --- a/Packages/packages-lock.json +++ b/Packages/packages-lock.json @@ -5,7 +5,7 @@ "depth": 1, "source": "registry", "dependencies": {}, - "url": "https://packages.unity.com" + "url": "https://packages.unity.cn" }, "com.unity.assetbundlebrowser": { "version": "https://github.com/Unity-Technologies/AssetBundles-Browser.git", @@ -21,14 +21,14 @@ "dependencies": { "com.unity.services.core": "1.0.1" }, - "url": "https://packages.unity.com" + "url": "https://packages.unity.cn" }, "com.unity.ext.nunit": { "version": "1.0.6", "depth": 1, "source": "registry", "dependencies": {}, - "url": "https://packages.unity.com" + "url": "https://packages.unity.cn" }, "com.unity.formats.fbx": { "version": "4.1.2", @@ -38,7 +38,7 @@ "com.unity.timeline": "1.5.2", "com.autodesk.fbx": "4.1.1" }, - "url": "https://packages.unity.com" + "url": "https://packages.unity.cn" }, "com.unity.ide.rider": { "version": "2.0.7", @@ -47,7 +47,7 @@ "dependencies": { "com.unity.test-framework": "1.1.1" }, - "url": "https://packages.unity.com" + "url": "https://packages.unity.cn" }, "com.unity.ide.visualstudio": { "version": "2.0.16", @@ -56,14 +56,14 @@ "dependencies": { "com.unity.test-framework": "1.1.9" }, - "url": "https://packages.unity.com" + "url": "https://packages.unity.cn" }, "com.unity.ide.vscode": { "version": "1.2.5", "depth": 0, "source": "registry", "dependencies": {}, - "url": "https://packages.unity.com" + "url": "https://packages.unity.cn" }, "com.unity.postprocessing": { "version": "3.2.2", @@ -72,7 +72,7 @@ "dependencies": { "com.unity.modules.physics": "1.0.0" }, - "url": "https://packages.unity.com" + "url": "https://packages.unity.cn" }, "com.unity.services.core": { "version": "1.0.1", @@ -81,7 +81,7 @@ "dependencies": { "com.unity.modules.unitywebrequest": "1.0.0" }, - "url": "https://packages.unity.com" + "url": "https://packages.unity.cn" }, "com.unity.test-framework": { "version": "1.1.31", @@ -92,7 +92,7 @@ "com.unity.modules.imgui": "1.0.0", "com.unity.modules.jsonserialize": "1.0.0" }, - "url": "https://packages.unity.com" + "url": "https://packages.unity.cn" }, "com.unity.textmeshpro": { "version": "3.0.6", @@ -101,7 +101,7 @@ "dependencies": { "com.unity.ugui": "1.0.0" }, - "url": "https://packages.unity.com" + "url": "https://packages.unity.cn" }, "com.unity.timeline": { "version": "1.5.2", @@ -113,7 +113,7 @@ "com.unity.modules.audio": "1.0.0", "com.unity.modules.particlesystem": "1.0.0" }, - "url": "https://packages.unity.com" + "url": "https://packages.unity.cn" }, "com.unity.ugui": { "version": "1.0.0", diff --git a/ProjectSettings/PackageManagerSettings.asset b/ProjectSettings/PackageManagerSettings.asset index be4a797..bc93024 100644 --- a/ProjectSettings/PackageManagerSettings.asset +++ b/ProjectSettings/PackageManagerSettings.asset @@ -20,7 +20,7 @@ MonoBehaviour: m_Registries: - m_Id: main m_Name: - m_Url: https://packages.unity.com + m_Url: https://packages.unity.cn m_Scopes: [] m_IsDefault: 1 m_Capabilities: 7 diff --git a/ProjectSettings/ProjectVersion.txt b/ProjectSettings/ProjectVersion.txt index 3598ae5..9b8fc7a 100644 --- a/ProjectSettings/ProjectVersion.txt +++ b/ProjectSettings/ProjectVersion.txt @@ -1,2 +1,2 @@ -m_EditorVersion: 2020.3.28f1 -m_EditorVersionWithRevision: 2020.3.28f1 (f5400f52e03f) +m_EditorVersion: 2020.3.24f1c2 +m_EditorVersionWithRevision: 2020.3.24f1c2 (f3616f7ef48a) From 4dd72017274208d32978979c3803c5c6d9656fe8 Mon Sep 17 00:00:00 2001 From: CroakFang <1605296300@qq.com> Date: Tue, 13 Dec 2022 22:57:59 +0800 Subject: [PATCH 2/8] update --- Assets/Scripts/{Test.cs => ManifestEntry.cs} | 17 +++++------------ .../{Test.cs.meta => ManifestEntry.cs.meta} | 0 2 files changed, 5 insertions(+), 12 deletions(-) rename Assets/Scripts/{Test.cs => ManifestEntry.cs} (51%) rename Assets/Scripts/{Test.cs.meta => ManifestEntry.cs.meta} (100%) diff --git a/Assets/Scripts/Test.cs b/Assets/Scripts/ManifestEntry.cs similarity index 51% rename from Assets/Scripts/Test.cs rename to Assets/Scripts/ManifestEntry.cs index 5bc6597..0bef48d 100644 --- a/Assets/Scripts/Test.cs +++ b/Assets/Scripts/ManifestEntry.cs @@ -6,19 +6,12 @@ using UnityEngine; namespace Assets.Editor.RootMotion { - public class Test : MonoBehaviour + public class ManifestEntry { - private void Start() - { - SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider(); - var str = CalHameString(sha, 1541716412357448819, 77, Encoding.UTF8.GetBytes("root")); - Debug.LogWarning($"{str} Length:{str.Length}"); - Debug.LogWarning($"{"FN4II57IWE274AT5R45G2UE7XVMFDPBD"} Length:{"FN4II57IWE274AT5R45G2UE7XVMFDPBD".Length}"); - } - - public byte[] CalHame(SHA1CryptoServiceProvider sha1, ulong checksum, ulong size, byte[] name) + public static byte[] CalHame(ulong checksum, ulong size, byte[] name) { if (name == null) return null; + SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider(); byte[] allbyte = new byte[name.Length + 16]; byte[] checksumByte = BitConverter.GetBytes(checksum); byte[] sizeByte = BitConverter.GetBytes(size); @@ -30,9 +23,9 @@ namespace Assets.Editor.RootMotion return sha1.ComputeHash(allbyte); } - public string CalHameString(SHA1CryptoServiceProvider sha1, ulong checksum, ulong size, byte[] name) + public static string CalHameString(ulong checksum, ulong size, byte[] name) { - var bytes = CalHame(sha1, checksum, size, name); + var bytes = CalHame(checksum, size, name); Base32 base32 = new Base32(); return base32.Encode(bytes); } diff --git a/Assets/Scripts/Test.cs.meta b/Assets/Scripts/ManifestEntry.cs.meta similarity index 100% rename from Assets/Scripts/Test.cs.meta rename to Assets/Scripts/ManifestEntry.cs.meta From fd39c75a64e7ef703264a5e09cac2909e73882c8 Mon Sep 17 00:00:00 2001 From: CroakFang <1605296300@qq.com> Date: Tue, 13 Dec 2022 23:09:47 +0800 Subject: [PATCH 3/8] add game manifest hash algorithm --- Assets/Scripts/ManifestEntry.cs | 44 +++++++++++++++++---------------- 1 file changed, 23 insertions(+), 21 deletions(-) diff --git a/Assets/Scripts/ManifestEntry.cs b/Assets/Scripts/ManifestEntry.cs index 0bef48d..ca498f1 100644 --- a/Assets/Scripts/ManifestEntry.cs +++ b/Assets/Scripts/ManifestEntry.cs @@ -3,31 +3,33 @@ using System; using System.Security.Cryptography; using System.Text; using UnityEngine; - -namespace Assets.Editor.RootMotion +public class ManifestEntry { - public class ManifestEntry + public static byte[] CalHame(ulong checksum, ulong size, byte[] name) { - public static byte[] CalHame(ulong checksum, ulong size, byte[] name) + if (name == null) return null; + SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider(); + byte[] allbyte = new byte[name.Length + 16]; + byte[] checksumByte = BitConverter.GetBytes(checksum); + byte[] sizeByte = BitConverter.GetBytes(size); + for (int i = 0; i < 16; i++) { - if (name == null) return null; - SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider(); - byte[] allbyte = new byte[name.Length + 16]; - byte[] checksumByte = BitConverter.GetBytes(checksum); - byte[] sizeByte = BitConverter.GetBytes(size); - for(int i=0; i < 16; i++) - { - allbyte[i] = (i < 8 ? checksumByte[7 - i] : sizeByte[15 - i]); - } - Buffer.BlockCopy(name, 0, allbyte, 16, name.Length); - return sha1.ComputeHash(allbyte); + allbyte[i] = (i < 8 ? checksumByte[7 - i] : sizeByte[15 - i]); } + Buffer.BlockCopy(name, 0, allbyte, 16, name.Length); + return sha1.ComputeHash(allbyte); + } - public static string CalHameString(ulong checksum, ulong size, byte[] name) - { - var bytes = CalHame(checksum, size, name); - Base32 base32 = new Base32(); - return base32.Encode(bytes); - } + public static string CalHameString(ulong checksum, ulong size, byte[] name) + { + var bytes = CalHame(checksum, size, name); + Base32 base32 = new Base32(); + return base32.Encode(bytes); + } + + public static string CalHameString(ulong checksum, ulong size, string name) + { + return CalHameString(checksum, size, Encoding.UTF8.GetBytes(name)); } } + From 820951189a11a78ed49f5013bec776174ae3d3bd Mon Sep 17 00:00:00 2001 From: CroakFang <1605296300@qq.com> Date: Tue, 13 Dec 2022 23:30:18 +0800 Subject: [PATCH 4/8] update --- Assets/Scenes/Version2.unity | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/Assets/Scenes/Version2.unity b/Assets/Scenes/Version2.unity index 269dacf..119b79b 100644 --- a/Assets/Scenes/Version2.unity +++ b/Assets/Scenes/Version2.unity @@ -30122,7 +30122,6 @@ GameObject: - component: {fileID: 1564959565} - component: {fileID: 1564959567} - component: {fileID: 1564959568} - - component: {fileID: 1564959569} m_Layer: 0 m_Name: ViewerMain m_TagString: Untagged @@ -30276,18 +30275,6 @@ MonoBehaviour: type: 2} AnimationCameraAnimator: {fileID: 1468470379} AnimationCamera: {fileID: 790387849} ---- !u!114 &1564959569 -MonoBehaviour: - m_ObjectHideFlags: 0 - m_CorrespondingSourceObject: {fileID: 0} - m_PrefabInstance: {fileID: 0} - m_PrefabAsset: {fileID: 0} - m_GameObject: {fileID: 1564959564} - m_Enabled: 1 - m_EditorHideFlags: 0 - m_Script: {fileID: 11500000, guid: 822adc4dd85200142901586dd5c697c6, type: 3} - m_Name: - m_EditorClassIdentifier: --- !u!1 &1566898429 GameObject: m_ObjectHideFlags: 0 From 0d22399fcb1b415bd33fcb9881b1ed4c349d3912 Mon Sep 17 00:00:00 2001 From: CroakFang <1605296300@qq.com> Date: Wed, 14 Dec 2022 23:32:16 +0800 Subject: [PATCH 5/8] Update manifest file Reader --- Assets/Plugins/I18N.meta | 8 + Assets/Plugins/{ => I18N}/I18N.CJK.dll | Bin Assets/Plugins/{ => I18N}/I18N.CJK.dll.meta | 0 Assets/Plugins/{ => I18N}/I18N.dll | Bin Assets/Plugins/{ => I18N}/I18N.dll.meta | 0 Assets/{Scripts => Plugins}/LZ4.meta | 2 +- .../LZ4/K4os.Compression.LZ4.Streams.dll | Bin 0 -> 33280 bytes .../LZ4/K4os.Compression.LZ4.Streams.dll.meta | 33 + Assets/Plugins/LZ4/K4os.Compression.LZ4.dll | Bin 0 -> 65536 bytes .../Plugins/LZ4/K4os.Compression.LZ4.dll.meta | 33 + Assets/Plugins/LZ4/K4os.Hash.xxHash.dll | Bin 0 -> 13312 bytes Assets/Plugins/LZ4/K4os.Hash.xxHash.dll.meta | 33 + Assets/Plugins/LZ4/System.Buffers.dll | Bin 0 -> 21376 bytes Assets/Plugins/LZ4/System.Buffers.dll.meta | 33 + Assets/Plugins/LZ4/System.Memory.dll | Bin 0 -> 142752 bytes Assets/Plugins/LZ4/System.Memory.dll.meta | 33 + ...System.Runtime.CompilerServices.Unsafe.dll | Bin 0 -> 18024 bytes ...m.Runtime.CompilerServices.Unsafe.dll.meta | 33 + Assets/Plugins/Sqlite.meta | 8 + .../Plugins/{ => Sqlite}/Mono.Data.Sqlite.dll | Bin .../{ => Sqlite}/Mono.Data.Sqlite.dll.meta | 0 Assets/Plugins/{ => Sqlite}/Mono.Data.dll | Bin .../Plugins/{ => Sqlite}/Mono.Data.dll.meta | 0 Assets/Plugins/{ => Sqlite}/sqlite3.def | 0 Assets/Plugins/{ => Sqlite}/sqlite3.def.meta | 0 Assets/Plugins/{ => Sqlite}/sqlite3.dll | Bin Assets/Plugins/{ => Sqlite}/sqlite3.dll.meta | 0 Assets/Scripts/LZ4/LZ4Codec.Safe.cs | 757 ---------------- Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs | 795 ----------------- Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs | 524 ------------ Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs | 808 ------------------ Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs | 526 ------------ .../LZ4/LZ4Codec.Safe64HC.Dirty.cs.meta | 11 - Assets/Scripts/LZ4/LZ4Codec.cs | 176 ---- Assets/Scripts/LZ4/LZ4Codec.cs.meta | 11 - Assets/Scripts/LZ4/LZ4Util.cs | 129 --- Assets/Scripts/LZ4/LZ4Util.cs.meta | 11 - Assets/Scripts/Manifest.cs | 6 + ...afe32HC.Dirty.cs.meta => Manifest.cs.meta} | 2 +- Assets/Scripts/Manifest.meta | 8 + Assets/Scripts/Manifest/BSVReader.cs | 242 ++++++ .../BSVReader.cs.meta} | 2 +- Assets/Scripts/Manifest/ManifestCategory.cs | 17 + .../ManifestCategory.cs.meta} | 2 +- Assets/Scripts/Manifest/ManifestDB.cs | 43 + .../ManifestDB.cs.meta} | 2 +- Assets/Scripts/Manifest/ManifestEntry.cs | 124 +++ .../{ => Manifest}/ManifestEntry.cs.meta | 2 +- Assets/Scripts/ManifestEntry.cs | 35 - Assets/Scripts/UmaViewerMain.cs | 1 + 50 files changed, 661 insertions(+), 3789 deletions(-) create mode 100644 Assets/Plugins/I18N.meta rename Assets/Plugins/{ => I18N}/I18N.CJK.dll (100%) rename Assets/Plugins/{ => I18N}/I18N.CJK.dll.meta (100%) rename Assets/Plugins/{ => I18N}/I18N.dll (100%) rename Assets/Plugins/{ => I18N}/I18N.dll.meta (100%) rename Assets/{Scripts => Plugins}/LZ4.meta (77%) create mode 100644 Assets/Plugins/LZ4/K4os.Compression.LZ4.Streams.dll create mode 100644 Assets/Plugins/LZ4/K4os.Compression.LZ4.Streams.dll.meta create mode 100644 Assets/Plugins/LZ4/K4os.Compression.LZ4.dll create mode 100644 Assets/Plugins/LZ4/K4os.Compression.LZ4.dll.meta create mode 100644 Assets/Plugins/LZ4/K4os.Hash.xxHash.dll create mode 100644 Assets/Plugins/LZ4/K4os.Hash.xxHash.dll.meta create mode 100644 Assets/Plugins/LZ4/System.Buffers.dll create mode 100644 Assets/Plugins/LZ4/System.Buffers.dll.meta create mode 100644 Assets/Plugins/LZ4/System.Memory.dll create mode 100644 Assets/Plugins/LZ4/System.Memory.dll.meta create mode 100644 Assets/Plugins/LZ4/System.Runtime.CompilerServices.Unsafe.dll create mode 100644 Assets/Plugins/LZ4/System.Runtime.CompilerServices.Unsafe.dll.meta create mode 100644 Assets/Plugins/Sqlite.meta rename Assets/Plugins/{ => Sqlite}/Mono.Data.Sqlite.dll (100%) rename Assets/Plugins/{ => Sqlite}/Mono.Data.Sqlite.dll.meta (100%) rename Assets/Plugins/{ => Sqlite}/Mono.Data.dll (100%) rename Assets/Plugins/{ => Sqlite}/Mono.Data.dll.meta (100%) rename Assets/Plugins/{ => Sqlite}/sqlite3.def (100%) rename Assets/Plugins/{ => Sqlite}/sqlite3.def.meta (100%) rename Assets/Plugins/{ => Sqlite}/sqlite3.dll (100%) rename Assets/Plugins/{ => Sqlite}/sqlite3.dll.meta (100%) delete mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe.cs delete mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs delete mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs delete mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs delete mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs delete mode 100644 Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs.meta delete mode 100644 Assets/Scripts/LZ4/LZ4Codec.cs delete mode 100644 Assets/Scripts/LZ4/LZ4Codec.cs.meta delete mode 100644 Assets/Scripts/LZ4/LZ4Util.cs delete mode 100644 Assets/Scripts/LZ4/LZ4Util.cs.meta create mode 100644 Assets/Scripts/Manifest.cs rename Assets/Scripts/{LZ4/LZ4Codec.Safe32HC.Dirty.cs.meta => Manifest.cs.meta} (83%) create mode 100644 Assets/Scripts/Manifest.meta create mode 100644 Assets/Scripts/Manifest/BSVReader.cs rename Assets/Scripts/{LZ4/LZ4Codec.Safe.cs.meta => Manifest/BSVReader.cs.meta} (83%) create mode 100644 Assets/Scripts/Manifest/ManifestCategory.cs rename Assets/Scripts/{LZ4/LZ4Codec.Safe64.Dirty.cs.meta => Manifest/ManifestCategory.cs.meta} (83%) create mode 100644 Assets/Scripts/Manifest/ManifestDB.cs rename Assets/Scripts/{LZ4/LZ4Codec.Safe32.Dirty.cs.meta => Manifest/ManifestDB.cs.meta} (83%) create mode 100644 Assets/Scripts/Manifest/ManifestEntry.cs rename Assets/Scripts/{ => Manifest}/ManifestEntry.cs.meta (83%) delete mode 100644 Assets/Scripts/ManifestEntry.cs diff --git a/Assets/Plugins/I18N.meta b/Assets/Plugins/I18N.meta new file mode 100644 index 0000000..096540d --- /dev/null +++ b/Assets/Plugins/I18N.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 497e7785cb8817945ad032b3ad69da45 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Plugins/I18N.CJK.dll b/Assets/Plugins/I18N/I18N.CJK.dll similarity index 100% rename from Assets/Plugins/I18N.CJK.dll rename to Assets/Plugins/I18N/I18N.CJK.dll diff --git a/Assets/Plugins/I18N.CJK.dll.meta b/Assets/Plugins/I18N/I18N.CJK.dll.meta similarity index 100% rename from Assets/Plugins/I18N.CJK.dll.meta rename to Assets/Plugins/I18N/I18N.CJK.dll.meta diff --git a/Assets/Plugins/I18N.dll b/Assets/Plugins/I18N/I18N.dll similarity index 100% rename from Assets/Plugins/I18N.dll rename to Assets/Plugins/I18N/I18N.dll diff --git a/Assets/Plugins/I18N.dll.meta b/Assets/Plugins/I18N/I18N.dll.meta similarity index 100% rename from Assets/Plugins/I18N.dll.meta rename to Assets/Plugins/I18N/I18N.dll.meta diff --git a/Assets/Scripts/LZ4.meta b/Assets/Plugins/LZ4.meta similarity index 77% rename from Assets/Scripts/LZ4.meta rename to Assets/Plugins/LZ4.meta index 50baab7..dd3180e 100644 --- a/Assets/Scripts/LZ4.meta +++ b/Assets/Plugins/LZ4.meta @@ -1,5 +1,5 @@ fileFormatVersion: 2 -guid: dbb2fcf97a52a74408ada473a663544b +guid: dd64793f28865c14b8f230db22e5c0ab folderAsset: yes DefaultImporter: externalObjects: {} diff --git a/Assets/Plugins/LZ4/K4os.Compression.LZ4.Streams.dll b/Assets/Plugins/LZ4/K4os.Compression.LZ4.Streams.dll new file mode 100644 index 0000000000000000000000000000000000000000..f34454ee0181d3c7217264234a2f45824814086c GIT binary patch literal 33280 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 C$mO>H literal 0 HcmV?d00001 diff --git a/Assets/Plugins/LZ4/K4os.Compression.LZ4.Streams.dll.meta b/Assets/Plugins/LZ4/K4os.Compression.LZ4.Streams.dll.meta new file mode 100644 index 0000000..1d994ce --- /dev/null +++ b/Assets/Plugins/LZ4/K4os.Compression.LZ4.Streams.dll.meta @@ -0,0 +1,33 @@ +fileFormatVersion: 2 +guid: 8fa90c95ae974744d86e11e1cd793c66 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Plugins/LZ4/K4os.Compression.LZ4.dll b/Assets/Plugins/LZ4/K4os.Compression.LZ4.dll new file mode 100644 index 0000000000000000000000000000000000000000..d9bfc8508956e9c0b73fa1569906f9e1bb6cbb63 GIT binary patch literal 65536 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 literal 0 HcmV?d00001 diff --git a/Assets/Plugins/LZ4/K4os.Compression.LZ4.dll.meta b/Assets/Plugins/LZ4/K4os.Compression.LZ4.dll.meta new file mode 100644 index 0000000..f833930 --- /dev/null +++ b/Assets/Plugins/LZ4/K4os.Compression.LZ4.dll.meta @@ -0,0 +1,33 @@ +fileFormatVersion: 2 +guid: 38a6e9a942b6b8948a1a92be95c5b15c +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Plugins/LZ4/K4os.Hash.xxHash.dll b/Assets/Plugins/LZ4/K4os.Hash.xxHash.dll new file mode 100644 index 0000000000000000000000000000000000000000..cd0af6d4a660581f5b28d0a7605ca390a018ed62 GIT binary patch literal 13312 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 TW3~Lq_{;JC&jbGh=E8GS literal 0 HcmV?d00001 diff --git a/Assets/Plugins/LZ4/K4os.Hash.xxHash.dll.meta b/Assets/Plugins/LZ4/K4os.Hash.xxHash.dll.meta new file mode 100644 index 0000000..338b10e --- /dev/null +++ b/Assets/Plugins/LZ4/K4os.Hash.xxHash.dll.meta @@ -0,0 +1,33 @@ +fileFormatVersion: 2 +guid: 607fe1db3678bac46bad918b3532e867 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Plugins/LZ4/System.Buffers.dll b/Assets/Plugins/LZ4/System.Buffers.dll new file mode 100644 index 0000000000000000000000000000000000000000..c0970c078522845d0ac9420f390fed5c29344d8c GIT binary patch literal 21376 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%0AL|T{&GAus z1pa-U;di!!FLs7^+QI*@V;k@MYC9RCUQLJk{zg0acXoz9-v++8*dFz;w|7wraWkMrJOq5KQ$5K*{=crS7&iZlb?q_0QeD6NWxLWv<=5MlF4*4o%*{PV zw=2D!c;aQsTJZ4L9}`h(+9A3T&eNy&S>C7j7*BiWJo;a1=N2sp~$cN2jc!M_0Tf=*pk2E5Fd@K0k|Qdi>THcRGwP=S*zLPt)?C zoO@z=rcE>OQ+4<>x2Q*l_l#vcB;w>IJK#YzftykHJ<9<1d2!JWJf@1(8olrnVDs$? z#CJJRC%g=zm!tjgcp@*<#N}1f$kyL8vU%$V&{h+MKh2i>6K3GuI@h@78g+K^DoQLC zdME|G(DREFu*Bn?f?nE*D|kH)<6=3YX?y%48pcH{T52c;XkBhyieHR$@`GM)rW8;Ke>rsE?uroLGD3uJg4HX7|5gK z*WxfDc{P9C! zh7rr#dU>w}I`muFt_8thKXkE3@5p%$>|f|vJal~QT1Ir>?FH*K^qA9)n5Ech!o=DI zW_K8-@F=uiVMO-ywqa4vM7r^)7~UwtmgW4dztjS2Hzhn{N}HJT6CRQHYMF1=Rd`e) z+!ll{`f&#CynQ$;yq)Twnp;Whh+M|Vkl&MY2)$Vp5*cdipP3VGETMw;9uYfrVt6R# zdZFQ=egp6nXSn-G@!Y+B;h|Gg9k!|1yS)mtQhJy(JTyGaUCao~b?F^^F0Cy*47WB68G#X1n%-GYZ9zL=4I)XbL*IqtYCGZ$FC)Y;pnid<` z;}_r)+LYo{qu>#N_&yx1i?~w9+p<_|@0V-vb8d6eV8_lm;ejnv1_T>S*yuS0E+d5p zPMw&O;nJpMFw&l?-#qtdO_|8`L2{9Ke)#@`5Z9r<#-L;7coqzB^-asg4U4}c#Ct;O z_`o$w=Ew73aO?3pEQ+A6NwGcV5It4s!p`-i&%SXz>ER)F3fS1nGX>AZC7rgPa=n{? zhb_Hz-AQ3PyZ=^F*a+{xm6YGVpH%KCDriGe=Te{OQGd1-9=*roob>rZe0=ys72U^k zGu;y^OkFV)yCz=cJzEFUDwdRPs-mitl2qqM0r|w^4&^`oyPpFvJklgZ_N5i$SPQ zKRi-2G&dCl8yVoqp_%kb@~qrgA8cg63&)LUAbwzIrpq&%JXlh`+*;hEYx!$P57o!H z?mmlc23{`UU3uI+BM)1h;6Y`#gwB7zpx9uV-nx2^rBlQ=tGvBLa=u&NTDo+vTRL9$ zkDFTOi>xznB;W|c;g16&k0{2G(~oYNf^z!fJu*0%HtT`$pqwO|^}0$>PK3>RgC!`( zX0zUDp>J7mr$qu}uXo|DMcvHQ*rGtZ!&ZddCHT!Y>}hFrTBAk3L6{mh=S`Guc24QJCY&QCng z{d>;OIRAb{bkgDctmTtW=1wX75FA8GncL)_hBHrAY_Njh$HrOPKy**`J_Bhrt>-!5 zIRpP6IKlp$8hqtc7^3$ZdoaJSKBn*zeD2`g?%QiQ@G=Uq*`jnZ| zXXB$yS@Y;TgFBzxOqDWIrOcS}CeC3~q{B)k`Xog?F6yyEJe=e8fq04#4;9Xs?w2wH zFX%K*pOQU8&EGRT=`wN|$SO+VOUOKJ6(809<>0lMYONUJ1T^@sVa0lw8 zLuRsc6b}Zp{~4aM!!3qO$=@)Ban&ZEYN%TeJxr~=^hRV+_4p$JztF>!#!GKh7FCfy zOz;amoJwAL!?UQGC(9R|+DmUFH`dAW#SrABH;Q|O&iCZ)*#CF5BkBBBJCe?CwIk{L zRy&f;Z?z-o{AN31y70T&k@S8~JCfe-X-CrgJ?%((zo#9oe5tx<#~IeShbb4Gdts8k zd5AMJ$4fvBWeISqc?+m@ECJ3hZvi!lCAhh#fZD+l;E@9F7*rZdfL}1Y1)fsf)>Ggq z)$Kh6o>JY>Q{XApx}E}0sn+)tcuIArN6`ONwjzP2R9?0sfu~enwjzP2R9?0sfu~en zwjzP2R9?0s!AWgJ0#B*DY()Z3sl04O0#B*DY()Z3sl04O0#B*fR#=$mPM9(>HL5Y~ zxF0Sq+2pnn5FYSV3twAWh?(nr> zF@@4k8)^xuW#MVYfC2u>m$hT@3C0nYK(S)hb(99BxdtAjc|CDl!)VN;YnhcMg<5Hn zS{CN=R+=1crOELZQ$W^QN`un80Umq^^G4#FrXiBxq8YI_GKJ#R61AALu$OK%UV>@G z~=ToVct_M}I90%`+>By`Ur10|^r(#9Y2~{9M!NwT+ z79_>ZPG~Pd(iaw3bTuXFY7YnmId%fiwU{cvRdEEW7^|q*;w+~9PK2WmEWQiw zQYtY|ST?|ei3fek4Hmc?%xL{1Y2ZOvvV--_D6+d+OhNc&luuR`eqi-&Kb>r7&AU@{ z+qiW4MdG8Bq|Pb&#O?~Tj-eIQHk2PlKTIKOlgX`$Mrm3^mLLNflq zbAJW9FCnoNXeAVz^?;7>Ai4CNSN2euOfegCWQ>2VH4S_;suBerdcvB90Z>+hSI`?ECa`}H@? z5!kbo#bix-iOX%s_-si1u(v8=sJLwU`cSST^Mn}6S{tE^IEHP?#JFth)j3f;VMMj0 z?bGlVgya0e+`L>zo+H1ELVRcsQ*mR55WOzK9DMsu3pWIm7P>3luL=_`=}{TOalnQm9>-7|6wii(@(jj7dWg<$B3wMTBrx*vx5tEd zC57ZTKgHgd*K>TuSFwbT#SuouEXj!!sr^a%_vp9#`HE>VdwcncrdYz;7;lave<))X z<5#Q`#L}9$Ua7vKF`9I4Nqh)tz7k8=-fMQQuPBHmygzz>g|E0KnsWSz^~V)Ztlp7? z8zf;x^tu#ZQ4>S>cqWCs!_xc9S(-|?B!#dmhVU+w+*b_D$|&;{Z^n^-D&v`oqncBp2eD%axOo~#{zuC3!HvhpL0;=Ra}cLF%RVgh(4+r`tgc%e#)d8eVIiz>C7N( z51^0( zoXgK#i{3sIZWx3wCJouOQ|KtGD>XQi1%{(P?ch-~r?F7A~YAs&%~22dZpgw})5kE!#AiHo8? z?SHnLtwN6_MrTx*IF8;#%n+Sm-TuB64Pd752lGe1PG%%~w{Nf12IvLw334IwTLxCj z@!k(0S)^tuC>^oE!iIQ{fH|=j_i#@0A=KK5U3kZE?$?7gh|}@)<7Lo1BbV3&eBgz0 zzlSv^ia#^^3tHYOrieYv{>JPq@dc;y2TtW25g@6Y7otx!;M;`3l5&5vkm5Cnfy|a7 zUW1q+YFP7}AYwB`Ez9b0Rye_ivaH*mWOKwwW-S9QPH4cG)&PTsi7`0y&&C^xGbNR} zD&?V^2CznE<2A!I60&E|9@&sBVp(18paBi|V&YP{90naXf%DMN>C)Op7 zFq<}j*n05|Yo3u!>@Hy_YKK)U+br@GSt*odF9-*-2m60r-hl6^&Qa)I;u`c;Vt1+) z(A?FR*xO(MV7+tb`{i$oyS>;u;$9UD*)lAEIK_M7eiaDTj-lHr_KF9X{R7?G!%}di zvDk8GV!DkSNYeltff6*}Ii`o0-Gb{*gE%0b@XGHW;wi|4I1)ko1|Ag8uxxrhrTG;Y zy)^W<1d@F%wy8*@c@{1wPVp}=iuZIb$xLan+X{*Kf>EiR*`yf=M!%Fl$90I1&ob-g zQoEQx*Ve`SU^6G)POvm{ddSB1NM$(snn!bak2KG8GrKsWfWG)x($}GUed_}pYI5gi zNe3b)cea%h8VQ7<<%EmF34OB(%X$%}Ita6i3A>62`?2P0W#oU9{Z&!q&**y~azf`q ze}~E!$>LySzQ`3{0CRlEU+Hr=5@T67${?POUtycvS)Sm4d2bfqz&u+N;aY>Rmr3{p zV~7v=A7Olhv9B+MtYEZp+)a#ca0(A{3WXf^L&kWHwUzOG#z`D^u$3?4UXJ@Q$F1a8 zpEFKk{bw0}Vmy=M)^e<882549PdRQK$NHLaA?v@$s5n+V<1CK#9AhTO`hsx;$NGkG zDaU%1F@s|@GBzWYyEV%lXw!p94mG~>)nxKtRB^T85T_Sk>2spa1g+x?Ukd5B1*Ai9 z?c&6cN6L@-jPERpKNdN@^W8qjkmJ?yKcMY41t=fPf%+eZe^nyk*fPR1f{#P|$4;Uj-$luBSUhKb`{Xa0C$M`wp*+9FX8rjA2{PDO^ z_#pUdLyG%?&xC(_@XX-Jo&QSz2E8||7uoj5e8Ob-rKrmO0oXSp3=c~=!=q7`Gx|_} zcJ@h#8sC`__zmit0UM%hnUun;0KzV$FuC*Y5W>~$zb29V-*Cw3oY&*o6!KlXLluj) z1z(^H&kmq;4(1Uq??t#6_MhDOboz0eQ|D)=L`~>C&^HD7KHHb_eS)!Cl7Bw>&-l(n z^qldXT~UO0Fg^gx7dPbEQS!e<5w2wa)9{b)^bIA=A5g0CosB5f_|B<}S8!?H=6bCw zqmpcA|0V2S%lDm&9qnqkh%EufeV0^%x z0OKCUF&HI$alb?O2;*BE_c4xJ#Jn}!Zi*s5^~S3MT2O{>j zo#W>lglQ(>X2w7t^3zD}E7lA+9yu-z7bCGME-#1XroYCfxHa2hhuIbrc?H*D&N)xB zetma?EoAl&8JW8%$`H3Qdr?H@UL0kL=QV2&-Hm(FkCsdC*En5lM*>2h8Q2}DUmVFr36%{BJYT5l^*MnWJ zWlJ0+yH(4EJ4p6`mQBbc*=8+sWRmP@Ez9Ufvgfqy%N&xuu4Pw6lI$%ln-WQ~eOlHT zNU~40Y(yZ*j%Zl`m-7cLdn=S=e(9Dy=d&yXjM`xk*C9d6F3O@b?OHY>i{kayvev#N zE7Y(f;6G%2e%bc)vpg2>@>S60Z(ZI5`;_A$Mz?wB{%X}azNL-{@ zMCKDwA>vYIUE=HBuSSK7{cc%zRFwF_E&C)YMuhdE`mGf&^!_R;PQ)?m5;yfe5*07{ zY1ZWXeN=)tgV}ZBd|w%zBo=G-ld?r8i+i=^s*14aRIy9TqC{*ou0UFr>4=R^7t=E+ zzb;W4m=fJfyuoa(_`Xk{=-%Se-XyzDyc9klx{uhyY^`WXDUI$c=Jg@jS`nR96P+U( zG4rKV&M6ul-Ctay*&_3d=mFvy&91FDJ33z+&}?>&GrCZGt=X3FInhO8JLc<1C9XK9 z3s>~M{fMoyh2_nUE*7V0mYBB)Y=ma-=k3O03R5g5wv}8x#Hp_9HP#qed~V z3RAGkBIF9N!$yhN$&6$pRhbx!nYJanJb0j(>1Jz#2Z<})><(2WHV_kQZ4Wvw!gDyA z-0bq`It>xn!$d|N%WRL?m#PusYht)hJDT}G^az0q9J7CAwi_cwsb+ViKM_4jR2EpW zYs>4@C^3zhHP($1cWYT>Zo4sB?9nnB`NoJ?2gU0WA^kVYF(S>)mKo#30A^&t2cjp4 z8aI0;dZIYpVzz|bIyFhuGg~XNQ(uanB$_olr}U-h$zp?MGeTa9K0|c7HTOhM5nsDC z_e7s5GI0Mxy>3Rxp6F>}nr7LlA4Q)dnl(G8^rPtMVwYR3h2>~(Zi6xq?Oi7HHD}E$~vh2$Yh-np@ zOD)a$3H@T`i&3a>)W> zt`!^HY);G?VH@m{EsD88EOfK7m|Mgl%~qyd9&?*$uGE^DWifY%j4F$LpOhH0UTko) z%VX{m8P%5TFl2X&hu!S*n0v&)8pvo2iM}OfqqvnA>UUcDA7kzl8{F)%nES1L6!Pl!owmLB_*nD1te*r&x^ zZdMojjMz^MB|DlqC3d?IbuM;p>~kViGy8zVm>nY7%{pRV6#a;ye)a*E$Gj|dy4fYM zuZl;9SgHIo;pW)a#nW!KDfSKVvYR~_`&aRfo9&E!OYC#A_hSDh4!PMUvG0mFT9}qy z;rs-OaD3c@1jAojNG8O4@HM&kzgN*SBW8BV^nh70r8QR9n8#$`$Qzs z5&+Kr;ZXzQJ`?dHtTg8*CTh?`v# z=POG`yJR=V*<>fPE-|t=JUmc7X)(Ua1j-kP>FYzFJm_X4RgmmEhGcZLxC0LpR1)J+ z|L(X5In2!-iHnqtnjNWlHZDqD$jln&qvWNU(KsI^Z)IkU^HH+jSk4{e{EVO|Ior*e zgQDdYi(#Bk_lcF4j-%YIaXwaV(u~IWIQfQVG|tD%cg9mj)d4Snk z+s2BseA4A%W>)SQ@+ZwGzuwY+0+ofXqOZjDmf>#pc3h^+)9gsaKjQkxA8E6gES>CP3uUQXLJT=jJCw_Z zS++uChHmjGmtV1Lg>6dsX8&^et!D2PWE$o2xD}7BTQ2?1;8bj6-EtYhjI8?uQt`I# zz#i5;O{Qqg2OWcq(`2TbsrW&%R=klB3TxE9I~$ zF4;&`E#Gjn_hg+6no2S{S9YtRGJ_e}y0;u5JBhKaxA=^dZ)kRRABh$68_%?4dsFW9 z8!2O_S&Z6Yl+4nM+F`Vu#f;kF2cI!=wPp`GZjs~Uz09mu884&GMk?GYtpVfZL^s=_ zPM0?l)2%X5?qZqMDidYkIV7`MWulDKj9O))Ok_qgoln(7ndfHhK9gjf#dxMOS&k-# z5$vA{@5N4*^H@f#cl;E&U9Vgm`@m+(b(+mjD36~dr_8W4 z=OW%5xy8-O<6GoPrz@4}`1$h3*)BFReu1>jwb;J$>i7%gnt3iZGX5gDrNd$?Qzpf) zkhb%|a1Dryua93PhY>@`_GRY9Un1vSV989#u8EvF^^ zDrsBjN@ZdE)pGSBi_K419)F$Od7;JTf~}QtOROAr^tn9#COO5;n&NMkOEh~JvRmX< zH*1Q&Rdy3YIp-&=iN8&bTIyo!|$w_(i%dAGKMtu)a?w_^Cr~_ELhsD!hZ@trgdXznc)OYBhT_ z;j@Ggbs;gF9ge{75+c-Q&GG`x#7L#qS+aAY!xN*`V9m~oPDzZ#V_KH1xjZs9UVW|E zP5pBclhnZVmh7hf<%!8^6*1&qQ!zX-MXk}SHgsxYs(Q!G&P_~HNq1VBUzfHg+SR3Q zwjwcI{gc^0Y`qe8i(cwGi;2}m*CqB+){4Y_VMa%b43%*grD9pPx9Ud>^_!7!dtz_3 zgk@c#yXf}BKI$DUJDT}eVqcZ9f#P)uTk&IwIcgp=*sT1;#Qy3=Vo2qj=(iGc)n2Xn zdeJ`;=@&}+d(kH*)Ca$ry4a|SyP^x-tTw$hph#8SP13ct;Gmxq@dY{ld(nsL;AX*8 zzY=Ag;VbzJFHyrd-an)njdgDwZ-)=nwnUx5GOO2>s+r7aE__6ks`E6X*-WXrfS6om zd#Z?7mzI53dJOC)&Hhp12q;zSH9HziY$L~`@$9XjQnk~Pf!UGk{Ah3Jq*l-w;EZha;v0wW-)giFFCz za$8`V%3_8m5K=1w+totN8j_BP1!_Mre6{P=q9XqVYTRQMySaR{{~~p-W{)OJ_rFj@ zZ6;ZlxGQXS;8HKv8rZ4qmW=P!R;U7E=<~fwozWiFKg1cm(k&~8><_9$YgR+H%FTQs zyTq*-0okQ)+1Dk`=*!&f=U`{_<*Jf%r@k~R=?e9l#cZSV+mcqRw=|>Gt<~!9nx$17 z6RXt$W-Dzu70*PkR$pqFe_2}KmFlRLMU*W`x>6n2vbW2Qh^v&}<7A1Iwol6DgkII- zjJsNev22xXU&C45{sz9^(g~Wzh40X5~njOsOYJYuFms)8t z5gL7K(zUAaPn7#wuzQlOQ`4APcW!IcO3mob?RxbfGy2u!!KCZe8(K!|t!vfHCpZ<% z(jQM+tLAF95$s0y_;N>jv~jbWJ)SPbEiM+ER&hblE$Tv!N0#4~bc^b;n9ZKO*5`J0 z6Ekb_vZyce^VUpW5`L%EKr>52O6v`z&P6E8^W zt#_&zX8YvfC@JpJIap)eT|L@pgUVvfwW7c8t4SMF(^Hh@TJcb#GkT+1LJZd364IS? zpAuV1)+H_u{UT|TnxonL{@)}$s8$n$=0K$Ku-ftrX|5HoB9+J08^j=cJ>( zX|a#}A4)!~cD`(}Pizk*A5mGa5~CcRN&Z$f?y_Y2{a#Q0L4Ep~#pc^SNESxpUo7^P z?Tcj7c;O9V6z_**KjRHI3rGnx_A=`d+e+e7LXC&tbZKU%L>eRaxL8F>tZ{~$jYvuK zl1)uXHJaSA*(treWEZ6LF&4XJt5R}|%iQexlmW&XH`|cnFg6fFU%K0TETzQge9L03 ze$S^2G&X29tniJLN~7p)OO{x;H>JiHr`d?Sy(vSC4VwKS?~Rn<#*f5c-7SbW%4q(Z z#SVatHNxJpQW@_5e9GxYp=Q^c*QZQ2!rrws$NGJma;C9{7)q93cr>Nn_);^oP^Hc= zeBZNVFFI7J)5y}SU!F>xZJeXoKF86N^Nf|6&B{BP(qe2ShLV*Q9Zi{Uq`hyk2(S)g zvu1t$KTWy7n7G%HTV-r# zwpIj1_fK7AhLX55TwHio>b1s=A6x7e+nm(vjgEgbY2O%~KU(Z+zZ=tz8CgGDEYI)mv>%L}cshXEcDmoAX+ImA@Dv5H8~v|HljaUQ zSwXDH|Hd@a+;3Ve!2j+vKQqYJV&(pirUjU_e#FQw+tPx~EpGN&TDaNI=90ai7HzI` zvx8~zW|Y5`%G-Y5rX`y;Jh4IfUF>Jt)68js7EALBxA!t1#`8fW8|;^2&ouYrg#lvs z_1*F&qnG<6z=9`scuQJU9i*2_JvJWw%k}MYDH^@HR zyfv8^Sz@$(l=(HYF0r;(xP6?ti=S)n5?k$O+b5WtQ>}O_kjk0nPif5f>^R%(ZwJHK z@x_4i>}Q*KZZ^+;jyc55oYD2>7&rSqWV%<}}T|Py3U7 zj@hZ%a{D&>dFH*Ey^{8deXjY2W|{W4?5*Z8%_i8p?eopFURDmbqh0l%&^{84qH=? z+AlGSHM_+w(=Ri}YW8tjVEPs2Y|RGSqtmZ6muWWFo|=BOd9!AZr}a(mG9S|{-0n!f z&fKNhjrP;huQv~9)}1yq{RZ=A%?8@Xr{848W?E&LV?QhX7Bf$?N7J0?x0%B=3$eGR z-(k+sY(bh#UvDnf?C#XS^t;S8ngyptr{8TppjlN~YWh9qi<-?(?VG;Q{7|!ZQyuB| zo5wV3OFJ$70W%!y*3@6_OdXp3keRJnK-&29N6Z?{2Bn>q{+KyUvzAn6`s3yT&E8IJ zO@G3?iWttSjm3-7pEU2#Y;M3s=}(zYXm(lpiu9+=7dRfRthf7YHQ!;jN+gyo7tff! zSyYx)w&^9`#XV!jGb7DU)t}9NmW(yGnP<8+xA<%`=Mv+)A|q;nWZ>AO$~JC}_@y!}0O{uDy`y|YN??Oe-GCA8A9!oAa^ z5GhjfNx!><{0{|?{}G_K-w@0DP>3fTtNcA{;i-`!K1(9~3|Lk5@KYUKQnI#X4Oa-I zfHf$#|HT#L_gKc2PFXJsx6o=YtL+>PN{yacL9b*Rt~V&JKHSz;Y8H-8C!Jp+Y|eG0 z@KgH>2e{%YadN+vvdiXHYL?x8-EY;x(((5Hp19sRv@~mot=xaC)I1@kxEVHamGGYa z9=}J&CG~{-?}+7X6K}tF-GAGEV!w6uJ*(Fdy3SCK-=$;qPftJh?*A^G-;+*rDCJ`H zVQ>G5tzX$!p*6#~SN|UA;&4x!di%*T2KG%kx%6b3G`>wvAbs!pT4k_OtKzZIQz}FJ zGQ`!FsJ&cL=|^?<1-hi(sd=mc{V3A$gn0W;COuWzywe|1MrjhdTG``wwczj3`DIUV z#r^d$?Y}XaQMaEBtb{14&Kc!?{>eZ#)wt%&GOQTAx@u?-1|Qy#4=oEcWlVwRg#_ z68^h3KUKX>Y>QL1!Z+M+JGphf#+=O*KX9wjS&5k~&!()o>)0F);kKjM9i%7t+cE!9 zVl0PKT-W$OHFceFr}BHBeXrr_CdHj6#Cn<2+?GJnk9p4dG0#9O|BF0h@%Rm~f#)i} z3^7GE&*(gJJSk>|(s-DSpE(W8z!mJ!Rito6yoO%wl3L@TrD@FrE&qrzibW%;sn4K` zD=0Nf-}2Kumfq;0@C?2p_tf`DPfU%jUv%Z7xR&*3)H<2pbDedagPxI!a;J2>LtOqa ztSA|5)laeV3~&s}};_v?7#x~>SRJewj^ zVk2KEGBc=kF0Kd*Geinj>!fgnP~WI4qmZ^zvI(VT2#Ra!`@}?^F=q1Bllq&-1Ey>XB+Fp!tb)%NDikvM^jKbR=@Q{Z?sbI&YiCQ)X(WolgdW@oUBUWB?zav z4N0kgx_S|{sp~$=vc`!al)Kce^LzZ%e@-?g_@{=2DUpI6E(Pt-A;nKP(_MI~`!(;; zBa};0olWUvM^KBL8%}-C3is|6pCwtfru08eARO*XHC^AI>i(BNvP?^QSQwt0;Cp8) z?t58epB8TSapiri*NLQKrFJ&Qn#HNj_VV{<`_IB!k7WlX z4y90O-{ZS)t1aHkqM9Bn3kx&FKCX)^oHT#SZ^iZ2^n_&c$bWq{m9vD)c4CONj&UT{ zmBNWFOJjvqQ!1g=rdFx`-Eca0XjHLU$Cabvv*u*suJk>crw;Ly&06d5Xqwz7eZ=={ z`IAdsD<_^&ICsixj3;KgW^%349aJc35lH!)fo;{5?s+H#EKK6=)4KhI7RF_IhN99$zz zF%2V|kN7r@_FAHQ6F;#7JEgm4ZSF)XGx){v0m}QP^nNisfB9>l$_wh~-GdR#5TEeaG7K{`A8`+QGWHb1Y{XA|Xg_%_ z)_MK=(RIgXrFJT`dZTxa|1LT4ace?f0~gaduB8zTAbzyN&7FE1xdlrdH@ z4rd(CIF+%1v59d$Bi?z=i5AO%3HYToFDFf`2WE>3A@;$>jFcoR4nze>}yFbDa!=~^)zzeyjIf530i2jz7920aST zUEd)N%XIwa{2j-wQk24zocpub59B5BEWaiBEbl5X9MUi`o^__Ozk&VvZVbcDWmKd2 z96}f-7BMbkyo|#;1U>iLA?T^$C4zPZ_>OUFT``I^q$*lgx@D` zQn#dU=J2QFMzy?r2Q*8vUxQ9w&U@0%<+sZ@Az#Wj)t~dfLCBntALP4=p3kKarJfbz zB4gEIeAgxoxUnKjt>GQK*6dNxWUM8{ape-4YIq z+c*~OLGY$}E#XRaSd~Ul`rqVVht%ke*&TwO!rhAUZ&6g2=b=e;+zRP#gi|_O@lN%p zKzhS(hoI+ltK??^Nk9{C-AM!Q8W~-xA~4U`3JVMZ(%Y14;6KyYjCN@<)&Sd$mlZvk zyoTRaCEP5ZMfy_g;ytT2bF4jVy@TqbklTzsZ09{F+f$NoA&}ll*vsMj87be_jJ-&w zSP_m?hu9j2*cyk}8b?@4c-SBusrGZoey-OMLH60pZMUD(?^1^fe9bO(RzkQ*wM$@3 zHBGeIICC$*XZfaz%)P*TQ+*V9F>rpuoo0|EyS=Hd%znz;!zs^~{i2?Q^k03S0v=8x z{qKQ$ko#^WjW2ucHKUN`9crVxIpCO?Bx!H0F10AZ*Jm@g^=5AC&D_?Txy*zk)n=4A z9Xb@3Y<`Q(Ksvish9oPIe<+9ymJc{$er`{U{Efx4Ur3-0vU%B_$g>5bW~{N8Mrs*3nCG;gce z?eiv5{ut@dj!Ij(7F*FLe}JFzszqMZuPCpr)^235_5j~5^?l$d#)-b8B<-%0BH5mAKg5m$BdN|z%r1$CwLm8v}pOkZg`}nVx^xns6eu93r zr1yJPOM0(ojih%zmhgMz1M!~NX#Ydp>pHj{$zQBCAQvC(NK5-*MM-+&d^PukmHMpw zJaC==5$>PZ;{fkZ?-lfhE{%S>arRNjehyj9A)B~IZAO|Ha~OAU`V%3Q7$h6c8%L`pyI;hdV6Y*r1z`#^XNhNl$^*r&rRgF zzQ!AM3HJu3D(z`!&rW_AEf|3LW?dKZp zm-N2Seo622Y(~jvFg6G6z?JBNpfw2Tgp}T{+5{_MOoP7|Nc-gd$Y;%d^rFJxBj`oP zu$w16@ntG{g6c;}d*B_CvmJQeKJm@-;~L@?gTX!8_Pu z{;Dnhi{Nl|ML}dpxSAXh4;&8kSGYojU@Nuc-Pjj+P&r{&AHoSagook?SBLDzuBgLO zv!H*x{}K58a|__l?N8xP3?Rfc3+c=csSBBEl%$LV{;^;@LP&olYQ06ptFg&vhV;d? z^2v}lRrY{qLnyp8KpJ1iA2V-K6UsK@`rDZEJ<7I_%a)fjDAZqN^{NBr<;)2U2evY< z42@Tz$(v=oy1CEw@aN^+jBrZ7$#}QIFYHNJH8E_pHJ%%*(^lB}N!m%SpQN4SGI-3- z!02(GtVQ_eVYM8-mFEUQiuRTZQna^Rq4)@&Tp^;zF-f~G` zgtWt4lA=B5l29HWk)-G>OH%agU4{w{Di6<4tBY#GcW^6bsJAmmh98l%=iGiiFOEps zh3<%?9qIP-Ibtf>XU>LQXj3C>B1&WcLvI95`7$}y=MZiwEJi=exDz5;plh;7H zL0%8s%$nOJm1>8iQtgyfs$G&wwHNv}(ak#hS?5#6LyTXu^a$fI4*8M&LR}HzBjVJ} zz$A4maG<&!=~Sw9@Ykxlfy2~2z)@-=aGbgyI8i+SoT45APE(Hnr?a#Xny8ne^2}3I z(+)+JS*RYP+Nmw5QKxz~B1EiIF9I)BpCImPWsAi6mI?r_Q9-~PRS57_4qvCj;NPGk zfcL5>;8qm_+^*t)J5&O2r%D3uLK$r04bFX!BFnsk85}I5sJ*%swa9)&ZS<*1iL{AB zimduI>mOnLW32xp>kEVQO@s7pMla|G8P}uyQASpzzlbxa74Bu+WKdf?Y*3Dy4XXPV z!vW15kot?AMt{VOGBZ%qB(nhJOfw6C8D=ps%PfWTN?SSbO&g{87UR1JQFx}GG^+w` zj))NR15$wtfHtuRh+lXD3Ze5R&?dqIDX(atO_VX#0VBjR#xBP7j0YL}29dOkaVldI z<08h(7;j?S$oM4V%Z%?bhKHm^7@~K`;7CIhG1f6ghf+vy#v;bKjO!U6VSJYHO~$G) z(jU**z&M}rwD7@^eejlhMntX%WQ-Iy^~x2A;!a>M@hmV$yaIHHw}2IlHH;(0rwExK zjEr1ymgohXDb4_%Cz^omBC2<;SS%74iy21&S77hM8hnW(BccYodS^t;WdBU|uVDWQ z_OBCniSv4IXMA2nKvPHx@t3cPV|~)tKT{@93i5vOLFNicIxFPU_~mJZd|piI^Sq=Q zeazt>bNI&`ZYYXnD2ip^TZrV}Ezav>sHepOAjS3e`?F3jj@64}_0k~}s~5-W#j(8o zGZp3D*PznY7@v!-KF=EzQiCr^5I!w#?o(rOIjs<1vdIcxD%%QQD%)M`zl;4Z`%*eH z{Yd9yzvsm(eGdAyi?GbTHcrh}fsyKgZ)bluBThlek+G6-I%6l}I>zmc-HZYwBJ>$68K*OLGOlCX&e+W;B3YlY zl5sj?C*wNC?Tp=w0{b^2ea1@0>5QF>>ln8)b~C0$lYS-RbjEdz-HalJQ)8@ToX*(E zxQ=lhFSWqrm<#_5dP=xM_sz?3BBiNjdT z3h8D{%VR0y^ipnj#&wL_8M_%p8K+P|`K~%fPsuQPfb#hFU7ae#VSC@;5SW zV9XdoA=`(M=JXMq0^>Ty#*rl5!MNYTQ4~@+nl!r^#TfFZG1iXZ^chz&uH*3SjNOdW z$8s)=>lo96{MZI>xjKoDSo3#%@M2k<(%9p5(x2 zASM%5GEQggWL(F%-SVG77T(Ud{|u_vh8qZ1-biS}dS7*izlJ*!F8v<`7zcMW!UXoL zr$6lW2K)x=jzS#8+PM(lV%<@QV^}*ESmDA07vg)YoeS{;em4{1NB-dGPq@X7xw)q54sc zFqRryjUC22#&?D?OUz5n`^=ZjUFJvT*Jh|soKJyIwa-YO2Yg=k`P}DgpGe;{-%8(U zzUTQa^j+?Isqfdmv3_-a&3@PWJ@0qWFUnSE8)6$}n`}GZw#xRr?XR}uwq$?1{~Z5S z{#W|n?7z|fxPMB(*no2a76n`!aCN}WfG+|@2A&`Ia^T*;_@KO?D}puzJsI?T(5|4r z2mLeXc+k1Q^Mfx4z9@Kk@Lj=A2fq^hZt#KNe+C~7{vlX~_=W_9q=uA*Ob=-bSsrqI z$Ri;yhU^acTgV3?pM)5piJ{q{V?v#w7lbYiy(09^(4C=Qg&JWIVcB8h!ls9v7j}Nw zlCVp{t_^!I?5VJq!`=w{TiE+yABM^B8BnAP7B9$MjR^e2lmtnMo3C(4A5K0%H`VhWQ0E*Pq_~cr;>b`m5vaf$Sh!d zdVk;{J7HKb;qFqx-a&+C_anTeFX4O+d5iU9!YQONk?_et!j~cm`y^2M;X(Os|3^s` z@LP5Na}kx{r_#X)X)YZGJU4`JeEw*lRoeCnlBSl?4!@t5aop4f_#=BcfkrP%VL>5b zdqopM%Cg&lmcOy&0{9zCI)RTCuLABbzQRjNDKE;u8oyo*$GNF+M*9Fq;(S!%4D%E6<&-o^ zjR2yYvI2OzJPkNO4hBw?RlrHI1~^&P0nd;_fm7sg;8Zyhc%~c;JWGxRPLtz-XUhq| zbL1poy*vZBNKOS_BF_R|CeH?5CF_A#%Ld>zawf1#I)T^9S-|UL6YyDi9`HFi7x=tv zMLBl>VIMgk{uhBtyd>M<-w9Osn#uy;tMUTiF1ZN!np_NgPc8-Sl@|l?Js2)bs2Drx&rvLx)S(|x*93}8JI0zF$UvoobE$7!>0<^=u-nc*QX9R+h-_n zj?Zvlv(HGJ;iE9)KMOPc^TdVN4eti=ka$9DL;D@Vh?^?gWUz|DdckRGrdp*QR+kz# z821{F8y^{;88zk*bF=xG`JbNJt8TAdZ5`!PZ!XIiJtNk zVrh5;o?cM!x&F=z-$a)aXyN%+9oP|m2Y%hPVp2H$b%b9_7aUH_75_Z`1`dVtrB8g) zPvCAU0Apbo#=>y?ZWf7=lD=aUiC@7YF=9r-+DRB6lQBM~WAseN7?~j|(etbDTUs@) zur)Ypan#|rxFI-(;uwZwIF1oGM&cNSV>Ax>ixVMqnZ#&qxhdLB({8$UGqjtn-E!>? z(r%@8YqdK}yCbwaPP-GeJ5#$(?atEfZ0*j`ZZll6V6*rE&p*SCI{bX?F4XRY+FhdE zi?n-CyPs?K3+;ZT-NV}bmv+C=?zh_gPP;#7_b2Th*DhugY(GQ0KHBxuuD^BzwTp`~ z>xXJLT)UCljn;0gcH_01sNH1krfS!&-Co-5t=&G_?W^4!?e^F10PW^$*P-1a?Urb_ zOuH4@Jx#lVwOgg#8tv9;cPLzHx1q8%oZ4-;=EJ4cjw7|+XdOOU>y6cXtkxT^^(JUH zQCaCGDl6S&&671B3r_is*X{)EPSWlf+MTN1v$T7*cI&m z?yK5;O}lSucQ;(J$8NO`PuvRemgaA1{x{Z(6Yp#H@7n!PyZhJ`;$zJZX!jExeo(ug zYxfH+|4I$O9tv^dEA{tGI@=FxewaCC%v%2^?H<>zG<3h#u8(&8v}-pl`5)k(D?Y$_ z&JbL88s%l;ZTTsV#aN}>CSFmy@hj11s?4~IUDCVLSS%hg#;Fgm0{DR#gX2sbQ*exv zABY)n8*!YDV4rpT*+u zKG^LTWiRwyEXsYc+HL-Tdd^U9%SG~Sd5?V3cO%?~a4cg!!|!RhFUW0v%aH!dI2Mb) z`rRY{hNIgr9`2hsHp(#D(>Pv6`Iq6CgF3#9c#Fk*w#DKT9AD!22FLf%i9sDGuMfm$ zaQj1dn|Q{5v3SA13So;l{`>y%@_qkp_QE$@#A0Ye#gnxkW4-ozV!n+aPjqq-ScO$$T;oS(2Mf=cwM>4LVDL7Jb zq~WmRz;z6>N31L2=#3*2M;{znIQrtq#*u@gACCSwa&Zj6k%uE6M*$A&+8lywa{#W* z0k}2?;MyF3YiWoWi@ToF;ZB4*1@4(R&Vpgii*a<~ScZ7Zaa<~RTbAlY9nQQwQ9mO;Pmmu@ zt#jt+1gP{DJgag$uBA{%`Yh%Qdd`8 zm{(0v@&qzp;Izt>mrrHPx5`NV0s;p?Awo;5%Zl@=>&gns>Po7ss>|}K>I!O*Q9)sG zX-!daO>I$Oeql{M-m)K3ou8jyR9EUK&U4h2)Rp8H6c$z$4=JcEbkr3TRF{(| zx$_!0E(F6pDKVSBprJ!6vVF(3wl+h+{?X34t!;~Rh&#V|4J}ZxWTP8e8fH1$C?zXk z>;)|rwKBE*)eFu&*V%SPTT_R{brCvRDdJ@3Ov^LQ*+vaJnHr`Y0(XYGf)kvx<~mzC zAmPG!=r0v(oii59n%v~P0ICyET5oQZ(mTWz+mav(`hwLv^2O|YG0*B3c?A?+VD%C5 z7Z5lKP|8`r*-e1vR=}j;Egf*s(W@F8E&r+eZy_Z@aLOKDR3IERwN)jBg=N)wMWw}6 z)uknlnv$ZLyuxbqw%Wqd;=& zhzq|QMlb%@Cn%OPev#5^nK zyh18Pp;Zd<7Z5lI3IV6IQ8A)4v^(LTF@P9h90dy<1ru9As@km%M(qMRv2D?i*0#9~ z9lzw3crs_kCBO$&PMu{wgfjp* z2?_`t1chay)=^N~bpGhp#{4=E=S&Z&pHU_TLa+eCrWiP`t?B%R4(IT>^O~JBlHi)s ziov0yp{coj5MF33sCJaqmKHc1dByo<1tqm*RW-GBMHrfk>WWM2N{Sps#g3vXkylpa zs2x&NSXk;PC@3qcE37K2&Mzw~C>>H(gdUzhq@bv_3TLWl?`UJF7DH>OZr`Ud#*=;d#;z%FTU1DPs4J?fswvJZsq@5}KrP^*Ze|qG0M`?9UVQEp7qX1(|bqR*MlG^IhqPmj2qP&ulAytsq4e^}Yx-cBl!|0=$ zIy#!2L*1sXMR%YE;SgOB@1P!$tD9zd>sb}{4$(13xs$hAc8r^I%X+BQvdq0()}z2J z=_U7Yua@nho?kph)YjDuA6+%7e%$HsOc*}aqcC(q6F%eO>WSQ-9!d?$tfw8uy7gVg z8hh@!?aq#|V#4Vp>Z#2^T)3Xv2zRGrS!GHOUR=oB+YCJw@{2v3N;<{5h}GBARc>yB zz(k~@slB~H3~#~AuBj2(H;6G#XXEJBHm5}}9Bc0^XGgtNi;1lhI@+3AX0gT$F=0`A zhjVUjO>1*AW+fOM+H;3GF`;RiDJahHc55O^gADa{I5iE;GeuQ%bL&je-ezglENE-P z=weNc8Yj+f!$fU(qZl}-xxT&$v)87EW_KWubI5;OLnGOP<|33hrVirthL*RAUJa9+=Lw>8C(LeWgK~R)yXB!UJs)dopV!(B znPp|RCu;2C!y4KeFF@R?nKPZuRC`EJQTITu6|352p=>Q3^+V5S>X<#Q4UN=pnPkF( zdGlJ^D4JzTm!`*r+DD%Hysv;OzwRnzQjXdC5hZ=X23 zp=F#^8oK3a6r-ECi(pPq7Nb)d{rm!U2cGV1Z(Yzf(@E7BbY6XZb;Hc_(7T2-Ih)Y| z^^CdwM9CQE!j2O|PhZf|g4n}b8l4MIlv*u!LO9hF9Y|Q`70xd`d#5lfioR#)Dbi)@ z8OZbeoT~!iK$ktvmGZk zod~1R1#yQb=4!X+`7?Gw$Jlc*P|b3B&Lr1JhL+&E{b~Y!( z7~aB#|HY_q(h|BxlZmaZqZ-;^kshPL?~6hm)MbWx_xR*ak;D^bHZ)UTa`{}h^kTTH zb8t6zllpo3MqfB@}Nui{$jXw;pK$@tRl>vfm`v`+SUam zv#50o?+zSVGYn@7q`EKh2-7o&#vmPnZb^)0_d3KH2{fsnZKX8>@iVe!`@-v9fcd+*dUGiT16bLLFBIuj~@Oevv8mY+03 zar}fr!qVW=k-CwZjd!>K4=Rc^otj6ZPvUmWPqEe<8Pfov#pc*(BeQl$xqE`s7UUM8 z7A!>Q#cZQNFC}1ap#^Ui>^=3EH9~#SrAtheD)%?qK-HP31y#qG2&O=BfGy5#NCbLDZsxZ0K>F3v*2rm?pl(ViFB;1?kz) zIifT50MHpzel7y$t6XE{@a~4l-0Xaoq$h+!K^i3{b6O0U8zrA#IiJ79$0qKfsi_6J zA=ymV0zpXm!c&Ug5F=`jRs+jh7-JR;L2nuYwF0PPDjk?KOjY3jVNlhKG!#j}M6=Sf zVH2wm*uH~rax$b8;(>6ca>2S`)a9k-7R6!~3o1_uH9?(CEhG>a#Odj}bV~@Kk=Q-c zXi0~%MD^68R@oWZR09$omKd|ECy4>G4=P8YsURg+B5z|1gg{}r6w$^o=(8Cy**R9( zg!WP~7EqONV2P@L2TO$1?!;`&=Pbd|7{@8V9K&KP)L@KMOKe=K(U7Y%S%rW!fobT7 zDY=$p(Rzzps#}+A;L<8QVwg#%C*{(TRH{-WaNG-hTxDdmK7(1GSdo=dK|?8ok+cX( zNggIMWni^}P(LZwcj!Ig{AXr_6vl$1QCG+M%l6$xsSB}}RcV=Q_r0HQQw;il}= z>|At)C7V<(abdJ#m{k<# z$UcSwwjvUjkvPU&tCjRDxLOvMP@-T#uk^D48 z;i90<<}(*?k)2nVCnyh6h?S3_EoGQhh%q^@oS$Z21<*YsiSZL~BRvRITn1-WH8VIu zF`K9$IFv+Z*AnI^P>Uo-K@nm_Pr5L0L|;N-s*za=I3OEx zg&;wU&?}wkQRE6kB@3`1Llc1tI;BO|jRULAP07cI%hc0sH8$IrmtsPOath@?NKeQ! zYm;w;N)&_%kui%)$faj2MlDyxNG801USNCx|4)|;u`xP*CejOWf>AbIu*!-tR0+|U z4*4TGVG5C4Y_?_gn5Rf$2udUZ5g?0UsTd@plaZ|G&bLg0#SqlW;)+Whgi!&;Umyjh z8zol;jWsc;V0|KVW#k%$S_K9LR1xSKR3VTJ>k47XxdN6j6*bbF33Ff6LU0m(m^Ohv zC^AOt1$Q1T3}DltA$1TJMvTGOIZKy@<0t~1GfoffD!)i@!3dPYh8JMOW%MSWK$a*m zHpQ4zeqt>JirSy#WqeWcuxSR%ngB9n4pNFpX#xjgev$!U*`Nu)?}3HDA&7-kkb>A? zlRQFgShHFBaua<^uvjBY0IQS5n@43aiX!!$la%RL*v+%xm!OKiLN;9yO>q^cDT0B{ z41(#2oMcZCd}d=GWSX7^A_zYh8krH(04BUJF-w4z4;2y2fQy^qe6dBTO&^ zk>bZJZ{X_weu6a{T?+ANRtW|At{6p`-khh(7^$3~fQrBbYacRIjuOkM9KrIuF$-1N zH|UM!RE`qMsT?7dQz0hWSP{6?Jgm59XI6>Ba^YfuRi$RwtCX0U6ckV{*a~mu!p%r4 z7b>-+0uZU*zCo2!3ur7CF2b%VHN&|ju^vQ3V~-Z6h?;~M3eAC~kOU}VCUbyEilI!_ zcGBd|DSExZ1j~4Cl*Jwur)OaPBC$A^6VinmS#khi?_?v@s!LIRmQK$x>l$=DILW#u zxJYUk31?8uIm|Y71tvjLG3bfKv8G9eE!a@?v_pbR)n(#ofYymuR|pucryd3sNq=IQ z%yt^)GYedyk!%ucNzvV4aZ^j7b65f(>nxt+e953h;~RGJf+DH9U?yf3#F=23?FlT8 zy1;(^=FCh6(v(6{1S@3!i}>;lAX8zbyuyk|`6wY96T5K*=qL#Tm?vaIi38ZbnGA$M;sI4SO-fW zhc#lsVK8Nx+g^c~v9Ome1SP=I3&R}}Rz=oTrOSj|lBm6^co^5AaOV(2P_F0{)&jcd za$!pqN)p|e4JVR0k6BqUlNR6NkU(qF*ir;?(N-QdIt#d=Y$qT?o4B-zoRTZlD7liw zDIbwAEOii1Fz+!qLfgqFi7}>|P=Hh+X0YW7jXJ@RXb|48;u&C-AS0o$Y8?*QFU-{h zvxP1nMkI=rHcFD)JXNT)FTh($1{}0c?11e85Pf8FU@)r4XO+G}VsF|9$$6)-7vKo{ z);Ln?;!OoyK7Q19U9iH-Wzi$l$c3gFxfJ}wf!D^4(&8YIV}T)GS{sxgO3~E8)@z627=0sePKE$9(h4j17PJOodDHke z4E+t62n$t%W86$6AF>gp({$XbxW8GKfMy9sSTVn$5W0i8#%9e&SaLOTk;9~+Z}b); z#ff4<4{wPF7^QV1X?fNtn*NE6W8Nur57bgv5RIH*Xp?*(R~E_`y^h%sjhqSFN|?nE z&Y=df{uu>&1{=^3&0|dj%L*(!+DI}-7?RBN4$C~HXDYL>kH#q4uFTdvMjTA9!O|C- z_+vX8tQzHmQVKGSP^Qxg3`RqS2@A?tI)I(7$e1lOC^0)N2N=S{R&WU_J|jh%{}NV& zwIOWVF#!lITQT)Rw63FCjMW;=_I4D0~g~Vh= zf+bKu6$wuCr6@wp!%=L%w9YDUU7(b$BA8IF6hee0xoOHIxdoOh`4S}dW-dTt8QucB z5h_DG1{5mJ9Waf6P!N_%g&2WA1vi?CwBov!Fp<{7T)~;`=82#ZY_AX)5aYJYDQq?n z*e_`bLX(Kw`TJo9uPGb5G%LpbWh7+{3iykxl_J>`TP%aQp^~|U=E_Gz4dkw zwmd=G-pwhnKZI?WH*)d0g)~t0c$(E}X!R!e(_xq7deTfu;$z)(2tlQ=bU~&}wkt;H z9pVAjUWvVlvF2Xnk~0{AVz*0rL0ksyR?wvj${1&)Z7`q{(F++Qx}vbDkQs4>Bq+JS z9AM>6HVBCXbxM*;R-@M}k|9pL(I%aV(VIZO(2w<)CzFa=#x>QXTiW<_ik zEqbZ@iG_+@G}6kKOl(z*VfO1#qv*rlH8S{%J_B1#p=~+|S=kvdPiL68TzW9uEDPh< za#)3x1W3M0du{|nW4J*_8`dJTO@dsNw7h?m1M_#XO=hPdH{7r{2ySzq3L`TCbRv$+ z@`E-gz&a}0$jH2W5^U2J)>JIPY(Q5E6-IKUU^c#`Q1qM7>Nt!|w!|rj6{F-s#ToA_ z-<47uM>C@khp7r4Y%4 z6PHmgm=-I_1<*PM&O#7Nm$G7+8`e9lBQy3SXclIV7#N`+l3ie6OJtDwDaJzV24X94 zq3MGPjV2mNQaGCdS_PXY@zMz3AcCM8BM0klbLX?2yF(@0T2;J6-2Q9LQ%KDh_xM(o zLsIaG`}{?+HvlHo|3xlq;MPgockoM27O~2fNV{YUl+4;o##BrbQ*tA74JjscD^qca z2v~G?;?=pZ`c;e-*n0V3Rx0T~*knde@-tQ~&e<*7HHFY}^WBP(VxLzG7EE5|t)l`U z^JYiEOKT>Ai%i3!i^N0)c4?-Co=^UDQfjC~PgTOgs<4T}q9a2IGZ%1d z;gR`ihb@!n%n^&#H0BU>&qRt9-J-_l&BBtgm&?SAz%a!OC4(-T5BmF&?r2%Sgj&JE zE3RQm;T4xLDZGl6ObW)*Ez|MMa$4|#cL)wb115pyjlrx@-34U0DDk_nusB%dbd*w0@?Y70xlXhrOEnrH~Rh7d~o z&_VT>2nzm0gZO6LPjE-%dv za}cU8s@Q+RW`H+O4_WPn(ZO&iItBeh^n@Bk2e2r*q){$<%QJE@uzd&rrSf@t zAa4rJQOBW;xfN<#C5(1|oj-xg2RuD)S*fD@mgV#QWm+Y*pNr}ae1Y2lU$77}EK+OJ zaT>fcD+dc=h$nY0{zc#fcp-CR>VR5EC2(*5J2+7&!-Sh(Qh;4-jzJme2q_1#FZFOH zO3Oox9;uVjTYB^m)g&9~6M@Zq#Pw!WlEwNyo28^)r+%%vWn6G&$l-uP{Y?1qJVVcBHYAxYm{H z5QbdoxD|)W%44-4>%wNfQ_u(h{UDP5ABlxmsU)>+0od*VN* zvXkMCz~XmnsBE2Gl7y_bYUxd}#qYW#A-~L)Kz8Dlb{dq>3FWKRwNx(lNQ*$V@MmkU z#y@*U4)vxa1cy+;*Dv1B>cPp75Pk^)?ss$@{h5m5k90jUz;~4%Z57MC3o}7o;j<4a0&r5Lj$RoJi)vQnvdnjIXvCehl z+*P)YF2#$SsMb!PqD9Q(QoIz+!&7a`q2CsHxRi_nIk_u2pwk^FmN^k#L0Tw^x`==h z1eIK9uh2>l)_p`_VyiVgiX}ffPQ(w0j#^8-j}e zfXk6g2HbB|qxFvDsI9`MI-KMY&T{eL1hgL_o5h)v> z#3{(ZurBs9^*O7INY@l^CIAni$DJ@_gq*^YI^q=4q5m1`S#L9nC8EBA7?}-Yu1;Xc zs0&Df$l21V?snAC-~jlKA%`c$i9L=E_n?+JQ?t=-VA%uI0(Ppxcpz*7NABQZ)cXn> zB3M>GYKcI@RKIWF1IKV@ybJw^0jE~i#-*>$%G%C&fF5ewGq6hbbhlU8s415Cl8Qq? zywaB5&Pu#hGFBlpqzmBMQ0>(uXVk<5Y?RK7;ejh6)Lo^rMQ5Q3hk5j`<%tsA)#xo5 z&`+T%HrkODoy-EeXFEG z8YiLRVp{aMz+{Bp1dT!Pg4sZZK;)v*Y8RCQY9s?$DDCZSNm@}i+F`VVFr1YTvNBtH zf$BZcvodE0sUjxmU5iiRzl_9A$$V%QBz|0r?3fzx0K)5}8p+I#V-x~l_O^g;TN@Ai z+A5X8-qy}p2~MSSDZUKU*RHJ=JlBNR4?vO9jvi_-Khky_9c@So*7HDW$Q~7^APMAw zSX&Gjm*OknGI&z^C!meBGzytB>M@hLL~U`|gU+0hhGZi3#spq&tC7o`9g#@wq*6kX zu~<*89%IBF6fTF`MkV(I+6aN@5ZB`SD1?m*N0K+d87}xD5l9Rih$d_hYY-Wok_lYW zaD)_$aR|x}FG@vEa1#hB_5#yqg*>F%WAG8fqpT%R;)wsafX|4&>dL>MdK5^>CAvf5D%;ROaKMAcE*Q*+d6 z4-YXLYdrFJfY8*`9u6?YI1e>+3PAy79nAq3<|sQCjT5PG=wo0J8KHQBXL!&*F%gEj zfE_9mVjjw+ExqjR?dz!=Dup5W1VMCntnHK{C)UPxMP!Fr?9?&gHrpV4JGYK9}O>NI}#r zAYXbhS`dUE;Y~=!x}1na&2%>AQZvnultC6o4kiKslF<*^F3gt7pQAwep+yys6OCR&?@x6n31 z7$J^gAYgb23=Mn=BbAPkrp(69PGutpGn#Fy7Wm0*8_ZOSXA^@_f?t6n%a!PLsI3AC zSA)ow+-f(KBQZ@dQMEIZpm2aqD;!mJ6r>ab9WnP1lToNWAx(%!5yI3$VdGMwM4581 zOtn2@Ff{3*O3BqAPE-o@oz|;&S2(O9z?%5wj zTK<4zI~gj+(8EPQ{ zl2f6?15(S5w}C@#i-(;(e0EOgI>IhmfqydU2=XJ!-cAMd)67;RJ&X#KQdv*QxB4{fr+kKQVpQ;~j7 zZ#DtM0KEXA;KoDs=V{{0%iMUN8)_+p3hs>+L@_#()dL4T1PIr-CP#x-?pCe;+``t+Z;zV zP(hv^R67N*!zn0Gfzgg>1U=|e6bdyxfD)Ko=s};MP|#N>6!Z}a1zj4hz<1<1g+D!B zzkWRiQ(mP)F2iI~fh)#Y35Y5N?AM&a8BYE+pT>tMUcP>v%(unYDq8X0d`sSk*C@t( zJeyNBLTl?kk^XM7^xkB{PG`Aj~KH}NC*QG7GLxuQB% z7a#v1%M?BEM7O{?1|Eu5yarN=7kTr=?^Rf>V?2U-HseT@K@==_MTP z4)OEW(myYaxQ#nRFPwTbo!9AwAQ#In>k2wV#(RG0u1x)#ABbB4i9obIaKoOvc8$($!>A)Z`ygt-U4EF=REgniG1Teu(lLHD6late&oIFCTBhYUK#^M!LUfi@V#0$C2@sihE zoCP3^8`NB?9ZD8mm@E+>As8O0I_5ZrI8V+64H4qS0JW<*hZLd~AkusaKpa>O(W4gN zOFj`kdCS4K3J~F2ho}i8570tIEIvv^)iKwQ+Uv|9us)Hn>8z$^hzJBtlkKeGI<&9GN4HAAqJnt5QpquD;_I9_NtVVF?qjL8Wj5cYt{4TNMBfM}F1(UlNw z6<`$|j)7Rb1G%MW1c2yRW=9MX!J)R}1QNx(gvG)kV<3 zke?+YSuG_Zw{;@&3#$7mxG)0|%;`>&4c9s?(-YVf<{PB7BV3a?6_!qjI_To~kHL)> znb}A)Rfi@9I9fBW5 z0V^9$DV*5=K&2>-oXl%aGzBkZp>$-SWxru+lycG`)=n_x=5b9cp)dQGcPZPr~0_S$Dk6NL7F@r=^ zL{=7@;b0v`)&nP~8!VMvu$_oWC`z!e(3q7`E*9ho@|RH#(MM(# z#ums_L?epA9T`jzlmL>ri!j)fz?VShN+69qjMqpWfCalo3@|Q42xD6Cg4q)_qslB+ z-~m(|;7}h3Y0VxXrBHw;gGM>Yj~L-elSyE%jA#@h4aGC7i!d*zz9wXd({u?w)deG1 zN<*w1Fh+_Egux2bAqF4~RYIs2(_xE?QIs2|%&fmqs`R$lA=GM%=|NrI4xx51TPVoR z0TTl2I5*gcs3C$e!46KzEeydwX;@L9Fh|A$iyS}9I-yyyDQ59(xgBV*cs64eAU-%9 zp=r~+nN3EEXTwEnJ#6U)3QKhuXo|;Ca&!rG8K^*pl?N8c{1EaOq0UfSiS*SDoLq`S zQZZ5q0+%}jG;u7{85td*0Sh3Z%tP;&@%Aj7T#)xj0Zt~mXgHJ1x5pck6w)tfp^)s8 zYFi>fk(|^h!5Lo6B*n^_0~{&^V8SSdp~}c2rCL|1p0Gv1_sV8E9Qb`3``6;)> zOOX;JY0L3KbTdm#}NNs5smkXx#XkV@(zp?@UEs5J-y zaiA|}z>o_}ihSsi3VvJo9RXNKjZTJ$H)p2gEQpGO2SyI^yKweo?w~(0#E~Nx`x6o{ zQ#$!!7obwDVWJ2GxtMDOt(J;4`$5z1qE?nRR4eDB7J%K@2vruO3iwxf09VR4s~CP4 z%v)J2WpWxe2(gr)C|80_IUiZREh+8bt7gU*@>x8{X7M1G#e+;12%sw~c&c(f>J3Xu zDCAaUA)f^zvRORHW$_@BD|$=pPcO8)MC~lI?qUG4!gYyI9~e=Y`2~GJ8h`?GXWqsJ z4<&hF`orvlcmoV0h+xp+U}_T>5f4fReZhf|Bsf5+f&=6W2Tenm!`a5-gz6-P+F6_` zi__NPgi0ccI~%hLs)!h7XLhN~E?cvU@}hK%TFNW9D6in6yn>7J3NFekxXAowOJ*l~ zW_xmgR1mEuVChJLwqc9`p)j9FK4)81Gl3x~nql%JZwBpOjR2Z7!6Q=(v9Mh?BPEc< zk!HxkN&90VObu)%?WLeNww3|_SQud7v3S#rZTNsy1M^TkpyA+I1d-rqi!{QL1ajCh z&{PI$0rHKn@q@Cn){s*0skgs~=gAfIGBf@K6I2Yl0z z>_CaKn!O8B^1EA|o@YmLjl7z^)<%E$;F40OZ`Csax){$nhz1F9(~1|qYkXocz2IT)Zna9o^Gh2Acy1pdCvR5Dvddbb#8ABu2a^qlO#qB zwzA@~S6#X{7R&Ih%mD8oZ+~BZZ5wZV1BEMI#dF0=tiv>&=m@qctf;LfE!R+(j#GoC zR&4@&{R92eGt#u|4`~W;qit4O0LSr3qt3_A+qYG0LXXaxP6-8RbSAK^Cd*{XH@5Zh z!CBj^!c^}xL!M8%!34vKPZ|zEWDN5$;nbp!zaOsi_YL+B&PYx7^$X1K*W!yPzG-wT ze4A8Xoo_&DfX+WS5TABc62`f@z!;&zj0x#tH{cpyps^PZuhN-EMPdQ2I%A=@gafBJ zqxGqVVPYtC5bH@e$jl}5RCq*KPkiq)7GG%;&Mh`;t}*B}=0g+McCHzUQ+=A0+@Ux_ zrNNO*!%z(Zb<*7x-Wu#%)`Wy;a36^Yr?r6fFrEv+W?tzS=)VWa+Kw7V@LVVBYSEd$ ze_x%pJQrB0I{yR|KBUWYp&|uKhk|hy#rn*!w?NrALQdB=wXE_hHu#Dq*Mp9y8c}&u zmWHk=OveReASUU^tp+ESHMmelW5iu>>=tj}6WGo+YOo2OZb{S_GBiavq^AL0u~W(3 z=*4>Y%2>G(WZ@ds8IFG=Na(1GmS#z&~l%b{1iNZPe;rVi|<#^!Ndxs0t)C3Xz3t!9LH^ug#YTtPMp48&1E*WRk77!*Uc zT=sVbX56p7{ACYO=XCsXCCrO=3>fL48!(WjqYCH>yfk@6jI7-3RExzj;GbG7Q(L!A z2}}#bM=<;YblNt-jVc!=+#oHLnV>TfgCjdK{l$ld)BnwfyO!0x_FysJzHCjhm)Fst zlyi5spRCF4xOCJZW#J6R51ltTjrQ@VxpVr!nkyZ*wLN{-r58SCi7$h3_);gweU0~W zG}uvKp7@F>hc9{J2me*Leei~Hnv2HN7GK+_xIy(FZLS5lww1H~(|xh^k-bgj?Eh?Q zaTYR1R?htYWN+_Sfa+5j)c>B%(|Z9ttTOO_yOXyjdMcnYn7`jf3`WPb_~*NTbCBHQ zuQqMZM}o*V?UMd?d*D9@sQ7;e>hHI~t3lQ+{`tQ0FiQTb)U8clZzXF}AAw|08-jm?*NY0`xH02R1h19!LpR}jXi zlsB)9(5It(;o}?(&D59z;S(L2bX@lfs5;FUse~}5g&1&X7X-8MxKhko~6wmt`V(RXcCw-mYWt(IF`g??w6Ry&>B`Gd=)qt8y<*0%I?M^n?F^?vul?tH?z_rL8Ge{byDN0#(5IZWS&&BM>Z--B0 zOMgAdt&x1?-%(cSI4&9UB-~~jiwovCrt;`??1D~~=XDbRaSjc`XS^b#x_3qQRUrK6Px-KI#D|=8*Zl2zdKN#1<77iIYtZ2B_*Uvv7FsOB#;FdnL zi2M)#Iv`y~Az#~e?L)*|FzL$`*!`fkwX?70;OOM+;_6ntM$KC8wS@$A>Uz}ktgmU% zuuNFVsn~n0?vw>v^INW5dwBl&k2*UlCpTaJ&GN5b zN7o;A;E!kDy*G9E?QhGf&pljo&E{X``8AreZ>`h2-%q+*d@O3`hqsoWU3qwiZ0X8c zx5l(wRCC+3y>s84zPQ%eN>zk3~PfAjUnJ>E~PwfFqv<;s^k*BUaC`}lt-}&Xy?PbPGA6|R1Ie|Og=2FvIi<_TllsI(k z>*=MtmWHhQzIZGb=iBvu`ycPuy5aZr$>ev=4XZsotx0F!eT&=uFmTNjkF^^P4;q{L z)&03i(e^tpULHKDO>k+{tk1ZYb>>Wt4Ih5v=D+PN3;BpS1uA+on7@mEbI$))V#MKG zCceKA-+u`2PVl?`Anav-j_^kLcZLd*_|>c3$?)9eTI8 zJ&vYH#ZNT1w&GppyDItS$rHk#{kKcwD|Jo)B-aJ+W(&yW^H_VQ${n-7X~A23~Hw5Bx>R?s>)EhLGcO-Mt}Eb20zT&1_!3e9-bGwjz~~D2p@5H5(_9?jcL#jjHiDCB zIb0cc4%VoSd?CM@zsgsaMaxFZHp}kHJmm@U3G&_YNAhNh0ZbaQBJt&74(CrfoP6bQ z29x8cGq&M(4nOK3n6o%v{NnJ_<0t)5KAO|@!*3XVv+$!1`3Aqo_`wLpY4PihU!IuH zh`Qr~Y|e!C4@LW7G2$}NexulaWc$B=|D!MfTMXLcj`3Q)S%NiATSYjf>w;e&jg0%j zicWt}1R%5*mw>awy>RBT2VBuy98Lz)S>oME+PL)oU(-b=cXH)5~F<@~xK}=`V^*F6cXI#x^*;$GWif|<1 zQ702p(aGb?Dj;cC8ZFM63;zOeJ`^~>sZyL*V<)HcIO)8s5#i-evRY4lIWC5)Y0e{@ zA}<0KQdoYf5}mhALtW@}EuFSEaT-JMr|oS0HLdyd=WQ94l*wTOE5uW)E-OCr83&$H9obe6sl{Rkd!hEP@Cu0yT7 zktPCEszIsLzf|5(*4J1^;Bxt;m0(uvr2xRFs*f~WCw2=1wZ#Ni5!V)_q`_xE?ZC%T z5}lN9g1B93zFSk6FT0G30n z9>Io=+EJV69t^rILIVy{epC>?wXD6~DC>X7pR)`bA~`OL*!BPY`~MvV%E)*klX2S8 zrqgU}Ta52A{+R=>l9iP#mK_*0Kt5(%Q;-u1v95R?KOAE96yZCyK{*oKkq zzX+eUdh5%wQU{c*e61~&-!8+RcbUx1A2sapf&c2~A3YAfL_H+yL14wo(*8T`XkUA+ zt&O~=!p2S3Gr`wQ>p~v2n_ce|_OT(8LGSCVb)-O*o2rK{9eQoLucy|7LhRhCUheg6 zrhSXz0UxgX zX7#zSC7+indJjI<5Dz@gcmmcS-m{*=*w(9v~tCg1YFt{v;5UW{Bb{_?M;k)6gzhqf4fvHSAxddJE@sQi*r zel##LTw5P~U9XA4U0c&k%`s};Mh#lW86>$}TaOYrDrzdK2hQl{68gb~oDJKzb(j6@ zIWn?V(P?cwMY|}XwNXnWw4HsMYnu}B*t=Qn1~6awX~f|K+@fvJ^vF&#_}0``r=&_Z z2S0x;%uOu=f?5X#w-##Dh-y?^y^B8m$9U!0($%$Ew{EyKZ{?STvX8WhRAhZcthSpr zx-6-^cR)(4j-U^UT))(<*;{PPQT6=#y5E>jPrOW&qGI$d{-$nI5gQty^LH z0phhOQk!{R(NmkCeOvNtW#c3Mwg5EC_%}tEwAHBMZan{5A%m__elW{Rv6xshy7dmP z^q5X5-(2c6YeVX;5-&dUo#cLVo=5fd9e=9%8uvRBdbBdd92yXM`NsUHGkd2WZ9e01 zQk`V^gGsZyOn$BWYp#};=#pPo?siT~+<(<_eMX*Vl6 zVPczzm2um$?zR1+)`HTqdc)r?3z#w8W9#&tF7JP~NqeiW=IEJCzuRA2H|F3FAMcn6 zHCrs4^--s z{&xyX19Em3AJ~y`TUY4OCTB|Dvt`X@d{_Teiz&x^TkcuwKBc71z>l}Q`0DJRPZN{A zTliq=>gevTo_yXd?52Cvq}GEQ-Tds*r@OYlEUta|y_tjjchqq_U(-?cNHuxf=o16| zKDF!5b%^b=#dGWQRZlj4H?hClf<;aCH}>_2W(=X-K5T6H&d$zrj zbNKx5gGcVAHC<@>Q+DI($r}-$*<1~7;Bs`6GX0k!@qg5E>pyPNp4=G&3Sy@X^}BVg zjid76YL}q8H>&flad(gW`n7k%BNvNyw~xN%?6>lqYqqvjH5_6fRS*GoDUQ?5Fxf1x zKrGsl3I7q+>ZjGxkd(VMx3K;m2CNu$27L>sg>;(GLfkJ+--$E}0f>Uu+BSaLz+f#C z0zu46k|DU?e_cqG$|{Qk8Hod&xTG<+=HVX&&K}-tFX&g7I>!d=e6+1kgN0#rTjbpB z7r**5n>KY6(L2W+tmb*8blZ}N zyPGxe%+%aZD@0ah?QQplMa>uX7TdqF0*Qn#a-Ws*V?3is!tCbw!AFOsnyv|A3neNy~^QSQqi*L=C>X8l(`Mv zGc)9u7dKn>bFLrTtJ&h=1=n2LZjT;#;lYE>)5l&Mv1!Ekx)(caoHXFh#JF*F9xd|e z`@^($t=9SXIlR5YE5Eaw$wi8X8wP`XtxNFeYBR9@i=h0}zs*L+7^#@&V z7Ck?C!i^>a&Nk@Qp~s=Ey*oCRKRi9Wzt6cwH}eNLy&XAp^K< zxc<*88!~R}pH(vA!TAT>Zbvs?;nr;Vicy)xx86@3mb}Sl+_$~wCG8#Btl6&*@(wne z>NT}f>$v^b-wmI5$TsHiH_JNvm_B-@e?Cmp$IETNJ0E@0AfT6DHY9;_v~);a#n>jjgEV)!^CTLo4}Lr7)^(&QM*ZsOD*hc_7X2I&+~~ zdt&!a3Ia1;>tyErO066spq!X1Xw_EcJFWAM>dNlde_C;_804Z^O6HeTCZ@tlIdn7dCRpWW3?Tn;$(bH|Gz4Zgm=0j&FGVl z`&RLhswr*gzNid28xb zV5m&`W zmiI?xEjqTy=@Xq+-!@y{Z}!JOjD50i>f^|k-~ZX})b7Av^i9_NxW4IwQ&%24uAkFv z*6div5c@~!iRbGd^mD)Q@NlcI`Y+fL9c*{R?!b|?>wesH@luTmZ%6cL<2SfzoiQ7q zG=2WPS6fZ?>`i?qX6X$pwwn%iQrax%TQuuX+R-gG!+zi9*r(U0j`1+m7!|Q%$d8>` z=$0HD&?9yH!Fp*yv&LWj?(y?SH5Yx-^!mwVvrhdyAT9J}f7QJAI@k=gIc>ACuzvMD zDJfeYUOrM+vFB>&QO9OKf3NeoKkK(eNgrR}&M%7G-S_dVWwzbAIL|4re~N2jU8XC zJh61Z{zVh!_8#1;dzXlPVaMhU>2FuuCFf<)!u`AR@&+C2VRUmC9)Hrew05bswDxFB z|Fk6^{kH|z8)tx4lhU%1by_eWaZYF}_pN4D;xS3ZJkK&^wfA*|{%P^o(E3<1DtsF% zG~d=An2`MbsFm3_U zJ-=6{n{w@s+Z113eXB{-(g{Jv1*3MC4pfzm>3;Nfi=VsJ%s#uJ+5FfBoj)J>Mai<8 zWs3suwJv$O_i@?FhWz2)AMR-$6MZKuP&e4;z_{uIUhG{|TC1A2v=%NP5(ST3&ij_u ze6B66`NZ5qWSgk@BZ98u^iyTqL@D3X#$KWV9Lp&y<->v7P7rDBLCqrQaeeLNd=mD)(sS&5?{>fD#wH!P@~|kc&38Bqo|+TUyyGBuH$N>V_<`Cs zT7SQQK2ionmk52U{v-y8;1j$dI-)MS@RIrLo1DZ%r0*C+?SlbtU28!Qi+f9c3+_;K^;Lr* z1*4kp98=@r_wmX;pG5`kpOcaM?CqQvrAH^cKXC5Iv#;{Y_!*ALK3z@^{@{b6`SPA# z4ZEyue)!t9AEy6a>skk|0>91Avb#LlqF?9c6yxIj)4bLbaugv`C$2p)rrMlMp@Zfw zy>fU{#JXqh@0@(!ePi9l8{Yc8`dHWTZ!MeU>%UV!*sFW>A75;A+12>Wtq@)O$)3M9 zC~fRnc&K>j;E#7FwEoGy&+(VUE1{;?(^~T z14E0B9vkudi^DcCJ3n7l>+MjRlF*?`Jqx1>azMPeR zVn+Bf+b6erb~?AYQNg2b3ri<`;H4O9`1bsyJI%fgyOlm8yKmdGEv9XG=lsP*#Z$I^ z5x-}u^H52_4+1yzvr^~l=YBRuIon(NuHm|4nEdgRKl(+CEvJ<)Tv1~HH!yX;*e5@p z(XFVP5Lo+efi{^G+xm(=+FshkvL0peSY*2_LCy;-|H+8F(;k@q~)5ZRXpY zsph$oY75o;9qmBaokd$5RP*@1ElbkQ|5<4jO;T>uxF(8fT05ywxw-;(W14cD>mR<4 zFSe~d>KorPmsbd>cFDRQnxYIAp&)B%s#) zUzY~E_kJ}fEnTyt>Gp$H{9+cKkMDf2*1Y*%N5`CMJTbQTX}`8}LQ-SZKn?+jl(uZygRv}IwxyNgDY2GU0OFq zwZasCal7ANJ#)EvIW9LM9G|ovN=zCUP|n-_BVen;Sic z8LVnlpql@43|4}Ggl)=S>)Xc9&o2-H66R;-^(XItS$zMUH2dND@|fFO3L4lKEk6Ej zAb!Js=_rfo}4D9_IKPI>9wHv#4bg1=?|Ldfc0`&N?If*B195J;~W)even% z?xZ%kJjm(m0Z(2{N%;Ew{darC{&Hp4Elv)wnh zyw~{PwPRC9Z%v$f`445!*?C#*K8f7@VClNy&0BwZ{NC7z+mZS&{m$(huT6^cx{8DQK6qi7M?tm9B{>T;`x`$G^0lU zd2vC+)olenmqsNQ@4U2nbkO~vnBQ9JSGvA^XRlJenlC`GkGiP4d5&ygW#FWQDHi7QrqAp#o zd-~<3Z#)j?{FcJzAMR^k<5Hd0N7XglI}TeD zvF)kndjr3lx}au3_K|fXwr}q+=!W-NNt#`OG`pyEH5*o7u2Ql%D7I!3mW-BdTCC{t zD*ezWdrGIbj|^=7wexEq#m`n^uu3VHM1nvgu7gw)CnhmtM`30h`tPha;bgt(p<`zd z39WrxT|8Kwg#Ql)Ammsp^v{*4J!-|o4Ip<#* z(rCp<+e#bM%Fmxk>VA@tgruhR;I5J%lDflRN$M($Xysv>DzHx`bm#XR^=FH<*S+dz z^1hAxUtdtr?ax()pOUI?>(D(aeb`2u4`+q=`fm;X_Q2qvj^Cx{jyzQuocFnt?+*v2 zzQ{ejXr_C^pYLX5woQn=GJEGX&tVsWyyvYd?ZwGADECaflYMQc?aw2w4l?X%eq4W{ zW0ykyqWkxGrPZG1HA?(pSVCdr-aD==d^{!O$m6W5y5E-eTK(*!ZOwW%J=J)3r?S1Z zx4F8y3;ClOGavN@3`=g0@^V3XSyf$`^YPG+*V({Md-y82S=6yNE zcK2q!cXVRC0_uWoNW)vV4$`>8?S?Tq<-?rXcd0nZx;X12WM@Y$_N zbIxCH_|wCtVIfUs-ZGi`4?4Y|!-LUfzW$?j9ltwbZ=3w^)6;(aVolrk+p1H?T+B~P zh@Jd%Y2GrW^Zvm$gPgb2>*?QT^P>EWM~g~jXE51m$IMfIF8ZH2<6hjz4m<`|f46j$ z%j(E$aQjC8;@NzLy!BYGD=ki@_5W`E`tUJjFd>%|FCG0~7S&b@xJq2-rsQrlDEmd* z(A~*wCJ7Am3uxWX91yG(0<=T5Ar_mAg7@_STft@13;>p-;Kq?~ne7-E)(KS1?eepb zpy49}B?z+0E~6bAX4@Vad1PgFS~X>ps}^Y%Np608nKfHMmE|QR+|uN!>n59`Pb@t0 zAUxOa)}cl3et++mX~l_)9`E-0^l**vmtV|%@9y)gChuJ}*8gqCqNT-6zX`d2=I}G^ zqd$GN)M~n+&k}xamrwPz9~kv+y+ei2Q4ep$T;I3AWo7ePNuS1c_-;yF zZOQEa1BOD?h=Wbp-R0f$g-cHCTzGTgk)CTp9`Bo~&ppvKwf4(B`q}RdN#ABokT9Jo zN@ZN|FE7QP29`ytQ?K)3$(VpH1_1X%p3dpX*jT z=aIEC>iy|`yids^4L<&GWV~NG|L}0Pk6RY5b#JNu;AMl;fArn7Ve#qPbNc*tQ0v^b z_m$T{cXg)LnlZnvdGubBQlBRu**wy`)!A)HQIZkBu6V>gFY!qY8_H1fB%oGwnlBJKJ2mMqP{Puu1Sqix%{$e_jQ$*XQ(M=pZvI| zexPwlnSclF=Ar|qv3x()uJ@yo(r{U&@g zy34~oo5p<{IreCa?RD4Pef9pZ`CaWsX2-XjUT@3A#4f#dd@`o{lU^Dhw|OJKFVPL0 zsLR=6j406l*kZIiZbjtv&cl~woEb1KoIlYx=j!TDGtLeRIJwFut8c-=*Ey|ApN`Vp zJ~!#zz@6qo)=bbxz?%CCe37-^gD!O;%Zf>>W zkdkRj`*}VHKb$!*HSlC&!=KIsAKmI$b4150vu57e_FKuMbt~qKeXf{dI2|yi^y9*# zeZI-M+g8iJbMoD3tq#0>WXp{wyjM4y3Ev;>vM8>T_ayG?mt$P?Hx8X{-|)%k`I{TQm-hYK@xx(mXWqW>+t|UAX9TPp6h!mK{{_dYHUIzs literal 0 HcmV?d00001 diff --git a/Assets/Plugins/LZ4/System.Memory.dll.meta b/Assets/Plugins/LZ4/System.Memory.dll.meta new file mode 100644 index 0000000..e041789 --- /dev/null +++ b/Assets/Plugins/LZ4/System.Memory.dll.meta @@ -0,0 +1,33 @@ +fileFormatVersion: 2 +guid: 4f44e1b4f3db0674dae250f26d7e82c9 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Plugins/LZ4/System.Runtime.CompilerServices.Unsafe.dll b/Assets/Plugins/LZ4/System.Runtime.CompilerServices.Unsafe.dll new file mode 100644 index 0000000000000000000000000000000000000000..491a80a97880de93aa893f6974c5f76891d2de73 GIT binary patch literal 18024 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 LZ4 codec. - public static partial class LZ4Codec - { - #region Helper - - // ReSharper disable UnusedParameter.Local - - [Conditional("DEBUG")] - private static void Assert(bool condition, string errorMessage) - { - if (!condition) throw new ArgumentException(errorMessage); - Debug.Assert(condition, errorMessage); - } - - // ReSharper restore UnusedParameter.Local - - #endregion - - #region Byte manipulation - - // ReSharper disable RedundantCast - - internal static void Poke2(byte[] buffer, int offset, ushort value) - { - buffer[offset] = (byte)value; - buffer[offset + 1] = (byte)(value >> 8); - } - - internal static ushort Peek2(byte[] buffer, int offset) - { - // NOTE: It's faster than BitConverter.ToUInt16 (suprised? me too) - return (ushort)(((uint)buffer[offset]) | ((uint)buffer[offset + 1] << 8)); - } - - internal static uint Peek4(byte[] buffer, int offset) - { - // NOTE: It's faster than BitConverter.ToUInt32 (suprised? me too) - return - ((uint)buffer[offset]) | - ((uint)buffer[offset + 1] << 8) | - ((uint)buffer[offset + 2] << 16) | - ((uint)buffer[offset + 3] << 24); - } - - private static uint Xor4(byte[] buffer, int offset1, int offset2) - { - // return Peek4(buffer, offset1) ^ Peek4(buffer, offset2); - var value1 = - ((uint)buffer[offset1]) | - ((uint)buffer[offset1 + 1] << 8) | - ((uint)buffer[offset1 + 2] << 16) | - ((uint)buffer[offset1 + 3] << 24); - var value2 = - ((uint)buffer[offset2]) | - ((uint)buffer[offset2 + 1] << 8) | - ((uint)buffer[offset2 + 2] << 16) | - ((uint)buffer[offset2 + 3] << 24); - return value1 ^ value2; - } - - private static ulong Xor8(byte[] buffer, int offset1, int offset2) - { - // return Peek8(buffer, offset1) ^ Peek8(buffer, offset2); - var value1 = - ((ulong)buffer[offset1]) | - ((ulong)buffer[offset1 + 1] << 8) | - ((ulong)buffer[offset1 + 2] << 16) | - ((ulong)buffer[offset1 + 3] << 24) | - ((ulong)buffer[offset1 + 4] << 32) | - ((ulong)buffer[offset1 + 5] << 40) | - ((ulong)buffer[offset1 + 6] << 48) | - ((ulong)buffer[offset1 + 7] << 56); - var value2 = - ((ulong)buffer[offset2]) | - ((ulong)buffer[offset2 + 1] << 8) | - ((ulong)buffer[offset2 + 2] << 16) | - ((ulong)buffer[offset2 + 3] << 24) | - ((ulong)buffer[offset2 + 4] << 32) | - ((ulong)buffer[offset2 + 5] << 40) | - ((ulong)buffer[offset2 + 6] << 48) | - ((ulong)buffer[offset2 + 7] << 56); - return value1 ^ value2; - } - - private static bool Equal2(byte[] buffer, int offset1, int offset2) - { - // return Peek2(buffer, offset1) == Peek2(buffer, offset2); - if (buffer[offset1] != buffer[offset2]) return false; - return buffer[offset1 + 1] == buffer[offset2 + 1]; - } - - private static bool Equal4(byte[] buffer, int offset1, int offset2) - { - // return Peek4(buffer, offset1) == Peek4(buffer, offset2); - if (buffer[offset1] != buffer[offset2]) return false; - if (buffer[offset1 + 1] != buffer[offset2 + 1]) return false; - if (buffer[offset1 + 2] != buffer[offset2 + 2]) return false; - return buffer[offset1 + 3] == buffer[offset2 + 3]; - } - - // ReSharper restore RedundantCast - - #endregion - - #region Byte block copy - - private static void Copy4(byte[] buf, int src, int dst) - { - Assert(dst > src, "Copying backwards is not implemented"); - buf[dst + 3] = buf[src + 3]; - buf[dst + 2] = buf[src + 2]; - buf[dst + 1] = buf[src + 1]; - buf[dst] = buf[src]; - } - - private static void Copy8(byte[] buf, int src, int dst) - { - Assert(dst > src, "Copying backwards is not implemented"); - buf[dst + 7] = buf[src + 7]; - buf[dst + 6] = buf[src + 6]; - buf[dst + 5] = buf[src + 5]; - buf[dst + 4] = buf[src + 4]; - buf[dst + 3] = buf[src + 3]; - buf[dst + 2] = buf[src + 2]; - buf[dst + 1] = buf[src + 1]; - buf[dst] = buf[src]; - } - - private static void BlockCopy(byte[] src, int src_0, byte[] dst, int dst_0, int len) - { - Assert(src != dst, "BlockCopy does not handle copying to the same buffer"); - - if (len >= BLOCK_COPY_LIMIT) - { - Buffer.BlockCopy(src, src_0, dst, dst_0, len); - } - else - { - while (len >= 8) - { - dst[dst_0] = src[src_0]; - dst[dst_0 + 1] = src[src_0 + 1]; - dst[dst_0 + 2] = src[src_0 + 2]; - dst[dst_0 + 3] = src[src_0 + 3]; - dst[dst_0 + 4] = src[src_0 + 4]; - dst[dst_0 + 5] = src[src_0 + 5]; - dst[dst_0 + 6] = src[src_0 + 6]; - dst[dst_0 + 7] = src[src_0 + 7]; - len -= 8; - src_0 += 8; - dst_0 += 8; - } - - while (len >= 4) - { - dst[dst_0] = src[src_0]; - dst[dst_0 + 1] = src[src_0 + 1]; - dst[dst_0 + 2] = src[src_0 + 2]; - dst[dst_0 + 3] = src[src_0 + 3]; - len -= 4; - src_0 += 4; - dst_0 += 4; - } - - while (len-- > 0) - { - dst[dst_0++] = src[src_0++]; - } - } - } - - private static int WildCopy(byte[] src, int src_0, byte[] dst, int dst_0, int dst_end) - { - var len = dst_end - dst_0; - - Assert(src != dst, "BlockCopy does not handle copying to the same buffer"); - Assert(len > 0, "Length have to be greater than 0"); - - if (len >= BLOCK_COPY_LIMIT) - { - Buffer.BlockCopy(src, src_0, dst, dst_0, len); - } - else - { - // apparently (tested) this is an overkill - // it seems to be faster without this 8-byte loop - //while (len >= 8) - //{ - // dst[dst_0] = src[src_0]; - // dst[dst_0 + 1] = src[src_0 + 1]; - // dst[dst_0 + 2] = src[src_0 + 2]; - // dst[dst_0 + 3] = src[src_0 + 3]; - // dst[dst_0 + 4] = src[src_0 + 4]; - // dst[dst_0 + 5] = src[src_0 + 5]; - // dst[dst_0 + 6] = src[src_0 + 6]; - // dst[dst_0 + 7] = src[src_0 + 7]; - // len -= 8; src_0 += 8; dst_0 += 8; - //} - - while (len >= 4) - { - dst[dst_0] = src[src_0]; - dst[dst_0 + 1] = src[src_0 + 1]; - dst[dst_0 + 2] = src[src_0 + 2]; - dst[dst_0 + 3] = src[src_0 + 3]; - len -= 4; - src_0 += 4; - dst_0 += 4; - } - - while (len-- > 0) - { - dst[dst_0++] = src[src_0++]; - } - } - - return len; - } - - private static int SecureCopy(byte[] buffer, int src, int dst, int dst_end) - { - var diff = dst - src; - var length = dst_end - dst; - var len = length; - - Assert(diff >= 4, "Target must be at least 4 bytes further than source"); - Assert(BLOCK_COPY_LIMIT > 4, "This method requires BLOCK_COPY_LIMIT > 4"); - Assert(len > 0, "Length have to be greater than 0"); - - if (diff >= BLOCK_COPY_LIMIT) - { - if (diff >= length) - { - Buffer.BlockCopy(buffer, src, buffer, dst, length); - return length; // done - } - - do - { - Buffer.BlockCopy(buffer, src, buffer, dst, diff); - src += diff; - dst += diff; - len -= diff; - } while (len >= diff); - } - - // apparently (tested) this is an overkill - // it seems to be faster without this 8-byte loop - //while (len >= 8) - //{ - // buffer[dst] = buffer[src]; - // buffer[dst + 1] = buffer[src + 1]; - // buffer[dst + 2] = buffer[src + 2]; - // buffer[dst + 3] = buffer[src + 3]; - // buffer[dst + 4] = buffer[src + 4]; - // buffer[dst + 5] = buffer[src + 5]; - // buffer[dst + 6] = buffer[src + 6]; - // buffer[dst + 7] = buffer[src + 7]; - // dst += 8; src += 8; len -= 8; - //} - - while (len >= 4) - { - buffer[dst] = buffer[src]; - buffer[dst + 1] = buffer[src + 1]; - buffer[dst + 2] = buffer[src + 2]; - buffer[dst + 3] = buffer[src + 3]; - dst += 4; - src += 4; - len -= 4; - } - - while (len-- > 0) - { - buffer[dst++] = buffer[src++]; - } - - return length; // done - } - - #endregion - - #region Encode32 - - /// Encodes the specified input. - /// The input. - /// The input offset. - /// Length of the input. - /// The output. - /// The output offset. - /// Length of the output. - /// Number of bytes written. - public static int Encode32( - byte[] input, - int inputOffset, - int inputLength, - byte[] output, - int outputOffset, - int outputLength) - { - CheckArguments( - input, inputOffset, ref inputLength, - output, outputOffset, ref outputLength); - if (outputLength == 0) return 0; - - if (inputLength < LZ4_64KLIMIT) - { - var hashTable = new ushort[HASH64K_TABLESIZE]; - return LZ4_compress64kCtx_safe32(hashTable, input, output, inputOffset, outputOffset, inputLength, outputLength); - } - else - { - var hashTable = new int[HASH_TABLESIZE]; - return LZ4_compressCtx_safe32(hashTable, input, output, inputOffset, outputOffset, inputLength, outputLength); - } - } - - /// Encodes the specified input. - /// The input. - /// The input offset. - /// Length of the input. - /// Compressed buffer. - public static byte[] Encode32(byte[] input, int inputOffset, int inputLength) - { - if (inputLength < 0) inputLength = input.Length - inputOffset; - - if (input == null) throw new ArgumentNullException("input"); - if (inputOffset < 0 || inputOffset + inputLength > input.Length) - throw new ArgumentException("inputOffset and inputLength are invalid for given input"); - - var result = new byte[MaximumOutputLength(inputLength)]; - var length = Encode32(input, inputOffset, inputLength, result, 0, result.Length); - - if (length != result.Length) - { - if (length < 0) - throw new InvalidOperationException("Compression has been corrupted"); - var buffer = new byte[length]; - Buffer.BlockCopy(result, 0, buffer, 0, length); - return buffer; - } - return result; - } - - #endregion - - #region Encode64 - - /// Encodes the specified input. - /// The input. - /// The input offset. - /// Length of the input. - /// The output. - /// The output offset. - /// Length of the output. - /// Number of bytes written. - public static int Encode64( - byte[] input, - int inputOffset, - int inputLength, - byte[] output, - int outputOffset, - int outputLength) - { - CheckArguments( - input, inputOffset, ref inputLength, - output, outputOffset, ref outputLength); - if (outputLength == 0) return 0; - - if (inputLength < LZ4_64KLIMIT) - { - var hashTable = new ushort[HASH64K_TABLESIZE]; - return LZ4_compress64kCtx_safe64(hashTable, input, output, inputOffset, outputOffset, inputLength, outputLength); - } - else - { - var hashTable = new int[HASH_TABLESIZE]; - return LZ4_compressCtx_safe64(hashTable, input, output, inputOffset, outputOffset, inputLength, outputLength); - } - } - - /// Encodes the specified input. - /// The input. - /// The input offset. - /// Length of the input. - /// Compressed buffer. - public static byte[] Encode64(byte[] input, int inputOffset, int inputLength) - { - if (inputLength < 0) inputLength = input.Length - inputOffset; - - if (input == null) throw new ArgumentNullException("input"); - if (inputOffset < 0 || inputOffset + inputLength > input.Length) - throw new ArgumentException("inputOffset and inputLength are invalid for given input"); - - var result = new byte[MaximumOutputLength(inputLength)]; - var length = Encode64(input, inputOffset, inputLength, result, 0, result.Length); - - if (length != result.Length) - { - if (length < 0) - throw new InvalidOperationException("Compression has been corrupted"); - var buffer = new byte[length]; - Buffer.BlockCopy(result, 0, buffer, 0, length); - return buffer; - } - return result; - } - - #endregion - - #region Decode32 - - /// Decodes the specified input. - /// The input. - /// The input offset. - /// Length of the input. - /// The output. - /// The output offset. - /// Length of the output. - /// Set it to true if output length is known. - /// Number of bytes written. - public static int Decode32( - byte[] input, - int inputOffset, - int inputLength, - byte[] output, - int outputOffset, - int outputLength, - bool knownOutputLength) - { - CheckArguments( - input, inputOffset, ref inputLength, - output, outputOffset, ref outputLength); - - if (outputLength == 0) return 0; - - if (knownOutputLength) - { - var length = LZ4_uncompress_safe32(input, output, inputOffset, outputOffset, outputLength); - if (length != inputLength) - throw new ArgumentException("LZ4 block is corrupted, or invalid length has been given."); - return outputLength; - } - else - { - var length = LZ4_uncompress_unknownOutputSize_safe32(input, output, inputOffset, outputOffset, inputLength, outputLength); - if (length < 0) - throw new ArgumentException("LZ4 block is corrupted, or invalid length has been given."); - return length; - } - } - - /// Decodes the specified input. - /// The input. - /// The input offset. - /// Length of the input. - /// Length of the output. - /// Decompressed buffer. - public static byte[] Decode32(byte[] input, int inputOffset, int inputLength, int outputLength) - { - if (inputLength < 0) inputLength = input.Length - inputOffset; - - if (input == null) throw new ArgumentNullException("input"); - if (inputOffset < 0 || inputOffset + inputLength > input.Length) - throw new ArgumentException("inputOffset and inputLength are invalid for given input"); - - var result = new byte[outputLength]; - var length = Decode32(input, inputOffset, inputLength, result, 0, outputLength, true); - if (length != outputLength) - throw new ArgumentException("outputLength is not valid"); - return result; - } - - #endregion - - #region Decode64 - - /// Decodes the specified input. - /// The input. - /// The input offset. - /// Length of the input. - /// The output. - /// The output offset. - /// Length of the output. - /// Set it to true if output length is known. - /// Number of bytes written. - public static int Decode64( - byte[] input, - int inputOffset, - int inputLength, - byte[] output, - int outputOffset, - int outputLength, - bool knownOutputLength) - { - CheckArguments( - input, inputOffset, ref inputLength, - output, outputOffset, ref outputLength); - - if (outputLength == 0) return 0; - - if (knownOutputLength) - { - var length = LZ4_uncompress_safe64(input, output, inputOffset, outputOffset, outputLength); - if (length != inputLength) - throw new ArgumentException("LZ4 block is corrupted, or invalid length has been given."); - return outputLength; - } - else - { - var length = LZ4_uncompress_unknownOutputSize_safe64(input, output, inputOffset, outputOffset, inputLength, outputLength); - if (length < 0) - throw new ArgumentException("LZ4 block is corrupted, or invalid length has been given."); - return length; - } - } - - /// Decodes the specified input. - /// The input. - /// The input offset. - /// Length of the input. - /// Length of the output. - /// Decompressed buffer. - public static byte[] Decode64(byte[] input, int inputOffset, int inputLength, int outputLength) - { - if (inputLength < 0) inputLength = input.Length - inputOffset; - - if (input == null) throw new ArgumentNullException("input"); - if (inputOffset < 0 || inputOffset + inputLength > input.Length) - throw new ArgumentException("inputOffset and inputLength are invalid for given input"); - - var result = new byte[outputLength]; - var length = Decode64(input, inputOffset, inputLength, result, 0, outputLength, true); - if (length != outputLength) - throw new ArgumentException("outputLength is not valid"); - return result; - } - - #endregion - - #region HC utilities - - // ReSharper disable InconsistentNaming - - private class LZ4HC_Data_Structure - { - public byte[] src; - public int src_base; - public int src_end; - public int src_LASTLITERALS; - public byte[] dst; - public int dst_base; - public int dst_len; - public int dst_end; - public int[] hashTable; - public ushort[] chainTable; - public int nextToUpdate; - }; - - // ReSharper restore InconsistentNaming - - - private static LZ4HC_Data_Structure LZ4HC_Create(byte[] src, int src_0, int src_len, byte[] dst, int dst_0, int dst_len) - { - var hc4 = new LZ4HC_Data_Structure { - src = src, - src_base = src_0, - src_end = src_0 + src_len, - src_LASTLITERALS = (src_0 + src_len - LASTLITERALS), - dst = dst, - dst_base = dst_0, - dst_len = dst_len, - dst_end = dst_0 + dst_len, - hashTable = new int[HASHHC_TABLESIZE], - chainTable = new ushort[MAXD], - nextToUpdate = src_0 + 1, - }; - - var ct = hc4.chainTable; - for (var i = ct.Length - 1; i >= 0; i--) ct[i] = unchecked((ushort)-1); - - return hc4; - } - - #endregion - - #region Encode32HC - - private static int LZ4_compressHC_32( - byte[] input, int inputOffset, int inputLength, - byte[] output, int outputOffset, int outputLength) - { - return LZ4_compressHCCtx_32( - LZ4HC_Create( - input, inputOffset, inputLength, output, outputOffset, outputLength)); - } - - /// Encodes the specified input using HC codec. - /// The input. - /// The input offset. - /// Length of the input. - /// The output. - /// The output offset. - /// Length of the output. - /// Number of bytes written. NOTE: when output buffer is too small it returns negative value. - public static int Encode32HC( - byte[] input, - int inputOffset, - int inputLength, - byte[] output, - int outputOffset, - int outputLength) - { - if (inputLength == 0) return 0; - - CheckArguments( - input, inputOffset, ref inputLength, - output, outputOffset, ref outputLength); - - var length = LZ4_compressHC_32(input, inputOffset, inputLength, output, outputOffset, outputLength); - // NOTE: there is a potential problem here as original implementation returns 0 not -1 - return length <= 0 ? -1 : length; - } - - /// Encodes the specified input using HC codec. - /// The input. - /// The input offset. - /// Length of the input. - /// Buffer with compressed data (NOTE: it can be bigger than input). - public static byte[] Encode32HC( - byte[] input, int inputOffset, int inputLength) - { - if (inputLength == 0) return new byte[0]; - var outputLength = MaximumOutputLength(inputLength); - var result = new byte[outputLength]; - var length = Encode32HC(input, inputOffset, inputLength, result, 0, outputLength); - - if (length < 0) - throw new ArgumentException("Provided data seems to be corrupted."); - - if (length != outputLength) - { - var buffer = new byte[length]; - Buffer.BlockCopy(result, 0, buffer, 0, length); - result = buffer; - } - - return result; - } - - #endregion - - #region Encode64HC - - private static int LZ4_compressHC_64( - byte[] input, int inputOffset, int inputLength, - byte[] output, int outputOffset, int outputLength) - { - return LZ4_compressHCCtx_64( - LZ4HC_Create( - input, inputOffset, inputLength, output, outputOffset, outputLength)); - } - - /// Encodes the specified input using HC codec. - /// The input. - /// The input offset. - /// Length of the input. - /// The output. - /// The output offset. - /// Length of the output. - /// Number of bytes written. NOTE: when output buffer is too small it returns negative value. - public static int Encode64HC( - byte[] input, - int inputOffset, - int inputLength, - byte[] output, - int outputOffset, - int outputLength) - { - if (inputLength == 0) return 0; - - CheckArguments( - input, inputOffset, ref inputLength, - output, outputOffset, ref outputLength); - - var length = LZ4_compressHC_64(input, inputOffset, inputLength, output, outputOffset, outputLength); - // NOTE: there is a potential problem here as original implementation returns 0 not -1 - return length <= 0 ? -1 : length; - } - - /// Encodes the specified input using HC codec. - /// The input. - /// The input offset. - /// Length of the input. - /// Buffer with compressed data (NOTE: it can be bigger than input). - public static byte[] Encode64HC( - byte[] input, int inputOffset, int inputLength) - { - if (inputLength == 0) return new byte[0]; - var outputLength = MaximumOutputLength(inputLength); - var result = new byte[outputLength]; - var length = Encode64HC(input, inputOffset, inputLength, result, 0, outputLength); - - if (length < 0) - throw new ArgumentException("Provided data seems to be corrupted."); - - if (length != outputLength) - { - var buffer = new byte[length]; - Buffer.BlockCopy(result, 0, buffer, 0, length); - result = buffer; - } - - return result; - } - - #endregion - } -} - -// ReSharper restore InconsistentNaming -// ReSharper restore CheckNamespace diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs b/Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs deleted file mode 100644 index 85e7c49..0000000 --- a/Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs +++ /dev/null @@ -1,795 +0,0 @@ -#region LZ4 original - -/* - LZ4 - Fast LZ compression algorithm - Copyright (C) 2011-2012, Yann Collet. - BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html - - LZ4 source repository : http://code.google.com/p/lz4/ -*/ - -#endregion - -#region LZ4 port - -/* -Copyright (c) 2013, Milosz Krajewski -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, are permitted provided -that the following conditions are met: - -* Redistributions of source code must retain the above copyright notice, this list of conditions - and the following disclaimer. - -* Redistributions in binary form must reproduce the above copyright notice, this list of conditions - and the following disclaimer in the documentation and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED -WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN -IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#endregion - -// ReSharper disable CheckNamespace -// ReSharper disable InconsistentNaming -// ReSharper disable TooWideLocalVariableScope -// ReSharper disable JoinDeclarationAndInitializer -// ReSharper disable RedundantIfElseBlock - -namespace LZ4ps -{ - public static partial class LZ4Codec - { - #region LZ4_compressCtx - - private static int LZ4_compressCtx_safe32( - int[] hash_table, - byte[] src, - byte[] dst, - int src_0, - int dst_0, - int src_len, - int dst_maxlen) - { - var debruijn32 = DEBRUIJN_TABLE_32; - int _i; - - // ---- preprocessed source start here ---- - // r93 - var src_p = src_0; - var src_base = src_0; - var src_anchor = src_p; - var src_end = src_p + src_len; - var src_mflimit = src_end - MFLIMIT; - - var dst_p = dst_0; - var dst_end = dst_p + dst_maxlen; - - var src_LASTLITERALS = src_end - LASTLITERALS; - var src_LASTLITERALS_1 = src_LASTLITERALS - 1; - - var src_LASTLITERALS_STEPSIZE_1 = src_LASTLITERALS - (STEPSIZE_32 - 1); - var dst_LASTLITERALS_1 = dst_end - (1 + LASTLITERALS); - var dst_LASTLITERALS_3 = dst_end - (2 + 1 + LASTLITERALS); - - int length; - - uint h, h_fwd; - - // Init - if (src_len < MINLENGTH) goto _last_literals; - - // First Byte - hash_table[(((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST)] = (src_p - src_base); - src_p++; - h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST); - - // Main Loop - while (true) - { - var findMatchAttempts = (1 << SKIPSTRENGTH) + 3; - var src_p_fwd = src_p; - int src_ref; - int dst_token; - - // Find a match - do - { - h = h_fwd; - var step = findMatchAttempts++ >> SKIPSTRENGTH; - src_p = src_p_fwd; - src_p_fwd = src_p + step; - - if (src_p_fwd > src_mflimit) goto _last_literals; - - h_fwd = (((Peek4(src, src_p_fwd)) * 2654435761u) >> HASH_ADJUST); - src_ref = src_base + hash_table[h]; - hash_table[h] = (src_p - src_base); - } while ((src_ref < src_p - MAX_DISTANCE) || (!Equal4(src, src_ref, src_p))); - - // Catch up - while ((src_p > src_anchor) && (src_ref > src_0) && (src[src_p - 1] == src[src_ref - 1])) - { - src_p--; - src_ref--; - } - - // Encode Literal length - length = (src_p - src_anchor); - dst_token = dst_p++; - - if (dst_p + length + (length >> 8) > dst_LASTLITERALS_3) return 0; // Check output limit - - if (length >= RUN_MASK) - { - var len = length - RUN_MASK; - dst[dst_token] = (RUN_MASK << ML_BITS); - if (len > 254) - { - do - { - dst[dst_p++] = 255; - len -= 255; - } while (len > 254); - dst[dst_p++] = (byte)len; - BlockCopy(src, src_anchor, dst, dst_p, length); - dst_p += length; - goto _next_match; - } - else - dst[dst_p++] = (byte)len; - } - else - { - dst[dst_token] = (byte)(length << ML_BITS); - } - - // Copy Literals - if (length > 0) - { - _i = dst_p + length; - WildCopy(src, src_anchor, dst, dst_p, _i); - dst_p = _i; - } - - _next_match: - // Encode Offset - Poke2(dst, dst_p, (ushort)(src_p - src_ref)); - dst_p += 2; - - // Start Counting - src_p += MINMATCH; - src_ref += MINMATCH; // MinMatch already verified - src_anchor = src_p; - - while (src_p < src_LASTLITERALS_STEPSIZE_1) - { - var diff = (int)Xor4(src, src_ref, src_p); - if (diff == 0) - { - src_p += STEPSIZE_32; - src_ref += STEPSIZE_32; - continue; - } - src_p += debruijn32[((uint)((diff) & -(diff)) * 0x077CB531u) >> 27]; - goto _endCount; - } - - if ((src_p < src_LASTLITERALS_1) && (Equal2(src, src_ref, src_p))) - { - src_p += 2; - src_ref += 2; - } - if ((src_p < src_LASTLITERALS) && (src[src_ref] == src[src_p])) src_p++; - - _endCount: - // Encode MatchLength - length = (src_p - src_anchor); - - if (dst_p + (length >> 8) > dst_LASTLITERALS_1) return 0; // Check output limit - - if (length >= ML_MASK) - { - dst[dst_token] += ML_MASK; - length -= ML_MASK; - for (; length > 509; length -= 510) - { - dst[dst_p++] = 255; - dst[dst_p++] = 255; - } - if (length > 254) - { - length -= 255; - dst[dst_p++] = 255; - } - dst[dst_p++] = (byte)length; - } - else - { - dst[dst_token] += (byte)length; - } - - // Test end of chunk - if (src_p > src_mflimit) - { - src_anchor = src_p; - break; - } - - // Fill table - hash_table[(((Peek4(src, src_p - 2)) * 2654435761u) >> HASH_ADJUST)] = (src_p - 2 - src_base); - - // Test next position - - h = (((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST); - src_ref = src_base + hash_table[h]; - hash_table[h] = (src_p - src_base); - - if ((src_ref > src_p - (MAX_DISTANCE + 1)) && (Equal4(src, src_ref, src_p))) - { - dst_token = dst_p++; - dst[dst_token] = 0; - goto _next_match; - } - - // Prepare next loop - src_anchor = src_p++; - h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST); - } - - _last_literals: - // Encode Last Literals - { - var lastRun = (src_end - src_anchor); - - if (dst_p + lastRun + 1 + ((lastRun + 255 - RUN_MASK) / 255) > dst_end) return 0; - - if (lastRun >= RUN_MASK) - { - dst[dst_p++] = (RUN_MASK << ML_BITS); - lastRun -= RUN_MASK; - for (; lastRun > 254; lastRun -= 255) dst[dst_p++] = 255; - dst[dst_p++] = (byte)lastRun; - } - else dst[dst_p++] = (byte)(lastRun << ML_BITS); - BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor); - dst_p += src_end - src_anchor; - } - - // End - return ((dst_p) - dst_0); - } - - #endregion - - #region LZ4_compress64kCtx - - private static int LZ4_compress64kCtx_safe32( - ushort[] hash_table, - byte[] src, - byte[] dst, - int src_0, - int dst_0, - int src_len, - int dst_maxlen) - { - var debruijn32 = DEBRUIJN_TABLE_32; - int _i; - - // ---- preprocessed source start here ---- - // r93 - var src_p = src_0; - var src_anchor = src_p; - var src_base = src_p; - var src_end = src_p + src_len; - var src_mflimit = src_end - MFLIMIT; - - var dst_p = dst_0; - var dst_end = dst_p + dst_maxlen; - - var src_LASTLITERALS = src_end - LASTLITERALS; - var src_LASTLITERALS_1 = src_LASTLITERALS - 1; - - var src_LASTLITERALS_STEPSIZE_1 = src_LASTLITERALS - (STEPSIZE_32 - 1); - var dst_LASTLITERALS_1 = dst_end - (1 + LASTLITERALS); - var dst_LASTLITERALS_3 = dst_end - (2 + 1 + LASTLITERALS); - - int len, length; - - uint h, h_fwd; - - // Init - if (src_len < MINLENGTH) goto _last_literals; - - // First Byte - src_p++; - h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH64K_ADJUST); - - // Main Loop - while (true) - { - var findMatchAttempts = (1 << SKIPSTRENGTH) + 3; - var src_p_fwd = src_p; - int src_ref; - int dst_token; - - // Find a match - do - { - h = h_fwd; - var step = findMatchAttempts++ >> SKIPSTRENGTH; - src_p = src_p_fwd; - src_p_fwd = src_p + step; - - if (src_p_fwd > src_mflimit) goto _last_literals; - - h_fwd = (((Peek4(src, src_p_fwd)) * 2654435761u) >> HASH64K_ADJUST); - src_ref = src_base + hash_table[h]; - hash_table[h] = (ushort)(src_p - src_base); - } while (!Equal4(src, src_ref, src_p)); - - // Catch up - while ((src_p > src_anchor) && (src_ref > src_0) && (src[src_p - 1] == src[src_ref - 1])) - { - src_p--; - src_ref--; - } - - // Encode Literal length - length = (src_p - src_anchor); - dst_token = dst_p++; - - if (dst_p + length + (length >> 8) > dst_LASTLITERALS_3) return 0; // Check output limit - - if (length >= RUN_MASK) - { - len = length - RUN_MASK; - dst[dst_token] = (RUN_MASK << ML_BITS); - if (len > 254) - { - do - { - dst[dst_p++] = 255; - len -= 255; - } while (len > 254); - dst[dst_p++] = (byte)len; - BlockCopy(src, src_anchor, dst, dst_p, length); - dst_p += length; - goto _next_match; - } - else - { - dst[dst_p++] = (byte)len; - } - } - else - { - dst[dst_token] = (byte)(length << ML_BITS); - } - - // Copy Literals - if (length > 0) - { - _i = dst_p + length; - WildCopy(src, src_anchor, dst, dst_p, _i); - dst_p = _i; - } - - _next_match: - // Encode Offset - Poke2(dst, dst_p, (ushort)(src_p - src_ref)); - dst_p += 2; - - // Start Counting - src_p += MINMATCH; - src_ref += MINMATCH; // MinMatch verified - src_anchor = src_p; - - while (src_p < src_LASTLITERALS_STEPSIZE_1) - { - var diff = (int)Xor4(src, src_ref, src_p); - if (diff == 0) - { - src_p += STEPSIZE_32; - src_ref += STEPSIZE_32; - continue; - } - src_p += debruijn32[((uint)((diff) & -(diff)) * 0x077CB531u) >> 27]; - goto _endCount; - } - - if ((src_p < src_LASTLITERALS_1) && (Equal2(src, src_ref, src_p))) - { - src_p += 2; - src_ref += 2; - } - if ((src_p < src_LASTLITERALS) && (src[src_ref] == src[src_p])) src_p++; - - _endCount: - - // Encode MatchLength - len = (src_p - src_anchor); - - if (dst_p + (len >> 8) > dst_LASTLITERALS_1) return 0; // Check output limit - - if (len >= ML_MASK) - { - dst[dst_token] += ML_MASK; - len -= ML_MASK; - for (; len > 509; len -= 510) - { - dst[dst_p++] = 255; - dst[dst_p++] = 255; - } - if (len > 254) - { - len -= 255; - dst[dst_p++] = 255; - } - dst[dst_p++] = (byte)len; - } - else - { - dst[dst_token] += (byte)len; - } - - // Test end of chunk - if (src_p > src_mflimit) - { - src_anchor = src_p; - break; - } - - // Fill table - hash_table[(((Peek4(src, src_p - 2)) * 2654435761u) >> HASH64K_ADJUST)] = (ushort)(src_p - 2 - src_base); - - // Test next position - - h = (((Peek4(src, src_p)) * 2654435761u) >> HASH64K_ADJUST); - src_ref = src_base + hash_table[h]; - hash_table[h] = (ushort)(src_p - src_base); - - if (Equal4(src, src_ref, src_p)) - { - dst_token = dst_p++; - dst[dst_token] = 0; - goto _next_match; - } - - // Prepare next loop - src_anchor = src_p++; - h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH64K_ADJUST); - } - - _last_literals: - // Encode Last Literals - var lastRun = (src_end - src_anchor); - if (dst_p + lastRun + 1 + (lastRun - RUN_MASK + 255) / 255 > dst_end) return 0; - if (lastRun >= RUN_MASK) - { - dst[dst_p++] = (RUN_MASK << ML_BITS); - lastRun -= RUN_MASK; - for (; lastRun > 254; lastRun -= 255) dst[dst_p++] = 255; - dst[dst_p++] = (byte)lastRun; - } - else - { - dst[dst_p++] = (byte)(lastRun << ML_BITS); - } - BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor); - dst_p += src_end - src_anchor; - - // End - return ((dst_p) - dst_0); - } - - #endregion - - #region LZ4_uncompress - - private static int LZ4_uncompress_safe32( - byte[] src, - byte[] dst, - int src_0, - int dst_0, - int dst_len) - { - var dec32table = DECODER_TABLE_32; - int _i; - - // ---- preprocessed source start here ---- - // r93 - var src_p = src_0; - int dst_ref; - - var dst_p = dst_0; - var dst_end = dst_p + dst_len; - int dst_cpy; - - var dst_LASTLITERALS = dst_end - LASTLITERALS; - var dst_COPYLENGTH = dst_end - COPYLENGTH; - var dst_COPYLENGTH_STEPSIZE_4 = dst_end - COPYLENGTH - (STEPSIZE_32 - 4); - - byte token; - - // Main Loop - while (true) - { - int length; - - // get runlength - token = src[src_p++]; - if ((length = (token >> ML_BITS)) == RUN_MASK) - { - int len; - for (; (len = src[src_p++]) == 255; length += 255) - { - /* do nothing */ - } - length += len; - } - - // copy literals - dst_cpy = dst_p + length; - - if (dst_cpy > dst_COPYLENGTH) - { - if (dst_cpy != dst_end) goto _output_error; // Error : not enough place for another match (min 4) + 5 literals - BlockCopy(src, src_p, dst, dst_p, length); - src_p += length; - break; // EOF - } - if (dst_p < dst_cpy) - { - _i = WildCopy(src, src_p, dst, dst_p, dst_cpy); - src_p += _i; - dst_p += _i; - } - src_p -= (dst_p - dst_cpy); - dst_p = dst_cpy; - - // get offset - dst_ref = (dst_cpy) - Peek2(src, src_p); - src_p += 2; - if (dst_ref < dst_0) goto _output_error; // Error : offset outside destination buffer - - // get matchlength - if ((length = (token & ML_MASK)) == ML_MASK) - { - for (; src[src_p] == 255; length += 255) src_p++; - length += src[src_p++]; - } - - // copy repeated sequence - if ((dst_p - dst_ref) < STEPSIZE_32) - { - const int dec64 = 0; - dst[dst_p + 0] = dst[dst_ref + 0]; - dst[dst_p + 1] = dst[dst_ref + 1]; - dst[dst_p + 2] = dst[dst_ref + 2]; - dst[dst_p + 3] = dst[dst_ref + 3]; - dst_p += 4; - dst_ref += 4; - dst_ref -= dec32table[dst_p - dst_ref]; - Copy4(dst, dst_ref, dst_p); - dst_p += STEPSIZE_32 - 4; - dst_ref -= dec64; - } - else - { - Copy4(dst, dst_ref, dst_p); - dst_p += 4; - dst_ref += 4; - } - dst_cpy = dst_p + length - (STEPSIZE_32 - 4); - - if (dst_cpy > dst_COPYLENGTH_STEPSIZE_4) - { - if (dst_cpy > dst_LASTLITERALS) goto _output_error; // Error : last 5 bytes must be literals - if (dst_p < dst_COPYLENGTH) - { - _i = SecureCopy(dst, dst_ref, dst_p, dst_COPYLENGTH); - dst_ref += _i; - dst_p += _i; - } - - while (dst_p < dst_cpy) dst[dst_p++] = dst[dst_ref++]; - dst_p = dst_cpy; - continue; - } - - if (dst_p < dst_cpy) - { - SecureCopy(dst, dst_ref, dst_p, dst_cpy); - } - dst_p = dst_cpy; // correction - } - - // end of decoding - return ((src_p) - src_0); - - // write overflow error detected - _output_error: - return (-((src_p) - src_0)); - } - - #endregion - - #region LZ4_uncompress_unknownOutputSize - - private static int LZ4_uncompress_unknownOutputSize_safe32( - byte[] src, - byte[] dst, - int src_0, - int dst_0, - int src_len, - int dst_maxlen) - { - var dec32table = DECODER_TABLE_32; - int _i; - - // ---- preprocessed source start here ---- - // r93 - var src_p = src_0; - var src_end = src_p + src_len; - int dst_ref; - - var dst_p = dst_0; - var dst_end = dst_p + dst_maxlen; - int dst_cpy; - - var src_LASTLITERALS_3 = (src_end - (2 + 1 + LASTLITERALS)); - var src_LASTLITERALS_1 = (src_end - (LASTLITERALS + 1)); - var dst_COPYLENGTH = (dst_end - COPYLENGTH); - var dst_COPYLENGTH_STEPSIZE_4 = (dst_end - (COPYLENGTH + (STEPSIZE_32 - 4))); - var dst_LASTLITERALS = (dst_end - LASTLITERALS); - var dst_MFLIMIT = (dst_end - MFLIMIT); - - // Special case - if (src_p == src_end) goto _output_error; // A correctly formed null-compressed LZ4 must have at least one byte (token=0) - - // Main Loop - while (true) - { - byte token; - int length; - - // get runlength - token = src[src_p++]; - if ((length = (token >> ML_BITS)) == RUN_MASK) - { - var s = 255; - while ((src_p < src_end) && (s == 255)) length += (s = src[src_p++]); - } - - // copy literals - dst_cpy = dst_p + length; - - if ((dst_cpy > dst_MFLIMIT) || (src_p + length > src_LASTLITERALS_3)) - { - if (dst_cpy > dst_end) goto _output_error; // Error : writes beyond output buffer - if (src_p + length != src_end) goto _output_error; // Error : LZ4 format requires to consume all input at this stage (no match within the last 11 bytes, and at least 8 remaining input bytes for another match+literals) - BlockCopy(src, src_p, dst, dst_p, length); - dst_p += length; - break; // Necessarily EOF, due to parsing restrictions - } - if (dst_p < dst_cpy) - { - _i = WildCopy(src, src_p, dst, dst_p, dst_cpy); - src_p += _i; - dst_p += _i; - } - src_p -= (dst_p - dst_cpy); - dst_p = dst_cpy; - - // get offset - dst_ref = (dst_cpy) - Peek2(src, src_p); - src_p += 2; - if (dst_ref < dst_0) goto _output_error; // Error : offset outside of destination buffer - - // get matchlength - if ((length = (token & ML_MASK)) == ML_MASK) - { - while (src_p < src_LASTLITERALS_1) // Error : a minimum input bytes must remain for LASTLITERALS + token - { - int s = src[src_p++]; - length += s; - if (s == 255) continue; - break; - } - } - - // copy repeated sequence - if (dst_p - dst_ref < STEPSIZE_32) - { - const int dec64 = 0; - dst[dst_p + 0] = dst[dst_ref + 0]; - dst[dst_p + 1] = dst[dst_ref + 1]; - dst[dst_p + 2] = dst[dst_ref + 2]; - dst[dst_p + 3] = dst[dst_ref + 3]; - dst_p += 4; - dst_ref += 4; - dst_ref -= dec32table[dst_p - dst_ref]; - Copy4(dst, dst_ref, dst_p); - dst_p += STEPSIZE_32 - 4; - dst_ref -= dec64; - } - else - { - Copy4(dst, dst_ref, dst_p); - dst_p += 4; - dst_ref += 4; - } - dst_cpy = dst_p + length - (STEPSIZE_32 - 4); - - if (dst_cpy > dst_COPYLENGTH_STEPSIZE_4) - { - if (dst_cpy > dst_LASTLITERALS) goto _output_error; // Error : last 5 bytes must be literals - if (dst_p < dst_COPYLENGTH) - { - _i = SecureCopy(dst, dst_ref, dst_p, dst_COPYLENGTH); - dst_ref += _i; - dst_p += _i; - } - - while (dst_p < dst_cpy) dst[dst_p++] = dst[dst_ref++]; - dst_p = dst_cpy; - continue; - } - - if (dst_p < dst_cpy) - { - SecureCopy(dst, dst_ref, dst_p, dst_cpy); - } - dst_p = dst_cpy; // correction - } - - // end of decoding - return ((dst_p) - dst_0); - - // write overflow error detected - _output_error: - return (-((src_p) - src_0)); - } - - #endregion - } -} - -// ReSharper restore RedundantIfElseBlock -// ReSharper restore JoinDeclarationAndInitializer -// ReSharper restore TooWideLocalVariableScope -// ReSharper restore InconsistentNaming -// ReSharper restore CheckNamespace diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs b/Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs deleted file mode 100644 index 446bbfd..0000000 --- a/Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs +++ /dev/null @@ -1,524 +0,0 @@ -#region LZ4 original - -/* - LZ4 - Fast LZ compression algorithm - Copyright (C) 2011-2012, Yann Collet. - BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html - - LZ4 source repository : http://code.google.com/p/lz4/ -*/ - -#endregion - -#region LZ4 port - -/* -Copyright (c) 2013, Milosz Krajewski -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, are permitted provided -that the following conditions are met: - -* Redistributions of source code must retain the above copyright notice, this list of conditions - and the following disclaimer. - -* Redistributions in binary form must reproduce the above copyright notice, this list of conditions - and the following disclaimer in the documentation and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED -WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN -IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#endregion - -// ReSharper disable InconsistentNaming - -namespace LZ4ps -{ - public static partial class LZ4Codec - { - // Update chains up to ip (excluded) - private static void LZ4HC_Insert_32(LZ4HC_Data_Structure ctx, int src_p) - { - var chainTable = ctx.chainTable; - var hashTable = ctx.hashTable; - var nextToUpdate = ctx.nextToUpdate; - var src = ctx.src; - var src_base = ctx.src_base; - - while (nextToUpdate < src_p) - { - var p = nextToUpdate; - var delta = (p) - (hashTable[(((Peek4(src, p)) * 2654435761u) >> HASHHC_ADJUST)] + src_base); - if (delta > MAX_DISTANCE) delta = MAX_DISTANCE; - chainTable[(p) & MAXD_MASK] = (ushort)delta; - hashTable[(((Peek4(src, p)) * 2654435761u) >> HASHHC_ADJUST)] = ((p) - src_base); - nextToUpdate++; - } - - ctx.nextToUpdate = nextToUpdate; - } - - private static int LZ4HC_CommonLength_32(LZ4HC_Data_Structure ctx, int p1, int p2) - { - var debruijn32 = DEBRUIJN_TABLE_32; - var src = ctx.src; - var src_LASTLITERALS = ctx.src_LASTLITERALS; - - var p1t = p1; - - while (p1t < src_LASTLITERALS - (STEPSIZE_32 - 1)) - { - var diff = (int)Xor4(src, p2, p1t); - if (diff == 0) - { - p1t += STEPSIZE_32; - p2 += STEPSIZE_32; - continue; - } - p1t += debruijn32[((uint)((diff) & -(diff)) * 0x077CB531u) >> 27]; - return (p1t - p1); - } - if ((p1t < (src_LASTLITERALS - 1)) && (Equal2(src, p2, p1t))) - { - p1t += 2; - p2 += 2; - } - if ((p1t < src_LASTLITERALS) && (src[p2] == src[p1t])) p1t++; - return (p1t - p1); - } - - private static int LZ4HC_InsertAndFindBestMatch_32(LZ4HC_Data_Structure ctx, int src_p, ref int src_match) - { - var chainTable = ctx.chainTable; - var hashTable = ctx.hashTable; - var src = ctx.src; - var src_base = ctx.src_base; - - var nbAttempts = MAX_NB_ATTEMPTS; - int repl = 0, ml = 0; - ushort delta = 0; - - // HC4 match finder - LZ4HC_Insert_32(ctx, src_p); - var src_ref = (hashTable[(((Peek4(src, src_p)) * 2654435761u) >> HASHHC_ADJUST)] + src_base); - - - // Detect repetitive sequences of length <= 4 - if (src_ref >= src_p - 4) // potential repetition - { - if (Equal4(src, src_ref, src_p)) // confirmed - { - delta = (ushort)(src_p - src_ref); - repl = ml = LZ4HC_CommonLength_32(ctx, src_p + MINMATCH, src_ref + MINMATCH) + MINMATCH; - src_match = src_ref; - } - src_ref = ((src_ref) - chainTable[(src_ref) & MAXD_MASK]); - } - - while ((src_ref >= src_p - MAX_DISTANCE) && (nbAttempts != 0)) - { - nbAttempts--; - if (src[(src_ref + ml)] == src[(src_p + ml)]) - { - if (Equal4(src, src_ref, src_p)) - { - var mlt = LZ4HC_CommonLength_32(ctx, src_p + MINMATCH, src_ref + MINMATCH) + MINMATCH; - if (mlt > ml) - { - ml = mlt; - src_match = src_ref; - } - } - } - src_ref = ((src_ref) - chainTable[(src_ref) & MAXD_MASK]); - } - - - // Complete table - if (repl != 0) - { - var src_ptr = src_p; - - var end = src_p + repl - (MINMATCH - 1); - while (src_ptr < end - delta) - { - chainTable[(src_ptr) & MAXD_MASK] = delta; // Pre-Load - src_ptr++; - } - do - { - chainTable[(src_ptr) & MAXD_MASK] = delta; - hashTable[(((Peek4(src, src_ptr)) * 2654435761u) >> HASHHC_ADJUST)] = ((src_ptr) - src_base); // Head of chain - src_ptr++; - } while (src_ptr < end); - ctx.nextToUpdate = end; - } - - return ml; - } - - private static int LZ4HC_InsertAndGetWiderMatch_32( - LZ4HC_Data_Structure ctx, int src_p, int startLimit, int longest, ref int matchpos, ref int startpos) - { - var chainTable = ctx.chainTable; - var hashTable = ctx.hashTable; - var src = ctx.src; - var src_base = ctx.src_base; - var src_LASTLITERALS = ctx.src_LASTLITERALS; - var debruijn32 = DEBRUIJN_TABLE_32; - var nbAttempts = MAX_NB_ATTEMPTS; - var delta = (src_p - startLimit); - - // First Match - LZ4HC_Insert_32(ctx, src_p); - var src_ref = (hashTable[(((Peek4(src, src_p)) * 2654435761u) >> HASHHC_ADJUST)] + src_base); - - while ((src_ref >= src_p - MAX_DISTANCE) && (nbAttempts != 0)) - { - nbAttempts--; - if (src[(startLimit + longest)] == src[(src_ref - delta + longest)]) - { - if (Equal4(src, src_ref, src_p)) - { - var reft = src_ref + MINMATCH; - var ipt = src_p + MINMATCH; - var startt = src_p; - - while (ipt < src_LASTLITERALS - (STEPSIZE_32 - 1)) - { - var diff = (int)Xor4(src, reft, ipt); - if (diff == 0) - { - ipt += STEPSIZE_32; - reft += STEPSIZE_32; - continue; - } - ipt += debruijn32[((uint)((diff) & -(diff)) * 0x077CB531u) >> 27]; - goto _endCount; - } - if ((ipt < (src_LASTLITERALS - 1)) && (Equal2(src, reft, ipt))) - { - ipt += 2; - reft += 2; - } - if ((ipt < src_LASTLITERALS) && (src[reft] == src[ipt])) ipt++; - - _endCount: - reft = src_ref; - - while ((startt > startLimit) && (reft > src_base) && (src[startt - 1] == src[reft - 1])) - { - startt--; - reft--; - } - - if ((ipt - startt) > longest) - { - longest = (ipt - startt); - matchpos = reft; - startpos = startt; - } - } - } - src_ref = ((src_ref) - chainTable[(src_ref) & MAXD_MASK]); - } - - return longest; - } - - private static int LZ4_encodeSequence_32( - LZ4HC_Data_Structure ctx, ref int src_p, ref int dst_p, ref int src_anchor, int matchLength, int src_ref, int dst_end) - { - int len; - var src = ctx.src; - var dst = ctx.dst; - - // Encode Literal length - var length = src_p - src_anchor; - var dst_token = dst_p++; - if ((dst_p + length + (2 + 1 + LASTLITERALS) + (length >> 8)) > dst_end) return 1; // Check output limit - if (length >= RUN_MASK) - { - dst[dst_token] = (RUN_MASK << ML_BITS); - len = length - RUN_MASK; - for (; len > 254; len -= 255) dst[dst_p++] = 255; - dst[dst_p++] = (byte)len; - } - else - { - dst[dst_token] = (byte)(length << ML_BITS); - } - - // Copy Literals - if (length > 0) - { - var _i = dst_p + length; - src_anchor += WildCopy(src, src_anchor, dst, dst_p, _i); - dst_p = _i; - } - - // Encode Offset - Poke2(dst, dst_p, (ushort)(src_p - src_ref)); - dst_p += 2; - - // Encode MatchLength - len = (matchLength - MINMATCH); - if (dst_p + (1 + LASTLITERALS) + (length >> 8) > dst_end) return 1; // Check output limit - if (len >= ML_MASK) - { - dst[dst_token] += ML_MASK; - len -= ML_MASK; - for (; len > 509; len -= 510) - { - dst[(dst_p)++] = 255; - dst[(dst_p)++] = 255; - } - if (len > 254) - { - len -= 255; - dst[(dst_p)++] = 255; - } - dst[(dst_p)++] = (byte)len; - } - else - { - dst[dst_token] += (byte)len; - } - - // Prepare next loop - src_p += matchLength; - src_anchor = src_p; - - return 0; - } - - private static int LZ4_compressHCCtx_32(LZ4HC_Data_Structure ctx) - { - var src = ctx.src; - var dst = ctx.dst; - var src_0 = ctx.src_base; - var src_end = ctx.src_end; - var dst_0 = ctx.dst_base; - var dst_len = ctx.dst_len; - var dst_end = ctx.dst_end; - - var src_p = src_0; - var src_anchor = src_p; - var src_mflimit = src_end - MFLIMIT; - - var dst_p = dst_0; - - var src_ref = 0; - var start2 = 0; - var ref2 = 0; - var start3 = 0; - var ref3 = 0; - - src_p++; - - // Main Loop - while (src_p < src_mflimit) - { - var ml = LZ4HC_InsertAndFindBestMatch_32(ctx, src_p, ref src_ref); - if (ml == 0) - { - src_p++; - continue; - } - - // saved, in case we would skip too much - var start0 = src_p; - var ref0 = src_ref; - var ml0 = ml; - - _Search2: - var ml2 = src_p + ml < src_mflimit - ? LZ4HC_InsertAndGetWiderMatch_32(ctx, src_p + ml - 2, src_p + 1, ml, ref ref2, ref start2) - : ml; - - if (ml2 == ml) // No better match - { - if (LZ4_encodeSequence_32(ctx, ref src_p, ref dst_p, ref src_anchor, ml, src_ref, dst_end) != 0) return 0; - continue; - } - - if (start0 < src_p) - { - if (start2 < src_p + ml0) // empirical - { - src_p = start0; - src_ref = ref0; - ml = ml0; - } - } - - // Here, start0==ip - if ((start2 - src_p) < 3) // First Match too small : removed - { - ml = ml2; - src_p = start2; - src_ref = ref2; - goto _Search2; - } - - _Search3: - // Currently we have : - // ml2 > ml1, and - // ip1+3 <= ip2 (usually < ip1+ml1) - if ((start2 - src_p) < OPTIMAL_ML) - { - var new_ml = ml; - if (new_ml > OPTIMAL_ML) new_ml = OPTIMAL_ML; - if (src_p + new_ml > start2 + ml2 - MINMATCH) new_ml = (start2 - src_p) + ml2 - MINMATCH; - var correction = new_ml - (start2 - src_p); - if (correction > 0) - { - start2 += correction; - ref2 += correction; - ml2 -= correction; - } - } - // Now, we have start2 = ip+new_ml, with new_ml=min(ml, OPTIMAL_ML=18) - - var ml3 = start2 + ml2 < src_mflimit - ? LZ4HC_InsertAndGetWiderMatch_32(ctx, start2 + ml2 - 3, start2, ml2, ref ref3, ref start3) - : ml2; - - if (ml3 == ml2) // No better match : 2 sequences to encode - { - // ip & ref are known; Now for ml - if (start2 < src_p + ml) ml = (start2 - src_p); - // Now, encode 2 sequences - if (LZ4_encodeSequence_32(ctx, ref src_p, ref dst_p, ref src_anchor, ml, src_ref, dst_end) != 0) return 0; - src_p = start2; - if (LZ4_encodeSequence_32(ctx, ref src_p, ref dst_p, ref src_anchor, ml2, ref2, dst_end) != 0) return 0; - continue; - } - - if (start3 < src_p + ml + 3) // Not enough space for match 2 : remove it - { - if (start3 >= (src_p + ml)) // can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 - { - if (start2 < src_p + ml) - { - var correction = (src_p + ml - start2); - start2 += correction; - ref2 += correction; - ml2 -= correction; - if (ml2 < MINMATCH) - { - start2 = start3; - ref2 = ref3; - ml2 = ml3; - } - } - - if (LZ4_encodeSequence_32(ctx, ref src_p, ref dst_p, ref src_anchor, ml, src_ref, dst_end) != 0) return 0; - src_p = start3; - src_ref = ref3; - ml = ml3; - - start0 = start2; - ref0 = ref2; - ml0 = ml2; - goto _Search2; - } - - start2 = start3; - ref2 = ref3; - ml2 = ml3; - goto _Search3; - } - - // OK, now we have 3 ascending matches; let's write at least the first one - // ip & ref are known; Now for ml - if (start2 < src_p + ml) - { - if ((start2 - src_p) < ML_MASK) - { - if (ml > OPTIMAL_ML) ml = OPTIMAL_ML; - if (src_p + ml > start2 + ml2 - MINMATCH) ml = (start2 - src_p) + ml2 - MINMATCH; - var correction = ml - (start2 - src_p); - if (correction > 0) - { - start2 += correction; - ref2 += correction; - ml2 -= correction; - } - } - else - { - ml = (start2 - src_p); - } - } - if (LZ4_encodeSequence_32(ctx, ref src_p, ref dst_p, ref src_anchor, ml, src_ref, dst_end) != 0) return 0; - - src_p = start2; - src_ref = ref2; - ml = ml2; - - start2 = start3; - ref2 = ref3; - ml2 = ml3; - - goto _Search3; - } - - // Encode Last Literals - { - var lastRun = (src_end - src_anchor); - if ((dst_p - dst_0) + lastRun + 1 + ((lastRun + 255 - RUN_MASK) / 255) > (uint)dst_len) return 0; // Check output limit - if (lastRun >= RUN_MASK) - { - dst[dst_p++] = (RUN_MASK << ML_BITS); - lastRun -= RUN_MASK; - for (; lastRun > 254; lastRun -= 255) dst[dst_p++] = 255; - dst[dst_p++] = (byte)lastRun; - } - else - { - dst[dst_p++] = (byte)(lastRun << ML_BITS); - } - BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor); - dst_p += src_end - src_anchor; - } - - // End - return (dst_p - dst_0); - } - } -} - -// ReSharper restore InconsistentNaming diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs b/Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs deleted file mode 100644 index fbeee17..0000000 --- a/Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs +++ /dev/null @@ -1,808 +0,0 @@ -#region LZ4 original - -/* - LZ4 - Fast LZ compression algorithm - Copyright (C) 2011-2012, Yann Collet. - BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html - - LZ4 source repository : http://code.google.com/p/lz4/ -*/ - -#endregion - -#region LZ4 port - -/* -Copyright (c) 2013, Milosz Krajewski -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, are permitted provided -that the following conditions are met: - -* Redistributions of source code must retain the above copyright notice, this list of conditions - and the following disclaimer. - -* Redistributions in binary form must reproduce the above copyright notice, this list of conditions - and the following disclaimer in the documentation and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED -WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN -IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#endregion - -// ReSharper disable CheckNamespace -// ReSharper disable InconsistentNaming -// ReSharper disable TooWideLocalVariableScope -// ReSharper disable JoinDeclarationAndInitializer -// ReSharper disable RedundantIfElseBlock - -namespace LZ4ps -{ - public static partial class LZ4Codec - { - #region LZ4_compressCtx - - private static int LZ4_compressCtx_safe64( - int[] hash_table, - byte[] src, - byte[] dst, - int src_0, - int dst_0, - int src_len, - int dst_maxlen) - { - var debruijn64 = DEBRUIJN_TABLE_64; - int _i; - - // ---- preprocessed source start here ---- - // r93 - var src_p = src_0; - var src_base = src_0; - var src_anchor = src_p; - var src_end = src_p + src_len; - var src_mflimit = src_end - MFLIMIT; - - var dst_p = dst_0; - var dst_end = dst_p + dst_maxlen; - - var src_LASTLITERALS = src_end - LASTLITERALS; - var src_LASTLITERALS_1 = src_LASTLITERALS - 1; - - var src_LASTLITERALS_3 = src_LASTLITERALS - 3; - - var src_LASTLITERALS_STEPSIZE_1 = src_LASTLITERALS - (STEPSIZE_64 - 1); - var dst_LASTLITERALS_1 = dst_end - (1 + LASTLITERALS); - var dst_LASTLITERALS_3 = dst_end - (2 + 1 + LASTLITERALS); - - int length; - - uint h, h_fwd; - - // Init - if (src_len < MINLENGTH) goto _last_literals; - - // First Byte - hash_table[(((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST)] = (src_p - src_base); - src_p++; - h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST); - - // Main Loop - while (true) - { - var findMatchAttempts = (1 << SKIPSTRENGTH) + 3; - var src_p_fwd = src_p; - int src_ref; - int dst_token; - - // Find a match - do - { - h = h_fwd; - var step = findMatchAttempts++ >> SKIPSTRENGTH; - src_p = src_p_fwd; - src_p_fwd = src_p + step; - - if (src_p_fwd > src_mflimit) goto _last_literals; - - h_fwd = (((Peek4(src, src_p_fwd)) * 2654435761u) >> HASH_ADJUST); - src_ref = src_base + hash_table[h]; - hash_table[h] = (src_p - src_base); - } while ((src_ref < src_p - MAX_DISTANCE) || (!Equal4(src, src_ref, src_p))); - - // Catch up - while ((src_p > src_anchor) && (src_ref > src_0) && (src[src_p - 1] == src[src_ref - 1])) - { - src_p--; - src_ref--; - } - - // Encode Literal length - length = (src_p - src_anchor); - dst_token = dst_p++; - - if (dst_p + length + (length >> 8) > dst_LASTLITERALS_3) return 0; // Check output limit - - if (length >= RUN_MASK) - { - var len = length - RUN_MASK; - dst[dst_token] = (RUN_MASK << ML_BITS); - if (len > 254) - { - do - { - dst[dst_p++] = 255; - len -= 255; - } while (len > 254); - dst[dst_p++] = (byte)len; - BlockCopy(src, src_anchor, dst, dst_p, length); - dst_p += length; - goto _next_match; - } - else - dst[dst_p++] = (byte)len; - } - else - { - dst[dst_token] = (byte)(length << ML_BITS); - } - - // Copy Literals - if (length > 0) - { - _i = dst_p + length; - WildCopy(src, src_anchor, dst, dst_p, _i); - dst_p = _i; - } - - _next_match: - // Encode Offset - Poke2(dst, dst_p, (ushort)(src_p - src_ref)); - dst_p += 2; - - // Start Counting - src_p += MINMATCH; - src_ref += MINMATCH; // MinMatch already verified - src_anchor = src_p; - - while (src_p < src_LASTLITERALS_STEPSIZE_1) - { - var diff = (long)Xor8(src, src_ref, src_p); - if (diff == 0) - { - src_p += STEPSIZE_64; - src_ref += STEPSIZE_64; - continue; - } - src_p += debruijn64[((ulong)((diff) & -(diff)) * 0x0218A392CDABBD3FL) >> 58]; - goto _endCount; - } - - if ((src_p < src_LASTLITERALS_3) && (Equal4(src, src_ref, src_p))) - { - src_p += 4; - src_ref += 4; - } - if ((src_p < src_LASTLITERALS_1) && (Equal2(src, src_ref, src_p))) - { - src_p += 2; - src_ref += 2; - } - if ((src_p < src_LASTLITERALS) && (src[src_ref] == src[src_p])) src_p++; - - _endCount: - // Encode MatchLength - length = (src_p - src_anchor); - - if (dst_p + (length >> 8) > dst_LASTLITERALS_1) return 0; // Check output limit - - if (length >= ML_MASK) - { - dst[dst_token] += ML_MASK; - length -= ML_MASK; - for (; length > 509; length -= 510) - { - dst[dst_p++] = 255; - dst[dst_p++] = 255; - } - if (length > 254) - { - length -= 255; - dst[dst_p++] = 255; - } - dst[dst_p++] = (byte)length; - } - else - { - dst[dst_token] += (byte)length; - } - - // Test end of chunk - if (src_p > src_mflimit) - { - src_anchor = src_p; - break; - } - - // Fill table - hash_table[(((Peek4(src, src_p - 2)) * 2654435761u) >> HASH_ADJUST)] = (src_p - 2 - src_base); - - // Test next position - - h = (((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST); - src_ref = src_base + hash_table[h]; - hash_table[h] = (src_p - src_base); - - if ((src_ref > src_p - (MAX_DISTANCE + 1)) && (Equal4(src, src_ref, src_p))) - { - dst_token = dst_p++; - dst[dst_token] = 0; - goto _next_match; - } - - // Prepare next loop - src_anchor = src_p++; - h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH_ADJUST); - } - - _last_literals: - // Encode Last Literals - { - var lastRun = (src_end - src_anchor); - - if (dst_p + lastRun + 1 + ((lastRun + 255 - RUN_MASK) / 255) > dst_end) return 0; - - if (lastRun >= RUN_MASK) - { - dst[dst_p++] = (RUN_MASK << ML_BITS); - lastRun -= RUN_MASK; - for (; lastRun > 254; lastRun -= 255) dst[dst_p++] = 255; - dst[dst_p++] = (byte)lastRun; - } - else dst[dst_p++] = (byte)(lastRun << ML_BITS); - BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor); - dst_p += src_end - src_anchor; - } - - // End - return (dst_p - dst_0); - } - - #endregion - - #region LZ4_compress64kCtx - - private static int LZ4_compress64kCtx_safe64( - ushort[] hash_table, - byte[] src, - byte[] dst, - int src_0, - int dst_0, - int src_len, - int dst_maxlen) - { - var debruijn64 = DEBRUIJN_TABLE_64; - int _i; - - // ---- preprocessed source start here ---- - // r93 - var src_p = src_0; - var src_anchor = src_p; - var src_base = src_p; - var src_end = src_p + src_len; - var src_mflimit = src_end - MFLIMIT; - - var dst_p = dst_0; - var dst_end = dst_p + dst_maxlen; - - var src_LASTLITERALS = src_end - LASTLITERALS; - var src_LASTLITERALS_1 = src_LASTLITERALS - 1; - - var src_LASTLITERALS_3 = src_LASTLITERALS - 3; - - var src_LASTLITERALS_STEPSIZE_1 = src_LASTLITERALS - (STEPSIZE_64 - 1); - var dst_LASTLITERALS_1 = dst_end - (1 + LASTLITERALS); - var dst_LASTLITERALS_3 = dst_end - (2 + 1 + LASTLITERALS); - - int len, length; - - uint h, h_fwd; - - // Init - if (src_len < MINLENGTH) goto _last_literals; - - // First Byte - src_p++; - h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH64K_ADJUST); - - // Main Loop - while (true) - { - var findMatchAttempts = (1 << SKIPSTRENGTH) + 3; - var src_p_fwd = src_p; - int src_ref; - int dst_token; - - // Find a match - do - { - h = h_fwd; - var step = findMatchAttempts++ >> SKIPSTRENGTH; - src_p = src_p_fwd; - src_p_fwd = src_p + step; - - if (src_p_fwd > src_mflimit) goto _last_literals; - - h_fwd = (((Peek4(src, src_p_fwd)) * 2654435761u) >> HASH64K_ADJUST); - src_ref = src_base + hash_table[h]; - hash_table[h] = (ushort)(src_p - src_base); - } while (!Equal4(src, src_ref, src_p)); - - // Catch up - while ((src_p > src_anchor) && (src_ref > src_0) && (src[src_p - 1] == src[src_ref - 1])) - { - src_p--; - src_ref--; - } - - // Encode Literal length - length = (src_p - src_anchor); - dst_token = dst_p++; - - if (dst_p + length + (length >> 8) > dst_LASTLITERALS_3) return 0; // Check output limit - - if (length >= RUN_MASK) - { - len = length - RUN_MASK; - dst[dst_token] = (RUN_MASK << ML_BITS); - if (len > 254) - { - do - { - dst[dst_p++] = 255; - len -= 255; - } while (len > 254); - dst[dst_p++] = (byte)len; - BlockCopy(src, src_anchor, dst, dst_p, length); - dst_p += length; - goto _next_match; - } - else - dst[dst_p++] = (byte)len; - } - else - { - dst[dst_token] = (byte)(length << ML_BITS); - } - - // Copy Literals - if (length > 0) /*?*/ - { - _i = dst_p + length; - WildCopy(src, src_anchor, dst, dst_p, _i); - dst_p = _i; - } - - _next_match: - // Encode Offset - Poke2(dst, dst_p, (ushort)(src_p - src_ref)); - dst_p += 2; - - // Start Counting - src_p += MINMATCH; - src_ref += MINMATCH; // MinMatch verified - src_anchor = src_p; - - while (src_p < src_LASTLITERALS_STEPSIZE_1) - { - var diff = (long)Xor8(src, src_ref, src_p); - if (diff == 0) - { - src_p += STEPSIZE_64; - src_ref += STEPSIZE_64; - continue; - } - src_p += debruijn64[((ulong)((diff) & -(diff)) * 0x0218A392CDABBD3FL) >> 58]; - goto _endCount; - } - - if ((src_p < src_LASTLITERALS_3) && (Equal4(src, src_ref, src_p))) - { - src_p += 4; - src_ref += 4; - } - if ((src_p < src_LASTLITERALS_1) && (Equal2(src, src_ref, src_p))) - { - src_p += 2; - src_ref += 2; - } - if ((src_p < src_LASTLITERALS) && (src[src_ref] == src[src_p])) src_p++; - - _endCount: - - // Encode MatchLength - len = (src_p - src_anchor); - - if (dst_p + (len >> 8) > dst_LASTLITERALS_1) return 0; // Check output limit - - if (len >= ML_MASK) - { - dst[dst_token] += ML_MASK; - len -= ML_MASK; - for (; len > 509; len -= 510) - { - dst[dst_p++] = 255; - dst[dst_p++] = 255; - } - if (len > 254) - { - len -= 255; - dst[dst_p++] = 255; - } - dst[dst_p++] = (byte)len; - } - else - { - dst[dst_token] += (byte)len; - } - - // Test end of chunk - if (src_p > src_mflimit) - { - src_anchor = src_p; - break; - } - - // Fill table - hash_table[(((Peek4(src, src_p - 2)) * 2654435761u) >> HASH64K_ADJUST)] = (ushort)(src_p - 2 - src_base); - - // Test next position - - h = (((Peek4(src, src_p)) * 2654435761u) >> HASH64K_ADJUST); - src_ref = src_base + hash_table[h]; - hash_table[h] = (ushort)(src_p - src_base); - - if (Equal4(src, src_ref, src_p)) - { - dst_token = dst_p++; - dst[dst_token] = 0; - goto _next_match; - } - - // Prepare next loop - src_anchor = src_p++; - h_fwd = (((Peek4(src, src_p)) * 2654435761u) >> HASH64K_ADJUST); - } - - _last_literals: - // Encode Last Literals - { - var lastRun = (src_end - src_anchor); - if (dst_p + lastRun + 1 + (lastRun - RUN_MASK + 255) / 255 > dst_end) return 0; - if (lastRun >= RUN_MASK) - { - dst[dst_p++] = (RUN_MASK << ML_BITS); - lastRun -= RUN_MASK; - for (; lastRun > 254; lastRun -= 255) dst[dst_p++] = 255; - dst[dst_p++] = (byte)lastRun; - } - else dst[dst_p++] = (byte)(lastRun << ML_BITS); - BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor); - dst_p += src_end - src_anchor; - } - - // End - return (dst_p - dst_0); - } - - #endregion - - #region LZ4_uncompress - - private static int LZ4_uncompress_safe64( - byte[] src, - byte[] dst, - int src_0, - int dst_0, - int dst_len) - { - var dec32table = DECODER_TABLE_32; - var dec64table = DECODER_TABLE_64; - int _i; - - // ---- preprocessed source start here ---- - // r93 - var src_p = src_0; - int dst_ref; - - var dst_p = dst_0; - var dst_end = dst_p + dst_len; - int dst_cpy; - - var dst_LASTLITERALS = dst_end - LASTLITERALS; - var dst_COPYLENGTH = dst_end - COPYLENGTH; - var dst_COPYLENGTH_STEPSIZE_4 = dst_end - COPYLENGTH - (STEPSIZE_64 - 4); - - uint token; - - // Main Loop - while (true) - { - int length; - - // get runlength - token = src[src_p++]; - if ((length = (byte)(token >> ML_BITS)) == RUN_MASK) - { - int len; - for (; (len = src[src_p++]) == 255; length += 255) - { - /* do nothing */ - } - length += len; - } - - // copy literals - dst_cpy = dst_p + length; - - if (dst_cpy > dst_COPYLENGTH) - { - if (dst_cpy != dst_end) goto _output_error; // Error : not enough place for another match (min 4) + 5 literals - BlockCopy(src, src_p, dst, dst_p, length); - src_p += length; - break; // EOF - } - if (dst_p < dst_cpy) /*?*/ - { - _i = WildCopy(src, src_p, dst, dst_p, dst_cpy); - src_p += _i; - dst_p += _i; - } - src_p -= (dst_p - dst_cpy); - dst_p = dst_cpy; - - // get offset - dst_ref = (dst_cpy) - Peek2(src, src_p); - src_p += 2; - if (dst_ref < dst_0) goto _output_error; // Error : offset outside destination buffer - - // get matchlength - if ((length = (byte)(token & ML_MASK)) == ML_MASK) - { - for (; src[src_p] == 255; length += 255) src_p++; - length += src[src_p++]; - } - - // copy repeated sequence - if ((dst_p - dst_ref) < STEPSIZE_64) - { - var dec64 = dec64table[dst_p - dst_ref]; - - dst[dst_p + 0] = dst[dst_ref + 0]; - dst[dst_p + 1] = dst[dst_ref + 1]; - dst[dst_p + 2] = dst[dst_ref + 2]; - dst[dst_p + 3] = dst[dst_ref + 3]; - dst_p += 4; - dst_ref += 4; - dst_ref -= dec32table[dst_p - dst_ref]; - Copy4(dst, dst_ref, dst_p); - dst_p += STEPSIZE_64 - 4; - dst_ref -= dec64; - } - else - { - Copy8(dst, dst_ref, dst_p); - dst_p += 8; - dst_ref += 8; - } - dst_cpy = dst_p + length - (STEPSIZE_64 - 4); - - if (dst_cpy > dst_COPYLENGTH_STEPSIZE_4) - { - if (dst_cpy > dst_LASTLITERALS) goto _output_error; // Error : last 5 bytes must be literals - if (dst_p < dst_COPYLENGTH) - { - _i = SecureCopy(dst, dst_ref, dst_p, dst_COPYLENGTH); - dst_ref += _i; - dst_p += _i; - } - - while (dst_p < dst_cpy) dst[dst_p++] = dst[dst_ref++]; - dst_p = dst_cpy; - continue; - } - - if (dst_p < dst_cpy) - { - SecureCopy(dst, dst_ref, dst_p, dst_cpy); - } - dst_p = dst_cpy; // correction - } - - // end of decoding - return ((src_p) - src_0); - - _output_error: - // write overflow error detected - return (-((src_p) - src_0)); - } - - #endregion - - #region LZ4_uncompress_unknownOutputSize - - private static int LZ4_uncompress_unknownOutputSize_safe64( - byte[] src, - byte[] dst, - int src_0, - int dst_0, - int src_len, - int dst_maxlen) - { - var dec32table = DECODER_TABLE_32; - var dec64table = DECODER_TABLE_64; - int _i; - - // ---- preprocessed source start here ---- - // r93 - var src_p = src_0; - var src_end = src_p + src_len; - int dst_ref; - - var dst_p = dst_0; - var dst_end = dst_p + dst_maxlen; - int dst_cpy; - - var src_LASTLITERALS_3 = (src_end - (2 + 1 + LASTLITERALS)); - var src_LASTLITERALS_1 = (src_end - (LASTLITERALS + 1)); - var dst_COPYLENGTH = (dst_end - COPYLENGTH); - var dst_COPYLENGTH_STEPSIZE_4 = (dst_end - (COPYLENGTH + (STEPSIZE_64 - 4))); - var dst_LASTLITERALS = (dst_end - LASTLITERALS); - var dst_MFLIMIT = (dst_end - MFLIMIT); - - // Special case - if (src_p == src_end) goto _output_error; // A correctly formed null-compressed LZ4 must have at least one byte (token=0) - - // Main Loop - while (true) - { - byte token; - int length; - - // get runlength - token = src[src_p++]; - if ((length = (token >> ML_BITS)) == RUN_MASK) - { - var s = 255; - while ((src_p < src_end) && (s == 255)) length += (s = src[src_p++]); - } - - // copy literals - dst_cpy = dst_p + length; - - if ((dst_cpy > dst_MFLIMIT) || (src_p + length > src_LASTLITERALS_3)) - { - if (dst_cpy > dst_end) goto _output_error; // Error : writes beyond output buffer - if (src_p + length != src_end) goto _output_error; // Error : LZ4 format requires to consume all input at this stage (no match within the last 11 bytes, and at least 8 remaining input bytes for another match+literals) - BlockCopy(src, src_p, dst, dst_p, length); - dst_p += length; - break; // Necessarily EOF, due to parsing restrictions - } - if (dst_p < dst_cpy) /*?*/ - { - _i = WildCopy(src, src_p, dst, dst_p, dst_cpy); - src_p += _i; - dst_p += _i; - } - src_p -= (dst_p - dst_cpy); - dst_p = dst_cpy; - - // get offset - dst_ref = (dst_cpy) - Peek2(src, src_p); - src_p += 2; - if (dst_ref < dst_0) goto _output_error; // Error : offset outside of destination buffer - - // get matchlength - if ((length = (token & ML_MASK)) == ML_MASK) - { - while (src_p < src_LASTLITERALS_1) // Error : a minimum input bytes must remain for LASTLITERALS + token - { - int s = src[src_p++]; - length += s; - if (s == 255) continue; - break; - } - } - - // copy repeated sequence - if (dst_p - dst_ref < STEPSIZE_64) - { - var dec64 = dec64table[dst_p - dst_ref]; - dst[dst_p + 0] = dst[dst_ref + 0]; - dst[dst_p + 1] = dst[dst_ref + 1]; - dst[dst_p + 2] = dst[dst_ref + 2]; - dst[dst_p + 3] = dst[dst_ref + 3]; - dst_p += 4; - dst_ref += 4; - dst_ref -= dec32table[dst_p - dst_ref]; - Copy4(dst, dst_ref, dst_p); - dst_p += STEPSIZE_64 - 4; - dst_ref -= dec64; - } - else - { - Copy8(dst, dst_ref, dst_p); - dst_p += 8; - dst_ref += 8; - } - dst_cpy = dst_p + length - (STEPSIZE_64 - 4); - - if (dst_cpy > dst_COPYLENGTH_STEPSIZE_4) - { - if (dst_cpy > dst_LASTLITERALS) goto _output_error; // Error : last 5 bytes must be literals - if (dst_p < dst_COPYLENGTH) - { - _i = SecureCopy(dst, dst_ref, dst_p, dst_COPYLENGTH); - dst_ref += _i; - dst_p += _i; - } - while (dst_p < dst_cpy) dst[dst_p++] = dst[dst_ref++]; - dst_p = dst_cpy; - continue; - } - - if (dst_p < dst_cpy) - { - SecureCopy(dst, dst_ref, dst_p, dst_cpy); - } - dst_p = dst_cpy; // correction - } - - // end of decoding - return ((dst_p) - dst_0); - - // write overflow error detected - _output_error: - return (-((src_p) - src_0)); - } - - #endregion - } -} - -// ReSharper restore RedundantIfElseBlock -// ReSharper restore JoinDeclarationAndInitializer -// ReSharper restore TooWideLocalVariableScope -// ReSharper restore InconsistentNaming -// ReSharper restore CheckNamespace diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs b/Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs deleted file mode 100644 index 8ff946c..0000000 --- a/Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs +++ /dev/null @@ -1,526 +0,0 @@ -#region LZ4 original - -/* - LZ4 - Fast LZ compression algorithm - Copyright (C) 2011-2012, Yann Collet. - BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are - met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following disclaimer - in the documentation and/or other materials provided with the - distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - You can contact the author at : - - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html - - LZ4 source repository : http://code.google.com/p/lz4/ -*/ - -#endregion - -#region LZ4 port - -/* -Copyright (c) 2013, Milosz Krajewski -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, are permitted provided -that the following conditions are met: - -* Redistributions of source code must retain the above copyright notice, this list of conditions - and the following disclaimer. - -* Redistributions in binary form must reproduce the above copyright notice, this list of conditions - and the following disclaimer in the documentation and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED -WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN -IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#endregion - -// ReSharper disable InconsistentNaming - -namespace LZ4ps -{ - public static partial class LZ4Codec - { - private static void LZ4HC_Insert_64(LZ4HC_Data_Structure ctx, int src_p) - { - var chainTable = ctx.chainTable; - var hashTable = ctx.hashTable; - var src = ctx.src; - var src_base = ctx.src_base; - var nextToUpdate = ctx.nextToUpdate; - - while (nextToUpdate < src_p) - { - var p = nextToUpdate; - var delta = (p) - (hashTable[(((Peek4(src, p)) * 2654435761u) >> HASHHC_ADJUST)] + src_base); - if (delta > MAX_DISTANCE) delta = MAX_DISTANCE; - chainTable[(p) & MAXD_MASK] = (ushort)delta; - hashTable[(((Peek4(src, p)) * 2654435761u) >> HASHHC_ADJUST)] = ((p) - src_base); - nextToUpdate++; - } - - ctx.nextToUpdate = nextToUpdate; - } - - private static int LZ4HC_CommonLength_64(LZ4HC_Data_Structure ctx, int p1, int p2) - { - var debruijn64 = DEBRUIJN_TABLE_64; - var src = ctx.src; - var src_LASTLITERALS = ctx.src_LASTLITERALS; - var p1t = p1; - - while (p1t < src_LASTLITERALS - (STEPSIZE_64 - 1)) - { - var diff = (long)Xor8(src, p2, p1t); - if (diff == 0) - { - p1t += STEPSIZE_64; - p2 += STEPSIZE_64; - continue; - } - p1t += debruijn64[((ulong)((diff) & -(diff)) * 0x0218A392CDABBD3FL) >> 58]; - return (p1t - p1); - } - if ((p1t < (src_LASTLITERALS - 3)) && (Equal4(src, p2, p1t))) - { - p1t += 4; - p2 += 4; - } - if ((p1t < (src_LASTLITERALS - 1)) && (Equal2(src, p2, p1t))) - { - p1t += 2; - p2 += 2; - } - if ((p1t < src_LASTLITERALS) && (src[p2] == src[p1t])) p1t++; - return (p1t - p1); - } - - private static int LZ4HC_InsertAndFindBestMatch_64(LZ4HC_Data_Structure ctx, int src_p, ref int matchpos) - { - var chainTable = ctx.chainTable; - var hashTable = ctx.hashTable; - var src = ctx.src; - var src_base = ctx.src_base; - var nbAttempts = MAX_NB_ATTEMPTS; - int repl = 0, ml = 0; - ushort delta = 0; - - // HC4 match finder - LZ4HC_Insert_64(ctx, src_p); - var src_ref = (hashTable[(((Peek4(src, src_p)) * 2654435761u) >> HASHHC_ADJUST)] + src_base); - - // Detect repetitive sequences of length <= 4 - if (src_ref >= src_p - 4) // potential repetition - { - if (Equal4(src, src_ref, src_p)) // confirmed - { - delta = (ushort)(src_p - src_ref); - repl = ml = LZ4HC_CommonLength_64(ctx, src_p + MINMATCH, src_ref + MINMATCH) + MINMATCH; - matchpos = src_ref; - } - src_ref = ((src_ref) - chainTable[(src_ref) & MAXD_MASK]); - } - - - while ((src_ref >= src_p - MAX_DISTANCE) && (nbAttempts != 0)) - { - nbAttempts--; - if (src[src_ref + ml] == src[src_p + ml]) - { - if (Equal4(src, src_ref, src_p)) - { - var mlt = LZ4HC_CommonLength_64(ctx, src_p + MINMATCH, src_ref + MINMATCH) + MINMATCH; - if (mlt > ml) - { - ml = mlt; - matchpos = src_ref; - } - } - } - src_ref = ((src_ref) - chainTable[(src_ref) & MAXD_MASK]); - } - - - // Complete table - if (repl != 0) - { - var ptr = src_p; - - var end = src_p + repl - (MINMATCH - 1); - while (ptr < end - delta) - { - chainTable[(ptr) & MAXD_MASK] = delta; // Pre-Load - ptr++; - } - do - { - chainTable[(ptr) & MAXD_MASK] = delta; - hashTable[(((Peek4(src, ptr)) * 2654435761u) >> HASHHC_ADJUST)] = ((ptr) - src_base); // Head of chain - ptr++; - } while (ptr < end); - ctx.nextToUpdate = end; - } - - return ml; - } - - private static int LZ4HC_InsertAndGetWiderMatch_64(LZ4HC_Data_Structure ctx, int src_p, int startLimit, int longest, ref int matchpos, ref int startpos) - { - var debruijn64 = DEBRUIJN_TABLE_64; - var chainTable = ctx.chainTable; - var hashTable = ctx.hashTable; - var src = ctx.src; - var src_base = ctx.src_base; - var src_LASTLITERALS = ctx.src_LASTLITERALS; - var nbAttempts = MAX_NB_ATTEMPTS; - var delta = (src_p - startLimit); - - // First Match - LZ4HC_Insert_64(ctx, src_p); - var src_ref = (hashTable[(((Peek4(src, src_p)) * 2654435761u) >> HASHHC_ADJUST)] + src_base); - - while ((src_ref >= src_p - MAX_DISTANCE) && (nbAttempts != 0)) - { - nbAttempts--; - if (src[startLimit + longest] == src[src_ref - delta + longest]) - { - if (Equal4(src, src_ref, src_p)) - { - var reft = src_ref + MINMATCH; - var ipt = src_p + MINMATCH; - var startt = src_p; - - while (ipt < src_LASTLITERALS - (STEPSIZE_64 - 1)) - { - var diff = (long)Xor8(src, reft, ipt); - if (diff == 0) - { - ipt += STEPSIZE_64; - reft += STEPSIZE_64; - continue; - } - ipt += debruijn64[((ulong)((diff) & -(diff)) * 0x0218A392CDABBD3FL) >> 58]; - goto _endCount; - } - if ((ipt < (src_LASTLITERALS - 3)) && (Equal4(src, reft, ipt))) - { - ipt += 4; - reft += 4; - } - if ((ipt < (src_LASTLITERALS - 1)) && (Equal2(src, reft, ipt))) - { - ipt += 2; - reft += 2; - } - if ((ipt < src_LASTLITERALS) && (src[reft] == src[ipt])) ipt++; - - _endCount: - reft = src_ref; - - while ((startt > startLimit) && (reft > src_base) && (src[startt - 1] == src[reft - 1])) - { - startt--; - reft--; - } - - if ((ipt - startt) > longest) - { - longest = (ipt - startt); - matchpos = reft; - startpos = startt; - } - } - } - src_ref = ((src_ref) - chainTable[(src_ref) & MAXD_MASK]); - } - - return longest; - } - - private static int LZ4_encodeSequence_64(LZ4HC_Data_Structure ctx, ref int src_p, ref int dst_p, ref int src_anchor, int matchLength, int src_ref) - { - var src = ctx.src; - var dst = ctx.dst; - var dst_end = ctx.dst_end; - int len; - - // Encode Literal length - var length = (src_p - src_anchor); - var dst_token = (dst_p)++; - if ((dst_p + length + (2 + 1 + LASTLITERALS) + (length >> 8)) > dst_end) return 1; // Check output limit - if (length >= RUN_MASK) - { - dst[dst_token] = (RUN_MASK << ML_BITS); - len = length - RUN_MASK; - for (; len > 254; len -= 255) dst[dst_p++] = 255; - dst[dst_p++] = (byte)len; - } - else - { - dst[dst_token] = (byte)(length << ML_BITS); - } - - // Copy Literals - if (length > 0) - { - var _i = dst_p + length; - src_anchor += WildCopy(src, src_anchor, dst, dst_p, _i); - dst_p = _i; - } - - // Encode Offset - Poke2(dst, dst_p, (ushort)(src_p - src_ref)); - dst_p += 2; - - // Encode MatchLength - len = (matchLength - MINMATCH); - if (dst_p + (1 + LASTLITERALS) + (length >> 8) > dst_end) return 1; // Check output limit - if (len >= ML_MASK) - { - dst[dst_token] += ML_MASK; - len -= ML_MASK; - for (; len > 509; len -= 510) - { - dst[dst_p++] = 255; - dst[dst_p++] = 255; - } - if (len > 254) - { - len -= 255; - dst[dst_p++] = 255; - } - dst[dst_p++] = (byte)len; - } - else - { - dst[dst_token] += (byte)len; - } - - // Prepare next loop - src_p += matchLength; - src_anchor = src_p; - - return 0; - } - - private static int LZ4_compressHCCtx_64(LZ4HC_Data_Structure ctx) - { - var src = ctx.src; - var src_p = ctx.src_base; - var src_end = ctx.src_end; - var dst_0 = ctx.dst_base; - var src_anchor = src_p; - var src_mflimit = src_end - MFLIMIT; - var dst = ctx.dst; - var dst_len = ctx.dst_len; - var dst_p = ctx.dst_base; - - var xxx_ref = 0; - var start2 = 0; - var ref2 = 0; - var start3 = 0; - var ref3 = 0; - - src_p++; - - // Main Loop - while (src_p < src_mflimit) - { - var ml = LZ4HC_InsertAndFindBestMatch_64(ctx, src_p, ref xxx_ref); - if (ml == 0) - { - src_p++; - continue; - } - - // saved, in case we would skip too much - var start0 = src_p; - var ref0 = xxx_ref; - var ml0 = ml; - - _Search2: - var ml2 = src_p + ml < src_mflimit - ? LZ4HC_InsertAndGetWiderMatch_64(ctx, src_p + ml - 2, src_p + 1, ml, ref ref2, ref start2) - : ml; - - if (ml2 == ml) // No better match - { - if (LZ4_encodeSequence_64(ctx, ref src_p, ref dst_p, ref src_anchor, ml, xxx_ref) != 0) return 0; - continue; - } - - if (start0 < src_p) - { - if (start2 < src_p + ml0) // empirical - { - src_p = start0; - xxx_ref = ref0; - ml = ml0; - } - } - - // Here, start0==ip - if ((start2 - src_p) < 3) // First Match too small : removed - { - ml = ml2; - src_p = start2; - xxx_ref = ref2; - goto _Search2; - } - - _Search3: - // Currently we have : - // ml2 > ml1, and - // ip1+3 <= ip2 (usually < ip1+ml1) - if ((start2 - src_p) < OPTIMAL_ML) - { - var new_ml = ml; - if (new_ml > OPTIMAL_ML) new_ml = OPTIMAL_ML; - if (src_p + new_ml > start2 + ml2 - MINMATCH) new_ml = (start2 - src_p) + ml2 - MINMATCH; - var correction = new_ml - (start2 - src_p); - if (correction > 0) - { - start2 += correction; - ref2 += correction; - ml2 -= correction; - } - } - // Now, we have start2 = ip+new_ml, with new_ml=min(ml, OPTIMAL_ML=18) - - var ml3 = start2 + ml2 < src_mflimit - ? LZ4HC_InsertAndGetWiderMatch_64(ctx, start2 + ml2 - 3, start2, ml2, ref ref3, ref start3) - : ml2; - - if (ml3 == ml2) // No better match : 2 sequences to encode - { - // ip & ref are known; Now for ml - if (start2 < src_p + ml) ml = (start2 - src_p); - // Now, encode 2 sequences - if (LZ4_encodeSequence_64(ctx, ref src_p, ref dst_p, ref src_anchor, ml, xxx_ref) != 0) return 0; - src_p = start2; - if (LZ4_encodeSequence_64(ctx, ref src_p, ref dst_p, ref src_anchor, ml2, ref2) != 0) return 0; - continue; - } - - if (start3 < src_p + ml + 3) // Not enough space for match 2 : remove it - { - if (start3 >= (src_p + ml)) // can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 - { - if (start2 < src_p + ml) - { - var correction = (src_p + ml - start2); - start2 += correction; - ref2 += correction; - ml2 -= correction; - if (ml2 < MINMATCH) - { - start2 = start3; - ref2 = ref3; - ml2 = ml3; - } - } - - if (LZ4_encodeSequence_64(ctx, ref src_p, ref dst_p, ref src_anchor, ml, xxx_ref) != 0) return 0; - src_p = start3; - xxx_ref = ref3; - ml = ml3; - - start0 = start2; - ref0 = ref2; - ml0 = ml2; - goto _Search2; - } - - start2 = start3; - ref2 = ref3; - ml2 = ml3; - goto _Search3; - } - - // OK, now we have 3 ascending matches; let's write at least the first one - // ip & ref are known; Now for ml - if (start2 < src_p + ml) - { - if ((start2 - src_p) < ML_MASK) - { - if (ml > OPTIMAL_ML) ml = OPTIMAL_ML; - if (src_p + ml > start2 + ml2 - MINMATCH) ml = (start2 - src_p) + ml2 - MINMATCH; - var correction = ml - (start2 - src_p); - if (correction > 0) - { - start2 += correction; - ref2 += correction; - ml2 -= correction; - } - } - else - { - ml = (start2 - src_p); - } - } - if (LZ4_encodeSequence_64(ctx, ref src_p, ref dst_p, ref src_anchor, ml, xxx_ref) != 0) return 0; - - src_p = start2; - xxx_ref = ref2; - ml = ml2; - - start2 = start3; - ref2 = ref3; - ml2 = ml3; - - goto _Search3; - } - - // Encode Last Literals - { - var lastRun = (src_end - src_anchor); - if ((dst_p - dst_0) + lastRun + 1 + ((lastRun + 255 - RUN_MASK) / 255) > (uint)dst_len) return 0; // Check output limit - if (lastRun >= RUN_MASK) - { - dst[dst_p++] = (RUN_MASK << ML_BITS); - lastRun -= RUN_MASK; - for (; lastRun > 254; lastRun -= 255) dst[dst_p++] = 255; - dst[dst_p++] = (byte)lastRun; - } - else - { - dst[dst_p++] = (byte)(lastRun << ML_BITS); - } - BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor); - dst_p += src_end - src_anchor; - } - - // End - return (dst_p - dst_0); - } - } -} - -// ReSharper restore InconsistentNaming diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs.meta b/Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs.meta deleted file mode 100644 index e6f49e8..0000000 --- a/Assets/Scripts/LZ4/LZ4Codec.Safe64HC.Dirty.cs.meta +++ /dev/null @@ -1,11 +0,0 @@ -fileFormatVersion: 2 -guid: c61e65caf96385a469be74084e2e1f00 -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/Assets/Scripts/LZ4/LZ4Codec.cs b/Assets/Scripts/LZ4/LZ4Codec.cs deleted file mode 100644 index 5cdf315..0000000 --- a/Assets/Scripts/LZ4/LZ4Codec.cs +++ /dev/null @@ -1,176 +0,0 @@ -#region license - -/* -Copyright (c) 2013, Milosz Krajewski -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, are permitted provided -that the following conditions are met: - -* Redistributions of source code must retain the above copyright notice, this list of conditions - and the following disclaimer. - -* Redistributions in binary form must reproduce the above copyright notice, this list of conditions - and the following disclaimer in the documentation and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED -WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN -IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#endregion - -using System; - -/* -NOTE: - This file is shared between LZ4pn and LZ4ps. - If you would like to modify this file please keep in mind that your changes will - affect both projects. - Use 'UNSAFE' conditional define to differentiate -*/ - -// ReSharper disable InconsistentNaming - -#if UNSAFE -namespace LZ4pn -#else -namespace LZ4ps -#endif -{ - public static partial class LZ4Codec - { - #region configuration - - /// - /// Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.) - /// Increasing memory usage improves compression ratio - /// Reduced memory usage can improve speed, due to cache effect - /// Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache - /// - private const int MEMORY_USAGE = 20; - - /// - /// Decreasing this value will make the algorithm skip faster data segments considered "incompressible" - /// This may decrease compression ratio dramatically, but will be faster on incompressible data - /// Increasing this value will make the algorithm search more before declaring a segment "incompressible" - /// This could improve compression a bit, but will be slower on incompressible data - /// The default value (6) is recommended - /// - private const int NOTCOMPRESSIBLE_DETECTIONLEVEL = 6; - -#if !UNSAFE - - /// Buffer length when Buffer.BlockCopy becomes faster than straight loop. - /// Please note that safe implementation REQUIRES it to be greater (not even equal) than 8. - private const int BLOCK_COPY_LIMIT = 16; - -#endif - - #endregion - - #region consts - - private const int MINMATCH = 4; - #pragma warning disable 162 - // ReSharper disable once UnreachableCode - private const int SKIPSTRENGTH = - NOTCOMPRESSIBLE_DETECTIONLEVEL > 2 - ? NOTCOMPRESSIBLE_DETECTIONLEVEL - : 2; - #pragma warning restore 162 - private const int COPYLENGTH = 8; - private const int LASTLITERALS = 5; - private const int MFLIMIT = COPYLENGTH + MINMATCH; - private const int MINLENGTH = MFLIMIT + 1; - private const int MAXD_LOG = 16; - private const int MAXD = 1 << MAXD_LOG; - private const int MAXD_MASK = MAXD - 1; - private const int MAX_DISTANCE = (1 << MAXD_LOG) - 1; - private const int ML_BITS = 4; - private const int ML_MASK = (1 << ML_BITS) - 1; - private const int RUN_BITS = 8 - ML_BITS; - private const int RUN_MASK = (1 << RUN_BITS) - 1; - private const int STEPSIZE_64 = 8; - private const int STEPSIZE_32 = 4; - - private const int LZ4_64KLIMIT = (1 << 16) + (MFLIMIT - 1); - - private const int HASH_LOG = MEMORY_USAGE - 2; - private const int HASH_TABLESIZE = 1 << HASH_LOG; - private const int HASH_ADJUST = (MINMATCH * 8) - HASH_LOG; - - private const int HASH64K_LOG = HASH_LOG + 1; - private const int HASH64K_TABLESIZE = 1 << HASH64K_LOG; - private const int HASH64K_ADJUST = (MINMATCH * 8) - HASH64K_LOG; - - private const int HASHHC_LOG = MAXD_LOG - 1; - private const int HASHHC_TABLESIZE = 1 << HASHHC_LOG; - private const int HASHHC_ADJUST = (MINMATCH * 8) - HASHHC_LOG; - //private const int HASHHC_MASK = HASHHC_TABLESIZE - 1; - - private static readonly int[] DECODER_TABLE_32 = { 0, 3, 2, 3, 0, 0, 0, 0 }; - private static readonly int[] DECODER_TABLE_64 = { 0, 0, 0, -1, 0, 1, 2, 3 }; - - private static readonly int[] DEBRUIJN_TABLE_32 = { - 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, - 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 - }; - - private static readonly int[] DEBRUIJN_TABLE_64 = { - 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, - 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, - 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, - 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 - }; - - private const int MAX_NB_ATTEMPTS = 256; - private const int OPTIMAL_ML = (ML_MASK - 1) + MINMATCH; - - #endregion - - #region public interface (common) - - /// Gets maximum the length of the output. - /// Length of the input. - /// Maximum number of bytes needed for compressed buffer. - public static int MaximumOutputLength(int inputLength) - { - return inputLength + (inputLength / 255) + 16; - } - - #endregion - - #region internal interface (common) - - internal static void CheckArguments( - byte[] input, int inputOffset, ref int inputLength, - byte[] output, int outputOffset, ref int outputLength) - { - if (inputLength < 0) inputLength = input.Length - inputOffset; - if (inputLength == 0) - { - outputLength = 0; - return; - } - - if (input == null) throw new ArgumentNullException("input"); - if (inputOffset < 0 || inputOffset + inputLength > input.Length) - throw new ArgumentException("inputOffset and inputLength are invalid for given input"); - - if (outputLength < 0) outputLength = output.Length - outputOffset; - if (output == null) throw new ArgumentNullException("output"); - if (outputOffset < 0 || outputOffset + outputLength > output.Length) - throw new ArgumentException("outputOffset and outputLength are invalid for given output"); - } - - #endregion - } -} - -// ReSharper restore InconsistentNaming \ No newline at end of file diff --git a/Assets/Scripts/LZ4/LZ4Codec.cs.meta b/Assets/Scripts/LZ4/LZ4Codec.cs.meta deleted file mode 100644 index ea0b563..0000000 --- a/Assets/Scripts/LZ4/LZ4Codec.cs.meta +++ /dev/null @@ -1,11 +0,0 @@ -fileFormatVersion: 2 -guid: 60265417a9a7cb346be1757b77ecdd37 -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/Assets/Scripts/LZ4/LZ4Util.cs b/Assets/Scripts/LZ4/LZ4Util.cs deleted file mode 100644 index de805dc..0000000 --- a/Assets/Scripts/LZ4/LZ4Util.cs +++ /dev/null @@ -1,129 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.IO; -//using LZ4Sharp; -using LZ4ps; - -namespace LZ4 -{ - /// - /// 置換 - /// - public class LZ4Util - { - public static byte[] decompress(byte[] indata) - { - int m_curPos = 4; - int token = (int)(indata[m_curPos - 4] | (indata[m_curPos - 3] << 8) | (indata[m_curPos - 2] << 16) | (indata[m_curPos - 1] << 24)); - m_curPos += 4; - int decompSize = (int)(indata[m_curPos - 4] | (indata[m_curPos - 3] << 8) | (indata[m_curPos - 2] << 16) | (indata[m_curPos - 1] << 24)); - m_curPos += 4; - int compSize = (int)(indata[m_curPos - 4] | (indata[m_curPos - 3] << 8) | (indata[m_curPos - 2] << 16) | (indata[m_curPos - 1] << 24)); - m_curPos += 4; - int tmp4 = (int)(indata[m_curPos - 4] | (indata[m_curPos - 3] << 8) | (indata[m_curPos - 2] << 16) | (indata[m_curPos - 1] << 24)); - - //byte[] srcBytes = new byte[compSize]; - //Array.Copy(indata, 0x10, srcBytes, 0, compSize); - - if (IntPtr.Size == 4) - { - return LZ4Codec.Decode32(indata, 0x10, compSize, decompSize); - } - else - { - return LZ4Codec.Decode64(indata, 0x10, compSize, decompSize); - } - } - } - /* - public class LZ4Util - { - - public static byte[] decompress(byte[] indata) - { - LZ4.BinaryReader r = new LZ4.BinaryReader(indata); - - byte[] dec = decompress(r); - - return dec; - } - - public static byte[] decompress(BinaryReader r) - { - byte[] retArray; - var dataSize = 0; - var decompressedSize = 0; - - var token = 0; - var sqSize = 0; - var matchSize = 0; - var offset = 0; - var retCurPos = 0; - var endPos = 0; - - r.seekAbs(4); - decompressedSize = r.readIntLE(); - dataSize = r.readIntLE(); - endPos = dataSize + 16; - retArray = new byte[decompressedSize]; - - r.seekAbs(16); - - //Start reading sequences - while (true) - { - //read the LiteralSize and the MatchSize - token = r.readByte(); - sqSize = token >> 4; - matchSize = (token & 0x0F) + 4; - if (sqSize == 15) - sqSize += readAdditionalSize(r); - - //copy the literal - r.copyBytes(retArray, retCurPos, sqSize); - retCurPos += sqSize; - - if (r.getPos() >= endPos - 1) - break; - - //read the offset - offset = r.readShortLE(); - - //read the additional MatchSize - if (matchSize == 19) - matchSize += readAdditionalSize(r); - - //copy the match properly - if (matchSize > offset) - { - var matchPos = retCurPos - offset; - while (true) - { - Array.Copy(retArray, matchPos, retArray, retCurPos, offset); - retCurPos += offset; - matchSize -= offset; - if (matchSize < offset) - break; - } - } - Array.Copy(retArray, retCurPos - offset, retArray, retCurPos, matchSize); - retCurPos += matchSize; - } - - - return retArray; - } - - public static int readAdditionalSize(BinaryReader reader) - { - var size = reader.readByte(); - if (size == 255) - return size + readAdditionalSize(reader); - else - return size; - } - } - */ -} diff --git a/Assets/Scripts/LZ4/LZ4Util.cs.meta b/Assets/Scripts/LZ4/LZ4Util.cs.meta deleted file mode 100644 index 05ff99b..0000000 --- a/Assets/Scripts/LZ4/LZ4Util.cs.meta +++ /dev/null @@ -1,11 +0,0 @@ -fileFormatVersion: 2 -guid: a39980c7200b27b4b8357880848e8646 -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/Assets/Scripts/Manifest.cs b/Assets/Scripts/Manifest.cs new file mode 100644 index 0000000..02d7b8f --- /dev/null +++ b/Assets/Scripts/Manifest.cs @@ -0,0 +1,6 @@ +namespace Assets.Scripts +{ + internal class Manifest + { + } +} \ No newline at end of file diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs.meta b/Assets/Scripts/Manifest.cs.meta similarity index 83% rename from Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs.meta rename to Assets/Scripts/Manifest.cs.meta index f1a35b3..9d555b1 100644 --- a/Assets/Scripts/LZ4/LZ4Codec.Safe32HC.Dirty.cs.meta +++ b/Assets/Scripts/Manifest.cs.meta @@ -1,5 +1,5 @@ fileFormatVersion: 2 -guid: 0cd0b555f5386b84b9fc6aea0b43418d +guid: 6edaa1ece12a29d43beec62ef0d73d29 MonoImporter: externalObjects: {} serializedVersion: 2 diff --git a/Assets/Scripts/Manifest.meta b/Assets/Scripts/Manifest.meta new file mode 100644 index 0000000..e6efa53 --- /dev/null +++ b/Assets/Scripts/Manifest.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: b5ad1e27f0d722e44bbd45017d9aaec8 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/Manifest/BSVReader.cs b/Assets/Scripts/Manifest/BSVReader.cs new file mode 100644 index 0000000..0e460fd --- /dev/null +++ b/Assets/Scripts/Manifest/BSVReader.cs @@ -0,0 +1,242 @@ +using K4os.Compression.LZ4.Streams; +using System; +using System.IO; + +public class BSVReader +{ + public enum ReadMode + { + Memory = 0, + Stream = 1 + } + + private enum Phase : byte + { + Header = 0, + Body = 1, + End = 2 + } + + private enum HeaderPhaseApriori : byte + { + Start = 0, + RowCount = 1, + MaxRowSize = 2 + } + + public enum Format : byte + { + Apriori = 0, + AnonymousSchema = 1 + } + + public static ulong ReadVLQ(byte[] buf, ref int offset, int max_bytes = 8) + { + ulong n = 0; + int count = 0; + while (count < max_bytes) + { + count++; + var val = (buf[offset] & 127Lu); + n |= val; + var isEnd = ((buf[offset] & 128) == 0); + offset++; + if (isEnd) + { + return n; + } + else + { + n = n << 7; + } + } + return n; + } + public static ulong ReadUNum(byte[] buf, ref int offset, int bytes) + { + var arraySegment = new ArraySegment(buf, offset, bytes); + offset += bytes; + ulong n = 0; + for(int i = arraySegment.Offset; i < arraySegment.Offset+arraySegment.Count; i++) + { + n = n << 8; + n |= arraySegment.Array[i]; + } + return n; + } + public static ArraySegment ReadText(byte[] buf, ref int offset) + { + int start = offset; + while (buf[offset] != 0 && offset < buf.Length) + { + offset++; + } + var arraySegment = new ArraySegment(buf, start, offset - start); + offset++; + return arraySegment; + } + public static ArraySegment ReadFixedBlob(byte[] buf, ref int offset, int bytes) + { + var arraySegment = new ArraySegment(buf, offset, bytes); + offset += bytes; + return arraySegment; + } + public static ArraySegment ReadFixedText(byte[] buf, ref int offset, int bytes) + { + var arraySegment = new ArraySegment(buf, offset, bytes); + offset += bytes; + return arraySegment; + } + public static ArraySegment ReadBlob(byte[] buf, ref int offset) + { + ulong size = ReadVLQ(buf, ref offset); + var arraySegment = new ArraySegment(buf, offset, (int)size); + offset += (int)size; + return arraySegment; + } + + public static T[] GetArray(ArraySegment array) + { + T[] subArray = new T[array.Count]; + Buffer.BlockCopy(array.Array, array.Offset, subArray, 0, array.Count); + return subArray; + } + + internal static IBSVReader Init(string path, ReadMode mode, bool isCompressed) + { + try + { + byte[] input; + if (isCompressed) + { + var source = new MemoryStream(File.ReadAllBytes(path)); + var decoder = LZ4Stream.Decode(source); + var target = new MemoryStream(); + decoder.CopyTo(target); + input = target.ToArray(); + } + else + { + input = File.ReadAllBytes(path); + } + + if (mode == ReadMode.Stream) + { + return new AprioriBSVReader(input, 2); + } + else + { + return new AnonymousSchemaBSVReader(input, 2); + } + } + catch (Exception e) + { + throw e; + } + } + + public interface IBSVReader : IDisposable + { + public abstract ulong GetRowCount(); + public abstract Format GetFormat(); + + public abstract bool ReadLine(ILineParser parser, ref T dat); + } + + public interface ILineParser + { + public abstract void Parse(byte[] buf, ref int offset, ref T dat); + } + + internal abstract class BaseBSVReader : IBSVReader, IDisposable + { + protected readonly byte[] buf; + protected int offset; + protected ulong rowCount; + protected ulong maxRowSize; + protected ulong row; + protected readonly Format format; + public ulong GetRowCount() { return rowCount; } + public Format GetFormat() { return format; } + public BaseBSVReader(Format format, byte[] buf, int offset) + { + this.format = format; + this.buf = buf; + this.offset = offset; + } + public bool ReadLine(ILineParser parser, ref T dat) + { + if (offset < buf.Length) + { + parser.Parse(buf, ref offset, ref dat); + return true; + } + else return false; + } + public abstract void Dispose(); + } + + internal class AnonymousSchemaBSVReader : BaseBSVReader + { + private readonly ushort headerSize; + private readonly uint schemaCount; + private readonly uint schemaVersion; + private readonly Schema[] schemas; + + internal uint GetSchemaCount() { return schemaCount; } + + internal uint GetSchemaVersion() { return schemaVersion; } + + public AnonymousSchemaBSVReader(byte[] buf, int offset) : base(Format.AnonymousSchema, buf, offset) + { + headerSize = (ushort)ReadUNum(buf, ref this.offset, 2); + rowCount = ReadVLQ(buf, ref this.offset); + maxRowSize = ReadVLQ(buf, ref this.offset); + schemaVersion = (uint)ReadVLQ(buf, ref this.offset); + schemaCount = (uint)ReadVLQ(buf, ref this.offset); + if (schemaCount > 0) + { + schemas = new Schema[schemaCount]; + for (int i = 0; i < schemaCount; i++) + { + Schema.Type type = (Schema.Type)ReadUNum(buf, ref this.offset, 1); + ulong? fixSize = null; + if (type == Schema.Type.UNumFixed || type == Schema.Type.TextFixed || type == Schema.Type.BlobFixed) + { + fixSize = ReadVLQ(buf, ref this.offset); + } + schemas[i] = new Schema(type, fixSize); + } + } + } + + public override void Dispose() { } + } + + public class Schema + { + public enum Type : byte + { + UShort = 16, + UInt = 17, + ULong = 18, + UNum = 32, + UNumFixed = 33, + Blob = 48, + BlobFixed = 49, + Text = 64, + TextFixed = 65 + } + public readonly Type type; + public readonly ulong? fixedSize; + + public Schema(Type type, ulong? fixedSize) { } + } + + internal class AprioriBSVReader : BaseBSVReader + { + public AprioriBSVReader(byte[] buf, int offset) : base(Format.Apriori, buf, offset) { } + public override void Dispose() { } + } +} + diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe.cs.meta b/Assets/Scripts/Manifest/BSVReader.cs.meta similarity index 83% rename from Assets/Scripts/LZ4/LZ4Codec.Safe.cs.meta rename to Assets/Scripts/Manifest/BSVReader.cs.meta index c5fc009..f1e1744 100644 --- a/Assets/Scripts/LZ4/LZ4Codec.Safe.cs.meta +++ b/Assets/Scripts/Manifest/BSVReader.cs.meta @@ -1,5 +1,5 @@ fileFormatVersion: 2 -guid: a2f5d2c7e152d8f43ab710530107c9ff +guid: 4a15e32c966280446ba094c5db043677 MonoImporter: externalObjects: {} serializedVersion: 2 diff --git a/Assets/Scripts/Manifest/ManifestCategory.cs b/Assets/Scripts/Manifest/ManifestCategory.cs new file mode 100644 index 0000000..32fc3f7 --- /dev/null +++ b/Assets/Scripts/Manifest/ManifestCategory.cs @@ -0,0 +1,17 @@ + +public static class ManifestCategory +{ + public const int APP_DEFINED_KIND_BASE = 10; + public const string ASSET_MANIFEST = "manifest"; + public const string PLATFORM_MANIFEST = "manifest2"; + public const string ROOT_MANIFEST = "manifest3"; + + public enum Kind : int + { + Default = 0, + AssetManifest = 1, + PlatformManifest = 2, + RootManifest = 3 + } +} + diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs.meta b/Assets/Scripts/Manifest/ManifestCategory.cs.meta similarity index 83% rename from Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs.meta rename to Assets/Scripts/Manifest/ManifestCategory.cs.meta index bb791e8..a45c1b6 100644 --- a/Assets/Scripts/LZ4/LZ4Codec.Safe64.Dirty.cs.meta +++ b/Assets/Scripts/Manifest/ManifestCategory.cs.meta @@ -1,5 +1,5 @@ fileFormatVersion: 2 -guid: 04fd67d662c762548a89d1fe5bf6cfcc +guid: be0b7cdd8f20ce14b8d0e1d129684d19 MonoImporter: externalObjects: {} serializedVersion: 2 diff --git a/Assets/Scripts/Manifest/ManifestDB.cs b/Assets/Scripts/Manifest/ManifestDB.cs new file mode 100644 index 0000000..d61ad03 --- /dev/null +++ b/Assets/Scripts/Manifest/ManifestDB.cs @@ -0,0 +1,43 @@ +using Mono.Data.Sqlite; +using System; +using UnityEngine; +using static BSVReader; +using static ManifestCategory; + +public class ManifestDB +{ + public SqliteConnection metaDb; + + public static ManifestEntry[] GetManifest(string path, bool isCompressed, Kind kind) + { + IBSVReader reader = Init(path, ReadMode.Memory, isCompressed); + ulong count = reader.GetRowCount(); + ManifestEntry[] manifests = new ManifestEntry[count]; + if (kind == Kind.AssetManifest) + { + for (ulong i = 0; i < count; i++) + { + manifests[i].kind = (int)kind; + if (!reader.ReadLine(ManifestEntry.GetBsvParser(ManifestEntry.Format.Full, reader), ref manifests[i])) + { + throw new Exception("ReadLineError"); + } + } + } + else + { + for (ulong i = 0; i < count; i++) + { + manifests[i].kind = (int)kind; + if (!reader.ReadLine(ManifestEntry.GetBsvParser(ManifestEntry.Format.Simplified, reader), ref manifests[i])) + { + throw new Exception("ReadLineError"); + } + } + } + return manifests; + } + + +} + diff --git a/Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs.meta b/Assets/Scripts/Manifest/ManifestDB.cs.meta similarity index 83% rename from Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs.meta rename to Assets/Scripts/Manifest/ManifestDB.cs.meta index 7086673..4621d41 100644 --- a/Assets/Scripts/LZ4/LZ4Codec.Safe32.Dirty.cs.meta +++ b/Assets/Scripts/Manifest/ManifestDB.cs.meta @@ -1,5 +1,5 @@ fileFormatVersion: 2 -guid: 8c5dc5c9f2a382b4db836cf150c3a176 +guid: 1c5745921b997134aa8682f304140a8a MonoImporter: externalObjects: {} serializedVersion: 2 diff --git a/Assets/Scripts/Manifest/ManifestEntry.cs b/Assets/Scripts/Manifest/ManifestEntry.cs new file mode 100644 index 0000000..8ed0730 --- /dev/null +++ b/Assets/Scripts/Manifest/ManifestEntry.cs @@ -0,0 +1,124 @@ +using BaseNcoding; +using System; +using System.Security.Cryptography; +using System.Text; +using UnityEngine; +using static BSVReader; + +public struct ManifestEntry +{ + public byte[] name; + public byte[] deps; + public uint group; + public uint priority; + public ulong size; + public ulong checksum; + public string hname; + public int kind; + + public enum Format + { + Simplified = 0, + Full = 1 + } + + public static byte[] CalHame(ulong checksum, ulong size, byte[] name) + { + if (name == null) return null; + SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider(); + byte[] allbyte = new byte[name.Length + 16]; + byte[] checksumByte = BitConverter.GetBytes(checksum); + byte[] sizeByte = BitConverter.GetBytes(size); + for (int i = 0; i < 16; i++) + { + allbyte[i] = (i < 8 ? checksumByte[7 - i] : sizeByte[15 - i]); + } + Buffer.BlockCopy(name, 0, allbyte, 16, name.Length); + return sha1.ComputeHash(allbyte); + } + + public static string CalHameString(ulong checksum, ulong size, byte[] name) + { + var bytes = CalHame(checksum, size, name); + Base32 base32 = new Base32(); + return base32.Encode(bytes); + } + + public static string CalHameString(ulong checksum, ulong size, string name) + { + return CalHameString(checksum, size, Encoding.UTF8.GetBytes(name)); + } + + public override string ToString() + { + StringBuilder s = new StringBuilder(); + s.AppendFormat("Name : {0} ", Encoding.UTF8.GetString(name)); + s.AppendFormat("Deps : {0} \n", deps == null ? "NULL" : Encoding.UTF8.GetString(deps)); + s.AppendFormat("Size : {0} ", size); + s.AppendFormat("Checksum : {0} ", (long)checksum); + s.AppendFormat("Group : {0} ", group); + s.AppendFormat("Priority : {0} ", priority); + s.AppendFormat("Kind : {0} ", kind); + s.AppendFormat("Hash : {0} ", CalHameString(checksum, size, name)); + return s.ToString(); + } + + public static ILineParser GetBsvParser(Format format, IBSVReader bsvReader) + { + if (format == Format.Simplified) + { + return new SimplifiedEntryLineReader(); + } + else + { + if (bsvReader is AnonymousSchemaBSVReader) + { + return new FullEntryLineReader(); + } + else if (bsvReader is AprioriBSVReader) + { + return new LegacyFullEntryLineReader(); + } + return null; + } + } + + public class SimplifiedEntryLineReader : ILineParser + { + public void Parse(byte[] buf, ref int offset, ref ManifestEntry dat) + { + dat.name = GetArray(ReadText(buf, ref offset)); + dat.size = ReadVLQ(buf, ref offset); + dat.checksum = ReadUNum(buf, ref offset, 8); + } + + } + + public class FullEntryLineReader : ILineParser + { + + public void Parse(byte[] buf, ref int offset, ref ManifestEntry dat) + { + dat.name = GetArray(ReadText(buf, ref offset)); + dat.deps = GetArray(ReadText(buf, ref offset)); + dat.group = (uint)ReadVLQ(buf, ref offset, 4); + dat.priority = (uint)ReadVLQ(buf, ref offset, 4); + dat.size = (uint)ReadVLQ(buf, ref offset, 8); + dat.checksum = ReadUNum(buf, ref offset, 8); + } + + } + + public class LegacyFullEntryLineReader : ILineParser + { + public void Parse(byte[] buf, ref int offset, ref ManifestEntry dat) + { + dat.name = GetArray(ReadText(buf, ref offset)); + dat.deps = GetArray(ReadText(buf, ref offset)); + dat.group = (uint)ReadVLQ(buf, ref offset, 4); + dat.size = (uint)ReadVLQ(buf, ref offset, 8); + dat.checksum = ReadUNum(buf, ref offset, 8); + dat.priority = 0; + } + } +} diff --git a/Assets/Scripts/ManifestEntry.cs.meta b/Assets/Scripts/Manifest/ManifestEntry.cs.meta similarity index 83% rename from Assets/Scripts/ManifestEntry.cs.meta rename to Assets/Scripts/Manifest/ManifestEntry.cs.meta index c617097..bc8a297 100644 --- a/Assets/Scripts/ManifestEntry.cs.meta +++ b/Assets/Scripts/Manifest/ManifestEntry.cs.meta @@ -1,5 +1,5 @@ fileFormatVersion: 2 -guid: 822adc4dd85200142901586dd5c697c6 +guid: f446452d64e1ef54399daba449bbb5dc MonoImporter: externalObjects: {} serializedVersion: 2 diff --git a/Assets/Scripts/ManifestEntry.cs b/Assets/Scripts/ManifestEntry.cs deleted file mode 100644 index ca498f1..0000000 --- a/Assets/Scripts/ManifestEntry.cs +++ /dev/null @@ -1,35 +0,0 @@ -using BaseNcoding; -using System; -using System.Security.Cryptography; -using System.Text; -using UnityEngine; -public class ManifestEntry -{ - public static byte[] CalHame(ulong checksum, ulong size, byte[] name) - { - if (name == null) return null; - SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider(); - byte[] allbyte = new byte[name.Length + 16]; - byte[] checksumByte = BitConverter.GetBytes(checksum); - byte[] sizeByte = BitConverter.GetBytes(size); - for (int i = 0; i < 16; i++) - { - allbyte[i] = (i < 8 ? checksumByte[7 - i] : sizeByte[15 - i]); - } - Buffer.BlockCopy(name, 0, allbyte, 16, name.Length); - return sha1.ComputeHash(allbyte); - } - - public static string CalHameString(ulong checksum, ulong size, byte[] name) - { - var bytes = CalHame(checksum, size, name); - Base32 base32 = new Base32(); - return base32.Encode(bytes); - } - - public static string CalHameString(ulong checksum, ulong size, string name) - { - return CalHameString(checksum, size, Encoding.UTF8.GetBytes(name)); - } -} - diff --git a/Assets/Scripts/UmaViewerMain.cs b/Assets/Scripts/UmaViewerMain.cs index cde8f8f..18232b8 100644 --- a/Assets/Scripts/UmaViewerMain.cs +++ b/Assets/Scripts/UmaViewerMain.cs @@ -5,6 +5,7 @@ using UnityEngine; using System; using Newtonsoft.Json.Linq; using System.Collections; +using static ManifestCategory; public class UmaViewerMain : MonoBehaviour { From e79e796a21b25b795e2f025b96aeb005d90d62d9 Mon Sep 17 00:00:00 2001 From: CroakFang <1605296300@qq.com> Date: Thu, 15 Dec 2022 13:55:32 +0800 Subject: [PATCH 6/8] Generate Meta database from game server --- .gitignore | 1 + Assets/Scripts/Manifest.cs | 6 - Assets/Scripts/Manifest.cs.meta | 11 -- Assets/Scripts/Manifest/BSVReader.cs | 8 +- Assets/Scripts/Manifest/ManifestDB.cs | 212 ++++++++++++++++++++- Assets/Scripts/Manifest/ManifestEntry.cs | 31 +++ Assets/Scripts/UmaDatabase/UmaDataTypes.cs | 3 +- 7 files changed, 245 insertions(+), 27 deletions(-) delete mode 100644 Assets/Scripts/Manifest.cs delete mode 100644 Assets/Scripts/Manifest.cs.meta diff --git a/.gitignore b/.gitignore index 7cb2e66..cf16bff 100644 --- a/.gitignore +++ b/.gitignore @@ -63,3 +63,4 @@ crashlytics-build.properties /Assets/Plugins/RootMotion/PuppetMaster/_Integration /VMDRecords +/umamusume diff --git a/Assets/Scripts/Manifest.cs b/Assets/Scripts/Manifest.cs deleted file mode 100644 index 02d7b8f..0000000 --- a/Assets/Scripts/Manifest.cs +++ /dev/null @@ -1,6 +0,0 @@ -namespace Assets.Scripts -{ - internal class Manifest - { - } -} \ No newline at end of file diff --git a/Assets/Scripts/Manifest.cs.meta b/Assets/Scripts/Manifest.cs.meta deleted file mode 100644 index 9d555b1..0000000 --- a/Assets/Scripts/Manifest.cs.meta +++ /dev/null @@ -1,11 +0,0 @@ -fileFormatVersion: 2 -guid: 6edaa1ece12a29d43beec62ef0d73d29 -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/Assets/Scripts/Manifest/BSVReader.cs b/Assets/Scripts/Manifest/BSVReader.cs index 0e460fd..2ead37c 100644 --- a/Assets/Scripts/Manifest/BSVReader.cs +++ b/Assets/Scripts/Manifest/BSVReader.cs @@ -1,6 +1,7 @@ using K4os.Compression.LZ4.Streams; using System; using System.IO; +using UnityEngine; public class BSVReader { @@ -67,7 +68,7 @@ public class BSVReader public static ArraySegment ReadText(byte[] buf, ref int offset) { int start = offset; - while (buf[offset] != 0 && offset < buf.Length) + while (offset < buf.Length &&buf[offset] != 0) { offset++; } @@ -102,7 +103,7 @@ public class BSVReader return subArray; } - internal static IBSVReader Init(string path, ReadMode mode, bool isCompressed) + internal static IBSVReader Init(string path, bool isCompressed,ReadMode mode = ReadMode.Memory) { try { @@ -131,7 +132,8 @@ public class BSVReader } catch (Exception e) { - throw e; + Debug.LogError("Read Manifest File Error :" + e); + return null; } } diff --git a/Assets/Scripts/Manifest/ManifestDB.cs b/Assets/Scripts/Manifest/ManifestDB.cs index d61ad03..86888d5 100644 --- a/Assets/Scripts/Manifest/ManifestDB.cs +++ b/Assets/Scripts/Manifest/ManifestDB.cs @@ -1,26 +1,160 @@ using Mono.Data.Sqlite; using System; +using System.Collections; +using System.IO; +using System.Text; using UnityEngine; +using UnityEngine.Networking; using static BSVReader; using static ManifestCategory; public class ManifestDB { - public SqliteConnection metaDb; + public SqliteConnection MetaDB; + public string DBPath; + public static string MANIFEST_ROOT_URL = "https://prd-storage-app-umamusume.akamaized.net/dl/resources/Manifest"; + public ManifestDB(string DBPath) + { + this.DBPath = DBPath; + if (File.Exists(DBPath)) + { + MetaDB = new SqliteConnection($@"Data Source={DBPath}"); + } + else + { + SqliteConnection.CreateFile(DBPath); + MetaDB = new SqliteConnection($@"Data Source={DBPath}"); + MetaDB.Open(); + SqliteCommand cmd = new SqliteCommand( + "CREATE TABLE `a` ( `i` INTEGER PRIMARY KEY,`n` TEXT NOT NULL,`d` TEXT,`g` INTEGER(4) NOT NULL,`l` INTEGER(8) NOT NULL,`c` INTEGER(8) NOT NULL,`h` TEXT NOT NULL,`m` TEXT NOT NULL,`k` INTEGER(1) NOT NULL,`s` INTEGER(1) NOT NULL,`p` INTEGER(4) NOT NULL DEFAULT 0)"); + cmd.Connection = MetaDB; + cmd.ExecuteNonQuery(); + cmd.CommandText = "CREATE INDEX `a0` ON `a`(`n`, `s`)"; + cmd.ExecuteNonQuery(); + cmd.CommandText = "CREATE INDEX `a2` ON `a`(`m`, `s`)"; + cmd.ExecuteNonQuery(); + cmd.CommandText = "CREATE INDEX `a3` ON `a`(`g`, 's')"; + cmd.ExecuteNonQuery(); + cmd.CommandText = "CREATE INDEX `a4` ON `a`(`p`)"; + cmd.ExecuteNonQuery(); + cmd.CommandText = "CREATE INDEX `a1` ON `a`(`s`)"; + cmd.ExecuteNonQuery(); + } + } + + + //umamusume uses the manifest file to generate meta database. + //it needs to get the root manifest file first + //then read the root manifest to get other manifest file information + //recursively read the manifest file to obtain all resource files information + //finally, insert all data into the meta database + public IEnumerator GenerateMetaDB(ulong rootSize, ulong rootCheckSum) + { + if (MetaDB == null || MetaDB.State == System.Data.ConnectionState.Closed) { + Debug.LogError("Open Meta Database Error"); + yield break; + } + + //Insert root + ManifestEntry rootEntry = new ManifestEntry(Encoding.UTF8.GetBytes("root"), null, 0, 0, rootSize, rootCheckSum, "", 3); + rootEntry.hname = rootEntry.CalHameString(); + + SqliteCommand command = new SqliteCommand(MetaDB); + command.CommandText = "DELETE FROM a"; + command.ExecuteNonQuery(); + + int index = 1; + InsertManifestEntry(index, "manifest3", rootEntry, ref command); + + //Insert platform + ManifestEntry[] platformEntrys = null; + yield return GetManifest(rootEntry.hname, Kind.PlatformManifest, entrys => { platformEntrys = entrys; }); + if (platformEntrys == null) + { + Debug.LogError("Read PlatformManifest Error"); + MetaDB.Close(); + yield break; + } + ManifestEntry platformEntry = GetLocalPlatformEntry(platformEntrys); + index++; + InsertManifestEntry(index, "manifest2", platformEntry, ref command); + + //Insert AssetManifest + ManifestEntry[] assetEntrys = null; + yield return GetManifest(platformEntry.hname, Kind.AssetManifest, entrys => { assetEntrys = entrys; }); + if (assetEntrys == null) + { + Debug.LogError("Read AssetManifest Error"); + MetaDB.Close(); + yield break; + } + using (SqliteTransaction tran = MetaDB.BeginTransaction()) + { + foreach (var entry in assetEntrys) + { + index++; + InsertManifestEntry(index, "manifest", entry, ref command); + } + tran.Commit(); + } + + //Insert Asset + foreach (var assetEntry in assetEntrys) + { + ManifestEntry[] assets = null; + yield return GetManifest(assetEntry.hname, Kind.Default, entrys => { assets = entrys; }); + if (assets == null) + { + Debug.LogError("Read AssetManifest Error"); + continue; + } + using (SqliteTransaction tran = MetaDB.BeginTransaction()) + { + foreach (var entry in assets) + { + index++; + InsertManifestEntry(index, assetEntry.tname, entry, ref command); + } + tran.Commit(); + } + } + MetaDB.Close(); + } + + private void InsertManifestEntry(int index, string type, ManifestEntry entry, ref SqliteCommand command) + { + command.CommandText = "INSERT INTO a (i,n,d,g,l,c,h,m,k,s,p) VALUES (@id,@name,@deps,@group,@length,@check,@hash,@m,@k,@s,@p)"; + command.Parameters.Clear(); + command.Parameters.Add(new SqliteParameter("@id", index)); + command.Parameters.Add(new SqliteParameter("@name", (type.Contains("manifest") ? "//" : "") + entry.tname)); + command.Parameters.Add(new SqliteParameter("@deps", entry.tdeps)); + command.Parameters.Add(new SqliteParameter("@group", entry.group)); + command.Parameters.Add(new SqliteParameter("@length", (long)entry.size)); + command.Parameters.Add(new SqliteParameter("@check", (long)entry.checksum)); + command.Parameters.Add(new SqliteParameter("@hash", entry.hname)); + command.Parameters.Add(new SqliteParameter("@m", type)); + command.Parameters.Add(new SqliteParameter("@k", (byte)entry.kind)); + command.Parameters.Add(new SqliteParameter("@s", 1)); + command.Parameters.Add(new SqliteParameter("@p", entry.priority)); + command.ExecuteNonQuery(); + } public static ManifestEntry[] GetManifest(string path, bool isCompressed, Kind kind) { - IBSVReader reader = Init(path, ReadMode.Memory, isCompressed); + IBSVReader reader = Init(path, isCompressed); + if (reader == null) return null; + ulong count = reader.GetRowCount(); ManifestEntry[] manifests = new ManifestEntry[count]; - if (kind == Kind.AssetManifest) + if (kind == Kind.Default) { for (ulong i = 0; i < count; i++) { manifests[i].kind = (int)kind; if (!reader.ReadLine(ManifestEntry.GetBsvParser(ManifestEntry.Format.Full, reader), ref manifests[i])) { - throw new Exception("ReadLineError"); + Debug.LogError("ReadLineError"); + return null; } } } @@ -31,13 +165,79 @@ public class ManifestDB manifests[i].kind = (int)kind; if (!reader.ReadLine(ManifestEntry.GetBsvParser(ManifestEntry.Format.Simplified, reader), ref manifests[i])) { - throw new Exception("ReadLineError"); + Debug.LogError("ReadLineError"); + return null; } } } return manifests; + } - + public IEnumerator GetManifest(string hash, Kind kind, Action callback) + { + var path = GetManifestPath(hash); + if (!File.Exists(path)) + { + yield return DownloadManifest(hash); + } + if (File.Exists(path)) + { + callback.Invoke(GetManifest(path, true, kind)); + } + } + + public IEnumerator DownloadManifest(string hash) + { + UnityWebRequest www = UnityWebRequest.Get(GetManifestRequestUrl(hash)); + yield return www.SendWebRequest(); + if (www.result == UnityWebRequest.Result.Success) + { + File.WriteAllBytes(GetManifestPath(hash), www.downloadHandler.data); + } + else + { + Debug.LogError("Download Manifest Failed :" + www.error); + } + } + + public string GetManifestPath(string hash, bool createPath = true) + { + string path = $"{Path.GetDirectoryName(DBPath)}/dat/{hash.Substring(0, 2)}"; + if (createPath && !Directory.Exists(path)) + { + Directory.CreateDirectory(path); + } + return path + $"/{hash}"; + } + + public static string GetManifestRequestUrl(string hash) + { + return $"{MANIFEST_ROOT_URL}/{hash.Substring(0, 2)}/{hash}"; + } + + public static ManifestEntry GetLocalPlatformEntry(ManifestEntry[] platformEntrys) + { + foreach (var entry in platformEntrys) + { + if (Encoding.UTF8.GetString(entry.name) == "Windows" && Application.platform == RuntimePlatform.WindowsPlayer) + { + return entry; + } + else if (Encoding.UTF8.GetString(entry.name) == "IOS" && Application.platform == RuntimePlatform.IPhonePlayer) + { + return entry; + } + else if (Encoding.UTF8.GetString(entry.name) == "Android" && Application.platform == RuntimePlatform.Android) + { + return entry; + } + else + { + return entry; + } + } + return platformEntrys[0]; + } } diff --git a/Assets/Scripts/Manifest/ManifestEntry.cs b/Assets/Scripts/Manifest/ManifestEntry.cs index 8ed0730..c522d81 100644 --- a/Assets/Scripts/Manifest/ManifestEntry.cs +++ b/Assets/Scripts/Manifest/ManifestEntry.cs @@ -9,6 +9,8 @@ public struct ManifestEntry { public byte[] name; public byte[] deps; + public string tname; + public string tdeps; public uint group; public uint priority; public ulong size; @@ -16,12 +18,27 @@ public struct ManifestEntry public string hname; public int kind; + public ManifestEntry(byte[] name, byte[] deps, uint group, uint priority, ulong size, ulong checksum, string hname, int kind) + { + this.name = name; + this.deps = deps; + this.group = group; + this.priority = priority; + this.size = size; + this.checksum = checksum; + this.hname = hname; + this.kind = kind; + this.tname = Encoding.UTF8.GetString(this.name); + this.tdeps = (this.deps == null ? null : Encoding.UTF8.GetString(this.deps)); + } + public enum Format { Simplified = 0, Full = 1 } + public static byte[] CalHame(ulong checksum, ulong size, byte[] name) { if (name == null) return null; @@ -37,6 +54,7 @@ public struct ManifestEntry return sha1.ComputeHash(allbyte); } + public static string CalHameString(ulong checksum, ulong size, byte[] name) { var bytes = CalHame(checksum, size, name); @@ -49,6 +67,11 @@ public struct ManifestEntry return CalHameString(checksum, size, Encoding.UTF8.GetBytes(name)); } + public string CalHameString() + { + return CalHameString(checksum, size, name); + } + public override string ToString() { StringBuilder s = new StringBuilder(); @@ -90,6 +113,8 @@ public struct ManifestEntry dat.name = GetArray(ReadText(buf, ref offset)); dat.size = ReadVLQ(buf, ref offset); dat.checksum = ReadUNum(buf, ref offset, 8); + dat.hname = CalHameString(dat.checksum, dat.size, dat.name); + dat.tname = Encoding.UTF8.GetString(dat.name); } } @@ -105,6 +130,9 @@ public struct ManifestEntry dat.priority = (uint)ReadVLQ(buf, ref offset, 4); dat.size = (uint)ReadVLQ(buf, ref offset, 8); dat.checksum = ReadUNum(buf, ref offset, 8); + dat.hname = CalHameString(dat.checksum, dat.size, dat.name); + dat.tname = Encoding.UTF8.GetString(dat.name); + dat.tdeps = (dat.deps == null ? null : Encoding.UTF8.GetString(dat.deps)); } } @@ -118,6 +146,9 @@ public struct ManifestEntry dat.group = (uint)ReadVLQ(buf, ref offset, 4); dat.size = (uint)ReadVLQ(buf, ref offset, 8); dat.checksum = ReadUNum(buf, ref offset, 8); + dat.hname = CalHameString(dat.checksum, dat.size, dat.name); + dat.tname = Encoding.UTF8.GetString(dat.name); + dat.tdeps = (dat.deps == null ? null : Encoding.UTF8.GetString(dat.deps)); dat.priority = 0; } } diff --git a/Assets/Scripts/UmaDatabase/UmaDataTypes.cs b/Assets/Scripts/UmaDatabase/UmaDataTypes.cs index 80afe32..3ba085f 100644 --- a/Assets/Scripts/UmaDatabase/UmaDataTypes.cs +++ b/Assets/Scripts/UmaDatabase/UmaDataTypes.cs @@ -128,5 +128,6 @@ public enum UmaFileType uianimation, transferevent, teambuilding, - challengematch + challengematch, + collectevent } From c6434cadbca3284502780d3262927e02da3e1452 Mon Sep 17 00:00:00 2001 From: CroakFang <1605296300@qq.com> Date: Fri, 16 Dec 2022 00:55:50 +0800 Subject: [PATCH 7/8] bug fix --- Assets/Scripts/Manifest/ManifestDB.cs | 14 ++++++++------ Assets/Scripts/Manifest/ManifestEntry.cs | 18 +++++++++--------- 2 files changed, 17 insertions(+), 15 deletions(-) diff --git a/Assets/Scripts/Manifest/ManifestDB.cs b/Assets/Scripts/Manifest/ManifestDB.cs index 86888d5..f26399d 100644 --- a/Assets/Scripts/Manifest/ManifestDB.cs +++ b/Assets/Scripts/Manifest/ManifestDB.cs @@ -19,6 +19,7 @@ public class ManifestDB if (File.Exists(DBPath)) { MetaDB = new SqliteConnection($@"Data Source={DBPath}"); + MetaDB.Open(); } else { @@ -64,7 +65,7 @@ public class ManifestDB command.ExecuteNonQuery(); int index = 1; - InsertManifestEntry(index, "manifest3", rootEntry, ref command); + UpdateManifestEntry(index, "manifest3", rootEntry, ref command); //Insert platform ManifestEntry[] platformEntrys = null; @@ -77,7 +78,7 @@ public class ManifestDB } ManifestEntry platformEntry = GetLocalPlatformEntry(platformEntrys); index++; - InsertManifestEntry(index, "manifest2", platformEntry, ref command); + UpdateManifestEntry(index, "manifest2", platformEntry, ref command); //Insert AssetManifest ManifestEntry[] assetEntrys = null; @@ -93,7 +94,7 @@ public class ManifestDB foreach (var entry in assetEntrys) { index++; - InsertManifestEntry(index, "manifest", entry, ref command); + UpdateManifestEntry(index, "manifest", entry, ref command); } tran.Commit(); } @@ -113,7 +114,7 @@ public class ManifestDB foreach (var entry in assets) { index++; - InsertManifestEntry(index, assetEntry.tname, entry, ref command); + UpdateManifestEntry(index, assetEntry.tname, entry, ref command); } tran.Commit(); } @@ -121,9 +122,9 @@ public class ManifestDB MetaDB.Close(); } - private void InsertManifestEntry(int index, string type, ManifestEntry entry, ref SqliteCommand command) + private void UpdateManifestEntry(int index, string type, ManifestEntry entry, ref SqliteCommand command) { - command.CommandText = "INSERT INTO a (i,n,d,g,l,c,h,m,k,s,p) VALUES (@id,@name,@deps,@group,@length,@check,@hash,@m,@k,@s,@p)"; + command.CommandText = "INSERT OR REPLACE INTO a (i,n,d,g,l,c,h,m,k,s,p) VALUES (@id,@name,@deps,@group,@length,@check,@hash,@m,@k,@s,@p)"; command.Parameters.Clear(); command.Parameters.Add(new SqliteParameter("@id", index)); command.Parameters.Add(new SqliteParameter("@name", (type.Contains("manifest") ? "//" : "") + entry.tname)); @@ -190,6 +191,7 @@ public class ManifestDB public IEnumerator DownloadManifest(string hash) { UnityWebRequest www = UnityWebRequest.Get(GetManifestRequestUrl(hash)); + www.timeout = 15; yield return www.SendWebRequest(); if (www.result == UnityWebRequest.Result.Success) { diff --git a/Assets/Scripts/Manifest/ManifestEntry.cs b/Assets/Scripts/Manifest/ManifestEntry.cs index c522d81..3a91d96 100644 --- a/Assets/Scripts/Manifest/ManifestEntry.cs +++ b/Assets/Scripts/Manifest/ManifestEntry.cs @@ -39,7 +39,7 @@ public struct ManifestEntry } - public static byte[] CalHame(ulong checksum, ulong size, byte[] name) + public static byte[] CalHName(ulong checksum, ulong size, byte[] name) { if (name == null) return null; SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider(); @@ -55,21 +55,21 @@ public struct ManifestEntry } - public static string CalHameString(ulong checksum, ulong size, byte[] name) + public static string CalHNameString(ulong checksum, ulong size, byte[] name) { - var bytes = CalHame(checksum, size, name); + var bytes = CalHName(checksum, size, name); Base32 base32 = new Base32(); return base32.Encode(bytes); } public static string CalHameString(ulong checksum, ulong size, string name) { - return CalHameString(checksum, size, Encoding.UTF8.GetBytes(name)); + return CalHNameString(checksum, size, Encoding.UTF8.GetBytes(name)); } public string CalHameString() { - return CalHameString(checksum, size, name); + return CalHNameString(checksum, size, name); } public override string ToString() @@ -82,7 +82,7 @@ public struct ManifestEntry s.AppendFormat("Group : {0} ", group); s.AppendFormat("Priority : {0} ", priority); s.AppendFormat("Kind : {0} ", kind); - s.AppendFormat("Hash : {0} ", CalHameString(checksum, size, name)); + s.AppendFormat("Hash : {0} ", CalHNameString(checksum, size, name)); return s.ToString(); } @@ -113,7 +113,7 @@ public struct ManifestEntry dat.name = GetArray(ReadText(buf, ref offset)); dat.size = ReadVLQ(buf, ref offset); dat.checksum = ReadUNum(buf, ref offset, 8); - dat.hname = CalHameString(dat.checksum, dat.size, dat.name); + dat.hname = CalHNameString(dat.checksum, dat.size, dat.name); dat.tname = Encoding.UTF8.GetString(dat.name); } @@ -130,7 +130,7 @@ public struct ManifestEntry dat.priority = (uint)ReadVLQ(buf, ref offset, 4); dat.size = (uint)ReadVLQ(buf, ref offset, 8); dat.checksum = ReadUNum(buf, ref offset, 8); - dat.hname = CalHameString(dat.checksum, dat.size, dat.name); + dat.hname = CalHNameString(dat.checksum, dat.size, dat.name); dat.tname = Encoding.UTF8.GetString(dat.name); dat.tdeps = (dat.deps == null ? null : Encoding.UTF8.GetString(dat.deps)); } @@ -146,7 +146,7 @@ public struct ManifestEntry dat.group = (uint)ReadVLQ(buf, ref offset, 4); dat.size = (uint)ReadVLQ(buf, ref offset, 8); dat.checksum = ReadUNum(buf, ref offset, 8); - dat.hname = CalHameString(dat.checksum, dat.size, dat.name); + dat.hname = CalHNameString(dat.checksum, dat.size, dat.name); dat.tname = Encoding.UTF8.GetString(dat.name); dat.tdeps = (dat.deps == null ? null : Encoding.UTF8.GetString(dat.deps)); dat.priority = 0; From 49305e7622500af8b4e6eacb35001a6ed02d5740 Mon Sep 17 00:00:00 2001 From: CroakFang <1605296300@qq.com> Date: Wed, 21 Dec 2022 17:54:36 +0800 Subject: [PATCH 8/8] Add UpdateDatabase Button --- Assets/Scenes/Version2.unity | 295 +++++++++++++++++- Assets/Scripts/Manifest/BSVReader.cs | 17 +- Assets/Scripts/Manifest/LZ4Util.cs | 54 ++++ Assets/Scripts/Manifest/LZ4Util.cs.meta | 11 + Assets/Scripts/Manifest/ManifestDB.cs | 133 ++++++-- Assets/Scripts/Manifest/ManifestEntry.cs | 3 +- .../UmaDatabase/UmaDatabaseController.cs | 13 +- Assets/Scripts/UmaViewerDownload.cs | 19 ++ Assets/Scripts/UmaViewerMain.cs | 2 + Assets/Scripts/UmaViewerUI.cs | 12 +- 10 files changed, 497 insertions(+), 62 deletions(-) create mode 100644 Assets/Scripts/Manifest/LZ4Util.cs create mode 100644 Assets/Scripts/Manifest/LZ4Util.cs.meta diff --git a/Assets/Scenes/Version2.unity b/Assets/Scenes/Version2.unity index 119b79b..6b4467d 100644 --- a/Assets/Scenes/Version2.unity +++ b/Assets/Scenes/Version2.unity @@ -1682,13 +1682,14 @@ RectTransform: m_LocalScale: {x: 1, y: 1, z: 1} m_Children: - {fileID: 844924682} + - {fileID: 2073237536} m_Father: {fileID: 1704906816} m_RootOrder: 17 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 1} m_AnchorMax: {x: 0, y: 1} - m_AnchoredPosition: {x: 141.5, y: -410} - m_SizeDelta: {x: 283, y: 50} + m_AnchoredPosition: {x: 141.5, y: -1071.7834} + m_SizeDelta: {x: 283, y: 100} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &93905315 MonoBehaviour: @@ -17114,7 +17115,7 @@ RectTransform: m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 1} m_AnchorMax: {x: 0, y: 1} - m_AnchoredPosition: {x: 283, y: -75} + m_AnchoredPosition: {x: 283, y: -25} m_SizeDelta: {x: 283, y: 50} m_Pivot: {x: 1, y: 0.5} --- !u!114 &844924683 @@ -29470,6 +29471,139 @@ MonoBehaviour: m_isRichTextEditingAllowed: 0 m_LineLimit: 0 m_InputValidator: {fileID: 0} +--- !u!1 &1516377149 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1516377150} + - component: {fileID: 1516377153} + - component: {fileID: 1516377152} + - component: {fileID: 1516377151} + m_Layer: 5 + m_Name: Button + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1516377150 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1516377149} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 1618706696} + m_Father: {fileID: 2073237536} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &1516377151 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1516377149} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 1516377152} + m_OnClick: + m_PersistentCalls: + m_Calls: + - m_Target: {fileID: 1564959567} + m_TargetAssemblyTypeName: UmaViewerUI, umamusume + m_MethodName: UpdateGameDB + m_Mode: 1 + m_Arguments: + m_ObjectArgument: {fileID: 0} + m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine + m_IntArgument: 0 + m_FloatArgument: 0 + m_StringArgument: + m_BoolArgument: 1 + m_CallState: 2 +--- !u!114 &1516377152 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1516377149} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!222 &1516377153 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1516377149} + m_CullTransparentMesh: 1 --- !u!224 &1525688469 stripped RectTransform: m_CorrespondingSourceObject: {fileID: 22448498, guid: 916ee089a0d7b63419075f91e1c657ec, @@ -31082,6 +31216,85 @@ Transform: m_Father: {fileID: 0} m_RootOrder: 2 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!1 &1618706695 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1618706696} + - component: {fileID: 1618706698} + - component: {fileID: 1618706697} + m_Layer: 5 + m_Name: Text + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1618706696 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1618706695} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 1516377150} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &1618706697 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1618706695} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_FontData: + m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0} + m_FontSize: 25 + m_FontStyle: 0 + m_BestFit: 0 + m_MinSize: 1 + m_MaxSize: 40 + m_Alignment: 4 + m_AlignByGeometry: 0 + m_RichText: 1 + m_HorizontalOverflow: 0 + m_VerticalOverflow: 0 + m_LineSpacing: 1 + m_Text: Update Database +--- !u!222 &1618706698 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1618706695} + m_CullTransparentMesh: 1 --- !u!1 &1622519936 GameObject: m_ObjectHideFlags: 0 @@ -39893,6 +40106,82 @@ CanvasRenderer: m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 2062531603} m_CullTransparentMesh: 1 +--- !u!1 &2073237535 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2073237536} + - component: {fileID: 2073237538} + - component: {fileID: 2073237537} + m_Layer: 5 + m_Name: UpdateDatabase + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2073237536 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2073237535} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 1516377150} + m_Father: {fileID: 93905314} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 1} + m_AnchorMax: {x: 0, y: 1} + m_AnchoredPosition: {x: 283, y: -75} + m_SizeDelta: {x: 283, y: 50} + m_Pivot: {x: 1, y: 0.5} +--- !u!114 &2073237537 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2073237535} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 0, g: 0, b: 0, a: 0.19607843} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 0} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!222 &2073237538 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2073237535} + m_CullTransparentMesh: 1 --- !u!1 &2073676005 GameObject: m_ObjectHideFlags: 0 diff --git a/Assets/Scripts/Manifest/BSVReader.cs b/Assets/Scripts/Manifest/BSVReader.cs index 2ead37c..e0c417b 100644 --- a/Assets/Scripts/Manifest/BSVReader.cs +++ b/Assets/Scripts/Manifest/BSVReader.cs @@ -1,5 +1,4 @@ -using K4os.Compression.LZ4.Streams; -using System; +using System; using System.IO; using UnityEngine; @@ -107,19 +106,7 @@ public class BSVReader { try { - byte[] input; - if (isCompressed) - { - var source = new MemoryStream(File.ReadAllBytes(path)); - var decoder = LZ4Stream.Decode(source); - var target = new MemoryStream(); - decoder.CopyTo(target); - input = target.ToArray(); - } - else - { - input = File.ReadAllBytes(path); - } + byte[] input = isCompressed? LZ4Util.DecompressFromFile(path): File.ReadAllBytes(path); if (mode == ReadMode.Stream) { diff --git a/Assets/Scripts/Manifest/LZ4Util.cs b/Assets/Scripts/Manifest/LZ4Util.cs new file mode 100644 index 0000000..bd0f08e --- /dev/null +++ b/Assets/Scripts/Manifest/LZ4Util.cs @@ -0,0 +1,54 @@ +using K4os.Compression.LZ4; +using K4os.Compression.LZ4.Streams; +using System; +using System.IO; +using System.Runtime.InteropServices; +using UnityEngine; + +public static class LZ4Util +{ + [DllImport("libnative.dll")] + public static extern int LZ4_decompress_safe_ext(IntPtr src, IntPtr dst, int compressedSize, int dstCapacity); + + public static byte[] DecompressFromFile(string path) + { + var decoder = LZ4Stream.Decode(File.OpenRead(path)); + var target = new MemoryStream(); + decoder.CopyTo(target); + return target.ToArray(); + } + + public static byte[] DecompressFromBytesSafe(byte[] bytes)//WIP + { + IntPtr data = Marshal.AllocHGlobal(bytes.Length); + Marshal.Copy(bytes, 0, data, bytes.Length); + + int dataLength = 0; + dataLength = ((dataLength| bytes[3])<<8); + dataLength = ((dataLength| bytes[2])<<8); + dataLength = ((dataLength| bytes[1])<<8); + dataLength = (dataLength| bytes[0]); + + IntPtr result = Marshal.AllocHGlobal(bytes.Length+ dataLength); + + var output = new byte[bytes.Length + dataLength]; + var outlength = LZ4_decompress_safe_ext(data, result, bytes.Length, output.Length); + + Marshal.Copy(result, output, 0,outlength); + + Array.Resize(ref output, outlength); + Marshal.FreeHGlobal(data); + Marshal.FreeHGlobal(result); + return output; + } + + public static byte[] CompressFromBytes(byte[] bytes) + { + var source = new MemoryStream(bytes); + var decoder = LZ4Stream.Encode(source); + var target = new MemoryStream(); + decoder.CopyTo(target); + return target.ToArray(); + } +} + diff --git a/Assets/Scripts/Manifest/LZ4Util.cs.meta b/Assets/Scripts/Manifest/LZ4Util.cs.meta new file mode 100644 index 0000000..567276f --- /dev/null +++ b/Assets/Scripts/Manifest/LZ4Util.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ad28139c90f43ce4eba7c018a861ca37 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/Manifest/ManifestDB.cs b/Assets/Scripts/Manifest/ManifestDB.cs index f26399d..4da06b6 100644 --- a/Assets/Scripts/Manifest/ManifestDB.cs +++ b/Assets/Scripts/Manifest/ManifestDB.cs @@ -1,4 +1,5 @@ using Mono.Data.Sqlite; +using Newtonsoft.Json.Linq; using System; using System.Collections; using System.IO; @@ -11,11 +12,12 @@ using static ManifestCategory; public class ManifestDB { public SqliteConnection MetaDB; - public string DBPath; - public static string MANIFEST_ROOT_URL = "https://prd-storage-app-umamusume.akamaized.net/dl/resources/Manifest"; - public ManifestDB(string DBPath) + public static string DBPath; + public const string DefaultDBPath = "umamusume/meta"; + public Action callback; + public ManifestDB(string DBPath = DefaultDBPath) { - this.DBPath = DBPath; + ManifestDB.DBPath = DBPath; if (File.Exists(DBPath)) { MetaDB = new SqliteConnection($@"Data Source={DBPath}"); @@ -43,31 +45,68 @@ public class ManifestDB } } + public IEnumerator UpdateResourceVersion(Action callback) + { + this.callback = callback; + callback?.Invoke("Checking Resource Version"); + yield return UpdateMetaDB(); + yield return UpdateMasterDB(); + callback?.Invoke($"Done"); + } //umamusume uses the manifest file to generate meta database. //it needs to get the root manifest file first //then read the root manifest to get other manifest file information //recursively read the manifest file to obtain all resource files information //finally, insert all data into the meta database - public IEnumerator GenerateMetaDB(ulong rootSize, ulong rootCheckSum) + public IEnumerator UpdateMetaDB() { - if (MetaDB == null || MetaDB.State == System.Data.ConnectionState.Closed) { + string rootHash = null; + callback?.Invoke("Getting resource version"); + yield return UmaViewerDownload.DownloadText("https://www.tracenacademy.com/api/MetaC/root", txt => + { + if (string.IsNullOrEmpty(txt)) return; + var item = JObject.Parse(txt); + if ((string)item["n"] == "//root") + { + rootHash = (string)item["h"]; + } + }); + + if (rootHash == null) + { + Debug.LogError("Get RootHash Error"); + yield break; + } + + ManifestEntry rootEntry = new ManifestEntry(Encoding.UTF8.GetBytes("root"), null, 0, 0, 0, 0, "", 3); + rootEntry.hname = rootHash; + yield return UpdateMetaDB(rootEntry); + } + + public IEnumerator UpdateMetaDB(ulong size, ulong checksum) + { + ManifestEntry rootEntry = new ManifestEntry(Encoding.UTF8.GetBytes("root"), null, 0, 0, size, checksum, "", 3); + rootEntry.hname = rootEntry.CalHameString(); + yield return UpdateMetaDB(rootEntry); + } + + public IEnumerator UpdateMetaDB(ManifestEntry rootEntry) + { + if (MetaDB == null || MetaDB.State == System.Data.ConnectionState.Closed) + { Debug.LogError("Open Meta Database Error"); yield break; } - //Insert root - ManifestEntry rootEntry = new ManifestEntry(Encoding.UTF8.GetBytes("root"), null, 0, 0, rootSize, rootCheckSum, "", 3); - rootEntry.hname = rootEntry.CalHameString(); - SqliteCommand command = new SqliteCommand(MetaDB); - command.CommandText = "DELETE FROM a"; - command.ExecuteNonQuery(); + //Insert root int index = 1; UpdateManifestEntry(index, "manifest3", rootEntry, ref command); //Insert platform + callback?.Invoke("Reading Platform Manifest"); ManifestEntry[] platformEntrys = null; yield return GetManifest(rootEntry.hname, Kind.PlatformManifest, entrys => { platformEntrys = entrys; }); if (platformEntrys == null) @@ -91,14 +130,15 @@ public class ManifestDB } using (SqliteTransaction tran = MetaDB.BeginTransaction()) { - foreach (var entry in assetEntrys) + for (int i = 0; i < assetEntrys.Length; i++) { index++; - UpdateManifestEntry(index, "manifest", entry, ref command); + callback?.Invoke($"Reading Assets Manifest : {assetEntrys[i].tname} ({i + 1}/{assetEntrys.Length})"); + UpdateManifestEntry(index, "manifest", assetEntrys[i], ref command); } tran.Commit(); } - + //Insert Asset foreach (var assetEntry in assetEntrys) { @@ -109,17 +149,54 @@ public class ManifestDB Debug.LogError("Read AssetManifest Error"); continue; } - using (SqliteTransaction tran = MetaDB.BeginTransaction()) + using SqliteTransaction tran = MetaDB.BeginTransaction(); + for (int i = 0; i < assets.Length; i++) { - foreach (var entry in assets) - { - index++; - UpdateManifestEntry(index, assetEntry.tname, entry, ref command); - } - tran.Commit(); + index++; + callback?.Invoke($"Reading AssetBundles Manifest : {assetEntry.tname} ({i + 1}/{assets.Length})"); + UpdateManifestEntry(index, assetEntry.tname, assets[i], ref command); } + tran.Commit(); + } + } + + public IEnumerator UpdateMasterDB() + { + if (MetaDB == null || MetaDB.State == System.Data.ConnectionState.Closed) + { + Debug.LogError("Open Meta Database Error"); + yield break; + } + + callback?.Invoke($"Checking master.mdb"); + SqliteCommand command = new SqliteCommand("SELECT h FROM a WHERE n LIKE 'master.mdb.lz4'", MetaDB); + var reader = command.ExecuteReader(); + + if (reader.Read()) + { + var hash = reader.GetString(0); + var path = GetManifestPath(hash); + if (!File.Exists(path)) + { + callback?.Invoke($"Downloading master.mdb"); + UnityWebRequest www = UnityWebRequest.Get(UmaViewerDownload.GetGenericRequestUrl(hash)); + yield return www.SendWebRequest(); + if (www.result == UnityWebRequest.Result.Success) + { + File.WriteAllBytes(path, www.downloadHandler.data); + } + else + { + Debug.LogError("Download Master.mdb Failed :" + www.error); + yield break; + } + } + + callback?.Invoke($"Decompress master.mdb"); + var masterPath = $"{Path.GetDirectoryName(DBPath)}/master/master.mdb"; + Directory.CreateDirectory(Path.GetDirectoryName(masterPath)); + File.WriteAllBytes(masterPath, LZ4Util.DecompressFromFile(path)); } - MetaDB.Close(); } private void UpdateManifestEntry(int index, string type, ManifestEntry entry, ref SqliteCommand command) @@ -180,6 +257,7 @@ public class ManifestDB var path = GetManifestPath(hash); if (!File.Exists(path)) { + this.callback?.Invoke($"Downloading Manifest :{hash}"); yield return DownloadManifest(hash); } if (File.Exists(path)) @@ -190,7 +268,7 @@ public class ManifestDB public IEnumerator DownloadManifest(string hash) { - UnityWebRequest www = UnityWebRequest.Get(GetManifestRequestUrl(hash)); + UnityWebRequest www = UnityWebRequest.Get(UmaViewerDownload.GetManifestRequestUrl(hash)); www.timeout = 15; yield return www.SendWebRequest(); if (www.result == UnityWebRequest.Result.Success) @@ -206,18 +284,13 @@ public class ManifestDB public string GetManifestPath(string hash, bool createPath = true) { string path = $"{Path.GetDirectoryName(DBPath)}/dat/{hash.Substring(0, 2)}"; - if (createPath && !Directory.Exists(path)) + if (createPath) { Directory.CreateDirectory(path); } return path + $"/{hash}"; } - public static string GetManifestRequestUrl(string hash) - { - return $"{MANIFEST_ROOT_URL}/{hash.Substring(0, 2)}/{hash}"; - } - public static ManifestEntry GetLocalPlatformEntry(ManifestEntry[] platformEntrys) { foreach (var entry in platformEntrys) diff --git a/Assets/Scripts/Manifest/ManifestEntry.cs b/Assets/Scripts/Manifest/ManifestEntry.cs index 3a91d96..6ef37f4 100644 --- a/Assets/Scripts/Manifest/ManifestEntry.cs +++ b/Assets/Scripts/Manifest/ManifestEntry.cs @@ -58,8 +58,7 @@ public struct ManifestEntry public static string CalHNameString(ulong checksum, ulong size, byte[] name) { var bytes = CalHName(checksum, size, name); - Base32 base32 = new Base32(); - return base32.Encode(bytes); + return new Base32().Encode(bytes); } public static string CalHameString(ulong checksum, ulong size, string name) diff --git a/Assets/Scripts/UmaDatabase/UmaDatabaseController.cs b/Assets/Scripts/UmaDatabase/UmaDatabaseController.cs index 3c07c85..e508507 100644 --- a/Assets/Scripts/UmaDatabase/UmaDatabaseController.cs +++ b/Assets/Scripts/UmaDatabase/UmaDatabaseController.cs @@ -53,16 +53,9 @@ public class UmaDatabaseController { try { - if (Application.platform == RuntimePlatform.Android) - { - metaDb = new SqliteConnection($@"Data Source={GetGameRootPath()}/meta;"); - masterDb = new SqliteConnection($@"Data Source={GetGameRootPath()}/master/master.mdb;"); - } - else - { - metaDb = new SqliteConnection($@"Data Source={Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "Low"}\Cygames\umamusume\meta;"); - masterDb = new SqliteConnection($@"Data Source={Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "Low"}\Cygames\umamusume\master\master.mdb;"); - } + metaDb = new SqliteConnection($@"Data Source={Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "Low"}\Cygames\umamusume\meta;"); + masterDb = new SqliteConnection($@"Data Source={Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "Low"}\Cygames\umamusume\master\master.mdb;"); + metaDb.Open(); MetaEntries = ReadMeta(metaDb); diff --git a/Assets/Scripts/UmaViewerDownload.cs b/Assets/Scripts/UmaViewerDownload.cs index 3d7ee1e..ad2be80 100644 --- a/Assets/Scripts/UmaViewerDownload.cs +++ b/Assets/Scripts/UmaViewerDownload.cs @@ -5,6 +5,10 @@ using UnityEngine.Networking; public class UmaViewerDownload : MonoBehaviour { + public static string MANIFEST_ROOT_URL = "https://prd-storage-app-umamusume.akamaized.net/dl/resources/Manifest"; + public static string GENERIC_BASE_URL = "https://prd-storage-umamusume.akamaized.net/dl/resources/Generic"; + public static string ASSET_BASE_URL = "https://prd-storage-umamusume.akamaized.net/dl/resources/Windows/assetbundles/"; + public static IEnumerator DownloadText(string url, System.Action callback) { UnityWebRequest www = UnityWebRequest.Get(url); @@ -21,4 +25,19 @@ public class UmaViewerDownload : MonoBehaviour callback(www.downloadHandler.text); } } + + public static string GetManifestRequestUrl(string hash) + { + return $"{MANIFEST_ROOT_URL}/{hash.Substring(0, 2)}/{hash}"; + } + + public static string GetGenericRequestUrl(string hash) + { + return $"{GENERIC_BASE_URL}/{hash.Substring(0, 2)}/{hash}"; + } + + public static string GetAssetRequestUrl(string hash) + { + return $"{ASSET_BASE_URL}/{hash.Substring(0, 2)}/{hash}"; + } } diff --git a/Assets/Scripts/UmaViewerMain.cs b/Assets/Scripts/UmaViewerMain.cs index 18232b8..918ec53 100644 --- a/Assets/Scripts/UmaViewerMain.cs +++ b/Assets/Scripts/UmaViewerMain.cs @@ -6,6 +6,8 @@ using System; using Newtonsoft.Json.Linq; using System.Collections; using static ManifestCategory; +using BaseNcoding; +using System.Text; public class UmaViewerMain : MonoBehaviour { diff --git a/Assets/Scripts/UmaViewerUI.cs b/Assets/Scripts/UmaViewerUI.cs index 41a195d..fe89c0d 100644 --- a/Assets/Scripts/UmaViewerUI.cs +++ b/Assets/Scripts/UmaViewerUI.cs @@ -88,6 +88,8 @@ public class UmaViewerUI : MonoBehaviour public FaceDrivenKeyTarget currentFaceDrivenKeyTarget; + private IEnumerator UpdateResVerCoroutine; + private void Awake() { Instance = this; @@ -713,8 +715,6 @@ public class UmaViewerUI : MonoBehaviour } } - - public void AudioPause() { if (Builder.CurrentAudioSources.Count>0) @@ -919,4 +919,12 @@ public class UmaViewerUI : MonoBehaviour } } } + + public void UpdateGameDB() { + if (UpdateResVerCoroutine != null) return; + ManifestDB dB = new ManifestDB(); + UpdateResVerCoroutine = dB.UpdateResourceVersion(delegate (string msg) { LyricsText.text = msg; }); + StartCoroutine(UpdateResVerCoroutine); + } + }