public int End(CompressionStream stream)
{
if (this.blocks != null)
{
this.blocks.Free(stream);
}
this.blocks = (InflaterBlocks)null;
return(0);
}
public int Initialize(CompressionStream stream, int windowSize)
{
stream.ErrorMessage = (string)null;
this.blocks = (InflaterBlocks)null;
this.nowrap = 0;
if (windowSize < 0)
{
windowSize = -windowSize;
this.nowrap = 1;
}
if (windowSize < 8 || windowSize > 15)
{
this.End(stream);
return(-2);
}
this.wbits = windowSize;
Inflater inflater = this.nowrap != 0 ? (Inflater)null : this;
this.blocks = new InflaterBlocks(stream, (object)inflater, 1 << windowSize);
this.Reset(stream);
return(0);
}
internal int Process(InflaterBlocks s, CompressionStream z, int r)
{
int inputIndex = z.InputIndex;
int inputCount = z.InputCount;
int number = s.BitBuffer;
int bitBufferLength = s.BitBufferLength;
int num1 = s.WindowWrite;
int num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1;
while (true)
{
switch (this.mode)
{
case 0:
if (num2 >= 258 && inputCount >= 10)
{
s.BitBuffer = number;
s.BitBufferLength = bitBufferLength;
z.InputCount = inputCount;
z.InputTotal += (long)(inputIndex - z.InputIndex);
z.InputIndex = inputIndex;
s.WindowWrite = num1;
r = this.InflateFast((int)this.lbits, (int)this.dbits, this.ltree, this.ltreeIndex, this.dtree, this.dtreeIndex, s, z);
inputIndex = z.InputIndex;
inputCount = z.InputCount;
number = s.BitBuffer;
bitBufferLength = s.BitBufferLength;
num1 = s.WindowWrite;
num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1;
int num3;
switch (r)
{
case 0:
goto label_6;
case 1:
num3 = 7;
break;
default:
num3 = 9;
break;
}
this.mode = num3;
break;
}
label_6:
this.need = (int)this.lbits;
this.tree = this.ltree;
this.treeIndex = this.ltreeIndex;
this.mode = 1;
goto case 1;
case 1:
int need1;
for (need1 = this.need; bitBufferLength < need1; bitBufferLength += 8)
{
if (inputCount != 0)
{
r = 0;
--inputCount;
number |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << bitBufferLength;
}
else
{
s.BitBuffer = number;
s.BitBufferLength = bitBufferLength;
z.InputCount = inputCount;
z.InputTotal += (long)(inputIndex - z.InputIndex);
z.InputIndex = inputIndex;
s.WindowWrite = num1;
return(s.InflateFlush(z, r));
}
}
int index1 = (this.treeIndex + (number & InflaterCodes.inflateMask[need1])) * 3;
number = Utils.ShiftRight(number, this.tree[index1 + 1]);
bitBufferLength -= this.tree[index1 + 1];
int num4 = this.tree[index1];
if (num4 == 0)
{
this.lit = this.tree[index1 + 2];
this.mode = 6;
break;
}
if ((num4 & 16) != 0)
{
this.getBits = num4 & 15;
this.len = this.tree[index1 + 2];
this.mode = 2;
break;
}
if ((num4 & 64) == 0)
{
this.need = num4;
this.treeIndex = index1 / 3 + this.tree[index1 + 2];
break;
}
if ((num4 & 32) != 0)
{
this.mode = 7;
break;
}
goto label_20;
case 2:
int getBits1;
for (getBits1 = this.getBits; bitBufferLength < getBits1; bitBufferLength += 8)
{
if (inputCount != 0)
{
r = 0;
--inputCount;
number |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << bitBufferLength;
}
else
{
s.BitBuffer = number;
s.BitBufferLength = bitBufferLength;
z.InputCount = inputCount;
z.InputTotal += (long)(inputIndex - z.InputIndex);
z.InputIndex = inputIndex;
s.WindowWrite = num1;
return(s.InflateFlush(z, r));
}
}
this.len += number & InflaterCodes.inflateMask[getBits1];
number >>= getBits1;
bitBufferLength -= getBits1;
this.need = (int)this.dbits;
this.tree = this.dtree;
this.treeIndex = this.dtreeIndex;
this.mode = 3;
goto case 3;
case 3:
int need2;
for (need2 = this.need; bitBufferLength < need2; bitBufferLength += 8)
{
if (inputCount != 0)
{
r = 0;
--inputCount;
number |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << bitBufferLength;
}
else
{
s.BitBuffer = number;
s.BitBufferLength = bitBufferLength;
z.InputCount = inputCount;
z.InputTotal += (long)(inputIndex - z.InputIndex);
z.InputIndex = inputIndex;
s.WindowWrite = num1;
return(s.InflateFlush(z, r));
}
}
int index2 = (this.treeIndex + (number & InflaterCodes.inflateMask[need2])) * 3;
number >>= this.tree[index2 + 1];
bitBufferLength -= this.tree[index2 + 1];
int num5 = this.tree[index2];
if ((num5 & 16) != 0)
{
this.getBits = num5 & 15;
this.dist = this.tree[index2 + 2];
this.mode = 4;
break;
}
if ((num5 & 64) == 0)
{
this.need = num5;
this.treeIndex = index2 / 3 + this.tree[index2 + 2];
break;
}
goto label_36;
case 4:
int getBits2;
for (getBits2 = this.getBits; bitBufferLength < getBits2; bitBufferLength += 8)
{
if (inputCount != 0)
{
r = 0;
--inputCount;
number |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << bitBufferLength;
}
else
{
s.BitBuffer = number;
s.BitBufferLength = bitBufferLength;
z.InputCount = inputCount;
z.InputTotal += (long)(inputIndex - z.InputIndex);
z.InputIndex = inputIndex;
s.WindowWrite = num1;
return(s.InflateFlush(z, r));
}
}
this.dist += number & InflaterCodes.inflateMask[getBits2];
number >>= getBits2;
bitBufferLength -= getBits2;
this.mode = 5;
goto case 5;
case 5:
int num6 = num1 - this.dist;
while (num6 < 0)
{
num6 += s.WindowEnd;
}
for (; this.len != 0; --this.len)
{
if (num2 == 0)
{
if (num1 == s.WindowEnd && s.WindowRead != 0)
{
num1 = 0;
num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1;
}
if (num2 == 0)
{
s.WindowWrite = num1;
r = s.InflateFlush(z, r);
num1 = s.WindowWrite;
num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1;
if (num1 == s.WindowEnd && s.WindowRead != 0)
{
num1 = 0;
num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1;
}
if (num2 == 0)
{
s.BitBuffer = number;
s.BitBufferLength = bitBufferLength;
z.InputCount = inputCount;
z.InputTotal += (long)(inputIndex - z.InputIndex);
z.InputIndex = inputIndex;
s.WindowWrite = num1;
return(s.InflateFlush(z, r));
}
}
}
s.Window[num1++] = s.Window[num6++];
--num2;
if (num6 == s.WindowEnd)
{
num6 = 0;
}
}
this.mode = 0;
break;
case 6:
if (num2 == 0)
{
if (num1 == s.WindowEnd && s.WindowRead != 0)
{
num1 = 0;
num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1;
}
if (num2 == 0)
{
s.WindowWrite = num1;
r = s.InflateFlush(z, r);
num1 = s.WindowWrite;
num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1;
if (num1 == s.WindowEnd && s.WindowRead != 0)
{
num1 = 0;
num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1;
}
if (num2 == 0)
{
goto label_67;
}
}
}
r = 0;
s.Window[num1++] = (byte)this.lit;
--num2;
this.mode = 0;
break;
case 7:
goto label_70;
case 8:
goto label_75;
case 9:
goto label_76;
default:
goto label_77;
}
}
label_20:
this.mode = 9;
z.ErrorMessage = "invalid literal/length code";
r = -3;
s.BitBuffer = number;
s.BitBufferLength = bitBufferLength;
z.InputCount = inputCount;
z.InputTotal += (long)(inputIndex - z.InputIndex);
z.InputIndex = inputIndex;
s.WindowWrite = num1;
return(s.InflateFlush(z, r));
label_36:
this.mode = 9;
z.ErrorMessage = "invalid distance code";
r = -3;
s.BitBuffer = number;
s.BitBufferLength = bitBufferLength;
z.InputCount = inputCount;
z.InputTotal += (long)(inputIndex - z.InputIndex);
z.InputIndex = inputIndex;
s.WindowWrite = num1;
return(s.InflateFlush(z, r));
label_67:
s.BitBuffer = number;
s.BitBufferLength = bitBufferLength;
z.InputCount = inputCount;
z.InputTotal += (long)(inputIndex - z.InputIndex);
z.InputIndex = inputIndex;
s.WindowWrite = num1;
return(s.InflateFlush(z, r));
label_70:
if (bitBufferLength > 7)
{
bitBufferLength -= 8;
++inputCount;
--inputIndex;
}
s.WindowWrite = num1;
r = s.InflateFlush(z, r);
num1 = s.WindowWrite;
int num7 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1;
if (s.WindowRead != s.WindowWrite)
{
s.BitBuffer = number;
s.BitBufferLength = bitBufferLength;
z.InputCount = inputCount;
z.InputTotal += (long)(inputIndex - z.InputIndex);
z.InputIndex = inputIndex;
s.WindowWrite = num1;
return(s.InflateFlush(z, r));
}
this.mode = 8;
label_75:
r = 1;
s.BitBuffer = number;
s.BitBufferLength = bitBufferLength;
z.InputCount = inputCount;
z.InputTotal += (long)(inputIndex - z.InputIndex);
z.InputIndex = inputIndex;
s.WindowWrite = num1;
return(s.InflateFlush(z, r));
label_76:
r = -3;
s.BitBuffer = number;
s.BitBufferLength = bitBufferLength;
z.InputCount = inputCount;
z.InputTotal += (long)(inputIndex - z.InputIndex);
z.InputIndex = inputIndex;
s.WindowWrite = num1;
return(s.InflateFlush(z, r));
label_77:
r = -2;
s.BitBuffer = number;
s.BitBufferLength = bitBufferLength;
z.InputCount = inputCount;
z.InputTotal += (long)(inputIndex - z.InputIndex);
z.InputIndex = inputIndex;
s.WindowWrite = num1;
return(s.InflateFlush(z, r));
}
internal int InflateFast(
int bl,
int bd,
int[] tl,
int tlIndex,
int[] td,
int tdIndex,
InflaterBlocks s,
CompressionStream z)
{
int inputIndex = z.InputIndex;
int inputCount = z.InputCount;
int num1 = s.BitBuffer;
int num2 = s.BitBufferLength;
int destinationIndex = s.WindowWrite;
int num3 = destinationIndex < s.WindowRead ? s.WindowRead - destinationIndex - 1 : s.WindowEnd - destinationIndex;
int num4 = InflaterCodes.inflateMask[bl];
int num5 = InflaterCodes.inflateMask[bd];
do
{
for (; num2 < 20; num2 += 8)
{
--inputCount;
num1 |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << num2;
}
int num6 = num1 & num4;
int[] numArray1 = tl;
int num7 = tlIndex;
int index1 = (num7 + num6) * 3;
int index2;
if ((index2 = numArray1[index1]) == 0)
{
num1 >>= numArray1[index1 + 1];
num2 -= numArray1[index1 + 1];
s.Window[destinationIndex++] = (byte)numArray1[index1 + 2];
--num3;
}
else
{
bool flag;
while (true)
{
num1 >>= numArray1[index1 + 1];
num2 -= numArray1[index1 + 1];
if ((index2 & 16) == 0)
{
if ((index2 & 64) == 0)
{
num6 = num6 + numArray1[index1 + 2] + (num1 & InflaterCodes.inflateMask[index2]);
index1 = (num7 + num6) * 3;
if ((index2 = numArray1[index1]) != 0)
{
flag = true;
}
else
{
goto label_34;
}
}
else
{
goto label_35;
}
}
else
{
break;
}
}
int index3 = index2 & 15;
int length1 = numArray1[index1 + 2] + (num1 & InflaterCodes.inflateMask[index3]);
int num8 = num1 >> index3;
int num9;
for (num9 = num2 - index3; num9 < 15; num9 += 8)
{
--inputCount;
num8 |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << num9;
}
int num10 = num8 & num5;
int[] numArray2 = td;
int num11 = tdIndex;
int index4 = (num11 + num10) * 3;
int index5 = numArray2[index4];
while (true)
{
num8 >>= numArray2[index4 + 1];
num9 -= numArray2[index4 + 1];
if ((index5 & 16) == 0)
{
if ((index5 & 64) == 0)
{
num10 = num10 + numArray2[index4 + 2] + (num8 & InflaterCodes.inflateMask[index5]);
index4 = (num11 + num10) * 3;
index5 = numArray2[index4];
flag = true;
}
else
{
goto label_31;
}
}
else
{
break;
}
}
int index6;
for (index6 = index5 & 15; num9 < index6; num9 += 8)
{
--inputCount;
num8 |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << num9;
}
int num12 = numArray2[index4 + 2] + (num8 & InflaterCodes.inflateMask[index6]);
num1 = num8 >> index6;
num2 = num9 - index6;
num3 -= length1;
int sourceIndex1;
int num13;
if (destinationIndex >= num12)
{
int sourceIndex2 = destinationIndex - num12;
if (destinationIndex - sourceIndex2 > 0 && 2 > destinationIndex - sourceIndex2)
{
byte[] window1 = s.Window;
int index7 = destinationIndex;
int num14 = index7 + 1;
byte[] window2 = s.Window;
int index8 = sourceIndex2;
int num15 = index8 + 1;
int num16 = (int)window2[index8];
window1[index7] = (byte)num16;
byte[] window3 = s.Window;
int index9 = num14;
destinationIndex = index9 + 1;
byte[] window4 = s.Window;
int index10 = num15;
sourceIndex1 = index10 + 1;
int num17 = (int)window4[index10];
window3[index9] = (byte)num17;
length1 -= 2;
}
else
{
Array.Copy((Array)s.Window, sourceIndex2, (Array)s.Window, destinationIndex, 2);
destinationIndex += 2;
sourceIndex1 = sourceIndex2 + 2;
length1 -= 2;
}
}
else
{
sourceIndex1 = destinationIndex - num12;
do
{
sourceIndex1 += s.WindowEnd;
}while (sourceIndex1 < 0);
int length2 = s.WindowEnd - sourceIndex1;
if (length1 > length2)
{
length1 -= length2;
if (destinationIndex - sourceIndex1 > 0 && length2 > destinationIndex - sourceIndex1)
{
do
{
s.Window[destinationIndex++] = s.Window[sourceIndex1++];
}while (--length2 != 0);
}
else
{
Array.Copy((Array)s.Window, sourceIndex1, (Array)s.Window, destinationIndex, length2);
destinationIndex += length2;
num13 = sourceIndex1 + length2;
}
sourceIndex1 = 0;
}
}
if (destinationIndex - sourceIndex1 > 0 && length1 > destinationIndex - sourceIndex1)
{
do
{
s.Window[destinationIndex++] = s.Window[sourceIndex1++];
}while (--length1 != 0);
goto label_39;
}
else
{
Array.Copy((Array)s.Window, sourceIndex1, (Array)s.Window, destinationIndex, length1);
destinationIndex += length1;
num13 = sourceIndex1 + length1;
goto label_39;
}
label_31:
z.ErrorMessage = "invalid distance code";
int num18 = z.InputCount - inputCount;
int num19 = num9 >> 3 < num18 ? num9 >> 3 : num18;
int num20 = inputCount + num19;
int num21 = inputIndex - num19;
int num22 = num9 - (num19 << 3);
s.BitBuffer = num8;
s.BitBufferLength = num22;
z.InputCount = num20;
z.InputTotal += (long)(num21 - z.InputIndex);
z.InputIndex = num21;
s.WindowWrite = destinationIndex;
return(-3);
label_34:
num1 >>= numArray1[index1 + 1];
num2 -= numArray1[index1 + 1];
s.Window[destinationIndex++] = (byte)numArray1[index1 + 2];
--num3;
goto label_39;
label_35:
if ((index2 & 32) != 0)
{
int num14 = z.InputCount - inputCount;
int num15 = num2 >> 3 < num14 ? num2 >> 3 : num14;
int num16 = inputCount + num15;
int num17 = inputIndex - num15;
int num23 = num2 - (num15 << 3);
s.BitBuffer = num1;
s.BitBufferLength = num23;
z.InputCount = num16;
z.InputTotal += (long)(num17 - z.InputIndex);
z.InputIndex = num17;
s.WindowWrite = destinationIndex;
return(1);
}
z.ErrorMessage = "invalid literal/length code";
int num24 = z.InputCount - inputCount;
int num25 = num2 >> 3 < num24 ? num2 >> 3 : num24;
int num26 = inputCount + num25;
int num27 = inputIndex - num25;
int num28 = num2 - (num25 << 3);
s.BitBuffer = num1;
s.BitBufferLength = num28;
z.InputCount = num26;
z.InputTotal += (long)(num27 - z.InputIndex);
z.InputIndex = num27;
s.WindowWrite = destinationIndex;
return(-3);
label_39 :;
}
}while (num3 >= 258 && inputCount >= 10);
int num29 = z.InputCount - inputCount;
int num30 = num2 >> 3 < num29 ? num2 >> 3 : num29;
int num31 = inputCount + num30;
int num32 = inputIndex - num30;
int num33 = num2 - (num30 << 3);
s.BitBuffer = num1;
s.BitBufferLength = num33;
z.InputCount = num31;
z.InputTotal += (long)(num32 - z.InputIndex);
z.InputIndex = num32;
s.WindowWrite = destinationIndex;
return(0);
}
