593 lines
21 KiB
JavaScript
593 lines
21 KiB
JavaScript
|
/**
|
||
|
|
* C15 Audio Engine - AudioWorklet Processor
|
||
|
|
*
|
||
|
|
* This processor loads the C15 WASM module and calls render() each audio frame.
|
||
|
|
* It runs in AudioWorkletGlobalScope and connects to the Web Audio graph with
|
||
|
|
* 0 inputs and 2 outputs (stereo).
|
||
|
|
*
|
||
|
|
* WASM API:
|
||
|
|
* - engineInit(sampleRate, polyphony) -> int
|
||
|
|
* - render(numFrames) -> float* (interleaved stereo)
|
||
|
|
* - noteOn(note, velocity)
|
||
|
|
* - noteOff(note, velocity)
|
||
|
|
* - setParameter(paramId, value)
|
||
|
|
* - reset()
|
||
|
|
*
|
||
|
|
* Ring Buffer Protocol (SharedArrayBuffer):
|
||
|
|
* - Lock-free SPSC ring buffer for main thread -> worklet communication
|
||
|
|
* - Message types: 0=parameter, 1=noteOn, 2=noteOff
|
||
|
|
* - Message format: [type, id/note, value/velocity, reserved]
|
||
|
|
*
|
||
|
|
* @file worklet-processor.js
|
||
|
|
*/
|
||
|
|
|
||
|
|
// WASM module state (shared across all processor instances)
|
||
|
|
let wasmInstance = null;
|
||
|
|
let wasmMemory = null;
|
||
|
|
let wasmReady = false;
|
||
|
|
|
||
|
|
// Ring buffer state
|
||
|
|
let ringBufferReader = null;
|
||
|
|
|
||
|
|
// Message type constants (must match ring-buffer.js)
|
||
|
|
const MessageType = {
|
||
|
|
PARAMETER: 0,
|
||
|
|
NOTE_ON: 1,
|
||
|
|
NOTE_OFF: 2
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Ring buffer layout constants
|
||
|
|
*/
|
||
|
|
const HEADER_SIZE = 3;
|
||
|
|
const MESSAGE_SIZE = 4;
|
||
|
|
const RING_CAPACITY = 512;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* RingBufferReader - Reads messages from SharedArrayBuffer ring buffer
|
||
|
|
*
|
||
|
|
* This is the consumer side of the SPSC ring buffer, designed for use
|
||
|
|
* in the AudioWorklet's process() callback.
|
||
|
|
*
|
||
|
|
* @class RingBufferReader
|
||
|
|
*/
|
||
|
|
class RingBufferReader {
|
||
|
|
constructor(sharedBuffer) {
|
||
|
|
this._buffer = new Float32Array(sharedBuffer);
|
||
|
|
this._capacity = RING_CAPACITY;
|
||
|
|
this._messageSize = MESSAGE_SIZE;
|
||
|
|
this._headerSize = HEADER_SIZE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get current write index (main thread updates this)
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
_getWriteIndex() {
|
||
|
|
return Atomics.load(new Int32Array(this._buffer.buffer), 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get current read index
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
_getReadIndex() {
|
||
|
|
return Atomics.load(new Int32Array(this._buffer.buffer), 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Advance read index with atomic store
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
_advanceReadIndex(currentIdx) {
|
||
|
|
const nextIdx = (currentIdx + 1) % this._capacity;
|
||
|
|
Atomics.store(new Int32Array(this._buffer.buffer), 1, nextIdx);
|
||
|
|
return nextIdx;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Read and process messages with callbacks
|
||
|
|
*
|
||
|
|
* This is the preferred method for use in the AudioWorklet process() call.
|
||
|
|
* It avoids creating arrays and directly calls the appropriate callback.
|
||
|
|
*
|
||
|
|
* @param {Object} callbacks - Callback handlers
|
||
|
|
* @param {Function} callbacks.onParameter - Called for parameter updates (paramId, value)
|
||
|
|
* @param {Function} callbacks.onNoteOn - Called for note on events (note, velocity)
|
||
|
|
* @param {Function} callbacks.onNoteOff - Called for note off events (note, velocity)
|
||
|
|
* @param {number} maxMessages - Maximum messages to process per call
|
||
|
|
* @returns {number} Number of messages processed
|
||
|
|
*/
|
||
|
|
processMessages(callbacks, maxMessages = 32) {
|
||
|
|
const writeIdx = this._getWriteIndex();
|
||
|
|
let readIdx = this._getReadIndex();
|
||
|
|
|
||
|
|
let count = 0;
|
||
|
|
|
||
|
|
while (readIdx !== writeIdx && count < maxMessages) {
|
||
|
|
// Read message from buffer
|
||
|
|
const msgOffset = this._headerSize + (readIdx * this._messageSize);
|
||
|
|
|
||
|
|
const type = this._buffer[msgOffset + 0];
|
||
|
|
const id = this._buffer[msgOffset + 1];
|
||
|
|
const value = this._buffer[msgOffset + 2];
|
||
|
|
|
||
|
|
// Dispatch to callback based on type
|
||
|
|
switch (type) {
|
||
|
|
case MessageType.PARAMETER:
|
||
|
|
if (callbacks.onParameter) {
|
||
|
|
callbacks.onParameter(id, value);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MessageType.NOTE_ON:
|
||
|
|
if (callbacks.onNoteOn) {
|
||
|
|
callbacks.onNoteOn(id, value);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MessageType.NOTE_OFF:
|
||
|
|
if (callbacks.onNoteOff) {
|
||
|
|
callbacks.onNoteOff(id, value);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
console.warn('[RingBufferReader] Unknown message type:', type);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Advance read index
|
||
|
|
readIdx = this._advanceReadIndex(readIdx);
|
||
|
|
count++;
|
||
|
|
}
|
||
|
|
|
||
|
|
return count;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get number of available messages (for debugging/monitoring)
|
||
|
|
*/
|
||
|
|
getAvailableCount() {
|
||
|
|
const writeIdx = this._getWriteIndex();
|
||
|
|
const readIdx = this._getReadIndex();
|
||
|
|
|
||
|
|
if (writeIdx >= readIdx) {
|
||
|
|
return writeIdx - readIdx;
|
||
|
|
} else {
|
||
|
|
return this._capacity - readIdx + writeIdx;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Initialize WASM module from compiled WebAssembly.Module and memory
|
||
|
|
* This is called when the main thread sends the 'init-wasm' message
|
||
|
|
*/
|
||
|
|
function initWasmFromModule(wasmModule, memory) {
|
||
|
|
return WebAssembly.instantiate(wasmModule, {
|
||
|
|
// Import object - Emscripten typically uses 'a' for the main import namespace
|
||
|
|
a: {
|
||
|
|
// Memory import if needed
|
||
|
|
d: () => { throw new Error('abort'); },
|
||
|
|
b: () => 1, // nowIsMonotonic
|
||
|
|
a: () => performance.now(), // _emscripten_get_now
|
||
|
|
c: (size) => { // _emscripten_resize_heap - not typically needed with fixed memory
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}).then(instance => {
|
||
|
|
wasmInstance = instance;
|
||
|
|
wasmMemory = memory;
|
||
|
|
wasmReady = true;
|
||
|
|
|
||
|
|
// Call the constructors
|
||
|
|
if (instance.exports.f) {
|
||
|
|
instance.exports.f();
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* C15Processor - AudioWorklet processor for the C15 synth engine
|
||
|
|
*
|
||
|
|
* Fulfills validation assertions:
|
||
|
|
* - VAL-M2-001: WASM module loads in AudioWorkletGlobalScope
|
||
|
|
* - VAL-M2-002: registerProcessor() succeeds with 0 inputs, 2 outputs
|
||
|
|
* - VAL-M2-003: AudioWorkletNode connects to AudioContext destination
|
||
|
|
* - VAL-M2-004: WASM render produces valid stereo float32 output
|
||
|
|
* - VAL-M2-005: Ring buffer enables lock-free parameter updates without corruption
|
||
|
|
* - VAL-M2-006: Note on/off via ring buffer triggers audio start/release
|
||
|
|
*
|
||
|
|
* NOTE: WebAssembly.Module cannot be sent via MessagePort.postMessage() in Chrome.
|
||
|
|
* The WASM module must be passed via processorOptions in the AudioWorkletNode constructor.
|
||
|
|
* See: https://issues.chromium.org/issues/40855462
|
||
|
|
*/
|
||
|
|
class C15Processor extends AudioWorkletProcessor {
|
||
|
|
constructor(options) {
|
||
|
|
super(options);
|
||
|
|
|
||
|
|
// Processor configuration
|
||
|
|
this._initialized = false;
|
||
|
|
this._sampleRate = 48000;
|
||
|
|
this._polyphony = 24;
|
||
|
|
this._bufferSize = 128;
|
||
|
|
|
||
|
|
// Default configuration
|
||
|
|
const processorOptions = options.processorOptions || {};
|
||
|
|
this._sampleRate = processorOptions.sampleRate || 48000;
|
||
|
|
this._polyphony = processorOptions.polyphony || 24;
|
||
|
|
|
||
|
|
// Listen for messages from main thread
|
||
|
|
this.port.onmessage = this._handleMessage.bind(this);
|
||
|
|
|
||
|
|
// Debug: verify message handler is bound
|
||
|
|
this.port.postMessage({ type: 'status', status: 'handler-bound', test: true });
|
||
|
|
|
||
|
|
// Log that processor was created
|
||
|
|
this._postStatus('created', {
|
||
|
|
sampleRate: this._sampleRate,
|
||
|
|
polyphony: this._polyphony
|
||
|
|
});
|
||
|
|
|
||
|
|
// Initialize WASM from processorOptions if provided
|
||
|
|
// Chrome requires this approach - WebAssembly.Module cannot be sent via postMessage
|
||
|
|
// See: https://issues.chromium.org/issues/40855462
|
||
|
|
if (processorOptions.wasmModule instanceof WebAssembly.Module) {
|
||
|
|
this._postStatus('wasm-module-received-via-options', {
|
||
|
|
hasModule: true,
|
||
|
|
moduleType: 'WebAssembly.Module'
|
||
|
|
});
|
||
|
|
// Initialize WASM asynchronously
|
||
|
|
this._initFromWasmModule(processorOptions.wasmModule, null);
|
||
|
|
} else if (processorOptions.wasmModule) {
|
||
|
|
this._postError(new Error('wasmModule in processorOptions is not a WebAssembly.Module'), 'constructor');
|
||
|
|
} else {
|
||
|
|
this._postStatus('no-wasm-in-options', {
|
||
|
|
hint: 'WASM module should be passed via processorOptions.wasmModule'
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
// Initialize ring buffer if provided
|
||
|
|
if (processorOptions.ringBuffer) {
|
||
|
|
ringBufferReader = new RingBufferReader(processorOptions.ringBuffer);
|
||
|
|
this._postStatus('ring-buffer-ready', {
|
||
|
|
hasRingBuffer: true,
|
||
|
|
capacity: RING_CAPACITY
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Post status message to main thread
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
_postStatus(status, data = {}) {
|
||
|
|
this.port.postMessage({
|
||
|
|
type: 'status',
|
||
|
|
status: status,
|
||
|
|
...data
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Post error message to main thread
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
_postError(error, context = '') {
|
||
|
|
this.port.postMessage({
|
||
|
|
type: 'error',
|
||
|
|
error: error.toString(),
|
||
|
|
context: context
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Handle messages from main thread
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
_handleMessage(event) {
|
||
|
|
const data = event.data; // event.data contains the message
|
||
|
|
|
||
|
|
// Debug log all messages (except high-frequency ones)
|
||
|
|
if (data.type !== 'setParameter' && data.type !== 'tick') {
|
||
|
|
this._postStatus('message-received', { msgType: data.type });
|
||
|
|
}
|
||
|
|
|
||
|
|
switch (data.type) {
|
||
|
|
case 'test':
|
||
|
|
this._postStatus('test-received', { value: data.value });
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 'init-wasm':
|
||
|
|
// Initialize WASM from compiled module sent by main thread
|
||
|
|
// NOTE: This may not work in Chrome due to cross-origin issues
|
||
|
|
// See: https://issues.chromium.org/issues/40855462
|
||
|
|
// The WASM module should be passed via processorOptions instead
|
||
|
|
if (this._initialized) {
|
||
|
|
this._postStatus('wasm-already-initialized', {
|
||
|
|
hint: 'WASM was already initialized via processorOptions'
|
||
|
|
});
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check if wasmModule is valid
|
||
|
|
if (!data.wasmModule) {
|
||
|
|
this._postError(new Error('No wasmModule in init-wasm message'), 'init-wasm');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!(data.wasmModule instanceof WebAssembly.Module)) {
|
||
|
|
this._postError(new Error('wasmModule is not a WebAssembly.Module: ' + typeof data.wasmModule), 'init-wasm');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
this._postStatus('starting-wasm-init', {
|
||
|
|
hasModule: true,
|
||
|
|
moduleType: 'WebAssembly.Module',
|
||
|
|
note: 'Using postMessage (may fail in Chrome)'
|
||
|
|
});
|
||
|
|
this._initFromWasmModule(data.wasmModule, data.memory);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 'init-ring-buffer':
|
||
|
|
// Initialize ring buffer from SharedArrayBuffer sent by main thread
|
||
|
|
if (this._initialized && ringBufferReader) {
|
||
|
|
this._postStatus('ring-buffer-already-initialized', {
|
||
|
|
hint: 'Ring buffer was already initialized via processorOptions'
|
||
|
|
});
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (data.ringBuffer) {
|
||
|
|
ringBufferReader = new RingBufferReader(data.ringBuffer);
|
||
|
|
this._postStatus('ring-buffer-ready', {
|
||
|
|
hasRingBuffer: true,
|
||
|
|
capacity: RING_CAPACITY
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
this._postError(new Error('No SharedArrayBuffer provided'), 'ring buffer init');
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 'noteOn':
|
||
|
|
if (this._initialized && wasmInstance) {
|
||
|
|
wasmInstance.exports.o(data.note, data.velocity); // _noteOn
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 'noteOff':
|
||
|
|
if (this._initialized && wasmInstance) {
|
||
|
|
wasmInstance.exports.p(data.note, data.velocity); // _noteOff
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 'setParameter':
|
||
|
|
if (this._initialized && wasmInstance) {
|
||
|
|
wasmInstance.exports.q(data.paramId, data.value); // _setParameter
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 'reset':
|
||
|
|
if (this._initialized && wasmInstance) {
|
||
|
|
wasmInstance.exports.t(); // _reset
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 'getConfig':
|
||
|
|
this._postStatus('config', {
|
||
|
|
sampleRate: this._sampleRate,
|
||
|
|
polyphony: this._polyphony,
|
||
|
|
initialized: this._initialized
|
||
|
|
});
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
console.warn('[C15Processor] Unknown message type:', data.type);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Initialize from pre-compiled WASM module
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
async _initFromWasmModule(wasmModule, memory) {
|
||
|
|
try {
|
||
|
|
this._postStatus('loading');
|
||
|
|
|
||
|
|
// Lazy reference to WASM memory — needed by _clock_time_get before we can
|
||
|
|
// assign wasmMemory (which only exists after WebAssembly.instantiate returns).
|
||
|
|
const memRef = [null];
|
||
|
|
|
||
|
|
// Define the WASM imports matching Emscripten's expected structure.
|
||
|
|
// Mapping (namespace 'a') as of the current build:
|
||
|
|
// a -> _emscripten_get_now
|
||
|
|
// b -> _proc_exit
|
||
|
|
// c -> __emscripten_runtime_keepalive_clear
|
||
|
|
// d -> __setitimer_js
|
||
|
|
// e -> _clock_time_get (WASI clock; writes i64 nanoseconds into WASM heap)
|
||
|
|
// f -> _emscripten_resize_heap
|
||
|
|
// g -> __abort_js
|
||
|
|
const imports = {
|
||
|
|
a: {
|
||
|
|
a: () => performance.now(),
|
||
|
|
b: (code) => { throw new Error('WASM exit: ' + code); },
|
||
|
|
c: () => {},
|
||
|
|
d: (_which, _timeout_ms) => 0,
|
||
|
|
e: (clk_id, _ignored_precision, ptime) => {
|
||
|
|
const now = clk_id === 0 ? Date.now() : performance.now();
|
||
|
|
const nsec = BigInt(Math.round(now * 1e6));
|
||
|
|
if (memRef[0]) {
|
||
|
|
new BigInt64Array(memRef[0].buffer)[ptime >> 3] = nsec;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
},
|
||
|
|
f: (requestedSize) => {
|
||
|
|
console.warn('[C15Processor] Heap resize requested but not supported');
|
||
|
|
return 0;
|
||
|
|
},
|
||
|
|
g: () => { throw new Error('WASM abort called'); }
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
// Instantiate the compiled module
|
||
|
|
const instance = await WebAssembly.instantiate(wasmModule, imports);
|
||
|
|
|
||
|
|
wasmInstance = instance;
|
||
|
|
|
||
|
|
// Get memory from exports (export 'h' is memory)
|
||
|
|
wasmMemory = instance.exports.h;
|
||
|
|
memRef[0] = wasmMemory;
|
||
|
|
|
||
|
|
// Call runtime init (export 'i' is initRuntime/__wasm_call_ctors)
|
||
|
|
if (instance.exports.i) {
|
||
|
|
instance.exports.i();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Initialize the engine (export 'j' is _engineInit)
|
||
|
|
const initResult = instance.exports.j(this._sampleRate, this._polyphony);
|
||
|
|
|
||
|
|
if (initResult !== 1) {
|
||
|
|
throw new Error('engineInit failed with result: ' + initResult);
|
||
|
|
}
|
||
|
|
|
||
|
|
this._initialized = true;
|
||
|
|
wasmReady = true;
|
||
|
|
|
||
|
|
// Get the default frames per render call (export 'v' is _getDefaultFrames)
|
||
|
|
this._bufferSize = instance.exports.v();
|
||
|
|
|
||
|
|
this._postStatus('ready', {
|
||
|
|
sampleRate: this._sampleRate,
|
||
|
|
polyphony: this._polyphony,
|
||
|
|
bufferSize: this._bufferSize
|
||
|
|
});
|
||
|
|
|
||
|
|
} catch (error) {
|
||
|
|
this._postError(error, 'WASM load/init');
|
||
|
|
console.error('[C15Processor] Failed to init WASM:', error);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Process audio frames
|
||
|
|
*
|
||
|
|
* Called by the browser for each audio render quantum (typically 128 frames).
|
||
|
|
*
|
||
|
|
* VAL-M2-005: Processes ring buffer messages lock-free from main thread
|
||
|
|
* VAL-M2-006: Note on/off via ring buffer triggers audio
|
||
|
|
*
|
||
|
|
* @param {Float32Array[][]} inputs - Input audio buffers (unused)
|
||
|
|
* @param {Float32Array[][]} outputs - Output audio buffers (stereo)
|
||
|
|
* @param {Object} parameters - Automatable parameters (unused)
|
||
|
|
* @returns {boolean} - True to keep processor alive
|
||
|
|
*/
|
||
|
|
process(inputs, outputs, parameters) {
|
||
|
|
const output = outputs[0];
|
||
|
|
|
||
|
|
if (!output || output.length < 2) {
|
||
|
|
return true; // Keep alive but no output
|
||
|
|
}
|
||
|
|
|
||
|
|
const leftChannel = output[0];
|
||
|
|
const rightChannel = output[1];
|
||
|
|
const numFrames = leftChannel.length;
|
||
|
|
|
||
|
|
// If not initialized, output silence
|
||
|
|
if (!this._initialized || !wasmInstance) {
|
||
|
|
for (let i = 0; i < numFrames; i++) {
|
||
|
|
leftChannel[i] = 0;
|
||
|
|
rightChannel[i] = 0;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Process ring buffer messages first (VAL-M2-005, VAL-M2-006)
|
||
|
|
if (ringBufferReader) {
|
||
|
|
ringBufferReader.processMessages({
|
||
|
|
onParameter: (paramId, value) => {
|
||
|
|
wasmInstance.exports.q(paramId, value); // _setParameter
|
||
|
|
},
|
||
|
|
onNoteOn: (note, velocity) => {
|
||
|
|
this._dbgNoteOns = (this._dbgNoteOns || 0) + 1;
|
||
|
|
wasmInstance.exports.o(note, velocity); // _noteOn
|
||
|
|
},
|
||
|
|
onNoteOff: (note, velocity) => {
|
||
|
|
wasmInstance.exports.p(note, velocity); // _noteOff
|
||
|
|
}
|
||
|
|
}, 64); // Process up to 64 messages per audio frame
|
||
|
|
}
|
||
|
|
|
||
|
|
// Cache HEAPF32 view (recreate if memory grew)
|
||
|
|
if (!this._heapF32 || this._heapF32.buffer !== wasmMemory.buffer) {
|
||
|
|
this._heapF32 = new Float32Array(wasmMemory.buffer);
|
||
|
|
}
|
||
|
|
|
||
|
|
try {
|
||
|
|
// Render audio using WASM
|
||
|
|
// export 'm' is _render - returns pointer to interleaved stereo buffer
|
||
|
|
const bufferPtr = wasmInstance.exports.m(numFrames);
|
||
|
|
|
||
|
|
if (!bufferPtr) {
|
||
|
|
// Render failed, output silence
|
||
|
|
for (let i = 0; i < numFrames; i++) {
|
||
|
|
leftChannel[i] = 0;
|
||
|
|
rightChannel[i] = 0;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
const heapF32 = this._heapF32;
|
||
|
|
const bufferOffset = bufferPtr >> 2; // Convert byte offset to float32 index
|
||
|
|
|
||
|
|
// Deinterleave stereo data from WASM buffer to output channels
|
||
|
|
let frameMax = 0;
|
||
|
|
for (let i = 0; i < numFrames; i++) {
|
||
|
|
const sampleIndex = bufferOffset + (i * 2);
|
||
|
|
const l = heapF32[sampleIndex];
|
||
|
|
const r = heapF32[sampleIndex + 1];
|
||
|
|
leftChannel[i] = l;
|
||
|
|
rightChannel[i] = r;
|
||
|
|
const v = Math.abs(l) > Math.abs(r) ? Math.abs(l) : Math.abs(r);
|
||
|
|
if (v > frameMax) frameMax = v;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Periodic diagnostics (every ~2 seconds = 750 frames at 128 frames/quantum)
|
||
|
|
this._dbgFrameCount = (this._dbgFrameCount || 0) + 1;
|
||
|
|
this._dbgMaxSample = Math.max(this._dbgMaxSample || 0, frameMax);
|
||
|
|
if (this._dbgFrameCount % 750 === 0) {
|
||
|
|
this.port.postMessage({
|
||
|
|
type: 'diag',
|
||
|
|
frames: this._dbgFrameCount,
|
||
|
|
maxSample: this._dbgMaxSample,
|
||
|
|
noteOns: this._dbgNoteOns || 0
|
||
|
|
});
|
||
|
|
this._dbgMaxSample = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
} catch (error) {
|
||
|
|
// On error, output silence
|
||
|
|
console.error('[C15Processor] Render error:', error);
|
||
|
|
for (let i = 0; i < numFrames; i++) {
|
||
|
|
leftChannel[i] = 0;
|
||
|
|
rightChannel[i] = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return true; // Keep processor alive
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Static getter for parameter descriptors (for automatable parameters)
|
||
|
|
* Currently not used but required for proper AudioWorklet interface.
|
||
|
|
*/
|
||
|
|
static get parameterDescriptors() {
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Register the processor with the AudioWorkletGlobalScope
|
||
|
|
// VAL-M2-002: This registration must succeed for the processor to be usable
|
||
|
|
registerProcessor('c15-processor', C15Processor);
|