/*

* Copyright (c) 2016-present, Yann Collet, Facebook, Inc.

* All rights reserved.

*

* This source code is licensed under both the BSD-style license (found in the

* LICENSE file in the root directory of this source tree) and the GPLv2 (found

* in the COPYING file in the root directory of this source tree).

* You may select, at your option, one of the above-listed licenses.

*/

/*- Dependencies -*/

#include "zstd_v04.h"

#include "error_private.h"

/* ******************************************************************

mem.h

****************************************************************** */

#ifndef MEM_H_MODULE

#define MEM_H_MODULE

#if defined (__cplusplus)

extern "C" {

#endif

/******************************************

* Includes

******************************************/

#include <stddef.h> /* size_t, ptrdiff_t */

#include <string.h> /* memcpy */

/******************************************

* Compiler-specific

******************************************/

#if defined(_MSC_VER) /* Visual Studio */

# include <stdlib.h> /* _byteswap_ulong */

# include <intrin.h> /* _byteswap_* */

#endif

#if defined(__GNUC__)

# define MEM_STATIC static __attribute__((unused))

#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)

# define MEM_STATIC static inline

#elif defined(_MSC_VER)

# define MEM_STATIC static __inline

#else

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

#endif

/****************************************************************

* Basic Types

*****************************************************************/

#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)

# include <stdint.h>

typedef uint8_t BYTE;

typedef uint16_t U16;

typedef int16_t S16;

typedef uint32_t U32;

typedef int32_t S32;

typedef uint64_t U64;

typedef int64_t S64;

#else

typedef unsigned char BYTE;

typedef unsigned short U16;

typedef signed short S16;

typedef unsigned int U32;

typedef signed int S32;

typedef unsigned long long U64;

typedef signed long long S64;

#endif

/*-*************************************

* Debug

***************************************/

#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=1)

# include <assert.h>

#else

# ifndef assert

# define assert(condition) ((void)0)

# endif

#endif

#define ZSTD_STATIC_ASSERT(c) { enum { ZSTD_static_assert = 1/(int)(!!(c)) }; }

#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=2)

# include <stdio.h>

extern int g_debuglog_enable;

/* recommended values for ZSTD_DEBUG display levels :

* 1 : no display, enables assert() only

* 2 : reserved for currently active debug path

* 3 : events once per object lifetime (CCtx, CDict, etc.)

* 4 : events once per frame

* 5 : events once per block

* 6 : events once per sequence (*very* verbose) */

# define RAWLOG(l, ...) { \

if ((g_debuglog_enable) & (l<=ZSTD_DEBUG)) { \

fprintf(stderr, __VA_ARGS__); \

} }

# define DEBUGLOG(l, ...) { \

if ((g_debuglog_enable) & (l<=ZSTD_DEBUG)) { \

fprintf(stderr, __FILE__ ": " __VA_ARGS__); \

fprintf(stderr, " \n"); \

} }

#else

# define RAWLOG(l, ...) {} /* disabled */

# define DEBUGLOG(l, ...) {} /* disabled */

#endif

/****************************************************************

* Memory I/O

*****************************************************************/

/* MEM_FORCE_MEMORY_ACCESS

* By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.

* Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.

* The below switch allow to select different access method for improved performance.

* Method 0 (default) : use `memcpy()`. Safe and portable.

* Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).

* This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.

* Method 2 : direct access. This method is portable but violate C standard.

* It can generate buggy code on targets generating assembly depending on alignment.

* But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)

* See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.

* Prefer these methods in priority order (0 > 1 > 2)

*/

#ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */

# if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )

# define MEM_FORCE_MEMORY_ACCESS 2

# elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \

(defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))

# define MEM_FORCE_MEMORY_ACCESS 1

# endif

#endif

MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }

MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }

MEM_STATIC unsigned MEM_isLittleEndian(void)

{

const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */

return one.c[0];

}

#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)

/* violates C standard on structure alignment.

Only use if no other choice to achieve best performance on target platform */

MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }

MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }

MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }

MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }

#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)

/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */

/* currently only defined for gcc and icc */

typedef union { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign;

MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }

MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }

MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }

MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }

#else

/* default method, safe and standard.

can sometimes prove slower */

MEM_STATIC U16 MEM_read16(const void* memPtr)

{

U16 val; memcpy(&val, memPtr, sizeof(val)); return val;

}

MEM_STATIC U32 MEM_read32(const void* memPtr)

{

U32 val; memcpy(&val, memPtr, sizeof(val)); return val;

}

MEM_STATIC U64 MEM_read64(const void* memPtr)

{

U64 val; memcpy(&val, memPtr, sizeof(val)); return val;

}

MEM_STATIC void MEM_write16(void* memPtr, U16 value)

{

memcpy(memPtr, &value, sizeof(value));

}

#endif // MEM_FORCE_MEMORY_ACCESS

MEM_STATIC U16 MEM_readLE16(const void* memPtr)

{

if (MEM_isLittleEndian())

return MEM_read16(memPtr);

else

{

const BYTE* p = (const BYTE*)memPtr;

return (U16)(p[0] + (p[1]<<8));

}

}

MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)

{

if (MEM_isLittleEndian())

{

MEM_write16(memPtr, val);

}

else

{

BYTE* p = (BYTE*)memPtr;

p[0] = (BYTE)val;

p[1] = (BYTE)(val>>8);

}

}

MEM_STATIC U32 MEM_readLE32(const void* memPtr)

{

if (MEM_isLittleEndian())

return MEM_read32(memPtr);

else

{

const BYTE* p = (const BYTE*)memPtr;

return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));

}

}

MEM_STATIC U64 MEM_readLE64(const void* memPtr)

{

if (MEM_isLittleEndian())

return MEM_read64(memPtr);

else

{

const BYTE* p = (const BYTE*)memPtr;

return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)

+ ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));

}

}

MEM_STATIC size_t MEM_readLEST(const void* memPtr)

{

if (MEM_32bits())

return (size_t)MEM_readLE32(memPtr);

else

return (size_t)MEM_readLE64(memPtr);

}

#if defined (__cplusplus)

}

#endif

#endif /* MEM_H_MODULE */

/*

zstd - standard compression library

Header File for static linking only

*/

#ifndef ZSTD_STATIC_H

#define ZSTD_STATIC_H

/* The objects defined into this file shall be considered experimental.

* They are not considered stable, as their prototype may change in the future.

* You can use them for tests, provide feedback, or if you can endure risks of future changes.

*/

#if defined (__cplusplus)

extern "C" {

#endif

/* *************************************

* Types

***************************************/

#define ZSTD_WINDOWLOG_MAX 26

#define ZSTD_WINDOWLOG_MIN 18

#define ZSTD_WINDOWLOG_ABSOLUTEMIN 11

#define ZSTD_CONTENTLOG_MAX (ZSTD_WINDOWLOG_MAX+1)

#define ZSTD_CONTENTLOG_MIN 4

#define ZSTD_HASHLOG_MAX 28

#define ZSTD_HASHLOG_MIN 4

#define ZSTD_SEARCHLOG_MAX (ZSTD_CONTENTLOG_MAX-1)

#define ZSTD_SEARCHLOG_MIN 1

#define ZSTD_SEARCHLENGTH_MAX 7

#define ZSTD_SEARCHLENGTH_MIN 4

/** from faster to stronger */

typedef enum { ZSTD_fast, ZSTD_greedy, ZSTD_lazy, ZSTD_lazy2, ZSTD_btlazy2 } ZSTD_strategy;

typedef struct

{

U64 srcSize; /* optional : tells how much bytes are present in the frame. Use 0 if not known. */

U32 windowLog; /* largest match distance : larger == more compression, more memory needed during decompression */

U32 contentLog; /* full search segment : larger == more compression, slower, more memory (useless for fast) */

U32 hashLog; /* dispatch table : larger == more memory, faster */

U32 searchLog; /* nb of searches : larger == more compression, slower */

U32 searchLength; /* size of matches : larger == faster decompression, sometimes less compression */

ZSTD_strategy strategy;

} ZSTD_parameters;

typedef ZSTDv04_Dctx ZSTD_DCtx;

/* *************************************

* Advanced functions

***************************************/

/** ZSTD_decompress_usingDict

* Same as ZSTD_decompressDCtx, using a Dictionary content as prefix

* Note : dict can be NULL, in which case, it's equivalent to ZSTD_decompressDCtx() */

static size_t ZSTD_decompress_usingDict(ZSTD_DCtx* ctx,

void* dst, size_t maxDstSize,

const void* src, size_t srcSize,

const void* dict,size_t dictSize);

/* **************************************

* Streaming functions (direct mode)

****************************************/

static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx);

static size_t ZSTD_getFrameParams(ZSTD_parameters* params, const void* src, size_t srcSize);

static void ZSTD_decompress_insertDictionary(ZSTD_DCtx* ctx, const void* src, size_t srcSize);

static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);

static size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);

/**

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.

@result 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.

*/

#if defined (__cplusplus)

}

#endif

#endif /* ZSTD_STATIC_H */

/*

zstd_internal - common functions to include

Header File for include

*/

#ifndef ZSTD_CCOMMON_H_MODULE

#define ZSTD_CCOMMON_H_MODULE

#if defined (__cplusplus)

extern "C" {

#endif

/* *************************************

* Common macros

***************************************/

#define MIN(a,b) ((a)<(b) ? (a) : (b))

#define MAX(a,b) ((a)>(b) ? (a) : (b))

/* *************************************

* Common constants

***************************************/

#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 */

static const size_t ZSTD_blockHeaderSize = 3;

static const size_t ZSTD_frameHeaderSize_min = 5;

#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)

typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;

/* ******************************************

* Shared functions to include for inlining

********************************************/

static void ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }

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

/*! ZSTD_wildcopy : custom version of memcpy(), can copy up to 7-8 bytes too many */

static void ZSTD_wildcopy(void* dst, const void* src, ptrdiff_t length)

{

const BYTE* ip = (const BYTE*)src;

BYTE* op = (BYTE*)dst;

BYTE* const oend = op + length;

do

COPY8(op, ip)

while (op < oend);

}

#if defined (__cplusplus)

}

#endif

/* ******************************************************************

FSE : Finite State Entropy coder

header file

****************************************************************** */

#ifndef FSE_H

#define FSE_H

#if defined (__cplusplus)

extern "C" {

#endif

/* *****************************************

* Includes

******************************************/

#include <stddef.h> /* size_t, ptrdiff_t */

/* *****************************************

* FSE simple functions

******************************************/

static size_t FSE_decompress(void* dst, size_t maxDstSize,

const void* cSrc, size_t cSrcSize);

/*!

FSE_decompress():

Decompress FSE 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 FSE_isError()

** Important ** : FSE_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.

*/

/* *****************************************

* Tool functions

******************************************/

/* Error Management */

static unsigned FSE_isError(size_t code); /* tells if a return value is an error code */

/* *****************************************

* FSE detailed API

******************************************/

/*!

FSE_compress() does the following:

1. count symbol occurrence from source[] into table count[]

2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog)

3. save normalized counters to memory buffer using writeNCount()

4. build encoding table 'CTable' from normalized counters

5. encode the data stream using encoding table 'CTable'

FSE_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.

*/

/* *** DECOMPRESSION *** */

/*!

FSE_readNCount():

Read compactly saved 'normalizedCounter' from 'rBuffer'.

return : size read from 'rBuffer'

or an errorCode, which can be tested using FSE_isError()

maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */

static size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize);

/*!

Constructor and Destructor of type FSE_DTable

Note that its size depends on 'tableLog' */

typedef unsigned FSE_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */

/*!

FSE_buildDTable():

Builds 'dt', which must be already allocated, using FSE_createDTable()

return : 0,

or an errorCode, which can be tested using FSE_isError() */

static size_t FSE_buildDTable ( FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);

/*!

FSE_decompress_usingDTable():

Decompress compressed source 'cSrc' of size 'cSrcSize' using 'dt'

into 'dst' which must be already allocated.

return : size of regenerated data (necessarily <= maxDstSize)

or an errorCode, which can be tested using FSE_isError() */

static size_t FSE_decompress_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt);

/*!

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)

*/

#if defined (__cplusplus)

}

#endif

#endif /* FSE_H */

/* ******************************************************************

bitstream

Part of NewGen Entropy library

header file (to include)

Copyright (C) 2013-2015, Yann Collet.

BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are

met:

* Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above

copyright notice, this list of conditions and the following disclaimer

in the documentation and/or other materials provided with the

distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

You can contact the author at :

- Source repository : https://github.com/Cyan4973/FiniteStateEntropy

- Public forum : https://groups.google.com/forum/#!forum/lz4c

****************************************************************** */

#ifndef BITSTREAM_H_MODULE

#define BITSTREAM_H_MODULE

#if defined (__cplusplus)

extern "C" {

#endif

/*

* This API consists of small unitary functions, which highly benefit from being inlined.

* Since link-time-optimization is not available for all compilers,

* these functions are defined into a .h to be included.

*/

/**********************************************

* bitStream decompression API (read backward)

**********************************************/

typedef struct

{

size_t bitContainer;

unsigned bitsConsumed;

const char* ptr;

const char* start;

} BIT_DStream_t;

typedef enum { BIT_DStream_unfinished = 0,

BIT_DStream_endOfBuffer = 1,

BIT_DStream_completed = 2,

BIT_DStream_overflow = 3 } BIT_DStream_status; /* result of BIT_reloadDStream() */

/* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */

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);

/******************************************

* unsafe API

******************************************/

MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);

/* faster, but works only if nbBits >= 1 */

/****************************************************************

* Helper functions

****************************************************************/

MEM_STATIC unsigned BIT_highbit32 (U32 val)

{

# if defined(_MSC_VER) /* Visual */

unsigned long r=0;

_BitScanReverse ( &r, val );

return (unsigned) r;

# elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */

return 31 - __builtin_clz (val);

# else /* Software version */

static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };

U32 v = val;

unsigned r;

v |= v >> 1;

v |= v >> 2;

v |= v >> 4;

v |= v >> 8;

v |= v >> 16;

r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];

return r;

# endif

}

/**********************************************************

* bitStream decoding

**********************************************************/

/*!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

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

*/

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

{

if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }

if (srcSize >= sizeof(size_t)) /* normal case */

{

U32 contain32;

bitD->start = (const char*)srcBuffer;

bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(size_t);

bitD->bitContainer = MEM_readLEST(bitD->ptr);

contain32 = ((const BYTE*)srcBuffer)[srcSize-1];

if (contain32 == 0) return ERROR(GENERIC); /* endMark not present */

bitD->bitsConsumed = 8 - BIT_highbit32(contain32);

}

else

{

U32 contain32;

bitD->start = (const char*)srcBuffer;

bitD->ptr = bitD->start;

bitD->bitContainer = *(const BYTE*)(bitD->start);

switch(srcSize)

{

case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);/* fall-through */

case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);/* fall-through */

case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);/* fall-through */

case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; /* fall-through */

case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; /* fall-through */

case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) << 8; /* fall-through */

default: break;

}

contain32 = ((const BYTE*)srcBuffer)[srcSize-1];

if (contain32 == 0) return ERROR(GENERIC); /* endMark not present */

bitD->bitsConsumed = 8 - BIT_highbit32(contain32);

bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;

}

return srcSize;

}

MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)

{

const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;

return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);

}

/*! BIT_lookBitsFast :

* unsafe version; only works only if nbBits >= 1 */

MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits)

{

const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;

return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);

}

MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)

{

bitD->bitsConsumed += nbBits;

}

MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)

{

size_t value = BIT_lookBits(bitD, nbBits);

BIT_skipBits(bitD, nbBits);

return value;

}

/*!BIT_readBitsFast :

* unsafe version; only works only if nbBits >= 1 */

MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)

{

size_t value = BIT_lookBitsFast(bitD, nbBits);

BIT_skipBits(bitD, nbBits);

return value;

}

MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)

{

if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* should never happen */

return BIT_DStream_overflow;

if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))

{

bitD->ptr -= bitD->bitsConsumed >> 3;

bitD->bitsConsumed &= 7;

bitD->bitContainer = MEM_readLEST(bitD->ptr);

return BIT_DStream_unfinished;

}

if (bitD->ptr == bitD->start)

{

if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;

return BIT_DStream_completed;

}

{

U32 nbBytes = bitD->bitsConsumed >> 3;

BIT_DStream_status result = BIT_DStream_unfinished;

if (bitD->ptr - nbBytes < bitD->start)

{

nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */

result = BIT_DStream_endOfBuffer;

}

bitD->ptr -= nbBytes;

bitD->bitsConsumed -= nbBytes*8;

bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD) */

return result;

}

}

/*! BIT_endOfDStream

* @return Tells if DStream has reached its exact end

*/

MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)

{

return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));

}

#if defined (__cplusplus)

}

#endif

#endif /* BITSTREAM_H_MODULE */

/* ******************************************************************

FSE : Finite State Entropy coder

header file for static linking (only)

Copyright (C) 2013-2015, Yann Collet

BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are

met:

* Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above

copyright notice, this list of conditions and the following disclaimer

in the documentation and/or other materials provided with the

distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

You can contact the author at :

- Source repository : https://github.com/Cyan4973/FiniteStateEntropy

- Public forum : https://groups.google.com/forum/#!forum/lz4c

****************************************************************** */

#ifndef FSE_STATIC_H

#define FSE_STATIC_H

#if defined (__cplusplus)

extern "C" {

#endif

/* *****************************************

* Static allocation

*******************************************/

/* FSE buffer bounds */

#define FSE_NCOUNTBOUND 512

#define FSE_BLOCKBOUND(size) (size + (size>>7))

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

/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */

#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))

#define FSE_DTABLE_SIZE_U32(maxTableLog) (1 + (1<<maxTableLog))

/* *****************************************

* FSE advanced API

*******************************************/

static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);

/* build a fake FSE_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */

static size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);

/* build a fake FSE_DTable, designed to always generate the same symbolValue */

/* *****************************************

* FSE symbol decompression API

*******************************************/

typedef struct

{

size_t state;

const void* table; /* precise table may vary, depending on U16 */

} FSE_DState_t;

static void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);

static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);

static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);

/* *****************************************

* FSE unsafe API

*******************************************/

static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);

/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */

/* *****************************************

* Implementation of inlined functions

*******************************************/

/* decompression */

typedef struct {

U16 tableLog;

U16 fastMode;

} FSE_DTableHeader; /* sizeof U32 */

typedef struct

{

unsigned short newState;

unsigned char symbol;

unsigned char nbBits;

} FSE_decode_t; /* size == U32 */

MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)

{

FSE_DTableHeader DTableH;

memcpy(&DTableH, dt, sizeof(DTableH));

DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog);

BIT_reloadDStream(bitD);

DStatePtr->table = dt + 1;

}

MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)

{

const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];

const U32 nbBits = DInfo.nbBits;

BYTE symbol = DInfo.symbol;

size_t lowBits = BIT_readBits(bitD, nbBits);

DStatePtr->state = DInfo.newState + lowBits;

return symbol;

}

MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)

{

const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];

const U32 nbBits = DInfo.nbBits;

BYTE symbol = DInfo.symbol;

size_t lowBits = BIT_readBitsFast(bitD, nbBits);

DStatePtr->state = DInfo.newState + lowBits;

return symbol;

}

MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)

{

return DStatePtr->state == 0;

}

#if defined (__cplusplus)

}

#endif

#endif /* FSE_STATIC_H */

/* ******************************************************************

FSE : Finite State Entropy coder

Copyright (C) 2013-2015, Yann Collet.

BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are

met:

* Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above

copyright notice, this list of conditions and the following disclaimer

in the documentation and/or other materials provided with the

distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR