ReactOS 0.4.15-dev-7085-g12a5971
fse.h
Go to the documentation of this file.
1/* ******************************************************************
2 * FSE : Finite State Entropy codec
3 * Public Prototypes declaration
4 * Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
5 *
6 * You can contact the author at :
7 * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
8 *
9 * This source code is licensed under both the BSD-style license (found in the
10 * LICENSE file in the root directory of this source tree) and the GPLv2 (found
11 * in the COPYING file in the root directory of this source tree).
12 * You may select, at your option, one of the above-listed licenses.
13****************************************************************** */
14
15#if defined (__cplusplus)
16extern "C" {
17#endif
18
19#ifndef FSE_H
20#define FSE_H
21
22
23/*-*****************************************
24* Dependencies
25******************************************/
26#include <stddef.h> /* size_t, ptrdiff_t */
27
28
29/*-*****************************************
30* FSE_PUBLIC_API : control library symbols visibility
31******************************************/
32#if defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) && defined(__GNUC__) && (__GNUC__ >= 4)
33# define FSE_PUBLIC_API __attribute__ ((visibility ("default")))
34#elif defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) /* Visual expected */
35# define FSE_PUBLIC_API __declspec(dllexport)
36#elif defined(FSE_DLL_IMPORT) && (FSE_DLL_IMPORT==1)
37# define FSE_PUBLIC_API __declspec(dllimport) /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
38#else
39# define FSE_PUBLIC_API
40#endif
41
42/*------ Version ------*/
43#define FSE_VERSION_MAJOR 0
44#define FSE_VERSION_MINOR 9
45#define FSE_VERSION_RELEASE 0
46
47#define FSE_LIB_VERSION FSE_VERSION_MAJOR.FSE_VERSION_MINOR.FSE_VERSION_RELEASE
48#define FSE_QUOTE(str) #str
49#define FSE_EXPAND_AND_QUOTE(str) FSE_QUOTE(str)
50#define FSE_VERSION_STRING FSE_EXPAND_AND_QUOTE(FSE_LIB_VERSION)
51
52#define FSE_VERSION_NUMBER (FSE_VERSION_MAJOR *100*100 + FSE_VERSION_MINOR *100 + FSE_VERSION_RELEASE)
53FSE_PUBLIC_API unsigned FSE_versionNumber(void);
56/*-****************************************
57* FSE simple functions
58******************************************/
67FSE_PUBLIC_API size_t FSE_compress(void* dst, size_t dstCapacity,
68 const void* src, size_t srcSize);
69
80FSE_PUBLIC_API size_t FSE_decompress(void* dst, size_t dstCapacity,
81 const void* cSrc, size_t cSrcSize);
82
83
84/*-*****************************************
85* Tool functions
86******************************************/
87FSE_PUBLIC_API size_t FSE_compressBound(size_t size); /* maximum compressed size */
88
89/* Error Management */
90FSE_PUBLIC_API unsigned FSE_isError(size_t code); /* tells if a return value is an error code */
91FSE_PUBLIC_API const char* FSE_getErrorName(size_t code); /* provides error code string (useful for debugging) */
92
93
94/*-*****************************************
95* FSE advanced functions
96******************************************/
105FSE_PUBLIC_API size_t FSE_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
106
107
108/*-*****************************************
109* FSE detailed API
110******************************************/
129/* *** COMPRESSION *** */
130
135FSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue);
136
142FSE_PUBLIC_API size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog,
143 const unsigned* count, size_t srcSize, unsigned maxSymbolValue);
144
148FSE_PUBLIC_API size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog);
149
154FSE_PUBLIC_API size_t FSE_writeNCount (void* buffer, size_t bufferSize,
155 const short* normalizedCounter,
156 unsigned maxSymbolValue, unsigned tableLog);
157
160typedef unsigned FSE_CTable; /* don't allocate that. It's only meant to be more restrictive than void* */
161FSE_PUBLIC_API FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog);
163
167FSE_PUBLIC_API size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
168
174FSE_PUBLIC_API size_t FSE_compress_usingCTable (void* dst, size_t dstCapacity, const void* src, size_t srcSize, const FSE_CTable* ct);
175
220/* *** DECOMPRESSION *** */
221
227FSE_PUBLIC_API size_t FSE_readNCount (short* normalizedCounter,
228 unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,
229 const void* rBuffer, size_t rBuffSize);
230
233typedef unsigned FSE_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */
234FSE_PUBLIC_API FSE_DTable* FSE_createDTable(unsigned tableLog);
236
240FSE_PUBLIC_API size_t FSE_buildDTable (FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
241
247FSE_PUBLIC_API size_t FSE_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt);
248
277#endif /* FSE_H */
278
279#if defined(FSE_STATIC_LINKING_ONLY) && !defined(FSE_H_FSE_STATIC_LINKING_ONLY)
280#define FSE_H_FSE_STATIC_LINKING_ONLY
281
282/* *** Dependency *** */
283#include "bitstream.h"
284
285
286/* *****************************************
287* Static allocation
288*******************************************/
289/* FSE buffer bounds */
290#define FSE_NCOUNTBOUND 512
291#define FSE_BLOCKBOUND(size) (size + (size>>7) + 4 /* fse states */ + sizeof(size_t) /* bitContainer */)
292#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size)) /* Macro version, useful for static allocation */
293
294/* It is possible to statically allocate FSE CTable/DTable as a table of FSE_CTable/FSE_DTable using below macros */
295#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))
296#define FSE_DTABLE_SIZE_U32(maxTableLog) (1 + (1<<maxTableLog))
297
298/* or use the size to malloc() space directly. Pay attention to alignment restrictions though */
299#define FSE_CTABLE_SIZE(maxTableLog, maxSymbolValue) (FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(FSE_CTable))
300#define FSE_DTABLE_SIZE(maxTableLog) (FSE_DTABLE_SIZE_U32(maxTableLog) * sizeof(FSE_DTable))
301
302
303/* *****************************************
304 * FSE advanced API
305 ***************************************** */
306
307unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus);
310/* FSE_compress_wksp() :
311 * Same as FSE_compress2(), but using an externally allocated scratch buffer (`workSpace`).
312 * FSE_WKSP_SIZE_U32() provides the minimum size required for `workSpace` as a table of FSE_CTable.
313 */
314#define FSE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) ( FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) + ((maxTableLog > 12) ? (1 << (maxTableLog - 2)) : 1024) )
315size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);
316
317size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits);
320size_t FSE_buildCTable_rle (FSE_CTable* ct, unsigned char symbolValue);
323/* FSE_buildCTable_wksp() :
324 * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).
325 * `wkspSize` must be >= `(1<<tableLog)`.
326 */
327size_t FSE_buildCTable_wksp(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);
328
329size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
332size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
335size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, FSE_DTable* workSpace, unsigned maxLog);
338typedef enum {
339 FSE_repeat_none,
340 FSE_repeat_check,
341 FSE_repeat_valid
342 } FSE_repeat;
343
344/* *****************************************
345* FSE symbol compression API
346*******************************************/
351typedef struct {
353 const void* stateTable;
354 const void* symbolTT;
355 unsigned stateLog;
356} FSE_CState_t;
357
358static void FSE_initCState(FSE_CState_t* CStatePtr, const FSE_CTable* ct);
359
360static void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* CStatePtr, unsigned symbol);
361
362static void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* CStatePtr);
363
408/* *****************************************
409* FSE symbol decompression API
410*******************************************/
411typedef struct {
412 size_t state;
413 const void* table; /* precise table may vary, depending on U16 */
414} FSE_DState_t;
415
416
417static void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
418
419static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
420
421static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
422
473/* *****************************************
474* FSE unsafe API
475*******************************************/
476static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
477/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
478
479
480/* *****************************************
481* Implementation of inlined functions
482*******************************************/
483typedef struct {
484 int deltaFindState;
485 U32 deltaNbBits;
486} FSE_symbolCompressionTransform; /* total 8 bytes */
487
488MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct)
489{
490 const void* ptr = ct;
491 const U16* u16ptr = (const U16*) ptr;
492 const U32 tableLog = MEM_read16(ptr);
493 statePtr->value = (ptrdiff_t)1<<tableLog;
494 statePtr->stateTable = u16ptr+2;
495 statePtr->symbolTT = ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1);
496 statePtr->stateLog = tableLog;
497}
498
499
503MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol)
504{
505 FSE_initCState(statePtr, ct);
506 { const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
507 const U16* stateTable = (const U16*)(statePtr->stateTable);
508 U32 nbBitsOut = (U32)((symbolTT.deltaNbBits + (1<<15)) >> 16);
509 statePtr->value = (nbBitsOut << 16) - symbolTT.deltaNbBits;
510 statePtr->value = stateTable[(statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
511 }
512}
513
514MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, unsigned symbol)
515{
516 FSE_symbolCompressionTransform const symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
517 const U16* const stateTable = (const U16*)(statePtr->stateTable);
518 U32 const nbBitsOut = (U32)((statePtr->value + symbolTT.deltaNbBits) >> 16);
519 BIT_addBits(bitC, statePtr->value, nbBitsOut);
520 statePtr->value = stateTable[ (statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
521}
522
523MEM_STATIC void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* statePtr)
524{
525 BIT_addBits(bitC, statePtr->value, statePtr->stateLog);
526 BIT_flushBits(bitC);
527}
528
529
530/* FSE_getMaxNbBits() :
531 * Approximate maximum cost of a symbol, in bits.
532 * Fractional get rounded up (i.e : a symbol with a normalized frequency of 3 gives the same result as a frequency of 2)
533 * note 1 : assume symbolValue is valid (<= maxSymbolValue)
534 * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
535MEM_STATIC U32 FSE_getMaxNbBits(const void* symbolTTPtr, U32 symbolValue)
536{
537 const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
538 return (symbolTT[symbolValue].deltaNbBits + ((1<<16)-1)) >> 16;
539}
540
541/* FSE_bitCost() :
542 * Approximate symbol cost, as fractional value, using fixed-point format (accuracyLog fractional bits)
543 * note 1 : assume symbolValue is valid (<= maxSymbolValue)
544 * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
545MEM_STATIC U32 FSE_bitCost(const void* symbolTTPtr, U32 tableLog, U32 symbolValue, U32 accuracyLog)
546{
547 const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
548 U32 const minNbBits = symbolTT[symbolValue].deltaNbBits >> 16;
549 U32 const threshold = (minNbBits+1) << 16;
550 assert(tableLog < 16);
551 assert(accuracyLog < 31-tableLog); /* ensure enough room for renormalization double shift */
552 { U32 const tableSize = 1 << tableLog;
553 U32 const deltaFromThreshold = threshold - (symbolTT[symbolValue].deltaNbBits + tableSize);
554 U32 const normalizedDeltaFromThreshold = (deltaFromThreshold << accuracyLog) >> tableLog; /* linear interpolation (very approximate) */
555 U32 const bitMultiplier = 1 << accuracyLog;
556 assert(symbolTT[symbolValue].deltaNbBits + tableSize <= threshold);
557 assert(normalizedDeltaFromThreshold <= bitMultiplier);
558 return (minNbBits+1)*bitMultiplier - normalizedDeltaFromThreshold;
559 }
560}
561
562
563/* ====== Decompression ====== */
564
565typedef struct {
566 U16 tableLog;
567 U16 fastMode;
568} FSE_DTableHeader; /* sizeof U32 */
569
570typedef struct
571{
572 unsigned short newState;
573 unsigned char symbol;
574 unsigned char nbBits;
575} FSE_decode_t; /* size == U32 */
576
577MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
578{
579 const void* ptr = dt;
580 const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr;
581 DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
582 BIT_reloadDStream(bitD);
583 DStatePtr->table = dt + 1;
584}
585
586MEM_STATIC BYTE FSE_peekSymbol(const FSE_DState_t* DStatePtr)
587{
588 FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
589 return DInfo.symbol;
590}
591
592MEM_STATIC void FSE_updateState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
593{
594 FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
595 U32 const nbBits = DInfo.nbBits;
596 size_t const lowBits = BIT_readBits(bitD, nbBits);
597 DStatePtr->state = DInfo.newState + lowBits;
598}
599
600MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
601{
602 FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
603 U32 const nbBits = DInfo.nbBits;
604 BYTE const symbol = DInfo.symbol;
605 size_t const lowBits = BIT_readBits(bitD, nbBits);
606
607 DStatePtr->state = DInfo.newState + lowBits;
608 return symbol;
609}
610
613MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
614{
615 FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
616 U32 const nbBits = DInfo.nbBits;
617 BYTE const symbol = DInfo.symbol;
618 size_t const lowBits = BIT_readBitsFast(bitD, nbBits);
619
620 DStatePtr->state = DInfo.newState + lowBits;
621 return symbol;
622}
623
624MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
625{
626 return DStatePtr->state == 0;
627}
628
629
630
631#ifndef FSE_COMMONDEFS_ONLY
632
633/* **************************************************************
634* Tuning parameters
635****************************************************************/
641#ifndef FSE_MAX_MEMORY_USAGE
642# define FSE_MAX_MEMORY_USAGE 14
643#endif
644#ifndef FSE_DEFAULT_MEMORY_USAGE
645# define FSE_DEFAULT_MEMORY_USAGE 13
646#endif
647
651#ifndef FSE_MAX_SYMBOL_VALUE
652# define FSE_MAX_SYMBOL_VALUE 255
653#endif
654
655/* **************************************************************
656* template functions type & suffix
657****************************************************************/
658#define FSE_FUNCTION_TYPE BYTE
659#define FSE_FUNCTION_EXTENSION
660#define FSE_DECODE_TYPE FSE_decode_t
661
662
663#endif /* !FSE_COMMONDEFS_ONLY */
664
665
666/* ***************************************************************
667* Constants
668*****************************************************************/
669#define FSE_MAX_TABLELOG (FSE_MAX_MEMORY_USAGE-2)
670#define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG)
671#define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1)
672#define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2)
673#define FSE_MIN_TABLELOG 5
674
675#define FSE_TABLELOG_ABSOLUTE_MAX 15
676#if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX
677# error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported"
678#endif
679
680#define FSE_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3)
681
682
683#endif /* FSE_STATIC_LINKING_ONLY */
684
685
686#if defined (__cplusplus)
687}
688#endif
static int state
Definition: maze.c:121
MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t *bitD)
Definition: bitstream.h:416
MEM_STATIC size_t BIT_readBits(BIT_DStream_t *bitD, unsigned nbBits)
Definition: bitstream.h:377
MEM_STATIC void BIT_flushBits(BIT_CStream_t *bitC)
Definition: bitstream.h:239
MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t *bitD, unsigned nbBits)
Definition: bitstream.h:386
MEM_STATIC void BIT_addBits(BIT_CStream_t *bitC, size_t value, unsigned nbBits)
Definition: bitstream.h:198
#define assert(x)
Definition: debug.h:53
MEM_STATIC U16 MEM_read16(const void *memPtr)
Definition: mem.h:237
#define MEM_STATIC
Definition: mem.h:39
__kernel_ptrdiff_t ptrdiff_t
Definition: linux.h:247
FSE_PUBLIC_API size_t FSE_buildDTable(FSE_DTable *dt, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
FSE_PUBLIC_API size_t FSE_readNCount(short *normalizedCounter, unsigned *maxSymbolValuePtr, unsigned *tableLogPtr, const void *rBuffer, size_t rBuffSize)
FSE_PUBLIC_API size_t FSE_writeNCount(void *buffer, size_t bufferSize, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
Definition: fse_compress.c:291
FSE_PUBLIC_API FSE_CTable * FSE_createCTable(unsigned maxSymbolValue, unsigned tableLog)
Definition: fse_compress.c:308
FSE_PUBLIC_API size_t FSE_compress(void *dst, size_t dstCapacity, const void *src, size_t srcSize)
Definition: fse_compress.c:695
FSE_PUBLIC_API const char * FSE_getErrorName(size_t code)
unsigned FSE_CTable
Definition: fse.h:160
FSE_PUBLIC_API void FSE_freeCTable(FSE_CTable *ct)
Definition: fse_compress.c:316
FSE_PUBLIC_API size_t FSE_buildCTable(FSE_CTable *ct, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
Definition: fse_compress.c:175
FSE_PUBLIC_API size_t FSE_decompress_usingDTable(void *dst, size_t dstCapacity, const void *cSrc, size_t cSrcSize, const FSE_DTable *dt)
FSE_PUBLIC_API size_t FSE_decompress(void *dst, size_t dstCapacity, const void *cSrc, size_t cSrcSize)
FSE_PUBLIC_API unsigned FSE_versionNumber(void)
FSE_PUBLIC_API size_t FSE_normalizeCount(short *normalizedCounter, unsigned tableLog, const unsigned *count, size_t srcSize, unsigned maxSymbolValue)
Definition: fse_compress.c:438
FSE_PUBLIC_API size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog)
Definition: fse_compress.c:189
FSE_PUBLIC_API size_t FSE_compress2(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog)
Definition: fse_compress.c:687
FSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue)
Definition: fse_compress.c:342
FSE_PUBLIC_API FSE_DTable * FSE_createDTable(unsigned tableLog)
FSE_PUBLIC_API void FSE_freeDTable(FSE_DTable *dt)
FSE_PUBLIC_API size_t FSE_compressBound(size_t size)
Definition: fse_compress.c:629
unsigned FSE_DTable
Definition: fse.h:233
FSE_PUBLIC_API size_t FSE_compress_usingCTable(void *dst, size_t dstCapacity, const void *src, size_t srcSize, const FSE_CTable *ct)
Definition: fse_compress.c:616
#define FSE_PUBLIC_API
Definition: fse.h:39
size_t FSE_compress_wksp(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void *workSpace, size_t wkspSize)
Definition: fse_compress.c:635
size_t FSE_buildCTable_wksp(FSE_CTable *ct, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void *workSpace, size_t wkspSize)
Definition: fse_compress.c:69
unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus)
Definition: fse_compress.c:328
#define FSE_isError
Definition: fse_compress.c:35
size_t FSE_buildCTable_rle(FSE_CTable *ct, BYTE symbolValue)
Definition: fse_compress.c:534
size_t FSE_buildCTable_raw(FSE_CTable *ct, unsigned nbBits)
Definition: fse_compress.c:501
size_t FSE_decompress_wksp(void *dst, size_t dstCapacity, const void *cSrc, size_t cSrcSize, FSE_DTable *workSpace, unsigned maxLog)
size_t FSE_buildDTable_rle(FSE_DTable *dt, BYTE symbolValue)
size_t FSE_buildDTable_raw(FSE_DTable *dt, unsigned nbBits)
size_t bufferSize
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLsizeiptr size
Definition: glext.h:5919
GLenum src
Definition: glext.h:6340
GLuint buffer
Definition: glext.h:5915
GLenum GLenum dst
Definition: glext.h:6340
static PVOID ptr
Definition: dispmode.c:27
Definition: inflate.c:139
Definition: pdh_main.c:94
unsigned char BYTE
Definition: xxhash.c:193
unsigned int U32
Definition: xxhash.c:195
unsigned short U16
Definition: xxhash.c:194