dmolony-DiskBrowser/src/com/bytezone/diskbrowser/applefile/ExoBuffer.java

315 lines
7.7 KiB
Java
Raw Normal View History

2020-06-23 04:23:53 +00:00
package com.bytezone.diskbrowser.applefile;
// pack::: ~/exomizer-3.0.2/src/exomizer mem -q -P23 -lnone LODE148@0x4000 -o LODE148c
// unpack: ~/exomizer-3.0.2/src/exomizer raw -d -b -P23 LODE148c,0,-2 -o LODE148x
// -----------------------------------------------------------------------------------//
public class ExoBuffer
{
private static int PBIT_BITS_ORDER_BE = 0;
private static int PBIT_BITS_COPY_GT_7 = 1;
private static int PBIT_IMPL_1LITERAL = 2;
private static int PBIT_BITS_ALIGN_START = 3;
private static int PBIT_4_OFFSET_TABLES = 4;
private static int PFLAG_BITS_ORDER_BE = (1 << PBIT_BITS_ORDER_BE);
private static int PFLAG_BITS_COPY_GT_7 = (1 << PBIT_BITS_COPY_GT_7);
private static int PFLAG_IMPL_1LITERAL = (1 << PBIT_IMPL_1LITERAL);
private static int PFLAG_BITS_ALIGN_START = (1 << PBIT_BITS_ALIGN_START);
private static int PFLAG_4_OFFSET_TABLES = (1 << PBIT_4_OFFSET_TABLES);
2020-06-23 23:08:11 +00:00
private byte[] inBuffer;
private byte[] outBuffer = new byte[0x8000];
2020-06-23 21:31:29 +00:00
2020-06-23 23:08:11 +00:00
private int inPos;
private int outPos;
2020-06-23 04:23:53 +00:00
2020-06-23 23:08:11 +00:00
private int bitBuffer;
private int flags;
2020-06-23 21:31:29 +00:00
2020-06-23 23:08:11 +00:00
private int tableBit[] = new int[8];
private int tableOff[] = new int[8];
private int tableBi[] = new int[100];
private int tableLo[] = new int[100];
private int tableHi[] = new int[100];
2020-06-23 21:31:29 +00:00
2020-06-23 04:23:53 +00:00
// ---------------------------------------------------------------------------------//
public ExoBuffer (byte[] inBuffer)
// ---------------------------------------------------------------------------------//
{
reverse (inBuffer);
2020-06-23 21:31:29 +00:00
this.inBuffer = inBuffer;
inPos = 2;
outPos = 0;
2020-06-23 23:08:11 +00:00
flags = 23;
2020-06-23 21:31:29 +00:00
2020-06-23 23:08:11 +00:00
if ((flags & PFLAG_BITS_ALIGN_START) != 0)
2020-06-23 21:31:29 +00:00
bitBuffer = 0;
else
bitBuffer = getByte ();
tableInit ();
2020-06-23 21:33:14 +00:00
decrunch ();
2020-06-23 04:23:53 +00:00
2020-06-23 23:08:11 +00:00
if (outPos < outBuffer.length)
2020-06-23 05:50:54 +00:00
{
2020-06-23 21:31:29 +00:00
byte[] outBuffer2 = new byte[outPos];
2020-06-23 23:08:11 +00:00
System.arraycopy (outBuffer, 0, outBuffer2, 0, outPos);
2020-06-23 05:50:54 +00:00
outBuffer = outBuffer2;
}
2020-06-23 23:08:11 +00:00
2020-06-23 04:23:53 +00:00
reverse (outBuffer);
}
2020-06-23 05:50:54 +00:00
// ---------------------------------------------------------------------------------//
2020-06-23 23:08:11 +00:00
private void reverse (byte[] buffer)
2020-06-23 05:50:54 +00:00
// ---------------------------------------------------------------------------------//
2020-06-23 04:23:53 +00:00
{
int lo = 0;
2020-06-23 23:08:11 +00:00
int hi = buffer.length - 1;
2020-06-23 04:23:53 +00:00
while (lo < hi)
{
2020-06-23 23:08:11 +00:00
byte temp = buffer[lo];
buffer[lo++] = buffer[hi];
buffer[hi--] = temp;
2020-06-23 04:23:53 +00:00
}
}
// ---------------------------------------------------------------------------------//
public byte[] getExpandedBuffer ()
// ---------------------------------------------------------------------------------//
{
return outBuffer;
}
// ---------------------------------------------------------------------------------//
2020-06-23 21:31:29 +00:00
private int bitBufRotate (int carry)
2020-06-23 04:23:53 +00:00
// ---------------------------------------------------------------------------------//
{
int carryOut;
2020-06-23 23:08:11 +00:00
if ((flags & PFLAG_BITS_ORDER_BE) != 0)
2020-06-23 04:23:53 +00:00
{
2020-06-23 21:31:29 +00:00
carryOut = (bitBuffer & 0x80) == 0 ? 0 : 1;
bitBuffer = (bitBuffer << 1) & 0xFF;
2020-06-23 04:23:53 +00:00
if (carry != 0)
2020-06-23 21:31:29 +00:00
bitBuffer |= 0x01;
2020-06-23 04:23:53 +00:00
}
else
{
2020-06-23 21:31:29 +00:00
carryOut = bitBuffer & 0x01;
bitBuffer = (bitBuffer >>> 1) & 0xFF;
2020-06-23 04:23:53 +00:00
if (carry != 0)
2020-06-23 21:31:29 +00:00
bitBuffer |= 0x80;
2020-06-23 04:23:53 +00:00
}
return carryOut;
}
// ---------------------------------------------------------------------------------//
2020-06-23 21:31:29 +00:00
private int getByte ()
2020-06-23 04:23:53 +00:00
// ---------------------------------------------------------------------------------//
{
2020-06-23 23:08:11 +00:00
return inBuffer[inPos++] & 0xFF;
2020-06-23 04:23:53 +00:00
}
// ---------------------------------------------------------------------------------//
2020-06-23 21:31:29 +00:00
private int getBits (int count)
2020-06-23 04:23:53 +00:00
// ---------------------------------------------------------------------------------//
{
int byteCopy = 0;
int value = 0;
2020-06-23 23:08:11 +00:00
if ((flags & PFLAG_BITS_COPY_GT_7) != 0)
2020-06-23 04:23:53 +00:00
{
while (count > 7)
{
byteCopy = count >>> 3;
count &= 7;
}
}
while (count-- > 0)
{
2020-06-23 21:31:29 +00:00
int carry = bitBufRotate (0);
2020-06-23 04:23:53 +00:00
2020-06-23 21:31:29 +00:00
if (bitBuffer == 0)
2020-06-23 04:23:53 +00:00
{
2020-06-23 21:31:29 +00:00
bitBuffer = getByte ();
carry = bitBufRotate (1);
2020-06-23 04:23:53 +00:00
}
value <<= 1;
value |= carry;
}
while (byteCopy-- > 0)
{
value <<= 8;
2020-06-23 21:31:29 +00:00
value |= getByte ();
2020-06-23 04:23:53 +00:00
}
return value;
}
// ---------------------------------------------------------------------------------//
2020-06-23 21:31:29 +00:00
private void tableInit ()
2020-06-23 04:23:53 +00:00
// ---------------------------------------------------------------------------------//
{
int end;
int a = 0;
int b = 0;
2020-06-23 21:31:29 +00:00
tableBit[0] = 2;
tableBit[1] = 4;
tableBit[2] = 4;
2020-06-23 04:23:53 +00:00
2020-06-23 23:08:11 +00:00
if ((flags & PFLAG_4_OFFSET_TABLES) != 0)
2020-06-23 04:23:53 +00:00
{
end = 68;
2020-06-23 21:31:29 +00:00
tableBit[3] = 4;
2020-06-23 04:23:53 +00:00
2020-06-23 21:31:29 +00:00
tableOff[0] = 64;
tableOff[1] = 48;
tableOff[2] = 32;
tableOff[3] = 16;
2020-06-23 04:23:53 +00:00
}
else
{
end = 52;
2020-06-23 21:31:29 +00:00
tableOff[0] = 48;
tableOff[1] = 32;
tableOff[2] = 16;
2020-06-23 04:23:53 +00:00
}
for (int i = 0; i < end; i++)
{
if ((i & 0x0F) != 0)
a += (1 << b);
else
a = 1;
2020-06-23 21:31:29 +00:00
tableLo[i] = a & 0xFF;
tableHi[i] = a >>> 8;
2020-06-23 04:23:53 +00:00
2020-06-23 23:08:11 +00:00
if ((flags & PFLAG_BITS_COPY_GT_7) != 0)
2020-06-23 04:23:53 +00:00
{
2020-06-23 21:31:29 +00:00
b = getBits (3);
b |= getBits (1) << 3;
2020-06-23 04:23:53 +00:00
}
else
2020-06-23 21:31:29 +00:00
b = getBits (4);
2020-06-23 04:23:53 +00:00
2020-06-23 21:31:29 +00:00
tableBi[i] = b;
2020-06-23 04:23:53 +00:00
}
2020-06-23 23:08:11 +00:00
// tableDump ();
2020-06-23 04:23:53 +00:00
}
// ---------------------------------------------------------------------------------//
2020-06-23 21:31:29 +00:00
private void tableDump ()
2020-06-23 04:23:53 +00:00
// ---------------------------------------------------------------------------------//
{
for (int i = 0; i < 16; i++)
2020-06-23 21:31:29 +00:00
System.out.printf ("%X", tableBi[i]);
2020-06-23 04:23:53 +00:00
for (int j = 0; j < 3; j++)
{
System.out.printf (",");
2020-06-23 21:31:29 +00:00
int start = tableOff[j];
int end = start + (1 << tableBit[j]);
2020-06-23 04:23:53 +00:00
for (int i = start; i < end; i++)
2020-06-23 21:31:29 +00:00
System.out.printf ("%X", tableBi[i]);
2020-06-23 04:23:53 +00:00
}
System.out.println ();
}
// ---------------------------------------------------------------------------------//
2020-06-23 21:33:14 +00:00
private void decrunch ()
2020-06-23 04:23:53 +00:00
// ---------------------------------------------------------------------------------//
{
int len;
2020-06-23 22:41:47 +00:00
int srcPtr = 0;
2020-06-23 04:23:53 +00:00
int literal;
2020-06-23 23:08:11 +00:00
int threshold = (flags & PFLAG_4_OFFSET_TABLES) != 0 ? 4 : 3;
2020-06-23 04:23:53 +00:00
2020-06-23 23:08:11 +00:00
if ((flags & PFLAG_IMPL_1LITERAL) != 0)
2020-06-23 04:23:53 +00:00
{
len = 1;
literal = 1;
2020-06-23 22:41:47 +00:00
srcPtr = copy (len, literal, srcPtr);
2020-06-23 04:23:53 +00:00
}
while (true)
{
2020-06-23 21:31:29 +00:00
if (getBits (1) != 0)
2020-06-23 04:23:53 +00:00
{
len = 1;
literal = 1;
}
2020-06-23 22:41:47 +00:00
else
2020-06-23 04:23:53 +00:00
{
2020-06-23 22:41:47 +00:00
int val = getGammaCode ();
if (val == 16)
break;
if (val == 17)
{
len = getBits (16);
literal = 1;
}
else
{
len = getCooked (val);
2020-06-23 23:08:11 +00:00
literal = 0;
2020-06-23 22:41:47 +00:00
int i = (len > threshold ? threshold : len) - 1;
srcPtr = outPos - getCooked (tableOff[i] + getBits (tableBit[i]));
}
2020-06-23 04:23:53 +00:00
}
2020-06-23 22:41:47 +00:00
srcPtr = copy (len, literal, srcPtr);
2020-06-23 04:23:53 +00:00
}
}
2020-06-23 23:08:11 +00:00
// ---------------------------------------------------------------------------------//
private int getGammaCode ()
// ---------------------------------------------------------------------------------//
{
int gammaCode = 0;
while (getBits (1) == 0)
++gammaCode;
return gammaCode;
}
// ---------------------------------------------------------------------------------//
private int getCooked (int index)
// ---------------------------------------------------------------------------------//
{
int base = tableLo[index] | (tableHi[index] << 8);
return base + getBits (tableBi[index]);
}
2020-06-23 04:23:53 +00:00
// ---------------------------------------------------------------------------------//
2020-06-23 22:41:47 +00:00
private int copy (int len, int literal, int src)
2020-06-23 04:23:53 +00:00
// ---------------------------------------------------------------------------------//
{
assert len > 0;
do
{
2020-06-23 21:31:29 +00:00
int val = literal == 0 ? outBuffer[src++] : getByte ();
outBuffer[outPos++] = (byte) (val & 0xFF);
2020-06-23 04:23:53 +00:00
} while (--len > 0);
return src;
}
}