internal int inflateInit(ZStream z, int w)
{
z.msg = null;
blocks = null;
// handle undocumented nowrap option (no zlib header or check)
nowrap = 0;
if(w < 0){
w = - w;
nowrap = 1;
}
// set window size
if(w<8 ||w>15){
inflateEnd(z);
return Z_STREAM_ERROR;
}
wbits=w;
z.istate.blocks=new InfBlocks(z,
z.istate.nowrap!=0 ? null : this,
1<<w);
// reset state
inflateReset(z);
return Z_OK;
}
internal int inflateEnd(ZStream z)
{
if(blocks != null)
blocks.free(z);
blocks=null;
// ZFREE(z, z->state);
return Z_OK;
}
private ZLibStatus ProcessCodes(InfBlocks s, ZStream z, ZLibStatus r)
{
int j; // temporary storage
int tindex; // temporary pointer
int e; // extra bits or operation
int b = 0; // bit buffer
int k = 0; // bits in bit buffer
int p = 0; // input data pointer
int n; // bytes available there
int q; // output window write pointer
int m; // bytes to end of window or read pointer
int f; // pointer to copy strings from
// copy input/output information to locals (UPDATE macro restores)
p = z.next_in_index; n = z.avail_in; b = s.bitb; k = s.bitk;
q = s.write; m = q < s.read ? s.read - q - 1 : s.end - q;
// process input and output based on current state
while (true)
{
switch (this._mode)
{
// waiting for "i:"=input, "o:"=output, "x:"=nothing
case InflateCodeMode.START: // x: set up for InflateCodeMode.LEN
if (m >= 258 && n >= 10)
{
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
r = this.InflateFast(this._lbits, this._dbits, this._ltree, this._ltreeIndex, this._dtree, this._dtreeIndex, s, z);
p = z.next_in_index; n = z.avail_in; b = s.bitb; k = s.bitk;
q = s.write; m = q < s.read ? s.read - q - 1 : s.end - q;
if (r != ZLibStatus.Z_OK)
{
this._mode = r == ZLibStatus.Z_STREAM_END ? InflateCodeMode.WASH : InflateCodeMode.BADCODE;
break;
}
}
this._need = this._lbits;
this._tree = this._ltree;
this._treeIndex = this._ltreeIndex;
this._mode = InflateCodeMode.LEN;
goto case InflateCodeMode.LEN;
case InflateCodeMode.LEN: // i: get length/literal/eob next
j = this._need;
while (k < (j))
{
if (n != 0) r = ZLibStatus.Z_OK;
else
{
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return s.InflateFlush(z, r);
}
n--;
b |= (z.next_in[p++] & 0xff) << k;
k += 8;
}
tindex = (this._treeIndex + (b & inflate_mask[j])) * 3;
b >>= (this._tree[tindex + 1]);
k -= (this._tree[tindex + 1]);
e = this._tree[tindex];
if (e == 0)
{ // literal
this._lit = this._tree[tindex + 2];
this._mode = InflateCodeMode.LIT;
break;
}
if ((e & 16) != 0)
{ // length
this._get = e & 15;
this._len = this._tree[tindex + 2];
this._mode = InflateCodeMode.LENEXT;
break;
}
if ((e & 64) == 0)
{ // next table
this._need = e;
this._treeIndex = tindex / 3 + this._tree[tindex + 2];
break;
}
if ((e & 32) != 0)
{ // end of block
this._mode = InflateCodeMode.WASH;
break;
}
this._mode = InflateCodeMode.BADCODE; // invalid code
z.msg = "invalid literal/length code";
r = ZLibStatus.Z_DATA_ERROR;
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return s.InflateFlush(z, r);
case InflateCodeMode.LENEXT: // i: getting length extra (have base)
j = this._get;
while (k < (j))
{
if (n != 0) r = ZLibStatus.Z_OK;
else
{
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return s.InflateFlush(z, r);
}
n--; b |= (z.next_in[p++] & 0xff) << k;
k += 8;
}
this._len += (b & inflate_mask[j]);
b >>= j;
k -= j;
this._need = this._dbits;
this._tree = this._dtree;
this._treeIndex = this._dtreeIndex;
this._mode = InflateCodeMode.DIST;
goto case InflateCodeMode.DIST;
case InflateCodeMode.DIST: // i: get distance next
j = this._need;
while (k < (j))
{
if (n != 0) r = ZLibStatus.Z_OK;
else
{
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return s.InflateFlush(z, r);
}
n--; b |= (z.next_in[p++] & 0xff) << k;
k += 8;
}
tindex = (this._treeIndex + (b & inflate_mask[j])) * 3;
b >>= this._tree[tindex + 1];
k -= this._tree[tindex + 1];
e = (this._tree[tindex]);
if ((e & 16) != 0)
{ // distance
this._get = e & 15;
this._dist = this._tree[tindex + 2];
this._mode = InflateCodeMode.DISTEXT;
break;
}
if ((e & 64) == 0)
{ // next table
this._need = e;
this._treeIndex = tindex / 3 + this._tree[tindex + 2];
break;
}
this._mode = InflateCodeMode.BADCODE; // invalid code
z.msg = "invalid distance code";
r = ZLibStatus.Z_DATA_ERROR;
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return s.InflateFlush(z, r);
case InflateCodeMode.DISTEXT: // i: getting distance extra
j = this._get;
while (k < (j))
{
if (n != 0) r = ZLibStatus.Z_OK;
else
{
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return s.InflateFlush(z, r);
}
n--; b |= (z.next_in[p++] & 0xff) << k;
k += 8;
}
this._dist += (b & inflate_mask[j]);
b >>= j;
k -= j;
this._mode = InflateCodeMode.COPY;
goto case InflateCodeMode.COPY;
case InflateCodeMode.COPY: // o: copying bytes in window, waiting for space
f = q - this._dist;
while (f < 0)
{ // modulo window size-"while" instead
f += s.end; // of "if" handles invalid distances
}
while (this._len != 0)
{
if (m == 0)
{
if (q == s.end && s.read != 0) { q = 0; m = q < s.read ? s.read - q - 1 : s.end - q; }
if (m == 0)
{
s.write = q; r = s.InflateFlush(z, r);
q = s.write; m = q < s.read ? s.read - q - 1 : s.end - q;
if (q == s.end && s.read != 0) { q = 0; m = q < s.read ? s.read - q - 1 : s.end - q; }
if (m == 0)
{
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return s.InflateFlush(z, r);
}
}
}
s.window[q++] = s.window[f++]; m--;
if (f == s.end)
f = 0;
this._len--;
}
this._mode = InflateCodeMode.START;
break;
case InflateCodeMode.LIT: // o: got literal, waiting for output space
if (m == 0)
{
if (q == s.end && s.read != 0) { q = 0; m = q < s.read ? s.read - q - 1 : s.end - q; }
if (m == 0)
{
s.write = q; r = s.InflateFlush(z, r);
q = s.write; m = q < s.read ? s.read - q - 1 : s.end - q;
if (q == s.end && s.read != 0) { q = 0; m = q < s.read ? s.read - q - 1 : s.end - q; }
if (m == 0)
{
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return s.InflateFlush(z, r);
}
}
}
r = ZLibStatus.Z_OK;
s.window[q++] = (byte)this._lit; m--;
this._mode = InflateCodeMode.START;
break;
case InflateCodeMode.WASH: // o: got eob, possibly more output
if (k > 7)
{ // return unused byte, if any
k -= 8;
n++;
p--; // can always return one
}
s.write = q; r = s.InflateFlush(z, r);
q = s.write; m = q < s.read ? s.read - q - 1 : s.end - q;
if (s.read != s.write)
{
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return s.InflateFlush(z, r);
}
this._mode = InflateCodeMode.END;
goto case InflateCodeMode.END;
case InflateCodeMode.END:
r = ZLibStatus.Z_STREAM_END;
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return s.InflateFlush(z, r);
case InflateCodeMode.BADCODE: // x: got error
r = ZLibStatus.Z_DATA_ERROR;
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return s.InflateFlush(z, r);
default:
r = ZLibStatus.Z_STREAM_ERROR;
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return s.InflateFlush(z, r);
}
}
}
internal ZLibStatus InflateEnd(ZStream z)
{
if (blocks != null)
blocks.free(z);
blocks = null;
// ZFREE(z, z->state);
return ZLibStatus.Z_OK;
}
/// <summary>
/// Inflates the fast.
/// </summary>
/// <param name="bl">The bl.</param>
/// <param name="bd">The bd.</param>
/// <param name="tl">The tl.</param>
/// <param name="tl_index">The tl_index.</param>
/// <param name="td">The td.</param>
/// <param name="td_index">The td_index.</param>
/// <param name="s">The s.</param>
/// <param name="z">The z.</param>
/// <returns></returns>
/// <remarks>
/// Called with number of bytes left to write in window at least 258
/// (the maximum string length) and number of input bytes available
/// at least ten. The ten bytes are six bytes for the longest length/
/// distance pair plus four bytes for overloading the bit buffer.
/// </remarks>
private ZLibStatus InflateFast(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index, InfBlocks s, ZStream z)
{
int t; // temporary pointer
int[] tp; // temporary pointer
int tp_index; // temporary pointer
int e; // extra bits or operation
int b; // bit buffer
int k; // bits in bit buffer
int p; // input data pointer
int n; // bytes available there
int q; // output window write pointer
int m; // bytes to end of window or read pointer
int ml; // mask for literal/length tree
int md; // mask for distance tree
int c; // bytes to copy
int d; // distance back to copy from
int r; // copy source pointer
int tp_index_t_3; // (tp_index+t)*3
// load input, output, bit values
p = z.next_in_index; n = z.avail_in; b = s.bitb; k = s.bitk;
q = s.write; m = q < s.read ? s.read - q - 1 : s.end - q;
// initialize masks
ml = inflate_mask[bl];
md = inflate_mask[bd];
// do until not enough input or output space for fast loop
do
{ // assume called with m >= 258 && n >= 10
// get literal/length code
while (k < (20))
{ // max bits for literal/length code
n--;
b |= (z.next_in[p++] & 0xff) << k; k += 8;
}
t = b & ml;
tp = tl;
tp_index = tl_index;
tp_index_t_3 = (tp_index + t) * 3;
if ((e = tp[tp_index_t_3]) == 0)
{
b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
s.window[q++] = (byte)tp[tp_index_t_3 + 2];
m--;
continue;
}
do
{
b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
if ((e & 16) != 0)
{
e &= 15;
c = tp[tp_index_t_3 + 2] + ((int)b & inflate_mask[e]);
b >>= e; k -= e;
// decode distance base of block to copy
while (k < (15))
{ // max bits for distance code
n--;
b |= (z.next_in[p++] & 0xff) << k; k += 8;
}
t = b & md;
tp = td;
tp_index = td_index;
tp_index_t_3 = (tp_index + t) * 3;
e = tp[tp_index_t_3];
do
{
b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
if ((e & 16) != 0)
{
// get extra bits to add to distance base
e &= 15;
while (k < (e))
{ // get extra bits (up to 13)
n--;
b |= (z.next_in[p++] & 0xff) << k; k += 8;
}
d = tp[tp_index_t_3 + 2] + (b & inflate_mask[e]);
b >>= (e); k -= (e);
// do the copy
m -= c;
if (q >= d)
{ // offset before dest
// just copy
r = q - d;
if (q - r > 0 && 2 > (q - r))
{
s.window[q++] = s.window[r++]; // minimum count is three,
s.window[q++] = s.window[r++]; // so unroll loop a little
c -= 2;
}
else
{
System.Array.Copy(s.window, r, s.window, q, 2);
q += 2; r += 2; c -= 2;
}
}
else
{ // else offset after destination
r = q - d;
do
{
r += s.end; // force pointer in window
} while (r < 0); // covers invalid distances
e = s.end - r;
if (c > e)
{ // if source crosses,
c -= e; // wrapped copy
if (q - r > 0 && e > (q - r))
{
do { s.window[q++] = s.window[r++]; }
while (--e != 0);
}
else
{
System.Array.Copy(s.window, r, s.window, q, e);
q += e; r += e; e = 0;
}
r = 0; // copy rest from start of window
}
}
// copy all or what's left
if (q - r > 0 && c > (q - r))
{
do { s.window[q++] = s.window[r++]; }
while (--c != 0);
}
else
{
System.Array.Copy(s.window, r, s.window, q, c);
q += c; r += c; c = 0;
}
break;
}
else if ((e & 64) == 0)
{
t += tp[tp_index_t_3 + 2];
t += (b & inflate_mask[e]);
tp_index_t_3 = (tp_index + t) * 3;
e = tp[tp_index_t_3];
}
else
{
z.msg = "invalid distance code";
c = z.avail_in - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= c << 3;
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return ZLibStatus.Z_DATA_ERROR;
}
}
while (true);
break;
}
if ((e & 64) == 0)
{
t += tp[tp_index_t_3 + 2];
t += (b & inflate_mask[e]);
tp_index_t_3 = (tp_index + t) * 3;
if ((e = tp[tp_index_t_3]) == 0)
{
b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
s.window[q++] = (byte)tp[tp_index_t_3 + 2];
m--;
break;
}
}
else if ((e & 32) != 0)
{
c = z.avail_in - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= c << 3;
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return ZLibStatus.Z_STREAM_END;
}
else
{
z.msg = "invalid literal/length code";
c = z.avail_in - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= c << 3;
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return ZLibStatus.Z_DATA_ERROR;
}
}
while (true);
}
while (m >= 258 && n >= 10);
// not enough input or output--restore pointers and return
c = z.avail_in - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= c << 3;
s.bitb = b; s.bitk = k;
z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
s.write = q;
return ZLibStatus.Z_OK;
}