@siteed/expo-audio-stream 1.16.0 → 2.0.0

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

@@ -1,3 +1,4 @@
+// packages/expo-audio-stream/android/src/main/java/net/siteed/audiostream/ExpoAudioStreamModule.kt
 package net.siteed.audiostream
 
 import android.Manifest
@@ -12,6 +13,7 @@ import expo.modules.kotlin.Promise
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 import expo.modules.interfaces.permissions.Permissions
+import java.util.zip.CRC32
 
 class ExpoAudioStreamModule : Module(), EventSender {
     private lateinit var audioRecorderManager: AudioRecorderManager
@@ -55,28 +57,77 @@ class ExpoAudioStreamModule : Module(), EventSender {
             try {
                 val fileUri = requireNotNull(options["fileUri"] as? String) { "fileUri is required" }
                 
-                // Get decoding options
-                val decodingOptionsMap = options["decodingOptions"] as? Map<String, Any>
-                val decodingConfig = if (decodingOptionsMap != null) {
+                // Get time or byte range options
+                val startTimeMs = options["startTimeMs"] as? Number
+                val endTimeMs = options["endTimeMs"] as? Number
+                val position = options["position"] as? Number
+                val length = options["length"] as? Number
+                val segmentDurationMs = (options["segmentDurationMs"] as? Number)?.toInt() ?: 100
+                
+                // Validate ranges - can have time range OR byte range OR no range
+                val hasTimeRange = startTimeMs != null && endTimeMs != null
+                val hasByteRange = position != null && length != null
+                
+                // Only throw if both ranges are provided
+                if (hasTimeRange && hasByteRange) {
+                    throw IllegalArgumentException("Cannot specify both time range and byte range")
+                }
+
+                // Get decoding options with default configuration
+                val defaultConfig = DecodingConfig(
+                    targetSampleRate = null,
+                    targetChannels = 1, // Default to mono
+                    targetBitDepth = 16,
+                    normalizeAudio = false
+                )
+                
+                val config = (options["decodingOptions"] as? Map<String, Any>)?.let { decodingOptionsMap ->
                     DecodingConfig(
                         targetSampleRate = decodingOptionsMap["targetSampleRate"] as? Int,
                         targetChannels = decodingOptionsMap["targetChannels"] as? Int,
                         targetBitDepth = (decodingOptionsMap["targetBitDepth"] as? Int) ?: 16,
                         normalizeAudio = (decodingOptionsMap["normalizeAudio"] as? Boolean) ?: false
                     )
-                } else null
-
-                val audioData = audioProcessor.loadAudioFromAnyFormat(fileUri, decodingConfig)
-                    ?: throw IllegalStateException("Failed to load audio file")
+                } ?: defaultConfig
+
+                // Load audio data based on range type (or full file if no range specified)
+                val audioData = when {
+                    hasByteRange -> {
+                        val format = audioProcessor.getAudioFormat(fileUri) 
+                            ?: throw IllegalArgumentException("Could not determine audio format")
+                        
+                        // Calculate time range from byte position
+                        val bytesPerSecond = format.sampleRate * format.channels * (format.bitDepth / 8)
+                        val effectiveStartTimeMs = (position!!.toLong() * 1000) / bytesPerSecond
+                        val effectiveEndTimeMs = effectiveStartTimeMs + (length!!.toLong() * 1000) / bytesPerSecond
+                        
+                        Log.d(Constants.TAG, "Loading audio with byte range: position=$position, length=$length")
+                        
+                        audioProcessor.loadAudioRange(
+                            fileUri = fileUri,
+                            startTimeMs = effectiveStartTimeMs,
+                            endTimeMs = effectiveEndTimeMs,
+                            config = config
+                        )
+                    }
+                    hasTimeRange -> {
+                        Log.d(Constants.TAG, "Loading audio with time range: startTimeMs=$startTimeMs, endTimeMs=$endTimeMs")
+                        
+                        audioProcessor.loadAudioRange(
+                            fileUri = fileUri,
+                            startTimeMs = startTimeMs!!.toLong(),
+                            endTimeMs = endTimeMs!!.toLong(),
+                            config = config
+                        )
+                    }
+                    else -> {
+                        Log.d(Constants.TAG, "Loading entire audio file")
+                        audioProcessor.loadAudioFromAnyFormat(fileUri, config)
+                    }
+                } ?: throw IllegalStateException("Failed to load audio data")
 
-                val pointsPerSecond = (options["pointsPerSecond"] as? Double) ?: 20.0
-                val algorithm = options["algorithm"] as? String ?: "peak"
                 val featuresMap = options["features"] as? Map<*, *>
-                val features = featuresMap?.filterKeys { it is String }
-                    ?.filterValues { it is Boolean }
-                    ?.mapKeys { it.key as String }
-                    ?.mapValues { it.value as Boolean }
-                    ?: emptyMap()
+                val features = Features.parseFeatureOptions(featuresMap)
 
                 val recordingConfig = RecordingConfig(
                     sampleRate = audioData.sampleRate,
@@ -87,8 +138,7 @@ class ExpoAudioStreamModule : Module(), EventSender {
                         32 -> "pcm_32bit"
                         else -> throw IllegalArgumentException("Unsupported bit depth: ${audioData.bitDepth}")
                     },
-                    pointsPerSecond = pointsPerSecond,
-                    algorithm = algorithm,
+                    segmentDurationMs = segmentDurationMs,
                     features = features
                 )
 
@@ -98,7 +148,7 @@ class ExpoAudioStreamModule : Module(), EventSender {
                 val analysisData = audioProcessor.processAudioData(audioData.data, recordingConfig)
                 promise.resolve(analysisData.toDictionary())
             } catch (e: Exception) {
-                Log.e(Constants.TAG, "Audio processing failed: ${e.message}", e)
+                Log.e(Constants.TAG, "Failed to extract audio analysis: ${e.message}", e)
                 promise.reject("PROCESSING_ERROR", e.message ?: "Unknown error", e)
             }
         }
@@ -189,85 +239,6 @@ class ExpoAudioStreamModule : Module(), EventSender {
             }
         }
 
-        AsyncFunction("extractPreview") { options: Map<String, Any>, promise: Promise ->
-            try {
-                val fileUri = requireNotNull(options["fileUri"] as? String) { "fileUri is required" }
-                val numberOfPoints = (options["numberOfPoints"] as? Int) ?: 100
-                val algorithm = (options["algorithm"] as? String)?.lowercase() ?: "rms"
-                val startTime = (options["startTime"] as? Number)?.toLong()
-                val endTime = (options["endTime"] as? Number)?.toLong()
-                
-                Log.d(Constants.TAG, """
-                    Extracting preview with params:
-                    - fileUri: $fileUri
-                    - numberOfPoints: $numberOfPoints
-                    - algorithm: $algorithm
-                    - startTime: ${startTime ?: "none"}
-                    - endTime: ${endTime ?: "none"}
-                """.trimIndent())
-                
-                // Get decoding options with defaults
-                val decodingOptionsMap = options["decodingOptions"] as? Map<String, Any>
-                val decodingConfig = if (decodingOptionsMap != null) {
-                    DecodingConfig(
-                        targetSampleRate = decodingOptionsMap["targetSampleRate"] as? Int ?: 22050,
-                        targetChannels = decodingOptionsMap["targetChannels"] as? Int ?: 1,
-                        targetBitDepth = (decodingOptionsMap["targetBitDepth"] as? Int) ?: 16,
-                        normalizeAudio = (decodingOptionsMap["normalizeAudio"] as? Boolean) ?: false
-                    )
-                } else DecodingConfig(
-                    targetSampleRate = 16000,
-                    targetChannels = 1,
-                    targetBitDepth = 16,
-                    normalizeAudio = false
-                )
-
-                Log.d(Constants.TAG, """
-                    Using decoding config:
-                    - targetSampleRate: ${decodingConfig.targetSampleRate}
-                    - targetChannels: ${decodingConfig.targetChannels}
-                    - targetBitDepth: ${decodingConfig.targetBitDepth}
-                    - normalizeAudio: ${decodingConfig.normalizeAudio}
-                """.trimIndent())
-
-                // Use loadAudioRange when time range is specified, otherwise fall back to loadAudioFromAnyFormat
-                val audioData = if (startTime != null && endTime != null) {
-                    audioProcessor.loadAudioRange(fileUri, startTime, endTime, decodingConfig)
-                } else {
-                    audioProcessor.loadAudioFromAnyFormat(fileUri, decodingConfig)
-                } ?: throw IllegalStateException("Failed to load audio file")
-
-                val previewConfig = RecordingConfig(
-                    sampleRate = audioData.sampleRate,
-                    channels = audioData.channels,
-                    encoding = when (audioData.bitDepth) {
-                        8 -> "pcm_8bit"
-                        16 -> "pcm_16bit"
-                        32 -> "pcm_32bit"
-                        else -> throw IllegalArgumentException("Unsupported bit depth: ${audioData.bitDepth}")
-                    },
-                    pointsPerSecond = 0.0, // Will be overridden by numberOfPoints
-                    algorithm = algorithm,
-                    features = emptyMap() // No features needed for preview
-                )
-
-                val preview = audioProcessor.generatePreview(
-                    audioData = audioData,
-                    numberOfPoints = numberOfPoints,
-                    startTimeMs = startTime,
-                    endTimeMs = endTime,
-                    config = previewConfig
-                )
-                
-                Log.d(Constants.TAG, "Preview generated successfully with ${preview.dataPoints.size} points")
-                promise.resolve(preview.toDictionary())
-            } catch (e: Exception) {
-                Log.e(Constants.TAG, "Preview generation failed: ${e.message}", e)
-                Log.e(Constants.TAG, "Stack trace: ${e.stackTraceToString()}")
-                promise.reject("PROCESSING_ERROR", e.message ?: "Unknown error", e)
-            }
-        }
-
         AsyncFunction("trimAudio") { options: Map<String, Any>, promise: Promise ->
             try {
                 val fileUri = requireNotNull(options["fileUri"] as? String) { "fileUri is required" }
@@ -341,6 +312,175 @@ class ExpoAudioStreamModule : Module(), EventSender {
             
             promise.resolve(status)
         }
+
+        AsyncFunction("extractAudioData") { options: Map<String, Any>, promise: Promise ->
+            try {
+                val fileUri = requireNotNull(options["fileUri"] as? String) { "fileUri is required" }
+                val startTimeMs = options["startTimeMs"] as? Number
+                val endTimeMs = options["endTimeMs"] as? Number
+                val position = options["position"] as? Number
+                val length = options["length"] as? Number
+                
+                // Validate that we have either time range or byte range, but not both and not neither
+                val hasTimeRange = startTimeMs != null && endTimeMs != null
+                val hasByteRange = position != null && length != null
+                
+                if (!hasTimeRange && !hasByteRange) {
+                    throw IllegalArgumentException("Must specify either time range (startTimeMs, endTimeMs) or byte range (position, length)")
+                }
+                if (hasTimeRange && hasByteRange) {
+                    throw IllegalArgumentException("Cannot specify both time range and byte range")
+                }
+                
+                // Get decoding options
+                val decodingOptionsMap = options["decodingOptions"] as? Map<String, Any>
+                val decodingConfig = if (decodingOptionsMap != null) {
+                    DecodingConfig(
+                        targetSampleRate = decodingOptionsMap["targetSampleRate"] as? Int,
+                        targetChannels = decodingOptionsMap["targetChannels"] as? Int,
+                        targetBitDepth = (decodingOptionsMap["targetBitDepth"] as? Int) ?: 16,
+                        normalizeAudio = (decodingOptionsMap["normalizeAudio"] as? Boolean) ?: false
+                    ).also {
+                        Log.d(Constants.TAG, """
+                            Using decoding config:
+                            - targetSampleRate: ${it.targetSampleRate ?: "original"}
+                            - targetChannels: ${it.targetChannels ?: "original"}
+                            - targetBitDepth: ${it.targetBitDepth}
+                            - normalizeAudio: ${it.normalizeAudio}
+                        """.trimIndent())
+                    }
+                } else null
+
+                val audioData = if (hasByteRange) {
+                    val format = audioProcessor.getAudioFormat(fileUri) 
+                        ?: throw IllegalArgumentException("Could not determine audio format")
+                    
+                    // Calculate time range from byte position
+                    val bytesPerSecond = format.sampleRate * format.channels * (format.bitDepth / 8)
+                    val effectiveStartTimeMs = (position!!.toLong() * 1000) / bytesPerSecond
+                    val effectiveEndTimeMs = effectiveStartTimeMs + (length!!.toLong() * 1000) / bytesPerSecond
+                    
+                    Log.d(Constants.TAG, """
+                        Converting byte range to time range:
+                        - position: $position bytes
+                        - length: $length bytes
+                        - bytesPerSecond: $bytesPerSecond
+                        - effectiveStartTimeMs: $effectiveStartTimeMs
+                        - effectiveEndTimeMs: $effectiveEndTimeMs
+                    """.trimIndent())
+                    
+                    audioProcessor.loadAudioRange(
+                        fileUri = fileUri,
+                        startTimeMs = effectiveStartTimeMs,
+                        endTimeMs = effectiveEndTimeMs,
+                        config = decodingConfig
+                    )
+                } else {
+                    // Must be time range due to earlier validation
+                    Log.d(Constants.TAG, """
+                        Using time range:
+                        - startTimeMs: $startTimeMs
+                        - endTimeMs: $endTimeMs
+                    """.trimIndent())
+                    
+                    audioProcessor.loadAudioRange(
+                        fileUri = fileUri,
+                        startTimeMs = startTimeMs!!.toLong(),
+                        endTimeMs = endTimeMs!!.toLong(),
+                        config = decodingConfig
+                    )
+                } ?: throw IllegalStateException("Failed to load audio data")
+
+                Log.d(Constants.TAG, """
+                    Audio data loaded successfully:
+                    - data size: ${audioData.data.size} bytes
+                    - sampleRate: ${audioData.sampleRate}
+                    - channels: ${audioData.channels}
+                    - bitDepth: ${audioData.bitDepth}
+                    - durationMs: ${audioData.durationMs}
+                """.trimIndent())
+
+                val includeNormalizedData = options["includeNormalizedData"] as? Boolean ?: false
+                val includeBase64Data = options["includeBase64Data"] as? Boolean ?: false
+                val includeWavHeader = options["includeWavHeader"] as? Boolean ?: false
+                val bytesPerSample = audioData.bitDepth / 8
+                val samples = audioData.data.size / (bytesPerSample * audioData.channels)
+                
+                // Create the result map
+                val resultMap = mutableMapOf<String, Any>()
+                
+                // Add WAV header if requested
+                if (includeWavHeader) {
+                    // Use ByteArrayOutputStream to write the WAV header and data
+                    val outputStream = java.io.ByteArrayOutputStream()
+                    val audioFileHandler = AudioFileHandler(appContext.reactContext!!.filesDir)
+                    
+                    // Write the WAV header
+                    audioFileHandler.writeWavHeader(
+                        outputStream,
+                        audioData.sampleRate,
+                        audioData.channels,
+                        audioData.bitDepth
+                    )
+                    
+                    // Write the PCM data
+                    outputStream.write(audioData.data)
+                    
+                    // Get the complete WAV data
+                    val wavData = outputStream.toByteArray()
+                    
+                    resultMap["pcmData"] = wavData
+                    resultMap["hasWavHeader"] = true
+                    
+                    Log.d(Constants.TAG, "Added WAV header to PCM data, total size: ${wavData.size} bytes")
+                } else {
+                    resultMap["pcmData"] = audioData.data
+                    resultMap["hasWavHeader"] = false
+                }
+                
+                // Add the rest of the data
+                resultMap.putAll(mapOf(
+                    "sampleRate" to audioData.sampleRate,
+                    "channels" to audioData.channels,
+                    "bitDepth" to audioData.bitDepth,
+                    "durationMs" to audioData.durationMs,
+                    "format" to "pcm_${audioData.bitDepth}bit",
+                    "samples" to samples
+                ))
+                
+                // Add checksum if requested
+                if (options["computeChecksum"] == true) {
+                    val crc32 = CRC32()
+                    crc32.update(audioData.data)
+                    resultMap["checksum"] = crc32.value.toInt()
+                    
+                    Log.d(Constants.TAG, "Computed CRC32 checksum: ${crc32.value}")
+                }
+                
+                if (includeNormalizedData) {
+                    val float32Data = AudioFormatUtils.convertByteArrayToFloatArray(
+                        audioData.data,
+                        "pcm_${audioData.bitDepth}bit"
+                    )
+                    resultMap["normalizedData"] = float32Data
+                }
+                
+                if (includeBase64Data) {
+                    // Convert the PCM data to a base64 string
+                    val base64Data = android.util.Base64.encodeToString(
+                        audioData.data, 
+                        android.util.Base64.NO_WRAP
+                    )
+                    resultMap["base64Data"] = base64Data
+                }
+                
+                promise.resolve(resultMap)
+            } catch (e: Exception) {
+                Log.e(Constants.TAG, "Failed to extract audio data: ${e.message}")
+                Log.e(Constants.TAG, "Stack trace: ${e.stackTraceToString()}")
+                promise.reject("PROCESSING_ERROR", e.message ?: "Unknown error", e)
+            }
+        }
     }
 
     private fun initializeManager() {

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

@@ -1,18 +1,47 @@
+// packages/expo-audio-stream/android/src/main/java/net/siteed/audiostream/FFT.kt
 package net.siteed.audiostream
 
 import kotlin.math.PI
 import kotlin.math.cos
 import kotlin.math.sin
+import kotlin.math.sqrt
 
 class FFT(private val n: Int) {
     private val cosTable = FloatArray(n / 2)
     private val sinTable = FloatArray(n / 2)
+    private val hannWindow = FloatArray(n)
 
     init {
+        // Precompute trig tables
         for (i in 0 until n / 2) {
             cosTable[i] = cos(2.0 * PI * i / n).toFloat()
             sinTable[i] = sin(2.0 * PI * i / n).toFloat()
         }
+        
+        // Precompute normalized Hann window to match vDSP
+        val normalizationFactor = sqrt(2.0f / n)  // Match vDSP normalization
+        for (i in hannWindow.indices) {
+            hannWindow[i] = normalizationFactor * 0.5f * (1 - cos(2.0 * PI * i / (n - 1))).toFloat()
+        }
+    }
+
+    fun processSegment(segment: FloatArray): FloatArray {
+        // Pad or truncate input to match FFT length
+        val paddedSegment = if (segment.size < n) {
+            segment + FloatArray(n - segment.size)
+        } else {
+            segment.copyOf(n)
+        }
+
+        // Apply normalized Hann window
+        for (i in paddedSegment.indices) {
+            paddedSegment[i] *= hannWindow[i]
+        }
+
+        // Perform FFT
+        realForward(paddedSegment)
+
+        return paddedSegment
     }
 
     fun realForward(data: FloatArray) {
@@ -41,4 +70,30 @@ class FFT(private val n: Int) {
             data[i + n / 2] = even[i] - t
         }
     }
+
+    fun realInverse(powerSpectrum: FloatArray, output: FloatArray) {
+        // Copy power spectrum to complex format for inverse FFT
+        val complexData = FloatArray(n * 2)
+        for (i in 0 until n/2 + 1) {
+            complexData[2 * i] = powerSpectrum[i]
+            if (2 * i + 1 < complexData.size) {
+                complexData[2 * i + 1] = 0f
+            }
+        }
+
+        // Conjugate for inverse FFT
+        for (i in 0 until n) {
+            if (2 * i + 1 < complexData.size) {
+                complexData[2 * i + 1] = -complexData[2 * i + 1]
+            }
+        }
+
+        // Perform forward FFT (which is inverse when input is conjugated)
+        realForward(complexData)
+
+        // Copy real part to output and conjugate again
+        for (i in 0 until n) {
+            output[i] = complexData[2 * i] / n
+        }
+    }
 }

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

@@ -14,12 +14,17 @@ data class Features(
     val spectralFlatness: Float = 0f,
     val spectralRollOff: Float = 0f,
     val spectralBandwidth: Float = 0f,
-    val chromagram: List<Float> = emptyList(),
     val tempo: Float = 0f,
-    val hnr: Float = 0f
+    val hnr: Float = 0f,
+    val melSpectrogram: List<Float> = emptyList(),
+    val chromagram: List<Float> = emptyList(),
+    val spectralContrast: List<Float> = emptyList(),
+    val tonnetz: List<Float> = emptyList(),
+    val pitch: Float = 0f,
+    val crc32: Long? = null
 ) {
     fun toDictionary(): Map<String, Any> {
-        return mapOf(
+        val baseMap = mapOf(
             "energy" to energy,
             "mfcc" to mfcc,
             "rms" to rms,
@@ -30,10 +35,16 @@ data class Features(
             "spectralFlatness" to spectralFlatness,
             "spectralRollOff" to spectralRollOff,
             "spectralBandwidth" to spectralBandwidth,
-            "chromagram" to chromagram,
             "tempo" to tempo,
-            "hnr" to hnr
+            "hnr" to hnr,
+            "melSpectrogram" to melSpectrogram,
+            "chromagram" to chromagram,
+            "spectralContrast" to spectralContrast,
+            "tonnetz" to tonnetz,
+            "pitch" to pitch,
+            "crc32" to (crc32 ?: 0)
         )
+        return baseMap.filterValues { it != null }
     }
 
     fun toBundle(): Bundle {
@@ -48,9 +59,40 @@ data class Features(
             "spectralFlatness" to spectralFlatness,
             "spectralRollOff" to spectralRollOff,
             "spectralBandwidth" to spectralBandwidth,
-            "chromagram" to chromagram,
             "tempo" to tempo,
-            "hnr" to hnr
+            "hnr" to hnr,
+            "melSpectrogram" to melSpectrogram,
+            "chromagram" to chromagram,
+            "spectralContrast" to spectralContrast,
+            "tonnetz" to tonnetz,
+            "pitch" to pitch,
+            "crc32" to (crc32 ?: 0)
         )
     }
+
+    companion object {
+        fun parseFeatureOptions(options: Map<*, *>?): Map<String, Boolean> {
+            return options?.let { map ->
+                mapOf(
+                    "energy" to (map["energy"] as? Boolean ?: false),
+                    "mfcc" to (map["mfcc"] as? Boolean ?: false),
+                    "rms" to (map["rms"] as? Boolean ?: false),
+                    "zcr" to (map["zcr"] as? Boolean ?: false),
+                    "dB" to (map["dB"] as? Boolean ?: false),
+                    "spectralCentroid" to (map["spectralCentroid"] as? Boolean ?: false),
+                    "spectralFlatness" to (map["spectralFlatness"] as? Boolean ?: false),
+                    "spectralRollOff" to (map["spectralRollOff"] as? Boolean ?: false),
+                    "spectralBandwidth" to (map["spectralBandwidth"] as? Boolean ?: false),
+                    "chromagram" to (map["chromagram"] as? Boolean ?: false),
+                    "tempo" to (map["tempo"] as? Boolean ?: false),
+                    "hnr" to (map["hnr"] as? Boolean ?: false),
+                    "melSpectrogram" to (map["melSpectrogram"] as? Boolean ?: false),
+                    "spectralContrast" to (map["spectralContrast"] as? Boolean ?: false),
+                    "tonnetz" to (map["tonnetz"] as? Boolean ?: false),
+                    "pitch" to (map["pitch"] as? Boolean ?: false),
+                    "crc32" to (map["crc32"] as? Boolean ?: false)
+                )
+            } ?: emptyMap()
+        }
+    }
 }

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

@@ -10,9 +10,9 @@ data class RecordingConfig(
     val encoding: String = "pcm_16bit",
     val keepAwake: Boolean = true,
     val interval: Long = Constants.DEFAULT_INTERVAL,
+    val intervalAnalysis: Long = Constants.DEFAULT_INTERVAL_ANALYSIS,
     val enableProcessing: Boolean = false,
-    val pointsPerSecond: Double = 20.0,
-    val algorithm: String = "rms",
+    val segmentDurationMs: Int = 100,
     val showNotification: Boolean = false,
     val showWaveformInNotification: Boolean = false,
     val notification: NotificationConfig = NotificationConfig(),
@@ -89,9 +89,9 @@ data class RecordingConfig(
                 encoding = options.getStringOrDefault("encoding", "pcm_16bit"),
                 keepAwake = options.getBooleanOrDefault("keepAwake", true),
                 interval = options.getNumberOrDefault("interval", Constants.DEFAULT_INTERVAL),
+                intervalAnalysis = options.getNumberOrDefault("intervalAnalysis", Constants.DEFAULT_INTERVAL_ANALYSIS),
                 enableProcessing = options.getBooleanOrDefault("enableProcessing", false),
-                pointsPerSecond = options.getNumberOrDefault("pointsPerSecond", 20.0),
-                algorithm = options.getStringOrDefault("algorithm", "rms"),
+                segmentDurationMs = options.getNumberOrDefault("segmentDurationMs", 100),
                 showNotification = options.getBooleanOrDefault("showNotification", false),
                 showWaveformInNotification = options.getBooleanOrDefault("showWaveformInNotification", false),
                 notification = notificationConfig,