livekit-plugins-silero 0.6.dev0__tar.gz → 0.6.0.dev2__tar.gz

{livekit_plugins_silero-0.6.dev0 → livekit_plugins_silero-0.6.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: livekit-plugins-silero
-Version: 0.6.dev0
+Version: 0.6.0.dev2
 Summary: Agent Framework Plugin for Silero
 Home-page: https://github.com/livekit/agents
 License: Apache-2.0
@@ -14,18 +14,14 @@ Classifier: Topic :: Multimedia :: Sound/Audio
 Classifier: Topic :: Multimedia :: Video
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.8.0
+Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
-Requires-Dist: livekit~=0.11
-Requires-Dist: livekit-agents~=0.8.dev0
-Requires-Dist: torch<3,>=2
-Requires-Dist: torchaudio>=2
-Requires-Dist: numpy<2,>=1
-Requires-Dist: onnxruntime~=1.17.0
+Requires-Dist: livekit-agents~=0.7
+Requires-Dist: onnxruntime>=1.18
+Requires-Dist: numpy>=1.26
 
 # LiveKit Plugins Silero
 

{livekit_plugins_silero-0.6.dev0 → livekit_plugins_silero-0.6.0.dev2}/livekit/plugins/silero/__init__.py

@@ -17,7 +17,6 @@ from .version import __version__
 
 __all__ = ["VAD", "VADStream", "__version__"]
 
-import torch
 from livekit.agents import Plugin
 
 
@@ -26,9 +25,7 @@ class SileroPlugin(Plugin):
         super().__init__(__name__, __version__, __package__)
 
     def download_files(self):
-        _ = torch.hub.load(
-            repo_or_dir="snakers4/silero-vad", model="silero_vad", onnx=True
-        )
+        pass
 
 
 Plugin.register_plugin(SileroPlugin())

livekit_plugins_silero-0.6.0.dev2/livekit/plugins/silero/onnx_model.py

@@ -0,0 +1,86 @@
+import atexit
+import importlib.resources
+from contextlib import ExitStack
+
+import numpy as np
+import onnxruntime  # type: ignore
+
+_resource_files = ExitStack()
+atexit.register(_resource_files.close)
+
+
+SUPPORTED_SAMPLE_RATES = [8000, 16000]
+
+
+def new_inference_session(force_cpu: bool) -> onnxruntime.InferenceSession:
+    res = (
+        importlib.resources.files("livekit.plugins.silero.resources")
+        / "silero_vad.onnx"
+    )
+    ctx = importlib.resources.as_file(res)
+    path = _resource_files.enter_context(ctx)
+
+    opts = onnxruntime.SessionOptions()
+    opts.inter_op_num_threads = 1
+    opts.intra_op_num_threads = 1
+    opts.graph_optimization_level = onnxruntime.GraphOptimizationLevel.ORT_ENABLE_ALL
+
+    if force_cpu and "CPUExecutionProvider" in onnxruntime.get_available_providers():
+        session = onnxruntime.InferenceSession(
+            str(path), providers=["CPUExecutionProvider"], ess_options=opts
+        )
+    else:
+        session = onnxruntime.InferenceSession(str(path), sess_options=opts)
+
+    return session
+
+
+class OnnxModel:
+    def __init__(
+        self, *, onnx_session: onnxruntime.InferenceSession, sample_rate: int
+    ) -> None:
+        self._sess = onnx_session
+        self._sample_rate = sample_rate
+
+        if sample_rate not in SUPPORTED_SAMPLE_RATES:
+            raise ValueError("Silero VAD only supports 8KHz and 16KHz sample rates")
+
+        if sample_rate == 8000:
+            self._window_size_samples = 256
+            self._context_size = 32
+        elif sample_rate == 16000:
+            self._window_size_samples = 512
+            self._context_size = 64
+
+        self.reset_states()
+
+    @property
+    def window_size_samples(self) -> int:
+        return self._window_size_samples
+
+    @property
+    def context_size(self) -> int:
+        return self._context_size
+
+    def reset_states(self) -> None:
+        self._state = np.zeros((2, 1, 128), dtype=np.float32)
+        self._context = np.zeros((1, self._context_size), dtype=np.float32)
+
+    def __call__(self, x: np.ndarray) -> float:
+        if x.ndim == 1:
+            x = np.expand_dims(x, axis=0)
+
+        if x.shape[1] != self._window_size_samples:
+            raise ValueError(
+                f"Input shape must be (N, {self._window_size_samples}), got {x.shape}"
+            )
+
+        x = np.concatenate([self._context, x], axis=1)
+        ort_inputs = {
+            "input": x,
+            "state": self._state,
+            "sr": np.array(self._sample_rate, dtype=np.int64),
+        }
+        out, self._state = self._sess.run(None, ort_inputs)
+        self._context = x[..., -self._context_size :]
+        return out.item()

livekit_plugins_silero-0.6.0.dev2/livekit/plugins/silero/resources/__init__.py

@@ -0,0 +1 @@
+"""Used by importlib.resources and setuptools"""

livekit_plugins_silero-0.6.0.dev2/livekit/plugins/silero/resources/silero_vad.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b99cbfd39246b6706f98ec13c7c50c6b299181f2474fa05cbc8046acc274396
+size 2313101

livekit_plugins_silero-0.6.0.dev2/livekit/plugins/silero/vad.py

@@ -0,0 +1,286 @@
+# Copyright 2023 LiveKit, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import asyncio
+import time
+from dataclasses import dataclass
+
+import numpy as np
+from livekit import agents, rtc
+from livekit.agents import utils
+
+from . import onnx_model
+from .log import logger
+
+
+@dataclass
+class _VADOptions:
+    min_speech_duration: float
+    min_silence_duration: float
+    padding_duration: float
+    max_buffered_speech: float
+    activation_threshold: float
+    sample_rate: int
+
+
+class VAD(agents.vad.VAD):
+    def __init__(
+        self,
+        *,
+        min_speech_duration: float = 0.05,
+        min_silence_duration: float = 0.1,
+        padding_duration: float = 0.1,
+        max_buffered_speech: float = 60.0,
+        activation_threshold: float = 0.25,
+        sample_rate: int = 16000,
+        force_cpu: bool = True,
+    ) -> None:
+        """
+        Initialize the Silero VAD with the given options.
+        The options are already set to strong defaults.
+
+        Args:
+            min_speech_duration: minimum duration of speech to start a new speech chunk
+            min_silence_duration: In the end of each speech, wait min_silence_duration before ending the speech
+            padding_duration: pad the chunks with this duration on both sides
+            max_buffered_speech: maximum duration of speech to keep in the buffer (in seconds)
+            activation_threshold: threshold to consider a frame as speech
+            sample_rate: sample rate for the inference (only 8KHz and 16KHz are supported)
+            force_cpu: force to use CPU for inference
+        """
+
+        if sample_rate not in onnx_model.SUPPORTED_SAMPLE_RATES:
+            raise ValueError("Silero VAD only supports 8KHz and 16KHz sample rates")
+
+        self._onnx_session = onnx_model.new_inference_session(force_cpu)
+        self._opts = _VADOptions(
+            min_speech_duration=min_speech_duration,
+            min_silence_duration=min_silence_duration,
+            padding_duration=padding_duration,
+            max_buffered_speech=max_buffered_speech,
+            activation_threshold=activation_threshold,
+            sample_rate=sample_rate,
+        )
+
+    def stream(self) -> "VADStream":
+        return VADStream(
+            self._opts,
+            onnx_model.OnnxModel(
+                onnx_session=self._onnx_session, sample_rate=self._opts.sample_rate
+            ),
+        )
+
+
+@dataclass
+class _WindowData:
+    inference_data: np.ndarray
+    # data returned to the user are the original frames (int16)
+    original_data: np.ndarray
+
+
+class VADStream(agents.vad.VADStream):
+    def __init__(self, opts: _VADOptions, model: onnx_model.OnnxModel) -> None:
+        super().__init__()
+        self._opts, self._model = opts, model
+        self._original_sample_rate: int | None = None
+        self._window_data: _WindowData | None = None
+        self._remaining_samples = model.window_size_samples
+
+    @agents.utils.log_exceptions(logger=logger)
+    async def _main_task(self):
+        window_ch = utils.aio.Chan[_WindowData]()
+        await asyncio.gather(
+            self._run_inference(window_ch), self._forward_input(window_ch)
+        )
+
+    async def _forward_input(self, window_tx: utils.aio.ChanSender[_WindowData]):
+        """
+        Push frame to the VAD stream for processing.
+        The frames are split into chunks of the given window size and processed.
+        (Buffered if the window size is not reached yet)
+        """
+        async for frame in self._input_ch:
+            if frame.sample_rate != 8000 and frame.sample_rate % 16000 != 0:
+                logger.error("only 8KHz and 16KHz*X sample rates are supported")
+                continue
+
+            if (
+                self._original_sample_rate is not None
+                and self._original_sample_rate != frame.sample_rate
+            ):
+                raise ValueError("a frame with another sample rate was already pushed")
+
+            self._original_sample_rate = frame.sample_rate
+            step = frame.sample_rate // 16000
+
+            if self._window_data is None:
+                self._window_data = _WindowData(
+                    inference_data=np.zeros(
+                        self._model.window_size_samples, dtype=np.float32
+                    ),
+                    original_data=np.zeros(
+                        self._model.window_size_samples * step, dtype=np.int16
+                    ),
+                )
+
+            if frame.num_channels != 1:
+                raise ValueError("vad currently only supports mono audio frames")
+
+            og_frame = np.frombuffer(frame.data, dtype=np.int16)
+            if_frame = og_frame[::step].astype(np.float32) / np.iinfo(np.int16).max
+
+            remaining_data = len(if_frame)
+            while remaining_data > 0:
+                i = self._model.window_size_samples - self._remaining_samples
+                to_copy = min(remaining_data, self._remaining_samples)
+                self._remaining_samples -= to_copy
+                remaining_data -= to_copy
+
+                self._window_data.original_data[
+                    i * step : i * step + to_copy * step
+                ] = og_frame[: to_copy * step]
+                self._window_data.inference_data[i : i + to_copy] = if_frame[:to_copy]
+
+                if self._remaining_samples == 0:
+                    window_tx.send_nowait(self._window_data)
+                    self._window_data = _WindowData(
+                        inference_data=np.zeros(
+                            self._model.window_size_samples, dtype=np.float32
+                        ),
+                        original_data=np.zeros(
+                            self._model.window_size_samples * step, dtype=np.int16
+                        ),
+                    )
+                    self._remaining_samples = self._model.window_size_samples
+
+        window_tx.close()
+
+    async def _run_inference(self, window_rx: utils.aio.ChanReceiver[_WindowData]):
+        pub_speaking = False
+        pub_speech_duration = 0.0
+        pub_silence_duration = 0.0
+        pub_speech_buf = np.array([], dtype=np.int16)
+
+        may_start_at_sample = -1
+        may_end_at_sample = -1
+
+        min_speech_samples = int(
+            self._opts.min_speech_duration * self._opts.sample_rate
+        )
+        min_silence_samples = int(
+            self._opts.min_silence_duration * self._opts.sample_rate
+        )
+
+        current_sample = 0
+
+        async for window_data in window_rx:
+            inference_data = window_data.inference_data
+            start_time = time.time()
+            raw_prob = await asyncio.to_thread(lambda: self._model(inference_data))
+            inference_duration = time.time() - start_time
+
+            window_duration = self._model.window_size_samples / self._opts.sample_rate
+            if inference_duration > window_duration:
+                # slower than realtime
+                logger.warning(
+                    "vad inference took too long - slower than realtime: %f",
+                    inference_duration,
+                )
+
+            # append new data to current speech buffer
+            pub_speech_buf = np.append(pub_speech_buf, window_data.original_data)
+            max_data_s = self._opts.padding_duration
+            if not pub_speaking:
+                max_data_s += self._opts.min_speech_duration
+            else:
+                max_data_s += self._opts.max_buffered_speech
+
+            assert self._original_sample_rate is not None
+            cl = int(max_data_s) * self._original_sample_rate
+            if len(pub_speech_buf) > cl:
+                pub_speech_buf = pub_speech_buf[-cl:]
+
+            # dispatch start/end when needed
+            if raw_prob >= self._opts.activation_threshold:
+                may_end_at_sample = -1
+
+                if may_start_at_sample == -1:
+                    may_start_at_sample = current_sample + min_speech_samples
+
+                if may_start_at_sample <= current_sample and not pub_speaking:
+                    pub_speaking = True
+                    self._event_ch.send_nowait(
+                        agents.vad.VADEvent(
+                            type=agents.vad.VADEventType.START_OF_SPEECH,
+                            silence_duration=pub_silence_duration,
+                            speech_duration=0.0,
+                            samples_index=current_sample,
+                            speaking=True,
+                        )
+                    )
+
+                    pub_silence_duration = 0
+                    pub_speech_duration += self._opts.min_speech_duration
+
+            if pub_speaking:
+                pub_speech_duration += window_duration
+            else:
+                pub_silence_duration = 0
+
+            self._event_ch.send_nowait(
+                agents.vad.VADEvent(
+                    type=agents.vad.VADEventType.INFERENCE_DONE,
+                    samples_index=current_sample,
+                    silence_duration=0.0,
+                    speech_duration=pub_speech_duration,
+                    probability=raw_prob,
+                    inference_duration=inference_duration,
+                    speaking=pub_speaking,
+                )
+            )
+
+            if raw_prob < self._opts.activation_threshold:
+                may_start_at_sample = -1
+
+                if may_end_at_sample == -1:
+                    may_end_at_sample = current_sample + min_silence_samples
+
+                if may_end_at_sample <= current_sample and pub_speaking:
+                    pub_speaking = False
+
+                    frame = rtc.AudioFrame(
+                        sample_rate=self._original_sample_rate,
+                        num_channels=1,
+                        samples_per_channel=len(pub_speech_buf),
+                        data=pub_speech_buf.tobytes(),
+                    )
+
+                    self._event_ch.send_nowait(
+                        agents.vad.VADEvent(
+                            type=agents.vad.VADEventType.END_OF_SPEECH,
+                            samples_index=current_sample,
+                            silence_duration=0.0,
+                            speech_duration=pub_speech_duration,
+                            frames=[frame],
+                            speaking=False,
+                        )
+                    )
+
+                    pub_speech_buf = np.array([], dtype=np.int16)
+                    pub_speech_duration = 0
+                    pub_silence_duration += self._opts.min_silence_duration
+
+            current_sample += self._model.window_size_samples

{livekit_plugins_silero-0.6.dev0 → livekit_plugins_silero-0.6.0.dev2}/livekit/plugins/silero/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "0.6.dev0"
+__version__ = "0.6.0-dev.2"

{livekit_plugins_silero-0.6.dev0 → livekit_plugins_silero-0.6.0.dev2}/livekit_plugins_silero.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: livekit-plugins-silero
-Version: 0.6.dev0
+Version: 0.6.0.dev2
 Summary: Agent Framework Plugin for Silero
 Home-page: https://github.com/livekit/agents
 License: Apache-2.0
@@ -14,18 +14,14 @@ Classifier: Topic :: Multimedia :: Sound/Audio
 Classifier: Topic :: Multimedia :: Video
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.8.0
+Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
-Requires-Dist: livekit~=0.11
-Requires-Dist: livekit-agents~=0.8.dev0
-Requires-Dist: torch<3,>=2
-Requires-Dist: torchaudio>=2
-Requires-Dist: numpy<2,>=1
-Requires-Dist: onnxruntime~=1.17.0
+Requires-Dist: livekit-agents~=0.7
+Requires-Dist: onnxruntime>=1.18
+Requires-Dist: numpy>=1.26
 
 # LiveKit Plugins Silero
 

{livekit_plugins_silero-0.6.dev0 → livekit_plugins_silero-0.6.0.dev2}/livekit_plugins_silero.egg-info/SOURCES.txt

@@ -3,9 +3,12 @@ pyproject.toml
 setup.py
 livekit/plugins/silero/__init__.py
 livekit/plugins/silero/log.py
+livekit/plugins/silero/onnx_model.py
 livekit/plugins/silero/py.typed
 livekit/plugins/silero/vad.py
 livekit/plugins/silero/version.py
+livekit/plugins/silero/resources/__init__.py
+livekit/plugins/silero/resources/silero_vad.onnx
 livekit_plugins_silero.egg-info/PKG-INFO
 livekit_plugins_silero.egg-info/SOURCES.txt
 livekit_plugins_silero.egg-info/dependency_links.txt

livekit_plugins_silero-0.6.0.dev2/livekit_plugins_silero.egg-info/requires.txt

@@ -0,0 +1,3 @@
+livekit-agents~=0.7
+onnxruntime>=1.18
+numpy>=1.26

{livekit_plugins_silero-0.6.dev0 → livekit_plugins_silero-0.6.0.dev2}/setup.py

@@ -39,7 +39,6 @@ setuptools.setup(
         "Topic :: Multimedia :: Video",
         "Topic :: Scientific/Engineering :: Artificial Intelligence",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3 :: Only",
@@ -47,16 +46,12 @@ setuptools.setup(
     keywords=["webrtc", "realtime", "audio", "video", "livekit"],
     license="Apache-2.0",
     packages=setuptools.find_namespace_packages(include=["livekit.*"]),
-    python_requires=">=3.8.0",
-    install_requires=[
-        "livekit ~= 0.11",
-        "livekit-agents~=0.8.dev0",
-        "torch >= 2, < 3",
-        "torchaudio >= 2",
-        "numpy >= 1, < 2",
-        "onnxruntime~=1.17.0",
-    ],
-    package_data={"livekit.plugins.silero": ["files/silero_vad.jit"]},
+    python_requires=">=3.9.0",
+    install_requires=["livekit-agents~=0.7", "onnxruntime>=1.18", "numpy>=1.26"],
+    package_data={
+        "livekit.plugins.silero.resources": ["silero_vad.onnx"],
+        "livekit.plugins.silero": ["py.typed"],
+    },
     project_urls={
         "Documentation": "https://docs.livekit.io",
         "Website": "https://livekit.io/",

livekit_plugins_silero-0.6.dev0/livekit/plugins/silero/vad.py

@@ -1,291 +0,0 @@
-# Copyright 2023 LiveKit, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import time
-from collections import deque
-from typing import List, Optional
-
-import numpy as np
-import torch
-from livekit import agents, rtc
-
-from .log import logger
-
-
-class VAD(agents.vad.VAD):
-    def __init__(self, *, model_path: str | None = None, use_onnx: bool = True) -> None:
-        if model_path:
-            model = torch.jit.load(model_path)
-            model.eval()
-        else:
-            model, _ = torch.hub.load(
-                repo_or_dir="snakers4/silero-vad",
-                model="silero_vad",
-                onnx=use_onnx,
-            )
-        self._model = model
-
-    def stream(
-        self,
-        *,
-        min_speaking_duration: float = 0.2,
-        min_silence_duration: float = 0.8,
-        padding_duration: float = 0.1,
-        sample_rate: int = 16000,
-        max_buffered_speech: float = 45.0,
-        threshold: float = 0.2,
-    ) -> "VADStream":
-        return VADStream(
-            self._model,
-            min_speaking_duration=min_speaking_duration,
-            min_silence_duration=min_silence_duration,
-            padding_duration=padding_duration,
-            sample_rate=sample_rate,
-            max_buffered_speech=max_buffered_speech,
-            threshold=threshold,
-        )
-
-
-# Based on https://github.com/snakers4/silero-vad/blob/94504ece54c8caeebb808410b08ae55ee82dba82/utils_vad.py#L428
-class VADStream(agents.vad.VADStream):
-    def __init__(
-        self,
-        model,
-        *,
-        min_speaking_duration: float,
-        min_silence_duration: float,
-        padding_duration: float,
-        sample_rate: int,
-        max_buffered_speech: float,
-        threshold: float,
-    ) -> None:
-        self._min_speaking_duration = min_speaking_duration
-        self._min_silence_duration = min_silence_duration
-        self._padding_duration = padding_duration
-        self._sample_rate = sample_rate
-        self._max_buffered_speech = max_buffered_speech
-        self._threshold = threshold
-
-        if sample_rate not in [8000, 16000]:
-            raise ValueError("Silero VAD only supports 8KHz and 16KHz sample rates")
-
-        self._queue = asyncio.Queue[Optional[rtc.AudioFrame]]()
-        self._event_queue = asyncio.Queue[Optional[agents.vad.VADEvent]]()
-        self._model = model
-
-        self._closed = False
-        self._speaking = False
-        self._waiting_start = False
-        self._waiting_end = False
-        self._current_sample = 0
-        self._filter = agents.utils.ExpFilter(0.8)
-        self._min_speaking_samples = min_speaking_duration * sample_rate
-        self._min_silence_samples = min_silence_duration * sample_rate
-        self._padding_duration_samples = padding_duration * sample_rate
-        self._max_buffered_samples = max_buffered_speech * sample_rate
-
-        self._queued_frames: deque[rtc.AudioFrame] = deque()
-        self._original_frames: deque[rtc.AudioFrame] = deque()
-        self._buffered_frames: List[rtc.AudioFrame] = []
-        self._main_task = asyncio.create_task(self._run())
-
-    def push_frame(self, frame: rtc.AudioFrame) -> None:
-        if self._closed:
-            raise ValueError("cannot push frame to closed stream")
-
-        self._queue.put_nowait(frame)
-
-    async def aclose(self, *, wait: bool = True) -> None:
-        self._closed = True
-        if not wait:
-            self._main_task.cancel()
-
-        self._queue.put_nowait(None)
-        with contextlib.suppress(asyncio.CancelledError):
-            await self._main_task
-
-    async def _run(self):
-        try:
-            while True:
-                frame = await self._queue.get()
-                if frame is None:
-                    break  # None is sent inside aclose
-
-                self._queue.task_done()
-
-                # resample to silero's sample rate
-                resampled_frame = frame.remix_and_resample(
-                    self._sample_rate, 1
-                )  # TODO: This is technically wrong, fix when we have a better resampler
-                self._original_frames.append(frame)
-                self._queued_frames.append(resampled_frame)
-
-                # run inference by chunks of 40ms until we run out of data
-                while True:
-                    available_length = sum(
-                        f.samples_per_channel for f in self._queued_frames
-                    )
-
-                    samples_40ms = self._sample_rate // 1000 * 40
-                    if available_length < samples_40ms:
-                        break
-
-                    await asyncio.shield(self._run_inference())
-
-        except Exception:
-            logger.exception("silero stream failed")
-        finally:
-            self._event_queue.put_nowait(None)
-
-    async def _run_inference(self) -> None:
-        # merge the first 4 frames (we know each is 10ms)
-        if len(self._queued_frames) < 4:
-            return
-
-        original_frames = [self._original_frames.popleft() for _ in range(4)]
-        merged_frame = agents.utils.merge_frames(
-            [self._queued_frames.popleft() for _ in range(4)]
-        )
-
-        # convert data_40ms to tensor & f32
-        tensor = torch.from_numpy(np.frombuffer(merged_frame.data, dtype=np.int16))
-        tensor = tensor.to(torch.float32) / 32768.0
-
-        # run inference
-        start_time = time.time()
-        raw_prob = await asyncio.to_thread(
-            lambda: self._model(tensor, self._sample_rate).item()
-        )
-        probability = self._filter.apply(1.0, raw_prob)
-        inference_duration = time.time() - start_time
-
-        # inference done
-        event = agents.vad.VADEvent(
-            type=agents.vad.VADEventType.INFERENCE_DONE,
-            samples_index=self._current_sample,
-            probability=probability,
-            raw_inference_prob=raw_prob,
-            inference_duration=inference_duration,
-        )
-        self._event_queue.put_nowait(event)
-
-        self._dispatch_event(original_frames, probability, raw_prob, inference_duration)
-        self._current_sample += merged_frame.samples_per_channel
-
-    def _dispatch_event(
-        self,
-        original_frames: List[rtc.AudioFrame],
-        probability: float,
-        raw_inference_prob: float,
-        inference_duration: float,
-    ):
-        """
-        Dispatches a VAD event based on the speech probability and the options
-        Args:
-            speech_prob: speech probability of the current frame
-            original_frames: original frames of the current inference
-        """
-
-        samples_10ms = self._sample_rate / 100
-        padding_count = int(
-            self._padding_duration_samples // samples_10ms
-        )  # number of frames to keep for the padding (one side)
-
-        self._buffered_frames.extend(original_frames)
-        if (
-            not self._speaking
-            and not self._waiting_start
-            and len(self._buffered_frames) > padding_count
-        ):
-            self._buffered_frames = self._buffered_frames[
-                len(self._buffered_frames) - padding_count :
-            ]
-
-        max_buffer_len = padding_count + max(
-            int(self._max_buffered_samples // samples_10ms),
-            int(self._min_speaking_samples // samples_10ms),
-        )
-        if len(self._buffered_frames) > max_buffer_len:
-            self._buffered_frames = self._buffered_frames[
-                len(self._buffered_frames) - max_buffer_len :
-            ]
-
-        if probability >= self._threshold:
-            # speaking, wait for min_speaking_duration to trigger START_OF_SPEECH
-            self._waiting_end = False
-            if not self._waiting_start and not self._speaking:
-                self._waiting_start = True
-                self._start_speech = self._current_sample
-
-            if self._waiting_start and (
-                self._current_sample - self._start_speech >= self._min_speaking_samples
-            ):
-                self._waiting_start = False
-                self._speaking = True
-
-                # since we're waiting for the min_spaking_duration to trigger START_OF_SPEECH,
-                # put the speech that were used to trigger the start here
-                event = agents.vad.VADEvent(
-                    type=agents.vad.VADEventType.START_OF_SPEECH,
-                    samples_index=self._start_speech,
-                    frames=self._buffered_frames[padding_count:],
-                    speaking=True,
-                )
-                self._event_queue.put_nowait(event)
-
-        # we don't check the speech_prob here
-        event = agents.vad.VADEvent(
-            type=agents.vad.VADEventType.INFERENCE_DONE,
-            samples_index=self._current_sample,
-            frames=original_frames,
-            probability=probability,
-            raw_inference_prob=raw_inference_prob,
-            inference_duration=inference_duration,
-            speaking=self._speaking,
-        )
-        self._event_queue.put_nowait(event)
-
-        if probability < self._threshold:
-            # stopped speaking, s for min_silence_duration to trigger END_OF_SPEECH,
-            self._waiting_start = False
-            if not self._waiting_end and self._speaking:
-                self._waiting_end = True
-                self._end_speech = self._current_sample
-
-            if self._waiting_end and (
-                self._current_sample - self._end_speech
-                >= max(self._min_silence_samples, self._padding_duration_samples)
-            ):
-                self._waiting_end = False
-                self._speaking = False
-                event = agents.vad.VADEvent(
-                    type=agents.vad.VADEventType.END_OF_SPEECH,
-                    samples_index=self._end_speech,
-                    duration=(self._end_speech - self._start_speech)
-                    / self._sample_rate,
-                    frames=self._buffered_frames,
-                    speaking=False,
-                )
-                self._event_queue.put_nowait(event)
-
-    async def __anext__(self) -> agents.vad.VADEvent:
-        evt = await self._event_queue.get()
-        if evt is None:
-            raise StopAsyncIteration
-
-        return evt

livekit_plugins_silero-0.6.dev0/livekit_plugins_silero.egg-info/requires.txt

@@ -1,6 +0,0 @@
-livekit~=0.11
-livekit-agents~=0.8.dev0
-torch<3,>=2
-torchaudio>=2
-numpy<2,>=1
-onnxruntime~=1.17.0