diff --git a/codec-http/pom.xml b/codec-http/pom.xml index 8edf9d6505..e2fa8a81c6 100644 --- a/codec-http/pom.xml +++ b/codec-http/pom.xml @@ -39,6 +39,11 @@ netty-handler ${project.version} + + com.jcraft + jzlib + true + diff --git a/codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyHeaderBlockJZlibCompressor.java b/codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyHeaderBlockJZlibCompressor.java index 9d376fd8e5..6737c78d14 100644 --- a/codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyHeaderBlockJZlibCompressor.java +++ b/codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyHeaderBlockJZlibCompressor.java @@ -16,14 +16,15 @@ package io.netty.handler.codec.spdy; import static io.netty.handler.codec.spdy.SpdyCodecUtil.*; + +import com.jcraft.jzlib.Deflater; +import com.jcraft.jzlib.JZlib; import io.netty.buffer.ByteBuf; import io.netty.handler.codec.compression.CompressionException; -import io.netty.util.internal.jzlib.JZlib; -import io.netty.util.internal.jzlib.ZStream; class SpdyHeaderBlockJZlibCompressor extends SpdyHeaderBlockCompressor { - private final ZStream z = new ZStream(); + private final Deflater z = new Deflater(); public SpdyHeaderBlockJZlibCompressor( int version, int compressionLevel, int windowBits, int memLevel) { diff --git a/codec/pom.xml b/codec/pom.xml index 82bff19b6e..056d6e58e7 100644 --- a/codec/pom.xml +++ b/codec/pom.xml @@ -44,6 +44,11 @@ jboss-marshalling true + + com.jcraft + jzlib + true + diff --git a/codec/src/main/java/io/netty/handler/codec/compression/JZlibDecoder.java b/codec/src/main/java/io/netty/handler/codec/compression/JZlibDecoder.java index 78c3fd60cc..a4dfe4a0a9 100644 --- a/codec/src/main/java/io/netty/handler/codec/compression/JZlibDecoder.java +++ b/codec/src/main/java/io/netty/handler/codec/compression/JZlibDecoder.java @@ -17,12 +17,12 @@ package io.netty.handler.codec.compression; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; -import io.netty.util.internal.jzlib.JZlib; -import io.netty.util.internal.jzlib.ZStream; +import com.jcraft.jzlib.JZlib; +import com.jcraft.jzlib.Inflater; public class JZlibDecoder extends ZlibDecoder { - private final ZStream z = new ZStream(); + private final Inflater z = new Inflater(); private byte[] dictionary; private volatile boolean finished; @@ -45,7 +45,7 @@ public class JZlibDecoder extends ZlibDecoder { throw new NullPointerException("wrapper"); } - int resultCode = z.inflateInit(ZlibUtil.convertWrapperType(wrapper)); + int resultCode = z.init(ZlibUtil.convertWrapperType(wrapper)); if (resultCode != JZlib.Z_OK) { ZlibUtil.fail(z, "initialization failure", resultCode); } diff --git a/codec/src/main/java/io/netty/handler/codec/compression/JZlibEncoder.java b/codec/src/main/java/io/netty/handler/codec/compression/JZlibEncoder.java index 8085134718..29c9be678b 100644 --- a/codec/src/main/java/io/netty/handler/codec/compression/JZlibEncoder.java +++ b/codec/src/main/java/io/netty/handler/codec/compression/JZlibEncoder.java @@ -21,8 +21,8 @@ import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelFutureListener; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelPromise; -import io.netty.util.internal.jzlib.JZlib; -import io.netty.util.internal.jzlib.ZStream; +import com.jcraft.jzlib.JZlib; +import com.jcraft.jzlib.Deflater; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; @@ -35,7 +35,7 @@ public class JZlibEncoder extends ZlibEncoder { private static final byte[] EMPTY_ARRAY = new byte[0]; - private final ZStream z = new ZStream(); + private final Deflater z = new Deflater(); private final AtomicBoolean finished = new AtomicBoolean(); private volatile ChannelHandlerContext ctx; @@ -140,7 +140,7 @@ public class JZlibEncoder extends ZlibEncoder { } synchronized (z) { - int resultCode = z.deflateInit( + int resultCode = z.init( compressionLevel, windowBits, memLevel, ZlibUtil.convertWrapperType(wrapper)); if (resultCode != JZlib.Z_OK) { diff --git a/codec/src/main/java/io/netty/handler/codec/compression/ZlibUtil.java b/codec/src/main/java/io/netty/handler/codec/compression/ZlibUtil.java index bcb9af3c8a..fd8411dfd0 100644 --- a/codec/src/main/java/io/netty/handler/codec/compression/ZlibUtil.java +++ b/codec/src/main/java/io/netty/handler/codec/compression/ZlibUtil.java @@ -15,8 +15,8 @@ */ package io.netty.handler.codec.compression; -import io.netty.util.internal.jzlib.JZlib; -import io.netty.util.internal.jzlib.ZStream; +import com.jcraft.jzlib.JZlib; +import com.jcraft.jzlib.ZStream; /** * Utility methods used by {@link JZlibEncoder} and {@link JZlibDecoder}. @@ -32,8 +32,8 @@ final class ZlibUtil { (z.msg != null? ": " + z.msg : "")); } - static Enum convertWrapperType(ZlibWrapper wrapper) { - Enum convertedWrapperType; + static JZlib.WrapperType convertWrapperType(ZlibWrapper wrapper) { + JZlib.WrapperType convertedWrapperType; switch (wrapper) { case NONE: convertedWrapperType = JZlib.W_NONE; @@ -45,7 +45,7 @@ final class ZlibUtil { convertedWrapperType = JZlib.W_GZIP; break; case ZLIB_OR_NONE: - convertedWrapperType = JZlib.W_ZLIB_OR_NONE; + convertedWrapperType = JZlib.W_ANY; break; default: throw new Error(); diff --git a/codec/src/test/java/io/netty/handler/codec/compression/JZlibTest.java b/codec/src/test/java/io/netty/handler/codec/compression/JZlibTest.java new file mode 100644 index 0000000000..3176133117 --- /dev/null +++ b/codec/src/test/java/io/netty/handler/codec/compression/JZlibTest.java @@ -0,0 +1,133 @@ +/* + * Copyright 2013 The Netty Project + * + * The Netty Project licenses this file to you under the Apache License, + * version 2.0 (the "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + */ +package io.netty.handler.codec.compression; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import org.junit.After; +import org.junit.Test; +import io.netty.channel.embedded.EmbeddedByteChannel; + +import static org.junit.Assert.*; + +public class JZlibTest { + + @After + public void resetSnappy() { + } + + @Test + public void testZLIB() throws Exception { + ByteBuf data = Unpooled.wrappedBuffer("test".getBytes()); + + EmbeddedByteChannel chEncoder = + new EmbeddedByteChannel(new JZlibEncoder(ZlibWrapper.ZLIB)); + + chEncoder.writeOutbound(data); + assertTrue(chEncoder.finish()); + + byte[] deflatedData = chEncoder.readOutbound().array(); + + { + EmbeddedByteChannel chDecoder = + new EmbeddedByteChannel(new JZlibDecoder(ZlibWrapper.ZLIB)); + + chDecoder.writeInbound(Unpooled.wrappedBuffer(deflatedData)); + assertTrue(chDecoder.finish()); + + assertEquals(data, chDecoder.readInbound()); + } + + { + EmbeddedByteChannel chDecoder = + new EmbeddedByteChannel(new JZlibDecoder(ZlibWrapper.ZLIB_OR_NONE)); + + chDecoder.writeInbound(Unpooled.wrappedBuffer(deflatedData)); + assertTrue(chDecoder.finish()); + + assertEquals(data, chDecoder.readInbound()); + } + } + + @Test + public void testNONE() throws Exception { + ByteBuf data = Unpooled.wrappedBuffer("test".getBytes()); + + EmbeddedByteChannel chEncoder = + new EmbeddedByteChannel(new JZlibEncoder(ZlibWrapper.NONE)); + + chEncoder.writeOutbound(data); + assertTrue(chEncoder.finish()); + + byte[] deflatedData = chEncoder.readOutbound().array(); + + { + EmbeddedByteChannel chDecoder = + new EmbeddedByteChannel(new JZlibDecoder(ZlibWrapper.NONE)); + + chDecoder.writeInbound(Unpooled.wrappedBuffer(deflatedData)); + assertTrue(chDecoder.finish()); + + assertEquals(data, chDecoder.readInbound()); + } + + { + EmbeddedByteChannel chDecoder = + new EmbeddedByteChannel(new JZlibDecoder(ZlibWrapper.ZLIB_OR_NONE)); + + chDecoder.writeInbound(Unpooled.wrappedBuffer(deflatedData)); + assertTrue(chDecoder.finish()); + + assertEquals(data, chDecoder.readInbound()); + } + } + + + @Test + public void testGZIP() throws Exception { + ByteBuf data = Unpooled.wrappedBuffer("test".getBytes()); + + EmbeddedByteChannel chEncoder = + new EmbeddedByteChannel(new JZlibEncoder(ZlibWrapper.GZIP)); + + chEncoder.writeOutbound(data); + assertTrue(chEncoder.finish()); + + byte[] deflatedData = chEncoder.readOutbound().array(); + + { + EmbeddedByteChannel chDecoder = + new EmbeddedByteChannel(new JZlibDecoder(ZlibWrapper.GZIP)); + + chDecoder.writeInbound(Unpooled.wrappedBuffer(deflatedData)); + assertTrue(chDecoder.finish()); + + assertEquals(data, chDecoder.readInbound()); + } + + + // This case will be failed with netty's jzlib. + { + EmbeddedByteChannel chDecoder = + new EmbeddedByteChannel(new JZlibDecoder(ZlibWrapper.ZLIB_OR_NONE)); + + chDecoder.writeInbound(Unpooled.wrappedBuffer(deflatedData)); + assertTrue(chDecoder.finish()); + + assertEquals(data, chDecoder.readInbound()); + } + } +} diff --git a/common/src/main/java/io/netty/util/internal/jzlib/Adler32.java b/common/src/main/java/io/netty/util/internal/jzlib/Adler32.java deleted file mode 100644 index 8167069c8c..0000000000 --- a/common/src/main/java/io/netty/util/internal/jzlib/Adler32.java +++ /dev/null @@ -1,119 +0,0 @@ -/* - * Copyright 2012 The Netty Project - * - * The Netty Project licenses this file to you under the Apache License, - * version 2.0 (the "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - */ -/* -Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the distribution. - - 3. The names of the authors may not be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, -INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, -OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, -EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * This program is based on zlib-1.1.3, so all credit should go authors - * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu) - * and contributors of zlib. - */ -package io.netty.util.internal.jzlib; - -final class Adler32 { - - // largest prime smaller than 65536 - private static final int BASE = 65521; - // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 - private static final int NMAX = 5552; - - static long adler32(long adler, byte[] buf, int index, int len) { - if (buf == null) { - return 1L; - } - - long s1 = adler & 0xffff; - long s2 = adler >> 16 & 0xffff; - int k; - - while (len > 0) { - k = len < NMAX? len : NMAX; - len -= k; - while (k >= 16) { - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - s1 += buf[index ++] & 0xff; - s2 += s1; - k -= 16; - } - if (k != 0) { - do { - s1 += buf[index ++] & 0xff; - s2 += s1; - } while (-- k != 0); - } - s1 %= BASE; - s2 %= BASE; - } - return s2 << 16 | s1; - } - - private Adler32() { - // Utility Class - } -} diff --git a/common/src/main/java/io/netty/util/internal/jzlib/CRC32.java b/common/src/main/java/io/netty/util/internal/jzlib/CRC32.java deleted file mode 100644 index a0ee9e60a3..0000000000 --- a/common/src/main/java/io/netty/util/internal/jzlib/CRC32.java +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Copyright 2012 The Netty Project - * - * The Netty Project licenses this file to you under the Apache License, - * version 2.0 (the "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - */ -/* -Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the distribution. - - 3. The names of the authors may not be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, -INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, -OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, -EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * This program is based on zlib-1.1.3, so all credit should go authors - * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu) - * and contributors of zlib. - */ -package io.netty.util.internal.jzlib; - -final class CRC32 { - private static final int[] TABLE = { - 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, - 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, - 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, - 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, - 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, - 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, - 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, - 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, - 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, - 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, - 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, - 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, - 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, - 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, - 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, - 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, - 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, - 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, - 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, - 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, - 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, - 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, - 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, - 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, - 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, - 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, - 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, - 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, - 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, - 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, - 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, - 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d, - }; - - static int crc32(int crc32, byte[] buf, int index, int len) { - final int endIndex = index + len; - crc32 ^= 0xffffffff; - for (int i = index; i < endIndex; i ++) { - crc32 = crc32 >>> 8 ^ TABLE[(crc32 ^ buf[i]) & 0xff]; - } - crc32 ^= 0xffffffff; - return crc32; - } - - private CRC32() { - // Utility Class - } -} diff --git a/common/src/main/java/io/netty/util/internal/jzlib/Deflate.java b/common/src/main/java/io/netty/util/internal/jzlib/Deflate.java deleted file mode 100644 index 07bc459d00..0000000000 --- a/common/src/main/java/io/netty/util/internal/jzlib/Deflate.java +++ /dev/null @@ -1,1678 +0,0 @@ -/* - * Copyright 2012 The Netty Project - * - * The Netty Project licenses this file to you under the Apache License, - * version 2.0 (the "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - */ -/* -Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the distribution. - - 3. The names of the authors may not be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, -INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, -OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, -EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * This program is based on zlib-1.1.3, so all credit should go authors - * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu) - * and contributors of zlib. - */ -package io.netty.util.internal.jzlib; - -import io.netty.util.internal.jzlib.JZlib.WrapperType; - -final class Deflate { - - private static final class Config { - final int good_length; // reduce lazy search above this match length - final int max_lazy; // do not perform lazy search above this match length - final int nice_length; // quit search above this match length - final int max_chain; - final int func; - - Config(int good_length, int max_lazy, int nice_length, int max_chain, - int func) { - this.good_length = good_length; - this.max_lazy = max_lazy; - this.nice_length = nice_length; - this.max_chain = max_chain; - this.func = func; - } - } - - private static final int STORED = 0; - private static final int FAST = 1; - private static final int SLOW = 2; - - private static final Config[] config_table; - static { - config_table = new Config[10]; - config_table[0] = new Config(0, 0, 0, 0, STORED); - config_table[1] = new Config(4, 4, 8, 4, FAST); - config_table[2] = new Config(4, 5, 16, 8, FAST); - config_table[3] = new Config(4, 6, 32, 32, FAST); - - config_table[4] = new Config(4, 4, 16, 16, SLOW); - config_table[5] = new Config(8, 16, 32, 32, SLOW); - config_table[6] = new Config(8, 16, 128, 128, SLOW); - config_table[7] = new Config(8, 32, 128, 256, SLOW); - config_table[8] = new Config(32, 128, 258, 1024, SLOW); - config_table[9] = new Config(32, 258, 258, 4096, SLOW); - } - - private static final String[] z_errmsg = { "need dictionary", // Z_NEED_DICT 2 - "stream end", // Z_STREAM_END 1 - "", // Z_OK 0 - "file error", // Z_ERRNO (-1) - "stream error", // Z_STREAM_ERROR (-2) - "data error", // Z_DATA_ERROR (-3) - "insufficient memory", // Z_MEM_ERROR (-4) - "buffer error", // Z_BUF_ERROR (-5) - "incompatible version", // Z_VERSION_ERROR (-6) - "" }; - - // block not completed, need more input or more output - private static final int NeedMore = 0; - // block flush performed - private static final int BlockDone = 1; - // finish started, need only more output at next deflate - private static final int FinishStarted = 2; - // finish done, accept no more input or output - private static final int FinishDone = 3; - private static final int INIT_STATE = 42; - private static final int BUSY_STATE = 113; - private static final int FINISH_STATE = 666; - private static final int STORED_BLOCK = 0; - private static final int STATIC_TREES = 1; - private static final int DYN_TREES = 2; - // The three kinds of block type - private static final int Z_BINARY = 0; - private static final int Z_ASCII = 1; - private static final int Z_UNKNOWN = 2; - private static final int Buf_size = 8 * 2; - // repeat previous bit length 3-6 times (2 bits of repeat count) - private static final int REP_3_6 = 16; - // repeat a zero length 3-10 times (3 bits of repeat count) - private static final int REPZ_3_10 = 17; - // repeat a zero length 11-138 times (7 bits of repeat count) - private static final int REPZ_11_138 = 18; - private static final int MIN_MATCH = 3; - private static final int MAX_MATCH = 258; - private static final int MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1; - private static final int END_BLOCK = 256; - ZStream strm; // pointer back to this zlib stream - int status; // as the name implies - byte[] pending_buf; // output still pending - int pending_buf_size; // size of pending_buf - int pending_out; // next pending byte to output to the stream - int pending; // nb of bytes in the pending buffer - WrapperType wrapperType; - private boolean wroteTrailer; - byte data_type; // UNKNOWN, BINARY or ASCII - int last_flush; // value of flush param for previous deflate call - int w_size; // LZ77 window size (32K by default) - int w_bits; // log2(w_size) (8..16) - int w_mask; // w_size - 1 - byte[] window; - // Sliding window. Input bytes are read into the second half of the window, - // and move to the first half later to keep a dictionary of at least wSize - // bytes. With this organization, matches are limited to a distance of - // wSize-MAX_MATCH bytes, but this ensures that IO is always - // performed with a length multiple of the block size. Also, it limits - // the window size to 64K, which is quite useful on MSDOS. - // To do: use the user input buffer as sliding window. - int window_size; - // Actual size of window: 2*wSize, except when the user input buffer - // is directly used as sliding window. - short[] prev; - // Link to older string with same hash index. To limit the size of this - // array to 64K, this link is maintained only for the last 32K strings. - // An index in this array is thus a window index modulo 32K. - short[] head; // Heads of the hash chains or NIL. - int ins_h; // hash index of string to be inserted - int hash_size; // number of elements in hash table - int hash_bits; // log2(hash_size) - int hash_mask; // hash_size-1 - // Number of bits by which ins_h must be shifted at each input - // step. It must be such that after MIN_MATCH steps, the oldest - // byte no longer takes part in the hash key, that is: - // hash_shift * MIN_MATCH >= hash_bits - int hash_shift; - // Window position at the beginning of the current output block. Gets - // negative when the window is moved backwards. - int block_start; - int match_length; // length of best match - int prev_match; // previous match - int match_available; // set if previous match exists - int strstart; // start of string to insert - int match_start; // start of matching string - int lookahead; // number of valid bytes ahead in window - // Length of the best match at previous step. Matches not greater than this - // are discarded. This is used in the lazy match evaluation. - int prev_length; - // To speed up deflation, hash chains are never searched beyond this - // length. A higher limit improves compression ratio but degrades the speed. - int max_chain_length; - // Attempt to find a better match only when the current match is strictly - // smaller than this value. This mechanism is used only for compression - // levels >= 4. - int max_lazy_match; - // Insert new strings in the hash table only if the match length is not - // greater than this length. This saves time but degrades compression. - // max_insert_length is used only for compression levels <= 3. - int level; // compression level (1..9) - int strategy; // favor or force Huffman coding - // Use a faster search when the previous match is longer than this - int good_match; - // Stop searching when current match exceeds this - int nice_match; - final short[] dyn_ltree; // literal and length tree - final short[] dyn_dtree; // distance tree - final short[] bl_tree; // Huffman tree for bit lengths - final Tree l_desc = new Tree(); // desc for literal tree - final Tree d_desc = new Tree(); // desc for distance tree - final Tree bl_desc = new Tree(); // desc for bit length tree - // number of codes at each bit length for an optimal tree - final short[] bl_count = new short[JZlib.MAX_BITS + 1]; - // heap used to build the Huffman trees - final int[] heap = new int[2 * JZlib.L_CODES + 1]; - int heap_len; // number of elements in the heap - int heap_max; // element of largest frequency - // The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. - // The same heap array is used to build all trees. - // Depth of each subtree used as tie breaker for trees of equal frequency - final byte[] depth = new byte[2 * JZlib.L_CODES + 1]; - int l_buf; // index for literals or lengths */ - // Size of match buffer for literals/lengths. There are 4 reasons for - // limiting lit_bufsize to 64K: - // - frequencies can be kept in 16 bit counters - // - if compression is not successful for the first block, all input - // data is still in the window so we can still emit a stored block even - // when input comes from standard input. (This can also be done for - // all blocks if lit_bufsize is not greater than 32K.) - // - if compression is not successful for a file smaller than 64K, we can - // even emit a stored file instead of a stored block (saving 5 bytes). - // This is applicable only for zip (not gzip or zlib). - // - creating new Huffman trees less frequently may not provide fast - // adaptation to changes in the input data statistics. (Take for - // example a binary file with poorly compressible code followed by - // a highly compressible string table.) Smaller buffer sizes give - // fast adaptation but have of course the overhead of transmitting - // trees more frequently. - // - I can't count above 4 - int lit_bufsize; - int last_lit; // running index in l_buf - // Buffer for distances. To simplify the code, d_buf and l_buf have - // the same number of elements. To use different lengths, an extra flag - // array would be necessary. - int d_buf; // index of pendig_buf - int opt_len; // bit length of current block with optimal trees - int static_len; // bit length of current block with static trees - int matches; // number of string matches in current block - int last_eob_len; // bit length of EOB code for last block - // Output buffer. bits are inserted starting at the bottom (least - // significant bits). - short bi_buf; - // Number of valid bits in bi_buf. All bits above the last valid bit - // are always zero. - int bi_valid; - private int gzipUncompressedBytes; - - Deflate() { - dyn_ltree = new short[JZlib.HEAP_SIZE * 2]; - dyn_dtree = new short[(2 * JZlib.D_CODES + 1) * 2]; // distance tree - bl_tree = new short[(2 * JZlib.BL_CODES + 1) * 2]; // Huffman tree for bit lengths - } - - private void lm_init() { - window_size = 2 * w_size; - - // Set the default configuration parameters: - max_lazy_match = config_table[level].max_lazy; - good_match = config_table[level].good_length; - nice_match = config_table[level].nice_length; - max_chain_length = config_table[level].max_chain; - - strstart = 0; - block_start = 0; - lookahead = 0; - match_length = prev_length = MIN_MATCH - 1; - match_available = 0; - ins_h = 0; - } - - // Initialize the tree data structures for a new zlib stream. - private void tr_init() { - - l_desc.dyn_tree = dyn_ltree; - l_desc.stat_desc = StaticTree.static_l_desc; - - d_desc.dyn_tree = dyn_dtree; - d_desc.stat_desc = StaticTree.static_d_desc; - - bl_desc.dyn_tree = bl_tree; - bl_desc.stat_desc = StaticTree.static_bl_desc; - - bi_buf = 0; - bi_valid = 0; - last_eob_len = 8; // enough lookahead for inflate - - // Initialize the first block of the first file: - init_block(); - } - - private void init_block() { - // Initialize the trees. - for (int i = 0; i < JZlib.L_CODES; i ++) { - dyn_ltree[i * 2] = 0; - } - for (int i = 0; i < JZlib.D_CODES; i ++) { - dyn_dtree[i * 2] = 0; - } - for (int i = 0; i < JZlib.BL_CODES; i ++) { - bl_tree[i * 2] = 0; - } - - dyn_ltree[END_BLOCK * 2] = 1; - opt_len = static_len = 0; - last_lit = matches = 0; - } - - // Restore the heap property by moving down the tree starting at node k, - // exchanging a node with the smallest of its two sons if necessary, stopping - // when the heap property is re-established (each father smaller than its - // two sons). - void pqdownheap(short[] tree, // the tree to restore - int k // node to move down - ) { - int v = heap[k]; - int j = k << 1; // left son of k - while (j <= heap_len) { - // Set j to the smallest of the two sons: - if (j < heap_len && smaller(tree, heap[j + 1], heap[j], depth)) { - j ++; - } - // Exit if v is smaller than both sons - if (smaller(tree, v, heap[j], depth)) { - break; - } - - // Exchange v with the smallest son - heap[k] = heap[j]; - k = j; - // And continue down the tree, setting j to the left son of k - j <<= 1; - } - heap[k] = v; - } - - private static boolean smaller(short[] tree, int n, int m, byte[] depth) { - short tn2 = tree[n * 2]; - short tm2 = tree[m * 2]; - return tn2 < tm2 || tn2 == tm2 && depth[n] <= depth[m]; - } - - // Scan a literal or distance tree to determine the frequencies of the codes - // in the bit length tree. - private void scan_tree(short[] tree, // the tree to be scanned - int max_code // and its largest code of non zero frequency - ) { - int n; // iterates over all tree elements - int prevlen = -1; // last emitted length - int curlen; // length of current code - int nextlen = tree[1]; // length of next code - int count = 0; // repeat count of the current code - int max_count = 7; // max repeat count - int min_count = 4; // min repeat count - - if (nextlen == 0) { - max_count = 138; - min_count = 3; - } - tree[(max_code + 1) * 2 + 1] = (short) 0xffff; // guard - - for (n = 0; n <= max_code; n ++) { - curlen = nextlen; - nextlen = tree[(n + 1) * 2 + 1]; - if (++ count < max_count && curlen == nextlen) { - continue; - } - if (count < min_count) { - bl_tree[curlen * 2] += count; - } else if (curlen != 0) { - if (curlen != prevlen) { - bl_tree[curlen * 2] ++; - } - bl_tree[REP_3_6 * 2] ++; - } else if (count <= 10) { - bl_tree[REPZ_3_10 * 2] ++; - } else { - bl_tree[REPZ_11_138 * 2] ++; - } - count = 0; - prevlen = curlen; - if (nextlen == 0) { - max_count = 138; - min_count = 3; - } else if (curlen == nextlen) { - max_count = 6; - min_count = 3; - } else { - max_count = 7; - min_count = 4; - } - } - } - - // Construct the Huffman tree for the bit lengths and return the index in - // bl_order of the last bit length code to send. - private int build_bl_tree() { - int max_blindex; // index of last bit length code of non zero freq - - // Determine the bit length frequencies for literal and distance trees - scan_tree(dyn_ltree, l_desc.max_code); - scan_tree(dyn_dtree, d_desc.max_code); - - // Build the bit length tree: - bl_desc.build_tree(this); - // opt_len now includes the length of the tree representations, except - // the lengths of the bit lengths codes and the 5+5+4 bits for the counts. - - // Determine the number of bit length codes to send. The pkzip format - // requires that at least 4 bit length codes be sent. (appnote.txt says - // 3 but the actual value used is 4.) - for (max_blindex = JZlib.BL_CODES - 1; max_blindex >= 3; max_blindex --) { - if (bl_tree[Tree.bl_order[max_blindex] * 2 + 1] != 0) { - break; - } - } - // Update opt_len to include the bit length tree and counts - opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; - - return max_blindex; - } - - // Send the header for a block using dynamic Huffman trees: the counts, the - // lengths of the bit length codes, the literal tree and the distance tree. - // IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. - private void send_all_trees(int lcodes, int dcodes, int blcodes) { - int rank; // index in bl_order - - send_bits(lcodes - 257, 5); // not +255 as stated in appnote.txt - send_bits(dcodes - 1, 5); - send_bits(blcodes - 4, 4); // not -3 as stated in appnote.txt - for (rank = 0; rank < blcodes; rank ++) { - send_bits(bl_tree[Tree.bl_order[rank] * 2 + 1], 3); - } - send_tree(dyn_ltree, lcodes - 1); // literal tree - send_tree(dyn_dtree, dcodes - 1); // distance tree - } - - // Send a literal or distance tree in compressed form, using the codes in - // bl_tree. - private void send_tree(short[] tree, // the tree to be sent - int max_code // and its largest code of non zero frequency - ) { - int n; // iterates over all tree elements - int prevlen = -1; // last emitted length - int curlen; // length of current code - int nextlen = tree[1]; // length of next code - int count = 0; // repeat count of the current code - int max_count = 7; // max repeat count - int min_count = 4; // min repeat count - - if (nextlen == 0) { - max_count = 138; - min_count = 3; - } - - for (n = 0; n <= max_code; n ++) { - curlen = nextlen; - nextlen = tree[(n + 1) * 2 + 1]; - if (++ count < max_count && curlen == nextlen) { - continue; - } - if (count < min_count) { - do { - send_code(curlen, bl_tree); - } while (-- count != 0); - } else if (curlen != 0) { - if (curlen != prevlen) { - send_code(curlen, bl_tree); - count --; - } - send_code(REP_3_6, bl_tree); - send_bits(count - 3, 2); - } else if (count <= 10) { - send_code(REPZ_3_10, bl_tree); - send_bits(count - 3, 3); - } else { - send_code(REPZ_11_138, bl_tree); - send_bits(count - 11, 7); - } - count = 0; - prevlen = curlen; - if (nextlen == 0) { - max_count = 138; - min_count = 3; - } else if (curlen == nextlen) { - max_count = 6; - min_count = 3; - } else { - max_count = 7; - min_count = 4; - } - } - } - - // Output a byte on the stream. - // IN assertion: there is enough room in pending_buf. - private void put_byte(byte[] p, int start, int len) { - System.arraycopy(p, start, pending_buf, pending, len); - pending += len; - } - - private void put_byte(byte c) { - pending_buf[pending ++] = c; - } - - private void put_short(int w) { - put_byte((byte) w/*&0xff*/); - put_byte((byte) (w >>> 8)); - } - - private void putShortMSB(int b) { - put_byte((byte) (b >> 8)); - put_byte((byte) b/*&0xff*/); - } - - private void send_code(int c, short[] tree) { - int c2 = c * 2; - send_bits(tree[c2] & 0xffff, tree[c2 + 1] & 0xffff); - } - - private void send_bits(int value, int length) { - if (bi_valid > Buf_size - length) { - // bi_buf |= (val << bi_valid); - bi_buf |= value << bi_valid & 0xffff; - put_short(bi_buf); - bi_buf = (short) (value >>> Buf_size - bi_valid); - bi_valid += length - Buf_size; - } else { - // bi_buf |= (value) << bi_valid; - bi_buf |= value << bi_valid & 0xffff; - bi_valid += length; - } - } - - // Send one empty static block to give enough lookahead for inflate. - // This takes 10 bits, of which 7 may remain in the bit buffer. - // The current inflate code requires 9 bits of lookahead. If the - // last two codes for the previous block (real code plus EOB) were coded - // on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode - // the last real code. In this case we send two empty static blocks instead - // of one. (There are no problems if the previous block is stored or fixed.) - // To simplify the code, we assume the worst case of last real code encoded - // on one bit only. - private void _tr_align() { - send_bits(STATIC_TREES << 1, 3); - send_code(END_BLOCK, StaticTree.static_ltree); - - bi_flush(); - - // Of the 10 bits for the empty block, we have already sent - // (10 - bi_valid) bits. The lookahead for the last real code (before - // the EOB of the previous block) was thus at least one plus the length - // of the EOB plus what we have just sent of the empty static block. - if (1 + last_eob_len + 10 - bi_valid < 9) { - send_bits(STATIC_TREES << 1, 3); - send_code(END_BLOCK, StaticTree.static_ltree); - bi_flush(); - } - last_eob_len = 7; - } - - // Save the match info and tally the frequency counts. Return true if - // the current block must be flushed. - private boolean _tr_tally(int dist, // distance of matched string - int lc // match length-MIN_MATCH or unmatched char (if dist==0) - ) { - - pending_buf[d_buf + last_lit * 2] = (byte) (dist >>> 8); - pending_buf[d_buf + last_lit * 2 + 1] = (byte) dist; - - pending_buf[l_buf + last_lit] = (byte) lc; - last_lit ++; - - if (dist == 0) { - // lc is the unmatched char - dyn_ltree[lc * 2] ++; - } else { - matches ++; - // Here, lc is the match length - MIN_MATCH - dist --; // dist = match distance - 1 - dyn_ltree[(Tree._length_code[lc] + JZlib.LITERALS + 1) * 2] ++; - dyn_dtree[Tree.d_code(dist) * 2] ++; - } - - if ((last_lit & 0x1fff) == 0 && level > 2) { - // Compute an upper bound for the compressed length - int out_length = last_lit * 8; - int in_length = strstart - block_start; - int dcode; - for (dcode = 0; dcode < JZlib.D_CODES; dcode ++) { - out_length += dyn_dtree[dcode * 2] * - (5L + Tree.extra_dbits[dcode]); - } - out_length >>>= 3; - if (matches < last_lit / 2 && out_length < in_length / 2) { - return true; - } - } - - return last_lit == lit_bufsize - 1; - // We avoid equality with lit_bufsize because of wraparound at 64K - // on 16 bit machines and because stored blocks are restricted to - // 64K-1 bytes. - } - - // Send the block data compressed using the given Huffman trees - private void compress_block(short[] ltree, short[] dtree) { - int dist; // distance of matched string - int lc; // match length or unmatched char (if dist == 0) - int lx = 0; // running index in l_buf - int code; // the code to send - int extra; // number of extra bits to send - - if (last_lit != 0) { - do { - dist = pending_buf[d_buf + lx * 2] << 8 & 0xff00 | - pending_buf[d_buf + lx * 2 + 1] & 0xff; - lc = pending_buf[l_buf + lx] & 0xff; - lx ++; - - if (dist == 0) { - send_code(lc, ltree); // send a literal byte - } else { - // Here, lc is the match length - MIN_MATCH - code = Tree._length_code[lc]; - - send_code(code + JZlib.LITERALS + 1, ltree); // send the length code - extra = Tree.extra_lbits[code]; - if (extra != 0) { - lc -= Tree.base_length[code]; - send_bits(lc, extra); // send the extra length bits - } - dist --; // dist is now the match distance - 1 - code = Tree.d_code(dist); - - send_code(code, dtree); // send the distance code - extra = Tree.extra_dbits[code]; - if (extra != 0) { - dist -= Tree.base_dist[code]; - send_bits(dist, extra); // send the extra distance bits - } - } // literal or match pair ? - - // Check that the overlay between pending_buf and d_buf+l_buf is ok: - } while (lx < last_lit); - } - - send_code(END_BLOCK, ltree); - last_eob_len = ltree[END_BLOCK * 2 + 1]; - } - - // Set the data type to ASCII or BINARY, using a crude approximation: - // binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise. - // IN assertion: the fields freq of dyn_ltree are set and the total of all - // frequencies does not exceed 64K (to fit in an int on 16 bit machines). - private void set_data_type() { - int n = 0; - int ascii_freq = 0; - int bin_freq = 0; - while (n < 7) { - bin_freq += dyn_ltree[n * 2]; - n ++; - } - while (n < 128) { - ascii_freq += dyn_ltree[n * 2]; - n ++; - } - while (n < JZlib.LITERALS) { - bin_freq += dyn_ltree[n * 2]; - n ++; - } - data_type = (byte) (bin_freq > ascii_freq >>> 2? Z_BINARY : Z_ASCII); - } - - // Flush the bit buffer, keeping at most 7 bits in it. - private void bi_flush() { - if (bi_valid == 16) { - put_short(bi_buf); - bi_buf = 0; - bi_valid = 0; - } else if (bi_valid >= 8) { - put_byte((byte) bi_buf); - bi_buf >>>= 8; - bi_valid -= 8; - } - } - - // Flush the bit buffer and align the output on a byte boundary - private void bi_windup() { - if (bi_valid > 8) { - put_short(bi_buf); - } else if (bi_valid > 0) { - put_byte((byte) bi_buf); - } - bi_buf = 0; - bi_valid = 0; - } - - // Copy a stored block, storing first the length and its - // one's complement if requested. - private void copy_block(int buf, // the input data - int len, // its length - boolean header // true if block header must be written - ) { - bi_windup(); // align on byte boundary - last_eob_len = 8; // enough lookahead for inflate - - if (header) { - put_short((short) len); - put_short((short) ~len); - } - - // while(len--!=0) { - // put_byte(window[buf+index]); - // index++; - // } - put_byte(window, buf, len); - } - - private void flush_block_only(boolean eof) { - _tr_flush_block(block_start >= 0? block_start : -1, strstart - - block_start, eof); - block_start = strstart; - strm.flush_pending(); - } - - // Copy without compression as much as possible from the input stream, return - // the current block state. - // This function does not insert new strings in the dictionary since - // uncompressible data is probably not useful. This function is used - // only for the level=0 compression option. - // NOTE: this function should be optimized to avoid extra copying from - // window to pending_buf. - private int deflate_stored(int flush) { - // Stored blocks are limited to 0xffff bytes, pending_buf is limited - // to pending_buf_size, and each stored block has a 5 byte header: - - int max_block_size = 0xffff; - int max_start; - - if (max_block_size > pending_buf_size - 5) { - max_block_size = pending_buf_size - 5; - } - - // Copy as much as possible from input to output: - while (true) { - // Fill the window as much as possible: - if (lookahead <= 1) { - fill_window(); - if (lookahead == 0 && flush == JZlib.Z_NO_FLUSH) { - return NeedMore; - } - if (lookahead == 0) { - break; // flush the current block - } - } - - strstart += lookahead; - lookahead = 0; - - // Emit a stored block if pending_buf will be full: - max_start = block_start + max_block_size; - if (strstart == 0 || strstart >= max_start) { - // strstart == 0 is possible when wraparound on 16-bit machine - lookahead = strstart - max_start; - strstart = max_start; - - flush_block_only(false); - if (strm.avail_out == 0) { - return NeedMore; - } - - } - - // Flush if we may have to slide, otherwise block_start may become - // negative and the data will be gone: - if (strstart - block_start >= w_size - MIN_LOOKAHEAD) { - flush_block_only(false); - if (strm.avail_out == 0) { - return NeedMore; - } - } - } - - flush_block_only(flush == JZlib.Z_FINISH); - if (strm.avail_out == 0) { - return flush == JZlib.Z_FINISH? FinishStarted : NeedMore; - } - - return flush == JZlib.Z_FINISH? FinishDone : BlockDone; - } - - // Send a stored block - private void _tr_stored_block(int buf, // input block - int stored_len, // length of input block - boolean eof // true if this is the last block for a file - ) { - //noinspection PointlessArithmeticExpression - send_bits((STORED_BLOCK << 1) + (eof? 1 : 0), 3); // send block type - copy_block(buf, stored_len, true); // with header - } - - // Determine the best encoding for the current block: dynamic trees, static - // trees or store, and output the encoded block to the zip file. - private void _tr_flush_block(int buf, // input block, or NULL if too old - int stored_len, // length of input block - boolean eof // true if this is the last block for a file - ) { - int opt_lenb, static_lenb; // opt_len and static_len in bytes - int max_blindex = 0; // index of last bit length code of non zero freq - - // Build the Huffman trees unless a stored block is forced - if (level > 0) { - // Check if the file is ascii or binary - if (data_type == Z_UNKNOWN) { - set_data_type(); - } - - // Construct the literal and distance trees - l_desc.build_tree(this); - - d_desc.build_tree(this); - - // At this point, opt_len and static_len are the total bit lengths of - // the compressed block data, excluding the tree representations. - - // Build the bit length tree for the above two trees, and get the index - // in bl_order of the last bit length code to send. - max_blindex = build_bl_tree(); - - // Determine the best encoding. Compute first the block length in bytes - opt_lenb = opt_len + 3 + 7 >>> 3; - static_lenb = static_len + 3 + 7 >>> 3; - - if (static_lenb <= opt_lenb) { - opt_lenb = static_lenb; - } - } else { - opt_lenb = static_lenb = stored_len + 5; // force a stored block - } - - if (stored_len + 4 <= opt_lenb && buf != -1) { - // 4: two words for the lengths - // The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. - // Otherwise we can't have processed more than WSIZE input bytes since - // the last block flush, because compression would have been - // successful. If LIT_BUFSIZE <= WSIZE, it is never too late to - // transform a block into a stored block. - _tr_stored_block(buf, stored_len, eof); - } else if (static_lenb == opt_lenb) { - send_bits((STATIC_TREES << 1) + (eof? 1 : 0), 3); - compress_block(StaticTree.static_ltree, StaticTree.static_dtree); - } else { - send_bits((DYN_TREES << 1) + (eof? 1 : 0), 3); - send_all_trees(l_desc.max_code + 1, d_desc.max_code + 1, - max_blindex + 1); - compress_block(dyn_ltree, dyn_dtree); - } - - // The above check is made mod 2^32, for files larger than 512 MB - // and uLong implemented on 32 bits. - - init_block(); - - if (eof) { - bi_windup(); - } - } - - // Fill the window when the lookahead becomes insufficient. - // Updates strstart and lookahead. - // - // IN assertion: lookahead < MIN_LOOKAHEAD - // OUT assertions: strstart <= window_size-MIN_LOOKAHEAD - // At least one byte has been read, or avail_in == 0; reads are - // performed for at least two bytes (required for the zip translate_eol - // option -- not supported here). - private void fill_window() { - int n, m; - int p; - int more; // Amount of free space at the end of the window. - - do { - more = window_size - lookahead - strstart; - - // Deal with !@#$% 64K limit: - if (more == 0 && strstart == 0 && lookahead == 0) { - more = w_size; - } else if (more == -1) { - // Very unlikely, but possible on 16 bit machine if strstart == 0 - // and lookahead == 1 (input done one byte at time) - more --; - - // If the window is almost full and there is insufficient lookahead, - // move the upper half to the lower one to make room in the upper half. - } else if (strstart >= w_size + w_size - MIN_LOOKAHEAD) { - System.arraycopy(window, w_size, window, 0, w_size); - match_start -= w_size; - strstart -= w_size; // we now have strstart >= MAX_DIST - block_start -= w_size; - - // Slide the hash table (could be avoided with 32 bit values - // at the expense of memory usage). We slide even when level == 0 - // to keep the hash table consistent if we switch back to level > 0 - // later. (Using level 0 permanently is not an optimal usage of - // zlib, so we don't care about this pathological case.) - - n = hash_size; - p = n; - do { - m = head[-- p] & 0xffff; - head[p] = m >= w_size? (short) (m - w_size) : 0; - } while (-- n != 0); - - n = w_size; - p = n; - do { - m = prev[-- p] & 0xffff; - prev[p] = m >= w_size? (short) (m - w_size) : 0; - // If n is not on any hash chain, prev[n] is garbage but - // its value will never be used. - } while (-- n != 0); - more += w_size; - } - - if (strm.avail_in == 0) { - return; - } - - // If there was no sliding: - // strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && - // more == window_size - lookahead - strstart - // => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) - // => more >= window_size - 2*WSIZE + 2 - // In the BIG_MEM or MMAP case (not yet supported), - // window_size == input_size + MIN_LOOKAHEAD && - // strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. - // Otherwise, window_size == 2*WSIZE so more >= 2. - // If there was sliding, more >= WSIZE. So in all cases, more >= 2. - - n = strm.read_buf(window, strstart + lookahead, more); - lookahead += n; - - // Initialize the hash value now that we have some input: - if (lookahead >= MIN_MATCH) { - ins_h = window[strstart] & 0xff; - ins_h = (ins_h << hash_shift ^ window[strstart + 1] & 0xff) & - hash_mask; - } - // If the whole input has less than MIN_MATCH bytes, ins_h is garbage, - // but this is not important since only literal bytes will be emitted. - } while (lookahead < MIN_LOOKAHEAD && strm.avail_in != 0); - } - - // Compress as much as possible from the input stream, return the current - // block state. - // This function does not perform lazy evaluation of matches and inserts - // new strings in the dictionary only for unmatched strings or for short - // matches. It is used only for the fast compression options. - private int deflate_fast(int flush) { - // short hash_head = 0; // head of the hash chain - int hash_head = 0; // head of the hash chain - boolean bflush; // set if current block must be flushed - - while (true) { - // Make sure that we always have enough lookahead, except - // at the end of the input file. We need MAX_MATCH bytes - // for the next match, plus MIN_MATCH bytes to insert the - // string following the next match. - if (lookahead < MIN_LOOKAHEAD) { - fill_window(); - if (lookahead < MIN_LOOKAHEAD && flush == JZlib.Z_NO_FLUSH) { - return NeedMore; - } - if (lookahead == 0) { - break; // flush the current block - } - } - - // Insert the string window[strstart .. strstart+2] in the - // dictionary, and set hash_head to the head of the hash chain: - if (lookahead >= MIN_MATCH) { - ins_h = (ins_h << hash_shift ^ window[strstart + MIN_MATCH - 1] & 0xff) & - hash_mask; - - // prev[strstart&w_mask]=hash_head=head[ins_h]; - hash_head = head[ins_h] & 0xffff; - prev[strstart & w_mask] = head[ins_h]; - head[ins_h] = (short) strstart; - } - - // Find the longest match, discarding those <= prev_length. - // At this point we have always match_length < MIN_MATCH - - if (hash_head != 0L && - (strstart - hash_head & 0xffff) <= w_size - MIN_LOOKAHEAD) { - // To simplify the code, we prevent matches with the string - // of window index 0 (in particular we have to avoid a match - // of the string with itself at the start of the input file). - if (strategy != JZlib.Z_HUFFMAN_ONLY) { - match_length = longest_match(hash_head); - } - // longest_match() sets match_start - } - if (match_length >= MIN_MATCH) { - // check_match(strstart, match_start, match_length); - - bflush = _tr_tally(strstart - match_start, match_length - - MIN_MATCH); - - lookahead -= match_length; - - // Insert new strings in the hash table only if the match length - // is not too large. This saves time but degrades compression. - if (match_length <= max_lazy_match && lookahead >= MIN_MATCH) { - match_length --; // string at strstart already in hash table - do { - strstart ++; - - ins_h = (ins_h << hash_shift ^ window[strstart + - MIN_MATCH - 1] & 0xff) & - hash_mask; - // prev[strstart&w_mask]=hash_head=head[ins_h]; - hash_head = head[ins_h] & 0xffff; - prev[strstart & w_mask] = head[ins_h]; - head[ins_h] = (short) strstart; - - // strstart never exceeds WSIZE-MAX_MATCH, so there are - // always MIN_MATCH bytes ahead. - } while (-- match_length != 0); - strstart ++; - } else { - strstart += match_length; - match_length = 0; - ins_h = window[strstart] & 0xff; - - ins_h = (ins_h << hash_shift ^ window[strstart + 1] & 0xff) & - hash_mask; - // If lookahead < MIN_MATCH, ins_h is garbage, but it does not - // matter since it will be recomputed at next deflate call. - } - } else { - // No match, output a literal byte - - bflush = _tr_tally(0, window[strstart] & 0xff); - lookahead --; - strstart ++; - } - if (bflush) { - - flush_block_only(false); - if (strm.avail_out == 0) { - return NeedMore; - } - } - } - - flush_block_only(flush == JZlib.Z_FINISH); - if (strm.avail_out == 0) { - if (flush == JZlib.Z_FINISH) { - return FinishStarted; - } else { - return NeedMore; - } - } - return flush == JZlib.Z_FINISH? FinishDone : BlockDone; - } - - // Same as above, but achieves better compression. We use a lazy - // evaluation for matches: a match is finally adopted only if there is - // no better match at the next window position. - private int deflate_slow(int flush) { - // short hash_head = 0; // head of hash chain - int hash_head = 0; // head of hash chain - boolean bflush; // set if current block must be flushed - - // Process the input block. - while (true) { - // Make sure that we always have enough lookahead, except - // at the end of the input file. We need MAX_MATCH bytes - // for the next match, plus MIN_MATCH bytes to insert the - // string following the next match. - - if (lookahead < MIN_LOOKAHEAD) { - fill_window(); - if (lookahead < MIN_LOOKAHEAD && flush == JZlib.Z_NO_FLUSH) { - return NeedMore; - } - if (lookahead == 0) { - break; // flush the current block - } - } - - // Insert the string window[strstart .. strstart+2] in the - // dictionary, and set hash_head to the head of the hash chain: - - if (lookahead >= MIN_MATCH) { - ins_h = (ins_h << hash_shift ^ window[strstart + MIN_MATCH - 1] & 0xff) & - hash_mask; - // prev[strstart&w_mask]=hash_head=head[ins_h]; - hash_head = head[ins_h] & 0xffff; - prev[strstart & w_mask] = head[ins_h]; - head[ins_h] = (short) strstart; - } - - // Find the longest match, discarding those <= prev_length. - prev_length = match_length; - prev_match = match_start; - match_length = MIN_MATCH - 1; - - if (hash_head != 0 && prev_length < max_lazy_match && - (strstart - hash_head & 0xffff) <= w_size - MIN_LOOKAHEAD) { - // To simplify the code, we prevent matches with the string - // of window index 0 (in particular we have to avoid a match - // of the string with itself at the start of the input file). - - if (strategy != JZlib.Z_HUFFMAN_ONLY) { - match_length = longest_match(hash_head); - } - // longest_match() sets match_start - - if (match_length <= 5 && - (strategy == JZlib.Z_FILTERED || match_length == MIN_MATCH && - strstart - match_start > 4096)) { - - // If prev_match is also MIN_MATCH, match_start is garbage - // but we will ignore the current match anyway. - match_length = MIN_MATCH - 1; - } - } - - // If there was a match at the previous step and the current - // match is not better, output the previous match: - if (prev_length >= MIN_MATCH && match_length <= prev_length) { - int max_insert = strstart + lookahead - MIN_MATCH; - // Do not insert strings in hash table beyond this. - - // check_match(strstart-1, prev_match, prev_length); - - bflush = _tr_tally(strstart - 1 - prev_match, prev_length - - MIN_MATCH); - - // Insert in hash table all strings up to the end of the match. - // strstart-1 and strstart are already inserted. If there is not - // enough lookahead, the last two strings are not inserted in - // the hash table. - lookahead -= prev_length - 1; - prev_length -= 2; - do { - if (++ strstart <= max_insert) { - ins_h = (ins_h << hash_shift ^ window[strstart + - MIN_MATCH - 1] & 0xff) & - hash_mask; - //prev[strstart&w_mask]=hash_head=head[ins_h]; - hash_head = head[ins_h] & 0xffff; - prev[strstart & w_mask] = head[ins_h]; - head[ins_h] = (short) strstart; - } - } while (-- prev_length != 0); - match_available = 0; - match_length = MIN_MATCH - 1; - strstart ++; - - if (bflush) { - flush_block_only(false); - if (strm.avail_out == 0) { - return NeedMore; - } - } - } else if (match_available != 0) { - - // If there was no match at the previous position, output a - // single literal. If there was a match but the current match - // is longer, truncate the previous match to a single literal. - - bflush = _tr_tally(0, window[strstart - 1] & 0xff); - - if (bflush) { - flush_block_only(false); - } - strstart ++; - lookahead --; - if (strm.avail_out == 0) { - return NeedMore; - } - } else { - // There is no previous match to compare with, wait for - // the next step to decide. - - match_available = 1; - strstart ++; - lookahead --; - } - } - - if (match_available != 0) { - _tr_tally(0, window[strstart - 1] & 0xff); - match_available = 0; - } - flush_block_only(flush == JZlib.Z_FINISH); - - if (strm.avail_out == 0) { - if (flush == JZlib.Z_FINISH) { - return FinishStarted; - } else { - return NeedMore; - } - } - - return flush == JZlib.Z_FINISH? FinishDone : BlockDone; - } - - private int longest_match(int cur_match) { - int chain_length = max_chain_length; // max hash chain length - int scan = strstart; // current string - int match; // matched string - int len; // length of current match - int best_len = prev_length; // best match length so far - int limit = strstart > w_size - MIN_LOOKAHEAD? strstart - - (w_size - MIN_LOOKAHEAD) : 0; - int nice_match = this.nice_match; - - // Stop when cur_match becomes <= limit. To simplify the code, - // we prevent matches with the string of window index 0. - - int wmask = w_mask; - - int strend = strstart + MAX_MATCH; - byte scan_end1 = window[scan + best_len - 1]; - byte scan_end = window[scan + best_len]; - - // The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. - // It is easy to get rid of this optimization if necessary. - - // Do not waste too much time if we already have a good match: - if (prev_length >= good_match) { - chain_length >>= 2; - } - - // Do not look for matches beyond the end of the input. This is necessary - // to make deflate deterministic. - if (nice_match > lookahead) { - nice_match = lookahead; - } - - do { - match = cur_match; - - // Skip to next match if the match length cannot increase - // or if the match length is less than 2: - if (window[match + best_len] != scan_end || - window[match + best_len - 1] != scan_end1 || - window[match] != window[scan] || - window[++ match] != window[scan + 1]) { - continue; - } - - // The check at best_len-1 can be removed because it will be made - // again later. (This heuristic is not always a win.) - // It is not necessary to compare scan[2] and match[2] since they - // are always equal when the other bytes match, given that - // the hash keys are equal and that HASH_BITS >= 8. - scan += 2; - match ++; - - // We check for insufficient lookahead only every 8th comparison; - // the 256th check will be made at strstart+258. - while (window[++ scan] == window[++ match] && - window[++ scan] == window[++ match] && - window[++ scan] == window[++ match] && - window[++ scan] == window[++ match] && - window[++ scan] == window[++ match] && - window[++ scan] == window[++ match] && - window[++ scan] == window[++ match] && - window[++ scan] == window[++ match] && scan < strend) { - continue; - } - - len = MAX_MATCH - (strend - scan); - scan = strend - MAX_MATCH; - - if (len > best_len) { - match_start = cur_match; - best_len = len; - if (len >= nice_match) { - break; - } - scan_end1 = window[scan + best_len - 1]; - scan_end = window[scan + best_len]; - } - - } while ((cur_match = prev[cur_match & wmask] & 0xffff) > limit && - -- chain_length != 0); - - if (best_len <= lookahead) { - return best_len; - } - return lookahead; - } - - int deflateInit(ZStream strm, int level, int bits, int memLevel, WrapperType wrapperType) { - return deflateInit2(strm, level, JZlib.Z_DEFLATED, bits, - memLevel, JZlib.Z_DEFAULT_STRATEGY, wrapperType); - } - - private int deflateInit2(ZStream strm, int level, int method, int windowBits, - int memLevel, int strategy, WrapperType wrapperType) { - - if (wrapperType == WrapperType.ZLIB_OR_NONE) { - throw new IllegalArgumentException("ZLIB_OR_NONE allowed only for inflate"); - } - - // byte[] my_version=ZLIB_VERSION; - - // - // if (version == null || version[0] != my_version[0] - // || stream_size != sizeof(z_stream)) { - // return Z_VERSION_ERROR; - // } - - strm.msg = null; - - if (level == JZlib.Z_DEFAULT_COMPRESSION) { - level = 6; - } - - if (windowBits < 0) { // undocumented feature: suppress zlib header - throw new IllegalArgumentException("windowBits: " + windowBits); - } - - if (memLevel < 1 || memLevel > JZlib.MAX_MEM_LEVEL || - method != JZlib.Z_DEFLATED || windowBits < 9 || - windowBits > 15 || level < 0 || level > 9 || strategy < 0 || - strategy > JZlib.Z_HUFFMAN_ONLY) { - return JZlib.Z_STREAM_ERROR; - } - - strm.dstate = this; - - this.wrapperType = wrapperType; - w_bits = windowBits; - w_size = 1 << w_bits; - w_mask = w_size - 1; - - hash_bits = memLevel + 7; - hash_size = 1 << hash_bits; - hash_mask = hash_size - 1; - hash_shift = (hash_bits + MIN_MATCH - 1) / MIN_MATCH; - - window = new byte[w_size * 2]; - prev = new short[w_size]; - head = new short[hash_size]; - - lit_bufsize = 1 << memLevel + 6; // 16K elements by default - - // We overlay pending_buf and d_buf+l_buf. This works since the average - // output size for (length,distance) codes is <= 24 bits. - pending_buf = new byte[lit_bufsize * 4]; - pending_buf_size = lit_bufsize * 4; - - d_buf = lit_bufsize / 2; - l_buf = (1 + 2) * lit_bufsize; - - this.level = level; - - //System.out.println("level="+level); - - this.strategy = strategy; - - return deflateReset(strm); - } - - private int deflateReset(ZStream strm) { - strm.total_in = strm.total_out = 0; - strm.msg = null; // - - pending = 0; - pending_out = 0; - - wroteTrailer = false; - status = wrapperType == WrapperType.NONE? BUSY_STATE : INIT_STATE; - strm.adler = Adler32.adler32(0, null, 0, 0); - strm.crc32 = 0; - gzipUncompressedBytes = 0; - - last_flush = JZlib.Z_NO_FLUSH; - - tr_init(); - lm_init(); - return JZlib.Z_OK; - } - - int deflateEnd() { - if (status != INIT_STATE && status != BUSY_STATE && - status != FINISH_STATE) { - return JZlib.Z_STREAM_ERROR; - } - // Deallocate in reverse order of allocations: - pending_buf = null; - head = null; - prev = null; - window = null; - // free - // dstate=null; - return status == BUSY_STATE? JZlib.Z_DATA_ERROR : JZlib.Z_OK; - } - - int deflateParams(ZStream strm, int _level, int _strategy) { - int err = JZlib.Z_OK; - - if (_level == JZlib.Z_DEFAULT_COMPRESSION) { - _level = 6; - } - if (_level < 0 || _level > 9 || _strategy < 0 || - _strategy > JZlib.Z_HUFFMAN_ONLY) { - return JZlib.Z_STREAM_ERROR; - } - - if (config_table[level].func != config_table[_level].func && - strm.total_in != 0) { - // Flush the last buffer: - err = strm.deflate(JZlib.Z_PARTIAL_FLUSH); - } - - if (level != _level) { - level = _level; - max_lazy_match = config_table[level].max_lazy; - good_match = config_table[level].good_length; - nice_match = config_table[level].nice_length; - max_chain_length = config_table[level].max_chain; - } - strategy = _strategy; - return err; - } - - int deflateSetDictionary(ZStream strm, byte[] dictionary, int dictLength) { - int length = dictLength; - int index = 0; - - if (dictionary == null || status != INIT_STATE) { - return JZlib.Z_STREAM_ERROR; - } - - strm.adler = Adler32.adler32(strm.adler, dictionary, 0, dictLength); - - if (length < MIN_MATCH) { - return JZlib.Z_OK; - } - if (length > w_size - MIN_LOOKAHEAD) { - length = w_size - MIN_LOOKAHEAD; - index = dictLength - length; // use the tail of the dictionary - } - System.arraycopy(dictionary, index, window, 0, length); - strstart = length; - block_start = length; - - // Insert all strings in the hash table (except for the last two bytes). - // s->lookahead stays null, so s->ins_h will be recomputed at the next - // call of fill_window. - - ins_h = window[0] & 0xff; - ins_h = (ins_h << hash_shift ^ window[1] & 0xff) & hash_mask; - - for (int n = 0; n <= length - MIN_MATCH; n ++) { - ins_h = (ins_h << hash_shift ^ window[n + MIN_MATCH - 1] & 0xff) & - hash_mask; - prev[n & w_mask] = head[ins_h]; - head[ins_h] = (short) n; - } - return JZlib.Z_OK; - } - - int deflate(ZStream strm, int flush) { - int old_flush; - - if (flush > JZlib.Z_FINISH || flush < 0) { - return JZlib.Z_STREAM_ERROR; - } - - if (strm.next_out == null || strm.next_in == null && - strm.avail_in != 0 || status == FINISH_STATE && - flush != JZlib.Z_FINISH) { - strm.msg = z_errmsg[JZlib.Z_NEED_DICT - JZlib.Z_STREAM_ERROR]; - return JZlib.Z_STREAM_ERROR; - } - if (strm.avail_out == 0) { - strm.msg = z_errmsg[JZlib.Z_NEED_DICT - JZlib.Z_BUF_ERROR]; - return JZlib.Z_BUF_ERROR; - } - - this.strm = strm; // just in case - old_flush = last_flush; - last_flush = flush; - - // Write the zlib header - if (status == INIT_STATE) { - switch (wrapperType) { - case ZLIB: - int header = JZlib.Z_DEFLATED + (w_bits - 8 << 4) << 8; - int level_flags = (level - 1 & 0xff) >> 1; - - if (level_flags > 3) { - level_flags = 3; - } - header |= level_flags << 6; - if (strstart != 0) { - header |= JZlib.PRESET_DICT; - } - header += 31 - header % 31; - - putShortMSB(header); - - // Save the adler32 of the preset dictionary: - if (strstart != 0) { - putShortMSB((int) (strm.adler >>> 16)); - putShortMSB((int) (strm.adler & 0xffff)); - } - strm.adler = Adler32.adler32(0, null, 0, 0); - break; - case GZIP: - // Identification - put_byte((byte) 0x1f); - put_byte((byte) 0x8b); - // Compression method: DEFLATE - put_byte((byte) 8); - // Flags - put_byte((byte) 0); - // MTIME - put_byte((byte) 0); - put_byte((byte) 0); - put_byte((byte) 0); - put_byte((byte) 0); - // XFL - switch (config_table[level].func) { - case FAST: - put_byte((byte) 4); - break; - case SLOW: - put_byte((byte) 2); - break; - default: - put_byte((byte) 0); - break; - } - // OS - put_byte((byte) 255); - - strm.crc32 = 0; - break; - } - - status = BUSY_STATE; - } - - // Flush as much pending output as possible - if (pending != 0) { - strm.flush_pending(); - if (strm.avail_out == 0) { - //System.out.println(" avail_out==0"); - // Since avail_out is 0, deflate will be called again with - // more output space, but possibly with both pending and - // avail_in equal to zero. There won't be anything to do, - // but this is not an error situation so make sure we - // return OK instead of BUF_ERROR at next call of deflate: - last_flush = -1; - return JZlib.Z_OK; - } - - // Make sure there is something to do and avoid duplicate consecutive - // flushes. For repeated and useless calls with Z_FINISH, we keep - // returning Z_STREAM_END instead of Z_BUFF_ERROR. - } else if (strm.avail_in == 0 && flush <= old_flush && - flush != JZlib.Z_FINISH) { - strm.msg = z_errmsg[JZlib.Z_NEED_DICT - JZlib.Z_BUF_ERROR]; - return JZlib.Z_BUF_ERROR; - } - - // User must not provide more input after the first FINISH: - if (status == FINISH_STATE && strm.avail_in != 0) { - strm.msg = z_errmsg[JZlib.Z_NEED_DICT - JZlib.Z_BUF_ERROR]; - return JZlib.Z_BUF_ERROR; - } - - // Start a new block or continue the current one. - int old_next_in_index = strm.next_in_index; - try { - if (strm.avail_in != 0 || lookahead != 0 || flush != JZlib.Z_NO_FLUSH && - status != FINISH_STATE) { - int bstate = -1; - switch (config_table[level].func) { - case STORED: - bstate = deflate_stored(flush); - break; - case FAST: - bstate = deflate_fast(flush); - break; - case SLOW: - bstate = deflate_slow(flush); - break; - default: - } - - if (bstate == FinishStarted || bstate == FinishDone) { - status = FINISH_STATE; - } - if (bstate == NeedMore || bstate == FinishStarted) { - if (strm.avail_out == 0) { - last_flush = -1; // avoid BUF_ERROR next call, see above - } - return JZlib.Z_OK; - // If flush != Z_NO_FLUSH && avail_out == 0, the next call - // of deflate should use the same flush parameter to make sure - // that the flush is complete. So we don't have to output an - // empty block here, this will be done at next call. This also - // ensures that for a very small output buffer, we emit at most - // one empty block. - } - - if (bstate == BlockDone) { - if (flush == JZlib.Z_PARTIAL_FLUSH) { - _tr_align(); - } else { // FULL_FLUSH or SYNC_FLUSH - _tr_stored_block(0, 0, false); - // For a full flush, this empty block will be recognized - // as a special marker by inflate_sync(). - if (flush == JZlib.Z_FULL_FLUSH) { - //state.head[s.hash_size-1]=0; - for (int i = 0; i < hash_size/*-1*/; i ++) { - head[i] = 0; - } - } - } - strm.flush_pending(); - if (strm.avail_out == 0) { - last_flush = -1; // avoid BUF_ERROR at next call, see above - return JZlib.Z_OK; - } - } - } - } finally { - gzipUncompressedBytes += strm.next_in_index - old_next_in_index; - } - - if (flush != JZlib.Z_FINISH) { - return JZlib.Z_OK; - } - - if (wrapperType == WrapperType.NONE || wroteTrailer) { - return JZlib.Z_STREAM_END; - } - - switch (wrapperType) { - case ZLIB: - // Write the zlib trailer (adler32) - putShortMSB((int) (strm.adler >>> 16)); - putShortMSB((int) (strm.adler & 0xffff)); - break; - case GZIP: - // Write the gzip trailer (CRC32 & ISIZE) - put_byte((byte) (strm.crc32 & 0xFF)); - put_byte((byte) (strm.crc32 >>> 8 & 0xFF)); - put_byte((byte) (strm.crc32 >>> 16 & 0xFF)); - put_byte((byte) (strm.crc32 >>> 24 & 0xFF)); - put_byte((byte) (gzipUncompressedBytes & 0xFF)); - put_byte((byte) (gzipUncompressedBytes >>> 8 & 0xFF)); - put_byte((byte) (gzipUncompressedBytes >>> 16 & 0xFF)); - put_byte((byte) (gzipUncompressedBytes >>> 24 & 0xFF)); - break; - } - - strm.flush_pending(); - // If avail_out is zero, the application will call deflate again - // to flush the rest. - wroteTrailer = true; // write the trailer only once! - return pending != 0? JZlib.Z_OK : JZlib.Z_STREAM_END; - } -} diff --git a/common/src/main/java/io/netty/util/internal/jzlib/InfBlocks.java b/common/src/main/java/io/netty/util/internal/jzlib/InfBlocks.java deleted file mode 100644 index 8329309bd9..0000000000 --- a/common/src/main/java/io/netty/util/internal/jzlib/InfBlocks.java +++ /dev/null @@ -1,697 +0,0 @@ -/* - * Copyright 2012 The Netty Project - * - * The Netty Project licenses this file to you under the Apache License, - * version 2.0 (the "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - */ -/* -Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the distribution. - - 3. The names of the authors may not be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, -INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, -OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, -EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * This program is based on zlib-1.1.3, so all credit should go authors - * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu) - * and contributors of zlib. - */ -package io.netty.util.internal.jzlib; - -final class InfBlocks { - - // And'ing with mask[n] masks the lower n bits - private static final int[] inflate_mask = { 0x00000000, 0x00000001, - 0x00000003, 0x00000007, 0x0000000f, 0x0000001f, 0x0000003f, - 0x0000007f, 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff, - 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff }; - - // Table for deflate from PKZIP's appnote.txt. - private static final int[] border = { // Order of the bit length code lengths - 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; - - private static final int TYPE = 0; // get type bits (3, including end bit) - private static final int LENS = 1; // get lengths for stored - private static final int STORED = 2; // processing stored block - private static final int TABLE = 3; // get table lengths - private static final int BTREE = 4; // get bit lengths tree for a dynamic block - private static final int DTREE = 5; // get length, distance trees for a dynamic block - private static final int CODES = 6; // processing fixed or dynamic block - private static final int DRY = 7; // output remaining window bytes - private static final int DONE = 8; // finished last block, done - private static final int BAD = 9; // ot a data error--stuck here - - private int mode; // current inflate_block mode - private int left; // if STORED, bytes left to copy - private int table; // table lengths (14 bits) - private int index; // index into blens (or border) - private int[] blens; // bit lengths of codes - private final int[] bb = new int[1]; // bit length tree depth - private final int[] tb = new int[1]; // bit length decoding tree - private final InfCodes codes = new InfCodes(); // if CODES, current state - private int last; // true if this block is the last block - // mode independent information - int bitk; // bits in bit buffer - int bitb; // bit buffer - private int[] hufts; // single malloc for tree space - byte[] window; // sliding window - final int end; // one byte after sliding window - int read; // window read pointer - int write; // window write pointer - private final Object checkfn; // check function - private long check; // check on output - private final InfTree inftree = new InfTree(); - - InfBlocks(ZStream z, Object checkfn, int w) { - hufts = new int[JZlib.MANY * 3]; - window = new byte[w]; - end = w; - this.checkfn = checkfn; - mode = TYPE; - reset(z, null); - } - - void reset(ZStream z, long[] c) { - if (c != null) { - c[0] = check; - } - mode = TYPE; - bitk = 0; - bitb = 0; - read = write = 0; - - if (checkfn != null) { - z.adler = check = Adler32.adler32(0L, null, 0, 0); - } - } - - int proc(ZStream z, 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 = z.next_in_index; - n = z.avail_in; - b = bitb; - k = bitk; - } - { - q = write; - m = q < read? read - q - 1 : end - q; - } - - // process input based on current state - while (true) { - switch (mode) { - case TYPE: - - while (k < 3) { - if (n != 0) { - r = JZlib.Z_OK; - } else { - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - n --; - b |= (z.next_in[p ++] & 0xff) << k; - k += 8; - } - t = b & 7; - last = t & 1; - - switch (t >>> 1) { - case 0: // stored - { - b >>>= 3; - k -= 3; - } - t = k & 7; // go to byte boundary - { - b >>>= t; - k -= t; - } - mode = 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); - codes.init(bl[0], bd[0], tl[0], 0, td[0], 0); - } - { - b >>>= 3; - k -= 3; - } - mode = CODES; - break; - case 2: // dynamic - { - b >>>= 3; - k -= 3; - } - mode = TABLE; - break; - case 3: // illegal - { - b >>>= 3; - k -= 3; - } - mode = BAD; - z.msg = "invalid block type"; - r = JZlib.Z_DATA_ERROR; - - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - break; - case LENS: - - while (k < 32) { - if (n != 0) { - r = JZlib.Z_OK; - } else { - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - n --; - b |= (z.next_in[p ++] & 0xff) << k; - k += 8; - } - - if ((~b >>> 16 & 0xffff) != (b & 0xffff)) { - mode = BAD; - z.msg = "invalid stored block lengths"; - r = JZlib.Z_DATA_ERROR; - - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - left = b & 0xffff; - b = k = 0; // dump bits - mode = left != 0? STORED : last != 0? DRY : TYPE; - break; - case STORED: - if (n == 0) { - bitb = b; - bitk = k; - z.avail_in = 0; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - - if (m == 0) { - if (q == end && read != 0) { - q = 0; - m = q < read? read - q - 1 : end - q; - } - if (m == 0) { - write = q; - r = inflate_flush(z, r); - q = write; - m = q < read? read - q - 1 : end - q; - if (q == end && read != 0) { - q = 0; - m = q < read? read - q - 1 : end - q; - } - if (m == 0) { - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - } - } - r = JZlib.Z_OK; - - t = left; - if (t > n) { - t = n; - } - if (t > m) { - t = m; - } - System.arraycopy(z.next_in, p, window, q, t); - p += t; - n -= t; - q += t; - m -= t; - if ((left -= t) != 0) { - break; - } - mode = last != 0? DRY : TYPE; - break; - case TABLE: - - while (k < 14) { - if (n != 0) { - r = JZlib.Z_OK; - } else { - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - n --; - b |= (z.next_in[p ++] & 0xff) << k; - k += 8; - } - - table = t = b & 0x3fff; - if ((t & 0x1f) > 29 || (t >> 5 & 0x1f) > 29) { - mode = BAD; - z.msg = "too many length or distance symbols"; - r = JZlib.Z_DATA_ERROR; - - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - t = 258 + (t & 0x1f) + (t >> 5 & 0x1f); - if (blens == null || blens.length < t) { - blens = new int[t]; - } else { - for (int i = 0; i < t; i ++) { - blens[i] = 0; - } - } - - { - b >>>= 14; - k -= 14; - } - - index = 0; - mode = BTREE; - case BTREE: - while (index < 4 + (table >>> 10)) { - while (k < 3) { - if (n != 0) { - r = JZlib.Z_OK; - } else { - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - n --; - b |= (z.next_in[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, z); - if (t != JZlib.Z_OK) { - r = t; - if (r == JZlib.Z_DATA_ERROR) { - blens = null; - mode = BAD; - } - - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - - index = 0; - mode = DTREE; - case 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 = JZlib.Z_OK; - } else { - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - n --; - b |= (z.next_in[p ++] & 0xff) << k; - k += 8; - } - - if (tb[0] == -1) { - //System.err.println("null..."); - } - - t = hufts[(tb[0] + (b & inflate_mask[t])) * 3 + 1]; - c = hufts[(tb[0] + (b & inflate_mask[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 = JZlib.Z_OK; - } else { - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - n --; - b |= (z.next_in[p ++] & 0xff) << k; - k += 8; - } - - b >>>= t; - k -= t; - - j += b & inflate_mask[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 = BAD; - z.msg = "invalid bit length repeat"; - r = JZlib.Z_DATA_ERROR; - - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - - c = c == 16? blens[i - 1] : 0; - do { - blens[i ++] = c; - } while (-- j != 0); - index = i; - } - } - - tb[0] = -1; - { - int[] bl = new int[1]; - int[] bd = new int[1]; - int[] tl = new int[1]; - int[] td = new int[1]; - bl[0] = 9; // must be <= 9 for lookahead assumptions - bd[0] = 6; // must be <= 9 for lookahead assumptions - - t = table; - t = inftree.inflate_trees_dynamic(257 + (t & 0x1f), - 1 + (t >> 5 & 0x1f), blens, bl, bd, tl, td, hufts, - z); - - if (t != JZlib.Z_OK) { - if (t == JZlib.Z_DATA_ERROR) { - blens = null; - mode = BAD; - } - r = t; - - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - codes.init(bl[0], bd[0], hufts, tl[0], hufts, td[0]); - } - mode = CODES; - case CODES: - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - - if ((r = codes.proc(this, z, r)) != JZlib.Z_STREAM_END) { - return inflate_flush(z, r); - } - r = JZlib.Z_OK; - - p = z.next_in_index; - n = z.avail_in; - b = bitb; - k = bitk; - q = write; - m = q < read? read - q - 1 : end - q; - - if (last == 0) { - mode = TYPE; - break; - } - mode = DRY; - case DRY: - write = q; - r = inflate_flush(z, r); - q = write; - if (read != write) { - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - mode = DONE; - case DONE: - r = JZlib.Z_STREAM_END; - - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - case BAD: - r = JZlib.Z_DATA_ERROR; - - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - - default: - r = JZlib.Z_STREAM_ERROR; - - bitb = b; - bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - write = q; - return inflate_flush(z, r); - } - } - } - - void free(ZStream z) { - reset(z, null); - window = null; - hufts = null; - //ZFREE(z, s); - } - - void set_dictionary(byte[] d, int start, int n) { - System.arraycopy(d, start, window, 0, n); - read = write = n; - } - - // Returns true if inflate is currently at the end of a block generated - // by Z_SYNC_FLUSH or Z_FULL_FLUSH. - int sync_point() { - return mode == LENS? 1 : 0; - } - - // copy as much as possible from the sliding window to the output area - int inflate_flush(ZStream z, int r) { - int n; - int p; - int q; - - // local copies of source and destination pointers - p = z.next_out_index; - q = read; - - // compute number of bytes to copy as far as end of window - n = (q <= write? write : end) - q; - if (n > z.avail_out) { - n = z.avail_out; - } - if (n != 0 && r == JZlib.Z_BUF_ERROR) { - r = JZlib.Z_OK; - } - - // update counters - z.avail_out -= n; - z.total_out += n; - - // update check information - if (checkfn != null) { - z.adler = check = Adler32.adler32(check, window, q, n); - } - - // copy as far as end of window - System.arraycopy(window, q, z.next_out, p, n); - p += n; - q += n; - - // see if more to copy at beginning of window - if (q == end) { - // wrap pointers - q = 0; - if (write == end) { - write = 0; - } - - // compute bytes to copy - n = write - q; - if (n > z.avail_out) { - n = z.avail_out; - } - if (n != 0 && r == JZlib.Z_BUF_ERROR) { - r = JZlib.Z_OK; - } - - // update counters - z.avail_out -= n; - z.total_out += n; - - // update check information - if (checkfn != null) { - z.adler = check = Adler32.adler32(check, window, q, n); - } - - // copy - System.arraycopy(window, q, z.next_out, p, n); - p += n; - q += n; - } - - // update pointers - z.next_out_index = p; - read = q; - - // done - return r; - } -} diff --git a/common/src/main/java/io/netty/util/internal/jzlib/InfCodes.java b/common/src/main/java/io/netty/util/internal/jzlib/InfCodes.java deleted file mode 100644 index b871a20178..0000000000 --- a/common/src/main/java/io/netty/util/internal/jzlib/InfCodes.java +++ /dev/null @@ -1,699 +0,0 @@ -/* - * Copyright 2012 The Netty Project - * - * The Netty Project licenses this file to you under the Apache License, - * version 2.0 (the "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - */ -/* -Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the distribution. - - 3. The names of the authors may not be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, -INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, -OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, -EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * This program is based on zlib-1.1.3, so all credit should go authors - * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu) - * and contributors of zlib. - */ -package io.netty.util.internal.jzlib; - -final class InfCodes { - - private static final int[] inflate_mask = { 0x00000000, 0x00000001, - 0x00000003, 0x00000007, 0x0000000f, 0x0000001f, 0x0000003f, - 0x0000007f, 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff, - 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff }; - - // waiting for "i:"=input, - // "o:"=output, - // "x:"=nothing - private static final int START = 0; // x: set up for LEN - private static final int LEN = 1; // i: get length/literal/eob next - private static final int LENEXT = 2; // i: getting length extra (have base) - private static final int DIST = 3; // i: get distance next - private static final int DISTEXT = 4; // i: getting distance extra - private static final int COPY = 5; // o: copying bytes in window, waiting for space - private static final int LIT = 6; // o: got literal, waiting for output space - private static final int WASH = 7; // o: got eob, possibly still output waiting - private static final int END = 8; // x: got eob and all data flushed - private static final int BADCODE = 9; // x: got error - private int mode; // current inflate_codes mode - // mode dependent information - private int len; - private int[] tree; // pointer into tree - private int tree_index; - private int need; // bits needed - private int lit; - // if EXT or COPY, where and how much - private int get; // bits to get for extra - private int dist; // distance back to copy from - private byte lbits; // ltree bits decoded per branch - private byte dbits; // dtree bits decoder per branch - private int[] ltree; // literal/length/eob tree - private int ltree_index; // literal/length/eob tree - private int[] dtree; // distance tree - private int dtree_index; // distance tree - - void init(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index) { - mode = START; - lbits = (byte) bl; - dbits = (byte) bd; - ltree = tl; - ltree_index = tl_index; - dtree = td; - dtree_index = td_index; - tree = null; - } - - int proc(InfBlocks s, ZStream z, int r) { - int j; // temporary storage - int tindex; // 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 f; // pointer to copy strings from - - // copy input/output information to locals (UPDATE macro restores) - p = z.next_in_index; - n = z.avail_in; - b = s.bitb; - k = s.bitk; - q = s.write; - m = q < s.read? s.read - q - 1 : s.end - q; - - // process input and output based on current state - while (true) { - switch (mode) { - // waiting for "i:"=input, "o:"=output, "x:"=nothing - case START: // x: set up for LEN - if (m >= 258 && n >= 10) { - - s.bitb = b; - s.bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - s.write = q; - r = inflate_fast(lbits, dbits, ltree, ltree_index, dtree, - dtree_index, s, z); - - p = z.next_in_index; - n = z.avail_in; - b = s.bitb; - k = s.bitk; - q = s.write; - m = q < s.read? s.read - q - 1 : s.end - q; - - if (r != JZlib.Z_OK) { - mode = r == JZlib.Z_STREAM_END? WASH : BADCODE; - break; - } - } - need = lbits; - tree = ltree; - tree_index = ltree_index; - - mode = LEN; - case LEN: // i: get length/literal/eob next - j = need; - - while (k < j) { - if (n != 0) { - r = JZlib.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]; - k -= tree[tindex + 1]; - - e = tree[tindex]; - - if (e == 0) { // literal - lit = tree[tindex + 2]; - mode = LIT; - break; - } - if ((e & 16) != 0) { // length - get = e & 15; - len = tree[tindex + 2]; - mode = LENEXT; - break; - } - if ((e & 64) == 0) { // next table - need = e; - tree_index = tindex / 3 + tree[tindex + 2]; - break; - } - if ((e & 32) != 0) { // end of block - mode = WASH; - break; - } - mode = BADCODE; // invalid code - z.msg = "invalid literal/length code"; - r = JZlib.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 LENEXT: // i: getting length extra (have base) - j = get; - - while (k < j) { - if (n != 0) { - r = JZlib.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; - } - - len += b & inflate_mask[j]; - - b >>= j; - k -= j; - - need = dbits; - tree = dtree; - tree_index = dtree_index; - mode = DIST; - case DIST: // i: get distance next - j = need; - - while (k < j) { - if (n != 0) { - r = JZlib.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]; - k -= tree[tindex + 1]; - - e = tree[tindex]; - if ((e & 16) != 0) { // distance - get = e & 15; - dist = tree[tindex + 2]; - mode = DISTEXT; - break; - } - if ((e & 64) == 0) { // next table - need = e; - tree_index = tindex / 3 + tree[tindex + 2]; - break; - } - mode = BADCODE; // invalid code - z.msg = "invalid distance code"; - r = JZlib.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 = JZlib.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 --; - - 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 = JZlib.Z_OK; - - s.window[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; - - 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 = JZlib.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 = JZlib.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 = JZlib.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); - } - } - } - - // 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. - - static int inflate_fast(int bl, int bd, int[] tl, int tl_index, int[] td, - int td_index, InfBlocks s, ZStream z) { - int t; // temporary pointer - int[] tp; // temporary pointer - int tp_index; // temporary pointer - int e; // extra bits or operation - int b; // bit buffer - int k; // bits in bit buffer - int p; // input data pointer - int n; // bytes available there - int q; // output window write pointer - int m; // bytes to end of window or read pointer - int ml; // mask for literal/length tree - int md; // mask for distance tree - int c; // bytes to copy - int d; // distance back to copy from - int r; // copy source pointer - - int tp_index_t_3; // (tp_index+t)*3 - - // load input, output, bit values - p = z.next_in_index; - n = z.avail_in; - b = s.bitb; - k = s.bitk; - q = s.write; - m = q < s.read? s.read - q - 1 : s.end - q; - - // initialize masks - ml = inflate_mask[bl]; - md = inflate_mask[bd]; - - // do until not enough input or output space for fast loop - do { // assume called with m >= 258 && n >= 10 - // get literal/length code - while (k < 20) { // max bits for literal/length code - n --; - b |= (z.next_in[p ++] & 0xff) << k; - k += 8; - } - - t = b & ml; - tp = tl; - tp_index = tl_index; - tp_index_t_3 = (tp_index + t) * 3; - if ((e = tp[tp_index_t_3]) == 0) { - b >>= tp[tp_index_t_3 + 1]; - k -= tp[tp_index_t_3 + 1]; - - s.window[q ++] = (byte) tp[tp_index_t_3 + 2]; - m --; - continue; - } - do { - - b >>= tp[tp_index_t_3 + 1]; - k -= tp[tp_index_t_3 + 1]; - - if ((e & 16) != 0) { - e &= 15; - c = tp[tp_index_t_3 + 2] + (b & inflate_mask[e]); - - b >>= e; - k -= e; - - // decode distance base of block to copy - while (k < 15) { // max bits for distance code - n --; - b |= (z.next_in[p ++] & 0xff) << k; - k += 8; - } - - t = b & md; - tp = td; - tp_index = td_index; - tp_index_t_3 = (tp_index + t) * 3; - e = tp[tp_index_t_3]; - - do { - - b >>= tp[tp_index_t_3 + 1]; - k -= tp[tp_index_t_3 + 1]; - - if ((e & 16) != 0) { - // get extra bits to add to distance base - e &= 15; - while (k < e) { // get extra bits (up to 13) - n --; - b |= (z.next_in[p ++] & 0xff) << k; - k += 8; - } - - d = tp[tp_index_t_3 + 2] + (b & inflate_mask[e]); - - b >>= e; - k -= e; - - // do the copy - m -= c; - if (q >= d) { // offset before dest - // just copy - r = q - d; - if (q - r > 0 && 2 > q - r) { - s.window[q ++] = s.window[r ++]; // minimum count is three, - s.window[q ++] = s.window[r ++]; // so unroll loop a little - c -= 2; - } else { - System.arraycopy(s.window, r, s.window, q, - 2); - q += 2; - r += 2; - c -= 2; - } - } else { // else offset after destination - r = q - d; - do { - r += s.end; // force pointer in window - } while (r < 0); // covers invalid distances - e = s.end - r; - if (c > e) { // if source crosses, - c -= e; // wrapped copy - if (q - r > 0 && e > q - r) { - do { - s.window[q ++] = s.window[r ++]; - } while (-- e != 0); - } else { - System.arraycopy(s.window, r, s.window, - q, e); - q += e; - r += e; - } - r = 0; // copy rest from start of window - } - - } - - // copy all or what's left - if (q - r > 0 && c > q - r) { - do { - s.window[q ++] = s.window[r ++]; - } while (-- c != 0); - } else { - System.arraycopy(s.window, r, s.window, q, c); - q += c; - r += c; - } - break; - } else if ((e & 64) == 0) { - t += tp[tp_index_t_3 + 2]; - t += b & inflate_mask[e]; - tp_index_t_3 = (tp_index + t) * 3; - e = tp[tp_index_t_3]; - } else { - z.msg = "invalid distance code"; - - c = z.avail_in - n; - c = k >> 3 < c? k >> 3 : c; - n += c; - p -= c; - k -= c << 3; - - s.bitb = b; - s.bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - s.write = q; - - return JZlib.Z_DATA_ERROR; - } - } while (true); - break; - } - - if ((e & 64) == 0) { - t += tp[tp_index_t_3 + 2]; - t += b & inflate_mask[e]; - tp_index_t_3 = (tp_index + t) * 3; - if ((e = tp[tp_index_t_3]) == 0) { - - b >>= tp[tp_index_t_3 + 1]; - k -= tp[tp_index_t_3 + 1]; - - s.window[q ++] = (byte) tp[tp_index_t_3 + 2]; - m --; - break; - } - } else if ((e & 32) != 0) { - - c = z.avail_in - n; - c = k >> 3 < c? k >> 3 : c; - n += c; - p -= c; - k -= c << 3; - - s.bitb = b; - s.bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - s.write = q; - - return JZlib.Z_STREAM_END; - } else { - z.msg = "invalid literal/length code"; - - c = z.avail_in - n; - c = k >> 3 < c? k >> 3 : c; - n += c; - p -= c; - k -= c << 3; - - s.bitb = b; - s.bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - s.write = q; - - return JZlib.Z_DATA_ERROR; - } - } while (true); - } while (m >= 258 && n >= 10); - - // not enough input or output--restore pointers and return - c = z.avail_in - n; - c = k >> 3 < c? k >> 3 : c; - n += c; - p -= c; - k -= c << 3; - - s.bitb = b; - s.bitk = k; - z.avail_in = n; - z.total_in += p - z.next_in_index; - z.next_in_index = p; - s.write = q; - - return JZlib.Z_OK; - } -} diff --git a/common/src/main/java/io/netty/util/internal/jzlib/InfTree.java b/common/src/main/java/io/netty/util/internal/jzlib/InfTree.java deleted file mode 100644 index c00b65610b..0000000000 --- a/common/src/main/java/io/netty/util/internal/jzlib/InfTree.java +++ /dev/null @@ -1,478 +0,0 @@ -/* - * Copyright 2012 The Netty Project - * - * The Netty Project licenses this file to you under the Apache License, - * version 2.0 (the "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - */ -/* -Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the distribution. - - 3. The names of the authors may not be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, -INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, -OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, -EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * This program is based on zlib-1.1.3, so all credit should go authors - * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu) - * and contributors of zlib. - */ -package io.netty.util.internal.jzlib; - -final class InfTree { - - static final int fixed_bl = 9; - static final int fixed_bd = 5; - - static final int[] fixed_tl = { 96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, - 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9, 192, 80, 7, 10, 0, 8, 96, 0, - 8, 32, 0, 9, 160, 0, 8, 0, 0, 8, 128, 0, 8, 64, 0, 9, 224, 80, 7, - 6, 0, 8, 88, 0, 8, 24, 0, 9, 144, 83, 7, 59, 0, 8, 120, 0, 8, 56, - 0, 9, 208, 81, 7, 17, 0, 8, 104, 0, 8, 40, 0, 9, 176, 0, 8, 8, 0, - 8, 136, 0, 8, 72, 0, 9, 240, 80, 7, 4, 0, 8, 84, 0, 8, 20, 85, 8, - 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 200, 81, 7, 13, 0, 8, - 100, 0, 8, 36, 0, 9, 168, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0, 9, 232, - 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 152, 84, 7, 83, 0, 8, 124, 0, - 8, 60, 0, 9, 216, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 184, 0, 8, - 12, 0, 8, 140, 0, 8, 76, 0, 9, 248, 80, 7, 3, 0, 8, 82, 0, 8, 18, - 85, 8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, 9, 196, 81, 7, 11, - 0, 8, 98, 0, 8, 34, 0, 9, 164, 0, 8, 2, 0, 8, 130, 0, 8, 66, 0, 9, - 228, 80, 7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 148, 84, 7, 67, 0, 8, 122, - 0, 8, 58, 0, 9, 212, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, 180, 0, - 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 244, 80, 7, 5, 0, 8, 86, 0, 8, - 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 204, 81, 7, - 15, 0, 8, 102, 0, 8, 38, 0, 9, 172, 0, 8, 6, 0, 8, 134, 0, 8, 70, - 0, 9, 236, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, 156, 84, 7, 99, 0, - 8, 126, 0, 8, 62, 0, 9, 220, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, - 188, 0, 8, 14, 0, 8, 142, 0, 8, 78, 0, 9, 252, 96, 7, 256, 0, 8, - 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0, 8, 113, 0, 8, 49, 0, 9, - 194, 80, 7, 10, 0, 8, 97, 0, 8, 33, 0, 9, 162, 0, 8, 1, 0, 8, 129, - 0, 8, 65, 0, 9, 226, 80, 7, 6, 0, 8, 89, 0, 8, 25, 0, 9, 146, 83, - 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 210, 81, 7, 17, 0, 8, 105, 0, 8, - 41, 0, 9, 178, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, 242, 80, 7, 4, - 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, 117, 0, 8, 53, 0, - 9, 202, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 170, 0, 8, 5, 0, 8, - 133, 0, 8, 69, 0, 9, 234, 80, 7, 8, 0, 8, 93, 0, 8, 29, 0, 9, 154, - 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 218, 82, 7, 23, 0, 8, 109, 0, - 8, 45, 0, 9, 186, 0, 8, 13, 0, 8, 141, 0, 8, 77, 0, 9, 250, 80, 7, - 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8, 51, - 0, 9, 198, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, 166, 0, 8, 3, 0, 8, - 131, 0, 8, 67, 0, 9, 230, 80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 150, - 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 214, 82, 7, 19, 0, 8, 107, 0, - 8, 43, 0, 9, 182, 0, 8, 11, 0, 8, 139, 0, 8, 75, 0, 9, 246, 80, 7, - 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, - 0, 9, 206, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 174, 0, 8, 7, 0, - 8, 135, 0, 8, 71, 0, 9, 238, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, - 158, 84, 7, 99, 0, 8, 127, 0, 8, 63, 0, 9, 222, 82, 7, 27, 0, 8, - 111, 0, 8, 47, 0, 9, 190, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 254, - 96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, - 0, 8, 48, 0, 9, 193, - 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 161, 0, 8, 0, 0, 8, 128, 0, 8, - 64, 0, 9, 225, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 145, 83, 7, 59, - 0, 8, 120, 0, 8, 56, 0, 9, 209, 81, 7, 17, 0, 8, 104, 0, 8, 40, 0, - 9, 177, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 241, 80, 7, 4, 0, 8, - 84, 0, 8, 20, 85, 8, 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, - 201, 81, 7, 13, 0, 8, 100, 0, 8, 36, 0, 9, 169, 0, 8, 4, 0, 8, 132, - 0, 8, 68, 0, 9, 233, 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 153, 84, - 7, 83, 0, 8, 124, 0, 8, 60, 0, 9, 217, 82, 7, 23, 0, 8, 108, 0, 8, - 44, 0, 9, 185, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9, 249, 80, 7, 3, - 0, 8, 82, 0, 8, 18, 85, 8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, - 9, 197, 81, 7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 165, 0, 8, 2, 0, 8, - 130, 0, 8, 66, 0, 9, 229, 80, 7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 149, - 84, 7, 67, 0, 8, 122, 0, 8, 58, 0, 9, 213, 82, 7, 19, 0, 8, 106, 0, - 8, 42, 0, 9, 181, 0, 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 245, 80, 7, - 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, - 0, 9, 205, 81, 7, 15, 0, 8, 102, 0, 8, 38, 0, 9, 173, 0, 8, 6, 0, - 8, 134, 0, 8, 70, 0, 9, 237, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, - 157, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9, 221, 82, 7, 27, 0, 8, - 110, 0, 8, 46, 0, 9, 189, 0, 8, 14, 0, 8, 142, 0, 8, 78, 0, 9, 253, - 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0, 8, 113, - 0, 8, 49, 0, 9, 195, 80, 7, 10, 0, 8, 97, 0, 8, 33, 0, 9, 163, 0, - 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 227, 80, 7, 6, 0, 8, 89, 0, 8, 25, - 0, 9, 147, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 211, 81, 7, 17, 0, - 8, 105, 0, 8, 41, 0, 9, 179, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, - 243, 80, 7, 4, 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, - 117, 0, 8, 53, 0, 9, 203, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, - 171, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, 235, 80, 7, 8, 0, 8, 93, - 0, 8, 29, 0, 9, 155, 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 219, 82, - 7, 23, 0, 8, 109, 0, 8, 45, 0, 9, 187, 0, 8, 13, 0, 8, 141, 0, 8, - 77, 0, 9, 251, 80, 7, 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, - 0, 8, 115, 0, 8, 51, 0, 9, 199, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, - 9, 167, 0, 8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 231, 80, 7, 7, 0, 8, - 91, 0, 8, 27, 0, 9, 151, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 215, - 82, 7, 19, 0, 8, 107, 0, 8, 43, 0, 9, 183, 0, 8, 11, 0, 8, 139, 0, - 8, 75, 0, 9, 247, 80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, - 51, 0, 8, 119, 0, 8, 55, 0, 9, 207, 81, 7, 15, 0, 8, 103, 0, 8, 39, - 0, 9, 175, 0, 8, 7, 0, 8, 135, 0, 8, 71, 0, 9, 239, 80, 7, 9, 0, 8, - 95, 0, 8, 31, 0, 9, 159, 84, 7, 99, 0, 8, 127, 0, 8, 63, 0, 9, 223, - 82, 7, 27, 0, 8, 111, 0, 8, 47, 0, 9, 191, 0, 8, 15, 0, 8, 143, 0, - 8, 79, 0, 9, 255 }; - - static final int[] fixed_td = { 80, 5, 1, 87, 5, 257, 83, 5, 17, 91, 5, - 4097, 81, 5, 5, 89, 5, 1025, 85, 5, 65, 93, 5, 16385, 80, 5, 3, 88, - 5, 513, 84, 5, 33, 92, 5, 8193, 82, 5, 9, 90, 5, 2049, 86, 5, 129, - 192, 5, 24577, 80, 5, 2, 87, 5, 385, 83, 5, 25, 91, 5, 6145, 81, 5, - 7, 89, 5, 1537, 85, 5, 97, 93, 5, 24577, 80, 5, 4, 88, 5, 769, 84, - 5, 49, 92, 5, 12289, 82, 5, 13, 90, 5, 3073, 86, 5, 193, 192, 5, - 24577 }; - - // Tables for deflate from PKZIP's appnote.txt. - static final int[] cplens = { // Copy lengths for literal codes 257..285 - 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, - 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 }; - - // see note #13 above about 258 - static final int[] cplext = { // Extra bits for literal codes 257..285 - 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, - 5, 5, 5, 0, 112, 112 // 112==invalid - }; - - static final int[] cpdist = { // Copy offsets for distance codes 0..29 - 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, - 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577 }; - - static final int[] cpdext = { // Extra bits for distance codes - 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, - 11, 11, 12, 12, 13, 13 }; - - // If BMAX needs to be larger than 16, then h and x[] should be uLong. - static final int BMAX = 15; // maximum bit length of any code - - private int[] hn; // hufts used in space - private int[] v; // work area for huft_build - private int[] c; // bit length count table - private int[] r; // table entry for structure assignment - private int[] u; // table stack - private int[] x; // bit offsets, then code stack - - private int huft_build(int[] b, // code lengths in bits (all assumed <= BMAX) - int bindex, int n, // number of codes (assumed <= 288) - int s, // number of simple-valued codes (0..s-1) - int[] d, // list of base values for non-simple codes - int[] e, // list of extra bits for non-simple codes - int[] t, // result: starting table - int[] m, // maximum lookup bits, returns actual - int[] hp, // space for trees - int[] hn, // hufts used in space - int[] v // working area: values in order of bit length - ) { - // 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 JZlib.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 JZlib.Z_DATA_ERROR; - } - } - if ((y -= c[i]) < 0) { - return JZlib.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 > JZlib.MANY) { // (note: doesn't matter for fixed) - return JZlib.Z_DATA_ERROR; // overflow of MANY - } - u[h] = q = /*hp+*/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] = (byte) j; // bits in this table - r[1] = (byte) l; // bits to dump before this table - j = i >>> w - l; - r[2] = q - u[h - 1] - j; // offset to this table - System.arraycopy(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] = (byte) (k - w); - if (p >= n) { - r[0] = 128 + 64; // out of values--invalid code - } else if (v[p] < s) { - r[0] = (byte) (v[p] < 256? 0 : 32 + 64); // 256 is end-of-block - r[2] = v[p ++]; // simple code is just the value - } else { - r[0] = (byte) (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 = i >>> w; j < z; j += f) { - System.arraycopy(r, 0, hp, (q + j) * 3, 3); - } - - // backwards increment the k-bit code i - for (j = 1 << k - 1; (i & j) != 0; 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? JZlib.Z_BUF_ERROR : JZlib.Z_OK; - } - - int inflate_trees_bits(int[] c, // 19 code lengths - int[] bb, // bits tree desired/actual depth - int[] tb, // bits tree result - int[] hp, // space for trees - ZStream z // for messages - ) { - int result; - initWorkArea(19); - hn[0] = 0; - result = huft_build(c, 0, 19, 19, null, null, tb, bb, hp, hn, v); - - if (result == JZlib.Z_DATA_ERROR) { - z.msg = "oversubscribed dynamic bit lengths tree"; - } else if (result == JZlib.Z_BUF_ERROR || bb[0] == 0) { - z.msg = "incomplete dynamic bit lengths tree"; - result = JZlib.Z_DATA_ERROR; - } - return result; - } - - int inflate_trees_dynamic(int nl, // number of literal/length codes - int nd, // number of distance codes - int[] c, // that many (total) code lengths - int[] bl, // literal desired/actual bit depth - int[] bd, // distance desired/actual bit depth - int[] tl, // literal/length tree result - int[] td, // distance tree result - int[] hp, // space for trees - ZStream z // for messages - ) { - int result; - - // build literal/length tree - initWorkArea(288); - hn[0] = 0; - result = huft_build(c, 0, nl, 257, cplens, cplext, tl, bl, hp, hn, v); - if (result != JZlib.Z_OK || bl[0] == 0) { - if (result == JZlib.Z_DATA_ERROR) { - z.msg = "oversubscribed literal/length tree"; - } else if (result != JZlib.Z_MEM_ERROR) { - z.msg = "incomplete literal/length tree"; - result = JZlib.Z_DATA_ERROR; - } - return result; - } - - // build distance tree - initWorkArea(288); - result = huft_build(c, nl, nd, 0, cpdist, cpdext, td, bd, hp, hn, v); - - if (result != JZlib.Z_OK || bd[0] == 0 && nl > 257) { - if (result == JZlib.Z_DATA_ERROR) { - z.msg = "oversubscribed distance tree"; - } else if (result == JZlib.Z_BUF_ERROR) { - z.msg = "incomplete distance tree"; - result = JZlib.Z_DATA_ERROR; - } else if (result != JZlib.Z_MEM_ERROR) { - z.msg = "empty distance tree with lengths"; - result = JZlib.Z_DATA_ERROR; - } - return result; - } - - return JZlib.Z_OK; - } - - static int inflate_trees_fixed(int[] bl, //literal desired/actual bit depth - int[] bd, //distance desired/actual bit depth - int[][] tl, //literal/length tree result - int[][] td //distance tree result - ) { - bl[0] = fixed_bl; - bd[0] = fixed_bd; - tl[0] = fixed_tl; - td[0] = fixed_td; - return JZlib.Z_OK; - } - - private void initWorkArea(int vsize) { - if (hn == null) { - hn = new int[1]; - v = new int[vsize]; - c = new int[BMAX + 1]; - r = new int[3]; - u = new int[BMAX]; - x = new int[BMAX + 1]; - } else { - if (v.length < vsize) { - v = new int[vsize]; - } else { - for (int i = 0; i < vsize; i ++) { - v[i] = 0; - } - } - for (int i = 0; i < BMAX + 1; i ++) { - c[i] = 0; - } - for (int i = 0; i < 3; i ++) { - r[i] = 0; - } - // for(int i=0; istate); - return JZlib.Z_OK; - } - - int inflateInit(ZStream z, int w, WrapperType wrapperType) { - z.msg = null; - blocks = null; - - this.wrapperType = wrapperType; - - if (w < 0) { - throw new IllegalArgumentException("w: " + w); - } - - // set window size - if (w < 8 || w > 15) { - inflateEnd(z); - return JZlib.Z_STREAM_ERROR; - } - wbits = w; - - z.istate.blocks = new InfBlocks( - z, z.istate.wrapperType == WrapperType.NONE? null : this, - 1 << w); - - // reset state - inflateReset(z); - return JZlib.Z_OK; - } - - int inflate(ZStream z, int f) { - int r; - int b; - - if (z == null || z.istate == null || z.next_in == null) { - return JZlib.Z_STREAM_ERROR; - } - f = f == JZlib.Z_FINISH? JZlib.Z_BUF_ERROR : JZlib.Z_OK; - r = JZlib.Z_BUF_ERROR; - while (true) { - //System.out.println("mode: "+z.istate.mode); - switch (z.istate.mode) { - case METHOD: - - if (z.avail_in == 0) { - return r; - } - - // Switch from zlib to none if necessary. - if (z.istate.wrapperType == WrapperType.ZLIB_OR_NONE) { - if ((z.next_in[z.next_in_index] & 0xf) != JZlib.Z_DEFLATED || - (z.next_in[z.next_in_index] >> 4) + 8 > z.istate.wbits) { - z.istate.wrapperType = WrapperType.NONE; - z.istate.mode = BLOCKS; - break; - } else { - z.istate.wrapperType = WrapperType.ZLIB; - } - } - - r = f; - - z.avail_in --; - z.total_in ++; - if (((z.istate.method = z.next_in[z.next_in_index ++]) & 0xf) != JZlib.Z_DEFLATED) { - z.istate.mode = BAD; - z.msg = "unknown compression method"; - z.istate.marker = 5; // can't try inflateSync - break; - } - if ((z.istate.method >> 4) + 8 > z.istate.wbits) { - z.istate.mode = BAD; - z.msg = "invalid window size"; - z.istate.marker = 5; // can't try inflateSync - break; - } - z.istate.mode = FLAG; - case FLAG: - - if (z.avail_in == 0) { - return r; - } - r = f; - - z.avail_in --; - z.total_in ++; - b = z.next_in[z.next_in_index ++] & 0xff; - - if (((z.istate.method << 8) + b) % 31 != 0) { - z.istate.mode = BAD; - z.msg = "incorrect header check"; - z.istate.marker = 5; // can't try inflateSync - break; - } - - if ((b & JZlib.PRESET_DICT) == 0) { - z.istate.mode = BLOCKS; - break; - } - z.istate.mode = DICT4; - case DICT4: - - if (z.avail_in == 0) { - return r; - } - r = f; - - z.avail_in --; - z.total_in ++; - z.istate.need = (z.next_in[z.next_in_index ++] & 0xff) << 24 & 0xff000000L; - z.istate.mode = DICT3; - case DICT3: - - if (z.avail_in == 0) { - return r; - } - r = f; - - z.avail_in --; - z.total_in ++; - z.istate.need += (z.next_in[z.next_in_index ++] & 0xff) << 16 & 0xff0000L; - z.istate.mode = DICT2; - case DICT2: - - if (z.avail_in == 0) { - return r; - } - r = f; - - z.avail_in --; - z.total_in ++; - z.istate.need += (z.next_in[z.next_in_index ++] & 0xff) << 8 & 0xff00L; - z.istate.mode = DICT1; - case DICT1: - - if (z.avail_in == 0) { - return r; - } - - z.avail_in --; - z.total_in ++; - z.istate.need += z.next_in[z.next_in_index ++] & 0xffL; - z.adler = z.istate.need; - z.istate.mode = DICT0; - return JZlib.Z_NEED_DICT; - case DICT0: - z.istate.mode = BAD; - z.msg = "need dictionary"; - z.istate.marker = 0; // can try inflateSync - return JZlib.Z_STREAM_ERROR; - case BLOCKS: - int old_next_out_index = z.next_out_index; - try { - r = z.istate.blocks.proc(z, r); - if (r == JZlib.Z_DATA_ERROR) { - z.istate.mode = BAD; - z.istate.marker = 0; // can try inflateSync - break; - } - if (r == JZlib.Z_OK) { - r = f; - } - if (r != JZlib.Z_STREAM_END) { - return r; - } - r = f; - z.istate.blocks.reset(z, z.istate.was); - } finally { - int decompressedBytes = z.next_out_index - old_next_out_index; - gzipUncompressedBytes += decompressedBytes; - z.crc32 = CRC32.crc32(z.crc32, z.next_out, old_next_out_index, decompressedBytes); - } - - if (z.istate.wrapperType == WrapperType.NONE) { - z.istate.mode = DONE; - break; - } - if (z.istate.wrapperType == WrapperType.ZLIB) { - z.istate.mode = CHECK4; - } else if (z.istate.wrapperType == WrapperType.GZIP) { - gzipCRC32 = 0; - gzipISize = 0; - gzipBytesToRead = 4; - z.istate.mode = GZIP_CRC32; - break; - } else { - z.istate.mode = BAD; - z.msg = "unexpected state"; - z.istate.marker = 0; - break; - } - case CHECK4: - if (z.avail_in == 0) { - return r; - } - r = f; - - z.avail_in --; - z.total_in ++; - z.istate.need = (z.next_in[z.next_in_index ++] & 0xff) << 24 & 0xff000000L; - z.istate.mode = CHECK3; - case CHECK3: - if (z.avail_in == 0) { - return r; - } - r = f; - - z.avail_in --; - z.total_in ++; - z.istate.need += (z.next_in[z.next_in_index ++] & 0xff) << 16 & 0xff0000L; - z.istate.mode = CHECK2; - case CHECK2: - if (z.avail_in == 0) { - return r; - } - r = f; - - z.avail_in --; - z.total_in ++; - z.istate.need += (z.next_in[z.next_in_index ++] & 0xff) << 8 & 0xff00L; - z.istate.mode = CHECK1; - case CHECK1: - if (z.avail_in == 0) { - return r; - } - r = f; - - z.avail_in --; - z.total_in ++; - z.istate.need += z.next_in[z.next_in_index ++] & 0xffL; - - if ((int) z.istate.was[0] != (int) z.istate.need) { - z.istate.mode = BAD; - z.msg = "incorrect data check"; - z.istate.marker = 5; // can't try inflateSync - break; - } - - z.istate.mode = DONE; - case DONE: - return JZlib.Z_STREAM_END; - case BAD: - return JZlib.Z_DATA_ERROR; - case GZIP_ID1: - if (z.avail_in == 0) { - return r; - } - r = f; - z.avail_in --; - z.total_in ++; - - if ((z.next_in[z.next_in_index ++] & 0xff) != 31) { - z.istate.mode = BAD; - z.msg = "not a gzip stream"; - z.istate.marker = 5; // can't try inflateSync - break; - } - z.istate.mode = GZIP_ID2; - case GZIP_ID2: - if (z.avail_in == 0) { - return r; - } - r = f; - z.avail_in --; - z.total_in ++; - - if ((z.next_in[z.next_in_index ++] & 0xff) != 139) { - z.istate.mode = BAD; - z.msg = "not a gzip stream"; - z.istate.marker = 5; // can't try inflateSync - break; - } - z.istate.mode = GZIP_CM; - case GZIP_CM: - if (z.avail_in == 0) { - return r; - } - r = f; - z.avail_in --; - z.total_in ++; - - if ((z.next_in[z.next_in_index ++] & 0xff) != JZlib.Z_DEFLATED) { - z.istate.mode = BAD; - z.msg = "unknown compression method"; - z.istate.marker = 5; // can't try inflateSync - break; - } - z.istate.mode = GZIP_FLG; - case GZIP_FLG: - if (z.avail_in == 0) { - return r; - } - r = f; - z.avail_in --; - z.total_in ++; - gzipFlag = z.next_in[z.next_in_index ++] & 0xff; - - if ((gzipFlag & 0xE2) != 0) { - z.istate.mode = BAD; - z.msg = "unsupported flag"; - z.istate.marker = 5; // can't try inflateSync - break; - } - gzipBytesToRead = 6; - z.istate.mode = GZIP_MTIME_XFL_OS; - case GZIP_MTIME_XFL_OS: - while (gzipBytesToRead > 0) { - if (z.avail_in == 0) { - return r; - } - r = f; - z.avail_in --; - z.total_in ++; - z.next_in_index ++; - gzipBytesToRead --; - } - z.istate.mode = GZIP_XLEN; - gzipXLen = 0; - gzipBytesToRead = 2; - case GZIP_XLEN: - if ((gzipFlag & 4) != 0) { - while (gzipBytesToRead > 0) { - if (z.avail_in == 0) { - return r; - } - r = f; - z.avail_in --; - z.total_in ++; - gzipXLen |= (z.next_in[z.next_in_index ++] & 0xff) << (1 - gzipBytesToRead) * 8; - gzipBytesToRead --; - } - gzipBytesToRead = gzipXLen; - z.istate.mode = GZIP_FEXTRA; - } else { - z.istate.mode = GZIP_FNAME; - break; - } - case GZIP_FEXTRA: - while (gzipBytesToRead > 0) { - if (z.avail_in == 0) { - return r; - } - r = f; - z.avail_in --; - z.total_in ++; - z.next_in_index ++; - gzipBytesToRead --; - } - z.istate.mode = GZIP_FNAME; - case GZIP_FNAME: - if ((gzipFlag & 8) != 0) { - do { - if (z.avail_in == 0) { - return r; - } - r = f; - z.avail_in --; - z.total_in ++; - } while (z.next_in[z.next_in_index ++] != 0); - } - z.istate.mode = GZIP_FCOMMENT; - case GZIP_FCOMMENT: - if ((gzipFlag & 16) != 0) { - do { - if (z.avail_in == 0) { - return r; - } - r = f; - z.avail_in --; - z.total_in ++; - } while (z.next_in[z.next_in_index ++] != 0); - } - gzipBytesToRead = 2; - z.istate.mode = GZIP_FHCRC; - case GZIP_FHCRC: - if ((gzipFlag & 2) != 0) { - while (gzipBytesToRead > 0) { - if (z.avail_in == 0) { - return r; - } - r = f; - z.avail_in --; - z.total_in ++; - z.next_in_index ++; - gzipBytesToRead --; - } - } - z.istate.mode = BLOCKS; - break; - case GZIP_CRC32: - while (gzipBytesToRead > 0) { - if (z.avail_in == 0) { - return r; - } - r = f; - z.avail_in --; - z.total_in ++; - gzipBytesToRead --; - z.istate.gzipCRC32 |= (z.next_in[z.next_in_index ++] & 0xff) << (3 - gzipBytesToRead) * 8; - } - - if (z.crc32 != z.istate.gzipCRC32) { - z.istate.mode = BAD; - z.msg = "incorrect CRC32 checksum"; - z.istate.marker = 5; // can't try inflateSync - break; - } - gzipBytesToRead = 4; - z.istate.mode = GZIP_ISIZE; - case GZIP_ISIZE: - while (gzipBytesToRead > 0) { - if (z.avail_in == 0) { - return r; - } - r = f; - z.avail_in --; - z.total_in ++; - gzipBytesToRead --; - z.istate.gzipISize |= (z.next_in[z.next_in_index ++] & 0xff) << (3 - gzipBytesToRead) * 8; - } - - if (gzipUncompressedBytes != z.istate.gzipISize) { - z.istate.mode = BAD; - z.msg = "incorrect ISIZE checksum"; - z.istate.marker = 5; // can't try inflateSync - break; - } - - z.istate.mode = DONE; - break; - default: - return JZlib.Z_STREAM_ERROR; - } - } - } - - static int inflateSetDictionary(ZStream z, byte[] dictionary, int dictLength) { - int index = 0; - int length = dictLength; - if (z == null || z.istate == null || z.istate.mode != DICT0) { - return JZlib.Z_STREAM_ERROR; - } - - if (Adler32.adler32(1L, dictionary, 0, dictLength) != z.adler) { - return JZlib.Z_DATA_ERROR; - } - - z.adler = Adler32.adler32(0, null, 0, 0); - - if (length >= 1 << z.istate.wbits) { - length = (1 << z.istate.wbits) - 1; - index = dictLength - length; - } - z.istate.blocks.set_dictionary(dictionary, index, length); - z.istate.mode = BLOCKS; - return JZlib.Z_OK; - } - - private static final byte[] mark = { (byte) 0, (byte) 0, (byte) 0xff, (byte) 0xff }; - - int inflateSync(ZStream z) { - int n; // number of bytes to look at - int p; // pointer to bytes - int m; // number of marker bytes found in a row - long r, w; // temporaries to save total_in and total_out - - // set up - if (z == null || z.istate == null) { - return JZlib.Z_STREAM_ERROR; - } - if (z.istate.mode != BAD) { - z.istate.mode = BAD; - z.istate.marker = 0; - } - if ((n = z.avail_in) == 0) { - return JZlib.Z_BUF_ERROR; - } - p = z.next_in_index; - m = z.istate.marker; - - // search - while (n != 0 && m < 4) { - if (z.next_in[p] == mark[m]) { - m ++; - } else if (z.next_in[p] != 0) { - m = 0; - } else { - m = 4 - m; - } - p ++; - n --; - } - - // restore - z.total_in += p - z.next_in_index; - z.next_in_index = p; - z.avail_in = n; - z.istate.marker = m; - - // return no joy or set up to restart on a new block - if (m != 4) { - return JZlib.Z_DATA_ERROR; - } - r = z.total_in; - w = z.total_out; - inflateReset(z); - z.total_in = r; - z.total_out = w; - z.istate.mode = BLOCKS; - return JZlib.Z_OK; - } -} diff --git a/common/src/main/java/io/netty/util/internal/jzlib/JZlib.java b/common/src/main/java/io/netty/util/internal/jzlib/JZlib.java deleted file mode 100644 index 9aee535ffc..0000000000 --- a/common/src/main/java/io/netty/util/internal/jzlib/JZlib.java +++ /dev/null @@ -1,112 +0,0 @@ -/* - * Copyright 2012 The Netty Project - * - * The Netty Project licenses this file to you under the Apache License, - * version 2.0 (the "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - */ -/* -Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the distribution. - - 3. The names of the authors may not be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, -INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, -OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, -EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * This program is based on zlib-1.1.3, so all credit should go authors - * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu) - * and contributors of zlib. - */ -package io.netty.util.internal.jzlib; - -public final class JZlib { - - // wrapper types - public static final Enum W_NONE = WrapperType.NONE; - public static final Enum W_ZLIB = WrapperType.ZLIB; - public static final Enum W_GZIP = WrapperType.GZIP; - public static final Enum W_ZLIB_OR_NONE = WrapperType.ZLIB_OR_NONE; - - // compression levels - public static final int Z_NO_COMPRESSION = 0; - public static final int Z_BEST_SPEED = 1; - public static final int Z_BEST_COMPRESSION = 9; - public static final int Z_DEFAULT_COMPRESSION = -1; - - // compression strategy - public static final int Z_FILTERED = 1; - public static final int Z_HUFFMAN_ONLY = 2; - public static final int Z_DEFAULT_STRATEGY = 0; - - // flush method - public static final int Z_NO_FLUSH = 0; - public static final int Z_PARTIAL_FLUSH = 1; - public static final int Z_SYNC_FLUSH = 2; - public static final int Z_FULL_FLUSH = 3; - public static final int Z_FINISH = 4; - - // return codes - public static final int Z_OK = 0; - public static final int Z_STREAM_END = 1; - public static final int Z_NEED_DICT = 2; - public static final int Z_ERRNO = -1; - public static final int Z_STREAM_ERROR = -2; - public static final int Z_DATA_ERROR = -3; - public static final int Z_MEM_ERROR = -4; - public static final int Z_BUF_ERROR = -5; - public static final int Z_VERSION_ERROR = -6; - - // internal stuff - static final int Z_DEFLATED = 8; - static final int MAX_MEM_LEVEL = 9; - static final int DEF_MEM_LEVEL = 8; - static final int MAX_WBITS = 15; // 32K LZ77 window - static final int DEF_WBITS = MAX_WBITS; - static final int MAX_BITS = 15; - static final int PRESET_DICT = 0x20; // preset dictionary flag in zlib header - static final int MANY = 1440; - static final int BL_CODES = 19; - static final int D_CODES = 30; - static final int LITERALS = 256; - static final int LENGTH_CODES = 29; - static final int L_CODES = LITERALS + 1 + LENGTH_CODES; - static final int HEAP_SIZE = 2 * L_CODES + 1; - // Bit length codes must not exceed MAX_BL_BITS bits - static final int MAX_BL_BITS = 7; - - enum WrapperType { - NONE, ZLIB, GZIP, ZLIB_OR_NONE - } - - private JZlib() { - // Utility class - } -} diff --git a/common/src/main/java/io/netty/util/internal/jzlib/StaticTree.java b/common/src/main/java/io/netty/util/internal/jzlib/StaticTree.java deleted file mode 100644 index 8f55ed45b9..0000000000 --- a/common/src/main/java/io/netty/util/internal/jzlib/StaticTree.java +++ /dev/null @@ -1,114 +0,0 @@ -/* - * Copyright 2012 The Netty Project - * - * The Netty Project licenses this file to you under the Apache License, - * version 2.0 (the "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - */ -/* -Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the distribution. - - 3. The names of the authors may not be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, -INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, -OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, -EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * This program is based on zlib-1.1.3, so all credit should go authors - * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu) - * and contributors of zlib. - */ -package io.netty.util.internal.jzlib; - -final class StaticTree { - static final short[] static_ltree = { 12, 8, 140, 8, 76, 8, 204, 8, 44, 8, - 172, 8, 108, 8, 236, 8, 28, 8, 156, 8, 92, 8, 220, 8, 60, 8, 188, - 8, 124, 8, 252, 8, 2, 8, 130, 8, 66, 8, 194, 8, 34, 8, 162, 8, 98, - 8, 226, 8, 18, 8, 146, 8, 82, 8, 210, 8, 50, 8, 178, 8, 114, 8, - 242, 8, 10, 8, 138, 8, 74, 8, 202, 8, 42, 8, 170, 8, 106, 8, 234, - 8, 26, 8, 154, 8, 90, 8, 218, 8, 58, 8, 186, 8, 122, 8, 250, 8, 6, - 8, 134, 8, 70, 8, 198, 8, 38, 8, 166, 8, 102, 8, 230, 8, 22, 8, - 150, 8, 86, 8, 214, 8, 54, 8, 182, 8, 118, 8, 246, 8, 14, 8, 142, - 8, 78, 8, 206, 8, 46, 8, 174, 8, 110, 8, 238, 8, 30, 8, 158, 8, 94, - 8, 222, 8, 62, 8, 190, 8, 126, 8, 254, 8, 1, 8, 129, 8, 65, 8, 193, - 8, 33, 8, 161, 8, 97, 8, 225, 8, 17, 8, 145, 8, 81, 8, 209, 8, 49, - 8, 177, 8, 113, 8, 241, 8, 9, 8, 137, 8, 73, 8, 201, 8, 41, 8, 169, - 8, 105, 8, 233, 8, 25, 8, 153, 8, 89, 8, 217, 8, 57, 8, 185, 8, - 121, 8, 249, 8, 5, 8, 133, 8, 69, 8, 197, 8, 37, 8, 165, 8, 101, 8, - 229, 8, 21, 8, 149, 8, 85, 8, 213, 8, 53, 8, 181, 8, 117, 8, 245, - 8, 13, 8, 141, 8, 77, 8, 205, 8, 45, 8, 173, 8, 109, 8, 237, 8, 29, - 8, 157, 8, 93, 8, 221, 8, 61, 8, 189, 8, 125, 8, 253, 8, 19, 9, - 275, 9, 147, 9, 403, 9, 83, 9, 339, 9, 211, 9, 467, 9, 51, 9, 307, - 9, 179, 9, 435, 9, 115, 9, 371, 9, 243, 9, 499, 9, 11, 9, 267, 9, - 139, 9, 395, 9, 75, 9, 331, 9, 203, 9, 459, 9, 43, 9, 299, 9, 171, - 9, 427, 9, 107, 9, 363, 9, 235, 9, 491, 9, 27, 9, 283, 9, 155, 9, - 411, 9, 91, 9, 347, 9, 219, 9, 475, 9, 59, 9, 315, 9, 187, 9, 443, - 9, 123, 9, 379, 9, 251, 9, 507, 9, 7, 9, 263, 9, 135, 9, 391, 9, - 71, 9, 327, 9, 199, 9, 455, 9, 39, 9, 295, 9, 167, 9, 423, 9, 103, - 9, 359, 9, 231, 9, 487, 9, 23, 9, 279, 9, 151, 9, 407, 9, 87, 9, - 343, 9, 215, 9, 471, 9, 55, 9, 311, 9, 183, 9, 439, 9, 119, 9, 375, - 9, 247, 9, 503, 9, 15, 9, 271, 9, 143, 9, 399, 9, 79, 9, 335, 9, - 207, 9, 463, 9, 47, 9, 303, 9, 175, 9, 431, 9, 111, 9, 367, 9, 239, - 9, 495, 9, 31, 9, 287, 9, 159, 9, 415, 9, 95, 9, 351, 9, 223, 9, - 479, 9, 63, 9, 319, 9, 191, 9, 447, 9, 127, 9, 383, 9, 255, 9, 511, - 9, 0, 7, 64, 7, 32, 7, 96, 7, 16, 7, 80, 7, 48, 7, 112, 7, 8, 7, - 72, 7, 40, 7, 104, 7, 24, 7, 88, 7, 56, 7, 120, 7, 4, 7, 68, 7, 36, - 7, 100, 7, 20, 7, 84, 7, 52, 7, 116, 7, 3, 8, 131, 8, 67, 8, 195, - 8, 35, 8, 163, 8, 99, 8, 227, 8 }; - - static final short[] static_dtree = { 0, 5, 16, 5, 8, 5, 24, 5, 4, 5, 20, - 5, 12, 5, 28, 5, 2, 5, 18, 5, 10, 5, 26, 5, 6, 5, 22, 5, 14, 5, 30, - 5, 1, 5, 17, 5, 9, 5, 25, 5, 5, 5, 21, 5, 13, 5, 29, 5, 3, 5, 19, - 5, 11, 5, 27, 5, 7, 5, 23, 5 }; - - static final StaticTree static_l_desc = new StaticTree(static_ltree, - Tree.extra_lbits, JZlib.LITERALS + 1, JZlib.L_CODES, JZlib.MAX_BITS); - - static final StaticTree static_d_desc = new StaticTree(static_dtree, - Tree.extra_dbits, 0, JZlib.D_CODES, JZlib.MAX_BITS); - - static final StaticTree static_bl_desc = new StaticTree(null, Tree.extra_blbits, - 0, JZlib.BL_CODES, JZlib.MAX_BL_BITS); - - final short[] static_tree; // static tree or null - final int[] extra_bits; // extra bits for each code or null - final int extra_base; // base index for extra_bits - final int elems; // max number of elements in the tree - final int max_length; // max bit length for the codes - - StaticTree(short[] static_tree, int[] extra_bits, int extra_base, - int elems, int max_length) { - this.static_tree = static_tree; - this.extra_bits = extra_bits; - this.extra_base = extra_base; - this.elems = elems; - this.max_length = max_length; - } -} diff --git a/common/src/main/java/io/netty/util/internal/jzlib/Tree.java b/common/src/main/java/io/netty/util/internal/jzlib/Tree.java deleted file mode 100644 index c39ececc48..0000000000 --- a/common/src/main/java/io/netty/util/internal/jzlib/Tree.java +++ /dev/null @@ -1,362 +0,0 @@ -/* - * Copyright 2012 The Netty Project - * - * The Netty Project licenses this file to you under the Apache License, - * version 2.0 (the "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - */ -/* -Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the distribution. - - 3. The names of the authors may not be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, -INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, -OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, -EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * This program is based on zlib-1.1.3, so all credit should go authors - * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu) - * and contributors of zlib. - */ -package io.netty.util.internal.jzlib; - -final class Tree { - // extra bits for each length code - static final int[] extra_lbits = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, - 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 }; - - // extra bits for each distance code - static final int[] extra_dbits = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, - 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 }; - - // extra bits for each bit length code - static final int[] extra_blbits = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2, 3, 7 }; - - static final byte[] bl_order = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, - 12, 3, 13, 2, 14, 1, 15 }; - - static final byte[] _dist_code = { 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, - 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, - 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, - 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, - 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, - 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, - 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, - 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, - 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, - 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, - 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, - 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, - 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, - 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, - 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, - 15, 0, 0, 16, 17, 18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, - 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, - 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, - 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, - 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, - 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, - 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, - 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, - 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, - 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, - 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, - 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, - 29, 29 }; - - static final byte[] _length_code = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, - 10, 10, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, - 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, - 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, - 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, - 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, - 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, - 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, - 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, - 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, - 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, - 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, - 27, 27, 27, 27, 27, 28 }; - - static final int[] base_length = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, - 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, - 224, 0 }; - - static final int[] base_dist = { 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, - 64, 96, 128, 192, 256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096, - 6144, 8192, 12288, 16384, 24576 }; - - // Mapping from a distance to a distance code. dist is the distance - 1 and - // must not have side effects. _dist_code[256] and _dist_code[257] are never - // used. - static int d_code(int dist) { - return dist < 256? _dist_code[dist] : _dist_code[256 + (dist >>> 7)]; - } - - short[] dyn_tree; // the dynamic tree - int max_code; // largest code with non zero frequency - StaticTree stat_desc; // the corresponding static tree - - // Compute the optimal bit lengths for a tree and update the total bit length - // for the current block. - // IN assertion: the fields freq and dad are set, heap[heap_max] and - // above are the tree nodes sorted by increasing frequency. - // OUT assertions: the field len is set to the optimal bit length, the - // array bl_count contains the frequencies for each bit length. - // The length opt_len is updated; static_len is also updated if stree is - // not null. - private void gen_bitlen(Deflate s) { - short[] tree = dyn_tree; - short[] stree = stat_desc.static_tree; - int[] extra = stat_desc.extra_bits; - int base = stat_desc.extra_base; - int max_length = stat_desc.max_length; - int h; // heap index - int n, m; // iterate over the tree elements - int bits; // bit length - int xbits; // extra bits - short f; // frequency - int overflow = 0; // number of elements with bit length too large - - for (bits = 0; bits <= JZlib.MAX_BITS; bits ++) { - s.bl_count[bits] = 0; - } - - // In a first pass, compute the optimal bit lengths (which may - // overflow in the case of the bit length tree). - tree[s.heap[s.heap_max] * 2 + 1] = 0; // root of the heap - - for (h = s.heap_max + 1; h < JZlib.HEAP_SIZE; h ++) { - n = s.heap[h]; - bits = tree[tree[n * 2 + 1] * 2 + 1] + 1; - if (bits > max_length) { - bits = max_length; - overflow ++; - } - tree[n * 2 + 1] = (short) bits; - // We overwrite tree[n*2+1] which is no longer needed - - if (n > max_code) { - continue; // not a leaf node - } - - s.bl_count[bits] ++; - xbits = 0; - if (n >= base) { - xbits = extra[n - base]; - } - f = tree[n * 2]; - s.opt_len += f * (bits + xbits); - if (stree != null) { - s.static_len += f * (stree[n * 2 + 1] + xbits); - } - } - if (overflow == 0) { - return; - } - - // This happens for example on obj2 and pic of the Calgary corpus - // Find the first bit length which could increase: - do { - bits = max_length - 1; - while (s.bl_count[bits] == 0) { - bits --; - } - s.bl_count[bits] --; // move one leaf down the tree - s.bl_count[bits + 1] += 2; // move one overflow item as its brother - s.bl_count[max_length] --; - // The brother of the overflow item also moves one step up, - // but this does not affect bl_count[max_length] - overflow -= 2; - } while (overflow > 0); - - for (bits = max_length; bits != 0; bits --) { - n = s.bl_count[bits]; - while (n != 0) { - m = s.heap[-- h]; - if (m > max_code) { - continue; - } - if (tree[m * 2 + 1] != bits) { - s.opt_len += ((long) bits - tree[m * 2 + 1]) * - tree[m * 2]; - tree[m * 2 + 1] = (short) bits; - } - n --; - } - } - } - - // Construct one Huffman tree and assigns the code bit strings and lengths. - // Update the total bit length for the current block. - // IN assertion: the field freq is set for all tree elements. - // OUT assertions: the fields len and code are set to the optimal bit length - // and corresponding code. The length opt_len is updated; static_len is - // also updated if stree is not null. The field max_code is set. - void build_tree(Deflate s) { - short[] tree = dyn_tree; - short[] stree = stat_desc.static_tree; - int elems = stat_desc.elems; - int n, m; // iterate over heap elements - int max_code = -1; // largest code with non zero frequency - int node; // new node being created - - // Construct the initial heap, with least frequent element in - // heap[1]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. - // heap[0] is not used. - s.heap_len = 0; - s.heap_max = JZlib.HEAP_SIZE; - - for (n = 0; n < elems; n ++) { - if (tree[n * 2] != 0) { - s.heap[++ s.heap_len] = max_code = n; - s.depth[n] = 0; - } else { - tree[n * 2 + 1] = 0; - } - } - - // The pkzip format requires that at least one distance code exists, - // and that at least one bit should be sent even if there is only one - // possible code. So to avoid special checks later on we force at least - // two codes of non zero frequency. - while (s.heap_len < 2) { - node = s.heap[++ s.heap_len] = max_code < 2? ++ max_code : 0; - tree[node * 2] = 1; - s.depth[node] = 0; - s.opt_len --; - if (stree != null) { - s.static_len -= stree[node * 2 + 1]; - // node is 0 or 1 so it does not have extra bits - } - } - this.max_code = max_code; - - // The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, - // establish sub-heaps of increasing lengths: - - for (n = s.heap_len / 2; n >= 1; n --) { - s.pqdownheap(tree, n); - } - - // Construct the Huffman tree by repeatedly combining the least two - // frequent nodes. - - node = elems; // next internal node of the tree - do { - // n = node of least frequency - n = s.heap[1]; - s.heap[1] = s.heap[s.heap_len --]; - s.pqdownheap(tree, 1); - m = s.heap[1]; // m = node of next least frequency - - s.heap[-- s.heap_max] = n; // keep the nodes sorted by frequency - s.heap[-- s.heap_max] = m; - - // Create a new node father of n and m - tree[node * 2] = (short) (tree[n * 2] + tree[m * 2]); - s.depth[node] = (byte) (Math.max(s.depth[n], s.depth[m]) + 1); - tree[n * 2 + 1] = tree[m * 2 + 1] = (short) node; - - // and insert the new node in the heap - s.heap[1] = node ++; - s.pqdownheap(tree, 1); - } while (s.heap_len >= 2); - - s.heap[-- s.heap_max] = s.heap[1]; - - // At this point, the fields freq and dad are set. We can now - // generate the bit lengths. - - gen_bitlen(s); - - // The field len is now set, we can generate the bit codes - gen_codes(tree, max_code, s.bl_count); - } - - // Generate the codes for a given tree and bit counts (which need not be - // optimal). - // IN assertion: the array bl_count contains the bit length statistics for - // the given tree and the field len is set for all tree elements. - // OUT assertion: the field code is set for all tree elements of non - // zero code length. - private static void gen_codes(short[] tree, // the tree to decorate - int max_code, // largest code with non zero frequency - short[] bl_count // number of codes at each bit length - ) { - short[] next_code = new short[JZlib.MAX_BITS + 1]; // next code value for each bit length - short code = 0; // running code value - int bits; // bit index - int n; // code index - - // The distribution counts are first used to generate the code values - // without bit reversal. - for (bits = 1; bits <= JZlib.MAX_BITS; bits ++) { - next_code[bits] = code = (short) (code + bl_count[bits - 1] << 1); - } - - // Check that the bit counts in bl_count are consistent. The last code - // must be all ones. - //Assert (code + bl_count[MAX_BITS]-1 == (1<>>= 1; - res <<= 1; - } while (-- len > 0); - return res >>> 1; - } -} diff --git a/common/src/main/java/io/netty/util/internal/jzlib/ZStream.java b/common/src/main/java/io/netty/util/internal/jzlib/ZStream.java deleted file mode 100644 index 9f6f2c2e7d..0000000000 --- a/common/src/main/java/io/netty/util/internal/jzlib/ZStream.java +++ /dev/null @@ -1,245 +0,0 @@ -/* - * Copyright 2012 The Netty Project - * - * The Netty Project licenses this file to you under the Apache License, - * version 2.0 (the "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - */ -/* -Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the distribution. - - 3. The names of the authors may not be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, -INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, -OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, -EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * This program is based on zlib-1.1.3, so all credit should go authors - * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu) - * and contributors of zlib. - */ -package io.netty.util.internal.jzlib; - -import io.netty.util.internal.InternalLogger; -import io.netty.util.internal.InternalLoggerFactory; -import io.netty.util.internal.jzlib.JZlib.WrapperType; - -public final class ZStream { - - private static final InternalLogger logger = - InternalLoggerFactory.getInstance(ZStream.class); - - public byte[] next_in; // next input byte - public int next_in_index; - public int avail_in; // number of bytes available at next_in - public long total_in; // total nb of input bytes read so far - public byte[] next_out; // next output byte should be put there - public int next_out_index; - public int avail_out; // remaining free space at next_out - public long total_out; // total nb of bytes output so far - public String msg; - Deflate dstate; - Inflate istate; - long adler; - int crc32; - - public int inflateInit() { - return inflateInit(JZlib.DEF_WBITS); - } - - public int inflateInit(Enum wrapperType) { - return inflateInit(JZlib.DEF_WBITS, wrapperType); - } - - public int inflateInit(int w) { - return inflateInit(w, WrapperType.ZLIB); - } - - public int inflateInit(int w, @SuppressWarnings("rawtypes") Enum wrapperType) { - istate = new Inflate(); - return istate.inflateInit(this, w, (WrapperType) wrapperType); - } - - public int inflate(int f) { - if (istate == null) { - return JZlib.Z_STREAM_ERROR; - } - return istate.inflate(this, f); - } - - public int inflateEnd() { - if (istate == null) { - return JZlib.Z_STREAM_ERROR; - } - int ret = istate.inflateEnd(this); - istate = null; - return ret; - } - - public int inflateSync() { - if (istate == null) { - return JZlib.Z_STREAM_ERROR; - } - return istate.inflateSync(this); - } - - public int inflateSetDictionary(byte[] dictionary, int dictLength) { - if (istate == null) { - return JZlib.Z_STREAM_ERROR; - } - return Inflate.inflateSetDictionary(this, dictionary, dictLength); - } - - public int deflateInit(int level) { - return deflateInit(level, JZlib.MAX_WBITS); - } - - public int deflateInit(int level, Enum wrapperType) { - return deflateInit(level, JZlib.MAX_WBITS, wrapperType); - } - - public int deflateInit(int level, int bits) { - return deflateInit(level, bits, WrapperType.ZLIB); - } - - public int deflateInit(int level, int bits, Enum wrapperType) { - return deflateInit(level, bits, JZlib.DEF_MEM_LEVEL, wrapperType); - } - - public int deflateInit(int level, int bits, int memLevel, @SuppressWarnings("rawtypes") Enum wrapperType) { - dstate = new Deflate(); - return dstate.deflateInit(this, level, bits, memLevel, (WrapperType) wrapperType); - } - - public int deflate(int flush) { - if (dstate == null) { - return JZlib.Z_STREAM_ERROR; - } - return dstate.deflate(this, flush); - } - - public int deflateEnd() { - if (dstate == null) { - return JZlib.Z_STREAM_ERROR; - } - int ret = dstate.deflateEnd(); - dstate = null; - return ret; - } - - public int deflateParams(int level, int strategy) { - if (dstate == null) { - return JZlib.Z_STREAM_ERROR; - } - return dstate.deflateParams(this, level, strategy); - } - - public int deflateSetDictionary(byte[] dictionary, int dictLength) { - if (dstate == null) { - return JZlib.Z_STREAM_ERROR; - } - return dstate.deflateSetDictionary(this, dictionary, dictLength); - } - - // Flush as much pending output as possible. All deflate() output goes - // through this function so some applications may wish to modify it - // to avoid allocating a large strm->next_out buffer and copying into it. - // (See also read_buf()). - void flush_pending() { - int len = dstate.pending; - - if (len > avail_out) { - len = avail_out; - } - if (len == 0) { - return; - } - - if (dstate.pending_buf.length <= dstate.pending_out || - next_out.length <= next_out_index || - dstate.pending_buf.length < dstate.pending_out + len || - next_out.length < next_out_index + len) { - logger.debug(dstate.pending_buf.length + ", " + - dstate.pending_out + ", " + next_out.length + ", " + - next_out_index + ", " + len); - logger.debug("avail_out=" + avail_out); - } - - System.arraycopy(dstate.pending_buf, dstate.pending_out, next_out, - next_out_index, len); - - next_out_index += len; - dstate.pending_out += len; - total_out += len; - avail_out -= len; - dstate.pending -= len; - if (dstate.pending == 0) { - dstate.pending_out = 0; - } - } - - // Read a new buffer from the current input stream, update the adler32 - // and total number of bytes read. All deflate() input goes through - // this function so some applications may wish to modify it to avoid - // allocating a large strm->next_in buffer and copying from it. - // (See also flush_pending()). - int read_buf(byte[] buf, int start, int size) { - int len = avail_in; - - if (len > size) { - len = size; - } - if (len == 0) { - return 0; - } - - avail_in -= len; - - switch (dstate.wrapperType) { - case ZLIB: - adler = Adler32.adler32(adler, next_in, next_in_index, len); - break; - case GZIP: - crc32 = CRC32.crc32(crc32, next_in, next_in_index, len); - break; - } - - System.arraycopy(next_in, next_in_index, buf, start, len); - next_in_index += len; - total_in += len; - return len; - } - - public void free() { - next_in = null; - next_out = null; - msg = null; - } -} diff --git a/common/src/main/java/io/netty/util/internal/jzlib/package-info.java b/common/src/main/java/io/netty/util/internal/jzlib/package-info.java deleted file mode 100644 index 23706a529c..0000000000 --- a/common/src/main/java/io/netty/util/internal/jzlib/package-info.java +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright 2012 The Netty Project - * - * The Netty Project licenses this file to you under the Apache License, - * version 2.0 (the "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - */ - -/** - * Internal-use-only utilities which is not allowed to be used - * outside Netty. - */ -package io.netty.util.internal.jzlib; diff --git a/pom.xml b/pom.xml index fcf361d42a..09a5343b9e 100644 --- a/pom.xml +++ b/pom.xml @@ -108,6 +108,12 @@ protobuf-java 2.4.1 + + com.jcraft + jzlib + true + 1.1.2 + org.rxtx