private void flushInputToStream(final OutputStream pStream) throws IOException {
    System.out.println("DeflateEncoder.flushInputToStream");

    if (deflater.needsInput()) {
      System.out.println("Foo");
    }

    while (!deflater.needsInput()) {
      int deflated = deflater.deflate(buffer, 0, buffer.length);
      pStream.write(buffer, 0, deflated);
      System.out.println("flushed " + deflated);
    }
  }
 @Override
 public void encode(ChannelBuffer compressed) {
   while (!compressor.needsInput()) {
     int numBytes = compressor.deflate(out, 0, out.length, Deflater.SYNC_FLUSH);
     compressed.writeBytes(out, 0, numBytes);
   }
 }
 @Override
 public void write(byte[] b, int off, int len) throws IOException {
   if (_def.finished()) throw new IOException("Stream already finished");
   if ((off | len | (off + len) | (b.length - (off + len))) < 0)
     throw new IndexOutOfBoundsException();
   if (len == 0) return;
   if (!_def.finished()) {
     _def.setInput(b, off, len);
     while (!_def.needsInput()) {
       deflate();
     }
   }
 }
 /** Writes bytes to ZIP entry. */
 public void write(byte[] b, int offset, int length) throws IOException {
   if (entry.getMethod() == DEFLATED) {
     if (length > 0) {
       if (!def.finished()) {
         def.setInput(b, offset, length);
         while (!def.needsInput()) {
           deflate();
         }
       }
     }
   } else {
     writeOut(b, offset, length);
     written += length;
   }
   crc.update(b, offset, length);
 }
 /**
  * {@collect.stats} {@description.open} Writes an array of bytes to the compressed output stream.
  * This method will block until all the bytes are written. {@description.close}
  *
  * @param b the data to be written
  * @param off the start offset of the data
  * @param len the length of the data
  * @exception IOException if an I/O error has occurred
  */
 public void write(byte[] b, int off, int len) throws IOException {
   if (def.finished()) {
     throw new IOException("write beyond end of stream");
   }
   if ((off | len | (off + len) | (b.length - (off + len))) < 0) {
     throw new IndexOutOfBoundsException();
   } else if (len == 0) {
     return;
   }
   if (!def.finished()) {
     // Deflate no more than stride bytes at a time.  This avoids
     // excess copying in deflateBytes (see Deflater.c)
     int stride = buf.length;
     for (int i = 0; i < len; i += stride) {
       def.setInput(b, off + i, Math.min(stride, len - i));
       while (!def.needsInput()) {
         deflate();
       }
     }
   }
 }
Example #6
0
  /**
   * Reads compressed data into a byte array. This method will block until some input can be read
   * and compressed.
   *
   * @param b buffer into which the data is read
   * @param off starting offset of the data within {@code b}
   * @param len maximum number of compressed bytes to read into {@code b}
   * @return the actual number of bytes read, or -1 if the end of the uncompressed input stream is
   *     reached
   * @throws IndexOutOfBoundsException if {@code len} > {@code b.length - off}
   * @throws IOException if an I/O error occurs or if this input stream is already closed
   */
  public int read(byte[] b, int off, int len) throws IOException {
    // Sanity checks
    ensureOpen();
    if (b == null) {
      throw new NullPointerException("Null buffer for read");
    } else if (off < 0 || len < 0 || len > b.length - off) {
      throw new IndexOutOfBoundsException();
    } else if (len == 0) {
      return 0;
    }

    // Read and compress (deflate) input data bytes
    int cnt = 0;
    while (len > 0 && !def.finished()) {
      int n;

      // Read data from the input stream
      if (def.needsInput()) {
        n = in.read(buf, 0, buf.length);
        if (n < 0) {
          // End of the input stream reached
          def.finish();
        } else if (n > 0) {
          def.setInput(buf, 0, n);
        }
      }

      // Compress the input data, filling the read buffer
      n = def.deflate(b, off, len);
      cnt += n;
      off += n;
      len -= n;
    }
    if (cnt == 0 && def.finished()) {
      reachEOF = true;
      cnt = -1;
    }

    return cnt;
  }
 private void deflateUntilInputIsNeeded() throws IOException {
   while (!def.needsInput()) {
     deflate();
   }
 }
Example #8
0
  @Override
  public List<MessagePart> sendMessagePart(List<MessagePart> uncompressedParts) {
    List<MessagePart> allCompressedParts = new ArrayList<MessagePart>();

    for (MessagePart uncompressedPart : uncompressedParts) {
      byte opCode = uncompressedPart.getOpCode();
      if (Util.isControl(opCode)) {
        // Control messages can appear in the middle of other messages
        // and must not be compressed. Pass it straight through
        allCompressedParts.add(uncompressedPart);
      } else {
        List<MessagePart> compressedParts = new ArrayList<MessagePart>();
        ByteBuffer uncompressedPayload = uncompressedPart.getPayload();
        SendHandler uncompressedIntermediateHandler = uncompressedPart.getIntermediateHandler();

        deflater.setInput(
            uncompressedPayload.array(),
            uncompressedPayload.arrayOffset() + uncompressedPayload.position(),
            uncompressedPayload.remaining());

        int flush = (uncompressedPart.isFin() ? Deflater.SYNC_FLUSH : Deflater.NO_FLUSH);
        boolean deflateRequired = true;

        while (deflateRequired) {
          ByteBuffer compressedPayload = writeBuffer;

          int written =
              deflater.deflate(
                  compressedPayload.array(),
                  compressedPayload.arrayOffset() + compressedPayload.position(),
                  compressedPayload.remaining(),
                  flush);
          compressedPayload.position(compressedPayload.position() + written);

          if (!uncompressedPart.isFin()
              && compressedPayload.hasRemaining()
              && deflater.needsInput()) {
            // This message part has been fully processed by the
            // deflater. Fire the send handler for this message part
            // and move on to the next message part.
            break;
          }

          // If this point is reached, a new compressed message part
          // will be created...
          MessagePart compressedPart;

          // .. and a new writeBuffer will be required.
          writeBuffer = ByteBuffer.allocate(Constants.DEFAULT_BUFFER_SIZE);

          // Flip the compressed payload ready for writing
          compressedPayload.flip();

          boolean fin = uncompressedPart.isFin();
          boolean full = compressedPayload.limit() == compressedPayload.capacity();
          boolean needsInput = deflater.needsInput();

          if (fin && !full && needsInput) {
            // End of compressed message. Drop EOM bytes and output.
            compressedPayload.limit(compressedPayload.limit() - EOM_BYTES.length);
            compressedPart =
                new MessagePart(
                    true,
                    getRsv(uncompressedPart),
                    opCode,
                    compressedPayload,
                    uncompressedIntermediateHandler,
                    uncompressedIntermediateHandler);
            deflateRequired = false;
            startNewMessage();
          } else if (full && !needsInput) {
            // Write buffer full and input message not fully read.
            // Output and start new compressed part.
            compressedPart =
                new MessagePart(
                    false,
                    getRsv(uncompressedPart),
                    opCode,
                    compressedPayload,
                    uncompressedIntermediateHandler,
                    uncompressedIntermediateHandler);
          } else if (!fin && full && needsInput) {
            // Write buffer full and input message not fully read.
            // Output and get more data.
            compressedPart =
                new MessagePart(
                    false,
                    getRsv(uncompressedPart),
                    opCode,
                    compressedPayload,
                    uncompressedIntermediateHandler,
                    uncompressedIntermediateHandler);
            deflateRequired = false;
          } else if (fin && full && needsInput) {
            // Write buffer full. Input fully read. Deflater may be
            // in one of four states:
            // - output complete (just happened to align with end of
            //   buffer
            // - in middle of EOM bytes
            // - about to write EOM bytes
            // - more data to write
            int eomBufferWritten =
                deflater.deflate(EOM_BUFFER, 0, EOM_BUFFER.length, Deflater.SYNC_FLUSH);
            if (eomBufferWritten < EOM_BUFFER.length) {
              // EOM has just been completed
              compressedPayload.limit(
                  compressedPayload.limit() - EOM_BYTES.length + eomBufferWritten);
              compressedPart =
                  new MessagePart(
                      true,
                      getRsv(uncompressedPart),
                      opCode,
                      compressedPayload,
                      uncompressedIntermediateHandler,
                      uncompressedIntermediateHandler);
              deflateRequired = false;
              startNewMessage();
            } else {
              // More data to write
              // Copy bytes to new write buffer
              writeBuffer.put(EOM_BUFFER, 0, eomBufferWritten);
              compressedPart =
                  new MessagePart(
                      false,
                      getRsv(uncompressedPart),
                      opCode,
                      compressedPayload,
                      uncompressedIntermediateHandler,
                      uncompressedIntermediateHandler);
            }
          } else {
            throw new IllegalStateException("Should never happen");
          }

          // Add the newly created compressed part to the set of parts
          // to pass on to the next transformation.
          compressedParts.add(compressedPart);
        }

        SendHandler uncompressedEndHandler = uncompressedPart.getEndHandler();
        int size = compressedParts.size();
        if (size > 0) {
          compressedParts.get(size - 1).setEndHandler(uncompressedEndHandler);
        }

        allCompressedParts.addAll(compressedParts);
      }
    }

    if (next == null) {
      return allCompressedParts;
    } else {
      return next.sendMessagePart(allCompressedParts);
    }
  }