/* libFLAC - Free Lossless Audio Codec library * Copyright (C) 2000-2009 Josh Coalson * Copyright (C) 2011-2022 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 "private/bitmath.h"#include "private/bitreader.h"#include "private/crc.h"#include "private/macros.h"#include "FLAC/assert.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 */#if WORDS_BIGENDIAN#define SWAP_BE_WORD_TO_HOST(x) (x)#else#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_32(x)#endif/* 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 */#if WORDS_BIGENDIAN#define SWAP_BE_WORD_TO_HOST(x) (x)#else#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x)#endif/* 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__bool read_limit_set; /* whether reads are limited */ uint32_t read_limit; /* the remaining size of what can be read */ uint32_t last_seen_framesync; /* the location of the last seen framesync, if it is in the buffer, in bits from front of buffer */ 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) { uint32_t shift = FLAC__BITS_PER_WORD - 8 - br->crc16_align ; crc = FLAC__CRC16_UPDATE ((uint32_t) (shift < FLAC__BITS_PER_WORD ? (word >> shift) & 0xff : 0), 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++]); /* Prevent OOB read due to wrap-around. */ if (br->consumed_words > 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, 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;#if WORDS_BIGENDIAN#else brword preswap_backup;#endif /* invalidate last seen framesync */ br->last_seen_framesync = -1; /* 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 WORDS_BIGENDIAN#else preswap_backup = br->buffer[br->words]; 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)){ /* Despite the read callback failing, the data in the target * might be used later, when the buffer is rewound. Therefore * we revert the swap that was just done */#if WORDS_BIGENDIAN#else br->buffer[br->words] = preswap_backup;#endif 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 + (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]);#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 + (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__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 = malloc(sizeof(brword) * br->capacity); if(br->buffer == 0) return false; br->read_callback = rcb; br->client_data = cd; br->read_limit_set = false; br->read_limit = -1; br->last_seen_framesync = -1; 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; br->read_limit_set = false; br->read_limit = -1; br->last_seen_framesync = -1;} FLAC__bool FLAC__bitreader_clear(FLAC__BitReader *br){ br->words = br->bytes = 0; br->consumed_words = br->consumed_bits = 0; br->read_limit_set = false; br->read_limit = -1; br->last_seen_framesync = -1; return true;} void FLAC__bitreader_set_framesync_location(FLAC__BitReader *br){ br->last_seen_framesync = br->consumed_words * FLAC__BYTES_PER_WORD + br->consumed_bits / 8;} FLAC__bool FLAC__bitreader_rewind_to_after_last_seen_framesync(FLAC__BitReader *br){ if(br->last_seen_framesync == (uint32_t)-1) { br->consumed_words = br->consumed_bits = 0; return false; } else { br->consumed_words = (br->last_seen_framesync + 1) / FLAC__BYTES_PER_WORD; br->consumed_bits = ((br->last_seen_framesync + 1) % FLAC__BYTES_PER_WORD) * 8; 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){ FLAC__ASSERT(0 != br); FLAC__ASSERT(0 != br->buffer); FLAC__ASSERT((br->consumed_bits & 7) == 0); 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){ FLAC__ASSERT(0 != br); FLAC__ASSERT(0 != br->buffer); /* CRC consumed words up to here */ crc16_update_block_(br); 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 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 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;} void FLAC__bitreader_set_limit(FLAC__BitReader *br, uint32_t limit){ br->read_limit = limit; br->read_limit_set = true;} void FLAC__bitreader_remove_limit(FLAC__BitReader *br){ br->read_limit_set = false; br->read_limit = -1;} uint32_t FLAC__bitreader_limit_remaining(FLAC__BitReader *br){ FLAC__ASSERT(br->read_limit_set); return br->read_limit;}void FLAC__bitreader_limit_invalidate(FLAC__BitReader *br){ br->read_limit = -1;} FLAC__bool FLAC__bitreader_read_raw_uint32(FLAC__BitReader *br, FLAC__uint32 *val, uint32_t 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; } if(br->read_limit_set && br->read_limit < (uint32_t)-1){ if(br->read_limit < bits) { br->read_limit = -1; return false; } else br->read_limit -= bits; } 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]; const brword mask = br->consumed_bits < FLAC__BITS_PER_WORD ? FLAC__WORD_ALL_ONES >> br->consumed_bits : 0; if(bits < n) { uint32_t shift = n - bits; *val = shift < FLAC__BITS_PER_WORD ? (FLAC__uint32)((word & mask) >> shift) : 0; /* 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 & mask); 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 */ uint32_t shift = FLAC__BITS_PER_WORD - bits; *val = bits < 32 ? *val << bits : 0; *val |= shift < FLAC__BITS_PER_WORD ? (FLAC__uint32)(br->buffer[br->consumed_words] >> shift) : 0; br->consumed_bits = bits; }Lines 1–500 of 1217. Load more
/* libFLAC - Free Lossless Audio Codec library * Copyright (C) 2000-2009 Josh Coalson * Copyright (C) 2011-2022 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 "private/bitmath.h" #include "private/bitreader.h" #include "private/crc.h" #include "private/macros.h" #include "FLAC/assert.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 */ #if WORDS_BIGENDIAN #define SWAP_BE_WORD_TO_HOST(x) (x) #else #define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_32(x) #endif /* 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 */ #if WORDS_BIGENDIAN #define SWAP_BE_WORD_TO_HOST(x) (x) #else #define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) #endif /* 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__bool read_limit_set; /* whether reads are limited */ uint32_t read_limit; /* the remaining size of what can be read */ uint32_t last_seen_framesync; /* the location of the last seen framesync, if it is in the buffer, in bits from front of buffer */ 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) { uint32_t shift = FLAC__BITS_PER_WORD - 8 - br->crc16_align ; crc = FLAC__CRC16_UPDATE ((uint32_t) (shift < FLAC__BITS_PER_WORD ? (word >> shift) & 0xff : 0), 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++]); /* Prevent OOB read due to wrap-around. */ if (br->consumed_words > 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, 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; #if WORDS_BIGENDIAN #else brword preswap_backup; #endif /* invalidate last seen framesync */ br->last_seen_framesync = -1; /* 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 WORDS_BIGENDIAN #else preswap_backup = br->buffer[br->words]; 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)){ /* Despite the read callback failing, the data in the target * might be used later, when the buffer is rewound. Therefore * we revert the swap that was just done */ #if WORDS_BIGENDIAN #else br->buffer[br->words] = preswap_backup; #endif 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 + (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]); #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 + (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__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 = malloc(sizeof(brword) * br->capacity); if(br->buffer == 0) return false; br->read_callback = rcb; br->client_data = cd; br->read_limit_set = false; br->read_limit = -1; br->last_seen_framesync = -1; 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; br->read_limit_set = false; br->read_limit = -1; br->last_seen_framesync = -1; } FLAC__bool FLAC__bitreader_clear(FLAC__BitReader *br) { br->words = br->bytes = 0; br->consumed_words = br->consumed_bits = 0; br->read_limit_set = false; br->read_limit = -1; br->last_seen_framesync = -1; return true; } void FLAC__bitreader_set_framesync_location(FLAC__BitReader *br) { br->last_seen_framesync = br->consumed_words * FLAC__BYTES_PER_WORD + br->consumed_bits / 8; } FLAC__bool FLAC__bitreader_rewind_to_after_last_seen_framesync(FLAC__BitReader *br) { if(br->last_seen_framesync == (uint32_t)-1) { br->consumed_words = br->consumed_bits = 0; return false; } else { br->consumed_words = (br->last_seen_framesync + 1) / FLAC__BYTES_PER_WORD; br->consumed_bits = ((br->last_seen_framesync + 1) % FLAC__BYTES_PER_WORD) * 8; 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) { FLAC__ASSERT(0 != br); FLAC__ASSERT(0 != br->buffer); FLAC__ASSERT((br->consumed_bits & 7) == 0); 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) { FLAC__ASSERT(0 != br); FLAC__ASSERT(0 != br->buffer); /* CRC consumed words up to here */ crc16_update_block_(br); 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 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 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; } void FLAC__bitreader_set_limit(FLAC__BitReader *br, uint32_t limit) { br->read_limit = limit; br->read_limit_set = true; } void FLAC__bitreader_remove_limit(FLAC__BitReader *br) { br->read_limit_set = false; br->read_limit = -1; } uint32_t FLAC__bitreader_limit_remaining(FLAC__BitReader *br) { FLAC__ASSERT(br->read_limit_set); return br->read_limit; } void FLAC__bitreader_limit_invalidate(FLAC__BitReader *br) { br->read_limit = -1; } FLAC__bool FLAC__bitreader_read_raw_uint32(FLAC__BitReader *br, FLAC__uint32 *val, uint32_t 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; } if(br->read_limit_set && br->read_limit < (uint32_t)-1){ if(br->read_limit < bits) { br->read_limit = -1; return false; } else br->read_limit -= bits; } 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]; const brword mask = br->consumed_bits < FLAC__BITS_PER_WORD ? FLAC__WORD_ALL_ONES >> br->consumed_bits : 0; if(bits < n) { uint32_t shift = n - bits; *val = shift < FLAC__BITS_PER_WORD ? (FLAC__uint32)((word & mask) >> shift) : 0; /* 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 & mask); 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 */ uint32_t shift = FLAC__BITS_PER_WORD - bits; *val = bits < 32 ? *val << bits : 0; *val |= shift < FLAC__BITS_PER_WORD ? (FLAC__uint32)(br->buffer[br->consumed_words] >> shift) : 0; br->consumed_bits = bits; }