This commit is contained in:
CroakFang
2022-12-13 22:47:31 +08:00
parent 9e7b10c1a5
commit df178687ba
40 changed files with 5401 additions and 15 deletions
+13
View File
@@ -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
+8
View File
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 8efe8ce6fc7c3d84db812df72e79c7ce
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
+184
View File
@@ -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);
/// <summary>
/// From: http://stackoverflow.com/a/600306/1046374
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public static bool IsPowerOf2(uint x)
{
uint xint = x;
if (x - xint != 0)
return false;
return (xint & (xint - 1)) == 0;
}
/// <summary>
/// From: http://stackoverflow.com/a/13569863/1046374
/// </summary>
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;
}
}
}
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: dddac6b0e9d7d75489cf3110fcc3a611
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+41
View File
@@ -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;
}
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: b84ecd8bc32acb7448d64c9bb045948d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+203
View File
@@ -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;
}
}
}
}
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 126c83fbe81b32444ade8272d29789b1
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+170
View File
@@ -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));
}
}
}
}
}
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: b591d6746a6fd9b45a0174c0c22d292b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+181
View File
@@ -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);
}
}
}
}
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: bb00dc9d3e90a49439d967614c88ded8
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+99
View File
@@ -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<byte> result = new List<byte>(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();
}
}
}
}
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 445180477b0318d48b58549426fd8ba9
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+261
View File
@@ -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;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 0a06acee1a2bf3d4aae0b2a2b83cb5d4
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+228
View File
@@ -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;
}
}
}
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 8d996e73fb18bfd45be33725dcf13786
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -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);
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: b72d6d0bcd1a9e846ad04cc26014bbcd
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+8
View File
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: dbb2fcf97a52a74408ada473a663544b
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
+757
View File
@@ -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
{
/// <summary>Safe LZ4 codec.</summary>
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
/// <summary>Encodes the specified input.</summary>
/// <param name="input">The input.</param>
/// <param name="inputOffset">The input offset.</param>
/// <param name="inputLength">Length of the input.</param>
/// <param name="output">The output.</param>
/// <param name="outputOffset">The output offset.</param>
/// <param name="outputLength">Length of the output.</param>
/// <returns>Number of bytes written.</returns>
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);
}
}
/// <summary>Encodes the specified input.</summary>
/// <param name="input">The input.</param>
/// <param name="inputOffset">The input offset.</param>
/// <param name="inputLength">Length of the input.</param>
/// <returns>Compressed buffer.</returns>
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
/// <summary>Encodes the specified input.</summary>
/// <param name="input">The input.</param>
/// <param name="inputOffset">The input offset.</param>
/// <param name="inputLength">Length of the input.</param>
/// <param name="output">The output.</param>
/// <param name="outputOffset">The output offset.</param>
/// <param name="outputLength">Length of the output.</param>
/// <returns>Number of bytes written.</returns>
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);
}
}
/// <summary>Encodes the specified input.</summary>
/// <param name="input">The input.</param>
/// <param name="inputOffset">The input offset.</param>
/// <param name="inputLength">Length of the input.</param>
/// <returns>Compressed buffer.</returns>
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
/// <summary>Decodes the specified input.</summary>
/// <param name="input">The input.</param>
/// <param name="inputOffset">The input offset.</param>
/// <param name="inputLength">Length of the input.</param>
/// <param name="output">The output.</param>
/// <param name="outputOffset">The output offset.</param>
/// <param name="outputLength">Length of the output.</param>
/// <param name="knownOutputLength">Set it to <c>true</c> if output length is known.</param>
/// <returns>Number of bytes written.</returns>
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;
}
}
/// <summary>Decodes the specified input.</summary>
/// <param name="input">The input.</param>
/// <param name="inputOffset">The input offset.</param>
/// <param name="inputLength">Length of the input.</param>
/// <param name="outputLength">Length of the output.</param>
/// <returns>Decompressed buffer.</returns>
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
/// <summary>Decodes the specified input.</summary>
/// <param name="input">The input.</param>
/// <param name="inputOffset">The input offset.</param>
/// <param name="inputLength">Length of the input.</param>
/// <param name="output">The output.</param>
/// <param name="outputOffset">The output offset.</param>
/// <param name="outputLength">Length of the output.</param>
/// <param name="knownOutputLength">Set it to <c>true</c> if output length is known.</param>
/// <returns>Number of bytes written.</returns>
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;
}
}
/// <summary>Decodes the specified input.</summary>
/// <param name="input">The input.</param>
/// <param name="inputOffset">The input offset.</param>
/// <param name="inputLength">Length of the input.</param>
/// <param name="outputLength">Length of the output.</param>
/// <returns>Decompressed buffer.</returns>
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));
}
/// <summary>Encodes the specified input using HC codec.</summary>
/// <param name="input">The input.</param>
/// <param name="inputOffset">The input offset.</param>
/// <param name="inputLength">Length of the input.</param>
/// <param name="output">The output.</param>
/// <param name="outputOffset">The output offset.</param>
/// <param name="outputLength">Length of the output.</param>
/// <returns>Number of bytes written. NOTE: when output buffer is too small it returns negative value.</returns>
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;
}
/// <summary>Encodes the specified input using HC codec.</summary>
/// <param name="input">The input.</param>
/// <param name="inputOffset">The input offset.</param>
/// <param name="inputLength">Length of the input.</param>
/// <returns>Buffer with compressed data (NOTE: it can be bigger than input).</returns>
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));
}
/// <summary>Encodes the specified input using HC codec.</summary>
/// <param name="input">The input.</param>
/// <param name="inputOffset">The input offset.</param>
/// <param name="inputLength">Length of the input.</param>
/// <param name="output">The output.</param>
/// <param name="outputOffset">The output offset.</param>
/// <param name="outputLength">Length of the output.</param>
/// <returns>Number of bytes written. NOTE: when output buffer is too small it returns negative value.</returns>
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;
}
/// <summary>Encodes the specified input using HC codec.</summary>
/// <param name="input">The input.</param>
/// <param name="inputOffset">The input offset.</param>
/// <param name="inputLength">Length of the input.</param>
/// <returns>Buffer with compressed data (NOTE: it can be bigger than input).</returns>
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
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: a2f5d2c7e152d8f43ab710530107c9ff
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+795
View File
@@ -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
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 8c5dc5c9f2a382b4db836cf150c3a176
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -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
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 0cd0b555f5386b84b9fc6aea0b43418d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+808
View File
@@ -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
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 04fd67d662c762548a89d1fe5bf6cfcc
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -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
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: c61e65caf96385a469be74084e2e1f00
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+176
View File
@@ -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
/// <summary>
/// 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
/// </summary>
private const int MEMORY_USAGE = 20;
/// <summary>
/// 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
/// </summary>
private const int NOTCOMPRESSIBLE_DETECTIONLEVEL = 6;
#if !UNSAFE
/// <summary>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.</summary>
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)
/// <summary>Gets maximum the length of the output.</summary>
/// <param name="inputLength">Length of the input.</param>
/// <returns>Maximum number of bytes needed for compressed buffer.</returns>
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
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 60265417a9a7cb346be1757b77ecdd37
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+129
View File
@@ -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
{
/// <summary>
/// 置換
/// </summary>
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;
}
}
*/
}
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: a39980c7200b27b4b8357880848e8646
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+40
View File
@@ -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);
}
}
}
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 822adc4dd85200142901586dd5c697c6
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+12 -12
View File
@@ -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",
+1 -1
View File
@@ -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
+2 -2
View File
@@ -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)