isomorfeus-ferret 0.12.6 → 0.12.7

Sign up to get free protection for your applications and to get access to all the features.
Files changed (97) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +1 -4
  3. data/ext/isomorfeus_ferret_ext/brotli_common_constants.c +15 -0
  4. data/ext/isomorfeus_ferret_ext/brotli_common_constants.h +200 -0
  5. data/ext/isomorfeus_ferret_ext/brotli_common_context.c +156 -0
  6. data/ext/isomorfeus_ferret_ext/brotli_common_context.h +113 -0
  7. data/ext/isomorfeus_ferret_ext/brotli_common_dictionary.c +5914 -0
  8. data/ext/isomorfeus_ferret_ext/brotli_common_dictionary.h +64 -0
  9. data/ext/isomorfeus_ferret_ext/brotli_common_platform.c +22 -0
  10. data/ext/isomorfeus_ferret_ext/brotli_common_platform.h +594 -0
  11. data/ext/isomorfeus_ferret_ext/brotli_common_transform.c +291 -0
  12. data/ext/isomorfeus_ferret_ext/brotli_common_transform.h +85 -0
  13. data/ext/isomorfeus_ferret_ext/brotli_common_version.h +26 -0
  14. data/ext/isomorfeus_ferret_ext/brotli_dec_bit_reader.c +76 -0
  15. data/ext/isomorfeus_ferret_ext/brotli_dec_bit_reader.h +351 -0
  16. data/ext/isomorfeus_ferret_ext/brotli_dec_decode.c +2608 -0
  17. data/ext/isomorfeus_ferret_ext/brotli_dec_huffman.c +339 -0
  18. data/ext/isomorfeus_ferret_ext/brotli_dec_huffman.h +121 -0
  19. data/ext/isomorfeus_ferret_ext/brotli_dec_prefix.h +732 -0
  20. data/ext/isomorfeus_ferret_ext/brotli_dec_state.c +159 -0
  21. data/ext/isomorfeus_ferret_ext/brotli_dec_state.h +365 -0
  22. data/ext/isomorfeus_ferret_ext/brotli_decode.h +344 -0
  23. data/ext/isomorfeus_ferret_ext/brotli_enc_backward_references.c +145 -0
  24. data/ext/isomorfeus_ferret_ext/brotli_enc_backward_references.h +39 -0
  25. data/ext/isomorfeus_ferret_ext/brotli_enc_backward_references_hq.c +843 -0
  26. data/ext/isomorfeus_ferret_ext/brotli_enc_backward_references_hq.h +95 -0
  27. data/ext/isomorfeus_ferret_ext/brotli_enc_backward_references_inc.h +163 -0
  28. data/ext/isomorfeus_ferret_ext/brotli_enc_bit_cost.c +35 -0
  29. data/ext/isomorfeus_ferret_ext/brotli_enc_bit_cost.h +63 -0
  30. data/ext/isomorfeus_ferret_ext/brotli_enc_bit_cost_inc.h +127 -0
  31. data/ext/isomorfeus_ferret_ext/brotli_enc_block_encoder_inc.h +34 -0
  32. data/ext/isomorfeus_ferret_ext/brotli_enc_block_splitter.c +194 -0
  33. data/ext/isomorfeus_ferret_ext/brotli_enc_block_splitter.h +51 -0
  34. data/ext/isomorfeus_ferret_ext/brotli_enc_block_splitter_inc.h +440 -0
  35. data/ext/isomorfeus_ferret_ext/brotli_enc_brotli_bit_stream.c +1314 -0
  36. data/ext/isomorfeus_ferret_ext/brotli_enc_brotli_bit_stream.h +84 -0
  37. data/ext/isomorfeus_ferret_ext/brotli_enc_cluster.c +56 -0
  38. data/ext/isomorfeus_ferret_ext/brotli_enc_cluster.h +48 -0
  39. data/ext/isomorfeus_ferret_ext/brotli_enc_cluster_inc.h +320 -0
  40. data/ext/isomorfeus_ferret_ext/brotli_enc_command.c +28 -0
  41. data/ext/isomorfeus_ferret_ext/brotli_enc_command.h +190 -0
  42. data/ext/isomorfeus_ferret_ext/brotli_enc_compress_fragment.c +790 -0
  43. data/ext/isomorfeus_ferret_ext/brotli_enc_compress_fragment.h +61 -0
  44. data/ext/isomorfeus_ferret_ext/brotli_enc_compress_fragment_two_pass.c +645 -0
  45. data/ext/isomorfeus_ferret_ext/brotli_enc_compress_fragment_two_pass.h +54 -0
  46. data/ext/isomorfeus_ferret_ext/brotli_enc_dictionary_hash.c +1846 -0
  47. data/ext/isomorfeus_ferret_ext/brotli_enc_dictionary_hash.h +25 -0
  48. data/ext/isomorfeus_ferret_ext/brotli_enc_encode.c +1927 -0
  49. data/ext/isomorfeus_ferret_ext/brotli_enc_encoder_dict.c +33 -0
  50. data/ext/isomorfeus_ferret_ext/brotli_enc_encoder_dict.h +43 -0
  51. data/ext/isomorfeus_ferret_ext/brotli_enc_entropy_encode.c +503 -0
  52. data/ext/isomorfeus_ferret_ext/brotli_enc_entropy_encode.h +122 -0
  53. data/ext/isomorfeus_ferret_ext/brotli_enc_entropy_encode_static.h +539 -0
  54. data/ext/isomorfeus_ferret_ext/brotli_enc_fast_log.c +105 -0
  55. data/ext/isomorfeus_ferret_ext/brotli_enc_fast_log.h +66 -0
  56. data/ext/isomorfeus_ferret_ext/brotli_enc_find_match_length.h +79 -0
  57. data/ext/isomorfeus_ferret_ext/brotli_enc_hash.h +488 -0
  58. data/ext/isomorfeus_ferret_ext/brotli_enc_hash_composite_inc.h +125 -0
  59. data/ext/isomorfeus_ferret_ext/brotli_enc_hash_forgetful_chain_inc.h +293 -0
  60. data/ext/isomorfeus_ferret_ext/brotli_enc_hash_longest_match64_inc.h +267 -0
  61. data/ext/isomorfeus_ferret_ext/brotli_enc_hash_longest_match_inc.h +262 -0
  62. data/ext/isomorfeus_ferret_ext/brotli_enc_hash_longest_match_quickly_inc.h +266 -0
  63. data/ext/isomorfeus_ferret_ext/brotli_enc_hash_rolling_inc.h +212 -0
  64. data/ext/isomorfeus_ferret_ext/brotli_enc_hash_to_binary_tree_inc.h +329 -0
  65. data/ext/isomorfeus_ferret_ext/brotli_enc_histogram.c +100 -0
  66. data/ext/isomorfeus_ferret_ext/brotli_enc_histogram.h +63 -0
  67. data/ext/isomorfeus_ferret_ext/brotli_enc_histogram_inc.h +51 -0
  68. data/ext/isomorfeus_ferret_ext/brotli_enc_literal_cost.c +175 -0
  69. data/ext/isomorfeus_ferret_ext/brotli_enc_literal_cost.h +30 -0
  70. data/ext/isomorfeus_ferret_ext/brotli_enc_memory.c +170 -0
  71. data/ext/isomorfeus_ferret_ext/brotli_enc_memory.h +114 -0
  72. data/ext/isomorfeus_ferret_ext/brotli_enc_metablock.c +663 -0
  73. data/ext/isomorfeus_ferret_ext/brotli_enc_metablock.h +105 -0
  74. data/ext/isomorfeus_ferret_ext/brotli_enc_metablock_inc.h +183 -0
  75. data/ext/isomorfeus_ferret_ext/brotli_enc_params.h +46 -0
  76. data/ext/isomorfeus_ferret_ext/brotli_enc_prefix.h +53 -0
  77. data/ext/isomorfeus_ferret_ext/brotli_enc_quality.h +165 -0
  78. data/ext/isomorfeus_ferret_ext/brotli_enc_ringbuffer.h +167 -0
  79. data/ext/isomorfeus_ferret_ext/brotli_enc_static_dict.c +486 -0
  80. data/ext/isomorfeus_ferret_ext/brotli_enc_static_dict.h +40 -0
  81. data/ext/isomorfeus_ferret_ext/brotli_enc_static_dict_lut.h +5864 -0
  82. data/ext/isomorfeus_ferret_ext/brotli_enc_utf8_util.c +85 -0
  83. data/ext/isomorfeus_ferret_ext/brotli_enc_utf8_util.h +32 -0
  84. data/ext/isomorfeus_ferret_ext/brotli_enc_write_bits.h +87 -0
  85. data/ext/isomorfeus_ferret_ext/brotli_encode.h +448 -0
  86. data/ext/isomorfeus_ferret_ext/brotli_port.h +288 -0
  87. data/ext/isomorfeus_ferret_ext/brotli_types.h +83 -0
  88. data/ext/isomorfeus_ferret_ext/frb_index.c +35 -4
  89. data/ext/isomorfeus_ferret_ext/frt_document.h +1 -0
  90. data/ext/isomorfeus_ferret_ext/frt_fs_store.c +1 -0
  91. data/ext/isomorfeus_ferret_ext/frt_index.c +174 -25
  92. data/ext/isomorfeus_ferret_ext/frt_index.h +6 -3
  93. data/ext/isomorfeus_ferret_ext/frt_ram_store.c +1 -0
  94. data/ext/isomorfeus_ferret_ext/test_fields.c +57 -45
  95. data/ext/isomorfeus_ferret_ext/test_index.c +4 -1
  96. data/lib/isomorfeus/ferret/version.rb +1 -1
  97. metadata +88 -3
@@ -0,0 +1,351 @@
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 "brotli_common_constants.h"
15
+ #include "brotli_common_platform.h"
16
+ #include "brotli_types.h"
17
+
18
+ #if defined(__cplusplus) || defined(c_plusplus)
19
+ extern "C" {
20
+ #endif
21
+
22
+ #define BROTLI_SHORT_FILL_BIT_WINDOW_READ (sizeof(brotli_reg_t) >> 1)
23
+
24
+ BROTLI_INTERNAL extern const uint32_t kBrotliBitMask[33];
25
+
26
+ static BROTLI_INLINE uint32_t BitMask(uint32_t n) {
27
+ if (BROTLI_IS_CONSTANT(n) || BROTLI_HAS_UBFX) {
28
+ /* Masking with this expression turns to a single
29
+ "Unsigned Bit Field Extract" UBFX instruction on ARM. */
30
+ return ~((0xFFFFFFFFu) << n);
31
+ } else {
32
+ return kBrotliBitMask[n];
33
+ }
34
+ }
35
+
36
+ typedef struct {
37
+ brotli_reg_t val_; /* pre-fetched bits */
38
+ uint32_t bit_pos_; /* current bit-reading position in val_ */
39
+ const uint8_t* next_in; /* the byte we're reading from */
40
+ size_t avail_in;
41
+ } BrotliBitReader;
42
+
43
+ typedef struct {
44
+ brotli_reg_t val_;
45
+ uint32_t bit_pos_;
46
+ const uint8_t* next_in;
47
+ size_t avail_in;
48
+ } BrotliBitReaderState;
49
+
50
+ /* Initializes the BrotliBitReader fields. */
51
+ BROTLI_INTERNAL void BrotliInitBitReader(BrotliBitReader* const br);
52
+
53
+ /* Ensures that accumulator is not empty.
54
+ May consume up to sizeof(brotli_reg_t) - 1 bytes of input.
55
+ Returns BROTLI_FALSE if data is required but there is no input available.
56
+ For BROTLI_ALIGNED_READ this function also prepares bit reader for aligned
57
+ reading. */
58
+ BROTLI_INTERNAL BROTLI_BOOL BrotliWarmupBitReader(BrotliBitReader* const br);
59
+
60
+ /* Fallback for BrotliSafeReadBits32. Extracted as noninlined method to unburden
61
+ the main code-path. Never called for RFC brotli streams, required only for
62
+ "large-window" mode and other extensions. */
63
+ BROTLI_INTERNAL BROTLI_NOINLINE BROTLI_BOOL BrotliSafeReadBits32Slow(
64
+ BrotliBitReader* const br, uint32_t n_bits, uint32_t* val);
65
+
66
+ static BROTLI_INLINE void BrotliBitReaderSaveState(
67
+ BrotliBitReader* const from, BrotliBitReaderState* to) {
68
+ to->val_ = from->val_;
69
+ to->bit_pos_ = from->bit_pos_;
70
+ to->next_in = from->next_in;
71
+ to->avail_in = from->avail_in;
72
+ }
73
+
74
+ static BROTLI_INLINE void BrotliBitReaderRestoreState(
75
+ BrotliBitReader* const to, BrotliBitReaderState* from) {
76
+ to->val_ = from->val_;
77
+ to->bit_pos_ = from->bit_pos_;
78
+ to->next_in = from->next_in;
79
+ to->avail_in = from->avail_in;
80
+ }
81
+
82
+ static BROTLI_INLINE uint32_t BrotliGetAvailableBits(
83
+ const BrotliBitReader* br) {
84
+ return (BROTLI_64_BITS ? 64 : 32) - br->bit_pos_;
85
+ }
86
+
87
+ /* Returns amount of unread bytes the bit reader still has buffered from the
88
+ BrotliInput, including whole bytes in br->val_. Result is capped with
89
+ maximal ring-buffer size (larger number won't be utilized anyway). */
90
+ static BROTLI_INLINE size_t BrotliGetRemainingBytes(BrotliBitReader* br) {
91
+ static const size_t kCap = (size_t)1 << BROTLI_LARGE_MAX_WBITS;
92
+ if (br->avail_in > kCap) return kCap;
93
+ return br->avail_in + (BrotliGetAvailableBits(br) >> 3);
94
+ }
95
+
96
+ /* Checks if there is at least |num| bytes left in the input ring-buffer
97
+ (excluding the bits remaining in br->val_). */
98
+ static BROTLI_INLINE BROTLI_BOOL BrotliCheckInputAmount(
99
+ BrotliBitReader* const br, size_t num) {
100
+ return TO_BROTLI_BOOL(br->avail_in >= num);
101
+ }
102
+
103
+ /* Guarantees that there are at least |n_bits| + 1 bits in accumulator.
104
+ Precondition: accumulator contains at least 1 bit.
105
+ |n_bits| should be in the range [1..24] for regular build. For portable
106
+ non-64-bit little-endian build only 16 bits are safe to request. */
107
+ static BROTLI_INLINE void BrotliFillBitWindow(
108
+ BrotliBitReader* const br, uint32_t n_bits) {
109
+ #if (BROTLI_64_BITS)
110
+ if (!BROTLI_ALIGNED_READ && BROTLI_IS_CONSTANT(n_bits) && (n_bits <= 8)) {
111
+ if (br->bit_pos_ >= 56) {
112
+ br->val_ >>= 56;
113
+ br->bit_pos_ ^= 56; /* here same as -= 56 because of the if condition */
114
+ br->val_ |= BROTLI_UNALIGNED_LOAD64LE(br->next_in) << 8;
115
+ br->avail_in -= 7;
116
+ br->next_in += 7;
117
+ }
118
+ } else if (
119
+ !BROTLI_ALIGNED_READ && BROTLI_IS_CONSTANT(n_bits) && (n_bits <= 16)) {
120
+ if (br->bit_pos_ >= 48) {
121
+ br->val_ >>= 48;
122
+ br->bit_pos_ ^= 48; /* here same as -= 48 because of the if condition */
123
+ br->val_ |= BROTLI_UNALIGNED_LOAD64LE(br->next_in) << 16;
124
+ br->avail_in -= 6;
125
+ br->next_in += 6;
126
+ }
127
+ } else {
128
+ if (br->bit_pos_ >= 32) {
129
+ br->val_ >>= 32;
130
+ br->bit_pos_ ^= 32; /* here same as -= 32 because of the if condition */
131
+ br->val_ |= ((uint64_t)BROTLI_UNALIGNED_LOAD32LE(br->next_in)) << 32;
132
+ br->avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ;
133
+ br->next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ;
134
+ }
135
+ }
136
+ #else
137
+ if (!BROTLI_ALIGNED_READ && BROTLI_IS_CONSTANT(n_bits) && (n_bits <= 8)) {
138
+ if (br->bit_pos_ >= 24) {
139
+ br->val_ >>= 24;
140
+ br->bit_pos_ ^= 24; /* here same as -= 24 because of the if condition */
141
+ br->val_ |= BROTLI_UNALIGNED_LOAD32LE(br->next_in) << 8;
142
+ br->avail_in -= 3;
143
+ br->next_in += 3;
144
+ }
145
+ } else {
146
+ if (br->bit_pos_ >= 16) {
147
+ br->val_ >>= 16;
148
+ br->bit_pos_ ^= 16; /* here same as -= 16 because of the if condition */
149
+ br->val_ |= ((uint32_t)BROTLI_UNALIGNED_LOAD16LE(br->next_in)) << 16;
150
+ br->avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ;
151
+ br->next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ;
152
+ }
153
+ }
154
+ #endif
155
+ }
156
+
157
+ /* Mostly like BrotliFillBitWindow, but guarantees only 16 bits and reads no
158
+ more than BROTLI_SHORT_FILL_BIT_WINDOW_READ bytes of input. */
159
+ static BROTLI_INLINE void BrotliFillBitWindow16(BrotliBitReader* const br) {
160
+ BrotliFillBitWindow(br, 17);
161
+ }
162
+
163
+ /* Tries to pull one byte of input to accumulator.
164
+ Returns BROTLI_FALSE if there is no input available. */
165
+ static BROTLI_INLINE BROTLI_BOOL BrotliPullByte(BrotliBitReader* const br) {
166
+ if (br->avail_in == 0) {
167
+ return BROTLI_FALSE;
168
+ }
169
+ br->val_ >>= 8;
170
+ #if (BROTLI_64_BITS)
171
+ br->val_ |= ((uint64_t)*br->next_in) << 56;
172
+ #else
173
+ br->val_ |= ((uint32_t)*br->next_in) << 24;
174
+ #endif
175
+ br->bit_pos_ -= 8;
176
+ --br->avail_in;
177
+ ++br->next_in;
178
+ return BROTLI_TRUE;
179
+ }
180
+
181
+ /* Returns currently available bits.
182
+ The number of valid bits could be calculated by BrotliGetAvailableBits. */
183
+ static BROTLI_INLINE brotli_reg_t BrotliGetBitsUnmasked(
184
+ BrotliBitReader* const br) {
185
+ return br->val_ >> br->bit_pos_;
186
+ }
187
+
188
+ /* Like BrotliGetBits, but does not mask the result.
189
+ The result contains at least 16 valid bits. */
190
+ static BROTLI_INLINE uint32_t BrotliGet16BitsUnmasked(
191
+ BrotliBitReader* const br) {
192
+ BrotliFillBitWindow(br, 16);
193
+ return (uint32_t)BrotliGetBitsUnmasked(br);
194
+ }
195
+
196
+ /* Returns the specified number of bits from |br| without advancing bit
197
+ position. */
198
+ static BROTLI_INLINE uint32_t BrotliGetBits(
199
+ BrotliBitReader* const br, uint32_t n_bits) {
200
+ BrotliFillBitWindow(br, n_bits);
201
+ return (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
202
+ }
203
+
204
+ /* Tries to peek the specified amount of bits. Returns BROTLI_FALSE, if there
205
+ is not enough input. */
206
+ static BROTLI_INLINE BROTLI_BOOL BrotliSafeGetBits(
207
+ BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
208
+ while (BrotliGetAvailableBits(br) < n_bits) {
209
+ if (!BrotliPullByte(br)) {
210
+ return BROTLI_FALSE;
211
+ }
212
+ }
213
+ *val = (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
214
+ return BROTLI_TRUE;
215
+ }
216
+
217
+ /* Advances the bit pos by |n_bits|. */
218
+ static BROTLI_INLINE void BrotliDropBits(
219
+ BrotliBitReader* const br, uint32_t n_bits) {
220
+ br->bit_pos_ += n_bits;
221
+ }
222
+
223
+ static BROTLI_INLINE void BrotliBitReaderUnload(BrotliBitReader* br) {
224
+ uint32_t unused_bytes = BrotliGetAvailableBits(br) >> 3;
225
+ uint32_t unused_bits = unused_bytes << 3;
226
+ br->avail_in += unused_bytes;
227
+ br->next_in -= unused_bytes;
228
+ if (unused_bits == sizeof(br->val_) << 3) {
229
+ br->val_ = 0;
230
+ } else {
231
+ br->val_ <<= unused_bits;
232
+ }
233
+ br->bit_pos_ += unused_bits;
234
+ }
235
+
236
+ /* Reads the specified number of bits from |br| and advances the bit pos.
237
+ Precondition: accumulator MUST contain at least |n_bits|. */
238
+ static BROTLI_INLINE void BrotliTakeBits(
239
+ BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
240
+ *val = (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
241
+ BROTLI_LOG(("[BrotliTakeBits] %d %d %d val: %6x\n",
242
+ (int)br->avail_in, (int)br->bit_pos_, (int)n_bits, (int)*val));
243
+ BrotliDropBits(br, n_bits);
244
+ }
245
+
246
+ /* Reads the specified number of bits from |br| and advances the bit pos.
247
+ Assumes that there is enough input to perform BrotliFillBitWindow.
248
+ Up to 24 bits are allowed to be requested from this method. */
249
+ static BROTLI_INLINE uint32_t BrotliReadBits24(
250
+ BrotliBitReader* const br, uint32_t n_bits) {
251
+ BROTLI_DCHECK(n_bits <= 24);
252
+ if (BROTLI_64_BITS || (n_bits <= 16)) {
253
+ uint32_t val;
254
+ BrotliFillBitWindow(br, n_bits);
255
+ BrotliTakeBits(br, n_bits, &val);
256
+ return val;
257
+ } else {
258
+ uint32_t low_val;
259
+ uint32_t high_val;
260
+ BrotliFillBitWindow(br, 16);
261
+ BrotliTakeBits(br, 16, &low_val);
262
+ BrotliFillBitWindow(br, 8);
263
+ BrotliTakeBits(br, n_bits - 16, &high_val);
264
+ return low_val | (high_val << 16);
265
+ }
266
+ }
267
+
268
+ /* Same as BrotliReadBits24, but allows reading up to 32 bits. */
269
+ static BROTLI_INLINE uint32_t BrotliReadBits32(
270
+ BrotliBitReader* const br, uint32_t n_bits) {
271
+ BROTLI_DCHECK(n_bits <= 32);
272
+ if (BROTLI_64_BITS || (n_bits <= 16)) {
273
+ uint32_t val;
274
+ BrotliFillBitWindow(br, n_bits);
275
+ BrotliTakeBits(br, n_bits, &val);
276
+ return val;
277
+ } else {
278
+ uint32_t low_val;
279
+ uint32_t high_val;
280
+ BrotliFillBitWindow(br, 16);
281
+ BrotliTakeBits(br, 16, &low_val);
282
+ BrotliFillBitWindow(br, 16);
283
+ BrotliTakeBits(br, n_bits - 16, &high_val);
284
+ return low_val | (high_val << 16);
285
+ }
286
+ }
287
+
288
+ /* Tries to read the specified amount of bits. Returns BROTLI_FALSE, if there
289
+ is not enough input. |n_bits| MUST be positive.
290
+ Up to 24 bits are allowed to be requested from this method. */
291
+ static BROTLI_INLINE BROTLI_BOOL BrotliSafeReadBits(
292
+ BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
293
+ BROTLI_DCHECK(n_bits <= 24);
294
+ while (BrotliGetAvailableBits(br) < n_bits) {
295
+ if (!BrotliPullByte(br)) {
296
+ return BROTLI_FALSE;
297
+ }
298
+ }
299
+ BrotliTakeBits(br, n_bits, val);
300
+ return BROTLI_TRUE;
301
+ }
302
+
303
+ /* Same as BrotliSafeReadBits, but allows reading up to 32 bits. */
304
+ static BROTLI_INLINE BROTLI_BOOL BrotliSafeReadBits32(
305
+ BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
306
+ BROTLI_DCHECK(n_bits <= 32);
307
+ if (BROTLI_64_BITS || (n_bits <= 24)) {
308
+ while (BrotliGetAvailableBits(br) < n_bits) {
309
+ if (!BrotliPullByte(br)) {
310
+ return BROTLI_FALSE;
311
+ }
312
+ }
313
+ BrotliTakeBits(br, n_bits, val);
314
+ return BROTLI_TRUE;
315
+ } else {
316
+ return BrotliSafeReadBits32Slow(br, n_bits, val);
317
+ }
318
+ }
319
+
320
+ /* Advances the bit reader position to the next byte boundary and verifies
321
+ that any skipped bits are set to zero. */
322
+ static BROTLI_INLINE BROTLI_BOOL BrotliJumpToByteBoundary(BrotliBitReader* br) {
323
+ uint32_t pad_bits_count = BrotliGetAvailableBits(br) & 0x7;
324
+ uint32_t pad_bits = 0;
325
+ if (pad_bits_count != 0) {
326
+ BrotliTakeBits(br, pad_bits_count, &pad_bits);
327
+ }
328
+ return TO_BROTLI_BOOL(pad_bits == 0);
329
+ }
330
+
331
+ /* Copies remaining input bytes stored in the bit reader to the output. Value
332
+ |num| may not be larger than BrotliGetRemainingBytes. The bit reader must be
333
+ warmed up again after this. */
334
+ static BROTLI_INLINE void BrotliCopyBytes(uint8_t* dest,
335
+ BrotliBitReader* br, size_t num) {
336
+ while (BrotliGetAvailableBits(br) >= 8 && num > 0) {
337
+ *dest = (uint8_t)BrotliGetBitsUnmasked(br);
338
+ BrotliDropBits(br, 8);
339
+ ++dest;
340
+ --num;
341
+ }
342
+ memcpy(dest, br->next_in, num);
343
+ br->avail_in -= num;
344
+ br->next_in += num;
345
+ }
346
+
347
+ #if defined(__cplusplus) || defined(c_plusplus)
348
+ } /* extern "C" */
349
+ #endif
350
+
351
+ #endif /* BROTLI_DEC_BIT_READER_H_ */