@4players/odin-nodejs 0.10.3 → 0.11.1

package/cppsrc/odinmedia.cpp

@@ -1,246 +1,204 @@
-//
-// Created by Phillip Schuster on 11.02.23.
-//
-
 #include "odinmedia.h"
-#include <string>
+#include "odinroom.h"
+#include "utilities.h"
 #include <iostream>
-#include <codecvt>
-#include <locale>
 
 using namespace std;
 
-// Required, otherwise an unknown symbol error comes up
-Napi::FunctionReference *OdinMedia::constructor;
+Napi::FunctionReference *OdinMediaWrapper::constructor;
 
 /**
- * Returns the media id as string of this room instance
- * @param info
+ * Constructs an OdinMediaWrapper for encoding and transmitting audio.
+ * This maps to odin_encoder_create() in the core SDK.
+ * 
+ * @param info[0] OdinRoom instance - parent room for transmission
+ * @param info[1] Sample rate (number) - typically 48000
+ * @param info[2] Number of channels (number) - 1 for mono, 2 for stereo
  */
-Napi::Value OdinMedia::MediaId(const Napi::CallbackInfo &info) {
+OdinMediaWrapper::OdinMediaWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<OdinMediaWrapper>(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 env.Undefined();
-    }
-
-    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();
-        return;
-    }
-
-    if (info.Length() == 4 && !info[3].IsObject()) {
-        Napi::TypeError::New(env, "Options need to be provided as an object").ThrowAsJavaScriptException();
+        Napi::TypeError::New(env, "Provide an OdinRoom instance, sample rate and number of channels").ThrowAsJavaScriptException();
         return;
     }
 
-    _room = Napi::ObjectWrap<OdinRoom>::Unwrap(info[0].As<Napi::Object>());
+    _roomWrapper = Napi::ObjectWrap<OdinRoomWrapper>::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");
+    _mediaId = 0;  // Will be set via setMediaId() after Joined event
+    _closed = false;
+    _encoder = nullptr;
+
+    // Create the ODIN encoder with the specified sample rate and stereo mode
+    OdinError rc = odin_encoder_create(_sampleRate, _numChannels == 2, &_encoder);
+    if (odin_is_error(rc)) {
+       OdinUtilities::ThrowNapiException(env, rc, "Failed to create encoder");
     }
 }
 
 /**
- * Destructor. Closes and destroys the OdinMedia and resets the event callback for this room handle.
+ * Releases resources when the JavaScript object is garbage collected.
+ * Uses mutex to prevent race conditions with Close().
  */
-void OdinMedia::Finalize(Napi::Env env) {
-    odin_media_stream_destroy(_mediaStreamHandle);
+void OdinMediaWrapper::Finalize(Napi::Env env) {
+    std::lock_guard<std::mutex> lock(_closeMutex);
+    
+    _closed = true;
+
+    if (_encoder) {
+        odin_encoder_free(_encoder);
+        _encoder = nullptr;
+    }
+    
+    _roomWrapper = nullptr;
 }
 
 /**
- * Exposes this class to JavaScript
- * @param info Napi::CallbackInfo
+ * Initializes the OdinMedia class and registers it with the N-API module.
+ * Exposes: sendAudioData, setMediaId, close, and id property.
+ * 
+ * Note: start() and stop() were removed as they served no purpose -
+ * they set a _running flag that was never checked. This simplifies
+ * the API to match the core ODIN SDK pattern.
  */
-Napi::Object OdinMedia::Init(Napi::Env env, Napi::Object exports) {
-    // This method is used to hook the accessor and method callbacks
+Napi::Object OdinMediaWrapper::Init(Napi::Env env, Napi::Object exports) {
     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)),
+            InstanceMethod<&OdinMediaWrapper::Close>("close", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+            InstanceMethod<&OdinMediaWrapper::SendData>("sendAudioData", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+            InstanceMethod<&OdinMediaWrapper::SetMediaId>("setMediaId", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+            InstanceAccessor("id", &OdinMediaWrapper::MediaId, nullptr, static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+            StaticMethod<&OdinMediaWrapper::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
+ * Closes the media stream and releases resources.
+ * This maps to odin_encoder_free() in the core SDK.
+ * 
+ * Thread Safety:
+ * Sets _closed to true FIRST (atomically), then acquires the mutex to free resources.
+ * This ensures that other methods see _closed=true immediately and exit early.
  */
-void OdinMedia::Close(const Napi::CallbackInfo &info) {
-    //Napi::Env env = info.Env();
+void OdinMediaWrapper::Close(const Napi::CallbackInfo &info) {
+    // Set closed flag first - this is atomic and immediately visible to other methods.
+    bool wasClosed = _closed.exchange(true);
+    if (wasClosed) {
+        return;  // Already closed
+    }
+    
+    // Acquire mutex to safely free resources
+    std::lock_guard<std::mutex> lock(_closeMutex);
+    
+    if (_encoder) {
+        odin_encoder_free(_encoder);
+        _encoder = nullptr;
+    }
+    
+    _roomWrapper = nullptr;
+}
 
-    if (_mediaStreamHandle <= 0) return;
+Napi::Value OdinMediaWrapper::CreateNewItem(const Napi::CallbackInfo &info) {
+    return constructor->New({info[0]});
+}
 
-    odin_media_stream_destroy(_mediaStreamHandle);
-    _mediaStreamHandle = 0;
+Napi::Object OdinMediaWrapper::NewInstance(const std::vector<napi_value>& args) {
+    return constructor->New(args);
 }
 
 /**
- * Creates a new instance of the OdinMedia class. Requires a token as a parameter.
- * @param info
- * @return
+ * Sets the server-assigned media ID.
+ * This must be called after receiving the Joined event which provides
+ * the list of available media IDs for this peer.
+ * 
+ * @param info[0] Media ID (number) - from Joined event's mediaIds array
  */
-Napi::Value OdinMedia::CreateNewItem(const Napi::CallbackInfo &info) {
+void OdinMediaWrapper::SetMediaId(const Napi::CallbackInfo &info) {
+    if (_closed) return;
+    
     Napi::Env env = info.Env();
-
-    if (info.Length() < 1 || !info[0].IsObject()) {
-        Napi::TypeError::New(env, "Token required as first parameter").ThrowAsJavaScriptException();
+    
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Media ID (number) required").ThrowAsJavaScriptException();
+        return;
     }
-
-#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]});
+    
+    _mediaId = static_cast<uint16_t>(info[0].As<Napi::Number>().Uint32Value());
 }
 
 /**
- * Creates a new instance of the OdinMedia class. Requires a token as a parameter.
- * @param info
- * @return
+ * Sends audio samples for transmission.
+ * This maps to odin_encoder_push() + odin_encoder_pop() + odin_room_send_datagram() in the core SDK.
+ * 
+ * Pushes samples to the encoder, then immediately pops and sends all available datagrams.
+ * If mediaId is 0 or the stream is closed, this is a no-op (matches core SDK behavior).
+ *
+ * @param info[0] Float32Array of interleaved audio samples in range [-1, 1]
  */
-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) {
+void OdinMediaWrapper::SendData(const Napi::CallbackInfo &info) {
+    // Early exit if closed - prevents use-after-free
+    if (_closed) return;
+    
     Napi::Env env = info.Env();
 
     if (info.Length() < 1 || !info[0].IsTypedArray()) {
-        Napi::TypeError::New(env, "TypedArray required as first parameter").ThrowAsJavaScriptException();
+        Napi::TypeError::New(env, "Float32Array required as first parameter").ThrowAsJavaScriptException();
+        return;
+    }
+
+    // Check resources are valid
+    if (!_encoder || !_roomWrapper || !_roomWrapper->GetRoom()) {
+        return;
+    }
+    
+    // mediaId must be set before sending (will produce no output if 0)
+    if (_mediaId == 0) {
         return;
     }
 
     Napi::Float32Array array = info[0].As<Napi::Float32Array>();
+    const float* samples = array.Data();
+    uint32_t sampleCount = array.ElementLength();
 
-#ifdef DEBUG
-    printf("Sent %d bytes of audio data\n", (int)array.ElementLength());
-#endif
+    // Push samples to encoder
+    OdinError err = odin_encoder_push(_encoder, samples, sampleCount);
+    if (odin_is_error(err)) {
+        std::cerr << "odin_encoder_push failed: " << odin_error_get_last_error() << std::endl;
+        return;
+    }
 
-    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");
+    // Pop and send all available datagrams
+    uint8_t datagram[2048];
+    for (;;) {
+        if (_closed) return;  // Check again in loop
+        
+        uint32_t datagram_length = sizeof(datagram);
+
+        switch (odin_encoder_pop(_encoder, &_mediaId, 1, datagram, &datagram_length)) {
+        case ODIN_ERROR_SUCCESS:
+            if (_roomWrapper && _roomWrapper->GetRoom()) {
+                odin_room_send_datagram(_roomWrapper->GetRoom(), datagram, datagram_length);
+            }
+            break;
+        case ODIN_ERROR_NO_DATA:
+            return;
+        default:
+            std::cerr << "odin_encoder_pop failed: " << odin_error_get_last_error() << std::endl;
+            return;
+        }
     }
+}
+
+/**
+ * Returns the media ID for this stream.
+ * @returns The server-assigned media ID, or 0 if not yet set.
+ */
+Napi::Value OdinMediaWrapper::MediaId(const Napi::CallbackInfo &info) {
+    return Napi::Number::New(info.Env(), _mediaId); 
 }

package/cppsrc/odinmedia.h

@@ -1,35 +1,68 @@
-//
-// 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"
+#include <vector>
+#include <atomic>
+#include <mutex>
+
+class OdinRoomWrapper;
 
-class OdinMedia : public Napi::ObjectWrap<OdinMedia> {
+/**
+ * OdinMediaWrapper handles encoding and transmitting audio data to the ODIN server.
+ * 
+ * This wrapper closely follows the core ODIN SDK pattern:
+ * 1. Constructor creates encoder (odin_encoder_create)
+ * 2. setMediaId() sets the server-assigned media ID
+ * 3. sendAudioData() encodes samples and sends datagrams (odin_encoder_push/pop + odin_room_send_datagram)
+ * 4. close() frees the encoder (odin_encoder_free)
+ *
+ * Usage workflow (from JavaScript):
+ * 1. Wait for Joined event to receive available media_ids
+ * 2. Create audio stream: media = room.createAudioStream(48000, 2)
+ * 3. Set the server-assigned media ID: media.setMediaId(mediaIds[0])
+ * 4. Push audio chunks: media.sendAudioData(chunk)  // 20ms chunks recommended
+ * 5. When done: media.close()
+ * 
+ * Thread Safety:
+ * The close() method sets _closed atomically before freeing resources.
+ * All methods check _closed first to prevent use-after-free crashes.
+ */
+class OdinMediaWrapper : public Napi::ObjectWrap<OdinMediaWrapper> {
 public:
-    OdinMedia(const Napi::CallbackInfo& info); //Constructor to initialise
-    static Napi::FunctionReference *New;
+    OdinMediaWrapper(const Napi::CallbackInfo& info);
     static Napi::Object Init(Napi::Env env, Napi::Object exports);
     static Napi::Value CreateNewItem(const Napi::CallbackInfo& info);
+    static Napi::Object NewInstance(const std::vector<napi_value>& args);
     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;
+    static Napi::FunctionReference *constructor;
+
+    // Room and encoder references
+    OdinRoomWrapper* _roomWrapper;
+    struct OdinEncoder* _encoder;
     uint32_t _sampleRate;
-    uint8_t _numChannels;
+    int _numChannels;
+
+    // Server-assigned media ID (received from Joined event)
+    uint16_t _mediaId;
+    
+    // Closed state - once set, all operations are rejected to prevent use-after-free.
+    // This is set BEFORE freeing resources in Close() to ensure thread safety.
+    std::atomic<bool> _closed;
+    
+    // Mutex for protecting resource cleanup
+    std::mutex _closeMutex;
+
+    // Native methods exposed to JavaScript
     void Close(const Napi::CallbackInfo& info);
     void SendData(const Napi::CallbackInfo& info);
-    Napi::Value MediaId(const Napi::CallbackInfo &info);
+    void SetMediaId(const Napi::CallbackInfo& info);
+    Napi::Value MediaId(const Napi::CallbackInfo& info);
 };
 
-
 #endif //ODIN_NODEJS_ODINMEDIA_H
+
+