whisper.rn 0.4.0-rc.9 → 0.4.1

package/cpp/whisper.h

@@ -2,6 +2,7 @@
 #define WHISPER_H
 
 #include "ggml.h"
+#include "ggml-cpu.h"
 
 #include <stddef.h>
 #include <stdint.h>
@@ -189,6 +190,15 @@ extern "C" {
         uint32_t             value; // Unicode code point or rule ID
     } whisper_grammar_element;
 
+    typedef struct whisper_vad_params {
+        float threshold;               // Probability threshold to consider as speech.
+        int   min_speech_duration_ms;  // Min duration for a valid speech segment.
+        int   min_silence_duration_ms; // Min silence duration to consider speech as ended.
+        float max_speech_duration_s;   // Max duration of a speech segment before forcing a new segment.
+        int   speech_pad_ms;           // Padding added before and after speech segments.
+        float samples_overlap;         // Overlap in seconds when copying audio samples from speech segment.
+    } whisper_vad_params;
+
     // Various functions for loading a ggml whisper model.
     // Allocate (almost) all memory needed for the model.
     // Return NULL on failure
@@ -425,21 +435,11 @@ extern "C" {
 
     // Performance information from the default state.
     struct whisper_timings {
-        int64_t load_us;
-        int64_t t_start_us;
-        int32_t fail_p;
-        int32_t fail_h;
-        int64_t t_mel_us;
-        int32_t n_sample;
-        int32_t n_encode;
-        int32_t n_decode;
-        int32_t n_batchd;
-        int32_t n_prompt;
-        int64_t t_sample_us;
-        int64_t t_encode_us;
-        int64_t t_decode_us;
-        int64_t t_batchd_us;
-        int64_t t_prompt_us;
+        float sample_ms;
+        float encode_ms;
+        float decode_ms;
+        float batchd_ms;
+        float prompt_ms;
     };
     WHISPER_API struct whisper_timings * whisper_get_timings(struct whisper_context * ctx);
     WHISPER_API void whisper_print_timings(struct whisper_context * ctx);
@@ -532,8 +532,8 @@ extern "C" {
         bool detect_language;
 
         // common decoding parameters:
-        bool suppress_blank;    // ref: https://github.com/openai/whisper/blob/f82bc59f5ea234d4b97fb2860842ed38519f7e65/whisper/decoding.py#L89
-        bool suppress_non_speech_tokens; // ref: https://github.com/openai/whisper/blob/7858aa9c08d98f75575035ecd6481f462d66ca27/whisper/tokenizer.py#L224-L253
+        bool suppress_blank; // ref: https://github.com/openai/whisper/blob/f82bc59f5ea234d4b97fb2860842ed38519f7e65/whisper/decoding.py#L89
+        bool suppress_nst;   // non-speech tokens, ref: https://github.com/openai/whisper/blob/7858aa9c08d98f75575035ecd6481f462d66ca27/whisper/tokenizer.py#L224-L253
 
         float temperature;      // initial decoding temperature, ref: https://ai.stackexchange.com/a/32478
         float max_initial_ts;   // ref: https://github.com/openai/whisper/blob/f82bc59f5ea234d4b97fb2860842ed38519f7e65/whisper/decoding.py#L97
@@ -544,7 +544,7 @@ extern "C" {
         float temperature_inc;
         float entropy_thold;    // similar to OpenAI's "compression_ratio_threshold"
         float logprob_thold;
-        float no_speech_thold;  // TODO: not implemented
+        float no_speech_thold;
 
         struct {
             int best_of;    // ref: https://github.com/openai/whisper/blob/f82bc59f5ea234d4b97fb2860842ed38519f7e65/whisper/transcribe.py#L264
@@ -580,11 +580,18 @@ extern "C" {
         size_t                           n_grammar_rules;
         size_t                           i_start_rule;
         float                            grammar_penalty;
+
+        // Voice Activity Detection (VAD) params
+        bool         vad;                         // Enable VAD
+        const char * vad_model_path;              // Path to VAD model
+
+        whisper_vad_params vad_params;
     };
 
     // NOTE: this function allocates memory, and it is the responsibility of the caller to free the pointer - see whisper_free_context_params & whisper_free_params()
     WHISPER_API struct whisper_context_params * whisper_context_default_params_by_ref(void);
     WHISPER_API struct whisper_context_params   whisper_context_default_params       (void);
+
     WHISPER_API struct whisper_full_params * whisper_full_default_params_by_ref(enum whisper_sampling_strategy strategy);
     WHISPER_API struct whisper_full_params   whisper_full_default_params       (enum whisper_sampling_strategy strategy);
 
@@ -662,6 +669,53 @@ extern "C" {
     WHISPER_API float whisper_full_get_token_p           (struct whisper_context * ctx, int i_segment, int i_token);
     WHISPER_API float whisper_full_get_token_p_from_state(struct whisper_state * state, int i_segment, int i_token);
 
+    //
+    // Voice Activity Detection (VAD)
+    //
+
+    struct whisper_vad_context;
+
+    WHISPER_API struct whisper_vad_params whisper_vad_default_params(void);
+
+    struct whisper_vad_context_params {
+        int   n_threads;  // The number of threads to use for processing.
+        bool  use_gpu;
+        int   gpu_device; // CUDA device
+    };
+
+    WHISPER_API struct whisper_vad_context_params whisper_vad_default_context_params(void);
+
+    WHISPER_API struct whisper_vad_context * whisper_vad_init_from_file_with_params(const char * path_model,              struct whisper_vad_context_params params);
+    WHISPER_API struct whisper_vad_context * whisper_vad_init_with_params          (struct whisper_model_loader * loader, struct whisper_vad_context_params params);
+
+    WHISPER_API bool whisper_vad_detect_speech(
+            struct whisper_vad_context * vctx,
+                           const float * samples,
+                                   int   n_samples);
+
+    WHISPER_API int     whisper_vad_n_probs(struct whisper_vad_context * vctx);
+    WHISPER_API float * whisper_vad_probs  (struct whisper_vad_context * vctx);
+
+    struct whisper_vad_segments;
+
+    WHISPER_API struct whisper_vad_segments * whisper_vad_segments_from_probs(
+            struct whisper_vad_context * vctx,
+            struct whisper_vad_params    params);
+
+    WHISPER_API struct whisper_vad_segments * whisper_vad_segments_from_samples(
+            struct whisper_vad_context * vctx,
+            struct whisper_vad_params    params,
+                           const float * samples,
+                                   int   n_samples);
+
+    WHISPER_API int whisper_vad_segments_n_segments(struct whisper_vad_segments * segments);
+
+    WHISPER_API float whisper_vad_segments_get_segment_t0(struct whisper_vad_segments * segments, int i_segment);
+    WHISPER_API float whisper_vad_segments_get_segment_t1(struct whisper_vad_segments * segments, int i_segment);
+
+    WHISPER_API void whisper_vad_free_segments(struct whisper_vad_segments * segments);
+    WHISPER_API void whisper_vad_free         (struct whisper_vad_context  * ctx);
+
     ////////////////////////////////////////////////////////////////////////////
 
     // Temporary helpers needed for exposing ggml interface
@@ -675,6 +729,9 @@ extern "C" {
 
     WHISPER_API void whisper_log_set(wsp_ggml_log_callback log_callback, void * user_data);
 
+    // Get the no_speech probability for the specified segment
+    WHISPER_API float whisper_full_get_segment_no_speech_prob           (struct whisper_context * ctx, int i_segment);
+    WHISPER_API float whisper_full_get_segment_no_speech_prob_from_state(struct whisper_state * state, int i_segment);
 #ifdef __cplusplus
 }
 #endif

package/ios/CMakeLists.txt

@@ -0,0 +1,95 @@
+cmake_minimum_required(VERSION 3.16)
+project(rnwhisper VERSION 1.0.0 LANGUAGES CXX C)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# iOS specific settings
+set(CMAKE_OSX_DEPLOYMENT_TARGET 13.0)
+set(CMAKE_XCODE_ATTRIBUTE_ENABLE_BITCODE NO)
+
+# Dependencies and compile options
+add_definitions(
+    -DNDEBUG
+    -DO3
+    -DWSP_GGML_USE_CPU
+    -DWSP_GGML_USE_ACCELERATE
+    -DWSP_GGML_USE_METAL
+    -DWSP_GGML_METAL_USE_BF16
+)
+
+if (CMAKE_OSX_ARCHITECTURES STREQUAL "arm64;x86_64")
+    add_definitions(-DWSP_GGML_CPU_GENERIC)
+endif ()
+
+set(SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../cpp)
+
+if (CMAKE_OSX_ARCHITECTURES STREQUAL "arm64")
+    set(SOURCE_FILES_ARCH
+        ${SOURCE_DIR}/ggml-cpu/arch/arm/quants.c
+        ${SOURCE_DIR}/ggml-cpu/arch/arm/repack.cpp
+    )
+endif ()
+
+# Define public headers
+set(PUBLIC_HEADERS
+    ${SOURCE_DIR}/rn-whisper.h
+    ${SOURCE_DIR}/whisper.h
+    ${SOURCE_DIR}/ggml.h
+)
+
+# Create library target
+add_library(rnwhisper SHARED
+    ${SOURCE_DIR}/ggml.c
+    ${SOURCE_DIR}/ggml-alloc.c
+    ${SOURCE_DIR}/ggml-backend.cpp
+    ${SOURCE_DIR}/ggml-backend-reg.cpp
+    ${SOURCE_DIR}/ggml-cpu/amx/amx.cpp
+    ${SOURCE_DIR}/ggml-cpu/amx/mmq.cpp
+    ${SOURCE_DIR}/ggml-cpu/ggml-cpu.c
+    ${SOURCE_DIR}/ggml-cpu/ggml-cpu.cpp
+    ${SOURCE_DIR}/ggml-cpu/quants.c
+    ${SOURCE_DIR}/ggml-cpu/traits.cpp
+    ${SOURCE_DIR}/ggml-cpu/repack.cpp
+    ${SOURCE_DIR}/ggml-cpu/unary-ops.cpp
+    ${SOURCE_DIR}/ggml-cpu/binary-ops.cpp
+    ${SOURCE_DIR}/ggml-cpu/vec.cpp
+    ${SOURCE_DIR}/ggml-cpu/ops.cpp
+    ${SOURCE_DIR}/ggml-metal.m
+    ${SOURCE_DIR}/ggml-opt.cpp
+    ${SOURCE_DIR}/ggml-threading.cpp
+    ${SOURCE_DIR}/ggml-quants.c
+    ${SOURCE_DIR}/gguf.cpp
+    ${SOURCE_DIR}/whisper.cpp
+    ${SOURCE_DIR}/rn-whisper.cpp
+    ${SOURCE_DIR}/rn-audioutils.cpp
+    ${SOURCE_FILES_ARCH}
+)
+
+# Setup include directories
+target_include_directories(rnwhisper
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../cpp>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../cpp/ggml-cpu>
+        $<INSTALL_INTERFACE:include>
+)
+
+# Link required frameworks
+target_link_libraries(rnwhisper PRIVATE
+    "-framework Accelerate"
+    "-framework Foundation"
+    "-framework Metal"
+    "-framework MetalKit"
+)
+
+# Set properties for framework
+set_target_properties(rnwhisper PROPERTIES
+    MACOSX_FRAMEWORK_IDENTIFIER "com.rnwhisper"
+    MACOSX_FRAMEWORK_BUNDLE_VERSION 1.0.0
+    MACOSX_FRAMEWORK_SHORT_VERSION_STRING 1.0.0
+    FRAMEWORK TRUE
+    FRAMEWORK_VERSION 1.0.0
+    VERSION 1.0.0
+    PUBLIC_HEADER "${PUBLIC_HEADERS}"
+    XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC NO
+)

package/ios/RNWhisper.h

@@ -1,6 +1,11 @@
 #ifdef __cplusplus
+#if RNWHISPER_BUILD_FROM_SOURCE
 #import "whisper.h"
 #import "rn-whisper.h"
+#else
+#import <rnwhisper/whisper.h>
+#import <rnwhisper/rn-whisper.h>
+#endif
 #endif
 
 #import <React/RCTBridgeModule.h>

package/ios/RNWhisper.mm

@@ -1,5 +1,6 @@
 #import "RNWhisper.h"
 #import "RNWhisperContext.h"
+#import "RNWhisperVadContext.h"
 #import "RNWhisperDownloader.h"
 #import "RNWhisperAudioUtils.h"
 #import "RNWhisperAudioSessionUtils.h"
@@ -13,6 +14,7 @@
 @implementation RNWhisper
 
 NSMutableDictionary *contexts;
+NSMutableDictionary *vadContexts;
 
 RCT_EXPORT_MODULE()
 
@@ -366,6 +368,15 @@ RCT_REMAP_METHOD(releaseAllContexts,
         [context invalidate];
     }
 
+    if (vadContexts != nil) {
+        for (NSNumber *contextId in vadContexts) {
+            RNWhisperVadContext *vadContext = vadContexts[contextId];
+            [vadContext invalidate];
+        }
+        [vadContexts removeAllObjects];
+        vadContexts = nil;
+    }
+
     rnwhisper::job_abort_all(); // graceful abort
 
     [contexts removeAllObjects];
@@ -437,6 +448,142 @@ RCT_REMAP_METHOD(setAudioSessionActive,
     resolve(nil);
 }
 
+RCT_REMAP_METHOD(initVadContext,
+                 withVadOptions:(NSDictionary *)vadOptions
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+{
+    if (vadContexts == nil) {
+        vadContexts = [[NSMutableDictionary alloc] init];
+    }
+
+    NSString *modelPath = [vadOptions objectForKey:@"filePath"];
+    BOOL isBundleAsset = [[vadOptions objectForKey:@"isBundleAsset"] boolValue];
+    BOOL useGpu = [[vadOptions objectForKey:@"useGpu"] boolValue];
+    NSNumber *nThreads = [vadOptions objectForKey:@"nThreads"];
+
+    NSString *path = modelPath;
+    if ([path hasPrefix:@"http://"] || [path hasPrefix:@"https://"]) {
+        path = [RNWhisperDownloader downloadFile:path toFile:nil];
+    }
+    if (isBundleAsset) {
+        path = [[NSBundle mainBundle] pathForResource:modelPath ofType:nil];
+    }
+
+    int contextId = arc4random_uniform(1000000);
+
+    RNWhisperVadContext *vadContext = [RNWhisperVadContext
+        initWithModelPath:path
+        contextId:contextId
+        noMetal:!useGpu
+        nThreads:nThreads
+    ];
+    if ([vadContext getVadContext] == NULL) {
+        reject(@"whisper_vad_error", @"Failed to load the VAD model", nil);
+        return;
+    }
+
+    [vadContexts setObject:vadContext forKey:[NSNumber numberWithInt:contextId]];
+
+    resolve(@{
+        @"contextId": @(contextId),
+        @"gpu": @([vadContext isMetalEnabled]),
+        @"reasonNoGPU": [vadContext reasonNoMetal],
+    });
+}
+
+RCT_REMAP_METHOD(vadDetectSpeech,
+                 withContextId:(int)contextId
+                 withAudioData:(NSString *)audioDataBase64
+                 withOptions:(NSDictionary *)options
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+{
+    RNWhisperVadContext *vadContext = vadContexts[[NSNumber numberWithInt:contextId]];
+
+    if (vadContext == nil) {
+        reject(@"whisper_vad_error", @"VAD context not found", nil);
+        return;
+    }
+
+    // Decode base64 audio data
+    NSData *audioData = [[NSData alloc] initWithBase64EncodedString:audioDataBase64 options:0];
+    if (audioData == nil) {
+        reject(@"whisper_vad_error", @"Invalid audio data", nil);
+        return;
+    }
+
+    NSArray *segments = [vadContext detectSpeech:audioData options:options];
+    resolve(segments);
+}
+
+RCT_REMAP_METHOD(vadDetectSpeechFile,
+                 withVadContextId:(int)contextId
+                 withFilePath:(NSString *)filePath
+                 withOptions:(NSDictionary *)options
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+{
+    RNWhisperVadContext *vadContext = vadContexts[[NSNumber numberWithInt:contextId]];
+
+    if (vadContext == nil) {
+        reject(@"whisper_vad_error", @"VAD context not found", nil);
+        return;
+    }
+
+    // Handle different input types like transcribeFile does
+    float *data = nil;
+    int count = 0;
+    if ([filePath hasPrefix:@"http://"] || [filePath hasPrefix:@"https://"]) {
+        NSString *path = [RNWhisperDownloader downloadFile:filePath toFile:nil];
+        data = [RNWhisperAudioUtils decodeWaveFile:path count:&count];
+    } else if ([filePath hasPrefix:@"data:audio/wav;base64,"]) {
+        NSData *waveData = [[NSData alloc] initWithBase64EncodedString:[filePath substringFromIndex:22] options:0];
+        data = [RNWhisperAudioUtils decodeWaveData:waveData count:&count cutHeader:YES];
+    } else {
+        data = [RNWhisperAudioUtils decodeWaveFile:filePath count:&count];
+    }
+
+    if (data == nil) {
+        reject(@"whisper_vad_error", @"Failed to load or decode audio file", nil);
+        return;
+    }
+
+    // Convert float32 data to NSData for VAD context
+    NSData *audioData = [NSData dataWithBytes:data length:count * sizeof(float)];
+
+    NSArray *segments = [vadContext detectSpeech:audioData options:options];
+    resolve(segments);
+}
+
+RCT_REMAP_METHOD(releaseVadContext,
+                 withVadContextId:(int)contextId
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+{
+    RNWhisperVadContext *vadContext = vadContexts[[NSNumber numberWithInt:contextId]];
+    if (vadContext == nil) {
+        reject(@"whisper_vad_error", @"VAD context not found", nil);
+        return;
+    }
+    [vadContext invalidate];
+    [vadContexts removeObjectForKey:[NSNumber numberWithInt:contextId]];
+    resolve(nil);
+}
+
+RCT_EXPORT_METHOD(releaseAllVadContexts:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+{
+    if (vadContexts != nil) {
+        for (NSNumber *contextId in vadContexts) {
+            RNWhisperVadContext *vadContext = vadContexts[contextId];
+            [vadContext invalidate];
+        }
+        [vadContexts removeAllObjects];
+    }
+    resolve(nil);
+}
+
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params

package/ios/RNWhisperAudioUtils.m

@@ -1,5 +1,9 @@
 #import "RNWhisperAudioUtils.h"
+#if RNWHISPER_BUILD_FROM_SOURCE
 #import "whisper.h"
+#else
+#import <rnwhisper/whisper.h>
+#endif
 
 @implementation RNWhisperAudioUtils
 

package/ios/RNWhisperContext.h

@@ -1,6 +1,11 @@
 #ifdef __cplusplus
+#if RNWHISPER_BUILD_FROM_SOURCE
 #import "whisper.h"
 #import "rn-whisper.h"
+#else
+#import <rnwhisper/whisper.h>
+#import <rnwhisper/rn-whisper.h>
+#endif
 #endif
 
 #import <AVFoundation/AVFoundation.h>

package/ios/RNWhisperContext.mm

@@ -19,8 +19,9 @@
     cparams.use_gpu = !noMetal;
     cparams.flash_attn = useFlashAttn;
 
-    // TODO: Figure out why it leads to re-init crash
+    // TODO: Expose dtw_token_timestamps and dtw_aheads_preset
     cparams.dtw_token_timestamps = false;
+    // cparams.dtw_aheads_preset = WHISPER_AHEADS_BASE;
 
     cparams.use_coreml = !noCoreML;
 #ifndef WHISPER_USE_COREML
@@ -35,36 +36,30 @@
         NSLog(@"[RNWhisper] ggml-metal is not enabled in this build, ignoring use_gpu option");
         cparams.use_gpu = false;
     }
+    reasonNoMetal = @"Metal is not enabled in this build";
 #endif
 
 #ifdef WSP_GGML_USE_METAL
     if (cparams.use_gpu) {
-#if TARGET_OS_SIMULATOR
-        NSLog(@"[RNWhisper] ggml-metal is not available in simulator, ignoring use_gpu option: %@", reasonNoMetal);
-        cparams.use_gpu = false;
-#else // TARGET_OS_SIMULATOR
-        // Check ggml-metal availability
-        NSError * error = nil;
         id<MTLDevice> device = MTLCreateSystemDefaultDevice();
-        id<MTLLibrary> library = [device
-            newLibraryWithSource:@"#include <metal_stdlib>\n"
-                                    "using namespace metal;"
-                                    "kernel void test() { simd_sum(0); }"
-            options:nil
-            error:&error
-        ];
-        if (error) {
-            reasonNoMetal = [error localizedDescription];
-        } else {
-            id<MTLFunction> kernel = [library newFunctionWithName:@"test"];
-            id<MTLComputePipelineState> pipeline = [device newComputePipelineStateWithFunction:kernel error:&error];
-            if (pipeline == nil) {
-                reasonNoMetal = [error localizedDescription];
-                NSLog(@"[RNWhisper] ggml-metal is not available, ignoring use_gpu option: %@", reasonNoMetal);
-                cparams.use_gpu = false;
-            }
+
+        // Check ggml-metal availability
+        BOOL supportsGgmlMetal = [device supportsFamily:MTLGPUFamilyApple7];
+        if (@available(iOS 16.0, tvOS 16.0, *)) {
+            supportsGgmlMetal = supportsGgmlMetal && [device supportsFamily:MTLGPUFamilyMetal3];
         }
-#endif // TARGET_OS_SIMULATOR
+        if (!supportsGgmlMetal) {
+            cparams.use_gpu = false;
+            reasonNoMetal = @"Metal is not supported in this device";
+        }
+
+#if TARGET_OS_SIMULATOR
+        // Use the backend, but no layers because not supported fully on simulator
+        cparams.use_gpu = false;
+        reasonNoMetal = @"Metal is not supported in simulator";
+#endif
+
+        device = nil;
     }
 #endif // WSP_GGML_USE_METAL
 
@@ -431,6 +426,7 @@ struct rnwhisper_segments_callback_data {
         self->recordState.job = job;
         int code = [self fullTranscribe:job audioData:audioData audioDataCount:audioDataCount];
         rnwhisper::job_remove(jobId);
+        self->recordState.job = nullptr;
         self->recordState.isTranscribing = false;
         onEnd(code);
     });
@@ -445,7 +441,7 @@ struct rnwhisper_segments_callback_data {
 }
 
 - (void)stopTranscribe:(int)jobId {
-    if (self->recordState.job) self->recordState.job->abort();
+    if (self->recordState.job != nullptr) self->recordState.job->abort();
     if (self->recordState.isRealtime && self->recordState.isCapturing) {
         [self stopAudio];
         if (!self->recordState.isTranscribing) {

package/ios/RNWhisperVadContext.h

@@ -0,0 +1,29 @@
+#ifdef __cplusplus
+#if RNWHISPER_BUILD_FROM_SOURCE
+#import "whisper.h"
+#import "rn-whisper.h"
+#else
+#import <rnwhisper/whisper.h>
+#import <rnwhisper/rn-whisper.h>
+#endif
+#endif
+
+#import <Foundation/Foundation.h>
+
+@interface RNWhisperVadContext : NSObject {
+    int contextId;
+    dispatch_queue_t dQueue;
+    struct whisper_vad_context * vctx;
+    NSString * reasonNoMetal;
+    bool isMetalEnabled;
+}
+
++ (instancetype)initWithModelPath:(NSString *)modelPath contextId:(int)contextId noMetal:(BOOL)noMetal nThreads:(NSNumber *)nThreads;
+- (bool)isMetalEnabled;
+- (NSString *)reasonNoMetal;
+- (struct whisper_vad_context *)getVadContext;
+- (dispatch_queue_t)getDispatchQueue;
+- (NSArray *)detectSpeech:(NSData *)audioData options:(NSDictionary *)options;
+- (void)invalidate;
+
+@end