From 0e3a955652d4065e18197fffb5b5421308b92a47 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sigrid=20Solveig=20Hafl=C3=ADnud=C3=B3ttir?= Date: Mon, 21 Feb 2022 21:11:19 +0000 Subject: [PATCH] libFLAC: update to 1.3.4 --- sys/src/cmd/audio/libFLAC/bitreader.c | 38 ++++++---- sys/src/cmd/audio/libFLAC/cpu.c | 20 +++++ sys/src/cmd/audio/libFLAC/format.c | 5 +- sys/src/cmd/audio/libFLAC/lpc.c | 28 +++---- .../cmd/audio/libFLAC/metadata_iterators.c | 10 ++- sys/src/cmd/audio/libFLAC/mkfile | 2 +- sys/src/cmd/audio/libFLAC/private/cpu.h | 6 ++ sys/src/cmd/audio/libFLAC/private/macros.h | 2 + sys/src/cmd/audio/libFLAC/share/compat.h | 10 ++- sys/src/cmd/audio/libFLAC/share/safe_str.h | 4 +- sys/src/cmd/audio/libFLAC/stream_decoder.c | 76 +++++++++++++++---- sys/src/cmd/audio/libFLAC/stream_encoder.c | 27 ++++--- sys/src/cmd/audio/libFLAC/window.c | 36 +++++---- 13 files changed, 189 insertions(+), 75 deletions(-) diff --git a/sys/src/cmd/audio/libFLAC/bitreader.c b/sys/src/cmd/audio/libFLAC/bitreader.c index 935208a53..79cb5cc40 100644 --- a/sys/src/cmd/audio/libFLAC/bitreader.c +++ b/sys/src/cmd/audio/libFLAC/bitreader.c @@ -119,8 +119,10 @@ static inline void crc16_update_word_(FLAC__BitReader *br, brword word) { register uint32_t crc = br->read_crc16; - for( ; br->crc16_align < FLAC__BITS_PER_WORD; br->crc16_align += 8) - crc = FLAC__CRC16_UPDATE((uint32_t)((word >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), crc); + 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; @@ -131,16 +133,19 @@ 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); + 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); + br->read_crc16 = FLAC__crc16_update_words64(br->buffer + br->crc16_offset, br->consumed_words - br->crc16_offset, br->read_crc16); #else - unsigned i; + unsigned i; - for(i = br->crc16_offset; i < br->consumed_words; i++) - crc16_update_word_(br, br->buffer[i]); + for (i = br->crc16_offset; i < br->consumed_words; i++) + crc16_update_word_(br, br->buffer[i]); #endif + } br->crc16_offset = 0; } @@ -398,19 +403,22 @@ FLAC__bool FLAC__bitreader_read_raw_uint32(FLAC__BitReader *br, FLAC__uint32 *va /* 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) { - *val = (FLAC__uint32)((word & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (n-bits)); /* The result has <= 32 non-zero bits */ + 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 & (FLAC__WORD_ALL_ONES >> br->consumed_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 */ - *val <<= bits; - *val |= (FLAC__uint32)(br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits)); + 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; } return true; @@ -453,11 +461,11 @@ FLAC__bool FLAC__bitreader_read_raw_int32(FLAC__BitReader *br, FLAC__int32 *val, { FLAC__uint32 uval, mask; /* OPT: inline raw uint32 code here, or make into a macro if possible in the .h file */ - if(!FLAC__bitreader_read_raw_uint32(br, &uval, bits)) + if (bits < 1 || ! FLAC__bitreader_read_raw_uint32(br, &uval, bits)) return false; /* sign-extend *val assuming it is currently bits wide. */ /* From: https://graphics.stanford.edu/~seander/bithacks.html#FixedSignExtend */ - mask = 1u << (bits - 1); + mask = bits >= 33 ? 0 : 1u << (bits - 1); *val = (uval ^ mask) - mask; return true; } @@ -663,7 +671,7 @@ FLAC__bool FLAC__bitreader_read_unary_unsigned(FLAC__BitReader *br, uint32_t *va *val = 0; while(1) { while(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */ - brword b = br->buffer[br->consumed_words] << br->consumed_bits; + brword b = br->consumed_bits < FLAC__BITS_PER_WORD ? br->buffer[br->consumed_words] << br->consumed_bits : 0; if(b) { i = COUNT_ZERO_MSBS(b); *val += i; @@ -864,7 +872,7 @@ incomplete_lsbs: cwords = br->consumed_words; words = br->words; ucbits = FLAC__BITS_PER_WORD - br->consumed_bits; - b = br->buffer[cwords] << br->consumed_bits; + b = cwords < br->capacity ? br->buffer[cwords] << br->consumed_bits : 0; } while(cwords >= words && val < end); } diff --git a/sys/src/cmd/audio/libFLAC/cpu.c b/sys/src/cmd/audio/libFLAC/cpu.c index 64da9cbcb..8b92f4c76 100644 --- a/sys/src/cmd/audio/libFLAC/cpu.c +++ b/sys/src/cmd/audio/libFLAC/cpu.c @@ -54,8 +54,10 @@ #endif #if defined FLAC__CPU_PPC +#if defined(__linux__) || (defined(__FreeBSD__) && (__FreeBSD__ >= 12)) #include #endif +#endif #if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64) && (defined FLAC__HAS_NASM || FLAC__HAS_X86INTRIN) && !defined FLAC__NO_ASM @@ -245,11 +247,29 @@ ppc_cpu_info (FLAC__CPUInfo *info) #define PPC_FEATURE2_ARCH_2_07 0x80000000 #endif +#ifdef __linux__ if (getauxval(AT_HWCAP2) & PPC_FEATURE2_ARCH_3_00) { info->ppc.arch_3_00 = true; } else if (getauxval(AT_HWCAP2) & PPC_FEATURE2_ARCH_2_07) { info->ppc.arch_2_07 = true; } +#elif defined(__FreeBSD__) && (__FreeBSD__ >= 12) + long hwcaps; + /* elf_aux_info() appeared in FreeBSD 12.0 */ + elf_aux_info(AT_HWCAP2, &hwcaps, sizeof(hwcaps)); + if (hwcaps & PPC_FEATURE2_ARCH_3_00) { + info->ppc.arch_3_00 = true; + } else if (hwcaps & PPC_FEATURE2_ARCH_2_07) { + info->ppc.arch_2_07 = true; + } +#elif defined(__APPLE__) + /* no Mac OS X version supports CPU with Power AVI v2.07 or better */ + info->ppc.arch_2_07 = false; + info->ppc.arch_3_00 = false; +#else +#error Unsupported platform! Please add support for reading ppc hwcaps. +#endif + #else info->ppc.arch_2_07 = false; info->ppc.arch_3_00 = false; diff --git a/sys/src/cmd/audio/libFLAC/format.c b/sys/src/cmd/audio/libFLAC/format.c index 6f626c228..ff6f30ffc 100644 --- a/sys/src/cmd/audio/libFLAC/format.c +++ b/sys/src/cmd/audio/libFLAC/format.c @@ -44,11 +44,10 @@ #include "private/format.h" #include "private/macros.h" -#define PACKAGE_VERSION "1.3.3" - +/* PACKAGE_VERSION should come from configure */ FLAC_API const char *FLAC__VERSION_STRING = PACKAGE_VERSION; -FLAC_API const char *FLAC__VENDOR_STRING = "reference libFLAC " PACKAGE_VERSION " 20190804"; +FLAC_API const char *FLAC__VENDOR_STRING = "reference libFLAC " PACKAGE_VERSION " 20220220"; FLAC_API const FLAC__byte FLAC__STREAM_SYNC_STRING[4] = { 'f','L','a','C' }; FLAC_API const uint32_t FLAC__STREAM_SYNC = 0x664C6143; diff --git a/sys/src/cmd/audio/libFLAC/lpc.c b/sys/src/cmd/audio/libFLAC/lpc.c index 923ec4927..29555141e 100644 --- a/sys/src/cmd/audio/libFLAC/lpc.c +++ b/sys/src/cmd/audio/libFLAC/lpc.c @@ -54,9 +54,9 @@ #if defined(_MSC_VER) && (_MSC_VER < 1800) #include #elif defined(Plan9) -#define copysign(x,y) ((x > 0.0 && y < 0.0) || (x < 0.0 && y > 0.0)) ? -x : x +#define _copysign(x,y) ((x > 0.0 && y < 0.0) || (x < 0.0 && y > 0.0)) ? -x : x static inline long int lround(double x) { - return (long)(x + copysign(0.5, x)); + return (long)(x + _copysign(0.5, x)); } #elif !defined(HAVE_LROUND) && defined(__GNUC__) static inline long int lround(double x) { @@ -1106,7 +1106,7 @@ void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, u sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; - data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization); + data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); } } else { /* order == 11 */ @@ -1123,7 +1123,7 @@ void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, u sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; - data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization); + data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); } } } @@ -1141,7 +1141,7 @@ void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, u sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; - data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization); + data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); } } else { /* order == 9 */ @@ -1156,7 +1156,7 @@ void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, u sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; - data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization); + data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); } } } @@ -1174,7 +1174,7 @@ void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, u sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; - data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization); + data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); } } else { /* order == 7 */ @@ -1187,7 +1187,7 @@ void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, u sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; - data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization); + data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); } } } @@ -1201,7 +1201,7 @@ void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, u sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; - data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization); + data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); } } else { /* order == 5 */ @@ -1212,7 +1212,7 @@ void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, u sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; - data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization); + data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); } } } @@ -1226,7 +1226,7 @@ void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, u sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; - data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization); + data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); } } else { /* order == 3 */ @@ -1235,7 +1235,7 @@ void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, u sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; - data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization); + data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); } } } @@ -1245,7 +1245,7 @@ void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, u sum = 0; sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; - data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization); + data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); } } else { /* order == 1 */ @@ -1292,7 +1292,7 @@ void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, u sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2]; sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1]; } - data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization); + data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); } } } diff --git a/sys/src/cmd/audio/libFLAC/metadata_iterators.c b/sys/src/cmd/audio/libFLAC/metadata_iterators.c index 352a6c7aa..17f25cd6e 100644 --- a/sys/src/cmd/audio/libFLAC/metadata_iterators.c +++ b/sys/src/cmd/audio/libFLAC/metadata_iterators.c @@ -3422,13 +3422,19 @@ FLAC__bool get_file_stats_(const char *filename, struct flac_stat_s *stats) void set_file_stats_(const char *filename, struct flac_stat_s *stats) { +#if defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200809L) + struct timespec srctime[2] = {}; + srctime[0].tv_sec = stats->st_atime; + srctime[1].tv_sec = stats->st_mtime; +#else struct utimbuf srctime; + srctime.actime = stats->st_atime; + srctime.modtime = stats->st_mtime; +#endif FLAC__ASSERT(0 != filename); FLAC__ASSERT(0 != stats); - srctime.actime = stats->st_atime; - srctime.modtime = stats->st_mtime; (void)flac_chmod(filename, stats->st_mode); (void)flac_utime(filename, &srctime); #if !defined _MSC_VER && !defined __BORLANDC__ && !defined __MINGW32__ diff --git a/sys/src/cmd/audio/libFLAC/mkfile b/sys/src/cmd/audio/libFLAC/mkfile index a50a762c4..4de6ac9ac 100644 --- a/sys/src/cmd/audio/libFLAC/mkfile +++ b/sys/src/cmd/audio/libFLAC/mkfile @@ -26,6 +26,6 @@ OFILES=\ window.$O\ CC=pcc -CFLAGS=-I. -I../libogg -DVERSION="1.3.3" -DPlan9 -DFLAC__NO_ASM -DFLAC__HAS_OGG -DFLAC__ALIGN_MALLOC_DATA -D_C99_SNPRINTF_EXTENSION -D_BSD_EXTENSION -D_POSIX_SOURCE -DHAVE_STDINT_H -DNDEBUG -c +CFLAGS=-I. -I../libogg -DPACKAGE_VERSION="1.3.4" -DPlan9 -DFLAC__NO_ASM -DFLAC__HAS_OGG -DFLAC__ALIGN_MALLOC_DATA -D_C99_SNPRINTF_EXTENSION -D_BSD_EXTENSION -D_POSIX_SOURCE -DHAVE_STDINT_H -DNDEBUG -c 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)) /* GCC 4.9+ */ #define FLAC__SSE_TARGET(x) __attribute__ ((__target__ (x))) #define FLAC__SSE_SUPPORTED 1 diff --git a/sys/src/cmd/audio/libFLAC/private/macros.h b/sys/src/cmd/audio/libFLAC/private/macros.h index 02eada455..3a8072ece 100644 --- a/sys/src/cmd/audio/libFLAC/private/macros.h +++ b/sys/src/cmd/audio/libFLAC/private/macros.h @@ -51,8 +51,10 @@ /* Whatever other unix that has sys/param.h */ #elif defined(HAVE_SYS_PARAM_H) #include +#if defined(MIN) && defined(MAX) #define flac_max(a,b) MAX(a,b) #define flac_min(a,b) MIN(a,b) +#endif /* Windows VS has them in stdlib.h.. XXX:Untested */ #elif defined(_MSC_VER) diff --git a/sys/src/cmd/audio/libFLAC/share/compat.h b/sys/src/cmd/audio/libFLAC/share/compat.h index f30416554..c28054be9 100644 --- a/sys/src/cmd/audio/libFLAC/share/compat.h +++ b/sys/src/cmd/audio/libFLAC/share/compat.h @@ -112,9 +112,13 @@ #include /* for utime() */ #endif #else +#if defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200809L) +#include +#else #include /* some flavors of BSD (like OS X) require this to get time_t */ #include /* for utime() */ #endif +#endif #if defined _MSC_VER # if _MSC_VER >= 1800 @@ -160,11 +164,15 @@ #define flac_fopen fopen #define flac_chmod chmod -#define flac_utime utime #define flac_unlink unlink #define flac_rename rename #define flac_stat stat +#if defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200809L) +#define flac_utime(a, b) utimensat (AT_FDCWD, a, *b, 0) +#else +#define flac_utime utime +#endif #endif #ifdef _WIN32 diff --git a/sys/src/cmd/audio/libFLAC/share/safe_str.h b/sys/src/cmd/audio/libFLAC/share/safe_str.h index eb974c517..6709334e5 100644 --- a/sys/src/cmd/audio/libFLAC/share/safe_str.h +++ b/sys/src/cmd/audio/libFLAC/share/safe_str.h @@ -46,7 +46,9 @@ safe_strncat(char *dest, const char *src, size_t dest_size) if (dest_size < 1) return dest; + /* Assume dist has space for a term character .. */ ret = strncat(dest, src, dest_size - strlen (dest)); + /* .. but set it explicitly. */ dest [dest_size - 1] = 0; return ret; @@ -60,7 +62,7 @@ safe_strncpy(char *dest, const char *src, size_t dest_size) if (dest_size < 1) return dest; - ret = strncpy(dest, src, dest_size); + ret = strncpy(dest, src, dest_size - 1); dest [dest_size - 1] = 0; return ret; diff --git a/sys/src/cmd/audio/libFLAC/stream_decoder.c b/sys/src/cmd/audio/libFLAC/stream_decoder.c index db1f3202b..ef6da44e3 100644 --- a/sys/src/cmd/audio/libFLAC/stream_decoder.c +++ b/sys/src/cmd/audio/libFLAC/stream_decoder.c @@ -1628,6 +1628,8 @@ FLAC__bool read_metadata_streaminfo_(FLAC__StreamDecoder *decoder, FLAC__bool is /* skip the rest of the block */ FLAC__ASSERT(used_bits % 8 == 0); + if (length < (used_bits / 8)) + return false; /* read_callback_ sets the state for us */ length -= (used_bits / 8); if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(decoder->private_->input, length)) return false; /* read_callback_ sets the state for us */ @@ -2079,7 +2081,11 @@ FLAC__bool read_frame_(FLAC__StreamDecoder *decoder, FLAC__bool *got_a_frame, FL frame_crc = FLAC__bitreader_get_read_crc16(decoder->private_->input); if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__FRAME_FOOTER_CRC_LEN)) return false; /* read_callback_ sets the state for us */ +#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION + if(1){ +#else if(frame_crc == x) { +#endif if(do_full_decode) { /* Undo any special channel coding */ switch(decoder->private_->frame.header.channel_assignment) { @@ -2353,9 +2359,16 @@ FLAC__bool read_frame_header_(FLAC__StreamDecoder *decoder) break; } + if(decoder->private_->frame.header.bits_per_sample == 32 && decoder->private_->frame.header.channel_assignment != FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT){ + /* Decoder isn't equipped for 33-bit side frame */ + is_unparseable = true; + } + +#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION /* check to make sure that reserved bit is 0 */ if(raw_header[3] & 0x01) /* MAGIC NUMBER */ is_unparseable = true; +#endif /* read the frame's starting sample number (or frame number as the case may be) */ if( @@ -2427,11 +2440,13 @@ FLAC__bool read_frame_header_(FLAC__StreamDecoder *decoder) return false; /* read_callback_ sets the state for us */ crc8 = (FLAC__byte)x; +#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION if(FLAC__crc8(raw_header, raw_header_len) != crc8) { send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER); decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; return true; } +#endif /* calculate the sample number from the frame number if needed */ decoder->private_->next_fixed_block_size = 0; @@ -2513,7 +2528,19 @@ FLAC__bool read_subframe_(FLAC__StreamDecoder *decoder, uint32_t channel, uint32 return true; } else if(x <= 24) { - if(!read_subframe_fixed_(decoder, channel, bps, (x>>1)&7, do_full_decode)) + uint32_t predictor_order = (x>>1)&7; + if(decoder->private_->frame.header.bits_per_sample > 24){ + /* Decoder isn't equipped for fixed subframes with more than 24 bps */ + send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM); + decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; + return true; + } + if(decoder->private_->frame.header.blocksize <= predictor_order){ + send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); + decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; + return true; + } + if(!read_subframe_fixed_(decoder, channel, bps, predictor_order, do_full_decode)) return false; if(decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC) /* means bad sync or got corruption */ return true; @@ -2524,7 +2551,13 @@ FLAC__bool read_subframe_(FLAC__StreamDecoder *decoder, uint32_t channel, uint32 return true; } else { - if(!read_subframe_lpc_(decoder, channel, bps, ((x>>1)&31)+1, do_full_decode)) + uint32_t predictor_order = ((x>>1)&31)+1; + if(decoder->private_->frame.header.blocksize <= predictor_order){ + send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); + decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; + return true; + } + if(!read_subframe_lpc_(decoder, channel, bps, predictor_order, do_full_decode)) return false; if(decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC) /* means bad sync or got corruption */ return true; @@ -2592,7 +2625,8 @@ FLAC__bool read_subframe_fixed_(FLAC__StreamDecoder *decoder, uint32_t channel, case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN)) return false; /* read_callback_ sets the state for us */ - if(decoder->private_->frame.header.blocksize >> u32 < order) { + if((decoder->private_->frame.header.blocksize >> u32 < order) || + (decoder->private_->frame.header.blocksize % (1 << u32) > 0)) { send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; return true; @@ -2681,7 +2715,8 @@ FLAC__bool read_subframe_lpc_(FLAC__StreamDecoder *decoder, uint32_t channel, ui case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN)) return false; /* read_callback_ sets the state for us */ - if(decoder->private_->frame.header.blocksize >> u32 < order) { + if((decoder->private_->frame.header.blocksize >> u32 < order) || + (decoder->private_->frame.header.blocksize % (1 << u32) > 0)) { send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; return true; @@ -2750,7 +2785,7 @@ FLAC__bool read_residual_partitioned_rice_(FLAC__StreamDecoder *decoder, uint32_ int i; uint32_t partition, sample, u; const uint32_t partitions = 1u << partition_order; - const uint32_t partition_samples = partition_order > 0? decoder->private_->frame.header.blocksize >> partition_order : decoder->private_->frame.header.blocksize - predictor_order; + const uint32_t partition_samples = decoder->private_->frame.header.blocksize >> partition_order; const uint32_t plen = is_extended? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN; const uint32_t pesc = is_extended? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER; @@ -2769,7 +2804,7 @@ FLAC__bool read_residual_partitioned_rice_(FLAC__StreamDecoder *decoder, uint32_ partitioned_rice_contents->parameters[partition] = rice_parameter; if(rice_parameter < pesc) { partitioned_rice_contents->raw_bits[partition] = 0; - u = (partition_order == 0 || partition > 0)? partition_samples : partition_samples - predictor_order; + u = (partition == 0) ? partition_samples - predictor_order : partition_samples; if(!FLAC__bitreader_read_rice_signed_block(decoder->private_->input, residual + sample, u, rice_parameter)) return false; /* read_callback_ sets the state for us */ sample += u; @@ -2778,7 +2813,7 @@ FLAC__bool read_residual_partitioned_rice_(FLAC__StreamDecoder *decoder, uint32_ if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN)) return false; /* read_callback_ sets the state for us */ partitioned_rice_contents->raw_bits[partition] = rice_parameter; - for(u = (partition_order == 0 || partition > 0)? 0 : predictor_order; u < partition_samples; u++, sample++) { + for(u = (partition == 0)? predictor_order : 0; u < partition_samples; u++, sample++) { if(!FLAC__bitreader_read_raw_int32(decoder->private_->input, &i, rice_parameter)) return false; /* read_callback_ sets the state for us */ residual[sample] = i; @@ -2795,10 +2830,12 @@ FLAC__bool read_zero_padding_(FLAC__StreamDecoder *decoder) FLAC__uint32 zero = 0; if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &zero, FLAC__bitreader_bits_left_for_byte_alignment(decoder->private_->input))) return false; /* read_callback_ sets the state for us */ +#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION if(zero != 0) { send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC); decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; } +#endif } return true; } @@ -3030,15 +3067,26 @@ FLAC__bool seek_to_absolute_sample_(FLAC__StreamDecoder *decoder, FLAC__uint64 s /* * First, we set an upper and lower bound on where in the - * stream we will search. For now we assume the worst case - * scenario, which is our best guess at the beginning of - * the first frame and end of the stream. + * stream we will search. For now we take the current position + * as one bound and, depending on where the target position lies, + * the beginning of the first frame or the end of the stream as + * the other bound. */ lower_bound = first_frame_offset; lower_bound_sample = 0; upper_bound = stream_length; upper_bound_sample = total_samples > 0 ? total_samples : target_sample /*estimate it*/; + if(decoder->protected_->state == FLAC__STREAM_DECODER_READ_FRAME) { + if(target_sample < decoder->private_->samples_decoded) { + if(FLAC__stream_decoder_get_decode_position(decoder, &upper_bound)) + upper_bound_sample = decoder->private_->samples_decoded; + } else { + if(FLAC__stream_decoder_get_decode_position(decoder, &lower_bound)) + lower_bound_sample = decoder->private_->samples_decoded; + } + } + /* * Now we refine the bounds if we have a seektable with * suitable points. Note that according to the spec they @@ -3117,8 +3165,10 @@ FLAC__bool seek_to_absolute_sample_(FLAC__StreamDecoder *decoder, FLAC__uint64 s /* a little less accurate: */ if(upper_bound - lower_bound < 0xffffffff) pos = (FLAC__int64)lower_bound + (FLAC__int64)(((target_sample - lower_bound_sample) * (upper_bound - lower_bound)) / (upper_bound_sample - lower_bound_sample)) - approx_bytes_per_frame; - else /* @@@ WATCHOUT, ~2TB limit */ - pos = (FLAC__int64)lower_bound + (FLAC__int64)((((target_sample - lower_bound_sample)>>8) * ((upper_bound - lower_bound)>>8)) / ((upper_bound_sample - lower_bound_sample)>>16)) - approx_bytes_per_frame; + else { /* @@@ WATCHOUT, ~2TB limit */ + FLAC__uint64 ratio = (1<<16) / (upper_bound_sample - lower_bound_sample); + pos = (FLAC__int64)lower_bound + (FLAC__int64)((((target_sample - lower_bound_sample)>>8) * ((upper_bound - lower_bound)>>8) * ratio)) - approx_bytes_per_frame; + } #endif if(pos >= (FLAC__int64)upper_bound) pos = (FLAC__int64)upper_bound - 1; @@ -3315,7 +3365,7 @@ FLAC__bool seek_to_absolute_sample_ogg_(FLAC__StreamDecoder *decoder, FLAC__uint } left_pos = pos; } - else if(this_frame_sample > target_sample) { + else { right_sample = this_frame_sample; /* sanity check to avoid infinite loop */ if (right_pos == pos) { diff --git a/sys/src/cmd/audio/libFLAC/stream_encoder.c b/sys/src/cmd/audio/libFLAC/stream_encoder.c index 74387ec3b..7109802c2 100644 --- a/sys/src/cmd/audio/libFLAC/stream_encoder.c +++ b/sys/src/cmd/audio/libFLAC/stream_encoder.c @@ -2610,7 +2610,9 @@ FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, uint32_t samples, FLAC encoder->private_->verify.needs_magic_hack = true; } else { - if(!FLAC__stream_decoder_process_single(encoder->private_->verify.decoder)) { + if(!FLAC__stream_decoder_process_single(encoder->private_->verify.decoder) + || (!is_last_block + && (FLAC__stream_encoder_get_verify_decoder_state(encoder) == FLAC__STREAM_DECODER_END_OF_STREAM))) { FLAC__bitwriter_release_buffer(encoder->private_->frame); FLAC__bitwriter_clear(encoder->private_->frame); if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA) @@ -4110,13 +4112,14 @@ static inline uint32_t count_rice_bits_in_partition_( const FLAC__int32 *residual ) { - uint32_t i, partition_bits = + uint32_t i; + uint64_t partition_bits = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN + /* actually could end up being FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN but err on side of 16bps */ (1+rice_parameter) * partition_samples /* 1 for unary stop bit + rice_parameter for the binary portion */ ; for(i = 0; i < partition_samples; i++) partition_bits += ( (FLAC__uint32)((residual[i]<<1)^(residual[i]>>31)) >> rice_parameter ); - return partition_bits; + return (uint32_t)(flac_min(partition_bits,(uint32_t)(-1))); // To make sure the return value doesn't overflow } #else static inline uint32_t count_rice_bits_in_partition_( @@ -4125,15 +4128,15 @@ static inline uint32_t count_rice_bits_in_partition_( const FLAC__uint64 abs_residual_partition_sum ) { - return + return (uint32_t)(flac_min( // To make sure the return value doesn't overflow FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN + /* actually could end up being FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN but err on side of 16bps */ (1+rice_parameter) * partition_samples + /* 1 for unary stop bit + rice_parameter for the binary portion */ ( rice_parameter? - (uint32_t)(abs_residual_partition_sum >> (rice_parameter-1)) /* rice_parameter-1 because the real coder sign-folds instead of using a sign bit */ - : (uint32_t)(abs_residual_partition_sum << 1) /* can't shift by negative number, so reverse */ + (abs_residual_partition_sum >> (rice_parameter-1)) /* rice_parameter-1 because the real coder sign-folds instead of using a sign bit */ + : (abs_residual_partition_sum << 1) /* can't shift by negative number, so reverse */ ) - - (partition_samples >> 1) + - (partition_samples >> 1),(uint32_t)(-1))); /* -(partition_samples>>1) to subtract out extra contributions to the abs_residual_partition_sum. * The actual number of bits used is closer to the sum(for all i in the partition) of abs(residual[i])>>(rice_parameter-1) * By using the abs_residual_partition sum, we also add in bits in the LSBs that would normally be shifted out. @@ -4224,7 +4227,10 @@ FLAC__bool set_partitioned_rice_( raw_bits[0] = 0; } parameters[0] = best_rice_parameter; - bits_ += best_partition_bits; + if(best_partition_bits < UINT_MAX - bits_) // To make sure _bits doesn't overflow + bits_ += best_partition_bits; + else + bits_ = UINT_MAX; } else { uint32_t partition, residual_sample; @@ -4327,7 +4333,10 @@ FLAC__bool set_partitioned_rice_( raw_bits[partition] = 0; } parameters[partition] = best_rice_parameter; - bits_ += best_partition_bits; + if(best_partition_bits < UINT_MAX - bits_) // To make sure _bits doesn't overflow + bits_ += best_partition_bits; + else + bits_ = UINT_MAX; residual_sample += partition_samples; } } diff --git a/sys/src/cmd/audio/libFLAC/window.c b/sys/src/cmd/audio/libFLAC/window.c index 769832861..8bf6bb84b 100644 --- a/sys/src/cmd/audio/libFLAC/window.c +++ b/sys/src/cmd/audio/libFLAC/window.c @@ -42,6 +42,10 @@ #ifndef FLAC__INTEGER_ONLY_LIBRARY +#ifdef Plan9 +#define cosf cos +#define fabsf fabs +#endif void FLAC__window_bartlett(FLAC__real *window, const FLAC__int32 L) { @@ -68,7 +72,7 @@ void FLAC__window_bartlett_hann(FLAC__real *window, const FLAC__int32 L) FLAC__int32 n; for (n = 0; n < L; n++) - window[n] = (FLAC__real)(0.62f - 0.48f * fabs((float)n/(float)N-0.5f) - 0.38f * cos(2.0f * M_PI * ((float)n/(float)N))); + window[n] = (FLAC__real)(0.62f - 0.48f * fabsf((float)n/(float)N-0.5f) - 0.38f * cosf(2.0f * M_PI * ((float)n/(float)N))); } void FLAC__window_blackman(FLAC__real *window, const FLAC__int32 L) @@ -77,7 +81,7 @@ void FLAC__window_blackman(FLAC__real *window, const FLAC__int32 L) FLAC__int32 n; for (n = 0; n < L; n++) - window[n] = (FLAC__real)(0.42f - 0.5f * cos(2.0f * M_PI * n / N) + 0.08f * cos(4.0f * M_PI * n / N)); + window[n] = (FLAC__real)(0.42f - 0.5f * cosf(2.0f * M_PI * n / N) + 0.08f * cosf(4.0f * M_PI * n / N)); } /* 4-term -92dB side-lobe */ @@ -87,7 +91,7 @@ void FLAC__window_blackman_harris_4term_92db_sidelobe(FLAC__real *window, const FLAC__int32 n; for (n = 0; n <= N; n++) - window[n] = (FLAC__real)(0.35875f - 0.48829f * cos(2.0f * M_PI * n / N) + 0.14128f * cos(4.0f * M_PI * n / N) - 0.01168f * cos(6.0f * M_PI * n / N)); + window[n] = (FLAC__real)(0.35875f - 0.48829f * cosf(2.0f * M_PI * n / N) + 0.14128f * cosf(4.0f * M_PI * n / N) - 0.01168f * cosf(6.0f * M_PI * n / N)); } void FLAC__window_connes(FLAC__real *window, const FLAC__int32 L) @@ -109,7 +113,7 @@ void FLAC__window_flattop(FLAC__real *window, const FLAC__int32 L) FLAC__int32 n; for (n = 0; n < L; n++) - window[n] = (FLAC__real)(0.21557895f - 0.41663158f * cos(2.0f * M_PI * n / N) + 0.277263158f * cos(4.0f * M_PI * n / N) - 0.083578947f * cos(6.0f * M_PI * n / N) + 0.006947368f * cos(8.0f * M_PI * n / N)); + window[n] = (FLAC__real)(0.21557895f - 0.41663158f * cosf(2.0f * M_PI * n / N) + 0.277263158f * cosf(4.0f * M_PI * n / N) - 0.083578947f * cosf(6.0f * M_PI * n / N) + 0.006947368f * cosf(8.0f * M_PI * n / N)); } void FLAC__window_gauss(FLAC__real *window, const FLAC__int32 L, const FLAC__real stddev) @@ -130,7 +134,7 @@ void FLAC__window_hamming(FLAC__real *window, const FLAC__int32 L) FLAC__int32 n; for (n = 0; n < L; n++) - window[n] = (FLAC__real)(0.54f - 0.46f * cos(2.0f * M_PI * n / N)); + window[n] = (FLAC__real)(0.54f - 0.46f * cosf(2.0f * M_PI * n / N)); } void FLAC__window_hann(FLAC__real *window, const FLAC__int32 L) @@ -139,7 +143,7 @@ void FLAC__window_hann(FLAC__real *window, const FLAC__int32 L) FLAC__int32 n; for (n = 0; n < L; n++) - window[n] = (FLAC__real)(0.5f - 0.5f * cos(2.0f * M_PI * n / N)); + window[n] = (FLAC__real)(0.5f - 0.5f * cosf(2.0f * M_PI * n / N)); } void FLAC__window_kaiser_bessel(FLAC__real *window, const FLAC__int32 L) @@ -148,7 +152,7 @@ void FLAC__window_kaiser_bessel(FLAC__real *window, const FLAC__int32 L) FLAC__int32 n; for (n = 0; n < L; n++) - window[n] = (FLAC__real)(0.402f - 0.498f * cos(2.0f * M_PI * n / N) + 0.098f * cos(4.0f * M_PI * n / N) - 0.001f * cos(6.0f * M_PI * n / N)); + window[n] = (FLAC__real)(0.402f - 0.498f * cosf(2.0f * M_PI * n / N) + 0.098f * cosf(4.0f * M_PI * n / N) - 0.001f * cosf(6.0f * M_PI * n / N)); } void FLAC__window_nuttall(FLAC__real *window, const FLAC__int32 L) @@ -157,7 +161,7 @@ void FLAC__window_nuttall(FLAC__real *window, const FLAC__int32 L) FLAC__int32 n; for (n = 0; n < L; n++) - window[n] = (FLAC__real)(0.3635819f - 0.4891775f*cos(2.0f*M_PI*n/N) + 0.1365995f*cos(4.0f*M_PI*n/N) - 0.0106411f*cos(6.0f*M_PI*n/N)); + window[n] = (FLAC__real)(0.3635819f - 0.4891775f*cosf(2.0f*M_PI*n/N) + 0.1365995f*cosf(4.0f*M_PI*n/N) - 0.0106411f*cosf(6.0f*M_PI*n/N)); } void FLAC__window_rectangle(FLAC__real *window, const FLAC__int32 L) @@ -200,8 +204,8 @@ void FLAC__window_tukey(FLAC__real *window, const FLAC__int32 L, const FLAC__rea /* ...replace ends with hann */ if (Np > 0) { for (n = 0; n <= Np; n++) { - window[n] = (FLAC__real)(0.5f - 0.5f * cos(M_PI * n / Np)); - window[L-Np-1+n] = (FLAC__real)(0.5f - 0.5f * cos(M_PI * (n+Np) / Np)); + window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * n / Np)); + window[L-Np-1+n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * (n+Np) / Np)); } } } @@ -225,11 +229,11 @@ void FLAC__window_partial_tukey(FLAC__real *window, const FLAC__int32 L, const F for (n = 0; n < start_n && n < L; n++) window[n] = 0.0f; for (i = 1; n < (start_n+Np) && n < L; n++, i++) - window[n] = (FLAC__real)(0.5f - 0.5f * cos(M_PI * i / Np)); + window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Np)); for (; n < (end_n-Np) && n < L; n++) window[n] = 1.0f; for (i = Np; n < end_n && n < L; n++, i--) - window[n] = (FLAC__real)(0.5f - 0.5f * cos(M_PI * i / Np)); + window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Np)); for (; n < L; n++) window[n] = 0.0f; } @@ -251,19 +255,19 @@ void FLAC__window_punchout_tukey(FLAC__real *window, const FLAC__int32 L, const Ne = (FLAC__int32)(p / 2.0f * (L - end_n)); for (n = 0, i = 1; n < Ns && n < L; n++, i++) - window[n] = (FLAC__real)(0.5f - 0.5f * cos(M_PI * i / Ns)); + window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ns)); for (; n < start_n-Ns && n < L; n++) window[n] = 1.0f; for (i = Ns; n < start_n && n < L; n++, i--) - window[n] = (FLAC__real)(0.5f - 0.5f * cos(M_PI * i / Ns)); + window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ns)); for (; n < end_n && n < L; n++) window[n] = 0.0f; for (i = 1; n < end_n+Ne && n < L; n++, i++) - window[n] = (FLAC__real)(0.5f - 0.5f * cos(M_PI * i / Ne)); + window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ne)); for (; n < L - (Ne) && n < L; n++) window[n] = 1.0f; for (i = Ne; n < L; n++, i--) - window[n] = (FLAC__real)(0.5f - 0.5f * cos(M_PI * i / Ne)); + window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ne)); } }