zstd_v06.c File Reference

#include "zstd_v06.h"
#include <stddef.h>
#include <string.h>
#include <stdlib.h>
#include "../common/error_private.h"

Data Structures
struct	ZSTDv06_match_t
struct	ZSTDv06_optimal_t
struct	ZSTDv06_stats_t
struct	seqStore_t
struct	BITv06_DStream_t
struct	FSEv06_DState_t
struct	FSEv06_DTableHeader
struct	FSEv06_decode_t
struct	HUFv06_DEltX2
struct	HUFv06_DEltX4
struct	sortedSymbol_t
struct	algo_time_t
struct	ZSTDv06_DCtx_s
struct	blockProperties_t
struct	seq_t
struct	seqState_t
struct	ZBUFFv06_DCtx_s

Macros
#define	MEM_H_MODULE
#define	MEM_STATIC   static /* this version may generate warnings for unused static functions; disable the relevant warning */
#define	ZSTDv06_STATIC_H
#define	ZSTDv06_FRAMEHEADERSIZE_MAX   13 /* for static allocation */
#define	ZSTDv06_BLOCKSIZE_MAX   (128 * 1024) /* define, for static allocation */
#define	ZSTDv06_CCOMMON_H_MODULE
#define	MIN(a, b)
#define	MAX(a, b)
#define	ZSTDv06_DICT_MAGIC   0xEC30A436
#define	ZSTDv06_REP_NUM   3
#define	ZSTDv06_REP_INIT   ZSTDv06_REP_NUM
#define	ZSTDv06_REP_MOVE   (ZSTDv06_REP_NUM-1)
#define	KB   *(1 <<10)
#define	MB   *(1 <<20)
#define	GB   *(1U<<30)
#define	BIT7   128
#define	BIT6   64
#define	BIT5   32
#define	BIT4   16
#define	BIT1   2
#define	BIT0   1
#define	ZSTDv06_WINDOWLOG_ABSOLUTEMIN   12
#define	ZSTDv06_BLOCKHEADERSIZE   3 /* because C standard does not allow a static const value to be defined using another static const value .... :( */
#define	MIN_SEQUENCES_SIZE   1 /* nbSeq==0 */
#define	MIN_CBLOCK_SIZE   (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */) /* for a non-null block */
#define	HufLog   12
#define	IS_HUF   0
#define	IS_PCH   1
#define	IS_RAW   2
#define	IS_RLE   3
#define	LONGNBSEQ   0x7F00
#define	MINMATCH   3
#define	EQUAL_READ32   4
#define	REPCODE_STARTVALUE   1
#define	Litbits   8
#define	MaxLit   ((1<<Litbits) - 1)
#define	MaxML   52
#define	MaxLL   35
#define	MaxOff   28
#define	MaxSeq   MAX(MaxLL, MaxML) /* Assumption : MaxOff < MaxLL,MaxML */
#define	MLFSELog   9
#define	LLFSELog   9
#define	OffFSELog   8
#define	FSEv06_ENCODING_RAW   0
#define	FSEv06_ENCODING_RLE   1
#define	FSEv06_ENCODING_STATIC   2
#define	FSEv06_ENCODING_DYNAMIC   3
#define	ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
#define	COPY8(d, s)
#define	WILDCOPY_OVERLENGTH   8
#define	FSEv06_H
#define	BITSTREAM_H_MODULE
#define	FSEv06_STATIC_H
#define	FSEv06_NCOUNTBOUND   512
#define	FSEv06_BLOCKBOUND(size)
#define	FSEv06_COMPRESSBOUND(size)
#define	FSEv06_DTABLE_SIZE_U32(maxTableLog)
#define	FSEv06_MAX_MEMORY_USAGE   14
#define	FSEv06_DEFAULT_MEMORY_USAGE   13
#define	FSEv06_MAX_SYMBOL_VALUE   255
#define	FSEv06_FUNCTION_TYPE   BYTE
#define	FSEv06_FUNCTION_EXTENSION
#define	FSEv06_DECODE_TYPE   FSEv06_decode_t
#define	FSEv06_MAX_TABLELOG   (FSEv06_MAX_MEMORY_USAGE-2)
#define	FSEv06_MAX_TABLESIZE   (1U<<FSEv06_MAX_TABLELOG)
#define	FSEv06_MAXTABLESIZE_MASK   (FSEv06_MAX_TABLESIZE-1)
#define	FSEv06_DEFAULT_TABLELOG   (FSEv06_DEFAULT_MEMORY_USAGE-2)
#define	FSEv06_MIN_TABLELOG   5
#define	FSEv06_TABLELOG_ABSOLUTE_MAX   15
#define	FSEv06_TABLESTEP(tableSize)
#define	FORCE_INLINE   static
#define	FSEv06_isError   ERR_isError
#define	FSEv06_STATIC_ASSERT(c)
#define	FSEv06_CAT(X, Y)
#define	FSEv06_FUNCTION_NAME(X, Y)
#define	FSEv06_TYPE_NAME(X, Y)
#define	FSEv06_GETSYMBOL(statePtr)
#define	HUFv06_H
#define	HUFv06_STATIC_H
#define	HUFv06_CTABLEBOUND   129
#define	HUFv06_BLOCKBOUND(size)
#define	HUFv06_COMPRESSBOUND(size)
#define	HUFv06_DTABLE_SIZE(maxTableLog)
#define	HUFv06_CREATE_STATIC_DTABLEX2(DTable, maxTableLog)
#define	HUFv06_CREATE_STATIC_DTABLEX4(DTable, maxTableLog)
#define	HUFv06_CREATE_STATIC_DTABLEX6(DTable, maxTableLog)
#define	HUFv06_ABSOLUTEMAX_TABLELOG   16 /* absolute limit of HUFv06_MAX_TABLELOG. Beyond that value, code does not work */
#define	HUFv06_MAX_TABLELOG   12 /* max configured tableLog (for static allocation); can be modified up to HUFv06_ABSOLUTEMAX_TABLELOG */
#define	HUFv06_DEFAULT_TABLELOG   HUFv06_MAX_TABLELOG /* tableLog by default, when not specified */
#define	HUFv06_MAX_SYMBOL_VALUE   255
#define	inline   /* disable inline */
#define	HUFv06_STATIC_ASSERT(c)
#define	HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
#define	HUFv06_DECODE_SYMBOLX2_1(ptr, DStreamPtr)
#define	HUFv06_DECODE_SYMBOLX2_2(ptr, DStreamPtr)
#define	HUFv06_DECODE_SYMBOLX4_0(ptr, DStreamPtr)
#define	HUFv06_DECODE_SYMBOLX4_1(ptr, DStreamPtr)
#define	HUFv06_DECODE_SYMBOLX4_2(ptr, DStreamPtr)
#define	ZSTDv06_HEAPMODE   1
#define	ZSTDv06_isError   ERR_isError /* for inlining */
#define	FSEv06_isError   ERR_isError
#define	HUFv06_isError   ERR_isError

Typedefs
typedef unsigned	FSEv06_DTable
typedef size_t(*	decompressionAlgo) (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)

Enumerations
enum	blockType_t { bt_compressed , bt_raw , bt_rle , bt_end }
enum	BITv06_DStream_status { BITv06_DStream_unfinished = 0 , BITv06_DStream_endOfBuffer = 1 , BITv06_DStream_completed = 2 , BITv06_DStream_overflow = 3 }
enum	ZSTDv06_dStage { ZSTDds_getFrameHeaderSize , ZSTDds_decodeFrameHeader , ZSTDds_decodeBlockHeader , ZSTDds_decompressBlock }
enum	ZBUFFv06_dStage {   ZBUFFds_init , ZBUFFds_loadHeader , ZBUFFds_read , ZBUFFds_load ,   ZBUFFds_flush }

Functions
MEM_STATIC unsigned	MEM_32bits (void)
MEM_STATIC unsigned	MEM_64bits (void)
MEM_STATIC unsigned	MEM_isLittleEndian (void)
MEM_STATIC U16	MEM_read16 (const void *memPtr)
MEM_STATIC U32	MEM_read32 (const void *memPtr)
MEM_STATIC U64	MEM_read64 (const void *memPtr)
MEM_STATIC void	MEM_write16 (void *memPtr, U16 value)
MEM_STATIC U32	MEM_swap32 (U32 in)
MEM_STATIC U64	MEM_swap64 (U64 in)
MEM_STATIC U16	MEM_readLE16 (const void *memPtr)
MEM_STATIC void	MEM_writeLE16 (void *memPtr, U16 val)
MEM_STATIC U32	MEM_readLE32 (const void *memPtr)
MEM_STATIC U64	MEM_readLE64 (const void *memPtr)
MEM_STATIC size_t	MEM_readLEST (const void *memPtr)
ZSTDLIBv06_API size_t	ZSTDv06_decompress_usingPreparedDCtx (ZSTDv06_DCtx *dctx, const ZSTDv06_DCtx *preparedDCtx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
ZSTDLIBv06_API size_t	ZSTDv06_decompressBegin (ZSTDv06_DCtx *dctx)
ZSTDLIBv06_API size_t	ZSTDv06_decompressBlock (ZSTDv06_DCtx *dctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
MEM_STATIC void	ZSTDv06_wildcopy (void *dst, const void *src, ptrdiff_t length)
void	ZSTDv06_seqToCodes (const seqStore_t *seqStorePtr, size_t const nbSeq)
size_t	FSEv06_decompress (void *dst, size_t dstCapacity, const void *cSrc, size_t cSrcSize)
size_t	FSEv06_compressBound (size_t size)
unsigned	FSEv06_isError (size_t code)
const char *	FSEv06_getErrorName (size_t code)
size_t	FSEv06_readNCount (short *normalizedCounter, unsigned *maxSymbolValuePtr, unsigned *tableLogPtr, const void *rBuffer, size_t rBuffSize)
FSEv06_DTable *	FSEv06_createDTable (unsigned tableLog)
void	FSEv06_freeDTable (FSEv06_DTable *dt)
size_t	FSEv06_buildDTable (FSEv06_DTable *dt, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
size_t	FSEv06_decompress_usingDTable (void *dst, size_t dstCapacity, const void *cSrc, size_t cSrcSize, const FSEv06_DTable *dt)
MEM_STATIC size_t	BITv06_initDStream (BITv06_DStream_t *bitD, const void *srcBuffer, size_t srcSize)
MEM_STATIC size_t	BITv06_readBits (BITv06_DStream_t *bitD, unsigned nbBits)
MEM_STATIC BITv06_DStream_status	BITv06_reloadDStream (BITv06_DStream_t *bitD)
MEM_STATIC unsigned	BITv06_endOfDStream (const BITv06_DStream_t *bitD)
MEM_STATIC size_t	BITv06_readBitsFast (BITv06_DStream_t *bitD, unsigned nbBits)
MEM_STATIC unsigned	BITv06_highbit32 (U32 val)
MEM_STATIC size_t	BITv06_lookBits (const BITv06_DStream_t *bitD, U32 nbBits)
MEM_STATIC size_t	BITv06_lookBitsFast (const BITv06_DStream_t *bitD, U32 nbBits)
MEM_STATIC void	BITv06_skipBits (BITv06_DStream_t *bitD, U32 nbBits)
MEM_STATIC size_t	BITv06_readBits (BITv06_DStream_t *bitD, U32 nbBits)
MEM_STATIC size_t	BITv06_readBitsFast (BITv06_DStream_t *bitD, U32 nbBits)
size_t	FSEv06_countFast (unsigned *count, unsigned *maxSymbolValuePtr, const void *src, size_t srcSize)
size_t	FSEv06_buildDTable_raw (FSEv06_DTable *dt, unsigned nbBits)
size_t	FSEv06_buildDTable_rle (FSEv06_DTable *dt, unsigned char symbolValue)
MEM_STATIC BYTE	FSEv06_peekSymbol (const FSEv06_DState_t *DStatePtr)
MEM_STATIC void	FSEv06_updateState (FSEv06_DState_t *DStatePtr, BITv06_DStream_t *bitD)
FORCE_INLINE size_t	FSEv06_decompress_usingDTable_generic (void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const FSEv06_DTable *dt, const unsigned fast)
size_t	HUFv06_decompress (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t	HUFv06_compressBound (size_t size)
size_t	HUFv06_decompress4X2 (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t	HUFv06_decompress4X4 (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t	HUFv06_readDTableX2 (unsigned short *DTable, const void *src, size_t srcSize)
size_t	HUFv06_readDTableX4 (unsigned *DTable, const void *src, size_t srcSize)
size_t	HUFv06_decompress4X2_usingDTable (void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const unsigned short *DTable)
size_t	HUFv06_decompress4X4_usingDTable (void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const unsigned *DTable)
size_t	HUFv06_decompress1X2 (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t	HUFv06_decompress1X4 (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t	HUFv06_decompress1X2_usingDTable (void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const unsigned short *DTable)
size_t	HUFv06_decompress1X4_usingDTable (void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const unsigned *DTable)
MEM_STATIC size_t	HUFv06_readStats (BYTE *huffWeight, size_t hwSize, U32 *rankStats, U32 *nbSymbolsPtr, U32 *tableLogPtr, const void *src, size_t srcSize)
size_t	HUFv06_readDTableX4 (U32 *DTable, const void *src, size_t srcSize)
size_t	HUFv06_decompress1X4_usingDTable (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const U32 *DTable)
size_t	HUFv06_decompress4X4_usingDTable (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const U32 *DTable)
unsigned	ZSTDv06_isError (size_t code)
const char *	ZSTDv06_getErrorName (size_t code)
unsigned	ZBUFFv06_isError (size_t errorCode)
const char *	ZBUFFv06_getErrorName (size_t errorCode)
size_t	ZSTDv06_sizeofDCtx (void)
ZSTDv06_DCtx *	ZSTDv06_createDCtx (void)
size_t	ZSTDv06_freeDCtx (ZSTDv06_DCtx *dctx)
void	ZSTDv06_copyDCtx (ZSTDv06_DCtx *dstDCtx, const ZSTDv06_DCtx *srcDCtx)
size_t	ZSTDv06_getFrameParams (ZSTDv06_frameParams *fparamsPtr, const void *src, size_t srcSize)
size_t	ZSTDv06_decompress_usingDict (ZSTDv06_DCtx *dctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const void *dict, size_t dictSize)
size_t	ZSTDv06_decompressDCtx (ZSTDv06_DCtx *dctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
size_t	ZSTDv06_decompress (void *dst, size_t dstCapacity, const void *src, size_t srcSize)
void	ZSTDv06_findFrameSizeInfoLegacy (const void *src, size_t srcSize, size_t *cSize, unsigned long long *dBound)
size_t	ZSTDv06_nextSrcSizeToDecompress (ZSTDv06_DCtx *dctx)
size_t	ZSTDv06_decompressContinue (ZSTDv06_DCtx *dctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
size_t	ZSTDv06_decompressBegin_usingDict (ZSTDv06_DCtx *dctx, const void *dict, size_t dictSize)
ZBUFFv06_DCtx *	ZBUFFv06_createDCtx (void)
size_t	ZBUFFv06_freeDCtx (ZBUFFv06_DCtx *zbd)
size_t	ZBUFFv06_decompressInitDictionary (ZBUFFv06_DCtx *zbd, const void *dict, size_t dictSize)
size_t	ZBUFFv06_decompressInit (ZBUFFv06_DCtx *zbd)
MEM_STATIC size_t	ZBUFFv06_limitCopy (void *dst, size_t dstCapacity, const void *src, size_t srcSize)
size_t	ZBUFFv06_decompressContinue (ZBUFFv06_DCtx *zbd, void *dst, size_t *dstCapacityPtr, const void *src, size_t *srcSizePtr)
size_t	ZBUFFv06_recommendedDInSize (void)
size_t	ZBUFFv06_recommendedDOutSize (void)

Macro Definition Documentation

BIT0

#define BIT0   1

BIT1

#define BIT1   2

BIT4

#define BIT4   16

BIT5

#define BIT5   32

BIT6

#define BIT6   64

BIT7

#define BIT7   128

BITSTREAM_H_MODULE

#define BITSTREAM_H_MODULE

Tutorial :

(Note : these functions only decompress FSE-compressed blocks. If block is uncompressed, use memcpy() instead If block is a single repeated byte, use memset() instead )

The first step is to obtain the normalized frequencies of symbols. This can be performed by FSEv06_readNCount() if it was saved using FSEv06_writeNCount(). 'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short. In practice, that means it's necessary to know 'maxSymbolValue' beforehand, or size the table to handle worst case situations (typically 256). FSEv06_readNCount() will provide 'tableLog' and 'maxSymbolValue'. The result of FSEv06_readNCount() is the number of bytes read from 'rBuffer'. Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that. If there is an error, the function will return an error code, which can be tested using FSEv06_isError().

The next step is to build the decompression tables 'FSEv06_DTable' from 'normalizedCounter'. This is performed by the function FSEv06_buildDTable(). The space required by 'FSEv06_DTable' must be already allocated using FSEv06_createDTable(). If there is an error, the function will return an error code, which can be tested using FSEv06_isError().

FSEv06_DTable can then be used to decompress cSrc, with FSEv06_decompress_usingDTable(). cSrcSize must be strictly correct, otherwise decompression will fail. FSEv06_decompress_usingDTable() result will tell how many bytes were regenerated (<=dstCapacity). If there is an error, the function will return an error code, which can be tested using FSEv06_isError(). (ex: dst buffer too small)

COPY8

#define COPY8	(		d,
			s )

Value:

{ ZSTDv06_copy8(d,s); d+=8; s+=8; }

EQUAL_READ32

#define EQUAL_READ32   4

FORCE_INLINE

#define FORCE_INLINE   static

FSEv06_BLOCKBOUND

#define FSEv06_BLOCKBOUND

(

size

)

Value:

(size + (size>>7))

FSEv06_CAT

#define FSEv06_CAT	(		X,
			Y )

Value:

X##Y

FSEv06_COMPRESSBOUND

#define FSEv06_COMPRESSBOUND

(

size

)

Value:

(FSEv06_NCOUNTBOUND + FSEv06_BLOCKBOUND(size))   /* Macro version, useful for static allocation */

FSEv06_DECODE_TYPE

#define FSEv06_DECODE_TYPE   FSEv06_decode_t

FSEv06_DEFAULT_MEMORY_USAGE

#define FSEv06_DEFAULT_MEMORY_USAGE   13

FSEv06_DEFAULT_TABLELOG

#define FSEv06_DEFAULT_TABLELOG   (FSEv06_DEFAULT_MEMORY_USAGE-2)

FSEv06_DTABLE_SIZE_U32

#define FSEv06_DTABLE_SIZE_U32

(

maxTableLog

)

Value:

(1 + (1<<maxTableLog))

FSEv06_ENCODING_DYNAMIC

#define FSEv06_ENCODING_DYNAMIC   3

FSEv06_ENCODING_RAW

#define FSEv06_ENCODING_RAW   0

FSEv06_ENCODING_RLE

#define FSEv06_ENCODING_RLE   1

FSEv06_ENCODING_STATIC

#define FSEv06_ENCODING_STATIC   2

FSEv06_FUNCTION_EXTENSION

#define FSEv06_FUNCTION_EXTENSION

FSEv06_FUNCTION_NAME

#define FSEv06_FUNCTION_NAME	(		X,
			Y )

Value:

FSEv06_CAT(X,Y)

FSEv06_FUNCTION_TYPE

#define FSEv06_FUNCTION_TYPE   BYTE

FSEv06_GETSYMBOL

#define FSEv06_GETSYMBOL

(

statePtr

)

Value:

fast ? FSEv06_decodeSymbolFast(statePtr, &bitD) : FSEv06_decodeSymbol(statePtr, &bitD)

FSEv06_H

#define FSEv06_H

FSEv06_isError [1/2]

#define FSEv06_isError   ERR_isError

FSEv06_isError [2/2]

#define FSEv06_isError   ERR_isError

FSEv06_MAX_MEMORY_USAGE

#define FSEv06_MAX_MEMORY_USAGE   14

MEMORY_USAGE : Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.) Increasing memory usage improves compression ratio Reduced memory usage can improve speed, due to cache effect Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache

FSEv06_MAX_SYMBOL_VALUE

#define FSEv06_MAX_SYMBOL_VALUE   255

FSEv06_MAX_SYMBOL_VALUE : Maximum symbol value authorized. Required for proper stack allocation

FSEv06_MAX_TABLELOG

#define FSEv06_MAX_TABLELOG   (FSEv06_MAX_MEMORY_USAGE-2)

FSEv06_MAX_TABLESIZE

#define FSEv06_MAX_TABLESIZE   (1U<<FSEv06_MAX_TABLELOG)

FSEv06_MAXTABLESIZE_MASK

#define FSEv06_MAXTABLESIZE_MASK   (FSEv06_MAX_TABLESIZE-1)

FSEv06_MIN_TABLELOG

#define FSEv06_MIN_TABLELOG   5

FSEv06_NCOUNTBOUND

#define FSEv06_NCOUNTBOUND   512

FSEv06_STATIC_ASSERT

#define FSEv06_STATIC_ASSERT

(

c

)

Value:

{ enum { FSEv06_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */

FSEv06_STATIC_H

#define FSEv06_STATIC_H

FSEv06_TABLELOG_ABSOLUTE_MAX

#define FSEv06_TABLELOG_ABSOLUTE_MAX   15

FSEv06_TABLESTEP

#define FSEv06_TABLESTEP

(

tableSize

)

Value:

((tableSize>>1) + (tableSize>>3) + 3)

FSEv06_TYPE_NAME

#define FSEv06_TYPE_NAME	(		X,
			Y )

Value:

FSEv06_CAT(X,Y)

GB

#define GB   *(1U<<30)

HufLog

#define HufLog   12

HUFv06_ABSOLUTEMAX_TABLELOG

#define HUFv06_ABSOLUTEMAX_TABLELOG   16 /* absolute limit of HUFv06_MAX_TABLELOG. Beyond that value, code does not work */

HUFv06_BLOCKBOUND

#define HUFv06_BLOCKBOUND

(

size

)

Value:

(size + (size>>8) + 8)   /* only true if incompressible pre-filtered with fast heuristic */

HUFv06_COMPRESSBOUND

#define HUFv06_COMPRESSBOUND

(

size

)

Value:

(HUFv06_CTABLEBOUND + HUFv06_BLOCKBOUND(size))   /* Macro version, useful for static allocation */

HUFv06_CREATE_STATIC_DTABLEX2

#define HUFv06_CREATE_STATIC_DTABLEX2	(		DTable,
			maxTableLog )

Value:

        unsigned short DTable[HUFv06_DTABLE_SIZE(maxTableLog)] = { maxTableLog }

HUFv06_CREATE_STATIC_DTABLEX4

#define HUFv06_CREATE_STATIC_DTABLEX4	(		DTable,
			maxTableLog )

Value:

        unsigned int DTable[HUFv06_DTABLE_SIZE(maxTableLog)] = { maxTableLog }

HUFv06_CREATE_STATIC_DTABLEX6

#define HUFv06_CREATE_STATIC_DTABLEX6	(		DTable,
			maxTableLog )

Value:

        unsigned int DTable[HUFv06_DTABLE_SIZE(maxTableLog) * 3 / 2] = { maxTableLog }

HUFv06_CTABLEBOUND

#define HUFv06_CTABLEBOUND   129

HUFv06_DECODE_SYMBOLX2_0

#define HUFv06_DECODE_SYMBOLX2_0	(		ptr,
			DStreamPtr )

Value:

    *ptr++ = HUFv06_decodeSymbolX2(DStreamPtr, dt, dtLog)

HUFv06_DECODE_SYMBOLX2_1

#define HUFv06_DECODE_SYMBOLX2_1	(		ptr,
			DStreamPtr )

Value:

    if (MEM_64bits() || (HUFv06_MAX_TABLELOG<=12)) \
        HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr)

HUFv06_DECODE_SYMBOLX2_2

#define HUFv06_DECODE_SYMBOLX2_2	(		ptr,
			DStreamPtr )

Value:

    if (MEM_64bits()) \
        HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr)

HUFv06_DECODE_SYMBOLX4_0

#define HUFv06_DECODE_SYMBOLX4_0	(		ptr,
			DStreamPtr )

Value:

    ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)

HUFv06_DECODE_SYMBOLX4_1

#define HUFv06_DECODE_SYMBOLX4_1	(		ptr,
			DStreamPtr )

Value:

    if (MEM_64bits() || (HUFv06_MAX_TABLELOG<=12)) \
        ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)

HUFv06_DECODE_SYMBOLX4_2

#define HUFv06_DECODE_SYMBOLX4_2	(		ptr,
			DStreamPtr )

Value:

    if (MEM_64bits()) \
        ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)

HUFv06_DEFAULT_TABLELOG

#define HUFv06_DEFAULT_TABLELOG   HUFv06_MAX_TABLELOG /* tableLog by default, when not specified */

HUFv06_DTABLE_SIZE

#define HUFv06_DTABLE_SIZE

(

maxTableLog

)

Value:

(1 + (1<<maxTableLog))

HUFv06_H

#define HUFv06_H

HUFv06_isError

#define HUFv06_isError   ERR_isError

HUFv06_MAX_SYMBOL_VALUE

#define HUFv06_MAX_SYMBOL_VALUE   255

HUFv06_MAX_TABLELOG

#define HUFv06_MAX_TABLELOG   12 /* max configured tableLog (for static allocation); can be modified up to HUFv06_ABSOLUTEMAX_TABLELOG */

HUFv06_STATIC_ASSERT

#define HUFv06_STATIC_ASSERT

(

c

)

Value:

{ enum { HUFv06_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */

HUFv06_STATIC_H

#define HUFv06_STATIC_H

inline

#define inline   /* disable inline */

IS_HUF

#define IS_HUF   0

IS_PCH

#define IS_PCH   1

IS_RAW

#define IS_RAW   2

IS_RLE

#define IS_RLE   3

KB

#define KB   *(1 <<10)

Litbits

#define Litbits   8

LLFSELog

#define LLFSELog   9

LONGNBSEQ

#define LONGNBSEQ   0x7F00

MAX

#define MAX	(		a,
			b )

Value:

((a)>(b) ? (a) : (b))

MaxLit

#define MaxLit   ((1<<Litbits) - 1)

MaxLL

#define MaxLL   35

MaxML

#define MaxML   52

MaxOff

#define MaxOff   28

MaxSeq

#define MaxSeq   MAX(MaxLL, MaxML) /* Assumption : MaxOff < MaxLL,MaxML */

MB

#define MB   *(1 <<20)

MEM_H_MODULE

#define MEM_H_MODULE

MEM_STATIC

#define MEM_STATIC   static /* this version may generate warnings for unused static functions; disable the relevant warning */

MIN

#define MIN	(		a,
			b )

Value:

((a)<(b) ? (a) : (b))

MIN_CBLOCK_SIZE

#define MIN_CBLOCK_SIZE   (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */) /* for a non-null block */

MIN_SEQUENCES_SIZE

#define MIN_SEQUENCES_SIZE   1 /* nbSeq==0 */

MINMATCH

#define MINMATCH   3

MLFSELog

#define MLFSELog   9

OffFSELog

#define OffFSELog   8

REPCODE_STARTVALUE

#define REPCODE_STARTVALUE   1

WILDCOPY_OVERLENGTH

#define WILDCOPY_OVERLENGTH   8

ZSTDv06_wildcopy() : custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0)

ZSTD_CONTENTSIZE_ERROR

#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)

ZSTDv06_BLOCKHEADERSIZE

#define ZSTDv06_BLOCKHEADERSIZE   3 /* because C standard does not allow a static const value to be defined using another static const value .... :( */

ZSTDv06_BLOCKSIZE_MAX

#define ZSTDv06_BLOCKSIZE_MAX   (128 * 1024) /* define, for static allocation */

Block functions produce and decode raw zstd blocks, without frame metadata. User will have to take in charge required information to regenerate data, such as compressed and content sizes.

A few rules to respect :

• Uncompressed block size must be <= ZSTDv06_BLOCKSIZE_MAX (128 KB)
• Compressing or decompressing requires a context structure
  • Use ZSTDv06_createCCtx() and ZSTDv06_createDCtx()
• It is necessary to init context before starting
  • compression : ZSTDv06_compressBegin()
  • decompression : ZSTDv06_decompressBegin()
  • variants _usingDict() are also allowed
  • copyCCtx() and copyDCtx() work too
• When a block is considered not compressible enough, ZSTDv06_compressBlock() result will be zero. In which case, nothing is produced into dst.
  • User must test for such outcome and deal directly with uncompressed data
  • ZSTDv06_decompressBlock() doesn't accept uncompressed data as input !!

ZSTDv06_CCOMMON_H_MODULE

#define ZSTDv06_CCOMMON_H_MODULE

ZSTDv06_DICT_MAGIC

#define ZSTDv06_DICT_MAGIC   0xEC30A436

ZSTDv06_FRAMEHEADERSIZE_MAX

#define ZSTDv06_FRAMEHEADERSIZE_MAX   13 /* for static allocation */

ZSTDv06_HEAPMODE

#define ZSTDv06_HEAPMODE   1

HEAPMODE : Select how default decompression function ZSTDv06_decompress() will allocate memory, in memory stack (0), or in memory heap (1, requires malloc())

ZSTDv06_isError

#define ZSTDv06_isError   ERR_isError /* for inlining */

ZSTDv06_REP_INIT

#define ZSTDv06_REP_INIT   ZSTDv06_REP_NUM

ZSTDv06_REP_MOVE

#define ZSTDv06_REP_MOVE   (ZSTDv06_REP_NUM-1)

ZSTDv06_REP_NUM

#define ZSTDv06_REP_NUM   3

ZSTDv06_STATIC_H

#define ZSTDv06_STATIC_H

ZSTDv06_WINDOWLOG_ABSOLUTEMIN

#define ZSTDv06_WINDOWLOG_ABSOLUTEMIN   12

Typedef Documentation

decompressionAlgo

typedef size_t(* decompressionAlgo) (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)

FSEv06_DTable

typedef unsigned FSEv06_DTable

Constructor and Destructor of FSEv06_DTable. Note that its size depends on 'tableLog'

Enumeration Type Documentation

BITv06_DStream_status

enum BITv06_DStream_status

Enumerator
BITv06_DStream_unfinished
BITv06_DStream_endOfBuffer
BITv06_DStream_completed
BITv06_DStream_overflow

blockType_t

enum blockType_t

Enumerator
bt_compressed
bt_raw
bt_rle
bt_end

ZBUFFv06_dStage

enum ZBUFFv06_dStage

Enumerator
ZBUFFds_init
ZBUFFds_loadHeader
ZBUFFds_read
ZBUFFds_load
ZBUFFds_flush

ZSTDv06_dStage

enum ZSTDv06_dStage

Enumerator
ZSTDds_getFrameHeaderSize
ZSTDds_decodeFrameHeader
ZSTDds_decodeBlockHeader
ZSTDds_decompressBlock

Function Documentation

BITv06_endOfDStream()

MEM_STATIC unsigned BITv06_endOfDStream

(

const BITv06_DStream_t *

DStream

)

BITv06_endOfDStream() :

Returns

Tells if DStream has exactly reached its end (all bits consumed).

BITv06_highbit32()

MEM_STATIC unsigned BITv06_highbit32

(

U32

val

)

BITv06_initDStream()

MEM_STATIC size_t BITv06_initDStream	(	BITv06_DStream_t *	bitD,
		const void *	srcBuffer,
		size_t	srcSize )

BITv06_initDStream() : Initialize a BITv06_DStream_t. bitD : a pointer to an already allocated BITv06_DStream_t structure. srcSize must be the exact size of the bitStream, in bytes.

Returns

: size of stream (== srcSize) or an errorCode if a problem is detected

BITv06_lookBits()

MEM_STATIC size_t BITv06_lookBits	(	const BITv06_DStream_t *	bitD,
		U32	nbBits )

BITv06_lookBitsFast()

MEM_STATIC size_t BITv06_lookBitsFast	(	const BITv06_DStream_t *	bitD,
		U32	nbBits )

BITv06_lookBitsFast() : unsafe version; only works only if nbBits >= 1

BITv06_readBits() [1/2]

MEM_STATIC size_t BITv06_readBits	(	BITv06_DStream_t *	bitD,
		U32	nbBits )

BITv06_readBits() [2/2]

MEM_STATIC size_t BITv06_readBits	(	BITv06_DStream_t *	bitD,
		unsigned	nbBits )

BITv06_readBitsFast() [1/2]

MEM_STATIC size_t BITv06_readBitsFast	(	BITv06_DStream_t *	bitD,
		U32	nbBits )

BITv06_readBitsFast() : unsafe version; only works only if nbBits >= 1

BITv06_readBitsFast() [2/2]

MEM_STATIC size_t BITv06_readBitsFast	(	BITv06_DStream_t *	bitD,
		unsigned	nbBits )

BITv06_reloadDStream()

MEM_STATIC BITv06_DStream_status BITv06_reloadDStream

(

BITv06_DStream_t *

bitD

)

BITv06_skipBits()

MEM_STATIC void BITv06_skipBits	(	BITv06_DStream_t *	bitD,
		U32	nbBits )

FSEv06_buildDTable()

size_t FSEv06_buildDTable	(	FSEv06_DTable *	dt,
		const short *	normalizedCounter,
		unsigned	maxSymbolValue,
		unsigned	tableLog )

FSEv06_buildDTable(): Builds 'dt', which must be already allocated, using FSEv06_createDTable(). return : 0, or an errorCode, which can be tested using FSEv06_isError()

FSEv06_buildDTable_raw()

size_t FSEv06_buildDTable_raw	(	FSEv06_DTable *	dt,
		unsigned	nbBits )

FSEv06_buildDTable_rle()

size_t FSEv06_buildDTable_rle	(	FSEv06_DTable *	dt,
		unsigned char	symbolValue )

FSEv06_compressBound()

size_t FSEv06_compressBound

(

size_t

size

)

FSEv06_countFast()

size_t FSEv06_countFast	(	unsigned *	count,
		unsigned *	maxSymbolValuePtr,
		const void *	src,
		size_t	srcSize )

FSEv06_createDTable()

FSEv06_DTable * FSEv06_createDTable

(

unsigned

tableLog

)

FSEv06_decompress()

size_t FSEv06_decompress	(	void *	dst,
		size_t	dstCapacity,
		const void *	cSrc,
		size_t	cSrcSize )

FSEv06_decompress(): Decompress FSE data from buffer 'cSrc', of size 'cSrcSize', into already allocated destination buffer 'dst', of size 'dstCapacity'.

Returns

: size of regenerated data (<= maxDstSize), or an error code, which can be tested using FSEv06_isError() .

Important ** : FSEv06_decompress() does not decompress non-compressible nor RLE data !!! Why ? : making this distinction requires a header. Header management is intentionally delegated to the user layer, which can better manage special cases.

FSEv06_decompress_usingDTable()

size_t FSEv06_decompress_usingDTable	(	void *	dst,
		size_t	dstCapacity,
		const void *	cSrc,
		size_t	cSrcSize,
		const FSEv06_DTable *	dt )

FSEv06_decompress_usingDTable(): Decompress compressed source cSrc of size cSrcSize using dt into dst which must be already allocated.

Returns

: size of regenerated data (necessarily <= dstCapacity), or an errorCode, which can be tested using FSEv06_isError()

FSEv06_decompress_usingDTable_generic()

FORCE_INLINE size_t FSEv06_decompress_usingDTable_generic	(	void *	dst,
		size_t	maxDstSize,
		const void *	cSrc,
		size_t	cSrcSize,
		const FSEv06_DTable *	dt,
		const unsigned	fast )

FSEv06_freeDTable()

void FSEv06_freeDTable

(

FSEv06_DTable *

dt

)

FSEv06_getErrorName()

const char * FSEv06_getErrorName

(

size_t

code

)

FSEv06_isError()

unsigned FSEv06_isError

(

size_t

code

)

FSEv06_peekSymbol()

MEM_STATIC BYTE FSEv06_peekSymbol

(

const FSEv06_DState_t *

DStatePtr

)

FSEv06_readNCount()

size_t FSEv06_readNCount	(	short *	normalizedCounter,
		unsigned *	maxSymbolValuePtr,
		unsigned *	tableLogPtr,
		const void *	rBuffer,
		size_t	rBuffSize )

FSEv06_decompress() does the following:

1. read normalized counters with readNCount()
2. build decoding table 'DTable' from normalized counters
3. decode the data stream using decoding table 'DTable'

The following API allows targeting specific sub-functions for advanced tasks. For example, it's possible to compress several blocks using the same 'CTable', or to save and provide normalized distribution using external method.

FSEv06_readNCount(): Read compactly saved 'normalizedCounter' from 'rBuffer'.

Returns

: size read from 'rBuffer', or an errorCode, which can be tested using FSEv06_isError(). maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values

FSEv06_updateState()

MEM_STATIC void FSEv06_updateState	(	FSEv06_DState_t *	DStatePtr,
		BITv06_DStream_t *	bitD )

HUFv06_compressBound()

size_t HUFv06_compressBound

(

size_t

size

)

maximum compressed size

HUFv06_decompress()

size_t HUFv06_decompress	(	void *	dst,
		size_t	dstSize,
		const void *	cSrc,
		size_t	cSrcSize )

HUFv06_decompress1X2()

size_t HUFv06_decompress1X2	(	void *	dst,
		size_t	dstSize,
		const void *	cSrc,
		size_t	cSrcSize )

HUFv06_decompress1X2_usingDTable()

size_t HUFv06_decompress1X2_usingDTable	(	void *	dst,
		size_t	maxDstSize,
		const void *	cSrc,
		size_t	cSrcSize,
		const unsigned short *	DTable )

HUFv06_decompress1X4()

size_t HUFv06_decompress1X4	(	void *	dst,
		size_t	dstSize,
		const void *	cSrc,
		size_t	cSrcSize )

HUFv06_decompress1X4_usingDTable() [1/2]

size_t HUFv06_decompress1X4_usingDTable	(	void *	dst,
		size_t	dstSize,
		const void *	cSrc,
		size_t	cSrcSize,
		const U32 *	DTable )

HUFv06_decompress1X4_usingDTable() [2/2]

size_t HUFv06_decompress1X4_usingDTable	(	void *	dst,
		size_t	maxDstSize,
		const void *	cSrc,
		size_t	cSrcSize,
		const unsigned *	DTable )

HUFv06_decompress4X2()

size_t HUFv06_decompress4X2	(	void *	dst,
		size_t	dstSize,
		const void *	cSrc,
		size_t	cSrcSize )

HUFv06_decompress4X2_usingDTable()

size_t HUFv06_decompress4X2_usingDTable	(	void *	dst,
		size_t	maxDstSize,
		const void *	cSrc,
		size_t	cSrcSize,
		const unsigned short *	DTable )

HUFv06_decompress4X4()

size_t HUFv06_decompress4X4	(	void *	dst,
		size_t	dstSize,
		const void *	cSrc,
		size_t	cSrcSize )

HUFv06_decompress4X4_usingDTable() [1/2]

size_t HUFv06_decompress4X4_usingDTable	(	void *	dst,
		size_t	dstSize,
		const void *	cSrc,
		size_t	cSrcSize,
		const U32 *	DTable )

HUFv06_decompress4X4_usingDTable() [2/2]

size_t HUFv06_decompress4X4_usingDTable	(	void *	dst,
		size_t	maxDstSize,
		const void *	cSrc,
		size_t	cSrcSize,
		const unsigned *	DTable )

HUFv06_readDTableX2()

size_t HUFv06_readDTableX2	(	unsigned short *	DTable,
		const void *	src,
		size_t	srcSize )

HUFv06_decompress() does the following:

1. select the decompression algorithm (X2, X4, X6) based on pre-computed heuristics
2. build Huffman table from save, using HUFv06_readDTableXn()
3. decode 1 or 4 segments in parallel using HUFv06_decompressSXn_usingDTable

HUFv06_readDTableX4() [1/2]

size_t HUFv06_readDTableX4	(	U32 *	DTable,
		const void *	src,
		size_t	srcSize )

HUFv06_readDTableX4() [2/2]

size_t HUFv06_readDTableX4	(	unsigned *	DTable,
		const void *	src,
		size_t	srcSize )

HUFv06_readStats()

MEM_STATIC size_t HUFv06_readStats	(	BYTE *	huffWeight,
		size_t	hwSize,
		U32 *	rankStats,
		U32 *	nbSymbolsPtr,
		U32 *	tableLogPtr,
		const void *	src,
		size_t	srcSize )

HUFv06_readStats() : Read compact Huffman tree, saved by HUFv06_writeCTable(). huffWeight is destination buffer.

Returns

: size read from src

MEM_32bits()

MEM_STATIC unsigned MEM_32bits

(

void

)

MEM_64bits()

MEM_STATIC unsigned MEM_64bits

(

void

)

MEM_isLittleEndian()

MEM_STATIC unsigned MEM_isLittleEndian

(

void

)

MEM_read16()

MEM_STATIC U16 MEM_read16

(

const void *

memPtr

)

MEM_read32()

MEM_STATIC U32 MEM_read32

(

const void *

memPtr

)

MEM_read64()

MEM_STATIC U64 MEM_read64

(

const void *

memPtr

)

MEM_readLE16()

MEM_STATIC U16 MEM_readLE16

(

const void *

memPtr

)

MEM_readLE32()

MEM_STATIC U32 MEM_readLE32

(

const void *

memPtr

)

MEM_readLE64()

MEM_STATIC U64 MEM_readLE64

(

const void *

memPtr

)

MEM_readLEST()

MEM_STATIC size_t MEM_readLEST

(

const void *

memPtr

)

MEM_swap32()

MEM_STATIC U32 MEM_swap32

(

U32

in

)

MEM_swap64()

MEM_STATIC U64 MEM_swap64

(

U64

in

)

MEM_write16()

MEM_STATIC void MEM_write16	(	void *	memPtr,
		U16	value )

MEM_writeLE16()

MEM_STATIC void MEM_writeLE16	(	void *	memPtr,
		U16	val )

ZBUFFv06_createDCtx()

ZBUFFv06_DCtx * ZBUFFv06_createDCtx

(

void

)

ZBUFFv06_decompressContinue()

size_t ZBUFFv06_decompressContinue	(	ZBUFFv06_DCtx *	zbd,
		void *	dst,
		size_t *	dstCapacityPtr,
		const void *	src,
		size_t *	srcSizePtr )

ZBUFFv06_decompressInit()

size_t ZBUFFv06_decompressInit

(

ZBUFFv06_DCtx *

zbd

)

ZBUFFv06_decompressInitDictionary()

size_t ZBUFFv06_decompressInitDictionary	(	ZBUFFv06_DCtx *	zbd,
		const void *	dict,
		size_t	dictSize )

ZBUFFv06_freeDCtx()

size_t ZBUFFv06_freeDCtx

(

ZBUFFv06_DCtx *

zbd

)

ZBUFFv06_getErrorName()

const char * ZBUFFv06_getErrorName

(

size_t

errorCode

)

ZBUFFv06_isError()

unsigned ZBUFFv06_isError

(

size_t

errorCode

)

ZBUFFv06_limitCopy()

MEM_STATIC size_t ZBUFFv06_limitCopy	(	void *	dst,
		size_t	dstCapacity,
		const void *	src,
		size_t	srcSize )

ZBUFFv06_recommendedDInSize()

size_t ZBUFFv06_recommendedDInSize

(

void

)

Functions below provide recommended buffer sizes for Compression or Decompression operations. These sizes are just hints, they tend to offer better latency

ZBUFFv06_recommendedDOutSize()

size_t ZBUFFv06_recommendedDOutSize

(

void

)

ZSTDv06_copyDCtx()

void ZSTDv06_copyDCtx	(	ZSTDv06_DCtx *	dstDCtx,
		const ZSTDv06_DCtx *	srcDCtx )

ZSTDv06_createDCtx()

ZSTDv06_DCtx * ZSTDv06_createDCtx

(

void

)

ZSTDv06_decompress()

size_t ZSTDv06_decompress	(	void *	dst,
		size_t	dstCapacity,
		const void *	src,
		size_t	compressedSize )

ZSTDv06_decompress() : compressedSize : is the exact size of the compressed blob, otherwise decompression will fail. dstCapacity must be large enough, equal or larger than originalSize.

Returns

: the number of bytes decompressed into dst (<= dstCapacity), or an errorCode if it fails (which can be tested using ZSTDv06_isError())

ZSTDv06_decompress_usingDict()

size_t ZSTDv06_decompress_usingDict	(	ZSTDv06_DCtx *	dctx,
		void *	dst,
		size_t	dstCapacity,
		const void *	src,
		size_t	srcSize,
		const void *	dict,
		size_t	dictSize )

ZSTDv06_decompress_usingDict() : Decompression using a pre-defined Dictionary content (see dictBuilder). Dictionary must be identical to the one used during compression, otherwise regenerated data will be corrupted. Note : dict can be NULL, in which case, it's equivalent to ZSTDv06_decompressDCtx()

ZSTDv06_decompress_usingPreparedDCtx()

size_t ZSTDv06_decompress_usingPreparedDCtx	(	ZSTDv06_DCtx *	dctx,
		const ZSTDv06_DCtx *	preparedDCtx,
		void *	dst,
		size_t	dstCapacity,
		const void *	src,
		size_t	srcSize )

ZSTDv06_decompress_usingPreparedDCtx() : Same as ZSTDv06_decompress_usingDict, but using a reference context preparedDCtx, where dictionary has been loaded. It avoids reloading the dictionary each time. preparedDCtx must have been properly initialized using ZSTDv06_decompressBegin_usingDict(). Requires 2 contexts : 1 for reference (preparedDCtx), which will not be modified, and 1 to run the decompression operation (dctx)

ZSTDv06_decompressBegin()

size_t ZSTDv06_decompressBegin

(

ZSTDv06_DCtx *

dctx

)

ZSTDv06_decompressBegin_usingDict()

size_t ZSTDv06_decompressBegin_usingDict	(	ZSTDv06_DCtx *	dctx,
		const void *	dict,
		size_t	dictSize )

ZSTDv06_decompressBlock()

size_t ZSTDv06_decompressBlock	(	ZSTDv06_DCtx *	dctx,
		void *	dst,
		size_t	dstCapacity,
		const void *	src,
		size_t	srcSize )

ZSTDv06_decompressContinue()

size_t ZSTDv06_decompressContinue	(	ZSTDv06_DCtx *	dctx,
		void *	dst,
		size_t	dstCapacity,
		const void *	src,
		size_t	srcSize )

ZSTDv06_decompressDCtx()

size_t ZSTDv06_decompressDCtx	(	ZSTDv06_DCtx *	ctx,
		void *	dst,
		size_t	dstCapacity,
		const void *	src,
		size_t	srcSize )

ZSTDv06_decompressDCtx() : Same as ZSTDv06_decompress(), but requires an already allocated ZSTDv06_DCtx (see ZSTDv06_createDCtx())

ZSTDv06_findFrameSizeInfoLegacy()

void ZSTDv06_findFrameSizeInfoLegacy	(	const void *	src,
		size_t	srcSize,
		size_t *	cSize,
		unsigned long long *	dBound )

ZSTDv06_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.6.x format srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src' cSize (output parameter) : the number of bytes that would be read to decompress this frame or an error code if it fails (which can be tested using ZSTDv01_isError()) dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame or ZSTD_CONTENTSIZE_ERROR if an error occurs

note : assumes cSize and dBound are not NULL.

ZSTDv06_freeDCtx()

size_t ZSTDv06_freeDCtx

(

ZSTDv06_DCtx *

dctx

)

Returns

: errorCode

ZSTDv06_getErrorName()

const char * ZSTDv06_getErrorName

(

size_t

code

)

ZSTDv06_getErrorName() : provides error code string from function result (useful for debugging)

ZSTDv06_getFrameParams()

size_t ZSTDv06_getFrameParams	(	ZSTDv06_frameParams *	fparamsPtr,
		const void *	src,
		size_t	srcSize )

ZSTDv06_getFrameParams() : decode Frame Header, or provide expected srcSize.

Returns

: 0, fparamsPtr is correctly filled, >0, srcSize is too small, result is expected srcSize, or an error code, which can be tested using ZSTDv06_isError()

ZSTDv06_isError()

unsigned ZSTDv06_isError

(

size_t

code

)

ZSTDv06_isError() : tells if a return value is an error code

ZSTDv06_nextSrcSizeToDecompress()

size_t ZSTDv06_nextSrcSizeToDecompress

(

ZSTDv06_DCtx *

dctx

)

ZSTDv06_seqToCodes()

void ZSTDv06_seqToCodes	(	const seqStore_t *	seqStorePtr,
		size_t const	nbSeq )

ZSTDv06_sizeofDCtx()

size_t ZSTDv06_sizeofDCtx

(

void

)

ZSTDv06_wildcopy()

MEM_STATIC void ZSTDv06_wildcopy	(	void *	dst,
		const void *	src,
		ptrdiff_t	length )