spessasynth_core 1.0.0

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/worklet_modulator.js

@@ -0,0 +1,173 @@
+import { modulatorSources } from '../../../soundfont/chunk/modulators.js'
+import { getModulatorCurveValue, MOD_PRECOMPUTED_LENGTH } from './modulator_curves.js'
+import { NON_CC_INDEX_OFFSET } from './worklet_processor_channel.js'
+
+/**
+ * worklet_modulator.js
+ * purpose: precomputes all curve types and computes modulators
+ */
+
+/**
+ * Computes a given modulator
+ * @param controllerTable {Int16Array} all midi controllers as 14bit values + the non controller indexes, starting at 128
+ * @param modulator {Modulator} the modulator to compute
+ * @param midiNote {number} the midiNote of the voice belonging to the modulator
+ * @param velocity {number} the velocity of the voice belonging to the modulator
+ * @returns {number} the computed value
+ */
+export function computeWorkletModulator(controllerTable, modulator, midiNote, velocity)
+{
+    if(modulator.transformAmount === 0)
+    {
+        return 0;
+    }
+    // mapped to 0-16384
+    let rawSourceValue = 0;
+    if(modulator.sourceUsesCC)
+    {
+        rawSourceValue = controllerTable[modulator.sourceIndex];
+    }
+    else
+    {
+        const index = modulator.sourceIndex + NON_CC_INDEX_OFFSET;
+        switch (modulator.sourceIndex)
+        {
+            case modulatorSources.noController:
+                return 0;// fluid_mod.c line 374 (0 times secondary times amount is still zero)
+
+            case modulatorSources.noteOnKeyNum:
+                rawSourceValue = midiNote << 7;
+                break;
+
+            case modulatorSources.noteOnVelocity:
+            case modulatorSources.polyPressure:
+                rawSourceValue = velocity << 7;
+                break;
+
+            default:
+                rawSourceValue = controllerTable[index]; // use the 7 bit value
+                break;
+        }
+
+    }
+
+    const sourceValue = transforms[modulator.sourceCurveType][modulator.sourcePolarity][modulator.sourceDirection][rawSourceValue];
+
+    // mapped to 0-127
+    let rawSecondSrcValue;
+    if(modulator.secSrcUsesCC)
+    {
+        rawSecondSrcValue = controllerTable[modulator.secSrcIndex];
+    }
+    else
+    {
+        const index = modulator.secSrcIndex + NON_CC_INDEX_OFFSET;
+        switch (modulator.secSrcIndex)
+        {
+            case modulatorSources.noController:
+                rawSecondSrcValue = 16383;// fluid_mod.c line 376
+                break;
+
+            case modulatorSources.noteOnKeyNum:
+                rawSecondSrcValue = midiNote << 7;
+                break;
+
+            case modulatorSources.noteOnVelocity:
+            case modulatorSources.polyPressure:
+                rawSecondSrcValue = velocity << 7;
+                break;
+
+            default:
+                rawSecondSrcValue = controllerTable[index];
+        }
+
+    }
+    const secondSrcValue = transforms[modulator.secSrcCurveType][modulator.secSrcPolarity][modulator.secSrcDirection][rawSecondSrcValue];
+
+
+    // compute the modulator
+    const computedValue = sourceValue * secondSrcValue * modulator.transformAmount;
+
+    if(modulator.transformType === 2)
+    {
+        // abs value
+        return Math.abs(computedValue);
+    }
+    return computedValue;
+}
+
+/**
+ * Computes all modulators of a given voice
+ * @param voice {WorkletVoice} the voice to compute modulators for
+ * @param controllerTable {Int16Array} all midi controllers as 14bit values + the non controller indexes, starting at 128
+ */
+export function computeModulators(voice, controllerTable)
+{
+    voice.modulatedGenerators.set(voice.generators);
+    voice.modulators.forEach(mod => {
+        voice.modulatedGenerators[mod.modulatorDestination] += computeWorkletModulator(controllerTable, mod, voice.midiNote, voice.velocity);
+    });
+}
+
+/**
+ * as follows: transforms[curveType][polarity][direction] is an array
+ * @type {Float32Array[][][]}
+ */
+const transforms = [];
+
+for(let curve = 0; curve < 4; curve++)
+{
+    transforms[curve] =
+    [
+        [
+            new Float32Array(MOD_PRECOMPUTED_LENGTH),
+            new Float32Array(MOD_PRECOMPUTED_LENGTH)
+        ],
+        [
+            new Float32Array(MOD_PRECOMPUTED_LENGTH),
+            new Float32Array(MOD_PRECOMPUTED_LENGTH)
+        ]
+    ];
+    for (let i = 0; i < MOD_PRECOMPUTED_LENGTH; i++) {
+
+        // polarity 0 dir 0
+        transforms[curve][0][0][i] = getModulatorCurveValue(
+            0,
+            curve,
+            i / MOD_PRECOMPUTED_LENGTH,
+            0);
+        if (isNaN(transforms[curve][0][0][i])) {
+            transforms[curve][0][0][i] = 1;
+        }
+
+        // polarity 1 dir 0
+        transforms[curve][1][0][i] = getModulatorCurveValue(
+            0,
+            curve,
+            i / MOD_PRECOMPUTED_LENGTH,
+            1);
+        if (isNaN(transforms[curve][1][0][i])) {
+            transforms[curve][1][0][i] = 1;
+        }
+
+        // polarity 0 dir 1
+        transforms[curve][0][1][i] = getModulatorCurveValue(
+            1,
+            curve,
+            i / MOD_PRECOMPUTED_LENGTH,
+            0);
+        if (isNaN(transforms[curve][0][1][i])) {
+            transforms[curve][0][1][i] = 1;
+        }
+
+        // polarity 1 dir 1
+        transforms[curve][1][1][i] = getModulatorCurveValue(
+            1,
+            curve,
+            i / MOD_PRECOMPUTED_LENGTH,
+            1);
+        if (isNaN(transforms[curve][1][1][i])) {
+            transforms[curve][1][1][i] = 1;
+        }
+    }
+}

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/worklet_processor_channel.js

@@ -0,0 +1,105 @@
+import { midiControllers } from '../../../midi_parser/midi_message.js'
+import { modulatorSources } from '../../../soundfont/chunk/modulators.js'
+/**
+ * @typedef {Object} WorkletProcessorChannel
+ * @property {Int16Array} midiControllers - array of MIDI controller values
+ * @property {boolean[]} lockedControllers - array indicating if a controller is locked
+ * @property {Float32Array} customControllers - array of custom (not sf2) control values such as RPN pitch tuning, transpose, modulation depth, etc.
+ * @property {boolean} holdPedal - indicates whether the hold pedal is active
+ * @property {boolean} drumChannel - indicates whether the channel is a drum channel
+ * @property {dataEntryStates} dataEntryState - the current state of the data entry
+ * @property {number} NRPCoarse - the current coarse value of the Non-Registered Parameter
+ * @property {number} NRPFine - the current fine value of the Non-Registered Parameter
+ * @property {number} RPValue - the current value of the Registered Parameter
+ *
+ * @property {Preset} preset - the channel's preset
+ * @property {boolean} lockPreset - indicates whether the program on the channel is locked
+ *
+ * @property {boolean} lockVibrato - indicates whether the custom vibrato is locked
+ * @property {Object} channelVibrato - vibrato settings for the channel
+ * @property {number} channelVibrato.depth - depth of the vibrato effect (cents)
+ * @property {number} channelVibrato.delay - delay before the vibrato effect starts (seconds)
+ * @property {number} channelVibrato.rate - rate of the vibrato oscillation (Hz)
+
+ * @property {boolean} isMuted - indicates whether the channel is muted
+ * @property {WorkletVoice[]} voices - array of voices currently active on the channel
+ * @property {WorkletVoice[]} sustainedVoices - array of voices that are sustained on the channel
+ * @property {WorkletVoice[][][]} cachedVoices - first is midi note, second is velocity. output is an array of WorkletVoices
+ */
+
+/**
+ * @this {Synthesizer}
+ */
+export function addNewChannel()
+{
+    /**
+     * @type {WorkletProcessorChannel}
+     */
+    const channel = {
+        midiControllers: new Int16Array(CONTROLLER_TABLE_SIZE),
+        lockedControllers: Array(CONTROLLER_TABLE_SIZE).fill(false),
+        customControllers: new Float32Array(CUSTOM_CONTROLLER_TABLE_SIZE),
+
+        NRPCoarse: 0,
+        NRPFine: 0,
+        RPValue: 0,
+        dataEntryState: dataEntryStates.Idle,
+
+        voices: [],
+        sustainedVoices: [],
+        cachedVoices: [],
+        preset: this.defaultPreset,
+
+        channelVibrato: {delay: 0, depth: 0, rate: 0},
+        lockVibrato: false,
+        holdPedal: false,
+        isMuted: false,
+        drumChannel: false,
+        lockPreset: false,
+
+    }
+    for (let i = 0; i < 128; i++) {
+        channel.cachedVoices.push([]);
+    }
+    this.workletProcessorChannels.push(channel);
+    this.resetControllers(this.workletProcessorChannels.length - 1);
+}
+
+export const NON_CC_INDEX_OFFSET = 128;
+export const CONTROLLER_TABLE_SIZE = 147;
+// an array with preset default values so we can quickly use set() to reset the controllers
+export const resetArray = new Int16Array(CONTROLLER_TABLE_SIZE);
+// default values (the array is 14 bit so shift the 7 bit values by 7 bits)
+resetArray[midiControllers.mainVolume] = 100 << 7;
+resetArray[midiControllers.expressionController] = 127 << 7;
+resetArray[midiControllers.pan] = 64 << 7;
+resetArray[midiControllers.releaseTime] = 64 << 7;
+resetArray[midiControllers.brightness] = 64 << 7;
+resetArray[midiControllers.effects1Depth] = 40 << 7;
+resetArray[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel] = 8192;
+resetArray[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] = 2 << 7;
+resetArray[NON_CC_INDEX_OFFSET + modulatorSources.channelPressure] = 127 << 7;
+
+/**
+ * @enum {number}
+ */
+export const dataEntryStates = {
+    Idle: 0,
+    RPCoarse: 1,
+    RPFine: 2,
+    NRPCoarse: 3,
+    NRPFine: 4,
+    DataCoarse: 5,
+    DataFine: 6
+};
+
+
+export const customControllers = {
+    channelTuning: 0, // cents
+    channelTranspose: 1, // cents
+    modulationMultiplier: 2, // cents
+    masterTuning: 3, // cents
+}
+export const CUSTOM_CONTROLLER_TABLE_SIZE = Object.keys(customControllers).length;
+export const customResetArray = new Float32Array(CUSTOM_CONTROLLER_TABLE_SIZE);
+customResetArray[customControllers.modulationMultiplier] = 1;

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/worklet_voice.js

@@ -0,0 +1,313 @@
+/**
+ * worklet_voice.js
+ * purpose: prepares workletvoices from sample and generator data and manages sample dumping
+ * note: sample dumping means sending it over to the AudioWorkletGlobalScope
+ */
+
+/**
+ * @typedef {Object} WorkletSample
+ * @property {number} sampleID - ID of the sample
+ * @property {number} playbackStep - current playback step (rate)
+ * @property {number} cursor - current position in the sample
+ * @property {number} rootKey - root key of the sample
+ * @property {number} loopStart - start position of the loop
+ * @property {number} loopEnd - end position of the loop
+ * @property {number} end - end position of the sample
+ * @property {0|1|2} loopingMode - looping mode of the sample
+ */
+
+/**
+ * @typedef {Object} WorkletLowpassFilter
+ * @property {number} a0 - filter coefficient 1
+ * @property {number} a1 - filter coefficient 2
+ * @property {number} a2 - filter coefficient 3
+ * @property {number} a3 - filter coefficient 4
+ * @property {number} a4 - filter coefficient 5
+ * @property {number} x1 - input history 1
+ * @property {number} x2 - input history 2
+ * @property {number} y1 - output history 1
+ * @property {number} y2 - output history 2
+ * @property {number} reasonanceCb - reasonance in centibels
+ * @property {number} reasonanceGain - resonance gain
+ * @property {number} cutoffCents - cutoff frequency in cents
+ * @property {number} cutoffHz - cutoff frequency in Hz
+ */
+
+/**
+ * @typedef {Object} WorkletVoice
+ * @property {WorkletSample} sample - sample ID for voice.
+ * @property {WorkletLowpassFilter} filter - lowpass filter applied to the voice
+ * @property {Int16Array} generators - the unmodulated (constant) generators of the voice
+ * @property {Modulator[]} modulators - the voice's modulators
+ * @property {Int16Array} modulatedGenerators - the generators modulated by the modulators
+ *
+ * @property {boolean} finished - indicates if the voice has finished
+ * @property {boolean} isInRelease - indicates if the voice is in the release phase
+ *
+ * @property {number} channelNumber - MIDI channel number
+ * @property {number} velocity - velocity of the note
+ * @property {number} midiNote - MIDI note number
+ * @property {number} targetKey - target key for the note
+ *
+ * @property {number} currentAttenuationDb - current attenuation in dB (used for calculating start of the release phase)
+ * @property {0|1|2|3|4} volumeEnvelopeState - state of the volume envelope.
+ * @property {number} currentModEnvValue - current value of the modulation envelope
+ *
+ * @property {number} startTime - start time of the voice
+ * @property {number} releaseStartTime - start time of the release phase
+ * @property {number} releaseStartModEnv - modenv value at the start of the release phase
+ *
+ * @property {number} currentTuningCents - current tuning adjustment in cents
+ * @property {number} currentTuningCalculated - calculated tuning adjustment
+ * @property {number} currentPan - from 0 to 1
+ */
+
+import { addAndClampGenerator, generatorTypes } from '../../../soundfont/chunk/generators.js'
+import { SpessaSynthTable } from '../../../utils/loggin.js'
+
+
+/**
+ * the sampleID is the index
+ * @type {boolean[]}
+ */
+let globalDumpedSamplesList = [];
+
+export function clearSamplesList()
+{
+    globalDumpedSamplesList = [];
+}
+
+function /**
+ * This is how the logic works: since sf3 is compressed, we rely on an async decoder.
+ * So, if the sample isn't loaded yet:
+ * send the workletVoice (generators, modulators, etc) and the WorkletSample(sampleID + end offset + loop)
+ * once the voice is done, then we dump it.
+ *
+ * on the WorkletScope side:
+ * skip the voice if sampleID isn't valid
+ * once we receive a sample dump, adjust all voice endOffsets (loop is already correct in sf3)
+ * now the voice starts playing, yay!
+ * @param channel {number} channel hint for the processor to recalculate cursor positions
+ * @param sample {Sample}
+ * @param id {number}
+ * @param sampleDumpCallback {function({channel: number, sampleID: number, sampleData: Float32Array})}
+ */
+dumpSample(channel, sample, id, sampleDumpCallback)
+{
+    // flag as defined, so it's currently being dumped
+    globalDumpedSamplesList[id] = false;
+
+    // load the data
+    sampleDumpCallback({
+        channel: channel,
+        sampleID: id,
+        sampleData: sample.getAudioData()
+    });
+    globalDumpedSamplesList[id] = true;
+}
+
+/**
+ * Deep clone function for the WorkletVoice object and its nested structures.
+ * This function handles Int16Array, objects, arrays, and primitives.
+ * It does not handle circular references.
+ * @param {WorkletVoice} obj - The object to clone.
+ * @returns {WorkletVoice} - Cloned object.
+ */
+function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+
+    // Handle Int16Array separately
+    if (obj instanceof Int16Array) {
+        return new Int16Array(obj);
+    }
+
+    // Handle objects and arrays
+    const clonedObj = Array.isArray(obj) ? [] : {};
+    for (let key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            if (typeof obj[key] === 'object' && obj[key] !== null) {
+                clonedObj[key] = deepClone(obj[key]); // Recursively clone nested objects
+            } else if (obj[key] instanceof Int16Array) {
+                clonedObj[key] = new Int16Array(obj[key]); // Clone Int16Array
+            } else {
+                clonedObj[key] = obj[key]; // Copy primitives
+            }
+        }
+    }
+    return clonedObj;
+}
+
+
+/**
+ * @param channel {number} a hint for the processor to recalculate sample cursors when sample dumping
+ * @param midiNote {number}
+ * @param velocity {number}
+ * @param preset {Preset}
+ * @param currentTime {number}
+ * @param sampleRate {number}
+ * @param sampleDumpCallback {function({channel: number, sampleID: number, sampleData: Float32Array})}
+ * @param cachedVoices {WorkletVoice[][][]} first is midi note, second is velocity. output is an array of WorkletVoices
+ * @param debug {boolean}
+ * @returns {WorkletVoice[]}
+ */
+export function getWorkletVoices(channel,
+                                 midiNote,
+                                 velocity,
+                                 preset,
+                                 currentTime,
+                                 sampleRate,
+                                 sampleDumpCallback,
+                                 cachedVoices,
+                                 debug=false)
+{
+    /**
+     * @type {WorkletVoice[]}
+     */
+    let workletVoices;
+
+    const cached = cachedVoices[midiNote][velocity];
+    if(cached)
+    {
+        workletVoices = cached.map(deepClone);
+        workletVoices.forEach(v => {
+            v.startTime = currentTime;
+        });
+    }
+    else
+    {
+        let canCache = true;
+        /**
+         * @returns {WorkletVoice}
+         */
+        workletVoices = preset.getSamplesAndGenerators(midiNote, velocity).map(sampleAndGenerators => {
+            // dump the sample if haven't already
+            if (globalDumpedSamplesList[sampleAndGenerators.sampleID] !== true) {
+                // if the sample is currently being loaded, don't dump again (undefined means not loaded, false means is being loaded)
+                if(globalDumpedSamplesList[sampleAndGenerators.sampleID] === undefined) {
+                    dumpSample(channel, sampleAndGenerators.sample, sampleAndGenerators.sampleID, sampleDumpCallback);
+                }
+
+                // can't cache the voice as the end in workletSample maybe is incorrect (the sample is still loading)
+                if(globalDumpedSamplesList[sampleAndGenerators.sampleID] !== true)
+                {
+                    canCache = false;
+                }
+            }
+
+            // create the generator list
+            const generators = new Int16Array(60);
+            // apply and sum the gens
+            for (let i = 0; i < 60; i++) {
+                generators[i] = addAndClampGenerator(i, sampleAndGenerators.presetGenerators, sampleAndGenerators.instrumentGenerators);
+            }
+
+            // !! EMU initial attenuation correction, multiply initial attenuation by 0.4
+            generators[generatorTypes.initialAttenuation] = Math.floor(generators[generatorTypes.initialAttenuation] * 0.4);
+
+            // key override
+            let rootKey = sampleAndGenerators.sample.samplePitch;
+            if (generators[generatorTypes.overridingRootKey] > -1) {
+                rootKey = generators[generatorTypes.overridingRootKey];
+            }
+
+            let targetKey = midiNote;
+            if (generators[generatorTypes.keyNum] > -1) {
+                targetKey = generators[generatorTypes.keyNum];
+            }
+
+            // determine looping mode now. if the loop is too small, disable
+            const loopStart = (sampleAndGenerators.sample.sampleLoopStartIndex / 2) + (generators[generatorTypes.startloopAddrsOffset] + (generators[generatorTypes.startloopAddrsCoarseOffset] * 32768));
+            const loopEnd = (sampleAndGenerators.sample.sampleLoopEndIndex / 2) + (generators[generatorTypes.endloopAddrsOffset] + (generators[generatorTypes.endloopAddrsCoarseOffset] * 32768));
+            let loopingMode = generators[generatorTypes.sampleModes];
+            if (loopEnd - loopStart < 1) {
+                loopingMode = 0;
+            }
+
+            // determine end
+            /**
+             * create the worklet sample
+             * @type {WorkletSample}
+             */
+            const workletSample = {
+                sampleID: sampleAndGenerators.sampleID,
+                playbackStep: (sampleAndGenerators.sample.sampleRate / sampleRate) * Math.pow(2, sampleAndGenerators.sample.samplePitchCorrection / 1200),// cent tuning
+                cursor: generators[generatorTypes.startAddrsOffset] + (generators[generatorTypes.startAddrsCoarseOffset] * 32768),
+                rootKey: rootKey,
+                loopStart: loopStart,
+                loopEnd: loopEnd,
+                end: Math.floor( sampleAndGenerators.sample.sampleData.length) - 1 + (generators[generatorTypes.endAddrOffset] + (generators[generatorTypes.endAddrsCoarseOffset] * 32768)),
+                loopingMode: loopingMode
+            };
+
+            // velocity override
+            if (generators[generatorTypes.velocity] > -1) {
+                velocity = generators[generatorTypes.velocity];
+            }
+
+            if(debug)
+            {
+                SpessaSynthTable([{
+                    Sample: sampleAndGenerators.sample.sampleName,
+                    Generators: generators,
+                    Modulators: sampleAndGenerators.modulators.map(m => m.debugString()),
+                    Velocity: velocity,
+                    TargetKey: targetKey,
+                    MidiNote: midiNote,
+                    WorkletSample: workletSample
+                }]);
+            }
+
+            return {
+                filter: {
+                    a0: 0,
+                    a1: 0,
+                    a2: 0,
+                    a3: 0,
+                    a4: 0,
+
+                    x1: 0,
+                    x2: 0,
+                    y1: 0,
+                    y2: 0,
+                    reasonanceCb: 0,
+                    reasonanceGain: 1,
+                    cutoffCents: 13500,
+                    cutoffHz: 20000
+                },
+                // generators and modulators
+                generators: generators,
+                modulators: sampleAndGenerators.modulators,
+                modulatedGenerators: new Int16Array(60),
+
+                // sample and playback data
+                sample: workletSample,
+                velocity: velocity,
+                midiNote: midiNote,
+                channelNumber: channel,
+                startTime: currentTime,
+                targetKey: targetKey,
+                currentTuningCalculated: 1,
+                currentTuningCents: 0,
+                releaseStartTime: Infinity,
+
+                // envelope data
+                finished: false,
+                isInRelease: false,
+                currentAttenuationDb: 100,
+                currentModEnvValue: 0,
+                releaseStartModEnv: 1,
+                volumeEnvelopeState: 0,
+                currentPan: 0.5
+            };
+
+        });
+        // cache the voice
+        if(canCache) {
+            // clone it so the system won't mess with it!
+            cachedVoices[midiNote][velocity] = workletVoices.map(deepClone);
+        }
+    }
+    return workletVoices;
+}

package/spessasynth_core/utils/README.md

@@ -0,0 +1,4 @@
+## This is the utility folder.
+There are various utilites here used by the SpessaSynth library.
+
+### Note that the stbvorbis_sync.js is licensed under Apache-2.0.

package/spessasynth_core/utils/buffer_to_wav.js

@@ -0,0 +1,70 @@
+/**
+ *
+ * @param sampleRate {number}
+ * @param left {Float32Array}
+ * @param right {Float32Array}
+ * @returns {ArrayBufferLike}
+ */
+export function rawDataToWav(sampleRate, left, right)
+{
+
+    const length = left.length;
+
+    const bytesPerSample = 2; // 16-bit PCM
+
+    // Prepare the header
+    const headerSize = 44;
+    const dataSize = length * 2 * bytesPerSample; // 2 channels, 16-bit per channel
+    const fileSize = headerSize + dataSize - 8; // total file size minus the first 8 bytes
+    const header = new Uint8Array(headerSize);
+
+    // 'RIFF'
+    header.set([82, 73, 70, 70], 0);
+    // file length
+    header.set(new Uint8Array([fileSize & 0xff, (fileSize >> 8) & 0xff, (fileSize >> 16) & 0xff, (fileSize >> 24) & 0xff]), 4);
+    // 'WAVE'
+    header.set([87, 65, 86, 69], 8);
+    // 'fmt '
+    header.set([102, 109, 116, 32], 12);
+    // fmt chunk length
+    header.set([16, 0, 0, 0], 16); // 16 for PCM
+    // audio format (PCM)
+    header.set([1, 0], 20);
+    // number of channels (2)
+    header.set([2, 0], 22);
+    // sample rate
+    header.set(new Uint8Array([sampleRate & 0xff, (sampleRate >> 8) & 0xff, (sampleRate >> 16) & 0xff, (sampleRate >> 24) & 0xff]), 24);
+    // byte rate (sample rate * block align)
+    const byteRate = sampleRate * 2 * bytesPerSample; // 2 channels, 16-bit per channel
+    header.set(new Uint8Array([byteRate & 0xff, (byteRate >> 8) & 0xff, (byteRate >> 16) & 0xff, (byteRate >> 24) & 0xff]), 28);
+    // block align (channels * bytes per sample)
+    header.set([4, 0], 32); // 2 channels * 16-bit per channel / 8
+    // bits per sample
+    header.set([16, 0], 34); // 16-bit
+
+    // data chunk identifier 'data'
+    header.set([100, 97, 116, 97], 36);
+    // data chunk length
+    header.set(new Uint8Array([dataSize & 0xff, (dataSize >> 8) & 0xff, (dataSize >> 16) & 0xff, (dataSize >> 24) & 0xff]), 40);
+
+    const wavData = new Uint8Array(headerSize + dataSize);
+    wavData.set(header, 0);
+
+    // Interleave audio data (combine channels)
+    let offset = headerSize;
+    for (let i = 0; i < length; i++)
+    {
+        // interleave both channels
+        const sample1 = Math.max(-1, Math.min(1, left[i])) * 0x7FFF;
+        const sample2 = Math.max(-1, Math.min(1, right[i])) * 0x7FFF;
+
+        // convert to 16-bit
+        wavData[offset++] = sample1 & 0xff;
+        wavData[offset++] = (sample1 >> 8) & 0xff;
+        wavData[offset++] = sample2 & 0xff;
+        wavData[offset++] = (sample2 >> 8) & 0xff;
+    }
+
+
+    return wavData.buffer;
+}