@siteed/expo-audio-studio 2.17.0 → 2.18.1

package/CHANGELOG.md

@@ -8,6 +8,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 
+## [2.18.1] - 2025-08-02
+### Changed
+- feat: improved memory monitoring ([55dfe16](https://github.com/deeeed/expo-audio-stream/commit/55dfe16d7e8c372392738d1441776a760e7ecdbe))
+- chore(expo-audio-studio): release @siteed/expo-audio-studio@2.18.0 ([cc80ac5](https://github.com/deeeed/expo-audio-stream/commit/cc80ac5fa7ece05fc9fae031f101163acce2aff4))
+## [2.18.0] - 2025-08-01
+### Changed
+- feat(expo-audio-studio): optimize buffer size on android to prevent oom ([32fcb9b](https://github.com/deeeed/expo-audio-stream/commit/32fcb9b0a965669b3a37c9860998ae46a1d26cd8))
+- fix(expo-audio-studio): invalid paused duration on android ([c107258](https://github.com/deeeed/expo-audio-stream/commit/c107258054ebdbc733298c84b8d84b0f9f416e6e))
+- chore(expo-audio-studio): release @siteed/expo-audio-studio@2.17.0 ([8a303b4](https://github.com/deeeed/expo-audio-stream/commit/8a303b4d96988b97604123d74daaa406d9ec517c))
 ## [2.17.0] - 2025-07-31
 ### Changed
 - fix(expo-audio-studio): fix OutOfMemoryError by tracking stream position correctly ([b67e521](https://github.com/deeeed/expo-audio-stream/commit/b67e52142154d07873c5c1ec9c183d524d61e528))
@@ -368,7 +377,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Feature: Audio features extraction during recording.
 - Feature: Consistent WAV PCM recording format across all platforms.
 
-[unreleased]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.17.0...HEAD
+[unreleased]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.18.1...HEAD
+[2.18.1]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.18.0...@siteed/expo-audio-studio@2.18.1
+[2.18.0]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.17.0...@siteed/expo-audio-studio@2.18.0
 [2.17.0]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.16.2...@siteed/expo-audio-studio@2.17.0
 [2.16.2]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.16.1...@siteed/expo-audio-studio@2.16.2
 [2.16.1]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.16.0...@siteed/expo-audio-studio@2.16.1

package/android/src/main/java/net/siteed/audiostream/AudioRecorderManager.kt

@@ -75,6 +75,9 @@ class AudioRecorderManager(
         }
     }
     
+    // Maximum size for analysis buffer to prevent OOM on low-RAM devices with extreme configs
+    private val MAX_ANALYSIS_BUFFER_SIZE = 20 * 1024 * 1024 // 20MB
+    
     private var audioRecord: AudioRecord? = null
     private var bufferSizeInBytes = 0
     private val _isRecording = AtomicBoolean(false)
@@ -709,19 +712,29 @@ class AudioRecorderManager(
             )
             
             // Calculate buffer size based on bufferDurationSeconds if provided
-            bufferSizeInBytes = recordingConfig.bufferDurationSeconds?.let { bufferDuration ->
+            var requestedBufferSize = recordingConfig.bufferDurationSeconds?.let { bufferDuration ->
                 val bytesPerSample = when (recordingConfig.encoding) {
                     "pcm_8bit" -> 1
                     "pcm_16bit" -> 2
                     "pcm_32bit" -> 4
                     else -> 2
                 }
-                val requestedSize = (bufferDuration * recordingConfig.sampleRate * 
-                                   bytesPerSample * recordingConfig.channels).toInt()
-                // Use the larger of requested size or minimum buffer size
-                maxOf(requestedSize, minBufferSize)
+                (bufferDuration * recordingConfig.sampleRate * bytesPerSample * recordingConfig.channels).toInt()
             } ?: minBufferSize
 
+            LogUtils.d(CLASS_NAME, "Calculated minBufferSize: $minBufferSize bytes")
+            LogUtils.d(CLASS_NAME, "Requested buffer size: $requestedBufferSize bytes")
+
+            // Cap the buffer size to prevent OOM
+            val MAX_BUFFER_SIZE = 10485760 // 10MB
+            if (requestedBufferSize > MAX_BUFFER_SIZE) {
+                LogUtils.w(CLASS_NAME, "Requested buffer size $requestedBufferSize exceeds max limit of $MAX_BUFFER_SIZE, capping to max")
+                requestedBufferSize = MAX_BUFFER_SIZE
+            }
+
+            bufferSizeInBytes = maxOf(requestedBufferSize, minBufferSize)
+            LogUtils.d(CLASS_NAME, "Final bufferSizeInBytes: $bufferSizeInBytes (after capping and min check)")
+
             when {
                 bufferSizeInBytes == AudioRecord.ERROR -> {
                     LogUtils.e(CLASS_NAME, "Error getting minimum buffer size: ERROR")
@@ -1253,7 +1266,14 @@ class AudioRecorderManager(
 
             // Use cached file size instead of file system call
             val fileSize = if (recordingConfig.output.primary.enabled) cachedPrimaryFileSize else 0L
-            val duration = if (!recordingConfig.output.primary.enabled) {
+            val duration = if (isPaused.get()) {
+                // Return frozen duration when paused using lastPauseTime
+                if (lastPauseTime > 0) {
+                    lastPauseTime - recordingStartTime - pausedDuration
+                } else {
+                    0L
+                }
+            } else if (!recordingConfig.output.primary.enabled) {
                 // For streaming-only mode, calculate duration from actual recording time
                 val actualRecordingTime = if (recordingStartTime > 0) {
                     System.currentTimeMillis() - recordingStartTime - pausedDuration
@@ -1423,7 +1443,7 @@ class AudioRecorderManager(
                 while (_isRecording.get() && !Thread.currentThread().isInterrupted) {
                     loopCount++
                     if (loopCount % 100 == 0) {
-                        LogUtils.d(CLASS_NAME, "Recording loop iteration $loopCount, isRecording: ${_isRecording.get()}")
+                        LogUtils.d(CLASS_NAME, "Recording loop iteration $loopCount, isRecording: ${_isRecording.get()}, accumulatedAudioSize: ${accumulatedAudioData.size()}, accumulatedAnalysisSize: ${accumulatedAnalysisData.size()}")
                     }
                     if (isPaused.get()) {
                         Thread.sleep(100) // Add small delay when paused
@@ -1460,9 +1480,14 @@ class AudioRecorderManager(
                         
                         accumulatedAudioData.write(audioData, 0, bytesRead)
                         
-                        // Also accumulate data for analysis if enabled
-                        if (shouldProcessAnalysis) {
-                            accumulatedAnalysisData.write(audioData, 0, bytesRead)
+                        // Always accumulate data for analysis if enabled (moved outside shouldProcessAnalysis check)
+                        if (recordingConfig.enableProcessing) {
+                            // Check buffer size to prevent OOM on low-RAM devices with extreme configs
+                            if (accumulatedAnalysisData.size() + bytesRead <= MAX_ANALYSIS_BUFFER_SIZE) {
+                                accumulatedAnalysisData.write(audioData, 0, bytesRead)
+                            } else {
+                                LogUtils.w(CLASS_NAME, "Analysis buffer size limit reached (${accumulatedAnalysisData.size()} bytes). Skipping data to prevent OOM.")
+                            }
                         }
 
                         // Handle regular audio data emission
@@ -1490,31 +1515,37 @@ class AudioRecorderManager(
                             if (analysisDataSize > 0) {
                                 // Add this check to enforce minimum interval
                                 if (isFirstAnalysis || (currentTime - lastEmissionTimeAnalysis) >= recordingConfig.intervalAnalysis) {
-                                    // Process and emit analysis data
-                                    val analysisData = audioProcessor.processAudioData(
-                                        accumulatedAnalysisData.toByteArray(),
-                                        recordingConfig
-                                    )
-                                    
-                                    LogUtils.d(CLASS_NAME, """
-                                        Analysis data details:
-                                        - Raw data size: ${accumulatedAnalysisData.size()} bytes
-                                    """.trimIndent())
-                                    
-                                    mainHandler.post {
-                                        try {
-                                            eventSender.sendExpoEvent(
-                                                Constants.AUDIO_ANALYSIS_EVENT_NAME,
-                                                analysisData.toBundle()
-                                            )
-                                        } catch (e: Exception) {
-                                            LogUtils.e(CLASS_NAME, "Failed to send audio analysis event", e)
+                                    try {
+                                        // Process and emit analysis data
+                                        val analysisData = audioProcessor.processAudioData(
+                                            accumulatedAnalysisData.toByteArray(),
+                                            recordingConfig
+                                        )
+                                        
+                                        LogUtils.d(CLASS_NAME, """
+                                            Analysis data details:
+                                            - Raw data size: ${accumulatedAnalysisData.size()} bytes
+                                        """.trimIndent())
+                                        
+                                        mainHandler.post {
+                                            try {
+                                                eventSender.sendExpoEvent(
+                                                    Constants.AUDIO_ANALYSIS_EVENT_NAME,
+                                                    analysisData.toBundle()
+                                                )
+                                            } catch (e: Exception) {
+                                                LogUtils.e(CLASS_NAME, "Failed to send audio analysis event", e)
+                                            }
                                         }
+                                        
+                                        lastEmissionTimeAnalysis = currentTime
+                                        isFirstAnalysis = false
+                                    } catch (e: Exception) {
+                                        LogUtils.e(CLASS_NAME, "Failed to process audio analysis data", e)
+                                    } finally {
+                                        // Always reset the buffer to prevent unbounded growth
+                                        accumulatedAnalysisData.reset()
                                     }
-                                    
-                                    lastEmissionTimeAnalysis = currentTime
-                                    accumulatedAnalysisData.reset()  // Clear the analysis accumulator
-                                    isFirstAnalysis = false
                                 }
                             }
                         }
@@ -1620,8 +1651,13 @@ class AudioRecorderManager(
             }
         }
 
-        if (recordingConfig.enableProcessing) {
-            processAudioData(audioData)
+        // Analysis is already handled in recordingProcess method to avoid duplicate processing
+        // and prevent memory issues from accumulating data in multiple buffers
+        
+        // Update notification waveform if needed (moved from processAudioData)
+        if (recordingConfig.showNotification && recordingConfig.showWaveformInNotification) {
+            val floatArray = convertByteArrayToFloatArray(audioData)
+            notificationManager.updateNotification(floatArray)
         }
     }
 
@@ -1634,55 +1670,6 @@ class AudioRecorderManager(
         return floatArray
     }
 
-    private fun processAudioData(audioData: ByteArray) {
-        // Skip the WAV header only for the first chunk
-        val dataToProcess = if (isFirstChunk && audioData.size > Constants.WAV_HEADER_SIZE) {
-            audioData.copyOfRange(Constants.WAV_HEADER_SIZE, audioData.size)
-        } else {
-            audioData
-        }
-
-        // Accumulate data for analysis
-        if (recordingConfig.enableProcessing) {
-            synchronized(analysisBuffer) {
-                analysisBuffer.write(dataToProcess)
-            }
-            
-            val currentTime = SystemClock.elapsedRealtime()
-            if (isFirstAnalysis || (currentTime - lastEmissionTimeAnalysis) >= recordingConfig.intervalAnalysis) {
-                synchronized(analysisBuffer) {
-                    if (analysisBuffer.size() > 0) {
-                        val analysisData = audioProcessor.processAudioData(
-                            analysisBuffer.toByteArray(),
-                            recordingConfig
-                        )
-                        
-                        mainHandler.post {
-                            eventSender.sendExpoEvent(
-                                Constants.AUDIO_ANALYSIS_EVENT_NAME,
-                                analysisData.toBundle()
-                            )
-                        }
-                        
-                        // Reset buffer after processing
-                        analysisBuffer.reset()
-                        lastEmissionTimeAnalysis = currentTime
-                        isFirstAnalysis = false
-                    }
-                }
-            }
-        }
-
-        // Only update notification if needed
-        if (recordingConfig.showNotification && recordingConfig.showWaveformInNotification) {
-            val floatArray = convertByteArrayToFloatArray(audioData)
-            notificationManager.updateNotification(floatArray)
-        }
-
-        // Reset isFirstChunk after processing
-        isFirstChunk = false
-    }
-
     fun cleanup() {
         synchronized(audioRecordLock) {
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@siteed/expo-audio-studio",
-    "version": "2.17.0",
+    "version": "2.18.1",
     "description": "Comprehensive audio processing library for React Native and Expo with recording, analysis, visualization, and streaming capabilities across iOS, Android, and web",
     "license": "MIT",
     "type": "commonjs",