internal ZLibRet DeflateInit(ZStreamL32 strm, ZLibCompLevel level, int windowBits, ZLibMemLevel memLevel)
{
string zlibVer = Lib.ZLibVersion();
return(DeflateInit2(strm, level, ZLibCompMethod.Deflated, windowBits, memLevel,
ZLibCompStrategy.Default, zlibVer, Marshal.SizeOf <ZStreamL32>()));
}
public DeflateStream(Stream stream, ZLibMode mode, ZLibCompLevel level, bool leaveOpen)
{
NativeMethods.CheckZLibLoaded();
_zstream = new ZStream();
_zstreamPtr = GCHandle.Alloc(_zstream, GCHandleType.Pinned);
_leaveOpen = leaveOpen;
_baseStream = stream;
_mode = mode;
_internalBufPos = 0;
Debug.Assert(0 < NativeMethods.BufferSize, "Internal Logic Error at DeflateStream");
_internalBuf = new byte[NativeMethods.BufferSize];
ZLibReturnCode ret;
if (_mode == ZLibMode.Compress)
{
ret = NativeMethods.DeflateInit(_zstream, level, WriteType);
}
else
{
ret = NativeMethods.InflateInit(_zstream, OpenType);
}
ZLibException.CheckZLibOK(ret, _zstream);
}
public ZLibStream(Stream stream, ZLibMode mode, ZLibCompLevel level, bool leaveOpen = false)
{
BaseStream = stream;
_zstream = new ZStream();
_zstreamPtr = GCHandle.Alloc(_zstream, GCHandleType.Pinned);
_leaveOpen = leaveOpen;
_mode = mode;
_internalBufPos = 0;
_internalBuf = new byte[BufferSize];
ZLibReturnCode ret;
if (_mode == ZLibMode.Compress)
{
ret = ZLibNative.DeflateInit(_zstream, level, _writeType);
}
else
{
ret = ZLibNative.InflateInit(_zstream, _openType);
}
if (ret != ZLibReturnCode.OK)
{
throw new Exception(ret + " " + _zstream.LastErrorMsg);
}
}
public static MemoryStream Compress(CreateStreamDelegate sc, Stream source, ZLibCompLevel level = ZLibCompLevel.Default)
{
MemoryStream result = new MemoryStream();
Compress(sc, source, result, level);
result.Position = 0;
return(result);
}
public static byte[] Compress(CreateStreamDelegate sc, byte[] source, ZLibCompLevel level = ZLibCompLevel.Default)
{
using (MemoryStream srcStream = new MemoryStream(source))
using (MemoryStream dstStream = Compress(sc, srcStream, level))
{
return(dstStream.ToArray());
}
}
internal static extern ZLibReturnCode DeflateInit2(
ZStream strm,
ZLibCompLevel level,
ZLibCompMethod method,
ZLibWriteType windowBits,
int memLevel,
ZLibCompressionStrategy strategy,
[MarshalAs(UnmanagedType.LPStr)] string version,
int stream_size);
private static void CompressTemplate(string sampleFileName, ZLibCompLevel level, bool useSpan)
{
string filePath = Path.Combine(TestSetup.SampleDir, sampleFileName);
ZLibCompressOptions compOpts = new ZLibCompressOptions()
{
Level = level,
LeaveOpen = true,
};
using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (MemoryStream compMs = new MemoryStream())
using (MemoryStream decompMs = new MemoryStream())
{
using (DeflateStream zs = new DeflateStream(compMs, compOpts))
{
#if !NETFRAMEWORK
if (useSpan)
{
byte[] buffer = new byte[64 * 1024];
int bytesRead;
do
{
bytesRead = fs.Read(buffer.AsSpan());
zs.Write(buffer.AsSpan(0, bytesRead));
} while (0 < bytesRead);
}
else
#endif
{
fs.CopyTo(zs);
}
}
fs.Position = 0;
compMs.Position = 0;
// Decompress compMs with BCL DeflateStream
using (System.IO.Compression.DeflateStream zs = new System.IO.Compression.DeflateStream(compMs, CompressionMode.Decompress, true))
{
zs.CopyTo(decompMs);
}
decompMs.Position = 0;
// Compare SHA256 Digest
byte[] decompDigest = TestHelper.SHA256Digest(decompMs);
byte[] fileDigest = TestHelper.SHA256Digest(fs);
Assert.IsTrue(decompDigest.SequenceEqual(fileDigest));
}
}
public ZLibStream(Stream stream, ZLibMode mode, ZLibCompLevel level, ZLibOpenType openType, bool leaveOpen = false) : this(stream, mode, level, leaveOpen)
{
_openType = openType;
}
public ZLibStream(Stream stream, ZLibMode mode, ZLibCompLevel level, ZLibWriteType writeType, bool leaveOpen = false) : this(stream, mode, level, leaveOpen)
{
_writeType = writeType;
}
public static MemoryStream Compress(Stream source, ZLibCompLevel level = ZLibCompLevel.Default)
{
return(CommonCompressor.Compress(CreateStream, source, level));
}
private static DeflateStream CreateStream(Stream s, ZLibMode mode, ZLibCompLevel level, bool leaveOpen)
{
return(new ZLibStream(s, mode, level, leaveOpen));
}
public static byte[] Compress(byte[] source, ZLibCompLevel level = ZLibCompLevel.Default)
{
return(CommonCompressor.Compress(CreateStream, source, level));
}
private static void Compress(CreateStreamDelegate sc, Stream source, Stream dest, ZLibCompLevel level)
{
using (DeflateStream zsDest = sc(dest, ZLibMode.Compress, level, true))
{
source.CopyTo(zsDest);
}
}
public ZLibMPQStream(Stream stream, ZLibMode mode, ZLibCompLevel level, bool leaveOpen) :
base(stream, mode, level, leaveOpen)
{
}
public ZLibMPQStream(Stream stream, ZLibMode mode, ZLibCompLevel level) :
base(stream, mode, level)
{
}
internal static ZLibReturnCode DeflateInit(ZStream stream, ZLibCompLevel level, ZLibWriteType windowBits)
{
return(DeflateInit2(stream, level, ZLibCompMethod.DEFLATED, windowBits, DEF_MEM_LEVEL, ZLibCompressionStrategy.DEFAULT_STRATEGY, ZLIB_VERSION, Marshal.SizeOf(typeof(ZStream))));
}
private static void CompressTemplate(string sampleFileName, ZLibCompLevel level, bool useSpan)
{
string tempDecompFile = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
string tempArchiveFile = tempDecompFile + ".zz";
try
{
ZLibCompressOptions compOpts = new ZLibCompressOptions()
{
Level = level,
LeaveOpen = true,
};
string sampleFile = Path.Combine(TestSetup.SampleDir, sampleFileName);
using (FileStream sampleFs = new FileStream(sampleFile, FileMode.Open, FileAccess.Read, FileShare.Read))
using (FileStream archiveFs = new FileStream(tempArchiveFile, FileMode.Create, FileAccess.Write, FileShare.None))
using (ZLibStream zs = new ZLibStream(archiveFs, compOpts))
{
#if !NETFRAMEWORK
if (useSpan)
{
byte[] buffer = new byte[64 * 1024];
int bytesRead;
do
{
bytesRead = sampleFs.Read(buffer.AsSpan());
zs.Write(buffer.AsSpan(0, bytesRead));
} while (0 < bytesRead);
}
else
#endif
{
sampleFs.CopyTo(zs);
}
zs.Flush();
Assert.AreEqual(sampleFs.Length, zs.TotalIn);
Assert.AreEqual(archiveFs.Length, zs.TotalOut);
}
int ret = TestHelper.RunPigz(tempArchiveFile);
Assert.IsTrue(ret == 0);
byte[] decompDigest;
byte[] originDigest;
using (FileStream fs = new FileStream(sampleFile, FileMode.Open, FileAccess.Read, FileShare.Read))
{
originDigest = TestHelper.SHA256Digest(fs);
}
using (FileStream fs = new FileStream(tempDecompFile, FileMode.Open, FileAccess.Read, FileShare.Read))
{
decompDigest = TestHelper.SHA256Digest(fs);
}
Assert.IsTrue(originDigest.SequenceEqual(decompDigest));
}
finally
{
if (File.Exists(tempArchiveFile))
{
File.Delete(tempArchiveFile);
}
if (File.Exists(tempDecompFile))
{
File.Delete(tempDecompFile);
}
}
}
public DeflateStream(Stream stream, ZLibMode mode, ZLibCompLevel level) :
this(stream, mode, level, false)
{
}
