static void CompressText(string text, string destinationFile, Lz4CompressionLevel level)
{
using (var writer = new FileStream(destinationFile, FileMode.Create))
using (var lz4Stream = new LZ4Stream(writer, CompressionMode.Compress, Lz4CompressionLevel.Fastest))
{
var lineBytes = Encoding.ASCII.GetBytes(text);
lz4Stream.Write(lineBytes, 0, lineBytes.Length);
}
}
static void CompressText(string text, string destinationFile, Lz4CompressionLevel level)
{
using (var writer = new FileStream(destinationFile, FileMode.Create))
using (var lz4Stream = new LZ4Stream(writer, CompressionMode.Compress, Lz4CompressionLevel.Fastest))
{
var lineBytes = Encoding.ASCII.GetBytes(text);
lz4Stream.Write(lineBytes, 0, lineBytes.Length);
}
}
public void Lz4_Lz4CompressionLevel()
{
// Constructors
var level = new Lz4CompressionLevel(5);
Assert.AreEqual(5, level);
level = new Lz4CompressionLevel(CompressionLevel.Fastest);
Assert.AreEqual(1, level);
level = new Lz4CompressionLevel(CompressionLevel.Optimal);
Assert.AreEqual(9, level);
try { level = new Lz4CompressionLevel(CompressionLevel.NoCompression); Assert.Fail("Constructor should have thrown an exception"); }
catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentOutOfRangeException)); }
try { level = new Lz4CompressionLevel(-1); Assert.Fail("Constructor should have thrown an exception"); }
catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentOutOfRangeException)); }
try { level = new Lz4CompressionLevel(17); Assert.Fail("Constructor should have thrown an exception"); }
catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentOutOfRangeException)); }
try { level = new Lz4CompressionLevel((CompressionLevel)99); Assert.Fail("Constructor should have thrown an exception"); }
catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentOutOfRangeException)); }
// Implicit conversion
level = 8;
Assert.AreEqual(8, level);
// Equality
Assert.IsTrue(new Lz4CompressionLevel(8) == level);
Assert.IsFalse(new Lz4CompressionLevel(1) == level);
Assert.IsTrue(new Lz4CompressionLevel(3) != level);
Assert.IsFalse(new Lz4CompressionLevel(8) != level);
object o = new Lz4CompressionLevel(2);
Assert.IsTrue(o.Equals(new Lz4CompressionLevel(2)));
Assert.IsFalse(o.Equals(new Lz4CompressionLevel(9)));
Assert.IsTrue(new Lz4CompressionLevel(2).Equals(new Lz4CompressionLevel(2)));
Assert.IsFalse(new Lz4CompressionLevel(8).Equals(new Lz4CompressionLevel(2)));
Assert.IsFalse(o.Equals(null));
Assert.IsFalse(o.Equals(new GzipMemoryUsageLevel(3)));
// HashCode
int hash = new Lz4CompressionLevel(CompressionLevel.Fastest).GetHashCode();
Assert.AreNotEqual(0, hash);
// ToString
string s = new Lz4CompressionLevel(9).ToString();
Assert.IsFalse(String.IsNullOrEmpty(s));
}
static void CompressFile(string sourceFile, string destinationFile, Lz4CompressionLevel level)
{
using (var writer = new FileStream(destinationFile, FileMode.Create))
using (var sourceStream = new FileStream(sourceFile, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var reader = new StreamReader(sourceStream))
using (var lz4Stream = new LZ4Stream(writer, CompressionMode.Compress, Lz4CompressionLevel.Fastest))
{
var allContent = reader.ReadToEnd();
var allContentBytes = Encoding.ASCII.GetBytes(allContent);
lz4Stream.Write(allContentBytes, 0, allContentBytes.Length);
}
}
static void CompressFile(string sourceFile, string destinationFile, Lz4CompressionLevel level)
{
using (var writer = new FileStream(destinationFile, FileMode.Create))
using (var sourceStream = new FileStream(sourceFile, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var reader = new StreamReader(sourceStream))
using (var lz4Stream = new LZ4Stream(writer, CompressionMode.Compress, Lz4CompressionLevel.Fastest))
{
var allContent = reader.ReadToEnd();
var allContentBytes = Encoding.ASCII.GetBytes(allContent);
lz4Stream.Write(allContentBytes, 0, allContentBytes.Length);
}
}
private static void CompressWithLZ4EXE(string uncompressed, string compressed, Lz4CompressionLevel level)
{
var psi = new ProcessStartInfo {
FileName = Lz4ExePath,
CreateNoWindow = true,
Arguments = $"-f -{(int) level} {uncompressed} {compressed}",
UseShellExecute = false,
};
var p = Process.Start(psi);
p.WaitForExit();
if (p.ExitCode != 0)
throw new Exception($"lz4 executable failed with error {p.ExitCode}");
}
public void DecompressionWithFixedBufferSize(
[Values(4 * KB, 400 * KB, 4 * MB, 16 * MB)] int size,
[Values(4 * KB, 400 * KB, 4 * MB, 16 * MB)] int bufferSize,
[Values(Lz4CompressionLevel.Fastest, Lz4CompressionLevel.Best)] Lz4CompressionLevel level
)
{
var uncompressedFile = PrepareFileWithRandomGarbage(size);
var compressedFile = AddExt(uncompressedFile, ".lz4");
var testManagedFile = AddExt(uncompressedFile, ".testmanaged");
CompressWithLZ4EXE(uncompressedFile, compressedFile, level);
UncompressWithLZ4Stream(compressedFile, testManagedFile, () => bufferSize, bufferSize);
FileCompare(uncompressedFile, testManagedFile);
}
public void DecompressionWithRandomBufferSize(
[Values(4 * KB, 400 * KB, 4 * MB, 8 * MB)] int size,
[Values(111, 222, 333, 444, 555, 666, 777, 888, 999)] int bufferSizeSeed,
[Values(Lz4CompressionLevel.Fastest, Lz4CompressionLevel.Best)] Lz4CompressionLevel level
)
{
var uncompressedFile = PrepareFileWithRandomGarbage(size);
var compressedFile = AddExt(uncompressedFile, ".lz4");
var testManagedFile = AddExt(uncompressedFile, ".testmanaged");
var r = new Random(bufferSizeSeed);
CompressWithLZ4EXE(uncompressedFile, compressedFile, level);
UncompressWithLZ4Stream(compressedFile, testManagedFile, () => r.Next(1, size), size);
FileCompare(uncompressedFile, testManagedFile);
}
private static void CompressWithLZ4EXE(string uncompressed, string compressed, Lz4CompressionLevel level)
{
var psi = new ProcessStartInfo {
FileName = Lz4ExePath,
CreateNoWindow = true,
Arguments = $"-f -{(int) level} {uncompressed} {compressed}",
UseShellExecute = false,
};
var p = Process.Start(psi);
p.WaitForExit();
if (p.ExitCode != 0)
{
throw new Exception($"lz4 executable failed with error {p.ExitCode}");
}
}
private static void CompressWithLZ4Stream(string uncompressedFile, string compressedFile, Func <int> bufferSizeGenerator, int bufferSize, Lz4CompressionLevel level)
{
using (var us = File.OpenRead(uncompressedFile))
using (var cs = File.OpenWrite(compressedFile))
using (var lz4s = new LZ4Stream(cs, CompressionMode.Compress, level))
{
us.CopyToWithBufferSizeGenerator(lz4s, bufferSizeGenerator, bufferSize);
}
}
//readonly unsafe LZ4Preferences* _prefs;
#endregion Private Members
#region Ctor
/// <summary>
/// Initializes a new instance of the <see cref="LZ4Stream"/> class.
/// </summary>
/// <param name="baseStream">The base stream.</param>
/// <param name="mode">The compression mode</param>
/// <param name="level">The compression level. Relevant for <see cref="CompressionMode.Compress"/></param>
/// <param name="blockSize">Size of the block.</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="LZ4Exception">
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">mode</exception>
/// <exception cref="OutOfMemoryException">There is insufficient memory to satisfy the request.</exception>
/// <exception cref="ArgumentException">Steam compression mode contradicts base-stream read/write availability</exception>
public unsafe LZ4Stream(Stream baseStream, CompressionMode mode, Lz4CompressionLevel level = Lz4CompressionLevel.Fastest, LZ4BlockSize blockSize = LZ4BlockSize.Max4Mb)
{
if (baseStream == null) throw new ArgumentNullException(nameof(baseStream));
if (mode == CompressionMode.Compress && !baseStream.CanWrite)
throw new ArgumentException("stream is set to compress, but base-stream cannot be written to", nameof(baseStream));
if (mode == CompressionMode.Decompress && !baseStream.CanRead)
throw new ArgumentException("stream is set to decompress, but base-stream cannot be read from", nameof(baseStream));
Contract.EndContractBlock();
_baseStream = baseStream;
_mode = mode;
void* ctx;
size_t rc;
switch (mode) {
case CompressionMode.Compress:
rc = LZ4F_createCompressionContext(&ctx, Lz4Version);
_ctx = ctx;
if (LZ4F_isError(rc))
throw new LZ4Exception(rc);
LZ4Preferences prefs;
prefs.AutoFlush = Lz4AutoFlush.Enabled;
prefs.CompressionLevel = level;
prefs.FrameInfo.BlockMode = LZ4BlockMode.Independent;
prefs.FrameInfo.BlockSize = blockSize;
prefs.FrameInfo.ContentChecksum = LZ4ContentChecksum.Enabled;
MaxInputBufferSize = GetBlockSize(blockSize);
_dstBuffer = new NativeBuffer(LZ4F_compressFrameBound((IntPtr) MaxInputBufferSize).ToInt32());
var headerSize = LZ4F_compressBegin(_ctx, _dstBuffer.Ptr, (IntPtr) _dstBuffer.Size, &prefs);
if (LZ4F_isError(headerSize))
throw new LZ4Exception(headerSize,
$"File header generation failed: {GetErrorName(headerSize)}");
_baseStream.Write(_dstBuffer.Buffer, 0, headerSize.ToInt32());
break;
case CompressionMode.Decompress:
rc = LZ4F_createDecompressionContext(&ctx, Lz4Version);
_ctx = ctx;
if (LZ4F_isError(rc))
throw new LZ4Exception(rc);
_srcBuffer = new NativeBuffer(DECOMPRESSION_BUFFER_SIZE);
baseStream.Read(_srcBuffer.Buffer, 0, sizeof (int));
var outSize = 0UL;
var inSize = (ulong) sizeof (int);
var frameHeader = stackalloc byte[MAX_FRAME_HEADER_SIZE];
rc = LZ4F_decompress(_ctx, frameHeader, (IntPtr*) &outSize, _srcBuffer.Ptr, (IntPtr*) &inSize);
if (LZ4F_isError(rc))
throw new LZ4Exception(rc);
_nextSizeToRead = (ulong) rc;
break;
default:
throw new ArgumentOutOfRangeException(nameof(mode), $"Unsupported mode: {mode}");
}
}
private static void CompressWithLZ4Stream(string uncompressedFile, string compressedFile, Func<int> bufferSizeGenerator, int bufferSize, Lz4CompressionLevel level)
{
using (var us = File.OpenRead(uncompressedFile))
using (var cs = File.OpenWrite(compressedFile))
using (var lz4s = new LZ4Stream(cs, CompressionMode.Compress, level))
{
us.CopyToWithBufferSizeGenerator(lz4s, bufferSizeGenerator, bufferSize);
}
}
//readonly unsafe LZ4Preferences* _prefs;
#endregion Private Members
#region Ctor
/// <summary>
/// Initializes a new instance of the <see cref="LZ4Stream"/> class.
/// </summary>
/// <param name="baseStream">The base stream.</param>
/// <param name="mode">The compression mode</param>
/// <param name="level">The compression level. Relevant for <see cref="CompressionMode.Compress"/></param>
/// <param name="blockSize">Size of the block.</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="LZ4Exception">
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">mode</exception>
/// <exception cref="OutOfMemoryException">There is insufficient memory to satisfy the request.</exception>
/// <exception cref="ArgumentException">Steam compression mode contradicts base-stream read/write availability</exception>
public unsafe LZ4Stream(Stream baseStream, CompressionMode mode, Lz4CompressionLevel level = Lz4CompressionLevel.Fastest, LZ4BlockSize blockSize = LZ4BlockSize.Max4Mb)
{
if (baseStream == null)
{
throw new ArgumentNullException(nameof(baseStream));
}
if (mode == CompressionMode.Compress && !baseStream.CanWrite)
{
throw new ArgumentException("stream is set to compress, but base-stream cannot be written to", nameof(baseStream));
}
if (mode == CompressionMode.Decompress && !baseStream.CanRead)
{
throw new ArgumentException("stream is set to decompress, but base-stream cannot be read from", nameof(baseStream));
}
Contract.EndContractBlock();
_baseStream = baseStream;
_mode = mode;
void * ctx;
size_t rc;
switch (mode)
{
case CompressionMode.Compress:
rc = LZ4F_createCompressionContext(&ctx, Lz4Version);
_ctx = ctx;
if (LZ4F_isError(rc))
{
throw new LZ4Exception(rc);
}
LZ4Preferences prefs;
prefs.AutoFlush = Lz4AutoFlush.Enabled;
prefs.CompressionLevel = level;
prefs.FrameInfo.BlockMode = LZ4BlockMode.Independent;
prefs.FrameInfo.BlockSize = blockSize;
prefs.FrameInfo.ContentChecksum = LZ4ContentChecksum.Enabled;
MaxInputBufferSize = GetBlockSize(blockSize);
_dstBuffer = new NativeBuffer(LZ4F_compressFrameBound((IntPtr)MaxInputBufferSize).ToInt32());
var headerSize = LZ4F_compressBegin(_ctx, _dstBuffer.Ptr, (IntPtr)_dstBuffer.Size, &prefs);
if (LZ4F_isError(headerSize))
{
throw new LZ4Exception(headerSize,
$"File header generation failed: {GetErrorName(headerSize)}");
}
_baseStream.Write(_dstBuffer.Buffer, 0, headerSize.ToInt32());
break;
case CompressionMode.Decompress:
rc = LZ4F_createDecompressionContext(&ctx, Lz4Version);
_ctx = ctx;
if (LZ4F_isError(rc))
{
throw new LZ4Exception(rc);
}
_srcBuffer = new NativeBuffer(DECOMPRESSION_BUFFER_SIZE);
baseStream.Read(_srcBuffer.Buffer, 0, sizeof(int));
var outSize = 0UL;
var inSize = (ulong)sizeof(int);
var frameHeader = stackalloc byte[MAX_FRAME_HEADER_SIZE];
rc = LZ4F_decompress(_ctx, frameHeader, (IntPtr *)&outSize, _srcBuffer.Ptr, (IntPtr *)&inSize);
if (LZ4F_isError(rc))
{
throw new LZ4Exception(rc);
}
_nextSizeToRead = (ulong)rc;
break;
default:
throw new ArgumentOutOfRangeException(nameof(mode), $"Unsupported mode: {mode}");
}
}