/src/mozilla-central/modules/brotli/dec/bit_reader.h

Source (jump to first uncovered line)
/* Copyright 2013 Google Inc. All Rights Reserved.

   Distributed under MIT license.
   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
*/

/* Bit reading helpers */

#ifndef BROTLI_DEC_BIT_READER_H_
#define BROTLI_DEC_BIT_READER_H_

#include <string.h>  /* memcpy */

#include "../common/platform.h"
#include <brotli/types.h>

#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif

#define BROTLI_SHORT_FILL_BIT_WINDOW_READ (sizeof(brotli_reg_t) >> 1)

static const uint32_t kBitMask[33] = {  0x00000000,
    0x00000001, 0x00000003, 0x00000007, 0x0000000F,
    0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF,
    0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF,
    0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF,
    0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF,
    0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF,
    0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF,
    0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF
};

static BROTLI_INLINE uint32_t BitMask(uint32_t n) {
  if (BROTLI_IS_CONSTANT(n) || BROTLI_HAS_UBFX) {
    /* Masking with this expression turns to a single
       "Unsigned Bit Field Extract" UBFX instruction on ARM. */
    return ~((0xFFFFFFFFu) << n);
  } else {
    return kBitMask[n];
  }
}

typedef struct {
  brotli_reg_t val_;       /* pre-fetched bits */
  uint32_t bit_pos_;       /* current bit-reading position in val_ */
  const uint8_t* next_in;  /* the byte we're reading from */
  size_t avail_in;
} BrotliBitReader;

typedef struct {
  brotli_reg_t val_;
  uint32_t bit_pos_;
  const uint8_t* next_in;
  size_t avail_in;
} BrotliBitReaderState;

/* Initializes the BrotliBitReader fields. */
BROTLI_INTERNAL void BrotliInitBitReader(BrotliBitReader* const br);

/* Ensures that accumulator is not empty.
   May consume up to sizeof(brotli_reg_t) - 1 bytes of input.
   Returns BROTLI_FALSE if data is required but there is no input available.
   For BROTLI_ALIGNED_READ this function also prepares bit reader for aligned
   reading. */
BROTLI_INTERNAL BROTLI_BOOL BrotliWarmupBitReader(BrotliBitReader* const br);

static BROTLI_INLINE void BrotliBitReaderSaveState(
    BrotliBitReader* const from, BrotliBitReaderState* to) {
  to->val_ = from->val_;
  to->bit_pos_ = from->bit_pos_;
  to->next_in = from->next_in;
  to->avail_in = from->avail_in;
}

static BROTLI_INLINE void BrotliBitReaderRestoreState(
    BrotliBitReader* const to, BrotliBitReaderState* from) {
  to->val_ = from->val_;
  to->bit_pos_ = from->bit_pos_;
  to->next_in = from->next_in;
  to->avail_in = from->avail_in;
}

static BROTLI_INLINE uint32_t BrotliGetAvailableBits(
    const BrotliBitReader* br) {
  return (BROTLI_64_BITS ? 64 : 32) - br->bit_pos_;
}

/* Returns amount of unread bytes the bit reader still has buffered from the
   BrotliInput, including whole bytes in br->val_. */
static BROTLI_INLINE size_t BrotliGetRemainingBytes(BrotliBitReader* br) {
  return br->avail_in + (BrotliGetAvailableBits(br) >> 3);
}

/* Checks if there is at least |num| bytes left in the input ring-buffer
   (excluding the bits remaining in br->val_). */
static BROTLI_INLINE BROTLI_BOOL BrotliCheckInputAmount(
    BrotliBitReader* const br, size_t num) {
  return TO_BROTLI_BOOL(br->avail_in >= num);
}

/* Guarantees that there are at least |n_bits| + 1 bits in accumulator.
   Precondition: accumulator contains at least 1 bit.
   |n_bits| should be in the range [1..24] for regular build. For portable
   non-64-bit little-endian build only 16 bits are safe to request. */
static BROTLI_INLINE void BrotliFillBitWindow(
    BrotliBitReader* const br, uint32_t n_bits) {
#if (BROTLI_64_BITS)
  if (!BROTLI_ALIGNED_READ && BROTLI_IS_CONSTANT(n_bits) && (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_ |= BROTLI_UNALIGNED_LOAD64LE(br->next_in) << 8;
      br->avail_in -= 7;
      br->next_in += 7;
    }
  } else if (
      !BROTLI_ALIGNED_READ && BROTLI_IS_CONSTANT(n_bits) && (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_ |= BROTLI_UNALIGNED_LOAD64LE(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_ |= ((uint64_t)BROTLI_UNALIGNED_LOAD32LE(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 && BROTLI_IS_CONSTANT(n_bits) && (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_ |= BROTLI_UNALIGNED_LOAD32LE(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_ |= ((uint32_t)BROTLI_UNALIGNED_LOAD16LE(br->next_in)) << 16;
      br->avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ;
      br->next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ;
    }
  }
#endif
}

/* Mostly like BrotliFillBitWindow, but guarantees only 16 bits and reads no
   more than BROTLI_SHORT_FILL_BIT_WINDOW_READ bytes of input. */
static BROTLI_INLINE void BrotliFillBitWindow16(BrotliBitReader* const br) {
  BrotliFillBitWindow(br, 17);
}

/* Tries to pull one byte of input to accumulator.
   Returns BROTLI_FALSE if there is no input available. */
static BROTLI_INLINE BROTLI_BOOL BrotliPullByte(BrotliBitReader* const br) {
  if (br->avail_in == 0) {
    return BROTLI_FALSE;
  }
  br->val_ >>= 8;
#if (BROTLI_64_BITS)
  br->val_ |= ((uint64_t)*br->next_in) << 56;
#else
  br->val_ |= ((uint32_t)*br->next_in) << 24;
#endif
  br->bit_pos_ -= 8;
  --br->avail_in;
  ++br->next_in;
  return BROTLI_TRUE;
}

/* Returns currently available bits.
   The number of valid bits could be calculated by BrotliGetAvailableBits. */
static BROTLI_INLINE brotli_reg_t BrotliGetBitsUnmasked(
    BrotliBitReader* const br) {
  return br->val_ >> br->bit_pos_;
}

/* Like BrotliGetBits, but does not mask the result.
   The result contains at least 16 valid bits. */
static BROTLI_INLINE uint32_t BrotliGet16BitsUnmasked(
    BrotliBitReader* const br) {
  BrotliFillBitWindow(br, 16);
  return (uint32_t)BrotliGetBitsUnmasked(br);
}

/* Returns the specified number of bits from |br| without advancing bit
   position. */
static BROTLI_INLINE uint32_t BrotliGetBits(
    BrotliBitReader* const br, uint32_t n_bits) {
  BrotliFillBitWindow(br, n_bits);
  return (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
}

/* Tries to peek the specified amount of bits. Returns BROTLI_FALSE, if there
   is not enough input. */
static BROTLI_INLINE BROTLI_BOOL BrotliSafeGetBits(
    BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
  while (BrotliGetAvailableBits(br) < n_bits) {
    if (!BrotliPullByte(br)) {
      return BROTLI_FALSE;
    }
  }
  *val = (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
  return BROTLI_TRUE;
}

/* Advances the bit pos by |n_bits|. */
static BROTLI_INLINE void BrotliDropBits(
    BrotliBitReader* const br, uint32_t n_bits) {
  br->bit_pos_ += n_bits;
}

static BROTLI_INLINE void BrotliBitReaderUnload(BrotliBitReader* br) {
  uint32_t unused_bytes = BrotliGetAvailableBits(br) >> 3;
  uint32_t unused_bits = unused_bytes << 3;
  br->avail_in += unused_bytes;
  br->next_in -= unused_bytes;
  if (unused_bits == sizeof(br->val_) << 3) {
    br->val_ = 0;
  } else {
    br->val_ <<= unused_bits;
  }
  br->bit_pos_ += unused_bits;
}

/* Reads the specified number of bits from |br| and advances the bit pos.
   Precondition: accumulator MUST contain at least |n_bits|. */
static BROTLI_INLINE void BrotliTakeBits(
  BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
  *val = (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
  BROTLI_LOG(("[BrotliReadBits]  %d %d %d val: %6x\n",
      (int)br->avail_in, (int)br->bit_pos_, (int)n_bits, (int)*val));
  BrotliDropBits(br, n_bits);
}

/* Reads the specified number of bits from |br| and advances the bit pos.
   Assumes that there is enough input to perform BrotliFillBitWindow. */
static BROTLI_INLINE uint32_t BrotliReadBits(
    BrotliBitReader* const br, uint32_t n_bits) {
  if (BROTLI_64_BITS || (n_bits <= 16)) {
    uint32_t val;
    BrotliFillBitWindow(br, n_bits);
    BrotliTakeBits(br, n_bits, &val);
    return val;
  } else {
    uint32_t low_val;
    uint32_t 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);
  }
}

/* Tries to read the specified amount of bits. Returns BROTLI_FALSE, if there
   is not enough input. |n_bits| MUST be positive. */
static BROTLI_INLINE BROTLI_BOOL BrotliSafeReadBits(
    BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
  while (BrotliGetAvailableBits(br) < n_bits) {
    if (!BrotliPullByte(br)) {
      return BROTLI_FALSE;
    }
  }
  BrotliTakeBits(br, n_bits, val);
  return BROTLI_TRUE;
}

/* Advances the bit reader position to the next byte boundary and verifies
   that any skipped bits are set to zero. */
static BROTLI_INLINE BROTLI_BOOL BrotliJumpToByteBoundary(BrotliBitReader* br) {
  uint32_t pad_bits_count = BrotliGetAvailableBits(br) & 0x7;
  uint32_t pad_bits = 0;
  if (pad_bits_count != 0) {
    BrotliTakeBits(br, pad_bits_count, &pad_bits);
  }
  return TO_BROTLI_BOOL(pad_bits == 0);
}

/* Copies remaining input bytes stored in the bit reader to the output. Value
   |num| may not be larger than BrotliGetRemainingBytes. The bit reader must be
   warmed up again after this. */
static BROTLI_INLINE void BrotliCopyBytes(uint8_t* dest,
                                          BrotliBitReader* br, size_t num) {
  while (BrotliGetAvailableBits(br) >= 8 && num > 0) {
    *dest = (uint8_t)BrotliGetBitsUnmasked(br);
    BrotliDropBits(br, 8);
    ++dest;
    --num;
  }
  memcpy(dest, br->next_in, num);
  br->avail_in -= num;
  br->next_in += num;
}

#if defined(__cplusplus) || defined(c_plusplus)
}  /* extern "C" */
#endif

#endif  /* BROTLI_DEC_BIT_READER_H_ */

Coverage Report

Created: 2018-09-25 14:53

Line	Count	Source (jump to first uncovered line)
1		/* Copyright 2013 Google Inc. All Rights Reserved.
2
3		Distributed under MIT license.
4		See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
5		*/
6
7		/* Bit reading helpers */
8
9		#ifndef BROTLI_DEC_BIT_READER_H_
10		#define BROTLI_DEC_BIT_READER_H_
11
12		#include <string.h> /* memcpy */
13
14		#include "../common/platform.h"
15		#include <brotli/types.h>
16
17		#if defined(__cplusplus) \|\| defined(c_plusplus)
18		extern "C" {
19		#endif
20
21	0	#define BROTLI_SHORT_FILL_BIT_WINDOW_READ (sizeof(brotli_reg_t) >> 1)
22
23		static const uint32_t kBitMask[33] = { 0x00000000,
24		0x00000001, 0x00000003, 0x00000007, 0x0000000F,
25		0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF,
26		0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF,
27		0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF,
28		0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF,
29		0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF,
30		0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF,
31		0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF
32		};
33
34	0	static BROTLI_INLINE uint32_t BitMask(uint32_t n) {
35	0	if (BROTLI_IS_CONSTANT(n) \|\| BROTLI_HAS_UBFX) {
36	0	/* Masking with this expression turns to a single
37	0	"Unsigned Bit Field Extract" UBFX instruction on ARM. */
38	0	return ~((0xFFFFFFFFu) << n);
39	0	} else {
40	0	return kBitMask[n];
41	0	}
42	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BitMask(unsigned int) Unexecuted instantiation: nsNetModule.cpp:BitMask(unsigned int) Unexecuted instantiation: Unified_c_modules_brotli0.c:BitMask
43
44		typedef struct {
45		brotli_reg_t val_; /* pre-fetched bits */
46		uint32_t bit_pos_; /* current bit-reading position in val_ */
47		const uint8_t* next_in; /* the byte we're reading from */
48		size_t avail_in;
49		} BrotliBitReader;
50
51		typedef struct {
52		brotli_reg_t val_;
53		uint32_t bit_pos_;
54		const uint8_t* next_in;
55		size_t avail_in;
56		} BrotliBitReaderState;
57
58		/* Initializes the BrotliBitReader fields. */
59		BROTLI_INTERNAL void BrotliInitBitReader(BrotliBitReader* const br);
60
61		/* Ensures that accumulator is not empty.
62		May consume up to sizeof(brotli_reg_t) - 1 bytes of input.
63		Returns BROTLI_FALSE if data is required but there is no input available.
64		For BROTLI_ALIGNED_READ this function also prepares bit reader for aligned
65		reading. */
66		BROTLI_INTERNAL BROTLI_BOOL BrotliWarmupBitReader(BrotliBitReader* const br);
67
68		static BROTLI_INLINE void BrotliBitReaderSaveState(
69	0	BrotliBitReader* const from, BrotliBitReaderState* to) {
70	0	to->val_ = from->val_;
71	0	to->bit_pos_ = from->bit_pos_;
72	0	to->next_in = from->next_in;
73	0	to->avail_in = from->avail_in;
74	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliBitReaderSaveState(BrotliBitReader, BrotliBitReaderState) Unexecuted instantiation: nsNetModule.cpp:BrotliBitReaderSaveState(BrotliBitReader, BrotliBitReaderState) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliBitReaderSaveState
75
76		static BROTLI_INLINE void BrotliBitReaderRestoreState(
77	0	BrotliBitReader* const to, BrotliBitReaderState* from) {
78	0	to->val_ = from->val_;
79	0	to->bit_pos_ = from->bit_pos_;
80	0	to->next_in = from->next_in;
81	0	to->avail_in = from->avail_in;
82	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliBitReaderRestoreState(BrotliBitReader, BrotliBitReaderState) Unexecuted instantiation: nsNetModule.cpp:BrotliBitReaderRestoreState(BrotliBitReader, BrotliBitReaderState) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliBitReaderRestoreState
83
84		static BROTLI_INLINE uint32_t BrotliGetAvailableBits(
85	0	const BrotliBitReader* br) {
86	0	return (BROTLI_64_BITS ? 64 : 32) - br->bit_pos_;
87	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliGetAvailableBits(BrotliBitReader const) Unexecuted instantiation: nsNetModule.cpp:BrotliGetAvailableBits(BrotliBitReader const) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliGetAvailableBits
88
89		/* Returns amount of unread bytes the bit reader still has buffered from the
90		BrotliInput, including whole bytes in br->val_. */
91	0	static BROTLI_INLINE size_t BrotliGetRemainingBytes(BrotliBitReader* br) {
92	0	return br->avail_in + (BrotliGetAvailableBits(br) >> 3);
93	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliGetRemainingBytes(BrotliBitReader) Unexecuted instantiation: nsNetModule.cpp:BrotliGetRemainingBytes(BrotliBitReader) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliGetRemainingBytes
94
95		/* Checks if there is at least \|num\| bytes left in the input ring-buffer
96		(excluding the bits remaining in br->val_). */
97		static BROTLI_INLINE BROTLI_BOOL BrotliCheckInputAmount(
98	0	BrotliBitReader* const br, size_t num) {
99	0	return TO_BROTLI_BOOL(br->avail_in >= num);
100	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliCheckInputAmount(BrotliBitReader, unsigned long) Unexecuted instantiation: nsNetModule.cpp:BrotliCheckInputAmount(BrotliBitReader, unsigned long) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliCheckInputAmount
101
102		/* Guarantees that there are at least \|n_bits\| + 1 bits in accumulator.
103		Precondition: accumulator contains at least 1 bit.
104		\|n_bits\| should be in the range [1..24] for regular build. For portable
105		non-64-bit little-endian build only 16 bits are safe to request. */
106		static BROTLI_INLINE void BrotliFillBitWindow(
107	0	BrotliBitReader* const br, uint32_t n_bits) {
108	0	#if (BROTLI_64_BITS)
109	0	if (!BROTLI_ALIGNED_READ && BROTLI_IS_CONSTANT(n_bits) && (n_bits <= 8)) {
110	0	if (br->bit_pos_ >= 56) {
111	0	br->val_ >>= 56;
112	0	br->bit_pos_ ^= 56; /* here same as -= 56 because of the if condition */
113	0	br->val_ \|= BROTLI_UNALIGNED_LOAD64LE(br->next_in) << 8;
114	0	br->avail_in -= 7;
115	0	br->next_in += 7;
116	0	}
117	0	} else if (
118	0	!BROTLI_ALIGNED_READ && BROTLI_IS_CONSTANT(n_bits) && (n_bits <= 16)) {
119	0	if (br->bit_pos_ >= 48) {
120	0	br->val_ >>= 48;
121	0	br->bit_pos_ ^= 48; /* here same as -= 48 because of the if condition */
122	0	br->val_ \|= BROTLI_UNALIGNED_LOAD64LE(br->next_in) << 16;
123	0	br->avail_in -= 6;
124	0	br->next_in += 6;
125	0	}
126	0	} else {
127	0	if (br->bit_pos_ >= 32) {
128	0	br->val_ >>= 32;
129	0	br->bit_pos_ ^= 32; /* here same as -= 32 because of the if condition */
130	0	br->val_ \|= ((uint64_t)BROTLI_UNALIGNED_LOAD32LE(br->next_in)) << 32;
131	0	br->avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ;
132	0	br->next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ;
133	0	}
134	0	}
135		#else
136		if (!BROTLI_ALIGNED_READ && BROTLI_IS_CONSTANT(n_bits) && (n_bits <= 8)) {
137		if (br->bit_pos_ >= 24) {
138		br->val_ >>= 24;
139		br->bit_pos_ ^= 24; /* here same as -= 24 because of the if condition */
140		br->val_ \|= BROTLI_UNALIGNED_LOAD32LE(br->next_in) << 8;
141		br->avail_in -= 3;
142		br->next_in += 3;
143		}
144		} else {
145		if (br->bit_pos_ >= 16) {
146		br->val_ >>= 16;
147		br->bit_pos_ ^= 16; /* here same as -= 16 because of the if condition */
148		br->val_ \|= ((uint32_t)BROTLI_UNALIGNED_LOAD16LE(br->next_in)) << 16;
149		br->avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ;
150		br->next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ;
151		}
152		}
153		#endif
154		} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliFillBitWindow(BrotliBitReader, unsigned int) Unexecuted instantiation: nsNetModule.cpp:BrotliFillBitWindow(BrotliBitReader, unsigned int) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliFillBitWindow
155
156		/* Mostly like BrotliFillBitWindow, but guarantees only 16 bits and reads no
157		more than BROTLI_SHORT_FILL_BIT_WINDOW_READ bytes of input. */
158	0	static BROTLI_INLINE void BrotliFillBitWindow16(BrotliBitReader* const br) {
159	0	BrotliFillBitWindow(br, 17);
160	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliFillBitWindow16(BrotliBitReader) Unexecuted instantiation: nsNetModule.cpp:BrotliFillBitWindow16(BrotliBitReader) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliFillBitWindow16
161
162		/* Tries to pull one byte of input to accumulator.
163		Returns BROTLI_FALSE if there is no input available. */
164	0	static BROTLI_INLINE BROTLI_BOOL BrotliPullByte(BrotliBitReader* const br) {
165	0	if (br->avail_in == 0) {
166	0	return BROTLI_FALSE;
167	0	}
168	0	br->val_ >>= 8;
169	0	#if (BROTLI_64_BITS)
170	0	br->val_ \|= ((uint64_t)*br->next_in) << 56;
171		#else
172		br->val_ \|= ((uint32_t)*br->next_in) << 24;
173		#endif
174		br->bit_pos_ -= 8;
175	0	--br->avail_in;
176	0	++br->next_in;
177	0	return BROTLI_TRUE;
178	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliPullByte(BrotliBitReader) Unexecuted instantiation: nsNetModule.cpp:BrotliPullByte(BrotliBitReader) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliPullByte
179
180		/* Returns currently available bits.
181		The number of valid bits could be calculated by BrotliGetAvailableBits. */
182		static BROTLI_INLINE brotli_reg_t BrotliGetBitsUnmasked(
183	0	BrotliBitReader* const br) {
184	0	return br->val_ >> br->bit_pos_;
185	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliGetBitsUnmasked(BrotliBitReader) Unexecuted instantiation: nsNetModule.cpp:BrotliGetBitsUnmasked(BrotliBitReader) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliGetBitsUnmasked
186
187		/* Like BrotliGetBits, but does not mask the result.
188		The result contains at least 16 valid bits. */
189		static BROTLI_INLINE uint32_t BrotliGet16BitsUnmasked(
190	0	BrotliBitReader* const br) {
191	0	BrotliFillBitWindow(br, 16);
192	0	return (uint32_t)BrotliGetBitsUnmasked(br);
193	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliGet16BitsUnmasked(BrotliBitReader) Unexecuted instantiation: nsNetModule.cpp:BrotliGet16BitsUnmasked(BrotliBitReader) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliGet16BitsUnmasked
194
195		/* Returns the specified number of bits from \|br\| without advancing bit
196		position. */
197		static BROTLI_INLINE uint32_t BrotliGetBits(
198	0	BrotliBitReader* const br, uint32_t n_bits) {
199	0	BrotliFillBitWindow(br, n_bits);
200	0	return (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
201	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliGetBits(BrotliBitReader, unsigned int) Unexecuted instantiation: nsNetModule.cpp:BrotliGetBits(BrotliBitReader, unsigned int) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliGetBits
202
203		/* Tries to peek the specified amount of bits. Returns BROTLI_FALSE, if there
204		is not enough input. */
205		static BROTLI_INLINE BROTLI_BOOL BrotliSafeGetBits(
206	0	BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
207	0	while (BrotliGetAvailableBits(br) < n_bits) {
208	0	if (!BrotliPullByte(br)) {
209	0	return BROTLI_FALSE;
210	0	}
211	0	}
212	0	*val = (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
213	0	return BROTLI_TRUE;
214	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliSafeGetBits(BrotliBitReader, unsigned int, unsigned int) Unexecuted instantiation: nsNetModule.cpp:BrotliSafeGetBits(BrotliBitReader, unsigned int, unsigned int) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliSafeGetBits
215
216		/* Advances the bit pos by \|n_bits\|. */
217		static BROTLI_INLINE void BrotliDropBits(
218	0	BrotliBitReader* const br, uint32_t n_bits) {
219	0	br->bit_pos_ += n_bits;
220	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliDropBits(BrotliBitReader, unsigned int) Unexecuted instantiation: nsNetModule.cpp:BrotliDropBits(BrotliBitReader, unsigned int) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliDropBits
221
222	0	static BROTLI_INLINE void BrotliBitReaderUnload(BrotliBitReader* br) {
223	0	uint32_t unused_bytes = BrotliGetAvailableBits(br) >> 3;
224	0	uint32_t unused_bits = unused_bytes << 3;
225	0	br->avail_in += unused_bytes;
226	0	br->next_in -= unused_bytes;
227	0	if (unused_bits == sizeof(br->val_) << 3) {
228	0	br->val_ = 0;
229	0	} else {
230	0	br->val_ <<= unused_bits;
231	0	}
232	0	br->bit_pos_ += unused_bits;
233	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliBitReaderUnload(BrotliBitReader) Unexecuted instantiation: nsNetModule.cpp:BrotliBitReaderUnload(BrotliBitReader) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliBitReaderUnload
234
235		/* Reads the specified number of bits from \|br\| and advances the bit pos.
236		Precondition: accumulator MUST contain at least \|n_bits\|. */
237		static BROTLI_INLINE void BrotliTakeBits(
238	0	BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
239	0	*val = (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
240	0	BROTLI_LOG(("[BrotliReadBits] %d %d %d val: %6x\n",
241	0	(int)br->avail_in, (int)br->bit_pos_, (int)n_bits, (int)*val));
242	0	BrotliDropBits(br, n_bits);
243	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliTakeBits(BrotliBitReader, unsigned int, unsigned int) Unexecuted instantiation: nsNetModule.cpp:BrotliTakeBits(BrotliBitReader, unsigned int, unsigned int) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliTakeBits
244
245		/* Reads the specified number of bits from \|br\| and advances the bit pos.
246		Assumes that there is enough input to perform BrotliFillBitWindow. */
247		static BROTLI_INLINE uint32_t BrotliReadBits(
248	0	BrotliBitReader* const br, uint32_t n_bits) {
249	0	if (BROTLI_64_BITS \|\| (n_bits <= 16)) {
250	0	uint32_t val;
251	0	BrotliFillBitWindow(br, n_bits);
252	0	BrotliTakeBits(br, n_bits, &val);
253	0	return val;
254	0	} else {
255	0	uint32_t low_val;
256	0	uint32_t high_val;
257	0	BrotliFillBitWindow(br, 16);
258	0	BrotliTakeBits(br, 16, &low_val);
259	0	BrotliFillBitWindow(br, 8);
260	0	BrotliTakeBits(br, n_bits - 16, &high_val);
261	0	return low_val \| (high_val << 16);
262	0	}
263	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliReadBits(BrotliBitReader, unsigned int) Unexecuted instantiation: nsNetModule.cpp:BrotliReadBits(BrotliBitReader, unsigned int) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliReadBits
264
265		/* Tries to read the specified amount of bits. Returns BROTLI_FALSE, if there
266		is not enough input. \|n_bits\| MUST be positive. */
267		static BROTLI_INLINE BROTLI_BOOL BrotliSafeReadBits(
268	0	BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
269	0	while (BrotliGetAvailableBits(br) < n_bits) {
270	0	if (!BrotliPullByte(br)) {
271	0	return BROTLI_FALSE;
272	0	}
273	0	}
274	0	BrotliTakeBits(br, n_bits, val);
275	0	return BROTLI_TRUE;
276	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliSafeReadBits(BrotliBitReader, unsigned int, unsigned int) Unexecuted instantiation: nsNetModule.cpp:BrotliSafeReadBits(BrotliBitReader, unsigned int, unsigned int) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliSafeReadBits
277
278		/* Advances the bit reader position to the next byte boundary and verifies
279		that any skipped bits are set to zero. */
280	0	static BROTLI_INLINE BROTLI_BOOL BrotliJumpToByteBoundary(BrotliBitReader* br) {
281	0	uint32_t pad_bits_count = BrotliGetAvailableBits(br) & 0x7;
282	0	uint32_t pad_bits = 0;
283	0	if (pad_bits_count != 0) {
284	0	BrotliTakeBits(br, pad_bits_count, &pad_bits);
285	0	}
286	0	return TO_BROTLI_BOOL(pad_bits == 0);
287	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliJumpToByteBoundary(BrotliBitReader) Unexecuted instantiation: nsNetModule.cpp:BrotliJumpToByteBoundary(BrotliBitReader) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliJumpToByteBoundary
288
289		/* Copies remaining input bytes stored in the bit reader to the output. Value
290		\|num\| may not be larger than BrotliGetRemainingBytes. The bit reader must be
291		warmed up again after this. */
292		static BROTLI_INLINE void BrotliCopyBytes(uint8_t* dest,
293	0	BrotliBitReader* br, size_t num) {
294	0	while (BrotliGetAvailableBits(br) >= 8 && num > 0) {
295	0	*dest = (uint8_t)BrotliGetBitsUnmasked(br);
296	0	BrotliDropBits(br, 8);
297	0	++dest;
298	0	--num;
299	0	}
300	0	memcpy(dest, br->next_in, num);
301	0	br->avail_in -= num;
302	0	br->next_in += num;
303	0	} Unexecuted instantiation: Unified_cpp_converters0.cpp:BrotliCopyBytes(unsigned char, BrotliBitReader, unsigned long) Unexecuted instantiation: nsNetModule.cpp:BrotliCopyBytes(unsigned char, BrotliBitReader, unsigned long) Unexecuted instantiation: Unified_c_modules_brotli0.c:BrotliCopyBytes
304
305		#if defined(__cplusplus) \|\| defined(c_plusplus)
306		} /* extern "C" */
307		#endif
308
309		#endif /* BROTLI_DEC_BIT_READER_H_ */