whisper.rn 0.4.0 → 0.4.1

package/android/src/main/jni.cpp

@@ -148,6 +148,47 @@ static struct whisper_context *whisper_init_from_asset(
     return whisper_init_with_params(&loader, cparams);
 }
 
+// VAD context initialization functions
+static struct whisper_vad_context *whisper_vad_init_from_input_stream(
+    JNIEnv *env,
+    jobject input_stream, // PushbackInputStream
+    struct whisper_vad_context_params vad_params
+) {
+    input_stream_context *context = new input_stream_context;
+    context->env = env;
+    context->input_stream = env->NewGlobalRef(input_stream);
+
+    whisper_model_loader loader = {
+        .context = context,
+        .read = &input_stream_read,
+        .eof = &input_stream_is_eof,
+        .close = &input_stream_close
+    };
+    return whisper_vad_init_with_params(&loader, vad_params);
+}
+
+static struct whisper_vad_context *whisper_vad_init_from_asset(
+    JNIEnv *env,
+    jobject assetManager,
+    const char *asset_path,
+    struct whisper_vad_context_params vad_params
+) {
+    LOGI("Loading VAD model from asset '%s'\n", asset_path);
+    AAssetManager *asset_manager = AAssetManager_fromJava(env, assetManager);
+    AAsset *asset = AAssetManager_open(asset_manager, asset_path, AASSET_MODE_STREAMING);
+    if (!asset) {
+        LOGW("Failed to open VAD asset '%s'\n", asset_path);
+        return NULL;
+    }
+    whisper_model_loader loader = {
+        .context = asset,
+        .read = &asset_read,
+        .eof = &asset_is_eof,
+        .close = &asset_close
+    };
+    return whisper_vad_init_with_params(&loader, vad_params);
+}
+
 extern "C" {
 
 JNIEXPORT jlong JNICALL
@@ -530,4 +571,159 @@ Java_com_rnwhisper_WhisperContext_bench(
     return env->NewStringUTF(result.c_str());
 }
 
+// VAD Context JNI implementations
+JNIEXPORT jlong JNICALL
+Java_com_rnwhisper_WhisperContext_initVadContext(
+    JNIEnv *env,
+    jobject thiz,
+    jstring model_path_str
+) {
+    UNUSED(thiz);
+    struct whisper_vad_context_params vad_params = whisper_vad_default_context_params();
+
+    struct whisper_vad_context *vad_context = nullptr;
+    const char *model_path_chars = env->GetStringUTFChars(model_path_str, nullptr);
+    vad_context = whisper_vad_init_from_file_with_params(model_path_chars, vad_params);
+    env->ReleaseStringUTFChars(model_path_str, model_path_chars);
+    return reinterpret_cast<jlong>(vad_context);
+}
+
+JNIEXPORT jlong JNICALL
+Java_com_rnwhisper_WhisperContext_initVadContextWithAsset(
+    JNIEnv *env,
+    jobject thiz,
+    jobject asset_manager,
+    jstring model_path_str
+) {
+    UNUSED(thiz);
+    struct whisper_vad_context_params vad_params = whisper_vad_default_context_params();
+
+    struct whisper_vad_context *vad_context = nullptr;
+    const char *model_path_chars = env->GetStringUTFChars(model_path_str, nullptr);
+    vad_context = whisper_vad_init_from_asset(env, asset_manager, model_path_chars, vad_params);
+    env->ReleaseStringUTFChars(model_path_str, model_path_chars);
+    return reinterpret_cast<jlong>(vad_context);
+}
+
+JNIEXPORT jlong JNICALL
+Java_com_rnwhisper_WhisperContext_initVadContextWithInputStream(
+    JNIEnv *env,
+    jobject thiz,
+    jobject input_stream
+) {
+    UNUSED(thiz);
+    struct whisper_vad_context_params vad_params = whisper_vad_default_context_params();
+
+    struct whisper_vad_context *vad_context = nullptr;
+    vad_context = whisper_vad_init_from_input_stream(env, input_stream, vad_params);
+    return reinterpret_cast<jlong>(vad_context);
+}
+
+JNIEXPORT void JNICALL
+Java_com_rnwhisper_WhisperContext_freeVadContext(
+    JNIEnv *env,
+    jobject thiz,
+    jlong vad_context_ptr
+) {
+    UNUSED(env);
+    UNUSED(thiz);
+    struct whisper_vad_context *vad_context = reinterpret_cast<struct whisper_vad_context *>(vad_context_ptr);
+    whisper_vad_free(vad_context);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_rnwhisper_WhisperContext_vadDetectSpeech(
+    JNIEnv *env,
+    jobject thiz,
+    jlong vad_context_ptr,
+    jfloatArray audio_data,
+    jint n_samples
+) {
+    UNUSED(thiz);
+    struct whisper_vad_context *vad_context = reinterpret_cast<struct whisper_vad_context *>(vad_context_ptr);
+
+    jfloat *audio_data_arr = env->GetFloatArrayElements(audio_data, nullptr);
+    bool result = whisper_vad_detect_speech(vad_context, audio_data_arr, n_samples);
+    env->ReleaseFloatArrayElements(audio_data, audio_data_arr, JNI_ABORT);
+
+    return result;
+}
+
+JNIEXPORT jlong JNICALL
+Java_com_rnwhisper_WhisperContext_vadGetSegmentsFromProbs(
+    JNIEnv *env,
+    jobject thiz,
+    jlong vad_context_ptr,
+    jfloat threshold,
+    jint min_speech_duration_ms,
+    jint min_silence_duration_ms,
+    jfloat max_speech_duration_s,
+    jint speech_pad_ms,
+    jfloat samples_overlap
+) {
+    UNUSED(thiz);
+    struct whisper_vad_context *vad_context = reinterpret_cast<struct whisper_vad_context *>(vad_context_ptr);
+
+    struct whisper_vad_params vad_params = whisper_vad_default_params();
+    vad_params.threshold = threshold;
+    vad_params.min_speech_duration_ms = min_speech_duration_ms;
+    vad_params.min_silence_duration_ms = min_silence_duration_ms;
+    vad_params.max_speech_duration_s = max_speech_duration_s;
+    vad_params.speech_pad_ms = speech_pad_ms;
+    vad_params.samples_overlap = samples_overlap;
+
+    struct whisper_vad_segments *segments = whisper_vad_segments_from_probs(vad_context, vad_params);
+    return reinterpret_cast<jlong>(segments);
+}
+
+JNIEXPORT jint JNICALL
+Java_com_rnwhisper_WhisperContext_vadGetNSegments(
+    JNIEnv *env,
+    jobject thiz,
+    jlong segments_ptr
+) {
+    UNUSED(env);
+    UNUSED(thiz);
+    struct whisper_vad_segments *segments = reinterpret_cast<struct whisper_vad_segments *>(segments_ptr);
+    return whisper_vad_segments_n_segments(segments);
+}
+
+JNIEXPORT jfloat JNICALL
+Java_com_rnwhisper_WhisperContext_vadGetSegmentT0(
+    JNIEnv *env,
+    jobject thiz,
+    jlong segments_ptr,
+    jint index
+) {
+    UNUSED(env);
+    UNUSED(thiz);
+    struct whisper_vad_segments *segments = reinterpret_cast<struct whisper_vad_segments *>(segments_ptr);
+    return whisper_vad_segments_get_segment_t0(segments, index);
+}
+
+JNIEXPORT jfloat JNICALL
+Java_com_rnwhisper_WhisperContext_vadGetSegmentT1(
+    JNIEnv *env,
+    jobject thiz,
+    jlong segments_ptr,
+    jint index
+) {
+    UNUSED(env);
+    UNUSED(thiz);
+    struct whisper_vad_segments *segments = reinterpret_cast<struct whisper_vad_segments *>(segments_ptr);
+    return whisper_vad_segments_get_segment_t1(segments, index);
+}
+
+JNIEXPORT void JNICALL
+Java_com_rnwhisper_WhisperContext_vadFreeSegments(
+    JNIEnv *env,
+    jobject thiz,
+    jlong segments_ptr
+) {
+    UNUSED(env);
+    UNUSED(thiz);
+    struct whisper_vad_segments *segments = reinterpret_cast<struct whisper_vad_segments *>(segments_ptr);
+    whisper_vad_free_segments(segments);
+}
+
 } // extern "C"

package/android/src/newarch/java/com/rnwhisper/RNWhisperModule.java

@@ -77,6 +77,32 @@ public class RNWhisperModule extends NativeRNWhisperSpec {
     rnwhisper.releaseAllContexts(promise);
   }
 
+  // VAD methods
+  @ReactMethod
+  public void initVadContext(final ReadableMap options, final Promise promise) {
+    rnwhisper.initVadContext(options, promise);
+  }
+
+  @ReactMethod
+  public void vadDetectSpeech(double id, String audioDataBase64, ReadableMap options, Promise promise) {
+    rnwhisper.vadDetectSpeech(id, audioDataBase64, options, promise);
+  }
+
+  @ReactMethod
+  public void vadDetectSpeechFile(double id, String filePath, ReadableMap options, Promise promise) {
+    rnwhisper.vadDetectSpeechFile(id, filePath, options, promise);
+  }
+
+  @ReactMethod
+  public void releaseVadContext(double id, Promise promise) {
+    rnwhisper.releaseVadContext(id, promise);
+  }
+
+  @ReactMethod
+  public void releaseAllVadContexts(Promise promise) {
+    rnwhisper.releaseAllVadContexts(promise);
+  }
+
   /*
    * iOS Specific methods, left here for make the turbo module happy:
    */

package/android/src/oldarch/java/com/rnwhisper/RNWhisperModule.java

@@ -76,4 +76,30 @@ public class RNWhisperModule extends ReactContextBaseJavaModule {
   public void releaseAllContexts(Promise promise) {
     rnwhisper.releaseAllContexts(promise);
   }
+
+  // VAD methods
+  @ReactMethod
+  public void initVadContext(final ReadableMap options, final Promise promise) {
+    rnwhisper.initVadContext(options, promise);
+  }
+
+  @ReactMethod
+  public void vadDetectSpeech(double id, String audioDataBase64, ReadableMap options, Promise promise) {
+    rnwhisper.vadDetectSpeech(id, audioDataBase64, options, promise);
+  }
+
+  @ReactMethod
+  public void vadDetectSpeechFile(double id, String filePath, ReadableMap options, Promise promise) {
+    rnwhisper.vadDetectSpeechFile(id, filePath, options, promise);
+  }
+
+  @ReactMethod
+  public void releaseVadContext(double id, Promise promise) {
+    rnwhisper.releaseVadContext(id, promise);
+  }
+
+  @ReactMethod
+  public void releaseAllVadContexts(Promise promise) {
+    rnwhisper.releaseAllVadContexts(promise);
+  }
 }

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/RNWhisperContext.mm

@@ -36,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
 

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

package/ios/RNWhisperVadContext.mm

@@ -0,0 +1,152 @@
+#import "RNWhisperVadContext.h"
+#import "RNWhisperAudioUtils.h"
+#import <Metal/Metal.h>
+
+@implementation RNWhisperVadContext
+
++ (instancetype)initWithModelPath:(NSString *)modelPath contextId:(int)contextId noMetal:(BOOL)noMetal nThreads:(NSNumber *)nThreads {
+    RNWhisperVadContext *context = [[RNWhisperVadContext alloc] init];
+
+    context->contextId = contextId;
+    context->dQueue = dispatch_queue_create("rnwhisper.vad.serial_queue", DISPATCH_QUEUE_SERIAL);
+    NSString *reasonNoMetal = @"";
+
+    // Set up VAD context parameters
+    struct whisper_vad_context_params ctx_params = whisper_vad_default_context_params();
+    ctx_params.use_gpu = !noMetal;
+    if (nThreads != nil) {
+        ctx_params.n_threads = [nThreads intValue];
+    }
+
+#ifdef WSP_GGML_USE_METAL
+    if (ctx_params.use_gpu) {
+        id<MTLDevice> device = MTLCreateSystemDefaultDevice();
+
+        // Check ggml-metal availability
+        BOOL supportsGgmlMetal = [device supportsFamily:MTLGPUFamilyApple7];
+        if (@available(iOS 16.0, tvOS 16.0, *)) {
+            supportsGgmlMetal = supportsGgmlMetal && [device supportsFamily:MTLGPUFamilyMetal3];
+        }
+        if (!supportsGgmlMetal) {
+          ctx_params.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
+        ctx_params.use_gpu = false;
+        reasonNoMetal = @"Metal is not supported in simulator";
+#endif
+
+        device = nil;
+    }
+#endif // WSP_GGML_USE_METAL
+
+    // Initialize VAD context
+    context->vctx = whisper_vad_init_from_file_with_params([modelPath UTF8String], ctx_params);
+
+    if (context->vctx == NULL) {
+        NSLog(@"Failed to initialize VAD context from model: %@", modelPath);
+        return nil;
+    }
+
+    // Check GPU status
+    context->isMetalEnabled = ctx_params.use_gpu;
+    context->reasonNoMetal = reasonNoMetal;
+
+    return context;
+}
+
+- (bool)isMetalEnabled {
+    return isMetalEnabled;
+}
+
+- (NSString *)reasonNoMetal {
+    return reasonNoMetal;
+}
+
+- (struct whisper_vad_context *)getVadContext {
+    return vctx;
+}
+
+- (dispatch_queue_t)getDispatchQueue {
+    return dQueue;
+}
+
+- (NSArray *)detectSpeech:(NSData *)audioData options:(NSDictionary *)options {
+    if (vctx == NULL) {
+        NSLog(@"VAD context is null");
+        return @[];
+    }
+
+    // Convert NSData to float array
+    const float *samples = (const float *)[audioData bytes];
+    int n_samples = (int)[audioData length] / sizeof(float);
+
+    // Run VAD detection
+    bool speechDetected = whisper_vad_detect_speech(vctx, samples, n_samples);
+    if (!speechDetected) {
+        return @[];
+    }
+
+    // Get VAD parameters
+    struct whisper_vad_params vad_params = whisper_vad_default_params();
+
+    if ([options objectForKey:@"threshold"]) {
+        vad_params.threshold = [[options objectForKey:@"threshold"] floatValue];
+    }
+    if ([options objectForKey:@"minSpeechDurationMs"]) {
+        vad_params.min_speech_duration_ms = [[options objectForKey:@"minSpeechDurationMs"] intValue];
+    }
+    if ([options objectForKey:@"minSilenceDurationMs"]) {
+        vad_params.min_silence_duration_ms = [[options objectForKey:@"minSilenceDurationMs"] intValue];
+    }
+    if ([options objectForKey:@"maxSpeechDurationS"]) {
+        vad_params.max_speech_duration_s = [[options objectForKey:@"maxSpeechDurationS"] floatValue];
+    }
+    if ([options objectForKey:@"speechPadMs"]) {
+        vad_params.speech_pad_ms = [[options objectForKey:@"speechPadMs"] intValue];
+    }
+    if ([options objectForKey:@"samplesOverlap"]) {
+        vad_params.samples_overlap = [[options objectForKey:@"samplesOverlap"] floatValue];
+    }
+
+    // Get segments from VAD probabilities
+    struct whisper_vad_segments * segments = whisper_vad_segments_from_probs(vctx, vad_params);
+    if (segments == NULL) {
+        return @[];
+    }
+
+    // Convert segments to NSArray
+    NSMutableArray *result = [[NSMutableArray alloc] init];
+    int n_segments = whisper_vad_segments_n_segments(segments);
+
+    for (int i = 0; i < n_segments; i++) {
+        float t0 = whisper_vad_segments_get_segment_t0(segments, i);
+        float t1 = whisper_vad_segments_get_segment_t1(segments, i);
+
+        NSDictionary *segment = @{
+            @"t0": @(t0),
+            @"t1": @(t1)
+        };
+        [result addObject:segment];
+    }
+
+    // Clean up
+    whisper_vad_free_segments(segments);
+
+    return result;
+}
+
+- (void)invalidate {
+    if (vctx != NULL) {
+        whisper_vad_free(vctx);
+        vctx = NULL;
+    }
+}
+
+- (void)dealloc {
+    [self invalidate];
+}
+
+@end