extzstd 0.0.2.CONCEPT → 0.0.3.CONCEPT

Sign up to get free protection for your applications and to get access to all the features.
Files changed (68) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +72 -22
  3. data/Rakefile +73 -19
  4. data/contrib/zstd/README.md +68 -0
  5. data/contrib/zstd/common/bitstream.h +414 -0
  6. data/contrib/zstd/common/entropy_common.c +231 -0
  7. data/contrib/zstd/common/error_private.h +125 -0
  8. data/contrib/zstd/common/error_public.h +77 -0
  9. data/contrib/zstd/common/fse.h +628 -0
  10. data/contrib/zstd/common/fse_decompress.c +331 -0
  11. data/contrib/zstd/common/huf.h +228 -0
  12. data/contrib/zstd/common/mem.h +377 -0
  13. data/contrib/zstd/common/xxhash.c +854 -0
  14. data/contrib/zstd/common/xxhash.h +273 -0
  15. data/contrib/zstd/common/zbuff.h +197 -0
  16. data/contrib/zstd/common/zstd.h +475 -0
  17. data/contrib/zstd/common/zstd_common.c +91 -0
  18. data/contrib/zstd/common/zstd_internal.h +238 -0
  19. data/contrib/zstd/compress/fse_compress.c +807 -0
  20. data/contrib/zstd/compress/huf_compress.c +577 -0
  21. data/contrib/zstd/compress/zbuff_compress.c +327 -0
  22. data/contrib/zstd/compress/zstd_compress.c +3074 -0
  23. data/contrib/zstd/compress/zstd_opt.h +1046 -0
  24. data/contrib/zstd/decompress/huf_decompress.c +894 -0
  25. data/contrib/zstd/decompress/zbuff_decompress.c +294 -0
  26. data/contrib/zstd/decompress/zstd_decompress.c +1362 -0
  27. data/contrib/zstd/dictBuilder/divsufsort.c +1913 -0
  28. data/contrib/zstd/dictBuilder/divsufsort.h +67 -0
  29. data/contrib/zstd/dictBuilder/zdict.c +1045 -0
  30. data/contrib/zstd/dictBuilder/zdict.h +113 -0
  31. data/contrib/zstd/legacy/zstd_legacy.h +140 -0
  32. data/contrib/zstd/legacy/zstd_v01.c +2178 -0
  33. data/contrib/zstd/{zstd.h → legacy/zstd_v01.h} +46 -39
  34. data/contrib/zstd/legacy/zstd_v02.c +3748 -0
  35. data/contrib/zstd/legacy/zstd_v02.h +99 -0
  36. data/contrib/zstd/legacy/zstd_v03.c +3389 -0
  37. data/contrib/zstd/legacy/zstd_v03.h +99 -0
  38. data/contrib/zstd/legacy/zstd_v04.c +4056 -0
  39. data/contrib/zstd/legacy/zstd_v04.h +148 -0
  40. data/contrib/zstd/legacy/zstd_v05.c +4325 -0
  41. data/contrib/zstd/legacy/zstd_v05.h +171 -0
  42. data/contrib/zstd/legacy/zstd_v06.c +4581 -0
  43. data/contrib/zstd/legacy/zstd_v06.h +185 -0
  44. data/ext/extconf.rb +10 -12
  45. data/ext/extzstd.c +497 -144
  46. data/ext/extzstd.h +127 -22
  47. data/ext/extzstd_buffered.c +265 -0
  48. data/ext/extzstd_nogvls.h +174 -0
  49. data/ext/zstd_amalgam.c +18 -0
  50. data/ext/zstd_legacy_v01.c +1 -0
  51. data/ext/zstd_legacy_v02.c +1 -0
  52. data/ext/zstd_legacy_v03.c +1 -0
  53. data/ext/zstd_legacy_v04.c +1 -0
  54. data/ext/zstd_legacy_v05.c +1 -0
  55. data/ext/zstd_legacy_v06.c +1 -0
  56. data/gemstub.rb +17 -1
  57. data/lib/extzstd.rb +197 -77
  58. data/lib/extzstd/version.rb +1 -1
  59. data/test/test_basic.rb +41 -0
  60. metadata +70 -20
  61. data/contrib/zstd/Makefile +0 -115
  62. data/contrib/zstd/fse.c +0 -2466
  63. data/contrib/zstd/fse.h +0 -320
  64. data/contrib/zstd/fse_static.h +0 -282
  65. data/contrib/zstd/libzstd.pc.in +0 -14
  66. data/contrib/zstd/zstd.c +0 -1768
  67. data/contrib/zstd/zstd_static.h +0 -89
  68. data/ext/extzstd-stream.c +0 -398
@@ -0,0 +1,331 @@
1
+ /* ******************************************************************
2
+ FSE : Finite State Entropy decoder
3
+ Copyright (C) 2013-2015, Yann Collet.
4
+
5
+ BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
6
+
7
+ Redistribution and use in source and binary forms, with or without
8
+ modification, are permitted provided that the following conditions are
9
+ met:
10
+
11
+ * Redistributions of source code must retain the above copyright
12
+ notice, this list of conditions and the following disclaimer.
13
+ * Redistributions in binary form must reproduce the above
14
+ copyright notice, this list of conditions and the following disclaimer
15
+ in the documentation and/or other materials provided with the
16
+ distribution.
17
+
18
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
+
30
+ You can contact the author at :
31
+ - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
32
+ - Public forum : https://groups.google.com/forum/#!forum/lz4c
33
+ ****************************************************************** */
34
+
35
+
36
+ /* **************************************************************
37
+ * Compiler specifics
38
+ ****************************************************************/
39
+ #ifdef _MSC_VER /* Visual Studio */
40
+ # define FORCE_INLINE static __forceinline
41
+ # include <intrin.h> /* For Visual 2005 */
42
+ # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */
43
+ # pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */
44
+ #else
45
+ # ifdef __GNUC__
46
+ # define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
47
+ # define FORCE_INLINE static inline __attribute__((always_inline))
48
+ # else
49
+ # define FORCE_INLINE static inline
50
+ # endif
51
+ #endif
52
+
53
+
54
+ /* **************************************************************
55
+ * Includes
56
+ ****************************************************************/
57
+ #include <stdlib.h> /* malloc, free, qsort */
58
+ #include <string.h> /* memcpy, memset */
59
+ #include <stdio.h> /* printf (debug) */
60
+ #include "bitstream.h"
61
+ #define FSE_STATIC_LINKING_ONLY
62
+ #include "fse.h"
63
+
64
+
65
+ /* **************************************************************
66
+ * Error Management
67
+ ****************************************************************/
68
+ #define FSE_isError ERR_isError
69
+ #define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */
70
+
71
+
72
+ /* **************************************************************
73
+ * Complex types
74
+ ****************************************************************/
75
+ typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];
76
+
77
+
78
+ /* **************************************************************
79
+ * Templates
80
+ ****************************************************************/
81
+ /*
82
+ designed to be included
83
+ for type-specific functions (template emulation in C)
84
+ Objective is to write these functions only once, for improved maintenance
85
+ */
86
+
87
+ /* safety checks */
88
+ #ifndef FSE_FUNCTION_EXTENSION
89
+ # error "FSE_FUNCTION_EXTENSION must be defined"
90
+ #endif
91
+ #ifndef FSE_FUNCTION_TYPE
92
+ # error "FSE_FUNCTION_TYPE must be defined"
93
+ #endif
94
+
95
+ /* Function names */
96
+ #define FSE_CAT(X,Y) X##Y
97
+ #define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
98
+ #define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)
99
+
100
+
101
+ /* Function templates */
102
+ FSE_DTable* FSE_createDTable (unsigned tableLog)
103
+ {
104
+ if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX;
105
+ return (FSE_DTable*)malloc( FSE_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );
106
+ }
107
+
108
+ void FSE_freeDTable (FSE_DTable* dt)
109
+ {
110
+ free(dt);
111
+ }
112
+
113
+ size_t FSE_buildDTable(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
114
+ {
115
+ void* const tdPtr = dt+1; /* because *dt is unsigned, 32-bits aligned on 32-bits */
116
+ FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr);
117
+ U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];
118
+
119
+ U32 const maxSV1 = maxSymbolValue + 1;
120
+ U32 const tableSize = 1 << tableLog;
121
+ U32 highThreshold = tableSize-1;
122
+
123
+ /* Sanity Checks */
124
+ if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
125
+ if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
126
+
127
+ /* Init, lay down lowprob symbols */
128
+ { FSE_DTableHeader DTableH;
129
+ DTableH.tableLog = (U16)tableLog;
130
+ DTableH.fastMode = 1;
131
+ { S16 const largeLimit= (S16)(1 << (tableLog-1));
132
+ U32 s;
133
+ for (s=0; s<maxSV1; s++) {
134
+ if (normalizedCounter[s]==-1) {
135
+ tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
136
+ symbolNext[s] = 1;
137
+ } else {
138
+ if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
139
+ symbolNext[s] = normalizedCounter[s];
140
+ } } }
141
+ memcpy(dt, &DTableH, sizeof(DTableH));
142
+ }
143
+
144
+ /* Spread symbols */
145
+ { U32 const tableMask = tableSize-1;
146
+ U32 const step = FSE_TABLESTEP(tableSize);
147
+ U32 s, position = 0;
148
+ for (s=0; s<maxSV1; s++) {
149
+ int i;
150
+ for (i=0; i<normalizedCounter[s]; i++) {
151
+ tableDecode[position].symbol = (FSE_FUNCTION_TYPE)s;
152
+ position = (position + step) & tableMask;
153
+ while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */
154
+ } }
155
+
156
+ if (position!=0) return ERROR(GENERIC); /* position must reach all cells once, otherwise normalizedCounter is incorrect */
157
+ }
158
+
159
+ /* Build Decoding table */
160
+ { U32 u;
161
+ for (u=0; u<tableSize; u++) {
162
+ FSE_FUNCTION_TYPE const symbol = (FSE_FUNCTION_TYPE)(tableDecode[u].symbol);
163
+ U16 nextState = symbolNext[symbol]++;
164
+ tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32 ((U32)nextState) );
165
+ tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
166
+ } }
167
+
168
+ return 0;
169
+ }
170
+
171
+
172
+
173
+ #ifndef FSE_COMMONDEFS_ONLY
174
+
175
+ /*-*******************************************************
176
+ * Decompression (Byte symbols)
177
+ *********************************************************/
178
+ size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
179
+ {
180
+ void* ptr = dt;
181
+ FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
182
+ void* dPtr = dt + 1;
183
+ FSE_decode_t* const cell = (FSE_decode_t*)dPtr;
184
+
185
+ DTableH->tableLog = 0;
186
+ DTableH->fastMode = 0;
187
+
188
+ cell->newState = 0;
189
+ cell->symbol = symbolValue;
190
+ cell->nbBits = 0;
191
+
192
+ return 0;
193
+ }
194
+
195
+
196
+ size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
197
+ {
198
+ void* ptr = dt;
199
+ FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
200
+ void* dPtr = dt + 1;
201
+ FSE_decode_t* const dinfo = (FSE_decode_t*)dPtr;
202
+ const unsigned tableSize = 1 << nbBits;
203
+ const unsigned tableMask = tableSize - 1;
204
+ const unsigned maxSV1 = tableMask+1;
205
+ unsigned s;
206
+
207
+ /* Sanity checks */
208
+ if (nbBits < 1) return ERROR(GENERIC); /* min size */
209
+
210
+ /* Build Decoding Table */
211
+ DTableH->tableLog = (U16)nbBits;
212
+ DTableH->fastMode = 1;
213
+ for (s=0; s<maxSV1; s++) {
214
+ dinfo[s].newState = 0;
215
+ dinfo[s].symbol = (BYTE)s;
216
+ dinfo[s].nbBits = (BYTE)nbBits;
217
+ }
218
+
219
+ return 0;
220
+ }
221
+
222
+ FORCE_INLINE size_t FSE_decompress_usingDTable_generic(
223
+ void* dst, size_t maxDstSize,
224
+ const void* cSrc, size_t cSrcSize,
225
+ const FSE_DTable* dt, const unsigned fast)
226
+ {
227
+ BYTE* const ostart = (BYTE*) dst;
228
+ BYTE* op = ostart;
229
+ BYTE* const omax = op + maxDstSize;
230
+ BYTE* const olimit = omax-3;
231
+
232
+ BIT_DStream_t bitD;
233
+ FSE_DState_t state1;
234
+ FSE_DState_t state2;
235
+
236
+ /* Init */
237
+ { size_t const errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize); /* replaced last arg by maxCompressed Size */
238
+ if (FSE_isError(errorCode)) return errorCode; }
239
+
240
+ FSE_initDState(&state1, &bitD, dt);
241
+ FSE_initDState(&state2, &bitD, dt);
242
+
243
+ #define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)
244
+
245
+ /* 4 symbols per loop */
246
+ for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) && (op<olimit) ; op+=4) {
247
+ op[0] = FSE_GETSYMBOL(&state1);
248
+
249
+ if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */
250
+ BIT_reloadDStream(&bitD);
251
+
252
+ op[1] = FSE_GETSYMBOL(&state2);
253
+
254
+ if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */
255
+ { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }
256
+
257
+ op[2] = FSE_GETSYMBOL(&state1);
258
+
259
+ if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */
260
+ BIT_reloadDStream(&bitD);
261
+
262
+ op[3] = FSE_GETSYMBOL(&state2);
263
+ }
264
+
265
+ /* tail */
266
+ /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */
267
+ while (1) {
268
+ if (op>(omax-2)) return ERROR(dstSize_tooSmall);
269
+
270
+ *op++ = FSE_GETSYMBOL(&state1);
271
+
272
+ if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {
273
+ *op++ = FSE_GETSYMBOL(&state2);
274
+ break;
275
+ }
276
+
277
+ if (op>(omax-2)) return ERROR(dstSize_tooSmall);
278
+
279
+ *op++ = FSE_GETSYMBOL(&state2);
280
+
281
+ if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {
282
+ *op++ = FSE_GETSYMBOL(&state1);
283
+ break;
284
+ } }
285
+
286
+ return op-ostart;
287
+ }
288
+
289
+
290
+ size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
291
+ const void* cSrc, size_t cSrcSize,
292
+ const FSE_DTable* dt)
293
+ {
294
+ const void* ptr = dt;
295
+ const FSE_DTableHeader* DTableH = (const FSE_DTableHeader*)ptr;
296
+ const U32 fastMode = DTableH->fastMode;
297
+
298
+ /* select fast mode (static) */
299
+ if (fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
300
+ return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
301
+ }
302
+
303
+
304
+ size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)
305
+ {
306
+ const BYTE* const istart = (const BYTE*)cSrc;
307
+ const BYTE* ip = istart;
308
+ short counting[FSE_MAX_SYMBOL_VALUE+1];
309
+ DTable_max_t dt; /* Static analyzer seems unable to understand this table will be properly initialized later */
310
+ unsigned tableLog;
311
+ unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
312
+
313
+ if (cSrcSize<2) return ERROR(srcSize_wrong); /* too small input size */
314
+
315
+ /* normal FSE decoding mode */
316
+ { size_t const NCountLength = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
317
+ if (FSE_isError(NCountLength)) return NCountLength;
318
+ if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong); /* too small input size */
319
+ ip += NCountLength;
320
+ cSrcSize -= NCountLength;
321
+ }
322
+
323
+ { size_t const errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);
324
+ if (FSE_isError(errorCode)) return errorCode; }
325
+
326
+ return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt); /* always return, even if it is an error code */
327
+ }
328
+
329
+
330
+
331
+ #endif /* FSE_COMMONDEFS_ONLY */
@@ -0,0 +1,228 @@
1
+ /* ******************************************************************
2
+ Huffman coder, part of New Generation Entropy library
3
+ header file
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
+ #ifndef HUF_H_298734234
35
+ #define HUF_H_298734234
36
+
37
+ #if defined (__cplusplus)
38
+ extern "C" {
39
+ #endif
40
+
41
+
42
+ /* *** Dependencies *** */
43
+ #include <stddef.h> /* size_t */
44
+
45
+
46
+ /* *** simple functions *** */
47
+ /**
48
+ HUF_compress() :
49
+ Compress content from buffer 'src', of size 'srcSize', into buffer 'dst'.
50
+ 'dst' buffer must be already allocated.
51
+ Compression runs faster if `dstCapacity` >= HUF_compressBound(srcSize).
52
+ `srcSize` must be <= `HUF_BLOCKSIZE_MAX` == 128 KB.
53
+ @return : size of compressed data (<= `dstCapacity`).
54
+ Special values : if return == 0, srcData is not compressible => Nothing is stored within dst !!!
55
+ if return == 1, srcData is a single repeated byte symbol (RLE compression).
56
+ if HUF_isError(return), compression failed (more details using HUF_getErrorName())
57
+ */
58
+ size_t HUF_compress(void* dst, size_t dstCapacity,
59
+ const void* src, size_t srcSize);
60
+
61
+ /**
62
+ HUF_decompress() :
63
+ Decompress HUF data from buffer 'cSrc', of size 'cSrcSize',
64
+ into already allocated buffer 'dst', of minimum size 'dstSize'.
65
+ `dstSize` : **must** be the ***exact*** size of original (uncompressed) data.
66
+ Note : in contrast with FSE, HUF_decompress can regenerate
67
+ RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data,
68
+ because it knows size to regenerate.
69
+ @return : size of regenerated data (== dstSize),
70
+ or an error code, which can be tested using HUF_isError()
71
+ */
72
+ size_t HUF_decompress(void* dst, size_t dstSize,
73
+ const void* cSrc, size_t cSrcSize);
74
+
75
+
76
+ /* ****************************************
77
+ * Tool functions
78
+ ******************************************/
79
+ #define HUF_BLOCKSIZE_MAX (128 * 1024)
80
+ size_t HUF_compressBound(size_t size); /**< maximum compressed size (worst case) */
81
+
82
+ /* Error Management */
83
+ unsigned HUF_isError(size_t code); /**< tells if a return value is an error code */
84
+ const char* HUF_getErrorName(size_t code); /**< provides error code string (useful for debugging) */
85
+
86
+
87
+ /* *** Advanced function *** */
88
+
89
+ /** HUF_compress2() :
90
+ * Same as HUF_compress(), but offers direct control over `maxSymbolValue` and `tableLog` */
91
+ size_t HUF_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
92
+
93
+
94
+ #ifdef HUF_STATIC_LINKING_ONLY
95
+
96
+ /* *** Dependencies *** */
97
+ #include "mem.h" /* U32 */
98
+
99
+
100
+ /* *** Constants *** */
101
+ #define HUF_TABLELOG_ABSOLUTEMAX 16 /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */
102
+ #define HUF_TABLELOG_MAX 12 /* max configured tableLog (for static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */
103
+ #define HUF_TABLELOG_DEFAULT HUF_TABLELOG_MAX /* tableLog by default, when not specified */
104
+ #define HUF_SYMBOLVALUE_MAX 255
105
+ #if (HUF_TABLELOG_MAX > HUF_TABLELOG_ABSOLUTEMAX)
106
+ # error "HUF_TABLELOG_MAX is too large !"
107
+ #endif
108
+
109
+
110
+ /* ****************************************
111
+ * Static allocation
112
+ ******************************************/
113
+ /* HUF buffer bounds */
114
+ #define HUF_CTABLEBOUND 129
115
+ #define HUF_BLOCKBOUND(size) (size + (size>>8) + 8) /* only true if incompressible pre-filtered with fast heuristic */
116
+ #define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size)) /* Macro version, useful for static allocation */
117
+
118
+ /* static allocation of HUF's Compression Table */
119
+ #define HUF_CREATE_STATIC_CTABLE(name, maxSymbolValue) \
120
+ U32 name##hb[maxSymbolValue+1]; \
121
+ void* name##hv = &(name##hb); \
122
+ HUF_CElt* name = (HUF_CElt*)(name##hv) /* no final ; */
123
+
124
+ /* static allocation of HUF's DTable */
125
+ typedef U32 HUF_DTable;
126
+ #define HUF_DTABLE_SIZE(maxTableLog) (1 + (1<<(maxTableLog)))
127
+ #define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
128
+ HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1)*0x1000001) }
129
+ #define HUF_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \
130
+ HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog)*0x1000001) }
131
+
132
+
133
+ /* ****************************************
134
+ * Advanced decompression functions
135
+ ******************************************/
136
+ size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */
137
+ size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */
138
+
139
+ size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< decodes RLE and uncompressed */
140
+ size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */
141
+ size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */
142
+ size_t HUF_decompress4X4_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */
143
+
144
+ size_t HUF_decompress1X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
145
+ size_t HUF_decompress1X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */
146
+ size_t HUF_decompress1X4_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */
147
+
148
+
149
+ /* ****************************************
150
+ * HUF detailed API
151
+ ******************************************/
152
+ /*!
153
+ HUF_compress() does the following:
154
+ 1. count symbol occurrence from source[] into table count[] using FSE_count()
155
+ 2. (optional) refine tableLog using HUF_optimalTableLog()
156
+ 3. build Huffman table from count using HUF_buildCTable()
157
+ 4. save Huffman table to memory buffer using HUF_writeCTable()
158
+ 5. encode the data stream using HUF_compress4X_usingCTable()
159
+
160
+ The following API allows targeting specific sub-functions for advanced tasks.
161
+ For example, it's possible to compress several blocks using the same 'CTable',
162
+ or to save and regenerate 'CTable' using external methods.
163
+ */
164
+ /* FSE_count() : find it within "fse.h" */
165
+ unsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue);
166
+ typedef struct HUF_CElt_s HUF_CElt; /* incomplete type */
167
+ size_t HUF_buildCTable (HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue, unsigned maxNbBits);
168
+ size_t HUF_writeCTable (void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog);
169
+ size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
170
+
171
+
172
+ /*! HUF_readStats() :
173
+ Read compact Huffman tree, saved by HUF_writeCTable().
174
+ `huffWeight` is destination buffer.
175
+ @return : size read from `src` , or an error Code .
176
+ Note : Needed by HUF_readCTable() and HUF_readDTableXn() . */
177
+ size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
178
+ U32* nbSymbolsPtr, U32* tableLogPtr,
179
+ const void* src, size_t srcSize);
180
+
181
+ /** HUF_readCTable() :
182
+ * Loading a CTable saved with HUF_writeCTable() */
183
+ size_t HUF_readCTable (HUF_CElt* CTable, unsigned maxSymbolValue, const void* src, size_t srcSize);
184
+
185
+
186
+ /*
187
+ HUF_decompress() does the following:
188
+ 1. select the decompression algorithm (X2, X4) based on pre-computed heuristics
189
+ 2. build Huffman table from save, using HUF_readDTableXn()
190
+ 3. decode 1 or 4 segments in parallel using HUF_decompressSXn_usingDTable
191
+ */
192
+
193
+ /** HUF_selectDecoder() :
194
+ * Tells which decoder is likely to decode faster,
195
+ * based on a set of pre-determined metrics.
196
+ * @return : 0==HUF_decompress4X2, 1==HUF_decompress4X4 .
197
+ * Assumption : 0 < cSrcSize < dstSize <= 128 KB */
198
+ U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize);
199
+
200
+ size_t HUF_readDTableX2 (HUF_DTable* DTable, const void* src, size_t srcSize);
201
+ size_t HUF_readDTableX4 (HUF_DTable* DTable, const void* src, size_t srcSize);
202
+
203
+ size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
204
+ size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
205
+ size_t HUF_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
206
+
207
+
208
+ /* single stream variants */
209
+
210
+ size_t HUF_compress1X (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
211
+ size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
212
+
213
+ size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* single-symbol decoder */
214
+ size_t HUF_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* double-symbol decoder */
215
+
216
+ size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
217
+ size_t HUF_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
218
+ size_t HUF_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
219
+
220
+
221
+ #endif /* HUF_STATIC_LINKING_ONLY */
222
+
223
+
224
+ #if defined (__cplusplus)
225
+ }
226
+ #endif
227
+
228
+ #endif /* HUF_H_298734234 */