src/libFLAC/bitbuffer.c

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