@4players/odin-nodejs 0.10.3 → 0.11.1

package/cppsrc/odinroom.h

@@ -1,66 +1,116 @@
-//
-// Created by Phillip Schuster on 11.02.23.
-//
-
 #ifndef ODIN_NODEJS_ODINROOM_H
 #define ODIN_NODEJS_ODINROOM_H
 
 #include <napi.h>
 #include <odin.h>
+// Forward declaration instead of including odin_crypto.h
+struct OdinCipher;
 #include "utilities.h"
 #include <map>
 #include <thread>
+#include <mutex>
+#include <atomic>
 
-class OdinRoom : public Napi::ObjectWrap<OdinRoom> {
-    struct Media {
-        OdinMediaStreamHandle Handle;
-        uint16_t Id;
-        uint64_t PeerId;
-    };
+class OdinRoomWrapper : public Napi::ObjectWrap<OdinRoomWrapper> {
 
 public:
-    OdinRoom(const Napi::CallbackInfo& info); //Constructor to initialise
+    OdinRoomWrapper(const Napi::CallbackInfo& info);
     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 void HandleOdinEvent(OdinRoomHandle room, const OdinEvent *event, void *data);
-    static Napi::Object PrepareEventObject(Napi::Env env, const EventData *event);
-    static Napi::Object PrepareEventObjectTest(Napi::Env env, const OdinEvent *event);
-    OdinRoomHandle GetRoomHandle() const;
+    
+    // Callbacks for Connection Pool
+    static void OnDatagram(uint64_t room_ref, uint16_t media_id, const uint8_t *bytes, uint32_t bytes_length, void *user_data);
+    static void OnRPC(uint64_t room_ref, const uint8_t *bytes, uint32_t bytes_length, void *user_data);
+
+    struct OdinRoom* GetRoom() const { return _room; }
     static Napi::FunctionReference *constructor;
     static Napi::Object NewInstance(Napi::Value arg);
+    
+    // SDK lifecycle management - reference counting for proper initialization/shutdown
+    static void IncrementRoomCount();
+    static void DecrementRoomCount();
+    
+    // Internal handler called by static callbacks
+    void HandleDatagramInternal(uint16_t media_id, const uint8_t *bytes, uint32_t bytes_length);
+    void HandleRPCInternal(const uint8_t *bytes, uint32_t bytes_length);
+
+    struct OdinRoom* _room; 
+    
 private:
-    OdinRoomHandle _roomHandle;
+    struct OdinCipher* _cipher;
+    
+    // Static connection pool for all rooms
+    static struct OdinConnectionPool* _pool;
+    static std::map<uint64_t, OdinRoomWrapper*> _roomsMap;
+    static std::mutex _roomsMapMutex;
+
+    static struct OdinConnectionPool* GetConnectionPool();
+
     std::string _token;
-    Napi::ThreadSafeFunction _eventListener;
-    std::map<uint16_t, Media> _mediaStreams;
+    
+    std::map<uint16_t, struct OdinDecoder*> _decoders;
+    std::mutex _decodersMutex;
+    
+    // Mapping from media_id to peer_id (populated from JavaScript via MediaStarted events)
+    std::map<uint16_t, uint64_t> _mediaToPeer;
+    std::mutex _mediaToPeerMutex;
+    
+    // Own peer ID (set from JavaScript after joining)
+    uint64_t _ownPeerId;
+    
+    // Position coordinates (x, y, z) for spatial audio and server-side culling
+    // These are stored and used during odin_room_create_ex call in Join()
+    float _position[3];
+    
+    // Position scale factor - divides position coordinates to normalize to unit circle
+    float _positionScale;
 
     std::thread _nativeThread;
-    bool _started;
+    std::atomic<bool> _started;
+    
+    // Counter for pending NonBlockingCall callbacks
+    // Incremented before NonBlockingCall, decremented when callback completes
+    // Used to ensure all callbacks finish before releasing ThreadSafeFunctions
+    std::atomic<int> _pendingCallbacks;
+    
     bool _joined;
-    float _audioSamplesBuffer[960];
+    
+    float _audioSamplesBuffer[1920]; 
 
     std::map<std::string, Napi::ThreadSafeFunction> _eventListeners;
+    Napi::ThreadSafeFunction _eventListener; // Restored
     Napi::ThreadSafeFunction _audioDataReceivedEventListener;
 
     void Close(const Napi::CallbackInfo& info);
     void Join(const Napi::CallbackInfo& info);
     void UpdatePeerUserData(const Napi::CallbackInfo &info);
-    void SendMessage(const Napi::CallbackInfo &info);
+    void SendMessage(const Napi::CallbackInfo &info); 
+    void SendRpc(const Napi::CallbackInfo &info); 
+    
     void SetEventListener(const Napi::CallbackInfo &info);
     void AddEventListener(const Napi::CallbackInfo &info);
     void RemoveEventListener(const Napi::CallbackInfo &info);
     Napi::Value GetOwnPeerId(const Napi::CallbackInfo &info);
     Napi::Value RoomId(const Napi::CallbackInfo &info);
-    EventData* PrepareEventData(OdinEvent* event);
-    static uint16_t GetMediaIdFromHandle(OdinMediaStreamHandle handle);
-    void HandleAudioData();
+    void SetCipher(const Napi::CallbackInfo &info);
+    
+    // Methods for JavaScript to register media-to-peer mapping
+    void RegisterMediaPeer(const Napi::CallbackInfo &info);
+    void UnregisterMedia(const Napi::CallbackInfo &info);
+    void SetOwnPeerId(const Napi::CallbackInfo &info);
+    
+    void HandleAudioData(); 
     void UpdatePosition(const Napi::CallbackInfo &info);
-    void SetPositionScale(const Napi::CallbackInfo &info);
+    void SetPositionScale(const Napi::CallbackInfo &info); 
 
     Napi::Value CreateAudioStream(const Napi::CallbackInfo &info);
+    
+    // Stats and diagnostics methods
+    Napi::Value GetConnectionStats(const Napi::CallbackInfo &info);
+    Napi::Value GetConnectionId(const Napi::CallbackInfo &info);
+    Napi::Value GetJitterStats(const Napi::CallbackInfo &info);
 };
 
-
 #endif //ODIN_NODEJS_ODINROOM_H

package/cppsrc/utilities.cpp

@@ -1,102 +1,32 @@
 #include "utilities.h"
+#include <cstdio>
+#include <cstdarg>
 
 std::string string_format(const std::string fmt, ...) {
-    int size = ((int)fmt.size()) * 2 + 50;   // Use a rubric appropriate for your code
+    int size = ((int)fmt.size()) * 2 + 50;
     std::string str;
     va_list ap;
-    while (1) {     // Maximum two passes on a POSIX system...
+    while (1) {
         str.resize(size);
         va_start(ap, fmt);
         int n = vsnprintf((char *)str.data(), size, fmt.c_str(), ap);
         va_end(ap);
-        if (n > -1 && n < size) {  // Everything worked
+        if (n > -1 && n < size) {
             str.resize(n);
             return str;
         }
-        if (n > -1)  // Needed size returned
-            size = n + 1;   // For null char
+        if (n > -1)
+            size = n + 1;
         else
-            size *= 2;      // Guess at a larger size (OS specific)
+            size *= 2;
     }
     return str;
 }
 
-void OdinUtilities::ThrowNapiException(Napi::Env env, OdinReturnCode error, const char* message)
+void OdinUtilities::ThrowNapiException(Napi::Env env, OdinError error, const char* message)
 {
-    char buffer[512];
-    odin_error_format(error, buffer, sizeof(buffer));
-
-    std::string text = string_format("%s: %s", message, buffer);
+    const char* lastError = odin_error_get_last_error();
+    std::string text = string_format("%s: ErrorCode=%d Details=%s", message, (int)error, lastError ? lastError : "");
 
     Napi::TypeError::New(env, text.c_str()).ThrowAsJavaScriptException();
-}
-
-/**
- * @brief Returns a human-readable string representation for a specified connection state
- *
- * @param state    The room connection state to translate
- */
-const char* OdinUtilities::GetNameFromConnectionState(OdinRoomConnectionState state)
-{
-    switch (state)
-    {
-        case OdinRoomConnectionState_Connecting:
-            return "connecting";
-        case OdinRoomConnectionState_Connected:
-            return "connected";
-        case OdinRoomConnectionState_Disconnecting:
-            return "disconnecting";
-        case OdinRoomConnectionState_Disconnected:
-            return "disconnected";
-        default:
-            return "unknown";
-    }
-}
-
-/**
- * @brief Returns a human-readable string representation for a specified connection state change reason
- *
- * @param state    The room connection state change reason to translate
- */
-const char* OdinUtilities::GetNameFromConnectionStateChangeReason(OdinRoomConnectionStateChangeReason reason)
-{
-    switch (reason)
-    {
-        case OdinRoomConnectionStateChangeReason_ClientRequested:
-            return "client_request";
-        case OdinRoomConnectionStateChangeReason_ServerRequested:
-            return "server_request";
-        case OdinRoomConnectionStateChangeReason_ConnectionLost:
-            return "timeout";
-        default:
-            return "unknown";
-    }
-}
-
-/**
- * @brief Basic helper function to get the internal media ID from a specified handle
- *
- * @param handle    The media stream handle to get the ID from
- */
-uint16_t OdinUtilities::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;
-}
-
-
-void convert_float32_to_float16(const float *in_buffer, size_t in_buffer_len, short *out_buffer) {
-    for (size_t i = 0; i < in_buffer_len; i++) {
-        float f = in_buffer[i];
-// Clamp to [-1, 1] range
-        if (f > 1.0f) {
-            f = 1.0f;
-        } else if (f < -1.0f) {
-            f = -1.0f;
-        }
-// Convert to 16-bit float
-        int16_t f16 = (int16_t) (f * 32767.0f);
-        out_buffer[i] = f16;
-    }
 }

package/cppsrc/utilities.h

@@ -1,175 +1,60 @@
-#include <odin.h>
-#include <napi.h>
-
 #ifndef ODIN_NODEJS_UTILITIES_H
 #define ODIN_NODEJS_UTILITIES_H
 
+#include <odin.h>
+#include <napi.h>
+#include <string>
+#include <atomic>
+
 namespace OdinUtilities
 {
-    void ThrowNapiException(Napi::Env env, OdinReturnCode error, const char* message);
-    const char* GetNameFromConnectionState(OdinRoomConnectionState state);
-    const char* GetNameFromConnectionStateChangeReason(OdinRoomConnectionStateChangeReason reason);
-    uint16_t GetMediaIdFromHandle(OdinMediaStreamHandle handle);
+    void ThrowNapiException(Napi::Env env, OdinError error, const char* message);
 }
 
-/**
- * Event data base structure used to copy OdinEvent data as a base for sending events to JS side
- */
-struct EventData {
-    OdinEventTag Tag;
-    std::string Event;
-};
-
-/**
- * Event data structure used to copy OdinEvent data as a base for sending events to JS side including data
- */
-struct EventDataWithData: EventData
-{
-    const uint8_t *Data;
-    size_t DataLen;
-
-    void SetData(const uint8_t *data, size_t len)
-    {
-        Data = new uint8_t[len];
-        memcpy((void*)Data, data, len);
-        DataLen = len;
-    }
-
-    ~EventDataWithData()
-    {
-        delete[] Data;
-    }
-};
-
-/**
- * Event data structure used to copy The Joined event data
- */
-struct JoinedEventData: EventDataWithData
-{
-    std::string RoomId;
-    std::string UserId;
-    uint64_t PeerId;
-};
-
-/**
- * Event data structure used to copy The Left event data
- */
-struct PeerJoinedEventData: EventDataWithData
-{
-    uint64_t PeerId;
-    std::string UserId;
-};
-
-/**
- * Event data structure used to copy The PeerLeft event data
- */
-struct PeerLeftEventData: EventData
+inline bool odin_is_error(OdinError code)
 {
-    uint64_t PeerId;
-};
-
-/**
- * Event data structure used to copy The PeerUserDataChanged event data
- */
-struct PeerUserDataChangedEventData: EventDataWithData
-{
-    uint64_t PeerId;
-};
-
-/**
- * Event data structure used to copy The RoomUserDataChanged event data
- */
-struct RoomUserDataChangedEventData: EventDataWithData
-{
-
-};
-
-/**
- * Event data structure used to copy The MessageReceived event data
- */
-struct MessageReceivedEventData: EventDataWithData
-{
-    uint64_t PeerId;
-};
-
-/**
- * Event data structure used to copy The RoomConnectionStateChanged event data
- */
-struct RoomConnectionStateChangedEventData: EventData
-{
-    int State;
-    int Reason;
-    std::string StateName;
-    std::string ReasonName;
-};
-
-/**
- * Event data structure used to copy The MediaAdded event data
- */
-struct MediaAddedEventData: EventData
-{
-    uint64_t PeerId;
-    uint16_t MediaId;
-    OdinMediaStreamHandle MediaStreamHandle;
-};
-
-/**
- * Event data structure used to copy The MediaRemoved event data
- */
-struct MediaRemovedEventData: EventData
-{
-    uint64_t PeerId;
-    uint16_t MediaId;
-};
+    return code != ODIN_ERROR_SUCCESS && code != ODIN_ERROR_NO_DATA;
+}
 
 /**
- * Event data structure used to copy The MediaActiveStateChanged event data
+ * Event data base structure used to copy OdinEvent data as a base for sending events to JS side
  */
-struct MediaActiveStateChangedEventData: EventData
-{
-    uint64_t PeerId;
-    uint16_t MediaId;
-    bool Active;
+struct EventData {
+    std::string Event; 
+    std::string Json;  
 };
 
 /**
- * Data structure to store audio samples used to copy The AudioDataReceived event data
+ * Data structure to store audio samples used to copy The AudioDataReceived event data.
+ * Also carries a pointer to the pending callback counter for ref-counting.
  */
 struct AudioSamples {
-    short Data[960];
-    float OriginalData[960];
+    short Data[1920]; 
+    float OriginalData[1920];
     size_t Len;
     uint64_t PeerId;
     uint16_t MediaId;
+    
+    // Pointer to atomic counter for tracking pending callbacks
+    // Set before NonBlockingCall, decremented in callback after execution
+    std::atomic<int>* PendingCounterPtr = nullptr;
 
     void ConvertFloat32ToFloat16(const float *in_buffer, size_t in_buffer_len, short *out_buffer) {
         for (size_t i = 0; i < in_buffer_len; i++) {
             float f = in_buffer[i];
-// Clamp to [-1, 1] range
-            if (f > 1.0f) {
-                f = 1.0f;
-            } else if (f < -1.0f) {
-                f = -1.0f;
-            }
-// Convert to 16-bit float
-            int16_t f16 = (int16_t) (f * 32767.0f);
-            out_buffer[i] = f16;
+            if (f > 1.0f) f = 1.0f;
+            else if (f < -1.0f) f = -1.0f;
+            out_buffer[i] = (int16_t) (f * 32767.0f);
         }
     }
 
     void SetSamples(const float *samples, size_t len)
     {
+        if (len > 1920) len = 1920; 
         ConvertFloat32ToFloat16(samples, len, Data);
         memcpy(OriginalData, samples, len * sizeof(float));
         Len = len;
     }
-
-    ~AudioSamples()
-    {
-    }
 };
 
-
-void convert_float32_to_float16(const float *in_buffer, size_t in_buffer_len, short *out_buffer);
-
 #endif //ODIN_NODEJS_UTILITIES_H