/// <summary>
/// Map from a distance to a distance code.
/// </summary>
/// <remarks>
/// No side effects. _dist_code[256] and _dist_code[257] are never used.
/// </remarks>
internal static int DistanceCode(int dist)
{
return(dist < 256
? _dist_code[dist]
: _dist_code[256 + SharedUtils.URShift(dist, 7)]);
}
internal int Process(InflateBlocks blocks, int r)
{
int num;
int num10;
bool flag;
int number = 0;
int bitk = 0;
int nextIn = 0;
ZlibCodec z = blocks._codec;
nextIn = z.NextIn;
int availableBytesIn = z.AvailableBytesIn;
number = blocks.bitb;
bitk = blocks.bitk;
int write = blocks.write;
int num9 = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
goto Label_0C3A;
Label_0196:
this.need = this.lbits;
this.tree = this.ltree;
this.tree_index = this.ltree_index;
this.mode = 1;
Label_01C3:
num = this.need;
while (bitk < num)
{
if (availableBytesIn != 0)
{
r = 0;
}
else
{
blocks.bitb = number;
blocks.bitk = bitk;
z.AvailableBytesIn = availableBytesIn;
z.TotalBytesIn += nextIn - z.NextIn;
z.NextIn = nextIn;
blocks.write = write;
return(blocks.Flush(r));
}
availableBytesIn--;
number |= (z.InputBuffer[nextIn++] & 0xff) << bitk;
bitk += 8;
}
int index = (this.tree_index + (number & inflate_mask[num])) * 3;
number = SharedUtils.URShift(number, this.tree[index + 1]);
bitk -= this.tree[index + 1];
int num3 = this.tree[index];
if (num3 == 0)
{
this.lit = this.tree[index + 2];
this.mode = 6;
goto Label_0C3A;
}
if ((num3 & 0x10) != 0)
{
this.get_Renamed = num3 & 15;
this.len = this.tree[index + 2];
this.mode = 2;
goto Label_0C3A;
}
if ((num3 & 0x40) == 0)
{
this.need = num3;
this.tree_index = (index / 3) + this.tree[index + 2];
goto Label_0C3A;
}
if ((num3 & 0x20) != 0)
{
this.mode = 7;
goto Label_0C3A;
}
this.mode = 9;
z.Message = "invalid literal/length code";
r = -3;
blocks.bitb = number;
blocks.bitk = bitk;
z.AvailableBytesIn = availableBytesIn;
z.TotalBytesIn += nextIn - z.NextIn;
z.NextIn = nextIn;
blocks.write = write;
return(blocks.Flush(r));
Label_04AE:
num = this.need;
while (bitk < num)
{
if (availableBytesIn != 0)
{
r = 0;
}
else
{
blocks.bitb = number;
blocks.bitk = bitk;
z.AvailableBytesIn = availableBytesIn;
z.TotalBytesIn += nextIn - z.NextIn;
z.NextIn = nextIn;
blocks.write = write;
return(blocks.Flush(r));
}
availableBytesIn--;
number |= (z.InputBuffer[nextIn++] & 0xff) << bitk;
bitk += 8;
}
index = (this.tree_index + (number & inflate_mask[num])) * 3;
number = number >> this.tree[index + 1];
bitk -= this.tree[index + 1];
num3 = this.tree[index];
if ((num3 & 0x10) != 0)
{
this.get_Renamed = num3 & 15;
this.dist = this.tree[index + 2];
this.mode = 4;
goto Label_0C3A;
}
if ((num3 & 0x40) == 0)
{
this.need = num3;
this.tree_index = (index / 3) + this.tree[index + 2];
goto Label_0C3A;
}
this.mode = 9;
z.Message = "invalid distance code";
r = -3;
blocks.bitb = number;
blocks.bitk = bitk;
z.AvailableBytesIn = availableBytesIn;
z.TotalBytesIn += nextIn - z.NextIn;
z.NextIn = nextIn;
blocks.write = write;
return(blocks.Flush(r));
Label_0730:
num10 = write - this.dist;
while (num10 < 0)
{
num10 += blocks.end;
}
while (this.len != 0)
{
if (num9 == 0)
{
if ((write == blocks.end) && (blocks.read != 0))
{
write = 0;
num9 = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
}
if (num9 == 0)
{
blocks.write = write;
r = blocks.Flush(r);
write = blocks.write;
num9 = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
if ((write == blocks.end) && (blocks.read != 0))
{
write = 0;
num9 = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
}
if (num9 == 0)
{
blocks.bitb = number;
blocks.bitk = bitk;
z.AvailableBytesIn = availableBytesIn;
z.TotalBytesIn += nextIn - z.NextIn;
z.NextIn = nextIn;
blocks.write = write;
return(blocks.Flush(r));
}
}
}
blocks.window[write++] = blocks.window[num10++];
num9--;
if (num10 == blocks.end)
{
num10 = 0;
}
this.len--;
}
this.mode = 0;
goto Label_0C3A;
Label_0B44:
r = 1;
blocks.bitb = number;
blocks.bitk = bitk;
z.AvailableBytesIn = availableBytesIn;
z.TotalBytesIn += nextIn - z.NextIn;
z.NextIn = nextIn;
blocks.write = write;
return(blocks.Flush(r));
Label_0C3A:
flag = true;
switch (this.mode)
{
case 0:
if ((num9 < 0x102) || (availableBytesIn < 10))
{
goto Label_0196;
}
blocks.bitb = number;
blocks.bitk = bitk;
z.AvailableBytesIn = availableBytesIn;
z.TotalBytesIn += nextIn - z.NextIn;
z.NextIn = nextIn;
blocks.write = write;
r = this.InflateFast(this.lbits, this.dbits, this.ltree, this.ltree_index, this.dtree, this.dtree_index, blocks, z);
nextIn = z.NextIn;
availableBytesIn = z.AvailableBytesIn;
number = blocks.bitb;
bitk = blocks.bitk;
write = blocks.write;
num9 = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
if (r == 0)
{
goto Label_0196;
}
this.mode = (r == 1) ? 7 : 9;
goto Label_0C3A;
case 1:
goto Label_01C3;
case 2:
num = this.get_Renamed;
while (bitk < num)
{
if (availableBytesIn != 0)
{
r = 0;
}
else
{
blocks.bitb = number;
blocks.bitk = bitk;
z.AvailableBytesIn = availableBytesIn;
z.TotalBytesIn += nextIn - z.NextIn;
z.NextIn = nextIn;
blocks.write = write;
return(blocks.Flush(r));
}
availableBytesIn--;
number |= (z.InputBuffer[nextIn++] & 0xff) << bitk;
bitk += 8;
}
this.len += number & inflate_mask[num];
number = number >> num;
bitk -= num;
this.need = this.dbits;
this.tree = this.dtree;
this.tree_index = this.dtree_index;
this.mode = 3;
goto Label_04AE;
case 3:
goto Label_04AE;
case 4:
num = this.get_Renamed;
while (bitk < num)
{
if (availableBytesIn != 0)
{
r = 0;
}
else
{
blocks.bitb = number;
blocks.bitk = bitk;
z.AvailableBytesIn = availableBytesIn;
z.TotalBytesIn += nextIn - z.NextIn;
z.NextIn = nextIn;
blocks.write = write;
return(blocks.Flush(r));
}
availableBytesIn--;
number |= (z.InputBuffer[nextIn++] & 0xff) << bitk;
bitk += 8;
}
this.dist += number & inflate_mask[num];
number = number >> num;
bitk -= num;
this.mode = 5;
goto Label_0730;
case 5:
goto Label_0730;
case 6:
if (num9 == 0)
{
if ((write == blocks.end) && (blocks.read != 0))
{
write = 0;
num9 = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
}
if (num9 == 0)
{
blocks.write = write;
r = blocks.Flush(r);
write = blocks.write;
num9 = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
if ((write == blocks.end) && (blocks.read != 0))
{
write = 0;
num9 = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
}
if (num9 == 0)
{
blocks.bitb = number;
blocks.bitk = bitk;
z.AvailableBytesIn = availableBytesIn;
z.TotalBytesIn += nextIn - z.NextIn;
z.NextIn = nextIn;
blocks.write = write;
return(blocks.Flush(r));
}
}
}
r = 0;
blocks.window[write++] = (byte)this.lit;
num9--;
this.mode = 0;
goto Label_0C3A;
case 7:
if (bitk > 7)
{
bitk -= 8;
availableBytesIn++;
nextIn--;
}
blocks.write = write;
r = blocks.Flush(r);
write = blocks.write;
num9 = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
if (blocks.read != blocks.write)
{
blocks.bitb = number;
blocks.bitk = bitk;
z.AvailableBytesIn = availableBytesIn;
z.TotalBytesIn += nextIn - z.NextIn;
z.NextIn = nextIn;
blocks.write = write;
return(blocks.Flush(r));
}
this.mode = 8;
goto Label_0B44;
case 8:
goto Label_0B44;
case 9:
r = -3;
blocks.bitb = number;
blocks.bitk = bitk;
z.AvailableBytesIn = availableBytesIn;
z.TotalBytesIn += nextIn - z.NextIn;
z.NextIn = nextIn;
blocks.write = write;
return(blocks.Flush(r));
}
r = -2;
blocks.bitb = number;
blocks.bitk = bitk;
z.AvailableBytesIn = availableBytesIn;
z.TotalBytesIn += nextIn - z.NextIn;
z.NextIn = nextIn;
blocks.write = write;
return(blocks.Flush(r));
}
internal static int DistanceCode(int dist)
{
return((int)((dist >= 256) ? Tree._dist_code[256 + SharedUtils.URShift(dist, 7)] : Tree._dist_code[dist]));
}
internal int[] x = null; // bit offsets, then code stack
private int huft_build(int[] b, int bindex, int n, int s, int[] d, int[] e, int[] t, int[] m, int[] hp, int[] hn, int[] v)
{
// Given a list of code lengths and a maximum table size, make a set of
// tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR
// if the given code set is incomplete (the tables are still built in this
// case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
// lengths), or Z_MEM_ERROR if not enough memory.
int a; // counter for codes of length k
int f; // i repeats in table every f entries
int g; // maximum code length
int h; // table level
int i; // counter, current code
int j; // counter
int k; // number of bits in current code
int l; // bits per table (returned in m)
int mask; // (1 << w) - 1, to avoid cc -O bug on HP
int p; // pointer into c[], b[], or v[]
int q; // points to current table
int w; // bits before this table == (l * h)
int xp; // pointer into x
int y; // number of dummy codes added
int z; // number of entries in current table
// Generate counts for each bit length
p = 0; i = n;
do
{
c[b[bindex + p]]++; p++; i--; // assume all entries <= BMAX
}while (i != 0);
if (c[0] == n)
{
// null input--all zero length codes
t[0] = -1;
m[0] = 0;
return(Z_OK);
}
// Find minimum and maximum length, bound *m by those
l = m[0];
for (j = 1; j <= BMAX; j++)
{
if (c[j] != 0)
{
break;
}
}
k = j; // minimum code length
if (l < j)
{
l = j;
}
for (i = BMAX; i != 0; i--)
{
if (c[i] != 0)
{
break;
}
}
g = i; // maximum code length
if (l > i)
{
l = i;
}
m[0] = l;
// Adjust last length count to fill out codes, if needed
for (y = 1 << j; j < i; j++, y <<= 1)
{
if ((y -= c[j]) < 0)
{
return(Z_DATA_ERROR);
}
}
if ((y -= c[i]) < 0)
{
return(Z_DATA_ERROR);
}
c[i] += y;
// Generate starting offsets into the value table for each length
x[1] = j = 0;
p = 1; xp = 2;
while (--i != 0)
{
// note that i == g from above
x[xp] = (j += c[p]);
xp++;
p++;
}
// Make a table of values in order of bit lengths
i = 0; p = 0;
do
{
if ((j = b[bindex + p]) != 0)
{
v[x[j]++] = i;
}
p++;
}while (++i < n);
n = x[g]; // set n to length of v
// Generate the Huffman codes and for each, make the table entries
x[0] = i = 0; // first Huffman code is zero
p = 0; // grab values in bit order
h = -1; // no tables yet--level -1
w = -l; // bits decoded == (l * h)
u[0] = 0; // just to keep compilers happy
q = 0; // ditto
z = 0; // ditto
// go through the bit lengths (k already is bits in shortest code)
for (; k <= g; k++)
{
a = c[k];
while (a-- != 0)
{
// here i is the Huffman code of length k bits for value *p
// make tables up to required level
while (k > w + l)
{
h++;
w += l; // previous table always l bits
// compute minimum size table less than or equal to l bits
z = g - w;
z = (z > l) ? l : z; // table size upper limit
if ((f = 1 << (j = k - w)) > a + 1)
{
// try a k-w bit table
// too few codes for k-w bit table
f -= (a + 1); // deduct codes from patterns left
xp = k;
if (j < z)
{
while (++j < z)
{
// try smaller tables up to z bits
if ((f <<= 1) <= c[++xp])
{
break; // enough codes to use up j bits
}
f -= c[xp]; // else deduct codes from patterns
}
}
}
z = 1 << j; // table entries for j-bit table
// allocate new table
if (hn[0] + z > MANY)
{
// (note: doesn't matter for fixed)
return(Z_DATA_ERROR); // overflow of MANY
}
u[h] = q = hn[0]; // DEBUG
hn[0] += z;
// connect to last table, if there is one
if (h != 0)
{
x[h] = i; // save pattern for backing up
r[0] = (sbyte)j; // bits in this table
r[1] = (sbyte)l; // bits to dump before this table
j = SharedUtils.URShift(i, (w - l));
r[2] = (int)(q - u[h - 1] - j); // offset to this table
Array.Copy(r, 0, hp, (u[h - 1] + j) * 3, 3); // connect to last table
}
else
{
t[0] = q; // first table is returned result
}
}
// set up table entry in r
r[1] = (sbyte)(k - w);
if (p >= n)
{
r[0] = 128 + 64; // out of values--invalid code
}
else if (v[p] < s)
{
r[0] = (sbyte)(v[p] < 256 ? 0 : 32 + 64); // 256 is end-of-block
r[2] = v[p++]; // simple code is just the value
}
else
{
r[0] = (sbyte)(e[v[p] - s] + 16 + 64); // non-simple--look up in lists
r[2] = d[v[p++] - s];
}
// fill code-like entries with r
f = 1 << (k - w);
for (j = SharedUtils.URShift(i, w); j < z; j += f)
{
Array.Copy(r, 0, hp, (q + j) * 3, 3);
}
// backwards increment the k-bit code i
for (j = 1 << (k - 1); (i & j) != 0; j = SharedUtils.URShift(j, 1))
{
i ^= j;
}
i ^= j;
// backup over finished tables
mask = (1 << w) - 1; // needed on HP, cc -O bug
while ((i & mask) != x[h])
{
h--; // don't need to update q
w -= l;
mask = (1 << w) - 1;
}
}
}
// Return Z_BUF_ERROR if we were given an incomplete table
return(y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK);
}
// Token: 0x060007A9 RID: 1961 RVA: 0x000447C0 File Offset: 0x000429C0
private int huft_build(int[] b, int bindex, int n, int s, int[] d, int[] e, int[] t, int[] m, int[] hp, int[] hn, int[] v)
{
int num = 0;
int num2 = n;
do
{
this.c[b[bindex + num]]++;
num++;
num2--;
}while (num2 != 0);
if (this.c[0] == n)
{
t[0] = -1;
m[0] = 0;
return(0);
}
int num3 = m[0];
int i = 1;
while (i <= 15 && this.c[i] == 0)
{
i++;
}
int j = i;
if (num3 < i)
{
num3 = i;
}
num2 = 15;
while (num2 != 0 && this.c[num2] == 0)
{
num2--;
}
int num4 = num2;
if (num3 > num2)
{
num3 = num2;
}
m[0] = num3;
int num5 = 1 << i;
while (i < num2)
{
if ((num5 -= this.c[i]) < 0)
{
return(-3);
}
i++;
num5 <<= 1;
}
if ((num5 -= this.c[num2]) < 0)
{
return(-3);
}
this.c[num2] += num5;
int[] array = this.x;
int num6 = 1;
int num7 = 0;
i = 0;
array[num6] = num7;
num = 1;
int num8 = 2;
while (--num2 != 0)
{
i = (this.x[num8] = i + this.c[num]);
num8++;
num++;
}
num2 = 0;
num = 0;
do
{
if ((i = b[bindex + num]) != 0)
{
v[this.x[i]++] = num2;
}
num++;
}while (++num2 < n);
n = this.x[num4];
int[] array2 = this.x;
int num9 = 0;
int num10 = 0;
num2 = 0;
array2[num9] = num10;
num = 0;
int num11 = -1;
int num12 = -num3;
this.u[0] = 0;
int num13 = 0;
int num14 = 0;
while (j <= num4)
{
int num15 = this.c[j];
while (num15-- != 0)
{
int num16;
while (j > num12 + num3)
{
num11++;
num12 += num3;
num14 = num4 - num12;
num14 = ((num14 > num3) ? num3 : num14);
if ((num16 = 1 << ((i = j - num12) & 31)) > num15 + 1)
{
num16 -= num15 + 1;
num8 = j;
if (i < num14)
{
while (++i < num14 && (num16 <<= 1) > this.c[++num8])
{
num16 -= this.c[num8];
}
}
}
num14 = 1 << i;
if (hn[0] + num14 > 1440)
{
return(-3);
}
num13 = (this.u[num11] = hn[0]);
hn[0] += num14;
if (num11 != 0)
{
this.x[num11] = num2;
this.r[0] = (int)((sbyte)i);
this.r[1] = (int)((sbyte)num3);
i = SharedUtils.URShift(num2, num12 - num3);
this.r[2] = num13 - this.u[num11 - 1] - i;
Array.Copy(this.r, 0, hp, (this.u[num11 - 1] + i) * 3, 3);
}
else
{
t[0] = num13;
}
}
this.r[1] = (int)((sbyte)(j - num12));
if (num >= n)
{
this.r[0] = 192;
}
else if (v[num] < s)
{
this.r[0] = (int)((v[num] < 256) ? 0 : 96);
this.r[2] = v[num++];
}
else
{
this.r[0] = (int)((sbyte)(e[v[num] - s] + 16 + 64));
this.r[2] = d[v[num++] - s];
}
num16 = 1 << j - num12;
for (i = SharedUtils.URShift(num2, num12); i < num14; i += num16)
{
Array.Copy(this.r, 0, hp, (num13 + i) * 3, 3);
}
i = 1 << j - 1;
while ((num2 & i) != 0)
{
num2 ^= i;
i = SharedUtils.URShift(i, 1);
}
num2 ^= i;
int num17 = (1 << num12) - 1;
while ((num2 & num17) != this.x[num11])
{
num11--;
num12 -= num3;
num17 = (1 << num12) - 1;
}
}
j++;
}
if (num5 != 0)
{
if (num4 != 1)
{
return(-5);
}
}
return(0);
}