Ported zstd v1.5.7

Author: oleg-st

src/Zstd.Extern/x64/libzstd.dll

@@ -1,8 +1,5 @@
 namespace ZstdSharp.Unsafe
 {
-    /*-******************************************
-     *  bitStream encoding API (write forward)
-     ********************************************/
     /* 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.

src/Zstd.Extern/x86/libzstd.dll

@@ -1,5 +1,8 @@
 namespace ZstdSharp.Unsafe
 {
+    /*-********************************************
+     *  bitStream decoding API (read backward)
+     **********************************************/
     public unsafe struct BIT_DStream_t
     {
         public nuint bitContainer;

src/ZstdSharp/Unsafe/BIT_CStream_t.cs

@@ -158,7 +158,7 @@ private static nuint BIT_closeCStream(BIT_CStream_t* bitC)
             BIT_flushBits(bitC);
             if (bitC->ptr >= bitC->endPtr)
                 return 0;
-            return (nuint)(bitC->ptr - bitC->startPtr + (bitC->bitPos > 0 ? 1 : 0));
+            return (nuint)(bitC->ptr - bitC->startPtr) + (nuint)(bitC->bitPos > 0 ? 1 : 0);
         }
 
         /*-********************************************************

src/ZstdSharp/Unsafe/BIT_DStream_t.cs

@@ -0,0 +1,9 @@
+namespace ZstdSharp.Unsafe
+{
+    public struct BlockSummary
+    {
+        public nuint nbSequences;
+        public nuint blockSize;
+        public nuint litSize;
+    }
+}

src/ZstdSharp/Unsafe/Bitstream.cs

@@ -4,8 +4,16 @@ namespace ZstdSharp.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 trigging
+         * Helper function to perform a wrapped pointer difference without triggering
          * UBSAN.
          *
          * @returns lhs - rhs with wrapping

src/ZstdSharp/Unsafe/BlockSummary.cs

@@ -70,6 +70,8 @@ private static string ERR_getErrorString(ZSTD_ErrorCode code)
                     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:

src/ZstdSharp/Unsafe/Compiler.cs

@@ -0,0 +1,8 @@
+namespace ZstdSharp.Unsafe
+{
+    public struct FPStats
+    {
+        public Fingerprint pastEvents;
+        public Fingerprint newEvents;
+    }
+}

src/ZstdSharp/Unsafe/ErrorPrivate.cs

@@ -0,0 +1,8 @@
+namespace ZstdSharp.Unsafe
+{
+    public unsafe struct Fingerprint
+    {
+        public fixed uint events[1024];
+        public nuint nbEvents;
+    }
+}

src/ZstdSharp/Unsafe/FPStats.cs

@@ -152,6 +152,11 @@ private static nuint FSE_decompress_usingDTable_generic(void* dst, nuint maxDstS
 
             FSE_initDState(&state1, &bitD, dt);
             FSE_initDState(&state2, &bitD, dt);
+            if (BIT_reloadDStream(&bitD) == BIT_DStream_status.BIT_DStream_overflow)
+            {
+                return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected));
+            }
+
             for (; BIT_reloadDStream(&bitD) == BIT_DStream_status.BIT_DStream_unfinished && op < olimit; op += 4)
             {
                 op[0] = fast != 0 ? FSE_decodeSymbolFast(&state1, &bitD) : FSE_decodeSymbol(&state1, &bitD);

src/ZstdSharp/Unsafe/Fingerprint.cs

@@ -7,7 +7,6 @@ public struct HUF_DEltX1
     {
         /* single-symbol decoding */
         public byte nbBits;
-        /* single-symbol decoding */
         public byte @byte;
     }
 }

src/ZstdSharp/Unsafe/FseDecompress.cs

@@ -7,9 +7,7 @@ public struct HUF_DEltX2
     {
         /* double-symbols decoding */
         public ushort sequence;
-        /* double-symbols decoding */
         public byte nbBits;
-        /* double-symbols decoding */
         public byte length;
     }
 }

src/ZstdSharp/Unsafe/HUF_DEltX1.cs

@@ -13,6 +13,24 @@ private static bool HIST_isError(nuint 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;

src/ZstdSharp/Unsafe/HUF_DEltX2.cs

@@ -1143,7 +1143,7 @@ private static uint HUF_optimalTableLog(uint maxTableLog, nuint srcSize, uint ma
          * 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, (nuint)sizeof(nuint));
+            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;