zstdlib 0.9.0-arm64-darwin

Sign up to get free protection for your applications and to get access to all the features.
Files changed (123) hide show
  1. checksums.yaml +7 -0
  2. data/.yardopts +6 -0
  3. data/CHANGES.md +78 -0
  4. data/Gemfile +3 -0
  5. data/README.md +107 -0
  6. data/Rakefile +59 -0
  7. data/ext/zstdlib_c/extconf.rb +54 -0
  8. data/ext/zstdlib_c/ruby/zlib-2.2/zstdlib.c +4675 -0
  9. data/ext/zstdlib_c/ruby/zlib-2.3/zstdlib.c +4702 -0
  10. data/ext/zstdlib_c/ruby/zlib-2.4/zstdlib.c +4859 -0
  11. data/ext/zstdlib_c/ruby/zlib-2.5/zstdlib.c +4864 -0
  12. data/ext/zstdlib_c/ruby/zlib-2.6/zstdlib.c +4906 -0
  13. data/ext/zstdlib_c/ruby/zlib-2.7/zstdlib.c +4895 -0
  14. data/ext/zstdlib_c/ruby/zlib-3.0/zstdlib.c +4994 -0
  15. data/ext/zstdlib_c/ruby/zlib-3.1/zstdlib.c +5076 -0
  16. data/ext/zstdlib_c/zlib-1.2.11/adler32.c +186 -0
  17. data/ext/zstdlib_c/zlib-1.2.11/compress.c +86 -0
  18. data/ext/zstdlib_c/zlib-1.2.11/crc32.c +442 -0
  19. data/ext/zstdlib_c/zlib-1.2.11/crc32.h +441 -0
  20. data/ext/zstdlib_c/zlib-1.2.11/deflate.c +2163 -0
  21. data/ext/zstdlib_c/zlib-1.2.11/deflate.h +349 -0
  22. data/ext/zstdlib_c/zlib-1.2.11/gzclose.c +25 -0
  23. data/ext/zstdlib_c/zlib-1.2.11/gzguts.h +218 -0
  24. data/ext/zstdlib_c/zlib-1.2.11/gzlib.c +637 -0
  25. data/ext/zstdlib_c/zlib-1.2.11/gzread.c +654 -0
  26. data/ext/zstdlib_c/zlib-1.2.11/gzwrite.c +665 -0
  27. data/ext/zstdlib_c/zlib-1.2.11/infback.c +640 -0
  28. data/ext/zstdlib_c/zlib-1.2.11/inffast.c +323 -0
  29. data/ext/zstdlib_c/zlib-1.2.11/inffast.h +11 -0
  30. data/ext/zstdlib_c/zlib-1.2.11/inffixed.h +94 -0
  31. data/ext/zstdlib_c/zlib-1.2.11/inflate.c +1561 -0
  32. data/ext/zstdlib_c/zlib-1.2.11/inflate.h +125 -0
  33. data/ext/zstdlib_c/zlib-1.2.11/inftrees.c +304 -0
  34. data/ext/zstdlib_c/zlib-1.2.11/inftrees.h +62 -0
  35. data/ext/zstdlib_c/zlib-1.2.11/trees.c +1203 -0
  36. data/ext/zstdlib_c/zlib-1.2.11/trees.h +128 -0
  37. data/ext/zstdlib_c/zlib-1.2.11/uncompr.c +93 -0
  38. data/ext/zstdlib_c/zlib-1.2.11/zconf.h +534 -0
  39. data/ext/zstdlib_c/zlib-1.2.11/zlib.h +1912 -0
  40. data/ext/zstdlib_c/zlib-1.2.11/zutil.c +325 -0
  41. data/ext/zstdlib_c/zlib-1.2.11/zutil.h +271 -0
  42. data/ext/zstdlib_c/zlib.mk +14 -0
  43. data/ext/zstdlib_c/zlibwrapper/zlibwrapper.c +10 -0
  44. data/ext/zstdlib_c/zlibwrapper.mk +14 -0
  45. data/ext/zstdlib_c/zstd-1.5.2/lib/common/bitstream.h +478 -0
  46. data/ext/zstdlib_c/zstd-1.5.2/lib/common/compiler.h +335 -0
  47. data/ext/zstdlib_c/zstd-1.5.2/lib/common/cpu.h +213 -0
  48. data/ext/zstdlib_c/zstd-1.5.2/lib/common/debug.c +24 -0
  49. data/ext/zstdlib_c/zstd-1.5.2/lib/common/debug.h +107 -0
  50. data/ext/zstdlib_c/zstd-1.5.2/lib/common/entropy_common.c +368 -0
  51. data/ext/zstdlib_c/zstd-1.5.2/lib/common/error_private.c +56 -0
  52. data/ext/zstdlib_c/zstd-1.5.2/lib/common/error_private.h +159 -0
  53. data/ext/zstdlib_c/zstd-1.5.2/lib/common/fse.h +717 -0
  54. data/ext/zstdlib_c/zstd-1.5.2/lib/common/fse_decompress.c +403 -0
  55. data/ext/zstdlib_c/zstd-1.5.2/lib/common/huf.h +364 -0
  56. data/ext/zstdlib_c/zstd-1.5.2/lib/common/mem.h +442 -0
  57. data/ext/zstdlib_c/zstd-1.5.2/lib/common/pool.c +355 -0
  58. data/ext/zstdlib_c/zstd-1.5.2/lib/common/pool.h +84 -0
  59. data/ext/zstdlib_c/zstd-1.5.2/lib/common/portability_macros.h +137 -0
  60. data/ext/zstdlib_c/zstd-1.5.2/lib/common/threading.c +122 -0
  61. data/ext/zstdlib_c/zstd-1.5.2/lib/common/threading.h +155 -0
  62. data/ext/zstdlib_c/zstd-1.5.2/lib/common/xxhash.c +24 -0
  63. data/ext/zstdlib_c/zstd-1.5.2/lib/common/xxhash.h +5686 -0
  64. data/ext/zstdlib_c/zstd-1.5.2/lib/common/zstd_common.c +83 -0
  65. data/ext/zstdlib_c/zstd-1.5.2/lib/common/zstd_deps.h +111 -0
  66. data/ext/zstdlib_c/zstd-1.5.2/lib/common/zstd_internal.h +493 -0
  67. data/ext/zstdlib_c/zstd-1.5.2/lib/common/zstd_trace.h +163 -0
  68. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/clevels.h +134 -0
  69. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/fse_compress.c +741 -0
  70. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/hist.c +181 -0
  71. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/hist.h +75 -0
  72. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/huf_compress.c +1370 -0
  73. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress.c +6327 -0
  74. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_internal.h +1458 -0
  75. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_literals.c +159 -0
  76. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_literals.h +31 -0
  77. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_sequences.c +442 -0
  78. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_sequences.h +54 -0
  79. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_superblock.c +573 -0
  80. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_superblock.h +32 -0
  81. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_cwksp.h +676 -0
  82. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_double_fast.c +696 -0
  83. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_double_fast.h +38 -0
  84. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_fast.c +675 -0
  85. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_fast.h +37 -0
  86. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_lazy.c +2104 -0
  87. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_lazy.h +125 -0
  88. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_ldm.c +724 -0
  89. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_ldm.h +117 -0
  90. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_ldm_geartab.h +106 -0
  91. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_opt.c +1446 -0
  92. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_opt.h +56 -0
  93. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstdmt_compress.c +1859 -0
  94. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstdmt_compress.h +113 -0
  95. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/huf_decompress.c +1889 -0
  96. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/huf_decompress_amd64.S +585 -0
  97. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/zstd_ddict.c +244 -0
  98. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/zstd_ddict.h +44 -0
  99. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/zstd_decompress.c +2230 -0
  100. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/zstd_decompress_block.c +2072 -0
  101. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/zstd_decompress_block.h +68 -0
  102. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/zstd_decompress_internal.h +236 -0
  103. data/ext/zstdlib_c/zstd-1.5.2/lib/zdict.h +452 -0
  104. data/ext/zstdlib_c/zstd-1.5.2/lib/zstd.h +2575 -0
  105. data/ext/zstdlib_c/zstd-1.5.2/lib/zstd_errors.h +95 -0
  106. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/gzclose.c +28 -0
  107. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/gzcompatibility.h +68 -0
  108. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/gzguts.h +229 -0
  109. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/gzlib.c +640 -0
  110. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/gzread.c +678 -0
  111. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/gzwrite.c +671 -0
  112. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/zstd_zlibwrapper.c +1198 -0
  113. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/zstd_zlibwrapper.h +88 -0
  114. data/ext/zstdlib_c/zstd.mk +15 -0
  115. data/lib/2.4/zstdlib_c.bundle +0 -0
  116. data/lib/2.5/zstdlib_c.bundle +0 -0
  117. data/lib/2.6/zstdlib_c.bundle +0 -0
  118. data/lib/2.7/zstdlib_c.bundle +0 -0
  119. data/lib/3.0/zstdlib_c.bundle +0 -0
  120. data/lib/3.1/zstdlib_c.bundle +0 -0
  121. data/lib/zstdlib.rb +6 -0
  122. data/test/zstdlib_test.rb +21 -0
  123. metadata +237 -0
@@ -0,0 +1,717 @@
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/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 "zstd_deps.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); /**< library version number; to be used when checking dll version */
54
+
55
+
56
+ /*-****************************************
57
+ * FSE simple functions
58
+ ******************************************/
59
+ /*! FSE_compress() :
60
+ Compress content of buffer 'src', of size 'srcSize', into destination buffer 'dst'.
61
+ 'dst' buffer must be already allocated. Compression runs faster is dstCapacity >= FSE_compressBound(srcSize).
62
+ @return : size of compressed data (<= dstCapacity).
63
+ Special values : if return == 0, srcData is not compressible => Nothing is stored within dst !!!
64
+ if return == 1, srcData is a single byte symbol * srcSize times. Use RLE compression instead.
65
+ if FSE_isError(return), compression failed (more details using FSE_getErrorName())
66
+ */
67
+ FSE_PUBLIC_API size_t FSE_compress(void* dst, size_t dstCapacity,
68
+ const void* src, size_t srcSize);
69
+
70
+ /*! FSE_decompress():
71
+ Decompress FSE data from buffer 'cSrc', of size 'cSrcSize',
72
+ into already allocated destination buffer 'dst', of size 'dstCapacity'.
73
+ @return : size of regenerated data (<= maxDstSize),
74
+ or an error code, which can be tested using FSE_isError() .
75
+
76
+ ** Important ** : FSE_decompress() does not decompress non-compressible nor RLE data !!!
77
+ Why ? : making this distinction requires a header.
78
+ Header management is intentionally delegated to the user layer, which can better manage special cases.
79
+ */
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
+ ******************************************/
97
+ /*! FSE_compress2() :
98
+ Same as FSE_compress(), but allows the selection of 'maxSymbolValue' and 'tableLog'
99
+ Both parameters can be defined as '0' to mean : use default value
100
+ @return : size of compressed data
101
+ Special values : if return == 0, srcData is not compressible => Nothing is stored within cSrc !!!
102
+ if return == 1, srcData is a single byte symbol * srcSize times. Use RLE compression.
103
+ if FSE_isError(return), it's an error code.
104
+ */
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
+ ******************************************/
111
+ /*!
112
+ FSE_compress() does the following:
113
+ 1. count symbol occurrence from source[] into table count[] (see hist.h)
114
+ 2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog)
115
+ 3. save normalized counters to memory buffer using writeNCount()
116
+ 4. build encoding table 'CTable' from normalized counters
117
+ 5. encode the data stream using encoding table 'CTable'
118
+
119
+ FSE_decompress() does the following:
120
+ 1. read normalized counters with readNCount()
121
+ 2. build decoding table 'DTable' from normalized counters
122
+ 3. decode the data stream using decoding table 'DTable'
123
+
124
+ The following API allows targeting specific sub-functions for advanced tasks.
125
+ For example, it's possible to compress several blocks using the same 'CTable',
126
+ or to save and provide normalized distribution using external method.
127
+ */
128
+
129
+ /* *** COMPRESSION *** */
130
+
131
+ /*! FSE_optimalTableLog():
132
+ dynamically downsize 'tableLog' when conditions are met.
133
+ It saves CPU time, by using smaller tables, while preserving or even improving compression ratio.
134
+ @return : recommended tableLog (necessarily <= 'maxTableLog') */
135
+ FSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue);
136
+
137
+ /*! FSE_normalizeCount():
138
+ normalize counts so that sum(count[]) == Power_of_2 (2^tableLog)
139
+ 'normalizedCounter' is a table of short, of minimum size (maxSymbolValue+1).
140
+ useLowProbCount is a boolean parameter which trades off compressed size for
141
+ faster header decoding. When it is set to 1, the compressed data will be slightly
142
+ smaller. And when it is set to 0, FSE_readNCount() and FSE_buildDTable() will be
143
+ faster. If you are compressing a small amount of data (< 2 KB) then useLowProbCount=0
144
+ is a good default, since header deserialization makes a big speed difference.
145
+ Otherwise, useLowProbCount=1 is a good default, since the speed difference is small.
146
+ @return : tableLog,
147
+ or an errorCode, which can be tested using FSE_isError() */
148
+ FSE_PUBLIC_API size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog,
149
+ const unsigned* count, size_t srcSize, unsigned maxSymbolValue, unsigned useLowProbCount);
150
+
151
+ /*! FSE_NCountWriteBound():
152
+ Provides the maximum possible size of an FSE normalized table, given 'maxSymbolValue' and 'tableLog'.
153
+ Typically useful for allocation purpose. */
154
+ FSE_PUBLIC_API size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog);
155
+
156
+ /*! FSE_writeNCount():
157
+ Compactly save 'normalizedCounter' into 'buffer'.
158
+ @return : size of the compressed table,
159
+ or an errorCode, which can be tested using FSE_isError(). */
160
+ FSE_PUBLIC_API size_t FSE_writeNCount (void* buffer, size_t bufferSize,
161
+ const short* normalizedCounter,
162
+ unsigned maxSymbolValue, unsigned tableLog);
163
+
164
+ /*! Constructor and Destructor of FSE_CTable.
165
+ Note that FSE_CTable size depends on 'tableLog' and 'maxSymbolValue' */
166
+ typedef unsigned FSE_CTable; /* don't allocate that. It's only meant to be more restrictive than void* */
167
+ FSE_PUBLIC_API FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog);
168
+ FSE_PUBLIC_API void FSE_freeCTable (FSE_CTable* ct);
169
+
170
+ /*! FSE_buildCTable():
171
+ Builds `ct`, which must be already allocated, using FSE_createCTable().
172
+ @return : 0, or an errorCode, which can be tested using FSE_isError() */
173
+ FSE_PUBLIC_API size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
174
+
175
+ /*! FSE_compress_usingCTable():
176
+ Compress `src` using `ct` into `dst` which must be already allocated.
177
+ @return : size of compressed data (<= `dstCapacity`),
178
+ or 0 if compressed data could not fit into `dst`,
179
+ or an errorCode, which can be tested using FSE_isError() */
180
+ FSE_PUBLIC_API size_t FSE_compress_usingCTable (void* dst, size_t dstCapacity, const void* src, size_t srcSize, const FSE_CTable* ct);
181
+
182
+ /*!
183
+ Tutorial :
184
+ ----------
185
+ The first step is to count all symbols. FSE_count() does this job very fast.
186
+ Result will be saved into 'count', a table of unsigned int, which must be already allocated, and have 'maxSymbolValuePtr[0]+1' cells.
187
+ 'src' is a table of bytes of size 'srcSize'. All values within 'src' MUST be <= maxSymbolValuePtr[0]
188
+ maxSymbolValuePtr[0] will be updated, with its real value (necessarily <= original value)
189
+ FSE_count() will return the number of occurrence of the most frequent symbol.
190
+ This can be used to know if there is a single symbol within 'src', and to quickly evaluate its compressibility.
191
+ If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).
192
+
193
+ The next step is to normalize the frequencies.
194
+ FSE_normalizeCount() will ensure that sum of frequencies is == 2 ^'tableLog'.
195
+ It also guarantees a minimum of 1 to any Symbol with frequency >= 1.
196
+ You can use 'tableLog'==0 to mean "use default tableLog value".
197
+ If you are unsure of which tableLog value to use, you can ask FSE_optimalTableLog(),
198
+ which will provide the optimal valid tableLog given sourceSize, maxSymbolValue, and a user-defined maximum (0 means "default").
199
+
200
+ The result of FSE_normalizeCount() will be saved into a table,
201
+ called 'normalizedCounter', which is a table of signed short.
202
+ 'normalizedCounter' must be already allocated, and have at least 'maxSymbolValue+1' cells.
203
+ The return value is tableLog if everything proceeded as expected.
204
+ It is 0 if there is a single symbol within distribution.
205
+ If there is an error (ex: invalid tableLog value), the function will return an ErrorCode (which can be tested using FSE_isError()).
206
+
207
+ 'normalizedCounter' can be saved in a compact manner to a memory area using FSE_writeNCount().
208
+ 'buffer' must be already allocated.
209
+ For guaranteed success, buffer size must be at least FSE_headerBound().
210
+ The result of the function is the number of bytes written into 'buffer'.
211
+ If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError(); ex : buffer size too small).
212
+
213
+ 'normalizedCounter' can then be used to create the compression table 'CTable'.
214
+ The space required by 'CTable' must be already allocated, using FSE_createCTable().
215
+ You can then use FSE_buildCTable() to fill 'CTable'.
216
+ If there is an error, both functions will return an ErrorCode (which can be tested using FSE_isError()).
217
+
218
+ 'CTable' can then be used to compress 'src', with FSE_compress_usingCTable().
219
+ Similar to FSE_count(), the convention is that 'src' is assumed to be a table of char of size 'srcSize'
220
+ The function returns the size of compressed data (without header), necessarily <= `dstCapacity`.
221
+ If it returns '0', compressed data could not fit into 'dst'.
222
+ If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).
223
+ */
224
+
225
+
226
+ /* *** DECOMPRESSION *** */
227
+
228
+ /*! FSE_readNCount():
229
+ Read compactly saved 'normalizedCounter' from 'rBuffer'.
230
+ @return : size read from 'rBuffer',
231
+ or an errorCode, which can be tested using FSE_isError().
232
+ maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
233
+ FSE_PUBLIC_API size_t FSE_readNCount (short* normalizedCounter,
234
+ unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,
235
+ const void* rBuffer, size_t rBuffSize);
236
+
237
+ /*! FSE_readNCount_bmi2():
238
+ * Same as FSE_readNCount() but pass bmi2=1 when your CPU supports BMI2 and 0 otherwise.
239
+ */
240
+ FSE_PUBLIC_API size_t FSE_readNCount_bmi2(short* normalizedCounter,
241
+ unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,
242
+ const void* rBuffer, size_t rBuffSize, int bmi2);
243
+
244
+ /*! Constructor and Destructor of FSE_DTable.
245
+ Note that its size depends on 'tableLog' */
246
+ typedef unsigned FSE_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */
247
+ FSE_PUBLIC_API FSE_DTable* FSE_createDTable(unsigned tableLog);
248
+ FSE_PUBLIC_API void FSE_freeDTable(FSE_DTable* dt);
249
+
250
+ /*! FSE_buildDTable():
251
+ Builds 'dt', which must be already allocated, using FSE_createDTable().
252
+ return : 0, or an errorCode, which can be tested using FSE_isError() */
253
+ FSE_PUBLIC_API size_t FSE_buildDTable (FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
254
+
255
+ /*! FSE_decompress_usingDTable():
256
+ Decompress compressed source `cSrc` of size `cSrcSize` using `dt`
257
+ into `dst` which must be already allocated.
258
+ @return : size of regenerated data (necessarily <= `dstCapacity`),
259
+ or an errorCode, which can be tested using FSE_isError() */
260
+ FSE_PUBLIC_API size_t FSE_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt);
261
+
262
+ /*!
263
+ Tutorial :
264
+ ----------
265
+ (Note : these functions only decompress FSE-compressed blocks.
266
+ If block is uncompressed, use memcpy() instead
267
+ If block is a single repeated byte, use memset() instead )
268
+
269
+ The first step is to obtain the normalized frequencies of symbols.
270
+ This can be performed by FSE_readNCount() if it was saved using FSE_writeNCount().
271
+ 'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short.
272
+ In practice, that means it's necessary to know 'maxSymbolValue' beforehand,
273
+ or size the table to handle worst case situations (typically 256).
274
+ FSE_readNCount() will provide 'tableLog' and 'maxSymbolValue'.
275
+ The result of FSE_readNCount() is the number of bytes read from 'rBuffer'.
276
+ Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that.
277
+ If there is an error, the function will return an error code, which can be tested using FSE_isError().
278
+
279
+ The next step is to build the decompression tables 'FSE_DTable' from 'normalizedCounter'.
280
+ This is performed by the function FSE_buildDTable().
281
+ The space required by 'FSE_DTable' must be already allocated using FSE_createDTable().
282
+ If there is an error, the function will return an error code, which can be tested using FSE_isError().
283
+
284
+ `FSE_DTable` can then be used to decompress `cSrc`, with FSE_decompress_usingDTable().
285
+ `cSrcSize` must be strictly correct, otherwise decompression will fail.
286
+ FSE_decompress_usingDTable() result will tell how many bytes were regenerated (<=`dstCapacity`).
287
+ If there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small)
288
+ */
289
+
290
+ #endif /* FSE_H */
291
+
292
+ #if defined(FSE_STATIC_LINKING_ONLY) && !defined(FSE_H_FSE_STATIC_LINKING_ONLY)
293
+ #define FSE_H_FSE_STATIC_LINKING_ONLY
294
+
295
+ /* *** Dependency *** */
296
+ #include "bitstream.h"
297
+
298
+
299
+ /* *****************************************
300
+ * Static allocation
301
+ *******************************************/
302
+ /* FSE buffer bounds */
303
+ #define FSE_NCOUNTBOUND 512
304
+ #define FSE_BLOCKBOUND(size) ((size) + ((size)>>7) + 4 /* fse states */ + sizeof(size_t) /* bitContainer */)
305
+ #define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size)) /* Macro version, useful for static allocation */
306
+
307
+ /* It is possible to statically allocate FSE CTable/DTable as a table of FSE_CTable/FSE_DTable using below macros */
308
+ #define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) (1 + (1<<((maxTableLog)-1)) + (((maxSymbolValue)+1)*2))
309
+ #define FSE_DTABLE_SIZE_U32(maxTableLog) (1 + (1<<(maxTableLog)))
310
+
311
+ /* or use the size to malloc() space directly. Pay attention to alignment restrictions though */
312
+ #define FSE_CTABLE_SIZE(maxTableLog, maxSymbolValue) (FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(FSE_CTable))
313
+ #define FSE_DTABLE_SIZE(maxTableLog) (FSE_DTABLE_SIZE_U32(maxTableLog) * sizeof(FSE_DTable))
314
+
315
+
316
+ /* *****************************************
317
+ * FSE advanced API
318
+ ***************************************** */
319
+
320
+ unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus);
321
+ /**< same as FSE_optimalTableLog(), which used `minus==2` */
322
+
323
+ /* FSE_compress_wksp() :
324
+ * Same as FSE_compress2(), but using an externally allocated scratch buffer (`workSpace`).
325
+ * FSE_COMPRESS_WKSP_SIZE_U32() provides the minimum size required for `workSpace` as a table of FSE_CTable.
326
+ */
327
+ #define FSE_COMPRESS_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) ( FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) + ((maxTableLog > 12) ? (1 << (maxTableLog - 2)) : 1024) )
328
+ 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);
329
+
330
+ size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits);
331
+ /**< build a fake FSE_CTable, designed for a flat distribution, where each symbol uses nbBits */
332
+
333
+ size_t FSE_buildCTable_rle (FSE_CTable* ct, unsigned char symbolValue);
334
+ /**< build a fake FSE_CTable, designed to compress always the same symbolValue */
335
+
336
+ /* FSE_buildCTable_wksp() :
337
+ * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).
338
+ * `wkspSize` must be >= `FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(maxSymbolValue, tableLog)` of `unsigned`.
339
+ * See FSE_buildCTable_wksp() for breakdown of workspace usage.
340
+ */
341
+ #define FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(maxSymbolValue, tableLog) (((maxSymbolValue + 2) + (1ull << (tableLog)))/2 + sizeof(U64)/sizeof(U32) /* additional 8 bytes for potential table overwrite */)
342
+ #define FSE_BUILD_CTABLE_WORKSPACE_SIZE(maxSymbolValue, tableLog) (sizeof(unsigned) * FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(maxSymbolValue, tableLog))
343
+ size_t FSE_buildCTable_wksp(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);
344
+
345
+ #define FSE_BUILD_DTABLE_WKSP_SIZE(maxTableLog, maxSymbolValue) (sizeof(short) * (maxSymbolValue + 1) + (1ULL << maxTableLog) + 8)
346
+ #define FSE_BUILD_DTABLE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) ((FSE_BUILD_DTABLE_WKSP_SIZE(maxTableLog, maxSymbolValue) + sizeof(unsigned) - 1) / sizeof(unsigned))
347
+ FSE_PUBLIC_API size_t FSE_buildDTable_wksp(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);
348
+ /**< Same as FSE_buildDTable(), using an externally allocated `workspace` produced with `FSE_BUILD_DTABLE_WKSP_SIZE_U32(maxSymbolValue)` */
349
+
350
+ size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
351
+ /**< build a fake FSE_DTable, designed to read a flat distribution where each symbol uses nbBits */
352
+
353
+ size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
354
+ /**< build a fake FSE_DTable, designed to always generate the same symbolValue */
355
+
356
+ #define FSE_DECOMPRESS_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) (FSE_DTABLE_SIZE_U32(maxTableLog) + FSE_BUILD_DTABLE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) + (FSE_MAX_SYMBOL_VALUE + 1) / 2 + 1)
357
+ #define FSE_DECOMPRESS_WKSP_SIZE(maxTableLog, maxSymbolValue) (FSE_DECOMPRESS_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(unsigned))
358
+ size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize);
359
+ /**< same as FSE_decompress(), using an externally allocated `workSpace` produced with `FSE_DECOMPRESS_WKSP_SIZE_U32(maxLog, maxSymbolValue)` */
360
+
361
+ size_t FSE_decompress_wksp_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize, int bmi2);
362
+ /**< Same as FSE_decompress_wksp() but with dynamic BMI2 support. Pass 1 if your CPU supports BMI2 or 0 if it doesn't. */
363
+
364
+ typedef enum {
365
+ FSE_repeat_none, /**< Cannot use the previous table */
366
+ FSE_repeat_check, /**< Can use the previous table but it must be checked */
367
+ FSE_repeat_valid /**< Can use the previous table and it is assumed to be valid */
368
+ } FSE_repeat;
369
+
370
+ /* *****************************************
371
+ * FSE symbol compression API
372
+ *******************************************/
373
+ /*!
374
+ This API consists of small unitary functions, which highly benefit from being inlined.
375
+ Hence their body are included in next section.
376
+ */
377
+ typedef struct {
378
+ ptrdiff_t value;
379
+ const void* stateTable;
380
+ const void* symbolTT;
381
+ unsigned stateLog;
382
+ } FSE_CState_t;
383
+
384
+ static void FSE_initCState(FSE_CState_t* CStatePtr, const FSE_CTable* ct);
385
+
386
+ static void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* CStatePtr, unsigned symbol);
387
+
388
+ static void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* CStatePtr);
389
+
390
+ /**<
391
+ These functions are inner components of FSE_compress_usingCTable().
392
+ They allow the creation of custom streams, mixing multiple tables and bit sources.
393
+
394
+ A key property to keep in mind is that encoding and decoding are done **in reverse direction**.
395
+ So the first symbol you will encode is the last you will decode, like a LIFO stack.
396
+
397
+ You will need a few variables to track your CStream. They are :
398
+
399
+ FSE_CTable ct; // Provided by FSE_buildCTable()
400
+ BIT_CStream_t bitStream; // bitStream tracking structure
401
+ FSE_CState_t state; // State tracking structure (can have several)
402
+
403
+
404
+ The first thing to do is to init bitStream and state.
405
+ size_t errorCode = BIT_initCStream(&bitStream, dstBuffer, maxDstSize);
406
+ FSE_initCState(&state, ct);
407
+
408
+ Note that BIT_initCStream() can produce an error code, so its result should be tested, using FSE_isError();
409
+ You can then encode your input data, byte after byte.
410
+ FSE_encodeSymbol() outputs a maximum of 'tableLog' bits at a time.
411
+ Remember decoding will be done in reverse direction.
412
+ FSE_encodeByte(&bitStream, &state, symbol);
413
+
414
+ At any time, you can also add any bit sequence.
415
+ Note : maximum allowed nbBits is 25, for compatibility with 32-bits decoders
416
+ BIT_addBits(&bitStream, bitField, nbBits);
417
+
418
+ The above methods don't commit data to memory, they just store it into local register, for speed.
419
+ Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
420
+ Writing data to memory is a manual operation, performed by the flushBits function.
421
+ BIT_flushBits(&bitStream);
422
+
423
+ Your last FSE encoding operation shall be to flush your last state value(s).
424
+ FSE_flushState(&bitStream, &state);
425
+
426
+ Finally, you must close the bitStream.
427
+ The function returns the size of CStream in bytes.
428
+ If data couldn't fit into dstBuffer, it will return a 0 ( == not compressible)
429
+ If there is an error, it returns an errorCode (which can be tested using FSE_isError()).
430
+ size_t size = BIT_closeCStream(&bitStream);
431
+ */
432
+
433
+
434
+ /* *****************************************
435
+ * FSE symbol decompression API
436
+ *******************************************/
437
+ typedef struct {
438
+ size_t state;
439
+ const void* table; /* precise table may vary, depending on U16 */
440
+ } FSE_DState_t;
441
+
442
+
443
+ static void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
444
+
445
+ static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
446
+
447
+ static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
448
+
449
+ /**<
450
+ Let's now decompose FSE_decompress_usingDTable() into its unitary components.
451
+ You will decode FSE-encoded symbols from the bitStream,
452
+ and also any other bitFields you put in, **in reverse order**.
453
+
454
+ You will need a few variables to track your bitStream. They are :
455
+
456
+ BIT_DStream_t DStream; // Stream context
457
+ FSE_DState_t DState; // State context. Multiple ones are possible
458
+ FSE_DTable* DTablePtr; // Decoding table, provided by FSE_buildDTable()
459
+
460
+ The first thing to do is to init the bitStream.
461
+ errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize);
462
+
463
+ You should then retrieve your initial state(s)
464
+ (in reverse flushing order if you have several ones) :
465
+ errorCode = FSE_initDState(&DState, &DStream, DTablePtr);
466
+
467
+ You can then decode your data, symbol after symbol.
468
+ For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'.
469
+ Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
470
+ unsigned char symbol = FSE_decodeSymbol(&DState, &DStream);
471
+
472
+ You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
473
+ Note : maximum allowed nbBits is 25, for 32-bits compatibility
474
+ size_t bitField = BIT_readBits(&DStream, nbBits);
475
+
476
+ All above operations only read from local register (which size depends on size_t).
477
+ Refueling the register from memory is manually performed by the reload method.
478
+ endSignal = FSE_reloadDStream(&DStream);
479
+
480
+ BIT_reloadDStream() result tells if there is still some more data to read from DStream.
481
+ BIT_DStream_unfinished : there is still some data left into the DStream.
482
+ BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
483
+ BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
484
+ BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
485
+
486
+ When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
487
+ to properly detect the exact end of stream.
488
+ After each decoded symbol, check if DStream is fully consumed using this simple test :
489
+ BIT_reloadDStream(&DStream) >= BIT_DStream_completed
490
+
491
+ When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
492
+ Checking if DStream has reached its end is performed by :
493
+ BIT_endOfDStream(&DStream);
494
+ Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
495
+ FSE_endOfDState(&DState);
496
+ */
497
+
498
+
499
+ /* *****************************************
500
+ * FSE unsafe API
501
+ *******************************************/
502
+ static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
503
+ /* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
504
+
505
+
506
+ /* *****************************************
507
+ * Implementation of inlined functions
508
+ *******************************************/
509
+ typedef struct {
510
+ int deltaFindState;
511
+ U32 deltaNbBits;
512
+ } FSE_symbolCompressionTransform; /* total 8 bytes */
513
+
514
+ MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct)
515
+ {
516
+ const void* ptr = ct;
517
+ const U16* u16ptr = (const U16*) ptr;
518
+ const U32 tableLog = MEM_read16(ptr);
519
+ statePtr->value = (ptrdiff_t)1<<tableLog;
520
+ statePtr->stateTable = u16ptr+2;
521
+ statePtr->symbolTT = ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1);
522
+ statePtr->stateLog = tableLog;
523
+ }
524
+
525
+
526
+ /*! FSE_initCState2() :
527
+ * Same as FSE_initCState(), but the first symbol to include (which will be the last to be read)
528
+ * uses the smallest state value possible, saving the cost of this symbol */
529
+ MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol)
530
+ {
531
+ FSE_initCState(statePtr, ct);
532
+ { const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
533
+ const U16* stateTable = (const U16*)(statePtr->stateTable);
534
+ U32 nbBitsOut = (U32)((symbolTT.deltaNbBits + (1<<15)) >> 16);
535
+ statePtr->value = (nbBitsOut << 16) - symbolTT.deltaNbBits;
536
+ statePtr->value = stateTable[(statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
537
+ }
538
+ }
539
+
540
+ MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, unsigned symbol)
541
+ {
542
+ FSE_symbolCompressionTransform const symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
543
+ const U16* const stateTable = (const U16*)(statePtr->stateTable);
544
+ U32 const nbBitsOut = (U32)((statePtr->value + symbolTT.deltaNbBits) >> 16);
545
+ BIT_addBits(bitC, statePtr->value, nbBitsOut);
546
+ statePtr->value = stateTable[ (statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
547
+ }
548
+
549
+ MEM_STATIC void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* statePtr)
550
+ {
551
+ BIT_addBits(bitC, statePtr->value, statePtr->stateLog);
552
+ BIT_flushBits(bitC);
553
+ }
554
+
555
+
556
+ /* FSE_getMaxNbBits() :
557
+ * Approximate maximum cost of a symbol, in bits.
558
+ * Fractional get rounded up (i.e : a symbol with a normalized frequency of 3 gives the same result as a frequency of 2)
559
+ * note 1 : assume symbolValue is valid (<= maxSymbolValue)
560
+ * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
561
+ MEM_STATIC U32 FSE_getMaxNbBits(const void* symbolTTPtr, U32 symbolValue)
562
+ {
563
+ const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
564
+ return (symbolTT[symbolValue].deltaNbBits + ((1<<16)-1)) >> 16;
565
+ }
566
+
567
+ /* FSE_bitCost() :
568
+ * Approximate symbol cost, as fractional value, using fixed-point format (accuracyLog fractional bits)
569
+ * note 1 : assume symbolValue is valid (<= maxSymbolValue)
570
+ * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
571
+ MEM_STATIC U32 FSE_bitCost(const void* symbolTTPtr, U32 tableLog, U32 symbolValue, U32 accuracyLog)
572
+ {
573
+ const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
574
+ U32 const minNbBits = symbolTT[symbolValue].deltaNbBits >> 16;
575
+ U32 const threshold = (minNbBits+1) << 16;
576
+ assert(tableLog < 16);
577
+ assert(accuracyLog < 31-tableLog); /* ensure enough room for renormalization double shift */
578
+ { U32 const tableSize = 1 << tableLog;
579
+ U32 const deltaFromThreshold = threshold - (symbolTT[symbolValue].deltaNbBits + tableSize);
580
+ U32 const normalizedDeltaFromThreshold = (deltaFromThreshold << accuracyLog) >> tableLog; /* linear interpolation (very approximate) */
581
+ U32 const bitMultiplier = 1 << accuracyLog;
582
+ assert(symbolTT[symbolValue].deltaNbBits + tableSize <= threshold);
583
+ assert(normalizedDeltaFromThreshold <= bitMultiplier);
584
+ return (minNbBits+1)*bitMultiplier - normalizedDeltaFromThreshold;
585
+ }
586
+ }
587
+
588
+
589
+ /* ====== Decompression ====== */
590
+
591
+ typedef struct {
592
+ U16 tableLog;
593
+ U16 fastMode;
594
+ } FSE_DTableHeader; /* sizeof U32 */
595
+
596
+ typedef struct
597
+ {
598
+ unsigned short newState;
599
+ unsigned char symbol;
600
+ unsigned char nbBits;
601
+ } FSE_decode_t; /* size == U32 */
602
+
603
+ MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
604
+ {
605
+ const void* ptr = dt;
606
+ const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr;
607
+ DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
608
+ BIT_reloadDStream(bitD);
609
+ DStatePtr->table = dt + 1;
610
+ }
611
+
612
+ MEM_STATIC BYTE FSE_peekSymbol(const FSE_DState_t* DStatePtr)
613
+ {
614
+ FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
615
+ return DInfo.symbol;
616
+ }
617
+
618
+ MEM_STATIC void FSE_updateState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
619
+ {
620
+ FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
621
+ U32 const nbBits = DInfo.nbBits;
622
+ size_t const lowBits = BIT_readBits(bitD, nbBits);
623
+ DStatePtr->state = DInfo.newState + lowBits;
624
+ }
625
+
626
+ MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
627
+ {
628
+ FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
629
+ U32 const nbBits = DInfo.nbBits;
630
+ BYTE const symbol = DInfo.symbol;
631
+ size_t const lowBits = BIT_readBits(bitD, nbBits);
632
+
633
+ DStatePtr->state = DInfo.newState + lowBits;
634
+ return symbol;
635
+ }
636
+
637
+ /*! FSE_decodeSymbolFast() :
638
+ unsafe, only works if no symbol has a probability > 50% */
639
+ MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
640
+ {
641
+ FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
642
+ U32 const nbBits = DInfo.nbBits;
643
+ BYTE const symbol = DInfo.symbol;
644
+ size_t const lowBits = BIT_readBitsFast(bitD, nbBits);
645
+
646
+ DStatePtr->state = DInfo.newState + lowBits;
647
+ return symbol;
648
+ }
649
+
650
+ MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
651
+ {
652
+ return DStatePtr->state == 0;
653
+ }
654
+
655
+
656
+
657
+ #ifndef FSE_COMMONDEFS_ONLY
658
+
659
+ /* **************************************************************
660
+ * Tuning parameters
661
+ ****************************************************************/
662
+ /*!MEMORY_USAGE :
663
+ * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
664
+ * Increasing memory usage improves compression ratio
665
+ * Reduced memory usage can improve speed, due to cache effect
666
+ * Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */
667
+ #ifndef FSE_MAX_MEMORY_USAGE
668
+ # define FSE_MAX_MEMORY_USAGE 14
669
+ #endif
670
+ #ifndef FSE_DEFAULT_MEMORY_USAGE
671
+ # define FSE_DEFAULT_MEMORY_USAGE 13
672
+ #endif
673
+ #if (FSE_DEFAULT_MEMORY_USAGE > FSE_MAX_MEMORY_USAGE)
674
+ # error "FSE_DEFAULT_MEMORY_USAGE must be <= FSE_MAX_MEMORY_USAGE"
675
+ #endif
676
+
677
+ /*!FSE_MAX_SYMBOL_VALUE :
678
+ * Maximum symbol value authorized.
679
+ * Required for proper stack allocation */
680
+ #ifndef FSE_MAX_SYMBOL_VALUE
681
+ # define FSE_MAX_SYMBOL_VALUE 255
682
+ #endif
683
+
684
+ /* **************************************************************
685
+ * template functions type & suffix
686
+ ****************************************************************/
687
+ #define FSE_FUNCTION_TYPE BYTE
688
+ #define FSE_FUNCTION_EXTENSION
689
+ #define FSE_DECODE_TYPE FSE_decode_t
690
+
691
+
692
+ #endif /* !FSE_COMMONDEFS_ONLY */
693
+
694
+
695
+ /* ***************************************************************
696
+ * Constants
697
+ *****************************************************************/
698
+ #define FSE_MAX_TABLELOG (FSE_MAX_MEMORY_USAGE-2)
699
+ #define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG)
700
+ #define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1)
701
+ #define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2)
702
+ #define FSE_MIN_TABLELOG 5
703
+
704
+ #define FSE_TABLELOG_ABSOLUTE_MAX 15
705
+ #if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX
706
+ # error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported"
707
+ #endif
708
+
709
+ #define FSE_TABLESTEP(tableSize) (((tableSize)>>1) + ((tableSize)>>3) + 3)
710
+
711
+
712
+ #endif /* FSE_STATIC_LINKING_ONLY */
713
+
714
+
715
+ #if defined (__cplusplus)
716
+ }
717
+ #endif