react-native-tuner-engine 1.0.0

package/android/src/main/cpp/TunerEngineJni.cpp

@@ -0,0 +1,220 @@
+#include <jni.h>
+#include <android/log.h>
+#include <memory>
+#include <string>
+#include "AudioFrameDispatcher.hpp"
+#include "OboeAudioSource.h"
+#include "OnsetDetector.hpp"
+#include "PostProcessor.hpp"
+
+#define LOG_TAG "TunerEngineJni"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+// Globals — one engine per process (single-instance module assumption)
+static std::unique_ptr<AudioFrameDispatcher> gDispatcher;
+static std::shared_ptr<OboeAudioSource> gAudioSource;
+
+// JNI back-reference for pitch callbacks
+static JavaVM* gJvm = nullptr;
+static jobject gModuleRef = nullptr; // strong global ref to TunerEngineModule kotlin object
+static jmethodID gOnPitchMethod = nullptr;
+
+// Called from C++ worker thread; marshals PitchResult → Java
+static void onPitchResult(const PitchResult& r) {
+    if (!gJvm || !gModuleRef || !gOnPitchMethod) return;
+
+    JNIEnv* env = nullptr;
+    bool didAttach = false;
+
+    jint attachResult = gJvm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);
+    if (attachResult == JNI_EDETACHED) {
+        if (gJvm->AttachCurrentThread(&env, nullptr) == JNI_OK) {
+            didAttach = true;
+        } else {
+            LOGE("Failed to attach thread");
+            return;
+        }
+    } else if (attachResult != JNI_OK) {
+        return;
+    }
+
+    if (gModuleRef) {
+        jstring noteName     = env->NewStringUTF(r.noteName.c_str());
+        jstring nearestStr   = env->NewStringUTF(r.nearestString.c_str());
+        env->CallVoidMethod(
+            gModuleRef,
+            gOnPitchMethod,
+            static_cast<jboolean>(r.hasPitch),
+            static_cast<jfloat>(r.frequency),
+            static_cast<jfloat>(r.confidence),
+            static_cast<jfloat>(r.rmsDb),
+            noteName,
+            static_cast<jint>(r.octave),
+            static_cast<jfloat>(r.cents),
+            nearestStr,
+            static_cast<jfloat>(r.stringDeviation)
+        );
+        env->DeleteLocalRef(noteName);
+        env->DeleteLocalRef(nearestStr);
+    }
+
+    if (didAttach) {
+        gJvm->DetachCurrentThread();
+    }
+}
+
+extern "C" {
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* /*reserved*/) {
+    gJvm = vm;
+    return JNI_VERSION_1_6;
+}
+
+JNIEXPORT void JNICALL
+Java_com_tunerengine_TunerEngineModule_nativeInit(
+    JNIEnv* env, jobject thiz,
+    jfloat sampleRate, jint frameSize, jfloat overlapRatio
+) {
+    // Store strong global ref to the Kotlin module object for callbacks
+    if (gModuleRef) env->DeleteGlobalRef(gModuleRef);
+    gModuleRef = env->NewGlobalRef(thiz);
+
+    // Cache the callback method ID
+    jclass cls = env->GetObjectClass(thiz);
+    gOnPitchMethod = env->GetMethodID(cls, "onPitchDetected",
+        "(ZFFFLjava/lang/String;IFLjava/lang/String;F)V");
+
+    gDispatcher = std::make_unique<AudioFrameDispatcher>(
+        static_cast<int>(frameSize),
+        static_cast<float>(sampleRate),
+        onPitchResult,
+        static_cast<float>(overlapRatio)
+    );
+
+    LOGI("nativeInit: sampleRate=%.0f frameSize=%d overlapRatio=%.2f", (float)sampleRate, (int)frameSize, (float)overlapRatio);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_tunerengine_TunerEngineModule_nativeStart(
+    JNIEnv* env, jobject thiz
+) {
+    if (!gDispatcher) {
+        Java_com_tunerengine_TunerEngineModule_nativeInit(env, thiz, 48000.0f, 2048, 0.0f);
+    }
+
+    gAudioSource = std::make_shared<OboeAudioSource>(
+        [](const float* samples, int count, float /*sr*/) {
+            if (gDispatcher) gDispatcher->push(samples, count);
+        }
+    );
+
+    if (!gAudioSource->start()) {
+        LOGE("Failed to start Oboe stream");
+        gAudioSource.reset();
+        return JNI_FALSE;
+    }
+
+    // Sync dispatcher to actual sample rate reported by Oboe
+    if (gDispatcher) {
+        gDispatcher->setSampleRate(gAudioSource->sampleRate());
+        gDispatcher->start();
+    }
+
+    LOGI("Audio capture started");
+    return JNI_TRUE;
+}
+
+JNIEXPORT void JNICALL
+Java_com_tunerengine_TunerEngineModule_nativeStop(
+    JNIEnv* env, jobject /*thiz*/
+) {
+    if (gDispatcher) gDispatcher->stop();
+    if (gAudioSource) {
+        gAudioSource->stop();
+        gAudioSource.reset();
+    }
+    // Release global ref to allow GC of the module object
+    if (gModuleRef) {
+        env->DeleteGlobalRef(gModuleRef);
+        gModuleRef = nullptr;
+    }
+    LOGI("Audio capture stopped");
+}
+
+JNIEXPORT void JNICALL
+Java_com_tunerengine_TunerEngineModule_nativeConfigure(
+    JNIEnv* env, jobject thiz,
+    jfloat sampleRate, jint frameSize,
+    jfloat noiseGateDb, jfloat confidenceThreshold,
+    jfloat minFrequency, jfloat maxFrequency,
+    jfloat a4, jfloat overlapRatio
+) {
+    Java_com_tunerengine_TunerEngineModule_nativeInit(env, thiz, sampleRate, frameSize, overlapRatio);
+    if (gDispatcher) {
+        gDispatcher->setNoiseGateDb(noiseGateDb);
+        gDispatcher->setConfidenceThreshold(confidenceThreshold);
+        gDispatcher->setFrequencyRange(minFrequency, maxFrequency);
+        gDispatcher->setA4(a4);
+    }
+}
+
+JNIEXPORT void JNICALL
+Java_com_tunerengine_TunerEngineModule_nativeSetA4(
+    JNIEnv* /*env*/, jobject /*thiz*/, jfloat hz
+) {
+    if (gDispatcher) gDispatcher->setA4(hz);
+}
+
+JNIEXPORT void JNICALL
+Java_com_tunerengine_TunerEngineModule_nativeSetHpfCutoff(
+    JNIEnv* /*env*/, jobject /*thiz*/, jfloat hz
+) {
+    if (gDispatcher) gDispatcher->setHpfCutoff(static_cast<float>(hz));
+}
+
+JNIEXPORT void JNICALL
+Java_com_tunerengine_TunerEngineModule_nativeSetPostProcessorConfig(
+    JNIEnv* /*env*/, jobject /*thiz*/, jfloat emaAlpha, jint hysteresisFrames
+) {
+    if (gDispatcher) {
+        PostProcessor::Config cfg;
+        cfg.emaAlpha         = static_cast<float>(emaAlpha);
+        cfg.hysteresisFrames = static_cast<int>(hysteresisFrames);
+        gDispatcher->setPostProcessorConfig(cfg);
+    }
+}
+
+JNIEXPORT void JNICALL
+Java_com_tunerengine_TunerEngineModule_nativeSetInstrument(
+    JNIEnv* env, jobject /*thiz*/, jstring name
+) {
+    const char* nameChars = env->GetStringUTFChars(name, nullptr);
+    if (gDispatcher && nameChars) gDispatcher->setInstrument(std::string(nameChars));
+    env->ReleaseStringUTFChars(name, nameChars);
+}
+
+JNIEXPORT void JNICALL
+Java_com_tunerengine_TunerEngineModule_nativeSetTuning(
+    JNIEnv* env, jobject /*thiz*/, jstring name
+) {
+    const char* nameChars = env->GetStringUTFChars(name, nullptr);
+    if (gDispatcher && nameChars) gDispatcher->setTuning(std::string(nameChars));
+    env->ReleaseStringUTFChars(name, nameChars);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_tunerengine_TunerEngineModule_nativeIsRunning(
+    JNIEnv* /*env*/, jobject /*thiz*/
+) {
+    return static_cast<jboolean>(gAudioSource != nullptr);
+}
+
+JNIEXPORT void JNICALL
+Java_com_tunerengine_TunerEngineModule_nativeSetOnsetDetection(
+    JNIEnv* /*env*/, jobject /*thiz*/, jboolean enabled
+) {
+    if (gDispatcher) gDispatcher->setOnsetDetectionEnabled(static_cast<bool>(enabled));
+}
+
+} // extern "C"

package/android/src/main/java/com/tunerengine/TunerEngineModule.kt

@@ -0,0 +1,183 @@
+package com.tunerengine
+
+import android.Manifest
+import android.content.pm.PackageManager
+import androidx.core.app.ActivityCompat
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+
+class TunerEngineModule(reactContext: ReactApplicationContext) :
+  NativeTunerEngineSpec(reactContext) {
+
+  private var isRunning = false
+
+  override fun configure(opts: ReadableMap?, promise: Promise) {
+    val sampleRate = opts?.getDouble("sampleRate")?.toFloat() ?: 48000.0f
+    val frameSize = if (opts?.hasKey("frameSize") == true) opts.getInt("frameSize") else 2048
+    val noiseGateDb = opts?.getDouble("noiseGateDb")?.toFloat() ?: -55.0f
+    val confidenceThreshold = opts?.getDouble("confidenceThreshold")?.toFloat() ?: 0.75f
+    val minFrequency = opts?.getDouble("minFrequency")?.toFloat() ?: 60.0f
+    val maxFrequency = opts?.getDouble("maxFrequency")?.toFloat() ?: 1200.0f
+    val a4 = opts?.getDouble("a4")?.toFloat() ?: 440.0f
+    val overlapRatio = opts?.getDouble("overlapRatio")?.toFloat() ?: 0.0f
+
+    nativeConfigure(sampleRate, frameSize, noiseGateDb, confidenceThreshold, minFrequency, maxFrequency, a4, overlapRatio)
+
+    val hpfCutoffHz = opts?.getDouble("hpfCutoffHz")?.toFloat()
+    if (hpfCutoffHz != null) nativeSetHpfCutoff(hpfCutoffHz)
+
+    val emaAlpha = opts?.getDouble("emaAlpha")?.toFloat()
+    val hysteresisFrames = if (opts?.hasKey("hysteresisFrames") == true) opts.getInt("hysteresisFrames") else null
+    if (emaAlpha != null || hysteresisFrames != null) {
+      nativeSetPostProcessorConfig(emaAlpha ?: 0.35f, hysteresisFrames ?: 3)
+    }
+
+    if (opts?.hasKey("onsetDetection") == true) {
+      nativeSetOnsetDetection(opts.getBoolean("onsetDetection"))
+    }
+
+    promise.resolve(null)
+  }
+
+  override fun start(promise: Promise) {
+    val started = nativeStart()
+    if (started) {
+      isRunning = true
+      promise.resolve(null)
+    } else {
+      promise.reject("START_ERROR", "Failed to start audio capture")
+    }
+  }
+
+  override fun stop(promise: Promise) {
+    nativeStop()
+    isRunning = false
+    promise.resolve(null)
+  }
+
+  override fun setA4(hz: Double) {
+    nativeSetA4(hz.toFloat())
+  }
+
+  override fun setInstrument(name: String) {
+    nativeSetInstrument(name)
+  }
+
+  override fun setTuning(name: String) {
+    nativeSetTuning(name)
+  }
+
+  override fun setTemperament(name: String) {
+    // Temperament support added in M2
+  }
+
+  override fun requestPermission(promise: Promise) {
+    val activity = currentActivity
+    if (activity == null) {
+      promise.resolve(false)
+      return
+    }
+
+    if (ActivityCompat.checkSelfPermission(activity, Manifest.permission.RECORD_AUDIO)
+        == PackageManager.PERMISSION_GRANTED) {
+      promise.resolve(true)
+      return
+    }
+
+    val permissionAwareActivity = activity as? PermissionAwareActivity
+    if (permissionAwareActivity == null) {
+      promise.resolve(false)
+      return
+    }
+
+    permissionAwareActivity.requestPermissions(
+      arrayOf(Manifest.permission.RECORD_AUDIO),
+      REQUEST_PERMISSION_CODE,
+      PermissionListener { requestCode, _, grantResults ->
+        if (requestCode == REQUEST_PERMISSION_CODE) {
+          val granted = grantResults.isNotEmpty() &&
+              grantResults[0] == PackageManager.PERMISSION_GRANTED
+          promise.resolve(granted)
+          true
+        } else {
+          false
+        }
+      }
+    )
+  }
+
+  override fun getStatus(): WritableMap {
+    val map = WritableNativeMap()
+    map.putBoolean("isRunning", isRunning)
+    map.putBoolean("engineReady", nativeIsRunning())
+    return map
+  }
+
+  override fun addListener(eventName: String) {}
+
+  override fun removeListeners(count: Double) {}
+
+  // Called from the C++ worker thread via JNI
+  @Suppress("unused")
+  fun onPitchDetected(
+    hasPitch: Boolean,
+    frequency: Float,
+    confidence: Float,
+    rmsDb: Float,
+    noteName: String,
+    octave: Int,
+    cents: Float,
+    nearestString: String,
+    stringDeviation: Float
+  ) {
+    val params = Arguments.createMap().apply {
+      putBoolean("hasPitch", hasPitch)
+      putDouble("frequency", frequency.toDouble())
+      putDouble("confidence", confidence.toDouble())
+      putDouble("rmsDb", rmsDb.toDouble())
+      putString("noteName", noteName)
+      putInt("octave", octave)
+      putDouble("cents", cents.toDouble())
+      putString("nearestString", nearestString)
+      putDouble("stringDeviation", stringDeviation.toDouble())
+    }
+
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("onPitch", params)
+  }
+
+  // JNI methods
+  private external fun nativeInit(sampleRate: Float, frameSize: Int, overlapRatio: Float)
+  private external fun nativeStart(): Boolean
+  private external fun nativeStop()
+  private external fun nativeConfigure(
+    sampleRate: Float, frameSize: Int,
+    noiseGateDb: Float, confidenceThreshold: Float,
+    minFrequency: Float, maxFrequency: Float,
+    a4: Float, overlapRatio: Float
+  )
+  private external fun nativeSetA4(hz: Float)
+  private external fun nativeSetInstrument(name: String)
+  private external fun nativeSetTuning(name: String)
+  private external fun nativeSetHpfCutoff(hz: Float)
+  private external fun nativeSetPostProcessorConfig(emaAlpha: Float, hysteresisFrames: Int)
+  private external fun nativeSetOnsetDetection(enabled: Boolean)
+  private external fun nativeIsRunning(): Boolean
+
+  companion object {
+    const val NAME = NativeTunerEngineSpec.NAME
+    private const val REQUEST_PERMISSION_CODE = 1001
+
+    init {
+      System.loadLibrary("tunerengine")
+    }
+  }
+}

package/android/src/main/java/com/tunerengine/TunerEnginePackage.kt

@@ -0,0 +1,31 @@
+package com.tunerengine
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class TunerEnginePackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == TunerEngineModule.NAME) {
+      TunerEngineModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      TunerEngineModule.NAME to ReactModuleInfo(
+        name = TunerEngineModule.NAME,
+        className = TunerEngineModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
+      )
+    )
+  }
+}

package/cpp/CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+project(TunerEngineCore LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library(tuner_engine_core STATIC
+    src/NoteMapper.cpp
+    src/YinPitchDetector.cpp
+    src/Window.cpp
+    src/BiquadHpf.cpp
+    src/SnrEstimator.cpp
+    src/OnsetDetector.cpp
+    src/PostProcessor.cpp
+    src/Pipeline.cpp
+    src/TunerEngine.cpp
+    src/AudioFrameDispatcher.cpp
+    src/CepstrumPitchDetector.cpp
+    src/PyinPitchDetector.cpp
+    src/EnsembleSelector.cpp
+    src/StringMatcher.cpp
+)
+
+target_include_directories(tuner_engine_core PUBLIC include)