@siteed/expo-audio-stream 1.7.2 → 1.9.0

package/build/workers/inlineAudioWebWorker.web.js.map

@@ -1 +1 @@
-{"version":3,"file":"inlineAudioWebWorker.web.js","sourceRoot":"","sources":["../../src/workers/inlineAudioWebWorker.web.tsx"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyPnC,CAAA","sourcesContent":["export const InlineAudioWebWorker = `\nconst DEFAULT_BIT_DEPTH = 32\nconst DEFAULT_SAMPLE_RATE = 44100\n\nclass RecorderProcessor extends AudioWorkletProcessor {\n    constructor() {\n        super()\n        this.recordedBuffers = [] // Float32Array\n        this.newRecBuffer = [] // Float32Array\n        this.resampledBuffer = [] // Float32Array\n        this.exportIntervalSamples = 0\n        this.samplesSinceLastExport = 0\n        this.recordSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten\n        this.exportSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten\n        this.recordBitDepth = DEFAULT_BIT_DEPTH // Default to 32-bit depth\n        this.exportBitDepth = DEFAULT_BIT_DEPTH // To be overwritten\n        this.numberOfChannels = 1 // Default to 1 channel (mono)\n        this.isRecording = true\n        this.port.onmessage = this.handleMessage.bind(this)\n    }\n\n    handleMessage(event) {\n        switch (event.data.command) {\n            case 'init':\n                this.recordSampleRate = event.data.recordSampleRate\n                this.exportSampleRate =\n                    event.data.exportSampleRate || event.data.recordSampleRate\n                this.exportIntervalSamples =\n                    this.recordSampleRate * (event.data.interval / 1000)\n                if (event.data.numberOfChannels) {\n                    this.numberOfChannels = event.data.numberOfChannels\n                }\n                if (event.data.recordBitDepth) {\n                    this.recordBitDepth = event.data.recordBitDepth\n                }\n                this.exportBitDepth =\n                    event.data.exportBitDepth ||\n                    this.recordBitDepth ||\n                    DEFAULT_BIT_DEPTH\n                break\n            case 'stop':\n                this.isRecording = false\n                this.getAllRecordedData()\n                    .then((fullRecordedData) => {\n                        this.port.postMessage({\n                            command: 'recordedData',\n                            recordedData: fullRecordedData,\n                            bitDepth: this.exportBitDepth,\n                            sampleRate: this.exportSampleRate,\n                        })\n                        return fullRecordedData\n                    })\n                    .catch((error) => {\n                        console.error(\n                            'RecorderProcessor Error extracting recorded data:',\n                            error\n                        )\n                    })\n                break\n        }\n    }\n\n    process(inputs, _outputs, _parameters) {\n        if (!this.isRecording) return true\n        const input = inputs[0]\n        if (input.length > 0) {\n            const newBuffer = new Float32Array(input[0])\n            this.newRecBuffer.push(newBuffer)\n            this.recordedBuffers.push(newBuffer)\n            this.samplesSinceLastExport += newBuffer.length\n\n            if (this.samplesSinceLastExport >= this.exportIntervalSamples) {\n                this.exportNewData()\n                this.samplesSinceLastExport = 0\n            }\n        }\n        return true\n    }\n\n    mergeBuffers(bufferArray, recLength) {\n        const result = new Float32Array(recLength)\n        let offset = 0\n        for (let i = 0; i < bufferArray.length; i++) {\n            result.set(bufferArray[i], offset)\n            offset += bufferArray[i].length\n        }\n        return result\n    }\n\n    floatTo16BitPCM(input) {\n        const output = new Int16Array(input.length)\n        for (let i = 0; i < input.length; i++) {\n            const s = Math.max(-1, Math.min(1, input[i]))\n            output[i] = s < 0 ? s * 0x8000 : s * 0x7fff\n        }\n        console.debug(\n            'RecorderProcessor Float to 16-bit PCM conversion complete. Output byte length:',\n            output.byteLength\n        )\n        return output\n    }\n\n    floatTo32BitPCM(input) {\n        const output = new Int32Array(input.length)\n        for (let i = 0; i < input.length; i++) {\n            const s = Math.max(-1, Math.min(1, input[i]))\n            output[i] = s < 0 ? s * 0x80000000 : s * 0x7fffffff\n        }\n        console.debug(\n            'RecorderProcessor Float to 32-bit PCM conversion complete. Output byte length:',\n            output.byteLength\n        )\n        return output\n    }\n\n    resample(samples, targetSampleRate) {\n        if (this.recordSampleRate === targetSampleRate) {\n            return samples\n        }\n        const resampledBuffer = new Float32Array(\n            (samples.length * targetSampleRate) / this.recordSampleRate\n        )\n        const ratio = this.recordSampleRate / targetSampleRate\n        let offset = 0\n        for (let i = 0; i < resampledBuffer.length; i++) {\n            const nextOffset = Math.floor((i + 1) * ratio)\n            let accum = 0\n            let count = 0\n            for (let j = offset; j < nextOffset && j < samples.length; j++) {\n                accum += samples[j]\n                count++\n            }\n            resampledBuffer[i] = accum / count\n            offset = nextOffset\n        }\n        return resampledBuffer\n    }\n\n    async resampleBuffer(buffer, targetSampleRate) {\n        if (typeof OfflineAudioContext === 'undefined') {\n            return this.resample(buffer, targetSampleRate)\n        }\n\n        if (this.recordSampleRate === targetSampleRate) {\n            return buffer\n        }\n        const offlineContext = new OfflineAudioContext(\n            this.numberOfChannels,\n            buffer.length,\n            this.recordSampleRate\n        )\n        const sourceBuffer = offlineContext.createBuffer(\n            this.numberOfChannels,\n            buffer.length,\n            this.recordSampleRate\n        )\n        sourceBuffer.copyToChannel(buffer, 0)\n\n        const bufferSource = offlineContext.createBufferSource()\n        bufferSource.buffer = sourceBuffer\n        bufferSource.connect(offlineContext.destination)\n        bufferSource.start()\n\n        const renderedBuffer = await offlineContext.startRendering()\n\n        const resampledBuffer = new Float32Array(renderedBuffer.length)\n        renderedBuffer.copyFromChannel(resampledBuffer, 0)\n\n        return resampledBuffer\n    }\n\n    async exportNewData() {\n        // Calculate the total length of the new recorded buffers\n        const length = this.newRecBuffer.reduce(\n            (acc, buffer) => acc + buffer.length,\n            0\n        )\n\n        // Merge all new recorded buffers into a single buffer\n        const mergedBuffer = this.mergeBuffers(this.newRecBuffer, length)\n\n        const resampledBuffer = await this.resampleBuffer(\n            mergedBuffer,\n            this.exportSampleRate\n        )\n\n        let finalBuffer = resampledBuffer // Float32Array\n        if (this.recordBitDepth !== this.exportBitDepth) {\n            if (this.exportBitDepth === 16) {\n                finalBuffer = this.floatTo16BitPCM(resampledBuffer)\n            } else if (this.exportBitDepth === 32) {\n                finalBuffer = this.floatTo32BitPCM(resampledBuffer)\n            }\n        }\n\n        const originalSize = mergedBuffer.byteLength\n        const resampledSize = resampledBuffer.byteLength\n        const finalSize = finalBuffer.byteLength\n\n        // Clear the new recorded buffers after they have been processed\n        this.newRecBuffer.length = 0\n\n        // Post the message to the main thread\n        // The first argument is the message data, containing the encoded WAV buffer\n        // The second argument is the transfer list, which transfers ownership of the ArrayBuffer\n        // to the main thread, avoiding the need to copy the buffer and improving performance\n        // this.port.postMessage({ recordedData: encodedWav.buffer, sampleRate: this.recordSampleRate }, [encodedWav.buffer]);\n        this.port.postMessage(\n            {\n                command: 'newData',\n                recordedData: finalBuffer,\n                sampleRate: this.exportSampleRate,\n                bitDepth: this.exportBitDepth,\n            },\n            []\n        )\n    }\n\n    async getAllRecordedData() {\n        const length = this.recordedBuffers.reduce(\n            (acc, buffer) => acc + buffer.length,\n            0\n        )\n        const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length)\n        const resampledBuffer = await this.resampleBuffer(\n            mergedBuffer,\n            this.exportSampleRate\n        )\n        // Convert to the desired bit depth if necessary\n        let finalBuffer = resampledBuffer\n        if (this.recordBitDepth !== this.exportBitDepth) {\n            if (this.exportBitDepth === 16) {\n                finalBuffer = this.floatTo16BitPCM(resampledBuffer)\n            } else if (this.exportBitDepth === 32) {\n                finalBuffer = this.floatTo32BitPCM(resampledBuffer)\n            }\n        }\n\n        const originalSize = mergedBuffer.byteLength\n        const resampledSize = resampledBuffer.byteLength\n        const finalSize = finalBuffer.byteLength\n\n        this.recordedBuffers.length = 0 // Clear the buffers after extraction\n\n        return finalBuffer\n    }\n}\n\nregisterProcessor('recorder-processor', RecorderProcessor)\n`\n"]}
+{"version":3,"file":"inlineAudioWebWorker.web.js","sourceRoot":"","sources":["../../src/workers/inlineAudioWebWorker.web.tsx"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0JnC,CAAA","sourcesContent":["export const InlineAudioWebWorker = `\nconst DEFAULT_BIT_DEPTH = 32\nconst DEFAULT_SAMPLE_RATE = 44100\n\nclass RecorderProcessor extends AudioWorkletProcessor {\n    constructor() {\n        super()\n        this.currentChunk = [] // Float32Array\n        this.samplesSinceLastExport = 0\n        this.recordSampleRate = DEFAULT_SAMPLE_RATE\n        this.exportSampleRate = DEFAULT_SAMPLE_RATE\n        this.recordBitDepth = DEFAULT_BIT_DEPTH\n        this.exportBitDepth = DEFAULT_BIT_DEPTH\n        this.numberOfChannels = 1\n        this.isRecording = true\n        this.port.onmessage = this.handleMessage.bind(this)\n        this.logger = undefined\n        this.exportIntervalSamples = 0\n    }\n\n    handleMessage(event) {\n        switch (event.data.command) {\n            case 'init':\n                this.logger = event.data.logger\n                this.recordSampleRate = event.data.recordSampleRate\n                this.exportSampleRate =\n                    event.data.exportSampleRate || event.data.recordSampleRate\n                this.exportIntervalSamples =\n                    this.recordSampleRate * (event.data.interval / 1000)\n                if (event.data.numberOfChannels) {\n                    this.numberOfChannels = event.data.numberOfChannels\n                }\n                if (event.data.recordBitDepth) {\n                    this.recordBitDepth = event.data.recordBitDepth\n                }\n                this.exportBitDepth =\n                    event.data.exportBitDepth || this.recordBitDepth\n                break\n\n            case 'stop':\n                this.isRecording = false\n                if (this.currentChunk.length > 0) {\n                    this.processChunk()\n                }\n                break\n        }\n    }\n\n    process(inputs, _outputs, _parameters) {\n        if (!this.isRecording) return true\n        const input = inputs[0]\n        if (input.length > 0) {\n            const newBuffer = new Float32Array(input[0])\n            this.currentChunk.push(newBuffer)\n            this.samplesSinceLastExport += newBuffer.length\n\n            if (this.samplesSinceLastExport >= this.exportIntervalSamples) {\n                this.processChunk()\n                this.samplesSinceLastExport = 0\n            }\n        }\n        return true\n    }\n\n    mergeBuffers(bufferArray, recLength) {\n        const result = new Float32Array(recLength)\n        let offset = 0\n        for (let i = 0; i < bufferArray.length; i++) {\n            result.set(bufferArray[i], offset)\n            offset += bufferArray[i].length\n        }\n        return result\n    }\n\n    // Keep basic resampling for sample rate conversion\n    resample(samples, targetSampleRate) {\n        if (this.recordSampleRate === targetSampleRate) {\n            return samples\n        }\n        const resampledBuffer = new Float32Array(\n            Math.ceil(\n                (samples.length * targetSampleRate) / this.recordSampleRate\n            )\n        )\n        const ratio = this.recordSampleRate / targetSampleRate\n        let offset = 0\n        for (let i = 0; i < resampledBuffer.length; i++) {\n            const nextOffset = Math.floor((i + 1) * ratio)\n            let accum = 0\n            let count = 0\n            for (let j = offset; j < nextOffset && j < samples.length; j++) {\n                accum += samples[j]\n                count++\n            }\n            resampledBuffer[i] = count > 0 ? accum / count : 0\n            offset = nextOffset\n        }\n        return resampledBuffer\n    }\n\n    // Keep bit depth conversion if needed\n    convertBitDepth(input, targetBitDepth) {\n        if (targetBitDepth === 32) {\n            const output = new Int32Array(input.length)\n            for (let i = 0; i < input.length; i++) {\n                const s = Math.max(-1, Math.min(1, input[i]))\n                output[i] = s < 0 ? s * 0x80000000 : s * 0x7fffffff\n            }\n            return output\n        } else if (targetBitDepth === 16) {\n            const output = new Int16Array(input.length)\n            for (let i = 0; i < input.length; i++) {\n                const s = Math.max(-1, Math.min(1, input[i]))\n                output[i] = s < 0 ? s * 0x8000 : s * 0x7fff\n            }\n            return output\n        }\n        return input\n    }\n\n    processChunk() {\n        if (this.currentChunk.length === 0) return\n\n        // Merge buffers\n        const chunkLength = this.currentChunk.reduce(\n            (acc, buf) => acc + buf.length,\n            0\n        )\n        const mergedChunk = this.mergeBuffers(this.currentChunk, chunkLength)\n\n        // Resample if needed\n        const resampledChunk = this.resample(mergedChunk, this.exportSampleRate)\n\n        // Convert bit depth if needed\n        const finalBuffer =\n            this.recordBitDepth !== this.exportBitDepth\n                ? this.convertBitDepth(resampledChunk, this.exportBitDepth)\n                : resampledChunk\n\n        // Send processed chunk\n        this.port.postMessage({\n            command: 'newData',\n            recordedData: finalBuffer,\n            sampleRate: this.exportSampleRate,\n            bitDepth: this.exportBitDepth,\n            numberOfChannels: this.numberOfChannels,\n        })\n\n        // Clear the current chunk\n        this.currentChunk = []\n    }\n}\n\nregisterProcessor('recorder-processor', RecorderProcessor)\n`\n"]}

package/ios/AudioStreamManager.swift

@@ -46,6 +46,7 @@ class AudioStreamManager: NSObject {
 
     internal var lastEmissionTime: Date?
     internal var lastEmittedSize: Int64 = 0
+    internal var lastEmittedCompressedSize: Int64 = 0
     private var emissionInterval: TimeInterval = 1.0 // Default to 1 second
     private var totalDataSize: Int64 = 0
     private var fileManager = FileManager.default
@@ -68,6 +69,11 @@ class AudioStreamManager: NSObject {
         
     private var lastValidDuration: TimeInterval?  // Add this property
     
+    private var compressedRecorder: AVAudioRecorder?
+    private var compressedFileURL: URL?
+    private var compressedFormat: String = "aac"
+    private var compressedBitRate: Int = 128000
+    
     /// Initializes the AudioStreamManager
     override init() {
         super.init()
@@ -394,8 +400,8 @@ class AudioStreamManager: NSObject {
         
         let durationInSeconds = currentRecordingDuration()
         let durationInMilliseconds = Int(durationInSeconds * 1000)
-
-        return [
+        
+        var status: [String: Any] = [
             "durationMs": durationInMilliseconds,
             "isRecording": isRecording,
             "isPaused": isPaused,
@@ -403,6 +409,27 @@ class AudioStreamManager: NSObject {
             "size": totalDataSize,
             "interval": emissionInterval
         ]
+        
+        // Add compression info if enabled
+        if settings.enableCompressedOutput, let compressedURL = compressedFileURL {
+            do {
+                let compressedAttributes = try FileManager.default.attributesOfItem(atPath: compressedURL.path)
+                if let compressedSize = compressedAttributes[.size] as? Int64 {
+                    let compressionBundle: [String: Any] = [
+                        "fileUri": compressedURL.absoluteString,
+                        "mimeType": compressedFormat == "aac" ? "audio/aac" : "audio/opus",
+                        "size": compressedSize,
+                        "format": compressedFormat,
+                        "bitrate": compressedBitRate
+                    ]
+                    status["compression"] = compressionBundle
+                }
+            } catch {
+                Logger.debug("Error getting compressed file attributes: \(error)")
+            }
+        }
+        
+        return status
     }
     
     /// Starts a new audio recording with the specified settings and interval.
@@ -521,6 +548,28 @@ class AudioStreamManager: NSObject {
                 self.lastBufferTime = time
             }
             
+            // Setup compressed recording if enabled
+            if settings.enableCompressedOutput {
+                let compressedSettings: [String: Any] = [
+                    AVFormatIDKey: settings.compressedFormat == "aac" ? kAudioFormatMPEG4AAC : kAudioFormatOpus,
+                    AVSampleRateKey: settings.sampleRate,
+                    AVNumberOfChannelsKey: settings.numberOfChannels,
+                    AVEncoderBitRateKey: settings.compressedBitRate,
+                    AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
+                ]
+                
+                compressedFileURL = FileManager.default.temporaryDirectory
+                    .appendingPathComponent(UUID().uuidString)
+                    .appendingPathExtension(settings.compressedFormat)
+                    
+                if let url = compressedFileURL {
+                    compressedRecorder = try AVAudioRecorder(url: url, settings: compressedSettings)
+                    compressedRecorder?.record()
+                    compressedFormat = settings.compressedFormat
+                    compressedBitRate = settings.compressedBitRate
+                }
+            }
+            
         } catch {
             Logger.debug("Error: Failed to set up audio session with preferred settings: \(error.localizedDescription)")
             return nil
@@ -574,13 +623,21 @@ class AudioStreamManager: NSObject {
             isRecording = true
             isPaused = false
             Logger.debug("Debug: Recording started successfully.")
+            
             return StartRecordingResult(
                 fileUri: recordingFileURL!.path,
                 mimeType: mimeType,
-                channels: newSettings.numberOfChannels,
-                bitDepth: newSettings.bitDepth,
-                sampleRate: newSettings.sampleRate
+                channels: settings.numberOfChannels,
+                bitDepth: settings.bitDepth,
+                sampleRate: settings.sampleRate,
+                compression: settings.enableCompressedOutput && compressedFileURL != nil ? CompressedRecordingInfo(
+                    fileUri: compressedFileURL!.absoluteString,
+                    mimeType: compressedFormat == "aac" ? "audio/aac" : "audio/opus",
+                    bitrate: compressedBitRate,
+                    format: compressedFormat
+                ) : nil
             )
+            
         } catch {
             Logger.debug("Error: Could not start the audio engine: \(error.localizedDescription)")
             isRecording = false
@@ -604,6 +661,9 @@ class AudioStreamManager: NSObject {
         notificationManager?.updateState(isPaused: true)
         delegate?.audioStreamManager(self, didPauseRecording: Date())
         delegate?.audioStreamManager(self, didUpdateNotificationState: true)
+        
+        // Pause compressed recording if active
+        compressedRecorder?.pause()
     }
     
     private func initializeNotifications() {
@@ -684,6 +744,10 @@ class AudioStreamManager: NSObject {
             notificationManager?.updateState(isPaused: false)
             delegate?.audioStreamManager(self, didResumeRecording: Date())
             delegate?.audioStreamManager(self, didUpdateNotificationState: false)
+            
+            // Resume compressed recording if active
+            compressedRecorder?.record()
+            
         } catch {
             Logger.debug("Error: Failed to resume recording: \(error.localizedDescription)")
         }
@@ -720,10 +784,15 @@ class AudioStreamManager: NSObject {
     /// Stops the current audio recording.
     /// - Returns: A RecordingResult object if the recording stopped successfully, or nil otherwise.
     func stopRecording() -> RecordingResult? {
+        guard isRecording else { return nil }
+        
         disableWakeLock()
         audioEngine.stop()
         audioEngine.inputNode.removeTap(onBus: 0)
         
+        // Stop compressed recording if active
+        compressedRecorder?.stop()
+        
         // Get the final duration before changing state
         let finalDuration = currentRecordingDuration()
         
@@ -783,13 +852,24 @@ class AudioStreamManager: NSObject {
                 size: fileSize,
                 channels: settings.numberOfChannels,
                 bitDepth: settings.bitDepth,
-                sampleRate: settings.sampleRate
+                sampleRate: settings.sampleRate,
+                compression: settings.enableCompressedOutput && compressedFileURL != nil ? CompressedRecordingInfo(
+                    fileUri: compressedFileURL!.absoluteString,
+                    mimeType: compressedFormat == "aac" ? "audio/aac" : "audio/opus",
+                    bitrate: compressedBitRate,
+                    format: compressedFormat
+                ) : nil
             )
+            
+            // Cleanup
             recordingFileURL = nil
             lastBufferTime = nil
             lastValidDuration = nil
+            compressedRecorder = nil
+            compressedFileURL = nil
             
             return result
+            
         } catch {
             Logger.debug("Failed to fetch file attributes: \(error)")
             return nil
@@ -1108,8 +1188,47 @@ class AudioStreamManager: NSObject {
             let recordingTime = currentTime.timeIntervalSince(startTime)
             let dataToProcess = accumulatedData
             
-            // Emit the audio data
-            delegate?.audioStreamManager(self, didReceiveAudioData: dataToProcess, recordingTime: recordingTime, totalDataSize: totalDataSize)
+            // Prepare compression info if enabled
+            var compressionInfo: [String: Any]? = nil
+            if settings.enableCompressedOutput, let compressedURL = compressedFileURL {
+                do {
+                    let compressedAttributes = try FileManager.default.attributesOfItem(atPath: compressedURL.path)
+                    if let compressedSize = compressedAttributes[.size] as? Int64 {
+                        let eventDataSize = compressedSize - lastEmittedCompressedSize
+                        
+                        // Read the new compressed data if there's new data
+                        var compressedData: String? = nil
+                        if eventDataSize > 0 {
+                            let fileHandle = try FileHandle(forReadingFrom: compressedURL)
+                            fileHandle.seek(toFileOffset: UInt64(lastEmittedCompressedSize))
+                            let data = fileHandle.readData(ofLength: Int(eventDataSize))
+                            compressedData = data.base64EncodedString()
+                            fileHandle.closeFile()
+                        }
+                        
+                        lastEmittedCompressedSize = compressedSize
+                        
+                        compressionInfo = [
+                            "position": recordingTime * 1000, // Convert to milliseconds
+                            "fileUri": compressedURL.absoluteString,
+                            "eventDataSize": eventDataSize,
+                            "totalSize": compressedSize,
+                            "data": compressedData ?? ""
+                        ]
+                    }
+                } catch {
+                    Logger.debug("Failed to read compressed data: \(error)")
+                }
+            }
+            
+            // Emit the audio data with compression info
+            delegate?.audioStreamManager(
+                self,
+                didReceiveAudioData: dataToProcess,
+                recordingTime: recordingTime,
+                totalDataSize: totalDataSize,
+                compressionInfo: compressionInfo
+            )
             
             // Process audio if enabled
             if settings.enableProcessing {

package/ios/AudioStreamManagerDelegate.swift

@@ -1,7 +1,13 @@
 protocol AudioStreamManagerDelegate: AnyObject {
-    func audioStreamManager(_ manager: AudioStreamManager, didReceiveAudioData data: Data, recordingTime: TimeInterval, totalDataSize: Int64)
-    func audioStreamManager(_ manager: AudioStreamManager, didReceiveProcessingResult result: AudioAnalysisData?)
+    func audioStreamManager(
+        _ manager: AudioStreamManager,
+        didReceiveAudioData data: Data,
+        recordingTime: TimeInterval,
+        totalDataSize: Int64,
+        compressionInfo: [String: Any]?
+    )
     
+    func audioStreamManager(_ manager: AudioStreamManager, didReceiveProcessingResult result: AudioAnalysisData?)
     func audioStreamManager(_ manager: AudioStreamManager, didPauseRecording pauseTime: Date)
     func audioStreamManager(_ manager: AudioStreamManager, didResumeRecording resumeTime: Date)
     func audioStreamManager(_ manager: AudioStreamManager, didUpdateNotificationState isPaused: Bool)

package/ios/ExpoAudioStreamModule.swift

@@ -124,6 +124,10 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
         ///     - `algorithm`: The algorithm to use for extraction (default is "rms").
         ///     - `featureOptions`: A dictionary of feature options to extract (default is empty).
         ///     - `maxRecentDataDuration`: The maximum duration of recent data to keep for processing (default is 10.0 seconds).
+        ///     - `compression`: A dictionary containing:
+        ///       - `enabled`: Boolean to enable/disable compression (default is false).
+        ///       - `format`: The compression format (default is "aac").
+        ///       - `bitrate`: The compression bitrate in bps (default is 128000).
         ///   - promise: A promise to resolve with the recording settings or reject with an error.
         AsyncFunction("startRecording") { (options: [String: Any], promise: Promise) in
             self.checkMicrophonePermission { granted in
@@ -132,30 +136,48 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
                     return
                 }
                 
-                let settings = RecordingSettings.fromDictionary(options)
+                // Create settings with validation
+                let settingsResult = RecordingSettings.fromDictionary(options)
                 
-                // Initialize notification if enabled
-                if settings.showNotification {
-                    Task {
-                        let notificationGranted = await self.requestNotificationPermissions()
-                        if !notificationGranted {
-                            Logger.debug("Notification permissions not granted")
+                switch settingsResult {
+                case .success(let settings):
+                    // Initialize notification if enabled
+                    if settings.showNotification {
+                        Task {
+                            let notificationGranted = await self.requestNotificationPermissions()
+                            if !notificationGranted {
+                                Logger.debug("Notification permissions not granted")
+                            }
                         }
                     }
+                    
+                    if let result = self.streamManager.startRecording(settings: settings, intervalMilliseconds: settings.interval ?? 1000) {
+                        var resultDict: [String: Any] = [
+                            "fileUri": result.fileUri,
+                            "channels": result.channels,
+                            "bitDepth": result.bitDepth,
+                            "sampleRate": result.sampleRate,
+                            "mimeType": result.mimeType,
+                        ]
+                        
+                        // Add compression info if available
+                        if let compression = result.compression {
+                            resultDict["compression"] = [
+                                "fileUri": compression.fileUri,
+                                "mimeType": compression.mimeType,
+                                "bitrate": compression.bitrate,
+                                "format": compression.format
+                            ]
+                        }
+                        
+                        promise.resolve(resultDict)
+                    } else {
+                        promise.reject("ERROR", "Failed to start recording.")
+                    }
+                    
+                case .failure(let error):
+                    promise.reject("INVALID_SETTINGS", error.localizedDescription)
                 }
-                
-                if let result = self.streamManager.startRecording(settings: settings, intervalMilliseconds: settings.interval ?? 1000) {
-                      let resultDict: [String: Any] = [
-                          "fileUri": result.fileUri,
-                          "channels": result.channels,
-                          "bitDepth": result.bitDepth,
-                          "sampleRate": result.sampleRate,
-                          "mimeType": result.mimeType,
-                      ]
-                      promise.resolve(resultDict)
-                  } else {
-                      promise.reject("ERROR", "Failed to start recording.")
-                  }
             }
         }
         
@@ -303,36 +325,29 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
     ///   - data: The received audio data.
     ///   - recordingTime: The current recording time.
     ///   - totalDataSize: The total size of the received audio data.
-    func audioStreamManager(_ manager: AudioStreamManager, didReceiveAudioData data: Data, recordingTime: TimeInterval, totalDataSize: Int64) {
-        guard let fileURL = manager.recordingFileURL,
-              let settings = manager.recordingSettings else { return }
-        
-        let encodedData = data.base64EncodedString()
-        
-        // Assuming `lastEmittedSize` and `streamUuid` are tracked within `AudioStreamManager`
-        let deltaSize = data.count  // This needs to be calculated based on what was last sent if using chunks
-        let fileSize = totalDataSize  // Total data size in bytes
-        
-        // Calculate the position in milliseconds using the lastEmittedSize
-        let sampleRate = settings.sampleRate
-        let channels = Double(settings.numberOfChannels)
-        let bitDepth = Double(settings.bitDepth)
-        let position = Int(manager.currentRecordingDuration() * 1000)
-        
-        // Construct the event payload similar to Android
-        let eventBody: [String: Any] = [
-            "fileUri": fileURL.absoluteString,
-            "lastEmittedSize": manager.lastEmittedSize,  // Needs to be maintained within AudioStreamManager
-            "position": position, // time in ms based on pause-aware duration
-            "encoded": encodedData,
-            "deltaSize": deltaSize,
-            "totalSize": fileSize,
+    func audioStreamManager(
+        _ manager: AudioStreamManager,
+        didReceiveAudioData data: Data,
+        recordingTime: TimeInterval,
+        totalDataSize: Int64,
+        compressionInfo: [String: Any]?
+    ) {
+        var resultDict: [String: Any] = [
+            "fileUri": manager.recordingFileURL?.absoluteString ?? "",
+            "lastEmittedSize": totalDataSize,
+            "encoded": data.base64EncodedString(),
+            "deltaSize": data.count,
+            "position": Int64(recordingTime * 1000),
             "mimeType": manager.mimeType,
+            "totalSize": totalDataSize,
             "streamUuid": manager.recordingUUID?.uuidString ?? UUID().uuidString
         ]
         
-        // Emit the event to JavaScript
-        sendEvent(audioDataEvent, eventBody)
+        if let compressionInfo = compressionInfo {
+            resultDict["compression"] = compressionInfo
+        }
+        
+        sendEvent(audioDataEvent, resultDict)
     }
     
     private func requestNotificationPermissions() async -> Bool {

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.9.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'
@@ -58,8 +69,10 @@ export interface AudioRecording {
     bitDepth: BitDepth
     sampleRate: SampleRate
     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 +81,9 @@ export interface StartRecordingResult {
     channels?: number
     bitDepth?: BitDepth
     sampleRate?: SampleRate
+    compression?: CompressionInfo & {
+        compressedFileUri: string
+    }
 }
 
 export interface AudioSessionConfig {
@@ -147,6 +163,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 {
@@ -225,5 +247,6 @@ export interface UseAudioRecorderState {
     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
 }