import decode, { decoder } from './decode-webm.js' import { execSync } from 'child_process' import { existsSync, readFileSync, mkdirSync } from 'fs' let pass = 0, fail = 0 function ok(cond, msg) { if (cond) { pass++; console.log(' ok', msg) } else { fail++; console.error(' FAIL', msg) } } const dur = r => r.channelData[0].length / r.sampleRate const rms = f32 => { let s = 0; for (let i = 0; i < f32.length; i++) s += f32[i] * f32[i]; return Math.sqrt(s / f32.length) } const near = (a, b, tol = 0.05) => Math.abs(a - b) < tol // Generate test fixture with ffmpeg if available let fixture = new URL('./fixtures/test.webm', import.meta.url) let fixturePath = new URL('./fixtures/', import.meta.url) let hasFixture = false try { mkdirSync(new URL(fixturePath), { recursive: true }) if (!existsSync(fixture)) { execSync(`ffmpeg -f lavfi -i "sine=frequency=440:duration=1" -c:a libopus -b:a 64k "${new URL(fixture).pathname}" -y 2>/dev/null`) } hasFixture = existsSync(fixture) } catch { hasFixture = existsSync(fixture) } // Also generate a stereo fixture let stereoFixture = new URL('./fixtures/stereo.webm', import.meta.url) let hasStereo = false try { if (!existsSync(stereoFixture)) { execSync(`ffmpeg -f lavfi -i "sine=frequency=440:duration=1" -f lavfi -i "sine=frequency=880:duration=1" -filter_complex "[0:a][1:a]amerge=inputs=2" -c:a libopus -b:a 64k "${new URL(stereoFixture).pathname}" -y 2>/dev/null`) } hasStereo = existsSync(stereoFixture) } catch { hasStereo = existsSync(stereoFixture) } // --- EBML parsing unit tests --- console.log('EBML parsing') // Test: valid WebM detection ok(await (async () => { try { await decode(new Uint8Array([0, 0, 0])); return false } catch (e) { return e.message.includes('Not a WebM') } })(), 'rejects too-small buffer') ok(await (async () => { try { await decode(new Uint8Array(100)); return false } catch (e) { return e.message.includes('Not a WebM') } })(), 'rejects non-WebM data') ok(await (async () => { try { await decode(null); return false } catch { return true } })(), 'rejects null') ok(await (async () => { try { await decode(new ArrayBuffer(0)); return false } catch { return true } })(), 'rejects empty ArrayBuffer') ok(await (async () => { let invalid = readFileSync(fixture) let cluster = invalid.indexOf(Buffer.from([0x1f, 0x43, 0xb6, 0x75])) if (cluster < 0) return false invalid = invalid.subarray(0, cluster).slice() let head = invalid.indexOf('OpusHead') if (head < 0) return false invalid[head + 9] = 0 try { await decode(invalid); return false } catch (error) { return invalid.length < 8192 && error.message.includes('Invalid Opus CodecPrivate') } })(), 'rejects a small zero-channel OpusHead') // --- Decoder lifecycle --- console.log('Decoder lifecycle') ok(await (async () => { let dec = await decoder() dec.free() try { dec.decode(new Uint8Array(10)); return false } catch (e) { return e.message.includes('freed') } })(), 'decode after free throws') ok(await (async () => { let dec = await decoder() dec.free() dec.free() return true })(), 'double free is safe') ok(await (async () => { let dec = await decoder() let r = dec.flush() return r.channelData.length === 0 && r.sampleRate === 0 })(), 'flush without data returns empty') ok(await (async () => { let dec = await decoder() let r = dec.decode(null) return r.channelData.length === 0 && r.sampleRate === 0 })(), 'decode null returns empty') ok(await (async () => { let dec = await decoder() let r = dec.decode(new Uint8Array(0)) return r.channelData.length === 0 && r.sampleRate === 0 })(), 'decode empty returns empty') // --- Synchronous decoder methods --- console.log('Synchronous decoder methods') for (let [name, file] of [ ['opus', './fixtures/test.webm'], ['vorbis', './fixtures/vorbis-mono.webm'] ]) { let webm = readFileSync(new URL(file, import.meta.url)) let whole = await decode(webm) let dec = await decoder(), results = [], sync = true for (let offset = 0, size = 1; offset < webm.length; offset += size, size = Math.min(size * 3, 4093)) { let chunk = webm.subarray(offset, offset + size) let result = dec.decode(offset ? chunk : chunk.slice().buffer) sync &&= !(result instanceof Promise) results.push(result) } let tail = dec.flush() sync &&= !(tail instanceof Promise) results.push(tail) let total = results.reduce((samples, result) => samples + (result.channelData[0]?.length || 0), 0) ok(sync, name + ': decode and flush return values') ok(total === whole.channelData[0].length, name + ': chunked length matches whole-file') let threw = false try { dec.decode(webm) } catch { threw = true } ok(threw, name + ': decode after flush throws') } // --- Integration tests (require ffmpeg fixture) --- if (hasFixture) { console.log('WebM+Opus mono decode') let webm = readFileSync(fixture) ok(await (async () => { let r = await decode(webm) return r.channelData.length === 1 && r.sampleRate === 48000 })(), 'mono: 1 channel, 48kHz') ok(await (async () => { let r = await decode(webm) return near(dur(r), 1.0, 0.1) })(), 'mono: ~1s duration') ok(await (async () => { let r = await decode(webm) return rms(r.channelData[0]) > 0.01 })(), 'mono: has audio content') ok(await (async () => { let r = await decode(new Uint8Array(webm)) return r.channelData.length >= 1 })(), 'accepts Uint8Array input') ok(await (async () => { let r = await decode(webm.buffer.slice(webm.byteOffset, webm.byteOffset + webm.byteLength)) return r.channelData.length >= 1 })(), 'accepts ArrayBuffer input') // Streaming decoder test ok(await (async () => { let dec = await decoder() let input = webm.buffer.slice(webm.byteOffset, webm.byteOffset + webm.byteLength) let r = dec.decode(input) let ok1 = !(r instanceof Promise) && r.channelData.length === 1 && r.sampleRate === 48000 let f = dec.flush() return ok1 && !(f instanceof Promise) && f.sampleRate === 0 })(), 'streaming decoder works') } else { console.log('SKIP: WebM+Opus mono decode (no ffmpeg / fixture)') } if (hasStereo) { console.log('WebM+Opus stereo decode') let webm = readFileSync(stereoFixture) ok(await (async () => { let r = await decode(webm) return r.channelData.length === 2 && r.sampleRate === 48000 })(), 'stereo: 2 channels, 48kHz') ok(await (async () => { let r = await decode(webm) return near(dur(r), 1.0, 0.1) })(), 'stereo: ~1s duration') ok(await (async () => { let r = await decode(webm) let l = rms(r.channelData[0]) let rr = rms(r.channelData[1]) return l > 0.01 && rr > 0.01 })(), 'stereo: both channels have content') } else { console.log('SKIP: WebM+Opus stereo decode (no ffmpeg / fixture)') } // --- Video+Audio WebM (should extract audio only) --- let videoAudioFixture = new URL('./fixtures/video-audio.webm', import.meta.url) let hasVideoAudio = false try { if (!existsSync(videoAudioFixture)) { execSync(`ffmpeg -f lavfi -i "sine=frequency=440:duration=1" -f lavfi -i "color=c=black:s=2x2:d=1" -c:a libopus -b:a 64k -c:v libvpx -b:v 100k "${new URL(videoAudioFixture).pathname}" -y 2>/dev/null`) } hasVideoAudio = existsSync(videoAudioFixture) } catch { hasVideoAudio = existsSync(videoAudioFixture) } if (hasVideoAudio) { console.log('WebM video+audio') let webm = readFileSync(videoAudioFixture) ok(await (async () => { let r = await decode(webm) return r.channelData.length >= 1 && r.sampleRate === 48000 })(), 'extracts audio from video+audio WebM') ok(await (async () => { let r = await decode(webm) return near(dur(r), 1.0, 0.15) })(), 'video+audio: ~1s duration') ok(await (async () => { let r = await decode(webm) return rms(r.channelData[0]) > 0.01 })(), 'video+audio: has audio content') } else { console.log('SKIP: WebM video+audio (no ffmpeg / fixture)') } // --- Sequential determinism --- if (hasFixture) { console.log('Sequential determinism') let webm = readFileSync(fixture) ok(await (async () => { let r1 = await decode(webm) let r2 = await decode(webm) if (r1.sampleRate !== r2.sampleRate) return false if (r1.channelData.length !== r2.channelData.length) return false for (let ch = 0; ch < r1.channelData.length; ch++) { let a = r1.channelData[ch], b = r2.channelData[ch] if (a.length !== b.length) return false for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false } return true })(), 'sequential decodes produce identical output') } else { console.log('SKIP: Sequential determinism (no fixture)') } // --- Concurrent decoders --- if (hasFixture) { console.log('Concurrent decoders') let webm = readFileSync(fixture) ok(await (async () => { let results = await Promise.all([decode(webm), decode(webm), decode(webm)]) return results.every(r => r.channelData.length === 1 && r.sampleRate === 48000 && near(dur(r), 1.0, 0.1)) })(), 'Promise.all decode x3 succeeds') } else { console.log('SKIP: Concurrent decoders (no fixture)') } // --- NaN/Inf validation --- if (hasFixture) { console.log('NaN/Inf validation') let webm = readFileSync(fixture) ok(await (async () => { let r = await decode(webm) for (let ch of r.channelData) for (let i = 0; i < ch.length; i++) if (!isFinite(ch[i])) return false return true })(), 'no NaN or Infinity in output samples') } else { console.log('SKIP: NaN/Inf validation (no fixture)') } // --- Performance benchmark --- if (hasFixture) { console.log('Performance benchmark') let webm = readFileSync(fixture) let iters = 10 let t0 = performance.now() for (let i = 0; i < iters; i++) await decode(webm) let elapsed = performance.now() - t0 let avg = elapsed / iters console.log(` ${iters} decodes in ${elapsed.toFixed(0)}ms (avg ${avg.toFixed(1)}ms)`) ok(avg < 5000, `avg decode < 5s (got ${avg.toFixed(1)}ms)`) } else { console.log('SKIP: Performance benchmark (no fixture)') } // --- Real file: Opus mono (lena.webm) --- console.log('real file: Opus mono') { let webm = readFileSync(new URL('lena.webm', import.meta.resolve('audio-lena'))) let r = await decode(webm) ok(r.channelData.length === 1, 'mono') ok(r.sampleRate === 48000, 'sampleRate 48000') ok(near(r.channelData[0].length / r.sampleRate, 12.27, 0.3), 'duration ~12.27s') ok(rms(r.channelData[0]) > 0.03, 'has audio content') // no NaN/Inf let bad = 0 for (let ch of r.channelData) for (let i = 0; i < ch.length; i++) if (!isFinite(ch[i])) bad++ ok(bad === 0, 'no NaN/Inf') } // --- Performance (real file) --- console.log('performance (real file)') { let webm = readFileSync(new URL('lena.webm', import.meta.resolve('audio-lena'))) await decode(webm) // warmup let t0 = performance.now(), N = 5 for (let i = 0; i < N; i++) await decode(webm) let ms = (performance.now() - t0) / N ok(ms < 2000, 'real file decode < 2s (' + ms.toFixed(0) + 'ms)') console.log(' ' + ms.toFixed(0) + 'ms/decode (161KB, 12.3s audio)') } // --- Vorbis: mono --- console.log('WebM+Vorbis mono decode') { let webm = readFileSync(new URL('./fixtures/vorbis-mono.webm', import.meta.url)) let r = await decode(webm) ok(r.channelData.length === 1, 'vorbis mono: 1 channel') ok(r.sampleRate === 44100, 'vorbis mono: sampleRate 44100') ok(near(dur(r), 1.0, 0.1), 'vorbis mono: ~1s duration') ok(rms(r.channelData[0]) > 0.1, 'vorbis mono: has audio content') let bad = 0 for (let ch of r.channelData) for (let i = 0; i < ch.length; i++) if (!isFinite(ch[i])) bad++ ok(bad === 0, 'vorbis mono: no NaN/Inf') } // --- Vorbis: stereo --- console.log('WebM+Vorbis stereo decode') { let webm = readFileSync(new URL('./fixtures/vorbis-stereo.webm', import.meta.url)) let r = await decode(webm) ok(r.channelData.length === 2, 'vorbis stereo: 2 channels') ok(r.sampleRate === 44100, 'vorbis stereo: sampleRate 44100') ok(near(dur(r), 1.0, 0.1), 'vorbis stereo: ~1s duration') ok(rms(r.channelData[0]) > 0.1 && rms(r.channelData[1]) > 0.1, 'vorbis stereo: both channels have content') } // --- Vorbis: real file (lena-vorbis.webm) --- console.log('real file: Vorbis mono') { let webm = readFileSync(new URL('lena-vorbis.webm', import.meta.resolve('audio-lena'))) let r = await decode(webm) ok(r.channelData.length === 1, 'vorbis lena: mono') ok(r.sampleRate === 44100, 'vorbis lena: sampleRate 44100') ok(near(r.channelData[0].length / r.sampleRate, 12.27, 0.3), 'vorbis lena: duration ~12.27s') ok(rms(r.channelData[0]) > 0.03, 'vorbis lena: has audio content') let bad = 0 for (let ch of r.channelData) for (let i = 0; i < ch.length; i++) if (!isFinite(ch[i])) bad++ ok(bad === 0, 'vorbis lena: no NaN/Inf') } // --- Vorbis: determinism --- console.log('Vorbis determinism') { let webm = readFileSync(new URL('./fixtures/vorbis-mono.webm', import.meta.url)) ok(await (async () => { let r1 = await decode(webm) let r2 = await decode(webm) if (r1.sampleRate !== r2.sampleRate) return false if (r1.channelData.length !== r2.channelData.length) return false for (let ch = 0; ch < r1.channelData.length; ch++) { let a = r1.channelData[ch], b = r2.channelData[ch] if (a.length !== b.length) return false for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false } return true })(), 'vorbis: sequential decodes produce identical output') } // --- Vorbis: concurrent --- console.log('Vorbis concurrent') { let webm = readFileSync(new URL('./fixtures/vorbis-mono.webm', import.meta.url)) ok(await (async () => { let results = await Promise.all([decode(webm), decode(webm), decode(webm)]) return results.every(r => r.channelData.length === 1 && r.sampleRate === 44100 && near(dur(r), 1.0, 0.1)) })(), 'vorbis: Promise.all decode x3 succeeds') } // --- Vorbis: performance --- console.log('Vorbis performance') { let webm = readFileSync(new URL('lena-vorbis.webm', import.meta.resolve('audio-lena'))) await decode(webm) // warmup let t0 = performance.now(), N = 5 for (let i = 0; i < N; i++) await decode(webm) let ms = (performance.now() - t0) / N ok(ms < 2000, 'vorbis decode < 2s (' + ms.toFixed(0) + 'ms)') console.log(' ' + ms.toFixed(0) + 'ms/decode (112KB, 12.3s audio)') } // --- Summary --- console.log(`\n${pass} passed, ${fail} failed`) if (fail) process.exit(1)