Lines Matching defs:bitD
63 * `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code.
96 MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
97 MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
98 MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
99 MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
107 * A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished.
122 MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
254 * `bitD` : a pointer to an already allocated BIT_DStream_t structure.
258 MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
260 if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
262 bitD->start = (const char*)srcBuffer;
263 bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
265 if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */
266 bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
267 bitD->bitContainer = MEM_readLEST(bitD->ptr);
269 bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */
272 bitD->ptr = bitD->start;
273 bitD->bitContainer = *(const BYTE*)(bitD->start);
276 case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
279 case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
282 case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
285 case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24;
288 case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16;
291 case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8;
297 bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
300 bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
340 MEM_STATIC FORCE_INLINE_ATTR size_t BIT_lookBits(const BIT_DStream_t* bitD, U32 nbBits)
344 /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8,
346 return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
349 U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
350 return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);
356 MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)
358 U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
360 return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
363 MEM_STATIC FORCE_INLINE_ATTR void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
365 bitD->bitsConsumed += nbBits;
372 MEM_STATIC FORCE_INLINE_ATTR size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits)
374 size_t const value = BIT_lookBits(bitD, nbBits);
375 BIT_skipBits(bitD, nbBits);
381 MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits)
383 size_t const value = BIT_lookBitsFast(bitD, nbBits);
385 BIT_skipBits(bitD, nbBits);
391 * 1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold!
392 * 2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this
395 MEM_STATIC BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t* bitD)
397 if (UNLIKELY(bitD->ptr < bitD->limitPtr))
399 assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8);
400 bitD->ptr -= bitD->bitsConsumed >> 3;
401 bitD->bitsConsumed &= 7;
402 bitD->bitContainer = MEM_readLEST(bitD->ptr);
407 * Refill `bitD` from buffer previously set in BIT_initDStream() .
411 MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
413 if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
416 if (bitD->ptr >= bitD->limitPtr) {
417 return BIT_reloadDStreamFast(bitD);
419 if (bitD->ptr == bitD->start) {
420 if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
424 { U32 nbBytes = bitD->bitsConsumed >> 3;
426 if (bitD->ptr - nbBytes < bitD->start) {
427 nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */
430 bitD->ptr -= nbBytes;
431 bitD->bitsConsumed -= nbBytes*8;
432 bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */