1 /* libFLAC - Free Lossless Audio Coder library
2 * Copyright (C) 2000 Josh Coalson
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 #include <stdlib.h> /* for malloc() */
22 #include <string.h> /* for memcpy(), memset() */
23 #include "private/bitbuffer.h"
25 static const unsigned FLAC__BITBUFFER_DEFAULT_CAPACITY = 65536; /* bytes */
30 #define min(x,y) ((x)<(y)?(x):(y))
34 #define max(x,y) ((x)>(y)?(x):(y))
36 static unsigned ilog2_(unsigned v)
45 static bool bitbuffer_resize_(FLAC__BitBuffer *bb, unsigned new_capacity)
50 assert(bb->buffer != 0);
52 if(bb->capacity == new_capacity)
55 new_buffer = (byte*)malloc(sizeof(byte) * new_capacity);
58 memset(new_buffer, 0, new_capacity);
59 memcpy(new_buffer, bb->buffer, sizeof(byte)*min(bb->bytes+(bb->bits?1:0), new_capacity));
60 if(new_capacity < bb->bytes+(bb->bits?1:0)) {
61 bb->bytes = new_capacity;
63 bb->total_bits = (new_capacity<<3);
65 if(new_capacity < bb->consumed_bytes+(bb->consumed_bits?1:0)) {
66 bb->consumed_bytes = new_capacity;
67 bb->consumed_bits = 0;
68 bb->total_consumed_bits = (new_capacity<<3);
70 bb->buffer = new_buffer;
71 bb->capacity = new_capacity;
75 static bool bitbuffer_grow_(FLAC__BitBuffer *bb, unsigned min_bytes_to_add)
77 unsigned new_capacity;
79 assert(min_bytes_to_add > 0);
81 new_capacity = max(bb->capacity * 4, bb->capacity + min_bytes_to_add);
82 return bitbuffer_resize_(bb, new_capacity);
85 static bool bitbuffer_ensure_size_(FLAC__BitBuffer *bb, unsigned bits_to_add)
88 assert(bb->buffer != 0);
89 if((bb->capacity<<3) < bb->total_bits + bits_to_add)
90 return bitbuffer_grow_(bb, (bits_to_add>>3)+2);
95 static bool bitbuffer_read_from_client_(FLAC__BitBuffer *bb, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
99 /* first shift the unconsumed buffer data toward the front as much as possible */
100 if(bb->total_consumed_bits >= 8) {
101 unsigned l = 0, r = bb->consumed_bytes, r_end = bb->bytes;
102 for( ; r < r_end; l++, r++)
103 bb->buffer[l] = bb->buffer[r];
104 for( ; l < r_end; l++)
106 bb->bytes -= bb->consumed_bytes;
107 bb->total_bits -= (bb->consumed_bytes<<3);
108 bb->consumed_bytes = 0;
109 bb->total_consumed_bits = bb->consumed_bits;
111 /* grow if we need to */
112 if(bb->capacity <= 1) {
113 if(!bitbuffer_resize_(bb, 16))
116 /* finally, read in some data; if OK, go back to read_bit_, else fail */
117 bytes = bb->capacity - bb->bytes;
118 if(!read_callback(bb->buffer+bb->bytes, &bytes, client_data))
121 bb->total_bits += (bytes<<3);
125 void FLAC__bitbuffer_init(FLAC__BitBuffer *bb)
130 bb->bytes = bb->bits = bb->total_bits = 0;
131 bb->consumed_bytes = bb->consumed_bits = bb->total_consumed_bits = 0;
134 bool FLAC__bitbuffer_init_from(FLAC__BitBuffer *bb, const byte buffer[], unsigned bytes)
137 FLAC__bitbuffer_init(bb);
142 bb->buffer = (byte*)malloc(sizeof(byte)*bytes);
145 memcpy(bb->buffer, buffer, sizeof(byte)*bytes);
146 bb->capacity = bb->bytes = bytes;
148 bb->total_bits = (bytes<<3);
149 bb->consumed_bytes = bb->consumed_bits = bb->total_consumed_bits = 0;
154 bool FLAC__bitbuffer_concatenate_aligned(FLAC__BitBuffer *dest, const FLAC__BitBuffer *src)
156 static byte mask_[9] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
157 unsigned bits_to_add = src->total_bits - src->total_consumed_bits;
163 if(dest->bits != src->consumed_bits)
165 if(!bitbuffer_ensure_size_(dest, bits_to_add))
167 if(dest->bits == 0) {
168 memcpy(dest->buffer+dest->bytes, src->buffer+src->consumed_bytes, src->bytes-src->consumed_bytes + ((src->bits)? 1:0));
170 else if(dest->bits + bits_to_add > 8) {
171 dest->buffer[dest->bytes] <<= (8 - dest->bits);
172 dest->buffer[dest->bytes] |= (src->buffer[src->consumed_bytes] & mask_[8-dest->bits]);
173 memcpy(dest->buffer+dest->bytes+1, src->buffer+src->consumed_bytes+1, src->bytes-src->consumed_bytes-1 + ((src->bits)? 1:0));
176 dest->buffer[dest->bytes] <<= bits_to_add;
177 dest->buffer[dest->bytes] |= (src->buffer[src->consumed_bytes] & mask_[bits_to_add]);
179 dest->bits = src->bits;
180 dest->total_bits += bits_to_add;
181 dest->bytes = dest->total_bits / 8;
186 void FLAC__bitbuffer_free(FLAC__BitBuffer *bb)
193 bb->bytes = bb->bits = bb->total_bits = 0;
194 bb->consumed_bytes = bb->consumed_bits = bb->total_consumed_bits = 0;
197 bool FLAC__bitbuffer_clear(FLAC__BitBuffer *bb)
199 if(bb->buffer == 0) {
200 bb->capacity = FLAC__BITBUFFER_DEFAULT_CAPACITY;
201 bb->buffer = (byte*)malloc(sizeof(byte) * bb->capacity);
204 memset(bb->buffer, 0, bb->capacity);
207 memset(bb->buffer, 0, bb->bytes + (bb->bits?1:0));
209 bb->bytes = bb->bits = bb->total_bits = 0;
210 bb->consumed_bytes = bb->consumed_bits = bb->total_consumed_bits = 0;
214 bool FLAC__bitbuffer_clone(FLAC__BitBuffer *dest, const FLAC__BitBuffer *src)
216 if(dest->capacity < src->capacity)
217 if(!bitbuffer_resize_(dest, src->capacity))
219 memcpy(dest->buffer, src->buffer, sizeof(byte)*min(src->capacity, src->bytes+1));
220 dest->bytes = src->bytes;
221 dest->bits = src->bits;
222 dest->total_bits = src->total_bits;
223 dest->consumed_bytes = src->consumed_bytes;
224 dest->consumed_bits = src->consumed_bits;
225 dest->total_consumed_bits = src->total_consumed_bits;
229 bool FLAC__bitbuffer_write_zeroes(FLAC__BitBuffer *bb, unsigned bits)
234 assert(bb->buffer != 0);
238 if(!bitbuffer_ensure_size_(bb, bits))
240 bb->total_bits += bits;
242 n = min(8 - bb->bits, bits);
244 bb->buffer[bb->bytes] <<= n;
255 bool FLAC__bitbuffer_write_raw_uint32(FLAC__BitBuffer *bb, uint32 val, unsigned bits)
257 static uint32 mask[] = {
259 0x00000001, 0x00000003, 0x00000007, 0x0000000F,
260 0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF,
261 0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF,
262 0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF,
263 0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF,
264 0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF,
265 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF,
266 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF
271 assert(bb->buffer != 0);
276 if(!bitbuffer_ensure_size_(bb, bits))
279 bb->total_bits += bits;
282 if(n == 8) { /* i.e. bb->bits == 0 */
284 bb->buffer[bb->bytes] = val;
289 bb->buffer[bb->bytes++] = val;
294 bb->buffer[bb->bytes++] = val >> k;
295 val &= (~(0xffffffff << k));
300 bb->buffer[bb->bytes] <<= bits;
301 bb->buffer[bb->bytes] |= val;
312 bb->buffer[bb->bytes] <<= n;
313 bb->buffer[bb->bytes] |= (val>>k);
314 val &= (~(0xffffffff << k));
324 bool FLAC__bitbuffer_write_raw_int32(FLAC__BitBuffer *bb, int32 val, unsigned bits)
326 return FLAC__bitbuffer_write_raw_uint32(bb, (uint32)val, bits);
329 bool FLAC__bitbuffer_write_raw_uint64(FLAC__BitBuffer *bb, uint64 val, unsigned bits)
331 static uint64 mask[] = {
333 0x0000000000000001, 0x0000000000000003, 0x0000000000000007, 0x000000000000000F,
334 0x000000000000001F, 0x000000000000003F, 0x000000000000007F, 0x00000000000000FF,
335 0x00000000000001FF, 0x00000000000003FF, 0x00000000000007FF, 0x0000000000000FFF,
336 0x0000000000001FFF, 0x0000000000003FFF, 0x0000000000007FFF, 0x000000000000FFFF,
337 0x000000000001FFFF, 0x000000000003FFFF, 0x000000000007FFFF, 0x00000000000FFFFF,
338 0x00000000001FFFFF, 0x00000000003FFFFF, 0x00000000007FFFFF, 0x0000000000FFFFFF,
339 0x0000000001FFFFFF, 0x0000000003FFFFFF, 0x0000000007FFFFFF, 0x000000000FFFFFFF,
340 0x000000001FFFFFFF, 0x000000003FFFFFFF, 0x000000007FFFFFFF, 0x00000000FFFFFFFF,
341 0x00000001FFFFFFFF, 0x00000003FFFFFFFF, 0x00000007FFFFFFFF, 0x0000000FFFFFFFFF,
342 0x0000001FFFFFFFFF, 0x0000003FFFFFFFFF, 0x0000007FFFFFFFFF, 0x000000FFFFFFFFFF,
343 0x000001FFFFFFFFFF, 0x000003FFFFFFFFFF, 0x000007FFFFFFFFFF, 0x00000FFFFFFFFFFF,
344 0x00001FFFFFFFFFFF, 0x00003FFFFFFFFFFF, 0x00007FFFFFFFFFFF, 0x0000FFFFFFFFFFFF,
345 0x0001FFFFFFFFFFFF, 0x0003FFFFFFFFFFFF, 0x0007FFFFFFFFFFFF, 0x000FFFFFFFFFFFFF,
346 0x001FFFFFFFFFFFFF, 0x003FFFFFFFFFFFFF, 0x007FFFFFFFFFFFFF, 0x00FFFFFFFFFFFFFF,
347 0x01FFFFFFFFFFFFFF, 0x03FFFFFFFFFFFFFF, 0x07FFFFFFFFFFFFFF, 0x0FFFFFFFFFFFFFFF,
348 0x1FFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF
353 assert(bb->buffer != 0);
358 if(!bitbuffer_ensure_size_(bb, bits))
361 bb->total_bits += bits;
365 bb->buffer[bb->bytes] = val;
370 bb->buffer[bb->bytes++] = val;
375 bb->buffer[bb->bytes++] = val >> k;
376 val &= (~(0xffffffffffffffff << k));
381 n = min(8 - bb->bits, bits);
383 bb->buffer[bb->bytes] <<= n;
384 bb->buffer[bb->bytes] |= (val>>k);
385 val &= (~(0xffffffffffffffff << k));
398 bool FLAC__bitbuffer_write_raw_int64(FLAC__BitBuffer *bb, int64 val, unsigned bits)
400 return FLAC__bitbuffer_write_raw_uint64(bb, (uint64)val, bits);
403 unsigned FLAC__bitbuffer_rice_bits(int val, unsigned parameter)
407 /* convert signed to unsigned */
410 * (unsigned)(((--val) << 1) - 1);
411 * but without the overflow problem at -MAXINT
413 uval = (unsigned)(((-(++val)) << 1) + 1);
415 uval = (unsigned)(val << 1);
417 msbs = uval >> parameter;
419 return 1 + parameter + msbs;
422 unsigned FLAC__bitbuffer_golomb_bits_signed(int val, unsigned parameter)
424 unsigned bits, msbs, uval;
427 assert(parameter > 0);
429 /* convert signed to unsigned */
432 * (unsigned)(((--val) << 1) - 1);
433 * but without the overflow problem at -MAXINT
435 uval = (unsigned)(((-(++val)) << 1) + 1);
437 uval = (unsigned)(val << 1);
439 k = ilog2_(parameter);
440 if(parameter == 1u<<k) {
449 d = (1 << (k+1)) - parameter;
450 q = uval / parameter;
451 r = uval - (q * parameter);
460 unsigned FLAC__bitbuffer_golomb_bits_unsigned(unsigned uval, unsigned parameter)
465 assert(parameter > 0);
467 k = ilog2_(parameter);
468 if(parameter == 1u<<k) {
477 d = (1 << (k+1)) - parameter;
478 q = uval / parameter;
479 r = uval - (q * parameter);
488 bool FLAC__bitbuffer_write_rice_signed(FLAC__BitBuffer *bb, int val, unsigned parameter)
490 unsigned bits, msbs, uval;
494 assert(bb->buffer != 0);
495 assert(parameter <= 30);
497 /* convert signed to unsigned */
500 * (unsigned)(((--val) << 1) - 1);
501 * but without the overflow problem at -MAXINT
503 uval = (unsigned)(((-(++val)) << 1) + 1);
505 uval = (unsigned)(val << 1);
507 msbs = uval >> parameter;
508 bits = 1 + parameter + msbs;
509 pattern = 1 << parameter; /* the unary end bit */
510 pattern |= (uval & ((1<<parameter)-1)); /* the binary LSBs */
513 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, bits))
517 /* write the unary MSBs */
518 if(!FLAC__bitbuffer_write_zeroes(bb, msbs))
520 /* write the unary end bit and binary LSBs */
521 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, parameter+1))
527 bool FLAC__bitbuffer_write_rice_signed_guarded(FLAC__BitBuffer *bb, int val, unsigned parameter, unsigned max_bits, bool *overflow)
529 unsigned bits, msbs, uval;
533 assert(bb->buffer != 0);
534 assert(parameter <= 30);
538 /* convert signed to unsigned */
541 * (unsigned)(((--val) << 1) - 1);
542 * but without the overflow problem at -MAXINT
544 uval = (unsigned)(((-(++val)) << 1) + 1);
546 uval = (unsigned)(val << 1);
548 msbs = uval >> parameter;
549 bits = 1 + parameter + msbs;
550 pattern = 1 << parameter; /* the unary end bit */
551 pattern |= (uval & ((1<<parameter)-1)); /* the binary LSBs */
554 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, bits))
557 else if(bits > max_bits) {
562 /* write the unary MSBs */
563 if(!FLAC__bitbuffer_write_zeroes(bb, msbs))
565 /* write the unary end bit and binary LSBs */
566 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, parameter+1))
572 bool FLAC__bitbuffer_write_golomb_signed(FLAC__BitBuffer *bb, int val, unsigned parameter)
574 unsigned bits, msbs, uval;
578 assert(bb->buffer != 0);
579 assert(parameter > 0);
581 /* convert signed to unsigned */
584 * (unsigned)(((--val) << 1) - 1);
585 * but without the overflow problem at -MAXINT
587 uval = (unsigned)(((-(++val)) << 1) + 1);
589 uval = (unsigned)(val << 1);
591 k = ilog2_(parameter);
592 if(parameter == 1u<<k) {
599 pattern = 1 << k; /* the unary end bit */
600 pattern |= (uval & ((1u<<k)-1)); /* the binary LSBs */
603 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, bits))
607 /* write the unary MSBs */
608 if(!FLAC__bitbuffer_write_zeroes(bb, msbs))
610 /* write the unary end bit and binary LSBs */
611 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, k+1))
618 d = (1 << (k+1)) - parameter;
619 q = uval / parameter;
620 r = uval - (q * parameter);
621 /* write the unary MSBs */
622 if(!FLAC__bitbuffer_write_zeroes(bb, q))
624 /* write the unary end bit */
625 if(!FLAC__bitbuffer_write_raw_uint32(bb, 1, 1))
627 /* write the binary LSBs */
629 if(!FLAC__bitbuffer_write_raw_uint32(bb, r+d, k+1))
633 if(!FLAC__bitbuffer_write_raw_uint32(bb, r, k))
640 bool FLAC__bitbuffer_write_golomb_unsigned(FLAC__BitBuffer *bb, unsigned uval, unsigned parameter)
646 assert(bb->buffer != 0);
647 assert(parameter > 0);
649 k = ilog2_(parameter);
650 if(parameter == 1u<<k) {
657 pattern = 1 << k; /* the unary end bit */
658 pattern |= (uval & ((1u<<k)-1)); /* the binary LSBs */
661 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, bits))
665 /* write the unary MSBs */
666 if(!FLAC__bitbuffer_write_zeroes(bb, msbs))
668 /* write the unary end bit and binary LSBs */
669 if(!FLAC__bitbuffer_write_raw_uint32(bb, pattern, k+1))
676 d = (1 << (k+1)) - parameter;
677 q = uval / parameter;
678 r = uval - (q * parameter);
679 /* write the unary MSBs */
680 if(!FLAC__bitbuffer_write_zeroes(bb, q))
682 /* write the unary end bit */
683 if(!FLAC__bitbuffer_write_raw_uint32(bb, 1, 1))
685 /* write the binary LSBs */
687 if(!FLAC__bitbuffer_write_raw_uint32(bb, r+d, k+1))
691 if(!FLAC__bitbuffer_write_raw_uint32(bb, r, k))
698 bool FLAC__bitbuffer_write_utf8_uint32(FLAC__BitBuffer *bb, uint32 val)
703 assert(bb->buffer != 0);
705 assert(!(val & 0x80000000)); /* this version only handles 31 bits */
708 return FLAC__bitbuffer_write_raw_uint32(bb, val, 8);
710 else if(val < 0x800) {
711 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xC0 | (val>>6), 8);
712 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (val&0x3F), 8);
714 else if(val < 0x10000) {
715 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xE0 | (val>>12), 8);
716 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>6)&0x3F), 8);
717 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (val&0x3F), 8);
719 else if(val < 0x200000) {
720 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xF0 | (val>>18), 8);
721 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>12)&0x3F), 8);
722 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>6)&0x3F), 8);
723 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (val&0x3F), 8);
725 else if(val < 0x4000000) {
726 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xF8 | (val>>24), 8);
727 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>18)&0x3F), 8);
728 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>12)&0x3F), 8);
729 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>6)&0x3F), 8);
730 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (val&0x3F), 8);
733 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xFC | (val>>30), 8);
734 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>24)&0x3F), 8);
735 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>18)&0x3F), 8);
736 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>12)&0x3F), 8);
737 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | ((val>>6)&0x3F), 8);
738 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (val&0x3F), 8);
744 bool FLAC__bitbuffer_write_utf8_uint64(FLAC__BitBuffer *bb, uint64 val)
749 assert(bb->buffer != 0);
751 assert(!(val & 0xFFFFFFF000000000)); /* this version only handles 36 bits */
754 return FLAC__bitbuffer_write_raw_uint32(bb, (uint32)val, 8);
756 else if(val < 0x800) {
757 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xC0 | (uint32)(val>>6), 8);
758 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)(val&0x3F), 8);
760 else if(val < 0x10000) {
761 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xE0 | (uint32)(val>>12), 8);
762 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>6)&0x3F), 8);
763 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)(val&0x3F), 8);
765 else if(val < 0x200000) {
766 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xF0 | (uint32)(val>>18), 8);
767 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>12)&0x3F), 8);
768 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>6)&0x3F), 8);
769 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)(val&0x3F), 8);
771 else if(val < 0x4000000) {
772 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xF8 | (uint32)(val>>24), 8);
773 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>18)&0x3F), 8);
774 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>12)&0x3F), 8);
775 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>6)&0x3F), 8);
776 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)(val&0x3F), 8);
778 else if(val < 0x80000000) {
779 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xFC | (uint32)(val>>30), 8);
780 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>24)&0x3F), 8);
781 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>18)&0x3F), 8);
782 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>12)&0x3F), 8);
783 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>6)&0x3F), 8);
784 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)(val&0x3F), 8);
787 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0xFE, 8);
788 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>30)&0x3F), 8);
789 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>24)&0x3F), 8);
790 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>18)&0x3F), 8);
791 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>12)&0x3F), 8);
792 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)((val>>6)&0x3F), 8);
793 ok &= FLAC__bitbuffer_write_raw_uint32(bb, 0x80 | (uint32)(val&0x3F), 8);
799 bool FLAC__bitbuffer_zero_pad_to_byte_boundary(FLAC__BitBuffer *bb)
801 /* 0-pad to byte boundary */
803 return FLAC__bitbuffer_write_zeroes(bb, 8 - bb->bits);
808 bool FLAC__bitbuffer_peek_bit(FLAC__BitBuffer *bb, unsigned *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
810 static byte mask[] = { 128, 64, 32, 16, 8, 4, 2, 1 };
812 /* to avoid a drastic speed penalty we don't:
814 assert(bb->buffer != 0);
815 assert(bb->bits == 0);
819 if(bb->total_consumed_bits < bb->total_bits) {
820 *val = (bb->buffer[bb->consumed_bytes] & mask[bb->consumed_bits])? 1 : 0;
824 if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
830 bool FLAC__bitbuffer_read_bit(FLAC__BitBuffer *bb, unsigned *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
832 static byte mask[] = { 128, 64, 32, 16, 8, 4, 2, 1 };
834 /* to avoid a drastic speed penalty we don't:
836 assert(bb->buffer != 0);
837 assert(bb->bits == 0);
841 if(bb->total_consumed_bits < bb->total_bits) {
842 *val = (bb->buffer[bb->consumed_bytes] & mask[bb->consumed_bits])? 1 : 0;
844 if(bb->consumed_bits == 8) {
845 bb->consumed_bytes++;
846 bb->consumed_bits = 0;
848 bb->total_consumed_bits++;
852 if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
858 bool FLAC__bitbuffer_read_bit_to_uint32(FLAC__BitBuffer *bb, uint32 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
860 static byte mask[] = { 128, 64, 32, 16, 8, 4, 2, 1 };
862 /* to avoid a drastic speed penalty we don't:
864 assert(bb->buffer != 0);
865 assert(bb->bits == 0);
869 if(bb->total_consumed_bits < bb->total_bits) {
871 *val |= (bb->buffer[bb->consumed_bytes] & mask[bb->consumed_bits])? 1 : 0;
873 if(bb->consumed_bits == 8) {
874 bb->consumed_bytes++;
875 bb->consumed_bits = 0;
877 bb->total_consumed_bits++;
881 if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
887 bool FLAC__bitbuffer_read_bit_to_uint64(FLAC__BitBuffer *bb, uint64 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
889 static byte mask[] = { 128, 64, 32, 16, 8, 4, 2, 1 };
891 /* to avoid a drastic speed penalty we don't:
893 assert(bb->buffer != 0);
894 assert(bb->bits == 0);
898 if(bb->total_consumed_bits < bb->total_bits) {
900 *val |= (bb->buffer[bb->consumed_bytes] & mask[bb->consumed_bits])? 1 : 0;
902 if(bb->consumed_bits == 8) {
903 bb->consumed_bytes++;
904 bb->consumed_bits = 0;
906 bb->total_consumed_bits++;
910 if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
916 bool FLAC__bitbuffer_read_raw_uint32(FLAC__BitBuffer *bb, uint32 *val, unsigned bits, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
921 assert(bb->buffer != 0);
926 for(i = 0; i < bits; i++) {
927 if(!FLAC__bitbuffer_read_bit_to_uint32(bb, val, read_callback, client_data))
933 bool FLAC__bitbuffer_read_raw_int32(FLAC__BitBuffer *bb, int32 *val, unsigned bits, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
939 assert(bb->buffer != 0);
944 for(i = 0; i < bits; i++) {
945 if(!FLAC__bitbuffer_read_bit_to_uint32(bb, &x, read_callback, client_data))
961 bool FLAC__bitbuffer_read_raw_uint64(FLAC__BitBuffer *bb, uint64 *val, unsigned bits, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
966 assert(bb->buffer != 0);
971 for(i = 0; i < bits; i++) {
972 if(!FLAC__bitbuffer_read_bit_to_uint64(bb, val, read_callback, client_data))
978 bool FLAC__bitbuffer_read_raw_int64(FLAC__BitBuffer *bb, int64 *val, unsigned bits, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
984 assert(bb->buffer != 0);
989 for(i = 0; i < bits; i++) {
990 if(!FLAC__bitbuffer_read_bit_to_uint64(bb, &x, read_callback, client_data))
1006 bool FLAC__bitbuffer_read_rice_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1008 uint32 lsbs, msbs = 0;
1012 assert(bb->buffer != 0);
1013 assert(parameter <= 32);
1015 /* read the unary MSBs and end bit */
1017 if(!FLAC__bitbuffer_read_bit(bb, &bit, read_callback, client_data))
1024 /* read the binary LSBs */
1025 if(!FLAC__bitbuffer_read_raw_uint32(bb, &lsbs, parameter, read_callback, client_data))
1027 /* compose the value */
1028 uval = (msbs << parameter) | lsbs;
1030 *val = -((int)(uval >> 1)) - 1;
1032 *val = (int)(uval >> 1);
1037 bool FLAC__bitbuffer_read_golomb_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1039 uint32 lsbs, msbs = 0;
1040 unsigned bit, uval, k;
1043 assert(bb->buffer != 0);
1045 k = ilog2_(parameter);
1047 /* read the unary MSBs and end bit */
1049 if(!FLAC__bitbuffer_read_bit(bb, &bit, read_callback, client_data))
1056 /* read the binary LSBs */
1057 if(!FLAC__bitbuffer_read_raw_uint32(bb, &lsbs, k, read_callback, client_data))
1060 if(parameter == 1u<<k) {
1061 /* compose the value */
1062 uval = (msbs << k) | lsbs;
1065 unsigned d = (1 << (k+1)) - parameter;
1067 if(!FLAC__bitbuffer_read_bit(bb, &bit, read_callback, client_data))
1073 /* compose the value */
1074 uval = msbs * parameter + lsbs;
1077 /* unfold unsigned to signed */
1079 *val = -((int)(uval >> 1)) - 1;
1081 *val = (int)(uval >> 1);
1086 bool FLAC__bitbuffer_read_golomb_unsigned(FLAC__BitBuffer *bb, unsigned *val, unsigned parameter, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data)
1088 uint32 lsbs, msbs = 0;
1092 assert(bb->buffer != 0);
1094 k = ilog2_(parameter);
1096 /* read the unary MSBs and end bit */
1098 if(!FLAC__bitbuffer_read_bit(bb, &bit, read_callback, client_data))
1105 /* read the binary LSBs */
1106 if(!FLAC__bitbuffer_read_raw_uint32(bb, &lsbs, k, read_callback, client_data))
1109 if(parameter == 1u<<k) {
1110 /* compose the value */
1111 *val = (msbs << k) | lsbs;
1114 unsigned d = (1 << (k+1)) - parameter;
1116 if(!FLAC__bitbuffer_read_bit(bb, &bit, read_callback, client_data))
1122 /* compose the value */
1123 *val = msbs * parameter + lsbs;
1129 /* on return, if *val == 0xffffffff then the utf-8 sequence was invalid, but the return value will be true */
1130 bool FLAC__bitbuffer_read_utf8_uint32(FLAC__BitBuffer *bb, uint32 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data, byte *raw, unsigned *rawlen)
1136 if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, 8, read_callback, client_data))
1139 raw[(*rawlen)++] = (byte)x;
1140 if(!(x & 0x80)) { /* 0xxxxxxx */
1144 else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
1148 else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
1152 else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
1156 else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
1160 else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
1167 if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, 8, read_callback, client_data))
1170 raw[(*rawlen)++] = (byte)x;
1171 if(!(x & 0x80) || (x & 0x40)) /* 10xxxxxx */
1183 /* on return, if *val == 0xffffffffffffffff then the utf-8 sequence was invalid, but the return value will be true */
1184 bool FLAC__bitbuffer_read_utf8_uint64(FLAC__BitBuffer *bb, uint64 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data, byte *raw, unsigned *rawlen)
1190 if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, 8, read_callback, client_data))
1193 raw[(*rawlen)++] = (byte)x;
1194 if(!(x & 0x80)) { /* 0xxxxxxx */
1198 else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
1202 else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
1206 else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
1210 else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
1214 else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
1218 else if(x & 0xFE && !(x & 0x01)) { /* 11111110 */
1225 if(!FLAC__bitbuffer_read_raw_uint32(bb, &x, 8, read_callback, client_data))
1228 raw[(*rawlen)++] = (byte)x;
1229 if(!(x & 0x80) || (x & 0x40)) /* 10xxxxxx */
1241 void FLAC__bitbuffer_dump(const FLAC__BitBuffer *bb, FILE *out)
1245 fprintf(out, "bitbuffer is NULL\n");
1248 fprintf(out, "bitbuffer: capacity=%u bytes=%u bits=%u total_bits=%u consumed: bytes=%u, bits=%u, total_bits=%u\n", bb->capacity, bb->bytes, bb->bits, bb->total_bits, bb->consumed_bytes, bb->consumed_bits, bb->total_consumed_bits);
1249 for(i = 0; i < bb->bytes; i++) {
1250 fprintf(out, "%08X: ", i);
1251 for(j = 0; j < 8; j++)
1252 if(i*8+j < bb->total_consumed_bits)
1255 fprintf(out, "%01u", bb->buffer[i] & (1 << (8-j-1)) ? 1:0);
1259 fprintf(out, "%08X: ", i);
1260 for(j = 0; j < bb->bits; j++)
1261 if(i*8+j < bb->total_consumed_bits)
1264 fprintf(out, "%01u", bb->buffer[i] & (1 << (bb->bits-j-1)) ? 1:0);