/// <summary>
/// Uses the cipher to generate a BCrypt hash.
/// </summary>
/// <returns>A BCrypt hash.</returns>
public byte[] BCrypt()
{
uint[] magicWords = null;
byte[] magicBytes = null;
try
{
magicWords = (uint[])Magic.Clone();
for (int j = 0; j < magicWords.Length; j += 2)
{
for (int i = 0; i < 64; i++)
{
Encipher(ref magicWords[j], ref magicWords[j + 1]);
}
}
magicBytes = new byte[magicWords.Length * 4];
for (int i = 0; i < magicWords.Length; i++)
{
BitPacking.BEBytesFromUInt32(magicWords[i], magicBytes, i * 4);
}
return(ByteArray.TruncateAndCopy(magicBytes, magicBytes.Length - 1));
}
finally
{
Security.Clear(magicWords);
Security.Clear(magicBytes);
}
}
private void decodePage(int[] @in, IntWrapper inpos, int[] @out, IntWrapper outpos, int thissize)
{
int tmpoutpos = outpos.get();
int tmpinpos = inpos.get();
for (int run = 0; run < thissize / BLOCK_SIZE; ++run, tmpoutpos += BLOCK_SIZE)
{
int b = @in[tmpinpos] & 0xFF;
int cexcept = (int)((uint)@in[tmpinpos] >> 8) & 0xFF;
int exceptsize = (int)((uint)@in[tmpinpos] >> 16);
++tmpinpos;
S9.uncompress(@in, tmpinpos, exceptsize, exceptbuffer,
0, 2 * cexcept);
tmpinpos += exceptsize;
for (int k = 0; k < BLOCK_SIZE; k += 32)
{
BitPacking.fastunpack(@in, tmpinpos, @out,
tmpoutpos + k, bits[b]);
tmpinpos += bits[b];
}
for (int k = 0; k < cexcept; ++k)
{
@out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]);
}
}
outpos.set(tmpoutpos);
inpos.set(tmpinpos);
}
/// <inheritdoc />
public override string GenerateSalt(CrypterOptions options)
{
Check.Null("options", options);
int?rounds = options.GetValue <int?>(CrypterOption.Rounds);
if (rounds != null)
{
Check.Range("CrypterOption.Rounds", (int)rounds, MinRounds, MaxRounds);
}
byte[] roundsBytes = new byte[3], saltBytes = null;
try
{
BitPacking.LEBytesFromUInt24((uint)(rounds ?? 4321), roundsBytes, 0);
saltBytes = Security.GenerateRandomBytes(3);
return("_"
+ Base64Encoding.UnixMD5.GetString(roundsBytes)
+ Base64Encoding.UnixMD5.GetString(saltBytes));
}
finally
{
Security.Clear(roundsBytes);
Security.Clear(saltBytes);
}
}
private void DesBegin(byte[] inputBuffer, int inputOffset, out uint L, out uint R)
{
ulong p = BitPacking.UInt64FromBEBytes(inputBuffer, inputOffset);
ulong pp = Permute(IP, p, 64); p = 0;
L = (uint)(pp >> 32); R = (uint)pp;
}
void DesEnd(byte[] outputBuffer, int outputOffset, ref uint L, ref uint R)
{
ulong rl = (ulong)R << 32 | L; L = 0; R = 0;
ulong rlp = Permute(FP, rl, 64); rl = 0;
BitPacking.BEBytesFromUInt64(rlp, outputBuffer, outputOffset);
}
public void verifyWithExceptions()
{
const int N = 32;
const int TIMES = 1000;
Random r = new Random();
int[] data = new int[N];
int[] compressed = new int[N];
int[] uncompressed = new int[N];
for (int bit = 0; bit < 31; ++bit)
{
for (int t = 0; t < TIMES; ++t)
{
for (int k = 0; k < N; ++k)
{
data[k] = r.Next();
}
BitPacking.fastpack(data, 0, compressed, 0, bit);
BitPacking.fastunpack(compressed, 0, uncompressed, 0, bit);
// Check assertions.
maskArray(data, ((1 << bit) - 1));
Assert2.assertArrayEquals(data, uncompressed);
}
}
}
static byte[] MFcrypt(byte[] P, byte[] S,
int cost, int blockSize, int parallel, int?maxThreads)
{
int MFLen = blockSize * 128;
if (maxThreads == null)
{
maxThreads = int.MaxValue;
}
if (!BitMath.IsPositivePowerOf2(cost))
{
throw Exceptions.ArgumentOutOfRange("cost", "Cost must be a positive power of 2.");
}
Check.Range("blockSize", blockSize, 1, int.MaxValue / 128);
Check.Range("parallel", parallel, 1, int.MaxValue / MFLen);
Check.Range("maxThreads", (int)maxThreads, 1, int.MaxValue);
byte[] B = Pbkdf2.ComputeDerivedKey(new HMACSHA256(P), S, 1, parallel * MFLen);
uint[] B0 = new uint[B.Length / 4];
for (int i = 0; i < B0.Length; i++)
{
B0[i] = BitPacking.UInt32FromLEBytes(B, i * 4);
} // code is easier with uint[]
ThreadSMixCalls(B0, MFLen, cost, blockSize, parallel, (int)maxThreads);
for (int i = 0; i < B0.Length; i++)
{
BitPacking.LEBytesFromUInt32(B0[i], B, i * 4);
}
Security.Clear(B0);
return(B);
}
void ExpandKey(byte[] key, byte[] salt, EksBlowfishKeyExpansionFlags flags)
{
uint[] p = P; uint[][] s = S;
int i, j, k; uint data, datal, datar;
j = 0;
for (i = 0; i < p.Length; i++)
{
data = 0x00000000;
for (k = 0; k < 4; k++)
{
if ((flags & EksBlowfishKeyExpansionFlags.EmulateCryptBlowfishSignExtensionBug) != 0)
{
data = (data << 8) | (uint)(int)(sbyte)key[j];
}
else
{
data = (data << 8) | key[j];
}
j = (j + 1) % key.Length;
}
p[i] = p[i] ^ data;
}
uint saltL0 = BitPacking.UInt32FromBEBytes(salt, 0);
uint saltR0 = BitPacking.UInt32FromBEBytes(salt, 4);
uint saltL1 = BitPacking.UInt32FromBEBytes(salt, 8);
uint saltR1 = BitPacking.UInt32FromBEBytes(salt, 12);
datal = 0x00000000;
datar = 0x00000000;
for (i = 0; i < p.Length; i += 4)
{
datal ^= saltL0; datar ^= saltR0;
Encipher(ref datal, ref datar); p[i + 0] = datal; p[i + 1] = datar;
if (i + 2 == p.Length)
{
break;
} // 18 here
datal ^= saltL1; datar ^= saltR1;
Encipher(ref datal, ref datar); p[i + 2] = datal; p[i + 3] = datar;
}
for (i = 0; i < s.Length; i++)
{
uint[] sb = s[i];
for (j = 0; j < sb.Length; j += 4)
{
datal ^= saltL1; datar ^= saltR1;
Encipher(ref datal, ref datar); sb[j + 0] = datal; sb[j + 1] = datar;
datal ^= saltL0; datar ^= saltR0;
Encipher(ref datal, ref datar); sb[j + 2] = datal; sb[j + 3] = datar;
}
}
}
/// <inheritdoc />
public override string Crypt(byte[] password, string salt)
{
Check.Null("password", password);
Check.Null("salt", salt);
Match match = _regex.Match(salt);
if (!match.Success)
{
throw Exceptions.Argument("salt", "Invalid salt.");
}
byte[] roundsBytes = null, saltBytes = null, crypt = null, input = null;
try
{
string roundsString = match.Groups["rounds"].Value;
roundsBytes = Base64Encoding.UnixMD5.GetBytes(roundsString);
int roundsValue = (int)BitPacking.UInt24FromLEBytes(roundsBytes, 0);
string saltString = match.Groups["salt"].Value;
saltBytes = Base64Encoding.UnixMD5.GetBytes(saltString);
int saltValue = (int)BitPacking.UInt24FromLEBytes(saltBytes, 0);
input = new byte[8];
int length = ByteArray.NullTerminatedLength(password, password.Length);
for (int m = 0; m < length; m += 8)
{
if (m != 0)
{
using (DesCipher cipher = DesCipher.Create(input))
{
cipher.Encipher(input, 0, input, 0);
}
}
for (int n = 0; n < 8 && n < length - m; n++)
{
// DES Crypt ignores the high bit of every byte.
input[n] ^= (byte)(password[m + n] << 1);
}
}
using (DesCipher cipher = DesCipher.Create(input))
{
crypt = new byte[8];
cipher.Crypt(crypt, 0, roundsValue, saltValue);
}
return("_" + roundsString + saltString + Base64Encoding.UnixCrypt.GetString(crypt));
}
finally
{
Security.Clear(roundsBytes);
Security.Clear(saltBytes);
Security.Clear(crypt);
Security.Clear(input);
}
}
private static int xorUnpack(int[] inBuf, int inOff, int[] outBuf, int outOff, int validBits, int context, int[] work)
{
BitPacking.fastunpack(inBuf, inOff, work, 0, validBits);
outBuf[outOff] = context = work[0] ^ context;
for (int i = 1, p = outOff + 1; i < 32; ++i, ++p)
{
outBuf[p] = context = work[i] ^ context;
}
return(validBits);
}
static BlowfishCipher()
{
byte[] magicBytes = Encoding.ASCII.GetBytes(BCryptMagic);
Array.Resize(ref magicBytes, (magicBytes.Length + 7) / 8 * 8);
Magic = new uint[(magicBytes.Length + 3) / 4];
for (int i = 0; i < Magic.Length; i++)
{
Magic[i] = BitPacking.UInt32FromBEBytes(magicBytes, i * 4);
}
}
private static int xorPack(int[] inBuf, int inOff, int[] outBuf, int outOff, int validBits, int context, int[] work)
{
work[0] = inBuf[inOff] ^ context;
for (int i = 1, p = inOff + 1; i < 32; ++i, ++p)
{
work[i] = inBuf[p] ^ inBuf[p - 1];
}
BitPacking.fastpackwithoutmask(work, 0, outBuf, outOff,
validBits);
return(validBits);
}
/// <summary>
/// Reverses the encipherment of eight bytes of data from one buffer and places the result in another buffer.
/// </summary>
/// <param name="inputBuffer">The buffer to read enciphered data from.</param>
/// <param name="inputOffset">The offset of the first enciphered byte.</param>
/// <param name="outputBuffer">The buffer to write plaintext data to.</param>
/// <param name="outputOffset">The offset at which to place the first plaintext byte.</param>
public void Decipher
(byte[] inputBuffer, int inputOffset,
byte[] outputBuffer, int outputOffset)
{
CheckCipherBuffers(inputBuffer, inputOffset, outputBuffer, outputOffset);
uint xl = BitPacking.UInt32FromBEBytes(inputBuffer, inputOffset + 0);
uint xr = BitPacking.UInt32FromBEBytes(inputBuffer, inputOffset + 4);
Decipher(ref xl, ref xr);
BitPacking.BEBytesFromUInt32(xl, outputBuffer, outputOffset + 0);
BitPacking.BEBytesFromUInt32(xr, outputBuffer, outputOffset + 4);
}
static byte[] MFcrypt(byte[] P, byte[] S,
int cost, int blockSize, int parallel, int?maxThreads)
{
int MFLen = blockSize * 128;
if (maxThreads == null)
{
maxThreads = int.MaxValue;
}
if (!BitMath.IsPositivePowerOf2(cost))
{
throw Exceptions.ArgumentOutOfRange("cost", "Cost must be a positive power of 2.");
}
Check.Range("blockSize", blockSize, 1, int.MaxValue / 128);
Check.Range("parallel", parallel, 1, int.MaxValue / MFLen);
Check.Range("maxThreads", (int)maxThreads, 1, int.MaxValue);
#if NO_NATIVE_HMACSHA512
var mac = new NBitcoin.BouncyCastle.Crypto.Macs.HMac(new NBitcoin.BouncyCastle.Crypto.Digests.Sha256Digest());
mac.Init(new KeyParameter(P));
byte[] B = Pbkdf2.ComputeDerivedKey(mac, S, 1, parallel * MFLen);
#elif NO_NATIVE_RFC2898_HMACSHA512
byte[] B = Pbkdf2.ComputeDerivedKey(new HMACSHA256(P), S, 1, parallel * MFLen);
#else
byte[] B = null;
if (S.Length >= 8)
{
// While we should be able to use Rfc2898DeriveBytes if salt is less than 8 bytes, it sadly does not accept salt less than 8 bytes needed for BIP38
using System.Security.Cryptography.Rfc2898DeriveBytes derive = new System.Security.Cryptography.Rfc2898DeriveBytes(P, S, 1, System.Security.Cryptography.HashAlgorithmName.SHA256);
B = derive.GetBytes(parallel * MFLen);
}
else
{
B = Pbkdf2.ComputeDerivedKey(new HMACSHA256(P), S, 1, parallel * MFLen);
}
#endif
uint[] B0 = new uint[B.Length / 4];
for (int i = 0; i < B0.Length; i++)
{
B0[i] = BitPacking.UInt32FromLEBytes(B, i * 4);
} // code is easier with uint[]
ThreadSMixCalls(B0, MFLen, cost, blockSize, parallel, (int)maxThreads);
for (int i = 0; i < B0.Length; i++)
{
BitPacking.LEBytesFromUInt32(B0[i], B, i * 4);
}
Security.Clear(B0);
return(B);
}
public static void test(bool verbose)
{
const int N = 32;
const int times = 100000;
Random r = new Random(0);
int[] data = new int[N];
int[] compressed = new int[N];
int[] uncompressed = new int[N];
for (int bit = 0; bit < 31; ++bit)
{
long comp = 0;
long compwm = 0;
long decomp = 0;
for (int t = 0; t < times; ++t)
{
for (int k = 0; k < N; ++k)
{
data[k] = r.Next(1 << bit);
}
long time1 = Port.System.nanoTime();
BitPacking
.fastpack(data, 0, compressed, 0, bit);
long time2 = Port.System.nanoTime();
BitPacking.fastpackwithoutmask(data, 0,
compressed, 0, bit);
long time3 = Port.System.nanoTime();
BitPacking.fastunpack(compressed, 0,
uncompressed, 0, bit);
long time4 = Port.System.nanoTime();
comp += time2 - time1;
compwm += time3 - time2;
decomp += time4 - time3;
}
if (verbose)
{
Console.WriteLine("bit = "
+ bit
+ " comp. speed = "
+ (N * times * 1000.0 / (comp)).ToString("0")
+ " comp. speed wm = "
+ (N * times * 1000.0 / (compwm)).ToString("0")
+ " decomp. speed = "
+ (N * times * 1000.0 / (decomp)).ToString("0"));
}
}
}
private void ComputeBlock(uint pos)
{
BitPacking.BEBytesFromUInt32(pos, this._saltBuffer, this._saltBuffer.Length - 4);
ComputeHmac(this._saltBuffer, this._digestT1);
Array.Copy(this._digestT1, this._digest, this._digestT1.Length);
for (int i = 1; i < this._iterations; i++)
{
ComputeHmac(this._digestT1, this._digestT1);
for (int j = 0; j < this._digest.Length; j++)
{
this._digest[j] ^= this._digestT1[j];
}
}
Security.Clear(this._digestT1);
}
void ComputeBlock(uint pos)
{
BitPacking.BEBytesFromUInt32(pos, _saltBuffer, _saltBuffer.Length - 4);
ComputeHmac(_saltBuffer, _digestT1);
Array.Copy(_digestT1, _digest, _digestT1.Length);
for (int i = 1; i < _iterations; i++)
{
ComputeHmac(_digestT1, _digestT1);
for (int j = 0; j < _digest.Length; j++)
{
_digest[j] ^= _digestT1[j];
}
}
NBitcoin.Crypto.Internal.Security.Clear(_digestT1);
}
private void encodePage(int[] @in, IntWrapper inpos, int thissize,
int[] @out, IntWrapper outpos)
{
int tmpoutpos = outpos.get();
int tmpinpos = inpos.get();
IntWrapper bestb = new IntWrapper();
IntWrapper bestexcept = new IntWrapper();
for (int finalinpos = tmpinpos + thissize; tmpinpos + BLOCK_SIZE <= finalinpos; tmpinpos += BLOCK_SIZE)
{
getBestBFromData(@in, tmpinpos, bestb, bestexcept);
int tmpbestb = bestb.get();
int nbrexcept = bestexcept.get();
int exceptsize = 0;
int remember = tmpoutpos;
tmpoutpos++;
if (nbrexcept > 0)
{
int c = 0;
for (int i = 0; i < BLOCK_SIZE; ++i)
{
if ((int)((uint)@in[tmpinpos + i] >> bits[tmpbestb]) != 0)
{
exceptbuffer[c + nbrexcept] = i;
exceptbuffer[c] = (int)((uint)@in[tmpinpos + i] >> bits[tmpbestb]);
++c;
}
}
exceptsize = S9.compress(exceptbuffer, 0,
2 * nbrexcept, @out, tmpoutpos);
tmpoutpos += exceptsize;
}
@out[remember] = tmpbestb | (nbrexcept << 8)
| (exceptsize << 16);
for (int k = 0; k < BLOCK_SIZE; k += 32)
{
BitPacking.fastpack(@in, tmpinpos + k, @out,
tmpoutpos, bits[tmpbestb]);
tmpoutpos += bits[tmpbestb];
}
}
inpos.set(tmpinpos);
outpos.set(tmpoutpos);
}
public void headlessCompress(int[] @in, IntWrapper inpos, int inlength, int[] @out, IntWrapper outpos)
{
inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
int tmpoutpos = outpos.get();
int s = inpos.get();
for (; s + BLOCK_SIZE * 4 - 1 < inpos.get() + inlength; s += BLOCK_SIZE * 4)
{
int mbits1 = Util.maxbits(@in, s, BLOCK_SIZE);
int mbits2 = Util.maxbits(@in, s + BLOCK_SIZE, BLOCK_SIZE);
int mbits3 = Util.maxbits(@in, s + 2 * BLOCK_SIZE, BLOCK_SIZE);
int mbits4 = Util.maxbits(@in, s + 3 * BLOCK_SIZE, BLOCK_SIZE);
@out[tmpoutpos++] = (mbits1 << 24) | (mbits2 << 16)
| (mbits3 << 8) | (mbits4);
BitPacking.fastpackwithoutmask(@in, s, @out, tmpoutpos,
mbits1);
tmpoutpos += mbits1;
BitPacking.fastpackwithoutmask(@in, s + BLOCK_SIZE, @out,
tmpoutpos, mbits2);
tmpoutpos += mbits2;
BitPacking.fastpackwithoutmask(@in, s + 2 * BLOCK_SIZE, @out,
tmpoutpos, mbits3);
tmpoutpos += mbits3;
BitPacking.fastpackwithoutmask(@in, s + 3 * BLOCK_SIZE, @out,
tmpoutpos, mbits4);
tmpoutpos += mbits4;
}
for (; s < inpos.get() + inlength; s += BLOCK_SIZE)
{
int mbits = Util.maxbits(@in, s, BLOCK_SIZE);
@out[tmpoutpos++] = mbits;
BitPacking.fastpackwithoutmask(@in, s, @out, tmpoutpos,
mbits);
tmpoutpos += mbits;
}
inpos.add(inlength);
outpos.set(tmpoutpos);
}
static byte[] MFcrypt(byte[] P, byte[] S,
int cost, int blockSize, int parallel, int?maxThreads)
{
int MFLen = blockSize * 128;
if (maxThreads == null)
{
maxThreads = int.MaxValue;
}
if (!BitMath.IsPositivePowerOf2(cost))
{
throw Exceptions.ArgumentOutOfRange("cost", "Cost must be a positive power of 2.");
}
Check.Range("blockSize", blockSize, 1, int.MaxValue / 128);
Check.Range("parallel", parallel, 1, int.MaxValue / MFLen);
Check.Range("maxThreads", (int)maxThreads, 1, int.MaxValue);
#if !(USEBC || NETSTANDARD1X)
byte[] B = Pbkdf2.ComputeDerivedKey(new HMACSHA256(P), S, 1, parallel * MFLen);
#else
var mac = new NBitcoin.BouncyCastle.Crypto.Macs.HMac(new NBitcoin.BouncyCastle.Crypto.Digests.Sha256Digest());
mac.Init(new KeyParameter(P));
byte[] B = Pbkdf2.ComputeDerivedKey(mac, S, 1, parallel * MFLen);
#endif
uint[] B0 = new uint[B.Length / 4];
for (int i = 0; i < B0.Length; i++)
{
B0[i] = BitPacking.UInt32FromLEBytes(B, i * 4);
} // code is easier with uint[]
ThreadSMixCalls(B0, MFLen, cost, blockSize, parallel, (int)maxThreads);
for (int i = 0; i < B0.Length; i++)
{
BitPacking.LEBytesFromUInt32(B0[i], B, i * 4);
}
Security.Clear(B0);
return(B);
}
public void headlessUncompress(int[] @in, IntWrapper inpos, int inlength, int[] @out, IntWrapper outpos, int num)
{
int outlength = Util.greatestMultiple(num, BLOCK_SIZE);
int tmpinpos = inpos.get();
int s = outpos.get();
for (; s + BLOCK_SIZE * 4 - 1 < outpos.get() + outlength; s += BLOCK_SIZE * 4)
{
int mbits1 = (int)((uint)@in[tmpinpos] >> 24);
int mbits2 = (int)((uint)@in[tmpinpos] >> 16) & 0xFF;
int mbits3 = (int)((uint)@in[tmpinpos] >> 8) & 0xFF;
int mbits4 = (int)((uint)@in[tmpinpos]) & 0xFF;
++tmpinpos;
BitPacking.fastunpack(@in, tmpinpos, @out, s, mbits1);
tmpinpos += mbits1;
BitPacking
.fastunpack(@in, tmpinpos, @out, s + BLOCK_SIZE, mbits2);
tmpinpos += mbits2;
BitPacking.fastunpack(@in, tmpinpos, @out, s + 2 * BLOCK_SIZE,
mbits3);
tmpinpos += mbits3;
BitPacking.fastunpack(@in, tmpinpos, @out, s + 3 * BLOCK_SIZE,
mbits4);
tmpinpos += mbits4;
}
for (; s < outpos.get() + outlength; s += BLOCK_SIZE)
{
int mbits = @in[tmpinpos];
++tmpinpos;
BitPacking.fastunpack(@in, tmpinpos, @out, s, mbits);
tmpinpos += mbits;
}
outpos.add(outlength);
inpos.set(tmpinpos);
}
void ExpandKey(byte[] key)
{
Dispose();
int[] pc1 = PC1, rotations = Rotations, pc2 = PC2;
uint[] c = new uint[16], d = new uint[16];
ulong[] kex = new ulong[16];
ulong k = BitPacking.UInt64FromBEBytes(key, 0);
ulong kp = Permute(PC1, k, 64); k = 0;
uint cn = (uint)(kp >> 28);
uint dn = (uint)(kp & 0xfffffff);
kp = 0;
for (int i = 0; i < c.Length; i++)
{
c[i] = cn = R(cn, rotations[i]);
}
cn = 0;
for (int i = 0; i < c.Length; i++)
{
d[i] = dn = R(dn, rotations[i]);
}
dn = 0;
for (int i = 0; i < kex.Length; i++)
{
ulong cd = (ulong)c[i] << 28 | d[i];
kex[i] = Permute(PC2, cd, 56);
cd = 0;
}
Security.Clear(c); Security.Clear(d);
Kex = kex;
}
public void verifyWithoutMask()
{
const int N = 32;
const int TIMES = 1000;
Random r = new Random();
int[] data = new int[N];
int[] compressed = new int[N];
int[] uncompressed = new int[N];
for (int bit = 0; bit < 31; ++bit)
{
for (int t = 0; t < TIMES; ++t)
{
for (int k = 0; k < N; ++k)
{
data[k] = r.Next(1 << bit);
}
BitPacking.fastpackwithoutmask(data, 0, compressed, 0, bit);
BitPacking.fastunpack(compressed, 0, uncompressed, 0, bit);
Assert2.assertArrayEquals(uncompressed, data);
}
}
}
void DoTest()
{
Debug.Log("write&read int : -11234\n");
int reta = BitPacking.WriteInt32(a, arr, 0);
Debug.Log(string.Format("write = {0}: {1}\t{2}\t{3}\t{4}\t{5}\n", reta, arr[0], arr[1], arr[2], arr[3], arr[4]));
int retb = BitPacking.ReadInt32(ref b, brr, 0);
Debug.Log(string.Format("read = {0}: {1}\n", retb, b));
Debug.Log("write&read uint : 11234\n");
int retc = BitPacking.WriteUInt32(c, crr, 0);
Debug.Log(string.Format("write = {0}: {1}\t{2}\t{3}\t{4}\t{5}\n", retc, crr[0], crr[1], crr[2], crr[3], crr[4]));
int retd = BitPacking.ReadUInt32(ref d, drr, 0);
Debug.Log(string.Format("read = {0}: {1}\n", retd, d));
if (reta != retb)
{
Debug.LogError("reta != retb");
}
if (a != b)
{
Debug.LogError("a != b");
}
if (retc != retd)
{
Debug.LogError("retc != retd");
}
if (c != d)
{
Debug.LogError("c != d");
}
Debug.Log("TestDone!\n");
}
public static void testWithDeltas(bool verbose)
{
const int N = 32;
const int times = 100000;
Random r = new Random(0);
int[] data = new int[N];
int[] compressed = new int[N];
int[] icompressed = new int[N];
int[] uncompressed = new int[N];
for (int bit = 1; bit < 31; ++bit)
{
long comp = 0;
long decomp = 0;
long icomp = 0;
long idecomp = 0;
for (int t = 0; t < times; ++t)
{
data[0] = r.Next(1 << bit);
for (int k = 1; k < N; ++k)
{
data[k] = r.Next(1 << bit)
+ data[k - 1];
}
int[] tmpdata = Arrays.copyOf(data, data.Length);
long time1 = Port.System.nanoTime();
Delta.delta(tmpdata);
BitPacking.fastpackwithoutmask(tmpdata, 0,
compressed, 0, bit);
long time2 = Port.System.nanoTime();
BitPacking.fastunpack(compressed, 0,
uncompressed, 0, bit);
Delta.fastinverseDelta(uncompressed);
long time3 = Port.System.nanoTime();
if (!Arrays.equals(data, uncompressed))
{
throw new Exception("bug");
}
comp += time2 - time1;
decomp += time3 - time2;
tmpdata = Arrays.copyOf(data, data.Length);
time1 = Port.System.nanoTime();
IntegratedBitPacking.integratedpack(0, tmpdata,
0, icompressed, 0, bit);
time2 = Port.System.nanoTime();
IntegratedBitPacking.integratedunpack(0,
icompressed, 0, uncompressed, 0, bit);
time3 = Port.System.nanoTime();
if (!Arrays.equals(icompressed, compressed))
{
throw new Exception("ibug " + bit);
}
if (!Arrays.equals(data, uncompressed))
{
throw new Exception("bug " + bit);
}
icomp += time2 - time1;
idecomp += time3 - time2;
}
if (verbose)
{
Console.WriteLine("bit = "
+ bit
+ " comp. speed = "
+ (N * times * 1000.0 / (comp)).ToString("0")
+ " decomp. speed = "
+ (N * times * 1000.0 / (decomp)).ToString("0")
+ " icomp. speed = "
+ (N * times * 1000.0 / (icomp)).ToString("0")
+ " idecomp. speed = "
+ (N * times * 1000.0 / (idecomp)).ToString("0"));
}
}
}
private void decodePage(int[] @in, IntWrapper inpos, int[] @out, IntWrapper outpos, int thissize)
{
int initpos = inpos.get();
int wheremeta = @in[inpos.get()];
inpos.increment();
int inexcept = initpos + wheremeta;
int bytesize = @in[inexcept++];
byteContainer.clear();
//byteContainer.asIntBuffer().put(@in, inexcept, (bytesize + 3) / 4); //Port note: I've collapsed the code here
byteContainer.put(@in, inexcept, (bytesize + 3) / 4);
byteContainer._ms.Position = 0;
inexcept += (bytesize + 3) / 4;
int bitmap = @in[inexcept++];
for (int k = 2; k <= 32; ++k)
{
if ((bitmap & (1 << (k - 1))) != 0)
{
int size = @in[inexcept++];
int roundedup = Util
.greatestMultiple(size + 31, 32);
if (dataTobePacked[k].Length < roundedup)
{
dataTobePacked[k] = new int[roundedup];
}
if (inexcept + roundedup / 32 * k <= @in.Length)
{
int j = 0;
for (; j < size; j += 32)
{
BitPacking.fastunpack(@in, inexcept,
dataTobePacked[k], j, k);
inexcept += k;
}
int overflow = j - size;
inexcept -= overflow * k / 32;
}
else
{
int j = 0;
int[] buf = new int[roundedup / 32 * k];
int initinexcept = inexcept;
Array.Copy(@in, inexcept, buf, 0, @in.Length - inexcept);
for (; j < size; j += 32)
{
BitPacking.fastunpack(buf, inexcept - initinexcept,
dataTobePacked[k], j, k);
inexcept += k;
}
int overflow = j - size;
inexcept -= overflow * k / 32;
}
}
}
Arrays.fill(dataPointers, 0);
int tmpoutpos = outpos.get();
int tmpinpos = inpos.get();
for (int run = 0, run_end = thissize / BLOCK_SIZE; run < run_end; ++run, tmpoutpos += BLOCK_SIZE)
{
int b = byteContainer.get();
int cexcept = byteContainer.get() & 0xFF;
for (int k = 0; k < BLOCK_SIZE; k += 32)
{
BitPacking.fastunpack(@in, tmpinpos, @out,
tmpoutpos + k, b);
tmpinpos += b;
}
if (cexcept > 0)
{
int maxbits = byteContainer.get();
int index = maxbits - b;
if (index == 1)
{
for (int k = 0; k < cexcept; ++k)
{
int pos = byteContainer.get() & 0xFF;
@out[pos + tmpoutpos] |= 1 << b;
}
}
else
{
for (int k = 0; k < cexcept; ++k)
{
int pos = byteContainer.get() & 0xFF;
int exceptvalue = dataTobePacked[index][dataPointers[index]++];
@out[pos + tmpoutpos] |= exceptvalue << b;
}
}
}
}
outpos.set(tmpoutpos);
inpos.set(inexcept);
}
private void encodePage(int[] @in, IntWrapper inpos, int thissize, int[] @out, IntWrapper outpos)
{
int headerpos = outpos.get();
outpos.increment();
int tmpoutpos = outpos.get();
// Clear working area.
Arrays.fill(dataPointers, 0);
byteContainer.clear();
int tmpinpos = inpos.get();
for (int finalinpos = tmpinpos + thissize - BLOCK_SIZE; tmpinpos <= finalinpos; tmpinpos += BLOCK_SIZE)
{
getBestBFromData(@in, tmpinpos);
int tmpbestb = bestbbestcexceptmaxb[0];
byteContainer.put((sbyte)bestbbestcexceptmaxb[0]);
byteContainer.put((sbyte)bestbbestcexceptmaxb[1]);
if (bestbbestcexceptmaxb[1] > 0)
{
byteContainer.put((sbyte)bestbbestcexceptmaxb[2]);
int index = bestbbestcexceptmaxb[2]
- bestbbestcexceptmaxb[0];
if (dataPointers[index]
+ bestbbestcexceptmaxb[1] >= dataTobePacked[index].Length)
{
int newsize = 2 * (dataPointers[index] + bestbbestcexceptmaxb[1]);
// make sure it is a multiple of 32
newsize = Util.greatestMultiple(newsize + 31, 32);
dataTobePacked[index] = Arrays.copyOf(dataTobePacked[index], newsize);
}
for (int k = 0; k < BLOCK_SIZE; ++k)
{
if ((int)((uint)@in[k + tmpinpos] >> bestbbestcexceptmaxb[0]) != 0)
{
// we have an exception
byteContainer.put((sbyte)k);
dataTobePacked[index][dataPointers[index]++] = (int)((uint)@in[k + tmpinpos] >> tmpbestb);
}
}
}
for (int k = 0; k < BLOCK_SIZE; k += 32)
{
BitPacking.fastpack(@in, tmpinpos + k, @out,
tmpoutpos, tmpbestb);
tmpoutpos += tmpbestb;
}
}
inpos.set(tmpinpos);
@out[headerpos] = tmpoutpos - headerpos;
int bytesize = byteContainer.position();
while ((byteContainer.position() & 3) != 0)
{
byteContainer.put((sbyte)0);
}
@out[tmpoutpos++] = bytesize;
int howmanyints = byteContainer.position() / 4;
byteContainer.flip();
byteContainer.asIntBuffer().get(@out, tmpoutpos, howmanyints);
tmpoutpos += howmanyints;
int bitmap = 0;
for (int k = 2; k <= 32; ++k)
{
if (dataPointers[k] != 0)
{
bitmap |= (1 << (k - 1));
}
}
@out[tmpoutpos++] = bitmap;
for (int k = 2; k <= 32; ++k)
{
if (dataPointers[k] != 0)
{
@out[tmpoutpos++] = dataPointers[k];// size
int j = 0;
for (; j < dataPointers[k]; j += 32)
{
BitPacking.fastpack(dataTobePacked[k],
j, @out, tmpoutpos, k);
tmpoutpos += k;
}
int overflow = j - dataPointers[k];
tmpoutpos -= overflow * k / 32;
}
}
outpos.set(tmpoutpos);
}
private static int unpack(int[] inBuf, int inOff, int[] outBuf, int outOff, int validBits)
{
BitPacking.fastunpack(inBuf, inOff, outBuf, outOff, validBits);
return(validBits);
}