@siteed/expo-audio-stream 1.7.2 → 1.9.0

package/src/ExpoAudioStream.web.ts

@@ -13,11 +13,18 @@ import {
 import { WebRecorder } from './WebRecorder.web'
 import { AudioEventPayload } from './events'
 import { encodingToBitDepth } from './utils/encodingToBitDepth'
-import { writeWavHeader } from './utils/writeWavHeader'
 
 export interface EmitAudioEventProps {
     data: Float32Array
     position: number
+    compression?: {
+        data: Blob
+        size: number
+        totalSize: number
+        mimeType: string
+        format: string
+        bitrate: number
+    }
 }
 export type EmitAudioEventFunction = (_: EmitAudioEventProps) => void
 export type EmitAudioAnalysisFunction = (_: AudioAnalysis) => void
@@ -26,6 +33,7 @@ export interface ExpoAudioStreamWebProps {
     logger?: ConsoleLike
     audioWorkletUrl: string
     featuresExtratorUrl: string
+    maxBufferSize?: number // Maximum number of chunks to keep in memory
 }
 
 export class ExpoAudioStreamWeb extends LegacyEventEmitter {
@@ -40,6 +48,7 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
     currentInterval: number
     lastEmittedSize: number
     lastEmittedTime: number
+    lastEmittedCompressionSize: number
     streamUuid: string | null
     extension: 'webm' | 'wav' = 'wav' // Default extension is 'webm'
     recordingConfig?: RecordingConfig
@@ -47,11 +56,15 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
     audioWorkletUrl: string
     featuresExtratorUrl: string
     logger?: ConsoleLike
+    latestPosition: number = 0
+    totalCompressedSize: number = 0
+    private readonly maxBufferSize: number
 
     constructor({
         audioWorkletUrl,
         featuresExtratorUrl,
         logger,
+        maxBufferSize = 100, // Default to storing last 100 chunks (1 chunk = 0.5 seconds)
     }: ExpoAudioStreamWebProps) {
         const mockNativeModule = {
             addListener: () => {
@@ -76,9 +89,12 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
         this.currentInterval = 1000 // Default interval in ms
         this.lastEmittedSize = 0
         this.lastEmittedTime = 0
+        this.latestPosition = 0
+        this.lastEmittedCompressionSize = 0
         this.streamUuid = null // Initialize UUID on first recording start
         this.audioWorkletUrl = audioWorkletUrl
         this.featuresExtratorUrl = featuresExtratorUrl
+        this.maxBufferSize = maxBufferSize
     }
 
     // Utility to handle user media stream
@@ -86,7 +102,7 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
         try {
             return await navigator.mediaDevices.getUserMedia({ audio: true })
         } catch (error) {
-            console.error('Failed to get media stream:', error)
+            this.logger?.error('Failed to get media stream:', error)
             throw error
         }
     }
@@ -110,6 +126,7 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
         const source = audioContext.createMediaStreamSource(stream)
 
         this.customRecorder = new WebRecorder({
+            logger: this.logger,
             audioContext,
             source,
             recordingConfig,
@@ -117,12 +134,18 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
             emitAudioEventCallback: ({
                 data,
                 position,
+                compression,
             }: EmitAudioEventProps) => {
+                // Keep only the latest chunks based on maxBufferSize
                 this.audioChunks.push(new Float32Array(data))
+                if (this.audioChunks.length > this.maxBufferSize) {
+                    this.audioChunks.shift() // Remove oldest chunk
+                }
                 this.currentSize += data.byteLength
-                this.emitAudioEvent({ data, position })
+                this.emitAudioEvent({ data, position, compression })
                 this.lastEmittedTime = Date.now()
                 this.lastEmittedSize = this.currentSize
+                this.lastEmittedCompressionSize = compression?.size ?? 0
             },
             emitAudioAnalysisCallback: (audioAnalysisData: AudioAnalysis) => {
                 this.logger?.log(`Emitted AudioAnalysis:`, audioAnalysisData)
@@ -146,6 +169,7 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
         this.isPaused = false
         this.lastEmittedSize = 0
         this.lastEmittedTime = 0
+        this.lastEmittedCompressionSize = 0
         this.streamUuid = Date.now().toString()
         const fileUri = `${this.streamUuid}.${this.extension}`
         const streamConfig: StartRecordingResult = {
@@ -154,21 +178,46 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
             bitDepth: this.bitDepth,
             channels: recordingConfig.channels ?? 1,
             sampleRate: recordingConfig.sampleRate ?? 44100,
+            compression: recordingConfig.compression
+                ? {
+                      ...recordingConfig.compression,
+                      bitrate: recordingConfig.compression?.bitrate ?? 128000,
+                      size: 0,
+                      mimeType: 'audio/webm',
+                      format: recordingConfig.compression?.format ?? 'opus',
+                      compressedFileUri: '',
+                  }
+                : undefined,
         }
         return streamConfig
     }
 
-    emitAudioEvent({ data, position }: EmitAudioEventProps) {
+    emitAudioEvent({ data, position, compression }: EmitAudioEventProps) {
         const fileUri = `${this.streamUuid}.${this.extension}`
+        if (compression?.size) {
+            this.lastEmittedCompressionSize = compression.size
+            this.totalCompressedSize = compression.totalSize
+        }
+        this.latestPosition = position
+        this.currentDurationMs = position * 1000 // Convert position (in seconds) to ms
+
         const audioEventPayload: AudioEventPayload = {
             fileUri,
             mimeType: `audio/${this.extension}`,
-            lastEmittedSize: this.lastEmittedSize, // Since this might be continuously streaming, adjust accordingly
+            lastEmittedSize: this.lastEmittedSize,
             deltaSize: data.byteLength,
             position,
             totalSize: this.currentSize,
             buffer: data,
-            streamUuid: this.streamUuid ?? '', // Generate or manage UUID for stream identification
+            streamUuid: this.streamUuid ?? '',
+            compression: compression
+                ? {
+                      data: compression?.data,
+                      totalSize: this.totalCompressedSize,
+                      eventDataSize: compression?.size ?? 0,
+                      position,
+                  }
+                : undefined,
         }
 
         this.emit('AudioData', audioEventPayload)
@@ -180,43 +229,58 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
             throw new Error('Recorder is not initialized')
         }
 
-        const fullPcmBufferArray = await this.customRecorder.stop()
+        this.logger?.debug('[Stop] Starting stop process')
+        const startTime = performance.now()
 
-        this.logger?.debug(`Stopped recording`, fullPcmBufferArray)
-        this.isRecording = false
-        this.isPaused = false
-        this.currentDurationMs = Date.now() - this.recordingStartTime
+        try {
+            this.logger?.debug('[Stop] Stopping recorder')
+            const { compressedBlob } = await this.customRecorder.stop()
 
-        // Create WAV header and combine with PCM data in one step
-        const wavBuffer = writeWavHeader({
-            buffer: fullPcmBufferArray.buffer,
-            sampleRate: this.recordingConfig?.sampleRate ?? 44100,
-            numChannels: this.recordingConfig?.channels ?? 1,
-            bitDepth: this.bitDepth,
-        })
+            this.isRecording = false
+            this.isPaused = false
+            this.currentDurationMs = Date.now() - this.recordingStartTime
 
-        // Create a cloneable copy
-        const cloneableBuffer = wavBuffer.slice(0)
+            let compression: AudioRecording['compression']
+            let fileUri = `${this.streamUuid}.${this.extension}`
+            let mimeType = `audio/${this.extension}`
 
-        // Create blob with complete WAV data
-        const blob = new Blob([cloneableBuffer], {
-            type: `audio/${this.extension}`,
-        })
-        const fileUri = URL.createObjectURL(blob)
+            if (compressedBlob && this.recordingConfig?.compression?.enabled) {
+                const compressedUri = URL.createObjectURL(compressedBlob)
+                compression = {
+                    compressedFileUri: compressedUri,
+                    size: compressedBlob.size,
+                    mimeType: 'audio/webm',
+                    format: 'opus',
+                    bitrate: this.recordingConfig.compression.bitrate ?? 128000,
+                }
+                // Use compressed values when compression is enabled
+                fileUri = compressedUri
+                mimeType = 'audio/webm'
+            }
 
-        const result: AudioRecording = {
-            fileUri,
-            filename: `${this.streamUuid}.${this.extension}`,
-            wavPCMData: new Float32Array(cloneableBuffer),
-            bitDepth: this.bitDepth,
-            channels: this.recordingConfig?.channels ?? 1,
-            sampleRate: this.recordingConfig?.sampleRate ?? 44100,
-            durationMs: this.currentDurationMs,
-            size: this.currentSize,
-            mimeType: `audio/${this.extension}`,
-        }
+            this.logger?.debug(
+                `[Stop] Completed stop process in ${performance.now() - startTime}ms`,
+                {
+                    durationMs: this.currentDurationMs,
+                    compressedSize: compression?.size,
+                }
+            )
 
-        return result
+            return {
+                fileUri,
+                filename: `${this.streamUuid}.${this.extension}`,
+                bitDepth: this.bitDepth,
+                channels: this.recordingConfig?.channels ?? 1,
+                sampleRate: this.recordingConfig?.sampleRate ?? 44100,
+                durationMs: this.currentDurationMs,
+                size: this.currentSize,
+                mimeType,
+                compression,
+            }
+        } catch (error) {
+            this.logger?.error('[Stop] Error stopping recording:', error)
+            throw error
+        }
     }
 
     // Pause recording
@@ -250,10 +314,19 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
         const status: AudioStreamStatus = {
             isRecording: this.isRecording,
             isPaused: this.isPaused,
-            durationMs: Date.now() - this.recordingStartTime,
+            durationMs: this.currentDurationMs,
             size: this.currentSize,
             interval: this.currentInterval,
             mimeType: `audio/${this.extension}`,
+            compression: this.recordingConfig?.compression?.enabled
+                ? {
+                      size: this.totalCompressedSize,
+                      mimeType: 'audio/webm',
+                      format: this.recordingConfig.compression.format ?? 'opus',
+                      bitrate:
+                          this.recordingConfig.compression.bitrate ?? 128000,
+                  }
+                : undefined,
         }
         return status
     }