@4players/odin-nodejs 0.7.0

package/cppsrc/odinmedia.cpp

@@ -0,0 +1,242 @@
+//
+// Created by Phillip Schuster on 11.02.23.
+//
+
+#include "odinmedia.h"
+#include <string>
+#include <iostream>
+#include <codecvt>
+#include <locale>
+
+using namespace std;
+
+// Required, otherwise an unknown symbol error comes up
+Napi::FunctionReference *OdinMedia::constructor;
+
+/**
+ * Returns the media id as string of this room instance
+ * @param info
+ */
+Napi::Value OdinMedia::MediaId(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+
+    uint16_t out_id;
+    OdinReturnCode error = odin_media_stream_media_id(_mediaStreamHandle, &out_id);
+    if (odin_is_error(error)) {
+        Napi::TypeError::New(env, "Failed to get media id").ThrowAsJavaScriptException();
+    }
+
+    return Napi::Number::New(env, out_id);
+}
+
+/**
+ * Creates a new OdinMedia instance. Requires an Odin token as a parameter.
+ * @param info Napi::CallbackInfo
+ */
+OdinMedia::OdinMedia(const Napi::CallbackInfo &info) : Napi::ObjectWrap<OdinMedia>(info) {
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+
+    // Checking for room instance, sample rate (float) and channels (int)
+    if (info.Length() < 3 || !info[0].IsObject() || !info[1].IsNumber() || !info[2].IsNumber()) {
+        Napi::TypeError::New(env, "Provide an OdinRoom instance, sample rate and number of channels as number").ThrowAsJavaScriptException();
+    }
+
+    if (info.Length() == 4 && !info[3].IsObject()) {
+        Napi::TypeError::New(env, "Options need to be provided as an object").ThrowAsJavaScriptException();
+    }
+
+    _room = Napi::ObjectWrap<OdinRoom>::Unwrap(info[0].As<Napi::Object>());
+    _sampleRate = info[1].As<Napi::Number>().Uint32Value();
+    _numChannels = info[2].As<Napi::Number>().Int32Value();
+
+    /*
+     * Configure audio processing options for the room
+     */
+    OdinApmConfig apm_config;
+    apm_config.voice_activity_detection = false;
+    apm_config.voice_activity_detection_attack_probability = 0.9;
+    apm_config.voice_activity_detection_release_probability = 0.8;
+    apm_config.volume_gate = false;
+    apm_config.volume_gate_attack_loudness = -30;
+    apm_config.volume_gate_release_loudness = -40;
+    apm_config.echo_canceller = false;
+    apm_config.high_pass_filter = false;
+    apm_config.pre_amplifier = false;
+    apm_config.noise_suppression_level = OdinNoiseSuppressionLevel_Moderate;
+    apm_config.transient_suppressor = false;
+    apm_config.gain_controller = true;
+
+    if (info.Length() == 4) {
+        Napi::Object options = info[3].As<Napi::Object>();
+        if (options.Has("voiceActivityDetection")) {
+            apm_config.voice_activity_detection = options.Get("voiceActivityDetection").As<Napi::Boolean>().Value();
+        }
+        if (options.Has("voiceActivityDetectionAttackProbability")) {
+            apm_config.voice_activity_detection_attack_probability = options.Get("voiceActivityDetectionAttackProbability").As<Napi::Number>().DoubleValue();
+        }
+        if (options.Has("voiceActivityDetectionReleaseProbability")) {
+            apm_config.voice_activity_detection_release_probability = options.Get("voiceActivityDetectionReleaseProbability").As<Napi::Number>().DoubleValue();
+        }
+        if (options.Has("volumeGate")) {
+            apm_config.volume_gate = options.Get("volumeGate").As<Napi::Boolean>().Value();
+        }
+        if (options.Has("volumeGateAttackLoudness")) {
+            apm_config.volume_gate_attack_loudness = options.Get("volumeGateAttackLoudness").As<Napi::Number>().DoubleValue();
+        }
+        if (options.Has("volumeGateReleaseLoudness")) {
+            apm_config.volume_gate_release_loudness = options.Get("volumeGateReleaseLoudness").As<Napi::Number>().DoubleValue();
+        }
+        if (options.Has("echoCanceller")) {
+            apm_config.echo_canceller = options.Get("echoCanceller").As<Napi::Boolean>().Value();
+        }
+        if (options.Has("highPassFilter")) {
+            apm_config.high_pass_filter = options.Get("highPassFilter").As<Napi::Boolean>().Value();
+        }
+        if (options.Has("preAmplifier")) {
+            apm_config.pre_amplifier = options.Get("preAmplifier").As<Napi::Boolean>().Value();
+        }
+        if (options.Has("noiseSuppressionLevel")) {
+            apm_config.noise_suppression_level = (OdinNoiseSuppressionLevel) options.Get("noiseSuppressionLevel").As<Napi::Number>().Int32Value();
+        }
+        if (options.Has("transientSuppressor")) {
+            apm_config.transient_suppressor = options.Get("transientSuppressor").As<Napi::Boolean>().Value();
+        }
+        if (options.Has("gainController")) {
+            apm_config.gain_controller = options.Get("gainController").As<Napi::Boolean>().Value();
+        }
+    }
+
+    OdinReturnCode error = odin_room_configure_apm(_room->GetRoomHandle(), apm_config);
+    if (odin_is_error(error)) {
+        OdinUtilities::ThrowNapiException(env, error, "Failed to configure APM settings");
+    }
+
+    /*
+     * Create the input audio stream with a samplerate of 48 kHz
+     */
+    OdinAudioStreamConfig audio_config;
+    audio_config.sample_rate = _sampleRate;
+    audio_config.channel_count = _numChannels;
+    _mediaStreamHandle = odin_audio_stream_create(audio_config);
+
+    error = odin_room_add_media(_room->GetRoomHandle(), _mediaStreamHandle);
+    if (odin_is_error(error)) {
+        OdinUtilities::ThrowNapiException(env, error, "Failed to add media to room");
+    }
+}
+
+/**
+ * Destructor. Closes and destroys the OdinMedia and resets the event callback for this room handle.
+ */
+void OdinMedia::Finalize(Napi::Env env) {
+    odin_media_stream_destroy(_mediaStreamHandle);
+}
+
+/**
+ * Exposes this class to JavaScript
+ * @param info Napi::CallbackInfo
+ */
+Napi::Object OdinMedia::Init(Napi::Env env, Napi::Object exports) {
+    // This method is used to hook the accessor and method callbacks
+    Napi::Function func = DefineClass(env, "OdinMedia", {
+            InstanceMethod<&OdinMedia::Close>("close", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+            InstanceMethod<&OdinMedia::SendData>("sendAudioData", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+            InstanceAccessor("id", &OdinMedia::MediaId, nullptr, static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+            StaticMethod<&OdinMedia::CreateNewItem>("CreateNewItem", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+    });
+
+    // We use a static variable to store the constructor. This is because we need to create instances within C++ and
+    // expose to JavaScript. We can't use the constructor directly because it's not exposed to JavaScript.
+    constructor = new Napi::FunctionReference();
+
+    // Create a persistent reference to the class constructor. This will allow
+    // a function called on a class prototype and a function
+    // called on instance of a class to be distinguished from each other.
+    *constructor = Napi::Persistent(func);
+    exports.Set("OdinMedia", func);
+
+    // Store the constructor as the add-on instance data. This will allow this
+    // add-on to support multiple instances of itself running on multiple worker
+    // threads, as well as multiple instances of itself running in different
+    // contexts on the same thread.
+    //
+    // By default, the value set on the environment here will be destroyed when
+    // the add-on is unloaded using the `delete` operator, but it is also
+    // possible to supply a custom deleter.
+    env.SetInstanceData<Napi::FunctionReference>(constructor);
+
+    return exports;
+}
+
+/**
+ * Closes the room connection and destroys the room handle.
+ * @param info
+ */
+void OdinMedia::Close(const Napi::CallbackInfo &info) {
+    //Napi::Env env = info.Env();
+
+    if (_mediaStreamHandle <= 0) return;
+
+    odin_media_stream_destroy(_mediaStreamHandle);
+    _mediaStreamHandle = 0;
+}
+
+/**
+ * Creates a new instance of the OdinMedia class. Requires a token as a parameter.
+ * @param info
+ * @return
+ */
+Napi::Value OdinMedia::CreateNewItem(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsObject()) {
+        Napi::TypeError::New(env, "Token required as first parameter").ThrowAsJavaScriptException();
+    }
+
+#ifdef DEBUG
+    printf("Odin NodeJS Addon: Creating OdinMedia Instance\n");
+#endif
+
+    // Retrieve the instance data we stored during `Init()`. We only stored the
+    // constructor there, so we retrieve it here to create a new instance of the
+    // JS class the constructor represents.
+    Napi::FunctionReference *constructor =
+            info.Env().GetInstanceData<Napi::FunctionReference>();
+    return constructor->New({info[0]});
+}
+
+/**
+ * Creates a new instance of the OdinMedia class. Requires a token as a parameter.
+ * @param info
+ * @return
+ */
+Napi::Object OdinMedia::NewInstance(const std::initializer_list<napi_value>& args) {
+    //printf("Creating OdinMedia Instance, sample rate %d, num channels %d\n", sampleRate.As<Napi::Number>().Uint32Value(), numChannels.As<Napi::Number>().Uint32Value());
+
+#ifdef DEBUG
+    printf("Odin NodeJS Addon: Creating OdinMedia Instance with %d arguments\n", (int)args.size());
+#endif
+
+    return constructor->New(args);
+}
+
+void OdinMedia::SendData(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsTypedArray()) {
+        Napi::TypeError::New(env, "TypedArray required as first parameter").ThrowAsJavaScriptException();
+    }
+
+    Napi::Float32Array array = info[0].As<Napi::Float32Array>();
+
+#ifdef DEBUG
+    printf("Received %d bytes of audio data\n", (int)array.ElementLength());
+#endif
+
+    OdinReturnCode result = odin_audio_push_data(_mediaStreamHandle, array.Data(), array.ElementLength());
+    if (odin_is_error(result)) {
+        OdinUtilities::ThrowNapiException(env, result, "Failed to push audio data");
+    }
+}

package/cppsrc/odinmedia.h

@@ -0,0 +1,35 @@
+//
+// Created by Phillip Schuster on 11.02.23.
+//
+
+#ifndef ODIN_NODEJS_ODINMEDIA_H
+#define ODIN_NODEJS_ODINMEDIA_H
+
+#include <napi.h>
+#include <odin.h>
+#include "utilities.h"
+#include <map>
+#include <thread>
+#include "odinroom.h"
+
+class OdinMedia : public Napi::ObjectWrap<OdinMedia> {
+public:
+    OdinMedia(const Napi::CallbackInfo& info); //Constructor to initialise
+    static Napi::FunctionReference *New;
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    static Napi::Value CreateNewItem(const Napi::CallbackInfo& info);
+    void Finalize(Napi::Env env) override;
+    static Napi::FunctionReference *constructor;
+    static Napi::Object NewInstance(const std::initializer_list<napi_value>& args);
+private:
+    OdinMediaStreamHandle _mediaStreamHandle;
+    OdinRoom* _room;
+    uint32_t _sampleRate;
+    uint8_t _numChannels;
+    void Close(const Napi::CallbackInfo& info);
+    void SendData(const Napi::CallbackInfo& info);
+    Napi::Value MediaId(const Napi::CallbackInfo &info);
+};
+
+
+#endif //ODIN_NODEJS_ODINMEDIA_H