bitbuffer.c - vx32 - Local 9vx git repository for patches.
(HTM) git clone git://r-36.net/vx32
(DIR) Log
(DIR) Files
(DIR) Refs
---
bitbuffer.c (78790B)
---
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 }