zstd_v04.c File Reference

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

Data Structures
struct	ZSTD_parameters
struct	BIT_DStream_t
struct	FSE_DState_t
struct	FSE_DTableHeader
struct	FSE_decode_t
struct	HUF_DEltX2
struct	HUF_DEltX4
struct	sortedSymbol_t
struct	algo_time_t
struct	blockProperties_t
struct	ZSTDv04_Dctx_s
struct	seq_t
struct	seqState_t
struct	ZBUFFv04_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	ZSTD_WINDOWLOG_ABSOLUTEMIN   11
#define	ZSTD_CCOMMON_H_MODULE
#define	MIN(a, b)
#define	MAX(a, b)
#define	ZSTD_MAGICNUMBER   0xFD2FB524 /* v0.4 */
#define	KB   *(1 <<10)
#define	MB   *(1 <<20)
#define	GB   *(1U<<30)
#define	BLOCKSIZE   (128 KB) /* define, for static allocation */
#define	ZSTD_frameHeaderSize_max   5 /* define, for static allocation */
#define	BIT7   128
#define	BIT6   64
#define	BIT5   32
#define	BIT4   16
#define	BIT1   2
#define	BIT0   1
#define	IS_RAW   BIT0
#define	IS_RLE   BIT1
#define	MINMATCH   4
#define	REPCODE_STARTVALUE   4
#define	MLbits   7
#define	LLbits   6
#define	Offbits   5
#define	MaxML   ((1<<MLbits) - 1)
#define	MaxLL   ((1<<LLbits) - 1)
#define	MaxOff   ((1<<Offbits)- 1)
#define	MLFSELog   10
#define	LLFSELog   10
#define	OffFSELog   9
#define	MaxSeq   MAX(MaxLL, MaxML)
#define	MIN_SEQUENCES_SIZE   (2 /*seqNb*/ + 2 /*dumps*/ + 3 /*seqTables*/ + 1 /*bitStream*/)
#define	MIN_CBLOCK_SIZE   (3 /*litCSize*/ + MIN_SEQUENCES_SIZE)
#define	ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
#define	COPY8(d, s)
#define	FSE_H
#define	BITSTREAM_H_MODULE
#define	FSE_STATIC_H
#define	FSE_NCOUNTBOUND   512
#define	FSE_BLOCKBOUND(size)
#define	FSE_COMPRESSBOUND(size)
#define	FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)
#define	FSE_DTABLE_SIZE_U32(maxTableLog)
#define	FSE_MAX_MEMORY_USAGE   14
#define	FSE_DEFAULT_MEMORY_USAGE   13
#define	FSE_MAX_SYMBOL_VALUE   255
#define	FSE_FUNCTION_TYPE   BYTE
#define	FSE_FUNCTION_EXTENSION
#define	FSE_DECODE_TYPE   FSE_decode_t
#define	FORCE_INLINE   static
#define	FSE_MAX_TABLELOG   (FSE_MAX_MEMORY_USAGE-2)
#define	FSE_MAX_TABLESIZE   (1U<<FSE_MAX_TABLELOG)
#define	FSE_MAXTABLESIZE_MASK   (FSE_MAX_TABLESIZE-1)
#define	FSE_DEFAULT_TABLELOG   (FSE_DEFAULT_MEMORY_USAGE-2)
#define	FSE_MIN_TABLELOG   5
#define	FSE_TABLELOG_ABSOLUTE_MAX   15
#define	FSE_STATIC_ASSERT(c)
#define	FSE_CAT(X, Y)
#define	FSE_FUNCTION_NAME(X, Y)
#define	FSE_TYPE_NAME(X, Y)
#define	FSE_GETSYMBOL(statePtr)
#define	HUFF0_H
#define	HUFF0_STATIC_H
#define	HUF_DTABLE_SIZE(maxTableLog)
#define	HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog)
#define	HUF_CREATE_STATIC_DTABLEX4(DTable, maxTableLog)
#define	HUF_CREATE_STATIC_DTABLEX6(DTable, maxTableLog)
#define	inline   /* disable inline */
#define	HUF_ABSOLUTEMAX_TABLELOG   16 /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */
#define	HUF_MAX_TABLELOG   12 /* max configured tableLog (for static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */
#define	HUF_DEFAULT_TABLELOG   HUF_MAX_TABLELOG /* tableLog by default, when not specified */
#define	HUF_MAX_SYMBOL_VALUE   255
#define	HUF_STATIC_ASSERT(c)
#define	HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
#define	HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr)
#define	HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr)
#define	HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr)
#define	HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr)
#define	HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr)
#define	ZSTD_HEAPMODE   1
#define	ZSTD_frameHeaderSize_max   5 /* too magical, should come from reference */

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

Enumerations
enum	ZSTD_strategy {   ZSTD_fast , ZSTD_greedy , ZSTD_lazy , ZSTD_lazy2 ,   ZSTD_btlazy2 }
enum	blockType_t { bt_compressed , bt_raw , bt_rle , bt_end }
enum	BIT_DStream_status { BIT_DStream_unfinished = 0 , BIT_DStream_endOfBuffer = 1 , BIT_DStream_completed = 2 , BIT_DStream_overflow = 3 }
enum	ZSTD_dStage { ZSTDds_getFrameHeaderSize , ZSTDds_decodeFrameHeader , ZSTDds_decodeBlockHeader , ZSTDds_decompressBlock }
enum	ZBUFF_dStage {   ZBUFFds_init , ZBUFFds_readHeader , ZBUFFds_loadHeader , ZBUFFds_decodeHeader ,   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 U16	MEM_readLE16 (const void *memPtr)
MEM_STATIC void	MEM_writeLE16 (void *memPtr, U16 val)
MEM_STATIC U32	MEM_readLE24 (const void *memPtr)
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)
MEM_STATIC size_t	BIT_initDStream (BIT_DStream_t *bitD, const void *srcBuffer, size_t srcSize)
MEM_STATIC size_t	BIT_readBits (BIT_DStream_t *bitD, unsigned nbBits)
MEM_STATIC BIT_DStream_status	BIT_reloadDStream (BIT_DStream_t *bitD)
MEM_STATIC unsigned	BIT_endOfDStream (const BIT_DStream_t *bitD)
MEM_STATIC size_t	BIT_readBitsFast (BIT_DStream_t *bitD, unsigned nbBits)
MEM_STATIC unsigned	BIT_highbit32 (U32 val)
MEM_STATIC size_t	BIT_lookBits (BIT_DStream_t *bitD, U32 nbBits)
MEM_STATIC size_t	BIT_lookBitsFast (BIT_DStream_t *bitD, U32 nbBits)
MEM_STATIC void	BIT_skipBits (BIT_DStream_t *bitD, U32 nbBits)
MEM_STATIC size_t	BIT_readBits (BIT_DStream_t *bitD, U32 nbBits)
MEM_STATIC size_t	BIT_readBitsFast (BIT_DStream_t *bitD, U32 nbBits)
FORCE_INLINE size_t	FSE_decompress_usingDTable_generic (void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const FSE_DTable *dt, const unsigned fast)
void	ZSTDv04_findFrameSizeInfoLegacy (const void *src, size_t srcSize, size_t *cSize, unsigned long long *dBound)
unsigned	ZBUFFv04_isError (size_t errorCode)
const char *	ZBUFFv04_getErrorName (size_t errorCode)
size_t	ZBUFFv04_recommendedDInSize ()
size_t	ZBUFFv04_recommendedDOutSize ()
size_t	ZSTDv04_decompressDCtx (ZSTD_DCtx *dctx, void *dst, size_t maxDstSize, const void *src, size_t srcSize)
size_t	ZSTDv04_decompress (void *dst, size_t maxDstSize, const void *src, size_t srcSize)
size_t	ZSTDv04_resetDCtx (ZSTDv04_Dctx *dctx)
size_t	ZSTDv04_nextSrcSizeToDecompress (ZSTDv04_Dctx *dctx)
size_t	ZSTDv04_decompressContinue (ZSTDv04_Dctx *dctx, void *dst, size_t maxDstSize, const void *src, size_t srcSize)
ZBUFFv04_DCtx *	ZBUFFv04_createDCtx (void)
size_t	ZBUFFv04_freeDCtx (ZBUFFv04_DCtx *dctx)
size_t	ZBUFFv04_decompressInit (ZBUFFv04_DCtx *dctx)
size_t	ZBUFFv04_decompressWithDictionary (ZBUFFv04_DCtx *dctx, const void *src, size_t srcSize)
size_t	ZBUFFv04_decompressContinue (ZBUFFv04_DCtx *dctx, void *dst, size_t *maxDstSizePtr, const void *src, size_t *srcSizePtr)
ZSTD_DCtx *	ZSTDv04_createDCtx (void)
size_t	ZSTDv04_freeDCtx (ZSTD_DCtx *dctx)

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 FSE_readNCount() if it was saved using FSE_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). FSE_readNCount() will provide 'tableLog' and 'maxSymbolValue'. The result of FSE_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 FSE_isError().

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

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

BLOCKSIZE

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

COPY8

#define COPY8	(		d,
			s )

Value:

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

FORCE_INLINE

#define FORCE_INLINE   static

FSE_BLOCKBOUND

#define FSE_BLOCKBOUND

(

size

)

Value:

(size + (size>>7))

FSE_CAT

#define FSE_CAT	(		X,
			Y )

Value:

X##Y

FSE_COMPRESSBOUND

#define FSE_COMPRESSBOUND

(

size

)

Value:

(FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */

FSE_CTABLE_SIZE_U32

#define FSE_CTABLE_SIZE_U32	(		maxTableLog,
			maxSymbolValue )

Value:

(1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))

FSE_DECODE_TYPE

#define FSE_DECODE_TYPE   FSE_decode_t

FSE_DEFAULT_MEMORY_USAGE

#define FSE_DEFAULT_MEMORY_USAGE   13

FSE_DEFAULT_TABLELOG

#define FSE_DEFAULT_TABLELOG   (FSE_DEFAULT_MEMORY_USAGE-2)

FSE_DTABLE_SIZE_U32

#define FSE_DTABLE_SIZE_U32

(

maxTableLog

)

Value:

(1 + (1<<maxTableLog))

FSE_FUNCTION_EXTENSION

#define FSE_FUNCTION_EXTENSION

FSE_FUNCTION_NAME

#define FSE_FUNCTION_NAME	(		X,
			Y )

Value:

FSE_CAT(X,Y)

FSE_FUNCTION_TYPE

#define FSE_FUNCTION_TYPE   BYTE

FSE_GETSYMBOL

#define FSE_GETSYMBOL

(

statePtr

)

Value:

fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)

FSE_H

#define FSE_H

FSE_MAX_MEMORY_USAGE

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

FSE_MAX_SYMBOL_VALUE

#define FSE_MAX_SYMBOL_VALUE   255

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

FSE_MAX_TABLELOG

#define FSE_MAX_TABLELOG   (FSE_MAX_MEMORY_USAGE-2)

FSE_MAX_TABLESIZE

#define FSE_MAX_TABLESIZE   (1U<<FSE_MAX_TABLELOG)

FSE_MAXTABLESIZE_MASK

#define FSE_MAXTABLESIZE_MASK   (FSE_MAX_TABLESIZE-1)

FSE_MIN_TABLELOG

#define FSE_MIN_TABLELOG   5

FSE_NCOUNTBOUND

#define FSE_NCOUNTBOUND   512

FSE_STATIC_ASSERT

#define FSE_STATIC_ASSERT

(

c

)

Value:

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

FSE_STATIC_H

#define FSE_STATIC_H

FSE_TABLELOG_ABSOLUTE_MAX

#define FSE_TABLELOG_ABSOLUTE_MAX   15

FSE_TYPE_NAME

#define FSE_TYPE_NAME	(		X,
			Y )

Value:

FSE_CAT(X,Y)

GB

#define GB   *(1U<<30)

HUF_ABSOLUTEMAX_TABLELOG

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

HUF_CREATE_STATIC_DTABLEX2

#define HUF_CREATE_STATIC_DTABLEX2	(		DTable,
			maxTableLog )

Value:

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

HUF_CREATE_STATIC_DTABLEX4

#define HUF_CREATE_STATIC_DTABLEX4	(		DTable,
			maxTableLog )

Value:

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

HUF_CREATE_STATIC_DTABLEX6

#define HUF_CREATE_STATIC_DTABLEX6	(		DTable,
			maxTableLog )

Value:

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

HUF_DECODE_SYMBOLX2_0

#define HUF_DECODE_SYMBOLX2_0	(		ptr,
			DStreamPtr )

Value:

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

HUF_DECODE_SYMBOLX2_1

#define HUF_DECODE_SYMBOLX2_1	(		ptr,
			DStreamPtr )

Value:

    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)

HUF_DECODE_SYMBOLX2_2

#define HUF_DECODE_SYMBOLX2_2	(		ptr,
			DStreamPtr )

Value:

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

HUF_DECODE_SYMBOLX4_0

#define HUF_DECODE_SYMBOLX4_0	(		ptr,
			DStreamPtr )

Value:

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

HUF_DECODE_SYMBOLX4_1

#define HUF_DECODE_SYMBOLX4_1	(		ptr,
			DStreamPtr )

Value:

    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)

HUF_DECODE_SYMBOLX4_2

#define HUF_DECODE_SYMBOLX4_2	(		ptr,
			DStreamPtr )

Value:

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

HUF_DEFAULT_TABLELOG

#define HUF_DEFAULT_TABLELOG   HUF_MAX_TABLELOG /* tableLog by default, when not specified */

HUF_DTABLE_SIZE

#define HUF_DTABLE_SIZE

(

maxTableLog

)

Value:

(1 + (1<<maxTableLog))  /* nb Cells; use unsigned short for X2, unsigned int for X4 */

HUF_MAX_SYMBOL_VALUE

#define HUF_MAX_SYMBOL_VALUE   255

HUF_MAX_TABLELOG

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

HUF_STATIC_ASSERT

#define HUF_STATIC_ASSERT

(

c

)

Value:

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

HUFF0_H

#define HUFF0_H

HUFF0_STATIC_H

#define HUFF0_STATIC_H

inline

#define inline   /* disable inline */

IS_RAW

#define IS_RAW   BIT0

IS_RLE

#define IS_RLE   BIT1

KB

#define KB   *(1 <<10)

LLbits

#define LLbits   6

LLFSELog

#define LLFSELog   10

MAX

#define MAX	(		a,
			b )

Value:

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

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   (3 /*litCSize*/ + MIN_SEQUENCES_SIZE)

MIN_SEQUENCES_SIZE

#define MIN_SEQUENCES_SIZE   (2 /*seqNb*/ + 2 /*dumps*/ + 3 /*seqTables*/ + 1 /*bitStream*/)

MINMATCH

#define MINMATCH   4

MLbits

#define MLbits   7

MLFSELog

#define MLFSELog   10

Offbits

#define Offbits   5

OffFSELog

#define OffFSELog   9

REPCODE_STARTVALUE

#define REPCODE_STARTVALUE   4

ZSTD_CCOMMON_H_MODULE

#define ZSTD_CCOMMON_H_MODULE

Streaming decompression, bufferless mode

A ZSTD_DCtx object is required to track streaming operations. Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it. A ZSTD_DCtx object can be re-used multiple times. Use ZSTD_resetDCtx() to return to fresh status.

First operation is to retrieve frame parameters, using ZSTD_getFrameParams(). This function doesn't consume its input. It needs enough input data to properly decode the frame header. Objective is to retrieve *params.windowlog, to know minimum amount of memory required during decoding. Result : 0 when successful, it means the ZSTD_parameters structure has been filled. >0 : means there is not enough data into src. Provides the expected size to successfully decode header. errorCode, which can be tested using ZSTD_isError() (For example, if it's not a ZSTD header)

Then, you can optionally insert a dictionary. This operation must mimic the compressor behavior, otherwise decompression will fail or be corrupted.

Then it's possible to start decompression. Use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively. ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue(). ZSTD_decompressContinue() requires this exact amount of bytes, or it will fail. ZSTD_decompressContinue() needs previous data blocks during decompression, up to (1 << windowlog). They should preferably be located contiguously, prior to current block. Alternatively, a round buffer is also possible.

Returns

of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst'. It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.

A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero. Context can then be reset to start a new decompression.

ZSTD_CONTENTSIZE_ERROR

#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)

ZSTD_frameHeaderSize_max [1/2]

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

ZSTD_frameHeaderSize_max [2/2]

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

ZSTD_HEAPMODE

#define ZSTD_HEAPMODE   1

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

ZSTD_MAGICNUMBER

#define ZSTD_MAGICNUMBER   0xFD2FB524 /* v0.4 */

ZSTD_STATIC_H

#define ZSTD_STATIC_H

ZSTD_WINDOWLOG_ABSOLUTEMIN

#define ZSTD_WINDOWLOG_ABSOLUTEMIN   11

Typedef Documentation

decompressionAlgo

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

Enumeration Type Documentation

BIT_DStream_status

enum BIT_DStream_status

Enumerator
BIT_DStream_unfinished
BIT_DStream_endOfBuffer
BIT_DStream_completed
BIT_DStream_overflow

blockType_t

enum blockType_t

Enumerator
bt_compressed
bt_raw
bt_rle
bt_end

ZBUFF_dStage

enum ZBUFF_dStage

---

Streaming decompression

A ZBUFF_DCtx object is required to track streaming operation. Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources. Use ZBUFF_decompressInit() to start a new decompression operation. ZBUFF_DCtx objects can be reused multiple times.

Use ZBUFF_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 ZBUFF_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 ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .

Enumerator
ZBUFFds_init
ZBUFFds_readHeader
ZBUFFds_loadHeader
ZBUFFds_decodeHeader
ZBUFFds_read
ZBUFFds_load
ZBUFFds_flush

ZSTD_dStage

enum ZSTD_dStage

Enumerator
ZSTDds_getFrameHeaderSize
ZSTDds_decodeFrameHeader
ZSTDds_decodeBlockHeader
ZSTDds_decompressBlock

ZSTD_strategy

enum ZSTD_strategy

from faster to stronger

Enumerator
ZSTD_fast
ZSTD_greedy
ZSTD_lazy
ZSTD_lazy2
ZSTD_btlazy2

Function Documentation

BIT_endOfDStream()

MEM_STATIC unsigned BIT_endOfDStream

(

const BIT_DStream_t *

DStream

)

BIT_endOfDStream

Returns

Tells if DStream has reached its exact end

BIT_highbit32()

MEM_STATIC unsigned BIT_highbit32

(

U32

val

)

BIT_initDStream()

MEM_STATIC size_t BIT_initDStream	(	BIT_DStream_t *	bitD,
		const void *	srcBuffer,
		size_t	srcSize )

BIT_initDStream Initialize a BIT_DStream_t. @bitD : a pointer to an already allocated BIT_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

BIT_lookBits()

MEM_STATIC size_t BIT_lookBits	(	BIT_DStream_t *	bitD,
		U32	nbBits )

BIT_lookBitsFast()

MEM_STATIC size_t BIT_lookBitsFast	(	BIT_DStream_t *	bitD,
		U32	nbBits )

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

BIT_readBits() [1/2]

MEM_STATIC size_t BIT_readBits	(	BIT_DStream_t *	bitD,
		U32	nbBits )

BIT_readBits() [2/2]

MEM_STATIC size_t BIT_readBits	(	BIT_DStream_t *	bitD,
		unsigned	nbBits )

BIT_readBits() : Read (consume) next n bits from local register and update. Pay attention to not read more than nbBits contained into local register.

Returns

: extracted value.

BIT_readBitsFast() [1/2]

MEM_STATIC size_t BIT_readBitsFast	(	BIT_DStream_t *	bitD,
		U32	nbBits )

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

BIT_readBitsFast() [2/2]

MEM_STATIC size_t BIT_readBitsFast	(	BIT_DStream_t *	bitD,
		unsigned	nbBits )

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

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

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

BIT_reloadDStream()

MEM_STATIC BIT_DStream_status BIT_reloadDStream

(

BIT_DStream_t *

bitD

)

BIT_skipBits()

MEM_STATIC void BIT_skipBits	(	BIT_DStream_t *	bitD,
		U32	nbBits )

FSE_decompress_usingDTable_generic()

FORCE_INLINE size_t FSE_decompress_usingDTable_generic	(	void *	dst,
		size_t	maxDstSize,
		const void *	cSrc,
		size_t	cSrcSize,
		const FSE_DTable *	dt,
		const unsigned	fast )

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

MEM_STATIC U32 MEM_readLE24

(

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

MEM_STATIC void MEM_writeLE16	(	void *	memPtr,
		U16	val )

ZBUFFv04_createDCtx()

ZBUFFv04_DCtx * ZBUFFv04_createDCtx

(

void

)

ZBUFFv04_decompressContinue()

size_t ZBUFFv04_decompressContinue	(	ZBUFFv04_DCtx *	dctx,
		void *	dst,
		size_t *	maxDstSizePtr,
		const void *	src,
		size_t *	srcSizePtr )

ZBUFFv04_decompressInit()

size_t ZBUFFv04_decompressInit

(

ZBUFFv04_DCtx *

dctx

)

ZBUFFv04_decompressWithDictionary()

size_t ZBUFFv04_decompressWithDictionary	(	ZBUFFv04_DCtx *	dctx,
		const void *	src,
		size_t	srcSize )

ZBUFFv04_freeDCtx()

size_t ZBUFFv04_freeDCtx

(

ZBUFFv04_DCtx *

dctx

)

ZBUFFv04_getErrorName()

const char * ZBUFFv04_getErrorName

(

size_t

errorCode

)

ZBUFFv04_isError()

unsigned ZBUFFv04_isError

(

size_t

errorCode

)

---

Streaming decompression

A ZBUFF_DCtx object is required to track streaming operation. Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources. Use ZBUFF_decompressInit() to start a new decompression operation. ZBUFF_DCtx objects can be reused multiple times.

Optionally, a reference to a static dictionary can be set, using ZBUFF_decompressWithDictionary() It must be the same content as the one set during compression phase. Dictionary content must remain accessible during the decompression process.

Use ZBUFF_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 present remaining input again. The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst.

Returns

: 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 ZBUFF_isError().

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

ZBUFFv04_recommendedDInSize()

size_t ZBUFFv04_recommendedDInSize

(

void

)

The below functions provide recommended buffer sizes for Compression or Decompression operations. These sizes are not compulsory, they just tend to offer better latency

ZBUFFv04_recommendedDOutSize()

size_t ZBUFFv04_recommendedDOutSize

(

void

)

ZSTDv04_createDCtx()

ZSTD_DCtx * ZSTDv04_createDCtx

(

void

)

ZSTDv04_decompress()

size_t ZSTDv04_decompress	(	void *	dst,
		size_t	maxOriginalSize,
		const void *	src,
		size_t	compressedSize )

ZSTDv04_decompress() : decompress ZSTD frames compliant with v0.4.x format compressedSize : is the exact source size maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated. It must be equal or larger than originalSize, otherwise decompression will fail. return : the number of bytes decompressed into destination buffer (originalSize) or an errorCode if it fails (which can be tested using ZSTDv01_isError())

ZSTDv04_decompressContinue()

size_t ZSTDv04_decompressContinue	(	ZSTDv04_Dctx *	dctx,
		void *	dst,
		size_t	maxDstSize,
		const void *	src,
		size_t	srcSize )

ZSTDv04_decompressDCtx()

size_t ZSTDv04_decompressDCtx	(	ZSTD_DCtx *	dctx,
		void *	dst,
		size_t	maxDstSize,
		const void *	src,
		size_t	srcSize )

ZSTDv04_findFrameSizeInfoLegacy()

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

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

ZSTDv04_freeDCtx()

size_t ZSTDv04_freeDCtx

(

ZSTD_DCtx *

dctx

)

ZSTDv04_nextSrcSizeToDecompress()

size_t ZSTDv04_nextSrcSizeToDecompress

(

ZSTDv04_Dctx *

dctx

)

ZSTDv04_resetDCtx()

size_t ZSTDv04_resetDCtx

(

ZSTDv04_Dctx *

dctx

)