ReactOS  0.4.15-dev-5461-g062a8f2
huf_decompress.c
Go to the documentation of this file.
1 /* ******************************************************************
2  * huff0 huffman decoder,
3  * part of Finite State Entropy library
4  * Copyright (c) 2013-2020, Yann Collet, Facebook, Inc.
5  *
6  * You can contact the author at :
7  * - FSE+HUF 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 /* **************************************************************
16 * Dependencies
17 ****************************************************************/
18 #include <string.h> /* memcpy, memset */
19 #include "compiler.h"
20 #include "bitstream.h" /* BIT_* */
21 #include "fse.h" /* to compress headers */
22 #define HUF_STATIC_LINKING_ONLY
23 #include "huf.h"
24 #include "error_private.h"
25 
26 /* **************************************************************
27 * Macros
28 ****************************************************************/
29 
30 /* These two optional macros force the use one way or another of the two
31  * Huffman decompression implementations. You can't force in both directions
32  * at the same time.
33  */
34 #if defined(HUF_FORCE_DECOMPRESS_X1) && \
35  defined(HUF_FORCE_DECOMPRESS_X2)
36 #error "Cannot force the use of the X1 and X2 decoders at the same time!"
37 #endif
38 
39 
40 /* **************************************************************
41 * Error Management
42 ****************************************************************/
43 #define HUF_isError ERR_isError
44 
45 
46 /* **************************************************************
47 * Byte alignment for workSpace management
48 ****************************************************************/
49 #define HUF_ALIGN(x, a) HUF_ALIGN_MASK((x), (a) - 1)
50 #define HUF_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))
51 
52 
53 /* **************************************************************
54 * BMI2 Variant Wrappers
55 ****************************************************************/
56 #if DYNAMIC_BMI2
57 
58 #define HUF_DGEN(fn) \
59  \
60  static size_t fn##_default( \
61  void* dst, size_t dstSize, \
62  const void* cSrc, size_t cSrcSize, \
63  const HUF_DTable* DTable) \
64  { \
65  return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \
66  } \
67  \
68  static TARGET_ATTRIBUTE("bmi2") size_t fn##_bmi2( \
69  void* dst, size_t dstSize, \
70  const void* cSrc, size_t cSrcSize, \
71  const HUF_DTable* DTable) \
72  { \
73  return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \
74  } \
75  \
76  static size_t fn(void* dst, size_t dstSize, void const* cSrc, \
77  size_t cSrcSize, HUF_DTable const* DTable, int bmi2) \
78  { \
79  if (bmi2) { \
80  return fn##_bmi2(dst, dstSize, cSrc, cSrcSize, DTable); \
81  } \
82  return fn##_default(dst, dstSize, cSrc, cSrcSize, DTable); \
83  }
84 
85 #else
86 
87 #define HUF_DGEN(fn) \
88  static size_t fn(void* dst, size_t dstSize, void const* cSrc, \
89  size_t cSrcSize, HUF_DTable const* DTable, int bmi2) \
90  { \
91  (void)bmi2; \
92  return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \
93  }
94 
95 #endif
96 
97 
98 /*-***************************/
99 /* generic DTableDesc */
100 /*-***************************/
101 typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc;
102 
103 static DTableDesc HUF_getDTableDesc(const HUF_DTable* table)
104 {
105  DTableDesc dtd;
106  memcpy(&dtd, table, sizeof(dtd));
107  return dtd;
108 }
109 
110 
111 #ifndef HUF_FORCE_DECOMPRESS_X2
112 
113 /*-***************************/
114 /* single-symbol decoding */
115 /*-***************************/
116 typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX1; /* single-symbol decoding */
117 
118 size_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize)
119 {
120  U32 tableLog = 0;
121  U32 nbSymbols = 0;
122  size_t iSize;
123  void* const dtPtr = DTable + 1;
124  HUF_DEltX1* const dt = (HUF_DEltX1*)dtPtr;
125 
126  U32* rankVal;
127  BYTE* huffWeight;
128  size_t spaceUsed32 = 0;
129 
130  rankVal = (U32 *)workSpace + spaceUsed32;
131  spaceUsed32 += HUF_TABLELOG_ABSOLUTEMAX + 1;
132  huffWeight = (BYTE *)((U32 *)workSpace + spaceUsed32);
133  spaceUsed32 += HUF_ALIGN(HUF_SYMBOLVALUE_MAX + 1, sizeof(U32)) >> 2;
134 
135  if ((spaceUsed32 << 2) > wkspSize) return ERROR(tableLog_tooLarge);
136 
137  DEBUG_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUF_DTable));
138  /* memset(huffWeight, 0, sizeof(huffWeight)); */ /* is not necessary, even though some analyzer complain ... */
139 
140  iSize = HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
141  if (HUF_isError(iSize)) return iSize;
142 
143  /* Table header */
144  { DTableDesc dtd = HUF_getDTableDesc(DTable);
145  if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge); /* DTable too small, Huffman tree cannot fit in */
146  dtd.tableType = 0;
147  dtd.tableLog = (BYTE)tableLog;
148  memcpy(DTable, &dtd, sizeof(dtd));
149  }
150 
151  /* Calculate starting value for each rank */
152  { U32 n, nextRankStart = 0;
153  for (n=1; n<tableLog+1; n++) {
154  U32 const current = nextRankStart;
155  nextRankStart += (rankVal[n] << (n-1));
156  rankVal[n] = current;
157  } }
158 
159  /* fill DTable */
160  { U32 n;
161  size_t const nEnd = nbSymbols;
162  for (n=0; n<nEnd; n++) {
163  size_t const w = huffWeight[n];
164  size_t const length = (1 << w) >> 1;
165  size_t const uStart = rankVal[w];
166  size_t const uEnd = uStart + length;
167  size_t u;
168  HUF_DEltX1 D;
169  D.byte = (BYTE)n;
170  D.nbBits = (BYTE)(tableLog + 1 - w);
171  rankVal[w] = (U32)uEnd;
172  if (length < 4) {
173  /* Use length in the loop bound so the compiler knows it is short. */
174  for (u = 0; u < length; ++u)
175  dt[uStart + u] = D;
176  } else {
177  /* Unroll the loop 4 times, we know it is a power of 2. */
178  for (u = uStart; u < uEnd; u += 4) {
179  dt[u + 0] = D;
180  dt[u + 1] = D;
181  dt[u + 2] = D;
182  dt[u + 3] = D;
183  } } } }
184  return iSize;
185 }
186 
187 size_t HUF_readDTableX1(HUF_DTable* DTable, const void* src, size_t srcSize)
188 {
189  U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
190  return HUF_readDTableX1_wksp(DTable, src, srcSize,
191  workSpace, sizeof(workSpace));
192 }
193 
195 HUF_decodeSymbolX1(BIT_DStream_t* Dstream, const HUF_DEltX1* dt, const U32 dtLog)
196 {
197  size_t const val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
198  BYTE const c = dt[val].byte;
199  BIT_skipBits(Dstream, dt[val].nbBits);
200  return c;
201 }
202 
203 #define HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr) \
204  *ptr++ = HUF_decodeSymbolX1(DStreamPtr, dt, dtLog)
205 
206 #define HUF_DECODE_SYMBOLX1_1(ptr, DStreamPtr) \
207  if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \
208  HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)
209 
210 #define HUF_DECODE_SYMBOLX1_2(ptr, DStreamPtr) \
211  if (MEM_64bits()) \
212  HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)
213 
214 HINT_INLINE size_t
215 HUF_decodeStreamX1(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX1* const dt, const U32 dtLog)
216 {
217  BYTE* const pStart = p;
218 
219  /* up to 4 symbols at a time */
220  while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-3)) {
221  HUF_DECODE_SYMBOLX1_2(p, bitDPtr);
222  HUF_DECODE_SYMBOLX1_1(p, bitDPtr);
223  HUF_DECODE_SYMBOLX1_2(p, bitDPtr);
224  HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
225  }
226 
227  /* [0-3] symbols remaining */
228  if (MEM_32bits())
229  while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd))
230  HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
231 
232  /* no more data to retrieve from bitstream, no need to reload */
233  while (p < pEnd)
234  HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
235 
236  return pEnd-pStart;
237 }
238 
241  void* dst, size_t dstSize,
242  const void* cSrc, size_t cSrcSize,
243  const HUF_DTable* DTable)
244 {
245  BYTE* op = (BYTE*)dst;
246  BYTE* const oend = op + dstSize;
247  const void* dtPtr = DTable + 1;
248  const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
249  BIT_DStream_t bitD;
250  DTableDesc const dtd = HUF_getDTableDesc(DTable);
251  U32 const dtLog = dtd.tableLog;
252 
253  CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );
254 
255  HUF_decodeStreamX1(op, &bitD, oend, dt, dtLog);
256 
257  if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
258 
259  return dstSize;
260 }
261 
264  void* dst, size_t dstSize,
265  const void* cSrc, size_t cSrcSize,
266  const HUF_DTable* DTable)
267 {
268  /* Check */
269  if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */
270 
271  { const BYTE* const istart = (const BYTE*) cSrc;
272  BYTE* const ostart = (BYTE*) dst;
273  BYTE* const oend = ostart + dstSize;
274  BYTE* const olimit = oend - 3;
275  const void* const dtPtr = DTable + 1;
276  const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
277 
278  /* Init */
279  BIT_DStream_t bitD1;
280  BIT_DStream_t bitD2;
281  BIT_DStream_t bitD3;
282  BIT_DStream_t bitD4;
283  size_t const length1 = MEM_readLE16(istart);
284  size_t const length2 = MEM_readLE16(istart+2);
285  size_t const length3 = MEM_readLE16(istart+4);
286  size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
287  const BYTE* const istart1 = istart + 6; /* jumpTable */
288  const BYTE* const istart2 = istart1 + length1;
289  const BYTE* const istart3 = istart2 + length2;
290  const BYTE* const istart4 = istart3 + length3;
291  const size_t segmentSize = (dstSize+3) / 4;
292  BYTE* const opStart2 = ostart + segmentSize;
293  BYTE* const opStart3 = opStart2 + segmentSize;
294  BYTE* const opStart4 = opStart3 + segmentSize;
295  BYTE* op1 = ostart;
296  BYTE* op2 = opStart2;
297  BYTE* op3 = opStart3;
298  BYTE* op4 = opStart4;
299  DTableDesc const dtd = HUF_getDTableDesc(DTable);
300  U32 const dtLog = dtd.tableLog;
301  U32 endSignal = 1;
302 
303  if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */
304  CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
305  CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
306  CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
307  CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );
308 
309  /* up to 16 symbols per loop (4 symbols per stream) in 64-bit mode */
310  for ( ; (endSignal) & (op4 < olimit) ; ) {
311  HUF_DECODE_SYMBOLX1_2(op1, &bitD1);
312  HUF_DECODE_SYMBOLX1_2(op2, &bitD2);
313  HUF_DECODE_SYMBOLX1_2(op3, &bitD3);
314  HUF_DECODE_SYMBOLX1_2(op4, &bitD4);
315  HUF_DECODE_SYMBOLX1_1(op1, &bitD1);
316  HUF_DECODE_SYMBOLX1_1(op2, &bitD2);
317  HUF_DECODE_SYMBOLX1_1(op3, &bitD3);
318  HUF_DECODE_SYMBOLX1_1(op4, &bitD4);
319  HUF_DECODE_SYMBOLX1_2(op1, &bitD1);
320  HUF_DECODE_SYMBOLX1_2(op2, &bitD2);
321  HUF_DECODE_SYMBOLX1_2(op3, &bitD3);
322  HUF_DECODE_SYMBOLX1_2(op4, &bitD4);
323  HUF_DECODE_SYMBOLX1_0(op1, &bitD1);
324  HUF_DECODE_SYMBOLX1_0(op2, &bitD2);
325  HUF_DECODE_SYMBOLX1_0(op3, &bitD3);
326  HUF_DECODE_SYMBOLX1_0(op4, &bitD4);
327  endSignal &= BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished;
328  endSignal &= BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished;
329  endSignal &= BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished;
330  endSignal &= BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished;
331  }
332 
333  /* check corruption */
334  /* note : should not be necessary : op# advance in lock step, and we control op4.
335  * but curiously, binary generated by gcc 7.2 & 7.3 with -mbmi2 runs faster when >=1 test is present */
336  if (op1 > opStart2) return ERROR(corruption_detected);
337  if (op2 > opStart3) return ERROR(corruption_detected);
338  if (op3 > opStart4) return ERROR(corruption_detected);
339  /* note : op4 supposed already verified within main loop */
340 
341  /* finish bitStreams one by one */
342  HUF_decodeStreamX1(op1, &bitD1, opStart2, dt, dtLog);
343  HUF_decodeStreamX1(op2, &bitD2, opStart3, dt, dtLog);
344  HUF_decodeStreamX1(op3, &bitD3, opStart4, dt, dtLog);
345  HUF_decodeStreamX1(op4, &bitD4, oend, dt, dtLog);
346 
347  /* check */
348  { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
349  if (!endCheck) return ERROR(corruption_detected); }
350 
351  /* decoded size */
352  return dstSize;
353  }
354 }
355 
356 
357 typedef size_t (*HUF_decompress_usingDTable_t)(void *dst, size_t dstSize,
358  const void *cSrc,
359  size_t cSrcSize,
360  const HUF_DTable *DTable);
361 
362 HUF_DGEN(HUF_decompress1X1_usingDTable_internal)
363 HUF_DGEN(HUF_decompress4X1_usingDTable_internal)
364 
365 
366 
368  void* dst, size_t dstSize,
369  const void* cSrc, size_t cSrcSize,
370  const HUF_DTable* DTable)
371 {
372  DTableDesc dtd = HUF_getDTableDesc(DTable);
373  if (dtd.tableType != 0) return ERROR(GENERIC);
374  return HUF_decompress1X1_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
375 }
376 
377 size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
378  const void* cSrc, size_t cSrcSize,
379  void* workSpace, size_t wkspSize)
380 {
381  const BYTE* ip = (const BYTE*) cSrc;
382 
383  size_t const hSize = HUF_readDTableX1_wksp(DCtx, cSrc, cSrcSize, workSpace, wkspSize);
384  if (HUF_isError(hSize)) return hSize;
385  if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
386  ip += hSize; cSrcSize -= hSize;
387 
388  return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
389 }
390 
391 
392 size_t HUF_decompress1X1_DCtx(HUF_DTable* DCtx, void* dst, size_t dstSize,
393  const void* cSrc, size_t cSrcSize)
394 {
395  U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
396  return HUF_decompress1X1_DCtx_wksp(DCtx, dst, dstSize, cSrc, cSrcSize,
397  workSpace, sizeof(workSpace));
398 }
399 
400 size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
401 {
402  HUF_CREATE_STATIC_DTABLEX1(DTable, HUF_TABLELOG_MAX);
403  return HUF_decompress1X1_DCtx (DTable, dst, dstSize, cSrc, cSrcSize);
404 }
405 
407  void* dst, size_t dstSize,
408  const void* cSrc, size_t cSrcSize,
409  const HUF_DTable* DTable)
410 {
411  DTableDesc dtd = HUF_getDTableDesc(DTable);
412  if (dtd.tableType != 0) return ERROR(GENERIC);
413  return HUF_decompress4X1_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
414 }
415 
416 static size_t HUF_decompress4X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
417  const void* cSrc, size_t cSrcSize,
418  void* workSpace, size_t wkspSize, int bmi2)
419 {
420  const BYTE* ip = (const BYTE*) cSrc;
421 
422  size_t const hSize = HUF_readDTableX1_wksp (dctx, cSrc, cSrcSize,
423  workSpace, wkspSize);
424  if (HUF_isError(hSize)) return hSize;
425  if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
426  ip += hSize; cSrcSize -= hSize;
427 
428  return HUF_decompress4X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
429 }
430 
431 size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
432  const void* cSrc, size_t cSrcSize,
433  void* workSpace, size_t wkspSize)
434 {
435  return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, 0);
436 }
437 
438 
439 size_t HUF_decompress4X1_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
440 {
441  U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
442  return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
443  workSpace, sizeof(workSpace));
444 }
445 size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
446 {
447  HUF_CREATE_STATIC_DTABLEX1(DTable, HUF_TABLELOG_MAX);
448  return HUF_decompress4X1_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
449 }
450 
451 #endif /* HUF_FORCE_DECOMPRESS_X2 */
452 
453 
454 #ifndef HUF_FORCE_DECOMPRESS_X1
455 
456 /* *************************/
457 /* double-symbols decoding */
458 /* *************************/
459 
460 typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX2; /* double-symbols decoding */
461 typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
462 typedef U32 rankValCol_t[HUF_TABLELOG_MAX + 1];
463 typedef rankValCol_t rankVal_t[HUF_TABLELOG_MAX];
464 
465 
466 /* HUF_fillDTableX2Level2() :
467  * `rankValOrigin` must be a table of at least (HUF_TABLELOG_MAX + 1) U32 */
468 static void HUF_fillDTableX2Level2(HUF_DEltX2* DTable, U32 sizeLog, const U32 consumed,
469  const U32* rankValOrigin, const int minWeight,
470  const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
471  U32 nbBitsBaseline, U16 baseSeq)
472 {
473  HUF_DEltX2 DElt;
474  U32 rankVal[HUF_TABLELOG_MAX + 1];
475 
476  /* get pre-calculated rankVal */
477  memcpy(rankVal, rankValOrigin, sizeof(rankVal));
478 
479  /* fill skipped values */
480  if (minWeight>1) {
481  U32 i, skipSize = rankVal[minWeight];
482  MEM_writeLE16(&(DElt.sequence), baseSeq);
483  DElt.nbBits = (BYTE)(consumed);
484  DElt.length = 1;
485  for (i = 0; i < skipSize; i++)
486  DTable[i] = DElt;
487  }
488 
489  /* fill DTable */
490  { U32 s; for (s=0; s<sortedListSize; s++) { /* note : sortedSymbols already skipped */
491  const U32 symbol = sortedSymbols[s].symbol;
492  const U32 weight = sortedSymbols[s].weight;
493  const U32 nbBits = nbBitsBaseline - weight;
494  const U32 length = 1 << (sizeLog-nbBits);
495  const U32 start = rankVal[weight];
496  U32 i = start;
497  const U32 end = start + length;
498 
499  MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
500  DElt.nbBits = (BYTE)(nbBits + consumed);
501  DElt.length = 2;
502  do { DTable[i++] = DElt; } while (i<end); /* since length >= 1 */
503 
504  rankVal[weight] += length;
505  } }
506 }
507 
508 
509 static void HUF_fillDTableX2(HUF_DEltX2* DTable, const U32 targetLog,
510  const sortedSymbol_t* sortedList, const U32 sortedListSize,
511  const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
512  const U32 nbBitsBaseline)
513 {
514  U32 rankVal[HUF_TABLELOG_MAX + 1];
515  const int scaleLog = nbBitsBaseline - targetLog; /* note : targetLog >= srcLog, hence scaleLog <= 1 */
516  const U32 minBits = nbBitsBaseline - maxWeight;
517  U32 s;
518 
519  memcpy(rankVal, rankValOrigin, sizeof(rankVal));
520 
521  /* fill DTable */
522  for (s=0; s<sortedListSize; s++) {
523  const U16 symbol = sortedList[s].symbol;
524  const U32 weight = sortedList[s].weight;
525  const U32 nbBits = nbBitsBaseline - weight;
526  const U32 start = rankVal[weight];
527  const U32 length = 1 << (targetLog-nbBits);
528 
529  if (targetLog-nbBits >= minBits) { /* enough room for a second symbol */
530  U32 sortedRank;
531  int minWeight = nbBits + scaleLog;
532  if (minWeight < 1) minWeight = 1;
533  sortedRank = rankStart[minWeight];
534  HUF_fillDTableX2Level2(DTable+start, targetLog-nbBits, nbBits,
535  rankValOrigin[nbBits], minWeight,
536  sortedList+sortedRank, sortedListSize-sortedRank,
537  nbBitsBaseline, symbol);
538  } else {
539  HUF_DEltX2 DElt;
540  MEM_writeLE16(&(DElt.sequence), symbol);
541  DElt.nbBits = (BYTE)(nbBits);
542  DElt.length = 1;
543  { U32 const end = start + length;
544  U32 u;
545  for (u = start; u < end; u++) DTable[u] = DElt;
546  } }
547  rankVal[weight] += length;
548  }
549 }
550 
551 size_t HUF_readDTableX2_wksp(HUF_DTable* DTable,
552  const void* src, size_t srcSize,
553  void* workSpace, size_t wkspSize)
554 {
555  U32 tableLog, maxW, sizeOfSort, nbSymbols;
556  DTableDesc dtd = HUF_getDTableDesc(DTable);
557  U32 const maxTableLog = dtd.maxTableLog;
558  size_t iSize;
559  void* dtPtr = DTable+1; /* force compiler to avoid strict-aliasing */
560  HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr;
561  U32 *rankStart;
562 
563  rankValCol_t* rankVal;
564  U32* rankStats;
565  U32* rankStart0;
566  sortedSymbol_t* sortedSymbol;
567  BYTE* weightList;
568  size_t spaceUsed32 = 0;
569 
570  rankVal = (rankValCol_t *)((U32 *)workSpace + spaceUsed32);
571  spaceUsed32 += (sizeof(rankValCol_t) * HUF_TABLELOG_MAX) >> 2;
572  rankStats = (U32 *)workSpace + spaceUsed32;
573  spaceUsed32 += HUF_TABLELOG_MAX + 1;
574  rankStart0 = (U32 *)workSpace + spaceUsed32;
575  spaceUsed32 += HUF_TABLELOG_MAX + 2;
576  sortedSymbol = (sortedSymbol_t *)workSpace + (spaceUsed32 * sizeof(U32)) / sizeof(sortedSymbol_t);
577  spaceUsed32 += HUF_ALIGN(sizeof(sortedSymbol_t) * (HUF_SYMBOLVALUE_MAX + 1), sizeof(U32)) >> 2;
578  weightList = (BYTE *)((U32 *)workSpace + spaceUsed32);
579  spaceUsed32 += HUF_ALIGN(HUF_SYMBOLVALUE_MAX + 1, sizeof(U32)) >> 2;
580 
581  if ((spaceUsed32 << 2) > wkspSize) return ERROR(tableLog_tooLarge);
582 
583  rankStart = rankStart0 + 1;
584  memset(rankStats, 0, sizeof(U32) * (2 * HUF_TABLELOG_MAX + 2 + 1));
585 
586  DEBUG_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(HUF_DTable)); /* if compiler fails here, assertion is wrong */
587  if (maxTableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
588  /* memset(weightList, 0, sizeof(weightList)); */ /* is not necessary, even though some analyzer complain ... */
589 
590  iSize = HUF_readStats(weightList, HUF_SYMBOLVALUE_MAX + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
591  if (HUF_isError(iSize)) return iSize;
592 
593  /* check result */
594  if (tableLog > maxTableLog) return ERROR(tableLog_tooLarge); /* DTable can't fit code depth */
595 
596  /* find maxWeight */
597  for (maxW = tableLog; rankStats[maxW]==0; maxW--) {} /* necessarily finds a solution before 0 */
598 
599  /* Get start index of each weight */
600  { U32 w, nextRankStart = 0;
601  for (w=1; w<maxW+1; w++) {
602  U32 current = nextRankStart;
603  nextRankStart += rankStats[w];
604  rankStart[w] = current;
605  }
606  rankStart[0] = nextRankStart; /* put all 0w symbols at the end of sorted list*/
607  sizeOfSort = nextRankStart;
608  }
609 
610  /* sort symbols by weight */
611  { U32 s;
612  for (s=0; s<nbSymbols; s++) {
613  U32 const w = weightList[s];
614  U32 const r = rankStart[w]++;
615  sortedSymbol[r].symbol = (BYTE)s;
616  sortedSymbol[r].weight = (BYTE)w;
617  }
618  rankStart[0] = 0; /* forget 0w symbols; this is beginning of weight(1) */
619  }
620 
621  /* Build rankVal */
622  { U32* const rankVal0 = rankVal[0];
623  { int const rescale = (maxTableLog-tableLog) - 1; /* tableLog <= maxTableLog */
624  U32 nextRankVal = 0;
625  U32 w;
626  for (w=1; w<maxW+1; w++) {
627  U32 current = nextRankVal;
628  nextRankVal += rankStats[w] << (w+rescale);
629  rankVal0[w] = current;
630  } }
631  { U32 const minBits = tableLog+1 - maxW;
632  U32 consumed;
633  for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) {
634  U32* const rankValPtr = rankVal[consumed];
635  U32 w;
636  for (w = 1; w < maxW+1; w++) {
637  rankValPtr[w] = rankVal0[w] >> consumed;
638  } } } }
639 
640  HUF_fillDTableX2(dt, maxTableLog,
641  sortedSymbol, sizeOfSort,
642  rankStart0, rankVal, maxW,
643  tableLog+1);
644 
645  dtd.tableLog = (BYTE)maxTableLog;
646  dtd.tableType = 1;
647  memcpy(DTable, &dtd, sizeof(dtd));
648  return iSize;
649 }
650 
651 size_t HUF_readDTableX2(HUF_DTable* DTable, const void* src, size_t srcSize)
652 {
653  U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
654  return HUF_readDTableX2_wksp(DTable, src, srcSize,
655  workSpace, sizeof(workSpace));
656 }
657 
658 
660 HUF_decodeSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
661 {
662  size_t const val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */
663  memcpy(op, dt+val, 2);
664  BIT_skipBits(DStream, dt[val].nbBits);
665  return dt[val].length;
666 }
667 
669 HUF_decodeLastSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
670 {
671  size_t const val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */
672  memcpy(op, dt+val, 1);
673  if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);
674  else {
675  if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {
676  BIT_skipBits(DStream, dt[val].nbBits);
677  if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
678  /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
679  DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);
680  } }
681  return 1;
682 }
683 
684 #define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
685  ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
686 
687 #define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
688  if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \
689  ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
690 
691 #define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
692  if (MEM_64bits()) \
693  ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
694 
695 HINT_INLINE size_t
696 HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd,
697  const HUF_DEltX2* const dt, const U32 dtLog)
698 {
699  BYTE* const pStart = p;
700 
701  /* up to 8 symbols at a time */
702  while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-(sizeof(bitDPtr->bitContainer)-1))) {
703  HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
704  HUF_DECODE_SYMBOLX2_1(p, bitDPtr);
705  HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
706  HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
707  }
708 
709  /* closer to end : up to 2 symbols at a time */
710  while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p <= pEnd-2))
711  HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
712 
713  while (p <= pEnd-2)
714  HUF_DECODE_SYMBOLX2_0(p, bitDPtr); /* no need to reload : reached the end of DStream */
715 
716  if (p < pEnd)
717  p += HUF_decodeLastSymbolX2(p, bitDPtr, dt, dtLog);
718 
719  return p-pStart;
720 }
721 
724  void* dst, size_t dstSize,
725  const void* cSrc, size_t cSrcSize,
726  const HUF_DTable* DTable)
727 {
728  BIT_DStream_t bitD;
729 
730  /* Init */
731  CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );
732 
733  /* decode */
734  { BYTE* const ostart = (BYTE*) dst;
735  BYTE* const oend = ostart + dstSize;
736  const void* const dtPtr = DTable+1; /* force compiler to not use strict-aliasing */
737  const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;
738  DTableDesc const dtd = HUF_getDTableDesc(DTable);
739  HUF_decodeStreamX2(ostart, &bitD, oend, dt, dtd.tableLog);
740  }
741 
742  /* check */
743  if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
744 
745  /* decoded size */
746  return dstSize;
747 }
748 
751  void* dst, size_t dstSize,
752  const void* cSrc, size_t cSrcSize,
753  const HUF_DTable* DTable)
754 {
755  if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */
756 
757  { const BYTE* const istart = (const BYTE*) cSrc;
758  BYTE* const ostart = (BYTE*) dst;
759  BYTE* const oend = ostart + dstSize;
760  BYTE* const olimit = oend - (sizeof(size_t)-1);
761  const void* const dtPtr = DTable+1;
762  const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;
763 
764  /* Init */
765  BIT_DStream_t bitD1;
766  BIT_DStream_t bitD2;
767  BIT_DStream_t bitD3;
768  BIT_DStream_t bitD4;
769  size_t const length1 = MEM_readLE16(istart);
770  size_t const length2 = MEM_readLE16(istart+2);
771  size_t const length3 = MEM_readLE16(istart+4);
772  size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
773  const BYTE* const istart1 = istart + 6; /* jumpTable */
774  const BYTE* const istart2 = istart1 + length1;
775  const BYTE* const istart3 = istart2 + length2;
776  const BYTE* const istart4 = istart3 + length3;
777  size_t const segmentSize = (dstSize+3) / 4;
778  BYTE* const opStart2 = ostart + segmentSize;
779  BYTE* const opStart3 = opStart2 + segmentSize;
780  BYTE* const opStart4 = opStart3 + segmentSize;
781  BYTE* op1 = ostart;
782  BYTE* op2 = opStart2;
783  BYTE* op3 = opStart3;
784  BYTE* op4 = opStart4;
785  U32 endSignal = 1;
786  DTableDesc const dtd = HUF_getDTableDesc(DTable);
787  U32 const dtLog = dtd.tableLog;
788 
789  if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */
790  CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
791  CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
792  CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
793  CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );
794 
795  /* 16-32 symbols per loop (4-8 symbols per stream) */
796  for ( ; (endSignal) & (op4 < olimit); ) {
797 #if defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
798  HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
799  HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
800  HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
801  HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
802  HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
803  HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
804  HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
805  HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
806  endSignal &= BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished;
807  endSignal &= BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished;
808  HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
809  HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
810  HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
811  HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
812  HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
813  HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
814  HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
815  HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
816  endSignal &= BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished;
817  endSignal &= BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished;
818 #else
819  HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
820  HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
821  HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
822  HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
823  HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
824  HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
825  HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
826  HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
827  HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
828  HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
829  HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
830  HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
831  HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
832  HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
833  HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
834  HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
835  endSignal = (U32)LIKELY(
840 #endif
841  }
842 
843  /* check corruption */
844  if (op1 > opStart2) return ERROR(corruption_detected);
845  if (op2 > opStart3) return ERROR(corruption_detected);
846  if (op3 > opStart4) return ERROR(corruption_detected);
847  /* note : op4 already verified within main loop */
848 
849  /* finish bitStreams one by one */
850  HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
851  HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
852  HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
853  HUF_decodeStreamX2(op4, &bitD4, oend, dt, dtLog);
854 
855  /* check */
856  { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
857  if (!endCheck) return ERROR(corruption_detected); }
858 
859  /* decoded size */
860  return dstSize;
861  }
862 }
863 
864 HUF_DGEN(HUF_decompress1X2_usingDTable_internal)
865 HUF_DGEN(HUF_decompress4X2_usingDTable_internal)
866 
868  void* dst, size_t dstSize,
869  const void* cSrc, size_t cSrcSize,
870  const HUF_DTable* DTable)
871 {
872  DTableDesc dtd = HUF_getDTableDesc(DTable);
873  if (dtd.tableType != 1) return ERROR(GENERIC);
874  return HUF_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
875 }
876 
877 size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
878  const void* cSrc, size_t cSrcSize,
879  void* workSpace, size_t wkspSize)
880 {
881  const BYTE* ip = (const BYTE*) cSrc;
882 
883  size_t const hSize = HUF_readDTableX2_wksp(DCtx, cSrc, cSrcSize,
884  workSpace, wkspSize);
885  if (HUF_isError(hSize)) return hSize;
886  if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
887  ip += hSize; cSrcSize -= hSize;
888 
889  return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
890 }
891 
892 
893 size_t HUF_decompress1X2_DCtx(HUF_DTable* DCtx, void* dst, size_t dstSize,
894  const void* cSrc, size_t cSrcSize)
895 {
896  U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
897  return HUF_decompress1X2_DCtx_wksp(DCtx, dst, dstSize, cSrc, cSrcSize,
898  workSpace, sizeof(workSpace));
899 }
900 
901 size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
902 {
903  HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX);
904  return HUF_decompress1X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
905 }
906 
908  void* dst, size_t dstSize,
909  const void* cSrc, size_t cSrcSize,
910  const HUF_DTable* DTable)
911 {
912  DTableDesc dtd = HUF_getDTableDesc(DTable);
913  if (dtd.tableType != 1) return ERROR(GENERIC);
914  return HUF_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
915 }
916 
917 static size_t HUF_decompress4X2_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
918  const void* cSrc, size_t cSrcSize,
919  void* workSpace, size_t wkspSize, int bmi2)
920 {
921  const BYTE* ip = (const BYTE*) cSrc;
922 
923  size_t hSize = HUF_readDTableX2_wksp(dctx, cSrc, cSrcSize,
924  workSpace, wkspSize);
925  if (HUF_isError(hSize)) return hSize;
926  if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
927  ip += hSize; cSrcSize -= hSize;
928 
929  return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
930 }
931 
932 size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
933  const void* cSrc, size_t cSrcSize,
934  void* workSpace, size_t wkspSize)
935 {
936  return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, /* bmi2 */ 0);
937 }
938 
939 
940 size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize,
941  const void* cSrc, size_t cSrcSize)
942 {
943  U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
944  return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
945  workSpace, sizeof(workSpace));
946 }
947 
948 size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
949 {
950  HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX);
951  return HUF_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
952 }
953 
954 #endif /* HUF_FORCE_DECOMPRESS_X1 */
955 
956 
957 /* ***********************************/
958 /* Universal decompression selectors */
959 /* ***********************************/
960 
961 size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize,
962  const void* cSrc, size_t cSrcSize,
963  const HUF_DTable* DTable)
964 {
965  DTableDesc const dtd = HUF_getDTableDesc(DTable);
966 #if defined(HUF_FORCE_DECOMPRESS_X1)
967  (void)dtd;
968  assert(dtd.tableType == 0);
969  return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
970 #elif defined(HUF_FORCE_DECOMPRESS_X2)
971  (void)dtd;
972  assert(dtd.tableType == 1);
973  return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
974 #else
975  return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
976  HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
977 #endif
978 }
979 
980 size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize,
981  const void* cSrc, size_t cSrcSize,
982  const HUF_DTable* DTable)
983 {
984  DTableDesc const dtd = HUF_getDTableDesc(DTable);
985 #if defined(HUF_FORCE_DECOMPRESS_X1)
986  (void)dtd;
987  assert(dtd.tableType == 0);
988  return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
989 #elif defined(HUF_FORCE_DECOMPRESS_X2)
990  (void)dtd;
991  assert(dtd.tableType == 1);
992  return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
993 #else
994  return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
995  HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
996 #endif
997 }
998 
999 
1000 #if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
1001 typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
1002 static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
1003 {
1004  /* single, double, quad */
1005  {{0,0}, {1,1}, {2,2}}, /* Q==0 : impossible */
1006  {{0,0}, {1,1}, {2,2}}, /* Q==1 : impossible */
1007  {{ 38,130}, {1313, 74}, {2151, 38}}, /* Q == 2 : 12-18% */
1008  {{ 448,128}, {1353, 74}, {2238, 41}}, /* Q == 3 : 18-25% */
1009  {{ 556,128}, {1353, 74}, {2238, 47}}, /* Q == 4 : 25-32% */
1010  {{ 714,128}, {1418, 74}, {2436, 53}}, /* Q == 5 : 32-38% */
1011  {{ 883,128}, {1437, 74}, {2464, 61}}, /* Q == 6 : 38-44% */
1012  {{ 897,128}, {1515, 75}, {2622, 68}}, /* Q == 7 : 44-50% */
1013  {{ 926,128}, {1613, 75}, {2730, 75}}, /* Q == 8 : 50-56% */
1014  {{ 947,128}, {1729, 77}, {3359, 77}}, /* Q == 9 : 56-62% */
1015  {{1107,128}, {2083, 81}, {4006, 84}}, /* Q ==10 : 62-69% */
1016  {{1177,128}, {2379, 87}, {4785, 88}}, /* Q ==11 : 69-75% */
1017  {{1242,128}, {2415, 93}, {5155, 84}}, /* Q ==12 : 75-81% */
1018  {{1349,128}, {2644,106}, {5260,106}}, /* Q ==13 : 81-87% */
1019  {{1455,128}, {2422,124}, {4174,124}}, /* Q ==14 : 87-93% */
1020  {{ 722,128}, {1891,145}, {1936,146}}, /* Q ==15 : 93-99% */
1021 };
1022 #endif
1023 
1029 U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
1030 {
1031  assert(dstSize > 0);
1032  assert(dstSize <= 128*1024);
1033 #if defined(HUF_FORCE_DECOMPRESS_X1)
1034  (void)dstSize;
1035  (void)cSrcSize;
1036  return 0;
1037 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1038  (void)dstSize;
1039  (void)cSrcSize;
1040  return 1;
1041 #else
1042  /* decoder timing evaluation */
1043  { U32 const Q = (cSrcSize >= dstSize) ? 15 : (U32)(cSrcSize * 16 / dstSize); /* Q < 16 */
1044  U32 const D256 = (U32)(dstSize >> 8);
1045  U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);
1046  U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);
1047  DTime1 += DTime1 >> 3; /* advantage to algorithm using less memory, to reduce cache eviction */
1048  return DTime1 < DTime0;
1049  }
1050 #endif
1051 }
1052 
1053 
1054 typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
1055 
1056 size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
1057 {
1058 #if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
1059  static const decompressionAlgo decompress[2] = { HUF_decompress4X1, HUF_decompress4X2 };
1060 #endif
1061 
1062  /* validation checks */
1063  if (dstSize == 0) return ERROR(dstSize_tooSmall);
1064  if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */
1065  if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */
1066  if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */
1067 
1068  { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
1069 #if defined(HUF_FORCE_DECOMPRESS_X1)
1070  (void)algoNb;
1071  assert(algoNb == 0);
1072  return HUF_decompress4X1(dst, dstSize, cSrc, cSrcSize);
1073 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1074  (void)algoNb;
1075  assert(algoNb == 1);
1076  return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);
1077 #else
1078  return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
1079 #endif
1080  }
1081 }
1082 
1083 size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
1084 {
1085  /* validation checks */
1086  if (dstSize == 0) return ERROR(dstSize_tooSmall);
1087  if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */
1088  if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */
1089  if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */
1090 
1091  { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
1092 #if defined(HUF_FORCE_DECOMPRESS_X1)
1093  (void)algoNb;
1094  assert(algoNb == 0);
1095  return HUF_decompress4X1_DCtx(dctx, dst, dstSize, cSrc, cSrcSize);
1096 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1097  (void)algoNb;
1098  assert(algoNb == 1);
1099  return HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize);
1100 #else
1101  return algoNb ? HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
1102  HUF_decompress4X1_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
1103 #endif
1104  }
1105 }
1106 
1107 size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
1108 {
1109  U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
1110  return HUF_decompress4X_hufOnly_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
1111  workSpace, sizeof(workSpace));
1112 }
1113 
1114 
1115 size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst,
1116  size_t dstSize, const void* cSrc,
1117  size_t cSrcSize, void* workSpace,
1118  size_t wkspSize)
1119 {
1120  /* validation checks */
1121  if (dstSize == 0) return ERROR(dstSize_tooSmall);
1122  if (cSrcSize == 0) return ERROR(corruption_detected);
1123 
1124  { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
1125 #if defined(HUF_FORCE_DECOMPRESS_X1)
1126  (void)algoNb;
1127  assert(algoNb == 0);
1128  return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
1129 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1130  (void)algoNb;
1131  assert(algoNb == 1);
1132  return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
1133 #else
1134  return algoNb ? HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
1135  cSrcSize, workSpace, wkspSize):
1136  HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
1137 #endif
1138  }
1139 }
1140 
1141 size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
1142  const void* cSrc, size_t cSrcSize,
1143  void* workSpace, size_t wkspSize)
1144 {
1145  /* validation checks */
1146  if (dstSize == 0) return ERROR(dstSize_tooSmall);
1147  if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */
1148  if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */
1149  if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */
1150 
1151  { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
1152 #if defined(HUF_FORCE_DECOMPRESS_X1)
1153  (void)algoNb;
1154  assert(algoNb == 0);
1155  return HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
1156  cSrcSize, workSpace, wkspSize);
1157 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1158  (void)algoNb;
1159  assert(algoNb == 1);
1160  return HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
1161  cSrcSize, workSpace, wkspSize);
1162 #else
1163  return algoNb ? HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
1164  cSrcSize, workSpace, wkspSize):
1165  HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
1166  cSrcSize, workSpace, wkspSize);
1167 #endif
1168  }
1169 }
1170 
1171 size_t HUF_decompress1X_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize,
1172  const void* cSrc, size_t cSrcSize)
1173 {
1174  U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
1175  return HUF_decompress1X_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
1176  workSpace, sizeof(workSpace));
1177 }
1178 
1179 
1180 size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
1181 {
1182  DTableDesc const dtd = HUF_getDTableDesc(DTable);
1183 #if defined(HUF_FORCE_DECOMPRESS_X1)
1184  (void)dtd;
1185  assert(dtd.tableType == 0);
1186  return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
1187 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1188  (void)dtd;
1189  assert(dtd.tableType == 1);
1190  return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
1191 #else
1192  return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
1193  HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
1194 #endif
1195 }
1196 
1197 #ifndef HUF_FORCE_DECOMPRESS_X2
1198 size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
1199 {
1200  const BYTE* ip = (const BYTE*) cSrc;
1201 
1202  size_t const hSize = HUF_readDTableX1_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize);
1203  if (HUF_isError(hSize)) return hSize;
1204  if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
1205  ip += hSize; cSrcSize -= hSize;
1206 
1207  return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
1208 }
1209 #endif
1210 
1211 size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
1212 {
1213  DTableDesc const dtd = HUF_getDTableDesc(DTable);
1214 #if defined(HUF_FORCE_DECOMPRESS_X1)
1215  (void)dtd;
1216  assert(dtd.tableType == 0);
1217  return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
1218 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1219  (void)dtd;
1220  assert(dtd.tableType == 1);
1221  return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
1222 #else
1223  return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
1224  HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
1225 #endif
1226 }
1227 
1228 size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
1229 {
1230  /* validation checks */
1231  if (dstSize == 0) return ERROR(dstSize_tooSmall);
1232  if (cSrcSize == 0) return ERROR(corruption_detected);
1233 
1234  { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
1235 #if defined(HUF_FORCE_DECOMPRESS_X1)
1236  (void)algoNb;
1237  assert(algoNb == 0);
1238  return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
1239 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1240  (void)algoNb;
1241  assert(algoNb == 1);
1242  return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
1243 #else
1244  return algoNb ? HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2) :
1245  HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
1246 #endif
1247  }
1248 }
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
size_t HUF_decompress(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t HUF_decompress1X_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t HUF_decompress4X2(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
MEM_STATIC void MEM_writeLE16(void *memPtr, U16 val)
Definition: mem.h:324
size_t HUF_decompress1X_usingDTable(void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
FORCE_INLINE_TEMPLATE size_t HUF_decompress1X2_usingDTable_internal_body(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
size_t HUF_decompress4X_usingDTable(void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
#define CHECK_F(f)
Definition: error_private.h:62
size_t HUF_readDTableX2_wksp(HUF_DTable *DTable, const void *src, size_t srcSize, void *workSpace, size_t wkspSize)
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
FORCE_INLINE_TEMPLATE U32 HUF_decodeSymbolX2(void *op, BIT_DStream_t *DStream, const HUF_DEltX2 *dt, const U32 dtLog)
#define ERROR(name)
Definition: error_private.h:53
size_t(* decompressionAlgo)(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, void *workSpace, size_t wkspSize)
#define LIKELY(x)
Definition: compiler.h:161
size_t HUF_decompress1X1_DCtx(HUF_DTable *DCtx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
GLdouble n
Definition: glext.h:7729
MEM_STATIC size_t BIT_initDStream(BIT_DStream_t *bitD, const void *srcBuffer, size_t srcSize)
Definition: bitstream.h:272
#define assert(x)
Definition: debug.h:53
#define HUF_DECODE_SYMBOLX1_2(ptr, DStreamPtr)
MEM_STATIC unsigned MEM_32bits(void)
Definition: mem.h:183
size_t HUF_decompress4X_hufOnly(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
static const algo_time_t algoTime[16][3]
size_t HUF_decompress1X1_usingDTable(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t *bitD)
Definition: bitstream.h:416
#define HUF_DGEN(fn)
#define HUF_DECODE_SYMBOLX1_1(ptr, DStreamPtr)
size_t HUF_decompress4X_usingDTable_bmi2(void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable, int bmi2)
size_t HUF_decompress1X2_usingDTable(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t *bitD)
Definition: bitstream.h:445
size_t HUF_decompress1X2_DCtx(HUF_DTable *DCtx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t HUF_readDTableX2(HUF_DTable *DTable, const void *src, size_t srcSize)
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
r reserved
Definition: btrfs.c:3006
HINT_INLINE size_t HUF_decodeStreamX2(BYTE *p, BIT_DStream_t *bitDPtr, BYTE *const pEnd, const HUF_DEltX2 *const dt, const U32 dtLog)
#define DEBUG_STATIC_ASSERT(c)
Definition: debug.h:43
static size_t HUF_decompress4X2_DCtx_wksp_bmi2(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, void *workSpace, size_t wkspSize, int bmi2)
GLuint GLfloat * val
Definition: glext.h:7180
size_t HUF_decompress4X1_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
FORCE_INLINE_TEMPLATE U32 HUF_decodeLastSymbolX2(void *op, BIT_DStream_t *DStream, const HUF_DEltX2 *dt, const U32 dtLog)
MEM_STATIC U16 MEM_readLE16(const void *memPtr)
Definition: mem.h:314
__kernel_size_t size_t
Definition: linux.h:237
size_t HUF_readDTableX1(HUF_DTable *DTable, const void *src, size_t srcSize)
size_t bitContainer
Definition: bitstream.h:92
size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, void *workSpace, size_t wkspSize, int bmi2)
size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, void *workSpace, size_t wkspSize, int bmi2)
Definition: dhcpd.h:61
#define HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)
size_t HUF_decompress4X2_usingDTable(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
#define D(d)
Definition: builtin.c:4557
const GLubyte * c
Definition: glext.h:8905
UINT op
Definition: effect.c:236
MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t *bitD, U32 nbBits)
Definition: bitstream.h:361
struct task_struct * current
Definition: linux.c:32
MEM_STATIC void BIT_skipBits(BIT_DStream_t *bitD, U32 nbBits)
Definition: bitstream.h:368
GLuint GLuint end
Definition: gl.h:1545
size_t HUF_decompress1X2(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
static const WCHAR maxW[]
Definition: math.c:53
unsigned bitsConsumed
Definition: bitstream.h:93
#define HUF_isError
size_t HUF_decompress4X2_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
FORCE_INLINE_TEMPLATE size_t HUF_decompress1X1_usingDTable_internal_body(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLdouble s
Definition: gl.h:2039
GLenum src
Definition: glext.h:6340
size_t HUF_decompress4X_DCtx(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
static void HUF_fillDTableX2Level2(HUF_DEltX2 *DTable, U32 sizeLog, const U32 consumed, const U32 *rankValOrigin, const int minWeight, const sortedSymbol_t *sortedSymbols, const U32 sortedListSize, U32 nbBitsBaseline, U16 baseSeq)
unsigned char BYTE
Definition: xxhash.c:193
static DTableDesc HUF_getDTableDesc(const HUF_DTable *table)
size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, void *workSpace, size_t wkspSize)
#define HUF_ALIGN(x, a)
unsigned short U16
Definition: xxhash.c:194
U32 HUF_selectDecoder(size_t dstSize, size_t cSrcSize)
#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr)
size_t HUF_readDTableX1_wksp(HUF_DTable *DTable, const void *src, size_t srcSize, void *workSpace, size_t wkspSize)
weight
Definition: sortkey.c:156
size_t HUF_decompress4X1(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable *DCtx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, void *workSpace, size_t wkspSize)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
size_t HUF_decompress1X1(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize)
size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable *DCtx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, void *workSpace, size_t wkspSize)
int consumed
Definition: scanf.h:134
#define byte(x, n)
Definition: tomcrypt.h:118
GLuint start
Definition: gl.h:1545
size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, void *workSpace, size_t wkspSize)
GLenum GLenum dst
Definition: glext.h:6340
FORCE_INLINE_TEMPLATE BYTE HUF_decodeSymbolX1(BIT_DStream_t *Dstream, const HUF_DEltX1 *dt, const U32 dtLog)
#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr)
MEM_STATIC BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t *bitD)
Definition: bitstream.h:400
static void HUF_fillDTableX2(HUF_DEltX2 *DTable, const U32 targetLog, const sortedSymbol_t *sortedList, const U32 sortedListSize, const U32 *rankStart, rankVal_t rankValOrigin, const U32 maxWeight, const U32 nbBitsBaseline)
U32 rankValCol_t[HUF_TABLELOG_MAX+1]
size_t HUF_decompress1X_usingDTable_bmi2(void *dst, size_t maxDstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable, int bmi2)
#define c
Definition: ke_i.h:80
#define const
Definition: zconf.h:230
size_t HUF_decompress4X1_usingDTable(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
size_t HUF_decompress1X_DCtx_wksp(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, void *workSpace, size_t wkspSize)
#define HINT_INLINE
Definition: compiler.h:61
FORCE_INLINE_TEMPLATE size_t HUF_decompress4X2_usingDTable_internal_body(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
FORCE_INLINE_TEMPLATE size_t HUF_decompress4X1_usingDTable_internal_body(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
GLfloat GLfloat p
Definition: glext.h:8902
#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
#define memset(x, y, z)
Definition: compat.h:39
size_t(* HUF_decompress_usingDTable_t)(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable)
unsigned int U32
Definition: xxhash.c:195
rankValCol_t rankVal_t[HUF_TABLELOG_MAX]
static size_t HUF_decompress4X1_DCtx_wksp_bmi2(HUF_DTable *dctx, void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, void *workSpace, size_t wkspSize, int bmi2)
#define FORCE_INLINE_TEMPLATE
Definition: xxhash.c:172
HINT_INLINE size_t HUF_decodeStreamX1(BYTE *p, BIT_DStream_t *const bitDPtr, BYTE *const pEnd, const HUF_DEltX1 *const dt, const U32 dtLog)
size_t HUF_readStats(BYTE *huffWeight, size_t hwSize, U32 *rankStats, U32 *nbSymbolsPtr, U32 *tableLogPtr, const void *src, size_t srcSize)