Lines Matching +full:link +full:- +full:signal +full:- +full:sources
1 /* SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause */
8 * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
10 * This source code is licensed under both the BSD-style license (found in the
13 * You may select, at your option, one of the above-listed licenses.
20 * Since link-time-optimization is not available for all compilers,
24 /*-****************************************
42 /*-******************************************
46 /* bitStream can mix input from multiple sources.
65 * `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code.
68 * Local register is BitContainerType, 64-bits on 64-bits systems, or 32-bits on 32-bits systems.
73 * Avoid storing elements of more than 24 bits if you want compatibility with 32-bits bitstream rea…
81 /*-********************************************
94 BIT_DStream_completed = 2, /* bitstream entirely consumed, bit-exact */
106 * Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (BitContainerType).
109 * A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_D…
115 /*-****************************************
137 /*-**************************************************************
147 bitC->bitContainer = 0; in BIT_initCStream()
148 bitC->bitPos = 0; in BIT_initCStream()
149 bitC->startPtr = (char*)startPtr; in BIT_initCStream()
150 bitC->ptr = bitC->startPtr; in BIT_initCStream()
151 bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContainer); in BIT_initCStream()
152 if (dstCapacity <= sizeof(bitC->bitContainer)) return ERROR(dstSize_tooSmall); in BIT_initCStream()
170 assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8); in BIT_addBits()
171 bitC->bitContainer |= BIT_getLowerBits(value, nbBits) << bitC->bitPos; in BIT_addBits()
172 bitC->bitPos += nbBits; in BIT_addBits()
182 assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8); in BIT_addBitsFast()
183 bitC->bitContainer |= value << bitC->bitPos; in BIT_addBitsFast()
184 bitC->bitPos += nbBits; in BIT_addBitsFast()
192 size_t const nbBytes = bitC->bitPos >> 3; in BIT_flushBitsFast()
193 assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8); in BIT_flushBitsFast()
194 assert(bitC->ptr <= bitC->endPtr); in BIT_flushBitsFast()
195 MEM_writeLEST(bitC->ptr, bitC->bitContainer); in BIT_flushBitsFast()
196 bitC->ptr += nbBytes; in BIT_flushBitsFast()
197 bitC->bitPos &= 7; in BIT_flushBitsFast()
198 bitC->bitContainer >>= nbBytes*8; in BIT_flushBitsFast()
204 * note : does not signal buffer overflow.
208 size_t const nbBytes = bitC->bitPos >> 3; in BIT_flushBits()
209 assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8); in BIT_flushBits()
210 assert(bitC->ptr <= bitC->endPtr); in BIT_flushBits()
211 MEM_writeLEST(bitC->ptr, bitC->bitContainer); in BIT_flushBits()
212 bitC->ptr += nbBytes; in BIT_flushBits()
213 if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr; in BIT_flushBits()
214 bitC->bitPos &= 7; in BIT_flushBits()
215 bitC->bitContainer >>= nbBytes*8; in BIT_flushBits()
225 if (bitC->ptr >= bitC->endPtr) return 0; /* overflow detected */ in BIT_closeCStream()
226 return (size_t)(bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0); in BIT_closeCStream()
230 /*-********************************************************
243 bitD->start = (const char*)srcBuffer; in BIT_initDStream()
244 bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer); in BIT_initDStream()
246 if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */ in BIT_initDStream()
247 bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer); in BIT_initDStream()
248 bitD->bitContainer = MEM_readLEST(bitD->ptr); in BIT_initDStream()
249 { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; in BIT_initDStream()
250 …bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0; /* ensures bitsConsumed is alwa… in BIT_initDStream()
253 bitD->ptr = bitD->start; in BIT_initDStream()
254 bitD->bitContainer = *(const BYTE*)(bitD->start); in BIT_initDStream()
257 …case 7: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->b… in BIT_initDStream()
260 …case 6: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->b… in BIT_initDStream()
263 …case 5: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->b… in BIT_initDStream()
266 case 4: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[3]) << 24; in BIT_initDStream()
269 case 3: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[2]) << 16; in BIT_initDStream()
272 case 2: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[1]) << 8; in BIT_initDStream()
277 { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; in BIT_initDStream()
278 bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0; in BIT_initDStream()
281 bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; in BIT_initDStream()
294 U32 const regMask = sizeof(bitContainer)*8 - 1; in BIT_getMiddleBits()
297 /* x86 transform & ((1 << nbBits) - 1) to bzhi instruction, it is better in BIT_getMiddleBits()
299 * such cpus old (pre-Haswell, 2013) and their performance is not of that in BIT_getMiddleBits()
303 return (bitContainer >> (start & regMask)) & ((((U64)1) << nbBits) - 1); in BIT_getMiddleBits()
312 * On 32-bits, maxNbBits==24.
313 * On 64-bits, maxNbBits==56.
317 /* arbitrate between double-shift and shift+mask */ in BIT_lookBits()
319 /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8, in BIT_lookBits()
321 …return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed -… in BIT_lookBits()
323 /* this code path is slower on my os-x laptop */ in BIT_lookBits()
324 U32 const regMask = sizeof(bitD->bitContainer)*8 - 1; in BIT_lookBits()
325 …return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMas… in BIT_lookBits()
333 U32 const regMask = sizeof(bitD->bitContainer)*8 - 1; in BIT_lookBitsFast()
335 … return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); in BIT_lookBitsFast()
340 bitD->bitsConsumed += nbBits; in BIT_skipBits()
366 * 1. bitstream is valid : bitsConsumed <= sizeof(bitD->bitContainer)*8
367 * 2. look window is valid after shifted down : bitD->ptr >= bitD->start
371 assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8); in BIT_reloadDStream_internal()
372 bitD->ptr -= bitD->bitsConsumed >> 3; in BIT_reloadDStream_internal()
373 assert(bitD->ptr >= bitD->start); in BIT_reloadDStream_internal()
374 bitD->bitsConsumed &= 7; in BIT_reloadDStream_internal()
375 bitD->bitContainer = MEM_readLEST(bitD->ptr); in BIT_reloadDStream_internal()
381 * 1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold!
382 * 2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this
387 if (UNLIKELY(bitD->ptr < bitD->limitPtr)) in BIT_reloadDStreamFast()
400 if (UNLIKELY(bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))) { in BIT_reloadDStream()
402 bitD->ptr = (const char*)&zeroFilled; /* aliasing is allowed for char */ in BIT_reloadDStream()
407 assert(bitD->ptr >= bitD->start); in BIT_reloadDStream()
409 if (bitD->ptr >= bitD->limitPtr) { in BIT_reloadDStream()
412 if (bitD->ptr == bitD->start) { in BIT_reloadDStream()
414 if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer; in BIT_reloadDStream()
418 { U32 nbBytes = bitD->bitsConsumed >> 3; in BIT_reloadDStream()
420 if (bitD->ptr - nbBytes < bitD->start) { in BIT_reloadDStream()
421 nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ in BIT_reloadDStream()
424 bitD->ptr -= nbBytes; in BIT_reloadDStream()
425 bitD->bitsConsumed -= nbBytes*8; in BIT_reloadDStream()
426 …bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer)… in BIT_reloadDStream()
436 …return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer… in BIT_endOfDStream()