libFLAC: update to 1.3.4
This commit is contained in:
Sigrid Solveig Haflínudóttir
parent
065d601916
commit
0e3a955652
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -54,8 +54,10 @@
|
|||
#endif
|
||||
|
||||
#if defined FLAC__CPU_PPC
|
||||
#if defined(__linux__) || (defined(__FreeBSD__) && (__FreeBSD__ >= 12))
|
||||
#include <sys/auxv.h>
|
||||
#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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -54,9 +54,9 @@
|
|||
#if defined(_MSC_VER) && (_MSC_VER < 1800)
|
||||
#include <float.h>
|
||||
#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));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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__
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
</sys/src/cmd/mklib
|
||||
|
|
|
|||
|
|
@ -90,9 +90,15 @@
|
|||
#if __has_builtin(__builtin_ia32_pmuldq128)
|
||||
#define FLAC__SSE4_1_SUPPORTED 1
|
||||
#endif
|
||||
#if __has_builtin(__builtin_ia32_maxps256)
|
||||
#define FLAC__AVX_SUPPORTED 1
|
||||
#endif
|
||||
#if __has_builtin(__builtin_ia32_pabsd256)
|
||||
#define FLAC__AVX2_SUPPORTED 1
|
||||
#endif
|
||||
#if __has_builtin(__builtin_ia32_vfmaddps)
|
||||
#define FLAC__FMA_SUPPORTED 1
|
||||
#endif
|
||||
#elif defined __GNUC__ && !defined __clang__ && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)) /* GCC 4.9+ */
|
||||
#define FLAC__SSE_TARGET(x) __attribute__ ((__target__ (x)))
|
||||
#define FLAC__SSE_SUPPORTED 1
|
||||
|
|
|
|||
|
|
@ -51,8 +51,10 @@
|
|||
/* Whatever other unix that has sys/param.h */
|
||||
#elif defined(HAVE_SYS_PARAM_H)
|
||||
#include <sys/param.h>
|
||||
#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)
|
||||
|
|
|
|||
|
|
@ -112,9 +112,13 @@
|
|||
#include <sys/utime.h> /* for utime() */
|
||||
#endif
|
||||
#else
|
||||
#if defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200809L)
|
||||
#include <fcntl.h>
|
||||
#else
|
||||
#include <sys/types.h> /* some flavors of BSD (like OS X) require this to get time_t */
|
||||
#include <utime.h> /* 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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue