hg-stable: comparison contrib/python-zstandard/zstd/compress/huf

equal deleted inserted replaced

-:1ce7a55b09d1
+:b1fb341d8a61
 *  Includes
 ****************************************************************/
 #include <string.h>     /* memcpy, memset */
 #include <stdio.h>      /* printf (debug) */
 #include "bitstream.h"
+#include "compiler.h"
 #define FSE_STATIC_LINKING_ONLY   /* FSE_optimalTableLog_internal */
 #include "fse.h"        /* header compression */
 #define HUF_STATIC_LINKING_ONLY
 #include "huf.h"
+#include "error_private.h"
 /* **************************************************************
 *  Error Management
 ****************************************************************/
+#define HUF_isError ERR_isError
 #define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return f
+#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e
 #define CHECK_F(f)   { CHECK_V_F(_var_err__, f); }
 /* **************************************************************
 *  Utils
 U16  val;
 BYTE nbBits;
 };   /* typedef'd to HUF_CElt within "huf.h" */
 /*! HUF_writeCTable() :
-`CTable` : huffman tree to save, using huf representation.
+`CTable` : Huffman tree to save, using huf representation.
 @return : size of saved CTable */
 size_t HUF_writeCTable (void* dst, size_t maxDstSize,
 const HUF_CElt* CTable, U32 maxSymbolValue, U32 huffLog)
 {
 BYTE bitsToWeight[HUF_TABLELOG_MAX + 1];   /* precomputed conversion table */
 op[(n/2)+1] = (BYTE)((huffWeight[n] << 4) + huffWeight[n+1]);
 return ((maxSymbolValue+1)/2) + 1;
 }
-size_t HUF_readCTable (HUF_CElt* CTable, U32 maxSymbolValue, const void* src, size_t srcSize)
+size_t HUF_readCTable (HUF_CElt* CTable, U32* maxSymbolValuePtr, const void* src, size_t srcSize)
 {
 BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1];   /* init not required, even though some static analyzer may complain */
 U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1];   /* large enough for values from 0 to 16 */
 U32 tableLog = 0;
 U32 nbSymbols = 0;
 /* get symbol weights */
 CHECK_V_F(readSize, HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX+1, rankVal, &nbSymbols, &tableLog, src, srcSize));
 /* check result */
 if (tableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
-if (nbSymbols > maxSymbolValue+1) return ERROR(maxSymbolValue_tooSmall);
+if (nbSymbols > *maxSymbolValuePtr+1) return ERROR(maxSymbolValue_tooSmall);
 /* Prepare base value per rank */
 {   U32 n, nextRankStart = 0;
 for (n=1; n<=tableLog; n++) {
 U32 current = nextRankStart;
 valPerRank[n] = min;     /* get starting value within each rank */
 min += nbPerRank[n];
 min >>= 1;
 }   }
 /* assign value within rank, symbol order */
-{ U32 n; for (n=0; n<=maxSymbolValue; n++) CTable[n].val = valPerRank[CTable[n].nbBits]++; }
+{ U32 n; for (n=0; n<nbSymbols; n++) CTable[n].val = valPerRank[CTable[n].nbBits]++; }
 }
+*maxSymbolValuePtr = nbSymbols - 1;
 return readSize;
 }
 typedef struct nodeElt_s {
 {   U32 const highTotal = huffNode[highPos].count;
 U32 const lowTotal = 2 * huffNode[lowPos].count;
 if (highTotal <= lowTotal) break;
 }   }
 /* only triggered when no more rank 1 symbol left => find closest one (note : there is necessarily at least one !) */
-while ((nBitsToDecrease<=HUF_TABLELOG_MAX) && (rankLast[nBitsToDecrease] == noSymbol))  /* HUF_MAX_TABLELOG test just to please gcc 5+; but it should not be necessary */
+/* HUF_MAX_TABLELOG test just to please gcc 5+; but it should not be necessary */
+while ((nBitsToDecrease<=HUF_TABLELOG_MAX) && (rankLast[nBitsToDecrease] == noSymbol))
 nBitsToDecrease ++;
 totalCost -= 1 << (nBitsToDecrease-1);
 if (rankLast[nBitsToDecrease-1] == noSymbol)
 rankLast[nBitsToDecrease-1] = rankLast[nBitsToDecrease];   /* this rank is no longer empty */
 huffNode[rankLast[nBitsToDecrease]].nbBits ++;
 for (n=0; n<32; n++) rank[n].current = rank[n].base;
 for (n=0; n<=maxSymbolValue; n++) {
 U32 const c = count[n];
 U32 const r = BIT_highbit32(c+1) + 1;
 U32 pos = rank[r].current++;
-while ((pos > rank[r].base) && (c > huffNode[pos-1].count)) huffNode[pos]=huffNode[pos-1], pos--;
+while ((pos > rank[r].base) && (c > huffNode[pos-1].count)) {
+huffNode[pos] = huffNode[pos-1];
+pos--;
+}
 huffNode[pos].count = c;
 huffNode[pos].byte  = (BYTE)n;
 }
 }
 /** HUF_buildCTable_wksp() :
 *  Same as HUF_buildCTable(), but using externally allocated scratch buffer.
-*  `workSpace` must be aligned on 4-bytes boundaries, and be at least as large as a table of 1024 unsigned.
+*  `workSpace` must be aligned on 4-bytes boundaries, and be at least as large as a table of HUF_CTABLE_WORKSPACE_SIZE_U32 unsigned.
 */
 #define STARTNODE (HUF_SYMBOLVALUE_MAX+1)
-typedef nodeElt huffNodeTable[2*HUF_SYMBOLVALUE_MAX+1 +1];
+typedef nodeElt huffNodeTable[HUF_CTABLE_WORKSPACE_SIZE_U32];
 size_t HUF_buildCTable_wksp (HUF_CElt* tree, const U32* count, U32 maxSymbolValue, U32 maxNbBits, void* workSpace, size_t wkspSize)
 {
 nodeElt* const huffNode0 = (nodeElt*)workSpace;
 nodeElt* const huffNode = huffNode0+1;
 U32 n, nonNullRank;
 int lowS, lowN;
 U16 nodeNb = STARTNODE;
 U32 nodeRoot;
 /* safety checks */
-if (wkspSize < sizeof(huffNodeTable)) return ERROR(GENERIC);   /* workSpace is not large enough */
+if (((size_t)workSpace & 3) != 0) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */
+if (wkspSize < sizeof(huffNodeTable)) return ERROR(workSpace_tooSmall);
 if (maxNbBits == 0) maxNbBits = HUF_TABLELOG_DEFAULT;
-if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(GENERIC);
+if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
 memset(huffNode0, 0, sizeof(huffNodeTable));
 /* sort, decreasing order */
 HUF_sort(huffNode, count, maxSymbolValue);
 return maxNbBits;
 }
 /** HUF_buildCTable() :
+* @return : maxNbBits
 *  Note : count is used before tree is written, so they can safely overlap
 */
 size_t HUF_buildCTable (HUF_CElt* tree, const U32* count, U32 maxSymbolValue, U32 maxNbBits)
 {
 huffNodeTable nodeTable;
 return HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, nodeTable, sizeof(nodeTable));
 }
-static void HUF_encodeSymbol(BIT_CStream_t* bitCPtr, U32 symbol, const HUF_CElt* CTable)
+static size_t HUF_estimateCompressedSize(HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue)
+{
+size_t nbBits = 0;
+int s;
+for (s = 0; s <= (int)maxSymbolValue; ++s) {
+nbBits += CTable[s].nbBits * count[s];
+}
+return nbBits >> 3;
+}
+static int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue) {
+int bad = 0;
+int s;
+for (s = 0; s <= (int)maxSymbolValue; ++s) {
+bad |= (count[s] != 0) & (CTable[s].nbBits == 0);
+}
+return !bad;
+}
+size_t HUF_compressBound(size_t size) { return HUF_COMPRESSBOUND(size); }
+FORCE_INLINE_TEMPLATE void
+HUF_encodeSymbol(BIT_CStream_t* bitCPtr, U32 symbol, const HUF_CElt* CTable)
 {
 BIT_addBitsFast(bitCPtr, CTable[symbol].val, CTable[symbol].nbBits);
 }
-size_t HUF_compressBound(size_t size) { return HUF_COMPRESSBOUND(size); }
+#define HUF_FLUSHBITS(s)  BIT_flushBits(s)
-#define HUF_FLUSHBITS(s)  (fast ? BIT_flushBitsFast(s) : BIT_flushBits(s))
 #define HUF_FLUSHBITS_1(stream) \
 if (sizeof((stream)->bitContainer)*8 < HUF_TABLELOG_MAX*2+7) HUF_FLUSHBITS(stream)
 #define HUF_FLUSHBITS_2(stream) \
 if (sizeof((stream)->bitContainer)*8 < HUF_TABLELOG_MAX*4+7) HUF_FLUSHBITS(stream)
-size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable)
+FORCE_INLINE_TEMPLATE size_t
+HUF_compress1X_usingCTable_internal_body(void* dst, size_t dstSize,
+const void* src, size_t srcSize,
+const HUF_CElt* CTable)
 {
 const BYTE* ip = (const BYTE*) src;
 BYTE* const ostart = (BYTE*)dst;
 BYTE* const oend = ostart + dstSize;
 BYTE* op = ostart;
 size_t n;
-const unsigned fast = (dstSize >= HUF_BLOCKBOUND(srcSize));
 BIT_CStream_t bitC;
 /* init */
 if (dstSize < 8) return 0;   /* not enough space to compress */
 { size_t const initErr = BIT_initCStream(&bitC, op, oend-op);
 n = srcSize & ~3;  /* join to mod 4 */
 switch (srcSize & 3)
 {
 case 3 : HUF_encodeSymbol(&bitC, ip[n+ 2], CTable);
 HUF_FLUSHBITS_2(&bitC);
+		 /* fall-through */
 case 2 : HUF_encodeSymbol(&bitC, ip[n+ 1], CTable);
 HUF_FLUSHBITS_1(&bitC);
+		 /* fall-through */
 case 1 : HUF_encodeSymbol(&bitC, ip[n+ 0], CTable);
 HUF_FLUSHBITS(&bitC);
-case 0 :
+		 /* fall-through */
-default: ;
+case 0 : /* fall-through */
+default: break;
 }
 for (; n>0; n-=4) {  /* note : n&3==0 at this stage */
 HUF_encodeSymbol(&bitC, ip[n- 1], CTable);
 HUF_FLUSHBITS_1(&bitC);
 }
 return BIT_closeCStream(&bitC);
 }
+#if DYNAMIC_BMI2
-size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable)
+static TARGET_ATTRIBUTE("bmi2") size_t
+HUF_compress1X_usingCTable_internal_bmi2(void* dst, size_t dstSize,
+const void* src, size_t srcSize,
+const HUF_CElt* CTable)
+{
+return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);
+}
+static size_t
+HUF_compress1X_usingCTable_internal_default(void* dst, size_t dstSize,
+const void* src, size_t srcSize,
+const HUF_CElt* CTable)
+{
+return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);
+}
+static size_t
+HUF_compress1X_usingCTable_internal(void* dst, size_t dstSize,
+const void* src, size_t srcSize,
+const HUF_CElt* CTable, const int bmi2)
+{
+if (bmi2) {
+return HUF_compress1X_usingCTable_internal_bmi2(dst, dstSize, src, srcSize, CTable);
+}
+return HUF_compress1X_usingCTable_internal_default(dst, dstSize, src, srcSize, CTable);
+}
+#else
+static size_t
+HUF_compress1X_usingCTable_internal(void* dst, size_t dstSize,
+const void* src, size_t srcSize,
+const HUF_CElt* CTable, const int bmi2)
+{
+(void)bmi2;
+return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);
+}
+#endif
+size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable)
+{
+return HUF_compress1X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, /* bmi2 */ 0);
+}
+static size_t
+HUF_compress4X_usingCTable_internal(void* dst, size_t dstSize,
+const void* src, size_t srcSize,
+const HUF_CElt* CTable, int bmi2)
 {
 size_t const segmentSize = (srcSize+3)/4;   /* first 3 segments */
 const BYTE* ip = (const BYTE*) src;
 const BYTE* const iend = ip + srcSize;
 BYTE* const ostart = (BYTE*) dst;
 if (dstSize < 6 + 1 + 1 + 1 + 8) return 0;   /* minimum space to compress successfully */
 if (srcSize < 12) return 0;   /* no saving possible : too small input */
 op += 6;   /* jumpTable */
-{   CHECK_V_F(cSize, HUF_compress1X_usingCTable(op, oend-op, ip, segmentSize, CTable) );
+{   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip, segmentSize, CTable, bmi2) );
 if (cSize==0) return 0;
+assert(cSize <= 65535);
 MEM_writeLE16(ostart, (U16)cSize);
 op += cSize;
 }
 ip += segmentSize;
-{   CHECK_V_F(cSize, HUF_compress1X_usingCTable(op, oend-op, ip, segmentSize, CTable) );
+{   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip, segmentSize, CTable, bmi2) );
 if (cSize==0) return 0;
+assert(cSize <= 65535);
 MEM_writeLE16(ostart+2, (U16)cSize);
 op += cSize;
 }
 ip += segmentSize;
-{   CHECK_V_F(cSize, HUF_compress1X_usingCTable(op, oend-op, ip, segmentSize, CTable) );
+{   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip, segmentSize, CTable, bmi2) );
 if (cSize==0) return 0;
+assert(cSize <= 65535);
 MEM_writeLE16(ostart+4, (U16)cSize);
 op += cSize;
 }
 ip += segmentSize;
-{   CHECK_V_F(cSize, HUF_compress1X_usingCTable(op, oend-op, ip, iend-ip, CTable) );
+{   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip, iend-ip, CTable, bmi2) );
 if (cSize==0) return 0;
 op += cSize;
 }
 return op-ostart;
 }
+size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable)
-/* `workSpace` must a table of at least 1024 unsigned */
+{
+return HUF_compress4X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, /* bmi2 */ 0);
+}
+static size_t HUF_compressCTable_internal(
+BYTE* const ostart, BYTE* op, BYTE* const oend,
+const void* src, size_t srcSize,
+unsigned singleStream, const HUF_CElt* CTable, const int bmi2)
+{
+size_t const cSize = singleStream ?
+HUF_compress1X_usingCTable_internal(op, oend - op, src, srcSize, CTable, bmi2) :
+HUF_compress4X_usingCTable_internal(op, oend - op, src, srcSize, CTable, bmi2);
+if (HUF_isError(cSize)) { return cSize; }
+if (cSize==0) { return 0; }   /* uncompressible */
+op += cSize;
+/* check compressibility */
+if ((size_t)(op-ostart) >= srcSize-1) { return 0; }
+return op-ostart;
+}
+typedef struct {
+U32 count[HUF_SYMBOLVALUE_MAX + 1];
+HUF_CElt CTable[HUF_SYMBOLVALUE_MAX + 1];
+huffNodeTable nodeTable;
+} HUF_compress_tables_t;
+/* HUF_compress_internal() :
+* `workSpace` must a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
 static size_t HUF_compress_internal (
 void* dst, size_t dstSize,
 const void* src, size_t srcSize,
 unsigned maxSymbolValue, unsigned huffLog,
 unsigned singleStream,
-void* workSpace, size_t wkspSize)
+void* workSpace, size_t wkspSize,
-{
+HUF_CElt* oldHufTable, HUF_repeat* repeat, int preferRepeat,
+const int bmi2)
+{
+HUF_compress_tables_t* const table = (HUF_compress_tables_t*)workSpace;
 BYTE* const ostart = (BYTE*)dst;
 BYTE* const oend = ostart + dstSize;
 BYTE* op = ostart;
-union {
-U32 count[HUF_SYMBOLVALUE_MAX+1];
-HUF_CElt CTable[HUF_SYMBOLVALUE_MAX+1];
-} table;   /* `count` can overlap with `CTable`; saves 1 KB */
 /* checks & inits */
-if (wkspSize < sizeof(huffNodeTable)) return ERROR(GENERIC);
+if (((size_t)workSpace & 3) != 0) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */
-if (!srcSize) return 0;  /* Uncompressed (note : 1 means rle, so first byte must be correct) */
+if (wkspSize < sizeof(*table)) return ERROR(workSpace_tooSmall);
-if (!dstSize) return 0;  /* cannot fit within dst budget */
+if (!srcSize) return 0;  /* Uncompressed */
+if (!dstSize) return 0;  /* cannot fit anything within dst budget */
 if (srcSize > HUF_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);   /* current block size limit */
 if (huffLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
+if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
 if (!maxSymbolValue) maxSymbolValue = HUF_SYMBOLVALUE_MAX;
 if (!huffLog) huffLog = HUF_TABLELOG_DEFAULT;
+/* Heuristic : If old table is valid, use it for small inputs */
+if (preferRepeat && repeat && *repeat == HUF_repeat_valid) {
+return HUF_compressCTable_internal(ostart, op, oend,
+src, srcSize,
+singleStream, oldHufTable, bmi2);
+}
 /* Scan input and build symbol stats */
-{   CHECK_V_F(largest, FSE_count_wksp (table.count, &maxSymbolValue, (const BYTE*)src, srcSize, (U32*)workSpace) );
+{   CHECK_V_F(largest, FSE_count_wksp (table->count, &maxSymbolValue, (const BYTE*)src, srcSize, table->count) );
 if (largest == srcSize) { *ostart = ((const BYTE*)src)[0]; return 1; }   /* single symbol, rle */
-if (largest <= (srcSize >> 7)+1) return 0;   /* Fast heuristic : not compressible enough */
+if (largest <= (srcSize >> 7)+1) return 0;   /* heuristic : probably not compressible enough */
+}
+/* Check validity of previous table */
+if ( repeat
+&& *repeat == HUF_repeat_check
+&& !HUF_validateCTable(oldHufTable, table->count, maxSymbolValue)) {
+*repeat = HUF_repeat_none;
+}
+/* Heuristic : use existing table for small inputs */
+if (preferRepeat && repeat && *repeat != HUF_repeat_none) {
+return HUF_compressCTable_internal(ostart, op, oend,
+src, srcSize,
+singleStream, oldHufTable, bmi2);
 }
 /* Build Huffman Tree */
 huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue);
-{   CHECK_V_F(maxBits, HUF_buildCTable_wksp (table.CTable, table.count, maxSymbolValue, huffLog, workSpace, wkspSize) );
+{   CHECK_V_F(maxBits, HUF_buildCTable_wksp(table->CTable, table->count,
+maxSymbolValue, huffLog,
+table->nodeTable, sizeof(table->nodeTable)) );
 huffLog = (U32)maxBits;
+/* Zero unused symbols in CTable, so we can check it for validity */
+memset(table->CTable + (maxSymbolValue + 1), 0,
+sizeof(table->CTable) - ((maxSymbolValue + 1) * sizeof(HUF_CElt)));
 }
 /* Write table description header */
-{   CHECK_V_F(hSize, HUF_writeCTable (op, dstSize, table.CTable, maxSymbolValue, huffLog) );
+{   CHECK_V_F(hSize, HUF_writeCTable (op, dstSize, table->CTable, maxSymbolValue, huffLog) );
-if (hSize + 12 >= srcSize) return 0;   /* not useful to try compression */
+/* Check if using previous huffman table is beneficial */
+if (repeat && *repeat != HUF_repeat_none) {
+size_t const oldSize = HUF_estimateCompressedSize(oldHufTable, table->count, maxSymbolValue);
+size_t const newSize = HUF_estimateCompressedSize(table->CTable, table->count, maxSymbolValue);
+if (oldSize <= hSize + newSize || hSize + 12 >= srcSize) {
+return HUF_compressCTable_internal(ostart, op, oend,
+src, srcSize,
+singleStream, oldHufTable, bmi2);
+}   }
+/* Use the new huffman table */
+if (hSize + 12ul >= srcSize) { return 0; }
 op += hSize;
-}
+if (repeat) { *repeat = HUF_repeat_none; }
+if (oldHufTable)
-/* Compress */
+memcpy(oldHufTable, table->CTable, sizeof(table->CTable));  /* Save new table */
-{   size_t const cSize = (singleStream) ?
+}
-HUF_compress1X_usingCTable(op, oend - op, src, srcSize, table.CTable) :   /* single segment */
+return HUF_compressCTable_internal(ostart, op, oend,
-HUF_compress4X_usingCTable(op, oend - op, src, srcSize, table.CTable);
+src, srcSize,
-if (HUF_isError(cSize)) return cSize;
+singleStream, table->CTable, bmi2);
-if (cSize==0) return 0;   /* uncompressible */
-op += cSize;
-}
-/* check compressibility */
-if ((size_t)(op-ostart) >= srcSize-1)
-return 0;
-return op-ostart;
 }
 size_t HUF_compress1X_wksp (void* dst, size_t dstSize,
 const void* src, size_t srcSize,
 unsigned maxSymbolValue, unsigned huffLog,
 void* workSpace, size_t wkspSize)
 {
-return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 1 /* single stream */, workSpace, wkspSize);
+return HUF_compress_internal(dst, dstSize, src, srcSize,
+maxSymbolValue, huffLog, 1 /*single stream*/,
+workSpace, wkspSize,
+NULL, NULL, 0, 0 /*bmi2*/);
+}
+size_t HUF_compress1X_repeat (void* dst, size_t dstSize,
+const void* src, size_t srcSize,
+unsigned maxSymbolValue, unsigned huffLog,
+void* workSpace, size_t wkspSize,
+HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2)
+{
+return HUF_compress_internal(dst, dstSize, src, srcSize,
+maxSymbolValue, huffLog, 1 /*single stream*/,
+workSpace, wkspSize, hufTable,
+repeat, preferRepeat, bmi2);
 }
 size_t HUF_compress1X (void* dst, size_t dstSize,
 const void* src, size_t srcSize,
 unsigned maxSymbolValue, unsigned huffLog)
 {
-unsigned workSpace[1024];
+unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
 return HUF_compress1X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
 }
+/* HUF_compress4X_repeat():
+* compress input using 4 streams.
+* provide workspace to generate compression tables */
 size_t HUF_compress4X_wksp (void* dst, size_t dstSize,
 const void* src, size_t srcSize,
 unsigned maxSymbolValue, unsigned huffLog,
 void* workSpace, size_t wkspSize)
 {
-return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 0 /* 4 streams */, workSpace, wkspSize);
+return HUF_compress_internal(dst, dstSize, src, srcSize,
+maxSymbolValue, huffLog, 0 /*4 streams*/,
+workSpace, wkspSize,
+NULL, NULL, 0, 0 /*bmi2*/);
+}
+/* HUF_compress4X_repeat():
+* compress input using 4 streams.
+* re-use an existing huffman compression table */
+size_t HUF_compress4X_repeat (void* dst, size_t dstSize,
+const void* src, size_t srcSize,
+unsigned maxSymbolValue, unsigned huffLog,
+void* workSpace, size_t wkspSize,
+HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2)
+{
+return HUF_compress_internal(dst, dstSize, src, srcSize,
+maxSymbolValue, huffLog, 0 /* 4 streams */,
+workSpace, wkspSize,
+hufTable, repeat, preferRepeat, bmi2);
 }
 size_t HUF_compress2 (void* dst, size_t dstSize,
 const void* src, size_t srcSize,
 unsigned maxSymbolValue, unsigned huffLog)
 {
-unsigned workSpace[1024];
+unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
 return HUF_compress4X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
 }
 size_t HUF_compress (void* dst, size_t maxDstSize, const void* src, size_t srcSize)
 {
-return HUF_compress2(dst, maxDstSize, src, (U32)srcSize, 255, HUF_TABLELOG_DEFAULT);
+return HUF_compress2(dst, maxDstSize, src, srcSize, 255, HUF_TABLELOG_DEFAULT);
 }

changeset 37495	b1fb341d8a61
parent 30822	b54a2984cdd4
child 40122	73fef626dae3