@@ -58,9 +58,9 @@ class AudioPlayer {
private onEndCallback : EndCallback | null = null ;
private progressInterval : number | null = null ;
private bufferChunks : Uint8Array [ ] = [ ] ;
private expectedSize : number = 0 ;
private currentSize : number = 0 ;
private processedBytes : number = 0 ; // Track how many bytes we've already processed
// Streaming properties
private isStreamingMode : boolean = false ;
private wavHeader : WavHeader | null = null ;
@@ -68,12 +68,10 @@ class AudioPlayer {
private currentStreamSource : AudioBufferSourceNode | null = null ;
private nextStartTime : number = 0 ;
private streamingStarted : boolean = false ;
private minBuffersForStreaming number = 3 ;
private streamingCompleted boolean = false ; // Track if streaming is finished
private totalStreamLength : number = 0 ; // Total bytes expected in stream
private minBuffersForStreaming : number = 6 ; // Increased for better buffering
// Buffer optimization
private cachedWavHeader : Uint8Array | null = null ;
private reusableBuffer : Uint8Array | null = null ;
private maxReusableBufferSize : number = 128 * 1024 ; // 128KB max reusable buffer
async initialize ( ) : Promise < AudioResult > {
try {
@@ -81,9 +79,26 @@ class AudioPlayer {
if ( ! AudioContextClass ) {
throw new Error ( 'Web Audio API not supported' ) ;
}
this . audioContext = new AudioContextClass ( ) ;
// Initialize with 44.1kHz for music (most common rate) to avoid recreation
this . audioContext = new AudioContextClass ( { sampleRate : 44100 } ) ;
this . gainNode = this . audioContext . createGain ( ) ;
this . gainNode . connect ( this . audioContext . destination ) ;
console . log ( ` AudioContext initialized: sampleRate= ${ this . audioContext . sampleRate } Hz, state= ${ this . audioContext . state } ` ) ;
return { success : true } ;
} catch ( error ) {
return { success : false , error : ( error as Error ) . message } ;
}
}
async ensureAudioContextReady ( ) : Promise < AudioResult > {
try {
if ( this . audioContext ! . state === 'suspended' ) {
console . log ( '🔊 Resuming AudioContext on track selection (user interaction)' ) ;
await this . audioContext ! . resume ( ) ;
console . log ( ` ✅ AudioContext resumed: state= ${ this . audioContext ! . state } ` ) ;
}
return { success : true } ;
} catch ( error ) {
return { success : false , error : ( error as Error ) . message } ;
@@ -94,7 +109,6 @@ class AudioPlayer {
try {
this . bufferChunks = [ ] ;
this . currentSize = 0 ;
this . expectedSize = 0 ;
return { success : true } ;
} catch ( error ) {
return { success : false , error : ( error as Error ) . message } ;
@@ -320,39 +334,44 @@ class AudioPlayer {
this . onEndCallback = callback ;
}
initializeStreaming ( ) : AudioResult {
initializeStreaming ( totalStreamLength : number ) : AudioResult {
try {
this . isStreamingMode = true ;
this . bufferChunks = [ ] ;
this . bufferQueue = [ ] ;
this . currentSize = 0 ;
this . processedBytes = 0 ; // Reset stream position
this . totalStreamLength = totalStreamLength ; // Set total expected stream length
this . wavHeader = null ;
this . streamingStarted = false ;
this . streamingCompleted = false ; // Reset completion flag
this . nextStartTime = 0 ;
console . log ( ` Streaming initialized: expecting ${ this . totalStreamLength } total bytes ` ) ;
return { success : true } ;
} catch ( error ) {
return { success : false , error : ( error as Error ) . message } ;
}
}
processStreamingChunk ( audioChunk : Uint8Array ) : StreamingResult {
private chunkCounter = 0 ;
async processStreamingChunk ( audioChunk : Uint8Array ) : Promise < StreamingResult > {
try {
this . bufferChunks . push ( audioChunk ) ;
this . currentSize += audioChunk . length ;
this . chunkCounter ++ ;
console . log ( ` \ n=== CHUNK ${ this . chunkCounter } === ` ) ;
console . log ( ` Incoming chunk size: ${ audioChunk . length } ` ) ;
console . log ( ` Chunk preview: ` , Array . from ( audioChunk . slice ( 0 , 32 ) ) . map ( b = > b . toString ( 16 ) . padStart ( 2 , '0' ) ) . join ( ' ' ) ) ;
console . log ( ` Buffer queue length before processing: ${ this . bufferQueue . length } ` ) ;
// Parse WAV header from first chunk if not done yet
if ( ! this . wavHeader && this . currentSize >= 44 ) {
const header = WavUtils . parseHeader ( this . bufferChunks , this . currentSize ) ;
if ( header ) {
this . wavHeader = header ;
// Cache the WAV header for reuse
this . cachedWavHeader = WavUtils . createHeader ( header , 64 * 1024 ) ; // Cache with dummy size
}
}
await this . processChunk ( audioChunk ) ;
// Try to create audio buffers from accumulated chunks
if ( this . wavHeader ) {
this . processBufferedChunks ( ) ;
// Check if we've received all expected data
console . log ( ` Stream check: ${ this . currentSize } / ${ this . totalStreamLength } bytes, completed= ${ this . streamingCompleted } ` ) ;
if ( this . totalStreamLength > 0 && this . currentSize >= this . totalStreamLength ) {
console . log ( ` Stream complete: received ${ this . currentSize } / ${ this . totalStreamLength } bytes ` ) ;
this . streamingCompleted = true ;
}
const canStart = this . wavHeader !== null && this . bufferQueue . length >= this . minBuffersForStreaming ;
@@ -368,115 +387,166 @@ class AudioPlayer {
}
}
startStreamingPlayback ( ) : AudioResult {
if ( ! this . wavHeader || this . bufferQueue . length === 0 ) {
return { success : false , error : "Not ready for streaming playback" } ;
private isFirstChunk = true ;
private async processChunk ( audioChunk : Uint8Array ) : Promise < void > {
if ( this . isFirstChunk ) {
const audioData = await this . extractAudioFromFirstChunk ( audioChunk ) ;
this . addToAudioStream ( audioData ) ;
this . isFirstChunk = false ;
} else {
// Continuation chunks are pure audio data
this . addToAudioStream ( audioChunk ) ;
}
try {
if ( this . audioContext ! . state === 'suspended' ) {
this . audioContext ! . resume ( ) ;
}
this . streamingStarted = true ;
this . isPlaying = true ;
this . isPaused = false ;
this . nextStartTime = this . audioContext ! . currentTime ;
this . startTime = this . nextStartTime ;
this . scheduleNextBuffer ( ) ;
this . startProgressTracking ( ) ;
return { success : true } ;
} catch ( error ) {
return { success : false , error : ( error as Error ) . message } ;
}
}
private processBufferedChunks ( ) : void {
if ( ! this . wavHeader || this . bufferChunks . length === 0 ) return ;
try {
// Process chunks in groups to create audio buffers
const chunkSize = 64 * 1024 ; // 64KB chunks for streaming
while ( this . currentSize >= chunkSize + this . wavHeader . headerSize ) {
// Extract audio data using WavUtils
const audioData = WavUtils . extractAudioData ( this . bufferChunks , this . currentSize , this . wavHeader . headerSize , chunkSize ) ;
// Reuse buffer if possible to reduce allocations
const totalSize = this . cachedWavHeader ! . length + audioData . length - this . wavHeader . headerSize ;
if ( ! this . reusableBuffer || this . reusableBuffer . length < totalSize ) {
// Only allocate if we don't have a buffer or it's too small
this . reusableBuffer = new Uint8Array ( Math . min ( totalSize , this . maxReusableBufferSize ) ) ;
}
// Create complete WAV buffer using cached header and reusable buffer
const completeBuffer = this . reusableBuffer . slice ( 0 , totalSize ) ;
completeBuffer . set ( this . cachedWavHeader ! . slice ( 0 , this . wavHeader . headerSize ) , 0 ) ;
completeBuffer . set ( audioData . subarray ( this . wavHeader . headerSize ) , this . wavHeader . headerSize ) ;
// Create audio buffer from the chunk
this . createAudioBufferFromChunk ( completeBuffer ) ;
// Remove processed data
this . removeProcessedChunks ( chunkSize ) ;
break ; // Process one chunk at a time
}
} catch ( error ) {
console . error ( 'Error processing buffered chunks:' , error ) ;
}
}
private async createAudioBufferFromChunk ( chunkData : Uint8Array ) : Promise < void > {
try {
const arrayBuffer = chunkData . buffer . slice ( chunkData . byteOffset , chunkData . byteOffset + chunkData . byteLength ) ;
const audioBuffer = await this . audioContext ! . decodeAudioData ( arrayBuffer ) ;
this . bufferQueue . push ( audioBuffer ) ;
// Schedule buffer if streaming has started
if ( this . streamingStarted ) {
this . scheduleNextBuffer ( ) ;
}
} catch ( error ) {
console . error ( 'Error creating audio buffer from chunk:' , error ) ;
}
}
private scheduleNextBuffer ( ) : void {
if ( this . bufferQueue . length === 0 || ! this . streamingStarted ) return ;
const buffer = this . bufferQueue . shift ( ) ! ;
const source = this . audioContext ! . createBufferSource ( ) ;
source . buffer = buffer ;
source . connect ( this . gainNode ! ) ;
source . onended = ( ) = > {
if ( this . bufferQueue . length > 0 ) {
this . scheduleNextBuffer ( ) ;
} else if ( ! this . isPlaying ) {
this . onEndCallback ? . ( ) ;
}
} ;
source . start ( this . nextStartTime ) ;
this . nextStartTime += buffer . duration ;
this . currentStreamSource = source ;
await this . processAudioStream ( ) ;
}
private async extractAudioFromFirstChunk ( chunkData : Uint8Array ) : Promise < Uint8Array > {
console . log ( '\n--- EXTRACTING AUDIO FROM FIRST CHUNK ---' ) ;
// Parse header and setup AudioContext
const header = WavUtils . parseHeader ( [ chunkData ] , chunkData . length ) ;
if ( ! header ) {
throw new Error ( 'Invalid WAV header in first chunk' ) ;
}
this . wavHeader = header ;
console . log ( ` WAV format: ${ header . bitsPerSample } -bit, ${ header . channels } ch, ${ header . sampleRate } Hz ` ) ;
console . log ( ` Header details: blockAlign= ${ header . blockAlign } , byteRate= ${ header . byteRate } , headerSize= ${ header . headerSize } ` ) ;
// Recreate AudioContext with correct sample rate if needed (only during initial setup)
if ( this . audioContext ! . sampleRate !== header . sampleRate ) {
console . log ( ` 🔄 AudioContext sample rate mismatch: ${ this . audioContext ! . sampleRate } Hz -> ${ header . sampleRate } Hz ` ) ;
private removeProcessedChunks ( processedSize : number ) : void {
// Only recreate if we haven't started playing yet AND AudioContext is already running
if ( ! this . streamingStarted && ! this . isPlaying && this . audioContext ! . state === 'running' ) {
console . log ( ` ⚠️ Recreating AudioContext for proper sample rate matching ` ) ;
await this . audioContext ! . close ( ) ;
const AudioContextClass = window . AudioContext || window . webkitAudioContext ;
this . audioContext = new AudioContextClass ( { sampleRate : header.sampleRate } ) ;
this . gainNode = this . audioContext . createGain ( ) ;
this . gainNode . connect ( this . audioContext . destination ) ;
console . log ( ` ✅ AudioContext recreated: ${ this . audioContext . sampleRate } Hz (should eliminate resampling artifacts) ` ) ;
} else {
console . log ( ` ℹ ` ) ;
}
}
// Extract pure audio data (skip WAV header)
const audioData = chunkData . subarray ( header . headerSize ) ;
console . log ( ` Extracted ${ audioData . length } bytes of audio data (skipped ${ header . headerSize } byte header) ` ) ;
return audioData ;
}
private async ensureCorrectSampleRate ( sampleRate : number ) : Promise < void > {
if ( this . audioContext ! . sampleRate !== sampleRate ) {
console . log ( ` 🔊 AUDIO CONTEXT CHANGE START: ${ this . audioContext ! . sampleRate } Hz -> ${ sampleRate } Hz ` ) ;
console . log ( ` ⚠️ This may cause an audible pop/click! ` ) ;
await this . audioContext ! . close ( ) ;
console . log ( ` ✅ Old AudioContext closed ` ) ;
const AudioContextClass = window . AudioContext || window . webkitAudioContext ;
this . audioContext = new AudioContextClass ( { sampleRate } ) ;
console . log ( ` ✅ New AudioContext created: actual= ${ this . audioContext . sampleRate } Hz (requested= ${ sampleRate } Hz) ` ) ;
this . gainNode = this . audioContext . createGain ( ) ;
this . gainNode . connect ( this . audioContext . destination ) ;
console . log ( ` 🔊 AUDIO CONTEXT CHANGE COMPLETE ` ) ;
}
}
private addToAudioStream ( audioData : Uint8Array ) : void {
this . bufferChunks . push ( audioData ) ;
this . currentSize += audioData . length ;
console . log ( ` Added ${ audioData . length } bytes to audio stream (total: ${ this . currentSize } bytes) ` ) ;
}
private async processAudioStream ( ) : Promise < void > {
if ( ! this . wavHeader ) return ;
// Process available data (but don't over-process during active playback)
if ( this . streamingStarted && this . bufferQueue . length >= 2 ) {
console . log ( ` Buffer queue has cushion ( ${ this . bufferQueue . length } ), minimal processing ` ) ;
// Still process but be less aggressive
}
// Create sample-aligned segments from continuous audio stream
const maxSegmentSize = 64 * 1024 ; // 64KB segments to match C# chunks better
const availableBytes = this . currentSize - this . processedBytes ; // Only count unprocessed bytes
const alignedSize = WavUtils . getSampleAlignedChunkSize ( this . wavHeader , maxSegmentSize , availableBytes ) ;
if ( alignedSize > 0 ) {
console . log ( ` \ n--- CREATING ALIGNED AUDIO SEGMENT --- ` ) ;
console . log ( ` Available: ${ availableBytes } bytes, requesting: ${ alignedSize } bytes (frame-aligned, frame size: ${ this . wavHeader . blockAlign } ) ` ) ;
console . log ( ` Buffer queue: ${ this . bufferQueue . length } , processing chunk ` ) ;
// Extract sample-aligned segment from continuous stream
const alignedSegment = this . extractAlignedData ( alignedSize ) ;
const wavFile = this . createWavFromRawData ( alignedSegment ) ;
await this . createAudioBufferFromChunk ( wavFile ) ;
// Note: No longer removing processed data - we track position instead
}
}
private extractAlignedData ( alignedSize : number ) : Uint8Array {
const extracted = new Uint8Array ( alignedSize ) ;
let extractedOffset = 0 ;
let remaining = alignedSize ;
let streamPosition = this . processedBytes ; // Start from where we left off
let currentPos = 0 ;
for ( const chunk of this . bufferChunks ) {
if ( remaining <= 0 ) break ;
// Skip chunks that are entirely before our current stream position
if ( currentPos + chunk . length <= streamPosition ) {
currentPos += chunk . length ;
continue ;
}
// Calculate the offset within this chunk to start extracting
const chunkStartOffset = Math . max ( 0 , streamPosition - currentPos ) ;
const availableInChunk = chunk . length - chunkStartOffset ;
const toCopy = Math . min ( availableInChunk , remaining ) ;
if ( toCopy > 0 ) {
extracted . set ( chunk . subarray ( chunkStartOffset , chunkStartOffset + toCopy ) , extractedOffset ) ;
extractedOffset += toCopy ;
remaining -= toCopy ;
}
currentPos += chunk . length ;
}
// Update processed bytes position
this . processedBytes += alignedSize ;
console . log ( ` Extracted ${ alignedSize } bytes from stream position ${ streamPosition } -> ${ this . processedBytes } ` ) ;
return extracted ;
}
private removeProcessedData ( processedSize : number ) : void {
let remaining = processedSize ;
while ( remaining > 0 && this . bufferChunks . length > 0 ) {
const chunk = this . bufferChunks [ 0 ] ;
if ( chunk . length <= remaining ) {
remaining - =chunk . length ;
this . currentSize -= chunk . length ;
const firstChunk = this . bufferChunks [ 0 ] ;
if ( firstChunk . length < =remaining ) {
// Remove entire chunk
remaining -= firstChunk . length ;
this . currentSize -= firstChunk . length ;
this . bufferChunks . shift ( ) ;
} else {
// Partial chunk removal
const newChunk = chunk . slice ( remaining ) ;
// Partially remove chunk
const newChunk = firstChunk . subarray ( remaining ) ;
this . bufferChunks [ 0 ] = newChunk ;
this . currentSize -= remaining ;
remaining = 0 ;
@@ -484,6 +554,203 @@ class AudioPlayer {
}
}
private concatenateChunks ( ) : Uint8Array {
const totalSize = this . currentSize ;
const concatenated = new Uint8Array ( totalSize ) ;
let offset = 0 ;
for ( const chunk of this . bufferChunks ) {
concatenated . set ( chunk , offset ) ;
offset += chunk . length ;
}
return concatenated ;
}
private createWavFromRawData ( rawData : Uint8Array ) : Uint8Array {
const header = WavUtils . createHeader ( this . wavHeader ! , rawData . length ) ;
const wavFile = new Uint8Array ( header . length + rawData . length ) ;
wavFile . set ( header , 0 ) ;
wavFile . set ( rawData , header . length ) ;
console . log ( ` Created WAV: header= ${ header . length } bytes, data= ${ rawData . length } bytes, total= ${ wavFile . length } bytes ` ) ;
console . log ( ` Expected duration: ${ rawData . length / this . wavHeader ! . byteRate } seconds ` ) ;
return wavFile ;
}
startStreamingPlayback ( ) : AudioResult {
if ( ! this . wavHeader || this . bufferQueue . length === 0 ) {
return { success : false , error : "Not ready for streaming playback" } ;
}
try {
console . log ( ` \ n=== STARTING STREAMING PLAYBACK === ` ) ;
console . log ( ` AudioContext state: ${ this . audioContext ! . state } ` ) ;
console . log ( ` AudioContext sample rate: ${ this . audioContext ! . sampleRate } Hz ` ) ;
console . log ( ` Current time precision: ${ this . audioContext ! . currentTime . toFixed ( 6 ) } s ` ) ;
console . log ( ` Queue ready: ${ this . bufferQueue . length } buffers, ${ this . bufferQueue . reduce ( ( sum , b ) = > sum + b . duration , 0 ) . toFixed ( 3 ) } s total ` ) ;
// AudioContext should already be resumed during track selection
const startTimestamp = performance . now ( ) ;
const audioContextTime = this . audioContext ! . currentTime ;
this . streamingStarted = true ;
this . isPlaying = true ;
this . isPaused = false ;
this . nextStartTime = audioContextTime ;
this . startTime = this . nextStartTime ;
console . log ( ` ▶️ Playback timing: audioContext= ${ audioContextTime . toFixed ( 6 ) } s, performance= ${ startTimestamp . toFixed ( 3 ) } ms ` ) ;
console . log ( ` 🎵 Initial nextStartTime set to: ${ this . nextStartTime . toFixed ( 6 ) } s ` ) ;
this . scheduleNextBuffer ( ) ;
this . startProgressTracking ( ) ;
console . log ( ` ✅ Streaming playback started successfully ` ) ;
console . log ( ` ===================================== \ n ` ) ;
return { success : true } ;
} catch ( error ) {
console . error ( ` ❌ Failed to start streaming playback: ` , error ) ;
return { success : false , error : ( error as Error ) . message } ;
}
}
private async createAudioBufferFromChunk ( chunkData : Uint8Array ) : Promise < void > {
try {
console . log ( ` createAudioBufferFromChunk: chunkData.length= ${ chunkData . length } ` ) ;
// Create a clean ArrayBuffer with exact size (avoid reusable buffer issues)
const cleanBuffer = new ArrayBuffer ( chunkData . length ) ;
new Uint8Array ( cleanBuffer ) . set ( chunkData ) ;
console . log ( ` Decoding ${ cleanBuffer . byteLength } bytes with Web Audio API ` ) ;
console . log ( 'Starting decode...' ) ;
// Try with timeout to catch hanging decodes
const decodePromise = this . audioContext ! . decodeAudioData ( cleanBuffer ) ;
const timeoutPromise = new Promise < never > ( ( _ , reject ) = > {
setTimeout ( ( ) = > reject ( new Error ( 'Decode timeout after 5 seconds' ) ) , 5000 ) ;
} ) ;
const audioBuffer = await Promise . race ( [ decodePromise , timeoutPromise ] ) ;
console . log ( "AFTER Promise.race - this should always appear after 5 seconds max" ) ;
console . log ( ` \ n--- DECODE SUCCESS --- ` ) ;
console . log ( ` Buffer duration: ${ audioBuffer . duration } s ` ) ;
console . log ( ` Buffer channels: ${ audioBuffer . numberOfChannels } ` ) ;
console . log ( ` Buffer sample rate: ${ audioBuffer . sampleRate } ` ) ;
console . log ( ` Buffer length: ${ audioBuffer . length } samples ` ) ;
// Check if buffer contains actual audio data or silence/noise
const channel0 = audioBuffer . getChannelData ( 0 ) ;
const firstSamples = Array . from ( channel0 . slice ( 0 , 10 ) ) . map ( v = > v . toFixed ( 4 ) ) ;
const maxValue = Math . max ( . . . Array . from ( channel0 ) . map ( Math . abs ) ) ;
const avgValue = Array . from ( channel0 ) . reduce ( ( sum , val ) = > sum + Math . abs ( val ) , 0 ) / channel0 . length ;
console . log ( ` First 10 samples: ` , firstSamples ) ;
console . log ( ` Max amplitude: ${ maxValue . toFixed ( 4 ) } ` ) ;
console . log ( ` Average amplitude: ${ avgValue . toFixed ( 4 ) } ` ) ;
this . bufferQueue . push ( audioBuffer ) ;
console . log ( ` \ n=== BUFFER QUEUE UPDATE === ` ) ;
console . log ( ` ✓ Added buffer: duration= ${ audioBuffer . duration . toFixed ( 6 ) } s, samples= ${ audioBuffer . length } ` ) ;
console . log ( ` Queue state: ${ this . bufferQueue . length } buffers ( ${ this . bufferQueue . map ( b = > b . duration . toFixed ( 3 ) ) . join ( 's, ' ) } s) ` ) ;
console . log ( ` Total queued audio: ${ this . bufferQueue . reduce ( ( sum , b ) = > sum + b . duration , 0 ) . toFixed ( 3 ) } s ` ) ;
console . log ( ` Streaming: started= ${ this . streamingStarted } , completed= ${ this . streamingCompleted } ` ) ;
console . log ( ` Current playback time: ${ this . audioContext ! . currentTime . toFixed ( 6 ) } s ` ) ;
// Schedule immediately when streaming has started (for gapless playback)
if ( this . streamingStarted ) {
console . log ( ` ⏩ Triggering proactive schedule (streaming active) ` ) ;
this . scheduleNextBuffer ( ) ;
} else {
console . log ( ` ⏸️ Not scheduling yet (streaming not started) ` ) ;
}
console . log ( ` =========================== \ n ` ) ;
} catch ( error ) {
console . error ( 'Error creating audio buffer from chunk:' , error ) ;
console . error ( 'Failed chunk size:' , chunkData . length ) ;
// Log first few bytes of the chunk for debugging
const preview = Array . from ( chunkData . slice ( 0 , 16 ) ) . map ( b = > b . toString ( 16 ) . padStart ( 2 , '0' ) ) . join ( ' ' ) ;
console . error ( 'Chunk preview (first 16 bytes):' , preview ) ;
}
}
private scheduleNextBuffer ( ) : void {
// Schedule all available buffers proactively instead of waiting for onended
while ( this . bufferQueue . length > 0 && this . streamingStarted ) {
const scheduleStartTime = performance . now ( ) ;
const buffer = this . bufferQueue . shift ( ) ! ;
const source = this . audioContext ! . createBufferSource ( ) ;
source . buffer = buffer ;
source . connect ( this . gainNode ! ) ;
// Critical: Use precise timing for gapless playback
const currentTime = this . audioContext ! . currentTime ;
// For the very first buffer, add small lookahead to avoid startup glitches
const startTime = this . nextStartTime > 0 ? this . nextStartTime : currentTime + 0.01 ;
const schedulingDelay = currentTime - startTime ;
console . log ( ` 🎵 Scheduling buffer: start= ${ startTime . toFixed ( 3 ) } s, duration= ${ buffer . duration . toFixed ( 3 ) } s, delay= ${ ( schedulingDelay * 1000 ) . toFixed ( 1 ) } ms ${ schedulingDelay > 0.005 ? '⚠️' : '✓' } , queue= ${ this . bufferQueue . length } ` ) ;
// Only log timing issues for debugging
const gap = Math . abs ( startTime - this . nextStartTime ) ;
if ( gap > 0.001 ) {
console . warn ( ` ⚠️ TIMING GAP: ${ ( gap * 1000 ) . toFixed ( 3 ) } ms between expected and actual start time ` ) ;
}
source . onended = ( ) = > {
const endTime = this . audioContext ! . currentTime ;
const expectedEndTime = startTime + buffer . duration ;
const timingError = Math . abs ( endTime - expectedEndTime ) ;
console . log ( ` 🏁 Buffer ended: timing error= ${ ( timingError * 1000 ) . toFixed ( 1 ) } ms ` ) ;
this . currentStreamSource = null ;
// Check for end-of-stream
if ( this . bufferQueue . length === 0 ) {
if ( this . streamingCompleted ) {
console . log ( ` ✓ End-of-stream: All buffers played at ${ endTime . toFixed ( 3 ) } s (expected) ` ) ;
} else {
console . warn ( ` ❌ Buffer underrun! Queue empty at ${ endTime . toFixed ( 3 ) } s (unexpected during streaming) ` ) ;
}
if ( ! this . isPlaying ) {
this . onEndCallback ? . ( ) ;
}
}
} ;
source . start ( startTime ) ;
// Calculate next start time with sample-perfect precision
this . nextStartTime = startTime + buffer . duration ;
this . currentStreamSource = source ;
const scheduleEndTime = performance . now ( ) ;
const scheduleProcessingTime = scheduleEndTime - scheduleStartTime ;
// Stop scheduling when we have enough buffered ahead
const lookaheadTime = this . nextStartTime - currentTime ;
if ( lookaheadTime > 0.5 ) { // Stop when we have 500ms of audio scheduled ahead
console . log ( ` 📋 Sufficient lookahead: ${ ( lookaheadTime * 1000 ) . toFixed ( 0 ) } ms scheduled ahead ` ) ;
break ;
}
}
}
unload ( ) : AudioResult {
try {
this . stop ( ) ;
@@ -491,22 +758,21 @@ class AudioPlayer {
this . duration = 0 ;
this . bufferChunks = [ ] ;
this . currentSize = 0 ;
this . expectedSize = 0 ;
this . processedBytes = 0 ; // Reset stream position
// Clean up streaming state
this . isStreamingMode = false ;
this . wavHeader = null ;
this . bufferQueue = [ ] ;
this . streamingStarted = false ;
this . streamingCompleted = false ;
this . totalStreamLength = 0 ;
this . nextStartTime = 0 ;
if ( this . currentStreamSource ) {
this . currentStreamSource . stop ( ) ;
this . currentStreamSource = null ;
}
// Clean up cached buffers
this . cachedWavHeader = null ;
this . reusableBuffer = null ;
return { success : true } ;
} catch ( error ) {
@@ -530,8 +796,6 @@ class AudioPlayer {
this . bufferQueue = [ ] ;
this . wavHeader = null ;
this . currentStreamSource = null ;
this . cachedWavHeader = null ;
this . reusableBuffer = null ;
}
}
@@ -583,20 +847,20 @@ const DeepDrftAudio = {
} ,
// Streaming methods
initializeStreaming : ( playerId : string ) : AudioResult = > {
initializeStreaming : ( playerId : string , totalStreamLength : number ) : AudioResult = > {
const player = audioPlayers . get ( playerId ) ;
if ( ! player ) {
return { success : false , error : "Player not found" } ;
}
return player . initializeStreaming ( ) ;
return player . initializeStreaming ( totalStreamLength ) ;
} ,
processStreamingChunk : ( playerId : string , audioChunk : Uint8Array ) : StreamingResult = > {
processStreamingChunk : async ( playerId : string , audioChunk : Uint8Array ) : Promise < StreamingResult > = > {
const player = audioPlayers . get ( playerId ) ;
if ( ! player ) {
return { success : false , error : "Player not found" } ;
}
return player . processStreamingChunk ( audioChunk ) ;
return await player . processStreamingChunk ( audioChunk ) ;
} ,
startStreamingPlayback : ( playerId : string ) : AudioResult = > {
@@ -607,6 +871,14 @@ const DeepDrftAudio = {
return player . startStreamingPlayback ( ) ;
} ,
ensureAudioContextReady : async ( playerId : string ) : Promise < AudioResult > = > {
const player = audioPlayers . get ( playerId ) ;
if ( ! player ) {
return { success : false , error : "Player not found" } ;
}
return await player . ensureAudioContextReady ( ) ;
} ,
play : ( playerId : string ) : AudioResult = > {
const player = audioPlayers . get ( playerId ) ;
if ( ! player ) {
daniel-c-harvey