From 1b68982b0e24cd4a24780a2dece42e50b9186517 Mon Sep 17 00:00:00 2001 From: Josh Coalson Date: Thu, 31 May 2001 20:11:02 +0000 Subject: [PATCH] put a FLAC__ASSERT wrapper around assert() --- include/FLAC/Makefile.am | 1 + include/FLAC/all.h | 1 + include/FLAC/assert.h | 31 +++++ src/flac/analyze.c | 1 - src/flac/decode.c | 7 +- src/flac/encode.c | 11 +- src/flac/main.c | 3 +- src/libFLAC/bitbuffer.c | 226 +++++++++++++++++---------------- src/libFLAC/bitmath.c | 4 +- src/libFLAC/encoder.c | 70 +++++----- src/libFLAC/encoder_framing.c | 54 ++++---- src/libFLAC/file_decoder.c | 40 +++--- src/libFLAC/fixed.c | 6 +- src/libFLAC/format.c | 1 - src/libFLAC/i386/lpc_asm.s | 6 +- src/libFLAC/lpc.c | 36 +++--- src/libFLAC/md5.c | 1 - src/libFLAC/memory.c | 36 +++--- src/libFLAC/seek_table.c | 1 - src/libFLAC/stream_decoder.c | 88 ++++++------- src/metaflac/main.c | 3 +- src/plugin_winamp2/in_flac.c | 3 +- src/plugin_winamp3/in_flac.cpp | 4 +- src/plugin_xmms/plugin.c | 3 +- src/test_streams/main.c | 8 +- 25 files changed, 337 insertions(+), 308 deletions(-) create mode 100644 include/FLAC/assert.h diff --git a/include/FLAC/Makefile.am b/include/FLAC/Makefile.am index 89c5b677..172f5bbc 100644 --- a/include/FLAC/Makefile.am +++ b/include/FLAC/Makefile.am @@ -1,6 +1,7 @@ includedir = ${prefix}/include/FLAC include_HEADERS = all.h \ + assert.h \ encoder.h \ file_decoder.h \ format.h \ diff --git a/include/FLAC/all.h b/include/FLAC/all.h index 154b8e68..cc19d242 100644 --- a/include/FLAC/all.h +++ b/include/FLAC/all.h @@ -20,6 +20,7 @@ #ifndef FLAC__ALL_H #define FLAC__ALL_H +#include "assert.h" #include "encoder.h" #include "file_decoder.h" #include "format.h" diff --git a/include/FLAC/assert.h b/include/FLAC/assert.h new file mode 100644 index 00000000..ed626bce --- /dev/null +++ b/include/FLAC/assert.h @@ -0,0 +1,31 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2001 Josh Coalson + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef FLAC__ASSERT_H +#define FLAC__ASSERT_H + +/* we need this since some compilers (like MSVC) leave asserts on release code (and we don't want to use their ASSERT) */ +#ifdef DEBUG +#include +#define FLAC__ASSERT(x) assert(x) +#else +#define FLAC__ASSERT(x) +#endif + +#endif diff --git a/src/flac/analyze.c b/src/flac/analyze.c index 231d92fb..714739b5 100644 --- a/src/flac/analyze.c +++ b/src/flac/analyze.c @@ -16,7 +16,6 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -#include #include #include #include diff --git a/src/flac/decode.c b/src/flac/decode.c index 21558b80..1ff54298 100644 --- a/src/flac/decode.c +++ b/src/flac/decode.c @@ -22,7 +22,6 @@ #else # include #endif -#include /* for FILE */ #include /* for FILE */ #include /* for strcmp() */ #include "FLAC/all.h" @@ -78,7 +77,7 @@ int decode_wav(const char *infile, const char *outfile, bool analysis_mode, anal stream_info.frame_counter = 0; stream_info.fout = 0; /* initialized with an open file later if necessary */ - assert(!(stream_info.test_only && stream_info.analysis_mode)); + FLAC__ASSERT(!(stream_info.test_only && stream_info.analysis_mode)); if(!stream_info.test_only) { if(0 == strcmp(outfile, "-")) { @@ -191,7 +190,7 @@ int decode_raw(const char *infile, const char *outfile, bool analysis_mode, anal stream_info.frame_counter = 0; stream_info.fout = 0; /* initialized with an open file later if necessary */ - assert(!(stream_info.test_only && stream_info.analysis_mode)); + FLAC__ASSERT(!(stream_info.test_only && stream_info.analysis_mode)); if(!stream_info.test_only) { if(0 == strcmp(outfile, "-")) { @@ -441,7 +440,7 @@ FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, return FLAC__STREAM_DECODER_WRITE_ABORT; } else { - assert(0); + FLAC__ASSERT(0); } } return FLAC__STREAM_DECODER_WRITE_CONTINUE; diff --git a/src/flac/encode.c b/src/flac/encode.c index 7bed2f2e..b0d3fd2e 100644 --- a/src/flac/encode.c +++ b/src/flac/encode.c @@ -18,7 +18,6 @@ /*@@@ need to "_finish()" the verify decoder */ -#include #if defined _WIN32 && !defined __CYGWIN__ /* where MSVC puts unlink() */ # include @@ -592,7 +591,7 @@ bool convert_to_seek_table(char *requested_seek_points, int num_requested_seek_p real_points = placeholders = 0; for(i = 0; i < (unsigned)num_requested_seek_points; i++) { q = strchr(pt, '<'); - assert(0 != q); + FLAC__ASSERT(0 != q); *q = '\0'; if(0 == strcmp(pt, "X")) { /* -S X */ @@ -624,7 +623,7 @@ bool convert_to_seek_table(char *requested_seek_points, int num_requested_seek_p for(i = 0; i < (unsigned)num_requested_seek_points; i++) { q = strchr(pt, '<'); - assert(0 != q); + FLAC__ASSERT(0 != q); *q++ = '\0'; if(0 == strcmp(pt, "X")) { /* -S X */ @@ -753,14 +752,14 @@ void format_input(unsigned wide_samples, bool is_big_endian, bool is_unsigned_sa } } else { - assert(0); + FLAC__ASSERT(0); } if(encoder_wrapper->verify) { for(channel = 0; channel < channels; channel++) memcpy(&encoder_wrapper->verify_fifo.original[channel][encoder_wrapper->verify_fifo.tail], &input[channel][0], sizeof(int32) * wide_samples); encoder_wrapper->verify_fifo.tail += wide_samples; - assert(encoder_wrapper->verify_fifo.tail <= encoder_wrapper->verify_fifo.size); + FLAC__ASSERT(encoder_wrapper->verify_fifo.tail <= encoder_wrapper->verify_fifo.size); } } @@ -829,7 +828,7 @@ void metadata_callback(const FLAC__Encoder *encoder, const FLAC__StreamMetaData const unsigned min_framesize = metadata->data.stream_info.min_framesize; const unsigned max_framesize = metadata->data.stream_info.max_framesize; - assert(metadata->type == FLAC__METADATA_TYPE_STREAMINFO); + FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO); /* * we get called by the encoder when the encoding process has diff --git a/src/flac/main.c b/src/flac/main.c index 76864266..e702a5db 100644 --- a/src/flac/main.c +++ b/src/flac/main.c @@ -16,7 +16,6 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -#include #include #include #include @@ -290,7 +289,7 @@ int main(int argc, char *argv[]) } } - assert(blocksize >= 0 || mode_decode); + FLAC__ASSERT(blocksize >= 0 || mode_decode); if(format_channels >= 0) { if(format_channels == 0 || (unsigned)format_channels > FLAC__MAX_CHANNELS) diff --git a/src/libFLAC/bitbuffer.c b/src/libFLAC/bitbuffer.c index 1eb32df6..05b53fce 100644 --- a/src/libFLAC/bitbuffer.c +++ b/src/libFLAC/bitbuffer.c @@ -17,12 +17,12 @@ * Boston, MA 02111-1307, USA. */ -#include #include /* for malloc() */ #include /* for memcpy(), memset() */ #include "private/bitbuffer.h" #include "private/bitmath.h" #include "private/crc.h" +#include "FLAC/assert.h" /* * Along the way you will see two versions of some functions, selected @@ -50,8 +50,8 @@ static bool bitbuffer_resize_(FLAC__BitBuffer *bb, unsigned new_capacity) { byte *new_buffer; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); if(bb->capacity == new_capacity) return true; @@ -80,7 +80,7 @@ static bool bitbuffer_grow_(FLAC__BitBuffer *bb, unsigned min_bytes_to_add) { unsigned new_capacity; - assert(min_bytes_to_add > 0); + FLAC__ASSERT(min_bytes_to_add > 0); new_capacity = max(bb->capacity * 4, bb->capacity + min_bytes_to_add); return bitbuffer_resize_(bb, new_capacity); @@ -88,8 +88,8 @@ static bool bitbuffer_grow_(FLAC__BitBuffer *bb, unsigned min_bytes_to_add) static bool bitbuffer_ensure_size_(FLAC__BitBuffer *bb, unsigned bits_to_add) { - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); if((bb->capacity<<3) < bb->total_bits + bits_to_add) return bitbuffer_grow_(bb, (bits_to_add>>3)+2); else @@ -128,7 +128,8 @@ static bool bitbuffer_read_from_client_(FLAC__BitBuffer *bb, bool (*read_callbac void FLAC__bitbuffer_init(FLAC__BitBuffer *bb) { - assert(bb != 0); + FLAC__ASSERT(bb != 0); + bb->buffer = 0; bb->capacity = 0; bb->bytes = bb->bits = bb->total_bits = 0; @@ -137,12 +138,13 @@ void FLAC__bitbuffer_init(FLAC__BitBuffer *bb) bool FLAC__bitbuffer_init_from(FLAC__BitBuffer *bb, const byte buffer[], unsigned bytes) { - assert(bb != 0); + FLAC__ASSERT(bb != 0); FLAC__bitbuffer_init(bb); + if(bytes == 0) return true; else { - assert(buffer != 0); + FLAC__ASSERT(buffer != 0); bb->buffer = (byte*)malloc(sizeof(byte)*bytes); if(bb->buffer == 0) return false; @@ -157,7 +159,7 @@ bool FLAC__bitbuffer_init_from(FLAC__BitBuffer *bb, const byte buffer[], unsigne void FLAC__bitbuffer_init_read_crc16(FLAC__BitBuffer *bb, uint16 seed) { - assert(bb != 0); + FLAC__ASSERT(bb != 0); bb->read_crc16 = seed; } @@ -167,8 +169,8 @@ bool FLAC__bitbuffer_concatenate_aligned(FLAC__BitBuffer *dest, const FLAC__BitB static const byte mask_[9] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff }; unsigned bits_to_add = src->total_bits - src->total_consumed_bits; - assert(dest != 0); - assert(src != 0); + FLAC__ASSERT(dest != 0); + FLAC__ASSERT(src != 0); if(bits_to_add == 0) return true; @@ -197,7 +199,8 @@ bool FLAC__bitbuffer_concatenate_aligned(FLAC__BitBuffer *dest, const FLAC__BitB void FLAC__bitbuffer_free(FLAC__BitBuffer *bb) { - assert(bb != 0); + FLAC__ASSERT(bb != 0); + if(bb->buffer != 0) free(bb->buffer); bb->buffer = 0; @@ -243,8 +246,8 @@ bool FLAC__bitbuffer_write_zeroes(FLAC__BitBuffer *bb, unsigned bits) { unsigned n, k; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); if(bits == 0) return true; @@ -269,14 +272,17 @@ bool FLAC__bitbuffer_write_raw_uint32(FLAC__BitBuffer *bb, uint32 val, unsigned { unsigned n, k; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); - assert(bits <= 32); + FLAC__ASSERT(bits <= 32); if(bits == 0) return true; - if(!bitbuffer_ensure_size_(bb, bits)) - return false; + /* inline the size check so we don't incure a function call unnecessarily */ + if((bb->capacity<<3) < bb->total_bits + bits) { + if(!bitbuffer_ensure_size_(bb, bits)) + return false; + } if(bits < 32) /* @@@ gcc seems to require this because the following line causes incorrect results when bits==32; investigate */ val &= (~(0xffffffff << bits)); /* zero-out unused bits */ bb->total_bits += bits; @@ -352,10 +358,10 @@ bool FLAC__bitbuffer_write_raw_uint64(FLAC__BitBuffer *bb, uint64 val, unsigned }; unsigned n, k; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); - assert(bits <= 64); + FLAC__ASSERT(bits <= 64); if(bits == 0) return true; if(!bitbuffer_ensure_size_(bb, bits)) @@ -440,7 +446,7 @@ unsigned FLAC__bitbuffer_golomb_bits_signed(int val, unsigned parameter) unsigned bits, msbs, uval; unsigned k; - assert(parameter > 0); + FLAC__ASSERT(parameter > 0); /* convert signed to unsigned */ if(val < 0) @@ -454,7 +460,7 @@ unsigned FLAC__bitbuffer_golomb_bits_signed(int val, unsigned parameter) k = FLAC__bitmath_ilog2(parameter); if(parameter == 1u<> k; bits = 1 + k + msbs; @@ -478,11 +484,11 @@ unsigned FLAC__bitbuffer_golomb_bits_unsigned(unsigned uval, unsigned parameter) unsigned bits, msbs; unsigned k; - assert(parameter > 0); + FLAC__ASSERT(parameter > 0); k = FLAC__bitmath_ilog2(parameter); if(parameter == 1u<> k; bits = 1 + k + msbs; @@ -506,9 +512,9 @@ bool FLAC__bitbuffer_write_symmetric_rice_signed(FLAC__BitBuffer *bb, int val, u unsigned total_bits, interesting_bits, msbs; uint32 pattern; - assert(bb != 0); - assert(bb->buffer != 0); - assert(parameter <= 31); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); + FLAC__ASSERT(parameter <= 31); /* init pattern with the unary end bit and the sign bit */ if(val < 0) { @@ -544,9 +550,9 @@ bool FLAC__bitbuffer_write_symmetric_rice_signed_guarded(FLAC__BitBuffer *bb, in unsigned total_bits, interesting_bits, msbs; uint32 pattern; - assert(bb != 0); - assert(bb->buffer != 0); - assert(parameter <= 31); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); + FLAC__ASSERT(parameter <= 31); *overflow = false; @@ -588,9 +594,9 @@ bool FLAC__bitbuffer_write_symmetric_rice_signed_escape(FLAC__BitBuffer *bb, int unsigned total_bits, val_bits; uint32 pattern; - assert(bb != 0); - assert(bb->buffer != 0); - assert(parameter <= 31); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); + FLAC__ASSERT(parameter <= 31); val_bits = FLAC__bitmath_silog2(val); total_bits = 2 + parameter + 5 + val_bits; @@ -623,9 +629,9 @@ bool FLAC__bitbuffer_write_rice_signed(FLAC__BitBuffer *bb, int val, unsigned pa unsigned total_bits, interesting_bits, msbs, uval; uint32 pattern; - assert(bb != 0); - assert(bb->buffer != 0); - assert(parameter <= 30); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); + FLAC__ASSERT(parameter <= 30); /* convert signed to unsigned */ if(val < 0) @@ -663,9 +669,9 @@ bool FLAC__bitbuffer_write_rice_signed_guarded(FLAC__BitBuffer *bb, int val, uns unsigned total_bits, interesting_bits, msbs, uval; uint32 pattern; - assert(bb != 0); - assert(bb->buffer != 0); - assert(parameter <= 30); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); + FLAC__ASSERT(parameter <= 30); *overflow = false; @@ -709,9 +715,9 @@ bool FLAC__bitbuffer_write_golomb_signed(FLAC__BitBuffer *bb, int val, unsigned unsigned total_bits, msbs, uval; unsigned k; - assert(bb != 0); - assert(bb->buffer != 0); - assert(parameter > 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); + FLAC__ASSERT(parameter > 0); /* convert signed to unsigned */ if(val < 0) @@ -727,7 +733,7 @@ bool FLAC__bitbuffer_write_golomb_signed(FLAC__BitBuffer *bb, int val, unsigned if(parameter == 1u<> k; total_bits = 1 + k + msbs; @@ -777,15 +783,15 @@ bool FLAC__bitbuffer_write_golomb_unsigned(FLAC__BitBuffer *bb, unsigned uval, u unsigned total_bits, msbs; unsigned k; - assert(bb != 0); - assert(bb->buffer != 0); - assert(parameter > 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); + FLAC__ASSERT(parameter > 0); k = FLAC__bitmath_ilog2(parameter); if(parameter == 1u<> k; total_bits = 1 + k + msbs; @@ -834,10 +840,10 @@ bool FLAC__bitbuffer_write_utf8_uint32(FLAC__BitBuffer *bb, uint32 val) { bool ok = 1; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); - assert(!(val & 0x80000000)); /* this version only handles 31 bits */ + FLAC__ASSERT(!(val & 0x80000000)); /* this version only handles 31 bits */ if(val < 0x80) { return FLAC__bitbuffer_write_raw_uint32(bb, val, 8); @@ -880,10 +886,10 @@ bool FLAC__bitbuffer_write_utf8_uint64(FLAC__BitBuffer *bb, uint64 val) { bool ok = 1; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); - assert(!(val & 0xFFFFFFF000000000)); /* this version only handles 36 bits */ + FLAC__ASSERT(!(val & 0xFFFFFFF000000000)); /* this version only handles 36 bits */ if(val < 0x80) { return FLAC__bitbuffer_write_raw_uint32(bb, (uint32)val, 8); @@ -943,9 +949,9 @@ bool FLAC__bitbuffer_zero_pad_to_byte_boundary(FLAC__BitBuffer *bb) bool FLAC__bitbuffer_peek_bit(FLAC__BitBuffer *bb, unsigned *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data) { /* to avoid a drastic speed penalty we don't: - assert(bb != 0); - assert(bb->buffer != 0); - assert(bb->bits == 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); + FLAC__ASSERT(bb->bits == 0); */ while(1) { @@ -963,9 +969,9 @@ bool FLAC__bitbuffer_peek_bit(FLAC__BitBuffer *bb, unsigned *val, bool (*read_ca bool FLAC__bitbuffer_read_bit(FLAC__BitBuffer *bb, unsigned *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data) { /* to avoid a drastic speed penalty we don't: - assert(bb != 0); - assert(bb->buffer != 0); - assert(bb->bits == 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); + FLAC__ASSERT(bb->bits == 0); */ while(1) { @@ -990,9 +996,9 @@ bool FLAC__bitbuffer_read_bit(FLAC__BitBuffer *bb, unsigned *val, bool (*read_ca bool FLAC__bitbuffer_read_bit_to_uint32(FLAC__BitBuffer *bb, uint32 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data) { /* to avoid a drastic speed penalty we don't: - assert(bb != 0); - assert(bb->buffer != 0); - assert(bb->bits == 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); + FLAC__ASSERT(bb->bits == 0); */ while(1) { @@ -1018,9 +1024,9 @@ bool FLAC__bitbuffer_read_bit_to_uint32(FLAC__BitBuffer *bb, uint32 *val, bool ( bool FLAC__bitbuffer_read_bit_to_uint64(FLAC__BitBuffer *bb, uint64 *val, bool (*read_callback)(byte buffer[], unsigned *bytes, void *client_data), void *client_data) { /* to avoid a drastic speed penalty we don't: - assert(bb != 0); - assert(bb->buffer != 0); - assert(bb->bits == 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); + FLAC__ASSERT(bb->bits == 0); */ while(1) { @@ -1048,10 +1054,10 @@ bool FLAC__bitbuffer_read_raw_uint32(FLAC__BitBuffer *bb, uint32 *val, const uns { unsigned i; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); - assert(bits <= 32); + FLAC__ASSERT(bits <= 32); *val = 0; for(i = 0; i < bits; i++) { @@ -1065,11 +1071,11 @@ bool FLAC__bitbuffer_read_raw_uint32(FLAC__BitBuffer *bb, uint32 *val, const uns unsigned i, bits_ = bits; uint32 v = 0; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); - assert(bits <= 32); - assert((bb->capacity*8) * 2 >= bits); + FLAC__ASSERT(bits <= 32); + FLAC__ASSERT((bb->capacity*8) * 2 >= bits); while(bb->total_consumed_bits + bits > bb->total_bits) { if(!bitbuffer_read_from_client_(bb, read_callback, client_data)) @@ -1119,10 +1125,10 @@ bool FLAC__bitbuffer_read_raw_int32(FLAC__BitBuffer *bb, int32 *val, const unsig unsigned i; uint32 v; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); - assert(bits <= 32); + FLAC__ASSERT(bits <= 32); v = 0; for(i = 0; i < bits; i++) { @@ -1147,11 +1153,11 @@ bool FLAC__bitbuffer_read_raw_int32(FLAC__BitBuffer *bb, int32 *val, const unsig unsigned i, bits_ = bits; uint32 v = 0; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); - assert(bits <= 32); - assert((bb->capacity*8) * 2 >= bits); + FLAC__ASSERT(bits <= 32); + FLAC__ASSERT((bb->capacity*8) * 2 >= bits); while(bb->total_consumed_bits + bits > bb->total_bits) { if(!bitbuffer_read_from_client_(bb, read_callback, client_data)) @@ -1214,10 +1220,10 @@ bool FLAC__bitbuffer_read_raw_uint64(FLAC__BitBuffer *bb, uint64 *val, const uns { unsigned i; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); - assert(bits <= 64); + FLAC__ASSERT(bits <= 64); *val = 0; for(i = 0; i < bits; i++) { @@ -1231,11 +1237,11 @@ bool FLAC__bitbuffer_read_raw_uint64(FLAC__BitBuffer *bb, uint64 *val, const uns unsigned i, bits_ = bits; uint64 v = 0; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); - assert(bits <= 64); - assert((bb->capacity*8) * 2 >= bits); + FLAC__ASSERT(bits <= 64); + FLAC__ASSERT((bb->capacity*8) * 2 >= bits); while(bb->total_consumed_bits + bits > bb->total_bits) { if(!bitbuffer_read_from_client_(bb, read_callback, client_data)) @@ -1285,10 +1291,10 @@ bool FLAC__bitbuffer_read_raw_int64(FLAC__BitBuffer *bb, int64 *val, const unsig unsigned i; uint64 v; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); - assert(bits <= 64); + FLAC__ASSERT(bits <= 64); v = 0; for(i = 0; i < bits; i++) { @@ -1312,11 +1318,11 @@ bool FLAC__bitbuffer_read_raw_int64(FLAC__BitBuffer *bb, int64 *val, const unsig unsigned i, bits_ = bits; uint64 v = 0; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); - assert(bits <= 64); - assert((bb->capacity*8) * 2 >= bits); + FLAC__ASSERT(bits <= 64); + FLAC__ASSERT((bb->capacity*8) * 2 >= bits); while(bb->total_consumed_bits + bits > bb->total_bits) { if(!bitbuffer_read_from_client_(bb, read_callback, client_data)) @@ -1379,8 +1385,8 @@ bool FLAC__bitbuffer_read_unary_unsigned(FLAC__BitBuffer *bb, unsigned *val, boo { unsigned bit, val_ = 0; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); while(1) { if(!FLAC__bitbuffer_read_bit(bb, &bit, read_callback, client_data)) @@ -1399,8 +1405,8 @@ bool FLAC__bitbuffer_read_unary_unsigned(FLAC__BitBuffer *bb, unsigned *val, boo unsigned total_bytes_ = (bb->total_bits + 7) / 8; byte b; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); if(bb->consumed_bits) { b = bb->buffer[bb->consumed_bytes] << bb->consumed_bits; @@ -1464,9 +1470,9 @@ bool FLAC__bitbuffer_read_symmetric_rice_signed(FLAC__BitBuffer *bb, int *val, u { uint32 sign = 0, lsbs = 0, msbs = 0; - assert(bb != 0); - assert(bb->buffer != 0); - assert(parameter <= 31); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); + FLAC__ASSERT(parameter <= 31); /* read the unary MSBs and end bit */ if(!FLAC__bitbuffer_read_unary_unsigned(bb, &msbs, read_callback, client_data)) @@ -1493,9 +1499,9 @@ bool FLAC__bitbuffer_read_rice_signed(FLAC__BitBuffer *bb, int *val, unsigned pa uint32 lsbs = 0, msbs = 0; unsigned uval; - assert(bb != 0); - assert(bb->buffer != 0); - assert(parameter <= 31); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); + FLAC__ASSERT(parameter <= 31); /* read the unary MSBs and end bit */ if(!FLAC__bitbuffer_read_unary_unsigned(bb, &msbs, read_callback, client_data)) @@ -1520,8 +1526,8 @@ bool FLAC__bitbuffer_read_golomb_signed(FLAC__BitBuffer *bb, int *val, unsigned uint32 lsbs = 0, msbs = 0; unsigned bit, uval, k; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); k = FLAC__bitmath_ilog2(parameter); @@ -1564,8 +1570,8 @@ bool FLAC__bitbuffer_read_golomb_unsigned(FLAC__BitBuffer *bb, unsigned *val, un uint32 lsbs, msbs = 0; unsigned bit, k; - assert(bb != 0); - assert(bb->buffer != 0); + FLAC__ASSERT(bb != 0); + FLAC__ASSERT(bb->buffer != 0); k = FLAC__bitmath_ilog2(parameter); diff --git a/src/libFLAC/bitmath.c b/src/libFLAC/bitmath.c index 009f43c4..44ef3f1c 100644 --- a/src/libFLAC/bitmath.c +++ b/src/libFLAC/bitmath.c @@ -17,13 +17,13 @@ * Boston, MA 02111-1307, USA. */ -#include #include "private/bitmath.h" +#include "FLAC/assert.h" unsigned FLAC__bitmath_ilog2(unsigned v) { unsigned l = 0; - assert(v > 0); + FLAC__ASSERT(v > 0); while(v >>= 1) l++; return l; diff --git a/src/libFLAC/encoder.c b/src/libFLAC/encoder.c index 635b5d4d..137c9599 100644 --- a/src/libFLAC/encoder.c +++ b/src/libFLAC/encoder.c @@ -17,10 +17,10 @@ * Boston, MA 02111-1307, USA. */ -#include #include #include /* for malloc() */ #include /* for memcpy() */ +#include "FLAC/assert.h" #include "FLAC/encoder.h" #include "FLAC/seek_table.h" #include "private/bitbuffer.h" @@ -139,9 +139,9 @@ bool encoder_resize_buffers_(FLAC__Encoder *encoder, unsigned new_size) bool ok; unsigned i, channel; - assert(new_size > 0); - assert(encoder->state == FLAC__ENCODER_OK); - assert(encoder->guts->current_sample_number == 0); + FLAC__ASSERT(new_size > 0); + FLAC__ASSERT(encoder->state == FLAC__ENCODER_OK); + FLAC__ASSERT(encoder->guts->current_sample_number == 0); /* To avoid excessive malloc'ing, we only grow the buffer; no shrinking. */ if(new_size <= encoder->guts->input_capacity) @@ -194,7 +194,7 @@ FLAC__Encoder *FLAC__encoder_get_new_instance() void FLAC__encoder_free_instance(FLAC__Encoder *encoder) { - assert(encoder != 0); + FLAC__ASSERT(encoder != 0); free(encoder); } @@ -204,12 +204,12 @@ FLAC__EncoderState FLAC__encoder_init(FLAC__Encoder *encoder, FLAC__EncoderWrite FLAC__StreamMetaData padding; FLAC__StreamMetaData seek_table; - assert(sizeof(int) >= 4); /* we want to die right away if this is not true */ - assert(encoder != 0); - assert(write_callback != 0); - assert(metadata_callback != 0); - assert(encoder->state == FLAC__ENCODER_UNINITIALIZED); - assert(encoder->guts == 0); + FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */ + FLAC__ASSERT(encoder != 0); + FLAC__ASSERT(write_callback != 0); + FLAC__ASSERT(metadata_callback != 0); + FLAC__ASSERT(encoder->state == FLAC__ENCODER_UNINITIALIZED); + FLAC__ASSERT(encoder->guts == 0); encoder->state = FLAC__ENCODER_OK; @@ -331,9 +331,9 @@ FLAC__EncoderState FLAC__encoder_init(FLAC__Encoder *encoder, FLAC__EncoderWrite encoder->guts->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients; /* now override with asm where appropriate */ #ifndef FLAC__NO_ASM - assert(encoder->guts->cpuinfo.use_asm); + FLAC__ASSERT(encoder->guts->cpuinfo.use_asm); #ifdef FLAC__CPU_IA32 - assert(encoder->guts->cpuinfo.type == FLAC__CPUINFO_TYPE_IA32); + FLAC__ASSERT(encoder->guts->cpuinfo.type == FLAC__CPUINFO_TYPE_IA32); #ifdef FLAC__HAS_NASM #if 0 /* @@@ SSE version not working yet */ @@ -438,8 +438,8 @@ fprintf(stderr,"@@@ got _asm_i386 of lpc_compute_residual_from_qlp_coefficients( return encoder->state = FLAC__ENCODER_FRAMING_ERROR; } - assert(encoder->guts->frame.bits == 0); /* assert that we're byte-aligned before writing */ - assert(encoder->guts->frame.total_consumed_bits == 0); /* assert that no reading of the buffer was done */ + FLAC__ASSERT(encoder->guts->frame.bits == 0); /* assert that we're byte-aligned before writing */ + FLAC__ASSERT(encoder->guts->frame.total_consumed_bits == 0); /* assert that no reading of the buffer was done */ if(encoder->guts->write_callback(encoder, encoder->guts->frame.buffer, encoder->guts->frame.bytes, 0, encoder->guts->current_frame_number, encoder->guts->client_data) != FLAC__ENCODER_WRITE_OK) return encoder->state = FLAC__ENCODER_FATAL_ERROR_WHILE_WRITING; @@ -455,7 +455,7 @@ void FLAC__encoder_finish(FLAC__Encoder *encoder) { unsigned i, channel; - assert(encoder != 0); + FLAC__ASSERT(encoder != 0); if(encoder->state == FLAC__ENCODER_UNINITIALIZED) return; if(encoder->guts->current_sample_number != 0) { @@ -526,8 +526,8 @@ bool FLAC__encoder_process(FLAC__Encoder *encoder, const int32 *buf[], unsigned int32 x, mid, side; const unsigned channels = encoder->channels, blocksize = encoder->blocksize; - assert(encoder != 0); - assert(encoder->state == FLAC__ENCODER_OK); + FLAC__ASSERT(encoder != 0); + FLAC__ASSERT(encoder->state == FLAC__ENCODER_OK); j = 0; if(encoder->do_mid_side_stereo && channels == 2) { @@ -581,8 +581,8 @@ bool FLAC__encoder_process_interleaved(FLAC__Encoder *encoder, const int32 buf[] int32 x, mid, side; const unsigned channels = encoder->channels, blocksize = encoder->blocksize; - assert(encoder != 0); - assert(encoder->state == FLAC__ENCODER_OK); + FLAC__ASSERT(encoder != 0); + FLAC__ASSERT(encoder->state == FLAC__ENCODER_OK); j = k = 0; if(encoder->do_mid_side_stereo && channels == 2) { @@ -631,7 +631,7 @@ bool FLAC__encoder_process_interleaved(FLAC__Encoder *encoder, const int32 buf[] bool encoder_process_frame_(FLAC__Encoder *encoder, bool is_last_frame) { - assert(encoder->state == FLAC__ENCODER_OK); + FLAC__ASSERT(encoder->state == FLAC__ENCODER_OK); /* * Accumulate raw signal to the MD5 signature @@ -661,8 +661,8 @@ bool encoder_process_frame_(FLAC__Encoder *encoder, bool is_last_frame) /* * CRC-16 the whole thing */ - assert(encoder->guts->frame.bits == 0); /* assert that we're byte-aligned */ - assert(encoder->guts->frame.total_consumed_bits == 0); /* assert that no reading of the buffer was done */ + FLAC__ASSERT(encoder->guts->frame.bits == 0); /* assert that we're byte-aligned */ + FLAC__ASSERT(encoder->guts->frame.total_consumed_bits == 0); /* assert that no reading of the buffer was done */ FLAC__bitbuffer_write_raw_uint32(&encoder->guts->frame, FLAC__crc16(encoder->guts->frame.buffer, encoder->guts->frame.bytes), FLAC__FRAME_FOOTER_CRC_LEN); /* @@ -745,7 +745,7 @@ bool encoder_process_subframes_(FLAC__Encoder *encoder, bool is_last_frame) do_mid_side = false; } - assert(do_independent || do_mid_side); + FLAC__ASSERT(do_independent || do_mid_side); /* * Check for wasted bits; set effective bps for each subframe @@ -760,7 +760,7 @@ bool encoder_process_subframes_(FLAC__Encoder *encoder, bool is_last_frame) } if(do_mid_side) { unsigned w; - assert(encoder->channels == 2); + FLAC__ASSERT(encoder->channels == 2); for(channel = 0; channel < 2; channel++) { w = encoder_get_wasted_bits_(encoder->guts->integer_signal_mid_side[channel], encoder->blocksize); encoder->guts->subframe_workspace_mid_side[channel][0].wasted_bits = encoder->guts->subframe_workspace_mid_side[channel][1].wasted_bits = w; @@ -782,7 +782,7 @@ bool encoder_process_subframes_(FLAC__Encoder *encoder, bool is_last_frame) * Now do mid and side channels if requested */ if(do_mid_side) { - assert(encoder->channels == 2); + FLAC__ASSERT(encoder->channels == 2); for(channel = 0; channel < 2; channel++) { if(!encoder_process_subframe_(encoder, min_partition_order, max_partition_order, false, &frame_header, encoder->guts->subframe_bps_mid_side[channel], encoder->guts->integer_signal_mid_side[channel], encoder->guts->real_signal_mid_side[channel], encoder->guts->subframe_workspace_ptr_mid_side[channel], encoder->guts->residual_workspace_mid_side[channel], encoder->guts->best_subframe_mid_side+channel, encoder->guts->best_subframe_bits_mid_side+channel)) @@ -798,7 +798,7 @@ bool encoder_process_subframes_(FLAC__Encoder *encoder, bool is_last_frame) FLAC__Subframe *left_subframe = 0, *right_subframe = 0; /* initialized only to prevent superfluous compiler warning */ FLAC__ChannelAssignment channel_assignment; - assert(encoder->channels == 2); + FLAC__ASSERT(encoder->channels == 2); if(encoder->loose_mid_side_stereo && encoder->guts->loose_mid_side_stereo_frame_count > 0) { channel_assignment = (encoder->guts->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT? FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT : FLAC__CHANNEL_ASSIGNMENT_MID_SIDE); @@ -808,7 +808,7 @@ bool encoder_process_subframes_(FLAC__Encoder *encoder, bool is_last_frame) unsigned min_bits; FLAC__ChannelAssignment ca; - assert(do_independent && do_mid_side); + FLAC__ASSERT(do_independent && do_mid_side); /* We have to figure out which channel assignent results in the smallest frame */ bits[FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT] = encoder->guts->best_subframe_bits [0] + encoder->guts->best_subframe_bits [1]; @@ -849,7 +849,7 @@ bool encoder_process_subframes_(FLAC__Encoder *encoder, bool is_last_frame) right_subframe = &encoder->guts->subframe_workspace_mid_side[1][encoder->guts->best_subframe_mid_side[1]]; break; default: - assert(0); + FLAC__ASSERT(0); } switch(channel_assignment) { @@ -870,7 +870,7 @@ bool encoder_process_subframes_(FLAC__Encoder *encoder, bool is_last_frame) right_bps = encoder->guts->subframe_bps_mid_side[1]; break; default: - assert(0); + FLAC__ASSERT(0); } /* note that encoder_add_subframe_ sets the state for us in case of an error */ @@ -1055,7 +1055,7 @@ bool encoder_add_subframe_(FLAC__Encoder *encoder, const FLAC__FrameHeader *fram } break; default: - assert(0); + FLAC__ASSERT(0); } return true; @@ -1154,7 +1154,7 @@ unsigned encoder_find_best_partition_order_(const int32 residual[], uint32 abs_r for(partition_order = (int)max_partition_order, sum = 0; partition_order >= (int)min_partition_order; partition_order--) { if(!encoder_set_partitioned_rice_(abs_residual, abs_residual_partition_sums+sum, raw_bits_per_partition+sum, residual_samples, predictor_order, rice_parameter, rice_parameter_search_dist, (unsigned)partition_order, parameters[!best_parameters_index], raw_bits[!best_parameters_index], &residual_bits)) { - assert(0); /* encoder_precompute_partition_info_ should keep this from ever happening */ + FLAC__ASSERT(0); /* encoder_precompute_partition_info_ should keep this from ever happening */ } sum += 1u << partition_order; if(best_residual_bits == 0 || residual_bits < best_residual_bits) { @@ -1166,7 +1166,7 @@ unsigned encoder_find_best_partition_order_(const int32 residual[], uint32 abs_r #else for(partition_order = min_partition_order; partition_order <= max_partition_order; partition_order++) { if(!encoder_set_partitioned_rice_(abs_residual, 0, 0, residual_samples, predictor_order, rice_parameter, rice_parameter_search_dist, partition_order, parameters[!best_parameters_index], raw_bits[!best_parameters_index], &residual_bits)) { - assert(best_residual_bits != 0); + FLAC__ASSERT(best_residual_bits != 0); break; } if(best_residual_bits == 0 || residual_bits < best_residual_bits) { @@ -1204,7 +1204,7 @@ unsigned encoder_precompute_partition_info_(const int32 residual[], uint32 abs_r const unsigned default_partition_samples = blocksize >> partition_order; if(default_partition_samples <= predictor_order) { - assert(max_partition_order > 0); + FLAC__ASSERT(max_partition_order > 0); max_partition_order--; } else { @@ -1296,7 +1296,7 @@ bool encoder_set_partitioned_rice_(const uint32 abs_residual[], const uint32 abs #endif unsigned bits_ = FLAC__ENTROPY_CODING_METHOD_TYPE_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN; - assert(suggested_rice_parameter < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER); + FLAC__ASSERT(suggested_rice_parameter < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER); if(partition_order == 0) { unsigned i; diff --git a/src/libFLAC/encoder_framing.c b/src/libFLAC/encoder_framing.c index bae80d56..a3c4e1cc 100644 --- a/src/libFLAC/encoder_framing.c +++ b/src/libFLAC/encoder_framing.c @@ -17,10 +17,10 @@ * Boston, MA 02111-1307, USA. */ -#include #include #include "private/encoder_framing.h" #include "private/crc.h" +#include "FLAC/assert.h" #ifdef max #undef max @@ -40,34 +40,34 @@ bool FLAC__add_metadata_block(const FLAC__StreamMetaData *metadata, FLAC__BitBuf if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->type, FLAC__STREAM_METADATA_TYPE_LEN)) return false; - assert(metadata->length < (1u << FLAC__STREAM_METADATA_LENGTH_LEN)); + FLAC__ASSERT(metadata->length < (1u << FLAC__STREAM_METADATA_LENGTH_LEN)); if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->length, FLAC__STREAM_METADATA_LENGTH_LEN)) return false; switch(metadata->type) { case FLAC__METADATA_TYPE_STREAMINFO: - assert(metadata->data.stream_info.min_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN)); + FLAC__ASSERT(metadata->data.stream_info.min_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN)); if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.min_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN)) return false; - assert(metadata->data.stream_info.max_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN)); + FLAC__ASSERT(metadata->data.stream_info.max_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN)); if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.max_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN)) return false; - assert(metadata->data.stream_info.min_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)); + FLAC__ASSERT(metadata->data.stream_info.min_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)); if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.min_framesize, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)) return false; - assert(metadata->data.stream_info.max_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)); + FLAC__ASSERT(metadata->data.stream_info.max_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)); if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.max_framesize, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)) return false; - assert(metadata->data.stream_info.sample_rate > 0); - assert(metadata->data.stream_info.sample_rate < (1u << FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN)); + FLAC__ASSERT(metadata->data.stream_info.sample_rate > 0); + FLAC__ASSERT(metadata->data.stream_info.sample_rate < (1u << FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN)); if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.sample_rate, FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN)) return false; - assert(metadata->data.stream_info.channels > 0); - assert(metadata->data.stream_info.channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN)); + FLAC__ASSERT(metadata->data.stream_info.channels > 0); + FLAC__ASSERT(metadata->data.stream_info.channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN)); if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.channels-1, FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN)) return false; - assert(metadata->data.stream_info.bits_per_sample > 0); - assert(metadata->data.stream_info.bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)); + FLAC__ASSERT(metadata->data.stream_info.bits_per_sample > 0); + FLAC__ASSERT(metadata->data.stream_info.bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)); if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.bits_per_sample-1, FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)) return false; if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.stream_info.total_samples, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)) @@ -92,7 +92,7 @@ bool FLAC__add_metadata_block(const FLAC__StreamMetaData *metadata, FLAC__BitBuf } break; default: - assert(0); + FLAC__ASSERT(0); } return true; @@ -103,7 +103,7 @@ bool FLAC__frame_add_header(const FLAC__FrameHeader *header, bool streamable_sub unsigned u, crc8_start, blocksize_hint, sample_rate_hint; byte crc8; - assert(bb->bits == 0); /* assert that we're byte-aligned before writing */ + FLAC__ASSERT(bb->bits == 0); /* assert that we're byte-aligned before writing */ crc8_start = bb->bytes; @@ -113,7 +113,7 @@ bool FLAC__frame_add_header(const FLAC__FrameHeader *header, bool streamable_sub if(!FLAC__bitbuffer_write_raw_uint32(bb, 0, FLAC__FRAME_HEADER_RESERVED_LEN)) return false; - assert(header->blocksize > 0 && header->blocksize <= FLAC__MAX_BLOCK_SIZE); + FLAC__ASSERT(header->blocksize > 0 && header->blocksize <= FLAC__MAX_BLOCK_SIZE); blocksize_hint = 0; switch(header->blocksize) { case 192: u = 1; break; @@ -143,7 +143,7 @@ bool FLAC__frame_add_header(const FLAC__FrameHeader *header, bool streamable_sub if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_BLOCK_SIZE_LEN)) return false; - assert(header->sample_rate > 0 && header->sample_rate < (1u << FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN)); + FLAC__ASSERT(header->sample_rate > 0 && header->sample_rate < (1u << FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN)); sample_rate_hint = 0; switch(header->sample_rate) { case 8000: u = 4; break; @@ -170,30 +170,30 @@ bool FLAC__frame_add_header(const FLAC__FrameHeader *header, bool streamable_sub if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_SAMPLE_RATE_LEN)) return false; - assert(header->channels > 0 && header->channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN) && header->channels <= FLAC__MAX_CHANNELS); + FLAC__ASSERT(header->channels > 0 && header->channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN) && header->channels <= FLAC__MAX_CHANNELS); switch(header->channel_assignment) { case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: u = header->channels - 1; break; case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: - assert(header->channels == 2); + FLAC__ASSERT(header->channels == 2); u = 8; break; case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: - assert(header->channels == 2); + FLAC__ASSERT(header->channels == 2); u = 9; break; case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: - assert(header->channels == 2); + FLAC__ASSERT(header->channels == 2); u = 10; break; default: - assert(0); + FLAC__ASSERT(0); } if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN)) return false; - assert(header->bits_per_sample > 0 && header->bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)); + FLAC__ASSERT(header->bits_per_sample > 0 && header->bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)); switch(header->bits_per_sample) { case 8 : u = 1; break; case 12: u = 2; break; @@ -231,8 +231,8 @@ bool FLAC__frame_add_header(const FLAC__FrameHeader *header, bool streamable_sub } /* write the CRC */ - assert(bb->buffer[crc8_start] == 0xff); /* MAGIC NUMBER for the first byte of the sync code */ - assert(bb->bits == 0); /* assert that we're byte-aligned */ + FLAC__ASSERT(bb->buffer[crc8_start] == 0xff); /* MAGIC NUMBER for the first byte of the sync code */ + FLAC__ASSERT(bb->bits == 0); /* assert that we're byte-aligned */ crc8 = FLAC__crc8(bb->buffer+crc8_start, bb->bytes-crc8_start); if(!FLAC__bitbuffer_write_raw_uint32(bb, crc8, FLAC__FRAME_HEADER_CRC_LEN)) return false; @@ -275,7 +275,7 @@ bool FLAC__subframe_add_fixed(const FLAC__Subframe_Fixed *subframe, unsigned res return false; break; default: - assert(0); + FLAC__ASSERT(0); } return true; @@ -311,7 +311,7 @@ bool FLAC__subframe_add_lpc(const FLAC__Subframe_LPC *subframe, unsigned residua return false; break; default: - assert(0); + FLAC__ASSERT(0); } return true; @@ -345,7 +345,7 @@ bool subframe_add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__Entrop return false; break; default: - assert(0); + FLAC__ASSERT(0); } return true; } diff --git a/src/libFLAC/file_decoder.c b/src/libFLAC/file_decoder.c index 99b85ec3..079dad05 100644 --- a/src/libFLAC/file_decoder.c +++ b/src/libFLAC/file_decoder.c @@ -17,11 +17,11 @@ * Boston, MA 02111-1307, USA. */ -#include #include #include /* for malloc() */ #include /* for strcmp() */ #include /* for stat() */ +#include "FLAC/assert.h" #include "FLAC/file_decoder.h" #include "protected/stream_decoder.h" #include "private/md5.h" @@ -85,13 +85,13 @@ FLAC__FileDecoderState FLAC__file_decoder_init( void *client_data ) { - assert(sizeof(int) >= 4); /* we want to die right away if this is not true */ - assert(decoder != 0); - assert(write_callback != 0); - assert(metadata_callback != 0); - assert(error_callback != 0); - assert(decoder->state == FLAC__FILE_DECODER_UNINITIALIZED); - assert(decoder->guts == 0); + FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */ + FLAC__ASSERT(decoder != 0); + FLAC__ASSERT(write_callback != 0); + FLAC__ASSERT(metadata_callback != 0); + FLAC__ASSERT(error_callback != 0); + FLAC__ASSERT(decoder->state == FLAC__FILE_DECODER_UNINITIALIZED); + FLAC__ASSERT(decoder->guts == 0); decoder->state = FLAC__FILE_DECODER_OK; @@ -140,7 +140,7 @@ bool FLAC__file_decoder_finish(FLAC__FileDecoder *decoder) { bool md5_failed = false; - assert(decoder != 0); + FLAC__ASSERT(decoder != 0); if(decoder->state == FLAC__FILE_DECODER_UNINITIALIZED) return true; if(decoder->guts != 0) { @@ -170,7 +170,7 @@ bool FLAC__file_decoder_finish(FLAC__FileDecoder *decoder) bool FLAC__file_decoder_process_whole_file(FLAC__FileDecoder *decoder) { bool ret; - assert(decoder != 0); + FLAC__ASSERT(decoder != 0); if(decoder->guts->stream->state == FLAC__STREAM_DECODER_END_OF_STREAM) decoder->state = FLAC__FILE_DECODER_END_OF_FILE; @@ -178,7 +178,7 @@ bool FLAC__file_decoder_process_whole_file(FLAC__FileDecoder *decoder) if(decoder->state == FLAC__FILE_DECODER_END_OF_FILE) return true; - assert(decoder->state == FLAC__FILE_DECODER_OK); + FLAC__ASSERT(decoder->state == FLAC__FILE_DECODER_OK); ret = FLAC__stream_decoder_process_whole_stream(decoder->guts->stream); if(!ret) @@ -190,7 +190,7 @@ bool FLAC__file_decoder_process_whole_file(FLAC__FileDecoder *decoder) bool FLAC__file_decoder_process_metadata(FLAC__FileDecoder *decoder) { bool ret; - assert(decoder != 0); + FLAC__ASSERT(decoder != 0); if(decoder->guts->stream->state == FLAC__STREAM_DECODER_END_OF_STREAM) decoder->state = FLAC__FILE_DECODER_END_OF_FILE; @@ -198,7 +198,7 @@ bool FLAC__file_decoder_process_metadata(FLAC__FileDecoder *decoder) if(decoder->state == FLAC__FILE_DECODER_END_OF_FILE) return true; - assert(decoder->state == FLAC__FILE_DECODER_OK); + FLAC__ASSERT(decoder->state == FLAC__FILE_DECODER_OK); ret = FLAC__stream_decoder_process_metadata(decoder->guts->stream); if(!ret) @@ -210,7 +210,7 @@ bool FLAC__file_decoder_process_metadata(FLAC__FileDecoder *decoder) bool FLAC__file_decoder_process_one_frame(FLAC__FileDecoder *decoder) { bool ret; - assert(decoder != 0); + FLAC__ASSERT(decoder != 0); if(decoder->guts->stream->state == FLAC__STREAM_DECODER_END_OF_STREAM) decoder->state = FLAC__FILE_DECODER_END_OF_FILE; @@ -218,7 +218,7 @@ bool FLAC__file_decoder_process_one_frame(FLAC__FileDecoder *decoder) if(decoder->state == FLAC__FILE_DECODER_END_OF_FILE) return true; - assert(decoder->state == FLAC__FILE_DECODER_OK); + FLAC__ASSERT(decoder->state == FLAC__FILE_DECODER_OK); ret = FLAC__stream_decoder_process_one_frame(decoder->guts->stream); if(!ret) @@ -230,7 +230,7 @@ bool FLAC__file_decoder_process_one_frame(FLAC__FileDecoder *decoder) bool FLAC__file_decoder_process_remaining_frames(FLAC__FileDecoder *decoder) { bool ret; - assert(decoder != 0); + FLAC__ASSERT(decoder != 0); if(decoder->guts->stream->state == FLAC__STREAM_DECODER_END_OF_STREAM) decoder->state = FLAC__FILE_DECODER_END_OF_FILE; @@ -238,7 +238,7 @@ bool FLAC__file_decoder_process_remaining_frames(FLAC__FileDecoder *decoder) if(decoder->state == FLAC__FILE_DECODER_END_OF_FILE) return true; - assert(decoder->state == FLAC__FILE_DECODER_OK); + FLAC__ASSERT(decoder->state == FLAC__FILE_DECODER_OK); ret = FLAC__stream_decoder_process_remaining_frames(decoder->guts->stream); if(!ret) @@ -252,8 +252,8 @@ bool FLAC__file_decoder_seek_absolute(FLAC__FileDecoder *decoder, uint64 sample) long filesize; struct stat filestats; - assert(decoder != 0); - assert(decoder->state == FLAC__FILE_DECODER_OK); + FLAC__ASSERT(decoder != 0); + FLAC__ASSERT(decoder->state == FLAC__FILE_DECODER_OK); if(decoder->guts->filename == 0) { /* means the file is stdin... */ decoder->state = FLAC__FILE_DECODER_SEEK_ERROR; @@ -423,7 +423,7 @@ bool seek_to_absolute_sample_(FLAC__FileDecoder *decoder, long filesize, uint64 return false; } first_frame_offset -= FLAC__stream_decoder_input_bytes_unconsumed(decoder->guts->stream); - assert(first_frame_offset >= 0); + FLAC__ASSERT(first_frame_offset >= 0); /* * First, we set an upper and lower bound on where in the diff --git a/src/libFLAC/fixed.c b/src/libFLAC/fixed.c index 5c5cfe86..8fd6a5da 100644 --- a/src/libFLAC/fixed.c +++ b/src/libFLAC/fixed.c @@ -17,9 +17,9 @@ * Boston, MA 02111-1307, USA. */ -#include #include #include "private/fixed.h" +#include "FLAC/assert.h" #ifndef M_LN2 /* math.h in VC++ doesn't seem to have this (how Microsoft is that?) */ @@ -162,7 +162,7 @@ void FLAC__fixed_compute_residual(const int32 data[], unsigned data_len, unsigne } break; default: - assert(0); + FLAC__ASSERT(0); } } @@ -200,6 +200,6 @@ void FLAC__fixed_restore_signal(const int32 residual[], unsigned data_len, unsig } break; default: - assert(0); + FLAC__ASSERT(0); } } diff --git a/src/libFLAC/format.c b/src/libFLAC/format.c index 4284f4f6..2f2c7d61 100644 --- a/src/libFLAC/format.c +++ b/src/libFLAC/format.c @@ -17,7 +17,6 @@ * Boston, MA 02111-1307, USA. */ -#include #include #include "FLAC/format.h" diff --git a/src/libFLAC/i386/lpc_asm.s b/src/libFLAC/i386/lpc_asm.s index 738620b5..28255204 100644 --- a/src/libFLAC/i386/lpc_asm.s +++ b/src/libFLAC/i386/lpc_asm.s @@ -39,8 +39,8 @@ cglobal FLAC__lpc_restore_signal_asm_i386_mmx ; unsigned sample, coeff; ; const unsigned limit = data_len - lag; ; -; assert(lag > 0); -; assert(lag <= data_len); +; FLAC__ASSERT(lag > 0); +; FLAC__ASSERT(lag <= data_len); ; ; for(coeff = 0; coeff < lag; coeff++) ; autoc[coeff] = 0.0; @@ -790,7 +790,7 @@ cident FLAC__lpc_compute_residual_from_qlp_coefficients_asm_i386_mmx ; unsigned i, j; ; int32 sum; ; -; assert(order > 0); +; FLAC__ASSERT(order > 0); ; ; for(i = 0; i < data_len; i++) { ; sum = 0; diff --git a/src/libFLAC/lpc.c b/src/libFLAC/lpc.c index f5558998..ddca21e7 100644 --- a/src/libFLAC/lpc.c +++ b/src/libFLAC/lpc.c @@ -17,9 +17,9 @@ * Boston, MA 02111-1307, USA. */ -#include #include #include +#include "FLAC/assert.h" #include "FLAC/format.h" #include "private/lpc.h" @@ -37,8 +37,8 @@ void FLAC__lpc_compute_autocorrelation(const real data[], unsigned data_len, uns real d; unsigned i; - assert(lag > 0); - assert(lag <= data_len); + FLAC__ASSERT(lag > 0); + FLAC__ASSERT(lag <= data_len); while(lag--) { for(i = lag, d = 0.0; i < data_len; i++) @@ -55,8 +55,8 @@ void FLAC__lpc_compute_autocorrelation(const real data[], unsigned data_len, uns unsigned sample, coeff; const unsigned limit = data_len - lag; - assert(lag > 0); - assert(lag <= data_len); + FLAC__ASSERT(lag > 0); + FLAC__ASSERT(lag <= data_len); for(coeff = 0; coeff < lag; coeff++) autoc[coeff] = 0.0; @@ -77,9 +77,9 @@ void FLAC__lpc_compute_lp_coefficients(const real autoc[], unsigned max_order, r unsigned i, j; real r, err, ref[FLAC__MAX_LPC_ORDER], lpc[FLAC__MAX_LPC_ORDER]; - assert(0 < max_order); - assert(max_order <= FLAC__MAX_LPC_ORDER); - assert(autoc[0] != 0.0); + FLAC__ASSERT(0 < max_order); + FLAC__ASSERT(max_order <= FLAC__MAX_LPC_ORDER); + FLAC__ASSERT(autoc[0] != 0.0); err = autoc[0]; @@ -114,11 +114,11 @@ int FLAC__lpc_quantize_coefficients(const real lp_coeff[], unsigned order, unsig unsigned i; real d, cmax = -1e10; - assert(bits_per_sample > 0); - assert(bits_per_sample <= sizeof(int32)*8); - assert(precision > 0); - assert(precision >= FLAC__MIN_QLP_COEFF_PRECISION); - assert(precision + bits_per_sample < sizeof(int32)*8); + FLAC__ASSERT(bits_per_sample > 0); + FLAC__ASSERT(bits_per_sample <= sizeof(int32)*8); + FLAC__ASSERT(precision > 0); + FLAC__ASSERT(precision >= FLAC__MIN_QLP_COEFF_PRECISION); + FLAC__ASSERT(precision + bits_per_sample < sizeof(int32)*8); #ifdef NDEBUG (void)bits_per_sample; /* silence compiler warning about unused parameter */ #endif @@ -171,7 +171,7 @@ void FLAC__lpc_compute_residual_from_qlp_coefficients(const int32 data[], unsign fprintf(stderr,", q[%u]=%d",i,qlp_coeff[i]); fprintf(stderr,"\n"); #endif - assert(order > 0); + FLAC__ASSERT(order > 0); for(i = 0; i < data_len; i++) { #ifdef FLAC__OVERFLOW_DETECT @@ -216,7 +216,7 @@ void FLAC__lpc_restore_signal(const int32 residual[], unsigned data_len, const i fprintf(stderr,", q[%u]=%d",i,qlp_coeff[i]); fprintf(stderr,"\n"); #endif - assert(order > 0); + FLAC__ASSERT(order > 0); for(i = 0; i < data_len; i++) { #ifdef FLAC__OVERFLOW_DETECT @@ -250,7 +250,7 @@ real FLAC__lpc_compute_expected_bits_per_residual_sample(real lpc_error, unsigne { real error_scale; - assert(total_samples > 0); + FLAC__ASSERT(total_samples > 0); error_scale = 0.5 * M_LN2 * M_LN2 / (real)total_samples; @@ -291,8 +291,8 @@ unsigned FLAC__lpc_compute_best_order(const real lpc_error[], unsigned max_order unsigned order, best_order; real best_bits, tmp_bits, error_scale; - assert(max_order > 0); - assert(total_samples > 0); + FLAC__ASSERT(max_order > 0); + FLAC__ASSERT(total_samples > 0); error_scale = 0.5 * M_LN2 * M_LN2 / (real)total_samples; diff --git a/src/libFLAC/md5.c b/src/libFLAC/md5.c index 85330f98..6bdda137 100644 --- a/src/libFLAC/md5.c +++ b/src/libFLAC/md5.c @@ -23,7 +23,6 @@ * Still in the public domain. */ -#include /* for assert() */ #include /* for malloc() */ #include /* for memcpy() */ diff --git a/src/libFLAC/memory.c b/src/libFLAC/memory.c index 58eab678..92151042 100644 --- a/src/libFLAC/memory.c +++ b/src/libFLAC/memory.c @@ -17,14 +17,14 @@ * Boston, MA 02111-1307, USA. */ -#include #include "private/memory.h" +#include "FLAC/assert.h" void *FLAC__memory_alloc_aligned(size_t bytes, void **aligned_address) { void *x; - assert(0 != aligned_address); + FLAC__ASSERT(0 != aligned_address); #ifdef FLAC__ALIGN_MALLOC_DATA /* align on 32-byte (256-bit) boundary */ @@ -41,10 +41,10 @@ bool FLAC__memory_alloc_aligned_int32_array(unsigned elements, int32 **unaligned { int32 *pa, *pu; /* aligned pointer, unaligned pointer */ - assert(elements > 0); - assert(0 != unaligned_pointer); - assert(0 != aligned_pointer); - assert(unaligned_pointer != aligned_pointer); + FLAC__ASSERT(elements > 0); + FLAC__ASSERT(0 != unaligned_pointer); + FLAC__ASSERT(0 != aligned_pointer); + FLAC__ASSERT(unaligned_pointer != aligned_pointer); pu = (int32*)FLAC__memory_alloc_aligned(sizeof(int32) * elements, (void*)&pa); if(0 == pu) { @@ -63,10 +63,10 @@ bool FLAC__memory_alloc_aligned_uint32_array(unsigned elements, uint32 **unalign { uint32 *pa, *pu; /* aligned pointer, unaligned pointer */ - assert(elements > 0); - assert(0 != unaligned_pointer); - assert(0 != aligned_pointer); - assert(unaligned_pointer != aligned_pointer); + FLAC__ASSERT(elements > 0); + FLAC__ASSERT(0 != unaligned_pointer); + FLAC__ASSERT(0 != aligned_pointer); + FLAC__ASSERT(unaligned_pointer != aligned_pointer); pu = (uint32*)FLAC__memory_alloc_aligned(sizeof(uint32) * elements, (void*)&pa); if(0 == pu) { @@ -85,10 +85,10 @@ bool FLAC__memory_alloc_aligned_unsigned_array(unsigned elements, unsigned **una { unsigned *pa, *pu; /* aligned pointer, unaligned pointer */ - assert(elements > 0); - assert(0 != unaligned_pointer); - assert(0 != aligned_pointer); - assert(unaligned_pointer != aligned_pointer); + FLAC__ASSERT(elements > 0); + FLAC__ASSERT(0 != unaligned_pointer); + FLAC__ASSERT(0 != aligned_pointer); + FLAC__ASSERT(unaligned_pointer != aligned_pointer); pu = (unsigned*)FLAC__memory_alloc_aligned(sizeof(unsigned) * elements, (void*)&pa); if(0 == pu) { @@ -107,10 +107,10 @@ bool FLAC__memory_alloc_aligned_real_array(unsigned elements, real **unaligned_p { real *pa, *pu; /* aligned pointer, unaligned pointer */ - assert(elements > 0); - assert(0 != unaligned_pointer); - assert(0 != aligned_pointer); - assert(unaligned_pointer != aligned_pointer); + FLAC__ASSERT(elements > 0); + FLAC__ASSERT(0 != unaligned_pointer); + FLAC__ASSERT(0 != aligned_pointer); + FLAC__ASSERT(unaligned_pointer != aligned_pointer); pu = (real*)FLAC__memory_alloc_aligned(sizeof(real) * elements, (void*)&pa); if(0 == pu) { diff --git a/src/libFLAC/seek_table.c b/src/libFLAC/seek_table.c index 3a072331..d76a942d 100644 --- a/src/libFLAC/seek_table.c +++ b/src/libFLAC/seek_table.c @@ -17,7 +17,6 @@ * Boston, MA 02111-1307, USA. */ -#include #include "FLAC/seek_table.h" bool FLAC__seek_table_is_valid(const FLAC__StreamMetaData_SeekTable *seek_table) diff --git a/src/libFLAC/stream_decoder.c b/src/libFLAC/stream_decoder.c index 2c2a6f18..44ac5c11 100644 --- a/src/libFLAC/stream_decoder.c +++ b/src/libFLAC/stream_decoder.c @@ -17,10 +17,10 @@ * Boston, MA 02111-1307, USA. */ -#include #include #include /* for malloc() */ #include /* for memset/memcpy() */ +#include "FLAC/assert.h" #include "FLAC/stream_decoder.h" #include "private/bitbuffer.h" #include "private/cpu.h" @@ -124,14 +124,14 @@ FLAC__StreamDecoderState FLAC__stream_decoder_init( { unsigned i; - assert(sizeof(int) >= 4); /* we want to die right away if this is not true */ - assert(decoder != 0); - assert(read_callback != 0); - assert(write_callback != 0); - assert(metadata_callback != 0); - assert(error_callback != 0); - assert(decoder->state == FLAC__STREAM_DECODER_UNINITIALIZED); - assert(decoder->guts == 0); + FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */ + FLAC__ASSERT(decoder != 0); + FLAC__ASSERT(read_callback != 0); + FLAC__ASSERT(write_callback != 0); + FLAC__ASSERT(metadata_callback != 0); + FLAC__ASSERT(error_callback != 0); + FLAC__ASSERT(decoder->state == FLAC__STREAM_DECODER_UNINITIALIZED); + FLAC__ASSERT(decoder->guts == 0); decoder->state = FLAC__STREAM_DECODER_SEARCH_FOR_METADATA; @@ -168,9 +168,9 @@ FLAC__StreamDecoderState FLAC__stream_decoder_init( decoder->guts->local_lpc_restore_signal = FLAC__lpc_restore_signal; /* now override with asm where appropriate */ #ifndef FLAC__NO_ASM - assert(decoder->guts->cpuinfo.use_asm); + FLAC__ASSERT(decoder->guts->cpuinfo.use_asm); #ifdef FLAC__CPU_IA32 - assert(decoder->guts->cpuinfo.type == FLAC__CPUINFO_TYPE_IA32); + FLAC__ASSERT(decoder->guts->cpuinfo.type == FLAC__CPUINFO_TYPE_IA32); #ifdef FLAC__HAS_NASM #if 0 /* @@@ MMX version needs bps check */ @@ -193,7 +193,7 @@ fprintf(stderr,"@@@ got _asm_i386 of lpc_restore_signal()\n");} void FLAC__stream_decoder_finish(FLAC__StreamDecoder *decoder) { unsigned i; - assert(decoder != 0); + FLAC__ASSERT(decoder != 0); if(decoder->state == FLAC__STREAM_DECODER_UNINITIALIZED) return; if(decoder->guts != 0) { @@ -220,7 +220,7 @@ void FLAC__stream_decoder_finish(FLAC__StreamDecoder *decoder) bool FLAC__stream_decoder_flush(FLAC__StreamDecoder *decoder) { - assert(decoder != 0); + FLAC__ASSERT(decoder != 0); if(!FLAC__bitbuffer_clear(&decoder->guts->input)) { decoder->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; @@ -232,7 +232,7 @@ bool FLAC__stream_decoder_flush(FLAC__StreamDecoder *decoder) bool FLAC__stream_decoder_reset(FLAC__StreamDecoder *decoder) { - assert(decoder != 0); + FLAC__ASSERT(decoder != 0); if(!FLAC__stream_decoder_flush(decoder)) { decoder->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; @@ -248,12 +248,12 @@ bool FLAC__stream_decoder_reset(FLAC__StreamDecoder *decoder) bool FLAC__stream_decoder_process_whole_stream(FLAC__StreamDecoder *decoder) { bool dummy; - assert(decoder != 0); + FLAC__ASSERT(decoder != 0); if(decoder->state == FLAC__STREAM_DECODER_END_OF_STREAM) return true; - assert(decoder->state == FLAC__STREAM_DECODER_SEARCH_FOR_METADATA); + FLAC__ASSERT(decoder->state == FLAC__STREAM_DECODER_SEARCH_FOR_METADATA); if(!FLAC__stream_decoder_reset(decoder)) { decoder->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; @@ -281,19 +281,19 @@ bool FLAC__stream_decoder_process_whole_stream(FLAC__StreamDecoder *decoder) case FLAC__STREAM_DECODER_END_OF_STREAM: return true; default: - assert(0); + FLAC__ASSERT(0); } } } bool FLAC__stream_decoder_process_metadata(FLAC__StreamDecoder *decoder) { - assert(decoder != 0); + FLAC__ASSERT(decoder != 0); if(decoder->state == FLAC__STREAM_DECODER_END_OF_STREAM) return true; - assert(decoder->state == FLAC__STREAM_DECODER_SEARCH_FOR_METADATA); + FLAC__ASSERT(decoder->state == FLAC__STREAM_DECODER_SEARCH_FOR_METADATA); if(!FLAC__stream_decoder_reset(decoder)) { decoder->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; @@ -316,7 +316,7 @@ bool FLAC__stream_decoder_process_metadata(FLAC__StreamDecoder *decoder) case FLAC__STREAM_DECODER_END_OF_STREAM: return true; default: - assert(0); + FLAC__ASSERT(0); } } } @@ -324,12 +324,12 @@ bool FLAC__stream_decoder_process_metadata(FLAC__StreamDecoder *decoder) bool FLAC__stream_decoder_process_one_frame(FLAC__StreamDecoder *decoder) { bool got_a_frame; - assert(decoder != 0); + FLAC__ASSERT(decoder != 0); if(decoder->state == FLAC__STREAM_DECODER_END_OF_STREAM) return true; - assert(decoder->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC); + FLAC__ASSERT(decoder->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC); while(1) { switch(decoder->state) { @@ -346,7 +346,7 @@ bool FLAC__stream_decoder_process_one_frame(FLAC__StreamDecoder *decoder) case FLAC__STREAM_DECODER_END_OF_STREAM: return true; default: - assert(0); + FLAC__ASSERT(0); } } } @@ -354,12 +354,12 @@ bool FLAC__stream_decoder_process_one_frame(FLAC__StreamDecoder *decoder) bool FLAC__stream_decoder_process_remaining_frames(FLAC__StreamDecoder *decoder) { bool dummy; - assert(decoder != 0); + FLAC__ASSERT(decoder != 0); if(decoder->state == FLAC__STREAM_DECODER_END_OF_STREAM) return true; - assert(decoder->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC); + FLAC__ASSERT(decoder->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC); while(1) { switch(decoder->state) { @@ -374,14 +374,14 @@ bool FLAC__stream_decoder_process_remaining_frames(FLAC__StreamDecoder *decoder) case FLAC__STREAM_DECODER_END_OF_STREAM: return true; default: - assert(0); + FLAC__ASSERT(0); } } } unsigned FLAC__stream_decoder_input_bytes_unconsumed(FLAC__StreamDecoder *decoder) { - assert(decoder != 0); + FLAC__ASSERT(decoder != 0); return decoder->guts->input.bytes - decoder->guts->input.consumed_bytes; } @@ -434,7 +434,7 @@ bool stream_decoder_find_metadata_(FLAC__StreamDecoder *decoder) unsigned i, id; bool first = true; - assert(decoder->guts->input.consumed_bits == 0); /* make sure we're byte aligned */ + FLAC__ASSERT(decoder->guts->input.consumed_bits == 0); /* make sure we're byte aligned */ for(i = id = 0; i < 4; ) { if(decoder->guts->cached) { @@ -493,7 +493,7 @@ bool stream_decoder_read_metadata_(FLAC__StreamDecoder *decoder) uint32 i, x, last_block, type, length; uint64 xx; - assert(decoder->guts->input.consumed_bits == 0); /* make sure we're byte aligned */ + FLAC__ASSERT(decoder->guts->input.consumed_bits == 0); /* make sure we're byte aligned */ if(!FLAC__bitbuffer_read_raw_uint32(&decoder->guts->input, &last_block, FLAC__STREAM_METADATA_IS_LAST_LEN, read_callback_, decoder)) return false; /* the read_callback_ sets the state for us */ @@ -554,7 +554,7 @@ bool stream_decoder_read_metadata_(FLAC__StreamDecoder *decoder) used_bits += i*8; /* skip the rest of the block */ - assert(used_bits % 8 == 0); + FLAC__ASSERT(used_bits % 8 == 0); length -= (used_bits / 8); for(i = 0; i < length; i++) { if(!FLAC__bitbuffer_read_raw_uint32(&decoder->guts->input, &x, 8, read_callback_, decoder)) @@ -723,22 +723,22 @@ bool stream_decoder_read_frame_(FLAC__StreamDecoder *decoder, bool *got_a_frame) /* no adjustment needed */ break; case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: - assert(decoder->guts->frame.header.channels == 2); + FLAC__ASSERT(decoder->guts->frame.header.channels == 2); if(channel == 1) bps++; break; case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: - assert(decoder->guts->frame.header.channels == 2); + FLAC__ASSERT(decoder->guts->frame.header.channels == 2); if(channel == 0) bps++; break; case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: - assert(decoder->guts->frame.header.channels == 2); + FLAC__ASSERT(decoder->guts->frame.header.channels == 2); if(channel == 1) bps++; break; default: - assert(0); + FLAC__ASSERT(0); } /* * now read it @@ -766,17 +766,17 @@ bool stream_decoder_read_frame_(FLAC__StreamDecoder *decoder, bool *got_a_frame) /* do nothing */ break; case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: - assert(decoder->guts->frame.header.channels == 2); + FLAC__ASSERT(decoder->guts->frame.header.channels == 2); for(i = 0; i < decoder->guts->frame.header.blocksize; i++) decoder->guts->output[1][i] = decoder->guts->output[0][i] - decoder->guts->output[1][i]; break; case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: - assert(decoder->guts->frame.header.channels == 2); + FLAC__ASSERT(decoder->guts->frame.header.channels == 2); for(i = 0; i < decoder->guts->frame.header.blocksize; i++) decoder->guts->output[0][i] += decoder->guts->output[1][i]; break; case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: - assert(decoder->guts->frame.header.channels == 2); + FLAC__ASSERT(decoder->guts->frame.header.channels == 2); for(i = 0; i < decoder->guts->frame.header.blocksize; i++) { mid = decoder->guts->output[0][i]; side = decoder->guts->output[1][i]; @@ -790,7 +790,7 @@ bool stream_decoder_read_frame_(FLAC__StreamDecoder *decoder, bool *got_a_frame) } break; default: - assert(0); + FLAC__ASSERT(0); break; } } @@ -833,7 +833,7 @@ bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder) const bool is_known_variable_blocksize_stream = (decoder->guts->has_stream_info && decoder->guts->stream_info.data.stream_info.min_blocksize != decoder->guts->stream_info.data.stream_info.max_blocksize); const bool is_known_fixed_blocksize_stream = (decoder->guts->has_stream_info && decoder->guts->stream_info.data.stream_info.min_blocksize == decoder->guts->stream_info.data.stream_info.max_blocksize); - assert(decoder->guts->input.consumed_bits == 0); /* make sure we're byte aligned */ + FLAC__ASSERT(decoder->guts->input.consumed_bits == 0); /* make sure we're byte aligned */ /* init the raw header with the saved bits from synchronization */ raw_header[0] = decoder->guts->header_warmup[0]; @@ -901,7 +901,7 @@ bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder) decoder->guts->frame.header.blocksize = 256 << (x-8); break; default: - assert(0); + FLAC__ASSERT(0); break; } @@ -951,7 +951,7 @@ bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder) decoder->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; return true; default: - assert(0); + FLAC__ASSERT(0); } x = (unsigned)(raw_header[3] >> 4); @@ -1004,7 +1004,7 @@ bool stream_decoder_read_frame_header_(FLAC__StreamDecoder *decoder) is_unparseable = true; break; default: - assert(0); + FLAC__ASSERT(0); break; } @@ -1223,7 +1223,7 @@ bool stream_decoder_read_subframe_fixed_(FLAC__StreamDecoder *decoder, unsigned return false; break; default: - assert(0); + FLAC__ASSERT(0); } /* decode the subframe */ @@ -1296,7 +1296,7 @@ bool stream_decoder_read_subframe_lpc_(FLAC__StreamDecoder *decoder, unsigned ch return false; break; default: - assert(0); + FLAC__ASSERT(0); } /* decode the subframe */ diff --git a/src/metaflac/main.c b/src/metaflac/main.c index 8a0351a4..adcfc8cb 100644 --- a/src/metaflac/main.c +++ b/src/metaflac/main.c @@ -22,7 +22,6 @@ * duplicated here. Look for 'DUPLICATE:' in comments. */ -#include #include #include #include @@ -239,7 +238,7 @@ bool list(FILE *f, bool verbose) } break; default: - assert(0); + FLAC__ASSERT(0); } if(!metadata.is_last) diff --git a/src/plugin_winamp2/in_flac.c b/src/plugin_winamp2/in_flac.c index bcdaf06c..c1f66f7e 100644 --- a/src/plugin_winamp2/in_flac.c +++ b/src/plugin_winamp2/in_flac.c @@ -20,7 +20,6 @@ #include #include #include -#include #include "in2.h" #include "FLAC/all.h" @@ -395,7 +394,7 @@ void metadata_callback(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaD stream_info_struct *stream_info = (stream_info_struct *)client_data; (void)decoder; if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) { - assert(metadata->data.stream_info.total_samples < 0x100000000); /* this plugin can only handle < 4 gigasamples */ + FLAC__ASSERT(metadata->data.stream_info.total_samples < 0x100000000); /* this plugin can only handle < 4 gigasamples */ stream_info->total_samples = (unsigned)(metadata->data.stream_info.total_samples&0xffffffff); stream_info->bits_per_sample = metadata->data.stream_info.bits_per_sample; stream_info->channels = metadata->data.stream_info.channels; diff --git a/src/plugin_winamp3/in_flac.cpp b/src/plugin_winamp3/in_flac.cpp index d93e43ff..9d956591 100644 --- a/src/plugin_winamp3/in_flac.cpp +++ b/src/plugin_winamp3/in_flac.cpp @@ -346,7 +346,7 @@ FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__FileDecoder *decoder, if(file_info->abort_flag) return FLAC__STREAM_DECODER_WRITE_ABORT; - assert(bps == 16); + FLAC__ASSERT(bps == 16); for(sample = reservoir_samples_*channels, wide_sample = 0; wide_sample < wide_samples; wide_sample++) for(channel = 0; channel < channels; channel++, sample++) @@ -362,7 +362,7 @@ void metadata_callback_(const FLAC__FileDecoder *decoder, const FLAC__StreamMeta file_info_struct *file_info = (file_info_struct *)client_data; (void)decoder; if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) { - assert(metadata->data.stream_info.total_samples < 0x100000000); /* this plugin can only handle < 4 gigasamples */ + FLAC__ASSERT(metadata->data.stream_info.total_samples < 0x100000000); /* this plugin can only handle < 4 gigasamples */ file_info->total_samples = (unsigned)(metadata->data.stream_info.total_samples&0xffffffff); file_info->bits_per_sample = metadata->data.stream_info.bits_per_sample; file_info->channels = metadata->data.stream_info.channels; diff --git a/src/plugin_xmms/plugin.c b/src/plugin_xmms/plugin.c index 8ed4db6c..be0d6e59 100644 --- a/src/plugin_xmms/plugin.c +++ b/src/plugin_xmms/plugin.c @@ -20,7 +20,6 @@ #include #include #include -#include #include #include "xmms/plugin.h" @@ -411,7 +410,7 @@ void metadata_callback_(const FLAC__FileDecoder *decoder, const FLAC__StreamMeta file_info_struct *file_info = (file_info_struct *)client_data; (void)decoder; if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) { - assert(metadata->data.stream_info.total_samples < 0x100000000); /* this plugin can only handle < 4 gigasamples */ + FLAC__ASSERT(metadata->data.stream_info.total_samples < 0x100000000); /* this plugin can only handle < 4 gigasamples */ file_info->total_samples = (unsigned)(metadata->data.stream_info.total_samples&0xffffffff); file_info->bits_per_sample = metadata->data.stream_info.bits_per_sample; file_info->channels = metadata->data.stream_info.channels; diff --git a/src/test_streams/main.c b/src/test_streams/main.c index 8b8f7e18..3405f88d 100644 --- a/src/test_streams/main.c +++ b/src/test_streams/main.c @@ -19,8 +19,8 @@ #include #include #include -#include #include +#include "FLAC/assert.h" #include "FLAC/ordinals.h" #ifdef _WIN32 @@ -151,7 +151,7 @@ static bool generate_fsd8(const char *fn, const int pattern[], unsigned reps) FILE *f; unsigned rep, p; - assert(pattern != 0); + FLAC__ASSERT(pattern != 0); if(0 == (f = fopen(fn, mode))) return false; @@ -177,7 +177,7 @@ static bool generate_fsd16(const char *fn, const int pattern[], unsigned reps) FILE *f; unsigned rep, p; - assert(pattern != 0); + FLAC__ASSERT(pattern != 0); if(0 == (f = fopen(fn, mode))) return false; @@ -231,7 +231,7 @@ static bool generate_fsd24(const char *fn, const int pattern[], unsigned reps) FILE *f; unsigned rep, p; - assert(pattern != 0); + FLAC__ASSERT(pattern != 0); if(0 == (f = fopen(fn, mode))) return false;