ReactOS  0.4.15-dev-5461-g062a8f2
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)
16 extern "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)
53 FSE_PUBLIC_API unsigned FSE_versionNumber(void);
56 /*-****************************************
57 * FSE simple functions
58 ******************************************/
67 FSE_PUBLIC_API size_t FSE_compress(void* dst, size_t dstCapacity,
68  const void* src, size_t srcSize);
69 
80 FSE_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 ******************************************/
87 FSE_PUBLIC_API size_t FSE_compressBound(size_t size); /* maximum compressed size */
88 
89 /* Error Management */
90 FSE_PUBLIC_API unsigned FSE_isError(size_t code); /* tells if a return value is an error code */
91 FSE_PUBLIC_API const char* FSE_getErrorName(size_t code); /* provides error code string (useful for debugging) */
92 
93 
94 /*-*****************************************
95 * FSE advanced functions
96 ******************************************/
105 FSE_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 
135 FSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue);
136 
142 FSE_PUBLIC_API size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog,
143  const unsigned* count, size_t srcSize, unsigned maxSymbolValue);
144 
148 FSE_PUBLIC_API size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog);
149 
154 FSE_PUBLIC_API size_t FSE_writeNCount (void* buffer, size_t bufferSize,
155  const short* normalizedCounter,
156  unsigned maxSymbolValue, unsigned tableLog);
157 
160 typedef unsigned FSE_CTable; /* don't allocate that. It's only meant to be more restrictive than void* */
161 FSE_PUBLIC_API FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog);
163 
167 FSE_PUBLIC_API size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
168 
174 FSE_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 
227 FSE_PUBLIC_API size_t FSE_readNCount (short* normalizedCounter,
228  unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,
229  const void* rBuffer, size_t rBuffSize);
230 
233 typedef unsigned FSE_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */
234 FSE_PUBLIC_API FSE_DTable* FSE_createDTable(unsigned tableLog);
236 
240 FSE_PUBLIC_API size_t FSE_buildDTable (FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
241 
247 FSE_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 
307 unsigned 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) )
315 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);
316 
317 size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits);
320 size_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  */
327 size_t FSE_buildCTable_wksp(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);
328 
329 size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
332 size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
335 size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, FSE_DTable* workSpace, unsigned maxLog);
338 typedef enum {
339  FSE_repeat_none,
340  FSE_repeat_check,
341  FSE_repeat_valid
342  } FSE_repeat;
343 
344 /* *****************************************
345 * FSE symbol compression API
346 *******************************************/
351 typedef struct {
353  const void* stateTable;
354  const void* symbolTT;
355  unsigned stateLog;
356 } FSE_CState_t;
357 
358 static void FSE_initCState(FSE_CState_t* CStatePtr, const FSE_CTable* ct);
359 
360 static void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* CStatePtr, unsigned symbol);
361 
362 static void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* CStatePtr);
363 
408 /* *****************************************
409 * FSE symbol decompression API
410 *******************************************/
411 typedef struct {
412  size_t state;
413  const void* table; /* precise table may vary, depending on U16 */
414 } FSE_DState_t;
415 
416 
417 static void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
418 
419 static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
420 
421 static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
422 
473 /* *****************************************
474 * FSE unsafe API
475 *******************************************/
476 static 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 *******************************************/
483 typedef struct {
484  int deltaFindState;
485  U32 deltaNbBits;
486 } FSE_symbolCompressionTransform; /* total 8 bytes */
487 
488 MEM_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 
503 MEM_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 
514 MEM_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 
523 MEM_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 */
535 MEM_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 */
545 MEM_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 
565 typedef struct {
566  U16 tableLog;
567  U16 fastMode;
568 } FSE_DTableHeader; /* sizeof U32 */
569 
570 typedef struct
571 {
572  unsigned short newState;
573  unsigned char symbol;
574  unsigned char nbBits;
575 } FSE_decode_t; /* size == U32 */
576 
577 MEM_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 
586 MEM_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 
592 MEM_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 
600 MEM_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 
613 MEM_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 
624 MEM_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
FSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue)
Definition: fse_compress.c:342
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
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 FSE_CTable * FSE_createCTable(unsigned maxSymbolValue, unsigned tableLog)
Definition: fse_compress.c:308
FSE_PUBLIC_API size_t FSE_decompress_usingDTable(void *dst, size_t dstCapacity, const void *cSrc, size_t cSrcSize, const FSE_DTable *dt)
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define assert(x)
Definition: debug.h:53
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
GLuint buffer
Definition: glext.h:5915
unsigned FSE_CTable
Definition: fse.h:160
unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus)
Definition: fse_compress.c:328
FSE_PUBLIC_API size_t FSE_readNCount(short *normalizedCounter, unsigned *maxSymbolValuePtr, unsigned *tableLogPtr, const void *rBuffer, size_t rBuffSize)
MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t *bitD)
Definition: bitstream.h:416
unsigned FSE_DTable
Definition: fse.h:233
MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t *bitD, unsigned nbBits)
Definition: bitstream.h:386
FSE_PUBLIC_API const char * FSE_getErrorName(size_t code)
size_t FSE_buildCTable_raw(FSE_CTable *ct, unsigned nbBits)
Definition: fse_compress.c:501
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_compress2(void *dst, size_t dstSize, const void *src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog)
Definition: fse_compress.c:687
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
static PVOID ptr
Definition: dispmode.c:27
FSE_PUBLIC_API size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog)
Definition: fse_compress.c:189
FSE_PUBLIC_API size_t FSE_decompress(void *dst, size_t dstCapacity, const void *cSrc, size_t cSrcSize)
#define FSE_PUBLIC_API
Definition: fse.h:39
FSE_PUBLIC_API FSE_DTable * FSE_createDTable(unsigned tableLog)
size_t FSE_buildCTable_rle(FSE_CTable *ct, BYTE symbolValue)
Definition: fse_compress.c:534
#define MEM_STATIC
Definition: mem.h:39
GLsizeiptr size
Definition: glext.h:5919
MEM_STATIC void BIT_flushBits(BIT_CStream_t *bitC)
Definition: bitstream.h:239
FSE_PUBLIC_API void FSE_freeCTable(FSE_CTable *ct)
Definition: fse_compress.c:316
FSE_PUBLIC_API void FSE_freeDTable(FSE_DTable *dt)
FSE_PUBLIC_API size_t FSE_buildDTable(FSE_DTable *dt, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
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 bufferSize
static int state
Definition: maze.c:121
GLsizei const GLfloat * value
Definition: glext.h:6069
GLenum src
Definition: glext.h:6340
Definition: inflate.c:139
size_t FSE_buildDTable_raw(FSE_DTable *dt, unsigned nbBits)
FSE_PUBLIC_API size_t FSE_compressBound(size_t size)
Definition: fse_compress.c:629
unsigned char BYTE
Definition: xxhash.c:193
unsigned short U16
Definition: xxhash.c:194
MEM_STATIC void BIT_addBits(BIT_CStream_t *bitC, size_t value, unsigned nbBits)
Definition: bitstream.h:198
MEM_STATIC size_t BIT_readBits(BIT_DStream_t *bitD, unsigned nbBits)
Definition: bitstream.h:377
GLenum GLenum dst
Definition: glext.h:6340
__kernel_ptrdiff_t ptrdiff_t
Definition: linux.h:247
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 size_t FSE_compress(void *dst, size_t dstCapacity, const void *src, size_t srcSize)
Definition: fse_compress.c:695
size_t FSE_decompress_wksp(void *dst, size_t dstCapacity, const void *cSrc, size_t cSrcSize, FSE_DTable *workSpace, unsigned maxLog)
MEM_STATIC U16 MEM_read16(const void *memPtr)
Definition: mem.h:237
FSE_PUBLIC_API unsigned FSE_isError(size_t code)
FSE_PUBLIC_API unsigned FSE_versionNumber(void)
unsigned int U32
Definition: xxhash.c:195
size_t FSE_buildDTable_rle(FSE_DTable *dt, BYTE symbolValue)