Java Code Examples for org.xerial.snappy.Snappy#uncompress()

/**
 * Using snappy uncompress.
 * 
 * @param data
 * @return
 */
public static byte[] snappyUnCompress(byte[] data) {
	try {
		return Snappy.uncompress(data);
	} catch (IOException e) {
		throw new IllegalStateException(e);
	}
}
 

private static byte[] deserializeByteCompressedArray(DataInput is)
    throws IOException {
  int size = LongPacker.unpackInt(is);
  byte[] b = new byte[size];
  is.readFully(b);
  return Snappy.uncompress(b);
}
 

@Override
public byte[] decompress(byte[] input) {
  try {
    return Snappy.uncompress(input);
  } catch (IOException e) {
    throw new CompressionException(e);
  }
}
 

@Override
public ByteBuf decode(ByteBuf encoded, int uncompressedLength) throws IOException {
    ByteBuf uncompressed = PooledByteBufAllocator.DEFAULT.buffer(uncompressedLength, uncompressedLength);
    ByteBuffer uncompressedNio = uncompressed.nioBuffer(0, uncompressedLength);

    ByteBuffer encodedNio = encoded.nioBuffer(encoded.readerIndex(), encoded.readableBytes());
    Snappy.uncompress(encodedNio, uncompressedNio);

    uncompressed.writerIndex(uncompressedLength);
    return uncompressed;
}
 

private synchronized void findNextValues() {
    if (!wasClosed()) {
        try {
            long numOfValues = connection.readLong();
            if (numOfValues == LONG_END) {
                nextValues = null;
                readAllValuesFromConnection = true;
            } else if (numOfValues != LONG_ERROR) {
                byte[] compressedValues = connection.readByteArray();
                byte[] uncompressedValues = Snappy.uncompress(compressedValues);
                DataStream valueIS = new DataStream(uncompressedValues);
                List<T> nextValuesList = new ArrayList<>();
                while (nextValuesList.size() < numOfValues) {
                    int objectSize = DataStreamUtils.getObjectSize(valueIS, objectSerializer);
                    T value = objectSerializer.readValue(valueIS, objectSize);
                    nextValuesList.add(value);
                }
                if (nextValuesList.isEmpty()) {
                    throw new RuntimeException("Received zero values! numOfValues=" + numOfValues);
                }
                nextValues = nextValuesList.iterator();
            } else {
                throw new RuntimeException("Unexpected response " + connection.readString());

            }
        } catch (Exception e) {
            remoteDataInterface.dropConnection(connection);
            throw new RuntimeException(e);
        }
    } else {
        nextValues = null;
    }
}
 

@Override
public byte[] decompress(byte[] input) {
  try {
    return Snappy.uncompress(input);
  } catch (IOException e) {
    throw new CompressionException(e);
  }
}
 

@Override
public Closeable newCache(ImmutableBytesWritable cachePtr, MemoryChunk chunk) throws SQLException {
    try {
        int size = Snappy.uncompressedLength(cachePtr.get());
        byte[] uncompressed = new byte[size];
        Snappy.uncompress(cachePtr.get(), 0, cachePtr.getLength(), uncompressed, 0);
        return new HashCacheImpl(uncompressed, chunk);
    } catch (IOException e) {
        throw ServerUtil.parseServerException(e);
    }
}
 

private void fetchBlock() throws IOException {
  int compressedSize = Util.readUnsignedVLQInt(data);
  data.readFully(compressedBuf, 0, compressedSize);
  bufPos = 0;
  blockSize = Snappy.uncompress(compressedBuf, 0, compressedSize, uncompressedBuf, 0);
  position = -1;
}
 

private synchronized void findNextValues() {
    if (!wasClosed()) {
        try {
            long numOfValues = connection.readLong();
            if (numOfValues == LONG_END) {
                nextValues = null;
                readAllValuesFromConnection = true;
            } else if (numOfValues != LONG_ERROR) {
                byte[] keys = connection.readByteArray();
                byte[] compressedValues = connection.readByteArray();
                byte[] uncompressedValues = Snappy.uncompress(compressedValues);
                DataStream keyIS = new DataStream(keys);
                DataStream valueIS = new DataStream(uncompressedValues);
                List<KeyValue<T>> nextValuesList = new ArrayList<>();
                while (nextValuesList.size() < numOfValues) {
                    long key = keyIS.readLong();
                    int objectSize = DataStreamUtils.getObjectSize(valueIS, objectSerializer);
                    T value = objectSerializer.readValue(valueIS, objectSize);
                    nextValuesList.add(new KeyValue<>(key, value));
                }
                if (nextValuesList.isEmpty()) {
                    throw new RuntimeException("Received zero values! numOfValues=" + numOfValues);
                }
                nextValues = nextValuesList.iterator();
            } else {
                throw new RuntimeException("Unexpected response " + connection.readString());

            }
        } catch (Exception e) {
            remoteDataInterface.dropConnection(connection);
            throw new RuntimeException(e);
        }
    } else {
        nextValues = null;
    }
}
 

public byte[] decompress(final byte[] compressed) {
  checkNotNull(compressed, "input data must not be null");
  try {
    return Snappy.uncompress(compressed);
  } catch (final IOException e) {
    throw new FramingException("Snappy decompression failed", e);
  }
}
 

public Frame decompress(Frame frame) throws IOException
{
    byte[] input = CBUtil.readRawBytes(frame.body);

    if (!Snappy.isValidCompressedBuffer(input, 0, input.length))
        throw new ProtocolException("Provided frame does not appear to be Snappy compressed");

    ByteBuf output = CBUtil.allocator.heapBuffer(Snappy.uncompressedLength(input));

    try
    {
        int size = Snappy.uncompress(input, 0, input.length, output.array(), output.arrayOffset());
        output.writerIndex(size);
    }
    catch (final Throwable e)
    {
        output.release();
        throw e;
    }
    finally
    {
        //release the old frame
        frame.release();
    }

    return frame.with(output);
}
 

@Test
public void testBytes() throws IOException {
  String input = randomString(50000);
  byte[] uncom = input.getBytes(StandardCharsets.UTF_8);
  long time = System.currentTimeMillis();
  byte[] compressed = Snappy.compress(uncom);
  System.out.println("compression time cost:" + (System.currentTimeMillis() - time));
  time = System.currentTimeMillis();
  byte[] uncompressed = Snappy.uncompress(compressed);
  System.out.println("decompression time cost:" + (System.currentTimeMillis() - time));
}
 

@Override
public Object decode(ByteBuf buf, State state) throws IOException {
    byte[] bytes = new byte[buf.readableBytes()];
    buf.readBytes(bytes);
    bytes = Snappy.uncompress(bytes);
    ByteBuf bf = Unpooled.wrappedBuffer(bytes);
    try {
        return innerCodec.getValueDecoder().decode(bf, state);
    } finally {
        bf.release();
    }
}
 

@Override
public byte[] uncompress(byte[] bytes) {
  if (bytes == null) {
    return new byte[0];
  }

  try {
    return Snappy.uncompress(bytes);
  } catch (IOException e) {
    logger.error(
        "tsfile-compression SnappyUnCompressor: errors occurs when uncompress input byte", e);
  }
  return new byte[0];
}
 

/**
 * Snappy解压
 * @param data
 * @return
 * @throws IOException
 */
public static byte[] uncompressSnappy(byte[] data) throws IOException {
    if (data == null) {
        return new byte[0];
    }
    return Snappy.uncompress(data);
}
 

public Object objectFromByteBuffer(byte[] buf) throws IOException {
    byte[] uncompressBuf;
    ByteArrayInputStream bais = null;
    Object o = null;

    if( DEBUG )
        log.debug(StackTraceUtil.getStackTrace(Thread.currentThread().getStackTrace()) );

    try {
        if (USE_SNAPPY_COMPRESSION) {
            uncompressBuf = Snappy.uncompress(buf);
            if (DEBUG) {
                log.debug("KhanFSTMarshaller/toObject/SIZE=" + buf.length + "/UNCOMPRESS=" + uncompressBuf.length);
            }

            return MarshallerUtil.bytes2obj(marshaller, uncompressBuf);
        } else {
            if (DEBUG) {
                log.debug("KhanFSTMarshaller/toObject/SIZE=" + buf.length);
            }
            return MarshallerUtil.bytes2obj(marshaller, buf);
        }


    } catch (Exception e) {
        throw new IOException("Exception");
    }
}
 

/**
 * 解压
 * @param bytes
 * @return
 */
public static byte[] uncompress(byte[] bytes) {
	try {
		return Snappy.uncompress(bytes);
	} catch (Exception e) {
		LOGGER.warn("{}", e);
	}
	return null;
}
 

@Override
public void decompress(ByteBuffer src, int compressedSize, ByteBuffer dst, int uncompressedSize) throws IOException {
  dst.clear();
  int size = Snappy.uncompress(src, dst);
  dst.limit(size);
}
 

@Override
public int decompress(byte[] src, int srcPos, int length, byte[] dest,
	 int destPos, int maxLength) throws IOException {
	this.src = src;
	decompressedLength = 0;

	// Check for magic number
	if (src[srcPos] == MAGIC_NUMBER[0] //
		 || src[srcPos + 1] == MAGIC_NUMBER[1] //
		 || src[srcPos + 2] == MAGIC_NUMBER[2] //
		 || src[srcPos + 3] == MAGIC_NUMBER[3] //
		 || src[srcPos + 4] == MAGIC_NUMBER[4] //
		 || src[srcPos + 5] == MAGIC_NUMBER[5] //
		 || src[srcPos + 6] == MAGIC_NUMBER[6] //
		 || src[srcPos + 7] == MAGIC_NUMBER[7]) {

     // advance past the magic number
		// assume the version (4 bytes), min compatable version (4 bytes) are fine
		pos = srcPos + 8 + 8;

		// TODO: limit the decompressed length
		while (pos < srcPos + length) {
			blockLength = readInt();

			// Check to see if this will exceed maxLength
			uncompressedBlockLength = Snappy.uncompressedLength(src, pos,
				 blockLength);
			if (decompressedLength + uncompressedBlockLength > maxLength) {
				return -1;
			}

			decompressedLength += Snappy.uncompress(src, pos, blockLength, dest,
				 destPos + decompressedLength);
			pos += blockLength;
		}

		return decompressedLength;
	} else {
		// Assume it's just straight compressed
		return Snappy.uncompress(src, pos, blockLength, dest, destPos);
	}
}
 

@Override
public int decompress(ByteBuffer compressedInput, ByteBuffer decompressedOutput)
    throws IOException {
  return Snappy.uncompress(compressedInput, decompressedOutput);
}