reinstitute old FLAC__bitbuffer_read_rice_signed_block() for MSVC compiles
[flac.git] / src / libFLAC / bitbuffer.c
1 /* libFLAC - Free Lossless Audio Codec library
2  * Copyright (C) 2000,2001,2002,2003,2004,2005  Josh Coalson
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * - Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *
11  * - Redistributions in binary form must reproduce the above copyright
12  * notice, this list of conditions and the following disclaimer in the
13  * documentation and/or other materials provided with the distribution.
14  *
15  * - Neither the name of the Xiph.org Foundation nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include <stdlib.h> /* for malloc() */
33 #include <string.h> /* for memcpy(), memset() */
34 #include "private/bitbuffer.h"
35 #include "private/bitmath.h"
36 #include "private/crc.h"
37 #include "FLAC/assert.h"
38
39 /*
40  * Along the way you will see two versions of some functions, selected
41  * by a FLAC__NO_MANUAL_INLINING macro.  One is the simplified, more
42  * readable, and slow version, and the other is the same function
43  * where crucial parts have been manually inlined and are much faster.
44  *
45  */
46
47 /*
48  * Some optimization strategies are slower with older versions of MSVC
49  */
50 #if defined _MSC_VER && _MSC_VER <= 1200
51 #define FLAC__OLD_MSVC_FLAVOR
52 #endif
53
54 /*
55  * This should be at least twice as large as the largest number of blurbs
56  * required to represent any 'number' (in any encoding) you are going to
57  * read.  With FLAC this is on the order of maybe a few hundred bits.
58  * If the buffer is smaller than that, the decoder won't be able to read
59  * in a whole number that is in a variable length encoding (e.g. Rice).
60  *
61  * The number we are actually using here is based on what would be the
62  * approximate maximum size of a verbatim frame at the default block size,
63  * for CD audio (4096 sample * 4 bytes per sample), plus some wiggle room.
64  * 32kbytes sounds reasonable.  For kicks we subtract out 64 bytes for any
65  * alignment or malloc overhead.
66  *
67  * Increase this number to decrease the number of read callbacks, at the
68  * expense of using more memory.  Or decrease for the reverse effect,
69  * keeping in mind the limit from the first paragraph.
70  */
71 static const unsigned FLAC__BITBUFFER_DEFAULT_CAPACITY = ((65536 - 64) * 8) / FLAC__BITS_PER_BLURB; /* blurbs */
72
73 #ifndef FLAC__OLD_MSVC_FLAVOR
74 static const unsigned char byte_to_unary_table[] = {
75         8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
76         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
77         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
78         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
79         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
80         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
81         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
82         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
83         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
84         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
85         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
86         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
87         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
88         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
89         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
90         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
91 };
92 #endif
93
94 #if FLAC__BITS_PER_BLURB == 8
95 #define FLAC__BITS_PER_BLURB_LOG2 3
96 #define FLAC__BYTES_PER_BLURB 1
97 #define FLAC__BLURB_ALL_ONES ((FLAC__byte)0xff)
98 #define FLAC__BLURB_TOP_BIT_ONE ((FLAC__byte)0x80)
99 #define BLURB_BIT_TO_MASK(b) (((FLAC__blurb)'\x80') >> (b))
100 #define CRC16_UPDATE_BLURB(bb, blurb, crc) FLAC__CRC16_UPDATE((blurb), (crc));
101 #ifndef FLAC__OLD_MSVC_FLAVOR
102 #define FLAC__ALIGNED_BLURB_UNARY(blurb) (byte_to_unary_table[blurb])
103 #endif
104 #elif FLAC__BITS_PER_BLURB == 32
105 #define FLAC__BITS_PER_BLURB_LOG2 5
106 #define FLAC__BYTES_PER_BLURB 4
107 #define FLAC__BLURB_ALL_ONES ((FLAC__uint32)0xffffffff)
108 #define FLAC__BLURB_TOP_BIT_ONE ((FLAC__uint32)0x80000000)
109 #define BLURB_BIT_TO_MASK(b) (((FLAC__blurb)0x80000000) >> (b))
110 #define CRC16_UPDATE_BLURB(bb, blurb, crc) crc16_update_blurb((bb), (blurb));
111 #ifndef FLAC__OLD_MSVC_FLAVOR
112 #define FLAC__ALIGNED_BLURB_UNARY(blurb) ((blurb) <= 0xff ? byte_to_unary_table[blurb] + 24 : ((blurb) <= 0xffff ? byte_to_unary_table[(blurb) >> 8] + 16 : ((blurb) <= 0xffffff ? byte_to_unary_table[(blurb) >> 16] + 8 : byte_to_unary_table[(blurb) >> 24])))
113 #endif
114 #else
115 /* ERROR, only sizes of 8 and 32 are supported */
116 #endif
117
118 #define FLAC__BLURBS_TO_BITS(blurbs) ((blurbs) << FLAC__BITS_PER_BLURB_LOG2)
119
120 #ifdef min
121 #undef min
122 #endif
123 #define min(x,y) ((x)<(y)?(x):(y))
124 #ifdef max
125 #undef max
126 #endif
127 #define max(x,y) ((x)>(y)?(x):(y))
128
129 /* adjust for compilers that can't understand using LLU suffix for uint64_t literals */
130 #ifdef _MSC_VER
131 #define FLAC__U64L(x) x
132 #else
133 #define FLAC__U64L(x) x##LLU
134 #endif
135
136 #ifndef FLaC__INLINE
137 #define FLaC__INLINE
138 #endif
139
140 struct FLAC__BitBuffer {
141         FLAC__blurb *buffer;
142         unsigned capacity; /* in blurbs */
143         unsigned blurbs, bits;
144         unsigned total_bits; /* must always == FLAC__BITS_PER_BLURB*blurbs+bits */
145         unsigned consumed_blurbs, consumed_bits;
146         unsigned total_consumed_bits; /* must always == FLAC__BITS_PER_BLURB*consumed_blurbs+consumed_bits */
147         FLAC__uint16 read_crc16;
148 #if FLAC__BITS_PER_BLURB == 32
149         unsigned crc16_align;
150 #endif
151         FLAC__blurb save_head, save_tail;
152 };
153
154 #if FLAC__BITS_PER_BLURB == 32
155 static void crc16_update_blurb(FLAC__BitBuffer *bb, FLAC__blurb blurb)
156 {
157         if(bb->crc16_align == 0) {
158                 FLAC__CRC16_UPDATE(blurb >> 24, bb->read_crc16);
159                 FLAC__CRC16_UPDATE((blurb >> 16) & 0xff, bb->read_crc16);
160                 FLAC__CRC16_UPDATE((blurb >> 8) & 0xff, bb->read_crc16);
161                 FLAC__CRC16_UPDATE(blurb & 0xff, bb->read_crc16);
162         }
163         else if(bb->crc16_align == 8) {
164                 FLAC__CRC16_UPDATE((blurb >> 16) & 0xff, bb->read_crc16);
165                 FLAC__CRC16_UPDATE((blurb >> 8) & 0xff, bb->read_crc16);
166                 FLAC__CRC16_UPDATE(blurb & 0xff, bb->read_crc16);
167         }
168         else if(bb->crc16_align == 16) {
169                 FLAC__CRC16_UPDATE((blurb >> 8) & 0xff, bb->read_crc16);
170                 FLAC__CRC16_UPDATE(blurb & 0xff, bb->read_crc16);
171         }
172         else if(bb->crc16_align == 24) {
173                 FLAC__CRC16_UPDATE(blurb & 0xff, bb->read_crc16);
174         }
175         bb->crc16_align = 0;
176 }
177 #endif
178
179 /*
180  * WATCHOUT: The current implentation is not friendly to shrinking, i.e. it
181  * does not shift left what is consumed, it just chops off the end, whether
182  * there is unconsumed data there or not.  This is OK because currently we
183  * never shrink the buffer, but if this ever changes, we'll have to do some
184  * fixups here.
185  */
186 static FLAC__bool bitbuffer_resize_(FLAC__BitBuffer *bb, unsigned new_capacity)
187 {
188         FLAC__blurb *new_buffer;
189
190         FLAC__ASSERT(0 != bb);
191         FLAC__ASSERT(0 != bb->buffer);
192
193         if(bb->capacity == new_capacity)
194                 return true;
195
196         new_buffer = (FLAC__blurb*)calloc(new_capacity, sizeof(FLAC__blurb));
197         if(new_buffer == 0)
198                 return false;
199         memcpy(new_buffer, bb->buffer, sizeof(FLAC__blurb)*min(bb->blurbs+(bb->bits?1:0), new_capacity));
200         if(new_capacity < bb->blurbs+(bb->bits?1:0)) {
201                 bb->blurbs = new_capacity;
202                 bb->bits = 0;
203                 bb->total_bits = FLAC__BLURBS_TO_BITS(new_capacity);
204         }
205         if(new_capacity < bb->consumed_blurbs+(bb->consumed_bits?1:0)) {
206                 bb->consumed_blurbs = new_capacity;
207                 bb->consumed_bits = 0;
208                 bb->total_consumed_bits = FLAC__BLURBS_TO_BITS(new_capacity);
209         }
210         free(bb->buffer); /* we've already asserted above that (0 != bb->buffer) */
211         bb->buffer = new_buffer;
212         bb->capacity = new_capacity;
213         return true;
214 }
215
216 static FLAC__bool bitbuffer_grow_(FLAC__BitBuffer *bb, unsigned min_blurbs_to_add)
217 {
218         unsigned new_capacity;
219
220         FLAC__ASSERT(min_blurbs_to_add > 0);
221
222         new_capacity = max(bb->capacity * 2, bb->capacity + min_blurbs_to_add);
223         return bitbuffer_resize_(bb, new_capacity);
224 }
225
226 static FLAC__bool bitbuffer_ensure_size_(FLAC__BitBuffer *bb, unsigned bits_to_add)
227 {
228         FLAC__ASSERT(0 != bb);
229         FLAC__ASSERT(0 != bb->buffer);
230
231         if(FLAC__BLURBS_TO_BITS(bb->capacity) < bb->total_bits + bits_to_add)
232                 return bitbuffer_grow_(bb, (bits_to_add >> FLAC__BITS_PER_BLURB_LOG2) + 2);
233         else
234                 return true;
235 }
236
237 static FLAC__bool bitbuffer_read_from_client_(FLAC__BitBuffer *bb, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
238 {
239         unsigned bytes;
240         FLAC__byte *target;
241
242         /* first shift the unconsumed buffer data toward the front as much as possible */
243         if(bb->total_consumed_bits >= FLAC__BITS_PER_BLURB) {
244 #if FLAC__BITS_PER_BLURB == 8
245                 /*
246                  * memset and memcpy are usually implemented in assembly language
247                  * by the system libc, and they can be much faster
248                  */
249                 const unsigned r_end = bb->blurbs + (bb->bits? 1:0);
250                 const unsigned r = bb->consumed_blurbs, l = r_end - r;
251                 memmove(&bb->buffer[0], &bb->buffer[r], l);
252                 memset(&bb->buffer[l], 0, r);
253 #elif FLAC__BITS_PER_BLURB == 32
254                 /* still needs optimization */
255                 const unsigned r_end = bb->blurbs + (bb->bits? 1:0);
256                 unsigned l = 0, r = bb->consumed_blurbs;
257                 for( ; r < r_end; l++, r++)
258                         bb->buffer[l] = bb->buffer[r];
259                 for( ; l < r_end; l++)
260                         bb->buffer[l] = 0;
261 #else
262                 FLAC__ASSERT(false); /* ERROR, only sizes of 8 and 32 are supported */
263 #endif /* FLAC__BITS_PER_BLURB == 32 or 8 */
264
265                 bb->blurbs -= bb->consumed_blurbs;
266                 bb->total_bits -= FLAC__BLURBS_TO_BITS(bb->consumed_blurbs);
267                 bb->consumed_blurbs = 0;
268                 bb->total_consumed_bits = bb->consumed_bits;
269         }
270
271         /* grow if we need to */
272         if(bb->capacity <= 1) {
273                 if(!bitbuffer_resize_(bb, 16))
274                         return false;
275         }
276
277         /* set the target for reading, taking into account blurb alignment */
278 #if FLAC__BITS_PER_BLURB == 8
279         /* blurb == byte, so no gyrations necessary: */
280         target = bb->buffer + bb->blurbs;
281         bytes = bb->capacity - bb->blurbs;
282 #elif FLAC__BITS_PER_BLURB == 32
283         /* @@@ WATCHOUT: code currently only works for big-endian: */
284         FLAC__ASSERT((bb->bits & 7) == 0);
285         target = (FLAC__byte*)(bb->buffer + bb->blurbs) + (bb->bits >> 3);
286         bytes = ((bb->capacity - bb->blurbs) << 2) - (bb->bits >> 3); /* i.e. (bb->capacity - bb->blurbs) * FLAC__BYTES_PER_BLURB - (bb->bits / 8) */
287 #else
288         FLAC__ASSERT(false); /* ERROR, only sizes of 8 and 32 are supported */
289 #endif
290
291         /* finally, read in some data */
292         if(!read_callback(target, &bytes, client_data))
293                 return false;
294
295         /* now we have to handle partial blurb cases: */
296 #if FLAC__BITS_PER_BLURB == 8
297         /* blurb == byte, so no gyrations necessary: */
298         bb->blurbs += bytes;
299         bb->total_bits += FLAC__BLURBS_TO_BITS(bytes);
300 #elif FLAC__BITS_PER_BLURB == 32
301         /* @@@ WATCHOUT: code currently only works for big-endian: */
302         {
303                 const unsigned aligned_bytes = (bb->bits >> 3) + bytes;
304                 bb->blurbs += (aligned_bytes >> 2); /* i.e. aligned_bytes / FLAC__BYTES_PER_BLURB */
305                 bb->bits = (aligned_bytes & 3u) << 3; /* i.e. (aligned_bytes % FLAC__BYTES_PER_BLURB) * 8 */
306                 bb->total_bits += (bytes << 3);
307         }
308 #else
309         FLAC__ASSERT(false); /* ERROR, only sizes of 8 and 32 are supported */
310 #endif
311         return true;
312 }
313
314 /***********************************************************************
315  *
316  * Class constructor/destructor
317  *
318  ***********************************************************************/
319
320 FLAC__BitBuffer *FLAC__bitbuffer_new()
321 {
322         FLAC__BitBuffer *bb = (FLAC__BitBuffer*)calloc(1, sizeof(FLAC__BitBuffer));
323
324         /* calloc() implies:
325                 memset(bb, 0, sizeof(FLAC__BitBuffer));
326                 bb->buffer = 0;
327                 bb->capacity = 0;
328                 bb->blurbs = bb->bits = bb->total_bits = 0;
329                 bb->consumed_blurbs = bb->consumed_bits = bb->total_consumed_bits = 0;
330         */
331         return bb;
332 }
333
334 void FLAC__bitbuffer_delete(FLAC__BitBuffer *bb)
335 {
336         FLAC__ASSERT(0 != bb);
337
338         FLAC__bitbuffer_free(bb);
339         free(bb);
340 }
341
342 /***********************************************************************
343  *
344  * Public class methods
345  *
346  ***********************************************************************/
347
348 FLAC__bool FLAC__bitbuffer_init(FLAC__BitBuffer *bb)
349 {
350         FLAC__ASSERT(0 != bb);
351
352         bb->buffer = 0;
353         bb->capacity = 0;
354         bb->blurbs = bb->bits = bb->total_bits = 0;
355         bb->consumed_blurbs = bb->consumed_bits = bb->total_consumed_bits = 0;
356
357         return FLAC__bitbuffer_clear(bb);
358 }
359
360 FLAC__bool FLAC__bitbuffer_init_from(FLAC__BitBuffer *bb, const FLAC__byte buffer[], unsigned bytes)
361 {
362         FLAC__ASSERT(0 != bb);
363         FLAC__ASSERT(bytes > 0);
364
365         if(!FLAC__bitbuffer_init(bb))
366                 return false;
367
368         if(!bitbuffer_ensure_size_(bb, bytes << 3))
369                 return false;
370
371         FLAC__ASSERT(0 != buffer);
372         /* @@@ WATCHOUT: code currently only works for 8-bits-per-blurb inclusive-or big-endian: */
373         memcpy((FLAC__byte*)bb->buffer, buffer, sizeof(FLAC__byte)*bytes);
374         bb->blurbs = bytes / FLAC__BYTES_PER_BLURB;
375         bb->bits = (bytes % FLAC__BYTES_PER_BLURB) << 3;
376         bb->total_bits = bytes << 3;
377         return true;
378 }
379
380 FLAC__bool FLAC__bitbuffer_concatenate_aligned(FLAC__BitBuffer *dest, const FLAC__BitBuffer *src)
381 {
382         unsigned bits_to_add = src->total_bits - src->total_consumed_bits;
383
384         FLAC__ASSERT(0 != dest);
385         FLAC__ASSERT(0 != src);
386
387         if(bits_to_add == 0)
388                 return true;
389         if(dest->bits != src->consumed_bits)
390                 return false;
391         if(!bitbuffer_ensure_size_(dest, bits_to_add))
392                 return false;
393         if(dest->bits == 0) {
394                 memcpy(dest->buffer+dest->blurbs, src->buffer+src->consumed_blurbs, sizeof(FLAC__blurb)*(src->blurbs-src->consumed_blurbs + ((src->bits)? 1:0)));
395         }
396         else if(dest->bits + bits_to_add > FLAC__BITS_PER_BLURB) {
397                 dest->buffer[dest->blurbs] <<= (FLAC__BITS_PER_BLURB - dest->bits);
398                 dest->buffer[dest->blurbs] |= (src->buffer[src->consumed_blurbs] & ((1u << (FLAC__BITS_PER_BLURB-dest->bits)) - 1));
399                 memcpy(dest->buffer+dest->blurbs+1, src->buffer+src->consumed_blurbs+1, sizeof(FLAC__blurb)*(src->blurbs-src->consumed_blurbs-1 + ((src->bits)? 1:0)));
400         }
401         else {
402                 dest->buffer[dest->blurbs] <<= bits_to_add;
403                 dest->buffer[dest->blurbs] |= (src->buffer[src->consumed_blurbs] & ((1u << bits_to_add) - 1));
404         }
405         dest->bits = src->bits;
406         dest->total_bits += bits_to_add;
407         dest->blurbs = dest->total_bits / FLAC__BITS_PER_BLURB;
408
409         return true;
410 }
411
412 void FLAC__bitbuffer_free(FLAC__BitBuffer *bb)
413 {
414         FLAC__ASSERT(0 != bb);
415
416         if(0 != bb->buffer)
417                 free(bb->buffer);
418         bb->buffer = 0;
419         bb->capacity = 0;
420         bb->blurbs = bb->bits = bb->total_bits = 0;
421         bb->consumed_blurbs = bb->consumed_bits = bb->total_consumed_bits = 0;
422 }
423
424 FLAC__bool FLAC__bitbuffer_clear(FLAC__BitBuffer *bb)
425 {
426         if(bb->buffer == 0) {
427                 bb->capacity = FLAC__BITBUFFER_DEFAULT_CAPACITY;
428                 bb->buffer = (FLAC__blurb*)calloc(bb->capacity, sizeof(FLAC__blurb));
429                 if(bb->buffer == 0)
430                         return false;
431         }
432         else {
433                 memset(bb->buffer, 0, bb->blurbs + (bb->bits?1:0));
434         }
435         bb->blurbs = bb->bits = bb->total_bits = 0;
436         bb->consumed_blurbs = bb->consumed_bits = bb->total_consumed_bits = 0;
437         return true;
438 }
439
440 FLAC__bool FLAC__bitbuffer_clone(FLAC__BitBuffer *dest, const FLAC__BitBuffer *src)
441 {
442         FLAC__ASSERT(0 != dest);
443         FLAC__ASSERT(0 != dest->buffer);
444         FLAC__ASSERT(0 != src);
445         FLAC__ASSERT(0 != src->buffer);
446
447         if(dest->capacity < src->capacity)
448                 if(!bitbuffer_resize_(dest, src->capacity))
449                         return false;
450         memcpy(dest->buffer, src->buffer, sizeof(FLAC__blurb)*min(src->capacity, src->blurbs+1));
451         dest->blurbs = src->blurbs;
452         dest->bits = src->bits;
453         dest->total_bits = src->total_bits;
454         dest->consumed_blurbs = src->consumed_blurbs;
455         dest->consumed_bits = src->consumed_bits;
456         dest->total_consumed_bits = src->total_consumed_bits;
457         dest->read_crc16 = src->read_crc16;
458         return true;
459 }
460
461 void FLAC__bitbuffer_reset_read_crc16(FLAC__BitBuffer *bb, FLAC__uint16 seed)
462 {
463         FLAC__ASSERT(0 != bb);
464         FLAC__ASSERT(0 != bb->buffer);
465         FLAC__ASSERT((bb->consumed_bits & 7) == 0);
466
467         bb->read_crc16 = seed;
468 #if FLAC__BITS_PER_BLURB == 8
469         /* no need to do anything */
470 #elif FLAC__BITS_PER_BLURB == 32
471         bb->crc16_align = bb->consumed_bits;
472 #else
473         FLAC__ASSERT(false); /* ERROR, only sizes of 8 and 32 are supported */
474 #endif
475 }
476
477 FLAC__uint16 FLAC__bitbuffer_get_read_crc16(FLAC__BitBuffer *bb)
478 {
479         FLAC__ASSERT(0 != bb);
480         FLAC__ASSERT(0 != bb->buffer);
481         FLAC__ASSERT((bb->bits & 7) == 0);
482         FLAC__ASSERT((bb->consumed_bits & 7) == 0);
483
484 #if FLAC__BITS_PER_BLURB == 8
485         /* no need to do anything */
486 #elif FLAC__BITS_PER_BLURB == 32
487         /*@@@ BUG: even though this probably can't happen with FLAC, need to fix the case where we are called here for the very first blurb and crc16_align is > 0 */
488         if(bb->bits == 0 || bb->consumed_blurbs < bb->blurbs) {
489                 if(bb->consumed_bits == 8) {
490                         const FLAC__blurb blurb = bb->buffer[bb->consumed_blurbs];
491                         FLAC__CRC16_UPDATE(blurb >> 24, bb->read_crc16);
492                 }
493                 else if(bb->consumed_bits == 16) {
494                         const FLAC__blurb blurb = bb->buffer[bb->consumed_blurbs];
495                         FLAC__CRC16_UPDATE(blurb >> 24, bb->read_crc16);
496                         FLAC__CRC16_UPDATE((blurb >> 16) & 0xff, bb->read_crc16);
497                 }
498                 else if(bb->consumed_bits == 24) {
499                         const FLAC__blurb blurb = bb->buffer[bb->consumed_blurbs];
500                         FLAC__CRC16_UPDATE(blurb >> 24, bb->read_crc16);
501                         FLAC__CRC16_UPDATE((blurb >> 16) & 0xff, bb->read_crc16);
502                         FLAC__CRC16_UPDATE((blurb >> 8) & 0xff, bb->read_crc16);
503                 }
504         }
505         else {
506                 if(bb->consumed_bits == 8) {
507                         const FLAC__blurb blurb = bb->buffer[bb->consumed_blurbs];
508                         FLAC__CRC16_UPDATE(blurb >> (bb->bits-8), bb->read_crc16);
509                 }
510                 else if(bb->consumed_bits == 16) {
511                         const FLAC__blurb blurb = bb->buffer[bb->consumed_blurbs];
512                         FLAC__CRC16_UPDATE(blurb >> (bb->bits-8), bb->read_crc16);
513                         FLAC__CRC16_UPDATE((blurb >> (bb->bits-16)) & 0xff, bb->read_crc16);
514                 }
515                 else if(bb->consumed_bits == 24) {
516                         const FLAC__blurb blurb = bb->buffer[bb->consumed_blurbs];
517                         FLAC__CRC16_UPDATE(blurb >> (bb->bits-8), bb->read_crc16);
518                         FLAC__CRC16_UPDATE((blurb >> (bb->bits-16)) & 0xff, bb->read_crc16);
519                         FLAC__CRC16_UPDATE((blurb >> (bb->bits-24)) & 0xff, bb->read_crc16);
520                 }
521         }
522         bb->crc16_align = bb->consumed_bits;
523 #else
524         FLAC__ASSERT(false); /* ERROR, only sizes of 8 and 32 are supported */
525 #endif
526         return bb->read_crc16;
527 }
528
529 FLAC__uint16 FLAC__bitbuffer_get_write_crc16(const FLAC__BitBuffer *bb)
530 {
531         FLAC__ASSERT((bb->bits & 7) == 0); /* assert that we're byte-aligned */
532
533 #if FLAC__BITS_PER_BLURB == 8
534         return FLAC__crc16(bb->buffer, bb->blurbs);
535 #elif FLAC__BITS_PER_BLURB == 32
536         /* @@@ WATCHOUT: code currently only works for big-endian: */
537         return FLAC__crc16((FLAC__byte*)(bb->buffer), (bb->blurbs * FLAC__BYTES_PER_BLURB) + (bb->bits >> 3));
538 #else
539         FLAC__ASSERT(false); /* ERROR, only sizes of 8 and 32 are supported */
540 #endif
541 }
542
543 FLAC__byte FLAC__bitbuffer_get_write_crc8(const FLAC__BitBuffer *bb)
544 {
545         FLAC__ASSERT(0 != bb);
546         FLAC__ASSERT((bb->bits & 7) == 0); /* assert that we're byte-aligned */
547         FLAC__ASSERT(bb->buffer[0] == 0xff); /* MAGIC NUMBER for the first byte of the sync code */
548 #if FLAC__BITS_PER_BLURB == 8
549         return FLAC__crc8(bb->buffer, bb->blurbs);
550 #elif FLAC__BITS_PER_BLURB == 32
551         /* @@@ WATCHOUT: code currently only works for big-endian: */
552         return FLAC__crc8((FLAC__byte*)(bb->buffer), (bb->blurbs * FLAC__BYTES_PER_BLURB) + (bb->bits >> 3));
553 #else
554         FLAC__ASSERT(false); /* ERROR, only sizes of 8 and 32 are supported */
555 #endif
556 }
557
558 FLAC__bool FLAC__bitbuffer_is_byte_aligned(const FLAC__BitBuffer *bb)
559 {
560         return ((bb->bits & 7) == 0);
561 }
562
563 FLAC__bool FLAC__bitbuffer_is_consumed_byte_aligned(const FLAC__BitBuffer *bb)
564 {
565         return ((bb->consumed_bits & 7) == 0);
566 }
567
568 unsigned FLAC__bitbuffer_bits_left_for_byte_alignment(const FLAC__BitBuffer *bb)
569 {
570         return 8 - (bb->consumed_bits & 7);
571 }
572
573 unsigned FLAC__bitbuffer_get_input_bytes_unconsumed(const FLAC__BitBuffer *bb)
574 {
575         FLAC__ASSERT((bb->consumed_bits & 7) == 0 && (bb->bits & 7) == 0);
576         return (bb->total_bits - bb->total_consumed_bits) >> 3;
577 }
578
579 void FLAC__bitbuffer_get_buffer(FLAC__BitBuffer *bb, const FLAC__byte **buffer, unsigned *bytes)
580 {
581         FLAC__ASSERT((bb->consumed_bits & 7) == 0 && (bb->bits & 7) == 0);
582 #if FLAC__BITS_PER_BLURB == 8
583         *buffer = bb->buffer + bb->consumed_blurbs;
584         *bytes = bb->blurbs - bb->consumed_blurbs;
585 #elif FLAC__BITS_PER_BLURB == 32
586         /* @@@ WATCHOUT: code currently only works for big-endian: */
587         *buffer = (FLAC__byte*)(bb->buffer + bb->consumed_blurbs) + (bb->consumed_bits >> 3);
588         *bytes = (bb->total_bits - bb->total_consumed_bits) >> 3;
589 #else
590         FLAC__ASSERT(false); /* ERROR, only sizes of 8 and 32 are supported */
591 #endif
592 }
593
594 void FLAC__bitbuffer_release_buffer(FLAC__BitBuffer *bb)
595 {
596 #if FLAC__BITS_PER_BLURB == 8
597         (void)bb;
598 #elif FLAC__BITS_PER_BLURB == 32
599         /* @@@ WATCHOUT: code currently only works for big-endian: */
600         (void)bb;
601 #else
602         FLAC__ASSERT(false); /* ERROR, only sizes of 8 and 32 are supported */
603 #endif
604 }
605
606 FLAC__bool FLAC__bitbuffer_write_zeroes(FLAC__BitBuffer *bb, unsigned bits)
607 {
608         unsigned n;
609
610         FLAC__ASSERT(0 != bb);
611         FLAC__ASSERT(0 != bb->buffer);
612
613         if(bits == 0)
614                 return true;
615         if(!bitbuffer_ensure_size_(bb, bits))
616                 return false;
617         bb->total_bits += bits;
618         while(bits > 0) {
619                 n = min(FLAC__BITS_PER_BLURB - bb->bits, bits);
620                 bb->buffer[bb->blurbs] <<= n;
621                 bits -= n;
622                 bb->bits += n;
623                 if(bb->bits == FLAC__BITS_PER_BLURB) {
624                         bb->blurbs++;
625                         bb->bits = 0;
626                 }
627         }
628         return true;
629 }
630
631 FLaC__INLINE FLAC__bool FLAC__bitbuffer_write_raw_uint32(FLAC__BitBuffer *bb, FLAC__uint32 val, unsigned bits)
632 {
633         unsigned n, k;
634
635         FLAC__ASSERT(0 != bb);
636         FLAC__ASSERT(0 != bb->buffer);
637
638         FLAC__ASSERT(bits <= 32);
639         if(bits == 0)
640                 return true;
641         /* inline the size check so we don't incure a function call unnecessarily */
642         if(FLAC__BLURBS_TO_BITS(bb->capacity) < bb->total_bits + bits) {
643                 if(!bitbuffer_ensure_size_(bb, bits))
644                         return false;
645         }
646
647         /* zero-out unused bits; WATCHOUT: other code relies on this, so this needs to stay */
648         if(bits < 32) /* @@@ gcc seems to require this because the following line causes incorrect results when bits==32; investigate */
649                 val &= (~(0xffffffff << bits)); /* zero-out unused bits */
650
651         bb->total_bits += bits;
652         while(bits > 0) {
653                 n = FLAC__BITS_PER_BLURB - bb->bits;
654                 if(n == FLAC__BITS_PER_BLURB) { /* i.e. bb->bits == 0 */
655                         if(bits < FLAC__BITS_PER_BLURB) {
656                                 bb->buffer[bb->blurbs] = (FLAC__blurb)val;
657                                 bb->bits = bits;
658                                 break;
659                         }
660                         else if(bits == FLAC__BITS_PER_BLURB) {
661                                 bb->buffer[bb->blurbs++] = (FLAC__blurb)val;
662                                 break;
663                         }
664                         else {
665                                 k = bits - FLAC__BITS_PER_BLURB;
666                                 bb->buffer[bb->blurbs++] = (FLAC__blurb)(val >> k);
667                                 /* we know k < 32 so no need to protect against the gcc bug mentioned above */
668                                 val &= (~(0xffffffff << k));
669                                 bits -= FLAC__BITS_PER_BLURB;
670                         }
671                 }
672                 else if(bits <= n) {
673                         bb->buffer[bb->blurbs] <<= bits;
674                         bb->buffer[bb->blurbs] |= val;
675                         if(bits == n) {
676                                 bb->blurbs++;
677                                 bb->bits = 0;
678                         }
679                         else
680                                 bb->bits += bits;
681                         break;
682                 }
683                 else {
684                         k = bits - n;
685                         bb->buffer[bb->blurbs] <<= n;
686                         bb->buffer[bb->blurbs] |= (val >> k);
687                         /* we know n > 0 so k < 32 so no need to protect against the gcc bug mentioned above */
688                         val &= (~(0xffffffff << k));
689                         bits -= n;
690                         bb->blurbs++;
691                         bb->bits = 0;
692                 }
693         }
694
695         return true;
696 }
697
698 FLAC__bool FLAC__bitbuffer_write_raw_int32(FLAC__BitBuffer *bb, FLAC__int32 val, unsigned bits)
699 {
700         return FLAC__bitbuffer_write_raw_uint32(bb, (FLAC__uint32)val, bits);
701 }
702
703 FLAC__bool FLAC__bitbuffer_write_raw_uint64(FLAC__BitBuffer *bb, FLAC__uint64 val, unsigned bits)
704 {
705         static const FLAC__uint64 mask[] = {
706                 0,
707                 FLAC__U64L(0x0000000000000001), FLAC__U64L(0x0000000000000003), FLAC__U64L(0x0000000000000007), FLAC__U64L(0x000000000000000F),
708                 FLAC__U64L(0x000000000000001F), FLAC__U64L(0x000000000000003F), FLAC__U64L(0x000000000000007F), FLAC__U64L(0x00000000000000FF),
709                 FLAC__U64L(0x00000000000001FF), FLAC__U64L(0x00000000000003FF), FLAC__U64L(0x00000000000007FF), FLAC__U64L(0x0000000000000FFF),
710                 FLAC__U64L(0x0000000000001FFF), FLAC__U64L(0x0000000000003FFF), FLAC__U64L(0x0000000000007FFF), FLAC__U64L(0x000000000000FFFF),
711                 FLAC__U64L(0x000000000001FFFF), FLAC__U64L(0x000000000003FFFF), FLAC__U64L(0x000000000007FFFF), FLAC__U64L(0x00000000000FFFFF),
712                 FLAC__U64L(0x00000000001FFFFF), FLAC__U64L(0x00000000003FFFFF), FLAC__U64L(0x00000000007FFFFF), FLAC__U64L(0x0000000000FFFFFF),
713                 FLAC__U64L(0x0000000001FFFFFF), FLAC__U64L(0x0000000003FFFFFF), FLAC__U64L(0x0000000007FFFFFF), FLAC__U64L(0x000000000FFFFFFF),
714                 FLAC__U64L(0x000000001FFFFFFF), FLAC__U64L(0x000000003FFFFFFF), FLAC__U64L(0x000000007FFFFFFF), FLAC__U64L(0x00000000FFFFFFFF),
715                 FLAC__U64L(0x00000001FFFFFFFF), FLAC__U64L(0x00000003FFFFFFFF), FLAC__U64L(0x00000007FFFFFFFF), FLAC__U64L(0x0000000FFFFFFFFF),
716                 FLAC__U64L(0x0000001FFFFFFFFF), FLAC__U64L(0x0000003FFFFFFFFF), FLAC__U64L(0x0000007FFFFFFFFF), FLAC__U64L(0x000000FFFFFFFFFF),
717                 FLAC__U64L(0x000001FFFFFFFFFF), FLAC__U64L(0x000003FFFFFFFFFF), FLAC__U64L(0x000007FFFFFFFFFF), FLAC__U64L(0x00000FFFFFFFFFFF),
718                 FLAC__U64L(0x00001FFFFFFFFFFF), FLAC__U64L(0x00003FFFFFFFFFFF), FLAC__U64L(0x00007FFFFFFFFFFF), FLAC__U64L(0x0000FFFFFFFFFFFF),
719                 FLAC__U64L(0x0001FFFFFFFFFFFF), FLAC__U64L(0x0003FFFFFFFFFFFF), FLAC__U64L(0x0007FFFFFFFFFFFF), FLAC__U64L(0x000FFFFFFFFFFFFF),
720                 FLAC__U64L(0x001FFFFFFFFFFFFF), FLAC__U64L(0x003FFFFFFFFFFFFF), FLAC__U64L(0x007FFFFFFFFFFFFF), FLAC__U64L(0x00FFFFFFFFFFFFFF),
721                 FLAC__U64L(0x01FFFFFFFFFFFFFF), FLAC__U64L(0x03FFFFFFFFFFFFFF), FLAC__U64L(0x07FFFFFFFFFFFFFF), FLAC__U64L(0x0FFFFFFFFFFFFFFF),
722                 FLAC__U64L(0x1FFFFFFFFFFFFFFF), FLAC__U64L(0x3FFFFFFFFFFFFFFF), FLAC__U64L(0x7FFFFFFFFFFFFFFF), FLAC__U64L(0xFFFFFFFFFFFFFFFF)
723         };
724         unsigned n, k;
725
726         FLAC__ASSERT(0 != bb);
727         FLAC__ASSERT(0 != bb->buffer);
728
729         FLAC__ASSERT(bits <= 64);
730         if(bits == 0)
731                 return true;
732         if(!bitbuffer_ensure_size_(bb, bits))
733                 return false;
734         val &= mask[bits];
735         bb->total_bits += bits;
736         while(bits > 0) {
737                 if(bb->bits == 0) {
738                         if(bits < FLAC__BITS_PER_BLURB) {
739                                 bb->buffer[bb->blurbs] = (FLAC__blurb)val;
740                                 bb->bits = bits;
741                                 break;
742                         }
743                         else if(bits == FLAC__BITS_PER_BLURB) {
744                                 bb->buffer[bb->blurbs++] = (FLAC__blurb)val;
745                                 break;
746                         }
747                         else {
748                                 k = bits - FLAC__BITS_PER_BLURB;
749                                 bb->buffer[bb->blurbs++] = (FLAC__blurb)(val >> k);
750                                 /* we know k < 64 so no need to protect against the gcc bug mentioned above */
751                                 val &= (~(FLAC__U64L(0xffffffffffffffff) << k));
752                                 bits -= FLAC__BITS_PER_BLURB;
753                         }
754                 }
755                 else {
756                         n = min(FLAC__BITS_PER_BLURB - bb->bits, bits);
757                         k = bits - n;
758                         bb->buffer[bb->blurbs] <<= n;
759                         bb->buffer[bb->blurbs] |= (val >> k);
760                         /* we know n > 0 so k < 64 so no need to protect against the gcc bug mentioned above */
761                         val &= (~(FLAC__U64L(0xffffffffffffffff) << k));
762                         bits -= n;
763                         bb->bits += n;
764                         if(bb->bits == FLAC__BITS_PER_BLURB) {
765                                 bb->blurbs++;
766                                 bb->bits = 0;
767                         }
768                 }
769         }
770
771         return true;
772 }
773
774 #if 0 /* UNUSED */
775 FLAC__bool FLAC__bitbuffer_write_raw_int64(FLAC__BitBuffer *bb, FLAC__int64 val, unsigned bits)
776 {
777         return FLAC__bitbuffer_write_raw_uint64(bb, (FLAC__uint64)val, bits);
778 }
779 #endif
780
781 FLaC__INLINE FLAC__bool FLAC__bitbuffer_write_raw_uint32_little_endian(FLAC__BitBuffer *bb, FLAC__uint32 val)
782 {
783         /* this doesn't need to be that fast as currently it is only used for vorbis comments */
784
785         /* NOTE: we rely on the fact that FLAC__bitbuffer_write_raw_uint32() masks out the unused bits */
786         if(!FLAC__bitbuffer_write_raw_uint32(bb, val, 8))
787                 return false;
788         if(!FLAC__bitbuffer_write_raw_uint32(bb, val>>8, 8))
789                 return false;
790         if(!FLAC__bitbuffer_write_raw_uint32(bb, val>>16, 8))
791                 return false;
792         if(!FLAC__bitbuffer_write_raw_uint32(bb, val>>24, 8))
793                 return false;
794
795         return true;
796 }
797
798 FLaC__INLINE FLAC__bool FLAC__bitbuffer_write_byte_block(FLAC__BitBuffer *bb, const FLAC__byte vals[], unsigned nvals)
799 {
800         unsigned i;
801
802         /* this could be faster but currently we don't need it to be */
803         for(i = 0; i < nvals; i++) {
804                 if(!FLAC__bitbuffer_write_raw_uint32(bb, (FLAC__uint32)(vals[i]), 8))
805                         return false;
806         }
807
808         return true;
809 }
810
811 FLAC__bool FLAC__bitbuffer_write_unary_unsigned(FLAC__BitBuffer *bb, unsigned val)
812 {
813         if(val < 32)
814                 return FLAC__bitbuffer_write_raw_uint32(bb, 1, ++val);
815         else if(val < 64)
816                 return FLAC__bitbuffer_write_raw_uint64(bb, 1, ++val);
817         else {
818                 if(!FLAC__bitbuffer_write_zeroes(bb, val))
819                         return false;
820                 return FLAC__bitbuffer_write_raw_uint32(bb, 1, 1);
821         }
822 }
823
824 unsigned FLAC__bitbuffer_rice_bits(int val, unsigned parameter)
825 {
826         unsigned msbs, uval;
827
828         /* fold signed to unsigned */
829         if(val < 0)
830                 /* equivalent to
831                  *     (unsigned)(((--val) << 1) - 1);
832                  * but without the overflow problem at MININT
833                  */
834                 uval = (unsigned)(((-(++val)) << 1) + 1);
835         else
836                 uval = (unsigned)(val << 1);
837
838         msbs = uval >> parameter;
839
840         return 1 + parameter + msbs;
841 }
842
843 #if 0 /* UNUSED */
844 unsigned FLAC__bitbuffer_golomb_bits_signed(int val, unsigned parameter)
845 {
846         unsigned bits, msbs, uval;
847         unsigned k;
848
849         FLAC__ASSERT(parameter > 0);
850
851         /* fold signed to unsigned */
852         if(val < 0)
853                 /* equivalent to
854                  *     (unsigned)(((--val) << 1) - 1);
855                  * but without the overflow problem at MININT
856                  */
857                 uval = (unsigned)(((-(++val)) << 1) + 1);
858         else
859                 uval = (unsigned)(val << 1);
860
861         k = FLAC__bitmath_ilog2(parameter);
862         if(parameter == 1u<<k) {
863                 FLAC__ASSERT(k <= 30);
864
865                 msbs = uval >> k;
866                 bits = 1 + k + msbs;
867         }
868         else {
869                 unsigned q, r, d;
870
871                 d = (1 << (k+1)) - parameter;
872                 q = uval / parameter;
873                 r = uval - (q * parameter);
874
875                 bits = 1 + q + k;
876                 if(r >= d)
877                         bits++;
878         }
879         return bits;
880 }
881
882 unsigned FLAC__bitbuffer_golomb_bits_unsigned(unsigned uval, unsigned parameter)
883 {
884         unsigned bits, msbs;
885         unsigned k;
886
887         FLAC__ASSERT(parameter > 0);
888
889         k = FLAC__bitmath_ilog2(parameter);
890         if(parameter == 1u<<k) {
891                 FLAC__ASSERT(k <= 30);
892
893                 msbs = uval >> k;
894                 bits = 1 + k + msbs;
895         }
896         else {
897                 unsigned q, r, d;
898
899                 d = (1 << (k+1)) - parameter;
900                 q = uval / parameter;
901                 r = uval - (q * parameter);
902
903                 bits = 1 + q + k;
904                 if(r >= d)
905                         bits++;
906         }
907         return bits;
908 }
909 #endif /* UNUSED */
910
911 #ifdef FLAC__SYMMETRIC_RICE
912 FLAC__bool FLAC__bitbuffer_write_symmetric_rice_signed(FLAC__BitBuffer *bb, int val, unsigned parameter)
913 {
914         unsigned total_bits, interesting_bits, msbs;
915         FLAC__uint32 pattern;
916
917         FLAC__ASSERT(0 != bb);
918         FLAC__ASSERT(0 != bb->buffer);
919         FLAC__ASSERT(parameter <= 31);
920
921         /* init pattern with the unary end bit and the sign bit */
922         if(val < 0) {
923                 pattern = 3;
924                 val = -val;
925         }
926         else
927                 pattern = 2;
928
929         msbs = val >> parameter;
930         interesting_bits = 2 + parameter;
931         total_bits = interesting_bits + msbs;
932         pattern <<= parameter;
933         pattern |= (val & ((1<<parameter)-1)); /* the binary LSBs */
934
935         if(total_bits <= 32) {
936                 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, total_bits))
937                         return false;
938         }
939         else {
940                 /* write the unary MSBs */
941                 if(!FLAC__bitbuffer_write_zeroes(bb, msbs))
942                         return false;
943                 /* write the unary end bit, the sign bit, and binary LSBs */
944                 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, interesting_bits))
945                         return false;
946         }
947         return true;
948 }
949
950 #if 0 /* UNUSED */
951 FLAC__bool FLAC__bitbuffer_write_symmetric_rice_signed_guarded(FLAC__BitBuffer *bb, int val, unsigned parameter, unsigned max_bits, FLAC__bool *overflow)
952 {
953         unsigned total_bits, interesting_bits, msbs;
954         FLAC__uint32 pattern;
955
956         FLAC__ASSERT(0 != bb);
957         FLAC__ASSERT(0 != bb->buffer);
958         FLAC__ASSERT(parameter <= 31);
959
960         *overflow = false;
961
962         /* init pattern with the unary end bit and the sign bit */
963         if(val < 0) {
964                 pattern = 3;
965                 val = -val;
966         }
967         else
968                 pattern = 2;
969
970         msbs = val >> parameter;
971         interesting_bits = 2 + parameter;
972         total_bits = interesting_bits + msbs;
973         pattern <<= parameter;
974         pattern |= (val & ((1<<parameter)-1)); /* the binary LSBs */
975
976         if(total_bits <= 32) {
977                 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, total_bits))
978                         return false;
979         }
980         else if(total_bits > max_bits) {
981                 *overflow = true;
982                 return true;
983         }
984         else {
985                 /* write the unary MSBs */
986                 if(!FLAC__bitbuffer_write_zeroes(bb, msbs))
987                         return false;
988                 /* write the unary end bit, the sign bit, and binary LSBs */
989                 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, interesting_bits))
990                         return false;
991         }
992         return true;
993 }
994 #endif /* UNUSED */
995
996 FLAC__bool FLAC__bitbuffer_write_symmetric_rice_signed_escape(FLAC__BitBuffer *bb, int val, unsigned parameter)
997 {
998         unsigned total_bits, val_bits;
999         FLAC__uint32 pattern;
1000
1001         FLAC__ASSERT(0 != bb);
1002         FLAC__ASSERT(0 != bb->buffer);
1003         FLAC__ASSERT(parameter <= 31);
1004
1005         val_bits = FLAC__bitmath_silog2(val);
1006         total_bits = 2 + parameter + 5 + val_bits;
1007
1008         if(total_bits <= 32) {
1009                 pattern = 3;
1010                 pattern <<= (parameter + 5);
1011                 pattern |= val_bits;
1012                 pattern <<= val_bits;
1013                 pattern |= (val & ((1 << val_bits) - 1));
1014                 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, total_bits))
1015                         return false;
1016         }
1017         else {
1018                 /* write the '-0' escape code first */
1019                 if(!FLAC__bitbuffer_write_raw_uint32(bb, 3u << parameter, 2+parameter))
1020                         return false;
1021                 /* write the length */
1022                 if(!FLAC__bitbuffer_write_raw_uint32(bb, val_bits, 5))
1023                         return false;
1024                 /* write the value */
1025                 if(!FLAC__bitbuffer_write_raw_int32(bb, val, val_bits))
1026                         return false;
1027         }
1028         return true;
1029 }
1030 #endif /* ifdef FLAC__SYMMETRIC_RICE */
1031
1032 FLAC__bool FLAC__bitbuffer_write_rice_signed(FLAC__BitBuffer *bb, int val, unsigned parameter)
1033 {
1034         unsigned total_bits, interesting_bits, msbs, uval;
1035         FLAC__uint32 pattern;
1036
1037         FLAC__ASSERT(0 != bb);
1038         FLAC__ASSERT(0 != bb->buffer);
1039         FLAC__ASSERT(parameter <= 30);
1040
1041         /* fold signed to unsigned */
1042         if(val < 0)
1043                 /* equivalent to
1044                  *     (unsigned)(((--val) << 1) - 1);
1045                  * but without the overflow problem at MININT
1046                  */
1047                 uval = (unsigned)(((-(++val)) << 1) + 1);
1048         else
1049                 uval = (unsigned)(val << 1);
1050
1051         msbs = uval >> parameter;
1052         interesting_bits = 1 + parameter;
1053         total_bits = interesting_bits + msbs;
1054         pattern = 1 << parameter; /* the unary end bit */
1055         pattern |= (uval & ((1<<parameter)-1)); /* the binary LSBs */
1056
1057         if(total_bits <= 32) {
1058                 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, total_bits))
1059                         return false;
1060         }
1061         else {
1062                 /* write the unary MSBs */
1063                 if(!FLAC__bitbuffer_write_zeroes(bb, msbs))
1064                         return false;
1065                 /* write the unary end bit and binary LSBs */
1066                 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, interesting_bits))
1067                         return false;
1068         }
1069         return true;
1070 }
1071
1072 #if 0 /* UNUSED */
1073 FLAC__bool FLAC__bitbuffer_write_rice_signed_guarded(FLAC__BitBuffer *bb, int val, unsigned parameter, unsigned max_bits, FLAC__bool *overflow)
1074 {
1075         unsigned total_bits, interesting_bits, msbs, uval;
1076         FLAC__uint32 pattern;
1077
1078         FLAC__ASSERT(0 != bb);
1079         FLAC__ASSERT(0 != bb->buffer);
1080         FLAC__ASSERT(parameter <= 30);
1081
1082         *overflow = false;
1083
1084         /* fold signed to unsigned */
1085         if(val < 0)
1086                 /* equivalent to
1087                  *     (unsigned)(((--val) << 1) - 1);
1088                  * but without the overflow problem at MININT
1089                  */
1090                 uval = (unsigned)(((-(++val)) << 1) + 1);
1091         else
1092                 uval = (unsigned)(val << 1);
1093
1094         msbs = uval >> parameter;
1095         interesting_bits = 1 + parameter;
1096         total_bits = interesting_bits + msbs;
1097         pattern = 1 << parameter; /* the unary end bit */
1098         pattern |= (uval & ((1<<parameter)-1)); /* the binary LSBs */
1099
1100         if(total_bits <= 32) {
1101                 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, total_bits))
1102                         return false;
1103         }
1104         else if(total_bits > max_bits) {
1105                 *overflow = true;
1106                 return true;
1107         }
1108         else {
1109                 /* write the unary MSBs */
1110                 if(!FLAC__bitbuffer_write_zeroes(bb, msbs))
1111                         return false;
1112                 /* write the unary end bit and binary LSBs */
1113                 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, interesting_bits))
1114                         return false;
1115         }
1116         return true;
1117 }
1118 #endif /* UNUSED */
1119
1120 #if 0 /* UNUSED */
1121 FLAC__bool FLAC__bitbuffer_write_golomb_signed(FLAC__BitBuffer *bb, int val, unsigned parameter)
1122 {
1123         unsigned total_bits, msbs, uval;
1124         unsigned k;
1125
1126         FLAC__ASSERT(0 != bb);
1127         FLAC__ASSERT(0 != bb->buffer);
1128         FLAC__ASSERT(parameter > 0);
1129
1130         /* fold signed to unsigned */
1131         if(val < 0)
1132                 /* equivalent to
1133                  *     (unsigned)(((--val) << 1) - 1);
1134                  * but without the overflow problem at MININT
1135                  */
1136                 uval = (unsigned)(((-(++val)) << 1) + 1);
1137         else
1138                 uval = (unsigned)(val << 1);
1139
1140         k = FLAC__bitmath_ilog2(parameter);
1141         if(parameter == 1u<<k) {
1142                 unsigned pattern;
1143
1144                 FLAC__ASSERT(k <= 30);
1145
1146                 msbs = uval >> k;
1147                 total_bits = 1 + k + msbs;
1148                 pattern = 1 << k; /* the unary end bit */
1149                 pattern |= (uval & ((1u<<k)-1)); /* the binary LSBs */
1150
1151                 if(total_bits <= 32) {
1152                         if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, total_bits))
1153                                 return false;
1154                 }
1155                 else {
1156                         /* write the unary MSBs */
1157                         if(!FLAC__bitbuffer_write_zeroes(bb, msbs))
1158                                 return false;
1159                         /* write the unary end bit and binary LSBs */
1160                         if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, k+1))
1161                                 return false;
1162                 }
1163         }
1164         else {
1165                 unsigned q, r, d;
1166
1167                 d = (1 << (k+1)) - parameter;
1168                 q = uval / parameter;
1169                 r = uval - (q * parameter);
1170                 /* write the unary MSBs */
1171                 if(!FLAC__bitbuffer_write_zeroes(bb, q))
1172                         return false;
1173                 /* write the unary end bit */
1174                 if(!FLAC__bitbuffer_write_raw_uint32(bb, 1, 1))
1175                         return false;
1176                 /* write the binary LSBs */
1177                 if(r >= d) {
1178                         if(!FLAC__bitbuffer_write_raw_uint32(bb, r+d, k+1))
1179                                 return false;
1180                 }
1181                 else {
1182                         if(!FLAC__bitbuffer_write_raw_uint32(bb, r, k))
1183                                 return false;
1184                 }
1185         }
1186         return true;
1187 }
1188
1189 FLAC__bool FLAC__bitbuffer_write_golomb_unsigned(FLAC__BitBuffer *bb, unsigned uval, unsigned parameter)
1190 {
1191         unsigned total_bits, msbs;
1192         unsigned k;
1193
1194         FLAC__ASSERT(0 != bb);
1195         FLAC__ASSERT(0 != bb->buffer);
1196         FLAC__ASSERT(parameter > 0);
1197
1198         k = FLAC__bitmath_ilog2(parameter);
1199         if(parameter == 1u<<k) {
1200                 unsigned pattern;
1201
1202                 FLAC__ASSERT(k <= 30);
1203
1204                 msbs = uval >> k;
1205                 total_bits = 1 + k + msbs;
1206                 pattern = 1 << k; /* the unary end bit */
1207                 pattern |= (uval & ((1u<<k)-1)); /* the binary LSBs */
1208
1209                 if(total_bits <= 32) {
1210                         if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, total_bits))
1211                                 return false;
1212                 }
1213                 else {
1214                         /* write the unary MSBs */
1215                         if(!FLAC__bitbuffer_write_zeroes(bb, msbs))
1216                                 return false;
1217                         /* write the unary end bit and binary LSBs */
1218                         if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, k+1))
1219                                 return false;
1220                 }
1221         }
1222         else {
1223                 unsigned q, r, d;
1224
1225                 d = (1 << (k+1)) - parameter;
1226                 q = uval / parameter;
1227                 r = uval - (q * parameter);
1228                 /* write the unary MSBs */
1229                 if(!FLAC__bitbuffer_write_zeroes(bb, q))
1230                         return false;
1231                 /* write the unary end bit */
1232                 if(!FLAC__bitbuffer_write_raw_uint32(bb, 1, 1))
1233                         return false;
1234                 /* write the binary LSBs */
1235                 if(r >= d) {
1236                         if(!FLAC__bitbuffer_write_raw_uint32(bb, r+d, k+1))
1237                                 return false;
1238                 }
1239                 else {
1240                         if(!FLAC__bitbuffer_write_raw_uint32(bb, r, k))
1241                                 return false;
1242                 }
1243         }
1244         return true;
1245 }
1246 #endif /* UNUSED */
1247
1248 FLAC__bool FLAC__bitbuffer_write_utf8_uint32(FLAC__BitBuffer *bb, FLAC__uint32 val)
1249 {
1250         FLAC__bool ok = 1;
1251
1252         FLAC__ASSERT(0 != bb);
1253         FLAC__ASSERT(0 != bb->buffer);
1254
1255         FLAC__ASSERT(!(val & 0x80000000)); /* this version only handles 31 bits */
1256
1257         if(val < 0x80) {
1258                 return FLAC__bitbuffer_write_raw_uint32(bb, val, 8);
1259         }
1260         else if(val < 0x800) {
1261                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xC0 | (val>>6), 8);
1262                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (val&0x3F), 8);
1263         }
1264         else if(val < 0x10000) {
1265                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xE0 | (val>>12), 8);
1266                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>6)&0x3F), 8);
1267                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (val&0x3F), 8);
1268         }
1269         else if(val < 0x200000) {
1270                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xF0 | (val>>18), 8);
1271                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>12)&0x3F), 8);
1272                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>6)&0x3F), 8);
1273                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (val&0x3F), 8);
1274         }
1275         else if(val < 0x4000000) {
1276                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xF8 | (val>>24), 8);
1277                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>18)&0x3F), 8);
1278                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>12)&0x3F), 8);
1279                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>6)&0x3F), 8);
1280                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (val&0x3F), 8);
1281         }
1282         else {
1283                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xFC | (val>>30), 8);
1284                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>24)&0x3F), 8);
1285                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>18)&0x3F), 8);
1286                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>12)&0x3F), 8);
1287                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>6)&0x3F), 8);
1288                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (val&0x3F), 8);
1289         }
1290
1291         return ok;
1292 }
1293
1294 FLAC__bool FLAC__bitbuffer_write_utf8_uint64(FLAC__BitBuffer *bb, FLAC__uint64 val)
1295 {
1296         FLAC__bool ok = 1;
1297
1298         FLAC__ASSERT(0 != bb);
1299         FLAC__ASSERT(0 != bb->buffer);
1300
1301         FLAC__ASSERT(!(val & FLAC__U64L(0xFFFFFFF000000000))); /* this version only handles 36 bits */
1302
1303         if(val < 0x80) {
1304                 return FLAC__bitbuffer_write_raw_uint32(bb, (FLAC__uint32)val, 8);
1305         }
1306         else if(val < 0x800) {
1307                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xC0 | (FLAC__uint32)(val>>6), 8);
1308                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)(val&0x3F), 8);
1309         }
1310         else if(val < 0x10000) {
1311                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xE0 | (FLAC__uint32)(val>>12), 8);
1312                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
1313                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)(val&0x3F), 8);
1314         }
1315         else if(val < 0x200000) {
1316                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xF0 | (FLAC__uint32)(val>>18), 8);
1317                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
1318                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
1319                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)(val&0x3F), 8);
1320         }
1321         else if(val < 0x4000000) {
1322                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xF8 | (FLAC__uint32)(val>>24), 8);
1323                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
1324                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
1325                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
1326                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)(val&0x3F), 8);
1327         }
1328         else if(val < 0x80000000) {
1329                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xFC | (FLAC__uint32)(val>>30), 8);
1330                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>24)&0x3F), 8);
1331                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
1332                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
1333                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
1334                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)(val&0x3F), 8);
1335         }
1336         else {
1337                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xFE, 8);
1338                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>30)&0x3F), 8);
1339                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>24)&0x3F), 8);
1340                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
1341                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
1342                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
1343                 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (FLAC__uint32)(val&0x3F), 8);
1344         }
1345
1346         return ok;
1347 }
1348
1349 FLAC__bool FLAC__bitbuffer_zero_pad_to_byte_boundary(FLAC__BitBuffer *bb)
1350 {
1351         /* 0-pad to byte boundary */
1352         if(bb->bits & 7u)
1353                 return FLAC__bitbuffer_write_zeroes(bb, 8 - (bb->bits & 7u));
1354         else
1355                 return true;
1356 }
1357
1358 FLAC__bool FLAC__bitbuffer_peek_bit(FLAC__BitBuffer *bb, unsigned *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1359 {
1360         /* to avoid a drastic speed penalty we don't:
1361         FLAC__ASSERT(0 != bb);
1362         FLAC__ASSERT(0 != bb->buffer);
1363         FLAC__ASSERT(bb->bits == 0);
1364         */
1365
1366         while(1) {
1367                 if(bb->total_consumed_bits < bb->total_bits) {
1368                         *val = (bb->buffer[bb->consumed_blurbs] & BLURB_BIT_TO_MASK(bb->consumed_bits))? 1 : 0;
1369                         return true;
1370                 }
1371                 else {
1372                         if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
1373                                 return false;
1374                 }
1375         }
1376 }
1377
1378 FLAC__bool FLAC__bitbuffer_read_bit(FLAC__BitBuffer *bb, unsigned *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1379 {
1380         /* to avoid a drastic speed penalty we don't:
1381         FLAC__ASSERT(0 != bb);
1382         FLAC__ASSERT(0 != bb->buffer);
1383         FLAC__ASSERT(bb->bits == 0);
1384         */
1385
1386         while(1) {
1387                 if(bb->total_consumed_bits < bb->total_bits) {
1388                         *val = (bb->buffer[bb->consumed_blurbs] & BLURB_BIT_TO_MASK(bb->consumed_bits))? 1 : 0;
1389                         bb->consumed_bits++;
1390                         if(bb->consumed_bits == FLAC__BITS_PER_BLURB) {
1391                                 CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
1392                                 bb->consumed_blurbs++;
1393                                 bb->consumed_bits = 0;
1394                         }
1395                         bb->total_consumed_bits++;
1396                         return true;
1397                 }
1398                 else {
1399                         if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
1400                                 return false;
1401                 }
1402         }
1403 }
1404
1405 FLAC__bool FLAC__bitbuffer_read_bit_to_uint32(FLAC__BitBuffer *bb, FLAC__uint32 *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1406 {
1407         /* to avoid a drastic speed penalty we don't:
1408         FLAC__ASSERT(0 != bb);
1409         FLAC__ASSERT(0 != bb->buffer);
1410         FLAC__ASSERT(bb->bits == 0);
1411         */
1412
1413         while(1) {
1414                 if(bb->total_consumed_bits < bb->total_bits) {
1415                         *val <<= 1;
1416                         *val |= (bb->buffer[bb->consumed_blurbs] & BLURB_BIT_TO_MASK(bb->consumed_bits))? 1 : 0;
1417                         bb->consumed_bits++;
1418                         if(bb->consumed_bits == FLAC__BITS_PER_BLURB) {
1419                                 CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
1420                                 bb->consumed_blurbs++;
1421                                 bb->consumed_bits = 0;
1422                         }
1423                         bb->total_consumed_bits++;
1424                         return true;
1425                 }
1426                 else {
1427                         if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
1428                                 return false;
1429                 }
1430         }
1431 }
1432
1433 FLAC__bool FLAC__bitbuffer_read_bit_to_uint64(FLAC__BitBuffer *bb, FLAC__uint64 *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1434 {
1435         /* to avoid a drastic speed penalty we don't:
1436         FLAC__ASSERT(0 != bb);
1437         FLAC__ASSERT(0 != bb->buffer);
1438         FLAC__ASSERT(bb->bits == 0);
1439         */
1440
1441         while(1) {
1442                 if(bb->total_consumed_bits < bb->total_bits) {
1443                         *val <<= 1;
1444                         *val |= (bb->buffer[bb->consumed_blurbs] & BLURB_BIT_TO_MASK(bb->consumed_bits))? 1 : 0;
1445                         bb->consumed_bits++;
1446                         if(bb->consumed_bits == FLAC__BITS_PER_BLURB) {
1447                                 CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
1448                                 bb->consumed_blurbs++;
1449                                 bb->consumed_bits = 0;
1450                         }
1451                         bb->total_consumed_bits++;
1452                         return true;
1453                 }
1454                 else {
1455                         if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
1456                                 return false;
1457                 }
1458         }
1459 }
1460
1461 FLaC__INLINE FLAC__bool FLAC__bitbuffer_read_raw_uint32(FLAC__BitBuffer *bb, FLAC__uint32 *val, const unsigned bits, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1462 #ifdef FLAC__NO_MANUAL_INLINING
1463 {
1464         unsigned i;
1465
1466         FLAC__ASSERT(0 != bb);
1467         FLAC__ASSERT(0 != bb->buffer);
1468
1469         FLAC__ASSERT(bits <= 32);
1470
1471         *val = 0;
1472         for(i = 0; i < bits; i++) {
1473                 if(!FLAC__bitbuffer_read_bit_to_uint32(bb, val, read_callback, client_data))
1474                         return false;
1475         }
1476         return true;
1477 }
1478 #else
1479 {
1480         unsigned i, bits_ = bits;
1481         FLAC__uint32 v = 0;
1482
1483         FLAC__ASSERT(0 != bb);
1484         FLAC__ASSERT(0 != bb->buffer);
1485
1486         FLAC__ASSERT(bits <= 32);
1487         FLAC__ASSERT((bb->capacity*FLAC__BITS_PER_BLURB) * 2 >= bits);
1488
1489         if(bits == 0) {
1490                 *val = 0;
1491                 return true;
1492         }
1493
1494         while(bb->total_consumed_bits + bits > bb->total_bits) {
1495                 if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
1496                         return false;
1497         }
1498 #if FLAC__BITS_PER_BLURB > 8
1499         if(bb->bits == 0 || bb->consumed_blurbs < bb->blurbs) { /*@@@ comment on why this is here*/
1500 #endif
1501                 if(bb->consumed_bits) {
1502                         i = FLAC__BITS_PER_BLURB - bb->consumed_bits;
1503                         if(i <= bits_) {
1504                                 v = bb->buffer[bb->consumed_blurbs] & (FLAC__BLURB_ALL_ONES >> bb->consumed_bits);
1505                                 bits_ -= i;
1506                                 CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
1507                                 bb->consumed_blurbs++;
1508                                 bb->consumed_bits = 0;
1509                                 /* we hold off updating bb->total_consumed_bits until the end */
1510                         }
1511                         else {
1512                                 *val = (bb->buffer[bb->consumed_blurbs] & (FLAC__BLURB_ALL_ONES >> bb->consumed_bits)) >> (i-bits_);
1513                                 bb->consumed_bits += bits_;
1514                                 bb->total_consumed_bits += bits_;
1515                                 return true;
1516                         }
1517                 }
1518 #if FLAC__BITS_PER_BLURB == 32
1519                 /* note that we know bits_ cannot be > 32 because of previous assertions */
1520                 if(bits_ == FLAC__BITS_PER_BLURB) {
1521                         v = bb->buffer[bb->consumed_blurbs];
1522                         CRC16_UPDATE_BLURB(bb, v, bb->read_crc16);
1523                         bb->consumed_blurbs++;
1524                         /* bb->consumed_bits is already 0 */
1525                         bb->total_consumed_bits += bits;
1526                         *val = v;
1527                         return true;
1528                 }
1529 #else
1530                 while(bits_ >= FLAC__BITS_PER_BLURB) {
1531                         v <<= FLAC__BITS_PER_BLURB;
1532                         v |= bb->buffer[bb->consumed_blurbs];
1533                         bits_ -= FLAC__BITS_PER_BLURB;
1534                         CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
1535                         bb->consumed_blurbs++;
1536                         /* bb->consumed_bits is already 0 */
1537                         /* we hold off updating bb->total_consumed_bits until the end */
1538                 }
1539 #endif
1540                 if(bits_ > 0) {
1541                         v <<= bits_;
1542                         v |= (bb->buffer[bb->consumed_blurbs] >> (FLAC__BITS_PER_BLURB-bits_));
1543                         bb->consumed_bits = bits_;
1544                         /* we hold off updating bb->total_consumed_bits until the end */
1545                 }
1546                 bb->total_consumed_bits += bits;
1547                 *val = v;
1548 #if FLAC__BITS_PER_BLURB > 8
1549         }
1550         else {
1551                 *val = 0;
1552                 for(i = 0; i < bits; i++) {
1553                         if(!FLAC__bitbuffer_read_bit_to_uint32(bb, val, read_callback, client_data))
1554                                 return false;
1555                 }
1556         }
1557 #endif
1558         return true;
1559 }
1560 #endif
1561
1562 FLAC__bool FLAC__bitbuffer_read_raw_int32(FLAC__BitBuffer *bb, FLAC__int32 *val, const unsigned bits, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1563 #ifdef FLAC__NO_MANUAL_INLINING
1564 {
1565         unsigned i;
1566         FLAC__uint32 v;
1567
1568         FLAC__ASSERT(0 != bb);
1569         FLAC__ASSERT(0 != bb->buffer);
1570
1571         FLAC__ASSERT(bits <= 32);
1572
1573         if(bits == 0) {
1574                 *val = 0;
1575                 return true;
1576         }
1577
1578         v = 0;
1579         for(i = 0; i < bits; i++) {
1580                 if(!FLAC__bitbuffer_read_bit_to_uint32(bb, &v, read_callback, client_data))
1581                         return false;
1582         }
1583
1584         /* fix the sign */
1585         i = 32 - bits;
1586         if(i) {
1587                 v <<= i;
1588                 *val = (FLAC__int32)v;
1589                 *val >>= i;
1590         }
1591         else
1592                 *val = (FLAC__int32)v;
1593
1594         return true;
1595 }
1596 #else
1597 {
1598         unsigned i, bits_ = bits;
1599         FLAC__uint32 v = 0;
1600
1601         FLAC__ASSERT(0 != bb);
1602         FLAC__ASSERT(0 != bb->buffer);
1603
1604         FLAC__ASSERT(bits <= 32);
1605         FLAC__ASSERT((bb->capacity*FLAC__BITS_PER_BLURB) * 2 >= bits);
1606
1607         if(bits == 0) {
1608                 *val = 0;
1609                 return true;
1610         }
1611
1612         while(bb->total_consumed_bits + bits > bb->total_bits) {
1613                 if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
1614                         return false;
1615         }
1616 #if FLAC__BITS_PER_BLURB > 8
1617         if(bb->bits == 0 || bb->consumed_blurbs < bb->blurbs) { /*@@@ comment on why this is here*/
1618 #endif
1619                 if(bb->consumed_bits) {
1620                         i = FLAC__BITS_PER_BLURB - bb->consumed_bits;
1621                         if(i <= bits_) {
1622                                 v = bb->buffer[bb->consumed_blurbs] & (FLAC__BLURB_ALL_ONES >> bb->consumed_bits);
1623                                 bits_ -= i;
1624                                 CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
1625                                 bb->consumed_blurbs++;
1626                                 bb->consumed_bits = 0;
1627                                 /* we hold off updating bb->total_consumed_bits until the end */
1628                         }
1629                         else {
1630                                 /* bits_ must be < FLAC__BITS_PER_BLURB-1 if we get to here */
1631                                 v = (bb->buffer[bb->consumed_blurbs] & (FLAC__BLURB_ALL_ONES >> bb->consumed_bits));
1632                                 v <<= (32-i);
1633                                 *val = (FLAC__int32)v;
1634                                 *val >>= (32-bits_);
1635                                 bb->consumed_bits += bits_;
1636                                 bb->total_consumed_bits += bits_;
1637                                 return true;
1638                         }
1639                 }
1640 #if FLAC__BITS_PER_BLURB == 32
1641                 /* note that we know bits_ cannot be > 32 because of previous assertions */
1642                 if(bits_ == FLAC__BITS_PER_BLURB) {
1643                         v = bb->buffer[bb->consumed_blurbs];
1644                         bits_ = 0;
1645                         CRC16_UPDATE_BLURB(bb, v, bb->read_crc16);
1646                         bb->consumed_blurbs++;
1647                         /* bb->consumed_bits is already 0 */
1648                         /* we hold off updating bb->total_consumed_bits until the end */
1649                 }
1650 #else
1651                 while(bits_ >= FLAC__BITS_PER_BLURB) {
1652                         v <<= FLAC__BITS_PER_BLURB;
1653                         v |= bb->buffer[bb->consumed_blurbs];
1654                         bits_ -= FLAC__BITS_PER_BLURB;
1655                         CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
1656                         bb->consumed_blurbs++;
1657                         /* bb->consumed_bits is already 0 */
1658                         /* we hold off updating bb->total_consumed_bits until the end */
1659                 }
1660 #endif
1661                 if(bits_ > 0) {
1662                         v <<= bits_;
1663                         v |= (bb->buffer[bb->consumed_blurbs] >> (FLAC__BITS_PER_BLURB-bits_));
1664                         bb->consumed_bits = bits_;
1665                         /* we hold off updating bb->total_consumed_bits until the end */
1666                 }
1667                 bb->total_consumed_bits += bits;
1668 #if FLAC__BITS_PER_BLURB > 8
1669         }
1670         else {
1671                 for(i = 0; i < bits; i++) {
1672                         if(!FLAC__bitbuffer_read_bit_to_uint32(bb, &v, read_callback, client_data))
1673                                 return false;
1674                 }
1675         }
1676 #endif
1677
1678         /* fix the sign */
1679         i = 32 - bits;
1680         if(i) {
1681                 v <<= i;
1682                 *val = (FLAC__int32)v;
1683                 *val >>= i;
1684         }
1685         else
1686                 *val = (FLAC__int32)v;
1687
1688         return true;
1689 }
1690 #endif
1691
1692 FLAC__bool FLAC__bitbuffer_read_raw_uint64(FLAC__BitBuffer *bb, FLAC__uint64 *val, const unsigned bits, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1693 #ifdef FLAC__NO_MANUAL_INLINING
1694 {
1695         unsigned i;
1696
1697         FLAC__ASSERT(0 != bb);
1698         FLAC__ASSERT(0 != bb->buffer);
1699
1700         FLAC__ASSERT(bits <= 64);
1701
1702         *val = 0;
1703         for(i = 0; i < bits; i++) {
1704                 if(!FLAC__bitbuffer_read_bit_to_uint64(bb, val, read_callback, client_data))
1705                         return false;
1706         }
1707         return true;
1708 }
1709 #else
1710 {
1711         unsigned i, bits_ = bits;
1712         FLAC__uint64 v = 0;
1713
1714         FLAC__ASSERT(0 != bb);
1715         FLAC__ASSERT(0 != bb->buffer);
1716
1717         FLAC__ASSERT(bits <= 64);
1718         FLAC__ASSERT((bb->capacity*FLAC__BITS_PER_BLURB) * 2 >= bits);
1719
1720         if(bits == 0) {
1721                 *val = 0;
1722                 return true;
1723         }
1724
1725         while(bb->total_consumed_bits + bits > bb->total_bits) {
1726                 if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
1727                         return false;
1728         }
1729 #if FLAC__BITS_PER_BLURB > 8
1730         if(bb->bits == 0 || bb->consumed_blurbs < bb->blurbs) { /*@@@ comment on why this is here*/
1731 #endif
1732                 if(bb->consumed_bits) {
1733                         i = FLAC__BITS_PER_BLURB - bb->consumed_bits;
1734                         if(i <= bits_) {
1735                                 v = bb->buffer[bb->consumed_blurbs] & (FLAC__BLURB_ALL_ONES >> bb->consumed_bits);
1736                                 bits_ -= i;
1737                                 CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
1738                                 bb->consumed_blurbs++;
1739                                 bb->consumed_bits = 0;
1740                                 /* we hold off updating bb->total_consumed_bits until the end */
1741                         }
1742                         else {
1743                                 *val = (bb->buffer[bb->consumed_blurbs] & (FLAC__BLURB_ALL_ONES >> bb->consumed_bits)) >> (i-bits_);
1744                                 bb->consumed_bits += bits_;
1745                                 bb->total_consumed_bits += bits_;
1746                                 return true;
1747                         }
1748                 }
1749                 while(bits_ >= FLAC__BITS_PER_BLURB) {
1750                         v <<= FLAC__BITS_PER_BLURB;
1751                         v |= bb->buffer[bb->consumed_blurbs];
1752                         bits_ -= FLAC__BITS_PER_BLURB;
1753                         CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
1754                         bb->consumed_blurbs++;
1755                         /* bb->consumed_bits is already 0 */
1756                         /* we hold off updating bb->total_consumed_bits until the end */
1757                 }
1758                 if(bits_ > 0) {
1759                         v <<= bits_;
1760                         v |= (bb->buffer[bb->consumed_blurbs] >> (FLAC__BITS_PER_BLURB-bits_));
1761                         bb->consumed_bits = bits_;
1762                         /* we hold off updating bb->total_consumed_bits until the end */
1763                 }
1764                 bb->total_consumed_bits += bits;
1765                 *val = v;
1766 #if FLAC__BITS_PER_BLURB > 8
1767         }
1768         else {
1769                 *val = 0;
1770                 for(i = 0; i < bits; i++) {
1771                         if(!FLAC__bitbuffer_read_bit_to_uint64(bb, val, read_callback, client_data))
1772                                 return false;
1773                 }
1774         }
1775 #endif
1776         return true;
1777 }
1778 #endif
1779
1780 #if 0 /* UNUSED */
1781 FLAC__bool FLAC__bitbuffer_read_raw_int64(FLAC__BitBuffer *bb, FLAC__int64 *val, const unsigned bits, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1782 #ifdef FLAC__NO_MANUAL_INLINING
1783 {
1784         unsigned i;
1785         FLAC__uint64 v;
1786
1787         FLAC__ASSERT(0 != bb);
1788         FLAC__ASSERT(0 != bb->buffer);
1789
1790         FLAC__ASSERT(bits <= 64);
1791
1792         v = 0;
1793         for(i = 0; i < bits; i++) {
1794                 if(!FLAC__bitbuffer_read_bit_to_uint64(bb, &v, read_callback, client_data))
1795                         return false;
1796         }
1797         /* fix the sign */
1798         i = 64 - bits;
1799         if(i) {
1800                 v <<= i;
1801                 *val = (FLAC__int64)v;
1802                 *val >>= i;
1803         }
1804         else
1805                 *val = (FLAC__int64)v;
1806
1807         return true;
1808 }
1809 #else
1810 {
1811         unsigned i, bits_ = bits;
1812         FLAC__uint64 v = 0;
1813
1814         FLAC__ASSERT(0 != bb);
1815         FLAC__ASSERT(0 != bb->buffer);
1816
1817         FLAC__ASSERT(bits <= 64);
1818         FLAC__ASSERT((bb->capacity*FLAC__BITS_PER_BLURB) * 2 >= bits);
1819
1820         if(bits == 0) {
1821                 *val = 0;
1822                 return true;
1823         }
1824
1825         while(bb->total_consumed_bits + bits > bb->total_bits) {
1826                 if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
1827                         return false;
1828         }
1829 #if FLAC__BITS_PER_BLURB > 8
1830         if(bb->bits == 0 || bb->consumed_blurbs < bb->blurbs) { /*@@@ comment on why this is here*/
1831 #endif
1832                 if(bb->consumed_bits) {
1833                         i = FLAC__BITS_PER_BLURB - bb->consumed_bits;
1834                         if(i <= bits_) {
1835                                 v = bb->buffer[bb->consumed_blurbs] & (FLAC__BLURB_ALL_ONES >> bb->consumed_bits);
1836                                 bits_ -= i;
1837                                 CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
1838                                 bb->consumed_blurbs++;
1839                                 bb->consumed_bits = 0;
1840                                 /* we hold off updating bb->total_consumed_bits until the end */
1841                         }
1842                         else {
1843                                 /* bits_ must be < FLAC__BITS_PER_BLURB-1 if we get to here */
1844                                 v = (bb->buffer[bb->consumed_blurbs] & (FLAC__BLURB_ALL_ONES >> bb->consumed_bits));
1845                                 v <<= (64-i);
1846                                 *val = (FLAC__int64)v;
1847                                 *val >>= (64-bits_);
1848                                 bb->consumed_bits += bits_;
1849                                 bb->total_consumed_bits += bits_;
1850                                 return true;
1851                         }
1852                 }
1853                 while(bits_ >= FLAC__BITS_PER_BLURB) {
1854                         v <<= FLAC__BITS_PER_BLURB;
1855                         v |= bb->buffer[bb->consumed_blurbs];
1856                         bits_ -= FLAC__BITS_PER_BLURB;
1857                         CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
1858                         bb->consumed_blurbs++;
1859                         /* bb->consumed_bits is already 0 */
1860                         /* we hold off updating bb->total_consumed_bits until the end */
1861                 }
1862                 if(bits_ > 0) {
1863                         v <<= bits_;
1864                         v |= (bb->buffer[bb->consumed_blurbs] >> (FLAC__BITS_PER_BLURB-bits_));
1865                         bb->consumed_bits = bits_;
1866                         /* we hold off updating bb->total_consumed_bits until the end */
1867                 }
1868                 bb->total_consumed_bits += bits;
1869 #if FLAC__BITS_PER_BLURB > 8
1870         }
1871         else {
1872                 for(i = 0; i < bits; i++) {
1873                         if(!FLAC__bitbuffer_read_bit_to_uint64(bb, &v, read_callback, client_data))
1874                                 return false;
1875                 }
1876         }
1877 #endif
1878
1879         /* fix the sign */
1880         i = 64 - bits;
1881         if(i) {
1882                 v <<= i;
1883                 *val = (FLAC__int64)v;
1884                 *val >>= i;
1885         }
1886         else
1887                 *val = (FLAC__int64)v;
1888
1889         return true;
1890 }
1891 #endif
1892 #endif
1893
1894 FLaC__INLINE FLAC__bool FLAC__bitbuffer_read_raw_uint32_little_endian(FLAC__BitBuffer *bb, FLAC__uint32 *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1895 {
1896         FLAC__uint32 x8, x32 = 0;
1897
1898         /* this doesn't need to be that fast as currently it is only used for vorbis comments */
1899
1900         if(!FLAC__bitbuffer_read_raw_uint32(bb, &x32, 8, read_callback, client_data))
1901                 return false;
1902
1903         if(!FLAC__bitbuffer_read_raw_uint32(bb, &x8, 8, read_callback, client_data))
1904                 return false;
1905         x32 |= (x8 << 8);
1906
1907         if(!FLAC__bitbuffer_read_raw_uint32(bb, &x8, 8, read_callback, client_data))
1908                 return false;
1909         x32 |= (x8 << 16);
1910
1911         if(!FLAC__bitbuffer_read_raw_uint32(bb, &x8, 8, read_callback, client_data))
1912                 return false;
1913         x32 |= (x8 << 24);
1914
1915         *val = x32;
1916         return true;
1917 }
1918
1919 FLAC__bool FLAC__bitbuffer_skip_bits_no_crc(FLAC__BitBuffer *bb, unsigned bits, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1920 {
1921         /*
1922          * @@@ a slightly faster implementation is possible but
1923          * probably not that useful since this is only called a
1924          * couple of times in the metadata readers.
1925          */
1926         FLAC__ASSERT(0 != bb);
1927         FLAC__ASSERT(0 != bb->buffer);
1928
1929         if(bits > 0) {
1930                 const unsigned n = bb->consumed_bits & 7;
1931                 unsigned m;
1932                 FLAC__uint32 x;
1933
1934                 if(n != 0) {
1935                         m = min(8-n, bits);
1936                         if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, m, read_callback, client_data))
1937                                 return false;
1938                         bits -= m;
1939                 }
1940                 m = bits / 8;
1941                 if(m > 0) {
1942                         if(!FLAC__bitbuffer_read_byte_block_aligned_no_crc(bb, 0, m, read_callback, client_data))
1943                                 return false;
1944                         bits %= 8;
1945                 }
1946                 if(bits > 0) {
1947                         if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, bits, read_callback, client_data))
1948                                 return false;
1949                 }
1950         }
1951
1952         return true;
1953 }
1954
1955 FLAC__bool FLAC__bitbuffer_read_byte_block_aligned_no_crc(FLAC__BitBuffer *bb, FLAC__byte *val, unsigned nvals, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1956 {
1957         FLAC__ASSERT(0 != bb);
1958         FLAC__ASSERT(0 != bb->buffer);
1959         FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(bb));
1960         FLAC__ASSERT(FLAC__bitbuffer_is_consumed_byte_aligned(bb));
1961 #if FLAC__BITS_PER_BLURB == 8
1962         while(nvals > 0) {
1963                 unsigned chunk = min(nvals, bb->blurbs - bb->consumed_blurbs);
1964                 if(chunk == 0) {
1965                         if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
1966                                 return false;
1967                 }
1968                 else {
1969                         if(0 != val) {
1970                                 memcpy(val, bb->buffer + bb->consumed_blurbs, FLAC__BYTES_PER_BLURB * chunk);
1971                                 val += FLAC__BYTES_PER_BLURB * chunk;
1972                         }
1973                         nvals -= chunk;
1974                         bb->consumed_blurbs += chunk;
1975                         bb->total_consumed_bits = (bb->consumed_blurbs << FLAC__BITS_PER_BLURB_LOG2);
1976                 }
1977         }
1978 #else
1979         @@@ need to write this still
1980         FLAC__ASSERT(0);
1981 #endif
1982
1983         return true;
1984 }
1985
1986 FLaC__INLINE FLAC__bool FLAC__bitbuffer_read_unary_unsigned(FLAC__BitBuffer *bb, unsigned *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1987 #ifdef FLAC__NO_MANUAL_INLINING
1988 {
1989         unsigned bit, val_ = 0;
1990
1991         FLAC__ASSERT(0 != bb);
1992         FLAC__ASSERT(0 != bb->buffer);
1993
1994         while(1) {
1995                 if(!FLAC__bitbuffer_read_bit(bb, &bit, read_callback, client_data))
1996                         return false;
1997                 if(bit)
1998                         break;
1999                 else
2000                         val_++;
2001         }
2002         *val = val_;
2003         return true;
2004 }
2005 #else
2006 {
2007         unsigned i, val_ = 0;
2008         unsigned total_blurbs_ = (bb->total_bits + (FLAC__BITS_PER_BLURB-1)) / FLAC__BITS_PER_BLURB;
2009         FLAC__blurb b;
2010
2011         FLAC__ASSERT(0 != bb);
2012         FLAC__ASSERT(0 != bb->buffer);
2013
2014 #if FLAC__BITS_PER_BLURB > 8
2015         if(bb->bits == 0 || bb->consumed_blurbs < bb->blurbs) { /*@@@ comment on why this is here*/
2016 #endif
2017                 if(bb->consumed_bits) {
2018                         b = bb->buffer[bb->consumed_blurbs] << bb->consumed_bits;
2019                         if(b) {
2020                                 for(i = 0; !(b & FLAC__BLURB_TOP_BIT_ONE); i++)
2021                                         b <<= 1;
2022                                 *val = i;
2023                                 i++;
2024                                 bb->consumed_bits += i;
2025                                 bb->total_consumed_bits += i;
2026                                 if(bb->consumed_bits == FLAC__BITS_PER_BLURB) {
2027                                         CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
2028                                         bb->consumed_blurbs++;
2029                                         bb->consumed_bits = 0;
2030                                 }
2031                                 return true;
2032                         }
2033                         else {
2034                                 val_ = FLAC__BITS_PER_BLURB - bb->consumed_bits;
2035                                 CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
2036                                 bb->consumed_blurbs++;
2037                                 bb->consumed_bits = 0;
2038                                 bb->total_consumed_bits += val_;
2039                         }
2040                 }
2041                 while(1) {
2042                         if(bb->consumed_blurbs >= total_blurbs_) {
2043                                 if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
2044                                         return false;
2045                                 total_blurbs_ = (bb->total_bits + (FLAC__BITS_PER_BLURB-1)) / FLAC__BITS_PER_BLURB;
2046                         }
2047                         b = bb->buffer[bb->consumed_blurbs];
2048                         if(b) {
2049                                 for(i = 0; !(b & FLAC__BLURB_TOP_BIT_ONE); i++)
2050                                         b <<= 1;
2051                                 val_ += i;
2052                                 i++;
2053                                 bb->consumed_bits = i;
2054                                 *val = val_;
2055                                 if(i == FLAC__BITS_PER_BLURB) {
2056                                         CRC16_UPDATE_BLURB(bb, bb->buffer[bb->consumed_blurbs], bb->read_crc16);
2057                                         bb->consumed_blurbs++;
2058                                         bb->consumed_bits = 0;
2059                                 }
2060                                 bb->total_consumed_bits += i;
2061                                 return true;
2062                         }
2063                         else {
2064                                 val_ += FLAC__BITS_PER_BLURB;
2065                                 CRC16_UPDATE_BLURB(bb, 0, bb->read_crc16);
2066                                 bb->consumed_blurbs++;
2067                                 /* bb->consumed_bits is already 0 */
2068                                 bb->total_consumed_bits += FLAC__BITS_PER_BLURB;
2069                         }
2070                 }
2071 #if FLAC__BITS_PER_BLURB > 8
2072         }
2073         else {
2074                 while(1) {
2075                         if(!FLAC__bitbuffer_read_bit(bb, &i, read_callback, client_data))
2076                                 return false;
2077                         if(i)
2078                                 break;
2079                         else
2080                                 val_++;
2081                 }
2082                 *val = val_;
2083                 return true;
2084         }
2085 #endif
2086 }
2087 #endif
2088
2089 #ifdef FLAC__SYMMETRIC_RICE
2090 FLAC__bool FLAC__bitbuffer_read_symmetric_rice_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
2091 {
2092         FLAC__uint32 sign = 0, lsbs = 0, msbs = 0;
2093
2094         FLAC__ASSERT(0 != bb);
2095         FLAC__ASSERT(0 != bb->buffer);
2096         FLAC__ASSERT(parameter <= 31);
2097
2098         /* read the unary MSBs and end bit */
2099         if(!FLAC__bitbuffer_read_unary_unsigned(bb, &msbs, read_callback, client_data))
2100                 return false;
2101
2102         /* read the sign bit */
2103         if(!FLAC__bitbuffer_read_bit_to_uint32(bb, &sign, read_callback, client_data))
2104                 return false;
2105
2106         /* read the binary LSBs */
2107         if(!FLAC__bitbuffer_read_raw_uint32(bb, &lsbs, parameter, read_callback, client_data))
2108                 return false;
2109
2110         /* compose the value */
2111         *val = (msbs << parameter) | lsbs;
2112         if(sign)
2113                 *val = -(*val);
2114
2115         return true;
2116 }
2117 #endif /* ifdef FLAC__SYMMETRIC_RICE */
2118
2119 FLAC__bool FLAC__bitbuffer_read_rice_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
2120 {
2121         FLAC__uint32 lsbs = 0, msbs = 0;
2122         unsigned uval;
2123
2124         FLAC__ASSERT(0 != bb);
2125         FLAC__ASSERT(0 != bb->buffer);
2126         FLAC__ASSERT(parameter <= 31);
2127
2128         /* read the unary MSBs and end bit */
2129         if(!FLAC__bitbuffer_read_unary_unsigned(bb, &msbs, read_callback, client_data))
2130                 return false;
2131
2132         /* read the binary LSBs */
2133         if(!FLAC__bitbuffer_read_raw_uint32(bb, &lsbs, parameter, read_callback, client_data))
2134                 return false;
2135
2136         /* compose the value */
2137         uval = (msbs << parameter) | lsbs;
2138         if(uval & 1)
2139                 *val = -((int)(uval >> 1)) - 1;
2140         else
2141                 *val = (int)(uval >> 1);
2142
2143         return true;
2144 }
2145
2146 FLAC__bool FLAC__bitbuffer_read_rice_signed_block(FLAC__BitBuffer *bb, int vals[], unsigned nvals, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
2147 #ifdef FLAC__OLD_MSVC_FLAVOR
2148 {
2149         const FLAC__blurb *buffer = bb->buffer;
2150
2151         unsigned i, j, val_i = 0;
2152         unsigned cbits = 0, uval = 0, msbs = 0, lsbs_left = 0;
2153         FLAC__blurb blurb, save_blurb;
2154         unsigned state = 0; /* 0 = getting unary MSBs, 1 = getting binary LSBs */
2155
2156         FLAC__ASSERT(0 != bb);
2157         FLAC__ASSERT(0 != bb->buffer);
2158         FLAC__ASSERT(parameter <= 31);
2159
2160         if(nvals == 0)
2161                 return true;
2162
2163         i = bb->consumed_blurbs;
2164         /*
2165          * We unroll the main loop to take care of partially consumed blurbs here.
2166          */
2167         if(bb->consumed_bits > 0) {
2168                 save_blurb = blurb = buffer[i];
2169                 cbits = bb->consumed_bits;
2170                 blurb <<= cbits;
2171
2172                 while(1) {
2173                         if(state == 0) {
2174                                 if(blurb) {
2175                                         for(j = 0; !(blurb & FLAC__BLURB_TOP_BIT_ONE); j++)
2176                                                 blurb <<= 1;
2177                                         msbs += j;
2178
2179                                         /* dispose of the unary end bit */
2180                                         blurb <<= 1;
2181                                         j++;
2182                                         cbits += j;
2183
2184                                         uval = 0;
2185                                         lsbs_left = parameter;
2186                                         state++;
2187                                         if(cbits == FLAC__BITS_PER_BLURB) {
2188                                                 cbits = 0;
2189                                                 CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
2190                                                 break;
2191                                         }
2192                                 }
2193                                 else {
2194                                         msbs += FLAC__BITS_PER_BLURB - cbits;
2195                                         cbits = 0;
2196                                         CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
2197                                         break;
2198                                 }
2199                         }
2200                         else {
2201                                 const unsigned available_bits = FLAC__BITS_PER_BLURB - cbits;
2202                                 if(lsbs_left >= available_bits) {
2203                                         uval <<= available_bits;
2204                                         uval |= (blurb >> cbits);
2205                                         cbits = 0;
2206                                         CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
2207
2208                                         if(lsbs_left == available_bits) {
2209                                                 /* compose the value */
2210                                                 uval |= (msbs << parameter);
2211                                                 if(uval & 1)
2212                                                         vals[val_i++] = -((int)(uval >> 1)) - 1;
2213                                                 else
2214                                                         vals[val_i++] = (int)(uval >> 1);
2215                                                 if(val_i == nvals)
2216                                                         break;
2217
2218                                                 msbs = 0;
2219                                                 state = 0;
2220                                         }
2221
2222                                         lsbs_left -= available_bits;
2223                                         break;
2224                                 }
2225                                 else {
2226                                         uval <<= lsbs_left;
2227                                         uval |= (blurb >> (FLAC__BITS_PER_BLURB - lsbs_left));
2228                                         blurb <<= lsbs_left;
2229                                         cbits += lsbs_left;
2230
2231                                         /* compose the value */
2232                                         uval |= (msbs << parameter);
2233                                         if(uval & 1)
2234                                                 vals[val_i++] = -((int)(uval >> 1)) - 1;
2235                                         else
2236                                                 vals[val_i++] = (int)(uval >> 1);
2237                                         if(val_i == nvals) {
2238                                                 /* back up one if we exited the for loop because we read all nvals but the end came in the middle of a blurb */
2239                                                 i--;
2240                                                 break;
2241                                         }
2242
2243                                         msbs = 0;
2244                                         state = 0;
2245                                 }
2246                         }
2247                 }
2248                 i++;
2249
2250                 bb->consumed_blurbs = i;
2251                 bb->consumed_bits = cbits;
2252                 bb->total_consumed_bits = (i << FLAC__BITS_PER_BLURB_LOG2) | cbits;
2253         }
2254
2255         /*
2256          * Now that we are blurb-aligned the logic is slightly simpler
2257          */
2258         while(val_i < nvals) {
2259                 for( ; i < bb->blurbs && val_i < nvals; i++) {
2260                         save_blurb = blurb = buffer[i];
2261                         cbits = 0;
2262                         while(1) {
2263                                 if(state == 0) {
2264                                         if(blurb) {
2265                                                 for(j = 0; !(blurb & FLAC__BLURB_TOP_BIT_ONE); j++)
2266                                                         blurb <<= 1;
2267                                                 msbs += j;
2268
2269                                                 /* dispose of the unary end bit */
2270                                                 blurb <<= 1;
2271                                                 j++;
2272                                                 cbits += j;
2273
2274                                                 uval = 0;
2275                                                 lsbs_left = parameter;
2276                                                 state++;
2277                                                 if(cbits == FLAC__BITS_PER_BLURB) {
2278                                                         cbits = 0;
2279                                                         CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
2280                                                         break;
2281                                                 }
2282                                         }
2283                                         else {
2284                                                 msbs += FLAC__BITS_PER_BLURB - cbits;
2285                                                 cbits = 0;
2286                                                 CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
2287                                                 break;
2288                                         }
2289                                 }
2290                                 else {
2291                                         const unsigned available_bits = FLAC__BITS_PER_BLURB - cbits;
2292                                         if(lsbs_left >= available_bits) {
2293                                                 uval <<= available_bits;
2294                                                 uval |= (blurb >> cbits);
2295                                                 cbits = 0;
2296                                                 CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
2297
2298                                                 if(lsbs_left == available_bits) {
2299                                                         /* compose the value */
2300                                                         uval |= (msbs << parameter);
2301                                                         if(uval & 1)
2302                                                                 vals[val_i++] = -((int)(uval >> 1)) - 1;
2303                                                         else
2304                                                                 vals[val_i++] = (int)(uval >> 1);
2305                                                         if(val_i == nvals)
2306                                                                 break;
2307
2308                                                         msbs = 0;
2309                                                         state = 0;
2310                                                 }
2311
2312                                                 lsbs_left -= available_bits;
2313                                                 break;
2314                                         }
2315                                         else {
2316                                                 uval <<= lsbs_left;
2317                                                 uval |= (blurb >> (FLAC__BITS_PER_BLURB - lsbs_left));
2318                                                 blurb <<= lsbs_left;
2319                                                 cbits += lsbs_left;
2320
2321                                                 /* compose the value */
2322                                                 uval |= (msbs << parameter);
2323                                                 if(uval & 1)
2324                                                         vals[val_i++] = -((int)(uval >> 1)) - 1;
2325                                                 else
2326                                                         vals[val_i++] = (int)(uval >> 1);
2327                                                 if(val_i == nvals) {
2328                                                         /* back up one if we exited the for loop because we read all nvals but the end came in the middle of a blurb */
2329                                                         i--;
2330                                                         break;
2331                                                 }
2332
2333                                                 msbs = 0;
2334                                                 state = 0;
2335                                         }
2336                                 }
2337                         }
2338                 }
2339                 bb->consumed_blurbs = i;
2340                 bb->consumed_bits = cbits;
2341                 bb->total_consumed_bits = (i << FLAC__BITS_PER_BLURB_LOG2) | cbits;
2342                 if(val_i < nvals) {
2343                         if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
2344                                 return false;
2345                         /* these must be zero because we can only get here if we got to the end of the buffer */
2346                         FLAC__ASSERT(bb->consumed_blurbs == 0);
2347                         FLAC__ASSERT(bb->consumed_bits == 0);
2348                         i = 0;
2349                 }
2350         }
2351
2352         return true;
2353 }
2354 #else
2355 {
2356         const FLAC__blurb *buffer = bb->buffer;
2357
2358         unsigned i, j, val_i = nvals;
2359         unsigned cbits = 0, uval = 0, msbs = 0, lsbs_left = 0;
2360         FLAC__blurb blurb, save_blurb;
2361         unsigned state = 0; /* 0 = getting unary MSBs, 1 = getting binary LSBs */
2362
2363         FLAC__ASSERT(0 != bb);
2364         FLAC__ASSERT(0 != bb->buffer);
2365         FLAC__ASSERT(parameter <= 31);
2366
2367         if(nvals == 0)
2368                 return true;
2369
2370         cbits = bb->consumed_bits;
2371         i = bb->consumed_blurbs;
2372         while(val_i != 0) {
2373                 for( ; i < bb->blurbs; i++) {
2374                         blurb = (save_blurb = buffer[i]) << cbits;
2375                         while(1) {
2376                                 if(state == 0) {
2377                                         if(blurb) {
2378                                                 j = FLAC__ALIGNED_BLURB_UNARY(blurb);
2379                                                 msbs += j;
2380                                                 j++;
2381                                                 cbits += j;
2382
2383                                                 uval = 0;
2384                                                 lsbs_left = parameter;
2385                                                 state++;
2386                                                 if(cbits == FLAC__BITS_PER_BLURB) {
2387                                                         cbits = 0;
2388                                                         CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
2389                                                         break;
2390                                                 }
2391                                                 blurb <<= j;
2392                                         }
2393                                         else {
2394                                                 msbs += FLAC__BITS_PER_BLURB - cbits;
2395                                                 cbits = 0;
2396                                                 CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
2397                                                 break;
2398                                         }
2399                                 }
2400                                 else {
2401                                         const unsigned available_bits = FLAC__BITS_PER_BLURB - cbits;
2402                                         if(lsbs_left >= available_bits) {
2403                                                 uval <<= available_bits;
2404                                                 uval |= (blurb >> cbits);
2405                                                 cbits = 0;
2406                                                 CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
2407
2408                                                 if(lsbs_left == available_bits) {
2409                                                         /* compose the value */
2410                                                         uval |= (msbs << parameter);
2411                                                         *vals = (int)(uval >> 1 ^ -(int)(uval & 1));
2412                                                         --val_i;
2413                                                         if(val_i == 0) {
2414                                                                 i++;
2415                                                                 goto break2;
2416                                                         }
2417                                                         ++vals;
2418
2419                                                         msbs = 0;
2420                                                         state = 0;
2421                                                 }
2422
2423                                                 lsbs_left -= available_bits;
2424                                                 break;
2425                                         }
2426                                         else {
2427                                                 cbits += lsbs_left;
2428                                                 uval <<= lsbs_left;
2429                                                 uval |= (blurb >> (FLAC__BITS_PER_BLURB - lsbs_left));
2430                                                 blurb <<= lsbs_left;
2431
2432                                                 /* compose the value */
2433                                                 uval |= (msbs << parameter);
2434                                                 *vals = (int)(uval >> 1 ^ -(int)(uval & 1));
2435                                                 --val_i;
2436                                                 if(val_i == 0)
2437                                                         goto break2;
2438                                                 ++vals;
2439
2440                                                 msbs = 0;
2441                                                 state = 0;
2442                                         }
2443                                 }
2444                         }
2445                 }
2446 break2:
2447                 bb->consumed_blurbs = i;
2448                 bb->consumed_bits = cbits;
2449                 bb->total_consumed_bits = (i << FLAC__BITS_PER_BLURB_LOG2) | cbits;
2450                 if(val_i != 0) {
2451                         if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
2452                                 return false;
2453                         /* these must be zero because we can only get here if we got to the end of the buffer */
2454                         FLAC__ASSERT(bb->consumed_blurbs == 0);
2455                         FLAC__ASSERT(bb->consumed_bits == 0);
2456                         i = 0;
2457                 }
2458         }
2459
2460         return true;
2461 }
2462 #endif
2463
2464 #if 0 /* UNUSED */
2465 FLAC__bool FLAC__bitbuffer_read_golomb_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
2466 {
2467         FLAC__uint32 lsbs = 0, msbs = 0;
2468         unsigned bit, uval, k;
2469
2470         FLAC__ASSERT(0 != bb);
2471         FLAC__ASSERT(0 != bb->buffer);
2472
2473         k = FLAC__bitmath_ilog2(parameter);
2474
2475         /* read the unary MSBs and end bit */
2476         if(!FLAC__bitbuffer_read_unary_unsigned(bb, &msbs, read_callback, client_data))
2477                 return false;
2478
2479         /* read the binary LSBs */
2480         if(!FLAC__bitbuffer_read_raw_uint32(bb, &lsbs, k, read_callback, client_data))
2481                 return false;
2482
2483         if(parameter == 1u<<k) {
2484                 /* compose the value */
2485                 uval = (msbs << k) | lsbs;
2486         }
2487         else {
2488                 unsigned d = (1 << (k+1)) - parameter;
2489                 if(lsbs >= d) {
2490                         if(!FLAC__bitbuffer_read_bit(bb, &bit, read_callback, client_data))
2491                                 return false;
2492                         lsbs <<= 1;
2493                         lsbs |= bit;
2494                         lsbs -= d;
2495                 }
2496                 /* compose the value */
2497                 uval = msbs * parameter + lsbs;
2498         }
2499
2500         /* unfold unsigned to signed */
2501         if(uval & 1)
2502                 *val = -((int)(uval >> 1)) - 1;
2503         else
2504                 *val = (int)(uval >> 1);
2505
2506         return true;
2507 }
2508
2509 FLAC__bool FLAC__bitbuffer_read_golomb_unsigned(FLAC__BitBuffer *bb, unsigned *val, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
2510 {
2511         FLAC__uint32 lsbs, msbs = 0;
2512         unsigned bit, k;
2513
2514         FLAC__ASSERT(0 != bb);
2515         FLAC__ASSERT(0 != bb->buffer);
2516
2517         k = FLAC__bitmath_ilog2(parameter);
2518
2519         /* read the unary MSBs and end bit */
2520         if(!FLAC__bitbuffer_read_unary_unsigned(bb, &msbs, read_callback, client_data))
2521                 return false;
2522
2523         /* read the binary LSBs */
2524         if(!FLAC__bitbuffer_read_raw_uint32(bb, &lsbs, k, read_callback, client_data))
2525                 return false;
2526
2527         if(parameter == 1u<<k) {
2528                 /* compose the value */
2529                 *val = (msbs << k) | lsbs;
2530         }
2531         else {
2532                 unsigned d = (1 << (k+1)) - parameter;
2533                 if(lsbs >= d) {
2534                         if(!FLAC__bitbuffer_read_bit(bb, &bit, read_callback, client_data))
2535                                 return false;
2536                         lsbs <<= 1;
2537                         lsbs |= bit;
2538                         lsbs -= d;
2539                 }
2540                 /* compose the value */
2541                 *val = msbs * parameter + lsbs;
2542         }
2543
2544         return true;
2545 }
2546 #endif /* UNUSED */
2547
2548 /* on return, if *val == 0xffffffff then the utf-8 sequence was invalid, but the return value will be true */
2549 FLAC__bool FLAC__bitbuffer_read_utf8_uint32(FLAC__BitBuffer *bb, FLAC__uint32 *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data, FLAC__byte *raw, unsigned *rawlen)
2550 {
2551         FLAC__uint32 v = 0;
2552         FLAC__uint32 x;
2553         unsigned i;
2554
2555         if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, 8, read_callback, client_data))
2556                 return false;
2557         if(raw)
2558                 raw[(*rawlen)++] = (FLAC__byte)x;
2559         if(!(x & 0x80)) { /* 0xxxxxxx */
2560                 v = x;
2561                 i = 0;
2562         }
2563         else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
2564                 v = x & 0x1F;
2565                 i = 1;
2566         }
2567         else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
2568                 v = x & 0x0F;
2569                 i = 2;
2570         }
2571         else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
2572                 v = x & 0x07;
2573                 i = 3;
2574         }
2575         else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
2576                 v = x & 0x03;
2577                 i = 4;
2578         }
2579         else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
2580                 v = x & 0x01;
2581                 i = 5;
2582         }
2583         else {
2584                 *val = 0xffffffff;
2585                 return true;
2586         }
2587         for( ; i; i--) {
2588                 if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, 8, read_callback, client_data))
2589                         return false;
2590                 if(raw)
2591                         raw[(*rawlen)++] = (FLAC__byte)x;
2592                 if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
2593                         *val = 0xffffffff;
2594                         return true;
2595                 }
2596                 v <<= 6;
2597                 v |= (x & 0x3F);
2598         }
2599         *val = v;
2600         return true;
2601 }
2602
2603 /* on return, if *val == 0xffffffffffffffff then the utf-8 sequence was invalid, but the return value will be true */
2604 FLAC__bool FLAC__bitbuffer_read_utf8_uint64(FLAC__BitBuffer *bb, FLAC__uint64 *val, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data, FLAC__byte *raw, unsigned *rawlen)
2605 {
2606         FLAC__uint64 v = 0;
2607         FLAC__uint32 x;
2608         unsigned i;
2609
2610         if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, 8, read_callback, client_data))
2611                 return false;
2612         if(raw)
2613                 raw[(*rawlen)++] = (FLAC__byte)x;
2614         if(!(x & 0x80)) { /* 0xxxxxxx */
2615                 v = x;
2616                 i = 0;
2617         }
2618         else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
2619                 v = x & 0x1F;
2620                 i = 1;
2621         }
2622         else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
2623                 v = x & 0x0F;
2624                 i = 2;
2625         }
2626         else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
2627                 v = x & 0x07;
2628                 i = 3;
2629         }
2630         else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
2631                 v = x & 0x03;
2632                 i = 4;
2633         }
2634         else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
2635                 v = x & 0x01;
2636                 i = 5;
2637         }
2638         else if(x & 0xFE && !(x & 0x01)) { /* 11111110 */
2639                 v = 0;
2640                 i = 6;
2641         }
2642         else {
2643                 *val = FLAC__U64L(0xffffffffffffffff);
2644                 return true;
2645         }
2646         for( ; i; i--) {
2647                 if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, 8, read_callback, client_data))
2648                         return false;
2649                 if(raw)
2650                         raw[(*rawlen)++] = (FLAC__byte)x;
2651                 if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
2652                         *val = FLAC__U64L(0xffffffffffffffff);
2653                         return true;
2654                 }
2655                 v <<= 6;
2656                 v |= (x & 0x3F);
2657         }
2658         *val = v;
2659         return true;
2660 }
2661
2662 void FLAC__bitbuffer_dump(const FLAC__BitBuffer *bb, FILE *out)
2663 {
2664         unsigned i, j;
2665         if(bb == 0) {
2666                 fprintf(out, "bitbuffer is NULL\n");
2667         }
2668         else {
2669                 fprintf(out, "bitbuffer: capacity=%u blurbs=%u bits=%u total_bits=%u consumed: blurbs=%u, bits=%u, total_bits=%u\n", bb->capacity, bb->blurbs, bb->bits, bb->total_bits, bb->consumed_blurbs, bb->consumed_bits, bb->total_consumed_bits);
2670
2671                 for(i = 0; i < bb->blurbs; i++) {
2672                         fprintf(out, "%08X: ", i);
2673                         for(j = 0; j < FLAC__BITS_PER_BLURB; j++)
2674                                 if(i*FLAC__BITS_PER_BLURB+j < bb->total_consumed_bits)
2675                                         fprintf(out, ".");
2676                                 else
2677                                         fprintf(out, "%01u", bb->buffer[i] & (1 << (FLAC__BITS_PER_BLURB-j-1)) ? 1:0);
2678                         fprintf(out, "\n");
2679                 }
2680                 if(bb->bits > 0) {
2681                         fprintf(out, "%08X: ", i);
2682                         for(j = 0; j < bb->bits; j++)
2683                                 if(i*FLAC__BITS_PER_BLURB+j < bb->total_consumed_bits)
2684                                         fprintf(out, ".");
2685                                 else
2686                                         fprintf(out, "%01u", bb->buffer[i] & (1 << (bb->bits-j-1)) ? 1:0);
2687                         fprintf(out, "\n");
2688                 }
2689         }
2690 }