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

package/examples/esm-bundler/node_modules/@jadujoel/web-audio-clip-node/dist/workers/ogg-opus-decode-worker.js

@@ -0,0 +1,398 @@
+// Ogg Opus Decode Worker — runs fetch → Ogg/Opus demux → AudioDecoder off the main thread.
+// Sends decoded Float32Array data directly to the ClipProcessor via a
+// transferred MessagePort, bypassing the main thread for audio data.
+import { concat, createThrottleStream, estimateTotalSamplesFromContentLength, resampleChannel, } from "./worker-utils.js";
+const OGG_MAGIC = [0x4f, 0x67, 0x67, 0x53];
+const OPUS_SAMPLE_RATE = 48_000;
+function readUint64LE(buf, offset) {
+    let value = 0n;
+    for (let i = 0; i < 8; i++) {
+        value |= BigInt(buf[offset + i] ?? 0) << BigInt(i * 8);
+    }
+    return value;
+}
+function indexOfOggSync(buf, from) {
+    for (let i = from; i <= buf.length - OGG_MAGIC.length; i++) {
+        if (buf[i] === OGG_MAGIC[0] &&
+            buf[i + 1] === OGG_MAGIC[1] &&
+            buf[i + 2] === OGG_MAGIC[2] &&
+            buf[i + 3] === OGG_MAGIC[3]) {
+            return i;
+        }
+    }
+    return -1;
+}
+function parseOggPages(buf) {
+    const pages = [];
+    let cursor = 0;
+    while (cursor < buf.length) {
+        const sync = indexOfOggSync(buf, cursor);
+        if (sync < 0) {
+            break;
+        }
+        if (sync > cursor) {
+            cursor = sync;
+        }
+        if (cursor + 27 > buf.length) {
+            break;
+        }
+        const version = buf[cursor + 4] ?? 255;
+        if (version !== 0) {
+            cursor += 1;
+            continue;
+        }
+        const headerType = buf[cursor + 5] ?? 0;
+        const granulePosition = readUint64LE(buf, cursor + 6);
+        const serialNumber = (buf[cursor + 14] ?? 0) |
+            ((buf[cursor + 15] ?? 0) << 8) |
+            ((buf[cursor + 16] ?? 0) << 16) |
+            ((buf[cursor + 17] ?? 0) << 24);
+        const pageSequence = (buf[cursor + 18] ?? 0) |
+            ((buf[cursor + 19] ?? 0) << 8) |
+            ((buf[cursor + 20] ?? 0) << 16) |
+            ((buf[cursor + 21] ?? 0) << 24);
+        const segmentCount = buf[cursor + 26] ?? 0;
+        const segmentTableStart = cursor + 27;
+        const segmentTableEnd = segmentTableStart + segmentCount;
+        if (segmentTableEnd > buf.length) {
+            break;
+        }
+        let segmentBytes = 0;
+        for (let i = 0; i < segmentCount; i++) {
+            segmentBytes += buf[segmentTableStart + i] ?? 0;
+        }
+        const segmentDataStart = segmentTableEnd;
+        const segmentDataEnd = segmentDataStart + segmentBytes;
+        if (segmentDataEnd > buf.length) {
+            break;
+        }
+        const packets = [];
+        let packetStart = segmentDataStart;
+        let packetSize = 0;
+        for (let i = 0; i < segmentCount; i++) {
+            const lace = buf[segmentTableStart + i] ?? 0;
+            packetSize += lace;
+            if (lace < 255) {
+                packets.push(buf.slice(packetStart, packetStart + packetSize));
+                packetStart += packetSize;
+                packetSize = 0;
+            }
+        }
+        const lastPacketComplete = packetSize === 0;
+        if (!lastPacketComplete) {
+            packets.push(buf.slice(packetStart, packetStart + packetSize));
+        }
+        pages.push({
+            headerType,
+            granulePosition,
+            serialNumber,
+            pageSequence,
+            packets,
+            continued: (headerType & 0x01) !== 0,
+            lastPacketComplete,
+        });
+        cursor = segmentDataEnd;
+    }
+    return {
+        pages,
+        leftover: buf.slice(cursor),
+    };
+}
+function parseOpusHead(packet) {
+    if (packet.length < 19)
+        return null;
+    const magic = new TextDecoder().decode(packet.slice(0, 8));
+    if (magic !== "OpusHead")
+        return null;
+    const channels = packet[9] ?? 0;
+    const preSkip = (packet[10] ?? 0) | ((packet[11] ?? 0) << 8);
+    return {
+        channels,
+        preSkip,
+        description: packet,
+    };
+}
+let abortController = null;
+self.onmessage = (ev) => {
+    const { type } = ev.data;
+    if (type === "init") {
+        const { port, url, throttle, targetSampleRate } = ev.data;
+        abortController = new AbortController();
+        startStreaming(port, url, abortController.signal, throttle ?? 0, targetSampleRate ?? 0);
+    }
+    else if (type === "abort") {
+        abortController?.abort();
+    }
+};
+async function startStreaming(processorPort, url, signal, throttle, targetSampleRate) {
+    let totalBytes = null;
+    let bytesReceived = 0;
+    let samplesDecoded = 0;
+    let leftover = new Uint8Array(0);
+    let pendingPacket = new Uint8Array(0);
+    let initialized = false;
+    let didSendMeta = false;
+    let packetIndex = 0;
+    let activeSerial = null;
+    let streamChannels = 2;
+    let preSkipSourceSamples = 0;
+    let preSkipTargetSamples = 0;
+    let samplesSkipped = 0;
+    let shouldApplyPreSkip = true;
+    let preSkipProbeDone = false;
+    let timestampUs = 0;
+    const decoder = new AudioDecoder({
+        output(audioData) {
+            const numFrames = audioData.numberOfFrames;
+            const numChannels = audioData.numberOfChannels;
+            const srcRate = audioData.sampleRate;
+            const dstRate = targetSampleRate > 0 ? targetSampleRate : srcRate;
+            if (!preSkipProbeDone) {
+                const preSkipUs = Math.round((preSkipSourceSamples / OPUS_SAMPLE_RATE) * 1_000_000);
+                if (audioData.timestamp >= preSkipUs && preSkipUs > 0) {
+                    shouldApplyPreSkip = false;
+                }
+                preSkipProbeDone = true;
+            }
+            const channelData = [];
+            for (let ch = 0; ch < numChannels; ch++) {
+                const raw = new Float32Array(numFrames);
+                audioData.copyTo(raw, { planeIndex: ch, format: "f32-planar" });
+                channelData.push(resampleChannel(raw, srcRate, dstRate));
+            }
+            audioData.close();
+            let resampledFrames = channelData[0]?.length ?? 0;
+            if (shouldApplyPreSkip &&
+                samplesSkipped < preSkipTargetSamples &&
+                resampledFrames > 0) {
+                const toSkip = Math.min(preSkipTargetSamples - samplesSkipped, resampledFrames);
+                samplesSkipped += toSkip;
+                if (toSkip === resampledFrames) {
+                    timestampUs += Math.round((numFrames / OPUS_SAMPLE_RATE) * 1_000_000);
+                    return;
+                }
+                for (let ch = 0; ch < channelData.length; ch++) {
+                    channelData[ch] = channelData[ch].subarray(toSkip);
+                }
+                resampledFrames = channelData[0]?.length ?? 0;
+            }
+            if (!didSendMeta) {
+                didSendMeta = true;
+                const estimatedTotalSamples = estimateTotalSamplesFromContentLength({
+                    totalBytes,
+                    bitrate: null,
+                    sourceSampleRate: OPUS_SAMPLE_RATE,
+                    targetSampleRate: dstRate,
+                });
+                self.postMessage({
+                    type: "streamMeta",
+                    estimatedTotalSamples,
+                    sampleRate: dstRate,
+                    channels: numChannels,
+                    isEstimate: true,
+                });
+            }
+            if (!initialized) {
+                initialized = true;
+                const estimatedTotalSamples = estimateTotalSamplesFromContentLength({
+                    totalBytes,
+                    bitrate: null,
+                    sourceSampleRate: OPUS_SAMPLE_RATE,
+                    targetSampleRate: dstRate,
+                });
+                processorPort.postMessage({
+                    type: "bufferInit",
+                    data: {
+                        channels: numChannels,
+                        totalLength: estimatedTotalSamples ?? 0,
+                        streaming: true,
+                    },
+                });
+                self.postMessage({
+                    type: "info",
+                    sampleRate: srcRate,
+                    channels: numChannels,
+                });
+            }
+            if (resampledFrames > 0) {
+                processorPort.postMessage({
+                    type: "bufferRange",
+                    data: {
+                        startSample: samplesDecoded,
+                        channelData,
+                    },
+                });
+                samplesDecoded += resampledFrames;
+                self.postMessage({ type: "decoded", samplesDecoded });
+            }
+            timestampUs += Math.round((numFrames / OPUS_SAMPLE_RATE) * 1_000_000);
+        },
+        error(e) {
+            self.postMessage({ type: "error", message: e.message });
+        },
+    });
+    try {
+        const response = await fetch(url, { signal });
+        if (!response.ok) {
+            self.postMessage({
+                type: "error",
+                message: `Fetch failed: ${response.status} ${response.statusText}`,
+            });
+            return;
+        }
+        if (!response.body) {
+            self.postMessage({ type: "error", message: "Response has no body" });
+            return;
+        }
+        const contentLength = response.headers.get("content-length");
+        totalBytes = contentLength ? Number.parseInt(contentLength, 10) : null;
+        const body = throttle > 0
+            ? response.body.pipeThrough(createThrottleStream(throttle))
+            : response.body;
+        const reader = body.getReader();
+        let configuredDecoder = false;
+        let decodedAnyPacket = false;
+        const handlePacket = (packet) => {
+            if (packet.length === 0)
+                return;
+            if (packetIndex === 0) {
+                const head = parseOpusHead(packet);
+                if (!head) {
+                    throw new Error("Missing or invalid OpusHead packet");
+                }
+                if (head.channels <= 0) {
+                    throw new Error("OpusHead contains invalid channel count");
+                }
+                streamChannels = head.channels;
+                preSkipSourceSamples = head.preSkip;
+                const dstRate = targetSampleRate > 0 ? targetSampleRate : OPUS_SAMPLE_RATE;
+                preSkipTargetSamples = Math.round((preSkipSourceSamples / OPUS_SAMPLE_RATE) * dstRate);
+                decoder.configure({
+                    codec: "opus",
+                    sampleRate: OPUS_SAMPLE_RATE,
+                    numberOfChannels: head.channels,
+                    description: head.description,
+                });
+                configuredDecoder = true;
+                packetIndex += 1;
+                return;
+            }
+            if (packetIndex === 1) {
+                packetIndex += 1;
+                return;
+            }
+            if (!configuredDecoder) {
+                throw new Error("Decoder is not configured for Opus stream");
+            }
+            decoder.decode(new EncodedAudioChunk({
+                type: "key",
+                timestamp: timestampUs,
+                data: packet,
+            }));
+            decodedAnyPacket = true;
+            packetIndex += 1;
+        };
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            bytesReceived += value.length;
+            self.postMessage({ type: "progress", bytesReceived, totalBytes });
+            const combined = leftover.length > 0 ? concat(leftover, value) : value;
+            const parsed = parseOggPages(combined);
+            leftover = parsed.leftover;
+            for (const page of parsed.pages) {
+                if (activeSerial == null) {
+                    activeSerial = page.serialNumber;
+                }
+                if (page.serialNumber !== activeSerial) {
+                    continue;
+                }
+                if (page.continued) {
+                    if (page.packets.length === 0) {
+                        continue;
+                    }
+                    pendingPacket = concat(pendingPacket, page.packets[0]);
+                    const firstComplete = page.packets.length > 1 || page.lastPacketComplete;
+                    if (firstComplete) {
+                        handlePacket(pendingPacket);
+                        pendingPacket = new Uint8Array(0);
+                    }
+                    for (let i = 1; i < page.packets.length; i++) {
+                        const isTrailingPartial = i === page.packets.length - 1 && !page.lastPacketComplete;
+                        if (isTrailingPartial) {
+                            pendingPacket = concat(pendingPacket, page.packets[i]);
+                            continue;
+                        }
+                        if (pendingPacket.length > 0) {
+                            handlePacket(concat(pendingPacket, page.packets[i]));
+                            pendingPacket = new Uint8Array(0);
+                        }
+                        else {
+                            handlePacket(page.packets[i]);
+                        }
+                    }
+                    continue;
+                }
+                for (let i = 0; i < page.packets.length; i++) {
+                    const isTrailingPartial = i === page.packets.length - 1 && !page.lastPacketComplete;
+                    if (isTrailingPartial) {
+                        pendingPacket = concat(pendingPacket, page.packets[i]);
+                        continue;
+                    }
+                    if (pendingPacket.length > 0) {
+                        handlePacket(concat(pendingPacket, page.packets[i]));
+                        pendingPacket = new Uint8Array(0);
+                    }
+                    else {
+                        handlePacket(page.packets[i]);
+                    }
+                }
+            }
+        }
+        if (pendingPacket.length > 0) {
+            handlePacket(pendingPacket);
+            pendingPacket = new Uint8Array(0);
+        }
+        if (configuredDecoder && decodedAnyPacket) {
+            await decoder.flush();
+        }
+        else {
+            self.postMessage({
+                type: "error",
+                message: "No Opus packets found in the stream",
+            });
+            return;
+        }
+        processorPort.postMessage({
+            type: "bufferEnd",
+            data: { totalLength: samplesDecoded },
+        });
+        self.postMessage({
+            type: "done",
+            samplesDecoded,
+            sampleRate: OPUS_SAMPLE_RATE,
+            channels: streamChannels,
+        });
+    }
+    catch (e) {
+        if (e instanceof DOMException && e.name === "AbortError") {
+            self.postMessage({ type: "aborted" });
+        }
+        else {
+            self.postMessage({
+                type: "error",
+                message: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+    finally {
+        try {
+            decoder.close();
+        }
+        catch {
+            // already closed
+        }
+        processorPort.close();
+    }
+}

package/examples/esm-bundler/node_modules/@jadujoel/web-audio-clip-node/dist/workers/ogg-opus-decode-worker.min.js

@@ -0,0 +1 @@
+function z(A,_){let w=new Uint8Array(A.length+_.length);return w.set(A),w.set(_,A.length),w}var i=128000;function b({totalBytes:A,bitrate:_,sourceSampleRate:w,targetSampleRate:M}){if(A==null||A<=0)return null;if(w<=0||M<=0)return null;let G=_!=null&&Number.isFinite(_)&&_>0?_:i,j=A*8/G;if(!Number.isFinite(j)||j<=0)return null;let H=Math.ceil(j*M);return Number.isFinite(H)&&H>0?H:null}function g(A,_,w){if(_===w)return A;let M=_/w,G=Math.round(A.length/M),j=new Float32Array(G);for(let H=0;H<G;H++){let J=H*M,Q=Math.floor(J),N=J-Q,Y=A[Q]??0,I=A[Math.min(Q+1,A.length-1)]??0;j[H]=Y+N*(I-Y)}return j}function u(A){let _=0,w=performance.now();return new TransformStream({async transform(M,G){_+=M.length;let j=(performance.now()-w)/1000,J=_/A-j;if(J>0)await new Promise((Q)=>setTimeout(Q,J*1000));G.enqueue(M)}})}var f=[79,103,103,83],$=48000;function k(A,_){let w=0n;for(let M=0;M<8;M++)w|=BigInt(A[_+M]??0)<<BigInt(M*8);return w}function o(A,_){for(let w=_;w<=A.length-f.length;w++)if(A[w]===f[0]&&A[w+1]===f[1]&&A[w+2]===f[2]&&A[w+3]===f[3])return w;return-1}function d(A){let _=[],w=0;while(w<A.length){let M=o(A,w);if(M<0)break;if(M>w)w=M;if(w+27>A.length)break;if((A[w+4]??255)!==0){w+=1;continue}let j=A[w+5]??0,H=k(A,w+6),J=(A[w+14]??0)|(A[w+15]??0)<<8|(A[w+16]??0)<<16|(A[w+17]??0)<<24,Q=(A[w+18]??0)|(A[w+19]??0)<<8|(A[w+20]??0)<<16|(A[w+21]??0)<<24,N=A[w+26]??0,Y=w+27,I=Y+N;if(I>A.length)break;let E=0;for(let W=0;W<N;W++)E+=A[Y+W]??0;let y=I,R=y+E;if(R>A.length)break;let O=[],Z=y,V=0;for(let W=0;W<N;W++){let C=A[Y+W]??0;if(V+=C,C<255)O.push(A.slice(Z,Z+V)),Z+=V,V=0}let D=V===0;if(!D)O.push(A.slice(Z,Z+V));_.push({headerType:j,granulePosition:H,serialNumber:J,pageSequence:Q,packets:O,continued:(j&1)!==0,lastPacketComplete:D}),w=R}return{pages:_,leftover:A.slice(w)}}function r(A){if(A.length<19)return null;if(new TextDecoder().decode(A.slice(0,8))!=="OpusHead")return null;let w=A[9]??0,M=(A[10]??0)|(A[11]??0)<<8;return{channels:w,preSkip:M,description:A}}var l=null;self.onmessage=(A)=>{let{type:_}=A.data;if(_==="init"){let{port:w,url:M,throttle:G,targetSampleRate:j}=A.data;l=new AbortController,s(w,M,l.signal,G??0,j??0)}else if(_==="abort")l?.abort()};async function s(A,_,w,M,G){let j=null,H=0,J=0,Q=new Uint8Array(0),N=new Uint8Array(0),Y=!1,I=!1,E=0,y=null,R=2,O=0,Z=0,V=0,D=!0,W=!1,C=0,m=new AudioDecoder({output(x){let{numberOfFrames:v,numberOfChannels:h,sampleRate:P}=x,B=G>0?G:P;if(!W){let K=Math.round(O/$*1e6);if(x.timestamp>=K&&K>0)D=!1;W=!0}let X=[];for(let K=0;K<h;K++){let q=new Float32Array(v);x.copyTo(q,{planeIndex:K,format:"f32-planar"}),X.push(g(q,P,B))}x.close();let L=X[0]?.length??0;if(D&&V<Z&&L>0){let K=Math.min(Z-V,L);if(V+=K,K===L){C+=Math.round(v/$*1e6);return}for(let q=0;q<X.length;q++)X[q]=X[q].subarray(K);L=X[0]?.length??0}if(!I){I=!0;let K=b({totalBytes:j,bitrate:null,sourceSampleRate:$,targetSampleRate:B});self.postMessage({type:"streamMeta",estimatedTotalSamples:K,sampleRate:B,channels:h,isEstimate:!0})}if(!Y){Y=!0;let K=b({totalBytes:j,bitrate:null,sourceSampleRate:$,targetSampleRate:B});A.postMessage({type:"bufferInit",data:{channels:h,totalLength:K??0,streaming:!0}}),self.postMessage({type:"info",sampleRate:P,channels:h})}if(L>0)A.postMessage({type:"bufferRange",data:{startSample:J,channelData:X}}),J+=L,self.postMessage({type:"decoded",samplesDecoded:J});C+=Math.round(v/$*1e6)},error(x){self.postMessage({type:"error",message:x.message})}});try{let x=await fetch(_,{signal:w});if(!x.ok){self.postMessage({type:"error",message:`Fetch failed: ${x.status} ${x.statusText}`});return}if(!x.body){self.postMessage({type:"error",message:"Response has no body"});return}let v=x.headers.get("content-length");j=v?Number.parseInt(v,10):null;let P=(M>0?x.body.pipeThrough(u(M)):x.body).getReader(),B=!1,X=!1,L=(K)=>{if(K.length===0)return;if(E===0){let q=r(K);if(!q)throw Error("Missing or invalid OpusHead packet");if(q.channels<=0)throw Error("OpusHead contains invalid channel count");R=q.channels,O=q.preSkip;let S=G>0?G:$;Z=Math.round(O/$*S),m.configure({codec:"opus",sampleRate:$,numberOfChannels:q.channels,description:q.description}),B=!0,E+=1;return}if(E===1){E+=1;return}if(!B)throw Error("Decoder is not configured for Opus stream");m.decode(new EncodedAudioChunk({type:"key",timestamp:C,data:K})),X=!0,E+=1};while(!0){let{done:K,value:q}=await P.read();if(K)break;H+=q.length,self.postMessage({type:"progress",bytesReceived:H,totalBytes:j});let S=Q.length>0?z(Q,q):q,n=d(S);Q=n.leftover;for(let U of n.pages){if(y==null)y=U.serialNumber;if(U.serialNumber!==y)continue;if(U.continued){if(U.packets.length===0)continue;if(N=z(N,U.packets[0]),U.packets.length>1||U.lastPacketComplete)L(N),N=new Uint8Array(0);for(let T=1;T<U.packets.length;T++){if(T===U.packets.length-1&&!U.lastPacketComplete){N=z(N,U.packets[T]);continue}if(N.length>0)L(z(N,U.packets[T])),N=new Uint8Array(0);else L(U.packets[T])}continue}for(let F=0;F<U.packets.length;F++){if(F===U.packets.length-1&&!U.lastPacketComplete){N=z(N,U.packets[F]);continue}if(N.length>0)L(z(N,U.packets[F])),N=new Uint8Array(0);else L(U.packets[F])}}}if(N.length>0)L(N),N=new Uint8Array(0);if(B&&X)await m.flush();else{self.postMessage({type:"error",message:"No Opus packets found in the stream"});return}A.postMessage({type:"bufferEnd",data:{totalLength:J}}),self.postMessage({type:"done",samplesDecoded:J,sampleRate:$,channels:R})}catch(x){if(x instanceof DOMException&&x.name==="AbortError")self.postMessage({type:"aborted"});else self.postMessage({type:"error",message:x instanceof Error?x.message:String(x)})}finally{try{m.close()}catch{}A.close()}}

package/examples/esm-bundler/node_modules/@jadujoel/web-audio-clip-node/dist/workers/opus-worker-common.d.ts

@@ -0,0 +1,45 @@
+export declare const OPUS_SAMPLE_RATE = 48000;
+export interface OpusHead {
+    channels: number;
+    preSkip: number;
+    description: Uint8Array<ArrayBufferLike>;
+}
+export declare function parseOpusHead(packet: Uint8Array): OpusHead | null;
+export declare function createFallbackOpusHead(channels: number): OpusHead;
+interface StreamingOpusDecoderOptions {
+    processorPort: MessagePort;
+    targetSampleRate: number;
+    postMessage: (message: unknown) => void;
+}
+export declare class StreamingOpusDecoder {
+    private readonly processorPort;
+    private readonly targetSampleRate;
+    private readonly postMessage;
+    private readonly decoder;
+    private totalBytes;
+    private samplesDecodedCount;
+    private didSendMeta;
+    private initialized;
+    private configured;
+    private decodedAnyPacket;
+    private streamChannels;
+    private preSkipSourceSamples;
+    private preSkipTargetSamples;
+    private samplesSkipped;
+    private allowTimestampProbe;
+    private preSkipProbeDone;
+    private shouldApplyPreSkip;
+    private lastConfig;
+    constructor({ processorPort, targetSampleRate, postMessage, }: StreamingOpusDecoderOptions);
+    setTotalBytes(totalBytes: number | null): void;
+    configure(head: OpusHead, bitstreamFormat: "ogg" | "opus"): Promise<void>;
+    decodePacket(packet: Uint8Array, timestampUs: number): void;
+    flush(): Promise<void>;
+    close(): void;
+    get samplesDecoded(): number;
+    get channels(): number;
+    get hasConfiguredDecoder(): boolean;
+    get hasDecodedPackets(): boolean;
+    private readonly handleOutput;
+}
+export {};

package/examples/esm-bundler/node_modules/@jadujoel/web-audio-clip-node/dist/workers/opus-worker-common.js

@@ -0,0 +1,226 @@
+import { estimateTotalSamplesFromContentLength, resampleChannel, } from "./worker-utils.js";
+export const OPUS_SAMPLE_RATE = 48_000;
+const textDecoder = new TextDecoder();
+export function parseOpusHead(packet) {
+    if (packet.length < 19)
+        return null;
+    const magic = textDecoder.decode(packet.slice(0, 8));
+    if (magic !== "OpusHead")
+        return null;
+    const channels = packet[9] ?? 0;
+    const preSkip = (packet[10] ?? 0) | ((packet[11] ?? 0) << 8);
+    return {
+        channels,
+        preSkip,
+        description: packet,
+    };
+}
+export function createFallbackOpusHead(channels) {
+    const description = new Uint8Array(19);
+    description.set(new TextEncoder().encode("OpusHead"), 0);
+    description[8] = 1;
+    description[9] = channels;
+    return {
+        channels,
+        preSkip: 0,
+        description,
+    };
+}
+export class StreamingOpusDecoder {
+    processorPort;
+    targetSampleRate;
+    postMessage;
+    decoder;
+    totalBytes = null;
+    samplesDecodedCount = 0;
+    didSendMeta = false;
+    initialized = false;
+    configured = false;
+    decodedAnyPacket = false;
+    streamChannels = 2;
+    preSkipSourceSamples = 0;
+    preSkipTargetSamples = 0;
+    samplesSkipped = 0;
+    allowTimestampProbe = false;
+    preSkipProbeDone = false;
+    shouldApplyPreSkip = true;
+    lastConfig = null;
+    constructor({ processorPort, targetSampleRate, postMessage, }) {
+        this.processorPort = processorPort;
+        this.targetSampleRate = targetSampleRate;
+        this.postMessage = postMessage;
+        this.decoder = new AudioDecoder({
+            output: this.handleOutput,
+            error: (error) => {
+                this.postMessage({
+                    type: "error",
+                    message: this.lastConfig == null
+                        ? error.message
+                        : `${error.message} (${JSON.stringify({
+                            configured: this.configured,
+                            decodedAnyPacket: this.decodedAnyPacket,
+                            config: this.lastConfig,
+                        })})`,
+                });
+            },
+        });
+    }
+    setTotalBytes(totalBytes) {
+        this.totalBytes = totalBytes;
+    }
+    async configure(head, bitstreamFormat) {
+        if (head.channels <= 0) {
+            throw new Error("Opus stream contains invalid channel count");
+        }
+        this.streamChannels = head.channels;
+        this.preSkipSourceSamples = head.preSkip;
+        const dstRate = this.targetSampleRate > 0 ? this.targetSampleRate : OPUS_SAMPLE_RATE;
+        this.preSkipTargetSamples = Math.round((this.preSkipSourceSamples / OPUS_SAMPLE_RATE) * dstRate);
+        this.allowTimestampProbe = bitstreamFormat === "ogg";
+        this.preSkipProbeDone = false;
+        this.shouldApplyPreSkip = true;
+        const config = {
+            codec: "opus",
+            sampleRate: OPUS_SAMPLE_RATE,
+            numberOfChannels: head.channels,
+            description: head.description,
+        };
+        this.lastConfig = {
+            codec: config.codec,
+            sampleRate: config.sampleRate,
+            numberOfChannels: config.numberOfChannels,
+            descriptionLength: head.description.length,
+        };
+        const support = await AudioDecoder.isConfigSupported(config);
+        if (!support.supported) {
+            throw new Error(`Unsupported Opus decoder config: ${JSON.stringify({
+                codec: config.codec,
+                sampleRate: config.sampleRate,
+                numberOfChannels: config.numberOfChannels,
+                descriptionLength: head.description.length,
+            })}`);
+        }
+        this.decoder.configure(config);
+        this.configured = true;
+    }
+    decodePacket(packet, timestampUs) {
+        if (!this.configured) {
+            throw new Error("Decoder is not configured for Opus stream");
+        }
+        this.decoder.decode(new EncodedAudioChunk({
+            type: "key",
+            timestamp: timestampUs,
+            data: packet,
+        }));
+        this.decodedAnyPacket = true;
+    }
+    async flush() {
+        await this.decoder.flush();
+    }
+    close() {
+        try {
+            this.decoder.close();
+        }
+        catch {
+            // already closed
+        }
+    }
+    get samplesDecoded() {
+        return this.samplesDecodedCount;
+    }
+    get channels() {
+        return this.streamChannels;
+    }
+    get hasConfiguredDecoder() {
+        return this.configured;
+    }
+    get hasDecodedPackets() {
+        return this.decodedAnyPacket;
+    }
+    handleOutput = (audioData) => {
+        const numFrames = audioData.numberOfFrames;
+        const numChannels = audioData.numberOfChannels;
+        const srcRate = audioData.sampleRate;
+        const dstRate = this.targetSampleRate > 0 ? this.targetSampleRate : srcRate;
+        if (this.allowTimestampProbe && !this.preSkipProbeDone) {
+            const preSkipUs = Math.round((this.preSkipSourceSamples / OPUS_SAMPLE_RATE) * 1_000_000);
+            if (audioData.timestamp >= preSkipUs && preSkipUs > 0) {
+                this.shouldApplyPreSkip = false;
+            }
+            this.preSkipProbeDone = true;
+        }
+        const channelData = [];
+        for (let ch = 0; ch < numChannels; ch++) {
+            const raw = new Float32Array(numFrames);
+            audioData.copyTo(raw, { planeIndex: ch, format: "f32-planar" });
+            channelData.push(resampleChannel(raw, srcRate, dstRate));
+        }
+        audioData.close();
+        let resampledFrames = channelData[0]?.length ?? 0;
+        if (this.shouldApplyPreSkip &&
+            this.samplesSkipped < this.preSkipTargetSamples &&
+            resampledFrames > 0) {
+            const toSkip = Math.min(this.preSkipTargetSamples - this.samplesSkipped, resampledFrames);
+            this.samplesSkipped += toSkip;
+            if (toSkip === resampledFrames) {
+                return;
+            }
+            for (let ch = 0; ch < channelData.length; ch++) {
+                channelData[ch] = channelData[ch].subarray(toSkip);
+            }
+            resampledFrames = channelData[0]?.length ?? 0;
+        }
+        if (!this.didSendMeta) {
+            this.didSendMeta = true;
+            const estimatedTotalSamples = estimateTotalSamplesFromContentLength({
+                totalBytes: this.totalBytes,
+                bitrate: null,
+                sourceSampleRate: OPUS_SAMPLE_RATE,
+                targetSampleRate: dstRate,
+            });
+            this.postMessage({
+                type: "streamMeta",
+                estimatedTotalSamples,
+                sampleRate: dstRate,
+                channels: numChannels,
+                isEstimate: true,
+            });
+        }
+        if (!this.initialized) {
+            this.initialized = true;
+            const estimatedTotalSamples = estimateTotalSamplesFromContentLength({
+                totalBytes: this.totalBytes,
+                bitrate: null,
+                sourceSampleRate: OPUS_SAMPLE_RATE,
+                targetSampleRate: dstRate,
+            });
+            this.processorPort.postMessage({
+                type: "bufferInit",
+                data: {
+                    channels: numChannels,
+                    totalLength: estimatedTotalSamples ?? 0,
+                    streaming: true,
+                },
+            });
+            this.postMessage({
+                type: "info",
+                sampleRate: srcRate,
+                channels: numChannels,
+            });
+        }
+        if (resampledFrames > 0) {
+            this.processorPort.postMessage({
+                type: "bufferRange",
+                data: {
+                    startSample: this.samplesDecodedCount,
+                    channelData,
+                },
+            });
+            this.samplesDecodedCount += resampledFrames;
+            this.postMessage({
+                type: "decoded",
+                samplesDecoded: this.samplesDecodedCount,
+            });
+        }
+    };
+}

package/examples/esm-bundler/node_modules/@jadujoel/web-audio-clip-node/dist/workers/raw-opus-framed-decode-worker.d.ts

@@ -0,0 +1 @@
+export {};