Java LZ4FastDecompressor.decompress方法代码示例

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
public void readFieldsC(DataInput in) throws IOException {
	int decompressedLength = in.readInt();
	int compressedLength = in.readInt();
	byte[] compressed = new byte[compressedLength];
	in.readFully(compressed, 0, compressedLength);
	LZ4Factory factory = LZ4Factory.fastestInstance();
	LZ4FastDecompressor decompressor = factory.fastDecompressor();
	byte[] uncompressedByteArray = new byte[decompressedLength];
	decompressor.decompress(compressed, 0, uncompressedByteArray, 0, decompressedLength);		
	//byte[] uncompressedByteArray = WritableUtils.readCompressedByteArray(in);
	UnsafeByteArrayInputStream inStream = new UnsafeByteArrayInputStream(uncompressedByteArray);

	size = inStream.readInt();
	tables = new HashMap<String, Table>();
	for (int i = 0; i < size; i++)
	{
		String tableName = inStream.readUTF();
		Table table = new Table(null, null);
		table.readFields(inStream);
		tables.put(tableName, table);
	}
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
@Override
protected void onDeserialize(Deserializer buf) {
    super.onDeserialize(buf);
    int length = buf.getInt(null);
    int compressedLength = buf.getInt(null);
    Preconditions.checkState(length == data.length,
            "Size of serialized sketch does not match expected value. Expected %s, actual %s.", data.length, length);

    if (length == compressedLength) {
        deserializeDataArray(data, length, buf);
    } else {
        LZ4FastDecompressor c = LZ4Factory.safeInstance().fastDecompressor();
        byte[] compressedData = buf.getBytes(null, compressedLength);
        c.decompress(compressedData, data);
    }
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
private void print(Request request) {
    Values ret = request.returnValues();
    CompressionType type = CompressionType.valueOf(ret.get(0).asInt8());
    int uncompressedSize = ret.get(1).asInt32();
    byte [] blob = ret.get(2).asData();
    if (type == CompressionType.LZ4) {
        LZ4Factory factory = LZ4Factory.fastestInstance();
        LZ4FastDecompressor decompressor = factory.fastDecompressor();
        byte [] uncompressed = new byte [uncompressedSize];
        int compressedLength = decompressor.decompress(blob, 0, uncompressed, 0, uncompressedSize);
        if (compressedLength != blob.length) {
            throw new DeserializationException("LZ4 decompression failed. compressed size does not match. Expected " + blob.length + ". Got " + compressedLength);
        }
        blob = uncompressed;
    }
    Slime slime = BinaryFormat.decode(blob);
    try {
        new JsonFormat(true).encode(System.out, slime);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
/**
 * lz4 解壓縮
 *
 * @param value
 * @return
 */
public static byte[] unlz4(byte[] value) {
	byte[] result = new byte[0];
	try {
		LZ4Factory factory = LZ4Factory.fastestInstance();
		LZ4FastDecompressor decompressor = factory.fastDecompressor();
		//
		final int INTEGER_BYTES = 4;
		// 取原始長度
		int uncompressedLength = ((value[0] & 0xFF) << 24) | ((value[1] & 0xFF) << 16) | ((value[2] & 0xFF) << 8)
				| ((value[3] & 0xFF));
		result = new byte[uncompressedLength];
		int read = decompressor.decompress(value, INTEGER_BYTES, result, 0, uncompressedLength);
		if (read != (value.length - INTEGER_BYTES)) {
			result = new byte[0];
		}
	} catch (Exception ex) {
		ex.printStackTrace();
	}
	return result;
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
/**
 * When the exact decompressed size is known, use this method to decompress. It's faster.
 *
 * @see net.jpountz.lz4.LZ4FastDecompressor
 */
public static byte[] decompressFast(byte[] src, int srcOffset, int exactDecompressedSize) {
    if (src == null) {
        throw new IllegalArgumentException("src must not be null.");
    }

    if (srcOffset < 0) {
        throw new IllegalArgumentException("srcOffset must equal to or larger than 0 but " + srcOffset);
    }

    if (exactDecompressedSize < 0) {
        throw new IllegalArgumentException("exactDecompressedSize must equal to or larger than 0 but " + exactDecompressedSize);
    }

    LZ4FastDecompressor decompressor = factory.fastDecompressor();

    return decompressor.decompress(src, srcOffset, exactDecompressedSize);
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
public Image get() {
	switch (type) {
	case PNG:
		return ImageUtils.fromPNG(data);

	case LZ4:
		LZ4FastDecompressor lz4Decompressor = LZ4Factory.unsafeInstance().fastDecompressor();
		byte[] uncompressed = new byte[uncompressedLength];
		lz4Decompressor.decompress(data, uncompressed);
		return uncompressImage(width, height, uncompressed);
		// byte[]decompressed = lz4Decompressor.d
		// case LZ4:
		// return LZ4Factory.unsafeInstance().fastCompressor().compress(getUncompressedBytes(img));
		//
	default:
		throw new IllegalArgumentException();
	}
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
public static byte[] uncompressCGSS(byte[] src) throws IOException {
    byte[] buf = new byte[4];
    System.arraycopy(src, 4, buf, 0, 4);
    int destL = getInt(buf, 0);


    byte[] source = new byte[src.length - 16];
    byte[] dest = new byte[destL];
    System.arraycopy(src, 16, source, 0, src.length - 16);

    LZ4Factory factory = LZ4Factory.fastestInstance();
    LZ4FastDecompressor decompresser = factory.fastDecompressor();
    decompresser.decompress(source, dest, destL);
    return dest;
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
public byte[] decompress(byte[] value, int offset, int length, int uncompressedLength) throws IOException {
    LZ4FastDecompressor decompressor;
    byte[]              restored;
    
    decompressor = factory.fastDecompressor();
    restored = new byte[uncompressedLength];
    decompressor.decompress(value, offset, restored, 0, uncompressedLength);    
    return restored;
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
public static byte[] uncompress(byte[] result) {
	byte[] length = new byte[4];
	System.arraycopy(result, 0, length, 0, length.length);
	int size = byteArrayToInt(length);
	byte[] restored = new byte[size];
	LZ4FastDecompressor decompressor = factory.fastDecompressor();
	decompressor.decompress(result, 4, restored, 0, size);
	return restored;
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
@Override
protected byte[] decompress(byte[] in) {
	byte[] out = null;
	if (in != null) {
		LZ4FastDecompressor decompressor = lz4Factory.fastDecompressor();

		int size = ByteBuffer.wrap(in).getInt();
		out = new byte[size];
		decompressor.decompress(in, Ints.BYTES, out, 0, out.length);
	}
	return out == null ? null : out;
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
private static ByteBuf readBody(LZ4FastDecompressor decompressor, StreamingXXHash32 checksum, Header header,
                                byte[] bytes, int off) throws ParseException {
	ByteBuf outputBuf = ByteBufPool.allocate(header.originalLen);
	outputBuf.writePosition(header.originalLen);
	switch (header.compressionMethod) {
		case COMPRESSION_METHOD_RAW:
			System.arraycopy(bytes, off, outputBuf.array(), 0, header.originalLen);
			break;
		case COMPRESSION_METHOD_LZ4:
			try {
				int compressedLen2 = decompressor.decompress(bytes, off, outputBuf.array(), 0, header.originalLen);
				if (header.compressedLen != compressedLen2) {
					throw new ParseException("Stream is corrupted");
				}
			} catch (LZ4Exception e) {
				throw new ParseException("Stream is corrupted", e);
			}
			break;
		default:
			throw new AssertionError();
	}
	checksum.reset();
	checksum.update(outputBuf.array(), 0, header.originalLen);
	if (checksum.getValue() != header.check) {
		throw new ParseException("Stream is corrupted");
	}
	return outputBuf;
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
public String getDataTypePriv() throws IOException {
	RandomAccessFile fin = new RandomAccessFile(sinfile,"r");
	byte[] res=null;
	byte[] rescomp=null;
	if (dataHeader.mmcfLen>0) {
		Object block = dataBlocks.firstElement();
		if (block instanceof AddrBlock) {
			res = new byte[(int)((AddrBlock)block).dataLen];
			fin.seek(getDataOffset()+((AddrBlock)block).dataOffset);
			fin.read(res);
			fin.close();
		}
		else {
			rescomp = new byte[(int)((LZ4ABlock)block).compDataLen];
			fin.seek(getDataOffset()+((LZ4ABlock)block).dataOffset);
			fin.read(rescomp);
			fin.close();
			LZ4Factory factory = LZ4Factory.fastestInstance();
			LZ4FastDecompressor decomp = factory.fastDecompressor();
			res = decomp.decompress(rescomp, (int)((LZ4ABlock)block).uncompDataLen);
		}
	}
	else {
		res = new byte[blocks.blocks[0].length];
		fin.seek(getDataOffset());
		fin.read(res);
		fin.close();
	}
	return getDataTypePriv(res);
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
public byte[] decompressLZ4(byte[] compressed, int decompressedLength) {
	LZ4FastDecompressor decompressor = lz4.get().fastDecompressor();
	byte[] restored = new byte[decompressedLength];
	decompressor.decompress(compressed, 0, restored, 0, decompressedLength);
	return restored;
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
public static void main(String[] args)
{
	if (!Util.setTheme())
		return;

	// choose input file
	File inFile = Util.getOpenFile("Select file to decompress");
	if (inFile == null)
		return;

	// choose output file
	File outFile = Util.getSaveFile("Select output file");
	if (outFile == null)
		return;

	try
	{
		LZ4Factory factory = LZ4Factory.fastestJavaInstance();
		GpqLog.LOGGER.log("Loading data from file");
		byte[] data = FileUtils.readFileToByteArray(inFile);
		ByteBuffer inBuf = ByteBuffer.wrap(data);
		int decompressedLength = inBuf.getInt();
		GpqLog.LOGGER.log("Preparing to decompress " + decompressedLength + " bytes");
		LZ4FastDecompressor decompressor = factory.fastDecompressor();
		ByteBuffer outBuf = ByteBuffer.allocateDirect(decompressedLength);
		long preTime = System.currentTimeMillis();
		decompressor.decompress(inBuf, 4, outBuf, 0, decompressedLength);
		long postTime = System.currentTimeMillis();
		long timeTaken = postTime - preTime;
		GpqLog.LOGGER.log("Before decompression, data was " + (data.length - 4) + " bytes. It is now " + decompressedLength + ". Decompression took " + timeTaken + "ms");
		GpqLog.LOGGER.log("Writing data to file");
		byte[] outarray = new byte[decompressedLength];
		outBuf.rewind();
		outBuf.get(outarray);
		FileUtils.writeByteArrayToFile(outFile, outarray);
		GpqLog.LOGGER.log("Done");
	}
	catch (Throwable e)
	{
		e.printStackTrace();
		Util.showMessage("Exception " + e.getLocalizedMessage());
		return;
	}
}
 

import net.jpountz.lz4.LZ4FastDecompressor; //导入方法依赖的package包/类
public static void main(String[] args) throws IOException {


        LZ4Factory factory = LZ4Factory.fastestInstance();
        byte[] data = "Compressors and decompressors are interchangeable: it is perfectly correct to compress with the JNI bindings and to decompress with a Java port, or the other way around.Compressors might not generate the same compressed streams on all platforms, especially if CPU endianness differs, but the compressed streams can be safely decompressed by any decompressor implementation on any platform.Compressors and decompressors are interchangeable: it is perfectly correct to compress with the JNI bindings and to decompress with a Java port, or the other way around.Compressors might not generate the same compressed streams on all platforms, especially if CPU endianness differs, but the compressed streams can be safely decompressed by any decompressor implementation on any platform.".getBytes("UTF-8");


        final int decompressedLength = data.length;
        System.out.println("dataLength:" + decompressedLength);

        // compress data
        LZ4Compressor compressor = factory.fastCompressor();
        int maxCompressedLength = compressor.maxCompressedLength(decompressedLength);
        byte[] compressed = new byte[maxCompressedLength];
        int compressedLength = compressor.compress(data, 0, decompressedLength, compressed, 0, maxCompressedLength);
        System.out.println("compressedLength:" + compressedLength);

     // decompress data
        // - method 1: when the decompressed length is known
        LZ4FastDecompressor decompressor = factory.fastDecompressor();
        byte[] restored = new byte[decompressedLength];
        int compressedLength2 = decompressor.decompress(compressed, 0, restored, 0, decompressedLength);
        // compressedLength == compressedLength2
        System.out.println("compressedLength2:" + compressedLength2);

        // - method 2: when the compressed length is known (a little slower)
        // the destination buffer needs to be over-sized
        LZ4SafeDecompressor decompressor2 = factory.safeDecompressor();
        int decompressedLength2 = decompressor2.decompress(compressed, 0, compressedLength, restored, 0);
        // decompressedLength == decompressedLength2
        System.out.println("decompressedLength2:" + compressedLength);



        XXHashFactory factory1 = XXHashFactory.fastestInstance();
        ByteArrayInputStream in = new ByteArrayInputStream(data);

        int seed = 0x9747b28c; // used to initialize the hash value, use whatever
        // value you want, but always the same
        StreamingXXHash32 hash32 = factory1.newStreamingHash32(seed);
        byte[] buf = new byte[8]; // for real-world usage, use a larger buffer, like 8192 bytes
        for (;;) {
            int read = in.read(buf);
            if (read == -1) {
                break;
            }
            hash32.update(buf, 0, read);
        }
        int hash = hash32.getValue();

        System.out.println(hash);
    }