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

package/examples/react/node_modules/@jadujoel/web-audio-clip-node/dist/workers/framed-raw-opus.d.ts

@@ -0,0 +1,13 @@
+import { type OpusHead } from "./opus-worker-common";
+export declare const FRAMED_RAW_OPUS_MAGIC = "FROPUS01";
+export interface FramedRawOpusStreamState {
+    headerParsed: boolean;
+    head: OpusHead | null;
+}
+export interface FramedRawOpusParseResult {
+    packets: Uint8Array<ArrayBufferLike>[];
+    leftover: Uint8Array<ArrayBufferLike>;
+    head: OpusHead | null;
+}
+export declare function createFramedRawOpusStreamState(): FramedRawOpusStreamState;
+export declare function parseFramedRawOpusStream(buf: Uint8Array<ArrayBufferLike>, state: FramedRawOpusStreamState): FramedRawOpusParseResult;

package/examples/react/node_modules/@jadujoel/web-audio-clip-node/dist/workers/framed-raw-opus.js

@@ -0,0 +1,68 @@
+import { parseOpusHead } from "./opus-worker-common.js";
+export const FRAMED_RAW_OPUS_MAGIC = "FROPUS01";
+const magicBytes = new TextEncoder().encode(FRAMED_RAW_OPUS_MAGIC);
+export function createFramedRawOpusStreamState() {
+    return {
+        headerParsed: false,
+        head: null,
+    };
+}
+function readUint32LE(buf, offset) {
+    return (((buf[offset] ?? 0) |
+        ((buf[offset + 1] ?? 0) << 8) |
+        ((buf[offset + 2] ?? 0) << 16) |
+        ((buf[offset + 3] ?? 0) << 24)) >>>
+        0);
+}
+export function parseFramedRawOpusStream(buf, state) {
+    let cursor = 0;
+    if (!state.headerParsed) {
+        const headerLength = magicBytes.length + 4;
+        if (buf.length < headerLength) {
+            return {
+                packets: [],
+                leftover: buf,
+                head: state.head,
+            };
+        }
+        for (let i = 0; i < magicBytes.length; i++) {
+            if (buf[i] !== magicBytes[i]) {
+                throw new Error(`Expected ${FRAMED_RAW_OPUS_MAGIC} header for framed raw Opus transport`);
+            }
+        }
+        const opusHeadLength = readUint32LE(buf, magicBytes.length);
+        const opusHeadStart = headerLength;
+        const opusHeadEnd = opusHeadStart + opusHeadLength;
+        if (buf.length < opusHeadEnd) {
+            return {
+                packets: [],
+                leftover: buf,
+                head: state.head,
+            };
+        }
+        const headPacket = buf.slice(opusHeadStart, opusHeadEnd);
+        const head = parseOpusHead(headPacket);
+        if (!head) {
+            throw new Error("Framed raw Opus stream is missing a valid OpusHead packet");
+        }
+        state.headerParsed = true;
+        state.head = head;
+        cursor = opusHeadEnd;
+    }
+    const packets = [];
+    while (cursor + 4 <= buf.length) {
+        const packetLength = readUint32LE(buf, cursor);
+        const packetStart = cursor + 4;
+        const packetEnd = packetStart + packetLength;
+        if (buf.length < packetEnd) {
+            break;
+        }
+        packets.push(buf.slice(packetStart, packetEnd));
+        cursor = packetEnd;
+    }
+    return {
+        packets,
+        leftover: buf.slice(cursor),
+        head: state.head,
+    };
+}

package/examples/react/node_modules/@jadujoel/web-audio-clip-node/dist/workers/mp3-decode-worker.d.ts

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

package/examples/react/node_modules/@jadujoel/web-audio-clip-node/dist/workers/mp3-decode-worker.js

@@ -0,0 +1,254 @@
+// MP3 Decode Worker — runs fetch → MP3 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";
+// ── MP3 frame parser ─────────────────────────────────────────────────
+const BITRATES = [
+    0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0,
+];
+const SAMPLE_RATES = [44100, 48000, 32000, 0];
+const SAMPLES_PER_FRAME = 1152; // MPEG1 Layer III
+function parseMp3Frames(buf) {
+    const frames = [];
+    let i = 0;
+    // Skip ID3v2 tag if present
+    if (buf.length >= 10 &&
+        buf[0] === 0x49 &&
+        buf[1] === 0x44 &&
+        buf[2] === 0x33) {
+        const size = ((buf[6] & 0x7f) << 21) |
+            ((buf[7] & 0x7f) << 14) |
+            ((buf[8] & 0x7f) << 7) |
+            (buf[9] & 0x7f);
+        i = 10 + size;
+    }
+    while (i + 4 <= buf.length) {
+        // Sync word: 11 set bits
+        if (buf[i] !== 0xff || (buf[i + 1] & 0xe0) !== 0xe0) {
+            i++;
+            continue;
+        }
+        const header = buf[i + 1];
+        const mpegVersion = (header >> 3) & 0x03;
+        const layer = (header >> 1) & 0x03;
+        // Only MPEG1 Layer III
+        if (mpegVersion !== 3 || layer !== 1) {
+            i++;
+            continue;
+        }
+        const bitrateIndex = (buf[i + 2] >> 4) & 0x0f;
+        const sampleRateIndex = (buf[i + 2] >> 2) & 0x03;
+        const padding = (buf[i + 2] >> 1) & 0x01;
+        const channelMode = (buf[i + 3] >> 6) & 0x03;
+        const bitrate = BITRATES[bitrateIndex] * 1000;
+        const sampleRate = SAMPLE_RATES[sampleRateIndex];
+        if (bitrate === 0 || sampleRate === 0) {
+            i++;
+            continue;
+        }
+        const frameSize = Math.floor((144 * bitrate) / sampleRate) + padding;
+        if (i + frameSize > buf.length) {
+            // Incomplete frame — return as leftover
+            break;
+        }
+        frames.push({
+            offset: i,
+            size: frameSize,
+            bitrate,
+            sampleRate,
+            channels: channelMode === 3 ? 1 : 2,
+        });
+        i += frameSize;
+    }
+    return { frames, leftover: buf.slice(i) };
+}
+// ── Main worker entry ────────────────────────────────────────────────
+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 initialized = false;
+    let didSendMeta = false;
+    const decoder = new AudioDecoder({
+        output(audioData) {
+            const numFrames = audioData.numberOfFrames;
+            const numChannels = audioData.numberOfChannels;
+            const srcRate = audioData.sampleRate;
+            const dstRate = targetSampleRate > 0 ? targetSampleRate : srcRate;
+            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();
+            const resampledFrames = channelData[0].length;
+            if (!didSendMeta) {
+                didSendMeta = true;
+                const estimatedTotalSamples = estimateTotalSamplesFromContentLength({
+                    totalBytes,
+                    bitrate: null,
+                    sourceSampleRate: srcRate,
+                    targetSampleRate: dstRate,
+                });
+                self.postMessage({
+                    type: "streamMeta",
+                    estimatedTotalSamples,
+                    sampleRate: dstRate,
+                    channels: numChannels,
+                    isEstimate: true,
+                });
+            }
+            if (!initialized) {
+                initialized = true;
+                const estimatedTotalSamples = estimateTotalSamplesFromContentLength({
+                    totalBytes,
+                    bitrate: null,
+                    sourceSampleRate: srcRate,
+                    targetSampleRate: dstRate,
+                });
+                processorPort.postMessage({
+                    type: "bufferInit",
+                    data: {
+                        channels: numChannels,
+                        totalLength: estimatedTotalSamples ?? 0,
+                        streaming: true,
+                    },
+                });
+                self.postMessage({
+                    type: "info",
+                    sampleRate: srcRate,
+                    channels: numChannels,
+                });
+            }
+            processorPort.postMessage({
+                type: "bufferRange",
+                data: {
+                    startSample: samplesDecoded,
+                    channelData,
+                },
+            });
+            samplesDecoded += resampledFrames;
+            self.postMessage({ type: "decoded", samplesDecoded });
+        },
+        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 timestampUs = 0;
+        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 { frames, leftover: remainder } = parseMp3Frames(combined);
+            leftover = remainder;
+            for (const frame of frames) {
+                if (didSendMeta && totalBytes !== null) {
+                    const refinedEstimate = estimateTotalSamplesFromContentLength({
+                        totalBytes,
+                        bitrate: frame.bitrate,
+                        sourceSampleRate: frame.sampleRate,
+                        targetSampleRate: targetSampleRate > 0 ? targetSampleRate : frame.sampleRate,
+                    });
+                    if (refinedEstimate != null) {
+                        self.postMessage({
+                            type: "streamMeta",
+                            estimatedTotalSamples: refinedEstimate,
+                            sampleRate: targetSampleRate > 0 ? targetSampleRate : frame.sampleRate,
+                            channels: frame.channels,
+                            isEstimate: true,
+                        });
+                    }
+                }
+                if (!configuredDecoder) {
+                    decoder.configure({
+                        codec: "mp3",
+                        sampleRate: frame.sampleRate,
+                        numberOfChannels: frame.channels,
+                    });
+                    configuredDecoder = true;
+                }
+                const frameData = combined.slice(frame.offset, frame.offset + frame.size);
+                decoder.decode(new EncodedAudioChunk({
+                    type: "key",
+                    timestamp: timestampUs,
+                    data: frameData,
+                }));
+                timestampUs += Math.round((SAMPLES_PER_FRAME / frame.sampleRate) * 1_000_000);
+            }
+        }
+        // Flush remaining decoded data
+        if (configuredDecoder) {
+            await decoder.flush();
+        }
+        else {
+            self.postMessage({
+                type: "error",
+                message: "No MP3 frames found in the stream",
+            });
+            return;
+        }
+        // Signal end of buffer
+        processorPort.postMessage({
+            type: "bufferEnd",
+            data: { totalLength: samplesDecoded },
+        });
+        self.postMessage({ type: "done", samplesDecoded });
+    }
+    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/react/node_modules/@jadujoel/web-audio-clip-node/dist/workers/mp3-decode-worker.min.js

@@ -0,0 +1 @@
+function k(n,x){let A=new Uint8Array(n.length+x.length);return A.set(n),A.set(x,n.length),A}var P=128000;function X({totalBytes:n,bitrate:x,sourceSampleRate:A,targetSampleRate:N}){if(n==null||n<=0)return null;if(A<=0||N<=0)return null;let T=x!=null&&Number.isFinite(x)&&x>0?x:P,U=n*8/T;if(!Number.isFinite(U)||U<=0)return null;let _=Math.ceil(U*N);return Number.isFinite(_)&&_>0?_:null}function L(n,x,A){if(x===A)return n;let N=x/A,T=Math.round(n.length/N),U=new Float32Array(T);for(let _=0;_<T;_++){let F=_*N,q=Math.floor(F),I=F-q,y=n[q]??0,E=n[Math.min(q+1,n.length-1)]??0;U[_]=y+I*(E-y)}return U}function M(n){let x=0,A=performance.now();return new TransformStream({async transform(N,T){x+=N.length;let U=(performance.now()-A)/1000,F=x/n-U;if(F>0)await new Promise((q)=>setTimeout(q,F*1000));T.enqueue(N)}})}var C=[0,32,40,48,56,64,80,96,112,128,160,192,224,256,320,0],h=[44100,48000,32000,0],v=1152;function c(n){let x=[],A=0;if(n.length>=10&&n[0]===73&&n[1]===68&&n[2]===51)A=10+((n[6]&127)<<21|(n[7]&127)<<14|(n[8]&127)<<7|n[9]&127);while(A+4<=n.length){if(n[A]!==255||(n[A+1]&224)!==224){A++;continue}let N=n[A+1],T=N>>3&3,U=N>>1&3;if(T!==3||U!==1){A++;continue}let _=n[A+2]>>4&15,F=n[A+2]>>2&3,q=n[A+2]>>1&1,I=n[A+3]>>6&3,y=C[_]*1000,E=h[F];if(y===0||E===0){A++;continue}let w=Math.floor(144*y/E)+q;if(A+w>n.length)break;x.push({offset:A,size:w,bitrate:y,sampleRate:E,channels:I===3?1:2}),A+=w}return{frames:x,leftover:n.slice(A)}}var Z=null;self.onmessage=(n)=>{let{type:x}=n.data;if(x==="init"){let{port:A,url:N,throttle:T,targetSampleRate:U}=n.data;Z=new AbortController,S(A,N,Z.signal,T??0,U??0)}else if(x==="abort")Z?.abort()};async function S(n,x,A,N,T){let U=null,_=0,F=0,q=new Uint8Array(0),I=!1,y=!1,E=new AudioDecoder({output(w){let{numberOfFrames:W,numberOfChannels:O,sampleRate:H}=w,G=T>0?T:H,J=[];for(let K=0;K<O;K++){let Q=new Float32Array(W);w.copyTo(Q,{planeIndex:K,format:"f32-planar"}),J.push(L(Q,H,G))}w.close();let Y=J[0].length;if(!y){y=!0;let K=X({totalBytes:U,bitrate:null,sourceSampleRate:H,targetSampleRate:G});self.postMessage({type:"streamMeta",estimatedTotalSamples:K,sampleRate:G,channels:O,isEstimate:!0})}if(!I){I=!0;let K=X({totalBytes:U,bitrate:null,sourceSampleRate:H,targetSampleRate:G});n.postMessage({type:"bufferInit",data:{channels:O,totalLength:K??0,streaming:!0}}),self.postMessage({type:"info",sampleRate:H,channels:O})}n.postMessage({type:"bufferRange",data:{startSample:F,channelData:J}}),F+=Y,self.postMessage({type:"decoded",samplesDecoded:F})},error(w){self.postMessage({type:"error",message:w.message})}});try{let w=await fetch(x,{signal:A});if(!w.ok){self.postMessage({type:"error",message:`Fetch failed: ${w.status} ${w.statusText}`});return}if(!w.body){self.postMessage({type:"error",message:"Response has no body"});return}let W=w.headers.get("content-length");U=W?Number.parseInt(W,10):null;let H=(N>0?w.body.pipeThrough(M(N)):w.body).getReader(),G=!1,J=0;while(!0){let{done:Y,value:K}=await H.read();if(Y)break;_+=K.length,self.postMessage({type:"progress",bytesReceived:_,totalBytes:U});let Q=q.length>0?k(q,K):K,{frames:V,leftover:B}=c(Q);q=B;for(let j of V){if(y&&U!==null){let $=X({totalBytes:U,bitrate:j.bitrate,sourceSampleRate:j.sampleRate,targetSampleRate:T>0?T:j.sampleRate});if($!=null)self.postMessage({type:"streamMeta",estimatedTotalSamples:$,sampleRate:T>0?T:j.sampleRate,channels:j.channels,isEstimate:!0})}if(!G)E.configure({codec:"mp3",sampleRate:j.sampleRate,numberOfChannels:j.channels}),G=!0;let z=Q.slice(j.offset,j.offset+j.size);E.decode(new EncodedAudioChunk({type:"key",timestamp:J,data:z})),J+=Math.round(v/j.sampleRate*1e6)}}if(G)await E.flush();else{self.postMessage({type:"error",message:"No MP3 frames found in the stream"});return}n.postMessage({type:"bufferEnd",data:{totalLength:F}}),self.postMessage({type:"done",samplesDecoded:F})}catch(w){if(w instanceof DOMException&&w.name==="AbortError")self.postMessage({type:"aborted"});else self.postMessage({type:"error",message:w instanceof Error?w.message:String(w)})}finally{try{E.close()}catch{}n.close()}}

package/examples/react/node_modules/@jadujoel/web-audio-clip-node/dist/workers/ogg-opus-decode-worker.d.ts

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