Lines Matching +full:3 +full:- +full:byte
1 // SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
8 * - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
10 * This source code is licensed under both the BSD-style license (found in the
13 * You may select, at your option, one of the above-listed licenses.
79 * Byte alignment for workSpace management
81 #define HUF_ALIGN(x, a) HUF_ALIGN_MASK((x), (a) - 1)
135 /*-***************************/
137 /*-***************************/
138 typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc;
147 static size_t HUF_initFastDStream(BYTE const* ip) { in HUF_initFastDStream()
148 BYTE const lastByte = ip[7]; in HUF_initFastDStream()
149 size_t const bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0; in HUF_initFastDStream()
160 * ip [in/out] - The input pointers, must be updated to reflect what is consumed.
161 * op [in/out] - The output pointers, must be updated to reflect what is written.
162 * bits [in/out] - The bitstream containers, must be updated to reflect the current state.
163 * dt [in] - The decoding table.
164 * ilowest [in] - The beginning of the valid range of the input. Decoders may read
166 * oend [in] - The end of the output stream. op[3] must not cross oend.
167 * iend [in] - The end of each input stream. ip[i] may cross iend[i],
171 BYTE const* ip[4];
172 BYTE* op[4];
175 BYTE const* ilowest;
176 BYTE* oend;
177 BYTE const* iend[4];
193 const BYTE* const istart = (const BYTE*)src; in HUF_DecompressFastArgs_init()
195 BYTE* const oend = ZSTD_maybeNullPtrAdd((BYTE*)dst, dstSize); in HUF_DecompressFastArgs_init()
197 /* The fast decoding loop assumes 64-bit little-endian. in HUF_DecompressFastArgs_init()
208 /* strict minimum : jump table + 1 byte per stream */ in HUF_DecompressFastArgs_init()
224 size_t const length4 = srcSize - (length1 + length2 + length3 + 6); in HUF_DecompressFastArgs_init()
225 args->iend[0] = istart + 6; /* jumpTable */ in HUF_DecompressFastArgs_init()
226 args->iend[1] = args->iend[0] + length1; in HUF_DecompressFastArgs_init()
227 args->iend[2] = args->iend[1] + length2; in HUF_DecompressFastArgs_init()
228 args->iend[3] = args->iend[2] + length3; in HUF_DecompressFastArgs_init()
238 args->ip[0] = args->iend[1] - sizeof(U64); in HUF_DecompressFastArgs_init()
239 args->ip[1] = args->iend[2] - sizeof(U64); in HUF_DecompressFastArgs_init()
240 args->ip[2] = args->iend[3] - sizeof(U64); in HUF_DecompressFastArgs_init()
241 args->ip[3] = (BYTE const*)src + srcSize - sizeof(U64); in HUF_DecompressFastArgs_init()
244 args->op[0] = (BYTE*)dst; in HUF_DecompressFastArgs_init()
245 args->op[1] = args->op[0] + (dstSize+3)/4; in HUF_DecompressFastArgs_init()
246 args->op[2] = args->op[1] + (dstSize+3)/4; in HUF_DecompressFastArgs_init()
247 args->op[3] = args->op[2] + (dstSize+3)/4; in HUF_DecompressFastArgs_init()
250 if (args->op[3] >= oend) in HUF_DecompressFastArgs_init()
260 args->bits[0] = HUF_initFastDStream(args->ip[0]); in HUF_DecompressFastArgs_init()
261 args->bits[1] = HUF_initFastDStream(args->ip[1]); in HUF_DecompressFastArgs_init()
262 args->bits[2] = HUF_initFastDStream(args->ip[2]); in HUF_DecompressFastArgs_init()
263 args->bits[3] = HUF_initFastDStream(args->ip[3]); in HUF_DecompressFastArgs_init()
270 args->ilowest = istart; in HUF_DecompressFastArgs_init()
272 args->oend = oend; in HUF_DecompressFastArgs_init()
273 args->dt = dt; in HUF_DecompressFastArgs_init()
278 …ainingDStream(BIT_DStream_t* bit, HUF_DecompressFastArgs const* args, int stream, BYTE* segmentEnd) in HUF_initRemainingDStream()
281 if (args->op[stream] > segmentEnd) in HUF_initRemainingDStream()
286 * of the stream, so down to iend[i] - 8 is valid. in HUF_initRemainingDStream()
288 if (args->ip[stream] < args->iend[stream] - 8) in HUF_initRemainingDStream()
293 bit->bitContainer = MEM_readLEST(args->ip[stream]); in HUF_initRemainingDStream()
294 bit->bitsConsumed = ZSTD_countTrailingZeros64(args->bits[stream]); in HUF_initRemainingDStream()
295 bit->start = (const char*)args->ilowest; in HUF_initRemainingDStream()
296 bit->limitPtr = bit->start + sizeof(size_t); in HUF_initRemainingDStream()
297 bit->ptr = (const char*)args->ip[stream]; in HUF_initRemainingDStream()
302 /* Calls X(N) for each stream 0, 1, 2, 3. */
308 X(3); \
311 /* Calls X(N, var) for each stream 0, 1, 2, 3. */
317 X(3, (var)); \
323 /*-***************************/
324 /* single-symbol decoding */
325 /*-***************************/
326 typedef struct { BYTE nbBits; BYTE byte; } HUF_DEltX1; /* single-symbol decoding */ member
332 static U64 HUF_DEltX1_set4(BYTE symbol, BYTE nbBits) { in HUF_DEltX1_set4()
346 * If tableLog > targetTableLog this is a no-op.
349 static U32 HUF_rescaleStats(BYTE* huffWeight, U32* rankVal, U32 nbSymbols, U32 tableLog, U32 target… in HUF_rescaleStats()
354 U32 const scale = targetTableLog - tableLog; in HUF_rescaleStats()
356 /* Increase the weight for all non-zero probability symbols by scale. */ in HUF_rescaleStats()
358 huffWeight[s] += (BYTE)((huffWeight[s] == 0) ? 0 : scale); in HUF_rescaleStats()
364 for (s = targetTableLog; s > scale; --s) { in HUF_rescaleStats()
365 rankVal[s] = rankVal[s - scale]; in HUF_rescaleStats()
367 for (s = scale; s > 0; --s) { in HUF_rescaleStats()
378 BYTE symbols[HUF_SYMBOLVALUE_MAX + 1];
379 BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1];
397 …dStats_wksp(wksp->huffWeight, HUF_SYMBOLVALUE_MAX + 1, wksp->rankVal, &nbSymbols, &tableLog, src, … in HUF_readDTableX1_wksp()
405 … tableLog = HUF_rescaleStats(wksp->huffWeight, wksp->rankVal, nbSymbols, tableLog, targetTableLog); in HUF_readDTableX1_wksp()
408 dtd.tableLog = (BYTE)tableLog; in HUF_readDTableX1_wksp()
427 int const nLimit = (int)nbSymbols - unroll + 1; in HUF_readDTableX1_wksp()
430 nextRankStart += wksp->rankVal[n]; in HUF_readDTableX1_wksp()
431 wksp->rankStart[n] = curr; in HUF_readDTableX1_wksp()
436 size_t const w = wksp->huffWeight[n+u]; in HUF_readDTableX1_wksp()
437 wksp->symbols[wksp->rankStart[w]++] = (BYTE)(n+u); in HUF_readDTableX1_wksp()
441 size_t const w = wksp->huffWeight[n]; in HUF_readDTableX1_wksp()
442 wksp->symbols[wksp->rankStart[w]++] = (BYTE)n; in HUF_readDTableX1_wksp()
453 int symbol = wksp->rankVal[0]; in HUF_readDTableX1_wksp()
456 int const symbolCount = wksp->rankVal[w]; in HUF_readDTableX1_wksp()
459 BYTE const nbBits = (BYTE)(tableLog + 1 - w); in HUF_readDTableX1_wksp()
466 D.byte = wksp->symbols[symbol + s]; in HUF_readDTableX1_wksp()
475 D.byte = wksp->symbols[symbol + s]; in HUF_readDTableX1_wksp()
484 U64 const D4 = HUF_DEltX1_set4(wksp->symbols[symbol + s], nbBits); in HUF_readDTableX1_wksp()
491 U64 const D4 = HUF_DEltX1_set4(wksp->symbols[symbol + s], nbBits); in HUF_readDTableX1_wksp()
499 U64 const D4 = HUF_DEltX1_set4(wksp->symbols[symbol + s], nbBits); in HUF_readDTableX1_wksp()
518 FORCE_INLINE_TEMPLATE BYTE
522 BYTE const c = dt[val].byte; in HUF_decodeSymbolX1()
543 HUF_decodeStreamX1(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX1* const… in HUF_decodeStreamX1()
545 BYTE* const pStart = p; in HUF_decodeStreamX1()
548 if ((pEnd - p) > 3) { in HUF_decodeStreamX1()
549 while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-3)) { in HUF_decodeStreamX1()
559 /* [0-3] symbols remaining */ in HUF_decodeStreamX1()
568 return (size_t)(pEnd-pStart); in HUF_decodeStreamX1()
577 BYTE* op = (BYTE*)dst; in HUF_decompress1X1_usingDTable_internal_body()
578 BYTE* const oend = ZSTD_maybeNullPtrAdd(op, dstSize); in HUF_decompress1X1_usingDTable_internal_body()
605 …if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per… in HUF_decompress4X1_usingDTable_internal_body()
606 if (dstSize < 6) return ERROR(corruption_detected); /* stream 4-split doesn't work */ in HUF_decompress4X1_usingDTable_internal_body()
608 { const BYTE* const istart = (const BYTE*) cSrc; in HUF_decompress4X1_usingDTable_internal_body()
609 BYTE* const ostart = (BYTE*) dst; in HUF_decompress4X1_usingDTable_internal_body()
610 BYTE* const oend = ostart + dstSize; in HUF_decompress4X1_usingDTable_internal_body()
611 BYTE* const olimit = oend - 3; in HUF_decompress4X1_usingDTable_internal_body()
623 size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6); in HUF_decompress4X1_usingDTable_internal_body()
624 const BYTE* const istart1 = istart + 6; /* jumpTable */ in HUF_decompress4X1_usingDTable_internal_body()
625 const BYTE* const istart2 = istart1 + length1; in HUF_decompress4X1_usingDTable_internal_body()
626 const BYTE* const istart3 = istart2 + length2; in HUF_decompress4X1_usingDTable_internal_body()
627 const BYTE* const istart4 = istart3 + length3; in HUF_decompress4X1_usingDTable_internal_body()
628 const size_t segmentSize = (dstSize+3) / 4; in HUF_decompress4X1_usingDTable_internal_body()
629 BYTE* const opStart2 = ostart + segmentSize; in HUF_decompress4X1_usingDTable_internal_body()
630 BYTE* const opStart3 = opStart2 + segmentSize; in HUF_decompress4X1_usingDTable_internal_body()
631 BYTE* const opStart4 = opStart3 + segmentSize; in HUF_decompress4X1_usingDTable_internal_body()
632 BYTE* op1 = ostart; in HUF_decompress4X1_usingDTable_internal_body()
633 BYTE* op2 = opStart2; in HUF_decompress4X1_usingDTable_internal_body()
634 BYTE* op3 = opStart3; in HUF_decompress4X1_usingDTable_internal_body()
635 BYTE* op4 = opStart4; in HUF_decompress4X1_usingDTable_internal_body()
648 /* up to 16 symbols per loop (4 symbols per stream) in 64-bit mode */ in HUF_decompress4X1_usingDTable_internal_body()
649 if ((size_t)(oend - op4) >= sizeof(size_t)) { in HUF_decompress4X1_usingDTable_internal_body()
676 …* but curiously, binary generated by gcc 7.2 & 7.3 with -mbmi2 runs faster when >=1 test is… in HUF_decompress4X1_usingDTable_internal_body()
721 BYTE const* ip[4]; in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
722 BYTE* op[4]; in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
723 U16 const* const dtable = (U16 const*)args->dt; in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
724 BYTE* const oend = args->oend; in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
725 BYTE const* const ilowest = args->ilowest; in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
728 ZSTD_memcpy(&bits, &args->bits, sizeof(bits)); in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
729 ZSTD_memcpy((void*)(&ip), &args->ip, sizeof(ip)); in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
730 ZSTD_memcpy(&op, &args->op, sizeof(op)); in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
736 BYTE* olimit; in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
742 assert(op[stream] <= (stream == 3 ? oend : op[stream + 1])); in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
749 size_t const oiters = (size_t)(oend - op[3]) / 5; in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
753 size_t const iiters = (size_t)(ip[0] - ilowest) / 7; in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
758 /* We can simply check that op[3] < olimit, instead of checking all in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
760 * iters iterations, which only happens when op[3] == olimit. in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
762 olimit = op[3] + symbols; in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
765 if (op[3] == olimit) in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
773 if (ip[stream] < ip[stream - 1]) in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
780 assert(ip[stream] >= ip[stream - 1]); in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
789 op[(_stream)][(_symbol)] = (BYTE)((entry >> 8) & 0xFF); \ in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
796 int const nbBytes = ctz >> 3; \ in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
798 ip[(_stream)] -= nbBytes; \ in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
811 HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X1_DECODE_SYMBOL, 3); in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
816 } while (op[3] < olimit); in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
825 ZSTD_memcpy(&args->bits, &bits, sizeof(bits)); in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
826 ZSTD_memcpy((void*)(&args->ip), &ip, sizeof(ip)); in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
827 ZSTD_memcpy(&args->op, &op, sizeof(op)); in HUF_decompress4X1_usingDTable_internal_fast_c_loop()
844 BYTE const* const ilowest = (BYTE const*)cSrc; in HUF_decompress4X1_usingDTable_internal_fast()
845 BYTE* const oend = ZSTD_maybeNullPtrAdd((BYTE*)dst, dstSize); in HUF_decompress4X1_usingDTable_internal_fast()
863 assert(args.ip[3] >= ilowest); in HUF_decompress4X1_usingDTable_internal_fast()
864 assert(args.op[3] <= oend); in HUF_decompress4X1_usingDTable_internal_fast()
871 { size_t const segmentSize = (dstSize+3) / 4; in HUF_decompress4X1_usingDTable_internal_fast()
872 BYTE* segmentEnd = (BYTE*)dst; in HUF_decompress4X1_usingDTable_internal_fast()
876 if (segmentSize <= (size_t)(oend - segmentEnd)) in HUF_decompress4X1_usingDTable_internal_fast()
931 const BYTE* ip = (const BYTE*) cSrc; in HUF_decompress4X1_DCtx_wksp()
936 ip += hSize; cSrcSize -= hSize; in HUF_decompress4X1_DCtx_wksp()
947 /* double-symbols decoding */
950 typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX2; /* double-symbols decoding …
951 typedef struct { BYTE symbol; } sortedSymbol_t;
963 DEBUG_STATIC_ASSERT(offsetof(HUF_DEltX2, length) == 3); in HUF_buildDEltX2U32()
1013 U32 const length = 1U << ((tableLog - nbBits) & 0x1F /* quiet static-analyzer */); in HUF_fillDTableX2ForWeight()
1019 HUF_DEltX2 const DElt = HUF_buildDEltX2(ptr->symbol, nbBits, baseSeq, level); in HUF_fillDTableX2ForWeight()
1025 HUF_DEltX2 const DElt = HUF_buildDEltX2(ptr->symbol, nbBits, baseSeq, level); in HUF_fillDTableX2ForWeight()
1033 U64 const DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level); in HUF_fillDTableX2ForWeight()
1041 U64 const DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level); in HUF_fillDTableX2ForWeight()
1051 U64 const DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level); in HUF_fillDTableX2ForWeight()
1076 U32 const length = 1U << ((targetLog - consumedBits) & 0x1F /* quiet static-analyzer */); in HUF_fillDTableX2Level2()
1110 U32 const nbBits = nbBitsBaseline - w; in HUF_fillDTableX2Level2()
1127 …const int scaleLog = nbBitsBaseline - targetLog; /* note : targetLog >= srcLog, hence scaleLog <… in HUF_fillDTableX2()
1128 const U32 minBits = nbBitsBaseline - maxWeight; in HUF_fillDTableX2()
1136 U32 const nbBits = nbBitsBaseline - w; in HUF_fillDTableX2()
1138 if (targetLog-nbBits >= minBits) { in HUF_fillDTableX2()
1141 U32 const length = 1U << ((targetLog - nbBits) & 0x1F /* quiet static-analyzer */); in HUF_fillDTableX2()
1170 U32 rankStart0[HUF_TABLELOG_MAX + 3];
1172 BYTE weightList[HUF_SYMBOLVALUE_MAX + 1];
1184 void* dtPtr = DTable+1; /* force compiler to avoid strict-aliasing */ in HUF_readDTableX2_wksp()
1192 rankStart = wksp->rankStart0 + 1; in HUF_readDTableX2_wksp()
1193 ZSTD_memset(wksp->rankStats, 0, sizeof(wksp->rankStats)); in HUF_readDTableX2_wksp()
1194 ZSTD_memset(wksp->rankStart0, 0, sizeof(wksp->rankStart0)); in HUF_readDTableX2_wksp()
1200 …Stats_wksp(wksp->weightList, HUF_SYMBOLVALUE_MAX + 1, wksp->rankStats, &nbSymbols, &tableLog, src,… in HUF_readDTableX2_wksp()
1208 …for (maxW = tableLog; wksp->rankStats[maxW]==0; maxW--) {} /* necessarily finds a solution before… in HUF_readDTableX2_wksp()
1214 nextRankStart += wksp->rankStats[w]; in HUF_readDTableX2_wksp()
1224 U32 const w = wksp->weightList[s]; in HUF_readDTableX2_wksp()
1226 wksp->sortedSymbol[r].symbol = (BYTE)s; in HUF_readDTableX2_wksp()
1232 { U32* const rankVal0 = wksp->rankVal[0]; in HUF_readDTableX2_wksp()
1233 { int const rescale = (maxTableLog-tableLog) - 1; /* tableLog <= maxTableLog */ in HUF_readDTableX2_wksp()
1238 nextRankVal += wksp->rankStats[w] << (w+rescale); in HUF_readDTableX2_wksp()
1241 { U32 const minBits = tableLog+1 - maxW; in HUF_readDTableX2_wksp()
1243 for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) { in HUF_readDTableX2_wksp()
1244 U32* const rankValPtr = wksp->rankVal[consumed]; in HUF_readDTableX2_wksp()
1251 wksp->sortedSymbol, in HUF_readDTableX2_wksp()
1252 wksp->rankStart0, wksp->rankVal, maxW, in HUF_readDTableX2_wksp()
1255 dtd.tableLog = (BYTE)maxTableLog; in HUF_readDTableX2_wksp()
1279 if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) { in HUF_decodeLastSymbolX2()
1281 if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8)) in HUF_decodeLastSymbolX2()
1283 DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8); in HUF_decodeLastSymbolX2()
1305 HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, in HUF_decodeStreamX2()
1308 BYTE* const pStart = p; in HUF_decodeStreamX2()
1311 if ((size_t)(pEnd - p) >= sizeof(bitDPtr->bitContainer)) { in HUF_decodeStreamX2()
1314 while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-9)) { in HUF_decodeStreamX2()
1323 …reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-(sizeof(bitDPtr->bitContainer)-1))) { in HUF_decodeStreamX2()
1335 if ((size_t)(pEnd - p) >= 2) { in HUF_decodeStreamX2()
1336 while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p <= pEnd-2)) in HUF_decodeStreamX2()
1339 while (p <= pEnd-2) in HUF_decodeStreamX2()
1346 return p-pStart; in HUF_decodeStreamX2()
1361 { BYTE* const ostart = (BYTE*) dst; in HUF_decompress1X2_usingDTable_internal_body()
1362 BYTE* const oend = ZSTD_maybeNullPtrAdd(ostart, dstSize); in HUF_decompress1X2_usingDTable_internal_body()
1363 const void* const dtPtr = DTable+1; /* force compiler to not use strict-aliasing */ in HUF_decompress1X2_usingDTable_internal_body()
1386 …if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte pe… in HUF_decompress4X2_usingDTable_internal_body()
1387 if (dstSize < 6) return ERROR(corruption_detected); /* stream 4-split doesn't work */ in HUF_decompress4X2_usingDTable_internal_body()
1389 { const BYTE* const istart = (const BYTE*) cSrc; in HUF_decompress4X2_usingDTable_internal_body()
1390 BYTE* const ostart = (BYTE*) dst; in HUF_decompress4X2_usingDTable_internal_body()
1391 BYTE* const oend = ostart + dstSize; in HUF_decompress4X2_usingDTable_internal_body()
1392 BYTE* const olimit = oend - (sizeof(size_t)-1); in HUF_decompress4X2_usingDTable_internal_body()
1404 size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6); in HUF_decompress4X2_usingDTable_internal_body()
1405 const BYTE* const istart1 = istart + 6; /* jumpTable */ in HUF_decompress4X2_usingDTable_internal_body()
1406 const BYTE* const istart2 = istart1 + length1; in HUF_decompress4X2_usingDTable_internal_body()
1407 const BYTE* const istart3 = istart2 + length2; in HUF_decompress4X2_usingDTable_internal_body()
1408 const BYTE* const istart4 = istart3 + length3; in HUF_decompress4X2_usingDTable_internal_body()
1409 size_t const segmentSize = (dstSize+3) / 4; in HUF_decompress4X2_usingDTable_internal_body()
1410 BYTE* const opStart2 = ostart + segmentSize; in HUF_decompress4X2_usingDTable_internal_body()
1411 BYTE* const opStart3 = opStart2 + segmentSize; in HUF_decompress4X2_usingDTable_internal_body()
1412 BYTE* const opStart4 = opStart3 + segmentSize; in HUF_decompress4X2_usingDTable_internal_body()
1413 BYTE* op1 = ostart; in HUF_decompress4X2_usingDTable_internal_body()
1414 BYTE* op2 = opStart2; in HUF_decompress4X2_usingDTable_internal_body()
1415 BYTE* op3 = opStart3; in HUF_decompress4X2_usingDTable_internal_body()
1416 BYTE* op4 = opStart4; in HUF_decompress4X2_usingDTable_internal_body()
1429 /* 16-32 symbols per loop (4-8 symbols per stream) */ in HUF_decompress4X2_usingDTable_internal_body()
1430 if ((size_t)(oend - op4) >= sizeof(size_t)) { in HUF_decompress4X2_usingDTable_internal_body()
1524 BYTE const* ip[4]; in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1525 BYTE* op[4]; in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1526 BYTE* oend[4]; in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1527 HUF_DEltX2 const* const dtable = (HUF_DEltX2 const*)args->dt; in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1528 BYTE const* const ilowest = args->ilowest; in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1531 ZSTD_memcpy(&bits, &args->bits, sizeof(bits)); in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1532 ZSTD_memcpy((void*)(&ip), &args->ip, sizeof(ip)); in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1533 ZSTD_memcpy(&op, &args->op, sizeof(op)); in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1537 oend[2] = op[3]; in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1538 oend[3] = args->oend; in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1544 BYTE* olimit; in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1564 size_t iters = (size_t)(ip[0] - ilowest) / 7; in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1570 size_t const oiters = (size_t)(oend[stream] - op[stream]) / 10; in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1575 * op[3] crosses olimit, we know we haven't executed iters in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1580 olimit = op[3] + (iters * 5); in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1583 if (op[3] == olimit) in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1591 if (ip[stream] < ip[stream - 1]) in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1598 assert(ip[stream] >= ip[stream - 1]); in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1604 if ((_decode3) || (_stream) != 3) { \ in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1615 HUF_4X2_DECODE_SYMBOL(3, 1); \ in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1619 int const nbBytes = ctz >> 3; \ in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1620 ip[(_stream)] -= nbBytes; \ in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1630 /* Decode 5 symbols from each of the first 3 streams. in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1641 HUF_4X2_DECODE_SYMBOL(3, 1); in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1648 } while (op[3] < olimit); in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1657 ZSTD_memcpy(&args->bits, &bits, sizeof(bits)); in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1658 ZSTD_memcpy((void*)(&args->ip), &ip, sizeof(ip)); in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1659 ZSTD_memcpy(&args->op, &op, sizeof(op)); in HUF_decompress4X2_usingDTable_internal_fast_c_loop()
1670 const BYTE* const ilowest = (const BYTE*)cSrc; in HUF_decompress4X2_usingDTable_internal_fast()
1671 BYTE* const oend = ZSTD_maybeNullPtrAdd((BYTE*)dst, dstSize); in HUF_decompress4X2_usingDTable_internal_fast()
1687 assert(args.ip[3] >= ilowest); in HUF_decompress4X2_usingDTable_internal_fast()
1688 assert(args.op[3] <= oend); in HUF_decompress4X2_usingDTable_internal_fast()
1696 size_t const segmentSize = (dstSize+3) / 4; in HUF_decompress4X2_usingDTable_internal_fast()
1697 BYTE* segmentEnd = (BYTE*)dst; in HUF_decompress4X2_usingDTable_internal_fast()
1701 if (segmentSize <= (size_t)(oend - segmentEnd)) in HUF_decompress4X2_usingDTable_internal_fast()
1755 const BYTE* ip = (const BYTE*) cSrc; in HUF_DGEN()
1761 ip += hSize; cSrcSize -= hSize; in HUF_DGEN()
1770 const BYTE* ip = (const BYTE*) cSrc; in HUF_decompress4X2_DCtx_wksp()
1776 ip += hSize; cSrcSize -= hSize; in HUF_decompress4X2_DCtx_wksp()
1796 {{ 150,216}, { 381,119}}, /* Q == 2 : 12-18% */
1797 {{ 170,205}, { 514,112}}, /* Q == 3 : 18-25% */
1798 {{ 177,199}, { 539,110}}, /* Q == 4 : 25-32% */
1799 {{ 197,194}, { 644,107}}, /* Q == 5 : 32-38% */
1800 {{ 221,192}, { 735,107}}, /* Q == 6 : 38-44% */
1801 {{ 256,189}, { 881,106}}, /* Q == 7 : 44-50% */
1802 {{ 359,188}, {1167,109}}, /* Q == 8 : 50-56% */
1803 {{ 582,187}, {1570,114}}, /* Q == 9 : 56-62% */
1804 {{ 688,187}, {1712,122}}, /* Q ==10 : 62-69% */
1805 {{ 825,186}, {1965,136}}, /* Q ==11 : 69-75% */
1806 {{ 976,185}, {2131,150}}, /* Q ==12 : 75-81% */
1807 {{1180,186}, {2070,175}}, /* Q ==13 : 81-87% */
1808 {{1377,185}, {1731,202}}, /* Q ==14 : 87-93% */
1809 {{1412,185}, {1695,202}}, /* Q ==15 : 93-99% */
1815 * based on a set of pre-computed metrics.
1850 … if (cSrcSize == 1) { ZSTD_memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */ in HUF_decompress1X_DCtx_wksp()
1893 const BYTE* ip = (const BYTE*) cSrc; in HUF_decompress1X1_DCtx_wksp()
1898 ip += hSize; cSrcSize -= hSize; in HUF_decompress1X1_DCtx_wksp()