@jadujoel/web-audio-clip-node 0.1.6 → 0.1.8

package/examples/react/node_modules/@jadujoel/web-audio-clip-node/dist/audio/processor-kernel.js

@@ -0,0 +1,892 @@
+// processor-kernel.ts — Pure DSP logic, state machine, all filters
+// NO AudioWorklet or platform dependencies. Fully testable.
+import { State, } from "./types.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+export const SAMPLE_BLOCK_SIZE = 128;
+function createStreamBufferState(buffer = []) {
+    const totalLength = buffer[0]?.length ?? 0;
+    const hasBuffer = totalLength > 0;
+    return {
+        totalLength: hasBuffer ? totalLength : null,
+        committedLength: hasBuffer ? totalLength : 0,
+        streamEnded: hasBuffer,
+        streaming: false,
+        writtenSpans: hasBuffer ? [{ startSample: 0, endSample: totalLength }] : [],
+        pendingWrites: [],
+        lowWaterThreshold: SAMPLE_BLOCK_SIZE * 4,
+        lowWaterNotified: false,
+        lastUnderrunSample: null,
+    };
+}
+function getBufferLength(buffer) {
+    return buffer[0]?.length ?? 0;
+}
+function getLogicalBufferLength(properties) {
+    return (properties.streamBuffer.totalLength ?? getBufferLength(properties.buffer));
+}
+function createSilentBuffer(channels, length) {
+    return Array.from({ length: channels }, () => new Float32Array(length));
+}
+function mergeWrittenSpan(spans, nextSpan) {
+    const merged = [...spans, nextSpan].sort((a, b) => a.startSample - b.startSample);
+    const result = [];
+    for (const span of merged) {
+        const previous = result[result.length - 1];
+        if (!previous || span.startSample > previous.endSample) {
+            result.push({ ...span });
+            continue;
+        }
+        previous.endSample = Math.max(previous.endSample, span.endSample);
+    }
+    return result;
+}
+function getCommittedLength(spans) {
+    let committedLength = 0;
+    for (const span of spans) {
+        if (span.startSample > committedLength)
+            break;
+        committedLength = Math.max(committedLength, span.endSample);
+    }
+    return committedLength;
+}
+function resetLowWaterState(streamBuffer, playhead) {
+    if (streamBuffer.committedLength - Math.floor(playhead) >=
+        streamBuffer.lowWaterThreshold) {
+        streamBuffer.lowWaterNotified = false;
+    }
+}
+function ensureBufferCapacity(properties, requiredChannels, requiredLength) {
+    const currentLength = getBufferLength(properties.buffer);
+    const currentChannels = properties.buffer.length;
+    if (currentLength >= requiredLength && currentChannels >= requiredChannels) {
+        return;
+    }
+    const nextLength = Math.max(currentLength, requiredLength);
+    const nextChannels = Math.max(currentChannels, requiredChannels);
+    const nextBuffer = createSilentBuffer(nextChannels, nextLength);
+    for (let ch = 0; ch < currentChannels; ch++) {
+        nextBuffer[ch].set(properties.buffer[ch].subarray(0, currentLength));
+    }
+    properties.buffer = nextBuffer;
+    if (properties.streamBuffer.totalLength == null ||
+        properties.streamBuffer.totalLength < nextLength) {
+        properties.streamBuffer.totalLength = nextLength;
+    }
+}
+function applyBufferRangeWrite(properties, write) {
+    const startSample = Math.max(Math.floor(write.startSample), 0);
+    const writeLength = write.channelData[0]?.length ?? 0;
+    const requestedTotalLength = write.totalLength ?? null;
+    const requiredLength = Math.max(startSample + writeLength, requestedTotalLength ?? 0);
+    ensureBufferCapacity(properties, Math.max(write.channelData.length, properties.buffer.length, 1), requiredLength);
+    for (let ch = 0; ch < write.channelData.length; ch++) {
+        properties.buffer[ch].set(write.channelData[ch], startSample);
+    }
+    if (requestedTotalLength != null) {
+        properties.streamBuffer.totalLength = requestedTotalLength;
+    }
+    if (writeLength > 0) {
+        properties.streamBuffer.writtenSpans = mergeWrittenSpan(properties.streamBuffer.writtenSpans, { startSample, endSample: startSample + writeLength });
+        properties.streamBuffer.committedLength = getCommittedLength(properties.streamBuffer.writtenSpans);
+    }
+    if (write.streamEnded === true) {
+        properties.streamBuffer.streamEnded = true;
+    }
+    resetLowWaterState(properties.streamBuffer, properties.playhead);
+}
+function applyPendingBufferWrites(properties) {
+    if (properties.streamBuffer.pendingWrites.length === 0) {
+        return;
+    }
+    for (const write of properties.streamBuffer.pendingWrites) {
+        applyBufferRangeWrite(properties, write);
+    }
+    properties.streamBuffer.pendingWrites = [];
+}
+function setWholeBuffer(properties, buffer) {
+    properties.buffer = buffer;
+    properties.streamBuffer = createStreamBufferState(buffer);
+}
+// ---------------------------------------------------------------------------
+// Properties & offset
+// ---------------------------------------------------------------------------
+export function getProperties(opts = {}, sampleRate) {
+    const { buffer = [], streamBuffer = createStreamBufferState(buffer), duration = -1, loop = false, loopStart = 0, loopEnd = (buffer[0]?.length ?? 0) / sampleRate, loopCrossfade = 0, playhead = 0, offset = 0, startWhen = 0, stopWhen = 0, pauseWhen = 0, resumeWhen = 0, playedSamples = 0, state = State.Initial, timesLooped = 0, fadeInDuration = 0, fadeOutDuration = 0, enableFadeIn = fadeInDuration > 0, enableFadeOut = fadeOutDuration > 0, enableLoopStart = true, enableLoopEnd = true, enableLoopCrossfade = loopCrossfade > 0, enableHighpass = true, enableLowpass = true, enableGain = true, enablePan = true, enableDetune = true, enablePlaybackRate = true, } = opts;
+    return {
+        buffer,
+        streamBuffer,
+        loop,
+        loopStart,
+        loopEnd,
+        loopCrossfade,
+        duration,
+        playhead,
+        offset,
+        startWhen,
+        stopWhen,
+        pauseWhen,
+        resumeWhen,
+        playedSamples,
+        state,
+        timesLooped,
+        fadeInDuration,
+        fadeOutDuration,
+        enableFadeIn,
+        enableFadeOut,
+        enableLoopStart,
+        enableLoopEnd,
+        enableHighpass,
+        enableLowpass,
+        enableGain,
+        enablePan,
+        enableDetune,
+        enablePlaybackRate,
+        enableLoopCrossfade,
+    };
+}
+function getBufferDurationSeconds(properties, sampleRate) {
+    return getLogicalBufferLength(properties) / sampleRate;
+}
+function normalizeLoopBounds(properties, sampleRate) {
+    const bufferDuration = getBufferDurationSeconds(properties, sampleRate);
+    if (bufferDuration <= 0) {
+        properties.loopStart = 0;
+        properties.loopEnd = 0;
+        return;
+    }
+    if (!Number.isFinite(properties.loopStart) || properties.loopStart < 0) {
+        properties.loopStart = 0;
+    }
+    if (properties.loopStart >= bufferDuration) {
+        properties.loopStart = 0;
+    }
+    if (!Number.isFinite(properties.loopEnd) ||
+        properties.loopEnd <= properties.loopStart ||
+        properties.loopEnd > bufferDuration) {
+        properties.loopEnd = bufferDuration;
+    }
+}
+export function setOffset(properties, offset, sampleRate) {
+    if (offset === undefined) {
+        properties.offset = 0;
+        return 0;
+    }
+    if (offset < 0) {
+        return setOffset(properties, getLogicalBufferLength(properties) + offset, sampleRate);
+    }
+    if (offset > (getLogicalBufferLength(properties) || 1) - 1) {
+        return setOffset(properties, getLogicalBufferLength(properties) % offset, sampleRate);
+    }
+    const offs = Math.floor(offset * sampleRate);
+    properties.offset = offs;
+    return offs;
+}
+// ---------------------------------------------------------------------------
+// Index calculation
+// ---------------------------------------------------------------------------
+export function findIndexesNormal(p) {
+    const { playhead, bufferLength, loop, loopStartSamples, loopEndSamples } = p;
+    let length = 128;
+    if (!loop && playhead + 128 > bufferLength) {
+        length = Math.max(bufferLength - playhead, 0);
+    }
+    const indexes = new Array(length);
+    if (!loop) {
+        for (let i = 0, head = playhead; i < length; i++, head++) {
+            indexes[i] = head;
+        }
+        const nextPlayhead = playhead + length;
+        return {
+            playhead: nextPlayhead,
+            indexes,
+            looped: false,
+            ended: nextPlayhead >= bufferLength,
+        };
+    }
+    let head = playhead;
+    let looped = false;
+    for (let i = 0; i < length; i++, head++) {
+        if (head >= loopEndSamples) {
+            head = loopStartSamples + (head - loopEndSamples);
+            looped = true;
+        }
+        indexes[i] = head;
+    }
+    return { indexes, looped, ended: false, playhead: head };
+}
+export function findIndexesWithPlaybackRates(p) {
+    const { playhead, bufferLength, loop, loopStartSamples, loopEndSamples, playbackRates, } = p;
+    let length = 128;
+    if (!loop && playhead + 128 > bufferLength) {
+        length = Math.max(bufferLength - playhead, 0);
+    }
+    const indexes = new Array(length);
+    let head = playhead;
+    let looped = false;
+    if (loop) {
+        for (let i = 0; i < length; i++) {
+            indexes[i] = Math.min(Math.max(Math.floor(head), 0), bufferLength - 1);
+            const rate = playbackRates[i] ?? playbackRates[0] ?? 1;
+            head += rate;
+            if (rate >= 0 && (head > loopEndSamples || head > bufferLength)) {
+                head = loopStartSamples;
+                looped = true;
+            }
+            else if (rate < 0 && (head < loopStartSamples || head < 0)) {
+                head = loopEndSamples;
+                looped = true;
+            }
+        }
+        return { playhead: head, indexes, looped, ended: false };
+    }
+    for (let i = 0; i < length; i++) {
+        indexes[i] = Math.min(Math.max(Math.floor(head), 0), bufferLength - 1);
+        head += playbackRates[i] ?? playbackRates[0] ?? 1;
+    }
+    return {
+        playhead: head,
+        indexes,
+        looped: false,
+        ended: head >= bufferLength || head < 0,
+    };
+}
+// ---------------------------------------------------------------------------
+// Buffer operations
+// ---------------------------------------------------------------------------
+export function fill(target, source, indexes) {
+    const nc = Math.min(target.length, source.length);
+    for (let i = 0; i < indexes.length; i++) {
+        for (let ch = 0; ch < nc; ch++) {
+            target[ch][i] = source[ch][indexes[i]];
+        }
+    }
+    for (let ch = nc; ch < target.length; ch++) {
+        for (let i = 0; i < target[ch].length; i++) {
+            target[ch][i] = 0;
+        }
+    }
+    for (let i = indexes.length; i < target[0].length; i++) {
+        for (let ch = 0; ch < nc; ch++) {
+            target[ch][i] = 0;
+        }
+    }
+}
+export function fillWithSilence(buffer) {
+    for (let ch = 0; ch < buffer.length; ch++) {
+        for (let j = 0; j < buffer[ch].length; j++) {
+            buffer[ch][j] = 0;
+        }
+    }
+}
+export function monoToStereo(signal) {
+    if (signal.length >= 2) {
+        // Output already has a second channel — copy mono data into it
+        for (let i = 0; i < signal[0].length; i++) {
+            signal[1][i] = signal[0][i];
+        }
+    }
+    else {
+        const r = new Float32Array(signal[0].length);
+        for (let i = 0; i < signal[0].length; i++) {
+            r[i] = signal[0][i];
+        }
+        signal.push(r);
+    }
+}
+export function copy(source, target) {
+    for (let i = target.length; i < source.length; i++) {
+        target[i] = new Float32Array(source[i].length);
+    }
+    for (let ch = 0; ch < source.length; ch++) {
+        for (let i = 0; i < source[ch].length; i++) {
+            target[ch][i] = source[ch][i];
+        }
+    }
+}
+export function checkNans(output) {
+    let numNans = 0;
+    for (let ch = 0; ch < output.length; ch++) {
+        for (let j = 0; j < output[ch].length; j++) {
+            if (Number.isNaN(output[ch][j])) {
+                numNans++;
+                output[ch][j] = 0;
+            }
+        }
+    }
+    return numNans;
+}
+export function createFilterState() {
+    return [
+        { x_1: 0, x_2: 0, y_1: 0, y_2: 0 },
+        { x_1: 0, x_2: 0, y_1: 0, y_2: 0 },
+    ];
+}
+export function gainFilter(arr, gains) {
+    if (gains.length === 1) {
+        const g = gains[0];
+        if (g === 1)
+            return;
+        for (const ch of arr) {
+            for (let i = 0; i < ch.length; i++)
+                ch[i] *= g;
+        }
+        return;
+    }
+    let g = gains[0];
+    for (const ch of arr) {
+        for (let i = 0; i < ch.length; i++) {
+            g = gains[i] ?? g;
+            ch[i] *= g;
+        }
+    }
+}
+export function panFilter(signal, pans) {
+    let pan = pans[0];
+    for (let i = 0; i < signal[0].length; i++) {
+        pan = pans[i] ?? pan;
+        const leftGain = pan <= 0 ? 1 : 1 - pan;
+        const rightGain = pan >= 0 ? 1 : 1 + pan;
+        signal[0][i] *= leftGain;
+        signal[1][i] *= rightGain;
+    }
+}
+export function lowpassFilter(buffer, cutoffs, sampleRate, states) {
+    for (let channel = 0; channel < buffer.length; channel++) {
+        const arr = buffer[channel];
+        let { x_1, x_2, y_1, y_2 } = states[channel] ?? {
+            x_1: 0,
+            x_2: 0,
+            y_1: 0,
+            y_2: 0,
+        };
+        if (cutoffs.length === 1) {
+            const cutoff = cutoffs[0];
+            if (cutoff >= 20000)
+                return;
+            const w0 = (2 * Math.PI * cutoff) / sampleRate;
+            const alpha = Math.sin(w0) / 2;
+            const b0 = (1 - Math.cos(w0)) / 2;
+            const b1 = 1 - Math.cos(w0);
+            const b2 = (1 - Math.cos(w0)) / 2;
+            const a0 = 1 + alpha;
+            const a1 = -2 * Math.cos(w0);
+            const a2 = 1 - alpha;
+            const h0 = b0 / a0, h1 = b1 / a0, h2 = b2 / a0, h3 = a1 / a0, h4 = a2 / a0;
+            for (let i = 0; i < arr.length; i++) {
+                const x = arr[i];
+                const y = h0 * x + h1 * x_1 + h2 * x_2 - h3 * y_1 - h4 * y_2;
+                x_2 = x_1;
+                x_1 = x;
+                y_2 = y_1;
+                y_1 = y;
+                arr[i] = y;
+            }
+        }
+        else {
+            const prevCutoff = cutoffs[0];
+            for (let i = 0; i < arr.length; i++) {
+                const cutoff = cutoffs[i] ?? prevCutoff;
+                const w0 = (2 * Math.PI * cutoff) / sampleRate;
+                const alpha = Math.sin(w0) / 2;
+                const b0 = (1 - Math.cos(w0)) / 2;
+                const b1 = 1 - Math.cos(w0);
+                const b2 = (1 - Math.cos(w0)) / 2;
+                const a0 = 1 + alpha;
+                const a1 = -2 * Math.cos(w0);
+                const a2 = 1 - alpha;
+                const x = arr[i];
+                const y = (b0 / a0) * x +
+                    (b1 / a0) * x_1 +
+                    (b2 / a0) * x_2 -
+                    (a1 / a0) * y_1 -
+                    (a2 / a0) * y_2;
+                x_2 = x_1;
+                x_1 = x;
+                y_2 = y_1;
+                y_1 = y;
+                arr[i] = y;
+            }
+        }
+        states[channel] = { x_1, x_2, y_1, y_2 };
+    }
+}
+export function highpassFilter(buffer, cutoffs, sampleRate, states) {
+    for (let channel = 0; channel < buffer.length; channel++) {
+        const arr = buffer[channel];
+        let { x_1, x_2, y_1, y_2 } = states[channel] ?? {
+            x_1: 0,
+            x_2: 0,
+            y_1: 0,
+            y_2: 0,
+        };
+        if (cutoffs.length === 1) {
+            const cutoff = cutoffs[0];
+            if (cutoff <= 20)
+                return;
+            const w0 = (2 * Math.PI * cutoff) / sampleRate;
+            const alpha = Math.sin(w0) / 2;
+            const b0 = (1 + Math.cos(w0)) / 2;
+            const b1 = -(1 + Math.cos(w0));
+            const b2 = (1 + Math.cos(w0)) / 2;
+            const a0 = 1 + alpha;
+            const a1 = -2 * Math.cos(w0);
+            const a2 = 1 - alpha;
+            for (let i = 0; i < arr.length; i++) {
+                const x = arr[i];
+                const y = (b0 / a0) * x +
+                    (b1 / a0) * x_1 +
+                    (b2 / a0) * x_2 -
+                    (a1 / a0) * y_1 -
+                    (a2 / a0) * y_2;
+                x_2 = x_1;
+                x_1 = x;
+                y_2 = y_1;
+                y_1 = y;
+                arr[i] = y;
+            }
+        }
+        else {
+            const prevCutoff = cutoffs[0];
+            for (let i = 0; i < arr.length; i++) {
+                const cutoff = cutoffs[i] ?? prevCutoff;
+                const w0 = (2 * Math.PI * cutoff) / sampleRate;
+                const alpha = Math.sin(w0) / 2;
+                const b0 = (1 + Math.cos(w0)) / 2;
+                const b1 = -(1 + Math.cos(w0));
+                const b2 = (1 + Math.cos(w0)) / 2;
+                const a0 = 1 + alpha;
+                const a1 = -2 * Math.cos(w0);
+                const a2 = 1 - alpha;
+                const x = arr[i];
+                const y = (b0 / a0) * x +
+                    (b1 / a0) * x_1 +
+                    (b2 / a0) * x_2 -
+                    (a1 / a0) * y_1 -
+                    (a2 / a0) * y_2;
+                x_2 = x_1;
+                x_1 = x;
+                y_2 = y_1;
+                y_1 = y;
+                arr[i] = y;
+            }
+        }
+        states[channel] = { x_1, x_2, y_1, y_2 };
+    }
+}
+export function handleProcessorMessage(properties, message, currentTime, sampleRate) {
+    const { type, data } = message;
+    switch (type) {
+        case "buffer":
+            setWholeBuffer(properties, data);
+            normalizeLoopBounds(properties, sampleRate);
+            return [];
+        case "bufferInit": {
+            const init = data;
+            properties.buffer = createSilentBuffer(init.channels, init.totalLength);
+            properties.streamBuffer = {
+                ...createStreamBufferState(),
+                totalLength: init.totalLength,
+                streamEnded: false,
+                streaming: init.streaming ?? true,
+            };
+            normalizeLoopBounds(properties, sampleRate);
+            return [];
+        }
+        case "bufferRange":
+            properties.streamBuffer.pendingWrites.push(data);
+            return [];
+        case "bufferEnd": {
+            const endData = data;
+            if (endData?.totalLength != null) {
+                properties.streamBuffer.totalLength = endData.totalLength;
+            }
+            properties.streamBuffer.streamEnded = true;
+            return [];
+        }
+        case "bufferReset":
+            properties.buffer = [];
+            properties.streamBuffer = createStreamBufferState();
+            normalizeLoopBounds(properties, sampleRate);
+            return [];
+        case "start":
+            properties.timesLooped = 0;
+            {
+                const d = data;
+                properties.duration = d?.duration ?? -1;
+                if (properties.duration === -1) {
+                    properties.duration = properties.loop
+                        ? Number.MAX_SAFE_INTEGER
+                        : (properties.buffer[0]?.length ?? 0) / sampleRate;
+                }
+                setOffset(properties, d?.offset, sampleRate);
+                normalizeLoopBounds(properties, sampleRate);
+                properties.playhead = properties.offset;
+                properties.startWhen = d?.when ?? currentTime;
+                properties.stopWhen = properties.startWhen + properties.duration;
+                properties.playedSamples = 0;
+                properties.state = State.Scheduled;
+            }
+            return [{ type: "scheduled" }];
+        case "stop":
+            if (properties.state === State.Ended ||
+                properties.state === State.Initial)
+                return [];
+            properties.stopWhen = data ?? properties.stopWhen;
+            properties.state = State.Stopped;
+            return [{ type: "stopped" }];
+        case "pause":
+            properties.state = State.Paused;
+            properties.pauseWhen = data ?? currentTime;
+            return [{ type: "paused" }];
+        case "resume":
+            properties.state = State.Started;
+            properties.startWhen = data ?? currentTime;
+            return [{ type: "resume" }];
+        case "dispose":
+            properties.state = State.Disposed;
+            properties.buffer = [];
+            properties.streamBuffer = createStreamBufferState();
+            return [{ type: "disposed" }];
+        case "loop": {
+            const loop = data;
+            const st = properties.state;
+            if (loop && (st === State.Scheduled || st === State.Started)) {
+                properties.stopWhen = Number.MAX_SAFE_INTEGER;
+                properties.duration = Number.MAX_SAFE_INTEGER;
+            }
+            properties.loop = loop;
+            if (loop) {
+                normalizeLoopBounds(properties, sampleRate);
+            }
+            return [];
+        }
+        case "loopStart":
+            properties.loopStart = data;
+            return [];
+        case "loopEnd":
+            properties.loopEnd = data;
+            return [];
+        case "loopCrossfade":
+            properties.loopCrossfade = data;
+            properties.enableLoopCrossfade = properties.loopCrossfade > 0;
+            return [];
+        case "playhead":
+            properties.playhead = Math.floor(data);
+            return [];
+        case "fadeIn":
+            properties.fadeInDuration = data;
+            properties.enableFadeIn = properties.fadeInDuration > 0;
+            return [];
+        case "fadeOut":
+            properties.fadeOutDuration = data;
+            properties.enableFadeOut = properties.fadeOutDuration > 0;
+            return [];
+        case "toggleGain":
+            properties.enableGain =
+                data ?? !properties.enableGain;
+            return [];
+        case "togglePan":
+            properties.enablePan =
+                data ?? !properties.enablePan;
+            return [];
+        case "toggleLowpass":
+            properties.enableLowpass =
+                data ?? !properties.enableLowpass;
+            return [];
+        case "toggleHighpass":
+            properties.enableHighpass =
+                data ?? !properties.enableHighpass;
+            return [];
+        case "toggleDetune":
+            properties.enableDetune =
+                data ?? !properties.enableDetune;
+            return [];
+        case "togglePlaybackRate":
+            properties.enablePlaybackRate =
+                data ?? !properties.enablePlaybackRate;
+            return [];
+        case "toggleFadeIn":
+            properties.enableFadeIn =
+                data ?? !properties.enableFadeIn;
+            return [];
+        case "toggleFadeOut":
+            properties.enableFadeOut =
+                data ?? !properties.enableFadeOut;
+            return [];
+        case "toggleLoopStart":
+            properties.enableLoopStart =
+                data ?? !properties.enableLoopStart;
+            return [];
+        case "toggleLoopEnd":
+            properties.enableLoopEnd =
+                data ?? !properties.enableLoopEnd;
+            return [];
+        case "toggleLoopCrossfade":
+            properties.enableLoopCrossfade =
+                data ?? !properties.enableLoopCrossfade;
+            return [];
+        case "logState":
+            return [];
+    }
+    return [];
+}
+export function processBlock(props, outputs, parameters, ctx, filterState) {
+    const messages = [];
+    let state = props.state;
+    if (state === State.Disposed)
+        return { keepAlive: false, messages };
+    applyPendingBufferWrites(props);
+    if (state === State.Initial)
+        return { keepAlive: true, messages };
+    if (state === State.Ended) {
+        fillWithSilence(outputs[0]);
+        return { keepAlive: true, messages };
+    }
+    if (state === State.Scheduled) {
+        if (ctx.currentTime >= props.startWhen) {
+            state = props.state = State.Started;
+            messages.push({ type: "started" });
+        }
+        else {
+            fillWithSilence(outputs[0]);
+            return { keepAlive: true, messages };
+        }
+    }
+    else if (state === State.Paused) {
+        if (ctx.currentTime > props.pauseWhen) {
+            fillWithSilence(outputs[0]);
+            return { keepAlive: true, messages };
+        }
+    }
+    if (ctx.currentTime > props.stopWhen) {
+        fillWithSilence(outputs[0]);
+        props.state = State.Ended;
+        messages.push({ type: "ended" });
+        props.playedSamples = 0;
+        return { keepAlive: true, messages };
+    }
+    const output0 = outputs[0];
+    const sourceLength = getLogicalBufferLength(props);
+    if (sourceLength === 0) {
+        fillWithSilence(output0);
+        return { keepAlive: true, messages };
+    }
+    const { playbackRate: playbackRates, detune: detunes, lowpass, highpass, gain: gains, pan: pans, } = parameters;
+    const { buffer, loopStart, loopEnd, loopCrossfade, stopWhen, playedSamples, enableLowpass, enableHighpass, enableGain, enablePan, enableDetune, enableFadeOut, enableFadeIn, enableLoopStart, enableLoopEnd, enableLoopCrossfade, playhead, fadeInDuration, fadeOutDuration, } = props;
+    const hasIncompleteStream = props.streamBuffer.streaming &&
+        props.streamBuffer.committedLength < sourceLength;
+    const loop = props.loop;
+    // When looping during an incomplete stream, clamp effective length to committed data
+    // to avoid reading silence/unwritten regions.
+    const effectiveSourceLength = hasIncompleteStream && loop
+        ? Math.max(props.streamBuffer.committedLength, 0)
+        : sourceLength;
+    // Guard against degenerate tiny loops that would produce audible artifacts
+    const MIN_LOOP_SAMPLES = SAMPLE_BLOCK_SIZE * 2;
+    if (hasIncompleteStream && loop && effectiveSourceLength < MIN_LOOP_SAMPLES) {
+        fillWithSilence(output0);
+        for (let i = 1; i < outputs.length; i++) {
+            copy(output0, outputs[i]);
+        }
+        return { keepAlive: true, messages };
+    }
+    const nc = Math.min(buffer.length, output0.length);
+    const durationSamples = props.duration * ctx.sampleRate;
+    const loopCrossfadeSamples = Math.floor(ctx.sampleRate * loopCrossfade);
+    const maxLoopStartSample = Math.max(effectiveSourceLength - SAMPLE_BLOCK_SIZE, 0);
+    const loopStartSamples = enableLoopStart
+        ? Math.min(Math.floor(loopStart * ctx.sampleRate), maxLoopStartSample)
+        : 0;
+    const loopEndSamples = enableLoopEnd
+        ? Math.min(Math.floor(loopEnd * ctx.sampleRate), effectiveSourceLength)
+        : effectiveSourceLength;
+    const loopLengthSamples = loopEndSamples - loopStartSamples;
+    // Apply detune to playback rates: effectiveRate = rate * 2^(detune/1200)
+    const needsDetune = enableDetune && detunes.length > 0 && detunes[0] !== 0;
+    let effectiveRates = playbackRates;
+    if (needsDetune) {
+        const len = Math.max(playbackRates.length, detunes.length, SAMPLE_BLOCK_SIZE);
+        effectiveRates = new Float32Array(len);
+        for (let i = 0; i < len; i++) {
+            const rate = playbackRates[i] ?? playbackRates[playbackRates.length - 1];
+            const cents = detunes[i] ?? detunes[detunes.length - 1];
+            effectiveRates[i] = rate * 2 ** (cents / 1200);
+        }
+    }
+    const useRateIndexing = props.enablePlaybackRate || needsDetune;
+    const isZeroRateBlock = useRateIndexing &&
+        effectiveRates.length > 0 &&
+        effectiveRates.every((rate) => rate === 0);
+    if (props.streamBuffer.streaming &&
+        !props.streamBuffer.streamEnded &&
+        !props.streamBuffer.lowWaterNotified &&
+        props.streamBuffer.committedLength - Math.floor(playhead) <
+            props.streamBuffer.lowWaterThreshold) {
+        messages.push({
+            type: "bufferLowWater",
+            data: {
+                playhead: Math.floor(playhead),
+                committedLength: props.streamBuffer.committedLength,
+            },
+        });
+        props.streamBuffer.lowWaterNotified = true;
+    }
+    if (isZeroRateBlock) {
+        fillWithSilence(output0);
+        for (let i = 1; i < outputs.length; i++) {
+            copy(output0, outputs[i]);
+        }
+        return { keepAlive: true, messages };
+    }
+    const blockParams = {
+        bufferLength: effectiveSourceLength,
+        loop,
+        playhead: props.playhead,
+        loopStartSamples,
+        loopEndSamples,
+        durationSamples,
+        playbackRates: effectiveRates,
+    };
+    const { indexes, ended, looped, playhead: updatedPlayhead, } = useRateIndexing
+        ? findIndexesWithPlaybackRates(blockParams)
+        : findIndexesNormal(blockParams);
+    const underrunSample = indexes.find((index) => index >= props.streamBuffer.committedLength && index < sourceLength);
+    if (underrunSample !== undefined &&
+        !props.streamBuffer.streamEnded &&
+        props.streamBuffer.lastUnderrunSample !== underrunSample) {
+        messages.push({
+            type: "bufferUnderrun",
+            data: {
+                playhead: Math.floor(playhead),
+                committedLength: props.streamBuffer.committedLength,
+                requestedSample: underrunSample,
+            },
+        });
+        props.streamBuffer.lastUnderrunSample = underrunSample;
+    }
+    else if (underrunSample === undefined) {
+        props.streamBuffer.lastUnderrunSample = null;
+    }
+    fill(output0, buffer, indexes);
+    // --- Loop crossfade ---
+    const xfadeNumSamples = Math.min(Math.floor(loopCrossfade * ctx.sampleRate), loopLengthSamples);
+    const isWithinLoopRange = loop && playhead > loopStartSamples && playhead < loopEndSamples;
+    const needsCrossfade = enableLoopCrossfade &&
+        loopCrossfadeSamples > 0 &&
+        effectiveSourceLength > SAMPLE_BLOCK_SIZE;
+    if (isWithinLoopRange && needsCrossfade) {
+        // Crossfade out at loop start: fade out tail of previous loop iteration.
+        // Source: reads from END of loop (loopEnd - xfade to loopEnd).
+        {
+            const endIndex = loopStartSamples + xfadeNumSamples;
+            if (xfadeNumSamples > 0 &&
+                playhead > loopStartSamples &&
+                playhead < endIndex) {
+                const elapsed = playhead - loopStartSamples;
+                const n = Math.min(Math.floor(endIndex - playhead), SAMPLE_BLOCK_SIZE);
+                for (let i = 0; i < n; i++) {
+                    const position = (elapsed + i) / xfadeNumSamples;
+                    const g = Math.cos((Math.PI * position) / 2);
+                    const srcIdx = Math.floor(loopEndSamples - xfadeNumSamples + elapsed + i);
+                    if (srcIdx >= 0 && srcIdx < effectiveSourceLength) {
+                        for (let ch = 0; ch < nc; ch++) {
+                            output0[ch][i] += buffer[ch][srcIdx] * g;
+                        }
+                    }
+                }
+            }
+        }
+        // Crossfade in approaching loop end: fade in head of next loop iteration.
+        // Source: reads from START of loop (loopStart to loopStart + xfade).
+        {
+            const startIndex = loopEndSamples - xfadeNumSamples;
+            if (xfadeNumSamples > 0 &&
+                playhead > startIndex &&
+                playhead < loopEndSamples) {
+                const elapsed = playhead - startIndex;
+                const n = Math.min(Math.floor(loopEndSamples - playhead), SAMPLE_BLOCK_SIZE);
+                for (let i = 0; i < n; i++) {
+                    const position = (elapsed + i) / xfadeNumSamples;
+                    const g = Math.sin((Math.PI * position) / 2);
+                    const srcIdx = Math.floor(loopStartSamples + elapsed + i);
+                    if (srcIdx >= 0 && srcIdx < effectiveSourceLength) {
+                        for (let ch = 0; ch < nc; ch++) {
+                            output0[ch][i] += buffer[ch][srcIdx] * g;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // --- Fade in ---
+    if (enableFadeIn && fadeInDuration > 0) {
+        const fadeInSamples = Math.floor(fadeInDuration * ctx.sampleRate);
+        const remaining = fadeInSamples - playedSamples;
+        if (remaining > 0) {
+            const n = Math.min(remaining, SAMPLE_BLOCK_SIZE);
+            for (let i = 0; i < n; i++) {
+                const t = (playedSamples + i) / fadeInSamples;
+                const g = t * t * t; // cubic: slow start, fast finish
+                for (let ch = 0; ch < nc; ch++) {
+                    output0[ch][i] *= g;
+                }
+            }
+        }
+    }
+    // --- Fade out ---
+    if (enableFadeOut && fadeOutDuration > 0) {
+        const fadeOutSamples = Math.floor(fadeOutDuration * ctx.sampleRate);
+        const remainingSamples = Math.floor(ctx.sampleRate * (stopWhen - ctx.currentTime));
+        if (remainingSamples < fadeOutSamples + SAMPLE_BLOCK_SIZE) {
+            for (let i = 0; i < SAMPLE_BLOCK_SIZE; i++) {
+                const sampleRemaining = remainingSamples - i;
+                if (sampleRemaining >= fadeOutSamples)
+                    continue; // not yet in fade zone
+                const t = sampleRemaining <= 0 ? 0 : sampleRemaining / fadeOutSamples;
+                const g = t * t * t; // cubic fade-out: fast drop, slow tail
+                for (let ch = 0; ch < nc; ch++) {
+                    output0[ch][i] *= g;
+                }
+            }
+        }
+    }
+    // --- Filters ---
+    if (enableLowpass)
+        lowpassFilter(output0, lowpass, ctx.sampleRate, filterState.lowpass);
+    if (enableHighpass)
+        highpassFilter(output0, highpass, ctx.sampleRate, filterState.highpass);
+    if (enableGain)
+        gainFilter(output0, gains);
+    if (nc === 1)
+        monoToStereo(output0);
+    if (enablePan)
+        panFilter(output0, pans);
+    if (looped) {
+        props.timesLooped++;
+        messages.push({ type: "looped", data: props.timesLooped });
+    }
+    if (ended) {
+        props.state = State.Ended;
+        messages.push({ type: "ended" });
+    }
+    props.playedSamples += indexes.length;
+    props.playhead = updatedPlayhead;
+    const numNans = checkNans(output0);
+    if (numNans > 0) {
+        console.log({
+            numNans,
+            indexes,
+            playhead: updatedPlayhead,
+            ended,
+            looped,
+            sourceLength,
+        });
+        return { keepAlive: true, messages };
+    }
+    for (let i = 1; i < outputs.length; i++) {
+        copy(output0, outputs[i]);
+    }
+    return { keepAlive: true, messages };
+}