Java Code Examples for java.util.zip.Inflater#needsInput()

@Override
public void decompress(ByteBuffer in, ByteBuffer out) throws IOException {
  Inflater inflater = new Inflater(true);
  inflater.setInput(in.array(), in.arrayOffset() + in.position(),
                    in.remaining());
  while (!(inflater.finished() || inflater.needsDictionary() ||
           inflater.needsInput())) {
    try {
      int count = inflater.inflate(out.array(),
                                   out.arrayOffset() + out.position(),
                                   out.remaining());
      out.position(count + out.position());
    } catch (DataFormatException dfe) {
      throw new IOException("Bad compression data", dfe);
    }
  }
  out.flip();
  inflater.end();
  in.position(in.limit());
}
 

private void readChunkUnzip(Inflater inflater, byte[] buffer, int offset, int length) throws IOException {
    try {
        do {
            int read = inflater.inflate(buffer, offset, length);
            if(read <= 0) {
                if(inflater.finished()) {
                    throw new EOFException();
                }
                if(inflater.needsInput()) {
                    refillInflater(inflater);
                } else {
                    throw new IOException("Can't inflate " + length + " bytes");
                }
            } else {
                offset += read;
                length -= read;
            }
        } while(length > 0);
    } catch (DataFormatException ex) {
        throw (IOException)(new IOException("inflate error").initCause(ex));
    }
}
 

private void readChunkUnzip(Inflater inflater, byte[] buffer, int offset, int length) throws IOException {
	assert (buffer != this.buffer);
	try {
		do {
			int read = inflater.inflate(buffer, offset, length);
			if(read <= 0) {
				if(inflater.finished()) {
					throw new EOFException();
				}
				if(inflater.needsInput()) {
					refillInflater(inflater);
				} else {
					throw new IOException("Can't inflate " + length + " bytes");
				}
			} else {
				offset += read;
				length -= read;
			}
		} while(length > 0);
	} catch(DataFormatException ex) {
		throw (IOException)(new IOException("inflate error").initCause(ex));
	}
}
 

private void readChunkUnzip(Inflater inflater, byte[] buffer, int offset, int length) throws IOException {
    try {
        do {
            int read = inflater.inflate(buffer, offset, length);
            if(read <= 0) {
                if(inflater.finished()) {
                    throw new EOFException();
                }
                if(inflater.needsInput()) {
                    refillInflater(inflater);
                } else {
                    throw new IOException("Can't inflate " + length + " bytes");
                }
            } else {
                offset += read;
                length -= read;
            }
        } while(length > 0);
    } catch (DataFormatException ex) {
        throw (IOException)(new IOException("inflate error").initCause(ex));
    }
}
 

public static DeflaterInflaterData uncompressBytes(byte[] output, int compressedDataLength) throws DataFormatException {
    Inflater decompresser = new Inflater();
    decompresser.setInput(output, 0, compressedDataLength);
    byte[] buffer = new byte[512];
    byte[] result = new byte[0];
    int bytesRead;
    while (!decompresser.needsInput()) {
      bytesRead = decompresser.inflate(buffer);
      byte[] newResult = new byte[result.length + bytesRead];
      System.arraycopy(result, 0, newResult, 0, result.length);
      System.arraycopy(buffer, 0, newResult, result.length, bytesRead);
      result = newResult;
    }
//    System.out.println(new String(result));
    decompresser.end();

    return new DeflaterInflaterData(result.length, result);
  }
 

public static InputStream inflate(byte[] deflatedToken, boolean nowrap)
    throws DataFormatException {
    Inflater inflater = new Inflater(true);
    inflater.setInput(deflatedToken);

    byte[] buffer = new byte[deflatedToken.length];
    int inflateLen;
    ByteArrayOutputStream inflatedToken = new ByteArrayOutputStream();
    while (!inflater.finished()) {
        inflateLen = inflater.inflate(buffer, 0, deflatedToken.length);
        if (inflateLen == 0 && !inflater.finished()) {
            if (inflater.needsInput()) {
                throw new DataFormatException("Inflater can not inflate all the token bytes");
            }
            break;
        }

        inflatedToken.write(buffer, 0, inflateLen);
    }

    return new ByteArrayInputStream(inflatedToken.toByteArray());
}
 

public static DeflaterInflaterData uncompressBytes(byte[] output, int compressedDataLength) throws DataFormatException {
    Inflater decompresser = new Inflater();
    decompresser.setInput(output, 0, compressedDataLength);
    byte[] buffer = new byte[512];
    byte[] result = new byte[0];
    int bytesRead;
    while (!decompresser.needsInput()) {
      bytesRead = decompresser.inflate(buffer);
      byte[] newResult = new byte[result.length + bytesRead];
      System.arraycopy(result, 0, newResult, 0, result.length);
      System.arraycopy(buffer, 0, newResult, result.length, bytesRead);
      result = newResult;
    }
//    System.out.println(new String(result));
    decompresser.end();

    return new DeflaterInflaterData(result.length, result);
  }
 

public static byte[] b(byte abyte0[])
{
    int i = 0;
    if (abyte0 == null || abyte0.length == 0)
    {
        return null;
    }
    Inflater inflater = new Inflater();
    inflater.setInput(abyte0, 0, abyte0.length);
    ByteArrayOutputStream bytearrayoutputstream = new ByteArrayOutputStream();
    byte abyte1[] = new byte[1024];
    do
    {
        if (inflater.needsInput())
        {
            inflater.end();
            return bytearrayoutputstream.toByteArray();
        }
        int j = inflater.inflate(abyte1);
        bytearrayoutputstream.write(abyte1, i, j);
        i += j;
    } while (true);
}
 

public ByteBuffer getData() {
    try {
        byte[] input = new byte[1024];
        byte[] output = new byte[1024];
        FileInputStream fin = new FileInputStream(file);
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        Inflater inflater = new Inflater(true);

        while (true) {
            int numRead = fin.read(input);
            if (numRead != -1) {
                inflater.setInput(input, 0, numRead);
            }

            int numDecompressed;
            while ((numDecompressed = inflater.inflate(output, 0, output.length)) != 0) {
                bos.write(output, 0, numDecompressed);
            }

            if (inflater.finished()) {
                break;
            } else if (inflater.needsInput()) {
                continue;
            }
        }

        inflater.end();
        ByteBuffer result = ByteBuffer.wrap(bos.toByteArray(), 0, bos.size());

        bos.close();
        fin.close();

        return result;
    } catch (Exception e) {
        FileLog.e(e);
    }

    return null;
}
 

public ByteBuffer getData() {
    try {
        byte[] input = new byte[1024];
        byte[] output = new byte[1024];
        FileInputStream fin = new FileInputStream(file);
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        Inflater inflater = new Inflater(true);

        while (true) {
            int numRead = fin.read(input);
            if (numRead != -1) {
                inflater.setInput(input, 0, numRead);
            }

            int numDecompressed;
            while ((numDecompressed = inflater.inflate(output, 0, output.length)) != 0) {
                bos.write(output, 0, numDecompressed);
            }

            if (inflater.finished()) {
                break;
            }
            else if (inflater.needsInput()) {
                continue;
            }
        }

        inflater.end();
        ByteBuffer result = ByteBuffer.wrap(bos.toByteArray(), 0, bos.size());

        bos.close();
        fin.close();

        return result;
    } catch (Exception e) {
        FileLog.e(e);
    }

    return null;
}
 

private void expand(Inflater inflater, byte[] inBuf, int inCount,
        byte[] outBuf) throws DataFormatException {
    int inPosn;
    int outPosn;

    inPosn = outPosn = 0;

    //System.out.println("### starting expand, inCount is " + inCount);

    while (!inflater.finished()) {
        int want = -1, got;

        // only read if the input buffer is empty
        if (inflater.needsInput() && inCount != 0) {
            want = (inCount < LOCAL_BUF_SIZE) ? inCount : LOCAL_BUF_SIZE;

            inflater.setInput(inBuf, inPosn, want);

            inCount -= want;
            inPosn += want;
        }

        // inflate to current position in output buffer
        int compCount;

        compCount = inflater.inflate(outBuf, outPosn, LOCAL_BUF_SIZE);
        outPosn += compCount;

        //System.out.println("Expanded " + want + ", output " + compCount);
    }
}
 

/**
 * java.util.zip.Inflater#Inflater(boolean)
 */
public void test_ConstructorZ() {
    // test method of java.util.zip.inflater.Inflater(boolean)
    // note does not throw exception if deflater has a header, but inflater
    // doesn't or vice versa.
    byte byteArray[] = { 1, 3, 4, 7, 8, 'e', 'r', 't', 'y', '5' };
    Inflater inflate = new Inflater(true);
    assertNotNull("failed to create the instance of inflater", inflate);
    byte outPutInf[] = new byte[500];
    int r = 0;
    try {
        while (!(inflate.finished())) {
            if (inflate.needsInput()) {
                inflate.setInput(outPutBuff1);
            }

            inflate.inflate(outPutInf);
        }
        for (int i = 0; i < byteArray.length; i++) {
            assertEquals("the output array from inflate should contain 0 because the"
                            + " header of inflate and deflate did not match, but this failed",
                    0, outPutBuff1[i]);
        }
    } catch (DataFormatException e) {
        r = 1;
    }
    assertEquals("Error: exception should be thrown because of header inconsistency", 1, r);
    inflate.end();
}
 

public ByteBuffer getData() {
    try {
        byte[] input = new byte[1024];
        byte[] output = new byte[1024];
        FileInputStream fin = new FileInputStream(file);
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        Inflater inflater = new Inflater(true);

        while (true) {
            int numRead = fin.read(input);
            if (numRead != -1) {
                inflater.setInput(input, 0, numRead);
            }

            int numDecompressed;
            while ((numDecompressed = inflater.inflate(output, 0, output.length)) != 0) {
                bos.write(output, 0, numDecompressed);
            }

            if (inflater.finished()) {
                break;
            } else if (inflater.needsInput()) {
                continue;
            }
        }

        inflater.end();
        ByteBuffer result = ByteBuffer.wrap(bos.toByteArray(), 0, bos.size());

        bos.close();
        fin.close();

        return result;
    } catch (Exception e) {
        FileLog.e(e);
    }

    return null;
}
 

@Override
    public int inflate(byte[] b, int off, int len) throws DataFormatException {
        if (finished) {
            if (in.hasRemaining()) throw new DataFormatException("zlib stream ended unexpectedly");
            return 0;
        }

        if (!in.hasRemaining()) return 0;

        if (determineWrapper) {
            // First two bytes are needed to decide if it's a ZLIB stream.
            if (accumulator.remaining() + len < 2) {
                buffer();
                return 0;
            }

            byte[] cmf_flg = new byte[2];
            cmf_flg[0] = readByte();
            cmf_flg[1] = readByte();
            boolean nowrap = !looksLikeZlib(cmf_flg[0], cmf_flg[1]);
            inflater = new Inflater(nowrap);
            inflater.inflate(cmf_flg, 0, 2);
            determineWrapper = false;
        }


        if (crc != null) {
            switch (gzipState) {
                case FOOTER_START:
                    if (readGZIPFooter()) {
                        finished = true;
                    }
                    return 0;
                default:
                    if (gzipState != GzipState.HEADER_END) {
                        if (!readGZIPHeader()) {
                            return 0;
                        }
                    }
            }
            // Some bytes may have been consumed, and so we must re-set the number of readable bytes.
//            readableBytes = in.readableBytes();
        }

        inflater.setInput(in.array(), in.arrayOffset() + in.position(), in.remaining());

        boolean readFooter = false;
        int totalWritten = 0;
        while (off < len && !inflater.needsInput()) {

            int bytesWritten = inflater.inflate(b, off, len);
            if (bytesWritten > 0) {
                totalWritten += bytesWritten;
                if (crc != null) {
                    crc.update(b, off, bytesWritten);
                }
                off += bytesWritten;
            } else {
                if (inflater.needsDictionary()) {
                    inflater.setDictionary(dictionary);
                }
            }

            if (inflater.finished()) {
                if (crc == null) {
                    finished = true; // Do not decode anymore.
                } else {
                    readFooter = true;
                }
                break;
            }
        }

        in.position(in.position() + in.remaining() - inflater.getRemaining());

        if (readFooter) {
            gzipState = GzipState.FOOTER_START;
            if (readGZIPFooter()) {
                finished = true;
            }
        }

        return totalWritten;
    }
 

/**
 * zlib decompress 2 byte
 *
 * @param bytesToDecompress
 * @return
 */
public static byte[] decompressForZlib(byte[] bytesToDecompress) {
    byte[] returnValues = null;

    Inflater inflater = new Inflater();

    int numberOfBytesToDecompress = bytesToDecompress.length;

    inflater.setInput
            (
                    bytesToDecompress,
                    0,
                    numberOfBytesToDecompress
            );

    int bufferSizeInBytes = numberOfBytesToDecompress;

    int numberOfBytesDecompressedSoFar = 0;
    List<Byte> bytesDecompressedSoFar = new ArrayList<Byte>();

    try {
        while (inflater.needsInput() == false) {
            byte[] bytesDecompressedBuffer = new byte[bufferSizeInBytes];

            int numberOfBytesDecompressedThisTime = inflater.inflate
                    (
                            bytesDecompressedBuffer
                    );

            numberOfBytesDecompressedSoFar += numberOfBytesDecompressedThisTime;

            for (int b = 0; b < numberOfBytesDecompressedThisTime; b++) {
                bytesDecompressedSoFar.add(bytesDecompressedBuffer[b]);
            }
        }

        returnValues = new byte[bytesDecompressedSoFar.size()];
        for (int b = 0; b < returnValues.length; b++) {
            returnValues[b] = (byte) (bytesDecompressedSoFar.get(b));
        }

    } catch (DataFormatException dfe) {
        dfe.printStackTrace();
    }

    inflater.end();

    return returnValues;
}
 

/**
 * zlib decompress 2 byte
 *
 * @param bytesToDecompress
 * @return
 */
public static byte[] decompressForZlib(byte[] bytesToDecompress) {
    byte[] returnValues = null;

    Inflater inflater = new Inflater();

    int numberOfBytesToDecompress = bytesToDecompress.length;

    inflater.setInput
            (
                    bytesToDecompress,
                    0,
                    numberOfBytesToDecompress
            );

    int numberOfBytesDecompressedSoFar = 0;
    List<Byte> bytesDecompressedSoFar = new ArrayList<>();

    try {
        while (!inflater.needsInput()) {
            byte[] bytesDecompressedBuffer = new byte[numberOfBytesToDecompress];

            int numberOfBytesDecompressedThisTime = inflater.inflate
                    (
                            bytesDecompressedBuffer
                    );

            numberOfBytesDecompressedSoFar += numberOfBytesDecompressedThisTime;

            for (int b = 0; b < numberOfBytesDecompressedThisTime; b++) {
                bytesDecompressedSoFar.add(bytesDecompressedBuffer[b]);
            }
        }

        returnValues = new byte[bytesDecompressedSoFar.size()];
        for (int b = 0; b < returnValues.length; b++) {
            returnValues[b] = bytesDecompressedSoFar.get(b);
        }

    } catch (DataFormatException dfe) {
        dfe.printStackTrace();
    }

    inflater.end();

    return returnValues;
}
 

private static void assertRoundTrip(byte[] dictionary) throws Exception {
    // Construct a nice long input byte sequence.
    String expected = makeString();
    byte[] expectedBytes = expected.getBytes("UTF-8");

    // Compress the bytes, using the passed-in dictionary (or no dictionary).
    byte[] deflatedBytes = deflate(expectedBytes, dictionary);

    // Get ready to decompress deflatedBytes back to the original bytes ...
    Inflater inflater = new Inflater();
    // We'll only supply the input a little bit at a time, so that zlib has to ask for more.
    final int CHUNK_SIZE = 16;
    int offset = 0;
    inflater.setInput(deflatedBytes, offset, CHUNK_SIZE);
    offset += CHUNK_SIZE;
    // If we used a dictionary to compress, check that we're asked for that same dictionary.
    if (dictionary != null) {
        // 1. there's no data available immediately...
        assertEquals(0, inflater.inflate(new byte[8]));
        // 2. ...because you need a dictionary.
        assertTrue(inflater.needsDictionary());
        // 3. ...and that dictionary has the same Adler32 as the dictionary we used.
        assertEquals(adler32(dictionary), inflater.getAdler());
        inflater.setDictionary(dictionary);
    }
    // Do the actual decompression, now the dictionary's set up appropriately...
    // We use a tiny output buffer to ensure that we call inflate multiple times, and
    // a tiny input buffer to ensure that zlib has to ask for more input.
    ByteArrayOutputStream inflatedBytes = new ByteArrayOutputStream();
    byte[] buf = new byte[8];
    while (inflatedBytes.size() != expectedBytes.length) {
        if (inflater.needsInput()) {
            int nextChunkByteCount = Math.min(CHUNK_SIZE, deflatedBytes.length - offset);
            inflater.setInput(deflatedBytes, offset, nextChunkByteCount);
            offset += nextChunkByteCount;
        } else {
            int inflatedByteCount = inflater.inflate(buf);
            if (inflatedByteCount > 0) {
                inflatedBytes.write(buf, 0, inflatedByteCount);
            }
        }
    }
    inflater.end();

    assertEquals(expected, new String(inflatedBytes.toByteArray(), "UTF-8"));
}
 

/**
 * zlib decompress 2 byte
 *
 * @param bytesToDecompress
 * @return
 */
public static byte[] decompressForZlib(byte[] bytesToDecompress) {
    byte[] returnValues = null;

    Inflater inflater = new Inflater();

    int numberOfBytesToDecompress = bytesToDecompress.length;

    inflater.setInput
            (
                    bytesToDecompress,
                    0,
                    numberOfBytesToDecompress
            );

    int bufferSizeInBytes = numberOfBytesToDecompress;

    int numberOfBytesDecompressedSoFar = 0;
    List<Byte> bytesDecompressedSoFar = new ArrayList<Byte>();

    try {
        while (inflater.needsInput() == false) {
            byte[] bytesDecompressedBuffer = new byte[bufferSizeInBytes];

            int numberOfBytesDecompressedThisTime = inflater.inflate
                    (
                            bytesDecompressedBuffer
                    );

            numberOfBytesDecompressedSoFar += numberOfBytesDecompressedThisTime;

            for (int b = 0; b < numberOfBytesDecompressedThisTime; b++) {
                bytesDecompressedSoFar.add(bytesDecompressedBuffer[b]);
            }
        }

        returnValues = new byte[bytesDecompressedSoFar.size()];
        for (int b = 0; b < returnValues.length; b++) {
            returnValues[b] = (byte) (bytesDecompressedSoFar.get(b));
        }

    } catch (DataFormatException dfe) {
        dfe.printStackTrace();
    }

    inflater.end();

    return returnValues;
}
 

/**
 * Returns the non-null InputStream that should be returned to by all
 * requests to {@link #getContent()}.
 * 
 * @return a non-null InputStream
 * @throws IOException
 *             if there was a problem
 */
@Override
InputStream getDecompressingInputStream(final InputStream wrapped)
        throws IOException {
    /*
     * A zlib stream will have a header.
     * 
     * CMF | FLG [| DICTID ] | ...compressed data | ADLER32 |
     * 
     * * CMF is one byte.
     * 
     * * FLG is one byte.
     * 
     * * DICTID is four bytes, and only present if FLG.FDICT is set.
     * 
     * Sniff the content. Does it look like a zlib stream, with a CMF, etc?
     * c.f. RFC1950, section 2.2. http://tools.ietf.org/html/rfc1950#page-4
     * 
     * We need to see if it looks like a proper zlib stream, or whether it
     * is just a deflate stream. RFC2616 calls zlib streams deflate.
     * Confusing, isn't it? That's why some servers implement deflate
     * Content-Encoding using deflate streams, rather than zlib streams.
     * 
     * We could start looking at the bytes, but to be honest, someone else
     * has already read the RFCs and implemented that for us. So we'll just
     * use the JDK libraries and exception handling to do this. If that
     * proves slow, then we could potentially change this to check the first
     * byte - does it look like a CMF? What about the second byte - does it
     * look like a FLG, etc.
     */

    /* We read a small buffer to sniff the content. */
    final byte[] peeked = new byte[6];

    final PushbackInputStream pushback = new PushbackInputStream(wrapped,
            peeked.length);

    final int headerLength = pushback.read(peeked);

    if (headerLength == -1) {
        throw new IOException("Unable to read the response");
    }

    /* We try to read the first uncompressed byte. */
    final byte[] dummy = new byte[1];

    final Inflater inf = new Inflater();

    try {
        int n;
        while ((n = inf.inflate(dummy)) == 0) {
            if (inf.finished()) {

                /* Not expecting this, so fail loudly. */
                throw new IOException("Unable to read the response");
            }

            if (inf.needsDictionary()) {

                /*
                 * Need dictionary - then it must be zlib stream with DICTID
                 * part?
                 */
                break;
            }

            if (inf.needsInput()) {
                inf.setInput(peeked);
            }
        }

        if (n == -1) {
            throw new IOException("Unable to read the response");
        }

        /*
         * We read something without a problem, so it's a valid zlib stream.
         * Just need to reset and return an unused InputStream now.
         */
        pushback.unread(peeked, 0, headerLength);
        return new InflaterInputStream(pushback);
    } catch (final DataFormatException e) {

        /*
         * Presume that it's an RFC1951 deflate stream rather than RFC1950
         * zlib stream and try again.
         */
        pushback.unread(peeked, 0, headerLength);
        return new InflaterInputStream(pushback, new Inflater(true));
    }
}
 

/**
 * zlib decompress 2 byte
 */
public static byte[] decompressForZlib(byte[] bytesToDecompress) {
  byte[] returnValues = null;

  Inflater inflater = new Inflater();

  int numberOfBytesToDecompress = bytesToDecompress.length;

  inflater.setInput
      (
          bytesToDecompress,
          0,
          numberOfBytesToDecompress
      );

  int bufferSizeInBytes = numberOfBytesToDecompress;

  int numberOfBytesDecompressedSoFar = 0;
  List<Byte> bytesDecompressedSoFar = new ArrayList<Byte>();

  try {
    while (inflater.needsInput() == false) {
      byte[] bytesDecompressedBuffer = new byte[bufferSizeInBytes];

      int numberOfBytesDecompressedThisTime = inflater.inflate
          (
              bytesDecompressedBuffer
          );

      numberOfBytesDecompressedSoFar += numberOfBytesDecompressedThisTime;

      for (int b = 0; b < numberOfBytesDecompressedThisTime; b++) {
        bytesDecompressedSoFar.add(bytesDecompressedBuffer[b]);
      }
    }

    returnValues = new byte[bytesDecompressedSoFar.size()];
    for (int b = 0; b < returnValues.length; b++) {
      returnValues[b] = (byte) (bytesDecompressedSoFar.get(b));
    }

  } catch (DataFormatException dfe) {
    dfe.printStackTrace();
  }

  inflater.end();

  return returnValues;
}