whisper.rn 0.4.0-rc.9 → 0.4.1

package/android/src/main/java/com/rnwhisper/WhisperVadContext.java

@@ -0,0 +1,157 @@
+package com.rnwhisper;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReactApplicationContext;
+
+import android.util.Log;
+import android.content.res.AssetManager;
+import android.util.Base64;
+
+import java.io.PushbackInputStream;
+
+public class WhisperVadContext {
+    public static final String NAME = "RNWhisperVadContext";
+
+    private int id;
+    private ReactApplicationContext reactContext;
+    private long vadContext;
+
+    public WhisperVadContext(int id, ReactApplicationContext reactContext, long vadContext) {
+        this.id = id;
+        this.vadContext = vadContext;
+        this.reactContext = reactContext;
+    }
+
+    public WritableArray detectSpeech(String audioDataBase64, ReadableMap options) throws Exception {
+        if (vadContext == 0) {
+            throw new Exception("VAD context is null");
+        }
+
+        // Decode base64 audio data to float array
+        byte[] audioBytes = Base64.decode(audioDataBase64, Base64.DEFAULT);
+        int numSamples = audioBytes.length / 4; // 4 bytes per float
+        float[] audioData = new float[numSamples];
+
+        for (int i = 0; i < numSamples; i++) {
+            int intBits = (audioBytes[i * 4] & 0xFF) |
+                         ((audioBytes[i * 4 + 1] & 0xFF) << 8) |
+                         ((audioBytes[i * 4 + 2] & 0xFF) << 16) |
+                         ((audioBytes[i * 4 + 3] & 0xFF) << 24);
+            audioData[i] = Float.intBitsToFloat(intBits);
+        }
+
+        return processVadDetection(audioData, numSamples, options);
+    }
+
+    public WritableArray detectSpeechFile(String filePathOrBase64, ReadableMap options) throws Exception {
+        if (vadContext == 0) {
+            throw new Exception("VAD context is null");
+        }
+
+        // Follow the same pattern as transcribeFile
+        String filePath = filePathOrBase64;
+
+        // Handle HTTP downloads
+        if (filePathOrBase64.startsWith("http://") || filePathOrBase64.startsWith("https://")) {
+            // Note: This would require access to the downloader, but for now we'll throw an error
+            throw new Exception("HTTP URLs not supported in VAD file detection. Please download the file first.");
+        }
+
+        float[] audioData;
+
+        // Check for resource identifier (bundled assets)
+        int resId = getResourceIdentifier(filePath);
+        if (resId > 0) {
+            audioData = AudioUtils.decodeWaveFile(reactContext.getResources().openRawResource(resId));
+        } else if (filePathOrBase64.startsWith("data:audio/wav;base64,")) {
+            // Handle base64 WAV data
+            audioData = AudioUtils.decodeWaveData(filePathOrBase64);
+        } else {
+            // Handle regular file path
+            audioData = AudioUtils.decodeWaveFile(new java.io.FileInputStream(new java.io.File(filePath)));
+        }
+
+        if (audioData == null) {
+            throw new Exception("Failed to load audio file: " + filePathOrBase64);
+        }
+
+        return processVadDetection(audioData, audioData.length, options);
+    }
+
+    public WritableArray detectSpeechWithAudioData(float[] audioData, ReadableMap options) throws Exception {
+        if (vadContext == 0) {
+            throw new Exception("VAD context is null");
+        }
+
+        return processVadDetection(audioData, audioData.length, options);
+    }
+
+    private int getResourceIdentifier(String filePath) {
+        int identifier = reactContext.getResources().getIdentifier(
+            filePath,
+            "drawable",
+            reactContext.getPackageName()
+        );
+        if (identifier == 0) {
+            identifier = reactContext.getResources().getIdentifier(
+                filePath,
+                "raw",
+                reactContext.getPackageName()
+            );
+        }
+        return identifier;
+    }
+
+    private WritableArray processVadDetection(float[] audioData, int numSamples, ReadableMap options) throws Exception {
+        // Run VAD detection using WhisperContext static methods
+        boolean speechDetected = WhisperContext.vadDetectSpeech(vadContext, audioData, numSamples);
+        if (!speechDetected) {
+            return Arguments.createArray();
+        }
+
+        // Set VAD parameters from options
+        float threshold = options.hasKey("threshold") ? (float) options.getDouble("threshold") : 0.5f;
+        int minSpeechDurationMs = options.hasKey("minSpeechDurationMs") ? options.getInt("minSpeechDurationMs") : 250;
+        int minSilenceDurationMs = options.hasKey("minSilenceDurationMs") ? options.getInt("minSilenceDurationMs") : 100;
+        float maxSpeechDurationS = options.hasKey("maxSpeechDurationS") ? (float) options.getDouble("maxSpeechDurationS") : 30.0f;
+        int speechPadMs = options.hasKey("speechPadMs") ? options.getInt("speechPadMs") : 30;
+        float samplesOverlap = options.hasKey("samplesOverlap") ? (float) options.getDouble("samplesOverlap") : 0.1f;
+
+        // Get segments from VAD using WhisperContext static methods
+        long segments = WhisperContext.vadGetSegmentsFromProbs(vadContext, threshold, minSpeechDurationMs,
+                                               minSilenceDurationMs, maxSpeechDurationS,
+                                               speechPadMs, samplesOverlap);
+        if (segments == 0) {
+            return Arguments.createArray();
+        }
+
+        // Convert segments to WritableArray using WhisperContext static methods
+        WritableArray result = Arguments.createArray();
+        int nSegments = WhisperContext.vadGetNSegments(segments);
+
+        for (int i = 0; i < nSegments; i++) {
+            float t0 = WhisperContext.vadGetSegmentT0(segments, i);
+            float t1 = WhisperContext.vadGetSegmentT1(segments, i);
+
+            WritableMap segment = Arguments.createMap();
+            segment.putDouble("t0", t0);
+            segment.putDouble("t1", t1);
+            result.pushMap(segment);
+        }
+
+        // Clean up using WhisperContext static methods
+        WhisperContext.vadFreeSegments(segments);
+
+        return result;
+    }
+
+    public void release() {
+        if (vadContext != 0) {
+            WhisperContext.freeVadContext(vadContext);
+            vadContext = 0;
+        }
+    }
+}

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
@@ -155,7 +196,10 @@ Java_com_rnwhisper_WhisperContext_initContext(
         JNIEnv *env, jobject thiz, jstring model_path_str) {
     UNUSED(thiz);
     struct whisper_context_params cparams;
+
+    // TODO: Expose dtw_token_timestamps and dtw_aheads_preset
     cparams.dtw_token_timestamps = false;
+    // cparams.dtw_aheads_preset = WHISPER_AHEADS_BASE;
 
     struct whisper_context *context = nullptr;
     const char *model_path_chars = env->GetStringUTFChars(model_path_str, nullptr);
@@ -173,7 +217,10 @@ Java_com_rnwhisper_WhisperContext_initContextWithAsset(
 ) {
     UNUSED(thiz);
     struct whisper_context_params cparams;
+
+    // TODO: Expose dtw_token_timestamps and dtw_aheads_preset
     cparams.dtw_token_timestamps = false;
+    // cparams.dtw_aheads_preset = WHISPER_AHEADS_BASE;
 
     struct whisper_context *context = nullptr;
     const char *model_path_chars = env->GetStringUTFChars(model_path_str, nullptr);
@@ -190,7 +237,10 @@ Java_com_rnwhisper_WhisperContext_initContextWithInputStream(
 ) {
     UNUSED(thiz);
     struct whisper_context_params cparams;
+
+    // TODO: Expose dtw_token_timestamps and dtw_aheads_preset
     cparams.dtw_token_timestamps = false;
+    // cparams.dtw_aheads_preset = WHISPER_AHEADS_BASE;
 
     struct whisper_context *context = nullptr;
     context = whisper_init_from_input_stream(env, input_stream, cparams);
@@ -521,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/cpp/coreml/whisper-compat.h

@@ -0,0 +1,10 @@
+#import <CoreML/CoreML.h>
+
+@interface MLModel (Compat)
+- (void) predictionFromFeatures:(id<MLFeatureProvider>) input
+              completionHandler:(void (^)(id<MLFeatureProvider> output, NSError * error)) completionHandler;
+
+- (void) predictionFromFeatures:(id<MLFeatureProvider>) input
+                        options:(MLPredictionOptions *) options
+              completionHandler:(void (^)(id<MLFeatureProvider> output, NSError * error)) completionHandler;
+@end

package/cpp/coreml/whisper-compat.m

@@ -0,0 +1,35 @@
+#import "whisper-compat.h"
+#import <Foundation/Foundation.h>
+
+@implementation MLModel (Compat)
+
+#if !defined(MAC_OS_X_VERSION_14_00) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_14_00
+
+- (void) predictionFromFeatures:(id<MLFeatureProvider>) input
+              completionHandler:(void (^)(id<MLFeatureProvider> output, NSError * error)) completionHandler {
+    [NSOperationQueue.new addOperationWithBlock:^{
+        NSError *error = nil;
+        id<MLFeatureProvider> prediction = [self predictionFromFeatures:input error:&error];
+
+        [NSOperationQueue.mainQueue addOperationWithBlock:^{
+            completionHandler(prediction, error);
+        }];
+    }];
+}
+
+- (void) predictionFromFeatures:(id<MLFeatureProvider>) input
+                        options:(MLPredictionOptions *) options
+              completionHandler:(void (^)(id<MLFeatureProvider> output, NSError * error)) completionHandler {
+    [NSOperationQueue.new addOperationWithBlock:^{
+        NSError *error = nil;
+        id<MLFeatureProvider> prediction = [self predictionFromFeatures:input options:options error:&error];
+
+        [NSOperationQueue.mainQueue addOperationWithBlock:^{
+            completionHandler(prediction, error);
+        }];
+    }];
+}
+
+#endif
+
+@end

package/cpp/coreml/whisper-decoder-impl.h

@@ -11,36 +11,33 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-
 /// Model Prediction Input Type
-API_AVAILABLE(macos(12.0), ios(15.0), watchos(8.0), tvos(15.0)) __attribute__((visibility("hidden")))
+API_AVAILABLE(macos(10.15), ios(13.0), watchos(6.0), tvos(13.0)) __attribute__((visibility("hidden")))
 @interface whisper_decoder_implInput : NSObject<MLFeatureProvider>
 
-/// token_data as 1 by 1 matrix of 32-bit integers
+/// token_data as 1 by 1 matrix of floats
 @property (readwrite, nonatomic, strong) MLMultiArray * token_data;
 
-/// audio_data as 1 × 384 × 1 × 1500 4-dimensional array of floats
+/// audio_data as 1 × 1500 × 384 3-dimensional array of floats
 @property (readwrite, nonatomic, strong) MLMultiArray * audio_data;
 - (instancetype)init NS_UNAVAILABLE;
 - (instancetype)initWithToken_data:(MLMultiArray *)token_data audio_data:(MLMultiArray *)audio_data NS_DESIGNATED_INITIALIZER;
 
 @end
 
-
 /// Model Prediction Output Type
-API_AVAILABLE(macos(12.0), ios(15.0), watchos(8.0), tvos(15.0)) __attribute__((visibility("hidden")))
+API_AVAILABLE(macos(10.15), ios(13.0), watchos(6.0), tvos(13.0)) __attribute__((visibility("hidden")))
 @interface whisper_decoder_implOutput : NSObject<MLFeatureProvider>
 
-/// var_1346 as multidimensional array of floats
-@property (readwrite, nonatomic, strong) MLMultiArray * var_1346;
+/// cast_76 as multidimensional array of floats
+@property (readwrite, nonatomic, strong) MLMultiArray * cast_76;
 - (instancetype)init NS_UNAVAILABLE;
-- (instancetype)initWithVar_1346:(MLMultiArray *)var_1346 NS_DESIGNATED_INITIALIZER;
+- (instancetype)initWithCast_76:(MLMultiArray *)cast_76 NS_DESIGNATED_INITIALIZER;
 
 @end
 
-
 /// Class for model loading and prediction
-API_AVAILABLE(macos(12.0), ios(15.0), watchos(8.0), tvos(15.0)) __attribute__((visibility("hidden")))
+API_AVAILABLE(macos(10.15), ios(13.0), watchos(6.0), tvos(13.0)) __attribute__((visibility("hidden")))
 @interface whisper_decoder_impl : NSObject
 @property (readonly, nonatomic, nullable) MLModel * model;
 
@@ -94,7 +91,7 @@ API_AVAILABLE(macos(12.0), ios(15.0), watchos(8.0), tvos(15.0)) __attribute__((v
     @param configuration The model configuration
     @param handler When the model load completes successfully or unsuccessfully, the completion handler is invoked with a valid whisper_decoder_impl instance or NSError object.
 */
-+ (void)loadWithConfiguration:(MLModelConfiguration *)configuration completionHandler:(void (^)(whisper_decoder_impl * _Nullable model, NSError * _Nullable error))handler;
++ (void)loadWithConfiguration:(MLModelConfiguration *)configuration completionHandler:(void (^)(whisper_decoder_impl * _Nullable model, NSError * _Nullable error))handler API_AVAILABLE(macos(11.0), ios(14.0), watchos(7.0), tvos(14.0)) __attribute__((visibility("hidden")));
 
 /**
     Construct whisper_decoder_impl instance asynchronously with URL of .mlmodelc directory and optional configuration.
@@ -105,7 +102,7 @@ API_AVAILABLE(macos(12.0), ios(15.0), watchos(8.0), tvos(15.0)) __attribute__((v
     @param configuration The model configuration
     @param handler When the model load completes successfully or unsuccessfully, the completion handler is invoked with a valid whisper_decoder_impl instance or NSError object.
 */
-+ (void)loadContentsOfURL:(NSURL *)modelURL configuration:(MLModelConfiguration *)configuration completionHandler:(void (^)(whisper_decoder_impl * _Nullable model, NSError * _Nullable error))handler;
++ (void)loadContentsOfURL:(NSURL *)modelURL configuration:(MLModelConfiguration *)configuration completionHandler:(void (^)(whisper_decoder_impl * _Nullable model, NSError * _Nullable error))handler API_AVAILABLE(macos(11.0), ios(14.0), watchos(7.0), tvos(14.0)) __attribute__((visibility("hidden")));
 
 /**
     Make a prediction using the standard interface
@@ -124,10 +121,25 @@ API_AVAILABLE(macos(12.0), ios(15.0), watchos(8.0), tvos(15.0)) __attribute__((v
 */
 - (nullable whisper_decoder_implOutput *)predictionFromFeatures:(whisper_decoder_implInput *)input options:(MLPredictionOptions *)options error:(NSError * _Nullable __autoreleasing * _Nullable)error;
 
+/**
+    Make an asynchronous prediction using the standard interface
+    @param input an instance of whisper_decoder_implInput to predict from
+    @param completionHandler a block that will be called upon completion of the prediction. error will be nil if no error occurred.
+*/
+- (void)predictionFromFeatures:(whisper_decoder_implInput *)input completionHandler:(void (^)(whisper_decoder_implOutput * _Nullable output, NSError * _Nullable error))completionHandler API_AVAILABLE(macos(14.0), ios(17.0), watchos(10.0), tvos(17.0)) __attribute__((visibility("hidden")));
+
+/**
+    Make an asynchronous prediction using the standard interface
+    @param input an instance of whisper_decoder_implInput to predict from
+    @param options prediction options
+    @param completionHandler a block that will be called upon completion of the prediction. error will be nil if no error occurred.
+*/
+- (void)predictionFromFeatures:(whisper_decoder_implInput *)input options:(MLPredictionOptions *)options completionHandler:(void (^)(whisper_decoder_implOutput * _Nullable output, NSError * _Nullable error))completionHandler API_AVAILABLE(macos(14.0), ios(17.0), watchos(10.0), tvos(17.0)) __attribute__((visibility("hidden")));
+
 /**
     Make a prediction using the convenience interface
-    @param token_data as 1 by 1 matrix of 32-bit integers:
-    @param audio_data as 1 × 384 × 1 × 1500 4-dimensional array of floats:
+    @param token_data 1 by 1 matrix of floats
+    @param audio_data 1 × 1500 × 384 3-dimensional array of floats
     @param error If an error occurs, upon return contains an NSError object that describes the problem. If you are not interested in possible errors, pass in NULL.
     @return the prediction as whisper_decoder_implOutput
 */