Lines Matching +full:value +full:- +full:start
7 * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
9 * This source code is licensed under both the BSD-style license (found in the
12 * You may select, at your option, one of the above-listed licenses.
19 * Since link-time-optimization is not available for all compilers,
23 /*-****************************************
41 /*-******************************************
57 MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
61 /* Start with initCStream, providing the size of buffer to write into.
63 * `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code.
66 * Local register is size_t, hence 64-bits on 64-bits systems, or 32-bits on 32-bits systems.
71 * Avoid storing elements of more than 24 bits if you want compatibility with 32-bits bitstream rea…
79 /*-********************************************
86 const char* start; member
102 /* Start by invoking BIT_initDStream().
104 * Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
107 * A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_D…
113 /*-****************************************
116 MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
117 /* faster, but works only if value is "clean", meaning all high bits above nbBits are 0 */
127 /*-**************************************************************
162 /*-**************************************************************
172 bitC->bitContainer = 0; in BIT_initCStream()
173 bitC->bitPos = 0; in BIT_initCStream()
174 bitC->startPtr = (char*)startPtr; in BIT_initCStream()
175 bitC->ptr = bitC->startPtr; in BIT_initCStream()
176 bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContainer); in BIT_initCStream()
177 if (dstCapacity <= sizeof(bitC->bitContainer)) return ERROR(dstSize_tooSmall); in BIT_initCStream()
185 size_t value, unsigned nbBits) in BIT_addBits() argument
189 assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8); in BIT_addBits()
190 bitC->bitContainer |= (value & BIT_mask[nbBits]) << bitC->bitPos; in BIT_addBits()
191 bitC->bitPos += nbBits; in BIT_addBits()
195 * works only if `value` is _clean_,
198 size_t value, unsigned nbBits) in BIT_addBitsFast() argument
200 assert((value>>nbBits) == 0); in BIT_addBitsFast()
201 assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8); in BIT_addBitsFast()
202 bitC->bitContainer |= value << bitC->bitPos; in BIT_addBitsFast()
203 bitC->bitPos += nbBits; in BIT_addBitsFast()
211 size_t const nbBytes = bitC->bitPos >> 3; in BIT_flushBitsFast()
212 assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8); in BIT_flushBitsFast()
213 assert(bitC->ptr <= bitC->endPtr); in BIT_flushBitsFast()
214 MEM_writeLEST(bitC->ptr, bitC->bitContainer); in BIT_flushBitsFast()
215 bitC->ptr += nbBytes; in BIT_flushBitsFast()
216 bitC->bitPos &= 7; in BIT_flushBitsFast()
217 bitC->bitContainer >>= nbBytes*8; in BIT_flushBitsFast()
227 size_t const nbBytes = bitC->bitPos >> 3; in BIT_flushBits()
228 assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8); in BIT_flushBits()
229 assert(bitC->ptr <= bitC->endPtr); in BIT_flushBits()
230 MEM_writeLEST(bitC->ptr, bitC->bitContainer); in BIT_flushBits()
231 bitC->ptr += nbBytes; in BIT_flushBits()
232 if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr; in BIT_flushBits()
233 bitC->bitPos &= 7; in BIT_flushBits()
234 bitC->bitContainer >>= nbBytes*8; in BIT_flushBits()
244 if (bitC->ptr >= bitC->endPtr) return 0; /* overflow detected */ in BIT_closeCStream()
245 return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0); in BIT_closeCStream()
249 /*-********************************************************
262 bitD->start = (const char*)srcBuffer; in BIT_initDStream()
263 bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer); in BIT_initDStream()
265 if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */ in BIT_initDStream()
266 bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer); in BIT_initDStream()
267 bitD->bitContainer = MEM_readLEST(bitD->ptr); in BIT_initDStream()
268 { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; in BIT_initDStream()
269 …bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is alway… in BIT_initDStream()
272 bitD->ptr = bitD->start; in BIT_initDStream()
273 bitD->bitContainer = *(const BYTE*)(bitD->start); in BIT_initDStream()
276 …case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContaine… in BIT_initDStream()
279 …case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContaine… in BIT_initDStream()
282 …case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContaine… in BIT_initDStream()
285 case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24; in BIT_initDStream()
288 case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; in BIT_initDStream()
291 case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8; in BIT_initDStream()
296 { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; in BIT_initDStream()
297 bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; in BIT_initDStream()
300 bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; in BIT_initDStream()
306 MEM_STATIC FORCE_INLINE_ATTR size_t BIT_getUpperBits(size_t bitContainer, U32 const start) in BIT_getUpperBits() argument
308 return bitContainer >> start; in BIT_getUpperBits()
311 MEM_STATIC FORCE_INLINE_ATTR size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 con… in BIT_getMiddleBits() argument
313 U32 const regMask = sizeof(bitContainer)*8 - 1; in BIT_getMiddleBits()
314 /* if start > regMask, bitstream is corrupted, and result is undefined */ in BIT_getMiddleBits()
316 /* x86 transform & ((1 << nbBits) - 1) to bzhi instruction, it is better in BIT_getMiddleBits()
318 * such cpus old (pre-Haswell, 2013) and their performance is not of that in BIT_getMiddleBits()
322 return (bitContainer >> (start & regMask)) & ((((U64)1) << nbBits) - 1); in BIT_getMiddleBits()
324 return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; in BIT_getMiddleBits()
337 * On 32-bits, maxNbBits==24.
338 * On 64-bits, maxNbBits==56.
339 * @return : value extracted */
342 /* arbitrate between double-shift and shift+mask */ in BIT_lookBits()
344 /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8, in BIT_lookBits()
346 …return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed -… in BIT_lookBits()
348 /* this code path is slower on my os-x laptop */ in BIT_lookBits()
349 U32 const regMask = sizeof(bitD->bitContainer)*8 - 1; in BIT_lookBits()
350 …return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMas… in BIT_lookBits()
358 U32 const regMask = sizeof(bitD->bitContainer)*8 - 1; in BIT_lookBitsFast()
360 … return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); in BIT_lookBitsFast()
365 bitD->bitsConsumed += nbBits; in BIT_skipBits()
371 * @return : extracted value. */
374 size_t const value = BIT_lookBits(bitD, nbBits); in BIT_readBits() local
376 return value; in BIT_readBits()
383 size_t const value = BIT_lookBitsFast(bitD, nbBits); in BIT_readBitsFast() local
386 return value; in BIT_readBitsFast()
391 * 1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold!
392 * 2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this
397 if (UNLIKELY(bitD->ptr < bitD->limitPtr)) in BIT_reloadDStreamFast()
399 assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8); in BIT_reloadDStreamFast()
400 bitD->ptr -= bitD->bitsConsumed >> 3; in BIT_reloadDStreamFast()
401 bitD->bitsConsumed &= 7; in BIT_reloadDStreamFast()
402 bitD->bitContainer = MEM_readLEST(bitD->ptr); in BIT_reloadDStreamFast()
413 …if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream… in BIT_reloadDStream()
416 if (bitD->ptr >= bitD->limitPtr) { in BIT_reloadDStream()
419 if (bitD->ptr == bitD->start) { in BIT_reloadDStream()
420 if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer; in BIT_reloadDStream()
423 /* start < ptr < limitPtr */ in BIT_reloadDStream()
424 { U32 nbBytes = bitD->bitsConsumed >> 3; in BIT_reloadDStream()
426 if (bitD->ptr - nbBytes < bitD->start) { in BIT_reloadDStream()
427 nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ in BIT_reloadDStream()
430 bitD->ptr -= nbBytes; in BIT_reloadDStream()
431 bitD->bitsConsumed -= nbBytes*8; in BIT_reloadDStream()
432 …bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer)… in BIT_reloadDStream()
442 …return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer… in BIT_endOfDStream()