From 0ac6b4637935ba5ffe40256684dcff5cd1e76da0 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 26 Nov 2025 08:12:38 +0000 Subject: [PATCH 1/9] Initial plan From ac4bcd0fe3ad45a014a7035c14b15f4073663190 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 26 Nov 2025 08:23:29 +0000 Subject: [PATCH 2/9] Add SOZip index data structure and basic tests Co-authored-by: adamhathcock <527620+adamhathcock@users.noreply.github.com> --- .../Headers/LocalEntryHeaderExtraFactory.cs | 43 ++ .../Common/Zip/SOZip/SOZipDeflateStream.cs | 154 ++++++++ .../Common/Zip/SOZip/SOZipIndex.cs | 369 ++++++++++++++++++ .../Writers/Zip/ZipWriterEntryOptions.cs | 7 + .../Writers/Zip/ZipWriterOptions.cs | 27 ++ tests/SharpCompress.Test/Zip/SOZipTests.cs | 135 +++++++ 6 files changed, 735 insertions(+) create mode 100644 src/SharpCompress/Common/Zip/SOZip/SOZipDeflateStream.cs create mode 100644 src/SharpCompress/Common/Zip/SOZip/SOZipIndex.cs create mode 100644 tests/SharpCompress.Test/Zip/SOZipTests.cs diff --git a/src/SharpCompress/Common/Zip/Headers/LocalEntryHeaderExtraFactory.cs b/src/SharpCompress/Common/Zip/Headers/LocalEntryHeaderExtraFactory.cs index daedd9a6d..d9067d9cc 100644 --- a/src/SharpCompress/Common/Zip/Headers/LocalEntryHeaderExtraFactory.cs +++ b/src/SharpCompress/Common/Zip/Headers/LocalEntryHeaderExtraFactory.cs @@ -15,6 +15,10 @@ internal enum ExtraDataType : ushort UnicodePathExtraField = 0x7075, Zip64ExtendedInformationExtraField = 0x0001, UnixTimeExtraField = 0x5455, + + // SOZip (Seek-Optimized ZIP) extra field + // Used to link a main file to its SOZip index file + SOZip = 0x564B, } internal class ExtraData @@ -233,6 +237,44 @@ private enum RecordedTimeFlag } } +/// +/// SOZip (Seek-Optimized ZIP) extra field that links a main file to its index file. +/// The extra field contains the offset within the ZIP file where the index entry's +/// local header is located. +/// +internal sealed class SOZipExtraField : ExtraData +{ + public SOZipExtraField(ExtraDataType type, ushort length, byte[] dataBytes) + : base(type, length, dataBytes) { } + + /// + /// Gets the offset to the SOZip index file's local entry header within the ZIP archive. + /// + internal ulong IndexOffset + { + get + { + if (DataBytes is null || DataBytes.Length < 8) + { + return 0; + } + return BinaryPrimitives.ReadUInt64LittleEndian(DataBytes); + } + } + + /// + /// Creates a SOZip extra field with the specified index offset + /// + /// The offset to the index file's local entry header + /// A new SOZipExtraField instance + public static SOZipExtraField Create(ulong indexOffset) + { + var data = new byte[8]; + BinaryPrimitives.WriteUInt64LittleEndian(data, indexOffset); + return new SOZipExtraField(ExtraDataType.SOZip, 8, data); + } +} + internal static class LocalEntryHeaderExtraFactory { internal static ExtraData Create(ExtraDataType type, ushort length, byte[] extraData) => @@ -246,6 +288,7 @@ internal static ExtraData Create(ExtraDataType type, ushort length, byte[] extra ExtraDataType.Zip64ExtendedInformationExtraField => new Zip64ExtendedInformationExtraField(type, length, extraData), ExtraDataType.UnixTimeExtraField => new UnixTimeExtraField(type, length, extraData), + ExtraDataType.SOZip => new SOZipExtraField(type, length, extraData), _ => new ExtraData(type, length, extraData), }; } diff --git a/src/SharpCompress/Common/Zip/SOZip/SOZipDeflateStream.cs b/src/SharpCompress/Common/Zip/SOZip/SOZipDeflateStream.cs new file mode 100644 index 000000000..5b564db82 --- /dev/null +++ b/src/SharpCompress/Common/Zip/SOZip/SOZipDeflateStream.cs @@ -0,0 +1,154 @@ +using System; +using System.Collections.Generic; +using System.IO; +using SharpCompress.Compressors; +using SharpCompress.Compressors.Deflate; + +namespace SharpCompress.Common.Zip.SOZip; + +/// +/// A Deflate stream that inserts sync flush points at regular intervals +/// to enable random access (SOZip optimization). +/// +internal sealed class SOZipDeflateStream : Stream +{ + private readonly DeflateStream _deflateStream; + private readonly Stream _baseStream; + private readonly uint _chunkSize; + private readonly List _compressedOffsets = new(); + private readonly long _baseOffset; + private long _uncompressedBytesWritten; + private long _nextSyncPoint; + private bool _disposed; + + /// + /// Creates a new SOZip Deflate stream + /// + /// The underlying stream to write to + /// The compression level + /// The chunk size for sync flush points + public SOZipDeflateStream(Stream baseStream, CompressionLevel compressionLevel, int chunkSize) + { + _baseStream = baseStream; + _chunkSize = (uint)chunkSize; + _baseOffset = baseStream.Position; + _nextSyncPoint = chunkSize; + + // Record the first offset (start of compressed data) + _compressedOffsets.Add(0); + + _deflateStream = new DeflateStream( + baseStream, + CompressionMode.Compress, + compressionLevel + ); + } + + /// + /// Gets the array of compressed offsets recorded during writing + /// + public ulong[] CompressedOffsets => _compressedOffsets.ToArray(); + + /// + /// Gets the total number of uncompressed bytes written + /// + public ulong UncompressedBytesWritten => (ulong)_uncompressedBytesWritten; + + /// + /// Gets the total number of compressed bytes written + /// + public ulong CompressedBytesWritten => (ulong)(_baseStream.Position - _baseOffset); + + /// + /// Gets the chunk size being used + /// + public uint ChunkSize => _chunkSize; + + public override bool CanRead => false; + + public override bool CanSeek => false; + + public override bool CanWrite => !_disposed && _deflateStream.CanWrite; + + public override long Length => throw new NotSupportedException(); + + public override long Position + { + get => throw new NotSupportedException(); + set => throw new NotSupportedException(); + } + + public override void Flush() => _deflateStream.Flush(); + + public override int Read(byte[] buffer, int offset, int count) => + throw new NotSupportedException(); + + public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException(); + + public override void SetLength(long value) => throw new NotSupportedException(); + + public override void Write(byte[] buffer, int offset, int count) + { + if (_disposed) + { + throw new ObjectDisposedException(nameof(SOZipDeflateStream)); + } + + var remaining = count; + var currentOffset = offset; + + while (remaining > 0) + { + // Calculate how many bytes until the next sync point + var bytesUntilSync = (int)(_nextSyncPoint - _uncompressedBytesWritten); + + if (bytesUntilSync <= 0) + { + // We've reached a sync point - perform sync flush + PerformSyncFlush(); + continue; + } + + // Write up to the next sync point + var bytesToWrite = Math.Min(remaining, bytesUntilSync); + _deflateStream.Write(buffer, currentOffset, bytesToWrite); + + _uncompressedBytesWritten += bytesToWrite; + currentOffset += bytesToWrite; + remaining -= bytesToWrite; + } + } + + private void PerformSyncFlush() + { + // Flush with Z_SYNC_FLUSH to create an independent block + var originalFlushMode = _deflateStream.FlushMode; + _deflateStream.FlushMode = FlushType.Sync; + _deflateStream.Flush(); + _deflateStream.FlushMode = originalFlushMode; + + // Record the compressed offset for this sync point + var compressedOffset = (ulong)(_baseStream.Position - _baseOffset); + _compressedOffsets.Add(compressedOffset); + + // Set the next sync point + _nextSyncPoint += _chunkSize; + } + + protected override void Dispose(bool disposing) + { + if (_disposed) + { + return; + } + + _disposed = true; + + if (disposing) + { + _deflateStream.Dispose(); + } + + base.Dispose(disposing); + } +} diff --git a/src/SharpCompress/Common/Zip/SOZip/SOZipIndex.cs b/src/SharpCompress/Common/Zip/SOZip/SOZipIndex.cs new file mode 100644 index 000000000..22a119c33 --- /dev/null +++ b/src/SharpCompress/Common/Zip/SOZip/SOZipIndex.cs @@ -0,0 +1,369 @@ +using System; +using System.Buffers.Binary; +using System.IO; + +namespace SharpCompress.Common.Zip.SOZip; + +/// +/// Represents a SOZip (Seek-Optimized ZIP) index that enables random access +/// within DEFLATE-compressed files by storing offsets to sync flush points. +/// +/// +/// SOZip index files (.sozip.idx) contain a header followed by offset entries +/// that point to the beginning of independently decompressable DEFLATE blocks. +/// +[CLSCompliant(false)] +public sealed class SOZipIndex +{ + /// + /// SOZip index file magic number: "SOZo" (0x534F5A6F) + /// + public const uint SOZIP_MAGIC = 0x6F5A4F53; // "SOZo" little-endian + + /// + /// Current SOZip specification version + /// + public const byte SOZIP_VERSION = 1; + + /// + /// Index file extension suffix + /// + public const string INDEX_EXTENSION = ".sozip.idx"; + + /// + /// Default chunk size in bytes (32KB) + /// + public const uint DEFAULT_CHUNK_SIZE = 32768; + + /// + /// The version of the SOZip index format + /// + public byte Version { get; private set; } + + /// + /// Size of each uncompressed chunk in bytes + /// + public uint ChunkSize { get; private set; } + + /// + /// Total uncompressed size of the file + /// + public ulong UncompressedSize { get; private set; } + + /// + /// Total compressed size of the file + /// + public ulong CompressedSize { get; private set; } + + /// + /// Number of offset entries in the index + /// + public uint OffsetCount { get; private set; } + + /// + /// Array of compressed offsets for each chunk + /// + public ulong[] CompressedOffsets { get; private set; } = Array.Empty(); + + /// + /// Creates a new empty SOZip index + /// + public SOZipIndex() { } + + /// + /// Creates a new SOZip index with specified parameters + /// + /// Size of each uncompressed chunk + /// Total uncompressed size + /// Total compressed size + /// Array of compressed offsets + public SOZipIndex( + uint chunkSize, + ulong uncompressedSize, + ulong compressedSize, + ulong[] compressedOffsets + ) + { + Version = SOZIP_VERSION; + ChunkSize = chunkSize; + UncompressedSize = uncompressedSize; + CompressedSize = compressedSize; + OffsetCount = (uint)compressedOffsets.Length; + CompressedOffsets = compressedOffsets; + } + + /// + /// Reads a SOZip index from a stream + /// + /// The stream containing the index data + /// A parsed SOZipIndex instance + /// If the stream doesn't contain valid SOZip index data + public static SOZipIndex Read(Stream stream) + { + var index = new SOZipIndex(); + Span header = stackalloc byte[4]; + + // Read magic number + if (stream.Read(header) != 4) + { + throw new InvalidDataException("Invalid SOZip index: unable to read magic number"); + } + + var magic = BinaryPrimitives.ReadUInt32LittleEndian(header); + if (magic != SOZIP_MAGIC) + { + throw new InvalidDataException( + $"Invalid SOZip index: magic number mismatch (expected 0x{SOZIP_MAGIC:X8}, got 0x{magic:X8})" + ); + } + + // Read version + var versionByte = stream.ReadByte(); + if (versionByte < 0) + { + throw new InvalidDataException("Invalid SOZip index: unable to read version"); + } + index.Version = (byte)versionByte; + + if (index.Version != SOZIP_VERSION) + { + throw new InvalidDataException( + $"Unsupported SOZip index version: {index.Version} (expected {SOZIP_VERSION})" + ); + } + + // Read reserved byte (padding) + stream.ReadByte(); + + // Read chunk size (2 bytes) + Span buf2 = stackalloc byte[2]; + if (stream.Read(buf2) != 2) + { + throw new InvalidDataException("Invalid SOZip index: unable to read chunk size"); + } + + // Chunk size is stored as (actual_size / 1024) - 1 + var chunkSizeEncoded = BinaryPrimitives.ReadUInt16LittleEndian(buf2); + index.ChunkSize = ((uint)chunkSizeEncoded + 1) * 1024; + + // Read uncompressed size (8 bytes) + Span buf8 = stackalloc byte[8]; + if (stream.Read(buf8) != 8) + { + throw new InvalidDataException( + "Invalid SOZip index: unable to read uncompressed size" + ); + } + index.UncompressedSize = BinaryPrimitives.ReadUInt64LittleEndian(buf8); + + // Read compressed size (8 bytes) + if (stream.Read(buf8) != 8) + { + throw new InvalidDataException("Invalid SOZip index: unable to read compressed size"); + } + index.CompressedSize = BinaryPrimitives.ReadUInt64LittleEndian(buf8); + + // Read offset count (4 bytes) + if (stream.Read(header) != 4) + { + throw new InvalidDataException("Invalid SOZip index: unable to read offset count"); + } + index.OffsetCount = BinaryPrimitives.ReadUInt32LittleEndian(header); + + // Read offsets + index.CompressedOffsets = new ulong[index.OffsetCount]; + for (uint i = 0; i < index.OffsetCount; i++) + { + if (stream.Read(buf8) != 8) + { + throw new InvalidDataException($"Invalid SOZip index: unable to read offset {i}"); + } + index.CompressedOffsets[i] = BinaryPrimitives.ReadUInt64LittleEndian(buf8); + } + + return index; + } + + /// + /// Reads a SOZip index from a byte array + /// + /// The byte array containing the index data + /// A parsed SOZipIndex instance + public static SOZipIndex Read(byte[] data) + { + using var stream = new MemoryStream(data); + return Read(stream); + } + + /// + /// Writes this SOZip index to a stream + /// + /// The stream to write to + public void Write(Stream stream) + { + Span buf8 = stackalloc byte[8]; + + // Write magic number + BinaryPrimitives.WriteUInt32LittleEndian(buf8, SOZIP_MAGIC); + stream.Write(buf8.Slice(0, 4)); + + // Write version + stream.WriteByte(SOZIP_VERSION); + + // Write reserved byte (padding) + stream.WriteByte(0); + + // Write chunk size (encoded as (size/1024)-1) + var chunkSizeEncoded = (ushort)((ChunkSize / 1024) - 1); + BinaryPrimitives.WriteUInt16LittleEndian(buf8, chunkSizeEncoded); + stream.Write(buf8.Slice(0, 2)); + + // Write uncompressed size + BinaryPrimitives.WriteUInt64LittleEndian(buf8, UncompressedSize); + stream.Write(buf8); + + // Write compressed size + BinaryPrimitives.WriteUInt64LittleEndian(buf8, CompressedSize); + stream.Write(buf8); + + // Write offset count + BinaryPrimitives.WriteUInt32LittleEndian(buf8, OffsetCount); + stream.Write(buf8.Slice(0, 4)); + + // Write offsets + foreach (var offset in CompressedOffsets) + { + BinaryPrimitives.WriteUInt64LittleEndian(buf8, offset); + stream.Write(buf8); + } + } + + /// + /// Converts this SOZip index to a byte array + /// + /// Byte array containing the serialized index + public byte[] ToByteArray() + { + using var stream = new MemoryStream(); + Write(stream); + return stream.ToArray(); + } + + /// + /// Gets the index of the chunk that contains the specified uncompressed offset + /// + /// The uncompressed byte offset + /// The chunk index + public int GetChunkIndex(long uncompressedOffset) + { + if (uncompressedOffset < 0 || (ulong)uncompressedOffset >= UncompressedSize) + { + throw new ArgumentOutOfRangeException( + nameof(uncompressedOffset), + "Offset is out of range" + ); + } + + return (int)((ulong)uncompressedOffset / ChunkSize); + } + + /// + /// Gets the compressed offset for the specified chunk index + /// + /// The chunk index + /// The compressed byte offset for the start of the chunk + public ulong GetCompressedOffset(int chunkIndex) + { + if (chunkIndex < 0 || chunkIndex >= CompressedOffsets.Length) + { + throw new ArgumentOutOfRangeException( + nameof(chunkIndex), + "Chunk index is out of range" + ); + } + + return CompressedOffsets[chunkIndex]; + } + + /// + /// Gets the uncompressed offset for the start of the specified chunk + /// + /// The chunk index + /// The uncompressed byte offset for the start of the chunk + public ulong GetUncompressedOffset(int chunkIndex) + { + if (chunkIndex < 0 || chunkIndex >= CompressedOffsets.Length) + { + throw new ArgumentOutOfRangeException( + nameof(chunkIndex), + "Chunk index is out of range" + ); + } + + return (ulong)chunkIndex * ChunkSize; + } + + /// + /// Gets the name of the SOZip index file for a given entry name + /// + /// The main entry name + /// The index file name (hidden with .sozip.idx extension) + public static string GetIndexFileName(string entryName) + { + var directory = Path.GetDirectoryName(entryName); + var fileName = Path.GetFileName(entryName); + + // The index file is hidden (prefixed with .) + var indexFileName = $".{fileName}{INDEX_EXTENSION}"; + + if (string.IsNullOrEmpty(directory)) + { + return indexFileName; + } + + return Path.Combine(directory, indexFileName).Replace('\\', '/'); + } + + /// + /// Checks if a file name is a SOZip index file + /// + /// The file name to check + /// True if the file is a SOZip index file + public static bool IsIndexFile(string fileName) + { + if (string.IsNullOrEmpty(fileName)) + { + return false; + } + + var name = Path.GetFileName(fileName); + return name.StartsWith(".", StringComparison.Ordinal) + && name.EndsWith(INDEX_EXTENSION, StringComparison.OrdinalIgnoreCase); + } + + /// + /// Gets the main file name from a SOZip index file name + /// + /// The index file name + /// The main file name, or null if not a valid index file + public static string? GetMainFileName(string indexFileName) + { + if (!IsIndexFile(indexFileName)) + { + return null; + } + + var directory = Path.GetDirectoryName(indexFileName); + var name = Path.GetFileName(indexFileName); + + // Remove leading '.' and trailing '.sozip.idx' + var mainName = name.Substring(1, name.Length - 1 - INDEX_EXTENSION.Length); + + if (string.IsNullOrEmpty(directory)) + { + return mainName; + } + + return Path.Combine(directory, mainName).Replace('\\', '/'); + } +} diff --git a/src/SharpCompress/Writers/Zip/ZipWriterEntryOptions.cs b/src/SharpCompress/Writers/Zip/ZipWriterEntryOptions.cs index dcadb21c8..b41e86b13 100644 --- a/src/SharpCompress/Writers/Zip/ZipWriterEntryOptions.cs +++ b/src/SharpCompress/Writers/Zip/ZipWriterEntryOptions.cs @@ -49,4 +49,11 @@ public CompressionLevel? DeflateCompressionLevel /// This option is not supported with non-seekable streams. /// public bool? EnableZip64 { get; set; } + + /// + /// Enable or disable SOZip (Seek-Optimized ZIP) for this entry. + /// When null, uses the archive's default setting. + /// SOZip is only applicable to Deflate-compressed files on seekable streams. + /// + public bool? EnableSOZip { get; set; } } diff --git a/src/SharpCompress/Writers/Zip/ZipWriterOptions.cs b/src/SharpCompress/Writers/Zip/ZipWriterOptions.cs index 9aa80dd17..d99dbde4a 100644 --- a/src/SharpCompress/Writers/Zip/ZipWriterOptions.cs +++ b/src/SharpCompress/Writers/Zip/ZipWriterOptions.cs @@ -1,5 +1,6 @@ using System; using SharpCompress.Common; +using SharpCompress.Common.Zip.SOZip; using SharpCompress.Compressors.Deflate; using D = SharpCompress.Compressors.Deflate; @@ -24,6 +25,9 @@ internal ZipWriterOptions(WriterOptions options) { UseZip64 = writerOptions.UseZip64; ArchiveComment = writerOptions.ArchiveComment; + EnableSOZip = writerOptions.EnableSOZip; + SOZipChunkSize = writerOptions.SOZipChunkSize; + SOZipMinFileSize = writerOptions.SOZipMinFileSize; } } @@ -80,4 +84,27 @@ public CompressionLevel DeflateCompressionLevel /// are less than 4GiB in length. /// public bool UseZip64 { get; set; } + + /// + /// Enables SOZip (Seek-Optimized ZIP) for Deflate-compressed files. + /// When enabled, files that meet the minimum size requirement will have + /// an accompanying index file that allows random access within the + /// compressed data. Requires a seekable output stream. + /// + public bool EnableSOZip { get; set; } + + /// + /// The chunk size for SOZip index creation in bytes. + /// Must be a multiple of 1024 bytes. Default is 32KB (32768 bytes). + /// Smaller chunks allow for finer-grained random access but result + /// in larger index files and slightly less efficient compression. + /// + public int SOZipChunkSize { get; set; } = (int)SOZipIndex.DEFAULT_CHUNK_SIZE; + + /// + /// Minimum file size (uncompressed) in bytes for SOZip optimization. + /// Files smaller than this size will not have SOZip index files created. + /// Default is 1MB (1048576 bytes). + /// + public long SOZipMinFileSize { get; set; } = 1048576; } diff --git a/tests/SharpCompress.Test/Zip/SOZipTests.cs b/tests/SharpCompress.Test/Zip/SOZipTests.cs new file mode 100644 index 000000000..a53529bbd --- /dev/null +++ b/tests/SharpCompress.Test/Zip/SOZipTests.cs @@ -0,0 +1,135 @@ +using System; +using System.IO; +using SharpCompress.Common.Zip.SOZip; +using Xunit; + +namespace SharpCompress.Test.Zip; + +public class SOZipTests : TestBase +{ + [Fact] + public void SOZipIndex_RoundTrip() + { + // Create an index + var offsets = new ulong[] { 0, 1024, 2048, 3072 }; + var originalIndex = new SOZipIndex( + chunkSize: 32768, + uncompressedSize: 100000, + compressedSize: 50000, + compressedOffsets: offsets + ); + + // Serialize to bytes + var bytes = originalIndex.ToByteArray(); + + // Deserialize back + var parsedIndex = SOZipIndex.Read(bytes); + + // Verify all fields + Assert.Equal(SOZipIndex.SOZIP_VERSION, parsedIndex.Version); + Assert.Equal(32768u, parsedIndex.ChunkSize); + Assert.Equal(100000ul, parsedIndex.UncompressedSize); + Assert.Equal(50000ul, parsedIndex.CompressedSize); + Assert.Equal(4u, parsedIndex.OffsetCount); + Assert.Equal(offsets, parsedIndex.CompressedOffsets); + } + + [Fact] + public void SOZipIndex_Read_InvalidMagic_ThrowsException() + { + var invalidData = new byte[] { 0x00, 0x00, 0x00, 0x00 }; + + var exception = Assert.Throws( + () => SOZipIndex.Read(invalidData) + ); + + Assert.Contains("magic number mismatch", exception.Message); + } + + [Fact] + public void SOZipIndex_GetChunkIndex() + { + var offsets = new ulong[] { 0, 1000, 2000, 3000, 4000 }; + var index = new SOZipIndex( + chunkSize: 32768, + uncompressedSize: 163840, // 5 * 32768 + compressedSize: 5000, + compressedOffsets: offsets + ); + + Assert.Equal(0, index.GetChunkIndex(0)); + Assert.Equal(0, index.GetChunkIndex(32767)); + Assert.Equal(1, index.GetChunkIndex(32768)); + Assert.Equal(2, index.GetChunkIndex(65536)); + Assert.Equal(4, index.GetChunkIndex(163839)); + } + + [Fact] + public void SOZipIndex_GetCompressedOffset() + { + var offsets = new ulong[] { 0, 1000, 2000, 3000, 4000 }; + var index = new SOZipIndex( + chunkSize: 32768, + uncompressedSize: 163840, + compressedSize: 5000, + compressedOffsets: offsets + ); + + Assert.Equal(0ul, index.GetCompressedOffset(0)); + Assert.Equal(1000ul, index.GetCompressedOffset(1)); + Assert.Equal(2000ul, index.GetCompressedOffset(2)); + Assert.Equal(3000ul, index.GetCompressedOffset(3)); + Assert.Equal(4000ul, index.GetCompressedOffset(4)); + } + + [Fact] + public void SOZipIndex_GetUncompressedOffset() + { + var offsets = new ulong[] { 0, 1000, 2000, 3000, 4000 }; + var index = new SOZipIndex( + chunkSize: 32768, + uncompressedSize: 163840, + compressedSize: 5000, + compressedOffsets: offsets + ); + + Assert.Equal(0ul, index.GetUncompressedOffset(0)); + Assert.Equal(32768ul, index.GetUncompressedOffset(1)); + Assert.Equal(65536ul, index.GetUncompressedOffset(2)); + Assert.Equal(98304ul, index.GetUncompressedOffset(3)); + Assert.Equal(131072ul, index.GetUncompressedOffset(4)); + } + + [Fact] + public void SOZipIndex_GetIndexFileName() + { + Assert.Equal(".file.txt.sozip.idx", SOZipIndex.GetIndexFileName("file.txt")); + Assert.Equal("dir/.file.txt.sozip.idx", SOZipIndex.GetIndexFileName("dir/file.txt")); + Assert.Equal("a/b/.file.txt.sozip.idx", SOZipIndex.GetIndexFileName("a/b/file.txt")); + } + + [Fact] + public void SOZipIndex_IsIndexFile() + { + Assert.True(SOZipIndex.IsIndexFile(".file.txt.sozip.idx")); + Assert.True(SOZipIndex.IsIndexFile("dir/.file.txt.sozip.idx")); + Assert.True(SOZipIndex.IsIndexFile(".test.sozip.idx")); + + Assert.False(SOZipIndex.IsIndexFile("file.txt")); + Assert.False(SOZipIndex.IsIndexFile("file.sozip.idx")); // Missing leading dot + Assert.False(SOZipIndex.IsIndexFile(".file.txt")); // Missing .sozip.idx + Assert.False(SOZipIndex.IsIndexFile("")); + Assert.False(SOZipIndex.IsIndexFile(null!)); + } + + [Fact] + public void SOZipIndex_GetMainFileName() + { + Assert.Equal("file.txt", SOZipIndex.GetMainFileName(".file.txt.sozip.idx")); + Assert.Equal("dir/file.txt", SOZipIndex.GetMainFileName("dir/.file.txt.sozip.idx")); + Assert.Equal("test", SOZipIndex.GetMainFileName(".test.sozip.idx")); + + Assert.Null(SOZipIndex.GetMainFileName("file.txt")); + Assert.Null(SOZipIndex.GetMainFileName("")); + } +} From a35089900fb6142fa72fb2ea99c33e5aefc3247c Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 26 Nov 2025 08:27:16 +0000 Subject: [PATCH 3/9] Add SOZip detection in ZipEntry and additional tests Co-authored-by: adamhathcock <527620+adamhathcock@users.noreply.github.com> --- .../Common/Zip/SOZip/SOZipDeflateStream.cs | 6 +- .../Common/Zip/SOZip/SOZipIndex.cs | 4 +- src/SharpCompress/Common/Zip/ZipEntry.cs | 23 +++++- src/SharpCompress/Writers/Zip/ZipWriter.cs | 7 ++ tests/SharpCompress.Test/Zip/SOZipTests.cs | 70 ++++++++++++++++++- 5 files changed, 98 insertions(+), 12 deletions(-) diff --git a/src/SharpCompress/Common/Zip/SOZip/SOZipDeflateStream.cs b/src/SharpCompress/Common/Zip/SOZip/SOZipDeflateStream.cs index 5b564db82..ba306a695 100644 --- a/src/SharpCompress/Common/Zip/SOZip/SOZipDeflateStream.cs +++ b/src/SharpCompress/Common/Zip/SOZip/SOZipDeflateStream.cs @@ -37,11 +37,7 @@ public SOZipDeflateStream(Stream baseStream, CompressionLevel compressionLevel, // Record the first offset (start of compressed data) _compressedOffsets.Add(0); - _deflateStream = new DeflateStream( - baseStream, - CompressionMode.Compress, - compressionLevel - ); + _deflateStream = new DeflateStream(baseStream, CompressionMode.Compress, compressionLevel); } /// diff --git a/src/SharpCompress/Common/Zip/SOZip/SOZipIndex.cs b/src/SharpCompress/Common/Zip/SOZip/SOZipIndex.cs index 22a119c33..ff2e5e574 100644 --- a/src/SharpCompress/Common/Zip/SOZip/SOZipIndex.cs +++ b/src/SharpCompress/Common/Zip/SOZip/SOZipIndex.cs @@ -150,9 +150,7 @@ public static SOZipIndex Read(Stream stream) Span buf8 = stackalloc byte[8]; if (stream.Read(buf8) != 8) { - throw new InvalidDataException( - "Invalid SOZip index: unable to read uncompressed size" - ); + throw new InvalidDataException("Invalid SOZip index: unable to read uncompressed size"); } index.UncompressedSize = BinaryPrimitives.ReadUInt64LittleEndian(buf8); diff --git a/src/SharpCompress/Common/Zip/ZipEntry.cs b/src/SharpCompress/Common/Zip/ZipEntry.cs index 19f9961b0..81298784a 100644 --- a/src/SharpCompress/Common/Zip/ZipEntry.cs +++ b/src/SharpCompress/Common/Zip/ZipEntry.cs @@ -2,6 +2,7 @@ using System.Collections.Generic; using System.Linq; using SharpCompress.Common.Zip.Headers; +using SharpCompress.Common.Zip.SOZip; namespace SharpCompress.Common.Zip; @@ -11,7 +12,7 @@ public class ZipEntry : Entry internal ZipEntry(ZipFilePart? filePart) { - if (filePart == null) + if (filePart is null) { return; } @@ -88,4 +89,24 @@ internal ZipEntry(ZipFilePart? filePart) public override int? Attrib => (int?)_filePart?.Header.ExternalFileAttributes; public string? Comment => _filePart?.Header.Comment; + + /// + /// Gets a value indicating whether this entry has SOZip (Seek-Optimized ZIP) support. + /// A SOZip entry has an associated index file that enables random access within + /// the compressed data. + /// + public bool IsSozip => _filePart?.Header.Extra.Any(e => e.Type == ExtraDataType.SOZip) ?? false; + + /// + /// Gets a value indicating whether this entry is a SOZip index file. + /// Index files are hidden files with a .sozip.idx extension that contain + /// offsets into the main compressed file. + /// + public bool IsSozipIndexFile => Key is not null && SOZipIndex.IsIndexFile(Key); + + /// + /// Gets the SOZip extra field data, if present. + /// + internal SOZipExtraField? SOZipExtra => + _filePart?.Header.Extra.OfType().FirstOrDefault(); } diff --git a/src/SharpCompress/Writers/Zip/ZipWriter.cs b/src/SharpCompress/Writers/Zip/ZipWriter.cs index f867c8a91..e70dba060 100644 --- a/src/SharpCompress/Writers/Zip/ZipWriter.cs +++ b/src/SharpCompress/Writers/Zip/ZipWriter.cs @@ -26,12 +26,19 @@ public class ZipWriter : AbstractWriter private long streamPosition; private PpmdProperties? ppmdProps; private readonly bool isZip64; + private readonly bool enableSOZip; + private readonly int sozipChunkSize; + private readonly long sozipMinFileSize; public ZipWriter(Stream destination, ZipWriterOptions zipWriterOptions) : base(ArchiveType.Zip, zipWriterOptions) { zipComment = zipWriterOptions.ArchiveComment ?? string.Empty; isZip64 = zipWriterOptions.UseZip64; + enableSOZip = zipWriterOptions.EnableSOZip; + sozipChunkSize = zipWriterOptions.SOZipChunkSize; + sozipMinFileSize = zipWriterOptions.SOZipMinFileSize; + if (destination.CanSeek) { streamPosition = destination.Position; diff --git a/tests/SharpCompress.Test/Zip/SOZipTests.cs b/tests/SharpCompress.Test/Zip/SOZipTests.cs index a53529bbd..33b71dc2a 100644 --- a/tests/SharpCompress.Test/Zip/SOZipTests.cs +++ b/tests/SharpCompress.Test/Zip/SOZipTests.cs @@ -1,6 +1,12 @@ using System; using System.IO; +using System.Linq; +using System.Text; +using SharpCompress.Archives.Zip; +using SharpCompress.Common; using SharpCompress.Common.Zip.SOZip; +using SharpCompress.Writers; +using SharpCompress.Writers.Zip; using Xunit; namespace SharpCompress.Test.Zip; @@ -39,9 +45,7 @@ public void SOZipIndex_Read_InvalidMagic_ThrowsException() { var invalidData = new byte[] { 0x00, 0x00, 0x00, 0x00 }; - var exception = Assert.Throws( - () => SOZipIndex.Read(invalidData) - ); + var exception = Assert.Throws(() => SOZipIndex.Read(invalidData)); Assert.Contains("magic number mismatch", exception.Message); } @@ -132,4 +136,64 @@ public void SOZipIndex_GetMainFileName() Assert.Null(SOZipIndex.GetMainFileName("file.txt")); Assert.Null(SOZipIndex.GetMainFileName("")); } + + [Fact] + public void ZipEntry_IsSozipIndexFile_Detection() + { + // Create a zip with a file that has a SOZip index file name pattern + using var memoryStream = new MemoryStream(); + + using ( + var writer = WriterFactory.Open( + memoryStream, + ArchiveType.Zip, + new ZipWriterOptions(CompressionType.Deflate) { LeaveStreamOpen = true } + ) + ) + { + // Write a regular file + writer.Write("test.txt", new MemoryStream(Encoding.UTF8.GetBytes("Hello World"))); + + // Write a file with SOZip index name pattern + var indexData = new SOZipIndex( + chunkSize: 32768, + uncompressedSize: 100, + compressedSize: 50, + compressedOffsets: new ulong[] { 0 } + ); + writer.Write(".test.txt.sozip.idx", new MemoryStream(indexData.ToByteArray())); + } + + memoryStream.Position = 0; + + using var archive = ZipArchive.Open(memoryStream); + var entries = archive.Entries.ToList(); + + Assert.Equal(2, entries.Count); + + var regularEntry = entries.First(e => e.Key == "test.txt"); + Assert.False(regularEntry.IsSozipIndexFile); + Assert.False(regularEntry.IsSozip); // No SOZip extra field + + var indexEntry = entries.First(e => e.Key == ".test.txt.sozip.idx"); + Assert.True(indexEntry.IsSozipIndexFile); + } + + [Fact] + public void ZipWriterOptions_SOZipDefaults() + { + var options = new ZipWriterOptions(CompressionType.Deflate); + + Assert.False(options.EnableSOZip); + Assert.Equal((int)SOZipIndex.DEFAULT_CHUNK_SIZE, options.SOZipChunkSize); + Assert.Equal(1048576L, options.SOZipMinFileSize); // 1MB + } + + [Fact] + public void ZipWriterEntryOptions_SOZipDefaults() + { + var options = new ZipWriterEntryOptions(); + + Assert.Null(options.EnableSOZip); + } } From d9c9612b8f71eb608282724979f0884d2c1909a3 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 26 Nov 2025 08:31:49 +0000 Subject: [PATCH 4/9] Update documentation for SOZip support Co-authored-by: adamhathcock <527620+adamhathcock@users.noreply.github.com> --- FORMATS.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/FORMATS.md b/FORMATS.md index 473d8eb90..32dcc2885 100644 --- a/FORMATS.md +++ b/FORMATS.md @@ -22,7 +22,7 @@ | 7Zip (4) | LZMA, LZMA2, BZip2, PPMd, BCJ, BCJ2, Deflate | Decompress | SevenZipArchive | N/A | N/A | 1. SOLID Rars are only supported in the RarReader API. -2. Zip format supports pkware and WinzipAES encryption. However, encrypted LZMA is not supported. Zip64 reading/writing is supported but only with seekable streams as the Zip spec doesn't support Zip64 data in post data descriptors. Deflate64 is only supported for reading. +2. Zip format supports pkware and WinzipAES encryption. However, encrypted LZMA is not supported. Zip64 reading/writing is supported but only with seekable streams as the Zip spec doesn't support Zip64 data in post data descriptors. Deflate64 is only supported for reading. SOZip (Seek-Optimized ZIP) detection is supported for reading. 3. The Tar format requires a file size in the header. If no size is specified to the TarWriter and the stream is not seekable, then an exception will be thrown. 4. The 7Zip format doesn't allow for reading as a forward-only stream so 7Zip is only supported through the Archive API 5. LZip has no support for extra data like the file name or timestamp. There is a default filename used when looking at the entry Key on the archive. From 8c6d9140040190a3ecba630f35eefbd1fda8dafa Mon Sep 17 00:00:00 2001 From: Adam Hathcock Date: Wed, 26 Nov 2025 15:11:03 +0000 Subject: [PATCH 5/9] reader tests don't pass or make sense --- .../Zip/SOZipReaderTests.cs | 45 ++++++++++++++++++ .../{SOZipTests.cs => SoZipWriterTests.cs} | 2 +- tests/TestArchives/Archives/foo.zip | Bin 0 -> 204 bytes 3 files changed, 46 insertions(+), 1 deletion(-) create mode 100644 tests/SharpCompress.Test/Zip/SOZipReaderTests.cs rename tests/SharpCompress.Test/Zip/{SOZipTests.cs => SoZipWriterTests.cs} (99%) create mode 100644 tests/TestArchives/Archives/foo.zip diff --git a/tests/SharpCompress.Test/Zip/SOZipReaderTests.cs b/tests/SharpCompress.Test/Zip/SOZipReaderTests.cs new file mode 100644 index 000000000..9c6fa089d --- /dev/null +++ b/tests/SharpCompress.Test/Zip/SOZipReaderTests.cs @@ -0,0 +1,45 @@ +using System; +using System.IO; +using System.Threading.Tasks; +using SharpCompress.Archives.Zip; +using SharpCompress.Common.Zip.SOZip; +using SharpCompress.Readers; +using SharpCompress.Readers.Zip; +using SharpCompress.Test.Mocks; +using Xunit; + +namespace SharpCompress.Test.Zip; + +public class SoZipReaderTests : TestBase +{ + [Fact] + public async Task SOZip_Reader() + { + var path = Path.Combine(TEST_ARCHIVES_PATH, "foo.zip"); + using Stream stream = new ForwardOnlyStream(File.OpenRead(path)); + using var reader = ZipReader.Open(stream); + while (await reader.MoveToNextEntryAsync()) + { + Assert.True(reader.Entry.IsSozip, $"Entry {reader.Entry.Key} is not SOZip"); + if (!reader.Entry.IsDirectory) + { + await reader.WriteEntryToAsync(Stream.Null); + } + } + } + + [Fact] + public void SOZip_Archive() + { + var path = Path.Combine(TEST_ARCHIVES_PATH, "foo.zip"); + using Stream stream = File.OpenRead(path); + using var archive = ZipArchive.Open(stream); + foreach (var entry in archive.Entries) + { + if (entry.IsSozip) + Console.WriteLine($"{entry.Key} has SOZip random access support"); + if (entry.IsSozipIndexFile) + Console.WriteLine($"{entry.Key} is a SOZip index file"); + } + } +} diff --git a/tests/SharpCompress.Test/Zip/SOZipTests.cs b/tests/SharpCompress.Test/Zip/SoZipWriterTests.cs similarity index 99% rename from tests/SharpCompress.Test/Zip/SOZipTests.cs rename to tests/SharpCompress.Test/Zip/SoZipWriterTests.cs index 33b71dc2a..dde04a92c 100644 --- a/tests/SharpCompress.Test/Zip/SOZipTests.cs +++ b/tests/SharpCompress.Test/Zip/SoZipWriterTests.cs @@ -11,7 +11,7 @@ namespace SharpCompress.Test.Zip; -public class SOZipTests : TestBase +public class SoZipWriterTests : TestBase { [Fact] public void SOZipIndex_RoundTrip() diff --git a/tests/TestArchives/Archives/foo.zip b/tests/TestArchives/Archives/foo.zip new file mode 100644 index 0000000000000000000000000000000000000000..fb80a9225027dde15df2cfec6b050d29b55f31e0 GIT binary patch literal 204 zcmWIWW@Zs#U|`^2SW&AQrkGmXBLL(vLvdPuzSn7XAm{&oFacx-Ks7LcHRPQ57p4J} z0%1NN)&uI$E6%UVEYQnLsbB<(fB+K^a{w{OSP%eN0Rp@b3TP%HPzi2lK$Sr$pcMh$ QtZX12BM=$_=~l2503FU8ZU6uP literal 0 HcmV?d00001 From 7339567880c9e28bf52a59f7038669797360798f Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 27 Nov 2025 08:18:27 +0000 Subject: [PATCH 6/9] Fix SOZip tests to work correctly with ZipReader and ZipArchive Co-authored-by: adamhathcock <527620+adamhathcock@users.noreply.github.com> --- .../Zip/SOZipReaderTests.cs | 136 ++++++++++++++++-- 1 file changed, 121 insertions(+), 15 deletions(-) diff --git a/tests/SharpCompress.Test/Zip/SOZipReaderTests.cs b/tests/SharpCompress.Test/Zip/SOZipReaderTests.cs index 9c6fa089d..d94aa3df6 100644 --- a/tests/SharpCompress.Test/Zip/SOZipReaderTests.cs +++ b/tests/SharpCompress.Test/Zip/SOZipReaderTests.cs @@ -1,11 +1,14 @@ -using System; using System.IO; +using System.Linq; +using System.Text; using System.Threading.Tasks; using SharpCompress.Archives.Zip; +using SharpCompress.Common; using SharpCompress.Common.Zip.SOZip; -using SharpCompress.Readers; using SharpCompress.Readers.Zip; using SharpCompress.Test.Mocks; +using SharpCompress.Writers; +using SharpCompress.Writers.Zip; using Xunit; namespace SharpCompress.Test.Zip; @@ -13,33 +16,136 @@ namespace SharpCompress.Test.Zip; public class SoZipReaderTests : TestBase { [Fact] - public async Task SOZip_Reader() + public async Task SOZip_Reader_RegularZip_NoSozipEntries() { - var path = Path.Combine(TEST_ARCHIVES_PATH, "foo.zip"); + // Regular zip files should not have SOZip entries + var path = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.zip"); using Stream stream = new ForwardOnlyStream(File.OpenRead(path)); using var reader = ZipReader.Open(stream); while (await reader.MoveToNextEntryAsync()) { - Assert.True(reader.Entry.IsSozip, $"Entry {reader.Entry.Key} is not SOZip"); - if (!reader.Entry.IsDirectory) - { - await reader.WriteEntryToAsync(Stream.Null); - } + // Regular zip entries should NOT be SOZip + Assert.False(reader.Entry.IsSozip, $"Entry {reader.Entry.Key} should not be SOZip"); + Assert.False( + reader.Entry.IsSozipIndexFile, + $"Entry {reader.Entry.Key} should not be a SOZip index file" + ); } } [Fact] - public void SOZip_Archive() + public void SOZip_Archive_RegularZip_NoSozipEntries() { - var path = Path.Combine(TEST_ARCHIVES_PATH, "foo.zip"); + // Regular zip files should not have SOZip entries + var path = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.zip"); using Stream stream = File.OpenRead(path); using var archive = ZipArchive.Open(stream); foreach (var entry in archive.Entries) { - if (entry.IsSozip) - Console.WriteLine($"{entry.Key} has SOZip random access support"); - if (entry.IsSozipIndexFile) - Console.WriteLine($"{entry.Key} is a SOZip index file"); + // Regular zip entries should NOT be SOZip + Assert.False(entry.IsSozip, $"Entry {entry.Key} should not be SOZip"); + Assert.False( + entry.IsSozipIndexFile, + $"Entry {entry.Key} should not be a SOZip index file" + ); + } + } + + [Fact] + public void SOZip_Archive_DetectsIndexFileByName() + { + // Create a zip with a SOZip index file (by name pattern) + using var memoryStream = new MemoryStream(); + + using ( + var writer = WriterFactory.Open( + memoryStream, + ArchiveType.Zip, + new ZipWriterOptions(CompressionType.Deflate) { LeaveStreamOpen = true } + ) + ) + { + // Write a regular file + writer.Write("test.txt", new MemoryStream(Encoding.UTF8.GetBytes("Hello World"))); + + // Write a file that looks like a SOZip index (by name pattern) + var indexData = new SOZipIndex( + chunkSize: 32768, + uncompressedSize: 100, + compressedSize: 50, + compressedOffsets: new ulong[] { 0 } + ); + writer.Write(".test.txt.sozip.idx", new MemoryStream(indexData.ToByteArray())); + } + + memoryStream.Position = 0; + + // Test with ZipArchive + using var archive = ZipArchive.Open(memoryStream); + var entries = archive.Entries.ToList(); + + Assert.Equal(2, entries.Count); + + var regularEntry = entries.First(e => e.Key == "test.txt"); + Assert.False(regularEntry.IsSozipIndexFile); + Assert.False(regularEntry.IsSozip); // No SOZip extra field + + var indexEntry = entries.First(e => e.Key == ".test.txt.sozip.idx"); + Assert.True(indexEntry.IsSozipIndexFile); + } + + [Fact] + public async Task SOZip_Reader_DetectsIndexFileByName() + { + // Create a zip with a SOZip index file (by name pattern) + using var memoryStream = new MemoryStream(); + + using ( + var writer = WriterFactory.Open( + memoryStream, + ArchiveType.Zip, + new ZipWriterOptions(CompressionType.Deflate) { LeaveStreamOpen = true } + ) + ) + { + // Write a regular file + writer.Write("test.txt", new MemoryStream(Encoding.UTF8.GetBytes("Hello World"))); + + // Write a file that looks like a SOZip index (by name pattern) + var indexData = new SOZipIndex( + chunkSize: 32768, + uncompressedSize: 100, + compressedSize: 50, + compressedOffsets: new ulong[] { 0 } + ); + writer.Write(".test.txt.sozip.idx", new MemoryStream(indexData.ToByteArray())); + } + + memoryStream.Position = 0; + + // Test with ZipReader + using Stream stream = new ForwardOnlyStream(memoryStream); + using var reader = ZipReader.Open(stream); + + var foundRegular = false; + var foundIndex = false; + + while (await reader.MoveToNextEntryAsync()) + { + if (reader.Entry.Key == "test.txt") + { + foundRegular = true; + Assert.False(reader.Entry.IsSozipIndexFile); + Assert.False(reader.Entry.IsSozip); + } + else if (reader.Entry.Key == ".test.txt.sozip.idx") + { + foundIndex = true; + Assert.True(reader.Entry.IsSozipIndexFile); + } } + + Assert.True(foundRegular, "Regular entry not found"); + Assert.True(foundIndex, "Index entry not found"); } } From 9058645feae652505042663a14df2de3a4234b64 Mon Sep 17 00:00:00 2001 From: Adam Hathcock Date: Thu, 27 Nov 2025 10:49:19 +0000 Subject: [PATCH 7/9] sozip writing and validation --- .../Writers/Zip/ZipCentralDirectoryEntry.cs | 1 + src/SharpCompress/Writers/Zip/ZipWriter.cs | 99 ++++++++++++++++++- tests/SharpCompress.Test/TestBase.cs | 20 +++- .../Zip/SoZipWriterTests.cs | 93 +++++++++++++++++ 4 files changed, 208 insertions(+), 5 deletions(-) diff --git a/src/SharpCompress/Writers/Zip/ZipCentralDirectoryEntry.cs b/src/SharpCompress/Writers/Zip/ZipCentralDirectoryEntry.cs index 6816859a2..a9fb37ad9 100644 --- a/src/SharpCompress/Writers/Zip/ZipCentralDirectoryEntry.cs +++ b/src/SharpCompress/Writers/Zip/ZipCentralDirectoryEntry.cs @@ -34,6 +34,7 @@ ArchiveEncoding archiveEncoding internal ulong Decompressed { get; set; } internal ushort Zip64HeaderOffset { get; set; } internal ulong HeaderOffset { get; } + internal string FileName => fileName; internal uint Write(Stream outputStream) { diff --git a/src/SharpCompress/Writers/Zip/ZipWriter.cs b/src/SharpCompress/Writers/Zip/ZipWriter.cs index e70dba060..fbffb206a 100644 --- a/src/SharpCompress/Writers/Zip/ZipWriter.cs +++ b/src/SharpCompress/Writers/Zip/ZipWriter.cs @@ -8,6 +8,7 @@ using SharpCompress.Common; using SharpCompress.Common.Zip; using SharpCompress.Common.Zip.Headers; +using SharpCompress.Common.Zip.SOZip; using SharpCompress.Compressors; using SharpCompress.Compressors.BZip2; using SharpCompress.Compressors.Deflate; @@ -122,12 +123,21 @@ public Stream WriteToStream(string entryPath, ZipWriterEntryOptions options) var headersize = (uint)WriteHeader(entryPath, options, entry, useZip64); streamPosition += headersize; + + // Determine if SOZip should be used for this entry + var useSozip = + (options.EnableSOZip ?? enableSOZip) + && compression == ZipCompressionMethod.Deflate + && OutputStream.CanSeek; + return new ZipWritingStream( this, OutputStream.NotNull(), entry, compression, - options.CompressionLevel ?? compressionLevel + options.CompressionLevel ?? compressionLevel, + useSozip, + useSozip ? sozipChunkSize : 0 ); } @@ -309,6 +319,64 @@ private void WriteFooter(uint crc, uint compressed, uint uncompressed) OutputStream.Write(intBuf); } + private void WriteSozipIndexFile( + ZipCentralDirectoryEntry dataEntry, + SOZipDeflateStream sozipStream + ) + { + var indexFileName = SOZipIndex.GetIndexFileName(dataEntry.FileName); + + // Create the SOZip index + var index = new SOZipIndex( + chunkSize: sozipStream.ChunkSize, + uncompressedSize: sozipStream.UncompressedBytesWritten, + compressedSize: sozipStream.CompressedBytesWritten, + compressedOffsets: sozipStream.CompressedOffsets + ); + + var indexBytes = index.ToByteArray(); + + // Calculate CRC for index data + var crc = new CRC32(); + crc.SlurpBlock(indexBytes, 0, indexBytes.Length); + var indexCrc = (uint)crc.Crc32Result; + + // Write the index file as a stored (uncompressed) entry + var indexEntry = new ZipCentralDirectoryEntry( + ZipCompressionMethod.None, + indexFileName, + (ulong)streamPosition, + WriterOptions.ArchiveEncoding + ) + { + ModificationTime = DateTime.Now, + }; + + // Write the local file header for index + var indexOptions = new ZipWriterEntryOptions { CompressionType = CompressionType.None }; + var headerSize = (uint)WriteHeader(indexFileName, indexOptions, indexEntry, isZip64); + streamPosition += headerSize; + + // Write the index data directly + OutputStream.Write(indexBytes, 0, indexBytes.Length); + + // Finalize the index entry + indexEntry.Crc = indexCrc; + indexEntry.Compressed = (ulong)indexBytes.Length; + indexEntry.Decompressed = (ulong)indexBytes.Length; + + if (OutputStream.CanSeek) + { + // Update the header with sizes and CRC + OutputStream.Position = (long)(indexEntry.HeaderOffset + 14); + WriteFooter(indexCrc, (uint)indexBytes.Length, (uint)indexBytes.Length); + OutputStream.Position = streamPosition + indexBytes.Length; + } + + streamPosition += indexBytes.Length; + entries.Add(indexEntry); + } + private void WriteEndRecord(ulong size) { var zip64EndOfCentralDirectoryNeeded = @@ -390,7 +458,10 @@ internal class ZipWritingStream : Stream private readonly ZipWriter writer; private readonly ZipCompressionMethod zipCompressionMethod; private readonly int compressionLevel; + private readonly bool useSozip; + private readonly int sozipChunkSize; private SharpCompressStream? counting; + private SOZipDeflateStream? sozipStream; private ulong decompressed; // Flag to prevent throwing exceptions on Dispose @@ -402,7 +473,9 @@ internal ZipWritingStream( Stream originalStream, ZipCentralDirectoryEntry entry, ZipCompressionMethod zipCompressionMethod, - int compressionLevel + int compressionLevel, + bool useSozip = false, + int sozipChunkSize = 0 ) { this.writer = writer; @@ -411,6 +484,8 @@ int compressionLevel this.entry = entry; this.zipCompressionMethod = zipCompressionMethod; this.compressionLevel = compressionLevel; + this.useSozip = useSozip; + this.sozipChunkSize = sozipChunkSize; writeStream = GetWriteStream(originalStream); } @@ -440,6 +515,15 @@ private Stream GetWriteStream(Stream writeStream) } case ZipCompressionMethod.Deflate: { + if (useSozip && sozipChunkSize > 0) + { + sozipStream = new SOZipDeflateStream( + counting, + (CompressionLevel)compressionLevel, + sozipChunkSize + ); + return sozipStream; + } return new DeflateStream( counting, CompressionMode.Compress, @@ -586,7 +670,18 @@ protected override void Dispose(bool disposing) writer.WriteFooter(entry.Crc, compressedvalue, decompressedvalue); writer.streamPosition += (long)entry.Compressed + 16; } + writer.entries.Add(entry); + + // Write SOZip index file if SOZip was used and file meets minimum size + if ( + useSozip + && sozipStream is not null + && entry.Decompressed >= (ulong)writer.sozipMinFileSize + ) + { + writer.WriteSozipIndexFile(entry, sozipStream); + } } } diff --git a/tests/SharpCompress.Test/TestBase.cs b/tests/SharpCompress.Test/TestBase.cs index 184e64420..0a091de52 100644 --- a/tests/SharpCompress.Test/TestBase.cs +++ b/tests/SharpCompress.Test/TestBase.cs @@ -3,6 +3,7 @@ using System.IO; using System.Linq; using System.Text; +using SharpCompress.Common.Zip.SOZip; using SharpCompress.Readers; using Xunit; @@ -45,7 +46,7 @@ protected TestBase() public void Dispose() => Directory.Delete(SCRATCH_BASE_PATH, true); - public void VerifyFiles() + public void VerifyFiles(bool skipSoIndexes = false) { if (UseExtensionInsteadOfNameToVerify) { @@ -53,7 +54,7 @@ public void VerifyFiles() } else { - VerifyFilesByName(); + VerifyFilesByName(skipSoIndexes); } } @@ -72,10 +73,23 @@ public void VerifyFilesEx() } } - protected void VerifyFilesByName() + private void VerifyFilesByName(bool skipSoIndexes) { var extracted = Directory .EnumerateFiles(SCRATCH_FILES_PATH, "*.*", SearchOption.AllDirectories) + .Where(x => + { + if ( + skipSoIndexes + && Path.GetFileName(x) + .EndsWith(SOZipIndex.INDEX_EXTENSION, StringComparison.OrdinalIgnoreCase) + ) + { + return false; + } + + return true; + }) .ToLookup(path => path.Substring(SCRATCH_FILES_PATH.Length)); var original = Directory .EnumerateFiles(ORIGINAL_FILES_PATH, "*.*", SearchOption.AllDirectories) diff --git a/tests/SharpCompress.Test/Zip/SoZipWriterTests.cs b/tests/SharpCompress.Test/Zip/SoZipWriterTests.cs index dde04a92c..42b9a314a 100644 --- a/tests/SharpCompress.Test/Zip/SoZipWriterTests.cs +++ b/tests/SharpCompress.Test/Zip/SoZipWriterTests.cs @@ -5,6 +5,7 @@ using SharpCompress.Archives.Zip; using SharpCompress.Common; using SharpCompress.Common.Zip.SOZip; +using SharpCompress.Readers; using SharpCompress.Writers; using SharpCompress.Writers.Zip; using Xunit; @@ -196,4 +197,96 @@ public void ZipWriterEntryOptions_SOZipDefaults() Assert.Null(options.EnableSOZip); } + + [Fact] + public void SOZip_RoundTrip_CompressAndDecompress() + { + // Create a SOZip archive from Original files + var archivePath = Path.Combine(SCRATCH2_FILES_PATH, "test.sozip.zip"); + + using (var stream = File.Create(archivePath)) + { + var options = new ZipWriterOptions(CompressionType.Deflate) + { + EnableSOZip = true, + SOZipMinFileSize = 1024, // 1KB to ensure test files qualify + LeaveStreamOpen = false, + }; + + using var writer = new ZipWriter(stream, options); + + // Write all files from Original directory + var files = Directory.GetFiles(ORIGINAL_FILES_PATH, "*", SearchOption.AllDirectories); + foreach (var filePath in files) + { + var relativePath = filePath + .Substring(ORIGINAL_FILES_PATH.Length + 1) + .Replace('\\', '/'); + using var fileStream = File.OpenRead(filePath); + writer.Write(relativePath, fileStream, new ZipWriterEntryOptions()); + } + } + + // Validate the archive was created and has files + Assert.True(File.Exists(archivePath)); + + // Validate the archive has SOZip entries + using (var stream = File.OpenRead(archivePath)) + { + using var archive = ZipArchive.Open(stream); + + var allEntries = archive.Entries.ToList(); + + // Archive should have files + Assert.NotEmpty(allEntries); + + var sozipIndexEntries = allEntries.Where(e => e.IsSozipIndexFile).ToList(); + + // Should have at least one SOZip index file + Assert.NotEmpty(sozipIndexEntries); + + // Verify index files have valid SOZip index data + foreach (var indexEntry in sozipIndexEntries) + { + // Check that the entry is stored (not compressed) + Assert.Equal(CompressionType.None, indexEntry.CompressionType); + + using var indexStream = indexEntry.OpenEntryStream(); + using var memStream = new MemoryStream(); + indexStream.CopyTo(memStream); + var indexBytes = memStream.ToArray(); + + // Debug: Check first 4 bytes + Assert.True( + indexBytes.Length >= 4, + $"Index file too small: {indexBytes.Length} bytes" + ); + + // Should be able to parse the index without exception + var index = SOZipIndex.Read(indexBytes); + Assert.Equal(SOZipIndex.SOZIP_VERSION, index.Version); + Assert.True(index.ChunkSize > 0); + Assert.True(index.UncompressedSize > 0); + Assert.True(index.OffsetCount > 0); + + // Verify there's a corresponding data file + var mainFileName = SOZipIndex.GetMainFileName(indexEntry.Key!); + Assert.NotNull(mainFileName); + Assert.Contains(allEntries, e => e.Key == mainFileName); + } + } + + // Read and decompress the archive + using (var stream = File.OpenRead(archivePath)) + { + using var reader = ReaderFactory.Open(stream); + reader.WriteAllToDirectory( + SCRATCH_FILES_PATH, + new ExtractionOptions { ExtractFullPath = true } + ); + } + + // Verify extracted files match originals + VerifyFiles(true); + } } From 0dc63223abd2b71c9ea6878cae4c68c209e9e509 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Mon, 5 Jan 2026 17:21:38 +0000 Subject: [PATCH 8/9] Merge master branch and resolve FORMATS.md conflict Co-authored-by: adamhathcock <527620+adamhathcock@users.noreply.github.com> --- .config/dotnet-tools.json | 2 +- .github/COPILOT_AGENT_README.md | 15 - .github/prompts/plan-async.prompt.md | 25 + .github/prompts/plan-for-next.prompt.md | 123 + .github/workflows/NUGET_RELEASE.md | 155 + .github/workflows/TESTING.md | 120 + .github/workflows/dotnetcore.yml | 25 - .github/workflows/nuget-release.yml | 61 + .gitignore | 2 +- .vscode/extensions.json | 9 + .vscode/launch.json | 97 + .vscode/settings.json | 29 + .vscode/tasks.json | 178 + AGENTS.md | 71 +- Directory.Packages.props | 15 +- FORMATS.md | 26 +- README.md | 2 +- SharpCompress.sln | 2 +- USAGE.md | 64 +- build/Program.cs | 177 +- build/build.csproj | 2 +- build/packages.lock.json | 14 +- global.json | 2 +- src/SharpCompress/Archives/AbstractArchive.cs | 52 +- src/SharpCompress/Archives/IArchive.cs | 6 - .../Archives/IArchiveEntryExtensions.cs | 231 +- .../Archives/IArchiveExtensions.cs | 195 +- .../Archives/IArchiveExtractionListener.cs | 10 - src/SharpCompress/Archives/Rar/RarArchive.cs | 2 + .../Archives/Rar/RarArchiveEntry.cs | 8 +- .../Archives/SevenZip/SevenZipArchive.cs | 159 +- src/SharpCompress/AssemblyInfo.cs | 3 +- src/SharpCompress/Common/Ace/AceCrc.cs | 61 + src/SharpCompress/Common/Ace/AceEntry.cs | 68 + src/SharpCompress/Common/Ace/AceFilePart.cs | 52 + src/SharpCompress/Common/Ace/AceVolume.cs | 35 + .../Common/Ace/Headers/AceFileHeader.cs | 171 + .../Common/Ace/Headers/AceHeader.cs | 153 + .../Common/Ace/Headers/AceMainHeader.cs | 97 + .../Common/Ace/Headers/CompressionQuality.cs | 16 + .../Common/Ace/Headers/CompressionType.cs | 13 + .../Common/Ace/Headers/HeaderFlags.cs | 33 + .../Common/Ace/Headers/HostOS.cs | 22 + .../Common/ArchiveExtractionEventArgs.cs | 10 - src/SharpCompress/Common/ArchiveType.cs | 1 + .../Common/Arj/Headers/ArjHeader.cs | 22 +- .../Common/CompressedBytesReadEventArgs.cs | 25 - src/SharpCompress/Common/CompressionType.cs | 1 + src/SharpCompress/Common/ExtractionMethods.cs | 9 +- .../FilePartExtractionBeginEventArgs.cs | 28 - .../Common/IExtractionListener.cs | 7 - src/SharpCompress/Common/ProgressReport.cs | 43 + .../Common/ReaderExtractionEventArgs.cs | 17 - .../Common/Tar/Headers/TarHeader.cs | 133 +- .../Tar/Headers/TarHeaderWriteFormat.cs | 7 + .../Common/Zip/WinzipAesEncryptionData.cs | 24 +- src/SharpCompress/Common/Zip/ZipFilePart.cs | 2 +- .../Compressors/BZip2/CBZip2OutputStream.cs | 6 + .../Compressors/LZMA/LzmaStream.cs | 18 +- .../Compressors/LZMA/Registry.cs | 2 +- .../Rar/MultiVolumeReadOnlyStream.cs | 38 +- .../Compressors/Rar/RarStream.cs | 4 +- .../Compressors/ZStandard/BitOperations.cs | 311 + .../ZStandard/CompressionStream.cs | 301 + .../Compressors/ZStandard/Compressor.cs | 204 + .../Compressors/ZStandard/Constants.cs | 8 + .../ZStandard/DecompressionStream.cs | 293 + .../Compressors/ZStandard/Decompressor.cs | 176 + .../Compressors/ZStandard/JobThreadPool.cs | 141 + .../Compressors/ZStandard/SafeHandles.cs | 163 + .../ZStandard/SynchronizationWrapper.cs | 22 + .../Compressors/ZStandard/ThrowHelper.cs | 48 + .../Compressors/ZStandard/UnmanagedObject.cs | 18 + .../ZStandard/Unsafe/Allocations.cs | 52 + .../ZStandard/Unsafe/BIT_CStream_t.cs | 14 + .../ZStandard/Unsafe/BIT_DStream_status.cs | 16 + .../ZStandard/Unsafe/BIT_DStream_t.cs | 13 + .../Compressors/ZStandard/Unsafe/Bits.cs | 60 + .../Compressors/ZStandard/Unsafe/Bitstream.cs | 739 + .../ZStandard/Unsafe/BlockSummary.cs | 8 + .../ZStandard/Unsafe/COVER_best_s.cs | 20 + .../ZStandard/Unsafe/COVER_ctx_t.cs | 19 + .../ZStandard/Unsafe/COVER_dictSelection.cs | 11 + .../ZStandard/Unsafe/COVER_epoch_info_t.cs | 10 + .../ZStandard/Unsafe/COVER_map_pair_t_s.cs | 7 + .../ZStandard/Unsafe/COVER_map_s.cs | 9 + .../ZStandard/Unsafe/COVER_segment_t.cs | 11 + .../Unsafe/COVER_tryParameters_data_s.cs | 12 + .../Compressors/ZStandard/Unsafe/Clevels.cs | 849 ++ .../Compressors/ZStandard/Unsafe/Compiler.cs | 61 + .../Compressors/ZStandard/Unsafe/Cover.cs | 444 + .../ZStandard/Unsafe/DTableDesc.cs | 12 + .../ZStandard/Unsafe/EStats_ress_t.cs | 13 + .../ZStandard/Unsafe/EntropyCommon.cs | 447 + .../ZStandard/Unsafe/ErrorPrivate.cs | 110 + .../ZStandard/Unsafe/EstimatedBlockSize.cs | 7 + .../ZStandard/Unsafe/FASTCOVER_accel_t.cs | 19 + .../ZStandard/Unsafe/FASTCOVER_ctx_t.cs | 19 + .../Unsafe/FASTCOVER_tryParameters_data_s.cs | 12 + .../Compressors/ZStandard/Unsafe/FPStats.cs | 7 + .../ZStandard/Unsafe/FSE_CState_t.cs | 16 + .../ZStandard/Unsafe/FSE_DState_t.cs | 12 + .../ZStandard/Unsafe/FSE_DTableHeader.cs | 8 + .../ZStandard/Unsafe/FSE_DecompressWksp.cs | 6 + .../ZStandard/Unsafe/FSE_decode_t.cs | 8 + .../ZStandard/Unsafe/FSE_repeat.cs | 13 + .../Unsafe/FSE_symbolCompressionTransform.cs | 10 + .../Compressors/ZStandard/Unsafe/Fastcover.cs | 761 ++ .../ZStandard/Unsafe/Fingerprint.cs | 7 + .../Compressors/ZStandard/Unsafe/Fse.cs | 198 + .../ZStandard/Unsafe/FseCompress.cs | 782 ++ .../ZStandard/Unsafe/FseDecompress.cs | 462 + .../ZStandard/Unsafe/HIST_checkInput_e.cs | 7 + .../ZStandard/Unsafe/HUF_CStream_t.cs | 22 + .../ZStandard/Unsafe/HUF_CTableHeader.cs | 8 + .../Unsafe/HUF_CompressWeightsWksp.cs | 9 + .../ZStandard/Unsafe/HUF_DEltX1.cs | 11 + .../ZStandard/Unsafe/HUF_DEltX2.cs | 12 + .../Unsafe/HUF_DecompressFastArgs.cs | 49 + .../Unsafe/HUF_ReadDTableX1_Workspace.cs | 10 + .../Unsafe/HUF_ReadDTableX2_Workspace.cs | 307 + .../ZStandard/Unsafe/HUF_WriteCTableWksp.cs | 10 + .../Unsafe/HUF_buildCTable_wksp_tables.cs | 739 + .../ZStandard/Unsafe/HUF_compress_tables_t.cs | 280 + .../ZStandard/Unsafe/HUF_flags_e.cs | 44 + .../ZStandard/Unsafe/HUF_nbStreams_e.cs | 7 + .../ZStandard/Unsafe/HUF_repeat.cs | 13 + .../Compressors/ZStandard/Unsafe/Hist.cs | 273 + .../ZStandard/Unsafe/HufCompress.cs | 1825 +++ .../ZStandard/Unsafe/HufDecompress.cs | 2505 ++++ .../Compressors/ZStandard/Unsafe/Mem.cs | 162 + .../Compressors/ZStandard/Unsafe/Pool.cs | 122 + .../ZStandard/Unsafe/RSyncState_t.cs | 8 + .../Compressors/ZStandard/Unsafe/Range.cs | 14 + .../ZStandard/Unsafe/RawSeqStore_t.cs | 29 + .../ZStandard/Unsafe/RoundBuff_t.cs | 28 + .../ZStandard/Unsafe/SeqCollector.cs | 9 + .../Compressors/ZStandard/Unsafe/SeqDef_s.cs | 14 + .../ZStandard/Unsafe/SeqStore_t.cs | 27 + .../ZStandard/Unsafe/SerialState.cs | 23 + .../ZStandard/Unsafe/SymbolEncodingType_e.cs | 9 + .../Compressors/ZStandard/Unsafe/SyncPoint.cs | 10 + .../ZStandard/Unsafe/XXH32_canonical_t.cs | 10 + .../ZStandard/Unsafe/XXH32_state_s.cs | 34 + .../ZStandard/Unsafe/XXH64_canonical_t.cs | 9 + .../ZStandard/Unsafe/XXH64_state_s.cs | 34 + .../ZStandard/Unsafe/XXH_alignment.cs | 14 + .../ZStandard/Unsafe/XXH_errorcode.cs | 13 + .../Compressors/ZStandard/Unsafe/Xxhash.cs | 626 + .../ZStandard/Unsafe/ZDICT_cover_params_t.cs | 30 + .../Unsafe/ZDICT_fastCover_params_t.cs | 32 + .../ZStandard/Unsafe/ZDICT_legacy_params_t.cs | 8 + .../ZStandard/Unsafe/ZDICT_params_t.cs | 20 + .../ZStandard/Unsafe/ZSTDMT_CCtxPool.cs | 12 + .../ZStandard/Unsafe/ZSTDMT_CCtx_s.cs | 32 + .../ZStandard/Unsafe/ZSTDMT_bufferPool_s.cs | 11 + .../ZStandard/Unsafe/ZSTDMT_jobDescription.cs | 61 + .../Unsafe/ZSTD_BlockCompressor_f.cs | 12 + .../ZStandard/Unsafe/ZSTD_BuildCTableWksp.cs | 7 + .../ZStandard/Unsafe/ZSTD_BuildSeqStore_e.cs | 7 + .../ZStandard/Unsafe/ZSTD_CCtx_params_s.cs | 86 + .../ZStandard/Unsafe/ZSTD_CCtx_s.cs | 91 + .../ZStandard/Unsafe/ZSTD_CDict_s.cs | 30 + .../ZStandard/Unsafe/ZSTD_CParamMode_e.cs | 29 + .../ZStandard/Unsafe/ZSTD_DCtx_s.cs | 95 + .../ZStandard/Unsafe/ZSTD_DDictHashSet.cs | 9 + .../ZStandard/Unsafe/ZSTD_DDict_s.cs | 15 + .../ZStandard/Unsafe/ZSTD_DefaultPolicy_e.cs | 7 + .../ZStandard/Unsafe/ZSTD_EndDirective.cs | 21 + .../ZStandard/Unsafe/ZSTD_ErrorCode.cs | 59 + .../ZStandard/Unsafe/ZSTD_MatchState_t.cs | 66 + .../ZStandard/Unsafe/ZSTD_OffsetInfo.cs | 7 + .../ZStandard/Unsafe/ZSTD_OptPrice_e.cs | 7 + .../ZStandard/Unsafe/ZSTD_ResetDirective.cs | 8 + .../ZStandard/Unsafe/ZSTD_Sequence.cs | 40 + .../ZStandard/Unsafe/ZSTD_SequenceLength.cs | 7 + .../ZStandard/Unsafe/ZSTD_SequencePosition.cs | 13 + .../ZStandard/Unsafe/ZSTD_blockSplitCtx.cs | 12 + .../ZStandard/Unsafe/ZSTD_blockState_t.cs | 8 + .../ZStandard/Unsafe/ZSTD_bounds.cs | 8 + .../ZStandard/Unsafe/ZSTD_bufferMode_e.cs | 11 + .../Unsafe/ZSTD_buffered_policy_e.cs | 12 + .../ZStandard/Unsafe/ZSTD_cParameter.cs | 218 + .../ZStandard/Unsafe/ZSTD_cStreamStage.cs | 8 + .../Unsafe/ZSTD_compResetPolicy_e.cs | 14 + .../Unsafe/ZSTD_compressedBlockState_t.cs | 7 + .../Unsafe/ZSTD_compressionParameters.cs | 44 + .../Unsafe/ZSTD_compressionStage_e.cs | 12 + .../ZStandard/Unsafe/ZSTD_customMem.cs | 15 + .../ZStandard/Unsafe/ZSTD_cwksp.cs | 110 + .../Unsafe/ZSTD_cwksp_alloc_phase_e.cs | 12 + .../Unsafe/ZSTD_cwksp_static_alloc_e.cs | 12 + .../ZStandard/Unsafe/ZSTD_dParameter.cs | 38 + .../ZStandard/Unsafe/ZSTD_dStage.cs | 13 + .../ZStandard/Unsafe/ZSTD_dStreamStage.cs | 10 + .../ZStandard/Unsafe/ZSTD_dictAttachPref_e.cs | 16 + .../Unsafe/ZSTD_dictContentType_e.cs | 13 + .../ZStandard/Unsafe/ZSTD_dictLoadMethod_e.cs | 10 + .../ZStandard/Unsafe/ZSTD_dictMode_e.cs | 9 + .../Unsafe/ZSTD_dictTableLoadMethod_e.cs | 7 + .../ZStandard/Unsafe/ZSTD_dictUses_e.cs | 13 + .../Unsafe/ZSTD_entropyCTablesMetadata_t.cs | 7 + .../ZStandard/Unsafe/ZSTD_entropyCTables_t.cs | 7 + .../ZStandard/Unsafe/ZSTD_entropyDTables_t.cs | 1342 ++ .../Unsafe/ZSTD_forceIgnoreChecksum_e.cs | 8 + .../ZStandard/Unsafe/ZSTD_format_e.cs | 12 + .../ZStandard/Unsafe/ZSTD_frameHeader.cs | 21 + .../ZStandard/Unsafe/ZSTD_frameParameters.cs | 13 + .../ZStandard/Unsafe/ZSTD_frameProgression.cs | 22 + .../ZStandard/Unsafe/ZSTD_frameSizeInfo.cs | 14 + .../ZStandard/Unsafe/ZSTD_frameType_e.cs | 7 + .../Unsafe/ZSTD_fseCTablesMetadata_t.cs | 18 + .../ZStandard/Unsafe/ZSTD_fseCTables_t.cs | 11 + .../ZStandard/Unsafe/ZSTD_fseState.cs | 7 + .../ZStandard/Unsafe/ZSTD_getAllMatchesFn.cs | 15 + .../Unsafe/ZSTD_hufCTablesMetadata_t.cs | 16 + .../ZStandard/Unsafe/ZSTD_hufCTables_t.cs | 279 + .../ZStandard/Unsafe/ZSTD_inBuffer_s.cs | 16 + .../Unsafe/ZSTD_indexResetPolicy_e.cs | 12 + .../ZStandard/Unsafe/ZSTD_litLocation_e.cs | 13 + .../Unsafe/ZSTD_literalCompressionMode_e.cs | 16 + .../ZStandard/Unsafe/ZSTD_localDict.cs | 10 + .../ZStandard/Unsafe/ZSTD_longLengthType_e.cs | 14 + .../ZStandard/Unsafe/ZSTD_longOffset_e.cs | 7 + .../ZStandard/Unsafe/ZSTD_match_t.cs | 13 + .../ZStandard/Unsafe/ZSTD_nextInputType_e.cs | 11 + .../ZStandard/Unsafe/ZSTD_optLdm_t.cs | 17 + .../ZStandard/Unsafe/ZSTD_optimal_t.cs | 19 + .../ZStandard/Unsafe/ZSTD_outBuffer_s.cs | 13 + .../ZStandard/Unsafe/ZSTD_overlap_e.cs | 7 + .../ZStandard/Unsafe/ZSTD_paramSwitch_e.cs | 13 + .../ZStandard/Unsafe/ZSTD_parameters.cs | 7 + .../ZStandard/Unsafe/ZSTD_prefixDict_s.cs | 8 + .../Unsafe/ZSTD_refMultipleDDicts_e.cs | 8 + .../ZStandard/Unsafe/ZSTD_resetTarget_e.cs | 7 + .../ZStandard/Unsafe/ZSTD_seqSymbol.cs | 17 + .../ZStandard/Unsafe/ZSTD_seqSymbol_header.cs | 10 + .../ZStandard/Unsafe/ZSTD_sequenceFormat_e.cs | 10 + .../ZStandard/Unsafe/ZSTD_strategy.cs | 15 + .../Unsafe/ZSTD_symbolEncodingTypeStats_t.cs | 16 + .../Unsafe/ZSTD_tableFillPurpose_e.cs | 7 + .../ZStandard/Unsafe/ZSTD_window_t.cs | 25 + .../Compressors/ZStandard/Unsafe/Zdict.cs | 640 + .../Compressors/ZStandard/Unsafe/Zstd.cs | 10 + .../ZStandard/Unsafe/ZstdCommon.cs | 48 + .../ZStandard/Unsafe/ZstdCompress.cs | 11225 ++++++++++++++++ .../ZStandard/Unsafe/ZstdCompressInternal.cs | 1444 ++ .../ZStandard/Unsafe/ZstdCompressLiterals.cs | 314 + .../ZStandard/Unsafe/ZstdCompressSequences.cs | 1211 ++ .../Unsafe/ZstdCompressSuperblock.cs | 976 ++ .../Compressors/ZStandard/Unsafe/ZstdCwksp.cs | 581 + .../Compressors/ZStandard/Unsafe/ZstdDdict.cs | 292 + .../ZStandard/Unsafe/ZstdDecompress.cs | 3420 +++++ .../ZStandard/Unsafe/ZstdDecompressBlock.cs | 3218 +++++ .../Unsafe/ZstdDecompressInternal.cs | 394 + .../ZStandard/Unsafe/ZstdDoubleFast.cs | 1118 ++ .../Compressors/ZStandard/Unsafe/ZstdFast.cs | 1209 ++ .../ZStandard/Unsafe/ZstdInternal.cs | 638 + .../Compressors/ZStandard/Unsafe/ZstdLazy.cs | 4661 +++++++ .../Compressors/ZStandard/Unsafe/ZstdLdm.cs | 940 ++ .../ZStandard/Unsafe/ZstdLdmGeartab.cs | 539 + .../Compressors/ZStandard/Unsafe/ZstdOpt.cs | 2254 ++++ .../ZStandard/Unsafe/ZstdPresplit.cs | 295 + .../ZStandard/Unsafe/ZstdmtCompress.cs | 1894 +++ .../ZStandard/Unsafe/_wksps_e__Union.cs | 16 + .../ZStandard/Unsafe/algo_time_t.cs | 13 + .../ZStandard/Unsafe/base_directive_e.cs | 7 + .../ZStandard/Unsafe/blockProperties_t.cs | 8 + .../ZStandard/Unsafe/blockType_e.cs | 9 + .../Compressors/ZStandard/Unsafe/buffer_s.cs | 15 + .../Compressors/ZStandard/Unsafe/dictItem.cs | 8 + .../Compressors/ZStandard/Unsafe/inBuff_t.cs | 12 + .../ZStandard/Unsafe/ldmEntry_t.cs | 7 + .../ZStandard/Unsafe/ldmMatchCandidate_t.cs | 9 + .../ZStandard/Unsafe/ldmParams_t.cs | 22 + .../ZStandard/Unsafe/ldmRollingHashState_t.cs | 7 + .../ZStandard/Unsafe/ldmState_t.cs | 170 + .../Compressors/ZStandard/Unsafe/nodeElt_s.cs | 12 + .../ZStandard/Unsafe/offsetCount_t.cs | 7 + .../ZStandard/Unsafe/optState_t.cs | 53 + .../Compressors/ZStandard/Unsafe/rankPos.cs | 7 + .../ZStandard/Unsafe/rankValCol_t.cs | 6 + .../Compressors/ZStandard/Unsafe/rawSeq.cs | 13 + .../ZStandard/Unsafe/repcodes_s.cs | 6 + .../ZStandard/Unsafe/searchMethod_e.cs | 8 + .../ZStandard/Unsafe/seqState_t.cs | 17 + .../ZStandard/Unsafe/seqStoreSplits.cs | 11 + .../Compressors/ZStandard/Unsafe/seq_t.cs | 8 + .../ZStandard/Unsafe/sortedSymbol_t.cs | 6 + .../ZStandard/Unsafe/streaming_operation.cs | 8 + .../Compressors/ZStandard/UnsafeHelper.cs | 107 + .../Compressors/ZStandard/ZStandardStream.cs | 2 +- .../ZStandard/ZstandardConstants.cs | 6 - .../Compressors/ZStandard/ZstdException.cs | 12 + src/SharpCompress/Factories/AceFactory.cs | 37 + src/SharpCompress/Factories/ArjFactory.cs | 7 +- src/SharpCompress/Factories/Factory.cs | 1 + src/SharpCompress/IO/ListeningStream.cs | 97 - .../IO/ProgressReportingStream.cs | 160 + src/SharpCompress/IO/SharpCompressStream.cs | 20 +- .../Polyfills/StreamExtensions.cs | 24 + src/SharpCompress/Readers/AbstractReader.cs | 94 +- src/SharpCompress/Readers/Ace/AceReader.cs | 115 + .../Readers/Ace/MultiVolumeAceReader.cs | 117 + .../Readers/Ace/SingleVolumeAceReader.cs | 31 + src/SharpCompress/Readers/IReader.cs | 5 - .../Readers/IReaderExtensions.cs | 195 +- .../Readers/IReaderExtractionListener.cs | 8 - src/SharpCompress/Readers/Rar/RarReader.cs | 6 +- src/SharpCompress/Readers/ReaderFactory.cs | 2 +- src/SharpCompress/Readers/ReaderOptions.cs | 7 + src/SharpCompress/Readers/ReaderProgress.cs | 21 - src/SharpCompress/Readers/Zip/ZipReader.cs | 8 + src/SharpCompress/SharpCompress.csproj | 25 +- src/SharpCompress/Utility.cs | 66 - src/SharpCompress/Writers/AbstractWriter.cs | 24 + src/SharpCompress/Writers/GZip/GZipWriter.cs | 3 +- src/SharpCompress/Writers/Tar/TarWriter.cs | 10 +- .../Writers/Tar/TarWriterOptions.cs | 15 +- src/SharpCompress/Writers/WriterOptions.cs | 7 + src/SharpCompress/Writers/Zip/ZipWriter.cs | 6 +- src/SharpCompress/packages.lock.json | 255 +- .../SharpCompress.Performance.csproj | 2 +- .../packages.lock.json | 19 +- .../SharpCompress.Test/Ace/AceReaderTests.cs | 61 + tests/SharpCompress.Test/ArchiveTests.cs | 2 +- .../SharpCompress.Test/Arj/ArjReaderTests.cs | 40 +- tests/SharpCompress.Test/ExtractAll.cs | 46 + .../ExtractAllEntriesTests.cs | 61 + .../Mocks/TruncatedStream.cs | 65 + .../SharpCompress.Test/ProgressReportTests.cs | 605 + .../SharpCompress.Test/Rar/RarArchiveTests.cs | 84 + tests/SharpCompress.Test/ReaderTests.cs | 23 + .../SevenZip/SevenZipArchiveTests.cs | 9 + .../SharpCompress.Test.csproj | 4 +- .../Zip/ZipArchiveAsyncTests.cs | 34 + .../SharpCompress.Test/Zip/ZipReaderTests.cs | 39 + .../SharpCompress.Test/Zip/ZipWriterTests.cs | 38 + tests/SharpCompress.Test/packages.lock.json | 117 +- .../Archives/7Zip.encryptedFiles.7z | Bin 0 -> 59042 bytes tests/TestArchives/Archives/Ace.encrypted.ace | Bin 0 -> 60234 bytes .../Archives/Ace.method1-solid.ace | Bin 0 -> 60286 bytes tests/TestArchives/Archives/Ace.method1.ace | Bin 0 -> 60290 bytes .../Archives/Ace.method2-solid.ace | Bin 0 -> 60234 bytes tests/TestArchives/Archives/Ace.method2.ace | Bin 0 -> 60238 bytes tests/TestArchives/Archives/Ace.store.ace | Bin 0 -> 101196 bytes .../Archives/Ace.store.largefile.ace | Bin 0 -> 152188 bytes .../TestArchives/Archives/Ace.store.split.ace | Bin 0 -> 65600 bytes .../TestArchives/Archives/Ace.store.split.c00 | Bin 0 -> 35692 bytes 349 files changed, 60146 insertions(+), 1241 deletions(-) delete mode 100644 .github/COPILOT_AGENT_README.md create mode 100644 .github/prompts/plan-async.prompt.md create mode 100644 .github/prompts/plan-for-next.prompt.md create mode 100644 .github/workflows/NUGET_RELEASE.md create mode 100644 .github/workflows/TESTING.md delete mode 100644 .github/workflows/dotnetcore.yml create mode 100644 .github/workflows/nuget-release.yml create mode 100644 .vscode/extensions.json create mode 100644 .vscode/launch.json create mode 100644 .vscode/settings.json create mode 100644 .vscode/tasks.json delete mode 100644 src/SharpCompress/Archives/IArchiveExtractionListener.cs create mode 100644 src/SharpCompress/Common/Ace/AceCrc.cs create mode 100644 src/SharpCompress/Common/Ace/AceEntry.cs create mode 100644 src/SharpCompress/Common/Ace/AceFilePart.cs create mode 100644 src/SharpCompress/Common/Ace/AceVolume.cs create mode 100644 src/SharpCompress/Common/Ace/Headers/AceFileHeader.cs create mode 100644 src/SharpCompress/Common/Ace/Headers/AceHeader.cs create mode 100644 src/SharpCompress/Common/Ace/Headers/AceMainHeader.cs create mode 100644 src/SharpCompress/Common/Ace/Headers/CompressionQuality.cs create mode 100644 src/SharpCompress/Common/Ace/Headers/CompressionType.cs create mode 100644 src/SharpCompress/Common/Ace/Headers/HeaderFlags.cs create mode 100644 src/SharpCompress/Common/Ace/Headers/HostOS.cs delete mode 100644 src/SharpCompress/Common/ArchiveExtractionEventArgs.cs delete mode 100644 src/SharpCompress/Common/CompressedBytesReadEventArgs.cs delete mode 100644 src/SharpCompress/Common/FilePartExtractionBeginEventArgs.cs delete mode 100644 src/SharpCompress/Common/IExtractionListener.cs create mode 100644 src/SharpCompress/Common/ProgressReport.cs delete mode 100644 src/SharpCompress/Common/ReaderExtractionEventArgs.cs create mode 100644 src/SharpCompress/Common/Tar/Headers/TarHeaderWriteFormat.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/BitOperations.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/CompressionStream.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Compressor.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Constants.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/DecompressionStream.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Decompressor.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/JobThreadPool.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/SafeHandles.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/SynchronizationWrapper.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/ThrowHelper.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/UnmanagedObject.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Allocations.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_CStream_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_DStream_status.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_DStream_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Bits.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Bitstream.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/BlockSummary.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_best_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_ctx_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_dictSelection.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_epoch_info_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_map_pair_t_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_map_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_segment_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_tryParameters_data_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Clevels.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Compiler.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Cover.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/DTableDesc.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/EStats_ress_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/EntropyCommon.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ErrorPrivate.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/EstimatedBlockSize.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/FASTCOVER_accel_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/FASTCOVER_ctx_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/FASTCOVER_tryParameters_data_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/FPStats.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_CState_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_DState_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_DTableHeader.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_DecompressWksp.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_decode_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_repeat.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_symbolCompressionTransform.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Fastcover.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Fingerprint.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Fse.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/FseCompress.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/FseDecompress.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HIST_checkInput_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_CStream_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_CTableHeader.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_CompressWeightsWksp.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_DEltX1.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_DEltX2.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_DecompressFastArgs.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_ReadDTableX1_Workspace.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_ReadDTableX2_Workspace.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_WriteCTableWksp.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_buildCTable_wksp_tables.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_compress_tables_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_flags_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_nbStreams_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_repeat.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Hist.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HufCompress.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/HufDecompress.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Mem.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Pool.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/RSyncState_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Range.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/RawSeqStore_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/RoundBuff_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/SeqCollector.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/SeqDef_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/SeqStore_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/SerialState.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/SymbolEncodingType_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/SyncPoint.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/XXH32_canonical_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/XXH32_state_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/XXH64_canonical_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/XXH64_state_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/XXH_alignment.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/XXH_errorcode.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Xxhash.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_cover_params_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_fastCover_params_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_legacy_params_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_params_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_CCtxPool.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_CCtx_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_bufferPool_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_jobDescription.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_BlockCompressor_f.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_BuildCTableWksp.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_BuildSeqStore_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_CCtx_params_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_CCtx_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_CDict_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_CParamMode_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_DCtx_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_DDictHashSet.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_DDict_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_DefaultPolicy_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_EndDirective.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_ErrorCode.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_MatchState_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_OffsetInfo.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_OptPrice_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_ResetDirective.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_Sequence.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_SequenceLength.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_SequencePosition.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_blockSplitCtx.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_blockState_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_bounds.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_bufferMode_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_buffered_policy_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cParameter.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cStreamStage.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compResetPolicy_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compressedBlockState_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compressionParameters.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compressionStage_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_customMem.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cwksp.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cwksp_alloc_phase_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cwksp_static_alloc_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dParameter.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dStage.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dStreamStage.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictAttachPref_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictContentType_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictLoadMethod_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictMode_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictTableLoadMethod_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictUses_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_entropyCTablesMetadata_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_entropyCTables_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_entropyDTables_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_forceIgnoreChecksum_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_format_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameHeader.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameParameters.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameProgression.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameSizeInfo.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameType_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_fseCTablesMetadata_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_fseCTables_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_fseState.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_getAllMatchesFn.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_hufCTablesMetadata_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_hufCTables_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_inBuffer_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_indexResetPolicy_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_litLocation_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_literalCompressionMode_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_localDict.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_longLengthType_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_longOffset_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_match_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_nextInputType_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_optLdm_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_optimal_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_outBuffer_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_overlap_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_paramSwitch_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_parameters.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_prefixDict_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_refMultipleDDicts_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_resetTarget_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_seqSymbol.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_seqSymbol_header.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_sequenceFormat_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_strategy.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_symbolEncodingTypeStats_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_tableFillPurpose_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_window_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Zdict.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/Zstd.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCommon.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompress.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressInternal.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressLiterals.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressSequences.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressSuperblock.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCwksp.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDdict.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDecompress.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDecompressBlock.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDecompressInternal.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDoubleFast.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdFast.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdInternal.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdLazy.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdLdm.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdLdmGeartab.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdOpt.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdPresplit.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdmtCompress.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/_wksps_e__Union.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/algo_time_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/base_directive_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/blockProperties_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/blockType_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/buffer_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/dictItem.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/inBuff_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ldmEntry_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ldmMatchCandidate_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ldmParams_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ldmRollingHashState_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/ldmState_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/nodeElt_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/offsetCount_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/optState_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/rankPos.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/rankValCol_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/rawSeq.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/repcodes_s.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/searchMethod_e.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/seqState_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/seqStoreSplits.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/seq_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/sortedSymbol_t.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/Unsafe/streaming_operation.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/UnsafeHelper.cs create mode 100644 src/SharpCompress/Compressors/ZStandard/ZstdException.cs create mode 100644 src/SharpCompress/Factories/AceFactory.cs delete mode 100644 src/SharpCompress/IO/ListeningStream.cs create mode 100644 src/SharpCompress/IO/ProgressReportingStream.cs create mode 100644 src/SharpCompress/Readers/Ace/AceReader.cs create mode 100644 src/SharpCompress/Readers/Ace/MultiVolumeAceReader.cs create mode 100644 src/SharpCompress/Readers/Ace/SingleVolumeAceReader.cs delete mode 100644 src/SharpCompress/Readers/IReaderExtractionListener.cs delete mode 100644 src/SharpCompress/Readers/ReaderProgress.cs create mode 100644 tests/SharpCompress.Test/Ace/AceReaderTests.cs create mode 100644 tests/SharpCompress.Test/ExtractAll.cs create mode 100644 tests/SharpCompress.Test/ExtractAllEntriesTests.cs create mode 100644 tests/SharpCompress.Test/Mocks/TruncatedStream.cs create mode 100644 tests/SharpCompress.Test/ProgressReportTests.cs create mode 100644 tests/TestArchives/Archives/7Zip.encryptedFiles.7z create mode 100644 tests/TestArchives/Archives/Ace.encrypted.ace create mode 100644 tests/TestArchives/Archives/Ace.method1-solid.ace create mode 100644 tests/TestArchives/Archives/Ace.method1.ace create mode 100644 tests/TestArchives/Archives/Ace.method2-solid.ace create mode 100644 tests/TestArchives/Archives/Ace.method2.ace create mode 100644 tests/TestArchives/Archives/Ace.store.ace create mode 100644 tests/TestArchives/Archives/Ace.store.largefile.ace create mode 100644 tests/TestArchives/Archives/Ace.store.split.ace create mode 100644 tests/TestArchives/Archives/Ace.store.split.c00 diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json index 03df23230..cdb3c8d1b 100644 --- a/.config/dotnet-tools.json +++ b/.config/dotnet-tools.json @@ -3,7 +3,7 @@ "isRoot": true, "tools": { "csharpier": { - "version": "1.2.1", + "version": "1.2.5", "commands": [ "csharpier" ], diff --git a/.github/COPILOT_AGENT_README.md b/.github/COPILOT_AGENT_README.md deleted file mode 100644 index 11f6cb5b6..000000000 --- a/.github/COPILOT_AGENT_README.md +++ /dev/null @@ -1,15 +0,0 @@ -# Copilot Coding Agent Configuration - -This repository includes a minimal opt-in configuration and CI workflow to allow the GitHub Copilot coding agent to open and validate PRs. - -- .copilot-agent.yml: opt-in config for automated agents -- .github/agents/copilot-agent.yml: detailed agent policy configuration -- .github/workflows/dotnetcore.yml: CI runs on PRs touching the solution, source, or tests to validate changes -- AGENTS.md: general instructions for Copilot coding agent with project-specific guidelines - -Maintainers can adjust the allowed paths or disable the agent by editing or removing .copilot-agent.yml. - -Notes: -- The agent can create, modify, and delete files within the allowed paths (src, tests, README.md, AGENTS.md) -- All changes require review before merge -- If build/test paths are different, update the workflow accordingly; this workflow targets SharpCompress.sln and the SharpCompress.Test test project. diff --git a/.github/prompts/plan-async.prompt.md b/.github/prompts/plan-async.prompt.md new file mode 100644 index 000000000..50f853fa2 --- /dev/null +++ b/.github/prompts/plan-async.prompt.md @@ -0,0 +1,25 @@ +# Plan: Implement Missing Async Functionality in SharpCompress + +SharpCompress has async support for low-level stream operations and Reader/Writer APIs, but critical entry points (Archive.Open, factory methods, initialization) remain synchronous. This plan adds async overloads for all user-facing I/O operations and fixes existing async bugs, enabling full end-to-end async workflows. + +## Steps + +1. **Add async factory methods** to [ArchiveFactory.cs](src/SharpCompress/Factories/ArchiveFactory.cs), [ReaderFactory.cs](src/SharpCompress/Factories/ReaderFactory.cs), and [WriterFactory.cs](src/SharpCompress/Factories/WriterFactory.cs) with `OpenAsync` and `CreateAsync` overloads accepting `CancellationToken` + +2. **Implement async Open methods** on concrete archive types ([ZipArchive.cs](src/SharpCompress/Archives/Zip/ZipArchive.cs), [TarArchive.cs](src/SharpCompress/Archives/Tar/TarArchive.cs), [RarArchive.cs](src/SharpCompress/Archives/Rar/RarArchive.cs), [GZipArchive.cs](src/SharpCompress/Archives/GZip/GZipArchive.cs), [SevenZipArchive.cs](src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs)) and reader types ([ZipReader.cs](src/SharpCompress/Readers/Zip/ZipReader.cs), [TarReader.cs](src/SharpCompress/Readers/Tar/TarReader.cs), etc.) + +3. **Convert archive initialization logic to async** including header reading, volume loading, and format signature detection across archive constructors and internal initialization methods + +4. **Fix LZMA decoder async bugs** in [LzmaStream.cs](src/SharpCompress/Compressors/LZMA/LzmaStream.cs), [Decoder.cs](src/SharpCompress/Compressors/LZMA/Decoder.cs), and [OutWindow.cs](src/SharpCompress/Compressors/LZMA/OutWindow.cs) to enable true async 7Zip support and remove `NonDisposingStream` workaround + +5. **Complete Rar async implementation** by converting `UnpackV2017` methods to async in [UnpackV2017.cs](src/SharpCompress/Compressors/Rar/UnpackV2017.cs) and updating Rar20 decompression + +6. **Add comprehensive async tests** covering all new async entry points, cancellation scenarios, and concurrent operations across all archive formats in test files + +## Further Considerations + +1. **Breaking changes** - Should new async methods be added alongside existing sync methods (non-breaking), or should sync methods eventually be deprecated? Recommend additive approach for backward compatibility. + +2. **Performance impact** - Header parsing for formats like Zip/Tar is often small; consider whether truly async parsing adds value vs sync parsing wrapped in Task, or make it conditional based on stream type (network vs file). + +3. **7Zip complexity** - The LZMA async bug fix (Step 4) may be challenging due to state management in the decoder; consider whether to scope it separately or implement a simpler workaround that maintains correctness. diff --git a/.github/prompts/plan-for-next.prompt.md b/.github/prompts/plan-for-next.prompt.md new file mode 100644 index 000000000..2bdedd974 --- /dev/null +++ b/.github/prompts/plan-for-next.prompt.md @@ -0,0 +1,123 @@ +# Plan: Modernize SharpCompress Public API + +Based on comprehensive analysis, the API has several inconsistencies around factory patterns, async support, format capabilities, and options classes. Most improvements can be done incrementally without breaking changes. + +## Steps + +1. **Standardize factory patterns** by deprecating format-specific static `Open` methods in [Archives/Zip/ZipArchive.cs](src/SharpCompress/Archives/Zip/ZipArchive.cs), [Archives/Tar/TarArchive.cs](src/SharpCompress/Archives/Tar/TarArchive.cs), etc. in favor of centralized [Factories/ArchiveFactory.cs](src/SharpCompress/Factories/ArchiveFactory.cs) + +2. **Complete async implementation** in [Writers/Zip/ZipWriter.cs](src/SharpCompress/Writers/Zip/ZipWriter.cs) and other writers that currently use sync-over-async, implementing true async I/O throughout the writer hierarchy + +3. **Unify options classes** by making [Common/ExtractionOptions.cs](src/SharpCompress/Common/ExtractionOptions.cs) inherit from `OptionsBase` and adding progress reporting to extraction methods consistently + +4. **Clarify GZip semantics** in [Archives/GZip/GZipArchive.cs](src/SharpCompress/Archives/GZip/GZipArchive.cs) by adding XML documentation explaining single-entry limitation and relationship to GZip compression used in Tar.gz + +## Further Considerations + +1. **Breaking changes roadmap** - Should we plan a major version (2.0) to remove deprecated factory methods, clean up `ArchiveType` enum (remove Arc/Arj or add full support), and consolidate naming patterns? + +2. **Progress reporting consistency** - Should `IProgress>` be added to all extraction extension methods or consolidated into options classes? + +## Detailed Analysis + +### Factory Pattern Issues + +Three different factory patterns exist with overlapping functionality: + +1. **Static Factories**: ArchiveFactory, ReaderFactory, WriterFactory +2. **Instance Factories**: IArchiveFactory, IReaderFactory, IWriterFactory +3. **Format-specific static methods**: Each archive class has static `Open` methods + +**Example confusion:** +```csharp +// Three ways to open a Zip archive - which is recommended? +var archive1 = ArchiveFactory.Open("file.zip"); +var archive2 = ZipArchive.Open("file.zip"); +var archive3 = ArchiveFactory.AutoFactory.Open(fileInfo, options); +``` + +### Async Support Gaps + +Base `IWriter` interface has async methods, but writer implementations provide minimal async support. Most writers just call synchronous methods: + +```csharp +public virtual async Task WriteAsync(...) +{ + // Default implementation calls synchronous version + Write(filename, source, modificationTime); + await Task.CompletedTask.ConfigureAwait(false); +} +``` + +Real async implementations only in: +- `TarWriter` - Proper async implementation +- Most other writers use sync-over-async + +### GZip Archive Special Case + +GZip is treated as both a compression format and an archive format, but only supports single-entry archives: + +```csharp +protected override GZipArchiveEntry CreateEntryInternal(...) +{ + if (Entries.Any()) + { + throw new InvalidFormatException("Only one entry is allowed in a GZip Archive"); + } + // ... +} +``` + +### Options Class Hierarchy + +``` +OptionsBase (LeaveStreamOpen, ArchiveEncoding) + ├─ ReaderOptions (LookForHeader, Password, DisableCheckIncomplete, BufferSize, ExtensionHint, Progress) + ├─ WriterOptions (CompressionType, CompressionLevel, Progress) + │ ├─ ZipWriterOptions (ArchiveComment, UseZip64) + │ ├─ TarWriterOptions (FinalizeArchiveOnClose, HeaderFormat) + │ └─ GZipWriterOptions (no additional properties) + └─ ExtractionOptions (standalone - Overwrite, ExtractFullPath, PreserveFileTime, PreserveAttributes) +``` + +**Issues:** +- `ExtractionOptions` doesn't inherit from `OptionsBase` - no encoding support during extraction +- Progress reporting inconsistency between readers and extraction +- Obsolete properties (`ChecksumIsValid`, `Version`) with unclear migration path + +### Implementation Priorities + +**High Priority (Non-Breaking):** +1. Add API usage guide (Archive vs Reader, factory recommendations, async best practices) +2. Fix progress reporting consistency +3. Complete async implementation in writers + +**Medium Priority (Next Major Version):** +1. Unify factory pattern - deprecate format-specific static `Open` methods +2. Clean up options classes - make `ExtractionOptions` inherit from `OptionsBase` +3. Clarify archive types - remove Arc/Arj from `ArchiveType` enum or add full support +4. Standardize naming across archive types + +**Low Priority:** +1. Add BZip2 archive support similar to GZipArchive +2. Complete obsolete property cleanup with migration guide + +### Backward Compatibility Strategy + +**Safe (Non-Breaking) Changes:** +- Add new methods to interfaces (use default implementations) +- Add new options properties (with defaults) +- Add new factory methods +- Improve async implementations +- Add progress reporting support + +**Breaking Changes to Avoid:** +- ❌ Removing format-specific `Open` methods (deprecate instead) +- ❌ Changing `LeaveStreamOpen` default (currently `true`) +- ❌ Removing obsolete properties before major version bump +- ❌ Changing return types or signatures of existing methods + +**Deprecation Pattern:** +- Use `[Obsolete]` for one major version +- Use `[EditorBrowsable(EditorBrowsableState.Never)]` in next major version +- Remove in following major version diff --git a/.github/workflows/NUGET_RELEASE.md b/.github/workflows/NUGET_RELEASE.md new file mode 100644 index 000000000..423750897 --- /dev/null +++ b/.github/workflows/NUGET_RELEASE.md @@ -0,0 +1,155 @@ +# NuGet Release Workflow + +This document describes the automated NuGet release workflow for SharpCompress. + +## Overview + +The `nuget-release.yml` workflow automatically builds, tests, and publishes SharpCompress packages to NuGet.org when: +- Changes are pushed to the `master` or `release` branch +- A version tag (format: `MAJOR.MINOR.PATCH`) is pushed + +The workflow runs on both Windows and Ubuntu, but only the Windows build publishes to NuGet. + +## How It Works + +### Version Determination + +The workflow automatically determines the version based on whether the commit is tagged using C# code in the build project: + +1. **Tagged Release (Stable)**: + - If the current commit has a version tag (e.g., `0.42.1`) + - Uses the tag as the version number + - Published as a stable release + +2. **Untagged Release (Prerelease)**: + - If the current commit is NOT tagged + - Creates a prerelease version based on the next minor version + - Format: `{NEXT_MINOR_VERSION}-beta.{COMMIT_COUNT}` + - Example: `0.43.0-beta.123` (if last tag is 0.42.x) + - Published as a prerelease to NuGet.org (Windows build only) + +### Workflow Steps + +The workflow runs on a matrix of operating systems (Windows and Ubuntu): + +1. **Checkout**: Fetches the repository with full history for version detection +2. **Setup .NET**: Installs .NET 10.0 +3. **Determine Version**: Runs `determine-version` build target to check for tags and determine version +4. **Update Version**: Runs `update-version` build target to update the version in the project file +5. **Build and Test**: Runs the full build and test suite on both platforms +6. **Upload Artifacts**: Uploads the generated `.nupkg` files as workflow artifacts (separate for each OS) +7. **Push to NuGet**: (Windows only) Runs `push-to-nuget` build target to publish the package to NuGet.org using the API key + +All version detection, file updates, and publishing logic is implemented in C# in the `build/Program.cs` file using build targets. + +## Setup Requirements + +### 1. NuGet API Key Secret + +The workflow requires a `NUGET_API_KEY` secret to be configured in the repository settings: + +1. Go to https://www.nuget.org/account/apikeys +2. Create a new API key with "Push" permission for the SharpCompress package +3. In GitHub, go to: **Settings** → **Secrets and variables** → **Actions** +4. Create a new secret named `NUGET_API_KEY` with the API key value + +### 2. Branch Protection (Recommended) + +Consider enabling branch protection rules for the `release` branch to ensure: +- Code reviews are required before merging +- Status checks pass before merging +- Only authorized users can push to the branch + +## Usage + +### Creating a Stable Release + +There are two ways to trigger a stable release: + +**Method 1: Push tag to trigger workflow** +1. Ensure all changes are committed on the `master` or `release` branch +2. Create and push a version tag: + ```bash + git checkout master # or release + git tag 0.43.0 + git push origin 0.43.0 + ``` +3. The workflow will automatically trigger, build, test, and publish `SharpCompress 0.43.0` to NuGet.org (Windows build) + +**Method 2: Tag after pushing to branch** +1. Ensure all changes are merged and pushed to the `master` or `release` branch +2. Create and push a version tag on the already-pushed commit: + ```bash + git checkout master # or release + git tag 0.43.0 + git push origin 0.43.0 + ``` +3. The workflow will automatically trigger, build, test, and publish `SharpCompress 0.43.0` to NuGet.org (Windows build) + +### Creating a Prerelease + +1. Push changes to the `master` or `release` branch without tagging: + ```bash + git checkout master # or release + git push origin master # or release + ``` +2. The workflow will automatically: + - Build and test the project on both Windows and Ubuntu + - Publish a prerelease version like `0.43.0-beta.456` to NuGet.org (Windows build) + +## Troubleshooting + +### Workflow Fails to Push to NuGet + +- **Check the API Key**: Ensure `NUGET_API_KEY` is set correctly in repository secrets +- **Check API Key Permissions**: Verify the API key has "Push" permission for SharpCompress +- **Check API Key Expiration**: NuGet API keys may expire; create a new one if needed + +### Version Conflict + +If you see "Package already exists" errors: +- The workflow uses `--skip-duplicate` flag to handle this gracefully +- If you need to republish the same version, delete it from NuGet.org first (if allowed) + +### Build or Test Failures + +- The workflow will not push to NuGet if build or tests fail +- Check the workflow logs in GitHub Actions for details +- Fix the issues and push again + +## Manual Package Creation + +If you need to create a package manually without publishing: + +```bash +dotnet run --project build/build.csproj -- publish +``` + +The package will be created in the `artifacts/` directory. + +## Build Targets + +The workflow uses the following C# build targets defined in `build/Program.cs`: + +- **determine-version**: Detects version from git tags and outputs VERSION and PRERELEASE variables +- **update-version**: Updates VersionPrefix, AssemblyVersion, and FileVersion in the project file +- **push-to-nuget**: Pushes the generated NuGet packages to NuGet.org (requires NUGET_API_KEY) + +These targets can be run manually for testing: + +```bash +# Determine the version +dotnet run --project build/build.csproj -- determine-version + +# Update version in project file +VERSION=0.43.0 dotnet run --project build/build.csproj -- update-version + +# Push to NuGet (requires NUGET_API_KEY environment variable) +NUGET_API_KEY=your-key dotnet run --project build/build.csproj -- push-to-nuget +``` + +## Related Files + +- `.github/workflows/nuget-release.yml` - The workflow definition +- `build/Program.cs` - Build script with version detection and publishing logic +- `src/SharpCompress/SharpCompress.csproj` - Project file with version information diff --git a/.github/workflows/TESTING.md b/.github/workflows/TESTING.md new file mode 100644 index 000000000..6afaa8aae --- /dev/null +++ b/.github/workflows/TESTING.md @@ -0,0 +1,120 @@ +# Testing Guide for NuGet Release Workflow + +This document describes how to test the NuGet release workflow. + +## Testing Strategy + +Since this workflow publishes to NuGet.org and requires repository secrets, testing should be done carefully. The workflow runs on both Windows and Ubuntu, but only the Windows build publishes to NuGet. + +## Pre-Testing Checklist + +- [x] Workflow YAML syntax validated +- [x] Version determination logic tested locally +- [x] Version update logic tested locally +- [x] Build script works (`dotnet run --project build/build.csproj`) + +## Manual Testing Steps + +### 1. Test Prerelease Publishing (Recommended First Test) + +This tests the workflow on untagged commits to the master or release branch. + +**Steps:** +1. Ensure `NUGET_API_KEY` secret is configured in repository settings +2. Create a test commit on the `master` or `release` branch (e.g., update a comment or README) +3. Push to the `master` or `release` branch +4. Monitor the GitHub Actions workflow at: https://github.com/adamhathcock/sharpcompress/actions +5. Verify: + - Workflow triggers and runs successfully on both Windows and Ubuntu + - Version is determined correctly (e.g., `0.43.0-beta.XXX` if last tag is 0.42.x) + - Build and tests pass on both platforms + - Package artifacts are uploaded for both platforms + - Package is pushed to NuGet.org as prerelease (Windows build only) + +**Expected Outcome:** +- A new prerelease package appears on NuGet.org: https://www.nuget.org/packages/SharpCompress/ +- Package version follows pattern: `{NEXT_MINOR_VERSION}-beta.{COMMIT_COUNT}` + +### 2. Test Tagged Release Publishing + +This tests the workflow when a version tag is pushed. + +**Steps:** +1. Prepare the `master` or `release` branch with all desired changes +2. Create a version tag (must be a pure semantic version like `MAJOR.MINOR.PATCH`): + ```bash + git checkout master # or release + git tag 0.42.2 + git push origin 0.42.2 + ``` +3. Monitor the GitHub Actions workflow +4. Verify: + - Workflow triggers and runs successfully on both Windows and Ubuntu + - Version is determined as the tag (e.g., `0.42.2`) + - Build and tests pass on both platforms + - Package artifacts are uploaded for both platforms + - Package is pushed to NuGet.org as stable release (Windows build only) + +**Expected Outcome:** +- A new stable release package appears on NuGet.org +- Package version matches the tag + +### 3. Test Duplicate Package Handling + +This tests the `--skip-duplicate` flag behavior. + +**Steps:** +1. Push to the `release` branch without making changes +2. Monitor the workflow +3. Verify: + - Workflow runs but NuGet push is skipped with "duplicate" message + - No errors occur + +### 4. Test Build Failure Handling + +This tests that failed builds don't publish packages. + +**Steps:** +1. Introduce a breaking change in a test or code +2. Push to the `release` branch +3. Verify: + - Workflow runs and detects the failure + - Build or test step fails + - NuGet push step is skipped + - No package is published + +## Verification + +After each test, verify: + +1. **GitHub Actions Logs**: Check the workflow logs for any errors or warnings +2. **NuGet.org**: Verify the package appears with correct version and metadata +3. **Artifacts**: Download and inspect the uploaded artifacts + +## Rollback/Cleanup + +If testing produces unwanted packages: + +1. **Prerelease packages**: Can be unlisted on NuGet.org (Settings → Unlist) +2. **Stable packages**: Cannot be deleted, only unlisted (use test versions) +3. **Tags**: Can be deleted with: + ```bash + git tag -d 0.42.2 + git push origin :refs/tags/0.42.2 + ``` + +## Known Limitations + +- NuGet.org does not allow re-uploading the same version +- Deleted packages on NuGet.org reserve the version number +- The workflow requires the `NUGET_API_KEY` secret to be set + +## Success Criteria + +The workflow is considered successful if: + +- ✅ Prerelease versions are published correctly with beta suffix +- ✅ Tagged versions are published as stable releases +- ✅ Build and test failures prevent publishing +- ✅ Duplicate packages are handled gracefully +- ✅ Workflow logs are clear and informative diff --git a/.github/workflows/dotnetcore.yml b/.github/workflows/dotnetcore.yml deleted file mode 100644 index fa268a672..000000000 --- a/.github/workflows/dotnetcore.yml +++ /dev/null @@ -1,25 +0,0 @@ -name: SharpCompress -on: - push: - branches: - - 'master' - pull_request: - types: [ opened, synchronize, reopened, ready_for_review ] - -jobs: - build: - runs-on: ${{ matrix.os }} - strategy: - matrix: - os: [windows-latest, ubuntu-latest] - - steps: - - uses: actions/checkout@v6 - - uses: actions/setup-dotnet@v5 - with: - dotnet-version: 8.0.x - - run: dotnet run --project build/build.csproj - - uses: actions/upload-artifact@v5 - with: - name: ${{ matrix.os }}-sharpcompress.nupkg - path: artifacts/* diff --git a/.github/workflows/nuget-release.yml b/.github/workflows/nuget-release.yml new file mode 100644 index 000000000..253a93edb --- /dev/null +++ b/.github/workflows/nuget-release.yml @@ -0,0 +1,61 @@ +name: NuGet Release + +on: + push: + branches: + - 'master' + - 'release' + tags: + - '[0-9]+.[0-9]+.[0-9]+' + pull_request: + branches: + - 'master' + - 'release' + +permissions: + contents: read + +jobs: + build-and-publish: + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [windows-latest, ubuntu-latest] + + steps: + - uses: actions/checkout@v6 + with: + fetch-depth: 0 # Fetch all history for versioning + + - uses: actions/setup-dotnet@v5 + with: + dotnet-version: 10.0.x + + # Determine version using C# build target + - name: Determine Version + id: version + run: dotnet run --project build/build.csproj -- determine-version + + # Update version in project file using C# build target + - name: Update Version in Project + run: dotnet run --project build/build.csproj -- update-version + env: + VERSION: ${{ steps.version.outputs.version }} + + # Build and test + - name: Build and Test + run: dotnet run --project build/build.csproj + + # Upload artifacts for verification + - name: Upload NuGet Package + uses: actions/upload-artifact@v6 + with: + name: ${{ matrix.os }}-nuget-package + path: artifacts/*.nupkg + + # Push to NuGet.org using C# build target (Windows only, not on PRs) + - name: Push to NuGet + if: success() && matrix.os == 'windows-latest' && github.event_name != 'pull_request' + run: dotnet run --project build/build.csproj -- push-to-nuget + env: + NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }} diff --git a/.gitignore b/.gitignore index f101b3b15..6c6a863dc 100644 --- a/.gitignore +++ b/.gitignore @@ -15,8 +15,8 @@ tests/TestArchives/*/Scratch tests/TestArchives/*/Scratch2 .vs tools -.vscode .idea/ +artifacts/ .DS_Store *.snupkg diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 000000000..0c9d8a371 --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,9 @@ +{ + "recommendations": [ + "ms-dotnettools.csdevkit", + "ms-dotnettools.csharp", + "ms-dotnettools.vscode-dotnet-runtime", + "csharpier.csharpier-vscode", + "formulahendry.dotnet-test-explorer" + ] +} diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 000000000..8171a42b1 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,97 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": "Debug Tests (net10.0)", + "type": "coreclr", + "request": "launch", + "preLaunchTask": "build", + "program": "dotnet", + "args": [ + "test", + "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj", + "-f", + "net10.0", + "--no-build", + "--verbosity=normal" + ], + "cwd": "${workspaceFolder}", + "console": "internalConsole", + "stopAtEntry": false + }, + { + "name": "Debug Specific Test (net10.0)", + "type": "coreclr", + "request": "launch", + "preLaunchTask": "build", + "program": "dotnet", + "args": [ + "test", + "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj", + "-f", + "net10.0", + "--no-build", + "--filter", + "FullyQualifiedName~${input:testName}" + ], + "cwd": "${workspaceFolder}", + "console": "internalConsole", + "stopAtEntry": false + }, + { + "name": "Debug Performance Tests", + "type": "coreclr", + "request": "launch", + "preLaunchTask": "build", + "program": "dotnet", + "args": [ + "run", + "--project", + "${workspaceFolder}/tests/SharpCompress.Performance/SharpCompress.Performance.csproj", + "--no-build" + ], + "cwd": "${workspaceFolder}", + "console": "internalConsole", + "stopAtEntry": false + }, + { + "name": "Debug Build Script", + "type": "coreclr", + "request": "launch", + "program": "dotnet", + "args": [ + "run", + "--project", + "${workspaceFolder}/build/build.csproj", + "--", + "${input:buildTarget}" + ], + "cwd": "${workspaceFolder}", + "console": "internalConsole", + "stopAtEntry": false + } + ], + "inputs": [ + { + "id": "testName", + "type": "promptString", + "description": "Enter test name or pattern (e.g., TestMethodName or ClassName)", + "default": "" + }, + { + "id": "buildTarget", + "type": "pickString", + "description": "Select build target", + "options": [ + "clean", + "restore", + "build", + "test", + "format", + "publish", + "default" + ], + "default": "build" + } + ] +} diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 000000000..079985397 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,29 @@ +{ + "dotnet.defaultSolution": "SharpCompress.sln", + "files.exclude": { + "**/bin": true, + "**/obj": true + }, + "files.watcherExclude": { + "**/bin/**": true, + "**/obj/**": true, + "**/artifacts/**": true + }, + "search.exclude": { + "**/bin": true, + "**/obj": true, + "**/artifacts": true + }, + "editor.formatOnSave": false, + "[csharp]": { + "editor.defaultFormatter": "csharpier.csharpier-vscode", + "editor.formatOnSave": true, + "editor.codeActionsOnSave": { + "source.fixAll": "explicit" + } + }, + "csharpier.enableDebugLogs": false, + "omnisharp.enableRoslynAnalyzers": true, + "omnisharp.enableEditorConfigSupport": true, + "dotnet-test-explorer.testProjectPath": "tests/**/*.csproj" +} diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 000000000..9f59e69dc --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,178 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "build", + "command": "dotnet", + "type": "process", + "args": [ + "build", + "${workspaceFolder}/SharpCompress.sln", + "/property:GenerateFullPaths=true", + "/consoleloggerparameters:NoSummary;ForceNoAlign" + ], + "problemMatcher": "$msCompile", + "group": { + "kind": "build", + "isDefault": true + } + }, + { + "label": "build-release", + "command": "dotnet", + "type": "process", + "args": [ + "build", + "${workspaceFolder}/SharpCompress.sln", + "-c", + "Release", + "/property:GenerateFullPaths=true", + "/consoleloggerparameters:NoSummary;ForceNoAlign" + ], + "problemMatcher": "$msCompile", + "group": "build" + }, + { + "label": "build-library", + "command": "dotnet", + "type": "process", + "args": [ + "build", + "${workspaceFolder}/src/SharpCompress/SharpCompress.csproj", + "/property:GenerateFullPaths=true", + "/consoleloggerparameters:NoSummary;ForceNoAlign" + ], + "problemMatcher": "$msCompile", + "group": "build" + }, + { + "label": "restore", + "command": "dotnet", + "type": "process", + "args": [ + "restore", + "${workspaceFolder}/SharpCompress.sln" + ], + "problemMatcher": "$msCompile" + }, + { + "label": "clean", + "command": "dotnet", + "type": "process", + "args": [ + "clean", + "${workspaceFolder}/SharpCompress.sln" + ], + "problemMatcher": "$msCompile" + }, + { + "label": "test", + "command": "dotnet", + "type": "process", + "args": [ + "test", + "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj", + "--no-build", + "--verbosity=normal" + ], + "problemMatcher": "$msCompile", + "group": { + "kind": "test", + "isDefault": true + }, + "dependsOn": "build" + }, + { + "label": "test-net10", + "command": "dotnet", + "type": "process", + "args": [ + "test", + "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj", + "-f", + "net10.0", + "--no-build", + "--verbosity=normal" + ], + "problemMatcher": "$msCompile", + "group": "test", + "dependsOn": "build" + }, + { + "label": "test-net48", + "command": "dotnet", + "type": "process", + "args": [ + "test", + "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj", + "-f", + "net48", + "--no-build", + "--verbosity=normal" + ], + "problemMatcher": "$msCompile", + "group": "test", + "dependsOn": "build" + }, + { + "label": "format", + "command": "dotnet", + "type": "process", + "args": [ + "csharpier", + "." + ], + "problemMatcher": [] + }, + { + "label": "format-check", + "command": "dotnet", + "type": "process", + "args": [ + "csharpier", + "check", + "." + ], + "problemMatcher": [] + }, + { + "label": "run-build-script", + "command": "dotnet", + "type": "process", + "args": [ + "run", + "--project", + "${workspaceFolder}/build/build.csproj" + ], + "problemMatcher": "$msCompile" + }, + { + "label": "pack", + "command": "dotnet", + "type": "process", + "args": [ + "pack", + "${workspaceFolder}/src/SharpCompress/SharpCompress.csproj", + "-c", + "Release", + "-o", + "${workspaceFolder}/artifacts/" + ], + "problemMatcher": "$msCompile", + "dependsOn": "build-release" + }, + { + "label": "performance-tests", + "command": "dotnet", + "type": "process", + "args": [ + "run", + "--project", + "${workspaceFolder}/tests/SharpCompress.Performance/SharpCompress.Performance.csproj", + "-c", + "Release" + ], + "problemMatcher": "$msCompile" + } + ] +} diff --git a/AGENTS.md b/AGENTS.md index 8275b651f..ae36265aa 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -28,14 +28,38 @@ SharpCompress is a pure C# compression library supporting multiple archive forma ## Code Formatting +**Copilot agents: You MUST run the `format` task after making code changes to ensure consistency.** + - Use CSharpier for code formatting to ensure consistent style across the project - CSharpier is configured as a local tool in `.config/dotnet-tools.json` -- Restore tools with: `dotnet tool restore` -- Format files from the project root with: `dotnet csharpier .` -- **Run `dotnet csharpier .` from the project root after making code changes before committing** -- Configure your IDE to format on save using CSharpier for the best experience + +### Commands + +1. **Restore tools** (first time only): + ```bash + dotnet tool restore + ``` + +2. **Check if files are formatted correctly** (doesn't modify files): + ```bash + dotnet csharpier check . + ``` + - Exit code 0: All files are properly formatted + - Exit code 1: Some files need formatting (will show which files and differences) + +3. **Format files** (modifies files): + ```bash + dotnet csharpier format . + ``` + - Formats all files in the project to match CSharpier style + - Run from project root directory + +4. **Configure your IDE** to format on save using CSharpier for the best experience + +### Additional Notes - The project also uses `.editorconfig` for editor settings (indentation, encoding, etc.) - Let CSharpier handle code style while `.editorconfig` handles editor behavior +- Always run `dotnet csharpier check .` before committing to verify formatting ## Project Setup and Structure @@ -49,6 +73,30 @@ SharpCompress is a pure C# compression library supporting multiple archive forma - Use `dotnet test` to run tests - Solution file: `SharpCompress.sln` +### Directory Structure +``` +src/SharpCompress/ + ├── Archives/ # IArchive implementations (Zip, Tar, Rar, 7Zip, GZip) + ├── Readers/ # IReader implementations (forward-only) + ├── Writers/ # IWriter implementations (forward-only) + ├── Compressors/ # Low-level compression streams (BZip2, Deflate, LZMA, etc.) + ├── Factories/ # Format detection and factory pattern + ├── Common/ # Shared types (ArchiveType, Entry, Options) + ├── Crypto/ # Encryption implementations + └── IO/ # Stream utilities and wrappers + +tests/SharpCompress.Test/ + ├── Zip/, Tar/, Rar/, SevenZip/, GZip/, BZip2/ # Format-specific tests + ├── TestBase.cs # Base test class with helper methods + └── TestArchives/ # Test data (not checked into main test project) +``` + +### Factory Pattern +All format types implement factory interfaces (`IArchiveFactory`, `IReaderFactory`, `IWriterFactory`) for auto-detection: +- `ReaderFactory.Open()` - Auto-detects format by probing stream +- `WriterFactory.Open()` - Creates writer for specified `ArchiveType` +- Factories located in: `src/SharpCompress/Factories/` + ## Nullable Reference Types - Declare variables non-nullable, and check for `null` at entry points. @@ -116,3 +164,18 @@ SharpCompress supports multiple archive and compression formats: - Use test archives from `tests/TestArchives` directory for consistency. - Test stream disposal and `LeaveStreamOpen` behavior. - Test edge cases: empty archives, large files, corrupted archives, encrypted archives. + +### Test Organization +- Base class: `TestBase` - Provides `TEST_ARCHIVES_PATH`, `SCRATCH_FILES_PATH`, temp directory management +- Framework: xUnit with AwesomeAssertions +- Test archives: `tests/TestArchives/` - Use existing archives, don't create new ones unnecessarily +- Match naming style of nearby test files + +## Common Pitfalls + +1. **Don't mix Archive and Reader APIs** - Archive needs seekable stream, Reader doesn't +2. **Solid archives (Rar, 7Zip)** - Use `ExtractAllEntries()` for best performance, not individual entry extraction +3. **Stream disposal** - Always set `LeaveStreamOpen` explicitly when needed (default is to close) +4. **Tar + non-seekable stream** - Must provide file size or it will throw +5. **Multi-framework differences** - Some features differ between .NET Framework and modern .NET (e.g., Mono.Posix) +6. **Format detection** - Use `ReaderFactory.Open()` for auto-detection, test with actual archive files diff --git a/Directory.Packages.props b/Directory.Packages.props index 216d1de4e..bdb5dfb2d 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -1,20 +1,19 @@ - + - - - + + + - + + - - - + diff --git a/FORMATS.md b/FORMATS.md index 32dcc2885..13cff98ab 100644 --- a/FORMATS.md +++ b/FORMATS.md @@ -10,7 +10,10 @@ | Archive Format | Compression Format(s) | Compress/Decompress | Archive API | Reader API | Writer API | | ---------------------- | ------------------------------------------------- | ------------------- | --------------- | ---------- | ------------- | -| Rar | Rar | Decompress (1) | RarArchive | RarReader | N/A | +| Ace | None | Decompress | N/A | AceReader | N/A | +| Arc | None, Packed, Squeezed, Crunched | Decompress | N/A | ArcReader | N/A | +| Arj | None | Decompress | N/A | ArjReader | N/A | +| Rar | Rar | Decompress | RarArchive | RarReader | N/A | | Zip (2) | None, Shrink, Reduce, Implode, DEFLATE, Deflate64, BZip2, LZMA/LZMA2, PPMd | Both | ZipArchive | ZipReader | ZipWriter | | Tar | None | Both | TarArchive | TarReader | TarWriter (3) | | Tar.GZip | DEFLATE | Both | TarArchive | TarReader | TarWriter (3) | @@ -22,11 +25,28 @@ | 7Zip (4) | LZMA, LZMA2, BZip2, PPMd, BCJ, BCJ2, Deflate | Decompress | SevenZipArchive | N/A | N/A | 1. SOLID Rars are only supported in the RarReader API. -2. Zip format supports pkware and WinzipAES encryption. However, encrypted LZMA is not supported. Zip64 reading/writing is supported but only with seekable streams as the Zip spec doesn't support Zip64 data in post data descriptors. Deflate64 is only supported for reading. SOZip (Seek-Optimized ZIP) detection is supported for reading. +2. Zip format supports pkware and WinzipAES encryption. However, encrypted LZMA is not supported. Zip64 reading/writing is supported but only with seekable streams as the Zip spec doesn't support Zip64 data in post data descriptors. Deflate64 is only supported for reading. SOZip (Seek-Optimized ZIP) detection is supported for reading. See [Zip Format Notes](#zip-format-notes) for details on multi-volume archives and streaming behavior. 3. The Tar format requires a file size in the header. If no size is specified to the TarWriter and the stream is not seekable, then an exception will be thrown. -4. The 7Zip format doesn't allow for reading as a forward-only stream so 7Zip is only supported through the Archive API +4. The 7Zip format doesn't allow for reading as a forward-only stream so 7Zip is only supported through the Archive API. See [7Zip Format Notes](#7zip-format-notes) for details on async extraction behavior. 5. LZip has no support for extra data like the file name or timestamp. There is a default filename used when looking at the entry Key on the archive. +### Zip Format Notes + +- Multi-volume/split ZIP archives require ZipArchive (seekable streams) as ZipReader cannot seek across volume files. +- ZipReader processes entries from LocalEntry headers (which include directory entries ending with `/`) and intentionally skips DirectoryEntry headers from the central directory, as they are redundant in streaming mode - all entry data comes from LocalEntry headers which ZipReader has already processed. + +### 7Zip Format Notes + +- **Async Extraction Performance**: When using async extraction methods (e.g., `ExtractAllEntries()` with `MoveToNextEntryAsync()`), each file creates its own decompression stream to avoid state corruption in the LZMA decoder. This is less efficient than synchronous extraction, which can reuse a single decompression stream for multiple files in the same folder. + + **Performance Impact**: For archives with many small files in the same compression folder, async extraction will be slower than synchronous extraction because it must: + 1. Create a new LZMA decoder for each file + 2. Skip through the decompressed data to reach each file's starting position + + **Recommendation**: For best performance with 7Zip archives, use synchronous extraction methods (`MoveToNextEntry()` and `WriteEntryToDirectory()`) when possible. Use async methods only when you need to avoid blocking the thread (e.g., in UI applications or async-only contexts). + + **Technical Details**: 7Zip archives group files into "folders" (compression units), where all files in a folder share one continuous LZMA-compressed stream. The LZMA decoder maintains internal state (dictionary window, decoder positions) that assumes sequential, non-interruptible processing. Async operations can yield control during awaits, which would corrupt this shared state. To avoid this, async extraction creates a fresh decoder stream for each file. + ## Compression Streams For those who want to directly compress/decompress bits. The single file formats are represented here as well. However, BZip2, LZip and XZ have no metadata (GZip has a little) so using them without something like a Tar file makes little sense. diff --git a/README.md b/README.md index f333d4972..172003c17 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # SharpCompress -SharpCompress is a compression library in pure C# for .NET Framework 4.62, .NET Standard 2.1, .NET 6.0 and NET 8.0 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip, unzstd, unarc and unarj with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented. +SharpCompress is a compression library in pure C# for .NET Framework 4.8, .NET 8.0 and .NET 10.0 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip, unzstd, unarc and unarj with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented. The major feature is support for non-seekable streams so large files can be processed on the fly (i.e. download stream). diff --git a/SharpCompress.sln b/SharpCompress.sln index fc9b64b8c..ba04063bf 100644 --- a/SharpCompress.sln +++ b/SharpCompress.sln @@ -20,7 +20,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Config", "Config", "{CDB425 .editorconfig = .editorconfig Directory.Packages.props = Directory.Packages.props NuGet.config = NuGet.config - .github\workflows\dotnetcore.yml = .github\workflows\dotnetcore.yml + .github\workflows\nuget-release.yml = .github\workflows\nuget-release.yml USAGE.md = USAGE.md README.md = README.md FORMATS.md = FORMATS.md diff --git a/USAGE.md b/USAGE.md index a06d2e834..1e3a6c78f 100644 --- a/USAGE.md +++ b/USAGE.md @@ -87,20 +87,17 @@ memoryStream.Position = 0; ### Extract all files from a rar file to a directory using RarArchive Note: Extracting a solid rar or 7z file needs to be done in sequential order to get acceptable decompression speed. -It is explicitly recommended to use `ExtractAllEntries` when extracting an entire `IArchive` instead of iterating over all its `Entries`. -Alternatively, use `IArchive.WriteToDirectory`. +`ExtractAllEntries` is primarily intended for solid archives (like solid Rar) or 7Zip archives, where sequential extraction provides the best performance. For general/simple extraction with any supported archive type, use `archive.WriteToDirectory()` instead. ```C# using (var archive = RarArchive.Open("Test.rar")) { - using (var reader = archive.ExtractAllEntries()) + // Simple extraction with RarArchive; this WriteToDirectory pattern works for all archive types + archive.WriteToDirectory(@"D:\temp", new ExtractionOptions() { - reader.WriteAllToDirectory(@"D:\temp", new ExtractionOptions() - { - ExtractFullPath = true, - Overwrite = true - }); - } + ExtractFullPath = true, + Overwrite = true + }); } ``` @@ -116,6 +113,41 @@ using (var archive = RarArchive.Open("Test.rar")) } ``` +### Extract solid Rar or 7Zip archives with manual progress reporting + +`ExtractAllEntries` only works for solid archives (Rar) or 7Zip archives. For optimal performance with these archive types, use this method: + +```C# +using (var archive = RarArchive.Open("archive.rar")) // Must be solid Rar or 7Zip +{ + if (archive.IsSolid || archive.Type == ArchiveType.SevenZip) + { + // Calculate total size for progress reporting + double totalSize = archive.Entries.Where(e => !e.IsDirectory).Sum(e => e.Size); + long completed = 0; + + using (var reader = archive.ExtractAllEntries()) + { + while (reader.MoveToNextEntry()) + { + if (!reader.Entry.IsDirectory) + { + reader.WriteEntryToDirectory(@"D:\output", new ExtractionOptions() + { + ExtractFullPath = true, + Overwrite = true + }); + + completed += reader.Entry.Size; + double progress = completed / totalSize; + Console.WriteLine($"Progress: {progress:P}"); + } + } + } + } +} +``` + ### Use ReaderFactory to autodetect archive type and Open the entry stream ```C# @@ -298,14 +330,12 @@ using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType. ```C# using (var archive = ZipArchive.Open("archive.zip")) { - using (var reader = archive.ExtractAllEntries()) - { - await reader.WriteAllToDirectoryAsync( - @"C:\output", - new ExtractionOptions() { ExtractFullPath = true, Overwrite = true }, - cancellationToken - ); - } + // Simple async extraction - works for all archive types + await archive.WriteToDirectoryAsync( + @"C:\output", + new ExtractionOptions() { ExtractFullPath = true, Overwrite = true }, + cancellationToken + ); } ``` diff --git a/build/Program.cs b/build/Program.cs index b3bb2c47e..47a867459 100644 --- a/build/Program.cs +++ b/build/Program.cs @@ -1,7 +1,10 @@ using System; using System.Collections.Generic; using System.IO; +using System.Linq; using System.Runtime.InteropServices; +using System.Text.RegularExpressions; +using System.Threading.Tasks; using GlobExpressions; using static Bullseye.Targets; using static SimpleExec.Command; @@ -11,7 +14,11 @@ const string Build = "build"; const string Test = "test"; const string Format = "format"; +const string CheckFormat = "check-format"; const string Publish = "publish"; +const string DetermineVersion = "determine-version"; +const string UpdateVersion = "update-version"; +const string PushToNuGet = "push-to-nuget"; Target( Clean, @@ -42,12 +49,20 @@ void RemoveDirectory(string d) Target( Format, () => + { + Run("dotnet", "tool restore"); + Run("dotnet", "csharpier format ."); + } +); +Target( + CheckFormat, + () => { Run("dotnet", "tool restore"); Run("dotnet", "csharpier check ."); } ); -Target(Restore, [Format], () => Run("dotnet", "restore")); +Target(Restore, [CheckFormat], () => Run("dotnet", "restore")); Target( Build, @@ -61,7 +76,7 @@ void RemoveDirectory(string d) Target( Test, [Build], - ["net8.0", "net48"], + ["net10.0", "net48"], framework => { IEnumerable GetFiles(string d) @@ -90,6 +105,164 @@ IEnumerable GetFiles(string d) } ); +Target( + DetermineVersion, + async () => + { + var (version, isPrerelease) = await GetVersion(); + Console.WriteLine($"VERSION={version}"); + Console.WriteLine($"PRERELEASE={isPrerelease.ToString().ToLower()}"); + + // Write to environment file for GitHub Actions + var githubOutput = Environment.GetEnvironmentVariable("GITHUB_OUTPUT"); + if (!string.IsNullOrEmpty(githubOutput)) + { + File.AppendAllText(githubOutput, $"version={version}\n"); + File.AppendAllText(githubOutput, $"prerelease={isPrerelease.ToString().ToLower()}\n"); + } + } +); + +Target( + UpdateVersion, + async () => + { + var version = Environment.GetEnvironmentVariable("VERSION"); + if (string.IsNullOrEmpty(version)) + { + var (detectedVersion, _) = await GetVersion(); + version = detectedVersion; + } + + Console.WriteLine($"Updating project file with version: {version}"); + + var projectPath = "src/SharpCompress/SharpCompress.csproj"; + var content = File.ReadAllText(projectPath); + + // Get base version (without prerelease suffix) + var baseVersion = version.Split('-')[0]; + + // Update VersionPrefix + content = Regex.Replace( + content, + @"[^<]*", + $"{version}" + ); + + // Update AssemblyVersion + content = Regex.Replace( + content, + @"[^<]*", + $"{baseVersion}" + ); + + // Update FileVersion + content = Regex.Replace( + content, + @"[^<]*", + $"{baseVersion}" + ); + + File.WriteAllText(projectPath, content); + Console.WriteLine($"Updated VersionPrefix to: {version}"); + Console.WriteLine($"Updated AssemblyVersion and FileVersion to: {baseVersion}"); + } +); + +Target( + PushToNuGet, + () => + { + var apiKey = Environment.GetEnvironmentVariable("NUGET_API_KEY"); + if (string.IsNullOrEmpty(apiKey)) + { + Console.WriteLine( + "NUGET_API_KEY environment variable is not set. Skipping NuGet push." + ); + return; + } + + var packages = Directory.GetFiles("artifacts", "*.nupkg"); + if (packages.Length == 0) + { + Console.WriteLine("No packages found in artifacts directory."); + return; + } + + foreach (var package in packages) + { + Console.WriteLine($"Pushing {package} to NuGet.org"); + try + { + // Note: API key is passed via command line argument which is standard practice for dotnet nuget push + // The key is already in an environment variable and not displayed in normal output + Run( + "dotnet", + $"nuget push \"{package}\" --api-key {apiKey} --source https://api.nuget.org/v3/index.json --skip-duplicate" + ); + } + catch (Exception ex) + { + Console.WriteLine($"Failed to push {package}: {ex.Message}"); + throw; + } + } + } +); + Target("default", [Publish], () => Console.WriteLine("Done!")); await RunTargetsAndExitAsync(args); + +static async Task<(string version, bool isPrerelease)> GetVersion() +{ + // Check if current commit has a version tag + var currentTag = (await GetGitOutput("tag", "--points-at HEAD")) + .Split('\n', StringSplitOptions.RemoveEmptyEntries) + .FirstOrDefault(tag => Regex.IsMatch(tag.Trim(), @"^\d+\.\d+\.\d+$")); + + if (!string.IsNullOrEmpty(currentTag)) + { + // Tagged release - use the tag as version + var version = currentTag.Trim(); + Console.WriteLine($"Building tagged release version: {version}"); + return (version, false); + } + else + { + // Not tagged - create prerelease version based on next minor version + var allTags = (await GetGitOutput("tag", "--list")) + .Split('\n', StringSplitOptions.RemoveEmptyEntries) + .Where(tag => Regex.IsMatch(tag.Trim(), @"^\d+\.\d+\.\d+$")) + .Select(tag => tag.Trim()) + .ToList(); + + var lastTag = allTags.OrderBy(tag => Version.Parse(tag)).LastOrDefault() ?? "0.0.0"; + var lastVersion = Version.Parse(lastTag); + + // Increment minor version for next release + var nextVersion = new Version(lastVersion.Major, lastVersion.Minor + 1, 0); + + // Use commit count since the last version tag if available; otherwise, fall back to total count + var revListArgs = allTags.Any() ? $"--count {lastTag}..HEAD" : "--count HEAD"; + var commitCount = (await GetGitOutput("rev-list", revListArgs)).Trim(); + + var version = $"{nextVersion}-beta.{commitCount}"; + Console.WriteLine($"Building prerelease version: {version}"); + return (version, true); + } +} + +static async Task GetGitOutput(string command, string args) +{ + try + { + // Use SimpleExec's Read to execute git commands in a cross-platform way + var (output, _) = await ReadAsync("git", $"{command} {args}"); + return output; + } + catch (Exception ex) + { + throw new Exception($"Git command failed: git {command} {args}\n{ex.Message}", ex); + } +} diff --git a/build/build.csproj b/build/build.csproj index 99e86377d..8f5b6f3c3 100644 --- a/build/build.csproj +++ b/build/build.csproj @@ -1,7 +1,7 @@ Exe - net8.0 + net10.0 diff --git a/build/packages.lock.json b/build/packages.lock.json index bc1f7953e..bfe9a5ca3 100644 --- a/build/packages.lock.json +++ b/build/packages.lock.json @@ -1,12 +1,12 @@ { "version": 2, "dependencies": { - "net8.0": { + "net10.0": { "Bullseye": { "type": "Direct", - "requested": "[6.0.0, )", - "resolved": "6.0.0", - "contentHash": "vgwwXfzs7jJrskWH7saHRMgPzziq/e86QZNWY1MnMxd7e+De7E7EX4K3C7yrvaK9y02SJoLxNxcLG/q5qUAghw==" + "requested": "[6.1.0, )", + "resolved": "6.1.0", + "contentHash": "fltnAJDe0BEX5eymXGUq+il2rSUA0pHqUonNDRH2TrvRu8SkU17mYG0IVpdmG2ibtfhdjNrv4CuTCxHOwcozCA==" }, "Glob": { "type": "Direct", @@ -16,9 +16,9 @@ }, "SimpleExec": { "type": "Direct", - "requested": "[12.0.0, )", - "resolved": "12.0.0", - "contentHash": "ptxlWtxC8vM6Y6e3h9ZTxBBkOWnWrm/Sa1HT+2i1xcXY3Hx2hmKDZP5RShPf8Xr9D+ivlrXNy57ktzyH8kyt+Q==" + "requested": "[12.1.0, )", + "resolved": "12.1.0", + "contentHash": "PcCSAlMcKr5yTd571MgEMoGmoSr+omwziq2crB47lKP740lrmjuBocAUXHj+Q6LR6aUDFyhszot2wbtFJTClkA==" } } } diff --git a/global.json b/global.json index 391ba3c2a..512142d2b 100644 --- a/global.json +++ b/global.json @@ -1,6 +1,6 @@ { "sdk": { - "version": "8.0.100", + "version": "10.0.100", "rollForward": "latestFeature" } } diff --git a/src/SharpCompress/Archives/AbstractArchive.cs b/src/SharpCompress/Archives/AbstractArchive.cs index 712db4de1..672382ffc 100644 --- a/src/SharpCompress/Archives/AbstractArchive.cs +++ b/src/SharpCompress/Archives/AbstractArchive.cs @@ -8,7 +8,7 @@ namespace SharpCompress.Archives; -public abstract class AbstractArchive : IArchive, IArchiveExtractionListener +public abstract class AbstractArchive : IArchive where TEntry : IArchiveEntry where TVolume : IVolume { @@ -17,11 +17,6 @@ public abstract class AbstractArchive : IArchive, IArchiveExtra private bool _disposed; private readonly SourceStream? _sourceStream; - public event EventHandler>? EntryExtractionBegin; - public event EventHandler>? EntryExtractionEnd; - - public event EventHandler? CompressedBytesRead; - public event EventHandler? FilePartExtractionBegin; protected ReaderOptions ReaderOptions { get; } internal AbstractArchive(ArchiveType type, SourceStream sourceStream) @@ -43,12 +38,6 @@ internal AbstractArchive(ArchiveType type) public ArchiveType Type { get; } - void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry) => - EntryExtractionBegin?.Invoke(this, new ArchiveExtractionEventArgs(entry)); - - void IArchiveExtractionListener.FireEntryExtractionEnd(IArchiveEntry entry) => - EntryExtractionEnd?.Invoke(this, new ArchiveExtractionEventArgs(entry)); - private static Stream CheckStreams(Stream stream) { if (!stream.CanSeek || !stream.CanRead) @@ -99,38 +88,12 @@ public virtual void Dispose() } } - void IArchiveExtractionListener.EnsureEntriesLoaded() + private void EnsureEntriesLoaded() { _lazyEntries.EnsureFullyLoaded(); _lazyVolumes.EnsureFullyLoaded(); } - void IExtractionListener.FireCompressedBytesRead( - long currentPartCompressedBytes, - long compressedReadBytes - ) => - CompressedBytesRead?.Invoke( - this, - new CompressedBytesReadEventArgs( - currentFilePartCompressedBytesRead: currentPartCompressedBytes, - compressedBytesRead: compressedReadBytes - ) - ); - - void IExtractionListener.FireFilePartExtractionBegin( - string name, - long size, - long compressedSize - ) => - FilePartExtractionBegin?.Invoke( - this, - new FilePartExtractionBeginEventArgs( - compressedSize: compressedSize, - size: size, - name: name - ) - ); - /// /// Use this method to extract all entries in an archive in order. /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be @@ -146,11 +109,11 @@ public IReader ExtractAllEntries() { if (!IsSolid && Type != ArchiveType.SevenZip) { - throw new InvalidOperationException( + throw new SharpCompressException( "ExtractAllEntries can only be used on solid archives or 7Zip archives (which require random access)." ); } - ((IArchiveExtractionListener)this).EnsureEntriesLoaded(); + EnsureEntriesLoaded(); return CreateReaderForSolidExtraction(); } @@ -161,6 +124,11 @@ public IReader ExtractAllEntries() /// public virtual bool IsSolid => false; + /// + /// Archive is ENCRYPTED (this means the Archive has password-protected files). + /// + public virtual bool IsEncrypted => false; + /// /// The archive can find all the parts of the archive needed to fully extract the archive. This forces the parsing of the entire archive. /// @@ -168,7 +136,7 @@ public bool IsComplete { get { - ((IArchiveExtractionListener)this).EnsureEntriesLoaded(); + EnsureEntriesLoaded(); return Entries.All(x => x.IsComplete); } } diff --git a/src/SharpCompress/Archives/IArchive.cs b/src/SharpCompress/Archives/IArchive.cs index 154529bfb..3ed7490d3 100644 --- a/src/SharpCompress/Archives/IArchive.cs +++ b/src/SharpCompress/Archives/IArchive.cs @@ -7,12 +7,6 @@ namespace SharpCompress.Archives; public interface IArchive : IDisposable { - event EventHandler> EntryExtractionBegin; - event EventHandler> EntryExtractionEnd; - - event EventHandler CompressedBytesRead; - event EventHandler FilePartExtractionBegin; - IEnumerable Entries { get; } IEnumerable Volumes { get; } diff --git a/src/SharpCompress/Archives/IArchiveEntryExtensions.cs b/src/SharpCompress/Archives/IArchiveEntryExtensions.cs index 6e76f7f90..af2c9be45 100644 --- a/src/SharpCompress/Archives/IArchiveEntryExtensions.cs +++ b/src/SharpCompress/Archives/IArchiveEntryExtensions.cs @@ -1,3 +1,4 @@ +using System; using System.IO; using System.Threading; using System.Threading.Tasks; @@ -8,127 +9,153 @@ namespace SharpCompress.Archives; public static class IArchiveEntryExtensions { - public static void WriteTo(this IArchiveEntry archiveEntry, Stream streamToWriteTo) + private const int BufferSize = 81920; + + /// The archive entry to extract. + extension(IArchiveEntry archiveEntry) { - if (archiveEntry.IsDirectory) + /// + /// Extract entry to the specified stream. + /// + /// The stream to write the entry content to. + /// Optional progress reporter for tracking extraction progress. + public void WriteTo(Stream streamToWriteTo, IProgress? progress = null) { - throw new ExtractionException("Entry is a file directory and cannot be extracted."); + if (archiveEntry.IsDirectory) + { + throw new ExtractionException("Entry is a file directory and cannot be extracted."); + } + + using var entryStream = archiveEntry.OpenEntryStream(); + var sourceStream = WrapWithProgress(entryStream, archiveEntry, progress); + sourceStream.CopyTo(streamToWriteTo, BufferSize); } - var streamListener = (IArchiveExtractionListener)archiveEntry.Archive; - streamListener.EnsureEntriesLoaded(); - streamListener.FireEntryExtractionBegin(archiveEntry); - streamListener.FireFilePartExtractionBegin( - archiveEntry.Key ?? "Key", - archiveEntry.Size, - archiveEntry.CompressedSize - ); - var entryStream = archiveEntry.OpenEntryStream(); - using (entryStream) + /// + /// Extract entry to the specified stream asynchronously. + /// + /// The stream to write the entry content to. + /// Cancellation token. + /// Optional progress reporter for tracking extraction progress. + public async Task WriteToAsync( + Stream streamToWriteTo, + IProgress? progress = null, + CancellationToken cancellationToken = default + ) { - using Stream s = new ListeningStream(streamListener, entryStream); - s.CopyTo(streamToWriteTo); + if (archiveEntry.IsDirectory) + { + throw new ExtractionException("Entry is a file directory and cannot be extracted."); + } + + using var entryStream = await archiveEntry.OpenEntryStreamAsync(cancellationToken); + var sourceStream = WrapWithProgress(entryStream, archiveEntry, progress); + await sourceStream + .CopyToAsync(streamToWriteTo, BufferSize, cancellationToken) + .ConfigureAwait(false); } - streamListener.FireEntryExtractionEnd(archiveEntry); } - public static async Task WriteToAsync( - this IArchiveEntry archiveEntry, - Stream streamToWriteTo, - CancellationToken cancellationToken = default + private static Stream WrapWithProgress( + Stream source, + IArchiveEntry entry, + IProgress? progress ) { - if (archiveEntry.IsDirectory) + if (progress is null) { - throw new ExtractionException("Entry is a file directory and cannot be extracted."); + return source; } - var streamListener = (IArchiveExtractionListener)archiveEntry.Archive; - streamListener.EnsureEntriesLoaded(); - streamListener.FireEntryExtractionBegin(archiveEntry); - streamListener.FireFilePartExtractionBegin( - archiveEntry.Key ?? "Key", - archiveEntry.Size, - archiveEntry.CompressedSize + var entryPath = entry.Key ?? string.Empty; + var totalBytes = GetEntrySizeSafe(entry); + return new ProgressReportingStream( + source, + progress, + entryPath, + totalBytes, + leaveOpen: true ); - var entryStream = archiveEntry.OpenEntryStream(); - using (entryStream) + } + + private static long? GetEntrySizeSafe(IArchiveEntry entry) + { + try { - using Stream s = new ListeningStream(streamListener, entryStream); - await s.CopyToAsync(streamToWriteTo, 81920, cancellationToken).ConfigureAwait(false); + var size = entry.Size; + return size >= 0 ? size : null; + } + catch (NotImplementedException) + { + return null; } - streamListener.FireEntryExtractionEnd(archiveEntry); } - /// - /// Extract to specific directory, retaining filename - /// - public static void WriteToDirectory( - this IArchiveEntry entry, - string destinationDirectory, - ExtractionOptions? options = null - ) => - ExtractionMethods.WriteEntryToDirectory( - entry, - destinationDirectory, - options, - entry.WriteToFile - ); + extension(IArchiveEntry entry) + { + /// + /// Extract to specific directory, retaining filename + /// + public void WriteToDirectory( + string destinationDirectory, + ExtractionOptions? options = null + ) => + ExtractionMethods.WriteEntryToDirectory( + entry, + destinationDirectory, + options, + entry.WriteToFile + ); - /// - /// Extract to specific directory asynchronously, retaining filename - /// - public static Task WriteToDirectoryAsync( - this IArchiveEntry entry, - string destinationDirectory, - ExtractionOptions? options = null, - CancellationToken cancellationToken = default - ) => - ExtractionMethods.WriteEntryToDirectoryAsync( - entry, - destinationDirectory, - options, - (x, opt) => entry.WriteToFileAsync(x, opt, cancellationToken), - cancellationToken - ); + /// + /// Extract to specific directory asynchronously, retaining filename + /// + public Task WriteToDirectoryAsync( + string destinationDirectory, + ExtractionOptions? options = null, + CancellationToken cancellationToken = default + ) => + ExtractionMethods.WriteEntryToDirectoryAsync( + entry, + destinationDirectory, + options, + entry.WriteToFileAsync, + cancellationToken + ); - /// - /// Extract to specific file - /// - public static void WriteToFile( - this IArchiveEntry entry, - string destinationFileName, - ExtractionOptions? options = null - ) => - ExtractionMethods.WriteEntryToFile( - entry, - destinationFileName, - options, - (x, fm) => - { - using var fs = File.Open(destinationFileName, fm); - entry.WriteTo(fs); - } - ); + /// + /// Extract to specific file + /// + public void WriteToFile(string destinationFileName, ExtractionOptions? options = null) => + ExtractionMethods.WriteEntryToFile( + entry, + destinationFileName, + options, + (x, fm) => + { + using var fs = File.Open(destinationFileName, fm); + entry.WriteTo(fs); + } + ); - /// - /// Extract to specific file asynchronously - /// - public static Task WriteToFileAsync( - this IArchiveEntry entry, - string destinationFileName, - ExtractionOptions? options = null, - CancellationToken cancellationToken = default - ) => - ExtractionMethods.WriteEntryToFileAsync( - entry, - destinationFileName, - options, - async (x, fm) => - { - using var fs = File.Open(destinationFileName, fm); - await entry.WriteToAsync(fs, cancellationToken).ConfigureAwait(false); - }, - cancellationToken - ); + /// + /// Extract to specific file asynchronously + /// + public Task WriteToFileAsync( + string destinationFileName, + ExtractionOptions? options = null, + CancellationToken cancellationToken = default + ) => + ExtractionMethods.WriteEntryToFileAsync( + entry, + destinationFileName, + options, + async (x, fm, ct) => + { + using var fs = File.Open(destinationFileName, fm); + await entry.WriteToAsync(fs, null, ct).ConfigureAwait(false); + }, + cancellationToken + ); + } } diff --git a/src/SharpCompress/Archives/IArchiveExtensions.cs b/src/SharpCompress/Archives/IArchiveExtensions.cs index d9701da30..0d39c6e2c 100644 --- a/src/SharpCompress/Archives/IArchiveExtensions.cs +++ b/src/SharpCompress/Archives/IArchiveExtensions.cs @@ -1,8 +1,8 @@ using System; using System.Collections.Generic; using System.IO; -using System.Linq; using System.Threading; +using System.Threading.Tasks; using SharpCompress.Common; using SharpCompress.Readers; @@ -10,76 +10,159 @@ namespace SharpCompress.Archives; public static class IArchiveExtensions { - /// - /// Extract to specific directory, retaining filename - /// - public static void WriteToDirectory( - this IArchive archive, - string destinationDirectory, - ExtractionOptions? options = null - ) - { - using var reader = archive.ExtractAllEntries(); - reader.WriteAllToDirectory(destinationDirectory, options); - } - - /// - /// Extracts the archive to the destination directory. Directories will be created as needed. - /// /// The archive to extract. - /// The folder to extract into. - /// Optional progress report callback. - /// Optional cancellation token. - public static void ExtractToDirectory( - this IArchive archive, - string destination, - Action? progressReport = null, - CancellationToken cancellationToken = default - ) + extension(IArchive archive) { - // Prepare for progress reporting - var totalBytes = archive.TotalUncompressSize; - var bytesRead = 0L; - - // Tracking for created directories. - var seenDirectories = new HashSet(); + /// + /// Extract to specific directory with progress reporting + /// + /// The folder to extract into. + /// Extraction options. + /// Optional progress reporter for tracking extraction progress. + public void WriteToDirectory( + string destinationDirectory, + ExtractionOptions? options = null, + IProgress? progress = null + ) + { + // For solid archives (Rar, 7Zip), use the optimized reader-based approach + if (archive.IsSolid || archive.Type == ArchiveType.SevenZip) + { + using var reader = archive.ExtractAllEntries(); + reader.WriteAllToDirectory(destinationDirectory, options); + } + else + { + // For non-solid archives, extract entries directly + archive.WriteToDirectoryInternal(destinationDirectory, options, progress); + } + } - // Extract - foreach (var entry in archive.Entries) + private void WriteToDirectoryInternal( + string destinationDirectory, + ExtractionOptions? options, + IProgress? progress + ) { - cancellationToken.ThrowIfCancellationRequested(); + // Prepare for progress reporting + var totalBytes = archive.TotalUncompressSize; + var bytesRead = 0L; + + // Tracking for created directories. + var seenDirectories = new HashSet(); - if (entry.IsDirectory) + // Extract + foreach (var entry in archive.Entries) { - var dirPath = Path.Combine(destination, entry.Key.NotNull("Entry Key is null")); - if ( - Path.GetDirectoryName(dirPath + "/") is { } emptyDirectory - && seenDirectories.Add(dirPath) - ) + if (entry.IsDirectory) { - Directory.CreateDirectory(emptyDirectory); + var dirPath = Path.Combine( + destinationDirectory, + entry.Key.NotNull("Entry Key is null") + ); + if ( + Path.GetDirectoryName(dirPath + "/") is { } parentDirectory + && seenDirectories.Add(dirPath) + ) + { + Directory.CreateDirectory(parentDirectory); + } + continue; } - continue; + + // Use the entry's WriteToDirectory method which respects ExtractionOptions + entry.WriteToDirectory(destinationDirectory, options); + + // Update progress + bytesRead += entry.Size; + progress?.Report( + new ProgressReport(entry.Key ?? string.Empty, bytesRead, totalBytes) + ); } + } - // Create each directory if not already created - var path = Path.Combine(destination, entry.Key.NotNull("Entry Key is null")); - if (Path.GetDirectoryName(path) is { } directory) + /// + /// Extract to specific directory asynchronously with progress reporting and cancellation support + /// + /// The folder to extract into. + /// Extraction options. + /// Optional progress reporter for tracking extraction progress. + /// Optional cancellation token. + public async Task WriteToDirectoryAsync( + string destinationDirectory, + ExtractionOptions? options = null, + IProgress? progress = null, + CancellationToken cancellationToken = default + ) + { + // For solid archives (Rar, 7Zip), use the optimized reader-based approach + if (archive.IsSolid || archive.Type == ArchiveType.SevenZip) + { + using var reader = archive.ExtractAllEntries(); + await reader.WriteAllToDirectoryAsync( + destinationDirectory, + options, + cancellationToken + ); + } + else { - if (!Directory.Exists(directory) && !seenDirectories.Contains(directory)) + // For non-solid archives, extract entries directly + await archive.WriteToDirectoryAsyncInternal( + destinationDirectory, + options, + progress, + cancellationToken + ); + } + } + + private async Task WriteToDirectoryAsyncInternal( + string destinationDirectory, + ExtractionOptions? options, + IProgress? progress, + CancellationToken cancellationToken + ) + { + // Prepare for progress reporting + var totalBytes = archive.TotalUncompressSize; + var bytesRead = 0L; + + // Tracking for created directories. + var seenDirectories = new HashSet(); + + // Extract + foreach (var entry in archive.Entries) + { + cancellationToken.ThrowIfCancellationRequested(); + + if (entry.IsDirectory) { - Directory.CreateDirectory(directory); - seenDirectories.Add(directory); + var dirPath = Path.Combine( + destinationDirectory, + entry.Key.NotNull("Entry Key is null") + ); + if ( + Path.GetDirectoryName(dirPath + "/") is { } parentDirectory + && seenDirectories.Add(dirPath) + ) + { + Directory.CreateDirectory(parentDirectory); + } + continue; } - } - // Write file - using var fs = File.OpenWrite(path); - entry.WriteTo(fs); + // Use the entry's WriteToDirectoryAsync method which respects ExtractionOptions + await entry + .WriteToDirectoryAsync(destinationDirectory, options, cancellationToken) + .ConfigureAwait(false); - // Update progress - bytesRead += entry.Size; - progressReport?.Invoke(bytesRead / (double)totalBytes); + // Update progress + bytesRead += entry.Size; + progress?.Report( + new ProgressReport(entry.Key ?? string.Empty, bytesRead, totalBytes) + ); + } } } } diff --git a/src/SharpCompress/Archives/IArchiveExtractionListener.cs b/src/SharpCompress/Archives/IArchiveExtractionListener.cs deleted file mode 100644 index 7bc2ef34e..000000000 --- a/src/SharpCompress/Archives/IArchiveExtractionListener.cs +++ /dev/null @@ -1,10 +0,0 @@ -using SharpCompress.Common; - -namespace SharpCompress.Archives; - -internal interface IArchiveExtractionListener : IExtractionListener -{ - void EnsureEntriesLoaded(); - void FireEntryExtractionBegin(IArchiveEntry entry); - void FireEntryExtractionEnd(IArchiveEntry entry); -} diff --git a/src/SharpCompress/Archives/Rar/RarArchive.cs b/src/SharpCompress/Archives/Rar/RarArchive.cs index b3689a9f5..9acfdccc5 100644 --- a/src/SharpCompress/Archives/Rar/RarArchive.cs +++ b/src/SharpCompress/Archives/Rar/RarArchive.cs @@ -84,6 +84,8 @@ protected override IReader CreateReaderForSolidExtraction() public override bool IsSolid => Volumes.First().IsSolidArchive; + public override bool IsEncrypted => Entries.First(x => !x.IsDirectory).IsEncrypted; + public virtual int MinVersion => Volumes.First().MinVersion; public virtual int MaxVersion => Volumes.First().MaxVersion; diff --git a/src/SharpCompress/Archives/Rar/RarArchiveEntry.cs b/src/SharpCompress/Archives/Rar/RarArchiveEntry.cs index aaba6d1ec..69c54f310 100644 --- a/src/SharpCompress/Archives/Rar/RarArchiveEntry.cs +++ b/src/SharpCompress/Archives/Rar/RarArchiveEntry.cs @@ -76,7 +76,7 @@ public Stream OpenEntryStream() stream = new RarStream( archive.UnpackV1.Value, FileHeader, - new MultiVolumeReadOnlyStream(Parts.Cast(), archive) + new MultiVolumeReadOnlyStream(Parts.Cast()) ); } else @@ -84,7 +84,7 @@ public Stream OpenEntryStream() stream = new RarStream( archive.UnpackV2017.Value, FileHeader, - new MultiVolumeReadOnlyStream(Parts.Cast(), archive) + new MultiVolumeReadOnlyStream(Parts.Cast()) ); } @@ -100,7 +100,7 @@ public async Task OpenEntryStreamAsync(CancellationToken cancellationTok stream = new RarStream( archive.UnpackV1.Value, FileHeader, - new MultiVolumeReadOnlyStream(Parts.Cast(), archive) + new MultiVolumeReadOnlyStream(Parts.Cast()) ); } else @@ -108,7 +108,7 @@ public async Task OpenEntryStreamAsync(CancellationToken cancellationTok stream = new RarStream( archive.UnpackV2017.Value, FileHeader, - new MultiVolumeReadOnlyStream(Parts.Cast(), archive) + new MultiVolumeReadOnlyStream(Parts.Cast()) ); } diff --git a/src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs b/src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs index ea763409d..d9b5ba1aa 100644 --- a/src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs +++ b/src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs @@ -2,6 +2,8 @@ using System.Collections.Generic; using System.IO; using System.Linq; +using System.Threading; +using System.Threading.Tasks; using SharpCompress.Common; using SharpCompress.Common.SevenZip; using SharpCompress.Compressors.LZMA.Utilites; @@ -205,15 +207,15 @@ protected override IReader CreateReaderForSolidExtraction() => .GroupBy(x => x.FilePart.Folder) .Any(folder => folder.Count() > 1); + public override bool IsEncrypted => Entries.First(x => !x.IsDirectory).IsEncrypted; + public override long TotalSize => _database?._packSizes.Aggregate(0L, (total, packSize) => total + packSize) ?? 0; private sealed class SevenZipReader : AbstractReader { private readonly SevenZipArchive _archive; - private CFolder? _currentFolder; - private Stream? _currentStream; - private CFileItem? _currentItem; + private SevenZipEntry? _currentEntry; internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive) : base(readerOptions, ArchiveType.SevenZip) => this._archive = archive; @@ -226,40 +228,135 @@ protected override IEnumerable GetEntries(Stream stream) stream.Position = 0; foreach (var dir in entries.Where(x => x.IsDirectory)) { + _currentEntry = dir; yield return dir; } - foreach ( - var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder) - ) + // For non-directory entries, yield them without creating shared streams + // Each call to GetEntryStream() will create a fresh decompression stream + // to avoid state corruption issues with async operations + foreach (var entry in entries.Where(x => !x.IsDirectory)) { - _currentFolder = group.Key; - if (group.Key is null) - { - _currentStream = Stream.Null; - } - else - { - _currentStream = _archive._database?.GetFolderStream( - stream, - _currentFolder, - new PasswordProvider(Options.Password) - ); - } - foreach (var entry in group) - { - _currentItem = entry.FilePart.Header; - yield return entry; - } + _currentEntry = entry; + yield return entry; } } - protected override EntryStream GetEntryStream() => - CreateEntryStream( - new ReadOnlySubStream( - _currentStream.NotNull("currentStream is not null"), - _currentItem?.Size ?? 0 - ) - ); + protected override EntryStream GetEntryStream() + { + // Create a fresh decompression stream for each file (no state sharing). + // However, the LZMA decoder has bugs in its async implementation that cause + // state corruption even on fresh streams. The SyncOnlyStream wrapper + // works around these bugs by forcing async operations to use sync equivalents. + // + // TODO: Fix the LZMA decoder async bugs (in LzmaStream, Decoder, OutWindow) + // so this wrapper is no longer necessary. + var entry = _currentEntry.NotNull("currentEntry is not null"); + if (entry.IsDirectory) + { + return CreateEntryStream(Stream.Null); + } + return CreateEntryStream(new SyncOnlyStream(entry.FilePart.GetCompressedStream())); + } + } + + /// + /// WORKAROUND: Forces async operations to use synchronous equivalents. + /// This is necessary because the LZMA decoder has bugs in its async implementation + /// that cause state corruption (IndexOutOfRangeException, DataErrorException). + /// + /// The proper fix would be to repair the LZMA decoder's async methods + /// (LzmaStream.ReadAsync, Decoder.CodeAsync, OutWindow async operations), + /// but that requires deep changes to the decoder state machine. + /// + private sealed class SyncOnlyStream : Stream + { + private readonly Stream _baseStream; + + public SyncOnlyStream(Stream baseStream) => _baseStream = baseStream; + + public override bool CanRead => _baseStream.CanRead; + public override bool CanSeek => _baseStream.CanSeek; + public override bool CanWrite => _baseStream.CanWrite; + public override long Length => _baseStream.Length; + public override long Position + { + get => _baseStream.Position; + set => _baseStream.Position = value; + } + + public override void Flush() => _baseStream.Flush(); + + public override int Read(byte[] buffer, int offset, int count) => + _baseStream.Read(buffer, offset, count); + + public override long Seek(long offset, SeekOrigin origin) => + _baseStream.Seek(offset, origin); + + public override void SetLength(long value) => _baseStream.SetLength(value); + + public override void Write(byte[] buffer, int offset, int count) => + _baseStream.Write(buffer, offset, count); + + // Force async operations to use sync equivalents to avoid LZMA decoder bugs + public override Task ReadAsync( + byte[] buffer, + int offset, + int count, + CancellationToken cancellationToken + ) + { + cancellationToken.ThrowIfCancellationRequested(); + return Task.FromResult(_baseStream.Read(buffer, offset, count)); + } + + public override Task WriteAsync( + byte[] buffer, + int offset, + int count, + CancellationToken cancellationToken + ) + { + cancellationToken.ThrowIfCancellationRequested(); + _baseStream.Write(buffer, offset, count); + return Task.CompletedTask; + } + + public override Task FlushAsync(CancellationToken cancellationToken) + { + cancellationToken.ThrowIfCancellationRequested(); + _baseStream.Flush(); + return Task.CompletedTask; + } + +#if !NETFRAMEWORK && !NETSTANDARD2_0 + public override ValueTask ReadAsync( + Memory buffer, + CancellationToken cancellationToken = default + ) + { + cancellationToken.ThrowIfCancellationRequested(); + return new ValueTask(_baseStream.Read(buffer.Span)); + } + + public override ValueTask WriteAsync( + ReadOnlyMemory buffer, + CancellationToken cancellationToken = default + ) + { + cancellationToken.ThrowIfCancellationRequested(); + _baseStream.Write(buffer.Span); + return ValueTask.CompletedTask; + } +#endif + + protected override void Dispose(bool disposing) + { + if (disposing) + { + _baseStream.Dispose(); + } + base.Dispose(disposing); + } } private class PasswordProvider : IPasswordProvider diff --git a/src/SharpCompress/AssemblyInfo.cs b/src/SharpCompress/AssemblyInfo.cs index e51d97fe0..c11eb8e02 100644 --- a/src/SharpCompress/AssemblyInfo.cs +++ b/src/SharpCompress/AssemblyInfo.cs @@ -1,7 +1,8 @@ using System; using System.Runtime.CompilerServices; -[assembly: CLSCompliant(true)] +// CLSCompliant(false) is required because ZStandard integration uses unsafe code +[assembly: CLSCompliant(false)] [assembly: InternalsVisibleTo( "SharpCompress.Test,PublicKey=0024000004800000940000000602000000240000525341310004000001000100158bebf1433f76dffc356733c138babea7a47536c65ed8009b16372c6f4edbb20554db74a62687f56b97c20a6ce8c4b123280279e33c894e7b3aa93ab3c573656fde4db576cfe07dba09619ead26375b25d2c4a8e43f7be257d712b0dd2eb546f67adb09281338618a58ac834fc038dd7e2740a7ab3591826252e4f4516306dc" )] diff --git a/src/SharpCompress/Common/Ace/AceCrc.cs b/src/SharpCompress/Common/Ace/AceCrc.cs new file mode 100644 index 000000000..8ae43a2b0 --- /dev/null +++ b/src/SharpCompress/Common/Ace/AceCrc.cs @@ -0,0 +1,61 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SharpCompress.Common.Ace +{ + public class AceCrc + { + // CRC-32 lookup table (standard polynomial 0xEDB88320, reflected) + private static readonly uint[] Crc32Table = GenerateTable(); + + private static uint[] GenerateTable() + { + var table = new uint[256]; + + for (int i = 0; i < 256; i++) + { + uint crc = (uint)i; + + for (int j = 0; j < 8; j++) + { + if ((crc & 1) != 0) + crc = (crc >> 1) ^ 0xEDB88320u; + else + crc >>= 1; + } + + table[i] = crc; + } + + return table; + } + + /// + /// Calculate ACE CRC-32 checksum. + /// ACE CRC-32 uses standard CRC-32 polynomial (0xEDB88320, reflected) + /// with init=0xFFFFFFFF but NO final XOR. + /// + public static uint AceCrc32(ReadOnlySpan data) + { + uint crc = 0xFFFFFFFFu; + + foreach (byte b in data) + { + crc = (crc >> 8) ^ Crc32Table[(crc ^ b) & 0xFF]; + } + + return crc; // No final XOR for ACE + } + + /// + /// ACE CRC-16 is the lower 16 bits of the ACE CRC-32. + /// + public static ushort AceCrc16(ReadOnlySpan data) + { + return (ushort)(AceCrc32(data) & 0xFFFF); + } + } +} diff --git a/src/SharpCompress/Common/Ace/AceEntry.cs b/src/SharpCompress/Common/Ace/AceEntry.cs new file mode 100644 index 000000000..a3dde1e7f --- /dev/null +++ b/src/SharpCompress/Common/Ace/AceEntry.cs @@ -0,0 +1,68 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SharpCompress.Common.Ace.Headers; + +namespace SharpCompress.Common.Ace +{ + public class AceEntry : Entry + { + private readonly AceFilePart _filePart; + + internal AceEntry(AceFilePart filePart) + { + _filePart = filePart; + } + + public override long Crc + { + get + { + if (_filePart == null) + { + return 0; + } + return _filePart.Header.Crc32; + } + } + + public override string? Key => _filePart?.Header.Filename; + + public override string? LinkTarget => null; + + public override long CompressedSize => _filePart?.Header.PackedSize ?? 0; + + public override CompressionType CompressionType + { + get + { + if (_filePart.Header.CompressionType == Headers.CompressionType.Stored) + { + return CompressionType.None; + } + return CompressionType.AceLZ77; + } + } + + public override long Size => _filePart?.Header.OriginalSize ?? 0; + + public override DateTime? LastModifiedTime => _filePart.Header.DateTime; + + public override DateTime? CreatedTime => null; + + public override DateTime? LastAccessedTime => null; + + public override DateTime? ArchivedTime => null; + + public override bool IsEncrypted => _filePart.Header.IsFileEncrypted; + + public override bool IsDirectory => _filePart.Header.IsDirectory; + + public override bool IsSplitAfter => false; + + internal override IEnumerable Parts => _filePart.Empty(); + } +} diff --git a/src/SharpCompress/Common/Ace/AceFilePart.cs b/src/SharpCompress/Common/Ace/AceFilePart.cs new file mode 100644 index 000000000..6efefaf56 --- /dev/null +++ b/src/SharpCompress/Common/Ace/AceFilePart.cs @@ -0,0 +1,52 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SharpCompress.Common.Ace.Headers; +using SharpCompress.IO; + +namespace SharpCompress.Common.Ace +{ + public class AceFilePart : FilePart + { + private readonly Stream _stream; + internal AceFileHeader Header { get; set; } + + internal AceFilePart(AceFileHeader localAceHeader, Stream seekableStream) + : base(localAceHeader.ArchiveEncoding) + { + _stream = seekableStream; + Header = localAceHeader; + } + + internal override string? FilePartName => Header.Filename; + + internal override Stream GetCompressedStream() + { + if (_stream != null) + { + Stream compressedStream; + switch (Header.CompressionType) + { + case Headers.CompressionType.Stored: + compressedStream = new ReadOnlySubStream( + _stream, + Header.DataStartPosition, + Header.PackedSize + ); + break; + default: + throw new NotSupportedException( + "CompressionMethod: " + Header.CompressionQuality + ); + } + return compressedStream; + } + return _stream.NotNull(); + } + + internal override Stream? GetRawStream() => _stream; + } +} diff --git a/src/SharpCompress/Common/Ace/AceVolume.cs b/src/SharpCompress/Common/Ace/AceVolume.cs new file mode 100644 index 000000000..28456866b --- /dev/null +++ b/src/SharpCompress/Common/Ace/AceVolume.cs @@ -0,0 +1,35 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SharpCompress.Common.Arj; +using SharpCompress.Readers; + +namespace SharpCompress.Common.Ace +{ + public class AceVolume : Volume + { + public AceVolume(Stream stream, ReaderOptions readerOptions, int index = 0) + : base(stream, readerOptions, index) { } + + public override bool IsFirstVolume + { + get { return true; } + } + + /// + /// ArjArchive is part of a multi-part archive. + /// + public override bool IsMultiVolume + { + get { return false; } + } + + internal IEnumerable GetVolumeFileParts() + { + return new List(); + } + } +} diff --git a/src/SharpCompress/Common/Ace/Headers/AceFileHeader.cs b/src/SharpCompress/Common/Ace/Headers/AceFileHeader.cs new file mode 100644 index 000000000..9fd34c63d --- /dev/null +++ b/src/SharpCompress/Common/Ace/Headers/AceFileHeader.cs @@ -0,0 +1,171 @@ +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.IO; +using System.Xml.Linq; +using SharpCompress.Common.Arc; + +namespace SharpCompress.Common.Ace.Headers +{ + /// + /// ACE file entry header + /// + public sealed class AceFileHeader : AceHeader + { + public long DataStartPosition { get; private set; } + public long PackedSize { get; set; } + public long OriginalSize { get; set; } + public DateTime DateTime { get; set; } + public int Attributes { get; set; } + public uint Crc32 { get; set; } + public CompressionType CompressionType { get; set; } + public CompressionQuality CompressionQuality { get; set; } + public ushort Parameters { get; set; } + public string Filename { get; set; } = string.Empty; + public List Comment { get; set; } = new(); + + /// + /// File data offset in the archive + /// + public ulong DataOffset { get; set; } + + public bool IsDirectory => (Attributes & 0x10) != 0; + + public bool IsContinuedFromPrev => + (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.CONTINUED_PREV) != 0; + + public bool IsContinuedToNext => + (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.CONTINUED_NEXT) != 0; + + public int DictionarySize + { + get + { + int bits = Parameters & 0x0F; + return bits < 10 ? 1024 : 1 << bits; + } + } + + public AceFileHeader(ArchiveEncoding archiveEncoding) + : base(archiveEncoding, AceHeaderType.FILE) { } + + /// + /// Reads the next file entry header from the stream. + /// Returns null if no more entries or end of archive. + /// Supports both ACE 1.0 and ACE 2.0 formats. + /// + public override AceHeader? Read(Stream stream) + { + var headerData = ReadHeader(stream); + if (headerData.Length == 0) + { + return null; + } + int offset = 0; + + // Header type (1 byte) + HeaderType = headerData[offset++]; + + // Skip recovery record headers (ACE 2.0 feature) + if (HeaderType == (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.RECOVERY32) + { + // Skip to next header + return null; + } + + if (HeaderType != (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.FILE) + { + // Unknown header type - skip + return null; + } + + // Header flags (2 bytes) + HeaderFlags = BitConverter.ToUInt16(headerData, offset); + offset += 2; + + // Packed size (4 bytes) + PackedSize = BitConverter.ToUInt32(headerData, offset); + offset += 4; + + // Original size (4 bytes) + OriginalSize = BitConverter.ToUInt32(headerData, offset); + offset += 4; + + // File date/time in DOS format (4 bytes) + var dosDateTime = BitConverter.ToUInt32(headerData, offset); + DateTime = ConvertDosDateTime(dosDateTime); + offset += 4; + + // File attributes (4 bytes) + Attributes = (int)BitConverter.ToUInt32(headerData, offset); + offset += 4; + + // CRC32 (4 bytes) + Crc32 = BitConverter.ToUInt32(headerData, offset); + offset += 4; + + // Compression type (1 byte) + byte compressionType = headerData[offset++]; + CompressionType = GetCompressionType(compressionType); + + // Compression quality/parameter (1 byte) + byte compressionQuality = headerData[offset++]; + CompressionQuality = GetCompressionQuality(compressionQuality); + + // Parameters (2 bytes) + Parameters = BitConverter.ToUInt16(headerData, offset); + offset += 2; + + // Reserved (2 bytes) - skip + offset += 2; + + // Filename length (2 bytes) + var filenameLength = BitConverter.ToUInt16(headerData, offset); + offset += 2; + + // Filename + if (offset + filenameLength <= headerData.Length) + { + Filename = ArchiveEncoding.Decode(headerData, offset, filenameLength); + offset += filenameLength; + } + + // Handle comment if present + if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0) + { + // Comment length (2 bytes) + if (offset + 2 <= headerData.Length) + { + ushort commentLength = BitConverter.ToUInt16(headerData, offset); + offset += 2 + commentLength; // Skip comment + } + } + + // Store the data start position + DataStartPosition = stream.Position; + + return this; + } + + public CompressionType GetCompressionType(byte value) => + value switch + { + 0 => CompressionType.Stored, + 1 => CompressionType.Lz77, + 2 => CompressionType.Blocked, + _ => CompressionType.Unknown, + }; + + public CompressionQuality GetCompressionQuality(byte value) => + value switch + { + 0 => CompressionQuality.None, + 1 => CompressionQuality.Fastest, + 2 => CompressionQuality.Fast, + 3 => CompressionQuality.Normal, + 4 => CompressionQuality.Good, + 5 => CompressionQuality.Best, + _ => CompressionQuality.Unknown, + }; + } +} diff --git a/src/SharpCompress/Common/Ace/Headers/AceHeader.cs b/src/SharpCompress/Common/Ace/Headers/AceHeader.cs new file mode 100644 index 000000000..0fa816e5b --- /dev/null +++ b/src/SharpCompress/Common/Ace/Headers/AceHeader.cs @@ -0,0 +1,153 @@ +using System; +using System.IO; +using SharpCompress.Common.Arj.Headers; +using SharpCompress.Crypto; + +namespace SharpCompress.Common.Ace.Headers +{ + /// + /// Header type constants + /// + public enum AceHeaderType + { + MAIN = 0, + FILE = 1, + RECOVERY32 = 2, + RECOVERY64A = 3, + RECOVERY64B = 4, + } + + public abstract class AceHeader + { + // ACE signature: bytes at offset 7 should be "**ACE**" + private static readonly byte[] AceSignature = + [ + (byte)'*', + (byte)'*', + (byte)'A', + (byte)'C', + (byte)'E', + (byte)'*', + (byte)'*', + ]; + + public AceHeader(ArchiveEncoding archiveEncoding, AceHeaderType type) + { + AceHeaderType = type; + ArchiveEncoding = archiveEncoding; + } + + public ArchiveEncoding ArchiveEncoding { get; } + public AceHeaderType AceHeaderType { get; } + + public ushort HeaderFlags { get; set; } + public ushort HeaderCrc { get; set; } + public ushort HeaderSize { get; set; } + public byte HeaderType { get; set; } + + public bool IsFileEncrypted => + (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.FILE_ENCRYPTED) != 0; + public bool Is64Bit => + (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.MEMORY_64BIT) != 0; + + public bool IsSolid => + (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.SOLID_MAIN) != 0; + + public bool IsMultiVolume => + (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.MULTIVOLUME) != 0; + + public abstract AceHeader? Read(Stream reader); + + public byte[] ReadHeader(Stream stream) + { + // Read header CRC (2 bytes) and header size (2 bytes) + var headerBytes = new byte[4]; + if (stream.Read(headerBytes, 0, 4) != 4) + { + return Array.Empty(); + } + + HeaderCrc = BitConverter.ToUInt16(headerBytes, 0); // CRC for validation + HeaderSize = BitConverter.ToUInt16(headerBytes, 2); + if (HeaderSize == 0) + { + return Array.Empty(); + } + + // Read the header data + var body = new byte[HeaderSize]; + if (stream.Read(body, 0, HeaderSize) != HeaderSize) + { + return Array.Empty(); + } + + // Verify crc + var checksum = AceCrc.AceCrc16(body); + if (checksum != HeaderCrc) + { + throw new InvalidDataException("Header checksum is invalid"); + } + return body; + } + + public static bool IsArchive(Stream stream) + { + // ACE files have a specific signature + // First two bytes are typically 0x60 0xEA (signature bytes) + // At offset 7, there should be "**ACE**" (7 bytes) + var bytes = new byte[14]; + if (stream.Read(bytes, 0, 14) != 14) + { + return false; + } + + // Check for "**ACE**" at offset 7 + return CheckMagicBytes(bytes, 7); + } + + protected static bool CheckMagicBytes(byte[] headerBytes, int offset) + { + // Check for "**ACE**" at specified offset + for (int i = 0; i < AceSignature.Length; i++) + { + if (headerBytes[offset + i] != AceSignature[i]) + { + return false; + } + } + return true; + } + + protected DateTime ConvertDosDateTime(uint dosDateTime) + { + try + { + int second = (int)(dosDateTime & 0x1F) * 2; + int minute = (int)((dosDateTime >> 5) & 0x3F); + int hour = (int)((dosDateTime >> 11) & 0x1F); + int day = (int)((dosDateTime >> 16) & 0x1F); + int month = (int)((dosDateTime >> 21) & 0x0F); + int year = (int)((dosDateTime >> 25) & 0x7F) + 1980; + + if ( + day < 1 + || day > 31 + || month < 1 + || month > 12 + || hour > 23 + || minute > 59 + || second > 59 + ) + { + return DateTime.MinValue; + } + + return new DateTime(year, month, day, hour, minute, second); + } + catch + { + return DateTime.MinValue; + } + } + } +} diff --git a/src/SharpCompress/Common/Ace/Headers/AceMainHeader.cs b/src/SharpCompress/Common/Ace/Headers/AceMainHeader.cs new file mode 100644 index 000000000..c2fc68159 --- /dev/null +++ b/src/SharpCompress/Common/Ace/Headers/AceMainHeader.cs @@ -0,0 +1,97 @@ +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.IO; +using SharpCompress.Common.Ace.Headers; +using SharpCompress.Common.Zip.Headers; +using SharpCompress.Crypto; + +namespace SharpCompress.Common.Ace.Headers +{ + /// + /// ACE main archive header + /// + public sealed class AceMainHeader : AceHeader + { + public byte ExtractVersion { get; set; } + public byte CreatorVersion { get; set; } + public HostOS HostOS { get; set; } + public byte VolumeNumber { get; set; } + public DateTime DateTime { get; set; } + public string Advert { get; set; } = string.Empty; + public List Comment { get; set; } = new(); + public byte AceVersion { get; private set; } + + public AceMainHeader(ArchiveEncoding archiveEncoding) + : base(archiveEncoding, AceHeaderType.MAIN) { } + + /// + /// Reads the main archive header from the stream. + /// Returns header if this is a valid ACE archive. + /// Supports both ACE 1.0 and ACE 2.0 formats. + /// + public override AceHeader? Read(Stream stream) + { + var headerData = ReadHeader(stream); + if (headerData.Length == 0) + { + return null; + } + int offset = 0; + + // Header type should be 0 for main header + if (headerData[offset++] != HeaderType) + { + return null; + } + + // Header flags (2 bytes) + HeaderFlags = BitConverter.ToUInt16(headerData, offset); + offset += 2; + + // Skip signature "**ACE**" (7 bytes) + if (!CheckMagicBytes(headerData, offset)) + { + throw new InvalidDataException("Invalid ACE archive signature."); + } + offset += 7; + + // ACE version (1 byte) - 10 for ACE 1.0, 20 for ACE 2.0 + AceVersion = headerData[offset++]; + ExtractVersion = headerData[offset++]; + + // Host OS (1 byte) + if (offset < headerData.Length) + { + var hostOsByte = headerData[offset++]; + HostOS = hostOsByte <= 11 ? (HostOS)hostOsByte : HostOS.Unknown; + } + // Volume number (1 byte) + VolumeNumber = headerData[offset++]; + + // Creation date/time (4 bytes) + var dosDateTime = BitConverter.ToUInt32(headerData, offset); + DateTime = ConvertDosDateTime(dosDateTime); + offset += 4; + + // Reserved fields (8 bytes) + if (offset + 8 <= headerData.Length) + { + offset += 8; + } + + // Skip additional fields based on flags + // Handle comment if present + if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0) + { + if (offset + 2 <= headerData.Length) + { + ushort commentLength = BitConverter.ToUInt16(headerData, offset); + offset += 2 + commentLength; + } + } + + return this; + } + } +} diff --git a/src/SharpCompress/Common/Ace/Headers/CompressionQuality.cs b/src/SharpCompress/Common/Ace/Headers/CompressionQuality.cs new file mode 100644 index 000000000..57017b55f --- /dev/null +++ b/src/SharpCompress/Common/Ace/Headers/CompressionQuality.cs @@ -0,0 +1,16 @@ +namespace SharpCompress.Common.Ace.Headers +{ + /// + /// Compression quality + /// + public enum CompressionQuality + { + None, + Fastest, + Fast, + Normal, + Good, + Best, + Unknown, + } +} diff --git a/src/SharpCompress/Common/Ace/Headers/CompressionType.cs b/src/SharpCompress/Common/Ace/Headers/CompressionType.cs new file mode 100644 index 000000000..799e7929b --- /dev/null +++ b/src/SharpCompress/Common/Ace/Headers/CompressionType.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Common.Ace.Headers +{ + /// + /// Compression types + /// + public enum CompressionType + { + Stored, + Lz77, + Blocked, + Unknown, + } +} diff --git a/src/SharpCompress/Common/Ace/Headers/HeaderFlags.cs b/src/SharpCompress/Common/Ace/Headers/HeaderFlags.cs new file mode 100644 index 000000000..6a5f8926f --- /dev/null +++ b/src/SharpCompress/Common/Ace/Headers/HeaderFlags.cs @@ -0,0 +1,33 @@ +namespace SharpCompress.Common.Ace.Headers +{ + /// + /// Header flags (main + file, overlapping meanings) + /// + public static class HeaderFlags + { + // Shared / low bits + public const ushort ADDSIZE = 0x0001; // extra size field present + public const ushort COMMENT = 0x0002; // comment present + public const ushort MEMORY_64BIT = 0x0004; + public const ushort AV_STRING = 0x0008; // AV string present + public const ushort SOLID = 0x0010; // solid file + public const ushort LOCKED = 0x0020; + public const ushort PROTECTED = 0x0040; + + // Main header specific + public const ushort V20FORMAT = 0x0100; + public const ushort SFX = 0x0200; + public const ushort LIMITSFXJR = 0x0400; + public const ushort MULTIVOLUME = 0x0800; + public const ushort ADVERT = 0x1000; + public const ushort RECOVERY = 0x2000; + public const ushort LOCKED_MAIN = 0x4000; + public const ushort SOLID_MAIN = 0x8000; + + // File header specific (same bits, different meaning) + public const ushort NTSECURITY = 0x0400; + public const ushort CONTINUED_PREV = 0x1000; + public const ushort CONTINUED_NEXT = 0x2000; + public const ushort FILE_ENCRYPTED = 0x4000; // file encrypted (file header) + } +} diff --git a/src/SharpCompress/Common/Ace/Headers/HostOS.cs b/src/SharpCompress/Common/Ace/Headers/HostOS.cs new file mode 100644 index 000000000..173d56eb8 --- /dev/null +++ b/src/SharpCompress/Common/Ace/Headers/HostOS.cs @@ -0,0 +1,22 @@ +namespace SharpCompress.Common.Ace.Headers +{ + /// + /// Host OS type + /// + public enum HostOS + { + MsDos = 0, + Os2, + Windows, + Unix, + MacOs, + WinNt, + Primos, + AppleGs, + Atari, + Vax, + Amiga, + Next, + Unknown, + } +} diff --git a/src/SharpCompress/Common/ArchiveExtractionEventArgs.cs b/src/SharpCompress/Common/ArchiveExtractionEventArgs.cs deleted file mode 100644 index 808177489..000000000 --- a/src/SharpCompress/Common/ArchiveExtractionEventArgs.cs +++ /dev/null @@ -1,10 +0,0 @@ -using System; - -namespace SharpCompress.Common; - -public class ArchiveExtractionEventArgs : EventArgs -{ - internal ArchiveExtractionEventArgs(T entry) => Item = entry; - - public T Item { get; } -} diff --git a/src/SharpCompress/Common/ArchiveType.cs b/src/SharpCompress/Common/ArchiveType.cs index 9d9438955..5952f6459 100644 --- a/src/SharpCompress/Common/ArchiveType.cs +++ b/src/SharpCompress/Common/ArchiveType.cs @@ -9,4 +9,5 @@ public enum ArchiveType GZip, Arc, Arj, + Ace, } diff --git a/src/SharpCompress/Common/Arj/Headers/ArjHeader.cs b/src/SharpCompress/Common/Arj/Headers/ArjHeader.cs index 138f75e72..142aca5bb 100644 --- a/src/SharpCompress/Common/Arj/Headers/ArjHeader.cs +++ b/src/SharpCompress/Common/Arj/Headers/ArjHeader.cs @@ -34,14 +34,13 @@ public ArjHeader(ArjHeaderType type) public byte[] ReadHeader(Stream stream) { // check for magic bytes - Span magic = stackalloc byte[2]; + var magic = new byte[2]; if (stream.Read(magic) != 2) { return Array.Empty(); } - var magicValue = (ushort)(magic[0] | magic[1] << 8); - if (magicValue != ARJ_MAGIC) + if (!CheckMagicBytes(magic)) { throw new InvalidDataException("Not an ARJ file (wrong magic bytes)"); } @@ -138,5 +137,22 @@ public static FileType FileTypeFromByte(byte value) ? (FileType)value : Headers.FileType.Unknown; } + + public static bool IsArchive(Stream stream) + { + var bytes = new byte[2]; + if (stream.Read(bytes, 0, 2) != 2) + { + return false; + } + + return CheckMagicBytes(bytes); + } + + protected static bool CheckMagicBytes(byte[] headerBytes) + { + var magicValue = (ushort)(headerBytes[0] | headerBytes[1] << 8); + return magicValue == ARJ_MAGIC; + } } } diff --git a/src/SharpCompress/Common/CompressedBytesReadEventArgs.cs b/src/SharpCompress/Common/CompressedBytesReadEventArgs.cs deleted file mode 100644 index 34ca461f1..000000000 --- a/src/SharpCompress/Common/CompressedBytesReadEventArgs.cs +++ /dev/null @@ -1,25 +0,0 @@ -using System; - -namespace SharpCompress.Common; - -public sealed class CompressedBytesReadEventArgs : EventArgs -{ - public CompressedBytesReadEventArgs( - long compressedBytesRead, - long currentFilePartCompressedBytesRead - ) - { - CompressedBytesRead = compressedBytesRead; - CurrentFilePartCompressedBytesRead = currentFilePartCompressedBytesRead; - } - - /// - /// Compressed bytes read for the current entry - /// - public long CompressedBytesRead { get; } - - /// - /// Current file part read for Multipart files (e.g. Rar) - /// - public long CurrentFilePartCompressedBytesRead { get; } -} diff --git a/src/SharpCompress/Common/CompressionType.cs b/src/SharpCompress/Common/CompressionType.cs index 7c50758a0..595834233 100644 --- a/src/SharpCompress/Common/CompressionType.cs +++ b/src/SharpCompress/Common/CompressionType.cs @@ -30,4 +30,5 @@ public enum CompressionType Distilled, ZStandard, ArjLZ77, + AceLZ77, } diff --git a/src/SharpCompress/Common/ExtractionMethods.cs b/src/SharpCompress/Common/ExtractionMethods.cs index 485fdf4d3..509524b15 100644 --- a/src/SharpCompress/Common/ExtractionMethods.cs +++ b/src/SharpCompress/Common/ExtractionMethods.cs @@ -128,7 +128,7 @@ public static async Task WriteEntryToDirectoryAsync( IEntry entry, string destinationDirectory, ExtractionOptions? options, - Func writeAsync, + Func writeAsync, CancellationToken cancellationToken = default ) { @@ -189,7 +189,7 @@ public static async Task WriteEntryToDirectoryAsync( "Entry is trying to write a file outside of the destination directory." ); } - await writeAsync(destinationFileName, options).ConfigureAwait(false); + await writeAsync(destinationFileName, options, cancellationToken).ConfigureAwait(false); } else if (options.ExtractFullPath && !Directory.Exists(destinationFileName)) { @@ -201,7 +201,7 @@ public static async Task WriteEntryToFileAsync( IEntry entry, string destinationFileName, ExtractionOptions? options, - Func openAndWriteAsync, + Func openAndWriteAsync, CancellationToken cancellationToken = default ) { @@ -225,7 +225,8 @@ public static async Task WriteEntryToFileAsync( fm = FileMode.CreateNew; } - await openAndWriteAsync(destinationFileName, fm).ConfigureAwait(false); + await openAndWriteAsync(destinationFileName, fm, cancellationToken) + .ConfigureAwait(false); entry.PreserveExtractionOptions(destinationFileName, options); } } diff --git a/src/SharpCompress/Common/FilePartExtractionBeginEventArgs.cs b/src/SharpCompress/Common/FilePartExtractionBeginEventArgs.cs deleted file mode 100644 index d5b8328cc..000000000 --- a/src/SharpCompress/Common/FilePartExtractionBeginEventArgs.cs +++ /dev/null @@ -1,28 +0,0 @@ -using System; - -namespace SharpCompress.Common; - -public sealed class FilePartExtractionBeginEventArgs : EventArgs -{ - public FilePartExtractionBeginEventArgs(string name, long size, long compressedSize) - { - Name = name; - Size = size; - CompressedSize = compressedSize; - } - - /// - /// File name for the part for the current entry - /// - public string Name { get; } - - /// - /// Uncompressed size of the current entry in the part - /// - public long Size { get; } - - /// - /// Compressed size of the current entry in the part - /// - public long CompressedSize { get; } -} diff --git a/src/SharpCompress/Common/IExtractionListener.cs b/src/SharpCompress/Common/IExtractionListener.cs deleted file mode 100644 index e1389810a..000000000 --- a/src/SharpCompress/Common/IExtractionListener.cs +++ /dev/null @@ -1,7 +0,0 @@ -namespace SharpCompress.Common; - -public interface IExtractionListener -{ - void FireFilePartExtractionBegin(string name, long size, long compressedSize); - void FireCompressedBytesRead(long currentPartCompressedBytes, long compressedReadBytes); -} diff --git a/src/SharpCompress/Common/ProgressReport.cs b/src/SharpCompress/Common/ProgressReport.cs new file mode 100644 index 000000000..2d8368674 --- /dev/null +++ b/src/SharpCompress/Common/ProgressReport.cs @@ -0,0 +1,43 @@ +namespace SharpCompress.Common; + +/// +/// Represents progress information for compression or extraction operations. +/// +public sealed class ProgressReport +{ + /// + /// Initializes a new instance of the class. + /// + /// The path of the entry being processed. + /// Number of bytes transferred so far. + /// Total bytes to be transferred, or null if unknown. + public ProgressReport(string entryPath, long bytesTransferred, long? totalBytes) + { + EntryPath = entryPath; + BytesTransferred = bytesTransferred; + TotalBytes = totalBytes; + } + + /// + /// Gets the path of the entry being processed. + /// + public string EntryPath { get; } + + /// + /// Gets the number of bytes transferred so far. + /// + public long BytesTransferred { get; } + + /// + /// Gets the total number of bytes to be transferred, or null if unknown. + /// + public long? TotalBytes { get; } + + /// + /// Gets the progress percentage (0-100), or null if total bytes is unknown. + /// + public double? PercentComplete => + TotalBytes.HasValue && TotalBytes.Value > 0 + ? (double)BytesTransferred / TotalBytes.Value * 100 + : null; +} diff --git a/src/SharpCompress/Common/ReaderExtractionEventArgs.cs b/src/SharpCompress/Common/ReaderExtractionEventArgs.cs deleted file mode 100644 index 7c4363e20..000000000 --- a/src/SharpCompress/Common/ReaderExtractionEventArgs.cs +++ /dev/null @@ -1,17 +0,0 @@ -using System; -using SharpCompress.Readers; - -namespace SharpCompress.Common; - -public sealed class ReaderExtractionEventArgs : EventArgs -{ - internal ReaderExtractionEventArgs(T entry, ReaderProgress? readerProgress = null) - { - Item = entry; - ReaderProgress = readerProgress; - } - - public T Item { get; } - - public ReaderProgress? ReaderProgress { get; } -} diff --git a/src/SharpCompress/Common/Tar/Headers/TarHeader.cs b/src/SharpCompress/Common/Tar/Headers/TarHeader.cs index 06a1f10a4..e6b7c265c 100644 --- a/src/SharpCompress/Common/Tar/Headers/TarHeader.cs +++ b/src/SharpCompress/Common/Tar/Headers/TarHeader.cs @@ -1,5 +1,6 @@ using System; using System.Buffers.Binary; +using System.Collections.Generic; using System.IO; using System.Text; @@ -9,8 +10,16 @@ internal sealed class TarHeader { internal static readonly DateTime EPOCH = new(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); - public TarHeader(ArchiveEncoding archiveEncoding) => ArchiveEncoding = archiveEncoding; + public TarHeader( + ArchiveEncoding archiveEncoding, + TarHeaderWriteFormat writeFormat = TarHeaderWriteFormat.GNU_TAR_LONG_LINK + ) + { + ArchiveEncoding = archiveEncoding; + WriteFormat = writeFormat; + } + internal TarHeaderWriteFormat WriteFormat { get; set; } internal string? Name { get; set; } internal string? LinkName { get; set; } @@ -30,6 +39,114 @@ internal sealed class TarHeader private const int MAX_LONG_NAME_SIZE = 32768; internal void Write(Stream output) + { + switch (WriteFormat) + { + case TarHeaderWriteFormat.GNU_TAR_LONG_LINK: + WriteGnuTarLongLink(output); + break; + case TarHeaderWriteFormat.USTAR: + WriteUstar(output); + break; + default: + throw new Exception("This should be impossible..."); + } + } + + internal void WriteUstar(Stream output) + { + var buffer = new byte[BLOCK_SIZE]; + + WriteOctalBytes(511, buffer, 100, 8); // file mode + WriteOctalBytes(0, buffer, 108, 8); // owner ID + WriteOctalBytes(0, buffer, 116, 8); // group ID + + //ArchiveEncoding.UTF8.GetBytes("magic").CopyTo(buffer, 257); + var nameByteCount = ArchiveEncoding + .GetEncoding() + .GetByteCount(Name.NotNull("Name is null")); + + if (nameByteCount > 100) + { + // if name is longer, try to split it into name and namePrefix + + string fullName = Name.NotNull("Name is null"); + + // find all directory separators + List dirSeps = new List(); + for (int i = 0; i < fullName.Length; i++) + { + if (fullName[i] == Path.DirectorySeparatorChar) + { + dirSeps.Add(i); + } + } + + // find the right place to split the name + int splitIndex = -1; + for (int i = 0; i < dirSeps.Count; i++) + { + int count = ArchiveEncoding + .GetEncoding() + .GetByteCount(fullName.Substring(0, dirSeps[i])); + if (count < 155) + { + splitIndex = dirSeps[i]; + } + else + { + break; + } + } + + if (splitIndex == -1) + { + throw new Exception( + $"Tar header USTAR format can not fit file name \"{fullName}\" of length {nameByteCount}! Directory separator not found! Try using GNU Tar format instead!" + ); + } + + string namePrefix = fullName.Substring(0, splitIndex); + string name = fullName.Substring(splitIndex + 1); + + if (this.ArchiveEncoding.GetEncoding().GetByteCount(namePrefix) >= 155) + throw new Exception( + $"Tar header USTAR format can not fit file name \"{fullName}\" of length {nameByteCount}! Try using GNU Tar format instead!" + ); + + if (this.ArchiveEncoding.GetEncoding().GetByteCount(name) >= 100) + throw new Exception( + $"Tar header USTAR format can not fit file name \"{fullName}\" of length {nameByteCount}! Try using GNU Tar format instead!" + ); + + // write name prefix + WriteStringBytes(ArchiveEncoding.Encode(namePrefix), buffer, 345, 100); + // write partial name + WriteStringBytes(ArchiveEncoding.Encode(name), buffer, 100); + } + else + { + WriteStringBytes(ArchiveEncoding.Encode(Name.NotNull("Name is null")), buffer, 100); + } + + WriteOctalBytes(Size, buffer, 124, 12); + var time = (long)(LastModifiedTime.ToUniversalTime() - EPOCH).TotalSeconds; + WriteOctalBytes(time, buffer, 136, 12); + buffer[156] = (byte)EntryType; + + // write ustar magic field + WriteStringBytes(Encoding.ASCII.GetBytes("ustar"), buffer, 257, 6); + // write ustar version "00" + buffer[263] = 0x30; + buffer[264] = 0x30; + + var crc = RecalculateChecksum(buffer); + WriteOctalBytes(crc, buffer, 148, 8); + + output.Write(buffer, 0, buffer.Length); + } + + internal void WriteGnuTarLongLink(Stream output) { var buffer = new byte[BLOCK_SIZE]; @@ -85,7 +202,7 @@ internal void Write(Stream output) 0, 100 - ArchiveEncoding.GetEncoding().GetMaxByteCount(1) ); - Write(output); + WriteGnuTarLongLink(output); } } @@ -241,6 +358,18 @@ private static void WriteStringBytes(ReadOnlySpan name, Span buffer, buffer.Slice(i, length - i).Clear(); } + private static void WriteStringBytes( + ReadOnlySpan name, + Span buffer, + int offset, + int length + ) + { + name.CopyTo(buffer.Slice(offset)); + var i = Math.Min(length, name.Length); + buffer.Slice(offset + i, length - i).Clear(); + } + private static void WriteStringBytes(string name, byte[] buffer, int offset, int length) { int i; diff --git a/src/SharpCompress/Common/Tar/Headers/TarHeaderWriteFormat.cs b/src/SharpCompress/Common/Tar/Headers/TarHeaderWriteFormat.cs new file mode 100644 index 000000000..3a3a434ab --- /dev/null +++ b/src/SharpCompress/Common/Tar/Headers/TarHeaderWriteFormat.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Common.Tar.Headers; + +public enum TarHeaderWriteFormat +{ + GNU_TAR_LONG_LINK, + USTAR, +} diff --git a/src/SharpCompress/Common/Zip/WinzipAesEncryptionData.cs b/src/SharpCompress/Common/Zip/WinzipAesEncryptionData.cs index 31322019f..b91d72912 100644 --- a/src/SharpCompress/Common/Zip/WinzipAesEncryptionData.cs +++ b/src/SharpCompress/Common/Zip/WinzipAesEncryptionData.cs @@ -1,6 +1,7 @@ using System; using System.Buffers.Binary; using System.Security.Cryptography; +using System.Text; namespace SharpCompress.Common.Zip; @@ -19,8 +20,24 @@ string password { _keySize = keySize; -#if NETFRAMEWORK || NETSTANDARD2_0 +#if NETFRAMEWORK var rfc2898 = new Rfc2898DeriveBytes(password, salt, RFC2898_ITERATIONS); + KeyBytes = rfc2898.GetBytes(KeySizeInBytes); + IvBytes = rfc2898.GetBytes(KeySizeInBytes); + var generatedVerifyValue = rfc2898.GetBytes(2); +#elif NET10_0_OR_GREATER + var derivedKeySize = (KeySizeInBytes * 2) + 2; + var passwordBytes = Encoding.UTF8.GetBytes(password); + var derivedKey = Rfc2898DeriveBytes.Pbkdf2( + passwordBytes, + salt, + RFC2898_ITERATIONS, + HashAlgorithmName.SHA1, + derivedKeySize + ); + KeyBytes = derivedKey.AsSpan(0, KeySizeInBytes).ToArray(); + IvBytes = derivedKey.AsSpan(KeySizeInBytes, KeySizeInBytes).ToArray(); + var generatedVerifyValue = derivedKey.AsSpan((KeySizeInBytes * 2), 2).ToArray(); #else var rfc2898 = new Rfc2898DeriveBytes( password, @@ -28,11 +45,10 @@ string password RFC2898_ITERATIONS, HashAlgorithmName.SHA1 ); -#endif - - KeyBytes = rfc2898.GetBytes(KeySizeInBytes); // 16 or 24 or 32 ??? + KeyBytes = rfc2898.GetBytes(KeySizeInBytes); IvBytes = rfc2898.GetBytes(KeySizeInBytes); var generatedVerifyValue = rfc2898.GetBytes(2); +#endif var verify = BinaryPrimitives.ReadInt16LittleEndian(passwordVerifyValue); var generated = BinaryPrimitives.ReadInt16LittleEndian(generatedVerifyValue); diff --git a/src/SharpCompress/Common/Zip/ZipFilePart.cs b/src/SharpCompress/Common/Zip/ZipFilePart.cs index 77dc4abba..16eb8e1a9 100644 --- a/src/SharpCompress/Common/Zip/ZipFilePart.cs +++ b/src/SharpCompress/Common/Zip/ZipFilePart.cs @@ -13,8 +13,8 @@ using SharpCompress.Compressors.Reduce; using SharpCompress.Compressors.Shrink; using SharpCompress.Compressors.Xz; +using SharpCompress.Compressors.ZStandard; using SharpCompress.IO; -using ZstdSharp; namespace SharpCompress.Common.Zip; diff --git a/src/SharpCompress/Compressors/BZip2/CBZip2OutputStream.cs b/src/SharpCompress/Compressors/BZip2/CBZip2OutputStream.cs index db470ff26..7ee38b81a 100644 --- a/src/SharpCompress/Compressors/BZip2/CBZip2OutputStream.cs +++ b/src/SharpCompress/Compressors/BZip2/CBZip2OutputStream.cs @@ -544,6 +544,12 @@ private void InitBlock() private void EndBlock() { + // Skip block processing for empty input (no data written) + if (last < 0) + { + return; + } + blockCRC = mCrc.GetFinalCRC(); combinedCRC = (combinedCRC << 1) | (int)(((uint)combinedCRC) >> 31); combinedCRC ^= blockCRC; diff --git a/src/SharpCompress/Compressors/LZMA/LzmaStream.cs b/src/SharpCompress/Compressors/LZMA/LzmaStream.cs index eaef5fd3b..e9d5877ff 100644 --- a/src/SharpCompress/Compressors/LZMA/LzmaStream.cs +++ b/src/SharpCompress/Compressors/LZMA/LzmaStream.cs @@ -428,7 +428,9 @@ private void DecodeChunkHeader() private async Task DecodeChunkHeaderAsync(CancellationToken cancellationToken = default) { var controlBuffer = new byte[1]; - await _inputStream.ReadAsync(controlBuffer, 0, 1, cancellationToken).ConfigureAwait(false); + await _inputStream + .ReadExactlyAsync(controlBuffer, 0, 1, cancellationToken) + .ConfigureAwait(false); var control = controlBuffer[0]; _inputPosition++; @@ -455,11 +457,15 @@ private async Task DecodeChunkHeaderAsync(CancellationToken cancellationToken = _availableBytes = (control & 0x1F) << 16; var buffer = new byte[2]; - await _inputStream.ReadAsync(buffer, 0, 2, cancellationToken).ConfigureAwait(false); + await _inputStream + .ReadExactlyAsync(buffer, 0, 2, cancellationToken) + .ConfigureAwait(false); _availableBytes += (buffer[0] << 8) + buffer[1] + 1; _inputPosition += 2; - await _inputStream.ReadAsync(buffer, 0, 2, cancellationToken).ConfigureAwait(false); + await _inputStream + .ReadExactlyAsync(buffer, 0, 2, cancellationToken) + .ConfigureAwait(false); _rangeDecoderLimit = (buffer[0] << 8) + buffer[1] + 1; _inputPosition += 2; @@ -467,7 +473,7 @@ private async Task DecodeChunkHeaderAsync(CancellationToken cancellationToken = { _needProps = false; await _inputStream - .ReadAsync(controlBuffer, 0, 1, cancellationToken) + .ReadExactlyAsync(controlBuffer, 0, 1, cancellationToken) .ConfigureAwait(false); Properties[0] = controlBuffer[0]; _inputPosition++; @@ -495,7 +501,9 @@ await _inputStream { _uncompressedChunk = true; var buffer = new byte[2]; - await _inputStream.ReadAsync(buffer, 0, 2, cancellationToken).ConfigureAwait(false); + await _inputStream + .ReadExactlyAsync(buffer, 0, 2, cancellationToken) + .ConfigureAwait(false); _availableBytes = (buffer[0] << 8) + buffer[1] + 1; _inputPosition += 2; } diff --git a/src/SharpCompress/Compressors/LZMA/Registry.cs b/src/SharpCompress/Compressors/LZMA/Registry.cs index eb3e3bdd6..d71abded2 100644 --- a/src/SharpCompress/Compressors/LZMA/Registry.cs +++ b/src/SharpCompress/Compressors/LZMA/Registry.cs @@ -7,7 +7,7 @@ using SharpCompress.Compressors.Filters; using SharpCompress.Compressors.LZMA.Utilites; using SharpCompress.Compressors.PPMd; -using ZstdSharp; +using SharpCompress.Compressors.ZStandard; namespace SharpCompress.Compressors.LZMA; diff --git a/src/SharpCompress/Compressors/Rar/MultiVolumeReadOnlyStream.cs b/src/SharpCompress/Compressors/Rar/MultiVolumeReadOnlyStream.cs index d20fecd07..df1c59592 100644 --- a/src/SharpCompress/Compressors/Rar/MultiVolumeReadOnlyStream.cs +++ b/src/SharpCompress/Compressors/Rar/MultiVolumeReadOnlyStream.cs @@ -37,18 +37,8 @@ void IStreamStack.SetPosition(long position) { } private IEnumerator filePartEnumerator; private Stream currentStream; - private readonly IExtractionListener streamListener; - - private long currentPartTotalReadBytes; - private long currentEntryTotalReadBytes; - - internal MultiVolumeReadOnlyStream( - IEnumerable parts, - IExtractionListener streamListener - ) + internal MultiVolumeReadOnlyStream(IEnumerable parts) { - this.streamListener = streamListener; - filePartEnumerator = parts.GetEnumerator(); filePartEnumerator.MoveNext(); InitializeNextFilePart(); @@ -81,15 +71,7 @@ private void InitializeNextFilePart() currentPosition = 0; currentStream = filePartEnumerator.Current.GetCompressedStream(); - currentPartTotalReadBytes = 0; - CurrentCrc = filePartEnumerator.Current.FileHeader.FileCrc; - - streamListener.FireFilePartExtractionBegin( - filePartEnumerator.Current.FilePartName, - filePartEnumerator.Current.FileHeader.CompressedSize, - filePartEnumerator.Current.FileHeader.UncompressedSize - ); } public override int Read(byte[] buffer, int offset, int count) @@ -141,12 +123,6 @@ public override int Read(byte[] buffer, int offset, int count) break; } } - currentPartTotalReadBytes += totalRead; - currentEntryTotalReadBytes += totalRead; - streamListener.FireCompressedBytesRead( - currentPartTotalReadBytes, - currentEntryTotalReadBytes - ); return totalRead; } @@ -206,12 +182,6 @@ System.Threading.CancellationToken cancellationToken break; } } - currentPartTotalReadBytes += totalRead; - currentEntryTotalReadBytes += totalRead; - streamListener.FireCompressedBytesRead( - currentPartTotalReadBytes, - currentEntryTotalReadBytes - ); return totalRead; } @@ -270,12 +240,6 @@ public override async System.Threading.Tasks.ValueTask ReadAsync( break; } } - currentPartTotalReadBytes += totalRead; - currentEntryTotalReadBytes += totalRead; - streamListener.FireCompressedBytesRead( - currentPartTotalReadBytes, - currentEntryTotalReadBytes - ); return totalRead; } #endif diff --git a/src/SharpCompress/Compressors/Rar/RarStream.cs b/src/SharpCompress/Compressors/Rar/RarStream.cs index ca718d616..a4869075a 100644 --- a/src/SharpCompress/Compressors/Rar/RarStream.cs +++ b/src/SharpCompress/Compressors/Rar/RarStream.cs @@ -134,7 +134,7 @@ public override int Read(byte[] buffer, int offset, int count) fetch = false; } _position += outTotal; - if (count > 0 && outTotal == 0 && _position != Length) + if (count > 0 && outTotal == 0 && _position < Length) { // sanity check, eg if we try to decompress a redir entry throw new InvalidOperationException( @@ -179,7 +179,7 @@ System.Threading.CancellationToken cancellationToken fetch = false; } _position += outTotal; - if (count > 0 && outTotal == 0 && _position != Length) + if (count > 0 && outTotal == 0 && _position < Length) { // sanity check, eg if we try to decompress a redir entry throw new InvalidOperationException( diff --git a/src/SharpCompress/Compressors/ZStandard/BitOperations.cs b/src/SharpCompress/Compressors/ZStandard/BitOperations.cs new file mode 100644 index 000000000..fc8e3108d --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/BitOperations.cs @@ -0,0 +1,311 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if !NETCOREAPP3_0_OR_GREATER + +using System.Runtime.CompilerServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +// Some routines inspired by the Stanford Bit Twiddling Hacks by Sean Eron Anderson: +// http://graphics.stanford.edu/~seander/bithacks.html + +namespace System.Numerics +{ + /// + /// Utility methods for intrinsic bit-twiddling operations. + /// The methods use hardware intrinsics when available on the underlying platform, + /// otherwise they use optimized software fallbacks. + /// + public static unsafe class BitOperations + { + // hack: should be public because of inline + public static readonly byte* TrailingZeroCountDeBruijn = GetArrayPointer( + new byte[] + { + 00, + 01, + 28, + 02, + 29, + 14, + 24, + 03, + 30, + 22, + 20, + 15, + 25, + 17, + 04, + 08, + 31, + 27, + 13, + 23, + 21, + 19, + 16, + 07, + 26, + 12, + 18, + 06, + 11, + 05, + 10, + 09, + } + ); + + // hack: should be public because of inline + public static readonly byte* Log2DeBruijn = GetArrayPointer( + new byte[] + { + 00, + 09, + 01, + 10, + 13, + 21, + 02, + 29, + 11, + 14, + 16, + 18, + 22, + 25, + 03, + 30, + 08, + 12, + 20, + 28, + 15, + 17, + 24, + 07, + 19, + 27, + 23, + 06, + 26, + 05, + 04, + 31, + } + ); + + /// + /// Returns the integer (floor) log of the specified value, base 2. + /// Note that by convention, input value 0 returns 0 since log(0) is undefined. + /// + /// The value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int Log2(uint value) + { + // The 0->0 contract is fulfilled by setting the LSB to 1. + // Log(1) is 0, and setting the LSB for values > 1 does not change the log2 result. + value |= 1; + + // value lzcnt actual expected + // ..0001 31 31-31 0 + // ..0010 30 31-30 1 + // 0010.. 2 31-2 29 + // 0100.. 1 31-1 30 + // 1000.. 0 31-0 31 + + // Fallback contract is 0->0 + // No AggressiveInlining due to large method size + // Has conventional contract 0->0 (Log(0) is undefined) + + // Fill trailing zeros with ones, eg 00010010 becomes 00011111 + value |= value >> 01; + value |= value >> 02; + value |= value >> 04; + value |= value >> 08; + value |= value >> 16; + + // uint.MaxValue >> 27 is always in range [0 - 31] so we use Unsafe.AddByteOffset to avoid bounds check + return Log2DeBruijn[ + // Using deBruijn sequence, k=2, n=5 (2^5=32) : 0b_0000_0111_1100_0100_1010_1100_1101_1101u + (int)((value * 0x07C4ACDDu) >> 27) + ]; + } + + /// + /// Returns the integer (floor) log of the specified value, base 2. + /// Note that by convention, input value 0 returns 0 since log(0) is undefined. + /// + /// The value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int Log2(ulong value) + { + value |= 1; + + uint hi = (uint)(value >> 32); + + if (hi == 0) + { + return Log2((uint)value); + } + + return 32 + Log2(hi); + } + + /// + /// Count the number of trailing zero bits in an integer value. + /// Similar in behavior to the x86 instruction TZCNT. + /// + /// The value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int TrailingZeroCount(int value) => TrailingZeroCount((uint)value); + + /// + /// Count the number of trailing zero bits in an integer value. + /// Similar in behavior to the x86 instruction TZCNT. + /// + /// The value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int TrailingZeroCount(uint value) + { + // Unguarded fallback contract is 0->0, BSF contract is 0->undefined + if (value == 0) + { + return 32; + } + + // uint.MaxValue >> 27 is always in range [0 - 31] so we use Unsafe.AddByteOffset to avoid bounds check + return TrailingZeroCountDeBruijn[ + // Using deBruijn sequence, k=2, n=5 (2^5=32) : 0b_0000_0111_0111_1100_1011_0101_0011_0001u + (int)(((value & (uint)-(int)value) * 0x077CB531u) >> 27) + ]; // Multi-cast mitigates redundant conv.u8 + } + + /// + /// Count the number of trailing zero bits in a mask. + /// Similar in behavior to the x86 instruction TZCNT. + /// + /// The value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int TrailingZeroCount(long value) => TrailingZeroCount((ulong)value); + + /// + /// Count the number of trailing zero bits in a mask. + /// Similar in behavior to the x86 instruction TZCNT. + /// + /// The value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int TrailingZeroCount(ulong value) + { + uint lo = (uint)value; + + if (lo == 0) + { + return 32 + TrailingZeroCount((uint)(value >> 32)); + } + + return TrailingZeroCount(lo); + } + + /// + /// Rotates the specified value left by the specified number of bits. + /// Similar in behavior to the x86 instruction ROL. + /// + /// The value to rotate. + /// The number of bits to rotate by. + /// Any value outside the range [0..31] is treated as congruent mod 32. + /// The rotated value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint RotateLeft(uint value, int offset) => + (value << offset) | (value >> (32 - offset)); + + /// + /// Rotates the specified value left by the specified number of bits. + /// Similar in behavior to the x86 instruction ROL. + /// + /// The value to rotate. + /// The number of bits to rotate by. + /// Any value outside the range [0..63] is treated as congruent mod 64. + /// The rotated value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong RotateLeft(ulong value, int offset) => + (value << offset) | (value >> (64 - offset)); + + /// + /// Rotates the specified value right by the specified number of bits. + /// Similar in behavior to the x86 instruction ROR. + /// + /// The value to rotate. + /// The number of bits to rotate by. + /// Any value outside the range [0..31] is treated as congruent mod 32. + /// The rotated value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint RotateRight(uint value, int offset) => + (value >> offset) | (value << (32 - offset)); + + /// + /// Rotates the specified value right by the specified number of bits. + /// Similar in behavior to the x86 instruction ROR. + /// + /// The value to rotate. + /// The number of bits to rotate by. + /// Any value outside the range [0..63] is treated as congruent mod 64. + /// The rotated value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong RotateRight(ulong value, int offset) => + (value >> offset) | (value << (64 - offset)); + + /// + /// Count the number of leading zero bits in a mask. + /// Similar in behavior to the x86 instruction LZCNT. + /// + /// The value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int LeadingZeroCount(uint value) + { + // Unguarded fallback contract is 0->31, BSR contract is 0->undefined + if (value == 0) + { + return 32; + } + + // No AggressiveInlining due to large method size + // Has conventional contract 0->0 (Log(0) is undefined) + + // Fill trailing zeros with ones, eg 00010010 becomes 00011111 + value |= value >> 01; + value |= value >> 02; + value |= value >> 04; + value |= value >> 08; + value |= value >> 16; + + // uint.MaxValue >> 27 is always in range [0 - 31] so we use Unsafe.AddByteOffset to avoid bounds check + return 31 + ^ Log2DeBruijn[ + // uint|long -> IntPtr cast on 32-bit platforms does expensive overflow checks not needed here + (int)((value * 0x07C4ACDDu) >> 27) + ]; + } + + /// + /// Count the number of leading zero bits in a mask. + /// Similar in behavior to the x86 instruction LZCNT. + /// + /// The value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int LeadingZeroCount(ulong value) + { + uint hi = (uint)(value >> 32); + + if (hi == 0) + { + return 32 + LeadingZeroCount((uint)value); + } + + return LeadingZeroCount(hi); + } + } +} + +#endif diff --git a/src/SharpCompress/Compressors/ZStandard/CompressionStream.cs b/src/SharpCompress/Compressors/ZStandard/CompressionStream.cs new file mode 100644 index 000000000..92de03b34 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/CompressionStream.cs @@ -0,0 +1,301 @@ +using System; +using System.Buffers; +using System.IO; +using System.Threading; +using System.Threading.Tasks; +using SharpCompress.Compressors.ZStandard.Unsafe; + +namespace SharpCompress.Compressors.ZStandard; + +public class CompressionStream : Stream +{ + private readonly Stream innerStream; + private readonly byte[] outputBuffer; + private readonly bool preserveCompressor; + private readonly bool leaveOpen; + private Compressor? compressor; + private ZSTD_outBuffer_s output; + + public CompressionStream( + Stream stream, + int level = Compressor.DefaultCompressionLevel, + int bufferSize = 0, + bool leaveOpen = true + ) + : this(stream, new Compressor(level), bufferSize, false, leaveOpen) { } + + public CompressionStream( + Stream stream, + Compressor compressor, + int bufferSize = 0, + bool preserveCompressor = true, + bool leaveOpen = true + ) + { + if (stream == null) + throw new ArgumentNullException(nameof(stream)); + + if (!stream.CanWrite) + throw new ArgumentException("Stream is not writable", nameof(stream)); + + if (bufferSize < 0) + throw new ArgumentOutOfRangeException(nameof(bufferSize)); + + innerStream = stream; + this.compressor = compressor; + this.preserveCompressor = preserveCompressor; + this.leaveOpen = leaveOpen; + + var outputBufferSize = + bufferSize > 0 + ? bufferSize + : (int)Unsafe.Methods.ZSTD_CStreamOutSize().EnsureZstdSuccess(); + outputBuffer = ArrayPool.Shared.Rent(outputBufferSize); + output = new ZSTD_outBuffer_s { pos = 0, size = (nuint)outputBufferSize }; + } + + public void SetParameter(ZSTD_cParameter parameter, int value) + { + EnsureNotDisposed(); + compressor.NotNull().SetParameter(parameter, value); + } + + public int GetParameter(ZSTD_cParameter parameter) + { + EnsureNotDisposed(); + return compressor.NotNull().GetParameter(parameter); + } + + public void LoadDictionary(byte[] dict) + { + EnsureNotDisposed(); + compressor.NotNull().LoadDictionary(dict); + } + + ~CompressionStream() => Dispose(false); + +#if !NETSTANDARD2_0 && !NETFRAMEWORK + public override async ValueTask DisposeAsync() +#else + public async Task DisposeAsync() +#endif + { + if (compressor == null) + return; + + try + { + await FlushInternalAsync(ZSTD_EndDirective.ZSTD_e_end).ConfigureAwait(false); + } + finally + { + ReleaseUnmanagedResources(); + GC.SuppressFinalize(this); + } + } + + protected override void Dispose(bool disposing) + { + if (compressor == null) + return; + + try + { + if (disposing) + FlushInternal(ZSTD_EndDirective.ZSTD_e_end); + } + finally + { + ReleaseUnmanagedResources(); + } + } + + private void ReleaseUnmanagedResources() + { + if (!preserveCompressor) + { + compressor.NotNull().Dispose(); + } + compressor = null; + + if (outputBuffer != null) + { + ArrayPool.Shared.Return(outputBuffer); + } + + if (!leaveOpen) + { + innerStream.Dispose(); + } + } + + public override void Flush() => FlushInternal(ZSTD_EndDirective.ZSTD_e_flush); + + public override async Task FlushAsync(CancellationToken cancellationToken) => + await FlushInternalAsync(ZSTD_EndDirective.ZSTD_e_flush, cancellationToken) + .ConfigureAwait(false); + + private void FlushInternal(ZSTD_EndDirective directive) => WriteInternal(null, directive); + + private async Task FlushInternalAsync( + ZSTD_EndDirective directive, + CancellationToken cancellationToken = default + ) => await WriteInternalAsync(null, directive, cancellationToken).ConfigureAwait(false); + + public override void Write(byte[] buffer, int offset, int count) => + Write(new ReadOnlySpan(buffer, offset, count)); + +#if !NETSTANDARD2_0 && !NETFRAMEWORK + public override void Write(ReadOnlySpan buffer) => + WriteInternal(buffer, ZSTD_EndDirective.ZSTD_e_continue); +#else + public void Write(ReadOnlySpan buffer) => + WriteInternal(buffer, ZSTD_EndDirective.ZSTD_e_continue); +#endif + + private void WriteInternal(ReadOnlySpan buffer, ZSTD_EndDirective directive) + { + EnsureNotDisposed(); + + var input = new ZSTD_inBuffer_s + { + pos = 0, + size = buffer != null ? (nuint)buffer.Length : 0, + }; + nuint remaining; + do + { + output.pos = 0; + remaining = CompressStream(ref input, buffer, directive); + + var written = (int)output.pos; + if (written > 0) + innerStream.Write(outputBuffer, 0, written); + } while ( + directive == ZSTD_EndDirective.ZSTD_e_continue ? input.pos < input.size : remaining > 0 + ); + } + +#if !NETSTANDARD2_0 && !NETFRAMEWORK + private async ValueTask WriteInternalAsync( + ReadOnlyMemory? buffer, + ZSTD_EndDirective directive, + CancellationToken cancellationToken = default + ) +#else + private async Task WriteInternalAsync( + ReadOnlyMemory? buffer, + ZSTD_EndDirective directive, + CancellationToken cancellationToken = default + ) +#endif + + { + EnsureNotDisposed(); + + var input = new ZSTD_inBuffer_s + { + pos = 0, + size = buffer.HasValue ? (nuint)buffer.Value.Length : 0, + }; + nuint remaining; + do + { + output.pos = 0; + remaining = CompressStream( + ref input, + buffer.HasValue ? buffer.Value.Span : null, + directive + ); + + var written = (int)output.pos; + if (written > 0) + await innerStream + .WriteAsync(outputBuffer, 0, written, cancellationToken) + .ConfigureAwait(false); + } while ( + directive == ZSTD_EndDirective.ZSTD_e_continue ? input.pos < input.size : remaining > 0 + ); + } + +#if !NETSTANDARD2_0 && !NETFRAMEWORK + + public override Task WriteAsync( + byte[] buffer, + int offset, + int count, + CancellationToken cancellationToken + ) => WriteAsync(new ReadOnlyMemory(buffer, offset, count), cancellationToken).AsTask(); + + public override async ValueTask WriteAsync( + ReadOnlyMemory buffer, + CancellationToken cancellationToken = default + ) => + await WriteInternalAsync(buffer, ZSTD_EndDirective.ZSTD_e_continue, cancellationToken) + .ConfigureAwait(false); +#else + + public override Task WriteAsync( + byte[] buffer, + int offset, + int count, + CancellationToken cancellationToken + ) => WriteAsync(new ReadOnlyMemory(buffer, offset, count), cancellationToken); + + public async Task WriteAsync( + ReadOnlyMemory buffer, + CancellationToken cancellationToken = default + ) => + await WriteInternalAsync(buffer, ZSTD_EndDirective.ZSTD_e_continue, cancellationToken) + .ConfigureAwait(false); +#endif + + internal unsafe nuint CompressStream( + ref ZSTD_inBuffer_s input, + ReadOnlySpan inputBuffer, + ZSTD_EndDirective directive + ) + { + fixed (byte* inputBufferPtr = inputBuffer) + fixed (byte* outputBufferPtr = outputBuffer) + { + input.src = inputBufferPtr; + output.dst = outputBufferPtr; + return compressor + .NotNull() + .CompressStream(ref input, ref output, directive) + .EnsureZstdSuccess(); + } + } + + public override bool CanRead => false; + public override bool CanSeek => false; + public override bool CanWrite => true; + + public override long Length => throw new NotSupportedException(); + + public override long Position + { + get => throw new NotSupportedException(); + set => throw new NotSupportedException(); + } + + public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException(); + + public override void SetLength(long value) => throw new NotSupportedException(); + + public override int Read(byte[] buffer, int offset, int count) => + throw new NotSupportedException(); + + private void EnsureNotDisposed() + { + if (compressor == null) + throw new ObjectDisposedException(nameof(CompressionStream)); + } + + public void SetPledgedSrcSize(ulong pledgedSrcSize) + { + EnsureNotDisposed(); + compressor.NotNull().SetPledgedSrcSize(pledgedSrcSize); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Compressor.cs b/src/SharpCompress/Compressors/ZStandard/Compressor.cs new file mode 100644 index 000000000..668606016 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Compressor.cs @@ -0,0 +1,204 @@ +using System; +using SharpCompress.Compressors.ZStandard.Unsafe; + +namespace SharpCompress.Compressors.ZStandard; + +public unsafe class Compressor : IDisposable +{ + /// + /// Minimum negative compression level allowed + /// + public static int MinCompressionLevel => Unsafe.Methods.ZSTD_minCLevel(); + + /// + /// Maximum compression level available + /// + public static int MaxCompressionLevel => Unsafe.Methods.ZSTD_maxCLevel(); + + /// + /// Default compression level + /// + /// + public const int DefaultCompressionLevel = 3; + + private int level = DefaultCompressionLevel; + + private readonly SafeCctxHandle handle; + + public int Level + { + get => level; + set + { + if (level != value) + { + level = value; + SetParameter(ZSTD_cParameter.ZSTD_c_compressionLevel, value); + } + } + } + + public void SetParameter(ZSTD_cParameter parameter, int value) + { + using var cctx = handle.Acquire(); + Unsafe.Methods.ZSTD_CCtx_setParameter(cctx, parameter, value).EnsureZstdSuccess(); + } + + public int GetParameter(ZSTD_cParameter parameter) + { + using var cctx = handle.Acquire(); + int value; + Unsafe.Methods.ZSTD_CCtx_getParameter(cctx, parameter, &value).EnsureZstdSuccess(); + return value; + } + + public void LoadDictionary(byte[] dict) + { + var dictReadOnlySpan = new ReadOnlySpan(dict); + LoadDictionary(dictReadOnlySpan); + } + + public void LoadDictionary(ReadOnlySpan dict) + { + using var cctx = handle.Acquire(); + fixed (byte* dictPtr = dict) + Unsafe + .Methods.ZSTD_CCtx_loadDictionary(cctx, dictPtr, (nuint)dict.Length) + .EnsureZstdSuccess(); + } + + public Compressor(int level = DefaultCompressionLevel) + { + handle = SafeCctxHandle.Create(); + Level = level; + } + + public static int GetCompressBound(int length) => + (int)Unsafe.Methods.ZSTD_compressBound((nuint)length); + + public static ulong GetCompressBoundLong(ulong length) => + Unsafe.Methods.ZSTD_compressBound((nuint)length); + + public Span Wrap(ReadOnlySpan src) + { + var dest = new byte[GetCompressBound(src.Length)]; + var length = Wrap(src, dest); + return new Span(dest, 0, length); + } + + public int Wrap(byte[] src, byte[] dest, int offset) => + Wrap(src, new Span(dest, offset, dest.Length - offset)); + + public int Wrap(ReadOnlySpan src, Span dest) + { + fixed (byte* srcPtr = src) + fixed (byte* destPtr = dest) + { + using var cctx = handle.Acquire(); + return (int) + Unsafe + .Methods.ZSTD_compress2( + cctx, + destPtr, + (nuint)dest.Length, + srcPtr, + (nuint)src.Length + ) + .EnsureZstdSuccess(); + } + } + + public int Wrap(ArraySegment src, ArraySegment dest) => + Wrap((ReadOnlySpan)src, dest); + + public int Wrap( + byte[] src, + int srcOffset, + int srcLength, + byte[] dst, + int dstOffset, + int dstLength + ) => + Wrap( + new ReadOnlySpan(src, srcOffset, srcLength), + new Span(dst, dstOffset, dstLength) + ); + + public bool TryWrap(byte[] src, byte[] dest, int offset, out int written) => + TryWrap(src, new Span(dest, offset, dest.Length - offset), out written); + + public bool TryWrap(ReadOnlySpan src, Span dest, out int written) + { + fixed (byte* srcPtr = src) + fixed (byte* destPtr = dest) + { + nuint returnValue; + using (var cctx = handle.Acquire()) + { + returnValue = Unsafe.Methods.ZSTD_compress2( + cctx, + destPtr, + (nuint)dest.Length, + srcPtr, + (nuint)src.Length + ); + } + + if (returnValue == unchecked(0 - (nuint)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)) + { + written = default; + return false; + } + + returnValue.EnsureZstdSuccess(); + written = (int)returnValue; + return true; + } + } + + public bool TryWrap(ArraySegment src, ArraySegment dest, out int written) => + TryWrap((ReadOnlySpan)src, dest, out written); + + public bool TryWrap( + byte[] src, + int srcOffset, + int srcLength, + byte[] dst, + int dstOffset, + int dstLength, + out int written + ) => + TryWrap( + new ReadOnlySpan(src, srcOffset, srcLength), + new Span(dst, dstOffset, dstLength), + out written + ); + + public void Dispose() + { + handle.Dispose(); + GC.SuppressFinalize(this); + } + + internal nuint CompressStream( + ref ZSTD_inBuffer_s input, + ref ZSTD_outBuffer_s output, + ZSTD_EndDirective directive + ) + { + fixed (ZSTD_inBuffer_s* inputPtr = &input) + fixed (ZSTD_outBuffer_s* outputPtr = &output) + { + using var cctx = handle.Acquire(); + return Unsafe + .Methods.ZSTD_compressStream2(cctx, outputPtr, inputPtr, directive) + .EnsureZstdSuccess(); + } + } + + public void SetPledgedSrcSize(ulong pledgedSrcSize) + { + using var cctx = handle.Acquire(); + Unsafe.Methods.ZSTD_CCtx_setPledgedSrcSize(cctx, pledgedSrcSize).EnsureZstdSuccess(); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Constants.cs b/src/SharpCompress/Compressors/ZStandard/Constants.cs new file mode 100644 index 000000000..cce84fc09 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Constants.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard; + +internal class Constants +{ + //NOTE: https://docs.microsoft.com/en-us/dotnet/framework/configure-apps/file-schema/runtime/gcallowverylargeobjects-element#remarks + //NOTE: https://github.com/dotnet/runtime/blob/v5.0.0-rtm.20519.4/src/libraries/System.Private.CoreLib/src/System/Array.cs#L27 + public const ulong MaxByteArrayLength = 0x7FFFFFC7; +} diff --git a/src/SharpCompress/Compressors/ZStandard/DecompressionStream.cs b/src/SharpCompress/Compressors/ZStandard/DecompressionStream.cs new file mode 100644 index 000000000..9864a8055 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/DecompressionStream.cs @@ -0,0 +1,293 @@ +using System; +using System.Buffers; +using System.IO; +using System.Threading; +using System.Threading.Tasks; +using SharpCompress.Compressors.ZStandard.Unsafe; + +namespace SharpCompress.Compressors.ZStandard; + +public class DecompressionStream : Stream +{ + private readonly Stream innerStream; + private readonly byte[] inputBuffer; + private readonly int inputBufferSize; + private readonly bool preserveDecompressor; + private readonly bool leaveOpen; + private readonly bool checkEndOfStream; + private Decompressor? decompressor; + private ZSTD_inBuffer_s input; + private nuint lastDecompressResult = 0; + private bool contextDrained = true; + + public DecompressionStream( + Stream stream, + int bufferSize = 0, + bool checkEndOfStream = true, + bool leaveOpen = true + ) + : this(stream, new Decompressor(), bufferSize, checkEndOfStream, false, leaveOpen) { } + + public DecompressionStream( + Stream stream, + Decompressor decompressor, + int bufferSize = 0, + bool checkEndOfStream = true, + bool preserveDecompressor = true, + bool leaveOpen = true + ) + { + if (stream == null) + throw new ArgumentNullException(nameof(stream)); + + if (!stream.CanRead) + throw new ArgumentException("Stream is not readable", nameof(stream)); + + if (bufferSize < 0) + throw new ArgumentOutOfRangeException(nameof(bufferSize)); + + innerStream = stream; + this.decompressor = decompressor; + this.preserveDecompressor = preserveDecompressor; + this.leaveOpen = leaveOpen; + this.checkEndOfStream = checkEndOfStream; + + inputBufferSize = + bufferSize > 0 + ? bufferSize + : (int)Unsafe.Methods.ZSTD_DStreamInSize().EnsureZstdSuccess(); + inputBuffer = ArrayPool.Shared.Rent(inputBufferSize); + input = new ZSTD_inBuffer_s { pos = (nuint)inputBufferSize, size = (nuint)inputBufferSize }; + } + + public void SetParameter(ZSTD_dParameter parameter, int value) + { + EnsureNotDisposed(); + decompressor.NotNull().SetParameter(parameter, value); + } + + public int GetParameter(ZSTD_dParameter parameter) + { + EnsureNotDisposed(); + return decompressor.NotNull().GetParameter(parameter); + } + + public void LoadDictionary(byte[] dict) + { + EnsureNotDisposed(); + decompressor.NotNull().LoadDictionary(dict); + } + + ~DecompressionStream() => Dispose(false); + + protected override void Dispose(bool disposing) + { + if (decompressor == null) + return; + + if (!preserveDecompressor) + { + decompressor.Dispose(); + } + decompressor = null; + + if (inputBuffer != null) + { + ArrayPool.Shared.Return(inputBuffer); + } + + if (!leaveOpen) + { + innerStream.Dispose(); + } + } + + public override int Read(byte[] buffer, int offset, int count) => + Read(new Span(buffer, offset, count)); + +#if !NETSTANDARD2_0 && !NETFRAMEWORK + public override int Read(Span buffer) +#else + public int Read(Span buffer) +#endif + { + EnsureNotDisposed(); + + // Guard against infinite loop (output.pos would never become non-zero) + if (buffer.Length == 0) + { + return 0; + } + + var output = new ZSTD_outBuffer_s { pos = 0, size = (nuint)buffer.Length }; + while (true) + { + // If there is still input available, or there might be data buffered in the decompressor context, flush that out + while (input.pos < input.size || !contextDrained) + { + nuint oldInputPos = input.pos; + nuint result = DecompressStream(ref output, buffer); + if (output.pos > 0 || oldInputPos != input.pos) + { + // Keep result from last decompress call that made some progress, so we known if we're at end of frame + lastDecompressResult = result; + } + // If decompression filled the output buffer, there might still be data buffered in the decompressor context + contextDrained = output.pos < output.size; + // If we have data to return, return it immediately, so we won't stall on Read + if (output.pos > 0) + { + return (int)output.pos; + } + } + + // Otherwise, read some more input + int bytesRead; + if ((bytesRead = innerStream.Read(inputBuffer, 0, inputBufferSize)) == 0) + { + if (checkEndOfStream && lastDecompressResult != 0) + { + throw new EndOfStreamException("Premature end of stream"); + } + + return 0; + } + + input.size = (nuint)bytesRead; + input.pos = 0; + } + } + +#if !NETSTANDARD2_0 && !NETFRAMEWORK + public override Task ReadAsync( + byte[] buffer, + int offset, + int count, + CancellationToken cancellationToken + ) => ReadAsync(new Memory(buffer, offset, count), cancellationToken).AsTask(); + + public override async ValueTask ReadAsync( + Memory buffer, + CancellationToken cancellationToken = default + ) +#else + + public override Task ReadAsync( + byte[] buffer, + int offset, + int count, + CancellationToken cancellationToken + ) => ReadAsync(new Memory(buffer, offset, count), cancellationToken); + + public async Task ReadAsync( + Memory buffer, + CancellationToken cancellationToken = default + ) +#endif + { + EnsureNotDisposed(); + + // Guard against infinite loop (output.pos would never become non-zero) + if (buffer.Length == 0) + { + return 0; + } + + var output = new ZSTD_outBuffer_s { pos = 0, size = (nuint)buffer.Length }; + while (true) + { + // If there is still input available, or there might be data buffered in the decompressor context, flush that out + while (input.pos < input.size || !contextDrained) + { + nuint oldInputPos = input.pos; + nuint result = DecompressStream(ref output, buffer.Span); + if (output.pos > 0 || oldInputPos != input.pos) + { + // Keep result from last decompress call that made some progress, so we known if we're at end of frame + lastDecompressResult = result; + } + // If decompression filled the output buffer, there might still be data buffered in the decompressor context + contextDrained = output.pos < output.size; + // If we have data to return, return it immediately, so we won't stall on Read + if (output.pos > 0) + { + return (int)output.pos; + } + } + + // Otherwise, read some more input + int bytesRead; + if ( + ( + bytesRead = await innerStream + .ReadAsync(inputBuffer, 0, inputBufferSize, cancellationToken) + .ConfigureAwait(false) + ) == 0 + ) + { + if (checkEndOfStream && lastDecompressResult != 0) + { + throw new EndOfStreamException("Premature end of stream"); + } + + return 0; + } + + input.size = (nuint)bytesRead; + input.pos = 0; + } + } + + private unsafe nuint DecompressStream(ref ZSTD_outBuffer_s output, Span outputBuffer) + { + fixed (byte* inputBufferPtr = inputBuffer) + fixed (byte* outputBufferPtr = outputBuffer) + { + input.src = inputBufferPtr; + output.dst = outputBufferPtr; + return decompressor.NotNull().DecompressStream(ref input, ref output); + } + } + + public override bool CanRead => true; + public override bool CanSeek => false; + public override bool CanWrite => false; + + public override long Length => throw new NotSupportedException(); + + public override long Position + { + get => throw new NotSupportedException(); + set => throw new NotSupportedException(); + } + + public override void Flush() => throw new NotSupportedException(); + + public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException(); + + public override void SetLength(long value) => throw new NotSupportedException(); + + public override void Write(byte[] buffer, int offset, int count) => + throw new NotSupportedException(); + + private void EnsureNotDisposed() + { + if (decompressor == null) + throw new ObjectDisposedException(nameof(DecompressionStream)); + } + +#if NETSTANDARD2_0 || NETFRAMEWORK + public virtual Task DisposeAsync() + { + try + { + Dispose(); + return Task.CompletedTask; + } + catch (Exception exc) + { + return Task.FromException(exc); + } + } +#endif +} diff --git a/src/SharpCompress/Compressors/ZStandard/Decompressor.cs b/src/SharpCompress/Compressors/ZStandard/Decompressor.cs new file mode 100644 index 000000000..8a63c4d9d --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Decompressor.cs @@ -0,0 +1,176 @@ +using System; +using SharpCompress.Compressors.ZStandard.Unsafe; + +namespace SharpCompress.Compressors.ZStandard; + +public unsafe class Decompressor : IDisposable +{ + private readonly SafeDctxHandle handle; + + public Decompressor() + { + handle = SafeDctxHandle.Create(); + } + + public void SetParameter(ZSTD_dParameter parameter, int value) + { + using var dctx = handle.Acquire(); + Unsafe.Methods.ZSTD_DCtx_setParameter(dctx, parameter, value).EnsureZstdSuccess(); + } + + public int GetParameter(ZSTD_dParameter parameter) + { + using var dctx = handle.Acquire(); + int value; + Unsafe.Methods.ZSTD_DCtx_getParameter(dctx, parameter, &value).EnsureZstdSuccess(); + return value; + } + + public void LoadDictionary(byte[] dict) + { + var dictReadOnlySpan = new ReadOnlySpan(dict); + this.LoadDictionary(dictReadOnlySpan); + } + + public void LoadDictionary(ReadOnlySpan dict) + { + using var dctx = handle.Acquire(); + fixed (byte* dictPtr = dict) + Unsafe + .Methods.ZSTD_DCtx_loadDictionary(dctx, dictPtr, (nuint)dict.Length) + .EnsureZstdSuccess(); + } + + public static ulong GetDecompressedSize(ReadOnlySpan src) + { + fixed (byte* srcPtr = src) + return Unsafe + .Methods.ZSTD_decompressBound(srcPtr, (nuint)src.Length) + .EnsureContentSizeOk(); + } + + public static ulong GetDecompressedSize(ArraySegment src) => + GetDecompressedSize((ReadOnlySpan)src); + + public static ulong GetDecompressedSize(byte[] src, int srcOffset, int srcLength) => + GetDecompressedSize(new ReadOnlySpan(src, srcOffset, srcLength)); + + public Span Unwrap(ReadOnlySpan src, int maxDecompressedSize = int.MaxValue) + { + var expectedDstSize = GetDecompressedSize(src); + if (expectedDstSize > (ulong)maxDecompressedSize) + throw new ZstdException( + ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall, + $"Decompressed content size {expectedDstSize} is greater than {nameof(maxDecompressedSize)} {maxDecompressedSize}" + ); + if (expectedDstSize > Constants.MaxByteArrayLength) + throw new ZstdException( + ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall, + $"Decompressed content size {expectedDstSize} is greater than max possible byte array size {Constants.MaxByteArrayLength}" + ); + + var dest = new byte[expectedDstSize]; + var length = Unwrap(src, dest); + return new Span(dest, 0, length); + } + + public int Unwrap(byte[] src, byte[] dest, int offset) => + Unwrap(src, new Span(dest, offset, dest.Length - offset)); + + public int Unwrap(ReadOnlySpan src, Span dest) + { + fixed (byte* srcPtr = src) + fixed (byte* destPtr = dest) + { + using var dctx = handle.Acquire(); + return (int) + Unsafe + .Methods.ZSTD_decompressDCtx( + dctx, + destPtr, + (nuint)dest.Length, + srcPtr, + (nuint)src.Length + ) + .EnsureZstdSuccess(); + } + } + + public int Unwrap( + byte[] src, + int srcOffset, + int srcLength, + byte[] dst, + int dstOffset, + int dstLength + ) => + Unwrap( + new ReadOnlySpan(src, srcOffset, srcLength), + new Span(dst, dstOffset, dstLength) + ); + + public bool TryUnwrap(byte[] src, byte[] dest, int offset, out int written) => + TryUnwrap(src, new Span(dest, offset, dest.Length - offset), out written); + + public bool TryUnwrap(ReadOnlySpan src, Span dest, out int written) + { + fixed (byte* srcPtr = src) + fixed (byte* destPtr = dest) + { + nuint returnValue; + using (var dctx = handle.Acquire()) + { + returnValue = Unsafe.Methods.ZSTD_decompressDCtx( + dctx, + destPtr, + (nuint)dest.Length, + srcPtr, + (nuint)src.Length + ); + } + + if (returnValue == unchecked(0 - (nuint)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)) + { + written = default; + return false; + } + + returnValue.EnsureZstdSuccess(); + written = (int)returnValue; + return true; + } + } + + public bool TryUnwrap( + byte[] src, + int srcOffset, + int srcLength, + byte[] dst, + int dstOffset, + int dstLength, + out int written + ) => + TryUnwrap( + new ReadOnlySpan(src, srcOffset, srcLength), + new Span(dst, dstOffset, dstLength), + out written + ); + + public void Dispose() + { + handle.Dispose(); + GC.SuppressFinalize(this); + } + + internal nuint DecompressStream(ref ZSTD_inBuffer_s input, ref ZSTD_outBuffer_s output) + { + fixed (ZSTD_inBuffer_s* inputPtr = &input) + fixed (ZSTD_outBuffer_s* outputPtr = &output) + { + using var dctx = handle.Acquire(); + return Unsafe + .Methods.ZSTD_decompressStream(dctx, outputPtr, inputPtr) + .EnsureZstdSuccess(); + } + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/JobThreadPool.cs b/src/SharpCompress/Compressors/ZStandard/JobThreadPool.cs new file mode 100644 index 000000000..e783940dc --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/JobThreadPool.cs @@ -0,0 +1,141 @@ +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Threading; + +namespace SharpCompress.Compressors.ZStandard; + +internal unsafe class JobThreadPool : IDisposable +{ + private int numThreads; + private readonly List threads; + private readonly BlockingCollection queue; + + private struct Job + { + public void* function; + public void* opaque; + } + + private class JobThread + { + private Thread Thread { get; } + public CancellationTokenSource CancellationTokenSource { get; } + + public JobThread(Thread thread) + { + CancellationTokenSource = new CancellationTokenSource(); + Thread = thread; + } + + public void Start() + { + Thread.Start(this); + } + + public void Cancel() + { + CancellationTokenSource.Cancel(); + } + + public void Join() + { + Thread.Join(); + } + } + + private void Worker(object? obj) + { + if (obj is not JobThread poolThread) + return; + + var cancellationToken = poolThread.CancellationTokenSource.Token; + while (!queue.IsCompleted && !cancellationToken.IsCancellationRequested) + { + try + { + if (queue.TryTake(out var job, -1, cancellationToken)) + ((delegate* managed)job.function)(job.opaque); + } + catch (InvalidOperationException) { } + catch (OperationCanceledException) { } + } + } + + public JobThreadPool(int num, int queueSize) + { + numThreads = num; + queue = new BlockingCollection(queueSize + 1); + threads = new List(num); + for (var i = 0; i < numThreads; i++) + CreateThread(); + } + + private void CreateThread() + { + var poolThread = new JobThread(new Thread(Worker)); + threads.Add(poolThread); + poolThread.Start(); + } + + public void Resize(int num) + { + lock (threads) + { + if (num < numThreads) + { + for (var i = numThreads - 1; i >= num; i--) + { + threads[i].Cancel(); + threads.RemoveAt(i); + } + } + else + { + for (var i = numThreads; i < num; i++) + CreateThread(); + } + } + + numThreads = num; + } + + public void Add(void* function, void* opaque) + { + queue.Add(new Job { function = function, opaque = opaque }); + } + + public bool TryAdd(void* function, void* opaque) + { + return queue.TryAdd(new Job { function = function, opaque = opaque }); + } + + public void Join(bool cancel = true) + { + queue.CompleteAdding(); + List jobThreads; + lock (threads) + jobThreads = new List(threads); + + if (cancel) + { + foreach (var thread in jobThreads) + thread.Cancel(); + } + + foreach (var thread in jobThreads) + thread.Join(); + } + + public void Dispose() + { + queue.Dispose(); + } + + public int Size() + { + // todo not implemented + // https://github.com/dotnet/runtime/issues/24200 + return 0; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/SafeHandles.cs b/src/SharpCompress/Compressors/ZStandard/SafeHandles.cs new file mode 100644 index 000000000..3b49bdcec --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/SafeHandles.cs @@ -0,0 +1,163 @@ +using System; +using System.Runtime.InteropServices; +using SharpCompress.Compressors.ZStandard.Unsafe; + +namespace SharpCompress.Compressors.ZStandard; + +/// +/// Provides the base class for ZstdSharp implementations. +/// +/// +/// Even though ZstdSharp is a managed library, its internals are using unmanaged +/// memory and we are using safe handles in the library's high-level API to ensure +/// proper disposal of unmanaged resources and increase safety. +/// +/// +/// +internal abstract unsafe class SafeZstdHandle : SafeHandle +{ + /// + /// Parameterless constructor is hidden. Use the static Create factory + /// method to create a new safe handle instance. + /// + protected SafeZstdHandle() + : base(IntPtr.Zero, true) { } + + public sealed override bool IsInvalid => handle == IntPtr.Zero; +} + +/// +/// Safely wraps an unmanaged Zstd compression context. +/// +internal sealed unsafe class SafeCctxHandle : SafeZstdHandle +{ + /// + private SafeCctxHandle() { } + + /// + /// Creates a new instance of . + /// + /// + /// Creation failed. + public static SafeCctxHandle Create() + { + var safeHandle = new SafeCctxHandle(); + bool success = false; + try + { + var cctx = Unsafe.Methods.ZSTD_createCCtx(); + if (cctx == null) + throw new ZstdException(ZSTD_ErrorCode.ZSTD_error_GENERIC, "Failed to create cctx"); + safeHandle.SetHandle((IntPtr)cctx); + success = true; + } + finally + { + if (!success) + { + safeHandle.SetHandleAsInvalid(); + } + } + return safeHandle; + } + + /// + /// Acquires a reference to the safe handle. + /// + /// + /// A instance that can be implicitly converted to a pointer + /// to . + /// + public SafeHandleHolder Acquire() => new(this); + + protected override bool ReleaseHandle() + { + return Unsafe.Methods.ZSTD_freeCCtx((ZSTD_CCtx_s*)handle) == 0; + } +} + +/// +/// Safely wraps an unmanaged Zstd compression context. +/// +internal sealed unsafe class SafeDctxHandle : SafeZstdHandle +{ + /// + private SafeDctxHandle() { } + + /// + /// Creates a new instance of . + /// + /// + /// Creation failed. + public static SafeDctxHandle Create() + { + var safeHandle = new SafeDctxHandle(); + bool success = false; + try + { + var dctx = Unsafe.Methods.ZSTD_createDCtx(); + if (dctx == null) + throw new ZstdException(ZSTD_ErrorCode.ZSTD_error_GENERIC, "Failed to create dctx"); + safeHandle.SetHandle((IntPtr)dctx); + success = true; + } + finally + { + if (!success) + { + safeHandle.SetHandleAsInvalid(); + } + } + return safeHandle; + } + + /// + /// Acquires a reference to the safe handle. + /// + /// + /// A instance that can be implicitly converted to a pointer + /// to . + /// + public SafeHandleHolder Acquire() => new(this); + + protected override bool ReleaseHandle() + { + return Unsafe.Methods.ZSTD_freeDCtx((ZSTD_DCtx_s*)handle) == 0; + } +} + +/// +/// Provides a convenient interface to safely acquire pointers of a specific type +/// from a , by utilizing blocks. +/// +/// The type of pointers to return. +/// +/// Safe handle holders can be d to decrement the safe handle's +/// reference count, and can be implicitly converted to pointers to . +/// +internal unsafe ref struct SafeHandleHolder + where T : unmanaged +{ + private readonly SafeHandle _handle; + + private bool _refAdded; + + public SafeHandleHolder(SafeHandle safeHandle) + { + _handle = safeHandle; + _refAdded = false; + safeHandle.DangerousAddRef(ref _refAdded); + } + + public static implicit operator T*(SafeHandleHolder holder) => + (T*)holder._handle.DangerousGetHandle(); + + public void Dispose() + { + if (_refAdded) + { + _handle.DangerousRelease(); + _refAdded = false; + } + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/SynchronizationWrapper.cs b/src/SharpCompress/Compressors/ZStandard/SynchronizationWrapper.cs new file mode 100644 index 000000000..406cacd43 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/SynchronizationWrapper.cs @@ -0,0 +1,22 @@ +using System.Threading; + +namespace SharpCompress.Compressors.ZStandard; + +internal static unsafe class SynchronizationWrapper +{ + private static object UnwrapObject(void** obj) => UnmanagedObject.Unwrap(*obj); + + public static void Init(void** obj) => *obj = UnmanagedObject.Wrap(new object()); + + public static void Free(void** obj) => UnmanagedObject.Free(*obj); + + public static void Enter(void** obj) => Monitor.Enter(UnwrapObject(obj)); + + public static void Exit(void** obj) => Monitor.Exit(UnwrapObject(obj)); + + public static void Pulse(void** obj) => Monitor.Pulse(UnwrapObject(obj)); + + public static void PulseAll(void** obj) => Monitor.PulseAll(UnwrapObject(obj)); + + public static void Wait(void** mutex) => Monitor.Wait(UnwrapObject(mutex)); +} diff --git a/src/SharpCompress/Compressors/ZStandard/ThrowHelper.cs b/src/SharpCompress/Compressors/ZStandard/ThrowHelper.cs new file mode 100644 index 000000000..5e051deb1 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/ThrowHelper.cs @@ -0,0 +1,48 @@ +using SharpCompress.Compressors.ZStandard.Unsafe; + +namespace SharpCompress.Compressors.ZStandard; + +public static unsafe class ThrowHelper +{ + private const ulong ZSTD_CONTENTSIZE_UNKNOWN = unchecked(0UL - 1); + private const ulong ZSTD_CONTENTSIZE_ERROR = unchecked(0UL - 2); + + public static nuint EnsureZstdSuccess(this nuint returnValue) + { + if (Unsafe.Methods.ZSTD_isError(returnValue)) + ThrowException(returnValue, Unsafe.Methods.ZSTD_getErrorName(returnValue)); + + return returnValue; + } + + public static nuint EnsureZdictSuccess(this nuint returnValue) + { + if (Unsafe.Methods.ZDICT_isError(returnValue)) + ThrowException(returnValue, Unsafe.Methods.ZDICT_getErrorName(returnValue)); + + return returnValue; + } + + public static ulong EnsureContentSizeOk(this ulong returnValue) + { + if (returnValue == ZSTD_CONTENTSIZE_UNKNOWN) + throw new ZstdException( + ZSTD_ErrorCode.ZSTD_error_GENERIC, + "Decompressed content size is not specified" + ); + + if (returnValue == ZSTD_CONTENTSIZE_ERROR) + throw new ZstdException( + ZSTD_ErrorCode.ZSTD_error_GENERIC, + "Decompressed content size cannot be determined (e.g. invalid magic number, srcSize too small)" + ); + + return returnValue; + } + + private static void ThrowException(nuint returnValue, string message) + { + var code = 0 - returnValue; + throw new ZstdException((ZSTD_ErrorCode)code, message); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/UnmanagedObject.cs b/src/SharpCompress/Compressors/ZStandard/UnmanagedObject.cs new file mode 100644 index 000000000..a5bb31bec --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/UnmanagedObject.cs @@ -0,0 +1,18 @@ +using System; +using System.Runtime.InteropServices; + +namespace SharpCompress.Compressors.ZStandard; + +/* + * Wrap object to void* to make it unmanaged + */ +internal static unsafe class UnmanagedObject +{ + public static void* Wrap(object obj) => (void*)GCHandle.ToIntPtr(GCHandle.Alloc(obj)); + + private static GCHandle UnwrapGcHandle(void* value) => GCHandle.FromIntPtr((IntPtr)value); + + public static T Unwrap(void* value) => (T)UnwrapGcHandle(value).Target!; + + public static void Free(void* value) => UnwrapGcHandle(value).Free(); +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Allocations.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Allocations.cs new file mode 100644 index 000000000..cecdd011e --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Allocations.cs @@ -0,0 +1,52 @@ +using System.Runtime.CompilerServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /* custom memory allocation functions */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void* ZSTD_customMalloc(nuint size, ZSTD_customMem customMem) + { + if (customMem.customAlloc != null) + return ((delegate* managed)customMem.customAlloc)( + customMem.opaque, + size + ); + return malloc(size); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void* ZSTD_customCalloc(nuint size, ZSTD_customMem customMem) + { + if (customMem.customAlloc != null) + { + /* calloc implemented as malloc+memset; + * not as efficient as calloc, but next best guess for custom malloc */ + void* ptr = ((delegate* managed)customMem.customAlloc)( + customMem.opaque, + size + ); + memset(ptr, 0, (uint)size); + return ptr; + } + + return calloc(1, size); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_customFree(void* ptr, ZSTD_customMem customMem) + { + if (ptr != null) + { + if (customMem.customFree != null) + ((delegate* managed)customMem.customFree)( + customMem.opaque, + ptr + ); + else + free(ptr); + } + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_CStream_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_CStream_t.cs new file mode 100644 index 000000000..ab23c39aa --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_CStream_t.cs @@ -0,0 +1,14 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* bitStream can mix input from multiple sources. + * A critical property of these streams is that they encode and decode in **reverse** direction. + * So the first bit sequence you add will be the last to be read, like a LIFO stack. + */ +public unsafe struct BIT_CStream_t +{ + public nuint bitContainer; + public uint bitPos; + public sbyte* startPtr; + public sbyte* ptr; + public sbyte* endPtr; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_DStream_status.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_DStream_status.cs new file mode 100644 index 000000000..60b468b14 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_DStream_status.cs @@ -0,0 +1,16 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum BIT_DStream_status +{ + /* fully refilled */ + BIT_DStream_unfinished = 0, + + /* still some bits left in bitstream */ + BIT_DStream_endOfBuffer = 1, + + /* bitstream entirely consumed, bit-exact */ + BIT_DStream_completed = 2, + + /* user requested more bits than present in bitstream */ + BIT_DStream_overflow = 3, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_DStream_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_DStream_t.cs new file mode 100644 index 000000000..c0e96134d --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_DStream_t.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*-******************************************** + * bitStream decoding API (read backward) + **********************************************/ +public unsafe struct BIT_DStream_t +{ + public nuint bitContainer; + public uint bitsConsumed; + public sbyte* ptr; + public sbyte* start; + public sbyte* limitPtr; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Bits.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Bits.cs new file mode 100644 index 000000000..e5484ae1e --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Bits.cs @@ -0,0 +1,60 @@ +using System; +using System.Numerics; +using System.Runtime.CompilerServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_countTrailingZeros32(uint val) + { + assert(val != 0); + return (uint)BitOperations.TrailingZeroCount(val); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_countLeadingZeros32(uint val) + { + assert(val != 0); + return (uint)BitOperations.LeadingZeroCount(val); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_countTrailingZeros64(ulong val) + { + assert(val != 0); + return (uint)BitOperations.TrailingZeroCount(val); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_countLeadingZeros64(ulong val) + { + assert(val != 0); + return (uint)BitOperations.LeadingZeroCount(val); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_NbCommonBytes(nuint val) + { + assert(val != 0); + if (BitConverter.IsLittleEndian) + { + return MEM_64bits + ? (uint)BitOperations.TrailingZeroCount(val) >> 3 + : (uint)BitOperations.TrailingZeroCount((uint)val) >> 3; + } + + return MEM_64bits + ? (uint)BitOperations.LeadingZeroCount(val) >> 3 + : (uint)BitOperations.LeadingZeroCount((uint)val) >> 3; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_highbit32(uint val) + { + assert(val != 0); + return (uint)BitOperations.Log2(val); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Bitstream.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Bitstream.cs new file mode 100644 index 000000000..88302a494 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Bitstream.cs @@ -0,0 +1,739 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; +#if NETCOREAPP3_0_OR_GREATER +using System.Runtime.Intrinsics.X86; +#endif + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_BIT_mask => + new uint[32] + { + 0, + 1, + 3, + 7, + 0xF, + 0x1F, + 0x3F, + 0x7F, + 0xFF, + 0x1FF, + 0x3FF, + 0x7FF, + 0xFFF, + 0x1FFF, + 0x3FFF, + 0x7FFF, + 0xFFFF, + 0x1FFFF, + 0x3FFFF, + 0x7FFFF, + 0xFFFFF, + 0x1FFFFF, + 0x3FFFFF, + 0x7FFFFF, + 0xFFFFFF, + 0x1FFFFFF, + 0x3FFFFFF, + 0x7FFFFFF, + 0xFFFFFFF, + 0x1FFFFFFF, + 0x3FFFFFFF, + 0x7FFFFFFF, + }; + private static uint* BIT_mask => + (uint*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_BIT_mask) + ); +#else + + private static readonly uint* BIT_mask = GetArrayPointer( + new uint[32] + { + 0, + 1, + 3, + 7, + 0xF, + 0x1F, + 0x3F, + 0x7F, + 0xFF, + 0x1FF, + 0x3FF, + 0x7FF, + 0xFFF, + 0x1FFF, + 0x3FFF, + 0x7FFF, + 0xFFFF, + 0x1FFFF, + 0x3FFFF, + 0x7FFFF, + 0xFFFFF, + 0x1FFFFF, + 0x3FFFFF, + 0x7FFFFF, + 0xFFFFFF, + 0x1FFFFFF, + 0x3FFFFFF, + 0x7FFFFFF, + 0xFFFFFFF, + 0x1FFFFFFF, + 0x3FFFFFFF, + 0x7FFFFFFF, + } + ); +#endif + /*-************************************************************** + * bitStream encoding + ****************************************************************/ + /*! BIT_initCStream() : + * `dstCapacity` must be > sizeof(size_t) + * @return : 0 if success, + * otherwise an error code (can be tested using ERR_isError()) */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_initCStream(ref BIT_CStream_t bitC, void* startPtr, nuint dstCapacity) + { + bitC.bitContainer = 0; + bitC.bitPos = 0; + bitC.startPtr = (sbyte*)startPtr; + bitC.ptr = bitC.startPtr; + bitC.endPtr = bitC.startPtr + dstCapacity - sizeof(nuint); + if (dstCapacity <= (nuint)sizeof(nuint)) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + return 0; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_getLowerBits(nuint bitContainer, uint nbBits) + { + assert(nbBits < sizeof(uint) * 32 / sizeof(uint)); +#if NETCOREAPP3_1_OR_GREATER + if (Bmi2.X64.IsSupported) + { + return (nuint)Bmi2.X64.ZeroHighBits(bitContainer, nbBits); + } + + if (Bmi2.IsSupported) + { + return Bmi2.ZeroHighBits((uint)bitContainer, nbBits); + } +#endif + + return bitContainer & BIT_mask[nbBits]; + } + + /*! BIT_addBits() : + * can add up to 31 bits into `bitC`. + * Note : does not check for register overflow ! */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void BIT_addBits( + ref nuint bitC_bitContainer, + ref uint bitC_bitPos, + nuint value, + uint nbBits + ) + { + assert(nbBits < sizeof(uint) * 32 / sizeof(uint)); + assert(nbBits + bitC_bitPos < (uint)(sizeof(nuint) * 8)); + bitC_bitContainer |= BIT_getLowerBits(value, nbBits) << (int)bitC_bitPos; + bitC_bitPos += nbBits; + } + + /*! BIT_addBitsFast() : + * works only if `value` is _clean_, + * meaning all high bits above nbBits are 0 */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void BIT_addBitsFast( + ref nuint bitC_bitContainer, + ref uint bitC_bitPos, + nuint value, + uint nbBits + ) + { + assert(value >> (int)nbBits == 0); + assert(nbBits + bitC_bitPos < (uint)(sizeof(nuint) * 8)); + bitC_bitContainer |= value << (int)bitC_bitPos; + bitC_bitPos += nbBits; + } + + /*! BIT_flushBitsFast() : + * assumption : bitContainer has not overflowed + * unsafe version; does not check buffer overflow */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void BIT_flushBitsFast( + ref nuint bitC_bitContainer, + ref uint bitC_bitPos, + ref sbyte* bitC_ptr, + sbyte* bitC_endPtr + ) + { + nuint nbBytes = bitC_bitPos >> 3; + assert(bitC_bitPos < (uint)(sizeof(nuint) * 8)); + assert(bitC_ptr <= bitC_endPtr); + MEM_writeLEST(bitC_ptr, bitC_bitContainer); + bitC_ptr += nbBytes; + bitC_bitPos &= 7; + bitC_bitContainer >>= (int)(nbBytes * 8); + } + + /*! BIT_flushBits() : + * assumption : bitContainer has not overflowed + * safe version; check for buffer overflow, and prevents it. + * note : does not signal buffer overflow. + * overflow will be revealed later on using BIT_closeCStream() */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void BIT_flushBits( + ref nuint bitC_bitContainer, + ref uint bitC_bitPos, + ref sbyte* bitC_ptr, + sbyte* bitC_endPtr + ) + { + nuint nbBytes = bitC_bitPos >> 3; + assert(bitC_bitPos < (uint)(sizeof(nuint) * 8)); + assert(bitC_ptr <= bitC_endPtr); + MEM_writeLEST(bitC_ptr, bitC_bitContainer); + bitC_ptr += nbBytes; + if (bitC_ptr > bitC_endPtr) + bitC_ptr = bitC_endPtr; + bitC_bitPos &= 7; + bitC_bitContainer >>= (int)(nbBytes * 8); + } + + /*! BIT_closeCStream() : + * @return : size of CStream, in bytes, + * or 0 if it could not fit into dstBuffer */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_closeCStream( + ref nuint bitC_bitContainer, + ref uint bitC_bitPos, + sbyte* bitC_ptr, + sbyte* bitC_endPtr, + sbyte* bitC_startPtr + ) + { + BIT_addBitsFast(ref bitC_bitContainer, ref bitC_bitPos, 1, 1); + BIT_flushBits(ref bitC_bitContainer, ref bitC_bitPos, ref bitC_ptr, bitC_endPtr); + if (bitC_ptr >= bitC_endPtr) + return 0; + return (nuint)(bitC_ptr - bitC_startPtr) + (nuint)(bitC_bitPos > 0 ? 1 : 0); + } + + /*-******************************************************** + * bitStream decoding + **********************************************************/ + /*! BIT_initDStream() : + * Initialize a BIT_DStream_t. + * `bitD` : a pointer to an already allocated BIT_DStream_t structure. + * `srcSize` must be the *exact* size of the bitStream, in bytes. + * @return : size of stream (== srcSize), or an errorCode if a problem is detected + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_initDStream(BIT_DStream_t* bitD, void* srcBuffer, nuint srcSize) + { + if (srcSize < 1) + { + *bitD = new BIT_DStream_t(); + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + bitD->start = (sbyte*)srcBuffer; + bitD->limitPtr = bitD->start + sizeof(nuint); + if (srcSize >= (nuint)sizeof(nuint)) + { + bitD->ptr = (sbyte*)srcBuffer + srcSize - sizeof(nuint); + bitD->bitContainer = MEM_readLEST(bitD->ptr); + { + byte lastByte = ((byte*)srcBuffer)[srcSize - 1]; + bitD->bitsConsumed = lastByte != 0 ? 8 - ZSTD_highbit32(lastByte) : 0; + if (lastByte == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + } + else + { + bitD->ptr = bitD->start; + bitD->bitContainer = *(byte*)bitD->start; + switch (srcSize) + { + case 7: + bitD->bitContainer += (nuint)((byte*)srcBuffer)[6] << sizeof(nuint) * 8 - 16; + goto case 6; + case 6: + bitD->bitContainer += (nuint)((byte*)srcBuffer)[5] << sizeof(nuint) * 8 - 24; + goto case 5; + case 5: + bitD->bitContainer += (nuint)((byte*)srcBuffer)[4] << sizeof(nuint) * 8 - 32; + goto case 4; + case 4: + bitD->bitContainer += (nuint)((byte*)srcBuffer)[3] << 24; + goto case 3; + case 3: + bitD->bitContainer += (nuint)((byte*)srcBuffer)[2] << 16; + goto case 2; + case 2: + bitD->bitContainer += (nuint)((byte*)srcBuffer)[1] << 8; + goto default; + default: + break; + } + + { + byte lastByte = ((byte*)srcBuffer)[srcSize - 1]; + bitD->bitsConsumed = lastByte != 0 ? 8 - ZSTD_highbit32(lastByte) : 0; + if (lastByte == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + bitD->bitsConsumed += (uint)((nuint)sizeof(nuint) - srcSize) * 8; + } + + return srcSize; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_getUpperBits(nuint bitContainer, uint start) + { + return bitContainer >> (int)start; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_getMiddleBits(nuint bitContainer, uint start, uint nbBits) + { + uint regMask = (uint)(sizeof(nuint) * 8 - 1); + assert(nbBits < sizeof(uint) * 32 / sizeof(uint)); +#if NETCOREAPP3_1_OR_GREATER + if (Bmi2.X64.IsSupported) + { + return (nuint)Bmi2.X64.ZeroHighBits(bitContainer >> (int)(start & regMask), nbBits); + } + + if (Bmi2.IsSupported) + { + return Bmi2.ZeroHighBits((uint)(bitContainer >> (int)(start & regMask)), nbBits); + } +#endif + + return (nuint)(bitContainer >> (int)(start & regMask) & ((ulong)1 << (int)nbBits) - 1); + } + + /*! BIT_lookBits() : + * Provides next n bits from local register. + * local register is not modified. + * On 32-bits, maxNbBits==24. + * On 64-bits, maxNbBits==56. + * @return : value extracted */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_lookBits(BIT_DStream_t* bitD, uint nbBits) + { + return BIT_getMiddleBits( + bitD->bitContainer, + (uint)(sizeof(nuint) * 8) - bitD->bitsConsumed - nbBits, + nbBits + ); + } + + /*! BIT_lookBitsFast() : + * unsafe version; only works if nbBits >= 1 */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_lookBitsFast(BIT_DStream_t* bitD, uint nbBits) + { + uint regMask = (uint)(sizeof(nuint) * 8 - 1); + assert(nbBits >= 1); + return bitD->bitContainer + << (int)(bitD->bitsConsumed & regMask) + >> (int)(regMask + 1 - nbBits & regMask); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void BIT_skipBits(BIT_DStream_t* bitD, uint nbBits) + { + bitD->bitsConsumed += nbBits; + } + + /*! BIT_readBits() : + * Read (consume) next n bits from local register and update. + * Pay attention to not read more than nbBits contained into local register. + * @return : extracted value. */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_readBits(BIT_DStream_t* bitD, uint nbBits) + { + nuint value = BIT_lookBits(bitD, nbBits); + BIT_skipBits(bitD, nbBits); + return value; + } + + /*! BIT_readBitsFast() : + * unsafe version; only works if nbBits >= 1 */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_readBitsFast(BIT_DStream_t* bitD, uint nbBits) + { + nuint value = BIT_lookBitsFast(bitD, nbBits); + assert(nbBits >= 1); + BIT_skipBits(bitD, nbBits); + return value; + } + + /*! BIT_reloadDStream_internal() : + * Simple variant of BIT_reloadDStream(), with two conditions: + * 1. bitstream is valid : bitsConsumed <= sizeof(bitD->bitContainer)*8 + * 2. look window is valid after shifted down : bitD->ptr >= bitD->start + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static BIT_DStream_status BIT_reloadDStream_internal(BIT_DStream_t* bitD) + { + assert(bitD->bitsConsumed <= (uint)(sizeof(nuint) * 8)); + bitD->ptr -= bitD->bitsConsumed >> 3; + assert(bitD->ptr >= bitD->start); + bitD->bitsConsumed &= 7; + bitD->bitContainer = MEM_readLEST(bitD->ptr); + return BIT_DStream_status.BIT_DStream_unfinished; + } + + /*! BIT_reloadDStreamFast() : + * Similar to BIT_reloadDStream(), but with two differences: + * 1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold! + * 2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this + * point you must use BIT_reloadDStream() to reload. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t* bitD) + { + if (bitD->ptr < bitD->limitPtr) + return BIT_DStream_status.BIT_DStream_overflow; + return BIT_reloadDStream_internal(bitD); + } + +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_static_zeroFilled => + new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }; + private static nuint* static_zeroFilled => + (nuint*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_static_zeroFilled) + ); +#else + + private static readonly nuint* static_zeroFilled = (nuint*)GetArrayPointer( + new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 } + ); +#endif + /*! BIT_reloadDStream() : + * Refill `bitD` from buffer previously set in BIT_initDStream() . + * This function is safe, it guarantees it will not never beyond src buffer. + * @return : status of `BIT_DStream_t` internal register. + * when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD) + { + if (bitD->bitsConsumed > (uint)(sizeof(nuint) * 8)) + { + bitD->ptr = (sbyte*)&static_zeroFilled[0]; + return BIT_DStream_status.BIT_DStream_overflow; + } + + assert(bitD->ptr >= bitD->start); + if (bitD->ptr >= bitD->limitPtr) + { + return BIT_reloadDStream_internal(bitD); + } + + if (bitD->ptr == bitD->start) + { + if (bitD->bitsConsumed < (uint)(sizeof(nuint) * 8)) + return BIT_DStream_status.BIT_DStream_endOfBuffer; + return BIT_DStream_status.BIT_DStream_completed; + } + + { + uint nbBytes = bitD->bitsConsumed >> 3; + BIT_DStream_status result = BIT_DStream_status.BIT_DStream_unfinished; + if (bitD->ptr - nbBytes < bitD->start) + { + nbBytes = (uint)(bitD->ptr - bitD->start); + result = BIT_DStream_status.BIT_DStream_endOfBuffer; + } + + bitD->ptr -= nbBytes; + bitD->bitsConsumed -= nbBytes * 8; + bitD->bitContainer = MEM_readLEST(bitD->ptr); + return result; + } + } + + /*! BIT_endOfDStream() : + * @return : 1 if DStream has _exactly_ reached its end (all bits consumed). + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint BIT_endOfDStream(BIT_DStream_t* DStream) + { + return DStream->ptr == DStream->start && DStream->bitsConsumed == (uint)(sizeof(nuint) * 8) + ? 1U + : 0U; + } + + /*-******************************************************** + * bitStream decoding + **********************************************************/ + /*! BIT_initDStream() : + * Initialize a BIT_DStream_t. + * `bitD` : a pointer to an already allocated BIT_DStream_t structure. + * `srcSize` must be the *exact* size of the bitStream, in bytes. + * @return : size of stream (== srcSize), or an errorCode if a problem is detected + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_initDStream(ref BIT_DStream_t bitD, void* srcBuffer, nuint srcSize) + { + if (srcSize < 1) + { + bitD = new BIT_DStream_t(); + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + bitD.start = (sbyte*)srcBuffer; + bitD.limitPtr = bitD.start + sizeof(nuint); + if (srcSize >= (nuint)sizeof(nuint)) + { + bitD.ptr = (sbyte*)srcBuffer + srcSize - sizeof(nuint); + bitD.bitContainer = MEM_readLEST(bitD.ptr); + { + byte lastByte = ((byte*)srcBuffer)[srcSize - 1]; + bitD.bitsConsumed = lastByte != 0 ? 8 - ZSTD_highbit32(lastByte) : 0; + if (lastByte == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + } + else + { + bitD.ptr = bitD.start; + bitD.bitContainer = *(byte*)bitD.start; + switch (srcSize) + { + case 7: + bitD.bitContainer += (nuint)((byte*)srcBuffer)[6] << sizeof(nuint) * 8 - 16; + goto case 6; + case 6: + bitD.bitContainer += (nuint)((byte*)srcBuffer)[5] << sizeof(nuint) * 8 - 24; + goto case 5; + case 5: + bitD.bitContainer += (nuint)((byte*)srcBuffer)[4] << sizeof(nuint) * 8 - 32; + goto case 4; + case 4: + bitD.bitContainer += (nuint)((byte*)srcBuffer)[3] << 24; + goto case 3; + case 3: + bitD.bitContainer += (nuint)((byte*)srcBuffer)[2] << 16; + goto case 2; + case 2: + bitD.bitContainer += (nuint)((byte*)srcBuffer)[1] << 8; + goto default; + default: + break; + } + + { + byte lastByte = ((byte*)srcBuffer)[srcSize - 1]; + bitD.bitsConsumed = lastByte != 0 ? 8 - ZSTD_highbit32(lastByte) : 0; + if (lastByte == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + bitD.bitsConsumed += (uint)((nuint)sizeof(nuint) - srcSize) * 8; + } + + return srcSize; + } + + /*! BIT_lookBits() : + * Provides next n bits from local register. + * local register is not modified. + * On 32-bits, maxNbBits==24. + * On 64-bits, maxNbBits==56. + * @return : value extracted */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_lookBits(nuint bitD_bitContainer, uint bitD_bitsConsumed, uint nbBits) + { + return BIT_getMiddleBits( + bitD_bitContainer, + (uint)(sizeof(nuint) * 8) - bitD_bitsConsumed - nbBits, + nbBits + ); + } + + /*! BIT_lookBitsFast() : + * unsafe version; only works if nbBits >= 1 */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_lookBitsFast( + nuint bitD_bitContainer, + uint bitD_bitsConsumed, + uint nbBits + ) + { + uint regMask = (uint)(sizeof(nuint) * 8 - 1); + assert(nbBits >= 1); + return bitD_bitContainer + << (int)(bitD_bitsConsumed & regMask) + >> (int)(regMask + 1 - nbBits & regMask); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void BIT_skipBits(ref uint bitD_bitsConsumed, uint nbBits) + { + bitD_bitsConsumed += nbBits; + } + + /*! BIT_readBits() : + * Read (consume) next n bits from local register and update. + * Pay attention to not read more than nbBits contained into local register. + * @return : extracted value. */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_readBits( + nuint bitD_bitContainer, + ref uint bitD_bitsConsumed, + uint nbBits + ) + { + nuint value = BIT_lookBits(bitD_bitContainer, bitD_bitsConsumed, nbBits); + BIT_skipBits(ref bitD_bitsConsumed, nbBits); + return value; + } + + /*! BIT_readBitsFast() : + * unsafe version; only works if nbBits >= 1 */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint BIT_readBitsFast( + nuint bitD_bitContainer, + ref uint bitD_bitsConsumed, + uint nbBits + ) + { + nuint value = BIT_lookBitsFast(bitD_bitContainer, bitD_bitsConsumed, nbBits); + assert(nbBits >= 1); + BIT_skipBits(ref bitD_bitsConsumed, nbBits); + return value; + } + + /*! BIT_reloadDStreamFast() : + * Similar to BIT_reloadDStream(), but with two differences: + * 1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold! + * 2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this + * point you must use BIT_reloadDStream() to reload. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static BIT_DStream_status BIT_reloadDStreamFast( + ref nuint bitD_bitContainer, + ref uint bitD_bitsConsumed, + ref sbyte* bitD_ptr, + sbyte* bitD_start, + sbyte* bitD_limitPtr + ) + { + if (bitD_ptr < bitD_limitPtr) + return BIT_DStream_status.BIT_DStream_overflow; + return BIT_reloadDStream_internal( + ref bitD_bitContainer, + ref bitD_bitsConsumed, + ref bitD_ptr, + bitD_start + ); + } + + /*! BIT_reloadDStream() : + * Refill `bitD` from buffer previously set in BIT_initDStream() . + * This function is safe, it guarantees it will not never beyond src buffer. + * @return : status of `BIT_DStream_t` internal register. + * when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static BIT_DStream_status BIT_reloadDStream( + ref nuint bitD_bitContainer, + ref uint bitD_bitsConsumed, + ref sbyte* bitD_ptr, + sbyte* bitD_start, + sbyte* bitD_limitPtr + ) + { + if (bitD_bitsConsumed > (uint)(sizeof(nuint) * 8)) + { + bitD_ptr = (sbyte*)&static_zeroFilled[0]; + return BIT_DStream_status.BIT_DStream_overflow; + } + + assert(bitD_ptr >= bitD_start); + if (bitD_ptr >= bitD_limitPtr) + { + return BIT_reloadDStream_internal( + ref bitD_bitContainer, + ref bitD_bitsConsumed, + ref bitD_ptr, + bitD_start + ); + } + + if (bitD_ptr == bitD_start) + { + if (bitD_bitsConsumed < (uint)(sizeof(nuint) * 8)) + return BIT_DStream_status.BIT_DStream_endOfBuffer; + return BIT_DStream_status.BIT_DStream_completed; + } + + { + uint nbBytes = bitD_bitsConsumed >> 3; + BIT_DStream_status result = BIT_DStream_status.BIT_DStream_unfinished; + if (bitD_ptr - nbBytes < bitD_start) + { + nbBytes = (uint)(bitD_ptr - bitD_start); + result = BIT_DStream_status.BIT_DStream_endOfBuffer; + } + + bitD_ptr -= nbBytes; + bitD_bitsConsumed -= nbBytes * 8; + bitD_bitContainer = MEM_readLEST(bitD_ptr); + return result; + } + } + + /*! BIT_reloadDStream_internal() : + * Simple variant of BIT_reloadDStream(), with two conditions: + * 1. bitstream is valid : bitsConsumed <= sizeof(bitD->bitContainer)*8 + * 2. look window is valid after shifted down : bitD->ptr >= bitD->start + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static BIT_DStream_status BIT_reloadDStream_internal( + ref nuint bitD_bitContainer, + ref uint bitD_bitsConsumed, + ref sbyte* bitD_ptr, + sbyte* bitD_start + ) + { + assert(bitD_bitsConsumed <= (uint)(sizeof(nuint) * 8)); + bitD_ptr -= bitD_bitsConsumed >> 3; + assert(bitD_ptr >= bitD_start); + bitD_bitsConsumed &= 7; + bitD_bitContainer = MEM_readLEST(bitD_ptr); + return BIT_DStream_status.BIT_DStream_unfinished; + } + + /*! BIT_endOfDStream() : + * @return : 1 if DStream has _exactly_ reached its end (all bits consumed). + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint BIT_endOfDStream( + uint DStream_bitsConsumed, + sbyte* DStream_ptr, + sbyte* DStream_start + ) + { + return DStream_ptr == DStream_start && DStream_bitsConsumed == (uint)(sizeof(nuint) * 8) + ? 1U + : 0U; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/BlockSummary.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/BlockSummary.cs new file mode 100644 index 000000000..9a53651dd --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/BlockSummary.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct BlockSummary +{ + public nuint nbSequences; + public nuint blockSize; + public nuint litSize; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_best_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_best_s.cs new file mode 100644 index 000000000..380831328 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_best_s.cs @@ -0,0 +1,20 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + * COVER_best_t is used for two purposes: + * 1. Synchronizing threads. + * 2. Saving the best parameters and dictionary. + * + * All of the methods except COVER_best_init() are thread safe if zstd is + * compiled with multithreaded support. + */ +public unsafe struct COVER_best_s +{ + public void* mutex; + public void* cond; + public nuint liveJobs; + public void* dict; + public nuint dictSize; + public ZDICT_cover_params_t parameters; + public nuint compressedSize; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_ctx_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_ctx_t.cs new file mode 100644 index 000000000..287127621 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_ctx_t.cs @@ -0,0 +1,19 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*-************************************* + * Context + ***************************************/ +public unsafe struct COVER_ctx_t +{ + public byte* samples; + public nuint* offsets; + public nuint* samplesSizes; + public nuint nbSamples; + public nuint nbTrainSamples; + public nuint nbTestSamples; + public uint* suffix; + public nuint suffixSize; + public uint* freqs; + public uint* dmerAt; + public uint d; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_dictSelection.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_dictSelection.cs new file mode 100644 index 000000000..f88d1e674 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_dictSelection.cs @@ -0,0 +1,11 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + * Struct used for the dictionary selection function. + */ +public unsafe struct COVER_dictSelection +{ + public byte* dictContent; + public nuint dictSize; + public nuint totalCompressedSize; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_epoch_info_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_epoch_info_t.cs new file mode 100644 index 000000000..dbb298909 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_epoch_info_t.cs @@ -0,0 +1,10 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + *Number of epochs and size of each epoch. + */ +public struct COVER_epoch_info_t +{ + public uint num; + public uint size; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_map_pair_t_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_map_pair_t_s.cs new file mode 100644 index 000000000..502f33b0c --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_map_pair_t_s.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct COVER_map_pair_t_s +{ + public uint key; + public uint value; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_map_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_map_s.cs new file mode 100644 index 000000000..dbfa337f6 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_map_s.cs @@ -0,0 +1,9 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct COVER_map_s +{ + public COVER_map_pair_t_s* data; + public uint sizeLog; + public uint size; + public uint sizeMask; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_segment_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_segment_t.cs new file mode 100644 index 000000000..7e852ea9c --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_segment_t.cs @@ -0,0 +1,11 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + * A segment is a range in the source as well as the score of the segment. + */ +public struct COVER_segment_t +{ + public uint begin; + public uint end; + public uint score; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_tryParameters_data_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_tryParameters_data_s.cs new file mode 100644 index 000000000..789ca9dc6 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/COVER_tryParameters_data_s.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + * Parameters for COVER_tryParameters(). + */ +public unsafe struct COVER_tryParameters_data_s +{ + public COVER_ctx_t* ctx; + public COVER_best_s* best; + public nuint dictBufferCapacity; + public ZDICT_cover_params_t parameters; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Clevels.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Clevels.cs new file mode 100644 index 000000000..9b3e78394 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Clevels.cs @@ -0,0 +1,849 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + private static readonly ZSTD_compressionParameters[][] ZSTD_defaultCParameters = + new ZSTD_compressionParameters[4][] + { + new ZSTD_compressionParameters[23] + { + new ZSTD_compressionParameters( + windowLog: 19, + chainLog: 12, + hashLog: 13, + searchLog: 1, + minMatch: 6, + targetLength: 1, + strategy: ZSTD_strategy.ZSTD_fast + ), + new ZSTD_compressionParameters( + windowLog: 19, + chainLog: 13, + hashLog: 14, + searchLog: 1, + minMatch: 7, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_fast + ), + new ZSTD_compressionParameters( + windowLog: 20, + chainLog: 15, + hashLog: 16, + searchLog: 1, + minMatch: 6, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_fast + ), + new ZSTD_compressionParameters( + windowLog: 21, + chainLog: 16, + hashLog: 17, + searchLog: 1, + minMatch: 5, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_dfast + ), + new ZSTD_compressionParameters( + windowLog: 21, + chainLog: 18, + hashLog: 18, + searchLog: 1, + minMatch: 5, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_dfast + ), + new ZSTD_compressionParameters( + windowLog: 21, + chainLog: 18, + hashLog: 19, + searchLog: 3, + minMatch: 5, + targetLength: 2, + strategy: ZSTD_strategy.ZSTD_greedy + ), + new ZSTD_compressionParameters( + windowLog: 21, + chainLog: 18, + hashLog: 19, + searchLog: 3, + minMatch: 5, + targetLength: 4, + strategy: ZSTD_strategy.ZSTD_lazy + ), + new ZSTD_compressionParameters( + windowLog: 21, + chainLog: 19, + hashLog: 20, + searchLog: 4, + minMatch: 5, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_lazy + ), + new ZSTD_compressionParameters( + windowLog: 21, + chainLog: 19, + hashLog: 20, + searchLog: 4, + minMatch: 5, + targetLength: 16, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 22, + chainLog: 20, + hashLog: 21, + searchLog: 4, + minMatch: 5, + targetLength: 16, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 22, + chainLog: 21, + hashLog: 22, + searchLog: 5, + minMatch: 5, + targetLength: 16, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 22, + chainLog: 21, + hashLog: 22, + searchLog: 6, + minMatch: 5, + targetLength: 16, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 22, + chainLog: 22, + hashLog: 23, + searchLog: 6, + minMatch: 5, + targetLength: 32, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 22, + chainLog: 22, + hashLog: 22, + searchLog: 4, + minMatch: 5, + targetLength: 32, + strategy: ZSTD_strategy.ZSTD_btlazy2 + ), + new ZSTD_compressionParameters( + windowLog: 22, + chainLog: 22, + hashLog: 23, + searchLog: 5, + minMatch: 5, + targetLength: 32, + strategy: ZSTD_strategy.ZSTD_btlazy2 + ), + new ZSTD_compressionParameters( + windowLog: 22, + chainLog: 23, + hashLog: 23, + searchLog: 6, + minMatch: 5, + targetLength: 32, + strategy: ZSTD_strategy.ZSTD_btlazy2 + ), + new ZSTD_compressionParameters( + windowLog: 22, + chainLog: 22, + hashLog: 22, + searchLog: 5, + minMatch: 5, + targetLength: 48, + strategy: ZSTD_strategy.ZSTD_btopt + ), + new ZSTD_compressionParameters( + windowLog: 23, + chainLog: 23, + hashLog: 22, + searchLog: 5, + minMatch: 4, + targetLength: 64, + strategy: ZSTD_strategy.ZSTD_btopt + ), + new ZSTD_compressionParameters( + windowLog: 23, + chainLog: 23, + hashLog: 22, + searchLog: 6, + minMatch: 3, + targetLength: 64, + strategy: ZSTD_strategy.ZSTD_btultra + ), + new ZSTD_compressionParameters( + windowLog: 23, + chainLog: 24, + hashLog: 22, + searchLog: 7, + minMatch: 3, + targetLength: 256, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 25, + chainLog: 25, + hashLog: 23, + searchLog: 7, + minMatch: 3, + targetLength: 256, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 26, + chainLog: 26, + hashLog: 24, + searchLog: 7, + minMatch: 3, + targetLength: 512, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 27, + chainLog: 27, + hashLog: 25, + searchLog: 9, + minMatch: 3, + targetLength: 999, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + }, + new ZSTD_compressionParameters[23] + { + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 12, + hashLog: 13, + searchLog: 1, + minMatch: 5, + targetLength: 1, + strategy: ZSTD_strategy.ZSTD_fast + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 13, + hashLog: 14, + searchLog: 1, + minMatch: 6, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_fast + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 14, + hashLog: 14, + searchLog: 1, + minMatch: 5, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_dfast + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 16, + hashLog: 16, + searchLog: 1, + minMatch: 4, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_dfast + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 16, + hashLog: 17, + searchLog: 3, + minMatch: 5, + targetLength: 2, + strategy: ZSTD_strategy.ZSTD_greedy + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 17, + hashLog: 18, + searchLog: 5, + minMatch: 5, + targetLength: 2, + strategy: ZSTD_strategy.ZSTD_greedy + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 18, + hashLog: 19, + searchLog: 3, + minMatch: 5, + targetLength: 4, + strategy: ZSTD_strategy.ZSTD_lazy + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 18, + hashLog: 19, + searchLog: 4, + minMatch: 4, + targetLength: 4, + strategy: ZSTD_strategy.ZSTD_lazy + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 18, + hashLog: 19, + searchLog: 4, + minMatch: 4, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 18, + hashLog: 19, + searchLog: 5, + minMatch: 4, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 18, + hashLog: 19, + searchLog: 6, + minMatch: 4, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 18, + hashLog: 19, + searchLog: 5, + minMatch: 4, + targetLength: 12, + strategy: ZSTD_strategy.ZSTD_btlazy2 + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 19, + hashLog: 19, + searchLog: 7, + minMatch: 4, + targetLength: 12, + strategy: ZSTD_strategy.ZSTD_btlazy2 + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 18, + hashLog: 19, + searchLog: 4, + minMatch: 4, + targetLength: 16, + strategy: ZSTD_strategy.ZSTD_btopt + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 18, + hashLog: 19, + searchLog: 4, + minMatch: 3, + targetLength: 32, + strategy: ZSTD_strategy.ZSTD_btopt + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 18, + hashLog: 19, + searchLog: 6, + minMatch: 3, + targetLength: 128, + strategy: ZSTD_strategy.ZSTD_btopt + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 19, + hashLog: 19, + searchLog: 6, + minMatch: 3, + targetLength: 128, + strategy: ZSTD_strategy.ZSTD_btultra + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 19, + hashLog: 19, + searchLog: 8, + minMatch: 3, + targetLength: 256, + strategy: ZSTD_strategy.ZSTD_btultra + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 19, + hashLog: 19, + searchLog: 6, + minMatch: 3, + targetLength: 128, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 19, + hashLog: 19, + searchLog: 8, + minMatch: 3, + targetLength: 256, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 19, + hashLog: 19, + searchLog: 10, + minMatch: 3, + targetLength: 512, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 19, + hashLog: 19, + searchLog: 12, + minMatch: 3, + targetLength: 512, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 18, + chainLog: 19, + hashLog: 19, + searchLog: 13, + minMatch: 3, + targetLength: 999, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + }, + new ZSTD_compressionParameters[23] + { + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 12, + hashLog: 12, + searchLog: 1, + minMatch: 5, + targetLength: 1, + strategy: ZSTD_strategy.ZSTD_fast + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 12, + hashLog: 13, + searchLog: 1, + minMatch: 6, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_fast + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 13, + hashLog: 15, + searchLog: 1, + minMatch: 5, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_fast + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 15, + hashLog: 16, + searchLog: 2, + minMatch: 5, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_dfast + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 17, + hashLog: 17, + searchLog: 2, + minMatch: 4, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_dfast + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 16, + hashLog: 17, + searchLog: 3, + minMatch: 4, + targetLength: 2, + strategy: ZSTD_strategy.ZSTD_greedy + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 16, + hashLog: 17, + searchLog: 3, + minMatch: 4, + targetLength: 4, + strategy: ZSTD_strategy.ZSTD_lazy + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 16, + hashLog: 17, + searchLog: 3, + minMatch: 4, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 16, + hashLog: 17, + searchLog: 4, + minMatch: 4, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 16, + hashLog: 17, + searchLog: 5, + minMatch: 4, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 16, + hashLog: 17, + searchLog: 6, + minMatch: 4, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 17, + hashLog: 17, + searchLog: 5, + minMatch: 4, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_btlazy2 + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 18, + hashLog: 17, + searchLog: 7, + minMatch: 4, + targetLength: 12, + strategy: ZSTD_strategy.ZSTD_btlazy2 + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 18, + hashLog: 17, + searchLog: 3, + minMatch: 4, + targetLength: 12, + strategy: ZSTD_strategy.ZSTD_btopt + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 18, + hashLog: 17, + searchLog: 4, + minMatch: 3, + targetLength: 32, + strategy: ZSTD_strategy.ZSTD_btopt + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 18, + hashLog: 17, + searchLog: 6, + minMatch: 3, + targetLength: 256, + strategy: ZSTD_strategy.ZSTD_btopt + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 18, + hashLog: 17, + searchLog: 6, + minMatch: 3, + targetLength: 128, + strategy: ZSTD_strategy.ZSTD_btultra + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 18, + hashLog: 17, + searchLog: 8, + minMatch: 3, + targetLength: 256, + strategy: ZSTD_strategy.ZSTD_btultra + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 18, + hashLog: 17, + searchLog: 10, + minMatch: 3, + targetLength: 512, + strategy: ZSTD_strategy.ZSTD_btultra + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 18, + hashLog: 17, + searchLog: 5, + minMatch: 3, + targetLength: 256, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 18, + hashLog: 17, + searchLog: 7, + minMatch: 3, + targetLength: 512, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 18, + hashLog: 17, + searchLog: 9, + minMatch: 3, + targetLength: 512, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 17, + chainLog: 18, + hashLog: 17, + searchLog: 11, + minMatch: 3, + targetLength: 999, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + }, + new ZSTD_compressionParameters[23] + { + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 12, + hashLog: 13, + searchLog: 1, + minMatch: 5, + targetLength: 1, + strategy: ZSTD_strategy.ZSTD_fast + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 14, + hashLog: 15, + searchLog: 1, + minMatch: 5, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_fast + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 14, + hashLog: 15, + searchLog: 1, + minMatch: 4, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_fast + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 14, + hashLog: 15, + searchLog: 2, + minMatch: 4, + targetLength: 0, + strategy: ZSTD_strategy.ZSTD_dfast + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 14, + hashLog: 14, + searchLog: 4, + minMatch: 4, + targetLength: 2, + strategy: ZSTD_strategy.ZSTD_greedy + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 14, + hashLog: 14, + searchLog: 3, + minMatch: 4, + targetLength: 4, + strategy: ZSTD_strategy.ZSTD_lazy + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 14, + hashLog: 14, + searchLog: 4, + minMatch: 4, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 14, + hashLog: 14, + searchLog: 6, + minMatch: 4, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 14, + hashLog: 14, + searchLog: 8, + minMatch: 4, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_lazy2 + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 14, + searchLog: 5, + minMatch: 4, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_btlazy2 + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 14, + searchLog: 9, + minMatch: 4, + targetLength: 8, + strategy: ZSTD_strategy.ZSTD_btlazy2 + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 14, + searchLog: 3, + minMatch: 4, + targetLength: 12, + strategy: ZSTD_strategy.ZSTD_btopt + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 14, + searchLog: 4, + minMatch: 3, + targetLength: 24, + strategy: ZSTD_strategy.ZSTD_btopt + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 14, + searchLog: 5, + minMatch: 3, + targetLength: 32, + strategy: ZSTD_strategy.ZSTD_btultra + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 15, + searchLog: 6, + minMatch: 3, + targetLength: 64, + strategy: ZSTD_strategy.ZSTD_btultra + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 15, + searchLog: 7, + minMatch: 3, + targetLength: 256, + strategy: ZSTD_strategy.ZSTD_btultra + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 15, + searchLog: 5, + minMatch: 3, + targetLength: 48, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 15, + searchLog: 6, + minMatch: 3, + targetLength: 128, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 15, + searchLog: 7, + minMatch: 3, + targetLength: 256, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 15, + searchLog: 8, + minMatch: 3, + targetLength: 256, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 15, + searchLog: 8, + minMatch: 3, + targetLength: 512, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 15, + searchLog: 9, + minMatch: 3, + targetLength: 512, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + new ZSTD_compressionParameters( + windowLog: 14, + chainLog: 15, + hashLog: 15, + searchLog: 10, + minMatch: 3, + targetLength: 999, + strategy: ZSTD_strategy.ZSTD_btultra2 + ), + }, + }; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Compiler.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Compiler.cs new file mode 100644 index 000000000..97fead59d --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Compiler.cs @@ -0,0 +1,61 @@ +using System.Runtime.CompilerServices; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /* @return 1 if @u is a 2^n value, 0 otherwise + * useful to check a value is valid for alignment restrictions */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_isPower2(nuint u) + { + return (u & u - 1) == 0 ? 1 : 0; + } + + /** + * Helper function to perform a wrapped pointer difference without triggering + * UBSAN. + * + * @returns lhs - rhs with wrapping + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nint ZSTD_wrappedPtrDiff(byte* lhs, byte* rhs) + { + return (nint)(lhs - rhs); + } + + /** + * Helper function to perform a wrapped pointer add without triggering UBSAN. + * + * @return ptr + add with wrapping + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static byte* ZSTD_wrappedPtrAdd(byte* ptr, nint add) + { + return ptr + add; + } + + /** + * Helper function to perform a wrapped pointer subtraction without triggering + * UBSAN. + * + * @return ptr - sub with wrapping + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static byte* ZSTD_wrappedPtrSub(byte* ptr, nint sub) + { + return ptr - sub; + } + + /** + * Helper function to add to a pointer that works around C's undefined behavior + * of adding 0 to NULL. + * + * @returns `ptr + add` except it defines `NULL + 0 == NULL`. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static byte* ZSTD_maybeNullPtrAdd(byte* ptr, nint add) + { + return add > 0 ? ptr + add : ptr; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Cover.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Cover.cs new file mode 100644 index 000000000..11c79f3c6 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Cover.cs @@ -0,0 +1,444 @@ +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + private static int g_displayLevel = 0; + + /** + * Returns the sum of the sample sizes. + */ + private static nuint COVER_sum(nuint* samplesSizes, uint nbSamples) + { + nuint sum = 0; + uint i; + for (i = 0; i < nbSamples; ++i) + { + sum += samplesSizes[i]; + } + + return sum; + } + + /** + * Warns the user when their corpus is too small. + */ + private static void COVER_warnOnSmallCorpus(nuint maxDictSize, nuint nbDmers, int displayLevel) + { + double ratio = nbDmers / (double)maxDictSize; + if (ratio >= 10) + { + return; + } + } + + /** + * Computes the number of epochs and the size of each epoch. + * We will make sure that each epoch gets at least 10 * k bytes. + * + * The COVER algorithms divide the data up into epochs of equal size and + * select one segment from each epoch. + * + * @param maxDictSize The maximum allowed dictionary size. + * @param nbDmers The number of dmers we are training on. + * @param k The parameter k (segment size). + * @param passes The target number of passes over the dmer corpus. + * More passes means a better dictionary. + */ + private static COVER_epoch_info_t COVER_computeEpochs( + uint maxDictSize, + uint nbDmers, + uint k, + uint passes + ) + { + uint minEpochSize = k * 10; + COVER_epoch_info_t epochs; + epochs.num = 1 > maxDictSize / k / passes ? 1 : maxDictSize / k / passes; + epochs.size = nbDmers / epochs.num; + if (epochs.size >= minEpochSize) + { + assert(epochs.size * epochs.num <= nbDmers); + return epochs; + } + + epochs.size = minEpochSize < nbDmers ? minEpochSize : nbDmers; + epochs.num = nbDmers / epochs.size; + assert(epochs.size * epochs.num <= nbDmers); + return epochs; + } + + /** + * Checks total compressed size of a dictionary + */ + private static nuint COVER_checkTotalCompressedSize( + ZDICT_cover_params_t parameters, + nuint* samplesSizes, + byte* samples, + nuint* offsets, + nuint nbTrainSamples, + nuint nbSamples, + byte* dict, + nuint dictBufferCapacity + ) + { + nuint totalCompressedSize = unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + /* Pointers */ + ZSTD_CCtx_s* cctx; + ZSTD_CDict_s* cdict; + void* dst; + /* Local variables */ + nuint dstCapacity; + nuint i; + { + nuint maxSampleSize = 0; + i = parameters.splitPoint < 1 ? nbTrainSamples : 0; + for (; i < nbSamples; ++i) + { + maxSampleSize = samplesSizes[i] > maxSampleSize ? samplesSizes[i] : maxSampleSize; + } + + dstCapacity = ZSTD_compressBound(maxSampleSize); + dst = malloc(dstCapacity); + } + + cctx = ZSTD_createCCtx(); + cdict = ZSTD_createCDict(dict, dictBufferCapacity, parameters.zParams.compressionLevel); + if (dst == null || cctx == null || cdict == null) + { + goto _compressCleanup; + } + + totalCompressedSize = dictBufferCapacity; + i = parameters.splitPoint < 1 ? nbTrainSamples : 0; + for (; i < nbSamples; ++i) + { + nuint size = ZSTD_compress_usingCDict( + cctx, + dst, + dstCapacity, + samples + offsets[i], + samplesSizes[i], + cdict + ); + if (ERR_isError(size)) + { + totalCompressedSize = size; + goto _compressCleanup; + } + + totalCompressedSize += size; + } + + _compressCleanup: + ZSTD_freeCCtx(cctx); + ZSTD_freeCDict(cdict); + if (dst != null) + { + free(dst); + } + + return totalCompressedSize; + } + + /** + * Initialize the `COVER_best_t`. + */ + private static void COVER_best_init(COVER_best_s* best) + { + if (best == null) + return; + SynchronizationWrapper.Init(&best->mutex); + best->liveJobs = 0; + best->dict = null; + best->dictSize = 0; + best->compressedSize = unchecked((nuint)(-1)); + best->parameters = new ZDICT_cover_params_t(); + } + + /** + * Wait until liveJobs == 0. + */ + private static void COVER_best_wait(COVER_best_s* best) + { + if (best == null) + { + return; + } + + SynchronizationWrapper.Enter(&best->mutex); + while (best->liveJobs != 0) + { + SynchronizationWrapper.Wait(&best->mutex); + } + + SynchronizationWrapper.Exit(&best->mutex); + } + + /** + * Call COVER_best_wait() and then destroy the COVER_best_t. + */ + private static void COVER_best_destroy(COVER_best_s* best) + { + if (best == null) + { + return; + } + + COVER_best_wait(best); + if (best->dict != null) + { + free(best->dict); + } + + SynchronizationWrapper.Free(&best->mutex); + } + + /** + * Called when a thread is about to be launched. + * Increments liveJobs. + */ + private static void COVER_best_start(COVER_best_s* best) + { + if (best == null) + { + return; + } + + SynchronizationWrapper.Enter(&best->mutex); + ++best->liveJobs; + SynchronizationWrapper.Exit(&best->mutex); + } + + /** + * Called when a thread finishes executing, both on error or success. + * Decrements liveJobs and signals any waiting threads if liveJobs == 0. + * If this dictionary is the best so far save it and its parameters. + */ + private static void COVER_best_finish( + COVER_best_s* best, + ZDICT_cover_params_t parameters, + COVER_dictSelection selection + ) + { + void* dict = selection.dictContent; + nuint compressedSize = selection.totalCompressedSize; + nuint dictSize = selection.dictSize; + if (best == null) + { + return; + } + + { + nuint liveJobs; + SynchronizationWrapper.Enter(&best->mutex); + --best->liveJobs; + liveJobs = best->liveJobs; + if (compressedSize < best->compressedSize) + { + if (best->dict == null || best->dictSize < dictSize) + { + if (best->dict != null) + { + free(best->dict); + } + + best->dict = malloc(dictSize); + if (best->dict == null) + { + best->compressedSize = unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC) + ); + best->dictSize = 0; + SynchronizationWrapper.Pulse(&best->mutex); + SynchronizationWrapper.Exit(&best->mutex); + return; + } + } + + if (dict != null) + { + memcpy(best->dict, dict, (uint)dictSize); + best->dictSize = dictSize; + best->parameters = parameters; + best->compressedSize = compressedSize; + } + } + + if (liveJobs == 0) + { + SynchronizationWrapper.PulseAll(&best->mutex); + } + + SynchronizationWrapper.Exit(&best->mutex); + } + } + + private static COVER_dictSelection setDictSelection(byte* buf, nuint s, nuint csz) + { + COVER_dictSelection ds; + ds.dictContent = buf; + ds.dictSize = s; + ds.totalCompressedSize = csz; + return ds; + } + + /** + * Error function for COVER_selectDict function. Returns a struct where + * return.totalCompressedSize is a ZSTD error. + */ + private static COVER_dictSelection COVER_dictSelectionError(nuint error) + { + return setDictSelection(null, 0, error); + } + + /** + * Error function for COVER_selectDict function. Checks if the return + * value is an error. + */ + private static uint COVER_dictSelectionIsError(COVER_dictSelection selection) + { + return ERR_isError(selection.totalCompressedSize) || selection.dictContent == null + ? 1U + : 0U; + } + + /** + * Always call after selectDict is called to free up used memory from + * newly created dictionary. + */ + private static void COVER_dictSelectionFree(COVER_dictSelection selection) + { + free(selection.dictContent); + } + + /** + * Called to finalize the dictionary and select one based on whether or not + * the shrink-dict flag was enabled. If enabled the dictionary used is the + * smallest dictionary within a specified regression of the compressed size + * from the largest dictionary. + */ + private static COVER_dictSelection COVER_selectDict( + byte* customDictContent, + nuint dictBufferCapacity, + nuint dictContentSize, + byte* samplesBuffer, + nuint* samplesSizes, + uint nbFinalizeSamples, + nuint nbCheckSamples, + nuint nbSamples, + ZDICT_cover_params_t @params, + nuint* offsets, + nuint totalCompressedSize + ) + { + nuint largestDict = 0; + nuint largestCompressed = 0; + byte* customDictContentEnd = customDictContent + dictContentSize; + byte* largestDictbuffer = (byte*)malloc(dictBufferCapacity); + byte* candidateDictBuffer = (byte*)malloc(dictBufferCapacity); + double regressionTolerance = (double)@params.shrinkDictMaxRegression / 100 + 1; + if (largestDictbuffer == null || candidateDictBuffer == null) + { + free(largestDictbuffer); + free(candidateDictBuffer); + return COVER_dictSelectionError(dictContentSize); + } + + memcpy(largestDictbuffer, customDictContent, (uint)dictContentSize); + dictContentSize = ZDICT_finalizeDictionary( + largestDictbuffer, + dictBufferCapacity, + customDictContent, + dictContentSize, + samplesBuffer, + samplesSizes, + nbFinalizeSamples, + @params.zParams + ); + if (ZDICT_isError(dictContentSize)) + { + free(largestDictbuffer); + free(candidateDictBuffer); + return COVER_dictSelectionError(dictContentSize); + } + + totalCompressedSize = COVER_checkTotalCompressedSize( + @params, + samplesSizes, + samplesBuffer, + offsets, + nbCheckSamples, + nbSamples, + largestDictbuffer, + dictContentSize + ); + if (ERR_isError(totalCompressedSize)) + { + free(largestDictbuffer); + free(candidateDictBuffer); + return COVER_dictSelectionError(totalCompressedSize); + } + + if (@params.shrinkDict == 0) + { + free(candidateDictBuffer); + return setDictSelection(largestDictbuffer, dictContentSize, totalCompressedSize); + } + + largestDict = dictContentSize; + largestCompressed = totalCompressedSize; + dictContentSize = 256; + while (dictContentSize < largestDict) + { + memcpy(candidateDictBuffer, largestDictbuffer, (uint)largestDict); + dictContentSize = ZDICT_finalizeDictionary( + candidateDictBuffer, + dictBufferCapacity, + customDictContentEnd - dictContentSize, + dictContentSize, + samplesBuffer, + samplesSizes, + nbFinalizeSamples, + @params.zParams + ); + if (ZDICT_isError(dictContentSize)) + { + free(largestDictbuffer); + free(candidateDictBuffer); + return COVER_dictSelectionError(dictContentSize); + } + + totalCompressedSize = COVER_checkTotalCompressedSize( + @params, + samplesSizes, + samplesBuffer, + offsets, + nbCheckSamples, + nbSamples, + candidateDictBuffer, + dictContentSize + ); + if (ERR_isError(totalCompressedSize)) + { + free(largestDictbuffer); + free(candidateDictBuffer); + return COVER_dictSelectionError(totalCompressedSize); + } + + if (totalCompressedSize <= largestCompressed * regressionTolerance) + { + free(largestDictbuffer); + return setDictSelection(candidateDictBuffer, dictContentSize, totalCompressedSize); + } + + dictContentSize *= 2; + } + + dictContentSize = largestDict; + totalCompressedSize = largestCompressed; + free(candidateDictBuffer); + return setDictSelection(largestDictbuffer, dictContentSize, totalCompressedSize); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/DTableDesc.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/DTableDesc.cs new file mode 100644 index 000000000..6586ac46f --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/DTableDesc.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*-***************************/ +/* generic DTableDesc */ +/*-***************************/ +public struct DTableDesc +{ + public byte maxTableLog; + public byte tableType; + public byte tableLog; + public byte reserved; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/EStats_ress_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/EStats_ress_t.cs new file mode 100644 index 000000000..9d3f1ba28 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/EStats_ress_t.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct EStats_ress_t +{ + /* dictionary */ + public ZSTD_CDict_s* dict; + + /* working context */ + public ZSTD_CCtx_s* zc; + + /* must be ZSTD_BLOCKSIZE_MAX allocated */ + public void* workPlace; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/EntropyCommon.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/EntropyCommon.cs new file mode 100644 index 000000000..e14f925f5 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/EntropyCommon.cs @@ -0,0 +1,447 @@ +using System.Runtime.CompilerServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /*=== Version ===*/ + private static uint FSE_versionNumber() + { + return 0 * 100 * 100 + 9 * 100 + 0; + } + + /*=== Error Management ===*/ + private static bool FSE_isError(nuint code) + { + return ERR_isError(code); + } + + private static string FSE_getErrorName(nuint code) + { + return ERR_getErrorName(code); + } + + /* Error Management */ + private static bool HUF_isError(nuint code) + { + return ERR_isError(code); + } + + private static string HUF_getErrorName(nuint code) + { + return ERR_getErrorName(code); + } + + /*-************************************************************** + * FSE NCount encoding-decoding + ****************************************************************/ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint FSE_readNCount_body( + short* normalizedCounter, + uint* maxSVPtr, + uint* tableLogPtr, + void* headerBuffer, + nuint hbSize + ) + { + byte* istart = (byte*)headerBuffer; + byte* iend = istart + hbSize; + byte* ip = istart; + int nbBits; + int remaining; + int threshold; + uint bitStream; + int bitCount; + uint charnum = 0; + uint maxSV1 = *maxSVPtr + 1; + int previous0 = 0; + if (hbSize < 8) + { + sbyte* buffer = stackalloc sbyte[8]; + /* This function only works when hbSize >= 8 */ + memset(buffer, 0, sizeof(sbyte) * 8); + memcpy(buffer, headerBuffer, (uint)hbSize); + { + nuint countSize = FSE_readNCount( + normalizedCounter, + maxSVPtr, + tableLogPtr, + buffer, + sizeof(sbyte) * 8 + ); + if (FSE_isError(countSize)) + return countSize; + if (countSize > hbSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + return countSize; + } + } + + assert(hbSize >= 8); + memset(normalizedCounter, 0, (*maxSVPtr + 1) * sizeof(short)); + bitStream = MEM_readLE32(ip); + nbBits = (int)((bitStream & 0xF) + 5); + if (nbBits > 15) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)); + bitStream >>= 4; + bitCount = 4; + *tableLogPtr = (uint)nbBits; + remaining = (1 << nbBits) + 1; + threshold = 1 << nbBits; + nbBits++; + for (; ; ) + { + if (previous0 != 0) + { + /* Count the number of repeats. Each time the + * 2-bit repeat code is 0b11 there is another + * repeat. + * Avoid UB by setting the high bit to 1. + */ + int repeats = (int)(ZSTD_countTrailingZeros32(~bitStream | 0x80000000) >> 1); + while (repeats >= 12) + { + charnum += 3 * 12; + if (ip <= iend - 7) + { + ip += 3; + } + else + { + bitCount -= (int)(8 * (iend - 7 - ip)); + bitCount &= 31; + ip = iend - 4; + } + + bitStream = MEM_readLE32(ip) >> bitCount; + repeats = (int)(ZSTD_countTrailingZeros32(~bitStream | 0x80000000) >> 1); + } + + charnum += (uint)(3 * repeats); + bitStream >>= 2 * repeats; + bitCount += 2 * repeats; + assert((bitStream & 3) < 3); + charnum += bitStream & 3; + bitCount += 2; + if (charnum >= maxSV1) + break; + if (ip <= iend - 7 || ip + (bitCount >> 3) <= iend - 4) + { + assert(bitCount >> 3 <= 3); + ip += bitCount >> 3; + bitCount &= 7; + } + else + { + bitCount -= (int)(8 * (iend - 4 - ip)); + bitCount &= 31; + ip = iend - 4; + } + + bitStream = MEM_readLE32(ip) >> bitCount; + } + + { + int max = 2 * threshold - 1 - remaining; + int count; + if ((bitStream & (uint)(threshold - 1)) < (uint)max) + { + count = (int)(bitStream & (uint)(threshold - 1)); + bitCount += nbBits - 1; + } + else + { + count = (int)(bitStream & (uint)(2 * threshold - 1)); + if (count >= threshold) + count -= max; + bitCount += nbBits; + } + + count--; + if (count >= 0) + { + remaining -= count; + } + else + { + assert(count == -1); + remaining += count; + } + + normalizedCounter[charnum++] = (short)count; + previous0 = count == 0 ? 1 : 0; + assert(threshold > 1); + if (remaining < threshold) + { + if (remaining <= 1) + break; + nbBits = (int)(ZSTD_highbit32((uint)remaining) + 1); + threshold = 1 << nbBits - 1; + } + + if (charnum >= maxSV1) + break; + if (ip <= iend - 7 || ip + (bitCount >> 3) <= iend - 4) + { + ip += bitCount >> 3; + bitCount &= 7; + } + else + { + bitCount -= (int)(8 * (iend - 4 - ip)); + bitCount &= 31; + ip = iend - 4; + } + + bitStream = MEM_readLE32(ip) >> bitCount; + } + } + + if (remaining != 1) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + if (charnum > maxSV1) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_maxSymbolValue_tooSmall)); + if (bitCount > 32) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + *maxSVPtr = charnum - 1; + ip += bitCount + 7 >> 3; + return (nuint)(ip - istart); + } + + /* Avoids the FORCE_INLINE of the _body() function. */ + private static nuint FSE_readNCount_body_default( + short* normalizedCounter, + uint* maxSVPtr, + uint* tableLogPtr, + void* headerBuffer, + nuint hbSize + ) + { + return FSE_readNCount_body(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize); + } + + /*! FSE_readNCount_bmi2(): + * Same as FSE_readNCount() but pass bmi2=1 when your CPU supports BMI2 and 0 otherwise. + */ + private static nuint FSE_readNCount_bmi2( + short* normalizedCounter, + uint* maxSVPtr, + uint* tableLogPtr, + void* headerBuffer, + nuint hbSize, + int bmi2 + ) + { + return FSE_readNCount_body_default( + normalizedCounter, + maxSVPtr, + tableLogPtr, + headerBuffer, + hbSize + ); + } + + /*! FSE_readNCount(): + Read compactly saved 'normalizedCounter' from 'rBuffer'. + @return : size read from 'rBuffer', + or an errorCode, which can be tested using FSE_isError(). + maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */ + private static nuint FSE_readNCount( + short* normalizedCounter, + uint* maxSVPtr, + uint* tableLogPtr, + void* headerBuffer, + nuint hbSize + ) + { + return FSE_readNCount_bmi2( + normalizedCounter, + maxSVPtr, + tableLogPtr, + headerBuffer, + hbSize, + 0 + ); + } + + /*! HUF_readStats() : + Read compact Huffman tree, saved by HUF_writeCTable(). + `huffWeight` is destination buffer. + `rankStats` is assumed to be a table of at least HUF_TABLELOG_MAX U32. + @return : size read from `src` , or an error Code . + Note : Needed by HUF_readCTable() and HUF_readDTableX?() . + */ + private static nuint HUF_readStats( + byte* huffWeight, + nuint hwSize, + uint* rankStats, + uint* nbSymbolsPtr, + uint* tableLogPtr, + void* src, + nuint srcSize + ) + { + uint* wksp = stackalloc uint[219]; + return HUF_readStats_wksp( + huffWeight, + hwSize, + rankStats, + nbSymbolsPtr, + tableLogPtr, + src, + srcSize, + wksp, + sizeof(uint) * 219, + 0 + ); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint HUF_readStats_body( + byte* huffWeight, + nuint hwSize, + uint* rankStats, + uint* nbSymbolsPtr, + uint* tableLogPtr, + void* src, + nuint srcSize, + void* workSpace, + nuint wkspSize, + int bmi2 + ) + { + uint weightTotal; + byte* ip = (byte*)src; + nuint iSize; + nuint oSize; + if (srcSize == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + iSize = ip[0]; + if (iSize >= 128) + { + oSize = iSize - 127; + iSize = (oSize + 1) / 2; + if (iSize + 1 > srcSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + if (oSize >= hwSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + ip += 1; + { + uint n; + for (n = 0; n < oSize; n += 2) + { + huffWeight[n] = (byte)(ip[n / 2] >> 4); + huffWeight[n + 1] = (byte)(ip[n / 2] & 15); + } + } + } + else + { + if (iSize + 1 > srcSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + oSize = FSE_decompress_wksp_bmi2( + huffWeight, + hwSize - 1, + ip + 1, + iSize, + 6, + workSpace, + wkspSize, + bmi2 + ); + if (FSE_isError(oSize)) + return oSize; + } + + memset(rankStats, 0, (12 + 1) * sizeof(uint)); + weightTotal = 0; + { + uint n; + for (n = 0; n < oSize; n++) + { + if (huffWeight[n] > 12) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + rankStats[huffWeight[n]]++; + weightTotal += (uint)(1 << huffWeight[n] >> 1); + } + } + + if (weightTotal == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + { + uint tableLog = ZSTD_highbit32(weightTotal) + 1; + if (tableLog > 12) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + *tableLogPtr = tableLog; + { + uint total = (uint)(1 << (int)tableLog); + uint rest = total - weightTotal; + uint verif = (uint)(1 << (int)ZSTD_highbit32(rest)); + uint lastWeight = ZSTD_highbit32(rest) + 1; + if (verif != rest) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + huffWeight[oSize] = (byte)lastWeight; + rankStats[lastWeight]++; + } + } + + if (rankStats[1] < 2 || (rankStats[1] & 1) != 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + *nbSymbolsPtr = (uint)(oSize + 1); + return iSize + 1; + } + + /* Avoids the FORCE_INLINE of the _body() function. */ + private static nuint HUF_readStats_body_default( + byte* huffWeight, + nuint hwSize, + uint* rankStats, + uint* nbSymbolsPtr, + uint* tableLogPtr, + void* src, + nuint srcSize, + void* workSpace, + nuint wkspSize + ) + { + return HUF_readStats_body( + huffWeight, + hwSize, + rankStats, + nbSymbolsPtr, + tableLogPtr, + src, + srcSize, + workSpace, + wkspSize, + 0 + ); + } + + private static nuint HUF_readStats_wksp( + byte* huffWeight, + nuint hwSize, + uint* rankStats, + uint* nbSymbolsPtr, + uint* tableLogPtr, + void* src, + nuint srcSize, + void* workSpace, + nuint wkspSize, + int flags + ) + { + return HUF_readStats_body_default( + huffWeight, + hwSize, + rankStats, + nbSymbolsPtr, + tableLogPtr, + src, + srcSize, + workSpace, + wkspSize + ); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ErrorPrivate.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ErrorPrivate.cs new file mode 100644 index 000000000..e211bda7d --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ErrorPrivate.cs @@ -0,0 +1,110 @@ +using System.Runtime.CompilerServices; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static bool ERR_isError(nuint code) + { + return code > unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_maxCode)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ZSTD_ErrorCode ERR_getErrorCode(nuint code) + { + if (!ERR_isError(code)) + return 0; + return (ZSTD_ErrorCode)(0 - code); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static string ERR_getErrorName(nuint code) + { + return ERR_getErrorString(ERR_getErrorCode(code)); + } + + /*-**************************************** + * Error Strings + ******************************************/ + private static string ERR_getErrorString(ZSTD_ErrorCode code) + { + const string notErrorCode = "Unspecified error code"; + switch (code) + { + case ZSTD_ErrorCode.ZSTD_error_no_error: + return "No error detected"; + case ZSTD_ErrorCode.ZSTD_error_GENERIC: + return "Error (generic)"; + case ZSTD_ErrorCode.ZSTD_error_prefix_unknown: + return "Unknown frame descriptor"; + case ZSTD_ErrorCode.ZSTD_error_version_unsupported: + return "Version not supported"; + case ZSTD_ErrorCode.ZSTD_error_frameParameter_unsupported: + return "Unsupported frame parameter"; + case ZSTD_ErrorCode.ZSTD_error_frameParameter_windowTooLarge: + return "Frame requires too much memory for decoding"; + case ZSTD_ErrorCode.ZSTD_error_corruption_detected: + return "Data corruption detected"; + case ZSTD_ErrorCode.ZSTD_error_checksum_wrong: + return "Restored data doesn't match checksum"; + case ZSTD_ErrorCode.ZSTD_error_literals_headerWrong: + return "Header of Literals' block doesn't respect format specification"; + case ZSTD_ErrorCode.ZSTD_error_parameter_unsupported: + return "Unsupported parameter"; + case ZSTD_ErrorCode.ZSTD_error_parameter_combination_unsupported: + return "Unsupported combination of parameters"; + case ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound: + return "Parameter is out of bound"; + case ZSTD_ErrorCode.ZSTD_error_init_missing: + return "Context should be init first"; + case ZSTD_ErrorCode.ZSTD_error_memory_allocation: + return "Allocation error : not enough memory"; + case ZSTD_ErrorCode.ZSTD_error_workSpace_tooSmall: + return "workSpace buffer is not large enough"; + case ZSTD_ErrorCode.ZSTD_error_stage_wrong: + return "Operation not authorized at current processing stage"; + case ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge: + return "tableLog requires too much memory : unsupported"; + case ZSTD_ErrorCode.ZSTD_error_maxSymbolValue_tooLarge: + return "Unsupported max Symbol Value : too large"; + case ZSTD_ErrorCode.ZSTD_error_maxSymbolValue_tooSmall: + return "Specified maxSymbolValue is too small"; + case ZSTD_ErrorCode.ZSTD_error_cannotProduce_uncompressedBlock: + return "This mode cannot generate an uncompressed block"; + case ZSTD_ErrorCode.ZSTD_error_stabilityCondition_notRespected: + return "pledged buffer stability condition is not respected"; + case ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted: + return "Dictionary is corrupted"; + case ZSTD_ErrorCode.ZSTD_error_dictionary_wrong: + return "Dictionary mismatch"; + case ZSTD_ErrorCode.ZSTD_error_dictionaryCreation_failed: + return "Cannot create Dictionary from provided samples"; + case ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall: + return "Destination buffer is too small"; + case ZSTD_ErrorCode.ZSTD_error_srcSize_wrong: + return "Src size is incorrect"; + case ZSTD_ErrorCode.ZSTD_error_dstBuffer_null: + return "Operation on NULL destination buffer"; + case ZSTD_ErrorCode.ZSTD_error_noForwardProgress_destFull: + return "Operation made no progress over multiple calls, due to output buffer being full"; + case ZSTD_ErrorCode.ZSTD_error_noForwardProgress_inputEmpty: + return "Operation made no progress over multiple calls, due to input being empty"; + case ZSTD_ErrorCode.ZSTD_error_frameIndex_tooLarge: + return "Frame index is too large"; + case ZSTD_ErrorCode.ZSTD_error_seekableIO: + return "An I/O error occurred when reading/seeking"; + case ZSTD_ErrorCode.ZSTD_error_dstBuffer_wrong: + return "Destination buffer is wrong"; + case ZSTD_ErrorCode.ZSTD_error_srcBuffer_wrong: + return "Source buffer is wrong"; + case ZSTD_ErrorCode.ZSTD_error_sequenceProducer_failed: + return "Block-level external sequence producer returned an error code"; + case ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid: + return "External sequences are not valid"; + case ZSTD_ErrorCode.ZSTD_error_maxCode: + default: + return notErrorCode; + } + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/EstimatedBlockSize.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/EstimatedBlockSize.cs new file mode 100644 index 000000000..a2f59adc6 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/EstimatedBlockSize.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct EstimatedBlockSize +{ + public nuint estLitSize; + public nuint estBlockSize; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/FASTCOVER_accel_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/FASTCOVER_accel_t.cs new file mode 100644 index 000000000..c5d239feb --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/FASTCOVER_accel_t.cs @@ -0,0 +1,19 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*-************************************* + * Acceleration + ***************************************/ +public struct FASTCOVER_accel_t +{ + /* Percentage of training samples used for ZDICT_finalizeDictionary */ + public uint finalize; + + /* Number of dmer skipped between each dmer counted in computeFrequency */ + public uint skip; + + public FASTCOVER_accel_t(uint finalize, uint skip) + { + this.finalize = finalize; + this.skip = skip; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/FASTCOVER_ctx_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/FASTCOVER_ctx_t.cs new file mode 100644 index 000000000..8c79a30d1 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/FASTCOVER_ctx_t.cs @@ -0,0 +1,19 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*-************************************* + * Context + ***************************************/ +public unsafe struct FASTCOVER_ctx_t +{ + public byte* samples; + public nuint* offsets; + public nuint* samplesSizes; + public nuint nbSamples; + public nuint nbTrainSamples; + public nuint nbTestSamples; + public nuint nbDmers; + public uint* freqs; + public uint d; + public uint f; + public FASTCOVER_accel_t accelParams; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/FASTCOVER_tryParameters_data_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/FASTCOVER_tryParameters_data_s.cs new file mode 100644 index 000000000..3a6e14f0a --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/FASTCOVER_tryParameters_data_s.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + * Parameters for FASTCOVER_tryParameters(). + */ +public unsafe struct FASTCOVER_tryParameters_data_s +{ + public FASTCOVER_ctx_t* ctx; + public COVER_best_s* best; + public nuint dictBufferCapacity; + public ZDICT_cover_params_t parameters; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/FPStats.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/FPStats.cs new file mode 100644 index 000000000..7a97d8be1 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/FPStats.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct FPStats +{ + public Fingerprint pastEvents; + public Fingerprint newEvents; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_CState_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_CState_t.cs new file mode 100644 index 000000000..dfdc049ba --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_CState_t.cs @@ -0,0 +1,16 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* ***************************************** + * FSE symbol compression API + *******************************************/ +/*! +This API consists of small unitary functions, which highly benefit from being inlined. +Hence their body are included in next section. + */ +public unsafe struct FSE_CState_t +{ + public nint value; + public void* stateTable; + public void* symbolTT; + public uint stateLog; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_DState_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_DState_t.cs new file mode 100644 index 000000000..61e0fb680 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_DState_t.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* ***************************************** + * FSE symbol decompression API + *******************************************/ +public unsafe struct FSE_DState_t +{ + public nuint state; + + /* precise table may vary, depending on U16 */ + public void* table; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_DTableHeader.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_DTableHeader.cs new file mode 100644 index 000000000..db091f0c9 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_DTableHeader.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* ====== Decompression ====== */ +public struct FSE_DTableHeader +{ + public ushort tableLog; + public ushort fastMode; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_DecompressWksp.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_DecompressWksp.cs new file mode 100644 index 000000000..cd03c36f5 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_DecompressWksp.cs @@ -0,0 +1,6 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct FSE_DecompressWksp +{ + public fixed short ncount[256]; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_decode_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_decode_t.cs new file mode 100644 index 000000000..66c496359 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_decode_t.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct FSE_decode_t +{ + public ushort newState; + public byte symbol; + public byte nbBits; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_repeat.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_repeat.cs new file mode 100644 index 000000000..6f2ceb531 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_repeat.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum FSE_repeat +{ + /**< Cannot use the previous table */ + FSE_repeat_none, + + /**< Can use the previous table but it must be checked */ + FSE_repeat_check, + + /**< Can use the previous table and it is assumed to be valid */ + FSE_repeat_valid, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_symbolCompressionTransform.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_symbolCompressionTransform.cs new file mode 100644 index 000000000..c4b43033d --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/FSE_symbolCompressionTransform.cs @@ -0,0 +1,10 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* ***************************************** + * Implementation of inlined functions + *******************************************/ +public struct FSE_symbolCompressionTransform +{ + public int deltaFindState; + public uint deltaNbBits; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Fastcover.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Fastcover.cs new file mode 100644 index 000000000..2bd7e30c1 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Fastcover.cs @@ -0,0 +1,761 @@ +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /*-************************************* + * Hash Functions + ***************************************/ + /** + * Hash the d-byte value pointed to by p and mod 2^f into the frequency vector + */ + private static nuint FASTCOVER_hashPtrToIndex(void* p, uint f, uint d) + { + if (d == 6) + { + return ZSTD_hash6Ptr(p, f); + } + + return ZSTD_hash8Ptr(p, f); + } + + private static readonly FASTCOVER_accel_t* FASTCOVER_defaultAccelParameters = GetArrayPointer( + new FASTCOVER_accel_t[11] + { + new FASTCOVER_accel_t(finalize: 100, skip: 0), + new FASTCOVER_accel_t(finalize: 100, skip: 0), + new FASTCOVER_accel_t(finalize: 50, skip: 1), + new FASTCOVER_accel_t(finalize: 34, skip: 2), + new FASTCOVER_accel_t(finalize: 25, skip: 3), + new FASTCOVER_accel_t(finalize: 20, skip: 4), + new FASTCOVER_accel_t(finalize: 17, skip: 5), + new FASTCOVER_accel_t(finalize: 14, skip: 6), + new FASTCOVER_accel_t(finalize: 13, skip: 7), + new FASTCOVER_accel_t(finalize: 11, skip: 8), + new FASTCOVER_accel_t(finalize: 10, skip: 9), + } + ); + + /*-************************************* + * Helper functions + ***************************************/ + /** + * Selects the best segment in an epoch. + * Segments of are scored according to the function: + * + * Let F(d) be the frequency of all dmers with hash value d. + * Let S_i be hash value of the dmer at position i of segment S which has length k. + * + * Score(S) = F(S_1) + F(S_2) + ... + F(S_{k-d+1}) + * + * Once the dmer with hash value d is in the dictionary we set F(d) = 0. + */ + private static COVER_segment_t FASTCOVER_selectSegment( + FASTCOVER_ctx_t* ctx, + uint* freqs, + uint begin, + uint end, + ZDICT_cover_params_t parameters, + ushort* segmentFreqs + ) + { + /* Constants */ + uint k = parameters.k; + uint d = parameters.d; + uint f = ctx->f; + uint dmersInK = k - d + 1; + /* Try each segment (activeSegment) and save the best (bestSegment) */ + COVER_segment_t bestSegment = new COVER_segment_t + { + begin = 0, + end = 0, + score = 0, + }; + COVER_segment_t activeSegment; + activeSegment.begin = begin; + activeSegment.end = begin; + activeSegment.score = 0; + while (activeSegment.end < end) + { + /* Get hash value of current dmer */ + nuint idx = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.end, f, d); + if (segmentFreqs[idx] == 0) + { + activeSegment.score += freqs[idx]; + } + + activeSegment.end += 1; + segmentFreqs[idx] += 1; + if (activeSegment.end - activeSegment.begin == dmersInK + 1) + { + /* Get hash value of the dmer to be eliminated from active segment */ + nuint delIndex = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.begin, f, d); + segmentFreqs[delIndex] -= 1; + if (segmentFreqs[delIndex] == 0) + { + activeSegment.score -= freqs[delIndex]; + } + + activeSegment.begin += 1; + } + + if (activeSegment.score > bestSegment.score) + { + bestSegment = activeSegment; + } + } + + while (activeSegment.begin < end) + { + nuint delIndex = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.begin, f, d); + segmentFreqs[delIndex] -= 1; + activeSegment.begin += 1; + } + + { + /* Zero the frequency of hash value of each dmer covered by the chosen segment. */ + uint pos; + for (pos = bestSegment.begin; pos != bestSegment.end; ++pos) + { + nuint i = FASTCOVER_hashPtrToIndex(ctx->samples + pos, f, d); + freqs[i] = 0; + } + } + + return bestSegment; + } + + private static int FASTCOVER_checkParameters( + ZDICT_cover_params_t parameters, + nuint maxDictSize, + uint f, + uint accel + ) + { + if (parameters.d == 0 || parameters.k == 0) + { + return 0; + } + + if (parameters.d != 6 && parameters.d != 8) + { + return 0; + } + + if (parameters.k > maxDictSize) + { + return 0; + } + + if (parameters.d > parameters.k) + { + return 0; + } + + if (f > 31 || f == 0) + { + return 0; + } + + if (parameters.splitPoint <= 0 || parameters.splitPoint > 1) + { + return 0; + } + + if (accel > 10 || accel == 0) + { + return 0; + } + + return 1; + } + + /** + * Clean up a context initialized with `FASTCOVER_ctx_init()`. + */ + private static void FASTCOVER_ctx_destroy(FASTCOVER_ctx_t* ctx) + { + if (ctx == null) + return; + free(ctx->freqs); + ctx->freqs = null; + free(ctx->offsets); + ctx->offsets = null; + } + + /** + * Calculate for frequency of hash value of each dmer in ctx->samples + */ + private static void FASTCOVER_computeFrequency(uint* freqs, FASTCOVER_ctx_t* ctx) + { + uint f = ctx->f; + uint d = ctx->d; + uint skip = ctx->accelParams.skip; + uint readLength = d > 8 ? d : 8; + nuint i; + assert(ctx->nbTrainSamples >= 5); + assert(ctx->nbTrainSamples <= ctx->nbSamples); + for (i = 0; i < ctx->nbTrainSamples; i++) + { + /* start of current dmer */ + nuint start = ctx->offsets[i]; + nuint currSampleEnd = ctx->offsets[i + 1]; + while (start + readLength <= currSampleEnd) + { + nuint dmerIndex = FASTCOVER_hashPtrToIndex(ctx->samples + start, f, d); + freqs[dmerIndex]++; + start = start + skip + 1; + } + } + } + + /** + * Prepare a context for dictionary building. + * The context is only dependent on the parameter `d` and can be used multiple + * times. + * Returns 0 on success or error code on error. + * The context must be destroyed with `FASTCOVER_ctx_destroy()`. + */ + private static nuint FASTCOVER_ctx_init( + FASTCOVER_ctx_t* ctx, + void* samplesBuffer, + nuint* samplesSizes, + uint nbSamples, + uint d, + double splitPoint, + uint f, + FASTCOVER_accel_t accelParams + ) + { + byte* samples = (byte*)samplesBuffer; + nuint totalSamplesSize = COVER_sum(samplesSizes, nbSamples); + /* Split samples into testing and training sets */ + uint nbTrainSamples = splitPoint < 1 ? (uint)(nbSamples * splitPoint) : nbSamples; + uint nbTestSamples = splitPoint < 1 ? nbSamples - nbTrainSamples : nbSamples; + nuint trainingSamplesSize = + splitPoint < 1 ? COVER_sum(samplesSizes, nbTrainSamples) : totalSamplesSize; + nuint testSamplesSize = + splitPoint < 1 + ? COVER_sum(samplesSizes + nbTrainSamples, nbTestSamples) + : totalSamplesSize; + if ( + totalSamplesSize < (d > sizeof(ulong) ? d : sizeof(ulong)) + || totalSamplesSize >= (sizeof(nuint) == 8 ? unchecked((uint)-1) : 1 * (1U << 30)) + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if (nbTrainSamples < 5) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if (nbTestSamples < 1) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + *ctx = new FASTCOVER_ctx_t + { + samples = samples, + samplesSizes = samplesSizes, + nbSamples = nbSamples, + nbTrainSamples = nbTrainSamples, + nbTestSamples = nbTestSamples, + nbDmers = trainingSamplesSize - (d > sizeof(ulong) ? d : sizeof(ulong)) + 1, + d = d, + f = f, + accelParams = accelParams, + offsets = (nuint*)calloc(nbSamples + 1, (ulong)sizeof(nuint)), + }; + if (ctx->offsets == null) + { + FASTCOVER_ctx_destroy(ctx); + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + { + uint i; + ctx->offsets[0] = 0; + assert(nbSamples >= 5); + for (i = 1; i <= nbSamples; ++i) + { + ctx->offsets[i] = ctx->offsets[i - 1] + samplesSizes[i - 1]; + } + } + + ctx->freqs = (uint*)calloc((ulong)1 << (int)f, sizeof(uint)); + if (ctx->freqs == null) + { + FASTCOVER_ctx_destroy(ctx); + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + FASTCOVER_computeFrequency(ctx->freqs, ctx); + return 0; + } + + /** + * Given the prepared context build the dictionary. + */ + private static nuint FASTCOVER_buildDictionary( + FASTCOVER_ctx_t* ctx, + uint* freqs, + void* dictBuffer, + nuint dictBufferCapacity, + ZDICT_cover_params_t parameters, + ushort* segmentFreqs + ) + { + byte* dict = (byte*)dictBuffer; + nuint tail = dictBufferCapacity; + /* Divide the data into epochs. We will select one segment from each epoch. */ + COVER_epoch_info_t epochs = COVER_computeEpochs( + (uint)dictBufferCapacity, + (uint)ctx->nbDmers, + parameters.k, + 1 + ); + const nuint maxZeroScoreRun = 10; + nuint zeroScoreRun = 0; + nuint epoch; + for (epoch = 0; tail > 0; epoch = (epoch + 1) % epochs.num) + { + uint epochBegin = (uint)(epoch * epochs.size); + uint epochEnd = epochBegin + epochs.size; + nuint segmentSize; + /* Select a segment */ + COVER_segment_t segment = FASTCOVER_selectSegment( + ctx, + freqs, + epochBegin, + epochEnd, + parameters, + segmentFreqs + ); + if (segment.score == 0) + { + if (++zeroScoreRun >= maxZeroScoreRun) + { + break; + } + + continue; + } + + zeroScoreRun = 0; + segmentSize = + segment.end - segment.begin + parameters.d - 1 < tail + ? segment.end - segment.begin + parameters.d - 1 + : tail; + if (segmentSize < parameters.d) + { + break; + } + + tail -= segmentSize; + memcpy(dict + tail, ctx->samples + segment.begin, (uint)segmentSize); + } + + return tail; + } + + /** + * Tries a set of parameters and updates the COVER_best_t with the results. + * This function is thread safe if zstd is compiled with multithreaded support. + * It takes its parameters as an *OWNING* opaque pointer to support threading. + */ + private static void FASTCOVER_tryParameters(void* opaque) + { + /* Save parameters as local variables */ + FASTCOVER_tryParameters_data_s* data = (FASTCOVER_tryParameters_data_s*)opaque; + FASTCOVER_ctx_t* ctx = data->ctx; + ZDICT_cover_params_t parameters = data->parameters; + nuint dictBufferCapacity = data->dictBufferCapacity; + nuint totalCompressedSize = unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + /* Initialize array to keep track of frequency of dmer within activeSegment */ + ushort* segmentFreqs = (ushort*)calloc((ulong)1 << (int)ctx->f, sizeof(ushort)); + /* Allocate space for hash table, dict, and freqs */ + byte* dict = (byte*)malloc(dictBufferCapacity); + COVER_dictSelection selection = COVER_dictSelectionError( + unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)) + ); + uint* freqs = (uint*)malloc(((ulong)1 << (int)ctx->f) * sizeof(uint)); + if (segmentFreqs == null || dict == null || freqs == null) + { + goto _cleanup; + } + + memcpy(freqs, ctx->freqs, (uint)(((ulong)1 << (int)ctx->f) * sizeof(uint))); + { + nuint tail = FASTCOVER_buildDictionary( + ctx, + freqs, + dict, + dictBufferCapacity, + parameters, + segmentFreqs + ); + uint nbFinalizeSamples = (uint)(ctx->nbTrainSamples * ctx->accelParams.finalize / 100); + selection = COVER_selectDict( + dict + tail, + dictBufferCapacity, + dictBufferCapacity - tail, + ctx->samples, + ctx->samplesSizes, + nbFinalizeSamples, + ctx->nbTrainSamples, + ctx->nbSamples, + parameters, + ctx->offsets, + totalCompressedSize + ); + if (COVER_dictSelectionIsError(selection) != 0) + { + goto _cleanup; + } + } + + _cleanup: + free(dict); + COVER_best_finish(data->best, parameters, selection); + free(data); + free(segmentFreqs); + COVER_dictSelectionFree(selection); + free(freqs); + } + + private static void FASTCOVER_convertToCoverParams( + ZDICT_fastCover_params_t fastCoverParams, + ZDICT_cover_params_t* coverParams + ) + { + coverParams->k = fastCoverParams.k; + coverParams->d = fastCoverParams.d; + coverParams->steps = fastCoverParams.steps; + coverParams->nbThreads = fastCoverParams.nbThreads; + coverParams->splitPoint = fastCoverParams.splitPoint; + coverParams->zParams = fastCoverParams.zParams; + coverParams->shrinkDict = fastCoverParams.shrinkDict; + } + + private static void FASTCOVER_convertToFastCoverParams( + ZDICT_cover_params_t coverParams, + ZDICT_fastCover_params_t* fastCoverParams, + uint f, + uint accel + ) + { + fastCoverParams->k = coverParams.k; + fastCoverParams->d = coverParams.d; + fastCoverParams->steps = coverParams.steps; + fastCoverParams->nbThreads = coverParams.nbThreads; + fastCoverParams->splitPoint = coverParams.splitPoint; + fastCoverParams->f = f; + fastCoverParams->accel = accel; + fastCoverParams->zParams = coverParams.zParams; + fastCoverParams->shrinkDict = coverParams.shrinkDict; + } + + /*! ZDICT_trainFromBuffer_fastCover(): + * Train a dictionary from an array of samples using a modified version of COVER algorithm. + * Samples must be stored concatenated in a single flat buffer `samplesBuffer`, + * supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order. + * d and k are required. + * All other parameters are optional, will use default values if not provided + * The resulting dictionary will be saved into `dictBuffer`. + * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) + * or an error code, which can be tested with ZDICT_isError(). + * See ZDICT_trainFromBuffer() for details on failure modes. + * Note: ZDICT_trainFromBuffer_fastCover() requires 6 * 2^f bytes of memory. + * Tips: In general, a reasonable dictionary has a size of ~ 100 KB. + * It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`. + * In general, it's recommended to provide a few thousands samples, though this can vary a lot. + * It's recommended that total size of all samples be about ~x100 times the target size of dictionary. + */ + public static nuint ZDICT_trainFromBuffer_fastCover( + void* dictBuffer, + nuint dictBufferCapacity, + void* samplesBuffer, + nuint* samplesSizes, + uint nbSamples, + ZDICT_fastCover_params_t parameters + ) + { + byte* dict = (byte*)dictBuffer; + FASTCOVER_ctx_t ctx; + ZDICT_cover_params_t coverParams; + FASTCOVER_accel_t accelParams; + g_displayLevel = (int)parameters.zParams.notificationLevel; + parameters.splitPoint = 1; + parameters.f = parameters.f == 0 ? 20 : parameters.f; + parameters.accel = parameters.accel == 0 ? 1 : parameters.accel; + coverParams = new ZDICT_cover_params_t(); + FASTCOVER_convertToCoverParams(parameters, &coverParams); + if ( + FASTCOVER_checkParameters( + coverParams, + dictBufferCapacity, + parameters.f, + parameters.accel + ) == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + if (nbSamples == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if (dictBufferCapacity < 256) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + accelParams = FASTCOVER_defaultAccelParameters[parameters.accel]; + { + nuint initVal = FASTCOVER_ctx_init( + &ctx, + samplesBuffer, + samplesSizes, + nbSamples, + coverParams.d, + parameters.splitPoint, + parameters.f, + accelParams + ); + if (ERR_isError(initVal)) + { + return initVal; + } + } + + COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.nbDmers, g_displayLevel); + { + /* Initialize array to keep track of frequency of dmer within activeSegment */ + ushort* segmentFreqs = (ushort*)calloc((ulong)1 << (int)parameters.f, sizeof(ushort)); + nuint tail = FASTCOVER_buildDictionary( + &ctx, + ctx.freqs, + dictBuffer, + dictBufferCapacity, + coverParams, + segmentFreqs + ); + uint nbFinalizeSamples = (uint)(ctx.nbTrainSamples * ctx.accelParams.finalize / 100); + nuint dictionarySize = ZDICT_finalizeDictionary( + dict, + dictBufferCapacity, + dict + tail, + dictBufferCapacity - tail, + samplesBuffer, + samplesSizes, + nbFinalizeSamples, + coverParams.zParams + ); + if (!ERR_isError(dictionarySize)) { } + + FASTCOVER_ctx_destroy(&ctx); + free(segmentFreqs); + return dictionarySize; + } + } + + /*! ZDICT_optimizeTrainFromBuffer_fastCover(): + * The same requirements as above hold for all the parameters except `parameters`. + * This function tries many parameter combinations (specifically, k and d combinations) + * and picks the best parameters. `*parameters` is filled with the best parameters found, + * dictionary constructed with those parameters is stored in `dictBuffer`. + * All of the parameters d, k, steps, f, and accel are optional. + * If d is non-zero then we don't check multiple values of d, otherwise we check d = {6, 8}. + * if steps is zero it defaults to its default value. + * If k is non-zero then we don't check multiple values of k, otherwise we check steps values in [50, 2000]. + * If f is zero, default value of 20 is used. + * If accel is zero, default value of 1 is used. + * + * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) + * or an error code, which can be tested with ZDICT_isError(). + * On success `*parameters` contains the parameters selected. + * See ZDICT_trainFromBuffer() for details on failure modes. + * Note: ZDICT_optimizeTrainFromBuffer_fastCover() requires about 6 * 2^f bytes of memory for each thread. + */ + public static nuint ZDICT_optimizeTrainFromBuffer_fastCover( + void* dictBuffer, + nuint dictBufferCapacity, + void* samplesBuffer, + nuint* samplesSizes, + uint nbSamples, + ZDICT_fastCover_params_t* parameters + ) + { + ZDICT_cover_params_t coverParams; + FASTCOVER_accel_t accelParams; + /* constants */ + uint nbThreads = parameters->nbThreads; + double splitPoint = parameters->splitPoint <= 0 ? 0.75 : parameters->splitPoint; + uint kMinD = parameters->d == 0 ? 6 : parameters->d; + uint kMaxD = parameters->d == 0 ? 8 : parameters->d; + uint kMinK = parameters->k == 0 ? 50 : parameters->k; + uint kMaxK = parameters->k == 0 ? 2000 : parameters->k; + uint kSteps = parameters->steps == 0 ? 40 : parameters->steps; + uint kStepSize = (kMaxK - kMinK) / kSteps > 1 ? (kMaxK - kMinK) / kSteps : 1; + uint kIterations = (1 + (kMaxD - kMinD) / 2) * (1 + (kMaxK - kMinK) / kStepSize); + uint f = parameters->f == 0 ? 20 : parameters->f; + uint accel = parameters->accel == 0 ? 1 : parameters->accel; + const uint shrinkDict = 0; + /* Local variables */ + int displayLevel = (int)parameters->zParams.notificationLevel; + uint iteration = 1; + uint d; + uint k; + COVER_best_s best; + void* pool = null; + int warned = 0; + if (splitPoint <= 0 || splitPoint > 1) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + if (accel == 0 || accel > 10) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + if (kMinK < kMaxD || kMaxK < kMinK) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + if (nbSamples == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if (dictBufferCapacity < 256) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (nbThreads > 1) + { + pool = POOL_create(nbThreads, 1); + if (pool == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + } + + COVER_best_init(&best); + coverParams = new ZDICT_cover_params_t(); + FASTCOVER_convertToCoverParams(*parameters, &coverParams); + accelParams = FASTCOVER_defaultAccelParameters[accel]; + g_displayLevel = displayLevel == 0 ? 0 : displayLevel - 1; + for (d = kMinD; d <= kMaxD; d += 2) + { + /* Initialize the context for this value of d */ + FASTCOVER_ctx_t ctx; + { + nuint initVal = FASTCOVER_ctx_init( + &ctx, + samplesBuffer, + samplesSizes, + nbSamples, + d, + splitPoint, + f, + accelParams + ); + if (ERR_isError(initVal)) + { + COVER_best_destroy(&best); + POOL_free(pool); + return initVal; + } + } + + if (warned == 0) + { + COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.nbDmers, displayLevel); + warned = 1; + } + + for (k = kMinK; k <= kMaxK; k += kStepSize) + { + /* Prepare the arguments */ + FASTCOVER_tryParameters_data_s* data = (FASTCOVER_tryParameters_data_s*)malloc( + (ulong)sizeof(FASTCOVER_tryParameters_data_s) + ); + if (data == null) + { + COVER_best_destroy(&best); + FASTCOVER_ctx_destroy(&ctx); + POOL_free(pool); + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + data->ctx = &ctx; + data->best = &best; + data->dictBufferCapacity = dictBufferCapacity; + data->parameters = coverParams; + data->parameters.k = k; + data->parameters.d = d; + data->parameters.splitPoint = splitPoint; + data->parameters.steps = kSteps; + data->parameters.shrinkDict = shrinkDict; + data->parameters.zParams.notificationLevel = (uint)g_displayLevel; + if ( + FASTCOVER_checkParameters( + data->parameters, + dictBufferCapacity, + data->ctx->f, + accel + ) == 0 + ) + { + free(data); + continue; + } + + COVER_best_start(&best); + if (pool != null) + { + POOL_add( + pool, + (delegate* managed)(&FASTCOVER_tryParameters), + data + ); + } + else + { + FASTCOVER_tryParameters(data); + } + + ++iteration; + } + + COVER_best_wait(&best); + FASTCOVER_ctx_destroy(&ctx); + } + + { + nuint dictSize = best.dictSize; + if (ERR_isError(best.compressedSize)) + { + nuint compressedSize = best.compressedSize; + COVER_best_destroy(&best); + POOL_free(pool); + return compressedSize; + } + + FASTCOVER_convertToFastCoverParams(best.parameters, parameters, f, accel); + memcpy(dictBuffer, best.dict, (uint)dictSize); + COVER_best_destroy(&best); + POOL_free(pool); + return dictSize; + } + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Fingerprint.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Fingerprint.cs new file mode 100644 index 000000000..c48772357 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Fingerprint.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct Fingerprint +{ + public fixed uint events[1024]; + public nuint nbEvents; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Fse.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Fse.cs new file mode 100644 index 000000000..32798dfe3 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Fse.cs @@ -0,0 +1,198 @@ +using System.Runtime.CompilerServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void FSE_initCState(FSE_CState_t* statePtr, uint* ct) + { + void* ptr = ct; + ushort* u16ptr = (ushort*)ptr; + uint tableLog = MEM_read16(ptr); + statePtr->value = (nint)1 << (int)tableLog; + statePtr->stateTable = u16ptr + 2; + statePtr->symbolTT = ct + 1 + (tableLog != 0 ? 1 << (int)(tableLog - 1) : 1); + statePtr->stateLog = tableLog; + } + + /*! FSE_initCState2() : + * Same as FSE_initCState(), but the first symbol to include (which will be the last to be read) + * uses the smallest state value possible, saving the cost of this symbol */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void FSE_initCState2(ref FSE_CState_t statePtr, uint* ct, uint symbol) + { + FSE_initCState(ref statePtr, ct); + { + FSE_symbolCompressionTransform symbolTT = ( + (FSE_symbolCompressionTransform*)statePtr.symbolTT + )[symbol]; + ushort* stateTable = (ushort*)statePtr.stateTable; + uint nbBitsOut = symbolTT.deltaNbBits + (1 << 15) >> 16; + statePtr.value = (nint)((nbBitsOut << 16) - symbolTT.deltaNbBits); + statePtr.value = stateTable[ + (statePtr.value >> (int)nbBitsOut) + symbolTT.deltaFindState + ]; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void FSE_encodeSymbol( + ref nuint bitC_bitContainer, + ref uint bitC_bitPos, + ref FSE_CState_t statePtr, + uint symbol + ) + { + FSE_symbolCompressionTransform symbolTT = ( + (FSE_symbolCompressionTransform*)statePtr.symbolTT + )[symbol]; + ushort* stateTable = (ushort*)statePtr.stateTable; + uint nbBitsOut = (uint)statePtr.value + symbolTT.deltaNbBits >> 16; + BIT_addBits(ref bitC_bitContainer, ref bitC_bitPos, (nuint)statePtr.value, nbBitsOut); + statePtr.value = stateTable[(statePtr.value >> (int)nbBitsOut) + symbolTT.deltaFindState]; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void FSE_flushCState( + ref nuint bitC_bitContainer, + ref uint bitC_bitPos, + ref sbyte* bitC_ptr, + sbyte* bitC_endPtr, + ref FSE_CState_t statePtr + ) + { + BIT_addBits( + ref bitC_bitContainer, + ref bitC_bitPos, + (nuint)statePtr.value, + statePtr.stateLog + ); + BIT_flushBits(ref bitC_bitContainer, ref bitC_bitPos, ref bitC_ptr, bitC_endPtr); + } + + /* FSE_getMaxNbBits() : + * Approximate maximum cost of a symbol, in bits. + * Fractional get rounded up (i.e. a symbol with a normalized frequency of 3 gives the same result as a frequency of 2) + * note 1 : assume symbolValue is valid (<= maxSymbolValue) + * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint FSE_getMaxNbBits(void* symbolTTPtr, uint symbolValue) + { + FSE_symbolCompressionTransform* symbolTT = (FSE_symbolCompressionTransform*)symbolTTPtr; + return symbolTT[symbolValue].deltaNbBits + ((1 << 16) - 1) >> 16; + } + + /* FSE_bitCost() : + * Approximate symbol cost, as fractional value, using fixed-point format (accuracyLog fractional bits) + * note 1 : assume symbolValue is valid (<= maxSymbolValue) + * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint FSE_bitCost( + void* symbolTTPtr, + uint tableLog, + uint symbolValue, + uint accuracyLog + ) + { + FSE_symbolCompressionTransform* symbolTT = (FSE_symbolCompressionTransform*)symbolTTPtr; + uint minNbBits = symbolTT[symbolValue].deltaNbBits >> 16; + uint threshold = minNbBits + 1 << 16; + assert(tableLog < 16); + assert(accuracyLog < 31 - tableLog); + { + uint tableSize = (uint)(1 << (int)tableLog); + uint deltaFromThreshold = threshold - (symbolTT[symbolValue].deltaNbBits + tableSize); + /* linear interpolation (very approximate) */ + uint normalizedDeltaFromThreshold = + deltaFromThreshold << (int)accuracyLog >> (int)tableLog; + uint bitMultiplier = (uint)(1 << (int)accuracyLog); + assert(symbolTT[symbolValue].deltaNbBits + tableSize <= threshold); + assert(normalizedDeltaFromThreshold <= bitMultiplier); + return (minNbBits + 1) * bitMultiplier - normalizedDeltaFromThreshold; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void FSE_initDState(ref FSE_DState_t DStatePtr, ref BIT_DStream_t bitD, uint* dt) + { + void* ptr = dt; + FSE_DTableHeader* DTableH = (FSE_DTableHeader*)ptr; + DStatePtr.state = BIT_readBits(bitD.bitContainer, ref bitD.bitsConsumed, DTableH->tableLog); + BIT_reloadDStream( + ref bitD.bitContainer, + ref bitD.bitsConsumed, + ref bitD.ptr, + bitD.start, + bitD.limitPtr + ); + DStatePtr.table = dt + 1; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static byte FSE_peekSymbol(FSE_DState_t* DStatePtr) + { + FSE_decode_t DInfo = ((FSE_decode_t*)DStatePtr->table)[DStatePtr->state]; + return DInfo.symbol; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void FSE_updateState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) + { + FSE_decode_t DInfo = ((FSE_decode_t*)DStatePtr->table)[DStatePtr->state]; + uint nbBits = DInfo.nbBits; + nuint lowBits = BIT_readBits(bitD, nbBits); + DStatePtr->state = DInfo.newState + lowBits; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static byte FSE_decodeSymbol( + ref FSE_DState_t DStatePtr, + nuint bitD_bitContainer, + ref uint bitD_bitsConsumed + ) + { + FSE_decode_t DInfo = ((FSE_decode_t*)DStatePtr.table)[DStatePtr.state]; + uint nbBits = DInfo.nbBits; + byte symbol = DInfo.symbol; + nuint lowBits = BIT_readBits(bitD_bitContainer, ref bitD_bitsConsumed, nbBits); + DStatePtr.state = DInfo.newState + lowBits; + return symbol; + } + + /*! FSE_decodeSymbolFast() : + unsafe, only works if no symbol has a probability > 50% */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static byte FSE_decodeSymbolFast( + ref FSE_DState_t DStatePtr, + nuint bitD_bitContainer, + ref uint bitD_bitsConsumed + ) + { + FSE_decode_t DInfo = ((FSE_decode_t*)DStatePtr.table)[DStatePtr.state]; + uint nbBits = DInfo.nbBits; + byte symbol = DInfo.symbol; + nuint lowBits = BIT_readBitsFast(bitD_bitContainer, ref bitD_bitsConsumed, nbBits); + DStatePtr.state = DInfo.newState + lowBits; + return symbol; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint FSE_endOfDState(FSE_DState_t* DStatePtr) + { + return DStatePtr->state == 0 ? 1U : 0U; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void FSE_initCState(ref FSE_CState_t statePtr, uint* ct) + { + void* ptr = ct; + ushort* u16ptr = (ushort*)ptr; + uint tableLog = MEM_read16(ptr); + statePtr.value = (nint)1 << (int)tableLog; + statePtr.stateTable = u16ptr + 2; + statePtr.symbolTT = ct + 1 + (tableLog != 0 ? 1 << (int)(tableLog - 1) : 1); + statePtr.stateLog = tableLog; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/FseCompress.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/FseCompress.cs new file mode 100644 index 000000000..c4c763a1f --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/FseCompress.cs @@ -0,0 +1,782 @@ +using System; +using System.Runtime.InteropServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /* FSE_buildCTable_wksp() : + * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`). + * wkspSize should be sized to handle worst case situation, which is `1<> 1 : 1); + FSE_symbolCompressionTransform* symbolTT = (FSE_symbolCompressionTransform*)FSCT; + uint step = (tableSize >> 1) + (tableSize >> 3) + 3; + uint maxSV1 = maxSymbolValue + 1; + /* size = maxSV1 */ + ushort* cumul = (ushort*)workSpace; + /* size = tableSize */ + byte* tableSymbol = (byte*)(cumul + (maxSV1 + 1)); + uint highThreshold = tableSize - 1; + assert(((nuint)workSpace & 1) == 0); + if ( + sizeof(uint) + * ((maxSymbolValue + 2 + (1UL << (int)tableLog)) / 2 + sizeof(ulong) / sizeof(uint)) + > wkspSize + ) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)); + tableU16[-2] = (ushort)tableLog; + tableU16[-1] = (ushort)maxSymbolValue; + assert(tableLog < 16); + { + uint u; + cumul[0] = 0; + for (u = 1; u <= maxSV1; u++) + { + if (normalizedCounter[u - 1] == -1) + { + cumul[u] = (ushort)(cumul[u - 1] + 1); + tableSymbol[highThreshold--] = (byte)(u - 1); + } + else + { + assert(normalizedCounter[u - 1] >= 0); + cumul[u] = (ushort)(cumul[u - 1] + (ushort)normalizedCounter[u - 1]); + assert(cumul[u] >= cumul[u - 1]); + } + } + + cumul[maxSV1] = (ushort)(tableSize + 1); + } + + if (highThreshold == tableSize - 1) + { + /* size = tableSize + 8 (may write beyond tableSize) */ + byte* spread = tableSymbol + tableSize; + { + const ulong add = 0x0101010101010101UL; + nuint pos = 0; + ulong sv = 0; + uint s; + for (s = 0; s < maxSV1; ++s, sv += add) + { + int i; + int n = normalizedCounter[s]; + MEM_write64(spread + pos, sv); + for (i = 8; i < n; i += 8) + { + MEM_write64(spread + pos + i, sv); + } + + assert(n >= 0); + pos += (nuint)n; + } + } + + { + nuint position = 0; + nuint s; + /* Experimentally determined optimal unroll */ + const nuint unroll = 2; + assert(tableSize % unroll == 0); + for (s = 0; s < tableSize; s += unroll) + { + nuint u; + for (u = 0; u < unroll; ++u) + { + nuint uPosition = position + u * step & tableMask; + tableSymbol[uPosition] = spread[s + u]; + } + + position = position + unroll * step & tableMask; + } + + assert(position == 0); + } + } + else + { + uint position = 0; + uint symbol; + for (symbol = 0; symbol < maxSV1; symbol++) + { + int nbOccurrences; + int freq = normalizedCounter[symbol]; + for (nbOccurrences = 0; nbOccurrences < freq; nbOccurrences++) + { + tableSymbol[position] = (byte)symbol; + position = position + step & tableMask; + while (position > highThreshold) + position = position + step & tableMask; + } + } + + assert(position == 0); + } + + { + uint u; + for (u = 0; u < tableSize; u++) + { + /* note : static analyzer may not understand tableSymbol is properly initialized */ + byte s = tableSymbol[u]; + tableU16[cumul[s]++] = (ushort)(tableSize + u); + } + } + + { + uint total = 0; + uint s; + for (s = 0; s <= maxSymbolValue; s++) + { + switch (normalizedCounter[s]) + { + case 0: + symbolTT[s].deltaNbBits = (tableLog + 1 << 16) - (uint)(1 << (int)tableLog); + break; + case -1: + case 1: + symbolTT[s].deltaNbBits = (tableLog << 16) - (uint)(1 << (int)tableLog); + assert(total <= 2147483647); + symbolTT[s].deltaFindState = (int)(total - 1); + total++; + break; + default: + assert(normalizedCounter[s] > 1); + + { + uint maxBitsOut = + tableLog - ZSTD_highbit32((uint)normalizedCounter[s] - 1); + uint minStatePlus = (uint)normalizedCounter[s] << (int)maxBitsOut; + symbolTT[s].deltaNbBits = (maxBitsOut << 16) - minStatePlus; + symbolTT[s].deltaFindState = (int)(total - (uint)normalizedCounter[s]); + total += (uint)normalizedCounter[s]; + } + + break; + } + } + } + + return 0; + } + + /*-************************************************************** + * FSE NCount encoding + ****************************************************************/ + private static nuint FSE_NCountWriteBound(uint maxSymbolValue, uint tableLog) + { + nuint maxHeaderSize = ((maxSymbolValue + 1) * tableLog + 4 + 2) / 8 + 1 + 2; + return maxSymbolValue != 0 ? maxHeaderSize : 512; + } + + private static nuint FSE_writeNCount_generic( + void* header, + nuint headerBufferSize, + short* normalizedCounter, + uint maxSymbolValue, + uint tableLog, + uint writeIsSafe + ) + { + byte* ostart = (byte*)header; + byte* @out = ostart; + byte* oend = ostart + headerBufferSize; + int nbBits; + int tableSize = 1 << (int)tableLog; + int remaining; + int threshold; + uint bitStream = 0; + int bitCount = 0; + uint symbol = 0; + uint alphabetSize = maxSymbolValue + 1; + int previousIs0 = 0; + bitStream += tableLog - 5 << bitCount; + bitCount += 4; + remaining = tableSize + 1; + threshold = tableSize; + nbBits = (int)tableLog + 1; + while (symbol < alphabetSize && remaining > 1) + { + if (previousIs0 != 0) + { + uint start = symbol; + while (symbol < alphabetSize && normalizedCounter[symbol] == 0) + symbol++; + if (symbol == alphabetSize) + break; + while (symbol >= start + 24) + { + start += 24; + bitStream += 0xFFFFU << bitCount; + if (writeIsSafe == 0 && @out > oend - 2) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + @out[0] = (byte)bitStream; + @out[1] = (byte)(bitStream >> 8); + @out += 2; + bitStream >>= 16; + } + + while (symbol >= start + 3) + { + start += 3; + bitStream += 3U << bitCount; + bitCount += 2; + } + + bitStream += symbol - start << bitCount; + bitCount += 2; + if (bitCount > 16) + { + if (writeIsSafe == 0 && @out > oend - 2) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + @out[0] = (byte)bitStream; + @out[1] = (byte)(bitStream >> 8); + @out += 2; + bitStream >>= 16; + bitCount -= 16; + } + } + + { + int count = normalizedCounter[symbol++]; + int max = 2 * threshold - 1 - remaining; + remaining -= count < 0 ? -count : count; + count++; + if (count >= threshold) + count += max; + bitStream += (uint)count << bitCount; + bitCount += nbBits; + bitCount -= count < max ? 1 : 0; + previousIs0 = count == 1 ? 1 : 0; + if (remaining < 1) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + while (remaining < threshold) + { + nbBits--; + threshold >>= 1; + } + } + + if (bitCount > 16) + { + if (writeIsSafe == 0 && @out > oend - 2) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + @out[0] = (byte)bitStream; + @out[1] = (byte)(bitStream >> 8); + @out += 2; + bitStream >>= 16; + bitCount -= 16; + } + } + + if (remaining != 1) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + assert(symbol <= alphabetSize); + if (writeIsSafe == 0 && @out > oend - 2) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + @out[0] = (byte)bitStream; + @out[1] = (byte)(bitStream >> 8); + @out += (bitCount + 7) / 8; + assert(@out >= ostart); + return (nuint)(@out - ostart); + } + + /*! FSE_writeNCount(): + Compactly save 'normalizedCounter' into 'buffer'. + @return : size of the compressed table, + or an errorCode, which can be tested using FSE_isError(). */ + private static nuint FSE_writeNCount( + void* buffer, + nuint bufferSize, + short* normalizedCounter, + uint maxSymbolValue, + uint tableLog + ) + { + if (tableLog > 14 - 2) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)); + if (tableLog < 5) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + if (bufferSize < FSE_NCountWriteBound(maxSymbolValue, tableLog)) + return FSE_writeNCount_generic( + buffer, + bufferSize, + normalizedCounter, + maxSymbolValue, + tableLog, + 0 + ); + return FSE_writeNCount_generic( + buffer, + bufferSize, + normalizedCounter, + maxSymbolValue, + tableLog, + 1 + ); + } + + /* provides the minimum logSize to safely represent a distribution */ + private static uint FSE_minTableLog(nuint srcSize, uint maxSymbolValue) + { + uint minBitsSrc = ZSTD_highbit32((uint)srcSize) + 1; + uint minBitsSymbols = ZSTD_highbit32(maxSymbolValue) + 2; + uint minBits = minBitsSrc < minBitsSymbols ? minBitsSrc : minBitsSymbols; + assert(srcSize > 1); + return minBits; + } + + /* ***************************************** + * FSE advanced API + ***************************************** */ + private static uint FSE_optimalTableLog_internal( + uint maxTableLog, + nuint srcSize, + uint maxSymbolValue, + uint minus + ) + { + uint maxBitsSrc = ZSTD_highbit32((uint)(srcSize - 1)) - minus; + uint tableLog = maxTableLog; + uint minBits = FSE_minTableLog(srcSize, maxSymbolValue); + assert(srcSize > 1); + if (tableLog == 0) + tableLog = 13 - 2; + if (maxBitsSrc < tableLog) + tableLog = maxBitsSrc; + if (minBits > tableLog) + tableLog = minBits; + if (tableLog < 5) + tableLog = 5; + if (tableLog > 14 - 2) + tableLog = 14 - 2; + return tableLog; + } + + /*! FSE_optimalTableLog(): + dynamically downsize 'tableLog' when conditions are met. + It saves CPU time, by using smaller tables, while preserving or even improving compression ratio. + @return : recommended tableLog (necessarily <= 'maxTableLog') */ + private static uint FSE_optimalTableLog(uint maxTableLog, nuint srcSize, uint maxSymbolValue) + { + return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 2); + } + + /* Secondary normalization method. + To be used when primary method fails. */ + private static nuint FSE_normalizeM2( + short* norm, + uint tableLog, + uint* count, + nuint total, + uint maxSymbolValue, + short lowProbCount + ) + { + const short NOT_YET_ASSIGNED = -2; + uint s; + uint distributed = 0; + uint ToDistribute; + /* Init */ + uint lowThreshold = (uint)(total >> (int)tableLog); + uint lowOne = (uint)(total * 3 >> (int)(tableLog + 1)); + for (s = 0; s <= maxSymbolValue; s++) + { + if (count[s] == 0) + { + norm[s] = 0; + continue; + } + + if (count[s] <= lowThreshold) + { + norm[s] = lowProbCount; + distributed++; + total -= count[s]; + continue; + } + + if (count[s] <= lowOne) + { + norm[s] = 1; + distributed++; + total -= count[s]; + continue; + } + + norm[s] = NOT_YET_ASSIGNED; + } + + ToDistribute = (uint)(1 << (int)tableLog) - distributed; + if (ToDistribute == 0) + return 0; + if (total / ToDistribute > lowOne) + { + lowOne = (uint)(total * 3 / (ToDistribute * 2)); + for (s = 0; s <= maxSymbolValue; s++) + { + if (norm[s] == NOT_YET_ASSIGNED && count[s] <= lowOne) + { + norm[s] = 1; + distributed++; + total -= count[s]; + continue; + } + } + + ToDistribute = (uint)(1 << (int)tableLog) - distributed; + } + + if (distributed == maxSymbolValue + 1) + { + /* all values are pretty poor; + probably incompressible data (should have already been detected); + find max, then give all remaining points to max */ + uint maxV = 0, + maxC = 0; + for (s = 0; s <= maxSymbolValue; s++) + if (count[s] > maxC) + { + maxV = s; + maxC = count[s]; + } + + norm[maxV] += (short)ToDistribute; + return 0; + } + + if (total == 0) + { + for (s = 0; ToDistribute > 0; s = (s + 1) % (maxSymbolValue + 1)) + if (norm[s] > 0) + { + ToDistribute--; + norm[s]++; + } + + return 0; + } + + { + ulong vStepLog = 62 - tableLog; + ulong mid = (1UL << (int)(vStepLog - 1)) - 1; + /* scale on remaining */ + ulong rStep = (((ulong)1 << (int)vStepLog) * ToDistribute + mid) / (uint)total; + ulong tmpTotal = mid; + for (s = 0; s <= maxSymbolValue; s++) + { + if (norm[s] == NOT_YET_ASSIGNED) + { + ulong end = tmpTotal + count[s] * rStep; + uint sStart = (uint)(tmpTotal >> (int)vStepLog); + uint sEnd = (uint)(end >> (int)vStepLog); + uint weight = sEnd - sStart; + if (weight < 1) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + norm[s] = (short)weight; + tmpTotal = end; + } + } + } + + return 0; + } + +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_rtbTable => + new uint[8] { 0, 473195, 504333, 520860, 550000, 700000, 750000, 830000 }; + private static uint* rtbTable => + (uint*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_rtbTable) + ); +#else + + private static readonly uint* rtbTable = GetArrayPointer( + new uint[8] { 0, 473195, 504333, 520860, 550000, 700000, 750000, 830000 } + ); +#endif + /*! FSE_normalizeCount(): + normalize counts so that sum(count[]) == Power_of_2 (2^tableLog) + 'normalizedCounter' is a table of short, of minimum size (maxSymbolValue+1). + useLowProbCount is a boolean parameter which trades off compressed size for + faster header decoding. When it is set to 1, the compressed data will be slightly + smaller. And when it is set to 0, FSE_readNCount() and FSE_buildDTable() will be + faster. If you are compressing a small amount of data (< 2 KB) then useLowProbCount=0 + is a good default, since header deserialization makes a big speed difference. + Otherwise, useLowProbCount=1 is a good default, since the speed difference is small. + @return : tableLog, + or an errorCode, which can be tested using FSE_isError() */ + private static nuint FSE_normalizeCount( + short* normalizedCounter, + uint tableLog, + uint* count, + nuint total, + uint maxSymbolValue, + uint useLowProbCount + ) + { + if (tableLog == 0) + tableLog = 13 - 2; + if (tableLog < 5) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + if (tableLog > 14 - 2) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)); + if (tableLog < FSE_minTableLog(total, maxSymbolValue)) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + { + short lowProbCount = (short)(useLowProbCount != 0 ? -1 : 1); + ulong scale = 62 - tableLog; + /* <== here, one division ! */ + ulong step = ((ulong)1 << 62) / (uint)total; + ulong vStep = 1UL << (int)(scale - 20); + int stillToDistribute = 1 << (int)tableLog; + uint s; + uint largest = 0; + short largestP = 0; + uint lowThreshold = (uint)(total >> (int)tableLog); + for (s = 0; s <= maxSymbolValue; s++) + { + if (count[s] == total) + return 0; + if (count[s] == 0) + { + normalizedCounter[s] = 0; + continue; + } + + if (count[s] <= lowThreshold) + { + normalizedCounter[s] = lowProbCount; + stillToDistribute--; + } + else + { + short proba = (short)(count[s] * step >> (int)scale); + if (proba < 8) + { + ulong restToBeat = vStep * rtbTable[proba]; + proba += (short)( + count[s] * step - ((ulong)proba << (int)scale) > restToBeat ? 1 : 0 + ); + } + + if (proba > largestP) + { + largestP = proba; + largest = s; + } + + normalizedCounter[s] = proba; + stillToDistribute -= proba; + } + } + + if (-stillToDistribute >= normalizedCounter[largest] >> 1) + { + /* corner case, need another normalization method */ + nuint errorCode = FSE_normalizeM2( + normalizedCounter, + tableLog, + count, + total, + maxSymbolValue, + lowProbCount + ); + if (ERR_isError(errorCode)) + return errorCode; + } + else + normalizedCounter[largest] += (short)stillToDistribute; + } + + return tableLog; + } + + /* fake FSE_CTable, for rle input (always same symbol) */ + private static nuint FSE_buildCTable_rle(uint* ct, byte symbolValue) + { + void* ptr = ct; + ushort* tableU16 = (ushort*)ptr + 2; + void* FSCTptr = (uint*)ptr + 2; + FSE_symbolCompressionTransform* symbolTT = (FSE_symbolCompressionTransform*)FSCTptr; + tableU16[-2] = 0; + tableU16[-1] = symbolValue; + tableU16[0] = 0; + tableU16[1] = 0; + symbolTT[symbolValue].deltaNbBits = 0; + symbolTT[symbolValue].deltaFindState = 0; + return 0; + } + + private static nuint FSE_compress_usingCTable_generic( + void* dst, + nuint dstSize, + void* src, + nuint srcSize, + uint* ct, + uint fast + ) + { + byte* istart = (byte*)src; + byte* iend = istart + srcSize; + byte* ip = iend; + BIT_CStream_t bitC; + System.Runtime.CompilerServices.Unsafe.SkipInit(out bitC); + FSE_CState_t CState1, + CState2; + System.Runtime.CompilerServices.Unsafe.SkipInit(out CState1); + System.Runtime.CompilerServices.Unsafe.SkipInit(out CState2); + if (srcSize <= 2) + return 0; + { + nuint initError = BIT_initCStream(ref bitC, dst, dstSize); + if (ERR_isError(initError)) + return 0; + } + + nuint bitC_bitContainer = bitC.bitContainer; + uint bitC_bitPos = bitC.bitPos; + sbyte* bitC_ptr = bitC.ptr; + sbyte* bitC_endPtr = bitC.endPtr; + if ((srcSize & 1) != 0) + { + FSE_initCState2(ref CState1, ct, *--ip); + FSE_initCState2(ref CState2, ct, *--ip); + FSE_encodeSymbol(ref bitC_bitContainer, ref bitC_bitPos, ref CState1, *--ip); + if (fast != 0) + BIT_flushBitsFast( + ref bitC_bitContainer, + ref bitC_bitPos, + ref bitC_ptr, + bitC_endPtr + ); + else + BIT_flushBits(ref bitC_bitContainer, ref bitC_bitPos, ref bitC_ptr, bitC_endPtr); + } + else + { + FSE_initCState2(ref CState2, ct, *--ip); + FSE_initCState2(ref CState1, ct, *--ip); + } + + srcSize -= 2; + if (sizeof(nuint) * 8 > (14 - 2) * 4 + 7 && (srcSize & 2) != 0) + { + FSE_encodeSymbol(ref bitC_bitContainer, ref bitC_bitPos, ref CState2, *--ip); + FSE_encodeSymbol(ref bitC_bitContainer, ref bitC_bitPos, ref CState1, *--ip); + if (fast != 0) + BIT_flushBitsFast( + ref bitC_bitContainer, + ref bitC_bitPos, + ref bitC_ptr, + bitC_endPtr + ); + else + BIT_flushBits(ref bitC_bitContainer, ref bitC_bitPos, ref bitC_ptr, bitC_endPtr); + } + + while (ip > istart) + { + FSE_encodeSymbol(ref bitC_bitContainer, ref bitC_bitPos, ref CState2, *--ip); + if (sizeof(nuint) * 8 < (14 - 2) * 2 + 7) + if (fast != 0) + BIT_flushBitsFast( + ref bitC_bitContainer, + ref bitC_bitPos, + ref bitC_ptr, + bitC_endPtr + ); + else + BIT_flushBits( + ref bitC_bitContainer, + ref bitC_bitPos, + ref bitC_ptr, + bitC_endPtr + ); + FSE_encodeSymbol(ref bitC_bitContainer, ref bitC_bitPos, ref CState1, *--ip); + if (sizeof(nuint) * 8 > (14 - 2) * 4 + 7) + { + FSE_encodeSymbol(ref bitC_bitContainer, ref bitC_bitPos, ref CState2, *--ip); + FSE_encodeSymbol(ref bitC_bitContainer, ref bitC_bitPos, ref CState1, *--ip); + } + + if (fast != 0) + BIT_flushBitsFast( + ref bitC_bitContainer, + ref bitC_bitPos, + ref bitC_ptr, + bitC_endPtr + ); + else + BIT_flushBits(ref bitC_bitContainer, ref bitC_bitPos, ref bitC_ptr, bitC_endPtr); + } + + FSE_flushCState( + ref bitC_bitContainer, + ref bitC_bitPos, + ref bitC_ptr, + bitC_endPtr, + ref CState2 + ); + FSE_flushCState( + ref bitC_bitContainer, + ref bitC_bitPos, + ref bitC_ptr, + bitC_endPtr, + ref CState1 + ); + return BIT_closeCStream( + ref bitC_bitContainer, + ref bitC_bitPos, + bitC_ptr, + bitC_endPtr, + bitC.startPtr + ); + } + + /*! FSE_compress_usingCTable(): + Compress `src` using `ct` into `dst` which must be already allocated. + @return : size of compressed data (<= `dstCapacity`), + or 0 if compressed data could not fit into `dst`, + or an errorCode, which can be tested using FSE_isError() */ + private static nuint FSE_compress_usingCTable( + void* dst, + nuint dstSize, + void* src, + nuint srcSize, + uint* ct + ) + { + uint fast = dstSize >= srcSize + (srcSize >> 7) + 4 + (nuint)sizeof(nuint) ? 1U : 0U; + if (fast != 0) + return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 1); + else + return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 0); + } + + /*-***************************************** + * Tool functions + ******************************************/ + private static nuint FSE_compressBound(nuint size) + { + return 512 + (size + (size >> 7) + 4 + (nuint)sizeof(nuint)); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/FseDecompress.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/FseDecompress.cs new file mode 100644 index 000000000..12be4ef69 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/FseDecompress.cs @@ -0,0 +1,462 @@ +using System.Runtime.CompilerServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + private static nuint FSE_buildDTable_internal( + uint* dt, + short* normalizedCounter, + uint maxSymbolValue, + uint tableLog, + void* workSpace, + nuint wkspSize + ) + { + /* because *dt is unsigned, 32-bits aligned on 32-bits */ + void* tdPtr = dt + 1; + FSE_decode_t* tableDecode = (FSE_decode_t*)tdPtr; + ushort* symbolNext = (ushort*)workSpace; + byte* spread = (byte*)(symbolNext + maxSymbolValue + 1); + uint maxSV1 = maxSymbolValue + 1; + uint tableSize = (uint)(1 << (int)tableLog); + uint highThreshold = tableSize - 1; + if (sizeof(short) * (maxSymbolValue + 1) + (1UL << (int)tableLog) + 8 > wkspSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_maxSymbolValue_tooLarge)); + if (maxSymbolValue > 255) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_maxSymbolValue_tooLarge)); + if (tableLog > 14 - 2) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)); + { + FSE_DTableHeader DTableH; + DTableH.tableLog = (ushort)tableLog; + DTableH.fastMode = 1; + { + short largeLimit = (short)(1 << (int)(tableLog - 1)); + uint s; + for (s = 0; s < maxSV1; s++) + { + if (normalizedCounter[s] == -1) + { + tableDecode[highThreshold--].symbol = (byte)s; + symbolNext[s] = 1; + } + else + { + if (normalizedCounter[s] >= largeLimit) + DTableH.fastMode = 0; + symbolNext[s] = (ushort)normalizedCounter[s]; + } + } + } + + memcpy(dt, &DTableH, (uint)sizeof(FSE_DTableHeader)); + } + + if (highThreshold == tableSize - 1) + { + nuint tableMask = tableSize - 1; + nuint step = (tableSize >> 1) + (tableSize >> 3) + 3; + { + const ulong add = 0x0101010101010101UL; + nuint pos = 0; + ulong sv = 0; + uint s; + for (s = 0; s < maxSV1; ++s, sv += add) + { + int i; + int n = normalizedCounter[s]; + MEM_write64(spread + pos, sv); + for (i = 8; i < n; i += 8) + { + MEM_write64(spread + pos + i, sv); + } + + pos += (nuint)n; + } + } + + { + nuint position = 0; + nuint s; + const nuint unroll = 2; + assert(tableSize % unroll == 0); + for (s = 0; s < tableSize; s += unroll) + { + nuint u; + for (u = 0; u < unroll; ++u) + { + nuint uPosition = position + u * step & tableMask; + tableDecode[uPosition].symbol = spread[s + u]; + } + + position = position + unroll * step & tableMask; + } + + assert(position == 0); + } + } + else + { + uint tableMask = tableSize - 1; + uint step = (tableSize >> 1) + (tableSize >> 3) + 3; + uint s, + position = 0; + for (s = 0; s < maxSV1; s++) + { + int i; + for (i = 0; i < normalizedCounter[s]; i++) + { + tableDecode[position].symbol = (byte)s; + position = position + step & tableMask; + while (position > highThreshold) + position = position + step & tableMask; + } + } + + if (position != 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + + { + uint u; + for (u = 0; u < tableSize; u++) + { + byte symbol = tableDecode[u].symbol; + uint nextState = symbolNext[symbol]++; + tableDecode[u].nbBits = (byte)(tableLog - ZSTD_highbit32(nextState)); + tableDecode[u].newState = (ushort)( + (nextState << tableDecode[u].nbBits) - tableSize + ); + } + } + + return 0; + } + + private static nuint FSE_buildDTable_wksp( + uint* dt, + short* normalizedCounter, + uint maxSymbolValue, + uint tableLog, + void* workSpace, + nuint wkspSize + ) + { + return FSE_buildDTable_internal( + dt, + normalizedCounter, + maxSymbolValue, + tableLog, + workSpace, + wkspSize + ); + } + + /*-******************************************************* + * Decompression (Byte symbols) + *********************************************************/ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint FSE_decompress_usingDTable_generic( + void* dst, + nuint maxDstSize, + void* cSrc, + nuint cSrcSize, + uint* dt, + uint fast + ) + { + byte* ostart = (byte*)dst; + byte* op = ostart; + byte* omax = op + maxDstSize; + byte* olimit = omax - 3; + BIT_DStream_t bitD; + System.Runtime.CompilerServices.Unsafe.SkipInit(out bitD); + FSE_DState_t state1; + System.Runtime.CompilerServices.Unsafe.SkipInit(out state1); + FSE_DState_t state2; + System.Runtime.CompilerServices.Unsafe.SkipInit(out state2); + { + /* Init */ + nuint _var_err__ = BIT_initDStream(ref bitD, cSrc, cSrcSize); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + FSE_initDState(ref state1, ref bitD, dt); + FSE_initDState(ref state2, ref bitD, dt); + nuint bitD_bitContainer = bitD.bitContainer; + uint bitD_bitsConsumed = bitD.bitsConsumed; + sbyte* bitD_ptr = bitD.ptr; + sbyte* bitD_start = bitD.start; + sbyte* bitD_limitPtr = bitD.limitPtr; + if ( + BIT_reloadDStream( + ref bitD_bitContainer, + ref bitD_bitsConsumed, + ref bitD_ptr, + bitD_start, + bitD_limitPtr + ) == BIT_DStream_status.BIT_DStream_overflow + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + for ( + ; + BIT_reloadDStream( + ref bitD_bitContainer, + ref bitD_bitsConsumed, + ref bitD_ptr, + bitD_start, + bitD_limitPtr + ) == BIT_DStream_status.BIT_DStream_unfinished + && op < olimit; + op += 4 + ) + { + op[0] = + fast != 0 + ? FSE_decodeSymbolFast(ref state1, bitD_bitContainer, ref bitD_bitsConsumed) + : FSE_decodeSymbol(ref state1, bitD_bitContainer, ref bitD_bitsConsumed); + if ((14 - 2) * 2 + 7 > sizeof(nuint) * 8) + BIT_reloadDStream( + ref bitD_bitContainer, + ref bitD_bitsConsumed, + ref bitD_ptr, + bitD_start, + bitD_limitPtr + ); + op[1] = + fast != 0 + ? FSE_decodeSymbolFast(ref state2, bitD_bitContainer, ref bitD_bitsConsumed) + : FSE_decodeSymbol(ref state2, bitD_bitContainer, ref bitD_bitsConsumed); + if ((14 - 2) * 4 + 7 > sizeof(nuint) * 8) + { + if ( + BIT_reloadDStream( + ref bitD_bitContainer, + ref bitD_bitsConsumed, + ref bitD_ptr, + bitD_start, + bitD_limitPtr + ) > BIT_DStream_status.BIT_DStream_unfinished + ) + { + op += 2; + break; + } + } + + op[2] = + fast != 0 + ? FSE_decodeSymbolFast(ref state1, bitD_bitContainer, ref bitD_bitsConsumed) + : FSE_decodeSymbol(ref state1, bitD_bitContainer, ref bitD_bitsConsumed); + if ((14 - 2) * 2 + 7 > sizeof(nuint) * 8) + BIT_reloadDStream( + ref bitD_bitContainer, + ref bitD_bitsConsumed, + ref bitD_ptr, + bitD_start, + bitD_limitPtr + ); + op[3] = + fast != 0 + ? FSE_decodeSymbolFast(ref state2, bitD_bitContainer, ref bitD_bitsConsumed) + : FSE_decodeSymbol(ref state2, bitD_bitContainer, ref bitD_bitsConsumed); + } + + while (true) + { + if (op > omax - 2) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + *op++ = + fast != 0 + ? FSE_decodeSymbolFast(ref state1, bitD_bitContainer, ref bitD_bitsConsumed) + : FSE_decodeSymbol(ref state1, bitD_bitContainer, ref bitD_bitsConsumed); + if ( + BIT_reloadDStream( + ref bitD_bitContainer, + ref bitD_bitsConsumed, + ref bitD_ptr, + bitD_start, + bitD_limitPtr + ) == BIT_DStream_status.BIT_DStream_overflow + ) + { + *op++ = + fast != 0 + ? FSE_decodeSymbolFast(ref state2, bitD_bitContainer, ref bitD_bitsConsumed) + : FSE_decodeSymbol(ref state2, bitD_bitContainer, ref bitD_bitsConsumed); + break; + } + + if (op > omax - 2) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + *op++ = + fast != 0 + ? FSE_decodeSymbolFast(ref state2, bitD_bitContainer, ref bitD_bitsConsumed) + : FSE_decodeSymbol(ref state2, bitD_bitContainer, ref bitD_bitsConsumed); + if ( + BIT_reloadDStream( + ref bitD_bitContainer, + ref bitD_bitsConsumed, + ref bitD_ptr, + bitD_start, + bitD_limitPtr + ) == BIT_DStream_status.BIT_DStream_overflow + ) + { + *op++ = + fast != 0 + ? FSE_decodeSymbolFast(ref state1, bitD_bitContainer, ref bitD_bitsConsumed) + : FSE_decodeSymbol(ref state1, bitD_bitContainer, ref bitD_bitsConsumed); + break; + } + } + + assert(op >= ostart); + return (nuint)(op - ostart); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint FSE_decompress_wksp_body( + void* dst, + nuint dstCapacity, + void* cSrc, + nuint cSrcSize, + uint maxLog, + void* workSpace, + nuint wkspSize, + int bmi2 + ) + { + byte* istart = (byte*)cSrc; + byte* ip = istart; + uint tableLog; + uint maxSymbolValue = 255; + FSE_DecompressWksp* wksp = (FSE_DecompressWksp*)workSpace; + nuint dtablePos = (nuint)(sizeof(FSE_DecompressWksp) / sizeof(uint)); + uint* dtable = (uint*)workSpace + dtablePos; + if (wkspSize < (nuint)sizeof(FSE_DecompressWksp)) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + { + nuint NCountLength = FSE_readNCount_bmi2( + wksp->ncount, + &maxSymbolValue, + &tableLog, + istart, + cSrcSize, + bmi2 + ); + if (ERR_isError(NCountLength)) + return NCountLength; + if (tableLog > maxLog) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)); + assert(NCountLength <= cSrcSize); + ip += NCountLength; + cSrcSize -= NCountLength; + } + + if ( + ( + (ulong)(1 + (1 << (int)tableLog) + 1) + + ( + sizeof(short) * (maxSymbolValue + 1) + + (1UL << (int)tableLog) + + 8 + + sizeof(uint) + - 1 + ) / sizeof(uint) + + (255 + 1) / 2 + + 1 + ) * sizeof(uint) + > wkspSize + ) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)); + assert( + (nuint)(sizeof(FSE_DecompressWksp) + (1 + (1 << (int)tableLog)) * sizeof(uint)) + <= wkspSize + ); + workSpace = + (byte*)workSpace + + sizeof(FSE_DecompressWksp) + + (1 + (1 << (int)tableLog)) * sizeof(uint); + wkspSize -= (nuint)(sizeof(FSE_DecompressWksp) + (1 + (1 << (int)tableLog)) * sizeof(uint)); + { + nuint _var_err__ = FSE_buildDTable_internal( + dtable, + wksp->ncount, + maxSymbolValue, + tableLog, + workSpace, + wkspSize + ); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + { + void* ptr = dtable; + FSE_DTableHeader* DTableH = (FSE_DTableHeader*)ptr; + uint fastMode = DTableH->fastMode; + if (fastMode != 0) + return FSE_decompress_usingDTable_generic( + dst, + dstCapacity, + ip, + cSrcSize, + dtable, + 1 + ); + return FSE_decompress_usingDTable_generic(dst, dstCapacity, ip, cSrcSize, dtable, 0); + } + } + + /* Avoids the FORCE_INLINE of the _body() function. */ + private static nuint FSE_decompress_wksp_body_default( + void* dst, + nuint dstCapacity, + void* cSrc, + nuint cSrcSize, + uint maxLog, + void* workSpace, + nuint wkspSize + ) + { + return FSE_decompress_wksp_body( + dst, + dstCapacity, + cSrc, + cSrcSize, + maxLog, + workSpace, + wkspSize, + 0 + ); + } + + private static nuint FSE_decompress_wksp_bmi2( + void* dst, + nuint dstCapacity, + void* cSrc, + nuint cSrcSize, + uint maxLog, + void* workSpace, + nuint wkspSize, + int bmi2 + ) + { + return FSE_decompress_wksp_body_default( + dst, + dstCapacity, + cSrc, + cSrcSize, + maxLog, + workSpace, + wkspSize + ); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HIST_checkInput_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HIST_checkInput_e.cs new file mode 100644 index 000000000..8aca6e8fe --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HIST_checkInput_e.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum HIST_checkInput_e +{ + trustInput, + checkMaxSymbolValue, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_CStream_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_CStream_t.cs new file mode 100644 index 000000000..b86d99f3d --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_CStream_t.cs @@ -0,0 +1,22 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct HUF_CStream_t +{ + public _bitContainer_e__FixedBuffer bitContainer; + public _bitPos_e__FixedBuffer bitPos; + public byte* startPtr; + public byte* ptr; + public byte* endPtr; + + public unsafe struct _bitContainer_e__FixedBuffer + { + public nuint e0; + public nuint e1; + } + + public unsafe struct _bitPos_e__FixedBuffer + { + public nuint e0; + public nuint e1; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_CTableHeader.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_CTableHeader.cs new file mode 100644 index 000000000..cc542493a --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_CTableHeader.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct HUF_CTableHeader +{ + public byte tableLog; + public byte maxSymbolValue; + public fixed byte unused[6]; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_CompressWeightsWksp.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_CompressWeightsWksp.cs new file mode 100644 index 000000000..789f4e7f4 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_CompressWeightsWksp.cs @@ -0,0 +1,9 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct HUF_CompressWeightsWksp +{ + public fixed uint CTable[59]; + public fixed uint scratchBuffer[41]; + public fixed uint count[13]; + public fixed short norm[13]; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_DEltX1.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_DEltX1.cs new file mode 100644 index 000000000..94d25d9d1 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_DEltX1.cs @@ -0,0 +1,11 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*-***************************/ +/* single-symbol decoding */ +/*-***************************/ +public struct HUF_DEltX1 +{ + /* single-symbol decoding */ + public byte nbBits; + public byte @byte; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_DEltX2.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_DEltX2.cs new file mode 100644 index 000000000..0ab3f1d49 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_DEltX2.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* *************************/ +/* double-symbols decoding */ +/* *************************/ +public struct HUF_DEltX2 +{ + /* double-symbols decoding */ + public ushort sequence; + public byte nbBits; + public byte length; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_DecompressFastArgs.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_DecompressFastArgs.cs new file mode 100644 index 000000000..c9b8d2d5c --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_DecompressFastArgs.cs @@ -0,0 +1,49 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + * The input/output arguments to the Huffman fast decoding loop: + * + * ip [in/out] - The input pointers, must be updated to reflect what is consumed. + * op [in/out] - The output pointers, must be updated to reflect what is written. + * bits [in/out] - The bitstream containers, must be updated to reflect the current state. + * dt [in] - The decoding table. + * ilowest [in] - The beginning of the valid range of the input. Decoders may read + * down to this pointer. It may be below iend[0]. + * oend [in] - The end of the output stream. op[3] must not cross oend. + * iend [in] - The end of each input stream. ip[i] may cross iend[i], + * as long as it is above ilowest, but that indicates corruption. + */ +public unsafe struct HUF_DecompressFastArgs +{ + public _ip_e__FixedBuffer ip; + public _op_e__FixedBuffer op; + public fixed ulong bits[4]; + public void* dt; + public byte* ilowest; + public byte* oend; + public _iend_e__FixedBuffer iend; + + public unsafe struct _ip_e__FixedBuffer + { + public byte* e0; + public byte* e1; + public byte* e2; + public byte* e3; + } + + public unsafe struct _op_e__FixedBuffer + { + public byte* e0; + public byte* e1; + public byte* e2; + public byte* e3; + } + + public unsafe struct _iend_e__FixedBuffer + { + public byte* e0; + public byte* e1; + public byte* e2; + public byte* e3; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_ReadDTableX1_Workspace.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_ReadDTableX1_Workspace.cs new file mode 100644 index 000000000..529a3e5e3 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_ReadDTableX1_Workspace.cs @@ -0,0 +1,10 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct HUF_ReadDTableX1_Workspace +{ + public fixed uint rankVal[13]; + public fixed uint rankStart[13]; + public fixed uint statsWksp[219]; + public fixed byte symbols[256]; + public fixed byte huffWeight[256]; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_ReadDTableX2_Workspace.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_ReadDTableX2_Workspace.cs new file mode 100644 index 000000000..a85bbb6c1 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_ReadDTableX2_Workspace.cs @@ -0,0 +1,307 @@ +using System.Runtime.CompilerServices; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct HUF_ReadDTableX2_Workspace +{ + public _rankVal_e__FixedBuffer rankVal; + public fixed uint rankStats[13]; + public fixed uint rankStart0[15]; + public _sortedSymbol_e__FixedBuffer sortedSymbol; + public fixed byte weightList[256]; + public fixed uint calleeWksp[219]; + +#if NET8_0_OR_GREATER + [InlineArray(12)] + public unsafe struct _rankVal_e__FixedBuffer + { + public rankValCol_t e0; + } + +#else + public unsafe struct _rankVal_e__FixedBuffer + { + public rankValCol_t e0; + public rankValCol_t e1; + public rankValCol_t e2; + public rankValCol_t e3; + public rankValCol_t e4; + public rankValCol_t e5; + public rankValCol_t e6; + public rankValCol_t e7; + public rankValCol_t e8; + public rankValCol_t e9; + public rankValCol_t e10; + public rankValCol_t e11; + } +#endif + +#if NET8_0_OR_GREATER + [InlineArray(256)] + public unsafe struct _sortedSymbol_e__FixedBuffer + { + public sortedSymbol_t e0; + } + +#else + public unsafe struct _sortedSymbol_e__FixedBuffer + { + public sortedSymbol_t e0; + public sortedSymbol_t e1; + public sortedSymbol_t e2; + public sortedSymbol_t e3; + public sortedSymbol_t e4; + public sortedSymbol_t e5; + public sortedSymbol_t e6; + public sortedSymbol_t e7; + public sortedSymbol_t e8; + public sortedSymbol_t e9; + public sortedSymbol_t e10; + public sortedSymbol_t e11; + public sortedSymbol_t e12; + public sortedSymbol_t e13; + public sortedSymbol_t e14; + public sortedSymbol_t e15; + public sortedSymbol_t e16; + public sortedSymbol_t e17; + public sortedSymbol_t e18; + public sortedSymbol_t e19; + public sortedSymbol_t e20; + public sortedSymbol_t e21; + public sortedSymbol_t e22; + public sortedSymbol_t e23; + public sortedSymbol_t e24; + public sortedSymbol_t e25; + public sortedSymbol_t e26; + public sortedSymbol_t e27; + public sortedSymbol_t e28; + public sortedSymbol_t e29; + public sortedSymbol_t e30; + public sortedSymbol_t e31; + public sortedSymbol_t e32; + public sortedSymbol_t e33; + public sortedSymbol_t e34; + public sortedSymbol_t e35; + public sortedSymbol_t e36; + public sortedSymbol_t e37; + public sortedSymbol_t e38; + public sortedSymbol_t e39; + public sortedSymbol_t e40; + public sortedSymbol_t e41; + public sortedSymbol_t e42; + public sortedSymbol_t e43; + public sortedSymbol_t e44; + public sortedSymbol_t e45; + public sortedSymbol_t e46; + public sortedSymbol_t e47; + public sortedSymbol_t e48; + public sortedSymbol_t e49; + public sortedSymbol_t e50; + public sortedSymbol_t e51; + public sortedSymbol_t e52; + public sortedSymbol_t e53; + public sortedSymbol_t e54; + public sortedSymbol_t e55; + public sortedSymbol_t e56; + public sortedSymbol_t e57; + public sortedSymbol_t e58; + public sortedSymbol_t e59; + public sortedSymbol_t e60; + public sortedSymbol_t e61; + public sortedSymbol_t e62; + public sortedSymbol_t e63; + public sortedSymbol_t e64; + public sortedSymbol_t e65; + public sortedSymbol_t e66; + public sortedSymbol_t e67; + public sortedSymbol_t e68; + public sortedSymbol_t e69; + public sortedSymbol_t e70; + public sortedSymbol_t e71; + public sortedSymbol_t e72; + public sortedSymbol_t e73; + public sortedSymbol_t e74; + public sortedSymbol_t e75; + public sortedSymbol_t e76; + public sortedSymbol_t e77; + public sortedSymbol_t e78; + public sortedSymbol_t e79; + public sortedSymbol_t e80; + public sortedSymbol_t e81; + public sortedSymbol_t e82; + public sortedSymbol_t e83; + public sortedSymbol_t e84; + public sortedSymbol_t e85; + public sortedSymbol_t e86; + public sortedSymbol_t e87; + public sortedSymbol_t e88; + public sortedSymbol_t e89; + public sortedSymbol_t e90; + public sortedSymbol_t e91; + public sortedSymbol_t e92; + public sortedSymbol_t e93; + public sortedSymbol_t e94; + public sortedSymbol_t e95; + public sortedSymbol_t e96; + public sortedSymbol_t e97; + public sortedSymbol_t e98; + public sortedSymbol_t e99; + public sortedSymbol_t e100; + public sortedSymbol_t e101; + public sortedSymbol_t e102; + public sortedSymbol_t e103; + public sortedSymbol_t e104; + public sortedSymbol_t e105; + public sortedSymbol_t e106; + public sortedSymbol_t e107; + public sortedSymbol_t e108; + public sortedSymbol_t e109; + public sortedSymbol_t e110; + public sortedSymbol_t e111; + public sortedSymbol_t e112; + public sortedSymbol_t e113; + public sortedSymbol_t e114; + public sortedSymbol_t e115; + public sortedSymbol_t e116; + public sortedSymbol_t e117; + public sortedSymbol_t e118; + public sortedSymbol_t e119; + public sortedSymbol_t e120; + public sortedSymbol_t e121; + public sortedSymbol_t e122; + public sortedSymbol_t e123; + public sortedSymbol_t e124; + public sortedSymbol_t e125; + public sortedSymbol_t e126; + public sortedSymbol_t e127; + public sortedSymbol_t e128; + public sortedSymbol_t e129; + public sortedSymbol_t e130; + public sortedSymbol_t e131; + public sortedSymbol_t e132; + public sortedSymbol_t e133; + public sortedSymbol_t e134; + public sortedSymbol_t e135; + public sortedSymbol_t e136; + public sortedSymbol_t e137; + public sortedSymbol_t e138; + public sortedSymbol_t e139; + public sortedSymbol_t e140; + public sortedSymbol_t e141; + public sortedSymbol_t e142; + public sortedSymbol_t e143; + public sortedSymbol_t e144; + public sortedSymbol_t e145; + public sortedSymbol_t e146; + public sortedSymbol_t e147; + public sortedSymbol_t e148; + public sortedSymbol_t e149; + public sortedSymbol_t e150; + public sortedSymbol_t e151; + public sortedSymbol_t e152; + public sortedSymbol_t e153; + public sortedSymbol_t e154; + public sortedSymbol_t e155; + public sortedSymbol_t e156; + public sortedSymbol_t e157; + public sortedSymbol_t e158; + public sortedSymbol_t e159; + public sortedSymbol_t e160; + public sortedSymbol_t e161; + public sortedSymbol_t e162; + public sortedSymbol_t e163; + public sortedSymbol_t e164; + public sortedSymbol_t e165; + public sortedSymbol_t e166; + public sortedSymbol_t e167; + public sortedSymbol_t e168; + public sortedSymbol_t e169; + public sortedSymbol_t e170; + public sortedSymbol_t e171; + public sortedSymbol_t e172; + public sortedSymbol_t e173; + public sortedSymbol_t e174; + public sortedSymbol_t e175; + public sortedSymbol_t e176; + public sortedSymbol_t e177; + public sortedSymbol_t e178; + public sortedSymbol_t e179; + public sortedSymbol_t e180; + public sortedSymbol_t e181; + public sortedSymbol_t e182; + public sortedSymbol_t e183; + public sortedSymbol_t e184; + public sortedSymbol_t e185; + public sortedSymbol_t e186; + public sortedSymbol_t e187; + public sortedSymbol_t e188; + public sortedSymbol_t e189; + public sortedSymbol_t e190; + public sortedSymbol_t e191; + public sortedSymbol_t e192; + public sortedSymbol_t e193; + public sortedSymbol_t e194; + public sortedSymbol_t e195; + public sortedSymbol_t e196; + public sortedSymbol_t e197; + public sortedSymbol_t e198; + public sortedSymbol_t e199; + public sortedSymbol_t e200; + public sortedSymbol_t e201; + public sortedSymbol_t e202; + public sortedSymbol_t e203; + public sortedSymbol_t e204; + public sortedSymbol_t e205; + public sortedSymbol_t e206; + public sortedSymbol_t e207; + public sortedSymbol_t e208; + public sortedSymbol_t e209; + public sortedSymbol_t e210; + public sortedSymbol_t e211; + public sortedSymbol_t e212; + public sortedSymbol_t e213; + public sortedSymbol_t e214; + public sortedSymbol_t e215; + public sortedSymbol_t e216; + public sortedSymbol_t e217; + public sortedSymbol_t e218; + public sortedSymbol_t e219; + public sortedSymbol_t e220; + public sortedSymbol_t e221; + public sortedSymbol_t e222; + public sortedSymbol_t e223; + public sortedSymbol_t e224; + public sortedSymbol_t e225; + public sortedSymbol_t e226; + public sortedSymbol_t e227; + public sortedSymbol_t e228; + public sortedSymbol_t e229; + public sortedSymbol_t e230; + public sortedSymbol_t e231; + public sortedSymbol_t e232; + public sortedSymbol_t e233; + public sortedSymbol_t e234; + public sortedSymbol_t e235; + public sortedSymbol_t e236; + public sortedSymbol_t e237; + public sortedSymbol_t e238; + public sortedSymbol_t e239; + public sortedSymbol_t e240; + public sortedSymbol_t e241; + public sortedSymbol_t e242; + public sortedSymbol_t e243; + public sortedSymbol_t e244; + public sortedSymbol_t e245; + public sortedSymbol_t e246; + public sortedSymbol_t e247; + public sortedSymbol_t e248; + public sortedSymbol_t e249; + public sortedSymbol_t e250; + public sortedSymbol_t e251; + public sortedSymbol_t e252; + public sortedSymbol_t e253; + public sortedSymbol_t e254; + public sortedSymbol_t e255; + } +#endif +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_WriteCTableWksp.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_WriteCTableWksp.cs new file mode 100644 index 000000000..2400dba76 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_WriteCTableWksp.cs @@ -0,0 +1,10 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct HUF_WriteCTableWksp +{ + public HUF_CompressWeightsWksp wksp; + + /* precomputed conversion table */ + public fixed byte bitsToWeight[13]; + public fixed byte huffWeight[255]; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_buildCTable_wksp_tables.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_buildCTable_wksp_tables.cs new file mode 100644 index 000000000..4fe92db70 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_buildCTable_wksp_tables.cs @@ -0,0 +1,739 @@ +using System.Runtime.CompilerServices; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct HUF_buildCTable_wksp_tables +{ + public _huffNodeTbl_e__FixedBuffer huffNodeTbl; + public _rankPosition_e__FixedBuffer rankPosition; + +#if NET8_0_OR_GREATER + [InlineArray(512)] + public unsafe struct _huffNodeTbl_e__FixedBuffer + { + public nodeElt_s e0; + } + +#else + public unsafe struct _huffNodeTbl_e__FixedBuffer + { + public nodeElt_s e0; + public nodeElt_s e1; + public nodeElt_s e2; + public nodeElt_s e3; + public nodeElt_s e4; + public nodeElt_s e5; + public nodeElt_s e6; + public nodeElt_s e7; + public nodeElt_s e8; + public nodeElt_s e9; + public nodeElt_s e10; + public nodeElt_s e11; + public nodeElt_s e12; + public nodeElt_s e13; + public nodeElt_s e14; + public nodeElt_s e15; + public nodeElt_s e16; + public nodeElt_s e17; + public nodeElt_s e18; + public nodeElt_s e19; + public nodeElt_s e20; + public nodeElt_s e21; + public nodeElt_s e22; + public nodeElt_s e23; + public nodeElt_s e24; + public nodeElt_s e25; + public nodeElt_s e26; + public nodeElt_s e27; + public nodeElt_s e28; + public nodeElt_s e29; + public nodeElt_s e30; + public nodeElt_s e31; + public nodeElt_s e32; + public nodeElt_s e33; + public nodeElt_s e34; + public nodeElt_s e35; + public nodeElt_s e36; + public nodeElt_s e37; + public nodeElt_s e38; + public nodeElt_s e39; + public nodeElt_s e40; + public nodeElt_s e41; + public nodeElt_s e42; + public nodeElt_s e43; + public nodeElt_s e44; + public nodeElt_s e45; + public nodeElt_s e46; + public nodeElt_s e47; + public nodeElt_s e48; + public nodeElt_s e49; + public nodeElt_s e50; + public nodeElt_s e51; + public nodeElt_s e52; + public nodeElt_s e53; + public nodeElt_s e54; + public nodeElt_s e55; + public nodeElt_s e56; + public nodeElt_s e57; + public nodeElt_s e58; + public nodeElt_s e59; + public nodeElt_s e60; + public nodeElt_s e61; + public nodeElt_s e62; + public nodeElt_s e63; + public nodeElt_s e64; + public nodeElt_s e65; + public nodeElt_s e66; + public nodeElt_s e67; + public nodeElt_s e68; + public nodeElt_s e69; + public nodeElt_s e70; + public nodeElt_s e71; + public nodeElt_s e72; + public nodeElt_s e73; + public nodeElt_s e74; + public nodeElt_s e75; + public nodeElt_s e76; + public nodeElt_s e77; + public nodeElt_s e78; + public nodeElt_s e79; + public nodeElt_s e80; + public nodeElt_s e81; + public nodeElt_s e82; + public nodeElt_s e83; + public nodeElt_s e84; + public nodeElt_s e85; + public nodeElt_s e86; + public nodeElt_s e87; + public nodeElt_s e88; + public nodeElt_s e89; + public nodeElt_s e90; + public nodeElt_s e91; + public nodeElt_s e92; + public nodeElt_s e93; + public nodeElt_s e94; + public nodeElt_s e95; + public nodeElt_s e96; + public nodeElt_s e97; + public nodeElt_s e98; + public nodeElt_s e99; + public nodeElt_s e100; + public nodeElt_s e101; + public nodeElt_s e102; + public nodeElt_s e103; + public nodeElt_s e104; + public nodeElt_s e105; + public nodeElt_s e106; + public nodeElt_s e107; + public nodeElt_s e108; + public nodeElt_s e109; + public nodeElt_s e110; + public nodeElt_s e111; + public nodeElt_s e112; + public nodeElt_s e113; + public nodeElt_s e114; + public nodeElt_s e115; + public nodeElt_s e116; + public nodeElt_s e117; + public nodeElt_s e118; + public nodeElt_s e119; + public nodeElt_s e120; + public nodeElt_s e121; + public nodeElt_s e122; + public nodeElt_s e123; + public nodeElt_s e124; + public nodeElt_s e125; + public nodeElt_s e126; + public nodeElt_s e127; + public nodeElt_s e128; + public nodeElt_s e129; + public nodeElt_s e130; + public nodeElt_s e131; + public nodeElt_s e132; + public nodeElt_s e133; + public nodeElt_s e134; + public nodeElt_s e135; + public nodeElt_s e136; + public nodeElt_s e137; + public nodeElt_s e138; + public nodeElt_s e139; + public nodeElt_s e140; + public nodeElt_s e141; + public nodeElt_s e142; + public nodeElt_s e143; + public nodeElt_s e144; + public nodeElt_s e145; + public nodeElt_s e146; + public nodeElt_s e147; + public nodeElt_s e148; + public nodeElt_s e149; + public nodeElt_s e150; + public nodeElt_s e151; + public nodeElt_s e152; + public nodeElt_s e153; + public nodeElt_s e154; + public nodeElt_s e155; + public nodeElt_s e156; + public nodeElt_s e157; + public nodeElt_s e158; + public nodeElt_s e159; + public nodeElt_s e160; + public nodeElt_s e161; + public nodeElt_s e162; + public nodeElt_s e163; + public nodeElt_s e164; + public nodeElt_s e165; + public nodeElt_s e166; + public nodeElt_s e167; + public nodeElt_s e168; + public nodeElt_s e169; + public nodeElt_s e170; + public nodeElt_s e171; + public nodeElt_s e172; + public nodeElt_s e173; + public nodeElt_s e174; + public nodeElt_s e175; + public nodeElt_s e176; + public nodeElt_s e177; + public nodeElt_s e178; + public nodeElt_s e179; + public nodeElt_s e180; + public nodeElt_s e181; + public nodeElt_s e182; + public nodeElt_s e183; + public nodeElt_s e184; + public nodeElt_s e185; + public nodeElt_s e186; + public nodeElt_s e187; + public nodeElt_s e188; + public nodeElt_s e189; + public nodeElt_s e190; + public nodeElt_s e191; + public nodeElt_s e192; + public nodeElt_s e193; + public nodeElt_s e194; + public nodeElt_s e195; + public nodeElt_s e196; + public nodeElt_s e197; + public nodeElt_s e198; + public nodeElt_s e199; + public nodeElt_s e200; + public nodeElt_s e201; + public nodeElt_s e202; + public nodeElt_s e203; + public nodeElt_s e204; + public nodeElt_s e205; + public nodeElt_s e206; + public nodeElt_s e207; + public nodeElt_s e208; + public nodeElt_s e209; + public nodeElt_s e210; + public nodeElt_s e211; + public nodeElt_s e212; + public nodeElt_s e213; + public nodeElt_s e214; + public nodeElt_s e215; + public nodeElt_s e216; + public nodeElt_s e217; + public nodeElt_s e218; + public nodeElt_s e219; + public nodeElt_s e220; + public nodeElt_s e221; + public nodeElt_s e222; + public nodeElt_s e223; + public nodeElt_s e224; + public nodeElt_s e225; + public nodeElt_s e226; + public nodeElt_s e227; + public nodeElt_s e228; + public nodeElt_s e229; + public nodeElt_s e230; + public nodeElt_s e231; + public nodeElt_s e232; + public nodeElt_s e233; + public nodeElt_s e234; + public nodeElt_s e235; + public nodeElt_s e236; + public nodeElt_s e237; + public nodeElt_s e238; + public nodeElt_s e239; + public nodeElt_s e240; + public nodeElt_s e241; + public nodeElt_s e242; + public nodeElt_s e243; + public nodeElt_s e244; + public nodeElt_s e245; + public nodeElt_s e246; + public nodeElt_s e247; + public nodeElt_s e248; + public nodeElt_s e249; + public nodeElt_s e250; + public nodeElt_s e251; + public nodeElt_s e252; + public nodeElt_s e253; + public nodeElt_s e254; + public nodeElt_s e255; + public nodeElt_s e256; + public nodeElt_s e257; + public nodeElt_s e258; + public nodeElt_s e259; + public nodeElt_s e260; + public nodeElt_s e261; + public nodeElt_s e262; + public nodeElt_s e263; + public nodeElt_s e264; + public nodeElt_s e265; + public nodeElt_s e266; + public nodeElt_s e267; + public nodeElt_s e268; + public nodeElt_s e269; + public nodeElt_s e270; + public nodeElt_s e271; + public nodeElt_s e272; + public nodeElt_s e273; + public nodeElt_s e274; + public nodeElt_s e275; + public nodeElt_s e276; + public nodeElt_s e277; + public nodeElt_s e278; + public nodeElt_s e279; + public nodeElt_s e280; + public nodeElt_s e281; + public nodeElt_s e282; + public nodeElt_s e283; + public nodeElt_s e284; + public nodeElt_s e285; + public nodeElt_s e286; + public nodeElt_s e287; + public nodeElt_s e288; + public nodeElt_s e289; + public nodeElt_s e290; + public nodeElt_s e291; + public nodeElt_s e292; + public nodeElt_s e293; + public nodeElt_s e294; + public nodeElt_s e295; + public nodeElt_s e296; + public nodeElt_s e297; + public nodeElt_s e298; + public nodeElt_s e299; + public nodeElt_s e300; + public nodeElt_s e301; + public nodeElt_s e302; + public nodeElt_s e303; + public nodeElt_s e304; + public nodeElt_s e305; + public nodeElt_s e306; + public nodeElt_s e307; + public nodeElt_s e308; + public nodeElt_s e309; + public nodeElt_s e310; + public nodeElt_s e311; + public nodeElt_s e312; + public nodeElt_s e313; + public nodeElt_s e314; + public nodeElt_s e315; + public nodeElt_s e316; + public nodeElt_s e317; + public nodeElt_s e318; + public nodeElt_s e319; + public nodeElt_s e320; + public nodeElt_s e321; + public nodeElt_s e322; + public nodeElt_s e323; + public nodeElt_s e324; + public nodeElt_s e325; + public nodeElt_s e326; + public nodeElt_s e327; + public nodeElt_s e328; + public nodeElt_s e329; + public nodeElt_s e330; + public nodeElt_s e331; + public nodeElt_s e332; + public nodeElt_s e333; + public nodeElt_s e334; + public nodeElt_s e335; + public nodeElt_s e336; + public nodeElt_s e337; + public nodeElt_s e338; + public nodeElt_s e339; + public nodeElt_s e340; + public nodeElt_s e341; + public nodeElt_s e342; + public nodeElt_s e343; + public nodeElt_s e344; + public nodeElt_s e345; + public nodeElt_s e346; + public nodeElt_s e347; + public nodeElt_s e348; + public nodeElt_s e349; + public nodeElt_s e350; + public nodeElt_s e351; + public nodeElt_s e352; + public nodeElt_s e353; + public nodeElt_s e354; + public nodeElt_s e355; + public nodeElt_s e356; + public nodeElt_s e357; + public nodeElt_s e358; + public nodeElt_s e359; + public nodeElt_s e360; + public nodeElt_s e361; + public nodeElt_s e362; + public nodeElt_s e363; + public nodeElt_s e364; + public nodeElt_s e365; + public nodeElt_s e366; + public nodeElt_s e367; + public nodeElt_s e368; + public nodeElt_s e369; + public nodeElt_s e370; + public nodeElt_s e371; + public nodeElt_s e372; + public nodeElt_s e373; + public nodeElt_s e374; + public nodeElt_s e375; + public nodeElt_s e376; + public nodeElt_s e377; + public nodeElt_s e378; + public nodeElt_s e379; + public nodeElt_s e380; + public nodeElt_s e381; + public nodeElt_s e382; + public nodeElt_s e383; + public nodeElt_s e384; + public nodeElt_s e385; + public nodeElt_s e386; + public nodeElt_s e387; + public nodeElt_s e388; + public nodeElt_s e389; + public nodeElt_s e390; + public nodeElt_s e391; + public nodeElt_s e392; + public nodeElt_s e393; + public nodeElt_s e394; + public nodeElt_s e395; + public nodeElt_s e396; + public nodeElt_s e397; + public nodeElt_s e398; + public nodeElt_s e399; + public nodeElt_s e400; + public nodeElt_s e401; + public nodeElt_s e402; + public nodeElt_s e403; + public nodeElt_s e404; + public nodeElt_s e405; + public nodeElt_s e406; + public nodeElt_s e407; + public nodeElt_s e408; + public nodeElt_s e409; + public nodeElt_s e410; + public nodeElt_s e411; + public nodeElt_s e412; + public nodeElt_s e413; + public nodeElt_s e414; + public nodeElt_s e415; + public nodeElt_s e416; + public nodeElt_s e417; + public nodeElt_s e418; + public nodeElt_s e419; + public nodeElt_s e420; + public nodeElt_s e421; + public nodeElt_s e422; + public nodeElt_s e423; + public nodeElt_s e424; + public nodeElt_s e425; + public nodeElt_s e426; + public nodeElt_s e427; + public nodeElt_s e428; + public nodeElt_s e429; + public nodeElt_s e430; + public nodeElt_s e431; + public nodeElt_s e432; + public nodeElt_s e433; + public nodeElt_s e434; + public nodeElt_s e435; + public nodeElt_s e436; + public nodeElt_s e437; + public nodeElt_s e438; + public nodeElt_s e439; + public nodeElt_s e440; + public nodeElt_s e441; + public nodeElt_s e442; + public nodeElt_s e443; + public nodeElt_s e444; + public nodeElt_s e445; + public nodeElt_s e446; + public nodeElt_s e447; + public nodeElt_s e448; + public nodeElt_s e449; + public nodeElt_s e450; + public nodeElt_s e451; + public nodeElt_s e452; + public nodeElt_s e453; + public nodeElt_s e454; + public nodeElt_s e455; + public nodeElt_s e456; + public nodeElt_s e457; + public nodeElt_s e458; + public nodeElt_s e459; + public nodeElt_s e460; + public nodeElt_s e461; + public nodeElt_s e462; + public nodeElt_s e463; + public nodeElt_s e464; + public nodeElt_s e465; + public nodeElt_s e466; + public nodeElt_s e467; + public nodeElt_s e468; + public nodeElt_s e469; + public nodeElt_s e470; + public nodeElt_s e471; + public nodeElt_s e472; + public nodeElt_s e473; + public nodeElt_s e474; + public nodeElt_s e475; + public nodeElt_s e476; + public nodeElt_s e477; + public nodeElt_s e478; + public nodeElt_s e479; + public nodeElt_s e480; + public nodeElt_s e481; + public nodeElt_s e482; + public nodeElt_s e483; + public nodeElt_s e484; + public nodeElt_s e485; + public nodeElt_s e486; + public nodeElt_s e487; + public nodeElt_s e488; + public nodeElt_s e489; + public nodeElt_s e490; + public nodeElt_s e491; + public nodeElt_s e492; + public nodeElt_s e493; + public nodeElt_s e494; + public nodeElt_s e495; + public nodeElt_s e496; + public nodeElt_s e497; + public nodeElt_s e498; + public nodeElt_s e499; + public nodeElt_s e500; + public nodeElt_s e501; + public nodeElt_s e502; + public nodeElt_s e503; + public nodeElt_s e504; + public nodeElt_s e505; + public nodeElt_s e506; + public nodeElt_s e507; + public nodeElt_s e508; + public nodeElt_s e509; + public nodeElt_s e510; + public nodeElt_s e511; + } +#endif + +#if NET8_0_OR_GREATER + [InlineArray(192)] + public unsafe struct _rankPosition_e__FixedBuffer + { + public rankPos e0; + } + +#else + public unsafe struct _rankPosition_e__FixedBuffer + { + public rankPos e0; + public rankPos e1; + public rankPos e2; + public rankPos e3; + public rankPos e4; + public rankPos e5; + public rankPos e6; + public rankPos e7; + public rankPos e8; + public rankPos e9; + public rankPos e10; + public rankPos e11; + public rankPos e12; + public rankPos e13; + public rankPos e14; + public rankPos e15; + public rankPos e16; + public rankPos e17; + public rankPos e18; + public rankPos e19; + public rankPos e20; + public rankPos e21; + public rankPos e22; + public rankPos e23; + public rankPos e24; + public rankPos e25; + public rankPos e26; + public rankPos e27; + public rankPos e28; + public rankPos e29; + public rankPos e30; + public rankPos e31; + public rankPos e32; + public rankPos e33; + public rankPos e34; + public rankPos e35; + public rankPos e36; + public rankPos e37; + public rankPos e38; + public rankPos e39; + public rankPos e40; + public rankPos e41; + public rankPos e42; + public rankPos e43; + public rankPos e44; + public rankPos e45; + public rankPos e46; + public rankPos e47; + public rankPos e48; + public rankPos e49; + public rankPos e50; + public rankPos e51; + public rankPos e52; + public rankPos e53; + public rankPos e54; + public rankPos e55; + public rankPos e56; + public rankPos e57; + public rankPos e58; + public rankPos e59; + public rankPos e60; + public rankPos e61; + public rankPos e62; + public rankPos e63; + public rankPos e64; + public rankPos e65; + public rankPos e66; + public rankPos e67; + public rankPos e68; + public rankPos e69; + public rankPos e70; + public rankPos e71; + public rankPos e72; + public rankPos e73; + public rankPos e74; + public rankPos e75; + public rankPos e76; + public rankPos e77; + public rankPos e78; + public rankPos e79; + public rankPos e80; + public rankPos e81; + public rankPos e82; + public rankPos e83; + public rankPos e84; + public rankPos e85; + public rankPos e86; + public rankPos e87; + public rankPos e88; + public rankPos e89; + public rankPos e90; + public rankPos e91; + public rankPos e92; + public rankPos e93; + public rankPos e94; + public rankPos e95; + public rankPos e96; + public rankPos e97; + public rankPos e98; + public rankPos e99; + public rankPos e100; + public rankPos e101; + public rankPos e102; + public rankPos e103; + public rankPos e104; + public rankPos e105; + public rankPos e106; + public rankPos e107; + public rankPos e108; + public rankPos e109; + public rankPos e110; + public rankPos e111; + public rankPos e112; + public rankPos e113; + public rankPos e114; + public rankPos e115; + public rankPos e116; + public rankPos e117; + public rankPos e118; + public rankPos e119; + public rankPos e120; + public rankPos e121; + public rankPos e122; + public rankPos e123; + public rankPos e124; + public rankPos e125; + public rankPos e126; + public rankPos e127; + public rankPos e128; + public rankPos e129; + public rankPos e130; + public rankPos e131; + public rankPos e132; + public rankPos e133; + public rankPos e134; + public rankPos e135; + public rankPos e136; + public rankPos e137; + public rankPos e138; + public rankPos e139; + public rankPos e140; + public rankPos e141; + public rankPos e142; + public rankPos e143; + public rankPos e144; + public rankPos e145; + public rankPos e146; + public rankPos e147; + public rankPos e148; + public rankPos e149; + public rankPos e150; + public rankPos e151; + public rankPos e152; + public rankPos e153; + public rankPos e154; + public rankPos e155; + public rankPos e156; + public rankPos e157; + public rankPos e158; + public rankPos e159; + public rankPos e160; + public rankPos e161; + public rankPos e162; + public rankPos e163; + public rankPos e164; + public rankPos e165; + public rankPos e166; + public rankPos e167; + public rankPos e168; + public rankPos e169; + public rankPos e170; + public rankPos e171; + public rankPos e172; + public rankPos e173; + public rankPos e174; + public rankPos e175; + public rankPos e176; + public rankPos e177; + public rankPos e178; + public rankPos e179; + public rankPos e180; + public rankPos e181; + public rankPos e182; + public rankPos e183; + public rankPos e184; + public rankPos e185; + public rankPos e186; + public rankPos e187; + public rankPos e188; + public rankPos e189; + public rankPos e190; + public rankPos e191; + } +#endif +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_compress_tables_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_compress_tables_t.cs new file mode 100644 index 000000000..6e6e12c09 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_compress_tables_t.cs @@ -0,0 +1,280 @@ +using System.Runtime.CompilerServices; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct HUF_compress_tables_t +{ + public fixed uint count[256]; + public _CTable_e__FixedBuffer CTable; + public _wksps_e__Union wksps; + +#if NET8_0_OR_GREATER + [InlineArray(257)] + public unsafe struct _CTable_e__FixedBuffer + { + public nuint e0; + } + +#else + public unsafe struct _CTable_e__FixedBuffer + { + public nuint e0; + public nuint e1; + public nuint e2; + public nuint e3; + public nuint e4; + public nuint e5; + public nuint e6; + public nuint e7; + public nuint e8; + public nuint e9; + public nuint e10; + public nuint e11; + public nuint e12; + public nuint e13; + public nuint e14; + public nuint e15; + public nuint e16; + public nuint e17; + public nuint e18; + public nuint e19; + public nuint e20; + public nuint e21; + public nuint e22; + public nuint e23; + public nuint e24; + public nuint e25; + public nuint e26; + public nuint e27; + public nuint e28; + public nuint e29; + public nuint e30; + public nuint e31; + public nuint e32; + public nuint e33; + public nuint e34; + public nuint e35; + public nuint e36; + public nuint e37; + public nuint e38; + public nuint e39; + public nuint e40; + public nuint e41; + public nuint e42; + public nuint e43; + public nuint e44; + public nuint e45; + public nuint e46; + public nuint e47; + public nuint e48; + public nuint e49; + public nuint e50; + public nuint e51; + public nuint e52; + public nuint e53; + public nuint e54; + public nuint e55; + public nuint e56; + public nuint e57; + public nuint e58; + public nuint e59; + public nuint e60; + public nuint e61; + public nuint e62; + public nuint e63; + public nuint e64; + public nuint e65; + public nuint e66; + public nuint e67; + public nuint e68; + public nuint e69; + public nuint e70; + public nuint e71; + public nuint e72; + public nuint e73; + public nuint e74; + public nuint e75; + public nuint e76; + public nuint e77; + public nuint e78; + public nuint e79; + public nuint e80; + public nuint e81; + public nuint e82; + public nuint e83; + public nuint e84; + public nuint e85; + public nuint e86; + public nuint e87; + public nuint e88; + public nuint e89; + public nuint e90; + public nuint e91; + public nuint e92; + public nuint e93; + public nuint e94; + public nuint e95; + public nuint e96; + public nuint e97; + public nuint e98; + public nuint e99; + public nuint e100; + public nuint e101; + public nuint e102; + public nuint e103; + public nuint e104; + public nuint e105; + public nuint e106; + public nuint e107; + public nuint e108; + public nuint e109; + public nuint e110; + public nuint e111; + public nuint e112; + public nuint e113; + public nuint e114; + public nuint e115; + public nuint e116; + public nuint e117; + public nuint e118; + public nuint e119; + public nuint e120; + public nuint e121; + public nuint e122; + public nuint e123; + public nuint e124; + public nuint e125; + public nuint e126; + public nuint e127; + public nuint e128; + public nuint e129; + public nuint e130; + public nuint e131; + public nuint e132; + public nuint e133; + public nuint e134; + public nuint e135; + public nuint e136; + public nuint e137; + public nuint e138; + public nuint e139; + public nuint e140; + public nuint e141; + public nuint e142; + public nuint e143; + public nuint e144; + public nuint e145; + public nuint e146; + public nuint e147; + public nuint e148; + public nuint e149; + public nuint e150; + public nuint e151; + public nuint e152; + public nuint e153; + public nuint e154; + public nuint e155; + public nuint e156; + public nuint e157; + public nuint e158; + public nuint e159; + public nuint e160; + public nuint e161; + public nuint e162; + public nuint e163; + public nuint e164; + public nuint e165; + public nuint e166; + public nuint e167; + public nuint e168; + public nuint e169; + public nuint e170; + public nuint e171; + public nuint e172; + public nuint e173; + public nuint e174; + public nuint e175; + public nuint e176; + public nuint e177; + public nuint e178; + public nuint e179; + public nuint e180; + public nuint e181; + public nuint e182; + public nuint e183; + public nuint e184; + public nuint e185; + public nuint e186; + public nuint e187; + public nuint e188; + public nuint e189; + public nuint e190; + public nuint e191; + public nuint e192; + public nuint e193; + public nuint e194; + public nuint e195; + public nuint e196; + public nuint e197; + public nuint e198; + public nuint e199; + public nuint e200; + public nuint e201; + public nuint e202; + public nuint e203; + public nuint e204; + public nuint e205; + public nuint e206; + public nuint e207; + public nuint e208; + public nuint e209; + public nuint e210; + public nuint e211; + public nuint e212; + public nuint e213; + public nuint e214; + public nuint e215; + public nuint e216; + public nuint e217; + public nuint e218; + public nuint e219; + public nuint e220; + public nuint e221; + public nuint e222; + public nuint e223; + public nuint e224; + public nuint e225; + public nuint e226; + public nuint e227; + public nuint e228; + public nuint e229; + public nuint e230; + public nuint e231; + public nuint e232; + public nuint e233; + public nuint e234; + public nuint e235; + public nuint e236; + public nuint e237; + public nuint e238; + public nuint e239; + public nuint e240; + public nuint e241; + public nuint e242; + public nuint e243; + public nuint e244; + public nuint e245; + public nuint e246; + public nuint e247; + public nuint e248; + public nuint e249; + public nuint e250; + public nuint e251; + public nuint e252; + public nuint e253; + public nuint e254; + public nuint e255; + public nuint e256; + } +#endif +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_flags_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_flags_e.cs new file mode 100644 index 000000000..a38bc711a --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_flags_e.cs @@ -0,0 +1,44 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + * Huffman flags bitset. + * For all flags, 0 is the default value. + */ +public enum HUF_flags_e +{ + /** + * If compiled with DYNAMIC_BMI2: Set flag only if the CPU supports BMI2 at runtime. + * Otherwise: Ignored. + */ + HUF_flags_bmi2 = 1 << 0, + + /** + * If set: Test possible table depths to find the one that produces the smallest header + encoded size. + * If unset: Use heuristic to find the table depth. + */ + HUF_flags_optimalDepth = 1 << 1, + + /** + * If set: If the previous table can encode the input, always reuse the previous table. + * If unset: If the previous table can encode the input, reuse the previous table if it results in a smaller output. + */ + HUF_flags_preferRepeat = 1 << 2, + + /** + * If set: Sample the input and check if the sample is uncompressible, if it is then don't attempt to compress. + * If unset: Always histogram the entire input. + */ + HUF_flags_suspectUncompressible = 1 << 3, + + /** + * If set: Don't use assembly implementations + * If unset: Allow using assembly implementations + */ + HUF_flags_disableAsm = 1 << 4, + + /** + * If set: Don't use the fast decoding loop, always use the fallback decoding loop. + * If unset: Use the fast decoding loop when possible. + */ + HUF_flags_disableFast = 1 << 5, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_nbStreams_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_nbStreams_e.cs new file mode 100644 index 000000000..ff7e26e7b --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_nbStreams_e.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum HUF_nbStreams_e +{ + HUF_singleStream, + HUF_fourStreams, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_repeat.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_repeat.cs new file mode 100644 index 000000000..5ab8b1da1 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HUF_repeat.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum HUF_repeat +{ + /**< Cannot use the previous table */ + HUF_repeat_none, + + /**< Can use the previous table but it must be checked. Note : The previous table must have been constructed by HUF_compress{1, 4}X_repeat */ + HUF_repeat_check, + + /**< Can use the previous table and it is assumed to be valid */ + HUF_repeat_valid, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Hist.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Hist.cs new file mode 100644 index 000000000..10a433ce0 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Hist.cs @@ -0,0 +1,273 @@ +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /* --- Error management --- */ + private static bool HIST_isError(nuint code) + { + return ERR_isError(code); + } + + /*-************************************************************** + * Histogram functions + ****************************************************************/ + private static void HIST_add(uint* count, void* src, nuint srcSize) + { + byte* ip = (byte*)src; + byte* end = ip + srcSize; + while (ip < end) + { + count[*ip++]++; + } + } + + /*! HIST_count_simple() : + * Same as HIST_countFast(), this function is unsafe, + * and will segfault if any value within `src` is `> *maxSymbolValuePtr`. + * It is also a bit slower for large inputs. + * However, it does not need any additional memory (not even on stack). + * @return : count of the most frequent symbol. + * Note this function doesn't produce any error (i.e. it must succeed). + */ + private static uint HIST_count_simple( + uint* count, + uint* maxSymbolValuePtr, + void* src, + nuint srcSize + ) + { + byte* ip = (byte*)src; + byte* end = ip + srcSize; + uint maxSymbolValue = *maxSymbolValuePtr; + uint largestCount = 0; + memset(count, 0, (maxSymbolValue + 1) * sizeof(uint)); + if (srcSize == 0) + { + *maxSymbolValuePtr = 0; + return 0; + } + + while (ip < end) + { + assert(*ip <= maxSymbolValue); + count[*ip++]++; + } + + while (count[maxSymbolValue] == 0) + maxSymbolValue--; + *maxSymbolValuePtr = maxSymbolValue; + { + uint s; + for (s = 0; s <= maxSymbolValue; s++) + if (count[s] > largestCount) + largestCount = count[s]; + } + + return largestCount; + } + + /* HIST_count_parallel_wksp() : + * store histogram into 4 intermediate tables, recombined at the end. + * this design makes better use of OoO cpus, + * and is noticeably faster when some values are heavily repeated. + * But it needs some additional workspace for intermediate tables. + * `workSpace` must be a U32 table of size >= HIST_WKSP_SIZE_U32. + * @return : largest histogram frequency, + * or an error code (notably when histogram's alphabet is larger than *maxSymbolValuePtr) */ + private static nuint HIST_count_parallel_wksp( + uint* count, + uint* maxSymbolValuePtr, + void* source, + nuint sourceSize, + HIST_checkInput_e check, + uint* workSpace + ) + { + byte* ip = (byte*)source; + byte* iend = ip + sourceSize; + nuint countSize = (*maxSymbolValuePtr + 1) * sizeof(uint); + uint max = 0; + uint* Counting1 = workSpace; + uint* Counting2 = Counting1 + 256; + uint* Counting3 = Counting2 + 256; + uint* Counting4 = Counting3 + 256; + assert(*maxSymbolValuePtr <= 255); + if (sourceSize == 0) + { + memset(count, 0, (uint)countSize); + *maxSymbolValuePtr = 0; + return 0; + } + + memset(workSpace, 0, 4 * 256 * sizeof(uint)); + { + uint cached = MEM_read32(ip); + ip += 4; + while (ip < iend - 15) + { + uint c = cached; + cached = MEM_read32(ip); + ip += 4; + Counting1[(byte)c]++; + Counting2[(byte)(c >> 8)]++; + Counting3[(byte)(c >> 16)]++; + Counting4[c >> 24]++; + c = cached; + cached = MEM_read32(ip); + ip += 4; + Counting1[(byte)c]++; + Counting2[(byte)(c >> 8)]++; + Counting3[(byte)(c >> 16)]++; + Counting4[c >> 24]++; + c = cached; + cached = MEM_read32(ip); + ip += 4; + Counting1[(byte)c]++; + Counting2[(byte)(c >> 8)]++; + Counting3[(byte)(c >> 16)]++; + Counting4[c >> 24]++; + c = cached; + cached = MEM_read32(ip); + ip += 4; + Counting1[(byte)c]++; + Counting2[(byte)(c >> 8)]++; + Counting3[(byte)(c >> 16)]++; + Counting4[c >> 24]++; + } + + ip -= 4; + } + + while (ip < iend) + Counting1[*ip++]++; + { + uint s; + for (s = 0; s < 256; s++) + { + Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s]; + if (Counting1[s] > max) + max = Counting1[s]; + } + } + + { + uint maxSymbolValue = 255; + while (Counting1[maxSymbolValue] == 0) + maxSymbolValue--; + if (check != default && maxSymbolValue > *maxSymbolValuePtr) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_maxSymbolValue_tooSmall)); + *maxSymbolValuePtr = maxSymbolValue; + memmove(count, Counting1, countSize); + } + + return max; + } + + /* HIST_countFast_wksp() : + * Same as HIST_countFast(), but using an externally provided scratch buffer. + * `workSpace` is a writable buffer which must be 4-bytes aligned, + * `workSpaceSize` must be >= HIST_WKSP_SIZE + */ + private static nuint HIST_countFast_wksp( + uint* count, + uint* maxSymbolValuePtr, + void* source, + nuint sourceSize, + void* workSpace, + nuint workSpaceSize + ) + { + if (sourceSize < 1500) + return HIST_count_simple(count, maxSymbolValuePtr, source, sourceSize); + if (((nuint)workSpace & 3) != 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + if (workSpaceSize < 1024 * sizeof(uint)) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_workSpace_tooSmall)); + return HIST_count_parallel_wksp( + count, + maxSymbolValuePtr, + source, + sourceSize, + HIST_checkInput_e.trustInput, + (uint*)workSpace + ); + } + + /* HIST_count_wksp() : + * Same as HIST_count(), but using an externally provided scratch buffer. + * `workSpace` size must be table of >= HIST_WKSP_SIZE_U32 unsigned */ + private static nuint HIST_count_wksp( + uint* count, + uint* maxSymbolValuePtr, + void* source, + nuint sourceSize, + void* workSpace, + nuint workSpaceSize + ) + { + if (((nuint)workSpace & 3) != 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + if (workSpaceSize < 1024 * sizeof(uint)) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_workSpace_tooSmall)); + if (*maxSymbolValuePtr < 255) + return HIST_count_parallel_wksp( + count, + maxSymbolValuePtr, + source, + sourceSize, + HIST_checkInput_e.checkMaxSymbolValue, + (uint*)workSpace + ); + *maxSymbolValuePtr = 255; + return HIST_countFast_wksp( + count, + maxSymbolValuePtr, + source, + sourceSize, + workSpace, + workSpaceSize + ); + } + + /* fast variant (unsafe : won't check if src contains values beyond count[] limit) */ + private static nuint HIST_countFast( + uint* count, + uint* maxSymbolValuePtr, + void* source, + nuint sourceSize + ) + { + uint* tmpCounters = stackalloc uint[1024]; + return HIST_countFast_wksp( + count, + maxSymbolValuePtr, + source, + sourceSize, + tmpCounters, + sizeof(uint) * 1024 + ); + } + + /*! HIST_count(): + * Provides the precise count of each byte within a table 'count'. + * 'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1). + * Updates *maxSymbolValuePtr with actual largest symbol value detected. + * @return : count of the most frequent symbol (which isn't identified). + * or an error code, which can be tested using HIST_isError(). + * note : if return == srcSize, there is only one symbol. + */ + private static nuint HIST_count(uint* count, uint* maxSymbolValuePtr, void* src, nuint srcSize) + { + uint* tmpCounters = stackalloc uint[1024]; + return HIST_count_wksp( + count, + maxSymbolValuePtr, + src, + srcSize, + tmpCounters, + sizeof(uint) * 1024 + ); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HufCompress.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HufCompress.cs new file mode 100644 index 000000000..785c81437 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HufCompress.cs @@ -0,0 +1,1825 @@ +using System.Runtime.CompilerServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + private static void* HUF_alignUpWorkspace(void* workspace, nuint* workspaceSizePtr, nuint align) + { + nuint mask = align - 1; + nuint rem = (nuint)workspace & mask; + nuint add = align - rem & mask; + byte* aligned = (byte*)workspace + add; + assert((align & align - 1) == 0); + assert(align <= 8); + if (*workspaceSizePtr >= add) + { + assert(add < align); + assert(((nuint)aligned & mask) == 0); + *workspaceSizePtr -= add; + return aligned; + } + else + { + *workspaceSizePtr = 0; + return null; + } + } + + private static nuint HUF_compressWeights( + void* dst, + nuint dstSize, + void* weightTable, + nuint wtSize, + void* workspace, + nuint workspaceSize + ) + { + byte* ostart = (byte*)dst; + byte* op = ostart; + byte* oend = ostart + dstSize; + uint maxSymbolValue = 12; + uint tableLog = 6; + HUF_CompressWeightsWksp* wksp = (HUF_CompressWeightsWksp*)HUF_alignUpWorkspace( + workspace, + &workspaceSize, + sizeof(uint) + ); + if (workspaceSize < (nuint)sizeof(HUF_CompressWeightsWksp)) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + if (wtSize <= 1) + return 0; + { + /* never fails */ + uint maxCount = HIST_count_simple(wksp->count, &maxSymbolValue, weightTable, wtSize); + if (maxCount == wtSize) + return 1; + if (maxCount == 1) + return 0; + } + + tableLog = FSE_optimalTableLog(tableLog, wtSize, maxSymbolValue); + { + /* useLowProbCount */ + nuint _var_err__ = FSE_normalizeCount( + wksp->norm, + tableLog, + wksp->count, + wtSize, + maxSymbolValue, + 0 + ); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + { + nuint hSize = FSE_writeNCount( + op, + (nuint)(oend - op), + wksp->norm, + maxSymbolValue, + tableLog + ); + if (ERR_isError(hSize)) + return hSize; + op += hSize; + } + + { + /* Compress */ + nuint _var_err__ = FSE_buildCTable_wksp( + wksp->CTable, + wksp->norm, + maxSymbolValue, + tableLog, + wksp->scratchBuffer, + sizeof(uint) * 41 + ); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + { + nuint cSize = FSE_compress_usingCTable( + op, + (nuint)(oend - op), + weightTable, + wtSize, + wksp->CTable + ); + if (ERR_isError(cSize)) + return cSize; + if (cSize == 0) + return 0; + op += cSize; + } + + return (nuint)(op - ostart); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint HUF_getNbBits(nuint elt) + { + return elt & 0xFF; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint HUF_getNbBitsFast(nuint elt) + { + return elt; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint HUF_getValue(nuint elt) + { + return elt & ~(nuint)0xFF; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint HUF_getValueFast(nuint elt) + { + return elt; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void HUF_setNbBits(nuint* elt, nuint nbBits) + { + assert(nbBits <= 12); + *elt = nbBits; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void HUF_setValue(nuint* elt, nuint value) + { + nuint nbBits = HUF_getNbBits(*elt); + if (nbBits > 0) + { + assert(value >> (int)nbBits == 0); + *elt |= value << (int)((nuint)(sizeof(nuint) * 8) - nbBits); + } + } + + /** HUF_readCTableHeader() : + * @returns The header from the CTable specifying the tableLog and the maxSymbolValue. + */ + private static HUF_CTableHeader HUF_readCTableHeader(nuint* ctable) + { + HUF_CTableHeader header; + memcpy(&header, ctable, (uint)sizeof(nuint)); + return header; + } + + private static void HUF_writeCTableHeader(nuint* ctable, uint tableLog, uint maxSymbolValue) + { + HUF_CTableHeader header; + memset(&header, 0, (uint)sizeof(nuint)); + assert(tableLog < 256); + header.tableLog = (byte)tableLog; + assert(maxSymbolValue < 256); + header.maxSymbolValue = (byte)maxSymbolValue; + memcpy(ctable, &header, (uint)sizeof(nuint)); + } + + private static nuint HUF_writeCTable_wksp( + void* dst, + nuint maxDstSize, + nuint* CTable, + uint maxSymbolValue, + uint huffLog, + void* workspace, + nuint workspaceSize + ) + { + nuint* ct = CTable + 1; + byte* op = (byte*)dst; + uint n; + HUF_WriteCTableWksp* wksp = (HUF_WriteCTableWksp*)HUF_alignUpWorkspace( + workspace, + &workspaceSize, + sizeof(uint) + ); + assert(HUF_readCTableHeader(CTable).maxSymbolValue == maxSymbolValue); + assert(HUF_readCTableHeader(CTable).tableLog == huffLog); + if (workspaceSize < (nuint)sizeof(HUF_WriteCTableWksp)) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + if (maxSymbolValue > 255) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_maxSymbolValue_tooLarge)); + wksp->bitsToWeight[0] = 0; + for (n = 1; n < huffLog + 1; n++) + wksp->bitsToWeight[n] = (byte)(huffLog + 1 - n); + for (n = 0; n < maxSymbolValue; n++) + wksp->huffWeight[n] = wksp->bitsToWeight[HUF_getNbBits(ct[n])]; + if (maxDstSize < 1) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + { + nuint hSize = HUF_compressWeights( + op + 1, + maxDstSize - 1, + wksp->huffWeight, + maxSymbolValue, + &wksp->wksp, + (nuint)sizeof(HUF_CompressWeightsWksp) + ); + if (ERR_isError(hSize)) + return hSize; + if (hSize > 1 && hSize < maxSymbolValue / 2) + { + op[0] = (byte)hSize; + return hSize + 1; + } + } + + if (maxSymbolValue > 256 - 128) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + if ((maxSymbolValue + 1) / 2 + 1 > maxDstSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + op[0] = (byte)(128 + (maxSymbolValue - 1)); + wksp->huffWeight[maxSymbolValue] = 0; + for (n = 0; n < maxSymbolValue; n += 2) + op[n / 2 + 1] = (byte)((wksp->huffWeight[n] << 4) + wksp->huffWeight[n + 1]); + return (maxSymbolValue + 1) / 2 + 1; + } + + /** HUF_readCTable() : + * Loading a CTable saved with HUF_writeCTable() */ + private static nuint HUF_readCTable( + nuint* CTable, + uint* maxSymbolValuePtr, + void* src, + nuint srcSize, + uint* hasZeroWeights + ) + { + /* init not required, even though some static analyzer may complain */ + byte* huffWeight = stackalloc byte[256]; + /* large enough for values from 0 to 16 */ + uint* rankVal = stackalloc uint[13]; + uint tableLog = 0; + uint nbSymbols = 0; + nuint* ct = CTable + 1; + /* get symbol weights */ + nuint readSize = HUF_readStats( + huffWeight, + 255 + 1, + rankVal, + &nbSymbols, + &tableLog, + src, + srcSize + ); + if (ERR_isError(readSize)) + return readSize; + *hasZeroWeights = rankVal[0] > 0 ? 1U : 0U; + if (tableLog > 12) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)); + if (nbSymbols > *maxSymbolValuePtr + 1) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_maxSymbolValue_tooSmall)); + *maxSymbolValuePtr = nbSymbols - 1; + HUF_writeCTableHeader(CTable, tableLog, *maxSymbolValuePtr); + { + uint n, + nextRankStart = 0; + for (n = 1; n <= tableLog; n++) + { + uint curr = nextRankStart; + nextRankStart += rankVal[n] << (int)(n - 1); + rankVal[n] = curr; + } + } + + { + uint n; + for (n = 0; n < nbSymbols; n++) + { + uint w = huffWeight[n]; + HUF_setNbBits(ct + n, (nuint)((byte)(tableLog + 1 - w) & -(w != 0 ? 1 : 0))); + } + } + + { + ushort* nbPerRank = stackalloc ushort[14]; + /* support w=0=>n=tableLog+1 */ + memset(nbPerRank, 0, sizeof(ushort) * 14); + ushort* valPerRank = stackalloc ushort[14]; + memset(valPerRank, 0, sizeof(ushort) * 14); + { + uint n; + for (n = 0; n < nbSymbols; n++) + nbPerRank[HUF_getNbBits(ct[n])]++; + } + + valPerRank[tableLog + 1] = 0; + { + ushort min = 0; + /* start at n=tablelog <-> w=1 */ + uint n; + for (n = tableLog; n > 0; n--) + { + valPerRank[n] = min; + min += nbPerRank[n]; + min >>= 1; + } + } + + { + uint n; + for (n = 0; n < nbSymbols; n++) + HUF_setValue(ct + n, valPerRank[HUF_getNbBits(ct[n])]++); + } + } + + return readSize; + } + + /** HUF_getNbBitsFromCTable() : + * Read nbBits from CTable symbolTable, for symbol `symbolValue` presumed <= HUF_SYMBOLVALUE_MAX + * Note 1 : If symbolValue > HUF_readCTableHeader(symbolTable).maxSymbolValue, returns 0 + * Note 2 : is not inlined, as HUF_CElt definition is private + */ + private static uint HUF_getNbBitsFromCTable(nuint* CTable, uint symbolValue) + { + nuint* ct = CTable + 1; + assert(symbolValue <= 255); + if (symbolValue > HUF_readCTableHeader(CTable).maxSymbolValue) + return 0; + return (uint)HUF_getNbBits(ct[symbolValue]); + } + + /** + * HUF_setMaxHeight(): + * Try to enforce @targetNbBits on the Huffman tree described in @huffNode. + * + * It attempts to convert all nodes with nbBits > @targetNbBits + * to employ @targetNbBits instead. Then it adjusts the tree + * so that it remains a valid canonical Huffman tree. + * + * @pre The sum of the ranks of each symbol == 2^largestBits, + * where largestBits == huffNode[lastNonNull].nbBits. + * @post The sum of the ranks of each symbol == 2^largestBits, + * where largestBits is the return value (expected <= targetNbBits). + * + * @param huffNode The Huffman tree modified in place to enforce targetNbBits. + * It's presumed sorted, from most frequent to rarest symbol. + * @param lastNonNull The symbol with the lowest count in the Huffman tree. + * @param targetNbBits The allowed number of bits, which the Huffman tree + * may not respect. After this function the Huffman tree will + * respect targetNbBits. + * @return The maximum number of bits of the Huffman tree after adjustment. + */ + private static uint HUF_setMaxHeight(nodeElt_s* huffNode, uint lastNonNull, uint targetNbBits) + { + uint largestBits = huffNode[lastNonNull].nbBits; + if (largestBits <= targetNbBits) + return largestBits; + { + int totalCost = 0; + uint baseCost = (uint)(1 << (int)(largestBits - targetNbBits)); + int n = (int)lastNonNull; + while (huffNode[n].nbBits > targetNbBits) + { + totalCost += (int)(baseCost - (uint)(1 << (int)(largestBits - huffNode[n].nbBits))); + huffNode[n].nbBits = (byte)targetNbBits; + n--; + } + + assert(huffNode[n].nbBits <= targetNbBits); + while (huffNode[n].nbBits == targetNbBits) + --n; + assert(((uint)totalCost & baseCost - 1) == 0); + totalCost >>= (int)(largestBits - targetNbBits); + assert(totalCost > 0); + { + const uint noSymbol = 0xF0F0F0F0; + uint* rankLast = stackalloc uint[14]; + memset(rankLast, 0xF0, sizeof(uint) * 14); + { + uint currentNbBits = targetNbBits; + int pos; + for (pos = n; pos >= 0; pos--) + { + if (huffNode[pos].nbBits >= currentNbBits) + continue; + currentNbBits = huffNode[pos].nbBits; + rankLast[targetNbBits - currentNbBits] = (uint)pos; + } + } + + while (totalCost > 0) + { + /* Try to reduce the next power of 2 above totalCost because we + * gain back half the rank. + */ + uint nBitsToDecrease = ZSTD_highbit32((uint)totalCost) + 1; + for (; nBitsToDecrease > 1; nBitsToDecrease--) + { + uint highPos = rankLast[nBitsToDecrease]; + uint lowPos = rankLast[nBitsToDecrease - 1]; + if (highPos == noSymbol) + continue; + if (lowPos == noSymbol) + break; + { + uint highTotal = huffNode[highPos].count; + uint lowTotal = 2 * huffNode[lowPos].count; + if (highTotal <= lowTotal) + break; + } + } + + assert(rankLast[nBitsToDecrease] != noSymbol || nBitsToDecrease == 1); + while (nBitsToDecrease <= 12 && rankLast[nBitsToDecrease] == noSymbol) + nBitsToDecrease++; + assert(rankLast[nBitsToDecrease] != noSymbol); + totalCost -= 1 << (int)(nBitsToDecrease - 1); + huffNode[rankLast[nBitsToDecrease]].nbBits++; + if (rankLast[nBitsToDecrease - 1] == noSymbol) + rankLast[nBitsToDecrease - 1] = rankLast[nBitsToDecrease]; + if (rankLast[nBitsToDecrease] == 0) + rankLast[nBitsToDecrease] = noSymbol; + else + { + rankLast[nBitsToDecrease]--; + if ( + huffNode[rankLast[nBitsToDecrease]].nbBits + != targetNbBits - nBitsToDecrease + ) + rankLast[nBitsToDecrease] = noSymbol; + } + } + + while (totalCost < 0) + { + if (rankLast[1] == noSymbol) + { + while (huffNode[n].nbBits == targetNbBits) + n--; + huffNode[n + 1].nbBits--; + assert(n >= 0); + rankLast[1] = (uint)(n + 1); + totalCost++; + continue; + } + + huffNode[rankLast[1] + 1].nbBits--; + rankLast[1]++; + totalCost++; + } + } + } + + return targetNbBits; + } + + /* Return the appropriate bucket index for a given count. See definition of + * RANK_POSITION_DISTINCT_COUNT_CUTOFF for explanation of bucketing strategy. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint HUF_getIndex(uint count) + { + return count < 192 - 1 - 32 - 1 + ZSTD_highbit32(192 - 1 - 32 - 1) + ? count + : ZSTD_highbit32(count) + (192 - 1 - 32 - 1); + } + + /* Helper swap function for HUF_quickSortPartition() */ + private static void HUF_swapNodes(nodeElt_s* a, nodeElt_s* b) + { + nodeElt_s tmp = *a; + *a = *b; + *b = tmp; + } + + /* Returns 0 if the huffNode array is not sorted by descending count */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int HUF_isSorted(nodeElt_s* huffNode, uint maxSymbolValue1) + { + uint i; + for (i = 1; i < maxSymbolValue1; ++i) + { + if (huffNode[i].count > huffNode[i - 1].count) + { + return 0; + } + } + + return 1; + } + + /* Insertion sort by descending order */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void HUF_insertionSort(nodeElt_s* huffNode, int low, int high) + { + int i; + int size = high - low + 1; + huffNode += low; + for (i = 1; i < size; ++i) + { + nodeElt_s key = huffNode[i]; + int j = i - 1; + while (j >= 0 && huffNode[j].count < key.count) + { + huffNode[j + 1] = huffNode[j]; + j--; + } + + huffNode[j + 1] = key; + } + } + + /* Pivot helper function for quicksort. */ + private static int HUF_quickSortPartition(nodeElt_s* arr, int low, int high) + { + /* Simply select rightmost element as pivot. "Better" selectors like + * median-of-three don't experimentally appear to have any benefit. + */ + uint pivot = arr[high].count; + int i = low - 1; + int j = low; + for (; j < high; j++) + { + if (arr[j].count > pivot) + { + i++; + HUF_swapNodes(&arr[i], &arr[j]); + } + } + + HUF_swapNodes(&arr[i + 1], &arr[high]); + return i + 1; + } + + /* Classic quicksort by descending with partially iterative calls + * to reduce worst case callstack size. + */ + private static void HUF_simpleQuickSort(nodeElt_s* arr, int low, int high) + { + const int kInsertionSortThreshold = 8; + if (high - low < kInsertionSortThreshold) + { + HUF_insertionSort(arr, low, high); + return; + } + + while (low < high) + { + int idx = HUF_quickSortPartition(arr, low, high); + if (idx - low < high - idx) + { + HUF_simpleQuickSort(arr, low, idx - 1); + low = idx + 1; + } + else + { + HUF_simpleQuickSort(arr, idx + 1, high); + high = idx - 1; + } + } + } + + /** + * HUF_sort(): + * Sorts the symbols [0, maxSymbolValue] by count[symbol] in decreasing order. + * This is a typical bucket sorting strategy that uses either quicksort or insertion sort to sort each bucket. + * + * @param[out] huffNode Sorted symbols by decreasing count. Only members `.count` and `.byte` are filled. + * Must have (maxSymbolValue + 1) entries. + * @param[in] count Histogram of the symbols. + * @param[in] maxSymbolValue Maximum symbol value. + * @param rankPosition This is a scratch workspace. Must have RANK_POSITION_TABLE_SIZE entries. + */ + private static void HUF_sort( + nodeElt_s* huffNode, + uint* count, + uint maxSymbolValue, + rankPos* rankPosition + ) + { + uint n; + uint maxSymbolValue1 = maxSymbolValue + 1; + memset(rankPosition, 0, (uint)(sizeof(rankPos) * 192)); + for (n = 0; n < maxSymbolValue1; ++n) + { + uint lowerRank = HUF_getIndex(count[n]); + assert(lowerRank < 192 - 1); + rankPosition[lowerRank].@base++; + } + + assert(rankPosition[192 - 1].@base == 0); + for (n = 192 - 1; n > 0; --n) + { + rankPosition[n - 1].@base += rankPosition[n].@base; + rankPosition[n - 1].curr = rankPosition[n - 1].@base; + } + + for (n = 0; n < maxSymbolValue1; ++n) + { + uint c = count[n]; + uint r = HUF_getIndex(c) + 1; + uint pos = rankPosition[r].curr++; + assert(pos < maxSymbolValue1); + huffNode[pos].count = c; + huffNode[pos].@byte = (byte)n; + } + + for (n = 192 - 1 - 32 - 1 + ZSTD_highbit32(192 - 1 - 32 - 1); n < 192 - 1; ++n) + { + int bucketSize = rankPosition[n].curr - rankPosition[n].@base; + uint bucketStartIdx = rankPosition[n].@base; + if (bucketSize > 1) + { + assert(bucketStartIdx < maxSymbolValue1); + HUF_simpleQuickSort(huffNode + bucketStartIdx, 0, bucketSize - 1); + } + } + + assert(HUF_isSorted(huffNode, maxSymbolValue1) != 0); + } + + /* HUF_buildTree(): + * Takes the huffNode array sorted by HUF_sort() and builds an unlimited-depth Huffman tree. + * + * @param huffNode The array sorted by HUF_sort(). Builds the Huffman tree in this array. + * @param maxSymbolValue The maximum symbol value. + * @return The smallest node in the Huffman tree (by count). + */ + private static int HUF_buildTree(nodeElt_s* huffNode, uint maxSymbolValue) + { + nodeElt_s* huffNode0 = huffNode - 1; + int nonNullRank; + int lowS, + lowN; + int nodeNb = 255 + 1; + int n, + nodeRoot; + nonNullRank = (int)maxSymbolValue; + while (huffNode[nonNullRank].count == 0) + nonNullRank--; + lowS = nonNullRank; + nodeRoot = nodeNb + lowS - 1; + lowN = nodeNb; + huffNode[nodeNb].count = huffNode[lowS].count + huffNode[lowS - 1].count; + huffNode[lowS].parent = huffNode[lowS - 1].parent = (ushort)nodeNb; + nodeNb++; + lowS -= 2; + for (n = nodeNb; n <= nodeRoot; n++) + huffNode[n].count = 1U << 30; + huffNode0[0].count = 1U << 31; + while (nodeNb <= nodeRoot) + { + int n1 = huffNode[lowS].count < huffNode[lowN].count ? lowS-- : lowN++; + int n2 = huffNode[lowS].count < huffNode[lowN].count ? lowS-- : lowN++; + huffNode[nodeNb].count = huffNode[n1].count + huffNode[n2].count; + huffNode[n1].parent = huffNode[n2].parent = (ushort)nodeNb; + nodeNb++; + } + + huffNode[nodeRoot].nbBits = 0; + for (n = nodeRoot - 1; n >= 255 + 1; n--) + huffNode[n].nbBits = (byte)(huffNode[huffNode[n].parent].nbBits + 1); + for (n = 0; n <= nonNullRank; n++) + huffNode[n].nbBits = (byte)(huffNode[huffNode[n].parent].nbBits + 1); + return nonNullRank; + } + + /** + * HUF_buildCTableFromTree(): + * Build the CTable given the Huffman tree in huffNode. + * + * @param[out] CTable The output Huffman CTable. + * @param huffNode The Huffman tree. + * @param nonNullRank The last and smallest node in the Huffman tree. + * @param maxSymbolValue The maximum symbol value. + * @param maxNbBits The exact maximum number of bits used in the Huffman tree. + */ + private static void HUF_buildCTableFromTree( + nuint* CTable, + nodeElt_s* huffNode, + int nonNullRank, + uint maxSymbolValue, + uint maxNbBits + ) + { + nuint* ct = CTable + 1; + /* fill result into ctable (val, nbBits) */ + int n; + ushort* nbPerRank = stackalloc ushort[13]; + memset(nbPerRank, 0, sizeof(ushort) * 13); + ushort* valPerRank = stackalloc ushort[13]; + memset(valPerRank, 0, sizeof(ushort) * 13); + int alphabetSize = (int)(maxSymbolValue + 1); + for (n = 0; n <= nonNullRank; n++) + nbPerRank[huffNode[n].nbBits]++; + { + ushort min = 0; + for (n = (int)maxNbBits; n > 0; n--) + { + valPerRank[n] = min; + min += nbPerRank[n]; + min >>= 1; + } + } + + for (n = 0; n < alphabetSize; n++) + HUF_setNbBits(ct + huffNode[n].@byte, huffNode[n].nbBits); + for (n = 0; n < alphabetSize; n++) + HUF_setValue(ct + n, valPerRank[HUF_getNbBits(ct[n])]++); + HUF_writeCTableHeader(CTable, maxNbBits, maxSymbolValue); + } + + private static nuint HUF_buildCTable_wksp( + nuint* CTable, + uint* count, + uint maxSymbolValue, + uint maxNbBits, + void* workSpace, + nuint wkspSize + ) + { + HUF_buildCTable_wksp_tables* wksp_tables = + (HUF_buildCTable_wksp_tables*)HUF_alignUpWorkspace(workSpace, &wkspSize, sizeof(uint)); + nodeElt_s* huffNode0 = &wksp_tables->huffNodeTbl.e0; + nodeElt_s* huffNode = huffNode0 + 1; + int nonNullRank; + if (wkspSize < (nuint)sizeof(HUF_buildCTable_wksp_tables)) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_workSpace_tooSmall)); + if (maxNbBits == 0) + maxNbBits = 11; + if (maxSymbolValue > 255) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_maxSymbolValue_tooLarge)); + memset(huffNode0, 0, (uint)(sizeof(nodeElt_s) * 512)); + HUF_sort(huffNode, count, maxSymbolValue, &wksp_tables->rankPosition.e0); + nonNullRank = HUF_buildTree(huffNode, maxSymbolValue); + maxNbBits = HUF_setMaxHeight(huffNode, (uint)nonNullRank, maxNbBits); + if (maxNbBits > 12) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + HUF_buildCTableFromTree(CTable, huffNode, nonNullRank, maxSymbolValue, maxNbBits); + return maxNbBits; + } + + private static nuint HUF_estimateCompressedSize(nuint* CTable, uint* count, uint maxSymbolValue) + { + nuint* ct = CTable + 1; + nuint nbBits = 0; + int s; + for (s = 0; s <= (int)maxSymbolValue; ++s) + { + nbBits += HUF_getNbBits(ct[s]) * count[s]; + } + + return nbBits >> 3; + } + + private static int HUF_validateCTable(nuint* CTable, uint* count, uint maxSymbolValue) + { + HUF_CTableHeader header = HUF_readCTableHeader(CTable); + nuint* ct = CTable + 1; + int bad = 0; + int s; + assert(header.tableLog <= 12); + if (header.maxSymbolValue < maxSymbolValue) + return 0; + for (s = 0; s <= (int)maxSymbolValue; ++s) + { + bad |= count[s] != 0 && HUF_getNbBits(ct[s]) == 0 ? 1 : 0; + } + + return bad == 0 ? 1 : 0; + } + + private static nuint HUF_compressBound(nuint size) + { + return 129 + (size + (size >> 8) + 8); + } + + /**! HUF_initCStream(): + * Initializes the bitstream. + * @returns 0 or an error code. + */ + private static nuint HUF_initCStream(ref HUF_CStream_t bitC, void* startPtr, nuint dstCapacity) + { + bitC = new HUF_CStream_t + { + startPtr = (byte*)startPtr, + ptr = (byte*)startPtr, + endPtr = (byte*)startPtr + dstCapacity - sizeof(nuint), + }; + if (dstCapacity <= (nuint)sizeof(nuint)) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + return 0; + } + + /*! HUF_addBits(): + * Adds the symbol stored in HUF_CElt elt to the bitstream. + * + * @param elt The element we're adding. This is a (nbBits, value) pair. + * See the HUF_CStream_t docs for the format. + * @param idx Insert into the bitstream at this idx. + * @param kFast This is a template parameter. If the bitstream is guaranteed + * to have at least 4 unused bits after this call it may be 1, + * otherwise it must be 0. HUF_addBits() is faster when fast is set. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void HUF_addBits( + ref nuint bitC_bitContainer_e0, + ref nuint bitC_bitPos_e0, + nuint elt, + int kFast + ) + { + assert(HUF_getNbBits(elt) <= 12); + bitC_bitContainer_e0 >>= (int)HUF_getNbBits(elt); + bitC_bitContainer_e0 |= kFast != 0 ? HUF_getValueFast(elt) : HUF_getValue(elt); + bitC_bitPos_e0 += HUF_getNbBitsFast(elt); + assert((bitC_bitPos_e0 & 0xFF) <= (nuint)(sizeof(nuint) * 8)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void HUF_zeroIndex1(ref nuint bitC_bitContainer_e1, ref nuint bitC_bitPos_e1) + { + bitC_bitContainer_e1 = 0; + bitC_bitPos_e1 = 0; + } + + /*! HUF_mergeIndex1() : + * Merges the bit container @ index 1 into the bit container @ index 0 + * and zeros the bit container @ index 1. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void HUF_mergeIndex1( + ref nuint bitC_bitContainer_e0, + ref nuint bitC_bitPos_e0, + ref nuint bitC_bitContainer_e1, + ref nuint bitC_bitPos_e1 + ) + { + assert((bitC_bitPos_e1 & 0xFF) < (nuint)(sizeof(nuint) * 8)); + bitC_bitContainer_e0 >>= (int)(bitC_bitPos_e1 & 0xFF); + bitC_bitContainer_e0 |= bitC_bitContainer_e1; + bitC_bitPos_e0 += bitC_bitPos_e1; + assert((bitC_bitPos_e0 & 0xFF) <= (nuint)(sizeof(nuint) * 8)); + } + + /*! HUF_flushBits() : + * Flushes the bits in the bit container @ index 0. + * + * @post bitPos will be < 8. + * @param kFast If kFast is set then we must know a-priori that + * the bit container will not overflow. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void HUF_flushBits( + ref nuint bitC_bitContainer_e0, + ref nuint bitC_bitPos_e0, + ref byte* bitC_ptr, + byte* bitC_endPtr, + int kFast + ) + { + /* The upper bits of bitPos are noisy, so we must mask by 0xFF. */ + nuint nbBits = bitC_bitPos_e0 & 0xFF; + nuint nbBytes = nbBits >> 3; + /* The top nbBits bits of bitContainer are the ones we need. */ + nuint bitContainer = bitC_bitContainer_e0 >> (int)((nuint)(sizeof(nuint) * 8) - nbBits); + bitC_bitPos_e0 &= 7; + assert(nbBits > 0); + assert(nbBits <= (nuint)(sizeof(nuint) * 8)); + assert(bitC_ptr <= bitC_endPtr); + MEM_writeLEST(bitC_ptr, bitContainer); + bitC_ptr += nbBytes; + assert(kFast == 0 || bitC_ptr <= bitC_endPtr); + if (kFast == 0 && bitC_ptr > bitC_endPtr) + bitC_ptr = bitC_endPtr; + } + + /*! HUF_endMark() + * @returns The Huffman stream end mark: A 1-bit value = 1. + */ + private static nuint HUF_endMark() + { + nuint endMark; + HUF_setNbBits(&endMark, 1); + HUF_setValue(&endMark, 1); + return endMark; + } + + /*! HUF_closeCStream() : + * @return Size of CStream, in bytes, + * or 0 if it could not fit into dstBuffer */ + private static nuint HUF_closeCStream(ref HUF_CStream_t bitC) + { + HUF_addBits(ref bitC.bitContainer.e0, ref bitC.bitPos.e0, HUF_endMark(), 0); + HUF_flushBits(ref bitC.bitContainer.e0, ref bitC.bitPos.e0, ref bitC.ptr, bitC.endPtr, 0); + { + nuint nbBits = bitC.bitPos.e0 & 0xFF; + if (bitC.ptr >= bitC.endPtr) + return 0; + return (nuint)(bitC.ptr - bitC.startPtr) + (nuint)(nbBits > 0 ? 1 : 0); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void HUF_encodeSymbol( + ref nuint bitCPtr_bitContainer_e0, + ref nuint bitCPtr_bitPos_e0, + uint symbol, + nuint* CTable, + int fast + ) + { + HUF_addBits(ref bitCPtr_bitContainer_e0, ref bitCPtr_bitPos_e0, CTable[symbol], fast); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void HUF_compress1X_usingCTable_internal_body_loop( + ref HUF_CStream_t bitC, + byte* ip, + nuint srcSize, + nuint* ct, + int kUnroll, + int kFastFlush, + int kLastFast + ) + { + byte* bitC_ptr = bitC.ptr; + byte* bitC_endPtr = bitC.endPtr; + nuint bitC_bitContainer_e0 = bitC.bitContainer.e0; + nuint bitC_bitPos_e0 = bitC.bitPos.e0; + nuint bitC_bitContainer_e1 = bitC.bitContainer.e1; + nuint bitC_bitPos_e1 = bitC.bitPos.e1; + /* Join to kUnroll */ + int n = (int)srcSize; + int rem = n % kUnroll; + if (rem > 0) + { + for (; rem > 0; --rem) + { + HUF_encodeSymbol(ref bitC_bitContainer_e0, ref bitC_bitPos_e0, ip[--n], ct, 0); + } + + HUF_flushBits( + ref bitC_bitContainer_e0, + ref bitC_bitPos_e0, + ref bitC_ptr, + bitC_endPtr, + kFastFlush + ); + } + + assert(n % kUnroll == 0); + if (n % (2 * kUnroll) != 0) + { + int u; + for (u = 1; u < kUnroll; ++u) + { + HUF_encodeSymbol(ref bitC_bitContainer_e0, ref bitC_bitPos_e0, ip[n - u], ct, 1); + } + + HUF_encodeSymbol( + ref bitC_bitContainer_e0, + ref bitC_bitPos_e0, + ip[n - kUnroll], + ct, + kLastFast + ); + HUF_flushBits( + ref bitC_bitContainer_e0, + ref bitC_bitPos_e0, + ref bitC_ptr, + bitC_endPtr, + kFastFlush + ); + n -= kUnroll; + } + + assert(n % (2 * kUnroll) == 0); + for (; n > 0; n -= 2 * kUnroll) + { + /* Encode kUnroll symbols into the bitstream @ index 0. */ + int u; + for (u = 1; u < kUnroll; ++u) + { + HUF_encodeSymbol(ref bitC_bitContainer_e0, ref bitC_bitPos_e0, ip[n - u], ct, 1); + } + + HUF_encodeSymbol( + ref bitC_bitContainer_e0, + ref bitC_bitPos_e0, + ip[n - kUnroll], + ct, + kLastFast + ); + HUF_flushBits( + ref bitC_bitContainer_e0, + ref bitC_bitPos_e0, + ref bitC_ptr, + bitC_endPtr, + kFastFlush + ); + HUF_zeroIndex1(ref bitC_bitContainer_e1, ref bitC_bitPos_e1); + for (u = 1; u < kUnroll; ++u) + { + HUF_encodeSymbol( + ref bitC_bitContainer_e1, + ref bitC_bitPos_e1, + ip[n - kUnroll - u], + ct, + 1 + ); + } + + HUF_encodeSymbol( + ref bitC_bitContainer_e1, + ref bitC_bitPos_e1, + ip[n - kUnroll - kUnroll], + ct, + kLastFast + ); + HUF_mergeIndex1( + ref bitC_bitContainer_e0, + ref bitC_bitPos_e0, + ref bitC_bitContainer_e1, + ref bitC_bitPos_e1 + ); + HUF_flushBits( + ref bitC_bitContainer_e0, + ref bitC_bitPos_e0, + ref bitC_ptr, + bitC_endPtr, + kFastFlush + ); + } + + assert(n == 0); + bitC.ptr = bitC_ptr; + bitC.endPtr = bitC_endPtr; + bitC.bitContainer.e0 = bitC_bitContainer_e0; + bitC.bitPos.e0 = bitC_bitPos_e0; + bitC.bitContainer.e1 = bitC_bitContainer_e1; + bitC.bitPos.e1 = bitC_bitPos_e1; + } + + /** + * Returns a tight upper bound on the output space needed by Huffman + * with 8 bytes buffer to handle over-writes. If the output is at least + * this large we don't need to do bounds checks during Huffman encoding. + */ + private static nuint HUF_tightCompressBound(nuint srcSize, nuint tableLog) + { + return (srcSize * tableLog >> 3) + 8; + } + + private static nuint HUF_compress1X_usingCTable_internal_body( + void* dst, + nuint dstSize, + void* src, + nuint srcSize, + nuint* CTable + ) + { + uint tableLog = HUF_readCTableHeader(CTable).tableLog; + nuint* ct = CTable + 1; + byte* ip = (byte*)src; + byte* ostart = (byte*)dst; + byte* oend = ostart + dstSize; + HUF_CStream_t bitC; + System.Runtime.CompilerServices.Unsafe.SkipInit(out bitC); + if (dstSize < 8) + return 0; + { + byte* op = ostart; + nuint initErr = HUF_initCStream(ref bitC, op, (nuint)(oend - op)); + if (ERR_isError(initErr)) + return 0; + } + + if (dstSize < HUF_tightCompressBound(srcSize, tableLog) || tableLog > 11) + HUF_compress1X_usingCTable_internal_body_loop( + ref bitC, + ip, + srcSize, + ct, + MEM_32bits ? 2 : 4, + 0, + 0 + ); + else + { + if (MEM_32bits) + { + switch (tableLog) + { + case 11: + HUF_compress1X_usingCTable_internal_body_loop( + ref bitC, + ip, + srcSize, + ct, + 2, + 1, + 0 + ); + break; + case 10: + case 9: + case 8: + HUF_compress1X_usingCTable_internal_body_loop( + ref bitC, + ip, + srcSize, + ct, + 2, + 1, + 1 + ); + break; + case 7: + default: + HUF_compress1X_usingCTable_internal_body_loop( + ref bitC, + ip, + srcSize, + ct, + 3, + 1, + 1 + ); + break; + } + } + else + { + switch (tableLog) + { + case 11: + HUF_compress1X_usingCTable_internal_body_loop( + ref bitC, + ip, + srcSize, + ct, + 5, + 1, + 0 + ); + break; + case 10: + HUF_compress1X_usingCTable_internal_body_loop( + ref bitC, + ip, + srcSize, + ct, + 5, + 1, + 1 + ); + break; + case 9: + HUF_compress1X_usingCTable_internal_body_loop( + ref bitC, + ip, + srcSize, + ct, + 6, + 1, + 0 + ); + break; + case 8: + HUF_compress1X_usingCTable_internal_body_loop( + ref bitC, + ip, + srcSize, + ct, + 7, + 1, + 0 + ); + break; + case 7: + HUF_compress1X_usingCTable_internal_body_loop( + ref bitC, + ip, + srcSize, + ct, + 8, + 1, + 0 + ); + break; + case 6: + default: + HUF_compress1X_usingCTable_internal_body_loop( + ref bitC, + ip, + srcSize, + ct, + 9, + 1, + 1 + ); + break; + } + } + } + + assert(bitC.ptr <= bitC.endPtr); + return HUF_closeCStream(ref bitC); + } + + private static nuint HUF_compress1X_usingCTable_internal( + void* dst, + nuint dstSize, + void* src, + nuint srcSize, + nuint* CTable, + int flags + ) + { + return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable); + } + + /* ====================== */ + /* single stream variants */ + /* ====================== */ + private static nuint HUF_compress1X_usingCTable( + void* dst, + nuint dstSize, + void* src, + nuint srcSize, + nuint* CTable, + int flags + ) + { + return HUF_compress1X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, flags); + } + + private static nuint HUF_compress4X_usingCTable_internal( + void* dst, + nuint dstSize, + void* src, + nuint srcSize, + nuint* CTable, + int flags + ) + { + /* first 3 segments */ + nuint segmentSize = (srcSize + 3) / 4; + byte* ip = (byte*)src; + byte* iend = ip + srcSize; + byte* ostart = (byte*)dst; + byte* oend = ostart + dstSize; + byte* op = ostart; + if (dstSize < 6 + 1 + 1 + 1 + 8) + return 0; + if (srcSize < 12) + return 0; + op += 6; + assert(op <= oend); + { + nuint cSize = HUF_compress1X_usingCTable_internal( + op, + (nuint)(oend - op), + ip, + segmentSize, + CTable, + flags + ); + if (ERR_isError(cSize)) + return cSize; + if (cSize == 0 || cSize > 65535) + return 0; + MEM_writeLE16(ostart, (ushort)cSize); + op += cSize; + } + + ip += segmentSize; + assert(op <= oend); + { + nuint cSize = HUF_compress1X_usingCTable_internal( + op, + (nuint)(oend - op), + ip, + segmentSize, + CTable, + flags + ); + if (ERR_isError(cSize)) + return cSize; + if (cSize == 0 || cSize > 65535) + return 0; + MEM_writeLE16(ostart + 2, (ushort)cSize); + op += cSize; + } + + ip += segmentSize; + assert(op <= oend); + { + nuint cSize = HUF_compress1X_usingCTable_internal( + op, + (nuint)(oend - op), + ip, + segmentSize, + CTable, + flags + ); + if (ERR_isError(cSize)) + return cSize; + if (cSize == 0 || cSize > 65535) + return 0; + MEM_writeLE16(ostart + 4, (ushort)cSize); + op += cSize; + } + + ip += segmentSize; + assert(op <= oend); + assert(ip <= iend); + { + nuint cSize = HUF_compress1X_usingCTable_internal( + op, + (nuint)(oend - op), + ip, + (nuint)(iend - ip), + CTable, + flags + ); + if (ERR_isError(cSize)) + return cSize; + if (cSize == 0 || cSize > 65535) + return 0; + op += cSize; + } + + return (nuint)(op - ostart); + } + + private static nuint HUF_compress4X_usingCTable( + void* dst, + nuint dstSize, + void* src, + nuint srcSize, + nuint* CTable, + int flags + ) + { + return HUF_compress4X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, flags); + } + + private static nuint HUF_compressCTable_internal( + byte* ostart, + byte* op, + byte* oend, + void* src, + nuint srcSize, + HUF_nbStreams_e nbStreams, + nuint* CTable, + int flags + ) + { + nuint cSize = + nbStreams == HUF_nbStreams_e.HUF_singleStream + ? HUF_compress1X_usingCTable_internal( + op, + (nuint)(oend - op), + src, + srcSize, + CTable, + flags + ) + : HUF_compress4X_usingCTable_internal( + op, + (nuint)(oend - op), + src, + srcSize, + CTable, + flags + ); + if (ERR_isError(cSize)) + { + return cSize; + } + + if (cSize == 0) + { + return 0; + } + + op += cSize; + assert(op >= ostart); + if ((nuint)(op - ostart) >= srcSize - 1) + { + return 0; + } + + return (nuint)(op - ostart); + } + + private static uint HUF_cardinality(uint* count, uint maxSymbolValue) + { + uint cardinality = 0; + uint i; + for (i = 0; i < maxSymbolValue + 1; i++) + { + if (count[i] != 0) + cardinality += 1; + } + + return cardinality; + } + + /*! HUF_compress() does the following: + * 1. count symbol occurrence from source[] into table count[] using FSE_count() (exposed within "fse.h") + * 2. (optional) refine tableLog using HUF_optimalTableLog() + * 3. build Huffman table from count using HUF_buildCTable() + * 4. save Huffman table to memory buffer using HUF_writeCTable() + * 5. encode the data stream using HUF_compress4X_usingCTable() + * + * The following API allows targeting specific sub-functions for advanced tasks. + * For example, it's possible to compress several blocks using the same 'CTable', + * or to save and regenerate 'CTable' using external methods. + */ + private static uint HUF_minTableLog(uint symbolCardinality) + { + uint minBitsSymbols = ZSTD_highbit32(symbolCardinality) + 1; + return minBitsSymbols; + } + + private static uint HUF_optimalTableLog( + uint maxTableLog, + nuint srcSize, + uint maxSymbolValue, + void* workSpace, + nuint wkspSize, + nuint* table, + uint* count, + int flags + ) + { + assert(srcSize > 1); + assert(wkspSize >= (nuint)sizeof(HUF_buildCTable_wksp_tables)); + if ((flags & (int)HUF_flags_e.HUF_flags_optimalDepth) == 0) + { + return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 1); + } + + { + byte* dst = (byte*)workSpace + sizeof(HUF_WriteCTableWksp); + nuint dstSize = wkspSize - (nuint)sizeof(HUF_WriteCTableWksp); + nuint hSize, + newSize; + uint symbolCardinality = HUF_cardinality(count, maxSymbolValue); + uint minTableLog = HUF_minTableLog(symbolCardinality); + nuint optSize = unchecked((nuint)~0) - 1; + uint optLog = maxTableLog, + optLogGuess; + for (optLogGuess = minTableLog; optLogGuess <= maxTableLog; optLogGuess++) + { + { + nuint maxBits = HUF_buildCTable_wksp( + table, + count, + maxSymbolValue, + optLogGuess, + workSpace, + wkspSize + ); + if (ERR_isError(maxBits)) + continue; + if (maxBits < optLogGuess && optLogGuess > minTableLog) + break; + hSize = HUF_writeCTable_wksp( + dst, + dstSize, + table, + maxSymbolValue, + (uint)maxBits, + workSpace, + wkspSize + ); + } + + if (ERR_isError(hSize)) + continue; + newSize = HUF_estimateCompressedSize(table, count, maxSymbolValue) + hSize; + if (newSize > optSize + 1) + { + break; + } + + if (newSize < optSize) + { + optSize = newSize; + optLog = optLogGuess; + } + } + + assert(optLog <= 12); + return optLog; + } + } + + /* HUF_compress_internal() : + * `workSpace_align4` must be aligned on 4-bytes boundaries, + * and occupies the same space as a table of HUF_WORKSPACE_SIZE_U64 unsigned */ + private static nuint HUF_compress_internal( + void* dst, + nuint dstSize, + void* src, + nuint srcSize, + uint maxSymbolValue, + uint huffLog, + HUF_nbStreams_e nbStreams, + void* workSpace, + nuint wkspSize, + nuint* oldHufTable, + HUF_repeat* repeat, + int flags + ) + { + HUF_compress_tables_t* table = (HUF_compress_tables_t*)HUF_alignUpWorkspace( + workSpace, + &wkspSize, + sizeof(ulong) + ); + byte* ostart = (byte*)dst; + byte* oend = ostart + dstSize; + byte* op = ostart; + if (wkspSize < (nuint)sizeof(HUF_compress_tables_t)) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_workSpace_tooSmall)); + if (srcSize == 0) + return 0; + if (dstSize == 0) + return 0; + if (srcSize > 128 * 1024) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + if (huffLog > 12) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)); + if (maxSymbolValue > 255) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_maxSymbolValue_tooLarge)); + if (maxSymbolValue == 0) + maxSymbolValue = 255; + if (huffLog == 0) + huffLog = 11; + if ( + (flags & (int)HUF_flags_e.HUF_flags_preferRepeat) != 0 + && repeat != null + && *repeat == HUF_repeat.HUF_repeat_valid + ) + { + return HUF_compressCTable_internal( + ostart, + op, + oend, + src, + srcSize, + nbStreams, + oldHufTable, + flags + ); + } + + if ((flags & (int)HUF_flags_e.HUF_flags_suspectUncompressible) != 0 && srcSize >= 4096 * 10) + { + nuint largestTotal = 0; + { + uint maxSymbolValueBegin = maxSymbolValue; + nuint largestBegin = HIST_count_simple( + table->count, + &maxSymbolValueBegin, + (byte*)src, + 4096 + ); + if (ERR_isError(largestBegin)) + return largestBegin; + largestTotal += largestBegin; + } + + { + uint maxSymbolValueEnd = maxSymbolValue; + nuint largestEnd = HIST_count_simple( + table->count, + &maxSymbolValueEnd, + (byte*)src + srcSize - 4096, + 4096 + ); + if (ERR_isError(largestEnd)) + return largestEnd; + largestTotal += largestEnd; + } + + if (largestTotal <= (2 * 4096 >> 7) + 4) + return 0; + } + + { + nuint largest = HIST_count_wksp( + table->count, + &maxSymbolValue, + (byte*)src, + srcSize, + table->wksps.hist_wksp, + sizeof(uint) * 1024 + ); + if (ERR_isError(largest)) + return largest; + if (largest == srcSize) + { + *ostart = ((byte*)src)[0]; + return 1; + } + + if (largest <= (srcSize >> 7) + 4) + return 0; + } + + if ( + repeat != null + && *repeat == HUF_repeat.HUF_repeat_check + && HUF_validateCTable(oldHufTable, table->count, maxSymbolValue) == 0 + ) + { + *repeat = HUF_repeat.HUF_repeat_none; + } + + if ( + (flags & (int)HUF_flags_e.HUF_flags_preferRepeat) != 0 + && repeat != null + && *repeat != HUF_repeat.HUF_repeat_none + ) + { + return HUF_compressCTable_internal( + ostart, + op, + oend, + src, + srcSize, + nbStreams, + oldHufTable, + flags + ); + } + + huffLog = HUF_optimalTableLog( + huffLog, + srcSize, + maxSymbolValue, + &table->wksps, + (nuint)sizeof(_wksps_e__Union), + &table->CTable.e0, + table->count, + flags + ); + { + nuint maxBits = HUF_buildCTable_wksp( + &table->CTable.e0, + table->count, + maxSymbolValue, + huffLog, + &table->wksps.buildCTable_wksp, + (nuint)sizeof(HUF_buildCTable_wksp_tables) + ); + { + nuint _var_err__ = maxBits; + if (ERR_isError(_var_err__)) + return _var_err__; + } + + huffLog = (uint)maxBits; + } + + { + nuint hSize = HUF_writeCTable_wksp( + op, + dstSize, + &table->CTable.e0, + maxSymbolValue, + huffLog, + &table->wksps.writeCTable_wksp, + (nuint)sizeof(HUF_WriteCTableWksp) + ); + if (ERR_isError(hSize)) + return hSize; + if (repeat != null && *repeat != HUF_repeat.HUF_repeat_none) + { + nuint oldSize = HUF_estimateCompressedSize( + oldHufTable, + table->count, + maxSymbolValue + ); + nuint newSize = HUF_estimateCompressedSize( + &table->CTable.e0, + table->count, + maxSymbolValue + ); + if (oldSize <= hSize + newSize || hSize + 12 >= srcSize) + { + return HUF_compressCTable_internal( + ostart, + op, + oend, + src, + srcSize, + nbStreams, + oldHufTable, + flags + ); + } + } + + if (hSize + 12U >= srcSize) + { + return 0; + } + + op += hSize; + if (repeat != null) + { + *repeat = HUF_repeat.HUF_repeat_none; + } + + if (oldHufTable != null) + memcpy(oldHufTable, &table->CTable.e0, sizeof(ulong) * 257); + } + + return HUF_compressCTable_internal( + ostart, + op, + oend, + src, + srcSize, + nbStreams, + &table->CTable.e0, + flags + ); + } + + /** HUF_compress1X_repeat() : + * Same as HUF_compress1X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none. + * If it uses hufTable it does not modify hufTable or repeat. + * If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used. + * If preferRepeat then the old table will always be used if valid. + * If suspectUncompressible then some sampling checks will be run to potentially skip huffman coding */ + private static nuint HUF_compress1X_repeat( + void* dst, + nuint dstSize, + void* src, + nuint srcSize, + uint maxSymbolValue, + uint huffLog, + void* workSpace, + nuint wkspSize, + nuint* hufTable, + HUF_repeat* repeat, + int flags + ) + { + return HUF_compress_internal( + dst, + dstSize, + src, + srcSize, + maxSymbolValue, + huffLog, + HUF_nbStreams_e.HUF_singleStream, + workSpace, + wkspSize, + hufTable, + repeat, + flags + ); + } + + /* HUF_compress4X_repeat(): + * compress input using 4 streams. + * consider skipping quickly + * reuse an existing huffman compression table */ + private static nuint HUF_compress4X_repeat( + void* dst, + nuint dstSize, + void* src, + nuint srcSize, + uint maxSymbolValue, + uint huffLog, + void* workSpace, + nuint wkspSize, + nuint* hufTable, + HUF_repeat* repeat, + int flags + ) + { + return HUF_compress_internal( + dst, + dstSize, + src, + srcSize, + maxSymbolValue, + huffLog, + HUF_nbStreams_e.HUF_fourStreams, + workSpace, + wkspSize, + hufTable, + repeat, + flags + ); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/HufDecompress.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/HufDecompress.cs new file mode 100644 index 000000000..262787084 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/HufDecompress.cs @@ -0,0 +1,2505 @@ +using System; +using System.Runtime.CompilerServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + private static DTableDesc HUF_getDTableDesc(uint* table) + { + DTableDesc dtd; + memcpy(&dtd, table, (uint)sizeof(DTableDesc)); + return dtd; + } + + private static nuint HUF_initFastDStream(byte* ip) + { + byte lastByte = ip[7]; + nuint bitsConsumed = lastByte != 0 ? 8 - ZSTD_highbit32(lastByte) : 0; + nuint value = MEM_readLEST(ip) | 1; + assert(bitsConsumed <= 8); + assert(sizeof(nuint) == 8); + return value << (int)bitsConsumed; + } + + /** + * Initializes args for the fast decoding loop. + * @returns 1 on success + * 0 if the fallback implementation should be used. + * Or an error code on failure. + */ + private static nuint HUF_DecompressFastArgs_init( + HUF_DecompressFastArgs* args, + void* dst, + nuint dstSize, + void* src, + nuint srcSize, + uint* DTable + ) + { + void* dt = DTable + 1; + uint dtLog = HUF_getDTableDesc(DTable).tableLog; + byte* istart = (byte*)src; + byte* oend = ZSTD_maybeNullPtrAdd((byte*)dst, (nint)dstSize); + if (!BitConverter.IsLittleEndian || MEM_32bits) + return 0; + if (dstSize == 0) + return 0; + assert(dst != null); + if (srcSize < 10) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + if (dtLog != 11) + return 0; + { + nuint length1 = MEM_readLE16(istart); + nuint length2 = MEM_readLE16(istart + 2); + nuint length3 = MEM_readLE16(istart + 4); + nuint length4 = srcSize - (length1 + length2 + length3 + 6); + args->iend.e0 = istart + 6; + args->iend.e1 = args->iend.e0 + length1; + args->iend.e2 = args->iend.e1 + length2; + args->iend.e3 = args->iend.e2 + length3; + if (length1 < 8 || length2 < 8 || length3 < 8 || length4 < 8) + return 0; + if (length4 > srcSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + args->ip.e0 = args->iend.e1 - sizeof(ulong); + args->ip.e1 = args->iend.e2 - sizeof(ulong); + args->ip.e2 = args->iend.e3 - sizeof(ulong); + args->ip.e3 = (byte*)src + srcSize - sizeof(ulong); + args->op.e0 = (byte*)dst; + args->op.e1 = args->op.e0 + (dstSize + 3) / 4; + args->op.e2 = args->op.e1 + (dstSize + 3) / 4; + args->op.e3 = args->op.e2 + (dstSize + 3) / 4; + if (args->op.e3 >= oend) + return 0; + args->bits[0] = HUF_initFastDStream(args->ip.e0); + args->bits[1] = HUF_initFastDStream(args->ip.e1); + args->bits[2] = HUF_initFastDStream(args->ip.e2); + args->bits[3] = HUF_initFastDStream(args->ip.e3); + args->ilowest = istart; + args->oend = oend; + args->dt = dt; + return 1; + } + + private static nuint HUF_initRemainingDStream( + BIT_DStream_t* bit, + HUF_DecompressFastArgs* args, + int stream, + byte* segmentEnd + ) + { + if ((&args->op.e0)[stream] > segmentEnd) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + if ((&args->ip.e0)[stream] < (&args->iend.e0)[stream] - 8) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + assert(sizeof(nuint) == 8); + bit->bitContainer = MEM_readLEST((&args->ip.e0)[stream]); + bit->bitsConsumed = ZSTD_countTrailingZeros64(args->bits[stream]); + bit->start = (sbyte*)args->ilowest; + bit->limitPtr = bit->start + sizeof(nuint); + bit->ptr = (sbyte*)(&args->ip.e0)[stream]; + return 0; + } + + /** + * Packs 4 HUF_DEltX1 structs into a U64. This is used to lay down 4 entries at + * a time. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ulong HUF_DEltX1_set4(byte symbol, byte nbBits) + { + ulong D4; + if (BitConverter.IsLittleEndian) + { + D4 = (ulong)((symbol << 8) + nbBits); + } + else + { + D4 = (ulong)(symbol + (nbBits << 8)); + } + + assert(D4 < 1U << 16); + D4 *= 0x0001000100010001UL; + return D4; + } + + /** + * Increase the tableLog to targetTableLog and rescales the stats. + * If tableLog > targetTableLog this is a no-op. + * @returns New tableLog + */ + private static uint HUF_rescaleStats( + byte* huffWeight, + uint* rankVal, + uint nbSymbols, + uint tableLog, + uint targetTableLog + ) + { + if (tableLog > targetTableLog) + return tableLog; + if (tableLog < targetTableLog) + { + uint scale = targetTableLog - tableLog; + uint s; + for (s = 0; s < nbSymbols; ++s) + { + huffWeight[s] += (byte)(huffWeight[s] == 0 ? 0 : scale); + } + + for (s = targetTableLog; s > scale; --s) + { + rankVal[s] = rankVal[s - scale]; + } + + for (s = scale; s > 0; --s) + { + rankVal[s] = 0; + } + } + + return targetTableLog; + } + + private static nuint HUF_readDTableX1_wksp( + uint* DTable, + void* src, + nuint srcSize, + void* workSpace, + nuint wkspSize, + int flags + ) + { + uint tableLog = 0; + uint nbSymbols = 0; + nuint iSize; + void* dtPtr = DTable + 1; + HUF_DEltX1* dt = (HUF_DEltX1*)dtPtr; + HUF_ReadDTableX1_Workspace* wksp = (HUF_ReadDTableX1_Workspace*)workSpace; + if ((nuint)sizeof(HUF_ReadDTableX1_Workspace) > wkspSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)); + iSize = HUF_readStats_wksp( + wksp->huffWeight, + 255 + 1, + wksp->rankVal, + &nbSymbols, + &tableLog, + src, + srcSize, + wksp->statsWksp, + sizeof(uint) * 219, + flags + ); + if (ERR_isError(iSize)) + return iSize; + { + DTableDesc dtd = HUF_getDTableDesc(DTable); + uint maxTableLog = (uint)(dtd.maxTableLog + 1); + uint targetTableLog = maxTableLog < 11 ? maxTableLog : 11; + tableLog = HUF_rescaleStats( + wksp->huffWeight, + wksp->rankVal, + nbSymbols, + tableLog, + targetTableLog + ); + if (tableLog > (uint)(dtd.maxTableLog + 1)) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)); + dtd.tableType = 0; + dtd.tableLog = (byte)tableLog; + memcpy(DTable, &dtd, (uint)sizeof(DTableDesc)); + } + + { + int n; + uint nextRankStart = 0; + const int unroll = 4; + int nLimit = (int)nbSymbols - unroll + 1; + for (n = 0; n < (int)tableLog + 1; n++) + { + uint curr = nextRankStart; + nextRankStart += wksp->rankVal[n]; + wksp->rankStart[n] = curr; + } + + for (n = 0; n < nLimit; n += unroll) + { + int u; + for (u = 0; u < unroll; ++u) + { + nuint w = wksp->huffWeight[n + u]; + wksp->symbols[wksp->rankStart[w]++] = (byte)(n + u); + } + } + + for (; n < (int)nbSymbols; ++n) + { + nuint w = wksp->huffWeight[n]; + wksp->symbols[wksp->rankStart[w]++] = (byte)n; + } + } + + { + uint w; + int symbol = (int)wksp->rankVal[0]; + int rankStart = 0; + for (w = 1; w < tableLog + 1; ++w) + { + int symbolCount = (int)wksp->rankVal[w]; + int length = 1 << (int)w >> 1; + int uStart = rankStart; + byte nbBits = (byte)(tableLog + 1 - w); + int s; + int u; + switch (length) + { + case 1: + for (s = 0; s < symbolCount; ++s) + { + HUF_DEltX1 D; + D.@byte = wksp->symbols[symbol + s]; + D.nbBits = nbBits; + dt[uStart] = D; + uStart += 1; + } + + break; + case 2: + for (s = 0; s < symbolCount; ++s) + { + HUF_DEltX1 D; + D.@byte = wksp->symbols[symbol + s]; + D.nbBits = nbBits; + dt[uStart + 0] = D; + dt[uStart + 1] = D; + uStart += 2; + } + + break; + case 4: + for (s = 0; s < symbolCount; ++s) + { + ulong D4 = HUF_DEltX1_set4(wksp->symbols[symbol + s], nbBits); + MEM_write64(dt + uStart, D4); + uStart += 4; + } + + break; + case 8: + for (s = 0; s < symbolCount; ++s) + { + ulong D4 = HUF_DEltX1_set4(wksp->symbols[symbol + s], nbBits); + MEM_write64(dt + uStart, D4); + MEM_write64(dt + uStart + 4, D4); + uStart += 8; + } + + break; + default: + for (s = 0; s < symbolCount; ++s) + { + ulong D4 = HUF_DEltX1_set4(wksp->symbols[symbol + s], nbBits); + for (u = 0; u < length; u += 16) + { + MEM_write64(dt + uStart + u + 0, D4); + MEM_write64(dt + uStart + u + 4, D4); + MEM_write64(dt + uStart + u + 8, D4); + MEM_write64(dt + uStart + u + 12, D4); + } + + assert(u == length); + uStart += length; + } + + break; + } + + symbol += symbolCount; + rankStart += symbolCount * length; + } + } + + return iSize; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static byte HUF_decodeSymbolX1(BIT_DStream_t* Dstream, HUF_DEltX1* dt, uint dtLog) + { + /* note : dtLog >= 1 */ + nuint val = BIT_lookBitsFast(Dstream, dtLog); + byte c = dt[val].@byte; + BIT_skipBits(Dstream, dt[val].nbBits); + return c; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint HUF_decodeStreamX1( + byte* p, + BIT_DStream_t* bitDPtr, + byte* pEnd, + HUF_DEltX1* dt, + uint dtLog + ) + { + byte* pStart = p; + if (pEnd - p > 3) + { + while ( + BIT_reloadDStream(bitDPtr) == BIT_DStream_status.BIT_DStream_unfinished + && p < pEnd - 3 + ) + { + if (MEM_64bits) + *p++ = HUF_decodeSymbolX1(bitDPtr, dt, dtLog); + *p++ = HUF_decodeSymbolX1(bitDPtr, dt, dtLog); + if (MEM_64bits) + *p++ = HUF_decodeSymbolX1(bitDPtr, dt, dtLog); + *p++ = HUF_decodeSymbolX1(bitDPtr, dt, dtLog); + } + } + else + { + BIT_reloadDStream(bitDPtr); + } + + if (MEM_32bits) + while ( + BIT_reloadDStream(bitDPtr) == BIT_DStream_status.BIT_DStream_unfinished && p < pEnd + ) + *p++ = HUF_decodeSymbolX1(bitDPtr, dt, dtLog); + while (p < pEnd) + *p++ = HUF_decodeSymbolX1(bitDPtr, dt, dtLog); + return (nuint)(pEnd - pStart); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint HUF_decompress1X1_usingDTable_internal_body( + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable + ) + { + byte* op = (byte*)dst; + byte* oend = ZSTD_maybeNullPtrAdd(op, (nint)dstSize); + void* dtPtr = DTable + 1; + HUF_DEltX1* dt = (HUF_DEltX1*)dtPtr; + BIT_DStream_t bitD; + DTableDesc dtd = HUF_getDTableDesc(DTable); + uint dtLog = dtd.tableLog; + { + nuint _var_err__ = BIT_initDStream(&bitD, cSrc, cSrcSize); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + HUF_decodeStreamX1(op, &bitD, oend, dt, dtLog); + if (BIT_endOfDStream(&bitD) == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + return dstSize; + } + + /* HUF_decompress4X1_usingDTable_internal_body(): + * Conditions : + * @dstSize >= 6 + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint HUF_decompress4X1_usingDTable_internal_body( + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable + ) + { + if (cSrcSize < 10) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + if (dstSize < 6) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + { + byte* istart = (byte*)cSrc; + byte* ostart = (byte*)dst; + byte* oend = ostart + dstSize; + byte* olimit = oend - 3; + void* dtPtr = DTable + 1; + HUF_DEltX1* dt = (HUF_DEltX1*)dtPtr; + /* Init */ + BIT_DStream_t bitD1; + BIT_DStream_t bitD2; + BIT_DStream_t bitD3; + BIT_DStream_t bitD4; + nuint length1 = MEM_readLE16(istart); + nuint length2 = MEM_readLE16(istart + 2); + nuint length3 = MEM_readLE16(istart + 4); + nuint length4 = cSrcSize - (length1 + length2 + length3 + 6); + /* jumpTable */ + byte* istart1 = istart + 6; + byte* istart2 = istart1 + length1; + byte* istart3 = istart2 + length2; + byte* istart4 = istart3 + length3; + nuint segmentSize = (dstSize + 3) / 4; + byte* opStart2 = ostart + segmentSize; + byte* opStart3 = opStart2 + segmentSize; + byte* opStart4 = opStart3 + segmentSize; + byte* op1 = ostart; + byte* op2 = opStart2; + byte* op3 = opStart3; + byte* op4 = opStart4; + DTableDesc dtd = HUF_getDTableDesc(DTable); + uint dtLog = dtd.tableLog; + uint endSignal = 1; + if (length4 > cSrcSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + if (opStart4 > oend) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + assert(dstSize >= 6); + { + nuint _var_err__ = BIT_initDStream(&bitD1, istart1, length1); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + { + nuint _var_err__ = BIT_initDStream(&bitD2, istart2, length2); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + { + nuint _var_err__ = BIT_initDStream(&bitD3, istart3, length3); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + { + nuint _var_err__ = BIT_initDStream(&bitD4, istart4, length4); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + if ((nuint)(oend - op4) >= (nuint)sizeof(nuint)) + { + for (; (endSignal & (uint)(op4 < olimit ? 1 : 0)) != 0; ) + { + if (MEM_64bits) + *op1++ = HUF_decodeSymbolX1(&bitD1, dt, dtLog); + if (MEM_64bits) + *op2++ = HUF_decodeSymbolX1(&bitD2, dt, dtLog); + if (MEM_64bits) + *op3++ = HUF_decodeSymbolX1(&bitD3, dt, dtLog); + if (MEM_64bits) + *op4++ = HUF_decodeSymbolX1(&bitD4, dt, dtLog); + *op1++ = HUF_decodeSymbolX1(&bitD1, dt, dtLog); + *op2++ = HUF_decodeSymbolX1(&bitD2, dt, dtLog); + *op3++ = HUF_decodeSymbolX1(&bitD3, dt, dtLog); + *op4++ = HUF_decodeSymbolX1(&bitD4, dt, dtLog); + if (MEM_64bits) + *op1++ = HUF_decodeSymbolX1(&bitD1, dt, dtLog); + if (MEM_64bits) + *op2++ = HUF_decodeSymbolX1(&bitD2, dt, dtLog); + if (MEM_64bits) + *op3++ = HUF_decodeSymbolX1(&bitD3, dt, dtLog); + if (MEM_64bits) + *op4++ = HUF_decodeSymbolX1(&bitD4, dt, dtLog); + *op1++ = HUF_decodeSymbolX1(&bitD1, dt, dtLog); + *op2++ = HUF_decodeSymbolX1(&bitD2, dt, dtLog); + *op3++ = HUF_decodeSymbolX1(&bitD3, dt, dtLog); + *op4++ = HUF_decodeSymbolX1(&bitD4, dt, dtLog); + endSignal &= + BIT_reloadDStreamFast(&bitD1) == BIT_DStream_status.BIT_DStream_unfinished + ? 1U + : 0U; + endSignal &= + BIT_reloadDStreamFast(&bitD2) == BIT_DStream_status.BIT_DStream_unfinished + ? 1U + : 0U; + endSignal &= + BIT_reloadDStreamFast(&bitD3) == BIT_DStream_status.BIT_DStream_unfinished + ? 1U + : 0U; + endSignal &= + BIT_reloadDStreamFast(&bitD4) == BIT_DStream_status.BIT_DStream_unfinished + ? 1U + : 0U; + } + } + + if (op1 > opStart2) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + if (op2 > opStart3) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + if (op3 > opStart4) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + HUF_decodeStreamX1(op1, &bitD1, opStart2, dt, dtLog); + HUF_decodeStreamX1(op2, &bitD2, opStart3, dt, dtLog); + HUF_decodeStreamX1(op3, &bitD3, opStart4, dt, dtLog); + HUF_decodeStreamX1(op4, &bitD4, oend, dt, dtLog); + { + uint endCheck = + BIT_endOfDStream(&bitD1) + & BIT_endOfDStream(&bitD2) + & BIT_endOfDStream(&bitD3) + & BIT_endOfDStream(&bitD4); + if (endCheck == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + return dstSize; + } + } + + private static nuint HUF_decompress4X1_usingDTable_internal_default( + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable + ) + { + return HUF_decompress4X1_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable); + } + + private static void HUF_decompress4X1_usingDTable_internal_fast_c_loop( + HUF_DecompressFastArgs* args + ) + { + ulong bits0, + bits1, + bits2, + bits3; + byte* ip0, + ip1, + ip2, + ip3; + byte* op0, + op1, + op2, + op3; + ushort* dtable = (ushort*)args->dt; + byte* oend = args->oend; + byte* ilowest = args->ilowest; + bits0 = args->bits[0]; + bits1 = args->bits[1]; + bits2 = args->bits[2]; + bits3 = args->bits[3]; + ip0 = args->ip.e0; + ip1 = args->ip.e1; + ip2 = args->ip.e2; + ip3 = args->ip.e3; + op0 = args->op.e0; + op1 = args->op.e1; + op2 = args->op.e2; + op3 = args->op.e3; + assert(BitConverter.IsLittleEndian); + assert(!MEM_32bits); + for (; ; ) + { + byte* olimit; + { + assert(op0 <= op1); + assert(ip0 >= ilowest); + } + + { + assert(op1 <= op2); + assert(ip1 >= ilowest); + } + + { + assert(op2 <= op3); + assert(ip2 >= ilowest); + } + + { + assert(op3 <= oend); + assert(ip3 >= ilowest); + } + + { + /* Each iteration produces 5 output symbols per stream */ + nuint oiters = (nuint)(oend - op3) / 5; + /* Each iteration consumes up to 11 bits * 5 = 55 bits < 7 bytes + * per stream. + */ + nuint iiters = (nuint)(ip0 - ilowest) / 7; + /* We can safely run iters iterations before running bounds checks */ + nuint iters = oiters < iiters ? oiters : iiters; + nuint symbols = iters * 5; + olimit = op3 + symbols; + if (op3 == olimit) + break; + { + if (ip1 < ip0) + goto _out; + } + + { + if (ip2 < ip1) + goto _out; + } + + { + if (ip3 < ip2) + goto _out; + } + } + + { + assert(ip1 >= ip0); + } + + { + assert(ip2 >= ip1); + } + + { + assert(ip3 >= ip2); + } + + do + { + { + { + /* Decode 5 symbols in each of the 4 streams */ + int index = (int)(bits0 >> 53); + int entry = dtable[index]; + bits0 <<= entry & 0x3F; + op0[0] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits1 >> 53); + int entry = dtable[index]; + bits1 <<= entry & 0x3F; + op1[0] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits2 >> 53); + int entry = dtable[index]; + bits2 <<= entry & 0x3F; + op2[0] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits3 >> 53); + int entry = dtable[index]; + bits3 <<= entry & 0x3F; + op3[0] = (byte)(entry >> 8 & 0xFF); + } + } + + { + { + int index = (int)(bits0 >> 53); + int entry = dtable[index]; + bits0 <<= entry & 0x3F; + op0[1] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits1 >> 53); + int entry = dtable[index]; + bits1 <<= entry & 0x3F; + op1[1] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits2 >> 53); + int entry = dtable[index]; + bits2 <<= entry & 0x3F; + op2[1] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits3 >> 53); + int entry = dtable[index]; + bits3 <<= entry & 0x3F; + op3[1] = (byte)(entry >> 8 & 0xFF); + } + } + + { + { + int index = (int)(bits0 >> 53); + int entry = dtable[index]; + bits0 <<= entry & 0x3F; + op0[2] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits1 >> 53); + int entry = dtable[index]; + bits1 <<= entry & 0x3F; + op1[2] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits2 >> 53); + int entry = dtable[index]; + bits2 <<= entry & 0x3F; + op2[2] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits3 >> 53); + int entry = dtable[index]; + bits3 <<= entry & 0x3F; + op3[2] = (byte)(entry >> 8 & 0xFF); + } + } + + { + { + int index = (int)(bits0 >> 53); + int entry = dtable[index]; + bits0 <<= entry & 0x3F; + op0[3] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits1 >> 53); + int entry = dtable[index]; + bits1 <<= entry & 0x3F; + op1[3] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits2 >> 53); + int entry = dtable[index]; + bits2 <<= entry & 0x3F; + op2[3] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits3 >> 53); + int entry = dtable[index]; + bits3 <<= entry & 0x3F; + op3[3] = (byte)(entry >> 8 & 0xFF); + } + } + + { + { + int index = (int)(bits0 >> 53); + int entry = dtable[index]; + bits0 <<= entry & 0x3F; + op0[4] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits1 >> 53); + int entry = dtable[index]; + bits1 <<= entry & 0x3F; + op1[4] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits2 >> 53); + int entry = dtable[index]; + bits2 <<= entry & 0x3F; + op2[4] = (byte)(entry >> 8 & 0xFF); + } + + { + int index = (int)(bits3 >> 53); + int entry = dtable[index]; + bits3 <<= entry & 0x3F; + op3[4] = (byte)(entry >> 8 & 0xFF); + } + } + + { + { + /* Reload each of the 4 the bitstreams */ + int ctz = (int)ZSTD_countTrailingZeros64(bits0); + int nbBits = ctz & 7; + int nbBytes = ctz >> 3; + op0 += 5; + ip0 -= nbBytes; + bits0 = MEM_read64(ip0) | 1; + bits0 <<= nbBits; + } + + { + int ctz = (int)ZSTD_countTrailingZeros64(bits1); + int nbBits = ctz & 7; + int nbBytes = ctz >> 3; + op1 += 5; + ip1 -= nbBytes; + bits1 = MEM_read64(ip1) | 1; + bits1 <<= nbBits; + } + + { + int ctz = (int)ZSTD_countTrailingZeros64(bits2); + int nbBits = ctz & 7; + int nbBytes = ctz >> 3; + op2 += 5; + ip2 -= nbBytes; + bits2 = MEM_read64(ip2) | 1; + bits2 <<= nbBits; + } + + { + int ctz = (int)ZSTD_countTrailingZeros64(bits3); + int nbBits = ctz & 7; + int nbBytes = ctz >> 3; + op3 += 5; + ip3 -= nbBytes; + bits3 = MEM_read64(ip3) | 1; + bits3 <<= nbBits; + } + } + } while (op3 < olimit); + } + + _out: + args->bits[0] = bits0; + args->bits[1] = bits1; + args->bits[2] = bits2; + args->bits[3] = bits3; + args->ip.e0 = ip0; + args->ip.e1 = ip1; + args->ip.e2 = ip2; + args->ip.e3 = ip3; + args->op.e0 = op0; + args->op.e1 = op1; + args->op.e2 = op2; + args->op.e3 = op3; + } + + /** + * @returns @p dstSize on success (>= 6) + * 0 if the fallback implementation should be used + * An error if an error occurred + */ + private static nuint HUF_decompress4X1_usingDTable_internal_fast( + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable, + void* loopFn + ) + { + void* dt = DTable + 1; + byte* ilowest = (byte*)cSrc; + byte* oend = ZSTD_maybeNullPtrAdd((byte*)dst, (nint)dstSize); + HUF_DecompressFastArgs args; + { + nuint ret = HUF_DecompressFastArgs_init(&args, dst, dstSize, cSrc, cSrcSize, DTable); + { + nuint err_code = ret; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (ret == 0) + return 0; + } + + assert(args.ip.e0 >= args.ilowest); + ((delegate* managed)loopFn)(&args); + assert(args.ip.e0 >= ilowest); + assert(args.ip.e0 >= ilowest); + assert(args.ip.e1 >= ilowest); + assert(args.ip.e2 >= ilowest); + assert(args.ip.e3 >= ilowest); + assert(args.op.e3 <= oend); + assert(ilowest == args.ilowest); + assert(ilowest + 6 == args.iend.e0); + { + nuint segmentSize = (dstSize + 3) / 4; + byte* segmentEnd = (byte*)dst; + int i; + for (i = 0; i < 4; ++i) + { + BIT_DStream_t bit; + if (segmentSize <= (nuint)(oend - segmentEnd)) + segmentEnd += segmentSize; + else + segmentEnd = oend; + { + nuint err_code = HUF_initRemainingDStream(&bit, &args, i, segmentEnd); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + (&args.op.e0)[i] += HUF_decodeStreamX1( + (&args.op.e0)[i], + &bit, + segmentEnd, + (HUF_DEltX1*)dt, + 11 + ); + if ((&args.op.e0)[i] != segmentEnd) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + } + + assert(dstSize != 0); + return dstSize; + } + + private static nuint HUF_decompress1X1_usingDTable_internal( + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable, + int flags + ) + { + return HUF_decompress1X1_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable); + } + + private static nuint HUF_decompress4X1_usingDTable_internal( + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable, + int flags + ) + { + void* fallbackFn = (delegate* managed)( + &HUF_decompress4X1_usingDTable_internal_default + ); + void* loopFn = (delegate* managed)( + &HUF_decompress4X1_usingDTable_internal_fast_c_loop + ); + if ((flags & (int)HUF_flags_e.HUF_flags_disableFast) == 0) + { + nuint ret = HUF_decompress4X1_usingDTable_internal_fast( + dst, + dstSize, + cSrc, + cSrcSize, + DTable, + loopFn + ); + if (ret != 0) + return ret; + } + + return ((delegate* managed)fallbackFn)( + dst, + dstSize, + cSrc, + cSrcSize, + DTable + ); + } + + private static nuint HUF_decompress4X1_DCtx_wksp( + uint* dctx, + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + void* workSpace, + nuint wkspSize, + int flags + ) + { + byte* ip = (byte*)cSrc; + nuint hSize = HUF_readDTableX1_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize, flags); + if (ERR_isError(hSize)) + return hSize; + if (hSize >= cSrcSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + ip += hSize; + cSrcSize -= hSize; + return HUF_decompress4X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, flags); + } + + /** + * Constructs a HUF_DEltX2 in a U32. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint HUF_buildDEltX2U32(uint symbol, uint nbBits, uint baseSeq, int level) + { + uint seq; + if (BitConverter.IsLittleEndian) + { + seq = level == 1 ? symbol : baseSeq + (symbol << 8); + return seq + (nbBits << 16) + ((uint)level << 24); + } + else + { + seq = level == 1 ? symbol << 8 : (baseSeq << 8) + symbol; + return (seq << 16) + (nbBits << 8) + (uint)level; + } + } + + /** + * Constructs a HUF_DEltX2. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static HUF_DEltX2 HUF_buildDEltX2(uint symbol, uint nbBits, uint baseSeq, int level) + { + HUF_DEltX2 DElt; + uint val = HUF_buildDEltX2U32(symbol, nbBits, baseSeq, level); + memcpy(&DElt, &val, sizeof(uint)); + return DElt; + } + + /** + * Constructs 2 HUF_DEltX2s and packs them into a U64. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ulong HUF_buildDEltX2U64(uint symbol, uint nbBits, ushort baseSeq, int level) + { + uint DElt = HUF_buildDEltX2U32(symbol, nbBits, baseSeq, level); + return DElt + ((ulong)DElt << 32); + } + + /** + * Fills the DTable rank with all the symbols from [begin, end) that are each + * nbBits long. + * + * @param DTableRank The start of the rank in the DTable. + * @param begin The first symbol to fill (inclusive). + * @param end The last symbol to fill (exclusive). + * @param nbBits Each symbol is nbBits long. + * @param tableLog The table log. + * @param baseSeq If level == 1 { 0 } else { the first level symbol } + * @param level The level in the table. Must be 1 or 2. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void HUF_fillDTableX2ForWeight( + HUF_DEltX2* DTableRank, + sortedSymbol_t* begin, + sortedSymbol_t* end, + uint nbBits, + uint tableLog, + ushort baseSeq, + int level + ) + { + /* quiet static-analyzer */ + uint length = 1U << (int)(tableLog - nbBits & 0x1F); + sortedSymbol_t* ptr; + assert(level >= 1 && level <= 2); + switch (length) + { + case 1: + for (ptr = begin; ptr != end; ++ptr) + { + HUF_DEltX2 DElt = HUF_buildDEltX2(ptr->symbol, nbBits, baseSeq, level); + *DTableRank++ = DElt; + } + + break; + case 2: + for (ptr = begin; ptr != end; ++ptr) + { + HUF_DEltX2 DElt = HUF_buildDEltX2(ptr->symbol, nbBits, baseSeq, level); + DTableRank[0] = DElt; + DTableRank[1] = DElt; + DTableRank += 2; + } + + break; + case 4: + for (ptr = begin; ptr != end; ++ptr) + { + ulong DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level); + memcpy(DTableRank + 0, &DEltX2, sizeof(ulong)); + memcpy(DTableRank + 2, &DEltX2, sizeof(ulong)); + DTableRank += 4; + } + + break; + case 8: + for (ptr = begin; ptr != end; ++ptr) + { + ulong DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level); + memcpy(DTableRank + 0, &DEltX2, sizeof(ulong)); + memcpy(DTableRank + 2, &DEltX2, sizeof(ulong)); + memcpy(DTableRank + 4, &DEltX2, sizeof(ulong)); + memcpy(DTableRank + 6, &DEltX2, sizeof(ulong)); + DTableRank += 8; + } + + break; + default: + for (ptr = begin; ptr != end; ++ptr) + { + ulong DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level); + HUF_DEltX2* DTableRankEnd = DTableRank + length; + for (; DTableRank != DTableRankEnd; DTableRank += 8) + { + memcpy(DTableRank + 0, &DEltX2, sizeof(ulong)); + memcpy(DTableRank + 2, &DEltX2, sizeof(ulong)); + memcpy(DTableRank + 4, &DEltX2, sizeof(ulong)); + memcpy(DTableRank + 6, &DEltX2, sizeof(ulong)); + } + } + + break; + } + } + + /* HUF_fillDTableX2Level2() : + * `rankValOrigin` must be a table of at least (HUF_TABLELOG_MAX + 1) U32 */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void HUF_fillDTableX2Level2( + HUF_DEltX2* DTable, + uint targetLog, + uint consumedBits, + uint* rankVal, + int minWeight, + int maxWeight1, + sortedSymbol_t* sortedSymbols, + uint* rankStart, + uint nbBitsBaseline, + ushort baseSeq + ) + { + if (minWeight > 1) + { + /* quiet static-analyzer */ + uint length = 1U << (int)(targetLog - consumedBits & 0x1F); + /* baseSeq */ + ulong DEltX2 = HUF_buildDEltX2U64(baseSeq, consumedBits, 0, 1); + int skipSize = (int)rankVal[minWeight]; + assert(length > 1); + assert((uint)skipSize < length); + switch (length) + { + case 2: + assert(skipSize == 1); + memcpy(DTable, &DEltX2, sizeof(ulong)); + break; + case 4: + assert(skipSize <= 4); + memcpy(DTable + 0, &DEltX2, sizeof(ulong)); + memcpy(DTable + 2, &DEltX2, sizeof(ulong)); + break; + default: + { + int i; + for (i = 0; i < skipSize; i += 8) + { + memcpy(DTable + i + 0, &DEltX2, sizeof(ulong)); + memcpy(DTable + i + 2, &DEltX2, sizeof(ulong)); + memcpy(DTable + i + 4, &DEltX2, sizeof(ulong)); + memcpy(DTable + i + 6, &DEltX2, sizeof(ulong)); + } + } + + break; + } + } + + { + int w; + for (w = minWeight; w < maxWeight1; ++w) + { + int begin = (int)rankStart[w]; + int end = (int)rankStart[w + 1]; + uint nbBits = nbBitsBaseline - (uint)w; + uint totalBits = nbBits + consumedBits; + HUF_fillDTableX2ForWeight( + DTable + rankVal[w], + sortedSymbols + begin, + sortedSymbols + end, + totalBits, + targetLog, + baseSeq, + 2 + ); + } + } + } + + private static void HUF_fillDTableX2( + HUF_DEltX2* DTable, + uint targetLog, + sortedSymbol_t* sortedList, + uint* rankStart, + rankValCol_t* rankValOrigin, + uint maxWeight, + uint nbBitsBaseline + ) + { + uint* rankVal = (uint*)&rankValOrigin[0]; + /* note : targetLog >= srcLog, hence scaleLog <= 1 */ + int scaleLog = (int)(nbBitsBaseline - targetLog); + uint minBits = nbBitsBaseline - maxWeight; + int w; + int wEnd = (int)maxWeight + 1; + for (w = 1; w < wEnd; ++w) + { + int begin = (int)rankStart[w]; + int end = (int)rankStart[w + 1]; + uint nbBits = nbBitsBaseline - (uint)w; + if (targetLog - nbBits >= minBits) + { + /* Enough room for a second symbol. */ + int start = (int)rankVal[w]; + /* quiet static-analyzer */ + uint length = 1U << (int)(targetLog - nbBits & 0x1F); + int minWeight = (int)(nbBits + (uint)scaleLog); + int s; + if (minWeight < 1) + minWeight = 1; + for (s = begin; s != end; ++s) + { + HUF_fillDTableX2Level2( + DTable + start, + targetLog, + nbBits, + (uint*)&rankValOrigin[nbBits], + minWeight, + wEnd, + sortedList, + rankStart, + nbBitsBaseline, + sortedList[s].symbol + ); + start += (int)length; + } + } + else + { + HUF_fillDTableX2ForWeight( + DTable + rankVal[w], + sortedList + begin, + sortedList + end, + nbBits, + targetLog, + 0, + 1 + ); + } + } + } + + private static nuint HUF_readDTableX2_wksp( + uint* DTable, + void* src, + nuint srcSize, + void* workSpace, + nuint wkspSize, + int flags + ) + { + uint tableLog, + maxW, + nbSymbols; + DTableDesc dtd = HUF_getDTableDesc(DTable); + uint maxTableLog = dtd.maxTableLog; + nuint iSize; + /* force compiler to avoid strict-aliasing */ + void* dtPtr = DTable + 1; + HUF_DEltX2* dt = (HUF_DEltX2*)dtPtr; + uint* rankStart; + HUF_ReadDTableX2_Workspace* wksp = (HUF_ReadDTableX2_Workspace*)workSpace; + if ((nuint)sizeof(HUF_ReadDTableX2_Workspace) > wkspSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + rankStart = wksp->rankStart0 + 1; + memset(wksp->rankStats, 0, sizeof(uint) * 13); + memset(wksp->rankStart0, 0, sizeof(uint) * 15); + if (maxTableLog > 12) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)); + iSize = HUF_readStats_wksp( + wksp->weightList, + 255 + 1, + wksp->rankStats, + &nbSymbols, + &tableLog, + src, + srcSize, + wksp->calleeWksp, + sizeof(uint) * 219, + flags + ); + if (ERR_isError(iSize)) + return iSize; + if (tableLog > maxTableLog) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)); + if (tableLog <= 11 && maxTableLog > 11) + maxTableLog = 11; + for (maxW = tableLog; wksp->rankStats[maxW] == 0; maxW--) { } + + { + uint w, + nextRankStart = 0; + for (w = 1; w < maxW + 1; w++) + { + uint curr = nextRankStart; + nextRankStart += wksp->rankStats[w]; + rankStart[w] = curr; + } + + rankStart[0] = nextRankStart; + rankStart[maxW + 1] = nextRankStart; + } + + { + uint s; + for (s = 0; s < nbSymbols; s++) + { + uint w = wksp->weightList[s]; + uint r = rankStart[w]++; + (&wksp->sortedSymbol.e0)[r].symbol = (byte)s; + } + + rankStart[0] = 0; + } + + { + uint* rankVal0 = (uint*)&wksp->rankVal.e0; + { + /* tableLog <= maxTableLog */ + int rescale = (int)(maxTableLog - tableLog - 1); + uint nextRankVal = 0; + uint w; + for (w = 1; w < maxW + 1; w++) + { + uint curr = nextRankVal; + nextRankVal += wksp->rankStats[w] << (int)(w + (uint)rescale); + rankVal0[w] = curr; + } + } + + { + uint minBits = tableLog + 1 - maxW; + uint consumed; + for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) + { + uint* rankValPtr = (uint*)&(&wksp->rankVal.e0)[consumed]; + uint w; + for (w = 1; w < maxW + 1; w++) + { + rankValPtr[w] = rankVal0[w] >> (int)consumed; + } + } + } + } + + HUF_fillDTableX2( + dt, + maxTableLog, + &wksp->sortedSymbol.e0, + wksp->rankStart0, + &wksp->rankVal.e0, + maxW, + tableLog + 1 + ); + dtd.tableLog = (byte)maxTableLog; + dtd.tableType = 1; + memcpy(DTable, &dtd, (uint)sizeof(DTableDesc)); + return iSize; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint HUF_decodeSymbolX2( + void* op, + BIT_DStream_t* DStream, + HUF_DEltX2* dt, + uint dtLog + ) + { + /* note : dtLog >= 1 */ + nuint val = BIT_lookBitsFast(DStream, dtLog); + memcpy(op, &dt[val].sequence, 2); + BIT_skipBits(DStream, dt[val].nbBits); + return dt[val].length; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint HUF_decodeLastSymbolX2( + void* op, + BIT_DStream_t* DStream, + HUF_DEltX2* dt, + uint dtLog + ) + { + /* note : dtLog >= 1 */ + nuint val = BIT_lookBitsFast(DStream, dtLog); + memcpy(op, &dt[val].sequence, 1); + if (dt[val].length == 1) + { + BIT_skipBits(DStream, dt[val].nbBits); + } + else + { + if (DStream->bitsConsumed < (uint)(sizeof(nuint) * 8)) + { + BIT_skipBits(DStream, dt[val].nbBits); + if (DStream->bitsConsumed > (uint)(sizeof(nuint) * 8)) + DStream->bitsConsumed = (uint)(sizeof(nuint) * 8); + } + } + + return 1; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint HUF_decodeStreamX2( + byte* p, + BIT_DStream_t* bitDPtr, + byte* pEnd, + HUF_DEltX2* dt, + uint dtLog + ) + { + byte* pStart = p; + if ((nuint)(pEnd - p) >= (nuint)sizeof(nuint)) + { + if (dtLog <= 11 && MEM_64bits) + { + while ( + BIT_reloadDStream(bitDPtr) == BIT_DStream_status.BIT_DStream_unfinished + && p < pEnd - 9 + ) + { + p += HUF_decodeSymbolX2(p, bitDPtr, dt, dtLog); + p += HUF_decodeSymbolX2(p, bitDPtr, dt, dtLog); + p += HUF_decodeSymbolX2(p, bitDPtr, dt, dtLog); + p += HUF_decodeSymbolX2(p, bitDPtr, dt, dtLog); + p += HUF_decodeSymbolX2(p, bitDPtr, dt, dtLog); + } + } + else + { + while ( + BIT_reloadDStream(bitDPtr) == BIT_DStream_status.BIT_DStream_unfinished + && p < pEnd - (sizeof(nuint) - 1) + ) + { + if (MEM_64bits) + p += HUF_decodeSymbolX2(p, bitDPtr, dt, dtLog); + p += HUF_decodeSymbolX2(p, bitDPtr, dt, dtLog); + if (MEM_64bits) + p += HUF_decodeSymbolX2(p, bitDPtr, dt, dtLog); + p += HUF_decodeSymbolX2(p, bitDPtr, dt, dtLog); + } + } + } + else + { + BIT_reloadDStream(bitDPtr); + } + + if ((nuint)(pEnd - p) >= 2) + { + while ( + BIT_reloadDStream(bitDPtr) == BIT_DStream_status.BIT_DStream_unfinished + && p <= pEnd - 2 + ) + p += HUF_decodeSymbolX2(p, bitDPtr, dt, dtLog); + while (p <= pEnd - 2) + p += HUF_decodeSymbolX2(p, bitDPtr, dt, dtLog); + } + + if (p < pEnd) + p += HUF_decodeLastSymbolX2(p, bitDPtr, dt, dtLog); + return (nuint)(p - pStart); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint HUF_decompress1X2_usingDTable_internal_body( + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable + ) + { + BIT_DStream_t bitD; + { + /* Init */ + nuint _var_err__ = BIT_initDStream(&bitD, cSrc, cSrcSize); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + { + byte* ostart = (byte*)dst; + byte* oend = ZSTD_maybeNullPtrAdd(ostart, (nint)dstSize); + /* force compiler to not use strict-aliasing */ + void* dtPtr = DTable + 1; + HUF_DEltX2* dt = (HUF_DEltX2*)dtPtr; + DTableDesc dtd = HUF_getDTableDesc(DTable); + HUF_decodeStreamX2(ostart, &bitD, oend, dt, dtd.tableLog); + } + + if (BIT_endOfDStream(&bitD) == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + return dstSize; + } + + /* HUF_decompress4X2_usingDTable_internal_body(): + * Conditions: + * @dstSize >= 6 + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint HUF_decompress4X2_usingDTable_internal_body( + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable + ) + { + if (cSrcSize < 10) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + if (dstSize < 6) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + { + byte* istart = (byte*)cSrc; + byte* ostart = (byte*)dst; + byte* oend = ostart + dstSize; + byte* olimit = oend - (sizeof(nuint) - 1); + void* dtPtr = DTable + 1; + HUF_DEltX2* dt = (HUF_DEltX2*)dtPtr; + /* Init */ + BIT_DStream_t bitD1; + BIT_DStream_t bitD2; + BIT_DStream_t bitD3; + BIT_DStream_t bitD4; + nuint length1 = MEM_readLE16(istart); + nuint length2 = MEM_readLE16(istart + 2); + nuint length3 = MEM_readLE16(istart + 4); + nuint length4 = cSrcSize - (length1 + length2 + length3 + 6); + /* jumpTable */ + byte* istart1 = istart + 6; + byte* istart2 = istart1 + length1; + byte* istart3 = istart2 + length2; + byte* istart4 = istart3 + length3; + nuint segmentSize = (dstSize + 3) / 4; + byte* opStart2 = ostart + segmentSize; + byte* opStart3 = opStart2 + segmentSize; + byte* opStart4 = opStart3 + segmentSize; + byte* op1 = ostart; + byte* op2 = opStart2; + byte* op3 = opStart3; + byte* op4 = opStart4; + uint endSignal = 1; + DTableDesc dtd = HUF_getDTableDesc(DTable); + uint dtLog = dtd.tableLog; + if (length4 > cSrcSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + if (opStart4 > oend) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + assert(dstSize >= 6); + { + nuint _var_err__ = BIT_initDStream(&bitD1, istart1, length1); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + { + nuint _var_err__ = BIT_initDStream(&bitD2, istart2, length2); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + { + nuint _var_err__ = BIT_initDStream(&bitD3, istart3, length3); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + { + nuint _var_err__ = BIT_initDStream(&bitD4, istart4, length4); + if (ERR_isError(_var_err__)) + return _var_err__; + } + + if ((nuint)(oend - op4) >= (nuint)sizeof(nuint)) + { + for (; (endSignal & (uint)(op4 < olimit ? 1 : 0)) != 0; ) + { + if (MEM_64bits) + op1 += HUF_decodeSymbolX2(op1, &bitD1, dt, dtLog); + op1 += HUF_decodeSymbolX2(op1, &bitD1, dt, dtLog); + if (MEM_64bits) + op1 += HUF_decodeSymbolX2(op1, &bitD1, dt, dtLog); + op1 += HUF_decodeSymbolX2(op1, &bitD1, dt, dtLog); + if (MEM_64bits) + op2 += HUF_decodeSymbolX2(op2, &bitD2, dt, dtLog); + op2 += HUF_decodeSymbolX2(op2, &bitD2, dt, dtLog); + if (MEM_64bits) + op2 += HUF_decodeSymbolX2(op2, &bitD2, dt, dtLog); + op2 += HUF_decodeSymbolX2(op2, &bitD2, dt, dtLog); + endSignal &= + BIT_reloadDStreamFast(&bitD1) == BIT_DStream_status.BIT_DStream_unfinished + ? 1U + : 0U; + endSignal &= + BIT_reloadDStreamFast(&bitD2) == BIT_DStream_status.BIT_DStream_unfinished + ? 1U + : 0U; + if (MEM_64bits) + op3 += HUF_decodeSymbolX2(op3, &bitD3, dt, dtLog); + op3 += HUF_decodeSymbolX2(op3, &bitD3, dt, dtLog); + if (MEM_64bits) + op3 += HUF_decodeSymbolX2(op3, &bitD3, dt, dtLog); + op3 += HUF_decodeSymbolX2(op3, &bitD3, dt, dtLog); + if (MEM_64bits) + op4 += HUF_decodeSymbolX2(op4, &bitD4, dt, dtLog); + op4 += HUF_decodeSymbolX2(op4, &bitD4, dt, dtLog); + if (MEM_64bits) + op4 += HUF_decodeSymbolX2(op4, &bitD4, dt, dtLog); + op4 += HUF_decodeSymbolX2(op4, &bitD4, dt, dtLog); + endSignal &= + BIT_reloadDStreamFast(&bitD3) == BIT_DStream_status.BIT_DStream_unfinished + ? 1U + : 0U; + endSignal &= + BIT_reloadDStreamFast(&bitD4) == BIT_DStream_status.BIT_DStream_unfinished + ? 1U + : 0U; + } + } + + if (op1 > opStart2) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + if (op2 > opStart3) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + if (op3 > opStart4) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog); + HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog); + HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog); + HUF_decodeStreamX2(op4, &bitD4, oend, dt, dtLog); + { + uint endCheck = + BIT_endOfDStream(&bitD1) + & BIT_endOfDStream(&bitD2) + & BIT_endOfDStream(&bitD3) + & BIT_endOfDStream(&bitD4); + if (endCheck == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + return dstSize; + } + } + + private static nuint HUF_decompress4X2_usingDTable_internal_default( + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable + ) + { + return HUF_decompress4X2_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable); + } + + private static void HUF_decompress4X2_usingDTable_internal_fast_c_loop( + HUF_DecompressFastArgs* args + ) + { + ulong bits0, + bits1, + bits2, + bits3; + byte* ip0, + ip1, + ip2, + ip3; + byte* op0, + op1, + op2, + op3; + byte* oend0, + oend1, + oend2, + oend3; + HUF_DEltX2* dtable = (HUF_DEltX2*)args->dt; + byte* ilowest = args->ilowest; + bits0 = args->bits[0]; + bits1 = args->bits[1]; + bits2 = args->bits[2]; + bits3 = args->bits[3]; + ip0 = args->ip.e0; + ip1 = args->ip.e1; + ip2 = args->ip.e2; + ip3 = args->ip.e3; + op0 = args->op.e0; + op1 = args->op.e1; + op2 = args->op.e2; + op3 = args->op.e3; + oend0 = op1; + oend1 = op2; + oend2 = op3; + oend3 = args->oend; + assert(BitConverter.IsLittleEndian); + assert(!MEM_32bits); + for (; ; ) + { + byte* olimit; + { + assert(op0 <= oend0); + assert(ip0 >= ilowest); + } + + { + assert(op1 <= oend1); + assert(ip1 >= ilowest); + } + + { + assert(op2 <= oend2); + assert(ip2 >= ilowest); + } + + { + assert(op3 <= oend3); + assert(ip3 >= ilowest); + } + + { + /* Each loop does 5 table lookups for each of the 4 streams. + * Each table lookup consumes up to 11 bits of input, and produces + * up to 2 bytes of output. + */ + /* We can consume up to 7 bytes of input per iteration per stream. + * We also know that each input pointer is >= ip[0]. So we can run + * iters loops before running out of input. + */ + nuint iters = (nuint)(ip0 - ilowest) / 7; + { + nuint oiters = (nuint)(oend0 - op0) / 10; + iters = iters < oiters ? iters : oiters; + } + + { + nuint oiters = (nuint)(oend1 - op1) / 10; + iters = iters < oiters ? iters : oiters; + } + + { + nuint oiters = (nuint)(oend2 - op2) / 10; + iters = iters < oiters ? iters : oiters; + } + + { + nuint oiters = (nuint)(oend3 - op3) / 10; + iters = iters < oiters ? iters : oiters; + } + + olimit = op3 + iters * 5; + if (op3 == olimit) + break; + { + if (ip1 < ip0) + goto _out; + } + + { + if (ip2 < ip1) + goto _out; + } + + { + if (ip3 < ip2) + goto _out; + } + } + + { + assert(ip1 >= ip0); + } + + { + assert(ip2 >= ip1); + } + + { + assert(ip3 >= ip2); + } + + do + { + { + { + /* Decode 5 symbols from each of the first 3 streams. + * The final stream will be decoded during the reload phase + * to reduce register pressure. + */ + int index = (int)(bits0 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op0, entry.sequence); + bits0 <<= entry.nbBits & 0x3F; + op0 += entry.length; + } + + { + int index = (int)(bits1 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op1, entry.sequence); + bits1 <<= entry.nbBits & 0x3F; + op1 += entry.length; + } + + { + int index = (int)(bits2 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op2, entry.sequence); + bits2 <<= entry.nbBits & 0x3F; + op2 += entry.length; + } + } + + { + { + int index = (int)(bits0 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op0, entry.sequence); + bits0 <<= entry.nbBits & 0x3F; + op0 += entry.length; + } + + { + int index = (int)(bits1 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op1, entry.sequence); + bits1 <<= entry.nbBits & 0x3F; + op1 += entry.length; + } + + { + int index = (int)(bits2 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op2, entry.sequence); + bits2 <<= entry.nbBits & 0x3F; + op2 += entry.length; + } + } + + { + { + int index = (int)(bits0 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op0, entry.sequence); + bits0 <<= entry.nbBits & 0x3F; + op0 += entry.length; + } + + { + int index = (int)(bits1 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op1, entry.sequence); + bits1 <<= entry.nbBits & 0x3F; + op1 += entry.length; + } + + { + int index = (int)(bits2 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op2, entry.sequence); + bits2 <<= entry.nbBits & 0x3F; + op2 += entry.length; + } + } + + { + { + int index = (int)(bits0 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op0, entry.sequence); + bits0 <<= entry.nbBits & 0x3F; + op0 += entry.length; + } + + { + int index = (int)(bits1 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op1, entry.sequence); + bits1 <<= entry.nbBits & 0x3F; + op1 += entry.length; + } + + { + int index = (int)(bits2 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op2, entry.sequence); + bits2 <<= entry.nbBits & 0x3F; + op2 += entry.length; + } + } + + { + { + int index = (int)(bits0 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op0, entry.sequence); + bits0 <<= entry.nbBits & 0x3F; + op0 += entry.length; + } + + { + int index = (int)(bits1 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op1, entry.sequence); + bits1 <<= entry.nbBits & 0x3F; + op1 += entry.length; + } + + { + int index = (int)(bits2 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op2, entry.sequence); + bits2 <<= entry.nbBits & 0x3F; + op2 += entry.length; + } + } + + { + /* Decode one symbol from the final stream */ + int index = (int)(bits3 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op3, entry.sequence); + bits3 <<= entry.nbBits & 0x3F; + op3 += entry.length; + } + + { + { + { + /* Decode 4 symbols from the final stream & reload bitstreams. + * The final stream is reloaded last, meaning that all 5 symbols + * are decoded from the final stream before it is reloaded. + */ + int index = (int)(bits3 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op3, entry.sequence); + bits3 <<= entry.nbBits & 0x3F; + op3 += entry.length; + } + + { + int ctz = (int)ZSTD_countTrailingZeros64(bits0); + int nbBits = ctz & 7; + int nbBytes = ctz >> 3; + ip0 -= nbBytes; + bits0 = MEM_read64(ip0) | 1; + bits0 <<= nbBits; + } + } + + { + { + int index = (int)(bits3 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op3, entry.sequence); + bits3 <<= entry.nbBits & 0x3F; + op3 += entry.length; + } + + { + int ctz = (int)ZSTD_countTrailingZeros64(bits1); + int nbBits = ctz & 7; + int nbBytes = ctz >> 3; + ip1 -= nbBytes; + bits1 = MEM_read64(ip1) | 1; + bits1 <<= nbBits; + } + } + + { + { + int index = (int)(bits3 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op3, entry.sequence); + bits3 <<= entry.nbBits & 0x3F; + op3 += entry.length; + } + + { + int ctz = (int)ZSTD_countTrailingZeros64(bits2); + int nbBits = ctz & 7; + int nbBytes = ctz >> 3; + ip2 -= nbBytes; + bits2 = MEM_read64(ip2) | 1; + bits2 <<= nbBits; + } + } + + { + { + int index = (int)(bits3 >> 53); + HUF_DEltX2 entry = dtable[index]; + MEM_write16(op3, entry.sequence); + bits3 <<= entry.nbBits & 0x3F; + op3 += entry.length; + } + + { + int ctz = (int)ZSTD_countTrailingZeros64(bits3); + int nbBits = ctz & 7; + int nbBytes = ctz >> 3; + ip3 -= nbBytes; + bits3 = MEM_read64(ip3) | 1; + bits3 <<= nbBits; + } + } + } + } while (op3 < olimit); + } + + _out: + args->bits[0] = bits0; + args->bits[1] = bits1; + args->bits[2] = bits2; + args->bits[3] = bits3; + args->ip.e0 = ip0; + args->ip.e1 = ip1; + args->ip.e2 = ip2; + args->ip.e3 = ip3; + args->op.e0 = op0; + args->op.e1 = op1; + args->op.e2 = op2; + args->op.e3 = op3; + } + + private static nuint HUF_decompress4X2_usingDTable_internal_fast( + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable, + void* loopFn + ) + { + void* dt = DTable + 1; + byte* ilowest = (byte*)cSrc; + byte* oend = ZSTD_maybeNullPtrAdd((byte*)dst, (nint)dstSize); + HUF_DecompressFastArgs args; + { + nuint ret = HUF_DecompressFastArgs_init(&args, dst, dstSize, cSrc, cSrcSize, DTable); + { + nuint err_code = ret; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (ret == 0) + return 0; + } + + assert(args.ip.e0 >= args.ilowest); + ((delegate* managed)loopFn)(&args); + assert(args.ip.e0 >= ilowest); + assert(args.ip.e1 >= ilowest); + assert(args.ip.e2 >= ilowest); + assert(args.ip.e3 >= ilowest); + assert(args.op.e3 <= oend); + assert(ilowest == args.ilowest); + assert(ilowest + 6 == args.iend.e0); + { + nuint segmentSize = (dstSize + 3) / 4; + byte* segmentEnd = (byte*)dst; + int i; + for (i = 0; i < 4; ++i) + { + BIT_DStream_t bit; + if (segmentSize <= (nuint)(oend - segmentEnd)) + segmentEnd += segmentSize; + else + segmentEnd = oend; + { + nuint err_code = HUF_initRemainingDStream(&bit, &args, i, segmentEnd); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + (&args.op.e0)[i] += HUF_decodeStreamX2( + (&args.op.e0)[i], + &bit, + segmentEnd, + (HUF_DEltX2*)dt, + 11 + ); + if ((&args.op.e0)[i] != segmentEnd) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + } + + return dstSize; + } + + private static nuint HUF_decompress4X2_usingDTable_internal( + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable, + int flags + ) + { + void* fallbackFn = (delegate* managed)( + &HUF_decompress4X2_usingDTable_internal_default + ); + void* loopFn = (delegate* managed)( + &HUF_decompress4X2_usingDTable_internal_fast_c_loop + ); + if ((flags & (int)HUF_flags_e.HUF_flags_disableFast) == 0) + { + nuint ret = HUF_decompress4X2_usingDTable_internal_fast( + dst, + dstSize, + cSrc, + cSrcSize, + DTable, + loopFn + ); + if (ret != 0) + return ret; + } + + return ((delegate* managed)fallbackFn)( + dst, + dstSize, + cSrc, + cSrcSize, + DTable + ); + } + + private static nuint HUF_decompress1X2_usingDTable_internal( + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable, + int flags + ) + { + return HUF_decompress1X2_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable); + } + + private static nuint HUF_decompress1X2_DCtx_wksp( + uint* DCtx, + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + void* workSpace, + nuint wkspSize, + int flags + ) + { + byte* ip = (byte*)cSrc; + nuint hSize = HUF_readDTableX2_wksp(DCtx, cSrc, cSrcSize, workSpace, wkspSize, flags); + if (ERR_isError(hSize)) + return hSize; + if (hSize >= cSrcSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + ip += hSize; + cSrcSize -= hSize; + return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, flags); + } + + private static nuint HUF_decompress4X2_DCtx_wksp( + uint* dctx, + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + void* workSpace, + nuint wkspSize, + int flags + ) + { + byte* ip = (byte*)cSrc; + nuint hSize = HUF_readDTableX2_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize, flags); + if (ERR_isError(hSize)) + return hSize; + if (hSize >= cSrcSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + ip += hSize; + cSrcSize -= hSize; + return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, flags); + } + + private static readonly algo_time_t[][] algoTime = new algo_time_t[16][] + { + new algo_time_t[2] + { + new algo_time_t(tableTime: 0, decode256Time: 0), + new algo_time_t(tableTime: 1, decode256Time: 1), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 0, decode256Time: 0), + new algo_time_t(tableTime: 1, decode256Time: 1), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 150, decode256Time: 216), + new algo_time_t(tableTime: 381, decode256Time: 119), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 170, decode256Time: 205), + new algo_time_t(tableTime: 514, decode256Time: 112), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 177, decode256Time: 199), + new algo_time_t(tableTime: 539, decode256Time: 110), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 197, decode256Time: 194), + new algo_time_t(tableTime: 644, decode256Time: 107), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 221, decode256Time: 192), + new algo_time_t(tableTime: 735, decode256Time: 107), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 256, decode256Time: 189), + new algo_time_t(tableTime: 881, decode256Time: 106), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 359, decode256Time: 188), + new algo_time_t(tableTime: 1167, decode256Time: 109), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 582, decode256Time: 187), + new algo_time_t(tableTime: 1570, decode256Time: 114), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 688, decode256Time: 187), + new algo_time_t(tableTime: 1712, decode256Time: 122), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 825, decode256Time: 186), + new algo_time_t(tableTime: 1965, decode256Time: 136), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 976, decode256Time: 185), + new algo_time_t(tableTime: 2131, decode256Time: 150), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 1180, decode256Time: 186), + new algo_time_t(tableTime: 2070, decode256Time: 175), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 1377, decode256Time: 185), + new algo_time_t(tableTime: 1731, decode256Time: 202), + }, + new algo_time_t[2] + { + new algo_time_t(tableTime: 1412, decode256Time: 185), + new algo_time_t(tableTime: 1695, decode256Time: 202), + }, + }; + + /** HUF_selectDecoder() : + * Tells which decoder is likely to decode faster, + * based on a set of pre-computed metrics. + * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 . + * Assumption : 0 < dstSize <= 128 KB */ + private static uint HUF_selectDecoder(nuint dstSize, nuint cSrcSize) + { + assert(dstSize > 0); + assert(dstSize <= 128 * 1024); + { + /* Q < 16 */ + uint Q = cSrcSize >= dstSize ? 15 : (uint)(cSrcSize * 16 / dstSize); + uint D256 = (uint)(dstSize >> 8); + uint DTime0 = algoTime[Q][0].tableTime + algoTime[Q][0].decode256Time * D256; + uint DTime1 = algoTime[Q][1].tableTime + algoTime[Q][1].decode256Time * D256; + DTime1 += DTime1 >> 5; + return DTime1 < DTime0 ? 1U : 0U; + } + } + + private static nuint HUF_decompress1X_DCtx_wksp( + uint* dctx, + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + void* workSpace, + nuint wkspSize, + int flags + ) + { + if (dstSize == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + if (cSrcSize > dstSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + if (cSrcSize == dstSize) + { + memcpy(dst, cSrc, (uint)dstSize); + return dstSize; + } + + if (cSrcSize == 1) + { + memset(dst, *(byte*)cSrc, (uint)dstSize); + return dstSize; + } + + { + uint algoNb = HUF_selectDecoder(dstSize, cSrcSize); + return algoNb != 0 + ? HUF_decompress1X2_DCtx_wksp( + dctx, + dst, + dstSize, + cSrc, + cSrcSize, + workSpace, + wkspSize, + flags + ) + : HUF_decompress1X1_DCtx_wksp( + dctx, + dst, + dstSize, + cSrc, + cSrcSize, + workSpace, + wkspSize, + flags + ); + } + } + + /* BMI2 variants. + * If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0. + */ + private static nuint HUF_decompress1X_usingDTable( + void* dst, + nuint maxDstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable, + int flags + ) + { + DTableDesc dtd = HUF_getDTableDesc(DTable); + return dtd.tableType != 0 + ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags) + : HUF_decompress1X1_usingDTable_internal( + dst, + maxDstSize, + cSrc, + cSrcSize, + DTable, + flags + ); + } + + private static nuint HUF_decompress1X1_DCtx_wksp( + uint* dctx, + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + void* workSpace, + nuint wkspSize, + int flags + ) + { + byte* ip = (byte*)cSrc; + nuint hSize = HUF_readDTableX1_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize, flags); + if (ERR_isError(hSize)) + return hSize; + if (hSize >= cSrcSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + ip += hSize; + cSrcSize -= hSize; + return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, flags); + } + + private static nuint HUF_decompress4X_usingDTable( + void* dst, + nuint maxDstSize, + void* cSrc, + nuint cSrcSize, + uint* DTable, + int flags + ) + { + DTableDesc dtd = HUF_getDTableDesc(DTable); + return dtd.tableType != 0 + ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags) + : HUF_decompress4X1_usingDTable_internal( + dst, + maxDstSize, + cSrc, + cSrcSize, + DTable, + flags + ); + } + + private static nuint HUF_decompress4X_hufOnly_wksp( + uint* dctx, + void* dst, + nuint dstSize, + void* cSrc, + nuint cSrcSize, + void* workSpace, + nuint wkspSize, + int flags + ) + { + if (dstSize == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + if (cSrcSize == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + { + uint algoNb = HUF_selectDecoder(dstSize, cSrcSize); + return algoNb != 0 + ? HUF_decompress4X2_DCtx_wksp( + dctx, + dst, + dstSize, + cSrc, + cSrcSize, + workSpace, + wkspSize, + flags + ) + : HUF_decompress4X1_DCtx_wksp( + dctx, + dst, + dstSize, + cSrc, + cSrcSize, + workSpace, + wkspSize, + flags + ); + } + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Mem.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Mem.cs new file mode 100644 index 000000000..673c7c95f --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Mem.cs @@ -0,0 +1,162 @@ +using System; +using System.Buffers.Binary; +using System.Runtime.CompilerServices; +using BclUnsafe = System.Runtime.CompilerServices.Unsafe; + +// ReSharper disable InconsistentNaming +// ReSharper disable IdentifierTypo + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /*-************************************************************** + * Memory I/O API + *****************************************************************/ + /*=== Static platform detection ===*/ + private static bool MEM_32bits + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get => sizeof(nint) == 4; + } + + private static bool MEM_64bits + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get => sizeof(nint) == 8; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + /* default method, safe and standard. + can sometimes prove slower */ + private static ushort MEM_read16(void* memPtr) => BclUnsafe.ReadUnaligned(memPtr); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint MEM_read32(void* memPtr) => BclUnsafe.ReadUnaligned(memPtr); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ulong MEM_read64(void* memPtr) => BclUnsafe.ReadUnaligned(memPtr); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint MEM_readST(void* memPtr) => BclUnsafe.ReadUnaligned(memPtr); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void MEM_write16(void* memPtr, ushort value) => + BclUnsafe.WriteUnaligned(memPtr, value); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void MEM_write64(void* memPtr, ulong value) => + BclUnsafe.WriteUnaligned(memPtr, value); + + /*=== Little endian r/w ===*/ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ushort MEM_readLE16(void* memPtr) + { + var val = BclUnsafe.ReadUnaligned(memPtr); + if (!BitConverter.IsLittleEndian) + { + val = BinaryPrimitives.ReverseEndianness(val); + } + return val; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void MEM_writeLE16(void* memPtr, ushort val) + { + if (!BitConverter.IsLittleEndian) + { + val = BinaryPrimitives.ReverseEndianness(val); + } + BclUnsafe.WriteUnaligned(memPtr, val); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint MEM_readLE24(void* memPtr) => + (uint)(MEM_readLE16(memPtr) + (((byte*)memPtr)[2] << 16)); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void MEM_writeLE24(void* memPtr, uint val) + { + MEM_writeLE16(memPtr, (ushort)val); + ((byte*)memPtr)[2] = (byte)(val >> 16); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint MEM_readLE32(void* memPtr) + { + var val = BclUnsafe.ReadUnaligned(memPtr); + if (!BitConverter.IsLittleEndian) + { + val = BinaryPrimitives.ReverseEndianness(val); + } + return val; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void MEM_writeLE32(void* memPtr, uint val32) + { + if (!BitConverter.IsLittleEndian) + { + val32 = BinaryPrimitives.ReverseEndianness(val32); + } + BclUnsafe.WriteUnaligned(memPtr, val32); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ulong MEM_readLE64(void* memPtr) + { + var val = BclUnsafe.ReadUnaligned(memPtr); + if (!BitConverter.IsLittleEndian) + { + val = BinaryPrimitives.ReverseEndianness(val); + } + return val; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void MEM_writeLE64(void* memPtr, ulong val64) + { + if (!BitConverter.IsLittleEndian) + { + val64 = BinaryPrimitives.ReverseEndianness(val64); + } + BclUnsafe.WriteUnaligned(memPtr, val64); + } + +#if !NET8_0_OR_GREATER + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ReverseEndiannessNative(nuint val) => + MEM_32bits + ? BinaryPrimitives.ReverseEndianness((uint)val) + : (nuint)BinaryPrimitives.ReverseEndianness(val); +#endif + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint MEM_readLEST(void* memPtr) + { + var val = BclUnsafe.ReadUnaligned(memPtr); + if (!BitConverter.IsLittleEndian) + { +#if NET8_0_OR_GREATER + val = BinaryPrimitives.ReverseEndianness(val); +#else + val = ReverseEndiannessNative(val); +#endif + } + return val; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void MEM_writeLEST(void* memPtr, nuint val) + { + if (!BitConverter.IsLittleEndian) + { +#if NET8_0_OR_GREATER + val = BinaryPrimitives.ReverseEndianness(val); +#else + val = ReverseEndiannessNative(val); +#endif + } + BclUnsafe.WriteUnaligned(memPtr, val); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Pool.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Pool.cs new file mode 100644 index 000000000..a7a4e5fec --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Pool.cs @@ -0,0 +1,122 @@ +using SharpCompress.Compressors.ZStandard.Unsafe; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + private static JobThreadPool GetThreadPool(void* ctx) => + UnmanagedObject.Unwrap(ctx); + + /* ZSTD_createThreadPool() : public access point */ + public static void* ZSTD_createThreadPool(nuint numThreads) + { + return POOL_create(numThreads, 0); + } + + /*! POOL_create() : + * Create a thread pool with at most `numThreads` threads. + * `numThreads` must be at least 1. + * The maximum number of queued jobs before blocking is `queueSize`. + * @return : POOL_ctx pointer on success, else NULL. + */ + private static void* POOL_create(nuint numThreads, nuint queueSize) + { + return POOL_create_advanced(numThreads, queueSize, Unsafe.Methods.ZSTD_defaultCMem); + } + + private static void* POOL_create_advanced( + nuint numThreads, + nuint queueSize, + ZSTD_customMem customMem + ) + { + var jobThreadPool = new JobThreadPool((int)numThreads, (int)queueSize); + return UnmanagedObject.Wrap(jobThreadPool); + } + + /*! POOL_join() : + Shutdown the queue, wake any sleeping threads, and join all of the threads. + */ + private static void POOL_join(void* ctx) + { + GetThreadPool(ctx).Join(); + } + + /*! POOL_free() : + * Free a thread pool returned by POOL_create(). + */ + private static void POOL_free(void* ctx) + { + if (ctx == null) + { + return; + } + + var jobThreadPool = GetThreadPool(ctx); + jobThreadPool.Join(); + jobThreadPool.Dispose(); + UnmanagedObject.Free(ctx); + } + + /*! POOL_joinJobs() : + * Waits for all queued jobs to finish executing. + */ + private static void POOL_joinJobs(void* ctx) + { + var jobThreadPool = GetThreadPool(ctx); + jobThreadPool.Join(false); + } + + public static void ZSTD_freeThreadPool(void* pool) + { + POOL_free(pool); + } + + /*! POOL_sizeof() : + * @return threadpool memory usage + * note : compatible with NULL (returns 0 in this case) + */ + private static nuint POOL_sizeof(void* ctx) + { + if (ctx == null) + return 0; + var jobThreadPool = GetThreadPool(ctx); + return (nuint)jobThreadPool.Size(); + } + + /* @return : 0 on success, 1 on error */ + private static int POOL_resize(void* ctx, nuint numThreads) + { + if (ctx == null) + return 1; + var jobThreadPool = GetThreadPool(ctx); + jobThreadPool.Resize((int)numThreads); + return 0; + } + + /*! POOL_add() : + * Add the job `function(opaque)` to the thread pool. `ctx` must be valid. + * Possibly blocks until there is room in the queue. + * Note : The function may be executed asynchronously, + * therefore, `opaque` must live until function has been completed. + */ + private static void POOL_add(void* ctx, void* function, void* opaque) + { + assert(ctx != null); + var jobThreadPool = GetThreadPool(ctx); + jobThreadPool.Add(function, opaque); + } + + /*! POOL_tryAdd() : + * Add the job `function(opaque)` to thread pool _if_ a queue slot is available. + * Returns immediately even if not (does not block). + * @return : 1 if successful, 0 if not. + */ + private static int POOL_tryAdd(void* ctx, void* function, void* opaque) + { + assert(ctx != null); + var jobThreadPool = GetThreadPool(ctx); + return jobThreadPool.TryAdd(function, opaque) ? 1 : 0; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/RSyncState_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/RSyncState_t.cs new file mode 100644 index 000000000..7b5f08ad9 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/RSyncState_t.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct RSyncState_t +{ + public ulong hash; + public ulong hitMask; + public ulong primePower; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Range.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Range.cs new file mode 100644 index 000000000..fabf08b0a --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Range.cs @@ -0,0 +1,14 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* ==== Serial State ==== */ +public unsafe struct Range +{ + public void* start; + public nuint size; + + public Range(void* start, nuint size) + { + this.start = start; + this.size = size; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/RawSeqStore_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/RawSeqStore_t.cs new file mode 100644 index 000000000..07db05a17 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/RawSeqStore_t.cs @@ -0,0 +1,29 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct RawSeqStore_t +{ + /* The start of the sequences */ + public rawSeq* seq; + + /* The index in seq where reading stopped. pos <= size. */ + public nuint pos; + + /* The position within the sequence at seq[pos] where reading + stopped. posInSequence <= seq[pos].litLength + seq[pos].matchLength */ + public nuint posInSequence; + + /* The number of sequences. <= capacity. */ + public nuint size; + + /* The capacity starting from `seq` pointer */ + public nuint capacity; + + public RawSeqStore_t(rawSeq* seq, nuint pos, nuint posInSequence, nuint size, nuint capacity) + { + this.seq = seq; + this.pos = pos; + this.posInSequence = posInSequence; + this.size = size; + this.capacity = capacity; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/RoundBuff_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/RoundBuff_t.cs new file mode 100644 index 000000000..84e42ca41 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/RoundBuff_t.cs @@ -0,0 +1,28 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct RoundBuff_t +{ + /* The round input buffer. All jobs get references + * to pieces of the buffer. ZSTDMT_tryGetInputRange() + * handles handing out job input buffers, and makes + * sure it doesn't overlap with any pieces still in use. + */ + public byte* buffer; + + /* The capacity of buffer. */ + public nuint capacity; + + /* The position of the current inBuff in the round + * buffer. Updated past the end if the inBuff once + * the inBuff is sent to the worker thread. + * pos <= capacity. + */ + public nuint pos; + + public RoundBuff_t(byte* buffer, nuint capacity, nuint pos) + { + this.buffer = buffer; + this.capacity = capacity; + this.pos = pos; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/SeqCollector.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/SeqCollector.cs new file mode 100644 index 000000000..8026ed92a --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/SeqCollector.cs @@ -0,0 +1,9 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct SeqCollector +{ + public int collectSequences; + public ZSTD_Sequence* seqStart; + public nuint seqIndex; + public nuint maxSequences; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/SeqDef_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/SeqDef_s.cs new file mode 100644 index 000000000..1e5aac57e --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/SeqDef_s.cs @@ -0,0 +1,14 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*********************************************** + * Sequences * + ***********************************************/ +public struct SeqDef_s +{ + /* offBase == Offset + ZSTD_REP_NUM, or repcode 1,2,3 */ + public uint offBase; + public ushort litLength; + + /* mlBase == matchLength - MINMATCH */ + public ushort mlBase; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/SeqStore_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/SeqStore_t.cs new file mode 100644 index 000000000..6aa751619 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/SeqStore_t.cs @@ -0,0 +1,27 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct SeqStore_t +{ + public SeqDef_s* sequencesStart; + + /* ptr to end of sequences */ + public SeqDef_s* sequences; + public byte* litStart; + + /* ptr to end of literals */ + public byte* lit; + public byte* llCode; + public byte* mlCode; + public byte* ofCode; + public nuint maxNbSeq; + public nuint maxNbLit; + + /* longLengthPos and longLengthType to allow us to represent either a single litLength or matchLength + * in the seqStore that has a value larger than U16 (if it exists). To do so, we increment + * the existing value of the litLength or matchLength by 0x10000. + */ + public ZSTD_longLengthType_e longLengthType; + + /* Index of the sequence to apply long length modification to */ + public uint longLengthPos; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/SerialState.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/SerialState.cs new file mode 100644 index 000000000..91d403e3a --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/SerialState.cs @@ -0,0 +1,23 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct SerialState +{ + /* All variables in the struct are protected by mutex. */ + public void* mutex; + public void* cond; + public ZSTD_CCtx_params_s @params; + public ldmState_t ldmState; + public XXH64_state_s xxhState; + public uint nextJobID; + + /* Protects ldmWindow. + * Must be acquired after the main mutex when acquiring both. + */ + public void* ldmWindowMutex; + + /* Signaled when ldmWindow is updated */ + public void* ldmWindowCond; + + /* A thread-safe copy of ldmState.window */ + public ZSTD_window_t ldmWindow; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/SymbolEncodingType_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/SymbolEncodingType_e.cs new file mode 100644 index 000000000..06d78d45a --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/SymbolEncodingType_e.cs @@ -0,0 +1,9 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum SymbolEncodingType_e +{ + set_basic, + set_rle, + set_compressed, + set_repeat, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/SyncPoint.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/SyncPoint.cs new file mode 100644 index 000000000..fda2ea51e --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/SyncPoint.cs @@ -0,0 +1,10 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct SyncPoint +{ + /* The number of bytes to load from the input. */ + public nuint toLoad; + + /* Boolean declaring if we must flush because we found a synchronization point. */ + public int flush; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH32_canonical_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH32_canonical_t.cs new file mode 100644 index 000000000..7da74bdf9 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH32_canonical_t.cs @@ -0,0 +1,10 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*! + * @brief Canonical (big endian) representation of @ref XXH32_hash_t. + */ +public unsafe struct XXH32_canonical_t +{ + /*!< Hash bytes, big endian */ + public fixed byte digest[4]; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH32_state_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH32_state_s.cs new file mode 100644 index 000000000..09559a84a --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH32_state_s.cs @@ -0,0 +1,34 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*! + * @internal + * @brief Structure for XXH32 streaming API. + * + * @note This is only defined when @ref XXH_STATIC_LINKING_ONLY, + * @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined. Otherwise it is + * an opaque type. This allows fields to safely be changed. + * + * Typedef'd to @ref XXH32_state_t. + * Do not access the members of this struct directly. + * @see XXH64_state_s, XXH3_state_s + */ +public unsafe struct XXH32_state_s +{ + /*!< Total length hashed, modulo 2^32 */ + public uint total_len_32; + + /*!< Whether the hash is >= 16 (handles @ref total_len_32 overflow) */ + public uint large_len; + + /*!< Accumulator lanes */ + public fixed uint v[4]; + + /*!< Internal buffer for partial reads. Treated as unsigned char[16]. */ + public fixed uint mem32[4]; + + /*!< Amount of data in @ref mem32 */ + public uint memsize; + + /*!< Reserved field. Do not read nor write to it. */ + public uint reserved; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH64_canonical_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH64_canonical_t.cs new file mode 100644 index 000000000..a50409885 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH64_canonical_t.cs @@ -0,0 +1,9 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*! + * @brief Canonical (big endian) representation of @ref XXH64_hash_t. + */ +public unsafe struct XXH64_canonical_t +{ + public fixed byte digest[8]; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH64_state_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH64_state_s.cs new file mode 100644 index 000000000..d2503d08c --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH64_state_s.cs @@ -0,0 +1,34 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*! + * @internal + * @brief Structure for XXH64 streaming API. + * + * @note This is only defined when @ref XXH_STATIC_LINKING_ONLY, + * @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined. Otherwise it is + * an opaque type. This allows fields to safely be changed. + * + * Typedef'd to @ref XXH64_state_t. + * Do not access the members of this struct directly. + * @see XXH32_state_s, XXH3_state_s + */ +public unsafe struct XXH64_state_s +{ + /*!< Total length hashed. This is always 64-bit. */ + public ulong total_len; + + /*!< Accumulator lanes */ + public fixed ulong v[4]; + + /*!< Internal buffer for partial reads. Treated as unsigned char[32]. */ + public fixed ulong mem64[4]; + + /*!< Amount of data in @ref mem64 */ + public uint memsize; + + /*!< Reserved field, needed for padding anyways*/ + public uint reserved32; + + /*!< Reserved field. Do not read or write to it. */ + public ulong reserved64; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH_alignment.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH_alignment.cs new file mode 100644 index 000000000..57b988099 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH_alignment.cs @@ -0,0 +1,14 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*! + * @internal + * @brief Enum to indicate whether a pointer is aligned. + */ +public enum XXH_alignment +{ + /*!< Aligned */ + XXH_aligned, + + /*!< Possibly unaligned */ + XXH_unaligned, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH_errorcode.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH_errorcode.cs new file mode 100644 index 000000000..eb65ceb14 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/XXH_errorcode.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*! + * @brief Exit code for the streaming API. + */ +public enum XXH_errorcode +{ + /*!< OK */ + XXH_OK = 0, + + /*!< Error */ + XXH_ERROR, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Xxhash.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Xxhash.cs new file mode 100644 index 000000000..ab8d814b5 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Xxhash.cs @@ -0,0 +1,626 @@ +using System; +using System.Buffers.Binary; +using System.Numerics; +using System.Runtime.CompilerServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /*! + * @internal + * @brief Modify this function to use a different routine than malloc(). + */ + private static void* XXH_malloc(nuint s) + { + return malloc(s); + } + + /*! + * @internal + * @brief Modify this function to use a different routine than free(). + */ + private static void XXH_free(void* p) + { + free(p); + } + + /*! + * @internal + * @brief Modify this function to use a different routine than memcpy(). + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void XXH_memcpy(void* dest, void* src, nuint size) + { + memcpy(dest, src, (uint)size); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint XXH_readLE32(void* ptr) + { + return BitConverter.IsLittleEndian + ? MEM_read32(ptr) + : BinaryPrimitives.ReverseEndianness(MEM_read32(ptr)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint XXH_readBE32(void* ptr) + { + return BitConverter.IsLittleEndian + ? BinaryPrimitives.ReverseEndianness(MEM_read32(ptr)) + : MEM_read32(ptr); + } + + private static uint XXH_readLE32_align(void* ptr, XXH_alignment align) + { + if (align == XXH_alignment.XXH_unaligned) + { + return XXH_readLE32(ptr); + } + else + { + return BitConverter.IsLittleEndian + ? *(uint*)ptr + : BinaryPrimitives.ReverseEndianness(*(uint*)ptr); + } + } + + /* ************************************* + * Misc + ***************************************/ + /*! @ingroup public */ + private static uint ZSTD_XXH_versionNumber() + { + return 0 * 100 * 100 + 8 * 100 + 2; + } + + /*! + * @internal + * @brief Normal stripe processing routine. + * + * This shuffles the bits so that any bit from @p input impacts several bits in + * @p acc. + * + * @param acc The accumulator lane. + * @param input The stripe of input to mix. + * @return The mixed accumulator lane. + */ + private static uint XXH32_round(uint acc, uint input) + { + acc += input * 0x85EBCA77U; + acc = BitOperations.RotateLeft(acc, 13); + acc *= 0x9E3779B1U; + return acc; + } + + /*! + * @internal + * @brief Mixes all bits to finalize the hash. + * + * The final mix ensures that all input bits have a chance to impact any bit in + * the output digest, resulting in an unbiased distribution. + * + * @param hash The hash to avalanche. + * @return The avalanched hash. + */ + private static uint XXH32_avalanche(uint hash) + { + hash ^= hash >> 15; + hash *= 0x85EBCA77U; + hash ^= hash >> 13; + hash *= 0xC2B2AE3DU; + hash ^= hash >> 16; + return hash; + } + + /*! + * @internal + * @brief Processes the last 0-15 bytes of @p ptr. + * + * There may be up to 15 bytes remaining to consume from the input. + * This final stage will digest them to ensure that all input bytes are present + * in the final mix. + * + * @param hash The hash to finalize. + * @param ptr The pointer to the remaining input. + * @param len The remaining length, modulo 16. + * @param align Whether @p ptr is aligned. + * @return The finalized hash. + * @see XXH64_finalize(). + */ + private static uint XXH32_finalize(uint hash, byte* ptr, nuint len, XXH_alignment align) + { + len &= 15; + while (len >= 4) + { + { + hash += XXH_readLE32_align(ptr, align) * 0xC2B2AE3DU; + ptr += 4; + hash = BitOperations.RotateLeft(hash, 17) * 0x27D4EB2FU; + } + + len -= 4; + } + + while (len > 0) + { + { + hash += *ptr++ * 0x165667B1U; + hash = BitOperations.RotateLeft(hash, 11) * 0x9E3779B1U; + } + + --len; + } + + return XXH32_avalanche(hash); + } + + /*! + * @internal + * @brief The implementation for @ref XXH32(). + * + * @param input , len , seed Directly passed from @ref XXH32(). + * @param align Whether @p input is aligned. + * @return The calculated hash. + */ + private static uint XXH32_endian_align(byte* input, nuint len, uint seed, XXH_alignment align) + { + uint h32; + if (len >= 16) + { + byte* bEnd = input + len; + byte* limit = bEnd - 15; + uint v1 = seed + 0x9E3779B1U + 0x85EBCA77U; + uint v2 = seed + 0x85EBCA77U; + uint v3 = seed + 0; + uint v4 = seed - 0x9E3779B1U; + do + { + v1 = XXH32_round(v1, XXH_readLE32_align(input, align)); + input += 4; + v2 = XXH32_round(v2, XXH_readLE32_align(input, align)); + input += 4; + v3 = XXH32_round(v3, XXH_readLE32_align(input, align)); + input += 4; + v4 = XXH32_round(v4, XXH_readLE32_align(input, align)); + input += 4; + } while (input < limit); + h32 = + BitOperations.RotateLeft(v1, 1) + + BitOperations.RotateLeft(v2, 7) + + BitOperations.RotateLeft(v3, 12) + + BitOperations.RotateLeft(v4, 18); + } + else + { + h32 = seed + 0x165667B1U; + } + + h32 += (uint)len; + return XXH32_finalize(h32, input, len & 15, align); + } + + /*! @ingroup XXH32_family */ + private static uint ZSTD_XXH32(void* input, nuint len, uint seed) + { + return XXH32_endian_align((byte*)input, len, seed, XXH_alignment.XXH_unaligned); + } + + /*! @ingroup XXH32_family */ + private static XXH32_state_s* ZSTD_XXH32_createState() + { + return (XXH32_state_s*)XXH_malloc((nuint)sizeof(XXH32_state_s)); + } + + /*! @ingroup XXH32_family */ + private static XXH_errorcode ZSTD_XXH32_freeState(XXH32_state_s* statePtr) + { + XXH_free(statePtr); + return XXH_errorcode.XXH_OK; + } + + /*! @ingroup XXH32_family */ + private static void ZSTD_XXH32_copyState(XXH32_state_s* dstState, XXH32_state_s* srcState) + { + XXH_memcpy(dstState, srcState, (nuint)sizeof(XXH32_state_s)); + } + + /*! @ingroup XXH32_family */ + private static XXH_errorcode ZSTD_XXH32_reset(XXH32_state_s* statePtr, uint seed) + { + *statePtr = new XXH32_state_s(); + statePtr->v[0] = seed + 0x9E3779B1U + 0x85EBCA77U; + statePtr->v[1] = seed + 0x85EBCA77U; + statePtr->v[2] = seed + 0; + statePtr->v[3] = seed - 0x9E3779B1U; + return XXH_errorcode.XXH_OK; + } + + /*! @ingroup XXH32_family */ + private static XXH_errorcode ZSTD_XXH32_update(XXH32_state_s* state, void* input, nuint len) + { + if (input == null) + { + return XXH_errorcode.XXH_OK; + } + + { + byte* p = (byte*)input; + byte* bEnd = p + len; + state->total_len_32 += (uint)len; + state->large_len |= len >= 16 || state->total_len_32 >= 16 ? 1U : 0U; + if (state->memsize + len < 16) + { + XXH_memcpy((byte*)state->mem32 + state->memsize, input, len); + state->memsize += (uint)len; + return XXH_errorcode.XXH_OK; + } + + if (state->memsize != 0) + { + XXH_memcpy((byte*)state->mem32 + state->memsize, input, 16 - state->memsize); + { + uint* p32 = state->mem32; + state->v[0] = XXH32_round(state->v[0], XXH_readLE32(p32)); + p32++; + state->v[1] = XXH32_round(state->v[1], XXH_readLE32(p32)); + p32++; + state->v[2] = XXH32_round(state->v[2], XXH_readLE32(p32)); + p32++; + state->v[3] = XXH32_round(state->v[3], XXH_readLE32(p32)); + } + + p += 16 - state->memsize; + state->memsize = 0; + } + + if (p <= bEnd - 16) + { + byte* limit = bEnd - 16; + do + { + state->v[0] = XXH32_round(state->v[0], XXH_readLE32(p)); + p += 4; + state->v[1] = XXH32_round(state->v[1], XXH_readLE32(p)); + p += 4; + state->v[2] = XXH32_round(state->v[2], XXH_readLE32(p)); + p += 4; + state->v[3] = XXH32_round(state->v[3], XXH_readLE32(p)); + p += 4; + } while (p <= limit); + } + + if (p < bEnd) + { + XXH_memcpy(state->mem32, p, (nuint)(bEnd - p)); + state->memsize = (uint)(bEnd - p); + } + } + + return XXH_errorcode.XXH_OK; + } + + /*! @ingroup XXH32_family */ + private static uint ZSTD_XXH32_digest(XXH32_state_s* state) + { + uint h32; + if (state->large_len != 0) + { + h32 = + BitOperations.RotateLeft(state->v[0], 1) + + BitOperations.RotateLeft(state->v[1], 7) + + BitOperations.RotateLeft(state->v[2], 12) + + BitOperations.RotateLeft(state->v[3], 18); + } + else + { + h32 = state->v[2] + 0x165667B1U; + } + + h32 += state->total_len_32; + return XXH32_finalize(h32, (byte*)state->mem32, state->memsize, XXH_alignment.XXH_aligned); + } + + /*! @ingroup XXH32_family */ + private static void ZSTD_XXH32_canonicalFromHash(XXH32_canonical_t* dst, uint hash) + { + assert(sizeof(XXH32_canonical_t) == sizeof(uint)); + if (BitConverter.IsLittleEndian) + hash = BinaryPrimitives.ReverseEndianness(hash); + XXH_memcpy(dst, &hash, (nuint)sizeof(XXH32_canonical_t)); + } + + /*! @ingroup XXH32_family */ + private static uint ZSTD_XXH32_hashFromCanonical(XXH32_canonical_t* src) + { + return XXH_readBE32(src); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ulong XXH_readLE64(void* ptr) + { + return BitConverter.IsLittleEndian + ? MEM_read64(ptr) + : BinaryPrimitives.ReverseEndianness(MEM_read64(ptr)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ulong XXH_readBE64(void* ptr) + { + return BitConverter.IsLittleEndian + ? BinaryPrimitives.ReverseEndianness(MEM_read64(ptr)) + : MEM_read64(ptr); + } + + private static ulong XXH_readLE64_align(void* ptr, XXH_alignment align) + { + if (align == XXH_alignment.XXH_unaligned) + return XXH_readLE64(ptr); + else + return BitConverter.IsLittleEndian + ? *(ulong*)ptr + : BinaryPrimitives.ReverseEndianness(*(ulong*)ptr); + } + + /*! @copydoc XXH32_round */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ulong XXH64_round(ulong acc, ulong input) + { + acc += input * 0xC2B2AE3D27D4EB4FUL; + acc = BitOperations.RotateLeft(acc, 31); + acc *= 0x9E3779B185EBCA87UL; + return acc; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ulong XXH64_mergeRound(ulong acc, ulong val) + { + val = XXH64_round(0, val); + acc ^= val; + acc = acc * 0x9E3779B185EBCA87UL + 0x85EBCA77C2B2AE63UL; + return acc; + } + + /*! @copydoc XXH32_avalanche */ + private static ulong XXH64_avalanche(ulong hash) + { + hash ^= hash >> 33; + hash *= 0xC2B2AE3D27D4EB4FUL; + hash ^= hash >> 29; + hash *= 0x165667B19E3779F9UL; + hash ^= hash >> 32; + return hash; + } + + /*! + * @internal + * @brief Processes the last 0-31 bytes of @p ptr. + * + * There may be up to 31 bytes remaining to consume from the input. + * This final stage will digest them to ensure that all input bytes are present + * in the final mix. + * + * @param hash The hash to finalize. + * @param ptr The pointer to the remaining input. + * @param len The remaining length, modulo 32. + * @param align Whether @p ptr is aligned. + * @return The finalized hash + * @see XXH32_finalize(). + */ + private static ulong XXH64_finalize(ulong hash, byte* ptr, nuint len, XXH_alignment align) + { + len &= 31; + while (len >= 8) + { + ulong k1 = XXH64_round(0, XXH_readLE64_align(ptr, align)); + ptr += 8; + hash ^= k1; + hash = BitOperations.RotateLeft(hash, 27) * 0x9E3779B185EBCA87UL + 0x85EBCA77C2B2AE63UL; + len -= 8; + } + + if (len >= 4) + { + hash ^= XXH_readLE32_align(ptr, align) * 0x9E3779B185EBCA87UL; + ptr += 4; + hash = BitOperations.RotateLeft(hash, 23) * 0xC2B2AE3D27D4EB4FUL + 0x165667B19E3779F9UL; + len -= 4; + } + + while (len > 0) + { + hash ^= *ptr++ * 0x27D4EB2F165667C5UL; + hash = BitOperations.RotateLeft(hash, 11) * 0x9E3779B185EBCA87UL; + --len; + } + + return XXH64_avalanche(hash); + } + + /*! + * @internal + * @brief The implementation for @ref XXH64(). + * + * @param input , len , seed Directly passed from @ref XXH64(). + * @param align Whether @p input is aligned. + * @return The calculated hash. + */ + private static ulong XXH64_endian_align(byte* input, nuint len, ulong seed, XXH_alignment align) + { + ulong h64; + if (len >= 32) + { + byte* bEnd = input + len; + byte* limit = bEnd - 31; + ulong v1 = seed + 0x9E3779B185EBCA87UL + 0xC2B2AE3D27D4EB4FUL; + ulong v2 = seed + 0xC2B2AE3D27D4EB4FUL; + ulong v3 = seed + 0; + ulong v4 = seed - 0x9E3779B185EBCA87UL; + do + { + v1 = XXH64_round(v1, XXH_readLE64_align(input, align)); + input += 8; + v2 = XXH64_round(v2, XXH_readLE64_align(input, align)); + input += 8; + v3 = XXH64_round(v3, XXH_readLE64_align(input, align)); + input += 8; + v4 = XXH64_round(v4, XXH_readLE64_align(input, align)); + input += 8; + } while (input < limit); + h64 = + BitOperations.RotateLeft(v1, 1) + + BitOperations.RotateLeft(v2, 7) + + BitOperations.RotateLeft(v3, 12) + + BitOperations.RotateLeft(v4, 18); + h64 = XXH64_mergeRound(h64, v1); + h64 = XXH64_mergeRound(h64, v2); + h64 = XXH64_mergeRound(h64, v3); + h64 = XXH64_mergeRound(h64, v4); + } + else + { + h64 = seed + 0x27D4EB2F165667C5UL; + } + + h64 += len; + return XXH64_finalize(h64, input, len, align); + } + + /*! @ingroup XXH64_family */ + private static ulong ZSTD_XXH64(void* input, nuint len, ulong seed) + { + return XXH64_endian_align((byte*)input, len, seed, XXH_alignment.XXH_unaligned); + } + + /*! @ingroup XXH64_family*/ + private static XXH64_state_s* ZSTD_XXH64_createState() + { + return (XXH64_state_s*)XXH_malloc((nuint)sizeof(XXH64_state_s)); + } + + /*! @ingroup XXH64_family */ + private static XXH_errorcode ZSTD_XXH64_freeState(XXH64_state_s* statePtr) + { + XXH_free(statePtr); + return XXH_errorcode.XXH_OK; + } + + /*! @ingroup XXH64_family */ + private static void ZSTD_XXH64_copyState(XXH64_state_s* dstState, XXH64_state_s* srcState) + { + XXH_memcpy(dstState, srcState, (nuint)sizeof(XXH64_state_s)); + } + + /*! @ingroup XXH64_family */ + private static XXH_errorcode ZSTD_XXH64_reset(XXH64_state_s* statePtr, ulong seed) + { + *statePtr = new XXH64_state_s(); + statePtr->v[0] = seed + 0x9E3779B185EBCA87UL + 0xC2B2AE3D27D4EB4FUL; + statePtr->v[1] = seed + 0xC2B2AE3D27D4EB4FUL; + statePtr->v[2] = seed + 0; + statePtr->v[3] = seed - 0x9E3779B185EBCA87UL; + return XXH_errorcode.XXH_OK; + } + + /*! @ingroup XXH64_family */ + private static XXH_errorcode ZSTD_XXH64_update(XXH64_state_s* state, void* input, nuint len) + { + if (input == null) + { + return XXH_errorcode.XXH_OK; + } + + { + byte* p = (byte*)input; + byte* bEnd = p + len; + state->total_len += len; + if (state->memsize + len < 32) + { + XXH_memcpy((byte*)state->mem64 + state->memsize, input, len); + state->memsize += (uint)len; + return XXH_errorcode.XXH_OK; + } + + if (state->memsize != 0) + { + XXH_memcpy((byte*)state->mem64 + state->memsize, input, 32 - state->memsize); + state->v[0] = XXH64_round(state->v[0], XXH_readLE64(state->mem64 + 0)); + state->v[1] = XXH64_round(state->v[1], XXH_readLE64(state->mem64 + 1)); + state->v[2] = XXH64_round(state->v[2], XXH_readLE64(state->mem64 + 2)); + state->v[3] = XXH64_round(state->v[3], XXH_readLE64(state->mem64 + 3)); + p += 32 - state->memsize; + state->memsize = 0; + } + + if (p + 32 <= bEnd) + { + byte* limit = bEnd - 32; + do + { + state->v[0] = XXH64_round(state->v[0], XXH_readLE64(p)); + p += 8; + state->v[1] = XXH64_round(state->v[1], XXH_readLE64(p)); + p += 8; + state->v[2] = XXH64_round(state->v[2], XXH_readLE64(p)); + p += 8; + state->v[3] = XXH64_round(state->v[3], XXH_readLE64(p)); + p += 8; + } while (p <= limit); + } + + if (p < bEnd) + { + XXH_memcpy(state->mem64, p, (nuint)(bEnd - p)); + state->memsize = (uint)(bEnd - p); + } + } + + return XXH_errorcode.XXH_OK; + } + + /*! @ingroup XXH64_family */ + private static ulong ZSTD_XXH64_digest(XXH64_state_s* state) + { + ulong h64; + if (state->total_len >= 32) + { + h64 = + BitOperations.RotateLeft(state->v[0], 1) + + BitOperations.RotateLeft(state->v[1], 7) + + BitOperations.RotateLeft(state->v[2], 12) + + BitOperations.RotateLeft(state->v[3], 18); + h64 = XXH64_mergeRound(h64, state->v[0]); + h64 = XXH64_mergeRound(h64, state->v[1]); + h64 = XXH64_mergeRound(h64, state->v[2]); + h64 = XXH64_mergeRound(h64, state->v[3]); + } + else + { + h64 = state->v[2] + 0x27D4EB2F165667C5UL; + } + + h64 += state->total_len; + return XXH64_finalize( + h64, + (byte*)state->mem64, + (nuint)state->total_len, + XXH_alignment.XXH_aligned + ); + } + + /*! @ingroup XXH64_family */ + private static void ZSTD_XXH64_canonicalFromHash(XXH64_canonical_t* dst, ulong hash) + { + assert(sizeof(XXH64_canonical_t) == sizeof(ulong)); + if (BitConverter.IsLittleEndian) + hash = BinaryPrimitives.ReverseEndianness(hash); + XXH_memcpy(dst, &hash, (nuint)sizeof(XXH64_canonical_t)); + } + + /*! @ingroup XXH64_family */ + private static ulong ZSTD_XXH64_hashFromCanonical(XXH64_canonical_t* src) + { + return XXH_readBE64(src); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_cover_params_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_cover_params_t.cs new file mode 100644 index 000000000..dfc4fecf2 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_cover_params_t.cs @@ -0,0 +1,30 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*! ZDICT_cover_params_t: + * k and d are the only required parameters. + * For others, value 0 means default. + */ +public struct ZDICT_cover_params_t +{ + /* Segment size : constraint: 0 < k : Reasonable range [16, 2048+] */ + public uint k; + + /* dmer size : constraint: 0 < d <= k : Reasonable range [6, 16] */ + public uint d; + + /* Number of steps : Only used for optimization : 0 means default (40) : Higher means more parameters checked */ + public uint steps; + + /* Number of threads : constraint: 0 < nbThreads : 1 means single-threaded : Only used for optimization : Ignored if ZSTD_MULTITHREAD is not defined */ + public uint nbThreads; + + /* Percentage of samples used for training: Only used for optimization : the first nbSamples * splitPoint samples will be used to training, the last nbSamples * (1 - splitPoint) samples will be used for testing, 0 means default (1.0), 1.0 when all samples are used for both training and testing */ + public double splitPoint; + + /* Train dictionaries to shrink in size starting from the minimum size and selects the smallest dictionary that is shrinkDictMaxRegression% worse than the largest dictionary. 0 means no shrinking and 1 means shrinking */ + public uint shrinkDict; + + /* Sets shrinkDictMaxRegression so that a smaller dictionary can be at worse shrinkDictMaxRegression% worse than the max dict size dictionary. */ + public uint shrinkDictMaxRegression; + public ZDICT_params_t zParams; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_fastCover_params_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_fastCover_params_t.cs new file mode 100644 index 000000000..a5af135db --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_fastCover_params_t.cs @@ -0,0 +1,32 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZDICT_fastCover_params_t +{ + /* Segment size : constraint: 0 < k : Reasonable range [16, 2048+] */ + public uint k; + + /* dmer size : constraint: 0 < d <= k : Reasonable range [6, 16] */ + public uint d; + + /* log of size of frequency array : constraint: 0 < f <= 31 : 1 means default(20)*/ + public uint f; + + /* Number of steps : Only used for optimization : 0 means default (40) : Higher means more parameters checked */ + public uint steps; + + /* Number of threads : constraint: 0 < nbThreads : 1 means single-threaded : Only used for optimization : Ignored if ZSTD_MULTITHREAD is not defined */ + public uint nbThreads; + + /* Percentage of samples used for training: Only used for optimization : the first nbSamples * splitPoint samples will be used to training, the last nbSamples * (1 - splitPoint) samples will be used for testing, 0 means default (0.75), 1.0 when all samples are used for both training and testing */ + public double splitPoint; + + /* Acceleration level: constraint: 0 < accel <= 10, higher means faster and less accurate, 0 means default(1) */ + public uint accel; + + /* Train dictionaries to shrink in size starting from the minimum size and selects the smallest dictionary that is shrinkDictMaxRegression% worse than the largest dictionary. 0 means no shrinking and 1 means shrinking */ + public uint shrinkDict; + + /* Sets shrinkDictMaxRegression so that a smaller dictionary can be at worse shrinkDictMaxRegression% worse than the max dict size dictionary. */ + public uint shrinkDictMaxRegression; + public ZDICT_params_t zParams; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_legacy_params_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_legacy_params_t.cs new file mode 100644 index 000000000..fd061e592 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_legacy_params_t.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZDICT_legacy_params_t +{ + /* 0 means default; larger => select more => larger dictionary */ + public uint selectivityLevel; + public ZDICT_params_t zParams; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_params_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_params_t.cs new file mode 100644 index 000000000..6c3fe7588 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZDICT_params_t.cs @@ -0,0 +1,20 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZDICT_params_t +{ + /**< optimize for a specific zstd compression level; 0 means default */ + public int compressionLevel; + + /**< Write log to stderr; 0 = none (default); 1 = errors; 2 = progression; 3 = details; 4 = debug; */ + public uint notificationLevel; + + /**< force dictID value; 0 means auto mode (32-bits random value) + * NOTE: The zstd format reserves some dictionary IDs for future use. + * You may use them in private settings, but be warned that they + * may be used by zstd in a public dictionary registry in the future. + * These dictionary IDs are: + * - low range : <= 32767 + * - high range : >= (2^31) + */ + public uint dictID; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_CCtxPool.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_CCtxPool.cs new file mode 100644 index 000000000..a9c7fccc4 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_CCtxPool.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* ===== CCtx Pool ===== */ +/* a single CCtx Pool can be invoked from multiple threads in parallel */ +public unsafe struct ZSTDMT_CCtxPool +{ + public void* poolMutex; + public int totalCCtx; + public int availCCtx; + public ZSTD_customMem cMem; + public ZSTD_CCtx_s** cctxs; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_CCtx_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_CCtx_s.cs new file mode 100644 index 000000000..3e4e2cfe7 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_CCtx_s.cs @@ -0,0 +1,32 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTDMT_CCtx_s +{ + public void* factory; + public ZSTDMT_jobDescription* jobs; + public ZSTDMT_bufferPool_s* bufPool; + public ZSTDMT_CCtxPool* cctxPool; + public ZSTDMT_bufferPool_s* seqPool; + public ZSTD_CCtx_params_s @params; + public nuint targetSectionSize; + public nuint targetPrefixSize; + + /* 1 => one job is already prepared, but pool has shortage of workers. Don't create a new job. */ + public int jobReady; + public InBuff_t inBuff; + public RoundBuff_t roundBuff; + public SerialState serial; + public RSyncState_t rsync; + public uint jobIDMask; + public uint doneJobID; + public uint nextJobID; + public uint frameEnded; + public uint allJobsCompleted; + public ulong frameContentSize; + public ulong consumed; + public ulong produced; + public ZSTD_customMem cMem; + public ZSTD_CDict_s* cdictLocal; + public ZSTD_CDict_s* cdict; + public uint providedFactory; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_bufferPool_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_bufferPool_s.cs new file mode 100644 index 000000000..0c64573a3 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_bufferPool_s.cs @@ -0,0 +1,11 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTDMT_bufferPool_s +{ + public void* poolMutex; + public nuint bufferSize; + public uint totalBuffers; + public uint nbBuffers; + public ZSTD_customMem cMem; + public buffer_s* buffers; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_jobDescription.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_jobDescription.cs new file mode 100644 index 000000000..cb2c18f63 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTDMT_jobDescription.cs @@ -0,0 +1,61 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTDMT_jobDescription +{ + /* SHARED - set0 by mtctx, then modified by worker AND read by mtctx */ + public nuint consumed; + + /* SHARED - set0 by mtctx, then modified by worker AND read by mtctx, then set0 by mtctx */ + public nuint cSize; + + /* Thread-safe - used by mtctx and worker */ + public void* job_mutex; + + /* Thread-safe - used by mtctx and worker */ + public void* job_cond; + + /* Thread-safe - used by mtctx and (all) workers */ + public ZSTDMT_CCtxPool* cctxPool; + + /* Thread-safe - used by mtctx and (all) workers */ + public ZSTDMT_bufferPool_s* bufPool; + + /* Thread-safe - used by mtctx and (all) workers */ + public ZSTDMT_bufferPool_s* seqPool; + + /* Thread-safe - used by mtctx and (all) workers */ + public SerialState* serial; + + /* set by worker (or mtctx), then read by worker & mtctx, then modified by mtctx => no barrier */ + public buffer_s dstBuff; + + /* set by mtctx, then read by worker & mtctx => no barrier */ + public Range prefix; + + /* set by mtctx, then read by worker & mtctx => no barrier */ + public Range src; + + /* set by mtctx, then read by worker => no barrier */ + public uint jobID; + + /* set by mtctx, then read by worker => no barrier */ + public uint firstJob; + + /* set by mtctx, then read by worker => no barrier */ + public uint lastJob; + + /* set by mtctx, then read by worker => no barrier */ + public ZSTD_CCtx_params_s @params; + + /* set by mtctx, then read by worker => no barrier */ + public ZSTD_CDict_s* cdict; + + /* set by mtctx, then read by worker => no barrier */ + public ulong fullFrameSize; + + /* used only by mtctx */ + public nuint dstFlushed; + + /* used only by mtctx */ + public uint frameChecksumNeeded; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_BlockCompressor_f.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_BlockCompressor_f.cs new file mode 100644 index 000000000..08a44808a --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_BlockCompressor_f.cs @@ -0,0 +1,12 @@ +using System.Runtime.InteropServices; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +[UnmanagedFunctionPointer(CallingConvention.Cdecl)] +public unsafe delegate nuint ZSTD_BlockCompressor_f( + ZSTD_MatchState_t* bs, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize +); diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_BuildCTableWksp.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_BuildCTableWksp.cs new file mode 100644 index 000000000..afdeff1d8 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_BuildCTableWksp.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_BuildCTableWksp +{ + public fixed short norm[53]; + public fixed uint wksp[285]; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_BuildSeqStore_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_BuildSeqStore_e.cs new file mode 100644 index 000000000..5378fc7e4 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_BuildSeqStore_e.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_BuildSeqStore_e +{ + ZSTDbss_compress, + ZSTDbss_noCompress, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_CCtx_params_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_CCtx_params_s.cs new file mode 100644 index 000000000..e7a45dbe0 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_CCtx_params_s.cs @@ -0,0 +1,86 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_CCtx_params_s +{ + public ZSTD_format_e format; + public ZSTD_compressionParameters cParams; + public ZSTD_frameParameters fParams; + public int compressionLevel; + + /* force back-references to respect limit of + * 1< 0: + * If litLength != 0: + * rep == 1 --> offset == repeat_offset_1 + * rep == 2 --> offset == repeat_offset_2 + * rep == 3 --> offset == repeat_offset_3 + * If litLength == 0: + * rep == 1 --> offset == repeat_offset_2 + * rep == 2 --> offset == repeat_offset_3 + * rep == 3 --> offset == repeat_offset_1 - 1 + * + * Note: This field is optional. ZSTD_generateSequences() will calculate the value of + * 'rep', but repeat offsets do not necessarily need to be calculated from an external + * sequence provider perspective. For example, ZSTD_compressSequences() does not + * use this 'rep' field at all (as of now). + */ + public uint rep; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_SequenceLength.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_SequenceLength.cs new file mode 100644 index 000000000..80e67fc9b --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_SequenceLength.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZSTD_SequenceLength +{ + public uint litLength; + public uint matchLength; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_SequencePosition.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_SequencePosition.cs new file mode 100644 index 000000000..db0ec511e --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_SequencePosition.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZSTD_SequencePosition +{ + /* Index in array of ZSTD_Sequence */ + public uint idx; + + /* Position within sequence at idx */ + public uint posInSequence; + + /* Number of bytes given by sequences provided so far */ + public nuint posInSrc; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_blockSplitCtx.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_blockSplitCtx.cs new file mode 100644 index 000000000..b83e4e1f0 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_blockSplitCtx.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_blockSplitCtx +{ + public SeqStore_t fullSeqStoreChunk; + public SeqStore_t firstHalfSeqStore; + public SeqStore_t secondHalfSeqStore; + public SeqStore_t currSeqStore; + public SeqStore_t nextSeqStore; + public fixed uint partitions[196]; + public ZSTD_entropyCTablesMetadata_t entropyMetadata; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_blockState_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_blockState_t.cs new file mode 100644 index 000000000..5dd067a1f --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_blockState_t.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_blockState_t +{ + public ZSTD_compressedBlockState_t* prevCBlock; + public ZSTD_compressedBlockState_t* nextCBlock; + public ZSTD_MatchState_t matchState; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_bounds.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_bounds.cs new file mode 100644 index 000000000..d82a2932f --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_bounds.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZSTD_bounds +{ + public nuint error; + public int lowerBound; + public int upperBound; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_bufferMode_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_bufferMode_e.cs new file mode 100644 index 000000000..6ae23f314 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_bufferMode_e.cs @@ -0,0 +1,11 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* Controls whether the input/output buffer is buffered or stable. */ +public enum ZSTD_bufferMode_e +{ + /* Buffer the input/output */ + ZSTD_bm_buffered = 0, + + /* ZSTD_inBuffer/ZSTD_outBuffer is stable */ + ZSTD_bm_stable = 1, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_buffered_policy_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_buffered_policy_e.cs new file mode 100644 index 000000000..8d5a1a917 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_buffered_policy_e.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + * Indicates whether this compression proceeds directly from user-provided + * source buffer to user-provided destination buffer (ZSTDb_not_buffered), or + * whether the context needs to buffer the input/output (ZSTDb_buffered). + */ +public enum ZSTD_buffered_policy_e +{ + ZSTDb_not_buffered, + ZSTDb_buffered, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cParameter.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cParameter.cs new file mode 100644 index 000000000..cfe1f38a9 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cParameter.cs @@ -0,0 +1,218 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_cParameter +{ + /* Set compression parameters according to pre-defined cLevel table. + * Note that exact compression parameters are dynamically determined, + * depending on both compression level and srcSize (when known). + * Default level is ZSTD_CLEVEL_DEFAULT==3. + * Special: value 0 means default, which is controlled by ZSTD_CLEVEL_DEFAULT. + * Note 1 : it's possible to pass a negative compression level. + * Note 2 : setting a level does not automatically set all other compression parameters + * to default. Setting this will however eventually dynamically impact the compression + * parameters which have not been manually set. The manually set + * ones will 'stick'. */ + ZSTD_c_compressionLevel = 100, + + /* Maximum allowed back-reference distance, expressed as power of 2. + * This will set a memory budget for streaming decompression, + * with larger values requiring more memory + * and typically compressing more. + * Must be clamped between ZSTD_WINDOWLOG_MIN and ZSTD_WINDOWLOG_MAX. + * Special: value 0 means "use default windowLog". + * Note: Using a windowLog greater than ZSTD_WINDOWLOG_LIMIT_DEFAULT + * requires explicitly allowing such size at streaming decompression stage. */ + ZSTD_c_windowLog = 101, + + /* Size of the initial probe table, as a power of 2. + * Resulting memory usage is (1 << (hashLog+2)). + * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX. + * Larger tables improve compression ratio of strategies <= dFast, + * and improve speed of strategies > dFast. + * Special: value 0 means "use default hashLog". */ + ZSTD_c_hashLog = 102, + + /* Size of the multi-probe search table, as a power of 2. + * Resulting memory usage is (1 << (chainLog+2)). + * Must be clamped between ZSTD_CHAINLOG_MIN and ZSTD_CHAINLOG_MAX. + * Larger tables result in better and slower compression. + * This parameter is useless for "fast" strategy. + * It's still useful when using "dfast" strategy, + * in which case it defines a secondary probe table. + * Special: value 0 means "use default chainLog". */ + ZSTD_c_chainLog = 103, + + /* Number of search attempts, as a power of 2. + * More attempts result in better and slower compression. + * This parameter is useless for "fast" and "dFast" strategies. + * Special: value 0 means "use default searchLog". */ + ZSTD_c_searchLog = 104, + + /* Minimum size of searched matches. + * Note that Zstandard can still find matches of smaller size, + * it just tweaks its search algorithm to look for this size and larger. + * Larger values increase compression and decompression speed, but decrease ratio. + * Must be clamped between ZSTD_MINMATCH_MIN and ZSTD_MINMATCH_MAX. + * Note that currently, for all strategies < btopt, effective minimum is 4. + * , for all strategies > fast, effective maximum is 6. + * Special: value 0 means "use default minMatchLength". */ + ZSTD_c_minMatch = 105, + + /* Impact of this field depends on strategy. + * For strategies btopt, btultra & btultra2: + * Length of Match considered "good enough" to stop search. + * Larger values make compression stronger, and slower. + * For strategy fast: + * Distance between match sampling. + * Larger values make compression faster, and weaker. + * Special: value 0 means "use default targetLength". */ + ZSTD_c_targetLength = 106, + + /* See ZSTD_strategy enum definition. + * The higher the value of selected strategy, the more complex it is, + * resulting in stronger and slower compression. + * Special: value 0 means "use default strategy". */ + ZSTD_c_strategy = 107, + + /* v1.5.6+ + * Attempts to fit compressed block size into approximately targetCBlockSize. + * Bound by ZSTD_TARGETCBLOCKSIZE_MIN and ZSTD_TARGETCBLOCKSIZE_MAX. + * Note that it's not a guarantee, just a convergence target (default:0). + * No target when targetCBlockSize == 0. + * This is helpful in low bandwidth streaming environments to improve end-to-end latency, + * when a client can make use of partial documents (a prominent example being Chrome). + * Note: this parameter is stable since v1.5.6. + * It was present as an experimental parameter in earlier versions, + * but it's not recommended using it with earlier library versions + * due to massive performance regressions. + */ + ZSTD_c_targetCBlockSize = 130, + + /* Enable long distance matching. + * This parameter is designed to improve compression ratio + * for large inputs, by finding large matches at long distance. + * It increases memory usage and window size. + * Note: enabling this parameter increases default ZSTD_c_windowLog to 128 MB + * except when expressly set to a different value. + * Note: will be enabled by default if ZSTD_c_windowLog >= 128 MB and + * compression strategy >= ZSTD_btopt (== compression level 16+) */ + ZSTD_c_enableLongDistanceMatching = 160, + + /* Size of the table for long distance matching, as a power of 2. + * Larger values increase memory usage and compression ratio, + * but decrease compression speed. + * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX + * default: windowlog - 7. + * Special: value 0 means "automatically determine hashlog". */ + ZSTD_c_ldmHashLog = 161, + + /* Minimum match size for long distance matcher. + * Larger/too small values usually decrease compression ratio. + * Must be clamped between ZSTD_LDM_MINMATCH_MIN and ZSTD_LDM_MINMATCH_MAX. + * Special: value 0 means "use default value" (default: 64). */ + ZSTD_c_ldmMinMatch = 162, + + /* Log size of each bucket in the LDM hash table for collision resolution. + * Larger values improve collision resolution but decrease compression speed. + * The maximum value is ZSTD_LDM_BUCKETSIZELOG_MAX. + * Special: value 0 means "use default value" (default: 3). */ + ZSTD_c_ldmBucketSizeLog = 163, + + /* Frequency of inserting/looking up entries into the LDM hash table. + * Must be clamped between 0 and (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN). + * Default is MAX(0, (windowLog - ldmHashLog)), optimizing hash table usage. + * Larger values improve compression speed. + * Deviating far from default value will likely result in a compression ratio decrease. + * Special: value 0 means "automatically determine hashRateLog". */ + ZSTD_c_ldmHashRateLog = 164, + + /* Content size will be written into frame header _whenever known_ (default:1) + * Content size must be known at the beginning of compression. + * This is automatically the case when using ZSTD_compress2(), + * For streaming scenarios, content size must be provided with ZSTD_CCtx_setPledgedSrcSize() */ + ZSTD_c_contentSizeFlag = 200, + + /* A 32-bits checksum of content is written at end of frame (default:0) */ + ZSTD_c_checksumFlag = 201, + + /* When applicable, dictionary's ID is written into frame header (default:1) */ + ZSTD_c_dictIDFlag = 202, + + /* Select how many threads will be spawned to compress in parallel. + * When nbWorkers >= 1, triggers asynchronous mode when invoking ZSTD_compressStream*() : + * ZSTD_compressStream*() consumes input and flush output if possible, but immediately gives back control to caller, + * while compression is performed in parallel, within worker thread(s). + * (note : a strong exception to this rule is when first invocation of ZSTD_compressStream2() sets ZSTD_e_end : + * in which case, ZSTD_compressStream2() delegates to ZSTD_compress2(), which is always a blocking call). + * More workers improve speed, but also increase memory usage. + * Default value is `0`, aka "single-threaded mode" : no worker is spawned, + * compression is performed inside Caller's thread, and all invocations are blocking */ + ZSTD_c_nbWorkers = 400, + + /* Size of a compression job. This value is enforced only when nbWorkers >= 1. + * Each compression job is completed in parallel, so this value can indirectly impact the nb of active threads. + * 0 means default, which is dynamically determined based on compression parameters. + * Job size must be a minimum of overlap size, or ZSTDMT_JOBSIZE_MIN (= 512 KB), whichever is largest. + * The minimum size is automatically and transparently enforced. */ + ZSTD_c_jobSize = 401, + + /* Control the overlap size, as a fraction of window size. + * The overlap size is an amount of data reloaded from previous job at the beginning of a new job. + * It helps preserve compression ratio, while each job is compressed in parallel. + * This value is enforced only when nbWorkers >= 1. + * Larger values increase compression ratio, but decrease speed. + * Possible values range from 0 to 9 : + * - 0 means "default" : value will be determined by the library, depending on strategy + * - 1 means "no overlap" + * - 9 means "full overlap", using a full window size. + * Each intermediate rank increases/decreases load size by a factor 2 : + * 9: full window; 8: w/2; 7: w/4; 6: w/8; 5:w/16; 4: w/32; 3:w/64; 2:w/128; 1:no overlap; 0:default + * default value varies between 6 and 9, depending on strategy */ + ZSTD_c_overlapLog = 402, + + /* note : additional experimental parameters are also available + * within the experimental section of the API. + * At the time of this writing, they include : + * ZSTD_c_rsyncable + * ZSTD_c_format + * ZSTD_c_forceMaxWindow + * ZSTD_c_forceAttachDict + * ZSTD_c_literalCompressionMode + * ZSTD_c_srcSizeHint + * ZSTD_c_enableDedicatedDictSearch + * ZSTD_c_stableInBuffer + * ZSTD_c_stableOutBuffer + * ZSTD_c_blockDelimiters + * ZSTD_c_validateSequences + * ZSTD_c_blockSplitterLevel + * ZSTD_c_splitAfterSequences + * ZSTD_c_useRowMatchFinder + * ZSTD_c_prefetchCDictTables + * ZSTD_c_enableSeqProducerFallback + * ZSTD_c_maxBlockSize + * Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them. + * note : never ever use experimentalParam? names directly; + * also, the enums values themselves are unstable and can still change. + */ + ZSTD_c_experimentalParam1 = 500, + ZSTD_c_experimentalParam2 = 10, + ZSTD_c_experimentalParam3 = 1000, + ZSTD_c_experimentalParam4 = 1001, + ZSTD_c_experimentalParam5 = 1002, + + /* was ZSTD_c_experimentalParam6=1003; is now ZSTD_c_targetCBlockSize */ + ZSTD_c_experimentalParam7 = 1004, + ZSTD_c_experimentalParam8 = 1005, + ZSTD_c_experimentalParam9 = 1006, + ZSTD_c_experimentalParam10 = 1007, + ZSTD_c_experimentalParam11 = 1008, + ZSTD_c_experimentalParam12 = 1009, + ZSTD_c_experimentalParam13 = 1010, + ZSTD_c_experimentalParam14 = 1011, + ZSTD_c_experimentalParam15 = 1012, + ZSTD_c_experimentalParam16 = 1013, + ZSTD_c_experimentalParam17 = 1014, + ZSTD_c_experimentalParam18 = 1015, + ZSTD_c_experimentalParam19 = 1016, + ZSTD_c_experimentalParam20 = 1017, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cStreamStage.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cStreamStage.cs new file mode 100644 index 000000000..c929b7fac --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cStreamStage.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_cStreamStage +{ + zcss_init = 0, + zcss_load, + zcss_flush, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compResetPolicy_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compResetPolicy_e.cs new file mode 100644 index 000000000..d943004d0 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compResetPolicy_e.cs @@ -0,0 +1,14 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + * Controls, for this matchState reset, whether the tables need to be cleared / + * prepared for the coming compression (ZSTDcrp_makeClean), or whether the + * tables can be left unclean (ZSTDcrp_leaveDirty), because we know that a + * subsequent operation will overwrite the table space anyways (e.g., copying + * the matchState contents in from a CDict). + */ +public enum ZSTD_compResetPolicy_e +{ + ZSTDcrp_makeClean, + ZSTDcrp_leaveDirty, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compressedBlockState_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compressedBlockState_t.cs new file mode 100644 index 000000000..af281c96c --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compressedBlockState_t.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_compressedBlockState_t +{ + public ZSTD_entropyCTables_t entropy; + public fixed uint rep[3]; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compressionParameters.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compressionParameters.cs new file mode 100644 index 000000000..bacbdea52 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compressionParameters.cs @@ -0,0 +1,44 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZSTD_compressionParameters +{ + /**< largest match distance : larger == more compression, more memory needed during decompression */ + public uint windowLog; + + /**< fully searched segment : larger == more compression, slower, more memory (useless for fast) */ + public uint chainLog; + + /**< dispatch table : larger == faster, more memory */ + public uint hashLog; + + /**< nb of searches : larger == more compression, slower */ + public uint searchLog; + + /**< match length searched : larger == faster decompression, sometimes less compression */ + public uint minMatch; + + /**< acceptable match size for optimal parser (only) : larger == more compression, slower */ + public uint targetLength; + + /**< see ZSTD_strategy definition above */ + public ZSTD_strategy strategy; + + public ZSTD_compressionParameters( + uint windowLog, + uint chainLog, + uint hashLog, + uint searchLog, + uint minMatch, + uint targetLength, + ZSTD_strategy strategy + ) + { + this.windowLog = windowLog; + this.chainLog = chainLog; + this.hashLog = hashLog; + this.searchLog = searchLog; + this.minMatch = minMatch; + this.targetLength = targetLength; + this.strategy = strategy; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compressionStage_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compressionStage_e.cs new file mode 100644 index 000000000..9ffa4833c --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_compressionStage_e.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*-************************************* + * Context memory management + ***************************************/ +public enum ZSTD_compressionStage_e +{ + ZSTDcs_created = 0, + ZSTDcs_init, + ZSTDcs_ongoing, + ZSTDcs_ending, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_customMem.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_customMem.cs new file mode 100644 index 000000000..16776a740 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_customMem.cs @@ -0,0 +1,15 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_customMem +{ + public void* customAlloc; + public void* customFree; + public void* opaque; + + public ZSTD_customMem(void* customAlloc, void* customFree, void* opaque) + { + this.customAlloc = customAlloc; + this.customFree = customFree; + this.opaque = opaque; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cwksp.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cwksp.cs new file mode 100644 index 000000000..847b08666 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cwksp.cs @@ -0,0 +1,110 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + * Zstd fits all its internal datastructures into a single continuous buffer, + * so that it only needs to perform a single OS allocation (or so that a buffer + * can be provided to it and it can perform no allocations at all). This buffer + * is called the workspace. + * + * Several optimizations complicate that process of allocating memory ranges + * from this workspace for each internal datastructure: + * + * - These different internal datastructures have different setup requirements: + * + * - The static objects need to be cleared once and can then be trivially + * reused for each compression. + * + * - Various buffers don't need to be initialized at all--they are always + * written into before they're read. + * + * - The matchstate tables have a unique requirement that they don't need + * their memory to be totally cleared, but they do need the memory to have + * some bound, i.e., a guarantee that all values in the memory they've been + * allocated is less than some maximum value (which is the starting value + * for the indices that they will then use for compression). When this + * guarantee is provided to them, they can use the memory without any setup + * work. When it can't, they have to clear the area. + * + * - These buffers also have different alignment requirements. + * + * - We would like to reuse the objects in the workspace for multiple + * compressions without having to perform any expensive reallocation or + * reinitialization work. + * + * - We would like to be able to efficiently reuse the workspace across + * multiple compressions **even when the compression parameters change** and + * we need to resize some of the objects (where possible). + * + * To attempt to manage this buffer, given these constraints, the ZSTD_cwksp + * abstraction was created. It works as follows: + * + * Workspace Layout: + * + * [ ... workspace ... ] + * [objects][tables ->] free space [<- buffers][<- aligned][<- init once] + * + * The various objects that live in the workspace are divided into the + * following categories, and are allocated separately: + * + * - Static objects: this is optionally the enclosing ZSTD_CCtx or ZSTD_CDict, + * so that literally everything fits in a single buffer. Note: if present, + * this must be the first object in the workspace, since ZSTD_customFree{CCtx, + * CDict}() rely on a pointer comparison to see whether one or two frees are + * required. + * + * - Fixed size objects: these are fixed-size, fixed-count objects that are + * nonetheless "dynamically" allocated in the workspace so that we can + * control how they're initialized separately from the broader ZSTD_CCtx. + * Examples: + * - Entropy Workspace + * - 2 x ZSTD_compressedBlockState_t + * - CDict dictionary contents + * + * - Tables: these are any of several different datastructures (hash tables, + * chain tables, binary trees) that all respect a common format: they are + * uint32_t arrays, all of whose values are between 0 and (nextSrc - base). + * Their sizes depend on the cparams. These tables are 64-byte aligned. + * + * - Init once: these buffers require to be initialized at least once before + * use. They should be used when we want to skip memory initialization + * while not triggering memory checkers (like Valgrind) when reading from + * from this memory without writing to it first. + * These buffers should be used carefully as they might contain data + * from previous compressions. + * Buffers are aligned to 64 bytes. + * + * - Aligned: these buffers don't require any initialization before they're + * used. The user of the buffer should make sure they write into a buffer + * location before reading from it. + * Buffers are aligned to 64 bytes. + * + * - Buffers: these buffers are used for various purposes that don't require + * any alignment or initialization before they're used. This means they can + * be moved around at no cost for a new compression. + * + * Allocating Memory: + * + * The various types of objects must be allocated in order, so they can be + * correctly packed into the workspace buffer. That order is: + * + * 1. Objects + * 2. Init once / Tables + * 3. Aligned / Tables + * 4. Buffers / Tables + * + * Attempts to reserve objects of different types out of order will fail. + */ +public unsafe struct ZSTD_cwksp +{ + public void* workspace; + public void* workspaceEnd; + public void* objectEnd; + public void* tableEnd; + public void* tableValidEnd; + public void* allocStart; + public void* initOnceStart; + public byte allocFailed; + public int workspaceOversizedDuration; + public ZSTD_cwksp_alloc_phase_e phase; + public ZSTD_cwksp_static_alloc_e isStatic; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cwksp_alloc_phase_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cwksp_alloc_phase_e.cs new file mode 100644 index 000000000..c9fd5aac0 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cwksp_alloc_phase_e.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*-************************************* + * Structures + ***************************************/ +public enum ZSTD_cwksp_alloc_phase_e +{ + ZSTD_cwksp_alloc_objects, + ZSTD_cwksp_alloc_aligned_init_once, + ZSTD_cwksp_alloc_aligned, + ZSTD_cwksp_alloc_buffers, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cwksp_static_alloc_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cwksp_static_alloc_e.cs new file mode 100644 index 000000000..8f290f3a5 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_cwksp_static_alloc_e.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + * Used to describe whether the workspace is statically allocated (and will not + * necessarily ever be freed), or if it's dynamically allocated and we can + * expect a well-formed caller to free this. + */ +public enum ZSTD_cwksp_static_alloc_e +{ + ZSTD_cwksp_dynamic_alloc, + ZSTD_cwksp_static_alloc, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dParameter.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dParameter.cs new file mode 100644 index 000000000..2dc4ecba3 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dParameter.cs @@ -0,0 +1,38 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* The advanced API pushes parameters one by one into an existing DCtx context. + * Parameters are sticky, and remain valid for all following frames + * using the same DCtx context. + * It's possible to reset parameters to default values using ZSTD_DCtx_reset(). + * Note : This API is compatible with existing ZSTD_decompressDCtx() and ZSTD_decompressStream(). + * Therefore, no new decompression function is necessary. + */ +public enum ZSTD_dParameter +{ + /* Select a size limit (in power of 2) beyond which + * the streaming API will refuse to allocate memory buffer + * in order to protect the host from unreasonable memory requirements. + * This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode. + * By default, a decompression context accepts window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT). + * Special: value 0 means "use default maximum windowLog". */ + ZSTD_d_windowLogMax = 100, + + /* note : additional experimental parameters are also available + * within the experimental section of the API. + * At the time of this writing, they include : + * ZSTD_d_format + * ZSTD_d_stableOutBuffer + * ZSTD_d_forceIgnoreChecksum + * ZSTD_d_refMultipleDDicts + * ZSTD_d_disableHuffmanAssembly + * ZSTD_d_maxBlockSize + * Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them. + * note : never ever use experimentalParam? names directly + */ + ZSTD_d_experimentalParam1 = 1000, + ZSTD_d_experimentalParam2 = 1001, + ZSTD_d_experimentalParam3 = 1002, + ZSTD_d_experimentalParam4 = 1003, + ZSTD_d_experimentalParam5 = 1004, + ZSTD_d_experimentalParam6 = 1005, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dStage.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dStage.cs new file mode 100644 index 000000000..69b992a27 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dStage.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_dStage +{ + ZSTDds_getFrameHeaderSize, + ZSTDds_decodeFrameHeader, + ZSTDds_decodeBlockHeader, + ZSTDds_decompressBlock, + ZSTDds_decompressLastBlock, + ZSTDds_checkChecksum, + ZSTDds_decodeSkippableHeader, + ZSTDds_skipFrame, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dStreamStage.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dStreamStage.cs new file mode 100644 index 000000000..851e06f7b --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dStreamStage.cs @@ -0,0 +1,10 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_dStreamStage +{ + zdss_init = 0, + zdss_loadHeader, + zdss_read, + zdss_load, + zdss_flush, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictAttachPref_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictAttachPref_e.cs new file mode 100644 index 000000000..8f989a423 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictAttachPref_e.cs @@ -0,0 +1,16 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_dictAttachPref_e +{ + /* Use the default heuristic. */ + ZSTD_dictDefaultAttach = 0, + + /* Never copy the dictionary. */ + ZSTD_dictForceAttach = 1, + + /* Always copy the dictionary. */ + ZSTD_dictForceCopy = 2, + + /* Always reload the dictionary */ + ZSTD_dictForceLoad = 3, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictContentType_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictContentType_e.cs new file mode 100644 index 000000000..3b97b12df --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictContentType_e.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_dictContentType_e +{ + /* dictionary is "full" when starting with ZSTD_MAGIC_DICTIONARY, otherwise it is "rawContent" */ + ZSTD_dct_auto = 0, + + /* ensures dictionary is always loaded as rawContent, even if it starts with ZSTD_MAGIC_DICTIONARY */ + ZSTD_dct_rawContent = 1, + + /* refuses to load a dictionary if it does not respect Zstandard's specification, starting with ZSTD_MAGIC_DICTIONARY */ + ZSTD_dct_fullDict = 2, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictLoadMethod_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictLoadMethod_e.cs new file mode 100644 index 000000000..af7ed50b5 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictLoadMethod_e.cs @@ -0,0 +1,10 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_dictLoadMethod_e +{ + /**< Copy dictionary content internally */ + ZSTD_dlm_byCopy = 0, + + /**< Reference dictionary content -- the dictionary buffer must outlive its users. */ + ZSTD_dlm_byRef = 1, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictMode_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictMode_e.cs new file mode 100644 index 000000000..f234551d9 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictMode_e.cs @@ -0,0 +1,9 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_dictMode_e +{ + ZSTD_noDict = 0, + ZSTD_extDict = 1, + ZSTD_dictMatchState = 2, + ZSTD_dedicatedDictSearch = 3, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictTableLoadMethod_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictTableLoadMethod_e.cs new file mode 100644 index 000000000..7cf4f3e5d --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictTableLoadMethod_e.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_dictTableLoadMethod_e +{ + ZSTD_dtlm_fast, + ZSTD_dtlm_full, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictUses_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictUses_e.cs new file mode 100644 index 000000000..314507c50 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_dictUses_e.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_dictUses_e +{ + /* Use the dictionary indefinitely */ + ZSTD_use_indefinitely = -1, + + /* Do not use the dictionary (if one exists free it) */ + ZSTD_dont_use = 0, + + /* Use the dictionary once and set to ZSTD_dont_use */ + ZSTD_use_once = 1, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_entropyCTablesMetadata_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_entropyCTablesMetadata_t.cs new file mode 100644 index 000000000..2455590b9 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_entropyCTablesMetadata_t.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZSTD_entropyCTablesMetadata_t +{ + public ZSTD_hufCTablesMetadata_t hufMetadata; + public ZSTD_fseCTablesMetadata_t fseMetadata; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_entropyCTables_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_entropyCTables_t.cs new file mode 100644 index 000000000..f3d983584 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_entropyCTables_t.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZSTD_entropyCTables_t +{ + public ZSTD_hufCTables_t huf; + public ZSTD_fseCTables_t fse; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_entropyDTables_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_entropyDTables_t.cs new file mode 100644 index 000000000..91dd9d7d3 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_entropyDTables_t.cs @@ -0,0 +1,1342 @@ +using System.Runtime.CompilerServices; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_entropyDTables_t +{ + /* Note : Space reserved for FSE Tables */ + public _LLTable_e__FixedBuffer LLTable; + + /* is also used as temporary workspace while building hufTable during DDict creation */ + public _OFTable_e__FixedBuffer OFTable; + + /* and therefore must be at least HUF_DECOMPRESS_WORKSPACE_SIZE large */ + public _MLTable_e__FixedBuffer MLTable; + + /* can accommodate HUF_decompress4X */ + public fixed uint hufTable[4097]; + public fixed uint rep[3]; + public fixed uint workspace[157]; + +#if NET8_0_OR_GREATER + [InlineArray(513)] + public unsafe struct _LLTable_e__FixedBuffer + { + public ZSTD_seqSymbol e0; + } + +#else + public unsafe struct _LLTable_e__FixedBuffer + { + public ZSTD_seqSymbol e0; + public ZSTD_seqSymbol e1; + public ZSTD_seqSymbol e2; + public ZSTD_seqSymbol e3; + public ZSTD_seqSymbol e4; + public ZSTD_seqSymbol e5; + public ZSTD_seqSymbol e6; + public ZSTD_seqSymbol e7; + public ZSTD_seqSymbol e8; + public ZSTD_seqSymbol e9; + public ZSTD_seqSymbol e10; + public ZSTD_seqSymbol e11; + public ZSTD_seqSymbol e12; + public ZSTD_seqSymbol e13; + public ZSTD_seqSymbol e14; + public ZSTD_seqSymbol e15; + public ZSTD_seqSymbol e16; + public ZSTD_seqSymbol e17; + public ZSTD_seqSymbol e18; + public ZSTD_seqSymbol e19; + public ZSTD_seqSymbol e20; + public ZSTD_seqSymbol e21; + public ZSTD_seqSymbol e22; + public ZSTD_seqSymbol e23; + public ZSTD_seqSymbol e24; + public ZSTD_seqSymbol e25; + public ZSTD_seqSymbol e26; + public ZSTD_seqSymbol e27; + public ZSTD_seqSymbol e28; + public ZSTD_seqSymbol e29; + public ZSTD_seqSymbol e30; + public ZSTD_seqSymbol e31; + public ZSTD_seqSymbol e32; + public ZSTD_seqSymbol e33; + public ZSTD_seqSymbol e34; + public ZSTD_seqSymbol e35; + public ZSTD_seqSymbol e36; + public ZSTD_seqSymbol e37; + public ZSTD_seqSymbol e38; + public ZSTD_seqSymbol e39; + public ZSTD_seqSymbol e40; + public ZSTD_seqSymbol e41; + public ZSTD_seqSymbol e42; + public ZSTD_seqSymbol e43; + public ZSTD_seqSymbol e44; + public ZSTD_seqSymbol e45; + public ZSTD_seqSymbol e46; + public ZSTD_seqSymbol e47; + public ZSTD_seqSymbol e48; + public ZSTD_seqSymbol e49; + public ZSTD_seqSymbol e50; + public ZSTD_seqSymbol e51; + public ZSTD_seqSymbol e52; + public ZSTD_seqSymbol e53; + public ZSTD_seqSymbol e54; + public ZSTD_seqSymbol e55; + public ZSTD_seqSymbol e56; + public ZSTD_seqSymbol e57; + public ZSTD_seqSymbol e58; + public ZSTD_seqSymbol e59; + public ZSTD_seqSymbol e60; + public ZSTD_seqSymbol e61; + public ZSTD_seqSymbol e62; + public ZSTD_seqSymbol e63; + public ZSTD_seqSymbol e64; + public ZSTD_seqSymbol e65; + public ZSTD_seqSymbol e66; + public ZSTD_seqSymbol e67; + public ZSTD_seqSymbol e68; + public ZSTD_seqSymbol e69; + public ZSTD_seqSymbol e70; + public ZSTD_seqSymbol e71; + public ZSTD_seqSymbol e72; + public ZSTD_seqSymbol e73; + public ZSTD_seqSymbol e74; + public ZSTD_seqSymbol e75; + public ZSTD_seqSymbol e76; + public ZSTD_seqSymbol e77; + public ZSTD_seqSymbol e78; + public ZSTD_seqSymbol e79; + public ZSTD_seqSymbol e80; + public ZSTD_seqSymbol e81; + public ZSTD_seqSymbol e82; + public ZSTD_seqSymbol e83; + public ZSTD_seqSymbol e84; + public ZSTD_seqSymbol e85; + public ZSTD_seqSymbol e86; + public ZSTD_seqSymbol e87; + public ZSTD_seqSymbol e88; + public ZSTD_seqSymbol e89; + public ZSTD_seqSymbol e90; + public ZSTD_seqSymbol e91; + public ZSTD_seqSymbol e92; + public ZSTD_seqSymbol e93; + public ZSTD_seqSymbol e94; + public ZSTD_seqSymbol e95; + public ZSTD_seqSymbol e96; + public ZSTD_seqSymbol e97; + public ZSTD_seqSymbol e98; + public ZSTD_seqSymbol e99; + public ZSTD_seqSymbol e100; + public ZSTD_seqSymbol e101; + public ZSTD_seqSymbol e102; + public ZSTD_seqSymbol e103; + public ZSTD_seqSymbol e104; + public ZSTD_seqSymbol e105; + public ZSTD_seqSymbol e106; + public ZSTD_seqSymbol e107; + public ZSTD_seqSymbol e108; + public ZSTD_seqSymbol e109; + public ZSTD_seqSymbol e110; + public ZSTD_seqSymbol e111; + public ZSTD_seqSymbol e112; + public ZSTD_seqSymbol e113; + public ZSTD_seqSymbol e114; + public ZSTD_seqSymbol e115; + public ZSTD_seqSymbol e116; + public ZSTD_seqSymbol e117; + public ZSTD_seqSymbol e118; + public ZSTD_seqSymbol e119; + public ZSTD_seqSymbol e120; + public ZSTD_seqSymbol e121; + public ZSTD_seqSymbol e122; + public ZSTD_seqSymbol e123; + public ZSTD_seqSymbol e124; + public ZSTD_seqSymbol e125; + public ZSTD_seqSymbol e126; + public ZSTD_seqSymbol e127; + public ZSTD_seqSymbol e128; + public ZSTD_seqSymbol e129; + public ZSTD_seqSymbol e130; + public ZSTD_seqSymbol e131; + public ZSTD_seqSymbol e132; + public ZSTD_seqSymbol e133; + public ZSTD_seqSymbol e134; + public ZSTD_seqSymbol e135; + public ZSTD_seqSymbol e136; + public ZSTD_seqSymbol e137; + public ZSTD_seqSymbol e138; + public ZSTD_seqSymbol e139; + public ZSTD_seqSymbol e140; + public ZSTD_seqSymbol e141; + public ZSTD_seqSymbol e142; + public ZSTD_seqSymbol e143; + public ZSTD_seqSymbol e144; + public ZSTD_seqSymbol e145; + public ZSTD_seqSymbol e146; + public ZSTD_seqSymbol e147; + public ZSTD_seqSymbol e148; + public ZSTD_seqSymbol e149; + public ZSTD_seqSymbol e150; + public ZSTD_seqSymbol e151; + public ZSTD_seqSymbol e152; + public ZSTD_seqSymbol e153; + public ZSTD_seqSymbol e154; + public ZSTD_seqSymbol e155; + public ZSTD_seqSymbol e156; + public ZSTD_seqSymbol e157; + public ZSTD_seqSymbol e158; + public ZSTD_seqSymbol e159; + public ZSTD_seqSymbol e160; + public ZSTD_seqSymbol e161; + public ZSTD_seqSymbol e162; + public ZSTD_seqSymbol e163; + public ZSTD_seqSymbol e164; + public ZSTD_seqSymbol e165; + public ZSTD_seqSymbol e166; + public ZSTD_seqSymbol e167; + public ZSTD_seqSymbol e168; + public ZSTD_seqSymbol e169; + public ZSTD_seqSymbol e170; + public ZSTD_seqSymbol e171; + public ZSTD_seqSymbol e172; + public ZSTD_seqSymbol e173; + public ZSTD_seqSymbol e174; + public ZSTD_seqSymbol e175; + public ZSTD_seqSymbol e176; + public ZSTD_seqSymbol e177; + public ZSTD_seqSymbol e178; + public ZSTD_seqSymbol e179; + public ZSTD_seqSymbol e180; + public ZSTD_seqSymbol e181; + public ZSTD_seqSymbol e182; + public ZSTD_seqSymbol e183; + public ZSTD_seqSymbol e184; + public ZSTD_seqSymbol e185; + public ZSTD_seqSymbol e186; + public ZSTD_seqSymbol e187; + public ZSTD_seqSymbol e188; + public ZSTD_seqSymbol e189; + public ZSTD_seqSymbol e190; + public ZSTD_seqSymbol e191; + public ZSTD_seqSymbol e192; + public ZSTD_seqSymbol e193; + public ZSTD_seqSymbol e194; + public ZSTD_seqSymbol e195; + public ZSTD_seqSymbol e196; + public ZSTD_seqSymbol e197; + public ZSTD_seqSymbol e198; + public ZSTD_seqSymbol e199; + public ZSTD_seqSymbol e200; + public ZSTD_seqSymbol e201; + public ZSTD_seqSymbol e202; + public ZSTD_seqSymbol e203; + public ZSTD_seqSymbol e204; + public ZSTD_seqSymbol e205; + public ZSTD_seqSymbol e206; + public ZSTD_seqSymbol e207; + public ZSTD_seqSymbol e208; + public ZSTD_seqSymbol e209; + public ZSTD_seqSymbol e210; + public ZSTD_seqSymbol e211; + public ZSTD_seqSymbol e212; + public ZSTD_seqSymbol e213; + public ZSTD_seqSymbol e214; + public ZSTD_seqSymbol e215; + public ZSTD_seqSymbol e216; + public ZSTD_seqSymbol e217; + public ZSTD_seqSymbol e218; + public ZSTD_seqSymbol e219; + public ZSTD_seqSymbol e220; + public ZSTD_seqSymbol e221; + public ZSTD_seqSymbol e222; + public ZSTD_seqSymbol e223; + public ZSTD_seqSymbol e224; + public ZSTD_seqSymbol e225; + public ZSTD_seqSymbol e226; + public ZSTD_seqSymbol e227; + public ZSTD_seqSymbol e228; + public ZSTD_seqSymbol e229; + public ZSTD_seqSymbol e230; + public ZSTD_seqSymbol e231; + public ZSTD_seqSymbol e232; + public ZSTD_seqSymbol e233; + public ZSTD_seqSymbol e234; + public ZSTD_seqSymbol e235; + public ZSTD_seqSymbol e236; + public ZSTD_seqSymbol e237; + public ZSTD_seqSymbol e238; + public ZSTD_seqSymbol e239; + public ZSTD_seqSymbol e240; + public ZSTD_seqSymbol e241; + public ZSTD_seqSymbol e242; + public ZSTD_seqSymbol e243; + public ZSTD_seqSymbol e244; + public ZSTD_seqSymbol e245; + public ZSTD_seqSymbol e246; + public ZSTD_seqSymbol e247; + public ZSTD_seqSymbol e248; + public ZSTD_seqSymbol e249; + public ZSTD_seqSymbol e250; + public ZSTD_seqSymbol e251; + public ZSTD_seqSymbol e252; + public ZSTD_seqSymbol e253; + public ZSTD_seqSymbol e254; + public ZSTD_seqSymbol e255; + public ZSTD_seqSymbol e256; + public ZSTD_seqSymbol e257; + public ZSTD_seqSymbol e258; + public ZSTD_seqSymbol e259; + public ZSTD_seqSymbol e260; + public ZSTD_seqSymbol e261; + public ZSTD_seqSymbol e262; + public ZSTD_seqSymbol e263; + public ZSTD_seqSymbol e264; + public ZSTD_seqSymbol e265; + public ZSTD_seqSymbol e266; + public ZSTD_seqSymbol e267; + public ZSTD_seqSymbol e268; + public ZSTD_seqSymbol e269; + public ZSTD_seqSymbol e270; + public ZSTD_seqSymbol e271; + public ZSTD_seqSymbol e272; + public ZSTD_seqSymbol e273; + public ZSTD_seqSymbol e274; + public ZSTD_seqSymbol e275; + public ZSTD_seqSymbol e276; + public ZSTD_seqSymbol e277; + public ZSTD_seqSymbol e278; + public ZSTD_seqSymbol e279; + public ZSTD_seqSymbol e280; + public ZSTD_seqSymbol e281; + public ZSTD_seqSymbol e282; + public ZSTD_seqSymbol e283; + public ZSTD_seqSymbol e284; + public ZSTD_seqSymbol e285; + public ZSTD_seqSymbol e286; + public ZSTD_seqSymbol e287; + public ZSTD_seqSymbol e288; + public ZSTD_seqSymbol e289; + public ZSTD_seqSymbol e290; + public ZSTD_seqSymbol e291; + public ZSTD_seqSymbol e292; + public ZSTD_seqSymbol e293; + public ZSTD_seqSymbol e294; + public ZSTD_seqSymbol e295; + public ZSTD_seqSymbol e296; + public ZSTD_seqSymbol e297; + public ZSTD_seqSymbol e298; + public ZSTD_seqSymbol e299; + public ZSTD_seqSymbol e300; + public ZSTD_seqSymbol e301; + public ZSTD_seqSymbol e302; + public ZSTD_seqSymbol e303; + public ZSTD_seqSymbol e304; + public ZSTD_seqSymbol e305; + public ZSTD_seqSymbol e306; + public ZSTD_seqSymbol e307; + public ZSTD_seqSymbol e308; + public ZSTD_seqSymbol e309; + public ZSTD_seqSymbol e310; + public ZSTD_seqSymbol e311; + public ZSTD_seqSymbol e312; + public ZSTD_seqSymbol e313; + public ZSTD_seqSymbol e314; + public ZSTD_seqSymbol e315; + public ZSTD_seqSymbol e316; + public ZSTD_seqSymbol e317; + public ZSTD_seqSymbol e318; + public ZSTD_seqSymbol e319; + public ZSTD_seqSymbol e320; + public ZSTD_seqSymbol e321; + public ZSTD_seqSymbol e322; + public ZSTD_seqSymbol e323; + public ZSTD_seqSymbol e324; + public ZSTD_seqSymbol e325; + public ZSTD_seqSymbol e326; + public ZSTD_seqSymbol e327; + public ZSTD_seqSymbol e328; + public ZSTD_seqSymbol e329; + public ZSTD_seqSymbol e330; + public ZSTD_seqSymbol e331; + public ZSTD_seqSymbol e332; + public ZSTD_seqSymbol e333; + public ZSTD_seqSymbol e334; + public ZSTD_seqSymbol e335; + public ZSTD_seqSymbol e336; + public ZSTD_seqSymbol e337; + public ZSTD_seqSymbol e338; + public ZSTD_seqSymbol e339; + public ZSTD_seqSymbol e340; + public ZSTD_seqSymbol e341; + public ZSTD_seqSymbol e342; + public ZSTD_seqSymbol e343; + public ZSTD_seqSymbol e344; + public ZSTD_seqSymbol e345; + public ZSTD_seqSymbol e346; + public ZSTD_seqSymbol e347; + public ZSTD_seqSymbol e348; + public ZSTD_seqSymbol e349; + public ZSTD_seqSymbol e350; + public ZSTD_seqSymbol e351; + public ZSTD_seqSymbol e352; + public ZSTD_seqSymbol e353; + public ZSTD_seqSymbol e354; + public ZSTD_seqSymbol e355; + public ZSTD_seqSymbol e356; + public ZSTD_seqSymbol e357; + public ZSTD_seqSymbol e358; + public ZSTD_seqSymbol e359; + public ZSTD_seqSymbol e360; + public ZSTD_seqSymbol e361; + public ZSTD_seqSymbol e362; + public ZSTD_seqSymbol e363; + public ZSTD_seqSymbol e364; + public ZSTD_seqSymbol e365; + public ZSTD_seqSymbol e366; + public ZSTD_seqSymbol e367; + public ZSTD_seqSymbol e368; + public ZSTD_seqSymbol e369; + public ZSTD_seqSymbol e370; + public ZSTD_seqSymbol e371; + public ZSTD_seqSymbol e372; + public ZSTD_seqSymbol e373; + public ZSTD_seqSymbol e374; + public ZSTD_seqSymbol e375; + public ZSTD_seqSymbol e376; + public ZSTD_seqSymbol e377; + public ZSTD_seqSymbol e378; + public ZSTD_seqSymbol e379; + public ZSTD_seqSymbol e380; + public ZSTD_seqSymbol e381; + public ZSTD_seqSymbol e382; + public ZSTD_seqSymbol e383; + public ZSTD_seqSymbol e384; + public ZSTD_seqSymbol e385; + public ZSTD_seqSymbol e386; + public ZSTD_seqSymbol e387; + public ZSTD_seqSymbol e388; + public ZSTD_seqSymbol e389; + public ZSTD_seqSymbol e390; + public ZSTD_seqSymbol e391; + public ZSTD_seqSymbol e392; + public ZSTD_seqSymbol e393; + public ZSTD_seqSymbol e394; + public ZSTD_seqSymbol e395; + public ZSTD_seqSymbol e396; + public ZSTD_seqSymbol e397; + public ZSTD_seqSymbol e398; + public ZSTD_seqSymbol e399; + public ZSTD_seqSymbol e400; + public ZSTD_seqSymbol e401; + public ZSTD_seqSymbol e402; + public ZSTD_seqSymbol e403; + public ZSTD_seqSymbol e404; + public ZSTD_seqSymbol e405; + public ZSTD_seqSymbol e406; + public ZSTD_seqSymbol e407; + public ZSTD_seqSymbol e408; + public ZSTD_seqSymbol e409; + public ZSTD_seqSymbol e410; + public ZSTD_seqSymbol e411; + public ZSTD_seqSymbol e412; + public ZSTD_seqSymbol e413; + public ZSTD_seqSymbol e414; + public ZSTD_seqSymbol e415; + public ZSTD_seqSymbol e416; + public ZSTD_seqSymbol e417; + public ZSTD_seqSymbol e418; + public ZSTD_seqSymbol e419; + public ZSTD_seqSymbol e420; + public ZSTD_seqSymbol e421; + public ZSTD_seqSymbol e422; + public ZSTD_seqSymbol e423; + public ZSTD_seqSymbol e424; + public ZSTD_seqSymbol e425; + public ZSTD_seqSymbol e426; + public ZSTD_seqSymbol e427; + public ZSTD_seqSymbol e428; + public ZSTD_seqSymbol e429; + public ZSTD_seqSymbol e430; + public ZSTD_seqSymbol e431; + public ZSTD_seqSymbol e432; + public ZSTD_seqSymbol e433; + public ZSTD_seqSymbol e434; + public ZSTD_seqSymbol e435; + public ZSTD_seqSymbol e436; + public ZSTD_seqSymbol e437; + public ZSTD_seqSymbol e438; + public ZSTD_seqSymbol e439; + public ZSTD_seqSymbol e440; + public ZSTD_seqSymbol e441; + public ZSTD_seqSymbol e442; + public ZSTD_seqSymbol e443; + public ZSTD_seqSymbol e444; + public ZSTD_seqSymbol e445; + public ZSTD_seqSymbol e446; + public ZSTD_seqSymbol e447; + public ZSTD_seqSymbol e448; + public ZSTD_seqSymbol e449; + public ZSTD_seqSymbol e450; + public ZSTD_seqSymbol e451; + public ZSTD_seqSymbol e452; + public ZSTD_seqSymbol e453; + public ZSTD_seqSymbol e454; + public ZSTD_seqSymbol e455; + public ZSTD_seqSymbol e456; + public ZSTD_seqSymbol e457; + public ZSTD_seqSymbol e458; + public ZSTD_seqSymbol e459; + public ZSTD_seqSymbol e460; + public ZSTD_seqSymbol e461; + public ZSTD_seqSymbol e462; + public ZSTD_seqSymbol e463; + public ZSTD_seqSymbol e464; + public ZSTD_seqSymbol e465; + public ZSTD_seqSymbol e466; + public ZSTD_seqSymbol e467; + public ZSTD_seqSymbol e468; + public ZSTD_seqSymbol e469; + public ZSTD_seqSymbol e470; + public ZSTD_seqSymbol e471; + public ZSTD_seqSymbol e472; + public ZSTD_seqSymbol e473; + public ZSTD_seqSymbol e474; + public ZSTD_seqSymbol e475; + public ZSTD_seqSymbol e476; + public ZSTD_seqSymbol e477; + public ZSTD_seqSymbol e478; + public ZSTD_seqSymbol e479; + public ZSTD_seqSymbol e480; + public ZSTD_seqSymbol e481; + public ZSTD_seqSymbol e482; + public ZSTD_seqSymbol e483; + public ZSTD_seqSymbol e484; + public ZSTD_seqSymbol e485; + public ZSTD_seqSymbol e486; + public ZSTD_seqSymbol e487; + public ZSTD_seqSymbol e488; + public ZSTD_seqSymbol e489; + public ZSTD_seqSymbol e490; + public ZSTD_seqSymbol e491; + public ZSTD_seqSymbol e492; + public ZSTD_seqSymbol e493; + public ZSTD_seqSymbol e494; + public ZSTD_seqSymbol e495; + public ZSTD_seqSymbol e496; + public ZSTD_seqSymbol e497; + public ZSTD_seqSymbol e498; + public ZSTD_seqSymbol e499; + public ZSTD_seqSymbol e500; + public ZSTD_seqSymbol e501; + public ZSTD_seqSymbol e502; + public ZSTD_seqSymbol e503; + public ZSTD_seqSymbol e504; + public ZSTD_seqSymbol e505; + public ZSTD_seqSymbol e506; + public ZSTD_seqSymbol e507; + public ZSTD_seqSymbol e508; + public ZSTD_seqSymbol e509; + public ZSTD_seqSymbol e510; + public ZSTD_seqSymbol e511; + public ZSTD_seqSymbol e512; + } +#endif + +#if NET8_0_OR_GREATER + [InlineArray(257)] + public unsafe struct _OFTable_e__FixedBuffer + { + public ZSTD_seqSymbol e0; + } + +#else + public unsafe struct _OFTable_e__FixedBuffer + { + public ZSTD_seqSymbol e0; + public ZSTD_seqSymbol e1; + public ZSTD_seqSymbol e2; + public ZSTD_seqSymbol e3; + public ZSTD_seqSymbol e4; + public ZSTD_seqSymbol e5; + public ZSTD_seqSymbol e6; + public ZSTD_seqSymbol e7; + public ZSTD_seqSymbol e8; + public ZSTD_seqSymbol e9; + public ZSTD_seqSymbol e10; + public ZSTD_seqSymbol e11; + public ZSTD_seqSymbol e12; + public ZSTD_seqSymbol e13; + public ZSTD_seqSymbol e14; + public ZSTD_seqSymbol e15; + public ZSTD_seqSymbol e16; + public ZSTD_seqSymbol e17; + public ZSTD_seqSymbol e18; + public ZSTD_seqSymbol e19; + public ZSTD_seqSymbol e20; + public ZSTD_seqSymbol e21; + public ZSTD_seqSymbol e22; + public ZSTD_seqSymbol e23; + public ZSTD_seqSymbol e24; + public ZSTD_seqSymbol e25; + public ZSTD_seqSymbol e26; + public ZSTD_seqSymbol e27; + public ZSTD_seqSymbol e28; + public ZSTD_seqSymbol e29; + public ZSTD_seqSymbol e30; + public ZSTD_seqSymbol e31; + public ZSTD_seqSymbol e32; + public ZSTD_seqSymbol e33; + public ZSTD_seqSymbol e34; + public ZSTD_seqSymbol e35; + public ZSTD_seqSymbol e36; + public ZSTD_seqSymbol e37; + public ZSTD_seqSymbol e38; + public ZSTD_seqSymbol e39; + public ZSTD_seqSymbol e40; + public ZSTD_seqSymbol e41; + public ZSTD_seqSymbol e42; + public ZSTD_seqSymbol e43; + public ZSTD_seqSymbol e44; + public ZSTD_seqSymbol e45; + public ZSTD_seqSymbol e46; + public ZSTD_seqSymbol e47; + public ZSTD_seqSymbol e48; + public ZSTD_seqSymbol e49; + public ZSTD_seqSymbol e50; + public ZSTD_seqSymbol e51; + public ZSTD_seqSymbol e52; + public ZSTD_seqSymbol e53; + public ZSTD_seqSymbol e54; + public ZSTD_seqSymbol e55; + public ZSTD_seqSymbol e56; + public ZSTD_seqSymbol e57; + public ZSTD_seqSymbol e58; + public ZSTD_seqSymbol e59; + public ZSTD_seqSymbol e60; + public ZSTD_seqSymbol e61; + public ZSTD_seqSymbol e62; + public ZSTD_seqSymbol e63; + public ZSTD_seqSymbol e64; + public ZSTD_seqSymbol e65; + public ZSTD_seqSymbol e66; + public ZSTD_seqSymbol e67; + public ZSTD_seqSymbol e68; + public ZSTD_seqSymbol e69; + public ZSTD_seqSymbol e70; + public ZSTD_seqSymbol e71; + public ZSTD_seqSymbol e72; + public ZSTD_seqSymbol e73; + public ZSTD_seqSymbol e74; + public ZSTD_seqSymbol e75; + public ZSTD_seqSymbol e76; + public ZSTD_seqSymbol e77; + public ZSTD_seqSymbol e78; + public ZSTD_seqSymbol e79; + public ZSTD_seqSymbol e80; + public ZSTD_seqSymbol e81; + public ZSTD_seqSymbol e82; + public ZSTD_seqSymbol e83; + public ZSTD_seqSymbol e84; + public ZSTD_seqSymbol e85; + public ZSTD_seqSymbol e86; + public ZSTD_seqSymbol e87; + public ZSTD_seqSymbol e88; + public ZSTD_seqSymbol e89; + public ZSTD_seqSymbol e90; + public ZSTD_seqSymbol e91; + public ZSTD_seqSymbol e92; + public ZSTD_seqSymbol e93; + public ZSTD_seqSymbol e94; + public ZSTD_seqSymbol e95; + public ZSTD_seqSymbol e96; + public ZSTD_seqSymbol e97; + public ZSTD_seqSymbol e98; + public ZSTD_seqSymbol e99; + public ZSTD_seqSymbol e100; + public ZSTD_seqSymbol e101; + public ZSTD_seqSymbol e102; + public ZSTD_seqSymbol e103; + public ZSTD_seqSymbol e104; + public ZSTD_seqSymbol e105; + public ZSTD_seqSymbol e106; + public ZSTD_seqSymbol e107; + public ZSTD_seqSymbol e108; + public ZSTD_seqSymbol e109; + public ZSTD_seqSymbol e110; + public ZSTD_seqSymbol e111; + public ZSTD_seqSymbol e112; + public ZSTD_seqSymbol e113; + public ZSTD_seqSymbol e114; + public ZSTD_seqSymbol e115; + public ZSTD_seqSymbol e116; + public ZSTD_seqSymbol e117; + public ZSTD_seqSymbol e118; + public ZSTD_seqSymbol e119; + public ZSTD_seqSymbol e120; + public ZSTD_seqSymbol e121; + public ZSTD_seqSymbol e122; + public ZSTD_seqSymbol e123; + public ZSTD_seqSymbol e124; + public ZSTD_seqSymbol e125; + public ZSTD_seqSymbol e126; + public ZSTD_seqSymbol e127; + public ZSTD_seqSymbol e128; + public ZSTD_seqSymbol e129; + public ZSTD_seqSymbol e130; + public ZSTD_seqSymbol e131; + public ZSTD_seqSymbol e132; + public ZSTD_seqSymbol e133; + public ZSTD_seqSymbol e134; + public ZSTD_seqSymbol e135; + public ZSTD_seqSymbol e136; + public ZSTD_seqSymbol e137; + public ZSTD_seqSymbol e138; + public ZSTD_seqSymbol e139; + public ZSTD_seqSymbol e140; + public ZSTD_seqSymbol e141; + public ZSTD_seqSymbol e142; + public ZSTD_seqSymbol e143; + public ZSTD_seqSymbol e144; + public ZSTD_seqSymbol e145; + public ZSTD_seqSymbol e146; + public ZSTD_seqSymbol e147; + public ZSTD_seqSymbol e148; + public ZSTD_seqSymbol e149; + public ZSTD_seqSymbol e150; + public ZSTD_seqSymbol e151; + public ZSTD_seqSymbol e152; + public ZSTD_seqSymbol e153; + public ZSTD_seqSymbol e154; + public ZSTD_seqSymbol e155; + public ZSTD_seqSymbol e156; + public ZSTD_seqSymbol e157; + public ZSTD_seqSymbol e158; + public ZSTD_seqSymbol e159; + public ZSTD_seqSymbol e160; + public ZSTD_seqSymbol e161; + public ZSTD_seqSymbol e162; + public ZSTD_seqSymbol e163; + public ZSTD_seqSymbol e164; + public ZSTD_seqSymbol e165; + public ZSTD_seqSymbol e166; + public ZSTD_seqSymbol e167; + public ZSTD_seqSymbol e168; + public ZSTD_seqSymbol e169; + public ZSTD_seqSymbol e170; + public ZSTD_seqSymbol e171; + public ZSTD_seqSymbol e172; + public ZSTD_seqSymbol e173; + public ZSTD_seqSymbol e174; + public ZSTD_seqSymbol e175; + public ZSTD_seqSymbol e176; + public ZSTD_seqSymbol e177; + public ZSTD_seqSymbol e178; + public ZSTD_seqSymbol e179; + public ZSTD_seqSymbol e180; + public ZSTD_seqSymbol e181; + public ZSTD_seqSymbol e182; + public ZSTD_seqSymbol e183; + public ZSTD_seqSymbol e184; + public ZSTD_seqSymbol e185; + public ZSTD_seqSymbol e186; + public ZSTD_seqSymbol e187; + public ZSTD_seqSymbol e188; + public ZSTD_seqSymbol e189; + public ZSTD_seqSymbol e190; + public ZSTD_seqSymbol e191; + public ZSTD_seqSymbol e192; + public ZSTD_seqSymbol e193; + public ZSTD_seqSymbol e194; + public ZSTD_seqSymbol e195; + public ZSTD_seqSymbol e196; + public ZSTD_seqSymbol e197; + public ZSTD_seqSymbol e198; + public ZSTD_seqSymbol e199; + public ZSTD_seqSymbol e200; + public ZSTD_seqSymbol e201; + public ZSTD_seqSymbol e202; + public ZSTD_seqSymbol e203; + public ZSTD_seqSymbol e204; + public ZSTD_seqSymbol e205; + public ZSTD_seqSymbol e206; + public ZSTD_seqSymbol e207; + public ZSTD_seqSymbol e208; + public ZSTD_seqSymbol e209; + public ZSTD_seqSymbol e210; + public ZSTD_seqSymbol e211; + public ZSTD_seqSymbol e212; + public ZSTD_seqSymbol e213; + public ZSTD_seqSymbol e214; + public ZSTD_seqSymbol e215; + public ZSTD_seqSymbol e216; + public ZSTD_seqSymbol e217; + public ZSTD_seqSymbol e218; + public ZSTD_seqSymbol e219; + public ZSTD_seqSymbol e220; + public ZSTD_seqSymbol e221; + public ZSTD_seqSymbol e222; + public ZSTD_seqSymbol e223; + public ZSTD_seqSymbol e224; + public ZSTD_seqSymbol e225; + public ZSTD_seqSymbol e226; + public ZSTD_seqSymbol e227; + public ZSTD_seqSymbol e228; + public ZSTD_seqSymbol e229; + public ZSTD_seqSymbol e230; + public ZSTD_seqSymbol e231; + public ZSTD_seqSymbol e232; + public ZSTD_seqSymbol e233; + public ZSTD_seqSymbol e234; + public ZSTD_seqSymbol e235; + public ZSTD_seqSymbol e236; + public ZSTD_seqSymbol e237; + public ZSTD_seqSymbol e238; + public ZSTD_seqSymbol e239; + public ZSTD_seqSymbol e240; + public ZSTD_seqSymbol e241; + public ZSTD_seqSymbol e242; + public ZSTD_seqSymbol e243; + public ZSTD_seqSymbol e244; + public ZSTD_seqSymbol e245; + public ZSTD_seqSymbol e246; + public ZSTD_seqSymbol e247; + public ZSTD_seqSymbol e248; + public ZSTD_seqSymbol e249; + public ZSTD_seqSymbol e250; + public ZSTD_seqSymbol e251; + public ZSTD_seqSymbol e252; + public ZSTD_seqSymbol e253; + public ZSTD_seqSymbol e254; + public ZSTD_seqSymbol e255; + public ZSTD_seqSymbol e256; + } +#endif + +#if NET8_0_OR_GREATER + [InlineArray(513)] + public unsafe struct _MLTable_e__FixedBuffer + { + public ZSTD_seqSymbol e0; + } + +#else + public unsafe struct _MLTable_e__FixedBuffer + { + public ZSTD_seqSymbol e0; + public ZSTD_seqSymbol e1; + public ZSTD_seqSymbol e2; + public ZSTD_seqSymbol e3; + public ZSTD_seqSymbol e4; + public ZSTD_seqSymbol e5; + public ZSTD_seqSymbol e6; + public ZSTD_seqSymbol e7; + public ZSTD_seqSymbol e8; + public ZSTD_seqSymbol e9; + public ZSTD_seqSymbol e10; + public ZSTD_seqSymbol e11; + public ZSTD_seqSymbol e12; + public ZSTD_seqSymbol e13; + public ZSTD_seqSymbol e14; + public ZSTD_seqSymbol e15; + public ZSTD_seqSymbol e16; + public ZSTD_seqSymbol e17; + public ZSTD_seqSymbol e18; + public ZSTD_seqSymbol e19; + public ZSTD_seqSymbol e20; + public ZSTD_seqSymbol e21; + public ZSTD_seqSymbol e22; + public ZSTD_seqSymbol e23; + public ZSTD_seqSymbol e24; + public ZSTD_seqSymbol e25; + public ZSTD_seqSymbol e26; + public ZSTD_seqSymbol e27; + public ZSTD_seqSymbol e28; + public ZSTD_seqSymbol e29; + public ZSTD_seqSymbol e30; + public ZSTD_seqSymbol e31; + public ZSTD_seqSymbol e32; + public ZSTD_seqSymbol e33; + public ZSTD_seqSymbol e34; + public ZSTD_seqSymbol e35; + public ZSTD_seqSymbol e36; + public ZSTD_seqSymbol e37; + public ZSTD_seqSymbol e38; + public ZSTD_seqSymbol e39; + public ZSTD_seqSymbol e40; + public ZSTD_seqSymbol e41; + public ZSTD_seqSymbol e42; + public ZSTD_seqSymbol e43; + public ZSTD_seqSymbol e44; + public ZSTD_seqSymbol e45; + public ZSTD_seqSymbol e46; + public ZSTD_seqSymbol e47; + public ZSTD_seqSymbol e48; + public ZSTD_seqSymbol e49; + public ZSTD_seqSymbol e50; + public ZSTD_seqSymbol e51; + public ZSTD_seqSymbol e52; + public ZSTD_seqSymbol e53; + public ZSTD_seqSymbol e54; + public ZSTD_seqSymbol e55; + public ZSTD_seqSymbol e56; + public ZSTD_seqSymbol e57; + public ZSTD_seqSymbol e58; + public ZSTD_seqSymbol e59; + public ZSTD_seqSymbol e60; + public ZSTD_seqSymbol e61; + public ZSTD_seqSymbol e62; + public ZSTD_seqSymbol e63; + public ZSTD_seqSymbol e64; + public ZSTD_seqSymbol e65; + public ZSTD_seqSymbol e66; + public ZSTD_seqSymbol e67; + public ZSTD_seqSymbol e68; + public ZSTD_seqSymbol e69; + public ZSTD_seqSymbol e70; + public ZSTD_seqSymbol e71; + public ZSTD_seqSymbol e72; + public ZSTD_seqSymbol e73; + public ZSTD_seqSymbol e74; + public ZSTD_seqSymbol e75; + public ZSTD_seqSymbol e76; + public ZSTD_seqSymbol e77; + public ZSTD_seqSymbol e78; + public ZSTD_seqSymbol e79; + public ZSTD_seqSymbol e80; + public ZSTD_seqSymbol e81; + public ZSTD_seqSymbol e82; + public ZSTD_seqSymbol e83; + public ZSTD_seqSymbol e84; + public ZSTD_seqSymbol e85; + public ZSTD_seqSymbol e86; + public ZSTD_seqSymbol e87; + public ZSTD_seqSymbol e88; + public ZSTD_seqSymbol e89; + public ZSTD_seqSymbol e90; + public ZSTD_seqSymbol e91; + public ZSTD_seqSymbol e92; + public ZSTD_seqSymbol e93; + public ZSTD_seqSymbol e94; + public ZSTD_seqSymbol e95; + public ZSTD_seqSymbol e96; + public ZSTD_seqSymbol e97; + public ZSTD_seqSymbol e98; + public ZSTD_seqSymbol e99; + public ZSTD_seqSymbol e100; + public ZSTD_seqSymbol e101; + public ZSTD_seqSymbol e102; + public ZSTD_seqSymbol e103; + public ZSTD_seqSymbol e104; + public ZSTD_seqSymbol e105; + public ZSTD_seqSymbol e106; + public ZSTD_seqSymbol e107; + public ZSTD_seqSymbol e108; + public ZSTD_seqSymbol e109; + public ZSTD_seqSymbol e110; + public ZSTD_seqSymbol e111; + public ZSTD_seqSymbol e112; + public ZSTD_seqSymbol e113; + public ZSTD_seqSymbol e114; + public ZSTD_seqSymbol e115; + public ZSTD_seqSymbol e116; + public ZSTD_seqSymbol e117; + public ZSTD_seqSymbol e118; + public ZSTD_seqSymbol e119; + public ZSTD_seqSymbol e120; + public ZSTD_seqSymbol e121; + public ZSTD_seqSymbol e122; + public ZSTD_seqSymbol e123; + public ZSTD_seqSymbol e124; + public ZSTD_seqSymbol e125; + public ZSTD_seqSymbol e126; + public ZSTD_seqSymbol e127; + public ZSTD_seqSymbol e128; + public ZSTD_seqSymbol e129; + public ZSTD_seqSymbol e130; + public ZSTD_seqSymbol e131; + public ZSTD_seqSymbol e132; + public ZSTD_seqSymbol e133; + public ZSTD_seqSymbol e134; + public ZSTD_seqSymbol e135; + public ZSTD_seqSymbol e136; + public ZSTD_seqSymbol e137; + public ZSTD_seqSymbol e138; + public ZSTD_seqSymbol e139; + public ZSTD_seqSymbol e140; + public ZSTD_seqSymbol e141; + public ZSTD_seqSymbol e142; + public ZSTD_seqSymbol e143; + public ZSTD_seqSymbol e144; + public ZSTD_seqSymbol e145; + public ZSTD_seqSymbol e146; + public ZSTD_seqSymbol e147; + public ZSTD_seqSymbol e148; + public ZSTD_seqSymbol e149; + public ZSTD_seqSymbol e150; + public ZSTD_seqSymbol e151; + public ZSTD_seqSymbol e152; + public ZSTD_seqSymbol e153; + public ZSTD_seqSymbol e154; + public ZSTD_seqSymbol e155; + public ZSTD_seqSymbol e156; + public ZSTD_seqSymbol e157; + public ZSTD_seqSymbol e158; + public ZSTD_seqSymbol e159; + public ZSTD_seqSymbol e160; + public ZSTD_seqSymbol e161; + public ZSTD_seqSymbol e162; + public ZSTD_seqSymbol e163; + public ZSTD_seqSymbol e164; + public ZSTD_seqSymbol e165; + public ZSTD_seqSymbol e166; + public ZSTD_seqSymbol e167; + public ZSTD_seqSymbol e168; + public ZSTD_seqSymbol e169; + public ZSTD_seqSymbol e170; + public ZSTD_seqSymbol e171; + public ZSTD_seqSymbol e172; + public ZSTD_seqSymbol e173; + public ZSTD_seqSymbol e174; + public ZSTD_seqSymbol e175; + public ZSTD_seqSymbol e176; + public ZSTD_seqSymbol e177; + public ZSTD_seqSymbol e178; + public ZSTD_seqSymbol e179; + public ZSTD_seqSymbol e180; + public ZSTD_seqSymbol e181; + public ZSTD_seqSymbol e182; + public ZSTD_seqSymbol e183; + public ZSTD_seqSymbol e184; + public ZSTD_seqSymbol e185; + public ZSTD_seqSymbol e186; + public ZSTD_seqSymbol e187; + public ZSTD_seqSymbol e188; + public ZSTD_seqSymbol e189; + public ZSTD_seqSymbol e190; + public ZSTD_seqSymbol e191; + public ZSTD_seqSymbol e192; + public ZSTD_seqSymbol e193; + public ZSTD_seqSymbol e194; + public ZSTD_seqSymbol e195; + public ZSTD_seqSymbol e196; + public ZSTD_seqSymbol e197; + public ZSTD_seqSymbol e198; + public ZSTD_seqSymbol e199; + public ZSTD_seqSymbol e200; + public ZSTD_seqSymbol e201; + public ZSTD_seqSymbol e202; + public ZSTD_seqSymbol e203; + public ZSTD_seqSymbol e204; + public ZSTD_seqSymbol e205; + public ZSTD_seqSymbol e206; + public ZSTD_seqSymbol e207; + public ZSTD_seqSymbol e208; + public ZSTD_seqSymbol e209; + public ZSTD_seqSymbol e210; + public ZSTD_seqSymbol e211; + public ZSTD_seqSymbol e212; + public ZSTD_seqSymbol e213; + public ZSTD_seqSymbol e214; + public ZSTD_seqSymbol e215; + public ZSTD_seqSymbol e216; + public ZSTD_seqSymbol e217; + public ZSTD_seqSymbol e218; + public ZSTD_seqSymbol e219; + public ZSTD_seqSymbol e220; + public ZSTD_seqSymbol e221; + public ZSTD_seqSymbol e222; + public ZSTD_seqSymbol e223; + public ZSTD_seqSymbol e224; + public ZSTD_seqSymbol e225; + public ZSTD_seqSymbol e226; + public ZSTD_seqSymbol e227; + public ZSTD_seqSymbol e228; + public ZSTD_seqSymbol e229; + public ZSTD_seqSymbol e230; + public ZSTD_seqSymbol e231; + public ZSTD_seqSymbol e232; + public ZSTD_seqSymbol e233; + public ZSTD_seqSymbol e234; + public ZSTD_seqSymbol e235; + public ZSTD_seqSymbol e236; + public ZSTD_seqSymbol e237; + public ZSTD_seqSymbol e238; + public ZSTD_seqSymbol e239; + public ZSTD_seqSymbol e240; + public ZSTD_seqSymbol e241; + public ZSTD_seqSymbol e242; + public ZSTD_seqSymbol e243; + public ZSTD_seqSymbol e244; + public ZSTD_seqSymbol e245; + public ZSTD_seqSymbol e246; + public ZSTD_seqSymbol e247; + public ZSTD_seqSymbol e248; + public ZSTD_seqSymbol e249; + public ZSTD_seqSymbol e250; + public ZSTD_seqSymbol e251; + public ZSTD_seqSymbol e252; + public ZSTD_seqSymbol e253; + public ZSTD_seqSymbol e254; + public ZSTD_seqSymbol e255; + public ZSTD_seqSymbol e256; + public ZSTD_seqSymbol e257; + public ZSTD_seqSymbol e258; + public ZSTD_seqSymbol e259; + public ZSTD_seqSymbol e260; + public ZSTD_seqSymbol e261; + public ZSTD_seqSymbol e262; + public ZSTD_seqSymbol e263; + public ZSTD_seqSymbol e264; + public ZSTD_seqSymbol e265; + public ZSTD_seqSymbol e266; + public ZSTD_seqSymbol e267; + public ZSTD_seqSymbol e268; + public ZSTD_seqSymbol e269; + public ZSTD_seqSymbol e270; + public ZSTD_seqSymbol e271; + public ZSTD_seqSymbol e272; + public ZSTD_seqSymbol e273; + public ZSTD_seqSymbol e274; + public ZSTD_seqSymbol e275; + public ZSTD_seqSymbol e276; + public ZSTD_seqSymbol e277; + public ZSTD_seqSymbol e278; + public ZSTD_seqSymbol e279; + public ZSTD_seqSymbol e280; + public ZSTD_seqSymbol e281; + public ZSTD_seqSymbol e282; + public ZSTD_seqSymbol e283; + public ZSTD_seqSymbol e284; + public ZSTD_seqSymbol e285; + public ZSTD_seqSymbol e286; + public ZSTD_seqSymbol e287; + public ZSTD_seqSymbol e288; + public ZSTD_seqSymbol e289; + public ZSTD_seqSymbol e290; + public ZSTD_seqSymbol e291; + public ZSTD_seqSymbol e292; + public ZSTD_seqSymbol e293; + public ZSTD_seqSymbol e294; + public ZSTD_seqSymbol e295; + public ZSTD_seqSymbol e296; + public ZSTD_seqSymbol e297; + public ZSTD_seqSymbol e298; + public ZSTD_seqSymbol e299; + public ZSTD_seqSymbol e300; + public ZSTD_seqSymbol e301; + public ZSTD_seqSymbol e302; + public ZSTD_seqSymbol e303; + public ZSTD_seqSymbol e304; + public ZSTD_seqSymbol e305; + public ZSTD_seqSymbol e306; + public ZSTD_seqSymbol e307; + public ZSTD_seqSymbol e308; + public ZSTD_seqSymbol e309; + public ZSTD_seqSymbol e310; + public ZSTD_seqSymbol e311; + public ZSTD_seqSymbol e312; + public ZSTD_seqSymbol e313; + public ZSTD_seqSymbol e314; + public ZSTD_seqSymbol e315; + public ZSTD_seqSymbol e316; + public ZSTD_seqSymbol e317; + public ZSTD_seqSymbol e318; + public ZSTD_seqSymbol e319; + public ZSTD_seqSymbol e320; + public ZSTD_seqSymbol e321; + public ZSTD_seqSymbol e322; + public ZSTD_seqSymbol e323; + public ZSTD_seqSymbol e324; + public ZSTD_seqSymbol e325; + public ZSTD_seqSymbol e326; + public ZSTD_seqSymbol e327; + public ZSTD_seqSymbol e328; + public ZSTD_seqSymbol e329; + public ZSTD_seqSymbol e330; + public ZSTD_seqSymbol e331; + public ZSTD_seqSymbol e332; + public ZSTD_seqSymbol e333; + public ZSTD_seqSymbol e334; + public ZSTD_seqSymbol e335; + public ZSTD_seqSymbol e336; + public ZSTD_seqSymbol e337; + public ZSTD_seqSymbol e338; + public ZSTD_seqSymbol e339; + public ZSTD_seqSymbol e340; + public ZSTD_seqSymbol e341; + public ZSTD_seqSymbol e342; + public ZSTD_seqSymbol e343; + public ZSTD_seqSymbol e344; + public ZSTD_seqSymbol e345; + public ZSTD_seqSymbol e346; + public ZSTD_seqSymbol e347; + public ZSTD_seqSymbol e348; + public ZSTD_seqSymbol e349; + public ZSTD_seqSymbol e350; + public ZSTD_seqSymbol e351; + public ZSTD_seqSymbol e352; + public ZSTD_seqSymbol e353; + public ZSTD_seqSymbol e354; + public ZSTD_seqSymbol e355; + public ZSTD_seqSymbol e356; + public ZSTD_seqSymbol e357; + public ZSTD_seqSymbol e358; + public ZSTD_seqSymbol e359; + public ZSTD_seqSymbol e360; + public ZSTD_seqSymbol e361; + public ZSTD_seqSymbol e362; + public ZSTD_seqSymbol e363; + public ZSTD_seqSymbol e364; + public ZSTD_seqSymbol e365; + public ZSTD_seqSymbol e366; + public ZSTD_seqSymbol e367; + public ZSTD_seqSymbol e368; + public ZSTD_seqSymbol e369; + public ZSTD_seqSymbol e370; + public ZSTD_seqSymbol e371; + public ZSTD_seqSymbol e372; + public ZSTD_seqSymbol e373; + public ZSTD_seqSymbol e374; + public ZSTD_seqSymbol e375; + public ZSTD_seqSymbol e376; + public ZSTD_seqSymbol e377; + public ZSTD_seqSymbol e378; + public ZSTD_seqSymbol e379; + public ZSTD_seqSymbol e380; + public ZSTD_seqSymbol e381; + public ZSTD_seqSymbol e382; + public ZSTD_seqSymbol e383; + public ZSTD_seqSymbol e384; + public ZSTD_seqSymbol e385; + public ZSTD_seqSymbol e386; + public ZSTD_seqSymbol e387; + public ZSTD_seqSymbol e388; + public ZSTD_seqSymbol e389; + public ZSTD_seqSymbol e390; + public ZSTD_seqSymbol e391; + public ZSTD_seqSymbol e392; + public ZSTD_seqSymbol e393; + public ZSTD_seqSymbol e394; + public ZSTD_seqSymbol e395; + public ZSTD_seqSymbol e396; + public ZSTD_seqSymbol e397; + public ZSTD_seqSymbol e398; + public ZSTD_seqSymbol e399; + public ZSTD_seqSymbol e400; + public ZSTD_seqSymbol e401; + public ZSTD_seqSymbol e402; + public ZSTD_seqSymbol e403; + public ZSTD_seqSymbol e404; + public ZSTD_seqSymbol e405; + public ZSTD_seqSymbol e406; + public ZSTD_seqSymbol e407; + public ZSTD_seqSymbol e408; + public ZSTD_seqSymbol e409; + public ZSTD_seqSymbol e410; + public ZSTD_seqSymbol e411; + public ZSTD_seqSymbol e412; + public ZSTD_seqSymbol e413; + public ZSTD_seqSymbol e414; + public ZSTD_seqSymbol e415; + public ZSTD_seqSymbol e416; + public ZSTD_seqSymbol e417; + public ZSTD_seqSymbol e418; + public ZSTD_seqSymbol e419; + public ZSTD_seqSymbol e420; + public ZSTD_seqSymbol e421; + public ZSTD_seqSymbol e422; + public ZSTD_seqSymbol e423; + public ZSTD_seqSymbol e424; + public ZSTD_seqSymbol e425; + public ZSTD_seqSymbol e426; + public ZSTD_seqSymbol e427; + public ZSTD_seqSymbol e428; + public ZSTD_seqSymbol e429; + public ZSTD_seqSymbol e430; + public ZSTD_seqSymbol e431; + public ZSTD_seqSymbol e432; + public ZSTD_seqSymbol e433; + public ZSTD_seqSymbol e434; + public ZSTD_seqSymbol e435; + public ZSTD_seqSymbol e436; + public ZSTD_seqSymbol e437; + public ZSTD_seqSymbol e438; + public ZSTD_seqSymbol e439; + public ZSTD_seqSymbol e440; + public ZSTD_seqSymbol e441; + public ZSTD_seqSymbol e442; + public ZSTD_seqSymbol e443; + public ZSTD_seqSymbol e444; + public ZSTD_seqSymbol e445; + public ZSTD_seqSymbol e446; + public ZSTD_seqSymbol e447; + public ZSTD_seqSymbol e448; + public ZSTD_seqSymbol e449; + public ZSTD_seqSymbol e450; + public ZSTD_seqSymbol e451; + public ZSTD_seqSymbol e452; + public ZSTD_seqSymbol e453; + public ZSTD_seqSymbol e454; + public ZSTD_seqSymbol e455; + public ZSTD_seqSymbol e456; + public ZSTD_seqSymbol e457; + public ZSTD_seqSymbol e458; + public ZSTD_seqSymbol e459; + public ZSTD_seqSymbol e460; + public ZSTD_seqSymbol e461; + public ZSTD_seqSymbol e462; + public ZSTD_seqSymbol e463; + public ZSTD_seqSymbol e464; + public ZSTD_seqSymbol e465; + public ZSTD_seqSymbol e466; + public ZSTD_seqSymbol e467; + public ZSTD_seqSymbol e468; + public ZSTD_seqSymbol e469; + public ZSTD_seqSymbol e470; + public ZSTD_seqSymbol e471; + public ZSTD_seqSymbol e472; + public ZSTD_seqSymbol e473; + public ZSTD_seqSymbol e474; + public ZSTD_seqSymbol e475; + public ZSTD_seqSymbol e476; + public ZSTD_seqSymbol e477; + public ZSTD_seqSymbol e478; + public ZSTD_seqSymbol e479; + public ZSTD_seqSymbol e480; + public ZSTD_seqSymbol e481; + public ZSTD_seqSymbol e482; + public ZSTD_seqSymbol e483; + public ZSTD_seqSymbol e484; + public ZSTD_seqSymbol e485; + public ZSTD_seqSymbol e486; + public ZSTD_seqSymbol e487; + public ZSTD_seqSymbol e488; + public ZSTD_seqSymbol e489; + public ZSTD_seqSymbol e490; + public ZSTD_seqSymbol e491; + public ZSTD_seqSymbol e492; + public ZSTD_seqSymbol e493; + public ZSTD_seqSymbol e494; + public ZSTD_seqSymbol e495; + public ZSTD_seqSymbol e496; + public ZSTD_seqSymbol e497; + public ZSTD_seqSymbol e498; + public ZSTD_seqSymbol e499; + public ZSTD_seqSymbol e500; + public ZSTD_seqSymbol e501; + public ZSTD_seqSymbol e502; + public ZSTD_seqSymbol e503; + public ZSTD_seqSymbol e504; + public ZSTD_seqSymbol e505; + public ZSTD_seqSymbol e506; + public ZSTD_seqSymbol e507; + public ZSTD_seqSymbol e508; + public ZSTD_seqSymbol e509; + public ZSTD_seqSymbol e510; + public ZSTD_seqSymbol e511; + public ZSTD_seqSymbol e512; + } +#endif +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_forceIgnoreChecksum_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_forceIgnoreChecksum_e.cs new file mode 100644 index 000000000..a83226218 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_forceIgnoreChecksum_e.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_forceIgnoreChecksum_e +{ + /* Note: this enum controls ZSTD_d_forceIgnoreChecksum */ + ZSTD_d_validateChecksum = 0, + ZSTD_d_ignoreChecksum = 1, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_format_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_format_e.cs new file mode 100644 index 000000000..28f4de188 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_format_e.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_format_e +{ + /* zstd frame format, specified in zstd_compression_format.md (default) */ + ZSTD_f_zstd1 = 0, + + /* Variant of zstd frame format, without initial 4-bytes magic number. + * Useful to save 4 bytes per generated frame. + * Decoder cannot recognise automatically this format, requiring this instruction. */ + ZSTD_f_zstd1_magicless = 1, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameHeader.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameHeader.cs new file mode 100644 index 000000000..8c80f7592 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameHeader.cs @@ -0,0 +1,21 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZSTD_frameHeader +{ + /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means "empty" */ + public ulong frameContentSize; + + /* can be very large, up to <= frameContentSize */ + public ulong windowSize; + public uint blockSizeMax; + + /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */ + public ZSTD_frameType_e frameType; + public uint headerSize; + + /* for ZSTD_skippableFrame, contains the skippable magic variant [0-15] */ + public uint dictID; + public uint checksumFlag; + public uint _reserved1; + public uint _reserved2; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameParameters.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameParameters.cs new file mode 100644 index 000000000..137ccb375 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameParameters.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZSTD_frameParameters +{ + /**< 1: content size will be in frame header (when known) */ + public int contentSizeFlag; + + /**< 1: generate a 32-bits checksum using XXH64 algorithm at end of frame, for error detection */ + public int checksumFlag; + + /**< 1: no dictID will be saved into frame header (dictID is only useful for dictionary compression) */ + public int noDictIDFlag; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameProgression.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameProgression.cs new file mode 100644 index 000000000..adf34b4df --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameProgression.cs @@ -0,0 +1,22 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZSTD_frameProgression +{ + /* nb input bytes read and buffered */ + public ulong ingested; + + /* nb input bytes actually compressed */ + public ulong consumed; + + /* nb of compressed bytes generated and buffered */ + public ulong produced; + + /* nb of compressed bytes flushed : not provided; can be tracked from caller side */ + public ulong flushed; + + /* MT only : latest started job nb */ + public uint currentJobID; + + /* MT only : nb of workers actively compressing at probe time */ + public uint nbActiveWorkers; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameSizeInfo.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameSizeInfo.cs new file mode 100644 index 000000000..7f9b6b08f --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameSizeInfo.cs @@ -0,0 +1,14 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + * Contains the compressed frame size and an upper-bound for the decompressed frame size. + * Note: before using `compressedSize`, check for errors using ZSTD_isError(). + * similarly, before using `decompressedBound`, check for errors using: + * `decompressedBound != ZSTD_CONTENTSIZE_ERROR` + */ +public struct ZSTD_frameSizeInfo +{ + public nuint nbBlocks; + public nuint compressedSize; + public ulong decompressedBound; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameType_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameType_e.cs new file mode 100644 index 000000000..a399748fa --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_frameType_e.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_frameType_e +{ + ZSTD_frame, + ZSTD_skippableFrame, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_fseCTablesMetadata_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_fseCTablesMetadata_t.cs new file mode 100644 index 000000000..c6aa0dc8c --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_fseCTablesMetadata_t.cs @@ -0,0 +1,18 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** ZSTD_fseCTablesMetadata_t : + * Stores symbol compression modes for a super-block in {ll, ol, ml}Type, and + * fse tables in fseTablesBuffer. + * fseTablesSize refers to the size of fse tables in bytes. + * This metadata is populated in ZSTD_buildBlockEntropyStats_sequences() */ +public unsafe struct ZSTD_fseCTablesMetadata_t +{ + public SymbolEncodingType_e llType; + public SymbolEncodingType_e ofType; + public SymbolEncodingType_e mlType; + public fixed byte fseTablesBuffer[133]; + public nuint fseTablesSize; + + /* This is to account for bug in 1.3.4. More detail in ZSTD_entropyCompressSeqStore_internal() */ + public nuint lastCountSize; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_fseCTables_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_fseCTables_t.cs new file mode 100644 index 000000000..3a9d621b3 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_fseCTables_t.cs @@ -0,0 +1,11 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_fseCTables_t +{ + public fixed uint offcodeCTable[193]; + public fixed uint matchlengthCTable[363]; + public fixed uint litlengthCTable[329]; + public FSE_repeat offcode_repeatMode; + public FSE_repeat matchlength_repeatMode; + public FSE_repeat litlength_repeatMode; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_fseState.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_fseState.cs new file mode 100644 index 000000000..2e7b2a2c7 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_fseState.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_fseState +{ + public nuint state; + public ZSTD_seqSymbol* table; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_getAllMatchesFn.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_getAllMatchesFn.cs new file mode 100644 index 000000000..4f7ee54f3 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_getAllMatchesFn.cs @@ -0,0 +1,15 @@ +using System.Runtime.InteropServices; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +[UnmanagedFunctionPointer(CallingConvention.Cdecl)] +public unsafe delegate uint ZSTD_getAllMatchesFn( + ZSTD_match_t* param0, + ZSTD_MatchState_t* param1, + uint* param2, + byte* param3, + byte* param4, + uint* rep, + uint ll0, + uint lengthToBeat +); diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_hufCTablesMetadata_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_hufCTablesMetadata_t.cs new file mode 100644 index 000000000..481bd6472 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_hufCTablesMetadata_t.cs @@ -0,0 +1,16 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*********************************************** + * Entropy buffer statistics structs and funcs * + ***********************************************/ +/** ZSTD_hufCTablesMetadata_t : + * Stores Literals Block Type for a super-block in hType, and + * huffman tree description in hufDesBuffer. + * hufDesSize refers to the size of huffman tree description in bytes. + * This metadata is populated in ZSTD_buildBlockEntropyStats_literals() */ +public unsafe struct ZSTD_hufCTablesMetadata_t +{ + public SymbolEncodingType_e hType; + public fixed byte hufDesBuffer[128]; + public nuint hufDesSize; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_hufCTables_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_hufCTables_t.cs new file mode 100644 index 000000000..bedd8c8bf --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_hufCTables_t.cs @@ -0,0 +1,279 @@ +using System.Runtime.CompilerServices; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_hufCTables_t +{ + public _CTable_e__FixedBuffer CTable; + public HUF_repeat repeatMode; + +#if NET8_0_OR_GREATER + [InlineArray(257)] + public unsafe struct _CTable_e__FixedBuffer + { + public nuint e0; + } + +#else + public unsafe struct _CTable_e__FixedBuffer + { + public nuint e0; + public nuint e1; + public nuint e2; + public nuint e3; + public nuint e4; + public nuint e5; + public nuint e6; + public nuint e7; + public nuint e8; + public nuint e9; + public nuint e10; + public nuint e11; + public nuint e12; + public nuint e13; + public nuint e14; + public nuint e15; + public nuint e16; + public nuint e17; + public nuint e18; + public nuint e19; + public nuint e20; + public nuint e21; + public nuint e22; + public nuint e23; + public nuint e24; + public nuint e25; + public nuint e26; + public nuint e27; + public nuint e28; + public nuint e29; + public nuint e30; + public nuint e31; + public nuint e32; + public nuint e33; + public nuint e34; + public nuint e35; + public nuint e36; + public nuint e37; + public nuint e38; + public nuint e39; + public nuint e40; + public nuint e41; + public nuint e42; + public nuint e43; + public nuint e44; + public nuint e45; + public nuint e46; + public nuint e47; + public nuint e48; + public nuint e49; + public nuint e50; + public nuint e51; + public nuint e52; + public nuint e53; + public nuint e54; + public nuint e55; + public nuint e56; + public nuint e57; + public nuint e58; + public nuint e59; + public nuint e60; + public nuint e61; + public nuint e62; + public nuint e63; + public nuint e64; + public nuint e65; + public nuint e66; + public nuint e67; + public nuint e68; + public nuint e69; + public nuint e70; + public nuint e71; + public nuint e72; + public nuint e73; + public nuint e74; + public nuint e75; + public nuint e76; + public nuint e77; + public nuint e78; + public nuint e79; + public nuint e80; + public nuint e81; + public nuint e82; + public nuint e83; + public nuint e84; + public nuint e85; + public nuint e86; + public nuint e87; + public nuint e88; + public nuint e89; + public nuint e90; + public nuint e91; + public nuint e92; + public nuint e93; + public nuint e94; + public nuint e95; + public nuint e96; + public nuint e97; + public nuint e98; + public nuint e99; + public nuint e100; + public nuint e101; + public nuint e102; + public nuint e103; + public nuint e104; + public nuint e105; + public nuint e106; + public nuint e107; + public nuint e108; + public nuint e109; + public nuint e110; + public nuint e111; + public nuint e112; + public nuint e113; + public nuint e114; + public nuint e115; + public nuint e116; + public nuint e117; + public nuint e118; + public nuint e119; + public nuint e120; + public nuint e121; + public nuint e122; + public nuint e123; + public nuint e124; + public nuint e125; + public nuint e126; + public nuint e127; + public nuint e128; + public nuint e129; + public nuint e130; + public nuint e131; + public nuint e132; + public nuint e133; + public nuint e134; + public nuint e135; + public nuint e136; + public nuint e137; + public nuint e138; + public nuint e139; + public nuint e140; + public nuint e141; + public nuint e142; + public nuint e143; + public nuint e144; + public nuint e145; + public nuint e146; + public nuint e147; + public nuint e148; + public nuint e149; + public nuint e150; + public nuint e151; + public nuint e152; + public nuint e153; + public nuint e154; + public nuint e155; + public nuint e156; + public nuint e157; + public nuint e158; + public nuint e159; + public nuint e160; + public nuint e161; + public nuint e162; + public nuint e163; + public nuint e164; + public nuint e165; + public nuint e166; + public nuint e167; + public nuint e168; + public nuint e169; + public nuint e170; + public nuint e171; + public nuint e172; + public nuint e173; + public nuint e174; + public nuint e175; + public nuint e176; + public nuint e177; + public nuint e178; + public nuint e179; + public nuint e180; + public nuint e181; + public nuint e182; + public nuint e183; + public nuint e184; + public nuint e185; + public nuint e186; + public nuint e187; + public nuint e188; + public nuint e189; + public nuint e190; + public nuint e191; + public nuint e192; + public nuint e193; + public nuint e194; + public nuint e195; + public nuint e196; + public nuint e197; + public nuint e198; + public nuint e199; + public nuint e200; + public nuint e201; + public nuint e202; + public nuint e203; + public nuint e204; + public nuint e205; + public nuint e206; + public nuint e207; + public nuint e208; + public nuint e209; + public nuint e210; + public nuint e211; + public nuint e212; + public nuint e213; + public nuint e214; + public nuint e215; + public nuint e216; + public nuint e217; + public nuint e218; + public nuint e219; + public nuint e220; + public nuint e221; + public nuint e222; + public nuint e223; + public nuint e224; + public nuint e225; + public nuint e226; + public nuint e227; + public nuint e228; + public nuint e229; + public nuint e230; + public nuint e231; + public nuint e232; + public nuint e233; + public nuint e234; + public nuint e235; + public nuint e236; + public nuint e237; + public nuint e238; + public nuint e239; + public nuint e240; + public nuint e241; + public nuint e242; + public nuint e243; + public nuint e244; + public nuint e245; + public nuint e246; + public nuint e247; + public nuint e248; + public nuint e249; + public nuint e250; + public nuint e251; + public nuint e252; + public nuint e253; + public nuint e254; + public nuint e255; + public nuint e256; + } +#endif +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_inBuffer_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_inBuffer_s.cs new file mode 100644 index 000000000..58242a2c5 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_inBuffer_s.cs @@ -0,0 +1,16 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/**************************** + * Streaming + ****************************/ +public unsafe struct ZSTD_inBuffer_s +{ + /**< start of input buffer */ + public void* src; + + /**< size of input buffer */ + public nuint size; + + /**< position where reading stopped. Will be updated. Necessarily 0 <= pos <= size */ + public nuint pos; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_indexResetPolicy_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_indexResetPolicy_e.cs new file mode 100644 index 000000000..b3638aa07 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_indexResetPolicy_e.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/** + * Controls, for this matchState reset, whether indexing can continue where it + * left off (ZSTDirp_continue), or whether it needs to be restarted from zero + * (ZSTDirp_reset). + */ +public enum ZSTD_indexResetPolicy_e +{ + ZSTDirp_continue, + ZSTDirp_reset, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_litLocation_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_litLocation_e.cs new file mode 100644 index 000000000..55d285621 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_litLocation_e.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_litLocation_e +{ + /* Stored entirely within litExtraBuffer */ + ZSTD_not_in_dst = 0, + + /* Stored entirely within dst (in memory after current output write) */ + ZSTD_in_dst = 1, + + /* Split between litExtraBuffer and dst */ + ZSTD_split = 2, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_literalCompressionMode_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_literalCompressionMode_e.cs new file mode 100644 index 000000000..2c309b06e --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_literalCompressionMode_e.cs @@ -0,0 +1,16 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_literalCompressionMode_e +{ + /**< Automatically determine the compression mode based on the compression level. + * Negative compression levels will be uncompressed, and positive compression + * levels will be compressed. */ + ZSTD_lcm_auto = 0, + + /**< Always attempt Huffman compression. Uncompressed literals will still be + * emitted if Huffman compression is not profitable. */ + ZSTD_lcm_huffman = 1, + + /**< Always emit uncompressed literals. */ + ZSTD_lcm_uncompressed = 2, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_localDict.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_localDict.cs new file mode 100644 index 000000000..4b9704519 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_localDict.cs @@ -0,0 +1,10 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_localDict +{ + public void* dictBuffer; + public void* dict; + public nuint dictSize; + public ZSTD_dictContentType_e dictContentType; + public ZSTD_CDict_s* cdict; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_longLengthType_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_longLengthType_e.cs new file mode 100644 index 000000000..141643f29 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_longLengthType_e.cs @@ -0,0 +1,14 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* Controls whether seqStore has a single "long" litLength or matchLength. See SeqStore_t. */ +public enum ZSTD_longLengthType_e +{ + /* no longLengthType */ + ZSTD_llt_none = 0, + + /* represents a long literal */ + ZSTD_llt_literalLength = 1, + + /* represents a long match */ + ZSTD_llt_matchLength = 2, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_longOffset_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_longOffset_e.cs new file mode 100644 index 000000000..86881bdd1 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_longOffset_e.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_longOffset_e +{ + ZSTD_lo_isRegularOffset, + ZSTD_lo_isLongOffset = 1, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_match_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_match_t.cs new file mode 100644 index 000000000..fa44b9ec5 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_match_t.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/********************************* + * Compression internals structs * + *********************************/ +public struct ZSTD_match_t +{ + /* Offset sumtype code for the match, using ZSTD_storeSeq() format */ + public uint off; + + /* Raw length of match */ + public uint len; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_nextInputType_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_nextInputType_e.cs new file mode 100644 index 000000000..5ebea51ea --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_nextInputType_e.cs @@ -0,0 +1,11 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_nextInputType_e +{ + ZSTDnit_frameHeader, + ZSTDnit_blockHeader, + ZSTDnit_block, + ZSTDnit_lastBlock, + ZSTDnit_checksum, + ZSTDnit_skippableFrame, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_optLdm_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_optLdm_t.cs new file mode 100644 index 000000000..8319db5bf --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_optLdm_t.cs @@ -0,0 +1,17 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* Struct containing info needed to make decision about ldm inclusion */ +public struct ZSTD_optLdm_t +{ + /* External match candidates store for this block */ + public RawSeqStore_t seqStore; + + /* Start position of the current match candidate */ + public uint startPosInBlock; + + /* End position of the current match candidate */ + public uint endPosInBlock; + + /* Offset of the match candidate */ + public uint offset; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_optimal_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_optimal_t.cs new file mode 100644 index 000000000..848451875 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_optimal_t.cs @@ -0,0 +1,19 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_optimal_t +{ + /* price from beginning of segment to this position */ + public int price; + + /* offset of previous match */ + public uint off; + + /* length of previous match */ + public uint mlen; + + /* nb of literals since previous match */ + public uint litlen; + + /* offset history after previous match */ + public fixed uint rep[3]; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_outBuffer_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_outBuffer_s.cs new file mode 100644 index 000000000..c2cc00895 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_outBuffer_s.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_outBuffer_s +{ + /**< start of output buffer */ + public void* dst; + + /**< size of output buffer */ + public nuint size; + + /**< position where writing stopped. Will be updated. Necessarily 0 <= pos <= size */ + public nuint pos; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_overlap_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_overlap_e.cs new file mode 100644 index 000000000..bf5b85e1b --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_overlap_e.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_overlap_e +{ + ZSTD_no_overlap, + ZSTD_overlap_src_before_dst, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_paramSwitch_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_paramSwitch_e.cs new file mode 100644 index 000000000..3ff214929 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_paramSwitch_e.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_paramSwitch_e +{ + /* Let the library automatically determine whether the feature shall be enabled */ + ZSTD_ps_auto = 0, + + /* Force-enable the feature */ + ZSTD_ps_enable = 1, + + /* Do not use the feature */ + ZSTD_ps_disable = 2, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_parameters.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_parameters.cs new file mode 100644 index 000000000..ebdf19696 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_parameters.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZSTD_parameters +{ + public ZSTD_compressionParameters cParams; + public ZSTD_frameParameters fParams; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_prefixDict_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_prefixDict_s.cs new file mode 100644 index 000000000..2a0db4729 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_prefixDict_s.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_prefixDict_s +{ + public void* dict; + public nuint dictSize; + public ZSTD_dictContentType_e dictContentType; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_refMultipleDDicts_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_refMultipleDDicts_e.cs new file mode 100644 index 000000000..c01fcefcf --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_refMultipleDDicts_e.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_refMultipleDDicts_e +{ + /* Note: this enum controls ZSTD_d_refMultipleDDicts */ + ZSTD_rmd_refSingleDDict = 0, + ZSTD_rmd_refMultipleDDicts = 1, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_resetTarget_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_resetTarget_e.cs new file mode 100644 index 000000000..679e8b281 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_resetTarget_e.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_resetTarget_e +{ + ZSTD_resetTarget_CDict, + ZSTD_resetTarget_CCtx, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_seqSymbol.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_seqSymbol.cs new file mode 100644 index 000000000..622ff4fcd --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_seqSymbol.cs @@ -0,0 +1,17 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ZSTD_seqSymbol +{ + public ushort nextState; + public byte nbAdditionalBits; + public byte nbBits; + public uint baseValue; + + public ZSTD_seqSymbol(ushort nextState, byte nbAdditionalBits, byte nbBits, uint baseValue) + { + this.nextState = nextState; + this.nbAdditionalBits = nbAdditionalBits; + this.nbBits = nbBits; + this.baseValue = baseValue; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_seqSymbol_header.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_seqSymbol_header.cs new file mode 100644 index 000000000..eb87911ca --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_seqSymbol_header.cs @@ -0,0 +1,10 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/*-******************************************************* + * Decompression types + *********************************************************/ +public struct ZSTD_seqSymbol_header +{ + public uint fastMode; + public uint tableLog; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_sequenceFormat_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_sequenceFormat_e.cs new file mode 100644 index 000000000..3b6ca5258 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_sequenceFormat_e.cs @@ -0,0 +1,10 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_sequenceFormat_e +{ + /* ZSTD_Sequence[] has no block delimiters, just sequences */ + ZSTD_sf_noBlockDelimiters = 0, + + /* ZSTD_Sequence[] contains explicit block delimiters */ + ZSTD_sf_explicitBlockDelimiters = 1, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_strategy.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_strategy.cs new file mode 100644 index 000000000..49d8e23e7 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_strategy.cs @@ -0,0 +1,15 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* Compression strategies, listed from fastest to strongest */ +public enum ZSTD_strategy +{ + ZSTD_fast = 1, + ZSTD_dfast = 2, + ZSTD_greedy = 3, + ZSTD_lazy = 4, + ZSTD_lazy2 = 5, + ZSTD_btlazy2 = 6, + ZSTD_btopt = 7, + ZSTD_btultra = 8, + ZSTD_btultra2 = 9, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_symbolEncodingTypeStats_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_symbolEncodingTypeStats_t.cs new file mode 100644 index 000000000..673f2b3df --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_symbolEncodingTypeStats_t.cs @@ -0,0 +1,16 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* Type returned by ZSTD_buildSequencesStatistics containing finalized symbol encoding types + * and size of the sequences statistics + */ +public struct ZSTD_symbolEncodingTypeStats_t +{ + public uint LLtype; + public uint Offtype; + public uint MLtype; + public nuint size; + + /* Accounts for bug in 1.3.4. More detail in ZSTD_entropyCompressSeqStore_internal() */ + public nuint lastCountSize; + public int longOffsets; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_tableFillPurpose_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_tableFillPurpose_e.cs new file mode 100644 index 000000000..f218de33b --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_tableFillPurpose_e.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum ZSTD_tableFillPurpose_e +{ + ZSTD_tfp_forCCtx, + ZSTD_tfp_forCDict, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_window_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_window_t.cs new file mode 100644 index 000000000..84895dab8 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZSTD_window_t.cs @@ -0,0 +1,25 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ZSTD_window_t +{ + /* next block here to continue on current prefix */ + public byte* nextSrc; + + /* All regular indexes relative to this position */ + public byte* @base; + + /* extDict indexes relative to this position */ + public byte* dictBase; + + /* below that point, need extDict */ + public uint dictLimit; + + /* below that point, no more valid data */ + public uint lowLimit; + + /* Number of times overflow correction has run since + * ZSTD_window_init(). Useful for debugging coredumps + * and for ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY. + */ + public uint nbOverflowCorrections; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Zdict.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Zdict.cs new file mode 100644 index 000000000..a79aa0082 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Zdict.cs @@ -0,0 +1,640 @@ +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /*-******************************************************** + * Helper functions + **********************************************************/ + public static bool ZDICT_isError(nuint errorCode) + { + return ERR_isError(errorCode); + } + + public static string ZDICT_getErrorName(nuint errorCode) + { + return ERR_getErrorName(errorCode); + } + + private static void ZDICT_countEStats( + EStats_ress_t esr, + ZSTD_parameters* @params, + uint* countLit, + uint* offsetcodeCount, + uint* matchlengthCount, + uint* litlengthCount, + uint* repOffsets, + void* src, + nuint srcSize, + uint notificationLevel + ) + { + nuint blockSizeMax = (nuint)( + 1 << 17 < 1 << (int)@params->cParams.windowLog + ? 1 << 17 + : 1 << (int)@params->cParams.windowLog + ); + nuint cSize; + if (srcSize > blockSizeMax) + srcSize = blockSizeMax; + { + nuint errorCode = ZSTD_compressBegin_usingCDict_deprecated(esr.zc, esr.dict); + if (ERR_isError(errorCode)) + { + return; + } + } + + cSize = ZSTD_compressBlock_deprecated(esr.zc, esr.workPlace, 1 << 17, src, srcSize); + if (ERR_isError(cSize)) + { + return; + } + + if (cSize != 0) + { + SeqStore_t* seqStorePtr = ZSTD_getSeqStore(esr.zc); + { + byte* bytePtr; + for (bytePtr = seqStorePtr->litStart; bytePtr < seqStorePtr->lit; bytePtr++) + countLit[*bytePtr]++; + } + + { + uint nbSeq = (uint)(seqStorePtr->sequences - seqStorePtr->sequencesStart); + ZSTD_seqToCodes(seqStorePtr); + { + byte* codePtr = seqStorePtr->ofCode; + uint u; + for (u = 0; u < nbSeq; u++) + offsetcodeCount[codePtr[u]]++; + } + + { + byte* codePtr = seqStorePtr->mlCode; + uint u; + for (u = 0; u < nbSeq; u++) + matchlengthCount[codePtr[u]]++; + } + + { + byte* codePtr = seqStorePtr->llCode; + uint u; + for (u = 0; u < nbSeq; u++) + litlengthCount[codePtr[u]]++; + } + + if (nbSeq >= 2) + { + SeqDef_s* seq = seqStorePtr->sequencesStart; + uint offset1 = seq[0].offBase - 3; + uint offset2 = seq[1].offBase - 3; + if (offset1 >= 1024) + offset1 = 0; + if (offset2 >= 1024) + offset2 = 0; + repOffsets[offset1] += 3; + repOffsets[offset2] += 1; + } + } + } + } + + private static nuint ZDICT_totalSampleSize(nuint* fileSizes, uint nbFiles) + { + nuint total = 0; + uint u; + for (u = 0; u < nbFiles; u++) + total += fileSizes[u]; + return total; + } + + private static void ZDICT_insertSortCount(offsetCount_t* table, uint val, uint count) + { + uint u; + table[3].offset = val; + table[3].count = count; + for (u = 3; u > 0; u--) + { + offsetCount_t tmp; + if (table[u - 1].count >= table[u].count) + break; + tmp = table[u - 1]; + table[u - 1] = table[u]; + table[u] = tmp; + } + } + + /* ZDICT_flatLit() : + * rewrite `countLit` to contain a mostly flat but still compressible distribution of literals. + * necessary to avoid generating a non-compressible distribution that HUF_writeCTable() cannot encode. + */ + private static void ZDICT_flatLit(uint* countLit) + { + int u; + for (u = 1; u < 256; u++) + countLit[u] = 2; + countLit[0] = 4; + countLit[253] = 1; + countLit[254] = 1; + } + + private static nuint ZDICT_analyzeEntropy( + void* dstBuffer, + nuint maxDstSize, + int compressionLevel, + void* srcBuffer, + nuint* fileSizes, + uint nbFiles, + void* dictBuffer, + nuint dictBufferSize, + uint notificationLevel + ) + { + uint* countLit = stackalloc uint[256]; + /* no final ; */ + nuint* hufTable = stackalloc nuint[257]; + uint* offcodeCount = stackalloc uint[31]; + short* offcodeNCount = stackalloc short[31]; + uint offcodeMax = ZSTD_highbit32((uint)(dictBufferSize + 128 * (1 << 10))); + uint* matchLengthCount = stackalloc uint[53]; + short* matchLengthNCount = stackalloc short[53]; + uint* litLengthCount = stackalloc uint[36]; + short* litLengthNCount = stackalloc short[36]; + uint* repOffset = stackalloc uint[1024]; + offsetCount_t* bestRepOffset = stackalloc offsetCount_t[4]; + EStats_ress_t esr = new EStats_ress_t + { + dict = null, + zc = null, + workPlace = null, + }; + ZSTD_parameters @params; + uint u, + huffLog = 11, + Offlog = 8, + mlLog = 9, + llLog = 9, + total; + nuint pos = 0, + errorCode; + nuint eSize = 0; + nuint totalSrcSize = ZDICT_totalSampleSize(fileSizes, nbFiles); + nuint averageSampleSize = totalSrcSize / (nbFiles + (uint)(nbFiles == 0 ? 1 : 0)); + byte* dstPtr = (byte*)dstBuffer; + uint* wksp = stackalloc uint[1216]; + if (offcodeMax > 30) + { + eSize = unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionaryCreation_failed)); + goto _cleanup; + } + + for (u = 0; u < 256; u++) + countLit[u] = 1; + for (u = 0; u <= offcodeMax; u++) + offcodeCount[u] = 1; + for (u = 0; u <= 52; u++) + matchLengthCount[u] = 1; + for (u = 0; u <= 35; u++) + litLengthCount[u] = 1; + memset(repOffset, 0, sizeof(uint) * 1024); + repOffset[1] = repOffset[4] = repOffset[8] = 1; + memset(bestRepOffset, 0, (uint)(sizeof(offsetCount_t) * 4)); + if (compressionLevel == 0) + compressionLevel = 3; + @params = ZSTD_getParams(compressionLevel, averageSampleSize, dictBufferSize); + esr.dict = ZSTD_createCDict_advanced( + dictBuffer, + dictBufferSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef, + ZSTD_dictContentType_e.ZSTD_dct_rawContent, + @params.cParams, + ZSTD_defaultCMem + ); + esr.zc = ZSTD_createCCtx(); + esr.workPlace = malloc(1 << 17); + if (esr.dict == null || esr.zc == null || esr.workPlace == null) + { + eSize = unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + goto _cleanup; + } + + for (u = 0; u < nbFiles; u++) + { + ZDICT_countEStats( + esr, + &@params, + countLit, + offcodeCount, + matchLengthCount, + litLengthCount, + repOffset, + (sbyte*)srcBuffer + pos, + fileSizes[u], + notificationLevel + ); + pos += fileSizes[u]; + } + + if (notificationLevel >= 4) + { + for (u = 0; u <= offcodeMax; u++) { } + } + + { + nuint maxNbBits = HUF_buildCTable_wksp( + hufTable, + countLit, + 255, + huffLog, + wksp, + sizeof(uint) * 1216 + ); + if (ERR_isError(maxNbBits)) + { + eSize = maxNbBits; + goto _cleanup; + } + + if (maxNbBits == 8) + { + ZDICT_flatLit(countLit); + maxNbBits = HUF_buildCTable_wksp( + hufTable, + countLit, + 255, + huffLog, + wksp, + sizeof(uint) * 1216 + ); + assert(maxNbBits == 9); + } + + huffLog = (uint)maxNbBits; + } + + { + uint offset; + for (offset = 1; offset < 1024; offset++) + ZDICT_insertSortCount(bestRepOffset, offset, repOffset[offset]); + } + + total = 0; + for (u = 0; u <= offcodeMax; u++) + total += offcodeCount[u]; + errorCode = FSE_normalizeCount(offcodeNCount, Offlog, offcodeCount, total, offcodeMax, 1); + if (ERR_isError(errorCode)) + { + eSize = errorCode; + goto _cleanup; + } + + Offlog = (uint)errorCode; + total = 0; + for (u = 0; u <= 52; u++) + total += matchLengthCount[u]; + errorCode = FSE_normalizeCount(matchLengthNCount, mlLog, matchLengthCount, total, 52, 1); + if (ERR_isError(errorCode)) + { + eSize = errorCode; + goto _cleanup; + } + + mlLog = (uint)errorCode; + total = 0; + for (u = 0; u <= 35; u++) + total += litLengthCount[u]; + errorCode = FSE_normalizeCount(litLengthNCount, llLog, litLengthCount, total, 35, 1); + if (ERR_isError(errorCode)) + { + eSize = errorCode; + goto _cleanup; + } + + llLog = (uint)errorCode; + { + nuint hhSize = HUF_writeCTable_wksp( + dstPtr, + maxDstSize, + hufTable, + 255, + huffLog, + wksp, + sizeof(uint) * 1216 + ); + if (ERR_isError(hhSize)) + { + eSize = hhSize; + goto _cleanup; + } + + dstPtr += hhSize; + maxDstSize -= hhSize; + eSize += hhSize; + } + + { + nuint ohSize = FSE_writeNCount(dstPtr, maxDstSize, offcodeNCount, 30, Offlog); + if (ERR_isError(ohSize)) + { + eSize = ohSize; + goto _cleanup; + } + + dstPtr += ohSize; + maxDstSize -= ohSize; + eSize += ohSize; + } + + { + nuint mhSize = FSE_writeNCount(dstPtr, maxDstSize, matchLengthNCount, 52, mlLog); + if (ERR_isError(mhSize)) + { + eSize = mhSize; + goto _cleanup; + } + + dstPtr += mhSize; + maxDstSize -= mhSize; + eSize += mhSize; + } + + { + nuint lhSize = FSE_writeNCount(dstPtr, maxDstSize, litLengthNCount, 35, llLog); + if (ERR_isError(lhSize)) + { + eSize = lhSize; + goto _cleanup; + } + + dstPtr += lhSize; + maxDstSize -= lhSize; + eSize += lhSize; + } + + if (maxDstSize < 12) + { + eSize = unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + goto _cleanup; + } + + MEM_writeLE32(dstPtr + 0, repStartValue[0]); + MEM_writeLE32(dstPtr + 4, repStartValue[1]); + MEM_writeLE32(dstPtr + 8, repStartValue[2]); + eSize += 12; + _cleanup: + ZSTD_freeCDict(esr.dict); + ZSTD_freeCCtx(esr.zc); + free(esr.workPlace); + return eSize; + } + + /** + * @returns the maximum repcode value + */ + private static uint ZDICT_maxRep(uint* reps) + { + uint maxRep = reps[0]; + int r; + for (r = 1; r < 3; ++r) + maxRep = maxRep > reps[r] ? maxRep : reps[r]; + return maxRep; + } + + /*! ZDICT_finalizeDictionary(): + * Given a custom content as a basis for dictionary, and a set of samples, + * finalize dictionary by adding headers and statistics according to the zstd + * dictionary format. + * + * Samples must be stored concatenated in a flat buffer `samplesBuffer`, + * supplied with an array of sizes `samplesSizes`, providing the size of each + * sample in order. The samples are used to construct the statistics, so they + * should be representative of what you will compress with this dictionary. + * + * The compression level can be set in `parameters`. You should pass the + * compression level you expect to use in production. The statistics for each + * compression level differ, so tuning the dictionary for the compression level + * can help quite a bit. + * + * You can set an explicit dictionary ID in `parameters`, or allow us to pick + * a random dictionary ID for you, but we can't guarantee no collisions. + * + * The dstDictBuffer and the dictContent may overlap, and the content will be + * appended to the end of the header. If the header + the content doesn't fit in + * maxDictSize the beginning of the content is truncated to make room, since it + * is presumed that the most profitable content is at the end of the dictionary, + * since that is the cheapest to reference. + * + * `maxDictSize` must be >= max(dictContentSize, ZDICT_DICTSIZE_MIN). + * + * @return: size of dictionary stored into `dstDictBuffer` (<= `maxDictSize`), + * or an error code, which can be tested by ZDICT_isError(). + * Note: ZDICT_finalizeDictionary() will push notifications into stderr if + * instructed to, using notificationLevel>0. + * NOTE: This function currently may fail in several edge cases including: + * * Not enough samples + * * Samples are uncompressible + * * Samples are all exactly the same + */ + public static nuint ZDICT_finalizeDictionary( + void* dictBuffer, + nuint dictBufferCapacity, + void* customDictContent, + nuint dictContentSize, + void* samplesBuffer, + nuint* samplesSizes, + uint nbSamples, + ZDICT_params_t @params + ) + { + nuint hSize; + byte* header = stackalloc byte[256]; + int compressionLevel = @params.compressionLevel == 0 ? 3 : @params.compressionLevel; + uint notificationLevel = @params.notificationLevel; + /* The final dictionary content must be at least as large as the largest repcode */ + nuint minContentSize = ZDICT_maxRep(repStartValue); + nuint paddingSize; + if (dictBufferCapacity < dictContentSize) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + if (dictBufferCapacity < 256) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + MEM_writeLE32(header, 0xEC30A437); + { + ulong randomID = ZSTD_XXH64(customDictContent, dictContentSize, 0); + uint compliantID = (uint)(randomID % ((1U << 31) - 32768) + 32768); + uint dictID = @params.dictID != 0 ? @params.dictID : compliantID; + MEM_writeLE32(header + 4, dictID); + } + + hSize = 8; + { + nuint eSize = ZDICT_analyzeEntropy( + header + hSize, + 256 - hSize, + compressionLevel, + samplesBuffer, + samplesSizes, + nbSamples, + customDictContent, + dictContentSize, + notificationLevel + ); + if (ZDICT_isError(eSize)) + return eSize; + hSize += eSize; + } + + if (hSize + dictContentSize > dictBufferCapacity) + { + dictContentSize = dictBufferCapacity - hSize; + } + + if (dictContentSize < minContentSize) + { + if (hSize + minContentSize > dictBufferCapacity) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + paddingSize = minContentSize - dictContentSize; + } + else + { + paddingSize = 0; + } + + { + nuint dictSize = hSize + paddingSize + dictContentSize; + /* The dictionary consists of the header, optional padding, and the content. + * The padding comes before the content because the "best" position in the + * dictionary is the last byte. + */ + byte* outDictHeader = (byte*)dictBuffer; + byte* outDictPadding = outDictHeader + hSize; + byte* outDictContent = outDictPadding + paddingSize; + assert(dictSize <= dictBufferCapacity); + assert(outDictContent + dictContentSize == (byte*)dictBuffer + dictSize); + memmove(outDictContent, customDictContent, dictContentSize); + memcpy(outDictHeader, header, (uint)hSize); + memset(outDictPadding, 0, (uint)paddingSize); + return dictSize; + } + } + + private static nuint ZDICT_addEntropyTablesFromBuffer_advanced( + void* dictBuffer, + nuint dictContentSize, + nuint dictBufferCapacity, + void* samplesBuffer, + nuint* samplesSizes, + uint nbSamples, + ZDICT_params_t @params + ) + { + int compressionLevel = @params.compressionLevel == 0 ? 3 : @params.compressionLevel; + uint notificationLevel = @params.notificationLevel; + nuint hSize = 8; + { + nuint eSize = ZDICT_analyzeEntropy( + (sbyte*)dictBuffer + hSize, + dictBufferCapacity - hSize, + compressionLevel, + samplesBuffer, + samplesSizes, + nbSamples, + (sbyte*)dictBuffer + dictBufferCapacity - dictContentSize, + dictContentSize, + notificationLevel + ); + if (ZDICT_isError(eSize)) + return eSize; + hSize += eSize; + } + + MEM_writeLE32(dictBuffer, 0xEC30A437); + { + ulong randomID = ZSTD_XXH64( + (sbyte*)dictBuffer + dictBufferCapacity - dictContentSize, + dictContentSize, + 0 + ); + uint compliantID = (uint)(randomID % ((1U << 31) - 32768) + 32768); + uint dictID = @params.dictID != 0 ? @params.dictID : compliantID; + MEM_writeLE32((sbyte*)dictBuffer + 4, dictID); + } + + if (hSize + dictContentSize < dictBufferCapacity) + memmove( + (sbyte*)dictBuffer + hSize, + (sbyte*)dictBuffer + dictBufferCapacity - dictContentSize, + dictContentSize + ); + return dictBufferCapacity < hSize + dictContentSize + ? dictBufferCapacity + : hSize + dictContentSize; + } + + /*! ZDICT_trainFromBuffer(): + * Train a dictionary from an array of samples. + * Redirect towards ZDICT_optimizeTrainFromBuffer_fastCover() single-threaded, with d=8, steps=4, + * f=20, and accel=1. + * Samples must be stored concatenated in a single flat buffer `samplesBuffer`, + * supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order. + * The resulting dictionary will be saved into `dictBuffer`. + * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) + * or an error code, which can be tested with ZDICT_isError(). + * Note: Dictionary training will fail if there are not enough samples to construct a + * dictionary, or if most of the samples are too small (< 8 bytes being the lower limit). + * If dictionary training fails, you should use zstd without a dictionary, as the dictionary + * would've been ineffective anyways. If you believe your samples would benefit from a dictionary + * please open an issue with details, and we can look into it. + * Note: ZDICT_trainFromBuffer()'s memory usage is about 6 MB. + * Tips: In general, a reasonable dictionary has a size of ~ 100 KB. + * It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`. + * In general, it's recommended to provide a few thousands samples, though this can vary a lot. + * It's recommended that total size of all samples be about ~x100 times the target size of dictionary. + */ + public static nuint ZDICT_trainFromBuffer( + void* dictBuffer, + nuint dictBufferCapacity, + void* samplesBuffer, + nuint* samplesSizes, + uint nbSamples + ) + { + ZDICT_fastCover_params_t @params; + @params = new ZDICT_fastCover_params_t { d = 8, steps = 4 }; + @params.zParams.compressionLevel = 3; + return ZDICT_optimizeTrainFromBuffer_fastCover( + dictBuffer, + dictBufferCapacity, + samplesBuffer, + samplesSizes, + nbSamples, + &@params + ); + } + + public static nuint ZDICT_addEntropyTablesFromBuffer( + void* dictBuffer, + nuint dictContentSize, + nuint dictBufferCapacity, + void* samplesBuffer, + nuint* samplesSizes, + uint nbSamples + ) + { + ZDICT_params_t @params; + @params = new ZDICT_params_t(); + return ZDICT_addEntropyTablesFromBuffer_advanced( + dictBuffer, + dictContentSize, + dictBufferCapacity, + samplesBuffer, + samplesSizes, + nbSamples, + @params + ); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/Zstd.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/Zstd.cs new file mode 100644 index 000000000..ce1018b0d --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/Zstd.cs @@ -0,0 +1,10 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + private static readonly ZSTD_customMem ZSTD_defaultCMem = new ZSTD_customMem( + customAlloc: null, + customFree: null, + opaque: null + ); +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCommon.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCommon.cs new file mode 100644 index 000000000..629a435c6 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCommon.cs @@ -0,0 +1,48 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /*-**************************************** + * Version + ******************************************/ + public static uint ZSTD_versionNumber() + { + return 1 * 100 * 100 + 5 * 100 + 7; + } + + /*! ZSTD_versionString() : + * Return runtime library version, like "1.4.5". Requires v1.3.0+. */ + public static string ZSTD_versionString() + { + return "1.5.7"; + } + + /*! ZSTD_isError() : + * tells if a return value is an error code + * symbol is required for external callers */ + public static bool ZSTD_isError(nuint code) + { + return ERR_isError(code); + } + + /*! ZSTD_getErrorName() : + * provides error code string from function result (useful for debugging) */ + public static string ZSTD_getErrorName(nuint code) + { + return ERR_getErrorName(code); + } + + /*! ZSTD_getError() : + * convert a `size_t` function result into a proper ZSTD_errorCode enum */ + public static ZSTD_ErrorCode ZSTD_getErrorCode(nuint code) + { + return ERR_getErrorCode(code); + } + + /*! ZSTD_getErrorString() : + * provides error code string from enum */ + public static string ZSTD_getErrorString(ZSTD_ErrorCode code) + { + return ERR_getErrorString(code); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompress.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompress.cs new file mode 100644 index 000000000..8198034b7 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompress.cs @@ -0,0 +1,11225 @@ +using System; +using System.Diagnostics; +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /*-************************************* + * Helper functions + ***************************************/ + /* ZSTD_compressBound() + * Note that the result from this function is only valid for + * the one-pass compression functions. + * When employing the streaming mode, + * if flushes are frequently altering the size of blocks, + * the overhead from block headers can make the compressed data larger + * than the return value of ZSTD_compressBound(). + */ + public static nuint ZSTD_compressBound(nuint srcSize) + { + nuint r = + srcSize >= (sizeof(nuint) == 8 ? 0xFF00FF00FF00FF00UL : 0xFF00FF00U) + ? 0 + : srcSize + + (srcSize >> 8) + + (srcSize < 128 << 10 ? (128 << 10) - srcSize >> 11 : 0); + if (r == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + return r; + } + + public static ZSTD_CCtx_s* ZSTD_createCCtx() + { + return ZSTD_createCCtx_advanced(ZSTD_defaultCMem); + } + + private static void ZSTD_initCCtx(ZSTD_CCtx_s* cctx, ZSTD_customMem memManager) + { + assert(cctx != null); + *cctx = new ZSTD_CCtx_s { customMem = memManager, bmi2 = 0 }; + { + nuint err = ZSTD_CCtx_reset(cctx, ZSTD_ResetDirective.ZSTD_reset_parameters); + assert(!ERR_isError(err)); + } + } + + public static ZSTD_CCtx_s* ZSTD_createCCtx_advanced(ZSTD_customMem customMem) + { + if (((customMem.customAlloc == null ? 1 : 0) ^ (customMem.customFree == null ? 1 : 0)) != 0) + return null; + { + ZSTD_CCtx_s* cctx = (ZSTD_CCtx_s*)ZSTD_customMalloc( + (nuint)sizeof(ZSTD_CCtx_s), + customMem + ); + if (cctx == null) + return null; + ZSTD_initCCtx(cctx, customMem); + return cctx; + } + } + + /*! ZSTD_initStatic*() : + * Initialize an object using a pre-allocated fixed-size buffer. + * workspace: The memory area to emplace the object into. + * Provided pointer *must be 8-bytes aligned*. + * Buffer must outlive object. + * workspaceSize: Use ZSTD_estimate*Size() to determine + * how large workspace must be to support target scenario. + * @return : pointer to object (same address as workspace, just different type), + * or NULL if error (size too small, incorrect alignment, etc.) + * Note : zstd will never resize nor malloc() when using a static buffer. + * If the object requires more memory than available, + * zstd will just error out (typically ZSTD_error_memory_allocation). + * Note 2 : there is no corresponding "free" function. + * Since workspace is allocated externally, it must be freed externally too. + * Note 3 : cParams : use ZSTD_getCParams() to convert a compression level + * into its associated cParams. + * Limitation 1 : currently not compatible with internal dictionary creation, triggered by + * ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict(). + * Limitation 2 : static cctx currently not compatible with multi-threading. + * Limitation 3 : static dctx is incompatible with legacy support. + */ + public static ZSTD_CCtx_s* ZSTD_initStaticCCtx(void* workspace, nuint workspaceSize) + { + ZSTD_cwksp ws; + ZSTD_CCtx_s* cctx; + if (workspaceSize <= (nuint)sizeof(ZSTD_CCtx_s)) + return null; + if (((nuint)workspace & 7) != 0) + return null; + ZSTD_cwksp_init( + &ws, + workspace, + workspaceSize, + ZSTD_cwksp_static_alloc_e.ZSTD_cwksp_static_alloc + ); + cctx = (ZSTD_CCtx_s*)ZSTD_cwksp_reserve_object(&ws, (nuint)sizeof(ZSTD_CCtx_s)); + if (cctx == null) + return null; + *cctx = new ZSTD_CCtx_s(); + ZSTD_cwksp_move(&cctx->workspace, &ws); + cctx->staticSize = workspaceSize; + if ( + ZSTD_cwksp_check_available( + &cctx->workspace, + (nuint)( + ( + (8 << 10) + 512 + sizeof(uint) * (52 + 2) > 8208 + ? (8 << 10) + 512 + sizeof(uint) * (52 + 2) + : 8208 + ) + + 2 * sizeof(ZSTD_compressedBlockState_t) + ) + ) == 0 + ) + return null; + cctx->blockState.prevCBlock = (ZSTD_compressedBlockState_t*)ZSTD_cwksp_reserve_object( + &cctx->workspace, + (nuint)sizeof(ZSTD_compressedBlockState_t) + ); + cctx->blockState.nextCBlock = (ZSTD_compressedBlockState_t*)ZSTD_cwksp_reserve_object( + &cctx->workspace, + (nuint)sizeof(ZSTD_compressedBlockState_t) + ); + cctx->tmpWorkspace = ZSTD_cwksp_reserve_object( + &cctx->workspace, + (8 << 10) + 512 + sizeof(uint) * (52 + 2) > 8208 + ? (8 << 10) + 512 + sizeof(uint) * (52 + 2) + : 8208 + ); + cctx->tmpWkspSize = + (8 << 10) + 512 + sizeof(uint) * (52 + 2) > 8208 + ? (8 << 10) + 512 + sizeof(uint) * (52 + 2) + : 8208; + cctx->bmi2 = 0; + return cctx; + } + + /** + * Clears and frees all of the dictionaries in the CCtx. + */ + private static void ZSTD_clearAllDicts(ZSTD_CCtx_s* cctx) + { + ZSTD_customFree(cctx->localDict.dictBuffer, cctx->customMem); + ZSTD_freeCDict(cctx->localDict.cdict); + cctx->localDict = new ZSTD_localDict(); + cctx->prefixDict = new ZSTD_prefixDict_s(); + cctx->cdict = null; + } + + private static nuint ZSTD_sizeof_localDict(ZSTD_localDict dict) + { + nuint bufferSize = dict.dictBuffer != null ? dict.dictSize : 0; + nuint cdictSize = ZSTD_sizeof_CDict(dict.cdict); + return bufferSize + cdictSize; + } + + private static void ZSTD_freeCCtxContent(ZSTD_CCtx_s* cctx) + { + assert(cctx != null); + assert(cctx->staticSize == 0); + ZSTD_clearAllDicts(cctx); + ZSTDMT_freeCCtx(cctx->mtctx); + cctx->mtctx = null; + ZSTD_cwksp_free(&cctx->workspace, cctx->customMem); + } + + public static nuint ZSTD_freeCCtx(ZSTD_CCtx_s* cctx) + { + if (cctx == null) + return 0; + if (cctx->staticSize != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + { + int cctxInWorkspace = ZSTD_cwksp_owns_buffer(&cctx->workspace, cctx); + ZSTD_freeCCtxContent(cctx); + if (cctxInWorkspace == 0) + ZSTD_customFree(cctx, cctx->customMem); + } + + return 0; + } + + private static nuint ZSTD_sizeof_mtctx(ZSTD_CCtx_s* cctx) + { + return ZSTDMT_sizeof_CCtx(cctx->mtctx); + } + + /*! ZSTD_sizeof_*() : Requires v1.4.0+ + * These functions give the _current_ memory usage of selected object. + * Note that object memory usage can evolve (increase or decrease) over time. */ + public static nuint ZSTD_sizeof_CCtx(ZSTD_CCtx_s* cctx) + { + if (cctx == null) + return 0; + return (nuint)(cctx->workspace.workspace == cctx ? 0 : sizeof(ZSTD_CCtx_s)) + + ZSTD_cwksp_sizeof(&cctx->workspace) + + ZSTD_sizeof_localDict(cctx->localDict) + + ZSTD_sizeof_mtctx(cctx); + } + + public static nuint ZSTD_sizeof_CStream(ZSTD_CCtx_s* zcs) + { + return ZSTD_sizeof_CCtx(zcs); + } + + /* private API call, for dictBuilder only */ + private static SeqStore_t* ZSTD_getSeqStore(ZSTD_CCtx_s* ctx) + { + return &ctx->seqStore; + } + + /* Returns true if the strategy supports using a row based matchfinder */ + private static int ZSTD_rowMatchFinderSupported(ZSTD_strategy strategy) + { + return strategy >= ZSTD_strategy.ZSTD_greedy && strategy <= ZSTD_strategy.ZSTD_lazy2 + ? 1 + : 0; + } + + /* Returns true if the strategy and useRowMatchFinder mode indicate that we will use the row based matchfinder + * for this compression. + */ + private static int ZSTD_rowMatchFinderUsed(ZSTD_strategy strategy, ZSTD_paramSwitch_e mode) + { + assert(mode != ZSTD_paramSwitch_e.ZSTD_ps_auto); + return + ZSTD_rowMatchFinderSupported(strategy) != 0 && mode == ZSTD_paramSwitch_e.ZSTD_ps_enable + ? 1 + : 0; + } + + /* Returns row matchfinder usage given an initial mode and cParams */ + private static ZSTD_paramSwitch_e ZSTD_resolveRowMatchFinderMode( + ZSTD_paramSwitch_e mode, + ZSTD_compressionParameters* cParams + ) + { + if (mode != ZSTD_paramSwitch_e.ZSTD_ps_auto) + return mode; + mode = ZSTD_paramSwitch_e.ZSTD_ps_disable; + if (ZSTD_rowMatchFinderSupported(cParams->strategy) == 0) + return mode; + if (cParams->windowLog > 14) + mode = ZSTD_paramSwitch_e.ZSTD_ps_enable; + return mode; + } + + /* Returns block splitter usage (generally speaking, when using slower/stronger compression modes) */ + private static ZSTD_paramSwitch_e ZSTD_resolveBlockSplitterMode( + ZSTD_paramSwitch_e mode, + ZSTD_compressionParameters* cParams + ) + { + if (mode != ZSTD_paramSwitch_e.ZSTD_ps_auto) + return mode; + return cParams->strategy >= ZSTD_strategy.ZSTD_btopt && cParams->windowLog >= 17 + ? ZSTD_paramSwitch_e.ZSTD_ps_enable + : ZSTD_paramSwitch_e.ZSTD_ps_disable; + } + + /* Returns 1 if the arguments indicate that we should allocate a chainTable, 0 otherwise */ + private static int ZSTD_allocateChainTable( + ZSTD_strategy strategy, + ZSTD_paramSwitch_e useRowMatchFinder, + uint forDDSDict + ) + { + assert(useRowMatchFinder != ZSTD_paramSwitch_e.ZSTD_ps_auto); + return + forDDSDict != 0 + || strategy != ZSTD_strategy.ZSTD_fast + && ZSTD_rowMatchFinderUsed(strategy, useRowMatchFinder) == 0 + ? 1 + : 0; + } + + /* Returns ZSTD_ps_enable if compression parameters are such that we should + * enable long distance matching (wlog >= 27, strategy >= btopt). + * Returns ZSTD_ps_disable otherwise. + */ + private static ZSTD_paramSwitch_e ZSTD_resolveEnableLdm( + ZSTD_paramSwitch_e mode, + ZSTD_compressionParameters* cParams + ) + { + if (mode != ZSTD_paramSwitch_e.ZSTD_ps_auto) + return mode; + return cParams->strategy >= ZSTD_strategy.ZSTD_btopt && cParams->windowLog >= 27 + ? ZSTD_paramSwitch_e.ZSTD_ps_enable + : ZSTD_paramSwitch_e.ZSTD_ps_disable; + } + + private static int ZSTD_resolveExternalSequenceValidation(int mode) + { + return mode; + } + + /* Resolves maxBlockSize to the default if no value is present. */ + private static nuint ZSTD_resolveMaxBlockSize(nuint maxBlockSize) + { + if (maxBlockSize == 0) + { + return 1 << 17; + } + else + { + return maxBlockSize; + } + } + + private static ZSTD_paramSwitch_e ZSTD_resolveExternalRepcodeSearch( + ZSTD_paramSwitch_e value, + int cLevel + ) + { + if (value != ZSTD_paramSwitch_e.ZSTD_ps_auto) + return value; + if (cLevel < 10) + { + return ZSTD_paramSwitch_e.ZSTD_ps_disable; + } + else + { + return ZSTD_paramSwitch_e.ZSTD_ps_enable; + } + } + + /* Returns 1 if compression parameters are such that CDict hashtable and chaintable indices are tagged. + * If so, the tags need to be removed in ZSTD_resetCCtx_byCopyingCDict. */ + private static int ZSTD_CDictIndicesAreTagged(ZSTD_compressionParameters* cParams) + { + return + cParams->strategy == ZSTD_strategy.ZSTD_fast + || cParams->strategy == ZSTD_strategy.ZSTD_dfast + ? 1 + : 0; + } + + private static ZSTD_CCtx_params_s ZSTD_makeCCtxParamsFromCParams( + ZSTD_compressionParameters cParams + ) + { + ZSTD_CCtx_params_s cctxParams; + ZSTD_CCtxParams_init(&cctxParams, 3); + cctxParams.cParams = cParams; + cctxParams.ldmParams.enableLdm = ZSTD_resolveEnableLdm( + cctxParams.ldmParams.enableLdm, + &cParams + ); + if (cctxParams.ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable) + { + ZSTD_ldm_adjustParameters(&cctxParams.ldmParams, &cParams); + assert(cctxParams.ldmParams.hashLog >= cctxParams.ldmParams.bucketSizeLog); + assert(cctxParams.ldmParams.hashRateLog < 32); + } + + cctxParams.postBlockSplitter = ZSTD_resolveBlockSplitterMode( + cctxParams.postBlockSplitter, + &cParams + ); + cctxParams.useRowMatchFinder = ZSTD_resolveRowMatchFinderMode( + cctxParams.useRowMatchFinder, + &cParams + ); + cctxParams.validateSequences = ZSTD_resolveExternalSequenceValidation( + cctxParams.validateSequences + ); + cctxParams.maxBlockSize = ZSTD_resolveMaxBlockSize(cctxParams.maxBlockSize); + cctxParams.searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch( + cctxParams.searchForExternalRepcodes, + cctxParams.compressionLevel + ); + assert(ZSTD_checkCParams(cParams) == 0); + return cctxParams; + } + + private static ZSTD_CCtx_params_s* ZSTD_createCCtxParams_advanced(ZSTD_customMem customMem) + { + ZSTD_CCtx_params_s* @params; + if (((customMem.customAlloc == null ? 1 : 0) ^ (customMem.customFree == null ? 1 : 0)) != 0) + return null; + @params = (ZSTD_CCtx_params_s*)ZSTD_customCalloc( + (nuint)sizeof(ZSTD_CCtx_params_s), + customMem + ); + if (@params == null) + { + return null; + } + + ZSTD_CCtxParams_init(@params, 3); + @params->customMem = customMem; + return @params; + } + + /*! ZSTD_CCtx_params : + * Quick howto : + * - ZSTD_createCCtxParams() : Create a ZSTD_CCtx_params structure + * - ZSTD_CCtxParams_setParameter() : Push parameters one by one into + * an existing ZSTD_CCtx_params structure. + * This is similar to + * ZSTD_CCtx_setParameter(). + * - ZSTD_CCtx_setParametersUsingCCtxParams() : Apply parameters to + * an existing CCtx. + * These parameters will be applied to + * all subsequent frames. + * - ZSTD_compressStream2() : Do compression using the CCtx. + * - ZSTD_freeCCtxParams() : Free the memory, accept NULL pointer. + * + * This can be used with ZSTD_estimateCCtxSize_advanced_usingCCtxParams() + * for static allocation of CCtx for single-threaded compression. + */ + public static ZSTD_CCtx_params_s* ZSTD_createCCtxParams() + { + return ZSTD_createCCtxParams_advanced(ZSTD_defaultCMem); + } + + public static nuint ZSTD_freeCCtxParams(ZSTD_CCtx_params_s* @params) + { + if (@params == null) + { + return 0; + } + + ZSTD_customFree(@params, @params->customMem); + return 0; + } + + /*! ZSTD_CCtxParams_reset() : + * Reset params to default values. + */ + public static nuint ZSTD_CCtxParams_reset(ZSTD_CCtx_params_s* @params) + { + return ZSTD_CCtxParams_init(@params, 3); + } + + /*! ZSTD_CCtxParams_init() : + * Initializes the compression parameters of cctxParams according to + * compression level. All other parameters are reset to their default values. + */ + public static nuint ZSTD_CCtxParams_init(ZSTD_CCtx_params_s* cctxParams, int compressionLevel) + { + if (cctxParams == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + + *cctxParams = new ZSTD_CCtx_params_s { compressionLevel = compressionLevel }; + cctxParams->fParams.contentSizeFlag = 1; + return 0; + } + + /** + * Initializes `cctxParams` from `params` and `compressionLevel`. + * @param compressionLevel If params are derived from a compression level then that compression level, otherwise ZSTD_NO_CLEVEL. + */ + private static void ZSTD_CCtxParams_init_internal( + ZSTD_CCtx_params_s* cctxParams, + ZSTD_parameters* @params, + int compressionLevel + ) + { + assert(ZSTD_checkCParams(@params->cParams) == 0); + *cctxParams = new ZSTD_CCtx_params_s + { + cParams = @params->cParams, + fParams = @params->fParams, + compressionLevel = compressionLevel, + useRowMatchFinder = ZSTD_resolveRowMatchFinderMode( + cctxParams->useRowMatchFinder, + &@params->cParams + ), + postBlockSplitter = ZSTD_resolveBlockSplitterMode( + cctxParams->postBlockSplitter, + &@params->cParams + ), + }; + cctxParams->ldmParams.enableLdm = ZSTD_resolveEnableLdm( + cctxParams->ldmParams.enableLdm, + &@params->cParams + ); + cctxParams->validateSequences = ZSTD_resolveExternalSequenceValidation( + cctxParams->validateSequences + ); + cctxParams->maxBlockSize = ZSTD_resolveMaxBlockSize(cctxParams->maxBlockSize); + cctxParams->searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch( + cctxParams->searchForExternalRepcodes, + compressionLevel + ); + } + + /*! ZSTD_CCtxParams_init_advanced() : + * Initializes the compression and frame parameters of cctxParams according to + * params. All other parameters are reset to their default values. + */ + public static nuint ZSTD_CCtxParams_init_advanced( + ZSTD_CCtx_params_s* cctxParams, + ZSTD_parameters @params + ) + { + if (cctxParams == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + + { + nuint err_code = ZSTD_checkCParams(@params.cParams); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + ZSTD_CCtxParams_init_internal(cctxParams, &@params, 0); + return 0; + } + + /** + * Sets cctxParams' cParams and fParams from params, but otherwise leaves them alone. + * @param params Validated zstd parameters. + */ + private static void ZSTD_CCtxParams_setZstdParams( + ZSTD_CCtx_params_s* cctxParams, + ZSTD_parameters* @params + ) + { + assert(ZSTD_checkCParams(@params->cParams) == 0); + cctxParams->cParams = @params->cParams; + cctxParams->fParams = @params->fParams; + cctxParams->compressionLevel = 0; + } + + /*! ZSTD_cParam_getBounds() : + * All parameters must belong to an interval with lower and upper bounds, + * otherwise they will either trigger an error or be automatically clamped. + * @return : a structure, ZSTD_bounds, which contains + * - an error status field, which must be tested using ZSTD_isError() + * - lower and upper bounds, both inclusive + */ + public static ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param) + { + ZSTD_bounds bounds = new ZSTD_bounds + { + error = 0, + lowerBound = 0, + upperBound = 0, + }; + switch (param) + { + case ZSTD_cParameter.ZSTD_c_compressionLevel: + bounds.lowerBound = ZSTD_minCLevel(); + bounds.upperBound = ZSTD_maxCLevel(); + return bounds; + case ZSTD_cParameter.ZSTD_c_windowLog: + bounds.lowerBound = 10; + bounds.upperBound = sizeof(nuint) == 4 ? 30 : 31; + return bounds; + case ZSTD_cParameter.ZSTD_c_hashLog: + bounds.lowerBound = 6; + bounds.upperBound = + (sizeof(nuint) == 4 ? 30 : 31) < 30 + ? sizeof(nuint) == 4 + ? 30 + : 31 + : 30; + return bounds; + case ZSTD_cParameter.ZSTD_c_chainLog: + bounds.lowerBound = 6; + bounds.upperBound = sizeof(nuint) == 4 ? 29 : 30; + return bounds; + case ZSTD_cParameter.ZSTD_c_searchLog: + bounds.lowerBound = 1; + bounds.upperBound = (sizeof(nuint) == 4 ? 30 : 31) - 1; + return bounds; + case ZSTD_cParameter.ZSTD_c_minMatch: + bounds.lowerBound = 3; + bounds.upperBound = 7; + return bounds; + case ZSTD_cParameter.ZSTD_c_targetLength: + bounds.lowerBound = 0; + bounds.upperBound = 1 << 17; + return bounds; + case ZSTD_cParameter.ZSTD_c_strategy: + bounds.lowerBound = (int)ZSTD_strategy.ZSTD_fast; + bounds.upperBound = (int)ZSTD_strategy.ZSTD_btultra2; + return bounds; + case ZSTD_cParameter.ZSTD_c_contentSizeFlag: + bounds.lowerBound = 0; + bounds.upperBound = 1; + return bounds; + case ZSTD_cParameter.ZSTD_c_checksumFlag: + bounds.lowerBound = 0; + bounds.upperBound = 1; + return bounds; + case ZSTD_cParameter.ZSTD_c_dictIDFlag: + bounds.lowerBound = 0; + bounds.upperBound = 1; + return bounds; + case ZSTD_cParameter.ZSTD_c_nbWorkers: + bounds.lowerBound = 0; + bounds.upperBound = sizeof(void*) == 4 ? 64 : 256; + return bounds; + case ZSTD_cParameter.ZSTD_c_jobSize: + bounds.lowerBound = 0; + bounds.upperBound = MEM_32bits ? 512 * (1 << 20) : 1024 * (1 << 20); + return bounds; + case ZSTD_cParameter.ZSTD_c_overlapLog: + bounds.lowerBound = 0; + bounds.upperBound = 9; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam8: + bounds.lowerBound = 0; + bounds.upperBound = 1; + return bounds; + case ZSTD_cParameter.ZSTD_c_enableLongDistanceMatching: + bounds.lowerBound = (int)ZSTD_paramSwitch_e.ZSTD_ps_auto; + bounds.upperBound = (int)ZSTD_paramSwitch_e.ZSTD_ps_disable; + return bounds; + case ZSTD_cParameter.ZSTD_c_ldmHashLog: + bounds.lowerBound = 6; + bounds.upperBound = + (sizeof(nuint) == 4 ? 30 : 31) < 30 + ? sizeof(nuint) == 4 + ? 30 + : 31 + : 30; + return bounds; + case ZSTD_cParameter.ZSTD_c_ldmMinMatch: + bounds.lowerBound = 4; + bounds.upperBound = 4096; + return bounds; + case ZSTD_cParameter.ZSTD_c_ldmBucketSizeLog: + bounds.lowerBound = 1; + bounds.upperBound = 8; + return bounds; + case ZSTD_cParameter.ZSTD_c_ldmHashRateLog: + bounds.lowerBound = 0; + bounds.upperBound = (sizeof(nuint) == 4 ? 30 : 31) - 6; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam1: + bounds.lowerBound = 0; + bounds.upperBound = 1; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam3: + bounds.lowerBound = 0; + bounds.upperBound = 1; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam2: + bounds.lowerBound = (int)ZSTD_format_e.ZSTD_f_zstd1; + bounds.upperBound = (int)ZSTD_format_e.ZSTD_f_zstd1_magicless; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam4: + bounds.lowerBound = (int)ZSTD_dictAttachPref_e.ZSTD_dictDefaultAttach; + bounds.upperBound = (int)ZSTD_dictAttachPref_e.ZSTD_dictForceLoad; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam5: + bounds.lowerBound = (int)ZSTD_paramSwitch_e.ZSTD_ps_auto; + bounds.upperBound = (int)ZSTD_paramSwitch_e.ZSTD_ps_disable; + return bounds; + case ZSTD_cParameter.ZSTD_c_targetCBlockSize: + bounds.lowerBound = 1340; + bounds.upperBound = 1 << 17; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam7: + bounds.lowerBound = 0; + bounds.upperBound = 2147483647; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam9: + case ZSTD_cParameter.ZSTD_c_experimentalParam10: + bounds.lowerBound = (int)ZSTD_bufferMode_e.ZSTD_bm_buffered; + bounds.upperBound = (int)ZSTD_bufferMode_e.ZSTD_bm_stable; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam11: + bounds.lowerBound = (int)ZSTD_sequenceFormat_e.ZSTD_sf_noBlockDelimiters; + bounds.upperBound = (int)ZSTD_sequenceFormat_e.ZSTD_sf_explicitBlockDelimiters; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam12: + bounds.lowerBound = 0; + bounds.upperBound = 1; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam13: + bounds.lowerBound = (int)ZSTD_paramSwitch_e.ZSTD_ps_auto; + bounds.upperBound = (int)ZSTD_paramSwitch_e.ZSTD_ps_disable; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam20: + bounds.lowerBound = 0; + bounds.upperBound = 6; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam14: + bounds.lowerBound = (int)ZSTD_paramSwitch_e.ZSTD_ps_auto; + bounds.upperBound = (int)ZSTD_paramSwitch_e.ZSTD_ps_disable; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam15: + bounds.lowerBound = 0; + bounds.upperBound = 1; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam16: + bounds.lowerBound = (int)ZSTD_paramSwitch_e.ZSTD_ps_auto; + bounds.upperBound = (int)ZSTD_paramSwitch_e.ZSTD_ps_disable; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam17: + bounds.lowerBound = 0; + bounds.upperBound = 1; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam18: + bounds.lowerBound = 1 << 10; + bounds.upperBound = 1 << 17; + return bounds; + case ZSTD_cParameter.ZSTD_c_experimentalParam19: + bounds.lowerBound = (int)ZSTD_paramSwitch_e.ZSTD_ps_auto; + bounds.upperBound = (int)ZSTD_paramSwitch_e.ZSTD_ps_disable; + return bounds; + default: + bounds.error = unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_unsupported) + ); + return bounds; + } + } + + /* ZSTD_cParam_clampBounds: + * Clamps the value into the bounded range. + */ + private static nuint ZSTD_cParam_clampBounds(ZSTD_cParameter cParam, int* value) + { + ZSTD_bounds bounds = ZSTD_cParam_getBounds(cParam); + if (ERR_isError(bounds.error)) + return bounds.error; + if (*value < bounds.lowerBound) + *value = bounds.lowerBound; + if (*value > bounds.upperBound) + *value = bounds.upperBound; + return 0; + } + + private static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param) + { + switch (param) + { + case ZSTD_cParameter.ZSTD_c_compressionLevel: + case ZSTD_cParameter.ZSTD_c_hashLog: + case ZSTD_cParameter.ZSTD_c_chainLog: + case ZSTD_cParameter.ZSTD_c_searchLog: + case ZSTD_cParameter.ZSTD_c_minMatch: + case ZSTD_cParameter.ZSTD_c_targetLength: + case ZSTD_cParameter.ZSTD_c_strategy: + case ZSTD_cParameter.ZSTD_c_experimentalParam20: + return 1; + case ZSTD_cParameter.ZSTD_c_experimentalParam2: + case ZSTD_cParameter.ZSTD_c_windowLog: + case ZSTD_cParameter.ZSTD_c_contentSizeFlag: + case ZSTD_cParameter.ZSTD_c_checksumFlag: + case ZSTD_cParameter.ZSTD_c_dictIDFlag: + case ZSTD_cParameter.ZSTD_c_experimentalParam3: + case ZSTD_cParameter.ZSTD_c_nbWorkers: + case ZSTD_cParameter.ZSTD_c_jobSize: + case ZSTD_cParameter.ZSTD_c_overlapLog: + case ZSTD_cParameter.ZSTD_c_experimentalParam1: + case ZSTD_cParameter.ZSTD_c_experimentalParam8: + case ZSTD_cParameter.ZSTD_c_enableLongDistanceMatching: + case ZSTD_cParameter.ZSTD_c_ldmHashLog: + case ZSTD_cParameter.ZSTD_c_ldmMinMatch: + case ZSTD_cParameter.ZSTD_c_ldmBucketSizeLog: + case ZSTD_cParameter.ZSTD_c_ldmHashRateLog: + case ZSTD_cParameter.ZSTD_c_experimentalParam4: + case ZSTD_cParameter.ZSTD_c_experimentalParam5: + case ZSTD_cParameter.ZSTD_c_targetCBlockSize: + case ZSTD_cParameter.ZSTD_c_experimentalParam7: + case ZSTD_cParameter.ZSTD_c_experimentalParam9: + case ZSTD_cParameter.ZSTD_c_experimentalParam10: + case ZSTD_cParameter.ZSTD_c_experimentalParam11: + case ZSTD_cParameter.ZSTD_c_experimentalParam12: + case ZSTD_cParameter.ZSTD_c_experimentalParam13: + case ZSTD_cParameter.ZSTD_c_experimentalParam14: + case ZSTD_cParameter.ZSTD_c_experimentalParam15: + case ZSTD_cParameter.ZSTD_c_experimentalParam16: + case ZSTD_cParameter.ZSTD_c_experimentalParam17: + case ZSTD_cParameter.ZSTD_c_experimentalParam18: + case ZSTD_cParameter.ZSTD_c_experimentalParam19: + default: + return 0; + } + } + + /*! ZSTD_CCtx_setParameter() : + * Set one compression parameter, selected by enum ZSTD_cParameter. + * All parameters have valid bounds. Bounds can be queried using ZSTD_cParam_getBounds(). + * Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter). + * Setting a parameter is generally only possible during frame initialization (before starting compression). + * Exception : when using multi-threading mode (nbWorkers >= 1), + * the following parameters can be updated _during_ compression (within same frame): + * => compressionLevel, hashLog, chainLog, searchLog, minMatch, targetLength and strategy. + * new parameters will be active for next job only (after a flush()). + * @return : an error code (which can be tested using ZSTD_isError()). + */ + public static nuint ZSTD_CCtx_setParameter(ZSTD_CCtx_s* cctx, ZSTD_cParameter param, int value) + { + if (cctx->streamStage != ZSTD_cStreamStage.zcss_init) + { + if (ZSTD_isUpdateAuthorized(param) != 0) + { + cctx->cParamsChanged = 1; + } + else + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + } + + switch (param) + { + case ZSTD_cParameter.ZSTD_c_nbWorkers: + if (value != 0 && cctx->staticSize != 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_unsupported) + ); + } + + break; + case ZSTD_cParameter.ZSTD_c_compressionLevel: + case ZSTD_cParameter.ZSTD_c_windowLog: + case ZSTD_cParameter.ZSTD_c_hashLog: + case ZSTD_cParameter.ZSTD_c_chainLog: + case ZSTD_cParameter.ZSTD_c_searchLog: + case ZSTD_cParameter.ZSTD_c_minMatch: + case ZSTD_cParameter.ZSTD_c_targetLength: + case ZSTD_cParameter.ZSTD_c_strategy: + case ZSTD_cParameter.ZSTD_c_ldmHashRateLog: + case ZSTD_cParameter.ZSTD_c_experimentalParam2: + case ZSTD_cParameter.ZSTD_c_contentSizeFlag: + case ZSTD_cParameter.ZSTD_c_checksumFlag: + case ZSTD_cParameter.ZSTD_c_dictIDFlag: + case ZSTD_cParameter.ZSTD_c_experimentalParam3: + case ZSTD_cParameter.ZSTD_c_experimentalParam4: + case ZSTD_cParameter.ZSTD_c_experimentalParam5: + case ZSTD_cParameter.ZSTD_c_jobSize: + case ZSTD_cParameter.ZSTD_c_overlapLog: + case ZSTD_cParameter.ZSTD_c_experimentalParam1: + case ZSTD_cParameter.ZSTD_c_experimentalParam8: + case ZSTD_cParameter.ZSTD_c_enableLongDistanceMatching: + case ZSTD_cParameter.ZSTD_c_ldmHashLog: + case ZSTD_cParameter.ZSTD_c_ldmMinMatch: + case ZSTD_cParameter.ZSTD_c_ldmBucketSizeLog: + case ZSTD_cParameter.ZSTD_c_targetCBlockSize: + case ZSTD_cParameter.ZSTD_c_experimentalParam7: + case ZSTD_cParameter.ZSTD_c_experimentalParam9: + case ZSTD_cParameter.ZSTD_c_experimentalParam10: + case ZSTD_cParameter.ZSTD_c_experimentalParam11: + case ZSTD_cParameter.ZSTD_c_experimentalParam12: + case ZSTD_cParameter.ZSTD_c_experimentalParam13: + case ZSTD_cParameter.ZSTD_c_experimentalParam20: + case ZSTD_cParameter.ZSTD_c_experimentalParam14: + case ZSTD_cParameter.ZSTD_c_experimentalParam15: + case ZSTD_cParameter.ZSTD_c_experimentalParam16: + case ZSTD_cParameter.ZSTD_c_experimentalParam17: + case ZSTD_cParameter.ZSTD_c_experimentalParam18: + case ZSTD_cParameter.ZSTD_c_experimentalParam19: + break; + default: + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_unsupported)); + } + + return ZSTD_CCtxParams_setParameter(&cctx->requestedParams, param, value); + } + + /*! ZSTD_CCtxParams_setParameter() : Requires v1.4.0+ + * Similar to ZSTD_CCtx_setParameter. + * Set one compression parameter, selected by enum ZSTD_cParameter. + * Parameters must be applied to a ZSTD_CCtx using + * ZSTD_CCtx_setParametersUsingCCtxParams(). + * @result : a code representing success or failure (which can be tested with + * ZSTD_isError()). + */ + public static nuint ZSTD_CCtxParams_setParameter( + ZSTD_CCtx_params_s* CCtxParams, + ZSTD_cParameter param, + int value + ) + { + switch (param) + { + case ZSTD_cParameter.ZSTD_c_experimentalParam2: + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam2, value) == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->format = (ZSTD_format_e)value; + return (nuint)CCtxParams->format; + case ZSTD_cParameter.ZSTD_c_compressionLevel: + { + { + nuint err_code = ZSTD_cParam_clampBounds(param, &value); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (value == 0) + CCtxParams->compressionLevel = 3; + else + CCtxParams->compressionLevel = value; + if (CCtxParams->compressionLevel >= 0) + return (nuint)CCtxParams->compressionLevel; + return 0; + } + + case ZSTD_cParameter.ZSTD_c_windowLog: + if (value != 0) + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_windowLog, value) == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + + CCtxParams->cParams.windowLog = (uint)value; + return CCtxParams->cParams.windowLog; + case ZSTD_cParameter.ZSTD_c_hashLog: + if (value != 0) + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_hashLog, value) == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + + CCtxParams->cParams.hashLog = (uint)value; + return CCtxParams->cParams.hashLog; + case ZSTD_cParameter.ZSTD_c_chainLog: + if (value != 0) + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_chainLog, value) == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + + CCtxParams->cParams.chainLog = (uint)value; + return CCtxParams->cParams.chainLog; + case ZSTD_cParameter.ZSTD_c_searchLog: + if (value != 0) + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_searchLog, value) == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + + CCtxParams->cParams.searchLog = (uint)value; + return (nuint)value; + case ZSTD_cParameter.ZSTD_c_minMatch: + if (value != 0) + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_minMatch, value) == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + + CCtxParams->cParams.minMatch = (uint)value; + return CCtxParams->cParams.minMatch; + case ZSTD_cParameter.ZSTD_c_targetLength: + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_targetLength, value) == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->cParams.targetLength = (uint)value; + return CCtxParams->cParams.targetLength; + case ZSTD_cParameter.ZSTD_c_strategy: + if (value != 0) + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_strategy, value) == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + + CCtxParams->cParams.strategy = (ZSTD_strategy)value; + return (nuint)CCtxParams->cParams.strategy; + case ZSTD_cParameter.ZSTD_c_contentSizeFlag: + CCtxParams->fParams.contentSizeFlag = value != 0 ? 1 : 0; + return (nuint)CCtxParams->fParams.contentSizeFlag; + case ZSTD_cParameter.ZSTD_c_checksumFlag: + CCtxParams->fParams.checksumFlag = value != 0 ? 1 : 0; + return (nuint)CCtxParams->fParams.checksumFlag; + case ZSTD_cParameter.ZSTD_c_dictIDFlag: + CCtxParams->fParams.noDictIDFlag = value == 0 ? 1 : 0; + return CCtxParams->fParams.noDictIDFlag == 0 ? 1U : 0U; + case ZSTD_cParameter.ZSTD_c_experimentalParam3: + CCtxParams->forceWindow = value != 0 ? 1 : 0; + return (nuint)CCtxParams->forceWindow; + case ZSTD_cParameter.ZSTD_c_experimentalParam4: + { + ZSTD_dictAttachPref_e pref = (ZSTD_dictAttachPref_e)value; + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam4, (int)pref) + == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->attachDictPref = pref; + return (nuint)CCtxParams->attachDictPref; + } + + case ZSTD_cParameter.ZSTD_c_experimentalParam5: + { + ZSTD_paramSwitch_e lcm = (ZSTD_paramSwitch_e)value; + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam5, (int)lcm) + == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->literalCompressionMode = lcm; + return (nuint)CCtxParams->literalCompressionMode; + } + + case ZSTD_cParameter.ZSTD_c_nbWorkers: + { + nuint err_code = ZSTD_cParam_clampBounds(param, &value); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + CCtxParams->nbWorkers = value; + return (nuint)CCtxParams->nbWorkers; + case ZSTD_cParameter.ZSTD_c_jobSize: + if (value != 0 && value < 512 * (1 << 10)) + value = 512 * (1 << 10); + + { + nuint err_code = ZSTD_cParam_clampBounds(param, &value); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(value >= 0); + CCtxParams->jobSize = (nuint)value; + return CCtxParams->jobSize; + case ZSTD_cParameter.ZSTD_c_overlapLog: + { + nuint err_code = ZSTD_cParam_clampBounds( + ZSTD_cParameter.ZSTD_c_overlapLog, + &value + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + CCtxParams->overlapLog = value; + return (nuint)CCtxParams->overlapLog; + case ZSTD_cParameter.ZSTD_c_experimentalParam1: + { + nuint err_code = ZSTD_cParam_clampBounds( + ZSTD_cParameter.ZSTD_c_overlapLog, + &value + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + CCtxParams->rsyncable = value; + return (nuint)CCtxParams->rsyncable; + case ZSTD_cParameter.ZSTD_c_experimentalParam8: + CCtxParams->enableDedicatedDictSearch = value != 0 ? 1 : 0; + return (nuint)CCtxParams->enableDedicatedDictSearch; + case ZSTD_cParameter.ZSTD_c_enableLongDistanceMatching: + if ( + ZSTD_cParam_withinBounds( + ZSTD_cParameter.ZSTD_c_enableLongDistanceMatching, + value + ) == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->ldmParams.enableLdm = (ZSTD_paramSwitch_e)value; + return (nuint)CCtxParams->ldmParams.enableLdm; + case ZSTD_cParameter.ZSTD_c_ldmHashLog: + if (value != 0) + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_ldmHashLog, value) == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + + CCtxParams->ldmParams.hashLog = (uint)value; + return CCtxParams->ldmParams.hashLog; + case ZSTD_cParameter.ZSTD_c_ldmMinMatch: + if (value != 0) + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_ldmMinMatch, value) == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + + CCtxParams->ldmParams.minMatchLength = (uint)value; + return CCtxParams->ldmParams.minMatchLength; + case ZSTD_cParameter.ZSTD_c_ldmBucketSizeLog: + if (value != 0) + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_ldmBucketSizeLog, value) + == 0 + ) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + + CCtxParams->ldmParams.bucketSizeLog = (uint)value; + return CCtxParams->ldmParams.bucketSizeLog; + case ZSTD_cParameter.ZSTD_c_ldmHashRateLog: + if (value != 0) + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_ldmHashRateLog, value) == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + + CCtxParams->ldmParams.hashRateLog = (uint)value; + return CCtxParams->ldmParams.hashRateLog; + case ZSTD_cParameter.ZSTD_c_targetCBlockSize: + if (value != 0) + { + value = value > 1340 ? value : 1340; + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_targetCBlockSize, value) + == 0 + ) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + } + + CCtxParams->targetCBlockSize = (uint)value; + return CCtxParams->targetCBlockSize; + case ZSTD_cParameter.ZSTD_c_experimentalParam7: + if (value != 0) + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam7, value) + == 0 + ) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + + CCtxParams->srcSizeHint = value; + return (nuint)CCtxParams->srcSizeHint; + case ZSTD_cParameter.ZSTD_c_experimentalParam9: + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam9, value) == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->inBufferMode = (ZSTD_bufferMode_e)value; + return (nuint)CCtxParams->inBufferMode; + case ZSTD_cParameter.ZSTD_c_experimentalParam10: + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam10, value) == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->outBufferMode = (ZSTD_bufferMode_e)value; + return (nuint)CCtxParams->outBufferMode; + case ZSTD_cParameter.ZSTD_c_experimentalParam11: + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam11, value) == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->blockDelimiters = (ZSTD_sequenceFormat_e)value; + return (nuint)CCtxParams->blockDelimiters; + case ZSTD_cParameter.ZSTD_c_experimentalParam12: + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam12, value) == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->validateSequences = value; + return (nuint)CCtxParams->validateSequences; + case ZSTD_cParameter.ZSTD_c_experimentalParam13: + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam13, value) == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->postBlockSplitter = (ZSTD_paramSwitch_e)value; + return (nuint)CCtxParams->postBlockSplitter; + case ZSTD_cParameter.ZSTD_c_experimentalParam20: + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam20, value) == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->preBlockSplitter_level = value; + return (nuint)CCtxParams->preBlockSplitter_level; + case ZSTD_cParameter.ZSTD_c_experimentalParam14: + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam14, value) == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->useRowMatchFinder = (ZSTD_paramSwitch_e)value; + return (nuint)CCtxParams->useRowMatchFinder; + case ZSTD_cParameter.ZSTD_c_experimentalParam15: + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam15, value) == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->deterministicRefPrefix = !(value == 0) ? 1 : 0; + return (nuint)CCtxParams->deterministicRefPrefix; + case ZSTD_cParameter.ZSTD_c_experimentalParam16: + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam16, value) == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->prefetchCDictTables = (ZSTD_paramSwitch_e)value; + return (nuint)CCtxParams->prefetchCDictTables; + case ZSTD_cParameter.ZSTD_c_experimentalParam17: + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam17, value) == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->enableMatchFinderFallback = value; + return (nuint)CCtxParams->enableMatchFinderFallback; + case ZSTD_cParameter.ZSTD_c_experimentalParam18: + if (value != 0) + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam18, value) + == 0 + ) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + + assert(value >= 0); + CCtxParams->maxBlockSize = (nuint)value; + return CCtxParams->maxBlockSize; + case ZSTD_cParameter.ZSTD_c_experimentalParam19: + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam19, value) == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + CCtxParams->searchForExternalRepcodes = (ZSTD_paramSwitch_e)value; + return (nuint)CCtxParams->searchForExternalRepcodes; + default: + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_unsupported)); + } + } + + /*! ZSTD_CCtx_getParameter() : + * Get the requested compression parameter value, selected by enum ZSTD_cParameter, + * and store it into int* value. + * @return : 0, or an error code (which can be tested with ZSTD_isError()). + */ + public static nuint ZSTD_CCtx_getParameter(ZSTD_CCtx_s* cctx, ZSTD_cParameter param, int* value) + { + return ZSTD_CCtxParams_getParameter(&cctx->requestedParams, param, value); + } + + /*! ZSTD_CCtxParams_getParameter() : + * Similar to ZSTD_CCtx_getParameter. + * Get the requested value of one compression parameter, selected by enum ZSTD_cParameter. + * @result : 0, or an error code (which can be tested with ZSTD_isError()). + */ + public static nuint ZSTD_CCtxParams_getParameter( + ZSTD_CCtx_params_s* CCtxParams, + ZSTD_cParameter param, + int* value + ) + { + switch (param) + { + case ZSTD_cParameter.ZSTD_c_experimentalParam2: + *value = (int)CCtxParams->format; + break; + case ZSTD_cParameter.ZSTD_c_compressionLevel: + *value = CCtxParams->compressionLevel; + break; + case ZSTD_cParameter.ZSTD_c_windowLog: + *value = (int)CCtxParams->cParams.windowLog; + break; + case ZSTD_cParameter.ZSTD_c_hashLog: + *value = (int)CCtxParams->cParams.hashLog; + break; + case ZSTD_cParameter.ZSTD_c_chainLog: + *value = (int)CCtxParams->cParams.chainLog; + break; + case ZSTD_cParameter.ZSTD_c_searchLog: + *value = (int)CCtxParams->cParams.searchLog; + break; + case ZSTD_cParameter.ZSTD_c_minMatch: + *value = (int)CCtxParams->cParams.minMatch; + break; + case ZSTD_cParameter.ZSTD_c_targetLength: + *value = (int)CCtxParams->cParams.targetLength; + break; + case ZSTD_cParameter.ZSTD_c_strategy: + *value = (int)CCtxParams->cParams.strategy; + break; + case ZSTD_cParameter.ZSTD_c_contentSizeFlag: + *value = CCtxParams->fParams.contentSizeFlag; + break; + case ZSTD_cParameter.ZSTD_c_checksumFlag: + *value = CCtxParams->fParams.checksumFlag; + break; + case ZSTD_cParameter.ZSTD_c_dictIDFlag: + *value = CCtxParams->fParams.noDictIDFlag == 0 ? 1 : 0; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam3: + *value = CCtxParams->forceWindow; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam4: + *value = (int)CCtxParams->attachDictPref; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam5: + *value = (int)CCtxParams->literalCompressionMode; + break; + case ZSTD_cParameter.ZSTD_c_nbWorkers: + *value = CCtxParams->nbWorkers; + break; + case ZSTD_cParameter.ZSTD_c_jobSize: + assert(CCtxParams->jobSize <= 2147483647); + *value = (int)CCtxParams->jobSize; + break; + case ZSTD_cParameter.ZSTD_c_overlapLog: + *value = CCtxParams->overlapLog; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam1: + *value = CCtxParams->rsyncable; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam8: + *value = CCtxParams->enableDedicatedDictSearch; + break; + case ZSTD_cParameter.ZSTD_c_enableLongDistanceMatching: + *value = (int)CCtxParams->ldmParams.enableLdm; + break; + case ZSTD_cParameter.ZSTD_c_ldmHashLog: + *value = (int)CCtxParams->ldmParams.hashLog; + break; + case ZSTD_cParameter.ZSTD_c_ldmMinMatch: + *value = (int)CCtxParams->ldmParams.minMatchLength; + break; + case ZSTD_cParameter.ZSTD_c_ldmBucketSizeLog: + *value = (int)CCtxParams->ldmParams.bucketSizeLog; + break; + case ZSTD_cParameter.ZSTD_c_ldmHashRateLog: + *value = (int)CCtxParams->ldmParams.hashRateLog; + break; + case ZSTD_cParameter.ZSTD_c_targetCBlockSize: + *value = (int)CCtxParams->targetCBlockSize; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam7: + *value = CCtxParams->srcSizeHint; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam9: + *value = (int)CCtxParams->inBufferMode; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam10: + *value = (int)CCtxParams->outBufferMode; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam11: + *value = (int)CCtxParams->blockDelimiters; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam12: + *value = CCtxParams->validateSequences; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam13: + *value = (int)CCtxParams->postBlockSplitter; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam20: + *value = CCtxParams->preBlockSplitter_level; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam14: + *value = (int)CCtxParams->useRowMatchFinder; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam15: + *value = CCtxParams->deterministicRefPrefix; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam16: + *value = (int)CCtxParams->prefetchCDictTables; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam17: + *value = CCtxParams->enableMatchFinderFallback; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam18: + *value = (int)CCtxParams->maxBlockSize; + break; + case ZSTD_cParameter.ZSTD_c_experimentalParam19: + *value = (int)CCtxParams->searchForExternalRepcodes; + break; + default: + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_unsupported)); + } + + return 0; + } + + /** ZSTD_CCtx_setParametersUsingCCtxParams() : + * just applies `params` into `cctx` + * no action is performed, parameters are merely stored. + * If ZSTDMT is enabled, parameters are pushed to cctx->mtctx. + * This is possible even if a compression is ongoing. + * In which case, new parameters will be applied on the fly, starting with next compression job. + */ + public static nuint ZSTD_CCtx_setParametersUsingCCtxParams( + ZSTD_CCtx_s* cctx, + ZSTD_CCtx_params_s* @params + ) + { + if (cctx->streamStage != ZSTD_cStreamStage.zcss_init) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + if (cctx->cdict != null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + cctx->requestedParams = *@params; + return 0; + } + + /*! ZSTD_CCtx_setCParams() : + * Set all parameters provided within @p cparams into the working @p cctx. + * Note : if modifying parameters during compression (MT mode only), + * note that changes to the .windowLog parameter will be ignored. + * @return 0 on success, or an error code (can be checked with ZSTD_isError()). + * On failure, no parameters are updated. + */ + public static nuint ZSTD_CCtx_setCParams(ZSTD_CCtx_s* cctx, ZSTD_compressionParameters cparams) + { + { + /* only update if all parameters are valid */ + nuint err_code = ZSTD_checkCParams(cparams); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setParameter( + cctx, + ZSTD_cParameter.ZSTD_c_windowLog, + (int)cparams.windowLog + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setParameter( + cctx, + ZSTD_cParameter.ZSTD_c_chainLog, + (int)cparams.chainLog + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setParameter( + cctx, + ZSTD_cParameter.ZSTD_c_hashLog, + (int)cparams.hashLog + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setParameter( + cctx, + ZSTD_cParameter.ZSTD_c_searchLog, + (int)cparams.searchLog + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setParameter( + cctx, + ZSTD_cParameter.ZSTD_c_minMatch, + (int)cparams.minMatch + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setParameter( + cctx, + ZSTD_cParameter.ZSTD_c_targetLength, + (int)cparams.targetLength + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setParameter( + cctx, + ZSTD_cParameter.ZSTD_c_strategy, + (int)cparams.strategy + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + /*! ZSTD_CCtx_setFParams() : + * Set all parameters provided within @p fparams into the working @p cctx. + * @return 0 on success, or an error code (can be checked with ZSTD_isError()). + */ + public static nuint ZSTD_CCtx_setFParams(ZSTD_CCtx_s* cctx, ZSTD_frameParameters fparams) + { + { + nuint err_code = ZSTD_CCtx_setParameter( + cctx, + ZSTD_cParameter.ZSTD_c_contentSizeFlag, + fparams.contentSizeFlag != 0 ? 1 : 0 + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setParameter( + cctx, + ZSTD_cParameter.ZSTD_c_checksumFlag, + fparams.checksumFlag != 0 ? 1 : 0 + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setParameter( + cctx, + ZSTD_cParameter.ZSTD_c_dictIDFlag, + fparams.noDictIDFlag == 0 ? 1 : 0 + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + /*! ZSTD_CCtx_setParams() : + * Set all parameters provided within @p params into the working @p cctx. + * @return 0 on success, or an error code (can be checked with ZSTD_isError()). + */ + public static nuint ZSTD_CCtx_setParams(ZSTD_CCtx_s* cctx, ZSTD_parameters @params) + { + { + /* First check cParams, because we want to update all or none. */ + nuint err_code = ZSTD_checkCParams(@params.cParams); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + /* Next set fParams, because this could fail if the cctx isn't in init stage. */ + nuint err_code = ZSTD_CCtx_setFParams(cctx, @params.fParams); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + /* Finally set cParams, which should succeed. */ + nuint err_code = ZSTD_CCtx_setCParams(cctx, @params.cParams); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + /*! ZSTD_CCtx_setPledgedSrcSize() : + * Total input data size to be compressed as a single frame. + * Value will be written in frame header, unless if explicitly forbidden using ZSTD_c_contentSizeFlag. + * This value will also be controlled at end of frame, and trigger an error if not respected. + * @result : 0, or an error code (which can be tested with ZSTD_isError()). + * Note 1 : pledgedSrcSize==0 actually means zero, aka an empty frame. + * In order to mean "unknown content size", pass constant ZSTD_CONTENTSIZE_UNKNOWN. + * ZSTD_CONTENTSIZE_UNKNOWN is default value for any new frame. + * Note 2 : pledgedSrcSize is only valid once, for the next frame. + * It's discarded at the end of the frame, and replaced by ZSTD_CONTENTSIZE_UNKNOWN. + * Note 3 : Whenever all input data is provided and consumed in a single round, + * for example with ZSTD_compress2(), + * or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end), + * this value is automatically overridden by srcSize instead. + */ + public static nuint ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx_s* cctx, ulong pledgedSrcSize) + { + if (cctx->streamStage != ZSTD_cStreamStage.zcss_init) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + cctx->pledgedSrcSizePlusOne = pledgedSrcSize + 1; + return 0; + } + + /** + * Initializes the local dictionary using requested parameters. + * NOTE: Initialization does not employ the pledged src size, + * because the dictionary may be used for multiple compressions. + */ + private static nuint ZSTD_initLocalDict(ZSTD_CCtx_s* cctx) + { + ZSTD_localDict* dl = &cctx->localDict; + if (dl->dict == null) + { + assert(dl->dictBuffer == null); + assert(dl->cdict == null); + assert(dl->dictSize == 0); + return 0; + } + + if (dl->cdict != null) + { + assert(cctx->cdict == dl->cdict); + return 0; + } + + assert(dl->dictSize > 0); + assert(cctx->cdict == null); + assert(cctx->prefixDict.dict == null); + dl->cdict = ZSTD_createCDict_advanced2( + dl->dict, + dl->dictSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef, + dl->dictContentType, + &cctx->requestedParams, + cctx->customMem + ); + if (dl->cdict == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + cctx->cdict = dl->cdict; + return 0; + } + + /*! ZSTD_CCtx_loadDictionary_advanced() : + * Same as ZSTD_CCtx_loadDictionary(), but gives finer control over + * how to load the dictionary (by copy ? by reference ?) + * and how to interpret it (automatic ? force raw mode ? full mode only ?) */ + public static nuint ZSTD_CCtx_loadDictionary_advanced( + ZSTD_CCtx_s* cctx, + void* dict, + nuint dictSize, + ZSTD_dictLoadMethod_e dictLoadMethod, + ZSTD_dictContentType_e dictContentType + ) + { + if (cctx->streamStage != ZSTD_cStreamStage.zcss_init) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + ZSTD_clearAllDicts(cctx); + if (dict == null || dictSize == 0) + return 0; + if (dictLoadMethod == ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef) + { + cctx->localDict.dict = dict; + } + else + { + /* copy dictionary content inside CCtx to own its lifetime */ + void* dictBuffer; + if (cctx->staticSize != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + dictBuffer = ZSTD_customMalloc(dictSize, cctx->customMem); + if (dictBuffer == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + memcpy(dictBuffer, dict, (uint)dictSize); + cctx->localDict.dictBuffer = dictBuffer; + cctx->localDict.dict = dictBuffer; + } + + cctx->localDict.dictSize = dictSize; + cctx->localDict.dictContentType = dictContentType; + return 0; + } + + /*! ZSTD_CCtx_loadDictionary_byReference() : + * Same as ZSTD_CCtx_loadDictionary(), but dictionary content is referenced, instead of being copied into CCtx. + * It saves some memory, but also requires that `dict` outlives its usage within `cctx` */ + public static nuint ZSTD_CCtx_loadDictionary_byReference( + ZSTD_CCtx_s* cctx, + void* dict, + nuint dictSize + ) + { + return ZSTD_CCtx_loadDictionary_advanced( + cctx, + dict, + dictSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef, + ZSTD_dictContentType_e.ZSTD_dct_auto + ); + } + + /*! ZSTD_CCtx_loadDictionary() : Requires v1.4.0+ + * Create an internal CDict from `dict` buffer. + * Decompression will have to use same dictionary. + * @result : 0, or an error code (which can be tested with ZSTD_isError()). + * Special: Loading a NULL (or 0-size) dictionary invalidates previous dictionary, + * meaning "return to no-dictionary mode". + * Note 1 : Dictionary is sticky, it will be used for all future compressed frames, + * until parameters are reset, a new dictionary is loaded, or the dictionary + * is explicitly invalidated by loading a NULL dictionary. + * Note 2 : Loading a dictionary involves building tables. + * It's also a CPU consuming operation, with non-negligible impact on latency. + * Tables are dependent on compression parameters, and for this reason, + * compression parameters can no longer be changed after loading a dictionary. + * Note 3 :`dict` content will be copied internally. + * Use experimental ZSTD_CCtx_loadDictionary_byReference() to reference content instead. + * In such a case, dictionary buffer must outlive its users. + * Note 4 : Use ZSTD_CCtx_loadDictionary_advanced() + * to precisely select how dictionary content must be interpreted. + * Note 5 : This method does not benefit from LDM (long distance mode). + * If you want to employ LDM on some large dictionary content, + * prefer employing ZSTD_CCtx_refPrefix() described below. + */ + public static nuint ZSTD_CCtx_loadDictionary(ZSTD_CCtx_s* cctx, void* dict, nuint dictSize) + { + return ZSTD_CCtx_loadDictionary_advanced( + cctx, + dict, + dictSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byCopy, + ZSTD_dictContentType_e.ZSTD_dct_auto + ); + } + + /*! ZSTD_CCtx_refCDict() : Requires v1.4.0+ + * Reference a prepared dictionary, to be used for all future compressed frames. + * Note that compression parameters are enforced from within CDict, + * and supersede any compression parameter previously set within CCtx. + * The parameters ignored are labelled as "superseded-by-cdict" in the ZSTD_cParameter enum docs. + * The ignored parameters will be used again if the CCtx is returned to no-dictionary mode. + * The dictionary will remain valid for future compressed frames using same CCtx. + * @result : 0, or an error code (which can be tested with ZSTD_isError()). + * Special : Referencing a NULL CDict means "return to no-dictionary mode". + * Note 1 : Currently, only one dictionary can be managed. + * Referencing a new dictionary effectively "discards" any previous one. + * Note 2 : CDict is just referenced, its lifetime must outlive its usage within CCtx. */ + public static nuint ZSTD_CCtx_refCDict(ZSTD_CCtx_s* cctx, ZSTD_CDict_s* cdict) + { + if (cctx->streamStage != ZSTD_cStreamStage.zcss_init) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + ZSTD_clearAllDicts(cctx); + cctx->cdict = cdict; + return 0; + } + + public static nuint ZSTD_CCtx_refThreadPool(ZSTD_CCtx_s* cctx, void* pool) + { + if (cctx->streamStage != ZSTD_cStreamStage.zcss_init) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + cctx->pool = pool; + return 0; + } + + /*! ZSTD_CCtx_refPrefix() : Requires v1.4.0+ + * Reference a prefix (single-usage dictionary) for next compressed frame. + * A prefix is **only used once**. Tables are discarded at end of frame (ZSTD_e_end). + * Decompression will need same prefix to properly regenerate data. + * Compressing with a prefix is similar in outcome as performing a diff and compressing it, + * but performs much faster, especially during decompression (compression speed is tunable with compression level). + * This method is compatible with LDM (long distance mode). + * @result : 0, or an error code (which can be tested with ZSTD_isError()). + * Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary + * Note 1 : Prefix buffer is referenced. It **must** outlive compression. + * Its content must remain unmodified during compression. + * Note 2 : If the intention is to diff some large src data blob with some prior version of itself, + * ensure that the window size is large enough to contain the entire source. + * See ZSTD_c_windowLog. + * Note 3 : Referencing a prefix involves building tables, which are dependent on compression parameters. + * It's a CPU consuming operation, with non-negligible impact on latency. + * If there is a need to use the same prefix multiple times, consider loadDictionary instead. + * Note 4 : By default, the prefix is interpreted as raw content (ZSTD_dct_rawContent). + * Use experimental ZSTD_CCtx_refPrefix_advanced() to alter dictionary interpretation. */ + public static nuint ZSTD_CCtx_refPrefix(ZSTD_CCtx_s* cctx, void* prefix, nuint prefixSize) + { + return ZSTD_CCtx_refPrefix_advanced( + cctx, + prefix, + prefixSize, + ZSTD_dictContentType_e.ZSTD_dct_rawContent + ); + } + + /*! ZSTD_CCtx_refPrefix_advanced() : + * Same as ZSTD_CCtx_refPrefix(), but gives finer control over + * how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) */ + public static nuint ZSTD_CCtx_refPrefix_advanced( + ZSTD_CCtx_s* cctx, + void* prefix, + nuint prefixSize, + ZSTD_dictContentType_e dictContentType + ) + { + if (cctx->streamStage != ZSTD_cStreamStage.zcss_init) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + ZSTD_clearAllDicts(cctx); + if (prefix != null && prefixSize > 0) + { + cctx->prefixDict.dict = prefix; + cctx->prefixDict.dictSize = prefixSize; + cctx->prefixDict.dictContentType = dictContentType; + } + + return 0; + } + + /*! ZSTD_CCtx_reset() : + * Also dumps dictionary */ + public static nuint ZSTD_CCtx_reset(ZSTD_CCtx_s* cctx, ZSTD_ResetDirective reset) + { + if ( + reset == ZSTD_ResetDirective.ZSTD_reset_session_only + || reset == ZSTD_ResetDirective.ZSTD_reset_session_and_parameters + ) + { + cctx->streamStage = ZSTD_cStreamStage.zcss_init; + cctx->pledgedSrcSizePlusOne = 0; + } + + if ( + reset == ZSTD_ResetDirective.ZSTD_reset_parameters + || reset == ZSTD_ResetDirective.ZSTD_reset_session_and_parameters + ) + { + if (cctx->streamStage != ZSTD_cStreamStage.zcss_init) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + ZSTD_clearAllDicts(cctx); + return ZSTD_CCtxParams_reset(&cctx->requestedParams); + } + + return 0; + } + + /** ZSTD_checkCParams() : + control CParam values remain within authorized range. + @return : 0, or an error code if one value is beyond authorized range */ + public static nuint ZSTD_checkCParams(ZSTD_compressionParameters cParams) + { + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_windowLog, (int)cParams.windowLog) == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_chainLog, (int)cParams.chainLog) == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_hashLog, (int)cParams.hashLog) == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_searchLog, (int)cParams.searchLog) == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_minMatch, (int)cParams.minMatch) == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + if ( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_targetLength, (int)cParams.targetLength) + == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + if (ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_strategy, (int)cParams.strategy) == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + return 0; + } + + /** ZSTD_clampCParams() : + * make CParam values within valid range. + * @return : valid CParams */ + private static ZSTD_compressionParameters ZSTD_clampCParams(ZSTD_compressionParameters cParams) + { + { + ZSTD_bounds bounds = ZSTD_cParam_getBounds(ZSTD_cParameter.ZSTD_c_windowLog); + if ((int)cParams.windowLog < bounds.lowerBound) + cParams.windowLog = (uint)bounds.lowerBound; + else if ((int)cParams.windowLog > bounds.upperBound) + cParams.windowLog = (uint)bounds.upperBound; + } + + { + ZSTD_bounds bounds = ZSTD_cParam_getBounds(ZSTD_cParameter.ZSTD_c_chainLog); + if ((int)cParams.chainLog < bounds.lowerBound) + cParams.chainLog = (uint)bounds.lowerBound; + else if ((int)cParams.chainLog > bounds.upperBound) + cParams.chainLog = (uint)bounds.upperBound; + } + + { + ZSTD_bounds bounds = ZSTD_cParam_getBounds(ZSTD_cParameter.ZSTD_c_hashLog); + if ((int)cParams.hashLog < bounds.lowerBound) + cParams.hashLog = (uint)bounds.lowerBound; + else if ((int)cParams.hashLog > bounds.upperBound) + cParams.hashLog = (uint)bounds.upperBound; + } + + { + ZSTD_bounds bounds = ZSTD_cParam_getBounds(ZSTD_cParameter.ZSTD_c_searchLog); + if ((int)cParams.searchLog < bounds.lowerBound) + cParams.searchLog = (uint)bounds.lowerBound; + else if ((int)cParams.searchLog > bounds.upperBound) + cParams.searchLog = (uint)bounds.upperBound; + } + + { + ZSTD_bounds bounds = ZSTD_cParam_getBounds(ZSTD_cParameter.ZSTD_c_minMatch); + if ((int)cParams.minMatch < bounds.lowerBound) + cParams.minMatch = (uint)bounds.lowerBound; + else if ((int)cParams.minMatch > bounds.upperBound) + cParams.minMatch = (uint)bounds.upperBound; + } + + { + ZSTD_bounds bounds = ZSTD_cParam_getBounds(ZSTD_cParameter.ZSTD_c_targetLength); + if ((int)cParams.targetLength < bounds.lowerBound) + cParams.targetLength = (uint)bounds.lowerBound; + else if ((int)cParams.targetLength > bounds.upperBound) + cParams.targetLength = (uint)bounds.upperBound; + } + + { + ZSTD_bounds bounds = ZSTD_cParam_getBounds(ZSTD_cParameter.ZSTD_c_strategy); + if ((int)cParams.strategy < bounds.lowerBound) + cParams.strategy = (ZSTD_strategy)bounds.lowerBound; + else if ((int)cParams.strategy > bounds.upperBound) + cParams.strategy = (ZSTD_strategy)bounds.upperBound; + } + + return cParams; + } + + /** ZSTD_cycleLog() : + * condition for correct operation : hashLog > 1 */ + private static uint ZSTD_cycleLog(uint hashLog, ZSTD_strategy strat) + { + uint btScale = (uint)strat >= (uint)ZSTD_strategy.ZSTD_btlazy2 ? 1U : 0U; + return hashLog - btScale; + } + + /** ZSTD_dictAndWindowLog() : + * Returns an adjusted window log that is large enough to fit the source and the dictionary. + * The zstd format says that the entire dictionary is valid if one byte of the dictionary + * is within the window. So the hashLog and chainLog should be large enough to reference both + * the dictionary and the window. So we must use this adjusted dictAndWindowLog when downsizing + * the hashLog and windowLog. + * NOTE: srcSize must not be ZSTD_CONTENTSIZE_UNKNOWN. + */ + private static uint ZSTD_dictAndWindowLog(uint windowLog, ulong srcSize, ulong dictSize) + { + ulong maxWindowSize = 1UL << (sizeof(nuint) == 4 ? 30 : 31); + if (dictSize == 0) + { + return windowLog; + } + + assert(windowLog <= (uint)(sizeof(nuint) == 4 ? 30 : 31)); + assert(srcSize != unchecked(0UL - 1)); + { + ulong windowSize = 1UL << (int)windowLog; + ulong dictAndWindowSize = dictSize + windowSize; + if (windowSize >= dictSize + srcSize) + { + return windowLog; + } + else if (dictAndWindowSize >= maxWindowSize) + { + return (uint)(sizeof(nuint) == 4 ? 30 : 31); + } + else + { + return ZSTD_highbit32((uint)dictAndWindowSize - 1) + 1; + } + } + } + + /** ZSTD_adjustCParams_internal() : + * optimize `cPar` for a specified input (`srcSize` and `dictSize`). + * mostly downsize to reduce memory consumption and initialization latency. + * `srcSize` can be ZSTD_CONTENTSIZE_UNKNOWN when not known. + * `mode` is the mode for parameter adjustment. See docs for `ZSTD_CParamMode_e`. + * note : `srcSize==0` means 0! + * condition : cPar is presumed validated (can be checked using ZSTD_checkCParams()). */ + private static ZSTD_compressionParameters ZSTD_adjustCParams_internal( + ZSTD_compressionParameters cPar, + ulong srcSize, + nuint dictSize, + ZSTD_CParamMode_e mode, + ZSTD_paramSwitch_e useRowMatchFinder + ) + { + /* (1<<9) + 1 */ + const ulong minSrcSize = 513; + ulong maxWindowResize = 1UL << (sizeof(nuint) == 4 ? 30 : 31) - 1; + assert(ZSTD_checkCParams(cPar) == 0); + switch (mode) + { + case ZSTD_CParamMode_e.ZSTD_cpm_unknown: + case ZSTD_CParamMode_e.ZSTD_cpm_noAttachDict: + break; + case ZSTD_CParamMode_e.ZSTD_cpm_createCDict: + if (dictSize != 0 && srcSize == unchecked(0UL - 1)) + srcSize = minSrcSize; + break; + case ZSTD_CParamMode_e.ZSTD_cpm_attachDict: + dictSize = 0; + break; + default: + assert(0 != 0); + break; + } + + if (srcSize <= maxWindowResize && dictSize <= maxWindowResize) + { + uint tSize = (uint)(srcSize + dictSize); + const uint hashSizeMin = 1 << 6; + uint srcLog = tSize < hashSizeMin ? 6 : ZSTD_highbit32(tSize - 1) + 1; + if (cPar.windowLog > srcLog) + cPar.windowLog = srcLog; + } + + if (srcSize != unchecked(0UL - 1)) + { + uint dictAndWindowLog = ZSTD_dictAndWindowLog(cPar.windowLog, srcSize, dictSize); + uint cycleLog = ZSTD_cycleLog(cPar.chainLog, cPar.strategy); + if (cPar.hashLog > dictAndWindowLog + 1) + cPar.hashLog = dictAndWindowLog + 1; + if (cycleLog > dictAndWindowLog) + cPar.chainLog -= cycleLog - dictAndWindowLog; + } + + if (cPar.windowLog < 10) + cPar.windowLog = 10; + if ( + mode == ZSTD_CParamMode_e.ZSTD_cpm_createCDict + && ZSTD_CDictIndicesAreTagged(&cPar) != 0 + ) + { + const uint maxShortCacheHashLog = 32 - 8; + if (cPar.hashLog > maxShortCacheHashLog) + { + cPar.hashLog = maxShortCacheHashLog; + } + + if (cPar.chainLog > maxShortCacheHashLog) + { + cPar.chainLog = maxShortCacheHashLog; + } + } + + if (useRowMatchFinder == ZSTD_paramSwitch_e.ZSTD_ps_auto) + useRowMatchFinder = ZSTD_paramSwitch_e.ZSTD_ps_enable; + if (ZSTD_rowMatchFinderUsed(cPar.strategy, useRowMatchFinder) != 0) + { + /* Switch to 32-entry rows if searchLog is 5 (or more) */ + uint rowLog = + cPar.searchLog <= 4 ? 4 + : cPar.searchLog <= 6 ? cPar.searchLog + : 6; + const uint maxRowHashLog = 32 - 8; + uint maxHashLog = maxRowHashLog + rowLog; + assert(cPar.hashLog >= rowLog); + if (cPar.hashLog > maxHashLog) + { + cPar.hashLog = maxHashLog; + } + } + + return cPar; + } + + /*! ZSTD_adjustCParams() : + * optimize params for a given `srcSize` and `dictSize`. + * `srcSize` can be unknown, in which case use ZSTD_CONTENTSIZE_UNKNOWN. + * `dictSize` must be `0` when there is no dictionary. + * cPar can be invalid : all parameters will be clamped within valid range in the @return struct. + * This function never fails (wide contract) */ + public static ZSTD_compressionParameters ZSTD_adjustCParams( + ZSTD_compressionParameters cPar, + ulong srcSize, + nuint dictSize + ) + { + cPar = ZSTD_clampCParams(cPar); + if (srcSize == 0) + srcSize = unchecked(0UL - 1); + return ZSTD_adjustCParams_internal( + cPar, + srcSize, + dictSize, + ZSTD_CParamMode_e.ZSTD_cpm_unknown, + ZSTD_paramSwitch_e.ZSTD_ps_auto + ); + } + + private static void ZSTD_overrideCParams( + ZSTD_compressionParameters* cParams, + ZSTD_compressionParameters* overrides + ) + { + if (overrides->windowLog != 0) + cParams->windowLog = overrides->windowLog; + if (overrides->hashLog != 0) + cParams->hashLog = overrides->hashLog; + if (overrides->chainLog != 0) + cParams->chainLog = overrides->chainLog; + if (overrides->searchLog != 0) + cParams->searchLog = overrides->searchLog; + if (overrides->minMatch != 0) + cParams->minMatch = overrides->minMatch; + if (overrides->targetLength != 0) + cParams->targetLength = overrides->targetLength; + if (overrides->strategy != default) + cParams->strategy = overrides->strategy; + } + + /* ZSTD_getCParamsFromCCtxParams() : + * cParams are built depending on compressionLevel, src size hints, + * LDM and manually set compression parameters. + * Note: srcSizeHint == 0 means 0! + */ + private static ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams( + ZSTD_CCtx_params_s* CCtxParams, + ulong srcSizeHint, + nuint dictSize, + ZSTD_CParamMode_e mode + ) + { + ZSTD_compressionParameters cParams; + if (srcSizeHint == unchecked(0UL - 1) && CCtxParams->srcSizeHint > 0) + { + assert(CCtxParams->srcSizeHint >= 0); + srcSizeHint = (ulong)CCtxParams->srcSizeHint; + } + + cParams = ZSTD_getCParams_internal( + CCtxParams->compressionLevel, + srcSizeHint, + dictSize, + mode + ); + if (CCtxParams->ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable) + cParams.windowLog = 27; + ZSTD_overrideCParams(&cParams, &CCtxParams->cParams); + assert(ZSTD_checkCParams(cParams) == 0); + return ZSTD_adjustCParams_internal( + cParams, + srcSizeHint, + dictSize, + mode, + CCtxParams->useRowMatchFinder + ); + } + + private static nuint ZSTD_sizeof_matchState( + ZSTD_compressionParameters* cParams, + ZSTD_paramSwitch_e useRowMatchFinder, + int enableDedicatedDictSearch, + uint forCCtx + ) + { + /* chain table size should be 0 for fast or row-hash strategies */ + nuint chainSize = + ZSTD_allocateChainTable( + cParams->strategy, + useRowMatchFinder, + enableDedicatedDictSearch != 0 && forCCtx == 0 ? 1U : 0U + ) != 0 + ? (nuint)1 << (int)cParams->chainLog + : 0; + nuint hSize = (nuint)1 << (int)cParams->hashLog; + uint hashLog3 = + forCCtx != 0 && cParams->minMatch == 3 + ? 17 < cParams->windowLog + ? 17 + : cParams->windowLog + : 0; + nuint h3Size = hashLog3 != 0 ? (nuint)1 << (int)hashLog3 : 0; + /* We don't use ZSTD_cwksp_alloc_size() here because the tables aren't + * surrounded by redzones in ASAN. */ + nuint tableSpace = chainSize * sizeof(uint) + hSize * sizeof(uint) + h3Size * sizeof(uint); + nuint optPotentialSpace = + ZSTD_cwksp_aligned64_alloc_size((52 + 1) * sizeof(uint)) + + ZSTD_cwksp_aligned64_alloc_size((35 + 1) * sizeof(uint)) + + ZSTD_cwksp_aligned64_alloc_size((31 + 1) * sizeof(uint)) + + ZSTD_cwksp_aligned64_alloc_size((1 << 8) * sizeof(uint)) + + ZSTD_cwksp_aligned64_alloc_size((nuint)(((1 << 12) + 3) * sizeof(ZSTD_match_t))) + + ZSTD_cwksp_aligned64_alloc_size((nuint)(((1 << 12) + 3) * sizeof(ZSTD_optimal_t))); + nuint lazyAdditionalSpace = + ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder) != 0 + ? ZSTD_cwksp_aligned64_alloc_size(hSize) + : 0; + nuint optSpace = + forCCtx != 0 && cParams->strategy >= ZSTD_strategy.ZSTD_btopt ? optPotentialSpace : 0; + nuint slackSpace = ZSTD_cwksp_slack_space_required(); + assert(useRowMatchFinder != ZSTD_paramSwitch_e.ZSTD_ps_auto); + return tableSpace + optSpace + slackSpace + lazyAdditionalSpace; + } + + /* Helper function for calculating memory requirements. + * Gives a tighter bound than ZSTD_sequenceBound() by taking minMatch into account. */ + private static nuint ZSTD_maxNbSeq(nuint blockSize, uint minMatch, int useSequenceProducer) + { + uint divider = (uint)(minMatch == 3 || useSequenceProducer != 0 ? 3 : 4); + return blockSize / divider; + } + + private static nuint ZSTD_estimateCCtxSize_usingCCtxParams_internal( + ZSTD_compressionParameters* cParams, + ldmParams_t* ldmParams, + int isStatic, + ZSTD_paramSwitch_e useRowMatchFinder, + nuint buffInSize, + nuint buffOutSize, + ulong pledgedSrcSize, + int useSequenceProducer, + nuint maxBlockSize + ) + { + nuint windowSize = (nuint)( + 1UL << (int)cParams->windowLog <= 1UL ? 1UL + : 1UL << (int)cParams->windowLog <= pledgedSrcSize ? 1UL << (int)cParams->windowLog + : pledgedSrcSize + ); + nuint blockSize = + ZSTD_resolveMaxBlockSize(maxBlockSize) < windowSize + ? ZSTD_resolveMaxBlockSize(maxBlockSize) + : windowSize; + nuint maxNbSeq = ZSTD_maxNbSeq(blockSize, cParams->minMatch, useSequenceProducer); + nuint tokenSpace = + ZSTD_cwksp_alloc_size(32 + blockSize) + + ZSTD_cwksp_aligned64_alloc_size(maxNbSeq * (nuint)sizeof(SeqDef_s)) + + 3 * ZSTD_cwksp_alloc_size(maxNbSeq * sizeof(byte)); + nuint tmpWorkSpace = ZSTD_cwksp_alloc_size( + (8 << 10) + 512 + sizeof(uint) * (52 + 2) > 8208 + ? (8 << 10) + 512 + sizeof(uint) * (52 + 2) + : 8208 + ); + nuint blockStateSpace = + 2 * ZSTD_cwksp_alloc_size((nuint)sizeof(ZSTD_compressedBlockState_t)); + /* enableDedicatedDictSearch */ + nuint matchStateSize = ZSTD_sizeof_matchState(cParams, useRowMatchFinder, 0, 1); + nuint ldmSpace = ZSTD_ldm_getTableSize(*ldmParams); + nuint maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(*ldmParams, blockSize); + nuint ldmSeqSpace = + ldmParams->enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable + ? ZSTD_cwksp_aligned64_alloc_size(maxNbLdmSeq * (nuint)sizeof(rawSeq)) + : 0; + nuint bufferSpace = ZSTD_cwksp_alloc_size(buffInSize) + ZSTD_cwksp_alloc_size(buffOutSize); + nuint cctxSpace = isStatic != 0 ? ZSTD_cwksp_alloc_size((nuint)sizeof(ZSTD_CCtx_s)) : 0; + nuint maxNbExternalSeq = ZSTD_sequenceBound(blockSize); + nuint externalSeqSpace = + useSequenceProducer != 0 + ? ZSTD_cwksp_aligned64_alloc_size(maxNbExternalSeq * (nuint)sizeof(ZSTD_Sequence)) + : 0; + nuint neededSpace = + cctxSpace + + tmpWorkSpace + + blockStateSpace + + ldmSpace + + ldmSeqSpace + + matchStateSize + + tokenSpace + + bufferSpace + + externalSeqSpace; + return neededSpace; + } + + public static nuint ZSTD_estimateCCtxSize_usingCCtxParams(ZSTD_CCtx_params_s* @params) + { + ZSTD_compressionParameters cParams = ZSTD_getCParamsFromCCtxParams( + @params, + unchecked(0UL - 1), + 0, + ZSTD_CParamMode_e.ZSTD_cpm_noAttachDict + ); + ZSTD_paramSwitch_e useRowMatchFinder = ZSTD_resolveRowMatchFinderMode( + @params->useRowMatchFinder, + &cParams + ); + if (@params->nbWorkers > 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + + return ZSTD_estimateCCtxSize_usingCCtxParams_internal( + &cParams, + &@params->ldmParams, + 1, + useRowMatchFinder, + 0, + 0, + unchecked(0UL - 1), + ZSTD_hasExtSeqProd(@params), + @params->maxBlockSize + ); + } + + public static nuint ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams) + { + ZSTD_CCtx_params_s initialParams = ZSTD_makeCCtxParamsFromCParams(cParams); + if (ZSTD_rowMatchFinderSupported(cParams.strategy) != 0) + { + /* Pick bigger of not using and using row-based matchfinder for greedy and lazy strategies */ + nuint noRowCCtxSize; + nuint rowCCtxSize; + initialParams.useRowMatchFinder = ZSTD_paramSwitch_e.ZSTD_ps_disable; + noRowCCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams); + initialParams.useRowMatchFinder = ZSTD_paramSwitch_e.ZSTD_ps_enable; + rowCCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams); + return noRowCCtxSize > rowCCtxSize ? noRowCCtxSize : rowCCtxSize; + } + else + { + return ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams); + } + } + +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_srcSizeTiers => + new ulong[4] { 16 * (1 << 10), 128 * (1 << 10), 256 * (1 << 10), unchecked(0UL - 1) }; + private static ulong* srcSizeTiers => + (ulong*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_srcSizeTiers) + ); +#else + + private static readonly ulong* srcSizeTiers = GetArrayPointer( + new ulong[4] + { + (ulong)(16 * (1 << 10)), + (ulong)(128 * (1 << 10)), + (ulong)(256 * (1 << 10)), + (unchecked(0UL - 1)), + } + ); +#endif + + private static nuint ZSTD_estimateCCtxSize_internal(int compressionLevel) + { + int tier = 0; + nuint largestSize = 0; + for (; tier < 4; ++tier) + { + /* Choose the set of cParams for a given level across all srcSizes that give the largest cctxSize */ + ZSTD_compressionParameters cParams = ZSTD_getCParams_internal( + compressionLevel, + srcSizeTiers[tier], + 0, + ZSTD_CParamMode_e.ZSTD_cpm_noAttachDict + ); + largestSize = + ZSTD_estimateCCtxSize_usingCParams(cParams) > largestSize + ? ZSTD_estimateCCtxSize_usingCParams(cParams) + : largestSize; + } + + return largestSize; + } + + /*! ZSTD_estimate*() : + * These functions make it possible to estimate memory usage + * of a future {D,C}Ctx, before its creation. + * This is useful in combination with ZSTD_initStatic(), + * which makes it possible to employ a static buffer for ZSTD_CCtx* state. + * + * ZSTD_estimateCCtxSize() will provide a memory budget large enough + * to compress data of any size using one-shot compression ZSTD_compressCCtx() or ZSTD_compress2() + * associated with any compression level up to max specified one. + * The estimate will assume the input may be arbitrarily large, + * which is the worst case. + * + * Note that the size estimation is specific for one-shot compression, + * it is not valid for streaming (see ZSTD_estimateCStreamSize*()) + * nor other potential ways of using a ZSTD_CCtx* state. + * + * When srcSize can be bound by a known and rather "small" value, + * this knowledge can be used to provide a tighter budget estimation + * because the ZSTD_CCtx* state will need less memory for small inputs. + * This tighter estimation can be provided by employing more advanced functions + * ZSTD_estimateCCtxSize_usingCParams(), which can be used in tandem with ZSTD_getCParams(), + * and ZSTD_estimateCCtxSize_usingCCtxParams(), which can be used in tandem with ZSTD_CCtxParams_setParameter(). + * Both can be used to estimate memory using custom compression parameters and arbitrary srcSize limits. + * + * Note : only single-threaded compression is supported. + * ZSTD_estimateCCtxSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1. + */ + public static nuint ZSTD_estimateCCtxSize(int compressionLevel) + { + int level; + nuint memBudget = 0; + for ( + level = compressionLevel < 1 ? compressionLevel : 1; + level <= compressionLevel; + level++ + ) + { + /* Ensure monotonically increasing memory usage as compression level increases */ + nuint newMB = ZSTD_estimateCCtxSize_internal(level); + if (newMB > memBudget) + memBudget = newMB; + } + + return memBudget; + } + + public static nuint ZSTD_estimateCStreamSize_usingCCtxParams(ZSTD_CCtx_params_s* @params) + { + if (@params->nbWorkers > 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + + { + ZSTD_compressionParameters cParams = ZSTD_getCParamsFromCCtxParams( + @params, + unchecked(0UL - 1), + 0, + ZSTD_CParamMode_e.ZSTD_cpm_noAttachDict + ); + nuint blockSize = + ZSTD_resolveMaxBlockSize(@params->maxBlockSize) < (nuint)1 << (int)cParams.windowLog + ? ZSTD_resolveMaxBlockSize(@params->maxBlockSize) + : (nuint)1 << (int)cParams.windowLog; + nuint inBuffSize = + @params->inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_buffered + ? ((nuint)1 << (int)cParams.windowLog) + blockSize + : 0; + nuint outBuffSize = + @params->outBufferMode == ZSTD_bufferMode_e.ZSTD_bm_buffered + ? ZSTD_compressBound(blockSize) + 1 + : 0; + ZSTD_paramSwitch_e useRowMatchFinder = ZSTD_resolveRowMatchFinderMode( + @params->useRowMatchFinder, + &@params->cParams + ); + return ZSTD_estimateCCtxSize_usingCCtxParams_internal( + &cParams, + &@params->ldmParams, + 1, + useRowMatchFinder, + inBuffSize, + outBuffSize, + unchecked(0UL - 1), + ZSTD_hasExtSeqProd(@params), + @params->maxBlockSize + ); + } + } + + public static nuint ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams) + { + ZSTD_CCtx_params_s initialParams = ZSTD_makeCCtxParamsFromCParams(cParams); + if (ZSTD_rowMatchFinderSupported(cParams.strategy) != 0) + { + /* Pick bigger of not using and using row-based matchfinder for greedy and lazy strategies */ + nuint noRowCCtxSize; + nuint rowCCtxSize; + initialParams.useRowMatchFinder = ZSTD_paramSwitch_e.ZSTD_ps_disable; + noRowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams); + initialParams.useRowMatchFinder = ZSTD_paramSwitch_e.ZSTD_ps_enable; + rowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams); + return noRowCCtxSize > rowCCtxSize ? noRowCCtxSize : rowCCtxSize; + } + else + { + return ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams); + } + } + + private static nuint ZSTD_estimateCStreamSize_internal(int compressionLevel) + { + ZSTD_compressionParameters cParams = ZSTD_getCParams_internal( + compressionLevel, + unchecked(0UL - 1), + 0, + ZSTD_CParamMode_e.ZSTD_cpm_noAttachDict + ); + return ZSTD_estimateCStreamSize_usingCParams(cParams); + } + + /*! ZSTD_estimateCStreamSize() : + * ZSTD_estimateCStreamSize() will provide a memory budget large enough for streaming compression + * using any compression level up to the max specified one. + * It will also consider src size to be arbitrarily "large", which is a worst case scenario. + * If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation. + * ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel. + * ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1. + * Note : CStream size estimation is only correct for single-threaded compression. + * ZSTD_estimateCStreamSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1. + * Note 2 : ZSTD_estimateCStreamSize* functions are not compatible with the Block-Level Sequence Producer API at this time. + * Size estimates assume that no external sequence producer is registered. + * + * ZSTD_DStream memory budget depends on frame's window Size. + * This information can be passed manually, using ZSTD_estimateDStreamSize, + * or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame(); + * Any frame requesting a window size larger than max specified one will be rejected. + * Note : if streaming is init with function ZSTD_init?Stream_usingDict(), + * an internal ?Dict will be created, which additional size is not estimated here. + * In this case, get total size by adding ZSTD_estimate?DictSize + */ + public static nuint ZSTD_estimateCStreamSize(int compressionLevel) + { + int level; + nuint memBudget = 0; + for ( + level = compressionLevel < 1 ? compressionLevel : 1; + level <= compressionLevel; + level++ + ) + { + nuint newMB = ZSTD_estimateCStreamSize_internal(level); + if (newMB > memBudget) + memBudget = newMB; + } + + return memBudget; + } + + /* ZSTD_getFrameProgression(): + * tells how much data has been consumed (input) and produced (output) for current frame. + * able to count progression inside worker threads (non-blocking mode). + */ + public static ZSTD_frameProgression ZSTD_getFrameProgression(ZSTD_CCtx_s* cctx) + { + if (cctx->appliedParams.nbWorkers > 0) + { + return ZSTDMT_getFrameProgression(cctx->mtctx); + } + + { + ZSTD_frameProgression fp; + nuint buffered = cctx->inBuff == null ? 0 : cctx->inBuffPos - cctx->inToCompress; +#if DEBUG + if (buffered != 0) + assert(cctx->inBuffPos >= cctx->inToCompress); +#endif + assert(buffered <= 1 << 17); + fp.ingested = cctx->consumedSrcSize + buffered; + fp.consumed = cctx->consumedSrcSize; + fp.produced = cctx->producedCSize; + fp.flushed = cctx->producedCSize; + fp.currentJobID = 0; + fp.nbActiveWorkers = 0; + return fp; + } + } + + /*! ZSTD_toFlushNow() + * Only useful for multithreading scenarios currently (nbWorkers >= 1). + */ + public static nuint ZSTD_toFlushNow(ZSTD_CCtx_s* cctx) + { + if (cctx->appliedParams.nbWorkers > 0) + { + return ZSTDMT_toFlushNow(cctx->mtctx); + } + + return 0; + } + + [Conditional("DEBUG")] + private static void ZSTD_assertEqualCParams( + ZSTD_compressionParameters cParams1, + ZSTD_compressionParameters cParams2 + ) + { + assert(cParams1.windowLog == cParams2.windowLog); + assert(cParams1.chainLog == cParams2.chainLog); + assert(cParams1.hashLog == cParams2.hashLog); + assert(cParams1.searchLog == cParams2.searchLog); + assert(cParams1.minMatch == cParams2.minMatch); + assert(cParams1.targetLength == cParams2.targetLength); + assert(cParams1.strategy == cParams2.strategy); + } + + private static void ZSTD_reset_compressedBlockState(ZSTD_compressedBlockState_t* bs) + { + int i; + for (i = 0; i < 3; ++i) + bs->rep[i] = repStartValue[i]; + bs->entropy.huf.repeatMode = HUF_repeat.HUF_repeat_none; + bs->entropy.fse.offcode_repeatMode = FSE_repeat.FSE_repeat_none; + bs->entropy.fse.matchlength_repeatMode = FSE_repeat.FSE_repeat_none; + bs->entropy.fse.litlength_repeatMode = FSE_repeat.FSE_repeat_none; + } + + /*! ZSTD_invalidateMatchState() + * Invalidate all the matches in the match finder tables. + * Requires nextSrc and base to be set (can be NULL). + */ + private static void ZSTD_invalidateMatchState(ZSTD_MatchState_t* ms) + { + ZSTD_window_clear(&ms->window); + ms->nextToUpdate = ms->window.dictLimit; + ms->loadedDictEnd = 0; + ms->opt.litLengthSum = 0; + ms->dictMatchState = null; + } + + /* Mixes bits in a 64 bits in a value, based on XXH3_rrmxmx */ + private static ulong ZSTD_bitmix(ulong val, ulong len) + { + val ^= BitOperations.RotateRight(val, 49) ^ BitOperations.RotateRight(val, 24); + val *= 0x9FB21C651E98DF25UL; + val ^= (val >> 35) + len; + val *= 0x9FB21C651E98DF25UL; + return val ^ val >> 28; + } + + /* Mixes in the hashSalt and hashSaltEntropy to create a new hashSalt */ + private static void ZSTD_advanceHashSalt(ZSTD_MatchState_t* ms) + { + ms->hashSalt = ZSTD_bitmix(ms->hashSalt, 8) ^ ZSTD_bitmix(ms->hashSaltEntropy, 4); + } + + private static nuint ZSTD_reset_matchState( + ZSTD_MatchState_t* ms, + ZSTD_cwksp* ws, + ZSTD_compressionParameters* cParams, + ZSTD_paramSwitch_e useRowMatchFinder, + ZSTD_compResetPolicy_e crp, + ZSTD_indexResetPolicy_e forceResetIndex, + ZSTD_resetTarget_e forWho + ) + { + /* disable chain table allocation for fast or row-based strategies */ + nuint chainSize = + ZSTD_allocateChainTable( + cParams->strategy, + useRowMatchFinder, + ms->dedicatedDictSearch != 0 && forWho == ZSTD_resetTarget_e.ZSTD_resetTarget_CDict + ? 1U + : 0U + ) != 0 + ? (nuint)1 << (int)cParams->chainLog + : 0; + nuint hSize = (nuint)1 << (int)cParams->hashLog; + uint hashLog3 = + forWho == ZSTD_resetTarget_e.ZSTD_resetTarget_CCtx && cParams->minMatch == 3 + ? 17 < cParams->windowLog + ? 17 + : cParams->windowLog + : 0; + nuint h3Size = hashLog3 != 0 ? (nuint)1 << (int)hashLog3 : 0; + assert(useRowMatchFinder != ZSTD_paramSwitch_e.ZSTD_ps_auto); + if (forceResetIndex == ZSTD_indexResetPolicy_e.ZSTDirp_reset) + { + ZSTD_window_init(&ms->window); + ZSTD_cwksp_mark_tables_dirty(ws); + } + + ms->hashLog3 = hashLog3; + ms->lazySkipping = 0; + ZSTD_invalidateMatchState(ms); + assert(ZSTD_cwksp_reserve_failed(ws) == 0); + ZSTD_cwksp_clear_tables(ws); + ms->hashTable = (uint*)ZSTD_cwksp_reserve_table(ws, hSize * sizeof(uint)); + ms->chainTable = (uint*)ZSTD_cwksp_reserve_table(ws, chainSize * sizeof(uint)); + ms->hashTable3 = (uint*)ZSTD_cwksp_reserve_table(ws, h3Size * sizeof(uint)); + if (ZSTD_cwksp_reserve_failed(ws) != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + if (crp != ZSTD_compResetPolicy_e.ZSTDcrp_leaveDirty) + { + ZSTD_cwksp_clean_tables(ws); + } + + if (ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder) != 0) + { + /* Row match finder needs an additional table of hashes ("tags") */ + nuint tagTableSize = hSize; + if (forWho == ZSTD_resetTarget_e.ZSTD_resetTarget_CCtx) + { + ms->tagTable = (byte*)ZSTD_cwksp_reserve_aligned_init_once(ws, tagTableSize); + ZSTD_advanceHashSalt(ms); + } + else + { + ms->tagTable = (byte*)ZSTD_cwksp_reserve_aligned64(ws, tagTableSize); + memset(ms->tagTable, 0, (uint)tagTableSize); + ms->hashSalt = 0; + } + + { + uint rowLog = + cParams->searchLog <= 4 ? 4 + : cParams->searchLog <= 6 ? cParams->searchLog + : 6; + assert(cParams->hashLog >= rowLog); + ms->rowHashLog = cParams->hashLog - rowLog; + } + } + + if ( + forWho == ZSTD_resetTarget_e.ZSTD_resetTarget_CCtx + && cParams->strategy >= ZSTD_strategy.ZSTD_btopt + ) + { + ms->opt.litFreq = (uint*)ZSTD_cwksp_reserve_aligned64(ws, (1 << 8) * sizeof(uint)); + ms->opt.litLengthFreq = (uint*)ZSTD_cwksp_reserve_aligned64( + ws, + (35 + 1) * sizeof(uint) + ); + ms->opt.matchLengthFreq = (uint*)ZSTD_cwksp_reserve_aligned64( + ws, + (52 + 1) * sizeof(uint) + ); + ms->opt.offCodeFreq = (uint*)ZSTD_cwksp_reserve_aligned64(ws, (31 + 1) * sizeof(uint)); + ms->opt.matchTable = (ZSTD_match_t*)ZSTD_cwksp_reserve_aligned64( + ws, + (nuint)(((1 << 12) + 3) * sizeof(ZSTD_match_t)) + ); + ms->opt.priceTable = (ZSTD_optimal_t*)ZSTD_cwksp_reserve_aligned64( + ws, + (nuint)(((1 << 12) + 3) * sizeof(ZSTD_optimal_t)) + ); + } + + ms->cParams = *cParams; + if (ZSTD_cwksp_reserve_failed(ws) != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + return 0; + } + + private static int ZSTD_indexTooCloseToMax(ZSTD_window_t w) + { + return + (nuint)(w.nextSrc - w.@base) + > (MEM_64bits ? 3500U * (1 << 20) : 2000U * (1 << 20)) - 16 * (1 << 20) + ? 1 + : 0; + } + + /** ZSTD_dictTooBig(): + * When dictionaries are larger than ZSTD_CHUNKSIZE_MAX they can't be loaded in + * one go generically. So we ensure that in that case we reset the tables to zero, + * so that we can load as much of the dictionary as possible. + */ + private static int ZSTD_dictTooBig(nuint loadedDictSize) + { + return + loadedDictSize + > unchecked((uint)-1) - (MEM_64bits ? 3500U * (1 << 20) : 2000U * (1 << 20)) + ? 1 + : 0; + } + + /*! ZSTD_resetCCtx_internal() : + * @param loadedDictSize The size of the dictionary to be loaded + * into the context, if any. If no dictionary is used, or the + * dictionary is being attached / copied, then pass 0. + * note : `params` are assumed fully validated at this stage. + */ + private static nuint ZSTD_resetCCtx_internal( + ZSTD_CCtx_s* zc, + ZSTD_CCtx_params_s* @params, + ulong pledgedSrcSize, + nuint loadedDictSize, + ZSTD_compResetPolicy_e crp, + ZSTD_buffered_policy_e zbuff + ) + { + ZSTD_cwksp* ws = &zc->workspace; + assert(!ERR_isError(ZSTD_checkCParams(@params->cParams))); + zc->isFirstBlock = 1; + zc->appliedParams = *@params; + @params = &zc->appliedParams; + assert(@params->useRowMatchFinder != ZSTD_paramSwitch_e.ZSTD_ps_auto); + assert(@params->postBlockSplitter != ZSTD_paramSwitch_e.ZSTD_ps_auto); + assert(@params->ldmParams.enableLdm != ZSTD_paramSwitch_e.ZSTD_ps_auto); + assert(@params->maxBlockSize != 0); + if (@params->ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable) + { + ZSTD_ldm_adjustParameters(&zc->appliedParams.ldmParams, &@params->cParams); + assert(@params->ldmParams.hashLog >= @params->ldmParams.bucketSizeLog); + assert(@params->ldmParams.hashRateLog < 32); + } + + { + nuint windowSize = + 1 + > (nuint)( + (ulong)1 << (int)@params->cParams.windowLog < pledgedSrcSize + ? (ulong)1 << (int)@params->cParams.windowLog + : pledgedSrcSize + ) + ? 1 + : (nuint)( + (ulong)1 << (int)@params->cParams.windowLog < pledgedSrcSize + ? (ulong)1 << (int)@params->cParams.windowLog + : pledgedSrcSize + ); + nuint blockSize = + @params->maxBlockSize < windowSize ? @params->maxBlockSize : windowSize; + nuint maxNbSeq = ZSTD_maxNbSeq( + blockSize, + @params->cParams.minMatch, + ZSTD_hasExtSeqProd(@params) + ); + nuint buffOutSize = + zbuff == ZSTD_buffered_policy_e.ZSTDb_buffered + && @params->outBufferMode == ZSTD_bufferMode_e.ZSTD_bm_buffered + ? ZSTD_compressBound(blockSize) + 1 + : 0; + nuint buffInSize = + zbuff == ZSTD_buffered_policy_e.ZSTDb_buffered + && @params->inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_buffered + ? windowSize + blockSize + : 0; + nuint maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(@params->ldmParams, blockSize); + int indexTooClose = ZSTD_indexTooCloseToMax(zc->blockState.matchState.window); + int dictTooBig = ZSTD_dictTooBig(loadedDictSize); + ZSTD_indexResetPolicy_e needsIndexReset = + indexTooClose != 0 || dictTooBig != 0 || zc->initialized == 0 + ? ZSTD_indexResetPolicy_e.ZSTDirp_reset + : ZSTD_indexResetPolicy_e.ZSTDirp_continue; + nuint neededSpace = ZSTD_estimateCCtxSize_usingCCtxParams_internal( + &@params->cParams, + &@params->ldmParams, + zc->staticSize != 0 ? 1 : 0, + @params->useRowMatchFinder, + buffInSize, + buffOutSize, + pledgedSrcSize, + ZSTD_hasExtSeqProd(@params), + @params->maxBlockSize + ); + { + nuint err_code = neededSpace; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (zc->staticSize == 0) + ZSTD_cwksp_bump_oversized_duration(ws, 0); + { + int workspaceTooSmall = ZSTD_cwksp_sizeof(ws) < neededSpace ? 1 : 0; + int workspaceWasteful = ZSTD_cwksp_check_wasteful(ws, neededSpace); + int resizeWorkspace = workspaceTooSmall != 0 || workspaceWasteful != 0 ? 1 : 0; + if (resizeWorkspace != 0) + { + if (zc->staticSize != 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation) + ); + } + + needsIndexReset = ZSTD_indexResetPolicy_e.ZSTDirp_reset; + ZSTD_cwksp_free(ws, zc->customMem); + { + nuint err_code = ZSTD_cwksp_create(ws, neededSpace, zc->customMem); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert( + ZSTD_cwksp_check_available( + ws, + (nuint)(2 * sizeof(ZSTD_compressedBlockState_t)) + ) != 0 + ); + zc->blockState.prevCBlock = + (ZSTD_compressedBlockState_t*)ZSTD_cwksp_reserve_object( + ws, + (nuint)sizeof(ZSTD_compressedBlockState_t) + ); + if (zc->blockState.prevCBlock == null) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation) + ); + } + + zc->blockState.nextCBlock = + (ZSTD_compressedBlockState_t*)ZSTD_cwksp_reserve_object( + ws, + (nuint)sizeof(ZSTD_compressedBlockState_t) + ); + if (zc->blockState.nextCBlock == null) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation) + ); + } + + zc->tmpWorkspace = ZSTD_cwksp_reserve_object( + ws, + (8 << 10) + 512 + sizeof(uint) * (52 + 2) > 8208 + ? (8 << 10) + 512 + sizeof(uint) * (52 + 2) + : 8208 + ); + if (zc->tmpWorkspace == null) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation) + ); + } + + zc->tmpWkspSize = + (8 << 10) + 512 + sizeof(uint) * (52 + 2) > 8208 + ? (8 << 10) + 512 + sizeof(uint) * (52 + 2) + : 8208; + } + } + + ZSTD_cwksp_clear(ws); + zc->blockState.matchState.cParams = @params->cParams; + zc->blockState.matchState.prefetchCDictTables = + @params->prefetchCDictTables == ZSTD_paramSwitch_e.ZSTD_ps_enable ? 1 : 0; + zc->pledgedSrcSizePlusOne = pledgedSrcSize + 1; + zc->consumedSrcSize = 0; + zc->producedCSize = 0; + if (pledgedSrcSize == unchecked(0UL - 1)) + zc->appliedParams.fParams.contentSizeFlag = 0; + zc->blockSizeMax = blockSize; + ZSTD_XXH64_reset(&zc->xxhState, 0); + zc->stage = ZSTD_compressionStage_e.ZSTDcs_init; + zc->dictID = 0; + zc->dictContentSize = 0; + ZSTD_reset_compressedBlockState(zc->blockState.prevCBlock); + { + nuint err_code = ZSTD_reset_matchState( + &zc->blockState.matchState, + ws, + &@params->cParams, + @params->useRowMatchFinder, + crp, + needsIndexReset, + ZSTD_resetTarget_e.ZSTD_resetTarget_CCtx + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + zc->seqStore.sequencesStart = (SeqDef_s*)ZSTD_cwksp_reserve_aligned64( + ws, + maxNbSeq * (nuint)sizeof(SeqDef_s) + ); + if (@params->ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable) + { + /* TODO: avoid memset? */ + nuint ldmHSize = (nuint)1 << (int)@params->ldmParams.hashLog; + zc->ldmState.hashTable = (ldmEntry_t*)ZSTD_cwksp_reserve_aligned64( + ws, + ldmHSize * (nuint)sizeof(ldmEntry_t) + ); + memset(zc->ldmState.hashTable, 0, (uint)(ldmHSize * (nuint)sizeof(ldmEntry_t))); + zc->ldmSequences = (rawSeq*)ZSTD_cwksp_reserve_aligned64( + ws, + maxNbLdmSeq * (nuint)sizeof(rawSeq) + ); + zc->maxNbLdmSequences = maxNbLdmSeq; + ZSTD_window_init(&zc->ldmState.window); + zc->ldmState.loadedDictEnd = 0; + } + + if (ZSTD_hasExtSeqProd(@params) != 0) + { + nuint maxNbExternalSeq = ZSTD_sequenceBound(blockSize); + zc->extSeqBufCapacity = maxNbExternalSeq; + zc->extSeqBuf = (ZSTD_Sequence*)ZSTD_cwksp_reserve_aligned64( + ws, + maxNbExternalSeq * (nuint)sizeof(ZSTD_Sequence) + ); + } + + zc->seqStore.litStart = ZSTD_cwksp_reserve_buffer(ws, blockSize + 32); + zc->seqStore.maxNbLit = blockSize; + zc->bufferedPolicy = zbuff; + zc->inBuffSize = buffInSize; + zc->inBuff = (sbyte*)ZSTD_cwksp_reserve_buffer(ws, buffInSize); + zc->outBuffSize = buffOutSize; + zc->outBuff = (sbyte*)ZSTD_cwksp_reserve_buffer(ws, buffOutSize); + if (@params->ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable) + { + /* TODO: avoid memset? */ + nuint numBuckets = + (nuint)1 + << (int)(@params->ldmParams.hashLog - @params->ldmParams.bucketSizeLog); + zc->ldmState.bucketOffsets = ZSTD_cwksp_reserve_buffer(ws, numBuckets); + memset(zc->ldmState.bucketOffsets, 0, (uint)numBuckets); + } + + ZSTD_referenceExternalSequences(zc, null, 0); + zc->seqStore.maxNbSeq = maxNbSeq; + zc->seqStore.llCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(byte)); + zc->seqStore.mlCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(byte)); + zc->seqStore.ofCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(byte)); + assert(ZSTD_cwksp_estimated_space_within_bounds(ws, neededSpace) != 0); + zc->initialized = 1; + return 0; + } + } + + /* ZSTD_invalidateRepCodes() : + * ensures next compression will not use repcodes from previous block. + * Note : only works with regular variant; + * do not use with extDict variant ! */ + private static void ZSTD_invalidateRepCodes(ZSTD_CCtx_s* cctx) + { + int i; + for (i = 0; i < 3; i++) + cctx->blockState.prevCBlock->rep[i] = 0; + assert(ZSTD_window_hasExtDict(cctx->blockState.matchState.window) == 0); + } + + private static readonly nuint* attachDictSizeCutoffs = GetArrayPointer( + new nuint[10] + { + 8 * (1 << 10), + 8 * (1 << 10), + 16 * (1 << 10), + 32 * (1 << 10), + 32 * (1 << 10), + 32 * (1 << 10), + 32 * (1 << 10), + 32 * (1 << 10), + 8 * (1 << 10), + 8 * (1 << 10), + } + ); + + private static int ZSTD_shouldAttachDict( + ZSTD_CDict_s* cdict, + ZSTD_CCtx_params_s* @params, + ulong pledgedSrcSize + ) + { + nuint cutoff = attachDictSizeCutoffs[(int)cdict->matchState.cParams.strategy]; + int dedicatedDictSearch = cdict->matchState.dedicatedDictSearch; + return + dedicatedDictSearch != 0 + || ( + pledgedSrcSize <= cutoff + || pledgedSrcSize == unchecked(0UL - 1) + || @params->attachDictPref == ZSTD_dictAttachPref_e.ZSTD_dictForceAttach + ) + && @params->attachDictPref != ZSTD_dictAttachPref_e.ZSTD_dictForceCopy + && @params->forceWindow == 0 + ? 1 + : 0; + } + + private static nuint ZSTD_resetCCtx_byAttachingCDict( + ZSTD_CCtx_s* cctx, + ZSTD_CDict_s* cdict, + ZSTD_CCtx_params_s @params, + ulong pledgedSrcSize, + ZSTD_buffered_policy_e zbuff + ) + { + { + ZSTD_compressionParameters adjusted_cdict_cParams = cdict->matchState.cParams; + uint windowLog = @params.cParams.windowLog; + assert(windowLog != 0); + if (cdict->matchState.dedicatedDictSearch != 0) + { + ZSTD_dedicatedDictSearch_revertCParams(&adjusted_cdict_cParams); + } + + @params.cParams = ZSTD_adjustCParams_internal( + adjusted_cdict_cParams, + pledgedSrcSize, + cdict->dictContentSize, + ZSTD_CParamMode_e.ZSTD_cpm_attachDict, + @params.useRowMatchFinder + ); + @params.cParams.windowLog = windowLog; + @params.useRowMatchFinder = cdict->useRowMatchFinder; + { + nuint err_code = ZSTD_resetCCtx_internal( + cctx, + &@params, + pledgedSrcSize, + 0, + ZSTD_compResetPolicy_e.ZSTDcrp_makeClean, + zbuff + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(cctx->appliedParams.cParams.strategy == adjusted_cdict_cParams.strategy); + } + + { + uint cdictEnd = (uint)( + cdict->matchState.window.nextSrc - cdict->matchState.window.@base + ); + uint cdictLen = cdictEnd - cdict->matchState.window.dictLimit; + if (cdictLen != 0) + { + cctx->blockState.matchState.dictMatchState = &cdict->matchState; + if (cctx->blockState.matchState.window.dictLimit < cdictEnd) + { + cctx->blockState.matchState.window.nextSrc = + cctx->blockState.matchState.window.@base + cdictEnd; + ZSTD_window_clear(&cctx->blockState.matchState.window); + } + + cctx->blockState.matchState.loadedDictEnd = cctx->blockState + .matchState + .window + .dictLimit; + } + } + + cctx->dictID = cdict->dictID; + cctx->dictContentSize = cdict->dictContentSize; + memcpy( + cctx->blockState.prevCBlock, + &cdict->cBlockState, + (uint)sizeof(ZSTD_compressedBlockState_t) + ); + return 0; + } + + private static void ZSTD_copyCDictTableIntoCCtx( + uint* dst, + uint* src, + nuint tableSize, + ZSTD_compressionParameters* cParams + ) + { + if (ZSTD_CDictIndicesAreTagged(cParams) != 0) + { + /* Remove tags from the CDict table if they are present. + * See docs on "short cache" in zstd_compress_internal.h for context. */ + nuint i; + for (i = 0; i < tableSize; i++) + { + uint taggedIndex = src[i]; + uint index = taggedIndex >> 8; + dst[i] = index; + } + } + else + { + memcpy(dst, src, (uint)(tableSize * sizeof(uint))); + } + } + + private static nuint ZSTD_resetCCtx_byCopyingCDict( + ZSTD_CCtx_s* cctx, + ZSTD_CDict_s* cdict, + ZSTD_CCtx_params_s @params, + ulong pledgedSrcSize, + ZSTD_buffered_policy_e zbuff + ) + { + ZSTD_compressionParameters* cdict_cParams = &cdict->matchState.cParams; + assert(cdict->matchState.dedicatedDictSearch == 0); + { + uint windowLog = @params.cParams.windowLog; + assert(windowLog != 0); + @params.cParams = *cdict_cParams; + @params.cParams.windowLog = windowLog; + @params.useRowMatchFinder = cdict->useRowMatchFinder; + { + nuint err_code = ZSTD_resetCCtx_internal( + cctx, + &@params, + pledgedSrcSize, + 0, + ZSTD_compResetPolicy_e.ZSTDcrp_leaveDirty, + zbuff + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(cctx->appliedParams.cParams.strategy == cdict_cParams->strategy); + assert(cctx->appliedParams.cParams.hashLog == cdict_cParams->hashLog); + assert(cctx->appliedParams.cParams.chainLog == cdict_cParams->chainLog); + } + + ZSTD_cwksp_mark_tables_dirty(&cctx->workspace); + assert(@params.useRowMatchFinder != ZSTD_paramSwitch_e.ZSTD_ps_auto); + { + /* DDS guaranteed disabled */ + nuint chainSize = + ZSTD_allocateChainTable(cdict_cParams->strategy, cdict->useRowMatchFinder, 0) != 0 + ? (nuint)1 << (int)cdict_cParams->chainLog + : 0; + nuint hSize = (nuint)1 << (int)cdict_cParams->hashLog; + ZSTD_copyCDictTableIntoCCtx( + cctx->blockState.matchState.hashTable, + cdict->matchState.hashTable, + hSize, + cdict_cParams + ); + if ( + ZSTD_allocateChainTable( + cctx->appliedParams.cParams.strategy, + cctx->appliedParams.useRowMatchFinder, + 0 + ) != 0 + ) + { + ZSTD_copyCDictTableIntoCCtx( + cctx->blockState.matchState.chainTable, + cdict->matchState.chainTable, + chainSize, + cdict_cParams + ); + } + + if (ZSTD_rowMatchFinderUsed(cdict_cParams->strategy, cdict->useRowMatchFinder) != 0) + { + nuint tagTableSize = hSize; + memcpy( + cctx->blockState.matchState.tagTable, + cdict->matchState.tagTable, + (uint)tagTableSize + ); + cctx->blockState.matchState.hashSalt = cdict->matchState.hashSalt; + } + } + + assert(cctx->blockState.matchState.hashLog3 <= 31); + { + uint h3log = cctx->blockState.matchState.hashLog3; + nuint h3Size = h3log != 0 ? (nuint)1 << (int)h3log : 0; + assert(cdict->matchState.hashLog3 == 0); + memset(cctx->blockState.matchState.hashTable3, 0, (uint)(h3Size * sizeof(uint))); + } + + ZSTD_cwksp_mark_tables_clean(&cctx->workspace); + { + ZSTD_MatchState_t* srcMatchState = &cdict->matchState; + ZSTD_MatchState_t* dstMatchState = &cctx->blockState.matchState; + dstMatchState->window = srcMatchState->window; + dstMatchState->nextToUpdate = srcMatchState->nextToUpdate; + dstMatchState->loadedDictEnd = srcMatchState->loadedDictEnd; + } + + cctx->dictID = cdict->dictID; + cctx->dictContentSize = cdict->dictContentSize; + memcpy( + cctx->blockState.prevCBlock, + &cdict->cBlockState, + (uint)sizeof(ZSTD_compressedBlockState_t) + ); + return 0; + } + + /* We have a choice between copying the dictionary context into the working + * context, or referencing the dictionary context from the working context + * in-place. We decide here which strategy to use. */ + private static nuint ZSTD_resetCCtx_usingCDict( + ZSTD_CCtx_s* cctx, + ZSTD_CDict_s* cdict, + ZSTD_CCtx_params_s* @params, + ulong pledgedSrcSize, + ZSTD_buffered_policy_e zbuff + ) + { + if (ZSTD_shouldAttachDict(cdict, @params, pledgedSrcSize) != 0) + { + return ZSTD_resetCCtx_byAttachingCDict(cctx, cdict, *@params, pledgedSrcSize, zbuff); + } + else + { + return ZSTD_resetCCtx_byCopyingCDict(cctx, cdict, *@params, pledgedSrcSize, zbuff); + } + } + + /*! ZSTD_copyCCtx_internal() : + * Duplicate an existing context `srcCCtx` into another one `dstCCtx`. + * Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()). + * The "context", in this case, refers to the hash and chain tables, + * entropy tables, and dictionary references. + * `windowLog` value is enforced if != 0, otherwise value is copied from srcCCtx. + * @return : 0, or an error code */ + private static nuint ZSTD_copyCCtx_internal( + ZSTD_CCtx_s* dstCCtx, + ZSTD_CCtx_s* srcCCtx, + ZSTD_frameParameters fParams, + ulong pledgedSrcSize, + ZSTD_buffered_policy_e zbuff + ) + { + if (srcCCtx->stage != ZSTD_compressionStage_e.ZSTDcs_init) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + memcpy(&dstCCtx->customMem, &srcCCtx->customMem, (uint)sizeof(ZSTD_customMem)); + { + ZSTD_CCtx_params_s @params = dstCCtx->requestedParams; + @params.cParams = srcCCtx->appliedParams.cParams; + assert(srcCCtx->appliedParams.useRowMatchFinder != ZSTD_paramSwitch_e.ZSTD_ps_auto); + assert(srcCCtx->appliedParams.postBlockSplitter != ZSTD_paramSwitch_e.ZSTD_ps_auto); + assert(srcCCtx->appliedParams.ldmParams.enableLdm != ZSTD_paramSwitch_e.ZSTD_ps_auto); + @params.useRowMatchFinder = srcCCtx->appliedParams.useRowMatchFinder; + @params.postBlockSplitter = srcCCtx->appliedParams.postBlockSplitter; + @params.ldmParams = srcCCtx->appliedParams.ldmParams; + @params.fParams = fParams; + @params.maxBlockSize = srcCCtx->appliedParams.maxBlockSize; + ZSTD_resetCCtx_internal( + dstCCtx, + &@params, + pledgedSrcSize, + 0, + ZSTD_compResetPolicy_e.ZSTDcrp_leaveDirty, + zbuff + ); + assert( + dstCCtx->appliedParams.cParams.windowLog == srcCCtx->appliedParams.cParams.windowLog + ); + assert( + dstCCtx->appliedParams.cParams.strategy == srcCCtx->appliedParams.cParams.strategy + ); + assert( + dstCCtx->appliedParams.cParams.hashLog == srcCCtx->appliedParams.cParams.hashLog + ); + assert( + dstCCtx->appliedParams.cParams.chainLog == srcCCtx->appliedParams.cParams.chainLog + ); + assert( + dstCCtx->blockState.matchState.hashLog3 == srcCCtx->blockState.matchState.hashLog3 + ); + } + + ZSTD_cwksp_mark_tables_dirty(&dstCCtx->workspace); + { + nuint chainSize = + ZSTD_allocateChainTable( + srcCCtx->appliedParams.cParams.strategy, + srcCCtx->appliedParams.useRowMatchFinder, + 0 + ) != 0 + ? (nuint)1 << (int)srcCCtx->appliedParams.cParams.chainLog + : 0; + nuint hSize = (nuint)1 << (int)srcCCtx->appliedParams.cParams.hashLog; + uint h3log = srcCCtx->blockState.matchState.hashLog3; + nuint h3Size = h3log != 0 ? (nuint)1 << (int)h3log : 0; + memcpy( + dstCCtx->blockState.matchState.hashTable, + srcCCtx->blockState.matchState.hashTable, + (uint)(hSize * sizeof(uint)) + ); + memcpy( + dstCCtx->blockState.matchState.chainTable, + srcCCtx->blockState.matchState.chainTable, + (uint)(chainSize * sizeof(uint)) + ); + memcpy( + dstCCtx->blockState.matchState.hashTable3, + srcCCtx->blockState.matchState.hashTable3, + (uint)(h3Size * sizeof(uint)) + ); + } + + ZSTD_cwksp_mark_tables_clean(&dstCCtx->workspace); + { + ZSTD_MatchState_t* srcMatchState = &srcCCtx->blockState.matchState; + ZSTD_MatchState_t* dstMatchState = &dstCCtx->blockState.matchState; + dstMatchState->window = srcMatchState->window; + dstMatchState->nextToUpdate = srcMatchState->nextToUpdate; + dstMatchState->loadedDictEnd = srcMatchState->loadedDictEnd; + } + + dstCCtx->dictID = srcCCtx->dictID; + dstCCtx->dictContentSize = srcCCtx->dictContentSize; + memcpy( + dstCCtx->blockState.prevCBlock, + srcCCtx->blockState.prevCBlock, + (uint)sizeof(ZSTD_compressedBlockState_t) + ); + return 0; + } + + /*! ZSTD_copyCCtx() : + * Duplicate an existing context `srcCCtx` into another one `dstCCtx`. + * Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()). + * pledgedSrcSize==0 means "unknown". + * @return : 0, or an error code */ + public static nuint ZSTD_copyCCtx( + ZSTD_CCtx_s* dstCCtx, + ZSTD_CCtx_s* srcCCtx, + ulong pledgedSrcSize + ) + { + /*content*/ + ZSTD_frameParameters fParams = new ZSTD_frameParameters + { + contentSizeFlag = 1, + checksumFlag = 0, + noDictIDFlag = 0, + }; + ZSTD_buffered_policy_e zbuff = srcCCtx->bufferedPolicy; + if (pledgedSrcSize == 0) + pledgedSrcSize = unchecked(0UL - 1); + fParams.contentSizeFlag = pledgedSrcSize != unchecked(0UL - 1) ? 1 : 0; + return ZSTD_copyCCtx_internal(dstCCtx, srcCCtx, fParams, pledgedSrcSize, zbuff); + } + + /*! ZSTD_reduceTable() : + * reduce table indexes by `reducerValue`, or squash to zero. + * PreserveMark preserves "unsorted mark" for btlazy2 strategy. + * It must be set to a clear 0/1 value, to remove branch during inlining. + * Presume table size is a multiple of ZSTD_ROWSIZE + * to help auto-vectorization */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_reduceTable_internal( + uint* table, + uint size, + uint reducerValue, + int preserveMark + ) + { + int nbRows = (int)size / 16; + int cellNb = 0; + int rowNb; + /* Protect special index values < ZSTD_WINDOW_START_INDEX. */ + uint reducerThreshold = reducerValue + 2; + assert((size & 16 - 1) == 0); + assert(size < 1U << 31); + for (rowNb = 0; rowNb < nbRows; rowNb++) + { + int column; + for (column = 0; column < 16; column++) + { + uint newVal; + if (preserveMark != 0 && table[cellNb] == 1) + { + newVal = 1; + } + else if (table[cellNb] < reducerThreshold) + { + newVal = 0; + } + else + { + newVal = table[cellNb] - reducerValue; + } + + table[cellNb] = newVal; + cellNb++; + } + } + } + + private static void ZSTD_reduceTable(uint* table, uint size, uint reducerValue) + { + ZSTD_reduceTable_internal(table, size, reducerValue, 0); + } + + private static void ZSTD_reduceTable_btlazy2(uint* table, uint size, uint reducerValue) + { + ZSTD_reduceTable_internal(table, size, reducerValue, 1); + } + + /*! ZSTD_reduceIndex() : + * rescale all indexes to avoid future overflow (indexes are U32) */ + private static void ZSTD_reduceIndex( + ZSTD_MatchState_t* ms, + ZSTD_CCtx_params_s* @params, + uint reducerValue + ) + { + { + uint hSize = (uint)1 << (int)@params->cParams.hashLog; + ZSTD_reduceTable(ms->hashTable, hSize, reducerValue); + } + + if ( + ZSTD_allocateChainTable( + @params->cParams.strategy, + @params->useRowMatchFinder, + (uint)ms->dedicatedDictSearch + ) != 0 + ) + { + uint chainSize = (uint)1 << (int)@params->cParams.chainLog; + if (@params->cParams.strategy == ZSTD_strategy.ZSTD_btlazy2) + ZSTD_reduceTable_btlazy2(ms->chainTable, chainSize, reducerValue); + else + ZSTD_reduceTable(ms->chainTable, chainSize, reducerValue); + } + + if (ms->hashLog3 != 0) + { + uint h3Size = (uint)1 << (int)ms->hashLog3; + ZSTD_reduceTable(ms->hashTable3, h3Size, reducerValue); + } + } + + /* See doc/zstd_compression_format.md for detailed format description */ + private static int ZSTD_seqToCodes(SeqStore_t* seqStorePtr) + { + SeqDef_s* sequences = seqStorePtr->sequencesStart; + byte* llCodeTable = seqStorePtr->llCode; + byte* ofCodeTable = seqStorePtr->ofCode; + byte* mlCodeTable = seqStorePtr->mlCode; + uint nbSeq = (uint)(seqStorePtr->sequences - seqStorePtr->sequencesStart); + uint u; + int longOffsets = 0; + assert(nbSeq <= seqStorePtr->maxNbSeq); + for (u = 0; u < nbSeq; u++) + { + uint llv = sequences[u].litLength; + uint ofCode = ZSTD_highbit32(sequences[u].offBase); + uint mlv = sequences[u].mlBase; + llCodeTable[u] = (byte)ZSTD_LLcode(llv); + ofCodeTable[u] = (byte)ofCode; + mlCodeTable[u] = (byte)ZSTD_MLcode(mlv); + assert(!(MEM_64bits && ofCode >= (uint)(MEM_32bits ? 25 : 57))); + if (MEM_32bits && ofCode >= (uint)(MEM_32bits ? 25 : 57)) + longOffsets = 1; + } + + if (seqStorePtr->longLengthType == ZSTD_longLengthType_e.ZSTD_llt_literalLength) + llCodeTable[seqStorePtr->longLengthPos] = 35; + if (seqStorePtr->longLengthType == ZSTD_longLengthType_e.ZSTD_llt_matchLength) + mlCodeTable[seqStorePtr->longLengthPos] = 52; + return longOffsets; + } + + /* ZSTD_useTargetCBlockSize(): + * Returns if target compressed block size param is being used. + * If used, compression will do best effort to make a compressed block size to be around targetCBlockSize. + * Returns 1 if true, 0 otherwise. */ + private static int ZSTD_useTargetCBlockSize(ZSTD_CCtx_params_s* cctxParams) + { + return cctxParams->targetCBlockSize != 0 ? 1 : 0; + } + + /* ZSTD_blockSplitterEnabled(): + * Returns if block splitting param is being used + * If used, compression will do best effort to split a block in order to improve compression ratio. + * At the time this function is called, the parameter must be finalized. + * Returns 1 if true, 0 otherwise. */ + private static int ZSTD_blockSplitterEnabled(ZSTD_CCtx_params_s* cctxParams) + { + assert(cctxParams->postBlockSplitter != ZSTD_paramSwitch_e.ZSTD_ps_auto); + return cctxParams->postBlockSplitter == ZSTD_paramSwitch_e.ZSTD_ps_enable ? 1 : 0; + } + + /* ZSTD_buildSequencesStatistics(): + * Returns a ZSTD_symbolEncodingTypeStats_t, or a zstd error code in the `size` field. + * Modifies `nextEntropy` to have the appropriate values as a side effect. + * nbSeq must be greater than 0. + * + * entropyWkspSize must be of size at least ENTROPY_WORKSPACE_SIZE - (MaxSeq + 1)*sizeof(U32) + */ + private static ZSTD_symbolEncodingTypeStats_t ZSTD_buildSequencesStatistics( + SeqStore_t* seqStorePtr, + nuint nbSeq, + ZSTD_fseCTables_t* prevEntropy, + ZSTD_fseCTables_t* nextEntropy, + byte* dst, + byte* dstEnd, + ZSTD_strategy strategy, + uint* countWorkspace, + void* entropyWorkspace, + nuint entropyWkspSize + ) + { + byte* ostart = dst; + byte* oend = dstEnd; + byte* op = ostart; + uint* CTable_LitLength = nextEntropy->litlengthCTable; + uint* CTable_OffsetBits = nextEntropy->offcodeCTable; + uint* CTable_MatchLength = nextEntropy->matchlengthCTable; + byte* ofCodeTable = seqStorePtr->ofCode; + byte* llCodeTable = seqStorePtr->llCode; + byte* mlCodeTable = seqStorePtr->mlCode; + ZSTD_symbolEncodingTypeStats_t stats; + System.Runtime.CompilerServices.Unsafe.SkipInit(out stats); + stats.lastCountSize = 0; + stats.longOffsets = ZSTD_seqToCodes(seqStorePtr); + assert(op <= oend); + assert(nbSeq != 0); + { + uint max = 35; + /* can't fail */ + nuint mostFrequent = HIST_countFast_wksp( + countWorkspace, + &max, + llCodeTable, + nbSeq, + entropyWorkspace, + entropyWkspSize + ); + nextEntropy->litlength_repeatMode = prevEntropy->litlength_repeatMode; + stats.LLtype = (uint)ZSTD_selectEncodingType( + &nextEntropy->litlength_repeatMode, + countWorkspace, + max, + mostFrequent, + nbSeq, + 9, + prevEntropy->litlengthCTable, + LL_defaultNorm, + LL_defaultNormLog, + ZSTD_DefaultPolicy_e.ZSTD_defaultAllowed, + strategy + ); + assert( + SymbolEncodingType_e.set_basic < SymbolEncodingType_e.set_compressed + && SymbolEncodingType_e.set_rle < SymbolEncodingType_e.set_compressed + ); + assert( + !( + stats.LLtype < (uint)SymbolEncodingType_e.set_compressed + && nextEntropy->litlength_repeatMode != FSE_repeat.FSE_repeat_none + ) + ); + { + nuint countSize = ZSTD_buildCTable( + op, + (nuint)(oend - op), + CTable_LitLength, + 9, + (SymbolEncodingType_e)stats.LLtype, + countWorkspace, + max, + llCodeTable, + nbSeq, + LL_defaultNorm, + LL_defaultNormLog, + 35, + prevEntropy->litlengthCTable, + sizeof(uint) * 329, + entropyWorkspace, + entropyWkspSize + ); + if (ERR_isError(countSize)) + { + stats.size = countSize; + return stats; + } + + if (stats.LLtype == (uint)SymbolEncodingType_e.set_compressed) + stats.lastCountSize = countSize; + op += countSize; + assert(op <= oend); + } + } + + { + uint max = 31; + nuint mostFrequent = HIST_countFast_wksp( + countWorkspace, + &max, + ofCodeTable, + nbSeq, + entropyWorkspace, + entropyWkspSize + ); + /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */ + ZSTD_DefaultPolicy_e defaultPolicy = + max <= 28 + ? ZSTD_DefaultPolicy_e.ZSTD_defaultAllowed + : ZSTD_DefaultPolicy_e.ZSTD_defaultDisallowed; + nextEntropy->offcode_repeatMode = prevEntropy->offcode_repeatMode; + stats.Offtype = (uint)ZSTD_selectEncodingType( + &nextEntropy->offcode_repeatMode, + countWorkspace, + max, + mostFrequent, + nbSeq, + 8, + prevEntropy->offcodeCTable, + OF_defaultNorm, + OF_defaultNormLog, + defaultPolicy, + strategy + ); + assert( + !( + stats.Offtype < (uint)SymbolEncodingType_e.set_compressed + && nextEntropy->offcode_repeatMode != FSE_repeat.FSE_repeat_none + ) + ); + { + nuint countSize = ZSTD_buildCTable( + op, + (nuint)(oend - op), + CTable_OffsetBits, + 8, + (SymbolEncodingType_e)stats.Offtype, + countWorkspace, + max, + ofCodeTable, + nbSeq, + OF_defaultNorm, + OF_defaultNormLog, + 28, + prevEntropy->offcodeCTable, + sizeof(uint) * 193, + entropyWorkspace, + entropyWkspSize + ); + if (ERR_isError(countSize)) + { + stats.size = countSize; + return stats; + } + + if (stats.Offtype == (uint)SymbolEncodingType_e.set_compressed) + stats.lastCountSize = countSize; + op += countSize; + assert(op <= oend); + } + } + + { + uint max = 52; + nuint mostFrequent = HIST_countFast_wksp( + countWorkspace, + &max, + mlCodeTable, + nbSeq, + entropyWorkspace, + entropyWkspSize + ); + nextEntropy->matchlength_repeatMode = prevEntropy->matchlength_repeatMode; + stats.MLtype = (uint)ZSTD_selectEncodingType( + &nextEntropy->matchlength_repeatMode, + countWorkspace, + max, + mostFrequent, + nbSeq, + 9, + prevEntropy->matchlengthCTable, + ML_defaultNorm, + ML_defaultNormLog, + ZSTD_DefaultPolicy_e.ZSTD_defaultAllowed, + strategy + ); + assert( + !( + stats.MLtype < (uint)SymbolEncodingType_e.set_compressed + && nextEntropy->matchlength_repeatMode != FSE_repeat.FSE_repeat_none + ) + ); + { + nuint countSize = ZSTD_buildCTable( + op, + (nuint)(oend - op), + CTable_MatchLength, + 9, + (SymbolEncodingType_e)stats.MLtype, + countWorkspace, + max, + mlCodeTable, + nbSeq, + ML_defaultNorm, + ML_defaultNormLog, + 52, + prevEntropy->matchlengthCTable, + sizeof(uint) * 363, + entropyWorkspace, + entropyWkspSize + ); + if (ERR_isError(countSize)) + { + stats.size = countSize; + return stats; + } + + if (stats.MLtype == (uint)SymbolEncodingType_e.set_compressed) + stats.lastCountSize = countSize; + op += countSize; + assert(op <= oend); + } + } + + stats.size = (nuint)(op - ostart); + return stats; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_entropyCompressSeqStore_internal( + void* dst, + nuint dstCapacity, + void* literals, + nuint litSize, + SeqStore_t* seqStorePtr, + ZSTD_entropyCTables_t* prevEntropy, + ZSTD_entropyCTables_t* nextEntropy, + ZSTD_CCtx_params_s* cctxParams, + void* entropyWorkspace, + nuint entropyWkspSize, + int bmi2 + ) + { + ZSTD_strategy strategy = cctxParams->cParams.strategy; + uint* count = (uint*)entropyWorkspace; + uint* CTable_LitLength = nextEntropy->fse.litlengthCTable; + uint* CTable_OffsetBits = nextEntropy->fse.offcodeCTable; + uint* CTable_MatchLength = nextEntropy->fse.matchlengthCTable; + SeqDef_s* sequences = seqStorePtr->sequencesStart; + nuint nbSeq = (nuint)(seqStorePtr->sequences - seqStorePtr->sequencesStart); + byte* ofCodeTable = seqStorePtr->ofCode; + byte* llCodeTable = seqStorePtr->llCode; + byte* mlCodeTable = seqStorePtr->mlCode; + byte* ostart = (byte*)dst; + byte* oend = ostart + dstCapacity; + byte* op = ostart; + nuint lastCountSize; + int longOffsets = 0; + entropyWorkspace = count + (52 + 1); + entropyWkspSize -= (52 + 1) * sizeof(uint); + assert(entropyWkspSize >= (8 << 10) + 512); + { + nuint numSequences = (nuint)(seqStorePtr->sequences - seqStorePtr->sequencesStart); + /* Base suspicion of uncompressibility on ratio of literals to sequences */ + int suspectUncompressible = numSequences == 0 || litSize / numSequences >= 20 ? 1 : 0; + nuint cSize = ZSTD_compressLiterals( + op, + dstCapacity, + literals, + litSize, + entropyWorkspace, + entropyWkspSize, + &prevEntropy->huf, + &nextEntropy->huf, + cctxParams->cParams.strategy, + ZSTD_literalsCompressionIsDisabled(cctxParams), + suspectUncompressible, + bmi2 + ); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(cSize <= dstCapacity); + op += cSize; + } + + if (oend - op < 3 + 1) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (nbSeq < 128) + { + *op++ = (byte)nbSeq; + } + else if (nbSeq < 0x7F00) + { + op[0] = (byte)((nbSeq >> 8) + 0x80); + op[1] = (byte)nbSeq; + op += 2; + } + else + { + op[0] = 0xFF; + MEM_writeLE16(op + 1, (ushort)(nbSeq - 0x7F00)); + op += 3; + } + + assert(op <= oend); + if (nbSeq == 0) + { + memcpy(&nextEntropy->fse, &prevEntropy->fse, (uint)sizeof(ZSTD_fseCTables_t)); + return (nuint)(op - ostart); + } + + { + byte* seqHead = op++; + /* build stats for sequences */ + ZSTD_symbolEncodingTypeStats_t stats = ZSTD_buildSequencesStatistics( + seqStorePtr, + nbSeq, + &prevEntropy->fse, + &nextEntropy->fse, + op, + oend, + strategy, + count, + entropyWorkspace, + entropyWkspSize + ); + { + nuint err_code = stats.size; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + *seqHead = (byte)((stats.LLtype << 6) + (stats.Offtype << 4) + (stats.MLtype << 2)); + lastCountSize = stats.lastCountSize; + op += stats.size; + longOffsets = stats.longOffsets; + } + + { + nuint bitstreamSize = ZSTD_encodeSequences( + op, + (nuint)(oend - op), + CTable_MatchLength, + mlCodeTable, + CTable_OffsetBits, + ofCodeTable, + CTable_LitLength, + llCodeTable, + sequences, + nbSeq, + longOffsets, + bmi2 + ); + { + nuint err_code = bitstreamSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + op += bitstreamSize; + assert(op <= oend); + if (lastCountSize != 0 && lastCountSize + bitstreamSize < 4) + { + assert(lastCountSize + bitstreamSize == 3); + return 0; + } + } + + return (nuint)(op - ostart); + } + + private static nuint ZSTD_entropyCompressSeqStore_wExtLitBuffer( + void* dst, + nuint dstCapacity, + void* literals, + nuint litSize, + nuint blockSize, + SeqStore_t* seqStorePtr, + ZSTD_entropyCTables_t* prevEntropy, + ZSTD_entropyCTables_t* nextEntropy, + ZSTD_CCtx_params_s* cctxParams, + void* entropyWorkspace, + nuint entropyWkspSize, + int bmi2 + ) + { + nuint cSize = ZSTD_entropyCompressSeqStore_internal( + dst, + dstCapacity, + literals, + litSize, + seqStorePtr, + prevEntropy, + nextEntropy, + cctxParams, + entropyWorkspace, + entropyWkspSize, + bmi2 + ); + if (cSize == 0) + return 0; + if ( + cSize == unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)) + && blockSize <= dstCapacity + ) + { + return 0; + } + + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint maxCSize = blockSize - ZSTD_minGain(blockSize, cctxParams->cParams.strategy); + if (cSize >= maxCSize) + return 0; + } + + assert(cSize < 1 << 17); + return cSize; + } + + private static nuint ZSTD_entropyCompressSeqStore( + SeqStore_t* seqStorePtr, + ZSTD_entropyCTables_t* prevEntropy, + ZSTD_entropyCTables_t* nextEntropy, + ZSTD_CCtx_params_s* cctxParams, + void* dst, + nuint dstCapacity, + nuint srcSize, + void* entropyWorkspace, + nuint entropyWkspSize, + int bmi2 + ) + { + return ZSTD_entropyCompressSeqStore_wExtLitBuffer( + dst, + dstCapacity, + seqStorePtr->litStart, + (nuint)(seqStorePtr->lit - seqStorePtr->litStart), + srcSize, + seqStorePtr, + prevEntropy, + nextEntropy, + cctxParams, + entropyWorkspace, + entropyWkspSize, + bmi2 + ); + } + + private static readonly ZSTD_BlockCompressor_f?[][] blockCompressor = + new ZSTD_BlockCompressor_f?[4][] + { + new ZSTD_BlockCompressor_f[10] + { + ZSTD_compressBlock_fast, + ZSTD_compressBlock_fast, + ZSTD_compressBlock_doubleFast, + ZSTD_compressBlock_greedy, + ZSTD_compressBlock_lazy, + ZSTD_compressBlock_lazy2, + ZSTD_compressBlock_btlazy2, + ZSTD_compressBlock_btopt, + ZSTD_compressBlock_btultra, + ZSTD_compressBlock_btultra2, + }, + new ZSTD_BlockCompressor_f[10] + { + ZSTD_compressBlock_fast_extDict, + ZSTD_compressBlock_fast_extDict, + ZSTD_compressBlock_doubleFast_extDict, + ZSTD_compressBlock_greedy_extDict, + ZSTD_compressBlock_lazy_extDict, + ZSTD_compressBlock_lazy2_extDict, + ZSTD_compressBlock_btlazy2_extDict, + ZSTD_compressBlock_btopt_extDict, + ZSTD_compressBlock_btultra_extDict, + ZSTD_compressBlock_btultra_extDict, + }, + new ZSTD_BlockCompressor_f[10] + { + ZSTD_compressBlock_fast_dictMatchState, + ZSTD_compressBlock_fast_dictMatchState, + ZSTD_compressBlock_doubleFast_dictMatchState, + ZSTD_compressBlock_greedy_dictMatchState, + ZSTD_compressBlock_lazy_dictMatchState, + ZSTD_compressBlock_lazy2_dictMatchState, + ZSTD_compressBlock_btlazy2_dictMatchState, + ZSTD_compressBlock_btopt_dictMatchState, + ZSTD_compressBlock_btultra_dictMatchState, + ZSTD_compressBlock_btultra_dictMatchState, + }, + new ZSTD_BlockCompressor_f?[10] + { + null, + null, + null, + ZSTD_compressBlock_greedy_dedicatedDictSearch, + ZSTD_compressBlock_lazy_dedicatedDictSearch, + ZSTD_compressBlock_lazy2_dedicatedDictSearch, + null, + null, + null, + null, + }, + }; + private static readonly ZSTD_BlockCompressor_f[][] rowBasedBlockCompressors = + new ZSTD_BlockCompressor_f[4][] + { + new ZSTD_BlockCompressor_f[3] + { + ZSTD_compressBlock_greedy_row, + ZSTD_compressBlock_lazy_row, + ZSTD_compressBlock_lazy2_row, + }, + new ZSTD_BlockCompressor_f[3] + { + ZSTD_compressBlock_greedy_extDict_row, + ZSTD_compressBlock_lazy_extDict_row, + ZSTD_compressBlock_lazy2_extDict_row, + }, + new ZSTD_BlockCompressor_f[3] + { + ZSTD_compressBlock_greedy_dictMatchState_row, + ZSTD_compressBlock_lazy_dictMatchState_row, + ZSTD_compressBlock_lazy2_dictMatchState_row, + }, + new ZSTD_BlockCompressor_f[3] + { + ZSTD_compressBlock_greedy_dedicatedDictSearch_row, + ZSTD_compressBlock_lazy_dedicatedDictSearch_row, + ZSTD_compressBlock_lazy2_dedicatedDictSearch_row, + }, + }; + + /* ZSTD_selectBlockCompressor() : + * Not static, but internal use only (used by long distance matcher) + * assumption : strat is a valid strategy */ + private static ZSTD_BlockCompressor_f ZSTD_selectBlockCompressor( + ZSTD_strategy strat, + ZSTD_paramSwitch_e useRowMatchFinder, + ZSTD_dictMode_e dictMode + ) + { + ZSTD_BlockCompressor_f? selectedCompressor; + assert(ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_strategy, (int)strat) != 0); + if (ZSTD_rowMatchFinderUsed(strat, useRowMatchFinder) != 0) + { + assert(useRowMatchFinder != ZSTD_paramSwitch_e.ZSTD_ps_auto); + selectedCompressor = rowBasedBlockCompressors[(int)dictMode][ + (int)strat - (int)ZSTD_strategy.ZSTD_greedy + ]; + } + else + { + selectedCompressor = blockCompressor[(int)dictMode][(int)strat]; + } + + assert(selectedCompressor != null); + return selectedCompressor.NotNull(); + } + + private static void ZSTD_storeLastLiterals( + SeqStore_t* seqStorePtr, + byte* anchor, + nuint lastLLSize + ) + { + memcpy(seqStorePtr->lit, anchor, (uint)lastLLSize); + seqStorePtr->lit += lastLLSize; + } + + private static void ZSTD_resetSeqStore(SeqStore_t* ssPtr) + { + ssPtr->lit = ssPtr->litStart; + ssPtr->sequences = ssPtr->sequencesStart; + ssPtr->longLengthType = ZSTD_longLengthType_e.ZSTD_llt_none; + } + + /* ZSTD_postProcessSequenceProducerResult() : + * Validates and post-processes sequences obtained through the external matchfinder API: + * - Checks whether nbExternalSeqs represents an error condition. + * - Appends a block delimiter to outSeqs if one is not already present. + * See zstd.h for context regarding block delimiters. + * Returns the number of sequences after post-processing, or an error code. */ + private static nuint ZSTD_postProcessSequenceProducerResult( + ZSTD_Sequence* outSeqs, + nuint nbExternalSeqs, + nuint outSeqsCapacity, + nuint srcSize + ) + { + if (nbExternalSeqs > outSeqsCapacity) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_sequenceProducer_failed)); + } + + if (nbExternalSeqs == 0 && srcSize > 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_sequenceProducer_failed)); + } + + if (srcSize == 0) + { + outSeqs[0] = new ZSTD_Sequence(); + return 1; + } + + { + ZSTD_Sequence lastSeq = outSeqs[nbExternalSeqs - 1]; + if (lastSeq.offset == 0 && lastSeq.matchLength == 0) + { + return nbExternalSeqs; + } + + if (nbExternalSeqs == outSeqsCapacity) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_sequenceProducer_failed)); + } + + outSeqs[nbExternalSeqs] = new ZSTD_Sequence(); + return nbExternalSeqs + 1; + } + } + + /* ZSTD_fastSequenceLengthSum() : + * Returns sum(litLen) + sum(matchLen) + lastLits for *seqBuf*. + * Similar to another function in zstd_compress.c (determine_blockSize), + * except it doesn't check for a block delimiter to end summation. + * Removing the early exit allows the compiler to auto-vectorize (https://godbolt.org/z/cY1cajz9P). + * This function can be deleted and replaced by determine_blockSize after we resolve issue #3456. */ + private static nuint ZSTD_fastSequenceLengthSum(ZSTD_Sequence* seqBuf, nuint seqBufSize) + { + nuint matchLenSum, + litLenSum, + i; + matchLenSum = 0; + litLenSum = 0; + for (i = 0; i < seqBufSize; i++) + { + litLenSum += seqBuf[i].litLength; + matchLenSum += seqBuf[i].matchLength; + } + + return litLenSum + matchLenSum; + } + + /** + * Function to validate sequences produced by a block compressor. + */ + private static void ZSTD_validateSeqStore( + SeqStore_t* seqStore, + ZSTD_compressionParameters* cParams + ) { } + + private static nuint ZSTD_buildSeqStore(ZSTD_CCtx_s* zc, void* src, nuint srcSize) + { + ZSTD_MatchState_t* ms = &zc->blockState.matchState; + assert(srcSize <= 1 << 17); + ZSTD_assertEqualCParams(zc->appliedParams.cParams, ms->cParams); + if (srcSize < (nuint)(1 + 1) + ZSTD_blockHeaderSize + 1 + 1) + { + if (zc->appliedParams.cParams.strategy >= ZSTD_strategy.ZSTD_btopt) + { + ZSTD_ldm_skipRawSeqStoreBytes(&zc->externSeqStore, srcSize); + } + else + { + ZSTD_ldm_skipSequences( + &zc->externSeqStore, + srcSize, + zc->appliedParams.cParams.minMatch + ); + } + + return (nuint)ZSTD_BuildSeqStore_e.ZSTDbss_noCompress; + } + + ZSTD_resetSeqStore(&zc->seqStore); + ms->opt.symbolCosts = &zc->blockState.prevCBlock->entropy; + ms->opt.literalCompressionMode = zc->appliedParams.literalCompressionMode; + assert(ms->dictMatchState == null || ms->loadedDictEnd == ms->window.dictLimit); + { + byte* @base = ms->window.@base; + byte* istart = (byte*)src; + uint curr = (uint)(istart - @base); +#if DEBUG + if (sizeof(nint) == 8) + assert(istart - @base < unchecked((nint)(uint)-1)); +#endif + if (curr > ms->nextToUpdate + 384) + ms->nextToUpdate = + curr + - (192 < curr - ms->nextToUpdate - 384 ? 192 : curr - ms->nextToUpdate - 384); + } + + { + ZSTD_dictMode_e dictMode = ZSTD_matchState_dictMode(ms); + nuint lastLLSize; + { + int i; + for (i = 0; i < 3; ++i) + zc->blockState.nextCBlock->rep[i] = zc->blockState.prevCBlock->rep[i]; + } + + if (zc->externSeqStore.pos < zc->externSeqStore.size) + { + assert(zc->appliedParams.ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_disable); + if (ZSTD_hasExtSeqProd(&zc->appliedParams) != 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_combination_unsupported) + ); + } + + lastLLSize = ZSTD_ldm_blockCompress( + &zc->externSeqStore, + ms, + &zc->seqStore, + zc->blockState.nextCBlock->rep, + zc->appliedParams.useRowMatchFinder, + src, + srcSize + ); + assert(zc->externSeqStore.pos <= zc->externSeqStore.size); + } + else if (zc->appliedParams.ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable) + { + RawSeqStore_t ldmSeqStore = kNullRawSeqStore; + if (ZSTD_hasExtSeqProd(&zc->appliedParams) != 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_combination_unsupported) + ); + } + + ldmSeqStore.seq = zc->ldmSequences; + ldmSeqStore.capacity = zc->maxNbLdmSequences; + { + /* Updates ldmSeqStore.size */ + nuint err_code = ZSTD_ldm_generateSequences( + &zc->ldmState, + &ldmSeqStore, + &zc->appliedParams.ldmParams, + src, + srcSize + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + lastLLSize = ZSTD_ldm_blockCompress( + &ldmSeqStore, + ms, + &zc->seqStore, + zc->blockState.nextCBlock->rep, + zc->appliedParams.useRowMatchFinder, + src, + srcSize + ); + assert(ldmSeqStore.pos == ldmSeqStore.size); + } + else if (ZSTD_hasExtSeqProd(&zc->appliedParams) != 0) + { + assert(zc->extSeqBufCapacity >= ZSTD_sequenceBound(srcSize)); + assert(zc->appliedParams.extSeqProdFunc != null); + { + uint windowSize = (uint)1 << (int)zc->appliedParams.cParams.windowLog; + nuint nbExternalSeqs = ( + (delegate* managed< + void*, + ZSTD_Sequence*, + nuint, + void*, + nuint, + void*, + nuint, + int, + nuint, + nuint>) + zc->appliedParams.extSeqProdFunc + )( + zc->appliedParams.extSeqProdState, + zc->extSeqBuf, + zc->extSeqBufCapacity, + src, + srcSize, + null, + 0, + zc->appliedParams.compressionLevel, + windowSize + ); + nuint nbPostProcessedSeqs = ZSTD_postProcessSequenceProducerResult( + zc->extSeqBuf, + nbExternalSeqs, + zc->extSeqBufCapacity, + srcSize + ); + if (!ERR_isError(nbPostProcessedSeqs)) + { + ZSTD_SequencePosition seqPos = new ZSTD_SequencePosition + { + idx = 0, + posInSequence = 0, + posInSrc = 0, + }; + nuint seqLenSum = ZSTD_fastSequenceLengthSum( + zc->extSeqBuf, + nbPostProcessedSeqs + ); + if (seqLenSum > srcSize) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid) + ); + } + + { + nuint err_code = ZSTD_transferSequences_wBlockDelim( + zc, + &seqPos, + zc->extSeqBuf, + nbPostProcessedSeqs, + src, + srcSize, + zc->appliedParams.searchForExternalRepcodes + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + ms->ldmSeqStore = null; + return (nuint)ZSTD_BuildSeqStore_e.ZSTDbss_compress; + } + + if (zc->appliedParams.enableMatchFinderFallback == 0) + { + return nbPostProcessedSeqs; + } + + { + ZSTD_BlockCompressor_f blockCompressor = ZSTD_selectBlockCompressor( + zc->appliedParams.cParams.strategy, + zc->appliedParams.useRowMatchFinder, + dictMode + ); + ms->ldmSeqStore = null; + lastLLSize = blockCompressor( + ms, + &zc->seqStore, + zc->blockState.nextCBlock->rep, + src, + srcSize + ); + } + } + } + else + { + ZSTD_BlockCompressor_f blockCompressor = ZSTD_selectBlockCompressor( + zc->appliedParams.cParams.strategy, + zc->appliedParams.useRowMatchFinder, + dictMode + ); + ms->ldmSeqStore = null; + lastLLSize = blockCompressor( + ms, + &zc->seqStore, + zc->blockState.nextCBlock->rep, + src, + srcSize + ); + } + + { + byte* lastLiterals = (byte*)src + srcSize - lastLLSize; + ZSTD_storeLastLiterals(&zc->seqStore, lastLiterals, lastLLSize); + } + } + + ZSTD_validateSeqStore(&zc->seqStore, &zc->appliedParams.cParams); + return (nuint)ZSTD_BuildSeqStore_e.ZSTDbss_compress; + } + + private static nuint ZSTD_copyBlockSequences( + SeqCollector* seqCollector, + SeqStore_t* seqStore, + uint* prevRepcodes + ) + { + SeqDef_s* inSeqs = seqStore->sequencesStart; + nuint nbInSequences = (nuint)(seqStore->sequences - inSeqs); + nuint nbInLiterals = (nuint)(seqStore->lit - seqStore->litStart); + ZSTD_Sequence* outSeqs = + seqCollector->seqIndex == 0 + ? seqCollector->seqStart + : seqCollector->seqStart + seqCollector->seqIndex; + nuint nbOutSequences = nbInSequences + 1; + nuint nbOutLiterals = 0; + repcodes_s repcodes; + nuint i; + assert(seqCollector->seqIndex <= seqCollector->maxSequences); + if (nbOutSequences > seqCollector->maxSequences - seqCollector->seqIndex) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + memcpy(&repcodes, prevRepcodes, (uint)sizeof(repcodes_s)); + for (i = 0; i < nbInSequences; ++i) + { + uint rawOffset; + outSeqs[i].litLength = inSeqs[i].litLength; + outSeqs[i].matchLength = (uint)(inSeqs[i].mlBase + 3); + outSeqs[i].rep = 0; + if (i == seqStore->longLengthPos) + { + if (seqStore->longLengthType == ZSTD_longLengthType_e.ZSTD_llt_literalLength) + { + outSeqs[i].litLength += 0x10000; + } + else if (seqStore->longLengthType == ZSTD_longLengthType_e.ZSTD_llt_matchLength) + { + outSeqs[i].matchLength += 0x10000; + } + } + + if (1 <= inSeqs[i].offBase && inSeqs[i].offBase <= 3) + { + assert(1 <= inSeqs[i].offBase && inSeqs[i].offBase <= 3); + uint repcode = inSeqs[i].offBase; + assert(repcode > 0); + outSeqs[i].rep = repcode; + if (outSeqs[i].litLength != 0) + { + rawOffset = repcodes.rep[repcode - 1]; + } + else + { + if (repcode == 3) + { + assert(repcodes.rep[0] > 1); + rawOffset = repcodes.rep[0] - 1; + } + else + { + rawOffset = repcodes.rep[repcode]; + } + } + } + else + { + assert(inSeqs[i].offBase > 3); + rawOffset = inSeqs[i].offBase - 3; + } + + outSeqs[i].offset = rawOffset; + ZSTD_updateRep(repcodes.rep, inSeqs[i].offBase, inSeqs[i].litLength == 0 ? 1U : 0U); + nbOutLiterals += outSeqs[i].litLength; + } + + assert(nbInLiterals >= nbOutLiterals); + { + nuint lastLLSize = nbInLiterals - nbOutLiterals; + outSeqs[nbInSequences].litLength = (uint)lastLLSize; + outSeqs[nbInSequences].matchLength = 0; + outSeqs[nbInSequences].offset = 0; + assert(nbOutSequences == nbInSequences + 1); + } + + seqCollector->seqIndex += nbOutSequences; + assert(seqCollector->seqIndex <= seqCollector->maxSequences); + return 0; + } + + /*! ZSTD_sequenceBound() : + * `srcSize` : size of the input buffer + * @return : upper-bound for the number of sequences that can be generated + * from a buffer of srcSize bytes + * + * note : returns number of sequences - to get bytes, multiply by sizeof(ZSTD_Sequence). + */ + public static nuint ZSTD_sequenceBound(nuint srcSize) + { + nuint maxNbSeq = srcSize / 3 + 1; + nuint maxNbDelims = srcSize / (1 << 10) + 1; + return maxNbSeq + maxNbDelims; + } + + /*! ZSTD_generateSequences() : + * WARNING: This function is meant for debugging and informational purposes ONLY! + * Its implementation is flawed, and it will be deleted in a future version. + * It is not guaranteed to succeed, as there are several cases where it will give + * up and fail. You should NOT use this function in production code. + * + * This function is deprecated, and will be removed in a future version. + * + * Generate sequences using ZSTD_compress2(), given a source buffer. + * + * @param zc The compression context to be used for ZSTD_compress2(). Set any + * compression parameters you need on this context. + * @param outSeqs The output sequences buffer of size @p outSeqsSize + * @param outSeqsCapacity The size of the output sequences buffer. + * ZSTD_sequenceBound(srcSize) is an upper bound on the number + * of sequences that can be generated. + * @param src The source buffer to generate sequences from of size @p srcSize. + * @param srcSize The size of the source buffer. + * + * Each block will end with a dummy sequence + * with offset == 0, matchLength == 0, and litLength == length of last literals. + * litLength may be == 0, and if so, then the sequence of (of: 0 ml: 0 ll: 0) + * simply acts as a block delimiter. + * + * @returns The number of sequences generated, necessarily less than + * ZSTD_sequenceBound(srcSize), or an error code that can be checked + * with ZSTD_isError(). + */ + public static nuint ZSTD_generateSequences( + ZSTD_CCtx_s* zc, + ZSTD_Sequence* outSeqs, + nuint outSeqsSize, + void* src, + nuint srcSize + ) + { + nuint dstCapacity = ZSTD_compressBound(srcSize); + /* Make C90 happy. */ + void* dst; + SeqCollector seqCollector; + { + int targetCBlockSize; + { + nuint err_code = ZSTD_CCtx_getParameter( + zc, + ZSTD_cParameter.ZSTD_c_targetCBlockSize, + &targetCBlockSize + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (targetCBlockSize != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_unsupported)); + } + } + + { + int nbWorkers; + { + nuint err_code = ZSTD_CCtx_getParameter( + zc, + ZSTD_cParameter.ZSTD_c_nbWorkers, + &nbWorkers + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (nbWorkers != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_unsupported)); + } + } + + dst = ZSTD_customMalloc(dstCapacity, ZSTD_defaultCMem); + if (dst == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + seqCollector.collectSequences = 1; + seqCollector.seqStart = outSeqs; + seqCollector.seqIndex = 0; + seqCollector.maxSequences = outSeqsSize; + zc->seqCollector = seqCollector; + { + nuint ret = ZSTD_compress2(zc, dst, dstCapacity, src, srcSize); + ZSTD_customFree(dst, ZSTD_defaultCMem); + { + nuint err_code = ret; + if (ERR_isError(err_code)) + { + return err_code; + } + } + } + + assert(zc->seqCollector.seqIndex <= ZSTD_sequenceBound(srcSize)); + return zc->seqCollector.seqIndex; + } + + /*! ZSTD_mergeBlockDelimiters() : + * Given an array of ZSTD_Sequence, remove all sequences that represent block delimiters/last literals + * by merging them into the literals of the next sequence. + * + * As such, the final generated result has no explicit representation of block boundaries, + * and the final last literals segment is not represented in the sequences. + * + * The output of this function can be fed into ZSTD_compressSequences() with CCtx + * setting of ZSTD_c_blockDelimiters as ZSTD_sf_noBlockDelimiters + * @return : number of sequences left after merging + */ + public static nuint ZSTD_mergeBlockDelimiters(ZSTD_Sequence* sequences, nuint seqsSize) + { + nuint @in = 0; + nuint @out = 0; + for (; @in < seqsSize; ++@in) + { + if (sequences[@in].offset == 0 && sequences[@in].matchLength == 0) + { + if (@in != seqsSize - 1) + { + sequences[@in + 1].litLength += sequences[@in].litLength; + } + } + else + { + sequences[@out] = sequences[@in]; + ++@out; + } + } + + return @out; + } + + /* Unrolled loop to read four size_ts of input at a time. Returns 1 if is RLE, 0 if not. */ + private static int ZSTD_isRLE(byte* src, nuint length) + { + byte* ip = src; + byte value = ip[0]; + nuint valueST = (nuint)(value * 0x0101010101010101UL); + nuint unrollSize = (nuint)(sizeof(nuint) * 4); + nuint unrollMask = unrollSize - 1; + nuint prefixLength = length & unrollMask; + nuint i; + if (length == 1) + return 1; + if (prefixLength != 0 && ZSTD_count(ip + 1, ip, ip + prefixLength) != prefixLength - 1) + { + return 0; + } + + for (i = prefixLength; i != length; i += unrollSize) + { + nuint u; + for (u = 0; u < unrollSize; u += (nuint)sizeof(nuint)) + { + if (MEM_readST(ip + i + u) != valueST) + { + return 0; + } + } + } + + return 1; + } + + /* Returns true if the given block may be RLE. + * This is just a heuristic based on the compressibility. + * It may return both false positives and false negatives. + */ + private static int ZSTD_maybeRLE(SeqStore_t* seqStore) + { + nuint nbSeqs = (nuint)(seqStore->sequences - seqStore->sequencesStart); + nuint nbLits = (nuint)(seqStore->lit - seqStore->litStart); + return nbSeqs < 4 && nbLits < 10 ? 1 : 0; + } + + private static void ZSTD_blockState_confirmRepcodesAndEntropyTables(ZSTD_blockState_t* bs) + { + ZSTD_compressedBlockState_t* tmp = bs->prevCBlock; + bs->prevCBlock = bs->nextCBlock; + bs->nextCBlock = tmp; + } + + /* Writes the block header */ + private static void writeBlockHeader(void* op, nuint cSize, nuint blockSize, uint lastBlock) + { + uint cBlockHeader = + cSize == 1 + ? lastBlock + ((uint)blockType_e.bt_rle << 1) + (uint)(blockSize << 3) + : lastBlock + ((uint)blockType_e.bt_compressed << 1) + (uint)(cSize << 3); + MEM_writeLE24(op, cBlockHeader); + } + + /** ZSTD_buildBlockEntropyStats_literals() : + * Builds entropy for the literals. + * Stores literals block type (raw, rle, compressed, repeat) and + * huffman description table to hufMetadata. + * Requires ENTROPY_WORKSPACE_SIZE workspace + * @return : size of huffman description table, or an error code + */ + private static nuint ZSTD_buildBlockEntropyStats_literals( + void* src, + nuint srcSize, + ZSTD_hufCTables_t* prevHuf, + ZSTD_hufCTables_t* nextHuf, + ZSTD_hufCTablesMetadata_t* hufMetadata, + int literalsCompressionIsDisabled, + void* workspace, + nuint wkspSize, + int hufFlags + ) + { + byte* wkspStart = (byte*)workspace; + byte* wkspEnd = wkspStart + wkspSize; + byte* countWkspStart = wkspStart; + uint* countWksp = (uint*)workspace; + const nuint countWkspSize = (255 + 1) * sizeof(uint); + byte* nodeWksp = countWkspStart + countWkspSize; + nuint nodeWkspSize = (nuint)(wkspEnd - nodeWksp); + uint maxSymbolValue = 255; + uint huffLog = 11; + HUF_repeat repeat = prevHuf->repeatMode; + memcpy(nextHuf, prevHuf, (uint)sizeof(ZSTD_hufCTables_t)); + if (literalsCompressionIsDisabled != 0) + { + hufMetadata->hType = SymbolEncodingType_e.set_basic; + return 0; + } + + { + nuint minLitSize = (nuint)(prevHuf->repeatMode == HUF_repeat.HUF_repeat_valid ? 6 : 63); + if (srcSize <= minLitSize) + { + hufMetadata->hType = SymbolEncodingType_e.set_basic; + return 0; + } + } + + { + nuint largest = HIST_count_wksp( + countWksp, + &maxSymbolValue, + (byte*)src, + srcSize, + workspace, + wkspSize + ); + { + nuint err_code = largest; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (largest == srcSize) + { + hufMetadata->hType = SymbolEncodingType_e.set_rle; + return 0; + } + + if (largest <= (srcSize >> 7) + 4) + { + hufMetadata->hType = SymbolEncodingType_e.set_basic; + return 0; + } + } + + if ( + repeat == HUF_repeat.HUF_repeat_check + && HUF_validateCTable(&prevHuf->CTable.e0, countWksp, maxSymbolValue) == 0 + ) + { + repeat = HUF_repeat.HUF_repeat_none; + } + + memset(&nextHuf->CTable.e0, 0, sizeof(ulong) * 257); + huffLog = HUF_optimalTableLog( + huffLog, + srcSize, + maxSymbolValue, + nodeWksp, + nodeWkspSize, + &nextHuf->CTable.e0, + countWksp, + hufFlags + ); + assert(huffLog <= 11); + { + nuint maxBits = HUF_buildCTable_wksp( + &nextHuf->CTable.e0, + countWksp, + maxSymbolValue, + huffLog, + nodeWksp, + nodeWkspSize + ); + { + nuint err_code = maxBits; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + huffLog = (uint)maxBits; + } + + { + nuint newCSize = HUF_estimateCompressedSize( + &nextHuf->CTable.e0, + countWksp, + maxSymbolValue + ); + nuint hSize = HUF_writeCTable_wksp( + hufMetadata->hufDesBuffer, + sizeof(byte) * 128, + &nextHuf->CTable.e0, + maxSymbolValue, + huffLog, + nodeWksp, + nodeWkspSize + ); + if (repeat != HUF_repeat.HUF_repeat_none) + { + nuint oldCSize = HUF_estimateCompressedSize( + &prevHuf->CTable.e0, + countWksp, + maxSymbolValue + ); + if (oldCSize < srcSize && (oldCSize <= hSize + newCSize || hSize + 12 >= srcSize)) + { + memcpy(nextHuf, prevHuf, (uint)sizeof(ZSTD_hufCTables_t)); + hufMetadata->hType = SymbolEncodingType_e.set_repeat; + return 0; + } + } + + if (newCSize + hSize >= srcSize) + { + memcpy(nextHuf, prevHuf, (uint)sizeof(ZSTD_hufCTables_t)); + hufMetadata->hType = SymbolEncodingType_e.set_basic; + return 0; + } + + hufMetadata->hType = SymbolEncodingType_e.set_compressed; + nextHuf->repeatMode = HUF_repeat.HUF_repeat_check; + return hSize; + } + } + + /* ZSTD_buildDummySequencesStatistics(): + * Returns a ZSTD_symbolEncodingTypeStats_t with all encoding types as set_basic, + * and updates nextEntropy to the appropriate repeatMode. + */ + private static ZSTD_symbolEncodingTypeStats_t ZSTD_buildDummySequencesStatistics( + ZSTD_fseCTables_t* nextEntropy + ) + { + ZSTD_symbolEncodingTypeStats_t stats = new ZSTD_symbolEncodingTypeStats_t + { + LLtype = (uint)SymbolEncodingType_e.set_basic, + Offtype = (uint)SymbolEncodingType_e.set_basic, + MLtype = (uint)SymbolEncodingType_e.set_basic, + size = 0, + lastCountSize = 0, + longOffsets = 0, + }; + nextEntropy->litlength_repeatMode = FSE_repeat.FSE_repeat_none; + nextEntropy->offcode_repeatMode = FSE_repeat.FSE_repeat_none; + nextEntropy->matchlength_repeatMode = FSE_repeat.FSE_repeat_none; + return stats; + } + + /** ZSTD_buildBlockEntropyStats_sequences() : + * Builds entropy for the sequences. + * Stores symbol compression modes and fse table to fseMetadata. + * Requires ENTROPY_WORKSPACE_SIZE wksp. + * @return : size of fse tables or error code */ + private static nuint ZSTD_buildBlockEntropyStats_sequences( + SeqStore_t* seqStorePtr, + ZSTD_fseCTables_t* prevEntropy, + ZSTD_fseCTables_t* nextEntropy, + ZSTD_CCtx_params_s* cctxParams, + ZSTD_fseCTablesMetadata_t* fseMetadata, + void* workspace, + nuint wkspSize + ) + { + ZSTD_strategy strategy = cctxParams->cParams.strategy; + nuint nbSeq = (nuint)(seqStorePtr->sequences - seqStorePtr->sequencesStart); + byte* ostart = fseMetadata->fseTablesBuffer; + byte* oend = ostart + sizeof(byte) * 133; + byte* op = ostart; + uint* countWorkspace = (uint*)workspace; + uint* entropyWorkspace = countWorkspace + (52 + 1); + nuint entropyWorkspaceSize = wkspSize - (52 + 1) * sizeof(uint); + ZSTD_symbolEncodingTypeStats_t stats; + stats = + nbSeq != 0 + ? ZSTD_buildSequencesStatistics( + seqStorePtr, + nbSeq, + prevEntropy, + nextEntropy, + op, + oend, + strategy, + countWorkspace, + entropyWorkspace, + entropyWorkspaceSize + ) + : ZSTD_buildDummySequencesStatistics(nextEntropy); + { + nuint err_code = stats.size; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + fseMetadata->llType = (SymbolEncodingType_e)stats.LLtype; + fseMetadata->ofType = (SymbolEncodingType_e)stats.Offtype; + fseMetadata->mlType = (SymbolEncodingType_e)stats.MLtype; + fseMetadata->lastCountSize = stats.lastCountSize; + return stats.size; + } + + /** ZSTD_buildBlockEntropyStats() : + * Builds entropy for the block. + * Requires workspace size ENTROPY_WORKSPACE_SIZE + * @return : 0 on success, or an error code + * Note : also employed in superblock + */ + private static nuint ZSTD_buildBlockEntropyStats( + SeqStore_t* seqStorePtr, + ZSTD_entropyCTables_t* prevEntropy, + ZSTD_entropyCTables_t* nextEntropy, + ZSTD_CCtx_params_s* cctxParams, + ZSTD_entropyCTablesMetadata_t* entropyMetadata, + void* workspace, + nuint wkspSize + ) + { + nuint litSize = (nuint)(seqStorePtr->lit - seqStorePtr->litStart); + int huf_useOptDepth = cctxParams->cParams.strategy >= ZSTD_strategy.ZSTD_btultra ? 1 : 0; + int hufFlags = huf_useOptDepth != 0 ? (int)HUF_flags_e.HUF_flags_optimalDepth : 0; + entropyMetadata->hufMetadata.hufDesSize = ZSTD_buildBlockEntropyStats_literals( + seqStorePtr->litStart, + litSize, + &prevEntropy->huf, + &nextEntropy->huf, + &entropyMetadata->hufMetadata, + ZSTD_literalsCompressionIsDisabled(cctxParams), + workspace, + wkspSize, + hufFlags + ); + { + nuint err_code = entropyMetadata->hufMetadata.hufDesSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + entropyMetadata->fseMetadata.fseTablesSize = ZSTD_buildBlockEntropyStats_sequences( + seqStorePtr, + &prevEntropy->fse, + &nextEntropy->fse, + cctxParams, + &entropyMetadata->fseMetadata, + workspace, + wkspSize + ); + { + nuint err_code = entropyMetadata->fseMetadata.fseTablesSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + /* Returns the size estimate for the literals section (header + content) of a block */ + private static nuint ZSTD_estimateBlockSize_literal( + byte* literals, + nuint litSize, + ZSTD_hufCTables_t* huf, + ZSTD_hufCTablesMetadata_t* hufMetadata, + void* workspace, + nuint wkspSize, + int writeEntropy + ) + { + uint* countWksp = (uint*)workspace; + uint maxSymbolValue = 255; + nuint literalSectionHeaderSize = (nuint)( + 3 + (litSize >= 1 * (1 << 10) ? 1 : 0) + (litSize >= 16 * (1 << 10) ? 1 : 0) + ); + uint singleStream = litSize < 256 ? 1U : 0U; + if (hufMetadata->hType == SymbolEncodingType_e.set_basic) + return litSize; + else if (hufMetadata->hType == SymbolEncodingType_e.set_rle) + return 1; + else if ( + hufMetadata->hType == SymbolEncodingType_e.set_compressed + || hufMetadata->hType == SymbolEncodingType_e.set_repeat + ) + { + nuint largest = HIST_count_wksp( + countWksp, + &maxSymbolValue, + literals, + litSize, + workspace, + wkspSize + ); + if (ERR_isError(largest)) + return litSize; + { + nuint cLitSizeEstimate = HUF_estimateCompressedSize( + &huf->CTable.e0, + countWksp, + maxSymbolValue + ); + if (writeEntropy != 0) + cLitSizeEstimate += hufMetadata->hufDesSize; + if (singleStream == 0) + cLitSizeEstimate += 6; + return cLitSizeEstimate + literalSectionHeaderSize; + } + } + + assert(0 != 0); + return 0; + } + + /* Returns the size estimate for the FSE-compressed symbols (of, ml, ll) of a block */ + private static nuint ZSTD_estimateBlockSize_symbolType( + SymbolEncodingType_e type, + byte* codeTable, + nuint nbSeq, + uint maxCode, + uint* fseCTable, + byte* additionalBits, + short* defaultNorm, + uint defaultNormLog, + uint defaultMax, + void* workspace, + nuint wkspSize + ) + { + uint* countWksp = (uint*)workspace; + byte* ctp = codeTable; + byte* ctStart = ctp; + byte* ctEnd = ctStart + nbSeq; + nuint cSymbolTypeSizeEstimateInBits = 0; + uint max = maxCode; + HIST_countFast_wksp(countWksp, &max, codeTable, nbSeq, workspace, wkspSize); + if (type == SymbolEncodingType_e.set_basic) + { + assert(max <= defaultMax); + cSymbolTypeSizeEstimateInBits = ZSTD_crossEntropyCost( + defaultNorm, + defaultNormLog, + countWksp, + max + ); + } + else if (type == SymbolEncodingType_e.set_rle) + { + cSymbolTypeSizeEstimateInBits = 0; + } + else if ( + type == SymbolEncodingType_e.set_compressed + || type == SymbolEncodingType_e.set_repeat + ) + { + cSymbolTypeSizeEstimateInBits = ZSTD_fseBitCost(fseCTable, countWksp, max); + } + + if (ERR_isError(cSymbolTypeSizeEstimateInBits)) + { + return nbSeq * 10; + } + + while (ctp < ctEnd) + { + if (additionalBits != null) + cSymbolTypeSizeEstimateInBits += additionalBits[*ctp]; + else + cSymbolTypeSizeEstimateInBits += *ctp; + ctp++; + } + + return cSymbolTypeSizeEstimateInBits >> 3; + } + + /* Returns the size estimate for the sequences section (header + content) of a block */ + private static nuint ZSTD_estimateBlockSize_sequences( + byte* ofCodeTable, + byte* llCodeTable, + byte* mlCodeTable, + nuint nbSeq, + ZSTD_fseCTables_t* fseTables, + ZSTD_fseCTablesMetadata_t* fseMetadata, + void* workspace, + nuint wkspSize, + int writeEntropy + ) + { + /* seqHead */ + nuint sequencesSectionHeaderSize = (nuint)( + 1 + 1 + (nbSeq >= 128 ? 1 : 0) + (nbSeq >= 0x7F00 ? 1 : 0) + ); + nuint cSeqSizeEstimate = 0; + cSeqSizeEstimate += ZSTD_estimateBlockSize_symbolType( + fseMetadata->ofType, + ofCodeTable, + nbSeq, + 31, + fseTables->offcodeCTable, + null, + OF_defaultNorm, + OF_defaultNormLog, + 28, + workspace, + wkspSize + ); + cSeqSizeEstimate += ZSTD_estimateBlockSize_symbolType( + fseMetadata->llType, + llCodeTable, + nbSeq, + 35, + fseTables->litlengthCTable, + LL_bits, + LL_defaultNorm, + LL_defaultNormLog, + 35, + workspace, + wkspSize + ); + cSeqSizeEstimate += ZSTD_estimateBlockSize_symbolType( + fseMetadata->mlType, + mlCodeTable, + nbSeq, + 52, + fseTables->matchlengthCTable, + ML_bits, + ML_defaultNorm, + ML_defaultNormLog, + 52, + workspace, + wkspSize + ); + if (writeEntropy != 0) + cSeqSizeEstimate += fseMetadata->fseTablesSize; + return cSeqSizeEstimate + sequencesSectionHeaderSize; + } + + /* Returns the size estimate for a given stream of literals, of, ll, ml */ + private static nuint ZSTD_estimateBlockSize( + byte* literals, + nuint litSize, + byte* ofCodeTable, + byte* llCodeTable, + byte* mlCodeTable, + nuint nbSeq, + ZSTD_entropyCTables_t* entropy, + ZSTD_entropyCTablesMetadata_t* entropyMetadata, + void* workspace, + nuint wkspSize, + int writeLitEntropy, + int writeSeqEntropy + ) + { + nuint literalsSize = ZSTD_estimateBlockSize_literal( + literals, + litSize, + &entropy->huf, + &entropyMetadata->hufMetadata, + workspace, + wkspSize, + writeLitEntropy + ); + nuint seqSize = ZSTD_estimateBlockSize_sequences( + ofCodeTable, + llCodeTable, + mlCodeTable, + nbSeq, + &entropy->fse, + &entropyMetadata->fseMetadata, + workspace, + wkspSize, + writeSeqEntropy + ); + return seqSize + literalsSize + ZSTD_blockHeaderSize; + } + + /* Builds entropy statistics and uses them for blocksize estimation. + * + * @return: estimated compressed size of the seqStore, or a zstd error. + */ + private static nuint ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize( + SeqStore_t* seqStore, + ZSTD_CCtx_s* zc + ) + { + ZSTD_entropyCTablesMetadata_t* entropyMetadata = &zc->blockSplitCtx.entropyMetadata; + { + nuint err_code = ZSTD_buildBlockEntropyStats( + seqStore, + &zc->blockState.prevCBlock->entropy, + &zc->blockState.nextCBlock->entropy, + &zc->appliedParams, + entropyMetadata, + zc->tmpWorkspace, + zc->tmpWkspSize + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return ZSTD_estimateBlockSize( + seqStore->litStart, + (nuint)(seqStore->lit - seqStore->litStart), + seqStore->ofCode, + seqStore->llCode, + seqStore->mlCode, + (nuint)(seqStore->sequences - seqStore->sequencesStart), + &zc->blockState.nextCBlock->entropy, + entropyMetadata, + zc->tmpWorkspace, + zc->tmpWkspSize, + entropyMetadata->hufMetadata.hType == SymbolEncodingType_e.set_compressed ? 1 : 0, + 1 + ); + } + + /* Returns literals bytes represented in a seqStore */ + private static nuint ZSTD_countSeqStoreLiteralsBytes(SeqStore_t* seqStore) + { + nuint literalsBytes = 0; + nuint nbSeqs = (nuint)(seqStore->sequences - seqStore->sequencesStart); + nuint i; + for (i = 0; i < nbSeqs; ++i) + { + SeqDef_s seq = seqStore->sequencesStart[i]; + literalsBytes += seq.litLength; + if ( + i == seqStore->longLengthPos + && seqStore->longLengthType == ZSTD_longLengthType_e.ZSTD_llt_literalLength + ) + { + literalsBytes += 0x10000; + } + } + + return literalsBytes; + } + + /* Returns match bytes represented in a seqStore */ + private static nuint ZSTD_countSeqStoreMatchBytes(SeqStore_t* seqStore) + { + nuint matchBytes = 0; + nuint nbSeqs = (nuint)(seqStore->sequences - seqStore->sequencesStart); + nuint i; + for (i = 0; i < nbSeqs; ++i) + { + SeqDef_s seq = seqStore->sequencesStart[i]; + matchBytes += (nuint)(seq.mlBase + 3); + if ( + i == seqStore->longLengthPos + && seqStore->longLengthType == ZSTD_longLengthType_e.ZSTD_llt_matchLength + ) + { + matchBytes += 0x10000; + } + } + + return matchBytes; + } + + /* Derives the seqStore that is a chunk of the originalSeqStore from [startIdx, endIdx). + * Stores the result in resultSeqStore. + */ + private static void ZSTD_deriveSeqStoreChunk( + SeqStore_t* resultSeqStore, + SeqStore_t* originalSeqStore, + nuint startIdx, + nuint endIdx + ) + { + *resultSeqStore = *originalSeqStore; + if (startIdx > 0) + { + resultSeqStore->sequences = originalSeqStore->sequencesStart + startIdx; + resultSeqStore->litStart += ZSTD_countSeqStoreLiteralsBytes(resultSeqStore); + } + + if (originalSeqStore->longLengthType != ZSTD_longLengthType_e.ZSTD_llt_none) + { + if ( + originalSeqStore->longLengthPos < startIdx + || originalSeqStore->longLengthPos > endIdx + ) + { + resultSeqStore->longLengthType = ZSTD_longLengthType_e.ZSTD_llt_none; + } + else + { + resultSeqStore->longLengthPos -= (uint)startIdx; + } + } + + resultSeqStore->sequencesStart = originalSeqStore->sequencesStart + startIdx; + resultSeqStore->sequences = originalSeqStore->sequencesStart + endIdx; + if (endIdx == (nuint)(originalSeqStore->sequences - originalSeqStore->sequencesStart)) + { + assert(resultSeqStore->lit == originalSeqStore->lit); + } + else + { + nuint literalsBytes = ZSTD_countSeqStoreLiteralsBytes(resultSeqStore); + resultSeqStore->lit = resultSeqStore->litStart + literalsBytes; + } + + resultSeqStore->llCode += startIdx; + resultSeqStore->mlCode += startIdx; + resultSeqStore->ofCode += startIdx; + } + + /** + * Returns the raw offset represented by the combination of offBase, ll0, and repcode history. + * offBase must represent a repcode in the numeric representation of ZSTD_storeSeq(). + */ + private static uint ZSTD_resolveRepcodeToRawOffset(uint* rep, uint offBase, uint ll0) + { + assert(1 <= offBase && offBase <= 3); + /* [ 0 - 3 ] */ + uint adjustedRepCode = offBase - 1 + ll0; + assert(1 <= offBase && offBase <= 3); + if (adjustedRepCode == 3) + { + assert(ll0 != 0); + return rep[0] - 1; + } + + return rep[adjustedRepCode]; + } + + /** + * ZSTD_seqStore_resolveOffCodes() reconciles any possible divergences in offset history that may arise + * due to emission of RLE/raw blocks that disturb the offset history, + * and replaces any repcodes within the seqStore that may be invalid. + * + * dRepcodes are updated as would be on the decompression side. + * cRepcodes are updated exactly in accordance with the seqStore. + * + * Note : this function assumes seq->offBase respects the following numbering scheme : + * 0 : invalid + * 1-3 : repcode 1-3 + * 4+ : real_offset+3 + */ + private static void ZSTD_seqStore_resolveOffCodes( + repcodes_s* dRepcodes, + repcodes_s* cRepcodes, + SeqStore_t* seqStore, + uint nbSeq + ) + { + uint idx = 0; + uint longLitLenIdx = + seqStore->longLengthType == ZSTD_longLengthType_e.ZSTD_llt_literalLength + ? seqStore->longLengthPos + : nbSeq; + for (; idx < nbSeq; ++idx) + { + SeqDef_s* seq = seqStore->sequencesStart + idx; + uint ll0 = seq->litLength == 0 && idx != longLitLenIdx ? 1U : 0U; + uint offBase = seq->offBase; + assert(offBase > 0); + if (1 <= offBase && offBase <= 3) + { + uint dRawOffset = ZSTD_resolveRepcodeToRawOffset(dRepcodes->rep, offBase, ll0); + uint cRawOffset = ZSTD_resolveRepcodeToRawOffset(cRepcodes->rep, offBase, ll0); + if (dRawOffset != cRawOffset) + { + assert(cRawOffset > 0); + seq->offBase = cRawOffset + 3; + } + } + + ZSTD_updateRep(dRepcodes->rep, seq->offBase, ll0); + ZSTD_updateRep(cRepcodes->rep, offBase, ll0); + } + } + + /* ZSTD_compressSeqStore_singleBlock(): + * Compresses a seqStore into a block with a block header, into the buffer dst. + * + * Returns the total size of that block (including header) or a ZSTD error code. + */ + private static nuint ZSTD_compressSeqStore_singleBlock( + ZSTD_CCtx_s* zc, + SeqStore_t* seqStore, + repcodes_s* dRep, + repcodes_s* cRep, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + uint lastBlock, + uint isPartition + ) + { + const uint rleMaxLength = 25; + byte* op = (byte*)dst; + byte* ip = (byte*)src; + nuint cSize; + nuint cSeqsSize; + /* In case of an RLE or raw block, the simulated decompression repcode history must be reset */ + repcodes_s dRepOriginal = *dRep; + if (isPartition != 0) + ZSTD_seqStore_resolveOffCodes( + dRep, + cRep, + seqStore, + (uint)(seqStore->sequences - seqStore->sequencesStart) + ); + if (dstCapacity < ZSTD_blockHeaderSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + cSeqsSize = ZSTD_entropyCompressSeqStore( + seqStore, + &zc->blockState.prevCBlock->entropy, + &zc->blockState.nextCBlock->entropy, + &zc->appliedParams, + op + ZSTD_blockHeaderSize, + dstCapacity - ZSTD_blockHeaderSize, + srcSize, + zc->tmpWorkspace, + zc->tmpWkspSize, + zc->bmi2 + ); + { + nuint err_code = cSeqsSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if ( + zc->isFirstBlock == 0 + && cSeqsSize < rleMaxLength + && ZSTD_isRLE((byte*)src, srcSize) != 0 + ) + { + cSeqsSize = 1; + } + + if (zc->seqCollector.collectSequences != 0) + { + { + nuint err_code = ZSTD_copyBlockSequences( + &zc->seqCollector, + seqStore, + dRepOriginal.rep + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState); + return 0; + } + + if (cSeqsSize == 0) + { + cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, srcSize, lastBlock); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + *dRep = dRepOriginal; + } + else if (cSeqsSize == 1) + { + cSize = ZSTD_rleCompressBlock(op, dstCapacity, *ip, srcSize, lastBlock); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + *dRep = dRepOriginal; + } + else + { + ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState); + writeBlockHeader(op, cSeqsSize, srcSize, lastBlock); + cSize = ZSTD_blockHeaderSize + cSeqsSize; + } + + if ( + zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat.FSE_repeat_valid + ) + zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat.FSE_repeat_check; + return cSize; + } + + /* Helper function to perform the recursive search for block splits. + * Estimates the cost of seqStore prior to split, and estimates the cost of splitting the sequences in half. + * If advantageous to split, then we recurse down the two sub-blocks. + * If not, or if an error occurred in estimation, then we do not recurse. + * + * Note: The recursion depth is capped by a heuristic minimum number of sequences, + * defined by MIN_SEQUENCES_BLOCK_SPLITTING. + * In theory, this means the absolute largest recursion depth is 10 == log2(maxNbSeqInBlock/MIN_SEQUENCES_BLOCK_SPLITTING). + * In practice, recursion depth usually doesn't go beyond 4. + * + * Furthermore, the number of splits is capped by ZSTD_MAX_NB_BLOCK_SPLITS. + * At ZSTD_MAX_NB_BLOCK_SPLITS == 196 with the current existing blockSize + * maximum of 128 KB, this value is actually impossible to reach. + */ + private static void ZSTD_deriveBlockSplitsHelper( + seqStoreSplits* splits, + nuint startIdx, + nuint endIdx, + ZSTD_CCtx_s* zc, + SeqStore_t* origSeqStore + ) + { + SeqStore_t* fullSeqStoreChunk = &zc->blockSplitCtx.fullSeqStoreChunk; + SeqStore_t* firstHalfSeqStore = &zc->blockSplitCtx.firstHalfSeqStore; + SeqStore_t* secondHalfSeqStore = &zc->blockSplitCtx.secondHalfSeqStore; + nuint estimatedOriginalSize; + nuint estimatedFirstHalfSize; + nuint estimatedSecondHalfSize; + nuint midIdx = (startIdx + endIdx) / 2; + assert(endIdx >= startIdx); + if (endIdx - startIdx < 300 || splits->idx >= 196) + { + return; + } + + ZSTD_deriveSeqStoreChunk(fullSeqStoreChunk, origSeqStore, startIdx, endIdx); + ZSTD_deriveSeqStoreChunk(firstHalfSeqStore, origSeqStore, startIdx, midIdx); + ZSTD_deriveSeqStoreChunk(secondHalfSeqStore, origSeqStore, midIdx, endIdx); + estimatedOriginalSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize( + fullSeqStoreChunk, + zc + ); + estimatedFirstHalfSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize( + firstHalfSeqStore, + zc + ); + estimatedSecondHalfSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize( + secondHalfSeqStore, + zc + ); + if ( + ERR_isError(estimatedOriginalSize) + || ERR_isError(estimatedFirstHalfSize) + || ERR_isError(estimatedSecondHalfSize) + ) + { + return; + } + + if (estimatedFirstHalfSize + estimatedSecondHalfSize < estimatedOriginalSize) + { + ZSTD_deriveBlockSplitsHelper(splits, startIdx, midIdx, zc, origSeqStore); + splits->splitLocations[splits->idx] = (uint)midIdx; + splits->idx++; + ZSTD_deriveBlockSplitsHelper(splits, midIdx, endIdx, zc, origSeqStore); + } + } + + /* Base recursive function. + * Populates a table with intra-block partition indices that can improve compression ratio. + * + * @return: number of splits made (which equals the size of the partition table - 1). + */ + private static nuint ZSTD_deriveBlockSplits(ZSTD_CCtx_s* zc, uint* partitions, uint nbSeq) + { + seqStoreSplits splits; + splits.splitLocations = partitions; + splits.idx = 0; + if (nbSeq <= 4) + { + return 0; + } + + ZSTD_deriveBlockSplitsHelper(&splits, 0, nbSeq, zc, &zc->seqStore); + splits.splitLocations[splits.idx] = nbSeq; + return splits.idx; + } + + /* ZSTD_compressBlock_splitBlock(): + * Attempts to split a given block into multiple blocks to improve compression ratio. + * + * Returns combined size of all blocks (which includes headers), or a ZSTD error code. + */ + private static nuint ZSTD_compressBlock_splitBlock_internal( + ZSTD_CCtx_s* zc, + void* dst, + nuint dstCapacity, + void* src, + nuint blockSize, + uint lastBlock, + uint nbSeq + ) + { + nuint cSize = 0; + byte* ip = (byte*)src; + byte* op = (byte*)dst; + nuint i = 0; + nuint srcBytesTotal = 0; + /* size == ZSTD_MAX_NB_BLOCK_SPLITS */ + uint* partitions = zc->blockSplitCtx.partitions; + SeqStore_t* nextSeqStore = &zc->blockSplitCtx.nextSeqStore; + SeqStore_t* currSeqStore = &zc->blockSplitCtx.currSeqStore; + nuint numSplits = ZSTD_deriveBlockSplits(zc, partitions, nbSeq); + /* If a block is split and some partitions are emitted as RLE/uncompressed, then repcode history + * may become invalid. In order to reconcile potentially invalid repcodes, we keep track of two + * separate repcode histories that simulate repcode history on compression and decompression side, + * and use the histories to determine whether we must replace a particular repcode with its raw offset. + * + * 1) cRep gets updated for each partition, regardless of whether the block was emitted as uncompressed + * or RLE. This allows us to retrieve the offset value that an invalid repcode references within + * a nocompress/RLE block. + * 2) dRep gets updated only for compressed partitions, and when a repcode gets replaced, will use + * the replacement offset value rather than the original repcode to update the repcode history. + * dRep also will be the final repcode history sent to the next block. + * + * See ZSTD_seqStore_resolveOffCodes() for more details. + */ + repcodes_s dRep; + repcodes_s cRep; + memcpy(dRep.rep, zc->blockState.prevCBlock->rep, (uint)sizeof(repcodes_s)); + memcpy(cRep.rep, zc->blockState.prevCBlock->rep, (uint)sizeof(repcodes_s)); + *nextSeqStore = new SeqStore_t(); + if (numSplits == 0) + { + nuint cSizeSingleBlock = ZSTD_compressSeqStore_singleBlock( + zc, + &zc->seqStore, + &dRep, + &cRep, + op, + dstCapacity, + ip, + blockSize, + lastBlock, + 0 + ); + { + nuint err_code = cSizeSingleBlock; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(zc->blockSizeMax <= 1 << 17); + assert(cSizeSingleBlock <= zc->blockSizeMax + ZSTD_blockHeaderSize); + return cSizeSingleBlock; + } + + ZSTD_deriveSeqStoreChunk(currSeqStore, &zc->seqStore, 0, partitions[0]); + for (i = 0; i <= numSplits; ++i) + { + nuint cSizeChunk; + uint lastPartition = i == numSplits ? 1U : 0U; + uint lastBlockEntireSrc = 0; + nuint srcBytes = + ZSTD_countSeqStoreLiteralsBytes(currSeqStore) + + ZSTD_countSeqStoreMatchBytes(currSeqStore); + srcBytesTotal += srcBytes; + if (lastPartition != 0) + { + srcBytes += blockSize - srcBytesTotal; + lastBlockEntireSrc = lastBlock; + } + else + { + ZSTD_deriveSeqStoreChunk( + nextSeqStore, + &zc->seqStore, + partitions[i], + partitions[i + 1] + ); + } + + cSizeChunk = ZSTD_compressSeqStore_singleBlock( + zc, + currSeqStore, + &dRep, + &cRep, + op, + dstCapacity, + ip, + srcBytes, + lastBlockEntireSrc, + 1 + ); + { + nuint err_code = cSizeChunk; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + ip += srcBytes; + op += cSizeChunk; + dstCapacity -= cSizeChunk; + cSize += cSizeChunk; + *currSeqStore = *nextSeqStore; + assert(cSizeChunk <= zc->blockSizeMax + ZSTD_blockHeaderSize); + } + + memcpy(zc->blockState.prevCBlock->rep, dRep.rep, (uint)sizeof(repcodes_s)); + return cSize; + } + + private static nuint ZSTD_compressBlock_splitBlock( + ZSTD_CCtx_s* zc, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + uint lastBlock + ) + { + uint nbSeq; + nuint cSize; + assert(zc->appliedParams.postBlockSplitter == ZSTD_paramSwitch_e.ZSTD_ps_enable); + { + nuint bss = ZSTD_buildSeqStore(zc, src, srcSize); + { + nuint err_code = bss; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (bss == (nuint)ZSTD_BuildSeqStore_e.ZSTDbss_noCompress) + { + if ( + zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode + == FSE_repeat.FSE_repeat_valid + ) + zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = + FSE_repeat.FSE_repeat_check; + if (zc->seqCollector.collectSequences != 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_sequenceProducer_failed) + ); + } + + cSize = ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return cSize; + } + + nbSeq = (uint)(zc->seqStore.sequences - zc->seqStore.sequencesStart); + } + + cSize = ZSTD_compressBlock_splitBlock_internal( + zc, + dst, + dstCapacity, + src, + srcSize, + lastBlock, + nbSeq + ); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return cSize; + } + + private static nuint ZSTD_compressBlock_internal( + ZSTD_CCtx_s* zc, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + uint frame + ) + { + /* This is an estimated upper bound for the length of an rle block. + * This isn't the actual upper bound. + * Finding the real threshold needs further investigation. + */ + const uint rleMaxLength = 25; + nuint cSize; + byte* ip = (byte*)src; + byte* op = (byte*)dst; + { + nuint bss = ZSTD_buildSeqStore(zc, src, srcSize); + { + nuint err_code = bss; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (bss == (nuint)ZSTD_BuildSeqStore_e.ZSTDbss_noCompress) + { + if (zc->seqCollector.collectSequences != 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_sequenceProducer_failed) + ); + } + + cSize = 0; + goto @out; + } + } + + if (zc->seqCollector.collectSequences != 0) + { + { + nuint err_code = ZSTD_copyBlockSequences( + &zc->seqCollector, + ZSTD_getSeqStore(zc), + zc->blockState.prevCBlock->rep + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState); + return 0; + } + + cSize = ZSTD_entropyCompressSeqStore( + &zc->seqStore, + &zc->blockState.prevCBlock->entropy, + &zc->blockState.nextCBlock->entropy, + &zc->appliedParams, + dst, + dstCapacity, + srcSize, + zc->tmpWorkspace, + zc->tmpWkspSize, + zc->bmi2 + ); + if ( + frame != 0 + && zc->isFirstBlock == 0 + && cSize < rleMaxLength + && ZSTD_isRLE(ip, srcSize) != 0 + ) + { + cSize = 1; + op[0] = ip[0]; + } + + @out: + if (!ERR_isError(cSize) && cSize > 1) + { + ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState); + } + + if ( + zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat.FSE_repeat_valid + ) + zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat.FSE_repeat_check; + return cSize; + } + + private static nuint ZSTD_compressBlock_targetCBlockSize_body( + ZSTD_CCtx_s* zc, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + nuint bss, + uint lastBlock + ) + { + if (bss == (nuint)ZSTD_BuildSeqStore_e.ZSTDbss_compress) + { + if ( + zc->isFirstBlock == 0 + && ZSTD_maybeRLE(&zc->seqStore) != 0 + && ZSTD_isRLE((byte*)src, srcSize) != 0 + ) + { + return ZSTD_rleCompressBlock(dst, dstCapacity, *(byte*)src, srcSize, lastBlock); + } + + { + nuint cSize = ZSTD_compressSuperBlock( + zc, + dst, + dstCapacity, + src, + srcSize, + lastBlock + ); + if (cSize != unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall))) + { + nuint maxCSize = + srcSize - ZSTD_minGain(srcSize, zc->appliedParams.cParams.strategy); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (cSize != 0 && cSize < maxCSize + ZSTD_blockHeaderSize) + { + ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState); + return cSize; + } + } + } + } + + return ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock); + } + + private static nuint ZSTD_compressBlock_targetCBlockSize( + ZSTD_CCtx_s* zc, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + uint lastBlock + ) + { + nuint cSize = 0; + nuint bss = ZSTD_buildSeqStore(zc, src, srcSize); + { + nuint err_code = bss; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + cSize = ZSTD_compressBlock_targetCBlockSize_body( + zc, + dst, + dstCapacity, + src, + srcSize, + bss, + lastBlock + ); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if ( + zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat.FSE_repeat_valid + ) + zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat.FSE_repeat_check; + return cSize; + } + + private static void ZSTD_overflowCorrectIfNeeded( + ZSTD_MatchState_t* ms, + ZSTD_cwksp* ws, + ZSTD_CCtx_params_s* @params, + void* ip, + void* iend + ) + { + uint cycleLog = ZSTD_cycleLog(@params->cParams.chainLog, @params->cParams.strategy); + uint maxDist = (uint)1 << (int)@params->cParams.windowLog; + if ( + ZSTD_window_needOverflowCorrection( + ms->window, + cycleLog, + maxDist, + ms->loadedDictEnd, + ip, + iend + ) != 0 + ) + { + uint correction = ZSTD_window_correctOverflow(&ms->window, cycleLog, maxDist, ip); + ZSTD_cwksp_mark_tables_dirty(ws); + ZSTD_reduceIndex(ms, @params, correction); + ZSTD_cwksp_mark_tables_clean(ws); + if (ms->nextToUpdate < correction) + ms->nextToUpdate = 0; + else + ms->nextToUpdate -= correction; + ms->loadedDictEnd = 0; + ms->dictMatchState = null; + } + } + +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_splitLevels => + new int[10] { 0, 0, 1, 2, 2, 3, 3, 4, 4, 4 }; + private static int* splitLevels => + (int*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_splitLevels) + ); +#else + + private static readonly int* splitLevels = GetArrayPointer( + new int[10] { 0, 0, 1, 2, 2, 3, 3, 4, 4, 4 } + ); +#endif + + private static nuint ZSTD_optimalBlockSize( + ZSTD_CCtx_s* cctx, + void* src, + nuint srcSize, + nuint blockSizeMax, + int splitLevel, + ZSTD_strategy strat, + long savings + ) + { + if (srcSize < 128 * (1 << 10) || blockSizeMax < 128 * (1 << 10)) + return srcSize < blockSizeMax ? srcSize : blockSizeMax; + if (savings < 3) + { + return 128 * (1 << 10); + } + + if (splitLevel == 1) + return 128 * (1 << 10); + if (splitLevel == 0) + { + assert(ZSTD_strategy.ZSTD_fast <= strat && strat <= ZSTD_strategy.ZSTD_btultra2); + splitLevel = splitLevels[(int)strat]; + } + else + { + assert(2 <= splitLevel && splitLevel <= 6); + splitLevel -= 2; + } + + return ZSTD_splitBlock( + src, + blockSizeMax, + splitLevel, + cctx->tmpWorkspace, + cctx->tmpWkspSize + ); + } + + /*! ZSTD_compress_frameChunk() : + * Compress a chunk of data into one or multiple blocks. + * All blocks will be terminated, all input will be consumed. + * Function will issue an error if there is not enough `dstCapacity` to hold the compressed content. + * Frame is supposed already started (header already produced) + * @return : compressed size, or an error code + */ + private static nuint ZSTD_compress_frameChunk( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + uint lastFrameChunk + ) + { + nuint blockSizeMax = cctx->blockSizeMax; + nuint remaining = srcSize; + byte* ip = (byte*)src; + byte* ostart = (byte*)dst; + byte* op = ostart; + uint maxDist = (uint)1 << (int)cctx->appliedParams.cParams.windowLog; + long savings = (long)cctx->consumedSrcSize - (long)cctx->producedCSize; + assert(cctx->appliedParams.cParams.windowLog <= (uint)(sizeof(nuint) == 4 ? 30 : 31)); + if (cctx->appliedParams.fParams.checksumFlag != 0 && srcSize != 0) + ZSTD_XXH64_update(&cctx->xxhState, src, srcSize); + while (remaining != 0) + { + ZSTD_MatchState_t* ms = &cctx->blockState.matchState; + nuint blockSize = ZSTD_optimalBlockSize( + cctx, + ip, + remaining, + blockSizeMax, + cctx->appliedParams.preBlockSplitter_level, + cctx->appliedParams.cParams.strategy, + savings + ); + uint lastBlock = lastFrameChunk & (uint)(blockSize == remaining ? 1 : 0); + assert(blockSize <= remaining); + if (dstCapacity < ZSTD_blockHeaderSize + (nuint)(1 + 1) + 1) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + ZSTD_overflowCorrectIfNeeded( + ms, + &cctx->workspace, + &cctx->appliedParams, + ip, + ip + blockSize + ); + ZSTD_checkDictValidity( + &ms->window, + ip + blockSize, + maxDist, + &ms->loadedDictEnd, + &ms->dictMatchState + ); + ZSTD_window_enforceMaxDist( + &ms->window, + ip, + maxDist, + &ms->loadedDictEnd, + &ms->dictMatchState + ); + if (ms->nextToUpdate < ms->window.lowLimit) + ms->nextToUpdate = ms->window.lowLimit; + { + nuint cSize; + if (ZSTD_useTargetCBlockSize(&cctx->appliedParams) != 0) + { + cSize = ZSTD_compressBlock_targetCBlockSize( + cctx, + op, + dstCapacity, + ip, + blockSize, + lastBlock + ); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(cSize > 0); + assert(cSize <= blockSize + ZSTD_blockHeaderSize); + } + else if (ZSTD_blockSplitterEnabled(&cctx->appliedParams) != 0) + { + cSize = ZSTD_compressBlock_splitBlock( + cctx, + op, + dstCapacity, + ip, + blockSize, + lastBlock + ); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(cSize > 0 || cctx->seqCollector.collectSequences == 1); + } + else + { + cSize = ZSTD_compressBlock_internal( + cctx, + op + ZSTD_blockHeaderSize, + dstCapacity - ZSTD_blockHeaderSize, + ip, + blockSize, + 1 + ); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (cSize == 0) + { + cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + } + else + { + uint cBlockHeader = + cSize == 1 + ? lastBlock + + ((uint)blockType_e.bt_rle << 1) + + (uint)(blockSize << 3) + : lastBlock + + ((uint)blockType_e.bt_compressed << 1) + + (uint)(cSize << 3); + MEM_writeLE24(op, cBlockHeader); + cSize += ZSTD_blockHeaderSize; + } + } + + savings += (long)blockSize - (long)cSize; + ip += blockSize; + assert(remaining >= blockSize); + remaining -= blockSize; + op += cSize; + assert(dstCapacity >= cSize); + dstCapacity -= cSize; + cctx->isFirstBlock = 0; + } + } + + if (lastFrameChunk != 0 && op > ostart) + cctx->stage = ZSTD_compressionStage_e.ZSTDcs_ending; + return (nuint)(op - ostart); + } + + private static nuint ZSTD_writeFrameHeader( + void* dst, + nuint dstCapacity, + ZSTD_CCtx_params_s* @params, + ulong pledgedSrcSize, + uint dictID + ) + { + byte* op = (byte*)dst; + /* 0-3 */ + uint dictIDSizeCodeLength = (uint)( + (dictID > 0 ? 1 : 0) + (dictID >= 256 ? 1 : 0) + (dictID >= 65536 ? 1 : 0) + ); + /* 0-3 */ + uint dictIDSizeCode = @params->fParams.noDictIDFlag != 0 ? 0 : dictIDSizeCodeLength; + uint checksumFlag = @params->fParams.checksumFlag > 0 ? 1U : 0U; + uint windowSize = (uint)1 << (int)@params->cParams.windowLog; + uint singleSegment = + @params->fParams.contentSizeFlag != 0 && windowSize >= pledgedSrcSize ? 1U : 0U; + byte windowLogByte = (byte)(@params->cParams.windowLog - 10 << 3); + uint fcsCode = (uint)( + @params->fParams.contentSizeFlag != 0 + ? (pledgedSrcSize >= 256 ? 1 : 0) + + (pledgedSrcSize >= 65536 + 256 ? 1 : 0) + + (pledgedSrcSize >= 0xFFFFFFFFU ? 1 : 0) + : 0 + ); + byte frameHeaderDescriptionByte = (byte)( + dictIDSizeCode + (checksumFlag << 2) + (singleSegment << 5) + (fcsCode << 6) + ); + nuint pos = 0; + assert(!(@params->fParams.contentSizeFlag != 0 && pledgedSrcSize == unchecked(0UL - 1))); + if (dstCapacity < 18) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (@params->format == ZSTD_format_e.ZSTD_f_zstd1) + { + MEM_writeLE32(dst, 0xFD2FB528); + pos = 4; + } + + op[pos++] = frameHeaderDescriptionByte; + if (singleSegment == 0) + op[pos++] = windowLogByte; + switch (dictIDSizeCode) + { + default: + assert(0 != 0); + goto case 0; + case 0: + break; + case 1: + op[pos] = (byte)dictID; + pos++; + break; + case 2: + MEM_writeLE16(op + pos, (ushort)dictID); + pos += 2; + break; + case 3: + MEM_writeLE32(op + pos, dictID); + pos += 4; + break; + } + + switch (fcsCode) + { + default: + assert(0 != 0); + goto case 0; + case 0: + if (singleSegment != 0) + op[pos++] = (byte)pledgedSrcSize; + break; + case 1: + MEM_writeLE16(op + pos, (ushort)(pledgedSrcSize - 256)); + pos += 2; + break; + case 2: + MEM_writeLE32(op + pos, (uint)pledgedSrcSize); + pos += 4; + break; + case 3: + MEM_writeLE64(op + pos, pledgedSrcSize); + pos += 8; + break; + } + + return pos; + } + + /* ZSTD_writeSkippableFrame_advanced() : + * Writes out a skippable frame with the specified magic number variant (16 are supported), + * from ZSTD_MAGIC_SKIPPABLE_START to ZSTD_MAGIC_SKIPPABLE_START+15, and the desired source data. + * + * Returns the total number of bytes written, or a ZSTD error code. + */ + public static nuint ZSTD_writeSkippableFrame( + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + uint magicVariant + ) + { + byte* op = (byte*)dst; + if (dstCapacity < srcSize + 8) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (srcSize > 0xFFFFFFFF) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if (magicVariant > 15) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + MEM_writeLE32(op, 0x184D2A50 + magicVariant); + MEM_writeLE32(op + 4, (uint)srcSize); + memcpy(op + 8, src, (uint)srcSize); + return srcSize + 8; + } + + /* ZSTD_writeLastEmptyBlock() : + * output an empty Block with end-of-frame mark to complete a frame + * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h)) + * or an error code if `dstCapacity` is too small (stage == ZSTD_compressionStage_e.ZSTDcs_init); + assert( + nbSeq == 0 + || cctx->appliedParams.ldmParams.enableLdm != ZSTD_paramSwitch_e.ZSTD_ps_enable + ); + cctx->externSeqStore.seq = seq; + cctx->externSeqStore.size = nbSeq; + cctx->externSeqStore.capacity = nbSeq; + cctx->externSeqStore.pos = 0; + cctx->externSeqStore.posInSequence = 0; + } + + private static nuint ZSTD_compressContinue_internal( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + uint frame, + uint lastFrameChunk + ) + { + ZSTD_MatchState_t* ms = &cctx->blockState.matchState; + nuint fhSize = 0; + if (cctx->stage == ZSTD_compressionStage_e.ZSTDcs_created) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + if (frame != 0 && cctx->stage == ZSTD_compressionStage_e.ZSTDcs_init) + { + fhSize = ZSTD_writeFrameHeader( + dst, + dstCapacity, + &cctx->appliedParams, + cctx->pledgedSrcSizePlusOne - 1, + cctx->dictID + ); + { + nuint err_code = fhSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(fhSize <= dstCapacity); + dstCapacity -= fhSize; + dst = (sbyte*)dst + fhSize; + cctx->stage = ZSTD_compressionStage_e.ZSTDcs_ongoing; + } + + if (srcSize == 0) + return fhSize; + if (ZSTD_window_update(&ms->window, src, srcSize, ms->forceNonContiguous) == 0) + { + ms->forceNonContiguous = 0; + ms->nextToUpdate = ms->window.dictLimit; + } + + if (cctx->appliedParams.ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable) + { + ZSTD_window_update(&cctx->ldmState.window, src, srcSize, 0); + } + + if (frame == 0) + { + ZSTD_overflowCorrectIfNeeded( + ms, + &cctx->workspace, + &cctx->appliedParams, + src, + (byte*)src + srcSize + ); + } + + { + nuint cSize = + frame != 0 + ? ZSTD_compress_frameChunk(cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) + : ZSTD_compressBlock_internal(cctx, dst, dstCapacity, src, srcSize, 0); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + cctx->consumedSrcSize += srcSize; + cctx->producedCSize += cSize + fhSize; + assert( + !( + cctx->appliedParams.fParams.contentSizeFlag != 0 + && cctx->pledgedSrcSizePlusOne == 0 + ) + ); + if (cctx->pledgedSrcSizePlusOne != 0) + { + if (cctx->consumedSrcSize + 1 > cctx->pledgedSrcSizePlusOne) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + } + + return cSize + fhSize; + } + } + + private static nuint ZSTD_compressContinue_public( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize + ) + { + return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1, 0); + } + + /* NOTE: Must just wrap ZSTD_compressContinue_public() */ + public static nuint ZSTD_compressContinue( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize + ) + { + return ZSTD_compressContinue_public(cctx, dst, dstCapacity, src, srcSize); + } + + private static nuint ZSTD_getBlockSize_deprecated(ZSTD_CCtx_s* cctx) + { + ZSTD_compressionParameters cParams = cctx->appliedParams.cParams; + assert(ZSTD_checkCParams(cParams) == 0); + return cctx->appliedParams.maxBlockSize < (nuint)1 << (int)cParams.windowLog + ? cctx->appliedParams.maxBlockSize + : (nuint)1 << (int)cParams.windowLog; + } + + /* NOTE: Must just wrap ZSTD_getBlockSize_deprecated() */ + public static nuint ZSTD_getBlockSize(ZSTD_CCtx_s* cctx) + { + return ZSTD_getBlockSize_deprecated(cctx); + } + + /* NOTE: Must just wrap ZSTD_compressBlock_deprecated() */ + private static nuint ZSTD_compressBlock_deprecated( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize + ) + { + { + nuint blockSizeMax = ZSTD_getBlockSize_deprecated(cctx); + if (srcSize > blockSizeMax) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + } + + return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0, 0); + } + + /* NOTE: Must just wrap ZSTD_compressBlock_deprecated() */ + public static nuint ZSTD_compressBlock( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_deprecated(cctx, dst, dstCapacity, src, srcSize); + } + + /*! ZSTD_loadDictionaryContent() : + * @return : 0, or an error code + */ + private static nuint ZSTD_loadDictionaryContent( + ZSTD_MatchState_t* ms, + ldmState_t* ls, + ZSTD_cwksp* ws, + ZSTD_CCtx_params_s* @params, + void* src, + nuint srcSize, + ZSTD_dictTableLoadMethod_e dtlm, + ZSTD_tableFillPurpose_e tfp + ) + { + byte* ip = (byte*)src; + byte* iend = ip + srcSize; + int loadLdmDict = + @params->ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable && ls != null ? 1 : 0; + ZSTD_assertEqualCParams(@params->cParams, ms->cParams); + { + /* Allow the dictionary to set indices up to exactly ZSTD_CURRENT_MAX. + * Dictionaries right at the edge will immediately trigger overflow + * correction, but I don't want to insert extra constraints here. + */ + uint maxDictSize = (MEM_64bits ? 3500U * (1 << 20) : 2000U * (1 << 20)) - 2; + int CDictTaggedIndices = ZSTD_CDictIndicesAreTagged(&@params->cParams); + if (CDictTaggedIndices != 0 && tfp == ZSTD_tableFillPurpose_e.ZSTD_tfp_forCDict) + { + /* Some dictionary matchfinders in zstd use "short cache", + * which treats the lower ZSTD_SHORT_CACHE_TAG_BITS of each + * CDict hashtable entry as a tag rather than as part of an index. + * When short cache is used, we need to truncate the dictionary + * so that its indices don't overlap with the tag. */ + const uint shortCacheMaxDictSize = (1U << 32 - 8) - 2; + maxDictSize = + maxDictSize < shortCacheMaxDictSize ? maxDictSize : shortCacheMaxDictSize; + assert(loadLdmDict == 0); + } + + if (srcSize > maxDictSize) + { + ip = iend - maxDictSize; + src = ip; + srcSize = maxDictSize; + } + } + + if (srcSize > unchecked((uint)-1) - (MEM_64bits ? 3500U * (1 << 20) : 2000U * (1 << 20))) + { + assert(ZSTD_window_isEmpty(ms->window) != 0); +#if DEBUG + if (loadLdmDict != 0) + assert(ZSTD_window_isEmpty(ls->window) != 0); +#endif + } + + ZSTD_window_update(&ms->window, src, srcSize, 0); + if (loadLdmDict != 0) + { + ZSTD_window_update(&ls->window, src, srcSize, 0); + ls->loadedDictEnd = @params->forceWindow != 0 ? 0 : (uint)(iend - ls->window.@base); + ZSTD_ldm_fillHashTable(ls, ip, iend, &@params->ldmParams); + } + + { + uint maxDictSize = + 1U + << (int)( + ( + @params->cParams.hashLog + 3 > @params->cParams.chainLog + 1 + ? @params->cParams.hashLog + 3 + : @params->cParams.chainLog + 1 + ) < 31 + ? @params->cParams.hashLog + 3 > @params->cParams.chainLog + 1 + ? @params->cParams.hashLog + 3 + : @params->cParams.chainLog + 1 + : 31 + ); + if (srcSize > maxDictSize) + { + ip = iend - maxDictSize; + src = ip; + srcSize = maxDictSize; + } + } + + ms->nextToUpdate = (uint)(ip - ms->window.@base); + ms->loadedDictEnd = @params->forceWindow != 0 ? 0 : (uint)(iend - ms->window.@base); + ms->forceNonContiguous = @params->deterministicRefPrefix; + if (srcSize <= 8) + return 0; + ZSTD_overflowCorrectIfNeeded(ms, ws, @params, ip, iend); + switch (@params->cParams.strategy) + { + case ZSTD_strategy.ZSTD_fast: + ZSTD_fillHashTable(ms, iend, dtlm, tfp); + break; + case ZSTD_strategy.ZSTD_dfast: + ZSTD_fillDoubleHashTable(ms, iend, dtlm, tfp); + break; + case ZSTD_strategy.ZSTD_greedy: + case ZSTD_strategy.ZSTD_lazy: + case ZSTD_strategy.ZSTD_lazy2: + assert(srcSize >= 8); + if (ms->dedicatedDictSearch != 0) + { + assert(ms->chainTable != null); + ZSTD_dedicatedDictSearch_lazy_loadDictionary(ms, iend - 8); + } + else + { + assert(@params->useRowMatchFinder != ZSTD_paramSwitch_e.ZSTD_ps_auto); + if (@params->useRowMatchFinder == ZSTD_paramSwitch_e.ZSTD_ps_enable) + { + nuint tagTableSize = (nuint)1 << (int)@params->cParams.hashLog; + memset(ms->tagTable, 0, (uint)tagTableSize); + ZSTD_row_update(ms, iend - 8); + } + else + { + ZSTD_insertAndFindFirstIndex(ms, iend - 8); + } + } + + break; + case ZSTD_strategy.ZSTD_btlazy2: + case ZSTD_strategy.ZSTD_btopt: + case ZSTD_strategy.ZSTD_btultra: + case ZSTD_strategy.ZSTD_btultra2: + assert(srcSize >= 8); + ZSTD_updateTree(ms, iend - 8, iend); + break; + default: + assert(0 != 0); + break; + } + + ms->nextToUpdate = (uint)(iend - ms->window.@base); + return 0; + } + + /* Dictionaries that assign zero probability to symbols that show up causes problems + * when FSE encoding. Mark dictionaries with zero probability symbols as FSE_repeat_check + * and only dictionaries with 100% valid symbols can be assumed valid. + */ + private static FSE_repeat ZSTD_dictNCountRepeat( + short* normalizedCounter, + uint dictMaxSymbolValue, + uint maxSymbolValue + ) + { + uint s; + if (dictMaxSymbolValue < maxSymbolValue) + { + return FSE_repeat.FSE_repeat_check; + } + + for (s = 0; s <= maxSymbolValue; ++s) + { + if (normalizedCounter[s] == 0) + { + return FSE_repeat.FSE_repeat_check; + } + } + + return FSE_repeat.FSE_repeat_valid; + } + + /* ZSTD_loadCEntropy() : + * dict : must point at beginning of a valid zstd dictionary. + * return : size of dictionary header (size of magic number + dict ID + entropy tables) + * assumptions : magic number supposed already checked + * and dictSize >= 8 */ + private static nuint ZSTD_loadCEntropy( + ZSTD_compressedBlockState_t* bs, + void* workspace, + void* dict, + nuint dictSize + ) + { + short* offcodeNCount = stackalloc short[32]; + uint offcodeMaxValue = 31; + /* skip magic num and dict ID */ + byte* dictPtr = (byte*)dict; + byte* dictEnd = dictPtr + dictSize; + dictPtr += 8; + bs->entropy.huf.repeatMode = HUF_repeat.HUF_repeat_check; + { + uint maxSymbolValue = 255; + uint hasZeroWeights = 1; + nuint hufHeaderSize = HUF_readCTable( + &bs->entropy.huf.CTable.e0, + &maxSymbolValue, + dictPtr, + (nuint)(dictEnd - dictPtr), + &hasZeroWeights + ); + if (hasZeroWeights == 0 && maxSymbolValue == 255) + bs->entropy.huf.repeatMode = HUF_repeat.HUF_repeat_valid; + if (ERR_isError(hufHeaderSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + dictPtr += hufHeaderSize; + } + + { + uint offcodeLog; + nuint offcodeHeaderSize = FSE_readNCount( + offcodeNCount, + &offcodeMaxValue, + &offcodeLog, + dictPtr, + (nuint)(dictEnd - dictPtr) + ); + if (ERR_isError(offcodeHeaderSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + if (offcodeLog > 8) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + if ( + ERR_isError( + FSE_buildCTable_wksp( + bs->entropy.fse.offcodeCTable, + offcodeNCount, + 31, + offcodeLog, + workspace, + (8 << 10) + 512 + ) + ) + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + dictPtr += offcodeHeaderSize; + } + + { + short* matchlengthNCount = stackalloc short[53]; + uint matchlengthMaxValue = 52, + matchlengthLog; + nuint matchlengthHeaderSize = FSE_readNCount( + matchlengthNCount, + &matchlengthMaxValue, + &matchlengthLog, + dictPtr, + (nuint)(dictEnd - dictPtr) + ); + if (ERR_isError(matchlengthHeaderSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + if (matchlengthLog > 9) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + if ( + ERR_isError( + FSE_buildCTable_wksp( + bs->entropy.fse.matchlengthCTable, + matchlengthNCount, + matchlengthMaxValue, + matchlengthLog, + workspace, + (8 << 10) + 512 + ) + ) + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + bs->entropy.fse.matchlength_repeatMode = ZSTD_dictNCountRepeat( + matchlengthNCount, + matchlengthMaxValue, + 52 + ); + dictPtr += matchlengthHeaderSize; + } + + { + short* litlengthNCount = stackalloc short[36]; + uint litlengthMaxValue = 35, + litlengthLog; + nuint litlengthHeaderSize = FSE_readNCount( + litlengthNCount, + &litlengthMaxValue, + &litlengthLog, + dictPtr, + (nuint)(dictEnd - dictPtr) + ); + if (ERR_isError(litlengthHeaderSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + if (litlengthLog > 9) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + if ( + ERR_isError( + FSE_buildCTable_wksp( + bs->entropy.fse.litlengthCTable, + litlengthNCount, + litlengthMaxValue, + litlengthLog, + workspace, + (8 << 10) + 512 + ) + ) + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + bs->entropy.fse.litlength_repeatMode = ZSTD_dictNCountRepeat( + litlengthNCount, + litlengthMaxValue, + 35 + ); + dictPtr += litlengthHeaderSize; + } + + if (dictPtr + 12 > dictEnd) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + bs->rep[0] = MEM_readLE32(dictPtr + 0); + bs->rep[1] = MEM_readLE32(dictPtr + 4); + bs->rep[2] = MEM_readLE32(dictPtr + 8); + dictPtr += 12; + { + nuint dictContentSize = (nuint)(dictEnd - dictPtr); + uint offcodeMax = 31; + if (dictContentSize <= unchecked((uint)-1) - 128 * (1 << 10)) + { + /* The maximum offset that must be supported */ + uint maxOffset = (uint)dictContentSize + 128 * (1 << 10); + offcodeMax = ZSTD_highbit32(maxOffset); + } + + bs->entropy.fse.offcode_repeatMode = ZSTD_dictNCountRepeat( + offcodeNCount, + offcodeMaxValue, + offcodeMax < 31 ? offcodeMax : 31 + ); + { + uint u; + for (u = 0; u < 3; u++) + { + if (bs->rep[u] == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted) + ); + } + + if (bs->rep[u] > dictContentSize) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted) + ); + } + } + } + } + + return (nuint)(dictPtr - (byte*)dict); + } + + /* Dictionary format : + * See : + * https://github.com/facebook/zstd/blob/release/doc/zstd_compression_format.md#dictionary-format + */ + /*! ZSTD_loadZstdDictionary() : + * @return : dictID, or an error code + * assumptions : magic number supposed already checked + * dictSize supposed >= 8 + */ + private static nuint ZSTD_loadZstdDictionary( + ZSTD_compressedBlockState_t* bs, + ZSTD_MatchState_t* ms, + ZSTD_cwksp* ws, + ZSTD_CCtx_params_s* @params, + void* dict, + nuint dictSize, + ZSTD_dictTableLoadMethod_e dtlm, + ZSTD_tableFillPurpose_e tfp, + void* workspace + ) + { + byte* dictPtr = (byte*)dict; + byte* dictEnd = dictPtr + dictSize; + nuint dictID; + nuint eSize; + assert(dictSize >= 8); + assert(MEM_readLE32(dictPtr) == 0xEC30A437); + dictID = @params->fParams.noDictIDFlag != 0 ? 0 : MEM_readLE32(dictPtr + 4); + eSize = ZSTD_loadCEntropy(bs, workspace, dict, dictSize); + { + nuint err_code = eSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + dictPtr += eSize; + { + nuint dictContentSize = (nuint)(dictEnd - dictPtr); + { + nuint err_code = ZSTD_loadDictionaryContent( + ms, + null, + ws, + @params, + dictPtr, + dictContentSize, + dtlm, + tfp + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + } + + return dictID; + } + + /** ZSTD_compress_insertDictionary() : + * @return : dictID, or an error code */ + private static nuint ZSTD_compress_insertDictionary( + ZSTD_compressedBlockState_t* bs, + ZSTD_MatchState_t* ms, + ldmState_t* ls, + ZSTD_cwksp* ws, + ZSTD_CCtx_params_s* @params, + void* dict, + nuint dictSize, + ZSTD_dictContentType_e dictContentType, + ZSTD_dictTableLoadMethod_e dtlm, + ZSTD_tableFillPurpose_e tfp, + void* workspace + ) + { + if (dict == null || dictSize < 8) + { + if (dictContentType == ZSTD_dictContentType_e.ZSTD_dct_fullDict) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_wrong)); + } + + return 0; + } + + ZSTD_reset_compressedBlockState(bs); + if (dictContentType == ZSTD_dictContentType_e.ZSTD_dct_rawContent) + return ZSTD_loadDictionaryContent(ms, ls, ws, @params, dict, dictSize, dtlm, tfp); + if (MEM_readLE32(dict) != 0xEC30A437) + { + if (dictContentType == ZSTD_dictContentType_e.ZSTD_dct_auto) + { + return ZSTD_loadDictionaryContent(ms, ls, ws, @params, dict, dictSize, dtlm, tfp); + } + + if (dictContentType == ZSTD_dictContentType_e.ZSTD_dct_fullDict) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_wrong)); + } + + assert(0 != 0); + } + + return ZSTD_loadZstdDictionary(bs, ms, ws, @params, dict, dictSize, dtlm, tfp, workspace); + } + + /*! ZSTD_compressBegin_internal() : + * Assumption : either @dict OR @cdict (or none) is non-NULL, never both + * @return : 0, or an error code */ + private static nuint ZSTD_compressBegin_internal( + ZSTD_CCtx_s* cctx, + void* dict, + nuint dictSize, + ZSTD_dictContentType_e dictContentType, + ZSTD_dictTableLoadMethod_e dtlm, + ZSTD_CDict_s* cdict, + ZSTD_CCtx_params_s* @params, + ulong pledgedSrcSize, + ZSTD_buffered_policy_e zbuff + ) + { + nuint dictContentSize = cdict != null ? cdict->dictContentSize : dictSize; + assert(!ERR_isError(ZSTD_checkCParams(@params->cParams))); + assert(!(dict != null && cdict != null)); + if ( + cdict != null + && cdict->dictContentSize > 0 + && ( + pledgedSrcSize < 128 * (1 << 10) + || pledgedSrcSize < cdict->dictContentSize * 6UL + || pledgedSrcSize == unchecked(0UL - 1) + || cdict->compressionLevel == 0 + ) + && @params->attachDictPref != ZSTD_dictAttachPref_e.ZSTD_dictForceLoad + ) + { + return ZSTD_resetCCtx_usingCDict(cctx, cdict, @params, pledgedSrcSize, zbuff); + } + + { + nuint err_code = ZSTD_resetCCtx_internal( + cctx, + @params, + pledgedSrcSize, + dictContentSize, + ZSTD_compResetPolicy_e.ZSTDcrp_makeClean, + zbuff + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint dictID = + cdict != null + ? ZSTD_compress_insertDictionary( + cctx->blockState.prevCBlock, + &cctx->blockState.matchState, + &cctx->ldmState, + &cctx->workspace, + &cctx->appliedParams, + cdict->dictContent, + cdict->dictContentSize, + cdict->dictContentType, + dtlm, + ZSTD_tableFillPurpose_e.ZSTD_tfp_forCCtx, + cctx->tmpWorkspace + ) + : ZSTD_compress_insertDictionary( + cctx->blockState.prevCBlock, + &cctx->blockState.matchState, + &cctx->ldmState, + &cctx->workspace, + &cctx->appliedParams, + dict, + dictSize, + dictContentType, + dtlm, + ZSTD_tableFillPurpose_e.ZSTD_tfp_forCCtx, + cctx->tmpWorkspace + ); + { + nuint err_code = dictID; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(dictID <= 0xffffffff); + cctx->dictID = (uint)dictID; + cctx->dictContentSize = dictContentSize; + } + + return 0; + } + + /* ZSTD_compressBegin_advanced_internal() : + * Private use only. To be called from zstdmt_compress.c. */ + private static nuint ZSTD_compressBegin_advanced_internal( + ZSTD_CCtx_s* cctx, + void* dict, + nuint dictSize, + ZSTD_dictContentType_e dictContentType, + ZSTD_dictTableLoadMethod_e dtlm, + ZSTD_CDict_s* cdict, + ZSTD_CCtx_params_s* @params, + ulong pledgedSrcSize + ) + { + { + /* compression parameters verification and optimization */ + nuint err_code = ZSTD_checkCParams(@params->cParams); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return ZSTD_compressBegin_internal( + cctx, + dict, + dictSize, + dictContentType, + dtlm, + cdict, + @params, + pledgedSrcSize, + ZSTD_buffered_policy_e.ZSTDb_not_buffered + ); + } + + /*! ZSTD_compressBegin_advanced() : + * @return : 0, or an error code */ + public static nuint ZSTD_compressBegin_advanced( + ZSTD_CCtx_s* cctx, + void* dict, + nuint dictSize, + ZSTD_parameters @params, + ulong pledgedSrcSize + ) + { + ZSTD_CCtx_params_s cctxParams; + ZSTD_CCtxParams_init_internal(&cctxParams, &@params, 0); + return ZSTD_compressBegin_advanced_internal( + cctx, + dict, + dictSize, + ZSTD_dictContentType_e.ZSTD_dct_auto, + ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast, + null, + &cctxParams, + pledgedSrcSize + ); + } + + private static nuint ZSTD_compressBegin_usingDict_deprecated( + ZSTD_CCtx_s* cctx, + void* dict, + nuint dictSize, + int compressionLevel + ) + { + ZSTD_CCtx_params_s cctxParams; + { + ZSTD_parameters @params = ZSTD_getParams_internal( + compressionLevel, + unchecked(0UL - 1), + dictSize, + ZSTD_CParamMode_e.ZSTD_cpm_noAttachDict + ); + ZSTD_CCtxParams_init_internal( + &cctxParams, + &@params, + compressionLevel == 0 ? 3 : compressionLevel + ); + } + + return ZSTD_compressBegin_internal( + cctx, + dict, + dictSize, + ZSTD_dictContentType_e.ZSTD_dct_auto, + ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast, + null, + &cctxParams, + unchecked(0UL - 1), + ZSTD_buffered_policy_e.ZSTDb_not_buffered + ); + } + + public static nuint ZSTD_compressBegin_usingDict( + ZSTD_CCtx_s* cctx, + void* dict, + nuint dictSize, + int compressionLevel + ) + { + return ZSTD_compressBegin_usingDict_deprecated(cctx, dict, dictSize, compressionLevel); + } + + /*===== Buffer-less streaming compression functions =====*/ + public static nuint ZSTD_compressBegin(ZSTD_CCtx_s* cctx, int compressionLevel) + { + return ZSTD_compressBegin_usingDict_deprecated(cctx, null, 0, compressionLevel); + } + + /*! ZSTD_writeEpilogue() : + * Ends a frame. + * @return : nb of bytes written into dst (or an error code) */ + private static nuint ZSTD_writeEpilogue(ZSTD_CCtx_s* cctx, void* dst, nuint dstCapacity) + { + byte* ostart = (byte*)dst; + byte* op = ostart; + if (cctx->stage == ZSTD_compressionStage_e.ZSTDcs_created) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + if (cctx->stage == ZSTD_compressionStage_e.ZSTDcs_init) + { + nuint fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams, 0, 0); + { + nuint err_code = fhSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + dstCapacity -= fhSize; + op += fhSize; + cctx->stage = ZSTD_compressionStage_e.ZSTDcs_ongoing; + } + + if (cctx->stage != ZSTD_compressionStage_e.ZSTDcs_ending) + { + /* last block */ + uint cBlockHeader24 = 1 + ((uint)blockType_e.bt_raw << 1) + 0; + if (dstCapacity < 3) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + MEM_writeLE24(op, cBlockHeader24); + op += ZSTD_blockHeaderSize; + dstCapacity -= ZSTD_blockHeaderSize; + } + + if (cctx->appliedParams.fParams.checksumFlag != 0) + { + uint checksum = (uint)ZSTD_XXH64_digest(&cctx->xxhState); + if (dstCapacity < 4) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + MEM_writeLE32(op, checksum); + op += 4; + } + + cctx->stage = ZSTD_compressionStage_e.ZSTDcs_created; + return (nuint)(op - ostart); + } + + /** ZSTD_CCtx_trace() : + * Trace the end of a compression call. + */ + private static void ZSTD_CCtx_trace(ZSTD_CCtx_s* cctx, nuint extraCSize) { } + + private static nuint ZSTD_compressEnd_public( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize + ) + { + nuint endResult; + nuint cSize = ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1, 1); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + endResult = ZSTD_writeEpilogue(cctx, (sbyte*)dst + cSize, dstCapacity - cSize); + { + nuint err_code = endResult; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert( + !(cctx->appliedParams.fParams.contentSizeFlag != 0 && cctx->pledgedSrcSizePlusOne == 0) + ); + if (cctx->pledgedSrcSizePlusOne != 0) + { + if (cctx->pledgedSrcSizePlusOne != cctx->consumedSrcSize + 1) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + } + + ZSTD_CCtx_trace(cctx, endResult); + return cSize + endResult; + } + + /* NOTE: Must just wrap ZSTD_compressEnd_public() */ + public static nuint ZSTD_compressEnd( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize + ) + { + return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize); + } + + /*! ZSTD_compress_advanced() : + * Note : this function is now DEPRECATED. + * It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_setParameter() and other parameter setters. + * This prototype will generate compilation warnings. */ + public static nuint ZSTD_compress_advanced( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + void* dict, + nuint dictSize, + ZSTD_parameters @params + ) + { + { + nuint err_code = ZSTD_checkCParams(@params.cParams); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + ZSTD_CCtxParams_init_internal(&cctx->simpleApiParams, &@params, 0); + return ZSTD_compress_advanced_internal( + cctx, + dst, + dstCapacity, + src, + srcSize, + dict, + dictSize, + &cctx->simpleApiParams + ); + } + + /* Internal */ + private static nuint ZSTD_compress_advanced_internal( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + void* dict, + nuint dictSize, + ZSTD_CCtx_params_s* @params + ) + { + { + nuint err_code = ZSTD_compressBegin_internal( + cctx, + dict, + dictSize, + ZSTD_dictContentType_e.ZSTD_dct_auto, + ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast, + null, + @params, + srcSize, + ZSTD_buffered_policy_e.ZSTDb_not_buffered + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize); + } + + /************************** + * Simple dictionary API + ***************************/ + /*! ZSTD_compress_usingDict() : + * Compression at an explicit compression level using a Dictionary. + * A dictionary can be any arbitrary data segment (also called a prefix), + * or a buffer with specified information (see zdict.h). + * Note : This function loads the dictionary, resulting in significant startup delay. + * It's intended for a dictionary used only once. + * Note 2 : When `dict == NULL || dictSize < 8` no dictionary is used. */ + public static nuint ZSTD_compress_usingDict( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + void* dict, + nuint dictSize, + int compressionLevel + ) + { + { + ZSTD_parameters @params = ZSTD_getParams_internal( + compressionLevel, + srcSize, + dict != null ? dictSize : 0, + ZSTD_CParamMode_e.ZSTD_cpm_noAttachDict + ); + assert(@params.fParams.contentSizeFlag == 1); + ZSTD_CCtxParams_init_internal( + &cctx->simpleApiParams, + &@params, + compressionLevel == 0 ? 3 : compressionLevel + ); + } + + return ZSTD_compress_advanced_internal( + cctx, + dst, + dstCapacity, + src, + srcSize, + dict, + dictSize, + &cctx->simpleApiParams + ); + } + + /*! ZSTD_compressCCtx() : + * Same as ZSTD_compress(), using an explicit ZSTD_CCtx. + * Important : in order to mirror `ZSTD_compress()` behavior, + * this function compresses at the requested compression level, + * __ignoring any other advanced parameter__ . + * If any advanced parameter was set using the advanced API, + * they will all be reset. Only @compressionLevel remains. + */ + public static nuint ZSTD_compressCCtx( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + int compressionLevel + ) + { + assert(cctx != null); + return ZSTD_compress_usingDict( + cctx, + dst, + dstCapacity, + src, + srcSize, + null, + 0, + compressionLevel + ); + } + + /*************************************** + * Simple Core API + ***************************************/ + /*! ZSTD_compress() : + * Compresses `src` content as a single zstd compressed frame into already allocated `dst`. + * NOTE: Providing `dstCapacity >= ZSTD_compressBound(srcSize)` guarantees that zstd will have + * enough space to successfully compress the data. + * @return : compressed size written into `dst` (<= `dstCapacity), + * or an error code if it fails (which can be tested using ZSTD_isError()). */ + public static nuint ZSTD_compress( + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + int compressionLevel + ) + { + nuint result; + ZSTD_CCtx_s ctxBody; + ZSTD_initCCtx(&ctxBody, ZSTD_defaultCMem); + result = ZSTD_compressCCtx(&ctxBody, dst, dstCapacity, src, srcSize, compressionLevel); + ZSTD_freeCCtxContent(&ctxBody); + return result; + } + + /*! ZSTD_estimateCDictSize_advanced() : + * Estimate amount of memory that will be needed to create a dictionary with following arguments */ + public static nuint ZSTD_estimateCDictSize_advanced( + nuint dictSize, + ZSTD_compressionParameters cParams, + ZSTD_dictLoadMethod_e dictLoadMethod + ) + { + return ZSTD_cwksp_alloc_size((nuint)sizeof(ZSTD_CDict_s)) + + ZSTD_cwksp_alloc_size((8 << 10) + 512) + + ZSTD_sizeof_matchState( + &cParams, + ZSTD_resolveRowMatchFinderMode(ZSTD_paramSwitch_e.ZSTD_ps_auto, &cParams), + 1, + 0 + ) + + ( + dictLoadMethod == ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef + ? 0 + : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, (nuint)sizeof(void*))) + ); + } + + /*! ZSTD_estimate?DictSize() : + * ZSTD_estimateCDictSize() will bet that src size is relatively "small", and content is copied, like ZSTD_createCDict(). + * ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced(). + * Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller. + */ + public static nuint ZSTD_estimateCDictSize(nuint dictSize, int compressionLevel) + { + ZSTD_compressionParameters cParams = ZSTD_getCParams_internal( + compressionLevel, + unchecked(0UL - 1), + dictSize, + ZSTD_CParamMode_e.ZSTD_cpm_createCDict + ); + return ZSTD_estimateCDictSize_advanced( + dictSize, + cParams, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byCopy + ); + } + + public static nuint ZSTD_sizeof_CDict(ZSTD_CDict_s* cdict) + { + if (cdict == null) + return 0; + return (nuint)(cdict->workspace.workspace == cdict ? 0 : sizeof(ZSTD_CDict_s)) + + ZSTD_cwksp_sizeof(&cdict->workspace); + } + + private static nuint ZSTD_initCDict_internal( + ZSTD_CDict_s* cdict, + void* dictBuffer, + nuint dictSize, + ZSTD_dictLoadMethod_e dictLoadMethod, + ZSTD_dictContentType_e dictContentType, + ZSTD_CCtx_params_s @params + ) + { + assert(ZSTD_checkCParams(@params.cParams) == 0); + cdict->matchState.cParams = @params.cParams; + cdict->matchState.dedicatedDictSearch = @params.enableDedicatedDictSearch; + if ( + dictLoadMethod == ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef + || dictBuffer == null + || dictSize == 0 + ) + { + cdict->dictContent = dictBuffer; + } + else + { + void* internalBuffer = ZSTD_cwksp_reserve_object( + &cdict->workspace, + ZSTD_cwksp_align(dictSize, (nuint)sizeof(void*)) + ); + if (internalBuffer == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + cdict->dictContent = internalBuffer; + memcpy(internalBuffer, dictBuffer, (uint)dictSize); + } + + cdict->dictContentSize = dictSize; + cdict->dictContentType = dictContentType; + cdict->entropyWorkspace = (uint*)ZSTD_cwksp_reserve_object( + &cdict->workspace, + (8 << 10) + 512 + ); + ZSTD_reset_compressedBlockState(&cdict->cBlockState); + { + nuint err_code = ZSTD_reset_matchState( + &cdict->matchState, + &cdict->workspace, + &@params.cParams, + @params.useRowMatchFinder, + ZSTD_compResetPolicy_e.ZSTDcrp_makeClean, + ZSTD_indexResetPolicy_e.ZSTDirp_reset, + ZSTD_resetTarget_e.ZSTD_resetTarget_CDict + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + @params.compressionLevel = 3; + @params.fParams.contentSizeFlag = 1; + { + nuint dictID = ZSTD_compress_insertDictionary( + &cdict->cBlockState, + &cdict->matchState, + null, + &cdict->workspace, + &@params, + cdict->dictContent, + cdict->dictContentSize, + dictContentType, + ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_full, + ZSTD_tableFillPurpose_e.ZSTD_tfp_forCDict, + cdict->entropyWorkspace + ); + { + nuint err_code = dictID; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(dictID <= unchecked((uint)-1)); + cdict->dictID = (uint)dictID; + } + } + + return 0; + } + + private static ZSTD_CDict_s* ZSTD_createCDict_advanced_internal( + nuint dictSize, + ZSTD_dictLoadMethod_e dictLoadMethod, + ZSTD_compressionParameters cParams, + ZSTD_paramSwitch_e useRowMatchFinder, + int enableDedicatedDictSearch, + ZSTD_customMem customMem + ) + { + if (((customMem.customAlloc == null ? 1 : 0) ^ (customMem.customFree == null ? 1 : 0)) != 0) + return null; + { + nuint workspaceSize = + ZSTD_cwksp_alloc_size((nuint)sizeof(ZSTD_CDict_s)) + + ZSTD_cwksp_alloc_size((8 << 10) + 512) + + ZSTD_sizeof_matchState(&cParams, useRowMatchFinder, enableDedicatedDictSearch, 0) + + ( + dictLoadMethod == ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef + ? 0 + : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, (nuint)sizeof(void*))) + ); + void* workspace = ZSTD_customMalloc(workspaceSize, customMem); + ZSTD_cwksp ws; + ZSTD_CDict_s* cdict; + if (workspace == null) + { + ZSTD_customFree(workspace, customMem); + return null; + } + + ZSTD_cwksp_init( + &ws, + workspace, + workspaceSize, + ZSTD_cwksp_static_alloc_e.ZSTD_cwksp_dynamic_alloc + ); + cdict = (ZSTD_CDict_s*)ZSTD_cwksp_reserve_object(&ws, (nuint)sizeof(ZSTD_CDict_s)); + assert(cdict != null); + ZSTD_cwksp_move(&cdict->workspace, &ws); + cdict->customMem = customMem; + cdict->compressionLevel = 0; + cdict->useRowMatchFinder = useRowMatchFinder; + return cdict; + } + } + + public static ZSTD_CDict_s* ZSTD_createCDict_advanced( + void* dictBuffer, + nuint dictSize, + ZSTD_dictLoadMethod_e dictLoadMethod, + ZSTD_dictContentType_e dictContentType, + ZSTD_compressionParameters cParams, + ZSTD_customMem customMem + ) + { + ZSTD_CCtx_params_s cctxParams; + cctxParams = new ZSTD_CCtx_params_s(); + ZSTD_CCtxParams_init(&cctxParams, 0); + cctxParams.cParams = cParams; + cctxParams.customMem = customMem; + return ZSTD_createCDict_advanced2( + dictBuffer, + dictSize, + dictLoadMethod, + dictContentType, + &cctxParams, + customMem + ); + } + + /* + * This API is temporary and is expected to change or disappear in the future! + */ + public static ZSTD_CDict_s* ZSTD_createCDict_advanced2( + void* dict, + nuint dictSize, + ZSTD_dictLoadMethod_e dictLoadMethod, + ZSTD_dictContentType_e dictContentType, + ZSTD_CCtx_params_s* originalCctxParams, + ZSTD_customMem customMem + ) + { + ZSTD_CCtx_params_s cctxParams = *originalCctxParams; + ZSTD_compressionParameters cParams; + ZSTD_CDict_s* cdict; + if (((customMem.customAlloc == null ? 1 : 0) ^ (customMem.customFree == null ? 1 : 0)) != 0) + return null; + if (cctxParams.enableDedicatedDictSearch != 0) + { + cParams = ZSTD_dedicatedDictSearch_getCParams(cctxParams.compressionLevel, dictSize); + ZSTD_overrideCParams(&cParams, &cctxParams.cParams); + } + else + { + cParams = ZSTD_getCParamsFromCCtxParams( + &cctxParams, + unchecked(0UL - 1), + dictSize, + ZSTD_CParamMode_e.ZSTD_cpm_createCDict + ); + } + + if (ZSTD_dedicatedDictSearch_isSupported(&cParams) == 0) + { + cctxParams.enableDedicatedDictSearch = 0; + cParams = ZSTD_getCParamsFromCCtxParams( + &cctxParams, + unchecked(0UL - 1), + dictSize, + ZSTD_CParamMode_e.ZSTD_cpm_createCDict + ); + } + + cctxParams.cParams = cParams; + cctxParams.useRowMatchFinder = ZSTD_resolveRowMatchFinderMode( + cctxParams.useRowMatchFinder, + &cParams + ); + cdict = ZSTD_createCDict_advanced_internal( + dictSize, + dictLoadMethod, + cctxParams.cParams, + cctxParams.useRowMatchFinder, + cctxParams.enableDedicatedDictSearch, + customMem + ); + if ( + cdict == null + || ERR_isError( + ZSTD_initCDict_internal( + cdict, + dict, + dictSize, + dictLoadMethod, + dictContentType, + cctxParams + ) + ) + ) + { + ZSTD_freeCDict(cdict); + return null; + } + + return cdict; + } + + /*! ZSTD_createCDict() : + * When compressing multiple messages or blocks using the same dictionary, + * it's recommended to digest the dictionary only once, since it's a costly operation. + * ZSTD_createCDict() will create a state from digesting a dictionary. + * The resulting state can be used for future compression operations with very limited startup cost. + * ZSTD_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only. + * @dictBuffer can be released after ZSTD_CDict creation, because its content is copied within CDict. + * Note 1 : Consider experimental function `ZSTD_createCDict_byReference()` if you prefer to not duplicate @dictBuffer content. + * Note 2 : A ZSTD_CDict can be created from an empty @dictBuffer, + * in which case the only thing that it transports is the @compressionLevel. + * This can be useful in a pipeline featuring ZSTD_compress_usingCDict() exclusively, + * expecting a ZSTD_CDict parameter with any data, including those without a known dictionary. */ + public static ZSTD_CDict_s* ZSTD_createCDict(void* dict, nuint dictSize, int compressionLevel) + { + ZSTD_compressionParameters cParams = ZSTD_getCParams_internal( + compressionLevel, + unchecked(0UL - 1), + dictSize, + ZSTD_CParamMode_e.ZSTD_cpm_createCDict + ); + ZSTD_CDict_s* cdict = ZSTD_createCDict_advanced( + dict, + dictSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byCopy, + ZSTD_dictContentType_e.ZSTD_dct_auto, + cParams, + ZSTD_defaultCMem + ); + if (cdict != null) + cdict->compressionLevel = compressionLevel == 0 ? 3 : compressionLevel; + return cdict; + } + + /*! ZSTD_createCDict_byReference() : + * Create a digested dictionary for compression + * Dictionary content is just referenced, not duplicated. + * As a consequence, `dictBuffer` **must** outlive CDict, + * and its content must remain unmodified throughout the lifetime of CDict. + * note: equivalent to ZSTD_createCDict_advanced(), with dictLoadMethod==ZSTD_dlm_byRef */ + public static ZSTD_CDict_s* ZSTD_createCDict_byReference( + void* dict, + nuint dictSize, + int compressionLevel + ) + { + ZSTD_compressionParameters cParams = ZSTD_getCParams_internal( + compressionLevel, + unchecked(0UL - 1), + dictSize, + ZSTD_CParamMode_e.ZSTD_cpm_createCDict + ); + ZSTD_CDict_s* cdict = ZSTD_createCDict_advanced( + dict, + dictSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef, + ZSTD_dictContentType_e.ZSTD_dct_auto, + cParams, + ZSTD_defaultCMem + ); + if (cdict != null) + cdict->compressionLevel = compressionLevel == 0 ? 3 : compressionLevel; + return cdict; + } + + /*! ZSTD_freeCDict() : + * Function frees memory allocated by ZSTD_createCDict(). + * If a NULL pointer is passed, no operation is performed. */ + public static nuint ZSTD_freeCDict(ZSTD_CDict_s* cdict) + { + if (cdict == null) + return 0; + { + ZSTD_customMem cMem = cdict->customMem; + int cdictInWorkspace = ZSTD_cwksp_owns_buffer(&cdict->workspace, cdict); + ZSTD_cwksp_free(&cdict->workspace, cMem); + if (cdictInWorkspace == 0) + { + ZSTD_customFree(cdict, cMem); + } + + return 0; + } + } + + /*! ZSTD_initStaticCDict_advanced() : + * Generate a digested dictionary in provided memory area. + * workspace: The memory area to emplace the dictionary into. + * Provided pointer must 8-bytes aligned. + * It must outlive dictionary usage. + * workspaceSize: Use ZSTD_estimateCDictSize() + * to determine how large workspace must be. + * cParams : use ZSTD_getCParams() to transform a compression level + * into its relevant cParams. + * @return : pointer to ZSTD_CDict*, or NULL if error (size too small) + * Note : there is no corresponding "free" function. + * Since workspace was allocated externally, it must be freed externally. + */ + public static ZSTD_CDict_s* ZSTD_initStaticCDict( + void* workspace, + nuint workspaceSize, + void* dict, + nuint dictSize, + ZSTD_dictLoadMethod_e dictLoadMethod, + ZSTD_dictContentType_e dictContentType, + ZSTD_compressionParameters cParams + ) + { + ZSTD_paramSwitch_e useRowMatchFinder = ZSTD_resolveRowMatchFinderMode( + ZSTD_paramSwitch_e.ZSTD_ps_auto, + &cParams + ); + /* enableDedicatedDictSearch */ + nuint matchStateSize = ZSTD_sizeof_matchState(&cParams, useRowMatchFinder, 1, 0); + nuint neededSize = + ZSTD_cwksp_alloc_size((nuint)sizeof(ZSTD_CDict_s)) + + ( + dictLoadMethod == ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef + ? 0 + : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, (nuint)sizeof(void*))) + ) + + ZSTD_cwksp_alloc_size((8 << 10) + 512) + + matchStateSize; + ZSTD_CDict_s* cdict; + ZSTD_CCtx_params_s @params; + if (((nuint)workspace & 7) != 0) + return null; + { + ZSTD_cwksp ws; + ZSTD_cwksp_init( + &ws, + workspace, + workspaceSize, + ZSTD_cwksp_static_alloc_e.ZSTD_cwksp_static_alloc + ); + cdict = (ZSTD_CDict_s*)ZSTD_cwksp_reserve_object(&ws, (nuint)sizeof(ZSTD_CDict_s)); + if (cdict == null) + return null; + ZSTD_cwksp_move(&cdict->workspace, &ws); + } + + if (workspaceSize < neededSize) + return null; + ZSTD_CCtxParams_init(&@params, 0); + @params.cParams = cParams; + @params.useRowMatchFinder = useRowMatchFinder; + cdict->useRowMatchFinder = useRowMatchFinder; + cdict->compressionLevel = 0; + if ( + ERR_isError( + ZSTD_initCDict_internal( + cdict, + dict, + dictSize, + dictLoadMethod, + dictContentType, + @params + ) + ) + ) + return null; + return cdict; + } + + /*! ZSTD_getCParamsFromCDict() : + * as the name implies */ + private static ZSTD_compressionParameters ZSTD_getCParamsFromCDict(ZSTD_CDict_s* cdict) + { + assert(cdict != null); + return cdict->matchState.cParams; + } + + /*! ZSTD_getDictID_fromCDict() : + * Provides the dictID of the dictionary loaded into `cdict`. + * If @return == 0, the dictionary is not conformant to Zstandard specification, or empty. + * Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */ + public static uint ZSTD_getDictID_fromCDict(ZSTD_CDict_s* cdict) + { + if (cdict == null) + return 0; + return cdict->dictID; + } + + /* ZSTD_compressBegin_usingCDict_internal() : + * Implementation of various ZSTD_compressBegin_usingCDict* functions. + */ + private static nuint ZSTD_compressBegin_usingCDict_internal( + ZSTD_CCtx_s* cctx, + ZSTD_CDict_s* cdict, + ZSTD_frameParameters fParams, + ulong pledgedSrcSize + ) + { + ZSTD_CCtx_params_s cctxParams; + if (cdict == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_wrong)); + } + + { + ZSTD_parameters @params; + @params.fParams = fParams; + @params.cParams = + pledgedSrcSize < 128 * (1 << 10) + || pledgedSrcSize < cdict->dictContentSize * 6UL + || pledgedSrcSize == unchecked(0UL - 1) + || cdict->compressionLevel == 0 + ? ZSTD_getCParamsFromCDict(cdict) + : ZSTD_getCParams( + cdict->compressionLevel, + pledgedSrcSize, + cdict->dictContentSize + ); + ZSTD_CCtxParams_init_internal(&cctxParams, &@params, cdict->compressionLevel); + } + + if (pledgedSrcSize != unchecked(0UL - 1)) + { + uint limitedSrcSize = (uint)(pledgedSrcSize < 1U << 19 ? pledgedSrcSize : 1U << 19); + uint limitedSrcLog = limitedSrcSize > 1 ? ZSTD_highbit32(limitedSrcSize - 1) + 1 : 1; + cctxParams.cParams.windowLog = + cctxParams.cParams.windowLog > limitedSrcLog + ? cctxParams.cParams.windowLog + : limitedSrcLog; + } + + return ZSTD_compressBegin_internal( + cctx, + null, + 0, + ZSTD_dictContentType_e.ZSTD_dct_auto, + ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast, + cdict, + &cctxParams, + pledgedSrcSize, + ZSTD_buffered_policy_e.ZSTDb_not_buffered + ); + } + + /* ZSTD_compressBegin_usingCDict_advanced() : + * This function is DEPRECATED. + * cdict must be != NULL */ + public static nuint ZSTD_compressBegin_usingCDict_advanced( + ZSTD_CCtx_s* cctx, + ZSTD_CDict_s* cdict, + ZSTD_frameParameters fParams, + ulong pledgedSrcSize + ) + { + return ZSTD_compressBegin_usingCDict_internal(cctx, cdict, fParams, pledgedSrcSize); + } + + /* ZSTD_compressBegin_usingCDict() : + * cdict must be != NULL */ + private static nuint ZSTD_compressBegin_usingCDict_deprecated( + ZSTD_CCtx_s* cctx, + ZSTD_CDict_s* cdict + ) + { + /*content*/ + ZSTD_frameParameters fParams = new ZSTD_frameParameters + { + contentSizeFlag = 0, + checksumFlag = 0, + noDictIDFlag = 0, + }; + return ZSTD_compressBegin_usingCDict_internal(cctx, cdict, fParams, unchecked(0UL - 1)); + } + + public static nuint ZSTD_compressBegin_usingCDict(ZSTD_CCtx_s* cctx, ZSTD_CDict_s* cdict) + { + return ZSTD_compressBegin_usingCDict_deprecated(cctx, cdict); + } + + /*! ZSTD_compress_usingCDict_internal(): + * Implementation of various ZSTD_compress_usingCDict* functions. + */ + private static nuint ZSTD_compress_usingCDict_internal( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + ZSTD_CDict_s* cdict, + ZSTD_frameParameters fParams + ) + { + { + /* will check if cdict != NULL */ + nuint err_code = ZSTD_compressBegin_usingCDict_internal(cctx, cdict, fParams, srcSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize); + } + + /*! ZSTD_compress_usingCDict_advanced(): + * This function is DEPRECATED. + */ + public static nuint ZSTD_compress_usingCDict_advanced( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + ZSTD_CDict_s* cdict, + ZSTD_frameParameters fParams + ) + { + return ZSTD_compress_usingCDict_internal( + cctx, + dst, + dstCapacity, + src, + srcSize, + cdict, + fParams + ); + } + + /*! ZSTD_compress_usingCDict() : + * Compression using a digested Dictionary. + * Faster startup than ZSTD_compress_usingDict(), recommended when same dictionary is used multiple times. + * Note that compression parameters are decided at CDict creation time + * while frame parameters are hardcoded */ + public static nuint ZSTD_compress_usingCDict( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + ZSTD_CDict_s* cdict + ) + { + /*content*/ + ZSTD_frameParameters fParams = new ZSTD_frameParameters + { + contentSizeFlag = 1, + checksumFlag = 0, + noDictIDFlag = 0, + }; + return ZSTD_compress_usingCDict_internal( + cctx, + dst, + dstCapacity, + src, + srcSize, + cdict, + fParams + ); + } + + /* ****************************************************************** + * Streaming + ********************************************************************/ + public static ZSTD_CCtx_s* ZSTD_createCStream() + { + return ZSTD_createCStream_advanced(ZSTD_defaultCMem); + } + + public static ZSTD_CCtx_s* ZSTD_initStaticCStream(void* workspace, nuint workspaceSize) + { + return ZSTD_initStaticCCtx(workspace, workspaceSize); + } + + public static ZSTD_CCtx_s* ZSTD_createCStream_advanced(ZSTD_customMem customMem) + { + return ZSTD_createCCtx_advanced(customMem); + } + + public static nuint ZSTD_freeCStream(ZSTD_CCtx_s* zcs) + { + return ZSTD_freeCCtx(zcs); + } + + /*====== Initialization ======*/ + public static nuint ZSTD_CStreamInSize() + { + return 1 << 17; + } + + public static nuint ZSTD_CStreamOutSize() + { + return ZSTD_compressBound(1 << 17) + ZSTD_blockHeaderSize + 4; + } + + private static ZSTD_CParamMode_e ZSTD_getCParamMode( + ZSTD_CDict_s* cdict, + ZSTD_CCtx_params_s* @params, + ulong pledgedSrcSize + ) + { + if (cdict != null && ZSTD_shouldAttachDict(cdict, @params, pledgedSrcSize) != 0) + return ZSTD_CParamMode_e.ZSTD_cpm_attachDict; + else + return ZSTD_CParamMode_e.ZSTD_cpm_noAttachDict; + } + + /* ZSTD_resetCStream(): + * pledgedSrcSize == 0 means "unknown" */ + public static nuint ZSTD_resetCStream(ZSTD_CCtx_s* zcs, ulong pss) + { + /* temporary : 0 interpreted as "unknown" during transition period. + * Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN. + * 0 will be interpreted as "empty" in the future. + */ + ulong pledgedSrcSize = pss == 0 ? unchecked(0UL - 1) : pss; + { + nuint err_code = ZSTD_CCtx_reset(zcs, ZSTD_ResetDirective.ZSTD_reset_session_only); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + /*! ZSTD_initCStream_internal() : + * Note : for lib/compress only. Used by zstdmt_compress.c. + * Assumption 1 : params are valid + * Assumption 2 : either dict, or cdict, is defined, not both */ + private static nuint ZSTD_initCStream_internal( + ZSTD_CCtx_s* zcs, + void* dict, + nuint dictSize, + ZSTD_CDict_s* cdict, + ZSTD_CCtx_params_s* @params, + ulong pledgedSrcSize + ) + { + { + nuint err_code = ZSTD_CCtx_reset(zcs, ZSTD_ResetDirective.ZSTD_reset_session_only); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(!ERR_isError(ZSTD_checkCParams(@params->cParams))); + zcs->requestedParams = *@params; + assert(!(dict != null && cdict != null)); + if (dict != null) + { + nuint err_code = ZSTD_CCtx_loadDictionary(zcs, dict, dictSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + else + { + /* Dictionary is cleared if !cdict */ + nuint err_code = ZSTD_CCtx_refCDict(zcs, cdict); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + /* ZSTD_initCStream_usingCDict_advanced() : + * same as ZSTD_initCStream_usingCDict(), with control over frame parameters */ + public static nuint ZSTD_initCStream_usingCDict_advanced( + ZSTD_CCtx_s* zcs, + ZSTD_CDict_s* cdict, + ZSTD_frameParameters fParams, + ulong pledgedSrcSize + ) + { + { + nuint err_code = ZSTD_CCtx_reset(zcs, ZSTD_ResetDirective.ZSTD_reset_session_only); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + zcs->requestedParams.fParams = fParams; + { + nuint err_code = ZSTD_CCtx_refCDict(zcs, cdict); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + /* note : cdict must outlive compression session */ + public static nuint ZSTD_initCStream_usingCDict(ZSTD_CCtx_s* zcs, ZSTD_CDict_s* cdict) + { + { + nuint err_code = ZSTD_CCtx_reset(zcs, ZSTD_ResetDirective.ZSTD_reset_session_only); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_refCDict(zcs, cdict); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + /* ZSTD_initCStream_advanced() : + * pledgedSrcSize must be exact. + * if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. + * dict is loaded with default parameters ZSTD_dct_auto and ZSTD_dlm_byCopy. */ + public static nuint ZSTD_initCStream_advanced( + ZSTD_CCtx_s* zcs, + void* dict, + nuint dictSize, + ZSTD_parameters @params, + ulong pss + ) + { + /* for compatibility with older programs relying on this behavior. + * Users should now specify ZSTD_CONTENTSIZE_UNKNOWN. + * This line will be removed in the future. + */ + ulong pledgedSrcSize = + pss == 0 && @params.fParams.contentSizeFlag == 0 ? unchecked(0UL - 1) : pss; + { + nuint err_code = ZSTD_CCtx_reset(zcs, ZSTD_ResetDirective.ZSTD_reset_session_only); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_checkCParams(@params.cParams); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + ZSTD_CCtxParams_setZstdParams(&zcs->requestedParams, &@params); + { + nuint err_code = ZSTD_CCtx_loadDictionary(zcs, dict, dictSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + /*! ZSTD_initCStream_usingDict() : + * This function is DEPRECATED, and is equivalent to: + * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only); + * ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel); + * ZSTD_CCtx_loadDictionary(zcs, dict, dictSize); + * + * Creates of an internal CDict (incompatible with static CCtx), except if + * dict == NULL or dictSize < 8, in which case no dict is used. + * Note: dict is loaded with ZSTD_dct_auto (treated as a full zstd dictionary if + * it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy. + * This prototype will generate compilation warnings. + */ + public static nuint ZSTD_initCStream_usingDict( + ZSTD_CCtx_s* zcs, + void* dict, + nuint dictSize, + int compressionLevel + ) + { + { + nuint err_code = ZSTD_CCtx_reset(zcs, ZSTD_ResetDirective.ZSTD_reset_session_only); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setParameter( + zcs, + ZSTD_cParameter.ZSTD_c_compressionLevel, + compressionLevel + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_loadDictionary(zcs, dict, dictSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + /*! ZSTD_initCStream_srcSize() : + * This function is DEPRECATED, and equivalent to: + * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only); + * ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any) + * ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel); + * ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize); + * + * pledgedSrcSize must be correct. If it is not known at init time, use + * ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, + * "0" also disables frame content size field. It may be enabled in the future. + * This prototype will generate compilation warnings. + */ + public static nuint ZSTD_initCStream_srcSize(ZSTD_CCtx_s* zcs, int compressionLevel, ulong pss) + { + /* temporary : 0 interpreted as "unknown" during transition period. + * Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN. + * 0 will be interpreted as "empty" in the future. + */ + ulong pledgedSrcSize = pss == 0 ? unchecked(0UL - 1) : pss; + { + nuint err_code = ZSTD_CCtx_reset(zcs, ZSTD_ResetDirective.ZSTD_reset_session_only); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_refCDict(zcs, null); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setParameter( + zcs, + ZSTD_cParameter.ZSTD_c_compressionLevel, + compressionLevel + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + /*! + * Equivalent to: + * + * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only); + * ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any) + * ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel); + * + * Note that ZSTD_initCStream() clears any previously set dictionary. Use the new API + * to compress with a dictionary. + */ + public static nuint ZSTD_initCStream(ZSTD_CCtx_s* zcs, int compressionLevel) + { + { + nuint err_code = ZSTD_CCtx_reset(zcs, ZSTD_ResetDirective.ZSTD_reset_session_only); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_refCDict(zcs, null); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_CCtx_setParameter( + zcs, + ZSTD_cParameter.ZSTD_c_compressionLevel, + compressionLevel + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + /*====== Compression ======*/ + private static nuint ZSTD_nextInputSizeHint(ZSTD_CCtx_s* cctx) + { + if (cctx->appliedParams.inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable) + { + return cctx->blockSizeMax - cctx->stableIn_notConsumed; + } + + assert(cctx->appliedParams.inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_buffered); + { + nuint hintInSize = cctx->inBuffTarget - cctx->inBuffPos; + if (hintInSize == 0) + hintInSize = cctx->blockSizeMax; + return hintInSize; + } + } + + /** ZSTD_compressStream_generic(): + * internal function for all *compressStream*() variants + * @return : hint size for next input to complete ongoing block */ + private static nuint ZSTD_compressStream_generic( + ZSTD_CCtx_s* zcs, + ZSTD_outBuffer_s* output, + ZSTD_inBuffer_s* input, + ZSTD_EndDirective flushMode + ) + { + assert(input != null); + sbyte* istart = (sbyte*)input->src; + sbyte* iend = istart != null ? istart + input->size : istart; + sbyte* ip = istart != null ? istart + input->pos : istart; + assert(output != null); + sbyte* ostart = (sbyte*)output->dst; + sbyte* oend = ostart != null ? ostart + output->size : ostart; + sbyte* op = ostart != null ? ostart + output->pos : ostart; + uint someMoreWork = 1; + assert(zcs != null); + if (zcs->appliedParams.inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable) + { + assert(input->pos >= zcs->stableIn_notConsumed); + input->pos -= zcs->stableIn_notConsumed; + if (ip != null) + ip -= zcs->stableIn_notConsumed; + zcs->stableIn_notConsumed = 0; + } + +#if DEBUG + if (zcs->appliedParams.inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_buffered) + { + assert(zcs->inBuff != null); + assert(zcs->inBuffSize > 0); + } +#endif + +#if DEBUG + if (zcs->appliedParams.outBufferMode == ZSTD_bufferMode_e.ZSTD_bm_buffered) + { + assert(zcs->outBuff != null); + assert(zcs->outBuffSize > 0); + } +#endif + +#if DEBUG + if (input->src == null) + assert(input->size == 0); +#endif + assert(input->pos <= input->size); +#if DEBUG + if (output->dst == null) + assert(output->size == 0); +#endif + assert(output->pos <= output->size); + assert((uint)flushMode <= (uint)ZSTD_EndDirective.ZSTD_e_end); + while (someMoreWork != 0) + { + switch (zcs->streamStage) + { + case ZSTD_cStreamStage.zcss_init: + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_init_missing)); + case ZSTD_cStreamStage.zcss_load: + if ( + flushMode == ZSTD_EndDirective.ZSTD_e_end + && ( + (nuint)(oend - op) >= ZSTD_compressBound((nuint)(iend - ip)) + || zcs->appliedParams.outBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable + ) + && zcs->inBuffPos == 0 + ) + { + /* shortcut to compression pass directly into output buffer */ + nuint cSize = ZSTD_compressEnd_public( + zcs, + op, + (nuint)(oend - op), + ip, + (nuint)(iend - ip) + ); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + ip = iend; + op += cSize; + zcs->frameEnded = 1; + ZSTD_CCtx_reset(zcs, ZSTD_ResetDirective.ZSTD_reset_session_only); + someMoreWork = 0; + break; + } + + if (zcs->appliedParams.inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_buffered) + { + nuint toLoad = zcs->inBuffTarget - zcs->inBuffPos; + nuint loaded = ZSTD_limitCopy( + zcs->inBuff + zcs->inBuffPos, + toLoad, + ip, + (nuint)(iend - ip) + ); + zcs->inBuffPos += loaded; + if (ip != null) + ip += loaded; + if ( + flushMode == ZSTD_EndDirective.ZSTD_e_continue + && zcs->inBuffPos < zcs->inBuffTarget + ) + { + someMoreWork = 0; + break; + } + + if ( + flushMode == ZSTD_EndDirective.ZSTD_e_flush + && zcs->inBuffPos == zcs->inToCompress + ) + { + someMoreWork = 0; + break; + } + } + else + { + assert(zcs->appliedParams.inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable); + if ( + flushMode == ZSTD_EndDirective.ZSTD_e_continue + && (nuint)(iend - ip) < zcs->blockSizeMax + ) + { + zcs->stableIn_notConsumed = (nuint)(iend - ip); + ip = iend; + someMoreWork = 0; + break; + } + + if (flushMode == ZSTD_EndDirective.ZSTD_e_flush && ip == iend) + { + someMoreWork = 0; + break; + } + } + + { + int inputBuffered = + zcs->appliedParams.inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_buffered + ? 1 + : 0; + void* cDst; + nuint cSize; + nuint oSize = (nuint)(oend - op); + nuint iSize = + inputBuffered != 0 ? zcs->inBuffPos - zcs->inToCompress + : (nuint)(iend - ip) < zcs->blockSizeMax ? (nuint)(iend - ip) + : zcs->blockSizeMax; + if ( + oSize >= ZSTD_compressBound(iSize) + || zcs->appliedParams.outBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable + ) + cDst = op; + else + { + cDst = zcs->outBuff; + oSize = zcs->outBuffSize; + } + + if (inputBuffered != 0) + { + uint lastBlock = + flushMode == ZSTD_EndDirective.ZSTD_e_end && ip == iend ? 1U : 0U; + cSize = + lastBlock != 0 + ? ZSTD_compressEnd_public( + zcs, + cDst, + oSize, + zcs->inBuff + zcs->inToCompress, + iSize + ) + : ZSTD_compressContinue_public( + zcs, + cDst, + oSize, + zcs->inBuff + zcs->inToCompress, + iSize + ); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + zcs->frameEnded = lastBlock; + zcs->inBuffTarget = zcs->inBuffPos + zcs->blockSizeMax; + if (zcs->inBuffTarget > zcs->inBuffSize) + { + zcs->inBuffPos = 0; + zcs->inBuffTarget = zcs->blockSizeMax; + } + +#if DEBUG + if (lastBlock == 0) + assert(zcs->inBuffTarget <= zcs->inBuffSize); +#endif + zcs->inToCompress = zcs->inBuffPos; + } + else + { + uint lastBlock = + flushMode == ZSTD_EndDirective.ZSTD_e_end && ip + iSize == iend + ? 1U + : 0U; + cSize = + lastBlock != 0 + ? ZSTD_compressEnd_public(zcs, cDst, oSize, ip, iSize) + : ZSTD_compressContinue_public(zcs, cDst, oSize, ip, iSize); + if (ip != null) + ip += iSize; + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + zcs->frameEnded = lastBlock; +#if DEBUG + if (lastBlock != 0) + assert(ip == iend); +#endif + } + + if (cDst == op) + { + op += cSize; + if (zcs->frameEnded != 0) + { + someMoreWork = 0; + ZSTD_CCtx_reset(zcs, ZSTD_ResetDirective.ZSTD_reset_session_only); + } + + break; + } + + zcs->outBuffContentSize = cSize; + zcs->outBuffFlushedSize = 0; + zcs->streamStage = ZSTD_cStreamStage.zcss_flush; + } + + goto case ZSTD_cStreamStage.zcss_flush; + case ZSTD_cStreamStage.zcss_flush: + assert(zcs->appliedParams.outBufferMode == ZSTD_bufferMode_e.ZSTD_bm_buffered); + + { + nuint toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize; + nuint flushed = ZSTD_limitCopy( + op, + (nuint)(oend - op), + zcs->outBuff + zcs->outBuffFlushedSize, + toFlush + ); + if (flushed != 0) + op += flushed; + zcs->outBuffFlushedSize += flushed; + if (toFlush != flushed) + { + assert(op == oend); + someMoreWork = 0; + break; + } + + zcs->outBuffContentSize = zcs->outBuffFlushedSize = 0; + if (zcs->frameEnded != 0) + { + someMoreWork = 0; + ZSTD_CCtx_reset(zcs, ZSTD_ResetDirective.ZSTD_reset_session_only); + break; + } + + zcs->streamStage = ZSTD_cStreamStage.zcss_load; + break; + } + + default: + assert(0 != 0); + break; + } + } + + input->pos = (nuint)(ip - istart); + output->pos = (nuint)(op - ostart); + if (zcs->frameEnded != 0) + return 0; + return ZSTD_nextInputSizeHint(zcs); + } + + private static nuint ZSTD_nextInputSizeHint_MTorST(ZSTD_CCtx_s* cctx) + { + if (cctx->appliedParams.nbWorkers >= 1) + { + assert(cctx->mtctx != null); + return ZSTDMT_nextInputSizeHint(cctx->mtctx); + } + + return ZSTD_nextInputSizeHint(cctx); + } + + /*! + * Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue). + * NOTE: The return value is different. ZSTD_compressStream() returns a hint for + * the next read size (if non-zero and not an error). ZSTD_compressStream2() + * returns the minimum nb of bytes left to flush (if non-zero and not an error). + */ + public static nuint ZSTD_compressStream( + ZSTD_CCtx_s* zcs, + ZSTD_outBuffer_s* output, + ZSTD_inBuffer_s* input + ) + { + { + nuint err_code = ZSTD_compressStream2( + zcs, + output, + input, + ZSTD_EndDirective.ZSTD_e_continue + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return ZSTD_nextInputSizeHint_MTorST(zcs); + } + + /* After a compression call set the expected input/output buffer. + * This is validated at the start of the next compression call. + */ + private static void ZSTD_setBufferExpectations( + ZSTD_CCtx_s* cctx, + ZSTD_outBuffer_s* output, + ZSTD_inBuffer_s* input + ) + { + if (cctx->appliedParams.inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable) + { + cctx->expectedInBuffer = *input; + } + + if (cctx->appliedParams.outBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable) + { + cctx->expectedOutBufferSize = output->size - output->pos; + } + } + + /* Validate that the input/output buffers match the expectations set by + * ZSTD_setBufferExpectations. + */ + private static nuint ZSTD_checkBufferStability( + ZSTD_CCtx_s* cctx, + ZSTD_outBuffer_s* output, + ZSTD_inBuffer_s* input, + ZSTD_EndDirective endOp + ) + { + if (cctx->appliedParams.inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable) + { + ZSTD_inBuffer_s expect = cctx->expectedInBuffer; + if (expect.src != input->src || expect.pos != input->pos) + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stabilityCondition_notRespected) + ); + } + + if (cctx->appliedParams.outBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable) + { + nuint outBufferSize = output->size - output->pos; + if (cctx->expectedOutBufferSize != outBufferSize) + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stabilityCondition_notRespected) + ); + } + + return 0; + } + + /* + * If @endOp == ZSTD_e_end, @inSize becomes pledgedSrcSize. + * Otherwise, it's ignored. + * @return: 0 on success, or a ZSTD_error code otherwise. + */ + private static nuint ZSTD_CCtx_init_compressStream2( + ZSTD_CCtx_s* cctx, + ZSTD_EndDirective endOp, + nuint inSize + ) + { + ZSTD_CCtx_params_s @params = cctx->requestedParams; + ZSTD_prefixDict_s prefixDict = cctx->prefixDict; + { + /* Init the local dict if present. */ + nuint err_code = ZSTD_initLocalDict(cctx); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + cctx->prefixDict = new ZSTD_prefixDict_s(); + assert(prefixDict.dict == null || cctx->cdict == null); + if (cctx->cdict != null && cctx->localDict.cdict == null) + { + @params.compressionLevel = cctx->cdict->compressionLevel; + } + + if (endOp == ZSTD_EndDirective.ZSTD_e_end) + cctx->pledgedSrcSizePlusOne = inSize + 1; + { + nuint dictSize = + prefixDict.dict != null ? prefixDict.dictSize + : cctx->cdict != null ? cctx->cdict->dictContentSize + : 0; + ZSTD_CParamMode_e mode = ZSTD_getCParamMode( + cctx->cdict, + &@params, + cctx->pledgedSrcSizePlusOne - 1 + ); + @params.cParams = ZSTD_getCParamsFromCCtxParams( + &@params, + cctx->pledgedSrcSizePlusOne - 1, + dictSize, + mode + ); + } + + @params.postBlockSplitter = ZSTD_resolveBlockSplitterMode( + @params.postBlockSplitter, + &@params.cParams + ); + @params.ldmParams.enableLdm = ZSTD_resolveEnableLdm( + @params.ldmParams.enableLdm, + &@params.cParams + ); + @params.useRowMatchFinder = ZSTD_resolveRowMatchFinderMode( + @params.useRowMatchFinder, + &@params.cParams + ); + @params.validateSequences = ZSTD_resolveExternalSequenceValidation( + @params.validateSequences + ); + @params.maxBlockSize = ZSTD_resolveMaxBlockSize(@params.maxBlockSize); + @params.searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch( + @params.searchForExternalRepcodes, + @params.compressionLevel + ); + if (ZSTD_hasExtSeqProd(&@params) != 0 && @params.nbWorkers >= 1) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_combination_unsupported) + ); + } + + if (cctx->pledgedSrcSizePlusOne - 1 <= 512 * (1 << 10)) + { + @params.nbWorkers = 0; + } + + if (@params.nbWorkers > 0) + { + if (cctx->mtctx == null) + { + cctx->mtctx = ZSTDMT_createCCtx_advanced( + (uint)@params.nbWorkers, + cctx->customMem, + cctx->pool + ); + if (cctx->mtctx == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + } + + { + nuint err_code = ZSTDMT_initCStream_internal( + cctx->mtctx, + prefixDict.dict, + prefixDict.dictSize, + prefixDict.dictContentType, + cctx->cdict, + @params, + cctx->pledgedSrcSizePlusOne - 1 + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + cctx->dictID = cctx->cdict != null ? cctx->cdict->dictID : 0; + cctx->dictContentSize = + cctx->cdict != null ? cctx->cdict->dictContentSize : prefixDict.dictSize; + cctx->consumedSrcSize = 0; + cctx->producedCSize = 0; + cctx->streamStage = ZSTD_cStreamStage.zcss_load; + cctx->appliedParams = @params; + } + else + { + ulong pledgedSrcSize = cctx->pledgedSrcSizePlusOne - 1; + assert(!ERR_isError(ZSTD_checkCParams(@params.cParams))); + { + nuint err_code = ZSTD_compressBegin_internal( + cctx, + prefixDict.dict, + prefixDict.dictSize, + prefixDict.dictContentType, + ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast, + cctx->cdict, + &@params, + pledgedSrcSize, + ZSTD_buffered_policy_e.ZSTDb_buffered + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(cctx->appliedParams.nbWorkers == 0); + cctx->inToCompress = 0; + cctx->inBuffPos = 0; + if (cctx->appliedParams.inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_buffered) + { + cctx->inBuffTarget = + cctx->blockSizeMax + (nuint)(cctx->blockSizeMax == pledgedSrcSize ? 1 : 0); + } + else + { + cctx->inBuffTarget = 0; + } + + cctx->outBuffContentSize = cctx->outBuffFlushedSize = 0; + cctx->streamStage = ZSTD_cStreamStage.zcss_load; + cctx->frameEnded = 0; + } + + return 0; + } + + /* @return provides a minimum amount of data remaining to be flushed from internal buffers + */ + public static nuint ZSTD_compressStream2( + ZSTD_CCtx_s* cctx, + ZSTD_outBuffer_s* output, + ZSTD_inBuffer_s* input, + ZSTD_EndDirective endOp + ) + { + if (output->pos > output->size) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (input->pos > input->size) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if ((uint)endOp > (uint)ZSTD_EndDirective.ZSTD_e_end) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + assert(cctx != null); + if (cctx->streamStage == ZSTD_cStreamStage.zcss_init) + { + /* no obligation to start from pos==0 */ + nuint inputSize = input->size - input->pos; + nuint totalInputSize = inputSize + cctx->stableIn_notConsumed; + if ( + cctx->requestedParams.inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable + && endOp == ZSTD_EndDirective.ZSTD_e_continue + && totalInputSize < 1 << 17 + ) + { + if (cctx->stableIn_notConsumed != 0) + { + if (input->src != cctx->expectedInBuffer.src) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stabilityCondition_notRespected) + ); + } + + if (input->pos != cctx->expectedInBuffer.size) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stabilityCondition_notRespected) + ); + } + } + + input->pos = input->size; + cctx->expectedInBuffer = *input; + cctx->stableIn_notConsumed += inputSize; + return (nuint)(cctx->requestedParams.format == ZSTD_format_e.ZSTD_f_zstd1 ? 6 : 2); + } + + { + nuint err_code = ZSTD_CCtx_init_compressStream2(cctx, endOp, totalInputSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + ZSTD_setBufferExpectations(cctx, output, input); + } + + { + /* end of transparent initialization stage */ + nuint err_code = ZSTD_checkBufferStability(cctx, output, input, endOp); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (cctx->appliedParams.nbWorkers > 0) + { + nuint flushMin; + if (cctx->cParamsChanged != 0) + { + ZSTDMT_updateCParams_whileCompressing(cctx->mtctx, &cctx->requestedParams); + cctx->cParamsChanged = 0; + } + + if (cctx->stableIn_notConsumed != 0) + { + assert(cctx->appliedParams.inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable); + assert(input->pos >= cctx->stableIn_notConsumed); + input->pos -= cctx->stableIn_notConsumed; + cctx->stableIn_notConsumed = 0; + } + + for (; ; ) + { + nuint ipos = input->pos; + nuint opos = output->pos; + flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp); + cctx->consumedSrcSize += input->pos - ipos; + cctx->producedCSize += output->pos - opos; + if (ERR_isError(flushMin) || endOp == ZSTD_EndDirective.ZSTD_e_end && flushMin == 0) + { + if (flushMin == 0) + ZSTD_CCtx_trace(cctx, 0); + ZSTD_CCtx_reset(cctx, ZSTD_ResetDirective.ZSTD_reset_session_only); + } + + { + nuint err_code = flushMin; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (endOp == ZSTD_EndDirective.ZSTD_e_continue) + { + if ( + input->pos != ipos + || output->pos != opos + || input->pos == input->size + || output->pos == output->size + ) + break; + } + else + { + assert( + endOp == ZSTD_EndDirective.ZSTD_e_flush + || endOp == ZSTD_EndDirective.ZSTD_e_end + ); + if (flushMin == 0 || output->pos == output->size) + break; + } + } + + assert( + endOp == ZSTD_EndDirective.ZSTD_e_continue + || flushMin == 0 + || output->pos == output->size + ); + ZSTD_setBufferExpectations(cctx, output, input); + return flushMin; + } + + { + nuint err_code = ZSTD_compressStream_generic(cctx, output, input, endOp); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + ZSTD_setBufferExpectations(cctx, output, input); + return cctx->outBuffContentSize - cctx->outBuffFlushedSize; + } + + /*! ZSTD_compressStream2_simpleArgs() : + * Same as ZSTD_compressStream2(), + * but using only integral types as arguments. + * This variant might be helpful for binders from dynamic languages + * which have troubles handling structures containing memory pointers. + */ + public static nuint ZSTD_compressStream2_simpleArgs( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + nuint* dstPos, + void* src, + nuint srcSize, + nuint* srcPos, + ZSTD_EndDirective endOp + ) + { + ZSTD_outBuffer_s output; + ZSTD_inBuffer_s input; + output.dst = dst; + output.size = dstCapacity; + output.pos = *dstPos; + input.src = src; + input.size = srcSize; + input.pos = *srcPos; + { + nuint cErr = ZSTD_compressStream2(cctx, &output, &input, endOp); + *dstPos = output.pos; + *srcPos = input.pos; + return cErr; + } + } + + /*! ZSTD_compress2() : + * Behave the same as ZSTD_compressCCtx(), but compression parameters are set using the advanced API. + * (note that this entry point doesn't even expose a compression level parameter). + * ZSTD_compress2() always starts a new frame. + * Should cctx hold data from a previously unfinished frame, everything about it is forgotten. + * - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*() + * - The function is always blocking, returns when compression is completed. + * NOTE: Providing `dstCapacity >= ZSTD_compressBound(srcSize)` guarantees that zstd will have + * enough space to successfully compress the data, though it is possible it fails for other reasons. + * @return : compressed size written into `dst` (<= `dstCapacity), + * or an error code if it fails (which can be tested using ZSTD_isError()). + */ + public static nuint ZSTD_compress2( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize + ) + { + ZSTD_bufferMode_e originalInBufferMode = cctx->requestedParams.inBufferMode; + ZSTD_bufferMode_e originalOutBufferMode = cctx->requestedParams.outBufferMode; + ZSTD_CCtx_reset(cctx, ZSTD_ResetDirective.ZSTD_reset_session_only); + cctx->requestedParams.inBufferMode = ZSTD_bufferMode_e.ZSTD_bm_stable; + cctx->requestedParams.outBufferMode = ZSTD_bufferMode_e.ZSTD_bm_stable; + { + nuint oPos = 0; + nuint iPos = 0; + nuint result = ZSTD_compressStream2_simpleArgs( + cctx, + dst, + dstCapacity, + &oPos, + src, + srcSize, + &iPos, + ZSTD_EndDirective.ZSTD_e_end + ); + cctx->requestedParams.inBufferMode = originalInBufferMode; + cctx->requestedParams.outBufferMode = originalOutBufferMode; + { + nuint err_code = result; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (result != 0) + { + assert(oPos == dstCapacity); + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + assert(iPos == srcSize); + return oPos; + } + } + + /* ZSTD_validateSequence() : + * @offBase : must use the format required by ZSTD_storeSeq() + * @returns a ZSTD error code if sequence is not valid + */ + private static nuint ZSTD_validateSequence( + uint offBase, + uint matchLength, + uint minMatch, + nuint posInSrc, + uint windowLog, + nuint dictSize, + int useSequenceProducer + ) + { + uint windowSize = 1U << (int)windowLog; + /* posInSrc represents the amount of data the decoder would decode up to this point. + * As long as the amount of data decoded is less than or equal to window size, offsets may be + * larger than the total length of output decoded in order to reference the dict, even larger than + * window size. After output surpasses windowSize, we're limited to windowSize offsets again. + */ + nuint offsetBound = posInSrc > windowSize ? windowSize : posInSrc + dictSize; + nuint matchLenLowerBound = (nuint)(minMatch == 3 || useSequenceProducer != 0 ? 3 : 4); + { + assert(offsetBound > 0); + if (offBase > offsetBound + 3) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid) + ); + } + } + + if (matchLength < matchLenLowerBound) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid)); + } + + return 0; + } + + /* Returns an offset code, given a sequence's raw offset, the ongoing repcode array, and whether litLength == 0 */ + private static uint ZSTD_finalizeOffBase(uint rawOffset, uint* rep, uint ll0) + { + assert(rawOffset > 0); + uint offBase = rawOffset + 3; + if (ll0 == 0 && rawOffset == rep[0]) + { + assert(1 >= 1); + assert(1 <= 3); + offBase = 1; + } + else if (rawOffset == rep[1]) + { + assert(2 - ll0 >= 1); + assert(2 - ll0 <= 3); + offBase = 2 - ll0; + } + else if (rawOffset == rep[2]) + { + assert(3 - ll0 >= 1); + assert(3 - ll0 <= 3); + offBase = 3 - ll0; + } + else if (ll0 != 0 && rawOffset == rep[0] - 1) + { + assert(3 >= 1); + assert(3 <= 3); + offBase = 3; + } + + return offBase; + } + + /* This function scans through an array of ZSTD_Sequence, + * storing the sequences it reads, until it reaches a block delimiter. + * Note that the block delimiter includes the last literals of the block. + * @blockSize must be == sum(sequence_lengths). + * @returns @blockSize on success, and a ZSTD_error otherwise. + */ + private static nuint ZSTD_transferSequences_wBlockDelim( + ZSTD_CCtx_s* cctx, + ZSTD_SequencePosition* seqPos, + ZSTD_Sequence* inSeqs, + nuint inSeqsSize, + void* src, + nuint blockSize, + ZSTD_paramSwitch_e externalRepSearch + ) + { + uint idx = seqPos->idx; + uint startIdx = idx; + byte* ip = (byte*)src; + byte* iend = ip + blockSize; + repcodes_s updatedRepcodes; + uint dictSize; + if (cctx->cdict != null) + { + dictSize = (uint)cctx->cdict->dictContentSize; + } + else if (cctx->prefixDict.dict != null) + { + dictSize = (uint)cctx->prefixDict.dictSize; + } + else + { + dictSize = 0; + } + + memcpy(updatedRepcodes.rep, cctx->blockState.prevCBlock->rep, (uint)sizeof(repcodes_s)); + for (; idx < inSeqsSize && (inSeqs[idx].matchLength != 0 || inSeqs[idx].offset != 0); ++idx) + { + uint litLength = inSeqs[idx].litLength; + uint matchLength = inSeqs[idx].matchLength; + uint offBase; + if (externalRepSearch == ZSTD_paramSwitch_e.ZSTD_ps_disable) + { + assert(inSeqs[idx].offset > 0); + offBase = inSeqs[idx].offset + 3; + } + else + { + uint ll0 = litLength == 0 ? 1U : 0U; + offBase = ZSTD_finalizeOffBase(inSeqs[idx].offset, updatedRepcodes.rep, ll0); + ZSTD_updateRep(updatedRepcodes.rep, offBase, ll0); + } + + if (cctx->appliedParams.validateSequences != 0) + { + seqPos->posInSrc += litLength + matchLength; + { + nuint err_code = ZSTD_validateSequence( + offBase, + matchLength, + cctx->appliedParams.cParams.minMatch, + seqPos->posInSrc, + cctx->appliedParams.cParams.windowLog, + dictSize, + ZSTD_hasExtSeqProd(&cctx->appliedParams) + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + } + + if (idx - seqPos->idx >= cctx->seqStore.maxNbSeq) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid) + ); + } + + ZSTD_storeSeq(&cctx->seqStore, litLength, ip, iend, offBase, matchLength); + ip += matchLength + litLength; + } + + if (idx == inSeqsSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid)); + } + + assert(externalRepSearch != ZSTD_paramSwitch_e.ZSTD_ps_auto); + assert(idx >= startIdx); + if (externalRepSearch == ZSTD_paramSwitch_e.ZSTD_ps_disable && idx != startIdx) + { + uint* rep = updatedRepcodes.rep; + /* index of last non-block-delimiter sequence */ + uint lastSeqIdx = idx - 1; + if (lastSeqIdx >= startIdx + 2) + { + rep[2] = inSeqs[lastSeqIdx - 2].offset; + rep[1] = inSeqs[lastSeqIdx - 1].offset; + rep[0] = inSeqs[lastSeqIdx].offset; + } + else if (lastSeqIdx == startIdx + 1) + { + rep[2] = rep[0]; + rep[1] = inSeqs[lastSeqIdx - 1].offset; + rep[0] = inSeqs[lastSeqIdx].offset; + } + else + { + assert(lastSeqIdx == startIdx); + rep[2] = rep[1]; + rep[1] = rep[0]; + rep[0] = inSeqs[lastSeqIdx].offset; + } + } + + memcpy(cctx->blockState.nextCBlock->rep, updatedRepcodes.rep, (uint)sizeof(repcodes_s)); + if (inSeqs[idx].litLength != 0) + { + ZSTD_storeLastLiterals(&cctx->seqStore, ip, inSeqs[idx].litLength); + ip += inSeqs[idx].litLength; + seqPos->posInSrc += inSeqs[idx].litLength; + } + + if (ip != iend) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid)); + } + + seqPos->idx = idx + 1; + return blockSize; + } + + /* + * This function attempts to scan through @blockSize bytes in @src + * represented by the sequences in @inSeqs, + * storing any (partial) sequences. + * + * Occasionally, we may want to reduce the actual number of bytes consumed from @src + * to avoid splitting a match, notably if it would produce a match smaller than MINMATCH. + * + * @returns the number of bytes consumed from @src, necessarily <= @blockSize. + * Otherwise, it may return a ZSTD error if something went wrong. + */ + private static nuint ZSTD_transferSequences_noDelim( + ZSTD_CCtx_s* cctx, + ZSTD_SequencePosition* seqPos, + ZSTD_Sequence* inSeqs, + nuint inSeqsSize, + void* src, + nuint blockSize, + ZSTD_paramSwitch_e externalRepSearch + ) + { + uint idx = seqPos->idx; + uint startPosInSequence = seqPos->posInSequence; + uint endPosInSequence = seqPos->posInSequence + (uint)blockSize; + nuint dictSize; + byte* istart = (byte*)src; + byte* ip = istart; + /* May be adjusted if we decide to process fewer than blockSize bytes */ + byte* iend = istart + blockSize; + repcodes_s updatedRepcodes; + uint bytesAdjustment = 0; + uint finalMatchSplit = 0; + if (cctx->cdict != null) + { + dictSize = cctx->cdict->dictContentSize; + } + else if (cctx->prefixDict.dict != null) + { + dictSize = cctx->prefixDict.dictSize; + } + else + { + dictSize = 0; + } + + memcpy(updatedRepcodes.rep, cctx->blockState.prevCBlock->rep, (uint)sizeof(repcodes_s)); + while (endPosInSequence != 0 && idx < inSeqsSize && finalMatchSplit == 0) + { + ZSTD_Sequence currSeq = inSeqs[idx]; + uint litLength = currSeq.litLength; + uint matchLength = currSeq.matchLength; + uint rawOffset = currSeq.offset; + uint offBase; + if (endPosInSequence >= currSeq.litLength + currSeq.matchLength) + { + if (startPosInSequence >= litLength) + { + startPosInSequence -= litLength; + litLength = 0; + matchLength -= startPosInSequence; + } + else + { + litLength -= startPosInSequence; + } + + endPosInSequence -= currSeq.litLength + currSeq.matchLength; + startPosInSequence = 0; + } + else + { + if (endPosInSequence > litLength) + { + uint firstHalfMatchLength; + litLength = + startPosInSequence >= litLength ? 0 : litLength - startPosInSequence; + firstHalfMatchLength = endPosInSequence - startPosInSequence - litLength; + if ( + matchLength > blockSize + && firstHalfMatchLength >= cctx->appliedParams.cParams.minMatch + ) + { + /* Only ever split the match if it is larger than the block size */ + uint secondHalfMatchLength = + currSeq.matchLength + currSeq.litLength - endPosInSequence; + if (secondHalfMatchLength < cctx->appliedParams.cParams.minMatch) + { + endPosInSequence -= + cctx->appliedParams.cParams.minMatch - secondHalfMatchLength; + bytesAdjustment = + cctx->appliedParams.cParams.minMatch - secondHalfMatchLength; + firstHalfMatchLength -= bytesAdjustment; + } + + matchLength = firstHalfMatchLength; + finalMatchSplit = 1; + } + else + { + bytesAdjustment = endPosInSequence - currSeq.litLength; + endPosInSequence = currSeq.litLength; + break; + } + } + else + { + break; + } + } + + { + uint ll0 = litLength == 0 ? 1U : 0U; + offBase = ZSTD_finalizeOffBase(rawOffset, updatedRepcodes.rep, ll0); + ZSTD_updateRep(updatedRepcodes.rep, offBase, ll0); + } + + if (cctx->appliedParams.validateSequences != 0) + { + seqPos->posInSrc += litLength + matchLength; + { + nuint err_code = ZSTD_validateSequence( + offBase, + matchLength, + cctx->appliedParams.cParams.minMatch, + seqPos->posInSrc, + cctx->appliedParams.cParams.windowLog, + dictSize, + ZSTD_hasExtSeqProd(&cctx->appliedParams) + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + } + + if (idx - seqPos->idx >= cctx->seqStore.maxNbSeq) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid) + ); + } + + ZSTD_storeSeq(&cctx->seqStore, litLength, ip, iend, offBase, matchLength); + ip += matchLength + litLength; + if (finalMatchSplit == 0) + idx++; + } + + assert( + idx == inSeqsSize || endPosInSequence <= inSeqs[idx].litLength + inSeqs[idx].matchLength + ); + seqPos->idx = idx; + seqPos->posInSequence = endPosInSequence; + memcpy(cctx->blockState.nextCBlock->rep, updatedRepcodes.rep, (uint)sizeof(repcodes_s)); + iend -= bytesAdjustment; + if (ip != iend) + { + /* Store any last literals */ + uint lastLLSize = (uint)(iend - ip); + assert(ip <= iend); + ZSTD_storeLastLiterals(&cctx->seqStore, ip, lastLLSize); + seqPos->posInSrc += lastLLSize; + } + + return (nuint)(iend - istart); + } + + private static void* ZSTD_selectSequenceCopier(ZSTD_sequenceFormat_e mode) + { + assert( + ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_experimentalParam11, (int)mode) != 0 + ); + if (mode == ZSTD_sequenceFormat_e.ZSTD_sf_explicitBlockDelimiters) + { + return (delegate* managed< + ZSTD_CCtx_s*, + ZSTD_SequencePosition*, + ZSTD_Sequence*, + nuint, + void*, + nuint, + ZSTD_paramSwitch_e, + nuint>)(&ZSTD_transferSequences_wBlockDelim); + } + + assert(mode == ZSTD_sequenceFormat_e.ZSTD_sf_noBlockDelimiters); + return (delegate* managed< + ZSTD_CCtx_s*, + ZSTD_SequencePosition*, + ZSTD_Sequence*, + nuint, + void*, + nuint, + ZSTD_paramSwitch_e, + nuint>)(&ZSTD_transferSequences_noDelim); + } + + /* Discover the size of next block by searching for the delimiter. + * Note that a block delimiter **must** exist in this mode, + * otherwise it's an input error. + * The block size retrieved will be later compared to ensure it remains within bounds */ + private static nuint blockSize_explicitDelimiter( + ZSTD_Sequence* inSeqs, + nuint inSeqsSize, + ZSTD_SequencePosition seqPos + ) + { + int end = 0; + nuint blockSize = 0; + nuint spos = seqPos.idx; + assert(spos <= inSeqsSize); + while (spos < inSeqsSize) + { + end = inSeqs[spos].offset == 0 ? 1 : 0; + blockSize += inSeqs[spos].litLength + inSeqs[spos].matchLength; + if (end != 0) + { + if (inSeqs[spos].matchLength != 0) + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid) + ); + break; + } + + spos++; + } + + if (end == 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid)); + return blockSize; + } + + private static nuint determine_blockSize( + ZSTD_sequenceFormat_e mode, + nuint blockSize, + nuint remaining, + ZSTD_Sequence* inSeqs, + nuint inSeqsSize, + ZSTD_SequencePosition seqPos + ) + { + if (mode == ZSTD_sequenceFormat_e.ZSTD_sf_noBlockDelimiters) + { + return remaining < blockSize ? remaining : blockSize; + } + + assert(mode == ZSTD_sequenceFormat_e.ZSTD_sf_explicitBlockDelimiters); + { + nuint explicitBlockSize = blockSize_explicitDelimiter(inSeqs, inSeqsSize, seqPos); + { + nuint err_code = explicitBlockSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (explicitBlockSize > blockSize) + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid) + ); + if (explicitBlockSize > remaining) + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid) + ); + return explicitBlockSize; + } + } + + /* Compress all provided sequences, block-by-block. + * + * Returns the cumulative size of all compressed blocks (including their headers), + * otherwise a ZSTD error. + */ + private static nuint ZSTD_compressSequences_internal( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + ZSTD_Sequence* inSeqs, + nuint inSeqsSize, + void* src, + nuint srcSize + ) + { + nuint cSize = 0; + nuint remaining = srcSize; + ZSTD_SequencePosition seqPos = new ZSTD_SequencePosition + { + idx = 0, + posInSequence = 0, + posInSrc = 0, + }; + byte* ip = (byte*)src; + byte* op = (byte*)dst; + void* sequenceCopier = ZSTD_selectSequenceCopier(cctx->appliedParams.blockDelimiters); + if (remaining == 0) + { + /* last block */ + uint cBlockHeader24 = 1 + ((uint)blockType_e.bt_raw << 1); + if (dstCapacity < 4) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + MEM_writeLE32(op, cBlockHeader24); + op += ZSTD_blockHeaderSize; + dstCapacity -= ZSTD_blockHeaderSize; + cSize += ZSTD_blockHeaderSize; + } + + while (remaining != 0) + { + nuint compressedSeqsSize; + nuint cBlockSize; + nuint blockSize = determine_blockSize( + cctx->appliedParams.blockDelimiters, + cctx->blockSizeMax, + remaining, + inSeqs, + inSeqsSize, + seqPos + ); + uint lastBlock = blockSize == remaining ? 1U : 0U; + { + nuint err_code = blockSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(blockSize <= remaining); + ZSTD_resetSeqStore(&cctx->seqStore); + blockSize = ( + (delegate* managed< + ZSTD_CCtx_s*, + ZSTD_SequencePosition*, + ZSTD_Sequence*, + nuint, + void*, + nuint, + ZSTD_paramSwitch_e, + nuint>)sequenceCopier + )( + cctx, + &seqPos, + inSeqs, + inSeqsSize, + ip, + blockSize, + cctx->appliedParams.searchForExternalRepcodes + ); + { + nuint err_code = blockSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (blockSize < (nuint)(1 + 1) + ZSTD_blockHeaderSize + 1 + 1) + { + cBlockSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock); + { + nuint err_code = cBlockSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + cSize += cBlockSize; + ip += blockSize; + op += cBlockSize; + remaining -= blockSize; + dstCapacity -= cBlockSize; + continue; + } + + if (dstCapacity < ZSTD_blockHeaderSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + compressedSeqsSize = ZSTD_entropyCompressSeqStore( + &cctx->seqStore, + &cctx->blockState.prevCBlock->entropy, + &cctx->blockState.nextCBlock->entropy, + &cctx->appliedParams, + op + ZSTD_blockHeaderSize, + dstCapacity - ZSTD_blockHeaderSize, + blockSize, + cctx->tmpWorkspace, + cctx->tmpWkspSize, + cctx->bmi2 + ); + { + nuint err_code = compressedSeqsSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if ( + cctx->isFirstBlock == 0 + && ZSTD_maybeRLE(&cctx->seqStore) != 0 + && ZSTD_isRLE(ip, blockSize) != 0 + ) + { + compressedSeqsSize = 1; + } + + if (compressedSeqsSize == 0) + { + cBlockSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock); + { + nuint err_code = cBlockSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + } + else if (compressedSeqsSize == 1) + { + cBlockSize = ZSTD_rleCompressBlock(op, dstCapacity, *ip, blockSize, lastBlock); + { + nuint err_code = cBlockSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + } + else + { + uint cBlockHeader; + ZSTD_blockState_confirmRepcodesAndEntropyTables(&cctx->blockState); + if ( + cctx->blockState.prevCBlock->entropy.fse.offcode_repeatMode + == FSE_repeat.FSE_repeat_valid + ) + cctx->blockState.prevCBlock->entropy.fse.offcode_repeatMode = + FSE_repeat.FSE_repeat_check; + cBlockHeader = + lastBlock + + ((uint)blockType_e.bt_compressed << 1) + + (uint)(compressedSeqsSize << 3); + MEM_writeLE24(op, cBlockHeader); + cBlockSize = ZSTD_blockHeaderSize + compressedSeqsSize; + } + + cSize += cBlockSize; + if (lastBlock != 0) + { + break; + } + else + { + ip += blockSize; + op += cBlockSize; + remaining -= blockSize; + dstCapacity -= cBlockSize; + cctx->isFirstBlock = 0; + } + } + + return cSize; + } + + /*! ZSTD_compressSequences() : + * Compress an array of ZSTD_Sequence, associated with @src buffer, into dst. + * @src contains the entire input (not just the literals). + * If @srcSize > sum(sequence.length), the remaining bytes are considered all literals + * If a dictionary is included, then the cctx should reference the dict (see: ZSTD_CCtx_refCDict(), ZSTD_CCtx_loadDictionary(), etc.). + * The entire source is compressed into a single frame. + * + * The compression behavior changes based on cctx params. In particular: + * If ZSTD_c_blockDelimiters == ZSTD_sf_noBlockDelimiters, the array of ZSTD_Sequence is expected to contain + * no block delimiters (defined in ZSTD_Sequence). Block boundaries are roughly determined based on + * the block size derived from the cctx, and sequences may be split. This is the default setting. + * + * If ZSTD_c_blockDelimiters == ZSTD_sf_explicitBlockDelimiters, the array of ZSTD_Sequence is expected to contain + * valid block delimiters (defined in ZSTD_Sequence). Behavior is undefined if no block delimiters are provided. + * + * When ZSTD_c_blockDelimiters == ZSTD_sf_explicitBlockDelimiters, it's possible to decide generating repcodes + * using the advanced parameter ZSTD_c_repcodeResolution. Repcodes will improve compression ratio, though the benefit + * can vary greatly depending on Sequences. On the other hand, repcode resolution is an expensive operation. + * By default, it's disabled at low (<10) compression levels, and enabled above the threshold (>=10). + * ZSTD_c_repcodeResolution makes it possible to directly manage this processing in either direction. + * + * If ZSTD_c_validateSequences == 0, this function blindly accepts the Sequences provided. Invalid Sequences cause undefined + * behavior. If ZSTD_c_validateSequences == 1, then the function will detect invalid Sequences (see doc/zstd_compression_format.md for + * specifics regarding offset/matchlength requirements) and then bail out and return an error. + * + * In addition to the two adjustable experimental params, there are other important cctx params. + * - ZSTD_c_minMatch MUST be set as less than or equal to the smallest match generated by the match finder. It has a minimum value of ZSTD_MINMATCH_MIN. + * - ZSTD_c_compressionLevel accordingly adjusts the strength of the entropy coder, as it would in typical compression. + * - ZSTD_c_windowLog affects offset validation: this function will return an error at higher debug levels if a provided offset + * is larger than what the spec allows for a given window log and dictionary (if present). See: doc/zstd_compression_format.md + * + * Note: Repcodes are, as of now, always re-calculated within this function, ZSTD_Sequence.rep is effectively unused. + * Dev Note: Once ability to ingest repcodes become available, the explicit block delims mode must respect those repcodes exactly, + * and cannot emit an RLE block that disagrees with the repcode history. + * @return : final compressed size, or a ZSTD error code. + */ + public static nuint ZSTD_compressSequences( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + ZSTD_Sequence* inSeqs, + nuint inSeqsSize, + void* src, + nuint srcSize + ) + { + byte* op = (byte*)dst; + nuint cSize = 0; + assert(cctx != null); + { + nuint err_code = ZSTD_CCtx_init_compressStream2( + cctx, + ZSTD_EndDirective.ZSTD_e_end, + srcSize + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint frameHeaderSize = ZSTD_writeFrameHeader( + op, + dstCapacity, + &cctx->appliedParams, + srcSize, + cctx->dictID + ); + op += frameHeaderSize; + assert(frameHeaderSize <= dstCapacity); + dstCapacity -= frameHeaderSize; + cSize += frameHeaderSize; + } + + if (cctx->appliedParams.fParams.checksumFlag != 0 && srcSize != 0) + { + ZSTD_XXH64_update(&cctx->xxhState, src, srcSize); + } + + { + nuint cBlocksSize = ZSTD_compressSequences_internal( + cctx, + op, + dstCapacity, + inSeqs, + inSeqsSize, + src, + srcSize + ); + { + nuint err_code = cBlocksSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + cSize += cBlocksSize; + assert(cBlocksSize <= dstCapacity); + dstCapacity -= cBlocksSize; + } + + if (cctx->appliedParams.fParams.checksumFlag != 0) + { + uint checksum = (uint)ZSTD_XXH64_digest(&cctx->xxhState); + if (dstCapacity < 4) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + MEM_writeLE32((sbyte*)dst + cSize, checksum); + cSize += 4; + } + + return cSize; + } + + private static nuint convertSequences_noRepcodes( + SeqDef_s* dstSeqs, + ZSTD_Sequence* inSeqs, + nuint nbSequences + ) + { + nuint longLen = 0; + nuint n; + for (n = 0; n < nbSequences; n++) + { + assert(inSeqs[n].offset > 0); + dstSeqs[n].offBase = inSeqs[n].offset + 3; + dstSeqs[n].litLength = (ushort)inSeqs[n].litLength; + dstSeqs[n].mlBase = (ushort)(inSeqs[n].matchLength - 3); + if (inSeqs[n].matchLength > 65535 + 3) + { + assert(longLen == 0); + longLen = n + 1; + } + + if (inSeqs[n].litLength > 65535) + { + assert(longLen == 0); + longLen = n + nbSequences + 1; + } + } + + return longLen; + } + + /* + * Precondition: Sequences must end on an explicit Block Delimiter + * @return: 0 on success, or an error code. + * Note: Sequence validation functionality has been disabled (removed). + * This is helpful to generate a lean main pipeline, improving performance. + * It may be re-inserted later. + */ + private static nuint ZSTD_convertBlockSequences( + ZSTD_CCtx_s* cctx, + ZSTD_Sequence* inSeqs, + nuint nbSequences, + int repcodeResolution + ) + { + repcodes_s updatedRepcodes; + nuint seqNb = 0; + if (nbSequences >= cctx->seqStore.maxNbSeq) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid)); + } + + memcpy(updatedRepcodes.rep, cctx->blockState.prevCBlock->rep, (uint)sizeof(repcodes_s)); + assert(nbSequences >= 1); + assert(inSeqs[nbSequences - 1].matchLength == 0); + assert(inSeqs[nbSequences - 1].offset == 0); + if (repcodeResolution == 0) + { + nuint longl = convertSequences_noRepcodes( + cctx->seqStore.sequencesStart, + inSeqs, + nbSequences - 1 + ); + cctx->seqStore.sequences = cctx->seqStore.sequencesStart + nbSequences - 1; + if (longl != 0) + { + assert(cctx->seqStore.longLengthType == ZSTD_longLengthType_e.ZSTD_llt_none); + if (longl <= nbSequences - 1) + { + cctx->seqStore.longLengthType = ZSTD_longLengthType_e.ZSTD_llt_matchLength; + cctx->seqStore.longLengthPos = (uint)(longl - 1); + } + else + { + assert(longl <= 2 * (nbSequences - 1)); + cctx->seqStore.longLengthType = ZSTD_longLengthType_e.ZSTD_llt_literalLength; + cctx->seqStore.longLengthPos = (uint)(longl - (nbSequences - 1) - 1); + } + } + } + else + { + for (seqNb = 0; seqNb < nbSequences - 1; seqNb++) + { + uint litLength = inSeqs[seqNb].litLength; + uint matchLength = inSeqs[seqNb].matchLength; + uint ll0 = litLength == 0 ? 1U : 0U; + uint offBase = ZSTD_finalizeOffBase(inSeqs[seqNb].offset, updatedRepcodes.rep, ll0); + ZSTD_storeSeqOnly(&cctx->seqStore, litLength, offBase, matchLength); + ZSTD_updateRep(updatedRepcodes.rep, offBase, ll0); + } + } + + if (repcodeResolution == 0 && nbSequences > 1) + { + uint* rep = updatedRepcodes.rep; + if (nbSequences >= 4) + { + /* index of last full sequence */ + uint lastSeqIdx = (uint)nbSequences - 2; + rep[2] = inSeqs[lastSeqIdx - 2].offset; + rep[1] = inSeqs[lastSeqIdx - 1].offset; + rep[0] = inSeqs[lastSeqIdx].offset; + } + else if (nbSequences == 3) + { + rep[2] = rep[0]; + rep[1] = inSeqs[0].offset; + rep[0] = inSeqs[1].offset; + } + else + { + assert(nbSequences == 2); + rep[2] = rep[1]; + rep[1] = rep[0]; + rep[0] = inSeqs[0].offset; + } + } + + memcpy(cctx->blockState.nextCBlock->rep, updatedRepcodes.rep, (uint)sizeof(repcodes_s)); + return 0; + } + + private static BlockSummary ZSTD_get1BlockSummary(ZSTD_Sequence* seqs, nuint nbSeqs) + { + nuint totalMatchSize = 0; + nuint litSize = 0; + nuint n; + assert(seqs != null); + for (n = 0; n < nbSeqs; n++) + { + totalMatchSize += seqs[n].matchLength; + litSize += seqs[n].litLength; + if (seqs[n].matchLength == 0) + { + assert(seqs[n].offset == 0); + break; + } + } + + if (n == nbSeqs) + { + BlockSummary bs; + System.Runtime.CompilerServices.Unsafe.SkipInit(out bs); + bs.nbSequences = unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid) + ); + return bs; + } + + { + BlockSummary bs; + bs.nbSequences = n + 1; + bs.blockSize = litSize + totalMatchSize; + bs.litSize = litSize; + return bs; + } + } + + private static nuint ZSTD_compressSequencesAndLiterals_internal( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + ZSTD_Sequence* inSeqs, + nuint nbSequences, + void* literals, + nuint litSize, + nuint srcSize + ) + { + nuint remaining = srcSize; + nuint cSize = 0; + byte* op = (byte*)dst; + int repcodeResolution = + cctx->appliedParams.searchForExternalRepcodes == ZSTD_paramSwitch_e.ZSTD_ps_enable + ? 1 + : 0; + assert(cctx->appliedParams.searchForExternalRepcodes != ZSTD_paramSwitch_e.ZSTD_ps_auto); + if (nbSequences == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid)); + } + + if (nbSequences == 1 && inSeqs[0].litLength == 0) + { + /* last block */ + uint cBlockHeader24 = 1 + ((uint)blockType_e.bt_raw << 1); + if (dstCapacity < 3) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + MEM_writeLE24(op, cBlockHeader24); + op += ZSTD_blockHeaderSize; + dstCapacity -= ZSTD_blockHeaderSize; + cSize += ZSTD_blockHeaderSize; + } + + while (nbSequences != 0) + { + nuint compressedSeqsSize, + cBlockSize, + conversionStatus; + BlockSummary block = ZSTD_get1BlockSummary(inSeqs, nbSequences); + uint lastBlock = block.nbSequences == nbSequences ? 1U : 0U; + { + nuint err_code = block.nbSequences; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(block.nbSequences <= nbSequences); + if (block.litSize > litSize) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid) + ); + } + + ZSTD_resetSeqStore(&cctx->seqStore); + conversionStatus = ZSTD_convertBlockSequences( + cctx, + inSeqs, + block.nbSequences, + repcodeResolution + ); + { + nuint err_code = conversionStatus; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + inSeqs += block.nbSequences; + nbSequences -= block.nbSequences; + remaining -= block.blockSize; + if (dstCapacity < ZSTD_blockHeaderSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + compressedSeqsSize = ZSTD_entropyCompressSeqStore_internal( + op + ZSTD_blockHeaderSize, + dstCapacity - ZSTD_blockHeaderSize, + literals, + block.litSize, + &cctx->seqStore, + &cctx->blockState.prevCBlock->entropy, + &cctx->blockState.nextCBlock->entropy, + &cctx->appliedParams, + cctx->tmpWorkspace, + cctx->tmpWkspSize, + cctx->bmi2 + ); + { + nuint err_code = compressedSeqsSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (compressedSeqsSize > cctx->blockSizeMax) + compressedSeqsSize = 0; + litSize -= block.litSize; + literals = (sbyte*)literals + block.litSize; + if (compressedSeqsSize == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_cannotProduce_uncompressedBlock) + ); + } + else + { + uint cBlockHeader; + assert(compressedSeqsSize > 1); + ZSTD_blockState_confirmRepcodesAndEntropyTables(&cctx->blockState); + if ( + cctx->blockState.prevCBlock->entropy.fse.offcode_repeatMode + == FSE_repeat.FSE_repeat_valid + ) + cctx->blockState.prevCBlock->entropy.fse.offcode_repeatMode = + FSE_repeat.FSE_repeat_check; + cBlockHeader = + lastBlock + + ((uint)blockType_e.bt_compressed << 1) + + (uint)(compressedSeqsSize << 3); + MEM_writeLE24(op, cBlockHeader); + cBlockSize = ZSTD_blockHeaderSize + compressedSeqsSize; + } + + cSize += cBlockSize; + op += cBlockSize; + dstCapacity -= cBlockSize; + cctx->isFirstBlock = 0; + if (lastBlock != 0) + { + assert(nbSequences == 0); + break; + } + } + + if (litSize != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid)); + } + + if (remaining != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_externalSequences_invalid)); + } + + return cSize; + } + + /*! ZSTD_compressSequencesAndLiterals() : + * This is a variant of ZSTD_compressSequences() which, + * instead of receiving (src,srcSize) as input parameter, receives (literals,litSize), + * aka all the literals, already extracted and laid out into a single continuous buffer. + * This can be useful if the process generating the sequences also happens to generate the buffer of literals, + * thus skipping an extraction + caching stage. + * It's a speed optimization, useful when the right conditions are met, + * but it also features the following limitations: + * - Only supports explicit delimiter mode + * - Currently does not support Sequences validation (so input Sequences are trusted) + * - Not compatible with frame checksum, which must be disabled + * - If any block is incompressible, will fail and return an error + * - @litSize must be == sum of all @.litLength fields in @inSeqs. Any discrepancy will generate an error. + * - @litBufCapacity is the size of the underlying buffer into which literals are written, starting at address @literals. + * @litBufCapacity must be at least 8 bytes larger than @litSize. + * - @decompressedSize must be correct, and correspond to the sum of all Sequences. Any discrepancy will generate an error. + * @return : final compressed size, or a ZSTD error code. + */ + public static nuint ZSTD_compressSequencesAndLiterals( + ZSTD_CCtx_s* cctx, + void* dst, + nuint dstCapacity, + ZSTD_Sequence* inSeqs, + nuint inSeqsSize, + void* literals, + nuint litSize, + nuint litCapacity, + nuint decompressedSize + ) + { + byte* op = (byte*)dst; + nuint cSize = 0; + assert(cctx != null); + if (litCapacity < litSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_workSpace_tooSmall)); + } + + { + nuint err_code = ZSTD_CCtx_init_compressStream2( + cctx, + ZSTD_EndDirective.ZSTD_e_end, + decompressedSize + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (cctx->appliedParams.blockDelimiters == ZSTD_sequenceFormat_e.ZSTD_sf_noBlockDelimiters) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_frameParameter_unsupported)); + } + + if (cctx->appliedParams.validateSequences != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_unsupported)); + } + + if (cctx->appliedParams.fParams.checksumFlag != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_frameParameter_unsupported)); + } + + { + nuint frameHeaderSize = ZSTD_writeFrameHeader( + op, + dstCapacity, + &cctx->appliedParams, + decompressedSize, + cctx->dictID + ); + op += frameHeaderSize; + assert(frameHeaderSize <= dstCapacity); + dstCapacity -= frameHeaderSize; + cSize += frameHeaderSize; + } + + { + nuint cBlocksSize = ZSTD_compressSequencesAndLiterals_internal( + cctx, + op, + dstCapacity, + inSeqs, + inSeqsSize, + literals, + litSize, + decompressedSize + ); + { + nuint err_code = cBlocksSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + cSize += cBlocksSize; + assert(cBlocksSize <= dstCapacity); + dstCapacity -= cBlocksSize; + } + + return cSize; + } + + /*====== Finalize ======*/ + private static ZSTD_inBuffer_s inBuffer_forEndFlush(ZSTD_CCtx_s* zcs) + { + ZSTD_inBuffer_s nullInput = new ZSTD_inBuffer_s + { + src = null, + size = 0, + pos = 0, + }; + int stableInput = + zcs->appliedParams.inBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable ? 1 : 0; + return stableInput != 0 ? zcs->expectedInBuffer : nullInput; + } + + /*! ZSTD_flushStream() : + * @return : amount of data remaining to flush */ + public static nuint ZSTD_flushStream(ZSTD_CCtx_s* zcs, ZSTD_outBuffer_s* output) + { + ZSTD_inBuffer_s input = inBuffer_forEndFlush(zcs); + input.size = input.pos; + return ZSTD_compressStream2(zcs, output, &input, ZSTD_EndDirective.ZSTD_e_flush); + } + + /*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end). */ + public static nuint ZSTD_endStream(ZSTD_CCtx_s* zcs, ZSTD_outBuffer_s* output) + { + ZSTD_inBuffer_s input = inBuffer_forEndFlush(zcs); + nuint remainingToFlush = ZSTD_compressStream2( + zcs, + output, + &input, + ZSTD_EndDirective.ZSTD_e_end + ); + { + nuint err_code = remainingToFlush; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (zcs->appliedParams.nbWorkers > 0) + return remainingToFlush; + { + nuint lastBlockSize = (nuint)(zcs->frameEnded != 0 ? 0 : 3); + nuint checksumSize = (nuint)( + zcs->frameEnded != 0 ? 0 : zcs->appliedParams.fParams.checksumFlag * 4 + ); + nuint toFlush = remainingToFlush + lastBlockSize + checksumSize; + return toFlush; + } + } + + public static int ZSTD_maxCLevel() + { + return 22; + } + + public static int ZSTD_minCLevel() + { + return -(1 << 17); + } + + public static int ZSTD_defaultCLevel() + { + return 3; + } + + private static ZSTD_compressionParameters ZSTD_dedicatedDictSearch_getCParams( + int compressionLevel, + nuint dictSize + ) + { + ZSTD_compressionParameters cParams = ZSTD_getCParams_internal( + compressionLevel, + 0, + dictSize, + ZSTD_CParamMode_e.ZSTD_cpm_createCDict + ); + switch (cParams.strategy) + { + case ZSTD_strategy.ZSTD_fast: + case ZSTD_strategy.ZSTD_dfast: + break; + case ZSTD_strategy.ZSTD_greedy: + case ZSTD_strategy.ZSTD_lazy: + case ZSTD_strategy.ZSTD_lazy2: + cParams.hashLog += 2; + break; + case ZSTD_strategy.ZSTD_btlazy2: + case ZSTD_strategy.ZSTD_btopt: + case ZSTD_strategy.ZSTD_btultra: + case ZSTD_strategy.ZSTD_btultra2: + break; + } + + return cParams; + } + + private static int ZSTD_dedicatedDictSearch_isSupported(ZSTD_compressionParameters* cParams) + { + return + cParams->strategy >= ZSTD_strategy.ZSTD_greedy + && cParams->strategy <= ZSTD_strategy.ZSTD_lazy2 + && cParams->hashLog > cParams->chainLog + && cParams->chainLog <= 24 + ? 1 + : 0; + } + + /** + * Reverses the adjustment applied to cparams when enabling dedicated dict + * search. This is used to recover the params set to be used in the working + * context. (Otherwise, those tables would also grow.) + */ + private static void ZSTD_dedicatedDictSearch_revertCParams(ZSTD_compressionParameters* cParams) + { + switch (cParams->strategy) + { + case ZSTD_strategy.ZSTD_fast: + case ZSTD_strategy.ZSTD_dfast: + break; + case ZSTD_strategy.ZSTD_greedy: + case ZSTD_strategy.ZSTD_lazy: + case ZSTD_strategy.ZSTD_lazy2: + cParams->hashLog -= 2; + if (cParams->hashLog < 6) + { + cParams->hashLog = 6; + } + + break; + case ZSTD_strategy.ZSTD_btlazy2: + case ZSTD_strategy.ZSTD_btopt: + case ZSTD_strategy.ZSTD_btultra: + case ZSTD_strategy.ZSTD_btultra2: + break; + } + } + + private static ulong ZSTD_getCParamRowSize( + ulong srcSizeHint, + nuint dictSize, + ZSTD_CParamMode_e mode + ) + { + switch (mode) + { + case ZSTD_CParamMode_e.ZSTD_cpm_unknown: + case ZSTD_CParamMode_e.ZSTD_cpm_noAttachDict: + case ZSTD_CParamMode_e.ZSTD_cpm_createCDict: + break; + case ZSTD_CParamMode_e.ZSTD_cpm_attachDict: + dictSize = 0; + break; + default: + assert(0 != 0); + break; + } + + { + int unknown = srcSizeHint == unchecked(0UL - 1) ? 1 : 0; + nuint addedSize = (nuint)(unknown != 0 && dictSize > 0 ? 500 : 0); + return unknown != 0 && dictSize == 0 + ? unchecked(0UL - 1) + : srcSizeHint + dictSize + addedSize; + } + } + + /*! ZSTD_getCParams_internal() : + * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize. + * Note: srcSizeHint 0 means 0, use ZSTD_CONTENTSIZE_UNKNOWN for unknown. + * Use dictSize == 0 for unknown or unused. + * Note: `mode` controls how we treat the `dictSize`. See docs for `ZSTD_CParamMode_e`. */ + private static ZSTD_compressionParameters ZSTD_getCParams_internal( + int compressionLevel, + ulong srcSizeHint, + nuint dictSize, + ZSTD_CParamMode_e mode + ) + { + ulong rSize = ZSTD_getCParamRowSize(srcSizeHint, dictSize, mode); + uint tableID = (uint)( + (rSize <= 256 * (1 << 10) ? 1 : 0) + + (rSize <= 128 * (1 << 10) ? 1 : 0) + + (rSize <= 16 * (1 << 10) ? 1 : 0) + ); + int row; + if (compressionLevel == 0) + row = 3; + else if (compressionLevel < 0) + row = 0; + else if (compressionLevel > 22) + row = 22; + else + row = compressionLevel; + { + ZSTD_compressionParameters cp = ZSTD_defaultCParameters[tableID][row]; + if (compressionLevel < 0) + { + int clampedCompressionLevel = + ZSTD_minCLevel() > compressionLevel ? ZSTD_minCLevel() : compressionLevel; + cp.targetLength = (uint)-clampedCompressionLevel; + } + + return ZSTD_adjustCParams_internal( + cp, + srcSizeHint, + dictSize, + mode, + ZSTD_paramSwitch_e.ZSTD_ps_auto + ); + } + } + + /*! ZSTD_getCParams() : + * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize. + * Size values are optional, provide 0 if not known or unused */ + public static ZSTD_compressionParameters ZSTD_getCParams( + int compressionLevel, + ulong srcSizeHint, + nuint dictSize + ) + { + if (srcSizeHint == 0) + srcSizeHint = unchecked(0UL - 1); + return ZSTD_getCParams_internal( + compressionLevel, + srcSizeHint, + dictSize, + ZSTD_CParamMode_e.ZSTD_cpm_unknown + ); + } + + /*! ZSTD_getParams() : + * same idea as ZSTD_getCParams() + * @return a `ZSTD_parameters` structure (instead of `ZSTD_compressionParameters`). + * Fields of `ZSTD_frameParameters` are set to default values */ + private static ZSTD_parameters ZSTD_getParams_internal( + int compressionLevel, + ulong srcSizeHint, + nuint dictSize, + ZSTD_CParamMode_e mode + ) + { + ZSTD_parameters @params; + ZSTD_compressionParameters cParams = ZSTD_getCParams_internal( + compressionLevel, + srcSizeHint, + dictSize, + mode + ); + @params = new ZSTD_parameters { cParams = cParams }; + @params.fParams.contentSizeFlag = 1; + return @params; + } + + /*! ZSTD_getParams() : + * same idea as ZSTD_getCParams() + * @return a `ZSTD_parameters` structure (instead of `ZSTD_compressionParameters`). + * Fields of `ZSTD_frameParameters` are set to default values */ + public static ZSTD_parameters ZSTD_getParams( + int compressionLevel, + ulong srcSizeHint, + nuint dictSize + ) + { + if (srcSizeHint == 0) + srcSizeHint = unchecked(0UL - 1); + return ZSTD_getParams_internal( + compressionLevel, + srcSizeHint, + dictSize, + ZSTD_CParamMode_e.ZSTD_cpm_unknown + ); + } + + /*! ZSTD_registerSequenceProducer() : + * Instruct zstd to use a block-level external sequence producer function. + * + * The sequenceProducerState must be initialized by the caller, and the caller is + * responsible for managing its lifetime. This parameter is sticky across + * compressions. It will remain set until the user explicitly resets compression + * parameters. + * + * Sequence producer registration is considered to be an "advanced parameter", + * part of the "advanced API". This means it will only have an effect on compression + * APIs which respect advanced parameters, such as compress2() and compressStream2(). + * Older compression APIs such as compressCCtx(), which predate the introduction of + * "advanced parameters", will ignore any external sequence producer setting. + * + * The sequence producer can be "cleared" by registering a NULL function pointer. This + * removes all limitations described above in the "LIMITATIONS" section of the API docs. + * + * The user is strongly encouraged to read the full API documentation (above) before + * calling this function. */ + public static void ZSTD_registerSequenceProducer( + ZSTD_CCtx_s* zc, + void* extSeqProdState, + void* extSeqProdFunc + ) + { + assert(zc != null); + ZSTD_CCtxParams_registerSequenceProducer( + &zc->requestedParams, + extSeqProdState, + extSeqProdFunc + ); + } + + /*! ZSTD_CCtxParams_registerSequenceProducer() : + * Same as ZSTD_registerSequenceProducer(), but operates on ZSTD_CCtx_params. + * This is used for accurate size estimation with ZSTD_estimateCCtxSize_usingCCtxParams(), + * which is needed when creating a ZSTD_CCtx with ZSTD_initStaticCCtx(). + * + * If you are using the external sequence producer API in a scenario where ZSTD_initStaticCCtx() + * is required, then this function is for you. Otherwise, you probably don't need it. + * + * See tests/zstreamtest.c for example usage. */ + public static void ZSTD_CCtxParams_registerSequenceProducer( + ZSTD_CCtx_params_s* @params, + void* extSeqProdState, + void* extSeqProdFunc + ) + { + assert(@params != null); + if (extSeqProdFunc != null) + { + @params->extSeqProdFunc = extSeqProdFunc; + @params->extSeqProdState = extSeqProdState; + } + else + { + @params->extSeqProdFunc = null; + @params->extSeqProdState = null; + } + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressInternal.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressInternal.cs new file mode 100644 index 000000000..2e836fb16 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressInternal.cs @@ -0,0 +1,1444 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /** + * Returns the ZSTD_SequenceLength for the given sequences. It handles the decoding of long sequences + * indicated by longLengthPos and longLengthType, and adds MINMATCH back to matchLength. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ZSTD_SequenceLength ZSTD_getSequenceLength(SeqStore_t* seqStore, SeqDef_s* seq) + { + ZSTD_SequenceLength seqLen; + seqLen.litLength = seq->litLength; + seqLen.matchLength = (uint)(seq->mlBase + 3); + if (seqStore->longLengthPos == (uint)(seq - seqStore->sequencesStart)) + { + if (seqStore->longLengthType == ZSTD_longLengthType_e.ZSTD_llt_literalLength) + { + seqLen.litLength += 0x10000; + } + + if (seqStore->longLengthType == ZSTD_longLengthType_e.ZSTD_llt_matchLength) + { + seqLen.matchLength += 0x10000; + } + } + + return seqLen; + } + + private static readonly RawSeqStore_t kNullRawSeqStore = new RawSeqStore_t( + seq: null, + pos: 0, + posInSequence: 0, + size: 0, + capacity: 0 + ); +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_LL_Code => + new byte[64] + { + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 16, + 17, + 17, + 18, + 18, + 19, + 19, + 20, + 20, + 20, + 20, + 21, + 21, + 21, + 21, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + }; + private static byte* LL_Code => + (byte*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_LL_Code) + ); +#else + + private static readonly byte* LL_Code = GetArrayPointer( + new byte[64] + { + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 16, + 17, + 17, + 18, + 18, + 19, + 19, + 20, + 20, + 20, + 20, + 21, + 21, + 21, + 21, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + } + ); +#endif + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_LLcode(uint litLength) + { + const uint LL_deltaCode = 19; + return litLength > 63 ? ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength]; + } + +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_ML_Code => + new byte[128] + { + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 32, + 33, + 33, + 34, + 34, + 35, + 35, + 36, + 36, + 36, + 36, + 37, + 37, + 37, + 37, + 38, + 38, + 38, + 38, + 38, + 38, + 38, + 38, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + }; + private static byte* ML_Code => + (byte*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_ML_Code) + ); +#else + + private static readonly byte* ML_Code = GetArrayPointer( + new byte[128] + { + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 32, + 33, + 33, + 34, + 34, + 35, + 35, + 36, + 36, + 36, + 36, + 37, + 37, + 37, + 37, + 38, + 38, + 38, + 38, + 38, + 38, + 38, + 38, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 41, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + } + ); +#endif + /* ZSTD_MLcode() : + * note : mlBase = matchLength - MINMATCH; + * because it's the format it's stored in seqStore->sequences */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_MLcode(uint mlBase) + { + const uint ML_deltaCode = 36; + return mlBase > 127 ? ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase]; + } + + /* ZSTD_cParam_withinBounds: + * @return 1 if value is within cParam bounds, + * 0 otherwise */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_cParam_withinBounds(ZSTD_cParameter cParam, int value) + { + ZSTD_bounds bounds = ZSTD_cParam_getBounds(cParam); + if (ERR_isError(bounds.error)) + return 0; + if (value < bounds.lowerBound) + return 0; + if (value > bounds.upperBound) + return 0; + return 1; + } + + /* ZSTD_selectAddr: + * @return index >= lowLimit ? candidate : backup, + * tries to force branchless codegen. */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static byte* ZSTD_selectAddr(uint index, uint lowLimit, byte* candidate, byte* backup) + { + return index >= lowLimit ? candidate : backup; + } + + /* ZSTD_noCompressBlock() : + * Writes uncompressed block to dst buffer from given src. + * Returns the size of the block */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_noCompressBlock( + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + uint lastBlock + ) + { + uint cBlockHeader24 = lastBlock + ((uint)blockType_e.bt_raw << 1) + (uint)(srcSize << 3); + if (srcSize + ZSTD_blockHeaderSize > dstCapacity) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + MEM_writeLE24(dst, cBlockHeader24); + memcpy((byte*)dst + ZSTD_blockHeaderSize, src, (uint)srcSize); + return ZSTD_blockHeaderSize + srcSize; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_rleCompressBlock( + void* dst, + nuint dstCapacity, + byte src, + nuint srcSize, + uint lastBlock + ) + { + byte* op = (byte*)dst; + uint cBlockHeader = lastBlock + ((uint)blockType_e.bt_rle << 1) + (uint)(srcSize << 3); + if (dstCapacity < 4) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + MEM_writeLE24(op, cBlockHeader); + op[3] = src; + return 4; + } + + /* ZSTD_minGain() : + * minimum compression required + * to generate a compress block or a compressed literals section. + * note : use same formula for both situations */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_minGain(nuint srcSize, ZSTD_strategy strat) + { + uint minlog = strat >= ZSTD_strategy.ZSTD_btultra ? (uint)strat - 1 : 6; + assert(ZSTD_cParam_withinBounds(ZSTD_cParameter.ZSTD_c_strategy, (int)strat) != 0); + return (srcSize >> (int)minlog) + 2; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_literalsCompressionIsDisabled(ZSTD_CCtx_params_s* cctxParams) + { + switch (cctxParams->literalCompressionMode) + { + case ZSTD_paramSwitch_e.ZSTD_ps_enable: + return 0; + case ZSTD_paramSwitch_e.ZSTD_ps_disable: + return 1; + default: + assert(0 != 0); + goto case ZSTD_paramSwitch_e.ZSTD_ps_auto; + case ZSTD_paramSwitch_e.ZSTD_ps_auto: + return + cctxParams->cParams.strategy == ZSTD_strategy.ZSTD_fast + && cctxParams->cParams.targetLength > 0 + ? 1 + : 0; + } + } + + /*! ZSTD_safecopyLiterals() : + * memcpy() function that won't read beyond more than WILDCOPY_OVERLENGTH bytes past ilimit_w. + * Only called when the sequence ends past ilimit_w, so it only needs to be optimized for single + * large copies. + */ + private static void ZSTD_safecopyLiterals(byte* op, byte* ip, byte* iend, byte* ilimit_w) + { + assert(iend > ilimit_w); + if (ip <= ilimit_w) + { + ZSTD_wildcopy(op, ip, (nint)(ilimit_w - ip), ZSTD_overlap_e.ZSTD_no_overlap); + op += ilimit_w - ip; + ip = ilimit_w; + } + + while (ip < iend) + *op++ = *ip++; + } + + /*! ZSTD_storeSeqOnly() : + * Store a sequence (litlen, litPtr, offBase and matchLength) into SeqStore_t. + * Literals themselves are not copied, but @litPtr is updated. + * @offBase : Users should employ macros REPCODE_TO_OFFBASE() and OFFSET_TO_OFFBASE(). + * @matchLength : must be >= MINMATCH + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_storeSeqOnly( + SeqStore_t* seqStorePtr, + nuint litLength, + uint offBase, + nuint matchLength + ) + { + assert( + (nuint)(seqStorePtr->sequences - seqStorePtr->sequencesStart) < seqStorePtr->maxNbSeq + ); + assert(litLength <= 1 << 17); + if (litLength > 0xFFFF) + { + assert(seqStorePtr->longLengthType == ZSTD_longLengthType_e.ZSTD_llt_none); + seqStorePtr->longLengthType = ZSTD_longLengthType_e.ZSTD_llt_literalLength; + seqStorePtr->longLengthPos = (uint)( + seqStorePtr->sequences - seqStorePtr->sequencesStart + ); + } + + seqStorePtr->sequences[0].litLength = (ushort)litLength; + seqStorePtr->sequences[0].offBase = offBase; + assert(matchLength <= 1 << 17); + assert(matchLength >= 3); + { + nuint mlBase = matchLength - 3; + if (mlBase > 0xFFFF) + { + assert(seqStorePtr->longLengthType == ZSTD_longLengthType_e.ZSTD_llt_none); + seqStorePtr->longLengthType = ZSTD_longLengthType_e.ZSTD_llt_matchLength; + seqStorePtr->longLengthPos = (uint)( + seqStorePtr->sequences - seqStorePtr->sequencesStart + ); + } + + seqStorePtr->sequences[0].mlBase = (ushort)mlBase; + } + + seqStorePtr->sequences++; + } + + /*! ZSTD_storeSeq() : + * Store a sequence (litlen, litPtr, offBase and matchLength) into SeqStore_t. + * @offBase : Users should employ macros REPCODE_TO_OFFBASE() and OFFSET_TO_OFFBASE(). + * @matchLength : must be >= MINMATCH + * Allowed to over-read literals up to litLimit. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_storeSeq( + SeqStore_t* seqStorePtr, + nuint litLength, + byte* literals, + byte* litLimit, + uint offBase, + nuint matchLength + ) + { + byte* litLimit_w = litLimit - 32; + byte* litEnd = literals + litLength; + assert( + (nuint)(seqStorePtr->sequences - seqStorePtr->sequencesStart) < seqStorePtr->maxNbSeq + ); + assert(seqStorePtr->maxNbLit <= 128 * (1 << 10)); + assert(seqStorePtr->lit + litLength <= seqStorePtr->litStart + seqStorePtr->maxNbLit); + assert(literals + litLength <= litLimit); + if (litEnd <= litLimit_w) + { + ZSTD_copy16(seqStorePtr->lit, literals); + if (litLength > 16) + { + ZSTD_wildcopy( + seqStorePtr->lit + 16, + literals + 16, + (nint)litLength - 16, + ZSTD_overlap_e.ZSTD_no_overlap + ); + } + } + else + { + ZSTD_safecopyLiterals(seqStorePtr->lit, literals, litEnd, litLimit_w); + } + + seqStorePtr->lit += litLength; + ZSTD_storeSeqOnly(seqStorePtr, litLength, offBase, matchLength); + } + + /* ZSTD_updateRep() : + * updates in-place @rep (array of repeat offsets) + * @offBase : sum-type, using numeric representation of ZSTD_storeSeq() + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_updateRep(uint* rep, uint offBase, uint ll0) + { + if (offBase > 3) + { + rep[2] = rep[1]; + rep[1] = rep[0]; + assert(offBase > 3); + rep[0] = offBase - 3; + } + else + { + assert(1 <= offBase && offBase <= 3); + uint repCode = offBase - 1 + ll0; + if (repCode > 0) + { + uint currentOffset = repCode == 3 ? rep[0] - 1 : rep[repCode]; + rep[2] = repCode >= 2 ? rep[1] : rep[2]; + rep[1] = rep[0]; + rep[0] = currentOffset; + } + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static repcodes_s ZSTD_newRep(uint* rep, uint offBase, uint ll0) + { + repcodes_s newReps; + memcpy(&newReps, rep, (uint)sizeof(repcodes_s)); + ZSTD_updateRep(newReps.rep, offBase, ll0); + return newReps; + } + + /*-************************************* + * Match length counter + ***************************************/ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_count(byte* pIn, byte* pMatch, byte* pInLimit) + { + byte* pStart = pIn; + byte* pInLoopLimit = pInLimit - (sizeof(nuint) - 1); + if (pIn < pInLoopLimit) + { + { + nuint diff = MEM_readST(pMatch) ^ MEM_readST(pIn); + if (diff != 0) + return ZSTD_NbCommonBytes(diff); + } + + pIn += sizeof(nuint); + pMatch += sizeof(nuint); + while (pIn < pInLoopLimit) + { + nuint diff = MEM_readST(pMatch) ^ MEM_readST(pIn); + if (diff == 0) + { + pIn += sizeof(nuint); + pMatch += sizeof(nuint); + continue; + } + + pIn += ZSTD_NbCommonBytes(diff); + return (nuint)(pIn - pStart); + } + } + + if (MEM_64bits && pIn < pInLimit - 3 && MEM_read32(pMatch) == MEM_read32(pIn)) + { + pIn += 4; + pMatch += 4; + } + + if (pIn < pInLimit - 1 && MEM_read16(pMatch) == MEM_read16(pIn)) + { + pIn += 2; + pMatch += 2; + } + + if (pIn < pInLimit && *pMatch == *pIn) + pIn++; + return (nuint)(pIn - pStart); + } + + /** ZSTD_count_2segments() : + * can count match length with `ip` & `match` in 2 different segments. + * convention : on reaching mEnd, match count continue starting from iStart + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_count_2segments( + byte* ip, + byte* match, + byte* iEnd, + byte* mEnd, + byte* iStart + ) + { + byte* vEnd = ip + (mEnd - match) < iEnd ? ip + (mEnd - match) : iEnd; + nuint matchLength = ZSTD_count(ip, match, vEnd); + if (match + matchLength != mEnd) + return matchLength; + return matchLength + ZSTD_count(ip + matchLength, iStart, iEnd); + } + + private const uint prime3bytes = 506832829U; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_hash3(uint u, uint h, uint s) + { + assert(h <= 32); + return ((u << 32 - 24) * prime3bytes ^ s) >> (int)(32 - h); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash3Ptr(void* ptr, uint h) + { + return ZSTD_hash3(MEM_readLE32(ptr), h, 0); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash3PtrS(void* ptr, uint h, uint s) + { + return ZSTD_hash3(MEM_readLE32(ptr), h, s); + } + + private const uint prime4bytes = 2654435761U; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_hash4(uint u, uint h, uint s) + { + assert(h <= 32); + return (u * prime4bytes ^ s) >> (int)(32 - h); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash4Ptr(void* ptr, uint h) + { + return ZSTD_hash4(MEM_readLE32(ptr), h, 0); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash4PtrS(void* ptr, uint h, uint s) + { + return ZSTD_hash4(MEM_readLE32(ptr), h, s); + } + + private const ulong prime5bytes = 889523592379UL; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash5(ulong u, uint h, ulong s) + { + assert(h <= 64); + return (nuint)(((u << 64 - 40) * prime5bytes ^ s) >> (int)(64 - h)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash5Ptr(void* p, uint h) + { + return ZSTD_hash5(MEM_readLE64(p), h, 0); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash5PtrS(void* p, uint h, ulong s) + { + return ZSTD_hash5(MEM_readLE64(p), h, s); + } + + private const ulong prime6bytes = 227718039650203UL; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash6(ulong u, uint h, ulong s) + { + assert(h <= 64); + return (nuint)(((u << 64 - 48) * prime6bytes ^ s) >> (int)(64 - h)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash6Ptr(void* p, uint h) + { + return ZSTD_hash6(MEM_readLE64(p), h, 0); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash6PtrS(void* p, uint h, ulong s) + { + return ZSTD_hash6(MEM_readLE64(p), h, s); + } + + private const ulong prime7bytes = 58295818150454627UL; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash7(ulong u, uint h, ulong s) + { + assert(h <= 64); + return (nuint)(((u << 64 - 56) * prime7bytes ^ s) >> (int)(64 - h)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash7Ptr(void* p, uint h) + { + return ZSTD_hash7(MEM_readLE64(p), h, 0); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash7PtrS(void* p, uint h, ulong s) + { + return ZSTD_hash7(MEM_readLE64(p), h, s); + } + + private const ulong prime8bytes = 0xCF1BBCDCB7A56463UL; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash8(ulong u, uint h, ulong s) + { + assert(h <= 64); + return (nuint)((u * prime8bytes ^ s) >> (int)(64 - h)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash8Ptr(void* p, uint h) + { + return ZSTD_hash8(MEM_readLE64(p), h, 0); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hash8PtrS(void* p, uint h, ulong s) + { + return ZSTD_hash8(MEM_readLE64(p), h, s); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hashPtr(void* p, uint hBits, uint mls) + { + assert(hBits <= 32); + if (mls == 5) + return ZSTD_hash5Ptr(p, hBits); + if (mls == 6) + return ZSTD_hash6Ptr(p, hBits); + if (mls == 7) + return ZSTD_hash7Ptr(p, hBits); + if (mls == 8) + return ZSTD_hash8Ptr(p, hBits); + return ZSTD_hash4Ptr(p, hBits); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_hashPtrSalted(void* p, uint hBits, uint mls, ulong hashSalt) + { + assert(hBits <= 32); + if (mls == 5) + return ZSTD_hash5PtrS(p, hBits, hashSalt); + if (mls == 6) + return ZSTD_hash6PtrS(p, hBits, hashSalt); + if (mls == 7) + return ZSTD_hash7PtrS(p, hBits, hashSalt); + if (mls == 8) + return ZSTD_hash8PtrS(p, hBits, hashSalt); + return ZSTD_hash4PtrS(p, hBits, (uint)hashSalt); + } + + /** ZSTD_ipow() : + * Return base^exponent. + */ + private static ulong ZSTD_ipow(ulong @base, ulong exponent) + { + ulong power = 1; + while (exponent != 0) + { + if ((exponent & 1) != 0) + power *= @base; + exponent >>= 1; + @base *= @base; + } + + return power; + } + + /** ZSTD_rollingHash_append() : + * Add the buffer to the hash value. + */ + private static ulong ZSTD_rollingHash_append(ulong hash, void* buf, nuint size) + { + byte* istart = (byte*)buf; + nuint pos; + for (pos = 0; pos < size; ++pos) + { + hash *= prime8bytes; + hash += (ulong)(istart[pos] + 10); + } + + return hash; + } + + /** ZSTD_rollingHash_compute() : + * Compute the rolling hash value of the buffer. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ulong ZSTD_rollingHash_compute(void* buf, nuint size) + { + return ZSTD_rollingHash_append(0, buf, size); + } + + /** ZSTD_rollingHash_primePower() : + * Compute the primePower to be passed to ZSTD_rollingHash_rotate() for a hash + * over a window of length bytes. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ulong ZSTD_rollingHash_primePower(uint length) + { + return ZSTD_ipow(prime8bytes, length - 1); + } + + /** ZSTD_rollingHash_rotate() : + * Rotate the rolling hash by one byte. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ulong ZSTD_rollingHash_rotate( + ulong hash, + byte toRemove, + byte toAdd, + ulong primePower + ) + { + hash -= (ulong)(toRemove + 10) * primePower; + hash *= prime8bytes; + hash += (ulong)(toAdd + 10); + return hash; + } + + /** + * ZSTD_window_clear(): + * Clears the window containing the history by simply setting it to empty. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_window_clear(ZSTD_window_t* window) + { + nuint endT = (nuint)(window->nextSrc - window->@base); + uint end = (uint)endT; + window->lowLimit = end; + window->dictLimit = end; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_window_isEmpty(ZSTD_window_t window) + { + return window.dictLimit == 2 && window.lowLimit == 2 && window.nextSrc - window.@base == 2 + ? 1U + : 0U; + } + + /** + * ZSTD_window_hasExtDict(): + * Returns non-zero if the window has a non-empty extDict. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_window_hasExtDict(ZSTD_window_t window) + { + return window.lowLimit < window.dictLimit ? 1U : 0U; + } + + /** + * ZSTD_matchState_dictMode(): + * Inspects the provided matchState and figures out what dictMode should be + * passed to the compressor. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ZSTD_dictMode_e ZSTD_matchState_dictMode(ZSTD_MatchState_t* ms) + { + return ZSTD_window_hasExtDict(ms->window) != 0 ? ZSTD_dictMode_e.ZSTD_extDict + : ms->dictMatchState != null + ? ms->dictMatchState->dedicatedDictSearch != 0 + ? ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + : ZSTD_dictMode_e.ZSTD_dictMatchState + : ZSTD_dictMode_e.ZSTD_noDict; + } + + /** + * ZSTD_window_canOverflowCorrect(): + * Returns non-zero if the indices are large enough for overflow correction + * to work correctly without impacting compression ratio. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_window_canOverflowCorrect( + ZSTD_window_t window, + uint cycleLog, + uint maxDist, + uint loadedDictEnd, + void* src + ) + { + uint cycleSize = 1U << (int)cycleLog; + uint curr = (uint)((byte*)src - window.@base); + uint minIndexToOverflowCorrect = + cycleSize + (maxDist > cycleSize ? maxDist : cycleSize) + 2; + /* Adjust the min index to backoff the overflow correction frequency, + * so we don't waste too much CPU in overflow correction. If this + * computation overflows we don't really care, we just need to make + * sure it is at least minIndexToOverflowCorrect. + */ + uint adjustment = window.nbOverflowCorrections + 1; + uint adjustedIndex = + minIndexToOverflowCorrect * adjustment > minIndexToOverflowCorrect + ? minIndexToOverflowCorrect * adjustment + : minIndexToOverflowCorrect; + uint indexLargeEnough = curr > adjustedIndex ? 1U : 0U; + /* Only overflow correct early if the dictionary is invalidated already, + * so we don't hurt compression ratio. + */ + uint dictionaryInvalidated = curr > maxDist + loadedDictEnd ? 1U : 0U; + return indexLargeEnough != 0 && dictionaryInvalidated != 0 ? 1U : 0U; + } + + /** + * ZSTD_window_needOverflowCorrection(): + * Returns non-zero if the indices are getting too large and need overflow + * protection. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_window_needOverflowCorrection( + ZSTD_window_t window, + uint cycleLog, + uint maxDist, + uint loadedDictEnd, + void* src, + void* srcEnd + ) + { + uint curr = (uint)((byte*)srcEnd - window.@base); + return curr > (MEM_64bits ? 3500U * (1 << 20) : 2000U * (1 << 20)) ? 1U : 0U; + } + + /** + * ZSTD_window_correctOverflow(): + * Reduces the indices to protect from index overflow. + * Returns the correction made to the indices, which must be applied to every + * stored index. + * + * The least significant cycleLog bits of the indices must remain the same, + * which may be 0. Every index up to maxDist in the past must be valid. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_window_correctOverflow( + ZSTD_window_t* window, + uint cycleLog, + uint maxDist, + void* src + ) + { + /* preemptive overflow correction: + * 1. correction is large enough: + * lowLimit > (3<<29) ==> current > 3<<29 + 1< (3<<29 + 1< (3<<29) - (1< (3<<29) - (1<<30) (NOTE: chainLog <= 30) + * > 1<<29 + * + * 2. (ip+ZSTD_CHUNKSIZE_MAX - cctx->base) doesn't overflow: + * After correction, current is less than (1<base < 1<<32. + * 3. (cctx->lowLimit + 1< 3<<29 + 1<@base); + uint currentCycle = curr & cycleMask; + /* Ensure newCurrent - maxDist >= ZSTD_WINDOW_START_INDEX. */ + uint currentCycleCorrection = + currentCycle < 2 + ? cycleSize > 2 + ? cycleSize + : 2 + : 0; + uint newCurrent = + currentCycle + currentCycleCorrection + (maxDist > cycleSize ? maxDist : cycleSize); + uint correction = curr - newCurrent; + assert((maxDist & maxDist - 1) == 0); + assert((curr & cycleMask) == (newCurrent & cycleMask)); + assert(curr > newCurrent); + { + assert(correction > 1 << 28); + } + + window->@base += correction; + window->dictBase += correction; + if (window->lowLimit < correction + 2) + { + window->lowLimit = 2; + } + else + { + window->lowLimit -= correction; + } + + if (window->dictLimit < correction + 2) + { + window->dictLimit = 2; + } + else + { + window->dictLimit -= correction; + } + + assert(newCurrent >= maxDist); + assert(newCurrent - maxDist >= 2); + assert(window->lowLimit <= newCurrent); + assert(window->dictLimit <= newCurrent); + ++window->nbOverflowCorrections; + return correction; + } + + /** + * ZSTD_window_enforceMaxDist(): + * Updates lowLimit so that: + * (srcEnd - base) - lowLimit == maxDist + loadedDictEnd + * + * It ensures index is valid as long as index >= lowLimit. + * This must be called before a block compression call. + * + * loadedDictEnd is only defined if a dictionary is in use for current compression. + * As the name implies, loadedDictEnd represents the index at end of dictionary. + * The value lies within context's referential, it can be directly compared to blockEndIdx. + * + * If loadedDictEndPtr is NULL, no dictionary is in use, and we use loadedDictEnd == 0. + * If loadedDictEndPtr is not NULL, we set it to zero after updating lowLimit. + * This is because dictionaries are allowed to be referenced fully + * as long as the last byte of the dictionary is in the window. + * Once input has progressed beyond window size, dictionary cannot be referenced anymore. + * + * In normal dict mode, the dictionary lies between lowLimit and dictLimit. + * In dictMatchState mode, lowLimit and dictLimit are the same, + * and the dictionary is below them. + * forceWindow and dictMatchState are therefore incompatible. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_window_enforceMaxDist( + ZSTD_window_t* window, + void* blockEnd, + uint maxDist, + uint* loadedDictEndPtr, + ZSTD_MatchState_t** dictMatchStatePtr + ) + { + uint blockEndIdx = (uint)((byte*)blockEnd - window->@base); + uint loadedDictEnd = loadedDictEndPtr != null ? *loadedDictEndPtr : 0; + if (blockEndIdx > maxDist + loadedDictEnd) + { + uint newLowLimit = blockEndIdx - maxDist; + if (window->lowLimit < newLowLimit) + window->lowLimit = newLowLimit; + if (window->dictLimit < window->lowLimit) + { + window->dictLimit = window->lowLimit; + } + + if (loadedDictEndPtr != null) + *loadedDictEndPtr = 0; + if (dictMatchStatePtr != null) + *dictMatchStatePtr = null; + } + } + + /* Similar to ZSTD_window_enforceMaxDist(), + * but only invalidates dictionary + * when input progresses beyond window size. + * assumption : loadedDictEndPtr and dictMatchStatePtr are valid (non NULL) + * loadedDictEnd uses same referential as window->base + * maxDist is the window size */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_checkDictValidity( + ZSTD_window_t* window, + void* blockEnd, + uint maxDist, + uint* loadedDictEndPtr, + ZSTD_MatchState_t** dictMatchStatePtr + ) + { + assert(loadedDictEndPtr != null); + assert(dictMatchStatePtr != null); + { + uint blockEndIdx = (uint)((byte*)blockEnd - window->@base); + uint loadedDictEnd = *loadedDictEndPtr; + assert(blockEndIdx >= loadedDictEnd); + if (blockEndIdx > loadedDictEnd + maxDist || loadedDictEnd != window->dictLimit) + { + *loadedDictEndPtr = 0; + *dictMatchStatePtr = null; + } + } + } + +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_stringToByte_20_00 => new byte[] { 32, 0 }; + private static byte* stringToByte_20_00 => + (byte*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_stringToByte_20_00) + ); +#else + + private static readonly byte* stringToByte_20_00 = GetArrayPointer(new byte[] { 32, 0 }); +#endif + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_window_init(ZSTD_window_t* window) + { + *window = new ZSTD_window_t + { + @base = stringToByte_20_00, + dictBase = stringToByte_20_00, + dictLimit = 2, + lowLimit = 2, + nextSrc = stringToByte_20_00 + 2, + nbOverflowCorrections = 0, + }; + } + + /** + * ZSTD_window_update(): + * Updates the window by appending [src, src + srcSize) to the window. + * If it is not contiguous, the current prefix becomes the extDict, and we + * forget about the extDict. Handles overlap of the prefix and extDict. + * Returns non-zero if the segment is contiguous. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_window_update( + ZSTD_window_t* window, + void* src, + nuint srcSize, + int forceNonContiguous + ) + { + byte* ip = (byte*)src; + uint contiguous = 1; + if (srcSize == 0) + return contiguous; + assert(window->@base != null); + assert(window->dictBase != null); + if (src != window->nextSrc || forceNonContiguous != 0) + { + /* not contiguous */ + nuint distanceFromBase = (nuint)(window->nextSrc - window->@base); + window->lowLimit = window->dictLimit; + assert(distanceFromBase == (uint)distanceFromBase); + window->dictLimit = (uint)distanceFromBase; + window->dictBase = window->@base; + window->@base = ip - distanceFromBase; + if (window->dictLimit - window->lowLimit < 8) + window->lowLimit = window->dictLimit; + contiguous = 0; + } + + window->nextSrc = ip + srcSize; + if ( + ip + srcSize > window->dictBase + window->lowLimit + && ip < window->dictBase + window->dictLimit + ) + { + nuint highInputIdx = (nuint)(ip + srcSize - window->dictBase); + uint lowLimitMax = + highInputIdx > window->dictLimit ? window->dictLimit : (uint)highInputIdx; + assert(highInputIdx < 0xffffffff); + window->lowLimit = lowLimitMax; + } + + return contiguous; + } + + /** + * Returns the lowest allowed match index. It may either be in the ext-dict or the prefix. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_getLowestMatchIndex(ZSTD_MatchState_t* ms, uint curr, uint windowLog) + { + uint maxDistance = 1U << (int)windowLog; + uint lowestValid = ms->window.lowLimit; + uint withinWindow = curr - lowestValid > maxDistance ? curr - maxDistance : lowestValid; + uint isDictionary = ms->loadedDictEnd != 0 ? 1U : 0U; + /* When using a dictionary the entire dictionary is valid if a single byte of the dictionary + * is within the window. We invalidate the dictionary (and set loadedDictEnd to 0) when it isn't + * valid for the entire block. So this check is sufficient to find the lowest valid match index. + */ + uint matchLowest = isDictionary != 0 ? lowestValid : withinWindow; + return matchLowest; + } + + /** + * Returns the lowest allowed match index in the prefix. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_getLowestPrefixIndex(ZSTD_MatchState_t* ms, uint curr, uint windowLog) + { + uint maxDistance = 1U << (int)windowLog; + uint lowestValid = ms->window.dictLimit; + uint withinWindow = curr - lowestValid > maxDistance ? curr - maxDistance : lowestValid; + uint isDictionary = ms->loadedDictEnd != 0 ? 1U : 0U; + /* When computing the lowest prefix index we need to take the dictionary into account to handle + * the edge case where the dictionary and the source are contiguous in memory. + */ + uint matchLowest = isDictionary != 0 ? lowestValid : withinWindow; + return matchLowest; + } + + /* index_safety_check: + * intentional underflow : ensure repIndex isn't overlapping dict + prefix + * @return 1 if values are not overlapping, + * 0 otherwise */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_index_overlap_check(uint prefixLowestIndex, uint repIndex) + { + return prefixLowestIndex - 1 - repIndex >= 3 ? 1 : 0; + } + + /* Helper function for ZSTD_fillHashTable and ZSTD_fillDoubleHashTable. + * Unpacks hashAndTag into (hash, tag), then packs (index, tag) into hashTable[hash]. */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_writeTaggedIndex(uint* hashTable, nuint hashAndTag, uint index) + { + nuint hash = hashAndTag >> 8; + uint tag = (uint)(hashAndTag & (1U << 8) - 1); + assert(index >> 32 - 8 == 0); + hashTable[hash] = index << 8 | tag; + } + + /* Helper function for short cache matchfinders. + * Unpacks tag1 and tag2 from lower bits of packedTag1 and packedTag2, then checks if the tags match. */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_comparePackedTags(nuint packedTag1, nuint packedTag2) + { + uint tag1 = (uint)(packedTag1 & (1U << 8) - 1); + uint tag2 = (uint)(packedTag2 & (1U << 8) - 1); + return tag1 == tag2 ? 1 : 0; + } + + /* Returns 1 if an external sequence producer is registered, otherwise returns 0. */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_hasExtSeqProd(ZSTD_CCtx_params_s* @params) + { + return @params->extSeqProdFunc != null ? 1 : 0; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressLiterals.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressLiterals.cs new file mode 100644 index 000000000..a4f92ab35 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressLiterals.cs @@ -0,0 +1,314 @@ +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /* ************************************************************** + * Literals compression - special cases + ****************************************************************/ + private static nuint ZSTD_noCompressLiterals( + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize + ) + { + byte* ostart = (byte*)dst; + uint flSize = (uint)(1 + (srcSize > 31 ? 1 : 0) + (srcSize > 4095 ? 1 : 0)); + if (srcSize + flSize > dstCapacity) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + switch (flSize) + { + case 1: + ostart[0] = (byte)((uint)SymbolEncodingType_e.set_basic + (srcSize << 3)); + break; + case 2: + MEM_writeLE16( + ostart, + (ushort)((uint)SymbolEncodingType_e.set_basic + (1 << 2) + (srcSize << 4)) + ); + break; + case 3: + MEM_writeLE32( + ostart, + (uint)((uint)SymbolEncodingType_e.set_basic + (3 << 2) + (srcSize << 4)) + ); + break; + default: + assert(0 != 0); + break; + } + + memcpy(ostart + flSize, src, (uint)srcSize); + return srcSize + flSize; + } + + private static int allBytesIdentical(void* src, nuint srcSize) + { + assert(srcSize >= 1); + assert(src != null); + { + byte b = ((byte*)src)[0]; + nuint p; + for (p = 1; p < srcSize; p++) + { + if (((byte*)src)[p] != b) + return 0; + } + + return 1; + } + } + + /* ZSTD_compressRleLiteralsBlock() : + * Conditions : + * - All bytes in @src are identical + * - dstCapacity >= 4 */ + private static nuint ZSTD_compressRleLiteralsBlock( + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize + ) + { + byte* ostart = (byte*)dst; + uint flSize = (uint)(1 + (srcSize > 31 ? 1 : 0) + (srcSize > 4095 ? 1 : 0)); + assert(dstCapacity >= 4); + assert(allBytesIdentical(src, srcSize) != 0); + switch (flSize) + { + case 1: + ostart[0] = (byte)((uint)SymbolEncodingType_e.set_rle + (srcSize << 3)); + break; + case 2: + MEM_writeLE16( + ostart, + (ushort)((uint)SymbolEncodingType_e.set_rle + (1 << 2) + (srcSize << 4)) + ); + break; + case 3: + MEM_writeLE32( + ostart, + (uint)((uint)SymbolEncodingType_e.set_rle + (3 << 2) + (srcSize << 4)) + ); + break; + default: + assert(0 != 0); + break; + } + + ostart[flSize] = *(byte*)src; + return flSize + 1; + } + + /* ZSTD_minLiteralsToCompress() : + * returns minimal amount of literals + * for literal compression to even be attempted. + * Minimum is made tighter as compression strategy increases. + */ + private static nuint ZSTD_minLiteralsToCompress(ZSTD_strategy strategy, HUF_repeat huf_repeat) + { + assert((int)strategy >= 0); + assert((int)strategy <= 9); + { + int shift = 9 - (int)strategy < 3 ? 9 - (int)strategy : 3; + nuint mintc = huf_repeat == HUF_repeat.HUF_repeat_valid ? 6 : (nuint)8 << shift; + return mintc; + } + } + + /* ZSTD_compressLiterals(): + * @entropyWorkspace: must be aligned on 4-bytes boundaries + * @entropyWorkspaceSize : must be >= HUF_WORKSPACE_SIZE + * @suspectUncompressible: sampling checks, to potentially skip huffman coding + */ + private static nuint ZSTD_compressLiterals( + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + void* entropyWorkspace, + nuint entropyWorkspaceSize, + ZSTD_hufCTables_t* prevHuf, + ZSTD_hufCTables_t* nextHuf, + ZSTD_strategy strategy, + int disableLiteralCompression, + int suspectUncompressible, + int bmi2 + ) + { + nuint lhSize = (nuint)( + 3 + (srcSize >= 1 * (1 << 10) ? 1 : 0) + (srcSize >= 16 * (1 << 10) ? 1 : 0) + ); + byte* ostart = (byte*)dst; + uint singleStream = srcSize < 256 ? 1U : 0U; + SymbolEncodingType_e hType = SymbolEncodingType_e.set_compressed; + nuint cLitSize; + memcpy(nextHuf, prevHuf, (uint)sizeof(ZSTD_hufCTables_t)); + if (disableLiteralCompression != 0) + return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize); + if (srcSize < ZSTD_minLiteralsToCompress(strategy, prevHuf->repeatMode)) + return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize); + if (dstCapacity < lhSize + 1) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + { + HUF_repeat repeat = prevHuf->repeatMode; + int flags = + 0 + | (bmi2 != 0 ? (int)HUF_flags_e.HUF_flags_bmi2 : 0) + | ( + strategy < ZSTD_strategy.ZSTD_lazy && srcSize <= 1024 + ? (int)HUF_flags_e.HUF_flags_preferRepeat + : 0 + ) + | ( + strategy >= ZSTD_strategy.ZSTD_btultra + ? (int)HUF_flags_e.HUF_flags_optimalDepth + : 0 + ) + | ( + suspectUncompressible != 0 + ? (int)HUF_flags_e.HUF_flags_suspectUncompressible + : 0 + ); + void* huf_compress; + if (repeat == HUF_repeat.HUF_repeat_valid && lhSize == 3) + singleStream = 1; + huf_compress = + singleStream != 0 + ? (delegate* managed< + void*, + nuint, + void*, + nuint, + uint, + uint, + void*, + nuint, + nuint*, + HUF_repeat*, + int, + nuint>)(&HUF_compress1X_repeat) + : (delegate* managed< + void*, + nuint, + void*, + nuint, + uint, + uint, + void*, + nuint, + nuint*, + HUF_repeat*, + int, + nuint>)(&HUF_compress4X_repeat); + cLitSize = ( + (delegate* managed< + void*, + nuint, + void*, + nuint, + uint, + uint, + void*, + nuint, + nuint*, + HUF_repeat*, + int, + nuint>)huf_compress + )( + ostart + lhSize, + dstCapacity - lhSize, + src, + srcSize, + 255, + 11, + entropyWorkspace, + entropyWorkspaceSize, + &nextHuf->CTable.e0, + &repeat, + flags + ); + if (repeat != HUF_repeat.HUF_repeat_none) + { + hType = SymbolEncodingType_e.set_repeat; + } + } + + { + nuint minGain = ZSTD_minGain(srcSize, strategy); + if (cLitSize == 0 || cLitSize >= srcSize - minGain || ERR_isError(cLitSize)) + { + memcpy(nextHuf, prevHuf, (uint)sizeof(ZSTD_hufCTables_t)); + return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize); + } + } + + if (cLitSize == 1) + { + if (srcSize >= 8 || allBytesIdentical(src, srcSize) != 0) + { + memcpy(nextHuf, prevHuf, (uint)sizeof(ZSTD_hufCTables_t)); + return ZSTD_compressRleLiteralsBlock(dst, dstCapacity, src, srcSize); + } + } + + if (hType == SymbolEncodingType_e.set_compressed) + { + nextHuf->repeatMode = HUF_repeat.HUF_repeat_check; + } + + switch (lhSize) + { + case 3: +#if DEBUG + if (singleStream == 0) + assert(srcSize >= 6); + +#endif + { + uint lhc = + (uint)hType + + ((singleStream == 0 ? 1U : 0U) << 2) + + ((uint)srcSize << 4) + + ((uint)cLitSize << 14); + MEM_writeLE24(ostart, lhc); + break; + } + + case 4: + assert(srcSize >= 6); + + { + uint lhc = + (uint)(hType + (2 << 2)) + ((uint)srcSize << 4) + ((uint)cLitSize << 18); + MEM_writeLE32(ostart, lhc); + break; + } + + case 5: + assert(srcSize >= 6); + + { + uint lhc = + (uint)(hType + (3 << 2)) + ((uint)srcSize << 4) + ((uint)cLitSize << 22); + MEM_writeLE32(ostart, lhc); + ostart[4] = (byte)(cLitSize >> 10); + break; + } + + default: + assert(0 != 0); + break; + } + + return lhSize + cLitSize; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressSequences.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressSequences.cs new file mode 100644 index 000000000..e0fd5eee0 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressSequences.cs @@ -0,0 +1,1211 @@ +using System; +using System.Runtime.InteropServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_kInverseProbabilityLog256 => + new uint[256] + { + 0, + 2048, + 1792, + 1642, + 1536, + 1453, + 1386, + 1329, + 1280, + 1236, + 1197, + 1162, + 1130, + 1100, + 1073, + 1047, + 1024, + 1001, + 980, + 960, + 941, + 923, + 906, + 889, + 874, + 859, + 844, + 830, + 817, + 804, + 791, + 779, + 768, + 756, + 745, + 734, + 724, + 714, + 704, + 694, + 685, + 676, + 667, + 658, + 650, + 642, + 633, + 626, + 618, + 610, + 603, + 595, + 588, + 581, + 574, + 567, + 561, + 554, + 548, + 542, + 535, + 529, + 523, + 517, + 512, + 506, + 500, + 495, + 489, + 484, + 478, + 473, + 468, + 463, + 458, + 453, + 448, + 443, + 438, + 434, + 429, + 424, + 420, + 415, + 411, + 407, + 402, + 398, + 394, + 390, + 386, + 382, + 377, + 373, + 370, + 366, + 362, + 358, + 354, + 350, + 347, + 343, + 339, + 336, + 332, + 329, + 325, + 322, + 318, + 315, + 311, + 308, + 305, + 302, + 298, + 295, + 292, + 289, + 286, + 282, + 279, + 276, + 273, + 270, + 267, + 264, + 261, + 258, + 256, + 253, + 250, + 247, + 244, + 241, + 239, + 236, + 233, + 230, + 228, + 225, + 222, + 220, + 217, + 215, + 212, + 209, + 207, + 204, + 202, + 199, + 197, + 194, + 192, + 190, + 187, + 185, + 182, + 180, + 178, + 175, + 173, + 171, + 168, + 166, + 164, + 162, + 159, + 157, + 155, + 153, + 151, + 149, + 146, + 144, + 142, + 140, + 138, + 136, + 134, + 132, + 130, + 128, + 126, + 123, + 121, + 119, + 117, + 115, + 114, + 112, + 110, + 108, + 106, + 104, + 102, + 100, + 98, + 96, + 94, + 93, + 91, + 89, + 87, + 85, + 83, + 82, + 80, + 78, + 76, + 74, + 73, + 71, + 69, + 67, + 66, + 64, + 62, + 61, + 59, + 57, + 55, + 54, + 52, + 50, + 49, + 47, + 46, + 44, + 42, + 41, + 39, + 37, + 36, + 34, + 33, + 31, + 30, + 28, + 26, + 25, + 23, + 22, + 20, + 19, + 17, + 16, + 14, + 13, + 11, + 10, + 8, + 7, + 5, + 4, + 2, + 1, + }; + private static uint* kInverseProbabilityLog256 => + (uint*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_kInverseProbabilityLog256) + ); +#else + + private static readonly uint* kInverseProbabilityLog256 = GetArrayPointer( + new uint[256] + { + 0, + 2048, + 1792, + 1642, + 1536, + 1453, + 1386, + 1329, + 1280, + 1236, + 1197, + 1162, + 1130, + 1100, + 1073, + 1047, + 1024, + 1001, + 980, + 960, + 941, + 923, + 906, + 889, + 874, + 859, + 844, + 830, + 817, + 804, + 791, + 779, + 768, + 756, + 745, + 734, + 724, + 714, + 704, + 694, + 685, + 676, + 667, + 658, + 650, + 642, + 633, + 626, + 618, + 610, + 603, + 595, + 588, + 581, + 574, + 567, + 561, + 554, + 548, + 542, + 535, + 529, + 523, + 517, + 512, + 506, + 500, + 495, + 489, + 484, + 478, + 473, + 468, + 463, + 458, + 453, + 448, + 443, + 438, + 434, + 429, + 424, + 420, + 415, + 411, + 407, + 402, + 398, + 394, + 390, + 386, + 382, + 377, + 373, + 370, + 366, + 362, + 358, + 354, + 350, + 347, + 343, + 339, + 336, + 332, + 329, + 325, + 322, + 318, + 315, + 311, + 308, + 305, + 302, + 298, + 295, + 292, + 289, + 286, + 282, + 279, + 276, + 273, + 270, + 267, + 264, + 261, + 258, + 256, + 253, + 250, + 247, + 244, + 241, + 239, + 236, + 233, + 230, + 228, + 225, + 222, + 220, + 217, + 215, + 212, + 209, + 207, + 204, + 202, + 199, + 197, + 194, + 192, + 190, + 187, + 185, + 182, + 180, + 178, + 175, + 173, + 171, + 168, + 166, + 164, + 162, + 159, + 157, + 155, + 153, + 151, + 149, + 146, + 144, + 142, + 140, + 138, + 136, + 134, + 132, + 130, + 128, + 126, + 123, + 121, + 119, + 117, + 115, + 114, + 112, + 110, + 108, + 106, + 104, + 102, + 100, + 98, + 96, + 94, + 93, + 91, + 89, + 87, + 85, + 83, + 82, + 80, + 78, + 76, + 74, + 73, + 71, + 69, + 67, + 66, + 64, + 62, + 61, + 59, + 57, + 55, + 54, + 52, + 50, + 49, + 47, + 46, + 44, + 42, + 41, + 39, + 37, + 36, + 34, + 33, + 31, + 30, + 28, + 26, + 25, + 23, + 22, + 20, + 19, + 17, + 16, + 14, + 13, + 11, + 10, + 8, + 7, + 5, + 4, + 2, + 1, + } + ); +#endif + + private static uint ZSTD_getFSEMaxSymbolValue(uint* ctable) + { + void* ptr = ctable; + ushort* u16ptr = (ushort*)ptr; + uint maxSymbolValue = MEM_read16(u16ptr + 1); + return maxSymbolValue; + } + + /** + * Returns true if we should use ncount=-1 else we should + * use ncount=1 for low probability symbols instead. + */ + private static uint ZSTD_useLowProbCount(nuint nbSeq) + { + return nbSeq >= 2048 ? 1U : 0U; + } + + /** + * Returns the cost in bytes of encoding the normalized count header. + * Returns an error if any of the helper functions return an error. + */ + private static nuint ZSTD_NCountCost(uint* count, uint max, nuint nbSeq, uint FSELog) + { + byte* wksp = stackalloc byte[512]; + short* norm = stackalloc short[53]; + uint tableLog = FSE_optimalTableLog(FSELog, nbSeq, max); + { + nuint err_code = FSE_normalizeCount( + norm, + tableLog, + count, + nbSeq, + max, + ZSTD_useLowProbCount(nbSeq) + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return FSE_writeNCount(wksp, sizeof(byte) * 512, norm, max, tableLog); + } + + /** + * Returns the cost in bits of encoding the distribution described by count + * using the entropy bound. + */ + private static nuint ZSTD_entropyCost(uint* count, uint max, nuint total) + { + uint cost = 0; + uint s; + assert(total > 0); + for (s = 0; s <= max; ++s) + { + uint norm = (uint)(256 * count[s] / total); + if (count[s] != 0 && norm == 0) + norm = 1; + assert(count[s] < total); + cost += count[s] * kInverseProbabilityLog256[norm]; + } + + return cost >> 8; + } + + /** + * Returns the cost in bits of encoding the distribution in count using ctable. + * Returns an error if ctable cannot represent all the symbols in count. + */ + private static nuint ZSTD_fseBitCost(uint* ctable, uint* count, uint max) + { + const uint kAccuracyLog = 8; + nuint cost = 0; + uint s; + FSE_CState_t cstate; + FSE_initCState(&cstate, ctable); + if (ZSTD_getFSEMaxSymbolValue(ctable) < max) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + + for (s = 0; s <= max; ++s) + { + uint tableLog = cstate.stateLog; + uint badCost = tableLog + 1 << (int)kAccuracyLog; + uint bitCost = FSE_bitCost(cstate.symbolTT, tableLog, s, kAccuracyLog); + if (count[s] == 0) + continue; + if (bitCost >= badCost) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + + cost += (nuint)count[s] * bitCost; + } + + return cost >> (int)kAccuracyLog; + } + + /** + * Returns the cost in bits of encoding the distribution in count using the + * table described by norm. The max symbol support by norm is assumed >= max. + * norm must be valid for every symbol with non-zero probability in count. + */ + private static nuint ZSTD_crossEntropyCost(short* norm, uint accuracyLog, uint* count, uint max) + { + uint shift = 8 - accuracyLog; + nuint cost = 0; + uint s; + assert(accuracyLog <= 8); + for (s = 0; s <= max; ++s) + { + uint normAcc = norm[s] != -1 ? (uint)norm[s] : 1; + uint norm256 = normAcc << (int)shift; + assert(norm256 > 0); + assert(norm256 < 256); + cost += count[s] * kInverseProbabilityLog256[norm256]; + } + + return cost >> 8; + } + + private static SymbolEncodingType_e ZSTD_selectEncodingType( + FSE_repeat* repeatMode, + uint* count, + uint max, + nuint mostFrequent, + nuint nbSeq, + uint FSELog, + uint* prevCTable, + short* defaultNorm, + uint defaultNormLog, + ZSTD_DefaultPolicy_e isDefaultAllowed, + ZSTD_strategy strategy + ) + { + if (mostFrequent == nbSeq) + { + *repeatMode = FSE_repeat.FSE_repeat_none; + if (isDefaultAllowed != default && nbSeq <= 2) + { + return SymbolEncodingType_e.set_basic; + } + + return SymbolEncodingType_e.set_rle; + } + + if (strategy < ZSTD_strategy.ZSTD_lazy) + { + if (isDefaultAllowed != default) + { + const nuint staticFse_nbSeq_max = 1000; + nuint mult = (nuint)(10 - strategy); + const nuint baseLog = 3; + /* 28-36 for offset, 56-72 for lengths */ + nuint dynamicFse_nbSeq_min = + ((nuint)1 << (int)defaultNormLog) * mult >> (int)baseLog; + assert(defaultNormLog >= 5 && defaultNormLog <= 6); + assert(mult <= 9 && mult >= 7); + if (*repeatMode == FSE_repeat.FSE_repeat_valid && nbSeq < staticFse_nbSeq_max) + { + return SymbolEncodingType_e.set_repeat; + } + + if ( + nbSeq < dynamicFse_nbSeq_min + || mostFrequent < nbSeq >> (int)(defaultNormLog - 1) + ) + { + *repeatMode = FSE_repeat.FSE_repeat_none; + return SymbolEncodingType_e.set_basic; + } + } + } + else + { + nuint basicCost = + isDefaultAllowed != default + ? ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, count, max) + : unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + nuint repeatCost = + *repeatMode != FSE_repeat.FSE_repeat_none + ? ZSTD_fseBitCost(prevCTable, count, max) + : unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + nuint NCountCost = ZSTD_NCountCost(count, max, nbSeq, FSELog); + nuint compressedCost = (NCountCost << 3) + ZSTD_entropyCost(count, max, nbSeq); +#if DEBUG + if (isDefaultAllowed != default) + { + assert(!ERR_isError(basicCost)); + assert(!(*repeatMode == FSE_repeat.FSE_repeat_valid && ERR_isError(repeatCost))); + } +#endif + + assert(!ERR_isError(NCountCost)); + assert(compressedCost < unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_maxCode))); + if (basicCost <= repeatCost && basicCost <= compressedCost) + { + assert(isDefaultAllowed != default); + *repeatMode = FSE_repeat.FSE_repeat_none; + return SymbolEncodingType_e.set_basic; + } + + if (repeatCost <= compressedCost) + { + assert(!ERR_isError(repeatCost)); + return SymbolEncodingType_e.set_repeat; + } + + assert(compressedCost < basicCost && compressedCost < repeatCost); + } + + *repeatMode = FSE_repeat.FSE_repeat_check; + return SymbolEncodingType_e.set_compressed; + } + + private static nuint ZSTD_buildCTable( + void* dst, + nuint dstCapacity, + uint* nextCTable, + uint FSELog, + SymbolEncodingType_e type, + uint* count, + uint max, + byte* codeTable, + nuint nbSeq, + short* defaultNorm, + uint defaultNormLog, + uint defaultMax, + uint* prevCTable, + nuint prevCTableSize, + void* entropyWorkspace, + nuint entropyWorkspaceSize + ) + { + byte* op = (byte*)dst; + byte* oend = op + dstCapacity; + switch (type) + { + case SymbolEncodingType_e.set_rle: + { + nuint err_code = FSE_buildCTable_rle(nextCTable, (byte)max); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (dstCapacity == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + *op = codeTable[0]; + return 1; + case SymbolEncodingType_e.set_repeat: + memcpy(nextCTable, prevCTable, (uint)prevCTableSize); + return 0; + case SymbolEncodingType_e.set_basic: + { + /* note : could be pre-calculated */ + nuint err_code = FSE_buildCTable_wksp( + nextCTable, + defaultNorm, + defaultMax, + defaultNormLog, + entropyWorkspace, + entropyWorkspaceSize + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + case SymbolEncodingType_e.set_compressed: + { + ZSTD_BuildCTableWksp* wksp = (ZSTD_BuildCTableWksp*)entropyWorkspace; + nuint nbSeq_1 = nbSeq; + uint tableLog = FSE_optimalTableLog(FSELog, nbSeq, max); + if (count[codeTable[nbSeq - 1]] > 1) + { + count[codeTable[nbSeq - 1]]--; + nbSeq_1--; + } + + assert(nbSeq_1 > 1); + assert(entropyWorkspaceSize >= (nuint)sizeof(ZSTD_BuildCTableWksp)); + { + nuint err_code = FSE_normalizeCount( + wksp->norm, + tableLog, + count, + nbSeq_1, + max, + ZSTD_useLowProbCount(nbSeq_1) + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(oend >= op); + { + /* overflow protected */ + nuint NCountSize = FSE_writeNCount( + op, + (nuint)(oend - op), + wksp->norm, + max, + tableLog + ); + { + nuint err_code = NCountSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = FSE_buildCTable_wksp( + nextCTable, + wksp->norm, + max, + tableLog, + wksp->wksp, + sizeof(uint) * 285 + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return NCountSize; + } + } + + default: + assert(0 != 0); + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + } + + private static nuint ZSTD_encodeSequences_body( + void* dst, + nuint dstCapacity, + uint* CTable_MatchLength, + byte* mlCodeTable, + uint* CTable_OffsetBits, + byte* ofCodeTable, + uint* CTable_LitLength, + byte* llCodeTable, + SeqDef_s* sequences, + nuint nbSeq, + int longOffsets + ) + { + BIT_CStream_t blockStream; + System.Runtime.CompilerServices.Unsafe.SkipInit(out blockStream); + FSE_CState_t stateMatchLength; + System.Runtime.CompilerServices.Unsafe.SkipInit(out stateMatchLength); + FSE_CState_t stateOffsetBits; + System.Runtime.CompilerServices.Unsafe.SkipInit(out stateOffsetBits); + FSE_CState_t stateLitLength; + System.Runtime.CompilerServices.Unsafe.SkipInit(out stateLitLength); + if (ERR_isError(BIT_initCStream(ref blockStream, dst, dstCapacity))) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + nuint blockStream_bitContainer = blockStream.bitContainer; + uint blockStream_bitPos = blockStream.bitPos; + sbyte* blockStream_ptr = blockStream.ptr; + sbyte* blockStream_endPtr = blockStream.endPtr; + FSE_initCState2(ref stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq - 1]); + FSE_initCState2(ref stateOffsetBits, CTable_OffsetBits, ofCodeTable[nbSeq - 1]); + FSE_initCState2(ref stateLitLength, CTable_LitLength, llCodeTable[nbSeq - 1]); + BIT_addBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + sequences[nbSeq - 1].litLength, + LL_bits[llCodeTable[nbSeq - 1]] + ); + if (MEM_32bits) + BIT_flushBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref blockStream_ptr, + blockStream_endPtr + ); + BIT_addBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + sequences[nbSeq - 1].mlBase, + ML_bits[mlCodeTable[nbSeq - 1]] + ); + if (MEM_32bits) + BIT_flushBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref blockStream_ptr, + blockStream_endPtr + ); + if (longOffsets != 0) + { + uint ofBits = ofCodeTable[nbSeq - 1]; + uint extraBits = + ofBits + - ( + ofBits < (uint)(MEM_32bits ? 25 : 57) - 1 + ? ofBits + : (uint)(MEM_32bits ? 25 : 57) - 1 + ); + if (extraBits != 0) + { + BIT_addBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + sequences[nbSeq - 1].offBase, + extraBits + ); + BIT_flushBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref blockStream_ptr, + blockStream_endPtr + ); + } + + BIT_addBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + sequences[nbSeq - 1].offBase >> (int)extraBits, + ofBits - extraBits + ); + } + else + { + BIT_addBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + sequences[nbSeq - 1].offBase, + ofCodeTable[nbSeq - 1] + ); + } + + BIT_flushBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref blockStream_ptr, + blockStream_endPtr + ); + { + nuint n; + for (n = nbSeq - 2; n < nbSeq; n--) + { + byte llCode = llCodeTable[n]; + byte ofCode = ofCodeTable[n]; + byte mlCode = mlCodeTable[n]; + uint llBits = LL_bits[llCode]; + uint ofBits = ofCode; + uint mlBits = ML_bits[mlCode]; + FSE_encodeSymbol( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref stateOffsetBits, + ofCode + ); + FSE_encodeSymbol( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref stateMatchLength, + mlCode + ); + if (MEM_32bits) + BIT_flushBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref blockStream_ptr, + blockStream_endPtr + ); + FSE_encodeSymbol( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref stateLitLength, + llCode + ); + if (MEM_32bits || ofBits + mlBits + llBits >= 64 - 7 - (9 + 9 + 8)) + BIT_flushBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref blockStream_ptr, + blockStream_endPtr + ); + BIT_addBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + sequences[n].litLength, + llBits + ); + if (MEM_32bits && llBits + mlBits > 24) + BIT_flushBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref blockStream_ptr, + blockStream_endPtr + ); + BIT_addBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + sequences[n].mlBase, + mlBits + ); + if (MEM_32bits || ofBits + mlBits + llBits > 56) + BIT_flushBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref blockStream_ptr, + blockStream_endPtr + ); + if (longOffsets != 0) + { + uint extraBits = + ofBits + - ( + ofBits < (uint)(MEM_32bits ? 25 : 57) - 1 + ? ofBits + : (uint)(MEM_32bits ? 25 : 57) - 1 + ); + if (extraBits != 0) + { + BIT_addBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + sequences[n].offBase, + extraBits + ); + BIT_flushBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref blockStream_ptr, + blockStream_endPtr + ); + } + + BIT_addBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + sequences[n].offBase >> (int)extraBits, + ofBits - extraBits + ); + } + else + { + BIT_addBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + sequences[n].offBase, + ofBits + ); + } + + BIT_flushBits( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref blockStream_ptr, + blockStream_endPtr + ); + } + } + + FSE_flushCState( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref blockStream_ptr, + blockStream_endPtr, + ref stateMatchLength + ); + FSE_flushCState( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref blockStream_ptr, + blockStream_endPtr, + ref stateOffsetBits + ); + FSE_flushCState( + ref blockStream_bitContainer, + ref blockStream_bitPos, + ref blockStream_ptr, + blockStream_endPtr, + ref stateLitLength + ); + { + nuint streamSize = BIT_closeCStream( + ref blockStream_bitContainer, + ref blockStream_bitPos, + blockStream_ptr, + blockStream_endPtr, + blockStream.startPtr + ); + if (streamSize == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + return streamSize; + } + } + + private static nuint ZSTD_encodeSequences_default( + void* dst, + nuint dstCapacity, + uint* CTable_MatchLength, + byte* mlCodeTable, + uint* CTable_OffsetBits, + byte* ofCodeTable, + uint* CTable_LitLength, + byte* llCodeTable, + SeqDef_s* sequences, + nuint nbSeq, + int longOffsets + ) + { + return ZSTD_encodeSequences_body( + dst, + dstCapacity, + CTable_MatchLength, + mlCodeTable, + CTable_OffsetBits, + ofCodeTable, + CTable_LitLength, + llCodeTable, + sequences, + nbSeq, + longOffsets + ); + } + + private static nuint ZSTD_encodeSequences( + void* dst, + nuint dstCapacity, + uint* CTable_MatchLength, + byte* mlCodeTable, + uint* CTable_OffsetBits, + byte* ofCodeTable, + uint* CTable_LitLength, + byte* llCodeTable, + SeqDef_s* sequences, + nuint nbSeq, + int longOffsets, + int bmi2 + ) + { + return ZSTD_encodeSequences_default( + dst, + dstCapacity, + CTable_MatchLength, + mlCodeTable, + CTable_OffsetBits, + ofCodeTable, + CTable_LitLength, + llCodeTable, + sequences, + nbSeq, + longOffsets + ); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressSuperblock.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressSuperblock.cs new file mode 100644 index 000000000..8a79453b3 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCompressSuperblock.cs @@ -0,0 +1,976 @@ +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /** ZSTD_compressSubBlock_literal() : + * Compresses literals section for a sub-block. + * When we have to write the Huffman table we will sometimes choose a header + * size larger than necessary. This is because we have to pick the header size + * before we know the table size + compressed size, so we have a bound on the + * table size. If we guessed incorrectly, we fall back to uncompressed literals. + * + * We write the header when writeEntropy=1 and set entropyWritten=1 when we succeeded + * in writing the header, otherwise it is set to 0. + * + * hufMetadata->hType has literals block type info. + * If it is set_basic, all sub-blocks literals section will be Raw_Literals_Block. + * If it is set_rle, all sub-blocks literals section will be RLE_Literals_Block. + * If it is set_compressed, first sub-block's literals section will be Compressed_Literals_Block + * If it is set_compressed, first sub-block's literals section will be Treeless_Literals_Block + * and the following sub-blocks' literals sections will be Treeless_Literals_Block. + * @return : compressed size of literals section of a sub-block + * Or 0 if unable to compress. + * Or error code */ + private static nuint ZSTD_compressSubBlock_literal( + nuint* hufTable, + ZSTD_hufCTablesMetadata_t* hufMetadata, + byte* literals, + nuint litSize, + void* dst, + nuint dstSize, + int bmi2, + int writeEntropy, + int* entropyWritten + ) + { + nuint header = (nuint)(writeEntropy != 0 ? 200 : 0); + nuint lhSize = (nuint)( + 3 + + (litSize >= 1 * (1 << 10) - header ? 1 : 0) + + (litSize >= 16 * (1 << 10) - header ? 1 : 0) + ); + byte* ostart = (byte*)dst; + byte* oend = ostart + dstSize; + byte* op = ostart + lhSize; + uint singleStream = lhSize == 3 ? 1U : 0U; + SymbolEncodingType_e hType = + writeEntropy != 0 ? hufMetadata->hType : SymbolEncodingType_e.set_repeat; + nuint cLitSize = 0; + *entropyWritten = 0; + if (litSize == 0 || hufMetadata->hType == SymbolEncodingType_e.set_basic) + { + return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize); + } + else if (hufMetadata->hType == SymbolEncodingType_e.set_rle) + { + return ZSTD_compressRleLiteralsBlock(dst, dstSize, literals, litSize); + } + + assert(litSize > 0); + assert( + hufMetadata->hType == SymbolEncodingType_e.set_compressed + || hufMetadata->hType == SymbolEncodingType_e.set_repeat + ); + if (writeEntropy != 0 && hufMetadata->hType == SymbolEncodingType_e.set_compressed) + { + memcpy(op, hufMetadata->hufDesBuffer, (uint)hufMetadata->hufDesSize); + op += hufMetadata->hufDesSize; + cLitSize += hufMetadata->hufDesSize; + } + + { + int flags = bmi2 != 0 ? (int)HUF_flags_e.HUF_flags_bmi2 : 0; + nuint cSize = + singleStream != 0 + ? HUF_compress1X_usingCTable( + op, + (nuint)(oend - op), + literals, + litSize, + hufTable, + flags + ) + : HUF_compress4X_usingCTable( + op, + (nuint)(oend - op), + literals, + litSize, + hufTable, + flags + ); + op += cSize; + cLitSize += cSize; + if (cSize == 0 || ERR_isError(cSize)) + { + return 0; + } + + if (writeEntropy == 0 && cLitSize >= litSize) + { + return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize); + } + + if ( + lhSize + < (nuint)( + 3 + (cLitSize >= 1 * (1 << 10) ? 1 : 0) + (cLitSize >= 16 * (1 << 10) ? 1 : 0) + ) + ) + { + assert(cLitSize > litSize); + return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize); + } + } + + switch (lhSize) + { + case 3: + { + uint lhc = + (uint)hType + + ((singleStream == 0 ? 1U : 0U) << 2) + + ((uint)litSize << 4) + + ((uint)cLitSize << 14); + MEM_writeLE24(ostart, lhc); + break; + } + + case 4: + { + uint lhc = (uint)(hType + (2 << 2)) + ((uint)litSize << 4) + ((uint)cLitSize << 18); + MEM_writeLE32(ostart, lhc); + break; + } + + case 5: + { + uint lhc = (uint)(hType + (3 << 2)) + ((uint)litSize << 4) + ((uint)cLitSize << 22); + MEM_writeLE32(ostart, lhc); + ostart[4] = (byte)(cLitSize >> 10); + break; + } + + default: + assert(0 != 0); + break; + } + + *entropyWritten = 1; + return (nuint)(op - ostart); + } + + private static nuint ZSTD_seqDecompressedSize( + SeqStore_t* seqStore, + SeqDef_s* sequences, + nuint nbSeqs, + nuint litSize, + int lastSubBlock + ) + { + nuint matchLengthSum = 0; + nuint litLengthSum = 0; + nuint n; + for (n = 0; n < nbSeqs; n++) + { + ZSTD_SequenceLength seqLen = ZSTD_getSequenceLength(seqStore, sequences + n); + litLengthSum += seqLen.litLength; + matchLengthSum += seqLen.matchLength; + } + + if (lastSubBlock == 0) + assert(litLengthSum == litSize); + else + assert(litLengthSum <= litSize); + return matchLengthSum + litSize; + } + + /** ZSTD_compressSubBlock_sequences() : + * Compresses sequences section for a sub-block. + * fseMetadata->llType, fseMetadata->ofType, and fseMetadata->mlType have + * symbol compression modes for the super-block. + * The first successfully compressed block will have these in its header. + * We set entropyWritten=1 when we succeed in compressing the sequences. + * The following sub-blocks will always have repeat mode. + * @return : compressed size of sequences section of a sub-block + * Or 0 if it is unable to compress + * Or error code. */ + private static nuint ZSTD_compressSubBlock_sequences( + ZSTD_fseCTables_t* fseTables, + ZSTD_fseCTablesMetadata_t* fseMetadata, + SeqDef_s* sequences, + nuint nbSeq, + byte* llCode, + byte* mlCode, + byte* ofCode, + ZSTD_CCtx_params_s* cctxParams, + void* dst, + nuint dstCapacity, + int bmi2, + int writeEntropy, + int* entropyWritten + ) + { + int longOffsets = cctxParams->cParams.windowLog > (uint)(MEM_32bits ? 25 : 57) ? 1 : 0; + byte* ostart = (byte*)dst; + byte* oend = ostart + dstCapacity; + byte* op = ostart; + byte* seqHead; + *entropyWritten = 0; + if (oend - op < 3 + 1) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (nbSeq < 128) + *op++ = (byte)nbSeq; + else if (nbSeq < 0x7F00) + { + op[0] = (byte)((nbSeq >> 8) + 0x80); + op[1] = (byte)nbSeq; + op += 2; + } + else + { + op[0] = 0xFF; + MEM_writeLE16(op + 1, (ushort)(nbSeq - 0x7F00)); + op += 3; + } + + if (nbSeq == 0) + { + return (nuint)(op - ostart); + } + + seqHead = op++; + if (writeEntropy != 0) + { + uint LLtype = (uint)fseMetadata->llType; + uint Offtype = (uint)fseMetadata->ofType; + uint MLtype = (uint)fseMetadata->mlType; + *seqHead = (byte)((LLtype << 6) + (Offtype << 4) + (MLtype << 2)); + memcpy(op, fseMetadata->fseTablesBuffer, (uint)fseMetadata->fseTablesSize); + op += fseMetadata->fseTablesSize; + } + else + { + uint repeat = (uint)SymbolEncodingType_e.set_repeat; + *seqHead = (byte)((repeat << 6) + (repeat << 4) + (repeat << 2)); + } + + { + nuint bitstreamSize = ZSTD_encodeSequences( + op, + (nuint)(oend - op), + fseTables->matchlengthCTable, + mlCode, + fseTables->offcodeCTable, + ofCode, + fseTables->litlengthCTable, + llCode, + sequences, + nbSeq, + longOffsets, + bmi2 + ); + { + nuint err_code = bitstreamSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + op += bitstreamSize; + if ( + writeEntropy != 0 + && fseMetadata->lastCountSize != 0 + && fseMetadata->lastCountSize + bitstreamSize < 4 + ) + { + assert(fseMetadata->lastCountSize + bitstreamSize == 3); + return 0; + } + } + + if (op - seqHead < 4) + { + return 0; + } + + *entropyWritten = 1; + return (nuint)(op - ostart); + } + + /** ZSTD_compressSubBlock() : + * Compresses a single sub-block. + * @return : compressed size of the sub-block + * Or 0 if it failed to compress. */ + private static nuint ZSTD_compressSubBlock( + ZSTD_entropyCTables_t* entropy, + ZSTD_entropyCTablesMetadata_t* entropyMetadata, + SeqDef_s* sequences, + nuint nbSeq, + byte* literals, + nuint litSize, + byte* llCode, + byte* mlCode, + byte* ofCode, + ZSTD_CCtx_params_s* cctxParams, + void* dst, + nuint dstCapacity, + int bmi2, + int writeLitEntropy, + int writeSeqEntropy, + int* litEntropyWritten, + int* seqEntropyWritten, + uint lastBlock + ) + { + byte* ostart = (byte*)dst; + byte* oend = ostart + dstCapacity; + byte* op = ostart + ZSTD_blockHeaderSize; + { + nuint cLitSize = ZSTD_compressSubBlock_literal( + &entropy->huf.CTable.e0, + &entropyMetadata->hufMetadata, + literals, + litSize, + op, + (nuint)(oend - op), + bmi2, + writeLitEntropy, + litEntropyWritten + ); + { + nuint err_code = cLitSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (cLitSize == 0) + return 0; + op += cLitSize; + } + + { + nuint cSeqSize = ZSTD_compressSubBlock_sequences( + &entropy->fse, + &entropyMetadata->fseMetadata, + sequences, + nbSeq, + llCode, + mlCode, + ofCode, + cctxParams, + op, + (nuint)(oend - op), + bmi2, + writeSeqEntropy, + seqEntropyWritten + ); + { + nuint err_code = cSeqSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (cSeqSize == 0) + return 0; + op += cSeqSize; + } + + { + nuint cSize = (nuint)(op - ostart) - ZSTD_blockHeaderSize; + uint cBlockHeader24 = + lastBlock + ((uint)blockType_e.bt_compressed << 1) + (uint)(cSize << 3); + MEM_writeLE24(ostart, cBlockHeader24); + } + + return (nuint)(op - ostart); + } + + private static nuint ZSTD_estimateSubBlockSize_literal( + byte* literals, + nuint litSize, + ZSTD_hufCTables_t* huf, + ZSTD_hufCTablesMetadata_t* hufMetadata, + void* workspace, + nuint wkspSize, + int writeEntropy + ) + { + uint* countWksp = (uint*)workspace; + uint maxSymbolValue = 255; + /* Use hard coded size of 3 bytes */ + nuint literalSectionHeaderSize = 3; + if (hufMetadata->hType == SymbolEncodingType_e.set_basic) + return litSize; + else if (hufMetadata->hType == SymbolEncodingType_e.set_rle) + return 1; + else if ( + hufMetadata->hType == SymbolEncodingType_e.set_compressed + || hufMetadata->hType == SymbolEncodingType_e.set_repeat + ) + { + nuint largest = HIST_count_wksp( + countWksp, + &maxSymbolValue, + literals, + litSize, + workspace, + wkspSize + ); + if (ERR_isError(largest)) + return litSize; + { + nuint cLitSizeEstimate = HUF_estimateCompressedSize( + &huf->CTable.e0, + countWksp, + maxSymbolValue + ); + if (writeEntropy != 0) + cLitSizeEstimate += hufMetadata->hufDesSize; + return cLitSizeEstimate + literalSectionHeaderSize; + } + } + + assert(0 != 0); + return 0; + } + + private static nuint ZSTD_estimateSubBlockSize_symbolType( + SymbolEncodingType_e type, + byte* codeTable, + uint maxCode, + nuint nbSeq, + uint* fseCTable, + byte* additionalBits, + short* defaultNorm, + uint defaultNormLog, + uint defaultMax, + void* workspace, + nuint wkspSize + ) + { + uint* countWksp = (uint*)workspace; + byte* ctp = codeTable; + byte* ctStart = ctp; + byte* ctEnd = ctStart + nbSeq; + nuint cSymbolTypeSizeEstimateInBits = 0; + uint max = maxCode; + HIST_countFast_wksp(countWksp, &max, codeTable, nbSeq, workspace, wkspSize); + if (type == SymbolEncodingType_e.set_basic) + { + assert(max <= defaultMax); + cSymbolTypeSizeEstimateInBits = + max <= defaultMax + ? ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, countWksp, max) + : unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + else if (type == SymbolEncodingType_e.set_rle) + { + cSymbolTypeSizeEstimateInBits = 0; + } + else if ( + type == SymbolEncodingType_e.set_compressed + || type == SymbolEncodingType_e.set_repeat + ) + { + cSymbolTypeSizeEstimateInBits = ZSTD_fseBitCost(fseCTable, countWksp, max); + } + + if (ERR_isError(cSymbolTypeSizeEstimateInBits)) + return nbSeq * 10; + while (ctp < ctEnd) + { + if (additionalBits != null) + cSymbolTypeSizeEstimateInBits += additionalBits[*ctp]; + else + cSymbolTypeSizeEstimateInBits += *ctp; + ctp++; + } + + return cSymbolTypeSizeEstimateInBits / 8; + } + + private static nuint ZSTD_estimateSubBlockSize_sequences( + byte* ofCodeTable, + byte* llCodeTable, + byte* mlCodeTable, + nuint nbSeq, + ZSTD_fseCTables_t* fseTables, + ZSTD_fseCTablesMetadata_t* fseMetadata, + void* workspace, + nuint wkspSize, + int writeEntropy + ) + { + /* Use hard coded size of 3 bytes */ + const nuint sequencesSectionHeaderSize = 3; + nuint cSeqSizeEstimate = 0; + if (nbSeq == 0) + return sequencesSectionHeaderSize; + cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType( + fseMetadata->ofType, + ofCodeTable, + 31, + nbSeq, + fseTables->offcodeCTable, + null, + OF_defaultNorm, + OF_defaultNormLog, + 28, + workspace, + wkspSize + ); + cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType( + fseMetadata->llType, + llCodeTable, + 35, + nbSeq, + fseTables->litlengthCTable, + LL_bits, + LL_defaultNorm, + LL_defaultNormLog, + 35, + workspace, + wkspSize + ); + cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType( + fseMetadata->mlType, + mlCodeTable, + 52, + nbSeq, + fseTables->matchlengthCTable, + ML_bits, + ML_defaultNorm, + ML_defaultNormLog, + 52, + workspace, + wkspSize + ); + if (writeEntropy != 0) + cSeqSizeEstimate += fseMetadata->fseTablesSize; + return cSeqSizeEstimate + sequencesSectionHeaderSize; + } + + private static EstimatedBlockSize ZSTD_estimateSubBlockSize( + byte* literals, + nuint litSize, + byte* ofCodeTable, + byte* llCodeTable, + byte* mlCodeTable, + nuint nbSeq, + ZSTD_entropyCTables_t* entropy, + ZSTD_entropyCTablesMetadata_t* entropyMetadata, + void* workspace, + nuint wkspSize, + int writeLitEntropy, + int writeSeqEntropy + ) + { + EstimatedBlockSize ebs; + ebs.estLitSize = ZSTD_estimateSubBlockSize_literal( + literals, + litSize, + &entropy->huf, + &entropyMetadata->hufMetadata, + workspace, + wkspSize, + writeLitEntropy + ); + ebs.estBlockSize = ZSTD_estimateSubBlockSize_sequences( + ofCodeTable, + llCodeTable, + mlCodeTable, + nbSeq, + &entropy->fse, + &entropyMetadata->fseMetadata, + workspace, + wkspSize, + writeSeqEntropy + ); + ebs.estBlockSize += ebs.estLitSize + ZSTD_blockHeaderSize; + return ebs; + } + + private static int ZSTD_needSequenceEntropyTables(ZSTD_fseCTablesMetadata_t* fseMetadata) + { + if ( + fseMetadata->llType == SymbolEncodingType_e.set_compressed + || fseMetadata->llType == SymbolEncodingType_e.set_rle + ) + return 1; + if ( + fseMetadata->mlType == SymbolEncodingType_e.set_compressed + || fseMetadata->mlType == SymbolEncodingType_e.set_rle + ) + return 1; + if ( + fseMetadata->ofType == SymbolEncodingType_e.set_compressed + || fseMetadata->ofType == SymbolEncodingType_e.set_rle + ) + return 1; + return 0; + } + + private static nuint countLiterals(SeqStore_t* seqStore, SeqDef_s* sp, nuint seqCount) + { + nuint n, + total = 0; + assert(sp != null); + for (n = 0; n < seqCount; n++) + { + total += ZSTD_getSequenceLength(seqStore, sp + n).litLength; + } + + return total; + } + + private static nuint sizeBlockSequences( + SeqDef_s* sp, + nuint nbSeqs, + nuint targetBudget, + nuint avgLitCost, + nuint avgSeqCost, + int firstSubBlock + ) + { + nuint n, + budget = 0, + inSize = 0; + /* generous estimate */ + nuint headerSize = (nuint)firstSubBlock * 120 * 256; + assert(firstSubBlock == 0 || firstSubBlock == 1); + budget += headerSize; + budget += sp[0].litLength * avgLitCost + avgSeqCost; + if (budget > targetBudget) + return 1; + inSize = (nuint)(sp[0].litLength + (sp[0].mlBase + 3)); + for (n = 1; n < nbSeqs; n++) + { + nuint currentCost = sp[n].litLength * avgLitCost + avgSeqCost; + budget += currentCost; + inSize += (nuint)(sp[n].litLength + (sp[n].mlBase + 3)); + if (budget > targetBudget && budget < inSize * 256) + break; + } + + return n; + } + + /** ZSTD_compressSubBlock_multi() : + * Breaks super-block into multiple sub-blocks and compresses them. + * Entropy will be written into the first block. + * The following blocks use repeat_mode to compress. + * Sub-blocks are all compressed, except the last one when beneficial. + * @return : compressed size of the super block (which features multiple ZSTD blocks) + * or 0 if it failed to compress. */ + private static nuint ZSTD_compressSubBlock_multi( + SeqStore_t* seqStorePtr, + ZSTD_compressedBlockState_t* prevCBlock, + ZSTD_compressedBlockState_t* nextCBlock, + ZSTD_entropyCTablesMetadata_t* entropyMetadata, + ZSTD_CCtx_params_s* cctxParams, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + int bmi2, + uint lastBlock, + void* workspace, + nuint wkspSize + ) + { + SeqDef_s* sstart = seqStorePtr->sequencesStart; + SeqDef_s* send = seqStorePtr->sequences; + /* tracks progresses within seqStorePtr->sequences */ + SeqDef_s* sp = sstart; + nuint nbSeqs = (nuint)(send - sstart); + byte* lstart = seqStorePtr->litStart; + byte* lend = seqStorePtr->lit; + byte* lp = lstart; + nuint nbLiterals = (nuint)(lend - lstart); + byte* ip = (byte*)src; + byte* iend = ip + srcSize; + byte* ostart = (byte*)dst; + byte* oend = ostart + dstCapacity; + byte* op = ostart; + byte* llCodePtr = seqStorePtr->llCode; + byte* mlCodePtr = seqStorePtr->mlCode; + byte* ofCodePtr = seqStorePtr->ofCode; + /* enforce minimum size, to reduce undesirable side effects */ + const nuint minTarget = 1340; + nuint targetCBlockSize = + minTarget > cctxParams->targetCBlockSize ? minTarget : cctxParams->targetCBlockSize; + int writeLitEntropy = + entropyMetadata->hufMetadata.hType == SymbolEncodingType_e.set_compressed ? 1 : 0; + int writeSeqEntropy = 1; + if (nbSeqs > 0) + { + EstimatedBlockSize ebs = ZSTD_estimateSubBlockSize( + lp, + nbLiterals, + ofCodePtr, + llCodePtr, + mlCodePtr, + nbSeqs, + &nextCBlock->entropy, + entropyMetadata, + workspace, + wkspSize, + writeLitEntropy, + writeSeqEntropy + ); + /* quick estimation */ + nuint avgLitCost = nbLiterals != 0 ? ebs.estLitSize * 256 / nbLiterals : 256; + nuint avgSeqCost = (ebs.estBlockSize - ebs.estLitSize) * 256 / nbSeqs; + nuint nbSubBlocks = + (ebs.estBlockSize + targetCBlockSize / 2) / targetCBlockSize > 1 + ? (ebs.estBlockSize + targetCBlockSize / 2) / targetCBlockSize + : 1; + nuint n, + avgBlockBudget, + blockBudgetSupp = 0; + avgBlockBudget = ebs.estBlockSize * 256 / nbSubBlocks; + if (ebs.estBlockSize > srcSize) + return 0; + assert(nbSubBlocks > 0); + for (n = 0; n < nbSubBlocks - 1; n++) + { + /* determine nb of sequences for current sub-block + nbLiterals from next sequence */ + nuint seqCount = sizeBlockSequences( + sp, + (nuint)(send - sp), + avgBlockBudget + blockBudgetSupp, + avgLitCost, + avgSeqCost, + n == 0 ? 1 : 0 + ); + assert(seqCount <= (nuint)(send - sp)); + if (sp + seqCount == send) + break; + assert(seqCount > 0); + { + int litEntropyWritten = 0; + int seqEntropyWritten = 0; + nuint litSize = countLiterals(seqStorePtr, sp, seqCount); + nuint decompressedSize = ZSTD_seqDecompressedSize( + seqStorePtr, + sp, + seqCount, + litSize, + 0 + ); + nuint cSize = ZSTD_compressSubBlock( + &nextCBlock->entropy, + entropyMetadata, + sp, + seqCount, + lp, + litSize, + llCodePtr, + mlCodePtr, + ofCodePtr, + cctxParams, + op, + (nuint)(oend - op), + bmi2, + writeLitEntropy, + writeSeqEntropy, + &litEntropyWritten, + &seqEntropyWritten, + 0 + ); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (cSize > 0 && cSize < decompressedSize) + { + assert(ip + decompressedSize <= iend); + ip += decompressedSize; + lp += litSize; + op += cSize; + llCodePtr += seqCount; + mlCodePtr += seqCount; + ofCodePtr += seqCount; + if (litEntropyWritten != 0) + { + writeLitEntropy = 0; + } + + if (seqEntropyWritten != 0) + { + writeSeqEntropy = 0; + } + + sp += seqCount; + blockBudgetSupp = 0; + } + } + } + } + + { + int litEntropyWritten = 0; + int seqEntropyWritten = 0; + nuint litSize = (nuint)(lend - lp); + nuint seqCount = (nuint)(send - sp); + nuint decompressedSize = ZSTD_seqDecompressedSize( + seqStorePtr, + sp, + seqCount, + litSize, + 1 + ); + nuint cSize = ZSTD_compressSubBlock( + &nextCBlock->entropy, + entropyMetadata, + sp, + seqCount, + lp, + litSize, + llCodePtr, + mlCodePtr, + ofCodePtr, + cctxParams, + op, + (nuint)(oend - op), + bmi2, + writeLitEntropy, + writeSeqEntropy, + &litEntropyWritten, + &seqEntropyWritten, + lastBlock + ); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (cSize > 0 && cSize < decompressedSize) + { + assert(ip + decompressedSize <= iend); + ip += decompressedSize; + lp += litSize; + op += cSize; + llCodePtr += seqCount; + mlCodePtr += seqCount; + ofCodePtr += seqCount; + if (litEntropyWritten != 0) + { + writeLitEntropy = 0; + } + + if (seqEntropyWritten != 0) + { + writeSeqEntropy = 0; + } + + sp += seqCount; + } + } + + if (writeLitEntropy != 0) + { + memcpy( + &nextCBlock->entropy.huf, + &prevCBlock->entropy.huf, + (uint)sizeof(ZSTD_hufCTables_t) + ); + } + + if ( + writeSeqEntropy != 0 + && ZSTD_needSequenceEntropyTables(&entropyMetadata->fseMetadata) != 0 + ) + { + return 0; + } + + if (ip < iend) + { + /* some data left : last part of the block sent uncompressed */ + nuint rSize = (nuint)(iend - ip); + nuint cSize = ZSTD_noCompressBlock(op, (nuint)(oend - op), ip, rSize, lastBlock); + { + nuint err_code = cSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(cSize != 0); + op += cSize; + if (sp < send) + { + SeqDef_s* seq; + repcodes_s rep; + memcpy(&rep, prevCBlock->rep, (uint)sizeof(repcodes_s)); + for (seq = sstart; seq < sp; ++seq) + { + ZSTD_updateRep( + rep.rep, + seq->offBase, + ZSTD_getSequenceLength(seqStorePtr, seq).litLength == 0 ? 1U : 0U + ); + } + + memcpy(nextCBlock->rep, &rep, (uint)sizeof(repcodes_s)); + } + } + + return (nuint)(op - ostart); + } + + /* ZSTD_compressSuperBlock() : + * Used to compress a super block when targetCBlockSize is being used. + * The given block will be compressed into multiple sub blocks that are around targetCBlockSize. */ + private static nuint ZSTD_compressSuperBlock( + ZSTD_CCtx_s* zc, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + uint lastBlock + ) + { + ZSTD_entropyCTablesMetadata_t entropyMetadata; + { + nuint err_code = ZSTD_buildBlockEntropyStats( + &zc->seqStore, + &zc->blockState.prevCBlock->entropy, + &zc->blockState.nextCBlock->entropy, + &zc->appliedParams, + &entropyMetadata, + zc->tmpWorkspace, + zc->tmpWkspSize + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return ZSTD_compressSubBlock_multi( + &zc->seqStore, + zc->blockState.prevCBlock, + zc->blockState.nextCBlock, + &entropyMetadata, + &zc->appliedParams, + dst, + dstCapacity, + src, + srcSize, + zc->bmi2, + lastBlock, + zc->tmpWorkspace, + zc->tmpWkspSize + ); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCwksp.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCwksp.cs new file mode 100644 index 000000000..236c94d46 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdCwksp.cs @@ -0,0 +1,581 @@ +using System.Diagnostics; +using System.Runtime.CompilerServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [Conditional("DEBUG")] + private static void ZSTD_cwksp_assert_internal_consistency(ZSTD_cwksp* ws) + { + assert(ws->workspace <= ws->objectEnd); + assert(ws->objectEnd <= ws->tableEnd); + assert(ws->objectEnd <= ws->tableValidEnd); + assert(ws->tableEnd <= ws->allocStart); + assert(ws->tableValidEnd <= ws->allocStart); + assert(ws->allocStart <= ws->workspaceEnd); + assert(ws->initOnceStart <= ZSTD_cwksp_initialAllocStart(ws)); + assert(ws->workspace <= ws->initOnceStart); + } + + /** + * Align must be a power of 2. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_cwksp_align(nuint size, nuint align) + { + nuint mask = align - 1; + assert(ZSTD_isPower2(align) != 0); + return size + mask & ~mask; + } + + /** + * Use this to determine how much space in the workspace we will consume to + * allocate this object. (Normally it should be exactly the size of the object, + * but under special conditions, like ASAN, where we pad each object, it might + * be larger.) + * + * Since tables aren't currently redzoned, you don't need to call through this + * to figure out how much space you need for the matchState tables. Everything + * else is though. + * + * Do not use for sizing aligned buffers. Instead, use ZSTD_cwksp_aligned64_alloc_size(). + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_cwksp_alloc_size(nuint size) + { + if (size == 0) + return 0; + return size; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_cwksp_aligned_alloc_size(nuint size, nuint alignment) + { + return ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(size, alignment)); + } + + /** + * Returns an adjusted alloc size that is the nearest larger multiple of 64 bytes. + * Used to determine the number of bytes required for a given "aligned". + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_cwksp_aligned64_alloc_size(nuint size) + { + return ZSTD_cwksp_aligned_alloc_size(size, 64); + } + + /** + * Returns the amount of additional space the cwksp must allocate + * for internal purposes (currently only alignment). + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_cwksp_slack_space_required() + { + /* For alignment, the wksp will always allocate an additional 2*ZSTD_CWKSP_ALIGNMENT_BYTES + * bytes to align the beginning of tables section and end of buffers; + */ + const nuint slackSpace = 64 * 2; + return slackSpace; + } + + /** + * Return the number of additional bytes required to align a pointer to the given number of bytes. + * alignBytes must be a power of two. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_cwksp_bytes_to_align_ptr(void* ptr, nuint alignBytes) + { + nuint alignBytesMask = alignBytes - 1; + nuint bytes = alignBytes - ((nuint)ptr & alignBytesMask) & alignBytesMask; + assert(ZSTD_isPower2(alignBytes) != 0); + assert(bytes < alignBytes); + return bytes; + } + + /** + * Returns the initial value for allocStart which is used to determine the position from + * which we can allocate from the end of the workspace. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void* ZSTD_cwksp_initialAllocStart(ZSTD_cwksp* ws) + { + sbyte* endPtr = (sbyte*)ws->workspaceEnd; + assert(ZSTD_isPower2(64) != 0); + endPtr = endPtr - (nuint)endPtr % 64; + return endPtr; + } + + /** + * Internal function. Do not use directly. + * Reserves the given number of bytes within the aligned/buffer segment of the wksp, + * which counts from the end of the wksp (as opposed to the object/table segment). + * + * Returns a pointer to the beginning of that space. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void* ZSTD_cwksp_reserve_internal_buffer_space(ZSTD_cwksp* ws, nuint bytes) + { + void* alloc = (byte*)ws->allocStart - bytes; + void* bottom = ws->tableEnd; + ZSTD_cwksp_assert_internal_consistency(ws); + assert(alloc >= bottom); + if (alloc < bottom) + { + ws->allocFailed = 1; + return null; + } + + if (alloc < ws->tableValidEnd) + { + ws->tableValidEnd = alloc; + } + + ws->allocStart = alloc; + return alloc; + } + + /** + * Moves the cwksp to the next phase, and does any necessary allocations. + * cwksp initialization must necessarily go through each phase in order. + * Returns a 0 on success, or zstd error + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_cwksp_internal_advance_phase( + ZSTD_cwksp* ws, + ZSTD_cwksp_alloc_phase_e phase + ) + { + assert(phase >= ws->phase); + if (phase > ws->phase) + { + if ( + ws->phase < ZSTD_cwksp_alloc_phase_e.ZSTD_cwksp_alloc_aligned_init_once + && phase >= ZSTD_cwksp_alloc_phase_e.ZSTD_cwksp_alloc_aligned_init_once + ) + { + ws->tableValidEnd = ws->objectEnd; + ws->initOnceStart = ZSTD_cwksp_initialAllocStart(ws); + { + void* alloc = ws->objectEnd; + nuint bytesToAlign = ZSTD_cwksp_bytes_to_align_ptr(alloc, 64); + void* objectEnd = (byte*)alloc + bytesToAlign; + if (objectEnd > ws->workspaceEnd) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation) + ); + } + + ws->objectEnd = objectEnd; + ws->tableEnd = objectEnd; + if (ws->tableValidEnd < ws->tableEnd) + { + ws->tableValidEnd = ws->tableEnd; + } + } + } + + ws->phase = phase; + ZSTD_cwksp_assert_internal_consistency(ws); + } + + return 0; + } + + /** + * Returns whether this object/buffer/etc was allocated in this workspace. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_cwksp_owns_buffer(ZSTD_cwksp* ws, void* ptr) + { + return ptr != null && ws->workspace <= ptr && ptr < ws->workspaceEnd ? 1 : 0; + } + + /** + * Internal function. Do not use directly. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void* ZSTD_cwksp_reserve_internal( + ZSTD_cwksp* ws, + nuint bytes, + ZSTD_cwksp_alloc_phase_e phase + ) + { + void* alloc; + if (ERR_isError(ZSTD_cwksp_internal_advance_phase(ws, phase)) || bytes == 0) + { + return null; + } + + alloc = ZSTD_cwksp_reserve_internal_buffer_space(ws, bytes); + return alloc; + } + + /** + * Reserves and returns unaligned memory. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static byte* ZSTD_cwksp_reserve_buffer(ZSTD_cwksp* ws, nuint bytes) + { + return (byte*)ZSTD_cwksp_reserve_internal( + ws, + bytes, + ZSTD_cwksp_alloc_phase_e.ZSTD_cwksp_alloc_buffers + ); + } + + /** + * Reserves and returns memory sized on and aligned on ZSTD_CWKSP_ALIGNMENT_BYTES (64 bytes). + * This memory has been initialized at least once in the past. + * This doesn't mean it has been initialized this time, and it might contain data from previous + * operations. + * The main usage is for algorithms that might need read access into uninitialized memory. + * The algorithm must maintain safety under these conditions and must make sure it doesn't + * leak any of the past data (directly or in side channels). + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void* ZSTD_cwksp_reserve_aligned_init_once(ZSTD_cwksp* ws, nuint bytes) + { + nuint alignedBytes = ZSTD_cwksp_align(bytes, 64); + void* ptr = ZSTD_cwksp_reserve_internal( + ws, + alignedBytes, + ZSTD_cwksp_alloc_phase_e.ZSTD_cwksp_alloc_aligned_init_once + ); + assert(((nuint)ptr & 64 - 1) == 0); + if (ptr != null && ptr < ws->initOnceStart) + { + memset( + ptr, + 0, + (uint)( + (nuint)((byte*)ws->initOnceStart - (byte*)ptr) < alignedBytes + ? (nuint)((byte*)ws->initOnceStart - (byte*)ptr) + : alignedBytes + ) + ); + ws->initOnceStart = ptr; + } + + return ptr; + } + + /** + * Reserves and returns memory sized on and aligned on ZSTD_CWKSP_ALIGNMENT_BYTES (64 bytes). + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void* ZSTD_cwksp_reserve_aligned64(ZSTD_cwksp* ws, nuint bytes) + { + void* ptr = ZSTD_cwksp_reserve_internal( + ws, + ZSTD_cwksp_align(bytes, 64), + ZSTD_cwksp_alloc_phase_e.ZSTD_cwksp_alloc_aligned + ); + assert(((nuint)ptr & 64 - 1) == 0); + return ptr; + } + + /** + * Aligned on 64 bytes. These buffers have the special property that + * their values remain constrained, allowing us to reuse them without + * memset()-ing them. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void* ZSTD_cwksp_reserve_table(ZSTD_cwksp* ws, nuint bytes) + { + ZSTD_cwksp_alloc_phase_e phase = + ZSTD_cwksp_alloc_phase_e.ZSTD_cwksp_alloc_aligned_init_once; + void* alloc; + void* end; + void* top; + if (ws->phase < phase) + { + if (ERR_isError(ZSTD_cwksp_internal_advance_phase(ws, phase))) + { + return null; + } + } + + alloc = ws->tableEnd; + end = (byte*)alloc + bytes; + top = ws->allocStart; + assert((bytes & sizeof(uint) - 1) == 0); + ZSTD_cwksp_assert_internal_consistency(ws); + assert(end <= top); + if (end > top) + { + ws->allocFailed = 1; + return null; + } + + ws->tableEnd = end; + assert((bytes & 64 - 1) == 0); + assert(((nuint)alloc & 64 - 1) == 0); + return alloc; + } + + /** + * Aligned on sizeof(void*). + * Note : should happen only once, at workspace first initialization + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void* ZSTD_cwksp_reserve_object(ZSTD_cwksp* ws, nuint bytes) + { + nuint roundedBytes = ZSTD_cwksp_align(bytes, (nuint)sizeof(void*)); + void* alloc = ws->objectEnd; + void* end = (byte*)alloc + roundedBytes; + assert((nuint)alloc % (nuint)sizeof(void*) == 0); + assert(bytes % (nuint)sizeof(void*) == 0); + ZSTD_cwksp_assert_internal_consistency(ws); + if ( + ws->phase != ZSTD_cwksp_alloc_phase_e.ZSTD_cwksp_alloc_objects + || end > ws->workspaceEnd + ) + { + ws->allocFailed = 1; + return null; + } + + ws->objectEnd = end; + ws->tableEnd = end; + ws->tableValidEnd = end; + return alloc; + } + + /** + * with alignment control + * Note : should happen only once, at workspace first initialization + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void* ZSTD_cwksp_reserve_object_aligned( + ZSTD_cwksp* ws, + nuint byteSize, + nuint alignment + ) + { + nuint mask = alignment - 1; + nuint surplus = alignment > (nuint)sizeof(void*) ? alignment - (nuint)sizeof(void*) : 0; + void* start = ZSTD_cwksp_reserve_object(ws, byteSize + surplus); + if (start == null) + return null; + if (surplus == 0) + return start; + assert(ZSTD_isPower2(alignment) != 0); + return (void*)((nuint)start + surplus & ~mask); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_cwksp_mark_tables_dirty(ZSTD_cwksp* ws) + { + assert(ws->tableValidEnd >= ws->objectEnd); + assert(ws->tableValidEnd <= ws->allocStart); + ws->tableValidEnd = ws->objectEnd; + ZSTD_cwksp_assert_internal_consistency(ws); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_cwksp_mark_tables_clean(ZSTD_cwksp* ws) + { + assert(ws->tableValidEnd >= ws->objectEnd); + assert(ws->tableValidEnd <= ws->allocStart); + if (ws->tableValidEnd < ws->tableEnd) + { + ws->tableValidEnd = ws->tableEnd; + } + + ZSTD_cwksp_assert_internal_consistency(ws); + } + + /** + * Zero the part of the allocated tables not already marked clean. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_cwksp_clean_tables(ZSTD_cwksp* ws) + { + assert(ws->tableValidEnd >= ws->objectEnd); + assert(ws->tableValidEnd <= ws->allocStart); + if (ws->tableValidEnd < ws->tableEnd) + { + memset( + ws->tableValidEnd, + 0, + (uint)(nuint)((byte*)ws->tableEnd - (byte*)ws->tableValidEnd) + ); + } + + ZSTD_cwksp_mark_tables_clean(ws); + } + + /** + * Invalidates table allocations. + * All other allocations remain valid. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_cwksp_clear_tables(ZSTD_cwksp* ws) + { + ws->tableEnd = ws->objectEnd; + ZSTD_cwksp_assert_internal_consistency(ws); + } + + /** + * Invalidates all buffer, aligned, and table allocations. + * Object allocations remain valid. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_cwksp_clear(ZSTD_cwksp* ws) + { + ws->tableEnd = ws->objectEnd; + ws->allocStart = ZSTD_cwksp_initialAllocStart(ws); + ws->allocFailed = 0; + if (ws->phase > ZSTD_cwksp_alloc_phase_e.ZSTD_cwksp_alloc_aligned_init_once) + { + ws->phase = ZSTD_cwksp_alloc_phase_e.ZSTD_cwksp_alloc_aligned_init_once; + } + + ZSTD_cwksp_assert_internal_consistency(ws); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_cwksp_sizeof(ZSTD_cwksp* ws) + { + return (nuint)((byte*)ws->workspaceEnd - (byte*)ws->workspace); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_cwksp_used(ZSTD_cwksp* ws) + { + return (nuint)((byte*)ws->tableEnd - (byte*)ws->workspace) + + (nuint)((byte*)ws->workspaceEnd - (byte*)ws->allocStart); + } + + /** + * The provided workspace takes ownership of the buffer [start, start+size). + * Any existing values in the workspace are ignored (the previously managed + * buffer, if present, must be separately freed). + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_cwksp_init( + ZSTD_cwksp* ws, + void* start, + nuint size, + ZSTD_cwksp_static_alloc_e isStatic + ) + { + assert(((nuint)start & (nuint)(sizeof(void*) - 1)) == 0); + ws->workspace = start; + ws->workspaceEnd = (byte*)start + size; + ws->objectEnd = ws->workspace; + ws->tableValidEnd = ws->objectEnd; + ws->initOnceStart = ZSTD_cwksp_initialAllocStart(ws); + ws->phase = ZSTD_cwksp_alloc_phase_e.ZSTD_cwksp_alloc_objects; + ws->isStatic = isStatic; + ZSTD_cwksp_clear(ws); + ws->workspaceOversizedDuration = 0; + ZSTD_cwksp_assert_internal_consistency(ws); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_cwksp_create(ZSTD_cwksp* ws, nuint size, ZSTD_customMem customMem) + { + void* workspace = ZSTD_customMalloc(size, customMem); + if (workspace == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + ZSTD_cwksp_init(ws, workspace, size, ZSTD_cwksp_static_alloc_e.ZSTD_cwksp_dynamic_alloc); + return 0; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_cwksp_free(ZSTD_cwksp* ws, ZSTD_customMem customMem) + { + void* ptr = ws->workspace; + *ws = new ZSTD_cwksp(); + ZSTD_customFree(ptr, customMem); + } + + /** + * Moves the management of a workspace from one cwksp to another. The src cwksp + * is left in an invalid state (src must be re-init()'ed before it's used again). + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_cwksp_move(ZSTD_cwksp* dst, ZSTD_cwksp* src) + { + *dst = *src; + *src = new ZSTD_cwksp(); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_cwksp_reserve_failed(ZSTD_cwksp* ws) + { + return ws->allocFailed; + } + + /* ZSTD_alignmentSpaceWithinBounds() : + * Returns if the estimated space needed for a wksp is within an acceptable limit of the + * actual amount of space used. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_cwksp_estimated_space_within_bounds( + ZSTD_cwksp* ws, + nuint estimatedSpace + ) + { + return + estimatedSpace - ZSTD_cwksp_slack_space_required() <= ZSTD_cwksp_used(ws) + && ZSTD_cwksp_used(ws) <= estimatedSpace + ? 1 + : 0; + } + + /*-************************************* + * Functions + ***************************************/ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_cwksp_available_space(ZSTD_cwksp* ws) + { + return (nuint)((byte*)ws->allocStart - (byte*)ws->tableEnd); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_cwksp_check_available(ZSTD_cwksp* ws, nuint additionalNeededSpace) + { + return ZSTD_cwksp_available_space(ws) >= additionalNeededSpace ? 1 : 0; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_cwksp_check_too_large(ZSTD_cwksp* ws, nuint additionalNeededSpace) + { + return ZSTD_cwksp_check_available(ws, additionalNeededSpace * 3); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_cwksp_check_wasteful(ZSTD_cwksp* ws, nuint additionalNeededSpace) + { + return + ZSTD_cwksp_check_too_large(ws, additionalNeededSpace) != 0 + && ws->workspaceOversizedDuration > 128 + ? 1 + : 0; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_cwksp_bump_oversized_duration( + ZSTD_cwksp* ws, + nuint additionalNeededSpace + ) + { + if (ZSTD_cwksp_check_too_large(ws, additionalNeededSpace) != 0) + { + ws->workspaceOversizedDuration++; + } + else + { + ws->workspaceOversizedDuration = 0; + } + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDdict.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDdict.cs new file mode 100644 index 000000000..ce79c0f16 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDdict.cs @@ -0,0 +1,292 @@ +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /* note: several prototypes are already published in `zstd.h` : + * ZSTD_createDDict() + * ZSTD_createDDict_byReference() + * ZSTD_createDDict_advanced() + * ZSTD_freeDDict() + * ZSTD_initStaticDDict() + * ZSTD_sizeof_DDict() + * ZSTD_estimateDDictSize() + * ZSTD_getDictID_fromDict() + */ + private static void* ZSTD_DDict_dictContent(ZSTD_DDict_s* ddict) + { + assert(ddict != null); + return ddict->dictContent; + } + + private static nuint ZSTD_DDict_dictSize(ZSTD_DDict_s* ddict) + { + assert(ddict != null); + return ddict->dictSize; + } + + private static void ZSTD_copyDDictParameters(ZSTD_DCtx_s* dctx, ZSTD_DDict_s* ddict) + { + assert(dctx != null); + assert(ddict != null); + dctx->dictID = ddict->dictID; + dctx->prefixStart = ddict->dictContent; + dctx->virtualStart = ddict->dictContent; + dctx->dictEnd = (byte*)ddict->dictContent + ddict->dictSize; + dctx->previousDstEnd = dctx->dictEnd; + if (ddict->entropyPresent != 0) + { + dctx->litEntropy = 1; + dctx->fseEntropy = 1; + dctx->LLTptr = &ddict->entropy.LLTable.e0; + dctx->MLTptr = &ddict->entropy.MLTable.e0; + dctx->OFTptr = &ddict->entropy.OFTable.e0; + dctx->HUFptr = ddict->entropy.hufTable; + dctx->entropy.rep[0] = ddict->entropy.rep[0]; + dctx->entropy.rep[1] = ddict->entropy.rep[1]; + dctx->entropy.rep[2] = ddict->entropy.rep[2]; + } + else + { + dctx->litEntropy = 0; + dctx->fseEntropy = 0; + } + } + + private static nuint ZSTD_loadEntropy_intoDDict( + ZSTD_DDict_s* ddict, + ZSTD_dictContentType_e dictContentType + ) + { + ddict->dictID = 0; + ddict->entropyPresent = 0; + if (dictContentType == ZSTD_dictContentType_e.ZSTD_dct_rawContent) + return 0; + if (ddict->dictSize < 8) + { + if (dictContentType == ZSTD_dictContentType_e.ZSTD_dct_fullDict) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + return 0; + } + + { + uint magic = MEM_readLE32(ddict->dictContent); + if (magic != 0xEC30A437) + { + if (dictContentType == ZSTD_dictContentType_e.ZSTD_dct_fullDict) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + return 0; + } + } + + ddict->dictID = MEM_readLE32((sbyte*)ddict->dictContent + 4); + if (ERR_isError(ZSTD_loadDEntropy(&ddict->entropy, ddict->dictContent, ddict->dictSize))) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + ddict->entropyPresent = 1; + return 0; + } + + private static nuint ZSTD_initDDict_internal( + ZSTD_DDict_s* ddict, + void* dict, + nuint dictSize, + ZSTD_dictLoadMethod_e dictLoadMethod, + ZSTD_dictContentType_e dictContentType + ) + { + if (dictLoadMethod == ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef || dict == null || dictSize == 0) + { + ddict->dictBuffer = null; + ddict->dictContent = dict; + if (dict == null) + dictSize = 0; + } + else + { + void* internalBuffer = ZSTD_customMalloc(dictSize, ddict->cMem); + ddict->dictBuffer = internalBuffer; + ddict->dictContent = internalBuffer; + if (internalBuffer == null) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + memcpy(internalBuffer, dict, (uint)dictSize); + } + + ddict->dictSize = dictSize; + ddict->entropy.hufTable[0] = 12 * 0x1000001; + { + /* parse dictionary content */ + nuint err_code = ZSTD_loadEntropy_intoDDict(ddict, dictContentType); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + public static ZSTD_DDict_s* ZSTD_createDDict_advanced( + void* dict, + nuint dictSize, + ZSTD_dictLoadMethod_e dictLoadMethod, + ZSTD_dictContentType_e dictContentType, + ZSTD_customMem customMem + ) + { + if (((customMem.customAlloc == null ? 1 : 0) ^ (customMem.customFree == null ? 1 : 0)) != 0) + return null; + { + ZSTD_DDict_s* ddict = (ZSTD_DDict_s*)ZSTD_customMalloc( + (nuint)sizeof(ZSTD_DDict_s), + customMem + ); + if (ddict == null) + return null; + ddict->cMem = customMem; + { + nuint initResult = ZSTD_initDDict_internal( + ddict, + dict, + dictSize, + dictLoadMethod, + dictContentType + ); + if (ERR_isError(initResult)) + { + ZSTD_freeDDict(ddict); + return null; + } + } + + return ddict; + } + } + + /*! ZSTD_createDDict() : + * Create a digested dictionary, to start decompression without startup delay. + * `dict` content is copied inside DDict. + * Consequently, `dict` can be released after `ZSTD_DDict` creation */ + public static ZSTD_DDict_s* ZSTD_createDDict(void* dict, nuint dictSize) + { + ZSTD_customMem allocator = new ZSTD_customMem + { + customAlloc = null, + customFree = null, + opaque = null, + }; + return ZSTD_createDDict_advanced( + dict, + dictSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byCopy, + ZSTD_dictContentType_e.ZSTD_dct_auto, + allocator + ); + } + + /*! ZSTD_createDDict_byReference() : + * Create a digested dictionary, to start decompression without startup delay. + * Dictionary content is simply referenced, it will be accessed during decompression. + * Warning : dictBuffer must outlive DDict (DDict must be freed before dictBuffer) */ + public static ZSTD_DDict_s* ZSTD_createDDict_byReference(void* dictBuffer, nuint dictSize) + { + ZSTD_customMem allocator = new ZSTD_customMem + { + customAlloc = null, + customFree = null, + opaque = null, + }; + return ZSTD_createDDict_advanced( + dictBuffer, + dictSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef, + ZSTD_dictContentType_e.ZSTD_dct_auto, + allocator + ); + } + + public static ZSTD_DDict_s* ZSTD_initStaticDDict( + void* sBuffer, + nuint sBufferSize, + void* dict, + nuint dictSize, + ZSTD_dictLoadMethod_e dictLoadMethod, + ZSTD_dictContentType_e dictContentType + ) + { + nuint neededSpace = + (nuint)sizeof(ZSTD_DDict_s) + + (dictLoadMethod == ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef ? 0 : dictSize); + ZSTD_DDict_s* ddict = (ZSTD_DDict_s*)sBuffer; + assert(sBuffer != null); + assert(dict != null); + if (((nuint)sBuffer & 7) != 0) + return null; + if (sBufferSize < neededSpace) + return null; + if (dictLoadMethod == ZSTD_dictLoadMethod_e.ZSTD_dlm_byCopy) + { + memcpy(ddict + 1, dict, (uint)dictSize); + dict = ddict + 1; + } + + if ( + ERR_isError( + ZSTD_initDDict_internal( + ddict, + dict, + dictSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef, + dictContentType + ) + ) + ) + return null; + return ddict; + } + + /*! ZSTD_freeDDict() : + * Function frees memory allocated with ZSTD_createDDict() + * If a NULL pointer is passed, no operation is performed. */ + public static nuint ZSTD_freeDDict(ZSTD_DDict_s* ddict) + { + if (ddict == null) + return 0; + { + ZSTD_customMem cMem = ddict->cMem; + ZSTD_customFree(ddict->dictBuffer, cMem); + ZSTD_customFree(ddict, cMem); + return 0; + } + } + + /*! ZSTD_estimateDDictSize() : + * Estimate amount of memory that will be needed to create a dictionary for decompression. + * Note : dictionary created by reference using ZSTD_dlm_byRef are smaller */ + public static nuint ZSTD_estimateDDictSize(nuint dictSize, ZSTD_dictLoadMethod_e dictLoadMethod) + { + return (nuint)sizeof(ZSTD_DDict_s) + + (dictLoadMethod == ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef ? 0 : dictSize); + } + + public static nuint ZSTD_sizeof_DDict(ZSTD_DDict_s* ddict) + { + if (ddict == null) + return 0; + return (nuint)sizeof(ZSTD_DDict_s) + (ddict->dictBuffer != null ? ddict->dictSize : 0); + } + + /*! ZSTD_getDictID_fromDDict() : + * Provides the dictID of the dictionary loaded into `ddict`. + * If @return == 0, the dictionary is not conformant to Zstandard specification, or empty. + * Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */ + public static uint ZSTD_getDictID_fromDDict(ZSTD_DDict_s* ddict) + { + if (ddict == null) + return 0; + return ddict->dictID; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDecompress.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDecompress.cs new file mode 100644 index 000000000..ab20f04c1 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDecompress.cs @@ -0,0 +1,3420 @@ +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /* Hash function to determine starting position of dict insertion within the table + * Returns an index between [0, hashSet->ddictPtrTableSize] + */ + private static nuint ZSTD_DDictHashSet_getIndex(ZSTD_DDictHashSet* hashSet, uint dictID) + { + ulong hash = ZSTD_XXH64(&dictID, sizeof(uint), 0); + return (nuint)(hash & hashSet->ddictPtrTableSize - 1); + } + + /* Adds DDict to a hashset without resizing it. + * If inserting a DDict with a dictID that already exists in the set, replaces the one in the set. + * Returns 0 if successful, or a zstd error code if something went wrong. + */ + private static nuint ZSTD_DDictHashSet_emplaceDDict( + ZSTD_DDictHashSet* hashSet, + ZSTD_DDict_s* ddict + ) + { + uint dictID = ZSTD_getDictID_fromDDict(ddict); + nuint idx = ZSTD_DDictHashSet_getIndex(hashSet, dictID); + nuint idxRangeMask = hashSet->ddictPtrTableSize - 1; + if (hashSet->ddictPtrCount == hashSet->ddictPtrTableSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + + while (hashSet->ddictPtrTable[idx] != null) + { + if (ZSTD_getDictID_fromDDict(hashSet->ddictPtrTable[idx]) == dictID) + { + hashSet->ddictPtrTable[idx] = ddict; + return 0; + } + + idx &= idxRangeMask; + idx++; + } + + hashSet->ddictPtrTable[idx] = ddict; + hashSet->ddictPtrCount++; + return 0; + } + + /* Expands hash table by factor of DDICT_HASHSET_RESIZE_FACTOR and + * rehashes all values, allocates new table, frees old table. + * Returns 0 on success, otherwise a zstd error code. + */ + private static nuint ZSTD_DDictHashSet_expand( + ZSTD_DDictHashSet* hashSet, + ZSTD_customMem customMem + ) + { + nuint newTableSize = hashSet->ddictPtrTableSize * 2; + ZSTD_DDict_s** newTable = (ZSTD_DDict_s**)ZSTD_customCalloc( + (nuint)sizeof(ZSTD_DDict_s*) * newTableSize, + customMem + ); + ZSTD_DDict_s** oldTable = hashSet->ddictPtrTable; + nuint oldTableSize = hashSet->ddictPtrTableSize; + nuint i; + if (newTable == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + hashSet->ddictPtrTable = newTable; + hashSet->ddictPtrTableSize = newTableSize; + hashSet->ddictPtrCount = 0; + for (i = 0; i < oldTableSize; ++i) + { + if (oldTable[i] != null) + { + nuint err_code = ZSTD_DDictHashSet_emplaceDDict(hashSet, oldTable[i]); + if (ERR_isError(err_code)) + { + return err_code; + } + } + } + + ZSTD_customFree(oldTable, customMem); + return 0; + } + + /* Fetches a DDict with the given dictID + * Returns the ZSTD_DDict* with the requested dictID. If it doesn't exist, then returns NULL. + */ + private static ZSTD_DDict_s* ZSTD_DDictHashSet_getDDict(ZSTD_DDictHashSet* hashSet, uint dictID) + { + nuint idx = ZSTD_DDictHashSet_getIndex(hashSet, dictID); + nuint idxRangeMask = hashSet->ddictPtrTableSize - 1; + for (; ; ) + { + nuint currDictID = ZSTD_getDictID_fromDDict(hashSet->ddictPtrTable[idx]); + if (currDictID == dictID || currDictID == 0) + { + break; + } + else + { + idx &= idxRangeMask; + idx++; + } + } + + return hashSet->ddictPtrTable[idx]; + } + + /* Allocates space for and returns a ddict hash set + * The hash set's ZSTD_DDict* table has all values automatically set to NULL to begin with. + * Returns NULL if allocation failed. + */ + private static ZSTD_DDictHashSet* ZSTD_createDDictHashSet(ZSTD_customMem customMem) + { + ZSTD_DDictHashSet* ret = (ZSTD_DDictHashSet*)ZSTD_customMalloc( + (nuint)sizeof(ZSTD_DDictHashSet), + customMem + ); + if (ret == null) + return null; + ret->ddictPtrTable = (ZSTD_DDict_s**)ZSTD_customCalloc( + (nuint)(64 * sizeof(ZSTD_DDict_s*)), + customMem + ); + if (ret->ddictPtrTable == null) + { + ZSTD_customFree(ret, customMem); + return null; + } + + ret->ddictPtrTableSize = 64; + ret->ddictPtrCount = 0; + return ret; + } + + /* Frees the table of ZSTD_DDict* within a hashset, then frees the hashset itself. + * Note: The ZSTD_DDict* within the table are NOT freed. + */ + private static void ZSTD_freeDDictHashSet(ZSTD_DDictHashSet* hashSet, ZSTD_customMem customMem) + { + if (hashSet != null && hashSet->ddictPtrTable != null) + { + ZSTD_customFree(hashSet->ddictPtrTable, customMem); + } + + if (hashSet != null) + { + ZSTD_customFree(hashSet, customMem); + } + } + + /* Public function: Adds a DDict into the ZSTD_DDictHashSet, possibly triggering a resize of the hash set. + * Returns 0 on success, or a ZSTD error. + */ + private static nuint ZSTD_DDictHashSet_addDDict( + ZSTD_DDictHashSet* hashSet, + ZSTD_DDict_s* ddict, + ZSTD_customMem customMem + ) + { + if (hashSet->ddictPtrCount * 4 / hashSet->ddictPtrTableSize * 3 != 0) + { + nuint err_code = ZSTD_DDictHashSet_expand(hashSet, customMem); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_DDictHashSet_emplaceDDict(hashSet, ddict); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return 0; + } + + /*-************************************************************* + * Context management + ***************************************************************/ + public static nuint ZSTD_sizeof_DCtx(ZSTD_DCtx_s* dctx) + { + if (dctx == null) + return 0; + return (nuint)sizeof(ZSTD_DCtx_s) + + ZSTD_sizeof_DDict(dctx->ddictLocal) + + dctx->inBuffSize + + dctx->outBuffSize; + } + + public static nuint ZSTD_estimateDCtxSize() + { + return (nuint)sizeof(ZSTD_DCtx_s); + } + + private static nuint ZSTD_startingInputLength(ZSTD_format_e format) + { + nuint startingInputLength = (nuint)(format == ZSTD_format_e.ZSTD_f_zstd1 ? 5 : 1); + assert( + format == ZSTD_format_e.ZSTD_f_zstd1 || format == ZSTD_format_e.ZSTD_f_zstd1_magicless + ); + return startingInputLength; + } + + private static void ZSTD_DCtx_resetParameters(ZSTD_DCtx_s* dctx) + { + assert(dctx->streamStage == ZSTD_dStreamStage.zdss_init); + dctx->format = ZSTD_format_e.ZSTD_f_zstd1; + dctx->maxWindowSize = ((uint)1 << 27) + 1; + dctx->outBufferMode = ZSTD_bufferMode_e.ZSTD_bm_buffered; + dctx->forceIgnoreChecksum = ZSTD_forceIgnoreChecksum_e.ZSTD_d_validateChecksum; + dctx->refMultipleDDicts = ZSTD_refMultipleDDicts_e.ZSTD_rmd_refSingleDDict; + dctx->disableHufAsm = 0; + dctx->maxBlockSizeParam = 0; + } + + private static void ZSTD_initDCtx_internal(ZSTD_DCtx_s* dctx) + { + dctx->staticSize = 0; + dctx->ddict = null; + dctx->ddictLocal = null; + dctx->dictEnd = null; + dctx->ddictIsCold = 0; + dctx->dictUses = ZSTD_dictUses_e.ZSTD_dont_use; + dctx->inBuff = null; + dctx->inBuffSize = 0; + dctx->outBuffSize = 0; + dctx->streamStage = ZSTD_dStreamStage.zdss_init; + dctx->noForwardProgress = 0; + dctx->oversizedDuration = 0; + dctx->isFrameDecompression = 1; + dctx->ddictSet = null; + ZSTD_DCtx_resetParameters(dctx); + } + + public static ZSTD_DCtx_s* ZSTD_initStaticDCtx(void* workspace, nuint workspaceSize) + { + ZSTD_DCtx_s* dctx = (ZSTD_DCtx_s*)workspace; + if (((nuint)workspace & 7) != 0) + return null; + if (workspaceSize < (nuint)sizeof(ZSTD_DCtx_s)) + return null; + ZSTD_initDCtx_internal(dctx); + dctx->staticSize = workspaceSize; + dctx->inBuff = (sbyte*)(dctx + 1); + return dctx; + } + + private static ZSTD_DCtx_s* ZSTD_createDCtx_internal(ZSTD_customMem customMem) + { + if (((customMem.customAlloc == null ? 1 : 0) ^ (customMem.customFree == null ? 1 : 0)) != 0) + return null; + { + ZSTD_DCtx_s* dctx = (ZSTD_DCtx_s*)ZSTD_customMalloc( + (nuint)sizeof(ZSTD_DCtx_s), + customMem + ); + if (dctx == null) + return null; + dctx->customMem = customMem; + ZSTD_initDCtx_internal(dctx); + return dctx; + } + } + + public static ZSTD_DCtx_s* ZSTD_createDCtx_advanced(ZSTD_customMem customMem) + { + return ZSTD_createDCtx_internal(customMem); + } + + public static ZSTD_DCtx_s* ZSTD_createDCtx() + { + return ZSTD_createDCtx_internal(ZSTD_defaultCMem); + } + + private static void ZSTD_clearDict(ZSTD_DCtx_s* dctx) + { + ZSTD_freeDDict(dctx->ddictLocal); + dctx->ddictLocal = null; + dctx->ddict = null; + dctx->dictUses = ZSTD_dictUses_e.ZSTD_dont_use; + } + + public static nuint ZSTD_freeDCtx(ZSTD_DCtx_s* dctx) + { + if (dctx == null) + return 0; + if (dctx->staticSize != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + { + ZSTD_customMem cMem = dctx->customMem; + ZSTD_clearDict(dctx); + ZSTD_customFree(dctx->inBuff, cMem); + dctx->inBuff = null; + if (dctx->ddictSet != null) + { + ZSTD_freeDDictHashSet(dctx->ddictSet, cMem); + dctx->ddictSet = null; + } + + ZSTD_customFree(dctx, cMem); + return 0; + } + } + + /* no longer useful */ + public static void ZSTD_copyDCtx(ZSTD_DCtx_s* dstDCtx, ZSTD_DCtx_s* srcDCtx) + { + nuint toCopy = (nuint)((sbyte*)&dstDCtx->inBuff - (sbyte*)dstDCtx); + memcpy(dstDCtx, srcDCtx, (uint)toCopy); + } + + /* Given a dctx with a digested frame params, re-selects the correct ZSTD_DDict based on + * the requested dict ID from the frame. If there exists a reference to the correct ZSTD_DDict, then + * accordingly sets the ddict to be used to decompress the frame. + * + * If no DDict is found, then no action is taken, and the ZSTD_DCtx::ddict remains as-is. + * + * ZSTD_d_refMultipleDDicts must be enabled for this function to be called. + */ + private static void ZSTD_DCtx_selectFrameDDict(ZSTD_DCtx_s* dctx) + { + assert(dctx->refMultipleDDicts != default && dctx->ddictSet != null); + if (dctx->ddict != null) + { + ZSTD_DDict_s* frameDDict = ZSTD_DDictHashSet_getDDict( + dctx->ddictSet, + dctx->fParams.dictID + ); + if (frameDDict != null) + { + ZSTD_clearDict(dctx); + dctx->dictID = dctx->fParams.dictID; + dctx->ddict = frameDDict; + dctx->dictUses = ZSTD_dictUses_e.ZSTD_use_indefinitely; + } + } + } + + /*! ZSTD_isFrame() : + * Tells if the content of `buffer` starts with a valid Frame Identifier. + * Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0. + * Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled. + * Note 3 : Skippable Frame Identifiers are considered valid. */ + public static uint ZSTD_isFrame(void* buffer, nuint size) + { + if (size < 4) + return 0; + { + uint magic = MEM_readLE32(buffer); + if (magic == 0xFD2FB528) + return 1; + if ((magic & 0xFFFFFFF0) == 0x184D2A50) + return 1; + } + + return 0; + } + + /*! ZSTD_isSkippableFrame() : + * Tells if the content of `buffer` starts with a valid Frame Identifier for a skippable frame. + * Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0. + */ + public static uint ZSTD_isSkippableFrame(void* buffer, nuint size) + { + if (size < 4) + return 0; + { + uint magic = MEM_readLE32(buffer); + if ((magic & 0xFFFFFFF0) == 0x184D2A50) + return 1; + } + + return 0; + } + + /** ZSTD_frameHeaderSize_internal() : + * srcSize must be large enough to reach header size fields. + * note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless. + * @return : size of the Frame Header + * or an error code, which can be tested with ZSTD_isError() */ + private static nuint ZSTD_frameHeaderSize_internal( + void* src, + nuint srcSize, + ZSTD_format_e format + ) + { + nuint minInputSize = ZSTD_startingInputLength(format); + if (srcSize < minInputSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + { + byte fhd = ((byte*)src)[minInputSize - 1]; + uint dictID = (uint)(fhd & 3); + uint singleSegment = (uint)(fhd >> 5 & 1); + uint fcsId = (uint)(fhd >> 6); + return minInputSize + + (nuint)(singleSegment == 0 ? 1 : 0) + + ZSTD_did_fieldSize[dictID] + + ZSTD_fcs_fieldSize[fcsId] + + (nuint)(singleSegment != 0 && fcsId == 0 ? 1 : 0); + } + } + + /** ZSTD_frameHeaderSize() : + * srcSize must be >= ZSTD_frameHeaderSize_prefix. + * @return : size of the Frame Header, + * or an error code (if srcSize is too small) */ + public static nuint ZSTD_frameHeaderSize(void* src, nuint srcSize) + { + return ZSTD_frameHeaderSize_internal(src, srcSize, ZSTD_format_e.ZSTD_f_zstd1); + } + + /** ZSTD_getFrameHeader_advanced() : + * decode Frame Header, or require larger `srcSize`. + * note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless + * @return : 0, `zfhPtr` is correctly filled, + * >0, `srcSize` is too small, value is wanted `srcSize` amount, + ** or an error code, which can be tested using ZSTD_isError() */ + public static nuint ZSTD_getFrameHeader_advanced( + ZSTD_frameHeader* zfhPtr, + void* src, + nuint srcSize, + ZSTD_format_e format + ) + { + byte* ip = (byte*)src; + nuint minInputSize = ZSTD_startingInputLength(format); + if (srcSize > 0) + { + if (src == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + } + + if (srcSize < minInputSize) + { + if (srcSize > 0 && format != ZSTD_format_e.ZSTD_f_zstd1_magicless) + { + /* when receiving less than @minInputSize bytes, + * control these bytes at least correspond to a supported magic number + * in order to error out early if they don't. + **/ + nuint toCopy = 4 < srcSize ? 4 : srcSize; + byte* hbuf = stackalloc byte[4]; + MEM_writeLE32(hbuf, 0xFD2FB528); + assert(src != null); + memcpy(hbuf, src, (uint)toCopy); + if (MEM_readLE32(hbuf) != 0xFD2FB528) + { + MEM_writeLE32(hbuf, 0x184D2A50); + memcpy(hbuf, src, (uint)toCopy); + if ((MEM_readLE32(hbuf) & 0xFFFFFFF0) != 0x184D2A50) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_prefix_unknown)); + } + } + } + + return minInputSize; + } + + *zfhPtr = new ZSTD_frameHeader(); + if (format != ZSTD_format_e.ZSTD_f_zstd1_magicless && MEM_readLE32(src) != 0xFD2FB528) + { + if ((MEM_readLE32(src) & 0xFFFFFFF0) == 0x184D2A50) + { + if (srcSize < 8) + return 8; + *zfhPtr = new ZSTD_frameHeader + { + frameType = ZSTD_frameType_e.ZSTD_skippableFrame, + dictID = MEM_readLE32(src) - 0x184D2A50, + headerSize = 8, + frameContentSize = MEM_readLE32((sbyte*)src + 4), + }; + return 0; + } + + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_prefix_unknown)); + } + + { + nuint fhsize = ZSTD_frameHeaderSize_internal(src, srcSize, format); + if (srcSize < fhsize) + return fhsize; + zfhPtr->headerSize = (uint)fhsize; + } + + { + byte fhdByte = ip[minInputSize - 1]; + nuint pos = minInputSize; + uint dictIDSizeCode = (uint)(fhdByte & 3); + uint checksumFlag = (uint)(fhdByte >> 2 & 1); + uint singleSegment = (uint)(fhdByte >> 5 & 1); + uint fcsID = (uint)(fhdByte >> 6); + ulong windowSize = 0; + uint dictID = 0; + ulong frameContentSize = unchecked(0UL - 1); + if ((fhdByte & 0x08) != 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_frameParameter_unsupported) + ); + } + + if (singleSegment == 0) + { + byte wlByte = ip[pos++]; + uint windowLog = (uint)((wlByte >> 3) + 10); + if (windowLog > (uint)(sizeof(nuint) == 4 ? 30 : 31)) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_frameParameter_windowTooLarge) + ); + } + + windowSize = 1UL << (int)windowLog; + windowSize += (windowSize >> 3) * (ulong)(wlByte & 7); + } + + switch (dictIDSizeCode) + { + default: + assert(0 != 0); + goto case 0; + case 0: + break; + case 1: + dictID = ip[pos]; + pos++; + break; + case 2: + dictID = MEM_readLE16(ip + pos); + pos += 2; + break; + case 3: + dictID = MEM_readLE32(ip + pos); + pos += 4; + break; + } + + switch (fcsID) + { + default: + assert(0 != 0); + goto case 0; + case 0: + if (singleSegment != 0) + frameContentSize = ip[pos]; + break; + case 1: + frameContentSize = (ulong)(MEM_readLE16(ip + pos) + 256); + break; + case 2: + frameContentSize = MEM_readLE32(ip + pos); + break; + case 3: + frameContentSize = MEM_readLE64(ip + pos); + break; + } + + if (singleSegment != 0) + windowSize = frameContentSize; + zfhPtr->frameType = ZSTD_frameType_e.ZSTD_frame; + zfhPtr->frameContentSize = frameContentSize; + zfhPtr->windowSize = windowSize; + zfhPtr->blockSizeMax = (uint)(windowSize < 1 << 17 ? windowSize : 1 << 17); + zfhPtr->dictID = dictID; + zfhPtr->checksumFlag = checksumFlag; + } + + return 0; + } + + /** ZSTD_getFrameHeader() : + * decode Frame Header, or require larger `srcSize`. + * note : this function does not consume input, it only reads it. + * @return : 0, `zfhPtr` is correctly filled, + * >0, `srcSize` is too small, value is wanted `srcSize` amount, + * or an error code, which can be tested using ZSTD_isError() */ + public static nuint ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, void* src, nuint srcSize) + { + return ZSTD_getFrameHeader_advanced(zfhPtr, src, srcSize, ZSTD_format_e.ZSTD_f_zstd1); + } + + /** ZSTD_getFrameContentSize() : + * compatible with legacy mode + * @return : decompressed size of the single frame pointed to be `src` if known, otherwise + * - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined + * - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) */ + public static ulong ZSTD_getFrameContentSize(void* src, nuint srcSize) + { + ZSTD_frameHeader zfh; + if (ZSTD_getFrameHeader(&zfh, src, srcSize) != 0) + return unchecked(0UL - 2); + if (zfh.frameType == ZSTD_frameType_e.ZSTD_skippableFrame) + { + return 0; + } + else + { + return zfh.frameContentSize; + } + } + + private static nuint readSkippableFrameSize(void* src, nuint srcSize) + { + const nuint skippableHeaderSize = 8; + uint sizeU32; + if (srcSize < 8) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + sizeU32 = MEM_readLE32((byte*)src + 4); + if (sizeU32 + 8 < sizeU32) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_frameParameter_unsupported)); + } + + { + nuint skippableSize = skippableHeaderSize + sizeU32; + if (skippableSize > srcSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + return skippableSize; + } + } + + /*! ZSTD_readSkippableFrame() : + * Retrieves content of a skippable frame, and writes it to dst buffer. + * + * The parameter magicVariant will receive the magicVariant that was supplied when the frame was written, + * i.e. magicNumber - ZSTD_MAGIC_SKIPPABLE_START. This can be NULL if the caller is not interested + * in the magicVariant. + * + * Returns an error if destination buffer is not large enough, or if this is not a valid skippable frame. + * + * @return : number of bytes written or a ZSTD error. + */ + public static nuint ZSTD_readSkippableFrame( + void* dst, + nuint dstCapacity, + uint* magicVariant, + void* src, + nuint srcSize + ) + { + if (srcSize < 8) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + { + uint magicNumber = MEM_readLE32(src); + nuint skippableFrameSize = readSkippableFrameSize(src, srcSize); + nuint skippableContentSize = skippableFrameSize - 8; + if (ZSTD_isSkippableFrame(src, srcSize) == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_frameParameter_unsupported) + ); + } + + if (skippableFrameSize < 8 || skippableFrameSize > srcSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if (skippableContentSize > dstCapacity) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (skippableContentSize > 0 && dst != null) + memcpy(dst, (byte*)src + 8, (uint)skippableContentSize); + if (magicVariant != null) + *magicVariant = magicNumber - 0x184D2A50; + return skippableContentSize; + } + } + + /** ZSTD_findDecompressedSize() : + * `srcSize` must be the exact length of some number of ZSTD compressed and/or + * skippable frames + * note: compatible with legacy mode + * @return : decompressed size of the frames contained */ + public static ulong ZSTD_findDecompressedSize(void* src, nuint srcSize) + { + ulong totalDstSize = 0; + while (srcSize >= ZSTD_startingInputLength(ZSTD_format_e.ZSTD_f_zstd1)) + { + uint magicNumber = MEM_readLE32(src); + if ((magicNumber & 0xFFFFFFF0) == 0x184D2A50) + { + nuint skippableSize = readSkippableFrameSize(src, srcSize); + if (ERR_isError(skippableSize)) + return unchecked(0UL - 2); + assert(skippableSize <= srcSize); + src = (byte*)src + skippableSize; + srcSize -= skippableSize; + continue; + } + + { + ulong fcs = ZSTD_getFrameContentSize(src, srcSize); + if (fcs >= unchecked(0UL - 2)) + return fcs; + if (totalDstSize + fcs < totalDstSize) + return unchecked(0UL - 2); + totalDstSize += fcs; + } + + { + nuint frameSrcSize = ZSTD_findFrameCompressedSize(src, srcSize); + if (ERR_isError(frameSrcSize)) + return unchecked(0UL - 2); + assert(frameSrcSize <= srcSize); + src = (byte*)src + frameSrcSize; + srcSize -= frameSrcSize; + } + } + + if (srcSize != 0) + return unchecked(0UL - 2); + return totalDstSize; + } + + /** ZSTD_getDecompressedSize() : + * compatible with legacy mode + * @return : decompressed size if known, 0 otherwise + note : 0 can mean any of the following : + - frame content is empty + - decompressed size field is not present in frame header + - frame header unknown / not supported + - frame header not complete (`srcSize` too small) */ + public static ulong ZSTD_getDecompressedSize(void* src, nuint srcSize) + { + ulong ret = ZSTD_getFrameContentSize(src, srcSize); + return ret >= unchecked(0UL - 2) ? 0 : ret; + } + + /** ZSTD_decodeFrameHeader() : + * `headerSize` must be the size provided by ZSTD_frameHeaderSize(). + * If multiple DDict references are enabled, also will choose the correct DDict to use. + * @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */ + private static nuint ZSTD_decodeFrameHeader(ZSTD_DCtx_s* dctx, void* src, nuint headerSize) + { + nuint result = ZSTD_getFrameHeader_advanced(&dctx->fParams, src, headerSize, dctx->format); + if (ERR_isError(result)) + return result; + if (result > 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if ( + dctx->refMultipleDDicts == ZSTD_refMultipleDDicts_e.ZSTD_rmd_refMultipleDDicts + && dctx->ddictSet != null + ) + { + ZSTD_DCtx_selectFrameDDict(dctx); + } + + if (dctx->fParams.dictID != 0 && dctx->dictID != dctx->fParams.dictID) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_wrong)); + } + + dctx->validateChecksum = (uint)( + dctx->fParams.checksumFlag != 0 && dctx->forceIgnoreChecksum == default ? 1 : 0 + ); + if (dctx->validateChecksum != 0) + ZSTD_XXH64_reset(&dctx->xxhState, 0); + dctx->processedCSize += headerSize; + return 0; + } + + private static ZSTD_frameSizeInfo ZSTD_errorFrameSizeInfo(nuint ret) + { + ZSTD_frameSizeInfo frameSizeInfo; + System.Runtime.CompilerServices.Unsafe.SkipInit(out frameSizeInfo); + frameSizeInfo.compressedSize = ret; + frameSizeInfo.decompressedBound = unchecked(0UL - 2); + return frameSizeInfo; + } + + private static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo( + void* src, + nuint srcSize, + ZSTD_format_e format + ) + { + ZSTD_frameSizeInfo frameSizeInfo; + frameSizeInfo = new ZSTD_frameSizeInfo(); + if ( + format == ZSTD_format_e.ZSTD_f_zstd1 + && srcSize >= 8 + && (MEM_readLE32(src) & 0xFFFFFFF0) == 0x184D2A50 + ) + { + frameSizeInfo.compressedSize = readSkippableFrameSize(src, srcSize); + assert( + ERR_isError(frameSizeInfo.compressedSize) || frameSizeInfo.compressedSize <= srcSize + ); + return frameSizeInfo; + } + else + { + byte* ip = (byte*)src; + byte* ipstart = ip; + nuint remainingSize = srcSize; + nuint nbBlocks = 0; + ZSTD_frameHeader zfh; + { + nuint ret = ZSTD_getFrameHeader_advanced(&zfh, src, srcSize, format); + if (ERR_isError(ret)) + return ZSTD_errorFrameSizeInfo(ret); + if (ret > 0) + return ZSTD_errorFrameSizeInfo( + unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)) + ); + } + + ip += zfh.headerSize; + remainingSize -= zfh.headerSize; + while (true) + { + blockProperties_t blockProperties; + nuint cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties); + if (ERR_isError(cBlockSize)) + return ZSTD_errorFrameSizeInfo(cBlockSize); + if (ZSTD_blockHeaderSize + cBlockSize > remainingSize) + return ZSTD_errorFrameSizeInfo( + unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)) + ); + ip += ZSTD_blockHeaderSize + cBlockSize; + remainingSize -= ZSTD_blockHeaderSize + cBlockSize; + nbBlocks++; + if (blockProperties.lastBlock != 0) + break; + } + + if (zfh.checksumFlag != 0) + { + if (remainingSize < 4) + return ZSTD_errorFrameSizeInfo( + unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)) + ); + ip += 4; + } + + frameSizeInfo.nbBlocks = nbBlocks; + frameSizeInfo.compressedSize = (nuint)(ip - ipstart); + frameSizeInfo.decompressedBound = + zfh.frameContentSize != unchecked(0UL - 1) + ? zfh.frameContentSize + : (ulong)nbBlocks * zfh.blockSizeMax; + return frameSizeInfo; + } + } + + private static nuint ZSTD_findFrameCompressedSize_advanced( + void* src, + nuint srcSize, + ZSTD_format_e format + ) + { + ZSTD_frameSizeInfo frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize, format); + return frameSizeInfo.compressedSize; + } + + /** ZSTD_findFrameCompressedSize() : + * See docs in zstd.h + * Note: compatible with legacy mode */ + public static nuint ZSTD_findFrameCompressedSize(void* src, nuint srcSize) + { + return ZSTD_findFrameCompressedSize_advanced(src, srcSize, ZSTD_format_e.ZSTD_f_zstd1); + } + + /** ZSTD_decompressBound() : + * compatible with legacy mode + * `src` must point to the start of a ZSTD frame or a skippable frame + * `srcSize` must be at least as large as the frame contained + * @return : the maximum decompressed size of the compressed source + */ + public static ulong ZSTD_decompressBound(void* src, nuint srcSize) + { + ulong bound = 0; + while (srcSize > 0) + { + ZSTD_frameSizeInfo frameSizeInfo = ZSTD_findFrameSizeInfo( + src, + srcSize, + ZSTD_format_e.ZSTD_f_zstd1 + ); + nuint compressedSize = frameSizeInfo.compressedSize; + ulong decompressedBound = frameSizeInfo.decompressedBound; + if (ERR_isError(compressedSize) || decompressedBound == unchecked(0UL - 2)) + return unchecked(0UL - 2); + assert(srcSize >= compressedSize); + src = (byte*)src + compressedSize; + srcSize -= compressedSize; + bound += decompressedBound; + } + + return bound; + } + + /*! ZSTD_decompressionMargin() : + * Zstd supports in-place decompression, where the input and output buffers overlap. + * In this case, the output buffer must be at least (Margin + Output_Size) bytes large, + * and the input buffer must be at the end of the output buffer. + * + * _______________________ Output Buffer ________________________ + * | | + * | ____ Input Buffer ____| + * | | | + * v v v + * |---------------------------------------|-----------|----------| + * ^ ^ ^ + * |___________________ Output_Size ___________________|_ Margin _| + * + * NOTE: See also ZSTD_DECOMPRESSION_MARGIN(). + * NOTE: This applies only to single-pass decompression through ZSTD_decompress() or + * ZSTD_decompressDCtx(). + * NOTE: This function supports multi-frame input. + * + * @param src The compressed frame(s) + * @param srcSize The size of the compressed frame(s) + * @returns The decompression margin or an error that can be checked with ZSTD_isError(). + */ + public static nuint ZSTD_decompressionMargin(void* src, nuint srcSize) + { + nuint margin = 0; + uint maxBlockSize = 0; + while (srcSize > 0) + { + ZSTD_frameSizeInfo frameSizeInfo = ZSTD_findFrameSizeInfo( + src, + srcSize, + ZSTD_format_e.ZSTD_f_zstd1 + ); + nuint compressedSize = frameSizeInfo.compressedSize; + ulong decompressedBound = frameSizeInfo.decompressedBound; + ZSTD_frameHeader zfh; + { + nuint err_code = ZSTD_getFrameHeader(&zfh, src, srcSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (ERR_isError(compressedSize) || decompressedBound == unchecked(0UL - 2)) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + if (zfh.frameType == ZSTD_frameType_e.ZSTD_frame) + { + margin += zfh.headerSize; + margin += (nuint)(zfh.checksumFlag != 0 ? 4 : 0); + margin += 3 * frameSizeInfo.nbBlocks; + maxBlockSize = maxBlockSize > zfh.blockSizeMax ? maxBlockSize : zfh.blockSizeMax; + } + else + { + assert(zfh.frameType == ZSTD_frameType_e.ZSTD_skippableFrame); + margin += compressedSize; + } + + assert(srcSize >= compressedSize); + src = (byte*)src + compressedSize; + srcSize -= compressedSize; + } + + margin += maxBlockSize; + return margin; + } + + /** ZSTD_insertBlock() : + * insert `src` block into `dctx` history. Useful to track uncompressed blocks. */ + public static nuint ZSTD_insertBlock(ZSTD_DCtx_s* dctx, void* blockStart, nuint blockSize) + { + ZSTD_checkContinuity(dctx, blockStart, blockSize); + dctx->previousDstEnd = (sbyte*)blockStart + blockSize; + return blockSize; + } + + private static nuint ZSTD_copyRawBlock(void* dst, nuint dstCapacity, void* src, nuint srcSize) + { + if (srcSize > dstCapacity) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (dst == null) + { + if (srcSize == 0) + return 0; + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstBuffer_null)); + } + + memmove(dst, src, srcSize); + return srcSize; + } + + private static nuint ZSTD_setRleBlock(void* dst, nuint dstCapacity, byte b, nuint regenSize) + { + if (regenSize > dstCapacity) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (dst == null) + { + if (regenSize == 0) + return 0; + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstBuffer_null)); + } + + memset(dst, b, (uint)regenSize); + return regenSize; + } + + private static void ZSTD_DCtx_trace_end( + ZSTD_DCtx_s* dctx, + ulong uncompressedSize, + ulong compressedSize, + int streaming + ) { } + + /*! ZSTD_decompressFrame() : + * @dctx must be properly initialized + * will update *srcPtr and *srcSizePtr, + * to make *srcPtr progress by one frame. */ + private static nuint ZSTD_decompressFrame( + ZSTD_DCtx_s* dctx, + void* dst, + nuint dstCapacity, + void** srcPtr, + nuint* srcSizePtr + ) + { + byte* istart = (byte*)*srcPtr; + byte* ip = istart; + byte* ostart = (byte*)dst; + byte* oend = dstCapacity != 0 ? ostart + dstCapacity : ostart; + byte* op = ostart; + nuint remainingSrcSize = *srcSizePtr; + if ( + remainingSrcSize + < (nuint)(dctx->format == ZSTD_format_e.ZSTD_f_zstd1 ? 6 : 2) + ZSTD_blockHeaderSize + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + { + nuint frameHeaderSize = ZSTD_frameHeaderSize_internal( + ip, + (nuint)(dctx->format == ZSTD_format_e.ZSTD_f_zstd1 ? 5 : 1), + dctx->format + ); + if (ERR_isError(frameHeaderSize)) + return frameHeaderSize; + if (remainingSrcSize < frameHeaderSize + ZSTD_blockHeaderSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + { + nuint err_code = ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + ip += frameHeaderSize; + remainingSrcSize -= frameHeaderSize; + } + + if (dctx->maxBlockSizeParam != 0) + dctx->fParams.blockSizeMax = + dctx->fParams.blockSizeMax < (uint)dctx->maxBlockSizeParam + ? dctx->fParams.blockSizeMax + : (uint)dctx->maxBlockSizeParam; + while (true) + { + byte* oBlockEnd = oend; + nuint decodedSize; + blockProperties_t blockProperties; + nuint cBlockSize = ZSTD_getcBlockSize(ip, remainingSrcSize, &blockProperties); + if (ERR_isError(cBlockSize)) + return cBlockSize; + ip += ZSTD_blockHeaderSize; + remainingSrcSize -= ZSTD_blockHeaderSize; + if (cBlockSize > remainingSrcSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if (ip >= op && ip < oBlockEnd) + { + oBlockEnd = op + (ip - op); + } + + switch (blockProperties.blockType) + { + case blockType_e.bt_compressed: + assert(dctx->isFrameDecompression == 1); + decodedSize = ZSTD_decompressBlock_internal( + dctx, + op, + (nuint)(oBlockEnd - op), + ip, + cBlockSize, + streaming_operation.not_streaming + ); + break; + case blockType_e.bt_raw: + decodedSize = ZSTD_copyRawBlock(op, (nuint)(oend - op), ip, cBlockSize); + break; + case blockType_e.bt_rle: + decodedSize = ZSTD_setRleBlock( + op, + (nuint)(oBlockEnd - op), + *ip, + blockProperties.origSize + ); + break; + case blockType_e.bt_reserved: + default: + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + { + nuint err_code = decodedSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (dctx->validateChecksum != 0) + { + ZSTD_XXH64_update(&dctx->xxhState, op, decodedSize); + } + + if (decodedSize != 0) + { + op += decodedSize; + } + + assert(ip != null); + ip += cBlockSize; + remainingSrcSize -= cBlockSize; + if (blockProperties.lastBlock != 0) + break; + } + + if (dctx->fParams.frameContentSize != unchecked(0UL - 1)) + { + if ((ulong)(op - ostart) != dctx->fParams.frameContentSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + } + + if (dctx->fParams.checksumFlag != 0) + { + if (remainingSrcSize < 4) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_checksum_wrong)); + } + + if (dctx->forceIgnoreChecksum == default) + { + uint checkCalc = (uint)ZSTD_XXH64_digest(&dctx->xxhState); + uint checkRead; + checkRead = MEM_readLE32(ip); + if (checkRead != checkCalc) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_checksum_wrong)); + } + } + + ip += 4; + remainingSrcSize -= 4; + } + + ZSTD_DCtx_trace_end(dctx, (ulong)(op - ostart), (ulong)(ip - istart), 0); + *srcPtr = ip; + *srcSizePtr = remainingSrcSize; + return (nuint)(op - ostart); + } + + private static nuint ZSTD_decompressMultiFrame( + ZSTD_DCtx_s* dctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + void* dict, + nuint dictSize, + ZSTD_DDict_s* ddict + ) + { + void* dststart = dst; + int moreThan1Frame = 0; + assert(dict == null || ddict == null); + if (ddict != null) + { + dict = ZSTD_DDict_dictContent(ddict); + dictSize = ZSTD_DDict_dictSize(ddict); + } + + while (srcSize >= ZSTD_startingInputLength(dctx->format)) + { + if (dctx->format == ZSTD_format_e.ZSTD_f_zstd1 && srcSize >= 4) + { + uint magicNumber = MEM_readLE32(src); + if ((magicNumber & 0xFFFFFFF0) == 0x184D2A50) + { + /* skippable frame detected : skip it */ + nuint skippableSize = readSkippableFrameSize(src, srcSize); + { + nuint err_code = skippableSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(skippableSize <= srcSize); + src = (byte*)src + skippableSize; + srcSize -= skippableSize; + continue; + } + } + + if (ddict != null) + { + /* we were called from ZSTD_decompress_usingDDict */ + nuint err_code = ZSTD_decompressBegin_usingDDict(dctx, ddict); + if (ERR_isError(err_code)) + { + return err_code; + } + } + else + { + /* this will initialize correctly with no dict if dict == NULL, so + * use this in all cases but ddict */ + nuint err_code = ZSTD_decompressBegin_usingDict(dctx, dict, dictSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + ZSTD_checkContinuity(dctx, dst, dstCapacity); + { + nuint res = ZSTD_decompressFrame(dctx, dst, dstCapacity, &src, &srcSize); + if ( + ZSTD_getErrorCode(res) == ZSTD_ErrorCode.ZSTD_error_prefix_unknown + && moreThan1Frame == 1 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if (ERR_isError(res)) + return res; + assert(res <= dstCapacity); + if (res != 0) + dst = (byte*)dst + res; + dstCapacity -= res; + } + + moreThan1Frame = 1; + } + + if (srcSize != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + return (nuint)((byte*)dst - (byte*)dststart); + } + + /*! ZSTD_decompress_usingDict() : + * Decompression using a known Dictionary. + * Dictionary must be identical to the one used during compression. + * Note : This function loads the dictionary, resulting in significant startup delay. + * It's intended for a dictionary used only once. + * Note : When `dict == NULL || dictSize < 8` no dictionary is used. */ + public static nuint ZSTD_decompress_usingDict( + ZSTD_DCtx_s* dctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + void* dict, + nuint dictSize + ) + { + return ZSTD_decompressMultiFrame( + dctx, + dst, + dstCapacity, + src, + srcSize, + dict, + dictSize, + null + ); + } + + private static ZSTD_DDict_s* ZSTD_getDDict(ZSTD_DCtx_s* dctx) + { + switch (dctx->dictUses) + { + default: + assert(0 != 0); + goto case ZSTD_dictUses_e.ZSTD_dont_use; + case ZSTD_dictUses_e.ZSTD_dont_use: + ZSTD_clearDict(dctx); + return null; + case ZSTD_dictUses_e.ZSTD_use_indefinitely: + return dctx->ddict; + case ZSTD_dictUses_e.ZSTD_use_once: + dctx->dictUses = ZSTD_dictUses_e.ZSTD_dont_use; + return dctx->ddict; + } + } + + /*! ZSTD_decompressDCtx() : + * Same as ZSTD_decompress(), + * requires an allocated ZSTD_DCtx. + * Compatible with sticky parameters (see below). + */ + public static nuint ZSTD_decompressDCtx( + ZSTD_DCtx_s* dctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize + ) + { + return ZSTD_decompress_usingDDict( + dctx, + dst, + dstCapacity, + src, + srcSize, + ZSTD_getDDict(dctx) + ); + } + + /*! ZSTD_decompress() : + * `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames. + * Multiple compressed frames can be decompressed at once with this method. + * The result will be the concatenation of all decompressed frames, back to back. + * `dstCapacity` is an upper bound of originalSize to regenerate. + * First frame's decompressed size can be extracted using ZSTD_getFrameContentSize(). + * If maximum upper bound isn't known, prefer using streaming mode to decompress data. + * @return : the number of bytes decompressed into `dst` (<= `dstCapacity`), + * or an errorCode if it fails (which can be tested using ZSTD_isError()). */ + public static nuint ZSTD_decompress(void* dst, nuint dstCapacity, void* src, nuint srcSize) + { + nuint regenSize; + ZSTD_DCtx_s* dctx = ZSTD_createDCtx_internal(ZSTD_defaultCMem); + if (dctx == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize); + ZSTD_freeDCtx(dctx); + return regenSize; + } + + /*-************************************** + * Advanced Streaming Decompression API + * Bufferless and synchronous + ****************************************/ + public static nuint ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx_s* dctx) + { + return dctx->expected; + } + + /** + * Similar to ZSTD_nextSrcSizeToDecompress(), but when a block input can be streamed, we + * allow taking a partial block as the input. Currently only raw uncompressed blocks can + * be streamed. + * + * For blocks that can be streamed, this allows us to reduce the latency until we produce + * output, and avoid copying the input. + * + * @param inputSize - The total amount of input that the caller currently has. + */ + private static nuint ZSTD_nextSrcSizeToDecompressWithInputSize( + ZSTD_DCtx_s* dctx, + nuint inputSize + ) + { + if ( + !( + dctx->stage == ZSTD_dStage.ZSTDds_decompressBlock + || dctx->stage == ZSTD_dStage.ZSTDds_decompressLastBlock + ) + ) + return dctx->expected; + if (dctx->bType != blockType_e.bt_raw) + return dctx->expected; + return inputSize <= 1 ? 1 + : inputSize <= dctx->expected ? inputSize + : dctx->expected; + } + + public static ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx_s* dctx) + { + switch (dctx->stage) + { + default: + assert(0 != 0); + goto case ZSTD_dStage.ZSTDds_getFrameHeaderSize; + case ZSTD_dStage.ZSTDds_getFrameHeaderSize: + case ZSTD_dStage.ZSTDds_decodeFrameHeader: + return ZSTD_nextInputType_e.ZSTDnit_frameHeader; + case ZSTD_dStage.ZSTDds_decodeBlockHeader: + return ZSTD_nextInputType_e.ZSTDnit_blockHeader; + case ZSTD_dStage.ZSTDds_decompressBlock: + return ZSTD_nextInputType_e.ZSTDnit_block; + case ZSTD_dStage.ZSTDds_decompressLastBlock: + return ZSTD_nextInputType_e.ZSTDnit_lastBlock; + case ZSTD_dStage.ZSTDds_checkChecksum: + return ZSTD_nextInputType_e.ZSTDnit_checksum; + case ZSTD_dStage.ZSTDds_decodeSkippableHeader: + case ZSTD_dStage.ZSTDds_skipFrame: + return ZSTD_nextInputType_e.ZSTDnit_skippableFrame; + } + } + + private static int ZSTD_isSkipFrame(ZSTD_DCtx_s* dctx) + { + return dctx->stage == ZSTD_dStage.ZSTDds_skipFrame ? 1 : 0; + } + + /** ZSTD_decompressContinue() : + * srcSize : must be the exact nb of bytes expected (see ZSTD_nextSrcSizeToDecompress()) + * @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity) + * or an error code, which can be tested using ZSTD_isError() */ + public static nuint ZSTD_decompressContinue( + ZSTD_DCtx_s* dctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize + ) + { + if (srcSize != ZSTD_nextSrcSizeToDecompressWithInputSize(dctx, srcSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + ZSTD_checkContinuity(dctx, dst, dstCapacity); + dctx->processedCSize += srcSize; + switch (dctx->stage) + { + case ZSTD_dStage.ZSTDds_getFrameHeaderSize: + assert(src != null); + if (dctx->format == ZSTD_format_e.ZSTD_f_zstd1) + { + assert(srcSize >= 4); + if ((MEM_readLE32(src) & 0xFFFFFFF0) == 0x184D2A50) + { + memcpy(dctx->headerBuffer, src, (uint)srcSize); + dctx->expected = 8 - srcSize; + dctx->stage = ZSTD_dStage.ZSTDds_decodeSkippableHeader; + return 0; + } + } + + dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format); + if (ERR_isError(dctx->headerSize)) + return dctx->headerSize; + memcpy(dctx->headerBuffer, src, (uint)srcSize); + dctx->expected = dctx->headerSize - srcSize; + dctx->stage = ZSTD_dStage.ZSTDds_decodeFrameHeader; + return 0; + case ZSTD_dStage.ZSTDds_decodeFrameHeader: + assert(src != null); + memcpy(dctx->headerBuffer + (dctx->headerSize - srcSize), src, (uint)srcSize); + + { + nuint err_code = ZSTD_decodeFrameHeader( + dctx, + dctx->headerBuffer, + dctx->headerSize + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + dctx->expected = ZSTD_blockHeaderSize; + dctx->stage = ZSTD_dStage.ZSTDds_decodeBlockHeader; + return 0; + case ZSTD_dStage.ZSTDds_decodeBlockHeader: + { + blockProperties_t bp; + nuint cBlockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp); + if (ERR_isError(cBlockSize)) + return cBlockSize; + if (cBlockSize > dctx->fParams.blockSizeMax) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + dctx->expected = cBlockSize; + dctx->bType = bp.blockType; + dctx->rleSize = bp.origSize; + if (cBlockSize != 0) + { + dctx->stage = + bp.lastBlock != 0 + ? ZSTD_dStage.ZSTDds_decompressLastBlock + : ZSTD_dStage.ZSTDds_decompressBlock; + return 0; + } + + if (bp.lastBlock != 0) + { + if (dctx->fParams.checksumFlag != 0) + { + dctx->expected = 4; + dctx->stage = ZSTD_dStage.ZSTDds_checkChecksum; + } + else + { + dctx->expected = 0; + dctx->stage = ZSTD_dStage.ZSTDds_getFrameHeaderSize; + } + } + else + { + dctx->expected = ZSTD_blockHeaderSize; + dctx->stage = ZSTD_dStage.ZSTDds_decodeBlockHeader; + } + + return 0; + } + + case ZSTD_dStage.ZSTDds_decompressLastBlock: + case ZSTD_dStage.ZSTDds_decompressBlock: + { + nuint rSize; + switch (dctx->bType) + { + case blockType_e.bt_compressed: + assert(dctx->isFrameDecompression == 1); + rSize = ZSTD_decompressBlock_internal( + dctx, + dst, + dstCapacity, + src, + srcSize, + streaming_operation.is_streaming + ); + dctx->expected = 0; + break; + case blockType_e.bt_raw: + assert(srcSize <= dctx->expected); + rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize); + + { + nuint err_code = rSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(rSize == srcSize); + dctx->expected -= rSize; + break; + case blockType_e.bt_rle: + rSize = ZSTD_setRleBlock(dst, dstCapacity, *(byte*)src, dctx->rleSize); + dctx->expected = 0; + break; + case blockType_e.bt_reserved: + default: + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + } + + { + nuint err_code = rSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (rSize > dctx->fParams.blockSizeMax) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + dctx->decodedSize += rSize; + if (dctx->validateChecksum != 0) + ZSTD_XXH64_update(&dctx->xxhState, dst, rSize); + dctx->previousDstEnd = (sbyte*)dst + rSize; + if (dctx->expected > 0) + { + return rSize; + } + + if (dctx->stage == ZSTD_dStage.ZSTDds_decompressLastBlock) + { + if ( + dctx->fParams.frameContentSize != unchecked(0UL - 1) + && dctx->decodedSize != dctx->fParams.frameContentSize + ) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + } + + if (dctx->fParams.checksumFlag != 0) + { + dctx->expected = 4; + dctx->stage = ZSTD_dStage.ZSTDds_checkChecksum; + } + else + { + ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, 1); + dctx->expected = 0; + dctx->stage = ZSTD_dStage.ZSTDds_getFrameHeaderSize; + } + } + else + { + dctx->stage = ZSTD_dStage.ZSTDds_decodeBlockHeader; + dctx->expected = ZSTD_blockHeaderSize; + } + + return rSize; + } + + case ZSTD_dStage.ZSTDds_checkChecksum: + assert(srcSize == 4); + + { + if (dctx->validateChecksum != 0) + { + uint h32 = (uint)ZSTD_XXH64_digest(&dctx->xxhState); + uint check32 = MEM_readLE32(src); + if (check32 != h32) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_checksum_wrong) + ); + } + } + + ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, 1); + dctx->expected = 0; + dctx->stage = ZSTD_dStage.ZSTDds_getFrameHeaderSize; + return 0; + } + + case ZSTD_dStage.ZSTDds_decodeSkippableHeader: + assert(src != null); + assert(srcSize <= 8); + assert(dctx->format != ZSTD_format_e.ZSTD_f_zstd1_magicless); + memcpy(dctx->headerBuffer + (8 - srcSize), src, (uint)srcSize); + dctx->expected = MEM_readLE32(dctx->headerBuffer + 4); + dctx->stage = ZSTD_dStage.ZSTDds_skipFrame; + return 0; + case ZSTD_dStage.ZSTDds_skipFrame: + dctx->expected = 0; + dctx->stage = ZSTD_dStage.ZSTDds_getFrameHeaderSize; + return 0; + default: + assert(0 != 0); + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + } + + private static nuint ZSTD_refDictContent(ZSTD_DCtx_s* dctx, void* dict, nuint dictSize) + { + dctx->dictEnd = dctx->previousDstEnd; + dctx->virtualStart = + (sbyte*)dict - ((sbyte*)dctx->previousDstEnd - (sbyte*)dctx->prefixStart); + dctx->prefixStart = dict; + dctx->previousDstEnd = (sbyte*)dict + dictSize; + return 0; + } + + /*! ZSTD_loadDEntropy() : + * dict : must point at beginning of a valid zstd dictionary. + * @return : size of entropy tables read */ + private static nuint ZSTD_loadDEntropy( + ZSTD_entropyDTables_t* entropy, + void* dict, + nuint dictSize + ) + { + byte* dictPtr = (byte*)dict; + byte* dictEnd = dictPtr + dictSize; + if (dictSize <= 8) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + assert(MEM_readLE32(dict) == 0xEC30A437); + dictPtr += 8; + { + /* use fse tables as temporary workspace; implies fse tables are grouped together */ + void* workspace = &entropy->LLTable; + nuint workspaceSize = (nuint)( + sizeof(ZSTD_seqSymbol) * 513 + + sizeof(ZSTD_seqSymbol) * 257 + + sizeof(ZSTD_seqSymbol) * 513 + ); + nuint hSize = HUF_readDTableX2_wksp( + entropy->hufTable, + dictPtr, + (nuint)(dictEnd - dictPtr), + workspace, + workspaceSize, + 0 + ); + if (ERR_isError(hSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + dictPtr += hSize; + } + + { + short* offcodeNCount = stackalloc short[32]; + uint offcodeMaxValue = 31, + offcodeLog; + nuint offcodeHeaderSize = FSE_readNCount( + offcodeNCount, + &offcodeMaxValue, + &offcodeLog, + dictPtr, + (nuint)(dictEnd - dictPtr) + ); + if (ERR_isError(offcodeHeaderSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + if (offcodeMaxValue > 31) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + if (offcodeLog > 8) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + ZSTD_buildFSETable( + &entropy->OFTable.e0, + offcodeNCount, + offcodeMaxValue, + OF_base, + OF_bits, + offcodeLog, + entropy->workspace, + sizeof(uint) * 157, + 0 + ); + dictPtr += offcodeHeaderSize; + } + + { + short* matchlengthNCount = stackalloc short[53]; + uint matchlengthMaxValue = 52, + matchlengthLog; + nuint matchlengthHeaderSize = FSE_readNCount( + matchlengthNCount, + &matchlengthMaxValue, + &matchlengthLog, + dictPtr, + (nuint)(dictEnd - dictPtr) + ); + if (ERR_isError(matchlengthHeaderSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + if (matchlengthMaxValue > 52) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + if (matchlengthLog > 9) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + ZSTD_buildFSETable( + &entropy->MLTable.e0, + matchlengthNCount, + matchlengthMaxValue, + ML_base, + ML_bits, + matchlengthLog, + entropy->workspace, + sizeof(uint) * 157, + 0 + ); + dictPtr += matchlengthHeaderSize; + } + + { + short* litlengthNCount = stackalloc short[36]; + uint litlengthMaxValue = 35, + litlengthLog; + nuint litlengthHeaderSize = FSE_readNCount( + litlengthNCount, + &litlengthMaxValue, + &litlengthLog, + dictPtr, + (nuint)(dictEnd - dictPtr) + ); + if (ERR_isError(litlengthHeaderSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + if (litlengthMaxValue > 35) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + if (litlengthLog > 9) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + ZSTD_buildFSETable( + &entropy->LLTable.e0, + litlengthNCount, + litlengthMaxValue, + LL_base, + LL_bits, + litlengthLog, + entropy->workspace, + sizeof(uint) * 157, + 0 + ); + dictPtr += litlengthHeaderSize; + } + + if (dictPtr + 12 > dictEnd) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + { + int i; + nuint dictContentSize = (nuint)(dictEnd - (dictPtr + 12)); + for (i = 0; i < 3; i++) + { + uint rep = MEM_readLE32(dictPtr); + dictPtr += 4; + if (rep == 0 || rep > dictContentSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + entropy->rep[i] = rep; + } + } + + return (nuint)(dictPtr - (byte*)dict); + } + + private static nuint ZSTD_decompress_insertDictionary( + ZSTD_DCtx_s* dctx, + void* dict, + nuint dictSize + ) + { + if (dictSize < 8) + return ZSTD_refDictContent(dctx, dict, dictSize); + { + uint magic = MEM_readLE32(dict); + if (magic != 0xEC30A437) + { + return ZSTD_refDictContent(dctx, dict, dictSize); + } + } + + dctx->dictID = MEM_readLE32((sbyte*)dict + 4); + { + nuint eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize); + if (ERR_isError(eSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + dict = (sbyte*)dict + eSize; + dictSize -= eSize; + } + + dctx->litEntropy = dctx->fseEntropy = 1; + return ZSTD_refDictContent(dctx, dict, dictSize); + } + + public static nuint ZSTD_decompressBegin(ZSTD_DCtx_s* dctx) + { + assert(dctx != null); + dctx->expected = ZSTD_startingInputLength(dctx->format); + dctx->stage = ZSTD_dStage.ZSTDds_getFrameHeaderSize; + dctx->processedCSize = 0; + dctx->decodedSize = 0; + dctx->previousDstEnd = null; + dctx->prefixStart = null; + dctx->virtualStart = null; + dctx->dictEnd = null; + dctx->entropy.hufTable[0] = 12 * 0x1000001; + dctx->litEntropy = dctx->fseEntropy = 0; + dctx->dictID = 0; + dctx->bType = blockType_e.bt_reserved; + dctx->isFrameDecompression = 1; + memcpy(dctx->entropy.rep, repStartValue, sizeof(uint) * 3); + dctx->LLTptr = &dctx->entropy.LLTable.e0; + dctx->MLTptr = &dctx->entropy.MLTable.e0; + dctx->OFTptr = &dctx->entropy.OFTable.e0; + dctx->HUFptr = dctx->entropy.hufTable; + return 0; + } + + public static nuint ZSTD_decompressBegin_usingDict( + ZSTD_DCtx_s* dctx, + void* dict, + nuint dictSize + ) + { + { + nuint err_code = ZSTD_decompressBegin(dctx); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (dict != null && dictSize != 0) + if (ERR_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize))) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)); + } + + return 0; + } + + /* ====== ZSTD_DDict ====== */ + public static nuint ZSTD_decompressBegin_usingDDict(ZSTD_DCtx_s* dctx, ZSTD_DDict_s* ddict) + { + assert(dctx != null); + if (ddict != null) + { + sbyte* dictStart = (sbyte*)ZSTD_DDict_dictContent(ddict); + nuint dictSize = ZSTD_DDict_dictSize(ddict); + void* dictEnd = dictStart + dictSize; + dctx->ddictIsCold = dctx->dictEnd != dictEnd ? 1 : 0; + } + + { + nuint err_code = ZSTD_decompressBegin(dctx); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (ddict != null) + { + ZSTD_copyDDictParameters(dctx, ddict); + } + + return 0; + } + + /*! ZSTD_getDictID_fromDict() : + * Provides the dictID stored within dictionary. + * if @return == 0, the dictionary is not conformant with Zstandard specification. + * It can still be loaded, but as a content-only dictionary. */ + public static uint ZSTD_getDictID_fromDict(void* dict, nuint dictSize) + { + if (dictSize < 8) + return 0; + if (MEM_readLE32(dict) != 0xEC30A437) + return 0; + return MEM_readLE32((sbyte*)dict + 4); + } + + /*! ZSTD_getDictID_fromFrame() : + * Provides the dictID required to decompress frame stored within `src`. + * If @return == 0, the dictID could not be decoded. + * This could for one of the following reasons : + * - The frame does not require a dictionary (most common case). + * - The frame was built with dictID intentionally removed. + * Needed dictionary is a hidden piece of information. + * Note : this use case also happens when using a non-conformant dictionary. + * - `srcSize` is too small, and as a result, frame header could not be decoded. + * Note : possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`. + * - This is not a Zstandard frame. + * When identifying the exact failure cause, it's possible to use + * ZSTD_getFrameHeader(), which will provide a more precise error code. */ + public static uint ZSTD_getDictID_fromFrame(void* src, nuint srcSize) + { + ZSTD_frameHeader zfp = new ZSTD_frameHeader + { + frameContentSize = 0, + windowSize = 0, + blockSizeMax = 0, + frameType = ZSTD_frameType_e.ZSTD_frame, + headerSize = 0, + dictID = 0, + checksumFlag = 0, + _reserved1 = 0, + _reserved2 = 0, + }; + nuint hError = ZSTD_getFrameHeader(&zfp, src, srcSize); + if (ERR_isError(hError)) + return 0; + return zfp.dictID; + } + + /*! ZSTD_decompress_usingDDict() : + * Decompression using a pre-digested Dictionary + * Use dictionary without significant overhead. */ + public static nuint ZSTD_decompress_usingDDict( + ZSTD_DCtx_s* dctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + ZSTD_DDict_s* ddict + ) + { + return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, null, 0, ddict); + } + + /*===================================== + * Streaming decompression + *====================================*/ + public static ZSTD_DCtx_s* ZSTD_createDStream() + { + return ZSTD_createDCtx_internal(ZSTD_defaultCMem); + } + + public static ZSTD_DCtx_s* ZSTD_initStaticDStream(void* workspace, nuint workspaceSize) + { + return ZSTD_initStaticDCtx(workspace, workspaceSize); + } + + public static ZSTD_DCtx_s* ZSTD_createDStream_advanced(ZSTD_customMem customMem) + { + return ZSTD_createDCtx_internal(customMem); + } + + public static nuint ZSTD_freeDStream(ZSTD_DCtx_s* zds) + { + return ZSTD_freeDCtx(zds); + } + + /* *** Initialization *** */ + public static nuint ZSTD_DStreamInSize() + { + return (nuint)(1 << 17) + ZSTD_blockHeaderSize; + } + + public static nuint ZSTD_DStreamOutSize() + { + return 1 << 17; + } + + /*! ZSTD_DCtx_loadDictionary_advanced() : + * Same as ZSTD_DCtx_loadDictionary(), + * but gives direct control over + * how to load the dictionary (by copy ? by reference ?) + * and how to interpret it (automatic ? force raw mode ? full mode only ?). */ + public static nuint ZSTD_DCtx_loadDictionary_advanced( + ZSTD_DCtx_s* dctx, + void* dict, + nuint dictSize, + ZSTD_dictLoadMethod_e dictLoadMethod, + ZSTD_dictContentType_e dictContentType + ) + { + if (dctx->streamStage != ZSTD_dStreamStage.zdss_init) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + ZSTD_clearDict(dctx); + if (dict != null && dictSize != 0) + { + dctx->ddictLocal = ZSTD_createDDict_advanced( + dict, + dictSize, + dictLoadMethod, + dictContentType, + dctx->customMem + ); + if (dctx->ddictLocal == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + dctx->ddict = dctx->ddictLocal; + dctx->dictUses = ZSTD_dictUses_e.ZSTD_use_indefinitely; + } + + return 0; + } + + /*! ZSTD_DCtx_loadDictionary_byReference() : + * Same as ZSTD_DCtx_loadDictionary(), + * but references `dict` content instead of copying it into `dctx`. + * This saves memory if `dict` remains around., + * However, it's imperative that `dict` remains accessible (and unmodified) while being used, so it must outlive decompression. */ + public static nuint ZSTD_DCtx_loadDictionary_byReference( + ZSTD_DCtx_s* dctx, + void* dict, + nuint dictSize + ) + { + return ZSTD_DCtx_loadDictionary_advanced( + dctx, + dict, + dictSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef, + ZSTD_dictContentType_e.ZSTD_dct_auto + ); + } + + /*! ZSTD_DCtx_loadDictionary() : Requires v1.4.0+ + * Create an internal DDict from dict buffer, to be used to decompress all future frames. + * The dictionary remains valid for all future frames, until explicitly invalidated, or + * a new dictionary is loaded. + * @result : 0, or an error code (which can be tested with ZSTD_isError()). + * Special : Adding a NULL (or 0-size) dictionary invalidates any previous dictionary, + * meaning "return to no-dictionary mode". + * Note 1 : Loading a dictionary involves building tables, + * which has a non-negligible impact on CPU usage and latency. + * It's recommended to "load once, use many times", to amortize the cost + * Note 2 :`dict` content will be copied internally, so `dict` can be released after loading. + * Use ZSTD_DCtx_loadDictionary_byReference() to reference dictionary content instead. + * Note 3 : Use ZSTD_DCtx_loadDictionary_advanced() to take control of + * how dictionary content is loaded and interpreted. + */ + public static nuint ZSTD_DCtx_loadDictionary(ZSTD_DCtx_s* dctx, void* dict, nuint dictSize) + { + return ZSTD_DCtx_loadDictionary_advanced( + dctx, + dict, + dictSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byCopy, + ZSTD_dictContentType_e.ZSTD_dct_auto + ); + } + + /*! ZSTD_DCtx_refPrefix_advanced() : + * Same as ZSTD_DCtx_refPrefix(), but gives finer control over + * how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) */ + public static nuint ZSTD_DCtx_refPrefix_advanced( + ZSTD_DCtx_s* dctx, + void* prefix, + nuint prefixSize, + ZSTD_dictContentType_e dictContentType + ) + { + { + nuint err_code = ZSTD_DCtx_loadDictionary_advanced( + dctx, + prefix, + prefixSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef, + dictContentType + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + dctx->dictUses = ZSTD_dictUses_e.ZSTD_use_once; + return 0; + } + + /*! ZSTD_DCtx_refPrefix() : Requires v1.4.0+ + * Reference a prefix (single-usage dictionary) to decompress next frame. + * This is the reverse operation of ZSTD_CCtx_refPrefix(), + * and must use the same prefix as the one used during compression. + * Prefix is **only used once**. Reference is discarded at end of frame. + * End of frame is reached when ZSTD_decompressStream() returns 0. + * @result : 0, or an error code (which can be tested with ZSTD_isError()). + * Note 1 : Adding any prefix (including NULL) invalidates any previously set prefix or dictionary + * Note 2 : Prefix buffer is referenced. It **must** outlive decompression. + * Prefix buffer must remain unmodified up to the end of frame, + * reached when ZSTD_decompressStream() returns 0. + * Note 3 : By default, the prefix is treated as raw content (ZSTD_dct_rawContent). + * Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode (Experimental section) + * Note 4 : Referencing a raw content prefix has almost no cpu nor memory cost. + * A full dictionary is more costly, as it requires building tables. + */ + public static nuint ZSTD_DCtx_refPrefix(ZSTD_DCtx_s* dctx, void* prefix, nuint prefixSize) + { + return ZSTD_DCtx_refPrefix_advanced( + dctx, + prefix, + prefixSize, + ZSTD_dictContentType_e.ZSTD_dct_rawContent + ); + } + + /* ZSTD_initDStream_usingDict() : + * return : expected size, aka ZSTD_startingInputLength(). + * this function cannot fail */ + public static nuint ZSTD_initDStream_usingDict(ZSTD_DCtx_s* zds, void* dict, nuint dictSize) + { + { + nuint err_code = ZSTD_DCtx_reset(zds, ZSTD_ResetDirective.ZSTD_reset_session_only); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_DCtx_loadDictionary(zds, dict, dictSize); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return ZSTD_startingInputLength(zds->format); + } + + /* note : this variant can't fail */ + public static nuint ZSTD_initDStream(ZSTD_DCtx_s* zds) + { + { + nuint err_code = ZSTD_DCtx_reset(zds, ZSTD_ResetDirective.ZSTD_reset_session_only); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_DCtx_refDDict(zds, null); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return ZSTD_startingInputLength(zds->format); + } + + /* ZSTD_initDStream_usingDDict() : + * ddict will just be referenced, and must outlive decompression session + * this function cannot fail */ + public static nuint ZSTD_initDStream_usingDDict(ZSTD_DCtx_s* dctx, ZSTD_DDict_s* ddict) + { + { + nuint err_code = ZSTD_DCtx_reset(dctx, ZSTD_ResetDirective.ZSTD_reset_session_only); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + { + nuint err_code = ZSTD_DCtx_refDDict(dctx, ddict); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return ZSTD_startingInputLength(dctx->format); + } + + /* ZSTD_resetDStream() : + * return : expected size, aka ZSTD_startingInputLength(). + * this function cannot fail */ + public static nuint ZSTD_resetDStream(ZSTD_DCtx_s* dctx) + { + { + nuint err_code = ZSTD_DCtx_reset(dctx, ZSTD_ResetDirective.ZSTD_reset_session_only); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return ZSTD_startingInputLength(dctx->format); + } + + /*! ZSTD_DCtx_refDDict() : Requires v1.4.0+ + * Reference a prepared dictionary, to be used to decompress next frames. + * The dictionary remains active for decompression of future frames using same DCtx. + * + * If called with ZSTD_d_refMultipleDDicts enabled, repeated calls of this function + * will store the DDict references in a table, and the DDict used for decompression + * will be determined at decompression time, as per the dict ID in the frame. + * The memory for the table is allocated on the first call to refDDict, and can be + * freed with ZSTD_freeDCtx(). + * + * If called with ZSTD_d_refMultipleDDicts disabled (the default), only one dictionary + * will be managed, and referencing a dictionary effectively "discards" any previous one. + * + * @result : 0, or an error code (which can be tested with ZSTD_isError()). + * Special: referencing a NULL DDict means "return to no-dictionary mode". + * Note 2 : DDict is just referenced, its lifetime must outlive its usage from DCtx. + */ + public static nuint ZSTD_DCtx_refDDict(ZSTD_DCtx_s* dctx, ZSTD_DDict_s* ddict) + { + if (dctx->streamStage != ZSTD_dStreamStage.zdss_init) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + ZSTD_clearDict(dctx); + if (ddict != null) + { + dctx->ddict = ddict; + dctx->dictUses = ZSTD_dictUses_e.ZSTD_use_indefinitely; + if (dctx->refMultipleDDicts == ZSTD_refMultipleDDicts_e.ZSTD_rmd_refMultipleDDicts) + { + if (dctx->ddictSet == null) + { + dctx->ddictSet = ZSTD_createDDictHashSet(dctx->customMem); + if (dctx->ddictSet == null) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation) + ); + } + } + + assert(dctx->staticSize == 0); + { + nuint err_code = ZSTD_DDictHashSet_addDDict( + dctx->ddictSet, + ddict, + dctx->customMem + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + } + } + + return 0; + } + + /* ZSTD_DCtx_setMaxWindowSize() : + * note : no direct equivalence in ZSTD_DCtx_setParameter, + * since this version sets windowSize, and the other sets windowLog */ + public static nuint ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx_s* dctx, nuint maxWindowSize) + { + ZSTD_bounds bounds = ZSTD_dParam_getBounds(ZSTD_dParameter.ZSTD_d_windowLogMax); + nuint min = (nuint)1 << bounds.lowerBound; + nuint max = (nuint)1 << bounds.upperBound; + if (dctx->streamStage != ZSTD_dStreamStage.zdss_init) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + if (maxWindowSize < min) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + if (maxWindowSize > max) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound)); + } + + dctx->maxWindowSize = maxWindowSize; + return 0; + } + + /*! ZSTD_DCtx_setFormat() : + * This function is REDUNDANT. Prefer ZSTD_DCtx_setParameter(). + * Instruct the decoder context about what kind of data to decode next. + * This instruction is mandatory to decode data without a fully-formed header, + * such ZSTD_f_zstd1_magicless for example. + * @return : 0, or an error code (which can be tested using ZSTD_isError()). */ + public static nuint ZSTD_DCtx_setFormat(ZSTD_DCtx_s* dctx, ZSTD_format_e format) + { + return ZSTD_DCtx_setParameter(dctx, ZSTD_dParameter.ZSTD_d_experimentalParam1, (int)format); + } + + /*! ZSTD_dParam_getBounds() : + * All parameters must belong to an interval with lower and upper bounds, + * otherwise they will either trigger an error or be automatically clamped. + * @return : a structure, ZSTD_bounds, which contains + * - an error status field, which must be tested using ZSTD_isError() + * - both lower and upper bounds, inclusive + */ + public static ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam) + { + ZSTD_bounds bounds = new ZSTD_bounds + { + error = 0, + lowerBound = 0, + upperBound = 0, + }; + switch (dParam) + { + case ZSTD_dParameter.ZSTD_d_windowLogMax: + bounds.lowerBound = 10; + bounds.upperBound = sizeof(nuint) == 4 ? 30 : 31; + return bounds; + case ZSTD_dParameter.ZSTD_d_experimentalParam1: + bounds.lowerBound = (int)ZSTD_format_e.ZSTD_f_zstd1; + bounds.upperBound = (int)ZSTD_format_e.ZSTD_f_zstd1_magicless; + return bounds; + case ZSTD_dParameter.ZSTD_d_experimentalParam2: + bounds.lowerBound = (int)ZSTD_bufferMode_e.ZSTD_bm_buffered; + bounds.upperBound = (int)ZSTD_bufferMode_e.ZSTD_bm_stable; + return bounds; + case ZSTD_dParameter.ZSTD_d_experimentalParam3: + bounds.lowerBound = (int)ZSTD_forceIgnoreChecksum_e.ZSTD_d_validateChecksum; + bounds.upperBound = (int)ZSTD_forceIgnoreChecksum_e.ZSTD_d_ignoreChecksum; + return bounds; + case ZSTD_dParameter.ZSTD_d_experimentalParam4: + bounds.lowerBound = (int)ZSTD_refMultipleDDicts_e.ZSTD_rmd_refSingleDDict; + bounds.upperBound = (int)ZSTD_refMultipleDDicts_e.ZSTD_rmd_refMultipleDDicts; + return bounds; + case ZSTD_dParameter.ZSTD_d_experimentalParam5: + bounds.lowerBound = 0; + bounds.upperBound = 1; + return bounds; + case ZSTD_dParameter.ZSTD_d_experimentalParam6: + bounds.lowerBound = 1 << 10; + bounds.upperBound = 1 << 17; + return bounds; + default: + break; + } + + bounds.error = unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_unsupported)); + return bounds; + } + + /* ZSTD_dParam_withinBounds: + * @return 1 if value is within dParam bounds, + * 0 otherwise */ + private static int ZSTD_dParam_withinBounds(ZSTD_dParameter dParam, int value) + { + ZSTD_bounds bounds = ZSTD_dParam_getBounds(dParam); + if (ERR_isError(bounds.error)) + return 0; + if (value < bounds.lowerBound) + return 0; + if (value > bounds.upperBound) + return 0; + return 1; + } + + /*! ZSTD_DCtx_getParameter() : + * Get the requested decompression parameter value, selected by enum ZSTD_dParameter, + * and store it into int* value. + * @return : 0, or an error code (which can be tested with ZSTD_isError()). + */ + public static nuint ZSTD_DCtx_getParameter(ZSTD_DCtx_s* dctx, ZSTD_dParameter param, int* value) + { + switch (param) + { + case ZSTD_dParameter.ZSTD_d_windowLogMax: + *value = (int)ZSTD_highbit32((uint)dctx->maxWindowSize); + return 0; + case ZSTD_dParameter.ZSTD_d_experimentalParam1: + *value = (int)dctx->format; + return 0; + case ZSTD_dParameter.ZSTD_d_experimentalParam2: + *value = (int)dctx->outBufferMode; + return 0; + case ZSTD_dParameter.ZSTD_d_experimentalParam3: + *value = (int)dctx->forceIgnoreChecksum; + return 0; + case ZSTD_dParameter.ZSTD_d_experimentalParam4: + *value = (int)dctx->refMultipleDDicts; + return 0; + case ZSTD_dParameter.ZSTD_d_experimentalParam5: + *value = dctx->disableHufAsm; + return 0; + case ZSTD_dParameter.ZSTD_d_experimentalParam6: + *value = dctx->maxBlockSizeParam; + return 0; + default: + break; + } + + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_unsupported)); + } + + /*! ZSTD_DCtx_setParameter() : + * Set one compression parameter, selected by enum ZSTD_dParameter. + * All parameters have valid bounds. Bounds can be queried using ZSTD_dParam_getBounds(). + * Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter). + * Setting a parameter is only possible during frame initialization (before starting decompression). + * @return : 0, or an error code (which can be tested using ZSTD_isError()). + */ + public static nuint ZSTD_DCtx_setParameter(ZSTD_DCtx_s* dctx, ZSTD_dParameter dParam, int value) + { + if (dctx->streamStage != ZSTD_dStreamStage.zdss_init) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + switch (dParam) + { + case ZSTD_dParameter.ZSTD_d_windowLogMax: + if (value == 0) + value = 27; + + { + if (ZSTD_dParam_withinBounds(ZSTD_dParameter.ZSTD_d_windowLogMax, value) == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + } + + dctx->maxWindowSize = (nuint)1 << value; + return 0; + case ZSTD_dParameter.ZSTD_d_experimentalParam1: + { + if ( + ZSTD_dParam_withinBounds(ZSTD_dParameter.ZSTD_d_experimentalParam1, value) + == 0 + ) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + } + + dctx->format = (ZSTD_format_e)value; + return 0; + case ZSTD_dParameter.ZSTD_d_experimentalParam2: + { + if ( + ZSTD_dParam_withinBounds(ZSTD_dParameter.ZSTD_d_experimentalParam2, value) + == 0 + ) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + } + + dctx->outBufferMode = (ZSTD_bufferMode_e)value; + return 0; + case ZSTD_dParameter.ZSTD_d_experimentalParam3: + { + if ( + ZSTD_dParam_withinBounds(ZSTD_dParameter.ZSTD_d_experimentalParam3, value) + == 0 + ) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + } + + dctx->forceIgnoreChecksum = (ZSTD_forceIgnoreChecksum_e)value; + return 0; + case ZSTD_dParameter.ZSTD_d_experimentalParam4: + { + if ( + ZSTD_dParam_withinBounds(ZSTD_dParameter.ZSTD_d_experimentalParam4, value) + == 0 + ) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + } + + if (dctx->staticSize != 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_unsupported) + ); + } + + dctx->refMultipleDDicts = (ZSTD_refMultipleDDicts_e)value; + return 0; + case ZSTD_dParameter.ZSTD_d_experimentalParam5: + { + if ( + ZSTD_dParam_withinBounds(ZSTD_dParameter.ZSTD_d_experimentalParam5, value) + == 0 + ) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + } + + dctx->disableHufAsm = value != 0 ? 1 : 0; + return 0; + case ZSTD_dParameter.ZSTD_d_experimentalParam6: + if (value != 0) + { + if ( + ZSTD_dParam_withinBounds(ZSTD_dParameter.ZSTD_d_experimentalParam6, value) + == 0 + ) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_outOfBound) + ); + } + } + + dctx->maxBlockSizeParam = value; + return 0; + default: + break; + } + + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_parameter_unsupported)); + } + + /*! ZSTD_DCtx_reset() : + * Return a DCtx to clean state. + * Session and parameters can be reset jointly or separately. + * Parameters can only be reset when no active frame is being decompressed. + * @return : 0, or an error code, which can be tested with ZSTD_isError() + */ + public static nuint ZSTD_DCtx_reset(ZSTD_DCtx_s* dctx, ZSTD_ResetDirective reset) + { + if ( + reset == ZSTD_ResetDirective.ZSTD_reset_session_only + || reset == ZSTD_ResetDirective.ZSTD_reset_session_and_parameters + ) + { + dctx->streamStage = ZSTD_dStreamStage.zdss_init; + dctx->noForwardProgress = 0; + dctx->isFrameDecompression = 1; + } + + if ( + reset == ZSTD_ResetDirective.ZSTD_reset_parameters + || reset == ZSTD_ResetDirective.ZSTD_reset_session_and_parameters + ) + { + if (dctx->streamStage != ZSTD_dStreamStage.zdss_init) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + ZSTD_clearDict(dctx); + ZSTD_DCtx_resetParameters(dctx); + } + + return 0; + } + + public static nuint ZSTD_sizeof_DStream(ZSTD_DCtx_s* dctx) + { + return ZSTD_sizeof_DCtx(dctx); + } + + private static nuint ZSTD_decodingBufferSize_internal( + ulong windowSize, + ulong frameContentSize, + nuint blockSizeMax + ) + { + nuint blockSize = + (nuint)(windowSize < 1 << 17 ? windowSize : 1 << 17) < blockSizeMax + ? (nuint)(windowSize < 1 << 17 ? windowSize : 1 << 17) + : blockSizeMax; + /* We need blockSize + WILDCOPY_OVERLENGTH worth of buffer so that if a block + * ends at windowSize + WILDCOPY_OVERLENGTH + 1 bytes, we can start writing + * the block at the beginning of the output buffer, and maintain a full window. + * + * We need another blockSize worth of buffer so that we can store split + * literals at the end of the block without overwriting the extDict window. + */ + ulong neededRBSize = windowSize + blockSize * 2 + 32 * 2; + ulong neededSize = frameContentSize < neededRBSize ? frameContentSize : neededRBSize; + nuint minRBSize = (nuint)neededSize; + if (minRBSize != neededSize) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_frameParameter_windowTooLarge) + ); + } + + return minRBSize; + } + + /*===== Buffer-less streaming decompression functions =====*/ + public static nuint ZSTD_decodingBufferSize_min(ulong windowSize, ulong frameContentSize) + { + return ZSTD_decodingBufferSize_internal(windowSize, frameContentSize, 1 << 17); + } + + public static nuint ZSTD_estimateDStreamSize(nuint windowSize) + { + nuint blockSize = windowSize < 1 << 17 ? windowSize : 1 << 17; + /* no block can be larger */ + nuint inBuffSize = blockSize; + nuint outBuffSize = ZSTD_decodingBufferSize_min(windowSize, unchecked(0UL - 1)); + return ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize; + } + + public static nuint ZSTD_estimateDStreamSize_fromFrame(void* src, nuint srcSize) + { + /* note : should be user-selectable, but requires an additional parameter (or a dctx) */ + uint windowSizeMax = 1U << (sizeof(nuint) == 4 ? 30 : 31); + ZSTD_frameHeader zfh; + nuint err = ZSTD_getFrameHeader(&zfh, src, srcSize); + if (ERR_isError(err)) + return err; + if (err > 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if (zfh.windowSize > windowSizeMax) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_frameParameter_windowTooLarge) + ); + } + + return ZSTD_estimateDStreamSize((nuint)zfh.windowSize); + } + + /* ***** Decompression ***** */ + private static int ZSTD_DCtx_isOverflow( + ZSTD_DCtx_s* zds, + nuint neededInBuffSize, + nuint neededOutBuffSize + ) + { + return zds->inBuffSize + zds->outBuffSize >= (neededInBuffSize + neededOutBuffSize) * 3 + ? 1 + : 0; + } + + private static void ZSTD_DCtx_updateOversizedDuration( + ZSTD_DCtx_s* zds, + nuint neededInBuffSize, + nuint neededOutBuffSize + ) + { + if (ZSTD_DCtx_isOverflow(zds, neededInBuffSize, neededOutBuffSize) != 0) + zds->oversizedDuration++; + else + zds->oversizedDuration = 0; + } + + private static int ZSTD_DCtx_isOversizedTooLong(ZSTD_DCtx_s* zds) + { + return zds->oversizedDuration >= 128 ? 1 : 0; + } + + /* Checks that the output buffer hasn't changed if ZSTD_obm_stable is used. */ + private static nuint ZSTD_checkOutBuffer(ZSTD_DCtx_s* zds, ZSTD_outBuffer_s* output) + { + ZSTD_outBuffer_s expect = zds->expectedOutBuffer; + if (zds->outBufferMode != ZSTD_bufferMode_e.ZSTD_bm_stable) + return 0; + if (zds->streamStage == ZSTD_dStreamStage.zdss_init) + return 0; + if (expect.dst == output->dst && expect.pos == output->pos && expect.size == output->size) + return 0; + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstBuffer_wrong)); + } + + /* Calls ZSTD_decompressContinue() with the right parameters for ZSTD_decompressStream() + * and updates the stage and the output buffer state. This call is extracted so it can be + * used both when reading directly from the ZSTD_inBuffer, and in buffered input mode. + * NOTE: You must break after calling this function since the streamStage is modified. + */ + private static nuint ZSTD_decompressContinueStream( + ZSTD_DCtx_s* zds, + sbyte** op, + sbyte* oend, + void* src, + nuint srcSize + ) + { + int isSkipFrame = ZSTD_isSkipFrame(zds); + if (zds->outBufferMode == ZSTD_bufferMode_e.ZSTD_bm_buffered) + { + nuint dstSize = isSkipFrame != 0 ? 0 : zds->outBuffSize - zds->outStart; + nuint decodedSize = ZSTD_decompressContinue( + zds, + zds->outBuff + zds->outStart, + dstSize, + src, + srcSize + ); + { + nuint err_code = decodedSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (decodedSize == 0 && isSkipFrame == 0) + { + zds->streamStage = ZSTD_dStreamStage.zdss_read; + } + else + { + zds->outEnd = zds->outStart + decodedSize; + zds->streamStage = ZSTD_dStreamStage.zdss_flush; + } + } + else + { + /* Write directly into the output buffer */ + nuint dstSize = isSkipFrame != 0 ? 0 : (nuint)(oend - *op); + nuint decodedSize = ZSTD_decompressContinue(zds, *op, dstSize, src, srcSize); + { + nuint err_code = decodedSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + *op += decodedSize; + zds->streamStage = ZSTD_dStreamStage.zdss_read; + assert(*op <= oend); + assert(zds->outBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable); + } + + return 0; + } + + /*! ZSTD_decompressStream() : + * Streaming decompression function. + * Call repetitively to consume full input updating it as necessary. + * Function will update both input and output `pos` fields exposing current state via these fields: + * - `input.pos < input.size`, some input remaining and caller should provide remaining input + * on the next call. + * - `output.pos < output.size`, decoder flushed internal output buffer. + * - `output.pos == output.size`, unflushed data potentially present in the internal buffers, + * check ZSTD_decompressStream() @return value, + * if > 0, invoke it again to flush remaining data to output. + * Note : with no additional input, amount of data flushed <= ZSTD_BLOCKSIZE_MAX. + * + * @return : 0 when a frame is completely decoded and fully flushed, + * or an error code, which can be tested using ZSTD_isError(), + * or any other value > 0, which means there is some decoding or flushing to do to complete current frame. + * + * Note: when an operation returns with an error code, the @zds state may be left in undefined state. + * It's UB to invoke `ZSTD_decompressStream()` on such a state. + * In order to re-use such a state, it must be first reset, + * which can be done explicitly (`ZSTD_DCtx_reset()`), + * or is implied for operations starting some new decompression job (`ZSTD_initDStream`, `ZSTD_decompressDCtx()`, `ZSTD_decompress_usingDict()`) + */ + public static nuint ZSTD_decompressStream( + ZSTD_DCtx_s* zds, + ZSTD_outBuffer_s* output, + ZSTD_inBuffer_s* input + ) + { + sbyte* src = (sbyte*)input->src; + sbyte* istart = input->pos != 0 ? src + input->pos : src; + sbyte* iend = input->size != 0 ? src + input->size : src; + sbyte* ip = istart; + sbyte* dst = (sbyte*)output->dst; + sbyte* ostart = output->pos != 0 ? dst + output->pos : dst; + sbyte* oend = output->size != 0 ? dst + output->size : dst; + sbyte* op = ostart; + uint someMoreWork = 1; + assert(zds != null); + if (input->pos > input->size) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if (output->pos > output->size) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + { + nuint err_code = ZSTD_checkOutBuffer(zds, output); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + while (someMoreWork != 0) + { + switch (zds->streamStage) + { + case ZSTD_dStreamStage.zdss_init: + zds->streamStage = ZSTD_dStreamStage.zdss_loadHeader; + zds->lhSize = zds->inPos = zds->outStart = zds->outEnd = 0; + zds->hostageByte = 0; + zds->expectedOutBuffer = *output; + goto case ZSTD_dStreamStage.zdss_loadHeader; + case ZSTD_dStreamStage.zdss_loadHeader: + { + nuint hSize = ZSTD_getFrameHeader_advanced( + &zds->fParams, + zds->headerBuffer, + zds->lhSize, + zds->format + ); + if (zds->refMultipleDDicts != default && zds->ddictSet != null) + { + ZSTD_DCtx_selectFrameDDict(zds); + } + + if (ERR_isError(hSize)) + { + return hSize; + } + + if (hSize != 0) + { + /* if hSize!=0, hSize > zds->lhSize */ + nuint toLoad = hSize - zds->lhSize; + nuint remainingInput = (nuint)(iend - ip); + assert(iend >= ip); + if (toLoad > remainingInput) + { + if (remainingInput > 0) + { + memcpy( + zds->headerBuffer + zds->lhSize, + ip, + (uint)remainingInput + ); + zds->lhSize += remainingInput; + } + + input->pos = input->size; + { + /* check first few bytes */ + nuint err_code = ZSTD_getFrameHeader_advanced( + &zds->fParams, + zds->headerBuffer, + zds->lhSize, + zds->format + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + return ( + (nuint)(zds->format == ZSTD_format_e.ZSTD_f_zstd1 ? 6 : 2) + > hSize + ? (nuint)( + zds->format == ZSTD_format_e.ZSTD_f_zstd1 ? 6 : 2 + ) + : hSize + ) + - zds->lhSize + + ZSTD_blockHeaderSize; + } + + assert(ip != null); + memcpy(zds->headerBuffer + zds->lhSize, ip, (uint)toLoad); + zds->lhSize = hSize; + ip += toLoad; + break; + } + } + + if ( + zds->fParams.frameContentSize != unchecked(0UL - 1) + && zds->fParams.frameType != ZSTD_frameType_e.ZSTD_skippableFrame + && (nuint)(oend - op) >= zds->fParams.frameContentSize + ) + { + nuint cSize = ZSTD_findFrameCompressedSize_advanced( + istart, + (nuint)(iend - istart), + zds->format + ); + if (cSize <= (nuint)(iend - istart)) + { + /* shortcut : using single-pass mode */ + nuint decompressedSize = ZSTD_decompress_usingDDict( + zds, + op, + (nuint)(oend - op), + istart, + cSize, + ZSTD_getDDict(zds) + ); + if (ERR_isError(decompressedSize)) + return decompressedSize; + assert(istart != null); + ip = istart + cSize; + op = op != null ? op + decompressedSize : op; + zds->expected = 0; + zds->streamStage = ZSTD_dStreamStage.zdss_init; + someMoreWork = 0; + break; + } + } + + if ( + zds->outBufferMode == ZSTD_bufferMode_e.ZSTD_bm_stable + && zds->fParams.frameType != ZSTD_frameType_e.ZSTD_skippableFrame + && zds->fParams.frameContentSize != unchecked(0UL - 1) + && (nuint)(oend - op) < zds->fParams.frameContentSize + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + { + nuint err_code = ZSTD_decompressBegin_usingDDict(zds, ZSTD_getDDict(zds)); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if ( + zds->format == ZSTD_format_e.ZSTD_f_zstd1 + && (MEM_readLE32(zds->headerBuffer) & 0xFFFFFFF0) == 0x184D2A50 + ) + { + zds->expected = MEM_readLE32(zds->headerBuffer + 4); + zds->stage = ZSTD_dStage.ZSTDds_skipFrame; + } + else + { + { + nuint err_code = ZSTD_decodeFrameHeader( + zds, + zds->headerBuffer, + zds->lhSize + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + zds->expected = ZSTD_blockHeaderSize; + zds->stage = ZSTD_dStage.ZSTDds_decodeBlockHeader; + } + + zds->fParams.windowSize = + zds->fParams.windowSize > 1U << 10 ? zds->fParams.windowSize : 1U << 10; + if (zds->fParams.windowSize > zds->maxWindowSize) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_frameParameter_windowTooLarge) + ); + } + + if (zds->maxBlockSizeParam != 0) + zds->fParams.blockSizeMax = + zds->fParams.blockSizeMax < (uint)zds->maxBlockSizeParam + ? zds->fParams.blockSizeMax + : (uint)zds->maxBlockSizeParam; + + { + /* frame checksum */ + nuint neededInBuffSize = + zds->fParams.blockSizeMax > 4 ? zds->fParams.blockSizeMax : 4; + nuint neededOutBuffSize = + zds->outBufferMode == ZSTD_bufferMode_e.ZSTD_bm_buffered + ? ZSTD_decodingBufferSize_internal( + zds->fParams.windowSize, + zds->fParams.frameContentSize, + zds->fParams.blockSizeMax + ) + : 0; + ZSTD_DCtx_updateOversizedDuration(zds, neededInBuffSize, neededOutBuffSize); + { + int tooSmall = + zds->inBuffSize < neededInBuffSize + || zds->outBuffSize < neededOutBuffSize + ? 1 + : 0; + int tooLarge = ZSTD_DCtx_isOversizedTooLong(zds); + if (tooSmall != 0 || tooLarge != 0) + { + nuint bufferSize = neededInBuffSize + neededOutBuffSize; + if (zds->staticSize != 0) + { + assert(zds->staticSize >= (nuint)sizeof(ZSTD_DCtx_s)); + if (bufferSize > zds->staticSize - (nuint)sizeof(ZSTD_DCtx_s)) + { + return unchecked( + (nuint)( + -(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation + ) + ); + } + } + else + { + ZSTD_customFree(zds->inBuff, zds->customMem); + zds->inBuffSize = 0; + zds->outBuffSize = 0; + zds->inBuff = (sbyte*)ZSTD_customMalloc( + bufferSize, + zds->customMem + ); + if (zds->inBuff == null) + { + return unchecked( + (nuint)( + -(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation + ) + ); + } + } + + zds->inBuffSize = neededInBuffSize; + zds->outBuff = zds->inBuff + zds->inBuffSize; + zds->outBuffSize = neededOutBuffSize; + } + } + } + + zds->streamStage = ZSTD_dStreamStage.zdss_read; + goto case ZSTD_dStreamStage.zdss_read; + case ZSTD_dStreamStage.zdss_read: + { + nuint neededInSize = ZSTD_nextSrcSizeToDecompressWithInputSize( + zds, + (nuint)(iend - ip) + ); + if (neededInSize == 0) + { + zds->streamStage = ZSTD_dStreamStage.zdss_init; + someMoreWork = 0; + break; + } + + if ((nuint)(iend - ip) >= neededInSize) + { + { + nuint err_code = ZSTD_decompressContinueStream( + zds, + &op, + oend, + ip, + neededInSize + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + assert(ip != null); + ip += neededInSize; + break; + } + } + + if (ip == iend) + { + someMoreWork = 0; + break; + } + + zds->streamStage = ZSTD_dStreamStage.zdss_load; + goto case ZSTD_dStreamStage.zdss_load; + case ZSTD_dStreamStage.zdss_load: + { + nuint neededInSize = ZSTD_nextSrcSizeToDecompress(zds); + nuint toLoad = neededInSize - zds->inPos; + int isSkipFrame = ZSTD_isSkipFrame(zds); + nuint loadedSize; + assert( + neededInSize + == ZSTD_nextSrcSizeToDecompressWithInputSize(zds, (nuint)(iend - ip)) + ); + if (isSkipFrame != 0) + { + loadedSize = toLoad < (nuint)(iend - ip) ? toLoad : (nuint)(iend - ip); + } + else + { + if (toLoad > zds->inBuffSize - zds->inPos) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + } + + loadedSize = ZSTD_limitCopy( + zds->inBuff + zds->inPos, + toLoad, + ip, + (nuint)(iend - ip) + ); + } + + if (loadedSize != 0) + { + ip += loadedSize; + zds->inPos += loadedSize; + } + + if (loadedSize < toLoad) + { + someMoreWork = 0; + break; + } + + zds->inPos = 0; + { + nuint err_code = ZSTD_decompressContinueStream( + zds, + &op, + oend, + zds->inBuff, + neededInSize + ); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + break; + } + + case ZSTD_dStreamStage.zdss_flush: + { + nuint toFlushSize = zds->outEnd - zds->outStart; + nuint flushedSize = ZSTD_limitCopy( + op, + (nuint)(oend - op), + zds->outBuff + zds->outStart, + toFlushSize + ); + op = op != null ? op + flushedSize : op; + zds->outStart += flushedSize; + if (flushedSize == toFlushSize) + { + zds->streamStage = ZSTD_dStreamStage.zdss_read; + if ( + zds->outBuffSize < zds->fParams.frameContentSize + && zds->outStart + zds->fParams.blockSizeMax > zds->outBuffSize + ) + { + zds->outStart = zds->outEnd = 0; + } + + break; + } + } + + someMoreWork = 0; + break; + default: + assert(0 != 0); + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + } + + input->pos = (nuint)(ip - (sbyte*)input->src); + output->pos = (nuint)(op - (sbyte*)output->dst); + zds->expectedOutBuffer = *output; + if (ip == istart && op == ostart) + { + zds->noForwardProgress++; + if (zds->noForwardProgress >= 16) + { + if (op == oend) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_noForwardProgress_destFull) + ); + } + + if (ip == iend) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_noForwardProgress_inputEmpty) + ); + } + + assert(0 != 0); + } + } + else + { + zds->noForwardProgress = 0; + } + + { + nuint nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zds); + if (nextSrcSizeHint == 0) + { + if (zds->outEnd == zds->outStart) + { + if (zds->hostageByte != 0) + { + if (input->pos >= input->size) + { + zds->streamStage = ZSTD_dStreamStage.zdss_read; + return 1; + } + + input->pos++; + } + + return 0; + } + + if (zds->hostageByte == 0) + { + input->pos--; + zds->hostageByte = 1; + } + + return 1; + } + + nextSrcSizeHint += + ZSTD_blockHeaderSize + * (nuint)(ZSTD_nextInputType(zds) == ZSTD_nextInputType_e.ZSTDnit_block ? 1 : 0); + assert(zds->inPos <= nextSrcSizeHint); + nextSrcSizeHint -= zds->inPos; + return nextSrcSizeHint; + } + } + + /*! ZSTD_decompressStream_simpleArgs() : + * Same as ZSTD_decompressStream(), + * but using only integral types as arguments. + * This can be helpful for binders from dynamic languages + * which have troubles handling structures containing memory pointers. + */ + public static nuint ZSTD_decompressStream_simpleArgs( + ZSTD_DCtx_s* dctx, + void* dst, + nuint dstCapacity, + nuint* dstPos, + void* src, + nuint srcSize, + nuint* srcPos + ) + { + ZSTD_outBuffer_s output; + ZSTD_inBuffer_s input; + output.dst = dst; + output.size = dstCapacity; + output.pos = *dstPos; + input.src = src; + input.size = srcSize; + input.pos = *srcPos; + { + nuint cErr = ZSTD_decompressStream(dctx, &output, &input); + *dstPos = output.pos; + *srcPos = input.pos; + return cErr; + } + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDecompressBlock.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDecompressBlock.cs new file mode 100644 index 000000000..fd4168b54 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDecompressBlock.cs @@ -0,0 +1,3218 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /*_******************************************************* + * Memory operations + **********************************************************/ + private static void ZSTD_copy4(void* dst, void* src) + { + memcpy(dst, src, 4); + } + + /*-************************************************************* + * Block decoding + ***************************************************************/ + private static nuint ZSTD_blockSizeMax(ZSTD_DCtx_s* dctx) + { + nuint blockSizeMax = dctx->isFrameDecompression != 0 ? dctx->fParams.blockSizeMax : 1 << 17; + assert(blockSizeMax <= 1 << 17); + return blockSizeMax; + } + + /*! ZSTD_getcBlockSize() : + * Provides the size of compressed block from block header `src` */ + private static nuint ZSTD_getcBlockSize(void* src, nuint srcSize, blockProperties_t* bpPtr) + { + if (srcSize < ZSTD_blockHeaderSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + { + uint cBlockHeader = MEM_readLE24(src); + uint cSize = cBlockHeader >> 3; + bpPtr->lastBlock = cBlockHeader & 1; + bpPtr->blockType = (blockType_e)(cBlockHeader >> 1 & 3); + bpPtr->origSize = cSize; + if (bpPtr->blockType == blockType_e.bt_rle) + return 1; + if (bpPtr->blockType == blockType_e.bt_reserved) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + return cSize; + } + } + + /* Allocate buffer for literals, either overlapping current dst, or split between dst and litExtraBuffer, or stored entirely within litExtraBuffer */ + private static void ZSTD_allocateLiteralsBuffer( + ZSTD_DCtx_s* dctx, + void* dst, + nuint dstCapacity, + nuint litSize, + streaming_operation streaming, + nuint expectedWriteSize, + uint splitImmediately + ) + { + nuint blockSizeMax = ZSTD_blockSizeMax(dctx); + assert(litSize <= blockSizeMax); + assert(dctx->isFrameDecompression != 0 || streaming == streaming_operation.not_streaming); + assert(expectedWriteSize <= blockSizeMax); + if ( + streaming == streaming_operation.not_streaming + && dstCapacity > blockSizeMax + 32 + litSize + 32 + ) + { + dctx->litBuffer = (byte*)dst + blockSizeMax + 32; + dctx->litBufferEnd = dctx->litBuffer + litSize; + dctx->litBufferLocation = ZSTD_litLocation_e.ZSTD_in_dst; + } + else if (litSize <= 1 << 16) + { + dctx->litBuffer = dctx->litExtraBuffer; + dctx->litBufferEnd = dctx->litBuffer + litSize; + dctx->litBufferLocation = ZSTD_litLocation_e.ZSTD_not_in_dst; + } + else + { + assert(blockSizeMax > 1 << 16); + if (splitImmediately != 0) + { + dctx->litBuffer = (byte*)dst + expectedWriteSize - litSize + (1 << 16) - 32; + dctx->litBufferEnd = dctx->litBuffer + litSize - (1 << 16); + } + else + { + dctx->litBuffer = (byte*)dst + expectedWriteSize - litSize; + dctx->litBufferEnd = (byte*)dst + expectedWriteSize; + } + + dctx->litBufferLocation = ZSTD_litLocation_e.ZSTD_split; + assert(dctx->litBufferEnd <= (byte*)dst + expectedWriteSize); + } + } + + /*! ZSTD_decodeLiteralsBlock() : + * Where it is possible to do so without being stomped by the output during decompression, the literals block will be stored + * in the dstBuffer. If there is room to do so, it will be stored in full in the excess dst space after where the current + * block will be output. Otherwise it will be stored at the end of the current dst blockspace, with a small portion being + * stored in dctx->litExtraBuffer to help keep it "ahead" of the current output write. + * + * @return : nb of bytes read from src (< srcSize ) + * note : symbol not declared but exposed for fullbench */ + private static nuint ZSTD_decodeLiteralsBlock( + ZSTD_DCtx_s* dctx, + void* src, + nuint srcSize, + void* dst, + nuint dstCapacity, + streaming_operation streaming + ) + { + if (srcSize < 1 + 1) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + { + byte* istart = (byte*)src; + SymbolEncodingType_e litEncType = (SymbolEncodingType_e)(istart[0] & 3); + nuint blockSizeMax = ZSTD_blockSizeMax(dctx); + switch (litEncType) + { + case SymbolEncodingType_e.set_repeat: + if (dctx->litEntropy == 0) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted) + ); + } + + goto case SymbolEncodingType_e.set_compressed; + case SymbolEncodingType_e.set_compressed: + if (srcSize < 5) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + } + + { + nuint lhSize, + litSize, + litCSize; + uint singleStream = 0; + uint lhlCode = (uint)(istart[0] >> 2 & 3); + uint lhc = MEM_readLE32(istart); + nuint hufSuccess; + nuint expectedWriteSize = + blockSizeMax < dstCapacity ? blockSizeMax : dstCapacity; + int flags = + 0 + | (ZSTD_DCtx_get_bmi2(dctx) != 0 ? (int)HUF_flags_e.HUF_flags_bmi2 : 0) + | ( + dctx->disableHufAsm != 0 ? (int)HUF_flags_e.HUF_flags_disableAsm : 0 + ); + switch (lhlCode) + { + case 0: + case 1: + default: + singleStream = lhlCode == 0 ? 1U : 0U; + lhSize = 3; + litSize = lhc >> 4 & 0x3FF; + litCSize = lhc >> 14 & 0x3FF; + break; + case 2: + lhSize = 4; + litSize = lhc >> 4 & 0x3FFF; + litCSize = lhc >> 18; + break; + case 3: + lhSize = 5; + litSize = lhc >> 4 & 0x3FFFF; + litCSize = (lhc >> 22) + ((nuint)istart[4] << 10); + break; + } + + if (litSize > 0 && dst == null) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall) + ); + } + + if (litSize > blockSizeMax) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + } + + if (singleStream == 0) + if (litSize < 6) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_literals_headerWrong) + ); + } + + if (litCSize + lhSize > srcSize) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + } + + if (expectedWriteSize < litSize) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall) + ); + } + + ZSTD_allocateLiteralsBuffer( + dctx, + dst, + dstCapacity, + litSize, + streaming, + expectedWriteSize, + 0 + ); + if (dctx->ddictIsCold != 0 && litSize > 768) + { + sbyte* _ptr = (sbyte*)dctx->HUFptr; + const nuint _size = sizeof(uint) * 4097; + nuint _pos; + for (_pos = 0; _pos < _size; _pos += 64) + { +#if NETCOREAPP3_0_OR_GREATER + if (System.Runtime.Intrinsics.X86.Sse.IsSupported) + { + System.Runtime.Intrinsics.X86.Sse.Prefetch1(_ptr + _pos); + } +#endif + } + } + + if (litEncType == SymbolEncodingType_e.set_repeat) + { + if (singleStream != 0) + { + hufSuccess = HUF_decompress1X_usingDTable( + dctx->litBuffer, + litSize, + istart + lhSize, + litCSize, + dctx->HUFptr, + flags + ); + } + else + { + assert(litSize >= 6); + hufSuccess = HUF_decompress4X_usingDTable( + dctx->litBuffer, + litSize, + istart + lhSize, + litCSize, + dctx->HUFptr, + flags + ); + } + } + else + { + if (singleStream != 0) + { + hufSuccess = HUF_decompress1X1_DCtx_wksp( + dctx->entropy.hufTable, + dctx->litBuffer, + litSize, + istart + lhSize, + litCSize, + dctx->workspace, + sizeof(uint) * 640, + flags + ); + } + else + { + hufSuccess = HUF_decompress4X_hufOnly_wksp( + dctx->entropy.hufTable, + dctx->litBuffer, + litSize, + istart + lhSize, + litCSize, + dctx->workspace, + sizeof(uint) * 640, + flags + ); + } + } + + if (dctx->litBufferLocation == ZSTD_litLocation_e.ZSTD_split) + { + assert(litSize > 1 << 16); + memcpy(dctx->litExtraBuffer, dctx->litBufferEnd - (1 << 16), 1 << 16); + memmove( + dctx->litBuffer + (1 << 16) - 32, + dctx->litBuffer, + litSize - (1 << 16) + ); + dctx->litBuffer += (1 << 16) - 32; + dctx->litBufferEnd -= 32; + assert(dctx->litBufferEnd <= (byte*)dst + blockSizeMax); + } + + if (ERR_isError(hufSuccess)) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + } + + dctx->litPtr = dctx->litBuffer; + dctx->litSize = litSize; + dctx->litEntropy = 1; + if (litEncType == SymbolEncodingType_e.set_compressed) + dctx->HUFptr = dctx->entropy.hufTable; + return litCSize + lhSize; + } + + case SymbolEncodingType_e.set_basic: + { + nuint litSize, + lhSize; + uint lhlCode = (uint)(istart[0] >> 2 & 3); + nuint expectedWriteSize = + blockSizeMax < dstCapacity ? blockSizeMax : dstCapacity; + switch (lhlCode) + { + case 0: + case 2: + default: + lhSize = 1; + litSize = (nuint)(istart[0] >> 3); + break; + case 1: + lhSize = 2; + litSize = (nuint)(MEM_readLE16(istart) >> 4); + break; + case 3: + lhSize = 3; + if (srcSize < 3) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + } + + litSize = MEM_readLE24(istart) >> 4; + break; + } + + if (litSize > 0 && dst == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (litSize > blockSizeMax) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + } + + if (expectedWriteSize < litSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + ZSTD_allocateLiteralsBuffer( + dctx, + dst, + dstCapacity, + litSize, + streaming, + expectedWriteSize, + 1 + ); + if (lhSize + litSize + 32 > srcSize) + { + if (litSize + lhSize > srcSize) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + } + + if (dctx->litBufferLocation == ZSTD_litLocation_e.ZSTD_split) + { + memcpy(dctx->litBuffer, istart + lhSize, (uint)(litSize - (1 << 16))); + memcpy( + dctx->litExtraBuffer, + istart + lhSize + litSize - (1 << 16), + 1 << 16 + ); + } + else + { + memcpy(dctx->litBuffer, istart + lhSize, (uint)litSize); + } + + dctx->litPtr = dctx->litBuffer; + dctx->litSize = litSize; + return lhSize + litSize; + } + + dctx->litPtr = istart + lhSize; + dctx->litSize = litSize; + dctx->litBufferEnd = dctx->litPtr + litSize; + dctx->litBufferLocation = ZSTD_litLocation_e.ZSTD_not_in_dst; + return lhSize + litSize; + } + + case SymbolEncodingType_e.set_rle: + { + uint lhlCode = (uint)(istart[0] >> 2 & 3); + nuint litSize, + lhSize; + nuint expectedWriteSize = + blockSizeMax < dstCapacity ? blockSizeMax : dstCapacity; + switch (lhlCode) + { + case 0: + case 2: + default: + lhSize = 1; + litSize = (nuint)(istart[0] >> 3); + break; + case 1: + lhSize = 2; + if (srcSize < 3) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + } + + litSize = (nuint)(MEM_readLE16(istart) >> 4); + break; + case 3: + lhSize = 3; + if (srcSize < 4) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + } + + litSize = MEM_readLE24(istart) >> 4; + break; + } + + if (litSize > 0 && dst == null) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (litSize > blockSizeMax) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + } + + if (expectedWriteSize < litSize) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + ZSTD_allocateLiteralsBuffer( + dctx, + dst, + dstCapacity, + litSize, + streaming, + expectedWriteSize, + 1 + ); + if (dctx->litBufferLocation == ZSTD_litLocation_e.ZSTD_split) + { + memset(dctx->litBuffer, istart[lhSize], (uint)(litSize - (1 << 16))); + memset(dctx->litExtraBuffer, istart[lhSize], 1 << 16); + } + else + { + memset(dctx->litBuffer, istart[lhSize], (uint)litSize); + } + + dctx->litPtr = dctx->litBuffer; + dctx->litSize = litSize; + return lhSize + 1; + } + + default: + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + } + } + + /* Hidden declaration for fullbench */ + private static nuint ZSTD_decodeLiteralsBlock_wrapper( + ZSTD_DCtx_s* dctx, + void* src, + nuint srcSize, + void* dst, + nuint dstCapacity + ) + { + dctx->isFrameDecompression = 0; + return ZSTD_decodeLiteralsBlock( + dctx, + src, + srcSize, + dst, + dstCapacity, + streaming_operation.not_streaming + ); + } + + private static readonly ZSTD_seqSymbol* LL_defaultDTable = GetArrayPointer( + new ZSTD_seqSymbol[65] + { + new ZSTD_seqSymbol(nextState: 1, nbAdditionalBits: 1, nbBits: 1, baseValue: 6), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 4, baseValue: 0), + new ZSTD_seqSymbol(nextState: 16, nbAdditionalBits: 0, nbBits: 4, baseValue: 0), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 1), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 3), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 4), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 6), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 7), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 9), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 10), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 12), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 14), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 1, nbBits: 5, baseValue: 16), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 1, nbBits: 5, baseValue: 20), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 1, nbBits: 5, baseValue: 22), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 2, nbBits: 5, baseValue: 28), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 3, nbBits: 5, baseValue: 32), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 4, nbBits: 5, baseValue: 48), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 6, nbBits: 5, baseValue: 64), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 7, nbBits: 5, baseValue: 128), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 8, nbBits: 6, baseValue: 256), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 10, nbBits: 6, baseValue: 1024), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 12, nbBits: 6, baseValue: 4096), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 4, baseValue: 0), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 4, baseValue: 1), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 2), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 4), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 5), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 7), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 8), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 10), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 11), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 13), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 1, nbBits: 5, baseValue: 16), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 1, nbBits: 5, baseValue: 18), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 1, nbBits: 5, baseValue: 22), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 2, nbBits: 5, baseValue: 24), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 3, nbBits: 5, baseValue: 32), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 3, nbBits: 5, baseValue: 40), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 6, nbBits: 4, baseValue: 64), + new ZSTD_seqSymbol(nextState: 16, nbAdditionalBits: 6, nbBits: 4, baseValue: 64), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 7, nbBits: 5, baseValue: 128), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 9, nbBits: 6, baseValue: 512), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 11, nbBits: 6, baseValue: 2048), + new ZSTD_seqSymbol(nextState: 48, nbAdditionalBits: 0, nbBits: 4, baseValue: 0), + new ZSTD_seqSymbol(nextState: 16, nbAdditionalBits: 0, nbBits: 4, baseValue: 1), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 2), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 3), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 5), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 6), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 8), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 9), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 11), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 12), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 15), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 1, nbBits: 5, baseValue: 18), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 1, nbBits: 5, baseValue: 20), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 2, nbBits: 5, baseValue: 24), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 2, nbBits: 5, baseValue: 28), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 3, nbBits: 5, baseValue: 40), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 4, nbBits: 5, baseValue: 48), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 16, nbBits: 6, baseValue: 65536), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 15, nbBits: 6, baseValue: 32768), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 14, nbBits: 6, baseValue: 16384), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 13, nbBits: 6, baseValue: 8192), + } + ); + private static readonly ZSTD_seqSymbol* OF_defaultDTable = GetArrayPointer( + new ZSTD_seqSymbol[33] + { + new ZSTD_seqSymbol(nextState: 1, nbAdditionalBits: 1, nbBits: 1, baseValue: 5), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 0), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 6, nbBits: 4, baseValue: 61), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 9, nbBits: 5, baseValue: 509), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 15, nbBits: 5, baseValue: 32765), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 21, nbBits: 5, baseValue: 2097149), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 3, nbBits: 5, baseValue: 5), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 7, nbBits: 4, baseValue: 125), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 12, nbBits: 5, baseValue: 4093), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 18, nbBits: 5, baseValue: 262141), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 23, nbBits: 5, baseValue: 8388605), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 5, nbBits: 5, baseValue: 29), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 8, nbBits: 4, baseValue: 253), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 14, nbBits: 5, baseValue: 16381), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 20, nbBits: 5, baseValue: 1048573), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 2, nbBits: 5, baseValue: 1), + new ZSTD_seqSymbol(nextState: 16, nbAdditionalBits: 7, nbBits: 4, baseValue: 125), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 11, nbBits: 5, baseValue: 2045), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 17, nbBits: 5, baseValue: 131069), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 22, nbBits: 5, baseValue: 4194301), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 4, nbBits: 5, baseValue: 13), + new ZSTD_seqSymbol(nextState: 16, nbAdditionalBits: 8, nbBits: 4, baseValue: 253), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 13, nbBits: 5, baseValue: 8189), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 19, nbBits: 5, baseValue: 524285), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 1, nbBits: 5, baseValue: 1), + new ZSTD_seqSymbol(nextState: 16, nbAdditionalBits: 6, nbBits: 4, baseValue: 61), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 10, nbBits: 5, baseValue: 1021), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 16, nbBits: 5, baseValue: 65533), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 28, nbBits: 5, baseValue: 268435453), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 27, nbBits: 5, baseValue: 134217725), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 26, nbBits: 5, baseValue: 67108861), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 25, nbBits: 5, baseValue: 33554429), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 24, nbBits: 5, baseValue: 16777213), + } + ); + private static readonly ZSTD_seqSymbol* ML_defaultDTable = GetArrayPointer( + new ZSTD_seqSymbol[65] + { + new ZSTD_seqSymbol(nextState: 1, nbAdditionalBits: 1, nbBits: 1, baseValue: 6), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 3), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 4, baseValue: 4), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 5), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 6), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 8), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 9), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 11), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 13), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 16), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 19), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 22), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 25), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 28), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 31), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 34), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 1, nbBits: 6, baseValue: 37), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 1, nbBits: 6, baseValue: 41), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 2, nbBits: 6, baseValue: 47), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 3, nbBits: 6, baseValue: 59), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 4, nbBits: 6, baseValue: 83), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 7, nbBits: 6, baseValue: 131), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 9, nbBits: 6, baseValue: 515), + new ZSTD_seqSymbol(nextState: 16, nbAdditionalBits: 0, nbBits: 4, baseValue: 4), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 4, baseValue: 5), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 6), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 7), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 9), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 5, baseValue: 10), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 12), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 15), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 18), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 21), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 24), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 27), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 30), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 33), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 1, nbBits: 6, baseValue: 35), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 1, nbBits: 6, baseValue: 39), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 2, nbBits: 6, baseValue: 43), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 3, nbBits: 6, baseValue: 51), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 4, nbBits: 6, baseValue: 67), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 5, nbBits: 6, baseValue: 99), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 8, nbBits: 6, baseValue: 259), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 4, baseValue: 4), + new ZSTD_seqSymbol(nextState: 48, nbAdditionalBits: 0, nbBits: 4, baseValue: 4), + new ZSTD_seqSymbol(nextState: 16, nbAdditionalBits: 0, nbBits: 4, baseValue: 5), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 7), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 8), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 10), + new ZSTD_seqSymbol(nextState: 32, nbAdditionalBits: 0, nbBits: 5, baseValue: 11), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 14), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 17), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 20), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 23), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 26), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 29), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 0, nbBits: 6, baseValue: 32), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 16, nbBits: 6, baseValue: 65539), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 15, nbBits: 6, baseValue: 32771), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 14, nbBits: 6, baseValue: 16387), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 13, nbBits: 6, baseValue: 8195), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 12, nbBits: 6, baseValue: 4099), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 11, nbBits: 6, baseValue: 2051), + new ZSTD_seqSymbol(nextState: 0, nbAdditionalBits: 10, nbBits: 6, baseValue: 1027), + } + ); + + private static void ZSTD_buildSeqTable_rle(ZSTD_seqSymbol* dt, uint baseValue, byte nbAddBits) + { + void* ptr = dt; + ZSTD_seqSymbol_header* DTableH = (ZSTD_seqSymbol_header*)ptr; + ZSTD_seqSymbol* cell = dt + 1; + DTableH->tableLog = 0; + DTableH->fastMode = 0; + cell->nbBits = 0; + cell->nextState = 0; + assert(nbAddBits < 255); + cell->nbAdditionalBits = nbAddBits; + cell->baseValue = baseValue; + } + + /* ZSTD_buildFSETable() : + * generate FSE decoding table for one symbol (ll, ml or off) + * cannot fail if input is valid => + * all inputs are presumed validated at this stage */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_buildFSETable_body( + ZSTD_seqSymbol* dt, + short* normalizedCounter, + uint maxSymbolValue, + uint* baseValue, + byte* nbAdditionalBits, + uint tableLog, + void* wksp, + nuint wkspSize + ) + { + ZSTD_seqSymbol* tableDecode = dt + 1; + uint maxSV1 = maxSymbolValue + 1; + uint tableSize = (uint)(1 << (int)tableLog); + ushort* symbolNext = (ushort*)wksp; + byte* spread = (byte*)(symbolNext + 52 + 1); + uint highThreshold = tableSize - 1; + assert(maxSymbolValue <= 52); + assert(tableLog <= 9); + assert(wkspSize >= sizeof(short) * (52 + 1) + (1U << 9) + sizeof(ulong)); + { + ZSTD_seqSymbol_header DTableH; + DTableH.tableLog = tableLog; + DTableH.fastMode = 1; + { + short largeLimit = (short)(1 << (int)(tableLog - 1)); + uint s; + for (s = 0; s < maxSV1; s++) + { + if (normalizedCounter[s] == -1) + { + tableDecode[highThreshold--].baseValue = s; + symbolNext[s] = 1; + } + else + { + if (normalizedCounter[s] >= largeLimit) + DTableH.fastMode = 0; + assert(normalizedCounter[s] >= 0); + symbolNext[s] = (ushort)normalizedCounter[s]; + } + } + } + + memcpy(dt, &DTableH, (uint)sizeof(ZSTD_seqSymbol_header)); + } + + assert(tableSize <= 512); + if (highThreshold == tableSize - 1) + { + nuint tableMask = tableSize - 1; + nuint step = (tableSize >> 1) + (tableSize >> 3) + 3; + { + const ulong add = 0x0101010101010101UL; + nuint pos = 0; + ulong sv = 0; + uint s; + for (s = 0; s < maxSV1; ++s, sv += add) + { + int i; + int n = normalizedCounter[s]; + MEM_write64(spread + pos, sv); + for (i = 8; i < n; i += 8) + { + MEM_write64(spread + pos + i, sv); + } + + assert(n >= 0); + pos += (nuint)n; + } + } + + { + nuint position = 0; + nuint s; + const nuint unroll = 2; + assert(tableSize % unroll == 0); + for (s = 0; s < tableSize; s += unroll) + { + nuint u; + for (u = 0; u < unroll; ++u) + { + nuint uPosition = position + u * step & tableMask; + tableDecode[uPosition].baseValue = spread[s + u]; + } + + position = position + unroll * step & tableMask; + } + + assert(position == 0); + } + } + else + { + uint tableMask = tableSize - 1; + uint step = (tableSize >> 1) + (tableSize >> 3) + 3; + uint s, + position = 0; + for (s = 0; s < maxSV1; s++) + { + int i; + int n = normalizedCounter[s]; + for (i = 0; i < n; i++) + { + tableDecode[position].baseValue = s; + position = position + step & tableMask; + while (position > highThreshold) + position = position + step & tableMask; + } + } + + assert(position == 0); + } + + { + uint u; + for (u = 0; u < tableSize; u++) + { + uint symbol = tableDecode[u].baseValue; + uint nextState = symbolNext[symbol]++; + tableDecode[u].nbBits = (byte)(tableLog - ZSTD_highbit32(nextState)); + tableDecode[u].nextState = (ushort)( + (nextState << tableDecode[u].nbBits) - tableSize + ); + assert(nbAdditionalBits[symbol] < 255); + tableDecode[u].nbAdditionalBits = nbAdditionalBits[symbol]; + tableDecode[u].baseValue = baseValue[symbol]; + } + } + } + + /* Avoids the FORCE_INLINE of the _body() function. */ + private static void ZSTD_buildFSETable_body_default( + ZSTD_seqSymbol* dt, + short* normalizedCounter, + uint maxSymbolValue, + uint* baseValue, + byte* nbAdditionalBits, + uint tableLog, + void* wksp, + nuint wkspSize + ) + { + ZSTD_buildFSETable_body( + dt, + normalizedCounter, + maxSymbolValue, + baseValue, + nbAdditionalBits, + tableLog, + wksp, + wkspSize + ); + } + + /* ZSTD_buildFSETable() : + * generate FSE decoding table for one symbol (ll, ml or off) + * this function must be called with valid parameters only + * (dt is large enough, normalizedCounter distribution total is a power of 2, max is within range, etc.) + * in which case it cannot fail. + * The workspace must be 4-byte aligned and at least ZSTD_BUILD_FSE_TABLE_WKSP_SIZE bytes, which is + * defined in zstd_decompress_internal.h. + * Internal use only. + */ + private static void ZSTD_buildFSETable( + ZSTD_seqSymbol* dt, + short* normalizedCounter, + uint maxSymbolValue, + uint* baseValue, + byte* nbAdditionalBits, + uint tableLog, + void* wksp, + nuint wkspSize, + int bmi2 + ) + { + ZSTD_buildFSETable_body_default( + dt, + normalizedCounter, + maxSymbolValue, + baseValue, + nbAdditionalBits, + tableLog, + wksp, + wkspSize + ); + } + + /*! ZSTD_buildSeqTable() : + * @return : nb bytes read from src, + * or an error code if it fails */ + private static nuint ZSTD_buildSeqTable( + ZSTD_seqSymbol* DTableSpace, + ZSTD_seqSymbol** DTablePtr, + SymbolEncodingType_e type, + uint max, + uint maxLog, + void* src, + nuint srcSize, + uint* baseValue, + byte* nbAdditionalBits, + ZSTD_seqSymbol* defaultTable, + uint flagRepeatTable, + int ddictIsCold, + int nbSeq, + uint* wksp, + nuint wkspSize, + int bmi2 + ) + { + switch (type) + { + case SymbolEncodingType_e.set_rle: + if (srcSize == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if (*(byte*)src > max) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + { + uint symbol = *(byte*)src; + uint baseline = baseValue[symbol]; + byte nbBits = nbAdditionalBits[symbol]; + ZSTD_buildSeqTable_rle(DTableSpace, baseline, nbBits); + } + + *DTablePtr = DTableSpace; + return 1; + case SymbolEncodingType_e.set_basic: + *DTablePtr = defaultTable; + return 0; + case SymbolEncodingType_e.set_repeat: + if (flagRepeatTable == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + if (ddictIsCold != 0 && nbSeq > 24) + { + void* pStart = *DTablePtr; + nuint pSize = (nuint)(sizeof(ZSTD_seqSymbol) * (1 + (1 << (int)maxLog))); + { + sbyte* _ptr = (sbyte*)pStart; + nuint _size = pSize; + nuint _pos; + for (_pos = 0; _pos < _size; _pos += 64) + { +#if NETCOREAPP3_0_OR_GREATER + if (System.Runtime.Intrinsics.X86.Sse.IsSupported) + { + System.Runtime.Intrinsics.X86.Sse.Prefetch1(_ptr + _pos); + } +#endif + } + } + } + + return 0; + case SymbolEncodingType_e.set_compressed: + { + uint tableLog; + short* norm = stackalloc short[53]; + nuint headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize); + if (ERR_isError(headerSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + if (tableLog > maxLog) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + ZSTD_buildFSETable( + DTableSpace, + norm, + max, + baseValue, + nbAdditionalBits, + tableLog, + wksp, + wkspSize, + bmi2 + ); + *DTablePtr = DTableSpace; + return headerSize; + } + + default: + assert(0 != 0); + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC)); + } + } + + /*! ZSTD_decodeSeqHeaders() : + * decode sequence header from src */ + /* Used by: zstd_decompress_block, fullbench */ + private static nuint ZSTD_decodeSeqHeaders( + ZSTD_DCtx_s* dctx, + int* nbSeqPtr, + void* src, + nuint srcSize + ) + { + byte* istart = (byte*)src; + byte* iend = istart + srcSize; + byte* ip = istart; + int nbSeq; + if (srcSize < 1) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + nbSeq = *ip++; + if (nbSeq > 0x7F) + { + if (nbSeq == 0xFF) + { + if (ip + 2 > iend) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + nbSeq = MEM_readLE16(ip) + 0x7F00; + ip += 2; + } + else + { + if (ip >= iend) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + nbSeq = (nbSeq - 0x80 << 8) + *ip++; + } + } + + *nbSeqPtr = nbSeq; + if (nbSeq == 0) + { + if (ip != iend) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + return (nuint)(ip - istart); + } + + if (ip + 1 > iend) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + if ((*ip & 3) != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + { + SymbolEncodingType_e LLtype = (SymbolEncodingType_e)(*ip >> 6); + SymbolEncodingType_e OFtype = (SymbolEncodingType_e)(*ip >> 4 & 3); + SymbolEncodingType_e MLtype = (SymbolEncodingType_e)(*ip >> 2 & 3); + ip++; + { + nuint llhSize = ZSTD_buildSeqTable( + &dctx->entropy.LLTable.e0, + &dctx->LLTptr, + LLtype, + 35, + 9, + ip, + (nuint)(iend - ip), + LL_base, + LL_bits, + LL_defaultDTable, + dctx->fseEntropy, + dctx->ddictIsCold, + nbSeq, + dctx->workspace, + sizeof(uint) * 640, + ZSTD_DCtx_get_bmi2(dctx) + ); + if (ERR_isError(llhSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + ip += llhSize; + } + + { + nuint ofhSize = ZSTD_buildSeqTable( + &dctx->entropy.OFTable.e0, + &dctx->OFTptr, + OFtype, + 31, + 8, + ip, + (nuint)(iend - ip), + OF_base, + OF_bits, + OF_defaultDTable, + dctx->fseEntropy, + dctx->ddictIsCold, + nbSeq, + dctx->workspace, + sizeof(uint) * 640, + ZSTD_DCtx_get_bmi2(dctx) + ); + if (ERR_isError(ofhSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + ip += ofhSize; + } + + { + nuint mlhSize = ZSTD_buildSeqTable( + &dctx->entropy.MLTable.e0, + &dctx->MLTptr, + MLtype, + 52, + 9, + ip, + (nuint)(iend - ip), + ML_base, + ML_bits, + ML_defaultDTable, + dctx->fseEntropy, + dctx->ddictIsCold, + nbSeq, + dctx->workspace, + sizeof(uint) * 640, + ZSTD_DCtx_get_bmi2(dctx) + ); + if (ERR_isError(mlhSize)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + ip += mlhSize; + } + } + + return (nuint)(ip - istart); + } + +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_dec32table => new uint[8] { 0, 1, 2, 1, 4, 4, 4, 4 }; + private static uint* dec32table => + (uint*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_dec32table) + ); +#else + + private static readonly uint* dec32table = GetArrayPointer( + new uint[8] { 0, 1, 2, 1, 4, 4, 4, 4 } + ); +#endif +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_dec64table => new int[8] { 8, 8, 8, 7, 8, 9, 10, 11 }; + private static int* dec64table => + (int*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_dec64table) + ); +#else + + private static readonly int* dec64table = GetArrayPointer( + new int[8] { 8, 8, 8, 7, 8, 9, 10, 11 } + ); +#endif + /*! ZSTD_overlapCopy8() : + * Copies 8 bytes from ip to op and updates op and ip where ip <= op. + * If the offset is < 8 then the offset is spread to at least 8 bytes. + * + * Precondition: *ip <= *op + * Postcondition: *op - *op >= 8 + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_overlapCopy8(byte** op, byte** ip, nuint offset) + { + assert(*ip <= *op); + if (offset < 8) + { + int sub2 = dec64table[offset]; + (*op)[0] = (*ip)[0]; + (*op)[1] = (*ip)[1]; + (*op)[2] = (*ip)[2]; + (*op)[3] = (*ip)[3]; + *ip += dec32table[offset]; + ZSTD_copy4(*op + 4, *ip); + *ip -= sub2; + } + else + { + ZSTD_copy8(*op, *ip); + } + + *ip += 8; + *op += 8; + assert(*op - *ip >= 8); + } + + /*! ZSTD_safecopy() : + * Specialized version of memcpy() that is allowed to READ up to WILDCOPY_OVERLENGTH past the input buffer + * and write up to 16 bytes past oend_w (op >= oend_w is allowed). + * This function is only called in the uncommon case where the sequence is near the end of the block. It + * should be fast for a single long sequence, but can be slow for several short sequences. + * + * @param ovtype controls the overlap detection + * - ZSTD_no_overlap: The source and destination are guaranteed to be at least WILDCOPY_VECLEN bytes apart. + * - ZSTD_overlap_src_before_dst: The src and dst may overlap and may be any distance apart. + * The src buffer must be before the dst buffer. + */ + private static void ZSTD_safecopy( + byte* op, + byte* oend_w, + byte* ip, + nint length, + ZSTD_overlap_e ovtype + ) + { + nint diff = (nint)(op - ip); + byte* oend = op + length; + assert( + ovtype == ZSTD_overlap_e.ZSTD_no_overlap && (diff <= -8 || diff >= 8 || op >= oend_w) + || ovtype == ZSTD_overlap_e.ZSTD_overlap_src_before_dst && diff >= 0 + ); + if (length < 8) + { + while (op < oend) + *op++ = *ip++; + return; + } + + if (ovtype == ZSTD_overlap_e.ZSTD_overlap_src_before_dst) + { + assert(length >= 8); + ZSTD_overlapCopy8(&op, &ip, (nuint)diff); + length -= 8; + assert(op - ip >= 8); + assert(op <= oend); + } + + if (oend <= oend_w) + { + ZSTD_wildcopy(op, ip, length, ovtype); + return; + } + + if (op <= oend_w) + { + assert(oend > oend_w); + ZSTD_wildcopy(op, ip, (nint)(oend_w - op), ovtype); + ip += oend_w - op; + op += oend_w - op; + } + + while (op < oend) + *op++ = *ip++; + } + + /* ZSTD_safecopyDstBeforeSrc(): + * This version allows overlap with dst before src, or handles the non-overlap case with dst after src + * Kept separate from more common ZSTD_safecopy case to avoid performance impact to the safecopy common case */ + private static void ZSTD_safecopyDstBeforeSrc(byte* op, byte* ip, nint length) + { + nint diff = (nint)(op - ip); + byte* oend = op + length; + if (length < 8 || diff > -8) + { + while (op < oend) + *op++ = *ip++; + return; + } + + if (op <= oend - 32 && diff < -16) + { + ZSTD_wildcopy(op, ip, (nint)(oend - 32 - op), ZSTD_overlap_e.ZSTD_no_overlap); + ip += oend - 32 - op; + op += oend - 32 - op; + } + + while (op < oend) + *op++ = *ip++; + } + + /* ZSTD_execSequenceEnd(): + * This version handles cases that are near the end of the output buffer. It requires + * more careful checks to make sure there is no overflow. By separating out these hard + * and unlikely cases, we can speed up the common cases. + * + * NOTE: This function needs to be fast for a single long sequence, but doesn't need + * to be optimized for many small sequences, since those fall into ZSTD_execSequence(). + */ + private static nuint ZSTD_execSequenceEnd( + byte* op, + byte* oend, + seq_t sequence, + byte** litPtr, + byte* litLimit, + byte* prefixStart, + byte* virtualStart, + byte* dictEnd + ) + { + byte* oLitEnd = op + sequence.litLength; + nuint sequenceLength = sequence.litLength + sequence.matchLength; + byte* iLitEnd = *litPtr + sequence.litLength; + byte* match = oLitEnd - sequence.offset; + byte* oend_w = oend - 32; + if (sequenceLength > (nuint)(oend - op)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (sequence.litLength > (nuint)(litLimit - *litPtr)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + assert(op < op + sequenceLength); + assert(oLitEnd < op + sequenceLength); + ZSTD_safecopy( + op, + oend_w, + *litPtr, + (nint)sequence.litLength, + ZSTD_overlap_e.ZSTD_no_overlap + ); + op = oLitEnd; + *litPtr = iLitEnd; + if (sequence.offset > (nuint)(oLitEnd - prefixStart)) + { + if (sequence.offset > (nuint)(oLitEnd - virtualStart)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + match = dictEnd - (prefixStart - match); + if (match + sequence.matchLength <= dictEnd) + { + memmove(oLitEnd, match, sequence.matchLength); + return sequenceLength; + } + + { + nuint length1 = (nuint)(dictEnd - match); + memmove(oLitEnd, match, length1); + op = oLitEnd + length1; + sequence.matchLength -= length1; + match = prefixStart; + } + } + + ZSTD_safecopy( + op, + oend_w, + match, + (nint)sequence.matchLength, + ZSTD_overlap_e.ZSTD_overlap_src_before_dst + ); + return sequenceLength; + } + + /* ZSTD_execSequenceEndSplitLitBuffer(): + * This version is intended to be used during instances where the litBuffer is still split. It is kept separate to avoid performance impact for the good case. + */ + private static nuint ZSTD_execSequenceEndSplitLitBuffer( + byte* op, + byte* oend, + byte* oend_w, + seq_t sequence, + byte** litPtr, + byte* litLimit, + byte* prefixStart, + byte* virtualStart, + byte* dictEnd + ) + { + byte* oLitEnd = op + sequence.litLength; + nuint sequenceLength = sequence.litLength + sequence.matchLength; + byte* iLitEnd = *litPtr + sequence.litLength; + byte* match = oLitEnd - sequence.offset; + if (sequenceLength > (nuint)(oend - op)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (sequence.litLength > (nuint)(litLimit - *litPtr)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + assert(op < op + sequenceLength); + assert(oLitEnd < op + sequenceLength); + if (op > *litPtr && op < *litPtr + sequence.litLength) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + ZSTD_safecopyDstBeforeSrc(op, *litPtr, (nint)sequence.litLength); + op = oLitEnd; + *litPtr = iLitEnd; + if (sequence.offset > (nuint)(oLitEnd - prefixStart)) + { + if (sequence.offset > (nuint)(oLitEnd - virtualStart)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + match = dictEnd - (prefixStart - match); + if (match + sequence.matchLength <= dictEnd) + { + memmove(oLitEnd, match, sequence.matchLength); + return sequenceLength; + } + + { + nuint length1 = (nuint)(dictEnd - match); + memmove(oLitEnd, match, length1); + op = oLitEnd + length1; + sequence.matchLength -= length1; + match = prefixStart; + } + } + + ZSTD_safecopy( + op, + oend_w, + match, + (nint)sequence.matchLength, + ZSTD_overlap_e.ZSTD_overlap_src_before_dst + ); + return sequenceLength; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_execSequence( + byte* op, + byte* oend, + seq_t sequence, + byte** litPtr, + byte* litLimit, + byte* prefixStart, + byte* virtualStart, + byte* dictEnd + ) + { + var sequence_litLength = sequence.litLength; + var sequence_matchLength = sequence.matchLength; + var sequence_offset = sequence.offset; + byte* oLitEnd = op + sequence_litLength; + nuint sequenceLength = sequence_litLength + sequence_matchLength; + /* risk : address space overflow (32-bits) */ + byte* oMatchEnd = op + sequenceLength; + /* risk : address space underflow on oend=NULL */ + byte* oend_w = oend - 32; + byte* iLitEnd = *litPtr + sequence_litLength; + byte* match = oLitEnd - sequence_offset; + assert(op != null); + assert(oend_w < oend); + if ( + iLitEnd > litLimit + || oMatchEnd > oend_w + || MEM_32bits && (nuint)(oend - op) < sequenceLength + 32 + ) + return ZSTD_execSequenceEnd( + op, + oend, + new seq_t + { + litLength = sequence_litLength, + matchLength = sequence_matchLength, + offset = sequence_offset, + }, + litPtr, + litLimit, + prefixStart, + virtualStart, + dictEnd + ); + assert(op <= oLitEnd); + assert(oLitEnd < oMatchEnd); + assert(oMatchEnd <= oend); + assert(iLitEnd <= litLimit); + assert(oLitEnd <= oend_w); + assert(oMatchEnd <= oend_w); + assert(32 >= 16); + ZSTD_copy16(op, *litPtr); + if (sequence_litLength > 16) + { + ZSTD_wildcopy( + op + 16, + *litPtr + 16, + (nint)(sequence_litLength - 16), + ZSTD_overlap_e.ZSTD_no_overlap + ); + } + + op = oLitEnd; + *litPtr = iLitEnd; + if (sequence_offset > (nuint)(oLitEnd - prefixStart)) + { + if (sequence_offset > (nuint)(oLitEnd - virtualStart)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + match = dictEnd + (match - prefixStart); + if (match + sequence_matchLength <= dictEnd) + { + memmove(oLitEnd, match, sequence_matchLength); + return sequenceLength; + } + + { + nuint length1 = (nuint)(dictEnd - match); + memmove(oLitEnd, match, length1); + op = oLitEnd + length1; + sequence_matchLength -= length1; + match = prefixStart; + } + } + + assert(op <= oMatchEnd); + assert(oMatchEnd <= oend_w); + assert(match >= prefixStart); + assert(sequence_matchLength >= 1); + if (sequence_offset >= 16) + { + ZSTD_wildcopy(op, match, (nint)sequence_matchLength, ZSTD_overlap_e.ZSTD_no_overlap); + return sequenceLength; + } + + assert(sequence_offset < 16); + ZSTD_overlapCopy8(ref op, ref match, sequence_offset); + if (sequence_matchLength > 8) + { + assert(op < oMatchEnd); + ZSTD_wildcopy( + op, + match, + (nint)sequence_matchLength - 8, + ZSTD_overlap_e.ZSTD_overlap_src_before_dst + ); + } + + return sequenceLength; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_execSequenceSplitLitBuffer( + byte* op, + byte* oend, + byte* oend_w, + seq_t sequence, + byte** litPtr, + byte* litLimit, + byte* prefixStart, + byte* virtualStart, + byte* dictEnd + ) + { + byte* oLitEnd = op + sequence.litLength; + nuint sequenceLength = sequence.litLength + sequence.matchLength; + /* risk : address space overflow (32-bits) */ + byte* oMatchEnd = op + sequenceLength; + byte* iLitEnd = *litPtr + sequence.litLength; + byte* match = oLitEnd - sequence.offset; + assert(op != null); + assert(oend_w < oend); + if ( + iLitEnd > litLimit + || oMatchEnd > oend_w + || MEM_32bits && (nuint)(oend - op) < sequenceLength + 32 + ) + return ZSTD_execSequenceEndSplitLitBuffer( + op, + oend, + oend_w, + sequence, + litPtr, + litLimit, + prefixStart, + virtualStart, + dictEnd + ); + assert(op <= oLitEnd); + assert(oLitEnd < oMatchEnd); + assert(oMatchEnd <= oend); + assert(iLitEnd <= litLimit); + assert(oLitEnd <= oend_w); + assert(oMatchEnd <= oend_w); + assert(32 >= 16); + ZSTD_copy16(op, *litPtr); + if (sequence.litLength > 16) + { + ZSTD_wildcopy( + op + 16, + *litPtr + 16, + (nint)(sequence.litLength - 16), + ZSTD_overlap_e.ZSTD_no_overlap + ); + } + + op = oLitEnd; + *litPtr = iLitEnd; + if (sequence.offset > (nuint)(oLitEnd - prefixStart)) + { + if (sequence.offset > (nuint)(oLitEnd - virtualStart)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + match = dictEnd + (match - prefixStart); + if (match + sequence.matchLength <= dictEnd) + { + memmove(oLitEnd, match, sequence.matchLength); + return sequenceLength; + } + + { + nuint length1 = (nuint)(dictEnd - match); + memmove(oLitEnd, match, length1); + op = oLitEnd + length1; + sequence.matchLength -= length1; + match = prefixStart; + } + } + + assert(op <= oMatchEnd); + assert(oMatchEnd <= oend_w); + assert(match >= prefixStart); + assert(sequence.matchLength >= 1); + if (sequence.offset >= 16) + { + ZSTD_wildcopy(op, match, (nint)sequence.matchLength, ZSTD_overlap_e.ZSTD_no_overlap); + return sequenceLength; + } + + assert(sequence.offset < 16); + ZSTD_overlapCopy8(&op, &match, sequence.offset); + if (sequence.matchLength > 8) + { + assert(op < oMatchEnd); + ZSTD_wildcopy( + op, + match, + (nint)sequence.matchLength - 8, + ZSTD_overlap_e.ZSTD_overlap_src_before_dst + ); + } + + return sequenceLength; + } + + private static void ZSTD_initFseState( + ZSTD_fseState* DStatePtr, + BIT_DStream_t* bitD, + ZSTD_seqSymbol* dt + ) + { + void* ptr = dt; + ZSTD_seqSymbol_header* DTableH = (ZSTD_seqSymbol_header*)ptr; + DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog); + BIT_reloadDStream(bitD); + DStatePtr->table = dt + 1; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_updateFseStateWithDInfo( + ZSTD_fseState* DStatePtr, + BIT_DStream_t* bitD, + ushort nextState, + uint nbBits + ) + { + nuint lowBits = BIT_readBits(bitD, nbBits); + DStatePtr->state = nextState + lowBits; + } + + /** + * ZSTD_decodeSequence(): + * @p longOffsets : tells the decoder to reload more bit while decoding large offsets + * only used in 32-bit mode + * @return : Sequence (litL + matchL + offset) + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static seq_t ZSTD_decodeSequence( + seqState_t* seqState, + ZSTD_longOffset_e longOffsets, + int isLastSeq + ) + { + seq_t seq; + ZSTD_seqSymbol* llDInfo = seqState->stateLL.table + seqState->stateLL.state; + ZSTD_seqSymbol* mlDInfo = seqState->stateML.table + seqState->stateML.state; + ZSTD_seqSymbol* ofDInfo = seqState->stateOffb.table + seqState->stateOffb.state; + seq.matchLength = mlDInfo->baseValue; + seq.litLength = llDInfo->baseValue; + { + uint ofBase = ofDInfo->baseValue; + byte llBits = llDInfo->nbAdditionalBits; + byte mlBits = mlDInfo->nbAdditionalBits; + byte ofBits = ofDInfo->nbAdditionalBits; + byte totalBits = (byte)(llBits + mlBits + ofBits); + ushort llNext = llDInfo->nextState; + ushort mlNext = mlDInfo->nextState; + ushort ofNext = ofDInfo->nextState; + uint llnbBits = llDInfo->nbBits; + uint mlnbBits = mlDInfo->nbBits; + uint ofnbBits = ofDInfo->nbBits; + assert(llBits <= 16); + assert(mlBits <= 16); + assert(ofBits <= 31); + { + nuint offset; + if (ofBits > 1) + { + if (MEM_32bits && longOffsets != default && ofBits >= 25) + { + /* Always read extra bits, this keeps the logic simple, + * avoids branches, and avoids accidentally reading 0 bits. + */ + const uint extraBits = 30 - 25; + offset = + ofBase + + ( + BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) + << (int)extraBits + ); + BIT_reloadDStream(&seqState->DStream); + offset += BIT_readBitsFast(&seqState->DStream, extraBits); + } + else + { + offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits); + if (MEM_32bits) + BIT_reloadDStream(&seqState->DStream); + } + + seqState->prevOffset.e2 = seqState->prevOffset.e1; + seqState->prevOffset.e1 = seqState->prevOffset.e0; + seqState->prevOffset.e0 = offset; + } + else + { + uint ll0 = llDInfo->baseValue == 0 ? 1U : 0U; + if (ofBits == 0) + { + offset = (&seqState->prevOffset.e0)[ll0]; + seqState->prevOffset.e1 = (&seqState->prevOffset.e0)[ll0 == 0 ? 1 : 0]; + seqState->prevOffset.e0 = offset; + } + else + { + offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1); + { + nuint temp = + offset == 3 + ? seqState->prevOffset.e0 - 1 + : (&seqState->prevOffset.e0)[offset]; + temp -= temp == 0 ? 1U : 0U; + if (offset != 1) + seqState->prevOffset.e2 = seqState->prevOffset.e1; + seqState->prevOffset.e1 = seqState->prevOffset.e0; + seqState->prevOffset.e0 = offset = temp; + } + } + } + + seq.offset = offset; + } + + if (mlBits > 0) + seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits); + if (MEM_32bits && mlBits + llBits >= 25 - (30 - 25)) + BIT_reloadDStream(&seqState->DStream); + if (MEM_64bits && totalBits >= 57 - (9 + 9 + 8)) + BIT_reloadDStream(&seqState->DStream); + if (llBits > 0) + seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits); + if (MEM_32bits) + BIT_reloadDStream(&seqState->DStream); + if (isLastSeq == 0) + { + ZSTD_updateFseStateWithDInfo( + &seqState->stateLL, + &seqState->DStream, + llNext, + llnbBits + ); + ZSTD_updateFseStateWithDInfo( + &seqState->stateML, + &seqState->DStream, + mlNext, + mlnbBits + ); + if (MEM_32bits) + BIT_reloadDStream(&seqState->DStream); + ZSTD_updateFseStateWithDInfo( + &seqState->stateOffb, + &seqState->DStream, + ofNext, + ofnbBits + ); + BIT_reloadDStream(&seqState->DStream); + } + } + + return seq; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_decompressSequences_bodySplitLitBuffer( + ZSTD_DCtx_s* dctx, + void* dst, + nuint maxDstSize, + void* seqStart, + nuint seqSize, + int nbSeq, + ZSTD_longOffset_e isLongOffset + ) + { + byte* ip = (byte*)seqStart; + byte* iend = ip + seqSize; + byte* ostart = (byte*)dst; + byte* oend = ZSTD_maybeNullPtrAdd(ostart, (nint)maxDstSize); + byte* op = ostart; + byte* litPtr = dctx->litPtr; + byte* litBufferEnd = dctx->litBufferEnd; + byte* prefixStart = (byte*)dctx->prefixStart; + byte* vBase = (byte*)dctx->virtualStart; + byte* dictEnd = (byte*)dctx->dictEnd; + if (nbSeq != 0) + { + seqState_t seqState; + dctx->fseEntropy = 1; + { + uint i; + for (i = 0; i < 3; i++) + (&seqState.prevOffset.e0)[i] = dctx->entropy.rep[i]; + } + + if (ERR_isError(BIT_initDStream(&seqState.DStream, ip, (nuint)(iend - ip)))) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); + ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr); + ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr); + assert(dst != null); + { + /* some static analyzer believe that @sequence is not initialized (it necessarily is, since for(;;) loop as at least one iteration) */ + seq_t sequence = new seq_t + { + litLength = 0, + matchLength = 0, + offset = 0, + }; + for (; nbSeq != 0; nbSeq--) + { + sequence = ZSTD_decodeSequence(&seqState, isLongOffset, nbSeq == 1 ? 1 : 0); + if (litPtr + sequence.litLength > dctx->litBufferEnd) + break; + { + nuint oneSeqSize = ZSTD_execSequenceSplitLitBuffer( + op, + oend, + litPtr + sequence.litLength - 32, + sequence, + &litPtr, + litBufferEnd, + prefixStart, + vBase, + dictEnd + ); + if (ERR_isError(oneSeqSize)) + return oneSeqSize; + op += oneSeqSize; + } + } + + if (nbSeq > 0) + { + nuint leftoverLit = (nuint)(dctx->litBufferEnd - litPtr); + if (leftoverLit != 0) + { + if (leftoverLit > (nuint)(oend - op)) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall) + ); + } + + ZSTD_safecopyDstBeforeSrc(op, litPtr, (nint)leftoverLit); + sequence.litLength -= leftoverLit; + op += leftoverLit; + } + + litPtr = dctx->litExtraBuffer; + litBufferEnd = dctx->litExtraBuffer + (1 << 16); + dctx->litBufferLocation = ZSTD_litLocation_e.ZSTD_not_in_dst; + { + nuint oneSeqSize = ZSTD_execSequence( + op, + oend, + sequence, + &litPtr, + litBufferEnd, + prefixStart, + vBase, + dictEnd + ); + if (ERR_isError(oneSeqSize)) + return oneSeqSize; + op += oneSeqSize; + } + + nbSeq--; + } + } + + if (nbSeq > 0) + { + for (; nbSeq != 0; nbSeq--) + { + seq_t sequence = ZSTD_decodeSequence( + &seqState, + isLongOffset, + nbSeq == 1 ? 1 : 0 + ); + nuint oneSeqSize = ZSTD_execSequence( + op, + oend, + sequence, + &litPtr, + litBufferEnd, + prefixStart, + vBase, + dictEnd + ); + if (ERR_isError(oneSeqSize)) + return oneSeqSize; + op += oneSeqSize; + } + } + + if (nbSeq != 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + if (BIT_endOfDStream(&seqState.DStream) == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + { + uint i; + for (i = 0; i < 3; i++) + dctx->entropy.rep[i] = (uint)(&seqState.prevOffset.e0)[i]; + } + } + + if (dctx->litBufferLocation == ZSTD_litLocation_e.ZSTD_split) + { + /* split hasn't been reached yet, first get dst then copy litExtraBuffer */ + nuint lastLLSize = (nuint)(litBufferEnd - litPtr); + if (lastLLSize > (nuint)(oend - op)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (op != null) + { + memmove(op, litPtr, lastLLSize); + op += lastLLSize; + } + + litPtr = dctx->litExtraBuffer; + litBufferEnd = dctx->litExtraBuffer + (1 << 16); + dctx->litBufferLocation = ZSTD_litLocation_e.ZSTD_not_in_dst; + } + + { + nuint lastLLSize = (nuint)(litBufferEnd - litPtr); + if (lastLLSize > (nuint)(oend - op)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (op != null) + { + memcpy(op, litPtr, (uint)lastLLSize); + op += lastLLSize; + } + } + + return (nuint)(op - ostart); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_decompressSequences_body( + ZSTD_DCtx_s* dctx, + void* dst, + nuint maxDstSize, + void* seqStart, + nuint seqSize, + int nbSeq, + ZSTD_longOffset_e isLongOffset + ) + { + // HACK, force nbSeq to stack (better register usage) + System.Threading.Volatile.Read(ref nbSeq); + byte* ip = (byte*)seqStart; + byte* iend = ip + seqSize; + byte* ostart = (byte*)dst; + byte* oend = + dctx->litBufferLocation == ZSTD_litLocation_e.ZSTD_not_in_dst + ? ZSTD_maybeNullPtrAdd(ostart, (nint)maxDstSize) + : dctx->litBuffer; + byte* op = ostart; + byte* litPtr = dctx->litPtr; + byte* litEnd = litPtr + dctx->litSize; + byte* prefixStart = (byte*)dctx->prefixStart; + byte* vBase = (byte*)dctx->virtualStart; + byte* dictEnd = (byte*)dctx->dictEnd; + if (nbSeq != 0) + { + seqState_t seqState; + System.Runtime.CompilerServices.Unsafe.SkipInit(out seqState); + dctx->fseEntropy = 1; + { + uint i; + for (i = 0; i < 3; i++) + System.Runtime.CompilerServices.Unsafe.Add(ref seqState.prevOffset.e0, (int)i) = + dctx->entropy.rep[i]; + } + + if (ERR_isError(BIT_initDStream(ref seqState.DStream, ip, (nuint)(iend - ip)))) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + ZSTD_initFseState(ref seqState.stateLL, ref seqState.DStream, dctx->LLTptr); + ZSTD_initFseState(ref seqState.stateOffb, ref seqState.DStream, dctx->OFTptr); + ZSTD_initFseState(ref seqState.stateML, ref seqState.DStream, dctx->MLTptr); + assert(dst != null); + nuint seqState_DStream_bitContainer = seqState.DStream.bitContainer; + uint seqState_DStream_bitsConsumed = seqState.DStream.bitsConsumed; + sbyte* seqState_DStream_ptr = seqState.DStream.ptr; + sbyte* seqState_DStream_start = seqState.DStream.start; + sbyte* seqState_DStream_limitPtr = seqState.DStream.limitPtr; + for (; nbSeq != 0; nbSeq--) + { + nuint sequence_litLength; + nuint sequence_matchLength; + nuint sequence_offset; + ZSTD_seqSymbol* llDInfo = seqState.stateLL.table + seqState.stateLL.state; + ZSTD_seqSymbol* mlDInfo = seqState.stateML.table + seqState.stateML.state; + ZSTD_seqSymbol* ofDInfo = seqState.stateOffb.table + seqState.stateOffb.state; + sequence_matchLength = mlDInfo->baseValue; + sequence_litLength = llDInfo->baseValue; + { + uint ofBase = ofDInfo->baseValue; + byte llBits = llDInfo->nbAdditionalBits; + byte mlBits = mlDInfo->nbAdditionalBits; + byte ofBits = ofDInfo->nbAdditionalBits; + byte totalBits = (byte)(llBits + mlBits + ofBits); + ushort llNext = llDInfo->nextState; + ushort mlNext = mlDInfo->nextState; + ushort ofNext = ofDInfo->nextState; + uint llnbBits = llDInfo->nbBits; + uint mlnbBits = mlDInfo->nbBits; + uint ofnbBits = ofDInfo->nbBits; + assert(llBits <= 16); + assert(mlBits <= 16); + assert(ofBits <= 31); + { + nuint offset; + if (ofBits > 1) + { + if (MEM_32bits && isLongOffset != default && ofBits >= 25) + { + /* Always read extra bits, this keeps the logic simple, + * avoids branches, and avoids accidentally reading 0 bits. + */ + const uint extraBits = 30 - 25; + offset = + ofBase + + ( + BIT_readBitsFast( + seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + ofBits - extraBits + ) << (int)extraBits + ); + BIT_reloadDStream( + ref seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + ref seqState_DStream_ptr, + seqState_DStream_start, + seqState_DStream_limitPtr + ); + offset += BIT_readBitsFast( + seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + extraBits + ); + } + else + { + offset = + ofBase + + BIT_readBitsFast( + seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + ofBits + ); + if (MEM_32bits) + BIT_reloadDStream( + ref seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + ref seqState_DStream_ptr, + seqState_DStream_start, + seqState_DStream_limitPtr + ); + } + + seqState.prevOffset.e2 = seqState.prevOffset.e1; + seqState.prevOffset.e1 = seqState.prevOffset.e0; + seqState.prevOffset.e0 = offset; + } + else + { + uint ll0 = llDInfo->baseValue == 0 ? 1U : 0U; + if (ofBits == 0) + { + offset = System.Runtime.CompilerServices.Unsafe.Add( + ref seqState.prevOffset.e0, + (int)ll0 + ); + seqState.prevOffset.e1 = System.Runtime.CompilerServices.Unsafe.Add( + ref seqState.prevOffset.e0, + ll0 == 0 ? 1 : 0 + ); + seqState.prevOffset.e0 = offset; + } + else + { + offset = + ofBase + + ll0 + + BIT_readBitsFast( + seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + 1 + ); + { + nuint temp = + offset == 3 + ? seqState.prevOffset.e0 - 1 + : System.Runtime.CompilerServices.Unsafe.Add( + ref seqState.prevOffset.e0, + (int)offset + ); + temp -= temp == 0 ? 1U : 0U; + if (offset != 1) + seqState.prevOffset.e2 = seqState.prevOffset.e1; + seqState.prevOffset.e1 = seqState.prevOffset.e0; + seqState.prevOffset.e0 = offset = temp; + } + } + } + + sequence_offset = offset; + } + + if (mlBits > 0) + sequence_matchLength += BIT_readBitsFast( + seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + mlBits + ); + if (MEM_32bits && mlBits + llBits >= 25 - (30 - 25)) + BIT_reloadDStream( + ref seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + ref seqState_DStream_ptr, + seqState_DStream_start, + seqState_DStream_limitPtr + ); + if (MEM_64bits && totalBits >= 57 - (9 + 9 + 8)) + BIT_reloadDStream( + ref seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + ref seqState_DStream_ptr, + seqState_DStream_start, + seqState_DStream_limitPtr + ); + if (llBits > 0) + sequence_litLength += BIT_readBitsFast( + seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + llBits + ); + if (MEM_32bits) + BIT_reloadDStream( + ref seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + ref seqState_DStream_ptr, + seqState_DStream_start, + seqState_DStream_limitPtr + ); + if ((nbSeq == 1 ? 1 : 0) == 0) + { + ZSTD_updateFseStateWithDInfo( + ref seqState.stateLL, + seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + llNext, + llnbBits + ); + ZSTD_updateFseStateWithDInfo( + ref seqState.stateML, + seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + mlNext, + mlnbBits + ); + if (MEM_32bits) + BIT_reloadDStream( + ref seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + ref seqState_DStream_ptr, + seqState_DStream_start, + seqState_DStream_limitPtr + ); + ZSTD_updateFseStateWithDInfo( + ref seqState.stateOffb, + seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + ofNext, + ofnbBits + ); + BIT_reloadDStream( + ref seqState_DStream_bitContainer, + ref seqState_DStream_bitsConsumed, + ref seqState_DStream_ptr, + seqState_DStream_start, + seqState_DStream_limitPtr + ); + } + } + + nuint oneSeqSize; + { + byte* oLitEnd = op + sequence_litLength; + oneSeqSize = sequence_litLength + sequence_matchLength; + /* risk : address space overflow (32-bits) */ + byte* oMatchEnd = op + oneSeqSize; + /* risk : address space underflow on oend=NULL */ + byte* oend_w = oend - 32; + byte* iLitEnd = litPtr + sequence_litLength; + byte* match = oLitEnd - sequence_offset; + assert(op != null); + assert(oend_w < oend); + if ( + iLitEnd > litEnd + || oMatchEnd > oend_w + || MEM_32bits && (nuint)(oend - op) < oneSeqSize + 32 + ) + { + oneSeqSize = ZSTD_execSequenceEnd( + op, + oend, + new seq_t + { + litLength = sequence_litLength, + matchLength = sequence_matchLength, + offset = sequence_offset, + }, + &litPtr, + litEnd, + prefixStart, + vBase, + dictEnd + ); + goto returnOneSeqSize; + } + + assert(op <= oLitEnd); + assert(oLitEnd < oMatchEnd); + assert(oMatchEnd <= oend); + assert(iLitEnd <= litEnd); + assert(oLitEnd <= oend_w); + assert(oMatchEnd <= oend_w); + assert(32 >= 16); + ZSTD_copy16(op, litPtr); + if (sequence_litLength > 16) + { + ZSTD_wildcopy( + op + 16, + litPtr + 16, + (nint)(sequence_litLength - 16), + ZSTD_overlap_e.ZSTD_no_overlap + ); + } + + byte* opInner = oLitEnd; + litPtr = iLitEnd; + if (sequence_offset > (nuint)(oLitEnd - prefixStart)) + { + if (sequence_offset > (nuint)(oLitEnd - vBase)) + { + oneSeqSize = unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected) + ); + goto returnOneSeqSize; + } + + match = dictEnd + (match - prefixStart); + if (match + sequence_matchLength <= dictEnd) + { + memmove(oLitEnd, match, sequence_matchLength); + goto returnOneSeqSize; + } + + { + nuint length1 = (nuint)(dictEnd - match); + memmove(oLitEnd, match, length1); + opInner = oLitEnd + length1; + sequence_matchLength -= length1; + match = prefixStart; + } + } + + assert(opInner <= oMatchEnd); + assert(oMatchEnd <= oend_w); + assert(match >= prefixStart); + assert(sequence_matchLength >= 1); + if (sequence_offset >= 16) + { + ZSTD_wildcopy( + opInner, + match, + (nint)sequence_matchLength, + ZSTD_overlap_e.ZSTD_no_overlap + ); + goto returnOneSeqSize; + } + + assert(sequence_offset < 16); + ZSTD_overlapCopy8(ref opInner, ref match, sequence_offset); + if (sequence_matchLength > 8) + { + assert(opInner < oMatchEnd); + ZSTD_wildcopy( + opInner, + match, + (nint)sequence_matchLength - 8, + ZSTD_overlap_e.ZSTD_overlap_src_before_dst + ); + } + + returnOneSeqSize: + ; + } + + if (ERR_isError(oneSeqSize)) + return oneSeqSize; + op += oneSeqSize; + } + + assert(nbSeq == 0); + if ( + BIT_endOfDStream( + seqState_DStream_bitsConsumed, + seqState_DStream_ptr, + seqState_DStream_start + ) == 0 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + { + uint i; + for (i = 0; i < 3; i++) + dctx->entropy.rep[i] = (uint) + System.Runtime.CompilerServices.Unsafe.Add( + ref seqState.prevOffset.e0, + (int)i + ); + } + } + + { + nuint lastLLSize = (nuint)(litEnd - litPtr); + if (lastLLSize > (nuint)(oend - op)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (op != null) + { + memcpy(op, litPtr, (uint)lastLLSize); + op += lastLLSize; + } + } + + return (nuint)(op - ostart); + } + + private static nuint ZSTD_decompressSequences_default( + ZSTD_DCtx_s* dctx, + void* dst, + nuint maxDstSize, + void* seqStart, + nuint seqSize, + int nbSeq, + ZSTD_longOffset_e isLongOffset + ) + { + return ZSTD_decompressSequences_body( + dctx, + dst, + maxDstSize, + seqStart, + seqSize, + nbSeq, + isLongOffset + ); + } + + private static nuint ZSTD_decompressSequencesSplitLitBuffer_default( + ZSTD_DCtx_s* dctx, + void* dst, + nuint maxDstSize, + void* seqStart, + nuint seqSize, + int nbSeq, + ZSTD_longOffset_e isLongOffset + ) + { + return ZSTD_decompressSequences_bodySplitLitBuffer( + dctx, + dst, + maxDstSize, + seqStart, + seqSize, + nbSeq, + isLongOffset + ); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_prefetchMatch( + nuint prefetchPos, + seq_t sequence, + byte* prefixStart, + byte* dictEnd + ) + { + prefetchPos += sequence.litLength; + { + byte* matchBase = sequence.offset > prefetchPos ? dictEnd : prefixStart; + /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. + * No consequence though : memory address is only used for prefetching, not for dereferencing */ + byte* match = ZSTD_wrappedPtrSub( + ZSTD_wrappedPtrAdd(matchBase, (nint)prefetchPos), + (nint)sequence.offset + ); +#if NETCOREAPP3_0_OR_GREATER + if (System.Runtime.Intrinsics.X86.Sse.IsSupported) + { + System.Runtime.Intrinsics.X86.Sse.Prefetch0(match); + System.Runtime.Intrinsics.X86.Sse.Prefetch0(match + 64); + } +#endif + } + + return prefetchPos + sequence.matchLength; + } + + /* This decoding function employs prefetching + * to reduce latency impact of cache misses. + * It's generally employed when block contains a significant portion of long-distance matches + * or when coupled with a "cold" dictionary */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_decompressSequencesLong_body( + ZSTD_DCtx_s* dctx, + void* dst, + nuint maxDstSize, + void* seqStart, + nuint seqSize, + int nbSeq, + ZSTD_longOffset_e isLongOffset + ) + { + byte* ip = (byte*)seqStart; + byte* iend = ip + seqSize; + byte* ostart = (byte*)dst; + byte* oend = + dctx->litBufferLocation == ZSTD_litLocation_e.ZSTD_in_dst + ? dctx->litBuffer + : ZSTD_maybeNullPtrAdd(ostart, (nint)maxDstSize); + byte* op = ostart; + byte* litPtr = dctx->litPtr; + byte* litBufferEnd = dctx->litBufferEnd; + byte* prefixStart = (byte*)dctx->prefixStart; + byte* dictStart = (byte*)dctx->virtualStart; + byte* dictEnd = (byte*)dctx->dictEnd; + if (nbSeq != 0) + { + seq_t* sequences = stackalloc seq_t[8]; + int seqAdvance = nbSeq < 8 ? nbSeq : 8; + seqState_t seqState; + int seqNb; + /* track position relative to prefixStart */ + nuint prefetchPos = (nuint)(op - prefixStart); + dctx->fseEntropy = 1; + { + int i; + for (i = 0; i < 3; i++) + (&seqState.prevOffset.e0)[i] = dctx->entropy.rep[i]; + } + + assert(dst != null); + assert(iend >= ip); + if (ERR_isError(BIT_initDStream(&seqState.DStream, ip, (nuint)(iend - ip)))) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); + ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr); + ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr); + for (seqNb = 0; seqNb < seqAdvance; seqNb++) + { + seq_t sequence = ZSTD_decodeSequence( + &seqState, + isLongOffset, + seqNb == nbSeq - 1 ? 1 : 0 + ); + prefetchPos = ZSTD_prefetchMatch(prefetchPos, sequence, prefixStart, dictEnd); + sequences[seqNb] = sequence; + } + + for (; seqNb < nbSeq; seqNb++) + { + seq_t sequence = ZSTD_decodeSequence( + &seqState, + isLongOffset, + seqNb == nbSeq - 1 ? 1 : 0 + ); + if ( + dctx->litBufferLocation == ZSTD_litLocation_e.ZSTD_split + && litPtr + sequences[seqNb - 8 & 8 - 1].litLength > dctx->litBufferEnd + ) + { + /* lit buffer is reaching split point, empty out the first buffer and transition to litExtraBuffer */ + nuint leftoverLit = (nuint)(dctx->litBufferEnd - litPtr); + if (leftoverLit != 0) + { + if (leftoverLit > (nuint)(oend - op)) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall) + ); + } + + ZSTD_safecopyDstBeforeSrc(op, litPtr, (nint)leftoverLit); + sequences[seqNb - 8 & 8 - 1].litLength -= leftoverLit; + op += leftoverLit; + } + + litPtr = dctx->litExtraBuffer; + litBufferEnd = dctx->litExtraBuffer + (1 << 16); + dctx->litBufferLocation = ZSTD_litLocation_e.ZSTD_not_in_dst; + { + nuint oneSeqSize = ZSTD_execSequence( + op, + oend, + sequences[seqNb - 8 & 8 - 1], + &litPtr, + litBufferEnd, + prefixStart, + dictStart, + dictEnd + ); + if (ERR_isError(oneSeqSize)) + return oneSeqSize; + prefetchPos = ZSTD_prefetchMatch( + prefetchPos, + sequence, + prefixStart, + dictEnd + ); + sequences[seqNb & 8 - 1] = sequence; + op += oneSeqSize; + } + } + else + { + /* lit buffer is either wholly contained in first or second split, or not split at all*/ + nuint oneSeqSize = + dctx->litBufferLocation == ZSTD_litLocation_e.ZSTD_split + ? ZSTD_execSequenceSplitLitBuffer( + op, + oend, + litPtr + sequences[seqNb - 8 & 8 - 1].litLength - 32, + sequences[seqNb - 8 & 8 - 1], + &litPtr, + litBufferEnd, + prefixStart, + dictStart, + dictEnd + ) + : ZSTD_execSequence( + op, + oend, + sequences[seqNb - 8 & 8 - 1], + &litPtr, + litBufferEnd, + prefixStart, + dictStart, + dictEnd + ); + if (ERR_isError(oneSeqSize)) + return oneSeqSize; + prefetchPos = ZSTD_prefetchMatch(prefetchPos, sequence, prefixStart, dictEnd); + sequences[seqNb & 8 - 1] = sequence; + op += oneSeqSize; + } + } + + if (BIT_endOfDStream(&seqState.DStream) == 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)); + } + + seqNb -= seqAdvance; + for (; seqNb < nbSeq; seqNb++) + { + seq_t* sequence = &sequences[seqNb & 8 - 1]; + if ( + dctx->litBufferLocation == ZSTD_litLocation_e.ZSTD_split + && litPtr + sequence->litLength > dctx->litBufferEnd + ) + { + nuint leftoverLit = (nuint)(dctx->litBufferEnd - litPtr); + if (leftoverLit != 0) + { + if (leftoverLit > (nuint)(oend - op)) + { + return unchecked( + (nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall) + ); + } + + ZSTD_safecopyDstBeforeSrc(op, litPtr, (nint)leftoverLit); + sequence->litLength -= leftoverLit; + op += leftoverLit; + } + + litPtr = dctx->litExtraBuffer; + litBufferEnd = dctx->litExtraBuffer + (1 << 16); + dctx->litBufferLocation = ZSTD_litLocation_e.ZSTD_not_in_dst; + { + nuint oneSeqSize = ZSTD_execSequence( + op, + oend, + *sequence, + &litPtr, + litBufferEnd, + prefixStart, + dictStart, + dictEnd + ); + if (ERR_isError(oneSeqSize)) + return oneSeqSize; + op += oneSeqSize; + } + } + else + { + nuint oneSeqSize = + dctx->litBufferLocation == ZSTD_litLocation_e.ZSTD_split + ? ZSTD_execSequenceSplitLitBuffer( + op, + oend, + litPtr + sequence->litLength - 32, + *sequence, + &litPtr, + litBufferEnd, + prefixStart, + dictStart, + dictEnd + ) + : ZSTD_execSequence( + op, + oend, + *sequence, + &litPtr, + litBufferEnd, + prefixStart, + dictStart, + dictEnd + ); + if (ERR_isError(oneSeqSize)) + return oneSeqSize; + op += oneSeqSize; + } + } + + { + uint i; + for (i = 0; i < 3; i++) + dctx->entropy.rep[i] = (uint)(&seqState.prevOffset.e0)[i]; + } + } + + if (dctx->litBufferLocation == ZSTD_litLocation_e.ZSTD_split) + { + nuint lastLLSize = (nuint)(litBufferEnd - litPtr); + if (lastLLSize > (nuint)(oend - op)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (op != null) + { + memmove(op, litPtr, lastLLSize); + op += lastLLSize; + } + + litPtr = dctx->litExtraBuffer; + litBufferEnd = dctx->litExtraBuffer + (1 << 16); + } + + { + nuint lastLLSize = (nuint)(litBufferEnd - litPtr); + if (lastLLSize > (nuint)(oend - op)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if (op != null) + { + memmove(op, litPtr, lastLLSize); + op += lastLLSize; + } + } + + return (nuint)(op - ostart); + } + + private static nuint ZSTD_decompressSequencesLong_default( + ZSTD_DCtx_s* dctx, + void* dst, + nuint maxDstSize, + void* seqStart, + nuint seqSize, + int nbSeq, + ZSTD_longOffset_e isLongOffset + ) + { + return ZSTD_decompressSequencesLong_body( + dctx, + dst, + maxDstSize, + seqStart, + seqSize, + nbSeq, + isLongOffset + ); + } + + private static nuint ZSTD_decompressSequences( + ZSTD_DCtx_s* dctx, + void* dst, + nuint maxDstSize, + void* seqStart, + nuint seqSize, + int nbSeq, + ZSTD_longOffset_e isLongOffset + ) + { + return ZSTD_decompressSequences_default( + dctx, + dst, + maxDstSize, + seqStart, + seqSize, + nbSeq, + isLongOffset + ); + } + + private static nuint ZSTD_decompressSequencesSplitLitBuffer( + ZSTD_DCtx_s* dctx, + void* dst, + nuint maxDstSize, + void* seqStart, + nuint seqSize, + int nbSeq, + ZSTD_longOffset_e isLongOffset + ) + { + return ZSTD_decompressSequencesSplitLitBuffer_default( + dctx, + dst, + maxDstSize, + seqStart, + seqSize, + nbSeq, + isLongOffset + ); + } + + /* ZSTD_decompressSequencesLong() : + * decompression function triggered when a minimum share of offsets is considered "long", + * aka out of cache. + * note : "long" definition seems overloaded here, sometimes meaning "wider than bitstream register", and sometimes meaning "farther than memory cache distance". + * This function will try to mitigate main memory latency through the use of prefetching */ + private static nuint ZSTD_decompressSequencesLong( + ZSTD_DCtx_s* dctx, + void* dst, + nuint maxDstSize, + void* seqStart, + nuint seqSize, + int nbSeq, + ZSTD_longOffset_e isLongOffset + ) + { + return ZSTD_decompressSequencesLong_default( + dctx, + dst, + maxDstSize, + seqStart, + seqSize, + nbSeq, + isLongOffset + ); + } + + /** + * @returns The total size of the history referenceable by zstd, including + * both the prefix and the extDict. At @p op any offset larger than this + * is invalid. + */ + private static nuint ZSTD_totalHistorySize(byte* op, byte* virtualStart) + { + return (nuint)(op - virtualStart); + } + + /* ZSTD_getOffsetInfo() : + * condition : offTable must be valid + * @return : "share" of long offsets (arbitrarily defined as > (1<<23)) + * compared to maximum possible of (1< table[u].nbAdditionalBits + ? info.maxNbAdditionalBits + : table[u].nbAdditionalBits; + if (table[u].nbAdditionalBits > 22) + info.longOffsetShare += 1; + } + + assert(tableLog <= 8); + info.longOffsetShare <<= (int)(8 - tableLog); + } + + return info; + } + + /** + * @returns The maximum offset we can decode in one read of our bitstream, without + * reloading more bits in the middle of the offset bits read. Any offsets larger + * than this must use the long offset decoder. + */ + private static nuint ZSTD_maxShortOffset() + { + if (MEM_64bits) + { + return unchecked((nuint)(-1)); + } + else + { + /* The maximum offBase is (1 << (STREAM_ACCUMULATOR_MIN + 1)) - 1. + * This offBase would require STREAM_ACCUMULATOR_MIN extra bits. + * Then we have to subtract ZSTD_REP_NUM to get the maximum possible offset. + */ + nuint maxOffbase = ((nuint)1 << (int)((uint)(MEM_32bits ? 25 : 57) + 1)) - 1; + nuint maxOffset = maxOffbase - 3; + assert(ZSTD_highbit32((uint)maxOffbase) == (uint)(MEM_32bits ? 25 : 57)); + return maxOffset; + } + } + + /* ZSTD_decompressBlock_internal() : + * decompress block, starting at `src`, + * into destination buffer `dst`. + * @return : decompressed block size, + * or an error code (which can be tested using ZSTD_isError()) + */ + private static nuint ZSTD_decompressBlock_internal( + ZSTD_DCtx_s* dctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize, + streaming_operation streaming + ) + { + byte* ip = (byte*)src; + if (srcSize > ZSTD_blockSizeMax(dctx)) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)); + } + + { + nuint litCSize = ZSTD_decodeLiteralsBlock( + dctx, + src, + srcSize, + dst, + dstCapacity, + streaming + ); + if (ERR_isError(litCSize)) + return litCSize; + ip += litCSize; + srcSize -= litCSize; + } + + { + /* Compute the maximum block size, which must also work when !frame and fParams are unset. + * Additionally, take the min with dstCapacity to ensure that the totalHistorySize fits in a size_t. + */ + nuint blockSizeMax = + dstCapacity < ZSTD_blockSizeMax(dctx) ? dstCapacity : ZSTD_blockSizeMax(dctx); + nuint totalHistorySize = ZSTD_totalHistorySize( + ZSTD_maybeNullPtrAdd((byte*)dst, (nint)blockSizeMax), + (byte*)dctx->virtualStart + ); + /* isLongOffset must be true if there are long offsets. + * Offsets are long if they are larger than ZSTD_maxShortOffset(). + * We don't expect that to be the case in 64-bit mode. + * + * We check here to see if our history is large enough to allow long offsets. + * If it isn't, then we can't possible have (valid) long offsets. If the offset + * is invalid, then it is okay to read it incorrectly. + * + * If isLongOffsets is true, then we will later check our decoding table to see + * if it is even possible to generate long offsets. + */ + ZSTD_longOffset_e isLongOffset = (ZSTD_longOffset_e)( + MEM_32bits && totalHistorySize > ZSTD_maxShortOffset() ? 1 : 0 + ); + int usePrefetchDecoder = dctx->ddictIsCold; + int nbSeq; + nuint seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, srcSize); + if (ERR_isError(seqHSize)) + return seqHSize; + ip += seqHSize; + srcSize -= seqHSize; + if ((dst == null || dstCapacity == 0) && nbSeq > 0) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if ( + MEM_64bits + && sizeof(nuint) == sizeof(void*) + && unchecked((nuint)(-1)) - (nuint)dst < 1 << 20 + ) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + } + + if ( + isLongOffset != default + || usePrefetchDecoder == 0 && totalHistorySize > 1U << 24 && nbSeq > 8 + ) + { + ZSTD_OffsetInfo info = ZSTD_getOffsetInfo(dctx->OFTptr, nbSeq); + if ( + isLongOffset != default + && info.maxNbAdditionalBits <= (uint)(MEM_32bits ? 25 : 57) + ) + { + isLongOffset = ZSTD_longOffset_e.ZSTD_lo_isRegularOffset; + } + + if (usePrefetchDecoder == 0) + { + /* heuristic values, correspond to 2.73% and 7.81% */ + uint minShare = (uint)(MEM_64bits ? 7 : 20); + usePrefetchDecoder = info.longOffsetShare >= minShare ? 1 : 0; + } + } + + dctx->ddictIsCold = 0; + if (usePrefetchDecoder != 0) + { + return ZSTD_decompressSequencesLong( + dctx, + dst, + dstCapacity, + ip, + srcSize, + nbSeq, + isLongOffset + ); + } + + if (dctx->litBufferLocation == ZSTD_litLocation_e.ZSTD_split) + return ZSTD_decompressSequencesSplitLitBuffer( + dctx, + dst, + dstCapacity, + ip, + srcSize, + nbSeq, + isLongOffset + ); + else + return ZSTD_decompressSequences( + dctx, + dst, + dstCapacity, + ip, + srcSize, + nbSeq, + isLongOffset + ); + } + } + + /*! ZSTD_checkContinuity() : + * check if next `dst` follows previous position, where decompression ended. + * If yes, do nothing (continue on current segment). + * If not, classify previous segment as "external dictionary", and start a new segment. + * This function cannot fail. */ + private static void ZSTD_checkContinuity(ZSTD_DCtx_s* dctx, void* dst, nuint dstSize) + { + if (dst != dctx->previousDstEnd && dstSize > 0) + { + dctx->dictEnd = dctx->previousDstEnd; + dctx->virtualStart = + (sbyte*)dst - ((sbyte*)dctx->previousDstEnd - (sbyte*)dctx->prefixStart); + dctx->prefixStart = dst; + dctx->previousDstEnd = dst; + } + } + + /* Internal definition of ZSTD_decompressBlock() to avoid deprecation warnings. */ + private static nuint ZSTD_decompressBlock_deprecated( + ZSTD_DCtx_s* dctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize + ) + { + nuint dSize; + dctx->isFrameDecompression = 0; + ZSTD_checkContinuity(dctx, dst, dstCapacity); + dSize = ZSTD_decompressBlock_internal( + dctx, + dst, + dstCapacity, + src, + srcSize, + streaming_operation.not_streaming + ); + { + nuint err_code = dSize; + if (ERR_isError(err_code)) + { + return err_code; + } + } + + dctx->previousDstEnd = (sbyte*)dst + dSize; + return dSize; + } + + /* NOTE: Must just wrap ZSTD_decompressBlock_deprecated() */ + public static nuint ZSTD_decompressBlock( + ZSTD_DCtx_s* dctx, + void* dst, + nuint dstCapacity, + void* src, + nuint srcSize + ) + { + return ZSTD_decompressBlock_deprecated(dctx, dst, dstCapacity, src, srcSize); + } + + private static void ZSTD_initFseState( + ref ZSTD_fseState DStatePtr, + ref BIT_DStream_t bitD, + ZSTD_seqSymbol* dt + ) + { + void* ptr = dt; + ZSTD_seqSymbol_header* DTableH = (ZSTD_seqSymbol_header*)ptr; + DStatePtr.state = BIT_readBits(bitD.bitContainer, ref bitD.bitsConsumed, DTableH->tableLog); + BIT_reloadDStream( + ref bitD.bitContainer, + ref bitD.bitsConsumed, + ref bitD.ptr, + bitD.start, + bitD.limitPtr + ); + DStatePtr.table = dt + 1; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_updateFseStateWithDInfo( + ref ZSTD_fseState DStatePtr, + nuint bitD_bitContainer, + ref uint bitD_bitsConsumed, + ushort nextState, + uint nbBits + ) + { + nuint lowBits = BIT_readBits(bitD_bitContainer, ref bitD_bitsConsumed, nbBits); + DStatePtr.state = nextState + lowBits; + } + + /*! ZSTD_overlapCopy8() : + * Copies 8 bytes from ip to op and updates op and ip where ip <= op. + * If the offset is < 8 then the offset is spread to at least 8 bytes. + * + * Precondition: *ip <= *op + * Postcondition: *op - *op >= 8 + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_overlapCopy8(ref byte* op, ref byte* ip, nuint offset) + { + assert(ip <= op); + if (offset < 8) + { + int sub2 = dec64table[offset]; + op[0] = ip[0]; + op[1] = ip[1]; + op[2] = ip[2]; + op[3] = ip[3]; + ip += dec32table[offset]; + ZSTD_copy4(op + 4, ip); + ip -= sub2; + } + else + { + ZSTD_copy8(op, ip); + } + + ip += 8; + op += 8; + assert(op - ip >= 8); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDecompressInternal.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDecompressInternal.cs new file mode 100644 index 000000000..670f58465 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDecompressInternal.cs @@ -0,0 +1,394 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_LL_base => + new uint[36] + { + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 18, + 20, + 22, + 24, + 28, + 32, + 40, + 48, + 64, + 0x80, + 0x100, + 0x200, + 0x400, + 0x800, + 0x1000, + 0x2000, + 0x4000, + 0x8000, + 0x10000, + }; + private static uint* LL_base => + (uint*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_LL_base) + ); +#else + + private static readonly uint* LL_base = GetArrayPointer( + new uint[36] + { + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 18, + 20, + 22, + 24, + 28, + 32, + 40, + 48, + 64, + 0x80, + 0x100, + 0x200, + 0x400, + 0x800, + 0x1000, + 0x2000, + 0x4000, + 0x8000, + 0x10000, + } + ); +#endif +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_OF_base => + new uint[32] + { + 0, + 1, + 1, + 5, + 0xD, + 0x1D, + 0x3D, + 0x7D, + 0xFD, + 0x1FD, + 0x3FD, + 0x7FD, + 0xFFD, + 0x1FFD, + 0x3FFD, + 0x7FFD, + 0xFFFD, + 0x1FFFD, + 0x3FFFD, + 0x7FFFD, + 0xFFFFD, + 0x1FFFFD, + 0x3FFFFD, + 0x7FFFFD, + 0xFFFFFD, + 0x1FFFFFD, + 0x3FFFFFD, + 0x7FFFFFD, + 0xFFFFFFD, + 0x1FFFFFFD, + 0x3FFFFFFD, + 0x7FFFFFFD, + }; + private static uint* OF_base => + (uint*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_OF_base) + ); +#else + + private static readonly uint* OF_base = GetArrayPointer( + new uint[32] + { + 0, + 1, + 1, + 5, + 0xD, + 0x1D, + 0x3D, + 0x7D, + 0xFD, + 0x1FD, + 0x3FD, + 0x7FD, + 0xFFD, + 0x1FFD, + 0x3FFD, + 0x7FFD, + 0xFFFD, + 0x1FFFD, + 0x3FFFD, + 0x7FFFD, + 0xFFFFD, + 0x1FFFFD, + 0x3FFFFD, + 0x7FFFFD, + 0xFFFFFD, + 0x1FFFFFD, + 0x3FFFFFD, + 0x7FFFFFD, + 0xFFFFFFD, + 0x1FFFFFFD, + 0x3FFFFFFD, + 0x7FFFFFFD, + } + ); +#endif +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_OF_bits => + new byte[32] + { + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + }; + private static byte* OF_bits => + (byte*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_OF_bits) + ); +#else + + private static readonly byte* OF_bits = GetArrayPointer( + new byte[32] + { + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + } + ); +#endif +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_ML_base => + new uint[53] + { + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 37, + 39, + 41, + 43, + 47, + 51, + 59, + 67, + 83, + 99, + 0x83, + 0x103, + 0x203, + 0x403, + 0x803, + 0x1003, + 0x2003, + 0x4003, + 0x8003, + 0x10003, + }; + private static uint* ML_base => + (uint*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_ML_base) + ); +#else + + private static readonly uint* ML_base = GetArrayPointer( + new uint[53] + { + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 37, + 39, + 41, + 43, + 47, + 51, + 59, + 67, + 83, + 99, + 0x83, + 0x103, + 0x203, + 0x403, + 0x803, + 0x1003, + 0x2003, + 0x4003, + 0x8003, + 0x10003, + } + ); +#endif + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_DCtx_get_bmi2(ZSTD_DCtx_s* dctx) + { + return 0; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDoubleFast.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDoubleFast.cs new file mode 100644 index 000000000..55d383ecb --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdDoubleFast.cs @@ -0,0 +1,1118 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + private static void ZSTD_fillDoubleHashTableForCDict( + ZSTD_MatchState_t* ms, + void* end, + ZSTD_dictTableLoadMethod_e dtlm + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* hashLarge = ms->hashTable; + uint hBitsL = cParams->hashLog + 8; + uint mls = cParams->minMatch; + uint* hashSmall = ms->chainTable; + uint hBitsS = cParams->chainLog + 8; + byte* @base = ms->window.@base; + byte* ip = @base + ms->nextToUpdate; + byte* iend = (byte*)end - 8; + const uint fastHashFillStep = 3; + for (; ip + fastHashFillStep - 1 <= iend; ip += fastHashFillStep) + { + uint curr = (uint)(ip - @base); + uint i; + for (i = 0; i < fastHashFillStep; ++i) + { + nuint smHashAndTag = ZSTD_hashPtr(ip + i, hBitsS, mls); + nuint lgHashAndTag = ZSTD_hashPtr(ip + i, hBitsL, 8); + if (i == 0) + { + ZSTD_writeTaggedIndex(hashSmall, smHashAndTag, curr + i); + } + + if (i == 0 || hashLarge[lgHashAndTag >> 8] == 0) + { + ZSTD_writeTaggedIndex(hashLarge, lgHashAndTag, curr + i); + } + + if (dtlm == ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast) + break; + } + } + } + + private static void ZSTD_fillDoubleHashTableForCCtx( + ZSTD_MatchState_t* ms, + void* end, + ZSTD_dictTableLoadMethod_e dtlm + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* hashLarge = ms->hashTable; + uint hBitsL = cParams->hashLog; + uint mls = cParams->minMatch; + uint* hashSmall = ms->chainTable; + uint hBitsS = cParams->chainLog; + byte* @base = ms->window.@base; + byte* ip = @base + ms->nextToUpdate; + byte* iend = (byte*)end - 8; + const uint fastHashFillStep = 3; + for (; ip + fastHashFillStep - 1 <= iend; ip += fastHashFillStep) + { + uint curr = (uint)(ip - @base); + uint i; + for (i = 0; i < fastHashFillStep; ++i) + { + nuint smHash = ZSTD_hashPtr(ip + i, hBitsS, mls); + nuint lgHash = ZSTD_hashPtr(ip + i, hBitsL, 8); + if (i == 0) + hashSmall[smHash] = curr + i; + if (i == 0 || hashLarge[lgHash] == 0) + hashLarge[lgHash] = curr + i; + if (dtlm == ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast) + break; + } + } + } + + private static void ZSTD_fillDoubleHashTable( + ZSTD_MatchState_t* ms, + void* end, + ZSTD_dictTableLoadMethod_e dtlm, + ZSTD_tableFillPurpose_e tfp + ) + { + if (tfp == ZSTD_tableFillPurpose_e.ZSTD_tfp_forCDict) + { + ZSTD_fillDoubleHashTableForCDict(ms, end, dtlm); + } + else + { + ZSTD_fillDoubleHashTableForCCtx(ms, end, dtlm); + } + } + +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_dummy => + new byte[10] { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0xe2, 0xb4 }; + private static byte* dummy => + (byte*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_dummy) + ); +#else + + private static readonly byte* dummy = GetArrayPointer( + new byte[10] { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0xe2, 0xb4 } + ); +#endif + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_compressBlock_doubleFast_noDict_generic( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize, + uint mls + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* hashLong = ms->hashTable; + uint hBitsL = cParams->hashLog; + uint* hashSmall = ms->chainTable; + uint hBitsS = cParams->chainLog; + byte* @base = ms->window.@base; + byte* istart = (byte*)src; + byte* anchor = istart; + uint endIndex = (uint)((nuint)(istart - @base) + srcSize); + /* presumes that, if there is a dictionary, it must be using Attach mode */ + uint prefixLowestIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog); + byte* prefixLowest = @base + prefixLowestIndex; + byte* iend = istart + srcSize; + byte* ilimit = iend - 8; + uint offset_1 = rep[0], + offset_2 = rep[1]; + uint offsetSaved1 = 0, + offsetSaved2 = 0; + nuint mLength; + uint offset; + uint curr; + /* how many positions to search before increasing step size */ + const nuint kStepIncr = 1 << 8; + /* the position at which to increment the step size if no match is found */ + byte* nextStep; + /* the current step size */ + nuint step; + /* the long hash at ip */ + nuint hl0; + /* the long hash at ip1 */ + nuint hl1; + /* the long match index for ip */ + uint idxl0; + /* the long match index for ip1 */ + uint idxl1; + /* the long match for ip */ + byte* matchl0; + /* the short match for ip */ + byte* matchs0; + /* the long match for ip1 */ + byte* matchl1; + /* matchs0 or safe address */ + byte* matchs0_safe; + /* the current position */ + byte* ip = istart; + /* the next position */ + byte* ip1; + ip += ip - prefixLowest == 0 ? 1 : 0; + { + uint current = (uint)(ip - @base); + uint windowLow = ZSTD_getLowestPrefixIndex(ms, current, cParams->windowLog); + uint maxRep = current - windowLow; + if (offset_2 > maxRep) + { + offsetSaved2 = offset_2; + offset_2 = 0; + } + + if (offset_1 > maxRep) + { + offsetSaved1 = offset_1; + offset_1 = 0; + } + } + + while (true) + { + step = 1; + nextStep = ip + kStepIncr; + ip1 = ip + step; + if (ip1 > ilimit) + { + goto _cleanup; + } + + hl0 = ZSTD_hashPtr(ip, hBitsL, 8); + idxl0 = hashLong[hl0]; + matchl0 = @base + idxl0; + do + { + nuint hs0 = ZSTD_hashPtr(ip, hBitsS, mls); + uint idxs0 = hashSmall[hs0]; + curr = (uint)(ip - @base); + matchs0 = @base + idxs0; + hashLong[hl0] = hashSmall[hs0] = curr; + if (offset_1 > 0 && MEM_read32(ip + 1 - offset_1) == MEM_read32(ip + 1)) + { + mLength = ZSTD_count(ip + 1 + 4, ip + 1 + 4 - offset_1, iend) + 4; + ip++; + assert(1 >= 1); + assert(1 <= 3); + ZSTD_storeSeq(seqStore, (nuint)(ip - anchor), anchor, iend, 1, mLength); + goto _match_stored; + } + + hl1 = ZSTD_hashPtr(ip1, hBitsL, 8); + { + byte* matchl0_safe = ZSTD_selectAddr( + idxl0, + prefixLowestIndex, + matchl0, + &dummy[0] + ); + if (MEM_read64(matchl0_safe) == MEM_read64(ip) && matchl0_safe == matchl0) + { + mLength = ZSTD_count(ip + 8, matchl0 + 8, iend) + 8; + offset = (uint)(ip - matchl0); + while (ip > anchor && matchl0 > prefixLowest && ip[-1] == matchl0[-1]) + { + ip--; + matchl0--; + mLength++; + } + + goto _match_found; + } + } + + idxl1 = hashLong[hl1]; + matchl1 = @base + idxl1; + matchs0_safe = ZSTD_selectAddr(idxs0, prefixLowestIndex, matchs0, &dummy[0]); + if (MEM_read32(matchs0_safe) == MEM_read32(ip) && matchs0_safe == matchs0) + { + goto _search_next_long; + } + + if (ip1 >= nextStep) + { +#if NETCOREAPP3_0_OR_GREATER + if (System.Runtime.Intrinsics.X86.Sse.IsSupported) + { + System.Runtime.Intrinsics.X86.Sse.Prefetch0(ip1 + 64); + System.Runtime.Intrinsics.X86.Sse.Prefetch0(ip1 + 128); + } +#endif + + step++; + nextStep += kStepIncr; + } + + ip = ip1; + ip1 += step; + hl0 = hl1; + idxl0 = idxl1; + matchl0 = matchl1; + } while (ip1 <= ilimit); + _cleanup: + offsetSaved2 = offsetSaved1 != 0 && offset_1 != 0 ? offsetSaved1 : offsetSaved2; + rep[0] = offset_1 != 0 ? offset_1 : offsetSaved1; + rep[1] = offset_2 != 0 ? offset_2 : offsetSaved2; + return (nuint)(iend - anchor); + _search_next_long: + mLength = ZSTD_count(ip + 4, matchs0 + 4, iend) + 4; + offset = (uint)(ip - matchs0); + if (idxl1 > prefixLowestIndex && MEM_read64(matchl1) == MEM_read64(ip1)) + { + nuint l1len = ZSTD_count(ip1 + 8, matchl1 + 8, iend) + 8; + if (l1len > mLength) + { + ip = ip1; + mLength = l1len; + offset = (uint)(ip - matchl1); + matchs0 = matchl1; + } + } + + while (ip > anchor && matchs0 > prefixLowest && ip[-1] == matchs0[-1]) + { + ip--; + matchs0--; + mLength++; + } + + _match_found: + offset_2 = offset_1; + offset_1 = offset; + if (step < 4) + { + hashLong[hl1] = (uint)(ip1 - @base); + } + + assert(offset > 0); + ZSTD_storeSeq(seqStore, (nuint)(ip - anchor), anchor, iend, offset + 3, mLength); + _match_stored: + ip += mLength; + anchor = ip; + if (ip <= ilimit) + { + { + uint indexToInsert = curr + 2; + hashLong[ZSTD_hashPtr(@base + indexToInsert, hBitsL, 8)] = indexToInsert; + hashLong[ZSTD_hashPtr(ip - 2, hBitsL, 8)] = (uint)(ip - 2 - @base); + hashSmall[ZSTD_hashPtr(@base + indexToInsert, hBitsS, mls)] = indexToInsert; + hashSmall[ZSTD_hashPtr(ip - 1, hBitsS, mls)] = (uint)(ip - 1 - @base); + } + + while (ip <= ilimit && offset_2 > 0 && MEM_read32(ip) == MEM_read32(ip - offset_2)) + { + /* store sequence */ + nuint rLength = ZSTD_count(ip + 4, ip + 4 - offset_2, iend) + 4; + /* swap offset_2 <=> offset_1 */ + uint tmpOff = offset_2; + offset_2 = offset_1; + offset_1 = tmpOff; + hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = (uint)(ip - @base); + hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = (uint)(ip - @base); + assert(1 >= 1); + assert(1 <= 3); + ZSTD_storeSeq(seqStore, 0, anchor, iend, 1, rLength); + ip += rLength; + anchor = ip; + continue; + } + } + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_compressBlock_doubleFast_dictMatchState_generic( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize, + uint mls + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* hashLong = ms->hashTable; + uint hBitsL = cParams->hashLog; + uint* hashSmall = ms->chainTable; + uint hBitsS = cParams->chainLog; + byte* @base = ms->window.@base; + byte* istart = (byte*)src; + byte* ip = istart; + byte* anchor = istart; + uint endIndex = (uint)((nuint)(istart - @base) + srcSize); + /* presumes that, if there is a dictionary, it must be using Attach mode */ + uint prefixLowestIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog); + byte* prefixLowest = @base + prefixLowestIndex; + byte* iend = istart + srcSize; + byte* ilimit = iend - 8; + uint offset_1 = rep[0], + offset_2 = rep[1]; + ZSTD_MatchState_t* dms = ms->dictMatchState; + ZSTD_compressionParameters* dictCParams = &dms->cParams; + uint* dictHashLong = dms->hashTable; + uint* dictHashSmall = dms->chainTable; + uint dictStartIndex = dms->window.dictLimit; + byte* dictBase = dms->window.@base; + byte* dictStart = dictBase + dictStartIndex; + byte* dictEnd = dms->window.nextSrc; + uint dictIndexDelta = prefixLowestIndex - (uint)(dictEnd - dictBase); + uint dictHBitsL = dictCParams->hashLog + 8; + uint dictHBitsS = dictCParams->chainLog + 8; + uint dictAndPrefixLength = (uint)(ip - prefixLowest + (dictEnd - dictStart)); + assert(ms->window.dictLimit + (1U << (int)cParams->windowLog) >= endIndex); + if (ms->prefetchCDictTables != 0) + { + nuint hashTableBytes = ((nuint)1 << (int)dictCParams->hashLog) * sizeof(uint); + nuint chainTableBytes = ((nuint)1 << (int)dictCParams->chainLog) * sizeof(uint); + { + sbyte* _ptr = (sbyte*)dictHashLong; + nuint _size = hashTableBytes; + nuint _pos; + for (_pos = 0; _pos < _size; _pos += 64) + { +#if NETCOREAPP3_0_OR_GREATER + if (System.Runtime.Intrinsics.X86.Sse.IsSupported) + { + System.Runtime.Intrinsics.X86.Sse.Prefetch1(_ptr + _pos); + } +#endif + } + } + + { + sbyte* _ptr = (sbyte*)dictHashSmall; + nuint _size = chainTableBytes; + nuint _pos; + for (_pos = 0; _pos < _size; _pos += 64) + { +#if NETCOREAPP3_0_OR_GREATER + if (System.Runtime.Intrinsics.X86.Sse.IsSupported) + { + System.Runtime.Intrinsics.X86.Sse.Prefetch1(_ptr + _pos); + } +#endif + } + } + } + + ip += dictAndPrefixLength == 0 ? 1 : 0; + assert(offset_1 <= dictAndPrefixLength); + assert(offset_2 <= dictAndPrefixLength); + while (ip < ilimit) + { + nuint mLength; + uint offset; + nuint h2 = ZSTD_hashPtr(ip, hBitsL, 8); + nuint h = ZSTD_hashPtr(ip, hBitsS, mls); + nuint dictHashAndTagL = ZSTD_hashPtr(ip, dictHBitsL, 8); + nuint dictHashAndTagS = ZSTD_hashPtr(ip, dictHBitsS, mls); + uint dictMatchIndexAndTagL = dictHashLong[dictHashAndTagL >> 8]; + uint dictMatchIndexAndTagS = dictHashSmall[dictHashAndTagS >> 8]; + int dictTagsMatchL = ZSTD_comparePackedTags(dictMatchIndexAndTagL, dictHashAndTagL); + int dictTagsMatchS = ZSTD_comparePackedTags(dictMatchIndexAndTagS, dictHashAndTagS); + uint curr = (uint)(ip - @base); + uint matchIndexL = hashLong[h2]; + uint matchIndexS = hashSmall[h]; + byte* matchLong = @base + matchIndexL; + byte* match = @base + matchIndexS; + uint repIndex = curr + 1 - offset_1; + byte* repMatch = + repIndex < prefixLowestIndex + ? dictBase + (repIndex - dictIndexDelta) + : @base + repIndex; + hashLong[h2] = hashSmall[h] = curr; + if ( + ZSTD_index_overlap_check(prefixLowestIndex, repIndex) != 0 + && MEM_read32(repMatch) == MEM_read32(ip + 1) + ) + { + byte* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend; + mLength = + ZSTD_count_2segments(ip + 1 + 4, repMatch + 4, iend, repMatchEnd, prefixLowest) + + 4; + ip++; + assert(1 >= 1); + assert(1 <= 3); + ZSTD_storeSeq(seqStore, (nuint)(ip - anchor), anchor, iend, 1, mLength); + goto _match_stored; + } + + if (matchIndexL >= prefixLowestIndex && MEM_read64(matchLong) == MEM_read64(ip)) + { + mLength = ZSTD_count(ip + 8, matchLong + 8, iend) + 8; + offset = (uint)(ip - matchLong); + while (ip > anchor && matchLong > prefixLowest && ip[-1] == matchLong[-1]) + { + ip--; + matchLong--; + mLength++; + } + + goto _match_found; + } + else if (dictTagsMatchL != 0) + { + /* check dictMatchState long match */ + uint dictMatchIndexL = dictMatchIndexAndTagL >> 8; + byte* dictMatchL = dictBase + dictMatchIndexL; + assert(dictMatchL < dictEnd); + if (dictMatchL > dictStart && MEM_read64(dictMatchL) == MEM_read64(ip)) + { + mLength = + ZSTD_count_2segments(ip + 8, dictMatchL + 8, iend, dictEnd, prefixLowest) + + 8; + offset = curr - dictMatchIndexL - dictIndexDelta; + while (ip > anchor && dictMatchL > dictStart && ip[-1] == dictMatchL[-1]) + { + ip--; + dictMatchL--; + mLength++; + } + + goto _match_found; + } + } + + if (matchIndexS > prefixLowestIndex) + { + if (MEM_read32(match) == MEM_read32(ip)) + { + goto _search_next_long; + } + } + else if (dictTagsMatchS != 0) + { + /* check dictMatchState short match */ + uint dictMatchIndexS = dictMatchIndexAndTagS >> 8; + match = dictBase + dictMatchIndexS; + matchIndexS = dictMatchIndexS + dictIndexDelta; + if (match > dictStart && MEM_read32(match) == MEM_read32(ip)) + { + goto _search_next_long; + } + } + + ip += (ip - anchor >> 8) + 1; + continue; + _search_next_long: + { + nuint hl3 = ZSTD_hashPtr(ip + 1, hBitsL, 8); + nuint dictHashAndTagL3 = ZSTD_hashPtr(ip + 1, dictHBitsL, 8); + uint matchIndexL3 = hashLong[hl3]; + uint dictMatchIndexAndTagL3 = dictHashLong[dictHashAndTagL3 >> 8]; + int dictTagsMatchL3 = ZSTD_comparePackedTags( + dictMatchIndexAndTagL3, + dictHashAndTagL3 + ); + byte* matchL3 = @base + matchIndexL3; + hashLong[hl3] = curr + 1; + if (matchIndexL3 >= prefixLowestIndex && MEM_read64(matchL3) == MEM_read64(ip + 1)) + { + mLength = ZSTD_count(ip + 9, matchL3 + 8, iend) + 8; + ip++; + offset = (uint)(ip - matchL3); + while (ip > anchor && matchL3 > prefixLowest && ip[-1] == matchL3[-1]) + { + ip--; + matchL3--; + mLength++; + } + + goto _match_found; + } + else if (dictTagsMatchL3 != 0) + { + /* check dict long +1 match */ + uint dictMatchIndexL3 = dictMatchIndexAndTagL3 >> 8; + byte* dictMatchL3 = dictBase + dictMatchIndexL3; + assert(dictMatchL3 < dictEnd); + if (dictMatchL3 > dictStart && MEM_read64(dictMatchL3) == MEM_read64(ip + 1)) + { + mLength = + ZSTD_count_2segments( + ip + 1 + 8, + dictMatchL3 + 8, + iend, + dictEnd, + prefixLowest + ) + 8; + ip++; + offset = curr + 1 - dictMatchIndexL3 - dictIndexDelta; + while (ip > anchor && dictMatchL3 > dictStart && ip[-1] == dictMatchL3[-1]) + { + ip--; + dictMatchL3--; + mLength++; + } + + goto _match_found; + } + } + } + + if (matchIndexS < prefixLowestIndex) + { + mLength = ZSTD_count_2segments(ip + 4, match + 4, iend, dictEnd, prefixLowest) + 4; + offset = curr - matchIndexS; + while (ip > anchor && match > dictStart && ip[-1] == match[-1]) + { + ip--; + match--; + mLength++; + } + } + else + { + mLength = ZSTD_count(ip + 4, match + 4, iend) + 4; + offset = (uint)(ip - match); + while (ip > anchor && match > prefixLowest && ip[-1] == match[-1]) + { + ip--; + match--; + mLength++; + } + } + + _match_found: + offset_2 = offset_1; + offset_1 = offset; + assert(offset > 0); + ZSTD_storeSeq(seqStore, (nuint)(ip - anchor), anchor, iend, offset + 3, mLength); + _match_stored: + ip += mLength; + anchor = ip; + if (ip <= ilimit) + { + { + uint indexToInsert = curr + 2; + hashLong[ZSTD_hashPtr(@base + indexToInsert, hBitsL, 8)] = indexToInsert; + hashLong[ZSTD_hashPtr(ip - 2, hBitsL, 8)] = (uint)(ip - 2 - @base); + hashSmall[ZSTD_hashPtr(@base + indexToInsert, hBitsS, mls)] = indexToInsert; + hashSmall[ZSTD_hashPtr(ip - 1, hBitsS, mls)] = (uint)(ip - 1 - @base); + } + + while (ip <= ilimit) + { + uint current2 = (uint)(ip - @base); + uint repIndex2 = current2 - offset_2; + byte* repMatch2 = + repIndex2 < prefixLowestIndex + ? dictBase + repIndex2 - dictIndexDelta + : @base + repIndex2; + if ( + ZSTD_index_overlap_check(prefixLowestIndex, repIndex2) != 0 + && MEM_read32(repMatch2) == MEM_read32(ip) + ) + { + byte* repEnd2 = repIndex2 < prefixLowestIndex ? dictEnd : iend; + nuint repLength2 = + ZSTD_count_2segments(ip + 4, repMatch2 + 4, iend, repEnd2, prefixLowest) + + 4; + /* swap offset_2 <=> offset_1 */ + uint tmpOffset = offset_2; + offset_2 = offset_1; + offset_1 = tmpOffset; + assert(1 >= 1); + assert(1 <= 3); + ZSTD_storeSeq(seqStore, 0, anchor, iend, 1, repLength2); + hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = current2; + hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = current2; + ip += repLength2; + anchor = ip; + continue; + } + + break; + } + } + } + + rep[0] = offset_1; + rep[1] = offset_2; + return (nuint)(iend - anchor); + } + + private static nuint ZSTD_compressBlock_doubleFast_noDict_4( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_doubleFast_noDict_generic(ms, seqStore, rep, src, srcSize, 4); + } + + private static nuint ZSTD_compressBlock_doubleFast_noDict_5( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_doubleFast_noDict_generic(ms, seqStore, rep, src, srcSize, 5); + } + + private static nuint ZSTD_compressBlock_doubleFast_noDict_6( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_doubleFast_noDict_generic(ms, seqStore, rep, src, srcSize, 6); + } + + private static nuint ZSTD_compressBlock_doubleFast_noDict_7( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_doubleFast_noDict_generic(ms, seqStore, rep, src, srcSize, 7); + } + + private static nuint ZSTD_compressBlock_doubleFast_dictMatchState_4( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_doubleFast_dictMatchState_generic( + ms, + seqStore, + rep, + src, + srcSize, + 4 + ); + } + + private static nuint ZSTD_compressBlock_doubleFast_dictMatchState_5( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_doubleFast_dictMatchState_generic( + ms, + seqStore, + rep, + src, + srcSize, + 5 + ); + } + + private static nuint ZSTD_compressBlock_doubleFast_dictMatchState_6( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_doubleFast_dictMatchState_generic( + ms, + seqStore, + rep, + src, + srcSize, + 6 + ); + } + + private static nuint ZSTD_compressBlock_doubleFast_dictMatchState_7( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_doubleFast_dictMatchState_generic( + ms, + seqStore, + rep, + src, + srcSize, + 7 + ); + } + + private static nuint ZSTD_compressBlock_doubleFast( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + uint mls = ms->cParams.minMatch; + switch (mls) + { + default: + case 4: + return ZSTD_compressBlock_doubleFast_noDict_4(ms, seqStore, rep, src, srcSize); + case 5: + return ZSTD_compressBlock_doubleFast_noDict_5(ms, seqStore, rep, src, srcSize); + case 6: + return ZSTD_compressBlock_doubleFast_noDict_6(ms, seqStore, rep, src, srcSize); + case 7: + return ZSTD_compressBlock_doubleFast_noDict_7(ms, seqStore, rep, src, srcSize); + } + } + + private static nuint ZSTD_compressBlock_doubleFast_dictMatchState( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + uint mls = ms->cParams.minMatch; + switch (mls) + { + default: + case 4: + return ZSTD_compressBlock_doubleFast_dictMatchState_4( + ms, + seqStore, + rep, + src, + srcSize + ); + case 5: + return ZSTD_compressBlock_doubleFast_dictMatchState_5( + ms, + seqStore, + rep, + src, + srcSize + ); + case 6: + return ZSTD_compressBlock_doubleFast_dictMatchState_6( + ms, + seqStore, + rep, + src, + srcSize + ); + case 7: + return ZSTD_compressBlock_doubleFast_dictMatchState_7( + ms, + seqStore, + rep, + src, + srcSize + ); + } + } + + private static nuint ZSTD_compressBlock_doubleFast_extDict_generic( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize, + uint mls + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* hashLong = ms->hashTable; + uint hBitsL = cParams->hashLog; + uint* hashSmall = ms->chainTable; + uint hBitsS = cParams->chainLog; + byte* istart = (byte*)src; + byte* ip = istart; + byte* anchor = istart; + byte* iend = istart + srcSize; + byte* ilimit = iend - 8; + byte* @base = ms->window.@base; + uint endIndex = (uint)((nuint)(istart - @base) + srcSize); + uint lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog); + uint dictStartIndex = lowLimit; + uint dictLimit = ms->window.dictLimit; + uint prefixStartIndex = dictLimit > lowLimit ? dictLimit : lowLimit; + byte* prefixStart = @base + prefixStartIndex; + byte* dictBase = ms->window.dictBase; + byte* dictStart = dictBase + dictStartIndex; + byte* dictEnd = dictBase + prefixStartIndex; + uint offset_1 = rep[0], + offset_2 = rep[1]; + if (prefixStartIndex == dictStartIndex) + return ZSTD_compressBlock_doubleFast(ms, seqStore, rep, src, srcSize); + while (ip < ilimit) + { + nuint hSmall = ZSTD_hashPtr(ip, hBitsS, mls); + uint matchIndex = hashSmall[hSmall]; + byte* matchBase = matchIndex < prefixStartIndex ? dictBase : @base; + byte* match = matchBase + matchIndex; + nuint hLong = ZSTD_hashPtr(ip, hBitsL, 8); + uint matchLongIndex = hashLong[hLong]; + byte* matchLongBase = matchLongIndex < prefixStartIndex ? dictBase : @base; + byte* matchLong = matchLongBase + matchLongIndex; + uint curr = (uint)(ip - @base); + /* offset_1 expected <= curr +1 */ + uint repIndex = curr + 1 - offset_1; + byte* repBase = repIndex < prefixStartIndex ? dictBase : @base; + byte* repMatch = repBase + repIndex; + nuint mLength; + hashSmall[hSmall] = hashLong[hLong] = curr; + if ( + ( + ZSTD_index_overlap_check(prefixStartIndex, repIndex) + & (offset_1 <= curr + 1 - dictStartIndex ? 1 : 0) + ) != 0 + && MEM_read32(repMatch) == MEM_read32(ip + 1) + ) + { + byte* repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend; + mLength = + ZSTD_count_2segments(ip + 1 + 4, repMatch + 4, iend, repMatchEnd, prefixStart) + + 4; + ip++; + assert(1 >= 1); + assert(1 <= 3); + ZSTD_storeSeq(seqStore, (nuint)(ip - anchor), anchor, iend, 1, mLength); + } + else + { + if (matchLongIndex > dictStartIndex && MEM_read64(matchLong) == MEM_read64(ip)) + { + byte* matchEnd = matchLongIndex < prefixStartIndex ? dictEnd : iend; + byte* lowMatchPtr = matchLongIndex < prefixStartIndex ? dictStart : prefixStart; + uint offset; + mLength = + ZSTD_count_2segments(ip + 8, matchLong + 8, iend, matchEnd, prefixStart) + + 8; + offset = curr - matchLongIndex; + while (ip > anchor && matchLong > lowMatchPtr && ip[-1] == matchLong[-1]) + { + ip--; + matchLong--; + mLength++; + } + + offset_2 = offset_1; + offset_1 = offset; + assert(offset > 0); + ZSTD_storeSeq( + seqStore, + (nuint)(ip - anchor), + anchor, + iend, + offset + 3, + mLength + ); + } + else if (matchIndex > dictStartIndex && MEM_read32(match) == MEM_read32(ip)) + { + nuint h3 = ZSTD_hashPtr(ip + 1, hBitsL, 8); + uint matchIndex3 = hashLong[h3]; + byte* match3Base = matchIndex3 < prefixStartIndex ? dictBase : @base; + byte* match3 = match3Base + matchIndex3; + uint offset; + hashLong[h3] = curr + 1; + if (matchIndex3 > dictStartIndex && MEM_read64(match3) == MEM_read64(ip + 1)) + { + byte* matchEnd = matchIndex3 < prefixStartIndex ? dictEnd : iend; + byte* lowMatchPtr = + matchIndex3 < prefixStartIndex ? dictStart : prefixStart; + mLength = + ZSTD_count_2segments(ip + 9, match3 + 8, iend, matchEnd, prefixStart) + + 8; + ip++; + offset = curr + 1 - matchIndex3; + while (ip > anchor && match3 > lowMatchPtr && ip[-1] == match3[-1]) + { + ip--; + match3--; + mLength++; + } + } + else + { + byte* matchEnd = matchIndex < prefixStartIndex ? dictEnd : iend; + byte* lowMatchPtr = matchIndex < prefixStartIndex ? dictStart : prefixStart; + mLength = + ZSTD_count_2segments(ip + 4, match + 4, iend, matchEnd, prefixStart) + + 4; + offset = curr - matchIndex; + while (ip > anchor && match > lowMatchPtr && ip[-1] == match[-1]) + { + ip--; + match--; + mLength++; + } + } + + offset_2 = offset_1; + offset_1 = offset; + assert(offset > 0); + ZSTD_storeSeq( + seqStore, + (nuint)(ip - anchor), + anchor, + iend, + offset + 3, + mLength + ); + } + else + { + ip += (ip - anchor >> 8) + 1; + continue; + } + } + + ip += mLength; + anchor = ip; + if (ip <= ilimit) + { + { + uint indexToInsert = curr + 2; + hashLong[ZSTD_hashPtr(@base + indexToInsert, hBitsL, 8)] = indexToInsert; + hashLong[ZSTD_hashPtr(ip - 2, hBitsL, 8)] = (uint)(ip - 2 - @base); + hashSmall[ZSTD_hashPtr(@base + indexToInsert, hBitsS, mls)] = indexToInsert; + hashSmall[ZSTD_hashPtr(ip - 1, hBitsS, mls)] = (uint)(ip - 1 - @base); + } + + while (ip <= ilimit) + { + uint current2 = (uint)(ip - @base); + uint repIndex2 = current2 - offset_2; + byte* repMatch2 = + repIndex2 < prefixStartIndex ? dictBase + repIndex2 : @base + repIndex2; + if ( + ( + ZSTD_index_overlap_check(prefixStartIndex, repIndex2) + & (offset_2 <= current2 - dictStartIndex ? 1 : 0) + ) != 0 + && MEM_read32(repMatch2) == MEM_read32(ip) + ) + { + byte* repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend; + nuint repLength2 = + ZSTD_count_2segments(ip + 4, repMatch2 + 4, iend, repEnd2, prefixStart) + + 4; + /* swap offset_2 <=> offset_1 */ + uint tmpOffset = offset_2; + offset_2 = offset_1; + offset_1 = tmpOffset; + assert(1 >= 1); + assert(1 <= 3); + ZSTD_storeSeq(seqStore, 0, anchor, iend, 1, repLength2); + hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = current2; + hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = current2; + ip += repLength2; + anchor = ip; + continue; + } + + break; + } + } + } + + rep[0] = offset_1; + rep[1] = offset_2; + return (nuint)(iend - anchor); + } + + private static nuint ZSTD_compressBlock_doubleFast_extDict_4( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 4); + } + + private static nuint ZSTD_compressBlock_doubleFast_extDict_5( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 5); + } + + private static nuint ZSTD_compressBlock_doubleFast_extDict_6( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 6); + } + + private static nuint ZSTD_compressBlock_doubleFast_extDict_7( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 7); + } + + private static nuint ZSTD_compressBlock_doubleFast_extDict( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + uint mls = ms->cParams.minMatch; + switch (mls) + { + default: + case 4: + return ZSTD_compressBlock_doubleFast_extDict_4(ms, seqStore, rep, src, srcSize); + case 5: + return ZSTD_compressBlock_doubleFast_extDict_5(ms, seqStore, rep, src, srcSize); + case 6: + return ZSTD_compressBlock_doubleFast_extDict_6(ms, seqStore, rep, src, srcSize); + case 7: + return ZSTD_compressBlock_doubleFast_extDict_7(ms, seqStore, rep, src, srcSize); + } + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdFast.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdFast.cs new file mode 100644 index 000000000..518954b6b --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdFast.cs @@ -0,0 +1,1209 @@ +using System.Runtime.CompilerServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + private static void ZSTD_fillHashTableForCDict( + ZSTD_MatchState_t* ms, + void* end, + ZSTD_dictTableLoadMethod_e dtlm + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* hashTable = ms->hashTable; + uint hBits = cParams->hashLog + 8; + uint mls = cParams->minMatch; + byte* @base = ms->window.@base; + byte* ip = @base + ms->nextToUpdate; + byte* iend = (byte*)end - 8; + const uint fastHashFillStep = 3; + assert(dtlm == ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_full); + for (; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep) + { + uint curr = (uint)(ip - @base); + { + nuint hashAndTag = ZSTD_hashPtr(ip, hBits, mls); + ZSTD_writeTaggedIndex(hashTable, hashAndTag, curr); + } + + if (dtlm == ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast) + continue; + { + uint p; + for (p = 1; p < fastHashFillStep; ++p) + { + nuint hashAndTag = ZSTD_hashPtr(ip + p, hBits, mls); + if (hashTable[hashAndTag >> 8] == 0) + { + ZSTD_writeTaggedIndex(hashTable, hashAndTag, curr + p); + } + } + } + } + } + + private static void ZSTD_fillHashTableForCCtx( + ZSTD_MatchState_t* ms, + void* end, + ZSTD_dictTableLoadMethod_e dtlm + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* hashTable = ms->hashTable; + uint hBits = cParams->hashLog; + uint mls = cParams->minMatch; + byte* @base = ms->window.@base; + byte* ip = @base + ms->nextToUpdate; + byte* iend = (byte*)end - 8; + const uint fastHashFillStep = 3; + assert(dtlm == ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast); + for (; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep) + { + uint curr = (uint)(ip - @base); + nuint hash0 = ZSTD_hashPtr(ip, hBits, mls); + hashTable[hash0] = curr; + if (dtlm == ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast) + continue; + { + uint p; + for (p = 1; p < fastHashFillStep; ++p) + { + nuint hash = ZSTD_hashPtr(ip + p, hBits, mls); + if (hashTable[hash] == 0) + { + hashTable[hash] = curr + p; + } + } + } + } + } + + private static void ZSTD_fillHashTable( + ZSTD_MatchState_t* ms, + void* end, + ZSTD_dictTableLoadMethod_e dtlm, + ZSTD_tableFillPurpose_e tfp + ) + { + if (tfp == ZSTD_tableFillPurpose_e.ZSTD_tfp_forCDict) + { + ZSTD_fillHashTableForCDict(ms, end, dtlm); + } + else + { + ZSTD_fillHashTableForCCtx(ms, end, dtlm); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_match4Found_cmov( + byte* currentPtr, + byte* matchAddress, + uint matchIdx, + uint idxLowLimit + ) + { + /* currentIdx >= lowLimit is a (somewhat) unpredictable branch. + * However expression below compiles into conditional move. + */ + byte* mvalAddr = ZSTD_selectAddr(matchIdx, idxLowLimit, matchAddress, dummy); + if (MEM_read32(currentPtr) != MEM_read32(mvalAddr)) + return 0; + return matchIdx >= idxLowLimit ? 1 : 0; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_match4Found_branch( + byte* currentPtr, + byte* matchAddress, + uint matchIdx, + uint idxLowLimit + ) + { + /* using a branch instead of a cmov, + * because it's faster in scenarios where matchIdx >= idxLowLimit is generally true, + * aka almost all candidates are within range */ + uint mval; + if (matchIdx >= idxLowLimit) + { + mval = MEM_read32(matchAddress); + } + else + { + mval = MEM_read32(currentPtr) ^ 1; + } + + return MEM_read32(currentPtr) == mval ? 1 : 0; + } + + /** + * If you squint hard enough (and ignore repcodes), the search operation at any + * given position is broken into 4 stages: + * + * 1. Hash (map position to hash value via input read) + * 2. Lookup (map hash val to index via hashtable read) + * 3. Load (map index to value at that position via input read) + * 4. Compare + * + * Each of these steps involves a memory read at an address which is computed + * from the previous step. This means these steps must be sequenced and their + * latencies are cumulative. + * + * Rather than do 1->2->3->4 sequentially for a single position before moving + * onto the next, this implementation interleaves these operations across the + * next few positions: + * + * R = Repcode Read & Compare + * H = Hash + * T = Table Lookup + * M = Match Read & Compare + * + * Pos | Time --> + * ----+------------------- + * N | ... M + * N+1 | ... TM + * N+2 | R H T M + * N+3 | H TM + * N+4 | R H T M + * N+5 | H ... + * N+6 | R ... + * + * This is very much analogous to the pipelining of execution in a CPU. And just + * like a CPU, we have to dump the pipeline when we find a match (i.e., take a + * branch). + * + * When this happens, we throw away our current state, and do the following prep + * to re-enter the loop: + * + * Pos | Time --> + * ----+------------------- + * N | H T + * N+1 | H + * + * This is also the work we do at the beginning to enter the loop initially. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_compressBlock_fast_noDict_generic( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize, + uint mls, + int useCmov + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* hashTable = ms->hashTable; + uint hlog = cParams->hashLog; + /* min 2 */ + nuint stepSize = cParams->targetLength + (uint)(cParams->targetLength == 0 ? 1 : 0) + 1; + byte* @base = ms->window.@base; + byte* istart = (byte*)src; + uint endIndex = (uint)((nuint)(istart - @base) + srcSize); + uint prefixStartIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog); + byte* prefixStart = @base + prefixStartIndex; + byte* iend = istart + srcSize; + byte* ilimit = iend - 8; + byte* anchor = istart; + byte* ip0 = istart; + byte* ip1; + byte* ip2; + byte* ip3; + uint current0; + uint rep_offset1 = rep[0]; + uint rep_offset2 = rep[1]; + uint offsetSaved1 = 0, + offsetSaved2 = 0; + /* hash for ip0 */ + nuint hash0; + /* hash for ip1 */ + nuint hash1; + /* match idx for ip0 */ + uint matchIdx; + uint offcode; + byte* match0; + nuint mLength; + /* ip0 and ip1 are always adjacent. The targetLength skipping and + * uncompressibility acceleration is applied to every other position, + * matching the behavior of #1562. step therefore represents the gap + * between pairs of positions, from ip0 to ip2 or ip1 to ip3. */ + nuint step; + byte* nextStep; + const nuint kStepIncr = 1 << 8 - 1; + void* matchFound = + useCmov != 0 + ? (delegate* managed)(&ZSTD_match4Found_cmov) + : (delegate* managed)(&ZSTD_match4Found_branch); + ip0 += ip0 == prefixStart ? 1 : 0; + { + uint curr = (uint)(ip0 - @base); + uint windowLow = ZSTD_getLowestPrefixIndex(ms, curr, cParams->windowLog); + uint maxRep = curr - windowLow; + if (rep_offset2 > maxRep) + { + offsetSaved2 = rep_offset2; + rep_offset2 = 0; + } + + if (rep_offset1 > maxRep) + { + offsetSaved1 = rep_offset1; + rep_offset1 = 0; + } + } + + _start: + step = stepSize; + nextStep = ip0 + kStepIncr; + ip1 = ip0 + 1; + ip2 = ip0 + step; + ip3 = ip2 + 1; + if (ip3 >= ilimit) + { + goto _cleanup; + } + + hash0 = ZSTD_hashPtr(ip0, hlog, mls); + hash1 = ZSTD_hashPtr(ip1, hlog, mls); + matchIdx = hashTable[hash0]; + do + { + /* load repcode match for ip[2]*/ + uint rval = MEM_read32(ip2 - rep_offset1); + current0 = (uint)(ip0 - @base); + hashTable[hash0] = current0; + if (MEM_read32(ip2) == rval && rep_offset1 > 0) + { + ip0 = ip2; + match0 = ip0 - rep_offset1; + mLength = ip0[-1] == match0[-1] ? 1U : 0U; + ip0 -= mLength; + match0 -= mLength; + assert(1 >= 1); + assert(1 <= 3); + offcode = 1; + mLength += 4; + hashTable[hash1] = (uint)(ip1 - @base); + goto _match; + } + + if ( + ((delegate* managed)matchFound)( + ip0, + @base + matchIdx, + matchIdx, + prefixStartIndex + ) != 0 + ) + { + hashTable[hash1] = (uint)(ip1 - @base); + goto _offset; + } + + matchIdx = hashTable[hash1]; + hash0 = hash1; + hash1 = ZSTD_hashPtr(ip2, hlog, mls); + ip0 = ip1; + ip1 = ip2; + ip2 = ip3; + current0 = (uint)(ip0 - @base); + hashTable[hash0] = current0; + if ( + ((delegate* managed)matchFound)( + ip0, + @base + matchIdx, + matchIdx, + prefixStartIndex + ) != 0 + ) + { + if (step <= 4) + { + hashTable[hash1] = (uint)(ip1 - @base); + } + + goto _offset; + } + + matchIdx = hashTable[hash1]; + hash0 = hash1; + hash1 = ZSTD_hashPtr(ip2, hlog, mls); + ip0 = ip1; + ip1 = ip2; + ip2 = ip0 + step; + ip3 = ip1 + step; + if (ip2 >= nextStep) + { + step++; +#if NETCOREAPP3_0_OR_GREATER + if (System.Runtime.Intrinsics.X86.Sse.IsSupported) + { + System.Runtime.Intrinsics.X86.Sse.Prefetch0(ip1 + 64); + System.Runtime.Intrinsics.X86.Sse.Prefetch0(ip1 + 128); + } +#endif + + nextStep += kStepIncr; + } + } while (ip3 < ilimit); + _cleanup: + offsetSaved2 = offsetSaved1 != 0 && rep_offset1 != 0 ? offsetSaved1 : offsetSaved2; + rep[0] = rep_offset1 != 0 ? rep_offset1 : offsetSaved1; + rep[1] = rep_offset2 != 0 ? rep_offset2 : offsetSaved2; + return (nuint)(iend - anchor); + _offset: + match0 = @base + matchIdx; + rep_offset2 = rep_offset1; + rep_offset1 = (uint)(ip0 - match0); + assert(rep_offset1 > 0); + offcode = rep_offset1 + 3; + mLength = 4; + while (ip0 > anchor && match0 > prefixStart && ip0[-1] == match0[-1]) + { + ip0--; + match0--; + mLength++; + } + + _match: + mLength += ZSTD_count(ip0 + mLength, match0 + mLength, iend); + ZSTD_storeSeq(seqStore, (nuint)(ip0 - anchor), anchor, iend, offcode, mLength); + ip0 += mLength; + anchor = ip0; + if (ip0 <= ilimit) + { + assert(@base + current0 + 2 > istart); + hashTable[ZSTD_hashPtr(@base + current0 + 2, hlog, mls)] = current0 + 2; + hashTable[ZSTD_hashPtr(ip0 - 2, hlog, mls)] = (uint)(ip0 - 2 - @base); + if (rep_offset2 > 0) + { + while (ip0 <= ilimit && MEM_read32(ip0) == MEM_read32(ip0 - rep_offset2)) + { + /* store sequence */ + nuint rLength = ZSTD_count(ip0 + 4, ip0 + 4 - rep_offset2, iend) + 4; + { + /* swap rep_offset2 <=> rep_offset1 */ + uint tmpOff = rep_offset2; + rep_offset2 = rep_offset1; + rep_offset1 = tmpOff; + } + + hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = (uint)(ip0 - @base); + ip0 += rLength; + assert(1 >= 1); + assert(1 <= 3); + ZSTD_storeSeq(seqStore, 0, anchor, iend, 1, rLength); + anchor = ip0; + continue; + } + } + } + + goto _start; + } + + private static nuint ZSTD_compressBlock_fast_noDict_4_1( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_noDict_generic(ms, seqStore, rep, src, srcSize, 4, 1); + } + + private static nuint ZSTD_compressBlock_fast_noDict_5_1( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_noDict_generic(ms, seqStore, rep, src, srcSize, 5, 1); + } + + private static nuint ZSTD_compressBlock_fast_noDict_6_1( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_noDict_generic(ms, seqStore, rep, src, srcSize, 6, 1); + } + + private static nuint ZSTD_compressBlock_fast_noDict_7_1( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_noDict_generic(ms, seqStore, rep, src, srcSize, 7, 1); + } + + private static nuint ZSTD_compressBlock_fast_noDict_4_0( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_noDict_generic(ms, seqStore, rep, src, srcSize, 4, 0); + } + + private static nuint ZSTD_compressBlock_fast_noDict_5_0( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_noDict_generic(ms, seqStore, rep, src, srcSize, 5, 0); + } + + private static nuint ZSTD_compressBlock_fast_noDict_6_0( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_noDict_generic(ms, seqStore, rep, src, srcSize, 6, 0); + } + + private static nuint ZSTD_compressBlock_fast_noDict_7_0( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_noDict_generic(ms, seqStore, rep, src, srcSize, 7, 0); + } + + private static nuint ZSTD_compressBlock_fast( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + uint mml = ms->cParams.minMatch; + /* use cmov when "candidate in range" branch is likely unpredictable */ + int useCmov = ms->cParams.windowLog < 19 ? 1 : 0; + assert(ms->dictMatchState == null); + if (useCmov != 0) + { + switch (mml) + { + default: + case 4: + return ZSTD_compressBlock_fast_noDict_4_1(ms, seqStore, rep, src, srcSize); + case 5: + return ZSTD_compressBlock_fast_noDict_5_1(ms, seqStore, rep, src, srcSize); + case 6: + return ZSTD_compressBlock_fast_noDict_6_1(ms, seqStore, rep, src, srcSize); + case 7: + return ZSTD_compressBlock_fast_noDict_7_1(ms, seqStore, rep, src, srcSize); + } + } + else + { + switch (mml) + { + default: + case 4: + return ZSTD_compressBlock_fast_noDict_4_0(ms, seqStore, rep, src, srcSize); + case 5: + return ZSTD_compressBlock_fast_noDict_5_0(ms, seqStore, rep, src, srcSize); + case 6: + return ZSTD_compressBlock_fast_noDict_6_0(ms, seqStore, rep, src, srcSize); + case 7: + return ZSTD_compressBlock_fast_noDict_7_0(ms, seqStore, rep, src, srcSize); + } + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_compressBlock_fast_dictMatchState_generic( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize, + uint mls, + uint hasStep + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* hashTable = ms->hashTable; + uint hlog = cParams->hashLog; + /* support stepSize of 0 */ + uint stepSize = cParams->targetLength + (uint)(cParams->targetLength == 0 ? 1 : 0); + byte* @base = ms->window.@base; + byte* istart = (byte*)src; + byte* ip0 = istart; + /* we assert below that stepSize >= 1 */ + byte* ip1 = ip0 + stepSize; + byte* anchor = istart; + uint prefixStartIndex = ms->window.dictLimit; + byte* prefixStart = @base + prefixStartIndex; + byte* iend = istart + srcSize; + byte* ilimit = iend - 8; + uint offset_1 = rep[0], + offset_2 = rep[1]; + ZSTD_MatchState_t* dms = ms->dictMatchState; + ZSTD_compressionParameters* dictCParams = &dms->cParams; + uint* dictHashTable = dms->hashTable; + uint dictStartIndex = dms->window.dictLimit; + byte* dictBase = dms->window.@base; + byte* dictStart = dictBase + dictStartIndex; + byte* dictEnd = dms->window.nextSrc; + uint dictIndexDelta = prefixStartIndex - (uint)(dictEnd - dictBase); + uint dictAndPrefixLength = (uint)(istart - prefixStart + dictEnd - dictStart); + uint dictHBits = dictCParams->hashLog + 8; + /* if a dictionary is still attached, it necessarily means that + * it is within window size. So we just check it. */ + uint maxDistance = 1U << (int)cParams->windowLog; + uint endIndex = (uint)((nuint)(istart - @base) + srcSize); + assert(endIndex - prefixStartIndex <= maxDistance); + assert(prefixStartIndex >= (uint)(dictEnd - dictBase)); + if (ms->prefetchCDictTables != 0) + { + nuint hashTableBytes = ((nuint)1 << (int)dictCParams->hashLog) * sizeof(uint); + { + sbyte* _ptr = (sbyte*)dictHashTable; + nuint _size = hashTableBytes; + nuint _pos; + for (_pos = 0; _pos < _size; _pos += 64) + { +#if NETCOREAPP3_0_OR_GREATER + if (System.Runtime.Intrinsics.X86.Sse.IsSupported) + { + System.Runtime.Intrinsics.X86.Sse.Prefetch1(_ptr + _pos); + } +#endif + } + } + } + + ip0 += dictAndPrefixLength == 0 ? 1 : 0; + assert(offset_1 <= dictAndPrefixLength); + assert(offset_2 <= dictAndPrefixLength); + assert(stepSize >= 1); + while (ip1 <= ilimit) + { + nuint mLength; + nuint hash0 = ZSTD_hashPtr(ip0, hlog, mls); + nuint dictHashAndTag0 = ZSTD_hashPtr(ip0, dictHBits, mls); + uint dictMatchIndexAndTag = dictHashTable[dictHashAndTag0 >> 8]; + int dictTagsMatch = ZSTD_comparePackedTags(dictMatchIndexAndTag, dictHashAndTag0); + uint matchIndex = hashTable[hash0]; + uint curr = (uint)(ip0 - @base); + nuint step = stepSize; + const nuint kStepIncr = 1 << 8; + byte* nextStep = ip0 + kStepIncr; + while (true) + { + byte* match = @base + matchIndex; + uint repIndex = curr + 1 - offset_1; + byte* repMatch = + repIndex < prefixStartIndex + ? dictBase + (repIndex - dictIndexDelta) + : @base + repIndex; + nuint hash1 = ZSTD_hashPtr(ip1, hlog, mls); + nuint dictHashAndTag1 = ZSTD_hashPtr(ip1, dictHBits, mls); + hashTable[hash0] = curr; + if ( + ZSTD_index_overlap_check(prefixStartIndex, repIndex) != 0 + && MEM_read32(repMatch) == MEM_read32(ip0 + 1) + ) + { + byte* repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend; + mLength = + ZSTD_count_2segments( + ip0 + 1 + 4, + repMatch + 4, + iend, + repMatchEnd, + prefixStart + ) + 4; + ip0++; + assert(1 >= 1); + assert(1 <= 3); + ZSTD_storeSeq(seqStore, (nuint)(ip0 - anchor), anchor, iend, 1, mLength); + break; + } + + if (dictTagsMatch != 0) + { + /* Found a possible dict match */ + uint dictMatchIndex = dictMatchIndexAndTag >> 8; + byte* dictMatch = dictBase + dictMatchIndex; + if (dictMatchIndex > dictStartIndex && MEM_read32(dictMatch) == MEM_read32(ip0)) + { + if (matchIndex <= prefixStartIndex) + { + uint offset = curr - dictMatchIndex - dictIndexDelta; + mLength = + ZSTD_count_2segments( + ip0 + 4, + dictMatch + 4, + iend, + dictEnd, + prefixStart + ) + 4; + while ( + ip0 > anchor && dictMatch > dictStart && ip0[-1] == dictMatch[-1] + ) + { + ip0--; + dictMatch--; + mLength++; + } + + offset_2 = offset_1; + offset_1 = offset; + assert(offset > 0); + ZSTD_storeSeq( + seqStore, + (nuint)(ip0 - anchor), + anchor, + iend, + offset + 3, + mLength + ); + break; + } + } + } + + if (ZSTD_match4Found_cmov(ip0, match, matchIndex, prefixStartIndex) != 0) + { + /* found a regular match of size >= 4 */ + uint offset = (uint)(ip0 - match); + mLength = ZSTD_count(ip0 + 4, match + 4, iend) + 4; + while (ip0 > anchor && match > prefixStart && ip0[-1] == match[-1]) + { + ip0--; + match--; + mLength++; + } + + offset_2 = offset_1; + offset_1 = offset; + assert(offset > 0); + ZSTD_storeSeq( + seqStore, + (nuint)(ip0 - anchor), + anchor, + iend, + offset + 3, + mLength + ); + break; + } + + dictMatchIndexAndTag = dictHashTable[dictHashAndTag1 >> 8]; + dictTagsMatch = ZSTD_comparePackedTags(dictMatchIndexAndTag, dictHashAndTag1); + matchIndex = hashTable[hash1]; + if (ip1 >= nextStep) + { + step++; + nextStep += kStepIncr; + } + + ip0 = ip1; + ip1 = ip1 + step; + if (ip1 > ilimit) + goto _cleanup; + curr = (uint)(ip0 - @base); + hash0 = hash1; + } + + assert(mLength != 0); + ip0 += mLength; + anchor = ip0; + if (ip0 <= ilimit) + { + assert(@base + curr + 2 > istart); + hashTable[ZSTD_hashPtr(@base + curr + 2, hlog, mls)] = curr + 2; + hashTable[ZSTD_hashPtr(ip0 - 2, hlog, mls)] = (uint)(ip0 - 2 - @base); + while (ip0 <= ilimit) + { + uint current2 = (uint)(ip0 - @base); + uint repIndex2 = current2 - offset_2; + byte* repMatch2 = + repIndex2 < prefixStartIndex + ? dictBase - dictIndexDelta + repIndex2 + : @base + repIndex2; + if ( + ZSTD_index_overlap_check(prefixStartIndex, repIndex2) != 0 + && MEM_read32(repMatch2) == MEM_read32(ip0) + ) + { + byte* repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend; + nuint repLength2 = + ZSTD_count_2segments(ip0 + 4, repMatch2 + 4, iend, repEnd2, prefixStart) + + 4; + /* swap offset_2 <=> offset_1 */ + uint tmpOffset = offset_2; + offset_2 = offset_1; + offset_1 = tmpOffset; + assert(1 >= 1); + assert(1 <= 3); + ZSTD_storeSeq(seqStore, 0, anchor, iend, 1, repLength2); + hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = current2; + ip0 += repLength2; + anchor = ip0; + continue; + } + + break; + } + } + + assert(ip0 == anchor); + ip1 = ip0 + stepSize; + } + + _cleanup: + rep[0] = offset_1; + rep[1] = offset_2; + return (nuint)(iend - anchor); + } + + private static nuint ZSTD_compressBlock_fast_dictMatchState_4_0( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_dictMatchState_generic( + ms, + seqStore, + rep, + src, + srcSize, + 4, + 0 + ); + } + + private static nuint ZSTD_compressBlock_fast_dictMatchState_5_0( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_dictMatchState_generic( + ms, + seqStore, + rep, + src, + srcSize, + 5, + 0 + ); + } + + private static nuint ZSTD_compressBlock_fast_dictMatchState_6_0( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_dictMatchState_generic( + ms, + seqStore, + rep, + src, + srcSize, + 6, + 0 + ); + } + + private static nuint ZSTD_compressBlock_fast_dictMatchState_7_0( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_dictMatchState_generic( + ms, + seqStore, + rep, + src, + srcSize, + 7, + 0 + ); + } + + private static nuint ZSTD_compressBlock_fast_dictMatchState( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + uint mls = ms->cParams.minMatch; + assert(ms->dictMatchState != null); + switch (mls) + { + default: + case 4: + return ZSTD_compressBlock_fast_dictMatchState_4_0(ms, seqStore, rep, src, srcSize); + case 5: + return ZSTD_compressBlock_fast_dictMatchState_5_0(ms, seqStore, rep, src, srcSize); + case 6: + return ZSTD_compressBlock_fast_dictMatchState_6_0(ms, seqStore, rep, src, srcSize); + case 7: + return ZSTD_compressBlock_fast_dictMatchState_7_0(ms, seqStore, rep, src, srcSize); + } + } + + private static nuint ZSTD_compressBlock_fast_extDict_generic( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize, + uint mls, + uint hasStep + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* hashTable = ms->hashTable; + uint hlog = cParams->hashLog; + /* support stepSize of 0 */ + nuint stepSize = cParams->targetLength + (uint)(cParams->targetLength == 0 ? 1 : 0) + 1; + byte* @base = ms->window.@base; + byte* dictBase = ms->window.dictBase; + byte* istart = (byte*)src; + byte* anchor = istart; + uint endIndex = (uint)((nuint)(istart - @base) + srcSize); + uint lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog); + uint dictStartIndex = lowLimit; + byte* dictStart = dictBase + dictStartIndex; + uint dictLimit = ms->window.dictLimit; + uint prefixStartIndex = dictLimit < lowLimit ? lowLimit : dictLimit; + byte* prefixStart = @base + prefixStartIndex; + byte* dictEnd = dictBase + prefixStartIndex; + byte* iend = istart + srcSize; + byte* ilimit = iend - 8; + uint offset_1 = rep[0], + offset_2 = rep[1]; + uint offsetSaved1 = 0, + offsetSaved2 = 0; + byte* ip0 = istart; + byte* ip1; + byte* ip2; + byte* ip3; + uint current0; + /* hash for ip0 */ + nuint hash0; + /* hash for ip1 */ + nuint hash1; + /* match idx for ip0 */ + uint idx; + /* base pointer for idx */ + byte* idxBase; + uint offcode; + byte* match0; + nuint mLength; + /* initialize to avoid warning, assert != 0 later */ + byte* matchEnd = null; + nuint step; + byte* nextStep; + const nuint kStepIncr = 1 << 8 - 1; + if (prefixStartIndex == dictStartIndex) + return ZSTD_compressBlock_fast(ms, seqStore, rep, src, srcSize); + { + uint curr = (uint)(ip0 - @base); + uint maxRep = curr - dictStartIndex; + if (offset_2 >= maxRep) + { + offsetSaved2 = offset_2; + offset_2 = 0; + } + + if (offset_1 >= maxRep) + { + offsetSaved1 = offset_1; + offset_1 = 0; + } + } + + _start: + step = stepSize; + nextStep = ip0 + kStepIncr; + ip1 = ip0 + 1; + ip2 = ip0 + step; + ip3 = ip2 + 1; + if (ip3 >= ilimit) + { + goto _cleanup; + } + + hash0 = ZSTD_hashPtr(ip0, hlog, mls); + hash1 = ZSTD_hashPtr(ip1, hlog, mls); + idx = hashTable[hash0]; + idxBase = idx < prefixStartIndex ? dictBase : @base; + do + { + { + uint current2 = (uint)(ip2 - @base); + uint repIndex = current2 - offset_1; + byte* repBase = repIndex < prefixStartIndex ? dictBase : @base; + uint rval; + if (prefixStartIndex - repIndex >= 4 && offset_1 > 0) + { + rval = MEM_read32(repBase + repIndex); + } + else + { + rval = MEM_read32(ip2) ^ 1; + } + + current0 = (uint)(ip0 - @base); + hashTable[hash0] = current0; + if (MEM_read32(ip2) == rval) + { + ip0 = ip2; + match0 = repBase + repIndex; + matchEnd = repIndex < prefixStartIndex ? dictEnd : iend; + assert(match0 != prefixStart && match0 != dictStart); + mLength = ip0[-1] == match0[-1] ? 1U : 0U; + ip0 -= mLength; + match0 -= mLength; + assert(1 >= 1); + assert(1 <= 3); + offcode = 1; + mLength += 4; + goto _match; + } + } + + { + uint mval = idx >= dictStartIndex ? MEM_read32(idxBase + idx) : MEM_read32(ip0) ^ 1; + if (MEM_read32(ip0) == mval) + { + goto _offset; + } + } + + idx = hashTable[hash1]; + idxBase = idx < prefixStartIndex ? dictBase : @base; + hash0 = hash1; + hash1 = ZSTD_hashPtr(ip2, hlog, mls); + ip0 = ip1; + ip1 = ip2; + ip2 = ip3; + current0 = (uint)(ip0 - @base); + hashTable[hash0] = current0; + { + uint mval = idx >= dictStartIndex ? MEM_read32(idxBase + idx) : MEM_read32(ip0) ^ 1; + if (MEM_read32(ip0) == mval) + { + goto _offset; + } + } + + idx = hashTable[hash1]; + idxBase = idx < prefixStartIndex ? dictBase : @base; + hash0 = hash1; + hash1 = ZSTD_hashPtr(ip2, hlog, mls); + ip0 = ip1; + ip1 = ip2; + ip2 = ip0 + step; + ip3 = ip1 + step; + if (ip2 >= nextStep) + { + step++; +#if NETCOREAPP3_0_OR_GREATER + if (System.Runtime.Intrinsics.X86.Sse.IsSupported) + { + System.Runtime.Intrinsics.X86.Sse.Prefetch0(ip1 + 64); + System.Runtime.Intrinsics.X86.Sse.Prefetch0(ip1 + 128); + } +#endif + + nextStep += kStepIncr; + } + } while (ip3 < ilimit); + _cleanup: + offsetSaved2 = offsetSaved1 != 0 && offset_1 != 0 ? offsetSaved1 : offsetSaved2; + rep[0] = offset_1 != 0 ? offset_1 : offsetSaved1; + rep[1] = offset_2 != 0 ? offset_2 : offsetSaved2; + return (nuint)(iend - anchor); + _offset: + { + uint offset = current0 - idx; + byte* lowMatchPtr = idx < prefixStartIndex ? dictStart : prefixStart; + matchEnd = idx < prefixStartIndex ? dictEnd : iend; + match0 = idxBase + idx; + offset_2 = offset_1; + offset_1 = offset; + assert(offset > 0); + offcode = offset + 3; + mLength = 4; + while (ip0 > anchor && match0 > lowMatchPtr && ip0[-1] == match0[-1]) + { + ip0--; + match0--; + mLength++; + } + } + + _match: + assert(matchEnd != null); + mLength += ZSTD_count_2segments( + ip0 + mLength, + match0 + mLength, + iend, + matchEnd, + prefixStart + ); + ZSTD_storeSeq(seqStore, (nuint)(ip0 - anchor), anchor, iend, offcode, mLength); + ip0 += mLength; + anchor = ip0; + if (ip1 < ip0) + { + hashTable[hash1] = (uint)(ip1 - @base); + } + + if (ip0 <= ilimit) + { + assert(@base + current0 + 2 > istart); + hashTable[ZSTD_hashPtr(@base + current0 + 2, hlog, mls)] = current0 + 2; + hashTable[ZSTD_hashPtr(ip0 - 2, hlog, mls)] = (uint)(ip0 - 2 - @base); + while (ip0 <= ilimit) + { + uint repIndex2 = (uint)(ip0 - @base) - offset_2; + byte* repMatch2 = + repIndex2 < prefixStartIndex ? dictBase + repIndex2 : @base + repIndex2; + if ( + (ZSTD_index_overlap_check(prefixStartIndex, repIndex2) & (offset_2 > 0 ? 1 : 0)) + != 0 + && MEM_read32(repMatch2) == MEM_read32(ip0) + ) + { + byte* repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend; + nuint repLength2 = + ZSTD_count_2segments(ip0 + 4, repMatch2 + 4, iend, repEnd2, prefixStart) + + 4; + { + /* swap offset_2 <=> offset_1 */ + uint tmpOffset = offset_2; + offset_2 = offset_1; + offset_1 = tmpOffset; + } + + assert(1 >= 1); + assert(1 <= 3); + ZSTD_storeSeq(seqStore, 0, anchor, iend, 1, repLength2); + hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = (uint)(ip0 - @base); + ip0 += repLength2; + anchor = ip0; + continue; + } + + break; + } + } + + goto _start; + } + + private static nuint ZSTD_compressBlock_fast_extDict_4_0( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 4, 0); + } + + private static nuint ZSTD_compressBlock_fast_extDict_5_0( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 5, 0); + } + + private static nuint ZSTD_compressBlock_fast_extDict_6_0( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 6, 0); + } + + private static nuint ZSTD_compressBlock_fast_extDict_7_0( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 7, 0); + } + + private static nuint ZSTD_compressBlock_fast_extDict( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + uint mls = ms->cParams.minMatch; + assert(ms->dictMatchState == null); + switch (mls) + { + default: + case 4: + return ZSTD_compressBlock_fast_extDict_4_0(ms, seqStore, rep, src, srcSize); + case 5: + return ZSTD_compressBlock_fast_extDict_5_0(ms, seqStore, rep, src, srcSize); + case 6: + return ZSTD_compressBlock_fast_extDict_6_0(ms, seqStore, rep, src, srcSize); + case 7: + return ZSTD_compressBlock_fast_extDict_7_0(ms, seqStore, rep, src, srcSize); + } + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdInternal.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdInternal.cs new file mode 100644 index 000000000..bea3765fa --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdInternal.cs @@ -0,0 +1,638 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; +#if NETCOREAPP3_0_OR_GREATER +using System.Runtime.Intrinsics.X86; +#endif +#if NET5_0_OR_GREATER +using System.Runtime.Intrinsics.Arm; +#endif + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_repStartValue => new uint[3] { 1, 4, 8 }; + private static uint* repStartValue => + (uint*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_repStartValue) + ); +#else + + private static readonly uint* repStartValue = GetArrayPointer(new uint[3] { 1, 4, 8 }); +#endif + private static readonly nuint* ZSTD_fcs_fieldSize = GetArrayPointer( + new nuint[4] { 0, 2, 4, 8 } + ); + private static readonly nuint* ZSTD_did_fieldSize = GetArrayPointer( + new nuint[4] { 0, 1, 2, 4 } + ); + private const uint ZSTD_blockHeaderSize = 3; +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_LL_bits => + new byte[36] + { + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + }; + private static byte* LL_bits => + (byte*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_LL_bits) + ); +#else + + private static readonly byte* LL_bits = GetArrayPointer( + new byte[36] + { + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + } + ); +#endif +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_LL_defaultNorm => + new short[36] + { + 4, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 3, + 2, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + }; + private static short* LL_defaultNorm => + (short*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_LL_defaultNorm) + ); +#else + + private static readonly short* LL_defaultNorm = GetArrayPointer( + new short[36] + { + 4, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 3, + 2, + 1, + 1, + 1, + 1, + 1, + (short)(-1), + (short)(-1), + (short)(-1), + (short)(-1), + } + ); +#endif + private const uint LL_defaultNormLog = 6; +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_ML_bits => + new byte[53] + { + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + }; + private static byte* ML_bits => + (byte*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_ML_bits) + ); +#else + + private static readonly byte* ML_bits = GetArrayPointer( + new byte[53] + { + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + } + ); +#endif +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_ML_defaultNorm => + new short[53] + { + 1, + 4, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + }; + private static short* ML_defaultNorm => + (short*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_ML_defaultNorm) + ); +#else + + private static readonly short* ML_defaultNorm = GetArrayPointer( + new short[53] + { + 1, + 4, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + (short)(-1), + (short)(-1), + (short)(-1), + (short)(-1), + (short)(-1), + (short)(-1), + (short)(-1), + } + ); +#endif + private const uint ML_defaultNormLog = 6; +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_OF_defaultNorm => + new short[29] + { + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + }; + private static short* OF_defaultNorm => + (short*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_OF_defaultNorm) + ); +#else + + private static readonly short* OF_defaultNorm = GetArrayPointer( + new short[29] + { + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + (short)(-1), + (short)(-1), + (short)(-1), + (short)(-1), + (short)(-1), + } + ); +#endif + private const uint OF_defaultNormLog = 5; + + /*-******************************************* + * Shared functions to include for inlining + *********************************************/ + private static void ZSTD_copy8(void* dst, void* src) + { + memcpy(dst, src, 8); + } + + /* Need to use memmove here since the literal buffer can now be located within + the dst buffer. In circumstances where the op "catches up" to where the + literal buffer is, there can be partial overlaps in this call on the final + copy if the literal is being shifted by less than 16 bytes. */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_copy16(void* dst, void* src) + { +#if NET5_0_OR_GREATER + if (AdvSimd.IsSupported) + { + AdvSimd.Store((byte*)dst, AdvSimd.LoadVector128((byte*)src)); + } + else +#endif +#if NETCOREAPP3_0_OR_GREATER + if (Sse2.IsSupported) + { + Sse2.Store((byte*)dst, Sse2.LoadVector128((byte*)src)); + } + else +#endif + { + var v1 = System.Runtime.CompilerServices.Unsafe.ReadUnaligned((ulong*)src); + var v2 = System.Runtime.CompilerServices.Unsafe.ReadUnaligned((ulong*)src + 1); + System.Runtime.CompilerServices.Unsafe.WriteUnaligned((ulong*)dst, v1); + System.Runtime.CompilerServices.Unsafe.WriteUnaligned((ulong*)dst + 1, v2); + } + } + + /*! ZSTD_wildcopy() : + * Custom version of ZSTD_memcpy(), can over read/write up to WILDCOPY_OVERLENGTH bytes (if length==0) + * @param ovtype controls the overlap detection + * - ZSTD_no_overlap: The source and destination are guaranteed to be at least WILDCOPY_VECLEN bytes apart. + * - ZSTD_overlap_src_before_dst: The src and dst may overlap, but they MUST be at least 8 bytes apart. + * The src buffer must be before the dst buffer. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_wildcopy(void* dst, void* src, nint length, ZSTD_overlap_e ovtype) + { + nint diff = (nint)((byte*)dst - (byte*)src); + byte* ip = (byte*)src; + byte* op = (byte*)dst; + byte* oend = op + length; + if (ovtype == ZSTD_overlap_e.ZSTD_overlap_src_before_dst && diff < 16) + { + do + { + ZSTD_copy8(op, ip); + op += 8; + ip += 8; + } while (op < oend); + } + else + { + assert(diff >= 16 || diff <= -16); + ZSTD_copy16(op, ip); + if (16 >= length) + return; + op += 16; + ip += 16; + do + { + { + ZSTD_copy16(op, ip); + op += 16; + ip += 16; + } + + { + ZSTD_copy16(op, ip); + op += 16; + ip += 16; + } + } while (op < oend); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_limitCopy(void* dst, nuint dstCapacity, void* src, nuint srcSize) + { + nuint length = dstCapacity < srcSize ? dstCapacity : srcSize; + if (length > 0) + { + memcpy(dst, src, (uint)length); + } + + return length; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdLazy.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdLazy.cs new file mode 100644 index 000000000..2256ffbfe --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdLazy.cs @@ -0,0 +1,4661 @@ +using System; +using System.Numerics; +using System.Runtime.CompilerServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; +#if NETCOREAPP3_0_OR_GREATER +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; +#endif +#if NET5_0_OR_GREATER +using System.Runtime.Intrinsics.Arm; +#endif + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /*-************************************* + * Binary Tree search + ***************************************/ + private static void ZSTD_updateDUBT(ZSTD_MatchState_t* ms, byte* ip, byte* iend, uint mls) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* hashTable = ms->hashTable; + uint hashLog = cParams->hashLog; + uint* bt = ms->chainTable; + uint btLog = cParams->chainLog - 1; + uint btMask = (uint)((1 << (int)btLog) - 1); + byte* @base = ms->window.@base; + uint target = (uint)(ip - @base); + uint idx = ms->nextToUpdate; + assert(ip + 8 <= iend); + assert(idx >= ms->window.dictLimit); + for (; idx < target; idx++) + { + /* assumption : ip + 8 <= iend */ + nuint h = ZSTD_hashPtr(@base + idx, hashLog, mls); + uint matchIndex = hashTable[h]; + uint* nextCandidatePtr = bt + 2 * (idx & btMask); + uint* sortMarkPtr = nextCandidatePtr + 1; + hashTable[h] = idx; + *nextCandidatePtr = matchIndex; + *sortMarkPtr = 1; + } + + ms->nextToUpdate = target; + } + + /** ZSTD_insertDUBT1() : + * sort one already inserted but unsorted position + * assumption : curr >= btlow == (curr - btmask) + * doesn't fail */ + private static void ZSTD_insertDUBT1( + ZSTD_MatchState_t* ms, + uint curr, + byte* inputEnd, + uint nbCompares, + uint btLow, + ZSTD_dictMode_e dictMode + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* bt = ms->chainTable; + uint btLog = cParams->chainLog - 1; + uint btMask = (uint)((1 << (int)btLog) - 1); + nuint commonLengthSmaller = 0, + commonLengthLarger = 0; + byte* @base = ms->window.@base; + byte* dictBase = ms->window.dictBase; + uint dictLimit = ms->window.dictLimit; + byte* ip = curr >= dictLimit ? @base + curr : dictBase + curr; + byte* iend = curr >= dictLimit ? inputEnd : dictBase + dictLimit; + byte* dictEnd = dictBase + dictLimit; + byte* prefixStart = @base + dictLimit; + byte* match; + uint* smallerPtr = bt + 2 * (curr & btMask); + uint* largerPtr = smallerPtr + 1; + /* this candidate is unsorted : next sorted candidate is reached through *smallerPtr, while *largerPtr contains previous unsorted candidate (which is already saved and can be overwritten) */ + uint matchIndex = *smallerPtr; + /* to be nullified at the end */ + uint dummy32; + uint windowValid = ms->window.lowLimit; + uint maxDistance = 1U << (int)cParams->windowLog; + uint windowLow = curr - windowValid > maxDistance ? curr - maxDistance : windowValid; + assert(curr >= btLow); + assert(ip < iend); + for (; nbCompares != 0 && matchIndex > windowLow; --nbCompares) + { + uint* nextPtr = bt + 2 * (matchIndex & btMask); + /* guaranteed minimum nb of common bytes */ + nuint matchLength = + commonLengthSmaller < commonLengthLarger ? commonLengthSmaller : commonLengthLarger; + assert(matchIndex < curr); + if ( + dictMode != ZSTD_dictMode_e.ZSTD_extDict + || matchIndex + matchLength >= dictLimit + || curr < dictLimit + ) + { + byte* mBase = + dictMode != ZSTD_dictMode_e.ZSTD_extDict + || matchIndex + matchLength >= dictLimit + ? @base + : dictBase; + assert(matchIndex + matchLength >= dictLimit || curr < dictLimit); + match = mBase + matchIndex; + matchLength += ZSTD_count(ip + matchLength, match + matchLength, iend); + } + else + { + match = dictBase + matchIndex; + matchLength += ZSTD_count_2segments( + ip + matchLength, + match + matchLength, + iend, + dictEnd, + prefixStart + ); + if (matchIndex + matchLength >= dictLimit) + match = @base + matchIndex; + } + + if (ip + matchLength == iend) + { + break; + } + + if (match[matchLength] < ip[matchLength]) + { + *smallerPtr = matchIndex; + commonLengthSmaller = matchLength; + if (matchIndex <= btLow) + { + smallerPtr = &dummy32; + break; + } + + smallerPtr = nextPtr + 1; + matchIndex = nextPtr[1]; + } + else + { + *largerPtr = matchIndex; + commonLengthLarger = matchLength; + if (matchIndex <= btLow) + { + largerPtr = &dummy32; + break; + } + + largerPtr = nextPtr; + matchIndex = nextPtr[0]; + } + } + + *smallerPtr = *largerPtr = 0; + } + + private static nuint ZSTD_DUBT_findBetterDictMatch( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iend, + nuint* offsetPtr, + nuint bestLength, + uint nbCompares, + uint mls, + ZSTD_dictMode_e dictMode + ) + { + ZSTD_MatchState_t* dms = ms->dictMatchState; + ZSTD_compressionParameters* dmsCParams = &dms->cParams; + uint* dictHashTable = dms->hashTable; + uint hashLog = dmsCParams->hashLog; + nuint h = ZSTD_hashPtr(ip, hashLog, mls); + uint dictMatchIndex = dictHashTable[h]; + byte* @base = ms->window.@base; + byte* prefixStart = @base + ms->window.dictLimit; + uint curr = (uint)(ip - @base); + byte* dictBase = dms->window.@base; + byte* dictEnd = dms->window.nextSrc; + uint dictHighLimit = (uint)(dms->window.nextSrc - dms->window.@base); + uint dictLowLimit = dms->window.lowLimit; + uint dictIndexDelta = ms->window.lowLimit - dictHighLimit; + uint* dictBt = dms->chainTable; + uint btLog = dmsCParams->chainLog - 1; + uint btMask = (uint)((1 << (int)btLog) - 1); + uint btLow = btMask >= dictHighLimit - dictLowLimit ? dictLowLimit : dictHighLimit - btMask; + nuint commonLengthSmaller = 0, + commonLengthLarger = 0; + assert(dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState); + for (; nbCompares != 0 && dictMatchIndex > dictLowLimit; --nbCompares) + { + uint* nextPtr = dictBt + 2 * (dictMatchIndex & btMask); + /* guaranteed minimum nb of common bytes */ + nuint matchLength = + commonLengthSmaller < commonLengthLarger ? commonLengthSmaller : commonLengthLarger; + byte* match = dictBase + dictMatchIndex; + matchLength += ZSTD_count_2segments( + ip + matchLength, + match + matchLength, + iend, + dictEnd, + prefixStart + ); + if (dictMatchIndex + matchLength >= dictHighLimit) + match = @base + dictMatchIndex + dictIndexDelta; + if (matchLength > bestLength) + { + uint matchIndex = dictMatchIndex + dictIndexDelta; + if ( + 4 * (int)(matchLength - bestLength) + > (int)( + ZSTD_highbit32(curr - matchIndex + 1) + - ZSTD_highbit32((uint)offsetPtr[0] + 1) + ) + ) + { + bestLength = matchLength; + assert(curr - matchIndex > 0); + *offsetPtr = curr - matchIndex + 3; + } + + if (ip + matchLength == iend) + { + break; + } + } + + if (match[matchLength] < ip[matchLength]) + { + if (dictMatchIndex <= btLow) + { + break; + } + + commonLengthSmaller = matchLength; + dictMatchIndex = nextPtr[1]; + } + else + { + if (dictMatchIndex <= btLow) + { + break; + } + + commonLengthLarger = matchLength; + dictMatchIndex = nextPtr[0]; + } + } + + if (bestLength >= 3) + { + assert(*offsetPtr > 3); + uint mIndex = curr - (uint)(*offsetPtr - 3); + } + + return bestLength; + } + + private static nuint ZSTD_DUBT_findBestMatch( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iend, + nuint* offBasePtr, + uint mls, + ZSTD_dictMode_e dictMode + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* hashTable = ms->hashTable; + uint hashLog = cParams->hashLog; + nuint h = ZSTD_hashPtr(ip, hashLog, mls); + uint matchIndex = hashTable[h]; + byte* @base = ms->window.@base; + uint curr = (uint)(ip - @base); + uint windowLow = ZSTD_getLowestMatchIndex(ms, curr, cParams->windowLog); + uint* bt = ms->chainTable; + uint btLog = cParams->chainLog - 1; + uint btMask = (uint)((1 << (int)btLog) - 1); + uint btLow = btMask >= curr ? 0 : curr - btMask; + uint unsortLimit = btLow > windowLow ? btLow : windowLow; + uint* nextCandidate = bt + 2 * (matchIndex & btMask); + uint* unsortedMark = bt + 2 * (matchIndex & btMask) + 1; + uint nbCompares = 1U << (int)cParams->searchLog; + uint nbCandidates = nbCompares; + uint previousCandidate = 0; + assert(ip <= iend - 8); + assert(dictMode != ZSTD_dictMode_e.ZSTD_dedicatedDictSearch); + while (matchIndex > unsortLimit && *unsortedMark == 1 && nbCandidates > 1) + { + *unsortedMark = previousCandidate; + previousCandidate = matchIndex; + matchIndex = *nextCandidate; + nextCandidate = bt + 2 * (matchIndex & btMask); + unsortedMark = bt + 2 * (matchIndex & btMask) + 1; + nbCandidates--; + } + + if (matchIndex > unsortLimit && *unsortedMark == 1) + { + *nextCandidate = *unsortedMark = 0; + } + + matchIndex = previousCandidate; + while (matchIndex != 0) + { + uint* nextCandidateIdxPtr = bt + 2 * (matchIndex & btMask) + 1; + uint nextCandidateIdx = *nextCandidateIdxPtr; + ZSTD_insertDUBT1(ms, matchIndex, iend, nbCandidates, unsortLimit, dictMode); + matchIndex = nextCandidateIdx; + nbCandidates++; + } + + { + nuint commonLengthSmaller = 0, + commonLengthLarger = 0; + byte* dictBase = ms->window.dictBase; + uint dictLimit = ms->window.dictLimit; + byte* dictEnd = dictBase + dictLimit; + byte* prefixStart = @base + dictLimit; + uint* smallerPtr = bt + 2 * (curr & btMask); + uint* largerPtr = bt + 2 * (curr & btMask) + 1; + uint matchEndIdx = curr + 8 + 1; + /* to be nullified at the end */ + uint dummy32; + nuint bestLength = 0; + matchIndex = hashTable[h]; + hashTable[h] = curr; + for (; nbCompares != 0 && matchIndex > windowLow; --nbCompares) + { + uint* nextPtr = bt + 2 * (matchIndex & btMask); + /* guaranteed minimum nb of common bytes */ + nuint matchLength = + commonLengthSmaller < commonLengthLarger + ? commonLengthSmaller + : commonLengthLarger; + byte* match; + if ( + dictMode != ZSTD_dictMode_e.ZSTD_extDict + || matchIndex + matchLength >= dictLimit + ) + { + match = @base + matchIndex; + matchLength += ZSTD_count(ip + matchLength, match + matchLength, iend); + } + else + { + match = dictBase + matchIndex; + matchLength += ZSTD_count_2segments( + ip + matchLength, + match + matchLength, + iend, + dictEnd, + prefixStart + ); + if (matchIndex + matchLength >= dictLimit) + match = @base + matchIndex; + } + + if (matchLength > bestLength) + { + if (matchLength > matchEndIdx - matchIndex) + matchEndIdx = matchIndex + (uint)matchLength; + if ( + 4 * (int)(matchLength - bestLength) + > (int)( + ZSTD_highbit32(curr - matchIndex + 1) + - ZSTD_highbit32((uint)*offBasePtr) + ) + ) + { + bestLength = matchLength; + assert(curr - matchIndex > 0); + *offBasePtr = curr - matchIndex + 3; + } + + if (ip + matchLength == iend) + { + if (dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState) + { + nbCompares = 0; + } + + break; + } + } + + if (match[matchLength] < ip[matchLength]) + { + *smallerPtr = matchIndex; + commonLengthSmaller = matchLength; + if (matchIndex <= btLow) + { + smallerPtr = &dummy32; + break; + } + + smallerPtr = nextPtr + 1; + matchIndex = nextPtr[1]; + } + else + { + *largerPtr = matchIndex; + commonLengthLarger = matchLength; + if (matchIndex <= btLow) + { + largerPtr = &dummy32; + break; + } + + largerPtr = nextPtr; + matchIndex = nextPtr[0]; + } + } + + *smallerPtr = *largerPtr = 0; + assert(nbCompares <= 1U << (sizeof(nuint) == 4 ? 30 : 31) - 1); + if (dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState && nbCompares != 0) + { + bestLength = ZSTD_DUBT_findBetterDictMatch( + ms, + ip, + iend, + offBasePtr, + bestLength, + nbCompares, + mls, + dictMode + ); + } + + assert(matchEndIdx > curr + 8); + ms->nextToUpdate = matchEndIdx - 8; + if (bestLength >= 3) + { + assert(*offBasePtr > 3); + uint mIndex = curr - (uint)(*offBasePtr - 3); + } + + return bestLength; + } + } + + /** ZSTD_BtFindBestMatch() : Tree updater, providing best match */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_BtFindBestMatch( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offBasePtr, + uint mls, + ZSTD_dictMode_e dictMode + ) + { + if (ip < ms->window.@base + ms->nextToUpdate) + return 0; + ZSTD_updateDUBT(ms, ip, iLimit, mls); + return ZSTD_DUBT_findBestMatch(ms, ip, iLimit, offBasePtr, mls, dictMode); + } + + /*********************************** + * Dedicated dict search + ***********************************/ + private static void ZSTD_dedicatedDictSearch_lazy_loadDictionary( + ZSTD_MatchState_t* ms, + byte* ip + ) + { + byte* @base = ms->window.@base; + uint target = (uint)(ip - @base); + uint* hashTable = ms->hashTable; + uint* chainTable = ms->chainTable; + uint chainSize = (uint)(1 << (int)ms->cParams.chainLog); + uint idx = ms->nextToUpdate; + uint minChain = chainSize < target - idx ? target - chainSize : idx; + const uint bucketSize = 1 << 2; + uint cacheSize = bucketSize - 1; + uint chainAttempts = (uint)(1 << (int)ms->cParams.searchLog) - cacheSize; + uint chainLimit = chainAttempts > 255 ? 255 : chainAttempts; + /* We know the hashtable is oversized by a factor of `bucketSize`. + * We are going to temporarily pretend `bucketSize == 1`, keeping only a + * single entry. We will use the rest of the space to construct a temporary + * chaintable. + */ + uint hashLog = ms->cParams.hashLog - 2; + uint* tmpHashTable = hashTable; + uint* tmpChainTable = hashTable + ((nuint)1 << (int)hashLog); + uint tmpChainSize = (uint)((1 << 2) - 1) << (int)hashLog; + uint tmpMinChain = tmpChainSize < target ? target - tmpChainSize : idx; + uint hashIdx; + assert(ms->cParams.chainLog <= 24); + assert(ms->cParams.hashLog > ms->cParams.chainLog); + assert(idx != 0); + assert(tmpMinChain <= minChain); + for (; idx < target; idx++) + { + uint h = (uint)ZSTD_hashPtr(@base + idx, hashLog, ms->cParams.minMatch); + if (idx >= tmpMinChain) + { + tmpChainTable[idx - tmpMinChain] = hashTable[h]; + } + + tmpHashTable[h] = idx; + } + + { + uint chainPos = 0; + for (hashIdx = 0; hashIdx < 1U << (int)hashLog; hashIdx++) + { + uint count; + uint countBeyondMinChain = 0; + uint i = tmpHashTable[hashIdx]; + for (count = 0; i >= tmpMinChain && count < cacheSize; count++) + { + if (i < minChain) + { + countBeyondMinChain++; + } + + i = tmpChainTable[i - tmpMinChain]; + } + + if (count == cacheSize) + { + for (count = 0; count < chainLimit; ) + { + if (i < minChain) + { + if (i == 0 || ++countBeyondMinChain > cacheSize) + { + break; + } + } + + chainTable[chainPos++] = i; + count++; + if (i < tmpMinChain) + { + break; + } + + i = tmpChainTable[i - tmpMinChain]; + } + } + else + { + count = 0; + } + + if (count != 0) + { + tmpHashTable[hashIdx] = (chainPos - count << 8) + count; + } + else + { + tmpHashTable[hashIdx] = 0; + } + } + + assert(chainPos <= chainSize); + } + + for (hashIdx = (uint)(1 << (int)hashLog); hashIdx != 0; ) + { + uint bucketIdx = --hashIdx << 2; + uint chainPackedPointer = tmpHashTable[hashIdx]; + uint i; + for (i = 0; i < cacheSize; i++) + { + hashTable[bucketIdx + i] = 0; + } + + hashTable[bucketIdx + bucketSize - 1] = chainPackedPointer; + } + + for (idx = ms->nextToUpdate; idx < target; idx++) + { + uint h = (uint)ZSTD_hashPtr(@base + idx, hashLog, ms->cParams.minMatch) << 2; + uint i; + for (i = cacheSize - 1; i != 0; i--) + hashTable[h + i] = hashTable[h + i - 1]; + hashTable[h] = idx; + } + + ms->nextToUpdate = target; + } + + /* Returns the longest match length found in the dedicated dict search structure. + * If none are longer than the argument ml, then ml will be returned. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_dedicatedDictSearch_lazy_search( + nuint* offsetPtr, + nuint ml, + uint nbAttempts, + ZSTD_MatchState_t* dms, + byte* ip, + byte* iLimit, + byte* prefixStart, + uint curr, + uint dictLimit, + nuint ddsIdx + ) + { + uint ddsLowestIndex = dms->window.dictLimit; + byte* ddsBase = dms->window.@base; + byte* ddsEnd = dms->window.nextSrc; + uint ddsSize = (uint)(ddsEnd - ddsBase); + uint ddsIndexDelta = dictLimit - ddsSize; + const uint bucketSize = 1 << 2; + uint bucketLimit = nbAttempts < bucketSize - 1 ? nbAttempts : bucketSize - 1; + uint ddsAttempt; + uint matchIndex; + for (ddsAttempt = 0; ddsAttempt < bucketSize - 1; ddsAttempt++) + { +#if NETCOREAPP3_0_OR_GREATER + if (Sse.IsSupported) + { + Sse.Prefetch0(ddsBase + dms->hashTable[ddsIdx + ddsAttempt]); + } +#endif + } + + { + uint chainPackedPointer = dms->hashTable[ddsIdx + bucketSize - 1]; + uint chainIndex = chainPackedPointer >> 8; +#if NETCOREAPP3_0_OR_GREATER + if (Sse.IsSupported) + { + Sse.Prefetch0(&dms->chainTable[chainIndex]); + } +#endif + } + + for (ddsAttempt = 0; ddsAttempt < bucketLimit; ddsAttempt++) + { + nuint currentMl = 0; + byte* match; + matchIndex = dms->hashTable[ddsIdx + ddsAttempt]; + match = ddsBase + matchIndex; + if (matchIndex == 0) + { + return ml; + } + + assert(matchIndex >= ddsLowestIndex); + assert(match + 4 <= ddsEnd); + if (MEM_read32(match) == MEM_read32(ip)) + { + currentMl = + ZSTD_count_2segments(ip + 4, match + 4, iLimit, ddsEnd, prefixStart) + 4; + } + + if (currentMl > ml) + { + ml = currentMl; + assert(curr - (matchIndex + ddsIndexDelta) > 0); + *offsetPtr = curr - (matchIndex + ddsIndexDelta) + 3; + if (ip + currentMl == iLimit) + { + return ml; + } + } + } + + { + uint chainPackedPointer = dms->hashTable[ddsIdx + bucketSize - 1]; + uint chainIndex = chainPackedPointer >> 8; + uint chainLength = chainPackedPointer & 0xFF; + uint chainAttempts = nbAttempts - ddsAttempt; + uint chainLimit = chainAttempts > chainLength ? chainLength : chainAttempts; + uint chainAttempt; + for (chainAttempt = 0; chainAttempt < chainLimit; chainAttempt++) + { +#if NETCOREAPP3_0_OR_GREATER + if (Sse.IsSupported) + { + Sse.Prefetch0(ddsBase + dms->chainTable[chainIndex + chainAttempt]); + } +#endif + } + + for (chainAttempt = 0; chainAttempt < chainLimit; chainAttempt++, chainIndex++) + { + nuint currentMl = 0; + byte* match; + matchIndex = dms->chainTable[chainIndex]; + match = ddsBase + matchIndex; + assert(matchIndex >= ddsLowestIndex); + assert(match + 4 <= ddsEnd); + if (MEM_read32(match) == MEM_read32(ip)) + { + currentMl = + ZSTD_count_2segments(ip + 4, match + 4, iLimit, ddsEnd, prefixStart) + 4; + } + + if (currentMl > ml) + { + ml = currentMl; + assert(curr - (matchIndex + ddsIndexDelta) > 0); + *offsetPtr = curr - (matchIndex + ddsIndexDelta) + 3; + if (ip + currentMl == iLimit) + break; + } + } + } + + return ml; + } + + /* Update chains up to ip (excluded) + Assumption : always within prefix (i.e. not within extDict) */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_insertAndFindFirstIndex_internal( + ZSTD_MatchState_t* ms, + ZSTD_compressionParameters* cParams, + byte* ip, + uint mls, + uint lazySkipping + ) + { + uint* hashTable = ms->hashTable; + uint hashLog = cParams->hashLog; + uint* chainTable = ms->chainTable; + uint chainMask = (uint)((1 << (int)cParams->chainLog) - 1); + byte* @base = ms->window.@base; + uint target = (uint)(ip - @base); + uint idx = ms->nextToUpdate; + while (idx < target) + { + nuint h = ZSTD_hashPtr(@base + idx, hashLog, mls); + chainTable[idx & chainMask] = hashTable[h]; + hashTable[h] = idx; + idx++; + if (lazySkipping != 0) + break; + } + + ms->nextToUpdate = target; + return hashTable[ZSTD_hashPtr(ip, hashLog, mls)]; + } + + private static uint ZSTD_insertAndFindFirstIndex(ZSTD_MatchState_t* ms, byte* ip) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + return ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, ms->cParams.minMatch, 0); + } + + /* inlining is important to hardwire a hot branch (template emulation) */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_HcFindBestMatch( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr, + uint mls, + ZSTD_dictMode_e dictMode + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* chainTable = ms->chainTable; + uint chainSize = (uint)(1 << (int)cParams->chainLog); + uint chainMask = chainSize - 1; + byte* @base = ms->window.@base; + byte* dictBase = ms->window.dictBase; + uint dictLimit = ms->window.dictLimit; + byte* prefixStart = @base + dictLimit; + byte* dictEnd = dictBase + dictLimit; + uint curr = (uint)(ip - @base); + uint maxDistance = 1U << (int)cParams->windowLog; + uint lowestValid = ms->window.lowLimit; + uint withinMaxDistance = + curr - lowestValid > maxDistance ? curr - maxDistance : lowestValid; + uint isDictionary = ms->loadedDictEnd != 0 ? 1U : 0U; + uint lowLimit = isDictionary != 0 ? lowestValid : withinMaxDistance; + uint minChain = curr > chainSize ? curr - chainSize : 0; + uint nbAttempts = 1U << (int)cParams->searchLog; + nuint ml = 4 - 1; + ZSTD_MatchState_t* dms = ms->dictMatchState; + uint ddsHashLog = + dictMode == ZSTD_dictMode_e.ZSTD_dedicatedDictSearch ? dms->cParams.hashLog - 2 : 0; + nuint ddsIdx = + dictMode == ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ? ZSTD_hashPtr(ip, ddsHashLog, mls) << 2 + : 0; + uint matchIndex; + if (dictMode == ZSTD_dictMode_e.ZSTD_dedicatedDictSearch) + { + uint* entry = &dms->hashTable[ddsIdx]; +#if NETCOREAPP3_0_OR_GREATER + if (Sse.IsSupported) + { + Sse.Prefetch0(entry); + } +#endif + } + + matchIndex = ZSTD_insertAndFindFirstIndex_internal( + ms, + cParams, + ip, + mls, + (uint)ms->lazySkipping + ); + for (; matchIndex >= lowLimit && nbAttempts > 0; nbAttempts--) + { + nuint currentMl = 0; + if (dictMode != ZSTD_dictMode_e.ZSTD_extDict || matchIndex >= dictLimit) + { + byte* match = @base + matchIndex; + assert(matchIndex >= dictLimit); + if (MEM_read32(match + ml - 3) == MEM_read32(ip + ml - 3)) + currentMl = ZSTD_count(ip, match, iLimit); + } + else + { + byte* match = dictBase + matchIndex; + assert(match + 4 <= dictEnd); + if (MEM_read32(match) == MEM_read32(ip)) + currentMl = + ZSTD_count_2segments(ip + 4, match + 4, iLimit, dictEnd, prefixStart) + 4; + } + + if (currentMl > ml) + { + ml = currentMl; + assert(curr - matchIndex > 0); + *offsetPtr = curr - matchIndex + 3; + if (ip + currentMl == iLimit) + break; + } + + if (matchIndex <= minChain) + break; + matchIndex = chainTable[matchIndex & chainMask]; + } + + assert(nbAttempts <= 1U << (sizeof(nuint) == 4 ? 30 : 31) - 1); + if (dictMode == ZSTD_dictMode_e.ZSTD_dedicatedDictSearch) + { + ml = ZSTD_dedicatedDictSearch_lazy_search( + offsetPtr, + ml, + nbAttempts, + dms, + ip, + iLimit, + prefixStart, + curr, + dictLimit, + ddsIdx + ); + } + else if (dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState) + { + uint* dmsChainTable = dms->chainTable; + uint dmsChainSize = (uint)(1 << (int)dms->cParams.chainLog); + uint dmsChainMask = dmsChainSize - 1; + uint dmsLowestIndex = dms->window.dictLimit; + byte* dmsBase = dms->window.@base; + byte* dmsEnd = dms->window.nextSrc; + uint dmsSize = (uint)(dmsEnd - dmsBase); + uint dmsIndexDelta = dictLimit - dmsSize; + uint dmsMinChain = dmsSize > dmsChainSize ? dmsSize - dmsChainSize : 0; + matchIndex = dms->hashTable[ZSTD_hashPtr(ip, dms->cParams.hashLog, mls)]; + for (; matchIndex >= dmsLowestIndex && nbAttempts > 0; nbAttempts--) + { + nuint currentMl = 0; + byte* match = dmsBase + matchIndex; + assert(match + 4 <= dmsEnd); + if (MEM_read32(match) == MEM_read32(ip)) + currentMl = + ZSTD_count_2segments(ip + 4, match + 4, iLimit, dmsEnd, prefixStart) + 4; + if (currentMl > ml) + { + ml = currentMl; + assert(curr > matchIndex + dmsIndexDelta); + assert(curr - (matchIndex + dmsIndexDelta) > 0); + *offsetPtr = curr - (matchIndex + dmsIndexDelta) + 3; + if (ip + currentMl == iLimit) + break; + } + + if (matchIndex <= dmsMinChain) + break; + matchIndex = dmsChainTable[matchIndex & dmsChainMask]; + } + } + + return ml; + } + + /* ZSTD_VecMask_next(): + * Starting from the LSB, returns the idx of the next non-zero bit. + * Basically counting the nb of trailing zeroes. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_VecMask_next(ulong val) + { + assert(val != 0); + return (uint)BitOperations.TrailingZeroCount(val); + } + + /* ZSTD_row_nextIndex(): + * Returns the next index to insert at within a tagTable row, and updates the "head" + * value to reflect the update. Essentially cycles backwards from [1, {entries per row}) + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_row_nextIndex(byte* tagRow, uint rowMask) + { + uint next = (uint)(*tagRow - 1) & rowMask; + next += next == 0 ? rowMask : 0; + *tagRow = (byte)next; + return next; + } + + /* ZSTD_isAligned(): + * Checks that a pointer is aligned to "align" bytes which must be a power of 2. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int ZSTD_isAligned(void* ptr, nuint align) + { + assert((align & align - 1) == 0); + return ((nuint)ptr & align - 1) == 0 ? 1 : 0; + } + + /* ZSTD_row_prefetch(): + * Performs prefetching for the hashTable and tagTable at a given row. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_row_prefetch(uint* hashTable, byte* tagTable, uint relRow, uint rowLog) + { +#if NETCOREAPP3_0_OR_GREATER + if (Sse.IsSupported) + { + Sse.Prefetch0(hashTable + relRow); + } +#endif + + if (rowLog >= 5) + { +#if NETCOREAPP3_0_OR_GREATER + if (Sse.IsSupported) + { + Sse.Prefetch0(hashTable + relRow + 16); + } +#endif + } + +#if NETCOREAPP3_0_OR_GREATER + if (Sse.IsSupported) + { + Sse.Prefetch0(tagTable + relRow); + } +#endif + + if (rowLog == 6) + { +#if NETCOREAPP3_0_OR_GREATER + if (Sse.IsSupported) + { + Sse.Prefetch0(tagTable + relRow + 32); + } +#endif + } + + assert(rowLog == 4 || rowLog == 5 || rowLog == 6); + assert(ZSTD_isAligned(hashTable + relRow, 64) != 0); + assert(ZSTD_isAligned(tagTable + relRow, (nuint)1 << (int)rowLog) != 0); + } + + /* ZSTD_row_fillHashCache(): + * Fill up the hash cache starting at idx, prefetching up to ZSTD_ROW_HASH_CACHE_SIZE entries, + * but not beyond iLimit. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_row_fillHashCache( + ZSTD_MatchState_t* ms, + byte* @base, + uint rowLog, + uint mls, + uint idx, + byte* iLimit + ) + { + uint* hashTable = ms->hashTable; + byte* tagTable = ms->tagTable; + uint hashLog = ms->rowHashLog; + uint maxElemsToPrefetch = @base + idx > iLimit ? 0 : (uint)(iLimit - (@base + idx) + 1); + uint lim = idx + (8 < maxElemsToPrefetch ? 8 : maxElemsToPrefetch); + for (; idx < lim; ++idx) + { + uint hash = (uint)ZSTD_hashPtrSalted(@base + idx, hashLog + 8, mls, ms->hashSalt); + uint row = hash >> 8 << (int)rowLog; + ZSTD_row_prefetch(hashTable, tagTable, row, rowLog); + ms->hashCache[idx & 8 - 1] = hash; + } + } + + /* ZSTD_row_nextCachedHash(): + * Returns the hash of base + idx, and replaces the hash in the hash cache with the byte at + * base + idx + ZSTD_ROW_HASH_CACHE_SIZE. Also prefetches the appropriate rows from hashTable and tagTable. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_row_nextCachedHash( + uint* cache, + uint* hashTable, + byte* tagTable, + byte* @base, + uint idx, + uint hashLog, + uint rowLog, + uint mls, + ulong hashSalt + ) + { + uint newHash = (uint)ZSTD_hashPtrSalted(@base + idx + 8, hashLog + 8, mls, hashSalt); + uint row = newHash >> 8 << (int)rowLog; + ZSTD_row_prefetch(hashTable, tagTable, row, rowLog); + { + uint hash = cache[idx & 8 - 1]; + cache[idx & 8 - 1] = newHash; + return hash; + } + } + + /* ZSTD_row_update_internalImpl(): + * Updates the hash table with positions starting from updateStartIdx until updateEndIdx. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_row_update_internalImpl( + ZSTD_MatchState_t* ms, + uint updateStartIdx, + uint updateEndIdx, + uint mls, + uint rowLog, + uint rowMask, + uint useCache + ) + { + uint* hashTable = ms->hashTable; + byte* tagTable = ms->tagTable; + uint hashLog = ms->rowHashLog; + byte* @base = ms->window.@base; + for (; updateStartIdx < updateEndIdx; ++updateStartIdx) + { + uint hash = + useCache != 0 + ? ZSTD_row_nextCachedHash( + ms->hashCache, + hashTable, + tagTable, + @base, + updateStartIdx, + hashLog, + rowLog, + mls, + ms->hashSalt + ) + : (uint)ZSTD_hashPtrSalted( + @base + updateStartIdx, + hashLog + 8, + mls, + ms->hashSalt + ); + uint relRow = hash >> 8 << (int)rowLog; + uint* row = hashTable + relRow; + byte* tagRow = tagTable + relRow; + uint pos = ZSTD_row_nextIndex(tagRow, rowMask); + assert( + hash == ZSTD_hashPtrSalted(@base + updateStartIdx, hashLog + 8, mls, ms->hashSalt) + ); + tagRow[pos] = (byte)(hash & (1U << 8) - 1); + row[pos] = updateStartIdx; + } + } + + /* ZSTD_row_update_internal(): + * Inserts the byte at ip into the appropriate position in the hash table, and updates ms->nextToUpdate. + * Skips sections of long matches as is necessary. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_row_update_internal( + ZSTD_MatchState_t* ms, + byte* ip, + uint mls, + uint rowLog, + uint rowMask, + uint useCache + ) + { + uint idx = ms->nextToUpdate; + byte* @base = ms->window.@base; + uint target = (uint)(ip - @base); + const uint kSkipThreshold = 384; + const uint kMaxMatchStartPositionsToUpdate = 96; + const uint kMaxMatchEndPositionsToUpdate = 32; + if (useCache != 0) + { + if (target - idx > kSkipThreshold) + { + uint bound = idx + kMaxMatchStartPositionsToUpdate; + ZSTD_row_update_internalImpl(ms, idx, bound, mls, rowLog, rowMask, useCache); + idx = target - kMaxMatchEndPositionsToUpdate; + ZSTD_row_fillHashCache(ms, @base, rowLog, mls, idx, ip + 1); + } + } + + assert(target >= idx); + ZSTD_row_update_internalImpl(ms, idx, target, mls, rowLog, rowMask, useCache); + ms->nextToUpdate = target; + } + + /* ZSTD_row_update(): + * External wrapper for ZSTD_row_update_internal(). Used for filling the hashtable during dictionary + * processing. + */ + private static void ZSTD_row_update(ZSTD_MatchState_t* ms, byte* ip) + { + uint rowLog = + ms->cParams.searchLog <= 4 ? 4 + : ms->cParams.searchLog <= 6 ? ms->cParams.searchLog + : 6; + uint rowMask = (1U << (int)rowLog) - 1; + /* mls caps out at 6 */ + uint mls = ms->cParams.minMatch < 6 ? ms->cParams.minMatch : 6; + ZSTD_row_update_internal(ms, ip, mls, rowLog, rowMask, 0); + } + + /* Returns the mask width of bits group of which will be set to 1. Given not all + * architectures have easy movemask instruction, this helps to iterate over + * groups of bits easier and faster. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_row_matchMaskGroupWidth(uint rowEntries) + { + assert(rowEntries == 16 || rowEntries == 32 || rowEntries == 64); + assert(rowEntries <= 64); +#if NET5_0_OR_GREATER + if (AdvSimd.IsSupported && BitConverter.IsLittleEndian) + { + if (rowEntries == 16) + return 4; +#if NET9_0_OR_GREATER + if (AdvSimd.Arm64.IsSupported) + { + if (rowEntries == 32) + return 2; + if (rowEntries == 64) + return 1; + } +#endif + } +#endif + return 1; + } + +#if NETCOREAPP3_0_OR_GREATER + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ulong ZSTD_row_getSSEMask(int nbChunks, byte* src, byte tag, uint head) + { + Vector128 comparisonMask = Vector128.Create(tag); + assert(nbChunks is 1 or 2 or 4); + if (nbChunks == 1) + { + Vector128 chunk0 = Sse2.LoadVector128(src); + Vector128 equalMask0 = Sse2.CompareEqual(chunk0, comparisonMask); + int matches0 = Sse2.MoveMask(equalMask0); + return BitOperations.RotateRight((ushort)matches0, (int)head); + } + + if (nbChunks == 2) + { + Vector128 chunk0 = Sse2.LoadVector128(src); + Vector128 equalMask0 = Sse2.CompareEqual(chunk0, comparisonMask); + int matches0 = Sse2.MoveMask(equalMask0); + Vector128 chunk1 = Sse2.LoadVector128(src + 16); + Vector128 equalMask1 = Sse2.CompareEqual(chunk1, comparisonMask); + int matches1 = Sse2.MoveMask(equalMask1); + return BitOperations.RotateRight((uint)matches1 << 16 | (uint)matches0, (int)head); + } + + { + Vector128 chunk0 = Sse2.LoadVector128(src); + Vector128 equalMask0 = Sse2.CompareEqual(chunk0, comparisonMask); + int matches0 = Sse2.MoveMask(equalMask0); + Vector128 chunk1 = Sse2.LoadVector128(src + 16 * 1); + Vector128 equalMask1 = Sse2.CompareEqual(chunk1, comparisonMask); + int matches1 = Sse2.MoveMask(equalMask1); + Vector128 chunk2 = Sse2.LoadVector128(src + 16 * 2); + Vector128 equalMask2 = Sse2.CompareEqual(chunk2, comparisonMask); + int matches2 = Sse2.MoveMask(equalMask2); + Vector128 chunk3 = Sse2.LoadVector128(src + 16 * 3); + Vector128 equalMask3 = Sse2.CompareEqual(chunk3, comparisonMask); + int matches3 = Sse2.MoveMask(equalMask3); + return BitOperations.RotateRight( + (ulong)matches3 << 48 + | (ulong)matches2 << 32 + | (ulong)matches1 << 16 + | (uint)matches0, + (int)head + ); + } + } +#endif + + /* Returns a ZSTD_VecMask (U64) that has the nth group (determined by + * ZSTD_row_matchMaskGroupWidth) of bits set to 1 if the newly-computed "tag" + * matches the hash at the nth position in a row of the tagTable. + * Each row is a circular buffer beginning at the value of "headGrouped". So we + * must rotate the "matches" bitfield to match up with the actual layout of the + * entries within the hashTable */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ulong ZSTD_row_getMatchMask( + byte* tagRow, + byte tag, + uint headGrouped, + uint rowEntries + ) + { + byte* src = tagRow; + assert(rowEntries == 16 || rowEntries == 32 || rowEntries == 64); + assert(rowEntries <= 64); + assert(ZSTD_row_matchMaskGroupWidth(rowEntries) * rowEntries <= sizeof(ulong) * 8); +#if NETCOREAPP3_0_OR_GREATER + if (Sse2.IsSupported) + { + return ZSTD_row_getSSEMask((int)(rowEntries / 16), src, tag, headGrouped); + } +#endif + +#if NET5_0_OR_GREATER + if (AdvSimd.IsSupported && BitConverter.IsLittleEndian) + { + if (rowEntries == 16) + { + /* vshrn_n_u16 shifts by 4 every u16 and narrows to 8 lower bits. + * After that groups of 4 bits represent the equalMask. We lower + * all bits except the highest in these groups by doing AND with + * 0x88 = 0b10001000. + */ + Vector128 chunk = AdvSimd.LoadVector128(src); + Vector128 equalMask = AdvSimd + .CompareEqual(chunk, AdvSimd.DuplicateToVector128(tag)) + .As(); + Vector64 res = AdvSimd.ShiftRightLogicalNarrowingLower(equalMask, 4); + ulong matches = res.As().GetElement(0); + return BitOperations.RotateRight(matches, (int)headGrouped) & 0x8888888888888888; + } + else if (rowEntries == 32) + { +#if NET9_0_OR_GREATER + if (AdvSimd.Arm64.IsSupported) + { + /* Same idea as with rowEntries == 16 but doing AND with + * 0x55 = 0b01010101. + */ + (Vector128 chunk0, Vector128 chunk1) = + AdvSimd.Arm64.Load2xVector128AndUnzip((ushort*)src); + Vector128 dup = AdvSimd.DuplicateToVector128(tag); + Vector64 t0 = AdvSimd.ShiftRightLogicalNarrowingLower( + AdvSimd.CompareEqual(chunk0.As(), dup).As(), + 6 + ); + Vector64 t1 = AdvSimd.ShiftRightLogicalNarrowingLower( + AdvSimd.CompareEqual(chunk1.As(), dup).As(), + 6 + ); + Vector64 res = AdvSimd.ShiftLeftAndInsert(t0, t1, 4); + ulong matches = res.As().GetElement(0); + return BitOperations.RotateRight(matches, (int)headGrouped) + & 0x5555555555555555; + } +#endif + } + else + { /* rowEntries == 64 */ +#if NET9_0_OR_GREATER + if (AdvSimd.Arm64.IsSupported) + { + ( + Vector128 chunk0, + Vector128 chunk1, + Vector128 chunk2, + Vector128 chunk3 + ) = AdvSimd.Arm64.Load4xVector128AndUnzip(src); + Vector128 dup = AdvSimd.DuplicateToVector128(tag); + Vector128 cmp0 = AdvSimd.CompareEqual(chunk0, dup); + Vector128 cmp1 = AdvSimd.CompareEqual(chunk1, dup); + Vector128 cmp2 = AdvSimd.CompareEqual(chunk2, dup); + Vector128 cmp3 = AdvSimd.CompareEqual(chunk3, dup); + + Vector128 t0 = AdvSimd.ShiftRightAndInsert(cmp1, cmp0, 1); + Vector128 t1 = AdvSimd.ShiftRightAndInsert(cmp3, cmp2, 1); + Vector128 t2 = AdvSimd.ShiftRightAndInsert(t1, t0, 2); + Vector128 t3 = AdvSimd.ShiftRightAndInsert(t2, t2, 4); + Vector64 t4 = AdvSimd.ShiftRightLogicalNarrowingLower( + t3.As(), + 4 + ); + ulong matches = t4.As().GetElement(0); + return BitOperations.RotateRight(matches, (int)headGrouped); + } +#endif + } + } +#endif + + { + nuint chunkSize = (nuint)sizeof(nuint); + nuint shiftAmount = chunkSize * 8 - chunkSize; + nuint xFF = ~(nuint)0; + nuint x01 = xFF / 0xFF; + nuint x80 = x01 << 7; + nuint splatChar = tag * x01; + ulong matches = 0; + int i = (int)(rowEntries - chunkSize); + assert(sizeof(nuint) == 4 || sizeof(nuint) == 8); + if (BitConverter.IsLittleEndian) + { + nuint extractMagic = xFF / 0x7F >> (int)chunkSize; + do + { + nuint chunk = MEM_readST(&src[i]); + chunk ^= splatChar; + chunk = ((chunk | x80) - x01 | chunk) & x80; + matches <<= (int)chunkSize; + matches |= chunk * extractMagic >> (int)shiftAmount; + i -= (int)chunkSize; + } while (i >= 0); + } + else + { + nuint msb = xFF ^ xFF >> 1; + nuint extractMagic = msb / 0x1FF | msb; + do + { + nuint chunk = MEM_readST(&src[i]); + chunk ^= splatChar; + chunk = ((chunk | x80) - x01 | chunk) & x80; + matches <<= (int)chunkSize; + matches |= (chunk >> 7) * extractMagic >> (int)shiftAmount; + i -= (int)chunkSize; + } while (i >= 0); + } + + matches = ~matches; + if (rowEntries == 16) + { + return BitOperations.RotateRight((ushort)matches, (int)headGrouped); + } + else if (rowEntries == 32) + { + return BitOperations.RotateRight((uint)matches, (int)headGrouped); + } + else + { + return BitOperations.RotateRight(matches, (int)headGrouped); + } + } + } + + /* The high-level approach of the SIMD row based match finder is as follows: + * - Figure out where to insert the new entry: + * - Generate a hash for current input position and split it into a one byte of tag and `rowHashLog` bits of index. + * - The hash is salted by a value that changes on every context reset, so when the same table is used + * we will avoid collisions that would otherwise slow us down by introducing phantom matches. + * - The hashTable is effectively split into groups or "rows" of 15 or 31 entries of U32, and the index determines + * which row to insert into. + * - Determine the correct position within the row to insert the entry into. Each row of 15 or 31 can + * be considered as a circular buffer with a "head" index that resides in the tagTable (overall 16 or 32 bytes + * per row). + * - Use SIMD to efficiently compare the tags in the tagTable to the 1-byte tag calculated for the position and + * generate a bitfield that we can cycle through to check the collisions in the hash table. + * - Pick the longest match. + * - Insert the tag into the equivalent row and position in the tagTable. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_RowFindBestMatch( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr, + uint mls, + ZSTD_dictMode_e dictMode, + uint rowLog + ) + { + uint* hashTable = ms->hashTable; + byte* tagTable = ms->tagTable; + uint* hashCache = ms->hashCache; + uint hashLog = ms->rowHashLog; + ZSTD_compressionParameters* cParams = &ms->cParams; + byte* @base = ms->window.@base; + byte* dictBase = ms->window.dictBase; + uint dictLimit = ms->window.dictLimit; + byte* prefixStart = @base + dictLimit; + byte* dictEnd = dictBase + dictLimit; + uint curr = (uint)(ip - @base); + uint maxDistance = 1U << (int)cParams->windowLog; + uint lowestValid = ms->window.lowLimit; + uint withinMaxDistance = + curr - lowestValid > maxDistance ? curr - maxDistance : lowestValid; + uint isDictionary = ms->loadedDictEnd != 0 ? 1U : 0U; + uint lowLimit = isDictionary != 0 ? lowestValid : withinMaxDistance; + uint rowEntries = 1U << (int)rowLog; + uint rowMask = rowEntries - 1; + /* nb of searches is capped at nb entries per row */ + uint cappedSearchLog = cParams->searchLog < rowLog ? cParams->searchLog : rowLog; + uint groupWidth = ZSTD_row_matchMaskGroupWidth(rowEntries); + ulong hashSalt = ms->hashSalt; + uint nbAttempts = 1U << (int)cappedSearchLog; + nuint ml = 4 - 1; + uint hash; + /* DMS/DDS variables that may be referenced laster */ + ZSTD_MatchState_t* dms = ms->dictMatchState; + /* Initialize the following variables to satisfy static analyzer */ + nuint ddsIdx = 0; + /* cctx hash tables are limited in searches, but allow extra searches into DDS */ + uint ddsExtraAttempts = 0; + uint dmsTag = 0; + uint* dmsRow = null; + byte* dmsTagRow = null; + if (dictMode == ZSTD_dictMode_e.ZSTD_dedicatedDictSearch) + { + uint ddsHashLog = dms->cParams.hashLog - 2; + { + ddsIdx = ZSTD_hashPtr(ip, ddsHashLog, mls) << 2; +#if NETCOREAPP3_0_OR_GREATER + if (Sse.IsSupported) + { + Sse.Prefetch0(&dms->hashTable[ddsIdx]); + } +#endif + } + + ddsExtraAttempts = + cParams->searchLog > rowLog ? 1U << (int)(cParams->searchLog - rowLog) : 0; + } + + if (dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState) + { + /* Prefetch DMS rows */ + uint* dmsHashTable = dms->hashTable; + byte* dmsTagTable = dms->tagTable; + uint dmsHash = (uint)ZSTD_hashPtr(ip, dms->rowHashLog + 8, mls); + uint dmsRelRow = dmsHash >> 8 << (int)rowLog; + dmsTag = dmsHash & (1U << 8) - 1; + dmsTagRow = dmsTagTable + dmsRelRow; + dmsRow = dmsHashTable + dmsRelRow; + ZSTD_row_prefetch(dmsHashTable, dmsTagTable, dmsRelRow, rowLog); + } + + if (ms->lazySkipping == 0) + { + ZSTD_row_update_internal(ms, ip, mls, rowLog, rowMask, 1); + hash = ZSTD_row_nextCachedHash( + hashCache, + hashTable, + tagTable, + @base, + curr, + hashLog, + rowLog, + mls, + hashSalt + ); + } + else + { + hash = (uint)ZSTD_hashPtrSalted(ip, hashLog + 8, mls, hashSalt); + ms->nextToUpdate = curr; + } + + ms->hashSaltEntropy += hash; + { + uint relRow = hash >> 8 << (int)rowLog; + uint tag = hash & (1U << 8) - 1; + uint* row = hashTable + relRow; + byte* tagRow = tagTable + relRow; + uint headGrouped = (*tagRow & rowMask) * groupWidth; + uint* matchBuffer = stackalloc uint[64]; + nuint numMatches = 0; + nuint currMatch = 0; + ulong matches = ZSTD_row_getMatchMask(tagRow, (byte)tag, headGrouped, rowEntries); + for (; matches > 0 && nbAttempts > 0; matches &= matches - 1) + { + uint matchPos = (headGrouped + ZSTD_VecMask_next(matches)) / groupWidth & rowMask; + uint matchIndex = row[matchPos]; + if (matchPos == 0) + continue; + assert(numMatches < rowEntries); + if (matchIndex < lowLimit) + break; + if (dictMode != ZSTD_dictMode_e.ZSTD_extDict || matchIndex >= dictLimit) + { +#if NETCOREAPP3_0_OR_GREATER + if (Sse.IsSupported) + { + Sse.Prefetch0(@base + matchIndex); + } +#endif + } + else + { +#if NETCOREAPP3_0_OR_GREATER + if (Sse.IsSupported) + { + Sse.Prefetch0(dictBase + matchIndex); + } +#endif + } + + matchBuffer[numMatches++] = matchIndex; + --nbAttempts; + } + + { + uint pos = ZSTD_row_nextIndex(tagRow, rowMask); + tagRow[pos] = (byte)tag; + row[pos] = ms->nextToUpdate++; + } + + for (; currMatch < numMatches; ++currMatch) + { + uint matchIndex = matchBuffer[currMatch]; + nuint currentMl = 0; + assert(matchIndex < curr); + assert(matchIndex >= lowLimit); + if (dictMode != ZSTD_dictMode_e.ZSTD_extDict || matchIndex >= dictLimit) + { + byte* match = @base + matchIndex; + assert(matchIndex >= dictLimit); + if (MEM_read32(match + ml - 3) == MEM_read32(ip + ml - 3)) + currentMl = ZSTD_count(ip, match, iLimit); + } + else + { + byte* match = dictBase + matchIndex; + assert(match + 4 <= dictEnd); + if (MEM_read32(match) == MEM_read32(ip)) + currentMl = + ZSTD_count_2segments(ip + 4, match + 4, iLimit, dictEnd, prefixStart) + + 4; + } + + if (currentMl > ml) + { + ml = currentMl; + assert(curr - matchIndex > 0); + *offsetPtr = curr - matchIndex + 3; + if (ip + currentMl == iLimit) + break; + } + } + } + + assert(nbAttempts <= 1U << (sizeof(nuint) == 4 ? 30 : 31) - 1); + if (dictMode == ZSTD_dictMode_e.ZSTD_dedicatedDictSearch) + { + ml = ZSTD_dedicatedDictSearch_lazy_search( + offsetPtr, + ml, + nbAttempts + ddsExtraAttempts, + dms, + ip, + iLimit, + prefixStart, + curr, + dictLimit, + ddsIdx + ); + } + else if (dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState) + { + /* TODO: Measure and potentially add prefetching to DMS */ + uint dmsLowestIndex = dms->window.dictLimit; + byte* dmsBase = dms->window.@base; + byte* dmsEnd = dms->window.nextSrc; + uint dmsSize = (uint)(dmsEnd - dmsBase); + uint dmsIndexDelta = dictLimit - dmsSize; + { + uint headGrouped = (*dmsTagRow & rowMask) * groupWidth; + uint* matchBuffer = stackalloc uint[64]; + nuint numMatches = 0; + nuint currMatch = 0; + ulong matches = ZSTD_row_getMatchMask( + dmsTagRow, + (byte)dmsTag, + headGrouped, + rowEntries + ); + for (; matches > 0 && nbAttempts > 0; matches &= matches - 1) + { + uint matchPos = + (headGrouped + ZSTD_VecMask_next(matches)) / groupWidth & rowMask; + uint matchIndex = dmsRow[matchPos]; + if (matchPos == 0) + continue; + if (matchIndex < dmsLowestIndex) + break; +#if NETCOREAPP3_0_OR_GREATER + if (Sse.IsSupported) + { + Sse.Prefetch0(dmsBase + matchIndex); + } +#endif + + matchBuffer[numMatches++] = matchIndex; + --nbAttempts; + } + + for (; currMatch < numMatches; ++currMatch) + { + uint matchIndex = matchBuffer[currMatch]; + nuint currentMl = 0; + assert(matchIndex >= dmsLowestIndex); + assert(matchIndex < curr); + { + byte* match = dmsBase + matchIndex; + assert(match + 4 <= dmsEnd); + if (MEM_read32(match) == MEM_read32(ip)) + currentMl = + ZSTD_count_2segments(ip + 4, match + 4, iLimit, dmsEnd, prefixStart) + + 4; + } + + if (currentMl > ml) + { + ml = currentMl; + assert(curr > matchIndex + dmsIndexDelta); + assert(curr - (matchIndex + dmsIndexDelta) > 0); + *offsetPtr = curr - (matchIndex + dmsIndexDelta) + 3; + if (ip + currentMl == iLimit) + break; + } + } + } + } + + return ml; + } + + /* Generate row search fns for each combination of (dictMode, mls, rowLog) */ + private static nuint ZSTD_RowFindBestMatch_noDict_4_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 4 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMode_e.ZSTD_noDict, 4); + } + + private static nuint ZSTD_RowFindBestMatch_noDict_4_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 5 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMode_e.ZSTD_noDict, 5); + } + + private static nuint ZSTD_RowFindBestMatch_noDict_4_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 6 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMode_e.ZSTD_noDict, 6); + } + + private static nuint ZSTD_RowFindBestMatch_noDict_5_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 4 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMode_e.ZSTD_noDict, 4); + } + + private static nuint ZSTD_RowFindBestMatch_noDict_5_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 5 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMode_e.ZSTD_noDict, 5); + } + + private static nuint ZSTD_RowFindBestMatch_noDict_5_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 6 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMode_e.ZSTD_noDict, 6); + } + + private static nuint ZSTD_RowFindBestMatch_noDict_6_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 4 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMode_e.ZSTD_noDict, 4); + } + + private static nuint ZSTD_RowFindBestMatch_noDict_6_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 5 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMode_e.ZSTD_noDict, 5); + } + + private static nuint ZSTD_RowFindBestMatch_noDict_6_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 6 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMode_e.ZSTD_noDict, 6); + } + + private static nuint ZSTD_RowFindBestMatch_extDict_4_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 4 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMode_e.ZSTD_extDict, 4); + } + + private static nuint ZSTD_RowFindBestMatch_extDict_4_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 5 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMode_e.ZSTD_extDict, 5); + } + + private static nuint ZSTD_RowFindBestMatch_extDict_4_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 6 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMode_e.ZSTD_extDict, 6); + } + + private static nuint ZSTD_RowFindBestMatch_extDict_5_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 4 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMode_e.ZSTD_extDict, 4); + } + + private static nuint ZSTD_RowFindBestMatch_extDict_5_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 5 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMode_e.ZSTD_extDict, 5); + } + + private static nuint ZSTD_RowFindBestMatch_extDict_5_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 6 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMode_e.ZSTD_extDict, 6); + } + + private static nuint ZSTD_RowFindBestMatch_extDict_6_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 4 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMode_e.ZSTD_extDict, 4); + } + + private static nuint ZSTD_RowFindBestMatch_extDict_6_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 5 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMode_e.ZSTD_extDict, 5); + } + + private static nuint ZSTD_RowFindBestMatch_extDict_6_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 6 + ); + return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMode_e.ZSTD_extDict, 6); + } + + private static nuint ZSTD_RowFindBestMatch_dictMatchState_4_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 4 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 4, + ZSTD_dictMode_e.ZSTD_dictMatchState, + 4 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dictMatchState_4_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 5 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 4, + ZSTD_dictMode_e.ZSTD_dictMatchState, + 5 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dictMatchState_4_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 6 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 4, + ZSTD_dictMode_e.ZSTD_dictMatchState, + 6 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dictMatchState_5_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 4 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 5, + ZSTD_dictMode_e.ZSTD_dictMatchState, + 4 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dictMatchState_5_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 5 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 5, + ZSTD_dictMode_e.ZSTD_dictMatchState, + 5 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dictMatchState_5_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 6 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 5, + ZSTD_dictMode_e.ZSTD_dictMatchState, + 6 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dictMatchState_6_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 4 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 6, + ZSTD_dictMode_e.ZSTD_dictMatchState, + 4 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dictMatchState_6_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 5 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 6, + ZSTD_dictMode_e.ZSTD_dictMatchState, + 5 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dictMatchState_6_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 6 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 6, + ZSTD_dictMode_e.ZSTD_dictMatchState, + 6 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dedicatedDictSearch_4_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 4 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 4, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch, + 4 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dedicatedDictSearch_4_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 5 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 4, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch, + 5 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dedicatedDictSearch_4_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 6 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 4, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch, + 6 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dedicatedDictSearch_5_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 4 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 5, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch, + 4 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dedicatedDictSearch_5_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 5 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 5, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch, + 5 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dedicatedDictSearch_5_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 6 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 5, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch, + 6 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dedicatedDictSearch_6_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 4 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 6, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch, + 4 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dedicatedDictSearch_6_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 5 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 6, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch, + 5 + ); + } + + private static nuint ZSTD_RowFindBestMatch_dedicatedDictSearch_6_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + assert( + ( + 4 > (6 < ms->cParams.searchLog ? 6 : ms->cParams.searchLog) ? 4 + : 6 < ms->cParams.searchLog ? 6 + : ms->cParams.searchLog + ) == 6 + ); + return ZSTD_RowFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 6, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch, + 6 + ); + } + + /* Generate binary Tree search fns for each combination of (dictMode, mls) */ + private static nuint ZSTD_BtFindBestMatch_noDict_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offBasePtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + return ZSTD_BtFindBestMatch(ms, ip, iLimit, offBasePtr, 4, ZSTD_dictMode_e.ZSTD_noDict); + } + + private static nuint ZSTD_BtFindBestMatch_noDict_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offBasePtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + return ZSTD_BtFindBestMatch(ms, ip, iLimit, offBasePtr, 5, ZSTD_dictMode_e.ZSTD_noDict); + } + + private static nuint ZSTD_BtFindBestMatch_noDict_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offBasePtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + return ZSTD_BtFindBestMatch(ms, ip, iLimit, offBasePtr, 6, ZSTD_dictMode_e.ZSTD_noDict); + } + + private static nuint ZSTD_BtFindBestMatch_extDict_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offBasePtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + return ZSTD_BtFindBestMatch(ms, ip, iLimit, offBasePtr, 4, ZSTD_dictMode_e.ZSTD_extDict); + } + + private static nuint ZSTD_BtFindBestMatch_extDict_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offBasePtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + return ZSTD_BtFindBestMatch(ms, ip, iLimit, offBasePtr, 5, ZSTD_dictMode_e.ZSTD_extDict); + } + + private static nuint ZSTD_BtFindBestMatch_extDict_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offBasePtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + return ZSTD_BtFindBestMatch(ms, ip, iLimit, offBasePtr, 6, ZSTD_dictMode_e.ZSTD_extDict); + } + + private static nuint ZSTD_BtFindBestMatch_dictMatchState_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offBasePtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + return ZSTD_BtFindBestMatch( + ms, + ip, + iLimit, + offBasePtr, + 4, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_BtFindBestMatch_dictMatchState_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offBasePtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + return ZSTD_BtFindBestMatch( + ms, + ip, + iLimit, + offBasePtr, + 5, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_BtFindBestMatch_dictMatchState_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offBasePtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + return ZSTD_BtFindBestMatch( + ms, + ip, + iLimit, + offBasePtr, + 6, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_BtFindBestMatch_dedicatedDictSearch_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offBasePtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + return ZSTD_BtFindBestMatch( + ms, + ip, + iLimit, + offBasePtr, + 4, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ); + } + + private static nuint ZSTD_BtFindBestMatch_dedicatedDictSearch_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offBasePtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + return ZSTD_BtFindBestMatch( + ms, + ip, + iLimit, + offBasePtr, + 5, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ); + } + + private static nuint ZSTD_BtFindBestMatch_dedicatedDictSearch_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offBasePtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + return ZSTD_BtFindBestMatch( + ms, + ip, + iLimit, + offBasePtr, + 6, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ); + } + + /* Generate hash chain search fns for each combination of (dictMode, mls) */ + private static nuint ZSTD_HcFindBestMatch_noDict_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + return ZSTD_HcFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMode_e.ZSTD_noDict); + } + + private static nuint ZSTD_HcFindBestMatch_noDict_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + return ZSTD_HcFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMode_e.ZSTD_noDict); + } + + private static nuint ZSTD_HcFindBestMatch_noDict_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + return ZSTD_HcFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMode_e.ZSTD_noDict); + } + + private static nuint ZSTD_HcFindBestMatch_extDict_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + return ZSTD_HcFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMode_e.ZSTD_extDict); + } + + private static nuint ZSTD_HcFindBestMatch_extDict_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + return ZSTD_HcFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMode_e.ZSTD_extDict); + } + + private static nuint ZSTD_HcFindBestMatch_extDict_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + return ZSTD_HcFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMode_e.ZSTD_extDict); + } + + private static nuint ZSTD_HcFindBestMatch_dictMatchState_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + return ZSTD_HcFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 4, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_HcFindBestMatch_dictMatchState_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + return ZSTD_HcFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 5, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_HcFindBestMatch_dictMatchState_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + return ZSTD_HcFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 6, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_HcFindBestMatch_dedicatedDictSearch_4( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 4 + ); + return ZSTD_HcFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 4, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ); + } + + private static nuint ZSTD_HcFindBestMatch_dedicatedDictSearch_5( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 5 + ); + return ZSTD_HcFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 5, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ); + } + + private static nuint ZSTD_HcFindBestMatch_dedicatedDictSearch_6( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iLimit, + nuint* offsetPtr + ) + { + assert( + ( + 4 > (6 < ms->cParams.minMatch ? 6 : ms->cParams.minMatch) ? 4 + : 6 < ms->cParams.minMatch ? 6 + : ms->cParams.minMatch + ) == 6 + ); + return ZSTD_HcFindBestMatch( + ms, + ip, + iLimit, + offsetPtr, + 6, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ); + } + + /** + * Searches for the longest match at @p ip. + * Dispatches to the correct implementation function based on the + * (searchMethod, dictMode, mls, rowLog). We use switch statements + * here instead of using an indirect function call through a function + * pointer because after Spectre and Meltdown mitigations, indirect + * function calls can be very costly, especially in the kernel. + * + * NOTE: dictMode and searchMethod should be templated, so those switch + * statements should be optimized out. Only the mls & rowLog switches + * should be left. + * + * @param ms The match state. + * @param ip The position to search at. + * @param iend The end of the input data. + * @param[out] offsetPtr Stores the match offset into this pointer. + * @param mls The minimum search length, in the range [4, 6]. + * @param rowLog The row log (if applicable), in the range [4, 6]. + * @param searchMethod The search method to use (templated). + * @param dictMode The dictMode (templated). + * + * @returns The length of the longest match found, or < mls if no match is found. + * If a match is found its offset is stored in @p offsetPtr. + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_searchMax( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iend, + nuint* offsetPtr, + uint mls, + uint rowLog, + searchMethod_e searchMethod, + ZSTD_dictMode_e dictMode + ) + { + if (dictMode == ZSTD_dictMode_e.ZSTD_noDict) + { + if (searchMethod == searchMethod_e.search_rowHash) + { + if (mls == 4) + { + if (rowLog == 4) + return ZSTD_RowFindBestMatch_noDict_4_4(ms, ip, iend, offsetPtr); + return rowLog == 5 + ? ZSTD_RowFindBestMatch_noDict_4_5(ms, ip, iend, offsetPtr) + : ZSTD_RowFindBestMatch_noDict_4_6(ms, ip, iend, offsetPtr); + } + + if (mls == 5) + { + if (rowLog == 4) + return ZSTD_RowFindBestMatch_noDict_5_4(ms, ip, iend, offsetPtr); + return rowLog == 5 + ? ZSTD_RowFindBestMatch_noDict_5_5(ms, ip, iend, offsetPtr) + : ZSTD_RowFindBestMatch_noDict_5_6(ms, ip, iend, offsetPtr); + } + + if (rowLog == 4) + return ZSTD_RowFindBestMatch_noDict_6_4(ms, ip, iend, offsetPtr); + return rowLog == 5 + ? ZSTD_RowFindBestMatch_noDict_6_5(ms, ip, iend, offsetPtr) + : ZSTD_RowFindBestMatch_noDict_6_6(ms, ip, iend, offsetPtr); + } + + if (searchMethod == searchMethod_e.search_hashChain) + { + if (mls == 4) + return ZSTD_HcFindBestMatch_noDict_4(ms, ip, iend, offsetPtr); + return mls == 5 + ? ZSTD_HcFindBestMatch_noDict_5(ms, ip, iend, offsetPtr) + : ZSTD_HcFindBestMatch_noDict_6(ms, ip, iend, offsetPtr); + } + + // searchMethod_e.search_binaryTree + if (mls == 4) + return ZSTD_BtFindBestMatch_noDict_4(ms, ip, iend, offsetPtr); + return mls == 5 + ? ZSTD_BtFindBestMatch_noDict_5(ms, ip, iend, offsetPtr) + : ZSTD_BtFindBestMatch_noDict_6(ms, ip, iend, offsetPtr); + } + + if (dictMode == ZSTD_dictMode_e.ZSTD_extDict) + { + if (searchMethod == searchMethod_e.search_rowHash) + { + if (mls == 4) + { + if (rowLog == 4) + return ZSTD_RowFindBestMatch_extDict_4_4(ms, ip, iend, offsetPtr); + if (rowLog == 5) + return ZSTD_RowFindBestMatch_extDict_4_5(ms, ip, iend, offsetPtr); + return ZSTD_RowFindBestMatch_extDict_4_6(ms, ip, iend, offsetPtr); + } + + if (mls == 5) + { + if (rowLog == 4) + return ZSTD_RowFindBestMatch_extDict_5_4(ms, ip, iend, offsetPtr); + if (rowLog == 5) + return ZSTD_RowFindBestMatch_extDict_5_5(ms, ip, iend, offsetPtr); + return ZSTD_RowFindBestMatch_extDict_5_6(ms, ip, iend, offsetPtr); + } + + if (mls == 6) + { + if (rowLog == 4) + return ZSTD_RowFindBestMatch_extDict_6_4(ms, ip, iend, offsetPtr); + if (rowLog == 5) + return ZSTD_RowFindBestMatch_extDict_6_5(ms, ip, iend, offsetPtr); + return ZSTD_RowFindBestMatch_extDict_6_6(ms, ip, iend, offsetPtr); + } + } + + if (searchMethod == searchMethod_e.search_hashChain) + { + if (mls == 4) + return ZSTD_HcFindBestMatch_extDict_4(ms, ip, iend, offsetPtr); + if (mls == 5) + return ZSTD_HcFindBestMatch_extDict_5(ms, ip, iend, offsetPtr); + return ZSTD_HcFindBestMatch_extDict_6(ms, ip, iend, offsetPtr); + } + + // searchMethod_e.search_binaryTree + if (mls == 4) + return ZSTD_BtFindBestMatch_extDict_4(ms, ip, iend, offsetPtr); + if (mls == 5) + return ZSTD_BtFindBestMatch_extDict_5(ms, ip, iend, offsetPtr); + return ZSTD_BtFindBestMatch_extDict_6(ms, ip, iend, offsetPtr); + } + + if (dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState) + { + if (searchMethod == searchMethod_e.search_rowHash) + { + if (mls == 4) + { + if (rowLog == 4) + return ZSTD_RowFindBestMatch_dictMatchState_4_4(ms, ip, iend, offsetPtr); + if (rowLog == 5) + return ZSTD_RowFindBestMatch_dictMatchState_4_5(ms, ip, iend, offsetPtr); + return ZSTD_RowFindBestMatch_dictMatchState_4_6(ms, ip, iend, offsetPtr); + } + + if (mls == 5) + { + if (rowLog == 4) + return ZSTD_RowFindBestMatch_dictMatchState_5_4(ms, ip, iend, offsetPtr); + if (rowLog == 5) + return ZSTD_RowFindBestMatch_dictMatchState_5_5(ms, ip, iend, offsetPtr); + return ZSTD_RowFindBestMatch_dictMatchState_5_6(ms, ip, iend, offsetPtr); + } + + if (mls == 6) + { + if (rowLog == 4) + return ZSTD_RowFindBestMatch_dictMatchState_6_4(ms, ip, iend, offsetPtr); + if (rowLog == 5) + return ZSTD_RowFindBestMatch_dictMatchState_6_5(ms, ip, iend, offsetPtr); + return ZSTD_RowFindBestMatch_dictMatchState_6_6(ms, ip, iend, offsetPtr); + } + } + + if (searchMethod == searchMethod_e.search_hashChain) + { + if (mls == 4) + return ZSTD_HcFindBestMatch_dictMatchState_4(ms, ip, iend, offsetPtr); + if (mls == 5) + return ZSTD_HcFindBestMatch_dictMatchState_5(ms, ip, iend, offsetPtr); + return ZSTD_HcFindBestMatch_dictMatchState_6(ms, ip, iend, offsetPtr); + } + + // search_binaryTree + if (mls == 4) + return ZSTD_BtFindBestMatch_dictMatchState_4(ms, ip, iend, offsetPtr); + if (mls == 5) + return ZSTD_BtFindBestMatch_dictMatchState_5(ms, ip, iend, offsetPtr); + return ZSTD_BtFindBestMatch_dictMatchState_6(ms, ip, iend, offsetPtr); + } + + if (searchMethod == searchMethod_e.search_rowHash) + { + if (mls == 4) + { + if (rowLog == 4) + return ZSTD_RowFindBestMatch_dedicatedDictSearch_4_4(ms, ip, iend, offsetPtr); + if (rowLog == 5) + return ZSTD_RowFindBestMatch_dedicatedDictSearch_4_5(ms, ip, iend, offsetPtr); + return ZSTD_RowFindBestMatch_dedicatedDictSearch_4_6(ms, ip, iend, offsetPtr); + } + + if (mls == 5) + { + if (rowLog == 4) + return ZSTD_RowFindBestMatch_dedicatedDictSearch_5_4(ms, ip, iend, offsetPtr); + if (rowLog == 5) + return ZSTD_RowFindBestMatch_dedicatedDictSearch_5_5(ms, ip, iend, offsetPtr); + return ZSTD_RowFindBestMatch_dedicatedDictSearch_5_6(ms, ip, iend, offsetPtr); + } + + if (mls == 6) + { + if (rowLog == 4) + return ZSTD_RowFindBestMatch_dedicatedDictSearch_6_4(ms, ip, iend, offsetPtr); + if (rowLog == 5) + return ZSTD_RowFindBestMatch_dedicatedDictSearch_6_5(ms, ip, iend, offsetPtr); + return ZSTD_RowFindBestMatch_dedicatedDictSearch_6_6(ms, ip, iend, offsetPtr); + } + } + + if (searchMethod == searchMethod_e.search_hashChain) + { + if (mls == 4) + return ZSTD_HcFindBestMatch_dedicatedDictSearch_4(ms, ip, iend, offsetPtr); + if (mls == 5) + return ZSTD_HcFindBestMatch_dedicatedDictSearch_5(ms, ip, iend, offsetPtr); + return ZSTD_HcFindBestMatch_dedicatedDictSearch_6(ms, ip, iend, offsetPtr); + } + + // searchMethod_e.search_binaryTree + if (mls == 4) + return ZSTD_BtFindBestMatch_dedicatedDictSearch_4(ms, ip, iend, offsetPtr); + if (mls == 5) + return ZSTD_BtFindBestMatch_dedicatedDictSearch_5(ms, ip, iend, offsetPtr); + return ZSTD_BtFindBestMatch_dedicatedDictSearch_6(ms, ip, iend, offsetPtr); + } + + /* ******************************* + * Common parser - lazy strategy + *********************************/ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_compressBlock_lazy_generic( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize, + searchMethod_e searchMethod, + uint depth, + ZSTD_dictMode_e dictMode + ) + { + byte* istart = (byte*)src; + byte* ip = istart; + byte* anchor = istart; + byte* iend = istart + srcSize; + byte* ilimit = searchMethod == searchMethod_e.search_rowHash ? iend - 8 - 8 : iend - 8; + byte* @base = ms->window.@base; + uint prefixLowestIndex = ms->window.dictLimit; + byte* prefixLowest = @base + prefixLowestIndex; + uint mls = + ms->cParams.minMatch <= 4 ? 4 + : ms->cParams.minMatch <= 6 ? ms->cParams.minMatch + : 6; + uint rowLog = + ms->cParams.searchLog <= 4 ? 4 + : ms->cParams.searchLog <= 6 ? ms->cParams.searchLog + : 6; + uint offset_1 = rep[0], + offset_2 = rep[1]; + uint offsetSaved1 = 0, + offsetSaved2 = 0; + int isDMS = dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState ? 1 : 0; + int isDDS = dictMode == ZSTD_dictMode_e.ZSTD_dedicatedDictSearch ? 1 : 0; + int isDxS = isDMS != 0 || isDDS != 0 ? 1 : 0; + ZSTD_MatchState_t* dms = ms->dictMatchState; + uint dictLowestIndex = isDxS != 0 ? dms->window.dictLimit : 0; + byte* dictBase = isDxS != 0 ? dms->window.@base : null; + byte* dictLowest = isDxS != 0 ? dictBase + dictLowestIndex : null; + byte* dictEnd = isDxS != 0 ? dms->window.nextSrc : null; + uint dictIndexDelta = isDxS != 0 ? prefixLowestIndex - (uint)(dictEnd - dictBase) : 0; + uint dictAndPrefixLength = (uint)(ip - prefixLowest + (dictEnd - dictLowest)); + ip += dictAndPrefixLength == 0 ? 1 : 0; + if (dictMode == ZSTD_dictMode_e.ZSTD_noDict) + { + uint curr = (uint)(ip - @base); + uint windowLow = ZSTD_getLowestPrefixIndex(ms, curr, ms->cParams.windowLog); + uint maxRep = curr - windowLow; + if (offset_2 > maxRep) + { + offsetSaved2 = offset_2; + offset_2 = 0; + } + + if (offset_1 > maxRep) + { + offsetSaved1 = offset_1; + offset_1 = 0; + } + } + +#if DEBUG + if (isDxS != 0) + { + assert(offset_1 <= dictAndPrefixLength); + assert(offset_2 <= dictAndPrefixLength); + } +#endif + + ms->lazySkipping = 0; + if (searchMethod == searchMethod_e.search_rowHash) + { + ZSTD_row_fillHashCache(ms, @base, rowLog, mls, ms->nextToUpdate, ilimit); + } + + while (ip < ilimit) + { + nuint matchLength = 0; + assert(1 >= 1); + assert(1 <= 3); + nuint offBase = 1; + byte* start = ip + 1; + if (isDxS != 0) + { + uint repIndex = (uint)(ip - @base) + 1 - offset_1; + byte* repMatch = + ( + dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState + || dictMode == ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ) + && repIndex < prefixLowestIndex + ? dictBase + (repIndex - dictIndexDelta) + : @base + repIndex; + if ( + ZSTD_index_overlap_check(prefixLowestIndex, repIndex) != 0 + && MEM_read32(repMatch) == MEM_read32(ip + 1) + ) + { + byte* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend; + matchLength = + ZSTD_count_2segments( + ip + 1 + 4, + repMatch + 4, + iend, + repMatchEnd, + prefixLowest + ) + 4; + if (depth == 0) + goto _storeSequence; + } + } + + if ( + dictMode == ZSTD_dictMode_e.ZSTD_noDict + && offset_1 > 0 + && MEM_read32(ip + 1 - offset_1) == MEM_read32(ip + 1) + ) + { + matchLength = ZSTD_count(ip + 1 + 4, ip + 1 + 4 - offset_1, iend) + 4; + if (depth == 0) + goto _storeSequence; + } + + { + nuint offbaseFound = 999999999; + nuint ml2 = ZSTD_searchMax( + ms, + ip, + iend, + &offbaseFound, + mls, + rowLog, + searchMethod, + dictMode + ); + if (ml2 > matchLength) + { + matchLength = ml2; + start = ip; + offBase = offbaseFound; + } + } + + if (matchLength < 4) + { + /* jump faster over incompressible sections */ + nuint step = ((nuint)(ip - anchor) >> 8) + 1; + ip += step; + ms->lazySkipping = step > 8 ? 1 : 0; + continue; + } + + if (depth >= 1) + while (ip < ilimit) + { + ip++; + if ( + dictMode == ZSTD_dictMode_e.ZSTD_noDict + && offBase != 0 + && offset_1 > 0 + && MEM_read32(ip) == MEM_read32(ip - offset_1) + ) + { + nuint mlRep = ZSTD_count(ip + 4, ip + 4 - offset_1, iend) + 4; + int gain2 = (int)(mlRep * 3); + int gain1 = (int)(matchLength * 3 - ZSTD_highbit32((uint)offBase) + 1); + if (mlRep >= 4 && gain2 > gain1) + { + matchLength = mlRep; + assert(1 >= 1); + assert(1 <= 3); + offBase = 1; + start = ip; + } + } + + if (isDxS != 0) + { + uint repIndex = (uint)(ip - @base) - offset_1; + byte* repMatch = + repIndex < prefixLowestIndex + ? dictBase + (repIndex - dictIndexDelta) + : @base + repIndex; + if ( + ZSTD_index_overlap_check(prefixLowestIndex, repIndex) != 0 + && MEM_read32(repMatch) == MEM_read32(ip) + ) + { + byte* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend; + nuint mlRep = + ZSTD_count_2segments( + ip + 4, + repMatch + 4, + iend, + repMatchEnd, + prefixLowest + ) + 4; + int gain2 = (int)(mlRep * 3); + int gain1 = (int)(matchLength * 3 - ZSTD_highbit32((uint)offBase) + 1); + if (mlRep >= 4 && gain2 > gain1) + { + matchLength = mlRep; + assert(1 >= 1); + assert(1 <= 3); + offBase = 1; + start = ip; + } + } + } + + { + nuint ofbCandidate = 999999999; + nuint ml2 = ZSTD_searchMax( + ms, + ip, + iend, + &ofbCandidate, + mls, + rowLog, + searchMethod, + dictMode + ); + /* raw approx */ + int gain2 = (int)(ml2 * 4 - ZSTD_highbit32((uint)ofbCandidate)); + int gain1 = (int)(matchLength * 4 - ZSTD_highbit32((uint)offBase) + 4); + if (ml2 >= 4 && gain2 > gain1) + { + matchLength = ml2; + offBase = ofbCandidate; + start = ip; + continue; + } + } + + if (depth == 2 && ip < ilimit) + { + ip++; + if ( + dictMode == ZSTD_dictMode_e.ZSTD_noDict + && offBase != 0 + && offset_1 > 0 + && MEM_read32(ip) == MEM_read32(ip - offset_1) + ) + { + nuint mlRep = ZSTD_count(ip + 4, ip + 4 - offset_1, iend) + 4; + int gain2 = (int)(mlRep * 4); + int gain1 = (int)(matchLength * 4 - ZSTD_highbit32((uint)offBase) + 1); + if (mlRep >= 4 && gain2 > gain1) + { + matchLength = mlRep; + assert(1 >= 1); + assert(1 <= 3); + offBase = 1; + start = ip; + } + } + + if (isDxS != 0) + { + uint repIndex = (uint)(ip - @base) - offset_1; + byte* repMatch = + repIndex < prefixLowestIndex + ? dictBase + (repIndex - dictIndexDelta) + : @base + repIndex; + if ( + ZSTD_index_overlap_check(prefixLowestIndex, repIndex) != 0 + && MEM_read32(repMatch) == MEM_read32(ip) + ) + { + byte* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend; + nuint mlRep = + ZSTD_count_2segments( + ip + 4, + repMatch + 4, + iend, + repMatchEnd, + prefixLowest + ) + 4; + int gain2 = (int)(mlRep * 4); + int gain1 = (int)( + matchLength * 4 - ZSTD_highbit32((uint)offBase) + 1 + ); + if (mlRep >= 4 && gain2 > gain1) + { + matchLength = mlRep; + assert(1 >= 1); + assert(1 <= 3); + offBase = 1; + start = ip; + } + } + } + + { + nuint ofbCandidate = 999999999; + nuint ml2 = ZSTD_searchMax( + ms, + ip, + iend, + &ofbCandidate, + mls, + rowLog, + searchMethod, + dictMode + ); + /* raw approx */ + int gain2 = (int)(ml2 * 4 - ZSTD_highbit32((uint)ofbCandidate)); + int gain1 = (int)(matchLength * 4 - ZSTD_highbit32((uint)offBase) + 7); + if (ml2 >= 4 && gain2 > gain1) + { + matchLength = ml2; + offBase = ofbCandidate; + start = ip; + continue; + } + } + } + + break; + } + + if (offBase > 3) + { + if (dictMode == ZSTD_dictMode_e.ZSTD_noDict) + { + assert(offBase > 3); + assert(offBase > 3); + while ( + start > anchor + && start - (offBase - 3) > prefixLowest + && start[-1] == (start - (offBase - 3))[-1] + ) + { + start--; + matchLength++; + } + } + + if (isDxS != 0) + { + assert(offBase > 3); + uint matchIndex = (uint)((nuint)(start - @base) - (offBase - 3)); + byte* match = + matchIndex < prefixLowestIndex + ? dictBase + matchIndex - dictIndexDelta + : @base + matchIndex; + byte* mStart = matchIndex < prefixLowestIndex ? dictLowest : prefixLowest; + while (start > anchor && match > mStart && start[-1] == match[-1]) + { + start--; + match--; + matchLength++; + } + } + + offset_2 = offset_1; + assert(offBase > 3); + offset_1 = (uint)(offBase - 3); + } + + _storeSequence: + { + nuint litLength = (nuint)(start - anchor); + ZSTD_storeSeq(seqStore, litLength, anchor, iend, (uint)offBase, matchLength); + anchor = ip = start + matchLength; + } + + if (ms->lazySkipping != 0) + { + if (searchMethod == searchMethod_e.search_rowHash) + { + ZSTD_row_fillHashCache(ms, @base, rowLog, mls, ms->nextToUpdate, ilimit); + } + + ms->lazySkipping = 0; + } + + if (isDxS != 0) + { + while (ip <= ilimit) + { + uint current2 = (uint)(ip - @base); + uint repIndex = current2 - offset_2; + byte* repMatch = + repIndex < prefixLowestIndex + ? dictBase - dictIndexDelta + repIndex + : @base + repIndex; + if ( + ZSTD_index_overlap_check(prefixLowestIndex, repIndex) != 0 + && MEM_read32(repMatch) == MEM_read32(ip) + ) + { + byte* repEnd2 = repIndex < prefixLowestIndex ? dictEnd : iend; + matchLength = + ZSTD_count_2segments(ip + 4, repMatch + 4, iend, repEnd2, prefixLowest) + + 4; + offBase = offset_2; + offset_2 = offset_1; + offset_1 = (uint)offBase; + assert(1 >= 1); + assert(1 <= 3); + ZSTD_storeSeq(seqStore, 0, anchor, iend, 1, matchLength); + ip += matchLength; + anchor = ip; + continue; + } + + break; + } + } + + if (dictMode == ZSTD_dictMode_e.ZSTD_noDict) + { + while (ip <= ilimit && offset_2 > 0 && MEM_read32(ip) == MEM_read32(ip - offset_2)) + { + matchLength = ZSTD_count(ip + 4, ip + 4 - offset_2, iend) + 4; + offBase = offset_2; + offset_2 = offset_1; + offset_1 = (uint)offBase; + assert(1 >= 1); + assert(1 <= 3); + ZSTD_storeSeq(seqStore, 0, anchor, iend, 1, matchLength); + ip += matchLength; + anchor = ip; + continue; + } + } + } + + offsetSaved2 = offsetSaved1 != 0 && offset_1 != 0 ? offsetSaved1 : offsetSaved2; + rep[0] = offset_1 != 0 ? offset_1 : offsetSaved1; + rep[1] = offset_2 != 0 ? offset_2 : offsetSaved2; + return (nuint)(iend - anchor); + } + + private static nuint ZSTD_compressBlock_greedy( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_hashChain, + 0, + ZSTD_dictMode_e.ZSTD_noDict + ); + } + + private static nuint ZSTD_compressBlock_greedy_dictMatchState( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_hashChain, + 0, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_compressBlock_greedy_dedicatedDictSearch( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_hashChain, + 0, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ); + } + + private static nuint ZSTD_compressBlock_greedy_row( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_rowHash, + 0, + ZSTD_dictMode_e.ZSTD_noDict + ); + } + + private static nuint ZSTD_compressBlock_greedy_dictMatchState_row( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_rowHash, + 0, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_compressBlock_greedy_dedicatedDictSearch_row( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_rowHash, + 0, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ); + } + + private static nuint ZSTD_compressBlock_lazy( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_hashChain, + 1, + ZSTD_dictMode_e.ZSTD_noDict + ); + } + + private static nuint ZSTD_compressBlock_lazy_dictMatchState( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_hashChain, + 1, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_compressBlock_lazy_dedicatedDictSearch( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_hashChain, + 1, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ); + } + + private static nuint ZSTD_compressBlock_lazy_row( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_rowHash, + 1, + ZSTD_dictMode_e.ZSTD_noDict + ); + } + + private static nuint ZSTD_compressBlock_lazy_dictMatchState_row( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_rowHash, + 1, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_compressBlock_lazy_dedicatedDictSearch_row( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_rowHash, + 1, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ); + } + + private static nuint ZSTD_compressBlock_lazy2( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_hashChain, + 2, + ZSTD_dictMode_e.ZSTD_noDict + ); + } + + private static nuint ZSTD_compressBlock_lazy2_dictMatchState( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_hashChain, + 2, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_compressBlock_lazy2_dedicatedDictSearch( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_hashChain, + 2, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ); + } + + private static nuint ZSTD_compressBlock_lazy2_row( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_rowHash, + 2, + ZSTD_dictMode_e.ZSTD_noDict + ); + } + + private static nuint ZSTD_compressBlock_lazy2_dictMatchState_row( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_rowHash, + 2, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_compressBlock_lazy2_dedicatedDictSearch_row( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_rowHash, + 2, + ZSTD_dictMode_e.ZSTD_dedicatedDictSearch + ); + } + + private static nuint ZSTD_compressBlock_btlazy2( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_binaryTree, + 2, + ZSTD_dictMode_e.ZSTD_noDict + ); + } + + private static nuint ZSTD_compressBlock_btlazy2_dictMatchState( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_binaryTree, + 2, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_compressBlock_lazy_extDict_generic( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize, + searchMethod_e searchMethod, + uint depth + ) + { + byte* istart = (byte*)src; + byte* ip = istart; + byte* anchor = istart; + byte* iend = istart + srcSize; + byte* ilimit = searchMethod == searchMethod_e.search_rowHash ? iend - 8 - 8 : iend - 8; + byte* @base = ms->window.@base; + uint dictLimit = ms->window.dictLimit; + byte* prefixStart = @base + dictLimit; + byte* dictBase = ms->window.dictBase; + byte* dictEnd = dictBase + dictLimit; + byte* dictStart = dictBase + ms->window.lowLimit; + uint windowLog = ms->cParams.windowLog; + uint mls = + ms->cParams.minMatch <= 4 ? 4 + : ms->cParams.minMatch <= 6 ? ms->cParams.minMatch + : 6; + uint rowLog = + ms->cParams.searchLog <= 4 ? 4 + : ms->cParams.searchLog <= 6 ? ms->cParams.searchLog + : 6; + uint offset_1 = rep[0], + offset_2 = rep[1]; + ms->lazySkipping = 0; + ip += ip == prefixStart ? 1 : 0; + if (searchMethod == searchMethod_e.search_rowHash) + { + ZSTD_row_fillHashCache(ms, @base, rowLog, mls, ms->nextToUpdate, ilimit); + } + + while (ip < ilimit) + { + nuint matchLength = 0; + assert(1 >= 1); + assert(1 <= 3); + nuint offBase = 1; + byte* start = ip + 1; + uint curr = (uint)(ip - @base); + { + uint windowLow = ZSTD_getLowestMatchIndex(ms, curr + 1, windowLog); + uint repIndex = curr + 1 - offset_1; + byte* repBase = repIndex < dictLimit ? dictBase : @base; + byte* repMatch = repBase + repIndex; + if ( + ( + ZSTD_index_overlap_check(dictLimit, repIndex) + & (offset_1 <= curr + 1 - windowLow ? 1 : 0) + ) != 0 + ) + if (MEM_read32(ip + 1) == MEM_read32(repMatch)) + { + /* repcode detected we should take it */ + byte* repEnd = repIndex < dictLimit ? dictEnd : iend; + matchLength = + ZSTD_count_2segments( + ip + 1 + 4, + repMatch + 4, + iend, + repEnd, + prefixStart + ) + 4; + if (depth == 0) + goto _storeSequence; + } + } + + { + nuint ofbCandidate = 999999999; + nuint ml2 = ZSTD_searchMax( + ms, + ip, + iend, + &ofbCandidate, + mls, + rowLog, + searchMethod, + ZSTD_dictMode_e.ZSTD_extDict + ); + if (ml2 > matchLength) + { + matchLength = ml2; + start = ip; + offBase = ofbCandidate; + } + } + + if (matchLength < 4) + { + nuint step = (nuint)(ip - anchor) >> 8; + ip += step + 1; + ms->lazySkipping = step > 8 ? 1 : 0; + continue; + } + + if (depth >= 1) + while (ip < ilimit) + { + ip++; + curr++; + if (offBase != 0) + { + uint windowLow = ZSTD_getLowestMatchIndex(ms, curr, windowLog); + uint repIndex = curr - offset_1; + byte* repBase = repIndex < dictLimit ? dictBase : @base; + byte* repMatch = repBase + repIndex; + if ( + ( + ZSTD_index_overlap_check(dictLimit, repIndex) + & (offset_1 <= curr - windowLow ? 1 : 0) + ) != 0 + ) + if (MEM_read32(ip) == MEM_read32(repMatch)) + { + /* repcode detected */ + byte* repEnd = repIndex < dictLimit ? dictEnd : iend; + nuint repLength = + ZSTD_count_2segments( + ip + 4, + repMatch + 4, + iend, + repEnd, + prefixStart + ) + 4; + int gain2 = (int)(repLength * 3); + int gain1 = (int)( + matchLength * 3 - ZSTD_highbit32((uint)offBase) + 1 + ); + if (repLength >= 4 && gain2 > gain1) + { + matchLength = repLength; + assert(1 >= 1); + assert(1 <= 3); + offBase = 1; + start = ip; + } + } + } + + { + nuint ofbCandidate = 999999999; + nuint ml2 = ZSTD_searchMax( + ms, + ip, + iend, + &ofbCandidate, + mls, + rowLog, + searchMethod, + ZSTD_dictMode_e.ZSTD_extDict + ); + /* raw approx */ + int gain2 = (int)(ml2 * 4 - ZSTD_highbit32((uint)ofbCandidate)); + int gain1 = (int)(matchLength * 4 - ZSTD_highbit32((uint)offBase) + 4); + if (ml2 >= 4 && gain2 > gain1) + { + matchLength = ml2; + offBase = ofbCandidate; + start = ip; + continue; + } + } + + if (depth == 2 && ip < ilimit) + { + ip++; + curr++; + if (offBase != 0) + { + uint windowLow = ZSTD_getLowestMatchIndex(ms, curr, windowLog); + uint repIndex = curr - offset_1; + byte* repBase = repIndex < dictLimit ? dictBase : @base; + byte* repMatch = repBase + repIndex; + if ( + ( + ZSTD_index_overlap_check(dictLimit, repIndex) + & (offset_1 <= curr - windowLow ? 1 : 0) + ) != 0 + ) + if (MEM_read32(ip) == MEM_read32(repMatch)) + { + /* repcode detected */ + byte* repEnd = repIndex < dictLimit ? dictEnd : iend; + nuint repLength = + ZSTD_count_2segments( + ip + 4, + repMatch + 4, + iend, + repEnd, + prefixStart + ) + 4; + int gain2 = (int)(repLength * 4); + int gain1 = (int)( + matchLength * 4 - ZSTD_highbit32((uint)offBase) + 1 + ); + if (repLength >= 4 && gain2 > gain1) + { + matchLength = repLength; + assert(1 >= 1); + assert(1 <= 3); + offBase = 1; + start = ip; + } + } + } + + { + nuint ofbCandidate = 999999999; + nuint ml2 = ZSTD_searchMax( + ms, + ip, + iend, + &ofbCandidate, + mls, + rowLog, + searchMethod, + ZSTD_dictMode_e.ZSTD_extDict + ); + /* raw approx */ + int gain2 = (int)(ml2 * 4 - ZSTD_highbit32((uint)ofbCandidate)); + int gain1 = (int)(matchLength * 4 - ZSTD_highbit32((uint)offBase) + 7); + if (ml2 >= 4 && gain2 > gain1) + { + matchLength = ml2; + offBase = ofbCandidate; + start = ip; + continue; + } + } + } + + break; + } + + if (offBase > 3) + { + assert(offBase > 3); + uint matchIndex = (uint)((nuint)(start - @base) - (offBase - 3)); + byte* match = matchIndex < dictLimit ? dictBase + matchIndex : @base + matchIndex; + byte* mStart = matchIndex < dictLimit ? dictStart : prefixStart; + while (start > anchor && match > mStart && start[-1] == match[-1]) + { + start--; + match--; + matchLength++; + } + + offset_2 = offset_1; + assert(offBase > 3); + offset_1 = (uint)(offBase - 3); + } + + _storeSequence: + { + nuint litLength = (nuint)(start - anchor); + ZSTD_storeSeq(seqStore, litLength, anchor, iend, (uint)offBase, matchLength); + anchor = ip = start + matchLength; + } + + if (ms->lazySkipping != 0) + { + if (searchMethod == searchMethod_e.search_rowHash) + { + ZSTD_row_fillHashCache(ms, @base, rowLog, mls, ms->nextToUpdate, ilimit); + } + + ms->lazySkipping = 0; + } + + while (ip <= ilimit) + { + uint repCurrent = (uint)(ip - @base); + uint windowLow = ZSTD_getLowestMatchIndex(ms, repCurrent, windowLog); + uint repIndex = repCurrent - offset_2; + byte* repBase = repIndex < dictLimit ? dictBase : @base; + byte* repMatch = repBase + repIndex; + if ( + ( + ZSTD_index_overlap_check(dictLimit, repIndex) + & (offset_2 <= repCurrent - windowLow ? 1 : 0) + ) != 0 + ) + if (MEM_read32(ip) == MEM_read32(repMatch)) + { + /* repcode detected we should take it */ + byte* repEnd = repIndex < dictLimit ? dictEnd : iend; + matchLength = + ZSTD_count_2segments(ip + 4, repMatch + 4, iend, repEnd, prefixStart) + + 4; + offBase = offset_2; + offset_2 = offset_1; + offset_1 = (uint)offBase; + assert(1 >= 1); + assert(1 <= 3); + ZSTD_storeSeq(seqStore, 0, anchor, iend, 1, matchLength); + ip += matchLength; + anchor = ip; + continue; + } + + break; + } + } + + rep[0] = offset_1; + rep[1] = offset_2; + return (nuint)(iend - anchor); + } + + private static nuint ZSTD_compressBlock_greedy_extDict( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_extDict_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_hashChain, + 0 + ); + } + + private static nuint ZSTD_compressBlock_greedy_extDict_row( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_extDict_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_rowHash, + 0 + ); + } + + private static nuint ZSTD_compressBlock_lazy_extDict( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_extDict_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_hashChain, + 1 + ); + } + + private static nuint ZSTD_compressBlock_lazy_extDict_row( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_extDict_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_rowHash, + 1 + ); + } + + private static nuint ZSTD_compressBlock_lazy2_extDict( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_extDict_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_hashChain, + 2 + ); + } + + private static nuint ZSTD_compressBlock_lazy2_extDict_row( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_extDict_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_rowHash, + 2 + ); + } + + private static nuint ZSTD_compressBlock_btlazy2_extDict( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_lazy_extDict_generic( + ms, + seqStore, + rep, + src, + srcSize, + searchMethod_e.search_binaryTree, + 2 + ); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdLdm.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdLdm.cs new file mode 100644 index 000000000..eb6349798 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdLdm.cs @@ -0,0 +1,940 @@ +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /** ZSTD_ldm_gear_init(): + * + * Initializes the rolling hash state such that it will honor the + * settings in params. */ + private static void ZSTD_ldm_gear_init(ldmRollingHashState_t* state, ldmParams_t* @params) + { + uint maxBitsInMask = @params->minMatchLength < 64 ? @params->minMatchLength : 64; + uint hashRateLog = @params->hashRateLog; + state->rolling = ~(uint)0; + if (hashRateLog > 0 && hashRateLog <= maxBitsInMask) + { + state->stopMask = + ((ulong)1 << (int)hashRateLog) - 1 << (int)(maxBitsInMask - hashRateLog); + } + else + { + state->stopMask = ((ulong)1 << (int)hashRateLog) - 1; + } + } + + /** ZSTD_ldm_gear_reset() + * Feeds [data, data + minMatchLength) into the hash without registering any + * splits. This effectively resets the hash state. This is used when skipping + * over data, either at the beginning of a block, or skipping sections. + */ + private static void ZSTD_ldm_gear_reset( + ldmRollingHashState_t* state, + byte* data, + nuint minMatchLength + ) + { + ulong hash = state->rolling; + nuint n = 0; + while (n + 3 < minMatchLength) + { + { + hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; + n += 1; + } + + { + hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; + n += 1; + } + + { + hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; + n += 1; + } + + { + hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; + n += 1; + } + } + + while (n < minMatchLength) + { + hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; + n += 1; + } + } + + /** ZSTD_ldm_gear_feed(): + * + * Registers in the splits array all the split points found in the first + * size bytes following the data pointer. This function terminates when + * either all the data has been processed or LDM_BATCH_SIZE splits are + * present in the splits array. + * + * Precondition: The splits array must not be full. + * Returns: The number of bytes processed. */ + private static nuint ZSTD_ldm_gear_feed( + ldmRollingHashState_t* state, + byte* data, + nuint size, + nuint* splits, + uint* numSplits + ) + { + nuint n; + ulong hash, + mask; + hash = state->rolling; + mask = state->stopMask; + n = 0; + while (n + 3 < size) + { + { + hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; + n += 1; + if ((hash & mask) == 0) + { + splits[*numSplits] = n; + *numSplits += 1; + if (*numSplits == 64) + goto done; + } + } + + { + hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; + n += 1; + if ((hash & mask) == 0) + { + splits[*numSplits] = n; + *numSplits += 1; + if (*numSplits == 64) + goto done; + } + } + + { + hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; + n += 1; + if ((hash & mask) == 0) + { + splits[*numSplits] = n; + *numSplits += 1; + if (*numSplits == 64) + goto done; + } + } + + { + hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; + n += 1; + if ((hash & mask) == 0) + { + splits[*numSplits] = n; + *numSplits += 1; + if (*numSplits == 64) + goto done; + } + } + } + + while (n < size) + { + hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; + n += 1; + if ((hash & mask) == 0) + { + splits[*numSplits] = n; + *numSplits += 1; + if (*numSplits == 64) + goto done; + } + } + + done: + state->rolling = hash; + return n; + } + + /** ZSTD_ldm_adjustParameters() : + * If the params->hashRateLog is not set, set it to its default value based on + * windowLog and params->hashLog. + * + * Ensures that params->bucketSizeLog is <= params->hashLog (setting it to + * params->hashLog if it is not). + * + * Ensures that the minMatchLength >= targetLength during optimal parsing. + */ + private static void ZSTD_ldm_adjustParameters( + ldmParams_t* @params, + ZSTD_compressionParameters* cParams + ) + { + @params->windowLog = cParams->windowLog; + if (@params->hashRateLog == 0) + { + if (@params->hashLog > 0) + { + assert( + @params->hashLog + <= (uint)( + (sizeof(nuint) == 4 ? 30 : 31) < 30 + ? sizeof(nuint) == 4 + ? 30 + : 31 + : 30 + ) + ); + if (@params->windowLog > @params->hashLog) + { + @params->hashRateLog = @params->windowLog - @params->hashLog; + } + } + else + { + assert(1 <= (int)cParams->strategy && (int)cParams->strategy <= 9); + @params->hashRateLog = (uint)(7 - (int)cParams->strategy / 3); + } + } + + if (@params->hashLog == 0) + { + @params->hashLog = + @params->windowLog - @params->hashRateLog <= 6 ? 6 + : @params->windowLog - @params->hashRateLog + <= (uint)( + (sizeof(nuint) == 4 ? 30 : 31) < 30 + ? sizeof(nuint) == 4 + ? 30 + : 31 + : 30 + ) + ? @params->windowLog - @params->hashRateLog + : (uint)( + (sizeof(nuint) == 4 ? 30 : 31) < 30 + ? sizeof(nuint) == 4 + ? 30 + : 31 + : 30 + ); + } + + if (@params->minMatchLength == 0) + { + @params->minMatchLength = 64; + if (cParams->strategy >= ZSTD_strategy.ZSTD_btultra) + @params->minMatchLength /= 2; + } + + if (@params->bucketSizeLog == 0) + { + assert(1 <= (int)cParams->strategy && (int)cParams->strategy <= 9); + @params->bucketSizeLog = + (uint)cParams->strategy <= 4 ? 4 + : (uint)cParams->strategy <= 8 ? (uint)cParams->strategy + : 8; + } + + @params->bucketSizeLog = + @params->bucketSizeLog < @params->hashLog ? @params->bucketSizeLog : @params->hashLog; + } + + /** ZSTD_ldm_getTableSize() : + * Estimate the space needed for long distance matching tables or 0 if LDM is + * disabled. + */ + private static nuint ZSTD_ldm_getTableSize(ldmParams_t @params) + { + nuint ldmHSize = (nuint)1 << (int)@params.hashLog; + nuint ldmBucketSizeLog = + @params.bucketSizeLog < @params.hashLog ? @params.bucketSizeLog : @params.hashLog; + nuint ldmBucketSize = (nuint)1 << (int)(@params.hashLog - ldmBucketSizeLog); + nuint totalSize = + ZSTD_cwksp_alloc_size(ldmBucketSize) + + ZSTD_cwksp_alloc_size(ldmHSize * (nuint)sizeof(ldmEntry_t)); + return @params.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable ? totalSize : 0; + } + + /** ZSTD_ldm_getSeqSpace() : + * Return an upper bound on the number of sequences that can be produced by + * the long distance matcher, or 0 if LDM is disabled. + */ + private static nuint ZSTD_ldm_getMaxNbSeq(ldmParams_t @params, nuint maxChunkSize) + { + return @params.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable + ? maxChunkSize / @params.minMatchLength + : 0; + } + + /** ZSTD_ldm_getBucket() : + * Returns a pointer to the start of the bucket associated with hash. */ + private static ldmEntry_t* ZSTD_ldm_getBucket( + ldmState_t* ldmState, + nuint hash, + uint bucketSizeLog + ) + { + return ldmState->hashTable + (hash << (int)bucketSizeLog); + } + + /** ZSTD_ldm_insertEntry() : + * Insert the entry with corresponding hash into the hash table */ + private static void ZSTD_ldm_insertEntry( + ldmState_t* ldmState, + nuint hash, + ldmEntry_t entry, + uint bucketSizeLog + ) + { + byte* pOffset = ldmState->bucketOffsets + hash; + uint offset = *pOffset; + *(ZSTD_ldm_getBucket(ldmState, hash, bucketSizeLog) + offset) = entry; + *pOffset = (byte)(offset + 1 & (1U << (int)bucketSizeLog) - 1); + } + + /** ZSTD_ldm_countBackwardsMatch() : + * Returns the number of bytes that match backwards before pIn and pMatch. + * + * We count only bytes where pMatch >= pBase and pIn >= pAnchor. */ + private static nuint ZSTD_ldm_countBackwardsMatch( + byte* pIn, + byte* pAnchor, + byte* pMatch, + byte* pMatchBase + ) + { + nuint matchLength = 0; + while (pIn > pAnchor && pMatch > pMatchBase && pIn[-1] == pMatch[-1]) + { + pIn--; + pMatch--; + matchLength++; + } + + return matchLength; + } + + /** ZSTD_ldm_countBackwardsMatch_2segments() : + * Returns the number of bytes that match backwards from pMatch, + * even with the backwards match spanning 2 different segments. + * + * On reaching `pMatchBase`, start counting from mEnd */ + private static nuint ZSTD_ldm_countBackwardsMatch_2segments( + byte* pIn, + byte* pAnchor, + byte* pMatch, + byte* pMatchBase, + byte* pExtDictStart, + byte* pExtDictEnd + ) + { + nuint matchLength = ZSTD_ldm_countBackwardsMatch(pIn, pAnchor, pMatch, pMatchBase); + if (pMatch - matchLength != pMatchBase || pMatchBase == pExtDictStart) + { + return matchLength; + } + + matchLength += ZSTD_ldm_countBackwardsMatch( + pIn - matchLength, + pAnchor, + pExtDictEnd, + pExtDictStart + ); + return matchLength; + } + + /** ZSTD_ldm_fillFastTables() : + * + * Fills the relevant tables for the ZSTD_fast and ZSTD_dfast strategies. + * This is similar to ZSTD_loadDictionaryContent. + * + * The tables for the other strategies are filled within their + * block compressors. */ + private static nuint ZSTD_ldm_fillFastTables(ZSTD_MatchState_t* ms, void* end) + { + byte* iend = (byte*)end; + switch (ms->cParams.strategy) + { + case ZSTD_strategy.ZSTD_fast: + ZSTD_fillHashTable( + ms, + iend, + ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast, + ZSTD_tableFillPurpose_e.ZSTD_tfp_forCCtx + ); + break; + case ZSTD_strategy.ZSTD_dfast: + ZSTD_fillDoubleHashTable( + ms, + iend, + ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast, + ZSTD_tableFillPurpose_e.ZSTD_tfp_forCCtx + ); + break; + case ZSTD_strategy.ZSTD_greedy: + case ZSTD_strategy.ZSTD_lazy: + case ZSTD_strategy.ZSTD_lazy2: + case ZSTD_strategy.ZSTD_btlazy2: + case ZSTD_strategy.ZSTD_btopt: + case ZSTD_strategy.ZSTD_btultra: + case ZSTD_strategy.ZSTD_btultra2: + break; + default: + assert(0 != 0); + break; + } + + return 0; + } + + private static void ZSTD_ldm_fillHashTable( + ldmState_t* ldmState, + byte* ip, + byte* iend, + ldmParams_t* @params + ) + { + uint minMatchLength = @params->minMatchLength; + uint bucketSizeLog = @params->bucketSizeLog; + uint hBits = @params->hashLog - bucketSizeLog; + byte* @base = ldmState->window.@base; + byte* istart = ip; + ldmRollingHashState_t hashState; + nuint* splits = &ldmState->splitIndices.e0; + uint numSplits; + ZSTD_ldm_gear_init(&hashState, @params); + while (ip < iend) + { + nuint hashed; + uint n; + numSplits = 0; + hashed = ZSTD_ldm_gear_feed(&hashState, ip, (nuint)(iend - ip), splits, &numSplits); + for (n = 0; n < numSplits; n++) + { + if (ip + splits[n] >= istart + minMatchLength) + { + byte* split = ip + splits[n] - minMatchLength; + ulong xxhash = ZSTD_XXH64(split, minMatchLength, 0); + uint hash = (uint)(xxhash & ((uint)1 << (int)hBits) - 1); + ldmEntry_t entry; + entry.offset = (uint)(split - @base); + entry.checksum = (uint)(xxhash >> 32); + ZSTD_ldm_insertEntry(ldmState, hash, entry, @params->bucketSizeLog); + } + } + + ip += hashed; + } + } + + /** ZSTD_ldm_limitTableUpdate() : + * + * Sets cctx->nextToUpdate to a position corresponding closer to anchor + * if it is far way + * (after a long match, only update tables a limited amount). */ + private static void ZSTD_ldm_limitTableUpdate(ZSTD_MatchState_t* ms, byte* anchor) + { + uint curr = (uint)(anchor - ms->window.@base); + if (curr > ms->nextToUpdate + 1024) + { + ms->nextToUpdate = + curr + - (512 < curr - ms->nextToUpdate - 1024 ? 512 : curr - ms->nextToUpdate - 1024); + } + } + + private static nuint ZSTD_ldm_generateSequences_internal( + ldmState_t* ldmState, + RawSeqStore_t* rawSeqStore, + ldmParams_t* @params, + void* src, + nuint srcSize + ) + { + /* LDM parameters */ + int extDict = (int)ZSTD_window_hasExtDict(ldmState->window); + uint minMatchLength = @params->minMatchLength; + uint entsPerBucket = 1U << (int)@params->bucketSizeLog; + uint hBits = @params->hashLog - @params->bucketSizeLog; + /* Prefix and extDict parameters */ + uint dictLimit = ldmState->window.dictLimit; + uint lowestIndex = extDict != 0 ? ldmState->window.lowLimit : dictLimit; + byte* @base = ldmState->window.@base; + byte* dictBase = extDict != 0 ? ldmState->window.dictBase : null; + byte* dictStart = extDict != 0 ? dictBase + lowestIndex : null; + byte* dictEnd = extDict != 0 ? dictBase + dictLimit : null; + byte* lowPrefixPtr = @base + dictLimit; + /* Input bounds */ + byte* istart = (byte*)src; + byte* iend = istart + srcSize; + byte* ilimit = iend - 8; + /* Input positions */ + byte* anchor = istart; + byte* ip = istart; + /* Rolling hash state */ + ldmRollingHashState_t hashState; + /* Arrays for staged-processing */ + nuint* splits = &ldmState->splitIndices.e0; + ldmMatchCandidate_t* candidates = &ldmState->matchCandidates.e0; + uint numSplits; + if (srcSize < minMatchLength) + return (nuint)(iend - anchor); + ZSTD_ldm_gear_init(&hashState, @params); + ZSTD_ldm_gear_reset(&hashState, ip, minMatchLength); + ip += minMatchLength; + while (ip < ilimit) + { + nuint hashed; + uint n; + numSplits = 0; + hashed = ZSTD_ldm_gear_feed(&hashState, ip, (nuint)(ilimit - ip), splits, &numSplits); + for (n = 0; n < numSplits; n++) + { + byte* split = ip + splits[n] - minMatchLength; + ulong xxhash = ZSTD_XXH64(split, minMatchLength, 0); + uint hash = (uint)(xxhash & ((uint)1 << (int)hBits) - 1); + candidates[n].split = split; + candidates[n].hash = hash; + candidates[n].checksum = (uint)(xxhash >> 32); + candidates[n].bucket = ZSTD_ldm_getBucket(ldmState, hash, @params->bucketSizeLog); +#if NETCOREAPP3_0_OR_GREATER + if (System.Runtime.Intrinsics.X86.Sse.IsSupported) + { + System.Runtime.Intrinsics.X86.Sse.Prefetch0(candidates[n].bucket); + } +#endif + } + + for (n = 0; n < numSplits; n++) + { + nuint forwardMatchLength = 0, + backwardMatchLength = 0, + bestMatchLength = 0, + mLength; + uint offset; + byte* split = candidates[n].split; + uint checksum = candidates[n].checksum; + uint hash = candidates[n].hash; + ldmEntry_t* bucket = candidates[n].bucket; + ldmEntry_t* cur; + ldmEntry_t* bestEntry = null; + ldmEntry_t newEntry; + newEntry.offset = (uint)(split - @base); + newEntry.checksum = checksum; + if (split < anchor) + { + ZSTD_ldm_insertEntry(ldmState, hash, newEntry, @params->bucketSizeLog); + continue; + } + + for (cur = bucket; cur < bucket + entsPerBucket; cur++) + { + nuint curForwardMatchLength, + curBackwardMatchLength, + curTotalMatchLength; + if (cur->checksum != checksum || cur->offset <= lowestIndex) + { + continue; + } + + if (extDict != 0) + { + byte* curMatchBase = cur->offset < dictLimit ? dictBase : @base; + byte* pMatch = curMatchBase + cur->offset; + byte* matchEnd = cur->offset < dictLimit ? dictEnd : iend; + byte* lowMatchPtr = cur->offset < dictLimit ? dictStart : lowPrefixPtr; + curForwardMatchLength = ZSTD_count_2segments( + split, + pMatch, + iend, + matchEnd, + lowPrefixPtr + ); + if (curForwardMatchLength < minMatchLength) + { + continue; + } + + curBackwardMatchLength = ZSTD_ldm_countBackwardsMatch_2segments( + split, + anchor, + pMatch, + lowMatchPtr, + dictStart, + dictEnd + ); + } + else + { + byte* pMatch = @base + cur->offset; + curForwardMatchLength = ZSTD_count(split, pMatch, iend); + if (curForwardMatchLength < minMatchLength) + { + continue; + } + + curBackwardMatchLength = ZSTD_ldm_countBackwardsMatch( + split, + anchor, + pMatch, + lowPrefixPtr + ); + } + + curTotalMatchLength = curForwardMatchLength + curBackwardMatchLength; + if (curTotalMatchLength > bestMatchLength) + { + bestMatchLength = curTotalMatchLength; + forwardMatchLength = curForwardMatchLength; + backwardMatchLength = curBackwardMatchLength; + bestEntry = cur; + } + } + + if (bestEntry == null) + { + ZSTD_ldm_insertEntry(ldmState, hash, newEntry, @params->bucketSizeLog); + continue; + } + + offset = (uint)(split - @base) - bestEntry->offset; + mLength = forwardMatchLength + backwardMatchLength; + { + rawSeq* seq = rawSeqStore->seq + rawSeqStore->size; + if (rawSeqStore->size == rawSeqStore->capacity) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)); + seq->litLength = (uint)(split - backwardMatchLength - anchor); + seq->matchLength = (uint)mLength; + seq->offset = offset; + rawSeqStore->size++; + } + + ZSTD_ldm_insertEntry(ldmState, hash, newEntry, @params->bucketSizeLog); + anchor = split + forwardMatchLength; + if (anchor > ip + hashed) + { + ZSTD_ldm_gear_reset(&hashState, anchor - minMatchLength, minMatchLength); + ip = anchor - hashed; + break; + } + } + + ip += hashed; + } + + return (nuint)(iend - anchor); + } + + /*! ZSTD_ldm_reduceTable() : + * reduce table indexes by `reducerValue` */ + private static void ZSTD_ldm_reduceTable(ldmEntry_t* table, uint size, uint reducerValue) + { + uint u; + for (u = 0; u < size; u++) + { + if (table[u].offset < reducerValue) + table[u].offset = 0; + else + table[u].offset -= reducerValue; + } + } + + /** + * ZSTD_ldm_generateSequences(): + * + * Generates the sequences using the long distance match finder. + * Generates long range matching sequences in `sequences`, which parse a prefix + * of the source. `sequences` must be large enough to store every sequence, + * which can be checked with `ZSTD_ldm_getMaxNbSeq()`. + * @returns 0 or an error code. + * + * NOTE: The user must have called ZSTD_window_update() for all of the input + * they have, even if they pass it to ZSTD_ldm_generateSequences() in chunks. + * NOTE: This function returns an error if it runs out of space to store + * sequences. + */ + private static nuint ZSTD_ldm_generateSequences( + ldmState_t* ldmState, + RawSeqStore_t* sequences, + ldmParams_t* @params, + void* src, + nuint srcSize + ) + { + uint maxDist = 1U << (int)@params->windowLog; + byte* istart = (byte*)src; + byte* iend = istart + srcSize; + const nuint kMaxChunkSize = 1 << 20; + nuint nbChunks = srcSize / kMaxChunkSize + (nuint)(srcSize % kMaxChunkSize != 0 ? 1 : 0); + nuint chunk; + nuint leftoverSize = 0; + assert( + unchecked((uint)-1) - (MEM_64bits ? 3500U * (1 << 20) : 2000U * (1 << 20)) + >= kMaxChunkSize + ); + assert(ldmState->window.nextSrc >= (byte*)src + srcSize); + assert(sequences->pos <= sequences->size); + assert(sequences->size <= sequences->capacity); + for (chunk = 0; chunk < nbChunks && sequences->size < sequences->capacity; ++chunk) + { + byte* chunkStart = istart + chunk * kMaxChunkSize; + nuint remaining = (nuint)(iend - chunkStart); + byte* chunkEnd = remaining < kMaxChunkSize ? iend : chunkStart + kMaxChunkSize; + nuint chunkSize = (nuint)(chunkEnd - chunkStart); + nuint newLeftoverSize; + nuint prevSize = sequences->size; + assert(chunkStart < iend); + if ( + ZSTD_window_needOverflowCorrection( + ldmState->window, + 0, + maxDist, + ldmState->loadedDictEnd, + chunkStart, + chunkEnd + ) != 0 + ) + { + uint ldmHSize = 1U << (int)@params->hashLog; + uint correction = ZSTD_window_correctOverflow( + &ldmState->window, + 0, + maxDist, + chunkStart + ); + ZSTD_ldm_reduceTable(ldmState->hashTable, ldmHSize, correction); + ldmState->loadedDictEnd = 0; + } + + ZSTD_window_enforceMaxDist( + &ldmState->window, + chunkEnd, + maxDist, + &ldmState->loadedDictEnd, + null + ); + newLeftoverSize = ZSTD_ldm_generateSequences_internal( + ldmState, + sequences, + @params, + chunkStart, + chunkSize + ); + if (ERR_isError(newLeftoverSize)) + return newLeftoverSize; + if (prevSize < sequences->size) + { + sequences->seq[prevSize].litLength += (uint)leftoverSize; + leftoverSize = newLeftoverSize; + } + else + { + assert(newLeftoverSize == chunkSize); + leftoverSize += chunkSize; + } + } + + return 0; + } + + /** + * ZSTD_ldm_skipSequences(): + * + * Skip past `srcSize` bytes worth of sequences in `rawSeqStore`. + * Avoids emitting matches less than `minMatch` bytes. + * Must be called for data that is not passed to ZSTD_ldm_blockCompress(). + */ + private static void ZSTD_ldm_skipSequences( + RawSeqStore_t* rawSeqStore, + nuint srcSize, + uint minMatch + ) + { + while (srcSize > 0 && rawSeqStore->pos < rawSeqStore->size) + { + rawSeq* seq = rawSeqStore->seq + rawSeqStore->pos; + if (srcSize <= seq->litLength) + { + seq->litLength -= (uint)srcSize; + return; + } + + srcSize -= seq->litLength; + seq->litLength = 0; + if (srcSize < seq->matchLength) + { + seq->matchLength -= (uint)srcSize; + if (seq->matchLength < minMatch) + { + if (rawSeqStore->pos + 1 < rawSeqStore->size) + { + seq[1].litLength += seq[0].matchLength; + } + + rawSeqStore->pos++; + } + + return; + } + + srcSize -= seq->matchLength; + seq->matchLength = 0; + rawSeqStore->pos++; + } + } + + /** + * If the sequence length is longer than remaining then the sequence is split + * between this block and the next. + * + * Returns the current sequence to handle, or if the rest of the block should + * be literals, it returns a sequence with offset == 0. + */ + private static rawSeq maybeSplitSequence( + RawSeqStore_t* rawSeqStore, + uint remaining, + uint minMatch + ) + { + rawSeq sequence = rawSeqStore->seq[rawSeqStore->pos]; + assert(sequence.offset > 0); + if (remaining >= sequence.litLength + sequence.matchLength) + { + rawSeqStore->pos++; + return sequence; + } + + if (remaining <= sequence.litLength) + { + sequence.offset = 0; + } + else if (remaining < sequence.litLength + sequence.matchLength) + { + sequence.matchLength = remaining - sequence.litLength; + if (sequence.matchLength < minMatch) + { + sequence.offset = 0; + } + } + + ZSTD_ldm_skipSequences(rawSeqStore, remaining, minMatch); + return sequence; + } + + /* ZSTD_ldm_skipRawSeqStoreBytes(): + * Moves forward in rawSeqStore by nbBytes, updating fields 'pos' and 'posInSequence'. + * Not to be used in conjunction with ZSTD_ldm_skipSequences(). + * Must be called for data with is not passed to ZSTD_ldm_blockCompress(). + */ + private static void ZSTD_ldm_skipRawSeqStoreBytes(RawSeqStore_t* rawSeqStore, nuint nbBytes) + { + uint currPos = (uint)(rawSeqStore->posInSequence + nbBytes); + while (currPos != 0 && rawSeqStore->pos < rawSeqStore->size) + { + rawSeq currSeq = rawSeqStore->seq[rawSeqStore->pos]; + if (currPos >= currSeq.litLength + currSeq.matchLength) + { + currPos -= currSeq.litLength + currSeq.matchLength; + rawSeqStore->pos++; + } + else + { + rawSeqStore->posInSequence = currPos; + break; + } + } + + if (currPos == 0 || rawSeqStore->pos == rawSeqStore->size) + { + rawSeqStore->posInSequence = 0; + } + } + + /** + * ZSTD_ldm_blockCompress(): + * + * Compresses a block using the predefined sequences, along with a secondary + * block compressor. The literals section of every sequence is passed to the + * secondary block compressor, and those sequences are interspersed with the + * predefined sequences. Returns the length of the last literals. + * Updates `rawSeqStore.pos` to indicate how many sequences have been consumed. + * `rawSeqStore.seq` may also be updated to split the last sequence between two + * blocks. + * @return The length of the last literals. + * + * NOTE: The source must be at most the maximum block size, but the predefined + * sequences can be any size, and may be longer than the block. In the case that + * they are longer than the block, the last sequences may need to be split into + * two. We handle that case correctly, and update `rawSeqStore` appropriately. + * NOTE: This function does not return any errors. + */ + private static nuint ZSTD_ldm_blockCompress( + RawSeqStore_t* rawSeqStore, + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + ZSTD_paramSwitch_e useRowMatchFinder, + void* src, + nuint srcSize + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint minMatch = cParams->minMatch; + ZSTD_BlockCompressor_f blockCompressor = ZSTD_selectBlockCompressor( + cParams->strategy, + useRowMatchFinder, + ZSTD_matchState_dictMode(ms) + ); + /* Input bounds */ + byte* istart = (byte*)src; + byte* iend = istart + srcSize; + /* Input positions */ + byte* ip = istart; + if (cParams->strategy >= ZSTD_strategy.ZSTD_btopt) + { + nuint lastLLSize; + ms->ldmSeqStore = rawSeqStore; + lastLLSize = blockCompressor(ms, seqStore, rep, src, srcSize); + ZSTD_ldm_skipRawSeqStoreBytes(rawSeqStore, srcSize); + return lastLLSize; + } + + assert(rawSeqStore->pos <= rawSeqStore->size); + assert(rawSeqStore->size <= rawSeqStore->capacity); + while (rawSeqStore->pos < rawSeqStore->size && ip < iend) + { + /* maybeSplitSequence updates rawSeqStore->pos */ + rawSeq sequence = maybeSplitSequence(rawSeqStore, (uint)(iend - ip), minMatch); + if (sequence.offset == 0) + break; + assert(ip + sequence.litLength + sequence.matchLength <= iend); + ZSTD_ldm_limitTableUpdate(ms, ip); + ZSTD_ldm_fillFastTables(ms, ip); + { + int i; + nuint newLitLength = blockCompressor(ms, seqStore, rep, ip, sequence.litLength); + ip += sequence.litLength; + for (i = 3 - 1; i > 0; i--) + rep[i] = rep[i - 1]; + rep[0] = sequence.offset; + assert(sequence.offset > 0); + ZSTD_storeSeq( + seqStore, + newLitLength, + ip - newLitLength, + iend, + sequence.offset + 3, + sequence.matchLength + ); + ip += sequence.matchLength; + } + } + + ZSTD_ldm_limitTableUpdate(ms, ip); + ZSTD_ldm_fillFastTables(ms, ip); + return blockCompressor(ms, seqStore, rep, ip, (nuint)(iend - ip)); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdLdmGeartab.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdLdmGeartab.cs new file mode 100644 index 000000000..5edf11974 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdLdmGeartab.cs @@ -0,0 +1,539 @@ +using System; +using System.Runtime.InteropServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_ZSTD_ldm_gearTab => + new ulong[256] + { + 0xf5b8f72c5f77775c, + 0x84935f266b7ac412, + 0xb647ada9ca730ccc, + 0xb065bb4b114fb1de, + 0x34584e7e8c3a9fd0, + 0x4e97e17c6ae26b05, + 0x3a03d743bc99a604, + 0xcecd042422c4044f, + 0x76de76c58524259e, + 0x9c8528f65badeaca, + 0x86563706e2097529, + 0x2902475fa375d889, + 0xafb32a9739a5ebe6, + 0xce2714da3883e639, + 0x21eaf821722e69e, + 0x37b628620b628, + 0x49a8d455d88caf5, + 0x8556d711e6958140, + 0x4f7ae74fc605c1f, + 0x829f0c3468bd3a20, + 0x4ffdc885c625179e, + 0x8473de048a3daf1b, + 0x51008822b05646b2, + 0x69d75d12b2d1cc5f, + 0x8c9d4a19159154bc, + 0xc3cc10f4abbd4003, + 0xd06ddc1cecb97391, + 0xbe48e6e7ed80302e, + 0x3481db31cee03547, + 0xacc3f67cdaa1d210, + 0x65cb771d8c7f96cc, + 0x8eb27177055723dd, + 0xc789950d44cd94be, + 0x934feadc3700b12b, + 0x5e485f11edbdf182, + 0x1e2e2a46fd64767a, + 0x2969ca71d82efa7c, + 0x9d46e9935ebbba2e, + 0xe056b67e05e6822b, + 0x94d73f55739d03a0, + 0xcd7010bdb69b5a03, + 0x455ef9fcd79b82f4, + 0x869cb54a8749c161, + 0x38d1a4fa6185d225, + 0xb475166f94bbe9bb, + 0xa4143548720959f1, + 0x7aed4780ba6b26ba, + 0xd0ce264439e02312, + 0x84366d746078d508, + 0xa8ce973c72ed17be, + 0x21c323a29a430b01, + 0x9962d617e3af80ee, + 0xab0ce91d9c8cf75b, + 0x530e8ee6d19a4dbc, + 0x2ef68c0cf53f5d72, + 0xc03a681640a85506, + 0x496e4e9f9c310967, + 0x78580472b59b14a0, + 0x273824c23b388577, + 0x66bf923ad45cb553, + 0x47ae1a5a2492ba86, + 0x35e304569e229659, + 0x4765182a46870b6f, + 0x6cbab625e9099412, + 0xddac9a2e598522c1, + 0x7172086e666624f2, + 0xdf5003ca503b7837, + 0x88c0c1db78563d09, + 0x58d51865acfc289d, + 0x177671aec65224f1, + 0xfb79d8a241e967d7, + 0x2be1e101cad9a49a, + 0x6625682f6e29186b, + 0x399553457ac06e50, + 0x35dffb4c23abb74, + 0x429db2591f54aade, + 0xc52802a8037d1009, + 0x6acb27381f0b25f3, + 0xf45e2551ee4f823b, + 0x8b0ea2d99580c2f7, + 0x3bed519cbcb4e1e1, + 0xff452823dbb010a, + 0x9d42ed614f3dd267, + 0x5b9313c06257c57b, + 0xa114b8008b5e1442, + 0xc1fe311c11c13d4b, + 0x66e8763ea34c5568, + 0x8b982af1c262f05d, + 0xee8876faaa75fbb7, + 0x8a62a4d0d172bb2a, + 0xc13d94a3b7449a97, + 0x6dbbba9dc15d037c, + 0xc786101f1d92e0f1, + 0xd78681a907a0b79b, + 0xf61aaf2962c9abb9, + 0x2cfd16fcd3cb7ad9, + 0x868c5b6744624d21, + 0x25e650899c74ddd7, + 0xba042af4a7c37463, + 0x4eb1a539465a3eca, + 0xbe09dbf03b05d5ca, + 0x774e5a362b5472ba, + 0x47a1221229d183cd, + 0x504b0ca18ef5a2df, + 0xdffbdfbde2456eb9, + 0x46cd2b2fbee34634, + 0xf2aef8fe819d98c3, + 0x357f5276d4599d61, + 0x24a5483879c453e3, + 0x88026889192b4b9, + 0x28da96671782dbec, + 0x4ef37c40588e9aaa, + 0x8837b90651bc9fb3, + 0xc164f741d3f0e5d6, + 0xbc135a0a704b70ba, + 0x69cd868f7622ada, + 0xbc37ba89e0b9c0ab, + 0x47c14a01323552f6, + 0x4f00794bacee98bb, + 0x7107de7d637a69d5, + 0x88af793bb6f2255e, + 0xf3c6466b8799b598, + 0xc288c616aa7f3b59, + 0x81ca63cf42fca3fd, + 0x88d85ace36a2674b, + 0xd056bd3792389e7, + 0xe55c396c4e9dd32d, + 0xbefb504571e6c0a6, + 0x96ab32115e91e8cc, + 0xbf8acb18de8f38d1, + 0x66dae58801672606, + 0x833b6017872317fb, + 0xb87c16f2d1c92864, + 0xdb766a74e58b669c, + 0x89659f85c61417be, + 0xc8daad856011ea0c, + 0x76a4b565b6fe7eae, + 0xa469d085f6237312, + 0xaaf0365683a3e96c, + 0x4dbb746f8424f7b8, + 0x638755af4e4acc1, + 0x3d7807f5bde64486, + 0x17be6d8f5bbb7639, + 0x903f0cd44dc35dc, + 0x67b672eafdf1196c, + 0xa676ff93ed4c82f1, + 0x521d1004c5053d9d, + 0x37ba9ad09ccc9202, + 0x84e54d297aacfb51, + 0xa0b4b776a143445, + 0x820d471e20b348e, + 0x1874383cb83d46dc, + 0x97edeec7a1efe11c, + 0xb330e50b1bdc42aa, + 0x1dd91955ce70e032, + 0xa514cdb88f2939d5, + 0x2791233fd90db9d3, + 0x7b670a4cc50f7a9b, + 0x77c07d2a05c6dfa5, + 0xe3778b6646d0a6fa, + 0xb39c8eda47b56749, + 0x933ed448addbef28, + 0xaf846af6ab7d0bf4, + 0xe5af208eb666e49, + 0x5e6622f73534cd6a, + 0x297daeca42ef5b6e, + 0x862daef3d35539a6, + 0xe68722498f8e1ea9, + 0x981c53093dc0d572, + 0xfa09b0bfbf86fbf5, + 0x30b1e96166219f15, + 0x70e7d466bdc4fb83, + 0x5a66736e35f2a8e9, + 0xcddb59d2b7c1baef, + 0xd6c7d247d26d8996, + 0xea4e39eac8de1ba3, + 0x539c8bb19fa3aff2, + 0x9f90e4c5fd508d8, + 0xa34e5956fbaf3385, + 0x2e2f8e151d3ef375, + 0x173691e9b83faec1, + 0xb85a8d56bf016379, + 0x8382381267408ae3, + 0xb90f901bbdc0096d, + 0x7c6ad32933bcec65, + 0x76bb5e2f2c8ad595, + 0x390f851a6cf46d28, + 0xc3e6064da1c2da72, + 0xc52a0c101cfa5389, + 0xd78eaf84a3fbc530, + 0x3781b9e2288b997e, + 0x73c2f6dea83d05c4, + 0x4228e364c5b5ed7, + 0x9d7a3edf0da43911, + 0x8edcfeda24686756, + 0x5e7667a7b7a9b3a1, + 0x4c4f389fa143791d, + 0xb08bc1023da7cddc, + 0x7ab4be3ae529b1cc, + 0x754e6132dbe74ff9, + 0x71635442a839df45, + 0x2f6fb1643fbe52de, + 0x961e0a42cf7a8177, + 0xf3b45d83d89ef2ea, + 0xee3de4cf4a6e3e9b, + 0xcd6848542c3295e7, + 0xe4cee1664c78662f, + 0x9947548b474c68c4, + 0x25d73777a5ed8b0b, + 0xc915b1d636b7fc, + 0x21c2ba75d9b0d2da, + 0x5f6b5dcf608a64a1, + 0xdcf333255ff9570c, + 0x633b922418ced4ee, + 0xc136dde0b004b34a, + 0x58cc83b05d4b2f5a, + 0x5eb424dda28e42d2, + 0x62df47369739cd98, + 0xb4e0b42485e4ce17, + 0x16e1f0c1f9a8d1e7, + 0x8ec3916707560ebf, + 0x62ba6e2df2cc9db3, + 0xcbf9f4ff77d83a16, + 0x78d9d7d07d2bbcc4, + 0xef554ce1e02c41f4, + 0x8d7581127eccf94d, + 0xa9b53336cb3c8a05, + 0x38c42c0bf45c4f91, + 0x640893cdf4488863, + 0x80ec34bc575ea568, + 0x39f324f5b48eaa40, + 0xe9d9ed1f8eff527f, + 0x9224fc058cc5a214, + 0xbaba00b04cfe7741, + 0x309a9f120fcf52af, + 0xa558f3ec65626212, + 0x424bec8b7adabe2f, + 0x41622513a6aea433, + 0xb88da2d5324ca798, + 0xd287733b245528a4, + 0x9a44697e6d68aec3, + 0x7b1093be2f49bb28, + 0x50bbec632e3d8aad, + 0x6cd90723e1ea8283, + 0x897b9e7431b02bf3, + 0x219efdcb338a7047, + 0x3b0311f0a27c0656, + 0xdb17bf91c0db96e7, + 0x8cd4fd6b4e85a5b2, + 0xfab071054ba6409d, + 0x40d6fe831fa9dfd9, + 0xaf358debad7d791e, + 0xeb8d0e25a65e3e58, + 0xbbcbd3df14e08580, + 0xcf751f27ecdab2b, + 0x2b4da14f2613d8f4, + }; + private static ulong* ZSTD_ldm_gearTab => + (ulong*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_ZSTD_ldm_gearTab) + ); +#else + + private static readonly ulong* ZSTD_ldm_gearTab = GetArrayPointer( + new ulong[256] + { + 0xf5b8f72c5f77775c, + 0x84935f266b7ac412, + 0xb647ada9ca730ccc, + 0xb065bb4b114fb1de, + 0x34584e7e8c3a9fd0, + 0x4e97e17c6ae26b05, + 0x3a03d743bc99a604, + 0xcecd042422c4044f, + 0x76de76c58524259e, + 0x9c8528f65badeaca, + 0x86563706e2097529, + 0x2902475fa375d889, + 0xafb32a9739a5ebe6, + 0xce2714da3883e639, + 0x21eaf821722e69e, + 0x37b628620b628, + 0x49a8d455d88caf5, + 0x8556d711e6958140, + 0x4f7ae74fc605c1f, + 0x829f0c3468bd3a20, + 0x4ffdc885c625179e, + 0x8473de048a3daf1b, + 0x51008822b05646b2, + 0x69d75d12b2d1cc5f, + 0x8c9d4a19159154bc, + 0xc3cc10f4abbd4003, + 0xd06ddc1cecb97391, + 0xbe48e6e7ed80302e, + 0x3481db31cee03547, + 0xacc3f67cdaa1d210, + 0x65cb771d8c7f96cc, + 0x8eb27177055723dd, + 0xc789950d44cd94be, + 0x934feadc3700b12b, + 0x5e485f11edbdf182, + 0x1e2e2a46fd64767a, + 0x2969ca71d82efa7c, + 0x9d46e9935ebbba2e, + 0xe056b67e05e6822b, + 0x94d73f55739d03a0, + 0xcd7010bdb69b5a03, + 0x455ef9fcd79b82f4, + 0x869cb54a8749c161, + 0x38d1a4fa6185d225, + 0xb475166f94bbe9bb, + 0xa4143548720959f1, + 0x7aed4780ba6b26ba, + 0xd0ce264439e02312, + 0x84366d746078d508, + 0xa8ce973c72ed17be, + 0x21c323a29a430b01, + 0x9962d617e3af80ee, + 0xab0ce91d9c8cf75b, + 0x530e8ee6d19a4dbc, + 0x2ef68c0cf53f5d72, + 0xc03a681640a85506, + 0x496e4e9f9c310967, + 0x78580472b59b14a0, + 0x273824c23b388577, + 0x66bf923ad45cb553, + 0x47ae1a5a2492ba86, + 0x35e304569e229659, + 0x4765182a46870b6f, + 0x6cbab625e9099412, + 0xddac9a2e598522c1, + 0x7172086e666624f2, + 0xdf5003ca503b7837, + 0x88c0c1db78563d09, + 0x58d51865acfc289d, + 0x177671aec65224f1, + 0xfb79d8a241e967d7, + 0x2be1e101cad9a49a, + 0x6625682f6e29186b, + 0x399553457ac06e50, + 0x35dffb4c23abb74, + 0x429db2591f54aade, + 0xc52802a8037d1009, + 0x6acb27381f0b25f3, + 0xf45e2551ee4f823b, + 0x8b0ea2d99580c2f7, + 0x3bed519cbcb4e1e1, + 0xff452823dbb010a, + 0x9d42ed614f3dd267, + 0x5b9313c06257c57b, + 0xa114b8008b5e1442, + 0xc1fe311c11c13d4b, + 0x66e8763ea34c5568, + 0x8b982af1c262f05d, + 0xee8876faaa75fbb7, + 0x8a62a4d0d172bb2a, + 0xc13d94a3b7449a97, + 0x6dbbba9dc15d037c, + 0xc786101f1d92e0f1, + 0xd78681a907a0b79b, + 0xf61aaf2962c9abb9, + 0x2cfd16fcd3cb7ad9, + 0x868c5b6744624d21, + 0x25e650899c74ddd7, + 0xba042af4a7c37463, + 0x4eb1a539465a3eca, + 0xbe09dbf03b05d5ca, + 0x774e5a362b5472ba, + 0x47a1221229d183cd, + 0x504b0ca18ef5a2df, + 0xdffbdfbde2456eb9, + 0x46cd2b2fbee34634, + 0xf2aef8fe819d98c3, + 0x357f5276d4599d61, + 0x24a5483879c453e3, + 0x88026889192b4b9, + 0x28da96671782dbec, + 0x4ef37c40588e9aaa, + 0x8837b90651bc9fb3, + 0xc164f741d3f0e5d6, + 0xbc135a0a704b70ba, + 0x69cd868f7622ada, + 0xbc37ba89e0b9c0ab, + 0x47c14a01323552f6, + 0x4f00794bacee98bb, + 0x7107de7d637a69d5, + 0x88af793bb6f2255e, + 0xf3c6466b8799b598, + 0xc288c616aa7f3b59, + 0x81ca63cf42fca3fd, + 0x88d85ace36a2674b, + 0xd056bd3792389e7, + 0xe55c396c4e9dd32d, + 0xbefb504571e6c0a6, + 0x96ab32115e91e8cc, + 0xbf8acb18de8f38d1, + 0x66dae58801672606, + 0x833b6017872317fb, + 0xb87c16f2d1c92864, + 0xdb766a74e58b669c, + 0x89659f85c61417be, + 0xc8daad856011ea0c, + 0x76a4b565b6fe7eae, + 0xa469d085f6237312, + 0xaaf0365683a3e96c, + 0x4dbb746f8424f7b8, + 0x638755af4e4acc1, + 0x3d7807f5bde64486, + 0x17be6d8f5bbb7639, + 0x903f0cd44dc35dc, + 0x67b672eafdf1196c, + 0xa676ff93ed4c82f1, + 0x521d1004c5053d9d, + 0x37ba9ad09ccc9202, + 0x84e54d297aacfb51, + 0xa0b4b776a143445, + 0x820d471e20b348e, + 0x1874383cb83d46dc, + 0x97edeec7a1efe11c, + 0xb330e50b1bdc42aa, + 0x1dd91955ce70e032, + 0xa514cdb88f2939d5, + 0x2791233fd90db9d3, + 0x7b670a4cc50f7a9b, + 0x77c07d2a05c6dfa5, + 0xe3778b6646d0a6fa, + 0xb39c8eda47b56749, + 0x933ed448addbef28, + 0xaf846af6ab7d0bf4, + 0xe5af208eb666e49, + 0x5e6622f73534cd6a, + 0x297daeca42ef5b6e, + 0x862daef3d35539a6, + 0xe68722498f8e1ea9, + 0x981c53093dc0d572, + 0xfa09b0bfbf86fbf5, + 0x30b1e96166219f15, + 0x70e7d466bdc4fb83, + 0x5a66736e35f2a8e9, + 0xcddb59d2b7c1baef, + 0xd6c7d247d26d8996, + 0xea4e39eac8de1ba3, + 0x539c8bb19fa3aff2, + 0x9f90e4c5fd508d8, + 0xa34e5956fbaf3385, + 0x2e2f8e151d3ef375, + 0x173691e9b83faec1, + 0xb85a8d56bf016379, + 0x8382381267408ae3, + 0xb90f901bbdc0096d, + 0x7c6ad32933bcec65, + 0x76bb5e2f2c8ad595, + 0x390f851a6cf46d28, + 0xc3e6064da1c2da72, + 0xc52a0c101cfa5389, + 0xd78eaf84a3fbc530, + 0x3781b9e2288b997e, + 0x73c2f6dea83d05c4, + 0x4228e364c5b5ed7, + 0x9d7a3edf0da43911, + 0x8edcfeda24686756, + 0x5e7667a7b7a9b3a1, + 0x4c4f389fa143791d, + 0xb08bc1023da7cddc, + 0x7ab4be3ae529b1cc, + 0x754e6132dbe74ff9, + 0x71635442a839df45, + 0x2f6fb1643fbe52de, + 0x961e0a42cf7a8177, + 0xf3b45d83d89ef2ea, + 0xee3de4cf4a6e3e9b, + 0xcd6848542c3295e7, + 0xe4cee1664c78662f, + 0x9947548b474c68c4, + 0x25d73777a5ed8b0b, + 0xc915b1d636b7fc, + 0x21c2ba75d9b0d2da, + 0x5f6b5dcf608a64a1, + 0xdcf333255ff9570c, + 0x633b922418ced4ee, + 0xc136dde0b004b34a, + 0x58cc83b05d4b2f5a, + 0x5eb424dda28e42d2, + 0x62df47369739cd98, + 0xb4e0b42485e4ce17, + 0x16e1f0c1f9a8d1e7, + 0x8ec3916707560ebf, + 0x62ba6e2df2cc9db3, + 0xcbf9f4ff77d83a16, + 0x78d9d7d07d2bbcc4, + 0xef554ce1e02c41f4, + 0x8d7581127eccf94d, + 0xa9b53336cb3c8a05, + 0x38c42c0bf45c4f91, + 0x640893cdf4488863, + 0x80ec34bc575ea568, + 0x39f324f5b48eaa40, + 0xe9d9ed1f8eff527f, + 0x9224fc058cc5a214, + 0xbaba00b04cfe7741, + 0x309a9f120fcf52af, + 0xa558f3ec65626212, + 0x424bec8b7adabe2f, + 0x41622513a6aea433, + 0xb88da2d5324ca798, + 0xd287733b245528a4, + 0x9a44697e6d68aec3, + 0x7b1093be2f49bb28, + 0x50bbec632e3d8aad, + 0x6cd90723e1ea8283, + 0x897b9e7431b02bf3, + 0x219efdcb338a7047, + 0x3b0311f0a27c0656, + 0xdb17bf91c0db96e7, + 0x8cd4fd6b4e85a5b2, + 0xfab071054ba6409d, + 0x40d6fe831fa9dfd9, + 0xaf358debad7d791e, + 0xeb8d0e25a65e3e58, + 0xbbcbd3df14e08580, + 0xcf751f27ecdab2b, + 0x2b4da14f2613d8f4, + } + ); +#endif +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdOpt.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdOpt.cs new file mode 100644 index 000000000..4b05bb17c --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdOpt.cs @@ -0,0 +1,2254 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /* ZSTD_bitWeight() : + * provide estimated "cost" of a stat in full bits only */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_bitWeight(uint stat) + { + return ZSTD_highbit32(stat + 1) * (1 << 8); + } + + /* ZSTD_fracWeight() : + * provide fractional-bit "cost" of a stat, + * using linear interpolation approximation */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_fracWeight(uint rawStat) + { + uint stat = rawStat + 1; + uint hb = ZSTD_highbit32(stat); + uint BWeight = hb * (1 << 8); + /* Fweight was meant for "Fractional weight" + * but it's effectively a value between 1 and 2 + * using fixed point arithmetic */ + uint FWeight = stat << 8 >> (int)hb; + uint weight = BWeight + FWeight; + assert(hb + 8 < 31); + return weight; + } + + private static int ZSTD_compressedLiterals(optState_t* optPtr) + { + return optPtr->literalCompressionMode != ZSTD_paramSwitch_e.ZSTD_ps_disable ? 1 : 0; + } + + private static void ZSTD_setBasePrices(optState_t* optPtr, int optLevel) + { + if (ZSTD_compressedLiterals(optPtr) != 0) + optPtr->litSumBasePrice = + optLevel != 0 ? ZSTD_fracWeight(optPtr->litSum) : ZSTD_bitWeight(optPtr->litSum); + optPtr->litLengthSumBasePrice = + optLevel != 0 + ? ZSTD_fracWeight(optPtr->litLengthSum) + : ZSTD_bitWeight(optPtr->litLengthSum); + optPtr->matchLengthSumBasePrice = + optLevel != 0 + ? ZSTD_fracWeight(optPtr->matchLengthSum) + : ZSTD_bitWeight(optPtr->matchLengthSum); + optPtr->offCodeSumBasePrice = + optLevel != 0 + ? ZSTD_fracWeight(optPtr->offCodeSum) + : ZSTD_bitWeight(optPtr->offCodeSum); + } + + private static uint sum_u32(uint* table, nuint nbElts) + { + nuint n; + uint total = 0; + for (n = 0; n < nbElts; n++) + { + total += table[n]; + } + + return total; + } + + private static uint ZSTD_downscaleStats( + uint* table, + uint lastEltIndex, + uint shift, + base_directive_e base1 + ) + { + uint s, + sum = 0; + assert(shift < 30); + for (s = 0; s < lastEltIndex + 1; s++) + { + uint @base = (uint)( + base1 != default ? 1 + : table[s] > 0 ? 1 + : 0 + ); + uint newStat = @base + (table[s] >> (int)shift); + sum += newStat; + table[s] = newStat; + } + + return sum; + } + + /* ZSTD_scaleStats() : + * reduce all elt frequencies in table if sum too large + * return the resulting sum of elements */ + private static uint ZSTD_scaleStats(uint* table, uint lastEltIndex, uint logTarget) + { + uint prevsum = sum_u32(table, lastEltIndex + 1); + uint factor = prevsum >> (int)logTarget; + assert(logTarget < 30); + if (factor <= 1) + return prevsum; + return ZSTD_downscaleStats( + table, + lastEltIndex, + ZSTD_highbit32(factor), + base_directive_e.base_1guaranteed + ); + } + +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_baseLLfreqs => + new uint[36] + { + 4, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + }; + private static uint* baseLLfreqs => + (uint*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_baseLLfreqs) + ); +#else + + private static readonly uint* baseLLfreqs = GetArrayPointer( + new uint[36] + { + 4, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + } + ); +#endif +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_baseOFCfreqs => + new uint[32] + { + 6, + 2, + 1, + 1, + 2, + 3, + 4, + 4, + 4, + 3, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + }; + private static uint* baseOFCfreqs => + (uint*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_baseOFCfreqs) + ); +#else + + private static readonly uint* baseOFCfreqs = GetArrayPointer( + new uint[32] + { + 6, + 2, + 1, + 1, + 2, + 3, + 4, + 4, + 4, + 3, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + } + ); +#endif + /* ZSTD_rescaleFreqs() : + * if first block (detected by optPtr->litLengthSum == 0) : init statistics + * take hints from dictionary if there is one + * and init from zero if there is none, + * using src for literals stats, and baseline stats for sequence symbols + * otherwise downscale existing stats, to be used as seed for next block. + */ + private static void ZSTD_rescaleFreqs( + optState_t* optPtr, + byte* src, + nuint srcSize, + int optLevel + ) + { + int compressedLiterals = ZSTD_compressedLiterals(optPtr); + optPtr->priceType = ZSTD_OptPrice_e.zop_dynamic; + if (optPtr->litLengthSum == 0) + { + if (srcSize <= 8) + { + optPtr->priceType = ZSTD_OptPrice_e.zop_predef; + } + + assert(optPtr->symbolCosts != null); + if (optPtr->symbolCosts->huf.repeatMode == HUF_repeat.HUF_repeat_valid) + { + optPtr->priceType = ZSTD_OptPrice_e.zop_dynamic; + if (compressedLiterals != 0) + { + /* generate literals statistics from huffman table */ + uint lit; + assert(optPtr->litFreq != null); + optPtr->litSum = 0; + for (lit = 0; lit <= (1 << 8) - 1; lit++) + { + /* scale to 2K */ + const uint scaleLog = 11; + uint bitCost = HUF_getNbBitsFromCTable( + &optPtr->symbolCosts->huf.CTable.e0, + lit + ); + assert(bitCost <= scaleLog); + optPtr->litFreq[lit] = (uint)( + bitCost != 0 ? 1 << (int)(scaleLog - bitCost) : 1 + ); + optPtr->litSum += optPtr->litFreq[lit]; + } + } + + { + uint ll; + FSE_CState_t llstate; + FSE_initCState(&llstate, optPtr->symbolCosts->fse.litlengthCTable); + optPtr->litLengthSum = 0; + for (ll = 0; ll <= 35; ll++) + { + /* scale to 1K */ + const uint scaleLog = 10; + uint bitCost = FSE_getMaxNbBits(llstate.symbolTT, ll); + assert(bitCost < scaleLog); + optPtr->litLengthFreq[ll] = (uint)( + bitCost != 0 ? 1 << (int)(scaleLog - bitCost) : 1 + ); + optPtr->litLengthSum += optPtr->litLengthFreq[ll]; + } + } + + { + uint ml; + FSE_CState_t mlstate; + FSE_initCState(&mlstate, optPtr->symbolCosts->fse.matchlengthCTable); + optPtr->matchLengthSum = 0; + for (ml = 0; ml <= 52; ml++) + { + const uint scaleLog = 10; + uint bitCost = FSE_getMaxNbBits(mlstate.symbolTT, ml); + assert(bitCost < scaleLog); + optPtr->matchLengthFreq[ml] = (uint)( + bitCost != 0 ? 1 << (int)(scaleLog - bitCost) : 1 + ); + optPtr->matchLengthSum += optPtr->matchLengthFreq[ml]; + } + } + + { + uint of; + FSE_CState_t ofstate; + FSE_initCState(&ofstate, optPtr->symbolCosts->fse.offcodeCTable); + optPtr->offCodeSum = 0; + for (of = 0; of <= 31; of++) + { + const uint scaleLog = 10; + uint bitCost = FSE_getMaxNbBits(ofstate.symbolTT, of); + assert(bitCost < scaleLog); + optPtr->offCodeFreq[of] = (uint)( + bitCost != 0 ? 1 << (int)(scaleLog - bitCost) : 1 + ); + optPtr->offCodeSum += optPtr->offCodeFreq[of]; + } + } + } + else + { + assert(optPtr->litFreq != null); + if (compressedLiterals != 0) + { + /* base initial cost of literals on direct frequency within src */ + uint lit = (1 << 8) - 1; + HIST_count_simple(optPtr->litFreq, &lit, src, srcSize); + optPtr->litSum = ZSTD_downscaleStats( + optPtr->litFreq, + (1 << 8) - 1, + 8, + base_directive_e.base_0possible + ); + } + + { + memcpy(optPtr->litLengthFreq, baseLLfreqs, sizeof(uint) * 36); + optPtr->litLengthSum = sum_u32(baseLLfreqs, 35 + 1); + } + + { + uint ml; + for (ml = 0; ml <= 52; ml++) + optPtr->matchLengthFreq[ml] = 1; + } + + optPtr->matchLengthSum = 52 + 1; + { + memcpy(optPtr->offCodeFreq, baseOFCfreqs, sizeof(uint) * 32); + optPtr->offCodeSum = sum_u32(baseOFCfreqs, 31 + 1); + } + } + } + else + { + if (compressedLiterals != 0) + optPtr->litSum = ZSTD_scaleStats(optPtr->litFreq, (1 << 8) - 1, 12); + optPtr->litLengthSum = ZSTD_scaleStats(optPtr->litLengthFreq, 35, 11); + optPtr->matchLengthSum = ZSTD_scaleStats(optPtr->matchLengthFreq, 52, 11); + optPtr->offCodeSum = ZSTD_scaleStats(optPtr->offCodeFreq, 31, 11); + } + + ZSTD_setBasePrices(optPtr, optLevel); + } + + /* ZSTD_rawLiteralsCost() : + * price of literals (only) in specified segment (which length can be 0). + * does not include price of literalLength symbol */ + private static uint ZSTD_rawLiteralsCost( + byte* literals, + uint litLength, + optState_t* optPtr, + int optLevel + ) + { + if (litLength == 0) + return 0; + if (ZSTD_compressedLiterals(optPtr) == 0) + return (litLength << 3) * (1 << 8); + if (optPtr->priceType == ZSTD_OptPrice_e.zop_predef) + return litLength * 6 * (1 << 8); + { + uint price = optPtr->litSumBasePrice * litLength; + uint litPriceMax = optPtr->litSumBasePrice - (1 << 8); + uint u; + assert(optPtr->litSumBasePrice >= 1 << 8); + for (u = 0; u < litLength; u++) + { + uint litPrice = + optLevel != 0 + ? ZSTD_fracWeight(optPtr->litFreq[literals[u]]) + : ZSTD_bitWeight(optPtr->litFreq[literals[u]]); + if (litPrice > litPriceMax) + litPrice = litPriceMax; + price -= litPrice; + } + + return price; + } + } + + /* ZSTD_litLengthPrice() : + * cost of literalLength symbol */ + private static uint ZSTD_litLengthPrice(uint litLength, optState_t* optPtr, int optLevel) + { + assert(litLength <= 1 << 17); + if (optPtr->priceType == ZSTD_OptPrice_e.zop_predef) + return optLevel != 0 ? ZSTD_fracWeight(litLength) : ZSTD_bitWeight(litLength); + if (litLength == 1 << 17) + return (1 << 8) + ZSTD_litLengthPrice((1 << 17) - 1, optPtr, optLevel); + { + uint llCode = ZSTD_LLcode(litLength); + return (uint)(LL_bits[llCode] * (1 << 8)) + + optPtr->litLengthSumBasePrice + - ( + optLevel != 0 + ? ZSTD_fracWeight(optPtr->litLengthFreq[llCode]) + : ZSTD_bitWeight(optPtr->litLengthFreq[llCode]) + ); + } + } + + /* ZSTD_getMatchPrice() : + * Provides the cost of the match part (offset + matchLength) of a sequence. + * Must be combined with ZSTD_fullLiteralsCost() to get the full cost of a sequence. + * @offBase : sumtype, representing an offset or a repcode, and using numeric representation of ZSTD_storeSeq() + * @optLevel: when <2, favors small offset for decompression speed (improved cache efficiency) + */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_getMatchPrice( + uint offBase, + uint matchLength, + optState_t* optPtr, + int optLevel + ) + { + uint price; + uint offCode = ZSTD_highbit32(offBase); + uint mlBase = matchLength - 3; + assert(matchLength >= 3); + if (optPtr->priceType == ZSTD_OptPrice_e.zop_predef) + return (optLevel != 0 ? ZSTD_fracWeight(mlBase) : ZSTD_bitWeight(mlBase)) + + (16 + offCode) * (1 << 8); + price = + offCode * (1 << 8) + + ( + optPtr->offCodeSumBasePrice + - ( + optLevel != 0 + ? ZSTD_fracWeight(optPtr->offCodeFreq[offCode]) + : ZSTD_bitWeight(optPtr->offCodeFreq[offCode]) + ) + ); + if (optLevel < 2 && offCode >= 20) + price += (offCode - 19) * 2 * (1 << 8); + { + uint mlCode = ZSTD_MLcode(mlBase); + price += + (uint)(ML_bits[mlCode] * (1 << 8)) + + ( + optPtr->matchLengthSumBasePrice + - ( + optLevel != 0 + ? ZSTD_fracWeight(optPtr->matchLengthFreq[mlCode]) + : ZSTD_bitWeight(optPtr->matchLengthFreq[mlCode]) + ) + ); + } + + price += (1 << 8) / 5; + return price; + } + + /* ZSTD_updateStats() : + * assumption : literals + litLength <= iend */ + private static void ZSTD_updateStats( + optState_t* optPtr, + uint litLength, + byte* literals, + uint offBase, + uint matchLength + ) + { + if (ZSTD_compressedLiterals(optPtr) != 0) + { + uint u; + for (u = 0; u < litLength; u++) + optPtr->litFreq[literals[u]] += 2; + optPtr->litSum += litLength * 2; + } + + { + uint llCode = ZSTD_LLcode(litLength); + optPtr->litLengthFreq[llCode]++; + optPtr->litLengthSum++; + } + + { + uint offCode = ZSTD_highbit32(offBase); + assert(offCode <= 31); + optPtr->offCodeFreq[offCode]++; + optPtr->offCodeSum++; + } + + { + uint mlBase = matchLength - 3; + uint mlCode = ZSTD_MLcode(mlBase); + optPtr->matchLengthFreq[mlCode]++; + optPtr->matchLengthSum++; + } + } + + /* ZSTD_readMINMATCH() : + * function safe only for comparisons + * assumption : memPtr must be at least 4 bytes before end of buffer */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_readMINMATCH(void* memPtr, uint length) + { + switch (length) + { + default: + case 4: + return MEM_read32(memPtr); + case 3: + if (BitConverter.IsLittleEndian) + return MEM_read32(memPtr) << 8; + else + return MEM_read32(memPtr) >> 8; + } + } + + /* Update hashTable3 up to ip (excluded) + Assumption : always within prefix (i.e. not within extDict) */ + private static uint ZSTD_insertAndFindFirstIndexHash3( + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip + ) + { + uint* hashTable3 = ms->hashTable3; + uint hashLog3 = ms->hashLog3; + byte* @base = ms->window.@base; + uint idx = *nextToUpdate3; + uint target = (uint)(ip - @base); + nuint hash3 = ZSTD_hash3Ptr(ip, hashLog3); + assert(hashLog3 > 0); + while (idx < target) + { + hashTable3[ZSTD_hash3Ptr(@base + idx, hashLog3)] = idx; + idx++; + } + + *nextToUpdate3 = target; + return hashTable3[hash3]; + } + + /*-************************************* + * Binary Tree search + ***************************************/ + /** ZSTD_insertBt1() : add one or multiple positions to tree. + * @param ip assumed <= iend-8 . + * @param target The target of ZSTD_updateTree_internal() - we are filling to this position + * @return : nb of positions added */ + private static uint ZSTD_insertBt1( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iend, + uint target, + uint mls, + int extDict + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint* hashTable = ms->hashTable; + uint hashLog = cParams->hashLog; + nuint h = ZSTD_hashPtr(ip, hashLog, mls); + uint* bt = ms->chainTable; + uint btLog = cParams->chainLog - 1; + uint btMask = (uint)((1 << (int)btLog) - 1); + uint matchIndex = hashTable[h]; + nuint commonLengthSmaller = 0, + commonLengthLarger = 0; + byte* @base = ms->window.@base; + byte* dictBase = ms->window.dictBase; + uint dictLimit = ms->window.dictLimit; + byte* dictEnd = dictBase + dictLimit; + byte* prefixStart = @base + dictLimit; + byte* match; + uint curr = (uint)(ip - @base); + uint btLow = btMask >= curr ? 0 : curr - btMask; + uint* smallerPtr = bt + 2 * (curr & btMask); + uint* largerPtr = smallerPtr + 1; + /* to be nullified at the end */ + uint dummy32; + /* windowLow is based on target because + * we only need positions that will be in the window at the end of the tree update. + */ + uint windowLow = ZSTD_getLowestMatchIndex(ms, target, cParams->windowLog); + uint matchEndIdx = curr + 8 + 1; + nuint bestLength = 8; + uint nbCompares = 1U << (int)cParams->searchLog; + assert(curr <= target); + assert(ip <= iend - 8); + hashTable[h] = curr; + assert(windowLow > 0); + for (; nbCompares != 0 && matchIndex >= windowLow; --nbCompares) + { + uint* nextPtr = bt + 2 * (matchIndex & btMask); + /* guaranteed minimum nb of common bytes */ + nuint matchLength = + commonLengthSmaller < commonLengthLarger ? commonLengthSmaller : commonLengthLarger; + assert(matchIndex < curr); + if (extDict == 0 || matchIndex + matchLength >= dictLimit) + { + assert(matchIndex + matchLength >= dictLimit); + match = @base + matchIndex; + matchLength += ZSTD_count(ip + matchLength, match + matchLength, iend); + } + else + { + match = dictBase + matchIndex; + matchLength += ZSTD_count_2segments( + ip + matchLength, + match + matchLength, + iend, + dictEnd, + prefixStart + ); + if (matchIndex + matchLength >= dictLimit) + match = @base + matchIndex; + } + + if (matchLength > bestLength) + { + bestLength = matchLength; + if (matchLength > matchEndIdx - matchIndex) + matchEndIdx = matchIndex + (uint)matchLength; + } + + if (ip + matchLength == iend) + { + break; + } + + if (match[matchLength] < ip[matchLength]) + { + *smallerPtr = matchIndex; + commonLengthSmaller = matchLength; + if (matchIndex <= btLow) + { + smallerPtr = &dummy32; + break; + } + + smallerPtr = nextPtr + 1; + matchIndex = nextPtr[1]; + } + else + { + *largerPtr = matchIndex; + commonLengthLarger = matchLength; + if (matchIndex <= btLow) + { + largerPtr = &dummy32; + break; + } + + largerPtr = nextPtr; + matchIndex = nextPtr[0]; + } + } + + *smallerPtr = *largerPtr = 0; + { + uint positions = 0; + if (bestLength > 384) + positions = 192 < (uint)(bestLength - 384) ? 192 : (uint)(bestLength - 384); + assert(matchEndIdx > curr + 8); + return positions > matchEndIdx - (curr + 8) ? positions : matchEndIdx - (curr + 8); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void ZSTD_updateTree_internal( + ZSTD_MatchState_t* ms, + byte* ip, + byte* iend, + uint mls, + ZSTD_dictMode_e dictMode + ) + { + byte* @base = ms->window.@base; + uint target = (uint)(ip - @base); + uint idx = ms->nextToUpdate; + while (idx < target) + { + uint forward = ZSTD_insertBt1( + ms, + @base + idx, + iend, + target, + mls, + dictMode == ZSTD_dictMode_e.ZSTD_extDict ? 1 : 0 + ); + assert(idx < idx + forward); + idx += forward; + } + + assert((nuint)(ip - @base) <= unchecked((uint)-1)); + assert((nuint)(iend - @base) <= unchecked((uint)-1)); + ms->nextToUpdate = target; + } + + /* used in ZSTD_loadDictionaryContent() */ + private static void ZSTD_updateTree(ZSTD_MatchState_t* ms, byte* ip, byte* iend) + { + ZSTD_updateTree_internal(ms, ip, iend, ms->cParams.minMatch, ZSTD_dictMode_e.ZSTD_noDict); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_insertBtAndGetAllMatches( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iLimit, + ZSTD_dictMode_e dictMode, + uint* rep, + uint ll0, + uint lengthToBeat, + uint mls + ) + { + ZSTD_compressionParameters* cParams = &ms->cParams; + uint sufficient_len = + cParams->targetLength < (1 << 12) - 1 ? cParams->targetLength : (1 << 12) - 1; + byte* @base = ms->window.@base; + uint curr = (uint)(ip - @base); + uint hashLog = cParams->hashLog; + uint minMatch = (uint)(mls == 3 ? 3 : 4); + uint* hashTable = ms->hashTable; + nuint h = ZSTD_hashPtr(ip, hashLog, mls); + uint matchIndex = hashTable[h]; + uint* bt = ms->chainTable; + uint btLog = cParams->chainLog - 1; + uint btMask = (1U << (int)btLog) - 1; + nuint commonLengthSmaller = 0, + commonLengthLarger = 0; + byte* dictBase = ms->window.dictBase; + uint dictLimit = ms->window.dictLimit; + byte* dictEnd = dictBase + dictLimit; + byte* prefixStart = @base + dictLimit; + uint btLow = btMask >= curr ? 0 : curr - btMask; + uint windowLow = ZSTD_getLowestMatchIndex(ms, curr, cParams->windowLog); + uint matchLow = windowLow != 0 ? windowLow : 1; + uint* smallerPtr = bt + 2 * (curr & btMask); + uint* largerPtr = bt + 2 * (curr & btMask) + 1; + /* farthest referenced position of any match => detects repetitive patterns */ + uint matchEndIdx = curr + 8 + 1; + /* to be nullified at the end */ + uint dummy32; + uint mnum = 0; + uint nbCompares = 1U << (int)cParams->searchLog; + ZSTD_MatchState_t* dms = + dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState ? ms->dictMatchState : null; + ZSTD_compressionParameters* dmsCParams = + dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState ? &dms->cParams : null; + byte* dmsBase = dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState ? dms->window.@base : null; + byte* dmsEnd = dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState ? dms->window.nextSrc : null; + uint dmsHighLimit = + dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState ? (uint)(dmsEnd - dmsBase) : 0; + uint dmsLowLimit = + dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState ? dms->window.lowLimit : 0; + uint dmsIndexDelta = + dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState ? windowLow - dmsHighLimit : 0; + uint dmsHashLog = + dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState ? dmsCParams->hashLog : hashLog; + uint dmsBtLog = + dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState ? dmsCParams->chainLog - 1 : btLog; + uint dmsBtMask = + dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState ? (1U << (int)dmsBtLog) - 1 : 0; + uint dmsBtLow = + dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState + && dmsBtMask < dmsHighLimit - dmsLowLimit + ? dmsHighLimit - dmsBtMask + : dmsLowLimit; + nuint bestLength = lengthToBeat - 1; + assert(ll0 <= 1); + { + uint lastR = 3 + ll0; + uint repCode; + for (repCode = ll0; repCode < lastR; repCode++) + { + uint repOffset = repCode == 3 ? rep[0] - 1 : rep[repCode]; + uint repIndex = curr - repOffset; + uint repLen = 0; + assert(curr >= dictLimit); + if (repOffset - 1 < curr - dictLimit) + { + if ( + repIndex >= windowLow + && ZSTD_readMINMATCH(ip, minMatch) + == ZSTD_readMINMATCH(ip - repOffset, minMatch) + ) + { + repLen = + (uint)ZSTD_count(ip + minMatch, ip + minMatch - repOffset, iLimit) + + minMatch; + } + } + else + { + byte* repMatch = + dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState + ? dmsBase + repIndex - dmsIndexDelta + : dictBase + repIndex; + assert(curr >= windowLow); + if ( + dictMode == ZSTD_dictMode_e.ZSTD_extDict + && ( + (repOffset - 1 < curr - windowLow ? 1 : 0) + & ZSTD_index_overlap_check(dictLimit, repIndex) + ) != 0 + && ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch) + ) + { + repLen = + (uint)ZSTD_count_2segments( + ip + minMatch, + repMatch + minMatch, + iLimit, + dictEnd, + prefixStart + ) + minMatch; + } + + if ( + dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState + && ( + (repOffset - 1 < curr - (dmsLowLimit + dmsIndexDelta) ? 1 : 0) + & ZSTD_index_overlap_check(dictLimit, repIndex) + ) != 0 + && ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch) + ) + { + repLen = + (uint)ZSTD_count_2segments( + ip + minMatch, + repMatch + minMatch, + iLimit, + dmsEnd, + prefixStart + ) + minMatch; + } + } + + if (repLen > bestLength) + { + bestLength = repLen; + assert(repCode - ll0 + 1 >= 1); + assert(repCode - ll0 + 1 <= 3); + matches[mnum].off = repCode - ll0 + 1; + matches[mnum].len = repLen; + mnum++; + if (repLen > sufficient_len || ip + repLen == iLimit) + { + return mnum; + } + } + } + } + + if (mls == 3 && bestLength < mls) + { + uint matchIndex3 = ZSTD_insertAndFindFirstIndexHash3(ms, nextToUpdate3, ip); + if (matchIndex3 >= matchLow && curr - matchIndex3 < 1 << 18) + { + nuint mlen; + if ( + dictMode == ZSTD_dictMode_e.ZSTD_noDict + || dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState + || matchIndex3 >= dictLimit + ) + { + byte* match = @base + matchIndex3; + mlen = ZSTD_count(ip, match, iLimit); + } + else + { + byte* match = dictBase + matchIndex3; + mlen = ZSTD_count_2segments(ip, match, iLimit, dictEnd, prefixStart); + } + + if (mlen >= mls) + { + bestLength = mlen; + assert(curr > matchIndex3); + assert(mnum == 0); + assert(curr - matchIndex3 > 0); + matches[0].off = curr - matchIndex3 + 3; + matches[0].len = (uint)mlen; + mnum = 1; + if (mlen > sufficient_len || ip + mlen == iLimit) + { + ms->nextToUpdate = curr + 1; + return 1; + } + } + } + } + + hashTable[h] = curr; + for (; nbCompares != 0 && matchIndex >= matchLow; --nbCompares) + { + uint* nextPtr = bt + 2 * (matchIndex & btMask); + byte* match; + /* guaranteed minimum nb of common bytes */ + nuint matchLength = + commonLengthSmaller < commonLengthLarger ? commonLengthSmaller : commonLengthLarger; + assert(curr > matchIndex); + if ( + dictMode == ZSTD_dictMode_e.ZSTD_noDict + || dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState + || matchIndex + matchLength >= dictLimit + ) + { + assert(matchIndex + matchLength >= dictLimit); + match = @base + matchIndex; +#if DEBUG + if (matchIndex >= dictLimit) + assert(memcmp(match, ip, matchLength) == 0); +#endif + matchLength += ZSTD_count(ip + matchLength, match + matchLength, iLimit); + } + else + { + match = dictBase + matchIndex; + assert(memcmp(match, ip, matchLength) == 0); + matchLength += ZSTD_count_2segments( + ip + matchLength, + match + matchLength, + iLimit, + dictEnd, + prefixStart + ); + if (matchIndex + matchLength >= dictLimit) + match = @base + matchIndex; + } + + if (matchLength > bestLength) + { + assert(matchEndIdx > matchIndex); + if (matchLength > matchEndIdx - matchIndex) + matchEndIdx = matchIndex + (uint)matchLength; + bestLength = matchLength; + assert(curr - matchIndex > 0); + matches[mnum].off = curr - matchIndex + 3; + matches[mnum].len = (uint)matchLength; + mnum++; + if (matchLength > 1 << 12 || ip + matchLength == iLimit) + { + if (dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState) + nbCompares = 0; + break; + } + } + + if (match[matchLength] < ip[matchLength]) + { + *smallerPtr = matchIndex; + commonLengthSmaller = matchLength; + if (matchIndex <= btLow) + { + smallerPtr = &dummy32; + break; + } + + smallerPtr = nextPtr + 1; + matchIndex = nextPtr[1]; + } + else + { + *largerPtr = matchIndex; + commonLengthLarger = matchLength; + if (matchIndex <= btLow) + { + largerPtr = &dummy32; + break; + } + + largerPtr = nextPtr; + matchIndex = nextPtr[0]; + } + } + + *smallerPtr = *largerPtr = 0; + assert(nbCompares <= 1U << (sizeof(nuint) == 4 ? 30 : 31) - 1); + if (dictMode == ZSTD_dictMode_e.ZSTD_dictMatchState && nbCompares != 0) + { + nuint dmsH = ZSTD_hashPtr(ip, dmsHashLog, mls); + uint dictMatchIndex = dms->hashTable[dmsH]; + uint* dmsBt = dms->chainTable; + commonLengthSmaller = commonLengthLarger = 0; + for (; nbCompares != 0 && dictMatchIndex > dmsLowLimit; --nbCompares) + { + uint* nextPtr = dmsBt + 2 * (dictMatchIndex & dmsBtMask); + /* guaranteed minimum nb of common bytes */ + nuint matchLength = + commonLengthSmaller < commonLengthLarger + ? commonLengthSmaller + : commonLengthLarger; + byte* match = dmsBase + dictMatchIndex; + matchLength += ZSTD_count_2segments( + ip + matchLength, + match + matchLength, + iLimit, + dmsEnd, + prefixStart + ); + if (dictMatchIndex + matchLength >= dmsHighLimit) + match = @base + dictMatchIndex + dmsIndexDelta; + if (matchLength > bestLength) + { + matchIndex = dictMatchIndex + dmsIndexDelta; + if (matchLength > matchEndIdx - matchIndex) + matchEndIdx = matchIndex + (uint)matchLength; + bestLength = matchLength; + assert(curr - matchIndex > 0); + matches[mnum].off = curr - matchIndex + 3; + matches[mnum].len = (uint)matchLength; + mnum++; + if (matchLength > 1 << 12 || ip + matchLength == iLimit) + { + break; + } + } + + if (dictMatchIndex <= dmsBtLow) + { + break; + } + + if (match[matchLength] < ip[matchLength]) + { + commonLengthSmaller = matchLength; + dictMatchIndex = nextPtr[1]; + } + else + { + commonLengthLarger = matchLength; + dictMatchIndex = nextPtr[0]; + } + } + } + + assert(matchEndIdx > curr + 8); + ms->nextToUpdate = matchEndIdx - 8; + return mnum; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint ZSTD_btGetAllMatches_internal( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iHighLimit, + uint* rep, + uint ll0, + uint lengthToBeat, + ZSTD_dictMode_e dictMode, + uint mls + ) + { + assert( + ( + ms->cParams.minMatch <= 3 ? 3 + : ms->cParams.minMatch <= 6 ? ms->cParams.minMatch + : 6 + ) == mls + ); + if (ip < ms->window.@base + ms->nextToUpdate) + return 0; + ZSTD_updateTree_internal(ms, ip, iHighLimit, mls, dictMode); + return ZSTD_insertBtAndGetAllMatches( + matches, + ms, + nextToUpdate3, + ip, + iHighLimit, + dictMode, + rep, + ll0, + lengthToBeat, + mls + ); + } + + private static uint ZSTD_btGetAllMatches_noDict_3( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iHighLimit, + uint* rep, + uint ll0, + uint lengthToBeat + ) + { + return ZSTD_btGetAllMatches_internal( + matches, + ms, + nextToUpdate3, + ip, + iHighLimit, + rep, + ll0, + lengthToBeat, + ZSTD_dictMode_e.ZSTD_noDict, + 3 + ); + } + + private static uint ZSTD_btGetAllMatches_noDict_4( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iHighLimit, + uint* rep, + uint ll0, + uint lengthToBeat + ) + { + return ZSTD_btGetAllMatches_internal( + matches, + ms, + nextToUpdate3, + ip, + iHighLimit, + rep, + ll0, + lengthToBeat, + ZSTD_dictMode_e.ZSTD_noDict, + 4 + ); + } + + private static uint ZSTD_btGetAllMatches_noDict_5( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iHighLimit, + uint* rep, + uint ll0, + uint lengthToBeat + ) + { + return ZSTD_btGetAllMatches_internal( + matches, + ms, + nextToUpdate3, + ip, + iHighLimit, + rep, + ll0, + lengthToBeat, + ZSTD_dictMode_e.ZSTD_noDict, + 5 + ); + } + + private static uint ZSTD_btGetAllMatches_noDict_6( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iHighLimit, + uint* rep, + uint ll0, + uint lengthToBeat + ) + { + return ZSTD_btGetAllMatches_internal( + matches, + ms, + nextToUpdate3, + ip, + iHighLimit, + rep, + ll0, + lengthToBeat, + ZSTD_dictMode_e.ZSTD_noDict, + 6 + ); + } + + private static uint ZSTD_btGetAllMatches_extDict_3( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iHighLimit, + uint* rep, + uint ll0, + uint lengthToBeat + ) + { + return ZSTD_btGetAllMatches_internal( + matches, + ms, + nextToUpdate3, + ip, + iHighLimit, + rep, + ll0, + lengthToBeat, + ZSTD_dictMode_e.ZSTD_extDict, + 3 + ); + } + + private static uint ZSTD_btGetAllMatches_extDict_4( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iHighLimit, + uint* rep, + uint ll0, + uint lengthToBeat + ) + { + return ZSTD_btGetAllMatches_internal( + matches, + ms, + nextToUpdate3, + ip, + iHighLimit, + rep, + ll0, + lengthToBeat, + ZSTD_dictMode_e.ZSTD_extDict, + 4 + ); + } + + private static uint ZSTD_btGetAllMatches_extDict_5( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iHighLimit, + uint* rep, + uint ll0, + uint lengthToBeat + ) + { + return ZSTD_btGetAllMatches_internal( + matches, + ms, + nextToUpdate3, + ip, + iHighLimit, + rep, + ll0, + lengthToBeat, + ZSTD_dictMode_e.ZSTD_extDict, + 5 + ); + } + + private static uint ZSTD_btGetAllMatches_extDict_6( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iHighLimit, + uint* rep, + uint ll0, + uint lengthToBeat + ) + { + return ZSTD_btGetAllMatches_internal( + matches, + ms, + nextToUpdate3, + ip, + iHighLimit, + rep, + ll0, + lengthToBeat, + ZSTD_dictMode_e.ZSTD_extDict, + 6 + ); + } + + private static uint ZSTD_btGetAllMatches_dictMatchState_3( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iHighLimit, + uint* rep, + uint ll0, + uint lengthToBeat + ) + { + return ZSTD_btGetAllMatches_internal( + matches, + ms, + nextToUpdate3, + ip, + iHighLimit, + rep, + ll0, + lengthToBeat, + ZSTD_dictMode_e.ZSTD_dictMatchState, + 3 + ); + } + + private static uint ZSTD_btGetAllMatches_dictMatchState_4( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iHighLimit, + uint* rep, + uint ll0, + uint lengthToBeat + ) + { + return ZSTD_btGetAllMatches_internal( + matches, + ms, + nextToUpdate3, + ip, + iHighLimit, + rep, + ll0, + lengthToBeat, + ZSTD_dictMode_e.ZSTD_dictMatchState, + 4 + ); + } + + private static uint ZSTD_btGetAllMatches_dictMatchState_5( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iHighLimit, + uint* rep, + uint ll0, + uint lengthToBeat + ) + { + return ZSTD_btGetAllMatches_internal( + matches, + ms, + nextToUpdate3, + ip, + iHighLimit, + rep, + ll0, + lengthToBeat, + ZSTD_dictMode_e.ZSTD_dictMatchState, + 5 + ); + } + + private static uint ZSTD_btGetAllMatches_dictMatchState_6( + ZSTD_match_t* matches, + ZSTD_MatchState_t* ms, + uint* nextToUpdate3, + byte* ip, + byte* iHighLimit, + uint* rep, + uint ll0, + uint lengthToBeat + ) + { + return ZSTD_btGetAllMatches_internal( + matches, + ms, + nextToUpdate3, + ip, + iHighLimit, + rep, + ll0, + lengthToBeat, + ZSTD_dictMode_e.ZSTD_dictMatchState, + 6 + ); + } + + private static readonly ZSTD_getAllMatchesFn[][] getAllMatchesFns = new ZSTD_getAllMatchesFn[ + 3 + ][] + { + new ZSTD_getAllMatchesFn[4] + { + ZSTD_btGetAllMatches_noDict_3, + ZSTD_btGetAllMatches_noDict_4, + ZSTD_btGetAllMatches_noDict_5, + ZSTD_btGetAllMatches_noDict_6, + }, + new ZSTD_getAllMatchesFn[4] + { + ZSTD_btGetAllMatches_extDict_3, + ZSTD_btGetAllMatches_extDict_4, + ZSTD_btGetAllMatches_extDict_5, + ZSTD_btGetAllMatches_extDict_6, + }, + new ZSTD_getAllMatchesFn[4] + { + ZSTD_btGetAllMatches_dictMatchState_3, + ZSTD_btGetAllMatches_dictMatchState_4, + ZSTD_btGetAllMatches_dictMatchState_5, + ZSTD_btGetAllMatches_dictMatchState_6, + }, + }; + + private static ZSTD_getAllMatchesFn ZSTD_selectBtGetAllMatches( + ZSTD_MatchState_t* ms, + ZSTD_dictMode_e dictMode + ) + { + uint mls = + ms->cParams.minMatch <= 3 ? 3 + : ms->cParams.minMatch <= 6 ? ms->cParams.minMatch + : 6; + assert((uint)dictMode < 3); + assert(mls - 3 < 4); + return getAllMatchesFns[(int)dictMode][mls - 3]; + } + + /* ZSTD_optLdm_skipRawSeqStoreBytes(): + * Moves forward in @rawSeqStore by @nbBytes, + * which will update the fields 'pos' and 'posInSequence'. + */ + private static void ZSTD_optLdm_skipRawSeqStoreBytes(RawSeqStore_t* rawSeqStore, nuint nbBytes) + { + uint currPos = (uint)(rawSeqStore->posInSequence + nbBytes); + while (currPos != 0 && rawSeqStore->pos < rawSeqStore->size) + { + rawSeq currSeq = rawSeqStore->seq[rawSeqStore->pos]; + if (currPos >= currSeq.litLength + currSeq.matchLength) + { + currPos -= currSeq.litLength + currSeq.matchLength; + rawSeqStore->pos++; + } + else + { + rawSeqStore->posInSequence = currPos; + break; + } + } + + if (currPos == 0 || rawSeqStore->pos == rawSeqStore->size) + { + rawSeqStore->posInSequence = 0; + } + } + + /* ZSTD_opt_getNextMatchAndUpdateSeqStore(): + * Calculates the beginning and end of the next match in the current block. + * Updates 'pos' and 'posInSequence' of the ldmSeqStore. + */ + private static void ZSTD_opt_getNextMatchAndUpdateSeqStore( + ZSTD_optLdm_t* optLdm, + uint currPosInBlock, + uint blockBytesRemaining + ) + { + rawSeq currSeq; + uint currBlockEndPos; + uint literalsBytesRemaining; + uint matchBytesRemaining; + if (optLdm->seqStore.size == 0 || optLdm->seqStore.pos >= optLdm->seqStore.size) + { + optLdm->startPosInBlock = 0xffffffff; + optLdm->endPosInBlock = 0xffffffff; + return; + } + + currSeq = optLdm->seqStore.seq[optLdm->seqStore.pos]; + assert(optLdm->seqStore.posInSequence <= currSeq.litLength + currSeq.matchLength); + currBlockEndPos = currPosInBlock + blockBytesRemaining; + literalsBytesRemaining = + optLdm->seqStore.posInSequence < currSeq.litLength + ? currSeq.litLength - (uint)optLdm->seqStore.posInSequence + : 0; + matchBytesRemaining = + literalsBytesRemaining == 0 + ? currSeq.matchLength - ((uint)optLdm->seqStore.posInSequence - currSeq.litLength) + : currSeq.matchLength; + if (literalsBytesRemaining >= blockBytesRemaining) + { + optLdm->startPosInBlock = 0xffffffff; + optLdm->endPosInBlock = 0xffffffff; + ZSTD_optLdm_skipRawSeqStoreBytes(&optLdm->seqStore, blockBytesRemaining); + return; + } + + optLdm->startPosInBlock = currPosInBlock + literalsBytesRemaining; + optLdm->endPosInBlock = optLdm->startPosInBlock + matchBytesRemaining; + optLdm->offset = currSeq.offset; + if (optLdm->endPosInBlock > currBlockEndPos) + { + optLdm->endPosInBlock = currBlockEndPos; + ZSTD_optLdm_skipRawSeqStoreBytes(&optLdm->seqStore, currBlockEndPos - currPosInBlock); + } + else + { + ZSTD_optLdm_skipRawSeqStoreBytes( + &optLdm->seqStore, + literalsBytesRemaining + matchBytesRemaining + ); + } + } + + /* ZSTD_optLdm_maybeAddMatch(): + * Adds a match if it's long enough, + * based on it's 'matchStartPosInBlock' and 'matchEndPosInBlock', + * into 'matches'. Maintains the correct ordering of 'matches'. + */ + private static void ZSTD_optLdm_maybeAddMatch( + ZSTD_match_t* matches, + uint* nbMatches, + ZSTD_optLdm_t* optLdm, + uint currPosInBlock, + uint minMatch + ) + { + uint posDiff = currPosInBlock - optLdm->startPosInBlock; + /* Note: ZSTD_match_t actually contains offBase and matchLength (before subtracting MINMATCH) */ + uint candidateMatchLength = optLdm->endPosInBlock - optLdm->startPosInBlock - posDiff; + if ( + currPosInBlock < optLdm->startPosInBlock + || currPosInBlock >= optLdm->endPosInBlock + || candidateMatchLength < minMatch + ) + { + return; + } + + if ( + *nbMatches == 0 + || candidateMatchLength > matches[*nbMatches - 1].len && *nbMatches < 1 << 12 + ) + { + assert(optLdm->offset > 0); + uint candidateOffBase = optLdm->offset + 3; + matches[*nbMatches].len = candidateMatchLength; + matches[*nbMatches].off = candidateOffBase; + (*nbMatches)++; + } + } + + /* ZSTD_optLdm_processMatchCandidate(): + * Wrapper function to update ldm seq store and call ldm functions as necessary. + */ + private static void ZSTD_optLdm_processMatchCandidate( + ZSTD_optLdm_t* optLdm, + ZSTD_match_t* matches, + uint* nbMatches, + uint currPosInBlock, + uint remainingBytes, + uint minMatch + ) + { + if (optLdm->seqStore.size == 0 || optLdm->seqStore.pos >= optLdm->seqStore.size) + { + return; + } + + if (currPosInBlock >= optLdm->endPosInBlock) + { + if (currPosInBlock > optLdm->endPosInBlock) + { + /* The position at which ZSTD_optLdm_processMatchCandidate() is called is not necessarily + * at the end of a match from the ldm seq store, and will often be some bytes + * over beyond matchEndPosInBlock. As such, we need to correct for these "overshoots" + */ + uint posOvershoot = currPosInBlock - optLdm->endPosInBlock; + ZSTD_optLdm_skipRawSeqStoreBytes(&optLdm->seqStore, posOvershoot); + } + + ZSTD_opt_getNextMatchAndUpdateSeqStore(optLdm, currPosInBlock, remainingBytes); + } + + ZSTD_optLdm_maybeAddMatch(matches, nbMatches, optLdm, currPosInBlock, minMatch); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static nuint ZSTD_compressBlock_opt_generic( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize, + int optLevel, + ZSTD_dictMode_e dictMode + ) + { + optState_t* optStatePtr = &ms->opt; + byte* istart = (byte*)src; + byte* ip = istart; + byte* anchor = istart; + byte* iend = istart + srcSize; + byte* ilimit = iend - 8; + byte* @base = ms->window.@base; + byte* prefixStart = @base + ms->window.dictLimit; + ZSTD_compressionParameters* cParams = &ms->cParams; + ZSTD_getAllMatchesFn getAllMatches = ZSTD_selectBtGetAllMatches(ms, dictMode); + uint sufficient_len = + cParams->targetLength < (1 << 12) - 1 ? cParams->targetLength : (1 << 12) - 1; + uint minMatch = (uint)(cParams->minMatch == 3 ? 3 : 4); + uint nextToUpdate3 = ms->nextToUpdate; + ZSTD_optimal_t* opt = optStatePtr->priceTable; + ZSTD_match_t* matches = optStatePtr->matchTable; + ZSTD_optimal_t lastStretch; + ZSTD_optLdm_t optLdm; + lastStretch = new ZSTD_optimal_t(); + optLdm.seqStore = ms->ldmSeqStore != null ? *ms->ldmSeqStore : kNullRawSeqStore; + optLdm.endPosInBlock = optLdm.startPosInBlock = optLdm.offset = 0; + ZSTD_opt_getNextMatchAndUpdateSeqStore(&optLdm, (uint)(ip - istart), (uint)(iend - ip)); + assert(optLevel <= 2); + ZSTD_rescaleFreqs(optStatePtr, (byte*)src, srcSize, optLevel); + ip += ip == prefixStart ? 1 : 0; + while (ip < ilimit) + { + uint cur, + last_pos = 0; + { + uint litlen = (uint)(ip - anchor); + uint ll0 = litlen == 0 ? 1U : 0U; + uint nbMatches = getAllMatches( + matches, + ms, + &nextToUpdate3, + ip, + iend, + rep, + ll0, + minMatch + ); + ZSTD_optLdm_processMatchCandidate( + &optLdm, + matches, + &nbMatches, + (uint)(ip - istart), + (uint)(iend - ip), + minMatch + ); + if (nbMatches == 0) + { + ip++; + continue; + } + + opt[0].mlen = 0; + opt[0].litlen = litlen; + opt[0].price = (int)ZSTD_litLengthPrice(litlen, optStatePtr, optLevel); + memcpy(&opt[0].rep[0], rep, sizeof(uint) * 3); + { + uint maxML = matches[nbMatches - 1].len; + uint maxOffBase = matches[nbMatches - 1].off; + if (maxML > sufficient_len) + { + lastStretch.litlen = 0; + lastStretch.mlen = maxML; + lastStretch.off = maxOffBase; + cur = 0; + last_pos = maxML; + goto _shortestPath; + } + } + + assert(opt[0].price >= 0); + { + uint pos; + uint matchNb; + for (pos = 1; pos < minMatch; pos++) + { + opt[pos].price = 1 << 30; + opt[pos].mlen = 0; + opt[pos].litlen = litlen + pos; + } + + for (matchNb = 0; matchNb < nbMatches; matchNb++) + { + uint offBase = matches[matchNb].off; + uint end = matches[matchNb].len; + for (; pos <= end; pos++) + { + int matchPrice = (int)ZSTD_getMatchPrice( + offBase, + pos, + optStatePtr, + optLevel + ); + int sequencePrice = opt[0].price + matchPrice; + opt[pos].mlen = pos; + opt[pos].off = offBase; + opt[pos].litlen = 0; + opt[pos].price = + sequencePrice + (int)ZSTD_litLengthPrice(0, optStatePtr, optLevel); + } + } + + last_pos = pos - 1; + opt[pos].price = 1 << 30; + } + } + + for (cur = 1; cur <= last_pos; cur++) + { + byte* inr = ip + cur; + assert(cur <= 1 << 12); + { + uint litlen = opt[cur - 1].litlen + 1; + int price = + opt[cur - 1].price + + (int)ZSTD_rawLiteralsCost(ip + cur - 1, 1, optStatePtr, optLevel) + + ( + (int)ZSTD_litLengthPrice(litlen, optStatePtr, optLevel) + - (int)ZSTD_litLengthPrice(litlen - 1, optStatePtr, optLevel) + ); + assert(price < 1000000000); + if (price <= opt[cur].price) + { + ZSTD_optimal_t prevMatch = opt[cur]; + opt[cur] = opt[cur - 1]; + opt[cur].litlen = litlen; + opt[cur].price = price; + if ( + optLevel >= 1 + && prevMatch.litlen == 0 + && (int)ZSTD_litLengthPrice(1, optStatePtr, optLevel) + - (int)ZSTD_litLengthPrice(1 - 1, optStatePtr, optLevel) + < 0 + && ip + cur < iend + ) + { + /* check next position, in case it would be cheaper */ + int with1literal = + prevMatch.price + + (int)ZSTD_rawLiteralsCost(ip + cur, 1, optStatePtr, optLevel) + + ( + (int)ZSTD_litLengthPrice(1, optStatePtr, optLevel) + - (int)ZSTD_litLengthPrice(1 - 1, optStatePtr, optLevel) + ); + int withMoreLiterals = + price + + (int)ZSTD_rawLiteralsCost(ip + cur, 1, optStatePtr, optLevel) + + ( + (int)ZSTD_litLengthPrice(litlen + 1, optStatePtr, optLevel) + - (int)ZSTD_litLengthPrice( + litlen + 1 - 1, + optStatePtr, + optLevel + ) + ); + if ( + with1literal < withMoreLiterals + && with1literal < opt[cur + 1].price + ) + { + /* update offset history - before it disappears */ + uint prev = cur - prevMatch.mlen; + repcodes_s newReps = ZSTD_newRep( + opt[prev].rep, + prevMatch.off, + opt[prev].litlen == 0 ? 1U : 0U + ); + assert(cur >= prevMatch.mlen); + opt[cur + 1] = prevMatch; + memcpy(opt[cur + 1].rep, &newReps, (uint)sizeof(repcodes_s)); + opt[cur + 1].litlen = 1; + opt[cur + 1].price = with1literal; + if (last_pos < cur + 1) + last_pos = cur + 1; + } + } + } + } + + assert(cur >= opt[cur].mlen); + if (opt[cur].litlen == 0) + { + /* just finished a match => alter offset history */ + uint prev = cur - opt[cur].mlen; + repcodes_s newReps = ZSTD_newRep( + opt[prev].rep, + opt[cur].off, + opt[prev].litlen == 0 ? 1U : 0U + ); + memcpy(opt[cur].rep, &newReps, (uint)sizeof(repcodes_s)); + } + + if (inr > ilimit) + continue; + if (cur == last_pos) + break; + if (optLevel == 0 && opt[cur + 1].price <= opt[cur].price + (1 << 8) / 2) + { + continue; + } + + assert(opt[cur].price >= 0); + { + uint ll0 = opt[cur].litlen == 0 ? 1U : 0U; + int previousPrice = opt[cur].price; + int basePrice = + previousPrice + (int)ZSTD_litLengthPrice(0, optStatePtr, optLevel); + uint nbMatches = getAllMatches( + matches, + ms, + &nextToUpdate3, + inr, + iend, + opt[cur].rep, + ll0, + minMatch + ); + uint matchNb; + ZSTD_optLdm_processMatchCandidate( + &optLdm, + matches, + &nbMatches, + (uint)(inr - istart), + (uint)(iend - inr), + minMatch + ); + if (nbMatches == 0) + { + continue; + } + + { + uint longestML = matches[nbMatches - 1].len; + if ( + longestML > sufficient_len + || cur + longestML >= 1 << 12 + || ip + cur + longestML >= iend + ) + { + lastStretch.mlen = longestML; + lastStretch.off = matches[nbMatches - 1].off; + lastStretch.litlen = 0; + last_pos = cur + longestML; + goto _shortestPath; + } + } + + for (matchNb = 0; matchNb < nbMatches; matchNb++) + { + uint offset = matches[matchNb].off; + uint lastML = matches[matchNb].len; + uint startML = matchNb > 0 ? matches[matchNb - 1].len + 1 : minMatch; + uint mlen; + for (mlen = lastML; mlen >= startML; mlen--) + { + uint pos = cur + mlen; + int price = + basePrice + + (int)ZSTD_getMatchPrice(offset, mlen, optStatePtr, optLevel); + if (pos > last_pos || price < opt[pos].price) + { + while (last_pos < pos) + { + last_pos++; + opt[last_pos].price = 1 << 30; + opt[last_pos].litlen = 0 == 0 ? 1U : 0U; + } + + opt[pos].mlen = mlen; + opt[pos].off = offset; + opt[pos].litlen = 0; + opt[pos].price = price; + } + else + { + if (optLevel == 0) + break; + } + } + } + } + + opt[last_pos + 1].price = 1 << 30; + } + + lastStretch = opt[last_pos]; + assert(cur >= lastStretch.mlen); + cur = last_pos - lastStretch.mlen; + _shortestPath: + assert(opt[0].mlen == 0); + assert(last_pos >= lastStretch.mlen); + assert(cur == last_pos - lastStretch.mlen); + if (lastStretch.mlen == 0) + { + assert(lastStretch.litlen == (uint)(ip - anchor) + last_pos); + ip += last_pos; + continue; + } + + assert(lastStretch.off > 0); + if (lastStretch.litlen == 0) + { + /* finishing on a match : update offset history */ + repcodes_s reps = ZSTD_newRep( + opt[cur].rep, + lastStretch.off, + opt[cur].litlen == 0 ? 1U : 0U + ); + memcpy(rep, &reps, (uint)sizeof(repcodes_s)); + } + else + { + memcpy(rep, lastStretch.rep, (uint)sizeof(repcodes_s)); + assert(cur >= lastStretch.litlen); + cur -= lastStretch.litlen; + } + + { + uint storeEnd = cur + 2; + uint storeStart = storeEnd; + uint stretchPos = cur; + assert(storeEnd < (1 << 12) + 3); + if (lastStretch.litlen > 0) + { + opt[storeEnd].litlen = lastStretch.litlen; + opt[storeEnd].mlen = 0; + storeStart = storeEnd - 1; + opt[storeStart] = lastStretch; + } + + { + opt[storeEnd] = lastStretch; + storeStart = storeEnd; + } + + while (true) + { + ZSTD_optimal_t nextStretch = opt[stretchPos]; + opt[storeStart].litlen = nextStretch.litlen; + if (nextStretch.mlen == 0) + { + break; + } + + storeStart--; + opt[storeStart] = nextStretch; + assert(nextStretch.litlen + nextStretch.mlen <= stretchPos); + stretchPos -= nextStretch.litlen + nextStretch.mlen; + } + + { + uint storePos; + for (storePos = storeStart; storePos <= storeEnd; storePos++) + { + uint llen = opt[storePos].litlen; + uint mlen = opt[storePos].mlen; + uint offBase = opt[storePos].off; + uint advance = llen + mlen; + if (mlen == 0) + { + assert(storePos == storeEnd); + ip = anchor + llen; + continue; + } + + assert(anchor + llen <= iend); + ZSTD_updateStats(optStatePtr, llen, anchor, offBase, mlen); + ZSTD_storeSeq(seqStore, llen, anchor, iend, offBase, mlen); + anchor += advance; + ip = anchor; + } + } + + ZSTD_setBasePrices(optStatePtr, optLevel); + } + } + + return (nuint)(iend - anchor); + } + + private static nuint ZSTD_compressBlock_opt0( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize, + ZSTD_dictMode_e dictMode + ) + { + return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 0, dictMode); + } + + private static nuint ZSTD_compressBlock_opt2( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize, + ZSTD_dictMode_e dictMode + ) + { + return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2, dictMode); + } + + private static nuint ZSTD_compressBlock_btopt( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_opt0( + ms, + seqStore, + rep, + src, + srcSize, + ZSTD_dictMode_e.ZSTD_noDict + ); + } + + /* ZSTD_initStats_ultra(): + * make a first compression pass, just to seed stats with more accurate starting values. + * only works on first block, with no dictionary and no ldm. + * this function cannot error out, its narrow contract must be respected. + */ + private static void ZSTD_initStats_ultra( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + /* updated rep codes will sink here */ + uint* tmpRep = stackalloc uint[3]; + memcpy(tmpRep, rep, sizeof(uint) * 3); + assert(ms->opt.litLengthSum == 0); + assert(seqStore->sequences == seqStore->sequencesStart); + assert(ms->window.dictLimit == ms->window.lowLimit); + assert(ms->window.dictLimit - ms->nextToUpdate <= 1); + ZSTD_compressBlock_opt2(ms, seqStore, tmpRep, src, srcSize, ZSTD_dictMode_e.ZSTD_noDict); + ZSTD_resetSeqStore(seqStore); + ms->window.@base -= srcSize; + ms->window.dictLimit += (uint)srcSize; + ms->window.lowLimit = ms->window.dictLimit; + ms->nextToUpdate = ms->window.dictLimit; + } + + private static nuint ZSTD_compressBlock_btultra( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_opt2( + ms, + seqStore, + rep, + src, + srcSize, + ZSTD_dictMode_e.ZSTD_noDict + ); + } + + /* note : no btultra2 variant for extDict nor dictMatchState, + * because btultra2 is not meant to work with dictionaries + * and is only specific for the first block (no prefix) */ + private static nuint ZSTD_compressBlock_btultra2( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + uint curr = (uint)((byte*)src - ms->window.@base); + assert(srcSize <= 1 << 17); + if ( + ms->opt.litLengthSum == 0 + && seqStore->sequences == seqStore->sequencesStart + && ms->window.dictLimit == ms->window.lowLimit + && curr == ms->window.dictLimit + && srcSize > 8 + ) + { + ZSTD_initStats_ultra(ms, seqStore, rep, src, srcSize); + } + + return ZSTD_compressBlock_opt2( + ms, + seqStore, + rep, + src, + srcSize, + ZSTD_dictMode_e.ZSTD_noDict + ); + } + + private static nuint ZSTD_compressBlock_btopt_dictMatchState( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_opt0( + ms, + seqStore, + rep, + src, + srcSize, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_compressBlock_btopt_extDict( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_opt0( + ms, + seqStore, + rep, + src, + srcSize, + ZSTD_dictMode_e.ZSTD_extDict + ); + } + + private static nuint ZSTD_compressBlock_btultra_dictMatchState( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_opt2( + ms, + seqStore, + rep, + src, + srcSize, + ZSTD_dictMode_e.ZSTD_dictMatchState + ); + } + + private static nuint ZSTD_compressBlock_btultra_extDict( + ZSTD_MatchState_t* ms, + SeqStore_t* seqStore, + uint* rep, + void* src, + nuint srcSize + ) + { + return ZSTD_compressBlock_opt2( + ms, + seqStore, + rep, + src, + srcSize, + ZSTD_dictMode_e.ZSTD_extDict + ); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdPresplit.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdPresplit.cs new file mode 100644 index 000000000..e0d139218 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdPresplit.cs @@ -0,0 +1,295 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + /* for hashLog > 8, hash 2 bytes. + * for hashLog == 8, just take the byte, no hashing. + * The speed of this method relies on compile-time constant propagation */ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static uint hash2(void* p, uint hashLog) + { + assert(hashLog >= 8); + if (hashLog == 8) + return ((byte*)p)[0]; + assert(hashLog <= 10); + return MEM_read16(p) * 0x9e3779b9 >> (int)(32 - hashLog); + } + + private static void initStats(FPStats* fpstats) + { + *fpstats = new FPStats(); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void addEvents_generic( + Fingerprint* fp, + void* src, + nuint srcSize, + nuint samplingRate, + uint hashLog + ) + { + sbyte* p = (sbyte*)src; + nuint limit = srcSize - 2 + 1; + nuint n; + assert(srcSize >= 2); + for (n = 0; n < limit; n += samplingRate) + { + fp->events[hash2(p + n, hashLog)]++; + } + + fp->nbEvents += limit / samplingRate; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void recordFingerprint_generic( + Fingerprint* fp, + void* src, + nuint srcSize, + nuint samplingRate, + uint hashLog + ) + { + memset(fp, 0, (uint)(sizeof(uint) * ((nuint)1 << (int)hashLog))); + fp->nbEvents = 0; + addEvents_generic(fp, src, srcSize, samplingRate, hashLog); + } + + private static void ZSTD_recordFingerprint_1(Fingerprint* fp, void* src, nuint srcSize) + { + recordFingerprint_generic(fp, src, srcSize, 1, 10); + } + + private static void ZSTD_recordFingerprint_5(Fingerprint* fp, void* src, nuint srcSize) + { + recordFingerprint_generic(fp, src, srcSize, 5, 10); + } + + private static void ZSTD_recordFingerprint_11(Fingerprint* fp, void* src, nuint srcSize) + { + recordFingerprint_generic(fp, src, srcSize, 11, 9); + } + + private static void ZSTD_recordFingerprint_43(Fingerprint* fp, void* src, nuint srcSize) + { + recordFingerprint_generic(fp, src, srcSize, 43, 8); + } + + private static ulong abs64(long s64) + { + return (ulong)(s64 < 0 ? -s64 : s64); + } + + private static ulong fpDistance(Fingerprint* fp1, Fingerprint* fp2, uint hashLog) + { + ulong distance = 0; + nuint n; + assert(hashLog <= 10); + for (n = 0; n < (nuint)1 << (int)hashLog; n++) + { + distance += abs64( + fp1->events[n] * (long)fp2->nbEvents - fp2->events[n] * (long)fp1->nbEvents + ); + } + + return distance; + } + + /* Compare newEvents with pastEvents + * return 1 when considered "too different" + */ + private static int compareFingerprints( + Fingerprint* @ref, + Fingerprint* newfp, + int penalty, + uint hashLog + ) + { + assert(@ref->nbEvents > 0); + assert(newfp->nbEvents > 0); + { + ulong p50 = @ref->nbEvents * (ulong)newfp->nbEvents; + ulong deviation = fpDistance(@ref, newfp, hashLog); + ulong threshold = p50 * (ulong)(16 - 2 + penalty) / 16; + return deviation >= threshold ? 1 : 0; + } + } + + private static void mergeEvents(Fingerprint* acc, Fingerprint* newfp) + { + nuint n; + for (n = 0; n < 1 << 10; n++) + { + acc->events[n] += newfp->events[n]; + } + + acc->nbEvents += newfp->nbEvents; + } + + private static void flushEvents(FPStats* fpstats) + { + nuint n; + for (n = 0; n < 1 << 10; n++) + { + fpstats->pastEvents.events[n] = fpstats->newEvents.events[n]; + } + + fpstats->pastEvents.nbEvents = fpstats->newEvents.nbEvents; + fpstats->newEvents = new Fingerprint(); + } + + private static void removeEvents(Fingerprint* acc, Fingerprint* slice) + { + nuint n; + for (n = 0; n < 1 << 10; n++) + { + assert(acc->events[n] >= slice->events[n]); + acc->events[n] -= slice->events[n]; + } + + acc->nbEvents -= slice->nbEvents; + } + + private static readonly void*[] records_fs = new void*[4] + { + (delegate* managed)(&ZSTD_recordFingerprint_43), + (delegate* managed)(&ZSTD_recordFingerprint_11), + (delegate* managed)(&ZSTD_recordFingerprint_5), + (delegate* managed)(&ZSTD_recordFingerprint_1), + }; +#if NET7_0_OR_GREATER + private static ReadOnlySpan Span_hashParams => new uint[4] { 8, 9, 10, 10 }; + private static uint* hashParams => + (uint*) + System.Runtime.CompilerServices.Unsafe.AsPointer( + ref MemoryMarshal.GetReference(Span_hashParams) + ); +#else + + private static readonly uint* hashParams = GetArrayPointer(new uint[4] { 8, 9, 10, 10 }); +#endif + + private static nuint ZSTD_splitBlock_byChunks( + void* blockStart, + nuint blockSize, + int level, + void* workspace, + nuint wkspSize + ) + { + assert(0 <= level && level <= 3); + void* record_f = records_fs[level]; + FPStats* fpstats = (FPStats*)workspace; + sbyte* p = (sbyte*)blockStart; + int penalty = 3; + nuint pos = 0; + assert(blockSize == 128 << 10); + assert(workspace != null); + assert((nuint)workspace % (nuint)Math.Max(sizeof(uint), sizeof(ulong)) == 0); + assert(wkspSize >= (nuint)sizeof(FPStats)); + initStats(fpstats); + ((delegate* managed)record_f)( + &fpstats->pastEvents, + p, + 8 << 10 + ); + for (pos = 8 << 10; pos <= blockSize - (8 << 10); pos += 8 << 10) + { + ((delegate* managed)record_f)( + &fpstats->newEvents, + p + pos, + 8 << 10 + ); + if ( + compareFingerprints( + &fpstats->pastEvents, + &fpstats->newEvents, + penalty, + hashParams[level] + ) != 0 + ) + { + return pos; + } + else + { + mergeEvents(&fpstats->pastEvents, &fpstats->newEvents); + if (penalty > 0) + penalty--; + } + } + + assert(pos == blockSize); + return blockSize; + } + + /* ZSTD_splitBlock_fromBorders(): very fast strategy : + * compare fingerprint from beginning and end of the block, + * derive from their difference if it's preferable to split in the middle, + * repeat the process a second time, for finer grained decision. + * 3 times did not brought improvements, so I stopped at 2. + * Benefits are good enough for a cheap heuristic. + * More accurate splitting saves more, but speed impact is also more perceptible. + * For better accuracy, use more elaborate variant *_byChunks. + */ + private static nuint ZSTD_splitBlock_fromBorders( + void* blockStart, + nuint blockSize, + void* workspace, + nuint wkspSize + ) + { + FPStats* fpstats = (FPStats*)workspace; + Fingerprint* middleEvents = (Fingerprint*)(void*)((sbyte*)workspace + 512 * sizeof(uint)); + assert(blockSize == 128 << 10); + assert(workspace != null); + assert((nuint)workspace % (nuint)Math.Max(sizeof(uint), sizeof(ulong)) == 0); + assert(wkspSize >= (nuint)sizeof(FPStats)); + initStats(fpstats); + HIST_add(fpstats->pastEvents.events, blockStart, 512); + HIST_add(fpstats->newEvents.events, (sbyte*)blockStart + blockSize - 512, 512); + fpstats->pastEvents.nbEvents = fpstats->newEvents.nbEvents = 512; + if (compareFingerprints(&fpstats->pastEvents, &fpstats->newEvents, 0, 8) == 0) + return blockSize; + HIST_add(middleEvents->events, (sbyte*)blockStart + blockSize / 2 - 512 / 2, 512); + middleEvents->nbEvents = 512; + { + ulong distFromBegin = fpDistance(&fpstats->pastEvents, middleEvents, 8); + ulong distFromEnd = fpDistance(&fpstats->newEvents, middleEvents, 8); + const ulong minDistance = 512 * 512 / 3; + if (abs64((long)distFromBegin - (long)distFromEnd) < minDistance) + return 64 * (1 << 10); + return (nuint)(distFromBegin > distFromEnd ? 32 * (1 << 10) : 96 * (1 << 10)); + } + } + + /* ZSTD_splitBlock(): + * @level must be a value between 0 and 4. + * higher levels spend more energy to detect block boundaries. + * @workspace must be aligned for size_t. + * @wkspSize must be at least >= ZSTD_SLIPBLOCK_WORKSPACESIZE + * note: + * For the time being, this function only accepts full 128 KB blocks. + * Therefore, @blockSize must be == 128 KB. + * While this could be extended to smaller sizes in the future, + * it is not yet clear if this would be useful. TBD. + */ + private static nuint ZSTD_splitBlock( + void* blockStart, + nuint blockSize, + int level, + void* workspace, + nuint wkspSize + ) + { + assert(0 <= level && level <= 4); + if (level == 0) + return ZSTD_splitBlock_fromBorders(blockStart, blockSize, workspace, wkspSize); + return ZSTD_splitBlock_byChunks(blockStart, blockSize, level - 1, workspace, wkspSize); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdmtCompress.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdmtCompress.cs new file mode 100644 index 000000000..2a21c3238 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ZstdmtCompress.cs @@ -0,0 +1,1894 @@ +using System.Runtime.CompilerServices; +using static SharpCompress.Compressors.ZStandard.UnsafeHelper; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public static unsafe partial class Methods +{ + private static readonly buffer_s g_nullBuffer = new buffer_s(start: null, capacity: 0); + + private static void ZSTDMT_freeBufferPool(ZSTDMT_bufferPool_s* bufPool) + { + if (bufPool == null) + return; + if (bufPool->buffers != null) + { + uint u; + for (u = 0; u < bufPool->totalBuffers; u++) + { + ZSTD_customFree(bufPool->buffers[u].start, bufPool->cMem); + } + + ZSTD_customFree(bufPool->buffers, bufPool->cMem); + } + + SynchronizationWrapper.Free(&bufPool->poolMutex); + ZSTD_customFree(bufPool, bufPool->cMem); + } + + private static ZSTDMT_bufferPool_s* ZSTDMT_createBufferPool( + uint maxNbBuffers, + ZSTD_customMem cMem + ) + { + ZSTDMT_bufferPool_s* bufPool = (ZSTDMT_bufferPool_s*)ZSTD_customCalloc( + (nuint)sizeof(ZSTDMT_bufferPool_s), + cMem + ); + if (bufPool == null) + return null; + SynchronizationWrapper.Init(&bufPool->poolMutex); + bufPool->buffers = (buffer_s*)ZSTD_customCalloc( + maxNbBuffers * (uint)sizeof(buffer_s), + cMem + ); + if (bufPool->buffers == null) + { + ZSTDMT_freeBufferPool(bufPool); + return null; + } + + bufPool->bufferSize = 64 * (1 << 10); + bufPool->totalBuffers = maxNbBuffers; + bufPool->nbBuffers = 0; + bufPool->cMem = cMem; + return bufPool; + } + + /* only works at initialization, not during compression */ + private static nuint ZSTDMT_sizeof_bufferPool(ZSTDMT_bufferPool_s* bufPool) + { + nuint poolSize = (nuint)sizeof(ZSTDMT_bufferPool_s); + nuint arraySize = bufPool->totalBuffers * (uint)sizeof(buffer_s); + uint u; + nuint totalBufferSize = 0; + SynchronizationWrapper.Enter(&bufPool->poolMutex); + for (u = 0; u < bufPool->totalBuffers; u++) + totalBufferSize += bufPool->buffers[u].capacity; + SynchronizationWrapper.Exit(&bufPool->poolMutex); + return poolSize + arraySize + totalBufferSize; + } + + /* ZSTDMT_setBufferSize() : + * all future buffers provided by this buffer pool will have _at least_ this size + * note : it's better for all buffers to have same size, + * as they become freely interchangeable, reducing malloc/free usages and memory fragmentation */ + private static void ZSTDMT_setBufferSize(ZSTDMT_bufferPool_s* bufPool, nuint bSize) + { + SynchronizationWrapper.Enter(&bufPool->poolMutex); + bufPool->bufferSize = bSize; + SynchronizationWrapper.Exit(&bufPool->poolMutex); + } + + private static ZSTDMT_bufferPool_s* ZSTDMT_expandBufferPool( + ZSTDMT_bufferPool_s* srcBufPool, + uint maxNbBuffers + ) + { + if (srcBufPool == null) + return null; + if (srcBufPool->totalBuffers >= maxNbBuffers) + return srcBufPool; + { + ZSTD_customMem cMem = srcBufPool->cMem; + /* forward parameters */ + nuint bSize = srcBufPool->bufferSize; + ZSTDMT_bufferPool_s* newBufPool; + ZSTDMT_freeBufferPool(srcBufPool); + newBufPool = ZSTDMT_createBufferPool(maxNbBuffers, cMem); + if (newBufPool == null) + return newBufPool; + ZSTDMT_setBufferSize(newBufPool, bSize); + return newBufPool; + } + } + + /** ZSTDMT_getBuffer() : + * assumption : bufPool must be valid + * @return : a buffer, with start pointer and size + * note: allocation may fail, in this case, start==NULL and size==0 */ + private static buffer_s ZSTDMT_getBuffer(ZSTDMT_bufferPool_s* bufPool) + { + nuint bSize = bufPool->bufferSize; + SynchronizationWrapper.Enter(&bufPool->poolMutex); + if (bufPool->nbBuffers != 0) + { + buffer_s buf = bufPool->buffers[--bufPool->nbBuffers]; + nuint availBufferSize = buf.capacity; + bufPool->buffers[bufPool->nbBuffers] = g_nullBuffer; + if (availBufferSize >= bSize && availBufferSize >> 3 <= bSize) + { + SynchronizationWrapper.Exit(&bufPool->poolMutex); + return buf; + } + + ZSTD_customFree(buf.start, bufPool->cMem); + } + + SynchronizationWrapper.Exit(&bufPool->poolMutex); + { + buffer_s buffer; + void* start = ZSTD_customMalloc(bSize, bufPool->cMem); + buffer.start = start; + buffer.capacity = start == null ? 0 : bSize; + return buffer; + } + } + + /* store buffer for later re-use, up to pool capacity */ + private static void ZSTDMT_releaseBuffer(ZSTDMT_bufferPool_s* bufPool, buffer_s buf) + { + if (buf.start == null) + return; + SynchronizationWrapper.Enter(&bufPool->poolMutex); + if (bufPool->nbBuffers < bufPool->totalBuffers) + { + bufPool->buffers[bufPool->nbBuffers++] = buf; + SynchronizationWrapper.Exit(&bufPool->poolMutex); + return; + } + + SynchronizationWrapper.Exit(&bufPool->poolMutex); + ZSTD_customFree(buf.start, bufPool->cMem); + } + + private static nuint ZSTDMT_sizeof_seqPool(ZSTDMT_bufferPool_s* seqPool) + { + return ZSTDMT_sizeof_bufferPool(seqPool); + } + + private static RawSeqStore_t bufferToSeq(buffer_s buffer) + { + RawSeqStore_t seq = kNullRawSeqStore; + seq.seq = (rawSeq*)buffer.start; + seq.capacity = buffer.capacity / (nuint)sizeof(rawSeq); + return seq; + } + + private static buffer_s seqToBuffer(RawSeqStore_t seq) + { + buffer_s buffer; + buffer.start = seq.seq; + buffer.capacity = seq.capacity * (nuint)sizeof(rawSeq); + return buffer; + } + + private static RawSeqStore_t ZSTDMT_getSeq(ZSTDMT_bufferPool_s* seqPool) + { + if (seqPool->bufferSize == 0) + { + return kNullRawSeqStore; + } + + return bufferToSeq(ZSTDMT_getBuffer(seqPool)); + } + + private static void ZSTDMT_releaseSeq(ZSTDMT_bufferPool_s* seqPool, RawSeqStore_t seq) + { + ZSTDMT_releaseBuffer(seqPool, seqToBuffer(seq)); + } + + private static void ZSTDMT_setNbSeq(ZSTDMT_bufferPool_s* seqPool, nuint nbSeq) + { + ZSTDMT_setBufferSize(seqPool, nbSeq * (nuint)sizeof(rawSeq)); + } + + private static ZSTDMT_bufferPool_s* ZSTDMT_createSeqPool(uint nbWorkers, ZSTD_customMem cMem) + { + ZSTDMT_bufferPool_s* seqPool = ZSTDMT_createBufferPool(nbWorkers, cMem); + if (seqPool == null) + return null; + ZSTDMT_setNbSeq(seqPool, 0); + return seqPool; + } + + private static void ZSTDMT_freeSeqPool(ZSTDMT_bufferPool_s* seqPool) + { + ZSTDMT_freeBufferPool(seqPool); + } + + private static ZSTDMT_bufferPool_s* ZSTDMT_expandSeqPool( + ZSTDMT_bufferPool_s* pool, + uint nbWorkers + ) + { + return ZSTDMT_expandBufferPool(pool, nbWorkers); + } + + /* note : all CCtx borrowed from the pool must be reverted back to the pool _before_ freeing the pool */ + private static void ZSTDMT_freeCCtxPool(ZSTDMT_CCtxPool* pool) + { + if (pool == null) + return; + SynchronizationWrapper.Free(&pool->poolMutex); + if (pool->cctxs != null) + { + int cid; + for (cid = 0; cid < pool->totalCCtx; cid++) + ZSTD_freeCCtx(pool->cctxs[cid]); + ZSTD_customFree(pool->cctxs, pool->cMem); + } + + ZSTD_customFree(pool, pool->cMem); + } + + /* ZSTDMT_createCCtxPool() : + * implies nbWorkers >= 1 , checked by caller ZSTDMT_createCCtx() */ + private static ZSTDMT_CCtxPool* ZSTDMT_createCCtxPool(int nbWorkers, ZSTD_customMem cMem) + { + ZSTDMT_CCtxPool* cctxPool = (ZSTDMT_CCtxPool*)ZSTD_customCalloc( + (nuint)sizeof(ZSTDMT_CCtxPool), + cMem + ); + assert(nbWorkers > 0); + if (cctxPool == null) + return null; + SynchronizationWrapper.Init(&cctxPool->poolMutex); + cctxPool->totalCCtx = nbWorkers; + cctxPool->cctxs = (ZSTD_CCtx_s**)ZSTD_customCalloc( + (nuint)(nbWorkers * sizeof(ZSTD_CCtx_s*)), + cMem + ); + if (cctxPool->cctxs == null) + { + ZSTDMT_freeCCtxPool(cctxPool); + return null; + } + + cctxPool->cMem = cMem; + cctxPool->cctxs[0] = ZSTD_createCCtx_advanced(cMem); + if (cctxPool->cctxs[0] == null) + { + ZSTDMT_freeCCtxPool(cctxPool); + return null; + } + + cctxPool->availCCtx = 1; + return cctxPool; + } + + private static ZSTDMT_CCtxPool* ZSTDMT_expandCCtxPool(ZSTDMT_CCtxPool* srcPool, int nbWorkers) + { + if (srcPool == null) + return null; + if (nbWorkers <= srcPool->totalCCtx) + return srcPool; + { + ZSTD_customMem cMem = srcPool->cMem; + ZSTDMT_freeCCtxPool(srcPool); + return ZSTDMT_createCCtxPool(nbWorkers, cMem); + } + } + + /* only works during initialization phase, not during compression */ + private static nuint ZSTDMT_sizeof_CCtxPool(ZSTDMT_CCtxPool* cctxPool) + { + SynchronizationWrapper.Enter(&cctxPool->poolMutex); + { + uint nbWorkers = (uint)cctxPool->totalCCtx; + nuint poolSize = (nuint)sizeof(ZSTDMT_CCtxPool); + nuint arraySize = (nuint)(cctxPool->totalCCtx * sizeof(ZSTD_CCtx_s*)); + nuint totalCCtxSize = 0; + uint u; + for (u = 0; u < nbWorkers; u++) + { + totalCCtxSize += ZSTD_sizeof_CCtx(cctxPool->cctxs[u]); + } + + SynchronizationWrapper.Exit(&cctxPool->poolMutex); + assert(nbWorkers > 0); + return poolSize + arraySize + totalCCtxSize; + } + } + + private static ZSTD_CCtx_s* ZSTDMT_getCCtx(ZSTDMT_CCtxPool* cctxPool) + { + SynchronizationWrapper.Enter(&cctxPool->poolMutex); + if (cctxPool->availCCtx != 0) + { + cctxPool->availCCtx--; + { + ZSTD_CCtx_s* cctx = cctxPool->cctxs[cctxPool->availCCtx]; + SynchronizationWrapper.Exit(&cctxPool->poolMutex); + return cctx; + } + } + + SynchronizationWrapper.Exit(&cctxPool->poolMutex); + return ZSTD_createCCtx_advanced(cctxPool->cMem); + } + + private static void ZSTDMT_releaseCCtx(ZSTDMT_CCtxPool* pool, ZSTD_CCtx_s* cctx) + { + if (cctx == null) + return; + SynchronizationWrapper.Enter(&pool->poolMutex); + if (pool->availCCtx < pool->totalCCtx) + pool->cctxs[pool->availCCtx++] = cctx; + else + { + ZSTD_freeCCtx(cctx); + } + + SynchronizationWrapper.Exit(&pool->poolMutex); + } + + private static int ZSTDMT_serialState_reset( + SerialState* serialState, + ZSTDMT_bufferPool_s* seqPool, + ZSTD_CCtx_params_s @params, + nuint jobSize, + void* dict, + nuint dictSize, + ZSTD_dictContentType_e dictContentType + ) + { + if (@params.ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable) + { + ZSTD_ldm_adjustParameters(&@params.ldmParams, &@params.cParams); + assert(@params.ldmParams.hashLog >= @params.ldmParams.bucketSizeLog); + assert(@params.ldmParams.hashRateLog < 32); + } + else + { + @params.ldmParams = new ldmParams_t(); + } + + serialState->nextJobID = 0; + if (@params.fParams.checksumFlag != 0) + ZSTD_XXH64_reset(&serialState->xxhState, 0); + if (@params.ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable) + { + ZSTD_customMem cMem = @params.customMem; + uint hashLog = @params.ldmParams.hashLog; + nuint hashSize = ((nuint)1 << (int)hashLog) * (nuint)sizeof(ldmEntry_t); + uint bucketLog = @params.ldmParams.hashLog - @params.ldmParams.bucketSizeLog; + uint prevBucketLog = + serialState->@params.ldmParams.hashLog + - serialState->@params.ldmParams.bucketSizeLog; + nuint numBuckets = (nuint)1 << (int)bucketLog; + ZSTDMT_setNbSeq(seqPool, ZSTD_ldm_getMaxNbSeq(@params.ldmParams, jobSize)); + ZSTD_window_init(&serialState->ldmState.window); + if ( + serialState->ldmState.hashTable == null + || serialState->@params.ldmParams.hashLog < hashLog + ) + { + ZSTD_customFree(serialState->ldmState.hashTable, cMem); + serialState->ldmState.hashTable = (ldmEntry_t*)ZSTD_customMalloc(hashSize, cMem); + } + + if (serialState->ldmState.bucketOffsets == null || prevBucketLog < bucketLog) + { + ZSTD_customFree(serialState->ldmState.bucketOffsets, cMem); + serialState->ldmState.bucketOffsets = (byte*)ZSTD_customMalloc(numBuckets, cMem); + } + + if ( + serialState->ldmState.hashTable == null + || serialState->ldmState.bucketOffsets == null + ) + return 1; + memset(serialState->ldmState.hashTable, 0, (uint)hashSize); + memset(serialState->ldmState.bucketOffsets, 0, (uint)numBuckets); + serialState->ldmState.loadedDictEnd = 0; + if (dictSize > 0) + { + if (dictContentType == ZSTD_dictContentType_e.ZSTD_dct_rawContent) + { + byte* dictEnd = (byte*)dict + dictSize; + ZSTD_window_update(&serialState->ldmState.window, dict, dictSize, 0); + ZSTD_ldm_fillHashTable( + &serialState->ldmState, + (byte*)dict, + dictEnd, + &@params.ldmParams + ); + serialState->ldmState.loadedDictEnd = + @params.forceWindow != 0 + ? 0 + : (uint)(dictEnd - serialState->ldmState.window.@base); + } + } + + serialState->ldmWindow = serialState->ldmState.window; + } + + serialState->@params = @params; + serialState->@params.jobSize = (uint)jobSize; + return 0; + } + + private static int ZSTDMT_serialState_init(SerialState* serialState) + { + int initError = 0; + *serialState = new SerialState(); + SynchronizationWrapper.Init(&serialState->mutex); + initError |= 0; + initError |= 0; + SynchronizationWrapper.Init(&serialState->ldmWindowMutex); + initError |= 0; + initError |= 0; + return initError; + } + + private static void ZSTDMT_serialState_free(SerialState* serialState) + { + ZSTD_customMem cMem = serialState->@params.customMem; + SynchronizationWrapper.Free(&serialState->mutex); + SynchronizationWrapper.Free(&serialState->ldmWindowMutex); + ZSTD_customFree(serialState->ldmState.hashTable, cMem); + ZSTD_customFree(serialState->ldmState.bucketOffsets, cMem); + } + + private static void ZSTDMT_serialState_genSequences( + SerialState* serialState, + RawSeqStore_t* seqStore, + Range src, + uint jobID + ) + { + SynchronizationWrapper.Enter(&serialState->mutex); + while (serialState->nextJobID < jobID) + { + SynchronizationWrapper.Wait(&serialState->mutex); + } + + if (serialState->nextJobID == jobID) + { + if (serialState->@params.ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable) + { + nuint error; + assert( + seqStore->seq != null + && seqStore->pos == 0 + && seqStore->size == 0 + && seqStore->capacity > 0 + ); + assert(src.size <= serialState->@params.jobSize); + ZSTD_window_update(&serialState->ldmState.window, src.start, src.size, 0); + error = ZSTD_ldm_generateSequences( + &serialState->ldmState, + seqStore, + &serialState->@params.ldmParams, + src.start, + src.size + ); + assert(!ERR_isError(error)); + SynchronizationWrapper.Enter(&serialState->ldmWindowMutex); + serialState->ldmWindow = serialState->ldmState.window; + SynchronizationWrapper.Pulse(&serialState->ldmWindowMutex); + SynchronizationWrapper.Exit(&serialState->ldmWindowMutex); + } + + if (serialState->@params.fParams.checksumFlag != 0 && src.size > 0) + ZSTD_XXH64_update(&serialState->xxhState, src.start, src.size); + } + + serialState->nextJobID++; + SynchronizationWrapper.PulseAll(&serialState->mutex); + SynchronizationWrapper.Exit(&serialState->mutex); + } + + private static void ZSTDMT_serialState_applySequences( + SerialState* serialState, + ZSTD_CCtx_s* jobCCtx, + RawSeqStore_t* seqStore + ) + { + if (seqStore->size > 0) + { + assert(serialState->@params.ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable); + assert(jobCCtx != null); + ZSTD_referenceExternalSequences(jobCCtx, seqStore->seq, seqStore->size); + } + } + + private static void ZSTDMT_serialState_ensureFinished( + SerialState* serialState, + uint jobID, + nuint cSize + ) + { + SynchronizationWrapper.Enter(&serialState->mutex); + if (serialState->nextJobID <= jobID) + { + assert(ERR_isError(cSize)); + serialState->nextJobID = jobID + 1; + SynchronizationWrapper.PulseAll(&serialState->mutex); + SynchronizationWrapper.Enter(&serialState->ldmWindowMutex); + ZSTD_window_clear(&serialState->ldmWindow); + SynchronizationWrapper.Pulse(&serialState->ldmWindowMutex); + SynchronizationWrapper.Exit(&serialState->ldmWindowMutex); + } + + SynchronizationWrapper.Exit(&serialState->mutex); + } + + private static readonly Range kNullRange = new Range(start: null, size: 0); + + /* ZSTDMT_compressionJob() is a POOL_function type */ + private static void ZSTDMT_compressionJob(void* jobDescription) + { + ZSTDMT_jobDescription* job = (ZSTDMT_jobDescription*)jobDescription; + /* do not modify job->params ! copy it, modify the copy */ + ZSTD_CCtx_params_s jobParams = job->@params; + ZSTD_CCtx_s* cctx = ZSTDMT_getCCtx(job->cctxPool); + RawSeqStore_t rawSeqStore = ZSTDMT_getSeq(job->seqPool); + buffer_s dstBuff = job->dstBuff; + nuint lastCBlockSize = 0; + if (cctx == null) + { + SynchronizationWrapper.Enter(&job->job_mutex); + job->cSize = unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + SynchronizationWrapper.Exit(&job->job_mutex); + goto _endJob; + } + + if (dstBuff.start == null) + { + dstBuff = ZSTDMT_getBuffer(job->bufPool); + if (dstBuff.start == null) + { + SynchronizationWrapper.Enter(&job->job_mutex); + job->cSize = unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + SynchronizationWrapper.Exit(&job->job_mutex); + goto _endJob; + } + + job->dstBuff = dstBuff; + } + + if ( + jobParams.ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable + && rawSeqStore.seq == null + ) + { + SynchronizationWrapper.Enter(&job->job_mutex); + job->cSize = unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + SynchronizationWrapper.Exit(&job->job_mutex); + goto _endJob; + } + + if (job->jobID != 0) + jobParams.fParams.checksumFlag = 0; + jobParams.ldmParams.enableLdm = ZSTD_paramSwitch_e.ZSTD_ps_disable; + jobParams.nbWorkers = 0; + ZSTDMT_serialState_genSequences(job->serial, &rawSeqStore, job->src, job->jobID); + if (job->cdict != null) + { + nuint initError = ZSTD_compressBegin_advanced_internal( + cctx, + null, + 0, + ZSTD_dictContentType_e.ZSTD_dct_auto, + ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast, + job->cdict, + &jobParams, + job->fullFrameSize + ); + assert(job->firstJob != 0); + if (ERR_isError(initError)) + { + SynchronizationWrapper.Enter(&job->job_mutex); + job->cSize = initError; + SynchronizationWrapper.Exit(&job->job_mutex); + goto _endJob; + } + } + else + { + ulong pledgedSrcSize = job->firstJob != 0 ? job->fullFrameSize : job->src.size; + { + nuint forceWindowError = ZSTD_CCtxParams_setParameter( + &jobParams, + ZSTD_cParameter.ZSTD_c_experimentalParam3, + job->firstJob == 0 ? 1 : 0 + ); + if (ERR_isError(forceWindowError)) + { + SynchronizationWrapper.Enter(&job->job_mutex); + job->cSize = forceWindowError; + SynchronizationWrapper.Exit(&job->job_mutex); + goto _endJob; + } + } + + if (job->firstJob == 0) + { + nuint err = ZSTD_CCtxParams_setParameter( + &jobParams, + ZSTD_cParameter.ZSTD_c_experimentalParam15, + 0 + ); + if (ERR_isError(err)) + { + SynchronizationWrapper.Enter(&job->job_mutex); + job->cSize = err; + SynchronizationWrapper.Exit(&job->job_mutex); + goto _endJob; + } + } + + { + nuint initError = ZSTD_compressBegin_advanced_internal( + cctx, + job->prefix.start, + job->prefix.size, + ZSTD_dictContentType_e.ZSTD_dct_rawContent, + ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast, + null, + &jobParams, + pledgedSrcSize + ); + if (ERR_isError(initError)) + { + SynchronizationWrapper.Enter(&job->job_mutex); + job->cSize = initError; + SynchronizationWrapper.Exit(&job->job_mutex); + goto _endJob; + } + } + } + + ZSTDMT_serialState_applySequences(job->serial, cctx, &rawSeqStore); + if (job->firstJob == 0) + { + nuint hSize = ZSTD_compressContinue_public( + cctx, + dstBuff.start, + dstBuff.capacity, + job->src.start, + 0 + ); + if (ERR_isError(hSize)) + { + SynchronizationWrapper.Enter(&job->job_mutex); + job->cSize = hSize; + SynchronizationWrapper.Exit(&job->job_mutex); + goto _endJob; + } + + ZSTD_invalidateRepCodes(cctx); + } + + { + const nuint chunkSize = 4 * (1 << 17); + int nbChunks = (int)((job->src.size + (chunkSize - 1)) / chunkSize); + byte* ip = (byte*)job->src.start; + byte* ostart = (byte*)dstBuff.start; + byte* op = ostart; + byte* oend = op + dstBuff.capacity; + int chunkNb; +#if DEBUG + if (sizeof(nuint) > sizeof(int)) + assert(job->src.size < unchecked(2147483647 * chunkSize)); +#endif + assert(job->cSize == 0); + for (chunkNb = 1; chunkNb < nbChunks; chunkNb++) + { + nuint cSize = ZSTD_compressContinue_public( + cctx, + op, + (nuint)(oend - op), + ip, + chunkSize + ); + if (ERR_isError(cSize)) + { + SynchronizationWrapper.Enter(&job->job_mutex); + job->cSize = cSize; + SynchronizationWrapper.Exit(&job->job_mutex); + goto _endJob; + } + + ip += chunkSize; + op += cSize; + assert(op < oend); + SynchronizationWrapper.Enter(&job->job_mutex); + job->cSize += cSize; + job->consumed = chunkSize * (nuint)chunkNb; + SynchronizationWrapper.Pulse(&job->job_mutex); + SynchronizationWrapper.Exit(&job->job_mutex); + } + + assert(chunkSize > 0); + assert((chunkSize & chunkSize - 1) == 0); + if (((uint)(nbChunks > 0 ? 1 : 0) | job->lastJob) != 0) + { + nuint lastBlockSize1 = job->src.size & chunkSize - 1; + nuint lastBlockSize = + lastBlockSize1 == 0 && job->src.size >= chunkSize ? chunkSize : lastBlockSize1; + nuint cSize = + job->lastJob != 0 + ? ZSTD_compressEnd_public(cctx, op, (nuint)(oend - op), ip, lastBlockSize) + : ZSTD_compressContinue_public( + cctx, + op, + (nuint)(oend - op), + ip, + lastBlockSize + ); + if (ERR_isError(cSize)) + { + SynchronizationWrapper.Enter(&job->job_mutex); + job->cSize = cSize; + SynchronizationWrapper.Exit(&job->job_mutex); + goto _endJob; + } + + lastCBlockSize = cSize; + } + } + +#if DEBUG + if (job->firstJob == 0) + { + assert(ZSTD_window_hasExtDict(cctx->blockState.matchState.window) == 0); + } +#endif + + ZSTD_CCtx_trace(cctx, 0); + _endJob: + ZSTDMT_serialState_ensureFinished(job->serial, job->jobID, job->cSize); + ZSTDMT_releaseSeq(job->seqPool, rawSeqStore); + ZSTDMT_releaseCCtx(job->cctxPool, cctx); + SynchronizationWrapper.Enter(&job->job_mutex); + if (ERR_isError(job->cSize)) + assert(lastCBlockSize == 0); + job->cSize += lastCBlockSize; + job->consumed = job->src.size; + SynchronizationWrapper.Pulse(&job->job_mutex); + SynchronizationWrapper.Exit(&job->job_mutex); + } + + private static readonly RoundBuff_t kNullRoundBuff = new RoundBuff_t( + buffer: null, + capacity: 0, + pos: 0 + ); + + private static void ZSTDMT_freeJobsTable( + ZSTDMT_jobDescription* jobTable, + uint nbJobs, + ZSTD_customMem cMem + ) + { + uint jobNb; + if (jobTable == null) + return; + for (jobNb = 0; jobNb < nbJobs; jobNb++) + { + SynchronizationWrapper.Free(&jobTable[jobNb].job_mutex); + } + + ZSTD_customFree(jobTable, cMem); + } + + /* ZSTDMT_allocJobsTable() + * allocate and init a job table. + * update *nbJobsPtr to next power of 2 value, as size of table */ + private static ZSTDMT_jobDescription* ZSTDMT_createJobsTable( + uint* nbJobsPtr, + ZSTD_customMem cMem + ) + { + uint nbJobsLog2 = ZSTD_highbit32(*nbJobsPtr) + 1; + uint nbJobs = (uint)(1 << (int)nbJobsLog2); + uint jobNb; + ZSTDMT_jobDescription* jobTable = (ZSTDMT_jobDescription*)ZSTD_customCalloc( + nbJobs * (uint)sizeof(ZSTDMT_jobDescription), + cMem + ); + int initError = 0; + if (jobTable == null) + return null; + *nbJobsPtr = nbJobs; + for (jobNb = 0; jobNb < nbJobs; jobNb++) + { + SynchronizationWrapper.Init(&jobTable[jobNb].job_mutex); + initError |= 0; + initError |= 0; + } + + if (initError != 0) + { + ZSTDMT_freeJobsTable(jobTable, nbJobs, cMem); + return null; + } + + return jobTable; + } + + private static nuint ZSTDMT_expandJobsTable(ZSTDMT_CCtx_s* mtctx, uint nbWorkers) + { + uint nbJobs = nbWorkers + 2; + if (nbJobs > mtctx->jobIDMask + 1) + { + ZSTDMT_freeJobsTable(mtctx->jobs, mtctx->jobIDMask + 1, mtctx->cMem); + mtctx->jobIDMask = 0; + mtctx->jobs = ZSTDMT_createJobsTable(&nbJobs, mtctx->cMem); + if (mtctx->jobs == null) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + assert(nbJobs != 0 && (nbJobs & nbJobs - 1) == 0); + mtctx->jobIDMask = nbJobs - 1; + } + + return 0; + } + + /* ZSTDMT_CCtxParam_setNbWorkers(): + * Internal use only */ + private static nuint ZSTDMT_CCtxParam_setNbWorkers(ZSTD_CCtx_params_s* @params, uint nbWorkers) + { + return ZSTD_CCtxParams_setParameter( + @params, + ZSTD_cParameter.ZSTD_c_nbWorkers, + (int)nbWorkers + ); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static ZSTDMT_CCtx_s* ZSTDMT_createCCtx_advanced_internal( + uint nbWorkers, + ZSTD_customMem cMem, + void* pool + ) + { + ZSTDMT_CCtx_s* mtctx; + uint nbJobs = nbWorkers + 2; + int initError; + if (nbWorkers < 1) + return null; + nbWorkers = + nbWorkers < (uint)(sizeof(void*) == 4 ? 64 : 256) + ? nbWorkers + : (uint)(sizeof(void*) == 4 ? 64 : 256); + if (((cMem.customAlloc != null ? 1 : 0) ^ (cMem.customFree != null ? 1 : 0)) != 0) + return null; + mtctx = (ZSTDMT_CCtx_s*)ZSTD_customCalloc((nuint)sizeof(ZSTDMT_CCtx_s), cMem); + if (mtctx == null) + return null; + ZSTDMT_CCtxParam_setNbWorkers(&mtctx->@params, nbWorkers); + mtctx->cMem = cMem; + mtctx->allJobsCompleted = 1; + if (pool != null) + { + mtctx->factory = pool; + mtctx->providedFactory = 1; + } + else + { + mtctx->factory = POOL_create_advanced(nbWorkers, 0, cMem); + mtctx->providedFactory = 0; + } + + mtctx->jobs = ZSTDMT_createJobsTable(&nbJobs, cMem); + assert(nbJobs > 0); + assert((nbJobs & nbJobs - 1) == 0); + mtctx->jobIDMask = nbJobs - 1; + mtctx->bufPool = ZSTDMT_createBufferPool(2 * nbWorkers + 3, cMem); + mtctx->cctxPool = ZSTDMT_createCCtxPool((int)nbWorkers, cMem); + mtctx->seqPool = ZSTDMT_createSeqPool(nbWorkers, cMem); + initError = ZSTDMT_serialState_init(&mtctx->serial); + mtctx->roundBuff = kNullRoundBuff; + if ( + ( + ( + mtctx->factory == null + || mtctx->jobs == null + || mtctx->bufPool == null + || mtctx->cctxPool == null + || mtctx->seqPool == null + ? 1 + : 0 + ) | initError + ) != 0 + ) + { + ZSTDMT_freeCCtx(mtctx); + return null; + } + + return mtctx; + } + + /* Requires ZSTD_MULTITHREAD to be defined during compilation, otherwise it will return NULL. */ + private static ZSTDMT_CCtx_s* ZSTDMT_createCCtx_advanced( + uint nbWorkers, + ZSTD_customMem cMem, + void* pool + ) + { + return ZSTDMT_createCCtx_advanced_internal(nbWorkers, cMem, pool); + } + + /* ZSTDMT_releaseAllJobResources() : + * note : ensure all workers are killed first ! */ + private static void ZSTDMT_releaseAllJobResources(ZSTDMT_CCtx_s* mtctx) + { + uint jobID; + for (jobID = 0; jobID <= mtctx->jobIDMask; jobID++) + { + /* Copy the mutex/cond out */ + void* mutex = mtctx->jobs[jobID].job_mutex; + void* cond = mtctx->jobs[jobID].job_cond; + ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[jobID].dstBuff); + mtctx->jobs[jobID] = new ZSTDMT_jobDescription { job_mutex = mutex, job_cond = cond }; + } + + mtctx->inBuff.buffer = g_nullBuffer; + mtctx->inBuff.filled = 0; + mtctx->allJobsCompleted = 1; + } + + private static void ZSTDMT_waitForAllJobsCompleted(ZSTDMT_CCtx_s* mtctx) + { + while (mtctx->doneJobID < mtctx->nextJobID) + { + uint jobID = mtctx->doneJobID & mtctx->jobIDMask; + SynchronizationWrapper.Enter(&mtctx->jobs[jobID].job_mutex); + while (mtctx->jobs[jobID].consumed < mtctx->jobs[jobID].src.size) + { + SynchronizationWrapper.Wait(&mtctx->jobs[jobID].job_mutex); + } + + SynchronizationWrapper.Exit(&mtctx->jobs[jobID].job_mutex); + mtctx->doneJobID++; + } + } + + private static nuint ZSTDMT_freeCCtx(ZSTDMT_CCtx_s* mtctx) + { + if (mtctx == null) + return 0; + if (mtctx->providedFactory == 0) + POOL_free(mtctx->factory); + ZSTDMT_releaseAllJobResources(mtctx); + ZSTDMT_freeJobsTable(mtctx->jobs, mtctx->jobIDMask + 1, mtctx->cMem); + ZSTDMT_freeBufferPool(mtctx->bufPool); + ZSTDMT_freeCCtxPool(mtctx->cctxPool); + ZSTDMT_freeSeqPool(mtctx->seqPool); + ZSTDMT_serialState_free(&mtctx->serial); + ZSTD_freeCDict(mtctx->cdictLocal); + if (mtctx->roundBuff.buffer != null) + ZSTD_customFree(mtctx->roundBuff.buffer, mtctx->cMem); + ZSTD_customFree(mtctx, mtctx->cMem); + return 0; + } + + private static nuint ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx_s* mtctx) + { + if (mtctx == null) + return 0; + return (nuint)sizeof(ZSTDMT_CCtx_s) + + POOL_sizeof(mtctx->factory) + + ZSTDMT_sizeof_bufferPool(mtctx->bufPool) + + (mtctx->jobIDMask + 1) * (uint)sizeof(ZSTDMT_jobDescription) + + ZSTDMT_sizeof_CCtxPool(mtctx->cctxPool) + + ZSTDMT_sizeof_seqPool(mtctx->seqPool) + + ZSTD_sizeof_CDict(mtctx->cdictLocal) + + mtctx->roundBuff.capacity; + } + + /* ZSTDMT_resize() : + * @return : error code if fails, 0 on success */ + private static nuint ZSTDMT_resize(ZSTDMT_CCtx_s* mtctx, uint nbWorkers) + { + if (POOL_resize(mtctx->factory, nbWorkers) != 0) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + { + nuint err_code = ZSTDMT_expandJobsTable(mtctx, nbWorkers); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + mtctx->bufPool = ZSTDMT_expandBufferPool(mtctx->bufPool, 2 * nbWorkers + 3); + if (mtctx->bufPool == null) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + mtctx->cctxPool = ZSTDMT_expandCCtxPool(mtctx->cctxPool, (int)nbWorkers); + if (mtctx->cctxPool == null) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + mtctx->seqPool = ZSTDMT_expandSeqPool(mtctx->seqPool, nbWorkers); + if (mtctx->seqPool == null) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + ZSTDMT_CCtxParam_setNbWorkers(&mtctx->@params, nbWorkers); + return 0; + } + + /*! ZSTDMT_updateCParams_whileCompressing() : + * Updates a selected set of compression parameters, remaining compatible with currently active frame. + * New parameters will be applied to next compression job. */ + private static void ZSTDMT_updateCParams_whileCompressing( + ZSTDMT_CCtx_s* mtctx, + ZSTD_CCtx_params_s* cctxParams + ) + { + /* Do not modify windowLog while compressing */ + uint saved_wlog = mtctx->@params.cParams.windowLog; + int compressionLevel = cctxParams->compressionLevel; + mtctx->@params.compressionLevel = compressionLevel; + { + ZSTD_compressionParameters cParams = ZSTD_getCParamsFromCCtxParams( + cctxParams, + unchecked(0UL - 1), + 0, + ZSTD_CParamMode_e.ZSTD_cpm_noAttachDict + ); + cParams.windowLog = saved_wlog; + mtctx->@params.cParams = cParams; + } + } + + /* ZSTDMT_getFrameProgression(): + * tells how much data has been consumed (input) and produced (output) for current frame. + * able to count progression inside worker threads. + * Note : mutex will be acquired during statistics collection inside workers. */ + private static ZSTD_frameProgression ZSTDMT_getFrameProgression(ZSTDMT_CCtx_s* mtctx) + { + ZSTD_frameProgression fps; + fps.ingested = mtctx->consumed + mtctx->inBuff.filled; + fps.consumed = mtctx->consumed; + fps.produced = fps.flushed = mtctx->produced; + fps.currentJobID = mtctx->nextJobID; + fps.nbActiveWorkers = 0; + { + uint jobNb; + uint lastJobNb = mtctx->nextJobID + (uint)mtctx->jobReady; + assert(mtctx->jobReady <= 1); + for (jobNb = mtctx->doneJobID; jobNb < lastJobNb; jobNb++) + { + uint wJobID = jobNb & mtctx->jobIDMask; + ZSTDMT_jobDescription* jobPtr = &mtctx->jobs[wJobID]; + SynchronizationWrapper.Enter(&jobPtr->job_mutex); + { + nuint cResult = jobPtr->cSize; + nuint produced = ERR_isError(cResult) ? 0 : cResult; + nuint flushed = ERR_isError(cResult) ? 0 : jobPtr->dstFlushed; + assert(flushed <= produced); + fps.ingested += jobPtr->src.size; + fps.consumed += jobPtr->consumed; + fps.produced += produced; + fps.flushed += flushed; + fps.nbActiveWorkers += jobPtr->consumed < jobPtr->src.size ? 1U : 0U; + } + + SynchronizationWrapper.Exit(&mtctx->jobs[wJobID].job_mutex); + } + } + + return fps; + } + + /*! ZSTDMT_toFlushNow() + * Tell how many bytes are ready to be flushed immediately. + * Probe the oldest active job (not yet entirely flushed) and check its output buffer. + * If return 0, it means there is no active job, + * or, it means oldest job is still active, but everything produced has been flushed so far, + * therefore flushing is limited by speed of oldest job. */ + private static nuint ZSTDMT_toFlushNow(ZSTDMT_CCtx_s* mtctx) + { + nuint toFlush; + uint jobID = mtctx->doneJobID; + assert(jobID <= mtctx->nextJobID); + if (jobID == mtctx->nextJobID) + return 0; + { + uint wJobID = jobID & mtctx->jobIDMask; + ZSTDMT_jobDescription* jobPtr = &mtctx->jobs[wJobID]; + SynchronizationWrapper.Enter(&jobPtr->job_mutex); + { + nuint cResult = jobPtr->cSize; + nuint produced = ERR_isError(cResult) ? 0 : cResult; + nuint flushed = ERR_isError(cResult) ? 0 : jobPtr->dstFlushed; + assert(flushed <= produced); + assert(jobPtr->consumed <= jobPtr->src.size); + toFlush = produced - flushed; +#if DEBUG + if (toFlush == 0) + { + assert(jobPtr->consumed < jobPtr->src.size); + } +#endif + } + + SynchronizationWrapper.Exit(&mtctx->jobs[wJobID].job_mutex); + } + + return toFlush; + } + + /* ------------------------------------------ */ + /* ===== Multi-threaded compression ===== */ + /* ------------------------------------------ */ + private static uint ZSTDMT_computeTargetJobLog(ZSTD_CCtx_params_s* @params) + { + uint jobLog; + if (@params->ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable) + { + jobLog = + 21 > ZSTD_cycleLog(@params->cParams.chainLog, @params->cParams.strategy) + 3 + ? 21 + : ZSTD_cycleLog(@params->cParams.chainLog, @params->cParams.strategy) + 3; + } + else + { + jobLog = 20 > @params->cParams.windowLog + 2 ? 20 : @params->cParams.windowLog + 2; + } + + return jobLog < (uint)(MEM_32bits ? 29 : 30) ? jobLog : (uint)(MEM_32bits ? 29 : 30); + } + + private static int ZSTDMT_overlapLog_default(ZSTD_strategy strat) + { + switch (strat) + { + case ZSTD_strategy.ZSTD_btultra2: + return 9; + case ZSTD_strategy.ZSTD_btultra: + case ZSTD_strategy.ZSTD_btopt: + return 8; + case ZSTD_strategy.ZSTD_btlazy2: + case ZSTD_strategy.ZSTD_lazy2: + return 7; + case ZSTD_strategy.ZSTD_lazy: + case ZSTD_strategy.ZSTD_greedy: + case ZSTD_strategy.ZSTD_dfast: + case ZSTD_strategy.ZSTD_fast: + default: + break; + } + + return 6; + } + + private static int ZSTDMT_overlapLog(int ovlog, ZSTD_strategy strat) + { + assert(0 <= ovlog && ovlog <= 9); + if (ovlog == 0) + return ZSTDMT_overlapLog_default(strat); + return ovlog; + } + + private static nuint ZSTDMT_computeOverlapSize(ZSTD_CCtx_params_s* @params) + { + int overlapRLog = 9 - ZSTDMT_overlapLog(@params->overlapLog, @params->cParams.strategy); + int ovLog = (int)(overlapRLog >= 8 ? 0 : @params->cParams.windowLog - (uint)overlapRLog); + assert(0 <= overlapRLog && overlapRLog <= 8); + if (@params->ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable) + { + ovLog = (int)( + ( + @params->cParams.windowLog < ZSTDMT_computeTargetJobLog(@params) - 2 + ? @params->cParams.windowLog + : ZSTDMT_computeTargetJobLog(@params) - 2 + ) - (uint)overlapRLog + ); + } + + assert(0 <= ovLog && ovLog <= (sizeof(nuint) == 4 ? 30 : 31)); + return ovLog == 0 ? 0 : (nuint)1 << ovLog; + } + + /* ====================================== */ + /* ======= Streaming API ======= */ + /* ====================================== */ + private static nuint ZSTDMT_initCStream_internal( + ZSTDMT_CCtx_s* mtctx, + void* dict, + nuint dictSize, + ZSTD_dictContentType_e dictContentType, + ZSTD_CDict_s* cdict, + ZSTD_CCtx_params_s @params, + ulong pledgedSrcSize + ) + { + assert(!ERR_isError(ZSTD_checkCParams(@params.cParams))); + assert(!(dict != null && cdict != null)); + if (@params.nbWorkers != mtctx->@params.nbWorkers) + { + /* init */ + nuint err_code = ZSTDMT_resize(mtctx, (uint)@params.nbWorkers); + if (ERR_isError(err_code)) + { + return err_code; + } + } + + if (@params.jobSize != 0 && @params.jobSize < 512 * (1 << 10)) + @params.jobSize = 512 * (1 << 10); + if (@params.jobSize > (nuint)(MEM_32bits ? 512 * (1 << 20) : 1024 * (1 << 20))) + @params.jobSize = (nuint)(MEM_32bits ? 512 * (1 << 20) : 1024 * (1 << 20)); + if (mtctx->allJobsCompleted == 0) + { + ZSTDMT_waitForAllJobsCompleted(mtctx); + ZSTDMT_releaseAllJobResources(mtctx); + mtctx->allJobsCompleted = 1; + } + + mtctx->@params = @params; + mtctx->frameContentSize = pledgedSrcSize; + ZSTD_freeCDict(mtctx->cdictLocal); + if (dict != null) + { + mtctx->cdictLocal = ZSTD_createCDict_advanced( + dict, + dictSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byCopy, + dictContentType, + @params.cParams, + mtctx->cMem + ); + mtctx->cdict = mtctx->cdictLocal; + if (mtctx->cdictLocal == null) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + else + { + mtctx->cdictLocal = null; + mtctx->cdict = cdict; + } + + mtctx->targetPrefixSize = ZSTDMT_computeOverlapSize(&@params); + mtctx->targetSectionSize = @params.jobSize; + if (mtctx->targetSectionSize == 0) + { + mtctx->targetSectionSize = (nuint)(1UL << (int)ZSTDMT_computeTargetJobLog(&@params)); + } + + assert( + mtctx->targetSectionSize <= (nuint)(MEM_32bits ? 512 * (1 << 20) : 1024 * (1 << 20)) + ); + if (@params.rsyncable != 0) + { + /* Aim for the targetsectionSize as the average job size. */ + uint jobSizeKB = (uint)(mtctx->targetSectionSize >> 10); + assert(jobSizeKB >= 1); + uint rsyncBits = ZSTD_highbit32(jobSizeKB) + 10; + assert(rsyncBits >= 17 + 2); + mtctx->rsync.hash = 0; + mtctx->rsync.hitMask = (1UL << (int)rsyncBits) - 1; + mtctx->rsync.primePower = ZSTD_rollingHash_primePower(32); + } + + if (mtctx->targetSectionSize < mtctx->targetPrefixSize) + mtctx->targetSectionSize = mtctx->targetPrefixSize; + ZSTDMT_setBufferSize(mtctx->bufPool, ZSTD_compressBound(mtctx->targetSectionSize)); + { + /* If ldm is enabled we need windowSize space. */ + nuint windowSize = + mtctx->@params.ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable + ? 1U << (int)mtctx->@params.cParams.windowLog + : 0; + /* Two buffers of slack, plus extra space for the overlap + * This is the minimum slack that LDM works with. One extra because + * flush might waste up to targetSectionSize-1 bytes. Another extra + * for the overlap (if > 0), then one to fill which doesn't overlap + * with the LDM window. + */ + nuint nbSlackBuffers = (nuint)(2 + (mtctx->targetPrefixSize > 0 ? 1 : 0)); + nuint slackSize = mtctx->targetSectionSize * nbSlackBuffers; + /* Compute the total size, and always have enough slack */ + nuint nbWorkers = (nuint)(mtctx->@params.nbWorkers > 1 ? mtctx->@params.nbWorkers : 1); + nuint sectionsSize = mtctx->targetSectionSize * nbWorkers; + nuint capacity = (windowSize > sectionsSize ? windowSize : sectionsSize) + slackSize; + if (mtctx->roundBuff.capacity < capacity) + { + if (mtctx->roundBuff.buffer != null) + ZSTD_customFree(mtctx->roundBuff.buffer, mtctx->cMem); + mtctx->roundBuff.buffer = (byte*)ZSTD_customMalloc(capacity, mtctx->cMem); + if (mtctx->roundBuff.buffer == null) + { + mtctx->roundBuff.capacity = 0; + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + + mtctx->roundBuff.capacity = capacity; + } + } + + mtctx->roundBuff.pos = 0; + mtctx->inBuff.buffer = g_nullBuffer; + mtctx->inBuff.filled = 0; + mtctx->inBuff.prefix = kNullRange; + mtctx->doneJobID = 0; + mtctx->nextJobID = 0; + mtctx->frameEnded = 0; + mtctx->allJobsCompleted = 0; + mtctx->consumed = 0; + mtctx->produced = 0; + ZSTD_freeCDict(mtctx->cdictLocal); + mtctx->cdictLocal = null; + mtctx->cdict = null; + if (dict != null) + { + if (dictContentType == ZSTD_dictContentType_e.ZSTD_dct_rawContent) + { + mtctx->inBuff.prefix.start = (byte*)dict; + mtctx->inBuff.prefix.size = dictSize; + } + else + { + mtctx->cdictLocal = ZSTD_createCDict_advanced( + dict, + dictSize, + ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef, + dictContentType, + @params.cParams, + mtctx->cMem + ); + mtctx->cdict = mtctx->cdictLocal; + if (mtctx->cdictLocal == null) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + } + } + else + { + mtctx->cdict = cdict; + } + + if ( + ZSTDMT_serialState_reset( + &mtctx->serial, + mtctx->seqPool, + @params, + mtctx->targetSectionSize, + dict, + dictSize, + dictContentType + ) != 0 + ) + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + return 0; + } + + /* ZSTDMT_writeLastEmptyBlock() + * Write a single empty block with an end-of-frame to finish a frame. + * Job must be created from streaming variant. + * This function is always successful if expected conditions are fulfilled. + */ + private static void ZSTDMT_writeLastEmptyBlock(ZSTDMT_jobDescription* job) + { + assert(job->lastJob == 1); + assert(job->src.size == 0); + assert(job->firstJob == 0); + assert(job->dstBuff.start == null); + job->dstBuff = ZSTDMT_getBuffer(job->bufPool); + if (job->dstBuff.start == null) + { + job->cSize = unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)); + return; + } + + assert(job->dstBuff.capacity >= ZSTD_blockHeaderSize); + job->src = kNullRange; + job->cSize = ZSTD_writeLastEmptyBlock(job->dstBuff.start, job->dstBuff.capacity); + assert(!ERR_isError(job->cSize)); + assert(job->consumed == 0); + } + + private static nuint ZSTDMT_createCompressionJob( + ZSTDMT_CCtx_s* mtctx, + nuint srcSize, + ZSTD_EndDirective endOp + ) + { + uint jobID = mtctx->nextJobID & mtctx->jobIDMask; + int endFrame = endOp == ZSTD_EndDirective.ZSTD_e_end ? 1 : 0; + if (mtctx->nextJobID > mtctx->doneJobID + mtctx->jobIDMask) + { + assert((mtctx->nextJobID & mtctx->jobIDMask) == (mtctx->doneJobID & mtctx->jobIDMask)); + return 0; + } + + if (mtctx->jobReady == 0) + { + byte* src = (byte*)mtctx->inBuff.buffer.start; + mtctx->jobs[jobID].src.start = src; + mtctx->jobs[jobID].src.size = srcSize; + assert(mtctx->inBuff.filled >= srcSize); + mtctx->jobs[jobID].prefix = mtctx->inBuff.prefix; + mtctx->jobs[jobID].consumed = 0; + mtctx->jobs[jobID].cSize = 0; + mtctx->jobs[jobID].@params = mtctx->@params; + mtctx->jobs[jobID].cdict = mtctx->nextJobID == 0 ? mtctx->cdict : null; + mtctx->jobs[jobID].fullFrameSize = mtctx->frameContentSize; + mtctx->jobs[jobID].dstBuff = g_nullBuffer; + mtctx->jobs[jobID].cctxPool = mtctx->cctxPool; + mtctx->jobs[jobID].bufPool = mtctx->bufPool; + mtctx->jobs[jobID].seqPool = mtctx->seqPool; + mtctx->jobs[jobID].serial = &mtctx->serial; + mtctx->jobs[jobID].jobID = mtctx->nextJobID; + mtctx->jobs[jobID].firstJob = mtctx->nextJobID == 0 ? 1U : 0U; + mtctx->jobs[jobID].lastJob = (uint)endFrame; + mtctx->jobs[jobID].frameChecksumNeeded = + mtctx->@params.fParams.checksumFlag != 0 && endFrame != 0 && mtctx->nextJobID > 0 + ? 1U + : 0U; + mtctx->jobs[jobID].dstFlushed = 0; + mtctx->roundBuff.pos += srcSize; + mtctx->inBuff.buffer = g_nullBuffer; + mtctx->inBuff.filled = 0; + if (endFrame == 0) + { + nuint newPrefixSize = + srcSize < mtctx->targetPrefixSize ? srcSize : mtctx->targetPrefixSize; + mtctx->inBuff.prefix.start = src + srcSize - newPrefixSize; + mtctx->inBuff.prefix.size = newPrefixSize; + } + else + { + mtctx->inBuff.prefix = kNullRange; + mtctx->frameEnded = (uint)endFrame; + if (mtctx->nextJobID == 0) + { + mtctx->@params.fParams.checksumFlag = 0; + } + } + + if (srcSize == 0 && mtctx->nextJobID > 0) + { + assert(endOp == ZSTD_EndDirective.ZSTD_e_end); + ZSTDMT_writeLastEmptyBlock(mtctx->jobs + jobID); + mtctx->nextJobID++; + return 0; + } + } + + if ( + POOL_tryAdd( + mtctx->factory, + (delegate* managed)(&ZSTDMT_compressionJob), + &mtctx->jobs[jobID] + ) != 0 + ) + { + mtctx->nextJobID++; + mtctx->jobReady = 0; + } + else + { + mtctx->jobReady = 1; + } + + return 0; + } + + /*! ZSTDMT_flushProduced() : + * flush whatever data has been produced but not yet flushed in current job. + * move to next job if current one is fully flushed. + * `output` : `pos` will be updated with amount of data flushed . + * `blockToFlush` : if >0, the function will block and wait if there is no data available to flush . + * @return : amount of data remaining within internal buffer, 0 if no more, 1 if unknown but > 0, or an error code */ + private static nuint ZSTDMT_flushProduced( + ZSTDMT_CCtx_s* mtctx, + ZSTD_outBuffer_s* output, + uint blockToFlush, + ZSTD_EndDirective end + ) + { + uint wJobID = mtctx->doneJobID & mtctx->jobIDMask; + assert(output->size >= output->pos); + SynchronizationWrapper.Enter(&mtctx->jobs[wJobID].job_mutex); + if (blockToFlush != 0 && mtctx->doneJobID < mtctx->nextJobID) + { + assert(mtctx->jobs[wJobID].dstFlushed <= mtctx->jobs[wJobID].cSize); + while (mtctx->jobs[wJobID].dstFlushed == mtctx->jobs[wJobID].cSize) + { + if (mtctx->jobs[wJobID].consumed == mtctx->jobs[wJobID].src.size) + { + break; + } + + SynchronizationWrapper.Wait(&mtctx->jobs[wJobID].job_mutex); + } + } + + { + /* shared */ + nuint cSize = mtctx->jobs[wJobID].cSize; + /* shared */ + nuint srcConsumed = mtctx->jobs[wJobID].consumed; + /* read-only, could be done after mutex lock, but no-declaration-after-statement */ + nuint srcSize = mtctx->jobs[wJobID].src.size; + SynchronizationWrapper.Exit(&mtctx->jobs[wJobID].job_mutex); + if (ERR_isError(cSize)) + { + ZSTDMT_waitForAllJobsCompleted(mtctx); + ZSTDMT_releaseAllJobResources(mtctx); + return cSize; + } + + assert(srcConsumed <= srcSize); + if (srcConsumed == srcSize && mtctx->jobs[wJobID].frameChecksumNeeded != 0) + { + uint checksum = (uint)ZSTD_XXH64_digest(&mtctx->serial.xxhState); + MEM_writeLE32( + (sbyte*)mtctx->jobs[wJobID].dstBuff.start + mtctx->jobs[wJobID].cSize, + checksum + ); + cSize += 4; + mtctx->jobs[wJobID].cSize += 4; + mtctx->jobs[wJobID].frameChecksumNeeded = 0; + } + + if (cSize > 0) + { + nuint toFlush = + cSize - mtctx->jobs[wJobID].dstFlushed < output->size - output->pos + ? cSize - mtctx->jobs[wJobID].dstFlushed + : output->size - output->pos; + assert(mtctx->doneJobID < mtctx->nextJobID); + assert(cSize >= mtctx->jobs[wJobID].dstFlushed); + assert(mtctx->jobs[wJobID].dstBuff.start != null); + if (toFlush > 0) + { + memcpy( + (sbyte*)output->dst + output->pos, + (sbyte*)mtctx->jobs[wJobID].dstBuff.start + mtctx->jobs[wJobID].dstFlushed, + (uint)toFlush + ); + } + + output->pos += toFlush; + mtctx->jobs[wJobID].dstFlushed += toFlush; + if (srcConsumed == srcSize && mtctx->jobs[wJobID].dstFlushed == cSize) + { + ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[wJobID].dstBuff); + mtctx->jobs[wJobID].dstBuff = g_nullBuffer; + mtctx->jobs[wJobID].cSize = 0; + mtctx->consumed += srcSize; + mtctx->produced += cSize; + mtctx->doneJobID++; + } + } + + if (cSize > mtctx->jobs[wJobID].dstFlushed) + return cSize - mtctx->jobs[wJobID].dstFlushed; + if (srcSize > srcConsumed) + return 1; + } + + if (mtctx->doneJobID < mtctx->nextJobID) + return 1; + if (mtctx->jobReady != 0) + return 1; + if (mtctx->inBuff.filled > 0) + return 1; + mtctx->allJobsCompleted = mtctx->frameEnded; + if (end == ZSTD_EndDirective.ZSTD_e_end) + return mtctx->frameEnded == 0 ? 1U : 0U; + return 0; + } + + /** + * Returns the range of data used by the earliest job that is not yet complete. + * If the data of the first job is broken up into two segments, we cover both + * sections. + */ + private static Range ZSTDMT_getInputDataInUse(ZSTDMT_CCtx_s* mtctx) + { + uint firstJobID = mtctx->doneJobID; + uint lastJobID = mtctx->nextJobID; + uint jobID; + /* no need to check during first round */ + nuint roundBuffCapacity = mtctx->roundBuff.capacity; + nuint nbJobs1stRoundMin = roundBuffCapacity / mtctx->targetSectionSize; + if (lastJobID < nbJobs1stRoundMin) + return kNullRange; + for (jobID = firstJobID; jobID < lastJobID; ++jobID) + { + uint wJobID = jobID & mtctx->jobIDMask; + nuint consumed; + SynchronizationWrapper.Enter(&mtctx->jobs[wJobID].job_mutex); + consumed = mtctx->jobs[wJobID].consumed; + SynchronizationWrapper.Exit(&mtctx->jobs[wJobID].job_mutex); + if (consumed < mtctx->jobs[wJobID].src.size) + { + Range range = mtctx->jobs[wJobID].prefix; + if (range.size == 0) + { + range = mtctx->jobs[wJobID].src; + } + + assert(range.start <= mtctx->jobs[wJobID].src.start); + return range; + } + } + + return kNullRange; + } + + /** + * Returns non-zero iff buffer and range overlap. + */ + private static int ZSTDMT_isOverlapped(buffer_s buffer, Range range) + { + byte* bufferStart = (byte*)buffer.start; + byte* rangeStart = (byte*)range.start; + if (rangeStart == null || bufferStart == null) + return 0; + { + byte* bufferEnd = bufferStart + buffer.capacity; + byte* rangeEnd = rangeStart + range.size; + if (bufferStart == bufferEnd || rangeStart == rangeEnd) + return 0; + return bufferStart < rangeEnd && rangeStart < bufferEnd ? 1 : 0; + } + } + + private static int ZSTDMT_doesOverlapWindow(buffer_s buffer, ZSTD_window_t window) + { + Range extDict; + Range prefix; + extDict.start = window.dictBase + window.lowLimit; + extDict.size = window.dictLimit - window.lowLimit; + prefix.start = window.@base + window.dictLimit; + prefix.size = (nuint)(window.nextSrc - (window.@base + window.dictLimit)); + return ZSTDMT_isOverlapped(buffer, extDict) != 0 || ZSTDMT_isOverlapped(buffer, prefix) != 0 + ? 1 + : 0; + } + + private static void ZSTDMT_waitForLdmComplete(ZSTDMT_CCtx_s* mtctx, buffer_s buffer) + { + if (mtctx->@params.ldmParams.enableLdm == ZSTD_paramSwitch_e.ZSTD_ps_enable) + { + void** mutex = &mtctx->serial.ldmWindowMutex; + SynchronizationWrapper.Enter(mutex); + while (ZSTDMT_doesOverlapWindow(buffer, mtctx->serial.ldmWindow) != 0) + { + SynchronizationWrapper.Wait(mutex); + } + + SynchronizationWrapper.Exit(mutex); + } + } + + /** + * Attempts to set the inBuff to the next section to fill. + * If any part of the new section is still in use we give up. + * Returns non-zero if the buffer is filled. + */ + private static int ZSTDMT_tryGetInputRange(ZSTDMT_CCtx_s* mtctx) + { + Range inUse = ZSTDMT_getInputDataInUse(mtctx); + nuint spaceLeft = mtctx->roundBuff.capacity - mtctx->roundBuff.pos; + nuint spaceNeeded = mtctx->targetSectionSize; + buffer_s buffer; + assert(mtctx->inBuff.buffer.start == null); + assert(mtctx->roundBuff.capacity >= spaceNeeded); + if (spaceLeft < spaceNeeded) + { + /* ZSTD_invalidateRepCodes() doesn't work for extDict variants. + * Simply copy the prefix to the beginning in that case. + */ + byte* start = mtctx->roundBuff.buffer; + nuint prefixSize = mtctx->inBuff.prefix.size; + buffer.start = start; + buffer.capacity = prefixSize; + if (ZSTDMT_isOverlapped(buffer, inUse) != 0) + { + return 0; + } + + ZSTDMT_waitForLdmComplete(mtctx, buffer); + memmove(start, mtctx->inBuff.prefix.start, prefixSize); + mtctx->inBuff.prefix.start = start; + mtctx->roundBuff.pos = prefixSize; + } + + buffer.start = mtctx->roundBuff.buffer + mtctx->roundBuff.pos; + buffer.capacity = spaceNeeded; + if (ZSTDMT_isOverlapped(buffer, inUse) != 0) + { + return 0; + } + + assert(ZSTDMT_isOverlapped(buffer, mtctx->inBuff.prefix) == 0); + ZSTDMT_waitForLdmComplete(mtctx, buffer); + mtctx->inBuff.buffer = buffer; + mtctx->inBuff.filled = 0; + assert(mtctx->roundBuff.pos + buffer.capacity <= mtctx->roundBuff.capacity); + return 1; + } + + /** + * Searches through the input for a synchronization point. If one is found, we + * will instruct the caller to flush, and return the number of bytes to load. + * Otherwise, we will load as many bytes as possible and instruct the caller + * to continue as normal. + */ + private static SyncPoint findSynchronizationPoint(ZSTDMT_CCtx_s* mtctx, ZSTD_inBuffer_s input) + { + byte* istart = (byte*)input.src + input.pos; + ulong primePower = mtctx->rsync.primePower; + ulong hitMask = mtctx->rsync.hitMask; + SyncPoint syncPoint; + ulong hash; + byte* prev; + nuint pos; + syncPoint.toLoad = + input.size - input.pos < mtctx->targetSectionSize - mtctx->inBuff.filled + ? input.size - input.pos + : mtctx->targetSectionSize - mtctx->inBuff.filled; + syncPoint.flush = 0; + if (mtctx->@params.rsyncable == 0) + return syncPoint; + if (mtctx->inBuff.filled + input.size - input.pos < 1 << 17) + return syncPoint; + if (mtctx->inBuff.filled + syncPoint.toLoad < 32) + return syncPoint; + if (mtctx->inBuff.filled < 1 << 17) + { + pos = (1 << 17) - mtctx->inBuff.filled; + if (pos >= 32) + { + prev = istart + pos - 32; + hash = ZSTD_rollingHash_compute(prev, 32); + } + else + { + assert(mtctx->inBuff.filled >= 32); + prev = (byte*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled - 32; + hash = ZSTD_rollingHash_compute(prev + pos, 32 - pos); + hash = ZSTD_rollingHash_append(hash, istart, pos); + } + } + else + { + assert(mtctx->inBuff.filled >= 1 << 17); + assert(1 << 17 >= 32); + pos = 0; + prev = (byte*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled - 32; + hash = ZSTD_rollingHash_compute(prev, 32); + if ((hash & hitMask) == hitMask) + { + syncPoint.toLoad = 0; + syncPoint.flush = 1; + return syncPoint; + } + } + + assert(pos < 32 || ZSTD_rollingHash_compute(istart + pos - 32, 32) == hash); + for (; pos < syncPoint.toLoad; ++pos) + { + byte toRemove = pos < 32 ? prev[pos] : istart[pos - 32]; + hash = ZSTD_rollingHash_rotate(hash, toRemove, istart[pos], primePower); + assert(mtctx->inBuff.filled + pos >= 1 << 17); + if ((hash & hitMask) == hitMask) + { + syncPoint.toLoad = pos + 1; + syncPoint.flush = 1; + ++pos; + break; + } + } + + assert(pos < 32 || ZSTD_rollingHash_compute(istart + pos - 32, 32) == hash); + return syncPoint; + } + + /* === Streaming functions === */ + private static nuint ZSTDMT_nextInputSizeHint(ZSTDMT_CCtx_s* mtctx) + { + nuint hintInSize = mtctx->targetSectionSize - mtctx->inBuff.filled; + if (hintInSize == 0) + hintInSize = mtctx->targetSectionSize; + return hintInSize; + } + + /** ZSTDMT_compressStream_generic() : + * internal use only - exposed to be invoked from zstd_compress.c + * assumption : output and input are valid (pos <= size) + * @return : minimum amount of data remaining to flush, 0 if none */ + private static nuint ZSTDMT_compressStream_generic( + ZSTDMT_CCtx_s* mtctx, + ZSTD_outBuffer_s* output, + ZSTD_inBuffer_s* input, + ZSTD_EndDirective endOp + ) + { + uint forwardInputProgress = 0; + assert(output->pos <= output->size); + assert(input->pos <= input->size); + if (mtctx->frameEnded != 0 && endOp == ZSTD_EndDirective.ZSTD_e_continue) + { + return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_stage_wrong)); + } + + if (mtctx->jobReady == 0 && input->size > input->pos) + { + if (mtctx->inBuff.buffer.start == null) + { + assert(mtctx->inBuff.filled == 0); + if (ZSTDMT_tryGetInputRange(mtctx) == 0) + { + assert(mtctx->doneJobID != mtctx->nextJobID); + } + } + + if (mtctx->inBuff.buffer.start != null) + { + SyncPoint syncPoint = findSynchronizationPoint(mtctx, *input); + if (syncPoint.flush != 0 && endOp == ZSTD_EndDirective.ZSTD_e_continue) + { + endOp = ZSTD_EndDirective.ZSTD_e_flush; + } + + assert(mtctx->inBuff.buffer.capacity >= mtctx->targetSectionSize); + memcpy( + (sbyte*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled, + (sbyte*)input->src + input->pos, + (uint)syncPoint.toLoad + ); + input->pos += syncPoint.toLoad; + mtctx->inBuff.filled += syncPoint.toLoad; + forwardInputProgress = syncPoint.toLoad > 0 ? 1U : 0U; + } + } + + if (input->pos < input->size && endOp == ZSTD_EndDirective.ZSTD_e_end) + { + assert( + mtctx->inBuff.filled == 0 + || mtctx->inBuff.filled == mtctx->targetSectionSize + || mtctx->@params.rsyncable != 0 + ); + endOp = ZSTD_EndDirective.ZSTD_e_flush; + } + + if ( + mtctx->jobReady != 0 + || mtctx->inBuff.filled >= mtctx->targetSectionSize + || endOp != ZSTD_EndDirective.ZSTD_e_continue && mtctx->inBuff.filled > 0 + || endOp == ZSTD_EndDirective.ZSTD_e_end && mtctx->frameEnded == 0 + ) + { + nuint jobSize = mtctx->inBuff.filled; + assert(mtctx->inBuff.filled <= mtctx->targetSectionSize); + { + nuint err_code = ZSTDMT_createCompressionJob(mtctx, jobSize, endOp); + if (ERR_isError(err_code)) + { + return err_code; + } + } + } + + { + /* block if there was no forward input progress */ + nuint remainingToFlush = ZSTDMT_flushProduced( + mtctx, + output, + forwardInputProgress == 0 ? 1U : 0U, + endOp + ); + if (input->pos < input->size) + return remainingToFlush > 1 ? remainingToFlush : 1; + return remainingToFlush; + } + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/_wksps_e__Union.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/_wksps_e__Union.cs new file mode 100644 index 000000000..af51bc197 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/_wksps_e__Union.cs @@ -0,0 +1,16 @@ +using System.Runtime.InteropServices; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +[StructLayout(LayoutKind.Explicit)] +public unsafe struct _wksps_e__Union +{ + [FieldOffset(0)] + public HUF_buildCTable_wksp_tables buildCTable_wksp; + + [FieldOffset(0)] + public HUF_WriteCTableWksp writeCTable_wksp; + + [FieldOffset(0)] + public fixed uint hist_wksp[1024]; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/algo_time_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/algo_time_t.cs new file mode 100644 index 000000000..869a68805 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/algo_time_t.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct algo_time_t +{ + public uint tableTime; + public uint decode256Time; + + public algo_time_t(uint tableTime, uint decode256Time) + { + this.tableTime = tableTime; + this.decode256Time = decode256Time; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/base_directive_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/base_directive_e.cs new file mode 100644 index 000000000..b461bbfdb --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/base_directive_e.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum base_directive_e +{ + base_0possible = 0, + base_1guaranteed = 1, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/blockProperties_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/blockProperties_t.cs new file mode 100644 index 000000000..e1f68e389 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/blockProperties_t.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct blockProperties_t +{ + public blockType_e blockType; + public uint lastBlock; + public uint origSize; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/blockType_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/blockType_e.cs new file mode 100644 index 000000000..1c0df0a25 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/blockType_e.cs @@ -0,0 +1,9 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum blockType_e +{ + bt_raw, + bt_rle, + bt_compressed, + bt_reserved, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/buffer_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/buffer_s.cs new file mode 100644 index 000000000..6ddf1b227 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/buffer_s.cs @@ -0,0 +1,15 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* ===== Buffer Pool ===== */ +/* a single Buffer Pool can be invoked from multiple threads in parallel */ +public unsafe struct buffer_s +{ + public void* start; + public nuint capacity; + + public buffer_s(void* start, nuint capacity) + { + this.start = start; + this.capacity = capacity; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/dictItem.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/dictItem.cs new file mode 100644 index 000000000..929fea695 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/dictItem.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct dictItem +{ + public uint pos; + public uint length; + public uint savings; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/inBuff_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/inBuff_t.cs new file mode 100644 index 000000000..1ea5fe48a --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/inBuff_t.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* ------------------------------------------ */ +/* ===== Multi-threaded compression ===== */ +/* ------------------------------------------ */ +public struct InBuff_t +{ + /* read-only non-owned prefix buffer */ + public Range prefix; + public buffer_s buffer; + public nuint filled; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmEntry_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmEntry_t.cs new file mode 100644 index 000000000..81304ceae --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmEntry_t.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ldmEntry_t +{ + public uint offset; + public uint checksum; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmMatchCandidate_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmMatchCandidate_t.cs new file mode 100644 index 000000000..e6f6d465f --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmMatchCandidate_t.cs @@ -0,0 +1,9 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ldmMatchCandidate_t +{ + public byte* split; + public uint hash; + public uint checksum; + public ldmEntry_t* bucket; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmParams_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmParams_t.cs new file mode 100644 index 000000000..71c108dd5 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmParams_t.cs @@ -0,0 +1,22 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ldmParams_t +{ + /* ZSTD_ps_enable to enable LDM. ZSTD_ps_auto by default */ + public ZSTD_paramSwitch_e enableLdm; + + /* Log size of hashTable */ + public uint hashLog; + + /* Log bucket size for collision resolution, at most 8 */ + public uint bucketSizeLog; + + /* Minimum match length */ + public uint minMatchLength; + + /* Log number of entries to skip */ + public uint hashRateLog; + + /* Window log for the LDM */ + public uint windowLog; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmRollingHashState_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmRollingHashState_t.cs new file mode 100644 index 000000000..73d11fd48 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmRollingHashState_t.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct ldmRollingHashState_t +{ + public ulong rolling; + public ulong stopMask; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmState_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmState_t.cs new file mode 100644 index 000000000..5596880d7 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/ldmState_t.cs @@ -0,0 +1,170 @@ +using System.Runtime.CompilerServices; + +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct ldmState_t +{ + /* State for the window round buffer management */ + public ZSTD_window_t window; + public ldmEntry_t* hashTable; + public uint loadedDictEnd; + + /* Next position in bucket to insert entry */ + public byte* bucketOffsets; + public _splitIndices_e__FixedBuffer splitIndices; + public _matchCandidates_e__FixedBuffer matchCandidates; + +#if NET8_0_OR_GREATER + [InlineArray(64)] + public unsafe struct _splitIndices_e__FixedBuffer + { + public nuint e0; + } + +#else + public unsafe struct _splitIndices_e__FixedBuffer + { + public nuint e0; + public nuint e1; + public nuint e2; + public nuint e3; + public nuint e4; + public nuint e5; + public nuint e6; + public nuint e7; + public nuint e8; + public nuint e9; + public nuint e10; + public nuint e11; + public nuint e12; + public nuint e13; + public nuint e14; + public nuint e15; + public nuint e16; + public nuint e17; + public nuint e18; + public nuint e19; + public nuint e20; + public nuint e21; + public nuint e22; + public nuint e23; + public nuint e24; + public nuint e25; + public nuint e26; + public nuint e27; + public nuint e28; + public nuint e29; + public nuint e30; + public nuint e31; + public nuint e32; + public nuint e33; + public nuint e34; + public nuint e35; + public nuint e36; + public nuint e37; + public nuint e38; + public nuint e39; + public nuint e40; + public nuint e41; + public nuint e42; + public nuint e43; + public nuint e44; + public nuint e45; + public nuint e46; + public nuint e47; + public nuint e48; + public nuint e49; + public nuint e50; + public nuint e51; + public nuint e52; + public nuint e53; + public nuint e54; + public nuint e55; + public nuint e56; + public nuint e57; + public nuint e58; + public nuint e59; + public nuint e60; + public nuint e61; + public nuint e62; + public nuint e63; + } +#endif + +#if NET8_0_OR_GREATER + [InlineArray(64)] + public unsafe struct _matchCandidates_e__FixedBuffer + { + public ldmMatchCandidate_t e0; + } + +#else + public unsafe struct _matchCandidates_e__FixedBuffer + { + public ldmMatchCandidate_t e0; + public ldmMatchCandidate_t e1; + public ldmMatchCandidate_t e2; + public ldmMatchCandidate_t e3; + public ldmMatchCandidate_t e4; + public ldmMatchCandidate_t e5; + public ldmMatchCandidate_t e6; + public ldmMatchCandidate_t e7; + public ldmMatchCandidate_t e8; + public ldmMatchCandidate_t e9; + public ldmMatchCandidate_t e10; + public ldmMatchCandidate_t e11; + public ldmMatchCandidate_t e12; + public ldmMatchCandidate_t e13; + public ldmMatchCandidate_t e14; + public ldmMatchCandidate_t e15; + public ldmMatchCandidate_t e16; + public ldmMatchCandidate_t e17; + public ldmMatchCandidate_t e18; + public ldmMatchCandidate_t e19; + public ldmMatchCandidate_t e20; + public ldmMatchCandidate_t e21; + public ldmMatchCandidate_t e22; + public ldmMatchCandidate_t e23; + public ldmMatchCandidate_t e24; + public ldmMatchCandidate_t e25; + public ldmMatchCandidate_t e26; + public ldmMatchCandidate_t e27; + public ldmMatchCandidate_t e28; + public ldmMatchCandidate_t e29; + public ldmMatchCandidate_t e30; + public ldmMatchCandidate_t e31; + public ldmMatchCandidate_t e32; + public ldmMatchCandidate_t e33; + public ldmMatchCandidate_t e34; + public ldmMatchCandidate_t e35; + public ldmMatchCandidate_t e36; + public ldmMatchCandidate_t e37; + public ldmMatchCandidate_t e38; + public ldmMatchCandidate_t e39; + public ldmMatchCandidate_t e40; + public ldmMatchCandidate_t e41; + public ldmMatchCandidate_t e42; + public ldmMatchCandidate_t e43; + public ldmMatchCandidate_t e44; + public ldmMatchCandidate_t e45; + public ldmMatchCandidate_t e46; + public ldmMatchCandidate_t e47; + public ldmMatchCandidate_t e48; + public ldmMatchCandidate_t e49; + public ldmMatchCandidate_t e50; + public ldmMatchCandidate_t e51; + public ldmMatchCandidate_t e52; + public ldmMatchCandidate_t e53; + public ldmMatchCandidate_t e54; + public ldmMatchCandidate_t e55; + public ldmMatchCandidate_t e56; + public ldmMatchCandidate_t e57; + public ldmMatchCandidate_t e58; + public ldmMatchCandidate_t e59; + public ldmMatchCandidate_t e60; + public ldmMatchCandidate_t e61; + public ldmMatchCandidate_t e62; + public ldmMatchCandidate_t e63; + } +#endif +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/nodeElt_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/nodeElt_s.cs new file mode 100644 index 000000000..de28886cf --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/nodeElt_s.cs @@ -0,0 +1,12 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* ************************************************************** + * Required declarations + ****************************************************************/ +public struct nodeElt_s +{ + public uint count; + public ushort parent; + public byte @byte; + public byte nbBits; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/offsetCount_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/offsetCount_t.cs new file mode 100644 index 000000000..9a5c80981 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/offsetCount_t.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct offsetCount_t +{ + public uint offset; + public uint count; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/optState_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/optState_t.cs new file mode 100644 index 000000000..d15e86840 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/optState_t.cs @@ -0,0 +1,53 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct optState_t +{ + /* table of literals statistics, of size 256 */ + public uint* litFreq; + + /* table of litLength statistics, of size (MaxLL+1) */ + public uint* litLengthFreq; + + /* table of matchLength statistics, of size (MaxML+1) */ + public uint* matchLengthFreq; + + /* table of offCode statistics, of size (MaxOff+1) */ + public uint* offCodeFreq; + + /* list of found matches, of size ZSTD_OPT_SIZE */ + public ZSTD_match_t* matchTable; + + /* All positions tracked by optimal parser, of size ZSTD_OPT_SIZE */ + public ZSTD_optimal_t* priceTable; + + /* nb of literals */ + public uint litSum; + + /* nb of litLength codes */ + public uint litLengthSum; + + /* nb of matchLength codes */ + public uint matchLengthSum; + + /* nb of offset codes */ + public uint offCodeSum; + + /* to compare to log2(litfreq) */ + public uint litSumBasePrice; + + /* to compare to log2(llfreq) */ + public uint litLengthSumBasePrice; + + /* to compare to log2(mlfreq) */ + public uint matchLengthSumBasePrice; + + /* to compare to log2(offreq) */ + public uint offCodeSumBasePrice; + + /* prices can be determined dynamically, or follow a pre-defined cost structure */ + public ZSTD_OptPrice_e priceType; + + /* pre-calculated dictionary statistics */ + public ZSTD_entropyCTables_t* symbolCosts; + public ZSTD_paramSwitch_e literalCompressionMode; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/rankPos.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/rankPos.cs new file mode 100644 index 000000000..c93cb1f68 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/rankPos.cs @@ -0,0 +1,7 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct rankPos +{ + public ushort @base; + public ushort curr; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/rankValCol_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/rankValCol_t.cs new file mode 100644 index 000000000..94eea418a --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/rankValCol_t.cs @@ -0,0 +1,6 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct rankValCol_t +{ + public fixed uint Body[13]; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/rawSeq.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/rawSeq.cs new file mode 100644 index 000000000..e2c315d72 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/rawSeq.cs @@ -0,0 +1,13 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct rawSeq +{ + /* Offset of sequence */ + public uint offset; + + /* Length of literals prior to match */ + public uint litLength; + + /* Raw length of match */ + public uint matchLength; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/repcodes_s.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/repcodes_s.cs new file mode 100644 index 000000000..f9b97bda6 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/repcodes_s.cs @@ -0,0 +1,6 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct repcodes_s +{ + public fixed uint rep[3]; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/searchMethod_e.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/searchMethod_e.cs new file mode 100644 index 000000000..10395b044 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/searchMethod_e.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public enum searchMethod_e +{ + search_hashChain = 0, + search_binaryTree = 1, + search_rowHash = 2, +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/seqState_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/seqState_t.cs new file mode 100644 index 000000000..a6aec9c33 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/seqState_t.cs @@ -0,0 +1,17 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public unsafe struct seqState_t +{ + public BIT_DStream_t DStream; + public ZSTD_fseState stateLL; + public ZSTD_fseState stateOffb; + public ZSTD_fseState stateML; + public _prevOffset_e__FixedBuffer prevOffset; + + public unsafe struct _prevOffset_e__FixedBuffer + { + public nuint e0; + public nuint e1; + public nuint e2; + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/seqStoreSplits.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/seqStoreSplits.cs new file mode 100644 index 000000000..83679d5f5 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/seqStoreSplits.cs @@ -0,0 +1,11 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* Struct to keep track of where we are in our recursive calls. */ +public unsafe struct seqStoreSplits +{ + /* Array of split indices */ + public uint* splitLocations; + + /* The current index within splitLocations being worked on */ + public nuint idx; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/seq_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/seq_t.cs new file mode 100644 index 000000000..88395a257 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/seq_t.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct seq_t +{ + public nuint litLength; + public nuint matchLength; + public nuint offset; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/sortedSymbol_t.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/sortedSymbol_t.cs new file mode 100644 index 000000000..acfe3dd90 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/sortedSymbol_t.cs @@ -0,0 +1,6 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +public struct sortedSymbol_t +{ + public byte symbol; +} diff --git a/src/SharpCompress/Compressors/ZStandard/Unsafe/streaming_operation.cs b/src/SharpCompress/Compressors/ZStandard/Unsafe/streaming_operation.cs new file mode 100644 index 000000000..77f189ec9 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/Unsafe/streaming_operation.cs @@ -0,0 +1,8 @@ +namespace SharpCompress.Compressors.ZStandard.Unsafe; + +/* Streaming state is used to inform allocation of the literal buffer */ +public enum streaming_operation +{ + not_streaming = 0, + is_streaming = 1, +} diff --git a/src/SharpCompress/Compressors/ZStandard/UnsafeHelper.cs b/src/SharpCompress/Compressors/ZStandard/UnsafeHelper.cs new file mode 100644 index 000000000..b145099b3 --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/UnsafeHelper.cs @@ -0,0 +1,107 @@ +using System; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace SharpCompress.Compressors.ZStandard; + +public static unsafe class UnsafeHelper +{ + public static void* PoisonMemory(void* destination, ulong size) + { + memset(destination, 0xCC, (uint)size); + return destination; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void* malloc(ulong size) + { +#if NET6_0_OR_GREATER + var ptr = NativeMemory.Alloc((nuint)size); +#else + var ptr = (void*)Marshal.AllocHGlobal((nint)size); +#endif +#if DEBUG + return PoisonMemory(ptr, size); +#else + return ptr; +#endif + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void* calloc(ulong num, ulong size) + { +#if NET6_0_OR_GREATER + return NativeMemory.AllocZeroed((nuint)num, (nuint)size); +#else + var total = num * size; + assert(total <= uint.MaxValue); + var destination = (void*)Marshal.AllocHGlobal((nint)total); + memset(destination, 0, (uint)total); + return destination; +#endif + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void memcpy(void* destination, void* source, uint size) => + System.Runtime.CompilerServices.Unsafe.CopyBlockUnaligned(destination, source, size); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void memset(void* memPtr, byte val, uint size) => + System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(memPtr, val, size); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void free(void* ptr) + { +#if NET6_0_OR_GREATER + NativeMemory.Free(ptr); +#else + Marshal.FreeHGlobal((IntPtr)ptr); +#endif + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static T* GetArrayPointer(T[] array) + where T : unmanaged + { + var size = (uint)(sizeof(T) * array.Length); +#if NET9_0_OR_GREATER + // This function is used to allocate memory for static data blocks. + // We have to use AllocateTypeAssociatedMemory and link the memory's + // lifetime to this assembly, in order to prevent memory leaks when + // loading the assembly in an unloadable AssemblyLoadContext. + // While introduced in .NET 5, we call this only in .NET 9+, because + // it's not implemented in the Mono runtime until then. + var destination = (T*) + RuntimeHelpers.AllocateTypeAssociatedMemory(typeof(UnsafeHelper), (int)size); +#else + var destination = (T*)malloc(size); +#endif + fixed (void* source = &array[0]) + System.Runtime.CompilerServices.Unsafe.CopyBlockUnaligned(destination, source, size); + + return destination; + } + + [Conditional("DEBUG")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void assert(bool condition, string? message = null) + { + if (!condition) + throw new ArgumentException(message ?? "assert failed"); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void memmove(void* destination, void* source, ulong size) => + Buffer.MemoryCopy(source, destination, size, size); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int memcmp(void* buf1, void* buf2, ulong size) + { + assert(size <= int.MaxValue); + var intSize = (int)size; + return new ReadOnlySpan(buf1, intSize).SequenceCompareTo( + new ReadOnlySpan(buf2, intSize) + ); + } +} diff --git a/src/SharpCompress/Compressors/ZStandard/ZStandardStream.cs b/src/SharpCompress/Compressors/ZStandard/ZStandardStream.cs index 61f7fbb46..d465c8355 100644 --- a/src/SharpCompress/Compressors/ZStandard/ZStandardStream.cs +++ b/src/SharpCompress/Compressors/ZStandard/ZStandardStream.cs @@ -8,7 +8,7 @@ namespace SharpCompress.Compressors.ZStandard; -internal class ZStandardStream : ZstdSharp.DecompressionStream, IStreamStack +internal class ZStandardStream : DecompressionStream, IStreamStack { #if DEBUG_STREAMS long IStreamStack.InstanceId { get; set; } diff --git a/src/SharpCompress/Compressors/ZStandard/ZstandardConstants.cs b/src/SharpCompress/Compressors/ZStandard/ZstandardConstants.cs index 8025c658e..ac4756d48 100644 --- a/src/SharpCompress/Compressors/ZStandard/ZstandardConstants.cs +++ b/src/SharpCompress/Compressors/ZStandard/ZstandardConstants.cs @@ -1,9 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - namespace SharpCompress.Compressors.ZStandard; internal class ZstandardConstants diff --git a/src/SharpCompress/Compressors/ZStandard/ZstdException.cs b/src/SharpCompress/Compressors/ZStandard/ZstdException.cs new file mode 100644 index 000000000..55d79579f --- /dev/null +++ b/src/SharpCompress/Compressors/ZStandard/ZstdException.cs @@ -0,0 +1,12 @@ +using SharpCompress.Common; +using SharpCompress.Compressors.ZStandard.Unsafe; + +namespace SharpCompress.Compressors.ZStandard; + +public class ZstdException : SharpCompressException +{ + public ZstdException(ZSTD_ErrorCode code, string message) + : base(message) => Code = code; + + public ZSTD_ErrorCode Code { get; } +} diff --git a/src/SharpCompress/Factories/AceFactory.cs b/src/SharpCompress/Factories/AceFactory.cs new file mode 100644 index 000000000..5b80ae24f --- /dev/null +++ b/src/SharpCompress/Factories/AceFactory.cs @@ -0,0 +1,37 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SharpCompress.Common; +using SharpCompress.Common.Ace.Headers; +using SharpCompress.Readers; +using SharpCompress.Readers.Ace; + +namespace SharpCompress.Factories +{ + public class AceFactory : Factory, IReaderFactory + { + public override string Name => "Ace"; + + public override ArchiveType? KnownArchiveType => ArchiveType.Ace; + + public override IEnumerable GetSupportedExtensions() + { + yield return "ace"; + } + + public override bool IsArchive( + Stream stream, + string? password = null, + int bufferSize = ReaderOptions.DefaultBufferSize + ) + { + return AceHeader.IsArchive(stream); + } + + public IReader OpenReader(Stream stream, ReaderOptions? options) => + AceReader.Open(stream, options); + } +} diff --git a/src/SharpCompress/Factories/ArjFactory.cs b/src/SharpCompress/Factories/ArjFactory.cs index 7499946be..f6f7a3934 100644 --- a/src/SharpCompress/Factories/ArjFactory.cs +++ b/src/SharpCompress/Factories/ArjFactory.cs @@ -28,12 +28,7 @@ public override bool IsArchive( int bufferSize = ReaderOptions.DefaultBufferSize ) { - var arjHeader = new ArjMainHeader(new ArchiveEncoding()); - if (arjHeader.Read(stream) == null) - { - return false; - } - return true; + return ArjHeader.IsArchive(stream); } public IReader OpenReader(Stream stream, ReaderOptions? options) => diff --git a/src/SharpCompress/Factories/Factory.cs b/src/SharpCompress/Factories/Factory.cs index dba201777..4651ccb22 100644 --- a/src/SharpCompress/Factories/Factory.cs +++ b/src/SharpCompress/Factories/Factory.cs @@ -19,6 +19,7 @@ static Factory() RegisterFactory(new TarFactory()); RegisterFactory(new ArcFactory()); RegisterFactory(new ArjFactory()); + RegisterFactory(new AceFactory()); } private static readonly HashSet _factories = new(); diff --git a/src/SharpCompress/IO/ListeningStream.cs b/src/SharpCompress/IO/ListeningStream.cs deleted file mode 100644 index fafe12b57..000000000 --- a/src/SharpCompress/IO/ListeningStream.cs +++ /dev/null @@ -1,97 +0,0 @@ -using System.IO; -using SharpCompress.Common; - -namespace SharpCompress.IO; - -internal class ListeningStream : Stream, IStreamStack -{ -#if DEBUG_STREAMS - long IStreamStack.InstanceId { get; set; } -#endif - int IStreamStack.DefaultBufferSize { get; set; } - - Stream IStreamStack.BaseStream() => Stream; - - int IStreamStack.BufferSize - { - get => 0; - set { return; } - } - int IStreamStack.BufferPosition - { - get => 0; - set { return; } - } - - void IStreamStack.SetPosition(long position) { } - - private long _currentEntryTotalReadBytes; - private readonly IExtractionListener _listener; - - public ListeningStream(IExtractionListener listener, Stream stream) - { - Stream = stream; - this._listener = listener; -#if DEBUG_STREAMS - this.DebugConstruct(typeof(ListeningStream)); -#endif - } - - protected override void Dispose(bool disposing) - { -#if DEBUG_STREAMS - this.DebugDispose(typeof(ListeningStream)); -#endif - if (disposing) - { - Stream.Dispose(); - } - base.Dispose(disposing); - } - - public Stream Stream { get; } - - public override bool CanRead => Stream.CanRead; - - public override bool CanSeek => Stream.CanSeek; - - public override bool CanWrite => Stream.CanWrite; - - public override void Flush() => Stream.Flush(); - - public override long Length => Stream.Length; - - public override long Position - { - get => Stream.Position; - set => Stream.Position = value; - } - - public override int Read(byte[] buffer, int offset, int count) - { - var read = Stream.Read(buffer, offset, count); - _currentEntryTotalReadBytes += read; - _listener.FireCompressedBytesRead(_currentEntryTotalReadBytes, _currentEntryTotalReadBytes); - return read; - } - - public override int ReadByte() - { - var value = Stream.ReadByte(); - if (value == -1) - { - return -1; - } - - ++_currentEntryTotalReadBytes; - _listener.FireCompressedBytesRead(_currentEntryTotalReadBytes, _currentEntryTotalReadBytes); - return value; - } - - public override long Seek(long offset, SeekOrigin origin) => Stream.Seek(offset, origin); - - public override void SetLength(long value) => Stream.SetLength(value); - - public override void Write(byte[] buffer, int offset, int count) => - Stream.Write(buffer, offset, count); -} diff --git a/src/SharpCompress/IO/ProgressReportingStream.cs b/src/SharpCompress/IO/ProgressReportingStream.cs new file mode 100644 index 000000000..5ed028351 --- /dev/null +++ b/src/SharpCompress/IO/ProgressReportingStream.cs @@ -0,0 +1,160 @@ +using System; +using System.IO; +using System.Threading; +using System.Threading.Tasks; +using SharpCompress.Common; + +namespace SharpCompress.IO; + +/// +/// A stream wrapper that reports progress as data is read from the source. +/// Used to track compression or extraction progress by wrapping the source stream. +/// +internal sealed class ProgressReportingStream : Stream +{ + private readonly Stream _baseStream; + private readonly IProgress _progress; + private readonly string _entryPath; + private readonly long? _totalBytes; + private long _bytesTransferred; + private readonly bool _leaveOpen; + + public ProgressReportingStream( + Stream baseStream, + IProgress progress, + string entryPath, + long? totalBytes, + bool leaveOpen = false + ) + { + _baseStream = baseStream; + _progress = progress; + _entryPath = entryPath; + _totalBytes = totalBytes; + _leaveOpen = leaveOpen; + } + + public override bool CanRead => _baseStream.CanRead; + + public override bool CanSeek => _baseStream.CanSeek; + + public override bool CanWrite => false; + + public override long Length => _baseStream.Length; + + public override long Position + { + get => _baseStream.Position; + set => + throw new NotSupportedException( + "Directly setting Position is not supported in ProgressReportingStream to maintain progress tracking integrity." + ); + } + + public override void Flush() => _baseStream.Flush(); + + public override int Read(byte[] buffer, int offset, int count) + { + var bytesRead = _baseStream.Read(buffer, offset, count); + if (bytesRead > 0) + { + _bytesTransferred += bytesRead; + ReportProgress(); + } + return bytesRead; + } + +#if !NETFRAMEWORK && !NETSTANDARD2_0 + public override int Read(Span buffer) + { + var bytesRead = _baseStream.Read(buffer); + if (bytesRead > 0) + { + _bytesTransferred += bytesRead; + ReportProgress(); + } + return bytesRead; + } +#endif + + public override async Task ReadAsync( + byte[] buffer, + int offset, + int count, + CancellationToken cancellationToken + ) + { + var bytesRead = await _baseStream + .ReadAsync(buffer, offset, count, cancellationToken) + .ConfigureAwait(false); + if (bytesRead > 0) + { + _bytesTransferred += bytesRead; + ReportProgress(); + } + return bytesRead; + } + +#if !NETFRAMEWORK && !NETSTANDARD2_0 + public override async ValueTask ReadAsync( + Memory buffer, + CancellationToken cancellationToken = default + ) + { + var bytesRead = await _baseStream + .ReadAsync(buffer, cancellationToken) + .ConfigureAwait(false); + if (bytesRead > 0) + { + _bytesTransferred += bytesRead; + ReportProgress(); + } + return bytesRead; + } +#endif + + public override int ReadByte() + { + var value = _baseStream.ReadByte(); + if (value != -1) + { + _bytesTransferred++; + ReportProgress(); + } + return value; + } + + public override long Seek(long offset, SeekOrigin origin) => _baseStream.Seek(offset, origin); + + public override void SetLength(long value) => _baseStream.SetLength(value); + + public override void Write(byte[] buffer, int offset, int count) => + throw new NotSupportedException( + "ProgressReportingStream is designed for read operations to track progress." + ); + + private void ReportProgress() + { + _progress.Report(new ProgressReport(_entryPath, _bytesTransferred, _totalBytes)); + } + + protected override void Dispose(bool disposing) + { + if (disposing && !_leaveOpen) + { + _baseStream.Dispose(); + } + base.Dispose(disposing); + } + +#if !NETFRAMEWORK && !NETSTANDARD2_0 + public override async ValueTask DisposeAsync() + { + if (!_leaveOpen) + { + await _baseStream.DisposeAsync().ConfigureAwait(false); + } + await base.DisposeAsync().ConfigureAwait(false); + } +#endif +} diff --git a/src/SharpCompress/IO/SharpCompressStream.cs b/src/SharpCompress/IO/SharpCompressStream.cs index 00c0ada2f..185a87668 100644 --- a/src/SharpCompress/IO/SharpCompressStream.cs +++ b/src/SharpCompress/IO/SharpCompressStream.cs @@ -57,14 +57,8 @@ int IStreamStack.BufferSize { ValidateBufferState(); // Add here } - try - { - _internalPosition = Stream.Position; - } - catch - { - _internalPosition = 0; - } + // Check CanSeek before accessing Position to avoid exception overhead on non-seekable streams. + _internalPosition = Stream.CanSeek ? Stream.Position : 0; } } } @@ -136,14 +130,8 @@ public SharpCompressStream( _readOnly = !Stream.CanSeek; ((IStreamStack)this).SetBuffer(bufferSize, forceBuffer); - try - { - _baseInitialPos = stream.Position; - } - catch - { - _baseInitialPos = 0; - } + // Check CanSeek before accessing Position to avoid exception overhead on non-seekable streams. + _baseInitialPos = Stream.CanSeek ? Stream.Position : 0; #if DEBUG_STREAMS this.DebugConstruct(typeof(SharpCompressStream)); diff --git a/src/SharpCompress/Polyfills/StreamExtensions.cs b/src/SharpCompress/Polyfills/StreamExtensions.cs index ab118a4fa..f00b274a1 100644 --- a/src/SharpCompress/Polyfills/StreamExtensions.cs +++ b/src/SharpCompress/Polyfills/StreamExtensions.cs @@ -3,6 +3,8 @@ using System; using System.Buffers; using System.IO; +using System.Threading; +using System.Threading.Tasks; namespace SharpCompress; @@ -41,6 +43,28 @@ internal static void Write(this Stream stream, ReadOnlySpan buffer) ArrayPool.Shared.Return(temp); } } + + internal static async Task ReadExactlyAsync( + this Stream stream, + byte[] buffer, + int offset, + int count, + CancellationToken cancellationToken + ) + { + var totalRead = 0; + while (totalRead < count) + { + var read = await stream + .ReadAsync(buffer, offset + totalRead, count - totalRead, cancellationToken) + .ConfigureAwait(false); + if (read == 0) + { + throw new EndOfStreamException(); + } + totalRead += read; + } + } } #endif diff --git a/src/SharpCompress/Readers/AbstractReader.cs b/src/SharpCompress/Readers/AbstractReader.cs index 17b74c2ae..cd37bb5ff 100644 --- a/src/SharpCompress/Readers/AbstractReader.cs +++ b/src/SharpCompress/Readers/AbstractReader.cs @@ -5,13 +5,14 @@ using System.Threading; using System.Threading.Tasks; using SharpCompress.Common; +using SharpCompress.IO; namespace SharpCompress.Readers; /// /// A generic push reader that reads unseekable comrpessed streams. /// -public abstract class AbstractReader : IReader, IReaderExtractionListener +public abstract class AbstractReader : IReader where TEntry : Entry where TVolume : Volume { @@ -19,11 +20,6 @@ public abstract class AbstractReader : IReader, IReaderExtracti private IEnumerator? _entriesForCurrentReadStream; private bool _wroteCurrentEntry; - public event EventHandler>? EntryExtractionProgress; - - public event EventHandler? CompressedBytesRead; - public event EventHandler? FilePartExtractionBegin; - internal AbstractReader(ReaderOptions options, ArchiveType archiveType) { ArchiveType = archiveType; @@ -264,25 +260,58 @@ public async Task WriteEntryToAsync( internal void Write(Stream writeStream) { - var streamListener = this as IReaderExtractionListener; using Stream s = OpenEntryStream(); - s.TransferTo(writeStream, Entry, streamListener); + var sourceStream = WrapWithProgress(s, Entry); + sourceStream.CopyTo(writeStream, 81920); } internal async Task WriteAsync(Stream writeStream, CancellationToken cancellationToken) { - var streamListener = this as IReaderExtractionListener; #if NETFRAMEWORK || NETSTANDARD2_0 using Stream s = OpenEntryStream(); - await s.TransferToAsync(writeStream, Entry, streamListener, cancellationToken) - .ConfigureAwait(false); + var sourceStream = WrapWithProgress(s, Entry); + await sourceStream.CopyToAsync(writeStream, 81920, cancellationToken).ConfigureAwait(false); #else await using Stream s = OpenEntryStream(); - await s.TransferToAsync(writeStream, Entry, streamListener, cancellationToken) - .ConfigureAwait(false); + var sourceStream = WrapWithProgress(s, Entry); + await sourceStream.CopyToAsync(writeStream, 81920, cancellationToken).ConfigureAwait(false); #endif } + private Stream WrapWithProgress(Stream source, Entry entry) + { + var progress = Options.Progress; + if (progress is null) + { + return source; + } + + var entryPath = entry.Key ?? string.Empty; + long? totalBytes = GetEntrySizeSafe(entry); + return new ProgressReportingStream( + source, + progress, + entryPath, + totalBytes, + leaveOpen: true + ); + } + + private static long? GetEntrySizeSafe(Entry entry) + { + try + { + var size = entry.Size; + // Return the actual size (including 0 for empty entries) + // Negative values indicate unknown size + return size >= 0 ? size : null; + } + catch (NotImplementedException) + { + return null; + } + } + public EntryStream OpenEntryStream() { if (_wroteCurrentEntry) @@ -325,43 +354,4 @@ protected virtual Task GetEntryStreamAsync( #endregion IEntry IReader.Entry => Entry; - - void IExtractionListener.FireCompressedBytesRead( - long currentPartCompressedBytes, - long compressedReadBytes - ) => - CompressedBytesRead?.Invoke( - this, - new CompressedBytesReadEventArgs( - currentFilePartCompressedBytesRead: currentPartCompressedBytes, - compressedBytesRead: compressedReadBytes - ) - ); - - void IExtractionListener.FireFilePartExtractionBegin( - string name, - long size, - long compressedSize - ) => - FilePartExtractionBegin?.Invoke( - this, - new FilePartExtractionBeginEventArgs( - compressedSize: compressedSize, - size: size, - name: name - ) - ); - - void IReaderExtractionListener.FireEntryExtractionProgress( - Entry entry, - long bytesTransferred, - int iterations - ) => - EntryExtractionProgress?.Invoke( - this, - new ReaderExtractionEventArgs( - entry, - new ReaderProgress(entry, bytesTransferred, iterations) - ) - ); } diff --git a/src/SharpCompress/Readers/Ace/AceReader.cs b/src/SharpCompress/Readers/Ace/AceReader.cs new file mode 100644 index 000000000..2252a276e --- /dev/null +++ b/src/SharpCompress/Readers/Ace/AceReader.cs @@ -0,0 +1,115 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SharpCompress.Common; +using SharpCompress.Common.Ace; +using SharpCompress.Common.Ace.Headers; +using SharpCompress.Common.Arj; + +namespace SharpCompress.Readers.Ace +{ + /// + /// Reader for ACE archives. + /// ACE is a proprietary archive format. This implementation supports both ACE 1.0 and ACE 2.0 formats + /// and can read archive metadata and extract uncompressed (stored) entries. + /// Compressed entries require proprietary decompression algorithms that are not publicly documented. + /// + /// + /// ACE 2.0 additions over ACE 1.0: + /// - Improved LZ77 compression (compression type 2) + /// - Recovery record support + /// - Additional header flags + /// + public abstract class AceReader : AbstractReader + { + private readonly ArchiveEncoding _archiveEncoding; + + internal AceReader(ReaderOptions options) + : base(options, ArchiveType.Ace) + { + _archiveEncoding = Options.ArchiveEncoding; + } + + private AceReader(Stream stream, ReaderOptions options) + : this(options) { } + + /// + /// Derived class must create or manage the Volume itself. + /// AbstractReader.Volume is get-only, so it cannot be set here. + /// + public override AceVolume? Volume => _volume; + + private AceVolume? _volume; + + /// + /// Opens an AceReader for non-seeking usage with a single volume. + /// + /// The stream containing the ACE archive. + /// Reader options. + /// An AceReader instance. + public static AceReader Open(Stream stream, ReaderOptions? options = null) + { + stream.NotNull(nameof(stream)); + return new SingleVolumeAceReader(stream, options ?? new ReaderOptions()); + } + + /// + /// Opens an AceReader for Non-seeking usage with multiple volumes + /// + /// + /// + /// + public static AceReader Open(IEnumerable streams, ReaderOptions? options = null) + { + streams.NotNull(nameof(streams)); + return new MultiVolumeAceReader(streams, options ?? new ReaderOptions()); + } + + protected abstract void ValidateArchive(AceVolume archive); + + protected override IEnumerable GetEntries(Stream stream) + { + var mainHeaderReader = new AceMainHeader(_archiveEncoding); + var mainHeader = mainHeaderReader.Read(stream); + if (mainHeader == null) + { + yield break; + } + + if (mainHeader?.IsMultiVolume == true) + { + throw new MultiVolumeExtractionException( + "Multi volumes are currently not supported" + ); + } + + if (_volume == null) + { + _volume = new AceVolume(stream, Options, 0); + ValidateArchive(_volume); + } + + var localHeaderReader = new AceFileHeader(_archiveEncoding); + while (true) + { + var localHeader = localHeaderReader.Read(stream); + if (localHeader?.IsFileEncrypted == true) + { + throw new CryptographicException( + "Password protected archives are currently not supported" + ); + } + if (localHeader == null) + break; + + yield return new AceEntry(new AceFilePart((AceFileHeader)localHeader, stream)); + } + } + + protected virtual IEnumerable CreateFilePartEnumerableForCurrentEntry() => + Entry.Parts; + } +} diff --git a/src/SharpCompress/Readers/Ace/MultiVolumeAceReader.cs b/src/SharpCompress/Readers/Ace/MultiVolumeAceReader.cs new file mode 100644 index 000000000..a729ab3fd --- /dev/null +++ b/src/SharpCompress/Readers/Ace/MultiVolumeAceReader.cs @@ -0,0 +1,117 @@ +#nullable disable + +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SharpCompress.Common; +using SharpCompress.Common.Ace; + +namespace SharpCompress.Readers.Ace +{ + internal class MultiVolumeAceReader : AceReader + { + private readonly IEnumerator streams; + private Stream tempStream; + + internal MultiVolumeAceReader(IEnumerable streams, ReaderOptions options) + : base(options) => this.streams = streams.GetEnumerator(); + + protected override void ValidateArchive(AceVolume archive) { } + + protected override Stream RequestInitialStream() + { + if (streams.MoveNext()) + { + return streams.Current; + } + throw new MultiVolumeExtractionException( + "No stream provided when requested by MultiVolumeAceReader" + ); + } + + internal override bool NextEntryForCurrentStream() + { + if (!base.NextEntryForCurrentStream()) + { + // if we're got another stream to try to process then do so + return streams.MoveNext() && LoadStreamForReading(streams.Current); + } + return true; + } + + protected override IEnumerable CreateFilePartEnumerableForCurrentEntry() + { + var enumerator = new MultiVolumeStreamEnumerator(this, streams, tempStream); + tempStream = null; + return enumerator; + } + + private class MultiVolumeStreamEnumerator : IEnumerable, IEnumerator + { + private readonly MultiVolumeAceReader reader; + private readonly IEnumerator nextReadableStreams; + private Stream tempStream; + private bool isFirst = true; + + internal MultiVolumeStreamEnumerator( + MultiVolumeAceReader r, + IEnumerator nextReadableStreams, + Stream tempStream + ) + { + reader = r; + this.nextReadableStreams = nextReadableStreams; + this.tempStream = tempStream; + } + + public IEnumerator GetEnumerator() => this; + + IEnumerator IEnumerable.GetEnumerator() => this; + + public FilePart Current { get; private set; } + + public void Dispose() { } + + object IEnumerator.Current => Current; + + public bool MoveNext() + { + if (isFirst) + { + Current = reader.Entry.Parts.First(); + isFirst = false; //first stream already to go + return true; + } + + if (!reader.Entry.IsSplitAfter) + { + return false; + } + if (tempStream != null) + { + reader.LoadStreamForReading(tempStream); + tempStream = null; + } + else if (!nextReadableStreams.MoveNext()) + { + throw new MultiVolumeExtractionException( + "No stream provided when requested by MultiVolumeAceReader" + ); + } + else + { + reader.LoadStreamForReading(nextReadableStreams.Current); + } + + Current = reader.Entry.Parts.First(); + return true; + } + + public void Reset() { } + } + } +} diff --git a/src/SharpCompress/Readers/Ace/SingleVolumeAceReader.cs b/src/SharpCompress/Readers/Ace/SingleVolumeAceReader.cs new file mode 100644 index 000000000..61182d66a --- /dev/null +++ b/src/SharpCompress/Readers/Ace/SingleVolumeAceReader.cs @@ -0,0 +1,31 @@ +using System; +using System.IO; +using SharpCompress.Common; +using SharpCompress.Common.Ace; + +namespace SharpCompress.Readers.Ace +{ + internal class SingleVolumeAceReader : AceReader + { + private readonly Stream _stream; + + internal SingleVolumeAceReader(Stream stream, ReaderOptions options) + : base(options) + { + stream.NotNull(nameof(stream)); + _stream = stream; + } + + protected override Stream RequestInitialStream() => _stream; + + protected override void ValidateArchive(AceVolume archive) + { + if (archive.IsMultiVolume) + { + throw new MultiVolumeExtractionException( + "Streamed archive is a Multi-volume archive. Use a different AceReader method to extract." + ); + } + } + } +} diff --git a/src/SharpCompress/Readers/IReader.cs b/src/SharpCompress/Readers/IReader.cs index c2d7c3c0e..574237088 100644 --- a/src/SharpCompress/Readers/IReader.cs +++ b/src/SharpCompress/Readers/IReader.cs @@ -8,11 +8,6 @@ namespace SharpCompress.Readers; public interface IReader : IDisposable { - event EventHandler> EntryExtractionProgress; - - event EventHandler CompressedBytesRead; - event EventHandler FilePartExtractionBegin; - ArchiveType ArchiveType { get; } IEntry Entry { get; } diff --git a/src/SharpCompress/Readers/IReaderExtensions.cs b/src/SharpCompress/Readers/IReaderExtensions.cs index 6480df1d4..65c6b1fac 100644 --- a/src/SharpCompress/Readers/IReaderExtensions.cs +++ b/src/SharpCompress/Readers/IReaderExtensions.cs @@ -7,124 +7,121 @@ namespace SharpCompress.Readers; public static class IReaderExtensions { - public static void WriteEntryTo(this IReader reader, string filePath) + extension(IReader reader) { - using Stream stream = File.Open(filePath, FileMode.Create, FileAccess.Write); - reader.WriteEntryTo(stream); - } - - public static void WriteEntryTo(this IReader reader, FileInfo filePath) - { - using Stream stream = filePath.Open(FileMode.Create); - reader.WriteEntryTo(stream); - } - - /// - /// Extract all remaining unread entries to specific directory, retaining filename - /// - public static void WriteAllToDirectory( - this IReader reader, - string destinationDirectory, - ExtractionOptions? options = null - ) - { - while (reader.MoveToNextEntry()) + public void WriteEntryTo(string filePath) { - reader.WriteEntryToDirectory(destinationDirectory, options); + using Stream stream = File.Open(filePath, FileMode.Create, FileAccess.Write); + reader.WriteEntryTo(stream); } - } - /// - /// Extract to specific directory, retaining filename - /// - public static void WriteEntryToDirectory( - this IReader reader, - string destinationDirectory, - ExtractionOptions? options = null - ) => - ExtractionMethods.WriteEntryToDirectory( - reader.Entry, - destinationDirectory, - options, - reader.WriteEntryToFile - ); + public void WriteEntryTo(FileInfo filePath) + { + using Stream stream = filePath.Open(FileMode.Create); + reader.WriteEntryTo(stream); + } - /// - /// Extract to specific file - /// - public static void WriteEntryToFile( - this IReader reader, - string destinationFileName, - ExtractionOptions? options = null - ) => - ExtractionMethods.WriteEntryToFile( - reader.Entry, - destinationFileName, - options, - (x, fm) => + /// + /// Extract all remaining unread entries to specific directory, retaining filename + /// + public void WriteAllToDirectory( + string destinationDirectory, + ExtractionOptions? options = null + ) + { + while (reader.MoveToNextEntry()) { - using var fs = File.Open(destinationFileName, fm); - reader.WriteEntryTo(fs); + reader.WriteEntryToDirectory(destinationDirectory, options); } - ); + } - /// - /// Extract to specific directory asynchronously, retaining filename - /// - public static async Task WriteEntryToDirectoryAsync( - this IReader reader, - string destinationDirectory, - ExtractionOptions? options = null, - CancellationToken cancellationToken = default - ) => - await ExtractionMethods - .WriteEntryToDirectoryAsync( + /// + /// Extract to specific directory, retaining filename + /// + public void WriteEntryToDirectory( + string destinationDirectory, + ExtractionOptions? options = null + ) => + ExtractionMethods.WriteEntryToDirectory( reader.Entry, destinationDirectory, options, - (fileName, opts) => reader.WriteEntryToFileAsync(fileName, opts, cancellationToken), - cancellationToken - ) - .ConfigureAwait(false); + reader.WriteEntryToFile + ); - /// - /// Extract to specific file asynchronously - /// - public static async Task WriteEntryToFileAsync( - this IReader reader, - string destinationFileName, - ExtractionOptions? options = null, - CancellationToken cancellationToken = default - ) => - await ExtractionMethods - .WriteEntryToFileAsync( + /// + /// Extract to specific file + /// + public void WriteEntryToFile( + string destinationFileName, + ExtractionOptions? options = null + ) => + ExtractionMethods.WriteEntryToFile( reader.Entry, destinationFileName, options, - async (x, fm) => + (x, fm) => { using var fs = File.Open(destinationFileName, fm); - await reader.WriteEntryToAsync(fs, cancellationToken).ConfigureAwait(false); - }, - cancellationToken - ) - .ConfigureAwait(false); + reader.WriteEntryTo(fs); + } + ); - /// - /// Extract all remaining unread entries to specific directory asynchronously, retaining filename - /// - public static async Task WriteAllToDirectoryAsync( - this IReader reader, - string destinationDirectory, - ExtractionOptions? options = null, - CancellationToken cancellationToken = default - ) - { - while (reader.MoveToNextEntry()) - { - await reader - .WriteEntryToDirectoryAsync(destinationDirectory, options, cancellationToken) + /// + /// Extract to specific directory asynchronously, retaining filename + /// + public async Task WriteEntryToDirectoryAsync( + string destinationDirectory, + ExtractionOptions? options = null, + CancellationToken cancellationToken = default + ) => + await ExtractionMethods + .WriteEntryToDirectoryAsync( + reader.Entry, + destinationDirectory, + options, + reader.WriteEntryToFileAsync, + cancellationToken + ) + .ConfigureAwait(false); + + /// + /// Extract to specific file asynchronously + /// + public async Task WriteEntryToFileAsync( + string destinationFileName, + ExtractionOptions? options = null, + CancellationToken cancellationToken = default + ) => + await ExtractionMethods + .WriteEntryToFileAsync( + reader.Entry, + destinationFileName, + options, + async (x, fm, ct) => + { + using var fs = File.Open(destinationFileName, fm); + await reader.WriteEntryToAsync(fs, ct).ConfigureAwait(false); + }, + cancellationToken + ) .ConfigureAwait(false); + + /// + /// Extract all remaining unread entries to specific directory asynchronously, retaining filename + /// + public async Task WriteAllToDirectoryAsync( + string destinationDirectory, + ExtractionOptions? options = null, + CancellationToken cancellationToken = default + ) + { + while (await reader.MoveToNextEntryAsync(cancellationToken)) + { + await reader + .WriteEntryToDirectoryAsync(destinationDirectory, options, cancellationToken) + .ConfigureAwait(false); + } } } } diff --git a/src/SharpCompress/Readers/IReaderExtractionListener.cs b/src/SharpCompress/Readers/IReaderExtractionListener.cs deleted file mode 100644 index 49e5dae42..000000000 --- a/src/SharpCompress/Readers/IReaderExtractionListener.cs +++ /dev/null @@ -1,8 +0,0 @@ -using SharpCompress.Common; - -namespace SharpCompress.Readers; - -public interface IReaderExtractionListener : IExtractionListener -{ - void FireEntryExtractionProgress(Entry entry, long sizeTransferred, int iterations); -} diff --git a/src/SharpCompress/Readers/Rar/RarReader.cs b/src/SharpCompress/Readers/Rar/RarReader.cs index 67af26842..9c6de26f8 100644 --- a/src/SharpCompress/Readers/Rar/RarReader.cs +++ b/src/SharpCompress/Readers/Rar/RarReader.cs @@ -108,8 +108,7 @@ protected override EntryStream GetEntryStream() } var stream = new MultiVolumeReadOnlyStream( - CreateFilePartEnumerableForCurrentEntry().Cast(), - this + CreateFilePartEnumerableForCurrentEntry().Cast() ); if (Entry.IsRarV3) { @@ -136,8 +135,7 @@ protected override async System.Threading.Tasks.Task GetEntryStream } var stream = new MultiVolumeReadOnlyStream( - CreateFilePartEnumerableForCurrentEntry().Cast(), - this + CreateFilePartEnumerableForCurrentEntry().Cast() ); if (Entry.IsRarV3) { diff --git a/src/SharpCompress/Readers/ReaderFactory.cs b/src/SharpCompress/Readers/ReaderFactory.cs index 80995e41e..b8b022b04 100644 --- a/src/SharpCompress/Readers/ReaderFactory.cs +++ b/src/SharpCompress/Readers/ReaderFactory.cs @@ -70,7 +70,7 @@ public static IReader Open(Stream stream, ReaderOptions? options = null) } throw new InvalidFormatException( - "Cannot determine compressed stream type. Supported Reader Formats: Arc, Arj, Zip, GZip, BZip2, Tar, Rar, LZip, XZ, ZStandard" + "Cannot determine compressed stream type. Supported Reader Formats: Ace, Arc, Arj, Zip, GZip, BZip2, Tar, Rar, LZip, XZ, ZStandard" ); } } diff --git a/src/SharpCompress/Readers/ReaderOptions.cs b/src/SharpCompress/Readers/ReaderOptions.cs index 4ddfe94d2..cedf8bedb 100644 --- a/src/SharpCompress/Readers/ReaderOptions.cs +++ b/src/SharpCompress/Readers/ReaderOptions.cs @@ -1,3 +1,4 @@ +using System; using SharpCompress.Common; namespace SharpCompress.Readers; @@ -21,4 +22,10 @@ public class ReaderOptions : OptionsBase /// Provide a hint for the extension of the archive being read, can speed up finding the correct decoder. Should be without the leading period in the form like: tar.gz or zip /// public string? ExtensionHint { get; set; } + + /// + /// An optional progress reporter for tracking extraction operations. + /// When set, progress updates will be reported as entries are extracted. + /// + public IProgress? Progress { get; set; } } diff --git a/src/SharpCompress/Readers/ReaderProgress.cs b/src/SharpCompress/Readers/ReaderProgress.cs deleted file mode 100644 index 2cffab9ab..000000000 --- a/src/SharpCompress/Readers/ReaderProgress.cs +++ /dev/null @@ -1,21 +0,0 @@ -using System; -using SharpCompress.Common; - -namespace SharpCompress.Readers; - -public class ReaderProgress -{ - private readonly IEntry _entry; - public long BytesTransferred { get; } - public int Iterations { get; } - - public int PercentageRead => (int)Math.Round(PercentageReadExact); - public double PercentageReadExact => (float)BytesTransferred / _entry.Size * 100; - - public ReaderProgress(IEntry entry, long bytesTransferred, int iterations) - { - _entry = entry; - BytesTransferred = bytesTransferred; - Iterations = iterations; - } -} diff --git a/src/SharpCompress/Readers/Zip/ZipReader.cs b/src/SharpCompress/Readers/Zip/ZipReader.cs index 5e82479ce..3a2578459 100644 --- a/src/SharpCompress/Readers/Zip/ZipReader.cs +++ b/src/SharpCompress/Readers/Zip/ZipReader.cs @@ -75,6 +75,14 @@ protected override IEnumerable GetEntries(Stream stream) ); } break; + case ZipHeaderType.DirectoryEntry: + // DirectoryEntry headers in the central directory are intentionally skipped. + // In streaming mode, we can only read forward, and DirectoryEntry headers + // reference LocalEntry headers that have already been processed. The file + // data comes from LocalEntry headers, not DirectoryEntry headers. + // For multi-volume ZIPs where file data spans multiple files, use ZipArchive + // instead, which requires seekable streams. + break; case ZipHeaderType.DirectoryEnd: { yield break; diff --git a/src/SharpCompress/SharpCompress.csproj b/src/SharpCompress/SharpCompress.csproj index 97a31080c..0d051d0c1 100644 --- a/src/SharpCompress/SharpCompress.csproj +++ b/src/SharpCompress/SharpCompress.csproj @@ -2,11 +2,11 @@ SharpCompress - Pure C# Decompression/Compression en-US - 0.41.0 - 0.41.0 - 0.41.0 + 0.42.0 + 0.42.0 + 0.42.0 Adam Hathcock - net48;net481;netstandard2.0;net6.0;net8.0 + net48;net8.0;net10.0 SharpCompress ../../SharpCompress.snk true @@ -17,7 +17,7 @@ Copyright (c) 2025 Adam Hathcock false false - SharpCompress is a compression library for NET Standard 2.0/NET 4.8/NET 4.8.1/NET 6.0/NET 8.0 that can unrar, decompress 7zip, decompress xz, zip/unzip, tar/untar lzip/unlzip, bzip2/unbzip2 and gzip/ungzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip is implemented. + SharpCompress is a compression library for NET 4.8/NET 8.0/NET 10.0 that can unrar, decompress 7zip, decompress xz, zip/unzip, tar/untar lzip/unlzip, bzip2/unbzip2 and gzip/ungzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip is implemented. true true embedded @@ -28,31 +28,28 @@ true $(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb - + true $(DefineConstants);DEBUG_STREAMS + + $(DefineConstants);DEBUG_STREAMS + - - + - + - - - - - diff --git a/src/SharpCompress/Utility.cs b/src/SharpCompress/Utility.cs index d781c79b7..6c6276026 100644 --- a/src/SharpCompress/Utility.cs +++ b/src/SharpCompress/Utility.cs @@ -6,7 +6,6 @@ using System.Text; using System.Threading; using System.Threading.Tasks; -using SharpCompress.Readers; namespace SharpCompress; @@ -216,34 +215,6 @@ public static long TransferTo(this Stream source, Stream destination, long maxLe } } - public static long TransferTo( - this Stream source, - Stream destination, - Common.Entry entry, - IReaderExtractionListener readerExtractionListener - ) - { - var array = ArrayPool.Shared.Rent(TEMP_BUFFER_SIZE); - try - { - var iterations = 0; - long total = 0; - int count; - while ((count = source.Read(array, 0, array.Length)) != 0) - { - total += count; - destination.Write(array, 0, count); - iterations++; - readerExtractionListener.FireEntryExtractionProgress(entry, total, iterations); - } - return total; - } - finally - { - ArrayPool.Shared.Return(array); - } - } - public static async Task TransferToAsync( this Stream source, Stream destination, @@ -290,43 +261,6 @@ await destination } } - public static async Task TransferToAsync( - this Stream source, - Stream destination, - Common.Entry entry, - IReaderExtractionListener readerExtractionListener, - CancellationToken cancellationToken = default - ) - { - var array = ArrayPool.Shared.Rent(TEMP_BUFFER_SIZE); - try - { - var iterations = 0; - long total = 0; - int count; - while ( - ( - count = await source - .ReadAsync(array, 0, array.Length, cancellationToken) - .ConfigureAwait(false) - ) != 0 - ) - { - total += count; - await destination - .WriteAsync(array, 0, count, cancellationToken) - .ConfigureAwait(false); - iterations++; - readerExtractionListener.FireEntryExtractionProgress(entry, total, iterations); - } - return total; - } - finally - { - ArrayPool.Shared.Return(array); - } - } - private static bool ReadTransferBlock(Stream source, byte[] array, int maxSize, out int count) { var size = maxSize; diff --git a/src/SharpCompress/Writers/AbstractWriter.cs b/src/SharpCompress/Writers/AbstractWriter.cs index e75b93b6c..d86ccc746 100644 --- a/src/SharpCompress/Writers/AbstractWriter.cs +++ b/src/SharpCompress/Writers/AbstractWriter.cs @@ -3,6 +3,7 @@ using System.Threading; using System.Threading.Tasks; using SharpCompress.Common; +using SharpCompress.IO; namespace SharpCompress.Writers; @@ -22,6 +23,29 @@ public abstract class AbstractWriter(ArchiveType type, WriterOptions writerOptio protected WriterOptions WriterOptions { get; } = writerOptions; + /// + /// Wraps the source stream with a progress-reporting stream if progress reporting is enabled. + /// + /// The source stream to wrap. + /// The path of the entry being written. + /// A stream that reports progress, or the original stream if progress is not enabled. + protected Stream WrapWithProgress(Stream source, string entryPath) + { + if (WriterOptions.Progress is null) + { + return source; + } + + long? totalBytes = source.CanSeek ? source.Length : null; + return new ProgressReportingStream( + source, + WriterOptions.Progress, + entryPath, + totalBytes, + leaveOpen: true + ); + } + public abstract void Write(string filename, Stream source, DateTime? modificationTime); public virtual async Task WriteAsync( diff --git a/src/SharpCompress/Writers/GZip/GZipWriter.cs b/src/SharpCompress/Writers/GZip/GZipWriter.cs index 00100323e..ad1d59d77 100644 --- a/src/SharpCompress/Writers/GZip/GZipWriter.cs +++ b/src/SharpCompress/Writers/GZip/GZipWriter.cs @@ -47,7 +47,8 @@ public override void Write(string filename, Stream source, DateTime? modificatio var stream = (GZipStream)OutputStream; stream.FileName = filename; stream.LastModified = modificationTime; - source.CopyTo(stream); + var progressStream = WrapWithProgress(source, filename); + progressStream.CopyTo(stream); _wroteToStream = true; } diff --git a/src/SharpCompress/Writers/Tar/TarWriter.cs b/src/SharpCompress/Writers/Tar/TarWriter.cs index 96346e2bc..afad63bea 100644 --- a/src/SharpCompress/Writers/Tar/TarWriter.cs +++ b/src/SharpCompress/Writers/Tar/TarWriter.cs @@ -15,11 +15,13 @@ namespace SharpCompress.Writers.Tar; public class TarWriter : AbstractWriter { private readonly bool finalizeArchiveOnClose; + private TarHeaderWriteFormat headerFormat; public TarWriter(Stream destination, TarWriterOptions options) : base(ArchiveType.Tar, options) { finalizeArchiveOnClose = options.FinalizeArchiveOnClose; + headerFormat = options.HeaderFormat; if (!destination.CanWrite) { @@ -121,13 +123,14 @@ public void Write(string filename, Stream source, DateTime? modificationTime, lo var realSize = size ?? source.Length; - var header = new TarHeader(WriterOptions.ArchiveEncoding); + var header = new TarHeader(WriterOptions.ArchiveEncoding, headerFormat); header.LastModifiedTime = modificationTime ?? TarHeader.EPOCH; header.Name = NormalizeFilename(filename); header.Size = realSize; header.Write(OutputStream); - size = source.TransferTo(OutputStream, realSize); + var progressStream = WrapWithProgress(source, filename); + size = progressStream.TransferTo(OutputStream, realSize); PadTo512(size.Value); } @@ -159,7 +162,8 @@ public async Task WriteAsync( header.Name = NormalizeFilename(filename); header.Size = realSize; header.Write(OutputStream); - var written = await source + var progressStream = WrapWithProgress(source, filename); + var written = await progressStream .TransferToAsync(OutputStream, realSize, cancellationToken) .ConfigureAwait(false); PadTo512(written); diff --git a/src/SharpCompress/Writers/Tar/TarWriterOptions.cs b/src/SharpCompress/Writers/Tar/TarWriterOptions.cs index 8f2e866df..a8c3a29e4 100755 --- a/src/SharpCompress/Writers/Tar/TarWriterOptions.cs +++ b/src/SharpCompress/Writers/Tar/TarWriterOptions.cs @@ -1,4 +1,5 @@ using SharpCompress.Common; +using SharpCompress.Common.Tar.Headers; namespace SharpCompress.Writers.Tar; @@ -9,8 +10,18 @@ public class TarWriterOptions : WriterOptions /// public bool FinalizeArchiveOnClose { get; } - public TarWriterOptions(CompressionType compressionType, bool finalizeArchiveOnClose) - : base(compressionType) => FinalizeArchiveOnClose = finalizeArchiveOnClose; + public TarHeaderWriteFormat HeaderFormat { get; } + + public TarWriterOptions( + CompressionType compressionType, + bool finalizeArchiveOnClose, + TarHeaderWriteFormat headerFormat = TarHeaderWriteFormat.GNU_TAR_LONG_LINK + ) + : base(compressionType) + { + FinalizeArchiveOnClose = finalizeArchiveOnClose; + HeaderFormat = headerFormat; + } internal TarWriterOptions(WriterOptions options) : this(options.CompressionType, true) => ArchiveEncoding = options.ArchiveEncoding; diff --git a/src/SharpCompress/Writers/WriterOptions.cs b/src/SharpCompress/Writers/WriterOptions.cs index 361dfb550..46e145602 100644 --- a/src/SharpCompress/Writers/WriterOptions.cs +++ b/src/SharpCompress/Writers/WriterOptions.cs @@ -1,3 +1,4 @@ +using System; using SharpCompress.Common; using D = SharpCompress.Compressors.Deflate; @@ -36,6 +37,12 @@ public WriterOptions(CompressionType compressionType, int compressionLevel) /// public int CompressionLevel { get; set; } + /// + /// An optional progress reporter for tracking compression operations. + /// When set, progress updates will be reported as entries are written. + /// + public IProgress? Progress { get; set; } + public static implicit operator WriterOptions(CompressionType compressionType) => new(compressionType); } diff --git a/src/SharpCompress/Writers/Zip/ZipWriter.cs b/src/SharpCompress/Writers/Zip/ZipWriter.cs index fbffb206a..7f791c68f 100644 --- a/src/SharpCompress/Writers/Zip/ZipWriter.cs +++ b/src/SharpCompress/Writers/Zip/ZipWriter.cs @@ -14,6 +14,7 @@ using SharpCompress.Compressors.Deflate; using SharpCompress.Compressors.LZMA; using SharpCompress.Compressors.PPMd; +using SharpCompress.Compressors.ZStandard; using SharpCompress.IO; namespace SharpCompress.Writers.Zip; @@ -93,7 +94,8 @@ public override void Write(string entryPath, Stream source, DateTime? modificati public void Write(string entryPath, Stream source, ZipWriterEntryOptions zipWriterEntryOptions) { using var output = WriteToStream(entryPath, zipWriterEntryOptions); - source.CopyTo(output); + var progressStream = WrapWithProgress(source, entryPath); + progressStream.CopyTo(output); } public Stream WriteToStream(string entryPath, ZipWriterEntryOptions options) @@ -556,7 +558,7 @@ private Stream GetWriteStream(Stream writeStream) } case ZipCompressionMethod.ZStandard: { - return new ZstdSharp.CompressionStream(counting, compressionLevel); + return new CompressionStream(counting, compressionLevel); } default: { diff --git a/src/SharpCompress/packages.lock.json b/src/SharpCompress/packages.lock.json index 3d0d443d6..581ac15c6 100644 --- a/src/SharpCompress/packages.lock.json +++ b/src/SharpCompress/packages.lock.json @@ -4,11 +4,11 @@ ".NETFramework,Version=v4.8": { "Microsoft.Bcl.AsyncInterfaces": { "type": "Direct", - "requested": "[8.0.0, )", - "resolved": "8.0.0", - "contentHash": "3WA9q9yVqJp222P3x1wYIGDAkpjAku0TMUaaQV22g6L67AI0LdOIrVS7Ht2vJfLHGSPVuqN94vIr15qn+HEkHw==", + "requested": "[10.0.0, )", + "resolved": "10.0.0", + "contentHash": "vFuwSLj9QJBbNR0NeNO4YVASUbokxs+i/xbuu8B+Fs4FAZg5QaFa6eGrMaRqTzzNI5tAb97T7BhSxtLckFyiRA==", "dependencies": { - "System.Threading.Tasks.Extensions": "4.5.4" + "System.Threading.Tasks.Extensions": "4.6.3" } }, "Microsoft.NETFramework.ReferenceAssemblies": { @@ -49,23 +49,13 @@ }, "System.Text.Encoding.CodePages": { "type": "Direct", - "requested": "[8.0.0, )", - "resolved": "8.0.0", - "contentHash": "OZIsVplFGaVY90G2SbpgU7EnCoOO5pw1t4ic21dBF3/1omrJFpAGoNAVpPyMVOC90/hvgkGG3VFqR13YgZMQfg==", + "requested": "[10.0.0, )", + "resolved": "10.0.0", + "contentHash": "QLP54mIATaBpjGlsZIxga38VPk1G9js0Kw651B+bvrXi2kSgGZYrxJSpM3whhTZCBK4HEBHX3fzfDQMw7CXHGQ==", "dependencies": { - "System.Memory": "4.5.5", - "System.Runtime.CompilerServices.Unsafe": "6.0.0" - } - }, - "ZstdSharp.Port": { - "type": "Direct", - "requested": "[0.8.6, )", - "resolved": "0.8.6", - "contentHash": "iP4jVLQoQmUjMU88g1WObiNr6YKZGvh4aOXn3yOJsHqZsflwRsxZPcIBvNXgjXO3vQKSLctXGLTpcBPLnWPS8A==", - "dependencies": { - "Microsoft.Bcl.AsyncInterfaces": "5.0.0", - "System.Memory": "4.5.5", - "System.Runtime.CompilerServices.Unsafe": "6.0.0" + "System.Memory": "4.6.3", + "System.Runtime.CompilerServices.Unsafe": "6.1.2", + "System.ValueTuple": "4.6.1" } }, "Microsoft.Build.Tasks.Git": { @@ -95,216 +85,25 @@ }, "System.Threading.Tasks.Extensions": { "type": "Transitive", - "resolved": "4.5.4", - "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==", - "dependencies": { - "System.Runtime.CompilerServices.Unsafe": "4.5.3" - } - } - }, - ".NETFramework,Version=v4.8.1": { - "Microsoft.Bcl.AsyncInterfaces": { - "type": "Direct", - "requested": "[8.0.0, )", - "resolved": "8.0.0", - "contentHash": "3WA9q9yVqJp222P3x1wYIGDAkpjAku0TMUaaQV22g6L67AI0LdOIrVS7Ht2vJfLHGSPVuqN94vIr15qn+HEkHw==", - "dependencies": { - "System.Threading.Tasks.Extensions": "4.5.4" - } - }, - "Microsoft.NETFramework.ReferenceAssemblies": { - "type": "Direct", - "requested": "[1.0.3, )", - "resolved": "1.0.3", - "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==", - "dependencies": { - "Microsoft.NETFramework.ReferenceAssemblies.net481": "1.0.3" - } - }, - "Microsoft.SourceLink.GitHub": { - "type": "Direct", - "requested": "[8.0.0, )", - "resolved": "8.0.0", - "contentHash": "G5q7OqtwIyGTkeIOAc3u2ZuV/kicQaec5EaRnc0pIeSnh9LUjj+PYQrJYBURvDt7twGl2PKA7nSN0kz1Zw5bnQ==", - "dependencies": { - "Microsoft.Build.Tasks.Git": "8.0.0", - "Microsoft.SourceLink.Common": "8.0.0" - } - }, - "System.Buffers": { - "type": "Direct", - "requested": "[4.6.1, )", - "resolved": "4.6.1", - "contentHash": "N8GXpmiLMtljq7gwvyS+1QvKT/W2J8sNAvx+HVg4NGmsG/H+2k/y9QI23auLJRterrzCiDH+IWAw4V/GPwsMlw==" - }, - "System.Memory": { - "type": "Direct", - "requested": "[4.6.3, )", "resolved": "4.6.3", - "contentHash": "qdcDOgnFZY40+Q9876JUHnlHu7bosOHX8XISRoH94fwk6hgaeQGSgfZd8srWRZNt5bV9ZW2TljcegDNxsf+96A==", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", "dependencies": { - "System.Buffers": "4.6.1", - "System.Numerics.Vectors": "4.6.1", "System.Runtime.CompilerServices.Unsafe": "6.1.2" } }, - "System.Text.Encoding.CodePages": { - "type": "Direct", - "requested": "[8.0.0, )", - "resolved": "8.0.0", - "contentHash": "OZIsVplFGaVY90G2SbpgU7EnCoOO5pw1t4ic21dBF3/1omrJFpAGoNAVpPyMVOC90/hvgkGG3VFqR13YgZMQfg==", - "dependencies": { - "System.Memory": "4.5.5", - "System.Runtime.CompilerServices.Unsafe": "6.0.0" - } - }, - "ZstdSharp.Port": { - "type": "Direct", - "requested": "[0.8.6, )", - "resolved": "0.8.6", - "contentHash": "iP4jVLQoQmUjMU88g1WObiNr6YKZGvh4aOXn3yOJsHqZsflwRsxZPcIBvNXgjXO3vQKSLctXGLTpcBPLnWPS8A==", - "dependencies": { - "Microsoft.Bcl.AsyncInterfaces": "5.0.0", - "System.Memory": "4.5.5", - "System.Runtime.CompilerServices.Unsafe": "6.0.0" - } - }, - "Microsoft.Build.Tasks.Git": { - "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "bZKfSIKJRXLTuSzLudMFte/8CempWjVamNUR5eHJizsy+iuOuO/k2gnh7W0dHJmYY0tBf+gUErfluCv5mySAOQ==" - }, - "Microsoft.NETFramework.ReferenceAssemblies.net481": { - "type": "Transitive", - "resolved": "1.0.3", - "contentHash": "Vv/20vgHS7VglVOVh8J3Iz/MA+VYKVRp9f7r2qiKBMuzviTOmocG70yq0Q8T5OTmCONkEAIJwETD1zhEfLkAXQ==" - }, - "Microsoft.SourceLink.Common": { - "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" - }, - "System.Numerics.Vectors": { + "System.ValueTuple": { "type": "Transitive", "resolved": "4.6.1", - "contentHash": "sQxefTnhagrhoq2ReR0D/6K0zJcr9Hrd6kikeXsA1I8kOCboTavcUC4r7TSfpKFeE163uMuxZcyfO1mGO3EN8Q==" - }, - "System.Runtime.CompilerServices.Unsafe": { - "type": "Transitive", - "resolved": "6.1.2", - "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" - }, - "System.Threading.Tasks.Extensions": { - "type": "Transitive", - "resolved": "4.5.4", - "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==", - "dependencies": { - "System.Runtime.CompilerServices.Unsafe": "4.5.3" - } + "contentHash": "+RJT4qaekpZ7DDLhf+LTjq+E48jieKiY9ulJ+BoxKmZblIJfIJT8Ufcaa/clQqnYvWs8jugfGSMu8ylS0caG0w==" } }, - ".NETStandard,Version=v2.0": { - "Microsoft.Bcl.AsyncInterfaces": { - "type": "Direct", - "requested": "[8.0.0, )", - "resolved": "8.0.0", - "contentHash": "3WA9q9yVqJp222P3x1wYIGDAkpjAku0TMUaaQV22g6L67AI0LdOIrVS7Ht2vJfLHGSPVuqN94vIr15qn+HEkHw==", - "dependencies": { - "System.Threading.Tasks.Extensions": "4.5.4" - } - }, - "Microsoft.SourceLink.GitHub": { - "type": "Direct", - "requested": "[8.0.0, )", - "resolved": "8.0.0", - "contentHash": "G5q7OqtwIyGTkeIOAc3u2ZuV/kicQaec5EaRnc0pIeSnh9LUjj+PYQrJYBURvDt7twGl2PKA7nSN0kz1Zw5bnQ==", - "dependencies": { - "Microsoft.Build.Tasks.Git": "8.0.0", - "Microsoft.SourceLink.Common": "8.0.0" - } - }, - "NETStandard.Library": { - "type": "Direct", - "requested": "[2.0.3, )", - "resolved": "2.0.3", - "contentHash": "st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==", - "dependencies": { - "Microsoft.NETCore.Platforms": "1.1.0" - } - }, - "System.Memory": { - "type": "Direct", - "requested": "[4.6.3, )", - "resolved": "4.6.3", - "contentHash": "qdcDOgnFZY40+Q9876JUHnlHu7bosOHX8XISRoH94fwk6hgaeQGSgfZd8srWRZNt5bV9ZW2TljcegDNxsf+96A==", - "dependencies": { - "System.Buffers": "4.6.1", - "System.Numerics.Vectors": "4.6.1", - "System.Runtime.CompilerServices.Unsafe": "6.1.2" - } - }, - "System.Text.Encoding.CodePages": { - "type": "Direct", - "requested": "[8.0.0, )", - "resolved": "8.0.0", - "contentHash": "OZIsVplFGaVY90G2SbpgU7EnCoOO5pw1t4ic21dBF3/1omrJFpAGoNAVpPyMVOC90/hvgkGG3VFqR13YgZMQfg==", - "dependencies": { - "System.Memory": "4.5.5", - "System.Runtime.CompilerServices.Unsafe": "6.0.0" - } - }, - "ZstdSharp.Port": { + "net10.0": { + "Microsoft.NET.ILLink.Tasks": { "type": "Direct", - "requested": "[0.8.6, )", - "resolved": "0.8.6", - "contentHash": "iP4jVLQoQmUjMU88g1WObiNr6YKZGvh4aOXn3yOJsHqZsflwRsxZPcIBvNXgjXO3vQKSLctXGLTpcBPLnWPS8A==", - "dependencies": { - "Microsoft.Bcl.AsyncInterfaces": "5.0.0", - "System.Memory": "4.5.5", - "System.Runtime.CompilerServices.Unsafe": "6.0.0" - } - }, - "Microsoft.Build.Tasks.Git": { - "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "bZKfSIKJRXLTuSzLudMFte/8CempWjVamNUR5eHJizsy+iuOuO/k2gnh7W0dHJmYY0tBf+gUErfluCv5mySAOQ==" - }, - "Microsoft.NETCore.Platforms": { - "type": "Transitive", - "resolved": "1.1.0", - "contentHash": "kz0PEW2lhqygehI/d6XsPCQzD7ff7gUJaVGPVETX611eadGsA3A877GdSlU0LRVMCTH/+P3o2iDTak+S08V2+A==" - }, - "Microsoft.SourceLink.Common": { - "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" - }, - "System.Numerics.Vectors": { - "type": "Transitive", - "resolved": "4.6.1", - "contentHash": "sQxefTnhagrhoq2ReR0D/6K0zJcr9Hrd6kikeXsA1I8kOCboTavcUC4r7TSfpKFeE163uMuxZcyfO1mGO3EN8Q==" + "requested": "[10.0.0, )", + "resolved": "10.0.0", + "contentHash": "kICGrGYEzCNI3wPzfEXcwNHgTvlvVn9yJDhSdRK+oZQy4jvYH529u7O0xf5ocQKzOMjfS07+3z9PKRIjrFMJDA==" }, - "System.Runtime.CompilerServices.Unsafe": { - "type": "Transitive", - "resolved": "6.1.2", - "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" - }, - "System.Threading.Tasks.Extensions": { - "type": "Transitive", - "resolved": "4.5.4", - "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==", - "dependencies": { - "System.Runtime.CompilerServices.Unsafe": "4.5.3" - } - }, - "System.Buffers": { - "type": "CentralTransitive", - "requested": "[4.6.1, )", - "resolved": "4.6.1", - "contentHash": "N8GXpmiLMtljq7gwvyS+1QvKT/W2J8sNAvx+HVg4NGmsG/H+2k/y9QI23auLJRterrzCiDH+IWAw4V/GPwsMlw==" - } - }, - "net6.0": { "Microsoft.SourceLink.GitHub": { "type": "Direct", "requested": "[8.0.0, )", @@ -315,12 +114,6 @@ "Microsoft.SourceLink.Common": "8.0.0" } }, - "ZstdSharp.Port": { - "type": "Direct", - "requested": "[0.8.6, )", - "resolved": "0.8.6", - "contentHash": "iP4jVLQoQmUjMU88g1WObiNr6YKZGvh4aOXn3yOJsHqZsflwRsxZPcIBvNXgjXO3vQKSLctXGLTpcBPLnWPS8A==" - }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", "resolved": "8.0.0", @@ -335,9 +128,9 @@ "net8.0": { "Microsoft.NET.ILLink.Tasks": { "type": "Direct", - "requested": "[8.0.21, )", - "resolved": "8.0.21", - "contentHash": "s8H5PZQs50OcNkaB6Si54+v3GWM7vzs6vxFRMlD3aXsbM+aPCtod62gmK0BYWou9diGzmo56j8cIf/PziijDqQ==" + "requested": "[10.0.0, )", + "resolved": "10.0.0", + "contentHash": "kICGrGYEzCNI3wPzfEXcwNHgTvlvVn9yJDhSdRK+oZQy4jvYH529u7O0xf5ocQKzOMjfS07+3z9PKRIjrFMJDA==" }, "Microsoft.SourceLink.GitHub": { "type": "Direct", @@ -349,12 +142,6 @@ "Microsoft.SourceLink.Common": "8.0.0" } }, - "ZstdSharp.Port": { - "type": "Direct", - "requested": "[0.8.6, )", - "resolved": "0.8.6", - "contentHash": "iP4jVLQoQmUjMU88g1WObiNr6YKZGvh4aOXn3yOJsHqZsflwRsxZPcIBvNXgjXO3vQKSLctXGLTpcBPLnWPS8A==" - }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", "resolved": "8.0.0", diff --git a/tests/SharpCompress.Performance/SharpCompress.Performance.csproj b/tests/SharpCompress.Performance/SharpCompress.Performance.csproj index 460b1d533..cab757e47 100644 --- a/tests/SharpCompress.Performance/SharpCompress.Performance.csproj +++ b/tests/SharpCompress.Performance/SharpCompress.Performance.csproj @@ -1,7 +1,7 @@  Exe - net8.0 + net10.0 diff --git a/tests/SharpCompress.Performance/packages.lock.json b/tests/SharpCompress.Performance/packages.lock.json index 5c6a2b9ea..255570ad3 100644 --- a/tests/SharpCompress.Performance/packages.lock.json +++ b/tests/SharpCompress.Performance/packages.lock.json @@ -1,12 +1,12 @@ { "version": 2, "dependencies": { - "net8.0": { + "net10.0": { "JetBrains.Profiler.SelfApi": { "type": "Direct", - "requested": "[2.5.14, )", - "resolved": "2.5.14", - "contentHash": "9+NcTe49B2M8/MOledSxKZkQKqavFf5xXZw4JL4bVu/KYiw6OOaD6cDQmNGSO18yUP/WoBXsXGKmZ9VOpmyadw==", + "requested": "[2.5.15, )", + "resolved": "2.5.15", + "contentHash": "Uc+GU4Mqwzw6i6C6wPWe2g9UwReUJzrWghCSN9818tSmNI7SJtqKQ1mgfuRylpJam+ED4Cbg2BNJE/LSVpokkg==", "dependencies": { "JetBrains.HabitatDetector": "1.4.5", "JetBrains.Profiler.Api": "1.4.10" @@ -34,16 +34,7 @@ } }, "sharpcompress": { - "type": "Project", - "dependencies": { - "ZstdSharp.Port": "[0.8.6, )" - } - }, - "ZstdSharp.Port": { - "type": "CentralTransitive", - "requested": "[0.8.6, )", - "resolved": "0.8.6", - "contentHash": "iP4jVLQoQmUjMU88g1WObiNr6YKZGvh4aOXn3yOJsHqZsflwRsxZPcIBvNXgjXO3vQKSLctXGLTpcBPLnWPS8A==" + "type": "Project" } } } diff --git a/tests/SharpCompress.Test/Ace/AceReaderTests.cs b/tests/SharpCompress.Test/Ace/AceReaderTests.cs new file mode 100644 index 000000000..b6cf97f2a --- /dev/null +++ b/tests/SharpCompress.Test/Ace/AceReaderTests.cs @@ -0,0 +1,61 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SharpCompress.Common; +using SharpCompress.Readers; +using SharpCompress.Readers.Ace; +using Xunit; + +namespace SharpCompress.Test.Ace +{ + public class AceReaderTests : ReaderTests + { + public AceReaderTests() + { + UseExtensionInsteadOfNameToVerify = true; + UseCaseInsensitiveToVerify = true; + } + + [Fact] + public void Ace_Uncompressed_Read() => Read("Ace.store.ace", CompressionType.None); + + [Fact] + public void Ace_Encrypted_Read() + { + var exception = Assert.Throws(() => Read("Ace.encrypted.ace")); + } + + [Theory] + [InlineData("Ace.method1.ace", CompressionType.AceLZ77)] + [InlineData("Ace.method1-solid.ace", CompressionType.AceLZ77)] + [InlineData("Ace.method2.ace", CompressionType.AceLZ77)] + [InlineData("Ace.method2-solid.ace", CompressionType.AceLZ77)] + public void Ace_Unsupported_ShouldThrow(string fileName, CompressionType compressionType) + { + var exception = Assert.Throws(() => + Read(fileName, compressionType) + ); + } + + [Theory] + [InlineData("Ace.store.largefile.ace", CompressionType.None)] + public void Ace_LargeFileTest_Read(string fileName, CompressionType compressionType) + { + ReadForBufferBoundaryCheck(fileName, compressionType); + } + + [Fact] + public void Ace_Multi_Reader() + { + var exception = Assert.Throws(() => + DoMultiReader( + ["Ace.store.split.ace", "Ace.store.split.c01"], + streams => AceReader.Open(streams) + ) + ); + } + } +} diff --git a/tests/SharpCompress.Test/ArchiveTests.cs b/tests/SharpCompress.Test/ArchiveTests.cs index 2f47e1215..916c9e2c0 100644 --- a/tests/SharpCompress.Test/ArchiveTests.cs +++ b/tests/SharpCompress.Test/ArchiveTests.cs @@ -261,7 +261,7 @@ protected void ArchiveExtractToDirectory( testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); using (var archive = ArchiveFactory.Open(new FileInfo(testArchive), readerOptions)) { - archive.ExtractToDirectory(SCRATCH_FILES_PATH); + archive.WriteToDirectory(SCRATCH_FILES_PATH); } VerifyFiles(); } diff --git a/tests/SharpCompress.Test/Arj/ArjReaderTests.cs b/tests/SharpCompress.Test/Arj/ArjReaderTests.cs index ec8b422d7..bad98ec80 100644 --- a/tests/SharpCompress.Test/Arj/ArjReaderTests.cs +++ b/tests/SharpCompress.Test/Arj/ArjReaderTests.cs @@ -45,14 +45,17 @@ public void Arj_Encrypted_Read() public void Arj_Multi_Reader() { var exception = Assert.Throws(() => - DoArj_Multi_Reader([ - "Arj.store.split.arj", - "Arj.store.split.a01", - "Arj.store.split.a02", - "Arj.store.split.a03", - "Arj.store.split.a04", - "Arj.store.split.a05", - ]) + DoMultiReader( + [ + "Arj.store.split.arj", + "Arj.store.split.a01", + "Arj.store.split.a02", + "Arj.store.split.a03", + "Arj.store.split.a04", + "Arj.store.split.a05", + ], + streams => ArjReader.Open(streams) + ) ); } @@ -74,26 +77,5 @@ public void Arj_LargeFileTest_Read(string fileName, CompressionType compressionT { ReadForBufferBoundaryCheck(fileName, compressionType); } - - private void DoArj_Multi_Reader(string[] archives) - { - using ( - var reader = ArjReader.Open( - archives - .Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)) - .Select(p => File.OpenRead(p)) - ) - ) - { - while (reader.MoveToNextEntry()) - { - reader.WriteEntryToDirectory( - SCRATCH_FILES_PATH, - new ExtractionOptions { ExtractFullPath = true, Overwrite = true } - ); - } - } - VerifyFiles(); - } } } diff --git a/tests/SharpCompress.Test/ExtractAll.cs b/tests/SharpCompress.Test/ExtractAll.cs new file mode 100644 index 000000000..3e8b7d7a2 --- /dev/null +++ b/tests/SharpCompress.Test/ExtractAll.cs @@ -0,0 +1,46 @@ +using System.IO; +using System.Linq; +using System.Threading.Tasks; +using SharpCompress.Archives; +using SharpCompress.Common; +using SharpCompress.Readers; +using Xunit; + +namespace SharpCompress.Test; + +public class ExtractAllTests : TestBase +{ + [Theory] + [InlineData("Zip.deflate.zip")] + [InlineData("Rar5.rar")] + [InlineData("Rar.rar")] + [InlineData("Rar.solid.rar")] + [InlineData("7Zip.solid.7z")] + [InlineData("7Zip.nonsolid.7z")] + [InlineData("7Zip.LZMA.7z")] + public async Task ExtractAllEntriesAsync(string archivePath) + { + var testArchive = Path.Combine(TEST_ARCHIVES_PATH, archivePath); + var options = new ExtractionOptions() { ExtractFullPath = true, Overwrite = true }; + + using var archive = ArchiveFactory.Open(testArchive); + await archive.WriteToDirectoryAsync(SCRATCH_FILES_PATH, options); + } + + [Theory] + [InlineData("Zip.deflate.zip")] + [InlineData("Rar5.rar")] + [InlineData("Rar.rar")] + [InlineData("Rar.solid.rar")] + [InlineData("7Zip.solid.7z")] + [InlineData("7Zip.nonsolid.7z")] + [InlineData("7Zip.LZMA.7z")] + public void ExtractAllEntriesSync(string archivePath) + { + var testArchive = Path.Combine(TEST_ARCHIVES_PATH, archivePath); + var options = new ExtractionOptions() { ExtractFullPath = true, Overwrite = true }; + + using var archive = ArchiveFactory.Open(testArchive); + archive.WriteToDirectory(SCRATCH_FILES_PATH, options); + } +} diff --git a/tests/SharpCompress.Test/ExtractAllEntriesTests.cs b/tests/SharpCompress.Test/ExtractAllEntriesTests.cs new file mode 100644 index 000000000..007f620f7 --- /dev/null +++ b/tests/SharpCompress.Test/ExtractAllEntriesTests.cs @@ -0,0 +1,61 @@ +using System.IO; +using System.Linq; +using SharpCompress.Archives; +using SharpCompress.Common; +using SharpCompress.Readers; +using Xunit; + +namespace SharpCompress.Test; + +/// +/// Tests for the ExtractAllEntries method behavior on both solid and non-solid +/// archives, including progress reporting and current usage restrictions. +/// +public class ExtractAllEntriesTests : TestBase +{ + [Fact] + public void ExtractAllEntries_WithProgressReporting_NonSolidArchive() + { + var archivePath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.zip"); + + using var archive = ArchiveFactory.Open(archivePath); + Assert.Throws(() => + { + using var reader = archive.ExtractAllEntries(); + }); + } + + [Fact] + public void ExtractAllEntries_WithProgressReporting_SolidArchive() + { + var archivePath = Path.Combine(TEST_ARCHIVES_PATH, "Rar.solid.rar"); + + using var archive = ArchiveFactory.Open(archivePath); + Assert.True(archive.IsSolid); + + // Calculate total size like user code does + double totalSize = archive.Entries.Where(e => !e.IsDirectory).Sum(e => e.Size); + long completed = 0; + var progressReports = 0; + + using var reader = archive.ExtractAllEntries(); + while (reader.MoveToNextEntry()) + { + if (!reader.Entry.IsDirectory) + { + reader.WriteEntryToDirectory( + SCRATCH_FILES_PATH, + new ExtractionOptions { ExtractFullPath = true, Overwrite = true } + ); + + completed += reader.Entry.Size; + var progress = completed / totalSize; + progressReports++; + + Assert.True(progress >= 0 && progress <= 1.0); + } + } + + Assert.True(progressReports > 0); + } +} diff --git a/tests/SharpCompress.Test/Mocks/TruncatedStream.cs b/tests/SharpCompress.Test/Mocks/TruncatedStream.cs new file mode 100644 index 000000000..8699a430d --- /dev/null +++ b/tests/SharpCompress.Test/Mocks/TruncatedStream.cs @@ -0,0 +1,65 @@ +using System; +using System.IO; + +namespace SharpCompress.Test.Mocks; + +/// +/// A stream wrapper that truncates the underlying stream after reading a specified number of bytes. +/// Used for testing error handling when streams end prematurely. +/// +public class TruncatedStream : Stream +{ + private readonly Stream baseStream; + private readonly long truncateAfterBytes; + private long bytesRead; + + public TruncatedStream(Stream baseStream, long truncateAfterBytes) + { + this.baseStream = baseStream ?? throw new ArgumentNullException(nameof(baseStream)); + this.truncateAfterBytes = truncateAfterBytes; + bytesRead = 0; + } + + public override bool CanRead => baseStream.CanRead; + public override bool CanSeek => baseStream.CanSeek; + public override bool CanWrite => false; + public override long Length => baseStream.Length; + + public override long Position + { + get => baseStream.Position; + set => baseStream.Position = value; + } + + public override int Read(byte[] buffer, int offset, int count) + { + if (bytesRead >= truncateAfterBytes) + { + // Simulate premature end of stream + return 0; + } + + var maxBytesToRead = (int)Math.Min(count, truncateAfterBytes - bytesRead); + var actualBytesRead = baseStream.Read(buffer, offset, maxBytesToRead); + bytesRead += actualBytesRead; + return actualBytesRead; + } + + public override long Seek(long offset, SeekOrigin origin) => baseStream.Seek(offset, origin); + + public override void SetLength(long value) => throw new NotSupportedException(); + + public override void Write(byte[] buffer, int offset, int count) => + throw new NotSupportedException(); + + public override void Flush() => baseStream.Flush(); + + protected override void Dispose(bool disposing) + { + if (disposing) + { + baseStream?.Dispose(); + } + base.Dispose(disposing); + } +} diff --git a/tests/SharpCompress.Test/ProgressReportTests.cs b/tests/SharpCompress.Test/ProgressReportTests.cs new file mode 100644 index 000000000..75fa21164 --- /dev/null +++ b/tests/SharpCompress.Test/ProgressReportTests.cs @@ -0,0 +1,605 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using SharpCompress.Archives; +using SharpCompress.Archives.Zip; +using SharpCompress.Common; +using SharpCompress.Readers; +using SharpCompress.Writers; +using SharpCompress.Writers.Tar; +using SharpCompress.Writers.Zip; +using Xunit; + +namespace SharpCompress.Test; + +/// +/// A synchronous progress implementation for testing. +/// Unlike Progress<T>, this captures reports immediately without SynchronizationContext. +/// +internal sealed class TestProgress : IProgress +{ + private readonly List _reports = new(); + + public IReadOnlyList Reports => _reports; + + public void Report(T value) => _reports.Add(value); +} + +public class ProgressReportTests : TestBase +{ + private static byte[] CreateTestData(int size, byte fillValue) + { + var data = new byte[size]; + for (var i = 0; i < size; i++) + { + data[i] = fillValue; + } + return data; + } + + [Fact] + public void Zip_Write_ReportsProgress() + { + var progress = new TestProgress(); + + using var archiveStream = new MemoryStream(); + var options = new ZipWriterOptions(CompressionType.Deflate) { Progress = progress }; + + using (var writer = new ZipWriter(archiveStream, options)) + { + var testData = CreateTestData(10000, (byte)'A'); + using var sourceStream = new MemoryStream(testData); + writer.Write("test.txt", sourceStream, DateTime.Now); + } + + Assert.NotEmpty(progress.Reports); + Assert.All(progress.Reports, p => Assert.Equal("test.txt", p.EntryPath)); + Assert.All(progress.Reports, p => Assert.Equal(10000, p.TotalBytes)); + + var lastReport = progress.Reports[progress.Reports.Count - 1]; + Assert.Equal(10000, lastReport.BytesTransferred); + Assert.Equal(100.0, lastReport.PercentComplete); + } + + [Fact] + public void Tar_Write_ReportsProgress() + { + var progress = new TestProgress(); + + using var archiveStream = new MemoryStream(); + var options = new TarWriterOptions(CompressionType.None, true) { Progress = progress }; + + using (var writer = new TarWriter(archiveStream, options)) + { + var testData = CreateTestData(10000, (byte)'A'); + using var sourceStream = new MemoryStream(testData); + writer.Write("test.txt", sourceStream, DateTime.Now); + } + + Assert.NotEmpty(progress.Reports); + Assert.All(progress.Reports, p => Assert.Equal("test.txt", p.EntryPath)); + Assert.All(progress.Reports, p => Assert.Equal(10000, p.TotalBytes)); + + var lastReport = progress.Reports[progress.Reports.Count - 1]; + Assert.Equal(10000, lastReport.BytesTransferred); + Assert.Equal(100.0, lastReport.PercentComplete); + } + + [Fact] + public void Zip_Read_ReportsProgress() + { + var progress = new TestProgress(); + + // First create a zip archive + using var archiveStream = new MemoryStream(); + using ( + var writer = new ZipWriter(archiveStream, new ZipWriterOptions(CompressionType.Deflate)) + ) + { + var testData = CreateTestData(10000, (byte)'A'); + using var sourceStream = new MemoryStream(testData); + writer.Write("test.txt", sourceStream, DateTime.Now); + } + + // Now read it with progress reporting + archiveStream.Position = 0; + var readerOptions = new ReaderOptions { Progress = progress }; + + using (var reader = ReaderFactory.Open(archiveStream, readerOptions)) + { + while (reader.MoveToNextEntry()) + { + if (!reader.Entry.IsDirectory) + { + using var extractedStream = new MemoryStream(); + reader.WriteEntryTo(extractedStream); + } + } + } + + Assert.NotEmpty(progress.Reports); + Assert.All(progress.Reports, p => Assert.Equal("test.txt", p.EntryPath)); + + var lastReport = progress.Reports[progress.Reports.Count - 1]; + Assert.Equal(10000, lastReport.BytesTransferred); + } + + [Fact] + public void ZipArchive_Entry_WriteTo_ReportsProgress() + { + var progress = new TestProgress(); + + // First create a zip archive + using var archiveStream = new MemoryStream(); + using ( + var writer = new ZipWriter(archiveStream, new ZipWriterOptions(CompressionType.Deflate)) + ) + { + var testData = CreateTestData(10000, (byte)'A'); + using var sourceStream = new MemoryStream(testData); + writer.Write("test.txt", sourceStream, DateTime.Now); + } + + // Now open as archive and extract entry with progress as parameter + archiveStream.Position = 0; + + using var archive = ZipArchive.Open(archiveStream); + foreach (var entry in archive.Entries) + { + if (!entry.IsDirectory) + { + using var extractedStream = new MemoryStream(); + entry.WriteTo(extractedStream, progress); + } + } + + Assert.NotEmpty(progress.Reports); + Assert.All(progress.Reports, p => Assert.Equal("test.txt", p.EntryPath)); + + var lastReport = progress.Reports[progress.Reports.Count - 1]; + Assert.Equal(10000, lastReport.BytesTransferred); + } + + [Fact] + public async Task ZipArchive_Entry_WriteToAsync_ReportsProgress() + { + var progress = new TestProgress(); + + // First create a zip archive + using var archiveStream = new MemoryStream(); + using ( + var writer = new ZipWriter(archiveStream, new ZipWriterOptions(CompressionType.Deflate)) + ) + { + var testData = CreateTestData(10000, (byte)'A'); + using var sourceStream = new MemoryStream(testData); + writer.Write("test.txt", sourceStream, DateTime.Now); + } + + // Now open as archive and extract entry async with progress as parameter + archiveStream.Position = 0; + + using var archive = ZipArchive.Open(archiveStream); + foreach (var entry in archive.Entries) + { + if (!entry.IsDirectory) + { + using var extractedStream = new MemoryStream(); + await entry.WriteToAsync(extractedStream, progress, CancellationToken.None); + } + } + + Assert.NotEmpty(progress.Reports); + Assert.All(progress.Reports, p => Assert.Equal("test.txt", p.EntryPath)); + + var lastReport = progress.Reports[progress.Reports.Count - 1]; + Assert.Equal(10000, lastReport.BytesTransferred); + } + + [Fact] + public void WriterOptions_WithoutProgress_DoesNotThrow() + { + using var archiveStream = new MemoryStream(); + var options = new ZipWriterOptions(CompressionType.Deflate); + Assert.Null(options.Progress); + + using (var writer = new ZipWriter(archiveStream, options)) + { + var testData = CreateTestData(100, (byte)'A'); + using var sourceStream = new MemoryStream(testData); + writer.Write("test.txt", sourceStream, DateTime.Now); + } + + Assert.True(archiveStream.Length > 0); + } + + [Fact] + public void ReaderOptions_WithoutProgress_DoesNotThrow() + { + // First create a zip archive + using var archiveStream = new MemoryStream(); + using ( + var writer = new ZipWriter(archiveStream, new ZipWriterOptions(CompressionType.Deflate)) + ) + { + var testData = CreateTestData(100, (byte)'A'); + using var sourceStream = new MemoryStream(testData); + writer.Write("test.txt", sourceStream, DateTime.Now); + } + + // Read without progress + archiveStream.Position = 0; + var readerOptions = new ReaderOptions(); + Assert.Null(readerOptions.Progress); + + using (var reader = ReaderFactory.Open(archiveStream, readerOptions)) + { + while (reader.MoveToNextEntry()) + { + if (!reader.Entry.IsDirectory) + { + using var extractedStream = new MemoryStream(); + reader.WriteEntryTo(extractedStream); + } + } + } + } + + [Fact] + public void ZipArchive_WithoutProgress_DoesNotThrow() + { + // First create a zip archive + using var archiveStream = new MemoryStream(); + using ( + var writer = new ZipWriter(archiveStream, new ZipWriterOptions(CompressionType.Deflate)) + ) + { + var testData = CreateTestData(100, (byte)'A'); + using var sourceStream = new MemoryStream(testData); + writer.Write("test.txt", sourceStream, DateTime.Now); + } + + // Open archive and extract without progress + archiveStream.Position = 0; + + using var archive = ZipArchive.Open(archiveStream); + foreach (var entry in archive.Entries) + { + if (!entry.IsDirectory) + { + using var extractedStream = new MemoryStream(); + entry.WriteTo(extractedStream); + } + } + } + + [Fact] + public void ProgressReport_PercentComplete_WithUnknownTotalBytes_ReturnsNull() + { + var progress = new ProgressReport("test.txt", 100, null); + Assert.Null(progress.PercentComplete); + } + + [Fact] + public void ProgressReport_PercentComplete_WithZeroTotalBytes_ReturnsNull() + { + var progress = new ProgressReport("test.txt", 0, 0); + Assert.Null(progress.PercentComplete); + } + + [Fact] + public void ProgressReport_Properties_AreSetCorrectly() + { + var progress = new ProgressReport("path/to/file.txt", 500, 1000); + + Assert.Equal("path/to/file.txt", progress.EntryPath); + Assert.Equal(500, progress.BytesTransferred); + Assert.Equal(1000, progress.TotalBytes); + Assert.Equal(50.0, progress.PercentComplete); + } + + [Fact] + public void Tar_Read_ReportsProgress() + { + var progress = new TestProgress(); + + // Create a tar archive first + using var archiveStream = new MemoryStream(); + using ( + var writer = new TarWriter( + archiveStream, + new TarWriterOptions(CompressionType.None, true) + ) + ) + { + var testData = CreateTestData(10000, (byte)'B'); + using var sourceStream = new MemoryStream(testData); + writer.Write("data.bin", sourceStream, DateTime.Now); + } + + // Now read it with progress reporting + archiveStream.Position = 0; + var readerOptions = new ReaderOptions { Progress = progress }; + + using (var reader = ReaderFactory.Open(archiveStream, readerOptions)) + { + while (reader.MoveToNextEntry()) + { + if (!reader.Entry.IsDirectory) + { + using var extractedStream = new MemoryStream(); + reader.WriteEntryTo(extractedStream); + } + } + } + + Assert.NotEmpty(progress.Reports); + Assert.All(progress.Reports, p => Assert.Equal("data.bin", p.EntryPath)); + + var lastReport = progress.Reports[progress.Reports.Count - 1]; + Assert.Equal(10000, lastReport.BytesTransferred); + } + + [Fact] + public void TarArchive_Entry_WriteTo_ReportsProgress() + { + var progress = new TestProgress(); + + // Create a tar archive first + using var archiveStream = new MemoryStream(); + using ( + var writer = new TarWriter( + archiveStream, + new TarWriterOptions(CompressionType.None, true) + ) + ) + { + var testData = CreateTestData(10000, (byte)'C'); + using var sourceStream = new MemoryStream(testData); + writer.Write("file.dat", sourceStream, DateTime.Now); + } + + // Now open as archive and extract entry with progress as parameter + archiveStream.Position = 0; + + using var archive = SharpCompress.Archives.Tar.TarArchive.Open(archiveStream); + foreach (var entry in archive.Entries) + { + if (!entry.IsDirectory) + { + using var extractedStream = new MemoryStream(); + entry.WriteTo(extractedStream, progress); + } + } + + Assert.NotEmpty(progress.Reports); + Assert.All(progress.Reports, p => Assert.Equal("file.dat", p.EntryPath)); + + var lastReport = progress.Reports[progress.Reports.Count - 1]; + Assert.Equal(10000, lastReport.BytesTransferred); + } + + [Fact] + public async Task TarArchive_Entry_WriteToAsync_ReportsProgress() + { + var progress = new TestProgress(); + + // Create a tar archive first + using var archiveStream = new MemoryStream(); + using ( + var writer = new TarWriter( + archiveStream, + new TarWriterOptions(CompressionType.None, true) + ) + ) + { + var testData = CreateTestData(10000, (byte)'D'); + using var sourceStream = new MemoryStream(testData); + writer.Write("async.dat", sourceStream, DateTime.Now); + } + + // Now open as archive and extract entry async with progress as parameter + archiveStream.Position = 0; + + using var archive = SharpCompress.Archives.Tar.TarArchive.Open(archiveStream); + foreach (var entry in archive.Entries) + { + if (!entry.IsDirectory) + { + using var extractedStream = new MemoryStream(); + await entry.WriteToAsync(extractedStream, progress, CancellationToken.None); + } + } + + Assert.NotEmpty(progress.Reports); + Assert.All(progress.Reports, p => Assert.Equal("async.dat", p.EntryPath)); + + var lastReport = progress.Reports[progress.Reports.Count - 1]; + Assert.Equal(10000, lastReport.BytesTransferred); + } + + [Fact] + public void Zip_Read_MultipleEntries_ReportsProgress() + { + var progress = new TestProgress(); + + // Create a zip archive with multiple entries + using var archiveStream = new MemoryStream(); + using ( + var writer = new ZipWriter(archiveStream, new ZipWriterOptions(CompressionType.Deflate)) + ) + { + var testData1 = CreateTestData(5000, (byte)'A'); + using var sourceStream1 = new MemoryStream(testData1); + writer.Write("file1.txt", sourceStream1, DateTime.Now); + + var testData2 = CreateTestData(8000, (byte)'B'); + using var sourceStream2 = new MemoryStream(testData2); + writer.Write("file2.txt", sourceStream2, DateTime.Now); + } + + // Now read it with progress reporting + archiveStream.Position = 0; + var readerOptions = new ReaderOptions { Progress = progress }; + + using (var reader = ReaderFactory.Open(archiveStream, readerOptions)) + { + while (reader.MoveToNextEntry()) + { + if (!reader.Entry.IsDirectory) + { + using var extractedStream = new MemoryStream(); + reader.WriteEntryTo(extractedStream); + } + } + } + + Assert.NotEmpty(progress.Reports); + + // Should have reports for both files + var file1Reports = progress.Reports.Where(p => p.EntryPath == "file1.txt").ToList(); + var file2Reports = progress.Reports.Where(p => p.EntryPath == "file2.txt").ToList(); + + Assert.NotEmpty(file1Reports); + Assert.NotEmpty(file2Reports); + + // Verify final bytes for each file + Assert.Equal(5000, file1Reports[file1Reports.Count - 1].BytesTransferred); + Assert.Equal(8000, file2Reports[file2Reports.Count - 1].BytesTransferred); + } + + [Fact] + public void ZipArchive_MultipleEntries_WriteTo_ReportsProgress() + { + var progress = new TestProgress(); + + // Create a zip archive with multiple entries + using var archiveStream = new MemoryStream(); + using ( + var writer = new ZipWriter(archiveStream, new ZipWriterOptions(CompressionType.Deflate)) + ) + { + var testData1 = CreateTestData(5000, (byte)'A'); + using var sourceStream1 = new MemoryStream(testData1); + writer.Write("entry1.txt", sourceStream1, DateTime.Now); + + var testData2 = CreateTestData(7000, (byte)'B'); + using var sourceStream2 = new MemoryStream(testData2); + writer.Write("entry2.txt", sourceStream2, DateTime.Now); + } + + // Now open as archive and extract entries with progress as parameter + archiveStream.Position = 0; + + using var archive = ZipArchive.Open(archiveStream); + foreach (var entry in archive.Entries) + { + if (!entry.IsDirectory) + { + using var extractedStream = new MemoryStream(); + entry.WriteTo(extractedStream, progress); + } + } + + Assert.NotEmpty(progress.Reports); + + // Should have reports for both files + var entry1Reports = progress.Reports.Where(p => p.EntryPath == "entry1.txt").ToList(); + var entry2Reports = progress.Reports.Where(p => p.EntryPath == "entry2.txt").ToList(); + + Assert.NotEmpty(entry1Reports); + Assert.NotEmpty(entry2Reports); + + // Verify final bytes for each entry + Assert.Equal(5000, entry1Reports[entry1Reports.Count - 1].BytesTransferred); + Assert.Equal(7000, entry2Reports[entry2Reports.Count - 1].BytesTransferred); + } + + [Fact] + public async Task Zip_ReadAsync_ReportsProgress() + { + var progress = new TestProgress(); + + // Create a zip archive + using var archiveStream = new MemoryStream(); + using ( + var writer = new ZipWriter(archiveStream, new ZipWriterOptions(CompressionType.Deflate)) + ) + { + var testData = CreateTestData(10000, (byte)'E'); + using var sourceStream = new MemoryStream(testData); + writer.Write("async_read.txt", sourceStream, DateTime.Now); + } + + // Now read it with progress reporting + archiveStream.Position = 0; + var readerOptions = new ReaderOptions { Progress = progress }; + + using (var reader = ReaderFactory.Open(archiveStream, readerOptions)) + { + while (reader.MoveToNextEntry()) + { + if (!reader.Entry.IsDirectory) + { + using var extractedStream = new MemoryStream(); + await reader.WriteEntryToAsync(extractedStream); + } + } + } + + Assert.NotEmpty(progress.Reports); + Assert.All(progress.Reports, p => Assert.Equal("async_read.txt", p.EntryPath)); + + var lastReport = progress.Reports[progress.Reports.Count - 1]; + Assert.Equal(10000, lastReport.BytesTransferred); + } + + [Fact] + public void GZip_Write_ReportsProgress() + { + var progress = new TestProgress(); + + using var archiveStream = new MemoryStream(); + var options = new SharpCompress.Writers.GZip.GZipWriterOptions { Progress = progress }; + + using (var writer = new SharpCompress.Writers.GZip.GZipWriter(archiveStream, options)) + { + var testData = CreateTestData(10000, (byte)'G'); + using var sourceStream = new MemoryStream(testData); + writer.Write("gzip_test.txt", sourceStream, DateTime.Now); + } + + Assert.NotEmpty(progress.Reports); + Assert.All(progress.Reports, p => Assert.Equal("gzip_test.txt", p.EntryPath)); + Assert.All(progress.Reports, p => Assert.Equal(10000, p.TotalBytes)); + + var lastReport = progress.Reports[progress.Reports.Count - 1]; + Assert.Equal(10000, lastReport.BytesTransferred); + Assert.Equal(100.0, lastReport.PercentComplete); + } + + [Fact] + public async Task Tar_WriteAsync_ReportsProgress() + { + var progress = new TestProgress(); + + using var archiveStream = new MemoryStream(); + var options = new TarWriterOptions(CompressionType.None, true) { Progress = progress }; + + using (var writer = new TarWriter(archiveStream, options)) + { + var testData = CreateTestData(10000, (byte)'A'); + using var sourceStream = new MemoryStream(testData); + await writer.WriteAsync("test.txt", sourceStream, DateTime.Now); + } + + Assert.NotEmpty(progress.Reports); + Assert.All(progress.Reports, p => Assert.Equal("test.txt", p.EntryPath)); + + var lastReport = progress.Reports[progress.Reports.Count - 1]; + Assert.Equal(10000, lastReport.BytesTransferred); + } +} diff --git a/tests/SharpCompress.Test/Rar/RarArchiveTests.cs b/tests/SharpCompress.Test/Rar/RarArchiveTests.cs index 1aca13ddc..ba42f649c 100644 --- a/tests/SharpCompress.Test/Rar/RarArchiveTests.cs +++ b/tests/SharpCompress.Test/Rar/RarArchiveTests.cs @@ -1,3 +1,4 @@ +using System; using System.IO; using System.Linq; using SharpCompress.Archives; @@ -5,6 +6,7 @@ using SharpCompress.Common; using SharpCompress.Compressors.LZMA.Utilites; using SharpCompress.Readers; +using SharpCompress.Test.Mocks; using Xunit; namespace SharpCompress.Test.Rar; @@ -633,4 +635,86 @@ public void Rar5_Encrypted_Iterate_Archive() => "Rar5.encrypted_filesOnly.rar", "Failure jpg exe Empty тест.txt jpg\\test.jpg exe\\test.exe" ); + + [Fact] + public void Rar_TestEncryptedDetection() + { + using var passwordProtectedFilesArchive = RarArchive.Open( + Path.Combine(TEST_ARCHIVES_PATH, "Rar.encrypted_filesOnly.rar") + ); + Assert.True(passwordProtectedFilesArchive.IsEncrypted); + } + + /// + /// Test for issue: InvalidOperationException when extracting RAR files. + /// This test verifies the fix for the validation logic that was changed from + /// (_position != Length) to (_position < Length). + /// The old logic would throw an exception when position exceeded expected length, + /// but the new logic only throws when decompression ends prematurely (position < expected). + /// + [Fact] + public void Rar_StreamValidation_OnlyThrowsOnPrematureEnd() + { + // Test normal extraction - should NOT throw InvalidOperationException + // even if actual decompressed size differs from header + var testFiles = new[] { "Rar.rar", "Rar5.rar", "Rar4.rar", "Rar2.rar" }; + + foreach (var testFile in testFiles) + { + using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, testFile)); + using var archive = RarArchive.Open(stream); + + // Extract all entries and read them completely + foreach (var entry in archive.Entries.Where(e => !e.IsDirectory)) + { + using var entryStream = entry.OpenEntryStream(); + using var ms = new MemoryStream(); + + // This should complete without throwing InvalidOperationException + // The fix ensures we only throw when position < expected length, not when position >= expected + entryStream.CopyTo(ms); + + // Verify we read some data + Assert.True( + ms.Length > 0, + $"Failed to extract data from {entry.Key} in {testFile}" + ); + } + } + } + + /// + /// Negative test case: Verifies that InvalidOperationException IS thrown when + /// a RAR stream ends prematurely (position < expected length). + /// This tests the validation condition (_position < Length) works correctly. + /// + [Fact] + public void Rar_StreamValidation_ThrowsOnTruncatedStream() + { + // This test verifies the exception is thrown when decompression ends prematurely + // by using a truncated stream that stops reading after a small number of bytes + var testFile = "Rar.rar"; + using var fileStream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, testFile)); + + // Wrap the file stream with a truncated stream that will stop reading early + // This simulates a corrupted or truncated RAR file + using var truncatedStream = new TruncatedStream(fileStream, 1000); + + // Opening the archive should work, but extracting should throw + // when we try to read beyond the truncated data + var exception = Assert.Throws(() => + { + using var archive = RarArchive.Open(truncatedStream); + foreach (var entry in archive.Entries.Where(e => !e.IsDirectory)) + { + using var entryStream = entry.OpenEntryStream(); + using var ms = new MemoryStream(); + // This should throw InvalidOperationException when it can't read all expected bytes + entryStream.CopyTo(ms); + } + }); + + // Verify the exception message matches our expectation + Assert.Contains("unpacked file size does not match header", exception.Message); + } } diff --git a/tests/SharpCompress.Test/ReaderTests.cs b/tests/SharpCompress.Test/ReaderTests.cs index cc5a75a76..897e6b329 100644 --- a/tests/SharpCompress.Test/ReaderTests.cs +++ b/tests/SharpCompress.Test/ReaderTests.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.IO; +using System.Linq; using System.Threading; using System.Threading.Tasks; using SharpCompress.Common; @@ -220,4 +221,26 @@ protected void Iterate( Assert.Equal(expected.Pop(), reader.Entry.Key); } } + + protected void DoMultiReader( + string[] archives, + Func, IDisposable> readerFactory + ) + { + using var reader = readerFactory( + archives.Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)).Select(File.OpenRead) + ); + + dynamic dynReader = reader; + + while (dynReader.MoveToNextEntry()) + { + dynReader.WriteEntryToDirectory( + SCRATCH_FILES_PATH, + new ExtractionOptions { ExtractFullPath = true, Overwrite = true } + ); + } + + VerifyFiles(); + } } diff --git a/tests/SharpCompress.Test/SevenZip/SevenZipArchiveTests.cs b/tests/SharpCompress.Test/SevenZip/SevenZipArchiveTests.cs index 829195864..af21ff94e 100644 --- a/tests/SharpCompress.Test/SevenZip/SevenZipArchiveTests.cs +++ b/tests/SharpCompress.Test/SevenZip/SevenZipArchiveTests.cs @@ -224,6 +224,15 @@ public void SevenZipArchive_Tar_PathRead() ); } + [Fact] + public void SevenZipArchive_TestEncryptedDetection() + { + using var passwordProtectedFilesArchive = SevenZipArchive.Open( + Path.Combine(TEST_ARCHIVES_PATH, "7Zip.encryptedFiles.7z") + ); + Assert.True(passwordProtectedFilesArchive.IsEncrypted); + } + [Fact] public void SevenZipArchive_TestSolidDetection() { diff --git a/tests/SharpCompress.Test/SharpCompress.Test.csproj b/tests/SharpCompress.Test/SharpCompress.Test.csproj index 916f67b67..6ee632bd5 100644 --- a/tests/SharpCompress.Test/SharpCompress.Test.csproj +++ b/tests/SharpCompress.Test/SharpCompress.Test.csproj @@ -1,12 +1,12 @@  - net8.0;net48 + net10.0;net48 SharpCompress.Test SharpCompress.Test SharpCompress.Test.snk true - + $(DefineConstants);DEBUG_STREAMS diff --git a/tests/SharpCompress.Test/Zip/ZipArchiveAsyncTests.cs b/tests/SharpCompress.Test/Zip/ZipArchiveAsyncTests.cs index 01fe9ca83..cd93a3c18 100644 --- a/tests/SharpCompress.Test/Zip/ZipArchiveAsyncTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipArchiveAsyncTests.cs @@ -194,4 +194,38 @@ await entry.WriteToDirectoryAsync( } VerifyFiles(); } + + [Fact] + public async Task Zip_Deflate_Archive_WriteToDirectoryAsync() + { + using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.zip"))) + using (var archive = ZipArchive.Open(stream)) + { + await archive.WriteToDirectoryAsync( + SCRATCH_FILES_PATH, + new ExtractionOptions { ExtractFullPath = true, Overwrite = true } + ); + } + VerifyFiles(); + } + + [Fact] + public async Task Zip_Deflate_Archive_WriteToDirectoryAsync_WithProgress() + { + var progressReports = new System.Collections.Generic.List(); + var progress = new Progress(report => progressReports.Add(report)); + + using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.zip"))) + using (var archive = ZipArchive.Open(stream)) + { + await archive.WriteToDirectoryAsync( + SCRATCH_FILES_PATH, + new ExtractionOptions { ExtractFullPath = true, Overwrite = true }, + progress + ); + } + + VerifyFiles(); + Assert.True(progressReports.Count > 0, "Progress reports should be generated"); + } } diff --git a/tests/SharpCompress.Test/Zip/ZipReaderTests.cs b/tests/SharpCompress.Test/Zip/ZipReaderTests.cs index c48d98f4d..fc87dc57d 100644 --- a/tests/SharpCompress.Test/Zip/ZipReaderTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipReaderTests.cs @@ -1,5 +1,7 @@ using System; +using System.Collections.Generic; using System.IO; +using System.Linq; using SharpCompress.Archives; using SharpCompress.Common; using SharpCompress.IO; @@ -397,4 +399,41 @@ public void Zip_Uncompressed_Encrypted_Read() Assert.Equal("second.txt", reader.Entry.Key); Assert.Equal(197, reader.Entry.Size); } + + [Fact] + public void ZipReader_Returns_Same_Entries_As_ZipArchive() + { + // Verifies that ZipReader and ZipArchive return the same entries + // for standard single-volume ZIP files. ZipReader processes LocalEntry + // headers sequentially, while ZipArchive uses DirectoryEntry headers + // from the central directory and seeks to LocalEntry headers for data. + var testFiles = new[] { "Zip.none.zip", "Zip.deflate.zip", "Zip.none.issue86.zip" }; + + foreach (var testFile in testFiles) + { + var path = Path.Combine(TEST_ARCHIVES_PATH, testFile); + + var readerKeys = new List(); + using (var stream = File.OpenRead(path)) + using (var reader = ZipReader.Open(stream)) + { + while (reader.MoveToNextEntry()) + { + readerKeys.Add(reader.Entry.Key!); + } + } + + var archiveKeys = new List(); + using (var archive = Archives.Zip.ZipArchive.Open(path)) + { + foreach (var entry in archive.Entries) + { + archiveKeys.Add(entry.Key!); + } + } + + Assert.Equal(archiveKeys.Count, readerKeys.Count); + Assert.Equal(archiveKeys.OrderBy(k => k), readerKeys.OrderBy(k => k)); + } + } } diff --git a/tests/SharpCompress.Test/Zip/ZipWriterTests.cs b/tests/SharpCompress.Test/Zip/ZipWriterTests.cs index b05913e95..82e7caa2f 100644 --- a/tests/SharpCompress.Test/Zip/ZipWriterTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipWriterTests.cs @@ -1,5 +1,7 @@ +using System.IO; using System.Text; using SharpCompress.Common; +using SharpCompress.Writers; using Xunit; namespace SharpCompress.Test.Zip; @@ -9,6 +11,42 @@ public class ZipWriterTests : WriterTests public ZipWriterTests() : base(ArchiveType.Zip) { } + [Fact] + public void Zip_BZip2_Write_EmptyFile() + { + // Test that writing an empty file with BZip2 compression doesn't throw DivideByZeroException + using var memoryStream = new MemoryStream(); + var options = new WriterOptions(CompressionType.BZip2) + { + ArchiveEncoding = new ArchiveEncoding { Default = new UTF8Encoding(false) }, + }; + + using (var writer = WriterFactory.Open(memoryStream, ArchiveType.Zip, options)) + { + writer.Write("test-folder/zero-byte-file.txt", Stream.Null); + } + + Assert.True(memoryStream.Length > 0); + } + + [Fact] + public void Zip_BZip2_Write_EmptyFolder() + { + // Test that writing an empty folder entry with BZip2 compression doesn't throw DivideByZeroException + using var memoryStream = new MemoryStream(); + var options = new WriterOptions(CompressionType.BZip2) + { + ArchiveEncoding = new ArchiveEncoding { Default = new UTF8Encoding(false) }, + }; + + using (var writer = WriterFactory.Open(memoryStream, ArchiveType.Zip, options)) + { + writer.Write("test-empty-folder/", Stream.Null); + } + + Assert.True(memoryStream.Length > 0); + } + [Fact] public void Zip_Deflate_Write() => Write( diff --git a/tests/SharpCompress.Test/packages.lock.json b/tests/SharpCompress.Test/packages.lock.json index 90c5ba117..7f87d400f 100644 --- a/tests/SharpCompress.Test/packages.lock.json +++ b/tests/SharpCompress.Test/packages.lock.json @@ -13,11 +13,11 @@ }, "Microsoft.NET.Test.Sdk": { "type": "Direct", - "requested": "[18.0.0, )", - "resolved": "18.0.0", - "contentHash": "bvxj2Asb7nT+tqOFFerrhQeEjUYLwx0Poi0Rznu63WbqN+A4uDn1t5NWXfAOOQsF6lpmK6N2v+Vvgso7KWZS7g==", + "requested": "[18.0.1, )", + "resolved": "18.0.1", + "contentHash": "WNpu6vI2rA0pXY4r7NKxCN16XRWl5uHu6qjuyVLoDo6oYEggIQefrMjkRuibQHm/NslIUNCcKftvoWAN80MSAg==", "dependencies": { - "Microsoft.CodeCoverage": "18.0.0" + "Microsoft.CodeCoverage": "18.0.1" } }, "Microsoft.NETFramework.ReferenceAssemblies": { @@ -29,6 +29,12 @@ "Microsoft.NETFramework.ReferenceAssemblies.net48": "1.0.3" } }, + "Mono.Posix.NETStandard": { + "type": "Direct", + "requested": "[1.0.0, )", + "resolved": "1.0.0", + "contentHash": "vSN/L1uaVwKsiLa95bYu2SGkF0iY3xMblTfxc8alSziPuVfJpj3geVqHGAA75J7cZkMuKpFVikz82Lo6y6LLdA==" + }, "xunit": { "type": "Direct", "requested": "[2.9.3, )", @@ -51,8 +57,8 @@ }, "Microsoft.CodeCoverage": { "type": "Transitive", - "resolved": "18.0.0", - "contentHash": "DFPhMrsIofgJ1DDU3ModqqRArDm15/bNl4ecmcuBspZkZ4ONYnCC0R8U27WzK7cYv6r8l6Q/fRmvg7cb+I/dJA==" + "resolved": "18.0.1", + "contentHash": "O+utSr97NAJowIQT/OVp3Lh9QgW/wALVTP4RG1m2AfFP4IyJmJz0ZBmFJUsRQiAPgq6IRC0t8AAzsiPIsaUDEA==" }, "Microsoft.NETFramework.ReferenceAssemblies.net48": { "type": "Transitive", @@ -92,12 +98,17 @@ }, "System.Threading.Tasks.Extensions": { "type": "Transitive", - "resolved": "4.5.4", - "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", "dependencies": { - "System.Runtime.CompilerServices.Unsafe": "4.5.3" + "System.Runtime.CompilerServices.Unsafe": "6.1.2" } }, + "System.ValueTuple": { + "type": "Transitive", + "resolved": "4.6.1", + "contentHash": "+RJT4qaekpZ7DDLhf+LTjq+E48jieKiY9ulJ+BoxKmZblIJfIJT8Ufcaa/clQqnYvWs8jugfGSMu8ylS0caG0w==" + }, "xunit.abstractions": { "type": "Transitive", "resolved": "2.0.3", @@ -141,20 +152,19 @@ "sharpcompress": { "type": "Project", "dependencies": { - "Microsoft.Bcl.AsyncInterfaces": "[8.0.0, )", + "Microsoft.Bcl.AsyncInterfaces": "[10.0.0, )", "System.Buffers": "[4.6.1, )", "System.Memory": "[4.6.3, )", - "System.Text.Encoding.CodePages": "[8.0.0, )", - "ZstdSharp.Port": "[0.8.6, )" + "System.Text.Encoding.CodePages": "[10.0.0, )" } }, "Microsoft.Bcl.AsyncInterfaces": { "type": "CentralTransitive", - "requested": "[8.0.0, )", - "resolved": "8.0.0", - "contentHash": "3WA9q9yVqJp222P3x1wYIGDAkpjAku0TMUaaQV22g6L67AI0LdOIrVS7Ht2vJfLHGSPVuqN94vIr15qn+HEkHw==", + "requested": "[10.0.0, )", + "resolved": "10.0.0", + "contentHash": "vFuwSLj9QJBbNR0NeNO4YVASUbokxs+i/xbuu8B+Fs4FAZg5QaFa6eGrMaRqTzzNI5tAb97T7BhSxtLckFyiRA==", "dependencies": { - "System.Threading.Tasks.Extensions": "4.5.4" + "System.Threading.Tasks.Extensions": "4.6.3" } }, "System.Buffers": { @@ -176,27 +186,17 @@ }, "System.Text.Encoding.CodePages": { "type": "CentralTransitive", - "requested": "[8.0.0, )", - "resolved": "8.0.0", - "contentHash": "OZIsVplFGaVY90G2SbpgU7EnCoOO5pw1t4ic21dBF3/1omrJFpAGoNAVpPyMVOC90/hvgkGG3VFqR13YgZMQfg==", - "dependencies": { - "System.Memory": "4.5.5", - "System.Runtime.CompilerServices.Unsafe": "6.0.0" - } - }, - "ZstdSharp.Port": { - "type": "CentralTransitive", - "requested": "[0.8.6, )", - "resolved": "0.8.6", - "contentHash": "iP4jVLQoQmUjMU88g1WObiNr6YKZGvh4aOXn3yOJsHqZsflwRsxZPcIBvNXgjXO3vQKSLctXGLTpcBPLnWPS8A==", + "requested": "[10.0.0, )", + "resolved": "10.0.0", + "contentHash": "QLP54mIATaBpjGlsZIxga38VPk1G9js0Kw651B+bvrXi2kSgGZYrxJSpM3whhTZCBK4HEBHX3fzfDQMw7CXHGQ==", "dependencies": { - "Microsoft.Bcl.AsyncInterfaces": "5.0.0", - "System.Memory": "4.5.5", - "System.Runtime.CompilerServices.Unsafe": "6.0.0" + "System.Memory": "4.6.3", + "System.Runtime.CompilerServices.Unsafe": "6.1.2", + "System.ValueTuple": "4.6.1" } } }, - "net8.0": { + "net10.0": { "AwesomeAssertions": { "type": "Direct", "requested": "[9.3.0, )", @@ -205,12 +205,12 @@ }, "Microsoft.NET.Test.Sdk": { "type": "Direct", - "requested": "[18.0.0, )", - "resolved": "18.0.0", - "contentHash": "bvxj2Asb7nT+tqOFFerrhQeEjUYLwx0Poi0Rznu63WbqN+A4uDn1t5NWXfAOOQsF6lpmK6N2v+Vvgso7KWZS7g==", + "requested": "[18.0.1, )", + "resolved": "18.0.1", + "contentHash": "WNpu6vI2rA0pXY4r7NKxCN16XRWl5uHu6qjuyVLoDo6oYEggIQefrMjkRuibQHm/NslIUNCcKftvoWAN80MSAg==", "dependencies": { - "Microsoft.CodeCoverage": "18.0.0", - "Microsoft.TestPlatform.TestHost": "18.0.0" + "Microsoft.CodeCoverage": "18.0.1", + "Microsoft.TestPlatform.TestHost": "18.0.1" } }, "Microsoft.NETFramework.ReferenceAssemblies": { @@ -247,8 +247,8 @@ }, "Microsoft.CodeCoverage": { "type": "Transitive", - "resolved": "18.0.0", - "contentHash": "DFPhMrsIofgJ1DDU3ModqqRArDm15/bNl4ecmcuBspZkZ4ONYnCC0R8U27WzK7cYv6r8l6Q/fRmvg7cb+I/dJA==" + "resolved": "18.0.1", + "contentHash": "O+utSr97NAJowIQT/OVp3Lh9QgW/wALVTP4RG1m2AfFP4IyJmJz0ZBmFJUsRQiAPgq6IRC0t8AAzsiPIsaUDEA==" }, "Microsoft.NETFramework.ReferenceAssemblies.net461": { "type": "Transitive", @@ -257,18 +257,15 @@ }, "Microsoft.TestPlatform.ObjectModel": { "type": "Transitive", - "resolved": "18.0.0", - "contentHash": "Al/a99ymb8UdEEh6DKNiaoFn5i8fvX5PdM9LfU9Z/Q8NJrlyHHzF+LRHLbR+t89gRsJ2fFMpwYxgEn3eH1BQwA==", - "dependencies": { - "System.Reflection.Metadata": "8.0.0" - } + "resolved": "18.0.1", + "contentHash": "qT/mwMcLF9BieRkzOBPL2qCopl8hQu6A1P7JWAoj/FMu5i9vds/7cjbJ/LLtaiwWevWLAeD5v5wjQJ/l6jvhWQ==" }, "Microsoft.TestPlatform.TestHost": { "type": "Transitive", - "resolved": "18.0.0", - "contentHash": "aAxE8Thr9ZHGrljOYaDeLJqitQi75iE4xeEFn6CEGFirlHSn1KwpKPniuEn6zCLZ90Z3XqNlrC3ZJTuvBov45w==", + "resolved": "18.0.1", + "contentHash": "uDJKAEjFTaa2wHdWlfo6ektyoh+WD4/Eesrwb4FpBFKsLGehhACVnwwTI4qD3FrIlIEPlxdXg3SyrYRIcO+RRQ==", "dependencies": { - "Microsoft.TestPlatform.ObjectModel": "18.0.0", + "Microsoft.TestPlatform.ObjectModel": "18.0.1", "Newtonsoft.Json": "13.0.3" } }, @@ -277,19 +274,6 @@ "resolved": "13.0.3", "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ==" }, - "System.Collections.Immutable": { - "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "AurL6Y5BA1WotzlEvVaIDpqzpIPvYnnldxru8oXJU2yFxFUy3+pNXjXd1ymO+RA0rq0+590Q8gaz2l3Sr7fmqg==" - }, - "System.Reflection.Metadata": { - "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "ptvgrFh7PvWI8bcVqG5rsA/weWM09EnthFHR5SCnS6IN+P4mj6rE1lBDC4U8HL9/57htKAqy4KQ3bBj84cfYyQ==", - "dependencies": { - "System.Collections.Immutable": "8.0.0" - } - }, "xunit.abstractions": { "type": "Transitive", "resolved": "2.0.3", @@ -331,16 +315,7 @@ } }, "sharpcompress": { - "type": "Project", - "dependencies": { - "ZstdSharp.Port": "[0.8.6, )" - } - }, - "ZstdSharp.Port": { - "type": "CentralTransitive", - "requested": "[0.8.6, )", - "resolved": "0.8.6", - "contentHash": "iP4jVLQoQmUjMU88g1WObiNr6YKZGvh4aOXn3yOJsHqZsflwRsxZPcIBvNXgjXO3vQKSLctXGLTpcBPLnWPS8A==" + "type": "Project" } } } diff --git a/tests/TestArchives/Archives/7Zip.encryptedFiles.7z b/tests/TestArchives/Archives/7Zip.encryptedFiles.7z new file mode 100644 index 0000000000000000000000000000000000000000..4c15bb2cf8e5407ddc147ffe1c4776c9895253e9 GIT binary patch literal 59042 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%0DoM)A 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 vOQ%qFDZl^#7Y4w9uaO01SaL3IWk=QcnN?;1-=d literal 0 HcmV?d00001 diff --git a/tests/TestArchives/Archives/Ace.encrypted.ace b/tests/TestArchives/Archives/Ace.encrypted.ace new file mode 100644 index 0000000000000000000000000000000000000000..d0b86b4ad4c567ce132d36537ff8ae4732bbbdc6 GIT binary patch literal 60234 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 literal 0 HcmV?d00001 diff --git a/tests/TestArchives/Archives/Ace.method1.ace b/tests/TestArchives/Archives/Ace.method1.ace new file mode 100644 index 0000000000000000000000000000000000000000..5a8abc30f4d96200ab9016d63c0154ae6442918c GIT binary patch literal 60290 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

    (+-t1Uy$4|8Y$pJB^BDjgv%IjR;wh6%t7{U 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≥{_-P;s+$1AvgIg)AHMbzdu{3J_}>P6E}xm8*KQv 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 literal 0 HcmV?d00001 diff --git a/tests/TestArchives/Archives/Ace.method2.ace b/tests/TestArchives/Archives/Ace.method2.ace new file mode 100644 index 0000000000000000000000000000000000000000..7d093e97ee993ce6766269b0938a853655636c6e GIT binary patch literal 60238 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≥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 K3(-zGB|=4 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 SCHR~Fw+8C)_|@}g|M)M&sH9*3 literal 0 HcmV?d00001 diff --git a/tests/TestArchives/Archives/Ace.store.split.ace b/tests/TestArchives/Archives/Ace.store.split.ace new file mode 100644 index 0000000000000000000000000000000000000000..df3e52554317f816f7cfab2aaf6e3236baba9f09 GIT binary patch literal 65600 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 zⓈ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

    $O#2ZwdhHme9*4iYkKVDvBE;8}@g( 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 literal 0 HcmV?d00001 diff --git a/tests/TestArchives/Archives/Ace.store.split.c00 b/tests/TestArchives/Archives/Ace.store.split.c00 new file mode 100644 index 0000000000000000000000000000000000000000..4f1d89a44e35651ea5d3d3d717ca8137c4e366c0 GIT binary patch literal 35692 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 S#a~W^ Date: Tue, 6 Jan 2026 13:36:21 +0000 Subject: [PATCH 9/9] Remove foo.zip and add Zip.sozip.zip test archive with tests Co-authored-by: adamhathcock <527620+adamhathcock@users.noreply.github.com> --- .../Zip/SOZipReaderTests.cs | 106 ++++++++++++++++++ .../Zip/SoZipWriterTests.cs | 66 +++++++++++ tests/TestArchives/Archives/Zip.sozip.zip | Bin 0 -> 428 bytes tests/TestArchives/Archives/foo.zip | Bin 204 -> 0 bytes 4 files changed, 172 insertions(+) create mode 100644 tests/TestArchives/Archives/Zip.sozip.zip delete mode 100644 tests/TestArchives/Archives/foo.zip diff --git a/tests/SharpCompress.Test/Zip/SOZipReaderTests.cs b/tests/SharpCompress.Test/Zip/SOZipReaderTests.cs index d94aa3df6..30bbbf277 100644 --- a/tests/SharpCompress.Test/Zip/SOZipReaderTests.cs +++ b/tests/SharpCompress.Test/Zip/SOZipReaderTests.cs @@ -51,6 +51,112 @@ public void SOZip_Archive_RegularZip_NoSozipEntries() } } + [Fact] + public void SOZip_Archive_ReadSOZipFile() + { + // Read the SOZip test archive + var path = Path.Combine(TEST_ARCHIVES_PATH, "Zip.sozip.zip"); + using Stream stream = File.OpenRead(path); + using var archive = ZipArchive.Open(stream); + + var entries = archive.Entries.ToList(); + + // Should have 3 entries: data.txt, .data.txt.sozip.idx, and small.txt + Assert.Equal(3, entries.Count); + + // Verify we have one SOZip index file + var indexFiles = entries.Where(e => e.IsSozipIndexFile).ToList(); + Assert.Single(indexFiles); + Assert.Equal(".data.txt.sozip.idx", indexFiles[0].Key); + + // Verify the index file is not compressed + Assert.Equal(CompressionType.None, indexFiles[0].CompressionType); + + // Read and validate the index + using (var indexStream = indexFiles[0].OpenEntryStream()) + { + using var memStream = new MemoryStream(); + indexStream.CopyTo(memStream); + var indexBytes = memStream.ToArray(); + + var index = SOZipIndex.Read(indexBytes); + Assert.Equal(SOZipIndex.SOZIP_VERSION, index.Version); + Assert.Equal(1024u, index.ChunkSize); // As set in CreateSOZipTestArchive + Assert.True(index.UncompressedSize > 0); + Assert.True(index.OffsetCount > 0); + } + + // Verify the data file can be read correctly + var dataEntry = entries.First(e => e.Key == "data.txt"); + using (var dataStream = dataEntry.OpenEntryStream()) + { + using var reader = new StreamReader(dataStream); + var content = reader.ReadToEnd(); + Assert.Equal(5000, content.Length); + Assert.True(content.All(c => c == 'A')); + } + + // Verify the small file + var smallEntry = entries.First(e => e.Key == "small.txt"); + Assert.False(smallEntry.IsSozipIndexFile); + using (var smallStream = smallEntry.OpenEntryStream()) + { + using var reader = new StreamReader(smallStream); + var content = reader.ReadToEnd(); + Assert.Equal("Small content", content); + } + } + + [Fact] + public async Task SOZip_Reader_ReadSOZipFile() + { + // Read the SOZip test archive with ZipReader + var path = Path.Combine(TEST_ARCHIVES_PATH, "Zip.sozip.zip"); + using Stream stream = new ForwardOnlyStream(File.OpenRead(path)); + using var reader = ZipReader.Open(stream); + + var foundData = false; + var foundIndex = false; + var foundSmall = false; + + while (await reader.MoveToNextEntryAsync()) + { + if (reader.Entry.Key == "data.txt") + { + foundData = true; + Assert.False(reader.Entry.IsSozipIndexFile); + + using var entryStream = reader.OpenEntryStream(); + using var streamReader = new StreamReader(entryStream); + var content = streamReader.ReadToEnd(); + Assert.Equal(5000, content.Length); + Assert.True(content.All(c => c == 'A')); + } + else if (reader.Entry.Key == ".data.txt.sozip.idx") + { + foundIndex = true; + Assert.True(reader.Entry.IsSozipIndexFile); + + using var indexStream = reader.OpenEntryStream(); + using var memStream = new MemoryStream(); + await indexStream.CopyToAsync(memStream); + var indexBytes = memStream.ToArray(); + + var index = SOZipIndex.Read(indexBytes); + Assert.Equal(SOZipIndex.SOZIP_VERSION, index.Version); + } + else if (reader.Entry.Key == "small.txt") + { + foundSmall = true; + Assert.False(reader.Entry.IsSozipIndexFile); + } + } + + Assert.True(foundData, "data.txt entry not found"); + Assert.True(foundIndex, ".data.txt.sozip.idx entry not found"); + Assert.True(foundSmall, "small.txt entry not found"); + } + [Fact] public void SOZip_Archive_DetectsIndexFileByName() { diff --git a/tests/SharpCompress.Test/Zip/SoZipWriterTests.cs b/tests/SharpCompress.Test/Zip/SoZipWriterTests.cs index 42b9a314a..1098228d0 100644 --- a/tests/SharpCompress.Test/Zip/SoZipWriterTests.cs +++ b/tests/SharpCompress.Test/Zip/SoZipWriterTests.cs @@ -289,4 +289,70 @@ public void SOZip_RoundTrip_CompressAndDecompress() // Verify extracted files match originals VerifyFiles(true); } + + [Fact] + public void CreateSOZipTestArchive() + { + // Create a SOZip test archive that can be committed to the repository + var archivePath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.sozip.zip"); + + using (var stream = File.Create(archivePath)) + { + var options = new ZipWriterOptions(CompressionType.Deflate) + { + EnableSOZip = true, + SOZipMinFileSize = 100, // Low threshold to ensure test content is optimized + SOZipChunkSize = 1024, // Small chunks for testing + LeaveStreamOpen = false, + }; + + using var writer = new ZipWriter(stream, options); + + // Create test content that's large enough to create multiple chunks + var largeContent = new string('A', 5000); // 5KB of 'A's + + // Write a file with enough data to be SOZip-optimized + writer.Write( + "data.txt", + new MemoryStream(Encoding.UTF8.GetBytes(largeContent)), + new ZipWriterEntryOptions() + ); + + // Write a smaller file that won't be SOZip-optimized + writer.Write( + "small.txt", + new MemoryStream(Encoding.UTF8.GetBytes("Small content")), + new ZipWriterEntryOptions() + ); + } + + // Validate the archive was created + Assert.True(File.Exists(archivePath)); + + // Validate it's a valid SOZip archive + using (var stream = File.OpenRead(archivePath)) + { + using var archive = ZipArchive.Open(stream); + var entries = archive.Entries.ToList(); + + // Should have data file, small file, and index file + Assert.Equal(3, entries.Count); + + // Verify we have one SOZip index file + var indexFiles = entries.Where(e => e.IsSozipIndexFile).ToList(); + Assert.Single(indexFiles); + + // Verify the index file + var indexEntry = indexFiles.First(); + Assert.Equal(".data.txt.sozip.idx", indexEntry.Key); + + // Verify the data file can be read + var dataEntry = entries.First(e => e.Key == "data.txt"); + using var dataStream = dataEntry.OpenEntryStream(); + using var reader = new StreamReader(dataStream); + var content = reader.ReadToEnd(); + Assert.Equal(5000, content.Length); + Assert.True(content.All(c => c == 'A')); + } + } } diff --git a/tests/TestArchives/Archives/Zip.sozip.zip b/tests/TestArchives/Archives/Zip.sozip.zip new file mode 100644 index 0000000000000000000000000000000000000000..e5b1b8fe2aac89dd75371d510fb635c90c080acb GIT binary patch literal 428 zcmWIWW@Zs#U|`^2D9cfc*;g$kEDq##2!liz7*Y~T67@&e=X}qc4D>j6Ufc7mHX}oTHzSh>1419V zPvKTKf>7CKeAP41feMx^oc*YyvXjjt}r=Wdlhu1K~O#{Q|^c F0081FOU?iQ literal 0 HcmV?d00001 diff --git a/tests/TestArchives/Archives/foo.zip b/tests/TestArchives/Archives/foo.zip deleted file mode 100644 index fb80a9225027dde15df2cfec6b050d29b55f31e0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 204 zcmWIWW@Zs#U|`^2SW&AQrkGmXBLL(vLvdPuzSn7XAm{&oFacx-Ks7LcHRPQ57p4J} z0%1NN)&uI$E6%UVEYQnLsbB<(fB+K^a{w{OSP%eN0Rp@b3TP%HPzi2lK$Sr$pcMh$ QtZX12BM=$_=~l2503FU8ZU6uP