lib/common/bitstream.h

72 *  `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code.
105 MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
106 MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
107 MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
108 MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
116 *  A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished.
131 MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
268  * `bitD` : a pointer to an already allocated BIT_DStream_t structure.
272 MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
274     if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
276     bitD->start = (const char*)srcBuffer;
277     bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
279     if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */
280         bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
281         bitD->bitContainer = MEM_readLEST(bitD->ptr);
283           bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;  /* ensures bitsConsumed is always set */
286         bitD->ptr   = bitD->start;
287         bitD->bitContainer = *(const BYTE*)(bitD->start);
290         case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
293         case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
296         case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
299         case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24;
302         case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16;
305         case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) <<  8;
311             bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
314         bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
345 MEM_STATIC size_t BIT_lookBits(const BIT_DStream_t* bitD, U32 nbBits)
349     /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8,
351     return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
354     U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
355     return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);
361 MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)
363     U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
365     return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
368 MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
370     bitD->bitsConsumed += nbBits;
377 MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits)
379     size_t const value = BIT_lookBits(bitD, nbBits);
380     BIT_skipBits(bitD, nbBits);
386 MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits)
388     size_t const value = BIT_lookBitsFast(bitD, nbBits);
390     BIT_skipBits(bitD, nbBits);
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     assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8);
405     bitD->ptr -= bitD->bitsConsumed >> 3;
406     bitD->bitsConsumed &= 7;
407     bitD->bitContainer = MEM_readLEST(bitD->ptr);
412  *  Refill `bitD` from buffer previously set in BIT_initDStream() .
416 MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
418     if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* overflow detected, like end of stream */
421     if (bitD->ptr >= bitD->limitPtr) {
422         return BIT_reloadDStreamFast(bitD);
424     if (bitD->ptr == bitD->start) {
425         if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
429     {   U32 nbBytes = bitD->bitsConsumed >> 3;
431         if (bitD->ptr - nbBytes < bitD->start) {
432             nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
435         bitD->ptr -= nbBytes;
436         bitD->bitsConsumed -= nbBytes*8;
437         bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */