supersonic-scsynth 0.1.8 → 0.2.0

package/dist/workers/osc_out_worker.js

@@ -7,24 +7,14 @@
 */
 
 /**
- * OSC OUT Worker - Scheduler for sending OSC bundles to scsynth
- * Handles timed bundles with priority queue scheduling
- * Writes directly to SharedArrayBuffer ring buffer
+ * OSC OUT Worker - Scheduler for OSC bundles
+ * Handles timed bundles and forwards them to the writer worker
+ * NO LONGER writes to ring buffer directly - all writes go through osc_writer_worker.js
  * ES5-compatible for Qt WebEngine
  */
 
-// Ring buffer configuration
-var sharedBuffer = null;
-var ringBufferBase = null;
-var atomicView = null;
-var dataView = null;
-var uint8View = null;
-
-// Ring buffer layout constants (loaded from WASM at initialization)
-var bufferConstants = null;
-
-// Control indices (calculated after init)
-var CONTROL_INDICES = {};
+// Reference to the writer worker
+var writerWorker = null;
 
 // Scheduling state
 var scheduledEvents = [];
@@ -33,181 +23,48 @@ var cachedTimeDelta = null;
 var minimumScheduleRequirementS = 0.002; // 2ms for audio precision
 var latencyS = 0.05; // 50ms latency compensation for scsynth
 
-// Message queue for handling backpressure
-var immediateQueue = []; // Queue of messages waiting to be written
-var isWriting = false; // Flag to prevent concurrent write attempts
-var writeRetryTimer = null;
+var DEBUG_SCHED_LOGS = false;
+function schedulerLog() {
+    if (DEBUG_SCHED_LOGS) {
+        console.log.apply(console, arguments);
+    }
+}
+function schedulerWarn() {
+    if (DEBUG_SCHED_LOGS) {
+        console.warn.apply(console, arguments);
+    }
+}
 
 // Statistics
 var stats = {
     bundlesScheduled: 0,
-    bundlesWritten: 0,
-    bundlesDropped: 0,
-    bufferOverruns: 0,
-    retries: 0,
-    queueDepth: 0,
-    maxQueueDepth: 0
+    bundlesSentToWriter: 0
 };
 
 /**
- * Initialize ring buffer access
+ * Initialize scheduler
  */
-function initRingBuffer(buffer, base, constants) {
-    sharedBuffer = buffer;
-    ringBufferBase = base;
-    bufferConstants = constants;
-    atomicView = new Int32Array(sharedBuffer);
-    dataView = new DataView(sharedBuffer);
-    uint8View = new Uint8Array(sharedBuffer);
-
-    // Calculate control indices using constants from WASM
-    CONTROL_INDICES = {
-        IN_HEAD: (ringBufferBase + bufferConstants.CONTROL_START + 0) / 4,
-        IN_TAIL: (ringBufferBase + bufferConstants.CONTROL_START + 4) / 4
-    };
+function init(buffer, base, constants) {
+    // We don't need the ring buffer anymore, but keep the params for compatibility
+    schedulerLog('[OSCSchedulerWorker] Initialized (scheduler only, no ring buffer access)');
 }
 
 /**
- * Queue a message for writing (handles backpressure)
+ * Send message to writer worker
  */
-function queueMessage(oscMessage) {
-    immediateQueue.push(oscMessage);
-    stats.queueDepth = immediateQueue.length;
-
-    if (stats.queueDepth > stats.maxQueueDepth) {
-        stats.maxQueueDepth = stats.queueDepth;
-    }
-
-    // Start processing if not already running
-    if (!isWriting) {
-        processQueue();
-    }
-}
-
-/**
- * Process the message queue - blocks until space is available
- */
-function processQueue() {
-    if (isWriting || immediateQueue.length === 0) {
+function sendToWriter(oscMessage) {
+    if (!writerWorker) {
+        console.error('[OSCSchedulerWorker] Writer worker not set');
         return;
     }
 
-    isWriting = true;
-
-    function processNext() {
-        if (immediateQueue.length === 0) {
-            isWriting = false;
-            stats.queueDepth = 0;
-            return;
-        }
-
-        var message = immediateQueue[0]; // Peek at first message
-
-        // Block until there's space, then write
-        var success = writeToRingBufferBlocking(message);
-
-        if (success) {
-            // Success! Remove from queue
-            immediateQueue.shift();
-            stats.queueDepth = immediateQueue.length;
-
-            // Process next message
-            if (immediateQueue.length > 0) {
-                setTimeout(processNext, 0);
-            } else {
-                isWriting = false;
-            }
-        } else {
-            // Fatal error (message too large or not initialized)
-            console.error('[OSCOutWorker] Fatal error, dropping message');
-            immediateQueue.shift(); // Remove bad message
-            stats.bundlesDropped++;
-            stats.queueDepth = immediateQueue.length;
-
-            // Continue with next message
-            setTimeout(processNext, 0);
-        }
-    }
-
-    processNext();
-}
-
-/**
- * Write OSC message to ring buffer - blocks until space available
- * Returns true on success, false on fatal error (message too large)
- */
-function writeToRingBufferBlocking(oscMessage) {
-    if (!sharedBuffer) {
-        console.error('[OSCOutWorker] Not initialized');
-        return false;
-    }
-
-    var payloadSize = oscMessage.length;
-    var totalSize = bufferConstants.MESSAGE_HEADER_SIZE + payloadSize;
-
-    // Check if message fits in buffer at all (account for padding at wrap)
-    if (totalSize > bufferConstants.IN_BUFFER_SIZE - bufferConstants.MESSAGE_HEADER_SIZE) {
-        console.error('[OSCOutWorker] Message too large:', totalSize, 'max:', bufferConstants.IN_BUFFER_SIZE - bufferConstants.MESSAGE_HEADER_SIZE);
-        return false;
-    }
-
-    // Keep trying until we have space
-    while (true) {
-        var head = Atomics.load(atomicView, CONTROL_INDICES.IN_HEAD);
-        var tail = Atomics.load(atomicView, CONTROL_INDICES.IN_TAIL);
-
-        // Check available space
-        var available = (bufferConstants.IN_BUFFER_SIZE - 1 - head + tail) % bufferConstants.IN_BUFFER_SIZE;
-
-        if (available >= totalSize) {
-            // Check if message fits contiguously, otherwise write padding and wrap
-            var spaceToEnd = bufferConstants.IN_BUFFER_SIZE - head;
-
-            if (totalSize > spaceToEnd) {
-                // Message won't fit at end - write padding marker and wrap to beginning
-                var paddingPos = ringBufferBase + bufferConstants.IN_BUFFER_START + head;
-                dataView.setUint32(paddingPos, bufferConstants.PADDING_MAGIC, true);
-                dataView.setUint32(paddingPos + 4, 0, true);
-                dataView.setUint32(paddingPos + 8, 0, true);
-                dataView.setUint32(paddingPos + 12, 0, true);
-
-                // Wrap head to beginning
-                head = 0;
-            }
-
-            // We have space! Write the message (now guaranteed contiguous)
-            var writePos = ringBufferBase + bufferConstants.IN_BUFFER_START + head;
-
-            // Write message header
-            dataView.setUint32(writePos, bufferConstants.MESSAGE_MAGIC, true);
-            dataView.setUint32(writePos + 4, totalSize, true);
-            dataView.setUint32(writePos + 8, stats.bundlesWritten, true); // sequence
-            dataView.setUint32(writePos + 12, 0, true); // padding
-
-            // Write payload
-            uint8View.set(oscMessage, writePos + bufferConstants.MESSAGE_HEADER_SIZE);
-
-            // Update head pointer (publish message)
-            var newHead = (head + totalSize) % bufferConstants.IN_BUFFER_SIZE;
-            Atomics.store(atomicView, CONTROL_INDICES.IN_HEAD, newHead);
-
-            stats.bundlesWritten++;
-            return true;
-        }
-
-        // Buffer is full - wait for tail to move (scsynth to consume)
-        stats.bufferOverruns++;
-
-        // Wait on the tail pointer - will wake when scsynth consumes data
-        // Timeout after 100ms to check if worker should stop
-        var result = Atomics.wait(atomicView, CONTROL_INDICES.IN_TAIL, tail, 100);
+    // Send to writer worker via postMessage
+    writerWorker.postMessage({
+        type: 'write',
+        oscData: oscMessage
+    });
 
-        if (result === 'ok' || result === 'not-equal') {
-            // Tail moved! Loop will retry
-            stats.retries++;
-        }
-        // On timeout, loop continues to retry (allows checking for stop signal)
-    }
+    stats.bundlesSentToWriter++;
 }
 
 /**
@@ -308,7 +165,7 @@ function extractMessagesFromBundle(data) {
 
 /**
  * Process incoming OSC data (message or bundle)
- * Pre-scheduler: waits for calculated time then sends to ring buffer
+ * Pre-scheduler: waits for calculated time then sends to writer
  * waitTimeMs is calculated by SuperSonic based on AudioContext time
  */
 function processOSC(oscData, editorId, runTag, waitTimeMs) {
@@ -316,13 +173,13 @@ function processOSC(oscData, editorId, runTag, waitTimeMs) {
 
     // If no wait time provided, or wait time is 0 or negative, send immediately
     if (waitTimeMs === null || waitTimeMs === undefined || waitTimeMs <= 0) {
-        queueMessage(oscData);
+        sendToWriter(oscData);
         return;
     }
 
     // Schedule to send after waitTimeMs
     setTimeout(function() {
-        queueMessage(oscData);
+        sendToWriter(oscData);
     }, waitTimeMs);
 }
 
@@ -338,11 +195,11 @@ function processImmediate(oscData) {
         // Send each message individually for immediate execution
         var messages = extractMessagesFromBundle(oscData);
         for (var i = 0; i < messages.length; i++) {
-            queueMessage(messages[i]);
+            sendToWriter(messages[i]);
         }
     } else {
         // Regular message - send as-is
-        queueMessage(oscData);
+        sendToWriter(oscData);
     }
 }
 
@@ -420,7 +277,7 @@ function runNextEvent() {
     var data = event[2];
 
     // Send the complete bundle unchanged (with original timestamp)
-    queueMessage(data);
+    sendToWriter(data);
 
     scheduleNextEvent();
 }
@@ -469,10 +326,16 @@ self.onmessage = function(event) {
     try {
         switch (data.type) {
             case 'init':
-                initRingBuffer(data.sharedBuffer, data.ringBufferBase, data.bufferConstants);
+                init(data.sharedBuffer, data.ringBufferBase, data.bufferConstants);
                 self.postMessage({ type: 'initialized' });
                 break;
 
+            case 'setWriterWorker':
+                // Set reference to writer worker (passed as MessagePort)
+                writerWorker = data.port;
+                schedulerLog('[OSCSchedulerWorker] Writer worker connected');
+                break;
+
             case 'send':
                 // Single send method for both messages and bundles
                 // waitTimeMs is calculated by SuperSonic based on AudioContext time
@@ -505,7 +368,7 @@ self.onmessage = function(event) {
                 break;
 
             default:
-                console.warn('[OSCOutWorker] Unknown message type:', data.type);
+                schedulerWarn('[OSCOutWorker] Unknown message type:', data.type);
         }
     } catch (error) {
         console.error('[OSCOutWorker] Error:', error);
@@ -516,4 +379,4 @@ self.onmessage = function(event) {
     }
 };
 
-console.log('[OSCOutWorker] Script loaded');
+schedulerLog('[OSCSchedulerWorker] Script loaded - scheduler only, delegates to writer worker');

package/dist/workers/ring_buffer_worker_base.js

@@ -0,0 +1,305 @@
+/*
+    SuperSonic - SuperCollider AudioWorklet WebAssembly port
+    Copyright (c) 2025 Sam Aaron
+
+    Based on SuperCollider by James McCartney and community
+    GPL v3 or later
+*/
+
+/**
+ * Base class for ring buffer workers
+ * Provides common functionality for polling ring buffers with Atomics.wait()
+ * ES5-compatible for Qt WebEngine
+ */
+
+// Ring buffer configuration
+var RingBufferWorkerBase = function(bufferType) {
+    this.bufferType = bufferType; // 'OUT', 'SYSTEM', etc.
+    this.sharedBuffer = null;
+    this.ringBufferBase = null;
+    this.atomicView = null;
+    this.dataView = null;
+    this.uint8View = null;
+    this.bufferConstants = null;
+    this.CONTROL_INDICES = {};
+    this.running = false;
+    this.loggedCorruptionState = false;
+
+    // Statistics
+    this.stats = {
+        messagesReceived: 0,
+        lastSequenceReceived: -1,
+        droppedMessages: 0,
+        wakeups: 0,
+        timeouts: 0
+    };
+};
+
+/**
+ * Initialize ring buffer access
+ */
+RingBufferWorkerBase.prototype.initRingBuffer = function(buffer, base, constants) {
+    this.sharedBuffer = buffer;
+    this.ringBufferBase = base;
+    this.bufferConstants = constants;
+    this.atomicView = new Int32Array(this.sharedBuffer);
+    this.dataView = new DataView(this.sharedBuffer);
+    this.uint8View = new Uint8Array(this.sharedBuffer);
+
+    // Calculate control indices based on buffer type
+    var headOffset, tailOffset;
+    if (this.bufferType === 'OUT') {
+        headOffset = 8;
+        tailOffset = 12;
+    } else if (this.bufferType === 'SYSTEM') {
+        headOffset = 24;  // system_head offset
+        tailOffset = 28;  // system_tail offset
+    }
+
+    // Debug logging for SYSTEM worker
+    if (this.bufferType === 'SYSTEM') {
+        console.log('[' + this.bufferType + 'Worker] Init params:', {
+            ringBufferBase: base,
+            CONTROL_START: constants.CONTROL_START,
+            headOffset: headOffset,
+            tailOffset: tailOffset,
+            calculatedHeadByteOffset: base + constants.CONTROL_START + headOffset,
+            calculatedHeadIndex: (base + constants.CONTROL_START + headOffset) / 4
+        });
+        console.log('[' + this.bufferType + 'Worker] Buffer constants:', {
+            SYSTEM_BUFFER_START: constants.SYSTEM_BUFFER_START,
+            SYSTEM_BUFFER_SIZE: constants.SYSTEM_BUFFER_SIZE,
+            MESSAGE_MAGIC: constants.MESSAGE_MAGIC,
+            PADDING_MAGIC: constants.PADDING_MAGIC
+        });
+    }
+
+    this.CONTROL_INDICES = {
+        HEAD: (this.ringBufferBase + this.bufferConstants.CONTROL_START + headOffset) / 4,
+        TAIL: (this.ringBufferBase + this.bufferConstants.CONTROL_START + tailOffset) / 4
+    };
+
+    // Debug: log buffer info for SYSTEM
+    if (this.bufferType === 'SYSTEM') {
+        var bufferInfo = this.getBufferInfo();
+        console.log('[' + this.bufferType + 'Worker] Buffer info:', bufferInfo);
+        console.log('[' + this.bufferType + 'Worker] Control indices:', this.CONTROL_INDICES);
+
+        // Check initial buffer state - read first 64 bytes
+        var startPos = this.ringBufferBase + bufferInfo.start;
+        console.log('[' + this.bufferType + 'Worker] First 64 bytes of buffer at position', startPos + ':');
+        for (var i = 0; i < 64; i += 4) {
+            var value = this.dataView.getUint32(startPos + i, true);
+            console.log('  Offset', i + ':', '0x' + value.toString(16).padStart(8, '0'));
+        }
+
+        // Check current head/tail values
+        var currentHead = Atomics.load(this.atomicView, this.CONTROL_INDICES.HEAD);
+        var currentTail = Atomics.load(this.atomicView, this.CONTROL_INDICES.TAIL);
+        console.log('[' + this.bufferType + 'Worker] Initial head:', currentHead, 'tail:', currentTail);
+    }
+};
+
+/**
+ * Get buffer start and size based on type
+ */
+RingBufferWorkerBase.prototype.getBufferInfo = function() {
+    if (this.bufferType === 'OUT') {
+        return {
+            start: this.bufferConstants.OUT_BUFFER_START,
+            size: this.bufferConstants.OUT_BUFFER_SIZE
+        };
+    } else if (this.bufferType === 'SYSTEM') {
+        return {
+            start: this.bufferConstants.SYSTEM_BUFFER_START,
+            size: this.bufferConstants.SYSTEM_BUFFER_SIZE
+        };
+    }
+    return null;
+};
+
+/**
+ * Read all available messages from buffer
+ */
+RingBufferWorkerBase.prototype.readMessages = function() {
+    var head = Atomics.load(this.atomicView, this.CONTROL_INDICES.HEAD);
+    var tail = Atomics.load(this.atomicView, this.CONTROL_INDICES.TAIL);
+
+    var messages = [];
+
+    if (head === tail) {
+        return messages; // No messages
+    }
+
+    var bufferInfo = this.getBufferInfo();
+    var currentTail = tail;
+    var messagesRead = 0;
+    var maxMessages = 100;
+
+    while (currentTail !== head && messagesRead < maxMessages) {
+        var readPos = this.ringBufferBase + bufferInfo.start + currentTail;
+
+        // Read message header (now always contiguous due to padding)
+        var magic = this.dataView.getUint32(readPos, true);
+
+        // Check for padding marker - skip to beginning
+        if (magic === this.bufferConstants.PADDING_MAGIC) {
+            currentTail = 0;
+            continue;
+        }
+
+        if (magic !== this.bufferConstants.MESSAGE_MAGIC) {
+            // Only log first few corrupted messages to avoid spamming
+            if (this.stats.droppedMessages < 5) {
+                console.error('[' + this.bufferType + 'Worker] Corrupted message at position', currentTail, 'magic:', magic, 'expected:', this.bufferConstants.MESSAGE_MAGIC);
+            }
+            this.stats.droppedMessages++;
+            // Skip this byte and continue
+            currentTail = (currentTail + 1) % bufferInfo.size;
+            continue;
+        }
+
+        var length = this.dataView.getUint32(readPos + 4, true);
+        var sequence = this.dataView.getUint32(readPos + 8, true);
+        var padding = this.dataView.getUint32(readPos + 12, true);  // unused padding field
+
+        // Validate message length
+        if (length < this.bufferConstants.MESSAGE_HEADER_SIZE || length > bufferInfo.size) {
+            // Only log first few invalid lengths to avoid spamming
+            if (this.stats.droppedMessages < 5) {
+                console.error('[' + this.bufferType + 'Worker] Invalid message length:', length);
+            }
+            this.stats.droppedMessages++;
+            currentTail = (currentTail + 1) % bufferInfo.size;
+            continue;
+        }
+
+        // Check for dropped messages via sequence
+        if (this.stats.lastSequenceReceived >= 0) {
+            var expectedSeq = (this.stats.lastSequenceReceived + 1) & 0xFFFFFFFF;
+            if (sequence !== expectedSeq) {
+                var dropped = (sequence - expectedSeq + 0x100000000) & 0xFFFFFFFF;
+                if (dropped < 1000) { // Sanity check
+                    console.warn('[' + this.bufferType + 'Worker] Detected', dropped, 'dropped messages');
+                    this.stats.droppedMessages += dropped;
+                }
+            }
+        }
+        this.stats.lastSequenceReceived = sequence;
+
+        // Read payload (OSC binary data) - now contiguous due to padding
+        var payloadLength = length - this.bufferConstants.MESSAGE_HEADER_SIZE;
+        var payloadStart = readPos + this.bufferConstants.MESSAGE_HEADER_SIZE;
+
+        // Create a proper copy (not a view into SharedArrayBuffer)
+        var payload = new Uint8Array(payloadLength);
+        for (var i = 0; i < payloadLength; i++) {
+            payload[i] = this.uint8View[payloadStart + i];
+        }
+
+        messages.push({
+            oscData: payload,
+            sequence: sequence
+        });
+
+        // Move to next message
+        currentTail = (currentTail + length) % bufferInfo.size;
+        messagesRead++;
+        this.stats.messagesReceived++;
+    }
+
+    // Update tail pointer (consume messages)
+    if (messagesRead > 0) {
+        Atomics.store(this.atomicView, this.CONTROL_INDICES.TAIL, currentTail);
+    }
+
+    return messages;
+};
+
+/**
+ * Main wait loop using Atomics.wait for instant wake
+ */
+RingBufferWorkerBase.prototype.waitLoop = function() {
+    var self = this;
+    while (this.running) {
+        try {
+            // Get current HEAD value
+            var currentHead = Atomics.load(this.atomicView, this.CONTROL_INDICES.HEAD);
+            var currentTail = Atomics.load(this.atomicView, this.CONTROL_INDICES.TAIL);
+
+            // If buffer is empty, wait for AudioWorklet to notify us
+            if (currentHead === currentTail) {
+                // Wait for up to 100ms (allows checking stop signal)
+                var result = Atomics.wait(this.atomicView, this.CONTROL_INDICES.HEAD, currentHead, 100);
+
+                if (result === 'ok' || result === 'not-equal') {
+                    // We were notified or value changed!
+                    this.stats.wakeups++;
+                } else if (result === 'timed-out') {
+                    this.stats.timeouts++;
+                    continue; // Check running flag
+                }
+            }
+
+            // Read all available messages
+            var messages = this.readMessages();
+
+            // Debug: log ONCE if we tried to read but got no valid messages due to corruption
+            if (messages.length === 0 && currentHead !== currentTail && this.stats.droppedMessages > 0) {
+                if (this.bufferType === 'SYSTEM' && !this.loggedCorruptionState) {
+                    console.log('[' + this.bufferType + 'Worker] Head != tail (head=' + currentHead + ', tail=' + currentTail + ') but all messages corrupted. Dropped:', this.stats.droppedMessages);
+                    this.loggedCorruptionState = true;
+                }
+            }
+
+            if (messages.length > 0) {
+                // Send to main thread
+                self.postMessage({
+                    type: 'messages',
+                    messages: messages,
+                    stats: {
+                        wakeups: this.stats.wakeups,
+                        timeouts: this.stats.timeouts,
+                        messagesReceived: this.stats.messagesReceived,
+                        droppedMessages: this.stats.droppedMessages
+                    }
+                });
+            }
+
+        } catch (error) {
+            console.error('[' + this.bufferType + 'Worker] Error in wait loop:', error);
+            self.postMessage({
+                type: 'error',
+                error: error.message
+            });
+
+            // Brief pause on error before retrying
+            Atomics.wait(this.atomicView, 0, this.atomicView[0], 10);
+        }
+    }
+};
+
+/**
+ * Start the wait loop
+ */
+RingBufferWorkerBase.prototype.start = function() {
+    if (!this.sharedBuffer) {
+        console.error('[' + this.bufferType + 'Worker] Cannot start - not initialized');
+        return;
+    }
+
+    if (this.running) {
+        console.warn('[' + this.bufferType + 'Worker] Already running');
+        return;
+    }
+
+    this.running = true;
+    this.waitLoop();
+};
+
+/**
+ * Stop the wait loop
+ */
+RingBufferWorkerBase.prototype.stop = function() {
+    this.running = false;
+};