private static unsafe bool BrotliWarmupBitReader(BrotliBitReader *br)
{
size_t aligned_read_mask = (IntPtr.Size >> 1) - 1;
/* Fixing alignment after unaligned BrotliFillWindow would result accumulator
* overflow. If unalignment is caused by BrotliSafeReadBits, then there is
* enough space in accumulator to fix alignment. */
if (!BROTLI_ALIGNED_READ)
{
aligned_read_mask = 0;
}
if (BrotliGetAvailableBits(br) == 0)
{
if (!BrotliPullByte(br))
{
return(false);
}
}
while ((((size_t)br->next_in) & aligned_read_mask) != 0)
{
if (!BrotliPullByte(br))
{
/* If we consumed all the input, we don't care about the alignment. */
return(true);
}
}
return(true);
}
private static unsafe void BrotliBitReaderRestoreState(
BrotliBitReader *to, BrotliBitReader *from)
{
to->val_ = from->val_;
to->bit_pos_ = from->bit_pos_;
to->next_in = from->next_in;
to->avail_in = from->avail_in;
}
private static unsafe bool BrotliJumpToByteBoundary(BrotliBitReader *br)
{
var pad_bits_count = BrotliGetAvailableBits(br) & 0x7;
uint pad_bits = 0;
if (pad_bits_count != 0)
{
BrotliTakeBits(br, pad_bits_count, &pad_bits);
}
return(pad_bits == 0);
}
/* Tries to read the specified amount of bits. Returns 0, if there is not
* enough input. n_bits MUST be positive. */
private static unsafe bool BrotliSafeReadBits(
BrotliBitReader *br, uint n_bits, uint *val)
{
while (BrotliGetAvailableBits(br) < n_bits)
{
if (!BrotliPullByte(br))
{
return(false);
}
}
BrotliTakeBits(br, n_bits, val);
return(true);
}
private static unsafe bool BrotliSafeGetBits(
BrotliBitReader *br, uint n_bits, uint *val)
{
while (BrotliGetAvailableBits(br) < n_bits)
{
if (!BrotliPullByte(br))
{
return(false);
}
}
*val = (uint)(BrotliGetBitsUnmasked(br) & BitMask(n_bits));
return(true);
}
private static unsafe void BrotliCopyBytes(byte *dest,
BrotliBitReader *br, size_t num)
{
while (BrotliGetAvailableBits(br) >= 8 && num > 0)
{
*dest = (byte)BrotliGetBitsUnmasked(br);
BrotliDropBits(br, 8);
++dest;
--num;
}
memcpy(dest, br->next_in, num);
br->avail_in -= num;
br->next_in += num;
}
private static unsafe void BrotliBitReaderUnload(BrotliBitReader *br)
{
var unused_bytes = BrotliGetAvailableBits(br) >> 3;
var unused_bits = unused_bytes << 3;
br->avail_in += unused_bytes;
br->next_in -= unused_bytes;
if (unused_bits == IntPtr.Size << 3)
{
br->val_ = 0;
}
else
{
br->val_ <<= (int)unused_bits;
}
br->bit_pos_ += unused_bits;
}
private static unsafe bool BrotliPullByte(BrotliBitReader *br)
{
if (br->avail_in == 0)
{
return(false);
}
br->val_ >>= 8;
if (Is64Bit)
{
br->val_ |= ((ulong)*br->next_in) << 56;
}
else
{
br->val_ |= ((uint)*br->next_in) << 24;
}
br->bit_pos_ -= 8;
--br->avail_in;
++br->next_in;
return(true);
}
private static unsafe uint BrotliReadBits(
BrotliBitReader *br, uint n_bits)
{
if (Is64Bit || (n_bits <= 16))
{
uint val;
BrotliFillBitWindow(br, n_bits);
BrotliTakeBits(br, n_bits, &val);
return(val);
}
else
{
uint low_val;
uint high_val;
BrotliFillBitWindow(br, 16);
BrotliTakeBits(br, 16, &low_val);
BrotliFillBitWindow(br, 8);
BrotliTakeBits(br, n_bits - 16, &high_val);
return(low_val | (high_val << 16));
}
}
private static unsafe void BrotliTakeBits(
BrotliBitReader *br, uint n_bits, uint *val)
{
*val = BrotliGetBitsUnmasked(br) & BitMask(n_bits);
BrotliDropBits(br, n_bits);
}
/* Returns amount of unread bytes the bit reader still has buffered from the
* BrotliInput, including whole bytes in br->val_. */
private static unsafe size_t BrotliGetRemainingBytes(BrotliBitReader *br)
{
return(br->avail_in + (BrotliGetAvailableBits(br) >> 3));
}
/* Returns the specified number of bits from |br| without advancing bit pos. */
private static unsafe uint BrotliGetBits(
BrotliBitReader *br, uint n_bits)
{
BrotliFillBitWindow(br, n_bits);
return((uint)(BrotliGetBitsUnmasked(br) & BitMask(n_bits)));
}
private static unsafe uint BrotliGet16BitsUnmasked(
BrotliBitReader *br)
{
BrotliFillBitWindow(br, 16);
return(BrotliGetBitsUnmasked(br));
}
private static unsafe reg_t BrotliGetBitsUnmasked(BrotliBitReader *br)
{
return(br->val_ >> (int)br->bit_pos_);
}
/* Mostly like BrotliFillBitWindow, but guarantees only 16 bits and reads no
* more than BROTLI_SHORT_FILL_BIT_WINDOW_READ bytes of input. */
private static unsafe void BrotliFillBitWindow16(BrotliBitReader *br)
{
BrotliFillBitWindow(br, 17);
}
private static unsafe void BrotliFillBitWindow(
BrotliBitReader *br, uint n_bits)
{
if (Is64Bit)
{
if (!BROTLI_ALIGNED_READ && n_bits != 0 && (n_bits <= 8))
{
if (br->bit_pos_ >= 56)
{
br->val_ >>= 56;
br->bit_pos_ ^= 56; /* here same as -= 56 because of the if condition */
br->val_ |= BrotliLoad64LE(br->next_in) << 8;
br->avail_in -= 7;
br->next_in += 7;
}
}
else if (!BROTLI_ALIGNED_READ && n_bits != 0 && (n_bits <= 16))
{
if (br->bit_pos_ >= 48)
{
br->val_ >>= 48;
br->bit_pos_ ^= 48; /* here same as -= 48 because of the if condition */
br->val_ |= BrotliLoad64LE(br->next_in) << 16;
br->avail_in -= 6;
br->next_in += 6;
}
}
else
{
if (br->bit_pos_ >= 32)
{
br->val_ >>= 32;
br->bit_pos_ ^= 32; /* here same as -= 32 because of the if condition */
br->val_ |= ((ulong)BrotliLoad32LE(br->next_in)) << 32;
br->avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ;
br->next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ;
}
}
}
else
{
if (!BROTLI_ALIGNED_READ && n_bits != 0 && (n_bits <= 8))
{
if (br->bit_pos_ >= 24)
{
br->val_ >>= 24;
br->bit_pos_ ^= 24; /* here same as -= 24 because of the if condition */
br->val_ |= BrotliLoad32LE(br->next_in) << 8;
br->avail_in -= 3;
br->next_in += 3;
}
}
else
{
if (br->bit_pos_ >= 16)
{
br->val_ >>= 16;
br->bit_pos_ ^= 16; /* here same as -= 16 because of the if condition */
br->val_ |= ((uint)BrotliLoad16LE(br->next_in)) << 16;
br->avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ;
br->next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ;
}
}
}
}
private static unsafe uint BrotliGetAvailableBits(BrotliBitReader *br)
{
return((uint)((Is64Bit ? 64 : 32) - br->bit_pos_));
}
/* Advances the bit pos by n_bits. */
private static unsafe void BrotliDropBits(
BrotliBitReader *br, uint n_bits)
{
br->bit_pos_ += n_bits;
}
/* Checks if there is at least |num| bytes left in the input ring-buffer
* (excluding the bits remaining in br->val_). */
private static unsafe bool BrotliCheckInputAmount(
BrotliBitReader *br, size_t num)
{
return(br->avail_in >= num);
}
private static unsafe void BrotliInitBitReader(BrotliBitReader *br)
{
br->val_ = 0;
br->bit_pos_ = (uint)(IntPtr.Size << 3);
}
