Cross Reference: /src/external/bsd/zstd/dist/lib/common/bitstream.h

Lines Matching refs:bitD
71 *  `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code.
104 MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
105 MEM_STATIC BitContainerType BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
106 MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
107 MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
115 *  A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished.
130 MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
250  * `bitD` : a pointer to an already allocated BIT_DStream_t structure.
254 MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
256     if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
258     bitD->start = (const char*)srcBuffer;
259     bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
261     if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */
262         bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
263         bitD->bitContainer = MEM_readLEST(bitD->ptr);
265           bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;  /* ensures bitsConsumed is always set */
268         bitD->ptr   = bitD->start;
269         bitD->bitContainer = *(const BYTE*)(bitD->start);
272         case 7: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
275         case 6: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
278         case 5: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
281         case 4: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[3]) << 24;
284         case 3: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[2]) << 16;
287         case 2: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[1]) <<  8;
293             bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;
296         bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
330 FORCE_INLINE_TEMPLATE BitContainerType BIT_lookBits(const BIT_DStream_t*  bitD, U32 nbBits)
334     /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8,
336     return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
339     U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
340     return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);
346 MEM_STATIC BitContainerType BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)
348     U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
350     return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
353 FORCE_INLINE_TEMPLATE void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
355     bitD->bitsConsumed += nbBits;
362 FORCE_INLINE_TEMPLATE BitContainerType BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits)
364     BitContainerType const value = BIT_lookBits(bitD, nbBits);
365     BIT_skipBits(bitD, nbBits);
371 MEM_STATIC BitContainerType BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits)
373     BitContainerType const value = BIT_lookBitsFast(bitD, nbBits);
375     BIT_skipBits(bitD, nbBits);
381  *  1. bitstream is valid : bitsConsumed <= sizeof(bitD->bitContainer)*8
382  *  2. look window is valid after shifted down : bitD->ptr >= bitD->start
384 MEM_STATIC BIT_DStream_status BIT_reloadDStream_internal(BIT_DStream_t* bitD)
386     assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8);
387     bitD->ptr -= bitD->bitsConsumed >> 3;
388     assert(bitD->ptr >= bitD->start);
389     bitD->bitsConsumed &= 7;
390     bitD->bitContainer = MEM_readLEST(bitD->ptr);
396  *  1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold!
397  *  2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this
400 MEM_STATIC BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t* bitD)
402     if (UNLIKELY(bitD->ptr < bitD->limitPtr))
404     return BIT_reloadDStream_internal(bitD);
408  *  Refill `bitD` from buffer previously set in BIT_initDStream() .
412 FORCE_INLINE_TEMPLATE BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
415     if (UNLIKELY(bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))) {
417         bitD->ptr = (const char*)&zeroFilled; /* aliasing is allowed for char */
422     assert(bitD->ptr >= bitD->start);
424     if (bitD->ptr >= bitD->limitPtr) {
425         return BIT_reloadDStream_internal(bitD);
427     if (bitD->ptr == bitD->start) {
429         if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
433     {   U32 nbBytes = bitD->bitsConsumed >> 3;
435         if (bitD->ptr - nbBytes < bitD->start) {
436             nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
439         bitD->ptr -= nbBytes;
440         bitD->bitsConsumed -= nbBytes*8;
441         bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
OpenGrok
