1 /* libFLAC - Free Lossless Audio Codec library
2 * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007,2008 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() */
41 # include <winsock2.h> /* for ntohl(), sometimes it is not in winsock.h */
43 #elif defined FLAC__SYS_DARWIN
44 # include <machine/endian.h> /* for ntohl() */
45 #elif defined __MINGW32__
46 # include <winsock.h> /* for ntohl() */
48 # include <netinet/in.h> /* for ntohl() */
50 #include "private/bitmath.h"
51 #include "private/bitreader.h"
52 #include "private/crc.h"
53 #include "FLAC/assert.h"
55 /* Things should be fastest when this matches the machine word size */
56 /* WATCHOUT: if you change this you must also change the following #defines down to COUNT_ZERO_MSBS below to match */
57 /* WATCHOUT: there are a few places where the code will not work unless brword is >= 32 bits wide */
58 /* also, some sections currently only have fast versions for 4 or 8 bytes per word */
59 typedef FLAC__uint32 brword;
60 #define FLAC__BYTES_PER_WORD 4
61 #define FLAC__BITS_PER_WORD 32
62 #define FLAC__WORD_ALL_ONES ((FLAC__uint32)0xffffffff)
63 /* SWAP_BE_WORD_TO_HOST swaps bytes in a brword (which is always big-endian) if necessary to match host byte order */
65 #define SWAP_BE_WORD_TO_HOST(x) (x)
68 #define SWAP_BE_WORD_TO_HOST(x) local_swap32_(x)
70 #define SWAP_BE_WORD_TO_HOST(x) ntohl(x)
73 /* counts the # of zero MSBs in a word */
74 #define COUNT_ZERO_MSBS(word) ( \
76 ( (word) <= 0xff? byte_to_unary_table[word] + 24 : byte_to_unary_table[(word) >> 8] + 16 ) : \
77 ( (word) <= 0xffffff? byte_to_unary_table[word >> 16] + 8 : byte_to_unary_table[(word) >> 24] ) \
79 /* this alternate might be slightly faster on some systems/compilers: */
80 #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])) )
84 * This should be at least twice as large as the largest number of words
85 * required to represent any 'number' (in any encoding) you are going to
86 * read. With FLAC this is on the order of maybe a few hundred bits.
87 * If the buffer is smaller than that, the decoder won't be able to read
88 * in a whole number that is in a variable length encoding (e.g. Rice).
89 * But to be practical it should be at least 1K bytes.
91 * Increase this number to decrease the number of read callbacks, at the
92 * expense of using more memory. Or decrease for the reverse effect,
93 * keeping in mind the limit from the first paragraph. The optimal size
94 * also depends on the CPU cache size and other factors; some twiddling
95 * may be necessary to squeeze out the best performance.
97 static const unsigned FLAC__BITREADER_DEFAULT_CAPACITY = 65536u / FLAC__BITS_PER_WORD; /* in words */
99 static const unsigned char byte_to_unary_table[] = {
100 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
101 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
102 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
103 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
104 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
105 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
106 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
107 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
108 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
110 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
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
121 #define min(x,y) ((x)<(y)?(x):(y))
125 #define max(x,y) ((x)>(y)?(x):(y))
127 /* adjust for compilers that can't understand using LLU suffix for uint64_t literals */
129 #define FLAC__U64L(x) x
131 #define FLAC__U64L(x) x##LLU
138 /* WATCHOUT: assembly routines rely on the order in which these fields are declared */
139 struct FLAC__BitReader {
140 /* any partially-consumed word at the head will stay right-justified as bits are consumed from the left */
141 /* any incomplete word at the tail will be left-justified, and bytes from the read callback are added on the right */
143 unsigned capacity; /* in words */
144 unsigned words; /* # of completed words in buffer */
145 unsigned bytes; /* # of bytes in incomplete word at buffer[words] */
146 unsigned consumed_words; /* #words ... */
147 unsigned consumed_bits; /* ... + (#bits of head word) already consumed from the front of buffer */
148 unsigned read_crc16; /* the running frame CRC */
149 unsigned crc16_align; /* the number of bits in the current consumed word that should not be CRC'd */
150 FLAC__BitReaderReadCallback read_callback;
152 FLAC__CPUInfo cpu_info;
156 /* OPT: an MSVC built-in would be better */
157 /* OPT: use _byteswap_ulong intrinsic? */
158 static _inline FLAC__uint32 local_swap32_(FLAC__uint32 x)
160 x = ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF);
161 return (x>>16) | (x<<16);
165 static void local_swap32_block_(FLAC__uint32 *start, FLAC__uint32 len)
185 static FLaC__INLINE void crc16_update_word_(FLAC__BitReader *br, brword word)
187 register unsigned crc = br->read_crc16;
188 #if FLAC__BYTES_PER_WORD == 4
189 switch(br->crc16_align) {
190 case 0: crc = FLAC__CRC16_UPDATE((unsigned)(word >> 24), crc);
191 case 8: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 16) & 0xff), crc);
192 case 16: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 8) & 0xff), crc);
193 case 24: br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)(word & 0xff), crc);
195 #elif FLAC__BYTES_PER_WORD == 8
196 switch(br->crc16_align) {
197 case 0: crc = FLAC__CRC16_UPDATE((unsigned)(word >> 56), crc);
198 case 8: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 48) & 0xff), crc);
199 case 16: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 40) & 0xff), crc);
200 case 24: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 32) & 0xff), crc);
201 case 32: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 24) & 0xff), crc);
202 case 40: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 16) & 0xff), crc);
203 case 48: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 8) & 0xff), crc);
204 case 56: br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)(word & 0xff), crc);
207 for( ; br->crc16_align < FLAC__BITS_PER_WORD; br->crc16_align += 8)
208 crc = FLAC__CRC16_UPDATE((unsigned)((word >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), crc);
209 br->read_crc16 = crc;
214 /* would be static except it needs to be called by asm routines */
215 FLAC__bool bitreader_read_from_client_(FLAC__BitReader *br)
221 /* first shift the unconsumed buffer data toward the front as much as possible */
222 if(br->consumed_words > 0) {
223 start = br->consumed_words;
224 end = br->words + (br->bytes? 1:0);
225 memmove(br->buffer, br->buffer+start, FLAC__BYTES_PER_WORD * (end - start));
228 br->consumed_words = 0;
232 * set the target for reading, taking into account word alignment and endianness
234 bytes = (br->capacity - br->words) * FLAC__BYTES_PER_WORD - br->bytes;
236 return false; /* no space left, buffer is too small; see note for FLAC__BITREADER_DEFAULT_CAPACITY */
237 target = ((FLAC__byte*)(br->buffer+br->words)) + br->bytes;
239 /* before reading, if the existing reader looks like this (say brword is 32 bits wide)
240 * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1 (partial tail word is left-justified)
241 * buffer[BE]: 11 22 33 44 55 ?? ?? ?? (shown layed out as bytes sequentially in memory)
242 * buffer[LE]: 44 33 22 11 ?? ?? ?? 55 (?? being don't-care)
243 * ^^-------target, bytes=3
244 * on LE machines, have to byteswap the odd tail word so nothing is
250 br->buffer[br->words] = SWAP_BE_WORD_TO_HOST(br->buffer[br->words]);
253 /* now it looks like:
254 * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1
255 * buffer[BE]: 11 22 33 44 55 ?? ?? ??
256 * buffer[LE]: 44 33 22 11 55 ?? ?? ??
257 * ^^-------target, bytes=3
260 /* read in the data; note that the callback may return a smaller number of bytes */
261 if(!br->read_callback(target, &bytes, br->client_data))
264 /* after reading bytes 66 77 88 99 AA BB CC DD EE FF from the client:
265 * bitstream : 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF
266 * buffer[BE]: 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??
267 * buffer[LE]: 44 33 22 11 55 66 77 88 99 AA BB CC DD EE FF ??
268 * now have to byteswap on LE machines:
272 end = (br->words*FLAC__BYTES_PER_WORD + br->bytes + bytes + (FLAC__BYTES_PER_WORD-1)) / FLAC__BYTES_PER_WORD;
273 # if defined(_MSC_VER) && !defined(_WIN64) && (FLAC__BYTES_PER_WORD == 4)
274 if(br->cpu_info.type == FLAC__CPUINFO_TYPE_IA32 && br->cpu_info.data.ia32.bswap) {
276 local_swap32_block_(br->buffer + start, end - start);
280 for(start = br->words; start < end; start++)
281 br->buffer[start] = SWAP_BE_WORD_TO_HOST(br->buffer[start]);
284 /* now it looks like:
285 * bitstream : 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF
286 * buffer[BE]: 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??
287 * buffer[LE]: 44 33 22 11 88 77 66 55 CC BB AA 99 ?? FF EE DD
288 * finally we'll update the reader values:
290 end = br->words*FLAC__BYTES_PER_WORD + br->bytes + bytes;
291 br->words = end / FLAC__BYTES_PER_WORD;
292 br->bytes = end % FLAC__BYTES_PER_WORD;
297 /***********************************************************************
299 * Class constructor/destructor
301 ***********************************************************************/
303 FLAC__BitReader *FLAC__bitreader_new(void)
305 FLAC__BitReader *br = (FLAC__BitReader*)calloc(1, sizeof(FLAC__BitReader));
308 memset(br, 0, sizeof(FLAC__BitReader));
311 br->words = br->bytes = 0;
312 br->consumed_words = br->consumed_bits = 0;
313 br->read_callback = 0;
319 void FLAC__bitreader_delete(FLAC__BitReader *br)
321 FLAC__ASSERT(0 != br);
323 FLAC__bitreader_free(br);
327 /***********************************************************************
329 * Public class methods
331 ***********************************************************************/
333 FLAC__bool FLAC__bitreader_init(FLAC__BitReader *br, FLAC__CPUInfo cpu, FLAC__BitReaderReadCallback rcb, void *cd)
335 FLAC__ASSERT(0 != br);
337 br->words = br->bytes = 0;
338 br->consumed_words = br->consumed_bits = 0;
339 br->capacity = FLAC__BITREADER_DEFAULT_CAPACITY;
340 br->buffer = (brword*)malloc(sizeof(brword) * br->capacity);
343 br->read_callback = rcb;
344 br->client_data = cd;
350 void FLAC__bitreader_free(FLAC__BitReader *br)
352 FLAC__ASSERT(0 != br);
358 br->words = br->bytes = 0;
359 br->consumed_words = br->consumed_bits = 0;
360 br->read_callback = 0;
364 FLAC__bool FLAC__bitreader_clear(FLAC__BitReader *br)
366 br->words = br->bytes = 0;
367 br->consumed_words = br->consumed_bits = 0;
371 void FLAC__bitreader_dump(const FLAC__BitReader *br, FILE *out)
375 fprintf(out, "bitreader is NULL\n");
378 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);
380 for(i = 0; i < br->words; i++) {
381 fprintf(out, "%08X: ", i);
382 for(j = 0; j < FLAC__BITS_PER_WORD; j++)
383 if(i < br->consumed_words || (i == br->consumed_words && j < br->consumed_bits))
386 fprintf(out, "%01u", br->buffer[i] & (1 << (FLAC__BITS_PER_WORD-j-1)) ? 1:0);
390 fprintf(out, "%08X: ", i);
391 for(j = 0; j < br->bytes*8; j++)
392 if(i < br->consumed_words || (i == br->consumed_words && j < br->consumed_bits))
395 fprintf(out, "%01u", br->buffer[i] & (1 << (br->bytes*8-j-1)) ? 1:0);
401 void FLAC__bitreader_reset_read_crc16(FLAC__BitReader *br, FLAC__uint16 seed)
403 FLAC__ASSERT(0 != br);
404 FLAC__ASSERT(0 != br->buffer);
405 FLAC__ASSERT((br->consumed_bits & 7) == 0);
407 br->read_crc16 = (unsigned)seed;
408 br->crc16_align = br->consumed_bits;
411 FLAC__uint16 FLAC__bitreader_get_read_crc16(FLAC__BitReader *br)
413 FLAC__ASSERT(0 != br);
414 FLAC__ASSERT(0 != br->buffer);
415 FLAC__ASSERT((br->consumed_bits & 7) == 0);
416 FLAC__ASSERT(br->crc16_align <= br->consumed_bits);
418 /* CRC any tail bytes in a partially-consumed word */
419 if(br->consumed_bits) {
420 const brword tail = br->buffer[br->consumed_words];
421 for( ; br->crc16_align < br->consumed_bits; br->crc16_align += 8)
422 br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)((tail >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), br->read_crc16);
424 return br->read_crc16;
427 FLaC__INLINE FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br)
429 return ((br->consumed_bits & 7) == 0);
432 FLaC__INLINE unsigned FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br)
434 return 8 - (br->consumed_bits & 7);
437 FLaC__INLINE unsigned FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br)
439 return (br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits;
442 FLaC__INLINE FLAC__bool FLAC__bitreader_read_raw_uint32(FLAC__BitReader *br, FLAC__uint32 *val, unsigned bits)
444 FLAC__ASSERT(0 != br);
445 FLAC__ASSERT(0 != br->buffer);
447 FLAC__ASSERT(bits <= 32);
448 FLAC__ASSERT((br->capacity*FLAC__BITS_PER_WORD) * 2 >= bits);
449 FLAC__ASSERT(br->consumed_words <= br->words);
451 /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
452 FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
454 if(bits == 0) { /* OPT: investigate if this can ever happen, maybe change to assertion */
459 while((br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits < bits) {
460 if(!bitreader_read_from_client_(br))
463 if(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */
464 /* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */
465 if(br->consumed_bits) {
466 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
467 const unsigned n = FLAC__BITS_PER_WORD - br->consumed_bits;
468 const brword word = br->buffer[br->consumed_words];
470 *val = (word & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (n-bits);
471 br->consumed_bits += bits;
474 *val = word & (FLAC__WORD_ALL_ONES >> br->consumed_bits);
476 crc16_update_word_(br, word);
477 br->consumed_words++;
478 br->consumed_bits = 0;
479 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 */
481 *val |= (br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits));
482 br->consumed_bits = bits;
487 const brword word = br->buffer[br->consumed_words];
488 if(bits < FLAC__BITS_PER_WORD) {
489 *val = word >> (FLAC__BITS_PER_WORD-bits);
490 br->consumed_bits = bits;
493 /* at this point 'bits' must be == FLAC__BITS_PER_WORD; because of previous assertions, it can't be larger */
495 crc16_update_word_(br, word);
496 br->consumed_words++;
501 /* in this case we're starting our read at a partial tail word;
502 * the reader has guaranteed that we have at least 'bits' bits
503 * available to read, which makes this case simpler.
505 /* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */
506 if(br->consumed_bits) {
507 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
508 FLAC__ASSERT(br->consumed_bits + bits <= br->bytes*8);
509 *val = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (FLAC__BITS_PER_WORD-br->consumed_bits-bits);
510 br->consumed_bits += bits;
514 *val = br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits);
515 br->consumed_bits += bits;
521 FLAC__bool FLAC__bitreader_read_raw_int32(FLAC__BitReader *br, FLAC__int32 *val, unsigned bits)
523 /* OPT: inline raw uint32 code here, or make into a macro if possible in the .h file */
524 if(!FLAC__bitreader_read_raw_uint32(br, (FLAC__uint32*)val, bits))
532 FLAC__bool FLAC__bitreader_read_raw_uint64(FLAC__BitReader *br, FLAC__uint64 *val, unsigned bits)
537 if(!FLAC__bitreader_read_raw_uint32(br, &hi, bits-32))
539 if(!FLAC__bitreader_read_raw_uint32(br, &lo, 32))
546 if(!FLAC__bitreader_read_raw_uint32(br, &lo, bits))
553 FLaC__INLINE FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val)
555 FLAC__uint32 x8, x32 = 0;
557 /* this doesn't need to be that fast as currently it is only used for vorbis comments */
559 if(!FLAC__bitreader_read_raw_uint32(br, &x32, 8))
562 if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
566 if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
570 if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
578 FLAC__bool FLAC__bitreader_skip_bits_no_crc(FLAC__BitReader *br, unsigned bits)
581 * OPT: a faster implementation is possible but probably not that useful
582 * since this is only called a couple of times in the metadata readers.
584 FLAC__ASSERT(0 != br);
585 FLAC__ASSERT(0 != br->buffer);
588 const unsigned n = br->consumed_bits & 7;
594 if(!FLAC__bitreader_read_raw_uint32(br, &x, m))
600 if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(br, m))
605 if(!FLAC__bitreader_read_raw_uint32(br, &x, bits))
613 FLAC__bool FLAC__bitreader_skip_byte_block_aligned_no_crc(FLAC__BitReader *br, unsigned nvals)
617 FLAC__ASSERT(0 != br);
618 FLAC__ASSERT(0 != br->buffer);
619 FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
621 /* step 1: skip over partial head word to get word aligned */
622 while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
623 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
629 /* step 2: skip whole words in chunks */
630 while(nvals >= FLAC__BYTES_PER_WORD) {
631 if(br->consumed_words < br->words) {
632 br->consumed_words++;
633 nvals -= FLAC__BYTES_PER_WORD;
635 else if(!bitreader_read_from_client_(br))
638 /* step 3: skip any remainder from partial tail bytes */
640 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
648 FLAC__bool FLAC__bitreader_read_byte_block_aligned_no_crc(FLAC__BitReader *br, FLAC__byte *val, unsigned nvals)
652 FLAC__ASSERT(0 != br);
653 FLAC__ASSERT(0 != br->buffer);
654 FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
656 /* step 1: read from partial head word to get word aligned */
657 while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
658 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
660 *val++ = (FLAC__byte)x;
665 /* step 2: read whole words in chunks */
666 while(nvals >= FLAC__BYTES_PER_WORD) {
667 if(br->consumed_words < br->words) {
668 const brword word = br->buffer[br->consumed_words++];
669 #if FLAC__BYTES_PER_WORD == 4
670 val[0] = (FLAC__byte)(word >> 24);
671 val[1] = (FLAC__byte)(word >> 16);
672 val[2] = (FLAC__byte)(word >> 8);
673 val[3] = (FLAC__byte)word;
674 #elif FLAC__BYTES_PER_WORD == 8
675 val[0] = (FLAC__byte)(word >> 56);
676 val[1] = (FLAC__byte)(word >> 48);
677 val[2] = (FLAC__byte)(word >> 40);
678 val[3] = (FLAC__byte)(word >> 32);
679 val[4] = (FLAC__byte)(word >> 24);
680 val[5] = (FLAC__byte)(word >> 16);
681 val[6] = (FLAC__byte)(word >> 8);
682 val[7] = (FLAC__byte)word;
684 for(x = 0; x < FLAC__BYTES_PER_WORD; x++)
685 val[x] = (FLAC__byte)(word >> (8*(FLAC__BYTES_PER_WORD-x-1)));
687 val += FLAC__BYTES_PER_WORD;
688 nvals -= FLAC__BYTES_PER_WORD;
690 else if(!bitreader_read_from_client_(br))
693 /* step 3: read any remainder from partial tail bytes */
695 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
697 *val++ = (FLAC__byte)x;
704 FLaC__INLINE FLAC__bool FLAC__bitreader_read_unary_unsigned(FLAC__BitReader *br, unsigned *val)
705 #if 0 /* slow but readable version */
709 FLAC__ASSERT(0 != br);
710 FLAC__ASSERT(0 != br->buffer);
714 if(!FLAC__bitreader_read_bit(br, &bit))
727 FLAC__ASSERT(0 != br);
728 FLAC__ASSERT(0 != br->buffer);
732 while(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */
733 brword b = br->buffer[br->consumed_words] << br->consumed_bits;
735 i = COUNT_ZERO_MSBS(b);
738 br->consumed_bits += i;
739 if(br->consumed_bits >= FLAC__BITS_PER_WORD) { /* faster way of testing if(br->consumed_bits == FLAC__BITS_PER_WORD) */
740 crc16_update_word_(br, br->buffer[br->consumed_words]);
741 br->consumed_words++;
742 br->consumed_bits = 0;
747 *val += FLAC__BITS_PER_WORD - br->consumed_bits;
748 crc16_update_word_(br, br->buffer[br->consumed_words]);
749 br->consumed_words++;
750 br->consumed_bits = 0;
751 /* didn't find stop bit yet, have to keep going... */
754 /* at this point we've eaten up all the whole words; have to try
755 * reading through any tail bytes before calling the read callback.
756 * this is a repeat of the above logic adjusted for the fact we
757 * don't have a whole word. note though if the client is feeding
758 * us data a byte at a time (unlikely), br->consumed_bits may not
762 const unsigned end = br->bytes * 8;
763 brword b = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << br->consumed_bits;
765 i = COUNT_ZERO_MSBS(b);
768 br->consumed_bits += i;
769 FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);
773 *val += end - br->consumed_bits;
774 br->consumed_bits += end;
775 FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);
776 /* didn't find stop bit yet, have to keep going... */
779 if(!bitreader_read_from_client_(br))
785 FLAC__bool FLAC__bitreader_read_rice_signed(FLAC__BitReader *br, int *val, unsigned parameter)
787 FLAC__uint32 lsbs = 0, msbs = 0;
790 FLAC__ASSERT(0 != br);
791 FLAC__ASSERT(0 != br->buffer);
792 FLAC__ASSERT(parameter <= 31);
794 /* read the unary MSBs and end bit */
795 if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
798 /* read the binary LSBs */
799 if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, parameter))
802 /* compose the value */
803 uval = (msbs << parameter) | lsbs;
805 *val = -((int)(uval >> 1)) - 1;
807 *val = (int)(uval >> 1);
812 /* this is by far the most heavily used reader call. it ain't pretty but it's fast */
813 /* a lot of the logic is copied, then adapted, from FLAC__bitreader_read_unary_unsigned() and FLAC__bitreader_read_raw_uint32() */
814 FLAC__bool FLAC__bitreader_read_rice_signed_block(FLAC__BitReader *br, int vals[], unsigned nvals, unsigned parameter)
815 /* OPT: possibly faster version for use with MSVC */
820 unsigned bits; /* the # of binary LSBs left to read to finish a rice codeword */
822 /* try and get br->consumed_words and br->consumed_bits into register;
823 * must remember to flush them back to *br before calling other
824 * bitwriter functions that use them, and before returning */
825 register unsigned cwords;
826 register unsigned cbits;
828 FLAC__ASSERT(0 != br);
829 FLAC__ASSERT(0 != br->buffer);
830 /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
831 FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
832 FLAC__ASSERT(parameter < 32);
833 /* 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 */
838 cbits = br->consumed_bits;
839 cwords = br->consumed_words;
843 /* read unary part */
845 while(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
846 brword b = br->buffer[cwords] << cbits;
848 #if 0 /* slower, probably due to bad register allocation... */ && defined FLAC__CPU_IA32 && !defined FLAC__NO_ASM && FLAC__BITS_PER_WORD == 32
856 i = COUNT_ZERO_MSBS(b);
862 if(cbits == FLAC__BITS_PER_WORD) {
863 crc16_update_word_(br, br->buffer[cwords]);
870 uval += FLAC__BITS_PER_WORD - cbits;
871 crc16_update_word_(br, br->buffer[cwords]);
874 /* didn't find stop bit yet, have to keep going... */
877 /* at this point we've eaten up all the whole words; have to try
878 * reading through any tail bytes before calling the read callback.
879 * this is a repeat of the above logic adjusted for the fact we
880 * don't have a whole word. note though if the client is feeding
881 * us data a byte at a time (unlikely), br->consumed_bits may not
885 const unsigned end = br->bytes * 8;
886 brword b = (br->buffer[cwords] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << cbits;
888 i = COUNT_ZERO_MSBS(b);
893 FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);
899 FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);
900 /* didn't find stop bit yet, have to keep going... */
903 /* flush registers and read; bitreader_read_from_client_() does
904 * not touch br->consumed_bits at all but we still need to set
905 * it in case it fails and we have to return false.
907 br->consumed_bits = cbits;
908 br->consumed_words = cwords;
909 if(!bitreader_read_from_client_(br))
911 cwords = br->consumed_words;
914 /* read binary part */
915 FLAC__ASSERT(cwords <= br->words);
918 while((br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits < bits) {
919 /* flush registers and read; bitreader_read_from_client_() does
920 * not touch br->consumed_bits at all but we still need to set
921 * it in case it fails and we have to return false.
923 br->consumed_bits = cbits;
924 br->consumed_words = cwords;
925 if(!bitreader_read_from_client_(br))
927 cwords = br->consumed_words;
929 if(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
931 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
932 const unsigned n = FLAC__BITS_PER_WORD - cbits;
933 const brword word = br->buffer[cwords];
936 uval |= (word & (FLAC__WORD_ALL_ONES >> cbits)) >> (n-bits);
941 uval |= word & (FLAC__WORD_ALL_ONES >> cbits);
943 crc16_update_word_(br, word);
946 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 */
948 uval |= (br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits));
954 FLAC__ASSERT(bits < FLAC__BITS_PER_WORD);
956 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits);
962 /* in this case we're starting our read at a partial tail word;
963 * the reader has guaranteed that we have at least 'bits' bits
964 * available to read, which makes this case simpler.
968 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
969 FLAC__ASSERT(cbits + bits <= br->bytes*8);
970 uval |= (br->buffer[cwords] & (FLAC__WORD_ALL_ONES >> cbits)) >> (FLAC__BITS_PER_WORD-cbits-bits);
975 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits);
982 /* compose the value */
983 *vals = (int)(uval >> 1 ^ -(int)(uval & 1));
988 br->consumed_bits = cbits;
989 br->consumed_words = cwords;
1003 /* try and get br->consumed_words and br->consumed_bits into register;
1004 * must remember to flush them back to *br before calling other
1005 * bitwriter functions that use them, and before returning */
1006 register unsigned cwords;
1007 register unsigned cbits;
1008 unsigned ucbits; /* keep track of the number of unconsumed bits in the buffer */
1010 FLAC__ASSERT(0 != br);
1011 FLAC__ASSERT(0 != br->buffer);
1012 /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
1013 FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
1014 FLAC__ASSERT(parameter < 32);
1015 /* 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 */
1020 cbits = br->consumed_bits;
1021 cwords = br->consumed_words;
1022 ucbits = (br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits;
1026 /* read unary part */
1028 while(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
1029 brword b = br->buffer[cwords] << cbits;
1031 #if 0 /* is not discernably faster... */ && defined FLAC__CPU_IA32 && !defined FLAC__NO_ASM && FLAC__BITS_PER_WORD == 32 && defined __GNUC__
1040 i = COUNT_ZERO_MSBS(b);
1044 cbits++; /* skip over stop bit */
1045 if(cbits >= FLAC__BITS_PER_WORD) { /* faster way of testing if(cbits == FLAC__BITS_PER_WORD) */
1046 crc16_update_word_(br, br->buffer[cwords]);
1053 uval += FLAC__BITS_PER_WORD - cbits;
1054 crc16_update_word_(br, br->buffer[cwords]);
1057 /* didn't find stop bit yet, have to keep going... */
1060 /* at this point we've eaten up all the whole words; have to try
1061 * reading through any tail bytes before calling the read callback.
1062 * this is a repeat of the above logic adjusted for the fact we
1063 * don't have a whole word. note though if the client is feeding
1064 * us data a byte at a time (unlikely), br->consumed_bits may not
1068 const unsigned end = br->bytes * 8;
1069 brword b = (br->buffer[cwords] & ~(FLAC__WORD_ALL_ONES >> end)) << cbits;
1071 i = COUNT_ZERO_MSBS(b);
1074 cbits++; /* skip over stop bit */
1075 FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);
1079 uval += end - cbits;
1081 FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);
1082 /* didn't find stop bit yet, have to keep going... */
1085 /* flush registers and read; bitreader_read_from_client_() does
1086 * not touch br->consumed_bits at all but we still need to set
1087 * it in case it fails and we have to return false.
1089 br->consumed_bits = cbits;
1090 br->consumed_words = cwords;
1091 if(!bitreader_read_from_client_(br))
1093 cwords = br->consumed_words;
1094 ucbits = (br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits + uval;
1095 /* + uval to offset our count by the # of unary bits already
1096 * consumed before the read, because we will add these back
1097 * in all at once at break1
1102 ucbits--; /* account for stop bit */
1104 /* read binary part */
1105 FLAC__ASSERT(cwords <= br->words);
1108 while(ucbits < parameter) {
1109 /* flush registers and read; bitreader_read_from_client_() does
1110 * not touch br->consumed_bits at all but we still need to set
1111 * it in case it fails and we have to return false.
1113 br->consumed_bits = cbits;
1114 br->consumed_words = cwords;
1115 if(!bitreader_read_from_client_(br))
1117 cwords = br->consumed_words;
1118 ucbits = (br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits;
1120 if(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
1122 /* this also works when consumed_bits==0, it's just slower than necessary for that case */
1123 const unsigned n = FLAC__BITS_PER_WORD - cbits;
1124 const brword word = br->buffer[cwords];
1127 uval |= (word & (FLAC__WORD_ALL_ONES >> cbits)) >> (n-parameter);
1132 uval |= word & (FLAC__WORD_ALL_ONES >> cbits);
1133 crc16_update_word_(br, word);
1135 cbits = parameter - n;
1136 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 */
1138 uval |= (br->buffer[cwords] >> (FLAC__BITS_PER_WORD-cbits));
1145 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-cbits);
1149 /* in this case we're starting our read at a partial tail word;
1150 * the reader has guaranteed that we have at least 'parameter'
1151 * bits available to read, which makes this case simpler.
1155 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
1156 FLAC__ASSERT(cbits + parameter <= br->bytes*8);
1157 uval |= (br->buffer[cwords] & (FLAC__WORD_ALL_ONES >> cbits)) >> (FLAC__BITS_PER_WORD-cbits-parameter);
1162 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-cbits);
1167 ucbits -= parameter;
1169 /* compose the value */
1170 *vals = (int)(uval >> 1 ^ -(int)(uval & 1));
1175 br->consumed_bits = cbits;
1176 br->consumed_words = cwords;
1188 FLAC__bool FLAC__bitreader_read_golomb_signed(FLAC__BitReader *br, int *val, unsigned parameter)
1190 FLAC__uint32 lsbs = 0, msbs = 0;
1191 unsigned bit, uval, k;
1193 FLAC__ASSERT(0 != br);
1194 FLAC__ASSERT(0 != br->buffer);
1196 k = FLAC__bitmath_ilog2(parameter);
1198 /* read the unary MSBs and end bit */
1199 if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
1202 /* read the binary LSBs */
1203 if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))
1206 if(parameter == 1u<<k) {
1207 /* compose the value */
1208 uval = (msbs << k) | lsbs;
1211 unsigned d = (1 << (k+1)) - parameter;
1213 if(!FLAC__bitreader_read_bit(br, &bit))
1219 /* compose the value */
1220 uval = msbs * parameter + lsbs;
1223 /* unfold unsigned to signed */
1225 *val = -((int)(uval >> 1)) - 1;
1227 *val = (int)(uval >> 1);
1232 FLAC__bool FLAC__bitreader_read_golomb_unsigned(FLAC__BitReader *br, unsigned *val, unsigned parameter)
1234 FLAC__uint32 lsbs, msbs = 0;
1237 FLAC__ASSERT(0 != br);
1238 FLAC__ASSERT(0 != br->buffer);
1240 k = FLAC__bitmath_ilog2(parameter);
1242 /* read the unary MSBs and end bit */
1243 if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
1246 /* read the binary LSBs */
1247 if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))
1250 if(parameter == 1u<<k) {
1251 /* compose the value */
1252 *val = (msbs << k) | lsbs;
1255 unsigned d = (1 << (k+1)) - parameter;
1257 if(!FLAC__bitreader_read_bit(br, &bit))
1263 /* compose the value */
1264 *val = msbs * parameter + lsbs;
1271 /* on return, if *val == 0xffffffff then the utf-8 sequence was invalid, but the return value will be true */
1272 FLAC__bool FLAC__bitreader_read_utf8_uint32(FLAC__BitReader *br, FLAC__uint32 *val, FLAC__byte *raw, unsigned *rawlen)
1278 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
1281 raw[(*rawlen)++] = (FLAC__byte)x;
1282 if(!(x & 0x80)) { /* 0xxxxxxx */
1286 else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
1290 else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
1294 else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
1298 else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
1302 else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
1311 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
1314 raw[(*rawlen)++] = (FLAC__byte)x;
1315 if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
1326 /* on return, if *val == 0xffffffffffffffff then the utf-8 sequence was invalid, but the return value will be true */
1327 FLAC__bool FLAC__bitreader_read_utf8_uint64(FLAC__BitReader *br, FLAC__uint64 *val, FLAC__byte *raw, unsigned *rawlen)
1333 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
1336 raw[(*rawlen)++] = (FLAC__byte)x;
1337 if(!(x & 0x80)) { /* 0xxxxxxx */
1341 else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
1345 else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
1349 else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
1353 else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
1357 else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
1361 else if(x & 0xFE && !(x & 0x01)) { /* 11111110 */
1366 *val = FLAC__U64L(0xffffffffffffffff);
1370 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
1373 raw[(*rawlen)++] = (FLAC__byte)x;
1374 if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
1375 *val = FLAC__U64L(0xffffffffffffffff);