715
|
1 /* libFLAC - Free Lossless Audio Codec library
|
|
2 * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007 Josh Coalson
|
|
3 *
|
|
4 * Redistribution and use in source and binary forms, with or without
|
|
5 * modification, are permitted provided that the following conditions
|
|
6 * are met:
|
|
7 *
|
|
8 * - Redistributions of source code must retain the above copyright
|
|
9 * notice, this list of conditions and the following disclaimer.
|
|
10 *
|
|
11 * - Redistributions in binary form must reproduce the above copyright
|
|
12 * notice, this list of conditions and the following disclaimer in the
|
|
13 * documentation and/or other materials provided with the distribution.
|
|
14 *
|
|
15 * - Neither the name of the Xiph.org Foundation nor the names of its
|
|
16 * contributors may be used to endorse or promote products derived from
|
|
17 * this software without specific prior written permission.
|
|
18 *
|
|
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
21 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
22 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
|
|
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
26 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
27 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
28 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
30 */
|
|
31
|
|
32 #if HAVE_CONFIG_H
|
|
33 # include <config.h>
|
|
34 #endif
|
|
35
|
|
36 #include <stdlib.h> /* for malloc() */
|
|
37 #include <string.h> /* for memcpy(), memset() */
|
|
38 #if defined(_MSC_VER) && _MSC_VER <= 1200
|
|
39 #include <winsock.h> /* for ntohl() */
|
|
40 #elif defined FLAC__SYS_DARWIN
|
|
41 #include <machine/endian.h> /* for ntohl() */
|
|
42 #else
|
|
43 #include <netinet/in.h> /* for ntohl() */
|
|
44 #endif
|
|
45 #include "private/bitmath.h"
|
|
46 #include "private/bitreader.h"
|
|
47 #include "private/crc.h"
|
|
48 #include "FLAC/assert.h"
|
|
49
|
|
50 /*
|
|
51 * Along the way you will see two versions of some functions, selected
|
|
52 * by a FLAC__NO_MANUAL_INLINING macro. One is the simplified, more
|
|
53 * readable, and slow version, and the other is the same function
|
|
54 * where crucial parts have been manually inlined and are much faster.
|
|
55 *
|
|
56 */
|
|
57
|
|
58 /* Things should be fastest when this matches the machine word size */
|
|
59 /* WATCHOUT: if you change this you must also change the following #defines down to ALIGNED_UNARY_BITS below to match */
|
|
60 /* WATCHOUT: there are a few places where the code will not work unless brword is >= 32 bits wide */
|
|
61 /* also, some sections currently only have fast versions for 4 or 8 bytes per word */
|
|
62 typedef FLAC__uint32 brword;
|
|
63 #define FLAC__BYTES_PER_WORD 4
|
|
64 #define FLAC__BITS_PER_WORD 32
|
|
65 #define FLAC__WORD_ALL_ONES ((FLAC__uint32)0xffffffff)
|
|
66 #define FLAC__WORD_TOP_BIT_ONE ((FLAC__uint32)0x80000000)
|
|
67 /* SWAP_BE_WORD_TO_HOST swaps bytes in a brword (which is always big-endian) if necessary to match host byte order */
|
|
68 #if WORDS_BIGENDIAN
|
|
69 #define SWAP_BE_WORD_TO_HOST(x) (x)
|
|
70 #else
|
|
71 #ifdef _MSC_VER
|
|
72 #define SWAP_BE_WORD_TO_HOST(x) local_swap32_(x)
|
|
73 #else
|
|
74 #define SWAP_BE_WORD_TO_HOST(x) ntohl(x)
|
|
75 #endif
|
|
76 #endif
|
|
77 /* counts the # of zero MSBs in a word */
|
|
78 #define ALIGNED_UNARY_BITS(word) ( \
|
|
79 (word) <= 0xffff ? \
|
|
80 ( (word) <= 0xff? byte_to_unary_table[word] + 24 : byte_to_unary_table[(word) >> 8] + 16 ) : \
|
|
81 ( (word) <= 0xffffff? byte_to_unary_table[word >> 16] + 8 : byte_to_unary_table[(word) >> 24] ) \
|
|
82 )
|
|
83 /* this alternate might be slightly faster on some systems/compilers: */
|
|
84 #define ALIGNED_UNARY_BITS2(word) ( (word) <= 0xff ? byte_to_unary_table[word] + 24 : ((word) <= 0xffff ? byte_to_unary_table[(word) >> 8] + 16 : ((word) <= 0xffffff ? byte_to_unary_table[(word) >> 16] + 8 : byte_to_unary_table[(word) >> 24])) )
|
|
85
|
|
86
|
|
87 /*
|
|
88 * This should be at least twice as large as the largest number of words
|
|
89 * required to represent any 'number' (in any encoding) you are going to
|
|
90 * read. With FLAC this is on the order of maybe a few hundred bits.
|
|
91 * If the buffer is smaller than that, the decoder won't be able to read
|
|
92 * in a whole number that is in a variable length encoding (e.g. Rice).
|
|
93 * But to be practical it should be at least 1K bytes.
|
|
94 *
|
|
95 * Increase this number to decrease the number of read callbacks, at the
|
|
96 * expense of using more memory. Or decrease for the reverse effect,
|
|
97 * keeping in mind the limit from the first paragraph. The optimal size
|
|
98 * also depends on the CPU cache size and other factors; some twiddling
|
|
99 * may be necessary to squeeze out the best performance.
|
|
100 */
|
|
101 static const unsigned FLAC__BITREADER_DEFAULT_CAPACITY = 65536u / FLAC__BITS_PER_WORD; /* in words */
|
|
102
|
|
103 static const unsigned char byte_to_unary_table[] = {
|
|
104 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
|
|
105 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
106 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
107 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
108 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
109 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
110 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
111 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
113 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
114 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
115 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
116 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
117 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
118 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
119 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
|
120 };
|
|
121
|
|
122 #ifdef min
|
|
123 #undef min
|
|
124 #endif
|
|
125 #define min(x,y) ((x)<(y)?(x):(y))
|
|
126 #ifdef max
|
|
127 #undef max
|
|
128 #endif
|
|
129 #define max(x,y) ((x)>(y)?(x):(y))
|
|
130
|
|
131 /* adjust for compilers that can't understand using LLU suffix for uint64_t literals */
|
|
132 #ifdef _MSC_VER
|
|
133 #define FLAC__U64L(x) x
|
|
134 #else
|
|
135 #define FLAC__U64L(x) x##LLU
|
|
136 #endif
|
|
137
|
|
138 #ifndef FLaC__INLINE
|
|
139 #define FLaC__INLINE
|
|
140 #endif
|
|
141
|
|
142 struct FLAC__BitReader {
|
|
143 /* any partially-consumed word at the head will stay right-justified as bits are consumed from the left */
|
|
144 /* any incomplete word at the tail will be left-justified, and bytes from the read callback are added on the right */
|
|
145 brword *buffer;
|
|
146 unsigned capacity; /* in words */
|
|
147 unsigned words; /* # of completed words in buffer */
|
|
148 unsigned bytes; /* # of bytes in incomplete word at buffer[words] */
|
|
149 unsigned consumed_words, consumed_bits; /* #words+(#bits of head word) already consumed from the front of buffer */
|
|
150 unsigned read_crc16; /* the running frame CRC */
|
|
151 unsigned crc16_align; /* the number of bits in the current consumed word that should not be CRC'd */
|
|
152 FLAC__BitReaderReadCallback read_callback;
|
|
153 void *client_data;
|
|
154 };
|
|
155
|
|
156 #ifdef _MSC_VER
|
|
157 /* OPT: an MSVC built-in would be better */
|
|
158 static _inline FLAC__uint32 local_swap32_(FLAC__uint32 x)
|
|
159 {
|
|
160 x = ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF);
|
|
161 return (x>>16) | (x<<16);
|
|
162 }
|
|
163 #endif
|
|
164
|
|
165 static FLaC__INLINE void crc16_update_word_(FLAC__BitReader *br, brword word)
|
|
166 {
|
|
167 register unsigned crc = br->read_crc16;
|
|
168 #if FLAC__BYTES_PER_WORD == 4
|
|
169 switch(br->crc16_align) {
|
|
170 case 0: crc = FLAC__CRC16_UPDATE((unsigned)(word >> 24), crc);
|
|
171 case 8: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 16) & 0xff), crc);
|
|
172 case 16: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 8) & 0xff), crc);
|
|
173 case 24: br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)(word & 0xff), crc);
|
|
174 }
|
|
175 #elif FLAC__BYTES_PER_WORD == 8
|
|
176 switch(br->crc16_align) {
|
|
177 case 0: crc = FLAC__CRC16_UPDATE((unsigned)(word >> 56), crc);
|
|
178 case 8: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 48) & 0xff), crc);
|
|
179 case 16: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 40) & 0xff), crc);
|
|
180 case 24: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 32) & 0xff), crc);
|
|
181 case 32: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 24) & 0xff), crc);
|
|
182 case 40: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 16) & 0xff), crc);
|
|
183 case 48: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 8) & 0xff), crc);
|
|
184 case 56: br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)(word & 0xff), crc);
|
|
185 }
|
|
186 #else
|
|
187 for( ; br->crc16_align < FLAC__BITS_PER_WORD; br->crc16_align += 8)
|
|
188 crc = FLAC__CRC16_UPDATE((unsigned)((word >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), crc);
|
|
189 br->read_crc16 = crc;
|
|
190 #endif
|
|
191 br->crc16_align = 0;
|
|
192 }
|
|
193
|
|
194 static FLAC__bool bitreader_read_from_client_(FLAC__BitReader *br)
|
|
195 {
|
|
196 unsigned start, end;
|
|
197 size_t bytes;
|
|
198 FLAC__byte *target;
|
|
199
|
|
200 /* first shift the unconsumed buffer data toward the front as much as possible */
|
|
201 if(br->consumed_words > 0) {
|
|
202 start = br->consumed_words;
|
|
203 end = br->words + (br->bytes? 1:0);
|
|
204 memmove(br->buffer, br->buffer+start, FLAC__BYTES_PER_WORD * (end - start));
|
|
205
|
|
206 br->words -= start;
|
|
207 br->consumed_words = 0;
|
|
208 }
|
|
209
|
|
210 /*
|
|
211 * set the target for reading, taking into account word alignment and endianness
|
|
212 */
|
|
213 bytes = (br->capacity - br->words) * FLAC__BYTES_PER_WORD - br->bytes;
|
|
214 if(bytes == 0)
|
|
215 return false; /* no space left, buffer is too small; see note for FLAC__BITREADER_DEFAULT_CAPACITY */
|
|
216 target = ((FLAC__byte*)(br->buffer+br->words)) + br->bytes;
|
|
217
|
|
218 /* before reading, if the existing reader looks like this (say brword is 32 bits wide)
|
|
219 * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1 (partial tail word is left-justified)
|
|
220 * buffer[BE]: 11 22 33 44 55 ?? ?? ?? (shown layed out as bytes sequentially in memory)
|
|
221 * buffer[LE]: 44 33 22 11 ?? ?? ?? 55 (?? being don't-care)
|
|
222 * ^^-------target, bytes=3
|
|
223 * on LE machines, have to byteswap the odd tail word so nothing is
|
|
224 * overwritten:
|
|
225 */
|
|
226 #if WORDS_BIGENDIAN
|
|
227 #else
|
|
228 if(br->bytes)
|
|
229 br->buffer[br->words] = SWAP_BE_WORD_TO_HOST(br->buffer[br->words]);
|
|
230 #endif
|
|
231
|
|
232 /* now it looks like:
|
|
233 * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1
|
|
234 * buffer[BE]: 11 22 33 44 55 ?? ?? ??
|
|
235 * buffer[LE]: 44 33 22 11 55 ?? ?? ??
|
|
236 * ^^-------target, bytes=3
|
|
237 */
|
|
238
|
|
239 /* read in the data; note that the callback may return a smaller number of bytes */
|
|
240 if(!br->read_callback(target, &bytes, br->client_data))
|
|
241 return false;
|
|
242
|
|
243 /* after reading bytes 66 77 88 99 AA BB CC DD EE FF from the client:
|
|
244 * bitstream : 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF
|
|
245 * buffer[BE]: 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??
|
|
246 * buffer[LE]: 44 33 22 11 55 66 77 88 99 AA BB CC DD EE FF ??
|
|
247 * now have to byteswap on LE machines:
|
|
248 */
|
|
249 #if WORDS_BIGENDIAN
|
|
250 #else
|
|
251 end = (br->words*FLAC__BYTES_PER_WORD + br->bytes + bytes + (FLAC__BYTES_PER_WORD-1)) / FLAC__BYTES_PER_WORD;
|
|
252 for(start = br->words; start < end; start++)
|
|
253 br->buffer[start] = SWAP_BE_WORD_TO_HOST(br->buffer[start]);
|
|
254 #endif
|
|
255
|
|
256 /* now it looks like:
|
|
257 * bitstream : 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF
|
|
258 * buffer[BE]: 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??
|
|
259 * buffer[LE]: 44 33 22 11 88 77 66 55 CC BB AA 99 ?? FF EE DD
|
|
260 * finally we'll update the reader values:
|
|
261 */
|
|
262 end = br->words*FLAC__BYTES_PER_WORD + br->bytes + bytes;
|
|
263 br->words = end / FLAC__BYTES_PER_WORD;
|
|
264 br->bytes = end % FLAC__BYTES_PER_WORD;
|
|
265
|
|
266 return true;
|
|
267 }
|
|
268
|
|
269 /***********************************************************************
|
|
270 *
|
|
271 * Class constructor/destructor
|
|
272 *
|
|
273 ***********************************************************************/
|
|
274
|
|
275 FLAC__BitReader *FLAC__bitreader_new(void)
|
|
276 {
|
|
277 FLAC__BitReader *br = (FLAC__BitReader*)calloc(1, sizeof(FLAC__BitReader));
|
|
278
|
|
279 /* calloc() implies:
|
|
280 memset(br, 0, sizeof(FLAC__BitReader));
|
|
281 br->buffer = 0;
|
|
282 br->capacity = 0;
|
|
283 br->words = br->bytes = 0;
|
|
284 br->consumed_words = br->consumed_bits = 0;
|
|
285 br->read_callback = 0;
|
|
286 br->client_data = 0;
|
|
287 */
|
|
288 return br;
|
|
289 }
|
|
290
|
|
291 void FLAC__bitreader_delete(FLAC__BitReader *br)
|
|
292 {
|
|
293 FLAC__ASSERT(0 != br);
|
|
294
|
|
295 FLAC__bitreader_free(br);
|
|
296 free(br);
|
|
297 }
|
|
298
|
|
299 /***********************************************************************
|
|
300 *
|
|
301 * Public class methods
|
|
302 *
|
|
303 ***********************************************************************/
|
|
304
|
|
305 FLAC__bool FLAC__bitreader_init(FLAC__BitReader *br, FLAC__BitReaderReadCallback rcb, void *cd)
|
|
306 {
|
|
307 FLAC__ASSERT(0 != br);
|
|
308
|
|
309 br->words = br->bytes = 0;
|
|
310 br->consumed_words = br->consumed_bits = 0;
|
|
311 br->capacity = FLAC__BITREADER_DEFAULT_CAPACITY;
|
|
312 br->buffer = (brword*)malloc(sizeof(brword) * br->capacity);
|
|
313 if(br->buffer == 0)
|
|
314 return false;
|
|
315 br->read_callback = rcb;
|
|
316 br->client_data = cd;
|
|
317
|
|
318 return true;
|
|
319 }
|
|
320
|
|
321 void FLAC__bitreader_free(FLAC__BitReader *br)
|
|
322 {
|
|
323 FLAC__ASSERT(0 != br);
|
|
324
|
|
325 if(0 != br->buffer)
|
|
326 free(br->buffer);
|
|
327 br->buffer = 0;
|
|
328 br->capacity = 0;
|
|
329 br->words = br->bytes = 0;
|
|
330 br->consumed_words = br->consumed_bits = 0;
|
|
331 br->read_callback = 0;
|
|
332 br->client_data = 0;
|
|
333 }
|
|
334
|
|
335 FLAC__bool FLAC__bitreader_clear(FLAC__BitReader *br)
|
|
336 {
|
|
337 br->words = br->bytes = 0;
|
|
338 br->consumed_words = br->consumed_bits = 0;
|
|
339 return true;
|
|
340 }
|
|
341
|
|
342 void FLAC__bitreader_dump(const FLAC__BitReader *br, FILE *out)
|
|
343 {
|
|
344 unsigned i, j;
|
|
345 if(br == 0) {
|
|
346 fprintf(out, "bitreader is NULL\n");
|
|
347 }
|
|
348 else {
|
|
349 fprintf(out, "bitreader: capacity=%u words=%u bytes=%u consumed: words=%u, bits=%u\n", br->capacity, br->words, br->bytes, br->consumed_words, br->consumed_bits);
|
|
350
|
|
351 for(i = 0; i < br->words; i++) {
|
|
352 fprintf(out, "%08X: ", i);
|
|
353 for(j = 0; j < FLAC__BITS_PER_WORD; j++)
|
|
354 if(i < br->consumed_words || (i == br->consumed_words && j < br->consumed_bits))
|
|
355 fprintf(out, ".");
|
|
356 else
|
|
357 fprintf(out, "%01u", br->buffer[i] & (1 << (FLAC__BITS_PER_WORD-j-1)) ? 1:0);
|
|
358 fprintf(out, "\n");
|
|
359 }
|
|
360 if(br->bytes > 0) {
|
|
361 fprintf(out, "%08X: ", i);
|
|
362 for(j = 0; j < br->bytes*8; j++)
|
|
363 if(i < br->consumed_words || (i == br->consumed_words && j < br->consumed_bits))
|
|
364 fprintf(out, ".");
|
|
365 else
|
|
366 fprintf(out, "%01u", br->buffer[i] & (1 << (br->bytes*8-j-1)) ? 1:0);
|
|
367 fprintf(out, "\n");
|
|
368 }
|
|
369 }
|
|
370 }
|
|
371
|
|
372 void FLAC__bitreader_reset_read_crc16(FLAC__BitReader *br, FLAC__uint16 seed)
|
|
373 {
|
|
374 FLAC__ASSERT(0 != br);
|
|
375 FLAC__ASSERT(0 != br->buffer);
|
|
376 FLAC__ASSERT((br->consumed_bits & 7) == 0);
|
|
377
|
|
378 br->read_crc16 = (unsigned)seed;
|
|
379 br->crc16_align = br->consumed_bits;
|
|
380 }
|
|
381
|
|
382 FLAC__uint16 FLAC__bitreader_get_read_crc16(FLAC__BitReader *br)
|
|
383 {
|
|
384 FLAC__ASSERT(0 != br);
|
|
385 FLAC__ASSERT(0 != br->buffer);
|
|
386 FLAC__ASSERT((br->consumed_bits & 7) == 0);
|
|
387 FLAC__ASSERT(br->crc16_align <= br->consumed_bits);
|
|
388
|
|
389 /* CRC any tail bytes in a partially-consumed word */
|
|
390 if(br->consumed_bits) {
|
|
391 const brword tail = br->buffer[br->consumed_words];
|
|
392 for( ; br->crc16_align < br->consumed_bits; br->crc16_align += 8)
|
|
393 br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)((tail >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), br->read_crc16);
|
|
394 }
|
|
395 return br->read_crc16;
|
|
396 }
|
|
397
|
|
398 FLaC__INLINE FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br)
|
|
399 {
|
|
400 return ((br->consumed_bits & 7) == 0);
|
|
401 }
|
|
402
|
|
403 FLaC__INLINE unsigned FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br)
|
|
404 {
|
|
405 return 8 - (br->consumed_bits & 7);
|
|
406 }
|
|
407
|
|
408 FLaC__INLINE unsigned FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br)
|
|
409 {
|
|
410 return (br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits;
|
|
411 }
|
|
412
|
|
413 FLaC__INLINE FLAC__bool FLAC__bitreader_read_raw_uint32(FLAC__BitReader *br, FLAC__uint32 *val, unsigned bits)
|
|
414 {
|
|
415 FLAC__ASSERT(0 != br);
|
|
416 FLAC__ASSERT(0 != br->buffer);
|
|
417
|
|
418 FLAC__ASSERT(bits <= 32);
|
|
419 FLAC__ASSERT((br->capacity*FLAC__BITS_PER_WORD) * 2 >= bits);
|
|
420 FLAC__ASSERT(br->consumed_words <= br->words);
|
|
421
|
|
422 /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
|
|
423 FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
|
|
424
|
|
425 if(bits == 0) { /* OPT: investigate if this can ever happen, maybe change to assertion */
|
|
426 *val = 0;
|
|
427 return true;
|
|
428 }
|
|
429
|
|
430 while((br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits < bits) {
|
|
431 if(!bitreader_read_from_client_(br))
|
|
432 return false;
|
|
433 }
|
|
434 if(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */
|
|
435 /* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */
|
|
436 if(br->consumed_bits) {
|
|
437 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
|
|
438 const unsigned n = FLAC__BITS_PER_WORD - br->consumed_bits;
|
|
439 const brword word = br->buffer[br->consumed_words];
|
|
440 if(bits < n) {
|
|
441 *val = (word & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (n-bits);
|
|
442 br->consumed_bits += bits;
|
|
443 return true;
|
|
444 }
|
|
445 *val = word & (FLAC__WORD_ALL_ONES >> br->consumed_bits);
|
|
446 bits -= n;
|
|
447 crc16_update_word_(br, word);
|
|
448 br->consumed_words++;
|
|
449 br->consumed_bits = 0;
|
|
450 if(bits) { /* if there are still bits left to read, there have to be less than 32 so they will all be in the next word */
|
|
451 *val <<= bits;
|
|
452 *val |= (br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits));
|
|
453 br->consumed_bits = bits;
|
|
454 }
|
|
455 return true;
|
|
456 }
|
|
457 else {
|
|
458 const brword word = br->buffer[br->consumed_words];
|
|
459 if(bits < FLAC__BITS_PER_WORD) {
|
|
460 *val = word >> (FLAC__BITS_PER_WORD-bits);
|
|
461 br->consumed_bits = bits;
|
|
462 return true;
|
|
463 }
|
|
464 /* at this point 'bits' must be == FLAC__BITS_PER_WORD; because of previous assertions, it can't be larger */
|
|
465 *val = word;
|
|
466 crc16_update_word_(br, word);
|
|
467 br->consumed_words++;
|
|
468 return true;
|
|
469 }
|
|
470 }
|
|
471 else {
|
|
472 /* in this case we're starting our read at a partial tail word;
|
|
473 * the reader has guaranteed that we have at least 'bits' bits
|
|
474 * available to read, which makes this case simpler.
|
|
475 */
|
|
476 /* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */
|
|
477 if(br->consumed_bits) {
|
|
478 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
|
|
479 FLAC__ASSERT(br->consumed_bits + bits <= br->bytes*8);
|
|
480 *val = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (FLAC__BITS_PER_WORD-br->consumed_bits-bits);
|
|
481 br->consumed_bits += bits;
|
|
482 return true;
|
|
483 }
|
|
484 else {
|
|
485 *val = br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits);
|
|
486 br->consumed_bits += bits;
|
|
487 return true;
|
|
488 }
|
|
489 }
|
|
490 }
|
|
491
|
|
492 FLAC__bool FLAC__bitreader_read_raw_int32(FLAC__BitReader *br, FLAC__int32 *val, unsigned bits)
|
|
493 {
|
|
494 /* OPT: inline raw uint32 code here, or make into a macro if possible in the .h file */
|
|
495 if(!FLAC__bitreader_read_raw_uint32(br, (FLAC__uint32*)val, bits))
|
|
496 return false;
|
|
497 /* sign-extend: */
|
|
498 *val <<= (32-bits);
|
|
499 *val >>= (32-bits);
|
|
500 return true;
|
|
501 }
|
|
502
|
|
503 FLAC__bool FLAC__bitreader_read_raw_uint64(FLAC__BitReader *br, FLAC__uint64 *val, unsigned bits)
|
|
504 {
|
|
505 FLAC__uint32 hi, lo;
|
|
506
|
|
507 if(bits > 32) {
|
|
508 if(!FLAC__bitreader_read_raw_uint32(br, &hi, bits-32))
|
|
509 return false;
|
|
510 if(!FLAC__bitreader_read_raw_uint32(br, &lo, 32))
|
|
511 return false;
|
|
512 *val = hi;
|
|
513 *val <<= 32;
|
|
514 *val |= lo;
|
|
515 }
|
|
516 else {
|
|
517 if(!FLAC__bitreader_read_raw_uint32(br, &lo, bits))
|
|
518 return false;
|
|
519 *val = lo;
|
|
520 }
|
|
521 return true;
|
|
522 }
|
|
523
|
|
524 FLaC__INLINE FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val)
|
|
525 {
|
|
526 FLAC__uint32 x8, x32 = 0;
|
|
527
|
|
528 /* this doesn't need to be that fast as currently it is only used for vorbis comments */
|
|
529
|
|
530 if(!FLAC__bitreader_read_raw_uint32(br, &x32, 8))
|
|
531 return false;
|
|
532
|
|
533 if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
|
|
534 return false;
|
|
535 x32 |= (x8 << 8);
|
|
536
|
|
537 if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
|
|
538 return false;
|
|
539 x32 |= (x8 << 16);
|
|
540
|
|
541 if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
|
|
542 return false;
|
|
543 x32 |= (x8 << 24);
|
|
544
|
|
545 *val = x32;
|
|
546 return true;
|
|
547 }
|
|
548
|
|
549 FLAC__bool FLAC__bitreader_skip_bits_no_crc(FLAC__BitReader *br, unsigned bits)
|
|
550 {
|
|
551 /*
|
|
552 * OPT: a faster implementation is possible but probably not that useful
|
|
553 * since this is only called a couple of times in the metadata readers.
|
|
554 */
|
|
555 FLAC__ASSERT(0 != br);
|
|
556 FLAC__ASSERT(0 != br->buffer);
|
|
557
|
|
558 if(bits > 0) {
|
|
559 const unsigned n = br->consumed_bits & 7;
|
|
560 unsigned m;
|
|
561 FLAC__uint32 x;
|
|
562
|
|
563 if(n != 0) {
|
|
564 m = min(8-n, bits);
|
|
565 if(!FLAC__bitreader_read_raw_uint32(br, &x, m))
|
|
566 return false;
|
|
567 bits -= m;
|
|
568 }
|
|
569 m = bits / 8;
|
|
570 if(m > 0) {
|
|
571 if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(br, m))
|
|
572 return false;
|
|
573 bits %= 8;
|
|
574 }
|
|
575 if(bits > 0) {
|
|
576 if(!FLAC__bitreader_read_raw_uint32(br, &x, bits))
|
|
577 return false;
|
|
578 }
|
|
579 }
|
|
580
|
|
581 return true;
|
|
582 }
|
|
583
|
|
584 FLAC__bool FLAC__bitreader_skip_byte_block_aligned_no_crc(FLAC__BitReader *br, unsigned nvals)
|
|
585 {
|
|
586 FLAC__uint32 x;
|
|
587
|
|
588 FLAC__ASSERT(0 != br);
|
|
589 FLAC__ASSERT(0 != br->buffer);
|
|
590 FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
|
|
591
|
|
592 /* step 1: skip over partial head word to get word aligned */
|
|
593 while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
|
|
594 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
|
|
595 return false;
|
|
596 nvals--;
|
|
597 }
|
|
598 if(0 == nvals)
|
|
599 return true;
|
|
600 /* step 2: skip whole words in chunks */
|
|
601 while(nvals >= FLAC__BYTES_PER_WORD) {
|
|
602 if(br->consumed_words < br->words) {
|
|
603 br->consumed_words++;
|
|
604 nvals -= FLAC__BYTES_PER_WORD;
|
|
605 }
|
|
606 else if(!bitreader_read_from_client_(br))
|
|
607 return false;
|
|
608 }
|
|
609 /* step 3: skip any remainder from partial tail bytes */
|
|
610 while(nvals) {
|
|
611 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
|
|
612 return false;
|
|
613 nvals--;
|
|
614 }
|
|
615
|
|
616 return true;
|
|
617 }
|
|
618
|
|
619 FLAC__bool FLAC__bitreader_read_byte_block_aligned_no_crc(FLAC__BitReader *br, FLAC__byte *val, unsigned nvals)
|
|
620 {
|
|
621 FLAC__uint32 x;
|
|
622
|
|
623 FLAC__ASSERT(0 != br);
|
|
624 FLAC__ASSERT(0 != br->buffer);
|
|
625 FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
|
|
626
|
|
627 /* step 1: read from partial head word to get word aligned */
|
|
628 while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
|
|
629 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
|
|
630 return false;
|
|
631 *val++ = (FLAC__byte)x;
|
|
632 nvals--;
|
|
633 }
|
|
634 if(0 == nvals)
|
|
635 return true;
|
|
636 /* step 2: read whole words in chunks */
|
|
637 while(nvals >= FLAC__BYTES_PER_WORD) {
|
|
638 if(br->consumed_words < br->words) {
|
|
639 const brword word = br->buffer[br->consumed_words++];
|
|
640 #if FLAC__BYTES_PER_WORD == 4
|
|
641 val[0] = (FLAC__byte)(word >> 24);
|
|
642 val[1] = (FLAC__byte)(word >> 16);
|
|
643 val[2] = (FLAC__byte)(word >> 8);
|
|
644 val[3] = (FLAC__byte)word;
|
|
645 #elif FLAC__BYTES_PER_WORD == 8
|
|
646 val[0] = (FLAC__byte)(word >> 56);
|
|
647 val[1] = (FLAC__byte)(word >> 48);
|
|
648 val[2] = (FLAC__byte)(word >> 40);
|
|
649 val[3] = (FLAC__byte)(word >> 32);
|
|
650 val[4] = (FLAC__byte)(word >> 24);
|
|
651 val[5] = (FLAC__byte)(word >> 16);
|
|
652 val[6] = (FLAC__byte)(word >> 8);
|
|
653 val[7] = (FLAC__byte)word;
|
|
654 #else
|
|
655 for(x = 0; x < FLAC__BYTES_PER_WORD; x++)
|
|
656 val[x] = (FLAC__byte)(word >> (8*(FLAC__BYTES_PER_WORD-x-1)));
|
|
657 #endif
|
|
658 val += FLAC__BYTES_PER_WORD;
|
|
659 nvals -= FLAC__BYTES_PER_WORD;
|
|
660 }
|
|
661 else if(!bitreader_read_from_client_(br))
|
|
662 return false;
|
|
663 }
|
|
664 /* step 3: read any remainder from partial tail bytes */
|
|
665 while(nvals) {
|
|
666 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
|
|
667 return false;
|
|
668 *val++ = (FLAC__byte)x;
|
|
669 nvals--;
|
|
670 }
|
|
671
|
|
672 return true;
|
|
673 }
|
|
674
|
|
675 FLaC__INLINE FLAC__bool FLAC__bitreader_read_unary_unsigned(FLAC__BitReader *br, unsigned *val)
|
|
676 #ifdef FLAC__NO_MANUAL_INLINING
|
|
677 {
|
|
678 unsigned bit;
|
|
679
|
|
680 FLAC__ASSERT(0 != br);
|
|
681 FLAC__ASSERT(0 != br->buffer);
|
|
682
|
|
683 *val = 0;
|
|
684 while(1) {
|
|
685 if(!FLAC__bitreader_read_bit(br, &bit))
|
|
686 return false;
|
|
687 if(bit)
|
|
688 break;
|
|
689 else
|
|
690 *val++;
|
|
691 }
|
|
692 return true;
|
|
693 }
|
|
694 #else
|
|
695 {
|
|
696 unsigned i;
|
|
697
|
|
698 FLAC__ASSERT(0 != br);
|
|
699 FLAC__ASSERT(0 != br->buffer);
|
|
700
|
|
701 *val = 0;
|
|
702 while(1) {
|
|
703 while(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */
|
|
704 brword b = br->buffer[br->consumed_words] << br->consumed_bits;
|
|
705 if(b) {
|
|
706 #if 0 /* too slow, but this is the idea: */
|
|
707 for(i = 0; !(b & FLAC__WORD_TOP_BIT_ONE); i++)
|
|
708 b <<= 1;
|
|
709 #else
|
|
710 i = ALIGNED_UNARY_BITS(b);
|
|
711 #endif
|
|
712 *val += i;
|
|
713 i++;
|
|
714 br->consumed_bits += i;
|
|
715 if(br->consumed_bits == FLAC__BITS_PER_WORD) {
|
|
716 crc16_update_word_(br, br->buffer[br->consumed_words]);
|
|
717 br->consumed_words++;
|
|
718 br->consumed_bits = 0;
|
|
719 }
|
|
720 return true;
|
|
721 }
|
|
722 else {
|
|
723 *val += FLAC__BITS_PER_WORD - br->consumed_bits;
|
|
724 crc16_update_word_(br, br->buffer[br->consumed_words]);
|
|
725 br->consumed_words++;
|
|
726 br->consumed_bits = 0;
|
|
727 /* didn't find stop bit yet, have to keep going... */
|
|
728 }
|
|
729 }
|
|
730 /* at this point we've eaten up all the whole words; have to try
|
|
731 * reading through any tail bytes before calling the read callback.
|
|
732 * this is a repeat of the above logic adjusted for the fact we
|
|
733 * don't have a whole word. note though if the client is feeding
|
|
734 * us data a byte at a time (unlikely), br->consumed_bits may not
|
|
735 * be zero.
|
|
736 */
|
|
737 if(br->bytes) {
|
|
738 const unsigned end = br->bytes * 8;
|
|
739 brword b = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << br->consumed_bits;
|
|
740 if(b) {
|
|
741 #if 0 /* too slow, but this is the idea: */
|
|
742 for(i = 0; !(b & FLAC__WORD_TOP_BIT_ONE); i++)
|
|
743 b <<= 1;
|
|
744 #else
|
|
745 i = ALIGNED_UNARY_BITS(b);
|
|
746 #endif
|
|
747 *val += i;
|
|
748 i++;
|
|
749 br->consumed_bits += i;
|
|
750 FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);
|
|
751 return true;
|
|
752 }
|
|
753 else {
|
|
754 *val += end - br->consumed_bits;
|
|
755 br->consumed_bits += end;
|
|
756 FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);
|
|
757 /* didn't find stop bit yet, have to keep going... */
|
|
758 }
|
|
759 }
|
|
760 if(!bitreader_read_from_client_(br))
|
|
761 return false;
|
|
762 }
|
|
763 }
|
|
764 #endif
|
|
765
|
|
766 FLAC__bool FLAC__bitreader_read_rice_signed(FLAC__BitReader *br, int *val, unsigned parameter)
|
|
767 {
|
|
768 FLAC__uint32 lsbs = 0, msbs = 0;
|
|
769 unsigned uval;
|
|
770
|
|
771 FLAC__ASSERT(0 != br);
|
|
772 FLAC__ASSERT(0 != br->buffer);
|
|
773 FLAC__ASSERT(parameter <= 31);
|
|
774
|
|
775 /* read the unary MSBs and end bit */
|
|
776 if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
|
|
777 return false;
|
|
778
|
|
779 /* read the binary LSBs */
|
|
780 if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, parameter))
|
|
781 return false;
|
|
782
|
|
783 /* compose the value */
|
|
784 uval = (msbs << parameter) | lsbs;
|
|
785 if(uval & 1)
|
|
786 *val = -((int)(uval >> 1)) - 1;
|
|
787 else
|
|
788 *val = (int)(uval >> 1);
|
|
789
|
|
790 return true;
|
|
791 }
|
|
792
|
|
793 /* this is by far the most heavily used reader call. it ain't pretty but it's fast */
|
|
794 /* a lot of the logic is copied, then adapted, from FLAC__bitreader_read_unary_unsigned() and FLAC__bitreader_read_raw_uint32() */
|
|
795 FLAC__bool FLAC__bitreader_read_rice_signed_block(FLAC__BitReader *br, int vals[], unsigned nvals, unsigned parameter)
|
|
796 {
|
|
797 unsigned i;
|
|
798 unsigned uval = 0;
|
|
799 unsigned bits; /* the # of binary LSBs left to read to finish a rice codeword */
|
|
800
|
|
801 /* try and get br->consumed_words and br->consumed_bits into register;
|
|
802 * must remember to flush them back to *br before calling other
|
|
803 * bitwriter functions that use them, and before returning */
|
|
804 register unsigned cwords;
|
|
805 register unsigned cbits;
|
|
806
|
|
807 FLAC__ASSERT(0 != br);
|
|
808 FLAC__ASSERT(0 != br->buffer);
|
|
809 /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
|
|
810 FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
|
|
811 FLAC__ASSERT(parameter < 32);
|
|
812 /* the above two asserts also guarantee that the binary part never straddles more that 2 words, so we don't have to loop to read it */
|
|
813
|
|
814 if(nvals == 0)
|
|
815 return true;
|
|
816
|
|
817 cbits = br->consumed_bits;
|
|
818 cwords = br->consumed_words;
|
|
819
|
|
820 while(1) {
|
|
821
|
|
822 /* read unary part */
|
|
823 while(1) {
|
|
824 while(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
|
|
825 brword b = br->buffer[cwords] << cbits;
|
|
826 if(b) {
|
|
827 #if 0 /* too slow, but this is the idea: */
|
|
828 for(i = 0; !(b & FLAC__WORD_TOP_BIT_ONE); i++)
|
|
829 b <<= 1;
|
|
830 #else
|
|
831 i = ALIGNED_UNARY_BITS(b);
|
|
832 #endif
|
|
833 uval += i;
|
|
834 bits = parameter;
|
|
835 i++;
|
|
836 cbits += i;
|
|
837 if(cbits == FLAC__BITS_PER_WORD) {
|
|
838 crc16_update_word_(br, br->buffer[cwords]);
|
|
839 cwords++;
|
|
840 cbits = 0;
|
|
841 }
|
|
842 goto break1;
|
|
843 }
|
|
844 else {
|
|
845 uval += FLAC__BITS_PER_WORD - cbits;
|
|
846 crc16_update_word_(br, br->buffer[cwords]);
|
|
847 cwords++;
|
|
848 cbits = 0;
|
|
849 /* didn't find stop bit yet, have to keep going... */
|
|
850 }
|
|
851 }
|
|
852 /* at this point we've eaten up all the whole words; have to try
|
|
853 * reading through any tail bytes before calling the read callback.
|
|
854 * this is a repeat of the above logic adjusted for the fact we
|
|
855 * don't have a whole word. note though if the client is feeding
|
|
856 * us data a byte at a time (unlikely), br->consumed_bits may not
|
|
857 * be zero.
|
|
858 */
|
|
859 if(br->bytes) {
|
|
860 const unsigned end = br->bytes * 8;
|
|
861 brword b = (br->buffer[cwords] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << cbits;
|
|
862 if(b) {
|
|
863 #if 0 /* too slow, but this is the idea: */
|
|
864 for(i = 0; !(b & FLAC__WORD_TOP_BIT_ONE); i++)
|
|
865 b <<= 1;
|
|
866 #else
|
|
867 i = ALIGNED_UNARY_BITS(b);
|
|
868 #endif
|
|
869 uval += i;
|
|
870 bits = parameter;
|
|
871 i++;
|
|
872 cbits += i;
|
|
873 FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);
|
|
874 goto break1;
|
|
875 }
|
|
876 else {
|
|
877 uval += end - cbits;
|
|
878 cbits += end;
|
|
879 FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);
|
|
880 /* didn't find stop bit yet, have to keep going... */
|
|
881 }
|
|
882 }
|
|
883 /* flush registers and read; bitreader_read_from_client_() does
|
|
884 * not touch br->consumed_bits at all but we still need to set
|
|
885 * it in case it fails and we have to return false.
|
|
886 */
|
|
887 br->consumed_bits = cbits;
|
|
888 br->consumed_words = cwords;
|
|
889 if(!bitreader_read_from_client_(br))
|
|
890 return false;
|
|
891 cwords = br->consumed_words;
|
|
892 }
|
|
893 break1:
|
|
894 /* read binary part */
|
|
895 FLAC__ASSERT(cwords <= br->words);
|
|
896
|
|
897 if(bits) {
|
|
898 while((br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits < bits) {
|
|
899 /* flush registers and read; bitreader_read_from_client_() does
|
|
900 * not touch br->consumed_bits at all but we still need to set
|
|
901 * it in case it fails and we have to return false.
|
|
902 */
|
|
903 br->consumed_bits = cbits;
|
|
904 br->consumed_words = cwords;
|
|
905 if(!bitreader_read_from_client_(br))
|
|
906 return false;
|
|
907 cwords = br->consumed_words;
|
|
908 }
|
|
909 if(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
|
|
910 if(cbits) {
|
|
911 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
|
|
912 const unsigned n = FLAC__BITS_PER_WORD - cbits;
|
|
913 const brword word = br->buffer[cwords];
|
|
914 if(bits < n) {
|
|
915 uval <<= bits;
|
|
916 uval |= (word & (FLAC__WORD_ALL_ONES >> cbits)) >> (n-bits);
|
|
917 cbits += bits;
|
|
918 goto break2;
|
|
919 }
|
|
920 uval <<= n;
|
|
921 uval |= word & (FLAC__WORD_ALL_ONES >> cbits);
|
|
922 bits -= n;
|
|
923 crc16_update_word_(br, word);
|
|
924 cwords++;
|
|
925 cbits = 0;
|
|
926 if(bits) { /* if there are still bits left to read, there have to be less than 32 so they will all be in the next word */
|
|
927 uval <<= bits;
|
|
928 uval |= (br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits));
|
|
929 cbits = bits;
|
|
930 }
|
|
931 goto break2;
|
|
932 }
|
|
933 else {
|
|
934 FLAC__ASSERT(bits < FLAC__BITS_PER_WORD);
|
|
935 uval <<= bits;
|
|
936 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits);
|
|
937 cbits = bits;
|
|
938 goto break2;
|
|
939 }
|
|
940 }
|
|
941 else {
|
|
942 /* in this case we're starting our read at a partial tail word;
|
|
943 * the reader has guaranteed that we have at least 'bits' bits
|
|
944 * available to read, which makes this case simpler.
|
|
945 */
|
|
946 uval <<= bits;
|
|
947 if(cbits) {
|
|
948 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
|
|
949 FLAC__ASSERT(cbits + bits <= br->bytes*8);
|
|
950 uval |= (br->buffer[cwords] & (FLAC__WORD_ALL_ONES >> cbits)) >> (FLAC__BITS_PER_WORD-cbits-bits);
|
|
951 cbits += bits;
|
|
952 goto break2;
|
|
953 }
|
|
954 else {
|
|
955 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits);
|
|
956 cbits += bits;
|
|
957 goto break2;
|
|
958 }
|
|
959 }
|
|
960 }
|
|
961 break2:
|
|
962 /* compose the value */
|
|
963 *vals = (int)(uval >> 1 ^ -(int)(uval & 1));
|
|
964
|
|
965 /* are we done? */
|
|
966 --nvals;
|
|
967 if(nvals == 0) {
|
|
968 br->consumed_bits = cbits;
|
|
969 br->consumed_words = cwords;
|
|
970 return true;
|
|
971 }
|
|
972
|
|
973 uval = 0;
|
|
974 ++vals;
|
|
975
|
|
976 }
|
|
977 }
|
|
978
|
|
979 #if 0 /* UNUSED */
|
|
980 FLAC__bool FLAC__bitreader_read_golomb_signed(FLAC__BitReader *br, int *val, unsigned parameter)
|
|
981 {
|
|
982 FLAC__uint32 lsbs = 0, msbs = 0;
|
|
983 unsigned bit, uval, k;
|
|
984
|
|
985 FLAC__ASSERT(0 != br);
|
|
986 FLAC__ASSERT(0 != br->buffer);
|
|
987
|
|
988 k = FLAC__bitmath_ilog2(parameter);
|
|
989
|
|
990 /* read the unary MSBs and end bit */
|
|
991 if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
|
|
992 return false;
|
|
993
|
|
994 /* read the binary LSBs */
|
|
995 if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))
|
|
996 return false;
|
|
997
|
|
998 if(parameter == 1u<<k) {
|
|
999 /* compose the value */
|
|
1000 uval = (msbs << k) | lsbs;
|
|
1001 }
|
|
1002 else {
|
|
1003 unsigned d = (1 << (k+1)) - parameter;
|
|
1004 if(lsbs >= d) {
|
|
1005 if(!FLAC__bitreader_read_bit(br, &bit))
|
|
1006 return false;
|
|
1007 lsbs <<= 1;
|
|
1008 lsbs |= bit;
|
|
1009 lsbs -= d;
|
|
1010 }
|
|
1011 /* compose the value */
|
|
1012 uval = msbs * parameter + lsbs;
|
|
1013 }
|
|
1014
|
|
1015 /* unfold unsigned to signed */
|
|
1016 if(uval & 1)
|
|
1017 *val = -((int)(uval >> 1)) - 1;
|
|
1018 else
|
|
1019 *val = (int)(uval >> 1);
|
|
1020
|
|
1021 return true;
|
|
1022 }
|
|
1023
|
|
1024 FLAC__bool FLAC__bitreader_read_golomb_unsigned(FLAC__BitReader *br, unsigned *val, unsigned parameter)
|
|
1025 {
|
|
1026 FLAC__uint32 lsbs, msbs = 0;
|
|
1027 unsigned bit, k;
|
|
1028
|
|
1029 FLAC__ASSERT(0 != br);
|
|
1030 FLAC__ASSERT(0 != br->buffer);
|
|
1031
|
|
1032 k = FLAC__bitmath_ilog2(parameter);
|
|
1033
|
|
1034 /* read the unary MSBs and end bit */
|
|
1035 if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
|
|
1036 return false;
|
|
1037
|
|
1038 /* read the binary LSBs */
|
|
1039 if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))
|
|
1040 return false;
|
|
1041
|
|
1042 if(parameter == 1u<<k) {
|
|
1043 /* compose the value */
|
|
1044 *val = (msbs << k) | lsbs;
|
|
1045 }
|
|
1046 else {
|
|
1047 unsigned d = (1 << (k+1)) - parameter;
|
|
1048 if(lsbs >= d) {
|
|
1049 if(!FLAC__bitreader_read_bit(br, &bit))
|
|
1050 return false;
|
|
1051 lsbs <<= 1;
|
|
1052 lsbs |= bit;
|
|
1053 lsbs -= d;
|
|
1054 }
|
|
1055 /* compose the value */
|
|
1056 *val = msbs * parameter + lsbs;
|
|
1057 }
|
|
1058
|
|
1059 return true;
|
|
1060 }
|
|
1061 #endif /* UNUSED */
|
|
1062
|
|
1063 /* on return, if *val == 0xffffffff then the utf-8 sequence was invalid, but the return value will be true */
|
|
1064 FLAC__bool FLAC__bitreader_read_utf8_uint32(FLAC__BitReader *br, FLAC__uint32 *val, FLAC__byte *raw, unsigned *rawlen)
|
|
1065 {
|
|
1066 FLAC__uint32 v = 0;
|
|
1067 FLAC__uint32 x;
|
|
1068 unsigned i;
|
|
1069
|
|
1070 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
|
|
1071 return false;
|
|
1072 if(raw)
|
|
1073 raw[(*rawlen)++] = (FLAC__byte)x;
|
|
1074 if(!(x & 0x80)) { /* 0xxxxxxx */
|
|
1075 v = x;
|
|
1076 i = 0;
|
|
1077 }
|
|
1078 else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
|
|
1079 v = x & 0x1F;
|
|
1080 i = 1;
|
|
1081 }
|
|
1082 else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
|
|
1083 v = x & 0x0F;
|
|
1084 i = 2;
|
|
1085 }
|
|
1086 else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
|
|
1087 v = x & 0x07;
|
|
1088 i = 3;
|
|
1089 }
|
|
1090 else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
|
|
1091 v = x & 0x03;
|
|
1092 i = 4;
|
|
1093 }
|
|
1094 else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
|
|
1095 v = x & 0x01;
|
|
1096 i = 5;
|
|
1097 }
|
|
1098 else {
|
|
1099 *val = 0xffffffff;
|
|
1100 return true;
|
|
1101 }
|
|
1102 for( ; i; i--) {
|
|
1103 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
|
|
1104 return false;
|
|
1105 if(raw)
|
|
1106 raw[(*rawlen)++] = (FLAC__byte)x;
|
|
1107 if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
|
|
1108 *val = 0xffffffff;
|
|
1109 return true;
|
|
1110 }
|
|
1111 v <<= 6;
|
|
1112 v |= (x & 0x3F);
|
|
1113 }
|
|
1114 *val = v;
|
|
1115 return true;
|
|
1116 }
|
|
1117
|
|
1118 /* on return, if *val == 0xffffffffffffffff then the utf-8 sequence was invalid, but the return value will be true */
|
|
1119 FLAC__bool FLAC__bitreader_read_utf8_uint64(FLAC__BitReader *br, FLAC__uint64 *val, FLAC__byte *raw, unsigned *rawlen)
|
|
1120 {
|
|
1121 FLAC__uint64 v = 0;
|
|
1122 FLAC__uint32 x;
|
|
1123 unsigned i;
|
|
1124
|
|
1125 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
|
|
1126 return false;
|
|
1127 if(raw)
|
|
1128 raw[(*rawlen)++] = (FLAC__byte)x;
|
|
1129 if(!(x & 0x80)) { /* 0xxxxxxx */
|
|
1130 v = x;
|
|
1131 i = 0;
|
|
1132 }
|
|
1133 else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
|
|
1134 v = x & 0x1F;
|
|
1135 i = 1;
|
|
1136 }
|
|
1137 else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
|
|
1138 v = x & 0x0F;
|
|
1139 i = 2;
|
|
1140 }
|
|
1141 else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
|
|
1142 v = x & 0x07;
|
|
1143 i = 3;
|
|
1144 }
|
|
1145 else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
|
|
1146 v = x & 0x03;
|
|
1147 i = 4;
|
|
1148 }
|
|
1149 else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
|
|
1150 v = x & 0x01;
|
|
1151 i = 5;
|
|
1152 }
|
|
1153 else if(x & 0xFE && !(x & 0x01)) { /* 11111110 */
|
|
1154 v = 0;
|
|
1155 i = 6;
|
|
1156 }
|
|
1157 else {
|
|
1158 *val = FLAC__U64L(0xffffffffffffffff);
|
|
1159 return true;
|
|
1160 }
|
|
1161 for( ; i; i--) {
|
|
1162 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
|
|
1163 return false;
|
|
1164 if(raw)
|
|
1165 raw[(*rawlen)++] = (FLAC__byte)x;
|
|
1166 if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
|
|
1167 *val = FLAC__U64L(0xffffffffffffffff);
|
|
1168 return true;
|
|
1169 }
|
|
1170 v <<= 6;
|
|
1171 v |= (x & 0x3F);
|
|
1172 }
|
|
1173 *val = v;
|
|
1174 return true;
|
|
1175 }
|