/* 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) brword; #define FLAC__BYTES_PER_WORD … #define FLAC__BITS_PER_WORD … #define FLAC__WORD_ALL_ONES … /* 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 … #else #define SWAP_BE_WORD_TO_HOST(x) … #endif /* counts the # of zero MSBs in a word */ #define COUNT_ZERO_MSBS(word) … #define COUNT_ZERO_MSBS2(word) … #else typedef FLAC__uint64 brword; #define FLAC__BYTES_PER_WORD … #define FLAC__BITS_PER_WORD … #define FLAC__WORD_ALL_ONES … /* 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 … #else #define SWAP_BE_WORD_TO_HOST … #endif /* counts the # of zero MSBs in a word */ #define COUNT_ZERO_MSBS … #define COUNT_ZERO_MSBS2 … #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 = …; /* in words */ struct FLAC__BitReader { … }; static inline void crc16_update_word_(FLAC__BitReader *br, brword word) { … } static inline void crc16_update_block_(FLAC__BitReader *br) { … } static FLAC__bool bitreader_read_from_client_(FLAC__BitReader *br) { … } /*********************************************************************** * * Class constructor/destructor * ***********************************************************************/ FLAC__BitReader *FLAC__bitreader_new(void) { … } void FLAC__bitreader_delete(FLAC__BitReader *br) { … } /*********************************************************************** * * Public class methods * ***********************************************************************/ FLAC__bool FLAC__bitreader_init(FLAC__BitReader *br, FLAC__BitReaderReadCallback rcb, void *cd) { … } void FLAC__bitreader_free(FLAC__BitReader *br) { … } FLAC__bool FLAC__bitreader_clear(FLAC__BitReader *br) { … } void FLAC__bitreader_set_framesync_location(FLAC__BitReader *br) { … } FLAC__bool FLAC__bitreader_rewind_to_after_last_seen_framesync(FLAC__BitReader *br) { … } void FLAC__bitreader_dump(const FLAC__BitReader *br, FILE *out) { … } void FLAC__bitreader_reset_read_crc16(FLAC__BitReader *br, FLAC__uint16 seed) { … } FLAC__uint16 FLAC__bitreader_get_read_crc16(FLAC__BitReader *br) { … } inline FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br) { … } inline uint32_t FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br) { … } inline uint32_t FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br) { … } void FLAC__bitreader_set_limit(FLAC__BitReader *br, uint32_t limit) { … } void FLAC__bitreader_remove_limit(FLAC__BitReader *br) { … } uint32_t FLAC__bitreader_limit_remaining(FLAC__BitReader *br) { … } void FLAC__bitreader_limit_invalidate(FLAC__BitReader *br) { … } FLAC__bool FLAC__bitreader_read_raw_uint32(FLAC__BitReader *br, FLAC__uint32 *val, uint32_t bits) { … } FLAC__bool FLAC__bitreader_read_raw_int32(FLAC__BitReader *br, FLAC__int32 *val, uint32_t bits) { … } FLAC__bool FLAC__bitreader_read_raw_uint64(FLAC__BitReader *br, FLAC__uint64 *val, uint32_t bits) { … } FLAC__bool FLAC__bitreader_read_raw_int64(FLAC__BitReader *br, FLAC__int64 *val, uint32_t bits) { … } inline FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val) { … } FLAC__bool FLAC__bitreader_skip_bits_no_crc(FLAC__BitReader *br, uint32_t bits) { … } FLAC__bool FLAC__bitreader_skip_byte_block_aligned_no_crc(FLAC__BitReader *br, uint32_t nvals) { … } FLAC__bool FLAC__bitreader_read_byte_block_aligned_no_crc(FLAC__BitReader *br, FLAC__byte *val, uint32_t nvals) { … } FLAC__bool FLAC__bitreader_read_unary_unsigned(FLAC__BitReader *br, uint32_t *val) #if 0 /* slow but readable version */ { … } #endif #if 0 /* unused */ FLAC__bool FLAC__bitreader_read_rice_signed(FLAC__BitReader *br, int *val, uint32_t parameter) { FLAC__uint32 lsbs = 0, msbs = 0; uint32_t uval; FLAC__ASSERT(0 != br); FLAC__ASSERT(0 != br->buffer); FLAC__ASSERT(parameter <= 31); /* read the unary MSBs and end bit */ if(!FLAC__bitreader_read_unary_unsigned(br, &msbs)) return false; /* read the binary LSBs */ if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, parameter)) return false; /* compose the value */ uval = (msbs << parameter) | lsbs; if(uval & 1) *val = -((int)(uval >> 1)) - 1; else *val = (int)(uval >> 1); return true; } #endif /* this is by far the most heavily used reader call. it ain't pretty but it's fast */ FLAC__bool FLAC__bitreader_read_rice_signed_block(FLAC__BitReader *br, int vals[], uint32_t nvals, uint32_t parameter) { … } #if 0 /* UNUSED */ FLAC__bool FLAC__bitreader_read_golomb_signed(FLAC__BitReader *br, int *val, uint32_t parameter) { FLAC__uint32 lsbs = 0, msbs = 0; uint32_t bit, uval, k; FLAC__ASSERT(0 != br); FLAC__ASSERT(0 != br->buffer); k = FLAC__bitmath_ilog2(parameter); /* read the unary MSBs and end bit */ if(!FLAC__bitreader_read_unary_unsigned(br, &msbs)) return false; /* read the binary LSBs */ if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k)) return false; if(parameter == 1u<<k) { /* compose the value */ uval = (msbs << k) | lsbs; } else { uint32_t d = (1 << (k+1)) - parameter; if(lsbs >= d) { if(!FLAC__bitreader_read_bit(br, &bit)) return false; lsbs <<= 1; lsbs |= bit; lsbs -= d; } /* compose the value */ uval = msbs * parameter + lsbs; } /* unfold uint32_t to signed */ if(uval & 1) *val = -((int)(uval >> 1)) - 1; else *val = (int)(uval >> 1); return true; } FLAC__bool FLAC__bitreader_read_golomb_unsigned(FLAC__BitReader *br, uint32_t *val, uint32_t parameter) { FLAC__uint32 lsbs, msbs = 0; uint32_t bit, k; FLAC__ASSERT(0 != br); FLAC__ASSERT(0 != br->buffer); k = FLAC__bitmath_ilog2(parameter); /* read the unary MSBs and end bit */ if(!FLAC__bitreader_read_unary_unsigned(br, &msbs)) return false; /* read the binary LSBs */ if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k)) return false; if(parameter == 1u<<k) { /* compose the value */ *val = (msbs << k) | lsbs; } else { uint32_t d = (1 << (k+1)) - parameter; if(lsbs >= d) { if(!FLAC__bitreader_read_bit(br, &bit)) return false; lsbs <<= 1; lsbs |= bit; lsbs -= d; } /* compose the value */ *val = msbs * parameter + lsbs; } return true; } #endif /* UNUSED */ /* on return, if *val == 0xffffffff then the utf-8 sequence was invalid, but the return value will be true */ FLAC__bool FLAC__bitreader_read_utf8_uint32(FLAC__BitReader *br, FLAC__uint32 *val, FLAC__byte *raw, uint32_t *rawlen) { … } /* on return, if *val == 0xffffffffffffffff then the utf-8 sequence was invalid, but the return value will be true */ FLAC__bool FLAC__bitreader_read_utf8_uint64(FLAC__BitReader *br, FLAC__uint64 *val, FLAC__byte *raw, uint32_t *rawlen) { … } /* These functions are declared inline in this file but are also callable as * externs from elsewhere. * According to the C99 spec, section 6.7.4, simply providing a function * prototype in a header file without 'inline' and making the function inline * in this file should be sufficient. * Unfortunately, the Microsoft VS compiler doesn't pick them up externally. To * fix that we add extern declarations here. */ extern FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br); extern uint32_t FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br); extern uint32_t FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br); extern FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val);
Codebase Browser
chromium