1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
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 */
|