Fix merge conflicts
This commit is contained in:
Sen Huang
parent
73f8905b83
commit
7ce891870c
@ -372,6 +372,10 @@
|
|||||||
RelativePath="..\..\..\lib\compress\zstd_compress_sequences.c"
|
RelativePath="..\..\..\lib\compress\zstd_compress_sequences.c"
|
||||||
>
|
>
|
||||||
</File>
|
</File>
|
||||||
|
<File
|
||||||
|
RelativePath="..\..\..\lib\compress\zstd_compress_superblock.c"
|
||||||
|
>
|
||||||
|
</File>
|
||||||
<File
|
<File
|
||||||
RelativePath="..\..\..\lib\compress\zstdmt_compress.c"
|
RelativePath="..\..\..\lib\compress\zstdmt_compress.c"
|
||||||
>
|
>
|
||||||
@ -514,6 +518,10 @@
|
|||||||
RelativePath="..\..\..\lib\compress\zstd_cwksp.h"
|
RelativePath="..\..\..\lib\compress\zstd_cwksp.h"
|
||||||
>
|
>
|
||||||
</File>
|
</File>
|
||||||
|
<File
|
||||||
|
RelativePath="..\..\..\lib\compress\zstd_compress_superblock.h"
|
||||||
|
>
|
||||||
|
</File>
|
||||||
<File
|
<File
|
||||||
RelativePath="..\..\..\lib\compress\zstd_fast.h"
|
RelativePath="..\..\..\lib\compress\zstd_fast.h"
|
||||||
>
|
>
|
||||||
|
|||||||
@ -420,6 +420,10 @@
|
|||||||
RelativePath="..\..\..\lib\compress\zstd_compress_sequences.c"
|
RelativePath="..\..\..\lib\compress\zstd_compress_sequences.c"
|
||||||
>
|
>
|
||||||
</File>
|
</File>
|
||||||
|
<File
|
||||||
|
RelativePath="..\..\..\lib\compress\zstd_compress_superblock.c"
|
||||||
|
>
|
||||||
|
</File>
|
||||||
<File
|
<File
|
||||||
RelativePath="..\..\..\lib\decompress\zstd_decompress.c"
|
RelativePath="..\..\..\lib\decompress\zstd_decompress.c"
|
||||||
>
|
>
|
||||||
@ -550,6 +554,10 @@
|
|||||||
RelativePath="..\..\..\lib\compress\zstd_cwksp.h"
|
RelativePath="..\..\..\lib\compress\zstd_cwksp.h"
|
||||||
>
|
>
|
||||||
</File>
|
</File>
|
||||||
|
<File
|
||||||
|
RelativePath="..\..\..\lib\compress\zstd_compress_superblock.h"
|
||||||
|
>
|
||||||
|
</File>
|
||||||
<File
|
<File
|
||||||
RelativePath="..\..\..\lib\compress\zstd_fast.h"
|
RelativePath="..\..\..\lib\compress\zstd_fast.h"
|
||||||
>
|
>
|
||||||
|
|||||||
@ -432,6 +432,10 @@
|
|||||||
RelativePath="..\..\..\lib\compress\zstd_compress_sequences.c"
|
RelativePath="..\..\..\lib\compress\zstd_compress_sequences.c"
|
||||||
>
|
>
|
||||||
</File>
|
</File>
|
||||||
|
<File
|
||||||
|
RelativePath="..\..\..\lib\compress\zstd_compress_superblock.c"
|
||||||
|
>
|
||||||
|
</File>
|
||||||
<File
|
<File
|
||||||
RelativePath="..\..\..\lib\decompress\zstd_decompress.c"
|
RelativePath="..\..\..\lib\decompress\zstd_decompress.c"
|
||||||
>
|
>
|
||||||
@ -630,6 +634,10 @@
|
|||||||
RelativePath="..\..\..\lib\compress\zstd_cwksp.h"
|
RelativePath="..\..\..\lib\compress\zstd_cwksp.h"
|
||||||
>
|
>
|
||||||
</File>
|
</File>
|
||||||
|
<File
|
||||||
|
RelativePath="..\..\..\lib\compress\zstd_compress_superblock.h"
|
||||||
|
>
|
||||||
|
</File>
|
||||||
<File
|
<File
|
||||||
RelativePath="..\..\..\lib\compress\zstd_fast.h"
|
RelativePath="..\..\..\lib\compress\zstd_fast.h"
|
||||||
>
|
>
|
||||||
|
|||||||
@ -404,6 +404,10 @@
|
|||||||
RelativePath="..\..\..\lib\compress\zstd_compress_sequences.c"
|
RelativePath="..\..\..\lib\compress\zstd_compress_sequences.c"
|
||||||
>
|
>
|
||||||
</File>
|
</File>
|
||||||
|
<File
|
||||||
|
RelativePath="..\..\..\lib\compress\zstd_compress_superblock.c"
|
||||||
|
>
|
||||||
|
</File>
|
||||||
<File
|
<File
|
||||||
RelativePath="..\..\..\lib\compress\zstd_fast.c"
|
RelativePath="..\..\..\lib\compress\zstd_fast.c"
|
||||||
>
|
>
|
||||||
@ -562,6 +566,10 @@
|
|||||||
RelativePath="..\..\..\lib\compress\zstd_cwksp.h"
|
RelativePath="..\..\..\lib\compress\zstd_cwksp.h"
|
||||||
>
|
>
|
||||||
</File>
|
</File>
|
||||||
|
<File
|
||||||
|
RelativePath="..\..\..\lib\compress\zstd_compress_superblock.h"
|
||||||
|
>
|
||||||
|
</File>
|
||||||
<File
|
<File
|
||||||
RelativePath="..\..\..\lib\compress\zstd_fast.h"
|
RelativePath="..\..\..\lib\compress\zstd_fast.h"
|
||||||
>
|
>
|
||||||
|
|||||||
@ -169,6 +169,7 @@
|
|||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
|
||||||
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_superblock.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstdmt_compress.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstdmt_compress.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
|
||||||
@ -198,6 +199,7 @@
|
|||||||
<ClInclude Include="..\..\..\lib\compress\zstd_compress_literals.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_literals.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_compress_sequences.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_sequences.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_cwksp.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_cwksp.h" />
|
||||||
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_superblock.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_fast.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_fast.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_double_fast.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_double_fast.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_lazy.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_lazy.h" />
|
||||||
|
|||||||
@ -169,6 +169,7 @@
|
|||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
|
||||||
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_superblock.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_lazy.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_lazy.c" />
|
||||||
@ -201,6 +202,7 @@
|
|||||||
<ClInclude Include="..\..\..\lib\compress\zstd_compress_literals.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_literals.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_compress_sequences.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_sequences.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_cwksp.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_cwksp.h" />
|
||||||
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_superblock.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_fast.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_fast.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_double_fast.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_double_fast.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_lazy.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_lazy.h" />
|
||||||
|
|||||||
@ -33,6 +33,7 @@
|
|||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
|
||||||
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_superblock.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_lazy.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_lazy.c" />
|
||||||
@ -83,6 +84,7 @@
|
|||||||
<ClInclude Include="..\..\..\lib\compress\zstd_compress_literals.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_literals.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_compress_sequences.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_sequences.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_cwksp.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_cwksp.h" />
|
||||||
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_superblock.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_fast.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_fast.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_double_fast.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_double_fast.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_lazy.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_lazy.h" />
|
||||||
|
|||||||
@ -33,6 +33,7 @@
|
|||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
|
||||||
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_superblock.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_lazy.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_lazy.c" />
|
||||||
@ -83,6 +84,7 @@
|
|||||||
<ClInclude Include="..\..\..\lib\compress\zstd_compress_literals.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_literals.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_compress_sequences.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_sequences.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_cwksp.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_cwksp.h" />
|
||||||
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_superblock.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_fast.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_fast.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_double_fast.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_double_fast.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_lazy.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_lazy.h" />
|
||||||
|
|||||||
@ -34,6 +34,7 @@
|
|||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
|
||||||
|
<ClCompile Include="..\..\..\lib\compress\zstd_compress_superblock.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
|
||||||
<ClCompile Include="..\..\..\lib\compress\zstd_lazy.c" />
|
<ClCompile Include="..\..\..\lib\compress\zstd_lazy.c" />
|
||||||
@ -80,6 +81,7 @@
|
|||||||
<ClInclude Include="..\..\..\lib\compress\zstd_compress_literals.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_literals.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_compress_sequences.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_sequences.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_cwksp.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_cwksp.h" />
|
||||||
|
<ClInclude Include="..\..\..\lib\compress\zstd_compress_superblock.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_fast.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_fast.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_double_fast.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_double_fast.h" />
|
||||||
<ClInclude Include="..\..\..\lib\compress\zstd_lazy.h" />
|
<ClInclude Include="..\..\..\lib\compress\zstd_lazy.h" />
|
||||||
|
|||||||
@ -30,6 +30,7 @@ libzstd_sources = [join_paths(zstd_rootdir, 'lib/common/entropy_common.c'),
|
|||||||
join_paths(zstd_rootdir, 'lib/compress/zstd_compress.c'),
|
join_paths(zstd_rootdir, 'lib/compress/zstd_compress.c'),
|
||||||
join_paths(zstd_rootdir, 'lib/compress/zstd_compress_literals.c'),
|
join_paths(zstd_rootdir, 'lib/compress/zstd_compress_literals.c'),
|
||||||
join_paths(zstd_rootdir, 'lib/compress/zstd_compress_sequences.c'),
|
join_paths(zstd_rootdir, 'lib/compress/zstd_compress_sequences.c'),
|
||||||
|
join_paths(zstd_rootdir, 'lib/compress/zstd_compress_superblock.c'),
|
||||||
join_paths(zstd_rootdir, 'lib/compress/zstdmt_compress.c'),
|
join_paths(zstd_rootdir, 'lib/compress/zstdmt_compress.c'),
|
||||||
join_paths(zstd_rootdir, 'lib/compress/zstd_fast.c'),
|
join_paths(zstd_rootdir, 'lib/compress/zstd_fast.c'),
|
||||||
join_paths(zstd_rootdir, 'lib/compress/zstd_double_fast.c'),
|
join_paths(zstd_rootdir, 'lib/compress/zstd_double_fast.c'),
|
||||||
|
|||||||
@ -208,6 +208,7 @@ typedef struct HUF_CElt_s HUF_CElt; /* incomplete type */
|
|||||||
size_t HUF_buildCTable (HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue, unsigned maxNbBits); /* @return : maxNbBits; CTable and count can overlap. In which case, CTable will overwrite count content */
|
size_t HUF_buildCTable (HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue, unsigned maxNbBits); /* @return : maxNbBits; CTable and count can overlap. In which case, CTable will overwrite count content */
|
||||||
size_t HUF_writeCTable (void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog);
|
size_t HUF_writeCTable (void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog);
|
||||||
size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
|
size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
|
||||||
|
size_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue);
|
||||||
|
|
||||||
typedef enum {
|
typedef enum {
|
||||||
HUF_repeat_none, /**< Cannot use the previous table */
|
HUF_repeat_none, /**< Cannot use the previous table */
|
||||||
|
|||||||
@ -427,7 +427,7 @@ size_t HUF_buildCTable (HUF_CElt* tree, const unsigned* count, unsigned maxSymbo
|
|||||||
return HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, nodeTable, sizeof(nodeTable));
|
return HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, nodeTable, sizeof(nodeTable));
|
||||||
}
|
}
|
||||||
|
|
||||||
static size_t HUF_estimateCompressedSize(HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue)
|
size_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue)
|
||||||
{
|
{
|
||||||
size_t nbBits = 0;
|
size_t nbBits = 0;
|
||||||
int s;
|
int s;
|
||||||
|
|||||||
@ -20,6 +20,7 @@
|
|||||||
#include "fse.h"
|
#include "fse.h"
|
||||||
#define HUF_STATIC_LINKING_ONLY
|
#define HUF_STATIC_LINKING_ONLY
|
||||||
#include "huf.h"
|
#include "huf.h"
|
||||||
|
#include "zstd_compress_superblock.h"
|
||||||
#include "zstd_compress_internal.h"
|
#include "zstd_compress_internal.h"
|
||||||
#include "zstd_compress_sequences.h"
|
#include "zstd_compress_sequences.h"
|
||||||
#include "zstd_compress_literals.h"
|
#include "zstd_compress_literals.h"
|
||||||
@ -33,6 +34,13 @@
|
|||||||
/*-*************************************
|
/*-*************************************
|
||||||
* Helper functions
|
* Helper functions
|
||||||
***************************************/
|
***************************************/
|
||||||
|
/* ZSTD_compressBound()
|
||||||
|
* Note that the result from this function is only compatible with the "normal"
|
||||||
|
* full-block strategy.
|
||||||
|
* When there are a lot of small blocks due to frequent flush in streaming mode
|
||||||
|
* or targetCBlockSize, the overhead of headers can make the compressed data to
|
||||||
|
* be larger than the return value of ZSTD_compressBound().
|
||||||
|
*/
|
||||||
size_t ZSTD_compressBound(size_t srcSize) {
|
size_t ZSTD_compressBound(size_t srcSize) {
|
||||||
return ZSTD_COMPRESSBOUND(srcSize);
|
return ZSTD_COMPRESSBOUND(srcSize);
|
||||||
}
|
}
|
||||||
@ -1889,16 +1897,6 @@ static void ZSTD_reduceIndex (ZSTD_matchState_t* ms, ZSTD_CCtx_params const* par
|
|||||||
|
|
||||||
/* See doc/zstd_compression_format.md for detailed format description */
|
/* See doc/zstd_compression_format.md for detailed format description */
|
||||||
|
|
||||||
static size_t ZSTD_noCompressBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize, U32 lastBlock)
|
|
||||||
{
|
|
||||||
U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw)<<1) + (U32)(srcSize << 3);
|
|
||||||
RETURN_ERROR_IF(srcSize + ZSTD_blockHeaderSize > dstCapacity,
|
|
||||||
dstSize_tooSmall);
|
|
||||||
MEM_writeLE24(dst, cBlockHeader24);
|
|
||||||
memcpy((BYTE*)dst + ZSTD_blockHeaderSize, src, srcSize);
|
|
||||||
return ZSTD_blockHeaderSize + srcSize;
|
|
||||||
}
|
|
||||||
|
|
||||||
void ZSTD_seqToCodes(const seqStore_t* seqStorePtr)
|
void ZSTD_seqToCodes(const seqStore_t* seqStorePtr)
|
||||||
{
|
{
|
||||||
const seqDef* const sequences = seqStorePtr->sequencesStart;
|
const seqDef* const sequences = seqStorePtr->sequencesStart;
|
||||||
@ -1936,6 +1934,16 @@ static int ZSTD_disableLiteralsCompression(const ZSTD_CCtx_params* cctxParams)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/* 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. */
|
||||||
|
static int ZSTD_useTargetCBlockSize(const ZSTD_CCtx_params* cctxParams)
|
||||||
|
{
|
||||||
|
DEBUGLOG(5, "ZSTD_useTargetCBlockSize (targetCBlockSize=%zu)", cctxParams->targetCBlockSize);
|
||||||
|
return (cctxParams->targetCBlockSize != 0);
|
||||||
|
}
|
||||||
|
|
||||||
/* ZSTD_compressSequences_internal():
|
/* ZSTD_compressSequences_internal():
|
||||||
* actually compresses both literals and sequences */
|
* actually compresses both literals and sequences */
|
||||||
MEM_STATIC size_t
|
MEM_STATIC size_t
|
||||||
@ -2435,6 +2443,70 @@ out:
|
|||||||
return cSize;
|
return cSize;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static size_t ZSTD_compressBlock_targetCBlockSize(ZSTD_CCtx* zc,
|
||||||
|
void* dst, size_t dstCapacity,
|
||||||
|
const void* src, size_t srcSize,
|
||||||
|
U32 lastBlock) {
|
||||||
|
size_t cSize = 0;
|
||||||
|
DEBUGLOG(5, "ZSTD_compressBlock_targetCBlockSize (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u, srcSize=%zu)",
|
||||||
|
(unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit, (unsigned)zc->blockState.matchState.nextToUpdate, srcSize);
|
||||||
|
|
||||||
|
{ const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize);
|
||||||
|
FORWARD_IF_ERROR(bss);
|
||||||
|
if (bss == ZSTDbss_compress) {
|
||||||
|
cSize = ZSTD_compressSuperBlock(zc, dst, dstCapacity, lastBlock);
|
||||||
|
} }
|
||||||
|
|
||||||
|
/* Superblock compression may fail, in which case
|
||||||
|
* encode using ZSTD_noCompressSuperBlock writing sub blocks
|
||||||
|
* in uncompressed mode.
|
||||||
|
*/
|
||||||
|
if (cSize == 0) {
|
||||||
|
cSize = ZSTD_noCompressSuperBlock(dst, dstCapacity, src, srcSize, zc->appliedParams.targetCBlockSize, lastBlock);
|
||||||
|
/* In compression, there is an assumption that a compressed block is always
|
||||||
|
* within the size of ZSTD_compressBound(). However, SuperBlock compression
|
||||||
|
* can exceed the limit due to overhead of headers from SubBlocks.
|
||||||
|
* This breaks in streaming mode where output buffer in compress context is
|
||||||
|
* allocated ZSTD_compressBound() amount of memory, which may not be big
|
||||||
|
* enough for SuperBlock compression.
|
||||||
|
* In such case, fall back to normal compression. This is possible because
|
||||||
|
* targetCBlockSize is best effort not a guarantee. */
|
||||||
|
if (cSize != ERROR(dstSize_tooSmall)) return cSize;
|
||||||
|
else {
|
||||||
|
BYTE* const ostart = (BYTE*)dst;
|
||||||
|
/* If ZSTD_noCompressSuperBlock fails with dstSize_tooSmall,
|
||||||
|
* compress normally.
|
||||||
|
*/
|
||||||
|
cSize = ZSTD_compressSequences(&zc->seqStore,
|
||||||
|
&zc->blockState.prevCBlock->entropy, &zc->blockState.nextCBlock->entropy,
|
||||||
|
&zc->appliedParams,
|
||||||
|
ostart+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize,
|
||||||
|
srcSize,
|
||||||
|
zc->entropyWorkspace, HUF_WORKSPACE_SIZE /* statically allocated in resetCCtx */,
|
||||||
|
zc->bmi2);
|
||||||
|
if (!ZSTD_isError(cSize) && cSize != 0) {
|
||||||
|
U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
|
||||||
|
MEM_writeLE24(ostart, cBlockHeader24);
|
||||||
|
cSize += ZSTD_blockHeaderSize;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!ZSTD_isError(cSize) && cSize != 0) {
|
||||||
|
/* confirm repcodes and entropy tables when emitting a compressed block */
|
||||||
|
ZSTD_compressedBlockState_t* const tmp = zc->blockState.prevCBlock;
|
||||||
|
zc->blockState.prevCBlock = zc->blockState.nextCBlock;
|
||||||
|
zc->blockState.nextCBlock = tmp;
|
||||||
|
}
|
||||||
|
/* We check that dictionaries have offset codes available for the first
|
||||||
|
* block. After the first block, the offcode table might not have large
|
||||||
|
* enough codes to represent the offsets in the data.
|
||||||
|
*/
|
||||||
|
if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)
|
||||||
|
zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;
|
||||||
|
|
||||||
|
return cSize;
|
||||||
|
}
|
||||||
|
|
||||||
static void ZSTD_overflowCorrectIfNeeded(ZSTD_matchState_t* ms,
|
static void ZSTD_overflowCorrectIfNeeded(ZSTD_matchState_t* ms,
|
||||||
ZSTD_cwksp* ws,
|
ZSTD_cwksp* ws,
|
||||||
@ -2500,21 +2572,28 @@ static size_t ZSTD_compress_frameChunk (ZSTD_CCtx* cctx,
|
|||||||
/* Ensure hash/chain table insertion resumes no sooner than lowlimit */
|
/* Ensure hash/chain table insertion resumes no sooner than lowlimit */
|
||||||
if (ms->nextToUpdate < ms->window.lowLimit) ms->nextToUpdate = ms->window.lowLimit;
|
if (ms->nextToUpdate < ms->window.lowLimit) ms->nextToUpdate = ms->window.lowLimit;
|
||||||
|
|
||||||
{ size_t cSize = ZSTD_compressBlock_internal(cctx,
|
{ int useTargetCBlockSize = ZSTD_useTargetCBlockSize(&cctx->appliedParams);
|
||||||
op+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize,
|
size_t cSize = 0;
|
||||||
ip, blockSize, 1 /* frame */);
|
if (useTargetCBlockSize) {
|
||||||
FORWARD_IF_ERROR(cSize);
|
cSize = ZSTD_compressBlock_targetCBlockSize(cctx, op, dstCapacity, ip, blockSize, lastBlock);
|
||||||
if (cSize == 0) { /* block is not compressible */
|
|
||||||
cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);
|
|
||||||
FORWARD_IF_ERROR(cSize);
|
FORWARD_IF_ERROR(cSize);
|
||||||
} else {
|
} else {
|
||||||
const U32 cBlockHeader = cSize == 1 ?
|
cSize = ZSTD_compressBlock_internal(cctx,
|
||||||
lastBlock + (((U32)bt_rle)<<1) + (U32)(blockSize << 3) :
|
op+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize,
|
||||||
lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
|
ip, blockSize);
|
||||||
MEM_writeLE24(op, cBlockHeader);
|
FORWARD_IF_ERROR(cSize);
|
||||||
cSize += ZSTD_blockHeaderSize;
|
|
||||||
|
if (cSize == 0) { /* block is not compressible */
|
||||||
|
cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);
|
||||||
|
FORWARD_IF_ERROR(cSize);
|
||||||
|
} else {
|
||||||
|
U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
|
||||||
|
MEM_writeLE24(op, cBlockHeader24);
|
||||||
|
cSize += ZSTD_blockHeaderSize;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
ip += blockSize;
|
ip += blockSize;
|
||||||
assert(remaining >= blockSize);
|
assert(remaining >= blockSize);
|
||||||
remaining -= blockSize;
|
remaining -= blockSize;
|
||||||
|
|||||||
@ -336,6 +336,20 @@ MEM_STATIC int ZSTD_cParam_withinBounds(ZSTD_cParameter cParam, int value)
|
|||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/* ZSTD_noCompressBlock() :
|
||||||
|
* Writes uncompressed block to dst buffer from given src.
|
||||||
|
* Returns the size of the block */
|
||||||
|
MEM_STATIC size_t ZSTD_noCompressBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize, U32 lastBlock)
|
||||||
|
{
|
||||||
|
U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw)<<1) + (U32)(srcSize << 3);
|
||||||
|
RETURN_ERROR_IF(srcSize + ZSTD_blockHeaderSize > dstCapacity,
|
||||||
|
dstSize_tooSmall);
|
||||||
|
MEM_writeLE24(dst, cBlockHeader24);
|
||||||
|
memcpy((BYTE*)dst + ZSTD_blockHeaderSize, src, srcSize);
|
||||||
|
return ZSTD_blockHeaderSize + srcSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
/* ZSTD_minGain() :
|
/* ZSTD_minGain() :
|
||||||
* minimum compression required
|
* minimum compression required
|
||||||
* to generate a compress block or a compressed literals section.
|
* to generate a compress block or a compressed literals section.
|
||||||
|
|||||||
@ -86,7 +86,7 @@ static size_t ZSTD_entropyCost(unsigned const* count, unsigned const max, size_t
|
|||||||
* Returns the cost in bits of encoding the distribution in count using ctable.
|
* 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.
|
* Returns an error if ctable cannot represent all the symbols in count.
|
||||||
*/
|
*/
|
||||||
static size_t ZSTD_fseBitCost(
|
size_t ZSTD_fseBitCost(
|
||||||
FSE_CTable const* ctable,
|
FSE_CTable const* ctable,
|
||||||
unsigned const* count,
|
unsigned const* count,
|
||||||
unsigned const max)
|
unsigned const max)
|
||||||
@ -117,8 +117,8 @@ static size_t ZSTD_fseBitCost(
|
|||||||
* table described by norm. The max symbol support by norm is assumed >= max.
|
* 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.
|
* norm must be valid for every symbol with non-zero probability in count.
|
||||||
*/
|
*/
|
||||||
static size_t ZSTD_crossEntropyCost(short const* norm, unsigned accuracyLog,
|
size_t ZSTD_crossEntropyCost(short const* norm, unsigned accuracyLog,
|
||||||
unsigned const* count, unsigned const max)
|
unsigned const* count, unsigned const max)
|
||||||
{
|
{
|
||||||
unsigned const shift = 8 - accuracyLog;
|
unsigned const shift = 8 - accuracyLog;
|
||||||
size_t cost = 0;
|
size_t cost = 0;
|
||||||
|
|||||||
@ -44,4 +44,11 @@ size_t ZSTD_encodeSequences(
|
|||||||
FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
|
FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
|
||||||
seqDef const* sequences, size_t nbSeq, int longOffsets, int bmi2);
|
seqDef const* sequences, size_t nbSeq, int longOffsets, int bmi2);
|
||||||
|
|
||||||
|
size_t ZSTD_fseBitCost(
|
||||||
|
FSE_CTable const* ctable,
|
||||||
|
unsigned const* count,
|
||||||
|
unsigned const max);
|
||||||
|
|
||||||
|
size_t ZSTD_crossEntropyCost(short const* norm, unsigned accuracyLog,
|
||||||
|
unsigned const* count, unsigned const max);
|
||||||
#endif /* ZSTD_COMPRESS_SEQUENCES_H */
|
#endif /* ZSTD_COMPRESS_SEQUENCES_H */
|
||||||
|
|||||||
739
lib/compress/zstd_compress_superblock.c
Normal file
739
lib/compress/zstd_compress_superblock.c
Normal file
@ -0,0 +1,739 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
|
||||||
|
* All rights reserved.
|
||||||
|
*
|
||||||
|
* This source code is licensed under both the BSD-style license (found in the
|
||||||
|
* LICENSE file in the root directory of this source tree) and the GPLv2 (found
|
||||||
|
* in the COPYING file in the root directory of this source tree).
|
||||||
|
* You may select, at your option, one of the above-listed licenses.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*-*************************************
|
||||||
|
* Dependencies
|
||||||
|
***************************************/
|
||||||
|
#include "hist.h" /* HIST_countFast_wksp */
|
||||||
|
#include "zstd_compress_internal.h"
|
||||||
|
#include "zstd_compress_superblock.h"
|
||||||
|
#include "zstd_compress_sequences.h"
|
||||||
|
#include "zstd_compress_literals.h"
|
||||||
|
|
||||||
|
/*-*************************************
|
||||||
|
* Superblock entropy buffer structs
|
||||||
|
***************************************/
|
||||||
|
/** 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_buildSuperBlockEntropy_literal() */
|
||||||
|
typedef struct {
|
||||||
|
symbolEncodingType_e hType;
|
||||||
|
BYTE hufDesBuffer[500]; // TODO give name to this value
|
||||||
|
size_t hufDesSize;
|
||||||
|
} ZSTD_hufCTablesMetadata_t;
|
||||||
|
|
||||||
|
/** 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_buildSuperBlockEntropy_sequences() */
|
||||||
|
typedef struct {
|
||||||
|
symbolEncodingType_e llType;
|
||||||
|
symbolEncodingType_e ofType;
|
||||||
|
symbolEncodingType_e mlType;
|
||||||
|
BYTE fseTablesBuffer[500]; // TODO give name to this value
|
||||||
|
size_t fseTablesSize;
|
||||||
|
size_t lastCountSize; // This is to account for bug in 1.3.4. More detail in ZSTD_compressSubBlock_sequences()
|
||||||
|
} ZSTD_fseCTablesMetadata_t;
|
||||||
|
|
||||||
|
typedef struct {
|
||||||
|
ZSTD_hufCTablesMetadata_t hufMetadata;
|
||||||
|
ZSTD_fseCTablesMetadata_t fseMetadata;
|
||||||
|
} ZSTD_entropyCTablesMetadata_t;
|
||||||
|
|
||||||
|
|
||||||
|
/** ZSTD_buildSuperBlockEntropy_literal() :
|
||||||
|
* Builds entropy for the super-block literals.
|
||||||
|
* Stores literals block type (raw, rle, compressed) and
|
||||||
|
* huffman description table to hufMetadata.
|
||||||
|
* Currently, this does not consider the option of reusing huffman table from
|
||||||
|
* previous super-block. I think it would be a good improvement to add that option.
|
||||||
|
* @return : size of huffman description table or error code */
|
||||||
|
static size_t ZSTD_buildSuperBlockEntropy_literal(void* const src, size_t srcSize,
|
||||||
|
const ZSTD_hufCTables_t* prevHuf,
|
||||||
|
ZSTD_hufCTables_t* nextHuf,
|
||||||
|
ZSTD_hufCTablesMetadata_t* hufMetadata,
|
||||||
|
void* workspace, size_t wkspSize)
|
||||||
|
{
|
||||||
|
BYTE* const wkspStart = (BYTE*)workspace;
|
||||||
|
BYTE* const wkspEnd = wkspStart + wkspSize;
|
||||||
|
BYTE* const countWkspStart = wkspStart;
|
||||||
|
unsigned* const countWksp = (unsigned*)workspace;
|
||||||
|
const size_t countWkspSize = (HUF_SYMBOLVALUE_MAX + 1) * sizeof(unsigned);
|
||||||
|
BYTE* const nodeWksp = countWkspStart + countWkspSize;
|
||||||
|
const size_t nodeWkspSize = wkspEnd-nodeWksp;
|
||||||
|
unsigned maxSymbolValue = 255;
|
||||||
|
unsigned huffLog = 11;
|
||||||
|
|
||||||
|
DEBUGLOG(5, "ZSTD_buildSuperBlockEntropy_literal (srcSize=%zu)", srcSize);
|
||||||
|
|
||||||
|
/* Prepare nextEntropy assuming reusing the existing table */
|
||||||
|
memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
|
||||||
|
|
||||||
|
/* small ? don't even attempt compression (speed opt) */
|
||||||
|
# define COMPRESS_LITERALS_SIZE_MIN 63
|
||||||
|
{ size_t const minLitSize = COMPRESS_LITERALS_SIZE_MIN;
|
||||||
|
if (srcSize <= minLitSize) { hufMetadata->hType = set_basic; return 0; }
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Scan input and build symbol stats */
|
||||||
|
{ size_t const largest = HIST_count_wksp (countWksp, &maxSymbolValue, (const BYTE*)src, srcSize, workspace, wkspSize);
|
||||||
|
FORWARD_IF_ERROR(largest);
|
||||||
|
if (largest == srcSize) { hufMetadata->hType = set_rle; return 0; }
|
||||||
|
if (largest <= (srcSize >> 7)+4) { hufMetadata->hType = set_basic; return 0; }
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* Build Huffman Tree */
|
||||||
|
memset(nextHuf->CTable, 0, sizeof(nextHuf->CTable));
|
||||||
|
huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue);
|
||||||
|
{ size_t const maxBits = HUF_buildCTable_wksp((HUF_CElt*)nextHuf->CTable, countWksp,
|
||||||
|
maxSymbolValue, huffLog,
|
||||||
|
nodeWksp, nodeWkspSize);
|
||||||
|
FORWARD_IF_ERROR(maxBits);
|
||||||
|
huffLog = (U32)maxBits;
|
||||||
|
{ size_t cSize = HUF_estimateCompressedSize(
|
||||||
|
(HUF_CElt*)nextHuf->CTable, countWksp, maxSymbolValue);
|
||||||
|
size_t hSize = HUF_writeCTable(
|
||||||
|
hufMetadata->hufDesBuffer, sizeof(hufMetadata->hufDesBuffer),
|
||||||
|
(HUF_CElt*)nextHuf->CTable, maxSymbolValue, huffLog);
|
||||||
|
if (cSize + hSize >= srcSize) { hufMetadata->hType = set_basic; return 0; }
|
||||||
|
hufMetadata->hType = set_compressed;
|
||||||
|
return hSize;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** ZSTD_buildSuperBlockEntropy_sequences() :
|
||||||
|
* Builds entropy for the super-block sequences.
|
||||||
|
* Stores symbol compression modes and fse table to fseMetadata.
|
||||||
|
* @return : size of fse tables or error code */
|
||||||
|
static size_t ZSTD_buildSuperBlockEntropy_sequences(seqStore_t* seqStorePtr,
|
||||||
|
const ZSTD_fseCTables_t* prevEntropy,
|
||||||
|
ZSTD_fseCTables_t* nextEntropy,
|
||||||
|
const ZSTD_CCtx_params* cctxParams,
|
||||||
|
ZSTD_fseCTablesMetadata_t* fseMetadata,
|
||||||
|
void* workspace, size_t wkspSize)
|
||||||
|
{
|
||||||
|
BYTE* const wkspStart = (BYTE*)workspace;
|
||||||
|
BYTE* const wkspEnd = wkspStart + wkspSize;
|
||||||
|
BYTE* const countWkspStart = wkspStart;
|
||||||
|
unsigned* const countWksp = (unsigned*)workspace;
|
||||||
|
const size_t countWkspSize = (MaxSeq + 1) * sizeof(unsigned);
|
||||||
|
BYTE* const cTableWksp = countWkspStart + countWkspSize;
|
||||||
|
const size_t cTableWkspSize = wkspEnd-cTableWksp;
|
||||||
|
ZSTD_strategy const strategy = cctxParams->cParams.strategy;
|
||||||
|
FSE_CTable* CTable_LitLength = nextEntropy->litlengthCTable;
|
||||||
|
FSE_CTable* CTable_OffsetBits = nextEntropy->offcodeCTable;
|
||||||
|
FSE_CTable* CTable_MatchLength = nextEntropy->matchlengthCTable;
|
||||||
|
const BYTE* const ofCodeTable = seqStorePtr->ofCode;
|
||||||
|
const BYTE* const llCodeTable = seqStorePtr->llCode;
|
||||||
|
const BYTE* const mlCodeTable = seqStorePtr->mlCode;
|
||||||
|
size_t const nbSeq = seqStorePtr->sequences - seqStorePtr->sequencesStart;
|
||||||
|
BYTE* const ostart = fseMetadata->fseTablesBuffer;
|
||||||
|
BYTE* const oend = ostart + sizeof(fseMetadata->fseTablesBuffer);
|
||||||
|
BYTE* op = ostart;
|
||||||
|
|
||||||
|
assert(cTableWkspSize >= (1 << MaxFSELog) * sizeof(FSE_FUNCTION_TYPE));
|
||||||
|
DEBUGLOG(5, "ZSTD_buildSuperBlockEntropy_sequences (nbSeq=%zu)", nbSeq);
|
||||||
|
memset(workspace, 0, wkspSize);
|
||||||
|
|
||||||
|
fseMetadata->lastCountSize = 0;
|
||||||
|
/* convert length/distances into codes */
|
||||||
|
ZSTD_seqToCodes(seqStorePtr);
|
||||||
|
/* build CTable for Literal Lengths */
|
||||||
|
{ U32 LLtype;
|
||||||
|
unsigned max = MaxLL;
|
||||||
|
size_t const mostFrequent = HIST_countFast_wksp(countWksp, &max, llCodeTable, nbSeq, workspace, wkspSize); /* can't fail */
|
||||||
|
DEBUGLOG(5, "Building LL table");
|
||||||
|
nextEntropy->litlength_repeatMode = prevEntropy->litlength_repeatMode;
|
||||||
|
LLtype = ZSTD_selectEncodingType(&nextEntropy->litlength_repeatMode,
|
||||||
|
countWksp, max, mostFrequent, nbSeq,
|
||||||
|
LLFSELog, prevEntropy->litlengthCTable,
|
||||||
|
LL_defaultNorm, LL_defaultNormLog,
|
||||||
|
ZSTD_defaultAllowed, strategy);
|
||||||
|
assert(set_basic < set_compressed && set_rle < set_compressed);
|
||||||
|
assert(!(LLtype < set_compressed && nextEntropy->litlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
|
||||||
|
{ size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_LitLength, LLFSELog, (symbolEncodingType_e)LLtype,
|
||||||
|
countWksp, max, llCodeTable, nbSeq, LL_defaultNorm, LL_defaultNormLog, MaxLL,
|
||||||
|
prevEntropy->litlengthCTable, sizeof(prevEntropy->litlengthCTable),
|
||||||
|
cTableWksp, cTableWkspSize);
|
||||||
|
FORWARD_IF_ERROR(countSize);
|
||||||
|
if (LLtype == set_compressed)
|
||||||
|
fseMetadata->lastCountSize = countSize;
|
||||||
|
op += countSize;
|
||||||
|
fseMetadata->llType = (symbolEncodingType_e) LLtype;
|
||||||
|
} }
|
||||||
|
/* build CTable for Offsets */
|
||||||
|
{ U32 Offtype;
|
||||||
|
unsigned max = MaxOff;
|
||||||
|
size_t const mostFrequent = HIST_countFast_wksp(countWksp, &max, ofCodeTable, nbSeq, workspace, wkspSize); /* can't fail */
|
||||||
|
/* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
|
||||||
|
ZSTD_defaultPolicy_e const defaultPolicy = (max <= DefaultMaxOff) ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed;
|
||||||
|
DEBUGLOG(5, "Building OF table");
|
||||||
|
nextEntropy->offcode_repeatMode = prevEntropy->offcode_repeatMode;
|
||||||
|
Offtype = ZSTD_selectEncodingType(&nextEntropy->offcode_repeatMode,
|
||||||
|
countWksp, max, mostFrequent, nbSeq,
|
||||||
|
OffFSELog, prevEntropy->offcodeCTable,
|
||||||
|
OF_defaultNorm, OF_defaultNormLog,
|
||||||
|
defaultPolicy, strategy);
|
||||||
|
assert(!(Offtype < set_compressed && nextEntropy->offcode_repeatMode != FSE_repeat_none)); /* We don't copy tables */
|
||||||
|
{ size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)Offtype,
|
||||||
|
countWksp, max, ofCodeTable, nbSeq, OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
|
||||||
|
prevEntropy->offcodeCTable, sizeof(prevEntropy->offcodeCTable),
|
||||||
|
cTableWksp, cTableWkspSize);
|
||||||
|
FORWARD_IF_ERROR(countSize);
|
||||||
|
if (Offtype == set_compressed)
|
||||||
|
fseMetadata->lastCountSize = countSize;
|
||||||
|
op += countSize;
|
||||||
|
fseMetadata->ofType = (symbolEncodingType_e) Offtype;
|
||||||
|
} }
|
||||||
|
/* build CTable for MatchLengths */
|
||||||
|
{ U32 MLtype;
|
||||||
|
unsigned max = MaxML;
|
||||||
|
size_t const mostFrequent = HIST_countFast_wksp(countWksp, &max, mlCodeTable, nbSeq, workspace, wkspSize); /* can't fail */
|
||||||
|
DEBUGLOG(5, "Building ML table (remaining space : %i)", (int)(oend-op));
|
||||||
|
nextEntropy->matchlength_repeatMode = prevEntropy->matchlength_repeatMode;
|
||||||
|
MLtype = ZSTD_selectEncodingType(&nextEntropy->matchlength_repeatMode,
|
||||||
|
countWksp, max, mostFrequent, nbSeq,
|
||||||
|
MLFSELog, prevEntropy->matchlengthCTable,
|
||||||
|
ML_defaultNorm, ML_defaultNormLog,
|
||||||
|
ZSTD_defaultAllowed, strategy);
|
||||||
|
assert(!(MLtype < set_compressed && nextEntropy->matchlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
|
||||||
|
{ size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_MatchLength, MLFSELog, (symbolEncodingType_e)MLtype,
|
||||||
|
countWksp, max, mlCodeTable, nbSeq, ML_defaultNorm, ML_defaultNormLog, MaxML,
|
||||||
|
prevEntropy->matchlengthCTable, sizeof(prevEntropy->matchlengthCTable),
|
||||||
|
cTableWksp, cTableWkspSize);
|
||||||
|
FORWARD_IF_ERROR(countSize);
|
||||||
|
if (MLtype == set_compressed)
|
||||||
|
fseMetadata->lastCountSize = countSize;
|
||||||
|
op += countSize;
|
||||||
|
fseMetadata->mlType = (symbolEncodingType_e) MLtype;
|
||||||
|
} }
|
||||||
|
assert((size_t) (op-ostart) <= sizeof(fseMetadata->fseTablesBuffer));
|
||||||
|
return op-ostart;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/** ZSTD_buildSuperBlockEntropy() :
|
||||||
|
* Builds entropy for the super-block.
|
||||||
|
* @return : 0 on success or error code */
|
||||||
|
static size_t
|
||||||
|
ZSTD_buildSuperBlockEntropy(seqStore_t* seqStorePtr,
|
||||||
|
const ZSTD_entropyCTables_t* prevEntropy,
|
||||||
|
ZSTD_entropyCTables_t* nextEntropy,
|
||||||
|
const ZSTD_CCtx_params* cctxParams,
|
||||||
|
ZSTD_entropyCTablesMetadata_t* entropyMetadata,
|
||||||
|
void* workspace, size_t wkspSize)
|
||||||
|
{
|
||||||
|
size_t const litSize = seqStorePtr->lit - seqStorePtr->litStart;
|
||||||
|
DEBUGLOG(5, "ZSTD_buildSuperBlockEntropy");
|
||||||
|
entropyMetadata->hufMetadata.hufDesSize =
|
||||||
|
ZSTD_buildSuperBlockEntropy_literal(seqStorePtr->litStart, litSize,
|
||||||
|
&prevEntropy->huf, &nextEntropy->huf,
|
||||||
|
&entropyMetadata->hufMetadata,
|
||||||
|
workspace, wkspSize);
|
||||||
|
FORWARD_IF_ERROR(entropyMetadata->hufMetadata.hufDesSize);
|
||||||
|
entropyMetadata->fseMetadata.fseTablesSize =
|
||||||
|
ZSTD_buildSuperBlockEntropy_sequences(seqStorePtr,
|
||||||
|
&prevEntropy->fse, &nextEntropy->fse,
|
||||||
|
cctxParams,
|
||||||
|
&entropyMetadata->fseMetadata,
|
||||||
|
workspace, wkspSize);
|
||||||
|
FORWARD_IF_ERROR(entropyMetadata->fseMetadata.fseTablesSize);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** ZSTD_compressSubBlock_literal() :
|
||||||
|
* Compresses literals section for a sub-block.
|
||||||
|
* Compressed literal size needs to be less than uncompressed literal size.
|
||||||
|
* ZSTD spec doesn't have this constaint. I will explain why I have this constraint here.
|
||||||
|
* Literals section header size ranges from 1 to 5 bytes,
|
||||||
|
* which is dictated by regenerated size and compressed size.
|
||||||
|
* In order to figure out the memory address to start writing compressed literal,
|
||||||
|
* it is necessary to figure out the literals section header size.
|
||||||
|
* The challenge is that compressed size is only known after compression.
|
||||||
|
* This is a chicken and egg problem.
|
||||||
|
* I am simplifying the problem by assuming that
|
||||||
|
* compressed size will always be less than or equal to regenerated size,
|
||||||
|
* and using regenerated size to calculate literals section header size.
|
||||||
|
* 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
|
||||||
|
* 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 it unable to compress.
|
||||||
|
* Or error code */
|
||||||
|
static size_t ZSTD_compressSubBlock_literal(const HUF_CElt* hufTable,
|
||||||
|
const ZSTD_hufCTablesMetadata_t* hufMetadata,
|
||||||
|
const BYTE* literals, size_t litSize,
|
||||||
|
void* dst, size_t dstSize,
|
||||||
|
const int bmi2, int writeEntropy)
|
||||||
|
{
|
||||||
|
size_t const lhSize = 3 + (litSize >= 1 KB) + (litSize >= 16 KB);
|
||||||
|
BYTE* const ostart = (BYTE*)dst;
|
||||||
|
BYTE* const oend = ostart + dstSize;
|
||||||
|
BYTE* op = ostart + lhSize;
|
||||||
|
U32 singleStream = litSize < 256;
|
||||||
|
symbolEncodingType_e hType = writeEntropy ? set_compressed : set_repeat;
|
||||||
|
size_t cLitSize = 0;
|
||||||
|
|
||||||
|
(void)bmi2; // TODO bmi2...
|
||||||
|
|
||||||
|
DEBUGLOG(5, "ZSTD_compressSubBlock_literal (litSize=%zu, lhSize=%zu, writeEntropy=%d)", litSize, lhSize, writeEntropy);
|
||||||
|
|
||||||
|
if (writeEntropy && litSize == 0) {
|
||||||
|
/* Literals section cannot be compressed mode when litSize == 0.
|
||||||
|
* (This seems to be decoder constraint.)
|
||||||
|
* Entropy cannot be written if literals section is not compressed mode.
|
||||||
|
*/
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (litSize == 0 || hufMetadata->hType == set_basic) {
|
||||||
|
DEBUGLOG(5, "ZSTD_compressSubBlock_literal using raw literal");
|
||||||
|
return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);
|
||||||
|
} else if (hufMetadata->hType == set_rle) {
|
||||||
|
DEBUGLOG(5, "ZSTD_compressSubBlock_literal using rle literal");
|
||||||
|
return ZSTD_compressRleLiteralsBlock(dst, dstSize, literals, litSize);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (lhSize == 3) singleStream = 1;
|
||||||
|
if (writeEntropy) {
|
||||||
|
memcpy(op, hufMetadata->hufDesBuffer, hufMetadata->hufDesSize);
|
||||||
|
op += hufMetadata->hufDesSize;
|
||||||
|
cLitSize += hufMetadata->hufDesSize;
|
||||||
|
DEBUGLOG(5, "ZSTD_compressSubBlock_literal (hSize=%zu)", hufMetadata->hufDesSize);
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO bmi2
|
||||||
|
{ const size_t cSize = singleStream ? HUF_compress1X_usingCTable(op, oend-op, literals, litSize, hufTable)
|
||||||
|
: HUF_compress4X_usingCTable(op, oend-op, literals, litSize, hufTable);
|
||||||
|
op += cSize;
|
||||||
|
cLitSize += cSize;
|
||||||
|
if (cSize == 0 || ERR_isError(cSize)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if (cLitSize > litSize) {
|
||||||
|
if (writeEntropy) return 0;
|
||||||
|
else return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);
|
||||||
|
}
|
||||||
|
DEBUGLOG(5, "ZSTD_compressSubBlock_literal (cSize=%zu)", cSize);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Build header */
|
||||||
|
switch(lhSize)
|
||||||
|
{
|
||||||
|
case 3: /* 2 - 2 - 10 - 10 */
|
||||||
|
{ U32 const lhc = hType + ((!singleStream) << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<14);
|
||||||
|
MEM_writeLE24(ostart, lhc);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case 4: /* 2 - 2 - 14 - 14 */
|
||||||
|
{ U32 const lhc = hType + (2 << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<18);
|
||||||
|
MEM_writeLE32(ostart, lhc);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case 5: /* 2 - 2 - 18 - 18 */
|
||||||
|
{ U32 const lhc = hType + (3 << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<22);
|
||||||
|
MEM_writeLE32(ostart, lhc);
|
||||||
|
ostart[4] = (BYTE)(cLitSize >> 10);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
default: /* not possible : lhSize is {3,4,5} */
|
||||||
|
assert(0);
|
||||||
|
}
|
||||||
|
return op-ostart;
|
||||||
|
}
|
||||||
|
|
||||||
|
static size_t ZSTD_seqDecompressedSize(const seqDef* sequences, size_t nbSeq, size_t litSize) {
|
||||||
|
const seqDef* const sstart = sequences;
|
||||||
|
const seqDef* const send = sequences + nbSeq;
|
||||||
|
const seqDef* sp = sstart;
|
||||||
|
size_t matchLengthSum = 0;
|
||||||
|
while (send-sp > 0) {
|
||||||
|
matchLengthSum += sp->matchLength + MINMATCH;
|
||||||
|
sp++;
|
||||||
|
}
|
||||||
|
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.
|
||||||
|
* First sub-block will have these in its header. 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. */
|
||||||
|
static size_t ZSTD_compressSubBlock_sequences(const ZSTD_fseCTables_t* fseTables,
|
||||||
|
const ZSTD_fseCTablesMetadata_t* fseMetadata,
|
||||||
|
const seqDef* sequences, size_t nbSeq,
|
||||||
|
const BYTE* llCode, const BYTE* mlCode, const BYTE* ofCode,
|
||||||
|
const ZSTD_CCtx_params* cctxParams,
|
||||||
|
void* dst, size_t dstCapacity,
|
||||||
|
const int bmi2, int writeEntropy)
|
||||||
|
{
|
||||||
|
const int longOffsets = cctxParams->cParams.windowLog > STREAM_ACCUMULATOR_MIN;
|
||||||
|
BYTE* const ostart = (BYTE*)dst;
|
||||||
|
BYTE* const oend = ostart + dstCapacity;
|
||||||
|
BYTE* op = ostart;
|
||||||
|
BYTE* seqHead;
|
||||||
|
|
||||||
|
DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (nbSeq=%zu, writeEntropy=%d, longOffsets=%d)", nbSeq, writeEntropy, longOffsets);
|
||||||
|
|
||||||
|
/* Sequences Header */
|
||||||
|
RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/,
|
||||||
|
dstSize_tooSmall);
|
||||||
|
if (nbSeq < 0x7F)
|
||||||
|
*op++ = (BYTE)nbSeq;
|
||||||
|
else if (nbSeq < LONGNBSEQ)
|
||||||
|
op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2;
|
||||||
|
else
|
||||||
|
op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3;
|
||||||
|
if (writeEntropy && nbSeq == 0) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if (nbSeq==0) {
|
||||||
|
return op - ostart;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* seqHead : flags for FSE encoding type */
|
||||||
|
seqHead = op++;
|
||||||
|
|
||||||
|
DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (seqHeadSize=%u)", (unsigned)(op-ostart));
|
||||||
|
|
||||||
|
if (writeEntropy) {
|
||||||
|
const U32 LLtype = fseMetadata->llType;
|
||||||
|
const U32 Offtype = fseMetadata->ofType;
|
||||||
|
const U32 MLtype = fseMetadata->mlType;
|
||||||
|
DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (fseTablesSize=%zu)", fseMetadata->fseTablesSize);
|
||||||
|
*seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2));
|
||||||
|
memcpy(op, fseMetadata->fseTablesBuffer, fseMetadata->fseTablesSize);
|
||||||
|
op += fseMetadata->fseTablesSize;
|
||||||
|
} else {
|
||||||
|
const U32 repeat = set_repeat;
|
||||||
|
*seqHead = (BYTE)((repeat<<6) + (repeat<<4) + (repeat<<2));
|
||||||
|
}
|
||||||
|
|
||||||
|
{ size_t const bitstreamSize = ZSTD_encodeSequences(
|
||||||
|
op, oend - op,
|
||||||
|
fseTables->matchlengthCTable, mlCode,
|
||||||
|
fseTables->offcodeCTable, ofCode,
|
||||||
|
fseTables->litlengthCTable, llCode,
|
||||||
|
sequences, nbSeq,
|
||||||
|
longOffsets, bmi2);
|
||||||
|
FORWARD_IF_ERROR(bitstreamSize);
|
||||||
|
op += bitstreamSize;
|
||||||
|
/* zstd versions <= 1.3.4 mistakenly report corruption when
|
||||||
|
* FSE_readNCount() receives a buffer < 4 bytes.
|
||||||
|
* Fixed by https://github.com/facebook/zstd/pull/1146.
|
||||||
|
* This can happen when the last set_compressed table present is 2
|
||||||
|
* bytes and the bitstream is only one byte.
|
||||||
|
* In this exceedingly rare case, we will simply emit an uncompressed
|
||||||
|
* block, since it isn't worth optimizing.
|
||||||
|
*/
|
||||||
|
if (writeEntropy && fseMetadata->lastCountSize && fseMetadata->lastCountSize + bitstreamSize < 4) {
|
||||||
|
/* NCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */
|
||||||
|
assert(fseMetadata->lastCountSize + bitstreamSize == 3);
|
||||||
|
DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by "
|
||||||
|
"emitting an uncompressed block.");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
DEBUGLOG(5, "ZSTD_compressSubBlock_sequences (bitstreamSize=%zu)", bitstreamSize);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* zstd versions <= 1.4.0 mistakenly report error when
|
||||||
|
* sequences section body size is less than 3 bytes.
|
||||||
|
* Fixed by https://github.com/facebook/zstd/pull/1664.
|
||||||
|
* This can happen when the previous sequences section block is compressed
|
||||||
|
* with rle mode and the current block's sequences section is compressed
|
||||||
|
* with repeat mode where sequences section body size can be 1 byte.
|
||||||
|
*/
|
||||||
|
if (op-seqHead < 4) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return op - ostart;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** ZSTD_compressSubBlock() :
|
||||||
|
* Compresses a single sub-block.
|
||||||
|
* @return : compressed size of the sub-block
|
||||||
|
* Or 0 if it failed to compress. */
|
||||||
|
static size_t ZSTD_compressSubBlock(const ZSTD_entropyCTables_t* entropy,
|
||||||
|
const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
|
||||||
|
const seqDef* sequences, size_t nbSeq,
|
||||||
|
const BYTE* literals, size_t litSize,
|
||||||
|
const BYTE* llCode, const BYTE* mlCode, const BYTE* ofCode,
|
||||||
|
const ZSTD_CCtx_params* cctxParams,
|
||||||
|
void* dst, size_t dstCapacity,
|
||||||
|
const int bmi2, int writeEntropy, U32 lastBlock)
|
||||||
|
{
|
||||||
|
BYTE* const ostart = (BYTE*)dst;
|
||||||
|
BYTE* const oend = ostart + dstCapacity;
|
||||||
|
BYTE* op = ostart + ZSTD_blockHeaderSize;
|
||||||
|
DEBUGLOG(5, "ZSTD_compressSubBlock (litSize=%zu, nbSeq=%zu, writeEntropy=%d, lastBlock=%d)",
|
||||||
|
litSize, nbSeq, writeEntropy, lastBlock);
|
||||||
|
{ size_t cLitSize = ZSTD_compressSubBlock_literal((const HUF_CElt*)entropy->huf.CTable,
|
||||||
|
&entropyMetadata->hufMetadata, literals, litSize,
|
||||||
|
op, oend-op, bmi2, writeEntropy);
|
||||||
|
FORWARD_IF_ERROR(cLitSize);
|
||||||
|
if (cLitSize == 0) return 0;
|
||||||
|
op += cLitSize;
|
||||||
|
}
|
||||||
|
{ size_t cSeqSize = ZSTD_compressSubBlock_sequences(&entropy->fse,
|
||||||
|
&entropyMetadata->fseMetadata,
|
||||||
|
sequences, nbSeq,
|
||||||
|
llCode, mlCode, ofCode,
|
||||||
|
cctxParams,
|
||||||
|
op, oend-op,
|
||||||
|
bmi2, writeEntropy);
|
||||||
|
FORWARD_IF_ERROR(cSeqSize);
|
||||||
|
if (cSeqSize == 0) return 0;
|
||||||
|
op += cSeqSize;
|
||||||
|
}
|
||||||
|
/* Write block header */
|
||||||
|
{ size_t cSize = (op-ostart)-ZSTD_blockHeaderSize;
|
||||||
|
U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
|
||||||
|
MEM_writeLE24(ostart, cBlockHeader24);
|
||||||
|
}
|
||||||
|
return op-ostart;
|
||||||
|
}
|
||||||
|
|
||||||
|
static size_t ZSTD_estimateSubBlockSize_literal(const BYTE* literals, size_t litSize,
|
||||||
|
const ZSTD_hufCTables_t* huf,
|
||||||
|
const ZSTD_hufCTablesMetadata_t* hufMetadata,
|
||||||
|
void* workspace, size_t wkspSize,
|
||||||
|
int writeEntropy)
|
||||||
|
{
|
||||||
|
unsigned* const countWksp = (unsigned*)workspace;
|
||||||
|
unsigned maxSymbolValue = 255;
|
||||||
|
size_t literalSectionHeaderSize = 3; /* Use hard coded size of 3 bytes */
|
||||||
|
|
||||||
|
if (hufMetadata->hType == set_basic) return litSize;
|
||||||
|
else if (hufMetadata->hType == set_rle) return 1;
|
||||||
|
else if (hufMetadata->hType == set_compressed) {
|
||||||
|
size_t const largest = HIST_count_wksp (countWksp, &maxSymbolValue, (const BYTE*)literals, litSize, workspace, wkspSize);
|
||||||
|
if (ZSTD_isError(largest)) return litSize;
|
||||||
|
{ size_t cLitSizeEstimate = HUF_estimateCompressedSize((const HUF_CElt*)huf->CTable, countWksp, maxSymbolValue);
|
||||||
|
if (writeEntropy) cLitSizeEstimate += hufMetadata->hufDesSize;
|
||||||
|
return cLitSizeEstimate + literalSectionHeaderSize;
|
||||||
|
} }
|
||||||
|
assert(0); /* impossible */
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static size_t ZSTD_estimateSubBlockSize_symbolType(symbolEncodingType_e type,
|
||||||
|
const BYTE* codeTable, unsigned maxCode,
|
||||||
|
size_t nbSeq, const FSE_CTable* fseCTable,
|
||||||
|
const U32* additionalBits,
|
||||||
|
short const* defaultNorm, U32 defaultNormLog,
|
||||||
|
void* workspace, size_t wkspSize)
|
||||||
|
{
|
||||||
|
unsigned* const countWksp = (unsigned*)workspace;
|
||||||
|
const BYTE* ctp = codeTable;
|
||||||
|
const BYTE* const ctStart = ctp;
|
||||||
|
const BYTE* const ctEnd = ctStart + nbSeq;
|
||||||
|
size_t cSymbolTypeSizeEstimateInBits = 0;
|
||||||
|
unsigned max = maxCode;
|
||||||
|
|
||||||
|
HIST_countFast_wksp(countWksp, &max, codeTable, nbSeq, workspace, wkspSize); /* can't fail */
|
||||||
|
if (type == set_basic) {
|
||||||
|
cSymbolTypeSizeEstimateInBits = ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, countWksp, max);
|
||||||
|
} else if (type == set_rle) {
|
||||||
|
cSymbolTypeSizeEstimateInBits = 0;
|
||||||
|
} else if (type == set_compressed || type == set_repeat) {
|
||||||
|
cSymbolTypeSizeEstimateInBits = ZSTD_fseBitCost(fseCTable, countWksp, max);
|
||||||
|
}
|
||||||
|
if (ZSTD_isError(cSymbolTypeSizeEstimateInBits)) return nbSeq * 10;
|
||||||
|
while (ctp < ctEnd) {
|
||||||
|
if (additionalBits) cSymbolTypeSizeEstimateInBits += additionalBits[*ctp];
|
||||||
|
else cSymbolTypeSizeEstimateInBits += *ctp; /* for offset, offset code is also the number of additional bits */
|
||||||
|
ctp++;
|
||||||
|
}
|
||||||
|
return cSymbolTypeSizeEstimateInBits / 8;
|
||||||
|
}
|
||||||
|
|
||||||
|
static size_t ZSTD_estimateSubBlockSize_sequences(const BYTE* ofCodeTable,
|
||||||
|
const BYTE* llCodeTable,
|
||||||
|
const BYTE* mlCodeTable,
|
||||||
|
size_t nbSeq,
|
||||||
|
const ZSTD_fseCTables_t* fseTables,
|
||||||
|
const ZSTD_fseCTablesMetadata_t* fseMetadata,
|
||||||
|
void* workspace, size_t wkspSize,
|
||||||
|
int writeEntropy)
|
||||||
|
{
|
||||||
|
size_t sequencesSectionHeaderSize = 3; /* Use hard coded size of 3 bytes */
|
||||||
|
size_t cSeqSizeEstimate = 0;
|
||||||
|
cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->ofType, ofCodeTable, MaxOff,
|
||||||
|
nbSeq, fseTables->offcodeCTable, NULL,
|
||||||
|
OF_defaultNorm, OF_defaultNormLog,
|
||||||
|
workspace, wkspSize);
|
||||||
|
cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->llType, llCodeTable, MaxLL,
|
||||||
|
nbSeq, fseTables->litlengthCTable, LL_bits,
|
||||||
|
LL_defaultNorm, LL_defaultNormLog,
|
||||||
|
workspace, wkspSize);
|
||||||
|
cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->mlType, mlCodeTable, MaxML,
|
||||||
|
nbSeq, fseTables->matchlengthCTable, ML_bits,
|
||||||
|
ML_defaultNorm, ML_defaultNormLog,
|
||||||
|
workspace, wkspSize);
|
||||||
|
if (writeEntropy) cSeqSizeEstimate += fseMetadata->fseTablesSize;
|
||||||
|
return cSeqSizeEstimate + sequencesSectionHeaderSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
static size_t ZSTD_estimateSubBlockSize(const BYTE* literals, size_t litSize,
|
||||||
|
const BYTE* ofCodeTable,
|
||||||
|
const BYTE* llCodeTable,
|
||||||
|
const BYTE* mlCodeTable,
|
||||||
|
size_t nbSeq,
|
||||||
|
const ZSTD_entropyCTables_t* entropy,
|
||||||
|
const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
|
||||||
|
void* workspace, size_t wkspSize,
|
||||||
|
int writeEntropy) {
|
||||||
|
size_t cSizeEstimate = 0;
|
||||||
|
cSizeEstimate += ZSTD_estimateSubBlockSize_literal(literals, litSize,
|
||||||
|
&entropy->huf, &entropyMetadata->hufMetadata,
|
||||||
|
workspace, wkspSize, writeEntropy);
|
||||||
|
cSizeEstimate += ZSTD_estimateSubBlockSize_sequences(ofCodeTable, llCodeTable, mlCodeTable,
|
||||||
|
nbSeq, &entropy->fse, &entropyMetadata->fseMetadata,
|
||||||
|
workspace, wkspSize, writeEntropy);
|
||||||
|
return cSizeEstimate + ZSTD_blockHeaderSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** ZSTD_compressSubBlock_multi() :
|
||||||
|
* Breaks super-block into multiple sub-blocks and compresses them.
|
||||||
|
* Entropy will be written to the first block.
|
||||||
|
* The following blocks will use repeat mode to compress.
|
||||||
|
* All sub-blocks are compressed blocks (no raw or rle blocks).
|
||||||
|
* @return : compressed size of the super block (which is multiple ZSTD blocks)
|
||||||
|
* Or 0 if it failed to compress. */
|
||||||
|
static size_t ZSTD_compressSubBlock_multi(const seqStore_t* seqStorePtr,
|
||||||
|
const ZSTD_entropyCTables_t* entropy,
|
||||||
|
const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
|
||||||
|
const ZSTD_CCtx_params* cctxParams,
|
||||||
|
void* dst, size_t dstCapacity,
|
||||||
|
const int bmi2, U32 lastBlock,
|
||||||
|
void* workspace, size_t wkspSize)
|
||||||
|
{
|
||||||
|
const seqDef* const sstart = seqStorePtr->sequencesStart;
|
||||||
|
const seqDef* const send = seqStorePtr->sequences;
|
||||||
|
const seqDef* sp = sstart;
|
||||||
|
const BYTE* const lstart = seqStorePtr->litStart;
|
||||||
|
const BYTE* const lend = seqStorePtr->lit;
|
||||||
|
const BYTE* lp = lstart;
|
||||||
|
BYTE* const ostart = (BYTE*)dst;
|
||||||
|
BYTE* const oend = ostart + dstCapacity;
|
||||||
|
BYTE* op = ostart;
|
||||||
|
const BYTE* llCodePtr = seqStorePtr->llCode;
|
||||||
|
const BYTE* mlCodePtr = seqStorePtr->mlCode;
|
||||||
|
const BYTE* ofCodePtr = seqStorePtr->ofCode;
|
||||||
|
size_t targetCBlockSize = cctxParams->targetCBlockSize;
|
||||||
|
size_t litSize, seqCount;
|
||||||
|
int writeEntropy = 1;
|
||||||
|
size_t remaining = ZSTD_seqDecompressedSize(sstart, send-sstart, lend-lstart);
|
||||||
|
size_t cBlockSizeEstimate = 0;
|
||||||
|
|
||||||
|
DEBUGLOG(5, "ZSTD_compressSubBlock_multi (litSize=%u, nbSeq=%u)",
|
||||||
|
(unsigned)(lend-lp), (unsigned)(send-sstart));
|
||||||
|
|
||||||
|
litSize = 0;
|
||||||
|
seqCount = 0;
|
||||||
|
while (sp + seqCount < send) {
|
||||||
|
// TODO this is crude estimate for now...
|
||||||
|
// Ask Yann, Nick for feedback.
|
||||||
|
const seqDef* const sequence = sp + seqCount;
|
||||||
|
const U32 lastSequence = sequence+1 == send;
|
||||||
|
litSize = (sequence == send) ? (size_t)(lend-lp) : litSize + sequence->litLength;
|
||||||
|
seqCount++;
|
||||||
|
cBlockSizeEstimate = ZSTD_estimateSubBlockSize(lp, litSize, ofCodePtr, llCodePtr, mlCodePtr, seqCount,
|
||||||
|
entropy, entropyMetadata,
|
||||||
|
workspace, wkspSize, writeEntropy);
|
||||||
|
if (cBlockSizeEstimate > targetCBlockSize || lastSequence) {
|
||||||
|
const size_t decompressedSize = ZSTD_seqDecompressedSize(sp, seqCount, litSize);
|
||||||
|
const size_t cSize = ZSTD_compressSubBlock(entropy, entropyMetadata,
|
||||||
|
sp, seqCount,
|
||||||
|
lp, litSize,
|
||||||
|
llCodePtr, mlCodePtr, ofCodePtr,
|
||||||
|
cctxParams,
|
||||||
|
op, oend-op,
|
||||||
|
bmi2, writeEntropy, lastBlock && lastSequence);
|
||||||
|
FORWARD_IF_ERROR(cSize);
|
||||||
|
if (cSize > 0 && cSize < decompressedSize) {
|
||||||
|
assert(remaining >= decompressedSize);
|
||||||
|
remaining -= decompressedSize;
|
||||||
|
sp += seqCount;
|
||||||
|
lp += litSize;
|
||||||
|
op += cSize;
|
||||||
|
llCodePtr += seqCount;
|
||||||
|
mlCodePtr += seqCount;
|
||||||
|
ofCodePtr += seqCount;
|
||||||
|
litSize = 0;
|
||||||
|
seqCount = 0;
|
||||||
|
writeEntropy = 0; // Entropy only needs to be written once
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (remaining) {
|
||||||
|
DEBUGLOG(5, "ZSTD_compressSubBlock_multi failed to compress");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
DEBUGLOG(5, "ZSTD_compressSubBlock_multi compressed");
|
||||||
|
return op-ostart;
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t ZSTD_compressSuperBlock(ZSTD_CCtx* zc,
|
||||||
|
void* dst, size_t dstCapacity,
|
||||||
|
unsigned lastBlock) {
|
||||||
|
ZSTD_entropyCTablesMetadata_t entropyMetadata;
|
||||||
|
|
||||||
|
FORWARD_IF_ERROR(ZSTD_buildSuperBlockEntropy(&zc->seqStore,
|
||||||
|
&zc->blockState.prevCBlock->entropy,
|
||||||
|
&zc->blockState.nextCBlock->entropy,
|
||||||
|
&zc->appliedParams,
|
||||||
|
&entropyMetadata,
|
||||||
|
zc->entropyWorkspace, HUF_WORKSPACE_SIZE /* statically allocated in resetCCtx */));
|
||||||
|
|
||||||
|
return ZSTD_compressSubBlock_multi(&zc->seqStore,
|
||||||
|
&zc->blockState.nextCBlock->entropy,
|
||||||
|
&entropyMetadata,
|
||||||
|
&zc->appliedParams,
|
||||||
|
dst, dstCapacity,
|
||||||
|
zc->bmi2, lastBlock,
|
||||||
|
zc->entropyWorkspace, HUF_WORKSPACE_SIZE /* statically allocated in resetCCtx */);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t ZSTD_noCompressSuperBlock(void* dst, size_t dstCapacity,
|
||||||
|
const void* src, size_t srcSize,
|
||||||
|
size_t targetCBlockSize,
|
||||||
|
unsigned lastBlock) {
|
||||||
|
const BYTE* const istart = (const BYTE*)src;
|
||||||
|
const BYTE* const iend = istart + srcSize;
|
||||||
|
const BYTE* ip = istart;
|
||||||
|
BYTE* const ostart = (BYTE*)dst;
|
||||||
|
BYTE* const oend = ostart + dstCapacity;
|
||||||
|
BYTE* op = ostart;
|
||||||
|
DEBUGLOG(5, "ZSTD_noCompressSuperBlock (dstCapacity=%zu, srcSize=%zu, targetCBlockSize=%zu)",
|
||||||
|
dstCapacity, srcSize, targetCBlockSize);
|
||||||
|
while (ip < iend) {
|
||||||
|
size_t remaining = iend-ip;
|
||||||
|
unsigned lastSubBlock = remaining <= targetCBlockSize;
|
||||||
|
size_t blockSize = lastSubBlock ? remaining : targetCBlockSize;
|
||||||
|
size_t cSize = ZSTD_noCompressBlock(op, oend-op, ip, blockSize, lastSubBlock && lastBlock);
|
||||||
|
FORWARD_IF_ERROR(cSize);
|
||||||
|
ip += blockSize;
|
||||||
|
op += cSize;
|
||||||
|
}
|
||||||
|
return op-ostart;
|
||||||
|
}
|
||||||
41
lib/compress/zstd_compress_superblock.h
Normal file
41
lib/compress/zstd_compress_superblock.h
Normal file
@ -0,0 +1,41 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
|
||||||
|
* All rights reserved.
|
||||||
|
*
|
||||||
|
* This source code is licensed under both the BSD-style license (found in the
|
||||||
|
* LICENSE file in the root directory of this source tree) and the GPLv2 (found
|
||||||
|
* in the COPYING file in the root directory of this source tree).
|
||||||
|
* You may select, at your option, one of the above-listed licenses.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef ZSTD_COMPRESS_ADVANCED_H
|
||||||
|
#define ZSTD_COMPRESS_ADVANCED_H
|
||||||
|
|
||||||
|
/*-*************************************
|
||||||
|
* Dependencies
|
||||||
|
***************************************/
|
||||||
|
|
||||||
|
#include "zstd.h" /* ZSTD_CCtx */
|
||||||
|
|
||||||
|
/*-*************************************
|
||||||
|
* Target Compressed Block Size
|
||||||
|
***************************************/
|
||||||
|
|
||||||
|
/* 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. */
|
||||||
|
size_t ZSTD_compressSuperBlock(ZSTD_CCtx* zc,
|
||||||
|
void* dst, size_t dstCapacity,
|
||||||
|
unsigned lastBlock);
|
||||||
|
|
||||||
|
/* ZSTD_noCompressSuperBlock() :
|
||||||
|
* Used to break a super block into multiple uncompressed sub blocks
|
||||||
|
* when targetCBlockSize is being used.
|
||||||
|
* The given block will be broken into multiple uncompressed sub blocks that are
|
||||||
|
* around targetCBlockSize. */
|
||||||
|
size_t ZSTD_noCompressSuperBlock(void* dst, size_t dstCapacity,
|
||||||
|
const void* src, size_t srcSize,
|
||||||
|
size_t targetCBlockSize,
|
||||||
|
unsigned lastBlock);
|
||||||
|
|
||||||
|
#endif /* ZSTD_COMPRESS_ADVANCED_H */
|
||||||
Loading…
Reference in New Issue
Block a user