DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2145 Commits
9 Branches
9.6GB
Tree: 0c142b51b5
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0c142b51b5'
${ noResults }
JUCE/modules/juce_audio_formats/codecs/flac/libFLAC/bitreader.c

1351 lines
42KB
Raw Blame History 

  1. /* libFLAC - Free Lossless Audio Codec library

  2.  * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007  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. #if HAVE_CONFIG_H

  33. #  include <config.h>

  34. #endif

  35. 

  36. #include <stdlib.h> /* for malloc() */

  37. #include <string.h> /* for memcpy(), memset() */

  38. #ifdef _MSC_VER

  39. #include <winsock.h> /* for ntohl() */

  40. #elif defined FLAC__SYS_DARWIN

  41. #include <machine/endian.h> /* for ntohl() */

  42. #elif defined __MINGW32__

  43. #include <winsock.h> /* for ntohl() */

  44. #else

  45. #include <netinet/in.h> /* for ntohl() */

  46. #endif

  47. #include "include/private/bitmath.h"

  48. #include "include/private/bitreader.h"

  49. #include "include/private/crc.h"

  50. #include "../assert.h"

  51. 

  52. /* Things should be fastest when this matches the machine word size */

  53. /* WATCHOUT: if you change this you must also change the following #defines down to COUNT_ZERO_MSBS below to match */

  54. /* WATCHOUT: there are a few places where the code will not work unless brword is >= 32 bits wide */

  55. /*           also, some sections currently only have fast versions for 4 or 8 bytes per word */

  56. typedef FLAC__uint32 brword;

  57. #define FLAC__BYTES_PER_WORD 4

  58. #define FLAC__BITS_PER_WORD 32

  59. #define FLAC__WORD_ALL_ONES ((FLAC__uint32)0xffffffff)

  60. /* SWAP_BE_WORD_TO_HOST swaps bytes in a brword (which is always big-endian) if necessary to match host byte order */

  61. #if WORDS_BIGENDIAN

  62. #define SWAP_BE_WORD_TO_HOST(x) (x)

  63. #else

  64. #if defined (_MSC_VER) && defined (_X86_)

  65. #define SWAP_BE_WORD_TO_HOST(x) local_swap32_(x)

  66. #else

  67. #define SWAP_BE_WORD_TO_HOST(x) ntohl(x)

  68. #endif

  69. #endif

  70. /* counts the # of zero MSBs in a word */

  71. #define COUNT_ZERO_MSBS(word) ( \

  72. 	(word) <= 0xffff ? \

  73. 		( (word) <= 0xff? byte_to_unary_table[word] + 24 : byte_to_unary_table[(word) >> 8] + 16 ) : \

  74. 		( (word) <= 0xffffff? byte_to_unary_table[word >> 16] + 8 : byte_to_unary_table[(word) >> 24] ) \

  75. )

  76. /* this alternate might be slightly faster on some systems/compilers: */

  77. #define COUNT_ZERO_MSBS2(word) ( (word) <= 0xff ? byte_to_unary_table[word] + 24 : ((word) <= 0xffff ? byte_to_unary_table[(word) >> 8] + 16 : ((word) <= 0xffffff ? byte_to_unary_table[(word) >> 16] + 8 : byte_to_unary_table[(word) >> 24])) )

  78. 

  79. 

  80. /*

  81.  * This should be at least twice as large as the largest number of words

  82.  * required to represent any 'number' (in any encoding) you are going to

  83.  * read.  With FLAC this is on the order of maybe a few hundred bits.

  84.  * If the buffer is smaller than that, the decoder won't be able to read

  85.  * in a whole number that is in a variable length encoding (e.g. Rice).

  86.  * But to be practical it should be at least 1K bytes.

  87.  *

  88.  * Increase this number to decrease the number of read callbacks, at the

  89.  * expense of using more memory.  Or decrease for the reverse effect,

  90.  * keeping in mind the limit from the first paragraph.  The optimal size

  91.  * also depends on the CPU cache size and other factors; some twiddling

  92.  * may be necessary to squeeze out the best performance.

  93.  */

  94. static const unsigned FLAC__BITREADER_DEFAULT_CAPACITY = 65536u / FLAC__BITS_PER_WORD; /* in words */

  95. 

  96. static const unsigned char byte_to_unary_table[] = {

  97. 	8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,

  98. 	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  99. 	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  100. 	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  101. 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  102. 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  103. 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  104. 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  105. 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  106. 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  107. 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  108. 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  109. 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  110. 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  111. 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  112. 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

  113. };

  114. 

  115. #ifdef min

  116. #undef min

  117. #endif

  118. #define min(x,y) ((x)<(y)?(x):(y))

  119. #ifdef max

  120. #undef max

  121. #endif

  122. #define max(x,y) ((x)>(y)?(x):(y))

  123. 

  124. /* adjust for compilers that can't understand using LLU suffix for uint64_t literals */

  125. #ifdef _MSC_VER

  126. #define FLAC__U64L(x) x

  127. #else

  128. #define FLAC__U64L(x) x##LLU

  129. #endif

  130. 

  131. #ifndef FLaC__INLINE

  132. #define FLaC__INLINE inline

  133. #endif

  134. 

  135. /* WATCHOUT: assembly routines rely on the order in which these fields are declared */

  136. struct FLAC__BitReader {

  137. 	/* any partially-consumed word at the head will stay right-justified as bits are consumed from the left */

  138. 	/* any incomplete word at the tail will be left-justified, and bytes from the read callback are added on the right */

  139. 	brword *buffer;

  140. 	unsigned capacity; /* in words */

  141. 	unsigned words; /* # of completed words in buffer */

  142. 	unsigned bytes; /* # of bytes in incomplete word at buffer[words] */

  143. 	unsigned consumed_words; /* #words ... */

  144. 	unsigned consumed_bits; /* ... + (#bits of head word) already consumed from the front of buffer */

  145. 	unsigned read_crc16; /* the running frame CRC */

  146. 	unsigned crc16_align; /* the number of bits in the current consumed word that should not be CRC'd */

  147. 	FLAC__BitReaderReadCallback read_callback;

  148. 	void *client_data;

  149. 	FLAC__CPUInfo cpu_info;

  150. };

  151. 

  152. static FLaC__INLINE void crc16_update_word_(FLAC__BitReader *br, brword word)

  153. {

  154. 	register unsigned crc = br->read_crc16;

  155. #if FLAC__BYTES_PER_WORD == 4

  156. 	switch(br->crc16_align) {

  157. 		case  0: crc = FLAC__CRC16_UPDATE((unsigned)(word >> 24), crc);

  158. 		case  8: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 16) & 0xff), crc);

  159. 		case 16: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 8) & 0xff), crc);

  160. 		case 24: br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)(word & 0xff), crc);

  161. 	}

  162. #elif FLAC__BYTES_PER_WORD == 8

  163. 	switch(br->crc16_align) {

  164. 		case  0: crc = FLAC__CRC16_UPDATE((unsigned)(word >> 56), crc);

  165. 		case  8: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 48) & 0xff), crc);

  166. 		case 16: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 40) & 0xff), crc);

  167. 		case 24: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 32) & 0xff), crc);

  168. 		case 32: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 24) & 0xff), crc);

  169. 		case 40: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 16) & 0xff), crc);

  170. 		case 48: crc = FLAC__CRC16_UPDATE((unsigned)((word >> 8) & 0xff), crc);

  171. 		case 56: br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)(word & 0xff), crc);

  172. 	}

  173. #else

  174. 	for( ; br->crc16_align < FLAC__BITS_PER_WORD; br->crc16_align += 8)

  175. 		crc = FLAC__CRC16_UPDATE((unsigned)((word >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), crc);

  176. 	br->read_crc16 = crc;

  177. #endif

  178. 	br->crc16_align = 0;

  179. }

  180. 

  181. /* would be static except it needs to be called by asm routines */

  182. FLAC__bool bitreader_read_from_client_(FLAC__BitReader *br)

  183. {

  184. 	unsigned start, end;

  185. 	size_t bytes;

  186. 	FLAC__byte *target;

  187. 

  188. 	/* first shift the unconsumed buffer data toward the front as much as possible */

  189. 	if(br->consumed_words > 0) {

  190. 		start = br->consumed_words;

  191. 		end = br->words + (br->bytes? 1:0);

  192. 		memmove(br->buffer, br->buffer+start, FLAC__BYTES_PER_WORD * (end - start));

  193. 

  194. 		br->words -= start;

  195. 		br->consumed_words = 0;

  196. 	}

  197. 

  198. 	/*

  199. 	 * set the target for reading, taking into account word alignment and endianness

  200. 	 */

  201. 	bytes = (br->capacity - br->words) * FLAC__BYTES_PER_WORD - br->bytes;

  202. 	if(bytes == 0)

  203. 		return false; /* no space left, buffer is too small; see note for FLAC__BITREADER_DEFAULT_CAPACITY  */

  204. 	target = ((FLAC__byte*)(br->buffer+br->words)) + br->bytes;

  205. 

  206. 	/* before reading, if the existing reader looks like this (say brword is 32 bits wide)

  207. 	 *   bitstream :  11 22 33 44 55            br->words=1 br->bytes=1 (partial tail word is left-justified)

  208. 	 *   buffer[BE]:  11 22 33 44 55 ?? ?? ??   (shown layed out as bytes sequentially in memory)

  209. 	 *   buffer[LE]:  44 33 22 11 ?? ?? ?? 55   (?? being don't-care)

  210. 	 *                               ^^-------target, bytes=3

  211. 	 * on LE machines, have to byteswap the odd tail word so nothing is

  212. 	 * overwritten:

  213. 	 */

  214. #if WORDS_BIGENDIAN

  215. #else

  216. 	if(br->bytes)

  217. 		br->buffer[br->words] = SWAP_BE_WORD_TO_HOST(br->buffer[br->words]);

  218. #endif

  219. 

  220. 	/* now it looks like:

  221. 	 *   bitstream :  11 22 33 44 55            br->words=1 br->bytes=1

  222. 	 *   buffer[BE]:  11 22 33 44 55 ?? ?? ??

  223. 	 *   buffer[LE]:  44 33 22 11 55 ?? ?? ??

  224. 	 *                               ^^-------target, bytes=3

  225. 	 */

  226. 

  227. 	/* read in the data; note that the callback may return a smaller number of bytes */

  228. 	if(!br->read_callback(target, &bytes, br->client_data))

  229. 		return false;

  230. 

  231. 	/* after reading bytes 66 77 88 99 AA BB CC DD EE FF from the client:

  232. 	 *   bitstream :  11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF

  233. 	 *   buffer[BE]:  11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??

  234. 	 *   buffer[LE]:  44 33 22 11 55 66 77 88 99 AA BB CC DD EE FF ??

  235. 	 * now have to byteswap on LE machines:

  236. 	 */

  237. #if WORDS_BIGENDIAN

  238. #else

  239. 	end = (br->words*FLAC__BYTES_PER_WORD + br->bytes + bytes + (FLAC__BYTES_PER_WORD-1)) / FLAC__BYTES_PER_WORD;

  240. # if defined(_MSC_VER) && defined (_X86_) && (FLAC__BYTES_PER_WORD == 4)

  241. 	if(br->cpu_info.type == FLAC__CPUINFO_TYPE_IA32 && br->cpu_info.data.ia32.bswap) {

  242. 		start = br->words;

  243. 		local_swap32_block_(br->buffer + start, end - start);

  244. 	}

  245. 	else

  246. # endif

  247. 	for(start = br->words; start < end; start++)

  248. 		br->buffer[start] = SWAP_BE_WORD_TO_HOST(br->buffer[start]);

  249. #endif

  250. 

  251. 	/* now it looks like:

  252. 	 *   bitstream :  11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF

  253. 	 *   buffer[BE]:  11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??

  254. 	 *   buffer[LE]:  44 33 22 11 88 77 66 55 CC BB AA 99 ?? FF EE DD

  255. 	 * finally we'll update the reader values:

  256. 	 */

  257. 	end = br->words*FLAC__BYTES_PER_WORD + br->bytes + bytes;

  258. 	br->words = end / FLAC__BYTES_PER_WORD;

  259. 	br->bytes = end % FLAC__BYTES_PER_WORD;

  260. 

  261. 	return true;

  262. }

  263. 

  264. /***********************************************************************

  265.  *

  266.  * Class constructor/destructor

  267.  *

  268.  ***********************************************************************/

  269. 

  270. FLAC__BitReader *FLAC__bitreader_new(void)

  271. {

  272. 	FLAC__BitReader *br = (FLAC__BitReader*)calloc(1, sizeof(FLAC__BitReader));

  273. 

  274. 	/* calloc() implies:

  275. 		memset(br, 0, sizeof(FLAC__BitReader));

  276. 		br->buffer = 0;

  277. 		br->capacity = 0;

  278. 		br->words = br->bytes = 0;

  279. 		br->consumed_words = br->consumed_bits = 0;

  280. 		br->read_callback = 0;

  281. 		br->client_data = 0;

  282. 	*/

  283. 	return br;

  284. }

  285. 

  286. void FLAC__bitreader_delete(FLAC__BitReader *br)

  287. {

  288. 	FLAC__ASSERT(0 != br);

  289. 

  290. 	FLAC__bitreader_free(br);

  291. 	free(br);

  292. }

  293. 

  294. /***********************************************************************

  295.  *

  296.  * Public class methods

  297.  *

  298.  ***********************************************************************/

  299. 

  300. FLAC__bool FLAC__bitreader_init(FLAC__BitReader *br, FLAC__CPUInfo cpu, FLAC__BitReaderReadCallback rcb, void *cd)

  301. {

  302. 	FLAC__ASSERT(0 != br);

  303. 

  304. 	br->words = br->bytes = 0;

  305. 	br->consumed_words = br->consumed_bits = 0;

  306. 	br->capacity = FLAC__BITREADER_DEFAULT_CAPACITY;

  307. 	br->buffer = (brword*)malloc(sizeof(brword) * br->capacity);

  308. 	if(br->buffer == 0)

  309. 		return false;

  310. 	br->read_callback = rcb;

  311. 	br->client_data = cd;

  312. 	br->cpu_info = cpu;

  313. 

  314. 	return true;

  315. }

  316. 

  317. void FLAC__bitreader_free(FLAC__BitReader *br)

  318. {

  319. 	FLAC__ASSERT(0 != br);

  320. 

  321. 	if(0 != br->buffer)

  322. 		free(br->buffer);

  323. 	br->buffer = 0;

  324. 	br->capacity = 0;

  325. 	br->words = br->bytes = 0;

  326. 	br->consumed_words = br->consumed_bits = 0;

  327. 	br->read_callback = 0;

  328. 	br->client_data = 0;

  329. }

  330. 

  331. FLAC__bool FLAC__bitreader_clear(FLAC__BitReader *br)

  332. {

  333. 	br->words = br->bytes = 0;

  334. 	br->consumed_words = br->consumed_bits = 0;

  335. 	return true;

  336. }

  337. 

  338. void FLAC__bitreader_dump(const FLAC__BitReader *br, FILE *out)

  339. {

  340. 	unsigned i, j;

  341. 	if(br == 0) {

  342. 		fprintf(out, "bitreader is NULL\n");

  343. 	}

  344. 	else {

  345. 		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);

  346. 

  347. 		for(i = 0; i < br->words; i++) {

  348. 			fprintf(out, "%08X: ", i);

  349. 			for(j = 0; j < FLAC__BITS_PER_WORD; j++)

  350. 				if(i < br->consumed_words || (i == br->consumed_words && j < br->consumed_bits))

  351. 					fprintf(out, ".");

  352. 				else

  353. 					fprintf(out, "%01u", br->buffer[i] & (1 << (FLAC__BITS_PER_WORD-j-1)) ? 1:0);

  354. 			fprintf(out, "\n");

  355. 		}

  356. 		if(br->bytes > 0) {

  357. 			fprintf(out, "%08X: ", i);

  358. 			for(j = 0; j < br->bytes*8; j++)

  359. 				if(i < br->consumed_words || (i == br->consumed_words && j < br->consumed_bits))

  360. 					fprintf(out, ".");

  361. 				else

  362. 					fprintf(out, "%01u", br->buffer[i] & (1 << (br->bytes*8-j-1)) ? 1:0);

  363. 			fprintf(out, "\n");

  364. 		}

  365. 	}

  366. }

  367. 

  368. void FLAC__bitreader_reset_read_crc16(FLAC__BitReader *br, FLAC__uint16 seed)

  369. {

  370. 	FLAC__ASSERT(0 != br);

  371. 	FLAC__ASSERT(0 != br->buffer);

  372. 	FLAC__ASSERT((br->consumed_bits & 7) == 0);

  373. 

  374. 	br->read_crc16 = (unsigned)seed;

  375. 	br->crc16_align = br->consumed_bits;

  376. }

  377. 

  378. FLAC__uint16 FLAC__bitreader_get_read_crc16(FLAC__BitReader *br)

  379. {

  380. 	FLAC__ASSERT(0 != br);

  381. 	FLAC__ASSERT(0 != br->buffer);

  382. 	FLAC__ASSERT((br->consumed_bits & 7) == 0);

  383. 	FLAC__ASSERT(br->crc16_align <= br->consumed_bits);

  384. 

  385. 	/* CRC any tail bytes in a partially-consumed word */

  386. 	if(br->consumed_bits) {

  387. 		const brword tail = br->buffer[br->consumed_words];

  388. 		for( ; br->crc16_align < br->consumed_bits; br->crc16_align += 8)

  389. 			br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)((tail >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), br->read_crc16);

  390. 	}

  391. 	return (FLAC__uint16) br->read_crc16;

  392. }

  393. 

  394. FLaC__INLINE FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br)

  395. {

  396. 	return ((br->consumed_bits & 7) == 0);

  397. }

  398. 

  399. FLaC__INLINE unsigned FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br)

  400. {

  401. 	return 8 - (br->consumed_bits & 7);

  402. }

  403. 

  404. FLaC__INLINE unsigned FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br)

  405. {

  406. 	return (br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits;

  407. }

  408. 

  409. FLaC__INLINE FLAC__bool FLAC__bitreader_read_raw_uint32(FLAC__BitReader *br, FLAC__uint32 *val, unsigned bits)

  410. {

  411. 	FLAC__ASSERT(0 != br);

  412. 	FLAC__ASSERT(0 != br->buffer);

  413. 

  414. 	FLAC__ASSERT(bits <= 32);

  415. 	FLAC__ASSERT((br->capacity*FLAC__BITS_PER_WORD) * 2 >= bits);

  416. 	FLAC__ASSERT(br->consumed_words <= br->words);

  417. 

  418. 	/* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */

  419. 	FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);

  420. 

  421. 	if(bits == 0) { /* OPT: investigate if this can ever happen, maybe change to assertion */

  422. 		*val = 0;

  423. 		return true;

  424. 	}

  425. 

  426. 	while((br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits < bits) {

  427. 		if(!bitreader_read_from_client_(br))

  428. 			return false;

  429. 	}

  430. 	if(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */

  431. 		/* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */

  432. 		if(br->consumed_bits) {

  433. 			/* this also works when consumed_bits==0, it's just a little slower than necessary for that case */

  434. 			const unsigned n = FLAC__BITS_PER_WORD - br->consumed_bits;

  435. 			const brword word = br->buffer[br->consumed_words];

  436. 			if(bits < n) {

  437. 				*val = (word & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (n-bits);

  438. 				br->consumed_bits += bits;

  439. 				return true;

  440. 			}

  441. 			*val = word & (FLAC__WORD_ALL_ONES >> br->consumed_bits);

  442. 			bits -= n;

  443. 			crc16_update_word_(br, word);

  444. 			br->consumed_words++;

  445. 			br->consumed_bits = 0;

  446. 			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 */

  447. 				*val <<= bits;

  448. 				*val |= (br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits));

  449. 				br->consumed_bits = bits;

  450. 			}

  451. 			return true;

  452. 		}

  453. 		else {

  454. 			const brword word = br->buffer[br->consumed_words];

  455. 			if(bits < FLAC__BITS_PER_WORD) {

  456. 				*val = word >> (FLAC__BITS_PER_WORD-bits);

  457. 				br->consumed_bits = bits;

  458. 				return true;

  459. 			}

  460. 			/* at this point 'bits' must be == FLAC__BITS_PER_WORD; because of previous assertions, it can't be larger */

  461. 			*val = word;

  462. 			crc16_update_word_(br, word);

  463. 			br->consumed_words++;

  464. 			return true;

  465. 		}

  466. 	}

  467. 	else {

  468. 		/* in this case we're starting our read at a partial tail word;

  469. 		 * the reader has guaranteed that we have at least 'bits' bits

  470. 		 * available to read, which makes this case simpler.

  471. 		 */

  472. 		/* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */

  473. 		if(br->consumed_bits) {

  474. 			/* this also works when consumed_bits==0, it's just a little slower than necessary for that case */

  475. 			FLAC__ASSERT(br->consumed_bits + bits <= br->bytes*8);

  476. 			*val = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (FLAC__BITS_PER_WORD-br->consumed_bits-bits);

  477. 			br->consumed_bits += bits;

  478. 			return true;

  479. 		}

  480. 		else {

  481. 			*val = br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits);

  482. 			br->consumed_bits += bits;

  483. 			return true;

  484. 		}

  485. 	}

  486. }

  487. 

  488. FLAC__bool FLAC__bitreader_read_raw_int32(FLAC__BitReader *br, FLAC__int32 *val, unsigned bits)

  489. {

  490. 	/* OPT: inline raw uint32 code here, or make into a macro if possible in the .h file */

  491. 	if(!FLAC__bitreader_read_raw_uint32(br, (FLAC__uint32*)val, bits))

  492. 		return false;

  493. 	/* sign-extend: */

  494. 	*val <<= (32-bits);

  495. 	*val >>= (32-bits);

  496. 	return true;

  497. }

  498. 

  499. FLAC__bool FLAC__bitreader_read_raw_uint64(FLAC__BitReader *br, FLAC__uint64 *val, unsigned bits)

  500. {

  501. 	FLAC__uint32 hi, lo;

  502. 

  503. 	if(bits > 32) {

  504. 		if(!FLAC__bitreader_read_raw_uint32(br, &hi, bits-32))

  505. 			return false;

  506. 		if(!FLAC__bitreader_read_raw_uint32(br, &lo, 32))

  507. 			return false;

  508. 		*val = hi;

  509. 		*val <<= 32;

  510. 		*val |= lo;

  511. 	}

  512. 	else {

  513. 		if(!FLAC__bitreader_read_raw_uint32(br, &lo, bits))

  514. 			return false;

  515. 		*val = lo;

  516. 	}

  517. 	return true;

  518. }

  519. 

  520. FLaC__INLINE FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val)

  521. {

  522. 	FLAC__uint32 x8, x32 = 0;

  523. 

  524. 	/* this doesn't need to be that fast as currently it is only used for vorbis comments */

  525. 

  526. 	if(!FLAC__bitreader_read_raw_uint32(br, &x32, 8))

  527. 		return false;

  528. 

  529. 	if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))

  530. 		return false;

  531. 	x32 |= (x8 << 8);

  532. 

  533. 	if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))

  534. 		return false;

  535. 	x32 |= (x8 << 16);

  536. 

  537. 	if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))

  538. 		return false;

  539. 	x32 |= (x8 << 24);

  540. 

  541. 	*val = x32;

  542. 	return true;

  543. }

  544. 

  545. FLAC__bool FLAC__bitreader_skip_bits_no_crc(FLAC__BitReader *br, unsigned bits)

  546. {

  547. 	/*

  548. 	 * OPT: a faster implementation is possible but probably not that useful

  549. 	 * since this is only called a couple of times in the metadata readers.

  550. 	 */

  551. 	FLAC__ASSERT(0 != br);

  552. 	FLAC__ASSERT(0 != br->buffer);

  553. 

  554. 	if(bits > 0) {

  555. 		const unsigned n = br->consumed_bits & 7;

  556. 		unsigned m;

  557. 		FLAC__uint32 x;

  558. 

  559. 		if(n != 0) {

  560. 			m = min(8-n, bits);

  561. 			if(!FLAC__bitreader_read_raw_uint32(br, &x, m))

  562. 				return false;

  563. 			bits -= m;

  564. 		}

  565. 		m = bits / 8;

  566. 		if(m > 0) {

  567. 			if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(br, m))

  568. 				return false;

  569. 			bits %= 8;

  570. 		}

  571. 		if(bits > 0) {

  572. 			if(!FLAC__bitreader_read_raw_uint32(br, &x, bits))

  573. 				return false;

  574. 		}

  575. 	}

  576. 

  577. 	return true;

  578. }

  579. 

  580. FLAC__bool FLAC__bitreader_skip_byte_block_aligned_no_crc(FLAC__BitReader *br, unsigned nvals)

  581. {

  582. 	FLAC__uint32 x;

  583. 

  584. 	FLAC__ASSERT(0 != br);

  585. 	FLAC__ASSERT(0 != br->buffer);

  586. 	FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));

  587. 

  588. 	/* step 1: skip over partial head word to get word aligned */

  589. 	while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */

  590. 		if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))

  591. 			return false;

  592. 		nvals--;

  593. 	}

  594. 	if(0 == nvals)

  595. 		return true;

  596. 	/* step 2: skip whole words in chunks */

  597. 	while(nvals >= FLAC__BYTES_PER_WORD) {

  598. 		if(br->consumed_words < br->words) {

  599. 			br->consumed_words++;

  600. 			nvals -= FLAC__BYTES_PER_WORD;

  601. 		}

  602. 		else if(!bitreader_read_from_client_(br))

  603. 			return false;

  604. 	}

  605. 	/* step 3: skip any remainder from partial tail bytes */

  606. 	while(nvals) {

  607. 		if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))

  608. 			return false;

  609. 		nvals--;

  610. 	}

  611. 

  612. 	return true;

  613. }

  614. 

  615. FLAC__bool FLAC__bitreader_read_byte_block_aligned_no_crc(FLAC__BitReader *br, FLAC__byte *val, unsigned nvals)

  616. {

  617. 	FLAC__uint32 x;

  618. 

  619. 	FLAC__ASSERT(0 != br);

  620. 	FLAC__ASSERT(0 != br->buffer);

  621. 	FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));

  622. 

  623. 	/* step 1: read from partial head word to get word aligned */

  624. 	while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */

  625. 		if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))

  626. 			return false;

  627. 		*val++ = (FLAC__byte)x;

  628. 		nvals--;

  629. 	}

  630. 	if(0 == nvals)

  631. 		return true;

  632. 	/* step 2: read whole words in chunks */

  633. 	while(nvals >= FLAC__BYTES_PER_WORD) {

  634. 		if(br->consumed_words < br->words) {

  635. 			const brword word = br->buffer[br->consumed_words++];

  636. #if FLAC__BYTES_PER_WORD == 4

  637. 			val[0] = (FLAC__byte)(word >> 24);

  638. 			val[1] = (FLAC__byte)(word >> 16);

  639. 			val[2] = (FLAC__byte)(word >> 8);

  640. 			val[3] = (FLAC__byte)word;

  641. #elif FLAC__BYTES_PER_WORD == 8

  642. 			val[0] = (FLAC__byte)(word >> 56);

  643. 			val[1] = (FLAC__byte)(word >> 48);

  644. 			val[2] = (FLAC__byte)(word >> 40);

  645. 			val[3] = (FLAC__byte)(word >> 32);

  646. 			val[4] = (FLAC__byte)(word >> 24);

  647. 			val[5] = (FLAC__byte)(word >> 16);

  648. 			val[6] = (FLAC__byte)(word >> 8);

  649. 			val[7] = (FLAC__byte)word;

  650. #else

  651. 			for(x = 0; x < FLAC__BYTES_PER_WORD; x++)

  652. 				val[x] = (FLAC__byte)(word >> (8*(FLAC__BYTES_PER_WORD-x-1)));

  653. #endif

  654. 			val += FLAC__BYTES_PER_WORD;

  655. 			nvals -= FLAC__BYTES_PER_WORD;

  656. 		}

  657. 		else if(!bitreader_read_from_client_(br))

  658. 			return false;

  659. 	}

  660. 	/* step 3: read any remainder from partial tail bytes */

  661. 	while(nvals) {

  662. 		if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))

  663. 			return false;

  664. 		*val++ = (FLAC__byte)x;

  665. 		nvals--;

  666. 	}

  667. 

  668. 	return true;

  669. }

  670. 

  671. FLaC__INLINE FLAC__bool FLAC__bitreader_read_unary_unsigned(FLAC__BitReader *br, unsigned *val)

  672. #if 0 /* slow but readable version */

  673. {

  674. 	unsigned bit;

  675. 

  676. 	FLAC__ASSERT(0 != br);

  677. 	FLAC__ASSERT(0 != br->buffer);

  678. 

  679. 	*val = 0;

  680. 	while(1) {

  681. 		if(!FLAC__bitreader_read_bit(br, &bit))

  682. 			return false;

  683. 		if(bit)

  684. 			break;

  685. 		else

  686. 			*val++;

  687. 	}

  688. 	return true;

  689. }

  690. #else

  691. {

  692. 	unsigned i;

  693. 

  694. 	FLAC__ASSERT(0 != br);

  695. 	FLAC__ASSERT(0 != br->buffer);

  696. 

  697. 	*val = 0;

  698. 	while(1) {

  699. 		while(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */

  700. 			brword b = br->buffer[br->consumed_words] << br->consumed_bits;

  701. 			if(b) {

  702. 				i = COUNT_ZERO_MSBS(b);

  703. 				*val += i;

  704. 				i++;

  705. 				br->consumed_bits += i;

  706. 				if(br->consumed_bits >= FLAC__BITS_PER_WORD) { /* faster way of testing if(br->consumed_bits == FLAC__BITS_PER_WORD) */

  707. 					crc16_update_word_(br, br->buffer[br->consumed_words]);

  708. 					br->consumed_words++;

  709. 					br->consumed_bits = 0;

  710. 				}

  711. 				return true;

  712. 			}

  713. 			else {

  714. 				*val += FLAC__BITS_PER_WORD - br->consumed_bits;

  715. 				crc16_update_word_(br, br->buffer[br->consumed_words]);

  716. 				br->consumed_words++;

  717. 				br->consumed_bits = 0;

  718. 				/* didn't find stop bit yet, have to keep going... */

  719. 			}

  720. 		}

  721. 		/* at this point we've eaten up all the whole words; have to try

  722. 		 * reading through any tail bytes before calling the read callback.

  723. 		 * this is a repeat of the above logic adjusted for the fact we

  724. 		 * don't have a whole word.  note though if the client is feeding

  725. 		 * us data a byte at a time (unlikely), br->consumed_bits may not

  726. 		 * be zero.

  727. 		 */

  728. 		if(br->bytes) {

  729. 			const unsigned end = br->bytes * 8;

  730. 			brword b = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << br->consumed_bits;

  731. 			if(b) {

  732. 				i = COUNT_ZERO_MSBS(b);

  733. 				*val += i;

  734. 				i++;

  735. 				br->consumed_bits += i;

  736. 				FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);

  737. 				return true;

  738. 			}

  739. 			else {

  740. 				*val += end - br->consumed_bits;

  741. 				br->consumed_bits += end;

  742. 				FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);

  743. 				/* didn't find stop bit yet, have to keep going... */

  744. 			}

  745. 		}

  746. 		if(!bitreader_read_from_client_(br))

  747. 			return false;

  748. 	}

  749. }

  750. #endif

  751. 

  752. FLAC__bool FLAC__bitreader_read_rice_signed(FLAC__BitReader *br, int *val, unsigned parameter)

  753. {

  754. 	FLAC__uint32 lsbs = 0, msbs = 0;

  755. 	unsigned uval;

  756. 

  757. 	FLAC__ASSERT(0 != br);

  758. 	FLAC__ASSERT(0 != br->buffer);

  759. 	FLAC__ASSERT(parameter <= 31);

  760. 

  761. 	/* read the unary MSBs and end bit */

  762. 	if(!FLAC__bitreader_read_unary_unsigned(br, (unsigned int*) &msbs))

  763. 		return false;

  764. 

  765. 	/* read the binary LSBs */

  766. 	if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, parameter))

  767. 		return false;

  768. 

  769. 	/* compose the value */

  770. 	uval = (msbs << parameter) | lsbs;

  771. 	if(uval & 1)

  772. 		*val = -((int)(uval >> 1)) - 1;

  773. 	else

  774. 		*val = (int)(uval >> 1);

  775. 

  776. 	return true;

  777. }

  778. 

  779. /* this is by far the most heavily used reader call.  it ain't pretty but it's fast */

  780. /* a lot of the logic is copied, then adapted, from FLAC__bitreader_read_unary_unsigned() and FLAC__bitreader_read_raw_uint32() */

  781. FLAC__bool FLAC__bitreader_read_rice_signed_block(FLAC__BitReader *br, int vals[], unsigned nvals, unsigned parameter)

  782. /* OPT: possibly faster version for use with MSVC */

  783. #ifdef _MSC_VER

  784. {

  785. 	unsigned i;

  786. 	unsigned uval = 0;

  787. 	unsigned bits; /* the # of binary LSBs left to read to finish a rice codeword */

  788. 

  789. 	/* try and get br->consumed_words and br->consumed_bits into register;

  790. 	 * must remember to flush them back to *br before calling other

  791. 	 * bitwriter functions that use them, and before returning */

  792. 	register unsigned cwords;

  793. 	register unsigned cbits;

  794. 

  795. 	FLAC__ASSERT(0 != br);

  796. 	FLAC__ASSERT(0 != br->buffer);

  797. 	/* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */

  798. 	FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);

  799. 	FLAC__ASSERT(parameter < 32);

  800. 	/* the above two asserts also guarantee that the binary part never straddles more that 2 words, so we don't have to loop to read it */

  801. 

  802. 	if(nvals == 0)

  803. 		return true;

  804. 

  805. 	cbits = br->consumed_bits;

  806. 	cwords = br->consumed_words;

  807. 

  808. 	while(1) {

  809. 

  810. 		/* read unary part */

  811. 		while(1) {

  812. 			while(cwords < br->words) { /* if we've not consumed up to a partial tail word... */

  813. 				brword b = br->buffer[cwords] << cbits;

  814. 				if(b) {

  815. #if 0 /* slower, probably due to bad register allocation... */ && defined FLAC__CPU_IA32 && !defined FLAC__NO_ASM && FLAC__BITS_PER_WORD == 32

  816. 					__asm {

  817. 						bsr eax, b

  818. 						not eax

  819. 						and eax, 31

  820. 						mov i, eax

  821. 					}

  822. #else

  823. 					i = COUNT_ZERO_MSBS(b);

  824. #endif

  825. 					uval += i;

  826. 					bits = parameter;

  827. 					i++;

  828. 					cbits += i;

  829. 					if(cbits == FLAC__BITS_PER_WORD) {

  830. 						crc16_update_word_(br, br->buffer[cwords]);

  831. 						cwords++;

  832. 						cbits = 0;

  833. 					}

  834. 					goto break1;

  835. 				}

  836. 				else {

  837. 					uval += FLAC__BITS_PER_WORD - cbits;

  838. 					crc16_update_word_(br, br->buffer[cwords]);

  839. 					cwords++;

  840. 					cbits = 0;

  841. 					/* didn't find stop bit yet, have to keep going... */

  842. 				}

  843. 			}

  844. 			/* at this point we've eaten up all the whole words; have to try

  845. 			 * reading through any tail bytes before calling the read callback.

  846. 			 * this is a repeat of the above logic adjusted for the fact we

  847. 			 * don't have a whole word.  note though if the client is feeding

  848. 			 * us data a byte at a time (unlikely), br->consumed_bits may not

  849. 			 * be zero.

  850. 			 */

  851. 			if(br->bytes) {

  852. 				const unsigned end = br->bytes * 8;

  853. 				brword b = (br->buffer[cwords] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << cbits;

  854. 				if(b) {

  855. 					i = COUNT_ZERO_MSBS(b);

  856. 					uval += i;

  857. 					bits = parameter;

  858. 					i++;

  859. 					cbits += i;

  860. 					FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);

  861. 					goto break1;

  862. 				}

  863. 				else {

  864. 					uval += end - cbits;

  865. 					cbits += end;

  866. 					FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);

  867. 					/* didn't find stop bit yet, have to keep going... */

  868. 				}

  869. 			}

  870. 			/* flush registers and read; bitreader_read_from_client_() does

  871. 			 * not touch br->consumed_bits at all but we still need to set

  872. 			 * it in case it fails and we have to return false.

  873. 			 */

  874. 			br->consumed_bits = cbits;

  875. 			br->consumed_words = cwords;

  876. 			if(!bitreader_read_from_client_(br))

  877. 				return false;

  878. 			cwords = br->consumed_words;

  879. 		}

  880. break1:

  881. 		/* read binary part */

  882. 		FLAC__ASSERT(cwords <= br->words);

  883. 

  884. 		if(bits) {

  885. 			while((br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits < bits) {

  886. 				/* flush registers and read; bitreader_read_from_client_() does

  887. 				 * not touch br->consumed_bits at all but we still need to set

  888. 				 * it in case it fails and we have to return false.

  889. 				 */

  890. 				br->consumed_bits = cbits;

  891. 				br->consumed_words = cwords;

  892. 				if(!bitreader_read_from_client_(br))

  893. 					return false;

  894. 				cwords = br->consumed_words;

  895. 			}

  896. 			if(cwords < br->words) { /* if we've not consumed up to a partial tail word... */

  897. 				if(cbits) {

  898. 					/* this also works when consumed_bits==0, it's just a little slower than necessary for that case */

  899. 					const unsigned n = FLAC__BITS_PER_WORD - cbits;

  900. 					const brword word = br->buffer[cwords];

  901. 					if(bits < n) {

  902. 						uval <<= bits;

  903. 						uval |= (word & (FLAC__WORD_ALL_ONES >> cbits)) >> (n-bits);

  904. 						cbits += bits;

  905. 						goto break2;

  906. 					}

  907. 					uval <<= n;

  908. 					uval |= word & (FLAC__WORD_ALL_ONES >> cbits);

  909. 					bits -= n;

  910. 					crc16_update_word_(br, word);

  911. 					cwords++;

  912. 					cbits = 0;

  913. 					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 */

  914. 						uval <<= bits;

  915. 						uval |= (br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits));

  916. 						cbits = bits;

  917. 					}

  918. 					goto break2;

  919. 				}

  920. 				else {

  921. 					FLAC__ASSERT(bits < FLAC__BITS_PER_WORD);

  922. 					uval <<= bits;

  923. 					uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits);

  924. 					cbits = bits;

  925. 					goto break2;

  926. 				}

  927. 			}

  928. 			else {

  929. 				/* in this case we're starting our read at a partial tail word;

  930. 				 * the reader has guaranteed that we have at least 'bits' bits

  931. 				 * available to read, which makes this case simpler.

  932. 				 */

  933. 				uval <<= bits;

  934. 				if(cbits) {

  935. 					/* this also works when consumed_bits==0, it's just a little slower than necessary for that case */

  936. 					FLAC__ASSERT(cbits + bits <= br->bytes*8);

  937. 					uval |= (br->buffer[cwords] & (FLAC__WORD_ALL_ONES >> cbits)) >> (FLAC__BITS_PER_WORD-cbits-bits);

  938. 					cbits += bits;

  939. 					goto break2;

  940. 				}

  941. 				else {

  942. 					uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits);

  943. 					cbits += bits;

  944. 					goto break2;

  945. 				}

  946. 			}

  947. 		}

  948. break2:

  949. 		/* compose the value */

  950. 		*vals = (int)(uval >> 1 ^ -(int)(uval & 1));

  951. 

  952. 		/* are we done? */

  953. 		--nvals;

  954. 		if(nvals == 0) {

  955. 			br->consumed_bits = cbits;

  956. 			br->consumed_words = cwords;

  957. 			return true;

  958. 		}

  959. 

  960. 		uval = 0;

  961. 		++vals;

  962. 

  963. 	}

  964. }

  965. #else

  966. {

  967. 	unsigned i;

  968. 	unsigned uval = 0;

  969. 

  970. 	/* try and get br->consumed_words and br->consumed_bits into register;

  971. 	 * must remember to flush them back to *br before calling other

  972. 	 * bitwriter functions that use them, and before returning */

  973. 	register unsigned cwords;

  974. 	register unsigned cbits;

  975. 	unsigned ucbits; /* keep track of the number of unconsumed bits in the buffer */

  976. 

  977. 	FLAC__ASSERT(0 != br);

  978. 	FLAC__ASSERT(0 != br->buffer);

  979. 	/* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */

  980. 	FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);

  981. 	FLAC__ASSERT(parameter < 32);

  982. 	/* 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 */

  983. 

  984. 	if(nvals == 0)

  985. 		return true;

  986. 

  987. 	cbits = br->consumed_bits;

  988. 	cwords = br->consumed_words;

  989. 	ucbits = (br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits;

  990. 

  991. 	while(1) {

  992. 

  993. 		/* read unary part */

  994. 		while(1) {

  995. 			while(cwords < br->words) { /* if we've not consumed up to a partial tail word... */

  996. 				brword b = br->buffer[cwords] << cbits;

  997. 				if(b) {

  998. #if 0 /* is not discernably faster... */ && defined FLAC__CPU_IA32 && !defined FLAC__NO_ASM && FLAC__BITS_PER_WORD == 32 && defined __GNUC__

  999. 					asm volatile (

  1000. 						"bsrl %1, %0;"

  1001. 						"notl %0;"

  1002. 						"andl $31, %0;"

  1003. 						: "=r"(i)

  1004. 						: "r"(b)

  1005. 					);

  1006. #else

  1007. 					i = COUNT_ZERO_MSBS(b);

  1008. #endif

  1009. 					uval += i;

  1010. 					cbits += i;

  1011. 					cbits++; /* skip over stop bit */

  1012. 					if(cbits >= FLAC__BITS_PER_WORD) { /* faster way of testing if(cbits == FLAC__BITS_PER_WORD) */

  1013. 						crc16_update_word_(br, br->buffer[cwords]);

  1014. 						cwords++;

  1015. 						cbits = 0;

  1016. 					}

  1017. 					goto break1;

  1018. 				}

  1019. 				else {

  1020. 					uval += FLAC__BITS_PER_WORD - cbits;

  1021. 					crc16_update_word_(br, br->buffer[cwords]);

  1022. 					cwords++;

  1023. 					cbits = 0;

  1024. 					/* didn't find stop bit yet, have to keep going... */

  1025. 				}

  1026. 			}

  1027. 			/* at this point we've eaten up all the whole words; have to try

  1028. 			 * reading through any tail bytes before calling the read callback.

  1029. 			 * this is a repeat of the above logic adjusted for the fact we

  1030. 			 * don't have a whole word.  note though if the client is feeding

  1031. 			 * us data a byte at a time (unlikely), br->consumed_bits may not

  1032. 			 * be zero.

  1033. 			 */

  1034. 			if(br->bytes) {

  1035. 				const unsigned end = br->bytes * 8;

  1036. 				brword b = (br->buffer[cwords] & ~(FLAC__WORD_ALL_ONES >> end)) << cbits;

  1037. 				if(b) {

  1038. 					i = COUNT_ZERO_MSBS(b);

  1039. 					uval += i;

  1040. 					cbits += i;

  1041. 					cbits++; /* skip over stop bit */

  1042. 					FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);

  1043. 					goto break1;

  1044. 				}

  1045. 				else {

  1046. 					uval += end - cbits;

  1047. 					cbits += end;

  1048. 					FLAC__ASSERT(cbits < FLAC__BITS_PER_WORD);

  1049. 					/* didn't find stop bit yet, have to keep going... */

  1050. 				}

  1051. 			}

  1052. 			/* flush registers and read; bitreader_read_from_client_() does

  1053. 			 * not touch br->consumed_bits at all but we still need to set

  1054. 			 * it in case it fails and we have to return false.

  1055. 			 */

  1056. 			br->consumed_bits = cbits;

  1057. 			br->consumed_words = cwords;

  1058. 			if(!bitreader_read_from_client_(br))

  1059. 				return false;

  1060. 			cwords = br->consumed_words;

  1061. 			ucbits = (br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits + uval;

  1062. 			/* + uval to offset our count by the # of unary bits already

  1063. 			 * consumed before the read, because we will add these back

  1064. 			 * in all at once at break1

  1065. 			 */

  1066. 		}

  1067. break1:

  1068. 		ucbits -= uval;

  1069. 		ucbits--; /* account for stop bit */

  1070. 

  1071. 		/* read binary part */

  1072. 		FLAC__ASSERT(cwords <= br->words);

  1073. 

  1074. 		if(parameter) {

  1075. 			while(ucbits < parameter) {

  1076. 				/* flush registers and read; bitreader_read_from_client_() does

  1077. 				 * not touch br->consumed_bits at all but we still need to set

  1078. 				 * it in case it fails and we have to return false.

  1079. 				 */

  1080. 				br->consumed_bits = cbits;

  1081. 				br->consumed_words = cwords;

  1082. 				if(!bitreader_read_from_client_(br))

  1083. 					return false;

  1084. 				cwords = br->consumed_words;

  1085. 				ucbits = (br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits;

  1086. 			}

  1087. 			if(cwords < br->words) { /* if we've not consumed up to a partial tail word... */

  1088. 				if(cbits) {

  1089. 					/* this also works when consumed_bits==0, it's just slower than necessary for that case */

  1090. 					const unsigned n = FLAC__BITS_PER_WORD - cbits;

  1091. 					const brword word = br->buffer[cwords];

  1092. 					if(parameter < n) {

  1093. 						uval <<= parameter;

  1094. 						uval |= (word & (FLAC__WORD_ALL_ONES >> cbits)) >> (n-parameter);

  1095. 						cbits += parameter;

  1096. 					}

  1097. 					else {

  1098. 						uval <<= n;

  1099. 						uval |= word & (FLAC__WORD_ALL_ONES >> cbits);

  1100. 						crc16_update_word_(br, word);

  1101. 						cwords++;

  1102. 						cbits = parameter - n;

  1103. 						if(cbits) { /* parameter > n, i.e. if there are still bits left to read, there have to be less than 32 so they will all be in the next word */

  1104. 							uval <<= cbits;

  1105. 							uval |= (br->buffer[cwords] >> (FLAC__BITS_PER_WORD-cbits));

  1106. 						}

  1107. 					}

  1108. 				}

  1109. 				else {

  1110. 					cbits = parameter;

  1111. 					uval <<= parameter;

  1112. 					uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-cbits);

  1113. 				}

  1114. 			}

  1115. 			else {

  1116. 				/* in this case we're starting our read at a partial tail word;

  1117. 				 * the reader has guaranteed that we have at least 'parameter'

  1118. 				 * bits available to read, which makes this case simpler.

  1119. 				 */

  1120. 				uval <<= parameter;

  1121. 				if(cbits) {

  1122. 					/* this also works when consumed_bits==0, it's just a little slower than necessary for that case */

  1123. 					FLAC__ASSERT(cbits + parameter <= br->bytes*8);

  1124. 					uval |= (br->buffer[cwords] & (FLAC__WORD_ALL_ONES >> cbits)) >> (FLAC__BITS_PER_WORD-cbits-parameter);

  1125. 					cbits += parameter;

  1126. 				}

  1127. 				else {

  1128. 					cbits = parameter;

  1129. 					uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-cbits);

  1130. 				}

  1131. 			}

  1132. 		}

  1133. 

  1134. 		ucbits -= parameter;

  1135. 

  1136. 		/* compose the value */

  1137. 		*vals = (int)(uval >> 1 ^ -(int)(uval & 1));

  1138. 

  1139. 		/* are we done? */

  1140. 		--nvals;

  1141. 		if(nvals == 0) {

  1142. 			br->consumed_bits = cbits;

  1143. 			br->consumed_words = cwords;

  1144. 			return true;

  1145. 		}

  1146. 

  1147. 		uval = 0;

  1148. 		++vals;

  1149. 

  1150. 	}

  1151. }

  1152. #endif

  1153. 

  1154. #if 0 /* UNUSED */

  1155. FLAC__bool FLAC__bitreader_read_golomb_signed(FLAC__BitReader *br, int *val, unsigned parameter)

  1156. {

  1157. 	FLAC__uint32 lsbs = 0, msbs = 0;

  1158. 	unsigned bit, uval, k;

  1159. 

  1160. 	FLAC__ASSERT(0 != br);

  1161. 	FLAC__ASSERT(0 != br->buffer);

  1162. 

  1163. 	k = FLAC__bitmath_ilog2(parameter);

  1164. 

  1165. 	/* read the unary MSBs and end bit */

  1166. 	if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))

  1167. 		return false;

  1168. 

  1169. 	/* read the binary LSBs */

  1170. 	if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))

  1171. 		return false;

  1172. 

  1173. 	if(parameter == 1u<<k) {

  1174. 		/* compose the value */

  1175. 		uval = (msbs << k) | lsbs;

  1176. 	}

  1177. 	else {

  1178. 		unsigned d = (1 << (k+1)) - parameter;

  1179. 		if(lsbs >= d) {

  1180. 			if(!FLAC__bitreader_read_bit(br, &bit))

  1181. 				return false;

  1182. 			lsbs <<= 1;

  1183. 			lsbs |= bit;

  1184. 			lsbs -= d;

  1185. 		}

  1186. 		/* compose the value */

  1187. 		uval = msbs * parameter + lsbs;

  1188. 	}

  1189. 

  1190. 	/* unfold unsigned to signed */

  1191. 	if(uval & 1)

  1192. 		*val = -((int)(uval >> 1)) - 1;

  1193. 	else

  1194. 		*val = (int)(uval >> 1);

  1195. 

  1196. 	return true;

  1197. }

  1198. 

  1199. FLAC__bool FLAC__bitreader_read_golomb_unsigned(FLAC__BitReader *br, unsigned *val, unsigned parameter)

  1200. {

  1201. 	FLAC__uint32 lsbs, msbs = 0;

  1202. 	unsigned bit, k;

  1203. 

  1204. 	FLAC__ASSERT(0 != br);

  1205. 	FLAC__ASSERT(0 != br->buffer);

  1206. 

  1207. 	k = FLAC__bitmath_ilog2(parameter);

  1208. 

  1209. 	/* read the unary MSBs and end bit */

  1210. 	if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))

  1211. 		return false;

  1212. 

  1213. 	/* read the binary LSBs */

  1214. 	if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))

  1215. 		return false;

  1216. 

  1217. 	if(parameter == 1u<<k) {

  1218. 		/* compose the value */

  1219. 		*val = (msbs << k) | lsbs;

  1220. 	}

  1221. 	else {

  1222. 		unsigned d = (1 << (k+1)) - parameter;

  1223. 		if(lsbs >= d) {

  1224. 			if(!FLAC__bitreader_read_bit(br, &bit))

  1225. 				return false;

  1226. 			lsbs <<= 1;

  1227. 			lsbs |= bit;

  1228. 			lsbs -= d;

  1229. 		}

  1230. 		/* compose the value */

  1231. 		*val = msbs * parameter + lsbs;

  1232. 	}

  1233. 

  1234. 	return true;

  1235. }

  1236. #endif /* UNUSED */

  1237. 

  1238. /* on return, if *val == 0xffffffff then the utf-8 sequence was invalid, but the return value will be true */

  1239. FLAC__bool FLAC__bitreader_read_utf8_uint32(FLAC__BitReader *br, FLAC__uint32 *val, FLAC__byte *raw, unsigned *rawlen)

  1240. {

  1241. 	FLAC__uint32 v = 0;

  1242. 	FLAC__uint32 x;

  1243. 	unsigned i;

  1244. 

  1245. 	if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))

  1246. 		return false;

  1247. 	if(raw)

  1248. 		raw[(*rawlen)++] = (FLAC__byte)x;

  1249. 	if(!(x & 0x80)) { /* 0xxxxxxx */

  1250. 		v = x;

  1251. 		i = 0;

  1252. 	}

  1253. 	else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */

  1254. 		v = x & 0x1F;

  1255. 		i = 1;

  1256. 	}

  1257. 	else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */

  1258. 		v = x & 0x0F;

  1259. 		i = 2;

  1260. 	}

  1261. 	else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */

  1262. 		v = x & 0x07;

  1263. 		i = 3;

  1264. 	}

  1265. 	else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */

  1266. 		v = x & 0x03;

  1267. 		i = 4;

  1268. 	}

  1269. 	else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */

  1270. 		v = x & 0x01;

  1271. 		i = 5;

  1272. 	}

  1273. 	else {

  1274. 		*val = 0xffffffff;

  1275. 		return true;

  1276. 	}

  1277. 	for( ; i; i--) {

  1278. 		if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))

  1279. 			return false;

  1280. 		if(raw)

  1281. 			raw[(*rawlen)++] = (FLAC__byte)x;

  1282. 		if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */

  1283. 			*val = 0xffffffff;

  1284. 			return true;

  1285. 		}

  1286. 		v <<= 6;

  1287. 		v |= (x & 0x3F);

  1288. 	}

  1289. 	*val = v;

  1290. 	return true;

  1291. }

  1292. 

  1293. /* on return, if *val == 0xffffffffffffffff then the utf-8 sequence was invalid, but the return value will be true */

  1294. FLAC__bool FLAC__bitreader_read_utf8_uint64(FLAC__BitReader *br, FLAC__uint64 *val, FLAC__byte *raw, unsigned *rawlen)

  1295. {

  1296. 	FLAC__uint64 v = 0;

  1297. 	FLAC__uint32 x;

  1298. 	unsigned i;

  1299. 

  1300. 	if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))

  1301. 		return false;

  1302. 	if(raw)

  1303. 		raw[(*rawlen)++] = (FLAC__byte)x;

  1304. 	if(!(x & 0x80)) { /* 0xxxxxxx */

  1305. 		v = x;

  1306. 		i = 0;

  1307. 	}

  1308. 	else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */

  1309. 		v = x & 0x1F;

  1310. 		i = 1;

  1311. 	}

  1312. 	else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */

  1313. 		v = x & 0x0F;

  1314. 		i = 2;

  1315. 	}

  1316. 	else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */

  1317. 		v = x & 0x07;

  1318. 		i = 3;

  1319. 	}

  1320. 	else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */

  1321. 		v = x & 0x03;

  1322. 		i = 4;

  1323. 	}

  1324. 	else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */

  1325. 		v = x & 0x01;

  1326. 		i = 5;

  1327. 	}

  1328. 	else if(x & 0xFE && !(x & 0x01)) { /* 11111110 */

  1329. 		v = 0;

  1330. 		i = 6;

  1331. 	}

  1332. 	else {

  1333. 		*val = FLAC__U64L(0xffffffffffffffff);

  1334. 		return true;

  1335. 	}

  1336. 	for( ; i; i--) {

  1337. 		if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))

  1338. 			return false;

  1339. 		if(raw)

  1340. 			raw[(*rawlen)++] = (FLAC__byte)x;

  1341. 		if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */

  1342. 			*val = FLAC__U64L(0xffffffffffffffff);

  1343. 			return true;

  1344. 		}

  1345. 		v <<= 6;

  1346. 		v |= (x & 0x3F);

  1347. 	}

  1348. 	*val = v;

  1349. 	return true;

  1350. }