1 /* libFLAC - Free Lossless Audio Codec library
2 * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007 Josh Coalson
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
8 * - Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
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.
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.
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.
36 #include <stdlib.h> /* for malloc() */
37 #include <string.h> /* for memcpy(), memset() */
39 #include <winsock.h> /* for ntohl() */
40 #elif defined FLAC__SYS_DARWIN
41 #include <machine/endian.h> /* for ntohl() */
42 #elif defined __MINGW32__
43 #include <winsock.h> /* for ntohl() */
45 //#include <netinet/in.h> /* for ntohl() */
47 #include "private/bitmath.h"
48 #include "private/bitreader.h"
49 #include "private/crc.h"
50 #include "flac/assert.h"
52 static unsigned long ntohl(unsigned long x) {
53 x = (x >> 16UL) | (x << 16UL);
54 x = ((x & 0x00FF00FFUL) << 8UL) | ((x & 0xFF00FF00UL) >> 8UL);
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 COUNT_ZERO_MSBS 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 /* SWAP_BE_WORD_TO_HOST swaps bytes in a brword (which is always big-endian) if necessary to match host byte order */
68 #define SWAP_BE_WORD_TO_HOST(x) (x)
71 #define SWAP_BE_WORD_TO_HOST(x) local_swap32_(x)
73 #define SWAP_BE_WORD_TO_HOST(x) ntohl(x)
76 /* counts the # of zero MSBs in a word */
77 #define COUNT_ZERO_MSBS(word) ( \
79 ( (word) <= 0xff? byte_to_unary_table[word] + 24 : byte_to_unary_table[(word) >> 8] + 16 ) : \
80 ( (word) <= 0xffffff? byte_to_unary_table[word >> 16] + 8 : byte_to_unary_table[(word) >> 24] ) \
82 /* this alternate might be slightly faster on some systems/compilers: */
83 #define COUNT_ZERO_MSBS2(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])) )
87 * This should be at least twice as large as the largest number of words
88 * required to represent any 'number' (in any encoding) you are going to
89 * read. With FLAC this is on the order of maybe a few hundred bits.
90 * If the buffer is smaller than that, the decoder won't be able to read
91 * in a whole number that is in a variable length encoding (e.g. Rice).
92 * But to be practical it should be at least 1K bytes.
94 * Increase this number to decrease the number of read callbacks, at the
95 * expense of using more memory. Or decrease for the reverse effect,
96 * keeping in mind the limit from the first paragraph. The optimal size
97 * also depends on the CPU cache size and other factors; some twiddling
98 * may be necessary to squeeze out the best performance.
100 static const unsigned FLAC__BITREADER_DEFAULT_CAPACITY = 65536u / FLAC__BITS_PER_WORD; /* in words */
102 static const unsigned char byte_to_unary_table[] = {
103 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
104 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
105 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
106 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
107 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
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 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
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
124 #define min(x,y) ((x)<(y)?(x):(y))
128 #define max(x,y) ((x)>(y)?(x):(y))
130 /* adjust for compilers that can't understand using LLU suffix for uint64_t literals */
132 #define FLAC__U64L(x) x
134 #define FLAC__U64L(x) x##LLU
141 /* WATCHOUT: assembly routines rely on the order in which these fields are declared */
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 */
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; /* #words ... */
150 unsigned consumed_bits; /* ... + (#bits of head word) already consumed from the front of buffer */
151 unsigned read_crc16; /* the running frame CRC */
152 unsigned crc16_align; /* the number of bits in the current consumed word that should not be CRC'd */
153 FLAC__BitReaderReadCallback read_callback;
155 FLAC__CPUInfo cpu_info;
159 /* OPT: an MSVC built-in would be better */
160 static _inline FLAC__uint32 local_swap32_(FLAC__uint32 x)
162 x = ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF);
163 return (x>>16) | (x<<16);
165 static void local_swap32_block_(FLAC__uint32 *start, FLAC__uint32 len)
184 static FLaC__INLINE void crc16_update_word_(FLAC__BitReader *br, brword word)
186 register unsigned crc = br->read_crc16;
187 #if FLAC__BYTES_PER_WORD == 4
188 switch(br->crc16_align) {
189 case 0: crc = FLAC__CRC16_UPDATE((unsigned)(word >> 24), crc);
190 case 8: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 16) & 0xff), crc);
191 case 16: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 8) & 0xff), crc);
192 case 24: br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)(word & 0xff), crc);
194 #elif FLAC__BYTES_PER_WORD == 8
195 switch(br->crc16_align) {
196 case 0: crc = FLAC__CRC16_UPDATE((unsigned)(word >> 56), crc);
197 case 8: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 48) & 0xff), crc);
198 case 16: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 40) & 0xff), crc);
199 case 24: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 32) & 0xff), crc);
200 case 32: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 24) & 0xff), crc);
201 case 40: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 16) & 0xff), crc);
202 case 48: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 8) & 0xff), crc);
203 case 56: br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)(word & 0xff), crc);
206 for( ; br->crc16_align < FLAC__BITS_PER_WORD; br->crc16_align += 8)
207 crc = FLAC__CRC16_UPDATE((unsigned)((word >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), crc);
208 br->read_crc16 = crc;
213 /* would be static except it needs to be called by asm routines */
214 FLAC__bool bitreader_read_from_client_(FLAC__BitReader *br)
220 /* first shift the unconsumed buffer data toward the front as much as possible */
221 if(br->consumed_words > 0) {
222 start = br->consumed_words;
223 end = br->words + (br->bytes? 1:0);
224 memmove(br->buffer, br->buffer+start, FLAC__BYTES_PER_WORD * (end - start));
227 br->consumed_words = 0;
231 * set the target for reading, taking into account word alignment and endianness
233 bytes = (br->capacity - br->words) * FLAC__BYTES_PER_WORD - br->bytes;
235 return false; /* no space left, buffer is too small; see note for FLAC__BITREADER_DEFAULT_CAPACITY */
236 target = ((FLAC__byte*)(br->buffer+br->words)) + br->bytes;
238 /* before reading, if the existing reader looks like this (say brword is 32 bits wide)
239 * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1 (partial tail word is left-justified)
240 * buffer[BE]: 11 22 33 44 55 ?? ?? ?? (shown layed out as bytes sequentially in memory)
241 * buffer[LE]: 44 33 22 11 ?? ?? ?? 55 (?? being don't-care)
242 * ^^-------target, bytes=3
243 * on LE machines, have to byteswap the odd tail word so nothing is
249 br->buffer[br->words] = SWAP_BE_WORD_TO_HOST(br->buffer[br->words]);
252 /* now it looks like:
253 * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1
254 * buffer[BE]: 11 22 33 44 55 ?? ?? ??
255 * buffer[LE]: 44 33 22 11 55 ?? ?? ??
256 * ^^-------target, bytes=3
259 /* read in the data; note that the callback may return a smaller number of bytes */
260 if(!br->read_callback(target, &bytes, br->client_data))
263 /* after reading bytes 66 77 88 99 AA BB CC DD EE FF from the client:
264 * bitstream : 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF
265 * buffer[BE]: 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??
266 * buffer[LE]: 44 33 22 11 55 66 77 88 99 AA BB CC DD EE FF ??
267 * now have to byteswap on LE machines:
271 end = (br->words*FLAC__BYTES_PER_WORD + br->bytes + bytes + (FLAC__BYTES_PER_WORD-1)) / FLAC__BYTES_PER_WORD;
272 # if defined(_MSC_VER) && (FLAC__BYTES_PER_WORD == 4)
273 if(br->cpu_info.type == FLAC__CPUINFO_TYPE_IA32 && br->cpu_info.data.ia32.bswap) {
275 local_swap32_block_(br->buffer + start, end - start);
279 for(start = br->words; start < end; start++)
280 br->buffer[start] = SWAP_BE_WORD_TO_HOST(br->buffer[start]);
283 /* now it looks like:
284 * bitstream : 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF
285 * buffer[BE]: 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??
286 * buffer[LE]: 44 33 22 11 88 77 66 55 CC BB AA 99 ?? FF EE DD
287 * finally we'll update the reader values:
289 end = br->words*FLAC__BYTES_PER_WORD + br->bytes + bytes;
290 br->words = end / FLAC__BYTES_PER_WORD;
291 br->bytes = end % FLAC__BYTES_PER_WORD;
296 /***********************************************************************
298 * Class constructor/destructor
300 ***********************************************************************/
302 FLAC__BitReader *FLAC__bitreader_new(void)
304 FLAC__BitReader *br = (FLAC__BitReader*)calloc(1, sizeof(FLAC__BitReader));
307 memset(br, 0, sizeof(FLAC__BitReader));
310 br->words = br->bytes = 0;
311 br->consumed_words = br->consumed_bits = 0;
312 br->read_callback = 0;
318 void FLAC__bitreader_delete(FLAC__BitReader *br)
320 FLAC__ASSERT(0 != br);
322 FLAC__bitreader_free(br);
326 /***********************************************************************
328 * Public class methods
330 ***********************************************************************/
332 FLAC__bool FLAC__bitreader_init(FLAC__BitReader *br, FLAC__CPUInfo cpu, FLAC__BitReaderReadCallback rcb, void *cd)
334 FLAC__ASSERT(0 != br);
336 br->words = br->bytes = 0;
337 br->consumed_words = br->consumed_bits = 0;
338 br->capacity = FLAC__BITREADER_DEFAULT_CAPACITY;
339 br->buffer = (brword*)malloc(sizeof(brword) * br->capacity);
342 br->read_callback = rcb;
343 br->client_data = cd;
349 void FLAC__bitreader_free(FLAC__BitReader *br)
351 FLAC__ASSERT(0 != br);
357 br->words = br->bytes = 0;
358 br->consumed_words = br->consumed_bits = 0;
359 br->read_callback = 0;
363 FLAC__bool FLAC__bitreader_clear(FLAC__BitReader *br)
365 br->words = br->bytes = 0;
366 br->consumed_words = br->consumed_bits = 0;
370 void FLAC__bitreader_dump(const FLAC__BitReader *br, FILE *out)
374 fprintf(out, "bitreader is NULL\n");
377 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);
379 for(i = 0; i < br->words; i++) {
380 fprintf(out, "%08X: ", i);
381 for(j = 0; j < FLAC__BITS_PER_WORD; j++)
382 if(i < br->consumed_words || (i == br->consumed_words && j < br->consumed_bits))
385 fprintf(out, "%01u", br->buffer[i] & (1 << (FLAC__BITS_PER_WORD-j-1)) ? 1:0);
389 fprintf(out, "%08X: ", i);
390 for(j = 0; j < br->bytes*8; j++)
391 if(i < br->consumed_words || (i == br->consumed_words && j < br->consumed_bits))
394 fprintf(out, "%01u", br->buffer[i] & (1 << (br->bytes*8-j-1)) ? 1:0);
400 void FLAC__bitreader_reset_read_crc16(FLAC__BitReader *br, FLAC__uint16 seed)
402 FLAC__ASSERT(0 != br);
403 FLAC__ASSERT(0 != br->buffer);
404 FLAC__ASSERT((br->consumed_bits & 7) == 0);
406 br->read_crc16 = (unsigned)seed;
407 br->crc16_align = br->consumed_bits;
410 FLAC__uint16 FLAC__bitreader_get_read_crc16(FLAC__BitReader *br)
412 FLAC__ASSERT(0 != br);
413 FLAC__ASSERT(0 != br->buffer);
414 FLAC__ASSERT((br->consumed_bits & 7) == 0);
415 FLAC__ASSERT(br->crc16_align <= br->consumed_bits);
417 /* CRC any tail bytes in a partially-consumed word */
418 if(br->consumed_bits) {
419 const brword tail = br->buffer[br->consumed_words];
420 for( ; br->crc16_align < br->consumed_bits; br->crc16_align += 8)
421 br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)((tail >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), br->read_crc16);
423 return br->read_crc16;
426 FLaC__INLINE FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br)
428 return ((br->consumed_bits & 7) == 0);
431 FLaC__INLINE unsigned FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br)
433 return 8 - (br->consumed_bits & 7);
436 FLaC__INLINE unsigned FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br)
438 return (br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits;
441 FLaC__INLINE FLAC__bool FLAC__bitreader_read_raw_uint32(FLAC__BitReader *br, FLAC__uint32 *val, unsigned bits)
443 FLAC__ASSERT(0 != br);
444 FLAC__ASSERT(0 != br->buffer);
446 FLAC__ASSERT(bits <= 32);
447 FLAC__ASSERT((br->capacity*FLAC__BITS_PER_WORD) * 2 >= bits);
448 FLAC__ASSERT(br->consumed_words <= br->words);
450 /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
451 FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
453 if(bits == 0) { /* OPT: investigate if this can ever happen, maybe change to assertion */
458 while((br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits < bits) {
459 if(!bitreader_read_from_client_(br))
462 if(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */
463 /* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */
464 if(br->consumed_bits) {
465 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
466 const unsigned n = FLAC__BITS_PER_WORD - br->consumed_bits;
467 const brword word = br->buffer[br->consumed_words];
469 *val = (word & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (n-bits);
470 br->consumed_bits += bits;
473 *val = word & (FLAC__WORD_ALL_ONES >> br->consumed_bits);
475 crc16_update_word_(br, word);
476 br->consumed_words++;
477 br->consumed_bits = 0;
478 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 */
480 *val |= (br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits));
481 br->consumed_bits = bits;
486 const brword word = br->buffer[br->consumed_words];
487 if(bits < FLAC__BITS_PER_WORD) {
488 *val = word >> (FLAC__BITS_PER_WORD-bits);
489 br->consumed_bits = bits;
492 /* at this point 'bits' must be == FLAC__BITS_PER_WORD; because of previous assertions, it can't be larger */
494 crc16_update_word_(br, word);
495 br->consumed_words++;
500 /* in this case we're starting our read at a partial tail word;
501 * the reader has guaranteed that we have at least 'bits' bits
502 * available to read, which makes this case simpler.
504 /* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */
505 if(br->consumed_bits) {
506 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
507 FLAC__ASSERT(br->consumed_bits + bits <= br->bytes*8);
508 *val = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (FLAC__BITS_PER_WORD-br->consumed_bits-bits);
509 br->consumed_bits += bits;
513 *val = br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits);
514 br->consumed_bits += bits;
520 FLAC__bool FLAC__bitreader_read_raw_int32(FLAC__BitReader *br, FLAC__int32 *val, unsigned bits)
522 /* OPT: inline raw uint32 code here, or make into a macro if possible in the .h file */
523 if(!FLAC__bitreader_read_raw_uint32(br, (FLAC__uint32*)val, bits))
531 FLAC__bool FLAC__bitreader_read_raw_uint64(FLAC__BitReader *br, FLAC__uint64 *val, unsigned bits)
536 if(!FLAC__bitreader_read_raw_uint32(br, &hi, bits-32))
538 if(!FLAC__bitreader_read_raw_uint32(br, &lo, 32))
545 if(!FLAC__bitreader_read_raw_uint32(br, &lo, bits))
552 FLaC__INLINE FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val)
554 FLAC__uint32 x8, x32 = 0;
556 /* this doesn't need to be that fast as currently it is only used for vorbis comments */
558 if(!FLAC__bitreader_read_raw_uint32(br, &x32, 8))
561 if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
565 if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
569 if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
577 FLAC__bool FLAC__bitreader_skip_bits_no_crc(FLAC__BitReader *br, unsigned bits)
580 * OPT: a faster implementation is possible but probably not that useful
581 * since this is only called a couple of times in the metadata readers.
583 FLAC__ASSERT(0 != br);
584 FLAC__ASSERT(0 != br->buffer);
587 const unsigned n = br->consumed_bits & 7;
593 if(!FLAC__bitreader_read_raw_uint32(br, &x, m))
599 if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(br, m))
604 if(!FLAC__bitreader_read_raw_uint32(br, &x, bits))
612 FLAC__bool FLAC__bitreader_skip_byte_block_aligned_no_crc(FLAC__BitReader *br, unsigned nvals)
616 FLAC__ASSERT(0 != br);
617 FLAC__ASSERT(0 != br->buffer);
618 FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
620 /* step 1: skip over partial head word to get word aligned */
621 while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
622 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
628 /* step 2: skip whole words in chunks */
629 while(nvals >= FLAC__BYTES_PER_WORD) {
630 if(br->consumed_words < br->words) {
631 br->consumed_words++;
632 nvals -= FLAC__BYTES_PER_WORD;
634 else if(!bitreader_read_from_client_(br))
637 /* step 3: skip any remainder from partial tail bytes */
639 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
647 FLAC__bool FLAC__bitreader_read_byte_block_aligned_no_crc(FLAC__BitReader *br, FLAC__byte *val, unsigned nvals)
651 FLAC__ASSERT(0 != br);
652 FLAC__ASSERT(0 != br->buffer);
653 FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
655 /* step 1: read from partial head word to get word aligned */
656 while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
657 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
659 *val++ = (FLAC__byte)x;
664 /* step 2: read whole words in chunks */
665 while(nvals >= FLAC__BYTES_PER_WORD) {
666 if(br->consumed_words < br->words) {
667 const brword word = br->buffer[br->consumed_words++];
668 #if FLAC__BYTES_PER_WORD == 4
669 val[0] = (FLAC__byte)(word >> 24);
670 val[1] = (FLAC__byte)(word >> 16);
671 val[2] = (FLAC__byte)(word >> 8);
672 val[3] = (FLAC__byte)word;
673 #elif FLAC__BYTES_PER_WORD == 8
674 val[0] = (FLAC__byte)(word >> 56);
675 val[1] = (FLAC__byte)(word >> 48);
676 val[2] = (FLAC__byte)(word >> 40);
677 val[3] = (FLAC__byte)(word >> 32);
678 val[4] = (FLAC__byte)(word >> 24);
679 val[5] = (FLAC__byte)(word >> 16);
680 val[6] = (FLAC__byte)(word >> 8);
681 val[7] = (FLAC__byte)word;
683 for(x = 0; x < FLAC__BYTES_PER_WORD; x++)
684 val[x] = (FLAC__byte)(word >> (8*(FLAC__BYTES_PER_WORD-x-1)));
686 val += FLAC__BYTES_PER_WORD;
687 nvals -= FLAC__BYTES_PER_WORD;
689 else if(!bitreader_read_from_client_(br))
692 /* step 3: read any remainder from partial tail bytes */
694 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
696 *val++ = (FLAC__byte)x;
703 FLaC__INLINE FLAC__bool FLAC__bitreader_read_unary_unsigned(FLAC__BitReader *br, unsigned *val)
704 #if 0 /* slow but readable version */
708 FLAC__ASSERT(0 != br);
709 FLAC__ASSERT(0 != br->buffer);
713 if(!FLAC__bitreader_read_bit(br, &bit))
726 FLAC__ASSERT(0 != br);
727 FLAC__ASSERT(0 != br->buffer);
731 while(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */
732 brword b = br->buffer[br->consumed_words] << br->consumed_bits;
734 i = COUNT_ZERO_MSBS(b);
737 br->consumed_bits += i;
738 if(br->consumed_bits >= FLAC__BITS_PER_WORD) { /* faster way of testing if(br->consumed_bits == FLAC__BITS_PER_WORD) */
739 crc16_update_word_(br, br->buffer[br->consumed_words]);
740 br->consumed_words++;
741 br->consumed_bits = 0;
746 *val += FLAC__BITS_PER_WORD - br->consumed_bits;
747 crc16_update_word_(br, br->buffer[br->consumed_words]);
748 br->consumed_words++;
749 br->consumed_bits = 0;
750 /* didn't find stop bit yet, have to keep going... */
753 /* at this point we've eaten up all the whole words; have to try
754 * reading through any tail bytes before calling the read callback.
755 * this is a repeat of the above logic adjusted for the fact we
756 * don't have a whole word. note though if the client is feeding
757 * us data a byte at a time (unlikely), br->consumed_bits may not
761 const unsigned end = br->bytes * 8;
762 brword b = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << br->consumed_bits;
764 i = COUNT_ZERO_MSBS(b);
767 br->consumed_bits += i;
768 FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);
772 *val += end - br->consumed_bits;
773 br->consumed_bits += end;
774 FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);
775 /* didn't find stop bit yet, have to keep going... */
778 if(!bitreader_read_from_client_(br))
784 FLAC__bool FLAC__bitreader_read_rice_signed(FLAC__BitReader *br, int *val, unsigned parameter)
786 FLAC__uint32 lsbs = 0, msbs = 0;
789 FLAC__ASSERT(0 != br);
790 FLAC__ASSERT(0 != br->buffer);
791 FLAC__ASSERT(parameter <= 31);
793 /* read the unary MSBs and end bit */
794 if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
797 /* read the binary LSBs */
798 if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, parameter))
801 /* compose the value */
802 uval = (msbs << parameter) | lsbs;
804 *val = -((int)(uval >> 1)) - 1;
806 *val = (int)(uval >> 1);
811 /* this is by far the most heavily used reader call. it ain't pretty but it's fast */
812 /* a lot of the logic is copied, then adapted, from FLAC__bitreader_read_unary_unsigned() and FLAC__bitreader_read_raw_uint32() */
813 FLAC__bool FLAC__bitreader_read_rice_signed_block(FLAC__BitReader *br, int vals[], unsigned nvals, unsigned parameter)
814 /* OPT: possibly faster version for use with MSVC */
819 unsigned bits; /* the # of binary LSBs left to read to finish a rice codeword */
821 /* try and get br->consumed_words and br->consumed_bits into register;
822 * must remember to flush them back to *br before calling other
823 * bitwriter functions that use them, and before returning */
824 register unsigned cwords;
825 register unsigned cbits;
827 FLAC__ASSERT(0 != br);
828 FLAC__ASSERT(0 != br->buffer);
829 /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
830 FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
831 FLAC__ASSERT(parameter < 32);
832 /* 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 */
837 cbits = br->consumed_bits;
838 cwords = br->consumed_words;
842 /* read unary part */
844 while(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
845 brword b = br->buffer[cwords] << cbits;
847 #if 0 /* slower, probably due to bad register allocation... */ && defined FLAC__CPU_IA32 && !defined FLAC__NO_ASM && FLAC__BITS_PER_WORD == 32
855 i = COUNT_ZERO_MSBS(b);
861 if(cbits == FLAC__BITS_PER_WORD) {
862 crc16_update_word_(br, br->buffer[cwords]);
869 uval += FLAC__BITS_PER_WORD - cbits;
870 crc16_update_word_(br, br->buffer[cwords]);
873 /* didn't find stop bit yet, have to keep going... */
876 /* at this point we've eaten up all the whole words; have to try
877 * reading through any tail bytes before calling the read callback.
878 * this is a repeat of the above logic adjusted for the fact we
879 * don't have a whole word. note though if the client is feeding
880 * us data a byte at a time (unlikely), br->consumed_bits may not
884 const unsigned end = br->bytes * 8;
885 brword b = (br->buffer[cwords] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << cbits;
887 i = COUNT_ZERO_MSBS(b);
892 FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);
898 FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);
899 /* didn't find stop bit yet, have to keep going... */
902 /* flush registers and read; bitreader_read_from_client_() does
903 * not touch br->consumed_bits at all but we still need to set
904 * it in case it fails and we have to return false.
906 br->consumed_bits = cbits;
907 br->consumed_words = cwords;
908 if(!bitreader_read_from_client_(br))
910 cwords = br->consumed_words;
913 /* read binary part */
914 FLAC__ASSERT(cwords <= br->words);
917 while((br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits < bits) {
918 /* flush registers and read; bitreader_read_from_client_() does
919 * not touch br->consumed_bits at all but we still need to set
920 * it in case it fails and we have to return false.
922 br->consumed_bits = cbits;
923 br->consumed_words = cwords;
924 if(!bitreader_read_from_client_(br))
926 cwords = br->consumed_words;
928 if(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
930 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
931 const unsigned n = FLAC__BITS_PER_WORD - cbits;
932 const brword word = br->buffer[cwords];
935 uval |= (word & (FLAC__WORD_ALL_ONES >> cbits)) >> (n-bits);
940 uval |= word & (FLAC__WORD_ALL_ONES >> cbits);
942 crc16_update_word_(br, word);
945 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 */
947 uval |= (br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits));
953 FLAC__ASSERT(bits < FLAC__BITS_PER_WORD);
955 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits);
961 /* in this case we're starting our read at a partial tail word;
962 * the reader has guaranteed that we have at least 'bits' bits
963 * available to read, which makes this case simpler.
967 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
968 FLAC__ASSERT(cbits + bits <= br->bytes*8);
969 uval |= (br->buffer[cwords] & (FLAC__WORD_ALL_ONES >> cbits)) >> (FLAC__BITS_PER_WORD-cbits-bits);
974 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits);
981 /* compose the value */
982 *vals = (int)(uval >> 1 ^ -(int)(uval & 1));
987 br->consumed_bits = cbits;
988 br->consumed_words = cwords;
1002 /* try and get br->consumed_words and br->consumed_bits into register;
1003 * must remember to flush them back to *br before calling other
1004 * bitwriter functions that use them, and before returning */
1005 register unsigned cwords;
1006 register unsigned cbits;
1007 unsigned ucbits; /* keep track of the number of unconsumed bits in the buffer */
1009 FLAC__ASSERT(0 != br);
1010 FLAC__ASSERT(0 != br->buffer);
1011 /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
1012 FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
1013 FLAC__ASSERT(parameter < 32);
1014 /* the above two asserts also guarantee that the binary part never straddles more than 2 words, so we don't have to loop to read it */
1019 cbits = br->consumed_bits;
1020 cwords = br->consumed_words;
1021 ucbits = (br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits;
1025 /* read unary part */
1027 while(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
1028 brword b = br->buffer[cwords] << cbits;
1030 #if 0 /* is not discernably faster... */ && defined FLAC__CPU_IA32 && !defined FLAC__NO_ASM && FLAC__BITS_PER_WORD == 32 && defined __GNUC__
1039 i = COUNT_ZERO_MSBS(b);
1043 cbits++; /* skip over stop bit */
1044 if(cbits >= FLAC__BITS_PER_WORD) { /* faster way of testing if(cbits == FLAC__BITS_PER_WORD) */
1045 crc16_update_word_(br, br->buffer[cwords]);
1052 uval += FLAC__BITS_PER_WORD - cbits;
1053 crc16_update_word_(br, br->buffer[cwords]);
1056 /* didn't find stop bit yet, have to keep going... */
1059 /* at this point we've eaten up all the whole words; have to try
1060 * reading through any tail bytes before calling the read callback.
1061 * this is a repeat of the above logic adjusted for the fact we
1062 * don't have a whole word. note though if the client is feeding
1063 * us data a byte at a time (unlikely), br->consumed_bits may not
1067 const unsigned end = br->bytes * 8;
1068 brword b = (br->buffer[cwords] & ~(FLAC__WORD_ALL_ONES >> end)) << cbits;
1070 i = COUNT_ZERO_MSBS(b);
1073 cbits++; /* skip over stop bit */
1074 FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);
1078 uval += end - cbits;
1080 FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);
1081 /* didn't find stop bit yet, have to keep going... */
1084 /* flush registers and read; bitreader_read_from_client_() does
1085 * not touch br->consumed_bits at all but we still need to set
1086 * it in case it fails and we have to return false.
1088 br->consumed_bits = cbits;
1089 br->consumed_words = cwords;
1090 if(!bitreader_read_from_client_(br))
1092 cwords = br->consumed_words;
1093 ucbits = (br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits + uval;
1094 /* + uval to offset our count by the # of unary bits already
1095 * consumed before the read, because we will add these back
1096 * in all at once at break1
1101 ucbits--; /* account for stop bit */
1103 /* read binary part */
1104 FLAC__ASSERT(cwords <= br->words);
1107 while(ucbits < parameter) {
1108 /* flush registers and read; bitreader_read_from_client_() does
1109 * not touch br->consumed_bits at all but we still need to set
1110 * it in case it fails and we have to return false.
1112 br->consumed_bits = cbits;
1113 br->consumed_words = cwords;
1114 if(!bitreader_read_from_client_(br))
1116 cwords = br->consumed_words;
1117 ucbits = (br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits;
1119 if(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
1121 /* this also works when consumed_bits==0, it's just slower than necessary for that case */
1122 const unsigned n = FLAC__BITS_PER_WORD - cbits;
1123 const brword word = br->buffer[cwords];
1126 uval |= (word & (FLAC__WORD_ALL_ONES >> cbits)) >> (n-parameter);
1131 uval |= word & (FLAC__WORD_ALL_ONES >> cbits);
1132 crc16_update_word_(br, word);
1134 cbits = parameter - n;
1135 if(cbits) { /* parameter > n, i.e. if there are still bits left to read, there have to be less than 32 so they will all be in the next word */
1137 uval |= (br->buffer[cwords] >> (FLAC__BITS_PER_WORD-cbits));
1144 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-cbits);
1148 /* in this case we're starting our read at a partial tail word;
1149 * the reader has guaranteed that we have at least 'parameter'
1150 * bits available to read, which makes this case simpler.
1154 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
1155 FLAC__ASSERT(cbits + parameter <= br->bytes*8);
1156 uval |= (br->buffer[cwords] & (FLAC__WORD_ALL_ONES >> cbits)) >> (FLAC__BITS_PER_WORD-cbits-parameter);
1161 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-cbits);
1166 ucbits -= parameter;
1168 /* compose the value */
1169 *vals = (int)(uval >> 1 ^ -(int)(uval & 1));
1174 br->consumed_bits = cbits;
1175 br->consumed_words = cwords;
1187 FLAC__bool FLAC__bitreader_read_golomb_signed(FLAC__BitReader *br, int *val, unsigned parameter)
1189 FLAC__uint32 lsbs = 0, msbs = 0;
1190 unsigned bit, uval, k;
1192 FLAC__ASSERT(0 != br);
1193 FLAC__ASSERT(0 != br->buffer);
1195 k = FLAC__bitmath_ilog2(parameter);
1197 /* read the unary MSBs and end bit */
1198 if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
1201 /* read the binary LSBs */
1202 if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))
1205 if(parameter == 1u<<k) {
1206 /* compose the value */
1207 uval = (msbs << k) | lsbs;
1210 unsigned d = (1 << (k+1)) - parameter;
1212 if(!FLAC__bitreader_read_bit(br, &bit))
1218 /* compose the value */
1219 uval = msbs * parameter + lsbs;
1222 /* unfold unsigned to signed */
1224 *val = -((int)(uval >> 1)) - 1;
1226 *val = (int)(uval >> 1);
1231 FLAC__bool FLAC__bitreader_read_golomb_unsigned(FLAC__BitReader *br, unsigned *val, unsigned parameter)
1233 FLAC__uint32 lsbs, msbs = 0;
1236 FLAC__ASSERT(0 != br);
1237 FLAC__ASSERT(0 != br->buffer);
1239 k = FLAC__bitmath_ilog2(parameter);
1241 /* read the unary MSBs and end bit */
1242 if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
1245 /* read the binary LSBs */
1246 if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))
1249 if(parameter == 1u<<k) {
1250 /* compose the value */
1251 *val = (msbs << k) | lsbs;
1254 unsigned d = (1 << (k+1)) - parameter;
1256 if(!FLAC__bitreader_read_bit(br, &bit))
1262 /* compose the value */
1263 *val = msbs * parameter + lsbs;
1270 /* on return, if *val == 0xffffffff then the utf-8 sequence was invalid, but the return value will be true */
1271 FLAC__bool FLAC__bitreader_read_utf8_uint32(FLAC__BitReader *br, FLAC__uint32 *val, FLAC__byte *raw, unsigned *rawlen)
1277 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
1280 raw[(*rawlen)++] = (FLAC__byte)x;
1281 if(!(x & 0x80)) { /* 0xxxxxxx */
1285 else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
1289 else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
1293 else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
1297 else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
1301 else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
1310 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
1313 raw[(*rawlen)++] = (FLAC__byte)x;
1314 if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
1325 /* on return, if *val == 0xffffffffffffffff then the utf-8 sequence was invalid, but the return value will be true */
1326 FLAC__bool FLAC__bitreader_read_utf8_uint64(FLAC__BitReader *br, FLAC__uint64 *val, FLAC__byte *raw, unsigned *rawlen)
1332 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
1335 raw[(*rawlen)++] = (FLAC__byte)x;
1336 if(!(x & 0x80)) { /* 0xxxxxxx */
1340 else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
1344 else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
1348 else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
1352 else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
1356 else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
1360 else if(x & 0xFE && !(x & 0x01)) { /* 11111110 */
1365 *val = FLAC__U64L(0xffffffffffffffff);
1369 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
1372 raw[(*rawlen)++] = (FLAC__byte)x;
1373 if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
1374 *val = FLAC__U64L(0xffffffffffffffff);