| /* |
| * Copyright (c) 1996, 2018, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package java.util.zip; |
| |
| import java.lang.ref.Cleaner.Cleanable; |
| import java.lang.ref.Reference; |
| import java.nio.ByteBuffer; |
| import java.nio.ReadOnlyBufferException; |
| import java.util.Objects; |
| |
| import jdk.internal.ref.CleanerFactory; |
| import sun.nio.ch.DirectBuffer; |
| |
| /** |
| * This class provides support for general purpose compression using the |
| * popular ZLIB compression library. The ZLIB compression library was |
| * initially developed as part of the PNG graphics standard and is not |
| * protected by patents. It is fully described in the specifications at |
| * the <a href="package-summary.html#package.description">java.util.zip |
| * package description</a>. |
| * <p> |
| * This class deflates sequences of bytes into ZLIB compressed data format. |
| * The input byte sequence is provided in either byte array or byte buffer, |
| * via one of the {@code setInput()} methods. The output byte sequence is |
| * written to the output byte array or byte buffer passed to the |
| * {@code deflate()} methods. |
| * <p> |
| * The following code fragment demonstrates a trivial compression |
| * and decompression of a string using {@code Deflater} and |
| * {@code Inflater}. |
| * |
| * <blockquote><pre> |
| * try { |
| * // Encode a String into bytes |
| * String inputString = "blahblahblah"; |
| * byte[] input = inputString.getBytes("UTF-8"); |
| * |
| * // Compress the bytes |
| * byte[] output = new byte[100]; |
| * Deflater compresser = new Deflater(); |
| * compresser.setInput(input); |
| * compresser.finish(); |
| * int compressedDataLength = compresser.deflate(output); |
| * compresser.end(); |
| * |
| * // Decompress the bytes |
| * Inflater decompresser = new Inflater(); |
| * decompresser.setInput(output, 0, compressedDataLength); |
| * byte[] result = new byte[100]; |
| * int resultLength = decompresser.inflate(result); |
| * decompresser.end(); |
| * |
| * // Decode the bytes into a String |
| * String outputString = new String(result, 0, resultLength, "UTF-8"); |
| * } catch (java.io.UnsupportedEncodingException ex) { |
| * // handle |
| * } catch (java.util.zip.DataFormatException ex) { |
| * // handle |
| * } |
| * </pre></blockquote> |
| * |
| * @apiNote |
| * To release resources used by this {@code Deflater}, the {@link #end()} method |
| * should be called explicitly. Subclasses are responsible for the cleanup of resources |
| * acquired by the subclass. Subclasses that override {@link #finalize()} in order |
| * to perform cleanup should be modified to use alternative cleanup mechanisms such |
| * as {@link java.lang.ref.Cleaner} and remove the overriding {@code finalize} method. |
| * |
| * @implSpec |
| * If this {@code Deflater} has been subclassed and the {@code end} method has been |
| * overridden, the {@code end} method will be called by the finalization when the |
| * deflater is unreachable. But the subclasses should not depend on this specific |
| * implementation; the finalization is not reliable and the {@code finalize} method |
| * is deprecated to be removed. |
| * |
| * @see Inflater |
| * @author David Connelly |
| * @since 1.1 |
| */ |
| |
| public class Deflater { |
| |
| private final DeflaterZStreamRef zsRef; |
| private ByteBuffer input = ZipUtils.defaultBuf; |
| private byte[] inputArray; |
| private int inputPos, inputLim; |
| private int level, strategy; |
| private boolean setParams; |
| private boolean finish, finished; |
| private long bytesRead; |
| private long bytesWritten; |
| |
| /** |
| * Compression method for the deflate algorithm (the only one currently |
| * supported). |
| */ |
| public static final int DEFLATED = 8; |
| |
| /** |
| * Compression level for no compression. |
| */ |
| public static final int NO_COMPRESSION = 0; |
| |
| /** |
| * Compression level for fastest compression. |
| */ |
| public static final int BEST_SPEED = 1; |
| |
| /** |
| * Compression level for best compression. |
| */ |
| public static final int BEST_COMPRESSION = 9; |
| |
| /** |
| * Default compression level. |
| */ |
| public static final int DEFAULT_COMPRESSION = -1; |
| |
| /** |
| * Compression strategy best used for data consisting mostly of small |
| * values with a somewhat random distribution. Forces more Huffman coding |
| * and less string matching. |
| */ |
| public static final int FILTERED = 1; |
| |
| /** |
| * Compression strategy for Huffman coding only. |
| */ |
| public static final int HUFFMAN_ONLY = 2; |
| |
| /** |
| * Default compression strategy. |
| */ |
| public static final int DEFAULT_STRATEGY = 0; |
| |
| /** |
| * Compression flush mode used to achieve best compression result. |
| * |
| * @see Deflater#deflate(byte[], int, int, int) |
| * @since 1.7 |
| */ |
| public static final int NO_FLUSH = 0; |
| |
| /** |
| * Compression flush mode used to flush out all pending output; may |
| * degrade compression for some compression algorithms. |
| * |
| * @see Deflater#deflate(byte[], int, int, int) |
| * @since 1.7 |
| */ |
| public static final int SYNC_FLUSH = 2; |
| |
| /** |
| * Compression flush mode used to flush out all pending output and |
| * reset the deflater. Using this mode too often can seriously degrade |
| * compression. |
| * |
| * @see Deflater#deflate(byte[], int, int, int) |
| * @since 1.7 |
| */ |
| public static final int FULL_FLUSH = 3; |
| |
| /** |
| * Flush mode to use at the end of output. Can only be provided by the |
| * user by way of {@link #finish()}. |
| */ |
| private static final int FINISH = 4; |
| |
| static { |
| ZipUtils.loadLibrary(); |
| } |
| |
| /** |
| * Creates a new compressor using the specified compression level. |
| * If 'nowrap' is true then the ZLIB header and checksum fields will |
| * not be used in order to support the compression format used in |
| * both GZIP and PKZIP. |
| * @param level the compression level (0-9) |
| * @param nowrap if true then use GZIP compatible compression |
| */ |
| public Deflater(int level, boolean nowrap) { |
| this.level = level; |
| this.strategy = DEFAULT_STRATEGY; |
| this.zsRef = DeflaterZStreamRef.get(this, |
| init(level, DEFAULT_STRATEGY, nowrap)); |
| } |
| |
| /** |
| * Creates a new compressor using the specified compression level. |
| * Compressed data will be generated in ZLIB format. |
| * @param level the compression level (0-9) |
| */ |
| public Deflater(int level) { |
| this(level, false); |
| } |
| |
| /** |
| * Creates a new compressor with the default compression level. |
| * Compressed data will be generated in ZLIB format. |
| */ |
| public Deflater() { |
| this(DEFAULT_COMPRESSION, false); |
| } |
| |
| /** |
| * Sets input data for compression. |
| * <p> |
| * One of the {@code setInput()} methods should be called whenever |
| * {@code needsInput()} returns true indicating that more input data |
| * is required. |
| * <p> |
| * @param input the input data bytes |
| * @param off the start offset of the data |
| * @param len the length of the data |
| * @see Deflater#needsInput |
| */ |
| public void setInput(byte[] input, int off, int len) { |
| if (off < 0 || len < 0 || off > input.length - len) { |
| throw new ArrayIndexOutOfBoundsException(); |
| } |
| synchronized (zsRef) { |
| this.input = null; |
| this.inputArray = input; |
| this.inputPos = off; |
| this.inputLim = off + len; |
| } |
| } |
| |
| /** |
| * Sets input data for compression. |
| * <p> |
| * One of the {@code setInput()} methods should be called whenever |
| * {@code needsInput()} returns true indicating that more input data |
| * is required. |
| * <p> |
| * @param input the input data bytes |
| * @see Deflater#needsInput |
| */ |
| public void setInput(byte[] input) { |
| setInput(input, 0, input.length); |
| } |
| |
| /** |
| * Sets input data for compression. |
| * <p> |
| * One of the {@code setInput()} methods should be called whenever |
| * {@code needsInput()} returns true indicating that more input data |
| * is required. |
| * <p> |
| * The given buffer's position will be advanced as deflate |
| * operations are performed, up to the buffer's limit. |
| * The input buffer may be modified (refilled) between deflate |
| * operations; doing so is equivalent to creating a new buffer |
| * and setting it with this method. |
| * <p> |
| * Modifying the input buffer's contents, position, or limit |
| * concurrently with an deflate operation will result in |
| * undefined behavior, which may include incorrect operation |
| * results or operation failure. |
| * |
| * @param input the input data bytes |
| * @see Deflater#needsInput |
| * @since 11 |
| */ |
| public void setInput(ByteBuffer input) { |
| Objects.requireNonNull(input); |
| synchronized (zsRef) { |
| this.input = input; |
| this.inputArray = null; |
| } |
| } |
| |
| /** |
| * Sets preset dictionary for compression. A preset dictionary is used |
| * when the history buffer can be predetermined. When the data is later |
| * uncompressed with Inflater.inflate(), Inflater.getAdler() can be called |
| * in order to get the Adler-32 value of the dictionary required for |
| * decompression. |
| * @param dictionary the dictionary data bytes |
| * @param off the start offset of the data |
| * @param len the length of the data |
| * @see Inflater#inflate |
| * @see Inflater#getAdler |
| */ |
| public void setDictionary(byte[] dictionary, int off, int len) { |
| if (off < 0 || len < 0 || off > dictionary.length - len) { |
| throw new ArrayIndexOutOfBoundsException(); |
| } |
| synchronized (zsRef) { |
| ensureOpen(); |
| setDictionary(zsRef.address(), dictionary, off, len); |
| } |
| } |
| |
| /** |
| * Sets preset dictionary for compression. A preset dictionary is used |
| * when the history buffer can be predetermined. When the data is later |
| * uncompressed with Inflater.inflate(), Inflater.getAdler() can be called |
| * in order to get the Adler-32 value of the dictionary required for |
| * decompression. |
| * @param dictionary the dictionary data bytes |
| * @see Inflater#inflate |
| * @see Inflater#getAdler |
| */ |
| public void setDictionary(byte[] dictionary) { |
| setDictionary(dictionary, 0, dictionary.length); |
| } |
| |
| /** |
| * Sets preset dictionary for compression. A preset dictionary is used |
| * when the history buffer can be predetermined. When the data is later |
| * uncompressed with Inflater.inflate(), Inflater.getAdler() can be called |
| * in order to get the Adler-32 value of the dictionary required for |
| * decompression. |
| * <p> |
| * The bytes in given byte buffer will be fully consumed by this method. On |
| * return, its position will equal its limit. |
| * |
| * @param dictionary the dictionary data bytes |
| * @see Inflater#inflate |
| * @see Inflater#getAdler |
| */ |
| public void setDictionary(ByteBuffer dictionary) { |
| synchronized (zsRef) { |
| int position = dictionary.position(); |
| int remaining = Math.max(dictionary.limit() - position, 0); |
| ensureOpen(); |
| if (dictionary.isDirect()) { |
| long address = ((DirectBuffer) dictionary).address(); |
| try { |
| setDictionaryBuffer(zsRef.address(), address + position, remaining); |
| } finally { |
| Reference.reachabilityFence(dictionary); |
| } |
| } else { |
| byte[] array = ZipUtils.getBufferArray(dictionary); |
| int offset = ZipUtils.getBufferOffset(dictionary); |
| setDictionary(zsRef.address(), array, offset + position, remaining); |
| } |
| dictionary.position(position + remaining); |
| } |
| } |
| |
| /** |
| * Sets the compression strategy to the specified value. |
| * |
| * <p> If the compression strategy is changed, the next invocation |
| * of {@code deflate} will compress the input available so far with |
| * the old strategy (and may be flushed); the new strategy will take |
| * effect only after that invocation. |
| * |
| * @param strategy the new compression strategy |
| * @exception IllegalArgumentException if the compression strategy is |
| * invalid |
| */ |
| public void setStrategy(int strategy) { |
| switch (strategy) { |
| case DEFAULT_STRATEGY: |
| case FILTERED: |
| case HUFFMAN_ONLY: |
| break; |
| default: |
| throw new IllegalArgumentException(); |
| } |
| synchronized (zsRef) { |
| if (this.strategy != strategy) { |
| this.strategy = strategy; |
| setParams = true; |
| } |
| } |
| } |
| |
| /** |
| * Sets the compression level to the specified value. |
| * |
| * <p> If the compression level is changed, the next invocation |
| * of {@code deflate} will compress the input available so far |
| * with the old level (and may be flushed); the new level will |
| * take effect only after that invocation. |
| * |
| * @param level the new compression level (0-9) |
| * @exception IllegalArgumentException if the compression level is invalid |
| */ |
| public void setLevel(int level) { |
| if ((level < 0 || level > 9) && level != DEFAULT_COMPRESSION) { |
| throw new IllegalArgumentException("invalid compression level"); |
| } |
| synchronized (zsRef) { |
| if (this.level != level) { |
| this.level = level; |
| setParams = true; |
| } |
| } |
| } |
| |
| /** |
| * Returns true if no data remains in the input buffer. This can |
| * be used to determine if one of the {@code setInput()} methods should be |
| * called in order to provide more input. |
| * |
| * @return true if the input data buffer is empty and setInput() |
| * should be called in order to provide more input |
| */ |
| public boolean needsInput() { |
| synchronized (zsRef) { |
| ByteBuffer input = this.input; |
| return input == null ? inputLim == inputPos : ! input.hasRemaining(); |
| } |
| } |
| |
| /** |
| * When called, indicates that compression should end with the current |
| * contents of the input buffer. |
| */ |
| public void finish() { |
| synchronized (zsRef) { |
| finish = true; |
| } |
| } |
| |
| /** |
| * Returns true if the end of the compressed data output stream has |
| * been reached. |
| * @return true if the end of the compressed data output stream has |
| * been reached |
| */ |
| public boolean finished() { |
| synchronized (zsRef) { |
| return finished; |
| } |
| } |
| |
| /** |
| * Compresses the input data and fills specified buffer with compressed |
| * data. Returns actual number of bytes of compressed data. A return value |
| * of 0 indicates that {@link #needsInput() needsInput} should be called |
| * in order to determine if more input data is required. |
| * |
| * <p>This method uses {@link #NO_FLUSH} as its compression flush mode. |
| * An invocation of this method of the form {@code deflater.deflate(b, off, len)} |
| * yields the same result as the invocation of |
| * {@code deflater.deflate(b, off, len, Deflater.NO_FLUSH)}. |
| * |
| * @param output the buffer for the compressed data |
| * @param off the start offset of the data |
| * @param len the maximum number of bytes of compressed data |
| * @return the actual number of bytes of compressed data written to the |
| * output buffer |
| */ |
| public int deflate(byte[] output, int off, int len) { |
| return deflate(output, off, len, NO_FLUSH); |
| } |
| |
| /** |
| * Compresses the input data and fills specified buffer with compressed |
| * data. Returns actual number of bytes of compressed data. A return value |
| * of 0 indicates that {@link #needsInput() needsInput} should be called |
| * in order to determine if more input data is required. |
| * |
| * <p>This method uses {@link #NO_FLUSH} as its compression flush mode. |
| * An invocation of this method of the form {@code deflater.deflate(b)} |
| * yields the same result as the invocation of |
| * {@code deflater.deflate(b, 0, b.length, Deflater.NO_FLUSH)}. |
| * |
| * @param output the buffer for the compressed data |
| * @return the actual number of bytes of compressed data written to the |
| * output buffer |
| */ |
| public int deflate(byte[] output) { |
| return deflate(output, 0, output.length, NO_FLUSH); |
| } |
| |
| /** |
| * Compresses the input data and fills specified buffer with compressed |
| * data. Returns actual number of bytes of compressed data. A return value |
| * of 0 indicates that {@link #needsInput() needsInput} should be called |
| * in order to determine if more input data is required. |
| * |
| * <p>This method uses {@link #NO_FLUSH} as its compression flush mode. |
| * An invocation of this method of the form {@code deflater.deflate(output)} |
| * yields the same result as the invocation of |
| * {@code deflater.deflate(output, Deflater.NO_FLUSH)}. |
| * |
| * @param output the buffer for the compressed data |
| * @return the actual number of bytes of compressed data written to the |
| * output buffer |
| * @since 11 |
| */ |
| public int deflate(ByteBuffer output) { |
| return deflate(output, NO_FLUSH); |
| } |
| |
| /** |
| * Compresses the input data and fills the specified buffer with compressed |
| * data. Returns actual number of bytes of data compressed. |
| * |
| * <p>Compression flush mode is one of the following three modes: |
| * |
| * <ul> |
| * <li>{@link #NO_FLUSH}: allows the deflater to decide how much data |
| * to accumulate, before producing output, in order to achieve the best |
| * compression (should be used in normal use scenario). A return value |
| * of 0 in this flush mode indicates that {@link #needsInput()} should |
| * be called in order to determine if more input data is required. |
| * |
| * <li>{@link #SYNC_FLUSH}: all pending output in the deflater is flushed, |
| * to the specified output buffer, so that an inflater that works on |
| * compressed data can get all input data available so far (In particular |
| * the {@link #needsInput()} returns {@code true} after this invocation |
| * if enough output space is provided). Flushing with {@link #SYNC_FLUSH} |
| * may degrade compression for some compression algorithms and so it |
| * should be used only when necessary. |
| * |
| * <li>{@link #FULL_FLUSH}: all pending output is flushed out as with |
| * {@link #SYNC_FLUSH}. The compression state is reset so that the inflater |
| * that works on the compressed output data can restart from this point |
| * if previous compressed data has been damaged or if random access is |
| * desired. Using {@link #FULL_FLUSH} too often can seriously degrade |
| * compression. |
| * </ul> |
| * |
| * <p>In the case of {@link #FULL_FLUSH} or {@link #SYNC_FLUSH}, if |
| * the return value is {@code len}, the space available in output |
| * buffer {@code b}, this method should be invoked again with the same |
| * {@code flush} parameter and more output space. Make sure that |
| * {@code len} is greater than 6 to avoid flush marker (5 bytes) being |
| * repeatedly output to the output buffer every time this method is |
| * invoked. |
| * |
| * <p>If the {@link #setInput(ByteBuffer)} method was called to provide a buffer |
| * for input, the input buffer's position will be advanced by the number of bytes |
| * consumed by this operation. |
| * |
| * @param output the buffer for the compressed data |
| * @param off the start offset of the data |
| * @param len the maximum number of bytes of compressed data |
| * @param flush the compression flush mode |
| * @return the actual number of bytes of compressed data written to |
| * the output buffer |
| * |
| * @throws IllegalArgumentException if the flush mode is invalid |
| * @since 1.7 |
| */ |
| public int deflate(byte[] output, int off, int len, int flush) { |
| if (off < 0 || len < 0 || off > output.length - len) { |
| throw new ArrayIndexOutOfBoundsException(); |
| } |
| if (flush != NO_FLUSH && flush != SYNC_FLUSH && flush != FULL_FLUSH) { |
| throw new IllegalArgumentException(); |
| } |
| synchronized (zsRef) { |
| ensureOpen(); |
| |
| ByteBuffer input = this.input; |
| if (finish) { |
| // disregard given flush mode in this case |
| flush = FINISH; |
| } |
| int params; |
| if (setParams) { |
| // bit 0: true to set params |
| // bit 1-2: strategy (0, 1, or 2) |
| // bit 3-31: level (0..9 or -1) |
| params = 1 | strategy << 1 | level << 3; |
| } else { |
| params = 0; |
| } |
| int inputPos; |
| long result; |
| if (input == null) { |
| inputPos = this.inputPos; |
| result = deflateBytesBytes(zsRef.address(), |
| inputArray, inputPos, inputLim - inputPos, |
| output, off, len, |
| flush, params); |
| } else { |
| inputPos = input.position(); |
| int inputRem = Math.max(input.limit() - inputPos, 0); |
| if (input.isDirect()) { |
| try { |
| long inputAddress = ((DirectBuffer) input).address(); |
| result = deflateBufferBytes(zsRef.address(), |
| inputAddress + inputPos, inputRem, |
| output, off, len, |
| flush, params); |
| } finally { |
| Reference.reachabilityFence(input); |
| } |
| } else { |
| byte[] inputArray = ZipUtils.getBufferArray(input); |
| int inputOffset = ZipUtils.getBufferOffset(input); |
| result = deflateBytesBytes(zsRef.address(), |
| inputArray, inputOffset + inputPos, inputRem, |
| output, off, len, |
| flush, params); |
| } |
| } |
| int read = (int) (result & 0x7fff_ffffL); |
| int written = (int) (result >>> 31 & 0x7fff_ffffL); |
| if ((result >>> 62 & 1) != 0) { |
| finished = true; |
| } |
| if (params != 0 && (result >>> 63 & 1) == 0) { |
| setParams = false; |
| } |
| if (input != null) { |
| input.position(inputPos + read); |
| } else { |
| this.inputPos = inputPos + read; |
| } |
| bytesWritten += written; |
| bytesRead += read; |
| return written; |
| } |
| } |
| |
| /** |
| * Compresses the input data and fills the specified buffer with compressed |
| * data. Returns actual number of bytes of data compressed. |
| * |
| * <p>Compression flush mode is one of the following three modes: |
| * |
| * <ul> |
| * <li>{@link #NO_FLUSH}: allows the deflater to decide how much data |
| * to accumulate, before producing output, in order to achieve the best |
| * compression (should be used in normal use scenario). A return value |
| * of 0 in this flush mode indicates that {@link #needsInput()} should |
| * be called in order to determine if more input data is required. |
| * |
| * <li>{@link #SYNC_FLUSH}: all pending output in the deflater is flushed, |
| * to the specified output buffer, so that an inflater that works on |
| * compressed data can get all input data available so far (In particular |
| * the {@link #needsInput()} returns {@code true} after this invocation |
| * if enough output space is provided). Flushing with {@link #SYNC_FLUSH} |
| * may degrade compression for some compression algorithms and so it |
| * should be used only when necessary. |
| * |
| * <li>{@link #FULL_FLUSH}: all pending output is flushed out as with |
| * {@link #SYNC_FLUSH}. The compression state is reset so that the inflater |
| * that works on the compressed output data can restart from this point |
| * if previous compressed data has been damaged or if random access is |
| * desired. Using {@link #FULL_FLUSH} too often can seriously degrade |
| * compression. |
| * </ul> |
| * |
| * <p>In the case of {@link #FULL_FLUSH} or {@link #SYNC_FLUSH}, if |
| * the return value is equal to the {@linkplain ByteBuffer#remaining() remaining space} |
| * of the buffer, this method should be invoked again with the same |
| * {@code flush} parameter and more output space. Make sure that |
| * the buffer has at least 6 bytes of remaining space to avoid the |
| * flush marker (5 bytes) being repeatedly output to the output buffer |
| * every time this method is invoked. |
| * |
| * <p>On success, the position of the given {@code output} byte buffer will be |
| * advanced by as many bytes as were produced by the operation, which is equal |
| * to the number returned by this method. |
| * |
| * <p>If the {@link #setInput(ByteBuffer)} method was called to provide a buffer |
| * for input, the input buffer's position will be advanced by the number of bytes |
| * consumed by this operation. |
| * |
| * @param output the buffer for the compressed data |
| * @param flush the compression flush mode |
| * @return the actual number of bytes of compressed data written to |
| * the output buffer |
| * |
| * @throws IllegalArgumentException if the flush mode is invalid |
| * @since 11 |
| */ |
| public int deflate(ByteBuffer output, int flush) { |
| if (output.isReadOnly()) { |
| throw new ReadOnlyBufferException(); |
| } |
| if (flush != NO_FLUSH && flush != SYNC_FLUSH && flush != FULL_FLUSH) { |
| throw new IllegalArgumentException(); |
| } |
| synchronized (zsRef) { |
| ensureOpen(); |
| |
| ByteBuffer input = this.input; |
| if (finish) { |
| // disregard given flush mode in this case |
| flush = FINISH; |
| } |
| int params; |
| if (setParams) { |
| // bit 0: true to set params |
| // bit 1-2: strategy (0, 1, or 2) |
| // bit 3-31: level (0..9 or -1) |
| params = 1 | strategy << 1 | level << 3; |
| } else { |
| params = 0; |
| } |
| int outputPos = output.position(); |
| int outputRem = Math.max(output.limit() - outputPos, 0); |
| int inputPos; |
| long result; |
| if (input == null) { |
| inputPos = this.inputPos; |
| if (output.isDirect()) { |
| long outputAddress = ((DirectBuffer) output).address(); |
| try { |
| result = deflateBytesBuffer(zsRef.address(), |
| inputArray, inputPos, inputLim - inputPos, |
| outputAddress + outputPos, outputRem, |
| flush, params); |
| } finally { |
| Reference.reachabilityFence(output); |
| } |
| } else { |
| byte[] outputArray = ZipUtils.getBufferArray(output); |
| int outputOffset = ZipUtils.getBufferOffset(output); |
| result = deflateBytesBytes(zsRef.address(), |
| inputArray, inputPos, inputLim - inputPos, |
| outputArray, outputOffset + outputPos, outputRem, |
| flush, params); |
| } |
| } else { |
| inputPos = input.position(); |
| int inputRem = Math.max(input.limit() - inputPos, 0); |
| if (input.isDirect()) { |
| long inputAddress = ((DirectBuffer) input).address(); |
| try { |
| if (output.isDirect()) { |
| long outputAddress = outputPos + ((DirectBuffer) output).address(); |
| try { |
| result = deflateBufferBuffer(zsRef.address(), |
| inputAddress + inputPos, inputRem, |
| outputAddress, outputRem, |
| flush, params); |
| } finally { |
| Reference.reachabilityFence(output); |
| } |
| } else { |
| byte[] outputArray = ZipUtils.getBufferArray(output); |
| int outputOffset = ZipUtils.getBufferOffset(output); |
| result = deflateBufferBytes(zsRef.address(), |
| inputAddress + inputPos, inputRem, |
| outputArray, outputOffset + outputPos, outputRem, |
| flush, params); |
| } |
| } finally { |
| Reference.reachabilityFence(input); |
| } |
| } else { |
| byte[] inputArray = ZipUtils.getBufferArray(input); |
| int inputOffset = ZipUtils.getBufferOffset(input); |
| if (output.isDirect()) { |
| long outputAddress = ((DirectBuffer) output).address(); |
| try { |
| result = deflateBytesBuffer(zsRef.address(), |
| inputArray, inputOffset + inputPos, inputRem, |
| outputAddress + outputPos, outputRem, |
| flush, params); |
| } finally { |
| Reference.reachabilityFence(output); |
| } |
| } else { |
| byte[] outputArray = ZipUtils.getBufferArray(output); |
| int outputOffset = ZipUtils.getBufferOffset(output); |
| result = deflateBytesBytes(zsRef.address(), |
| inputArray, inputOffset + inputPos, inputRem, |
| outputArray, outputOffset + outputPos, outputRem, |
| flush, params); |
| } |
| } |
| } |
| int read = (int) (result & 0x7fff_ffffL); |
| int written = (int) (result >>> 31 & 0x7fff_ffffL); |
| if ((result >>> 62 & 1) != 0) { |
| finished = true; |
| } |
| if (params != 0 && (result >>> 63 & 1) == 0) { |
| setParams = false; |
| } |
| if (input != null) { |
| input.position(inputPos + read); |
| } else { |
| this.inputPos = inputPos + read; |
| } |
| output.position(outputPos + written); |
| bytesWritten += written; |
| bytesRead += read; |
| return written; |
| } |
| } |
| |
| /** |
| * Returns the ADLER-32 value of the uncompressed data. |
| * @return the ADLER-32 value of the uncompressed data |
| */ |
| public int getAdler() { |
| synchronized (zsRef) { |
| ensureOpen(); |
| return getAdler(zsRef.address()); |
| } |
| } |
| |
| /** |
| * Returns the total number of uncompressed bytes input so far. |
| * |
| * <p>Since the number of bytes may be greater than |
| * Integer.MAX_VALUE, the {@link #getBytesRead()} method is now |
| * the preferred means of obtaining this information.</p> |
| * |
| * @return the total number of uncompressed bytes input so far |
| */ |
| public int getTotalIn() { |
| return (int) getBytesRead(); |
| } |
| |
| /** |
| * Returns the total number of uncompressed bytes input so far. |
| * |
| * @return the total (non-negative) number of uncompressed bytes input so far |
| * @since 1.5 |
| */ |
| public long getBytesRead() { |
| synchronized (zsRef) { |
| ensureOpen(); |
| return bytesRead; |
| } |
| } |
| |
| /** |
| * Returns the total number of compressed bytes output so far. |
| * |
| * <p>Since the number of bytes may be greater than |
| * Integer.MAX_VALUE, the {@link #getBytesWritten()} method is now |
| * the preferred means of obtaining this information.</p> |
| * |
| * @return the total number of compressed bytes output so far |
| */ |
| public int getTotalOut() { |
| return (int) getBytesWritten(); |
| } |
| |
| /** |
| * Returns the total number of compressed bytes output so far. |
| * |
| * @return the total (non-negative) number of compressed bytes output so far |
| * @since 1.5 |
| */ |
| public long getBytesWritten() { |
| synchronized (zsRef) { |
| ensureOpen(); |
| return bytesWritten; |
| } |
| } |
| |
| /** |
| * Resets deflater so that a new set of input data can be processed. |
| * Keeps current compression level and strategy settings. |
| */ |
| public void reset() { |
| synchronized (zsRef) { |
| ensureOpen(); |
| reset(zsRef.address()); |
| finish = false; |
| finished = false; |
| input = ZipUtils.defaultBuf; |
| inputArray = null; |
| bytesRead = bytesWritten = 0; |
| } |
| } |
| |
| /** |
| * Closes the compressor and discards any unprocessed input. |
| * |
| * This method should be called when the compressor is no longer |
| * being used. Once this method is called, the behavior of the |
| * Deflater object is undefined. |
| */ |
| public void end() { |
| synchronized (zsRef) { |
| zsRef.clean(); |
| input = ZipUtils.defaultBuf; |
| } |
| } |
| |
| /** |
| * Closes the compressor when garbage is collected. |
| * |
| * @deprecated The {@code finalize} method has been deprecated and will be |
| * removed. It is implemented as a no-op. Subclasses that override |
| * {@code finalize} in order to perform cleanup should be modified to use |
| * alternative cleanup mechanisms and to remove the overriding {@code finalize} |
| * method. The recommended cleanup for compressor is to explicitly call |
| * {@code end} method when it is no longer in use. If the {@code end} is |
| * not invoked explicitly the resource of the compressor will be released |
| * when the instance becomes unreachable. |
| */ |
| @Deprecated(since="9", forRemoval=true) |
| protected void finalize() {} |
| |
| private void ensureOpen() { |
| assert Thread.holdsLock(zsRef); |
| if (zsRef.address() == 0) |
| throw new NullPointerException("Deflater has been closed"); |
| } |
| |
| private static native long init(int level, int strategy, boolean nowrap); |
| private static native void setDictionary(long addr, byte[] b, int off, |
| int len); |
| private static native void setDictionaryBuffer(long addr, long bufAddress, int len); |
| private native long deflateBytesBytes(long addr, |
| byte[] inputArray, int inputOff, int inputLen, |
| byte[] outputArray, int outputOff, int outputLen, |
| int flush, int params); |
| private native long deflateBytesBuffer(long addr, |
| byte[] inputArray, int inputOff, int inputLen, |
| long outputAddress, int outputLen, |
| int flush, int params); |
| private native long deflateBufferBytes(long addr, |
| long inputAddress, int inputLen, |
| byte[] outputArray, int outputOff, int outputLen, |
| int flush, int params); |
| private native long deflateBufferBuffer(long addr, |
| long inputAddress, int inputLen, |
| long outputAddress, int outputLen, |
| int flush, int params); |
| private static native int getAdler(long addr); |
| private static native void reset(long addr); |
| private static native void end(long addr); |
| |
| /** |
| * A reference to the native zlib's z_stream structure. It also |
| * serves as the "cleaner" to clean up the native resource when |
| * the Deflater is ended, closed or cleaned. |
| */ |
| static class DeflaterZStreamRef implements Runnable { |
| |
| private long address; |
| private final Cleanable cleanable; |
| |
| private DeflaterZStreamRef(Deflater owner, long addr) { |
| this.cleanable = (owner != null) ? CleanerFactory.cleaner().register(owner, this) : null; |
| this.address = addr; |
| } |
| |
| long address() { |
| return address; |
| } |
| |
| void clean() { |
| cleanable.clean(); |
| } |
| |
| public synchronized void run() { |
| long addr = address; |
| address = 0; |
| if (addr != 0) { |
| end(addr); |
| } |
| } |
| |
| /* |
| * If {@code Deflater} has been subclassed and the {@code end} method is |
| * overridden, uses {@code finalizer} mechanism for resource cleanup. So |
| * {@code end} method can be called when the {@code Deflater} is unreachable. |
| * This mechanism will be removed when the {@code finalize} method is |
| * removed from {@code Deflater}. |
| */ |
| static DeflaterZStreamRef get(Deflater owner, long addr) { |
| Class<?> clz = owner.getClass(); |
| while (clz != Deflater.class) { |
| try { |
| clz.getDeclaredMethod("end"); |
| return new FinalizableZStreamRef(owner, addr); |
| } catch (NoSuchMethodException nsme) {} |
| clz = clz.getSuperclass(); |
| } |
| return new DeflaterZStreamRef(owner, addr); |
| } |
| |
| private static class FinalizableZStreamRef extends DeflaterZStreamRef { |
| final Deflater owner; |
| |
| FinalizableZStreamRef (Deflater owner, long addr) { |
| super(null, addr); |
| this.owner = owner; |
| } |
| |
| @Override |
| void clean() { |
| run(); |
| } |
| |
| @Override |
| @SuppressWarnings("deprecation") |
| protected void finalize() { |
| owner.end(); |
| } |
| } |
| } |
| } |