aboutsummaryrefslogtreecommitdiff
path: root/svad.h
diff options
context:
space:
mode:
Diffstat (limited to 'svad.h')
-rw-r--r--svad.h158
1 files changed, 158 insertions, 0 deletions
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 <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 */