text: /* libFLAC - Free Lossless Audio Codec library
   * Copyright (C) 2000-2009  Josh Coalson
   * Copyright (C) 2011-2014  Xiph.Org Foundation
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * - Redistributions of source code must retain the above copyright
   * notice, this list of conditions and the following disclaimer.
   *
   * - Redistributions in binary form must reproduce the above copyright
   * notice, this list of conditions and the following disclaimer in the
   * documentation and/or other materials provided with the distribution.
   *
   * - Neither the name of the Xiph.org Foundation nor the names of its
   * contributors may be used to endorse or promote products derived from
   * this software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
   * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  
  #ifdef HAVE_CONFIG_H
  #  include <config.h>
  #endif
  
  #include <stdlib.h>
  #include <string.h>
  #include "include/private/bitmath.h"
  #include "include/private/bitreader.h"
  #include "include/private/crc.h"
  #include "../assert.h"
  #include "../compat.h"
  #include "../endswap.h"
  
  /* Things should be fastest when this matches the machine word size */
  /* WATCHOUT: if you change this you must also change the following #defines down to FLAC__clz_uint32 below to match */
  /* WATCHOUT: there are a few places where the code will not work unless uint32_t is >= 32 bits wide */
  /*           also, some sections currently only have fast versions for 4 or 8 bytes per word */
  #define FLAC__BYTES_PER_WORD 4		/* sizeof uint32_t */
  #define FLAC__BITS_PER_WORD (8 * FLAC__BYTES_PER_WORD)
  #define FLAC__WORD_ALL_ONES ((FLAC__uint32)0xffffffff)
  /* SWAP_BE_WORD_TO_HOST swaps bytes in a uint32_t (which is always big-endian) if necessary to match host byte order */
  #if WORDS_BIGENDIAN
  #define SWAP_BE_WORD_TO_HOST(x) (x)
  #else
  #define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_32(x)
  #endif
  
  /*
   * This should be at least twice as large as the largest number of words
   * required to represent any 'number' (in any encoding) you are going to
   * read.  With FLAC this is on the order of maybe a few hundred bits.
   * If the buffer is smaller than that, the decoder won't be able to read
   * in a whole number that is in a variable length encoding (e.g. Rice).
   * But to be practical it should be at least 1K bytes.
   *
   * Increase this number to decrease the number of read callbacks, at the
   * expense of using more memory.  Or decrease for the reverse effect,
   * keeping in mind the limit from the first paragraph.  The optimal size
   * also depends on the CPU cache size and other factors; some twiddling
   * may be necessary to squeeze out the best performance.
   */
  static const unsigned FLAC__BITREADER_DEFAULT_CAPACITY = 65536u / FLAC__BITS_PER_WORD; /* in words */
  
  struct FLAC__BitReader {
  	/* any partially-consumed word at the head will stay right-justified as bits are consumed from the left */
  	/* any incomplete word at the tail will be left-justified, and bytes from the read callback are added on the right */
  	uint32_t *buffer;
  	unsigned capacity; /* in words */
  	unsigned words; /* # of completed words in buffer */
  	unsigned bytes; /* # of bytes in incomplete word at buffer[words] */
  	unsigned consumed_words; /* #words ... */
  	unsigned consumed_bits; /* ... + (#bits of head word) already consumed from the front of buffer */
  	unsigned read_crc16; /* the running frame CRC */
  	unsigned crc16_align; /* the number of bits in the current consumed word that should not be CRC'd */
  	FLAC__BitReaderReadCallback read_callback;
  	void *client_data;
  };
  
  static inline void crc16_update_word_(FLAC__BitReader *br, uint32_t word)
  {
  	unsigned crc = br->read_crc16;
  #if FLAC__BYTES_PER_WORD == 4
  	switch(br->crc16_align) {
  		case  0: crc = FLAC__CRC16_UPDATE((unsigned)(word >> 24), crc);
  		case  8: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 16) & 0xff), crc);
  		case 16: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 8) & 0xff), crc);
  		case 24: br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)(word & 0xff), crc);
  	}
  #elif FLAC__BYTES_PER_WORD == 8
  	switch(br->crc16_align) {
  		case  0: crc = FLAC__CRC16_UPDATE((unsigned)(word >> 56), crc);
  		case  8: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 48) & 0xff), crc);
  		case 16: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 40) & 0xff), crc);
  		case 24: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 32) & 0xff), crc);
  		case 32: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 24) & 0xff), crc);
  		case 40: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 16) & 0xff), crc);
  		case 48: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 8) & 0xff), crc);
  		case 56: br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)(word & 0xff), crc);
  	}
  #else
  	for( ; br->crc16_align < FLAC__BITS_PER_WORD; br->crc16_align += 8)
  		crc = FLAC__CRC16_UPDATE((unsigned)((word >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), crc);
  	br->read_crc16 = crc;
  #endif
  	br->crc16_align = 0;
  }
  
  static FLAC__bool bitreader_read_from_client_(FLAC__BitReader *br)
  {
  	unsigned start, end;
  	size_t bytes;
  	FLAC__byte *target;
  
  	/* first shift the unconsumed buffer data toward the front as much as possible */
  	if(br->consumed_words > 0) {
  		start = br->consumed_words;
  		end = br->words + (br->bytes? 1:0);
  		memmove(br->buffer, br->buffer+start, FLAC__BYTES_PER_WORD * (end - start));
  
  		br->words -= start;
  		br->consumed_words = 0;
  	}
  
  	/*
  	 * set the target for reading, taking into account word alignment and endianness
  	 */
  	bytes = (br->capacity - br->words) * FLAC__BYTES_PER_WORD - br->bytes;
  	if(bytes == 0)
  		return false; /* no space left, buffer is too small; see note for FLAC__BITREADER_DEFAULT_CAPACITY  */
  	target = ((FLAC__byte*)(br->buffer+br->words)) + br->bytes;
  
  	/* before reading, if the existing reader looks like this (say uint32_t is 32 bits wide)
  	 *   bitstream :  11 22 33 44 55            br->words=1 br->bytes=1 (partial tail word is left-justified)
  	 *   buffer[BE]:  11 22 33 44 55 ?? ?? ??   (shown layed out as bytes sequentially in memory)
  	 *   buffer[LE]:  44 33 22 11 ?? ?? ?? 55   (?? being don't-care)
  	 *                               ^^-------target, bytes=3
  	 * on LE machines, have to byteswap the odd tail word so nothing is
  	 * overwritten:
  	 */
  #if WORDS_BIGENDIAN
  #else
  	if(br->bytes)
  		br->buffer[br->words] = SWAP_BE_WORD_TO_HOST(br->buffer[br->words]);
  #endif
  
  	/* now it looks like:
  	 *   bitstream :  11 22 33 44 55            br->words=1 br->bytes=1
  	 *   buffer[BE]:  11 22 33 44 55 ?? ?? ??
  	 *   buffer[LE]:  44 33 22 11 55 ?? ?? ??
  	 *                               ^^-------target, bytes=3
  	 */
  
  	/* read in the data; note that the callback may return a smaller number of bytes */
  	if(!br->read_callback(target, &bytes, br->client_data))
  		return false;
  
  	/* after reading bytes 66 77 88 99 AA BB CC DD EE FF from the client:
  	 *   bitstream :  11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF
  	 *   buffer[BE]:  11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??
  	 *   buffer[LE]:  44 33 22 11 55 66 77 88 99 AA BB CC DD EE FF ??
  	 * now have to byteswap on LE machines:
  	 */
  #if WORDS_BIGENDIAN
  #else
  	end = (br->words*FLAC__BYTES_PER_WORD + br->bytes + bytes + (FLAC__BYTES_PER_WORD-1)) / FLAC__BYTES_PER_WORD;
  	for(start = br->words; start < end; start++)
  		br->buffer[start] = SWAP_BE_WORD_TO_HOST(br->buffer[start]);
  #endif
  
  	/* now it looks like:
  	 *   bitstream :  11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF
  	 *   buffer[BE]:  11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??
  	 *   buffer[LE]:  44 33 22 11 88 77 66 55 CC BB AA 99 ?? FF EE DD
  	 * finally we'll update the reader values:
  	 */
  	end = br->words*FLAC__BYTES_PER_WORD + br->bytes + bytes;
  	br->words = end / FLAC__BYTES_PER_WORD;
  	br->bytes = end % FLAC__BYTES_PER_WORD;
  
  	return true;
  }
  
  /***********************************************************************
   *
   * Class constructor/destructor
   *
   ***********************************************************************/
  
  FLAC__BitReader *FLAC__bitreader_new(void)
  {
  	FLAC__BitReader *br = (FLAC__BitReader*) calloc(1, sizeof(FLAC__BitReader));
  
  	/* calloc() implies:
  		memset(br, 0, sizeof(FLAC__BitReader));
  		br->buffer = 0;
  		br->capacity = 0;
  		br->words = br->bytes = 0;
  		br->consumed_words = br->consumed_bits = 0;
  		br->read_callback = 0;
  		br->client_data = 0;
  	*/
  	return br;
  }
  
  void FLAC__bitreader_delete(FLAC__BitReader *br)
  {
  	FLAC__ASSERT(0 != br);
  
  	FLAC__bitreader_free(br);
  	free(br);
  }
  
  /***********************************************************************
   *
   * Public class methods
   *
   ***********************************************************************/
  
  FLAC__bool FLAC__bitreader_init(FLAC__BitReader *br, FLAC__BitReaderReadCallback rcb, void *cd)
  {
  	FLAC__ASSERT(0 != br);
  
  	br->words = br->bytes = 0;
  	br->consumed_words = br->consumed_bits = 0;
  	br->capacity = FLAC__BITREADER_DEFAULT_CAPACITY;
  	br->buffer = (uint32_t*) malloc(sizeof(uint32_t) * br->capacity);
  	if(br->buffer == 0)
  		return false;
  	br->read_callback = rcb;
  	br->client_data = cd;
  
  	return true;
  }
  
  void FLAC__bitreader_free(FLAC__BitReader *br)
  {
  	FLAC__ASSERT(0 != br);
  
  	if(0 != br->buffer)
  		free(br->buffer);
  	br->buffer = 0;
  	br->capacity = 0;
  	br->words = br->bytes = 0;
  	br->consumed_words = br->consumed_bits = 0;
  	br->read_callback = 0;
  	br->client_data = 0;
  }
  
  FLAC__bool FLAC__bitreader_clear(FLAC__BitReader *br)
  {
  	br->words = br->bytes = 0;
  	br->consumed_words = br->consumed_bits = 0;
  	return true;
  }
  
  void FLAC__bitreader_dump(const FLAC__BitReader *br, FILE *out)
  {
  	unsigned i, j;
  	if(br == 0) {
  		fprintf(out, "bitreader is NULL\n");
  	}
  	else {
  		fprintf(out, "bitreader: capacity=%u words=%u bytes=%u consumed: words=%u, bits=%u\n", br->capacity, br->words, br->bytes, br->consumed_words, br->consumed_bits);
  
  		for(i = 0; i < br->words; i++) {
  			fprintf(out, "%08X: ", i);
  			for(j = 0; j < FLAC__BITS_PER_WORD; j++)
  				if(i < br->consumed_words || (i == br->consumed_words && j < br->consumed_bits))
  					fprintf(out, ".");
  				else
  					fprintf(out, "%01u", br->buffer[i] & (1 << (FLAC__BITS_PER_WORD-j-1)) ? 1:0);
  			fprintf(out, "\n");
  		}
  		if(br->bytes > 0) {
  			fprintf(out, "%08X: ", i);
  			for(j = 0; j < br->bytes*8; j++)
  				if(i < br->consumed_words || (i == br->consumed_words && j < br->consumed_bits))
  					fprintf(out, ".");
  				else
  					fprintf(out, "%01u", br->buffer[i] & (1 << (br->bytes*8-j-1)) ? 1:0);
  			fprintf(out, "\n");
  		}
  	}
  }
  
  void FLAC__bitreader_reset_read_crc16(FLAC__BitReader *br, FLAC__uint16 seed)
  {
  	FLAC__ASSERT(0 != br);
  	FLAC__ASSERT(0 != br->buffer);
  	FLAC__ASSERT((br->consumed_bits & 7) == 0);
  
  	br->read_crc16 = (unsigned)seed;
  	br->crc16_align = br->consumed_bits;
  }
  
  FLAC__uint16 FLAC__bitreader_get_read_crc16(FLAC__BitReader *br)
  {
  	FLAC__ASSERT(0 != br);
  	FLAC__ASSERT(0 != br->buffer);
  	FLAC__ASSERT((br->consumed_bits & 7) == 0);
  	FLAC__ASSERT(br->crc16_align <= br->consumed_bits);
  
  	/* CRC any tail bytes in a partially-consumed word */
  	if(br->consumed_bits) {
  		const uint32_t tail = br->buffer[br->consumed_words];
  		for( ; br->crc16_align < br->consumed_bits; br->crc16_align += 8)
  			br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)((tail >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), br->read_crc16);
  	}
  	return br->read_crc16;
  }
  
  inline FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br)
  {
  	return ((br->consumed_bits & 7) == 0);
  }
  
  inline unsigned FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br)
  {
  	return 8 - (br->consumed_bits & 7);
  }
  
  inline unsigned FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br)
  {
  	return (br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits;
  }
  
  FLAC__bool FLAC__bitreader_read_raw_uint32(FLAC__BitReader *br, FLAC__uint32 *val, unsigned bits)
  {
  	FLAC__ASSERT(0 != br);
  	FLAC__ASSERT(0 != br->buffer);
  
  	FLAC__ASSERT(bits <= 32);
  	FLAC__ASSERT((br->capacity*FLAC__BITS_PER_WORD) * 2 >= bits);
  	FLAC__ASSERT(br->consumed_words <= br->words);
  
  	/* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
  	FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
  
  	if(bits == 0) { /* OPT: investigate if this can ever happen, maybe change to assertion */
  		*val = 0;
  		return true;
  	}
  
  	while((br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits < bits) {
  		if(!bitreader_read_from_client_(br))
  			return false;
  	}
  	if(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */
  		/* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */
  		if(br->consumed_bits) {
  			/* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
  			const unsigned n = FLAC__BITS_PER_WORD - br->consumed_bits;
  			const uint32_t word = br->buffer[br->consumed_words];
  			if(bits < n) {
  				*val = (word & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (n-bits);
  				br->consumed_bits += bits;
  				return true;
  			}
  			*val = word & (FLAC__WORD_ALL_ONES >> br->consumed_bits);
  			bits -= n;
  			crc16_update_word_(br, word);
  			br->consumed_words++;
  			br->consumed_bits = 0;
  			if(bits) { /* if there are still bits left to read, there have to be less than 32 so they will all be in the next word */
  				*val <<= bits;
  				*val |= (br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits));
  				br->consumed_bits = bits;
  			}
  			return true;
  		}
  		else {
  			const uint32_t word = br->buffer[br->consumed_words];
  			if(bits < FLAC__BITS_PER_WORD) {
  				*val = word >> (FLAC__BITS_PER_WORD-bits);
  				br->consumed_bits = bits;
  				return true;
  			}
  			/* at this point 'bits' must be == FLAC__BITS_PER_WORD; because of previous assertions, it can't be larger */
  			*val = word;
  			crc16_update_word_(br, word);
  			br->consumed_words++;
  			return true;
  		}
  	}
  	else {
  		/* in this case we're starting our read at a partial tail word;
  		 * the reader has guaranteed that we have at least 'bits' bits
  		 * available to read, which makes this case simpler.
  		 */
  		/* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */
  		if(br->consumed_bits) {
  			/* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
  			FLAC__ASSERT(br->consumed_bits + bits <= br->bytes*8);
  			*val = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (FLAC__BITS_PER_WORD-br->consumed_bits-bits);
  			br->consumed_bits += bits;
  			return true;
  		}
  		else {
  			*val = br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits);
  			br->consumed_bits += bits;
  			return true;
  		}
  	}
  }
  
  FLAC__bool FLAC__bitreader_read_raw_int32(FLAC__BitReader *br, FLAC__int32 *val, unsigned bits)
  {
  	/* OPT: inline raw uint32 code here, or make into a macro if possible in the .h file */
  	if(!FLAC__bitreader_read_raw_uint32(br, (FLAC__uint32*)val, bits))
  		return false;
  	/* sign-extend: */
  	*val <<= (32-bits);
  	*val >>= (32-bits);
  	return true;
  }
  
  FLAC__bool FLAC__bitreader_read_raw_uint64(FLAC__BitReader *br, FLAC__uint64 *val, unsigned bits)
  {
  	FLAC__uint32 hi, lo;
  
  	if(bits > 32) {
  		if(!FLAC__bitreader_read_raw_uint32(br, &hi, bits-32))
  			return false;
  		if(!FLAC__bitreader_read_raw_uint32(br, &lo, 32))
  			return false;
  		*val = hi;
  		*val <<= 32;
  		*val |= lo;
  	}
  	else {
  		if(!FLAC__bitreader_read_raw_uint32(br, &lo, bits))
  			return false;
  		*val = lo;
  	}
  	return true;
  }
  
  inline FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val)
  {
  	FLAC__uint32 x8, x32 = 0;
  
  	/* this doesn't need to be that fast as currently it is only used for vorbis comments */
  
  	if(!FLAC__bitreader_read_raw_uint32(br, &x32, 8))
  		return false;
  
  	if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
  		return false;
  	x32 |= (x8 << 8);
  
  	if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
  		return false;
  	x32 |= (x8 << 16);
  
  	if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
  		return false;
  	x32 |= (x8 << 24);
  
  	*val = x32;
  	return true;
  }
  
  FLAC__bool FLAC__bitreader_skip_bits_no_crc(FLAC__BitReader *br, unsigned bits)
  {
  	/*
  	 * OPT: a faster implementation is possible but probably not that useful
  	 * since this is only called a couple of times in the metadata readers.
  	 */
  	FLAC__ASSERT(0 != br);
  	FLAC__ASSERT(0 != br->buffer);
  
  	if(bits > 0) {
  		const unsigned n = br->consumed_bits & 7;
  		unsigned m;
  		FLAC__uint32 x;
  
  		if(n != 0) {
  			m = flac_min(8-n, bits);
  			if(!FLAC__bitreader_read_raw_uint32(br, &x, m))
  				return false;
  			bits -= m;
  		}
  		m = bits / 8;
  		if(m > 0) {
  			if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(br, m))
  				return false;
  			bits %= 8;
  		}
  		if(bits > 0) {
  			if(!FLAC__bitreader_read_raw_uint32(br, &x, bits))
  				return false;
  		}
  	}
  
  	return true;
  }
  
  FLAC__bool FLAC__bitreader_skip_byte_block_aligned_no_crc(FLAC__BitReader *br, unsigned nvals)
  {
  	FLAC__uint32 x;
  
  	FLAC__ASSERT(0 != br);
  	FLAC__ASSERT(0 != br->buffer);
  	FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
  
  	/* step 1: skip over partial head word to get word aligned */
  	while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
  		if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
  			return false;
  		nvals--;
  	}
  	if(0 == nvals)
  		return true;
  	/* step 2: skip whole words in chunks */
  	while(nvals >= FLAC__BYTES_PER_WORD) {
  		if(br->consumed_words < br->words) {
  			br->consumed_words++;
  			nvals -= FLAC__BYTES_PER_WORD;
  		}
  		else if(!bitreader_read_from_client_(br))
  			return false;
  	}
  	/* step 3: skip any remainder from partial tail bytes */
  	while(nvals) {
  		if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
  			return false;
  		nvals--;
  	}
  
  	return true;
  }
  
  FLAC__bool FLAC__bitreader_read_byte_block_aligned_no_crc(FLAC__BitReader *br, FLAC__byte *val, unsigned nvals)
  {
  	FLAC__uint32 x;
  
  	FLAC__ASSERT(0 != br);
  	FLAC__ASSERT(0 != br->buffer);
  	FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
  
  	/* step 1: read from partial head word to get word aligned */
  	while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
  		if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
  			return false;
  		*val++ = (FLAC__byte)x;
  		nvals--;
  	}
  	if(0 == nvals)
  		return true;
  	/* step 2: read whole words in chunks */
  	while(nvals >= FLAC__BYTES_PER_WORD) {
  		if(br->consumed_words < br->words) {
  			const uint32_t word = br->buffer[br->consumed_words++];
  #if FLAC__BYTES_PER_WORD == 4
  			val[0] = (FLAC__byte)(word >> 24);
  			val[1] = (FLAC__byte)(word >> 16);
  			val[2] = (FLAC__byte)(word >> 8);
  			val[3] = (FLAC__byte)word;
  #elif FLAC__BYTES_PER_WORD == 8
  			val[0] = (FLAC__byte)(word >> 56);
  			val[1] = (FLAC__byte)(word >> 48);
  			val[2] = (FLAC__byte)(word >> 40);
  			val[3] = (FLAC__byte)(word >> 32);
  			val[4] = (FLAC__byte)(word >> 24);
  			val[5] = (FLAC__byte)(word >> 16);
  			val[6] = (FLAC__byte)(word >> 8);
  			val[7] = (FLAC__byte)word;
  #else
  			for(x = 0; x < FLAC__BYTES_PER_WORD; x++)
  				val[x] = (FLAC__byte)(word >> (8*(FLAC__BYTES_PER_WORD-x-1)));
  #endif
  			val += FLAC__BYTES_PER_WORD;
  			nvals -= FLAC__BYTES_PER_WORD;
  		}
  		else if(!bitreader_read_from_client_(br))
  			return false;
  	}
  	/* step 3: read any remainder from partial tail bytes */
  	while(nvals) {
  		if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
  			return false;
  		*val++ = (FLAC__byte)x;
  		nvals--;
  	}
  
  	return true;
  }
  
  FLAC__bool FLAC__bitreader_read_unary_unsigned(FLAC__BitReader *br, unsigned *val)
  #if 0 /* slow but readable version */
  {
  	unsigned bit;
  
  	FLAC__ASSERT(0 != br);
  	FLAC__ASSERT(0 != br->buffer);
  
  	*val = 0;
  	while(1) {
  		if(!FLAC__bitreader_read_bit(br, &bit))
  			return false;
  		if(bit)
  			break;
  		else
  			*val++;
  	}
  	return true;
  }
  #else
  {
  	unsigned i;
  
  	FLAC__ASSERT(0 != br);
  	FLAC__ASSERT(0 != br->buffer);
  
  	*val = 0;
  	while(1) {
  		while(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */
  			uint32_t b = br->buffer[br->consumed_words] << br->consumed_bits;
  			if(b) {
  				i = FLAC__clz_uint32(b);
  				*val += i;
  				i++;
  				br->consumed_bits += i;
  				if(br->consumed_bits >= FLAC__BITS_PER_WORD) { /* faster way of testing if(br->consumed_bits == FLAC__BITS_PER_WORD) */
  					crc16_update_word_(br, br->buffer[br->consumed_words]);
  					br->consumed_words++;
  					br->consumed_bits = 0;
  				}
  				return true;
  			}
  			else {
  				*val += FLAC__BITS_PER_WORD - br->consumed_bits;
  				crc16_update_word_(br, br->buffer[br->consumed_words]);
  				br->consumed_words++;
  				br->consumed_bits = 0;
  				/* didn't find stop bit yet, have to keep going... */
  			}
  		}
  		/* at this point we've eaten up all the whole words; have to try
  		 * reading through any tail bytes before calling the read callback.
  		 * this is a repeat of the above logic adjusted for the fact we
  		 * don't have a whole word.  note though if the client is feeding
  		 * us data a byte at a time (unlikely), br->consumed_bits may not
  		 * be zero.
  		 */
  		if(br->bytes*8 > br->consumed_bits) {
  			const unsigned end = br->bytes * 8;
  			uint32_t b = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << br->consumed_bits;
  			if(b) {
  				i = FLAC__clz_uint32(b);
  				*val += i;
  				i++;
  				br->consumed_bits += i;
  				FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);
  				return true;
  			}
  			else {
  				*val += end - br->consumed_bits;
  				br->consumed_bits = end;
  				FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);
  				/* didn't find stop bit yet, have to keep going... */
  			}
  		}
  		if(!bitreader_read_from_client_(br))
  			return false;
  	}
  }
  #endif
  
  FLAC__bool FLAC__bitreader_read_rice_signed(FLAC__BitReader *br, int *val, unsigned parameter)
  {
  	FLAC__uint32 lsbs = 0, msbs = 0;
  	unsigned uval;
  
  	FLAC__ASSERT(0 != br);
  	FLAC__ASSERT(0 != br->buffer);
  	FLAC__ASSERT(parameter <= 31);
  
  	/* read the unary MSBs and end bit */
  	if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
  		return false;
  
  	/* read the binary LSBs */
  	if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, parameter))
  		return false;
  
  	/* compose the value */
  	uval = (msbs << parameter) | lsbs;
  	if(uval & 1)
  		*val = -((int)(uval >> 1)) - 1;
  	else
  		*val = (int)(uval >> 1);
  
  	return true;
  }
  
  /* this is by far the most heavily used reader call.  it ain't pretty but it's fast */
  FLAC__bool FLAC__bitreader_read_rice_signed_block(FLAC__BitReader *br, int vals[], unsigned nvals, unsigned parameter)
  {
  	/* try and get br->consumed_words and br->consumed_bits into register;
  	 * must remember to flush them back to *br before calling other
  	 * bitreader functions that use them, and before returning */
  	unsigned cwords, words, lsbs, msbs, x, y;
  	unsigned ucbits; /* keep track of the number of unconsumed bits in word */
  	uint32_t b;
  	int *val, *end;
  
  	FLAC__ASSERT(0 != br);
  	FLAC__ASSERT(0 != br->buffer);
  	/* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
  	FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
  	FLAC__ASSERT(parameter < 32);
  	/* the above two asserts also guarantee that the binary part never straddles more than 2 words, so we don't have to loop to read it */
  
  	val = vals;
  	end = vals + nvals;
  
  	if(parameter == 0) {
  		while(val < end) {
  			/* read the unary MSBs and end bit */
  			if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
  				return false;
  
  			*val++ = (int)(msbs >> 1) ^ -(int)(msbs & 1);
  		}
  
  		return true;
  	}
  
  	FLAC__ASSERT(parameter > 0);
  
  	cwords = br->consumed_words;
  	words = br->words;
  
  	/* if we've not consumed up to a partial tail word... */
  	if(cwords >= words) {
  		x = 0;
  		goto process_tail;
  	}
  
  	ucbits = FLAC__BITS_PER_WORD - br->consumed_bits;
  	b = br->buffer[cwords] << br->consumed_bits;  /* keep unconsumed bits aligned to left */
  
  	while(val < end) {
  		/* read the unary MSBs and end bit */
  		x = y = FLAC__clz2_uint32(b);
  		if(x == FLAC__BITS_PER_WORD) {
  			x = ucbits;
  			do {
  				/* didn't find stop bit yet, have to keep going... */
  				crc16_update_word_(br, br->buffer[cwords++]);
  				if (cwords >= words)
  					goto incomplete_msbs;
  				b = br->buffer[cwords];
  				y = FLAC__clz2_uint32(b);
  				x += y;
  			} while(y == FLAC__BITS_PER_WORD);
  		}
  		b <<= y;
  		b <<= 1; /* account for stop bit */
  		ucbits = (ucbits - x - 1) % FLAC__BITS_PER_WORD;
  		msbs = x;
  
  		/* read the binary LSBs */
  		x = b >> (FLAC__BITS_PER_WORD - parameter);
  		if(parameter <= ucbits) {
  			ucbits -= parameter;
  			b <<= parameter;
  		} else {
  			/* there are still bits left to read, they will all be in the next word */
  			crc16_update_word_(br, br->buffer[cwords++]);
  			if (cwords >= words)
  				goto incomplete_lsbs;
  			b = br->buffer[cwords];
  			ucbits += FLAC__BITS_PER_WORD - parameter;
  			x |= b >> ucbits;
  			b <<= FLAC__BITS_PER_WORD - ucbits;
  		}
  		lsbs = x;
  
  		/* compose the value */
  		x = (msbs << parameter) | lsbs;
  		*val++ = (int)(x >> 1) ^ -(int)(x & 1);
  
  		continue;
  
  		/* at this point we've eaten up all the whole words */
  process_tail:
  		do {
  			if(0) {
  incomplete_msbs:
  				br->consumed_bits = 0;
  				br->consumed_words = cwords;
  			}
  
  			/* read the unary MSBs and end bit */
  			if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
  				return false;
  			msbs += x;
  			x = ucbits = 0;
  
  			if(0) {
  incomplete_lsbs:
  				br->consumed_bits = 0;
  				br->consumed_words = cwords;
  			}
  
  			/* read the binary LSBs */
  			if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, parameter - ucbits))
  				return false;
  			lsbs = x | lsbs;
  
  			/* compose the value */
  			x = (msbs << parameter) | lsbs;
  			*val++ = (int)(x >> 1) ^ -(int)(x & 1);
  			x = 0;
  
  			cwords = br->consumed_words;
  			words = br->words;
  			ucbits = FLAC__BITS_PER_WORD - br->consumed_bits;
  			b = br->buffer[cwords] << br->consumed_bits;
  		} while(cwords >= words && val < end);
  	}
  
  	if(ucbits == 0 && cwords < words) {
  		/* don't leave the head word with no unconsumed bits */
  		crc16_update_word_(br, br->buffer[cwords++]);
  		ucbits = FLAC__BITS_PER_WORD;
  	}
  
  	br->consumed_bits = FLAC__BITS_PER_WORD - ucbits;
  	br->consumed_words = cwords;
  
  	return true;
  }
  
  #if 0 /* UNUSED */
  FLAC__bool FLAC__bitreader_read_golomb_signed(FLAC__BitReader *br, int *val, unsigned parameter)
  {
  	FLAC__uint32 lsbs = 0, msbs = 0;
  	unsigned bit, uval, k;
  
  	FLAC__ASSERT(0 != br);
  	FLAC__ASSERT(0 != br->buffer);
  
  	k = FLAC__bitmath_ilog2(parameter);
  
  	/* read the unary MSBs and end bit */
  	if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
  		return false;
  
  	/* read the binary LSBs */
  	if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))
  		return false;
  
  	if(parameter == 1u<<k) {
  		/* compose the value */
  		uval = (msbs << k) | lsbs;
  	}
  	else {
  		unsigned d = (1 << (k+1)) - parameter;
  		if(lsbs >= d) {
  			if(!FLAC__bitreader_read_bit(br, &bit))
  				return false;
  			lsbs <<= 1;
  			lsbs |= bit;
  			lsbs -= d;
  		}
  		/* compose the value */
  		uval = msbs * parameter + lsbs;
  	}
  
  	/* unfold unsigned to signed */
  	if(uval & 1)
  		*val = -((int)(uval >> 1)) - 1;
  	else
  		*val = (int)(uval >> 1);
  
  	return true;
  }
  
  FLAC__bool FLAC__bitreader_read_golomb_unsigned(FLAC__BitReader *br, unsigned *val, unsigned parameter)
  {
  	FLAC__uint32 lsbs, msbs = 0;
  	unsigned bit, k;
  
  	FLAC__ASSERT(0 != br);
  	FLAC__ASSERT(0 != br->buffer);
  
  	k = FLAC__bitmath_ilog2(parameter);
  
  	/* read the unary MSBs and end bit */
  	if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
  		return false;
  
  	/* read the binary LSBs */
  	if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))
  		return false;
  
  	if(parameter == 1u<<k) {
  		/* compose the value */
  		*val = (msbs << k) | lsbs;
  	}
  	else {
  		unsigned d = (1 << (k+1)) - parameter;
  		if(lsbs >= d) {
  			if(!FLAC__bitreader_read_bit(br, &bit))
  				return false;
  			lsbs <<= 1;
  			lsbs |= bit;
  			lsbs -= d;
  		}
  		/* compose the value */
  		*val = msbs * parameter + lsbs;
  	}
  
  	return true;
  }
  #endif /* UNUSED */
  
  /* on return, if *val == 0xffffffff then the utf-8 sequence was invalid, but the return value will be true */
  FLAC__bool FLAC__bitreader_read_utf8_uint32(FLAC__BitReader *br, FLAC__uint32 *val, FLAC__byte *raw, unsigned *rawlen)
  {
  	FLAC__uint32 v = 0;
  	FLAC__uint32 x;
  	unsigned i;
  
  	if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
  		return false;
  	if(raw)
  		raw[(*rawlen)++] = (FLAC__byte)x;
  	if(!(x & 0x80)) { /* 0xxxxxxx */
  		v = x;
  		i = 0;
  	}
  	else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
  		v = x & 0x1F;
  		i = 1;
  	}
  	else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
  		v = x & 0x0F;
  		i = 2;
  	}
  	else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
  		v = x & 0x07;
  		i = 3;
  	}
  	else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
  		v = x & 0x03;
  		i = 4;
  	}
  	else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
  		v = x & 0x01;
  		i = 5;
  	}
  	else {
  		*val = 0xffffffff;
  		return true;
  	}
  	for( ; i; i--) {
  		if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
  			return false;
  		if(raw)
  			raw[(*rawlen)++] = (FLAC__byte)x;
  		if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
  			*val = 0xffffffff;
  			return true;
  		}
  		v <<= 6;
  		v |= (x & 0x3F);
  	}
  	*val = v;
  	return true;
  }
  
  /* on return, if *val == 0xffffffffffffffff then the utf-8 sequence was invalid, but the return value will be true */
  FLAC__bool FLAC__bitreader_read_utf8_uint64(FLAC__BitReader *br, FLAC__uint64 *val, FLAC__byte *raw, unsigned *rawlen)
  {
  	FLAC__uint64 v = 0;
  	FLAC__uint32 x;
  	unsigned i;
  
  	if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
  		return false;
  	if(raw)
  		raw[(*rawlen)++] = (FLAC__byte)x;
  	if(!(x & 0x80)) { /* 0xxxxxxx */
  		v = x;
  		i = 0;
  	}
  	else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
  		v = x & 0x1F;
  		i = 1;
  	}
  	else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
  		v = x & 0x0F;
  		i = 2;
  	}
  	else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
  		v = x & 0x07;
  		i = 3;
  	}
  	else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
  		v = x & 0x03;
  		i = 4;
  	}
  	else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
  		v = x & 0x01;
  		i = 5;
  	}
  	else if(x & 0xFE && !(x & 0x01)) { /* 11111110 */
  		v = 0;
  		i = 6;
  	}
  	else {
  		*val = FLAC__U64L(0xffffffffffffffff);
  		return true;
  	}
  	for( ; i; i--) {
  		if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
  			return false;
  		if(raw)
  			raw[(*rawlen)++] = (FLAC__byte)x;
  		if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
  			*val = FLAC__U64L(0xffffffffffffffff);
  			return true;
  		}
  		v <<= 6;
  		v |= (x & 0x3F);
  	}
  	*val = v;
  	return true;
  }
  
  /* These functions are declared inline in this file but are also callable as
   * externs from elsewhere.
   * According to the C99 spec, section 6.7.4, simply providing a function
   * prototype in a header file without 'inline' and making the function inline
   * in this file should be sufficient.
   * Unfortunately, the Microsoft VS compiler doesn't pick them up externally. To
   * fix that we add extern declarations here.
   */
  extern FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br);
  extern unsigned FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br);
  extern unsigned FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br);
  extern FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val);
  