whisper.rn 0.4.2 → 0.5.0-rc.0

package/cpp/jsi/RNWhisperJSI.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+#include <vector>
+#include <atomic>
+#include <ReactCommon/CallInvoker.h>
+
+#if defined(__ANDROID__)
+#include <android/log.h>
+#include "whisper.h"
+#include "rn-whisper.h"
+#endif
+
+#if defined(__APPLE__)
+#if RNWHISPER_BUILD_FROM_SOURCE
+#include "whisper.h"
+#include "rn-whisper.h"
+#else
+#include <rnwhisper/whisper.h>
+#include <rnwhisper/rn-whisper.h>
+#endif
+#endif
+
+namespace rnwhisper_jsi {
+
+// Context management functions
+void addContext(int contextId, long contextPtr);
+void removeContext(int contextId);
+void addVadContext(int contextId, long vadContextPtr);
+void removeVadContext(int contextId);
+
+// Main JSI installation function
+void installJSIBindings(
+    facebook::jsi::Runtime& runtime,
+    std::shared_ptr<facebook::react::CallInvoker> callInvoker
+);
+
+// Cleanup function to dispose of ThreadPool
+void cleanupJSIBindings();
+
+} // namespace rnwhisper_jsi

package/cpp/jsi/ThreadPool.h

@@ -0,0 +1,100 @@
+// From https://github.com/progschj/ThreadPool
+
+#ifndef THREAD_POOL_H
+#define THREAD_POOL_H
+
+#include <vector>
+#include <queue>
+#include <memory>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <future>
+#include <functional>
+#include <stdexcept>
+
+class ThreadPool {
+public:
+    ThreadPool(size_t);
+    template<class F, class... Args>
+    auto enqueue(F&& f, Args&&... args)
+        -> std::future<typename std::result_of<F(Args...)>::type>;
+    ~ThreadPool();
+private:
+    // need to keep track of threads so we can join them
+    std::vector< std::thread > workers;
+    // the task queue
+    std::queue< std::function<void()> > tasks;
+
+    // synchronization
+    std::mutex queue_mutex;
+    std::condition_variable condition;
+    bool stop;
+};
+
+// the constructor just launches some amount of workers
+inline ThreadPool::ThreadPool(size_t threads)
+    :   stop(false)
+{
+    for(size_t i = 0;i<threads;++i)
+        workers.emplace_back(
+            [this]
+            {
+                for(;;)
+                {
+                    std::function<void()> task;
+
+                    {
+                        std::unique_lock<std::mutex> lock(this->queue_mutex);
+                        this->condition.wait(lock,
+                            [this]{ return this->stop || !this->tasks.empty(); });
+                        if(this->stop && this->tasks.empty())
+                            return;
+                        task = std::move(this->tasks.front());
+                        this->tasks.pop();
+                    }
+
+                    task();
+                }
+            }
+        );
+}
+
+// add new work item to the pool
+template<class F, class... Args>
+auto ThreadPool::enqueue(F&& f, Args&&... args)
+    -> std::future<typename std::result_of<F(Args...)>::type>
+{
+    using return_type = typename std::result_of<F(Args...)>::type;
+
+    auto task = std::make_shared< std::packaged_task<return_type()> >(
+            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
+        );
+
+    std::future<return_type> res = task->get_future();
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex);
+
+        // don't allow enqueueing after stopping the pool
+        if(stop)
+            throw std::runtime_error("enqueue on stopped ThreadPool");
+
+        tasks.emplace([task](){ (*task)(); });
+    }
+    condition.notify_one();
+    return res;
+}
+
+// the destructor joins all threads
+inline ThreadPool::~ThreadPool()
+{
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex);
+        stop = true;
+    }
+    condition.notify_all();
+    for(std::thread &worker: workers)
+        worker.join();
+}
+
+#endif

package/cpp/whisper.cpp

@@ -8942,6 +8942,10 @@ void whisper_log_set(wsp_ggml_log_callback log_callback, void * user_data) {
     wsp_ggml_log_set(g_state.log_callback, g_state.log_callback_user_data);
 }
 
+const char * whisper_version(void) {
+    return "1.7.6";
+}
+
 WSP_GGML_ATTRIBUTE_FORMAT(2, 3)
 static void whisper_log_internal(wsp_ggml_log_level level, const char * format, ...) {
     va_list args;

package/cpp/whisper.h

@@ -199,6 +199,8 @@ extern "C" {
         float samples_overlap;         // Overlap in seconds when copying audio samples from speech segment.
     } whisper_vad_params;
 
+    WHISPER_API const char * whisper_version(void);
+
     // Various functions for loading a ggml whisper model.
     // Allocate (almost) all memory needed for the model.
     // Return NULL on failure

package/ios/RNWhisper.h

@@ -8,8 +8,11 @@
 #endif
 #endif
 
+#import <Foundation/Foundation.h>
 #import <React/RCTBridgeModule.h>
+#import <React/RCTBridge+Private.h>
 #import <React/RCTEventEmitter.h>
+#import <ReactCommon/RCTTurboModule.h>
 
 @interface RNWhisper : RCTEventEmitter <RCTBridgeModule>
 

package/ios/RNWhisper.mm

@@ -4,6 +4,7 @@
 #import "RNWhisperDownloader.h"
 #import "RNWhisperAudioUtils.h"
 #import "RNWhisperAudioSessionUtils.h"
+#import "RNWhisperJSI.h"
 #include <stdlib.h>
 #include <string>
 
@@ -90,6 +91,8 @@ RCT_REMAP_METHOD(initContext,
     }
 
     [contexts setObject:context forKey:[NSNumber numberWithInt:contextId]];
+    // Also add to unified context management - store raw context pointer like Android
+    rnwhisper_jsi::addContext(contextId, reinterpret_cast<long>([context getContext]));
 
     resolve(@{
         @"contextId": @(contextId),
@@ -345,6 +348,8 @@ RCT_REMAP_METHOD(releaseContext,
     }
     [context invalidate];
     [contexts removeObjectForKey:[NSNumber numberWithInt:contextId]];
+    // Also remove from unified context management
+    rnwhisper_jsi::removeContext(contextId);
     resolve(nil);
 }
 
@@ -352,39 +357,10 @@ RCT_REMAP_METHOD(releaseAllContexts,
                  withResolver:(RCTPromiseResolveBlock)resolve
                  withRejecter:(RCTPromiseRejectBlock)reject)
 {
-    [self invalidate];
+    [self releaseAllContexts];
     resolve(nil);
 }
 
-- (void)invalidate {
-    [super invalidate];
-
-    if (contexts == nil) {
-        return;
-    }
-
-    for (NSNumber *contextId in contexts) {
-        RNWhisperContext *context = contexts[contextId];
-        [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];
-    contexts = nil;
-
-    [RNWhisperDownloader clearCache];
-}
-
 // MARK: - AudioSessionUtils
 
 RCT_EXPORT_METHOD(getAudioSessionCurrentCategory:(RCTPromiseResolveBlock)resolve
@@ -484,6 +460,8 @@ RCT_REMAP_METHOD(initVadContext,
     }
 
     [vadContexts setObject:vadContext forKey:[NSNumber numberWithInt:contextId]];
+    // Also add to unified context management - store raw VAD context pointer like Android
+    rnwhisper_jsi::addVadContext(contextId, reinterpret_cast<long>([vadContext getVadContext]));
 
     resolve(@{
         @"contextId": @(contextId),
@@ -568,20 +546,77 @@ RCT_REMAP_METHOD(releaseVadContext,
     }
     [vadContext invalidate];
     [vadContexts removeObjectForKey:[NSNumber numberWithInt:contextId]];
+    // Also remove from unified context management
+    rnwhisper_jsi::removeVadContext(contextId);
     resolve(nil);
 }
 
 RCT_EXPORT_METHOD(releaseAllVadContexts:(RCTPromiseResolveBlock)resolve
                  withRejecter:(RCTPromiseRejectBlock)reject)
 {
+    [self releaseAllVadContexts];
+    resolve(nil);
+}
+
+- (void)releaseAllContexts {
+    rnwhisper::job_abort_all(); // graceful abort
+    if (contexts != nil) {
+        for (NSNumber *contextId in contexts) {
+            RNWhisperContext *context = contexts[contextId];
+            [context invalidate];
+        }
+        [contexts removeAllObjects];
+        contexts = nil;
+    }
+}
+
+- (void)releaseAllVadContexts {
     if (vadContexts != nil) {
         for (NSNumber *contextId in vadContexts) {
             RNWhisperVadContext *vadContext = vadContexts[contextId];
             [vadContext invalidate];
         }
         [vadContexts removeAllObjects];
+        vadContexts = nil;
     }
-    resolve(nil);
+}
+
+RCT_EXPORT_METHOD(installJSIBindings:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+{
+    RCTBridge *bridge = [RCTBridge currentBridge];
+    if (bridge == nil) {
+        reject(@"whisper_jsi_error", @"Bridge not available", nil);
+        return;
+    }
+
+    RCTCxxBridge *cxxBridge = (RCTCxxBridge *)bridge;
+    auto callInvoker = bridge.jsCallInvoker;
+    if (cxxBridge.runtime) {
+        facebook::jsi::Runtime *runtime = static_cast<facebook::jsi::Runtime *>(cxxBridge.runtime);
+
+        if (callInvoker) {
+          callInvoker->invokeAsync([runtime, callInvoker]() {
+            rnwhisper_jsi::installJSIBindings(*runtime, callInvoker);
+          });
+        } else {
+          reject(@"whisper_jsi_error", @"CallInvoker not available", nil);
+          return;
+        }
+
+        resolve(@{});
+    } else {
+        reject(@"whisper_jsi_error", @"Runtime not available", nil);
+    }
+}
+
+- (void)invalidate {
+    [super invalidate];
+
+    [self releaseAllContexts];
+    [self releaseAllVadContexts];
+
+    [RNWhisperDownloader clearCache];
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED

package/ios/rnwhisper.xcframework/ios-arm64/rnwhisper.framework/Headers/ggml-backend.h

@@ -339,7 +339,7 @@ extern "C" {
     typedef bool (*wsp_ggml_backend_eval_callback)(int node_index, struct wsp_ggml_tensor * t1, struct wsp_ggml_tensor * t2, void * user_data);
 
     // Compare the output of two backends
-    WSP_GGML_API bool wsp_ggml_backend_compare_graph_backend(wsp_ggml_backend_t backend1, wsp_ggml_backend_t backend2, struct wsp_ggml_cgraph * graph, wsp_ggml_backend_eval_callback callback, void * user_data);
+    WSP_GGML_API bool wsp_ggml_backend_compare_graph_backend(wsp_ggml_backend_t backend1, wsp_ggml_backend_t backend2, struct wsp_ggml_cgraph * graph, wsp_ggml_backend_eval_callback callback, void * user_data, struct wsp_ggml_tensor * test_node);
 
     // Tensor initialization
     WSP_GGML_API enum wsp_ggml_status wsp_ggml_backend_tensor_alloc(wsp_ggml_backend_buffer_t buffer, struct wsp_ggml_tensor * tensor, void * addr);

package/ios/rnwhisper.xcframework/ios-arm64/rnwhisper.framework/Headers/ggml-cpu.h

@@ -101,6 +101,7 @@ extern "C" {
     WSP_GGML_BACKEND_API int wsp_ggml_cpu_has_riscv_v    (void);
     WSP_GGML_BACKEND_API int wsp_ggml_cpu_has_vsx        (void);
     WSP_GGML_BACKEND_API int wsp_ggml_cpu_has_vxe        (void);
+    WSP_GGML_BACKEND_API int wsp_ggml_cpu_has_nnpa       (void);
     WSP_GGML_BACKEND_API int wsp_ggml_cpu_has_wasm_simd  (void);
     WSP_GGML_BACKEND_API int wsp_ggml_cpu_has_llamafile  (void);
 
@@ -133,6 +134,7 @@ extern "C" {
 
     WSP_GGML_BACKEND_API wsp_ggml_backend_reg_t wsp_ggml_backend_cpu_reg(void);
 
+    WSP_GGML_BACKEND_API void wsp_ggml_cpu_fp32_to_fp32(const float *,       float *, int64_t);
     WSP_GGML_BACKEND_API void wsp_ggml_cpu_fp32_to_fp16(const float *, wsp_ggml_fp16_t *, int64_t);
     WSP_GGML_BACKEND_API void wsp_ggml_cpu_fp16_to_fp32(const wsp_ggml_fp16_t *, float *, int64_t);
     WSP_GGML_BACKEND_API void wsp_ggml_cpu_fp32_to_bf16(const float *, wsp_ggml_bf16_t *, int64_t);