@glassly/bluetooth-sdk 0.1.0-dev.26

package/android/lc3Lib/third_party/opus_tools/src/src/wave_out.c

@@ -0,0 +1,223 @@
+/* Copyright (c) 2002, John Edwards
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   - Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+   - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+   - Neither the name of the Xiph.org Foundation nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+/* Set TABS = 4 */
+/********************************************************************
+
+ function: To provide playback of 16 bit PCM wave data in Win32
+           environments from decoded compressed files.
+
+ ********************************************************************/
+
+#if defined WIN32 || defined _WIN32
+
+#include <string.h>
+#include <errno.h>
+#include "wave_out.h"
+
+#define MAXWAVESIZE     4294967040LU
+#define MAX_WAVEBLOCKS    32
+
+// This is modified for USE_WIN_AUDIO - ONLY 2002-02-27
+
+
+static CRITICAL_SECTION  cs;
+static HWAVEOUT          dev                    = NULL;
+static unsigned          ScheduledBlocks        = 0;
+static int               PlayedWaveHeadersCount = 0;          // free index
+static WAVEHDR*          PlayedWaveHeaders [MAX_WAVEBLOCKS];
+
+static int
+Box ( const char* msg )
+{
+	MessageBox ( NULL, msg, " "PACKAGE" "VERSION": Error Message . . .", MB_OK | MB_ICONEXCLAMATION );
+	return -1;
+}
+
+
+/*
+ *  This function registers already played WAVE chunks. Freeing is done by free_memory(),
+ */
+
+static void CALLBACK
+wave_callback ( HWAVE hWave, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2 )
+{
+        (void) hWave;
+        (void) dwInstance;
+        (void) dwParam2;
+	if ( uMsg == WOM_DONE ) {
+		EnterCriticalSection ( &cs );
+		PlayedWaveHeaders [PlayedWaveHeadersCount++] = (WAVEHDR*) dwParam1;
+		LeaveCriticalSection ( &cs );
+	}
+}
+
+
+static void
+free_memory ( void )
+{
+	WAVEHDR*  wh;
+	HGLOBAL   hg;
+
+	EnterCriticalSection ( &cs );
+	wh = PlayedWaveHeaders [--PlayedWaveHeadersCount];
+	ScheduledBlocks--;                               // decrease the number of USED blocks
+	LeaveCriticalSection ( &cs );
+
+	waveOutUnprepareHeader ( dev, wh, sizeof (WAVEHDR) );
+
+	hg = GlobalHandle ( wh -> lpData );       // Deallocate the buffer memory
+	GlobalUnlock (hg);
+	GlobalFree   (hg);
+
+	hg = GlobalHandle ( wh );                 // Deallocate the header memory
+	GlobalUnlock (hg);
+	GlobalFree   (hg);
+}
+
+
+Int
+Set_WIN_Params ( FILE_T   dummyFile ,
+                 Ldouble  SampleFreq,
+                 Uint     BitsPerSample,
+                 Uint     Channels )
+{
+	WAVEFORMATEX  outFormat;
+	UINT          deviceID = WAVE_MAPPER;
+
+	(void) dummyFile;
+
+	if ( waveOutGetNumDevs () == 0 )
+		return Box ( "No audio device present." );
+
+	outFormat.wFormatTag      = WAVE_FORMAT_PCM;
+	outFormat.wBitsPerSample  = BitsPerSample;
+	outFormat.nChannels       = Channels;
+	outFormat.nSamplesPerSec  = (unsigned long)(SampleFreq + 0.5);
+	outFormat.nBlockAlign     = (outFormat.wBitsPerSample + 7) / 8 * outFormat.nChannels;
+	outFormat.nAvgBytesPerSec = outFormat.nSamplesPerSec * outFormat.nBlockAlign;
+
+	switch ( waveOutOpen ( &dev, deviceID, &outFormat, (DWORD)wave_callback, 0, CALLBACK_FUNCTION ) )
+	{
+		case MMSYSERR_ALLOCATED:   return Box ( "Device is already open." );
+		case MMSYSERR_BADDEVICEID: return Box ( "The specified device is out of range." );
+		case MMSYSERR_NODRIVER:    return Box ( "There is no audio driver in this system." );
+		case MMSYSERR_NOMEM:       return Box ( "Unable to allocate sound memory." );
+		case WAVERR_BADFORMAT:     return Box ( "This audio format is not supported." );
+		case WAVERR_SYNC:          return Box ( "The device is synchronous." );
+		default:                   return Box ( "Unknown media error." );
+		case MMSYSERR_NOERROR:     break;
+	}
+
+	waveOutReset ( dev );
+	InitializeCriticalSection ( &cs );
+	SetPriorityClass ( GetCurrentProcess (), HIGH_PRIORITY_CLASS );
+	return 0;
+}
+
+
+int
+WIN_Play_Samples ( const void* data, size_t len )
+{
+	HGLOBAL    hg;
+	HGLOBAL    hg2;
+	LPWAVEHDR  wh;
+	void*      allocptr;
+
+	do {
+		while ( PlayedWaveHeadersCount > 0 )                // free used blocks ...
+			free_memory ();
+
+		if ( ScheduledBlocks < sizeof(PlayedWaveHeaders)/sizeof(*PlayedWaveHeaders) ) // wait for a free block ...
+			break;
+		Sleep (26);
+	} while (1);
+
+	if ( (hg2 = GlobalAlloc ( GMEM_MOVEABLE, len )) == NULL )   // allocate some memory for a copy of the buffer
+		return Box ( "GlobalAlloc failed." );
+
+	allocptr = GlobalLock (hg2);
+	CopyMemory ( allocptr, data, len );                         // Here we can call any modification output functions we want....
+
+	if ( (hg = GlobalAlloc (GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof (WAVEHDR))) == NULL ) // now make a header and WRITE IT!
+		return -1;
+
+	wh                   = GlobalLock (hg);
+	wh -> dwBufferLength = len;
+	wh -> lpData         = allocptr;
+
+	if ( waveOutPrepareHeader ( dev, wh, sizeof (WAVEHDR)) != MMSYSERR_NOERROR ) {
+		GlobalUnlock (hg);
+		GlobalFree   (hg);
+		return -1;
+	}
+
+	if ( waveOutWrite ( dev, wh, sizeof (WAVEHDR)) != MMSYSERR_NOERROR ) {
+		GlobalUnlock (hg);
+		GlobalFree   (hg);
+		return -1;
+	}
+
+	EnterCriticalSection ( &cs );
+	ScheduledBlocks++;
+	LeaveCriticalSection ( &cs );
+
+	return len;
+}
+
+
+int
+WIN_Audio_close ( void )
+{
+	if ( dev != NULL ) {
+
+		while ( ScheduledBlocks > 0 ) {
+			Sleep (ScheduledBlocks);
+			while ( PlayedWaveHeadersCount > 0 )         // free used blocks ...
+				free_memory ();
+		}
+
+		waveOutReset (dev);      // reset the device
+		waveOutClose (dev);      // close the device
+		dev = NULL;
+	}
+
+	DeleteCriticalSection ( &cs );
+	ScheduledBlocks = 0;
+	return 0;
+}
+
+#endif
+
+/* end of wave_out.c */

package/android/lc3Lib/third_party/opus_tools/src/src/wave_out.h

@@ -0,0 +1,60 @@
+/* Copyright (c) 2002, John Edwards
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   - Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+   - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+   - Neither the name of the Xiph.org Foundation nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+//    WAVE_OUT.H - Necessary stuff for WIN_AUDIO
+
+#ifndef WAVE_OUT_H
+#define WAVE_OUT_H
+
+#include <stdio.h>
+#include <windows.h>
+#ifdef __MINGW32__
+#include <mmsystem.h>
+#endif
+
+//// constants /////////////////////////////////////////////////////
+
+#define SAMPLE_SIZE            16
+#define FILE_T                 FILE*
+#define INVALID_FILEDESC       NULL
+
+//// Simple types //////////////////////////////////////////////////
+
+typedef signed   int        Int;        // at least -32767...+32767, fast type
+typedef unsigned int        Uint;       // at least 0...65535, fast type
+typedef long double         Ldouble;    // most exact floating point format
+
+//// procedures/functions //////////////////////////////////////////
+// wave_out.c
+Int        Set_WIN_Params             ( FILE_T dummyFile , Ldouble SampleFreq, Uint BitsPerSample, Uint Channels);
+int        WIN_Play_Samples           ( const void* buff, size_t len );
+int        WIN_Audio_close            ( void );
+
+#endif /* WAVE_OUT_H */

package/android/settings.gradle

@@ -0,0 +1,4 @@
+include ':lc3Lib'
+
+include ':silero'
+project(':silero').projectDir = new File(rootDir, 'silero')

package/android/silero/LICENSE.md

@@ -0,0 +1,17 @@
+Copyright 2023 Georgiy Konovalov
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and 
+associated documentation files (the "Software"), to deal in the Software without restriction, 
+including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial 
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT 
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/android/silero/build.gradle

@@ -0,0 +1,50 @@
+// Vendored from https://github.com/gkonovalov/android-vad (silero module, v2.0.10)
+// Consumed in-place by the bluetooth-sdk so we can pin ORT to a version that
+// matches our other ORT consumer (sherpa-onnx) without depending on a Jitpack
+// AAR whose prebuilt JNI was built against a different ORT.
+plugins {
+    id 'com.android.library'
+    id 'kotlin-android'
+}
+
+android {
+    namespace "com.konovalov.vad.silero"
+    compileSdk 36
+
+    defaultConfig {
+        minSdkVersion 24
+        targetSdkVersion 36
+
+        ndk {
+            // Honor reactNativeArchitectures (dev CI is arm64-only; staging
+            // production sets all four ABIs) so this module does not keep
+            // compiling every ABI on a filtered build.
+            def abiList = (findProperty("reactNativeArchitectures") ?: "armeabi-v7a,arm64-v8a,x86,x86_64")
+                .toString()
+                .split(",")
+                .collect { it.trim() }
+                .findAll { !it.isEmpty() }
+            abiFilters(*abiList)
+        }
+    }
+
+    aaptOptions {
+        noCompress "onnx"
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+}
+
+dependencies {
+    // 1.27.0 matches the ORT version sherpa-onnx 1.13.4 was built against, so
+    // both consumers can share a single libonnxruntime.so (same versioned
+    // OrtGetApiBase@@VERS_1.27.0 symbol). Keep these versions in lockstep.
+    implementation 'com.microsoft.onnxruntime:onnxruntime-android:1.27.0'
+}

package/android/silero/proguard-rules.pro

@@ -0,0 +1,24 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
+-keep class ai.onnxruntime.** {*;}
+-keep class com.konovalov.vad.** {*;}
+-dontwarn com.google.**

package/android/silero/src/androidTest/java/com/konovalov/vad/silero/VadSileroTest.kt

@@ -0,0 +1,79 @@
+package com.konovalov.silero
+
+import android.content.Context
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.konovalov.vad.silero.Vad
+import com.konovalov.vad.silero.VadSilero
+import com.konovalov.vad.silero.config.FrameSize
+import com.konovalov.vad.silero.config.Mode
+import com.konovalov.vad.silero.config.SampleRate
+import junit.framework.TestCase.assertEquals
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+
+/**
+ * Created by Georgiy Konovalov on 12/22/2023.
+ *
+ * Instrumented test for VadSilero class.
+ */
+@RunWith(AndroidJUnit4::class)
+class VadSileroTest {
+
+    private lateinit var vad: VadSilero
+    private lateinit var testContext: Context
+
+    @Before
+    fun setUp() {
+        this.testContext = InstrumentationRegistry.getInstrumentation().context
+
+        this.vad = Vad.builder()
+            .setContext(testContext)
+            .setSampleRate(SampleRate.SAMPLE_RATE_16K)
+            .setFrameSize(FrameSize.FRAME_SIZE_512)
+            .setMode(Mode.VERY_AGGRESSIVE)
+            .build()
+    }
+
+    @After
+    fun shutdown() {
+        vad.close()
+    }
+
+    @Test
+    fun testIsSpeech() {
+        // List for VAD results
+        val actualResult = mutableListOf<Boolean>()
+
+        // List with expected VAD results
+        val expectedResult = listOf(
+            false, false, false, false, false,
+            false, true, true, true, true,
+            true, true, true, true, true,
+            true, true, true, false, false
+        )
+
+        // Buffer size should be 2x for ByteArray
+        val chunkSize = vad.frameSize.value * 2
+
+        // Reading audio data from test file
+        testContext.assets.open("hello.wav").buffered().use { input ->
+            // Skip WAV Header
+            input.skip(44)
+
+            while (input.available() > 0) {
+                // Read audio Frame
+                val frameChunk = ByteArray(chunkSize).apply { input.read(this) }
+
+                // Save interference result
+                actualResult.add(vad.isSpeech(frameChunk))
+            }
+        }
+
+        // Compare expectedResult with actualResult
+        assertEquals(expectedResult, actualResult)
+    }
+}

package/android/silero/src/main/assets/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-present Silero Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/android/silero/src/main/java/com/konovalov/vad/silero/Vad.kt

@@ -0,0 +1,160 @@
+package com.konovalov.vad.silero
+
+import android.content.Context
+import com.konovalov.vad.silero.config.FrameSize
+import com.konovalov.vad.silero.config.Mode
+import com.konovalov.vad.silero.config.SampleRate
+
+/**
+ * Created by Georgiy Konovalov on 6/26/2023.
+ *
+ * The Silero VAD algorithm, based on DNN, analyzes the audio signal to determine whether it
+ * contains speech or non-speech segments. It offers higher accuracy in differentiating speech from
+ * background noise compared to the WebRTC VAD algorithm.
+ *
+ * The Silero VAD supports the following parameters:
+ *
+ * Sample Rates:
+ *
+ *      8000Hz,
+ *      16000Hz
+ *
+ * Frame Sizes (per sample rate):
+ *
+ *    For 8000Hz: 80, 160, 240
+ *    For 16000Hz: 160, 320, 480
+ *
+ * Mode:
+ *
+ *    NORMAL,
+ *    LOW_BITRATE,
+ *    AGGRESSIVE,
+ *    VERY_AGGRESSIVE
+ *
+ * Please note that the VAD class supports these specific combinations of sample
+ * rates and frame sizes, and the classifiers determine the aggressiveness of the voice
+ * activity detection algorithm.
+ *
+ * @param context           is required for reading the model file from file system.
+ * @param sampleRate        is required for processing audio input.
+ * @param frameSize         is required for processing audio input.
+ * @param mode              is required for the VAD model.
+ * @param speechDurationMs  is minimum duration in milliseconds for speech segments (optional).
+ * @param silenceDurationMs is minimum duration in milliseconds for silence segments (optional).
+ */
+class Vad private constructor() {
+    private lateinit var context: Context
+    private lateinit var sampleRate: SampleRate
+    private lateinit var frameSize: FrameSize
+    private lateinit var mode: Mode
+    private var speechDurationMs = 0
+    private var silenceDurationMs = 0
+
+    /**
+     * Set Context for Vad Model.
+     *
+     * @param context is required for accessing the model file.
+     */
+    fun setContext(context: Context): Vad = apply {
+        this.context = context.applicationContext ?: context
+    }
+
+    /**
+     * Set, retrieve and validate sample rate for Vad Model.
+     *
+     * Valid Sample Rates:
+     *
+     *      8000Hz,
+     *      16000Hz
+     *
+     * @param sampleRate is required for processing audio input.
+     */
+    fun setSampleRate(sampleRate: SampleRate): Vad = apply {
+        this.sampleRate = sampleRate
+    }
+
+    /**
+     * Set, retrieve and validate frame size for Vad Model.
+     *
+     * Valid Frame Sizes (per sample rate):
+     *
+     *             For 8000Hz: 256, 512, 768
+     *             For 16000Hz: 512, 1024, 1536
+     *
+     * @param frameSize is required for processing audio input.
+     */
+    fun setFrameSize(frameSize: FrameSize): Vad = apply {
+        this.frameSize = frameSize
+    }
+
+    /**
+     * Set and retrieve detection mode for Vad model.
+     *
+     * Mode:
+     *
+     *    NORMAL,
+     *    LOW_BITRATE,
+     *    AGGRESSIVE,
+     *    VERY_AGGRESSIVE
+     *
+     * @param mode is required for the VAD model.
+     */
+    fun setMode(mode: Mode): Vad = apply {
+        this.mode = mode
+    }
+
+    /**
+     * Set the minimum duration in milliseconds for speech segments.
+     * The value of this parameter will define the necessary and sufficient duration of positive
+     * results to recognize result as speech. This parameter is optional.
+     *
+     * Permitted range (0ms >= speechDurationMs <= 300000ms).
+     *
+     * Parameters used for {@link VadSilero.isSpeech}.
+     *
+     * @param speechDurationMs minimum duration in milliseconds for speech segments.
+     */
+    fun setSpeechDurationMs(speechDurationMs: Int): Vad = apply {
+        this.speechDurationMs = speechDurationMs
+    }
+
+    /**
+     * Set the minimum duration in milliseconds for silence segments.
+     * The value of this parameter will define the necessary and sufficient duration of
+     * negative results to recognize it as silence. This parameter is optional.
+     *
+     * Permitted range (0ms >= silenceDurationMs <= 300000ms).
+     *
+     * Parameters used in {@link VadSilero.isSpeech}.
+     *
+     * @param silenceDurationMs minimum duration in milliseconds for silence segments.
+     */
+    fun setSilenceDurationMs(silenceDurationMs: Int): Vad = apply {
+        this.silenceDurationMs = silenceDurationMs
+    }
+
+    /**
+     * Builds and returns a VadModel instance based on the specified parameters.
+     *
+     * @return constructed VadSilero model.
+     * @throws IllegalArgumentException if invalid parameters have been set for the model.
+     * @throws OrtException if the model failed to parse, wasn't compatible or caused an error.
+     */
+    fun build(): VadSilero {
+        return VadSilero(
+            context,
+            sampleRate,
+            frameSize,
+            mode,
+            speechDurationMs,
+            silenceDurationMs
+        )
+    }
+
+    companion object {
+        @JvmStatic
+        fun builder(): Vad {
+            return Vad()
+        }
+    }
+}