/* libFLAC - Free Lossless Audio Codec library * Copyright (C) 2000-2009  Josh Coalson * Copyright (C) 2011-2018  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. */ #include <stdlib.h>#include <string.h>#include "private/bitmath.h"#include "private/bitreader.h"#include "private/crc.h"#include "private/macros.h"#include "share/compat.h"#include "share/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 COUNT_ZERO_MSBS2 below to match *//* WATCHOUT: there are a few places where the code will not work unless brword is >= 32 bits wide *//*           also, some sections currently only have fast versions for 4 or 8 bytes per word */ #if (ENABLE_64_BIT_WORDS == 0) typedef FLAC__uint32 brword;#define FLAC__BYTES_PER_WORD 4		/* sizeof brword */#define FLAC__BITS_PER_WORD 32#define FLAC__WORD_ALL_ONES ((FLAC__uint32)0xffffffff)/* SWAP_BE_WORD_TO_HOST swaps bytes in a brword (which is always big-endian) if necessary to match host byte order */#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_32(x)/* counts the # of zero MSBs in a word */#define COUNT_ZERO_MSBS(word) FLAC__clz_uint32(word)#define COUNT_ZERO_MSBS2(word) FLAC__clz2_uint32(word) #else typedef FLAC__uint64 brword;#define FLAC__BYTES_PER_WORD 8		/* sizeof brword */#define FLAC__BITS_PER_WORD 64#define FLAC__WORD_ALL_ONES ((FLAC__uint64)FLAC__U64L(0xffffffffffffffff))/* SWAP_BE_WORD_TO_HOST swaps bytes in a brword (which is always big-endian) if necessary to match host byte order */#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x)/* counts the # of zero MSBs in a word */#define COUNT_ZERO_MSBS(word) FLAC__clz_uint64(word)#define COUNT_ZERO_MSBS2(word) FLAC__clz2_uint64(word) #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 uint32_t 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 */	brword *buffer;	uint32_t capacity; /* in words */	uint32_t words; /* # of completed words in buffer */	uint32_t bytes; /* # of bytes in incomplete word at buffer[words] */	uint32_t consumed_words; /* #words ... */	uint32_t consumed_bits; /* ... + (#bits of head word) already consumed from the front of buffer */	uint32_t read_crc16; /* the running frame CRC */	uint32_t crc16_offset; /* the number of words in the current buffer that should not be CRC'd */	uint32_t 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, brword word){	register uint32_t crc = br->read_crc16; 	for( ; br->crc16_align < FLAC__BITS_PER_WORD; br->crc16_align += 8)		crc = FLAC__CRC16_UPDATE((uint32_t)((word >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), crc); 	br->read_crc16 = crc;	br->crc16_align = 0;} static inline void crc16_update_block_(FLAC__BitReader *br){	if(br->consumed_words > br->crc16_offset && br->crc16_align)		crc16_update_word_(br, br->buffer[br->crc16_offset++]); #if FLAC__BYTES_PER_WORD == 4	br->read_crc16 = FLAC__crc16_update_words32(br->buffer + br->crc16_offset, br->consumed_words - br->crc16_offset, (FLAC__uint16)br->read_crc16);#elif FLAC__BYTES_PER_WORD == 8	br->read_crc16 = FLAC__crc16_update_words64(br->buffer + br->crc16_offset, br->consumed_words - br->crc16_offset, br->read_crc16);#else	unsigned i; 	for(i = br->crc16_offset; i < br->consumed_words; i++)		crc16_update_word_(br, br->buffer[i]);#endif 	br->crc16_offset = 0;} static FLAC__bool bitreader_read_from_client_(FLAC__BitReader *br){	uint32_t 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) {		crc16_update_block_(br); /* CRC consumed words */ 		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 brword 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 laid 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(br->bytes)		br->buffer[br->words] = SWAP_BE_WORD_TO_HOST(br->buffer[br->words]); 	/* 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:	 */	end = (br->words*FLAC__BYTES_PER_WORD + br->bytes + (uint32_t)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]); 	/* 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 + (uint32_t)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 = 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__bitreader_free(br);	free(br);} /*********************************************************************** * * Public class methods * ***********************************************************************/ FLAC__bool FLAC__bitreader_init(FLAC__BitReader *br, FLAC__BitReaderReadCallback rcb, void *cd){	br->words = br->bytes = 0;	br->consumed_words = br->consumed_bits = 0;	br->capacity = FLAC__BITREADER_DEFAULT_CAPACITY;	br->buffer = malloc(sizeof(brword) * 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){	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){	uint32_t 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, "%01d", br->buffer[i] & ((brword)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, "%01d", br->buffer[i] & ((brword)1 << (br->bytes*8-j-1)) ? 1:0);			fprintf(out, "\n");		}	}} void FLAC__bitreader_reset_read_crc16(FLAC__BitReader *br, FLAC__uint16 seed){	br->read_crc16 = (uint32_t)seed;	br->crc16_offset = br->consumed_words;	br->crc16_align = br->consumed_bits;} FLAC__uint16 FLAC__bitreader_get_read_crc16(FLAC__BitReader *br){	/* CRC consumed words up to here */	crc16_update_block_(br); 	/* CRC any tail bytes in a partially-consumed word */	if(br->consumed_bits) {		const brword tail = br->buffer[br->consumed_words];		for( ; br->crc16_align < br->consumed_bits; br->crc16_align += 8)			br->read_crc16 = FLAC__CRC16_UPDATE((uint32_t)((tail >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), br->read_crc16);	}	return (FLAC__uint16)br->read_crc16;} inline FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br){	return ((br->consumed_bits & 7) == 0);} inline uint32_t FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br){	return 8 - (br->consumed_bits & 7);} inline uint32_t 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, uint32_t bits){	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 uint32_t n = FLAC__BITS_PER_WORD - br->consumed_bits;			const brword word = br->buffer[br->consumed_words];			if(bits < n) {				*val = (FLAC__uint32)((word & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (n-bits)); /* The result has <= 32 non-zero bits */				br->consumed_bits += bits;				return true;			}			/* (FLAC__BITS_PER_WORD - br->consumed_bits <= bits) ==> (FLAC__WORD_ALL_ONES >> br->consumed_bits) has no more than 'bits' non-zero bits */			*val = (FLAC__uint32)(word & (FLAC__WORD_ALL_ONES >> br->consumed_bits));			bits -= n;			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 |= (FLAC__uint32)(br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits));				br->consumed_bits = bits;			}			return true;		}		else { /* br->consumed_bits == 0 */			const brword word = br->buffer[br->consumed_words];			if(bits < FLAC__BITS_PER_WORD) {				*val = (FLAC__uint32)(word >> (FLAC__BITS_PER_WORD-bits));				br->consumed_bits = bits;				return true;			}			/* at this point bits == FLAC__BITS_PER_WORD == 32; because of previous assertions, it can't be larger */			*val = (FLAC__uint32)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 */			*val = (FLAC__uint32)((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 = (FLAC__uint32)(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, uint32_t bits){	FLAC__uint32 uval, mask;	/* OPT: inline raw uint32 code here, or make into a macro if possible in the .h file */	if(!FLAC__bitreader_read_raw_uint32(br, &uval, bits))		return false;	/* sign-extend *val assuming it is currently bits wide. */	/* From: https://graphics.stanford.edu/~seander/bithacks.html#FixedSignExtend */	mask = 1u << (bits - 1);	*val = (uval ^ mask) - mask;	return true;} FLAC__bool FLAC__bitreader_read_raw_uint64(FLAC__BitReader *br, FLAC__uint64 *val, uint32_t 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, uint32_t 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.	 */ 	if(bits > 0) {		const uint32_t n = br->consumed_bits & 7;		uint32_t 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, uint32_t nvals){	FLAC__uint32 x;

Lines 1–500 of 914. Load more