whisper.rn 0.4.0-rc.9 → 0.4.1

package/README.md

@@ -25,6 +25,8 @@ npm install whisper.rn
 
 Please re-run `npx pod-install` again.
 
+By default, `whisper.rn` will use pre-built `rnwhisper.xcframework` for iOS. If you want to build from source, please set `RNWHISPER_BUILD_FROM_SOURCE` to `1` in your Podfile.
+
 If you want to use `medium` or `large` model, the [Extended Virtual Addressing](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_developer_kernel_extended-virtual-addressing) capability is recommended to enable on iOS project.
 
 #### Android
@@ -36,7 +38,9 @@ Add proguard rule if it's enabled in project (android/app/proguard-rules.pro):
 -keep class com.rnwhisper.** { *; }
 ```
 
-For build, it's recommended to use `ndkVersion = "24.0.8215888"` (or above) in your root project build configuration for Apple Silicon Macs. Otherwise please follow this trobleshooting [issue](./TROUBLESHOOTING.md#android-got-build-error-unknown-host-cpu-architecture-arm64-on-apple-silicon-macs).
+By default, `whisper.rn` will use pre-built libraries for Android. If you want to build from source, please set `rnwhisperBuildFromSource` to `true` in `android/gradle.properties`.
+
+For build from source, it's recommended to use `ndkVersion = "24.0.8215888"` (or above) in your root project build configuration for Apple Silicon Macs. Otherwise please follow this trobleshooting [issue](./TROUBLESHOOTING.md#android-got-build-error-unknown-host-cpu-architecture-arm64-on-apple-silicon-macs).
 
 #### Expo
 
@@ -99,6 +103,75 @@ subscribe(evt => {
 })
 ```
 
+## Voice Activity Detection (VAD)
+
+Voice Activity Detection allows you to detect speech segments in audio data using the Silero VAD model.
+
+#### Initialize VAD Context
+
+```typescript
+import { initWhisperVad } from 'whisper.rn'
+
+const vadContext = await initWhisperVad({
+  filePath: require('./assets/ggml-silero-v5.1.2.bin'), // VAD model file
+  useGpu: true, // Use GPU acceleration (iOS only)
+  nThreads: 4, // Number of threads for processing
+})
+```
+
+#### Detect Speech Segments
+
+##### From Audio Files
+
+```typescript
+// Detect speech in audio file (supports same formats as transcribe)
+const segments = await vadContext.detectSpeech(require('./assets/audio.wav'), {
+  threshold: 0.5, // Speech probability threshold (0.0-1.0)
+  minSpeechDurationMs: 250, // Minimum speech duration in ms
+  minSilenceDurationMs: 100, // Minimum silence duration in ms
+  maxSpeechDurationS: 30, // Maximum speech duration in seconds
+  speechPadMs: 30, // Padding around speech segments in ms
+  samplesOverlap: 0.1, // Overlap between analysis windows
+})
+
+// Also supports:
+// - File paths: vadContext.detectSpeech('path/to/audio.wav', options)
+// - HTTP URLs: vadContext.detectSpeech('https://example.com/audio.wav', options)
+// - Base64 WAV: vadContext.detectSpeech('data:audio/wav;base64,...', options)
+// - Assets: vadContext.detectSpeech(require('./assets/audio.wav'), options)
+```
+
+##### From Raw Audio Data
+
+```typescript
+// Detect speech in base64 encoded float32 PCM data
+const segments = await vadContext.detectSpeechData(base64AudioData, {
+  threshold: 0.5,
+  minSpeechDurationMs: 250,
+  minSilenceDurationMs: 100,
+  maxSpeechDurationS: 30,
+  speechPadMs: 30,
+  samplesOverlap: 0.1,
+})
+```
+
+#### Process Results
+
+```typescript
+segments.forEach((segment, index) => {
+  console.log(`Segment ${index + 1}: ${segment.t0.toFixed(2)}s - ${segment.t1.toFixed(2)}s`)
+  console.log(`Duration: ${(segment.t1 - segment.t0).toFixed(2)}s`)
+})
+```
+
+#### Release VAD Context
+
+```typescript
+await vadContext.release()
+// Or release all VAD contexts
+await releaseAllWhisperVad()
+```
+
 In iOS, You may need to change the Audio Session so that it can be used with other audio playback, or to optimize the quality of the recording. So we have provided AudioSession utilities for you:
 
 Option 1 - Use options in transcribeRealtime:

package/android/build.gradle

@@ -53,9 +53,18 @@ android {
       }
     }
   }
-  externalNativeBuild {
-    cmake {
-      path = file('src/main/CMakeLists.txt')
+  def rnwhisperBuildFromSource = project.properties["rnwhisperBuildFromSource"]
+  if (rnwhisperBuildFromSource == "true") {
+    externalNativeBuild {
+      cmake {
+        path = file('src/main/CMakeLists.txt')
+      }
+    }
+    // Exclude jniLibs
+    sourceSets {
+      main {
+        jniLibs.srcDirs = []
+      }
     }
   }
   buildTypes {

package/android/src/main/CMakeLists.txt

@@ -2,16 +2,35 @@ cmake_minimum_required(VERSION 3.10)
 
 project(whisper.rn)
 
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 set(RNWHISPER_LIB_DIR ${CMAKE_SOURCE_DIR}/../../../cpp)
 
+include_directories(
+    ${RNWHISPER_LIB_DIR}
+    ${RNWHISPER_LIB_DIR}/ggml-cpu
+)
+
 set(
     SOURCE_FILES
     ${RNWHISPER_LIB_DIR}/ggml.c
     ${RNWHISPER_LIB_DIR}/ggml-alloc.c
     ${RNWHISPER_LIB_DIR}/ggml-backend.cpp
+    ${RNWHISPER_LIB_DIR}/ggml-backend-reg.cpp
+    ${RNWHISPER_LIB_DIR}/ggml-cpu/amx/amx.cpp
+    ${RNWHISPER_LIB_DIR}/ggml-cpu/amx/mmq.cpp
+    ${RNWHISPER_LIB_DIR}/ggml-cpu/ggml-cpu.c
+    ${RNWHISPER_LIB_DIR}/ggml-cpu/ggml-cpu.cpp
+    ${RNWHISPER_LIB_DIR}/ggml-cpu/quants.c
+    ${RNWHISPER_LIB_DIR}/ggml-cpu/traits.cpp
+    ${RNWHISPER_LIB_DIR}/ggml-cpu/repack.cpp
+    ${RNWHISPER_LIB_DIR}/ggml-cpu/unary-ops.cpp
+    ${RNWHISPER_LIB_DIR}/ggml-cpu/binary-ops.cpp
+    ${RNWHISPER_LIB_DIR}/ggml-cpu/vec.cpp
+    ${RNWHISPER_LIB_DIR}/ggml-cpu/ops.cpp
+    ${RNWHISPER_LIB_DIR}/ggml-opt.cpp
+    ${RNWHISPER_LIB_DIR}/ggml-threading.cpp
     ${RNWHISPER_LIB_DIR}/ggml-quants.c
-    ${RNWHISPER_LIB_DIR}/ggml-aarch64.c
+    ${RNWHISPER_LIB_DIR}/gguf.cpp
     ${RNWHISPER_LIB_DIR}/whisper.cpp
     ${RNWHISPER_LIB_DIR}/rn-audioutils.cpp
     ${RNWHISPER_LIB_DIR}/rn-whisper.cpp
@@ -20,45 +39,56 @@ set(
 
 find_library(LOG_LIB log)
 
-function(build_library target_name)
+function(build_library target_name arch cpu_flags)
+    if (NOT ${arch} STREQUAL "generic")
+        set(SOURCE_FILES_ARCH
+            ${RNWHISPER_LIB_DIR}/ggml-cpu/arch/${arch}/quants.c
+            ${RNWHISPER_LIB_DIR}/ggml-cpu/arch/${arch}/repack.cpp
+        )
+    endif ()
+
     add_library(
         ${target_name}
         SHARED
         ${SOURCE_FILES}
+        ${SOURCE_FILES_ARCH}
     )
 
     target_link_libraries(${target_name} ${LOG_LIB} android)
 
-    if (${target_name} STREQUAL "whisper_v8fp16_va")
-        target_compile_options(${target_name} PRIVATE -march=armv8.2-a+fp16)
-    elseif (${target_name} STREQUAL "whisper_vfpv4")
-        target_compile_options(${target_name} PRIVATE -mfpu=neon-vfpv4)
+    if (${arch} STREQUAL "generic")
+        target_compile_options(${target_name} PRIVATE -DWSP_GGML_CPU_GENERIC)
     endif ()
 
+    target_compile_options(${target_name} PRIVATE -DWSP_GGML_USE_CPU -DWSP_GGML_USE_CPU_REPACK -pthread ${cpu_flags})
+
     if (${CMAKE_BUILD_TYPE} STREQUAL "Debug")
         target_compile_options(${target_name} PRIVATE -DRNWHISPER_ANDROID_ENABLE_LOGGING)
     endif ()
 
     # NOTE: If you want to debug the native code, you can uncomment if and endif
+    # Note that it will be extremely slow
     # if (NOT ${CMAKE_BUILD_TYPE} STREQUAL "Debug")
-
-        target_compile_options(${target_name} PRIVATE -O3 -DNDEBUG -pthread)
+        target_compile_options(${target_name} PRIVATE -O3 -DNDEBUG)
         target_compile_options(${target_name} PRIVATE -fvisibility=hidden -fvisibility-inlines-hidden)
         target_compile_options(${target_name} PRIVATE -ffunction-sections -fdata-sections)
 
         target_link_options(${target_name} PRIVATE -Wl,--gc-sections)
         target_link_options(${target_name} PRIVATE -Wl,--exclude-libs,ALL)
         target_link_options(${target_name} PRIVATE -flto)
-
     # endif ()
 endfunction()
 
-build_library("whisper") # Default target
+build_library("rnwhisper" "generic" "")
 
 if (${ANDROID_ABI} STREQUAL "arm64-v8a")
-    build_library("whisper_v8fp16_va")
+    build_library("rnwhisper_v8fp16_va_2" "arm" "-march=armv8.2-a+fp16")
 elseif (${ANDROID_ABI} STREQUAL "armeabi-v7a")
-    build_library("whisper_vfpv4")
+    build_library("rnwhisper_vfpv4" "arm" "-mfpu=neon-vfpv4")
+elseif (${ANDROID_ABI} STREQUAL "x86_64")
+    # x86_64 target
+    build_library("rnwhisper_x86_64" "x86" "-march=x86-64" "-mtune=intel" "-msse4.2" "-mpopcnt")
 endif ()
 
+
 include_directories(${RNWHISPER_LIB_DIR})

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

@@ -13,6 +13,7 @@ import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.Arguments;
 
 import java.util.HashMap;
@@ -47,6 +48,7 @@ public class RNWhisper implements LifecycleEventListener {
   private HashMap<AsyncTask, String> tasks = new HashMap<>();
 
   private HashMap<Integer, WhisperContext> contexts = new HashMap<>();
+  private HashMap<Integer, WhisperVadContext> vadContexts = new HashMap<>();
 
   private int getResourceIdentifier(String filePath) {
     int identifier = reactContext.getResources().getIdentifier(
@@ -344,6 +346,211 @@ public class RNWhisper implements LifecycleEventListener {
     tasks.put(task, "releaseAllContexts");
   }
 
+  public void initVadContext(final ReadableMap options, final Promise promise) {
+    AsyncTask task = new AsyncTask<Void, Void, Integer>() {
+      private Exception exception;
+
+      @Override
+      protected Integer doInBackground(Void... voids) {
+        try {
+          String modelPath = options.getString("filePath");
+          boolean isBundleAsset = options.getBoolean("isBundleAsset");
+
+          String modelFilePath = modelPath;
+          if (!isBundleAsset && (modelPath.startsWith("http://") || modelPath.startsWith("https://"))) {
+            modelFilePath = downloader.downloadFile(modelPath);
+          }
+
+          long vadContext;
+          int resId = getResourceIdentifier(modelFilePath);
+          if (resId > 0) {
+            vadContext = WhisperContext.initVadContextWithInputStream(
+              new PushbackInputStream(reactContext.getResources().openRawResource(resId))
+            );
+          } else if (isBundleAsset) {
+            vadContext = WhisperContext.initVadContextWithAsset(reactContext.getAssets(), modelFilePath);
+          } else {
+            vadContext = WhisperContext.initVadContext(modelFilePath);
+          }
+          if (vadContext == 0) {
+            throw new Exception("Failed to initialize VAD context");
+          }
+          int id = Math.abs(new Random().nextInt());
+          WhisperVadContext whisperVadContext = new WhisperVadContext(id, reactContext, vadContext);
+          vadContexts.put(id, whisperVadContext);
+          return id;
+        } catch (Exception e) {
+          exception = e;
+          return null;
+        }
+      }
+
+      @Override
+      protected void onPostExecute(Integer id) {
+        if (exception != null) {
+          promise.reject(exception);
+          return;
+        }
+        WritableMap result = Arguments.createMap();
+        result.putInt("contextId", id);
+        result.putBoolean("gpu", false);
+        result.putString("reasonNoGPU", "Currently not supported");
+        promise.resolve(result);
+        tasks.remove(this);
+      }
+    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    tasks.put(task, "initVadContext");
+  }
+
+  public void vadDetectSpeech(double id, String audioDataBase64, ReadableMap options, Promise promise) {
+    final WhisperVadContext vadContext = vadContexts.get((int) id);
+    if (vadContext == null) {
+      promise.reject("VAD context not found");
+      return;
+    }
+
+    AsyncTask task = new AsyncTask<Void, Void, WritableArray>() {
+      private Exception exception;
+
+      @Override
+      protected WritableArray doInBackground(Void... voids) {
+        try {
+          return vadContext.detectSpeech(audioDataBase64, options);
+        } catch (Exception e) {
+          exception = e;
+          return null;
+        }
+      }
+
+      @Override
+      protected void onPostExecute(WritableArray segments) {
+        if (exception != null) {
+          promise.reject(exception);
+          return;
+        }
+        promise.resolve(segments);
+        tasks.remove(this);
+      }
+    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    tasks.put(task, "vadDetectSpeech-" + id);
+  }
+
+  public void vadDetectSpeechFile(double id, String filePathOrBase64, ReadableMap options, Promise promise) {
+    final WhisperVadContext vadContext = vadContexts.get((int) id);
+    if (vadContext == null) {
+      promise.reject("VAD context not found");
+      return;
+    }
+
+    AsyncTask task = new AsyncTask<Void, Void, WritableArray>() {
+      private Exception exception;
+
+      @Override
+      protected WritableArray doInBackground(Void... voids) {
+        try {
+          // Handle file processing like transcribeFile does
+          String filePath = filePathOrBase64;
+          if (filePathOrBase64.startsWith("http://") || filePathOrBase64.startsWith("https://")) {
+            filePath = downloader.downloadFile(filePathOrBase64);
+          }
+
+          float[] audioData;
+          int resId = getResourceIdentifier(filePath);
+          if (resId > 0) {
+            audioData = AudioUtils.decodeWaveFile(reactContext.getResources().openRawResource(resId));
+          } else if (filePathOrBase64.startsWith("data:audio/wav;base64,")) {
+            audioData = AudioUtils.decodeWaveData(filePathOrBase64);
+          } else {
+            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 vadContext.detectSpeechWithAudioData(audioData, options);
+        } catch (Exception e) {
+          exception = e;
+          return null;
+        }
+      }
+
+      @Override
+      protected void onPostExecute(WritableArray segments) {
+        if (exception != null) {
+          promise.reject(exception);
+          return;
+        }
+        promise.resolve(segments);
+        tasks.remove(this);
+      }
+    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    tasks.put(task, "vadDetectSpeechFile-" + id);
+  }
+
+  public void releaseVadContext(double id, Promise promise) {
+    final int contextId = (int) id;
+    AsyncTask task = new AsyncTask<Void, Void, Void>() {
+      private Exception exception;
+
+      @Override
+      protected Void doInBackground(Void... voids) {
+        try {
+          WhisperVadContext vadContext = vadContexts.get(contextId);
+          if (vadContext == null) {
+            throw new Exception("VAD context " + id + " not found");
+          }
+          vadContext.release();
+          vadContexts.remove(contextId);
+        } catch (Exception e) {
+          exception = e;
+        }
+        return null;
+      }
+
+      @Override
+      protected void onPostExecute(Void result) {
+        if (exception != null) {
+          promise.reject(exception);
+          return;
+        }
+        promise.resolve(null);
+        tasks.remove(this);
+      }
+    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    tasks.put(task, "releaseVadContext-" + id);
+  }
+
+  public void releaseAllVadContexts(Promise promise) {
+    AsyncTask task = new AsyncTask<Void, Void, Void>() {
+      private Exception exception;
+
+      @Override
+      protected Void doInBackground(Void... voids) {
+        try {
+          for (WhisperVadContext vadContext : vadContexts.values()) {
+            vadContext.release();
+          }
+          vadContexts.clear();
+        } catch (Exception e) {
+          exception = e;
+        }
+        return null;
+      }
+
+      @Override
+      protected void onPostExecute(Void result) {
+        if (exception != null) {
+          promise.reject(exception);
+          return;
+        }
+        promise.resolve(null);
+        tasks.remove(this);
+      }
+    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    tasks.put(task, "releaseAllVadContexts");
+  }
+
   @Override
   public void onHostResume() {
   }
@@ -367,8 +574,12 @@ public class RNWhisper implements LifecycleEventListener {
     for (WhisperContext context : contexts.values()) {
       context.release();
     }
+    for (WhisperVadContext vadContext : vadContexts.values()) {
+      vadContext.release();
+    }
     WhisperContext.abortAllTranscribe(); // graceful abort
     contexts.clear();
+    vadContexts.clear();
     downloader.clearCache();
   }
 }

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

@@ -27,6 +27,8 @@ import java.io.PushbackInputStream;
 public class WhisperContext {
   public static final String NAME = "RNWhisperContext";
 
+  private static String loadedLibrary = "";
+
   private static final int SAMPLE_RATE = 16000;
   private static final int CHANNEL_CONFIG = AudioFormat.CHANNEL_IN_MONO;
   private static final int AUDIO_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
@@ -433,67 +435,67 @@ public class WhisperContext {
 
   static {
     Log.d(NAME, "Primary ABI: " + Build.SUPPORTED_ABIS[0]);
-    boolean loadVfpv4 = false;
-    boolean loadV8fp16 = false;
-    if (isArmeabiV7a()) {
-      // armeabi-v7a needs runtime detection support
-      String cpuInfo = cpuInfo();
-      if (cpuInfo != null) {
-        Log.d(NAME, "CPU info: " + cpuInfo);
-        if (cpuInfo.contains("vfpv4")) {
-          Log.d(NAME, "CPU supports vfpv4");
-          loadVfpv4 = true;
-        }
-      }
-    } else if (isArmeabiV8a()) {
-      // ARMv8.2a needs runtime detection support
-      String cpuInfo = cpuInfo();
-      if (cpuInfo != null) {
-        Log.d(NAME, "CPU info: " + cpuInfo);
-        if (cpuInfo.contains("fphp")) {
-          Log.d(NAME, "CPU supports fp16 arithmetic");
-          loadV8fp16 = true;
-        }
-      }
-    }
 
-    if (loadVfpv4) {
-      Log.d(NAME, "Loading libwhisper_vfpv4.so");
-      System.loadLibrary("whisper_vfpv4");
-    } else if (loadV8fp16) {
-      Log.d(NAME, "Loading libwhisper_v8fp16_va.so");
-      System.loadLibrary("whisper_v8fp16_va");
+    String cpuFeatures = WhisperContext.getCpuFeatures();
+    Log.d(NAME, "CPU features: " + cpuFeatures);
+    boolean hasFp16 = cpuFeatures.contains("fp16") || cpuFeatures.contains("fphp");
+    Log.d(NAME, "- hasFp16: " + hasFp16);
+
+    if (WhisperContext.isArm64V8a()) {
+      if (hasFp16) {
+        Log.d(NAME, "Loading librnwhisper_v8fp16_va_2.so");
+        System.loadLibrary("rnwhisper_v8fp16_va_2");
+        loadedLibrary = "rnwhisper_v8fp16_va_2";
+      }
+    } else if (WhisperContext.isArmeabiV7a()) {
+      Log.d(NAME, "Loading librnwhisper_vfpv4.so");
+      System.loadLibrary("rnwhisper_vfpv4");
+      loadedLibrary = "rnwhisper_vfpv4";
+    } else if (WhisperContext.isX86_64()) {
+      Log.d(NAME, "Loading librnwhisper_x86_64.so");
+      System.loadLibrary("rnwhisper_x86_64");
+      loadedLibrary = "rnwhisper_x86_64";
     } else {
-      Log.d(NAME, "Loading libwhisper.so");
-      System.loadLibrary("whisper");
+      Log.d(NAME, "ARM32 is not supported, skipping loading library");
     }
   }
 
-  private static boolean isArmeabiV7a() {
+  public static boolean isArm64V8a() {
+    return Build.SUPPORTED_ABIS[0].equals("arm64-v8a");
+  }
+
+  public static boolean isArmeabiV7a() {
     return Build.SUPPORTED_ABIS[0].equals("armeabi-v7a");
   }
 
-  private static boolean isArmeabiV8a() {
-    return Build.SUPPORTED_ABIS[0].equals("arm64-v8a");
+  public static boolean isX86_64() {
+    return Build.SUPPORTED_ABIS[0].equals("x86_64");
   }
 
-  private static String cpuInfo() {
+  public static String getCpuFeatures() {
     File file = new File("/proc/cpuinfo");
     StringBuilder stringBuilder = new StringBuilder();
     try {
       BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
       String line;
       while ((line = bufferedReader.readLine()) != null) {
+        if (line.startsWith("Features")) {
           stringBuilder.append(line);
+          break;
+        }
       }
       bufferedReader.close();
       return stringBuilder.toString();
     } catch (IOException e) {
       Log.w(NAME, "Couldn't read /proc/cpuinfo", e);
-      return null;
+      return "";
     }
   }
 
+  public static String getLoadedLibrary() {
+    return loadedLibrary;
+  }
+
   // JNI methods
   protected static native long initContext(String modelPath);
   protected static native long initContextWithAsset(AssetManager assetManager, String modelPath);
@@ -531,4 +533,30 @@ public class WhisperContext {
     int n_samples
   );
   protected static native String bench(long context, int n_threads);
+
+  // VAD JNI methods
+  protected static native long initVadContext(String modelPath);
+  protected static native long initVadContextWithAsset(AssetManager assetManager, String modelPath);
+  protected static native long initVadContextWithInputStream(PushbackInputStream inputStream);
+  protected static native void freeVadContext(long vadContextPtr);
+  protected static native boolean vadDetectSpeech(long vadContextPtr, float[] audioData, int nSamples);
+  protected static native long vadGetSegmentsFromProbs(long vadContextPtr, float threshold,
+                                                       int minSpeechDurationMs, int minSilenceDurationMs,
+                                                       float maxSpeechDurationS, int speechPadMs,
+                                                       float samplesOverlap);
+  protected static native int vadGetNSegments(long segmentsPtr);
+  protected static native float vadGetSegmentT0(long segmentsPtr, int index);
+  protected static native float vadGetSegmentT1(long segmentsPtr, int index);
+  protected static native void vadFreeSegments(long segmentsPtr);
+
+  // Audio file loading utility for VAD
+  public static float[] loadAudioFileAsFloat32(String filePath) {
+    try {
+      java.io.FileInputStream fis = new java.io.FileInputStream(new java.io.File(filePath));
+      return AudioUtils.decodeWaveFile(fis);
+    } catch (Exception e) {
+      Log.e(NAME, "Failed to load audio file: " + filePath, e);
+      return null;
+    }
+  }
 }