/// <summary> /// This method returns an uncompressed version of the given compressed byte array /// </summary> /// <param name="inputBlob">the byte array to be decompressed</param> /// <param name="decompressedLength">the known length of the decompressed byte array</param> /// <param name="compressionCode">a generation number that indicates what compression technique to use</param> /// <returns>the decompressed byte array</returns> public static unsafe Byte[] DecompressBlob(Byte[] inputBlob, int decompressedLength, int compressionCode) { if (compressionCode == 1) { // the byte array of the output blob Byte[] decompressedBlob = new Byte[decompressedLength]; // Decompress using LZFX algorithm. // This method will throw an exception if the decompressed data does not // exactly fit into the allocated array size. LZFX.Decompress(inputBlob, decompressedBlob); return(decompressedBlob); } if (compressionCode == 2) { // the byte array of the output blob Byte[] decompressedBlob = new Byte[decompressedLength]; // Decompress using LZFX algorithm. // This method will throw an exception if the decompressed data does not // exactly fit into the allocated array size. LZ4.Decompress(inputBlob, decompressedBlob); return(decompressedBlob); } else { // return without doing any compression return(inputBlob); } }
/// <summary> /// This returns a compressed version of the given byte array /// </summary> /// <param name="uncompressedBlob">the uncompressed byte array</param> /// <param name="compressionCode">a generation number that indicates what compression technique to use</param> /// <returns>the compressed byte array</returns> public static unsafe Byte[] CompressBlob(Byte[] uncompressedBlob, int compressionCode) { if (compressionCode == 1) { Byte[] compressedBlob; // the byte-array length of the input blob int inputLength = uncompressedBlob.Length; // The byte array that will be created by the compression. // Note that some incompressible BLOBs will actually be made larger by LZFX // compression. We have observed about 1% increase over the original BLOB, // so the factor of 1.05 is expected to be safe. We add 16 since the factor // of 1.05 is insufficient when the BLOB is very small. compressedBlob = new Byte[(int)(inputLength * 1.05) + 16]; // Compress using LZFX algorithm. // This method resizes the compressed byte array for us. LZFX.Compress(uncompressedBlob, ref compressedBlob); return(compressedBlob); } if (compressionCode == 2) { Byte[] compressedBlob; // the byte-array length of the input blob int inputLength = uncompressedBlob.Length; // The byte array that will be created by the compression. // Note that some incompressible BLOBs might actually be made larger by LZ4 // compression. The GetMaxSize method calls a function built into LZ4 which // returns the maximum possible size of the output array. LZ4 documentation suggests // that speed is optimized by allocating this max size. compressedBlob = new Byte[(int)LZ4.GetMaxSize(inputLength)]; // Compress using LZ4 algorithm. // This method resizes the compressed byte array for us. LZ4.Compress(uncompressedBlob, ref compressedBlob, 4); return(compressedBlob); } else { // return without doing any compression return(uncompressedBlob); } }