Home | History | Annotate | Download | only in common

Lines Matching refs:nbBits

65 MEM_STATIC void   BIT_addBits(BIT_CStream_t* bitC, BitContainerType value, unsigned nbBits);
105 MEM_STATIC BitContainerType BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
124 MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, BitContainerType value, unsigned nbBits);
125 /* faster, but works only if value is "clean", meaning all high bits above nbBits are 0 */
130 MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
131 /* faster, but works only if nbBits >= 1 */
162 FORCE_INLINE_TEMPLATE BitContainerType BIT_getLowerBits(BitContainerType bitContainer, U32 const nbBits)
166     return _bzhi_u64(bitContainer, nbBits);
169     return _bzhi_u32(bitContainer, nbBits);
172     assert(nbBits < BIT_MASK_SIZE);
173     return bitContainer & BIT_mask[nbBits];
181                             BitContainerType value, unsigned nbBits)
184     assert(nbBits < BIT_MASK_SIZE);
185     assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
186     bitC->bitContainer |= BIT_getLowerBits(value, nbBits) << bitC->bitPos;
187     bitC->bitPos += nbBits;
192  *  meaning all high bits above nbBits are 0 */
194                                 BitContainerType value, unsigned nbBits)
196     assert((value>>nbBits) == 0);
197     assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
199     bitC->bitPos += nbBits;
307 FORCE_INLINE_TEMPLATE BitContainerType BIT_getMiddleBits(BitContainerType bitContainer, U32 const start, U32 const nbBits)
311     assert(nbBits < BIT_MASK_SIZE);
312     /* x86 transform & ((1 << nbBits) - 1) to bzhi instruction, it is better
318     return (bitContainer >> (start & regMask)) & ((((U64)1) << nbBits) - 1);
320     return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
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);
340     return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);
345  *  unsafe version; only works if nbBits >= 1 */
346 MEM_STATIC BitContainerType BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)
349     assert(nbBits >= 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;
360  *  Pay attention to not read more than nbBits contained into local register.
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);
370  *  unsafe version; only works if nbBits >= 1 */
371 MEM_STATIC BitContainerType BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits)
373     BitContainerType const value = BIT_lookBitsFast(bitD, nbBits);
374     assert(nbBits >= 1);
375     BIT_skipBits(bitD, nbBits);