1 /* ******************************************* 1
2 * FSE : Finite State Entropy codec
3 * Public Prototypes declaration
4 * Copyright (c) Yann Collet, Facebook, Inc.
5 *
6 * You can contact the author at :
7 * - Source repository : https://github.com/Cy
8 *
9 * This source code is licensed under both the
10 * LICENSE file in the root directory of this
11 * in the COPYING file in the root directory o
12 * You may select, at your option, one of the
13 **********************************************
14
15
16 #ifndef FSE_H
17 #define FSE_H
18
19
20 /*-*****************************************
21 * Dependencies
22 ******************************************/
23 #include "zstd_deps.h" /* size_t, ptrdiff_t
24
25
26 /*-*****************************************
27 * FSE_PUBLIC_API : control library symbols vi
28 ******************************************/
29 #if defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT
30 # define FSE_PUBLIC_API __attribute__ ((visib
31 #elif defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPO
32 # define FSE_PUBLIC_API __declspec(dllexport)
33 #elif defined(FSE_DLL_IMPORT) && (FSE_DLL_IMPO
34 # define FSE_PUBLIC_API __declspec(dllimport)
35 #else
36 # define FSE_PUBLIC_API
37 #endif
38
39 /*------ Version ------*/
40 #define FSE_VERSION_MAJOR 0
41 #define FSE_VERSION_MINOR 9
42 #define FSE_VERSION_RELEASE 0
43
44 #define FSE_LIB_VERSION FSE_VERSION_MAJOR.FSE_
45 #define FSE_QUOTE(str) #str
46 #define FSE_EXPAND_AND_QUOTE(str) FSE_QUOTE(st
47 #define FSE_VERSION_STRING FSE_EXPAND_AND_QUOT
48
49 #define FSE_VERSION_NUMBER (FSE_VERSION_MAJOR
50 FSE_PUBLIC_API unsigned FSE_versionNumber(void
51
52
53 /*-****************************************
54 * FSE simple functions
55 ******************************************/
56 /*! FSE_compress() :
57 Compress content of buffer 'src', of size
58 'dst' buffer must be already allocated. Co
59 @return : size of compressed data (<= dstC
60 Special values : if return == 0, srcData i
61 if return == 1, srcData i
62 if FSE_isError(return), c
63 */
64 FSE_PUBLIC_API size_t FSE_compress(void* dst,
65 const void* src,
66
67 /*! FSE_decompress():
68 Decompress FSE data from buffer 'cSrc', of
69 into already allocated destination buffer
70 @return : size of regenerated data (<= max
71 or an error code, which can be t
72
73 ** Important ** : FSE_decompress() does no
74 Why ? : making this distinction requires a
75 Header management is intentionally delegat
76 */
77 FSE_PUBLIC_API size_t FSE_decompress(void* dst
78 const void* cSr
79
80
81 /*-*****************************************
82 * Tool functions
83 ******************************************/
84 FSE_PUBLIC_API size_t FSE_compressBound(size_t
85
86 /* Error Management */
87 FSE_PUBLIC_API unsigned FSE_isError(size_t
88 FSE_PUBLIC_API const char* FSE_getErrorName(si
89
90
91 /*-*****************************************
92 * FSE advanced functions
93 ******************************************/
94 /*! FSE_compress2() :
95 Same as FSE_compress(), but allows the sel
96 Both parameters can be defined as '' to me
97 @return : size of compressed data
98 Special values : if return == 0, srcData i
99 if return == 1, srcData i
100 if FSE_isError(return), i
101 */
102 FSE_PUBLIC_API size_t FSE_compress2 (void* dst
103
104
105 /*-*****************************************
106 * FSE detailed API
107 ******************************************/
108 /*!
109 FSE_compress() does the following:
110 1. count symbol occurrence from source[] into
111 2. normalize counters so that sum(count[]) ==
112 3. save normalized counters to memory buffer u
113 4. build encoding table 'CTable' from normaliz
114 5. encode the data stream using encoding table
115
116 FSE_decompress() does the following:
117 1. read normalized counters with readNCount()
118 2. build decoding table 'DTable' from normaliz
119 3. decode the data stream using decoding table
120
121 The following API allows targeting specific su
122 For example, it's possible to compress several
123 or to save and provide normalized distribution
124 */
125
126 /* *** COMPRESSION *** */
127
128 /*! FSE_optimalTableLog():
129 dynamically downsize 'tableLog' when condi
130 It saves CPU time, by using smaller tables
131 @return : recommended tableLog (necessaril
132 FSE_PUBLIC_API unsigned FSE_optimalTableLog(un
133
134 /*! FSE_normalizeCount():
135 normalize counts so that sum(count[]) == P
136 'normalizedCounter' is a table of short, o
137 useLowProbCount is a boolean parameter whi
138 faster header decoding. When it is set to
139 smaller. And when it is set to 0, FSE_read
140 faster. If you are compressing a small amo
141 is a good default, since header deserializ
142 Otherwise, useLowProbCount=1 is a good def
143 @return : tableLog,
144 or an errorCode, which can be te
145 FSE_PUBLIC_API size_t FSE_normalizeCount(short
146 const unsigned* count, siz
147
148 /*! FSE_NCountWriteBound():
149 Provides the maximum possible size of an F
150 Typically useful for allocation purpose. *
151 FSE_PUBLIC_API size_t FSE_NCountWriteBound(uns
152
153 /*! FSE_writeNCount():
154 Compactly save 'normalizedCounter' into 'b
155 @return : size of the compressed table,
156 or an errorCode, which can be te
157 FSE_PUBLIC_API size_t FSE_writeNCount (void* b
158 const short*
159 unsigned maxS
160
161 /*! Constructor and Destructor of FSE_CTable.
162 Note that FSE_CTable size depends on 'tabl
163 typedef unsigned FSE_CTable; /* don't alloca
164 FSE_PUBLIC_API FSE_CTable* FSE_createCTable (u
165 FSE_PUBLIC_API void FSE_freeCTable (FSE
166
167 /*! FSE_buildCTable():
168 Builds `ct`, which must be already allocat
169 @return : 0, or an errorCode, which can be
170 FSE_PUBLIC_API size_t FSE_buildCTable(FSE_CTab
171
172 /*! FSE_compress_usingCTable():
173 Compress `src` using `ct` into `dst` which
174 @return : size of compressed data (<= `dst
175 or 0 if compressed data could no
176 or an errorCode, which can be te
177 FSE_PUBLIC_API size_t FSE_compress_usingCTable
178
179 /*!
180 Tutorial :
181 ----------
182 The first step is to count all symbols. FSE_co
183 Result will be saved into 'count', a table of
184 'src' is a table of bytes of size 'srcSize'. A
185 maxSymbolValuePtr[0] will be updated, with its
186 FSE_count() will return the number of occurren
187 This can be used to know if there is a single
188 If there is an error, the function will return
189
190 The next step is to normalize the frequencies.
191 FSE_normalizeCount() will ensure that sum of f
192 It also guarantees a minimum of 1 to any Symbo
193 You can use 'tableLog'==0 to mean "use default
194 If you are unsure of which tableLog value to u
195 which will provide the optimal valid tableLog
196
197 The result of FSE_normalizeCount() will be sav
198 called 'normalizedCounter', which is a table o
199 'normalizedCounter' must be already allocated,
200 The return value is tableLog if everything pro
201 It is 0 if there is a single symbol within dis
202 If there is an error (ex: invalid tableLog val
203
204 'normalizedCounter' can be saved in a compact
205 'buffer' must be already allocated.
206 For guaranteed success, buffer size must be at
207 The result of the function is the number of by
208 If there is an error, the function will return
209
210 'normalizedCounter' can then be used to create
211 The space required by 'CTable' must be already
212 You can then use FSE_buildCTable() to fill 'CT
213 If there is an error, both functions will retu
214
215 'CTable' can then be used to compress 'src', w
216 Similar to FSE_count(), the convention is that
217 The function returns the size of compressed da
218 If it returns '', compressed data could not fi
219 If there is an error, the function will return
220 */
221
222
223 /* *** DECOMPRESSION *** */
224
225 /*! FSE_readNCount():
226 Read compactly saved 'normalizedCounter' f
227 @return : size read from 'rBuffer',
228 or an errorCode, which can be te
229 maxSymbolValuePtr[0] and tableLo
230 FSE_PUBLIC_API size_t FSE_readNCount (short* n
231 unsigned* maxSymbol
232 const void* rBuffer
233
234 /*! FSE_readNCount_bmi2():
235 * Same as FSE_readNCount() but pass bmi2=1 wh
236 */
237 FSE_PUBLIC_API size_t FSE_readNCount_bmi2(shor
238 unsigned* maxSymbol
239 const void* rBuffer
240
241 /*! Constructor and Destructor of FSE_DTable.
242 Note that its size depends on 'tableLog' *
243 typedef unsigned FSE_DTable; /* don't alloca
244 FSE_PUBLIC_API FSE_DTable* FSE_createDTable(un
245 FSE_PUBLIC_API void FSE_freeDTable(FSE_
246
247 /*! FSE_buildDTable():
248 Builds 'dt', which must be already allocat
249 return : 0, or an errorCode, which can be
250 FSE_PUBLIC_API size_t FSE_buildDTable (FSE_DTa
251
252 /*! FSE_decompress_usingDTable():
253 Decompress compressed source `cSrc` of siz
254 into `dst` which must be already allocated
255 @return : size of regenerated data (necess
256 or an errorCode, which can be te
257 FSE_PUBLIC_API size_t FSE_decompress_usingDTab
258
259 /*!
260 Tutorial :
261 ----------
262 (Note : these functions only decompress FSE-co
263 If block is uncompressed, use memcpy() instea
264 If block is a single repeated byte, use memse
265
266 The first step is to obtain the normalized fre
267 This can be performed by FSE_readNCount() if i
268 'normalizedCounter' must be already allocated,
269 In practice, that means it's necessary to know
270 or size the table to handle worst case situati
271 FSE_readNCount() will provide 'tableLog' and '
272 The result of FSE_readNCount() is the number o
273 Note that 'rBufferSize' must be at least 4 byt
274 If there is an error, the function will return
275
276 The next step is to build the decompression ta
277 This is performed by the function FSE_buildDTa
278 The space required by 'FSE_DTable' must be alr
279 If there is an error, the function will return
280
281 `FSE_DTable` can then be used to decompress `c
282 `cSrcSize` must be strictly correct, otherwise
283 FSE_decompress_usingDTable() result will tell
284 If there is an error, the function will return
285 */
286
287 #endif /* FSE_H */
288
289 #if !defined(FSE_H_FSE_STATIC_LINKING_ONLY)
290 #define FSE_H_FSE_STATIC_LINKING_ONLY
291
292 /* *** Dependency *** */
293 #include "bitstream.h"
294
295
296 /* *****************************************
297 * Static allocation
298 *******************************************/
299 /* FSE buffer bounds */
300 #define FSE_NCOUNTBOUND 512
301 #define FSE_BLOCKBOUND(size) ((size) + ((size)
302 #define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOU
303
304 /* It is possible to statically allocate FSE C
305 #define FSE_CTABLE_SIZE_U32(maxTableLog, maxSy
306 #define FSE_DTABLE_SIZE_U32(maxTableLog)
307
308 /* or use the size to malloc() space directly.
309 #define FSE_CTABLE_SIZE(maxTableLog, maxSymbol
310 #define FSE_DTABLE_SIZE(maxTableLog)
311
312
313 /* *****************************************
314 * FSE advanced API
315 ***************************************** */
316
317 unsigned FSE_optimalTableLog_internal(unsigned
318 /*< same as FSE_optimalTableLog(), which used
319
320 /* FSE_compress_wksp() :
321 * Same as FSE_compress2(), but using an exter
322 * FSE_COMPRESS_WKSP_SIZE_U32() provides the m
323 */
324 #define FSE_COMPRESS_WKSP_SIZE_U32(maxTableLog
325 size_t FSE_compress_wksp (void* dst, size_t ds
326
327 size_t FSE_buildCTable_raw (FSE_CTable* ct, un
328 /*< build a fake FSE_CTable, designed for a fl
329
330 size_t FSE_buildCTable_rle (FSE_CTable* ct, un
331 /*< build a fake FSE_CTable, designed to compr
332
333 /* FSE_buildCTable_wksp() :
334 * Same as FSE_buildCTable(), but using an ext
335 * `wkspSize` must be >= `FSE_BUILD_CTABLE_WOR
336 * See FSE_buildCTable_wksp() for breakdown of
337 */
338 #define FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(ma
339 #define FSE_BUILD_CTABLE_WORKSPACE_SIZE(maxSym
340 size_t FSE_buildCTable_wksp(FSE_CTable* ct, co
341
342 #define FSE_BUILD_DTABLE_WKSP_SIZE(maxTableLog
343 #define FSE_BUILD_DTABLE_WKSP_SIZE_U32(maxTabl
344 FSE_PUBLIC_API size_t FSE_buildDTable_wksp(FSE
345 /*< Same as FSE_buildDTable(), using an extern
346
347 size_t FSE_buildDTable_raw (FSE_DTable* dt, un
348 /*< build a fake FSE_DTable, designed to read
349
350 size_t FSE_buildDTable_rle (FSE_DTable* dt, un
351 /*< build a fake FSE_DTable, designed to alway
352
353 #define FSE_DECOMPRESS_WKSP_SIZE_U32(maxTableL
354 #define FSE_DECOMPRESS_WKSP_SIZE(maxTableLog,
355 size_t FSE_decompress_wksp(void* dst, size_t d
356 /*< same as FSE_decompress(), using an externa
357
358 size_t FSE_decompress_wksp_bmi2(void* dst, siz
359 /*< Same as FSE_decompress_wksp() but with dyn
360
361 typedef enum {
362 FSE_repeat_none, /*< Cannot use the previo
363 FSE_repeat_check, /*< Can use the previous
364 FSE_repeat_valid /*< Can use the previous
365 } FSE_repeat;
366
367 /* *****************************************
368 * FSE symbol compression API
369 *******************************************/
370 /*!
371 This API consists of small unitary function
372 Hence their body are included in next secti
373 */
374 typedef struct {
375 ptrdiff_t value;
376 const void* stateTable;
377 const void* symbolTT;
378 unsigned stateLog;
379 } FSE_CState_t;
380
381 static void FSE_initCState(FSE_CState_t* CStat
382
383 static void FSE_encodeSymbol(BIT_CStream_t* bi
384
385 static void FSE_flushCState(BIT_CStream_t* bit
386
387 /*<
388 These functions are inner components of FSE_co
389 They allow the creation of custom streams, mix
390
391 A key property to keep in mind is that encodin
392 So the first symbol you will encode is the las
393
394 You will need a few variables to track your CS
395
396 FSE_CTable ct; // Provided by FSE_b
397 BIT_CStream_t bitStream; // bitStream trackin
398 FSE_CState_t state; // State tracking st
399
400
401 The first thing to do is to init bitStream and
402 size_t errorCode = BIT_initCStream(&bitStr
403 FSE_initCState(&state, ct);
404
405 Note that BIT_initCStream() can produce an err
406 You can then encode your input data, byte afte
407 FSE_encodeSymbol() outputs a maximum of 'table
408 Remember decoding will be done in reverse dire
409 FSE_encodeByte(&bitStream, &state, symbol)
410
411 At any time, you can also add any bit sequence
412 Note : maximum allowed nbBits is 25, for compa
413 BIT_addBits(&bitStream, bitField, nbBits);
414
415 The above methods don't commit data to memory,
416 Local register size is 64-bits on 64-bits syst
417 Writing data to memory is a manual operation,
418 BIT_flushBits(&bitStream);
419
420 Your last FSE encoding operation shall be to f
421 FSE_flushState(&bitStream, &state);
422
423 Finally, you must close the bitStream.
424 The function returns the size of CStream in by
425 If data couldn't fit into dstBuffer, it will r
426 If there is an error, it returns an errorCode
427 size_t size = BIT_closeCStream(&bitStream)
428 */
429
430
431 /* *****************************************
432 * FSE symbol decompression API
433 *******************************************/
434 typedef struct {
435 size_t state;
436 const void* table; /* precise table may
437 } FSE_DState_t;
438
439
440 static void FSE_initDState(FSE_DState_t* D
441
442 static unsigned char FSE_decodeSymbol(FSE_DSta
443
444 static unsigned FSE_endOfDState(const FSE_DSta
445
446 /*<
447 Let's now decompose FSE_decompress_usingDTable
448 You will decode FSE-encoded symbols from the b
449 and also any other bitFields you put in, **in
450
451 You will need a few variables to track your bi
452
453 BIT_DStream_t DStream; // Stream context
454 FSE_DState_t DState; // State context. Mu
455 FSE_DTable* DTablePtr; // Decoding table, p
456
457 The first thing to do is to init the bitStream
458 errorCode = BIT_initDStream(&DStream, srcB
459
460 You should then retrieve your initial state(s)
461 (in reverse flushing order if you have several
462 errorCode = FSE_initDState(&DState, &DStre
463
464 You can then decode your data, symbol after sy
465 For information the maximum number of bits rea
466 Keep in mind that symbols are decoded in rever
467 unsigned char symbol = FSE_decodeSymbol(&D
468
469 You can retrieve any bitfield you eventually s
470 Note : maximum allowed nbBits is 25, for 32-bi
471 size_t bitField = BIT_readBits(&DStream, n
472
473 All above operations only read from local regi
474 Refueling the register from memory is manually
475 endSignal = FSE_reloadDStream(&DStream);
476
477 BIT_reloadDStream() result tells if there is s
478 BIT_DStream_unfinished : there is still some d
479 BIT_DStream_endOfBuffer : Dstream reached end
480 BIT_DStream_completed : Dstream reached its ex
481 BIT_DStream_tooFar : Dstream went too far. Dec
482
483 When reaching end of buffer (BIT_DStream_endOf
484 to properly detect the exact end of stream.
485 After each decoded symbol, check if DStream is
486 BIT_reloadDStream(&DStream) >= BIT_DStream
487
488 When it's done, verify decompression is fully
489 Checking if DStream has reached its end is per
490 BIT_endOfDStream(&DStream);
491 Check also the states. There might be some sym
492 FSE_endOfDState(&DState);
493 */
494
495
496 /* *****************************************
497 * FSE unsafe API
498 *******************************************/
499 static unsigned char FSE_decodeSymbolFast(FSE_
500 /* faster, but works only if nbBits is always
501
502
503 /* *****************************************
504 * Implementation of inlined functions
505 *******************************************/
506 typedef struct {
507 int deltaFindState;
508 U32 deltaNbBits;
509 } FSE_symbolCompressionTransform; /* total 8 b
510
511 MEM_STATIC void FSE_initCState(FSE_CState_t* s
512 {
513 const void* ptr = ct;
514 const U16* u16ptr = (const U16*) ptr;
515 const U32 tableLog = MEM_read16(ptr);
516 statePtr->value = (ptrdiff_t)1<<tableLog;
517 statePtr->stateTable = u16ptr+2;
518 statePtr->symbolTT = ct + 1 + (tableLog ?
519 statePtr->stateLog = tableLog;
520 }
521
522
523 /*! FSE_initCState2() :
524 * Same as FSE_initCState(), but the first sy
525 * uses the smallest state value possible, sa
526 MEM_STATIC void FSE_initCState2(FSE_CState_t*
527 {
528 FSE_initCState(statePtr, ct);
529 { const FSE_symbolCompressionTransform s
530 const U16* stateTable = (const U16*)(s
531 U32 nbBitsOut = (U32)((symbolTT.delta
532 statePtr->value = (nbBitsOut << 16) -
533 statePtr->value = stateTable[(statePtr
534 }
535 }
536
537 MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t
538 {
539 FSE_symbolCompressionTransform const symbo
540 const U16* const stateTable = (const U16*)
541 U32 const nbBitsOut = (U32)((statePtr->va
542 BIT_addBits(bitC, statePtr->value, nbBitsO
543 statePtr->value = stateTable[ (statePtr->v
544 }
545
546 MEM_STATIC void FSE_flushCState(BIT_CStream_t*
547 {
548 BIT_addBits(bitC, statePtr->value, statePt
549 BIT_flushBits(bitC);
550 }
551
552
553 /* FSE_getMaxNbBits() :
554 * Approximate maximum cost of a symbol, in bi
555 * Fractional get rounded up (i.e : a symbol w
556 * note 1 : assume symbolValue is valid (<= ma
557 * note 2 : if freq[symbolValue]==0, @return a
558 MEM_STATIC U32 FSE_getMaxNbBits(const void* sy
559 {
560 const FSE_symbolCompressionTransform* symb
561 return (symbolTT[symbolValue].deltaNbBits
562 }
563
564 /* FSE_bitCost() :
565 * Approximate symbol cost, as fractional valu
566 * note 1 : assume symbolValue is valid (<= ma
567 * note 2 : if freq[symbolValue]==0, @return a
568 MEM_STATIC U32 FSE_bitCost(const void* symbolT
569 {
570 const FSE_symbolCompressionTransform* symb
571 U32 const minNbBits = symbolTT[symbolValue
572 U32 const threshold = (minNbBits+1) << 16;
573 assert(tableLog < 16);
574 assert(accuracyLog < 31-tableLog); /* ens
575 { U32 const tableSize = 1 << tableLog;
576 U32 const deltaFromThreshold = thresho
577 U32 const normalizedDeltaFromThreshold
578 U32 const bitMultiplier = 1 << accurac
579 assert(symbolTT[symbolValue].deltaNbBi
580 assert(normalizedDeltaFromThreshold <=
581 return (minNbBits+1)*bitMultiplier - n
582 }
583 }
584
585
586 /* ====== Decompression ====== */
587
588 typedef struct {
589 U16 tableLog;
590 U16 fastMode;
591 } FSE_DTableHeader; /* sizeof U32 */
592
593 typedef struct
594 {
595 unsigned short newState;
596 unsigned char symbol;
597 unsigned char nbBits;
598 } FSE_decode_t; /* size == U32 */
599
600 MEM_STATIC void FSE_initDState(FSE_DState_t* D
601 {
602 const void* ptr = dt;
603 const FSE_DTableHeader* const DTableH = (c
604 DStatePtr->state = BIT_readBits(bitD, DTab
605 BIT_reloadDStream(bitD);
606 DStatePtr->table = dt + 1;
607 }
608
609 MEM_STATIC BYTE FSE_peekSymbol(const FSE_DStat
610 {
611 FSE_decode_t const DInfo = ((const FSE_dec
612 return DInfo.symbol;
613 }
614
615 MEM_STATIC void FSE_updateState(FSE_DState_t*
616 {
617 FSE_decode_t const DInfo = ((const FSE_dec
618 U32 const nbBits = DInfo.nbBits;
619 size_t const lowBits = BIT_readBits(bitD,
620 DStatePtr->state = DInfo.newState + lowBit
621 }
622
623 MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t*
624 {
625 FSE_decode_t const DInfo = ((const FSE_dec
626 U32 const nbBits = DInfo.nbBits;
627 BYTE const symbol = DInfo.symbol;
628 size_t const lowBits = BIT_readBits(bitD,
629
630 DStatePtr->state = DInfo.newState + lowBit
631 return symbol;
632 }
633
634 /*! FSE_decodeSymbolFast() :
635 unsafe, only works if no symbol has a prob
636 MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DStat
637 {
638 FSE_decode_t const DInfo = ((const FSE_dec
639 U32 const nbBits = DInfo.nbBits;
640 BYTE const symbol = DInfo.symbol;
641 size_t const lowBits = BIT_readBitsFast(bi
642
643 DStatePtr->state = DInfo.newState + lowBit
644 return symbol;
645 }
646
647 MEM_STATIC unsigned FSE_endOfDState(const FSE_
648 {
649 return DStatePtr->state == 0;
650 }
651
652
653
654 #ifndef FSE_COMMONDEFS_ONLY
655
656 /* *******************************************
657 * Tuning parameters
658 **********************************************
659 /*!MEMORY_USAGE :
660 * Memory usage formula : N->2^N Bytes (exampl
661 * Increasing memory usage improves compressio
662 * Reduced memory usage can improve speed, due
663 * Recommended max value is 14, for 16KB, whic
664 #ifndef FSE_MAX_MEMORY_USAGE
665 # define FSE_MAX_MEMORY_USAGE 14
666 #endif
667 #ifndef FSE_DEFAULT_MEMORY_USAGE
668 # define FSE_DEFAULT_MEMORY_USAGE 13
669 #endif
670 #if (FSE_DEFAULT_MEMORY_USAGE > FSE_MAX_MEMORY
671 # error "FSE_DEFAULT_MEMORY_USAGE must be <=
672 #endif
673
674 /*!FSE_MAX_SYMBOL_VALUE :
675 * Maximum symbol value authorized.
676 * Required for proper stack allocation */
677 #ifndef FSE_MAX_SYMBOL_VALUE
678 # define FSE_MAX_SYMBOL_VALUE 255
679 #endif
680
681 /* *******************************************
682 * template functions type & suffix
683 **********************************************
684 #define FSE_FUNCTION_TYPE BYTE
685 #define FSE_FUNCTION_EXTENSION
686 #define FSE_DECODE_TYPE FSE_decode_t
687
688
689 #endif /* !FSE_COMMONDEFS_ONLY */
690
691
692 /* *******************************************
693 * Constants
694 **********************************************
695 #define FSE_MAX_TABLELOG (FSE_MAX_MEMORY_USAG
696 #define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELO
697 #define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESI
698 #define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMO
699 #define FSE_MIN_TABLELOG 5
700
701 #define FSE_TABLELOG_ABSOLUTE_MAX 15
702 #if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_M
703 # error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSO
704 #endif
705
706 #define FSE_TABLESTEP(tableSize) (((tableSize)
707
708
709 #endif /* FSE_STATIC_LINKING_ONLY */
710
711
712
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.