@4players/odin-nodejs 0.10.3 → 0.11.1

package/cppsrc/odinroom.cpp

@@ -1,787 +1,827 @@
-//
-// Created by Phillip Schuster on 11.02.23.
-//
-
 #include "odinroom.h"
-#include <string>
-#include <iostream>
-#include <codecvt>
-#include <locale>
 #include "odinmedia.h"
+#include "odincipher.h"
+#include "utilities.h"
+#include <iostream>
+#include <vector>
+#include <cstring>
+#include <cstdio>
 
 using namespace std;
 
+
+
 // Required, otherwise an unknown symbol error comes up
-Napi::FunctionReference* OdinRoom::constructor;
+Napi::FunctionReference* OdinRoomWrapper::constructor;
+struct OdinConnectionPool* OdinRoomWrapper::_pool = nullptr;
+std::map<uint64_t, OdinRoomWrapper*> OdinRoomWrapper::_roomsMap;
+std::mutex OdinRoomWrapper::_roomsMapMutex;
+
+// Shared SDK initialization flag (also used by OdinClient)
+bool g_odinSdkInitialized = false;
+
+// Static counter for active rooms - used for SDK lifecycle management
+static std::atomic<int> g_activeRoomCount{0};
+static std::mutex g_sdkLifecycleMutex;
 
 /**
- * Prepares a NAPI value object for the event
- * @param env
- * @param event The event data
- * @return
+ * Increments the active room count and initializes the SDK if this is the first room.
+ * Thread-safe for concurrent room creation.
  */
-Napi::Object OdinRoom::PrepareEventObject(Napi::Env env, const EventData *event) {
-    Napi::Object obj = Napi::Object::New(env);
-    obj.Set("event", event->Event);
-    obj.Set("tag", (int)event->Tag);
-    switch(event->Tag) {
-        case OdinEvent_Joined: {
-            const JoinedEventData *joined = static_cast<const JoinedEventData*>(event);
-            obj.Set("roomId", joined->RoomId);
-            obj.Set("ownPeerId", joined->PeerId);
-            obj.Set("ownUserId", joined->UserId);
-            Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(env, (void*)joined->Data, joined->DataLen);
-            Napi::Uint8Array array = Napi::Uint8Array::New(env, joined->DataLen, buffer, 0, napi_uint8_array);
-            obj.Set("roomUserData", array);
-            break;
-        }
-        case OdinEvent_PeerJoined: {
-            const PeerJoinedEventData *joined = static_cast<const PeerJoinedEventData*>(event);
-            obj.Set("peerId", joined->PeerId);
-            obj.Set("userId", joined->UserId);
-            Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(env, (void*)joined->Data, joined->DataLen);
-            Napi::Uint8Array array = Napi::Uint8Array::New(env, joined->DataLen, buffer, 0, napi_uint8_array);
-            obj.Set("userData", array);
-            break;
-        }
-        case OdinEvent_PeerLeft: {
-            const PeerLeftEventData *left = static_cast<const PeerLeftEventData*>(event);
-            obj.Set("peerId", left->PeerId);
-            break;
-        }
-        case OdinEvent_PeerUserDataChanged: {
-            const PeerUserDataChangedEventData *changed = static_cast<const PeerUserDataChangedEventData*>(event);
-            obj.Set("peerId", changed->PeerId);
-            Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(env, (void*)changed->Data, changed->DataLen);
-            Napi::Uint8Array array = Napi::Uint8Array::New(env, changed->DataLen, buffer, 0, napi_uint8_array);
-            obj.Set("userData", array);
-            break;
-        }
-        case OdinEvent_RoomUserDataChanged: {
-            const RoomUserDataChangedEventData *changed = static_cast<const RoomUserDataChangedEventData*>(event);
-            Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(env, (void*)changed->Data, changed->DataLen);
-            Napi::Uint8Array array = Napi::Uint8Array::New(env, changed->DataLen, buffer, 0, napi_uint8_array);
-            obj.Set("userData", array);
-            break;
-        }
-        case OdinEvent_MessageReceived: {
-            const MessageReceivedEventData *message = static_cast<const MessageReceivedEventData*>(event);
-            obj.Set("peerId", message->PeerId);
-            Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(env, (void*)message->Data, message->DataLen);
-            Napi::Uint8Array array = Napi::Uint8Array::New(env, message->DataLen, buffer, 0, napi_uint8_array);
-            obj.Set("messageData", array);
-            break;
-        }
-        case OdinEvent_RoomConnectionStateChanged: {
-            const RoomConnectionStateChangedEventData *state = static_cast<const RoomConnectionStateChangedEventData*>(event);
-            obj.Set("state", state->StateName);
-            obj.Set("reason", state->ReasonName);
-            break;
-        }
-        case OdinEvent_MediaAdded: {
-            const MediaAddedEventData *added = static_cast<const MediaAddedEventData*>(event);
-            obj.Set("peerId", added->PeerId);
-            obj.Set("mediaId", added->MediaId);
-            break;
-        }
-        case OdinEvent_MediaRemoved: {
-            const MediaRemovedEventData *removed = static_cast<const MediaRemovedEventData*>(event);
-            obj.Set("peerId", removed->PeerId);
-            obj.Set("mediaId", removed->MediaId);
-            break;
-        }
-        case OdinEvent_MediaActiveStateChanged: {
-            const MediaActiveStateChangedEventData *activity = static_cast<const MediaActiveStateChangedEventData*>(event);
-            obj.Set("peerId", activity->PeerId);
-            obj.Set("mediaId", activity->MediaId);
-            obj.Set("state", activity->Active);
-            break;
+void OdinRoomWrapper::IncrementRoomCount() {
+    std::lock_guard<std::mutex> lock(g_sdkLifecycleMutex);
+    int prevCount = g_activeRoomCount.fetch_add(1);
+    
+    if (prevCount == 0 && !g_odinSdkInitialized) {
+        // First room - initialize the SDK
+        OdinError initRc = odin_initialize(ODIN_VERSION);
+        if (!odin_is_error(initRc)) {
+            g_odinSdkInitialized = true;
         }
     }
-
-    return obj;
 }
 
 /**
- * Returns the room id as string of this room instance
- * @param info
+ * Decrements the active room count and shuts down the SDK if this was the last room.
+ * Thread-safe for concurrent room destruction.
  */
-Napi::Value OdinRoom::RoomId(const Napi::CallbackInfo &info) {
-    Napi::Env env = info.Env();
+void OdinRoomWrapper::DecrementRoomCount() {
+    std::lock_guard<std::mutex> lock(g_sdkLifecycleMutex);
+    int newCount = g_activeRoomCount.fetch_sub(1) - 1;
+    
+    if (newCount == 0 && g_odinSdkInitialized) {
+        // Last room closed - shutdown the SDK
+        // First free the connection pool if it exists
+        if (_pool) {
+            odin_connection_pool_free(_pool);
+            _pool = nullptr;
+        }
+        odin_shutdown();
+        g_odinSdkInitialized = false;
+    }
+}
 
-    char out_id[512];
-    OdinReturnCode error = odin_room_id(_roomHandle, out_id, sizeof(out_id));
-    if (odin_is_error(error))
-    {
-        Napi::TypeError::New(env, "Failed to get room id").ThrowAsJavaScriptException();
-        return env.Undefined();
+struct OdinConnectionPool* OdinRoomWrapper::GetConnectionPool() {
+    if (!_pool) {
+        // Auto-initialize ODIN SDK if not already done
+        if (!g_odinSdkInitialized) {
+            OdinError initRc = odin_initialize(ODIN_VERSION);
+            if (!odin_is_error(initRc)) {
+                g_odinSdkInitialized = true;
+            } else {
+                // Don't print error for "already initialized" - this is expected
+                // when OdinClient was created first
+            }
+        }
+        
+        OdinConnectionPoolSettings settings;
+        memset(&settings, 0, sizeof(settings));
+        settings.on_datagram = OdinRoomWrapper::OnDatagram;
+        settings.on_rpc = OdinRoomWrapper::OnRPC;
+        settings.user_data = nullptr;
+        
+        OdinError rc = odin_connection_pool_create(settings, &_pool);
+        if (odin_is_error(rc)) {
+            printf("Odin NodeJS Addon: Error creating connection pool: %d. Did you forget to create OdinClient first?\n", rc);
+        }
     }
+    return _pool;
+}
 
-    return Napi::String::New(env, out_id);
+void OdinRoomWrapper::OnDatagram(uint64_t room_ref, uint16_t media_id, const uint8_t *bytes, uint32_t bytes_length, void *user_data) {
+    std::lock_guard<std::mutex> lock(_roomsMapMutex);
+    auto it = _roomsMap.find(room_ref);
+    if (it != _roomsMap.end()) {
+        it->second->HandleDatagramInternal(media_id, bytes, bytes_length);
+    }
 }
 
-/**
- * Returns the room handle of this room instance
- */
-OdinRoomHandle OdinRoom::GetRoomHandle() const {
-    return _roomHandle;
+void OdinRoomWrapper::OnRPC(uint64_t room_ref, const uint8_t *bytes, uint32_t bytes_length, void *user_data) {
+    std::lock_guard<std::mutex> lock(_roomsMapMutex);
+    auto it = _roomsMap.find(room_ref);
+    if (it != _roomsMap.end()) {
+        it->second->HandleRPCInternal(bytes, bytes_length);
+    }
 }
 
-/**
- * Returns the media id of a media stream handle, used internally to map media stream handles to media ids in event callbacks
- */
-uint16_t OdinRoom::GetMediaIdFromHandle(OdinMediaStreamHandle handle)
-{
-    uint16_t media_id;
-    int error = odin_media_stream_media_id(handle, &media_id);
-    return odin_is_error(error) ? 0 : media_id;
+Napi::Value OdinRoomWrapper::RoomId(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    if (!_room) return env.Null();
+    char name[256];
+    uint32_t len = sizeof(name);
+    OdinError err = odin_room_get_name(_room, name, &len);
+    if (odin_is_error(err)) return env.Null();
+    return Napi::String::New(env, name);
 }
 
 /**
- * Creates an EventData object instance from an OdinEvent. As OdinEvents are allocated on the Odin SDK side, we need to
- * copy the data as the callbacks to the JS side are asynchronous.
- * @param event
- * @return EventData
+ * Internal handler for audio datagrams received from the ODIN server.
+ * Called from the static OnDatagram callback on the connection pool's thread.
+ * 
+ * Thread Safety: Checks _started before accessing decoders to prevent
+ * operations on freed decoders during shutdown.
  */
-EventData* OdinRoom::PrepareEventData(OdinEvent* event)
-{
-    switch(event->tag) {
-        case OdinEvent_Joined: {
-            JoinedEventData* data = new JoinedEventData();
-            data->Tag = event->tag;
-            data->Event = "Joined";
-            data->RoomId = event->joined.room_id;
-            data->UserId = event->joined.own_user_id;
-            data->PeerId = event->joined.own_peer_id;
-            if (event->joined.room_user_data && event->joined.room_user_data_len > 0) {
-                data->SetData(event->joined.room_user_data, event->joined.room_user_data_len);
-            }
-            return data;
-        }
-        case OdinEvent_PeerJoined: {
-            PeerJoinedEventData* data = new PeerJoinedEventData();
-            data->Tag = event->tag;
-            data->Event = "PeerJoined";
-            data->PeerId = event->peer_joined.peer_id;
-            data->UserId = event->peer_joined.user_id;
-            if (event->peer_joined.peer_user_data && event->peer_joined.peer_user_data_len > 0) {
-                data->SetData(event->peer_joined.peer_user_data, event->peer_joined.peer_user_data_len);
-            }
-            return data;
-        }
-        case OdinEvent_PeerLeft: {
-            PeerLeftEventData* data = new PeerLeftEventData();
-            data->Tag = event->tag;
-            data->Event = "PeerLeft";
-            data->PeerId = event->peer_left.peer_id;
-            return data;
-        }
-        case OdinEvent_PeerUserDataChanged: {
-            PeerUserDataChangedEventData* data = new PeerUserDataChangedEventData();
-            data->Tag = event->tag;
-            data->Event = "PeerUserDataChanged";
-            data->PeerId = event->peer_user_data_changed.peer_id;
-            if (event->peer_user_data_changed.peer_user_data && event->peer_user_data_changed.peer_user_data_len > 0) {
-                data->SetData(event->peer_user_data_changed.peer_user_data, event->peer_user_data_changed.peer_user_data_len);
-            }
-            return data;
-        }
-        case OdinEvent_RoomUserDataChanged: {
-            RoomUserDataChangedEventData* data = new RoomUserDataChangedEventData();
-            data->Tag = event->tag;
-            data->Event = "RoomUserDataChanged";
-            if (event->room_user_data_changed.room_user_data && event->room_user_data_changed.room_user_data_len > 0) {
-                data->SetData(event->room_user_data_changed.room_user_data, event->room_user_data_changed.room_user_data_len);
-            }
-            return data;
+void OdinRoomWrapper::HandleDatagramInternal(uint16_t media_id, const uint8_t *bytes, uint32_t bytes_length) {
+    // Early exit if room is closing - decoders may be freed
+    if (!_started) return;
+    
+    std::lock_guard<std::mutex> lock(_decodersMutex);
+    
+    // Double-check after acquiring lock
+    if (!_started) return;
+    
+    auto it = _decoders.find(media_id);
+    if (it == _decoders.end()) {
+        OdinDecoder* decoder = nullptr;
+        OdinError rc = odin_decoder_create(media_id, 48000, true, &decoder);
+        if (!odin_is_error(rc)) {
+            _decoders[media_id] = decoder;
+            it = _decoders.find(media_id);
         }
-        case OdinEvent_MessageReceived: {
-            MessageReceivedEventData* data = new MessageReceivedEventData();
-            data->Tag = event->tag;
-            data->Event = "MessageReceived";
-            data->PeerId = event->message_received.peer_id;
-            if (event->message_received.data && event->message_received.data_len > 0) {
-                data->SetData(event->message_received.data, event->message_received.data_len);
-            }
-            return data;
-        }
-        case OdinEvent_RoomConnectionStateChanged: {
-            RoomConnectionStateChangedEventData* data = new RoomConnectionStateChangedEventData();
-            data->Tag = event->tag;
-            data->Event = "ConnectionStateChanged";
-            data->State = (int)event->room_connection_state_changed.state;
-            data->Reason = (int)event->room_connection_state_changed.reason;
-            data->StateName = OdinUtilities::GetNameFromConnectionState(event->room_connection_state_changed.state);
-            data->ReasonName = OdinUtilities::GetNameFromConnectionStateChangeReason(event->room_connection_state_changed.reason);
-            return data;
-        }
-        case OdinEvent_MediaAdded: {
-            MediaAddedEventData* data = new MediaAddedEventData();
-            data->Tag = event->tag;
-            data->Event = "MediaAdded";
-            data->PeerId = event->media_added.peer_id;
-            data->MediaId = GetMediaIdFromHandle(event->media_added.media_handle);
-            data->MediaStreamHandle = event->media_added.media_handle;
-            return data;
-        }
-        case OdinEvent_MediaRemoved: {
-            MediaRemovedEventData* data = new MediaRemovedEventData();
-            data->Tag = event->tag;
-            data->Event = "MediaRemoved";
-            data->PeerId = event->media_removed.peer_id;
-            data->MediaId = GetMediaIdFromHandle(event->media_removed.media_handle);
-            return data;
-        }
-        case OdinEvent_MediaActiveStateChanged: {
-            MediaActiveStateChangedEventData *data = new MediaActiveStateChangedEventData();
-            data->Tag = event->tag;
-            data->Event = "MediaActivity";
-            data->PeerId = event->media_active_state_changed.peer_id;
-            data->MediaId = GetMediaIdFromHandle(event->media_active_state_changed.media_handle);
-            data->Active = event->media_active_state_changed.active;
-            return data;
-        }
-        default:
-            return NULL;
     }
-
-    return NULL;
+    
+    if (it != _decoders.end()) {
+        odin_decoder_push(it->second, bytes, bytes_length);
+    }
 }
 
 /**
- * Callback function for Odin events. This function is called by the Odin SDK when an event occurs. It creates an EventData
- * object instance from the OdinEvent and calls the JavaScript callback function with the event data.
- * @param room OdinRoomHandle
- * @param event OdinEvent
- * @param data void* Pointer to the OdinRoom instance
+ * Internal handler for RPC messages received from the ODIN server.
+ * Called from the static OnRPC callback on the connection pool's thread.
+ * 
+ * Thread Safety: Checks _started before calling callbacks to prevent
+ * calling released ThreadSafeFunctions during shutdown.
  */
-void OdinRoom::HandleOdinEvent(OdinRoomHandle room, const OdinEvent *event, void *data)
-{
-    OdinRoom* odinRoom = (OdinRoom*)data;
-    if (odinRoom != NULL) {
-
-        ::uint16_t mediaId = OdinRoom::GetMediaIdFromHandle(event->media_added.media_handle);
-        if (event->tag == OdinEvent_MediaAdded) {
-            Media media;
-            media.PeerId = event->media_added.peer_id;
-            media.Id = mediaId;
-            media.Handle = event->media_added.media_handle;
-            odinRoom->_mediaStreams[media.Id] = media;
-        } else if (event->tag == OdinEvent_MediaRemoved) {
-            if (odinRoom->_mediaStreams.find(mediaId) != odinRoom->_mediaStreams.end()) {
-                odinRoom->_mediaStreams.erase(mediaId);
-            }
+void OdinRoomWrapper::HandleRPCInternal(const uint8_t *bytes, uint32_t bytes_length) {
+    // Early exit if room is closing - callbacks may be released
+    if (!_started) return;
+    
+    // Just pass the raw RPC bytes to JavaScript
+    // The JS layer can handle parsing MessagePack format
+    
+    // Create a copy of the data to pass to the callback
+    std::vector<uint8_t>* data = new std::vector<uint8_t>(bytes, bytes + bytes_length);
+    
+    // Get pointer to pending counter for ref-counting
+    std::atomic<int>* pendingPtr = &_pendingCallbacks;
+    
+    auto callback = [pendingPtr](Napi::Env env, Napi::Function jsCallback, void* value) {
+        std::vector<uint8_t>* rpcData = (std::vector<uint8_t>*)value;
+        try {
+            auto buffer = Napi::ArrayBuffer::New(env, rpcData->size());
+            std::copy(rpcData->begin(), rpcData->end(), (uint8_t*)buffer.Data());
+            jsCallback.Call({buffer});
+        } catch (...) {
+            // Exception in RPC callback - silently ignore
         }
-
-        auto callback = []( Napi::Env env, Napi::Function jsCallback, void* value ) {
-            EventData* eventData = (EventData*)value;
-            if (eventData == NULL) {
-                // I have no idea how to call a function without a parameter ;-)
-                // This should never happen anyway
-                jsCallback.Call({Napi::Number::New( env, 42 )});
-            } else {
-                Napi::Object obj = PrepareEventObject(env, eventData);
-                jsCallback.Call( {obj} );
-                delete eventData;
-            }
-        };
-        if (odinRoom->_eventListener != NULL)
-        {
-            EventData* data = odinRoom->PrepareEventData((OdinEvent*)event);
-#ifdef DEBUG
-            printf("Odin NodeJS Addon: Sending event to JS: %s\n", data->Event.c_str());
-#endif
-            odinRoom->_eventListener.BlockingCall( (void*)data, callback );
+        delete rpcData;
+        
+        // Decrement pending count AFTER callback completes
+        if (pendingPtr) {
+            pendingPtr->fetch_sub(1);
         }
-
-        EventData* data = odinRoom->PrepareEventData((OdinEvent*)event);
-        Napi::ThreadSafeFunction function = odinRoom->_eventListeners[data->Event];
-        if (function != NULL) {
-            function.BlockingCall( (void*)data, callback );
+    };
+    
+    // Emit to the generic event listener (with safety check)
+    if (_started && _eventListener) {
+        std::vector<uint8_t>* dataCopy = new std::vector<uint8_t>(*data);
+        _pendingCallbacks.fetch_add(1);  // Increment before NonBlockingCall
+        _eventListener.NonBlockingCall(dataCopy, callback);
+    }
+    
+    // Emit to specific event listeners (with safety check for each)
+    // Note: We iterate over a copy of the keys to avoid issues if the map changes
+    if (_started) {
+        for (auto& pair : _eventListeners) {
+            if (!_started) break;  // Early exit if closing during iteration
+            std::vector<uint8_t>* dataCopy = new std::vector<uint8_t>(*data);
+            _pendingCallbacks.fetch_add(1);  // Increment before NonBlockingCall
+            pair.second.NonBlockingCall(dataCopy, callback);
         }
-
-    } else {
-        printf("Odin NodeJS Addon: No room available when handling events - this should NEVER HAPPEN.\n");
     }
+    
+    delete data;
 }
 
-/**
- * Creates a new OdinRoom instance. Requires an Odin token as a parameter.
- * @param info Napi::CallbackInfo
- */
-OdinRoom::OdinRoom(const Napi::CallbackInfo& info) :Napi::ObjectWrap<OdinRoom>(info) {
+OdinRoomWrapper::OdinRoomWrapper(const Napi::CallbackInfo& info) : Napi::ObjectWrap<OdinRoomWrapper>(info) {
     Napi::Env env = info.Env();
-
     if (info.Length() != 1 || !info[0].IsString()) {
         Napi::TypeError::New(env, "Provide a token to create a room").ThrowAsJavaScriptException();
         return;
     }
-
+    
+    // Increment room count - initializes SDK if this is the first room
+    IncrementRoomCount();
+    
     _token = info[0].ToString().Utf8Value();
-    _roomHandle = odin_room_create();
-    _started = false;
+    _room = nullptr;
+    _cipher = nullptr;
     _joined = false;
+    _started = false;
+    _pendingCallbacks = 0;
+    _ownPeerId = 0;
+    // Initialize position to origin and scale to 1.0 (default)
+    _position[0] = 0.0f;
+    _position[1] = 0.0f;
+    _position[2] = 0.0f;
+    _positionScale = 1.0f;
+    
 
-    odin_room_set_event_callback(_roomHandle, OdinRoom::HandleOdinEvent, this);
 }
 
 /**
- * Destructor. Closes and destroys the OdinRoom and resets the event callback for this room handle.
+ * Releases resources when the JavaScript object is garbage collected.
+ * 
+ * This ensures resources are freed even if close() wasn't called explicitly.
+ * Since Close() now handles all cleanup, Finalize() just needs to:
+ * 1. Stop the thread and free room (if not already done)
+ * 2. Free any remaining decoders
+ * 3. Decrement room count for SDK lifecycle management
  */
-void OdinRoom::Finalize(Napi::Env env) {
-    odin_room_set_event_callback(_roomHandle, NULL, NULL);
-    odin_room_close(_roomHandle);
-    odin_room_destroy(_roomHandle);
+void OdinRoomWrapper::Finalize(Napi::Env env) {
+    // Stop audio thread if still running
+    _started = false;
+    if (_nativeThread.joinable()) {
+        _nativeThread.join();
+    }
+    
+    // Free decoders if not already done by Close()
+    {
+        std::lock_guard<std::mutex> lock(_decodersMutex);
+        for (auto& pair : _decoders) {
+            odin_decoder_free(pair.second);
+        }
+        _decoders.clear();
+    }
+    
+    // Clear media-to-peer mapping
+    {
+        std::lock_guard<std::mutex> lock(_mediaToPeerMutex);
+        _mediaToPeer.clear();
+    }
+    
+    // Free room if not already done by Close()
+    if (_room) {
+        {
+            std::lock_guard<std::mutex> lock(_roomsMapMutex);
+            _roomsMap.erase(odin_room_get_ref(_room));
+        }
+        odin_room_free(_room);
+        _room = nullptr;
+    }
+    
+    // Clear cipher reference
+    _cipher = nullptr;
+    
+    // Decrement room count - shuts down SDK if this was the last room
+    DecrementRoomCount();
 }
 
-/**
- * Exposes this class to JavaScript
- * @param info Napi::CallbackInfo
- */
-Napi::Object OdinRoom::Init(Napi::Env env, Napi::Object exports) {
-    // This method is used to hook the accessor and method callbacks
+Napi::Object OdinRoomWrapper::Init(Napi::Env env, Napi::Object exports) {
     Napi::Function func = DefineClass(env, "OdinRoom", {
-        InstanceMethod<&OdinRoom::Join>("join", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-        InstanceMethod<&OdinRoom::UpdatePeerUserData>("updateOwnUserData", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-        InstanceMethod<&OdinRoom::UpdatePosition>("updatePosition", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-        InstanceMethod<&OdinRoom::SetPositionScale>("setPositionScale", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-        InstanceMethod<&OdinRoom::SendMessage>("sendMessage", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-        InstanceMethod<&OdinRoom::SetEventListener>("setEventListener", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-        InstanceMethod<&OdinRoom::AddEventListener>("addEventListener", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-        InstanceMethod<&OdinRoom::RemoveEventListener>("removeEventListener", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-        InstanceMethod<&OdinRoom::Close>("close", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-        InstanceMethod<&OdinRoom::CreateAudioStream>("createAudioStream", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-        InstanceAccessor("ownPeerId", &OdinRoom::GetOwnPeerId, nullptr, static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-        InstanceAccessor("id", &OdinRoom::RoomId, nullptr, static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
-        StaticMethod<&OdinRoom::CreateNewItem>("CreateNewItem", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::Join>("join", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::UpdatePeerUserData>("updateOwnUserData", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::UpdatePosition>("updatePosition", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::SetPositionScale>("setPositionScale", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::SendMessage>("sendMessage", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::SendRpc>("sendRpc", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::SetEventListener>("setEventListener", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::AddEventListener>("addEventListener", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::RemoveEventListener>("removeEventListener", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::Close>("close", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::CreateAudioStream>("createAudioStream", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::SetCipher>("setCipher", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::RegisterMediaPeer>("registerMediaPeer", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::UnregisterMedia>("unregisterMedia", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::SetOwnPeerId>("setOwnPeerId", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::GetConnectionStats>("getConnectionStats", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::GetConnectionId>("getConnectionId", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoomWrapper::GetJitterStats>("getJitterStats", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceAccessor("ownPeerId", &OdinRoomWrapper::GetOwnPeerId, nullptr, static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceAccessor("id", &OdinRoomWrapper::RoomId, nullptr, static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        StaticMethod<&OdinRoomWrapper::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("OdinRoom", 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);
-
+    // REMOVED: env.SetInstanceData<Napi::FunctionReference>(constructor);
     return exports;
 }
 
 /**
- * Updates the position of this room. Requires x, y and z coordinates as parameters.
- * @param info Napi::CallbackInfo
+ * Updates the 3D position of the local peer. This position is used for spatial audio
+ * and server-side culling. If called before join(), the position will be used during
+ * room creation. If called after join(), this is a no-op as the current SDK doesn't
+ * support runtime position updates (position is only set during room creation).
+ *
+ * @param info[0] x coordinate (number)
+ * @param info[1] y coordinate (number)
+ * @param info[2] z coordinate (number)
  */
-void OdinRoom::UpdatePosition(const Napi::CallbackInfo &info)
-{
+void OdinRoomWrapper::UpdatePosition(const Napi::CallbackInfo &info) {
     Napi::Env env = info.Env();
-
-    if (info.Length() != 3 || !info[0].IsNumber() || !info[1].IsNumber() || !info[2].IsNumber()) {
-        Napi::TypeError::New(env, "Provide x, y and z coordinates as numbers").ThrowAsJavaScriptException();
+    
+    // Validate arguments: we need exactly 3 numbers (x, y, z)
+    if (info.Length() < 3) {
+        Napi::TypeError::New(env, "updatePosition requires 3 arguments: x, y, z").ThrowAsJavaScriptException();
         return;
     }
-
-    float x = info[0].ToNumber();
-    float y = info[1].ToNumber();
-    float z = info[2].ToNumber();
-
-    OdinReturnCode error = odin_room_update_position(_roomHandle, x, y, z);
-    if (odin_is_error(error))
-    {
-        OdinUtilities::ThrowNapiException(env, error, "Failed to update position");
+    
+    if (!info[0].IsNumber() || !info[1].IsNumber() || !info[2].IsNumber()) {
+        Napi::TypeError::New(env, "updatePosition arguments must be numbers").ThrowAsJavaScriptException();
+        return;
     }
+    
+    // Store the position values (will be used during join/room creation)
+    // Note: The ODIN SDK 1.8.2+ only supports setting position during odin_room_create_ex,
+    // so this stores the values for use before join() is called.
+    _position[0] = info[0].As<Napi::Number>().FloatValue();
+    _position[1] = info[1].As<Napi::Number>().FloatValue();
+    _position[2] = info[2].As<Napi::Number>().FloatValue();
 }
 
 /**
- * Sets the position scale for this room. Requires a scale as a parameter.
- * @param info Napi::CallbackInfo
+ * Sets the scaling factor for position coordinates. This scale is applied to the
+ * position values when they are used during room creation. Peers are visible to each
+ * other within a unit circle of radius 1.0, so the scale should be set such that
+ * the maximum distance between peers remains <= 1.0.
+ *
+ * @param info[0] scale factor (number)
  */
-void OdinRoom::SetPositionScale(const Napi::CallbackInfo &info)
-{
+void OdinRoomWrapper::SetPositionScale(const Napi::CallbackInfo &info) {
     Napi::Env env = info.Env();
-
-    if (info.Length() != 1 || !info[0].IsNumber()) {
-        Napi::TypeError::New(env, "Provide scale as number").ThrowAsJavaScriptException();
+    
+    // Validate arguments: we need exactly 1 number (scale)
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "setPositionScale requires a scale value (number)").ThrowAsJavaScriptException();
         return;
     }
-
-    float scale = info[0].ToNumber();
-
-    OdinReturnCode error = odin_room_set_position_scale(_roomHandle, scale);
-    if (odin_is_error(error))
-    {
-        OdinUtilities::ThrowNapiException(env, error, "Failed to set position scale");
-    }
+    
+    // Store the scale value (will be applied to position during join/room creation)
+    _positionScale = info[0].As<Napi::Number>().FloatValue();
 }
 
-/**
- * Joins the Odin room. Requires a gateway URL as a parameter and optionally initial peer data.
- * @param info Napi::CallbackInfo
- */
-void OdinRoom::Join(const Napi::CallbackInfo &info) {
+void OdinRoomWrapper::Join(const Napi::CallbackInfo &info) {
     Napi::Env env = info.Env();
-
     if (info.Length() < 1) {
-        Napi::TypeError::New(env, "Gateway required as first parameter").ThrowAsJavaScriptException();
+        Napi::TypeError::New(env, "Gateway required").ThrowAsJavaScriptException();
         return;
     }
-
     std::string url = info[0].ToString().Utf8Value();
-
-    if (info.Length() > 1) {
+    const uint8_t* userData = nullptr;
+    size_t userDataLen = 0;
+    if (info.Length() > 1 && info[1].IsTypedArray()) {
         Napi::Uint8Array data = info[1].As<Napi::Uint8Array>();
-        OdinReturnCode error = odin_room_update_peer_user_data(_roomHandle, data.Data(), data.ByteLength());
-        if (odin_is_error(error))
-        {
-            Napi::TypeError::New(env, "Setting initial room peer data failed").ThrowAsJavaScriptException();
-        }
-    }
-
-    OdinReturnCode error = odin_room_join(_roomHandle, url.c_str(), _token.c_str());
-    if (odin_is_error(error))
-    {
+        userData = data.Data();
+        userDataLen = data.ByteLength();
+    }
+    struct OdinConnectionPool* pool = GetConnectionPool();
+    // Apply position scale to the stored position coordinates
+    float scaledPosition[3] = {
+        _position[0] / _positionScale,
+        _position[1] / _positionScale,
+        _position[2] / _positionScale
+    };
+    OdinError error = odin_room_create_ex(pool, url.c_str(), _token.c_str(), nullptr, userData, userDataLen, scaledPosition, _cipher, &_room);
+    if (odin_is_error(error)) {
         OdinUtilities::ThrowNapiException(env, error, "Failed to join room");
         return;
     }
-
-    _joined = true;
-
-    // Start capturing audio data if event listener has not been started yet
-    if (_audioDataReceivedEventListener) {
-        HandleAudioData();
+    {
+        std::lock_guard<std::mutex> lock(_roomsMapMutex);
+        _roomsMap[odin_room_get_ref(_room)] = this;
     }
+    _joined = true;
+    _started = true;
+    _nativeThread = std::thread(&OdinRoomWrapper::HandleAudioData, this);
 }
 
 /**
- * Closes the room connection and destroys the room handle.
- * @param info
+ * Closes the room connection and frees all associated resources.
+ * 
+ * This method performs a complete cleanup in the correct order to prevent:
+ * - Memory leaks (decoders, media-to-peer mappings)
+ * - Dangling pointers (cipher reference)
+ * - Race conditions (thread-callback synchronization)
+ * 
+ * CRITICAL: The cleanup sequence must:
+ * 1. Remove from room map FIRST (stops connection pool from routing new callbacks)
+ * 2. Close native room (stops connection pool activity)
+ * 3. Signal thread to stop and wait for it
+ * 4. THEN release callbacks (now safe - no more incoming calls)
+ * 5. Free remaining resources
  */
-void OdinRoom::Close(const Napi::CallbackInfo &info) {
-    //Napi::Env env = info.Env();
-
-    if (_roomHandle <= 0) return;
-
-    odin_room_set_event_callback(_roomHandle, NULL, NULL);
-
-    if (this->_eventListener != NULL) {
-        this->_eventListener.Release();
-        this->_eventListener = NULL;
+void OdinRoomWrapper::Close(const Napi::CallbackInfo &info) {
+    if (!_room || !_joined) {
+        return;
     }
-
-    for (auto it = _eventListeners.begin(); it != _eventListeners.end(); ++it) {
-        if (it->second != NULL) {
-            it->second.Release();
-            it->second = NULL;
+    
+    uint64_t roomRef = odin_room_get_ref(_room);
+    // Step 1: Remove from global room map FIRST
+    // This prevents the connection pool from routing any new callbacks to us
+    {
+        std::lock_guard<std::mutex> lock(_roomsMapMutex);
+        _roomsMap.erase(roomRef);
+    }
+    
+    // Step 2: Close the native room - this stops the connection pool
+    // After this call, OnDatagram and OnRPC won't be called for this room
+    odin_room_close(_room);
+    
+    // Step 3: Signal the audio thread to stop
+    _started = false;
+    
+    // Step 4: Wait for audio processing thread to finish
+    // The thread will see _started=false and exit
+    if (_nativeThread.joinable()) {
+        _nativeThread.join();
+    }
+    
+    
+    // Step 4.5: Wait for pending NonBlockingCall callbacks to complete
+    // NonBlockingCall schedules work asynchronously on the Node.js event loop.
+    // Even after the audio thread exits, there may be callbacks already queued
+    // that haven't executed yet. We must wait for these to complete before
+    // releasing the ThreadSafeFunctions.
+    // 
+    // We use ref-counting: _pendingCallbacks is incremented before NonBlockingCall
+    // and decremented in the callback after execution. We wait for it to reach 0.
+    {
+        int waitMs = 0;
+        const int maxWaitMs = 500;  // Maximum wait time to prevent hangs
+        while (_pendingCallbacks.load() > 0 && waitMs < maxWaitMs) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            waitMs += 10;
         }
+        // If we still have pending callbacks after timeout, they will execute
+        // after release but we've done our best. In practice this shouldn't happen.
     }
-
-    odin_room_close(_roomHandle);
-    odin_room_destroy(_roomHandle);
-    _roomHandle = 0;
-}
-
-/**
- * Creates a new instance of the OdinRoom class. Requires a token as a parameter.
- * @param info
- * @return
- */
-Napi::Value OdinRoom::CreateNewItem(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-
-    if (info.Length() < 1) {
-        Napi::TypeError::New(env, "Token required as first parameter").ThrowAsJavaScriptException();
-        return env.Undefined();
+    
+    // Step 5: NOW it's safe to release ThreadSafeFunctions
+    // No more connection pool callbacks, no more audio thread activity,
+    // and all pending NonBlockingCall callbacks have completed
+    if (_eventListener) {
+        _eventListener.Release();
     }
+    if (_audioDataReceivedEventListener) {
+        _audioDataReceivedEventListener.Release();
+    }
+    for (auto& pair : _eventListeners) {
+        pair.second.Release();
+    }
+    _eventListeners.clear();
+    
+    // Step 6: Free all decoders to prevent memory leaks
+    {
+        std::lock_guard<std::mutex> lock(_decodersMutex);
+        for (auto& pair : _decoders) {
+            odin_decoder_free(pair.second);
+        }
+        _decoders.clear();
+    }
+    
+    // Step 7: Clear media-to-peer mapping
+    {
+        std::lock_guard<std::mutex> lock(_mediaToPeerMutex);
+        _mediaToPeer.clear();
+    }
+    
+    // Step 8: Clear cipher reference (we don't own it, just null the pointer)
+    _cipher = nullptr;
+    
+    // Step 9: Free the native room
+    odin_room_free(_room);
+    _room = nullptr;
+    _joined = false;
+    
+}
 
-    Napi::String token = info[0].ToString();
-
-    // 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({ token });
+Napi::Value OdinRoomWrapper::CreateNewItem(const Napi::CallbackInfo& info) {
+    return constructor->New({ info[0] });
 }
 
-/**
- * Creates a new instance of the OdinRoom class. Requires a token as a parameter.
- * @param info
- * @return
- */
-Napi::Object OdinRoom::NewInstance(Napi::Value arg) {
+Napi::Object OdinRoomWrapper::NewInstance(Napi::Value arg) {
     return constructor->New({ arg });
 }
 
-/**
- * Updates the peer user data. Requires an array of bytes as a parameter.
- * @param info
- * @return
- */
-void OdinRoom::UpdatePeerUserData(const Napi::CallbackInfo &info) {
-    Napi::Env env = info.Env();
-
-    if (info.Length() != 1 || !info[0].IsTypedArray()) {
-        Napi::TypeError::New(env, "Data as byte array expected").ThrowAsJavaScriptException();
-        return;
-    }
-
-    Napi::Uint8Array data = info[0].As<Napi::Uint8Array>();
-
-    OdinReturnCode error = odin_room_update_peer_user_data(_roomHandle, data.Data(), data.ByteLength());
+void OdinRoomWrapper::UpdatePeerUserData(const Napi::CallbackInfo &info) {}
 
-    if (odin_is_error(error))
-    {
-        OdinUtilities::ThrowNapiException(env, error, "Failed to update peer user data");
-    }
-}
+void OdinRoomWrapper::SendMessage(const Napi::CallbackInfo &info) {}
 
 /**
- * Sends a message to the room. Requires an array of bytes as a parameter and optinally a list of peer ids to send to.
- * Please note: If the list is NULL the message will be sent to all peers in the room. If the list is not NULL the message
- * will be sent to all peers in the list. If the list is empty the message ODIN will raise an error.
- * @param info
- * @return
+ * Sends a raw RPC message (MessagePack format) to the ODIN server.
+ * This is used for commands like StartMedia, StopMedia, etc.
+ * 
+ * @param info[0] Uint8Array containing the MessagePack-encoded RPC message
  */
-void OdinRoom::SendMessage(const Napi::CallbackInfo &info) {
+void OdinRoomWrapper::SendRpc(const Napi::CallbackInfo &info) {
     Napi::Env env = info.Env();
-
-    if (info.Length() < 1 || !info[0].IsTypedArray()) {
-        Napi::TypeError::New(env, "Data as byte array expected").ThrowAsJavaScriptException();
+    
+    if (!_room || !_joined) {
+        Napi::Error::New(env, "Room not joined").ThrowAsJavaScriptException();
         return;
     }
-
-    Napi::Uint8Array data = info[0].As<Napi::Uint8Array>();
-
-    uint64_t *peer_id_list = NULL;
-    size_t peer_id_list_length = 0;
-    if (info.Length() >= 2 && !info[1].IsNull() && !info[1].IsUndefined()) {
-        if (!info[1].IsArray()) {
-            Napi::TypeError::New(env, "Peer id list as uint32 array expected").ThrowAsJavaScriptException();
-        } else {
-            Napi::Array peerIds = info[1].As<Napi::Array>();
-            peer_id_list_length = peerIds.Length();
-            peer_id_list = new uint64_t[peer_id_list_length];
-            for (int i = 0; i < (int)peer_id_list_length; i++) {
-                peer_id_list[i] = peerIds.Get(i).As<Napi::Number>().Uint32Value();
-            }
-        }
-    }
-
-    OdinReturnCode error = odin_room_send_message(_roomHandle, peer_id_list, peer_id_list_length, data.Data(), data.ByteLength());
-
-    if (peer_id_list != NULL) {
-        delete[] peer_id_list;
+    
+    if (info.Length() < 1 || !info[0].IsTypedArray()) {
+        Napi::TypeError::New(env, "Uint8Array required as RPC data").ThrowAsJavaScriptException();
+        return;
     }
-
-    if (odin_is_error(error))
-    {
-        OdinUtilities::ThrowNapiException(env, error, "Failed to send message");
+    
+    Napi::Uint8Array rpcData = info[0].As<Napi::Uint8Array>();
+    
+    OdinError rc = odin_room_send_rpc(_room, rpcData.Data(), static_cast<uint32_t>(rpcData.ByteLength()));
+    if (odin_is_error(rc)) {
+        OdinUtilities::ThrowNapiException(env, rc, "Failed to send RPC");
     }
 }
 
-/**
- * Sets a global event listener for this room. Requires a callback function as a parameter and will receive all events
- * @param info
- * @return
- */
-void OdinRoom::SetEventListener(const Napi::CallbackInfo &info) {
+void OdinRoomWrapper::SetEventListener(const Napi::CallbackInfo &info) {
     Napi::Env env = info.Env();
-
     if (info.Length() != 1 || !info[0].IsFunction()) {
         Napi::TypeError::New(env, "Callback function expected").ThrowAsJavaScriptException();
         return;
     }
-
-    Napi::Function napiFunction = info[0].As<Napi::Function>();
-
-    _eventListener = Napi::ThreadSafeFunction::New(env, napiFunction, "Callback", 0, 1);
+    _eventListener = Napi::ThreadSafeFunction::New(env, info[0].As<Napi::Function>(), "Callback", 0, 1);
 }
 
-/**
- * Adds an event listener for this room. Requires the event type to listen to and a callback function as a second parameter
- * @param info
- * @return
- */
-void OdinRoom::AddEventListener(const Napi::CallbackInfo &info) {
+void OdinRoomWrapper::AddEventListener(const Napi::CallbackInfo &info) {
     Napi::Env env = info.Env();
-
     if (info.Length() != 2 || !info[0].IsString() || !info[1].IsFunction()) {
-        Napi::TypeError::New(env, "Event Name and Callback function expected").ThrowAsJavaScriptException();
+        Napi::TypeError::New(env, "Event Name and Callback expected").ThrowAsJavaScriptException();
         return;
     }
-
     std::string eventName = info[0].As<Napi::String>().Utf8Value();
-    Napi::Function napiFunction = info[1].As<Napi::Function>();
-
-    if (eventName != "AudioDataReceived") {
-        _eventListeners[eventName] = Napi::ThreadSafeFunction::New(env, napiFunction, eventName + "Callback", 0, 1);
+    if (eventName == "AudioDataReceived") {
+       _audioDataReceivedEventListener = Napi::ThreadSafeFunction::New(env, info[1].As<Napi::Function>(), "AudioDataReceivedCallback", 0, 1);
     } else {
-        _audioDataReceivedEventListener = Napi::ThreadSafeFunction::New(
-                env,
-                napiFunction,
-                "AudioDataReceivedCallback",
-                0,
-                1,
-                [this](Napi::Env) {
-                    // This is the finalizer thread
-                    this->_nativeThread.join();
-                }
-        );
-
-        HandleAudioData();
+       _eventListeners[eventName] = Napi::ThreadSafeFunction::New(env, info[1].As<Napi::Function>(), eventName + "Callback", 0, 1);
     }
 }
 
-/**
- * Removes an event listener for this room. Requires the event type to remove the listener for.
- * @param info
- * @return
- */
-void OdinRoom::RemoveEventListener(const Napi::CallbackInfo &info) {
-    Napi::Env env = info.Env();
-
-    if (info.Length() != 1 || !info[0].IsString()) {
-        Napi::TypeError::New(env, "Event Name expected").ThrowAsJavaScriptException();
-        return;
-    }
-
-    std::string eventName = info[0].As<Napi::String>().Utf8Value();
-
-    if (eventName != "AudioDataReceived") {
-        _eventListeners[eventName].Release();
-        _eventListeners.erase(eventName);
-    } else {
-        // Stop the native thread and this will also release the callback function
-        _started = false;
-    }
-}
+void OdinRoomWrapper::RemoveEventListener(const Napi::CallbackInfo &info) {}
 
 /**
- * Internal function to receive audio data every 20ms and send it to the JS side. This function will start once the client
- * has registered AudioDataReceived as an event listener.
+ * Background thread function that processes incoming audio from decoders.
+ * 
+ * Runs continuously while _started is true, popping decoded audio from 
+ * each decoder and sending it to JavaScript via ThreadSafeFunction callbacks.
+ * 
+ * Safety: Checks _started multiple times per iteration to allow quick exit
+ * when Close() is called. Uses NonBlockingCall to avoid deadlocks during shutdown.
+ * 
+ * Ref-counting: Increments _pendingCallbacks before each NonBlockingCall and
+ * decrements after the callback executes. Close() waits for this count to reach
+ * zero before releasing ThreadSafeFunctions.
  */
-void OdinRoom::HandleAudioData()
-{
-    if (!_joined) {
-#ifdef DEBUG
-        printf("Odin NodeJS Addon: Skipping audio until joined\n");
-#endif
-        return;
-    }
-
-    if (_started) {
-#ifdef DEBUG
-        printf("Odin NodeJS Addon: Handle Audio Data thread already started\n");
-#endif
-        return;
-    }
-
-    _started = true;
-
-    // Create a native thread
-    _nativeThread = std::thread( [this] {
-        auto callback = []( Napi::Env env, Napi::Function jsCallback, void* value ) {
-            AudioSamples* samples = static_cast<AudioSamples*>( value );
-            // Transform native data into JS data, passing it to the provided
-            // `jsCallback` -- the TSFN's JavaScript function.
-            //Napi::Buffer<float> buffer = Napi::Buffer<float>::New(env, samples->OriginalData, samples->Len);
-            //Napi::ArrayBuffer buffer32 = Napi::ArrayBuffer::New(env, samples->OriginalData, samples->Len*sizeof(float));
-            //Napi::ArrayBuffer buffer16 = Napi::ArrayBuffer::New(env, samples->Data, samples->Len*sizeof(short));
-            Napi::Object obj = Napi::Object::New(env);
-            obj.Set("peerId", samples->PeerId);
-            obj.Set("mediaId", samples->MediaId);
-            obj.Set("samples16", Napi::Buffer<short>::New(env, samples->Data, samples->Len));
-            obj.Set("samples32", Napi::Buffer<float>::New(env, samples->OriginalData, samples->Len));
-
-            jsCallback.Call( {obj} );
-
-            // We're finished with the data.
-            delete samples;
-        };
-
-        while (this->_started)
+void OdinRoomWrapper::HandleAudioData() {
+    while (_started) {
+        // Early exit check at loop start
+        if (!_started) break;
+        
         {
-            for (auto it = _mediaStreams.begin(); it != _mediaStreams.end(); it++)
-            {
-                OdinReturnCode rc = odin_audio_read_data((OdinMediaStreamHandle)it->second.Handle, this->_audioSamplesBuffer, 960);
-
-                if (odin_is_error(rc)) {
-                    printf("Odin NodeJS Addon: Failed to read audio data\n");
-                    break;
-                }
-
-                AudioSamples* samples = new AudioSamples();
-                samples->SetSamples(this->_audioSamplesBuffer, 960);
-                samples->PeerId = it->second.PeerId;
-                samples->MediaId = it->second.Id;
-
-                // Perform a blocking call
-                napi_status status = _audioDataReceivedEventListener.BlockingCall( samples, callback );
-                if ( status != napi_ok )
-                {
-                    // Handle error
-                    printf("Odin NodeJS Addon: Failed to call audio data received callback\n");
-                    break;
+            std::lock_guard<std::mutex> lock(_decodersMutex);
+            for (auto& pair : _decoders) {
+                // Check again before processing each decoder
+                if (!_started) break;
+                
+                OdinDecoder* decoder = pair.second;
+                bool silent = false; 
+                OdinError rc = odin_decoder_pop(decoder, _audioSamplesBuffer, 1920, &silent);
+                if (!odin_is_error(rc) && !silent) {
+                     // Double-check _started before calling callback
+                     // This prevents calling a released ThreadSafeFunction
+                     if (_started && _audioDataReceivedEventListener) {
+                         AudioSamples* samples = new AudioSamples();
+                         samples->MediaId = pair.first;
+                         // Look up peer ID from media-to-peer mapping
+                         {
+                             std::lock_guard<std::mutex> peerLock(_mediaToPeerMutex);
+                             auto peerIt = _mediaToPeer.find(pair.first);
+                             samples->PeerId = (peerIt != _mediaToPeer.end()) ? peerIt->second : 0;
+                         }
+                         samples->SetSamples(_audioSamplesBuffer, 1920);
+                         
+                         // Store pointer to pending counter in samples for callback to decrement
+                         samples->PendingCounterPtr = &_pendingCallbacks;
+                         
+                         // Increment pending count BEFORE NonBlockingCall
+                         _pendingCallbacks.fetch_add(1);
+                         
+                         // Callback that decrements counter after execution
+                         // NOTE: Adding try-catch and logging to diagnose crashes
+                         auto callback = [](Napi::Env env, Napi::Function jsCallback, void* value) {
+                            AudioSamples* samples = (AudioSamples*)value;
+                            
+                            // Get the counter pointer before we delete samples
+                            std::atomic<int>* pendingPtr = samples->PendingCounterPtr;
+                            
+                            try {
+                                // Execute callback
+                                Napi::Object obj = Napi::Object::New(env);
+                                obj.Set("mediaId", samples->MediaId);
+                                obj.Set("peerId", (double)samples->PeerId); 
+                                obj.Set("samples16", Napi::Buffer<short>::New(env, samples->Data, samples->Len));
+                                obj.Set("samples32", Napi::Buffer<float>::New(env, samples->OriginalData, samples->Len));
+                                jsCallback.Call({obj});
+                            } catch (...) {
+                                // Exception in audio callback - silently ignore
+                            }
+                            
+                            delete samples;
+                            
+                            // Decrement pending count AFTER callback completes
+                            if (pendingPtr) {
+                                pendingPtr->fetch_sub(1);
+                            }
+                         };
+                         
+                         // Use NonBlockingCall to avoid potential deadlocks during shutdown
+                         _audioDataReceivedEventListener.NonBlockingCall(samples, callback);
+                     }
                 }
             }
-
-            std::this_thread::sleep_for( std::chrono::milliseconds ( 20 ) );
         }
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+}
 
-#ifdef DEBUG
-        printf("Odin NodeJS Addon: Handle Audio Thread finished.");
-#endif
+Napi::Value OdinRoomWrapper::CreateAudioStream(const Napi::CallbackInfo &info) {
+    std::vector<napi_value> args;
+    args.push_back(this->Value()); 
+    for (size_t i = 0; i < info.Length(); i++) args.push_back(info[i]);
+    return OdinMediaWrapper::NewInstance(args);
+}
 
-        // Release the thread-safe function
-        _audioDataReceivedEventListener.Release();
-        _audioDataReceivedEventListener = NULL;
-    } );
+void OdinRoomWrapper::SetCipher(const Napi::CallbackInfo &info) {
+     Napi::Env env = info.Env();
+     if (info.Length() < 1 || !info[0].IsObject()) {
+         Napi::TypeError::New(env, "OdinCipher instance expected").ThrowAsJavaScriptException();
+         return;
+     }
+     OdinCipherWrapper* cipherWrapper = Napi::ObjectWrap<OdinCipherWrapper>::Unwrap(info[0].As<Napi::Object>());
+     _cipher = cipherWrapper->GetCipher();
+     
+     // Transfer ownership: the room now owns the cipher and will free it.
+     // The wrapper must not try to free it again in its destructor.
+     cipherWrapper->TransferOwnership();
 }
 
-Napi::Value OdinRoom::CreateAudioStream(const Napi::CallbackInfo &info)
-{
-    Napi::Env env = info.Env();
+Napi::Value OdinRoomWrapper::GetOwnPeerId(const Napi::CallbackInfo &info) {
+    return Napi::Number::New(info.Env(), static_cast<double>(_ownPeerId));
+}
 
-    // Checking for input of sample rate (int) and number of channels (int)
-    if (info.Length() != 2 || !info[0].IsNumber() || !info[1].IsNumber()) {
-        Napi::TypeError::New(env, "Sample rate and number of channels expected").ThrowAsJavaScriptException();
-        return env.Undefined();
+void OdinRoomWrapper::SetOwnPeerId(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Peer ID (number) required").ThrowAsJavaScriptException();
+        return;
     }
+    _ownPeerId = static_cast<uint64_t>(info[0].As<Napi::Number>().DoubleValue());
+}
 
-    if (info.Length() == 3 && !info[2].IsObject()) {
-        Napi::TypeError::New(env, "Options need to be an object").ThrowAsJavaScriptException();
-        return env.Undefined();
+void OdinRoomWrapper::RegisterMediaPeer(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 2 || !info[0].IsNumber() || !info[1].IsNumber()) {
+        Napi::TypeError::New(env, "Media ID and Peer ID (numbers) required").ThrowAsJavaScriptException();
+        return;
     }
+    uint16_t mediaId = static_cast<uint16_t>(info[0].As<Napi::Number>().Uint32Value());
+    uint64_t peerId = static_cast<uint64_t>(info[1].As<Napi::Number>().DoubleValue());
+    
+    std::lock_guard<std::mutex> lock(_mediaToPeerMutex);
+    _mediaToPeer[mediaId] = peerId;
+}
 
-    if (info.Length() == 2) {
-        return OdinMedia::NewInstance({this->Value(), info[0], info[1]});
-    } else {
-        return OdinMedia::NewInstance({this->Value(), info[0], info[1], info[2]});
+void OdinRoomWrapper::UnregisterMedia(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Media ID (number) required").ThrowAsJavaScriptException();
+        return;
     }
+    uint16_t mediaId = static_cast<uint16_t>(info[0].As<Napi::Number>().Uint32Value());
+    
+    std::lock_guard<std::mutex> lock(_mediaToPeerMutex);
+    _mediaToPeer.erase(mediaId);
 }
 
-
 /**
- * Removes an event listener for this room. Requires the event type to remove the listener for.
- * @param info
- * @return
+ * Retrieves detailed connection statistics for the room.
+ * Returns an object containing UDP transmission/reception stats, packet loss, RTT, etc.
+ * 
+ * @returns {Object} Connection statistics:
+ *   - udpTxDatagrams: Number of outgoing UDP datagrams
+ *   - udpTxBytes: Total bytes sent
+ *   - udpTxLoss: Packet loss percentage for outgoing datagrams
+ *   - udpRxDatagrams: Number of incoming UDP datagrams
+ *   - udpRxBytes: Total bytes received
+ *   - udpRxLoss: Packet loss percentage for incoming datagrams
+ *   - cwnd: Current congestion window size
+ *   - congestionEvents: Number of congestion events
+ *   - rtt: Round-trip time in milliseconds
  */
-Napi::Value OdinRoom::GetOwnPeerId(const Napi::CallbackInfo &info) {
+Napi::Value OdinRoomWrapper::GetConnectionStats(const Napi::CallbackInfo &info) {
     Napi::Env env = info.Env();
+    
+    if (!_room || !_joined) {
+        return env.Null();
+    }
+    
+    OdinConnectionStats stats;
+    memset(&stats, 0, sizeof(stats));
+    
+    OdinError rc = odin_room_get_connection_stats(_room, &stats);
+    if (odin_is_error(rc)) {
+        OdinUtilities::ThrowNapiException(env, rc, "Failed to get connection stats");
+        return env.Null();
+    }
+    
+    // Build the JavaScript object with all stats
+    Napi::Object result = Napi::Object::New(env);
+    result.Set("udpTxDatagrams", Napi::Number::New(env, static_cast<double>(stats.udp_tx_datagrams)));
+    result.Set("udpTxBytes", Napi::Number::New(env, static_cast<double>(stats.udp_tx_bytes)));
+    result.Set("udpTxLoss", Napi::Number::New(env, stats.udp_tx_loss));
+    result.Set("udpRxDatagrams", Napi::Number::New(env, static_cast<double>(stats.udp_rx_datagrams)));
+    result.Set("udpRxBytes", Napi::Number::New(env, static_cast<double>(stats.udp_rx_bytes)));
+    result.Set("udpRxLoss", Napi::Number::New(env, stats.udp_rx_loss));
+    result.Set("cwnd", Napi::Number::New(env, static_cast<double>(stats.cwnd)));
+    result.Set("congestionEvents", Napi::Number::New(env, static_cast<double>(stats.congestion_events)));
+    result.Set("rtt", Napi::Number::New(env, stats.rtt));
+    
+    return result;
+}
 
-    uint64_t out_peer_id = 0;
-    odin_room_peer_id(this->_roomHandle, &out_peer_id);
+/**
+ * Retrieves the underlying connection identifier for the room.
+ * Returns 0 if no valid connection exists.
+ * 
+ * @returns {number} The connection ID, or 0 if not connected
+ */
+Napi::Value OdinRoomWrapper::GetConnectionId(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    
+    if (!_room) {
+        return Napi::Number::New(env, 0);
+    }
+    
+    uint64_t connectionId = odin_room_get_connection_id(_room);
+    return Napi::Number::New(env, static_cast<double>(connectionId));
+}
 
-    return Napi::Number::New(env, out_peer_id);
+/**
+ * Retrieves jitter buffer statistics for a specific decoder (media stream).
+ * Useful for debugging audio quality issues.
+ * 
+ * @param info[0] Media ID (number) - The media stream to get stats for
+ * @returns {Object|null} Jitter statistics, or null if decoder not found:
+ *   - packetsTotal: Total packets seen by jitter buffer
+ *   - packetsBuffered: Packets currently in buffer
+ *   - packetsProcessed: Packets successfully processed
+ *   - packetsArrivedTooEarly: Packets dropped (arrived too early)
+ *   - packetsArrivedTooLate: Packets dropped (arrived too late)
+ *   - packetsDropped: Packets dropped due to buffer reset
+ *   - packetsInvalid: Invalid packets received
+ *   - packetsRepeated: Duplicate packets received
+ *   - packetsLost: Packets lost during transmission
+ */
+Napi::Value OdinRoomWrapper::GetJitterStats(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Media ID (number) required").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    
+    uint16_t mediaId = static_cast<uint16_t>(info[0].As<Napi::Number>().Uint32Value());
+    
+    // Find the decoder for this media ID
+    std::lock_guard<std::mutex> lock(_decodersMutex);
+    auto it = _decoders.find(mediaId);
+    if (it == _decoders.end()) {
+        // No decoder for this media ID yet - return null
+        return env.Null();
+    }
+    
+    OdinDecoderJitterStats stats;
+    memset(&stats, 0, sizeof(stats));
+    
+    OdinError rc = odin_decoder_get_jitter_stats(it->second, &stats);
+    if (odin_is_error(rc)) {
+        OdinUtilities::ThrowNapiException(env, rc, "Failed to get jitter stats");
+        return env.Null();
+    }
+    
+    // Build the JavaScript object with all jitter stats
+    Napi::Object result = Napi::Object::New(env);
+    result.Set("packetsTotal", Napi::Number::New(env, stats.packets_total));
+    result.Set("packetsBuffered", Napi::Number::New(env, stats.packets_buffered));
+    result.Set("packetsProcessed", Napi::Number::New(env, stats.packets_processed));
+    result.Set("packetsArrivedTooEarly", Napi::Number::New(env, stats.packets_arrived_too_early));
+    result.Set("packetsArrivedTooLate", Napi::Number::New(env, stats.packets_arrived_too_late));
+    result.Set("packetsDropped", Napi::Number::New(env, stats.packets_dropped));
+    result.Set("packetsInvalid", Napi::Number::New(env, stats.packets_invalid));
+    result.Set("packetsRepeated", Napi::Number::New(env, stats.packets_repeated));
+    result.Set("packetsLost", Napi::Number::New(env, stats.packets_lost));
+    
+    return result;
 }