@jadujoel/web-audio-clip-node 0.1.2 → 0.1.3

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

@@ -1,861 +0,0 @@
-// processor-kernel.ts — Pure DSP logic, state machine, all filters
-// NO AudioWorklet or platform dependencies. Fully testable.
-import { State, } from "./types";
-// ---------------------------------------------------------------------------
-// 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) {
-    for (let i = 0; i < indexes.length; i++) {
-        for (let ch = 0; ch < target.length; ch++) {
-            target[ch][i] = source[ch][indexes[i]];
-        }
-    }
-    for (let i = indexes.length; i < target[0].length; i++) {
-        for (let ch = 0; ch < target.length; 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) {
-    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;
-            return [];
-        case "playhead":
-            properties.playhead = Math.floor(data);
-            return [];
-        case "fadeIn":
-            properties.fadeInDuration = data;
-            return [];
-        case "fadeOut":
-            properties.fadeOutDuration = data;
-            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 && !hasIncompleteStream;
-    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(sourceLength - 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), sourceLength)
-        : sourceLength;
-    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: sourceLength,
-        loop,
-        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 &&
-        sourceLength > 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 < sourceLength) {
-                        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 < sourceLength) {
-                        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 };
-}