Пример #1
0
 /// <summary>
 /// Map from a distance to a distance code.
 /// </summary>
 /// <remarks>
 /// No side effects. _dist_code[256] and _dist_code[257] are never used.
 /// </remarks>
 internal static int DistanceCode(int dist)
 {
     return(dist < 256
         ? _dist_code[dist]
         : _dist_code[256 + SharedUtils.URShift(dist, 7)]);
 }
Пример #2
0
        internal int Process(InflateBlocks blocks, int r)
        {
            int       num;
            int       num10;
            bool      flag;
            int       number = 0;
            int       bitk   = 0;
            int       nextIn = 0;
            ZlibCodec z      = blocks._codec;

            nextIn = z.NextIn;
            int availableBytesIn = z.AvailableBytesIn;

            number = blocks.bitb;
            bitk   = blocks.bitk;
            int write = blocks.write;
            int num9  = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);

            goto Label_0C3A;
Label_0196:
            this.need       = this.lbits;
            this.tree       = this.ltree;
            this.tree_index = this.ltree_index;
            this.mode       = 1;
Label_01C3:
            num = this.need;
            while (bitk < num)
            {
                if (availableBytesIn != 0)
                {
                    r = 0;
                }
                else
                {
                    blocks.bitb        = number;
                    blocks.bitk        = bitk;
                    z.AvailableBytesIn = availableBytesIn;
                    z.TotalBytesIn    += nextIn - z.NextIn;
                    z.NextIn           = nextIn;
                    blocks.write       = write;
                    return(blocks.Flush(r));
                }
                availableBytesIn--;
                number |= (z.InputBuffer[nextIn++] & 0xff) << bitk;
                bitk   += 8;
            }
            int index = (this.tree_index + (number & inflate_mask[num])) * 3;

            number = SharedUtils.URShift(number, this.tree[index + 1]);
            bitk  -= this.tree[index + 1];
            int num3 = this.tree[index];

            if (num3 == 0)
            {
                this.lit  = this.tree[index + 2];
                this.mode = 6;
                goto Label_0C3A;
            }
            if ((num3 & 0x10) != 0)
            {
                this.get_Renamed = num3 & 15;
                this.len         = this.tree[index + 2];
                this.mode        = 2;
                goto Label_0C3A;
            }
            if ((num3 & 0x40) == 0)
            {
                this.need       = num3;
                this.tree_index = (index / 3) + this.tree[index + 2];
                goto Label_0C3A;
            }
            if ((num3 & 0x20) != 0)
            {
                this.mode = 7;
                goto Label_0C3A;
            }
            this.mode          = 9;
            z.Message          = "invalid literal/length code";
            r                  = -3;
            blocks.bitb        = number;
            blocks.bitk        = bitk;
            z.AvailableBytesIn = availableBytesIn;
            z.TotalBytesIn    += nextIn - z.NextIn;
            z.NextIn           = nextIn;
            blocks.write       = write;
            return(blocks.Flush(r));

Label_04AE:
            num = this.need;
            while (bitk < num)
            {
                if (availableBytesIn != 0)
                {
                    r = 0;
                }
                else
                {
                    blocks.bitb        = number;
                    blocks.bitk        = bitk;
                    z.AvailableBytesIn = availableBytesIn;
                    z.TotalBytesIn    += nextIn - z.NextIn;
                    z.NextIn           = nextIn;
                    blocks.write       = write;
                    return(blocks.Flush(r));
                }
                availableBytesIn--;
                number |= (z.InputBuffer[nextIn++] & 0xff) << bitk;
                bitk   += 8;
            }
            index  = (this.tree_index + (number & inflate_mask[num])) * 3;
            number = number >> this.tree[index + 1];
            bitk  -= this.tree[index + 1];
            num3   = this.tree[index];
            if ((num3 & 0x10) != 0)
            {
                this.get_Renamed = num3 & 15;
                this.dist        = this.tree[index + 2];
                this.mode        = 4;
                goto Label_0C3A;
            }
            if ((num3 & 0x40) == 0)
            {
                this.need       = num3;
                this.tree_index = (index / 3) + this.tree[index + 2];
                goto Label_0C3A;
            }
            this.mode          = 9;
            z.Message          = "invalid distance code";
            r                  = -3;
            blocks.bitb        = number;
            blocks.bitk        = bitk;
            z.AvailableBytesIn = availableBytesIn;
            z.TotalBytesIn    += nextIn - z.NextIn;
            z.NextIn           = nextIn;
            blocks.write       = write;
            return(blocks.Flush(r));

Label_0730:
            num10 = write - this.dist;
            while (num10 < 0)
            {
                num10 += blocks.end;
            }
            while (this.len != 0)
            {
                if (num9 == 0)
                {
                    if ((write == blocks.end) && (blocks.read != 0))
                    {
                        write = 0;
                        num9  = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
                    }
                    if (num9 == 0)
                    {
                        blocks.write = write;
                        r            = blocks.Flush(r);
                        write        = blocks.write;
                        num9         = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
                        if ((write == blocks.end) && (blocks.read != 0))
                        {
                            write = 0;
                            num9  = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
                        }
                        if (num9 == 0)
                        {
                            blocks.bitb        = number;
                            blocks.bitk        = bitk;
                            z.AvailableBytesIn = availableBytesIn;
                            z.TotalBytesIn    += nextIn - z.NextIn;
                            z.NextIn           = nextIn;
                            blocks.write       = write;
                            return(blocks.Flush(r));
                        }
                    }
                }
                blocks.window[write++] = blocks.window[num10++];
                num9--;
                if (num10 == blocks.end)
                {
                    num10 = 0;
                }
                this.len--;
            }
            this.mode = 0;
            goto Label_0C3A;
Label_0B44:
            r                  = 1;
            blocks.bitb        = number;
            blocks.bitk        = bitk;
            z.AvailableBytesIn = availableBytesIn;
            z.TotalBytesIn    += nextIn - z.NextIn;
            z.NextIn           = nextIn;
            blocks.write       = write;
            return(blocks.Flush(r));

Label_0C3A:
            flag = true;
            switch (this.mode)
            {
            case 0:
                if ((num9 < 0x102) || (availableBytesIn < 10))
                {
                    goto Label_0196;
                }
                blocks.bitb        = number;
                blocks.bitk        = bitk;
                z.AvailableBytesIn = availableBytesIn;
                z.TotalBytesIn    += nextIn - z.NextIn;
                z.NextIn           = nextIn;
                blocks.write       = write;
                r                = this.InflateFast(this.lbits, this.dbits, this.ltree, this.ltree_index, this.dtree, this.dtree_index, blocks, z);
                nextIn           = z.NextIn;
                availableBytesIn = z.AvailableBytesIn;
                number           = blocks.bitb;
                bitk             = blocks.bitk;
                write            = blocks.write;
                num9             = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
                if (r == 0)
                {
                    goto Label_0196;
                }
                this.mode = (r == 1) ? 7 : 9;
                goto Label_0C3A;

            case 1:
                goto Label_01C3;

            case 2:
                num = this.get_Renamed;
                while (bitk < num)
                {
                    if (availableBytesIn != 0)
                    {
                        r = 0;
                    }
                    else
                    {
                        blocks.bitb        = number;
                        blocks.bitk        = bitk;
                        z.AvailableBytesIn = availableBytesIn;
                        z.TotalBytesIn    += nextIn - z.NextIn;
                        z.NextIn           = nextIn;
                        blocks.write       = write;
                        return(blocks.Flush(r));
                    }
                    availableBytesIn--;
                    number |= (z.InputBuffer[nextIn++] & 0xff) << bitk;
                    bitk   += 8;
                }
                this.len       += number & inflate_mask[num];
                number          = number >> num;
                bitk           -= num;
                this.need       = this.dbits;
                this.tree       = this.dtree;
                this.tree_index = this.dtree_index;
                this.mode       = 3;
                goto Label_04AE;

            case 3:
                goto Label_04AE;

            case 4:
                num = this.get_Renamed;
                while (bitk < num)
                {
                    if (availableBytesIn != 0)
                    {
                        r = 0;
                    }
                    else
                    {
                        blocks.bitb        = number;
                        blocks.bitk        = bitk;
                        z.AvailableBytesIn = availableBytesIn;
                        z.TotalBytesIn    += nextIn - z.NextIn;
                        z.NextIn           = nextIn;
                        blocks.write       = write;
                        return(blocks.Flush(r));
                    }
                    availableBytesIn--;
                    number |= (z.InputBuffer[nextIn++] & 0xff) << bitk;
                    bitk   += 8;
                }
                this.dist += number & inflate_mask[num];
                number     = number >> num;
                bitk      -= num;
                this.mode  = 5;
                goto Label_0730;

            case 5:
                goto Label_0730;

            case 6:
                if (num9 == 0)
                {
                    if ((write == blocks.end) && (blocks.read != 0))
                    {
                        write = 0;
                        num9  = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
                    }
                    if (num9 == 0)
                    {
                        blocks.write = write;
                        r            = blocks.Flush(r);
                        write        = blocks.write;
                        num9         = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
                        if ((write == blocks.end) && (blocks.read != 0))
                        {
                            write = 0;
                            num9  = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
                        }
                        if (num9 == 0)
                        {
                            blocks.bitb        = number;
                            blocks.bitk        = bitk;
                            z.AvailableBytesIn = availableBytesIn;
                            z.TotalBytesIn    += nextIn - z.NextIn;
                            z.NextIn           = nextIn;
                            blocks.write       = write;
                            return(blocks.Flush(r));
                        }
                    }
                }
                r = 0;
                blocks.window[write++] = (byte)this.lit;
                num9--;
                this.mode = 0;
                goto Label_0C3A;

            case 7:
                if (bitk > 7)
                {
                    bitk -= 8;
                    availableBytesIn++;
                    nextIn--;
                }
                blocks.write = write;
                r            = blocks.Flush(r);
                write        = blocks.write;
                num9         = (write < blocks.read) ? ((blocks.read - write) - 1) : (blocks.end - write);
                if (blocks.read != blocks.write)
                {
                    blocks.bitb        = number;
                    blocks.bitk        = bitk;
                    z.AvailableBytesIn = availableBytesIn;
                    z.TotalBytesIn    += nextIn - z.NextIn;
                    z.NextIn           = nextIn;
                    blocks.write       = write;
                    return(blocks.Flush(r));
                }
                this.mode = 8;
                goto Label_0B44;

            case 8:
                goto Label_0B44;

            case 9:
                r                  = -3;
                blocks.bitb        = number;
                blocks.bitk        = bitk;
                z.AvailableBytesIn = availableBytesIn;
                z.TotalBytesIn    += nextIn - z.NextIn;
                z.NextIn           = nextIn;
                blocks.write       = write;
                return(blocks.Flush(r));
            }
            r                  = -2;
            blocks.bitb        = number;
            blocks.bitk        = bitk;
            z.AvailableBytesIn = availableBytesIn;
            z.TotalBytesIn    += nextIn - z.NextIn;
            z.NextIn           = nextIn;
            blocks.write       = write;
            return(blocks.Flush(r));
        }
Пример #3
0
 internal static int DistanceCode(int dist)
 {
     return((int)((dist >= 256) ? Tree._dist_code[256 + SharedUtils.URShift(dist, 7)] : Tree._dist_code[dist]));
 }
Пример #4
0
        internal int[] x  = null;     // bit offsets, then code stack

        private int huft_build(int[] b, int bindex, int n, int s, int[] d, int[] e, int[] t, int[] m, int[] hp, int[] hn, int[] v)
        {
            // Given a list of code lengths and a maximum table size, make a set of
            // tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
            // if the given code set is incomplete (the tables are still built in this
            // case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
            // lengths), or Z_MEM_ERROR if not enough memory.

            int a;    // counter for codes of length k
            int f;    // i repeats in table every f entries
            int g;    // maximum code length
            int h;    // table level
            int i;    // counter, current code
            int j;    // counter
            int k;    // number of bits in current code
            int l;    // bits per table (returned in m)
            int mask; // (1 << w) - 1, to avoid cc -O bug on HP
            int p;    // pointer into c[], b[], or v[]
            int q;    // points to current table
            int w;    // bits before this table == (l * h)
            int xp;   // pointer into x
            int y;    // number of dummy codes added
            int z;    // number of entries in current table

            // Generate counts for each bit length

            p = 0; i = n;
            do
            {
                c[b[bindex + p]]++; p++; i--; // assume all entries <= BMAX
            }while (i != 0);

            if (c[0] == n)
            {
                // null input--all zero length codes
                t[0] = -1;
                m[0] = 0;
                return(Z_OK);
            }

            // Find minimum and maximum length, bound *m by those
            l = m[0];
            for (j = 1; j <= BMAX; j++)
            {
                if (c[j] != 0)
                {
                    break;
                }
            }
            k = j; // minimum code length
            if (l < j)
            {
                l = j;
            }
            for (i = BMAX; i != 0; i--)
            {
                if (c[i] != 0)
                {
                    break;
                }
            }
            g = i; // maximum code length
            if (l > i)
            {
                l = i;
            }
            m[0] = l;

            // Adjust last length count to fill out codes, if needed
            for (y = 1 << j; j < i; j++, y <<= 1)
            {
                if ((y -= c[j]) < 0)
                {
                    return(Z_DATA_ERROR);
                }
            }
            if ((y -= c[i]) < 0)
            {
                return(Z_DATA_ERROR);
            }
            c[i] += y;

            // Generate starting offsets into the value table for each length
            x[1] = j = 0;
            p    = 1; xp = 2;
            while (--i != 0)
            {
                // note that i == g from above
                x[xp] = (j += c[p]);
                xp++;
                p++;
            }

            // Make a table of values in order of bit lengths
            i = 0; p = 0;
            do
            {
                if ((j = b[bindex + p]) != 0)
                {
                    v[x[j]++] = i;
                }
                p++;
            }while (++i < n);
            n = x[g]; // set n to length of v

            // Generate the Huffman codes and for each, make the table entries
            x[0] = i = 0; // first Huffman code is zero
            p    = 0;     // grab values in bit order
            h    = -1;    // no tables yet--level -1
            w    = -l;    // bits decoded == (l * h)
            u[0] = 0;     // just to keep compilers happy
            q    = 0;     // ditto
            z    = 0;     // ditto

            // go through the bit lengths (k already is bits in shortest code)
            for (; k <= g; k++)
            {
                a = c[k];
                while (a-- != 0)
                {
                    // here i is the Huffman code of length k bits for value *p
                    // make tables up to required level
                    while (k > w + l)
                    {
                        h++;
                        w += l;              // previous table always l bits
                                             // compute minimum size table less than or equal to l bits
                        z = g - w;
                        z = (z > l) ? l : z; // table size upper limit
                        if ((f = 1 << (j = k - w)) > a + 1)
                        {
                            // try a k-w bit table
                            // too few codes for k-w bit table
                            f -= (a + 1); // deduct codes from patterns left
                            xp = k;
                            if (j < z)
                            {
                                while (++j < z)
                                {
                                    // try smaller tables up to z bits
                                    if ((f <<= 1) <= c[++xp])
                                    {
                                        break;  // enough codes to use up j bits
                                    }
                                    f -= c[xp]; // else deduct codes from patterns
                                }
                            }
                        }
                        z = 1 << j; // table entries for j-bit table

                        // allocate new table
                        if (hn[0] + z > MANY)
                        {
                            // (note: doesn't matter for fixed)
                            return(Z_DATA_ERROR); // overflow of MANY
                        }
                        u[h]   = q = hn[0];       // DEBUG
                        hn[0] += z;

                        // connect to last table, if there is one
                        if (h != 0)
                        {
                            x[h] = i;                                    // save pattern for backing up
                            r[0] = (sbyte)j;                             // bits in this table
                            r[1] = (sbyte)l;                             // bits to dump before this table
                            j    = SharedUtils.URShift(i, (w - l));
                            r[2] = (int)(q - u[h - 1] - j);              // offset to this table
                            Array.Copy(r, 0, hp, (u[h - 1] + j) * 3, 3); // connect to last table
                        }
                        else
                        {
                            t[0] = q; // first table is returned result
                        }
                    }

                    // set up table entry in r
                    r[1] = (sbyte)(k - w);
                    if (p >= n)
                    {
                        r[0] = 128 + 64; // out of values--invalid code
                    }
                    else if (v[p] < s)
                    {
                        r[0] = (sbyte)(v[p] < 256 ? 0 : 32 + 64); // 256 is end-of-block
                        r[2] = v[p++];                            // simple code is just the value
                    }
                    else
                    {
                        r[0] = (sbyte)(e[v[p] - s] + 16 + 64); // non-simple--look up in lists
                        r[2] = d[v[p++] - s];
                    }

                    // fill code-like entries with r
                    f = 1 << (k - w);
                    for (j = SharedUtils.URShift(i, w); j < z; j += f)
                    {
                        Array.Copy(r, 0, hp, (q + j) * 3, 3);
                    }

                    // backwards increment the k-bit code i
                    for (j = 1 << (k - 1); (i & j) != 0; j = SharedUtils.URShift(j, 1))
                    {
                        i ^= j;
                    }
                    i ^= j;

                    // backup over finished tables
                    mask = (1 << w) - 1; // needed on HP, cc -O bug
                    while ((i & mask) != x[h])
                    {
                        h--; // don't need to update q
                        w   -= l;
                        mask = (1 << w) - 1;
                    }
                }
            }
            // Return Z_BUF_ERROR if we were given an incomplete table
            return(y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK);
        }
Пример #5
0
        // Token: 0x060007A9 RID: 1961 RVA: 0x000447C0 File Offset: 0x000429C0
        private int huft_build(int[] b, int bindex, int n, int s, int[] d, int[] e, int[] t, int[] m, int[] hp, int[] hn, int[] v)
        {
            int num  = 0;
            int num2 = n;

            do
            {
                this.c[b[bindex + num]]++;
                num++;
                num2--;
            }while (num2 != 0);
            if (this.c[0] == n)
            {
                t[0] = -1;
                m[0] = 0;
                return(0);
            }
            int num3 = m[0];
            int i    = 1;

            while (i <= 15 && this.c[i] == 0)
            {
                i++;
            }
            int j = i;

            if (num3 < i)
            {
                num3 = i;
            }
            num2 = 15;
            while (num2 != 0 && this.c[num2] == 0)
            {
                num2--;
            }
            int num4 = num2;

            if (num3 > num2)
            {
                num3 = num2;
            }
            m[0] = num3;
            int num5 = 1 << i;

            while (i < num2)
            {
                if ((num5 -= this.c[i]) < 0)
                {
                    return(-3);
                }
                i++;
                num5 <<= 1;
            }
            if ((num5 -= this.c[num2]) < 0)
            {
                return(-3);
            }
            this.c[num2] += num5;
            int[] array = this.x;
            int   num6  = 1;
            int   num7  = 0;

            i           = 0;
            array[num6] = num7;
            num         = 1;
            int num8 = 2;

            while (--num2 != 0)
            {
                i = (this.x[num8] = i + this.c[num]);
                num8++;
                num++;
            }
            num2 = 0;
            num  = 0;
            do
            {
                if ((i = b[bindex + num]) != 0)
                {
                    v[this.x[i]++] = num2;
                }
                num++;
            }while (++num2 < n);
            n = this.x[num4];
            int[] array2 = this.x;
            int   num9   = 0;
            int   num10  = 0;

            num2         = 0;
            array2[num9] = num10;
            num          = 0;
            int num11 = -1;
            int num12 = -num3;

            this.u[0] = 0;
            int num13 = 0;
            int num14 = 0;

            while (j <= num4)
            {
                int num15 = this.c[j];
                while (num15-- != 0)
                {
                    int num16;
                    while (j > num12 + num3)
                    {
                        num11++;
                        num12 += num3;
                        num14  = num4 - num12;
                        num14  = ((num14 > num3) ? num3 : num14);
                        if ((num16 = 1 << ((i = j - num12) & 31)) > num15 + 1)
                        {
                            num16 -= num15 + 1;
                            num8   = j;
                            if (i < num14)
                            {
                                while (++i < num14 && (num16 <<= 1) > this.c[++num8])
                                {
                                    num16 -= this.c[num8];
                                }
                            }
                        }
                        num14 = 1 << i;
                        if (hn[0] + num14 > 1440)
                        {
                            return(-3);
                        }
                        num13  = (this.u[num11] = hn[0]);
                        hn[0] += num14;
                        if (num11 != 0)
                        {
                            this.x[num11] = num2;
                            this.r[0]     = (int)((sbyte)i);
                            this.r[1]     = (int)((sbyte)num3);
                            i             = SharedUtils.URShift(num2, num12 - num3);
                            this.r[2]     = num13 - this.u[num11 - 1] - i;
                            Array.Copy(this.r, 0, hp, (this.u[num11 - 1] + i) * 3, 3);
                        }
                        else
                        {
                            t[0] = num13;
                        }
                    }
                    this.r[1] = (int)((sbyte)(j - num12));
                    if (num >= n)
                    {
                        this.r[0] = 192;
                    }
                    else if (v[num] < s)
                    {
                        this.r[0] = (int)((v[num] < 256) ? 0 : 96);
                        this.r[2] = v[num++];
                    }
                    else
                    {
                        this.r[0] = (int)((sbyte)(e[v[num] - s] + 16 + 64));
                        this.r[2] = d[v[num++] - s];
                    }
                    num16 = 1 << j - num12;
                    for (i = SharedUtils.URShift(num2, num12); i < num14; i += num16)
                    {
                        Array.Copy(this.r, 0, hp, (num13 + i) * 3, 3);
                    }
                    i = 1 << j - 1;
                    while ((num2 & i) != 0)
                    {
                        num2 ^= i;
                        i     = SharedUtils.URShift(i, 1);
                    }
                    num2 ^= i;
                    int num17 = (1 << num12) - 1;
                    while ((num2 & num17) != this.x[num11])
                    {
                        num11--;
                        num12 -= num3;
                        num17  = (1 << num12) - 1;
                    }
                }
                j++;
            }
            if (num5 != 0)
            {
                if (num4 != 1)
                {
                    return(-5);
                }
            }
            return(0);
        }