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

Lines Matching defs:bitContainer
57     BitContainerType bitContainer;
71 *  `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code.
91     BitContainerType bitContainer;
115 *  A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished.
153     bitC->bitContainer = 0;
157     bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContainer);
158     if (dstCapacity <= sizeof(bitC->bitContainer)) return ERROR(dstSize_tooSmall);
162 FORCE_INLINE_TEMPLATE BitContainerType BIT_getLowerBits(BitContainerType bitContainer, U32 const nbBits)
166     return _bzhi_u64(bitContainer, nbBits);
168     DEBUG_STATIC_ASSERT(sizeof(bitContainer) == sizeof(U32));
169     return _bzhi_u32(bitContainer, nbBits);
173     return bitContainer & BIT_mask[nbBits];
185     assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
186     bitC->bitContainer |= BIT_getLowerBits(value, nbBits) << bitC->bitPos;
197     assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
198     bitC->bitContainer |= value << bitC->bitPos;
203  *  assumption : bitContainer has not overflowed
208     assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
210     MEM_writeLEST(bitC->ptr, bitC->bitContainer);
213     bitC->bitContainer >>= nbBytes*8;
217  *  assumption : bitContainer has not overflowed
224     assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
226     MEM_writeLEST(bitC->ptr, bitC->bitContainer);
230     bitC->bitContainer >>= nbBytes*8;
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);
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;
296         bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
302 FORCE_INLINE_TEMPLATE BitContainerType BIT_getUpperBits(BitContainerType bitContainer, U32 const start)
304     return bitContainer >> start;
307 FORCE_INLINE_TEMPLATE BitContainerType BIT_getMiddleBits(BitContainerType bitContainer, U32 const start, U32 const nbBits)
309     U32 const regMask = sizeof(bitContainer)*8 - 1;
318     return (bitContainer >> (start & regMask)) & ((((U64)1) << nbBits) - 1);
320     return (bitContainer >> (start & regMask)) & BIT_mask[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);
348     U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
350     return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
381  *  1. bitstream is valid : bitsConsumed <= sizeof(bitD->bitContainer)*8
386     assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8);
390     bitD->bitContainer = MEM_readLEST(bitD->ptr);
396  *  1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold!
415     if (UNLIKELY(bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))) {
429         if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
441         bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
451     return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
OpenGrok
