@4players/odin-nodejs 0.11.1 → 0.11.3

package/Dockerfile

@@ -0,0 +1,69 @@
+FROM node:20-bullseye
+
+WORKDIR /usr/src/app
+
+ARG ODIN_NODEJS_VERSION=latest
+
+RUN npm init -y \
+    && npm install --omit=dev "@4players/odin-nodejs@${ODIN_NODEJS_VERSION}"
+
+RUN cat <<'EOF' > connection-test.js
+const odin = require('@4players/odin-nodejs');
+const { OdinClient } = odin;
+
+const accessKey = process.env.ODIN_ACCESS_KEY;
+const roomId = process.env.ODIN_ROOM_ID || 'odin-sdk-ci-test';
+const userId = process.env.ODIN_USER_ID || `docker-example-${Math.floor(Math.random() * 1e6)}`;
+const gateway = process.env.ODIN_GATEWAY || 'https://gateway.odin.4players.io';
+const runDurationMs = Number(process.env.RUN_DURATION_MS || 15000);
+
+if (!accessKey) {
+    console.error('❌ Missing ODIN_ACCESS_KEY environment variable');
+    process.exit(1);
+}
+
+const client = new OdinClient();
+const token = client.generateToken(accessKey, roomId, userId);
+const room = client.createRoom(token);
+
+room.onConnectionStateChanged((event) => {
+    const message = event.message ? ` - ${event.message}` : '';
+    console.log(`[state] ${event.state}${message}`);
+});
+
+room.onJoined((event) => {
+    console.log(`[joined] room=${event.roomId} peer=${event.ownPeerId}`);
+});
+
+room.onLeft((event) => {
+    console.log(`[left] reason=${event.reason}`);
+});
+
+room.onPeerJoined((event) => {
+    console.log(`[peer-joined] peer=${event.peerId}`);
+});
+
+room.onPeerLeft((event) => {
+    console.log(`[peer-left] peer=${event.peerId}`);
+});
+
+console.log(`Connecting to ${gateway} as ${userId} (room: ${roomId}) ...`);
+room.join(gateway);
+
+setTimeout(() => {
+    console.log('✅ Connection test complete, closing room');
+    room.close();
+}, runDurationMs);
+
+process.on('SIGINT', () => {
+    console.log('Received SIGINT, closing room');
+    room.close();
+    process.exit(0);
+});
+EOF
+
+ENV ODIN_GATEWAY=https://gateway.odin.4players.io
+ENV ODIN_ROOM_ID=odin-sdk-ci-test
+ENV RUN_DURATION_MS=15000
+
+CMD ["node", "connection-test.js"]

package/README.md

@@ -94,6 +94,37 @@ main();
 
 ---
 
+## Docker Usage
+
+The repository includes a ready-to-use `Dockerfile` that shows how to run the SDK inside a Linux/amd64 container. It installs `@4players/odin-nodejs`, is configured for the official ODIN gateway, and runs a lightweight connection test. No manual library-path tweaks are required—the Linux prebuild now embeds `$ORIGIN` so the bundled `libodin*.so` files load automatically.
+
+Build the example image:
+
+```bash
+docker build --platform=linux/amd64 -t odin-nodejs-docker-example .
+```
+
+Run it by passing your access key (and optionally a room ID, user ID, or custom gateway):
+
+```bash
+docker run --rm --platform=linux/amd64 \
+  -e ODIN_ACCESS_KEY="ATPClAXgmBgY1ryDk/kTC2Yhitf4fJSx95jpN3F9Xac3" \
+  -e ODIN_ROOM_ID="my-room" \
+  odin-nodejs-docker-example
+```
+
+Environment variables supported by the example:
+
+- `ODIN_ACCESS_KEY` *(required)* – access key used to mint tokens.
+- `ODIN_ROOM_ID` *(optional)* – defaults to `odin-sdk-ci-test`.
+- `ODIN_USER_ID` *(optional)* – auto-generates a random ID when omitted.
+- `ODIN_GATEWAY` *(optional)* – defaults to `https://gateway.odin.4players.io`.
+- `RUN_DURATION_MS` *(optional)* – how long to keep the connection open.
+
+You can also use the Dockerfile as a starting point for your own services—replace the provided sample script with your application logic.
+
+---
+
 ## Event Handlers
 
 The SDK provides typed event handlers for easy integration:

package/binding.gyp

@@ -21,10 +21,14 @@
       "conditions": [
         ["OS=='linux'", {
           "libraries": [
-            "-Wl,-rpath,$$ORIGIN",
             "-L<(module_root_dir)/libs/bin/linux/<(target_arch)",
             "-lodin",
             "-lodin_crypto"
+          ],
+          "ldflags": [
+            "-Wl,-rpath,'$$ORIGIN'",
+            "-static-libstdc++",
+            "-static-libgcc"
           ]
         }],
         ["OS=='mac'", {

package/cppsrc/odinroom.cpp

@@ -588,7 +588,7 @@ void OdinRoomWrapper::HandleAudioData() {
                 OdinDecoder* decoder = pair.second;
                 bool silent = false; 
                 OdinError rc = odin_decoder_pop(decoder, _audioSamplesBuffer, 1920, &silent);
-                if (!odin_is_error(rc) && !silent) {
+                if (rc == ODIN_ERROR_SUCCESS && !silent) {
                      // Double-check _started before calling callback
                      // This prevents calling a released ThreadSafeFunction
                      if (_started && _audioDataReceivedEventListener) {
@@ -621,8 +621,10 @@ void OdinRoomWrapper::HandleAudioData() {
                                 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));
+                                // Must use Copy(), not New(). New() wraps the pointer without copying.
+                                // Since we delete samples below, New() would leave JS holding a dangling pointer.
+                                obj.Set("samples16", Napi::Buffer<short>::Copy(env, samples->Data, samples->Len));
+                                obj.Set("samples32", Napi::Buffer<float>::Copy(env, samples->OriginalData, samples->Len));
                                 jsCallback.Call({obj});
                             } catch (...) {
                                 // Exception in audio callback - silently ignore
@@ -642,7 +644,11 @@ void OdinRoomWrapper::HandleAudioData() {
                 }
             }
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        // Sleep must match the decoder frame size (1920 stereo samples @ 48kHz = 20ms).
+        // A shorter sleep (e.g. 10ms) polls faster than audio arrives, causing the
+        // decoder's jitter buffer to produce PLC (Packet Loss Concealment) frames that
+        // stretch and distort the audio stream.
+        std::this_thread::sleep_for(std::chrono::milliseconds(20));
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4players/odin-nodejs",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "description": "NodeJS bindings for the ODIN SDK. Use for AI enhanced human interactions, content moderation and audio processing features in a backend.",
   "main": "index.cjs",
   "types": "index.d.ts",

package/tests/audio-recording/index.js

@@ -198,8 +198,8 @@ async function run() {
         // Write audio samples to the recording
         const recorder = fileRecorder[mediaId];
         if (recorder && data.samples16) {
-            // Convert Int16Array to Buffer and write to WAV file
-            const buffer = Buffer.from(data.samples16.buffer, data.samples16.byteOffset, data.samples16.byteLength);
+            // Copy audio data into a new buffer for safe async WAV writing
+            const buffer = Buffer.from(data.samples16);
             recorder.wavEncoder.write(buffer);
             recorder.sampleCount += data.samples16.length;
         }