infcodes.java

j2me解压缩j2me解压缩j2me解压缩j2me解压缩j2me解压缩j2me解压缩j2me解压缩j2me解压缩

                    tree_index = dtree_index;
                    mode = DIST;
                case DIST:          // i: get distance next
                    j = need;

                    while (k < (j))
                    {
                        if (n != 0)
                        {
                            r = Z_OK;
                        }
                        else
                        {

                            s.bitb = b;
                            s.bitk = k;
                            z.avail_in = n;
                            z.total_in += p - z.next_in_index;
                            z.next_in_index = p;
                            s.write = q;
                            return s.inflate_flush(z, r);
                        }
                        n--;
                        b |= (z.next_in[p++] & 0xff) << k;
                        k += 8;
                    }

                    tindex = (tree_index + (b & inflate_mask[j])) * 3;

                    //b>>=tree[tindex+1];
                    b >>= tree.get(tindex + 1);
                    //k-=tree[tindex+1];
                    k -= tree.get(tindex + 1);

                    //e = (tree[tindex]);
                    e = (tree.get(tindex));
                    if ((e & 16) != 0)
                    {               // distance
                        get = e & 15;
                        //dist = tree[tindex+2];
                        dist = tree.get(tindex + 2);
                        mode = DISTEXT;
                        break;
                    }
                    if ((e & 64) == 0)
                    {        // next table
                        need = e;
                        //tree_index = tindex/3 + tree[tindex+2];
                        tree_index = tindex / 3 + tree.get(tindex + 2);
                        break;
                    }
                    mode = BADCODE;        // invalid code
                    z.msg = "invalid distance code";
                    r = Z_DATA_ERROR;

                    s.bitb = b;
                    s.bitk = k;
                    z.avail_in = n;
                    z.total_in += p - z.next_in_index;
                    z.next_in_index = p;
                    s.write = q;
                    return s.inflate_flush(z, r);

                case DISTEXT:       // i: getting distance extra
                    j = get;

                    while (k < (j))
                    {
                        if (n != 0)
                        {
                            r = Z_OK;
                        }
                        else
                        {

                            s.bitb = b;
                            s.bitk = k;
                            z.avail_in = n;
                            z.total_in += p - z.next_in_index;
                            z.next_in_index = p;
                            s.write = q;
                            return s.inflate_flush(z, r);
                        }
                        n--;
                        b |= (z.next_in[p++] & 0xff) << k;
                        k += 8;
                    }

                    dist += (b & inflate_mask[j]);

                    b >>= j;
                    k -= j;

                    mode = COPY;
                case COPY:          // o: copying bytes in window, waiting for space
                    f = q - dist;
                    while (f < 0)
                    {     // modulo window size-"while" instead
                        f += s.end;     // of "if" handles invalid distances
                    }
                    while (len != 0)
                    {

                        if (m == 0)
                        {
                            if (q == s.end && s.read != 0)
                            {
                                q = 0;
                                m = q < s.read ? s.read - q - 1 : s.end - q;
                            }
                            if (m == 0)
                            {
                                s.write = q;
                                r = s.inflate_flush(z, r);
                                q = s.write;
                                m = q < s.read ? s.read - q - 1 : s.end - q;

                                if (q == s.end && s.read != 0)
                                {
                                    q = 0;
                                    m = q < s.read ? s.read - q - 1 : s.end - q;
                                }

                                if (m == 0)
                                {
                                    s.bitb = b;
                                    s.bitk = k;
                                    z.avail_in = n;
                                    z.total_in += p - z.next_in_index;
                                    z.next_in_index = p;
                                    s.write = q;
                                    return s.inflate_flush(z, r);
                                }
                            }
                        }

                        //s.window[q++]=s.window[f++]; m--;
                        s.window.set(q++, s.window.get(f++));
                        m--;

                        if (f == s.end)
                        {
                            f = 0;
                        }
                        len--;
                    }
                    mode = START;
                    break;
                case LIT:           // o: got literal, waiting for output space
                    if (m == 0)
                    {
                        if (q == s.end && s.read != 0)
                        {
                            q = 0;
                            m = q < s.read ? s.read - q - 1 : s.end - q;
                        }
                        if (m == 0)
                        {
                            s.write = q;
                            r = s.inflate_flush(z, r);
                            q = s.write;
                            m = q < s.read ? s.read - q - 1 : s.end - q;

                            if (q == s.end && s.read != 0)
                            {
                                q = 0;
                                m = q < s.read ? s.read - q - 1 : s.end - q;
                            }
                            if (m == 0)
                            {
                                s.bitb = b;
                                s.bitk = k;
                                z.avail_in = n;
                                z.total_in += p - z.next_in_index;
                                z.next_in_index = p;
                                s.write = q;
                                return s.inflate_flush(z, r);
                            }
                        }
                    }
                    r = Z_OK;

                    //s.window[q++]=(byte)lit; m--;
                    s.window.set(q++, (byte) lit);
                    m--;

                    mode = START;
                    break;
                case WASH:           // o: got eob, possibly more output
                    if (k > 7)
                    {        // return unused byte, if any
                        k -= 8;
                        n++;
                        p--;             // can always return one
                    }

                    s.write = q;
                    r = s.inflate_flush(z, r);
                    q = s.write;
                    m = q < s.read ? s.read - q - 1 : s.end - q;

                    if (s.read != s.write)
                    {
                        s.bitb = b;
                        s.bitk = k;
                        z.avail_in = n;
                        z.total_in += p - z.next_in_index;
                        z.next_in_index = p;
                        s.write = q;
                        return s.inflate_flush(z, r);
                    }
                    mode = END;
                case END:
                    r = Z_STREAM_END;
                    s.bitb = b;
                    s.bitk = k;
                    z.avail_in = n;
                    z.total_in += p - z.next_in_index;
                    z.next_in_index = p;
                    s.write = q;
                    return s.inflate_flush(z, r);

                case BADCODE:       // x: got error

                    r = Z_DATA_ERROR;

                    s.bitb = b;
                    s.bitk = k;
                    z.avail_in = n;
                    z.total_in += p - z.next_in_index;
                    z.next_in_index = p;
                    s.write = q;
                    return s.inflate_flush(z, r);

                default:
                    r = Z_STREAM_ERROR;

                    s.bitb = b;
                    s.bitk = k;
                    z.avail_in = n;
                    z.total_in += p - z.next_in_index;
                    z.next_in_index = p;
                    s.write = q;
                    return s.inflate_flush(z, r);
            }
        }
    }

    void free(ZStream z)
    {
    //  ZFREE(z, c);
    }

    // Called with number of bytes left to write in window at least 258
    // (the maximum string length) and number of input bytes available
    // at least ten.  The ten bytes are six bytes for the longest length/
    // distance pair plus four bytes for overloading the bit buffer.
    int inflate_fast(int bl, int bd,
                     int_AccessibleArray tl, int tl_index,
                     int_AccessibleArray td, int td_index,
                     InfBlocks s, ZStream z)
    {
        int t;                // temporary pointer
        int_AccessibleArray tp;             // temporary pointer
        int tp_index;         // temporary pointer
        int e;                // extra bits or operation
        int b;                // bit buffer
        int k;                // bits in bit buffer
        int p;                // input data pointer
        int n;                // bytes available there
        int q;                // output window write pointer
        int m;                // bytes to end of window or read pointer
        int ml;               // mask for literal/length tree
        int md;               // mask for distance tree
        int c;                // bytes to copy
        int d;                // distance back to copy from
        int r;                // copy source pointer

        // load input, output, bit values
        p = z.next_in_index;