@siteed/expo-audio-stream 1.7.2 → 1.8.0

package/ios/RecordingResult.swift

@@ -9,6 +9,7 @@ struct RecordingResult {
     var channels: Int
     var bitDepth: Int
     var sampleRate: Double
+    var compression: CompressedRecordingInfo?
 }
 
 struct StartRecordingResult {
@@ -17,4 +18,5 @@ struct StartRecordingResult {
     var channels: Int
     var bitDepth: Int
     var sampleRate: Double
+    var compression: CompressedRecordingInfo?
 }

package/ios/RecordingSettings.swift

@@ -17,6 +17,27 @@ struct IOSNotificationConfig {
     var categoryIdentifier: String?
 }
 
+struct CompressedRecordingInfo {
+    var fileUri: String
+    var mimeType: String
+    var bitrate: Int
+    var format: String
+    
+    static func validate(format: String, bitrate: Int) -> Result<Void, Error> {
+        // Validate format
+        guard ["aac", "opus"].contains(format.lowercased()) else {
+            return .failure(RecordingError.unsupportedFormat(format))
+        }
+        
+        // Validate bitrate
+        guard (8000...960000).contains(bitrate) else {
+            return .failure(RecordingError.invalidBitrate(bitrate))
+        }
+        
+        return .success(())
+    }
+}
+
 struct NotificationConfig {
     var title: String?
     var text: String?
@@ -28,6 +49,20 @@ struct IOSConfig {
     var audioSession: IOSAudioSessionConfig?
 }
 
+enum RecordingError: Error {
+    case unsupportedFormat(String)
+    case invalidBitrate(Int)
+    
+    var localizedDescription: String {
+        switch self {
+        case .unsupportedFormat(let format):
+            return "Unsupported compression format: \(format). iOS only supports AAC."
+        case .invalidBitrate(let bitrate):
+            return "Invalid bitrate: \(bitrate). Must be between 8000 and 960000 bps."
+        }
+    }
+}
+
 struct RecordingSettings {
     // Core recording settings
     var sampleRate: Double
@@ -52,10 +87,35 @@ struct RecordingSettings {
     // Notification configuration
     var notification: NotificationConfig?
     
-    static func fromDictionary(_ dict: [String: Any]) -> RecordingSettings {
+    let enableCompressedOutput: Bool
+    let compressedFormat: String // "aac" or "opus"
+    let compressedBitRate: Int
+    
+    static func fromDictionary(_ dict: [String: Any]) -> Result<RecordingSettings, Error> {
+        // Extract compression settings
+        let compression = dict["compression"] as? [String: Any]
+        let enableCompressedOutput = compression?["enabled"] as? Bool ?? false
+        let compressedFormat = (compression?["format"] as? String)?.lowercased() ?? "opus"
+        let compressedBitRate = compression?["bitrate"] as? Int ?? 24000
+        
+        // Validate compression settings if enabled
+        if enableCompressedOutput {
+            // Validate format and bitrate
+            if case .failure(let error) = CompressedRecordingInfo.validate(
+                format: compressedFormat,
+                bitrate: compressedBitRate
+            ) {
+                return .failure(error)
+            }
+        }
+        
+        // Create settings
         var settings = RecordingSettings(
             sampleRate: dict["sampleRate"] as? Double ?? 44100.0,
-            desiredSampleRate: dict["desiredSampleRate"] as? Double ?? 44100.0
+            desiredSampleRate: dict["desiredSampleRate"] as? Double ?? 44100.0,
+            enableCompressedOutput: enableCompressedOutput,
+            compressedFormat: compressedFormat,
+            compressedBitRate: compressedBitRate
         )
         
         // Parse core settings
@@ -152,6 +212,6 @@ struct RecordingSettings {
             settings.notification = notificationConfig
         }
         
-        return settings
+        return .success(settings)
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siteed/expo-audio-stream",
-  "version": "1.7.2",
+  "version": "1.8.0",
   "description": "stream audio crossplatform",
   "license": "MIT",
   "main": "build/index.js",

package/src/AudioRecorder.provider.tsx

@@ -9,6 +9,7 @@ const initContext: UseAudioRecorderState = {
     isPaused: false,
     durationMs: 0,
     size: 0,
+    compression: undefined,
     startRecording: async () => {
         throw new Error('AudioRecorderProvider not found')
     },

package/src/ExpoAudioStream.types.ts

@@ -6,6 +6,13 @@ import {
 } from './AudioAnalysis/AudioAnalysis.types'
 import { AudioAnalysisEvent } from './events'
 
+export interface CompressionInfo {
+    size: number
+    mimeType: string
+    bitrate: number
+    format: string
+}
+
 export interface AudioStreamStatus {
     isRecording: boolean
     isPaused: boolean
@@ -13,6 +20,7 @@ export interface AudioStreamStatus {
     size: number
     interval: number
     mimeType: string
+    compression?: CompressionInfo
 }
 
 export interface AudioDataEvent {
@@ -21,6 +29,9 @@ export interface AudioDataEvent {
     fileUri: string
     eventDataSize: number
     totalSize: number
+    compression?: CompressionInfo & {
+        data?: string | Blob // Base64 (native) or Float32Array (web) encoded compressed data chunk
+    }
 }
 
 export type EncodingType = 'pcm_32bit' | 'pcm_16bit' | 'pcm_8bit'
@@ -60,6 +71,9 @@ export interface AudioRecording {
     transcripts?: TranscriberData[]
     wavPCMData?: Float32Array // Full PCM data for the recording in WAV format (only on web, for native use the fileUri)
     analysisData?: AudioAnalysis // Analysis data for the recording depending on enableProcessing flag
+    compression?: CompressionInfo & {
+        compressedFileUri: string
+    }
 }
 
 export interface StartRecordingResult {
@@ -68,6 +82,9 @@ export interface StartRecordingResult {
     channels?: number
     bitDepth?: BitDepth
     sampleRate?: SampleRate
+    compression?: CompressionInfo & {
+        compressedFileUri: string
+    }
 }
 
 export interface AudioSessionConfig {
@@ -147,6 +164,12 @@ export interface RecordingConfig {
 
     // Callback function to handle audio features extraction results
     onAudioAnalysis?: (_: AudioAnalysisEvent) => Promise<void>
+
+    compression?: {
+        enabled: boolean
+        format: 'aac' | 'opus' | 'mp3'
+        bitrate?: number
+    }
 }
 
 export interface NotificationConfig {
@@ -216,14 +239,28 @@ export interface WaveformConfig {
     height?: number // Height of the waveform view in dp (default: 64)
 }
 
+export interface WebRecordingOptions {
+    /**
+     * Web-specific option to skip the final audio data consolidation process.
+     * When true, it will:
+     * - Skip the time-consuming process of concatenating all audio chunks
+     * - Return immediately with the compressed audio (if compression is enabled)
+     * - Improve performance when stopping large recordings
+     * - Useful when only the compressed audio is needed (e.g., when not using transcription)
+     * @default false
+     */
+    skipFinalConsolidation?: boolean
+}
+
 export interface UseAudioRecorderState {
     startRecording: (_: RecordingConfig) => Promise<StartRecordingResult>
-    stopRecording: () => Promise<AudioRecording | null>
+    stopRecording: (options?: WebRecordingOptions) => Promise<AudioRecording | null>
     pauseRecording: () => Promise<void>
     resumeRecording: () => Promise<void>
     isRecording: boolean
     isPaused: boolean
     durationMs: number // Duration of the recording
     size: number // Size in bytes of the recorded audio
+    compression?: CompressionInfo
     analysisData?: AudioAnalysis // Analysis data for the recording depending on enableProcessing flag
 }

package/src/ExpoAudioStream.web.ts

@@ -9,6 +9,7 @@ import {
     ConsoleLike,
     RecordingConfig,
     StartRecordingResult,
+    WebRecordingOptions,
 } from './ExpoAudioStream.types'
 import { WebRecorder } from './WebRecorder.web'
 import { AudioEventPayload } from './events'
@@ -18,6 +19,14 @@ 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
@@ -40,6 +49,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,6 +57,8 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
     audioWorkletUrl: string
     featuresExtratorUrl: string
     logger?: ConsoleLike
+    latestPosition: number = 0
+    totalCompressedSize: number = 0
 
     constructor({
         audioWorkletUrl,
@@ -76,6 +88,8 @@ 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
@@ -86,7 +100,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 +124,7 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
         const source = audioContext.createMediaStreamSource(stream)
 
         this.customRecorder = new WebRecorder({
+            logger: this.logger,
             audioContext,
             source,
             recordingConfig,
@@ -117,12 +132,14 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
             emitAudioEventCallback: ({
                 data,
                 position,
+                compression,
             }: EmitAudioEventProps) => {
                 this.audioChunks.push(new Float32Array(data))
                 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 +163,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,69 +172,118 @@ 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)
     }
 
     // Stop recording
-    async stopRecording(): Promise<AudioRecording> {
+    async stopRecording(options?: WebRecordingOptions): Promise<AudioRecording> {
         if (!this.customRecorder) {
             throw new Error('Recorder is not initialized')
         }
 
-        const fullPcmBufferArray = await this.customRecorder.stop()
+        // Create a promise to handle the PCM data processing
+        return new Promise<AudioRecording>((resolve) => {
+            // Use requestAnimationFrame to avoid blocking the UI
+            requestAnimationFrame(() => {
+                // Move the async work inside a self-executing async function
+                (async () => {
+                    const { pcmData, compressedBlob } = await this.customRecorder!.stop(options)
 
-        this.logger?.debug(`Stopped recording`, fullPcmBufferArray)
-        this.isRecording = false
-        this.isPaused = false
-        this.currentDurationMs = Date.now() - this.recordingStartTime
+                    this.logger?.debug(`Stopped recording`, pcmData)
+                    this.isRecording = false
+                    this.isPaused = false
+                    this.currentDurationMs = Date.now() - this.recordingStartTime
 
-        // 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,
-        })
+                    // Process in the next frame to avoid blocking
+                    requestAnimationFrame(() => {
+                        // Rest of the code remains the same
+                        const wavBuffer = writeWavHeader({
+                            buffer: pcmData.buffer,
+                            sampleRate: this.recordingConfig?.sampleRate ?? 44100,
+                            numChannels: this.recordingConfig?.channels ?? 1,
+                            bitDepth: this.bitDepth,
+                        })
 
-        // Create a cloneable copy
-        const cloneableBuffer = wavBuffer.slice(0)
+                        const cloneableBuffer = wavBuffer.slice(0)
 
-        // Create blob with complete WAV data
-        const blob = new Blob([cloneableBuffer], {
-            type: `audio/${this.extension}`,
-        })
-        const fileUri = URL.createObjectURL(blob)
+                        const blob = new Blob([cloneableBuffer], {
+                            type: `audio/${this.extension}`,
+                        })
+                        const fileUri = URL.createObjectURL(blob)
 
-        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}`,
-        }
+                        let compression: AudioRecording['compression']
+                        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,
+                            }
+                        }
 
-        return result
+                        resolve({
+                            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}`,
+                            compression,
+                        })
+                    })
+                })().catch((error) => {
+                    this.logger?.error('Error in stopRecording:', error)
+                    throw error
+                })
+            })
+        })
     }
 
     // Pause recording
@@ -250,10 +317,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
     }