/* 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/bitwriter.h" #include "private/crc.h" #include "private/format.h" #include "private/macros.h" #include "private/stream_encoder.h" #include "FLAC/assert.h" #include "share/alloc.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 SWAP_BE_WORD_TO_HOST below to match */ /* WATCHOUT: there are a few places where the code will not work unless bwword is >= 32 bits wide */ #if (ENABLE_64_BIT_WORDS == 0) bwword; #define FLAC__BYTES_PER_WORD … #define FLAC__BITS_PER_WORD … /* SWAP_BE_WORD_TO_HOST swaps bytes in a bwword (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 #else typedef FLAC__uint64 bwword; #define FLAC__BYTES_PER_WORD … #define FLAC__BITS_PER_WORD … /* SWAP_BE_WORD_TO_HOST swaps bytes in a bwword (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 #endif /* * The default capacity here doesn't matter too much. The buffer always grows * to hold whatever is written to it. Usually the encoder will stop adding at * a frame or metadata block, then write that out and clear the buffer for the * next one. */ static const uint32_t FLAC__BITWRITER_DEFAULT_CAPACITY = …; /* size in words */ /* When growing, increment 4K at a time */ static const uint32_t FLAC__BITWRITER_DEFAULT_INCREMENT = …; /* size in words */ #define FLAC__WORDS_TO_BITS(words) … #define FLAC__TOTAL_BITS(bw) … struct FLAC__BitWriter { … }; /* * WATCHOUT: The current implementation only grows the buffer. */ #ifndef __SUNPRO_C static #endif FLAC__bool bitwriter_grow_(FLAC__BitWriter *bw, uint32_t bits_to_add) { … } /*********************************************************************** * * Class constructor/destructor * ***********************************************************************/ FLAC__BitWriter *FLAC__bitwriter_new(void) { … } void FLAC__bitwriter_delete(FLAC__BitWriter *bw) { … } /*********************************************************************** * * Public class methods * ***********************************************************************/ FLAC__bool FLAC__bitwriter_init(FLAC__BitWriter *bw) { … } void FLAC__bitwriter_free(FLAC__BitWriter *bw) { … } void FLAC__bitwriter_clear(FLAC__BitWriter *bw) { … } void FLAC__bitwriter_dump(const FLAC__BitWriter *bw, FILE *out) { … } FLAC__bool FLAC__bitwriter_get_write_crc16(FLAC__BitWriter *bw, FLAC__uint16 *crc) { … } FLAC__bool FLAC__bitwriter_get_write_crc8(FLAC__BitWriter *bw, FLAC__byte *crc) { … } FLAC__bool FLAC__bitwriter_is_byte_aligned(const FLAC__BitWriter *bw) { … } uint32_t FLAC__bitwriter_get_input_bits_unconsumed(const FLAC__BitWriter *bw) { … } FLAC__bool FLAC__bitwriter_get_buffer(FLAC__BitWriter *bw, const FLAC__byte **buffer, size_t *bytes) { … } void FLAC__bitwriter_release_buffer(FLAC__BitWriter *bw) { … } inline FLAC__bool FLAC__bitwriter_write_zeroes(FLAC__BitWriter *bw, uint32_t bits) { … } static inline FLAC__bool FLAC__bitwriter_write_raw_uint32_nocheck(FLAC__BitWriter *bw, FLAC__uint32 val, uint32_t bits) { … } inline FLAC__bool FLAC__bitwriter_write_raw_uint32(FLAC__BitWriter *bw, FLAC__uint32 val, uint32_t bits) { … } inline FLAC__bool FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int32 val, uint32_t bits) { … } inline FLAC__bool FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter *bw, FLAC__uint64 val, uint32_t bits) { … } inline FLAC__bool FLAC__bitwriter_write_raw_int64(FLAC__BitWriter *bw, FLAC__int64 val, uint32_t bits) { … } inline FLAC__bool FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter *bw, FLAC__uint32 val) { … } inline FLAC__bool FLAC__bitwriter_write_byte_block(FLAC__BitWriter *bw, const FLAC__byte vals[], uint32_t nvals) { … } FLAC__bool FLAC__bitwriter_write_unary_unsigned(FLAC__BitWriter *bw, uint32_t val) { … } uint32_t FLAC__bitwriter_rice_bits(FLAC__int32 val, uint32_t parameter) { … } #if 0 /* UNUSED */ uint32_t FLAC__bitwriter_golomb_bits_signed(int val, uint32_t parameter) { uint32_t bits, msbs, uval; uint32_t k; FLAC__ASSERT(parameter > 0); /* fold signed to uint32_t */ if(val < 0) uval = (uint32_t)(((-(++val)) << 1) + 1); else uval = (uint32_t)(val << 1); k = FLAC__bitmath_ilog2(parameter); if(parameter == 1u<<k) { FLAC__ASSERT(k <= 30); msbs = uval >> k; bits = 1 + k + msbs; } else { uint32_t q, r, d; d = (1 << (k+1)) - parameter; q = uval / parameter; r = uval - (q * parameter); bits = 1 + q + k; if(r >= d) bits++; } return bits; } uint32_t FLAC__bitwriter_golomb_bits_unsigned(uint32_t uval, uint32_t parameter) { uint32_t bits, msbs; uint32_t k; FLAC__ASSERT(parameter > 0); k = FLAC__bitmath_ilog2(parameter); if(parameter == 1u<<k) { FLAC__ASSERT(k <= 30); msbs = uval >> k; bits = 1 + k + msbs; } else { uint32_t q, r, d; d = (1 << (k+1)) - parameter; q = uval / parameter; r = uval - (q * parameter); bits = 1 + q + k; if(r >= d) bits++; } return bits; } #endif /* UNUSED */ FLAC__bool FLAC__bitwriter_write_rice_signed(FLAC__BitWriter *bw, FLAC__int32 val, uint32_t parameter) { … } FLAC__bool FLAC__bitwriter_write_rice_signed_block(FLAC__BitWriter *bw, const FLAC__int32 *vals, uint32_t nvals, uint32_t parameter) { … } #if 0 /* UNUSED */ FLAC__bool FLAC__bitwriter_write_golomb_signed(FLAC__BitWriter *bw, int val, uint32_t parameter) { uint32_t total_bits, msbs, uval; uint32_t k; FLAC__ASSERT(0 != bw); FLAC__ASSERT(0 != bw->buffer); FLAC__ASSERT(parameter > 0); /* fold signed to uint32_t */ if(val < 0) uval = (uint32_t)(((-(++val)) << 1) + 1); else uval = (uint32_t)(val << 1); k = FLAC__bitmath_ilog2(parameter); if(parameter == 1u<<k) { uint32_t pattern; FLAC__ASSERT(k <= 30); msbs = uval >> k; total_bits = 1 + k + msbs; pattern = 1 << k; /* the unary end bit */ pattern |= (uval & ((1u<<k)-1)); /* the binary LSBs */ if(total_bits <= 32) { if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, total_bits)) return false; } else { /* write the unary MSBs */ if(!FLAC__bitwriter_write_zeroes(bw, msbs)) return false; /* write the unary end bit and binary LSBs */ if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, k+1)) return false; } } else { uint32_t q, r, d; d = (1 << (k+1)) - parameter; q = uval / parameter; r = uval - (q * parameter); /* write the unary MSBs */ if(!FLAC__bitwriter_write_zeroes(bw, q)) return false; /* write the unary end bit */ if(!FLAC__bitwriter_write_raw_uint32(bw, 1, 1)) return false; /* write the binary LSBs */ if(r >= d) { if(!FLAC__bitwriter_write_raw_uint32(bw, r+d, k+1)) return false; } else { if(!FLAC__bitwriter_write_raw_uint32(bw, r, k)) return false; } } return true; } FLAC__bool FLAC__bitwriter_write_golomb_unsigned(FLAC__BitWriter *bw, uint32_t uval, uint32_t parameter) { uint32_t total_bits, msbs; uint32_t k; FLAC__ASSERT(0 != bw); FLAC__ASSERT(0 != bw->buffer); FLAC__ASSERT(parameter > 0); k = FLAC__bitmath_ilog2(parameter); if(parameter == 1u<<k) { uint32_t pattern; FLAC__ASSERT(k <= 30); msbs = uval >> k; total_bits = 1 + k + msbs; pattern = 1 << k; /* the unary end bit */ pattern |= (uval & ((1u<<k)-1)); /* the binary LSBs */ if(total_bits <= 32) { if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, total_bits)) return false; } else { /* write the unary MSBs */ if(!FLAC__bitwriter_write_zeroes(bw, msbs)) return false; /* write the unary end bit and binary LSBs */ if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, k+1)) return false; } } else { uint32_t q, r, d; d = (1 << (k+1)) - parameter; q = uval / parameter; r = uval - (q * parameter); /* write the unary MSBs */ if(!FLAC__bitwriter_write_zeroes(bw, q)) return false; /* write the unary end bit */ if(!FLAC__bitwriter_write_raw_uint32(bw, 1, 1)) return false; /* write the binary LSBs */ if(r >= d) { if(!FLAC__bitwriter_write_raw_uint32(bw, r+d, k+1)) return false; } else { if(!FLAC__bitwriter_write_raw_uint32(bw, r, k)) return false; } } return true; } #endif /* UNUSED */ FLAC__bool FLAC__bitwriter_write_utf8_uint32(FLAC__BitWriter *bw, FLAC__uint32 val) { … } FLAC__bool FLAC__bitwriter_write_utf8_uint64(FLAC__BitWriter *bw, FLAC__uint64 val) { … } FLAC__bool FLAC__bitwriter_zero_pad_to_byte_boundary(FLAC__BitWriter *bw) { … } /* 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__bitwriter_write_zeroes(FLAC__BitWriter *bw, uint32_t bits); extern FLAC__bool FLAC__bitwriter_write_raw_uint32(FLAC__BitWriter *bw, FLAC__uint32 val, uint32_t bits); extern FLAC__bool FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int32 val, uint32_t bits); extern FLAC__bool FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter *bw, FLAC__uint64 val, uint32_t bits); extern FLAC__bool FLAC__bitwriter_write_raw_int64(FLAC__BitWriter *bw, FLAC__int64 val, uint32_t bits); extern FLAC__bool FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter *bw, FLAC__uint32 val); extern FLAC__bool FLAC__bitwriter_write_byte_block(FLAC__BitWriter *bw, const FLAC__byte vals[], uint32_t nvals);
Codebase Browser
chromium