public void uncompress(int[] inBuf, IntWrapper inPos, int inLen, int[] outBuf, IntWrapper outPos)
{
if (inLen == 0)
{
return;
}
int outLen = inBuf[inPos.get()];
inPos.increment();
DeltaZigzagEncoding.Decoder ctx = new DeltaZigzagEncoding.Decoder(0);
int[] work = new int[BLOCK_LENGTH];
int ip = inPos.get();
int op = outPos.get();
int outPosLast = op + outLen;
for (; op < outPosLast; op += BLOCK_LENGTH)
{
int n = inBuf[ip++];
ip += unpack(inBuf, ip, work, 0, (n >> 24) & 0x3F);
ip += unpack(inBuf, ip, work, 32, (n >> 16) & 0x3F);
ip += unpack(inBuf, ip, work, 64, (n >> 8) & 0x3F);
ip += unpack(inBuf, ip, work, 96, (n >> 0) & 0x3F);
ctx.decodeArray(work, 0, BLOCK_LENGTH, outBuf, op);
}
outPos.add(outLen);
inPos.set(ip);
}
public void uncompress(int[] @in, IntWrapper inpos, int inlength, int[] @out, IntWrapper outpos)
{
int s = 0;
int val = 0;
int p = inpos.get();
int finalp = inpos.get() + inlength;
int tmpoutpos = outpos.get();
int initoffset = 0;
for (int v = 0, shift = 0; p < finalp;)
{
val = @in[p];
int c = (sbyte)(int)((uint)val >> s);
s += 8;
p += s >> 5;
s = s & 31;
v += ((c & 127) << shift);
if ((c & 128) == 128)
{
@out[tmpoutpos] = v + initoffset;
initoffset = @out[tmpoutpos];
tmpoutpos++;
v = 0;
shift = 0;
}
else
{
shift += 7;
}
}
outpos.set(tmpoutpos);
inpos.add(inlength);
}
/*@Override*/
public void headlessUncompress(int[] @in, IntWrapper inpos, int inlength, int[] @out,
IntWrapper outpos, int num)
{
num = Util.greatestMultiple(num, BLOCK_SIZE);
if (num > 0)
{
int d = PForDelta.decompressOneBlock(@out, @in, num);
inpos.add(d / 32);
outpos.add(num);
}
}
/*@Override*/
public void headlessCompress(int[] @in, IntWrapper inpos, int inlength, int[] @out,
IntWrapper outpos)
{
inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
if (inlength > 0)
{
int[] out2 = PForDelta.compressOneBlockOpt(@in, inlength);
inpos.add(inlength);
Array.Copy(out2, 0, @out, outpos.get(), out2.Length);
outpos.add(out2.Length);
}
}
public void headlessCompress(int[] @in, IntWrapper inpos, int inlength, int[] @out, IntWrapper outpos, IntWrapper initvalue)
{
inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
if (inlength == 0)
{
return;
}
int tmpoutpos = outpos.get();
int initoffset = initvalue.get();
initvalue.set(@in[inpos.get() + inlength - 1]);
int s = inpos.get();
for (; s + BLOCK_SIZE * 4 - 1 < inpos.get() + inlength; s += BLOCK_SIZE * 4)
{
int mbits1 = Util.maxdiffbits(initoffset, @in, s, BLOCK_SIZE);
int initoffset2 = @in[s + 31];
int mbits2 = Util.maxdiffbits(initoffset2, @in, s + BLOCK_SIZE, BLOCK_SIZE);
int initoffset3 = @in[s + BLOCK_SIZE + 31];
int mbits3 = Util
.maxdiffbits(initoffset3, @in, s + 2 * BLOCK_SIZE, BLOCK_SIZE);
int initoffset4 = @in[s + 2 * BLOCK_SIZE + 31];
int mbits4 = Util
.maxdiffbits(initoffset4, @in, s + 3 * BLOCK_SIZE, BLOCK_SIZE);
@out[tmpoutpos++] = (mbits1 << 24) | (mbits2 << 16) | (mbits3 << 8)
| (mbits4);
IntegratedBitPacking.integratedpack(initoffset, @in, s, @out,
tmpoutpos, mbits1);
tmpoutpos += mbits1;
IntegratedBitPacking.integratedpack(initoffset2, @in, s + BLOCK_SIZE, @out,
tmpoutpos, mbits2);
tmpoutpos += mbits2;
IntegratedBitPacking.integratedpack(initoffset3, @in, s + 2 * BLOCK_SIZE,
@out, tmpoutpos, mbits3);
tmpoutpos += mbits3;
IntegratedBitPacking.integratedpack(initoffset4, @in, s + 3 * BLOCK_SIZE,
@out, tmpoutpos, mbits4);
tmpoutpos += mbits4;
initoffset = @in[s + 3 * BLOCK_SIZE + 31];
}
for (; s < inpos.get() + inlength; s += BLOCK_SIZE)
{
int mbits = Util.maxdiffbits(initoffset, @in, s, BLOCK_SIZE);
@out[tmpoutpos++] = mbits;
IntegratedBitPacking.integratedpack(initoffset, @in, s, @out,
tmpoutpos, mbits);
tmpoutpos += mbits;
initoffset = @in[s + 31];
}
inpos.add(inlength);
outpos.set(tmpoutpos);
}
public void compress(int[] @in, IntWrapper inpos, int inlength, sbyte[] @out, IntWrapper outpos)
{
if (inlength == 0)
{
return;
}
int initoffset = 0;
int outpostmp = outpos.get();
for (int k = inpos.get(); k < inpos.get() + inlength; ++k)
{
long val = (@in[k] - initoffset) & 0xFFFFFFFFL; // To be consistent with unsigned integers in C/C++
initoffset = @in[k];
if (val < (1 << 7))
{
@out[outpostmp++] = (sbyte)(val | (1 << 7));
}
else if (val < (1 << 14))
{
@out[outpostmp++] = (sbyte)extract7bits(0, val);
@out[outpostmp++] = (sbyte)(extract7bitsmaskless(1, (val)) | (1 << 7));
}
else if (val < (1 << 21))
{
@out[outpostmp++] = (sbyte)extract7bits(0, val);
@out[outpostmp++] = (sbyte)extract7bits(1, val);
@out[outpostmp++] = (sbyte)(extract7bitsmaskless(2, (val)) | (1 << 7));
}
else if (val < (1 << 28))
{
@out[outpostmp++] = (sbyte)extract7bits(0, val);
@out[outpostmp++] = (sbyte)extract7bits(1, val);
@out[outpostmp++] = (sbyte)extract7bits(2, val);
@out[outpostmp++] = (sbyte)(extract7bitsmaskless(3, (val)) | (1 << 7));
}
else
{
@out[outpostmp++] = (sbyte)extract7bits(0, val);
@out[outpostmp++] = (sbyte)extract7bits(1, val);
@out[outpostmp++] = (sbyte)extract7bits(2, val);
@out[outpostmp++] = (sbyte)extract7bits(3, val);
@out[outpostmp++] = (sbyte)(extract7bitsmaskless(4, (val)) | (1 << 7));
}
}
outpos.set(outpostmp);
inpos.add(inlength);
}
public void headlessUncompress(int[] @in, IntWrapper inpos, int inlength, int[] @out, IntWrapper outpos, int num, IntWrapper initvalue)
{
int outlength = Util.greatestMultiple(num, BLOCK_SIZE);
int tmpinpos = inpos.get();
int initoffset = initvalue.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 = (@in[tmpinpos]) & 0xFF;
++tmpinpos;
IntegratedBitPacking.integratedunpack(initoffset, @in, tmpinpos,
@out, s, mbits1);
tmpinpos += mbits1;
initoffset = @out[s + 31];
IntegratedBitPacking.integratedunpack(initoffset, @in, tmpinpos,
@out, s + BLOCK_SIZE, mbits2);
tmpinpos += mbits2;
initoffset = @out[s + BLOCK_SIZE + 31];
IntegratedBitPacking.integratedunpack(initoffset, @in, tmpinpos,
@out, s + 2 * BLOCK_SIZE, mbits3);
tmpinpos += mbits3;
initoffset = @out[s + 2 * BLOCK_SIZE + 31];
IntegratedBitPacking.integratedunpack(initoffset, @in, tmpinpos,
@out, s + 3 * BLOCK_SIZE, mbits4);
tmpinpos += mbits4;
initoffset = @out[s + 3 * BLOCK_SIZE + 31];
}
for (; s < outpos.get() + outlength; s += BLOCK_SIZE)
{
int mbits = @in[tmpinpos];
++tmpinpos;
IntegratedBitPacking.integratedunpack(initoffset, @in, tmpinpos,
@out, s, mbits);
initoffset = @out[s + 31];
tmpinpos += mbits;
}
outpos.add(outlength);
initvalue.set(initoffset);
inpos.set(tmpinpos);
}
public void compress(int[] inBuf, IntWrapper inPos, int inLen, int[] outBuf, IntWrapper outPos)
{
inLen = inLen - inLen % BLOCK_LENGTH;
if (inLen == 0)
{
return;
}
outBuf[outPos.get()] = inLen;
outPos.increment();
int context = 0;
int[] work = new int[32];
int op = outPos.get();
int ip = inPos.get();
int inPosLast = ip + inLen;
for (; ip < inPosLast; ip += BLOCK_LENGTH)
{
int bits1 = xorMaxBits(inBuf, ip + 0, 32, context);
int bits2 = xorMaxBits(inBuf, ip + 32, 32,
inBuf[ip + 31]);
int bits3 = xorMaxBits(inBuf, ip + 64, 32,
inBuf[ip + 63]);
int bits4 = xorMaxBits(inBuf, ip + 96, 32,
inBuf[ip + 95]);
outBuf[op++] = (bits1 << 24) | (bits2 << 16)
| (bits3 << 8) | (bits4 << 0);
op += xorPack(inBuf, ip + 0, outBuf, op, bits1,
context, work);
op += xorPack(inBuf, ip + 32, outBuf, op, bits2,
inBuf[ip + 31], work);
op += xorPack(inBuf, ip + 64, outBuf, op, bits3,
inBuf[ip + 63], work);
op += xorPack(inBuf, ip + 96, outBuf, op, bits4,
inBuf[ip + 95], work);
context = inBuf[ip + 127];
}
inPos.add(inLen);
outPos.set(op);
}
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);
}
public void uncompress(int[] inBuf, IntWrapper inPos, int inLen, int[] outBuf, IntWrapper outPos)
{
if (inLen == 0)
{
return;
}
int outLen = inBuf[inPos.get()];
inPos.increment();
int context = 0;
int[] work = new int[32];
int ip = inPos.get();
int op = outPos.get();
int outPosLast = op + outLen;
for (; op < outPosLast; op += BLOCK_LENGTH)
{
int bits1 = (int)((uint)inBuf[ip] >> 24);
int bits2 = (int)((uint)inBuf[ip] >> 16) & 0xFF;
int bits3 = (int)((uint)inBuf[ip] >> 8) & 0xFF;
int bits4 = (int)((uint)inBuf[ip] >> 0) & 0xFF;
++ip;
ip += xorUnpack(inBuf, ip, outBuf, op + 0, bits1,
context, work);
ip += xorUnpack(inBuf, ip, outBuf, op + 32, bits2,
outBuf[op + 31], work);
ip += xorUnpack(inBuf, ip, outBuf, op + 64, bits3,
outBuf[op + 63], work);
ip += xorUnpack(inBuf, ip, outBuf, op + 96, bits4,
outBuf[op + 95], work);
context = outBuf[op + 127];
}
outPos.add(outLen);
inPos.set(ip);
}
public void uncompress(sbyte[] @in, IntWrapper inpos, int inlength, int[] @out, IntWrapper outpos)
{
int p = inpos.get();
int initoffset = 0;
int finalp = inpos.get() + inlength;
int tmpoutpos = outpos.get();
for (int v = 0; p < finalp; @out[tmpoutpos++] = (initoffset = initoffset + v))
{
v = @in[p] & 0x7F;
if (@in[p] < 0)
{
p += 1;
continue;
}
v = ((@in[p + 1] & 0x7F) << 7) | v;
if (@in[p + 1] < 0)
{
p += 2;
continue;
}
v = ((@in[p + 2] & 0x7F) << 14) | v;
if (@in[p + 2] < 0)
{
p += 3;
continue;
}
v = ((@in[p + 3] & 0x7F) << 21) | v;
if (@in[p + 3] < 0)
{
p += 4;
continue;
}
v = ((@in[p + 4] & 0x7F) << 28) | v;
p += 5;
}
outpos.set(tmpoutpos);
inpos.add(p);
}
public void compress(int[] inBuf, IntWrapper inPos, int inLen, int[] outBuf, IntWrapper outPos)
{
inLen = inLen - inLen % BLOCK_LENGTH;
if (inLen == 0)
{
return;
}
outBuf[outPos.get()] = inLen;
outPos.increment();
DeltaZigzagEncoding.Encoder ctx = new DeltaZigzagEncoding.Encoder(0);
int[] work = new int[BLOCK_LENGTH];
int op = outPos.get();
int ip = inPos.get();
int inPosLast = ip + inLen;
for (; ip < inPosLast; ip += BLOCK_LENGTH)
{
ctx.encodeArray(inBuf, ip, BLOCK_LENGTH, work);
int bits1 = Util.maxbits32(work, 0);
int bits2 = Util.maxbits32(work, 32);
int bits3 = Util.maxbits32(work, 64);
int bits4 = Util.maxbits32(work, 96);
outBuf[op++] = (bits1 << 24) | (bits2 << 16)
| (bits3 << 8) | (bits4 << 0);
op += pack(work, 0, outBuf, op, bits1);
op += pack(work, 32, outBuf, op, bits2);
op += pack(work, 64, outBuf, op, bits3);
op += pack(work, 96, outBuf, op, bits4);
}
inPos.add(inLen);
outPos.set(op);
}
public void compress(int[] @in, IntWrapper inpos, int inlength, int[] @out, IntWrapper outpos)
{
if (inlength == 0)
{
return;
}
int initoffset = 0;
ByteBuffer buf = ByteBuffer.allocateDirect(inlength * 8);
buf.order(ByteOrder.LITTLE_ENDIAN);
for (int k = inpos.get(); k < inpos.get() + inlength; ++k)
{
long val = (@in[k] - initoffset) & 0xFFFFFFFFL; // To be consistent with unsigned integers in C/C++
initoffset = @in[k];
if (val < (1 << 7))
{
buf.put((sbyte)(val | (1 << 7)));
}
else if (val < (1 << 14))
{
buf.put((sbyte)extract7bits(0, val));
buf.put((sbyte)(extract7bitsmaskless(1, (val)) | (1 << 7)));
}
else if (val < (1 << 21))
{
buf.put((sbyte)extract7bits(0, val));
buf.put((sbyte)extract7bits(1, val));
buf.put((sbyte)(extract7bitsmaskless(2, (val)) | (1 << 7)));
}
else if (val < (1 << 28))
{
buf.put((sbyte)extract7bits(0, val));
buf.put((sbyte)extract7bits(1, val));
buf.put((sbyte)extract7bits(2, val));
buf.put((sbyte)(extract7bitsmaskless(3, (val)) | (1 << 7)));
}
else
{
buf.put((sbyte)extract7bits(0, val));
buf.put((sbyte)extract7bits(1, val));
buf.put((sbyte)extract7bits(2, val));
buf.put((sbyte)extract7bits(3, val));
buf.put((sbyte)(extract7bitsmaskless(4, (val)) | (1 << 7)));
}
}
while (buf.position() % 4 != 0)
{
buf.put((sbyte)0);
}
int length = buf.position();
buf.flip();
IntBuffer ibuf = buf.asIntBuffer();
ibuf.get(@out, outpos.get(), length / 4);
outpos.add(length / 4);
inpos.add(inlength);
}
