Skip to content

Speech to text utils

stt.utils

Functions:

Name Description
make_stream
record_interruption_parallel
record_interruption
record_user
record_user_stream

Attributes:

Name Type Description
CHUNK
FORMAT
CHANNELS
RATE

CHUNK module-attribute 

CHUNK = int(1024 * 2)

FORMAT module-attribute 

FORMAT = paInt16

CHANNELS module-attribute 

CHANNELS = 1

RATE module-attribute 

RATE = 16000

make_stream 

make_stream()
Source code in openvoicechat/stt/utils.py 
12
13
14
15
16
def make_stream():
    p = pyaudio.PyAudio()
    return p.open(
        format=FORMAT, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=CHUNK
    )

record_interruption_parallel 

record_interruption_parallel(vad, listen_queue)
Source code in openvoicechat/stt/utils.py 
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
def record_interruption_parallel(vad, listen_queue):
    # listen for interruption untill the queue is not empty
    frames = []
    stream = make_stream()
    while True:
        a = listen_queue.get()
        if a is None:
            break
        data = stream.read(CHUNK)
        frames.append(data)
        contains_speech = vad.contains_speech(frames[int(RATE / CHUNK) * -2 :])
        if contains_speech:
            stream.close()
            frames = np.frombuffer(b"".join(frames), dtype=np.int16)
            frames = frames / (1 << 15)
            return frames.astype(np.float32)
    stream.close()
    return None

record_interruption 

record_interruption(vad, record_seconds=100, streamer=None, logger=None)
Source code in openvoicechat/stt/utils.py 
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
def record_interruption(vad, record_seconds=100, streamer=None, logger=None):
    if logger:
        logger.info(
            "recording for interruption",
            extra={
                "details": "record_interruption",
                "further": f"{record_seconds} seconds",
            },
        )
    frames = []
    if streamer is None:
        stream = make_stream()
        global CHUNK
        global RATE
    else:
        stream = streamer.make_stream()
        CHUNK = streamer.CHUNK
        RATE = streamer.RATE

    for _ in range(0, int(RATE / CHUNK * record_seconds)):
        data = stream.read(CHUNK)
        assert len(data) == CHUNK * 2, "chunk size does not match 2 bytes per sample"
        frames.append(data)
        contains_speech = vad.contains_speech(frames[int(RATE / CHUNK) * -2 :])
        if contains_speech:
            stream.close()
            frames = np.frombuffer(b"".join(frames), dtype=np.int16)
            frames = frames / (1 << 15)
            return frames.astype(np.float32)
    stream.close()
    return None

record_user 

record_user(silence_seconds, vad, streamer=None, started=False, logger=None)
Source code in openvoicechat/stt/utils.py 
 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
def record_user(silence_seconds, vad, streamer=None, started=False, logger=None):
    frames = []

    if streamer is None:
        stream = make_stream()
        global CHUNK
        global RATE
    else:
        stream = streamer.make_stream()
        CHUNK = streamer.CHUNK
        RATE = streamer.RATE
    one_second_iters = int(RATE / CHUNK)
    if logger:
        logger.info(
            "user recording started",
            extra={"details": "record_user", "further": f"{silence_seconds} seconds"},
        )

    while True:
        data = stream.read(CHUNK)
        assert len(data) == CHUNK * 2, "chunk size does not match 2 bytes per sample"
        frames.append(data)
        if len(frames) < one_second_iters * silence_seconds:
            continue
        contains_speech = vad.contains_speech(
            frames[int(-one_second_iters * silence_seconds) :]
        )
        if not started and contains_speech:
            started = True
            if logger:
                logger.info(
                    "speech detected",
                    extra={"details": "record_user", "further": ""},
                )
        if started and contains_speech is False:
            break
    stream.close()
    if logger:
        logger.info(
            "user recording ended",
            extra={"details": "record_user", "further": ""},
        )

    # creating a np array from buffer
    frames = np.frombuffer(b"".join(frames), dtype=np.int16)

    # normalization see https://discuss.pytorch.org/t/torchaudio-load-normalization-question/71470
    frames = frames / (1 << 15)

    return frames.astype(np.float32)

record_user_stream 

record_user_stream(silence_seconds, vad, audio_queue, streamer=None)
Source code in openvoicechat/stt/utils.py 
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
def record_user_stream(silence_seconds, vad, audio_queue, streamer=None):
    frames = []

    started = False
    if streamer is None:
        stream = make_stream()
        global CHUNK
        global RATE
    else:
        stream = streamer.make_stream()
        CHUNK = streamer.CHUNK
        RATE = streamer.RATE

    one_second_iters = int(RATE / CHUNK)
    print("* recording")

    while True:
        data = stream.read(CHUNK)
        assert len(data) == CHUNK * 2, "chunk size does not match 2 bytes per sample"
        frames.append(data)
        audio_queue.put(data)
        contains_speech = vad.contains_speech(
            frames[int(-one_second_iters * silence_seconds) :]
        )
        if not started and contains_speech:
            started = True
            print("*listening to speech*")
        if started and contains_speech is False:
            break
    audio_queue.put(None)
    stream.close()
    print("* done recording")

stt.vad.VoiceActivityDetection 

VoiceActivityDetection(sampling_rate=16000)

Methods:

Name Description
contains_speech

Attributes:

Name Type Description
sampling_rate
Source code in openvoicechat/stt/vad.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
def __init__(self, sampling_rate=16000):
    self.model, utils = torch.hub.load(
        repo_or_dir="snakers4/silero-vad", model="silero_vad", force_reload=False
    )

    (
        self.get_speech_timestamps,
        self.save_audio,
        self.read_audio,
        self.VADIterator,
        self.collect_chunks,
    ) = utils

    self.sampling_rate = sampling_rate

sampling_rate instance-attribute 

sampling_rate = sampling_rate

contains_speech 

contains_speech(audio)
Source code in openvoicechat/stt/vad.py 
22
23
24
25
26
27
28
29
30
31
32
def contains_speech(self, audio):
    frames = np.frombuffer(b"".join(audio), dtype=np.int16)

    # normalization see https://discuss.pytorch.org/t/torchaudio-load-normalization-question/71470
    frames = frames / (1 << 15)

    audio = torch.tensor(frames.astype(np.float32))
    speech_timestamps = self.get_speech_timestamps(
        audio, self.model, sampling_rate=self.sampling_rate
    )
    return len(speech_timestamps) > 0