From a5af9c3d351085f4005a949f8c382a3aad4e0b29 Mon Sep 17 00:00:00 2001 From: Onur Gündüz Date: Thu, 8 Oct 2026 06:49:33 +0200 Subject: init --- .gitignore | 4 + Makefile | 63 +++++++ README.md | 74 ++++++++ kernels.c | 429 ++++++++++++++++++++++++++++++++++++++++++++++ kernels.h | 52 ++++++ rfft.c | 190 ++++++++++++++++++++ rfft.h | 49 ++++++ scripts/export_weights.py | 367 +++++++++++++++++++++++++++++++++++++++ segment.c | 258 ++++++++++++++++++++++++++++ svad.c | 300 ++++++++++++++++++++++++++++++++ svad.h | 158 +++++++++++++++++ weights.c | 178 +++++++++++++++++++ weights.h | 73 ++++++++ 13 files changed, 2195 insertions(+) create mode 100644 .gitignore create mode 100644 Makefile create mode 100644 README.md create mode 100644 kernels.c create mode 100644 kernels.h create mode 100644 rfft.c create mode 100644 rfft.h create mode 100644 scripts/export_weights.py create mode 100644 segment.c create mode 100644 svad.c create mode 100644 svad.h create mode 100644 weights.c create mode 100644 weights.h diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..89c6270 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +build +libsvad.a +/weights_16k.h +/weights_8k.h diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..0cfef55 --- /dev/null +++ b/Makefile @@ -0,0 +1,63 @@ +CC ?= cc +AR ?= ar +MODE ?= release +ARCH_FLAGS ?= +TARGET ?= libsvad.a +OBJDIR := build/obj +BUILD_CONFIG := build/.build-config + +CPPFLAGS += -I. +WARNING_FLAGS ?= -Wall -Wextra -Werror=implicit-function-declaration +ifeq ($(MODE),release) +OPT_FLAGS ?= -O3 -DNDEBUG +else ifeq ($(MODE),debug) +OPT_FLAGS ?= -O0 -g3 -fno-omit-frame-pointer +else ifeq ($(MODE),profile) +OPT_FLAGS ?= -O2 -g -fno-omit-frame-pointer +else +$(error MODE must be release, debug, or profile) +endif +CFLAGS ?= $(OPT_FLAGS) $(WARNING_FLAGS) -std=gnu11 $(ARCH_FLAGS) +ARFLAGS := rcs + +SOURCES := kernels.c rfft.c segment.c svad.c weights.c +OBJECTS := $(patsubst %.c,$(OBJDIR)/%.o,$(SOURCES)) +HEADERS := $(wildcard *.h) + +.PHONY: all release debug profile clean FORCE + +all: $(TARGET) + +release: + $(MAKE) MODE=release all + +debug: + $(MAKE) MODE=debug all + +profile: + $(MAKE) MODE=profile all + +$(TARGET): $(OBJECTS) + $(RM) $@ + $(AR) $(ARFLAGS) $@ $^ + +$(OBJECTS): $(BUILD_CONFIG) + +$(OBJECTS): $(OBJDIR)/%.o: %.c $(HEADERS) | build + @mkdir -p $(dir $@) + $(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@ + +$(BUILD_CONFIG): FORCE | build + @printf '%s\n' 'MODE=$(MODE)' 'CC=$(CC)' \ + 'CPPFLAGS=$(CPPFLAGS)' 'CFLAGS=$(CFLAGS)' \ + 'ARCH_FLAGS=$(ARCH_FLAGS)' > $@.new + @cmp -s $@.new $@ || cp $@.new $@ + @rm -f $@.new + +FORCE: + +build: + mkdir -p $@ + +clean: + rm -rf build $(TARGET) diff --git a/README.md b/README.md new file mode 100644 index 0000000..88f135e --- /dev/null +++ b/README.md @@ -0,0 +1,74 @@ +# svad + +Voice activity detection library using [Silero VAD](https://github.com/snakers4/silero-vad) v6.2 weights. Supports mono 16 kHz and 8 kHz audio, speech probabilities, and speech segmentation. + +## Build + +To build the library, you need Make, a C11 compiler (GCC or Clang), and `ar`. + +### Get the weights + +This step needs `curl`, Python 3, and [uv](https://docs.astral.sh/uv/getting-started/installation/). The `uv` command below installs NumPy and ONNX for the script. Python is not needed to compile or run the C library. + +Run these commands from the project folder. They download the Silero VAD v6.2 models and create `weights_16k.h` and `weights_8k.h`. Both headers must be in this folder before you run `make`: + +```sh +mkdir -p build/models +base=https://raw.githubusercontent.com/snakers4/silero-vad/v6.2/src/silero_vad/data +curl -fL "$base/silero_vad_16k_op15.onnx" -o build/models/silero_vad_16k_op15.onnx +curl -fL "$base/silero_vad.onnx" -o build/models/silero_vad.onnx + +uv run --no-project --with numpy --with onnx python scripts/export_weights.py \ + build/models/silero_vad_16k_op15.onnx \ + build/models/silero_vad.onnx \ + build/generated + +cp build/generated/src/weights_16k.h build/generated/src/weights_8k.h . +``` + +The script also creates `build/generated/svad_weights.bin`. You only need that file if you use `svad_create_from_file` to load weights at run time. + +### Build the library + +```sh +make # builds libsvad.a +make debug # optional debug build +make clean # removes build outputs +``` + +Link your application with `libsvad.a` and `-lm`. + +## Usage + +Save this example as `example.c`. It reads raw mono signed 16-bit PCM in native byte order from standard input at 16 kHz and prints one speech probability per 32 ms chunk. Input must already be decoded and resampled; WAV headers are not accepted. + +```c +#include "svad.h" +#include + +int main(void) +{ + svad_t *vad = svad_create(16000); + if (!vad) return 1; + + const size_t chunk_size = (size_t)svad_chunk_samples(vad); + int16_t chunk[512]; + size_t n; + while ((n = fread(chunk, sizeof(*chunk), chunk_size, stdin)) > 0) { + for (size_t i = n; i < chunk_size; ++i) chunk[i] = 0; + printf("%.6f\n", svad_process_s16(vad, chunk)); + } + + svad_destroy(vad); + return ferror(stdin) ? 1 : 0; +} +``` + +```sh +cc -std=c11 -I. example.c libsvad.a -lm -o example +./example < audio.pcm +``` + +Use `svad_create(8000)` for 8 kHz audio. Each call consumes exactly 512 samples at 16 kHz or 256 at 8 kHz, without overlap. `svad_process_f32` accepts float samples in `[-1, 1]`. Call `svad_reset` before starting a new audio stream and use a separate instance for each concurrent stream. + +For speech boundaries, feed probabilities to `svad_segmenter_update` after `svad_segmenter_init`, or use `svad_speech_timestamps` for a complete recording. See [svad.h](./svad.h) for the API and segmentation parameters. diff --git a/kernels.c b/kernels.c new file mode 100644 index 0000000..2a6b8a2 --- /dev/null +++ b/kernels.c @@ -0,0 +1,429 @@ +/* Scalar and SIMD implementations of the matvec primitive. + * + * Every variant blocks four output rows together and, when there is more than + * one output time step, all the steps as well. Blocking rows amortises the + * activation loads, which stay in registers across the four rows; blocking + * steps amortises the weight loads, which are what the model is actually + * limited by. A 4x4 block issues eight vector loads for sixteen fused + * multiply-adds, against ten loads for eight in the single-step shape. + * + * The step count is folded in at the call site, so each specialisation has a + * fixed accumulator count and keeps them all in registers. + * + * Accumulation order differs between the variants, so their results differ in + * the last bits. tests/test_kernels.c and tests/test_parity.c bound that. */ + +#include "kernels.h" + +#include + +#if defined(__GNUC__) || defined(__clang__) +# define SVAD_INLINE static inline __attribute__((always_inline)) +#else +# define SVAD_INLINE static inline +#endif + +/* ---- portable C ------------------------------------------------------ */ + +SVAD_INLINE void mv_scalar_k(float *y, + int ys, + const float *W, + const float *x, + int xs, + const float *bias, + int m, + int n, + const int steps) { + int i = 0; + for (; i + 4 <= m; i += 4) { + const float *w0 = W + (size_t)i * n; + const float *w1 = w0 + n, *w2 = w1 + n, *w3 = w2 + n; + float acc[4][SVAD_MAX_STEPS] = {{0.0f}}; + for (int j = 0; j < n; ++j) { + const float a = w0[j], b = w1[j], c = w2[j], d = w3[j]; + for (int s = 0; s < steps; ++s) { + const float xv = x[(size_t)s * xs + j]; + acc[0][s] += a * xv; + acc[1][s] += b * xv; + acc[2][s] += c * xv; + acc[3][s] += d * xv; + } + } + for (int s = 0; s < steps; ++s) + for (int r = 0; r < 4; ++r) + y[(size_t)s * ys + i + r] = bias ? bias[i + r] + acc[r][s] : acc[r][s]; + } + for (; i < m; ++i) { + const float *w = W + (size_t)i * n; + float acc[SVAD_MAX_STEPS] = {0.0f}; + for (int j = 0; j < n; ++j) + for (int s = 0; s < steps; ++s) + acc[s] += w[j] * x[(size_t)s * xs + j]; + for (int s = 0; s < steps; ++s) + y[(size_t)s * ys + i] = bias ? bias[i] + acc[s] : acc[s]; + } +} + +static void matvec_scalar(float *y, + int ys, + const float *W, + const float *x, + int xs, + const float *bias, + int m, + int n, + int steps) { + switch (steps) { + case 1: + mv_scalar_k(y, ys, W, x, xs, bias, m, n, 1); + return; + case 2: + mv_scalar_k(y, ys, W, x, xs, bias, m, n, 2); + return; + case 4: + mv_scalar_k(y, ys, W, x, xs, bias, m, n, 4); + return; + default: + for (int s = 0; s < steps; ++s) + mv_scalar_k(y + (size_t)s * ys, 0, W, x + (size_t)s * xs, 0, bias, m, n, 1); + return; + } +} + +static float dot_scalar(const float *a, const float *b, int n) { + float s0 = 0.0f, s1 = 0.0f, s2 = 0.0f, s3 = 0.0f; + int j = 0; + for (; j + 4 <= n; j += 4) { + s0 += a[j + 0] * b[j + 0]; + s1 += a[j + 1] * b[j + 1]; + s2 += a[j + 2] * b[j + 2]; + s3 += a[j + 3] * b[j + 3]; + } + for (; j < n; ++j) + s0 += a[j] * b[j]; + return (s0 + s1) + (s2 + s3); +} + +static const svad_kernels kernels_scalar = {"scalar", matvec_scalar, dot_scalar}; + +const svad_kernels *svad_kernels_scalar(void) { return &kernels_scalar; } + +/* ---- AArch64 NEON ---------------------------------------------------- */ + +#if defined(__aarch64__) && defined(__ARM_NEON) +# define SVAD_HAVE_SIMD 1 +# include + +/* One output step: two accumulators per row cover the multiply-add latency + * without needing a second weight stream. */ +SVAD_INLINE void mv1_neon(float *y, const float *W, const float *x, const float *bias, int m, int n) { + int i = 0; + for (; i + 4 <= m; i += 4) { + const float *w0 = W + (size_t)i * n; + const float *w1 = w0 + n, *w2 = w1 + n, *w3 = w2 + n; + float32x4_t a0 = vdupq_n_f32(0.0f), a1 = a0, a2 = a0, a3 = a0; + float32x4_t c0 = a0, c1 = a0, c2 = a0, c3 = a0; + int j = 0; + for (; j + 8 <= n; j += 8) { + const float32x4_t x0 = vld1q_f32(x + j); + const float32x4_t x1 = vld1q_f32(x + j + 4); + a0 = vfmaq_f32(a0, vld1q_f32(w0 + j), x0); + c0 = vfmaq_f32(c0, vld1q_f32(w0 + j + 4), x1); + a1 = vfmaq_f32(a1, vld1q_f32(w1 + j), x0); + c1 = vfmaq_f32(c1, vld1q_f32(w1 + j + 4), x1); + a2 = vfmaq_f32(a2, vld1q_f32(w2 + j), x0); + c2 = vfmaq_f32(c2, vld1q_f32(w2 + j + 4), x1); + a3 = vfmaq_f32(a3, vld1q_f32(w3 + j), x0); + c3 = vfmaq_f32(c3, vld1q_f32(w3 + j + 4), x1); + } + for (; j + 4 <= n; j += 4) { + const float32x4_t x0 = vld1q_f32(x + j); + a0 = vfmaq_f32(a0, vld1q_f32(w0 + j), x0); + a1 = vfmaq_f32(a1, vld1q_f32(w1 + j), x0); + a2 = vfmaq_f32(a2, vld1q_f32(w2 + j), x0); + a3 = vfmaq_f32(a3, vld1q_f32(w3 + j), x0); + } + const float s0 = vaddvq_f32(vaddq_f32(a0, c0)); + const float s1 = vaddvq_f32(vaddq_f32(a1, c1)); + const float s2 = vaddvq_f32(vaddq_f32(a2, c2)); + const float s3 = vaddvq_f32(vaddq_f32(a3, c3)); + y[i + 0] = bias ? bias[i + 0] + s0 : s0; + y[i + 1] = bias ? bias[i + 1] + s1 : s1; + y[i + 2] = bias ? bias[i + 2] + s2 : s2; + y[i + 3] = bias ? bias[i + 3] + s3 : s3; + } + for (; i < m; ++i) { + const float *w = W + (size_t)i * n; + float32x4_t a = vdupq_n_f32(0.0f), c = a; + int j = 0; + for (; j + 8 <= n; j += 8) { + a = vfmaq_f32(a, vld1q_f32(w + j), vld1q_f32(x + j)); + c = vfmaq_f32(c, vld1q_f32(w + j + 4), vld1q_f32(x + j + 4)); + } + for (; j + 4 <= n; j += 4) + a = vfmaq_f32(a, vld1q_f32(w + j), vld1q_f32(x + j)); + const float s = vaddvq_f32(vaddq_f32(a, c)); + y[i] = bias ? bias[i] + s : s; + } +} + +/* Several output steps: a 4-row by steps-column register block, so each weight + * vector is loaded once and used `steps` times. */ +SVAD_INLINE void mv_ms_neon(float *y, + int ys, + const float *W, + const float *x, + int xs, + const float *bias, + int m, + int n, + const int steps) { + int i = 0; + for (; i + 4 <= m; i += 4) { + const float *w0 = W + (size_t)i * n; + const float *w1 = w0 + n, *w2 = w1 + n, *w3 = w2 + n; + float32x4_t acc[4][SVAD_MAX_STEPS]; + for (int r = 0; r < 4; ++r) + for (int s = 0; s < steps; ++s) + acc[r][s] = vdupq_n_f32(0.0f); + + int j = 0; + for (; j + 4 <= n; j += 4) { + const float32x4_t wv0 = vld1q_f32(w0 + j); + const float32x4_t wv1 = vld1q_f32(w1 + j); + const float32x4_t wv2 = vld1q_f32(w2 + j); + const float32x4_t wv3 = vld1q_f32(w3 + j); + for (int s = 0; s < steps; ++s) { + const float32x4_t xv = vld1q_f32(x + (size_t)s * xs + j); + acc[0][s] = vfmaq_f32(acc[0][s], wv0, xv); + acc[1][s] = vfmaq_f32(acc[1][s], wv1, xv); + acc[2][s] = vfmaq_f32(acc[2][s], wv2, xv); + acc[3][s] = vfmaq_f32(acc[3][s], wv3, xv); + } + } + for (int s = 0; s < steps; ++s) + for (int r = 0; r < 4; ++r) { + const float v = vaddvq_f32(acc[r][s]); + y[(size_t)s * ys + i + r] = bias ? bias[i + r] + v : v; + } + } + for (; i < m; ++i) { + const float *w = W + (size_t)i * n; + float32x4_t acc[SVAD_MAX_STEPS]; + for (int s = 0; s < steps; ++s) + acc[s] = vdupq_n_f32(0.0f); + int j = 0; + for (; j + 4 <= n; j += 4) { + const float32x4_t wv = vld1q_f32(w + j); + for (int s = 0; s < steps; ++s) + acc[s] = vfmaq_f32(acc[s], wv, vld1q_f32(x + (size_t)s * xs + j)); + } + for (int s = 0; s < steps; ++s) { + const float v = vaddvq_f32(acc[s]); + y[(size_t)s * ys + i] = bias ? bias[i] + v : v; + } + } +} + +static void matvec_neon(float *y, + int ys, + const float *W, + const float *x, + int xs, + const float *bias, + int m, + int n, + int steps) { + switch (steps) { + case 1: + mv1_neon(y, W, x, bias, m, n); + return; + case 2: + mv_ms_neon(y, ys, W, x, xs, bias, m, n, 2); + return; + case 4: + mv_ms_neon(y, ys, W, x, xs, bias, m, n, 4); + return; + default: + for (int s = 0; s < steps; ++s) + mv1_neon(y + (size_t)s * ys, W, x + (size_t)s * xs, bias, m, n); + return; + } +} + +static float dot_neon(const float *a, const float *b, int n) { + float32x4_t s0 = vdupq_n_f32(0.0f), s1 = s0; + int j = 0; + for (; j + 8 <= n; j += 8) { + s0 = vfmaq_f32(s0, vld1q_f32(a + j), vld1q_f32(b + j)); + s1 = vfmaq_f32(s1, vld1q_f32(a + j + 4), vld1q_f32(b + j + 4)); + } + for (; j + 4 <= n; j += 4) + s0 = vfmaq_f32(s0, vld1q_f32(a + j), vld1q_f32(b + j)); + float s = vaddvq_f32(vaddq_f32(s0, s1)); + for (; j < n; ++j) + s += a[j] * b[j]; + return s; +} + +static const svad_kernels kernels_simd = {"neon", matvec_neon, dot_neon}; +#endif /* aarch64 NEON */ + +/* ---- x86-64 AVX2 ----------------------------------------------------- + * + * These are compiled for every x86 build, whatever the baseline the rest of + * the file is built for, by carrying the instruction set on the functions + * themselves rather than on the command line. Selection then happens at + * startup against the running processor, which is what lets one binary be both + * safe on a host without AVX2 and fast on one with it; on the measured e2-medium + * that is the difference between 131 and 42 microseconds per chunk. + * + * Every function reachable from an AVX2 entry point needs the same attribute, + * including the always-inlined ones, or the compiler refuses to inline across + * the mismatch. */ + +#if (defined(__x86_64__) || defined(__i386__)) && (defined(__GNUC__) || defined(__clang__)) +# define SVAD_HAVE_SIMD 1 +# define SVAD_X86_DISPATCH 1 +# include + +# define SVAD_AVX2 __attribute__((target("avx2,fma"))) +# define SVAD_AVX2_INLINE static inline __attribute__((always_inline, target("avx2,fma"))) + +SVAD_AVX2_INLINE float hsum256(__m256 v) { + __m128 lo = _mm256_castps256_ps128(v); + __m128 hi = _mm256_extractf128_ps(v, 1); + lo = _mm_add_ps(lo, hi); + lo = _mm_add_ps(lo, _mm_movehl_ps(lo, lo)); + lo = _mm_add_ss(lo, _mm_shuffle_ps(lo, lo, 0x55)); + return _mm_cvtss_f32(lo); +} + +SVAD_AVX2_INLINE void mv_avx2_k(float *y, + int ys, + const float *W, + const float *x, + int xs, + const float *bias, + int m, + int n, + const int steps) { + int i = 0; + for (; i + 4 <= m; i += 4) { + const float *w0 = W + (size_t)i * n; + const float *w1 = w0 + n, *w2 = w1 + n, *w3 = w2 + n; + __m256 acc[4][SVAD_MAX_STEPS]; + for (int r = 0; r < 4; ++r) + for (int s = 0; s < steps; ++s) + acc[r][s] = _mm256_setzero_ps(); + + int j = 0; + for (; j + 8 <= n; j += 8) { + const __m256 wv0 = _mm256_loadu_ps(w0 + j); + const __m256 wv1 = _mm256_loadu_ps(w1 + j); + const __m256 wv2 = _mm256_loadu_ps(w2 + j); + const __m256 wv3 = _mm256_loadu_ps(w3 + j); + for (int s = 0; s < steps; ++s) { + const __m256 xv = _mm256_loadu_ps(x + (size_t)s * xs + j); + acc[0][s] = _mm256_fmadd_ps(wv0, xv, acc[0][s]); + acc[1][s] = _mm256_fmadd_ps(wv1, xv, acc[1][s]); + acc[2][s] = _mm256_fmadd_ps(wv2, xv, acc[2][s]); + acc[3][s] = _mm256_fmadd_ps(wv3, xv, acc[3][s]); + } + } + for (int s = 0; s < steps; ++s) + for (int r = 0; r < 4; ++r) { + float v = hsum256(acc[r][s]); + const float *w = W + (size_t)(i + r) * n; + for (int t = j; t < n; ++t) + v += w[t] * x[(size_t)s * xs + t]; + y[(size_t)s * ys + i + r] = bias ? bias[i + r] + v : v; + } + } + for (; i < m; ++i) { + const float *w = W + (size_t)i * n; + __m256 acc[SVAD_MAX_STEPS]; + for (int s = 0; s < steps; ++s) + acc[s] = _mm256_setzero_ps(); + int j = 0; + for (; j + 8 <= n; j += 8) { + const __m256 wv = _mm256_loadu_ps(w + j); + for (int s = 0; s < steps; ++s) + acc[s] = _mm256_fmadd_ps(wv, _mm256_loadu_ps(x + (size_t)s * xs + j), acc[s]); + } + for (int s = 0; s < steps; ++s) { + float v = hsum256(acc[s]); + for (int t = j; t < n; ++t) + v += w[t] * x[(size_t)s * xs + t]; + y[(size_t)s * ys + i] = bias ? bias[i] + v : v; + } + } +} + +SVAD_AVX2 static void matvec_avx2(float *y, + int ys, + const float *W, + const float *x, + int xs, + const float *bias, + int m, + int n, + int steps) { + switch (steps) { + case 1: + mv_avx2_k(y, ys, W, x, xs, bias, m, n, 1); + return; + case 2: + mv_avx2_k(y, ys, W, x, xs, bias, m, n, 2); + return; + case 4: + mv_avx2_k(y, ys, W, x, xs, bias, m, n, 4); + return; + default: + for (int s = 0; s < steps; ++s) + mv_avx2_k(y + (size_t)s * ys, 0, W, x + (size_t)s * xs, 0, bias, m, n, 1); + return; + } +} + +SVAD_AVX2 static float dot_avx2(const float *a, const float *b, int n) { + __m256 s = _mm256_setzero_ps(); + int j = 0; + for (; j + 8 <= n; j += 8) + s = _mm256_fmadd_ps(_mm256_loadu_ps(a + j), _mm256_loadu_ps(b + j), s); + float r = hsum256(s); + for (; j < n; ++j) + r += a[j] * b[j]; + return r; +} + +static const svad_kernels kernels_avx2 = {"avx2", matvec_avx2, dot_avx2}; + +/* AVX2 also needs the operating system to have enabled the wider register + * state, which __builtin_cpu_supports checks along with the processor's own + * feature bits. */ +static int cpu_has_avx2(void) { +# if defined(__has_builtin) +# if __has_builtin(__builtin_cpu_init) + __builtin_cpu_init(); +# endif +# elif defined(__GNUC__) + __builtin_cpu_init(); +# endif + return __builtin_cpu_supports("avx2") && __builtin_cpu_supports("fma"); +} +#endif /* x86 */ + +const svad_kernels *svad_kernels_simd(void) { +#if defined(SVAD_X86_DISPATCH) + /* Resolved once; the answer cannot change while the process runs. */ + static const svad_kernels *chosen; + if (!chosen) + chosen = cpu_has_avx2() ? &kernels_avx2 : &kernels_scalar; + return chosen; +#elif defined(SVAD_HAVE_SIMD) + return &kernels_simd; +#else + return &kernels_scalar; +#endif +} diff --git a/kernels.h b/kernels.h new file mode 100644 index 0000000..cd719a7 --- /dev/null +++ b/kernels.h @@ -0,0 +1,52 @@ +/* Dense kernels behind the forward pass. + * + * The whole model reduces to one primitive: several output time steps sharing + * one weight matrix. The convolutions reach it because the activation buffers + * hold time steps as consecutive rows with a zero guard row at each end, so + * the three taps a kernel-3 convolution needs are already contiguous and each + * output step is a plain dot product over a window that starts `x_stride` + * floats later; conv weights are packed to match (tools/export_weights.py). + * + * Taking all the steps in one call is what makes the kernel fast. A matvec + * touches each weight exactly once and cannot do better than memory, and this + * model streams roughly a megabyte of weights per 32 ms chunk, so it runs at + * the machine's read bandwidth. Calling the kernel once per time step would + * re-read conv1's weights four times and conv2's twice, which is 1.6 MB per + * chunk rather than 0.95 MB; folding the steps into one pass over the weights + * removes that traffic outright, and the extra activation loads it costs come + * from a few kilobytes that stay in L1. + * + * Both the scalar and the SIMD implementation are always compiled and selected + * through this table, so a single binary can compare them. */ + +#ifndef SVAD_KERNELS_H +#define SVAD_KERNELS_H + +#define SVAD_MAX_STEPS 4 + +typedef struct { + const char *name; + + /* For s in 0..steps-1 and i in 0..m-1: + * y[s*y_stride + i] = (bias ? bias[i] : 0) + dot(W + i*n, x + s*x_stride, n) + * n is a multiple of 4; steps is at most SVAD_MAX_STEPS. */ + void (*matvec)(float *y, + int y_stride, + const float *W, + const float *x, + int x_stride, + const float *bias, + int m, + int n, + int steps); + + float (*dot)(const float *a, const float *b, int n); +} svad_kernels; + +const svad_kernels *svad_kernels_scalar(void); + +/* The best set this build supports; equals the scalar set on architectures + * without an implementation here. */ +const svad_kernels *svad_kernels_simd(void); + +#endif /* SVAD_KERNELS_H */ diff --git a/rfft.c b/rfft.c new file mode 100644 index 0000000..0d20634 --- /dev/null +++ b/rfft.c @@ -0,0 +1,190 @@ +#include "rfft.h" + +#include +#include + +#ifndef M_PI +# define M_PI 3.14159265358979323846 +#endif + +void svad_rfft_init(svad_rfft *f, int n_fft, int simd) { + const int n = n_fft / 2; + f->n = n; + f->simd = simd; + + int bits = 0; + while ((1 << bits) < n) + ++bits; + for (int i = 0; i < n; ++i) { + unsigned r = 0; + for (int b = 0; b < bits; ++b) + r |= ((unsigned)i >> b & 1u) << (bits - 1 - b); + f->rev[i] = (uint16_t)r; + } + + /* Stage twiddles, e^(-i*pi*j/half); the stage with half-size `half` + * occupies 2*(half-1) onwards, since 1 + 2 + ... + n/2 == n - 1. */ + for (int half = 1; half < n; half <<= 1) { + float *w = f->tw + 2 * (half - 1); + for (int j = 0; j < half; ++j) { + const double a = -M_PI * (double)j / (double)half; + w[2 * j + 0] = (float)cos(a); + w[2 * j + 1] = (float)sin(a); + } + } + + /* Untangle twiddles, e^(-i*pi*k/n) for k in 0..n. */ + for (int k = 0; k <= n; ++k) { + const double a = -M_PI * (double)k / (double)n; + f->post[2 * k + 0] = (float)cos(a); + f->post[2 * k + 1] = (float)sin(a); + } + + /* Twiddles are computed in double and rounded once, so they carry no more + * error than the stored basis they replace. */ +} + +/* ---- portable C ------------------------------------------------------ */ + +static void rfft_mag_scalar(const svad_rfft *f, + const float *x, + int hop, + int frames, + const float *window, + float *out, + int out_stride, + float *z) { + const int n = f->n; + const int mask = n - 1; + + for (int t = 0; t < frames; ++t) { + const float *src = x + (size_t)t * hop; + for (int k = 0; k < n; ++k) { + const int r = f->rev[k]; + z[2 * r + 0] = src[2 * k + 0] * window[2 * k + 0]; + z[2 * r + 1] = src[2 * k + 1] * window[2 * k + 1]; + } + + for (int half = 1; half < n; half <<= 1) { + const float *w = f->tw + 2 * (half - 1); + const int len = half << 1; + for (int i = 0; i < n; i += len) { + for (int j = 0; j < half; ++j) { + const float wr = w[2 * j + 0], wi = w[2 * j + 1]; + float *a = z + 2 * (i + j); + float *b = z + 2 * (i + j + half); + const float tr = b[0] * wr - b[1] * wi; + const float ti = b[0] * wi + b[1] * wr; + b[0] = a[0] - tr; + b[1] = a[1] - ti; + a[0] = a[0] + tr; + a[1] = a[1] + ti; + } + } + } + + float *dst = out + (size_t)t * out_stride; + for (int k = 0; k <= n; ++k) { + const int ka = k & mask, kb = (n - k) & mask; + const float ar = z[2 * ka + 0], ai = z[2 * ka + 1]; + const float br = z[2 * kb + 0], bi = z[2 * kb + 1]; + /* even part (Z[k] + conj(Z[n-k]))/2, odd part (Z[k] - conj(Z[n-k]))/2i */ + const float er = 0.5f * (ar + br), ei = 0.5f * (ai - bi); + const float orr = 0.5f * (ai + bi), oi = -0.5f * (ar - br); + const float wr = f->post[2 * k + 0], wi = f->post[2 * k + 1]; + const float xr = er + (wr * orr - wi * oi); + const float xi = ei + (wr * oi + wi * orr); + dst[k] = sqrtf(xr * xr + xi * xi); + } + } +} + +/* ---- AArch64 NEON, four frames in the vector lanes -------------------- */ + +#if defined(__aarch64__) && defined(__ARM_NEON) +# define SVAD_RFFT_HAVE_SIMD 1 +# include + +/* Frames are independent transforms of identical shape, so they map onto the + * vector lanes directly: every butterfly becomes the scalar butterfly on four + * frames at once, with twiddles broadcast and no shuffles anywhere. Only the + * load and the final store cross lanes. */ +static void rfft_mag_neon4(const svad_rfft *f, + const float *x, + int hop, + const float *window, + float *out, + int out_stride, + float *scratch) { + const int n = f->n; + const int mask = n - 1; + float32x4_t *zr = (float32x4_t *)scratch; + float32x4_t *zi = zr + n; + + for (int k = 0; k < n; ++k) { + const int r = f->rev[k]; + const int e = 2 * k, o = 2 * k + 1; + const float32x4_t re = {x[e], x[hop + e], x[2 * hop + e], x[3 * hop + e]}; + const float32x4_t im = {x[o], x[hop + o], x[2 * hop + o], x[3 * hop + o]}; + zr[r] = vmulq_n_f32(re, window[e]); + zi[r] = vmulq_n_f32(im, window[o]); + } + + for (int half = 1; half < n; half <<= 1) { + const float *w = f->tw + 2 * (half - 1); + const int len = half << 1; + for (int i = 0; i < n; i += len) { + for (int j = 0; j < half; ++j) { + const float32x4_t wr = vdupq_n_f32(w[2 * j + 0]); + const float32x4_t wi = vdupq_n_f32(w[2 * j + 1]); + const int ia = i + j, ib = ia + half; + const float32x4_t br = zr[ib], bi = zi[ib]; + const float32x4_t tr = vfmsq_f32(vmulq_f32(br, wr), bi, wi); + const float32x4_t ti = vfmaq_f32(vmulq_f32(br, wi), bi, wr); + const float32x4_t ar = zr[ia], ai = zi[ia]; + zr[ib] = vsubq_f32(ar, tr); + zi[ib] = vsubq_f32(ai, ti); + zr[ia] = vaddq_f32(ar, tr); + zi[ia] = vaddq_f32(ai, ti); + } + } + } + + const float32x4_t half_v = vdupq_n_f32(0.5f); + for (int k = 0; k <= n; ++k) { + const int ka = k & mask, kb = (n - k) & mask; + const float32x4_t ar = zr[ka], ai = zi[ka]; + const float32x4_t br = zr[kb], bi = zi[kb]; + const float32x4_t er = vmulq_f32(vaddq_f32(ar, br), half_v); + const float32x4_t ei = vmulq_f32(vsubq_f32(ai, bi), half_v); + const float32x4_t orr = vmulq_f32(vaddq_f32(ai, bi), half_v); + const float32x4_t oi = vmulq_f32(vsubq_f32(br, ar), half_v); + const float32x4_t wr = vdupq_n_f32(f->post[2 * k + 0]); + const float32x4_t wi = vdupq_n_f32(f->post[2 * k + 1]); + const float32x4_t xr = vaddq_f32(er, vfmsq_f32(vmulq_f32(wr, orr), wi, oi)); + const float32x4_t xi = vaddq_f32(ei, vfmaq_f32(vmulq_f32(wr, oi), wi, orr)); + const float32x4_t mag = vsqrtq_f32(vfmaq_f32(vmulq_f32(xr, xr), xi, xi)); + vst1q_lane_f32(out + 0 * out_stride + k, mag, 0); + vst1q_lane_f32(out + 1 * out_stride + k, mag, 1); + vst1q_lane_f32(out + 2 * out_stride + k, mag, 2); + vst1q_lane_f32(out + 3 * out_stride + k, mag, 3); + } +} +#endif /* aarch64 NEON */ + +void svad_rfft_mag(const svad_rfft *f, + const float *x, + int hop, + int frames, + const float *window, + float *out, + int out_stride, + float *scratch) { +#if defined(SVAD_RFFT_HAVE_SIMD) + if (f->simd && frames == 4) { + rfft_mag_neon4(f, x, hop, window, out, out_stride, scratch); + return; + } +#endif + rfft_mag_scalar(f, x, hop, frames, window, out, out_stride, scratch); +} diff --git a/rfft.h b/rfft.h new file mode 100644 index 0000000..7cb3c50 --- /dev/null +++ b/rfft.h @@ -0,0 +1,49 @@ +/* Windowed real FFT for the short-time transform stage. + * + * The model's stored transform is a dense [2*bins][n_fft] basis whose rows are + * w[n]cos(2*pi*f*n/n_fft) and -w[n]sin(2*pi*f*n/n_fft) with w the periodic Hann + * window (tools/export_weights.py verifies this on every export). The stage + * therefore computes exactly the magnitude spectrum of the windowed frame, and + * an FFT computes the same quantity in O(n log n) instead of O(n * bins): + * 264K multiply-accumulates per 16 kHz chunk become about 24K floating point + * operations. It is the same transform, not an approximation of it, so only + * rounding differs. + * + * A real transform of length n_fft is evaluated as a complex transform of + * length n_fft/2 over the even/odd split, followed by the standard untangle + * step. Only magnitudes are returned, so the sign convention of the imaginary + * part is irrelevant. */ + +#ifndef SVAD_RFFT_H +#define SVAD_RFFT_H + +#include + +#define SVAD_RFFT_MAX_N 128 /* complex length, = max n_fft / 2 */ + +/* Scratch floats svad_rfft_mag needs; sized for the batched SIMD path. */ +#define SVAD_RFFT_SCRATCH (8 * SVAD_RFFT_MAX_N) + +typedef struct { + int n; /* complex transform length, n_fft / 2 */ + int simd; /* use the batched SIMD path when available */ + uint16_t rev[SVAD_RFFT_MAX_N]; /* bit-reversal permutation */ + float tw[2 * SVAD_RFFT_MAX_N]; /* per-stage butterfly twiddles */ + float post[2 * (SVAD_RFFT_MAX_N + 1)]; /* untangle twiddles */ +} svad_rfft; + +void svad_rfft_init(svad_rfft *f, int n_fft, int simd); + +/* Magnitude spectra of `frames` windows taken from x at the given hop, each + * multiplied by `window` first. Writes frames * (n_fft/2 + 1) magnitudes as + * out[t * out_stride + bin]. */ +void svad_rfft_mag(const svad_rfft *f, + const float *x, + int hop, + int frames, + const float *window, + float *out, + int out_stride, + float *scratch); + +#endif /* SVAD_RFFT_H */ diff --git a/scripts/export_weights.py b/scripts/export_weights.py new file mode 100644 index 0000000..570fd4f --- /dev/null +++ b/scripts/export_weights.py @@ -0,0 +1,367 @@ +#!/usr/bin/env python3 +"""Export silero-vad weights into the packed layouts the C engine consumes. + +The bundled headers match the official Silero VAD v6.2 models. The 16 kHz set comes +from the opset-15 16 kHz-only graph; the 8 kHz set is stored as Constant nodes +inside the full model's `If_0` else-branch. Both branches hold 15 float weight +tensors in topological order; the 16 kHz branch is identified by bitwise +equality of its [258,1,256] STFT basis with the opset-15 one. + +Offline transforms applied here (all free at inference time): + - convolution weights [O,C,K] -> [O][K][Cpad], so one output time step is a + single contiguous dot product over a 3-row window of a [T][Cpad] activation + buffer, with the channel axis zero-padded to a multiple of SIMD width; + - LSTM weight_ih | weight_hh concatenated on the input axis into [512,256] + and bias_ih + bias_hh merged into one [512] vector, so the cell is one + matvec over concat(feat, h); + - the final 1x1 convolution flattened to a [128] vector plus a scalar bias. + +Every packed tensor is unpacked again and compared bitwise against its source +before anything is written (verification gate 1). + +Usage: + export_weights.py + +Download both models from the official snakers4/silero-vad repository. +Use the pinned v6.2 release to reproduce this project's bundled weights: + + mkdir -p build/models + base=https://raw.githubusercontent.com/snakers4/silero-vad/v6.2/src/silero_vad/data + curl -fL "$base/silero_vad_16k_op15.onnx" -o build/models/silero_vad_16k_op15.onnx + curl -fL "$base/silero_vad.onnx" -o build/models/silero_vad.onnx + +From the project root, run with NumPy and ONNX installed: + + uv run --with numpy --with onnx python scripts/export_weights.py build/models/silero_vad_16k_op15.onnx build/models/silero_vad.onnx build/generated + +The exporter writes /src/weights_16k.h, /src/weights_8k.h, +and /svad_weights.bin. To use the generated headers in this project: + + cp build/generated/src/weights_16k.h build/generated/src/weights_8k.h . + make +""" + +import os +import struct +import sys + +import numpy as np +import onnx +from onnx import numpy_helper + +# Weight names in the opset-15 16 kHz graph, in the order the engine streams +# them. reference.py uses the same map. +ONNX_NAME_MAP = [ + ("stft_basis", "model.stft.forward_basis_buffer"), + ("conv1_w", "model.encoder.0.reparam_conv.weight"), + ("conv1_b", "model.encoder.0.reparam_conv.bias"), + ("conv2_w", "model.encoder.1.reparam_conv.weight"), + ("conv2_b", "model.encoder.1.reparam_conv.bias"), + ("conv3_w", "model.encoder.2.reparam_conv.weight"), + ("conv3_b", "model.encoder.2.reparam_conv.bias"), + ("conv4_w", "model.encoder.3.reparam_conv.weight"), + ("conv4_b", "model.encoder.3.reparam_conv.bias"), + ("lstm_w_ih", "model.decoder.rnn.weight_ih"), + ("lstm_w_hh", "model.decoder.rnn.weight_hh"), + ("lstm_b_ih", "model.decoder.rnn.bias_ih"), + ("lstm_b_hh", "model.decoder.rnn.bias_hh"), + ("head_w", "model.decoder.decoder.2.weight"), + ("head_b", "model.decoder.decoder.2.bias"), +] + +VEC = 4 # channel padding granularity, in floats +ALIGN_FLOATS = 16 # 64-byte tensor alignment inside a section +BLOB_MAGIC = b"SVAD" +BLOB_VERSION = 1 +ENTRY_SIZE = 80 # bytes per tensor-table entry +DTYPE_F32 = 1 + + +def roundup(n, m): + return (n + m - 1) // m * m + + +def fnv1a64(buf): + h = 0xCBF29CE484222325 + for b in memoryview(buf).cast("B"): + h = ((h ^ b) * 0x100000001B3) & 0xFFFFFFFFFFFFFFFF + return h + + +# --- weight sources ------------------------------------------------------- + +def load_16k(path): + inits = {i.name: numpy_helper.to_array(i) for i in onnx.load(path).graph.initializer} + missing = [full for _, full in ONNX_NAME_MAP if full not in inits] + if missing: + raise SystemExit(f"{path}: missing initializers {missing}") + return {short: np.ascontiguousarray(inits[full], dtype=np.float32) + for short, full in ONNX_NAME_MAP} + + +def load_8k(path, ref_basis): + """Pull the 8 kHz weight set out of the full model's If_0 branches.""" + graph = onnx.load(path).graph + ifs = [n for n in graph.node if n.op_type == "If"] + if len(ifs) != 1: + raise SystemExit(f"{path}: expected exactly one top-level If, got {len(ifs)}") + + branches = {} + for attr in ifs[0].attribute: + if attr.type != onnx.AttributeProto.GRAPH: + continue + tensors = [] + for node in attr.g.node: + if node.op_type != "Constant": + continue + arr = numpy_helper.to_array(node.attribute[0].t) + if arr.dtype == np.float32 and arr.ndim > 0: + tensors.append(np.ascontiguousarray(arr)) + branches[attr.name] = tensors + + eight = None + for name, tensors in branches.items(): + if len(tensors) != len(ONNX_NAME_MAP): + raise SystemExit(f"{path}: branch {name} holds {len(tensors)} float tensors, " + f"expected {len(ONNX_NAME_MAP)}") + is_16k = (tensors[0].shape == ref_basis.shape + and np.array_equal(tensors[0], ref_basis)) + print(f" branch {name}: stft basis {tensors[0].shape} " + f"{'== op15 (16 kHz)' if is_16k else '!= op15 (8 kHz)'}") + if not is_16k: + eight = tensors + if eight is None: + raise SystemExit(f"{path}: no non-16 kHz branch found") + + w = {short: t for (short, _), t in zip(ONNX_NAME_MAP, eight)} + expect = {"stft_basis": (130, 1, 128), "conv1_w": (128, 65, 3), "conv2_w": (64, 128, 3), + "conv3_w": (64, 64, 3), "conv4_w": (128, 64, 3), "lstm_w_ih": (512, 128), + "lstm_w_hh": (512, 128), "head_w": (1, 128, 1)} + for name, shape in expect.items(): + if w[name].shape != shape: + raise SystemExit(f"8 kHz {name}: shape {w[name].shape}, expected {shape} " + "(positional mapping is wrong)") + return w + + +# --- packing -------------------------------------------------------------- + +def check_stft_basis(basis): + """The basis is a windowed real DFT: rows 0..B-1 are w[n]cos(2*pi*f*n/N), + rows B..2B-1 are -w[n]sin(2*pi*f*n/N), with w the periodic Hann window of + length N. Confirming this is what licenses the rFFT STFT path, which is the + same transform rather than an approximation of it. Returns the window.""" + n_rows, _, n = basis.shape + bins = n // 2 + 1 + if n_rows != 2 * bins: + raise SystemExit(f"stft basis rows {n_rows}, expected {2 * bins}") + b = basis[:, 0, :] + window = b[0].copy() # f = 0 row is w[n] * cos(0) + t = np.arange(n) + ang = 2.0 * np.pi * np.arange(bins)[:, None] * t[None, :] / n + dcos = np.abs(window * np.cos(ang) - b[:bins]).max() + dsin = np.abs(-window * np.sin(ang) - b[bins:]).max() + hann = np.hanning(n + 1)[:n] + dwin = np.abs(hann - window).max() + print(f" stft basis: cos dev {dcos:.3e} sin dev {dsin:.3e} " + f"periodic-Hann dev {dwin:.3e}") + tol = 1e-6 + if dcos > tol or dsin > tol or dwin > tol: + raise SystemExit("stft basis is not a Hann-windowed DFT basis; " + "the rFFT path would not be equivalent") + return window + + +def pack_conv(w, cpad): + """[O,C,K] -> [O][K*cpad], with the channel axis zero-padded.""" + o, c, k = w.shape + out = np.zeros((o, k, cpad), dtype=np.float32) + out[:, :, :c] = np.transpose(w, (0, 2, 1)) + packed = np.ascontiguousarray(out.reshape(o, k * cpad)) + for kk in range(k): # round-trip check + back = packed[:, kk * cpad:kk * cpad + c] + assert np.array_equal(back, w[:, :, kk]), "conv repack mismatch" + assert not packed[:, kk * cpad + c:(kk + 1) * cpad].any(), "conv pad not zero" + return packed + + +def build_section(rate, w): + """Returns (tensor list, config dict). Tensors are (name, array, shape).""" + basis = w["stft_basis"] + window = check_stft_basis(basis) + n_fft = basis.shape[2] + bins = n_fft // 2 + 1 + bins_pad = roundup(bins, VEC) + + lstm_w = np.ascontiguousarray( + np.concatenate([w["lstm_w_ih"], w["lstm_w_hh"]], axis=1)) + assert np.array_equal(lstm_w[:, :128], w["lstm_w_ih"]) + assert np.array_equal(lstm_w[:, 128:], w["lstm_w_hh"]) + lstm_b = (w["lstm_b_ih"] + w["lstm_b_hh"]).astype(np.float32) + + tensors = [ + ("stft_basis", np.ascontiguousarray(basis.reshape(2 * bins, n_fft)), (2 * bins, n_fft)), + ("stft_window", window, (n_fft,)), + ("conv1_w", pack_conv(w["conv1_w"], bins_pad), (128, 3 * bins_pad)), + ("conv1_b", w["conv1_b"], (128,)), + ("conv2_w", pack_conv(w["conv2_w"], 128), (64, 3 * 128)), + ("conv2_b", w["conv2_b"], (64,)), + ("conv3_w", pack_conv(w["conv3_w"], 64), (64, 3 * 64)), + ("conv3_b", w["conv3_b"], (64,)), + ("conv4_w", pack_conv(w["conv4_w"], 64), (128, 3 * 64)), + ("conv4_b", w["conv4_b"], (128,)), + ("lstm_w", lstm_w, (512, 256)), + ("lstm_b", lstm_b, (512,)), + ("head_w", np.ascontiguousarray(w["head_w"][0, :, 0]), (128,)), + ("head_b", np.ascontiguousarray(w["head_b"]), (1,)), + ] + scale = rate // 8000 + cfg = dict(sample_rate=rate, chunk=256 * scale, context=32 * scale, n_fft=n_fft, + hop=n_fft // 2, pad=32 * scale, frames=4, bins=bins, bins_pad=bins_pad) + return tensors, cfg + + +def layout(tensors): + """Concatenate into one float array with every tensor 64-byte aligned.""" + parts, offsets, off = [], {}, 0 + for name, arr, shape in tensors: + flat = np.ascontiguousarray(arr, dtype=np.float32).reshape(-1) + gap = (-off) % ALIGN_FLOATS + if gap: + parts.append(np.zeros(gap, np.float32)) + off += gap + offsets[name] = (off, flat.size, shape) + parts.append(flat) + off += flat.size + gap = (-off) % ALIGN_FLOATS + if gap: + parts.append(np.zeros(gap, np.float32)) + off += gap + return np.concatenate(parts).astype(np.float32), offsets + + +# --- emitters ------------------------------------------------------------- + +def cfloat(v): + """Shortest decimal that round-trips through float32, as a C literal. + A bare integer form such as "0" would lex as an octal constant once the f + suffix is attached, so a decimal point is forced when there is no exponent.""" + s = "%.9g" % v + if "." not in s and "e" not in s: + s += ".0" + return s + "f" + + +HEADER_PREAMBLE = """\ +/* Generated by scripts/export_weights.py. Do not edit. + * + * Packed silero-vad weights for the {rate} Hz path, laid out in the order + * the engine streams them so the whole forward pass walks memory forward. + * Source: ONNX initializers ({src}). + * Layouts: convolutions [O][K][Cpad] (channel axis zero-padded to {vec}), + * LSTM weight_ih|weight_hh concatenated to [512][256] with merged biases. + * Section FNV-1a: 0x{checksum:016x} + */ + +""" + + +def emit_header(path, tag, rate, src, data, offsets, cfg): + guard = f"SVAD_WEIGHTS_{tag.upper()}_H" + var = f"svad_w_{tag}" + with open(path, "w") as f: + f.write(HEADER_PREAMBLE.format(rate=rate, src=os.path.basename(src), vec=VEC, + checksum=fnv1a64(data.tobytes()))) + f.write(f"#ifndef {guard}\n#define {guard}\n\n") + f.write(f"#define SVAD_{tag.upper()}_FLOATS {data.size}\n\n") + f.write(f"SVAD_ALIGN64 static const float {var}[SVAD_{tag.upper()}_FLOATS] = {{\n") + flat = data.reshape(-1) + if not np.isfinite(flat).all(): + raise SystemExit("non-finite weight value") + for i in range(0, flat.size, 8): + f.write(" " + " ".join(cfloat(v) + "," for v in flat[i:i + 8]) + "\n") + f.write("};\n\n") + + f.write(f"static const svad_weights {var}_manifest = {{\n") + for key in ("sample_rate", "chunk", "context", "n_fft", "hop", "pad", + "frames", "bins", "bins_pad"): + f.write(f" .{key} = {cfg[key]},\n") + for name, (off, _, _) in offsets.items(): + if name == "head_b": + f.write(f" .head_b = {var}[{off}],\n") + else: + f.write(f" .{name} = {var} + {off},\n") + f.write("};\n\n") + f.write(f"#endif /* {guard} */\n") + + +def emit_blob(path, sections): + """SVAD blob: magic, version, tensor table, then 64-byte-aligned data.""" + entries, data, cursor = [], bytearray(), 0 + for tag, (arr, offsets, _) in sections.items(): + raw = arr.tobytes() + base = cursor + data += raw + cursor += len(raw) + pad = (-cursor) % 64 + data += b"\0" * pad + cursor += pad + for name, (off, count, shape) in offsets.items(): + blob = arr[off:off + count].tobytes() + entries.append((f"{tag}.{name}", shape, base + off * 4, len(blob), + fnv1a64(blob))) + + head_size = 16 + ENTRY_SIZE * len(entries) + data_start = roundup(head_size, 64) + out = bytearray() + out += BLOB_MAGIC + out += struct.pack(" 31: + raise SystemExit(f"tensor name too long: {name}") + dims = list(shape) + [0] * (4 - len(shape)) + out += nb.ljust(32, b"\0") + out += struct.pack(" {header}") + for name, (off, count, shape) in offsets.items(): + checksum = fnv1a64(data[off:off + count].tobytes()) + print(f" {name:12s} {str(shape):12s} off {off:7d} fnv 0x{checksum:016x}") + + blob = os.path.join(out_dir, "svad_weights.bin") + size, n = emit_blob(blob, sections) + print(f"\nblob: {blob} ({size / 1024:.1f} KiB, {n} tensors)") + + +if __name__ == "__main__": + main() diff --git a/segment.c b/segment.c new file mode 100644 index 0000000..ae00771 --- /dev/null +++ b/segment.c @@ -0,0 +1,258 @@ +/* Turning speech probabilities into speech segments. + * + * Two ports of the upstream Python behaviour, both operating purely on the + * probability sequence: + * + * svad_segmenter_* mirrors VADIterator, emitting events as chunks + * arrive, with one window of look-behind; + * svad_speech_timestamps mirrors get_speech_timestamps, which sees the whole + * sequence and additionally drops short segments, + * splits over-long ones and pads the results. + * + * Both are integer arithmetic over the same thresholds, so given identical + * probabilities they reproduce the reference output exactly. temp_end == 0 + * doubles as "unset" in the reference and is kept that way here. */ + +#include "svad.h" + +#include + +void svad_segmenter_init(svad_segmenter *s, int sample_rate) { + s->threshold = 0.5f; + s->neg_threshold = 0.5f - 0.15f; + s->min_silence_samples = (int64_t)sample_rate * 100 / 1000; + s->speech_pad_samples = (int64_t)sample_rate * 30 / 1000; + s->window_samples = sample_rate == 8000 ? 256 : 512; + svad_segmenter_reset(s); +} + +void svad_segmenter_reset(svad_segmenter *s) { + s->triggered = 0; + s->current_sample = 0; + s->temp_end = 0; +} + +svad_event svad_segmenter_update(svad_segmenter *s, float prob) { + svad_event ev = {SVAD_EVENT_NONE, 0}; + + s->current_sample += s->window_samples; + + if (prob >= s->threshold && s->temp_end) + s->temp_end = 0; + + if (prob >= s->threshold && !s->triggered) { + s->triggered = 1; + int64_t start = s->current_sample - s->speech_pad_samples - s->window_samples; + ev.kind = SVAD_EVENT_SPEECH_START; + ev.sample = start > 0 ? start : 0; + return ev; + } + + if (prob < s->neg_threshold && s->triggered) { + if (!s->temp_end) + s->temp_end = s->current_sample; + if (s->current_sample - s->temp_end >= s->min_silence_samples) { + ev.kind = SVAD_EVENT_SPEECH_END; + ev.sample = s->temp_end + s->speech_pad_samples - s->window_samples; + s->temp_end = 0; + s->triggered = 0; + } + } + return ev; +} + +/* ---- offline --------------------------------------------------------- */ + +void svad_segment_params_default(svad_segment_params *p) { + p->threshold = 0.5f; + p->neg_threshold = 0.0f; /* derived */ + p->min_speech_ms = 250; + p->max_speech_s = HUGE_VAL; + p->min_silence_ms = 100; + p->speech_pad_ms = 30; + p->lead_pad_ms = 0; + p->min_silence_at_max_speech_ms = 98; + p->use_max_poss_sil_at_max_speech = 1; +} + +/* Scratch for the segment scan. `speeches` is written straight into the + * caller's array when it fits, and counted beyond that. */ +typedef struct { + svad_segment *out; + size_t cap; + size_t n; +} seglist; + +static void seg_push(seglist *l, int64_t start, int64_t end) { + if (l->out && l->n < l->cap) { + l->out[l->n].start = start; + l->out[l->n].end = end; + } + ++l->n; +} + +size_t svad_speech_timestamps(const float *probs, + size_t n_probs, + int64_t audio_length_samples, + int sample_rate, + const svad_segment_params *params, + svad_segment *out, + size_t out_cap) { + svad_segment_params def; + if (!params) { + svad_segment_params_default(&def); + params = &def; + } + + const int64_t window = sample_rate == 8000 ? 256 : 512; + const float threshold = params->threshold; + float neg = params->neg_threshold; + if (!(neg > 0.0f)) { + neg = threshold - 0.15f; + if (neg < 0.01f) + neg = 0.01f; + } + const int64_t min_speech = (int64_t)sample_rate * params->min_speech_ms / 1000; + const int64_t pad = (int64_t)sample_rate * params->speech_pad_ms / 1000; + const int64_t min_silence = (int64_t)sample_rate * params->min_silence_ms / 1000; + const int64_t lead = (int64_t)sample_rate * params->lead_pad_ms / 1000; + const int64_t min_sil_max = (int64_t)sample_rate * params->min_silence_at_max_speech_ms / 1000; + const double max_speech = + params->max_speech_s * (double)sample_rate - (double)window - 2.0 * (double)pad; + + seglist list = {out, out_cap, 0}; + int triggered = 0, have_speech = 0; + int64_t cur_start = 0; + int64_t temp_end = 0, prev_end = 0, next_start = 0; + /* The reference keeps every candidate silence and later takes the first + * longest one; a running maximum with a strict comparison is the same + * selection without the list. */ + int64_t best_end = 0, best_dur = 0; + int have_best = 0; + + for (size_t i = 0; i < n_probs; ++i) { + const float p = probs[i]; + const int64_t cur = window * (int64_t)i; + + if (p >= threshold && temp_end) { + const int64_t sil = cur - temp_end; + if (sil > min_sil_max && (!have_best || sil > best_dur)) { + best_end = temp_end; + best_dur = sil; + have_best = 1; + } + temp_end = 0; + if (next_start < prev_end) + next_start = cur; + } + + if (p >= threshold && !triggered) { + triggered = 1; + have_speech = 1; + cur_start = cur; + continue; + } + + if (triggered && (double)(cur - cur_start) > max_speech) { + if (params->use_max_poss_sil_at_max_speech && have_best) { + prev_end = best_end; + seg_push(&list, cur_start, prev_end); + have_speech = 0; + next_start = prev_end + best_dur; + if (next_start < prev_end + cur) { + cur_start = next_start; + have_speech = 1; + } else { + triggered = 0; + } + prev_end = next_start = temp_end = 0; + have_best = 0; + best_dur = 0; + } else if (prev_end) { + seg_push(&list, cur_start, prev_end); + have_speech = 0; + if (next_start < prev_end) { + triggered = 0; + } else { + cur_start = next_start; + have_speech = 1; + } + prev_end = next_start = temp_end = 0; + have_best = 0; + best_dur = 0; + } else { + seg_push(&list, cur_start, cur); + have_speech = 0; + prev_end = next_start = temp_end = 0; + triggered = 0; + have_best = 0; + best_dur = 0; + continue; + } + } + + if (p < neg && triggered) { + if (!temp_end) + temp_end = cur; + const int64_t sil_now = cur - temp_end; + if (!params->use_max_poss_sil_at_max_speech && sil_now > min_sil_max) + prev_end = temp_end; + if (sil_now < min_silence) + continue; + if (temp_end - cur_start > min_speech) + seg_push(&list, cur_start, temp_end); + have_speech = 0; + prev_end = next_start = temp_end = 0; + triggered = 0; + have_best = 0; + best_dur = 0; + } + } + + if (have_speech && audio_length_samples - cur_start > min_speech) + seg_push(&list, cur_start, audio_length_samples); + + /* Padding runs over the complete list, so it is applied only when every + * segment was written. A short buffer yields the count and nothing else. */ + if (!out || list.n > out_cap) + return list.n; + + /* Each step reads its neighbour's still-unmodified start, so one forward + * sweep reproduces the reference's in-place updates. Gaps are never + * negative, so truncating division matches the reference's floor. */ + for (size_t i = 0; i < list.n; ++i) { + if (i == 0) + out[0].start = out[0].start > pad ? out[0].start - pad : 0; + if (i + 1 < list.n) { + const int64_t gap = out[i + 1].start - out[i].end; + int64_t shift = pad; + if (gap < 2 * pad) { + shift = gap / 2; + out[i].end += shift; + } else { + const int64_t e = out[i].end + pad; + out[i].end = e < audio_length_samples ? e : audio_length_samples; + } + const int64_t s = out[i + 1].start - shift; + out[i + 1].start = s > 0 ? s : 0; + } else { + const int64_t e = out[i].end + pad; + out[i].end = e < audio_length_samples ? e : audio_length_samples; + } + } + + /* Reach further back for the opening of each segment. This runs after the + * padding pass so it cannot disturb how neighbours share a gap, and each + * start stops at the previous segment's end, so segments never overlap. */ + if (lead > 0) { + for (size_t i = 0; i < list.n; ++i) { + int64_t s = out[i].start - lead; + if (s < 0) + s = 0; + if (i > 0 && s < out[i - 1].end) + s = out[i - 1].end; + out[i].start = s; + } + } + return list.n; +} diff --git a/svad.c b/svad.c new file mode 100644 index 0000000..6b6d993 --- /dev/null +++ b/svad.c @@ -0,0 +1,300 @@ +/* silero-vad v6.2 forward pass. + * + * Per chunk: reflect-pad, four windowed transforms, four convolutions with + * ReLU, one LSTM cell, one logistic head. Every buffer below is allocated once + * in svad_create and reused, so a chunk costs no allocation, no syscall and no + * lock. The whole working set is about 16 KiB of activations plus a megabyte + * of read-only weights. + * + * Activation buffers carry a zero guard row before the first time step and + * after the last one. A kernel-3, pad-1 convolution therefore reads three + * consecutive rows starting at row (stride * output_step), which is one + * contiguous span of memory, and the whole encoder reduces to the same matvec + * the LSTM and the head use. */ + +#include "svad.h" + +#include +#include +#include +#include + +#include "kernels.h" +#include "rfft.h" +#include "weights.h" + +/* Time steps produced by each encoder stage; fixed because the transform + * always yields SVAD_FRAMES frames and the strides are 1, 2, 2, 1. */ +#define T1 SVAD_FRAMES /* 4 */ +#define T2 (SVAD_FRAMES / 2) /* 2 */ +#define T3 1 +#define T4 1 + +/* Rows including the two guard rows. */ +#define ROWS(t) ((t) + 2) + +struct svad { + const svad_weights *w; + const svad_kernels *k; + svad_rfft fft; + int use_fft; + int ftz; + char backend[32]; + + void *map; + size_t map_len; + svad_weights mapped; + + SVAD_ALIGN64 float h[SVAD_HID]; + SVAD_ALIGN64 float c[SVAD_HID]; + + SVAD_ALIGN64 float xp[SVAD_MAX_XP]; + SVAD_ALIGN64 float mag[ROWS(T1) * SVAD_MAX_BINS_PAD]; + SVAD_ALIGN64 float e1[ROWS(T1) * SVAD_C1]; + SVAD_ALIGN64 float e2[ROWS(T2) * SVAD_C2]; + SVAD_ALIGN64 float e3[ROWS(T3) * SVAD_C3]; + SVAD_ALIGN64 float lstm_in[2 * SVAD_HID]; + SVAD_ALIGN64 float gates[SVAD_GATES]; + SVAD_ALIGN64 float hr[SVAD_HID]; + SVAD_ALIGN64 float spec[SVAD_FRAMES * 2 * SVAD_MAX_BINS]; + SVAD_ALIGN64 float fft_scratch[SVAD_RFFT_SCRATCH]; +}; + +/* ---- denormal handling ------------------------------------------------ + * + * The LSTM cell state decays toward zero across long silences, and denormal + * operands are slow on several targets. Flushing them is scoped to the call so + * the library never leaves the caller's floating point mode altered. */ + +typedef struct { + unsigned long long saved; + int active; +} fp_scope; + +#if defined(__aarch64__) +# define FPCR_FZ (1ull << 24) +static inline void fp_scope_enter(fp_scope *s, int enable) { + s->active = enable; + if (!enable) + return; + unsigned long long r; + __asm__ __volatile__("mrs %0, fpcr" : "=r"(r)); + s->saved = r; + if (!(r & FPCR_FZ)) + __asm__ __volatile__("msr fpcr, %0" : : "r"(r | FPCR_FZ)); +} +static inline void fp_scope_leave(const fp_scope *s) { + if (s->active) + __asm__ __volatile__("msr fpcr, %0" : : "r"(s->saved)); +} +#elif defined(__SSE2__) || defined(__x86_64__) || defined(_M_X64) +# include +/* Bit 15 of MXCSR flushes a denormal result to zero. The neighbouring + * denormals-are-zero bit is deliberately left alone: it only affects denormal + * inputs, which cannot arise here because samples come from a 16-bit integer + * divided by 32768 and every intermediate that could decay that far is already + * covered by flushing results. It is also absent on the earliest x86-64 parts, + * where writing it would fault. */ +# define MXCSR_FTZ 0x8000u +static inline void fp_scope_enter(fp_scope *s, int enable) { + s->active = enable; + if (!enable) + return; + s->saved = _mm_getcsr(); + _mm_setcsr((unsigned)s->saved | MXCSR_FTZ); +} +static inline void fp_scope_leave(const fp_scope *s) { + if (s->active) + _mm_setcsr((unsigned)s->saved); +} +#else +static inline void fp_scope_enter(fp_scope *s, int enable) { + s->saved = 0; + s->active = enable; + (void)s->active; +} +static inline void fp_scope_leave(const fp_scope *s) { (void)s; } +#endif + +/* ---- pointwise ------------------------------------------------------- */ + +static inline float sigmoidf_(float x) { return 1.0f / (1.0f + expf(-x)); } + +static void relu_(float *p, int n) { + for (int i = 0; i < n; ++i) + if (!(p[i] > 0.0f)) + p[i] = 0.0f; +} + +/* ---- forward pass ---------------------------------------------------- */ + +static void stft(svad_t *v) { + const svad_weights *w = v->w; + const int bp = w->bins_pad; + float *rows = v->mag + bp; /* skip the leading guard row */ + + if (v->use_fft) { + svad_rfft_mag(&v->fft, v->xp, w->hop, w->frames, w->stft_window, rows, bp, v->fft_scratch); + return; + } + /* Every frame shares the basis, so one pass over it covers all of them. */ + const int stride = 2 * w->bins; + v->k->matvec(v->spec, stride, w->stft_basis, v->xp, w->hop, NULL, stride, w->n_fft, w->frames); + for (int t = 0; t < w->frames; ++t) { + const float *src = v->spec + (size_t)t * stride; + float *dst = rows + (size_t)t * bp; + for (int f = 0; f < w->bins; ++f) { + const float re = src[f], im = src[w->bins + f]; + dst[f] = sqrtf(re * re + im * im); + } + } +} + +/* Each encoder stage runs all its output time steps in a single call, so the + * weights are streamed once per chunk rather than once per time step. Output + * step s reads the window starting at input row s * stride and writes row + * s + 1, leaving the guard rows untouched. */ +static float forward(svad_t *v) { + const svad_weights *w = v->w; + const svad_kernels *k = v->k; + const int bp = w->bins_pad; + + stft(v); + + k->matvec(v->e1 + SVAD_C1, SVAD_C1, w->conv1_w, v->mag, bp, w->conv1_b, SVAD_C1, 3 * bp, T1); + relu_(v->e1 + SVAD_C1, T1 * SVAD_C1); + + k->matvec(v->e2 + SVAD_C2, SVAD_C2, w->conv2_w, v->e1, 2 * SVAD_C1, w->conv2_b, SVAD_C2, + 3 * SVAD_C1, T2); + relu_(v->e2 + SVAD_C2, T2 * SVAD_C2); + + k->matvec(v->e3 + SVAD_C3, 0, w->conv3_w, v->e2, 0, w->conv3_b, SVAD_C3, 3 * SVAD_C2, T3); + relu_(v->e3 + SVAD_C3, T3 * SVAD_C3); + + /* conv4 writes the LSTM input directly; the hidden half follows it. */ + k->matvec(v->lstm_in, 0, w->conv4_w, v->e3, 0, w->conv4_b, SVAD_C4, 3 * SVAD_C3, T4); + relu_(v->lstm_in, SVAD_C4); + memcpy(v->lstm_in + SVAD_HID, v->h, sizeof v->h); + + k->matvec(v->gates, 0, w->lstm_w, v->lstm_in, 0, w->lstm_b, SVAD_GATES, 2 * SVAD_HID, 1); + for (int i = 0; i < SVAD_HID; ++i) { + const float ig = sigmoidf_(v->gates[i]); + const float fg = sigmoidf_(v->gates[SVAD_HID + i]); + const float gg = tanhf(v->gates[2 * SVAD_HID + i]); + const float og = sigmoidf_(v->gates[3 * SVAD_HID + i]); + const float cn = fg * v->c[i] + ig * gg; + const float hn = og * tanhf(cn); + v->c[i] = cn; + v->h[i] = hn; + v->hr[i] = hn > 0.0f ? hn : 0.0f; + } + return sigmoidf_(k->dot(w->head_w, v->hr, SVAD_HID) + w->head_b); +} + +/* ---- lifecycle ------------------------------------------------------- */ + +svad_t *svad_create_ex(const char *path, int sample_rate, unsigned flags) { + const svad_weights *builtin = svad_weights_builtin(sample_rate); + if (!builtin) + return NULL; + + svad_t *v = NULL; + if (posix_memalign((void **)&v, 64, sizeof *v) != 0 || !v) + return NULL; + memset(v, 0, sizeof *v); /* zeroes the guard rows and the channel padding */ + + if (path) { + const int verify = !(flags & SVAD_NO_VERIFY); + if (svad_weights_map(path, sample_rate, verify, &v->mapped, &v->map, &v->map_len) != 0) { + free(v); + return NULL; + } + v->w = &v->mapped; + } else { + v->w = builtin; + } + + const int scalar = (flags & SVAD_SCALAR_KERNELS) != 0; + v->k = scalar ? svad_kernels_scalar() : svad_kernels_simd(); + v->use_fft = (flags & SVAD_DENSE_STFT) == 0; + v->ftz = (flags & SVAD_NO_FTZ) == 0; + svad_rfft_init(&v->fft, v->w->n_fft, !scalar); + snprintf(v->backend, sizeof v->backend, "%s+%s", v->k->name, v->use_fft ? "rfft" : "dense"); + + svad_reset(v); + return v; +} + +svad_t *svad_create(int sample_rate) { return svad_create_ex(NULL, sample_rate, 0); } + +svad_t *svad_create_from_file(const char *path, int sample_rate) { + return svad_create_ex(path, sample_rate, 0); +} + +void svad_destroy(svad_t *v) { + if (!v) + return; + svad_weights_unmap(v->map, v->map_len); + free(v); +} + +void svad_reset(svad_t *v) { + memset(v->h, 0, sizeof v->h); + memset(v->c, 0, sizeof v->c); + memset(v->xp, 0, (size_t)v->w->context * sizeof(float)); +} + +int svad_chunk_samples(const svad_t *v) { return v->w->chunk; } + +int svad_sample_rate(const svad_t *v) { return v->w->sample_rate; } + +const char *svad_backend_name(const svad_t *v) { return v->backend; } + +void svad_get_state(const svad_t *v, float *out) { + memcpy(out, v->h, sizeof v->h); + memcpy(out + SVAD_HID, v->c, sizeof v->c); +} + +void svad_set_state(svad_t *v, const float *in) { + memcpy(v->h, in, sizeof v->h); + memcpy(v->c, in + SVAD_HID, sizeof v->c); +} + +/* ---- per-chunk entry points ------------------------------------------ */ + +/* Right-side reflect pad only: xp[total + i] = xp[total - 2 - i]. A symmetric + * or left-side pad yields plausible but wrong probabilities. */ +static void reflect_pad(svad_t *v) { + const int total = v->w->context + v->w->chunk; + for (int i = 0; i < v->w->pad; ++i) + v->xp[total + i] = v->xp[total - 2 - i]; +} + +/* The next chunk's context is the tail of this chunk's model input. */ +static void carry_context(svad_t *v) { + memmove(v->xp, v->xp + v->w->chunk, (size_t)v->w->context * sizeof(float)); +} + +float svad_process_f32(svad_t *v, const float *chunk) { + fp_scope fp; + fp_scope_enter(&fp, v->ftz); + memcpy(v->xp + v->w->context, chunk, (size_t)v->w->chunk * sizeof(float)); + reflect_pad(v); + const float p = forward(v); + carry_context(v); + fp_scope_leave(&fp); + return p; +} + +float svad_process_s16(svad_t *v, const int16_t *chunk) { + fp_scope fp; + fp_scope_enter(&fp, v->ftz); + float *dst = v->xp + v->w->context; + for (int i = 0; i < v->w->chunk; ++i) + dst[i] = (float)chunk[i] * (1.0f / 32768.0f); + reflect_pad(v); + const float p = forward(v); + carry_context(v); + fp_scope_leave(&fp); + return p; +} diff --git a/svad.h b/svad.h new file mode 100644 index 0000000..7467b02 --- /dev/null +++ b/svad.h @@ -0,0 +1,158 @@ +/* svad: silero-vad v6.2 speech detection in portable C. + * + * The engine is a fixed-size state machine over a stream of audio chunks: one + * call per chunk returns the speech probability for that chunk. No allocation, + * no syscall and no lock happens inside svad_process_*; every buffer is sized + * at create time. Weights are compiled in by default, so a process needs no + * data files. + * + * A stream is a strict sequence of fixed-size chunks: 512 samples at 16 kHz, + * 256 at 8 kHz (svad_chunk_samples). Consecutive chunks must not overlap; the + * engine carries the 64 (or 32) sample context it needs internally. + * + * svad_segmenter turns that probability stream into speech start/end events as + * they happen, and svad_speech_timestamps turns a complete probability + * sequence into a segment list offline. Both mirror the upstream Python + * behaviour (VADIterator and get_speech_timestamps) exactly. + */ + +#ifndef SVAD_H +#define SVAD_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define SVAD_VERSION_MAJOR 1 +#define SVAD_VERSION_MINOR 0 + +/* ---- engine ---------------------------------------------------------- */ + +typedef struct svad svad_t; + +/* Creation flags. The defaults (0) select the fastest kernels available and + * the rFFT short-time transform; the alternatives exist so a build can be + * checked against a simpler implementation of the same arithmetic. */ +enum { + SVAD_SCALAR_KERNELS = 1u << 0, /* portable C kernels, no SIMD intrinsics */ + SVAD_DENSE_STFT = 1u << 1, /* dense basis matvec instead of the rFFT */ + SVAD_NO_FTZ = 1u << 2, /* leave denormal handling to the caller */ + SVAD_NO_VERIFY = 1u << 3, /* skip checksum verification of a weight file */ +}; + +/* sample_rate is 8000 or 16000. Returns NULL on an unsupported rate, on an + * unreadable or corrupt weight file, or on allocation failure. */ +svad_t *svad_create(int sample_rate); +svad_t *svad_create_from_file(const char *path, int sample_rate); +svad_t *svad_create_ex(const char *path, int sample_rate, unsigned flags); + +void svad_destroy(svad_t *v); + +/* Drops the LSTM state and the carried context, so the next chunk starts a new + * stream. Required whenever the audio source changes. */ +void svad_reset(svad_t *v); + +/* Samples consumed per svad_process_* call: 512 at 16 kHz, 256 at 8 kHz. */ +int svad_chunk_samples(const svad_t *v); +int svad_sample_rate(const svad_t *v); + +/* Name of the active kernel set, for logs and benchmark output. */ +const char *svad_backend_name(const svad_t *v); + +/* Speech probability in [0,1] for one chunk. chunk holds exactly + * svad_chunk_samples() samples; the f32 variant expects [-1,1], the s16 + * variant is scaled by 1/32768 to match. */ +float svad_process_f32(svad_t *v, const float *chunk); +float svad_process_s16(svad_t *v, const int16_t *chunk); + +/* Copies the LSTM state (h then c, 128 floats each). Intended for tests and + * for saving a stream's position; out holds 256 floats. */ +void svad_get_state(const svad_t *v, float *out); +void svad_set_state(svad_t *v, const float *in); + +/* ---- streaming segmenter --------------------------------------------- */ + +typedef enum { + SVAD_EVENT_NONE = 0, + SVAD_EVENT_SPEECH_START, + SVAD_EVENT_SPEECH_END, +} svad_event_kind; + +typedef struct { + svad_event_kind kind; + int64_t sample; /* position of the event in the input stream */ +} svad_event; + +/* Caller-owned, no allocation. Fields above the state block may be adjusted + * after init to retune; the state block is engine-managed. */ +typedef struct { + float threshold; + float neg_threshold; + int64_t min_silence_samples; + int64_t speech_pad_samples; + int64_t window_samples; + + int triggered; + int64_t current_sample; + int64_t temp_end; /* 0 means unset, matching the reference implementation */ +} svad_segmenter; + +void svad_segmenter_init(svad_segmenter *s, int sample_rate); +void svad_segmenter_reset(svad_segmenter *s); + +/* Feeds one chunk probability and advances the sample cursor by one window. + * Returns at most one event per chunk. */ +svad_event svad_segmenter_update(svad_segmenter *s, float prob); + +/* ---- offline segmentation -------------------------------------------- */ + +typedef struct { + int64_t start; + int64_t end; +} svad_segment; + +typedef struct { + float threshold; + float neg_threshold; /* <= 0 selects max(threshold - 0.15, 0.01) */ + int min_speech_ms; + double max_speech_s; /* HUGE_VAL for no limit */ + int min_silence_ms; + int speech_pad_ms; + /* Extra audio kept before a segment, on top of speech_pad_ms. + * + * A detector only becomes confident once speech is clearly under way, and + * where a voice emerges from music it can score the first word at nearly + * zero. Padding both ends equally is then the wrong shape: the opening is + * what gets lost, and widening the tail by as much only adds audio nobody + * needed. Zero, the default, leaves segmentation exactly as the reference + * implementation defines it. */ + int lead_pad_ms; + int min_silence_at_max_speech_ms; + int use_max_poss_sil_at_max_speech; +} svad_segment_params; + +void svad_segment_params_default(svad_segment_params *p); + +/* Converts a complete probability sequence into speech segments. probs[i] is + * the probability of the chunk starting at sample i * window. + * + * Returns the number of segments found. Segments are written only when the + * whole list fits, because the final padding pass is defined over the complete + * list; when out is NULL or out_cap is too small, nothing is written and the + * caller should size a buffer from the return value and call again. */ +size_t svad_speech_timestamps(const float *probs, + size_t n_probs, + int64_t audio_length_samples, + int sample_rate, + const svad_segment_params *params, + svad_segment *out, + size_t out_cap); + +#ifdef __cplusplus +} +#endif + +#endif /* SVAD_H */ diff --git a/weights.c b/weights.c new file mode 100644 index 0000000..308bfc0 --- /dev/null +++ b/weights.c @@ -0,0 +1,178 @@ +/* Weight sources: the compiled-in tables and the SVAD blob reader. + * + * The generated headers below hold the packed tensors as one contiguous + * read-only array per rate, laid out in the order the forward pass reads them. + * They live in .rodata, so the pages back straight onto the executable and an + * unused rate is never faulted in. */ + +#include "weights.h" + +#include +#include +#include +#include +#include +#include +#include + +#include "weights_16k.h" +#include "weights_8k.h" + +const svad_weights *svad_weights_builtin(int sample_rate) { + if (sample_rate == 16000) + return &svad_w_16k_manifest; + if (sample_rate == 8000) + return &svad_w_8k_manifest; + return NULL; +} + +/* ---- blob reader ------------------------------------------------------ + * + * Layout written by tools/export_weights.py: + * "SVAD", u32 version, u32 tensor count, u32 data start, + * tensor count * blob_entry, zero padding, then 64-byte-aligned tensor data. + * Names are ".", so one file carries both rate variants. */ + +#define BLOB_MAGIC "SVAD" +#define BLOB_VERSION 1u +#define BLOB_DTYPE_F32 1u + +typedef struct { + char name[32]; + uint32_t dtype; + uint32_t ndim; + uint32_t shape[4]; + uint64_t offset; + uint64_t nbytes; + uint64_t fnv1a; +} blob_entry; + +typedef struct { + char magic[4]; + uint32_t version; + uint32_t count; + uint32_t data_start; +} blob_head; + +static uint64_t fnv1a(const void *p, size_t n) { + const unsigned char *b = (const unsigned char *)p; + uint64_t h = 0xCBF29CE484222325ull; + for (size_t i = 0; i < n; ++i) { + h ^= b[i]; + h *= 0x100000001B3ull; + } + return h; +} + +/* Finds one tensor, validating dtype, element count, checksum and alignment. + * Returns NULL when anything does not line up. */ +static const float *blob_find(const unsigned char *base, + size_t len, + const blob_entry *tab, + uint32_t count, + const char *name, + size_t elems, + int verify) { + for (uint32_t i = 0; i < count; ++i) { + if (strncmp(tab[i].name, name, sizeof tab[i].name) != 0) + continue; + if (tab[i].dtype != BLOB_DTYPE_F32 || tab[i].nbytes != elems * sizeof(float)) + return NULL; + if (tab[i].offset > len || tab[i].nbytes > len - tab[i].offset) + return NULL; + if (tab[i].offset % 64u != 0) + return NULL; + const unsigned char *p = base + tab[i].offset; + if (verify && fnv1a(p, (size_t)tab[i].nbytes) != tab[i].fnv1a) + return NULL; + return (const float *)(const void *)p; + } + return NULL; +} + +int svad_weights_map( + const char *path, int sample_rate, int verify, svad_weights *out, void **map, size_t *map_len) { + const svad_weights *shape = svad_weights_builtin(sample_rate); + if (!path || !shape) + return -1; + + const int fd = open(path, O_RDONLY | O_CLOEXEC); + if (fd < 0) + return -1; + struct stat st; + if (fstat(fd, &st) != 0 || st.st_size < (off_t)sizeof(blob_head)) { + close(fd); + return -1; + } + const size_t len = (size_t)st.st_size; + void *base = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0); + close(fd); + if (base == MAP_FAILED) + return -1; + + const unsigned char *bytes = (const unsigned char *)base; + blob_head head; + memcpy(&head, bytes, sizeof head); + const size_t table_bytes = (size_t)head.count * sizeof(blob_entry); + if (memcmp(head.magic, BLOB_MAGIC, 4) != 0 || head.version != BLOB_VERSION || head.count == 0 || + table_bytes / sizeof(blob_entry) != head.count || table_bytes > len - sizeof head || + head.data_start > len) { + munmap(base, len); + return -1; + } + + /* The table is 8-byte aligned inside a page-aligned mapping. */ + const blob_entry *tab = (const blob_entry *)(const void *)(bytes + sizeof head); + + /* Field, name suffix, element count: mirrors the exporter's tensor list. */ + const int bins = shape->bins, bins_pad = shape->bins_pad, n_fft = shape->n_fft; + *out = *shape; /* geometry, then override every tensor pointer */ + + const struct { + const float **dst; + const char *name; + size_t elems; + } want[] = { + {&out->stft_basis, "stft_basis", (size_t)2 * bins * n_fft}, + {&out->stft_window, "stft_window", (size_t)n_fft}, + {&out->conv1_w, "conv1_w", (size_t)SVAD_C1 * 3 * bins_pad}, + {&out->conv1_b, "conv1_b", SVAD_C1}, + {&out->conv2_w, "conv2_w", (size_t)SVAD_C2 * 3 * SVAD_C1}, + {&out->conv2_b, "conv2_b", SVAD_C2}, + {&out->conv3_w, "conv3_w", (size_t)SVAD_C3 * 3 * SVAD_C2}, + {&out->conv3_b, "conv3_b", SVAD_C3}, + {&out->conv4_w, "conv4_w", (size_t)SVAD_C4 * 3 * SVAD_C3}, + {&out->conv4_b, "conv4_b", SVAD_C4}, + {&out->lstm_w, "lstm_w", (size_t)SVAD_GATES * 2 * SVAD_HID}, + {&out->lstm_b, "lstm_b", SVAD_GATES}, + {&out->head_w, "head_w", SVAD_HID}, + }; + + const char *prefix = (sample_rate == 16000) ? "16k." : "8k."; + char key[40]; + for (size_t i = 0; i < sizeof want / sizeof want[0]; ++i) { + snprintf(key, sizeof key, "%s%s", prefix, want[i].name); + const float *p = blob_find(bytes, len, tab, head.count, key, want[i].elems, verify); + if (!p) { + munmap(base, len); + return -1; + } + *want[i].dst = p; + } + snprintf(key, sizeof key, "%shead_b", prefix); + const float *hb = blob_find(bytes, len, tab, head.count, key, 1, verify); + if (!hb) { + munmap(base, len); + return -1; + } + out->head_b = *hb; + + *map = base; + *map_len = len; + return 0; +} + +void svad_weights_unmap(void *map, size_t map_len) { + if (map) + munmap(map, map_len); +} diff --git a/weights.h b/weights.h new file mode 100644 index 0000000..524fd4e --- /dev/null +++ b/weights.h @@ -0,0 +1,73 @@ +/* Weight manifest shared by the compiled-in tables and the blob loader. + * + * Every pointer refers to a tensor already in the layout the kernels want; see + * tools/export_weights.py for the offline transforms. The two rate variants + * differ only in the transform size and in conv1's input channel count, so one + * struct describes both. */ + +#ifndef SVAD_WEIGHTS_H +#define SVAD_WEIGHTS_H + +#include + +#if defined(__GNUC__) || defined(__clang__) +# define SVAD_ALIGN64 __attribute__((aligned(64))) +#else +# define SVAD_ALIGN64 _Alignas(64) +#endif + +/* Shapes that do not vary with sample rate. */ +#define SVAD_C1 128 /* conv1 output channels */ +#define SVAD_C2 64 /* conv2 output channels */ +#define SVAD_C3 64 /* conv3 output channels */ +#define SVAD_C4 128 /* conv4 output channels, and the LSTM input width */ +#define SVAD_HID 128 /* LSTM hidden width */ +#define SVAD_GATES 512 /* 4 * SVAD_HID, gate order i,f,g,o */ +#define SVAD_FRAMES 4 /* transform frames per chunk */ + +typedef struct { + int sample_rate; /* 8000 or 16000 */ + int chunk; /* new samples per call */ + int context; /* samples carried from the previous call */ + int n_fft; /* transform window */ + int hop; /* n_fft / 2 */ + int pad; /* right-side reflect pad */ + int frames; /* == SVAD_FRAMES */ + int bins; /* n_fft / 2 + 1 magnitude bins */ + int bins_pad; /* bins rounded up to the kernel's channel granularity */ + + const float *stft_basis; /* [2*bins][n_fft], dense transform path */ + const float *stft_window; /* [n_fft], periodic Hann, rFFT path */ + const float *conv1_w; /* [128][3*bins_pad] */ + const float *conv1_b; /* [128] */ + const float *conv2_w; /* [64][3*128] */ + const float *conv2_b; /* [64] */ + const float *conv3_w; /* [64][3*64] */ + const float *conv3_b; /* [64] */ + const float *conv4_w; /* [128][3*64] */ + const float *conv4_b; /* [128] */ + const float *lstm_w; /* [512][256] over concat(feat, h) */ + const float *lstm_b; /* [512], bias_ih + bias_hh merged */ + const float *head_w; /* [128] */ + float head_b; +} svad_weights; + +/* Largest values across both rate variants, for static scratch sizing. */ +#define SVAD_MAX_CHUNK 512 +#define SVAD_MAX_CONTEXT 64 +#define SVAD_MAX_PAD 64 +#define SVAD_MAX_NFFT 256 +#define SVAD_MAX_BINS 129 +#define SVAD_MAX_BINS_PAD 132 +#define SVAD_MAX_XP (SVAD_MAX_CONTEXT + SVAD_MAX_CHUNK + SVAD_MAX_PAD) + +/* Compiled-in tables. Returns NULL for an unsupported rate. */ +const svad_weights *svad_weights_builtin(int sample_rate); + +/* Maps an SVAD blob and fills out with pointers into it. On success stores the + * mapping in *map / *map_len for svad_weights_unmap. Returns 0 on success. */ +int svad_weights_map( + const char *path, int sample_rate, int verify, svad_weights *out, void **map, size_t *map_len); +void svad_weights_unmap(void *map, size_t map_len); + +#endif /* SVAD_WEIGHTS_H */ -- cgit v1.3.1