zstd_v05.c File Reference

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

Data Structures
struct	seqStore_t
struct	BITv05_DStream_t
struct	FSEv05_DState_t
struct	FSEv05_DTableHeader
struct	FSEv05_decode_t
struct	HUFv05_DEltX2
struct	HUFv05_DEltX4
struct	sortedSymbol_t
struct	algo_time_t
struct	blockProperties_t
struct	ZSTDv05_DCtx_s
struct	seq_t
struct	seqState_t
struct	ZBUFFv05_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	ZSTD_STATIC_H
#define	ZSTDv05_WINDOWLOG_ABSOLUTEMIN   11
#define	ZSTD_CCOMMON_H_MODULE
#define	MIN(a, b)
#define	MAX(a, b)
#define	ZSTDv05_DICT_MAGIC   0xEC30A435
#define	KB   *(1 <<10)
#define	MB   *(1 <<20)
#define	GB   *(1U<<30)
#define	BLOCKSIZE   (128 KB) /* define, for static allocation */
#define	ZSTDv05_frameHeaderSize_max   5 /* define, for static allocation */
#define	BITv057   128
#define	BITv056   64
#define	BITv055   32
#define	BITv054   16
#define	BITv051   2
#define	BITv050   1
#define	IS_HUFv05   0
#define	IS_PCH   1
#define	IS_RAW   2
#define	IS_RLE   3
#define	MINMATCH   4
#define	REPCODE_STARTVALUE   1
#define	Litbits   8
#define	MLbits   7
#define	LLbits   6
#define	Offbits   5
#define	MaxLit   ((1<<Litbits) - 1)
#define	MaxML   ((1<<MLbits) - 1)
#define	MaxLL   ((1<<LLbits) - 1)
#define	MaxOff   ((1<<Offbits)- 1)
#define	MLFSEv05Log   10
#define	LLFSEv05Log   10
#define	OffFSEv05Log   9
#define	MaxSeq   MAX(MaxLL, MaxML)
#define	FSEv05_ENCODING_RAW   0
#define	FSEv05_ENCODING_RLE   1
#define	FSEv05_ENCODING_STATIC   2
#define	FSEv05_ENCODING_DYNAMIC   3
#define	HufLog   12
#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	WILDCOPY_OVERLENGTH   8
#define	ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
#define	COPY8(d, s)
#define	FSEv05_H
#define	BITv05STREAM_H_MODULE
#define	FSEv05_STATIC_H
#define	FSEv05_DTABLE_SIZE_U32(maxTableLog)
#define	FSEv05_MAX_MEMORY_USAGE   14
#define	FSEv05_DEFAULT_MEMORY_USAGE   13
#define	FSEv05_MAX_SYMBOL_VALUE   255
#define	FSEv05_FUNCTION_TYPE   BYTE
#define	FSEv05_FUNCTION_EXTENSION
#define	FSEv05_DECODE_TYPE   FSEv05_decode_t
#define	FORCE_INLINE   static
#define	FSEv05_MAX_TABLELOG   (FSEv05_MAX_MEMORY_USAGE-2)
#define	FSEv05_MAX_TABLESIZE   (1U<<FSEv05_MAX_TABLELOG)
#define	FSEv05_MAXTABLESIZE_MASK   (FSEv05_MAX_TABLESIZE-1)
#define	FSEv05_DEFAULT_TABLELOG   (FSEv05_DEFAULT_MEMORY_USAGE-2)
#define	FSEv05_MIN_TABLELOG   5
#define	FSEv05_TABLELOG_ABSOLUTE_MAX   15
#define	FSEv05_STATIC_ASSERT(c)
#define	FSEv05_CAT(X, Y)
#define	FSEv05_FUNCTION_NAME(X, Y)
#define	FSEv05_TYPE_NAME(X, Y)
#define	FSEv05_GETSYMBOL(statePtr)
#define	HUFF0_H
#define	HUF0_STATIC_H
#define	HUFv05_DTABLE_SIZE(maxTableLog)
#define	HUFv05_CREATE_STATIC_DTABLEX2(DTable, maxTableLog)
#define	HUFv05_CREATE_STATIC_DTABLEX4(DTable, maxTableLog)
#define	HUFv05_CREATE_STATIC_DTABLEX6(DTable, maxTableLog)
#define	inline   /* disable inline */
#define	HUFv05_ABSOLUTEMAX_TABLELOG   16 /* absolute limit of HUFv05_MAX_TABLELOG. Beyond that value, code does not work */
#define	HUFv05_MAX_TABLELOG   12 /* max configured tableLog (for static allocation); can be modified up to HUFv05_ABSOLUTEMAX_TABLELOG */
#define	HUFv05_DEFAULT_TABLELOG   HUFv05_MAX_TABLELOG /* tableLog by default, when not specified */
#define	HUFv05_MAX_SYMBOL_VALUE   255
#define	HUFv05_STATIC_ASSERT(c)
#define	HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
#define	HUFv05_DECODE_SYMBOLX2_1(ptr, DStreamPtr)
#define	HUFv05_DECODE_SYMBOLX2_2(ptr, DStreamPtr)
#define	HUFv05_DECODE_SYMBOLX4_0(ptr, DStreamPtr)
#define	HUFv05_DECODE_SYMBOLX4_1(ptr, DStreamPtr)
#define	HUFv05_DECODE_SYMBOLX4_2(ptr, DStreamPtr)
#define	ZSTDv05_HEAPMODE   1
#define	ZSTDv05_frameHeaderSize_max   5 /* too magical, should come from reference */

Typedefs
typedef unsigned	FSEv05_DTable
typedef unsigned	DTable_max_t[FSEv05_DTABLE_SIZE_U32(FSEv05_MAX_TABLELOG)]
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	BITv05_DStream_status { BITv05_DStream_unfinished = 0 , BITv05_DStream_endOfBuffer = 1 , BITv05_DStream_completed = 2 , BITv05_DStream_overflow = 3 }
enum	ZSTDv05_dStage { ZSTDv05ds_getFrameHeaderSize , ZSTDv05ds_decodeFrameHeader , ZSTDv05ds_decodeBlockHeader , ZSTDv05ds_decompressBlock }
enum	ZBUFFv05_dStage {   ZBUFFv05ds_init , ZBUFFv05ds_readHeader , ZBUFFv05ds_loadHeader , ZBUFFv05ds_decodeHeader ,   ZBUFFv05ds_read , ZBUFFv05ds_load , ZBUFFv05ds_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 void	MEM_write32 (void *memPtr, U32 value)
MEM_STATIC void	MEM_write64 (void *memPtr, U64 value)
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)
size_t	ZSTDv05_decompress_usingPreparedDCtx (ZSTDv05_DCtx *dctx, const ZSTDv05_DCtx *preparedDCtx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
size_t	ZSTDv05_decompressBegin (ZSTDv05_DCtx *dctx)
size_t	ZSTDv05_decompressBlock (ZSTDv05_DCtx *dctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
MEM_STATIC void	ZSTDv05_wildcopy (void *dst, const void *src, ptrdiff_t length)
size_t	FSEv05_decompress (void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize)
unsigned	FSEv05_isError (size_t code)
const char *	FSEv05_getErrorName (size_t code)
size_t	FSEv05_readNCount (short *normalizedCounter, unsigned *maxSymbolValuePtr, unsigned *tableLogPtr, const void *rBuffer, size_t rBuffSize)
FSEv05_DTable *	FSEv05_createDTable (unsigned tableLog)
void	FSEv05_freeDTable (FSEv05_DTable *dt)
size_t	FSEv05_buildDTable (FSEv05_DTable *dt, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
size_t	FSEv05_decompress_usingDTable (void *dst, size_t dstCapacity, const void *cSrc, size_t cSrcSize, const FSEv05_DTable *dt)
MEM_STATIC size_t	BITv05_initDStream (BITv05_DStream_t *bitD, const void *srcBuffer, size_t srcSize)
MEM_STATIC size_t	BITv05_readBits (BITv05_DStream_t *bitD, unsigned nbBits)
MEM_STATIC BITv05_DStream_status	BITv05_reloadDStream (BITv05_DStream_t *bitD)
MEM_STATIC unsigned	BITv05_endOfDStream (const BITv05_DStream_t *bitD)
MEM_STATIC size_t	BITv05_readBitsFast (BITv05_DStream_t *bitD, unsigned nbBits)
MEM_STATIC unsigned	BITv05_highbit32 (U32 val)
MEM_STATIC size_t	BITv05_lookBits (BITv05_DStream_t *bitD, U32 nbBits)
MEM_STATIC size_t	BITv05_lookBitsFast (BITv05_DStream_t *bitD, U32 nbBits)
MEM_STATIC void	BITv05_skipBits (BITv05_DStream_t *bitD, U32 nbBits)
size_t	FSEv05_buildDTable_raw (FSEv05_DTable *dt, unsigned nbBits)
size_t	FSEv05_buildDTable_rle (FSEv05_DTable *dt, unsigned char symbolValue)
MEM_STATIC BYTE	FSEv05_peakSymbol (FSEv05_DState_t *DStatePtr)
FORCE_INLINE size_t	FSEv05_decompress_usingDTable_generic (void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const FSEv05_DTable *dt, const unsigned fast)
size_t	HUFv05_decompress (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
unsigned	HUFv05_isError (size_t code)
const char *	HUFv05_getErrorName (size_t code)
size_t	HUFv05_decompress4X2 (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t	HUFv05_decompress4X4 (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t	HUFv05_readDTableX2 (unsigned short *DTable, const void *src, size_t srcSize)
size_t	HUFv05_readDTableX4 (unsigned *DTable, const void *src, size_t srcSize)
size_t	HUFv05_decompress4X2_usingDTable (void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const unsigned short *DTable)
size_t	HUFv05_decompress4X4_usingDTable (void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const unsigned *DTable)
size_t	HUFv05_decompress1X2 (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t	HUFv05_decompress1X4 (void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t	HUFv05_decompress1X2_usingDTable (void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const unsigned short *DTable)
size_t	HUFv05_decompress1X4_usingDTable (void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const unsigned *DTable)
unsigned	ZSTDv05_isError (size_t code)
const char *	ZSTDv05_getErrorName (size_t code)
size_t	ZSTDv05_sizeofDCtx (void)
ZSTDv05_DCtx *	ZSTDv05_createDCtx (void)
size_t	ZSTDv05_freeDCtx (ZSTDv05_DCtx *dctx)
void	ZSTDv05_copyDCtx (ZSTDv05_DCtx *dstDCtx, const ZSTDv05_DCtx *srcDCtx)
size_t	ZSTDv05_getFrameParams (ZSTDv05_parameters *params, const void *src, size_t srcSize)
size_t	ZSTDv05_decompress_usingDict (ZSTDv05_DCtx *dctx, void *dst, size_t maxDstSize, const void *src, size_t srcSize, const void *dict, size_t dictSize)
size_t	ZSTDv05_decompressDCtx (ZSTDv05_DCtx *dctx, void *dst, size_t maxDstSize, const void *src, size_t srcSize)
size_t	ZSTDv05_decompress (void *dst, size_t maxDstSize, const void *src, size_t srcSize)
void	ZSTDv05_findFrameSizeInfoLegacy (const void *src, size_t srcSize, size_t *cSize, unsigned long long *dBound)
size_t	ZSTDv05_nextSrcSizeToDecompress (ZSTDv05_DCtx *dctx)
size_t	ZSTDv05_decompressContinue (ZSTDv05_DCtx *dctx, void *dst, size_t maxDstSize, const void *src, size_t srcSize)
size_t	ZSTDv05_decompressBegin_usingDict (ZSTDv05_DCtx *dctx, const void *dict, size_t dictSize)
ZBUFFv05_DCtx *	ZBUFFv05_createDCtx (void)
size_t	ZBUFFv05_freeDCtx (ZBUFFv05_DCtx *zbc)
size_t	ZBUFFv05_decompressInitDictionary (ZBUFFv05_DCtx *zbc, const void *dict, size_t dictSize)
size_t	ZBUFFv05_decompressInit (ZBUFFv05_DCtx *zbc)
size_t	ZBUFFv05_decompressContinue (ZBUFFv05_DCtx *zbc, void *dst, size_t *maxDstSizePtr, const void *src, size_t *srcSizePtr)
unsigned	ZBUFFv05_isError (size_t errorCode)
const char *	ZBUFFv05_getErrorName (size_t errorCode)
size_t	ZBUFFv05_recommendedDInSize (void)
size_t	ZBUFFv05_recommendedDOutSize (void)

Macro Definition Documentation

BITv050

#define BITv050   1

BITv051

#define BITv051   2

BITv054

#define BITv054   16

BITv055

#define BITv055   32

BITv056

#define BITv056   64

BITv057

#define BITv057   128

BITv05STREAM_H_MODULE

#define BITv05STREAM_H_MODULE

BLOCKSIZE

#define BLOCKSIZE   (128 KB) /* define, for static allocation */

COPY8

#define COPY8	(		d,
			s )

Value:

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

FORCE_INLINE

#define FORCE_INLINE   static

FSEv05_CAT

#define FSEv05_CAT	(		X,
			Y )

Value:

X##Y

FSEv05_DECODE_TYPE

#define FSEv05_DECODE_TYPE   FSEv05_decode_t

FSEv05_DEFAULT_MEMORY_USAGE

#define FSEv05_DEFAULT_MEMORY_USAGE   13

FSEv05_DEFAULT_TABLELOG

#define FSEv05_DEFAULT_TABLELOG   (FSEv05_DEFAULT_MEMORY_USAGE-2)

FSEv05_DTABLE_SIZE_U32

#define FSEv05_DTABLE_SIZE_U32

(

maxTableLog

)

Value:

(1 + (1<<maxTableLog))

FSEv05_ENCODING_DYNAMIC

#define FSEv05_ENCODING_DYNAMIC   3

FSEv05_ENCODING_RAW

#define FSEv05_ENCODING_RAW   0

FSEv05_ENCODING_RLE

#define FSEv05_ENCODING_RLE   1

FSEv05_ENCODING_STATIC

#define FSEv05_ENCODING_STATIC   2

FSEv05_FUNCTION_EXTENSION

#define FSEv05_FUNCTION_EXTENSION

FSEv05_FUNCTION_NAME

#define FSEv05_FUNCTION_NAME	(		X,
			Y )

Value:

FSEv05_CAT(X,Y)

FSEv05_FUNCTION_TYPE

#define FSEv05_FUNCTION_TYPE   BYTE

FSEv05_GETSYMBOL

#define FSEv05_GETSYMBOL

(

statePtr

)

Value:

fast ? FSEv05_decodeSymbolFast(statePtr, &bitD) : FSEv05_decodeSymbol(statePtr, &bitD)

FSEv05_H

#define FSEv05_H

FSEv05_MAX_MEMORY_USAGE

#define FSEv05_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

FSEv05_MAX_SYMBOL_VALUE

#define FSEv05_MAX_SYMBOL_VALUE   255

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

FSEv05_MAX_TABLELOG

#define FSEv05_MAX_TABLELOG   (FSEv05_MAX_MEMORY_USAGE-2)

FSEv05_MAX_TABLESIZE

#define FSEv05_MAX_TABLESIZE   (1U<<FSEv05_MAX_TABLELOG)

FSEv05_MAXTABLESIZE_MASK

#define FSEv05_MAXTABLESIZE_MASK   (FSEv05_MAX_TABLESIZE-1)

FSEv05_MIN_TABLELOG

#define FSEv05_MIN_TABLELOG   5

FSEv05_STATIC_ASSERT

#define FSEv05_STATIC_ASSERT

(

c

)

Value:

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

FSEv05_STATIC_H

#define FSEv05_STATIC_H

FSEv05_TABLELOG_ABSOLUTE_MAX

#define FSEv05_TABLELOG_ABSOLUTE_MAX   15

FSEv05_TYPE_NAME

#define FSEv05_TYPE_NAME	(		X,
			Y )

Value:

FSEv05_CAT(X,Y)

GB

#define GB   *(1U<<30)

HUF0_STATIC_H

#define HUF0_STATIC_H

HUFF0_H

#define HUFF0_H

HufLog

#define HufLog   12

HUFv05_ABSOLUTEMAX_TABLELOG

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

HUFv05_CREATE_STATIC_DTABLEX2

#define HUFv05_CREATE_STATIC_DTABLEX2	(		DTable,
			maxTableLog )

Value:

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

HUFv05_CREATE_STATIC_DTABLEX4

#define HUFv05_CREATE_STATIC_DTABLEX4	(		DTable,
			maxTableLog )

Value:

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

HUFv05_CREATE_STATIC_DTABLEX6

#define HUFv05_CREATE_STATIC_DTABLEX6	(		DTable,
			maxTableLog )

Value:

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

HUFv05_DECODE_SYMBOLX2_0

#define HUFv05_DECODE_SYMBOLX2_0	(		ptr,
			DStreamPtr )

Value:

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

HUFv05_DECODE_SYMBOLX2_1

#define HUFv05_DECODE_SYMBOLX2_1	(		ptr,
			DStreamPtr )

Value:

    if (MEM_64bits() || (HUFv05_MAX_TABLELOG<=12)) \
        HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr)

HUFv05_DECODE_SYMBOLX2_2

#define HUFv05_DECODE_SYMBOLX2_2	(		ptr,
			DStreamPtr )

Value:

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

HUFv05_DECODE_SYMBOLX4_0

#define HUFv05_DECODE_SYMBOLX4_0	(		ptr,
			DStreamPtr )

Value:

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

HUFv05_DECODE_SYMBOLX4_1

#define HUFv05_DECODE_SYMBOLX4_1	(		ptr,
			DStreamPtr )

Value:

    if (MEM_64bits() || (HUFv05_MAX_TABLELOG<=12)) \
        ptr += HUFv05_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)

HUFv05_DECODE_SYMBOLX4_2

#define HUFv05_DECODE_SYMBOLX4_2	(		ptr,
			DStreamPtr )

Value:

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

HUFv05_DEFAULT_TABLELOG

#define HUFv05_DEFAULT_TABLELOG   HUFv05_MAX_TABLELOG /* tableLog by default, when not specified */

HUFv05_DTABLE_SIZE

#define HUFv05_DTABLE_SIZE

(

maxTableLog

)

Value:

(1 + (1<<maxTableLog))

HUFv05_MAX_SYMBOL_VALUE

#define HUFv05_MAX_SYMBOL_VALUE   255

HUFv05_MAX_TABLELOG

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

HUFv05_STATIC_ASSERT

#define HUFv05_STATIC_ASSERT

(

c

)

Value:

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

inline

#define inline   /* disable inline */

IS_HUFv05

#define IS_HUFv05   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

LLbits

#define LLbits   6

LLFSEv05Log

#define LLFSEv05Log   10

MAX

#define MAX	(		a,
			b )

Value:

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

MaxLit

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

MaxLL

#define MaxLL   ((1<<LLbits) - 1)

MaxML

#define MaxML   ((1<<MLbits) - 1)

MaxOff

#define MaxOff   ((1<<Offbits)- 1)

MaxSeq

#define MaxSeq   MAX(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   4

MLbits

#define MLbits   7

MLFSEv05Log

#define MLFSEv05Log   10

Offbits

#define Offbits   5

OffFSEv05Log

#define OffFSEv05Log   9

REPCODE_STARTVALUE

#define REPCODE_STARTVALUE   1

WILDCOPY_OVERLENGTH

#define WILDCOPY_OVERLENGTH   8

ZSTD_CCOMMON_H_MODULE

#define ZSTD_CCOMMON_H_MODULE

ZSTD_CONTENTSIZE_ERROR

#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)

ZSTD_STATIC_H

#define ZSTD_STATIC_H

ZSTDv05_DICT_MAGIC

#define ZSTDv05_DICT_MAGIC   0xEC30A435

ZSTDv05_frameHeaderSize_max [1/2]

#define ZSTDv05_frameHeaderSize_max   5 /* define, for static allocation */

ZSTDv05_frameHeaderSize_max [2/2]

#define ZSTDv05_frameHeaderSize_max   5 /* too magical, should come from reference */

ZSTDv05_HEAPMODE

#define ZSTDv05_HEAPMODE   1

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

ZSTDv05_WINDOWLOG_ABSOLUTEMIN

#define ZSTDv05_WINDOWLOG_ABSOLUTEMIN   11

Typedef Documentation

decompressionAlgo

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

DTable_max_t

typedef unsigned DTable_max_t[FSEv05_DTABLE_SIZE_U32(FSEv05_MAX_TABLELOG)]

FSEv05_DTable

typedef unsigned FSEv05_DTable

Constructor and Destructor of type FSEv05_DTable Note that its size depends on 'tableLog'

Enumeration Type Documentation

BITv05_DStream_status

enum BITv05_DStream_status

Enumerator
BITv05_DStream_unfinished
BITv05_DStream_endOfBuffer
BITv05_DStream_completed
BITv05_DStream_overflow

blockType_t

enum blockType_t

Enumerator
bt_compressed
bt_raw
bt_rle
bt_end

ZBUFFv05_dStage

enum ZBUFFv05_dStage

---

Streaming decompression

A ZBUFFv05_DCtx object is required to track streaming operation. Use ZBUFFv05_createDCtx() and ZBUFFv05_freeDCtx() to create/release resources. Use ZBUFFv05_decompressInit() to start a new decompression operation. ZBUFFv05_DCtx objects can be reused multiple times.

Use ZBUFFv05_decompressContinue() repetitively to consume your input. *srcSizePtr and *maxDstSizePtr can be any size. The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr. Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input. The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst . return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency) or 0 when a frame is completely decoded or an error code, which can be tested using ZBUFFv05_isError().

Hint : recommended buffer sizes (not compulsory) output : 128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded. input : just follow indications from ZBUFFv05_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .

Enumerator
ZBUFFv05ds_init
ZBUFFv05ds_readHeader
ZBUFFv05ds_loadHeader
ZBUFFv05ds_decodeHeader
ZBUFFv05ds_read
ZBUFFv05ds_load
ZBUFFv05ds_flush

ZSTDv05_dStage

enum ZSTDv05_dStage

Enumerator
ZSTDv05ds_getFrameHeaderSize
ZSTDv05ds_decodeFrameHeader
ZSTDv05ds_decodeBlockHeader
ZSTDv05ds_decompressBlock

Function Documentation

BITv05_endOfDStream()

MEM_STATIC unsigned BITv05_endOfDStream

(

const BITv05_DStream_t *

DStream

)

BITv05_endOfDStream

Returns

Tells if DStream has reached its exact end

BITv05_highbit32()

MEM_STATIC unsigned BITv05_highbit32

(

U32

val

)

BITv05_initDStream()

MEM_STATIC size_t BITv05_initDStream	(	BITv05_DStream_t *	bitD,
		const void *	srcBuffer,
		size_t	srcSize )

BITv05_initDStream Initialize a BITv05_DStream_t. @bitD : a pointer to an already allocated BITv05_DStream_t structure @srcBuffer must point at the beginning of a bitStream @srcSize must be the exact size of the bitStream

Returns

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

BITv05_lookBits()

MEM_STATIC size_t BITv05_lookBits	(	BITv05_DStream_t *	bitD,
		U32	nbBits )

BITv05_lookBitsFast()

MEM_STATIC size_t BITv05_lookBitsFast	(	BITv05_DStream_t *	bitD,
		U32	nbBits )

BITv05_lookBitsFast : unsafe version; only works only if nbBits >= 1

BITv05_readBits()

MEM_STATIC size_t BITv05_readBits	(	BITv05_DStream_t *	bitD,
		unsigned	nbBits )

BITv05_readBitsFast()

MEM_STATIC size_t BITv05_readBitsFast	(	BITv05_DStream_t *	bitD,
		unsigned	nbBits )

BITv05_readBitsFast : unsafe version; only works only if nbBits >= 1

BITv05_readBitsFast : unsafe version; only works if nbBits >= 1

BITv05_reloadDStream()

MEM_STATIC BITv05_DStream_status BITv05_reloadDStream

(

BITv05_DStream_t *

bitD

)

BITv05_skipBits()

MEM_STATIC void BITv05_skipBits	(	BITv05_DStream_t *	bitD,
		U32	nbBits )

FSEv05_buildDTable()

size_t FSEv05_buildDTable	(	FSEv05_DTable *	dt,
		const short *	normalizedCounter,
		unsigned	maxSymbolValue,
		unsigned	tableLog )

FSEv05_buildDTable(): Builds 'dt', which must be already allocated, using FSEv05_createDTable()

Returns

: 0, or an errorCode, which can be tested using FSEv05_isError()

FSEv05_buildDTable_raw()

size_t FSEv05_buildDTable_raw	(	FSEv05_DTable *	dt,
		unsigned	nbBits )

FSEv05_buildDTable_rle()

size_t FSEv05_buildDTable_rle	(	FSEv05_DTable *	dt,
		unsigned char	symbolValue )

FSEv05_createDTable()

FSEv05_DTable * FSEv05_createDTable

(

unsigned

tableLog

)

FSEv05_decompress()

size_t FSEv05_decompress	(	void *	dst,
		size_t	maxDstSize,
		const void *	cSrc,
		size_t	cSrcSize )

FSEv05_decompress_usingDTable()

size_t FSEv05_decompress_usingDTable	(	void *	dst,
		size_t	dstCapacity,
		const void *	cSrc,
		size_t	cSrcSize,
		const FSEv05_DTable *	dt )

FSEv05_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 FSEv05_isError()

FSEv05_decompress_usingDTable_generic()

FORCE_INLINE size_t FSEv05_decompress_usingDTable_generic	(	void *	dst,
		size_t	maxDstSize,
		const void *	cSrc,
		size_t	cSrcSize,
		const FSEv05_DTable *	dt,
		const unsigned	fast )

FSEv05_freeDTable()

void FSEv05_freeDTable

(

FSEv05_DTable *

dt

)

FSEv05_getErrorName()

const char * FSEv05_getErrorName

(

size_t

code

)

FSEv05_isError()

unsigned FSEv05_isError

(

size_t

code

)

FSEv05_decompress(): Decompress FSEv05 data from buffer 'cSrc', of size 'cSrcSize', into already allocated destination buffer 'dst', of size 'maxDstSize'. return : size of regenerated data (<= maxDstSize) or an error code, which can be tested using FSEv05_isError()

Important ** : FSEv05_decompress() doesn't 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.

FSEv05_peakSymbol()

MEM_STATIC BYTE FSEv05_peakSymbol

(

FSEv05_DState_t *

DStatePtr

)

FSEv05_readNCount()

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

FSEv05_readNCount(): Read compactly saved 'normalizedCounter' from 'rBuffer'. return : size read from 'rBuffer' or an errorCode, which can be tested using FSEv05_isError() maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values

HUFv05_decompress()

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

HUFv05_decompress1X2()

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

HUFv05_decompress1X2_usingDTable()

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

HUFv05_decompress1X4()

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

HUFv05_decompress1X4_usingDTable()

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

HUFv05_decompress4X2()

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

HUFv05_decompress4X2_usingDTable()

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

HUFv05_decompress4X4()

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

HUFv05_decompress4X4_usingDTable()

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

HUFv05_getErrorName()

const char * HUFv05_getErrorName

(

size_t

code

)

HUFv05_isError()

unsigned HUFv05_isError

(

size_t

code

)

HUFv05_decompress(): Decompress Huff0 data from buffer 'cSrc', of size 'cSrcSize', into already allocated destination buffer 'dst', of size 'dstSize'. @dstSize : must be the exact size of original (uncompressed) data. Note : in contrast with FSEv05, HUFv05_decompress can regenerate RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data, because it knows size to regenerate.

Returns

: size of regenerated data (== dstSize) or an error code, which can be tested using HUFv05_isError()

HUFv05_readDTableX2()

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

HUFv05_decompress() does the following:

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

HUFv05_readDTableX4()

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

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_write16()

MEM_STATIC void MEM_write16	(	void *	memPtr,
		U16	value )

MEM_write32()

MEM_STATIC void MEM_write32	(	void *	memPtr,
		U32	value )

MEM_write64()

MEM_STATIC void MEM_write64	(	void *	memPtr,
		U64	value )

MEM_writeLE16()

MEM_STATIC void MEM_writeLE16	(	void *	memPtr,
		U16	val )

ZBUFFv05_createDCtx()

ZBUFFv05_DCtx * ZBUFFv05_createDCtx

(

void

)

ZBUFFv05_decompressContinue()

size_t ZBUFFv05_decompressContinue	(	ZBUFFv05_DCtx *	zbc,
		void *	dst,
		size_t *	maxDstSizePtr,
		const void *	src,
		size_t *	srcSizePtr )

ZBUFFv05_decompressInit()

size_t ZBUFFv05_decompressInit

(

ZBUFFv05_DCtx *

zbc

)

ZBUFFv05_decompressInitDictionary()

size_t ZBUFFv05_decompressInitDictionary	(	ZBUFFv05_DCtx *	zbc,
		const void *	dict,
		size_t	dictSize )

ZBUFFv05_freeDCtx()

size_t ZBUFFv05_freeDCtx

(

ZBUFFv05_DCtx *

zbc

)

ZBUFFv05_getErrorName()

const char * ZBUFFv05_getErrorName

(

size_t

errorCode

)

ZBUFFv05_isError()

unsigned ZBUFFv05_isError

(

size_t

errorCode

)

ZBUFFv05_recommendedDInSize()

size_t ZBUFFv05_recommendedDInSize

(

void

)

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

ZBUFFv05_recommendedDOutSize()

size_t ZBUFFv05_recommendedDOutSize

(

void

)

ZSTDv05_copyDCtx()

void ZSTDv05_copyDCtx	(	ZSTDv05_DCtx *	dstDCtx,
		const ZSTDv05_DCtx *	srcDCtx )

ZSTDv05_createDCtx()

ZSTDv05_DCtx * ZSTDv05_createDCtx

(

void

)

ZSTDv05_decompress()

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

ZSTDv05_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 ZSTDv05_isError())

ZSTDv05_decompress_usingDict()

size_t ZSTDv05_decompress_usingDict	(	ZSTDv05_DCtx *	dctx,
		void *	dst,
		size_t	dstCapacity,
		const void *	src,
		size_t	srcSize,
		const void *	dict,
		size_t	dictSize )

ZSTDv05_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 ZSTDv05_decompressDCtx()

ZSTDv05_decompress_usingPreparedDCtx()

size_t ZSTDv05_decompress_usingPreparedDCtx	(	ZSTDv05_DCtx *	dctx,
		const ZSTDv05_DCtx *	preparedDCtx,
		void *	dst,
		size_t	dstCapacity,
		const void *	src,
		size_t	srcSize )

ZSTDv05_decompress_usingPreparedDCtx() : Same as ZSTDv05_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 ZSTDv05_decompressBegin_usingDict(). Requires 2 contexts : 1 for reference, which will not be modified, and 1 to run the decompression operation

ZSTDv05_decompressBegin()

size_t ZSTDv05_decompressBegin

(

ZSTDv05_DCtx *

dctx

)

ZSTDv05_decompressBegin_usingDict()

size_t ZSTDv05_decompressBegin_usingDict	(	ZSTDv05_DCtx *	dctx,
		const void *	dict,
		size_t	dictSize )

ZSTDv05_decompressBlock()

size_t ZSTDv05_decompressBlock	(	ZSTDv05_DCtx *	dctx,
		void *	dst,
		size_t	dstCapacity,
		const void *	src,
		size_t	srcSize )

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 block sizes.

A few rules to respect :

• Uncompressed block size must be <= 128 KB
• Compressing or decompressing requires a context structure
  • Use ZSTDv05_createCCtx() and ZSTDv05_createDCtx()
• It is necessary to init context before starting
  • compression : ZSTDv05_compressBegin()
  • decompression : ZSTDv05_decompressBegin()
  • variants _usingDict() are also allowed
  • copyCCtx() and copyDCtx() work too
• When a block is considered not compressible enough, ZSTDv05_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
  • ZSTDv05_decompressBlock() doesn't accept uncompressed data as input !!

ZSTDv05_decompressContinue()

size_t ZSTDv05_decompressContinue	(	ZSTDv05_DCtx *	dctx,
		void *	dst,
		size_t	maxDstSize,
		const void *	src,
		size_t	srcSize )

ZSTDv05_decompressDCtx()

size_t ZSTDv05_decompressDCtx	(	ZSTDv05_DCtx *	ctx,
		void *	dst,
		size_t	dstCapacity,
		const void *	src,
		size_t	srcSize )

ZSTDv05_decompressDCtx() : Same as ZSTDv05_decompress(), but requires an already allocated ZSTDv05_DCtx (see ZSTDv05_createDCtx())

ZSTDv05_findFrameSizeInfoLegacy()

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

ZSTDv05_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.5.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.

ZSTDv05_freeDCtx()

size_t ZSTDv05_freeDCtx

(

ZSTDv05_DCtx *

dctx

)

Returns

: errorCode

ZSTDv05_getErrorName()

const char * ZSTDv05_getErrorName

(

size_t

code

)

ZSTDv05_getErrorName() : provides error code string (useful for debugging)

ZSTDv05_getFrameParams()

size_t ZSTDv05_getFrameParams	(	ZSTDv05_parameters *	params,
		const void *	src,
		size_t	srcSize )

ZSTDv05_isError()

unsigned ZSTDv05_isError

(

size_t

code

)

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

ZSTDv05_nextSrcSizeToDecompress()

size_t ZSTDv05_nextSrcSizeToDecompress

(

ZSTDv05_DCtx *

dctx

)

ZSTDv05_sizeofDCtx()

size_t ZSTDv05_sizeofDCtx

(

void

)

ZSTDv05_wildcopy()

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

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