/* 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 */