ReactOS  0.4.15-dev-2703-g05fb0f1
fse.h
Go to the documentation of this file.
1 /* ******************************************************************
2  FSE : Finite State Entropy codec
3  Public Prototypes declaration
4  Copyright (C) 2013-2016, Yann Collet.
5 
6  BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
7 
8  Redistribution and use in source and binary forms, with or without
9  modification, are permitted provided that the following conditions are
10  met:
11 
12  * Redistributions of source code must retain the above copyright
13  notice, this list of conditions and the following disclaimer.
14  * Redistributions in binary form must reproduce the above
15  copyright notice, this list of conditions and the following disclaimer
16  in the documentation and/or other materials provided with the
17  distribution.
18 
19  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 
31  You can contact the author at :
32  - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
33 ****************************************************************** */
34 
35 #if defined (__cplusplus)
36 extern "C" {
37 #endif
38 
39 #ifndef FSE_H
40 #define FSE_H
41 
42 
43 /*-*****************************************
44 * Dependencies
45 ******************************************/
46 #include <stddef.h> /* size_t, ptrdiff_t */
47 
48 
49 /*-*****************************************
50 * FSE_PUBLIC_API : control library symbols visibility
51 ******************************************/
52 #if defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) && defined(__GNUC__) && (__GNUC__ >= 4)
53 # define FSE_PUBLIC_API __attribute__ ((visibility ("default")))
54 #elif defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) /* Visual expected */
55 # define FSE_PUBLIC_API __declspec(dllexport)
56 #elif defined(FSE_DLL_IMPORT) && (FSE_DLL_IMPORT==1)
57 # 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.*/
58 #else
59 # define FSE_PUBLIC_API
60 #endif
61 
62 /*------ Version ------*/
63 #define FSE_VERSION_MAJOR 0
64 #define FSE_VERSION_MINOR 9
65 #define FSE_VERSION_RELEASE 0
66 
67 #define FSE_LIB_VERSION FSE_VERSION_MAJOR.FSE_VERSION_MINOR.FSE_VERSION_RELEASE
68 #define FSE_QUOTE(str) #str
69 #define FSE_EXPAND_AND_QUOTE(str) FSE_QUOTE(str)
70 #define FSE_VERSION_STRING FSE_EXPAND_AND_QUOTE(FSE_LIB_VERSION)
71 
72 #define FSE_VERSION_NUMBER (FSE_VERSION_MAJOR *100*100 + FSE_VERSION_MINOR *100 + FSE_VERSION_RELEASE)
73 FSE_PUBLIC_API unsigned FSE_versionNumber(void);
76 /*-****************************************
77 * FSE simple functions
78 ******************************************/
87 FSE_PUBLIC_API size_t FSE_compress(void* dst, size_t dstCapacity,
88  const void* src, size_t srcSize);
89 
100 FSE_PUBLIC_API size_t FSE_decompress(void* dst, size_t dstCapacity,
101  const void* cSrc, size_t cSrcSize);
102 
103 
104 /*-*****************************************
105 * Tool functions
106 ******************************************/
107 FSE_PUBLIC_API size_t FSE_compressBound(size_t size); /* maximum compressed size */
108 
109 /* Error Management */
110 FSE_PUBLIC_API unsigned FSE_isError(size_t code); /* tells if a return value is an error code */
111 FSE_PUBLIC_API const char* FSE_getErrorName(size_t code); /* provides error code string (useful for debugging) */
112 
113 
114 /*-*****************************************
115 * FSE advanced functions
116 ******************************************/
125 FSE_PUBLIC_API size_t FSE_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
126 
127 
128 /*-*****************************************
129 * FSE detailed API
130 ******************************************/
149 /* *** COMPRESSION *** */
150 
155 FSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue);
156 
162 FSE_PUBLIC_API size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog,
163  const unsigned* count, size_t srcSize, unsigned maxSymbolValue);
164 
168 FSE_PUBLIC_API size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog);
169 
174 FSE_PUBLIC_API size_t FSE_writeNCount (void* buffer, size_t bufferSize,
175  const short* normalizedCounter,
176  unsigned maxSymbolValue, unsigned tableLog);
177 
180 typedef unsigned FSE_CTable; /* don't allocate that. It's only meant to be more restrictive than void* */
181 FSE_PUBLIC_API FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog);
183 
187 FSE_PUBLIC_API size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
188 
194 FSE_PUBLIC_API size_t FSE_compress_usingCTable (void* dst, size_t dstCapacity, const void* src, size_t srcSize, const FSE_CTable* ct);
195 
240 /* *** DECOMPRESSION *** */
241 
247 FSE_PUBLIC_API size_t FSE_readNCount (short* normalizedCounter,
248  unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,
249  const void* rBuffer, size_t rBuffSize);
250 
253 typedef unsigned FSE_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */
254 FSE_PUBLIC_API FSE_DTable* FSE_createDTable(unsigned tableLog);
256 
260 FSE_PUBLIC_API size_t FSE_buildDTable (FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
261 
267 FSE_PUBLIC_API size_t FSE_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt);
268 
297 #endif /* FSE_H */
298 
299 #if defined(FSE_STATIC_LINKING_ONLY) && !defined(FSE_H_FSE_STATIC_LINKING_ONLY)
300 #define FSE_H_FSE_STATIC_LINKING_ONLY
301 
302 /* *** Dependency *** */
303 #include "bitstream.h"
304 
305 
306 /* *****************************************
307 * Static allocation
308 *******************************************/
309 /* FSE buffer bounds */
310 #define FSE_NCOUNTBOUND 512
311 #define FSE_BLOCKBOUND(size) (size + (size>>7))
312 #define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size)) /* Macro version, useful for static allocation */
313 
314 /* It is possible to statically allocate FSE CTable/DTable as a table of FSE_CTable/FSE_DTable using below macros */
315 #define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))
316 #define FSE_DTABLE_SIZE_U32(maxTableLog) (1 + (1<<maxTableLog))
317 
318 /* or use the size to malloc() space directly. Pay attention to alignment restrictions though */
319 #define FSE_CTABLE_SIZE(maxTableLog, maxSymbolValue) (FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(FSE_CTable))
320 #define FSE_DTABLE_SIZE(maxTableLog) (FSE_DTABLE_SIZE_U32(maxTableLog) * sizeof(FSE_DTable))
321 
322 
323 /* *****************************************
324  * FSE advanced API
325  ***************************************** */
326 
327 unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus);
330 /* FSE_compress_wksp() :
331  * Same as FSE_compress2(), but using an externally allocated scratch buffer (`workSpace`).
332  * FSE_WKSP_SIZE_U32() provides the minimum size required for `workSpace` as a table of FSE_CTable.
333  */
334 #define FSE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) ( FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) + ((maxTableLog > 12) ? (1 << (maxTableLog - 2)) : 1024) )
335 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);
336 
337 size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits);
340 size_t FSE_buildCTable_rle (FSE_CTable* ct, unsigned char symbolValue);
343 /* FSE_buildCTable_wksp() :
344  * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).
345  * `wkspSize` must be >= `(1<<tableLog)`.
346  */
347 size_t FSE_buildCTable_wksp(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);
348 
349 size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
352 size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
355 size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, FSE_DTable* workSpace, unsigned maxLog);
358 typedef enum {
359  FSE_repeat_none,
360  FSE_repeat_check,
361  FSE_repeat_valid
362  } FSE_repeat;
363 
364 /* *****************************************
365 * FSE symbol compression API
366 *******************************************/
371 typedef struct {
373  const void* stateTable;
374  const void* symbolTT;
375  unsigned stateLog;
376 } FSE_CState_t;
377 
378 static void FSE_initCState(FSE_CState_t* CStatePtr, const FSE_CTable* ct);
379 
380 static void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* CStatePtr, unsigned symbol);
381 
382 static void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* CStatePtr);
383 
428 /* *****************************************
429 * FSE symbol decompression API
430 *******************************************/
431 typedef struct {
432  size_t state;
433  const void* table; /* precise table may vary, depending on U16 */
434 } FSE_DState_t;
435 
436 
437 static void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
438 
439 static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
440 
441 static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
442 
493 /* *****************************************
494 * FSE unsafe API
495 *******************************************/
496 static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
497 /* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
498 
499 
500 /* *****************************************
501 * Implementation of inlined functions
502 *******************************************/
503 typedef struct {
504  int deltaFindState;
505  U32 deltaNbBits;
506 } FSE_symbolCompressionTransform; /* total 8 bytes */
507 
508 MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct)
509 {
510  const void* ptr = ct;
511  const U16* u16ptr = (const U16*) ptr;
512  const U32 tableLog = MEM_read16(ptr);
513  statePtr->value = (ptrdiff_t)1<<tableLog;
514  statePtr->stateTable = u16ptr+2;
515  statePtr->symbolTT = ((const U32*)ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1));
516  statePtr->stateLog = tableLog;
517 }
518 
519 
523 MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol)
524 {
525  FSE_initCState(statePtr, ct);
526  { const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
527  const U16* stateTable = (const U16*)(statePtr->stateTable);
528  U32 nbBitsOut = (U32)((symbolTT.deltaNbBits + (1<<15)) >> 16);
529  statePtr->value = (nbBitsOut << 16) - symbolTT.deltaNbBits;
530  statePtr->value = stateTable[(statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
531  }
532 }
533 
534 MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, U32 symbol)
535 {
536  FSE_symbolCompressionTransform const symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
537  const U16* const stateTable = (const U16*)(statePtr->stateTable);
538  U32 const nbBitsOut = (U32)((statePtr->value + symbolTT.deltaNbBits) >> 16);
539  BIT_addBits(bitC, statePtr->value, nbBitsOut);
540  statePtr->value = stateTable[ (statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
541 }
542 
543 MEM_STATIC void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* statePtr)
544 {
545  BIT_addBits(bitC, statePtr->value, statePtr->stateLog);
546  BIT_flushBits(bitC);
547 }
548 
549 
550 /* FSE_getMaxNbBits() :
551  * Approximate maximum cost of a symbol, in bits.
552  * Fractional get rounded up (i.e : a symbol with a normalized frequency of 3 gives the same result as a frequency of 2)
553  * note 1 : assume symbolValue is valid (<= maxSymbolValue)
554  * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
555 MEM_STATIC U32 FSE_getMaxNbBits(const void* symbolTTPtr, U32 symbolValue)
556 {
557  const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
558  return (symbolTT[symbolValue].deltaNbBits + ((1<<16)-1)) >> 16;
559 }
560 
561 /* FSE_bitCost() :
562  * Approximate symbol cost, as fractional value, using fixed-point format (accuracyLog fractional bits)
563  * note 1 : assume symbolValue is valid (<= maxSymbolValue)
564  * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
565 MEM_STATIC U32 FSE_bitCost(const void* symbolTTPtr, U32 tableLog, U32 symbolValue, U32 accuracyLog)
566 {
567  const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
568  U32 const minNbBits = symbolTT[symbolValue].deltaNbBits >> 16;
569  U32 const threshold = (minNbBits+1) << 16;
570  assert(tableLog < 16);
571  assert(accuracyLog < 31-tableLog); /* ensure enough room for renormalization double shift */
572  { U32 const tableSize = 1 << tableLog;
573  U32 const deltaFromThreshold = threshold - (symbolTT[symbolValue].deltaNbBits + tableSize);
574  U32 const normalizedDeltaFromThreshold = (deltaFromThreshold << accuracyLog) >> tableLog; /* linear interpolation (very approximate) */
575  U32 const bitMultiplier = 1 << accuracyLog;
576  assert(symbolTT[symbolValue].deltaNbBits + tableSize <= threshold);
577  assert(normalizedDeltaFromThreshold <= bitMultiplier);
578  return (minNbBits+1)*bitMultiplier - normalizedDeltaFromThreshold;
579  }
580 }
581 
582 
583 /* ====== Decompression ====== */
584 
585 typedef struct {
586  U16 tableLog;
587  U16 fastMode;
588 } FSE_DTableHeader; /* sizeof U32 */
589 
590 typedef struct
591 {
592  unsigned short newState;
593  unsigned char symbol;
594  unsigned char nbBits;
595 } FSE_decode_t; /* size == U32 */
596 
597 MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
598 {
599  const void* ptr = dt;
600  const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr;
601  DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
602  BIT_reloadDStream(bitD);
603  DStatePtr->table = dt + 1;
604 }
605 
606 MEM_STATIC BYTE FSE_peekSymbol(const FSE_DState_t* DStatePtr)
607 {
608  FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
609  return DInfo.symbol;
610 }
611 
612 MEM_STATIC void FSE_updateState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
613 {
614  FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
615  U32 const nbBits = DInfo.nbBits;
616  size_t const lowBits = BIT_readBits(bitD, nbBits);
617  DStatePtr->state = DInfo.newState + lowBits;
618 }
619 
620 MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
621 {
622  FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
623  U32 const nbBits = DInfo.nbBits;
624  BYTE const symbol = DInfo.symbol;
625  size_t const lowBits = BIT_readBits(bitD, nbBits);
626 
627  DStatePtr->state = DInfo.newState + lowBits;
628  return symbol;
629 }
630 
633 MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
634 {
635  FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
636  U32 const nbBits = DInfo.nbBits;
637  BYTE const symbol = DInfo.symbol;
638  size_t const lowBits = BIT_readBitsFast(bitD, nbBits);
639 
640  DStatePtr->state = DInfo.newState + lowBits;
641  return symbol;
642 }
643 
644 MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
645 {
646  return DStatePtr->state == 0;
647 }
648 
649 
650 
651 #ifndef FSE_COMMONDEFS_ONLY
652 
653 /* **************************************************************
654 * Tuning parameters
655 ****************************************************************/
661 #ifndef FSE_MAX_MEMORY_USAGE
662 # define FSE_MAX_MEMORY_USAGE 14
663 #endif
664 #ifndef FSE_DEFAULT_MEMORY_USAGE
665 # define FSE_DEFAULT_MEMORY_USAGE 13
666 #endif
667 
671 #ifndef FSE_MAX_SYMBOL_VALUE
672 # define FSE_MAX_SYMBOL_VALUE 255
673 #endif
674 
675 /* **************************************************************
676 * template functions type & suffix
677 ****************************************************************/
678 #define FSE_FUNCTION_TYPE BYTE
679 #define FSE_FUNCTION_EXTENSION
680 #define FSE_DECODE_TYPE FSE_decode_t
681 
682 
683 #endif /* !FSE_COMMONDEFS_ONLY */
684 
685 
686 /* ***************************************************************
687 * Constants
688 *****************************************************************/
689 #define FSE_MAX_TABLELOG (FSE_MAX_MEMORY_USAGE-2)
690 #define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG)
691 #define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1)
692 #define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2)
693 #define FSE_MIN_TABLELOG 5
694 
695 #define FSE_TABLELOG_ABSOLUTE_MAX 15
696 #if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX
697 # error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported"
698 #endif
699 
700 #define FSE_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3)
701 
702 
703 #endif /* FSE_STATIC_LINKING_ONLY */
704 
705 
706 #if defined (__cplusplus)
707 }
708 #endif
FSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue)
Definition: fse_compress.c:371
size_t FSE_buildCTable_wksp(FSE_CTable *ct, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void *workSpace, size_t wkspSize)
Definition: fse_compress.c:89
FSE_PUBLIC_API size_t FSE_normalizeCount(short *normalizedCounter, unsigned tableLog, const unsigned *count, size_t srcSize, unsigned maxSymbolValue)
Definition: fse_compress.c:467
FSE_PUBLIC_API FSE_CTable * FSE_createCTable(unsigned maxSymbolValue, unsigned tableLog)
Definition: fse_compress.c:337
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:180
unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus)
Definition: fse_compress.c:357
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:414
unsigned FSE_DTable
Definition: fse.h:253
MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t *bitD, unsigned nbBits)
FSE_PUBLIC_API const char * FSE_getErrorName(size_t code)
size_t FSE_buildCTable_raw(FSE_CTable *ct, unsigned nbBits)
Definition: fse_compress.c:530
FSE_PUBLIC_API size_t FSE_buildCTable(FSE_CTable *ct, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
Definition: fse_compress.c:195
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:719
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:645
static PVOID ptr
Definition: dispmode.c:27
FSE_PUBLIC_API size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog)
Definition: fse_compress.c:218
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:59
FSE_PUBLIC_API FSE_DTable * FSE_createDTable(unsigned tableLog)
size_t FSE_buildCTable_rle(FSE_CTable *ct, BYTE symbolValue)
Definition: fse_compress.c:563
#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:255
FSE_PUBLIC_API void FSE_freeCTable(FSE_CTable *ct)
Definition: fse_compress.c:345
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:667
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:658
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:214
MEM_STATIC size_t BIT_readBits(BIT_DStream_t *bitD, unsigned nbBits)
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:320
FSE_PUBLIC_API size_t FSE_compress(void *dst, size_t dstCapacity, const void *src, size_t srcSize)
Definition: fse_compress.c:741
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:164
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)