diff options
Diffstat (limited to 'svad.h')
| -rw-r--r-- | svad.h | 158 |
1 files changed, 158 insertions, 0 deletions
@@ -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 <stddef.h> +#include <stdint.h> + +#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 */ |
