@siteed/expo-audio-studio 2.8.6 → 2.10.0

package/src/ExpoAudioStream.web.ts

@@ -285,13 +285,15 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
             bitDepth: this.bitDepth,
             channels: recordingConfig.channels ?? 1,
             sampleRate: recordingConfig.sampleRate ?? 44100,
-            compression: recordingConfig.compression
+            compression: recordingConfig.output?.compressed?.enabled
                 ? {
-                      ...recordingConfig.compression,
-                      bitrate: recordingConfig.compression?.bitrate ?? 128000,
+                      ...recordingConfig.output.compressed,
+                      bitrate:
+                          recordingConfig.output.compressed.bitrate ?? 128000,
                       size: 0,
                       mimeType: 'audio/webm',
-                      format: recordingConfig.compression?.format ?? 'opus',
+                      format:
+                          recordingConfig.output.compressed.format ?? 'opus',
                       compressedFileUri: '',
                   }
                 : undefined,
@@ -459,56 +461,56 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
             let fileUri = `${this.streamUuid}.${this.extension}`
             let mimeType = `audio/${this.extension}`
 
-            // Handle both compressed and uncompressed blobs according to configuration
-            const compressionEnabled =
-                this.recordingConfig?.compression?.enabled ?? false
+            // Handle both compressed and uncompressed blobs according to new output configuration
+            const primaryEnabled =
+                this.recordingConfig?.output?.primary?.enabled ?? true
+            const compressedEnabled =
+                this.recordingConfig?.output?.compressed?.enabled ?? false
 
-            // Process compressed blob if available
-            if (compressedBlob) {
+            // Process compressed blob if available and enabled
+            if (compressedBlob && compressedEnabled) {
                 const compressedUri = URL.createObjectURL(compressedBlob)
                 const compressedInfo = {
                     compressedFileUri: compressedUri,
                     size: compressedBlob.size,
                     mimeType: 'audio/webm',
-                    format: 'opus',
+                    format:
+                        this.recordingConfig?.output?.compressed?.format ??
+                        'opus',
                     bitrate:
-                        this.recordingConfig?.compression?.bitrate ?? 128000,
+                        this.recordingConfig?.output?.compressed?.bitrate ??
+                        128000,
                 }
 
-                // If compression is enabled, use compressed blob as primary format
-                if (compressionEnabled) {
+                // Store compression info
+                compression = compressedInfo
+
+                // If primary is disabled, use compressed as main file
+                if (!primaryEnabled) {
                     this.logger?.debug(
-                        'Using compressed audio as primary output'
+                        'Using compressed audio as primary output (primary disabled)'
                     )
                     fileUri = compressedUri
                     mimeType = 'audio/webm'
-
-                    // Store compression info
-                    compression = compressedInfo
-                } else {
-                    // Compression was enabled during recording but not set as primary
-                    // Store as alternate format
-                    compression = compressedInfo
                 }
             }
 
-            // Process uncompressed WAV if available
-            if (uncompressedBlob) {
+            // Process uncompressed WAV if available and primary is enabled
+            if (uncompressedBlob && primaryEnabled) {
                 const wavUri = URL.createObjectURL(uncompressedBlob)
-
-                // If compression is disabled or no compressed blob is available,
-                // use WAV as primary format
-                if (!compressionEnabled || !compressedBlob) {
-                    this.logger?.debug(
-                        'Using uncompressed WAV as primary output'
-                    )
-                    fileUri = wavUri
-                    mimeType = 'audio/wav'
-                }
+                fileUri = wavUri
+                mimeType = 'audio/wav'
+            } else if (!primaryEnabled && !compressedEnabled) {
+                // No outputs enabled - streaming only mode
+                this.logger?.debug('No outputs enabled - streaming only mode')
+                fileUri = ''
+                mimeType = 'audio/wav'
             }
 
             // Use the stored streamUuid for the final filename
-            const filename = `${this.streamUuid}.${this.extension}`
+            const filename = fileUri
+                ? `${this.streamUuid}.${this.extension}`
+                : 'stream-only'
             const result: AudioRecording = {
                 fileUri,
                 filename,
@@ -517,7 +519,7 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
                 channels: this.recordingConfig?.channels ?? 1,
                 sampleRate: this.recordingConfig?.sampleRate ?? 44100,
                 durationMs: this.currentDurationMs,
-                size: this.currentSize,
+                size: primaryEnabled ? this.currentSize : 0,
                 mimeType,
                 compression,
             }
@@ -630,13 +632,16 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
             interval: this.currentInterval,
             intervalAnalysis: this.currentIntervalAnalysis,
             mimeType: `audio/${this.extension}`,
-            compression: this.recordingConfig?.compression?.enabled
+            compression: this.recordingConfig?.output?.compressed?.enabled
                 ? {
                       size: this.totalCompressedSize,
                       mimeType: 'audio/webm',
-                      format: this.recordingConfig.compression.format ?? 'opus',
+                      format:
+                          this.recordingConfig.output.compressed.format ??
+                          'opus',
                       bitrate:
-                          this.recordingConfig.compression.bitrate ?? 128000,
+                          this.recordingConfig.output.compressed.bitrate ??
+                          128000,
                       compressedFileUri: `${this.streamUuid}.webm`,
                   }
                 : undefined,
@@ -850,7 +855,8 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
                     }
                 } catch (err) {
                     this.logger?.warn(
-                        'Error determining current device, using default'
+                        'Error determining current device, using default',
+                        err
                     )
                 }
             }

package/src/WebRecorder.web.ts

@@ -48,15 +48,15 @@ export class WebRecorder {
     private bitDepth: number // Bit depth of the audio
     private exportBitDepth: number // Bit depth of the audio
     private audioAnalysisData: AudioAnalysis // Keep updating the full audio analysis data with latest events
-    private logger?: ConsoleLike
+    private readonly logger?: ConsoleLike
     private compressedMediaRecorder: MediaRecorder | null = null
     private compressedChunks: Blob[] = []
     private compressedSize: number = 0
     private pendingCompressedChunk: Blob | null = null
     private dataPointIdCounter: number = 0 // Add this property to track the counter
     private deviceDisconnectionHandler: (() => void) | null = null
-    private mediaStream: MediaStream | null = null
-    private onInterruptionCallback?: (event: {
+    private readonly mediaStream: MediaStream | null = null
+    private readonly onInterruptionCallback?: (event: {
         reason: string
         isPaused: boolean
         timestamp: number
@@ -154,7 +154,7 @@ export class WebRecorder {
         }
 
         // Initialize compressed recording if enabled
-        if (recordingConfig.compression?.enabled) {
+        if (recordingConfig.output?.compressed?.enabled) {
             this.initializeCompressedRecorder()
         }
 
@@ -214,6 +214,11 @@ export class WebRecorder {
                         ? event.data.position
                         : this.position
 
+                // Simple position tracking for logging (no duplicate filtering)
+                this.logger?.debug(
+                    `Audio chunk: position=${incomingPosition.toFixed(3)}s, size=${pcmBufferFloat.length}`
+                )
+
                 // Calculate bytes per sample based on bit depth
                 const bytesPerSample = this.bitDepth / 8
 
@@ -229,6 +234,17 @@ export class WebRecorder {
                     )
                     const samples = chunk.length // Number of samples in this chunk
 
+                    // Only store PCM data if primary output is enabled
+                    const shouldStoreUncompressed =
+                        this.config.output?.primary?.enabled ?? true
+
+                    // Store PCM chunks when needed - this is for the final WAV file
+                    if (shouldStoreUncompressed) {
+                        // Store the original Float32Array data for later WAV creation
+                        this.appendPcmData(chunk)
+                        this.totalSampleCount += chunk.length
+                    }
+
                     // Process features if enabled
                     if (
                         this.config.enableProcessing &&
@@ -252,39 +268,35 @@ export class WebRecorder {
                         })
                     }
 
-                    // Only store PCM data if web.storeUncompressedAudio is not explicitly false
-                    const shouldStoreUncompressed =
-                        this.config.web?.storeUncompressedAudio !== false
-
-                    // Store PCM chunks when needed
-                    if (shouldStoreUncompressed) {
-                        // Store the original Float32Array data for later WAV creation
-                        this.appendPcmData(chunk)
-                        this.totalSampleCount += chunk.length
-                    }
-
-                    // Emit chunk immediately
+                    // Prepare compression data if available
+                    const compression = this.pendingCompressedChunk
+                        ? {
+                              data: this.pendingCompressedChunk,
+                              size: this.pendingCompressedChunk.size,
+                              totalSize: this.compressedSize,
+                              mimeType: 'audio/webm',
+                              format:
+                                  this.config.output?.compressed?.format ??
+                                  'opus',
+                              bitrate:
+                                  this.config.output?.compressed?.bitrate ??
+                                  128000,
+                          }
+                        : undefined
+
+                    // Emit chunk immediately - whether compressed or not
                     this.emitAudioEventCallback({
                         data: chunk,
                         position: chunkPosition,
-                        compression: this.pendingCompressedChunk
-                            ? {
-                                  data: this.pendingCompressedChunk,
-                                  size: this.pendingCompressedChunk.size,
-                                  totalSize: this.compressedSize,
-                                  mimeType: 'audio/webm',
-                                  format: 'opus',
-                                  bitrate:
-                                      this.config.compression?.bitrate ??
-                                      128000,
-                              }
-                            : undefined,
+                        compression,
                     })
+
+                    // Reset pending compressed chunk after we've used it
+                    this.pendingCompressedChunk = null
                 }
 
                 // Update our position based on the worklet's position if provided
                 this.position = incomingPosition + duration
-                this.pendingCompressedChunk = null
             }
 
             // Ensure we use all relevant settings from config
@@ -302,12 +314,12 @@ export class WebRecorder {
                 channels,
                 interval,
                 position: this.position,
-                deviceId: this.config.deviceId || 'default',
-                compression: this.config.compression
+                deviceId: this.config.deviceId ?? 'default',
+                compression: this.config.output?.compressed
                     ? {
-                          enabled: this.config.compression.enabled,
-                          format: this.config.compression.format,
-                          bitrate: this.config.compression.bitrate,
+                          enabled: this.config.output.compressed.enabled,
+                          format: this.config.output.compressed.format,
+                          bitrate: this.config.output.compressed.bitrate,
                       }
                     : 'disabled',
             })
@@ -407,100 +419,109 @@ export class WebRecorder {
      * @param event - The event containing audio analysis results
      */
     handleFeatureExtractorMessage(event: AudioFeaturesEvent) {
-        if (event.data.command === 'features') {
-            const segmentResult = event.data.result
+        if (event.data.command !== 'features') return
 
-            // Track existing IDs to prevent duplicates
-            const existingIds = new Set(
-                this.audioAnalysisData.dataPoints.map((dp) => dp.id)
-            )
+        const segmentResult = event.data.result
+        const uniqueNewDataPoints = this.filterUniqueDataPoints(
+            segmentResult.dataPoints
+        )
 
-            // Filter out datapoints with duplicate IDs
-            const uniqueNewDataPoints = segmentResult.dataPoints.filter(
-                (dp) => {
-                    return !existingIds.has(dp.id)
-                }
-            )
+        // Update counter based on the highest ID seen
+        this.updateDataPointCounter(uniqueNewDataPoints)
 
-            // Log filtered duplicates if any
-            if (
-                uniqueNewDataPoints.length < segmentResult.dataPoints.length &&
-                this.logger?.warn
-            ) {
-                this.logger.warn(
-                    `Filtered ${segmentResult.dataPoints.length - uniqueNewDataPoints.length} duplicate datapoints`
-                )
-            }
+        // Update analysis data with the new results
+        this.updateAudioAnalysisData(segmentResult, uniqueNewDataPoints)
 
-            // Update counter based on the highest ID seen
-            if (uniqueNewDataPoints.length > 0) {
-                const lastDataPoint =
-                    uniqueNewDataPoints[uniqueNewDataPoints.length - 1]
+        // Send filtered result to avoid duplicate IDs
+        const filteredSegmentResult = {
+            ...segmentResult,
+            dataPoints: uniqueNewDataPoints,
+        }
 
-                if (lastDataPoint && typeof lastDataPoint.id === 'number') {
-                    const nextIdValue = lastDataPoint.id + 1
+        this.emitAudioAnalysisCallback(filteredSegmentResult)
+    }
 
-                    if (nextIdValue > this.dataPointIdCounter) {
-                        this.dataPointIdCounter = nextIdValue
-                        this.logger?.debug(
-                            `Counter updated to ${this.dataPointIdCounter}`
-                        )
-                    }
-                }
-            }
+    /**
+     * Filters out data points with duplicate IDs
+     */
+    private filterUniqueDataPoints(dataPoints: any[]): any[] {
+        // Track existing IDs to prevent duplicates
+        const existingIds = new Set(
+            this.audioAnalysisData.dataPoints.map((dp) => dp.id)
+        )
 
-            // Add unique data points to our analysis data
-            this.audioAnalysisData.dataPoints.push(...uniqueNewDataPoints)
-            this.audioAnalysisData.durationMs += segmentResult.durationMs
-            this.audioAnalysisData.sampleRate = segmentResult.sampleRate
+        // Filter out datapoints with duplicate IDs
+        const uniquePoints = dataPoints.filter((dp) => !existingIds.has(dp.id))
 
-            // Merge amplitude ranges
-            if (segmentResult.amplitudeRange) {
-                if (!this.audioAnalysisData.amplitudeRange) {
-                    this.audioAnalysisData.amplitudeRange = {
-                        ...segmentResult.amplitudeRange,
-                    }
-                } else {
-                    this.audioAnalysisData.amplitudeRange = {
-                        min: Math.min(
-                            this.audioAnalysisData.amplitudeRange.min,
-                            segmentResult.amplitudeRange.min
-                        ),
-                        max: Math.max(
-                            this.audioAnalysisData.amplitudeRange.max,
-                            segmentResult.amplitudeRange.max
-                        ),
-                    }
-                }
-            }
+        // Log filtered duplicates if any
+        if (uniquePoints.length < dataPoints.length && this.logger?.warn) {
+            this.logger.warn(
+                `Filtered ${dataPoints.length - uniquePoints.length} duplicate datapoints`
+            )
+        }
 
-            // Merge RMS ranges
-            if (segmentResult.rmsRange) {
-                if (!this.audioAnalysisData.rmsRange) {
-                    this.audioAnalysisData.rmsRange = {
-                        ...segmentResult.rmsRange,
-                    }
-                } else {
-                    this.audioAnalysisData.rmsRange = {
-                        min: Math.min(
-                            this.audioAnalysisData.rmsRange.min,
-                            segmentResult.rmsRange.min
-                        ),
-                        max: Math.max(
-                            this.audioAnalysisData.rmsRange.max,
-                            segmentResult.rmsRange.max
-                        ),
-                    }
-                }
-            }
+        return uniquePoints
+    }
 
-            // Send filtered result to avoid duplicate IDs
-            const filteredSegmentResult = {
-                ...segmentResult,
-                dataPoints: uniqueNewDataPoints,
+    /**
+     * Updates the counter based on the highest ID in datapoints
+     */
+    private updateDataPointCounter(dataPoints: any[]): void {
+        if (dataPoints.length === 0) return
+
+        const lastDataPoint = dataPoints[dataPoints.length - 1]
+        if (lastDataPoint && typeof lastDataPoint.id === 'number') {
+            const nextIdValue = lastDataPoint.id + 1
+            if (nextIdValue > this.dataPointIdCounter) {
+                this.dataPointIdCounter = nextIdValue
+                this.logger?.debug(
+                    `Counter updated to ${this.dataPointIdCounter}`
+                )
             }
+        }
+    }
 
-            this.emitAudioAnalysisCallback(filteredSegmentResult)
+    /**
+     * Updates audio analysis data with segment results
+     */
+    private updateAudioAnalysisData(
+        segmentResult: AudioAnalysis,
+        uniqueDataPoints: any[]
+    ): void {
+        // Add unique data points to our analysis data
+        this.audioAnalysisData.dataPoints.push(...uniqueDataPoints)
+        this.audioAnalysisData.durationMs += segmentResult.durationMs
+        this.audioAnalysisData.sampleRate = segmentResult.sampleRate
+
+        // Update amplitude range if present
+        if (segmentResult.amplitudeRange) {
+            this.audioAnalysisData.amplitudeRange = this.mergeRange(
+                this.audioAnalysisData.amplitudeRange,
+                segmentResult.amplitudeRange
+            )
+        }
+
+        // Update RMS range if present
+        if (segmentResult.rmsRange) {
+            this.audioAnalysisData.rmsRange = this.mergeRange(
+                this.audioAnalysisData.rmsRange,
+                segmentResult.rmsRange
+            )
+        }
+    }
+
+    /**
+     * Merges value ranges
+     */
+    private mergeRange(
+        existing: { min: number; max: number } | undefined,
+        newRange: { min: number; max: number }
+    ): { min: number; max: number } {
+        if (!existing) return { ...newRange }
+
+        return {
+            min: Math.min(existing.min, newRange.min),
+            max: Math.max(existing.max, newRange.max),
         }
     }
 
@@ -510,8 +531,7 @@ export class WebRecorder {
      */
     resetDataPointCounter(startCounterFrom?: number): void {
         // Set the counter with the passed value or 0
-        this.dataPointIdCounter =
-            startCounterFrom !== undefined ? startCounterFrom : 0
+        this.dataPointIdCounter = startCounterFrom ?? 0
         this.logger?.debug(
             `Reset data point counter to ${this.dataPointIdCounter}`
         )
@@ -591,7 +611,7 @@ export class WebRecorder {
             }
 
             const sampleRate =
-                this.config.sampleRate || this.audioContext.sampleRate
+                this.config.sampleRate ?? this.audioContext.sampleRate
             const channels = this.numberOfChannels || 1
 
             // Convert float32 PCM data to 16-bit PCM for WAV
@@ -648,8 +668,7 @@ export class WebRecorder {
 
             // Only create WAV if we have PCM data
             if (this.pcmData && this.pcmData.length > 0) {
-                uncompressedBlob =
-                    (await this.createWavFromPcmData()) || undefined
+                uncompressedBlob = this.createWavFromPcmData() || undefined
             }
 
             // Return the compressed and/or uncompressed blobs if available
@@ -670,6 +689,7 @@ export class WebRecorder {
             this.pendingCompressedChunk = null
             this.pcmData = null
             this.totalSampleCount = 0
+            this.dataPointIdCounter = 0 // Reset counter
         }
     }
 
@@ -686,11 +706,10 @@ export class WebRecorder {
 
         // Check if AudioContext is already closed before attempting to close it
         if (this.audioContext && this.audioContext.state !== 'closed') {
-            try {
-                this.audioContext.close()
-            } catch (e) {
-                // Ignore closure errors - this happens if already closed
-            }
+            this.audioContext.close().catch((e) => {
+                // Log closure errors but continue cleanup
+                this.logger?.warn('Error closing AudioContext:', e)
+            })
         }
 
         // Safely disconnect audioWorkletNode if it exists
@@ -698,7 +717,8 @@ export class WebRecorder {
             try {
                 this.audioWorkletNode.disconnect()
             } catch (e) {
-                // Ignore disconnection errors - node might be already disconnected
+                // Log disconnection errors but continue cleanup
+                this.logger?.warn('Error disconnecting audioWorkletNode:', e)
             }
         }
 
@@ -707,7 +727,8 @@ export class WebRecorder {
             try {
                 this.source.disconnect()
             } catch (e) {
-                // Ignore disconnection errors - source might be already disconnected
+                // Log disconnection errors but continue cleanup
+                this.logger?.warn('Error disconnecting source:', e)
             }
         }
 
@@ -797,8 +818,12 @@ export class WebRecorder {
             this.audioWorkletNode.connect(this.audioContext.destination)
             this.audioWorkletNode.port.postMessage({ command: 'resume' })
             this.compressedMediaRecorder?.resume()
-        } catch (error) {
+        } catch (error: unknown) {
             this.logger?.error('Error in resume(): ', error)
+            // Rethrow the error to inform callers
+            throw new Error(
+                `Failed to resume recording: ${error instanceof Error ? error.message : 'unknown error'}`
+            )
         }
     }
 
@@ -821,14 +846,17 @@ export class WebRecorder {
                 {
                     mimeType,
                     audioBitsPerSecond:
-                        this.config.compression?.bitrate ?? 128000,
+                        this.config.output?.compressed?.bitrate ?? 128000,
                 }
             )
 
             this.compressedMediaRecorder.ondataavailable = (event) => {
                 if (event.data.size > 0) {
+                    // Store the compressed chunk for final blob creation
                     this.compressedChunks.push(event.data)
                     this.compressedSize += event.data.size
+
+                    // Store the pending compressed chunk for the next PCM chunk to use
                     this.pendingCompressedChunk = event.data
                 }
             }
@@ -837,6 +865,8 @@ export class WebRecorder {
                 'Failed to initialize compressed recorder:',
                 error
             )
+            // Setting to null to indicate initialization failed
+            this.compressedMediaRecorder = null
         }
     }
 
@@ -903,6 +933,10 @@ export class WebRecorder {
                     this.audioWorkletNode.disconnect()
                 } catch (e) {
                     // Ignore disconnection errors as the track might already be gone
+                    this.logger?.warn(
+                        'Error disconnecting audioWorkletNode:',
+                        e
+                    )
                 }
             }
         }

package/android/src/main/test/java/net/siteed/audiostream/AudioProcessorTest.kt

@@ -1,56 +0,0 @@
-package net.siteed.audiostream
-
-import org.junit.Test
-import org.junit.Assert.*
-
-class AudioProcessorTest {
-
-    private val sampleRate = 44100
-    private val channels = 1
-    private val encoding = "pcm_16bit"
-    private val pointsPerSecond = 1000
-    private val algorithm = "rms"
-    private val features = mapOf("rms" to true, "zcr" to true)
-
-    private val recordingConfig = RecordingConfig(
-        sampleRate = sampleRate,
-        channels = channels,
-        encoding = encoding,
-        interval = 1000,
-        enableProcessing = true,
-        pointsPerSecond = pointsPerSecond,
-        algorithm = algorithm,
-        features = features
-    )
-
-    private val audioProcessor = AudioProcessor()
-
-    @Test
-    fun testProcessAudioData() {
-        val data = generateSineWave(440.0, sampleRate, 2.0)
-
-        val result = audioProcessor.processAudioData(data, recordingConfig)
-
-        assertNotNull(result)
-        assertEquals(pointsPerSecond, result.pointsPerSecond)
-        assertEquals((data.size / sampleRate) * 1000, result.durationMs.toInt())
-        assertEquals(16, result.bitDepth)
-        assertEquals(channels, result.numberOfChannels)
-        assertEquals(sampleRate, result.sampleRate.toInt())
-    }
-
-    // Helper function to generate a sine wave
-    private fun generateSineWave(frequency: Double, sampleRate: Int, durationSeconds: Double): ByteArray {
-        val numSamples = (sampleRate * durationSeconds).toInt()
-        val output = ByteArray(numSamples * 2) // 16-bit PCM
-
-        for (i in 0 until numSamples) {
-            val time = i / sampleRate.toDouble()
-            val amplitude = (Math.sin(2.0 * Math.PI * frequency * time) * 32767).toInt()
-            output[i * 2] = (amplitude and 0xff).toByte()
-            output[i * 2 + 1] = ((amplitude shr 8) and 0xff).toByte()
-        }
-
-        return output
-    }
-}

package/ios/siteedexpoaudiostudio.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Workspace
-   version = "1.0">
-   <FileRef
-      location = "self:">
-   </FileRef>
-</Workspace>

package/ios/siteedexpoaudiostudio.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>IDEDidComputeMac32BitWarning</key>
-	<true/>
-</dict>
-</plist>