Example #1
0
        internal int Process(int r)
        {
            int t; // temporary storage
            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

            // copy input/output information to locals (UPDATE macro restores)

            p = _codec.NextIn;
            n = _codec.AvailableBytesIn;
            b = bitb;
            k = bitk;

            q = writeAt;
            m = (int)(q < readAt ? readAt - q - 1 : end - q);


            // process input based on current state
            while (true)
            {
                switch (mode)
                {
                case InflateBlockMode.TYPE:

                    while (k < (3))
                    {
                        if (n != 0)
                        {
                            r = ZlibConstants.Z_OK;
                        }
                        else
                        {
                            bitb = b; bitk = k;
                            _codec.AvailableBytesIn = n;
                            _codec.TotalBytesIn    += p - _codec.NextIn;
                            _codec.NextIn           = p;
                            writeAt = q;
                            return(Flush(r));
                        }

                        n--;
                        b |= (_codec.InputBuffer[p++] & 0xff) << k;
                        k += 8;
                    }
                    t    = (int)(b & 7);
                    last = t & 1;

                    switch ((uint)t >> 1)
                    {
                    case 0:                           // stored
                        b  >>= 3; k -= (3);
                        t    = k & 7;                 // go to byte boundary
                        b  >>= t; k -= t;
                        mode = InflateBlockMode.LENS; // get length of stored block
                        break;

                    case 1:          // fixed
                        int[]   bl = new int[1];
                        int[]   bd = new int[1];
                        int[][] tl = new int[1][];
                        int[][] td = new int[1][];
                        InfTree.inflate_trees_fixed(bl, bd, tl, td, _codec);
                        codes.Init(bl[0], bd[0], tl[0], 0, td[0], 0);
                        b  >>= 3; k -= 3;
                        mode = InflateBlockMode.CODES;
                        break;

                    case 2:          // dynamic
                        b  >>= 3; k -= 3;
                        mode = InflateBlockMode.TABLE;
                        break;

                    case 3:          // illegal
                        b                     >>= 3; k -= 3;
                        mode                    = InflateBlockMode.BAD;
                        _codec.Message          = "invalid block type";
                        r                       = ZlibConstants.Z_DATA_ERROR;
                        bitb                    = b; bitk = k;
                        _codec.AvailableBytesIn = n;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt                 = q;
                        return(Flush(r));
                    }
                    break;

                case InflateBlockMode.LENS:

                    while (k < (32))
                    {
                        if (n != 0)
                        {
                            r = ZlibConstants.Z_OK;
                        }
                        else
                        {
                            bitb = b; bitk = k;
                            _codec.AvailableBytesIn = n;
                            _codec.TotalBytesIn    += p - _codec.NextIn;
                            _codec.NextIn           = p;
                            writeAt = q;
                            return(Flush(r));
                        }
                        ;
                        n--;
                        b |= (_codec.InputBuffer[p++] & 0xff) << k;
                        k += 8;
                    }

                    if ((((~b) >> 16) & 0xffff) != (b & 0xffff))
                    {
                        mode           = InflateBlockMode.BAD;
                        _codec.Message = "invalid stored block lengths";
                        r = ZlibConstants.Z_DATA_ERROR;

                        bitb = b; bitk = k;
                        _codec.AvailableBytesIn = n;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    left = (b & 0xffff);
                    b    = k = 0;  // dump bits
                    mode = left != 0 ? InflateBlockMode.STORED : (last != 0 ? InflateBlockMode.DRY : InflateBlockMode.TYPE);
                    break;

                case InflateBlockMode.STORED:
                    if (n == 0)
                    {
                        bitb = b; bitk = k;
                        _codec.AvailableBytesIn = n;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }

                    if (m == 0)
                    {
                        if (q == end && readAt != 0)
                        {
                            q = 0; m = (int)(q < readAt ? readAt - q - 1 : end - q);
                        }
                        if (m == 0)
                        {
                            writeAt = q;
                            r       = Flush(r);
                            q       = writeAt; m = (int)(q < readAt ? readAt - q - 1 : end - q);
                            if (q == end && readAt != 0)
                            {
                                q = 0; m = (int)(q < readAt ? readAt - q - 1 : end - q);
                            }
                            if (m == 0)
                            {
                                bitb = b; bitk = k;
                                _codec.AvailableBytesIn = n;
                                _codec.TotalBytesIn    += p - _codec.NextIn;
                                _codec.NextIn           = p;
                                writeAt = q;
                                return(Flush(r));
                            }
                        }
                    }
                    r = ZlibConstants.Z_OK;

                    t = left;
                    if (t > n)
                    {
                        t = n;
                    }
                    if (t > m)
                    {
                        t = m;
                    }
                    Array.Copy(_codec.InputBuffer, p, window, q, t);
                    p += t; n -= t;
                    q += t; m -= t;
                    if ((left -= t) != 0)
                    {
                        break;
                    }
                    mode = last != 0 ? InflateBlockMode.DRY : InflateBlockMode.TYPE;
                    break;

                case InflateBlockMode.TABLE:

                    while (k < (14))
                    {
                        if (n != 0)
                        {
                            r = ZlibConstants.Z_OK;
                        }
                        else
                        {
                            bitb = b; bitk = k;
                            _codec.AvailableBytesIn = n;
                            _codec.TotalBytesIn    += p - _codec.NextIn;
                            _codec.NextIn           = p;
                            writeAt = q;
                            return(Flush(r));
                        }

                        n--;
                        b |= (_codec.InputBuffer[p++] & 0xff) << k;
                        k += 8;
                    }

                    table = t = (b & 0x3fff);
                    if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
                    {
                        mode           = InflateBlockMode.BAD;
                        _codec.Message = "too many length or distance symbols";
                        r = ZlibConstants.Z_DATA_ERROR;

                        bitb = b; bitk = k;
                        _codec.AvailableBytesIn = n;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
                    if (blens == null || blens.Length < t)
                    {
                        blens = new int[t];
                    }
                    else
                    {
                        Array.Clear(blens, 0, t);
                        // for (int i = 0; i < t; i++)
                        // {
                        //     blens[i] = 0;
                        // }
                    }

                    b >>= 14;
                    k  -= 14;


                    index = 0;
                    mode  = InflateBlockMode.BTREE;
                    goto case InflateBlockMode.BTREE;

                case InflateBlockMode.BTREE:
                    while (index < 4 + (table >> 10))
                    {
                        while (k < (3))
                        {
                            if (n != 0)
                            {
                                r = ZlibConstants.Z_OK;
                            }
                            else
                            {
                                bitb = b; bitk = k;
                                _codec.AvailableBytesIn = n;
                                _codec.TotalBytesIn    += p - _codec.NextIn;
                                _codec.NextIn           = p;
                                writeAt = q;
                                return(Flush(r));
                            }

                            n--;
                            b |= (_codec.InputBuffer[p++] & 0xff) << k;
                            k += 8;
                        }

                        blens[border[index++]] = b & 7;

                        b >>= 3; k -= 3;
                    }

                    while (index < 19)
                    {
                        blens[border[index++]] = 0;
                    }

                    bb[0] = 7;
                    t     = inftree.inflate_trees_bits(blens, bb, tb, hufts, _codec);
                    if (t != ZlibConstants.Z_OK)
                    {
                        r = t;
                        if (r == ZlibConstants.Z_DATA_ERROR)
                        {
                            blens = null;
                            mode  = InflateBlockMode.BAD;
                        }

                        bitb = b; bitk = k;
                        _codec.AvailableBytesIn = n;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }

                    index = 0;
                    mode  = InflateBlockMode.DTREE;
                    goto case InflateBlockMode.DTREE;

                case InflateBlockMode.DTREE:
                    while (true)
                    {
                        t = table;
                        if (!(index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f)))
                        {
                            break;
                        }

                        int i, j, c;

                        t = bb[0];

                        while (k < t)
                        {
                            if (n != 0)
                            {
                                r = ZlibConstants.Z_OK;
                            }
                            else
                            {
                                bitb = b; bitk = k;
                                _codec.AvailableBytesIn = n;
                                _codec.TotalBytesIn    += p - _codec.NextIn;
                                _codec.NextIn           = p;
                                writeAt = q;
                                return(Flush(r));
                            }

                            n--;
                            b |= (_codec.InputBuffer[p++] & 0xff) << k;
                            k += 8;
                        }

                        t = hufts[(tb[0] + (b & InternalInflateConstants.InflateMask[t])) * 3 + 1];
                        c = hufts[(tb[0] + (b & InternalInflateConstants.InflateMask[t])) * 3 + 2];

                        if (c < 16)
                        {
                            b >>= t; k -= t;
                            blens[index++] = c;
                        }
                        else
                        {
                            // c == 16..18
                            i = c == 18 ? 7 : c - 14;
                            j = c == 18 ? 11 : 3;

                            while (k < (t + i))
                            {
                                if (n != 0)
                                {
                                    r = ZlibConstants.Z_OK;
                                }
                                else
                                {
                                    bitb = b; bitk = k;
                                    _codec.AvailableBytesIn = n;
                                    _codec.TotalBytesIn    += p - _codec.NextIn;
                                    _codec.NextIn           = p;
                                    writeAt = q;
                                    return(Flush(r));
                                }

                                n--;
                                b |= (_codec.InputBuffer[p++] & 0xff) << k;
                                k += 8;
                            }

                            b >>= t; k -= t;

                            j += (b & InternalInflateConstants.InflateMask[i]);

                            b >>= i; k -= i;

                            i = index;
                            t = table;
                            if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || (c == 16 && i < 1))
                            {
                                blens          = null;
                                mode           = InflateBlockMode.BAD;
                                _codec.Message = "invalid bit length repeat";
                                r = ZlibConstants.Z_DATA_ERROR;

                                bitb = b; bitk = k;
                                _codec.AvailableBytesIn = n;
                                _codec.TotalBytesIn    += p - _codec.NextIn;
                                _codec.NextIn           = p;
                                writeAt = q;
                                return(Flush(r));
                            }

                            c = (c == 16) ? blens[i - 1] : 0;
                            do
                            {
                                blens[i++] = c;
                            }while (--j != 0);
                            index = i;
                        }
                    }

                    tb[0] = -1;
                    {
                        int[] bl = new int[] { 9 };     // must be <= 9 for lookahead assumptions
                        int[] bd = new int[] { 6 };     // must be <= 9 for lookahead assumptions
                        int[] tl = new int[1];
                        int[] td = new int[1];

                        t = table;
                        t = inftree.inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), blens, bl, bd, tl, td, hufts, _codec);

                        if (t != ZlibConstants.Z_OK)
                        {
                            if (t == ZlibConstants.Z_DATA_ERROR)
                            {
                                blens = null;
                                mode  = InflateBlockMode.BAD;
                            }
                            r = t;

                            bitb = b; bitk = k;
                            _codec.AvailableBytesIn = n;
                            _codec.TotalBytesIn    += p - _codec.NextIn;
                            _codec.NextIn           = p;
                            writeAt = q;
                            return(Flush(r));
                        }
                        codes.Init(bl[0], bd[0], hufts, tl[0], hufts, td[0]);
                    }
                    mode = InflateBlockMode.CODES;
                    goto case InflateBlockMode.CODES;

                case InflateBlockMode.CODES:
                    bitb = b; bitk = k;
                    _codec.AvailableBytesIn = n;
                    _codec.TotalBytesIn    += p - _codec.NextIn;
                    _codec.NextIn           = p;
                    writeAt = q;

                    r = codes.Process(this, r);
                    if (r != ZlibConstants.Z_STREAM_END)
                    {
                        return(Flush(r));
                    }

                    r = ZlibConstants.Z_OK;
                    p = _codec.NextIn;
                    n = _codec.AvailableBytesIn;
                    b = bitb;
                    k = bitk;
                    q = writeAt;
                    m = (int)(q < readAt ? readAt - q - 1 : end - q);

                    if (last == 0)
                    {
                        mode = InflateBlockMode.TYPE;
                        break;
                    }
                    mode = InflateBlockMode.DRY;
                    goto case InflateBlockMode.DRY;

                case InflateBlockMode.DRY:
                    writeAt = q;
                    r       = Flush(r);
                    q       = writeAt; m = (int)(q < readAt ? readAt - q - 1 : end - q);
                    if (readAt != writeAt)
                    {
                        bitb = b; bitk = k;
                        _codec.AvailableBytesIn = n;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    mode = InflateBlockMode.DONE;
                    goto case InflateBlockMode.DONE;

                case InflateBlockMode.DONE:
                    r    = ZlibConstants.Z_STREAM_END;
                    bitb = b;
                    bitk = k;
                    _codec.AvailableBytesIn = n;
                    _codec.TotalBytesIn    += p - _codec.NextIn;
                    _codec.NextIn           = p;
                    writeAt = q;
                    return(Flush(r));

                case InflateBlockMode.BAD:
                    r = ZlibConstants.Z_DATA_ERROR;

                    bitb = b; bitk = k;
                    _codec.AvailableBytesIn = n;
                    _codec.TotalBytesIn    += p - _codec.NextIn;
                    _codec.NextIn           = p;
                    writeAt = q;
                    return(Flush(r));


                default:
                    r = ZlibConstants.Z_STREAM_ERROR;

                    bitb = b; bitk = k;
                    _codec.AvailableBytesIn = n;
                    _codec.TotalBytesIn    += p - _codec.NextIn;
                    _codec.NextIn           = p;
                    writeAt = q;
                    return(Flush(r));
                }
            }
        }
        internal int Process(int r)
        {
            int num  = this._codec.NextIn;
            int num2 = this._codec.AvailableBytesIn;
            int num3 = this.bitb;
            int i    = this.bitk;
            int num4 = this.writeAt;
            int num5 = (num4 >= this.readAt) ? (this.end - num4) : (this.readAt - num4 - 1);
            int num6;

            for (;;)
            {
                switch (this.mode)
                {
                case InflateBlocks.InflateBlockMode.TYPE:
                    while (i < 3)
                    {
                        if (num2 == 0)
                        {
                            goto IL_AD;
                        }
                        r = 0;
                        num2--;
                        num3 |= (int)(this._codec.InputBuffer[num++] & byte.MaxValue) << i;
                        i    += 8;
                    }
                    num6      = (num3 & 7);
                    this.last = (num6 & 1);
                    switch ((uint)num6 >> 1)
                    {
                    case 0u:
                        num3    >>= 3;
                        i        -= 3;
                        num6      = (i & 7);
                        num3    >>= num6;
                        i        -= num6;
                        this.mode = InflateBlocks.InflateBlockMode.LENS;
                        break;

                    case 1u:
                    {
                        int[]   array  = new int[1];
                        int[]   array2 = new int[1];
                        int[][] array3 = new int[1][];
                        int[][] array4 = new int[1][];
                        InfTree.inflate_trees_fixed(array, array2, array3, array4, this._codec);
                        this.codes.Init(array[0], array2[0], array3[0], 0, array4[0], 0);
                        num3    >>= 3;
                        i        -= 3;
                        this.mode = InflateBlocks.InflateBlockMode.CODES;
                        break;
                    }

                    case 2u:
                        num3    >>= 3;
                        i        -= 3;
                        this.mode = InflateBlocks.InflateBlockMode.TABLE;
                        break;

                    case 3u:
                        goto IL_206;
                    }
                    continue;

                case InflateBlocks.InflateBlockMode.LENS:
                    while (i < 32)
                    {
                        if (num2 == 0)
                        {
                            goto IL_2A3;
                        }
                        r = 0;
                        num2--;
                        num3 |= (int)(this._codec.InputBuffer[num++] & byte.MaxValue) << i;
                        i    += 8;
                    }
                    if ((~num3 >> 16 & 65535) != (num3 & 65535))
                    {
                        goto Block_8;
                    }
                    this.left = (num3 & 65535);
                    i         = (num3 = 0);
                    this.mode = ((this.left == 0) ? ((this.last == 0) ? InflateBlocks.InflateBlockMode.TYPE : InflateBlocks.InflateBlockMode.DRY) : InflateBlocks.InflateBlockMode.STORED);
                    continue;

                case InflateBlocks.InflateBlockMode.STORED:
                    if (num2 == 0)
                    {
                        goto Block_11;
                    }
                    if (num5 == 0)
                    {
                        if (num4 == this.end && this.readAt != 0)
                        {
                            num4 = 0;
                            num5 = ((num4 >= this.readAt) ? (this.end - num4) : (this.readAt - num4 - 1));
                        }
                        if (num5 == 0)
                        {
                            this.writeAt = num4;
                            r            = this.Flush(r);
                            num4         = this.writeAt;
                            num5         = ((num4 >= this.readAt) ? (this.end - num4) : (this.readAt - num4 - 1));
                            if (num4 == this.end && this.readAt != 0)
                            {
                                num4 = 0;
                                num5 = ((num4 >= this.readAt) ? (this.end - num4) : (this.readAt - num4 - 1));
                            }
                            if (num5 == 0)
                            {
                                goto Block_21;
                            }
                        }
                    }
                    r    = 0;
                    num6 = this.left;
                    if (num6 > num2)
                    {
                        num6 = num2;
                    }
                    if (num6 > num5)
                    {
                        num6 = num5;
                    }
                    Array.Copy(this._codec.InputBuffer, num, this.window, num4, num6);
                    num  += num6;
                    num2 -= num6;
                    num4 += num6;
                    num5 -= num6;
                    if ((this.left -= num6) != 0)
                    {
                        continue;
                    }
                    this.mode = ((this.last == 0) ? InflateBlocks.InflateBlockMode.TYPE : InflateBlocks.InflateBlockMode.DRY);
                    continue;

                case InflateBlocks.InflateBlockMode.TABLE:
                    while (i < 14)
                    {
                        if (num2 == 0)
                        {
                            goto IL_64B;
                        }
                        r = 0;
                        num2--;
                        num3 |= (int)(this._codec.InputBuffer[num++] & byte.MaxValue) << i;
                        i    += 8;
                    }
                    num6 = (this.table = (num3 & 16383));
                    if ((num6 & 31) > 29 || (num6 >> 5 & 31) > 29)
                    {
                        goto IL_702;
                    }
                    num6 = 258 + (num6 & 31) + (num6 >> 5 & 31);
                    if (this.blens == null || this.blens.Length < num6)
                    {
                        this.blens = new int[num6];
                    }
                    else
                    {
                        Array.Clear(this.blens, 0, num6);
                    }
                    num3     >>= 14;
                    i         -= 14;
                    this.index = 0;
                    this.mode  = InflateBlocks.InflateBlockMode.BTREE;
                    goto IL_7E6;

                case InflateBlocks.InflateBlockMode.BTREE:
                    goto IL_7E6;

                case InflateBlocks.InflateBlockMode.DTREE:
                    goto IL_9CF;

                case InflateBlocks.InflateBlockMode.CODES:
                    goto IL_E42;

                case InflateBlocks.InflateBlockMode.DRY:
                    goto IL_F34;

                case InflateBlocks.InflateBlockMode.DONE:
                    goto IL_FF0;

                case InflateBlocks.InflateBlockMode.BAD:
                    goto IL_1050;
                }
                break;
                for (;;)
                {
IL_9CF:
                    num6 = this.table;
                    if (this.index >= 258 + (num6 & 31) + (num6 >> 5 & 31))
                    {
                        break;
                    }
                    num6 = this.bb[0];
                    while (i < num6)
                    {
                        if (num2 == 0)
                        {
                            goto IL_A1A;
                        }
                        r = 0;
                        num2--;
                        num3 |= (int)(this._codec.InputBuffer[num++] & byte.MaxValue) << i;
                        i    += 8;
                    }
                    num6 = this.hufts[(this.tb[0] + (num3 & InternalInflateConstants.InflateMask[num6])) * 3 + 1];
                    int num7 = this.hufts[(this.tb[0] + (num3 & InternalInflateConstants.InflateMask[num6])) * 3 + 2];
                    if (num7 < 16)
                    {
                        num3 >>= num6;
                        i     -= num6;
                        this.blens[this.index++] = num7;
                    }
                    else
                    {
                        int num8 = (num7 != 18) ? (num7 - 14) : 7;
                        int num9 = (num7 != 18) ? 3 : 11;
                        while (i < num6 + num8)
                        {
                            if (num2 == 0)
                            {
                                goto IL_B5E;
                            }
                            r = 0;
                            num2--;
                            num3 |= (int)(this._codec.InputBuffer[num++] & byte.MaxValue) << i;
                            i    += 8;
                        }
                        num3 >>= num6;
                        i     -= num6;
                        num9  += (num3 & InternalInflateConstants.InflateMask[num8]);
                        num3 >>= num8;
                        i     -= num8;
                        num8   = this.index;
                        num6   = this.table;
                        if (num8 + num9 > 258 + (num6 & 31) + (num6 >> 5 & 31) || (num7 == 16 && num8 < 1))
                        {
                            goto IL_C52;
                        }
                        num7 = ((num7 != 16) ? 0 : this.blens[num8 - 1]);
                        do
                        {
                            this.blens[num8++] = num7;
                        }while (--num9 != 0);
                        this.index = num8;
                    }
                }
                this.tb[0] = -1;
                int[] array5 = new int[]
                {
                    9
                };
                int[] array6 = new int[]
                {
                    6
                };
                int[] array7 = new int[1];
                int[] array8 = new int[1];
                num6 = this.table;
                num6 = this.inftree.inflate_trees_dynamic(257 + (num6 & 31), 1 + (num6 >> 5 & 31), this.blens, array5, array6, array7, array8, this.hufts, this._codec);
                if (num6 != 0)
                {
                    goto Block_48;
                }
                this.codes.Init(array5[0], array6[0], this.hufts, array7[0], this.hufts, array8[0]);
                this.mode = InflateBlocks.InflateBlockMode.CODES;
                goto IL_E42;
                continue;
IL_E42:
                this.bitb = num3;
                this.bitk = i;
                this._codec.AvailableBytesIn = num2;
                this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
                this._codec.NextIn           = num;
                this.writeAt = num4;
                r            = this.codes.Process(this, r);
                if (r != 1)
                {
                    goto Block_50;
                }
                r    = 0;
                num  = this._codec.NextIn;
                num2 = this._codec.AvailableBytesIn;
                num3 = this.bitb;
                i    = this.bitk;
                num4 = this.writeAt;
                num5 = ((num4 >= this.readAt) ? (this.end - num4) : (this.readAt - num4 - 1));
                if (this.last == 0)
                {
                    this.mode = InflateBlocks.InflateBlockMode.TYPE;
                    continue;
                }
                goto IL_F28;
IL_7E6:
                while (this.index < 4 + (this.table >> 10))
                {
                    while (i < 3)
                    {
                        if (num2 == 0)
                        {
                            goto IL_803;
                        }
                        r = 0;
                        num2--;
                        num3 |= (int)(this._codec.InputBuffer[num++] & byte.MaxValue) << i;
                        i    += 8;
                    }
                    this.blens[InflateBlocks.border[this.index++]] = (num3 & 7);
                    num3 >>= 3;
                    i     -= 3;
                }
                while (this.index < 19)
                {
                    this.blens[InflateBlocks.border[this.index++]] = 0;
                }
                this.bb[0] = 7;
                num6       = this.inftree.inflate_trees_bits(this.blens, this.bb, this.tb, this.hufts, this._codec);
                if (num6 != 0)
                {
                    goto Block_34;
                }
                this.index = 0;
                this.mode  = InflateBlocks.InflateBlockMode.DTREE;
                goto IL_9CF;
            }
            r         = -2;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_AD:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_206:
            num3                       >>= 3;
            i                           -= 3;
            this.mode                    = InflateBlocks.InflateBlockMode.BAD;
            this._codec.Message          = "invalid block type";
            r                            = -3;
            this.bitb                    = num3;
            this.bitk                    = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt                 = num4;
            return(this.Flush(r));

IL_2A3:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

Block_8:
            this.mode           = InflateBlocks.InflateBlockMode.BAD;
            this._codec.Message = "invalid stored block lengths";
            r         = -3;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

Block_11:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

Block_21:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_64B:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_702:
            this.mode           = InflateBlocks.InflateBlockMode.BAD;
            this._codec.Message = "too many length or distance symbols";
            r         = -3;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_803:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

Block_34:
            r = num6;
            if (r == -3)
            {
                this.blens = null;
                this.mode  = InflateBlocks.InflateBlockMode.BAD;
            }
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_A1A:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_B5E:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_C52:
            this.blens          = null;
            this.mode           = InflateBlocks.InflateBlockMode.BAD;
            this._codec.Message = "invalid bit length repeat";
            r         = -3;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

Block_48:
            if (num6 == -3)
            {
                this.blens = null;
                this.mode  = InflateBlocks.InflateBlockMode.BAD;
            }
            r         = num6;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

Block_50:
            return(this.Flush(r));

IL_F28:
            this.mode = InflateBlocks.InflateBlockMode.DRY;
IL_F34:
            this.writeAt = num4;
            r            = this.Flush(r);
            num4         = this.writeAt;
            int num10 = (num4 >= this.readAt) ? (this.end - num4) : (this.readAt - num4 - 1);

            if (this.readAt != this.writeAt)
            {
                this.bitb = num3;
                this.bitk = i;
                this._codec.AvailableBytesIn = num2;
                this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
                this._codec.NextIn           = num;
                this.writeAt = num4;
                return(this.Flush(r));
            }
            this.mode = InflateBlocks.InflateBlockMode.DONE;
IL_FF0:
            r         = 1;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_1050:
            r         = -3;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));
        }
Example #3
0
        internal int Process(int r)
        {
            int num  = _codec.NextIn;
            int num2 = _codec.AvailableBytesIn;
            int num3 = bitb;
            int i    = bitk;
            int num4 = writeAt;
            int num5 = (num4 >= readAt) ? (end - num4) : (readAt - num4 - 1);

            while (true)
            {
                switch (mode)
                {
                case InflateBlockMode.TYPE:
                {
                    for (; i < 3; i += 8)
                    {
                        if (num2 == 0)
                        {
                            bitb = num3;
                            bitk = i;
                            _codec.AvailableBytesIn = num2;
                            _codec.TotalBytesIn    += num - _codec.NextIn;
                            _codec.NextIn           = num;
                            writeAt = num4;
                            return(Flush(r));
                        }
                        r = 0;
                        num2--;
                        num3 |= (_codec.InputBuffer[num++] & 0xFF) << i;
                    }
                    int num7 = num3 & 7;
                    last = (num7 & 1);
                    switch ((uint)num7 >> 1)
                    {
                    case 0u:
                        num3 >>= 3;
                        i     -= 3;
                        num7   = (i & 7);
                        num3 >>= num7;
                        i     -= num7;
                        mode   = InflateBlockMode.LENS;
                        break;

                    case 1u:
                    {
                        int[]   array  = new int[1];
                        int[]   array2 = new int[1];
                        int[][] array3 = new int[1][];
                        int[][] array4 = new int[1][];
                        InfTree.inflate_trees_fixed(array, array2, array3, array4, _codec);
                        codes.Init(array[0], array2[0], array3[0], 0, array4[0], 0);
                        num3 >>= 3;
                        i     -= 3;
                        mode   = InflateBlockMode.CODES;
                        break;
                    }

                    case 2u:
                        num3 >>= 3;
                        i     -= 3;
                        mode   = InflateBlockMode.TABLE;
                        break;

                    case 3u:
                        num3                  >>= 3;
                        i                      -= 3;
                        mode                    = InflateBlockMode.BAD;
                        _codec.Message          = "invalid block type";
                        r                       = -3;
                        bitb                    = num3;
                        bitk                    = i;
                        _codec.AvailableBytesIn = num2;
                        _codec.TotalBytesIn    += num - _codec.NextIn;
                        _codec.NextIn           = num;
                        writeAt                 = num4;
                        return(Flush(r));
                    }
                    break;
                }

                case InflateBlockMode.LENS:
                    for (; i < 32; i += 8)
                    {
                        if (num2 == 0)
                        {
                            bitb = num3;
                            bitk = i;
                            _codec.AvailableBytesIn = num2;
                            _codec.TotalBytesIn    += num - _codec.NextIn;
                            _codec.NextIn           = num;
                            writeAt = num4;
                            return(Flush(r));
                        }
                        r = 0;
                        num2--;
                        num3 |= (_codec.InputBuffer[num++] & 0xFF) << i;
                    }
                    if (((~num3 >> 16) & 0xFFFF) != (num3 & 0xFFFF))
                    {
                        mode           = InflateBlockMode.BAD;
                        _codec.Message = "invalid stored block lengths";
                        r    = -3;
                        bitb = num3;
                        bitk = i;
                        _codec.AvailableBytesIn = num2;
                        _codec.TotalBytesIn    += num - _codec.NextIn;
                        _codec.NextIn           = num;
                        writeAt = num4;
                        return(Flush(r));
                    }
                    left = (num3 & 0xFFFF);
                    num3 = (i = 0);
                    mode = ((left != 0) ? InflateBlockMode.STORED : ((last != 0) ? InflateBlockMode.DRY : InflateBlockMode.TYPE));
                    break;

                case InflateBlockMode.STORED:
                {
                    if (num2 == 0)
                    {
                        bitb = num3;
                        bitk = i;
                        _codec.AvailableBytesIn = num2;
                        _codec.TotalBytesIn    += num - _codec.NextIn;
                        _codec.NextIn           = num;
                        writeAt = num4;
                        return(Flush(r));
                    }
                    if (num5 == 0)
                    {
                        if (num4 == end && readAt != 0)
                        {
                            num4 = 0;
                            num5 = ((num4 >= readAt) ? (end - num4) : (readAt - num4 - 1));
                        }
                        if (num5 == 0)
                        {
                            writeAt = num4;
                            r       = Flush(r);
                            num4    = writeAt;
                            num5    = ((num4 >= readAt) ? (end - num4) : (readAt - num4 - 1));
                            if (num4 == end && readAt != 0)
                            {
                                num4 = 0;
                                num5 = ((num4 >= readAt) ? (end - num4) : (readAt - num4 - 1));
                            }
                            if (num5 == 0)
                            {
                                bitb = num3;
                                bitk = i;
                                _codec.AvailableBytesIn = num2;
                                _codec.TotalBytesIn    += num - _codec.NextIn;
                                _codec.NextIn           = num;
                                writeAt = num4;
                                return(Flush(r));
                            }
                        }
                    }
                    r = 0;
                    int num7 = left;
                    if (num7 > num2)
                    {
                        num7 = num2;
                    }
                    if (num7 > num5)
                    {
                        num7 = num5;
                    }
                    Array.Copy(_codec.InputBuffer, num, window, num4, num7);
                    num  += num7;
                    num2 -= num7;
                    num4 += num7;
                    num5 -= num7;
                    if ((left -= num7) == 0)
                    {
                        mode = ((last != 0) ? InflateBlockMode.DRY : InflateBlockMode.TYPE);
                    }
                    break;
                }

                case InflateBlockMode.TABLE:
                {
                    for (; i < 14; i += 8)
                    {
                        if (num2 == 0)
                        {
                            bitb = num3;
                            bitk = i;
                            _codec.AvailableBytesIn = num2;
                            _codec.TotalBytesIn    += num - _codec.NextIn;
                            _codec.NextIn           = num;
                            writeAt = num4;
                            return(Flush(r));
                        }
                        r = 0;
                        num2--;
                        num3 |= (_codec.InputBuffer[num++] & 0xFF) << i;
                    }
                    int num7 = table = (num3 & 0x3FFF);
                    if ((num7 & 0x1F) > 29 || ((num7 >> 5) & 0x1F) > 29)
                    {
                        mode           = InflateBlockMode.BAD;
                        _codec.Message = "too many length or distance symbols";
                        r    = -3;
                        bitb = num3;
                        bitk = i;
                        _codec.AvailableBytesIn = num2;
                        _codec.TotalBytesIn    += num - _codec.NextIn;
                        _codec.NextIn           = num;
                        writeAt = num4;
                        return(Flush(r));
                    }
                    num7 = 258 + (num7 & 0x1F) + ((num7 >> 5) & 0x1F);
                    if (blens == null || blens.Length < num7)
                    {
                        blens = new int[num7];
                    }
                    else
                    {
                        Array.Clear(blens, 0, num7);
                    }
                    num3 >>= 14;
                    i     -= 14;
                    index  = 0;
                    mode   = InflateBlockMode.BTREE;
                    goto case InflateBlockMode.BTREE;
                }

                case InflateBlockMode.BTREE:
                {
                    while (index < 4 + (table >> 10))
                    {
                        for (; i < 3; i += 8)
                        {
                            if (num2 == 0)
                            {
                                bitb = num3;
                                bitk = i;
                                _codec.AvailableBytesIn = num2;
                                _codec.TotalBytesIn    += num - _codec.NextIn;
                                _codec.NextIn           = num;
                                writeAt = num4;
                                return(Flush(r));
                            }
                            r = 0;
                            num2--;
                            num3 |= (_codec.InputBuffer[num++] & 0xFF) << i;
                        }
                        blens[border[index++]] = (num3 & 7);
                        num3 >>= 3;
                        i     -= 3;
                    }
                    while (index < 19)
                    {
                        blens[border[index++]] = 0;
                    }
                    bb[0] = 7;
                    int num7 = inftree.inflate_trees_bits(blens, bb, tb, hufts, _codec);
                    if (num7 != 0)
                    {
                        r = num7;
                        if (r == -3)
                        {
                            blens = null;
                            mode  = InflateBlockMode.BAD;
                        }
                        bitb = num3;
                        bitk = i;
                        _codec.AvailableBytesIn = num2;
                        _codec.TotalBytesIn    += num - _codec.NextIn;
                        _codec.NextIn           = num;
                        writeAt = num4;
                        return(Flush(r));
                    }
                    index = 0;
                    mode  = InflateBlockMode.DTREE;
                    goto case InflateBlockMode.DTREE;
                }

                case InflateBlockMode.DTREE:
                {
                    int num7;
                    while (true)
                    {
                        num7 = table;
                        if (index >= 258 + (num7 & 0x1F) + ((num7 >> 5) & 0x1F))
                        {
                            break;
                        }
                        for (num7 = bb[0]; i < num7; i += 8)
                        {
                            if (num2 == 0)
                            {
                                bitb = num3;
                                bitk = i;
                                _codec.AvailableBytesIn = num2;
                                _codec.TotalBytesIn    += num - _codec.NextIn;
                                _codec.NextIn           = num;
                                writeAt = num4;
                                return(Flush(r));
                            }
                            r = 0;
                            num2--;
                            num3 |= (_codec.InputBuffer[num++] & 0xFF) << i;
                        }
                        num7 = hufts[(tb[0] + (num3 & InternalInflateConstants.InflateMask[num7])) * 3 + 1];
                        int num11 = hufts[(tb[0] + (num3 & InternalInflateConstants.InflateMask[num7])) * 3 + 2];
                        if (num11 < 16)
                        {
                            num3         >>= num7;
                            i             -= num7;
                            blens[index++] = num11;
                        }
                        else
                        {
                            int num12 = (num11 != 18) ? (num11 - 14) : 7;
                            int num13 = (num11 != 18) ? 3 : 11;
                            for (; i < num7 + num12; i += 8)
                            {
                                if (num2 == 0)
                                {
                                    bitb = num3;
                                    bitk = i;
                                    _codec.AvailableBytesIn = num2;
                                    _codec.TotalBytesIn    += num - _codec.NextIn;
                                    _codec.NextIn           = num;
                                    writeAt = num4;
                                    return(Flush(r));
                                }
                                r = 0;
                                num2--;
                                num3 |= (_codec.InputBuffer[num++] & 0xFF) << i;
                            }
                            num3 >>= num7;
                            i     -= num7;
                            num13 += (num3 & InternalInflateConstants.InflateMask[num12]);
                            num3 >>= num12;
                            i     -= num12;
                            num12  = index;
                            num7   = table;
                            if (num12 + num13 > 258 + (num7 & 0x1F) + ((num7 >> 5) & 0x1F) || (num11 == 16 && num12 < 1))
                            {
                                blens          = null;
                                mode           = InflateBlockMode.BAD;
                                _codec.Message = "invalid bit length repeat";
                                r    = -3;
                                bitb = num3;
                                bitk = i;
                                _codec.AvailableBytesIn = num2;
                                _codec.TotalBytesIn    += num - _codec.NextIn;
                                _codec.NextIn           = num;
                                writeAt = num4;
                                return(Flush(r));
                            }
                            num11 = ((num11 == 16) ? blens[num12 - 1] : 0);
                            do
                            {
                                blens[num12++] = num11;
                            }while (--num13 != 0);
                            index = num12;
                        }
                    }
                    tb[0] = -1;
                    int[] array5 = new int[1]
                    {
                        9
                    };
                    int[] array6 = new int[1]
                    {
                        6
                    };
                    int[] array7 = new int[1];
                    int[] array8 = new int[1];
                    num7 = table;
                    num7 = inftree.inflate_trees_dynamic(257 + (num7 & 0x1F), 1 + ((num7 >> 5) & 0x1F), blens, array5, array6, array7, array8, hufts, _codec);
                    switch (num7)
                    {
                    case -3:
                        blens = null;
                        mode  = InflateBlockMode.BAD;
                        goto default;

                    default:
                        r    = num7;
                        bitb = num3;
                        bitk = i;
                        _codec.AvailableBytesIn = num2;
                        _codec.TotalBytesIn    += num - _codec.NextIn;
                        _codec.NextIn           = num;
                        writeAt = num4;
                        return(Flush(r));

                    case 0:
                        break;
                    }
                    codes.Init(array5[0], array6[0], hufts, array7[0], hufts, array8[0]);
                    mode = InflateBlockMode.CODES;
                    goto case InflateBlockMode.CODES;
                }

                case InflateBlockMode.CODES:
                    bitb = num3;
                    bitk = i;
                    _codec.AvailableBytesIn = num2;
                    _codec.TotalBytesIn    += num - _codec.NextIn;
                    _codec.NextIn           = num;
                    writeAt = num4;
                    r       = codes.Process(this, r);
                    if (r != 1)
                    {
                        return(Flush(r));
                    }
                    r    = 0;
                    num  = _codec.NextIn;
                    num2 = _codec.AvailableBytesIn;
                    num3 = bitb;
                    i    = bitk;
                    num4 = writeAt;
                    num5 = ((num4 >= readAt) ? (end - num4) : (readAt - num4 - 1));
                    if (last == 0)
                    {
                        mode = InflateBlockMode.TYPE;
                        break;
                    }
                    mode = InflateBlockMode.DRY;
                    goto case InflateBlockMode.DRY;

                case InflateBlockMode.DRY:
                    writeAt = num4;
                    r       = Flush(r);
                    num4    = writeAt;
                    num5    = ((num4 >= readAt) ? (end - num4) : (readAt - num4 - 1));
                    if (readAt != writeAt)
                    {
                        bitb = num3;
                        bitk = i;
                        _codec.AvailableBytesIn = num2;
                        _codec.TotalBytesIn    += num - _codec.NextIn;
                        _codec.NextIn           = num;
                        writeAt = num4;
                        return(Flush(r));
                    }
                    mode = InflateBlockMode.DONE;
                    goto case InflateBlockMode.DONE;

                case InflateBlockMode.DONE:
                    r    = 1;
                    bitb = num3;
                    bitk = i;
                    _codec.AvailableBytesIn = num2;
                    _codec.TotalBytesIn    += num - _codec.NextIn;
                    _codec.NextIn           = num;
                    writeAt = num4;
                    return(Flush(r));

                case InflateBlockMode.BAD:
                    r    = -3;
                    bitb = num3;
                    bitk = i;
                    _codec.AvailableBytesIn = num2;
                    _codec.TotalBytesIn    += num - _codec.NextIn;
                    _codec.NextIn           = num;
                    writeAt = num4;
                    return(Flush(r));

                default:
                    r    = -2;
                    bitb = num3;
                    bitk = i;
                    _codec.AvailableBytesIn = num2;
                    _codec.TotalBytesIn    += num - _codec.NextIn;
                    _codec.NextIn           = num;
                    writeAt = num4;
                    return(Flush(r));
                }
            }
        }
Example #4
0
        // Token: 0x06000792 RID: 1938 RVA: 0x00041C24 File Offset: 0x0003FE24
        internal int Process(int r)
        {
            int num  = this._codec.NextIn;
            int num2 = this._codec.AvailableBytesIn;
            int num3 = this.bitb;
            int i    = this.bitk;
            int num4 = this.writeAt;
            int num5 = (num4 < this.readAt) ? (this.readAt - num4 - 1) : (this.end - num4);
            int num6;

            for (;;)
            {
                switch (this.mode)
                {
                case InflateBlocks.InflateBlockMode.TYPE:
                    while (i < 3)
                    {
                        if (num2 == 0)
                        {
                            goto IL_928;
                        }
                        r = 0;
                        num2--;
                        num3 |= (int)(this._codec.InputBuffer[num++] & byte.MaxValue) << i;
                        i    += 8;
                    }
                    num6      = (num3 & 7);
                    this.last = (num6 & 1);
                    switch ((uint)num6 >> 1)
                    {
                    case 0U:
                        num3    >>= 3;
                        i        -= 3;
                        num6      = (i & 7);
                        num3    >>= num6;
                        i        -= num6;
                        this.mode = InflateBlocks.InflateBlockMode.LENS;
                        continue;

                    case 1U:
                    {
                        int[]   array  = new int[1];
                        int[]   array2 = new int[1];
                        int[][] array3 = new int[1][];
                        int[][] array4 = new int[1][];
                        InfTree.inflate_trees_fixed(array, array2, array3, array4, this._codec);
                        this.codes.Init(array[0], array2[0], array3[0], 0, array4[0], 0);
                        num3    >>= 3;
                        i        -= 3;
                        this.mode = InflateBlocks.InflateBlockMode.CODES;
                        continue;
                    }

                    case 2U:
                        num3    >>= 3;
                        i        -= 3;
                        this.mode = InflateBlocks.InflateBlockMode.TABLE;
                        continue;

                    case 3U:
                        goto IL_8AD;

                    default:
                        continue;
                    }
                    break;

                case InflateBlocks.InflateBlockMode.LENS:
                {
                    while (i < 32)
                    {
                        if (num2 == 0)
                        {
                            goto IL_9F1;
                        }
                        r = 0;
                        num2--;
                        num3 |= (int)(this._codec.InputBuffer[num++] & byte.MaxValue) << i;
                        i    += 8;
                    }
                    if ((~num3 >> 16 & 65535) != (num3 & 65535))
                    {
                        goto Block_45;
                    }
                    this.left = (num3 & 65535);
                    int num7 = 0;
                    i         = 0;
                    num3      = num7;
                    this.mode = ((this.left != 0) ? InflateBlocks.InflateBlockMode.STORED : ((this.last != 0) ? InflateBlocks.InflateBlockMode.DRY : InflateBlocks.InflateBlockMode.TYPE));
                    continue;
                }

                case InflateBlocks.InflateBlockMode.STORED:
                    if (num2 == 0)
                    {
                        goto IL_A47;
                    }
                    if (num5 == 0)
                    {
                        if (num4 == this.end && this.readAt != 0)
                        {
                            num4 = 0;
                            num5 = ((0 < this.readAt) ? (this.readAt - num4 - 1) : (this.end - num4));
                        }
                        if (num5 == 0)
                        {
                            this.writeAt = num4;
                            r            = this.Flush(r);
                            num4         = this.writeAt;
                            num5         = ((num4 < this.readAt) ? (this.readAt - num4 - 1) : (this.end - num4));
                            if (num4 == this.end && this.readAt != 0)
                            {
                                num4 = 0;
                                num5 = ((0 < this.readAt) ? (this.readAt - num4 - 1) : (this.end - num4));
                            }
                            if (num5 == 0)
                            {
                                goto IL_A9D;
                            }
                        }
                    }
                    r    = 0;
                    num6 = this.left;
                    if (num6 > num2)
                    {
                        num6 = num2;
                    }
                    if (num6 > num5)
                    {
                        num6 = num5;
                    }
                    Array.Copy(this._codec.InputBuffer, num, this.window, num4, num6);
                    num  += num6;
                    num2 -= num6;
                    num4 += num6;
                    num5 -= num6;
                    if ((this.left -= num6) == 0)
                    {
                        this.mode = ((this.last != 0) ? InflateBlocks.InflateBlockMode.DRY : InflateBlocks.InflateBlockMode.TYPE);
                        continue;
                    }
                    continue;

                case InflateBlocks.InflateBlockMode.TABLE:
                    while (i < 14)
                    {
                        if (num2 == 0)
                        {
                            goto IL_B66;
                        }
                        r = 0;
                        num2--;
                        num3 |= (int)(this._codec.InputBuffer[num++] & byte.MaxValue) << i;
                        i    += 8;
                    }
                    num6 = (this.table = (num3 & 16383));
                    if ((num6 & 31) <= 29 && (num6 >> 5 & 31) <= 29)
                    {
                        num6 = 258 + (num6 & 31) + (num6 >> 5 & 31);
                        if (this.blens != null && this.blens.Length >= num6)
                        {
                            Array.Clear(this.blens, 0, num6);
                        }
                        else
                        {
                            this.blens = new int[num6];
                        }
                        num3     >>= 14;
                        i         -= 14;
                        this.index = 0;
                        this.mode  = InflateBlocks.InflateBlockMode.BTREE;
                        goto IL_40A;
                    }
                    goto IL_AF3;

                case InflateBlocks.InflateBlockMode.BTREE:
                    goto IL_40A;

                case InflateBlocks.InflateBlockMode.DTREE:
                    goto IL_2CC;

                case InflateBlocks.InflateBlockMode.CODES:
                    goto IL_55;

                case InflateBlocks.InflateBlockMode.DRY:
                    goto IL_E24;

                case InflateBlocks.InflateBlockMode.DONE:
                    goto IL_ECA;

                case InflateBlocks.InflateBlockMode.BAD:
                    goto IL_F23;
                }
                goto Block_51;
                for (;;)
                {
IL_2CC:
                    num6 = this.table;
                    if (this.index >= 258 + (num6 & 31) + (num6 >> 5 & 31))
                    {
                        break;
                    }
                    num6 = this.bb[0];
                    while (i < num6)
                    {
                        if (num2 == 0)
                        {
                            goto IL_D50;
                        }
                        r = 0;
                        num2--;
                        num3 |= (int)(this._codec.InputBuffer[num++] & byte.MaxValue) << i;
                        i    += 8;
                    }
                    num6 = this.hufts[(this.tb[0] + (num3 & InternalInflateConstants.InflateMask[num6])) * 3 + 1];
                    int num8 = this.hufts[(this.tb[0] + (num3 & InternalInflateConstants.InflateMask[num6])) * 3 + 2];
                    if (num8 < 16)
                    {
                        num3 >>= num6;
                        i     -= num6;
                        this.blens[this.index++] = num8;
                    }
                    else
                    {
                        int num9  = (num8 == 18) ? 7 : (num8 - 14);
                        int num10 = (num8 == 18) ? 11 : 3;
                        while (i < num6 + num9)
                        {
                            if (num2 == 0)
                            {
                                goto IL_CFA;
                            }
                            r = 0;
                            num2--;
                            num3 |= (int)(this._codec.InputBuffer[num++] & byte.MaxValue) << i;
                            i    += 8;
                        }
                        num3 >>= num6;
                        i     -= num6;
                        num10 += (num3 & InternalInflateConstants.InflateMask[num9]);
                        num3 >>= num9;
                        i     -= num9;
                        num9   = this.index;
                        num6   = this.table;
                        if (num9 + num10 > 258 + (num6 & 31) + (num6 >> 5 & 31) || (num8 == 16 && num9 < 1))
                        {
                            goto IL_C80;
                        }
                        num8 = ((num8 == 16) ? this.blens[num9 - 1] : 0);
                        do
                        {
                            this.blens[num9++] = num8;
                        }while (--num10 != 0);
                        this.index = num9;
                    }
                }
                this.tb[0] = -1;
                int[] array5 = new int[]
                {
                    9
                };
                int[] array6 = new int[]
                {
                    6
                };
                int[] array7 = new int[1];
                int[] array8 = new int[1];
                num6 = this.table;
                num6 = this.inftree.inflate_trees_dynamic(257 + (num6 & 31), 1 + (num6 >> 5 & 31), this.blens, array5, array6, array7, array8, this.hufts, this._codec);
                if (num6 == 0)
                {
                    this.codes.Init(array5[0], array6[0], this.hufts, array7[0], this.hufts, array8[0]);
                    this.mode = InflateBlocks.InflateBlockMode.CODES;
                    goto IL_55;
                }
                goto IL_DA6;
IL_40A:
                while (this.index < 4 + (this.table >> 10))
                {
                    while (i < 3)
                    {
                        if (num2 == 0)
                        {
                            goto IL_C2A;
                        }
                        r = 0;
                        num2--;
                        num3 |= (int)(this._codec.InputBuffer[num++] & byte.MaxValue) << i;
                        i    += 8;
                    }
                    this.blens[InflateBlocks.border[this.index++]] = (num3 & 7);
                    num3 >>= 3;
                    i     -= 3;
                }
                while (this.index < 19)
                {
                    this.blens[InflateBlocks.border[this.index++]] = 0;
                }
                this.bb[0] = 7;
                num6       = this.inftree.inflate_trees_bits(this.blens, this.bb, this.tb, this.hufts, this._codec);
                if (num6 == 0)
                {
                    this.index = 0;
                    this.mode  = InflateBlocks.InflateBlockMode.DTREE;
                    goto IL_2CC;
                }
                goto IL_BBC;
IL_55:
                this.bitb = num3;
                this.bitk = i;
                this._codec.AvailableBytesIn = num2;
                this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
                this._codec.NextIn           = num;
                this.writeAt = num4;
                r            = this.codes.Process(this, r);
                if (r != 1)
                {
                    break;
                }
                r    = 0;
                num  = this._codec.NextIn;
                num2 = this._codec.AvailableBytesIn;
                num3 = this.bitb;
                i    = this.bitk;
                num4 = this.writeAt;
                num5 = ((num4 < this.readAt) ? (this.readAt - num4 - 1) : (this.end - num4));
                if (this.last != 0)
                {
                    goto IL_E1D;
                }
                this.mode = InflateBlocks.InflateBlockMode.TYPE;
            }
            return(this.Flush(r));

Block_45:
            this.mode           = InflateBlocks.InflateBlockMode.BAD;
            this._codec.Message = "invalid stored block lengths";
            r         = -3;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(-3));

Block_51:
            r         = -2;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(-2));

IL_8AD:
            num3                       >>= 3;
            i                           -= 3;
            this.mode                    = InflateBlocks.InflateBlockMode.BAD;
            this._codec.Message          = "invalid block type";
            r                            = -3;
            this.bitb                    = num3;
            this.bitk                    = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt                 = num4;
            return(this.Flush(-3));

IL_928:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_9F1:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_A47:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_A9D:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_AF3:
            this.mode           = InflateBlocks.InflateBlockMode.BAD;
            this._codec.Message = "too many length or distance symbols";
            r         = -3;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(-3));

IL_B66:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_BBC:
            r = num6;
            if (r == -3)
            {
                this.blens = null;
                this.mode  = InflateBlocks.InflateBlockMode.BAD;
            }
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_C2A:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_C80:
            this.blens          = null;
            this.mode           = InflateBlocks.InflateBlockMode.BAD;
            this._codec.Message = "invalid bit length repeat";
            r         = -3;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(-3));

IL_CFA:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_D50:
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_DA6:
            if (num6 == -3)
            {
                this.blens = null;
                this.mode  = InflateBlocks.InflateBlockMode.BAD;
            }
            r         = num6;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(r));

IL_E1D:
            this.mode = InflateBlocks.InflateBlockMode.DRY;
IL_E24:
            this.writeAt = num4;
            r            = this.Flush(r);
            num4         = this.writeAt;
            int num11 = (num4 < this.readAt) ? (this.readAt - num4 - 1) : (this.end - num4);

            if (this.readAt != this.writeAt)
            {
                this.bitb = num3;
                this.bitk = i;
                this._codec.AvailableBytesIn = num2;
                this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
                this._codec.NextIn           = num;
                this.writeAt = num4;
                return(this.Flush(r));
            }
            this.mode = InflateBlocks.InflateBlockMode.DONE;
IL_ECA:
            r         = 1;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(1));

IL_F23:
            r         = -3;
            this.bitb = num3;
            this.bitk = i;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += (long)(num - this._codec.NextIn);
            this._codec.NextIn           = num;
            this.writeAt = num4;
            return(this.Flush(-3));
        }
Example #5
0
        internal int Process(int r)
        {
            int t;                                               // temporary storage
            int nextIn  = _NextIn;                               // input data pointer
            int availIn = _AvailIn;                              // bytes available there
            int bits    = bitb;                                  // bit buffer
            int bitsNum = bitk;                                  // bits in bit buffer
            int q       = writeAt;                               // output window write pointer
            int m       = q < readAt ? readAt - q - 1 : end - q; // bytes to end of window or read pointer

            // process input based on current state
            while (true)
            {
                switch (mode)
                {
                case InflateBlockMode.TYPE:
                    while (bitsNum < 3)
                    {
                        if (availIn != 0)
                        {
                            r = RCode.Okay;
                        }
                        else
                        {
                            return(RanOutOfInput(bits, bitsNum, availIn, nextIn, q, r));
                        }

                        availIn--;
                        bits    |= InputBuffer[nextIn++] << bitsNum;
                        bitsNum += 8;
                    }

                    last = bits & 0x1;
                    switch ((bits & 0x7) >> 1)
                    {
                    case 0:                                      // stored
                        bits >>= 3; bitsNum -= 3;
                        t      = bitsNum & 7;                    // go to byte boundary
                        bits >>= t; bitsNum -= t;
                        mode   = InflateBlockMode.LENS;          // get length of stored block
                        break;

                    case 1:                                      // fixed
                        int   bl, bd;
                        int[] tl, td;
                        InfTree.InflateTreesFixed(out bl, out bd, out tl, out td);
                        codes.Init(bl, bd, tl, 0, td, 0);
                        bits >>= 3; bitsNum -= 3;
                        mode   = InflateBlockMode.CODES;
                        break;

                    case 2:                                      // dynamic
                        bits >>= 3; bitsNum -= 3;
                        mode   = InflateBlockMode.TABLE;
                        break;

                    case 3:                                      // illegal
                        throw new InvalidDataException("invalid block type");
                    }
                    break;

                case InflateBlockMode.LENS:
                    while (bitsNum < 32)
                    {
                        if (availIn != 0)
                        {
                            r = RCode.Okay;
                        }
                        else
                        {
                            return(RanOutOfInput(bits, bitsNum, availIn, nextIn, q, r));
                        }
                        availIn--;
                        bits    |= InputBuffer[nextIn++] << bitsNum;
                        bitsNum += 8;
                    }

                    if (((~bits >> 16) & 0xffff) != (bits & 0xffff))
                    {
                        throw new InvalidDataException("invalid stored block lengths");
                    }
                    left = bits & 0xffff;
                    bits = bitsNum = 0;                             // dump bits
                    mode = left != 0 ? InflateBlockMode.STORED : (last != 0 ? InflateBlockMode.DRY : InflateBlockMode.TYPE);
                    break;

                case InflateBlockMode.STORED:
                    if (availIn == 0)
                    {
                        return(RanOutOfInput(bits, bitsNum, availIn, nextIn, q, r));
                    }

                    if (m == 0)
                    {
                        if (q == end && readAt != 0)
                        {
                            q = 0;
                            m = q < readAt ? readAt - q - 1 : end - q;
                        }
                        if (m == 0)
                        {
                            writeAt = q;
                            r       = Flush(r);
                            q       = writeAt;
                            m       = q < readAt ? readAt - q - 1 : end - q;

                            if (q == end && readAt != 0)
                            {
                                q = 0;
                                m = q < readAt ? readAt - q - 1 : end - q;
                            }
                            if (m == 0)
                            {
                                return(RanOutOfInput(bits, bitsNum, availIn, nextIn, q, r));
                            }
                        }
                    }
                    r = RCode.Okay;

                    t = left;
                    if (t > availIn)
                    {
                        t = availIn;
                    }
                    if (t > m)
                    {
                        t = m;
                    }
                    Array.Copy(InputBuffer, nextIn, window, q, t);
                    nextIn += t; availIn -= t;
                    q      += t; m -= t;
                    if ((left -= t) != 0)
                    {
                        break;
                    }
                    mode = last != 0 ? InflateBlockMode.DRY : InflateBlockMode.TYPE;
                    break;

                case InflateBlockMode.TABLE:
                    while (bitsNum < 14)
                    {
                        if (availIn != 0)
                        {
                            r = RCode.Okay;
                        }
                        else
                        {
                            return(RanOutOfInput(bits, bitsNum, availIn, nextIn, q, r));
                        }

                        availIn--;
                        bits    |= InputBuffer[nextIn++] << bitsNum;
                        bitsNum += 8;
                    }

                    table = t = (bits & 0x3fff);
                    if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
                    {
                        throw new InvalidDataException("too many length or distance symbols");
                    }

                    t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
                    if (blens == null || blens.Length < t)
                    {
                        blens = new int[t];
                    }
                    else
                    {
                        Array.Clear(blens, 0, t);
                    }

                    bits   >>= 14;
                    bitsNum -= 14;

                    index = 0;
                    mode  = InflateBlockMode.BTREE;
                    goto case InflateBlockMode.BTREE;

                case InflateBlockMode.BTREE:
                    while (index < 4 + (table >> 10))
                    {
                        while (bitsNum < 3)
                        {
                            if (availIn != 0)
                            {
                                r = RCode.Okay;
                            }
                            else
                            {
                                return(RanOutOfInput(bits, bitsNum, availIn, nextIn, q, r));
                            }

                            availIn--;
                            bits    |= InputBuffer[nextIn++] << bitsNum;
                            bitsNum += 8;
                        }

                        blens[border[index++]] = bits & 7;
                        bits >>= 3; bitsNum -= 3;
                    }

                    while (index < 19)
                    {
                        blens[border[index++]] = 0;
                    }

                    bb = 7;
                    inftree.InflateTreeBits(blens, ref bb, ref tb, hufts);
                    index = 0;
                    mode  = InflateBlockMode.DTREE;
                    goto case InflateBlockMode.DTREE;

                case InflateBlockMode.DTREE:
                    while (true)
                    {
                        t = table;
                        if (!(index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f)))
                        {
                            break;
                        }
                        t = bb;

                        while (bitsNum < t)
                        {
                            if (availIn != 0)
                            {
                                r = RCode.Okay;
                            }
                            else
                            {
                                return(RanOutOfInput(bits, bitsNum, availIn, nextIn, q, r));
                            }

                            availIn--;
                            bits    |= InputBuffer[nextIn++] << bitsNum;
                            bitsNum += 8;
                        }

                        t = hufts[(tb + (bits & Constants.InflateMask[t])) * 3 + 1];
                        int c = hufts[(tb + (bits & Constants.InflateMask[t])) * 3 + 2];

                        if (c < 16)
                        {
                            bits         >>= t; bitsNum -= t;
                            blens[index++] = c;
                        }
                        else
                        {
                            // c == 16..18
                            int i = c == 18 ? 7 : c - 14;
                            int j = c == 18 ? 11 : 3;

                            while (bitsNum < (t + i))
                            {
                                if (availIn != 0)
                                {
                                    r = RCode.Okay;
                                }
                                else
                                {
                                    return(RanOutOfInput(bits, bitsNum, availIn, nextIn, q, r));
                                }

                                availIn--;
                                bits    |= InputBuffer[nextIn++] << bitsNum;
                                bitsNum += 8;
                            }

                            bits >>= t; bitsNum -= t;
                            j     += (bits & Constants.InflateMask[i]);
                            bits >>= i; bitsNum -= i;

                            i = index;
                            if (i + j > 258 + (table & 0x1f) + ((table >> 5) & 0x1f) || (c == 16 && i < 1))
                            {
                                throw new InvalidDataException("invalid bit length repeat");
                            }

                            c = (c == 16) ? blens[i - 1] : 0;
                            do
                            {
                                blens[i++] = c;
                            } while (--j != 0);
                            index = i;
                        }
                    }

                    tb = -1;
                    {
                        int bl = 9;                                 // must be <= 9 for lookahead assumptions
                        int bd = 6;                                 // must be <= 9 for lookahead assumptions
                        int tl = 0;
                        int td = 0;
                        inftree.InflateTreesDynamic(257 + (table & 0x1f), 1 + ((table >> 5) & 0x1f), blens,
                                                    ref bl, ref bd, ref tl, ref td, hufts);
                        codes.Init(bl, bd, hufts, tl, hufts, td);
                    }
                    mode = InflateBlockMode.CODES;
                    goto case InflateBlockMode.CODES;

                case InflateBlockMode.CODES:
                    UpdateState(bits, bitsNum, availIn, nextIn, q);

                    r = codes.Process(this, r);
                    if (r != RCode.StreamEnd)
                    {
                        return(Flush(r));
                    }

                    r       = RCode.Okay;
                    nextIn  = _NextIn;
                    availIn = _AvailIn;
                    bits    = bitb;
                    bitsNum = bitk;
                    q       = writeAt;
                    m       = q < readAt ? readAt - q - 1 : end - q;

                    if (last == 0)
                    {
                        mode = InflateBlockMode.TYPE;
                        break;
                    }
                    mode = InflateBlockMode.DRY;
                    goto case InflateBlockMode.DRY;

                case InflateBlockMode.DRY:
                    writeAt = q;
                    r       = Flush(r);
                    q       = writeAt;
                    m       = q < readAt ? readAt - q - 1 : end - q;
                    if (readAt != writeAt)
                    {
                        return(RanOutOfInput(bits, bitsNum, availIn, nextIn, q, r));
                    }
                    mode = InflateBlockMode.DONE;
                    goto case InflateBlockMode.DONE;

                case InflateBlockMode.DONE:
                    return(RanOutOfInput(bits, bitsNum, availIn, nextIn, q, RCode.StreamEnd));

                default:
                    throw new InvalidOperationException("Invalid inflate block mode: " + mode);
                }
            }
        }
Example #6
0
        internal int Process(int r)
        {
            int sourceIndex      = this._codec.NextIn;
            int num1             = this._codec.AvailableBytesIn;
            int num2             = this.bitb;
            int num3             = this.bitk;
            int destinationIndex = this.writeAt;
            int num4             = destinationIndex < this.readAt ? this.readAt - destinationIndex - 1 : this.end - destinationIndex;
            int num5;
            int num6;

            while (true)
            {
                bool flag = true;
                switch (this.mode)
                {
                case InflateBlocks.InflateBlockMode.TYPE:
                    while (num3 < 3)
                    {
                        if (num1 != 0)
                        {
                            r = 0;
                            --num1;
                            num2 |= ((int)this._codec.InputBuffer[sourceIndex++] & (int)byte.MaxValue) << num3;
                            num3 += 8;
                        }
                        else
                        {
                            this.bitb = num2;
                            this.bitk = num3;
                            this._codec.AvailableBytesIn = num1;
                            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
                            this._codec.NextIn           = sourceIndex;
                            this.writeAt = destinationIndex;
                            return(this.Flush(r));
                        }
                    }
                    int num7 = num2 & 7;
                    this.last = num7 & 1;
                    switch ((uint)num7 >> 1)
                    {
                    case 0:
                        int num8  = num2 >> 3;
                        int num9  = num3 - 3;
                        int num10 = num9 & 7;
                        num2      = num8 >> num10;
                        num3      = num9 - num10;
                        this.mode = InflateBlocks.InflateBlockMode.LENS;
                        break;

                    case 1:
                        int[]   bl1 = new int[1];
                        int[]   bd1 = new int[1];
                        int[][] tl1 = new int[1][];
                        int[][] td1 = new int[1][];
                        InfTree.inflate_trees_fixed(bl1, bd1, tl1, td1, this._codec);
                        this.codes.Init(bl1[0], bd1[0], tl1[0], 0, td1[0], 0);
                        num2    >>= 3;
                        num3     -= 3;
                        this.mode = InflateBlocks.InflateBlockMode.CODES;
                        break;

                    case 2:
                        num2    >>= 3;
                        num3     -= 3;
                        this.mode = InflateBlocks.InflateBlockMode.TABLE;
                        break;

                    case 3:
                        goto label_9;
                    }
                    break;

                case InflateBlocks.InflateBlockMode.LENS:
                    while (num3 < 32)
                    {
                        if (num1 != 0)
                        {
                            r = 0;
                            --num1;
                            num2 |= ((int)this._codec.InputBuffer[sourceIndex++] & (int)byte.MaxValue) << num3;
                            num3 += 8;
                        }
                        else
                        {
                            this.bitb = num2;
                            this.bitk = num3;
                            this._codec.AvailableBytesIn = num1;
                            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
                            this._codec.NextIn           = sourceIndex;
                            this.writeAt = destinationIndex;
                            return(this.Flush(r));
                        }
                    }
                    if ((~num2 >> 16 & (int)ushort.MaxValue) == (num2 & (int)ushort.MaxValue))
                    {
                        this.left = num2 & (int)ushort.MaxValue;
                        num2      = num3 = 0;
                        this.mode = this.left != 0 ? InflateBlocks.InflateBlockMode.STORED : (this.last != 0 ? InflateBlocks.InflateBlockMode.DRY : InflateBlocks.InflateBlockMode.TYPE);
                        break;
                    }
                    goto label_15;

                case InflateBlocks.InflateBlockMode.STORED:
                    if (num1 != 0)
                    {
                        if (num4 == 0)
                        {
                            if (destinationIndex == this.end && this.readAt != 0)
                            {
                                destinationIndex = 0;
                                num4             = destinationIndex < this.readAt ? this.readAt - destinationIndex - 1 : this.end - destinationIndex;
                            }
                            if (num4 == 0)
                            {
                                this.writeAt     = destinationIndex;
                                r                = this.Flush(r);
                                destinationIndex = this.writeAt;
                                num4             = destinationIndex < this.readAt ? this.readAt - destinationIndex - 1 : this.end - destinationIndex;
                                if (destinationIndex == this.end && this.readAt != 0)
                                {
                                    destinationIndex = 0;
                                    num4             = destinationIndex < this.readAt ? this.readAt - destinationIndex - 1 : this.end - destinationIndex;
                                }
                                if (num4 == 0)
                                {
                                    goto label_26;
                                }
                            }
                        }
                        r = 0;
                        int length = this.left;
                        if (length > num1)
                        {
                            length = num1;
                        }
                        if (length > num4)
                        {
                            length = num4;
                        }
                        Array.Copy((Array)this._codec.InputBuffer, sourceIndex, (Array)this.window, destinationIndex, length);
                        sourceIndex      += length;
                        num1             -= length;
                        destinationIndex += length;
                        num4             -= length;
                        if ((this.left -= length) == 0)
                        {
                            this.mode = this.last != 0 ? InflateBlocks.InflateBlockMode.DRY : InflateBlocks.InflateBlockMode.TYPE;
                            break;
                        }
                        break;
                    }
                    goto label_18;

                case InflateBlocks.InflateBlockMode.TABLE:
                    while (num3 < 14)
                    {
                        if (num1 != 0)
                        {
                            r = 0;
                            --num1;
                            num2 |= ((int)this._codec.InputBuffer[sourceIndex++] & (int)byte.MaxValue) << num3;
                            num3 += 8;
                        }
                        else
                        {
                            this.bitb = num2;
                            this.bitk = num3;
                            this._codec.AvailableBytesIn = num1;
                            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
                            this._codec.NextIn           = sourceIndex;
                            this.writeAt = destinationIndex;
                            return(this.Flush(r));
                        }
                    }
                    int num11;
                    this.table = num11 = num2 & 16383;
                    if ((num11 & 31) <= 29 && (num11 >> 5 & 31) <= 29)
                    {
                        int length = 258 + (num11 & 31) + (num11 >> 5 & 31);
                        if (this.blens == null || this.blens.Length < length)
                        {
                            this.blens = new int[length];
                        }
                        else
                        {
                            Array.Clear((Array)this.blens, 0, length);
                        }
                        num2     >>= 14;
                        num3      -= 14;
                        this.index = 0;
                        this.mode  = InflateBlocks.InflateBlockMode.BTREE;
                        goto case InflateBlocks.InflateBlockMode.BTREE;
                    }
                    else
                    {
                        goto label_39;
                    }

                case InflateBlocks.InflateBlockMode.BTREE:
                    while (this.index < 4 + (this.table >> 10))
                    {
                        while (num3 < 3)
                        {
                            if (num1 != 0)
                            {
                                r = 0;
                                --num1;
                                num2 |= ((int)this._codec.InputBuffer[sourceIndex++] & (int)byte.MaxValue) << num3;
                                num3 += 8;
                            }
                            else
                            {
                                this.bitb = num2;
                                this.bitk = num3;
                                this._codec.AvailableBytesIn = num1;
                                this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
                                this._codec.NextIn           = sourceIndex;
                                this.writeAt = destinationIndex;
                                return(this.Flush(r));
                            }
                        }
                        this.blens[InflateBlocks.border[this.index++]] = num2 & 7;
                        num2 >>= 3;
                        num3  -= 3;
                    }
                    while (this.index < 19)
                    {
                        this.blens[InflateBlocks.border[this.index++]] = 0;
                    }
                    this.bb[0] = 7;
                    num5       = this.inftree.inflate_trees_bits(this.blens, this.bb, this.tb, this.hufts, this._codec);
                    if (num5 == 0)
                    {
                        this.index = 0;
                        this.mode  = InflateBlocks.InflateBlockMode.DTREE;
                        goto case InflateBlocks.InflateBlockMode.DTREE;
                    }
                    else
                    {
                        goto label_53;
                    }

                case InflateBlocks.InflateBlockMode.DTREE:
                    while (true)
                    {
                        flag = true;
                        int num12 = this.table;
                        if (this.index < 258 + (num12 & 31) + (num12 >> 5 & 31))
                        {
                            int index1 = this.bb[0];
                            while (num3 < index1)
                            {
                                if (num1 != 0)
                                {
                                    r = 0;
                                    --num1;
                                    num2 |= ((int)this._codec.InputBuffer[sourceIndex++] & (int)byte.MaxValue) << num3;
                                    num3 += 8;
                                }
                                else
                                {
                                    this.bitb = num2;
                                    this.bitk = num3;
                                    this._codec.AvailableBytesIn = num1;
                                    this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
                                    this._codec.NextIn           = sourceIndex;
                                    this.writeAt = destinationIndex;
                                    return(this.Flush(r));
                                }
                            }
                            int index2 = this.hufts[(this.tb[0] + (num2 & InternalInflateConstants.InflateMask[index1])) * 3 + 1];
                            int num13  = this.hufts[(this.tb[0] + (num2 & InternalInflateConstants.InflateMask[index2])) * 3 + 2];
                            if (num13 < 16)
                            {
                                num2 >>= index2;
                                num3  -= index2;
                                this.blens[this.index++] = num13;
                            }
                            else
                            {
                                int index3 = num13 == 18 ? 7 : num13 - 14;
                                int num14  = num13 == 18 ? 11 : 3;
                                while (num3 < index2 + index3)
                                {
                                    if (num1 != 0)
                                    {
                                        r = 0;
                                        --num1;
                                        num2 |= ((int)this._codec.InputBuffer[sourceIndex++] & (int)byte.MaxValue) << num3;
                                        num3 += 8;
                                    }
                                    else
                                    {
                                        this.bitb = num2;
                                        this.bitk = num3;
                                        this._codec.AvailableBytesIn = num1;
                                        this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
                                        this._codec.NextIn           = sourceIndex;
                                        this.writeAt = destinationIndex;
                                        return(this.Flush(r));
                                    }
                                }
                                int num15 = num2 >> index2;
                                int num16 = num3 - index2;
                                int num17 = num14 + (num15 & InternalInflateConstants.InflateMask[index3]);
                                num2 = num15 >> index3;
                                num3 = num16 - index3;
                                int num18 = this.index;
                                int num19 = this.table;
                                if (num18 + num17 <= 258 + (num19 & 31) + (num19 >> 5 & 31) && (num13 != 16 || num18 >= 1))
                                {
                                    int num20 = num13 == 16 ? this.blens[num18 - 1] : 0;
                                    do
                                    {
                                        this.blens[num18++] = num20;
                                    }while (--num17 != 0);
                                    this.index = num18;
                                }
                                else
                                {
                                    goto label_70;
                                }
                            }
                        }
                        else
                        {
                            break;
                        }
                    }
                    this.tb[0] = -1;
                    int[] bl2 = new int[1]
                    {
                        9
                    };
                    int[] bd2 = new int[1] {
                        6
                    };
                    int[] tl2   = new int[1];
                    int[] td2   = new int[1];
                    int   num21 = this.table;
                    num6 = this.inftree.inflate_trees_dynamic(257 + (num21 & 31), 1 + (num21 >> 5 & 31), this.blens, bl2, bd2, tl2, td2, this.hufts, this._codec);
                    switch (num6)
                    {
                    case 0:
                        this.codes.Init(bl2[0], bd2[0], this.hufts, tl2[0], this.hufts, td2[0]);
                        this.mode = InflateBlocks.InflateBlockMode.CODES;
                        goto label_80;

                    case -3:
                        goto label_77;

                    default:
                        goto label_78;
                    }

                case InflateBlocks.InflateBlockMode.CODES:
label_80:
                    this.bitb = num2;
                    this.bitk = num3;
                    this._codec.AvailableBytesIn = num1;
                    this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
                    this._codec.NextIn           = sourceIndex;
                    this.writeAt = destinationIndex;
                    r            = this.codes.Process(this, r);
                    if (r == 1)
                    {
                        r                = 0;
                        sourceIndex      = this._codec.NextIn;
                        num1             = this._codec.AvailableBytesIn;
                        num2             = this.bitb;
                        num3             = this.bitk;
                        destinationIndex = this.writeAt;
                        num4             = destinationIndex < this.readAt ? this.readAt - destinationIndex - 1 : this.end - destinationIndex;
                        if (this.last == 0)
                        {
                            this.mode = InflateBlocks.InflateBlockMode.TYPE;
                            break;
                        }
                        goto label_84;
                    }
                    else
                    {
                        goto label_81;
                    }

                case InflateBlocks.InflateBlockMode.DRY:
                    goto label_85;

                case InflateBlocks.InflateBlockMode.DONE:
                    goto label_88;

                case InflateBlocks.InflateBlockMode.BAD:
                    goto label_89;

                default:
                    goto label_90;
                }
            }
label_9:
            int num22 = num2 >> 3;
            int num23 = num3 - 3;

            this.mode           = InflateBlocks.InflateBlockMode.BAD;
            this._codec.Message = "invalid block type";
            r         = -3;
            this.bitb = num22;
            this.bitk = num23;
            this._codec.AvailableBytesIn = num1;
            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
            this._codec.NextIn           = sourceIndex;
            this.writeAt = destinationIndex;
            return(this.Flush(r));

label_15:
            this.mode           = InflateBlocks.InflateBlockMode.BAD;
            this._codec.Message = "invalid stored block lengths";
            r         = -3;
            this.bitb = num2;
            this.bitk = num3;
            this._codec.AvailableBytesIn = num1;
            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
            this._codec.NextIn           = sourceIndex;
            this.writeAt = destinationIndex;
            return(this.Flush(r));

label_18:
            this.bitb = num2;
            this.bitk = num3;
            this._codec.AvailableBytesIn = num1;
            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
            this._codec.NextIn           = sourceIndex;
            this.writeAt = destinationIndex;
            return(this.Flush(r));

label_26:
            this.bitb = num2;
            this.bitk = num3;
            this._codec.AvailableBytesIn = num1;
            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
            this._codec.NextIn           = sourceIndex;
            this.writeAt = destinationIndex;
            return(this.Flush(r));

label_39:
            this.mode           = InflateBlocks.InflateBlockMode.BAD;
            this._codec.Message = "too many length or distance symbols";
            r         = -3;
            this.bitb = num2;
            this.bitk = num3;
            this._codec.AvailableBytesIn = num1;
            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
            this._codec.NextIn           = sourceIndex;
            this.writeAt = destinationIndex;
            return(this.Flush(r));

label_53:
            r = num5;
            if (r == -3)
            {
                this.blens = (int[])null;
                this.mode  = InflateBlocks.InflateBlockMode.BAD;
            }
            this.bitb = num2;
            this.bitk = num3;
            this._codec.AvailableBytesIn = num1;
            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
            this._codec.NextIn           = sourceIndex;
            this.writeAt = destinationIndex;
            return(this.Flush(r));

label_70:
            this.blens          = (int[])null;
            this.mode           = InflateBlocks.InflateBlockMode.BAD;
            this._codec.Message = "invalid bit length repeat";
            r         = -3;
            this.bitb = num2;
            this.bitk = num3;
            this._codec.AvailableBytesIn = num1;
            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
            this._codec.NextIn           = sourceIndex;
            this.writeAt = destinationIndex;
            return(this.Flush(r));

label_77:
            this.blens = (int[])null;
            this.mode  = InflateBlocks.InflateBlockMode.BAD;
label_78:
            r         = num6;
            this.bitb = num2;
            this.bitk = num3;
            this._codec.AvailableBytesIn = num1;
            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
            this._codec.NextIn           = sourceIndex;
            this.writeAt = destinationIndex;
            return(this.Flush(r));

label_81:
            return(this.Flush(r));

label_84:
            this.mode = InflateBlocks.InflateBlockMode.DRY;
label_85:
            this.writeAt     = destinationIndex;
            r                = this.Flush(r);
            destinationIndex = this.writeAt;
            int num24 = destinationIndex < this.readAt ? this.readAt - destinationIndex - 1 : this.end - destinationIndex;

            if (this.readAt != this.writeAt)
            {
                this.bitb = num2;
                this.bitk = num3;
                this._codec.AvailableBytesIn = num1;
                this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
                this._codec.NextIn           = sourceIndex;
                this.writeAt = destinationIndex;
                return(this.Flush(r));
            }
            this.mode = InflateBlocks.InflateBlockMode.DONE;
label_88:
            r         = 1;
            this.bitb = num2;
            this.bitk = num3;
            this._codec.AvailableBytesIn = num1;
            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
            this._codec.NextIn           = sourceIndex;
            this.writeAt = destinationIndex;
            return(this.Flush(r));

label_89:
            r         = -3;
            this.bitb = num2;
            this.bitk = num3;
            this._codec.AvailableBytesIn = num1;
            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
            this._codec.NextIn           = sourceIndex;
            this.writeAt = destinationIndex;
            return(this.Flush(r));

label_90:
            r         = -2;
            this.bitb = num2;
            this.bitk = num3;
            this._codec.AvailableBytesIn = num1;
            this._codec.TotalBytesIn    += (long)(sourceIndex - this._codec.NextIn);
            this._codec.NextIn           = sourceIndex;
            this.writeAt = destinationIndex;
            return(this.Flush(r));
        }
Example #7
0
        internal int Process(int r)
        {
            int[] numArray;
            int[] numArray2;
            int   num8;
            bool  flag;
            int   nextIn           = this._codec.NextIn;
            int   availableBytesIn = this._codec.AvailableBytesIn;
            int   bitb             = this.bitb;
            int   bitk             = this.bitk;
            int   write            = this.write;
            int   num7             = (write < this.read) ? ((this.read - write) - 1) : (this.end - write);

            goto Label_11DA;
Label_0933:
            while (this.index < (4 + SharedUtils.URShift(this.table, 10)))
            {
                while (bitk < 3)
                {
                    if (availableBytesIn != 0)
                    {
                        r = 0;
                    }
                    else
                    {
                        this.bitb = bitb;
                        this.bitk = bitk;
                        this._codec.AvailableBytesIn = availableBytesIn;
                        this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                        this._codec.NextIn           = nextIn;
                        this.write = write;
                        return(this.Flush(r));
                    }
                    availableBytesIn--;
                    bitb |= (this._codec.InputBuffer[nextIn++] & 0xff) << bitk;
                    bitk += 8;
                }
                this.blens[border[this.index++]] = bitb & 7;
                bitb  = SharedUtils.URShift(bitb, 3);
                bitk -= 3;
            }
            while (this.index < 0x13)
            {
                this.blens[border[this.index++]] = 0;
            }
            this.bb[0] = 7;
            int index = this.inftree.inflate_trees_bits(this.blens, this.bb, this.tb, this.hufts, this._codec);

            if (index != 0)
            {
                r = index;
                if (r == -3)
                {
                    this.blens = null;
                    this.mode  = 9;
                }
                this.bitb = bitb;
                this.bitk = bitk;
                this._codec.AvailableBytesIn = availableBytesIn;
                this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                this._codec.NextIn           = nextIn;
                this.write = write;
                return(this.Flush(r));
            }
            this.index = 0;
            this.mode  = 5;
Label_0DD2:
            flag  = true;
            index = this.table;
            if (this.index >= ((0x102 + (index & 0x1f)) + ((index >> 5) & 0x1f)))
            {
                this.tb[0] = -1;
                numArray   = new int[] { 9 };
                numArray2  = new int[] { 6 };
                int[] tl = new int[1];
                int[] td = new int[1];
                index = this.table;
                index = this.inftree.inflate_trees_dynamic(0x101 + (index & 0x1f), 1 + ((index >> 5) & 0x1f), this.blens, numArray, numArray2, tl, td, this.hufts, this._codec);
                if (index != 0)
                {
                    if (index == -3)
                    {
                        this.blens = null;
                        this.mode  = 9;
                    }
                    r         = index;
                    this.bitb = bitb;
                    this.bitk = bitk;
                    this._codec.AvailableBytesIn = availableBytesIn;
                    this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                    this._codec.NextIn           = nextIn;
                    this.write = write;
                    return(this.Flush(r));
                }
                this.codes.Init(numArray[0], numArray2[0], this.hufts, tl[0], this.hufts, td[0]);
                this.mode = 6;
            }
            else
            {
                index = this.bb[0];
                while (bitk < index)
                {
                    if (availableBytesIn != 0)
                    {
                        r = 0;
                    }
                    else
                    {
                        this.bitb = bitb;
                        this.bitk = bitk;
                        this._codec.AvailableBytesIn = availableBytesIn;
                        this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                        this._codec.NextIn           = nextIn;
                        this.write = write;
                        return(this.Flush(r));
                    }
                    availableBytesIn--;
                    bitb |= (this._codec.InputBuffer[nextIn++] & 0xff) << bitk;
                    bitk += 8;
                }
                if (this.tb[0] == -1)
                {
                }
                index = this.hufts[((this.tb[0] + (bitb & inflate_mask[index])) * 3) + 1];
                int num10 = this.hufts[((this.tb[0] + (bitb & inflate_mask[index])) * 3) + 2];
                if (num10 < 0x10)
                {
                    bitb  = SharedUtils.URShift(bitb, index);
                    bitk -= index;
                    this.blens[this.index++] = num10;
                }
                else
                {
                    num8 = (num10 == 0x12) ? 7 : (num10 - 14);
                    int num9 = (num10 == 0x12) ? 11 : 3;
                    while (bitk < (index + num8))
                    {
                        if (availableBytesIn != 0)
                        {
                            r = 0;
                        }
                        else
                        {
                            this.bitb = bitb;
                            this.bitk = bitk;
                            this._codec.AvailableBytesIn = availableBytesIn;
                            this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                            this._codec.NextIn           = nextIn;
                            this.write = write;
                            return(this.Flush(r));
                        }
                        availableBytesIn--;
                        bitb |= (this._codec.InputBuffer[nextIn++] & 0xff) << bitk;
                        bitk += 8;
                    }
                    bitb  = SharedUtils.URShift(bitb, index);
                    bitk -= index;
                    num9 += bitb & inflate_mask[num8];
                    bitb  = SharedUtils.URShift(bitb, num8);
                    bitk -= num8;
                    num8  = this.index;
                    index = this.table;
                    if (((num8 + num9) > ((0x102 + (index & 0x1f)) + ((index >> 5) & 0x1f))) || ((num10 == 0x10) && (num8 < 1)))
                    {
                        this.blens          = null;
                        this.mode           = 9;
                        this._codec.Message = "invalid bit length repeat";
                        r         = -3;
                        this.bitb = bitb;
                        this.bitk = bitk;
                        this._codec.AvailableBytesIn = availableBytesIn;
                        this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                        this._codec.NextIn           = nextIn;
                        this.write = write;
                        return(this.Flush(r));
                    }
                    num10 = (num10 == 0x10) ? this.blens[num8 - 1] : 0;
                    do
                    {
                        this.blens[num8++] = num10;
                    }while (--num9 != 0);
                    this.index = num8;
                }
                goto Label_0DD2;
            }
Label_0F15:
            this.bitb = bitb;
            this.bitk = bitk;
            this._codec.AvailableBytesIn = availableBytesIn;
            this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
            this._codec.NextIn           = nextIn;
            this.write = write;
            if ((r = this.codes.Process(this, r)) != 1)
            {
                return(this.Flush(r));
            }
            r                = 0;
            nextIn           = this._codec.NextIn;
            availableBytesIn = this._codec.AvailableBytesIn;
            bitb             = this.bitb;
            bitk             = this.bitk;
            write            = this.write;
            num7             = (write < this.read) ? ((this.read - write) - 1) : (this.end - write);
            if (this.last == 0)
            {
                this.mode = 0;
                goto Label_11DA;
            }
            this.mode = 7;
Label_1007:
            this.write = write;
            r          = this.Flush(r);
            write      = this.write;
            num7       = (write < this.read) ? ((this.read - write) - 1) : (this.end - write);
            if (this.read != this.write)
            {
                this.bitb = bitb;
                this.bitk = bitk;
                this._codec.AvailableBytesIn = availableBytesIn;
                this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                this._codec.NextIn           = nextIn;
                this.write = write;
                return(this.Flush(r));
            }
            this.mode = 8;
Label_10BD:
            r         = 1;
            this.bitb = bitb;
            this.bitk = bitk;
            this._codec.AvailableBytesIn = availableBytesIn;
            this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
            this._codec.NextIn           = nextIn;
            this.write = write;
            return(this.Flush(r));

Label_11DA:
            flag = true;
            switch (this.mode)
            {
            case 0:
                while (bitk < 3)
                {
                    if (availableBytesIn != 0)
                    {
                        r = 0;
                    }
                    else
                    {
                        this.bitb = bitb;
                        this.bitk = bitk;
                        this._codec.AvailableBytesIn = availableBytesIn;
                        this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                        this._codec.NextIn           = nextIn;
                        this.write = write;
                        return(this.Flush(r));
                    }
                    availableBytesIn--;
                    bitb |= (this._codec.InputBuffer[nextIn++] & 0xff) << bitk;
                    bitk += 8;
                }
                index     = bitb & 7;
                this.last = index & 1;
                switch (SharedUtils.URShift(index, 1))
                {
                case 0:
                    bitb      = SharedUtils.URShift(bitb, 3);
                    bitk     -= 3;
                    index     = bitk & 7;
                    bitb      = SharedUtils.URShift(bitb, index);
                    bitk     -= index;
                    this.mode = 1;
                    goto Label_11DA;

                case 1:
                {
                    numArray  = new int[1];
                    numArray2 = new int[1];
                    int[][] numArray3 = new int[1][];
                    int[][] numArray4 = new int[1][];
                    InfTree.inflate_trees_fixed(numArray, numArray2, numArray3, numArray4, this._codec);
                    this.codes.Init(numArray[0], numArray2[0], numArray3[0], 0, numArray4[0], 0);
                    bitb      = SharedUtils.URShift(bitb, 3);
                    bitk     -= 3;
                    this.mode = 6;
                    goto Label_11DA;
                }

                case 2:
                    bitb      = SharedUtils.URShift(bitb, 3);
                    bitk     -= 3;
                    this.mode = 3;
                    goto Label_11DA;

                case 3:
                    bitb                = SharedUtils.URShift(bitb, 3);
                    bitk               -= 3;
                    this.mode           = 9;
                    this._codec.Message = "invalid block type";
                    r         = -3;
                    this.bitb = bitb;
                    this.bitk = bitk;
                    this._codec.AvailableBytesIn = availableBytesIn;
                    this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                    this._codec.NextIn           = nextIn;
                    this.write = write;
                    return(this.Flush(r));
                }
                goto Label_11DA;

            case 1:
                while (bitk < 0x20)
                {
                    if (availableBytesIn != 0)
                    {
                        r = 0;
                    }
                    else
                    {
                        this.bitb = bitb;
                        this.bitk = bitk;
                        this._codec.AvailableBytesIn = availableBytesIn;
                        this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                        this._codec.NextIn           = nextIn;
                        this.write = write;
                        return(this.Flush(r));
                    }
                    availableBytesIn--;
                    bitb |= (this._codec.InputBuffer[nextIn++] & 0xff) << bitk;
                    bitk += 8;
                }
                if ((SharedUtils.URShift(~bitb, 0x10) & 0xffff) != (bitb & 0xffff))
                {
                    this.mode           = 9;
                    this._codec.Message = "invalid stored block lengths";
                    r         = -3;
                    this.bitb = bitb;
                    this.bitk = bitk;
                    this._codec.AvailableBytesIn = availableBytesIn;
                    this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                    this._codec.NextIn           = nextIn;
                    this.write = write;
                    return(this.Flush(r));
                }
                this.left = bitb & 0xffff;
                bitb      = bitk = 0;
                this.mode = (this.left != 0) ? 2 : ((this.last != 0) ? 7 : 0);
                goto Label_11DA;

            case 2:
                if (availableBytesIn != 0)
                {
                    if (num7 == 0)
                    {
                        if ((write == this.end) && (this.read != 0))
                        {
                            write = 0;
                            num7  = (write < this.read) ? ((this.read - write) - 1) : (this.end - write);
                        }
                        if (num7 == 0)
                        {
                            this.write = write;
                            r          = this.Flush(r);
                            write      = this.write;
                            num7       = (write < this.read) ? ((this.read - write) - 1) : (this.end - write);
                            if ((write == this.end) && (this.read != 0))
                            {
                                write = 0;
                                num7  = (write < this.read) ? ((this.read - write) - 1) : (this.end - write);
                            }
                            if (num7 == 0)
                            {
                                this.bitb = bitb;
                                this.bitk = bitk;
                                this._codec.AvailableBytesIn = availableBytesIn;
                                this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                                this._codec.NextIn           = nextIn;
                                this.write = write;
                                return(this.Flush(r));
                            }
                        }
                    }
                    r     = 0;
                    index = this.left;
                    if (index > availableBytesIn)
                    {
                        index = availableBytesIn;
                    }
                    if (index > num7)
                    {
                        index = num7;
                    }
                    Array.Copy(this._codec.InputBuffer, nextIn, this.window, write, index);
                    nextIn           += index;
                    availableBytesIn -= index;
                    write            += index;
                    num7             -= index;
                    this.left        -= index;
                    if (this.left == 0)
                    {
                        this.mode = (this.last != 0) ? 7 : 0;
                    }
                    goto Label_11DA;
                }
                this.bitb = bitb;
                this.bitk = bitk;
                this._codec.AvailableBytesIn = availableBytesIn;
                this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                this._codec.NextIn           = nextIn;
                this.write = write;
                return(this.Flush(r));

            case 3:
                while (bitk < 14)
                {
                    if (availableBytesIn != 0)
                    {
                        r = 0;
                    }
                    else
                    {
                        this.bitb = bitb;
                        this.bitk = bitk;
                        this._codec.AvailableBytesIn = availableBytesIn;
                        this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                        this._codec.NextIn           = nextIn;
                        this.write = write;
                        return(this.Flush(r));
                    }
                    availableBytesIn--;
                    bitb |= (this._codec.InputBuffer[nextIn++] & 0xff) << bitk;
                    bitk += 8;
                }
                this.table = index = bitb & 0x3fff;
                if (((index & 0x1f) > 0x1d) || (((index >> 5) & 0x1f) > 0x1d))
                {
                    this.mode           = 9;
                    this._codec.Message = "too many length or distance symbols";
                    r         = -3;
                    this.bitb = bitb;
                    this.bitk = bitk;
                    this._codec.AvailableBytesIn = availableBytesIn;
                    this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                    this._codec.NextIn           = nextIn;
                    this.write = write;
                    return(this.Flush(r));
                }
                index = (0x102 + (index & 0x1f)) + ((index >> 5) & 0x1f);
                if ((this.blens == null) || (this.blens.Length < index))
                {
                    this.blens = new int[index];
                }
                else
                {
                    for (num8 = 0; num8 < index; num8++)
                    {
                        this.blens[num8] = 0;
                    }
                }
                bitb       = SharedUtils.URShift(bitb, 14);
                bitk      -= 14;
                this.index = 0;
                this.mode  = 4;
                goto Label_0933;

            case 4:
                goto Label_0933;

            case 5:
                goto Label_0DD2;

            case 6:
                goto Label_0F15;

            case 7:
                goto Label_1007;

            case 8:
                goto Label_10BD;

            case 9:
                r         = -3;
                this.bitb = bitb;
                this.bitk = bitk;
                this._codec.AvailableBytesIn = availableBytesIn;
                this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
                this._codec.NextIn           = nextIn;
                this.write = write;
                return(this.Flush(r));
            }
            r         = -2;
            this.bitb = bitb;
            this.bitk = bitk;
            this._codec.AvailableBytesIn = availableBytesIn;
            this._codec.TotalBytesIn    += nextIn - this._codec.NextIn;
            this._codec.NextIn           = nextIn;
            this.write = write;
            return(this.Flush(r));
        }
        internal int Process(int r)
        {
            int num  = this._codec.NextIn;
            int num2 = this._codec.AvailableBytesIn;
            int num3 = this.bitb;
            int num4 = this.bitk;
            int num5 = this.writeAt;
            int num6 = (num5 >= this.readAt) ? (this.end - num5) : (this.readAt - num5 - 1);

            while (true)
            {
                switch (this.mode)
                {
                case InflateBlockMode.TYPE:
                    break;

                case InflateBlockMode.LENS:
                    goto IL_030c;

                case InflateBlockMode.STORED:
                    goto IL_03dd;

                case InflateBlockMode.TABLE:
                    goto IL_068c;

                case InflateBlockMode.BTREE:
                    goto IL_085f;

                case InflateBlockMode.DTREE:
                    goto IL_0965;

                case InflateBlockMode.CODES:
                    goto IL_0da6;

                case InflateBlockMode.DRY:
                    goto IL_0e90;

                case InflateBlockMode.DONE:
                    goto end_IL_0057;

                case InflateBlockMode.BAD:
                    r         = -3;
                    this.bitb = num3;
                    this.bitk = num4;
                    this._codec.AvailableBytesIn = num2;
                    this._codec.TotalBytesIn    += num - this._codec.NextIn;
                    this._codec.NextIn           = num;
                    this.writeAt = num5;
                    return(this.Flush(r));

                default:
                    r         = -2;
                    this.bitb = num3;
                    this.bitk = num4;
                    this._codec.AvailableBytesIn = num2;
                    this._codec.TotalBytesIn    += num - this._codec.NextIn;
                    this._codec.NextIn           = num;
                    this.writeAt = num5;
                    return(this.Flush(r));
                }
                while (num4 < 3)
                {
                    if (num2 != 0)
                    {
                        r = 0;
                        num2--;
                        num3 |= (this._codec.InputBuffer[num++] & 0xFF) << num4;
                        num4 += 8;
                        continue;
                    }
                    this.bitb = num3;
                    this.bitk = num4;
                    this._codec.AvailableBytesIn = num2;
                    this._codec.TotalBytesIn    += num - this._codec.NextIn;
                    this._codec.NextIn           = num;
                    this.writeAt = num5;
                    return(this.Flush(r));
                }
                int num8 = num3 & 7;
                this.last = (num8 & 1);
                switch ((uint)num8 >> 1)
                {
                case 0u:
                    num3    >>= 3;
                    num4     -= 3;
                    num8      = (num4 & 7);
                    num3    >>= num8;
                    num4     -= num8;
                    this.mode = InflateBlockMode.LENS;
                    break;

                case 1u:
                {
                    int[]   array  = new int[1];
                    int[]   array2 = new int[1];
                    int[][] array3 = new int[1][];
                    int[][] array4 = new int[1][];
                    InfTree.inflate_trees_fixed(array, array2, array3, array4, this._codec);
                    this.codes.Init(array[0], array2[0], array3[0], 0, array4[0], 0);
                    num3    >>= 3;
                    num4     -= 3;
                    this.mode = InflateBlockMode.CODES;
                    break;
                }

                case 2u:
                    num3    >>= 3;
                    num4     -= 3;
                    this.mode = InflateBlockMode.TABLE;
                    break;

                case 3u:
                    num3              >>= 3;
                    num4               -= 3;
                    this.mode           = InflateBlockMode.BAD;
                    this._codec.Message = "invalid block type";
                    r         = -3;
                    this.bitb = num3;
                    this.bitk = num4;
                    this._codec.AvailableBytesIn = num2;
                    this._codec.TotalBytesIn    += num - this._codec.NextIn;
                    this._codec.NextIn           = num;
                    this.writeAt = num5;
                    return(this.Flush(r));
                }
                continue;
IL_068c:
                while (num4 < 14)
                {
                    if (num2 != 0)
                    {
                        r = 0;
                        num2--;
                        num3 |= (this._codec.InputBuffer[num++] & 0xFF) << num4;
                        num4 += 8;
                        continue;
                    }
                    this.bitb = num3;
                    this.bitk = num4;
                    this._codec.AvailableBytesIn = num2;
                    this._codec.TotalBytesIn    += num - this._codec.NextIn;
                    this._codec.NextIn           = num;
                    this.writeAt = num5;
                    return(this.Flush(r));
                }
                num8 = (this.table = (num3 & 0x3FFF));
                if ((num8 & 0x1F) <= 29 && (num8 >> 5 & 0x1F) <= 29)
                {
                    num8 = 258 + (num8 & 0x1F) + (num8 >> 5 & 0x1F);
                    if (this.blens == null || this.blens.Length < num8)
                    {
                        this.blens = new int[num8];
                    }
                    else
                    {
                        Array.Clear(this.blens, 0, num8);
                    }
                    num3     >>= 14;
                    num4      -= 14;
                    this.index = 0;
                    this.mode  = InflateBlockMode.BTREE;
                    goto IL_085f;
                }
                this.mode           = InflateBlockMode.BAD;
                this._codec.Message = "too many length or distance symbols";
                r         = -3;
                this.bitb = num3;
                this.bitk = num4;
                this._codec.AvailableBytesIn = num2;
                this._codec.TotalBytesIn    += num - this._codec.NextIn;
                this._codec.NextIn           = num;
                this.writeAt = num5;
                return(this.Flush(r));

IL_030c:
                while (num4 < 32)
                {
                    if (num2 != 0)
                    {
                        r = 0;
                        num2--;
                        num3 |= (this._codec.InputBuffer[num++] & 0xFF) << num4;
                        num4 += 8;
                        continue;
                    }
                    this.bitb = num3;
                    this.bitk = num4;
                    this._codec.AvailableBytesIn = num2;
                    this._codec.TotalBytesIn    += num - this._codec.NextIn;
                    this._codec.NextIn           = num;
                    this.writeAt = num5;
                    return(this.Flush(r));
                }
                if ((~num3 >> 16 & 0xFFFF) != (num3 & 0xFFFF))
                {
                    this.mode           = InflateBlockMode.BAD;
                    this._codec.Message = "invalid stored block lengths";
                    r         = -3;
                    this.bitb = num3;
                    this.bitk = num4;
                    this._codec.AvailableBytesIn = num2;
                    this._codec.TotalBytesIn    += num - this._codec.NextIn;
                    this._codec.NextIn           = num;
                    this.writeAt = num5;
                    return(this.Flush(r));
                }
                this.left = (num3 & 0xFFFF);
                num3      = (num4 = 0);
                this.mode = (InflateBlockMode)((this.left == 0) ? ((this.last != 0) ? 7 : 0) : 2);
                continue;
IL_0da6:
                this.bitb = num3;
                this.bitk = num4;
                this._codec.AvailableBytesIn = num2;
                this._codec.TotalBytesIn    += num - this._codec.NextIn;
                this._codec.NextIn           = num;
                this.writeAt = num5;
                r            = this.codes.Process(this, r);
                if (r != 1)
                {
                    return(this.Flush(r));
                }
                r    = 0;
                num  = this._codec.NextIn;
                num2 = this._codec.AvailableBytesIn;
                num3 = this.bitb;
                num4 = this.bitk;
                num5 = this.writeAt;
                num6 = ((num5 >= this.readAt) ? (this.end - num5) : (this.readAt - num5 - 1));
                if (this.last == 0)
                {
                    this.mode = InflateBlockMode.TYPE;
                    continue;
                }
                this.mode = InflateBlockMode.DRY;
                goto IL_0e90;
IL_03dd:
                if (num2 == 0)
                {
                    this.bitb = num3;
                    this.bitk = num4;
                    this._codec.AvailableBytesIn = num2;
                    this._codec.TotalBytesIn    += num - this._codec.NextIn;
                    this._codec.NextIn           = num;
                    this.writeAt = num5;
                    return(this.Flush(r));
                }
                if (num6 == 0)
                {
                    if (num5 == this.end && this.readAt != 0)
                    {
                        num5 = 0;
                        num6 = ((num5 >= this.readAt) ? (this.end - num5) : (this.readAt - num5 - 1));
                    }
                    if (num6 == 0)
                    {
                        this.writeAt = num5;
                        r            = this.Flush(r);
                        num5         = this.writeAt;
                        num6         = ((num5 >= this.readAt) ? (this.end - num5) : (this.readAt - num5 - 1));
                        if (num5 == this.end && this.readAt != 0)
                        {
                            num5 = 0;
                            num6 = ((num5 >= this.readAt) ? (this.end - num5) : (this.readAt - num5 - 1));
                        }
                        if (num6 == 0)
                        {
                            this.bitb = num3;
                            this.bitk = num4;
                            this._codec.AvailableBytesIn = num2;
                            this._codec.TotalBytesIn    += num - this._codec.NextIn;
                            this._codec.NextIn           = num;
                            this.writeAt = num5;
                            return(this.Flush(r));
                        }
                    }
                }
                r    = 0;
                num8 = this.left;
                if (num8 > num2)
                {
                    num8 = num2;
                }
                if (num8 > num6)
                {
                    num8 = num6;
                }
                Array.Copy(this._codec.InputBuffer, num, this.window, num5, num8);
                num  += num8;
                num2 -= num8;
                num5 += num8;
                num6 -= num8;
                if ((this.left -= num8) == 0)
                {
                    this.mode = (InflateBlockMode)((this.last != 0) ? 7 : 0);
                }
                continue;
IL_0965:
                while (true)
                {
                    num8 = this.table;
                    if (this.index < 258 + (num8 & 0x1F) + (num8 >> 5 & 0x1F))
                    {
                        num8 = this.bb[0];
                        while (num4 < num8)
                        {
                            if (num2 != 0)
                            {
                                r = 0;
                                num2--;
                                num3 |= (this._codec.InputBuffer[num++] & 0xFF) << num4;
                                num4 += 8;
                                continue;
                            }
                            this.bitb = num3;
                            this.bitk = num4;
                            this._codec.AvailableBytesIn = num2;
                            this._codec.TotalBytesIn    += num - this._codec.NextIn;
                            this._codec.NextIn           = num;
                            this.writeAt = num5;
                            return(this.Flush(r));
                        }
                        num8 = this.hufts[(this.tb[0] + (num3 & InternalInflateConstants.InflateMask[num8])) * 3 + 1];
                        int num12 = this.hufts[(this.tb[0] + (num3 & InternalInflateConstants.InflateMask[num8])) * 3 + 2];
                        if (num12 < 16)
                        {
                            num3 >>= num8;
                            num4  -= num8;
                            this.blens[this.index++] = num12;
                            continue;
                        }
                        int num13 = (num12 != 18) ? (num12 - 14) : 7;
                        int num14 = (num12 != 18) ? 3 : 11;
                        while (num4 < num8 + num13)
                        {
                            if (num2 != 0)
                            {
                                r = 0;
                                num2--;
                                num3 |= (this._codec.InputBuffer[num++] & 0xFF) << num4;
                                num4 += 8;
                                continue;
                            }
                            this.bitb = num3;
                            this.bitk = num4;
                            this._codec.AvailableBytesIn = num2;
                            this._codec.TotalBytesIn    += num - this._codec.NextIn;
                            this._codec.NextIn           = num;
                            this.writeAt = num5;
                            return(this.Flush(r));
                        }
                        num3 >>= num8;
                        num4  -= num8;
                        num14 += (num3 & InternalInflateConstants.InflateMask[num13]);
                        num3 >>= num13;
                        num4  -= num13;
                        num13  = this.index;
                        num8   = this.table;
                        if (num13 + num14 <= 258 + (num8 & 0x1F) + (num8 >> 5 & 0x1F) && (num12 != 16 || num13 >= 1))
                        {
                            num12 = ((num12 == 16) ? this.blens[num13 - 1] : 0);
                            while (true)
                            {
                                this.blens[num13++] = num12;
                                if (--num14 == 0)
                                {
                                    break;
                                }
                            }
                            this.index = num13;
                            continue;
                        }
                        this.blens          = null;
                        this.mode           = InflateBlockMode.BAD;
                        this._codec.Message = "invalid bit length repeat";
                        r         = -3;
                        this.bitb = num3;
                        this.bitk = num4;
                        this._codec.AvailableBytesIn = num2;
                        this._codec.TotalBytesIn    += num - this._codec.NextIn;
                        this._codec.NextIn           = num;
                        this.writeAt = num5;
                        return(this.Flush(r));
                    }
                    break;
                }
                this.tb[0] = -1;
                int[] array5 = new int[1]
                {
                    9
                };
                int[] array6 = new int[1]
                {
                    6
                };
                int[] array7 = new int[1];
                int[] array8 = new int[1];
                num8 = this.table;
                num8 = this.inftree.inflate_trees_dynamic(257 + (num8 & 0x1F), 1 + (num8 >> 5 & 0x1F), this.blens, array5, array6, array7, array8, this.hufts, this._codec);
                switch (num8)
                {
                case -3:
                    this.blens = null;
                    this.mode  = InflateBlockMode.BAD;
                    goto default;

                default:
                    r         = num8;
                    this.bitb = num3;
                    this.bitk = num4;
                    this._codec.AvailableBytesIn = num2;
                    this._codec.TotalBytesIn    += num - this._codec.NextIn;
                    this._codec.NextIn           = num;
                    this.writeAt = num5;
                    return(this.Flush(r));

                case 0:
                    break;
                }
                this.codes.Init(array5[0], array6[0], this.hufts, array7[0], this.hufts, array8[0]);
                this.mode = InflateBlockMode.CODES;
                goto IL_0da6;
IL_085f:
                while (this.index < 4 + (this.table >> 10))
                {
                    while (num4 < 3)
                    {
                        if (num2 != 0)
                        {
                            r = 0;
                            num2--;
                            num3 |= (this._codec.InputBuffer[num++] & 0xFF) << num4;
                            num4 += 8;
                            continue;
                        }
                        this.bitb = num3;
                        this.bitk = num4;
                        this._codec.AvailableBytesIn = num2;
                        this._codec.TotalBytesIn    += num - this._codec.NextIn;
                        this._codec.NextIn           = num;
                        this.writeAt = num5;
                        return(this.Flush(r));
                    }
                    this.blens[InflateBlocks.border[this.index++]] = (num3 & 7);
                    num3 >>= 3;
                    num4  -= 3;
                }
                while (this.index < 19)
                {
                    this.blens[InflateBlocks.border[this.index++]] = 0;
                }
                this.bb[0] = 7;
                num8       = this.inftree.inflate_trees_bits(this.blens, this.bb, this.tb, this.hufts, this._codec);
                if (num8 != 0)
                {
                    r = num8;
                    if (r == -3)
                    {
                        this.blens = null;
                        this.mode  = InflateBlockMode.BAD;
                    }
                    this.bitb = num3;
                    this.bitk = num4;
                    this._codec.AvailableBytesIn = num2;
                    this._codec.TotalBytesIn    += num - this._codec.NextIn;
                    this._codec.NextIn           = num;
                    this.writeAt = num5;
                    return(this.Flush(r));
                }
                this.index = 0;
                this.mode  = InflateBlockMode.DTREE;
                goto IL_0965;
IL_0e90:
                this.writeAt = num5;
                r            = this.Flush(r);
                num5         = this.writeAt;
                num6         = ((num5 >= this.readAt) ? (this.end - num5) : (this.readAt - num5 - 1));
                if (this.readAt != this.writeAt)
                {
                    this.bitb = num3;
                    this.bitk = num4;
                    this._codec.AvailableBytesIn = num2;
                    this._codec.TotalBytesIn    += num - this._codec.NextIn;
                    this._codec.NextIn           = num;
                    this.writeAt = num5;
                    return(this.Flush(r));
                }
                this.mode = InflateBlockMode.DONE;
                break;
                continue;
end_IL_0057:
                break;
            }
            r         = 1;
            this.bitb = num3;
            this.bitk = num4;
            this._codec.AvailableBytesIn = num2;
            this._codec.TotalBytesIn    += num - this._codec.NextIn;
            this._codec.NextIn           = num;
            this.writeAt = num5;
            return(this.Flush(r));
        }
Example #9
0
        internal int Process(int r)
        {
            int p = _codec.NextIn;
            int m = _codec.AvailableBytesIn;
            int b = bitb;
            int k = bitk;
            int q = writeAt;
            int l = ((q < readAt) ? (readAt - q - 1) : (end - q));

            while (true)
            {
                switch (mode)
                {
                case InflateBlockMode.TYPE:
                {
                    for (; k < 3; k += 8)
                    {
                        if (m != 0)
                        {
                            r = 0;
                            m--;
                            b |= (_codec.InputBuffer[p++] & 0xFF) << k;
                            continue;
                        }
                        bitb = b;
                        bitk = k;
                        _codec.AvailableBytesIn = m;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    int t = b & 7;
                    last = t & 1;
                    switch ((uint)t >> 1)
                    {
                    case 0u:
                        b  >>= 3;
                        k   -= 3;
                        t    = k & 7;
                        b  >>= t;
                        k   -= t;
                        mode = InflateBlockMode.LENS;
                        break;

                    case 1u:
                    {
                        int[]   bl = new int[1];
                        int[]   bd = new int[1];
                        int[][] tl = new int[1][];
                        int[][] td = new int[1][];
                        InfTree.inflate_trees_fixed(bl, bd, tl, td, _codec);
                        codes.Init(bl[0], bd[0], tl[0], 0, td[0], 0);
                        b  >>= 3;
                        k   -= 3;
                        mode = InflateBlockMode.CODES;
                        break;
                    }

                    case 2u:
                        b  >>= 3;
                        k   -= 3;
                        mode = InflateBlockMode.TABLE;
                        break;

                    case 3u:
                        b                     >>= 3;
                        k                      -= 3;
                        mode                    = InflateBlockMode.BAD;
                        _codec.Message          = "invalid block type";
                        r                       = -3;
                        bitb                    = b;
                        bitk                    = k;
                        _codec.AvailableBytesIn = m;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt                 = q;
                        return(Flush(r));
                    }
                    break;
                }

                case InflateBlockMode.LENS:
                    for (; k < 32; k += 8)
                    {
                        if (m != 0)
                        {
                            r = 0;
                            m--;
                            b |= (_codec.InputBuffer[p++] & 0xFF) << k;
                            continue;
                        }
                        bitb = b;
                        bitk = k;
                        _codec.AvailableBytesIn = m;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    if (((~b >> 16) & 0xFFFF) != (b & 0xFFFF))
                    {
                        mode           = InflateBlockMode.BAD;
                        _codec.Message = "invalid stored block lengths";
                        r    = -3;
                        bitb = b;
                        bitk = k;
                        _codec.AvailableBytesIn = m;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    left = b & 0xFFFF;
                    b    = (k = 0);
                    mode = ((left != 0) ? InflateBlockMode.STORED : ((last != 0) ? InflateBlockMode.DRY : InflateBlockMode.TYPE));
                    break;

                case InflateBlockMode.STORED:
                {
                    if (m == 0)
                    {
                        bitb = b;
                        bitk = k;
                        _codec.AvailableBytesIn = m;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    if (l == 0)
                    {
                        if (q == end && readAt != 0)
                        {
                            q = 0;
                            l = ((q < readAt) ? (readAt - q - 1) : (end - q));
                        }
                        if (l == 0)
                        {
                            writeAt = q;
                            r       = Flush(r);
                            q       = writeAt;
                            l       = ((q < readAt) ? (readAt - q - 1) : (end - q));
                            if (q == end && readAt != 0)
                            {
                                q = 0;
                                l = ((q < readAt) ? (readAt - q - 1) : (end - q));
                            }
                            if (l == 0)
                            {
                                bitb = b;
                                bitk = k;
                                _codec.AvailableBytesIn = m;
                                _codec.TotalBytesIn    += p - _codec.NextIn;
                                _codec.NextIn           = p;
                                writeAt = q;
                                return(Flush(r));
                            }
                        }
                    }
                    r = 0;
                    int t = left;
                    if (t > m)
                    {
                        t = m;
                    }
                    if (t > l)
                    {
                        t = l;
                    }
                    Array.Copy(_codec.InputBuffer, p, window, q, t);
                    p += t;
                    m -= t;
                    q += t;
                    l -= t;
                    if ((left -= t) == 0)
                    {
                        mode = ((last != 0) ? InflateBlockMode.DRY : InflateBlockMode.TYPE);
                    }
                    break;
                }

                case InflateBlockMode.TABLE:
                {
                    for (; k < 14; k += 8)
                    {
                        if (m != 0)
                        {
                            r = 0;
                            m--;
                            b |= (_codec.InputBuffer[p++] & 0xFF) << k;
                            continue;
                        }
                        bitb = b;
                        bitk = k;
                        _codec.AvailableBytesIn = m;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    int t = (table = b & 0x3FFF);
                    if ((t & 0x1F) > 29 || ((t >> 5) & 0x1F) > 29)
                    {
                        mode           = InflateBlockMode.BAD;
                        _codec.Message = "too many length or distance symbols";
                        r    = -3;
                        bitb = b;
                        bitk = k;
                        _codec.AvailableBytesIn = m;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    t = 258 + (t & 0x1F) + ((t >> 5) & 0x1F);
                    if (blens == null || blens.Length < t)
                    {
                        blens = new int[t];
                    }
                    else
                    {
                        Array.Clear(blens, 0, t);
                    }
                    b   >>= 14;
                    k    -= 14;
                    index = 0;
                    mode  = InflateBlockMode.BTREE;
                    goto case InflateBlockMode.BTREE;
                }

                case InflateBlockMode.BTREE:
                {
                    while (index < 4 + (table >> 10))
                    {
                        for (; k < 3; k += 8)
                        {
                            if (m != 0)
                            {
                                r = 0;
                                m--;
                                b |= (_codec.InputBuffer[p++] & 0xFF) << k;
                                continue;
                            }
                            bitb = b;
                            bitk = k;
                            _codec.AvailableBytesIn = m;
                            _codec.TotalBytesIn    += p - _codec.NextIn;
                            _codec.NextIn           = p;
                            writeAt = q;
                            return(Flush(r));
                        }
                        blens[border[index++]] = b & 7;
                        b >>= 3;
                        k  -= 3;
                    }
                    while (index < 19)
                    {
                        blens[border[index++]] = 0;
                    }
                    bb[0] = 7;
                    int t = inftree.inflate_trees_bits(blens, bb, tb, hufts, _codec);
                    if (t != 0)
                    {
                        r = t;
                        if (r == -3)
                        {
                            blens = null;
                            mode  = InflateBlockMode.BAD;
                        }
                        bitb = b;
                        bitk = k;
                        _codec.AvailableBytesIn = m;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    index = 0;
                    mode  = InflateBlockMode.DTREE;
                    goto case InflateBlockMode.DTREE;
                }

                case InflateBlockMode.DTREE:
                {
                    int t;
                    while (true)
                    {
                        t = table;
                        if (index >= 258 + (t & 0x1F) + ((t >> 5) & 0x1F))
                        {
                            break;
                        }
                        for (t = bb[0]; k < t; k += 8)
                        {
                            if (m != 0)
                            {
                                r = 0;
                                m--;
                                b |= (_codec.InputBuffer[p++] & 0xFF) << k;
                                continue;
                            }
                            bitb = b;
                            bitk = k;
                            _codec.AvailableBytesIn = m;
                            _codec.TotalBytesIn    += p - _codec.NextIn;
                            _codec.NextIn           = p;
                            writeAt = q;
                            return(Flush(r));
                        }
                        t = hufts[(tb[0] + (b & InternalInflateConstants.InflateMask[t])) * 3 + 1];
                        int c = hufts[(tb[0] + (b & InternalInflateConstants.InflateMask[t])) * 3 + 2];
                        if (c < 16)
                        {
                            b >>= t;
                            k  -= t;
                            blens[index++] = c;
                            continue;
                        }
                        int i = ((c == 18) ? 7 : (c - 14));
                        int j = ((c == 18) ? 11 : 3);
                        for (; k < t + i; k += 8)
                        {
                            if (m != 0)
                            {
                                r = 0;
                                m--;
                                b |= (_codec.InputBuffer[p++] & 0xFF) << k;
                                continue;
                            }
                            bitb = b;
                            bitk = k;
                            _codec.AvailableBytesIn = m;
                            _codec.TotalBytesIn    += p - _codec.NextIn;
                            _codec.NextIn           = p;
                            writeAt = q;
                            return(Flush(r));
                        }
                        b >>= t;
                        k  -= t;
                        j  += b & InternalInflateConstants.InflateMask[i];
                        b >>= i;
                        k  -= i;
                        i   = index;
                        t   = table;
                        if (i + j > 258 + (t & 0x1F) + ((t >> 5) & 0x1F) || (c == 16 && i < 1))
                        {
                            blens          = null;
                            mode           = InflateBlockMode.BAD;
                            _codec.Message = "invalid bit length repeat";
                            r    = -3;
                            bitb = b;
                            bitk = k;
                            _codec.AvailableBytesIn = m;
                            _codec.TotalBytesIn    += p - _codec.NextIn;
                            _codec.NextIn           = p;
                            writeAt = q;
                            return(Flush(r));
                        }
                        c = ((c == 16) ? blens[i - 1] : 0);
                        do
                        {
                            blens[i++] = c;
                        }while (--j != 0);
                        index = i;
                    }
                    tb[0] = -1;
                    int[] bl2 = new int[1]
                    {
                        9
                    };
                    int[] bd2 = new int[1]
                    {
                        6
                    };
                    int[] tl2 = new int[1];
                    int[] td2 = new int[1];
                    t = table;
                    t = inftree.inflate_trees_dynamic(257 + (t & 0x1F), 1 + ((t >> 5) & 0x1F), blens, bl2, bd2, tl2, td2, hufts, _codec);
                    if (t != 0)
                    {
                        if (t == -3)
                        {
                            blens = null;
                            mode  = InflateBlockMode.BAD;
                        }
                        r    = t;
                        bitb = b;
                        bitk = k;
                        _codec.AvailableBytesIn = m;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    codes.Init(bl2[0], bd2[0], hufts, tl2[0], hufts, td2[0]);
                    mode = InflateBlockMode.CODES;
                    goto case InflateBlockMode.CODES;
                }

                case InflateBlockMode.CODES:
                    bitb = b;
                    bitk = k;
                    _codec.AvailableBytesIn = m;
                    _codec.TotalBytesIn    += p - _codec.NextIn;
                    _codec.NextIn           = p;
                    writeAt = q;
                    r       = codes.Process(this, r);
                    if (r != 1)
                    {
                        return(Flush(r));
                    }
                    r = 0;
                    p = _codec.NextIn;
                    m = _codec.AvailableBytesIn;
                    b = bitb;
                    k = bitk;
                    q = writeAt;
                    l = ((q < readAt) ? (readAt - q - 1) : (end - q));
                    if (last == 0)
                    {
                        mode = InflateBlockMode.TYPE;
                        break;
                    }
                    mode = InflateBlockMode.DRY;
                    goto case InflateBlockMode.DRY;

                case InflateBlockMode.DRY:
                    writeAt = q;
                    r       = Flush(r);
                    q       = writeAt;
                    l       = ((q < readAt) ? (readAt - q - 1) : (end - q));
                    if (readAt != writeAt)
                    {
                        bitb = b;
                        bitk = k;
                        _codec.AvailableBytesIn = m;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    mode = InflateBlockMode.DONE;
                    goto case InflateBlockMode.DONE;

                case InflateBlockMode.DONE:
                    r    = 1;
                    bitb = b;
                    bitk = k;
                    _codec.AvailableBytesIn = m;
                    _codec.TotalBytesIn    += p - _codec.NextIn;
                    _codec.NextIn           = p;
                    writeAt = q;
                    return(Flush(r));

                case InflateBlockMode.BAD:
                    r    = -3;
                    bitb = b;
                    bitk = k;
                    _codec.AvailableBytesIn = m;
                    _codec.TotalBytesIn    += p - _codec.NextIn;
                    _codec.NextIn           = p;
                    writeAt = q;
                    return(Flush(r));

                default:
                    r    = -2;
                    bitb = b;
                    bitk = k;
                    _codec.AvailableBytesIn = m;
                    _codec.TotalBytesIn    += p - _codec.NextIn;
                    _codec.NextIn           = p;
                    writeAt = q;
                    return(Flush(r));
                }
            }
        }
Example #10
0
        internal int Process(int r)
        {
            int p  = _codec.NextIn;
            int n2 = _codec.AvailableBytesIn;
            int b4 = bitb;
            int k2 = bitk;
            int q  = writeAt;
            int m2 = (q < readAt) ? (readAt - q - 1) : (end - q);

            while (true)
            {
                switch (mode)
                {
                case InflateBlockMode.TYPE:
                {
                    for (; k2 < 3; k2 += 8)
                    {
                        if (n2 != 0)
                        {
                            r = 0;
                            n2--;
                            b4 |= (_codec.InputBuffer[p++] & 0xFF) << k2;
                            continue;
                        }
                        bitb = b4;
                        bitk = k2;
                        _codec.AvailableBytesIn = n2;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    int t12 = b4 & 7;
                    last = (t12 & 1);
                    switch ((uint)t12 >> 1)
                    {
                    case 0u:
                        b4 >>= 3;
                        k2  -= 3;
                        t12  = (k2 & 7);
                        b4 >>= t12;
                        k2  -= t12;
                        mode = InflateBlockMode.LENS;
                        break;

                    case 1u:
                    {
                        int[]   bl = new int[1];
                        int[]   bd = new int[1];
                        int[][] tl = new int[1][];
                        int[][] td = new int[1][];
                        InfTree.inflate_trees_fixed(bl, bd, tl, td, _codec);
                        codes.Init(bl[0], bd[0], tl[0], 0, td[0], 0);
                        b4 >>= 3;
                        k2  -= 3;
                        mode = InflateBlockMode.CODES;
                        break;
                    }

                    case 2u:
                        b4 >>= 3;
                        k2  -= 3;
                        mode = InflateBlockMode.TABLE;
                        break;

                    case 3u:
                        b4           >>= 3;
                        k2            -= 3;
                        mode           = InflateBlockMode.BAD;
                        _codec.Message = "invalid block type";
                        r    = -3;
                        bitb = b4;
                        bitk = k2;
                        _codec.AvailableBytesIn = n2;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    break;
                }

                case InflateBlockMode.LENS:
                    for (; k2 < 32; k2 += 8)
                    {
                        if (n2 != 0)
                        {
                            r = 0;
                            n2--;
                            b4 |= (_codec.InputBuffer[p++] & 0xFF) << k2;
                            continue;
                        }
                        bitb = b4;
                        bitk = k2;
                        _codec.AvailableBytesIn = n2;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    if (((~b4 >> 16) & 0xFFFF) != (b4 & 0xFFFF))
                    {
                        mode           = InflateBlockMode.BAD;
                        _codec.Message = "invalid stored block lengths";
                        r    = -3;
                        bitb = b4;
                        bitk = k2;
                        _codec.AvailableBytesIn = n2;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    left = (b4 & 0xFFFF);
                    b4   = (k2 = 0);
                    mode = ((left != 0) ? InflateBlockMode.STORED : ((last != 0) ? InflateBlockMode.DRY : InflateBlockMode.TYPE));
                    break;

                case InflateBlockMode.STORED:
                {
                    if (n2 == 0)
                    {
                        bitb = b4;
                        bitk = k2;
                        _codec.AvailableBytesIn = n2;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    if (m2 == 0)
                    {
                        if (q == end && readAt != 0)
                        {
                            q  = 0;
                            m2 = ((q < readAt) ? (readAt - q - 1) : (end - q));
                        }
                        if (m2 == 0)
                        {
                            writeAt = q;
                            r       = Flush(r);
                            q       = writeAt;
                            m2      = ((q < readAt) ? (readAt - q - 1) : (end - q));
                            if (q == end && readAt != 0)
                            {
                                q  = 0;
                                m2 = ((q < readAt) ? (readAt - q - 1) : (end - q));
                            }
                            if (m2 == 0)
                            {
                                bitb = b4;
                                bitk = k2;
                                _codec.AvailableBytesIn = n2;
                                _codec.TotalBytesIn    += p - _codec.NextIn;
                                _codec.NextIn           = p;
                                writeAt = q;
                                return(Flush(r));
                            }
                        }
                    }
                    r = 0;
                    int t12 = left;
                    if (t12 > n2)
                    {
                        t12 = n2;
                    }
                    if (t12 > m2)
                    {
                        t12 = m2;
                    }
                    Array.Copy(_codec.InputBuffer, p, window, q, t12);
                    p  += t12;
                    n2 -= t12;
                    q  += t12;
                    m2 -= t12;
                    if ((left -= t12) == 0)
                    {
                        mode = ((last != 0) ? InflateBlockMode.DRY : InflateBlockMode.TYPE);
                    }
                    break;
                }

                case InflateBlockMode.TABLE:
                {
                    for (; k2 < 14; k2 += 8)
                    {
                        if (n2 != 0)
                        {
                            r = 0;
                            n2--;
                            b4 |= (_codec.InputBuffer[p++] & 0xFF) << k2;
                            continue;
                        }
                        bitb = b4;
                        bitk = k2;
                        _codec.AvailableBytesIn = n2;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    int t12 = table = (b4 & 0x3FFF);
                    if ((t12 & 0x1F) > 29 || ((t12 >> 5) & 0x1F) > 29)
                    {
                        mode           = InflateBlockMode.BAD;
                        _codec.Message = "too many length or distance symbols";
                        r    = -3;
                        bitb = b4;
                        bitk = k2;
                        _codec.AvailableBytesIn = n2;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    t12 = 258 + (t12 & 0x1F) + ((t12 >> 5) & 0x1F);
                    if (blens == null || blens.Length < t12)
                    {
                        blens = new int[t12];
                    }
                    else
                    {
                        Array.Clear(blens, 0, t12);
                    }
                    b4  >>= 14;
                    k2   -= 14;
                    index = 0;
                    mode  = InflateBlockMode.BTREE;
                    goto case InflateBlockMode.BTREE;
                }

                case InflateBlockMode.BTREE:
                {
                    while (index < 4 + (table >> 10))
                    {
                        for (; k2 < 3; k2 += 8)
                        {
                            if (n2 != 0)
                            {
                                r = 0;
                                n2--;
                                b4 |= (_codec.InputBuffer[p++] & 0xFF) << k2;
                                continue;
                            }
                            bitb = b4;
                            bitk = k2;
                            _codec.AvailableBytesIn = n2;
                            _codec.TotalBytesIn    += p - _codec.NextIn;
                            _codec.NextIn           = p;
                            writeAt = q;
                            return(Flush(r));
                        }
                        blens[border[index++]] = (b4 & 7);
                        b4 >>= 3;
                        k2  -= 3;
                    }
                    while (index < 19)
                    {
                        blens[border[index++]] = 0;
                    }
                    bb[0] = 7;
                    int t12 = inftree.inflate_trees_bits(blens, bb, tb, hufts, _codec);
                    if (t12 != 0)
                    {
                        r = t12;
                        if (r == -3)
                        {
                            blens = null;
                            mode  = InflateBlockMode.BAD;
                        }
                        bitb = b4;
                        bitk = k2;
                        _codec.AvailableBytesIn = n2;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    index = 0;
                    mode  = InflateBlockMode.DTREE;
                    goto case InflateBlockMode.DTREE;
                }

                case InflateBlockMode.DTREE:
                {
                    int t12;
                    while (true)
                    {
                        t12 = table;
                        if (index >= 258 + (t12 & 0x1F) + ((t12 >> 5) & 0x1F))
                        {
                            break;
                        }
                        for (t12 = bb[0]; k2 < t12; k2 += 8)
                        {
                            if (n2 != 0)
                            {
                                r = 0;
                                n2--;
                                b4 |= (_codec.InputBuffer[p++] & 0xFF) << k2;
                                continue;
                            }
                            bitb = b4;
                            bitk = k2;
                            _codec.AvailableBytesIn = n2;
                            _codec.TotalBytesIn    += p - _codec.NextIn;
                            _codec.NextIn           = p;
                            writeAt = q;
                            return(Flush(r));
                        }
                        t12 = hufts[(tb[0] + (b4 & InternalInflateConstants.InflateMask[t12])) * 3 + 1];
                        int c2 = hufts[(tb[0] + (b4 & InternalInflateConstants.InflateMask[t12])) * 3 + 2];
                        if (c2 < 16)
                        {
                            b4           >>= t12;
                            k2            -= t12;
                            blens[index++] = c2;
                            continue;
                        }
                        int i2 = (c2 == 18) ? 7 : (c2 - 14);
                        int j2 = (c2 == 18) ? 11 : 3;
                        for (; k2 < t12 + i2; k2 += 8)
                        {
                            if (n2 != 0)
                            {
                                r = 0;
                                n2--;
                                b4 |= (_codec.InputBuffer[p++] & 0xFF) << k2;
                                continue;
                            }
                            bitb = b4;
                            bitk = k2;
                            _codec.AvailableBytesIn = n2;
                            _codec.TotalBytesIn    += p - _codec.NextIn;
                            _codec.NextIn           = p;
                            writeAt = q;
                            return(Flush(r));
                        }
                        b4 >>= t12;
                        k2  -= t12;
                        j2  += (b4 & InternalInflateConstants.InflateMask[i2]);
                        b4 >>= i2;
                        k2  -= i2;
                        i2   = index;
                        t12  = table;
                        if (i2 + j2 > 258 + (t12 & 0x1F) + ((t12 >> 5) & 0x1F) || (c2 == 16 && i2 < 1))
                        {
                            blens          = null;
                            mode           = InflateBlockMode.BAD;
                            _codec.Message = "invalid bit length repeat";
                            r    = -3;
                            bitb = b4;
                            bitk = k2;
                            _codec.AvailableBytesIn = n2;
                            _codec.TotalBytesIn    += p - _codec.NextIn;
                            _codec.NextIn           = p;
                            writeAt = q;
                            return(Flush(r));
                        }
                        c2 = ((c2 == 16) ? blens[i2 - 1] : 0);
                        do
                        {
                            blens[i2++] = c2;
                        }while (--j2 != 0);
                        index = i2;
                    }
                    tb[0] = -1;
                    int[] bl2 = new int[1]
                    {
                        9
                    };
                    int[] bd2 = new int[1]
                    {
                        6
                    };
                    int[] tl2 = new int[1];
                    int[] td2 = new int[1];
                    t12 = table;
                    t12 = inftree.inflate_trees_dynamic(257 + (t12 & 0x1F), 1 + ((t12 >> 5) & 0x1F), blens, bl2, bd2, tl2, td2, hufts, _codec);
                    if (t12 != 0)
                    {
                        if (t12 == -3)
                        {
                            blens = null;
                            mode  = InflateBlockMode.BAD;
                        }
                        r    = t12;
                        bitb = b4;
                        bitk = k2;
                        _codec.AvailableBytesIn = n2;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    codes.Init(bl2[0], bd2[0], hufts, tl2[0], hufts, td2[0]);
                    mode = InflateBlockMode.CODES;
                    goto case InflateBlockMode.CODES;
                }

                case InflateBlockMode.CODES:
                    bitb = b4;
                    bitk = k2;
                    _codec.AvailableBytesIn = n2;
                    _codec.TotalBytesIn    += p - _codec.NextIn;
                    _codec.NextIn           = p;
                    writeAt = q;
                    r       = codes.Process(this, r);
                    if (r != 1)
                    {
                        return(Flush(r));
                    }
                    r  = 0;
                    p  = _codec.NextIn;
                    n2 = _codec.AvailableBytesIn;
                    b4 = bitb;
                    k2 = bitk;
                    q  = writeAt;
                    m2 = ((q < readAt) ? (readAt - q - 1) : (end - q));
                    if (last == 0)
                    {
                        mode = InflateBlockMode.TYPE;
                        break;
                    }
                    mode = InflateBlockMode.DRY;
                    goto case InflateBlockMode.DRY;

                case InflateBlockMode.DRY:
                    writeAt = q;
                    r       = Flush(r);
                    q       = writeAt;
                    m2      = ((q < readAt) ? (readAt - q - 1) : (end - q));
                    if (readAt != writeAt)
                    {
                        bitb = b4;
                        bitk = k2;
                        _codec.AvailableBytesIn = n2;
                        _codec.TotalBytesIn    += p - _codec.NextIn;
                        _codec.NextIn           = p;
                        writeAt = q;
                        return(Flush(r));
                    }
                    mode = InflateBlockMode.DONE;
                    goto case InflateBlockMode.DONE;

                case InflateBlockMode.DONE:
                    r    = 1;
                    bitb = b4;
                    bitk = k2;
                    _codec.AvailableBytesIn = n2;
                    _codec.TotalBytesIn    += p - _codec.NextIn;
                    _codec.NextIn           = p;
                    writeAt = q;
                    return(Flush(r));

                case InflateBlockMode.BAD:
                    r    = -3;
                    bitb = b4;
                    bitk = k2;
                    _codec.AvailableBytesIn = n2;
                    _codec.TotalBytesIn    += p - _codec.NextIn;
                    _codec.NextIn           = p;
                    writeAt = q;
                    return(Flush(r));

                default:
                    r    = -2;
                    bitb = b4;
                    bitk = k2;
                    _codec.AvailableBytesIn = n2;
                    _codec.TotalBytesIn    += p - _codec.NextIn;
                    _codec.NextIn           = p;
                    writeAt = q;
                    return(Flush(r));
                }
            }
        }