~mcf/plan9front

0e3a955652d4065e18197fffb5b5421308b92a47 — Sigrid Solveig Haflínudóttir 2 years ago 065d601
libFLAC: update to 1.3.4
M sys/src/cmd/audio/libFLAC/bitreader.c => sys/src/cmd/audio/libFLAC/bitreader.c +23 -15
@@ 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);
	}


M sys/src/cmd/audio/libFLAC/cpu.c => sys/src/cmd/audio/libFLAC/cpu.c +20 -0
@@ 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;

M sys/src/cmd/audio/libFLAC/format.c => sys/src/cmd/audio/libFLAC/format.c +2 -3
@@ 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;

M sys/src/cmd/audio/libFLAC/lpc.c => sys/src/cmd/audio/libFLAC/lpc.c +14 -14
@@ 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));
		}
	}
}

M sys/src/cmd/audio/libFLAC/metadata_iterators.c => sys/src/cmd/audio/libFLAC/metadata_iterators.c +8 -2
@@ 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__

M sys/src/cmd/audio/libFLAC/mkfile => sys/src/cmd/audio/libFLAC/mkfile +1 -1
@@ 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

M sys/src/cmd/audio/libFLAC/private/cpu.h => sys/src/cmd/audio/libFLAC/private/cpu.h +6 -0
@@ 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

M sys/src/cmd/audio/libFLAC/private/macros.h => sys/src/cmd/audio/libFLAC/private/macros.h +2 -0
@@ 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)

M sys/src/cmd/audio/libFLAC/share/compat.h => sys/src/cmd/audio/libFLAC/share/compat.h +9 -1
@@ 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

M sys/src/cmd/audio/libFLAC/share/safe_str.h => sys/src/cmd/audio/libFLAC/share/safe_str.h +3 -1
@@ 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;

M sys/src/cmd/audio/libFLAC/stream_decoder.c => sys/src/cmd/audio/libFLAC/stream_decoder.c +63 -13
@@ 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) {

M sys/src/cmd/audio/libFLAC/stream_encoder.c => sys/src/cmd/audio/libFLAC/stream_encoder.c +18 -9
@@ 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;
		}
	}

M sys/src/cmd/audio/libFLAC/window.c => sys/src/cmd/audio/libFLAC/window.c +20 -16
@@ 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));
	}
}