1 /* libFLAC - Free Lossless Audio Codec library
2 * Copyright (C) 2000-2009 Josh Coalson
3 * Copyright (C) 2011-2018 Xiph.Org Foundation
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * - Neither the name of the Xiph.org Foundation nor the names of its
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include "private/bitmath.h"
40 #include "private/bitreader.h"
41 #include "private/crc.h"
42 #include "private/macros.h"
43 #include "FLAC/assert.h"
44 #include "share/compat.h"
45 #include "share/endswap.h"
47 /* Things should be fastest when this matches the machine word size */
48 /* WATCHOUT: if you change this you must also change the following #defines down to COUNT_ZERO_MSBS2 below to match */
49 /* WATCHOUT: there are a few places where the code will not work unless brword is >= 32 bits wide */
50 /* also, some sections currently only have fast versions for 4 or 8 bytes per word */
52 #if (ENABLE_64_BIT_WORDS == 0)
54 typedef FLAC__uint32 brword
;
55 #define FLAC__BYTES_PER_WORD 4 /* sizeof brword */
56 #define FLAC__BITS_PER_WORD 32
57 #define FLAC__WORD_ALL_ONES ((FLAC__uint32)0xffffffff)
58 /* SWAP_BE_WORD_TO_HOST swaps bytes in a brword (which is always big-endian) if necessary to match host byte order */
60 #define SWAP_BE_WORD_TO_HOST(x) (x)
62 #define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_32(x)
64 /* counts the # of zero MSBs in a word */
65 #define COUNT_ZERO_MSBS(word) FLAC__clz_uint32(word)
66 #define COUNT_ZERO_MSBS2(word) FLAC__clz2_uint32(word)
70 typedef FLAC__uint64 brword
;
71 #define FLAC__BYTES_PER_WORD 8 /* sizeof brword */
72 #define FLAC__BITS_PER_WORD 64
73 #define FLAC__WORD_ALL_ONES ((FLAC__uint64)FLAC__U64L(0xffffffffffffffff))
74 /* SWAP_BE_WORD_TO_HOST swaps bytes in a brword (which is always big-endian) if necessary to match host byte order */
76 #define SWAP_BE_WORD_TO_HOST(x) (x)
78 #define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x)
80 /* counts the # of zero MSBs in a word */
81 #define COUNT_ZERO_MSBS(word) FLAC__clz_uint64(word)
82 #define COUNT_ZERO_MSBS2(word) FLAC__clz2_uint64(word)
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 uint32_t FLAC__BITREADER_DEFAULT_CAPACITY
= 65536u / FLAC__BITS_PER_WORD
; /* in words */
102 struct FLAC__BitReader
{
103 /* any partially-consumed word at the head will stay right-justified as bits are consumed from the left */
104 /* any incomplete word at the tail will be left-justified, and bytes from the read callback are added on the right */
106 uint32_t capacity
; /* in words */
107 uint32_t words
; /* # of completed words in buffer */
108 uint32_t bytes
; /* # of bytes in incomplete word at buffer[words] */
109 uint32_t consumed_words
; /* #words ... */
110 uint32_t consumed_bits
; /* ... + (#bits of head word) already consumed from the front of buffer */
111 uint32_t read_crc16
; /* the running frame CRC */
112 uint32_t crc16_offset
; /* the number of words in the current buffer that should not be CRC'd */
113 uint32_t crc16_align
; /* the number of bits in the current consumed word that should not be CRC'd */
114 FLAC__BitReaderReadCallback read_callback
;
118 static inline void crc16_update_word_(FLAC__BitReader
*br
, brword word
)
120 register uint32_t crc
= br
->read_crc16
;
122 for ( ; br
->crc16_align
< FLAC__BITS_PER_WORD
; br
->crc16_align
+= 8) {
123 uint32_t shift
= FLAC__BITS_PER_WORD
- 8 - br
->crc16_align
;
124 crc
= FLAC__CRC16_UPDATE ((uint32_t) (shift
< FLAC__BITS_PER_WORD
? (word
>> shift
) & 0xff : 0), crc
);
127 br
->read_crc16
= crc
;
131 static inline void crc16_update_block_(FLAC__BitReader
*br
)
133 if(br
->consumed_words
> br
->crc16_offset
&& br
->crc16_align
)
134 crc16_update_word_(br
, br
->buffer
[br
->crc16_offset
++]);
136 /* Prevent OOB read due to wrap-around. */
137 if (br
->consumed_words
> br
->crc16_offset
) {
138 #if FLAC__BYTES_PER_WORD == 4
139 br
->read_crc16
= FLAC__crc16_update_words32(br
->buffer
+ br
->crc16_offset
, br
->consumed_words
- br
->crc16_offset
, br
->read_crc16
);
140 #elif FLAC__BYTES_PER_WORD == 8
141 br
->read_crc16
= FLAC__crc16_update_words64(br
->buffer
+ br
->crc16_offset
, br
->consumed_words
- br
->crc16_offset
, br
->read_crc16
);
145 for (i
= br
->crc16_offset
; i
< br
->consumed_words
; i
++)
146 crc16_update_word_(br
, br
->buffer
[i
]);
150 br
->crc16_offset
= 0;
153 static FLAC__bool
bitreader_read_from_client_(FLAC__BitReader
*br
)
159 /* first shift the unconsumed buffer data toward the front as much as possible */
160 if(br
->consumed_words
> 0) {
161 crc16_update_block_(br
); /* CRC consumed words */
163 start
= br
->consumed_words
;
164 end
= br
->words
+ (br
->bytes
? 1:0);
165 memmove(br
->buffer
, br
->buffer
+start
, FLAC__BYTES_PER_WORD
* (end
- start
));
168 br
->consumed_words
= 0;
172 * set the target for reading, taking into account word alignment and endianness
174 bytes
= (br
->capacity
- br
->words
) * FLAC__BYTES_PER_WORD
- br
->bytes
;
176 return false; /* no space left, buffer is too small; see note for FLAC__BITREADER_DEFAULT_CAPACITY */
177 target
= ((FLAC__byte
*)(br
->buffer
+br
->words
)) + br
->bytes
;
179 /* before reading, if the existing reader looks like this (say brword is 32 bits wide)
180 * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1 (partial tail word is left-justified)
181 * buffer[BE]: 11 22 33 44 55 ?? ?? ?? (shown laid out as bytes sequentially in memory)
182 * buffer[LE]: 44 33 22 11 ?? ?? ?? 55 (?? being don't-care)
183 * ^^-------target, bytes=3
184 * on LE machines, have to byteswap the odd tail word so nothing is
190 br
->buffer
[br
->words
] = SWAP_BE_WORD_TO_HOST(br
->buffer
[br
->words
]);
193 /* now it looks like:
194 * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1
195 * buffer[BE]: 11 22 33 44 55 ?? ?? ??
196 * buffer[LE]: 44 33 22 11 55 ?? ?? ??
197 * ^^-------target, bytes=3
200 /* read in the data; note that the callback may return a smaller number of bytes */
201 if(!br
->read_callback(target
, &bytes
, br
->client_data
))
204 /* after reading bytes 66 77 88 99 AA BB CC DD EE FF from the client:
205 * bitstream : 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF
206 * buffer[BE]: 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??
207 * buffer[LE]: 44 33 22 11 55 66 77 88 99 AA BB CC DD EE FF ??
208 * now have to byteswap on LE machines:
212 end
= (br
->words
*FLAC__BYTES_PER_WORD
+ br
->bytes
+ (uint32_t)bytes
+ (FLAC__BYTES_PER_WORD
-1)) / FLAC__BYTES_PER_WORD
;
213 for(start
= br
->words
; start
< end
; start
++)
214 br
->buffer
[start
] = SWAP_BE_WORD_TO_HOST(br
->buffer
[start
]);
217 /* now it looks like:
218 * bitstream : 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF
219 * buffer[BE]: 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??
220 * buffer[LE]: 44 33 22 11 88 77 66 55 CC BB AA 99 ?? FF EE DD
221 * finally we'll update the reader values:
223 end
= br
->words
*FLAC__BYTES_PER_WORD
+ br
->bytes
+ (uint32_t)bytes
;
224 br
->words
= end
/ FLAC__BYTES_PER_WORD
;
225 br
->bytes
= end
% FLAC__BYTES_PER_WORD
;
230 /***********************************************************************
232 * Class constructor/destructor
234 ***********************************************************************/
236 FLAC__BitReader
*FLAC__bitreader_new(void)
238 FLAC__BitReader
*br
= calloc(1, sizeof(FLAC__BitReader
));
241 memset(br, 0, sizeof(FLAC__BitReader));
244 br->words = br->bytes = 0;
245 br->consumed_words = br->consumed_bits = 0;
246 br->read_callback = 0;
252 void FLAC__bitreader_delete(FLAC__BitReader
*br
)
254 FLAC__ASSERT(0 != br
);
256 FLAC__bitreader_free(br
);
260 /***********************************************************************
262 * Public class methods
264 ***********************************************************************/
266 FLAC__bool
FLAC__bitreader_init(FLAC__BitReader
*br
, FLAC__BitReaderReadCallback rcb
, void *cd
)
268 FLAC__ASSERT(0 != br
);
270 br
->words
= br
->bytes
= 0;
271 br
->consumed_words
= br
->consumed_bits
= 0;
272 br
->capacity
= FLAC__BITREADER_DEFAULT_CAPACITY
;
273 br
->buffer
= malloc(sizeof(brword
) * br
->capacity
);
276 br
->read_callback
= rcb
;
277 br
->client_data
= cd
;
282 void FLAC__bitreader_free(FLAC__BitReader
*br
)
284 FLAC__ASSERT(0 != br
);
290 br
->words
= br
->bytes
= 0;
291 br
->consumed_words
= br
->consumed_bits
= 0;
292 br
->read_callback
= 0;
296 FLAC__bool
FLAC__bitreader_clear(FLAC__BitReader
*br
)
298 br
->words
= br
->bytes
= 0;
299 br
->consumed_words
= br
->consumed_bits
= 0;
303 void FLAC__bitreader_dump(const FLAC__BitReader
*br
, FILE *out
)
307 fprintf(out
, "bitreader is NULL\n");
310 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
);
312 for(i
= 0; i
< br
->words
; i
++) {
313 fprintf(out
, "%08X: ", i
);
314 for(j
= 0; j
< FLAC__BITS_PER_WORD
; j
++)
315 if(i
< br
->consumed_words
|| (i
== br
->consumed_words
&& j
< br
->consumed_bits
))
318 fprintf(out
, "%01d", br
->buffer
[i
] & ((brword
)1 << (FLAC__BITS_PER_WORD
-j
-1)) ? 1:0);
322 fprintf(out
, "%08X: ", i
);
323 for(j
= 0; j
< br
->bytes
*8; j
++)
324 if(i
< br
->consumed_words
|| (i
== br
->consumed_words
&& j
< br
->consumed_bits
))
327 fprintf(out
, "%01d", br
->buffer
[i
] & ((brword
)1 << (br
->bytes
*8-j
-1)) ? 1:0);
333 void FLAC__bitreader_reset_read_crc16(FLAC__BitReader
*br
, FLAC__uint16 seed
)
335 FLAC__ASSERT(0 != br
);
336 FLAC__ASSERT(0 != br
->buffer
);
337 FLAC__ASSERT((br
->consumed_bits
& 7) == 0);
339 br
->read_crc16
= (uint32_t)seed
;
340 br
->crc16_offset
= br
->consumed_words
;
341 br
->crc16_align
= br
->consumed_bits
;
344 FLAC__uint16
FLAC__bitreader_get_read_crc16(FLAC__BitReader
*br
)
346 FLAC__ASSERT(0 != br
);
347 FLAC__ASSERT(0 != br
->buffer
);
349 /* CRC consumed words up to here */
350 crc16_update_block_(br
);
352 FLAC__ASSERT((br
->consumed_bits
& 7) == 0);
353 FLAC__ASSERT(br
->crc16_align
<= br
->consumed_bits
);
355 /* CRC any tail bytes in a partially-consumed word */
356 if(br
->consumed_bits
) {
357 const brword tail
= br
->buffer
[br
->consumed_words
];
358 for( ; br
->crc16_align
< br
->consumed_bits
; br
->crc16_align
+= 8)
359 br
->read_crc16
= FLAC__CRC16_UPDATE((uint32_t)((tail
>> (FLAC__BITS_PER_WORD
-8-br
->crc16_align
)) & 0xff), br
->read_crc16
);
361 return br
->read_crc16
;
364 inline FLAC__bool
FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader
*br
)
366 return ((br
->consumed_bits
& 7) == 0);
369 inline uint32_t FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader
*br
)
371 return 8 - (br
->consumed_bits
& 7);
374 inline uint32_t FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader
*br
)
376 return (br
->words
-br
->consumed_words
)*FLAC__BITS_PER_WORD
+ br
->bytes
*8 - br
->consumed_bits
;
379 FLAC__bool
FLAC__bitreader_read_raw_uint32(FLAC__BitReader
*br
, FLAC__uint32
*val
, uint32_t bits
)
381 FLAC__ASSERT(0 != br
);
382 FLAC__ASSERT(0 != br
->buffer
);
384 FLAC__ASSERT(bits
<= 32);
385 FLAC__ASSERT((br
->capacity
*FLAC__BITS_PER_WORD
) * 2 >= bits
);
386 FLAC__ASSERT(br
->consumed_words
<= br
->words
);
388 /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
389 FLAC__ASSERT(FLAC__BITS_PER_WORD
>= 32);
391 if(bits
== 0) { /* OPT: investigate if this can ever happen, maybe change to assertion */
396 while((br
->words
-br
->consumed_words
)*FLAC__BITS_PER_WORD
+ br
->bytes
*8 - br
->consumed_bits
< bits
) {
397 if(!bitreader_read_from_client_(br
))
400 if(br
->consumed_words
< br
->words
) { /* if we've not consumed up to a partial tail word... */
401 /* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */
402 if(br
->consumed_bits
) {
403 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
404 const uint32_t n
= FLAC__BITS_PER_WORD
- br
->consumed_bits
;
405 const brword word
= br
->buffer
[br
->consumed_words
];
407 *val
= (FLAC__uint32
)((word
& (FLAC__WORD_ALL_ONES
>> br
->consumed_bits
)) >> (n
-bits
)); /* The result has <= 32 non-zero bits */
408 br
->consumed_bits
+= bits
;
411 /* (FLAC__BITS_PER_WORD - br->consumed_bits <= bits) ==> (FLAC__WORD_ALL_ONES >> br->consumed_bits) has no more than 'bits' non-zero bits */
412 *val
= (FLAC__uint32
)(word
& (FLAC__WORD_ALL_ONES
>> br
->consumed_bits
));
414 br
->consumed_words
++;
415 br
->consumed_bits
= 0;
416 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 */
418 *val
|= (FLAC__uint32
)(br
->buffer
[br
->consumed_words
] >> (FLAC__BITS_PER_WORD
-bits
));
419 br
->consumed_bits
= bits
;
423 else { /* br->consumed_bits == 0 */
424 const brword word
= br
->buffer
[br
->consumed_words
];
425 if(bits
< FLAC__BITS_PER_WORD
) {
426 *val
= (FLAC__uint32
)(word
>> (FLAC__BITS_PER_WORD
-bits
));
427 br
->consumed_bits
= bits
;
430 /* at this point bits == FLAC__BITS_PER_WORD == 32; because of previous assertions, it can't be larger */
431 *val
= (FLAC__uint32
)word
;
432 br
->consumed_words
++;
437 /* in this case we're starting our read at a partial tail word;
438 * the reader has guaranteed that we have at least 'bits' bits
439 * available to read, which makes this case simpler.
441 /* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */
442 if(br
->consumed_bits
) {
443 /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
444 FLAC__ASSERT(br
->consumed_bits
+ bits
<= br
->bytes
*8);
445 *val
= (FLAC__uint32
)((br
->buffer
[br
->consumed_words
] & (FLAC__WORD_ALL_ONES
>> br
->consumed_bits
)) >> (FLAC__BITS_PER_WORD
-br
->consumed_bits
-bits
));
446 br
->consumed_bits
+= bits
;
450 *val
= (FLAC__uint32
)(br
->buffer
[br
->consumed_words
] >> (FLAC__BITS_PER_WORD
-bits
));
451 br
->consumed_bits
+= bits
;
457 FLAC__bool
FLAC__bitreader_read_raw_int32(FLAC__BitReader
*br
, FLAC__int32
*val
, uint32_t bits
)
459 FLAC__uint32 uval
, mask
;
460 /* OPT: inline raw uint32 code here, or make into a macro if possible in the .h file */
461 if (bits
< 1 || ! FLAC__bitreader_read_raw_uint32(br
, &uval
, bits
))
463 /* sign-extend *val assuming it is currently bits wide. */
464 /* From: https://graphics.stanford.edu/~seander/bithacks.html#FixedSignExtend */
465 mask
= bits
>= 33 ? 0 : 1u << (bits
- 1);
466 *val
= (uval
^ mask
) - mask
;
470 FLAC__bool
FLAC__bitreader_read_raw_uint64(FLAC__BitReader
*br
, FLAC__uint64
*val
, uint32_t bits
)
475 if(!FLAC__bitreader_read_raw_uint32(br
, &hi
, bits
-32))
477 if(!FLAC__bitreader_read_raw_uint32(br
, &lo
, 32))
484 if(!FLAC__bitreader_read_raw_uint32(br
, &lo
, bits
))
491 inline FLAC__bool
FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader
*br
, FLAC__uint32
*val
)
493 FLAC__uint32 x8
, x32
= 0;
495 /* this doesn't need to be that fast as currently it is only used for vorbis comments */
497 if(!FLAC__bitreader_read_raw_uint32(br
, &x32
, 8))
500 if(!FLAC__bitreader_read_raw_uint32(br
, &x8
, 8))
504 if(!FLAC__bitreader_read_raw_uint32(br
, &x8
, 8))
508 if(!FLAC__bitreader_read_raw_uint32(br
, &x8
, 8))
516 FLAC__bool
FLAC__bitreader_skip_bits_no_crc(FLAC__BitReader
*br
, uint32_t bits
)
519 * OPT: a faster implementation is possible but probably not that useful
520 * since this is only called a couple of times in the metadata readers.
522 FLAC__ASSERT(0 != br
);
523 FLAC__ASSERT(0 != br
->buffer
);
526 const uint32_t n
= br
->consumed_bits
& 7;
531 m
= flac_min(8-n
, bits
);
532 if(!FLAC__bitreader_read_raw_uint32(br
, &x
, m
))
538 if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(br
, m
))
543 if(!FLAC__bitreader_read_raw_uint32(br
, &x
, bits
))
551 FLAC__bool
FLAC__bitreader_skip_byte_block_aligned_no_crc(FLAC__BitReader
*br
, uint32_t nvals
)
555 FLAC__ASSERT(0 != br
);
556 FLAC__ASSERT(0 != br
->buffer
);
557 FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br
));
559 /* step 1: skip over partial head word to get word aligned */
560 while(nvals
&& br
->consumed_bits
) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
561 if(!FLAC__bitreader_read_raw_uint32(br
, &x
, 8))
567 /* step 2: skip whole words in chunks */
568 while(nvals
>= FLAC__BYTES_PER_WORD
) {
569 if(br
->consumed_words
< br
->words
) {
570 br
->consumed_words
++;
571 nvals
-= FLAC__BYTES_PER_WORD
;
573 else if(!bitreader_read_from_client_(br
))
576 /* step 3: skip any remainder from partial tail bytes */
578 if(!FLAC__bitreader_read_raw_uint32(br
, &x
, 8))
586 FLAC__bool
FLAC__bitreader_read_byte_block_aligned_no_crc(FLAC__BitReader
*br
, FLAC__byte
*val
, uint32_t nvals
)
590 FLAC__ASSERT(0 != br
);
591 FLAC__ASSERT(0 != br
->buffer
);
592 FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br
));
594 /* step 1: read from partial head word to get word aligned */
595 while(nvals
&& br
->consumed_bits
) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
596 if(!FLAC__bitreader_read_raw_uint32(br
, &x
, 8))
598 *val
++ = (FLAC__byte
)x
;
603 /* step 2: read whole words in chunks */
604 while(nvals
>= FLAC__BYTES_PER_WORD
) {
605 if(br
->consumed_words
< br
->words
) {
606 const brword word
= br
->buffer
[br
->consumed_words
++];
607 #if FLAC__BYTES_PER_WORD == 4
608 val
[0] = (FLAC__byte
)(word
>> 24);
609 val
[1] = (FLAC__byte
)(word
>> 16);
610 val
[2] = (FLAC__byte
)(word
>> 8);
611 val
[3] = (FLAC__byte
)word
;
612 #elif FLAC__BYTES_PER_WORD == 8
613 val
[0] = (FLAC__byte
)(word
>> 56);
614 val
[1] = (FLAC__byte
)(word
>> 48);
615 val
[2] = (FLAC__byte
)(word
>> 40);
616 val
[3] = (FLAC__byte
)(word
>> 32);
617 val
[4] = (FLAC__byte
)(word
>> 24);
618 val
[5] = (FLAC__byte
)(word
>> 16);
619 val
[6] = (FLAC__byte
)(word
>> 8);
620 val
[7] = (FLAC__byte
)word
;
622 for(x
= 0; x
< FLAC__BYTES_PER_WORD
; x
++)
623 val
[x
] = (FLAC__byte
)(word
>> (8*(FLAC__BYTES_PER_WORD
-x
-1)));
625 val
+= FLAC__BYTES_PER_WORD
;
626 nvals
-= FLAC__BYTES_PER_WORD
;
628 else if(!bitreader_read_from_client_(br
))
631 /* step 3: read any remainder from partial tail bytes */
633 if(!FLAC__bitreader_read_raw_uint32(br
, &x
, 8))
635 *val
++ = (FLAC__byte
)x
;
642 FLAC__bool
FLAC__bitreader_read_unary_unsigned(FLAC__BitReader
*br
, uint32_t *val
)
643 #if 0 /* slow but readable version */
647 FLAC__ASSERT(0 != br
);
648 FLAC__ASSERT(0 != br
->buffer
);
652 if(!FLAC__bitreader_read_bit(br
, &bit
))
665 FLAC__ASSERT(0 != br
);
666 FLAC__ASSERT(0 != br
->buffer
);
670 while(br
->consumed_words
< br
->words
) { /* if we've not consumed up to a partial tail word... */
671 brword b
= br
->buffer
[br
->consumed_words
] << br
->consumed_bits
;
673 i
= COUNT_ZERO_MSBS(b
);
676 br
->consumed_bits
+= i
;
677 if(br
->consumed_bits
>= FLAC__BITS_PER_WORD
) { /* faster way of testing if(br->consumed_bits == FLAC__BITS_PER_WORD) */
678 br
->consumed_words
++;
679 br
->consumed_bits
= 0;
684 *val
+= FLAC__BITS_PER_WORD
- br
->consumed_bits
;
685 br
->consumed_words
++;
686 br
->consumed_bits
= 0;
687 /* didn't find stop bit yet, have to keep going... */
690 /* at this point we've eaten up all the whole words; have to try
691 * reading through any tail bytes before calling the read callback.
692 * this is a repeat of the above logic adjusted for the fact we
693 * don't have a whole word. note though if the client is feeding
694 * us data a byte at a time (unlikely), br->consumed_bits may not
697 if(br
->bytes
*8 > br
->consumed_bits
) {
698 const uint32_t end
= br
->bytes
* 8;
699 brword b
= (br
->buffer
[br
->consumed_words
] & (FLAC__WORD_ALL_ONES
<< (FLAC__BITS_PER_WORD
-end
))) << br
->consumed_bits
;
701 i
= COUNT_ZERO_MSBS(b
);
704 br
->consumed_bits
+= i
;
705 FLAC__ASSERT(br
->consumed_bits
< FLAC__BITS_PER_WORD
);
709 *val
+= end
- br
->consumed_bits
;
710 br
->consumed_bits
= end
;
711 FLAC__ASSERT(br
->consumed_bits
< FLAC__BITS_PER_WORD
);
712 /* didn't find stop bit yet, have to keep going... */
715 if(!bitreader_read_from_client_(br
))
721 FLAC__bool
FLAC__bitreader_read_rice_signed(FLAC__BitReader
*br
, int *val
, uint32_t parameter
)
723 FLAC__uint32 lsbs
= 0, msbs
= 0;
726 FLAC__ASSERT(0 != br
);
727 FLAC__ASSERT(0 != br
->buffer
);
728 FLAC__ASSERT(parameter
<= 31);
730 /* read the unary MSBs and end bit */
731 if(!FLAC__bitreader_read_unary_unsigned(br
, &msbs
))
734 /* read the binary LSBs */
735 if(!FLAC__bitreader_read_raw_uint32(br
, &lsbs
, parameter
))
738 /* compose the value */
739 uval
= (msbs
<< parameter
) | lsbs
;
741 *val
= -((int)(uval
>> 1)) - 1;
743 *val
= (int)(uval
>> 1);
748 /* this is by far the most heavily used reader call. it ain't pretty but it's fast */
749 FLAC__bool
FLAC__bitreader_read_rice_signed_block(FLAC__BitReader
*br
, int vals
[], uint32_t nvals
, uint32_t parameter
)
751 /* try and get br->consumed_words and br->consumed_bits into register;
752 * must remember to flush them back to *br before calling other
753 * bitreader functions that use them, and before returning */
754 uint32_t cwords
, words
, lsbs
, msbs
, x
, y
;
755 uint32_t ucbits
; /* keep track of the number of unconsumed bits in word */
759 FLAC__ASSERT(0 != br
);
760 FLAC__ASSERT(0 != br
->buffer
);
761 /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
762 FLAC__ASSERT(FLAC__BITS_PER_WORD
>= 32);
763 FLAC__ASSERT(parameter
< 32);
764 /* 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 */
771 /* read the unary MSBs and end bit */
772 if(!FLAC__bitreader_read_unary_unsigned(br
, &msbs
))
775 *val
++ = (int)(msbs
>> 1) ^ -(int)(msbs
& 1);
781 FLAC__ASSERT(parameter
> 0);
783 cwords
= br
->consumed_words
;
786 /* if we've not consumed up to a partial tail word... */
787 if(cwords
>= words
) {
792 ucbits
= FLAC__BITS_PER_WORD
- br
->consumed_bits
;
793 b
= br
->buffer
[cwords
] << br
->consumed_bits
; /* keep unconsumed bits aligned to left */
796 /* read the unary MSBs and end bit */
797 x
= y
= COUNT_ZERO_MSBS2(b
);
798 if(x
== FLAC__BITS_PER_WORD
) {
801 /* didn't find stop bit yet, have to keep going... */
804 goto incomplete_msbs
;
805 b
= br
->buffer
[cwords
];
806 y
= COUNT_ZERO_MSBS2(b
);
808 } while(y
== FLAC__BITS_PER_WORD
);
811 b
<<= 1; /* account for stop bit */
812 ucbits
= (ucbits
- x
- 1) % FLAC__BITS_PER_WORD
;
815 /* read the binary LSBs */
816 x
= (FLAC__uint32
)(b
>> (FLAC__BITS_PER_WORD
- parameter
)); /* parameter < 32, so we can cast to 32-bit uint32_t */
817 if(parameter
<= ucbits
) {
821 /* there are still bits left to read, they will all be in the next word */
824 goto incomplete_lsbs
;
825 b
= br
->buffer
[cwords
];
826 ucbits
+= FLAC__BITS_PER_WORD
- parameter
;
827 x
|= (FLAC__uint32
)(b
>> ucbits
);
828 b
<<= FLAC__BITS_PER_WORD
- ucbits
;
832 /* compose the value */
833 x
= (msbs
<< parameter
) | lsbs
;
834 *val
++ = (int)(x
>> 1) ^ -(int)(x
& 1);
838 /* at this point we've eaten up all the whole words */
843 br
->consumed_bits
= 0;
844 br
->consumed_words
= cwords
;
847 /* read the unary MSBs and end bit */
848 if(!FLAC__bitreader_read_unary_unsigned(br
, &msbs
))
855 br
->consumed_bits
= 0;
856 br
->consumed_words
= cwords
;
859 /* read the binary LSBs */
860 if(!FLAC__bitreader_read_raw_uint32(br
, &lsbs
, parameter
- ucbits
))
864 /* compose the value */
865 x
= (msbs
<< parameter
) | lsbs
;
866 *val
++ = (int)(x
>> 1) ^ -(int)(x
& 1);
869 cwords
= br
->consumed_words
;
871 ucbits
= FLAC__BITS_PER_WORD
- br
->consumed_bits
;
872 b
= cwords
< br
->capacity
? br
->buffer
[cwords
] << br
->consumed_bits
: 0;
873 } while(cwords
>= words
&& val
< end
);
876 if(ucbits
== 0 && cwords
< words
) {
877 /* don't leave the head word with no unconsumed bits */
879 ucbits
= FLAC__BITS_PER_WORD
;
882 br
->consumed_bits
= FLAC__BITS_PER_WORD
- ucbits
;
883 br
->consumed_words
= cwords
;
889 FLAC__bool
FLAC__bitreader_read_golomb_signed(FLAC__BitReader
*br
, int *val
, uint32_t parameter
)
891 FLAC__uint32 lsbs
= 0, msbs
= 0;
892 uint32_t bit
, uval
, k
;
894 FLAC__ASSERT(0 != br
);
895 FLAC__ASSERT(0 != br
->buffer
);
897 k
= FLAC__bitmath_ilog2(parameter
);
899 /* read the unary MSBs and end bit */
900 if(!FLAC__bitreader_read_unary_unsigned(br
, &msbs
))
903 /* read the binary LSBs */
904 if(!FLAC__bitreader_read_raw_uint32(br
, &lsbs
, k
))
907 if(parameter
== 1u<<k
) {
908 /* compose the value */
909 uval
= (msbs
<< k
) | lsbs
;
912 uint32_t d
= (1 << (k
+1)) - parameter
;
914 if(!FLAC__bitreader_read_bit(br
, &bit
))
920 /* compose the value */
921 uval
= msbs
* parameter
+ lsbs
;
924 /* unfold uint32_t to signed */
926 *val
= -((int)(uval
>> 1)) - 1;
928 *val
= (int)(uval
>> 1);
933 FLAC__bool
FLAC__bitreader_read_golomb_unsigned(FLAC__BitReader
*br
, uint32_t *val
, uint32_t parameter
)
935 FLAC__uint32 lsbs
, msbs
= 0;
938 FLAC__ASSERT(0 != br
);
939 FLAC__ASSERT(0 != br
->buffer
);
941 k
= FLAC__bitmath_ilog2(parameter
);
943 /* read the unary MSBs and end bit */
944 if(!FLAC__bitreader_read_unary_unsigned(br
, &msbs
))
947 /* read the binary LSBs */
948 if(!FLAC__bitreader_read_raw_uint32(br
, &lsbs
, k
))
951 if(parameter
== 1u<<k
) {
952 /* compose the value */
953 *val
= (msbs
<< k
) | lsbs
;
956 uint32_t d
= (1 << (k
+1)) - parameter
;
958 if(!FLAC__bitreader_read_bit(br
, &bit
))
964 /* compose the value */
965 *val
= msbs
* parameter
+ lsbs
;
972 /* on return, if *val == 0xffffffff then the utf-8 sequence was invalid, but the return value will be true */
973 FLAC__bool
FLAC__bitreader_read_utf8_uint32(FLAC__BitReader
*br
, FLAC__uint32
*val
, FLAC__byte
*raw
, uint32_t *rawlen
)
979 if(!FLAC__bitreader_read_raw_uint32(br
, &x
, 8))
982 raw
[(*rawlen
)++] = (FLAC__byte
)x
;
983 if(!(x
& 0x80)) { /* 0xxxxxxx */
987 else if(x
& 0xC0 && !(x
& 0x20)) { /* 110xxxxx */
991 else if(x
& 0xE0 && !(x
& 0x10)) { /* 1110xxxx */
995 else if(x
& 0xF0 && !(x
& 0x08)) { /* 11110xxx */
999 else if(x
& 0xF8 && !(x
& 0x04)) { /* 111110xx */
1003 else if(x
& 0xFC && !(x
& 0x02)) { /* 1111110x */
1012 if(!FLAC__bitreader_read_raw_uint32(br
, &x
, 8))
1015 raw
[(*rawlen
)++] = (FLAC__byte
)x
;
1016 if(!(x
& 0x80) || (x
& 0x40)) { /* 10xxxxxx */
1027 /* on return, if *val == 0xffffffffffffffff then the utf-8 sequence was invalid, but the return value will be true */
1028 FLAC__bool
FLAC__bitreader_read_utf8_uint64(FLAC__BitReader
*br
, FLAC__uint64
*val
, FLAC__byte
*raw
, uint32_t *rawlen
)
1034 if(!FLAC__bitreader_read_raw_uint32(br
, &x
, 8))
1037 raw
[(*rawlen
)++] = (FLAC__byte
)x
;
1038 if(!(x
& 0x80)) { /* 0xxxxxxx */
1042 else if(x
& 0xC0 && !(x
& 0x20)) { /* 110xxxxx */
1046 else if(x
& 0xE0 && !(x
& 0x10)) { /* 1110xxxx */
1050 else if(x
& 0xF0 && !(x
& 0x08)) { /* 11110xxx */
1054 else if(x
& 0xF8 && !(x
& 0x04)) { /* 111110xx */
1058 else if(x
& 0xFC && !(x
& 0x02)) { /* 1111110x */
1062 else if(x
& 0xFE && !(x
& 0x01)) { /* 11111110 */
1067 *val
= FLAC__U64L(0xffffffffffffffff);
1071 if(!FLAC__bitreader_read_raw_uint32(br
, &x
, 8))
1074 raw
[(*rawlen
)++] = (FLAC__byte
)x
;
1075 if(!(x
& 0x80) || (x
& 0x40)) { /* 10xxxxxx */
1076 *val
= FLAC__U64L(0xffffffffffffffff);
1086 /* These functions are declared inline in this file but are also callable as
1087 * externs from elsewhere.
1088 * According to the C99 spec, section 6.7.4, simply providing a function
1089 * prototype in a header file without 'inline' and making the function inline
1090 * in this file should be sufficient.
1091 * Unfortunately, the Microsoft VS compiler doesn't pick them up externally. To
1092 * fix that we add extern declarations here.
1094 extern FLAC__bool
FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader
*br
);
1095 extern uint32_t FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader
*br
);
1096 extern uint32_t FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader
*br
);
1097 extern FLAC__bool
FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader
*br
, FLAC__uint32
*val
);