931 lines
15 KiB
C#
931 lines
15 KiB
C#
using System.IO;
|
|
using Org.BouncyCastle.Utilities;
|
|
|
|
namespace Org.BouncyCastle.Apache.Bzip2;
|
|
|
|
public class CBZip2InputStream : Stream
|
|
{
|
|
private const int START_BLOCK_STATE = 1;
|
|
|
|
private const int RAND_PART_A_STATE = 2;
|
|
|
|
private const int RAND_PART_B_STATE = 3;
|
|
|
|
private const int RAND_PART_C_STATE = 4;
|
|
|
|
private const int NO_RAND_PART_A_STATE = 5;
|
|
|
|
private const int NO_RAND_PART_B_STATE = 6;
|
|
|
|
private const int NO_RAND_PART_C_STATE = 7;
|
|
|
|
private int last;
|
|
|
|
private int origPtr;
|
|
|
|
private int blockSize100k;
|
|
|
|
private bool blockRandomised;
|
|
|
|
private int bsBuff;
|
|
|
|
private int bsLive;
|
|
|
|
private CRC mCrc = new CRC();
|
|
|
|
private bool[] inUse = new bool[256];
|
|
|
|
private int nInUse;
|
|
|
|
private char[] seqToUnseq = new char[256];
|
|
|
|
private char[] unseqToSeq = new char[256];
|
|
|
|
private char[] selector = new char[18002];
|
|
|
|
private char[] selectorMtf = new char[18002];
|
|
|
|
private int[] tt;
|
|
|
|
private char[] ll8;
|
|
|
|
private int[] unzftab = new int[256];
|
|
|
|
private int[][] limit = InitIntArray(6, 258);
|
|
|
|
private int[][] basev = InitIntArray(6, 258);
|
|
|
|
private int[][] perm = InitIntArray(6, 258);
|
|
|
|
private int[] minLens = new int[6];
|
|
|
|
private Stream bsStream;
|
|
|
|
private bool streamEnd = false;
|
|
|
|
private int currentChar = -1;
|
|
|
|
private int currentState = 1;
|
|
|
|
private int storedBlockCRC;
|
|
|
|
private int storedCombinedCRC;
|
|
|
|
private int computedBlockCRC;
|
|
|
|
private int computedCombinedCRC;
|
|
|
|
private int i2;
|
|
|
|
private int count;
|
|
|
|
private int chPrev;
|
|
|
|
private int ch2;
|
|
|
|
private int i;
|
|
|
|
private int tPos;
|
|
|
|
private int rNToGo = 0;
|
|
|
|
private int rTPos = 0;
|
|
|
|
private int j2;
|
|
|
|
private char z;
|
|
|
|
public override bool CanRead => true;
|
|
|
|
public override bool CanSeek => false;
|
|
|
|
public override bool CanWrite => false;
|
|
|
|
public override long Length => 0L;
|
|
|
|
public override long Position
|
|
{
|
|
get
|
|
{
|
|
return 0L;
|
|
}
|
|
set
|
|
{
|
|
}
|
|
}
|
|
|
|
private static void Cadvise()
|
|
{
|
|
}
|
|
|
|
private static void CompressedStreamEOF()
|
|
{
|
|
Cadvise();
|
|
}
|
|
|
|
private void MakeMaps()
|
|
{
|
|
nInUse = 0;
|
|
for (int i = 0; i < 256; i++)
|
|
{
|
|
if (inUse[i])
|
|
{
|
|
seqToUnseq[nInUse] = (char)i;
|
|
unseqToSeq[i] = (char)nInUse;
|
|
nInUse++;
|
|
}
|
|
}
|
|
}
|
|
|
|
public CBZip2InputStream(Stream zStream)
|
|
{
|
|
ll8 = null;
|
|
tt = null;
|
|
BsSetStream(zStream);
|
|
Initialize();
|
|
InitBlock();
|
|
SetupBlock();
|
|
}
|
|
|
|
internal static int[][] InitIntArray(int n1, int n2)
|
|
{
|
|
int[][] array = new int[n1][];
|
|
for (int i = 0; i < n1; i++)
|
|
{
|
|
array[i] = new int[n2];
|
|
}
|
|
return array;
|
|
}
|
|
|
|
internal static char[][] InitCharArray(int n1, int n2)
|
|
{
|
|
char[][] array = new char[n1][];
|
|
for (int i = 0; i < n1; i++)
|
|
{
|
|
array[i] = new char[n2];
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public override int ReadByte()
|
|
{
|
|
if (streamEnd)
|
|
{
|
|
return -1;
|
|
}
|
|
int result = currentChar;
|
|
switch (currentState)
|
|
{
|
|
case 3:
|
|
SetupRandPartB();
|
|
break;
|
|
case 4:
|
|
SetupRandPartC();
|
|
break;
|
|
case 6:
|
|
SetupNoRandPartB();
|
|
break;
|
|
case 7:
|
|
SetupNoRandPartC();
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void Initialize()
|
|
{
|
|
char c = BsGetUChar();
|
|
char c2 = BsGetUChar();
|
|
if (c != 'B' && c2 != 'Z')
|
|
{
|
|
throw new IOException("Not a BZIP2 marked stream");
|
|
}
|
|
c = BsGetUChar();
|
|
c2 = BsGetUChar();
|
|
if (c != 'h' || c2 < '1' || c2 > '9')
|
|
{
|
|
BsFinishedWithStream();
|
|
streamEnd = true;
|
|
}
|
|
else
|
|
{
|
|
SetDecompressStructureSizes(c2 - 48);
|
|
computedCombinedCRC = 0;
|
|
}
|
|
}
|
|
|
|
private void InitBlock()
|
|
{
|
|
char c = BsGetUChar();
|
|
char c2 = BsGetUChar();
|
|
char c3 = BsGetUChar();
|
|
char c4 = BsGetUChar();
|
|
char c5 = BsGetUChar();
|
|
char c6 = BsGetUChar();
|
|
if (c == '\u0017' && c2 == 'r' && c3 == 'E' && c4 == '8' && c5 == 'P' && c6 == '\u0090')
|
|
{
|
|
Complete();
|
|
return;
|
|
}
|
|
if (c != '1' || c2 != 'A' || c3 != 'Y' || c4 != '&' || c5 != 'S' || c6 != 'Y')
|
|
{
|
|
BadBlockHeader();
|
|
streamEnd = true;
|
|
return;
|
|
}
|
|
storedBlockCRC = BsGetInt32();
|
|
if (BsR(1) == 1)
|
|
{
|
|
blockRandomised = true;
|
|
}
|
|
else
|
|
{
|
|
blockRandomised = false;
|
|
}
|
|
GetAndMoveToFrontDecode();
|
|
mCrc.InitialiseCRC();
|
|
currentState = 1;
|
|
}
|
|
|
|
private void EndBlock()
|
|
{
|
|
computedBlockCRC = mCrc.GetFinalCRC();
|
|
if (storedBlockCRC != computedBlockCRC)
|
|
{
|
|
CrcError();
|
|
}
|
|
computedCombinedCRC = (computedCombinedCRC << 1) | (computedCombinedCRC >>> 31);
|
|
computedCombinedCRC ^= computedBlockCRC;
|
|
}
|
|
|
|
private void Complete()
|
|
{
|
|
storedCombinedCRC = BsGetInt32();
|
|
if (storedCombinedCRC != computedCombinedCRC)
|
|
{
|
|
CrcError();
|
|
}
|
|
BsFinishedWithStream();
|
|
streamEnd = true;
|
|
}
|
|
|
|
private static void BlockOverrun()
|
|
{
|
|
Cadvise();
|
|
}
|
|
|
|
private static void BadBlockHeader()
|
|
{
|
|
Cadvise();
|
|
}
|
|
|
|
private static void CrcError()
|
|
{
|
|
Cadvise();
|
|
}
|
|
|
|
private void BsFinishedWithStream()
|
|
{
|
|
try
|
|
{
|
|
if (bsStream != null)
|
|
{
|
|
Platform.Dispose(bsStream);
|
|
bsStream = null;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
private void BsSetStream(Stream f)
|
|
{
|
|
bsStream = f;
|
|
bsLive = 0;
|
|
bsBuff = 0;
|
|
}
|
|
|
|
private int BsR(int n)
|
|
{
|
|
while (bsLive < n)
|
|
{
|
|
char c = '\0';
|
|
try
|
|
{
|
|
c = (char)bsStream.ReadByte();
|
|
}
|
|
catch (IOException)
|
|
{
|
|
CompressedStreamEOF();
|
|
}
|
|
if (c == '\uffff')
|
|
{
|
|
CompressedStreamEOF();
|
|
}
|
|
int num = c;
|
|
bsBuff = (bsBuff << 8) | (num & 0xFF);
|
|
bsLive += 8;
|
|
}
|
|
int result = (bsBuff >> bsLive - n) & ((1 << n) - 1);
|
|
bsLive -= n;
|
|
return result;
|
|
}
|
|
|
|
private char BsGetUChar()
|
|
{
|
|
return (char)BsR(8);
|
|
}
|
|
|
|
private int BsGetint()
|
|
{
|
|
int num = 0;
|
|
num = (num << 8) | BsR(8);
|
|
num = (num << 8) | BsR(8);
|
|
num = (num << 8) | BsR(8);
|
|
return (num << 8) | BsR(8);
|
|
}
|
|
|
|
private int BsGetIntVS(int numBits)
|
|
{
|
|
return BsR(numBits);
|
|
}
|
|
|
|
private int BsGetInt32()
|
|
{
|
|
return BsGetint();
|
|
}
|
|
|
|
private void HbCreateDecodeTables(int[] limit, int[] basev, int[] perm, char[] length, int minLen, int maxLen, int alphaSize)
|
|
{
|
|
int num = 0;
|
|
for (int i = minLen; i <= maxLen; i++)
|
|
{
|
|
for (int j = 0; j < alphaSize; j++)
|
|
{
|
|
if (length[j] == i)
|
|
{
|
|
perm[num] = j;
|
|
num++;
|
|
}
|
|
}
|
|
}
|
|
for (int i = 0; i < 23; i++)
|
|
{
|
|
basev[i] = 0;
|
|
}
|
|
for (int i = 0; i < alphaSize; i++)
|
|
{
|
|
int[] array2;
|
|
int[] array = (array2 = basev);
|
|
int num2 = length[i] + 1;
|
|
nint num3 = num2;
|
|
array[num2] = array2[num3] + 1;
|
|
}
|
|
for (int i = 1; i < 23; i++)
|
|
{
|
|
int[] array2;
|
|
int[] array3 = (array2 = basev);
|
|
int num4 = i;
|
|
nint num3 = num4;
|
|
array3[num4] = array2[num3] + basev[i - 1];
|
|
}
|
|
for (int i = 0; i < 23; i++)
|
|
{
|
|
limit[i] = 0;
|
|
}
|
|
int num5 = 0;
|
|
for (int i = minLen; i <= maxLen; i++)
|
|
{
|
|
num5 += basev[i + 1] - basev[i];
|
|
limit[i] = num5 - 1;
|
|
num5 <<= 1;
|
|
}
|
|
for (int i = minLen + 1; i <= maxLen; i++)
|
|
{
|
|
basev[i] = (limit[i - 1] + 1 << 1) - basev[i];
|
|
}
|
|
}
|
|
|
|
private void RecvDecodingTables()
|
|
{
|
|
char[][] array = InitCharArray(6, 258);
|
|
bool[] array2 = new bool[16];
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
if (BsR(1) == 1)
|
|
{
|
|
array2[i] = true;
|
|
}
|
|
else
|
|
{
|
|
array2[i] = false;
|
|
}
|
|
}
|
|
for (int i = 0; i < 256; i++)
|
|
{
|
|
inUse[i] = false;
|
|
}
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
if (!array2[i])
|
|
{
|
|
continue;
|
|
}
|
|
for (int j = 0; j < 16; j++)
|
|
{
|
|
if (BsR(1) == 1)
|
|
{
|
|
inUse[i * 16 + j] = true;
|
|
}
|
|
}
|
|
}
|
|
MakeMaps();
|
|
int num = nInUse + 2;
|
|
int num2 = BsR(3);
|
|
int num3 = BsR(15);
|
|
for (int i = 0; i < num3; i++)
|
|
{
|
|
int j = 0;
|
|
while (BsR(1) == 1)
|
|
{
|
|
j++;
|
|
}
|
|
selectorMtf[i] = (char)j;
|
|
}
|
|
char[] array3 = new char[6];
|
|
for (char c = '\0'; c < num2; c = (char)(c + 1))
|
|
{
|
|
array3[(uint)c] = c;
|
|
}
|
|
for (int i = 0; i < num3; i++)
|
|
{
|
|
char c = selectorMtf[i];
|
|
char c2 = array3[(uint)c];
|
|
while (c > '\0')
|
|
{
|
|
array3[(uint)c] = array3[c - 1];
|
|
c = (char)(c - 1);
|
|
}
|
|
array3[0] = c2;
|
|
selector[i] = c2;
|
|
}
|
|
for (int k = 0; k < num2; k++)
|
|
{
|
|
int num4 = BsR(5);
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
while (BsR(1) == 1)
|
|
{
|
|
num4 = ((BsR(1) != 0) ? (num4 - 1) : (num4 + 1));
|
|
}
|
|
array[k][i] = (char)num4;
|
|
}
|
|
}
|
|
for (int k = 0; k < num2; k++)
|
|
{
|
|
int num5 = 32;
|
|
int num6 = 0;
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
if (array[k][i] > num6)
|
|
{
|
|
num6 = array[k][i];
|
|
}
|
|
if (array[k][i] < num5)
|
|
{
|
|
num5 = array[k][i];
|
|
}
|
|
}
|
|
HbCreateDecodeTables(limit[k], basev[k], perm[k], array[k], num5, num6, num);
|
|
minLens[k] = num5;
|
|
}
|
|
}
|
|
|
|
private void GetAndMoveToFrontDecode()
|
|
{
|
|
char[] array = new char[256];
|
|
int num = 100000 * blockSize100k;
|
|
origPtr = BsGetIntVS(24);
|
|
RecvDecodingTables();
|
|
int num2 = nInUse + 1;
|
|
int num3 = -1;
|
|
int num4 = 0;
|
|
for (int i = 0; i <= 255; i++)
|
|
{
|
|
unzftab[i] = 0;
|
|
}
|
|
for (int i = 0; i <= 255; i++)
|
|
{
|
|
array[i] = (char)i;
|
|
}
|
|
last = -1;
|
|
if (num4 == 0)
|
|
{
|
|
num3++;
|
|
num4 = 50;
|
|
}
|
|
num4--;
|
|
int num5 = selector[num3];
|
|
int num6 = minLens[num5];
|
|
int num7 = BsR(num6);
|
|
while (num7 > limit[num5][num6])
|
|
{
|
|
num6++;
|
|
while (bsLive < 1)
|
|
{
|
|
char c = '\0';
|
|
try
|
|
{
|
|
c = (char)bsStream.ReadByte();
|
|
}
|
|
catch (IOException)
|
|
{
|
|
CompressedStreamEOF();
|
|
}
|
|
if (c == '\uffff')
|
|
{
|
|
CompressedStreamEOF();
|
|
}
|
|
int num8 = c;
|
|
bsBuff = (bsBuff << 8) | (num8 & 0xFF);
|
|
bsLive += 8;
|
|
}
|
|
int num9 = (bsBuff >> bsLive - 1) & 1;
|
|
bsLive--;
|
|
num7 = (num7 << 1) | num9;
|
|
}
|
|
int num10 = perm[num5][num7 - basev[num5][num6]];
|
|
while (num10 != num2)
|
|
{
|
|
int[] array3;
|
|
nint num18;
|
|
if (num10 == 0 || num10 == 1)
|
|
{
|
|
int num11 = -1;
|
|
int num12 = 1;
|
|
do
|
|
{
|
|
switch (num10)
|
|
{
|
|
case 0:
|
|
num11 += num12;
|
|
break;
|
|
case 1:
|
|
num11 += 2 * num12;
|
|
break;
|
|
}
|
|
num12 *= 2;
|
|
if (num4 == 0)
|
|
{
|
|
num3++;
|
|
num4 = 50;
|
|
}
|
|
num4--;
|
|
int num13 = selector[num3];
|
|
int num14 = minLens[num13];
|
|
int num15 = BsR(num14);
|
|
while (num15 > limit[num13][num14])
|
|
{
|
|
num14++;
|
|
while (bsLive < 1)
|
|
{
|
|
char c2 = '\0';
|
|
try
|
|
{
|
|
c2 = (char)bsStream.ReadByte();
|
|
}
|
|
catch (IOException)
|
|
{
|
|
CompressedStreamEOF();
|
|
}
|
|
if (c2 == '\uffff')
|
|
{
|
|
CompressedStreamEOF();
|
|
}
|
|
int num16 = c2;
|
|
bsBuff = (bsBuff << 8) | (num16 & 0xFF);
|
|
bsLive += 8;
|
|
}
|
|
int num17 = (bsBuff >> bsLive - 1) & 1;
|
|
bsLive--;
|
|
num15 = (num15 << 1) | num17;
|
|
}
|
|
num10 = perm[num13][num15 - basev[num13][num14]];
|
|
}
|
|
while (num10 == 0 || num10 == 1);
|
|
num11++;
|
|
char c3 = seqToUnseq[(uint)array[0]];
|
|
int[] array2 = (array3 = unzftab);
|
|
num18 = (int)c3;
|
|
array2[(uint)c3] = array3[num18] + num11;
|
|
while (num11 > 0)
|
|
{
|
|
last++;
|
|
ll8[last] = c3;
|
|
num11--;
|
|
}
|
|
if (last >= num)
|
|
{
|
|
BlockOverrun();
|
|
}
|
|
continue;
|
|
}
|
|
last++;
|
|
if (last >= num)
|
|
{
|
|
BlockOverrun();
|
|
}
|
|
char c4 = array[num10 - 1];
|
|
int[] array4 = (array3 = unzftab);
|
|
char num19 = seqToUnseq[(uint)c4];
|
|
num18 = (int)num19;
|
|
array4[(uint)num19] = array3[num18] + 1;
|
|
ll8[last] = seqToUnseq[(uint)c4];
|
|
int num20;
|
|
for (num20 = num10 - 1; num20 > 3; num20 -= 4)
|
|
{
|
|
array[num20] = array[num20 - 1];
|
|
array[num20 - 1] = array[num20 - 2];
|
|
array[num20 - 2] = array[num20 - 3];
|
|
array[num20 - 3] = array[num20 - 4];
|
|
}
|
|
while (num20 > 0)
|
|
{
|
|
array[num20] = array[num20 - 1];
|
|
num20--;
|
|
}
|
|
array[0] = c4;
|
|
if (num4 == 0)
|
|
{
|
|
num3++;
|
|
num4 = 50;
|
|
}
|
|
num4--;
|
|
int num21 = selector[num3];
|
|
int num22 = minLens[num21];
|
|
int num23 = BsR(num22);
|
|
while (num23 > limit[num21][num22])
|
|
{
|
|
num22++;
|
|
while (bsLive < 1)
|
|
{
|
|
char c5 = '\0';
|
|
try
|
|
{
|
|
c5 = (char)bsStream.ReadByte();
|
|
}
|
|
catch (IOException)
|
|
{
|
|
CompressedStreamEOF();
|
|
}
|
|
int num24 = c5;
|
|
bsBuff = (bsBuff << 8) | (num24 & 0xFF);
|
|
bsLive += 8;
|
|
}
|
|
int num25 = (bsBuff >> bsLive - 1) & 1;
|
|
bsLive--;
|
|
num23 = (num23 << 1) | num25;
|
|
}
|
|
num10 = perm[num21][num23 - basev[num21][num22]];
|
|
}
|
|
}
|
|
|
|
private void SetupBlock()
|
|
{
|
|
int[] array = new int[257];
|
|
array[0] = 0;
|
|
for (i = 1; i <= 256; i++)
|
|
{
|
|
array[i] = unzftab[i - 1];
|
|
}
|
|
for (i = 1; i <= 256; i++)
|
|
{
|
|
int[] array3;
|
|
int[] array2 = (array3 = array);
|
|
int num = i;
|
|
nint num2 = num;
|
|
array2[num] = array3[num2] + array[i - 1];
|
|
}
|
|
for (i = 0; i <= last; i++)
|
|
{
|
|
char c = ll8[i];
|
|
tt[array[(uint)c]] = i;
|
|
int[] array3;
|
|
int[] array4 = (array3 = array);
|
|
nint num2 = (int)c;
|
|
array4[(uint)c] = array3[num2] + 1;
|
|
}
|
|
array = null;
|
|
tPos = tt[origPtr];
|
|
count = 0;
|
|
i2 = 0;
|
|
ch2 = 256;
|
|
if (blockRandomised)
|
|
{
|
|
rNToGo = 0;
|
|
rTPos = 0;
|
|
SetupRandPartA();
|
|
}
|
|
else
|
|
{
|
|
SetupNoRandPartA();
|
|
}
|
|
}
|
|
|
|
private void SetupRandPartA()
|
|
{
|
|
if (i2 <= last)
|
|
{
|
|
chPrev = ch2;
|
|
ch2 = ll8[tPos];
|
|
tPos = tt[tPos];
|
|
if (rNToGo == 0)
|
|
{
|
|
rNToGo = BZip2Constants.rNums[rTPos];
|
|
rTPos++;
|
|
if (rTPos == 512)
|
|
{
|
|
rTPos = 0;
|
|
}
|
|
}
|
|
rNToGo--;
|
|
ch2 ^= ((rNToGo == 1) ? 1 : 0);
|
|
i2++;
|
|
currentChar = ch2;
|
|
currentState = 3;
|
|
mCrc.UpdateCRC(ch2);
|
|
}
|
|
else
|
|
{
|
|
EndBlock();
|
|
InitBlock();
|
|
SetupBlock();
|
|
}
|
|
}
|
|
|
|
private void SetupNoRandPartA()
|
|
{
|
|
if (i2 <= last)
|
|
{
|
|
chPrev = ch2;
|
|
ch2 = ll8[tPos];
|
|
tPos = tt[tPos];
|
|
i2++;
|
|
currentChar = ch2;
|
|
currentState = 6;
|
|
mCrc.UpdateCRC(ch2);
|
|
}
|
|
else
|
|
{
|
|
EndBlock();
|
|
InitBlock();
|
|
SetupBlock();
|
|
}
|
|
}
|
|
|
|
private void SetupRandPartB()
|
|
{
|
|
if (ch2 != chPrev)
|
|
{
|
|
currentState = 2;
|
|
count = 1;
|
|
SetupRandPartA();
|
|
return;
|
|
}
|
|
count++;
|
|
if (count >= 4)
|
|
{
|
|
z = ll8[tPos];
|
|
tPos = tt[tPos];
|
|
if (rNToGo == 0)
|
|
{
|
|
rNToGo = BZip2Constants.rNums[rTPos];
|
|
rTPos++;
|
|
if (rTPos == 512)
|
|
{
|
|
rTPos = 0;
|
|
}
|
|
}
|
|
rNToGo--;
|
|
z ^= ((rNToGo == 1) ? '\u0001' : '\0');
|
|
j2 = 0;
|
|
currentState = 4;
|
|
SetupRandPartC();
|
|
}
|
|
else
|
|
{
|
|
currentState = 2;
|
|
SetupRandPartA();
|
|
}
|
|
}
|
|
|
|
private void SetupRandPartC()
|
|
{
|
|
if (j2 < z)
|
|
{
|
|
currentChar = ch2;
|
|
mCrc.UpdateCRC(ch2);
|
|
j2++;
|
|
}
|
|
else
|
|
{
|
|
currentState = 2;
|
|
i2++;
|
|
count = 0;
|
|
SetupRandPartA();
|
|
}
|
|
}
|
|
|
|
private void SetupNoRandPartB()
|
|
{
|
|
if (ch2 != chPrev)
|
|
{
|
|
currentState = 5;
|
|
count = 1;
|
|
SetupNoRandPartA();
|
|
return;
|
|
}
|
|
count++;
|
|
if (count >= 4)
|
|
{
|
|
z = ll8[tPos];
|
|
tPos = tt[tPos];
|
|
currentState = 7;
|
|
j2 = 0;
|
|
SetupNoRandPartC();
|
|
}
|
|
else
|
|
{
|
|
currentState = 5;
|
|
SetupNoRandPartA();
|
|
}
|
|
}
|
|
|
|
private void SetupNoRandPartC()
|
|
{
|
|
if (j2 < z)
|
|
{
|
|
currentChar = ch2;
|
|
mCrc.UpdateCRC(ch2);
|
|
j2++;
|
|
}
|
|
else
|
|
{
|
|
currentState = 5;
|
|
i2++;
|
|
count = 0;
|
|
SetupNoRandPartA();
|
|
}
|
|
}
|
|
|
|
private void SetDecompressStructureSizes(int newSize100k)
|
|
{
|
|
if (0 <= newSize100k && newSize100k <= 9 && 0 <= blockSize100k)
|
|
{
|
|
_ = blockSize100k;
|
|
_ = 9;
|
|
}
|
|
blockSize100k = newSize100k;
|
|
if (newSize100k != 0)
|
|
{
|
|
int num = 100000 * newSize100k;
|
|
ll8 = new char[num];
|
|
tt = new int[num];
|
|
}
|
|
}
|
|
|
|
public override void Flush()
|
|
{
|
|
}
|
|
|
|
public override int Read(byte[] buffer, int offset, int count)
|
|
{
|
|
int num = -1;
|
|
int i;
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
num = ReadByte();
|
|
if (num == -1)
|
|
{
|
|
break;
|
|
}
|
|
buffer[i + offset] = (byte)num;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public override long Seek(long offset, SeekOrigin origin)
|
|
{
|
|
return 0L;
|
|
}
|
|
|
|
public override void SetLength(long value)
|
|
{
|
|
}
|
|
|
|
public override void Write(byte[] buffer, int offset, int count)
|
|
{
|
|
}
|
|
}
|