@4players/odin-nodejs 0.7.0

package/cppsrc/odinroom.h

@@ -0,0 +1,65 @@
+//
+// Created by Phillip Schuster on 11.02.23.
+//
+
+#ifndef ODIN_NODEJS_ODINROOM_H
+#define ODIN_NODEJS_ODINROOM_H
+
+#include <napi.h>
+#include <odin.h>
+#include "utilities.h"
+#include <map>
+#include <thread>
+
+class OdinRoom : public Napi::ObjectWrap<OdinRoom> {
+    struct Media {
+        OdinMediaStreamHandle Handle;
+        uint16_t Id;
+        uint64_t PeerId;
+    };
+
+public:
+    OdinRoom(const Napi::CallbackInfo& info); //Constructor to initialise
+    static Napi::FunctionReference *New;
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    static Napi::Value CreateNewItem(const Napi::CallbackInfo& info);
+    void Finalize(Napi::Env env) override;
+    static 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;
+    static Napi::FunctionReference *constructor;
+    static Napi::Object NewInstance(Napi::Value arg);
+private:
+    OdinRoomHandle _roomHandle;
+    std::string _token;
+    Napi::ThreadSafeFunction _eventListener;
+    std::map<uint16_t, Media> _mediaStreams;
+
+    std::thread _nativeThread;
+    bool _started;
+    bool _joined;
+    float _audioSamplesBuffer[960];
+
+    std::map<std::string, Napi::ThreadSafeFunction> _eventListeners;
+    Napi::ThreadSafeFunction _audioDataReceivedEventListener;
+
+    void Close(const Napi::CallbackInfo& info);
+    void Join(const Napi::CallbackInfo& info);
+    void UpdatePeerUserData(const Napi::CallbackInfo &info);
+    void UpdateRoomUserData(const Napi::CallbackInfo &info);
+    void SendMessage(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();
+
+    Napi::Value CreateAudioStream(const Napi::CallbackInfo &info);
+};
+
+
+#endif //ODIN_NODEJS_ODINROOM_H

package/cppsrc/utilities.cpp

@@ -0,0 +1,102 @@
+#include "utilities.h"
+
+std::string string_format(const std::string fmt, ...) {
+    int size = ((int)fmt.size()) * 2 + 50;   // Use a rubric appropriate for your code
+    std::string str;
+    va_list ap;
+    while (1) {     // Maximum two passes on a POSIX system...
+        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
+            str.resize(n);
+            return str;
+        }
+        if (n > -1)  // Needed size returned
+            size = n + 1;   // For null char
+        else
+            size *= 2;      // Guess at a larger size (OS specific)
+    }
+    return str;
+}
+
+void OdinUtilities::ThrowNapiException(Napi::Env env, OdinReturnCode error, const char* message)
+{
+    char buffer[512];
+    odin_error_format(error, buffer, sizeof(buffer));
+
+    std::string text = string_format("%s: %s", message, buffer);
+
+    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

@@ -0,0 +1,175 @@
+#include <odin.h>
+#include <napi.h>
+
+#ifndef ODIN_NODEJS_UTILITIES_H
+#define ODIN_NODEJS_UTILITIES_H
+
+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);
+}
+
+/**
+ * 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
+{
+    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;
+};
+
+/**
+ * Event data structure used to copy The MediaActiveStateChanged event data
+ */
+struct MediaActiveStateChangedEventData: EventData
+{
+    uint64_t PeerId;
+    uint16_t MediaId;
+    bool Active;
+};
+
+/**
+ * Data structure to store audio samples used to copy The AudioDataReceived event data
+ */
+struct AudioSamples {
+    short Data[960];
+    float OriginalData[960];
+    size_t Len;
+    uint64_t PeerId;
+    uint16_t MediaId;
+
+    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;
+        }
+    }
+
+    void SetSamples(const float *samples, size_t len)
+    {
+        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

package/index.cjs

@@ -0,0 +1,2 @@
+var binding = require('node-gyp-build')(__dirname);
+module.exports = binding;

package/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./odin.client";
+export * from "./odin.room";
+export * from "./odin.media";
+
+export declare function generateAccessToken(accessKey: string, roomId: string, userId: string): string;