@siteed/expo-audio-stream 1.17.0 → 2.0.1

package/ios/AudioStreamManager.swift

@@ -1588,9 +1588,8 @@ class AudioStreamManager: NSObject {
                         let processingResult = processor.processAudioBuffer(
                             data: dataToProcess,
                             sampleRate: Float(settings.sampleRate),
-                            pointsPerSecond: settings.pointsPerSecond ?? 10,
-                            algorithm: settings.algorithm ?? "rms",
-                            featureOptions: settings.featureOptions ?? ["rms": true, "zcr": true],
+                            segmentDurationMs: settings.segmentDurationMs,
+                            featureOptions: settings.featureOptions ?? [:],
                             bitDepth: settings.bitDepth,
                             numberOfChannels: settings.numberOfChannels
                         )

package/ios/DataPoint.swift

@@ -7,19 +7,31 @@
 
 import Foundation
 
+public struct SpeechFeatures {
+    public var isActive: Bool
+    public var speakerId: Int?
+    
+    func toDictionary() -> [String: Any] {
+        return [
+            "isActive": isActive,
+            "speakerId": speakerId as Any
+        ]
+    }
+}
 
 public struct DataPoint {
     public var id: Int
     public var amplitude: Float
-    public var activeSpeech: Bool?
-    public var dB: Float?
-    public var silent: Bool?
+    public var rms: Float
+    public var dB: Float
+    public var silent: Bool
     public var features: Features?
-    public var startTime: Float?
-    public var endTime: Float?
-    public var startPosition: Int?
-    public var endPosition: Int?
-    public var speaker: Int?
+    public var speech: SpeechFeatures?
+    public let startTime: Float // in seconds
+    public let endTime: Float   // in seconds
+    public let startPosition: Int // byte position in audio file
+    public let endPosition: Int   // byte position in audio file
+    public let samples: Int       // number of samples in segment
 }
 
 extension DataPoint {
@@ -27,15 +39,16 @@ extension DataPoint {
         return [
             "id": id,
             "amplitude": amplitude,
-            "activeSpeech": activeSpeech ?? false,
-            "dB": dB ?? 0,
-            "silent": silent ?? false,
+            "rms": rms,
+            "dB": dB,
+            "silent": silent,
             "features": features?.toDictionary() ?? [:],
+            "speech": speech?.toDictionary() ?? [:],
             "startTime": startTime ?? 0,
             "endTime": endTime ?? 0,
             "startPosition": startPosition ?? 0,
             "endPosition": endPosition ?? 0,
-            "speaker": speaker ?? 0
+            "samples": samples ?? 0
         ]
     }
 }

package/ios/DecodingConfig.swift

@@ -0,0 +1,47 @@
+//
+//  DecodingConfig.swift
+//  Pods
+//
+//  Created by Arthur Breton on 24/2/2025.
+//
+
+import AVFoundation
+
+public struct DecodingConfig {
+    let targetSampleRate: Double?
+    let targetChannels: Int?
+    let targetBitDepth: Int?
+    let normalizeAudio: Bool
+    
+    static func fromDictionary(_ dict: [String: Any]?) -> DecodingConfig {
+        guard let dict = dict else {
+            return DecodingConfig.default
+        }
+        
+        return DecodingConfig(
+            targetSampleRate: dict["targetSampleRate"] as? Double,
+            targetChannels: dict["targetChannels"] as? Int,
+            targetBitDepth: dict["targetBitDepth"] as? Int,
+            normalizeAudio: dict["normalizeAudio"] as? Bool ?? false
+        )
+    }
+    
+    static var `default`: DecodingConfig {
+        return DecodingConfig(
+            targetSampleRate: nil,
+            targetChannels: nil,
+            targetBitDepth: nil,
+            normalizeAudio: false
+        )
+    }
+    
+    func toAudioFormat(baseFormat: AVAudioFormat) -> AVAudioFormat {
+        let sampleRate = targetSampleRate ?? baseFormat.sampleRate
+        let channels = targetChannels ?? Int(baseFormat.channelCount)
+        
+        return AVAudioFormat(
+            standardFormatWithSampleRate: sampleRate,
+            channels: AVAudioChannelCount(channels)
+        )!
+    }
+}

package/ios/ExpoAudioStreamModule.swift

@@ -1,3 +1,4 @@
+// packages/expo-audio-stream/ios/ExpoAudioStreamModule.swift
 import ExpoModulesCore
 import AVFoundation
 
@@ -31,72 +32,55 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
         ///   - options: A dictionary containing:
         ///     - `fileUri`: The URI of the audio file.
         ///     - `pointsPerSecond`: The number of data points to extract per second of audio.
-        ///     - `algorithm`: The algorithm to use for extraction.
         ///     - `features`: A dictionary specifying which features to extract (e.g., `energy`, `mfcc`, `rms`, etc.).
         ///   - promise: A promise to resolve with the extracted audio analysis data or reject with an error.
         /// - Returns: Promise to be resolved with audio analysis data.
         AsyncFunction("extractAudioAnalysis") { (options: [String: Any], promise: Promise) in
             guard let fileUri = options["fileUri"] as? String,
-                  let url = URL(string: fileUri),
-                  let pointsPerSecond = options["pointsPerSecond"] as? Int,
-                  let algorithm = options["algorithm"] as? String else {
-                promise.reject("INVALID_ARGUMENTS", "Invalid arguments provided")
+                  let url = URL(string: fileUri) else {
+                promise.reject("INVALID_ARGUMENTS", "Invalid file URI provided")
+                return
+            }
+            
+            // Get time or byte range options
+            let startTimeMs = options["startTimeMs"] as? Double
+            let endTimeMs = options["endTimeMs"] as? Double
+            let position = options["position"] as? Int
+            let byteLength = options["length"] as? Int
+            
+            // Validate ranges - can have time range OR byte range OR no range
+            let hasTimeRange = startTimeMs != nil && endTimeMs != nil
+            let hasByteRange = position != nil && byteLength != nil
+            
+            // Only throw if both ranges are provided
+            guard !(hasTimeRange && hasByteRange) else {
+                promise.reject("INVALID_ARGUMENTS", "Cannot specify both time range and byte range")
                 return
             }
             
             let features = options["features"] as? [String: Bool] ?? [:]
             let featureOptions = self.extractFeatureOptions(from: features)
+            let segmentDurationMs = options["segmentDurationMs"] as? Int ?? 100 // Default value of 100ms
             
-            DispatchQueue.global().async {
+            DispatchQueue.global().async(execute: {
                 do {
                     let audioFile = try AVAudioFile(forReading: url)
                     let bitDepth = audioFile.fileFormat.settings[AVLinearPCMBitDepthKey] as? Int ?? 16
                     let numberOfChannels = Int(audioFile.fileFormat.channelCount)
+                    let sampleRate = audioFile.fileFormat.sampleRate
                     
-                    let audioProcessor = try AudioProcessor(url: url, resolve: { result in
-                        promise.resolve(result)
-                    }, reject: { code, message in
-                        promise.reject(code, message)
-                    })
+                    // Convert time range to byte range if needed
+                    let effectivePosition: Int?
+                    let effectiveLength: Int?
                     
-                    if let result = audioProcessor.processAudioData(numberOfSamples: nil, pointsPerSecond: pointsPerSecond, algorithm: algorithm, featureOptions: featureOptions, bitDepth: bitDepth, numberOfChannels: numberOfChannels) {
-                        promise.resolve(result.toDictionary())
+                    if hasTimeRange {
+                        let bytesPerSecond = Int(sampleRate) * numberOfChannels * (bitDepth / 8)
+                        effectivePosition = Int(startTimeMs! * Double(bytesPerSecond) / 1000.0)
+                        effectiveLength = Int((endTimeMs! - startTimeMs!) * Double(bytesPerSecond) / 1000.0)
                     } else {
-                        promise.reject("PROCESSING_ERROR", "Failed to process audio data")
+                        effectivePosition = position
+                        effectiveLength = byteLength
                     }
-                } catch {
-                    promise.reject("PROCESSING_ERROR", "Failed to initialize audio processor: \(error.localizedDescription)")
-                }
-            }
-        }
-        
-        /// Extracts waveform data from an audio file.
-        ///
-        /// - Parameters:
-        ///   - options: A dictionary containing:
-        ///     - `fileUri`: The URI of the audio file.
-        ///     - `numberOfSamples`: The number of samples to extract for the waveform.
-        ///     - `offset`: The optional offset to start reading from. Defaults to 0 if not provided.
-        ///     - `length`: The optional length of the audio to read. Defaults to the entire file if not provided.
-        ///   - promise: A promise to resolve with the extracted waveform data or reject with an error.
-        /// - Returns: Promise to be resolved with waveform data.
-        AsyncFunction("extractWaveform") { (options: [String: Any], promise: Promise) in
-            guard let fileUri = options["fileUri"] as? String,
-                  let url = URL(string: fileUri),
-                  let numberOfSamples = options["numberOfSamples"] as? Int else {
-                promise.reject("INVALID_ARGUMENTS", "Invalid arguments provided")
-                return
-            }
-            
-            let offset = options["offset"] as? Int ?? 0
-            DispatchQueue.global().async {
-                do {
-                    let audioFile = try AVAudioFile(forReading: url)
-                    let bitDepth = audioFile.fileFormat.settings[AVLinearPCMBitDepthKey] as? Int ?? 16
-                    let numberOfChannels = Int(audioFile.fileFormat.channelCount)
-                    
-                    // If length is not provided, default to the entire file length
-                    let length = options["length"] as? UInt ?? UInt(audioFile.length - AVAudioFramePosition(offset))
                     
                     let audioProcessor = try AudioProcessor(url: url, resolve: { result in
                         promise.resolve(result)
@@ -104,15 +88,25 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
                         promise.reject(code, message)
                     })
                     
-                    if let result = audioProcessor.processAudioData(numberOfSamples: numberOfSamples, offset: offset, length: length, pointsPerSecond: nil, algorithm: "rms", featureOptions: [:], bitDepth: bitDepth, numberOfChannels: numberOfChannels) {
+                    if let result = audioProcessor.processAudioData(
+                        numberOfSamples: nil,
+                        offset: 0,
+                        length: nil,
+                        segmentDurationMs: segmentDurationMs,
+                        featureOptions: featureOptions,
+                        bitDepth: bitDepth,
+                        numberOfChannels: numberOfChannels,
+                        position: effectivePosition,
+                        byteLength: effectiveLength
+                    ) {
                         promise.resolve(result.toDictionary())
                     } else {
-                        promise.reject("EXTRACTION_ERROR", "Failed to extract waveform")
+                        promise.reject("PROCESSING_ERROR", "Failed to process audio data")
                     }
                 } catch {
-                    promise.reject("EXTRACTION_ERROR", "Failed to initialize waveform extractor: \(error.localizedDescription)")
+                    promise.reject("PROCESSING_ERROR", "Failed to initialize audio processor: \(error.localizedDescription)")
                 }
-            }
+            })
         }
         
         
@@ -315,57 +309,6 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
             }
         }
 
-        /// Extracts audio features from an audio file.
-        /// - Parameters:
-        ///   - options: A dictionary containing:
-        ///     - `fileUri`: The URI of the audio file.
-        ///     - `startTimeMs`: Optional start time in milliseconds.
-        ///     - `endTimeMs`: Optional end time in milliseconds.
-        ///     - `pointsPerSecond`: Number of points per second for analysis.
-        ///     - `algorithm`: The algorithm to use for extraction.
-        ///     - `featureOptions`: Features to extract.
-        AsyncFunction("extractPreview") { (options: [String: Any], promise: Promise) in
-            guard let fileUri = options["fileUri"] as? String,
-                  let url = URL(string: fileUri) else {
-                promise.reject("INVALID_ARGUMENTS", "Invalid file URI provided")
-                return
-            }
-
-            let startTimeMs = options["startTimeMs"] as? Double
-            let endTimeMs = options["endTimeMs"] as? Double
-            let pointsPerSecond = options["pointsPerSecond"] as? Int ?? 20
-            let algorithm = options["algorithm"] as? String ?? "rms"
-            let featureOptions = options["featureOptions"] as? [String: Bool] ?? [:]
-
-            DispatchQueue.global().async {
-                do {
-                    let audioProcessor = try AudioProcessor(
-                        url: url,
-                        resolve: { result in
-                            promise.resolve(result)
-                        },
-                        reject: { code, message in
-                            promise.reject(code, message)
-                        }
-                    )
-                    
-                    if let result = audioProcessor.processAudioData(
-                        startTimeMs: startTimeMs,
-                        endTimeMs: endTimeMs,
-                        pointsPerSecond: pointsPerSecond,
-                        algorithm: algorithm,
-                        featureOptions: featureOptions
-                    ) {
-                        promise.resolve(result.toDictionary())
-                    } else {
-                        promise.reject("PROCESSING_ERROR", "Failed to process audio data")
-                    }
-                } catch {
-                    promise.reject("PROCESSING_ERROR", "Failed to initialize audio processor: \(error.localizedDescription)")
-                }
-            }
-        }
-
         /// Trims an audio file to specified start and end times.
         /// - Parameters:
         ///   - options: A dictionary containing:
@@ -414,6 +357,142 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
                 }
             }
         }
+        
+        /// Extracts raw PCM audio data from a file with time or byte range support
+        /// - Parameters:
+        ///   - options: A dictionary containing:
+        ///     - `fileUri`: The URI of the audio file
+        ///     - `startTimeMs`: Optional start time in milliseconds
+        ///     - `endTimeMs`: Optional end time in milliseconds
+        ///     - `position`: Optional byte position
+        ///     - `length`: Optional byte length
+        ///     - `includeNormalizedData`: Boolean to include normalized audio data in [-1, 1] range
+        ///     - `includeWavHeader`: Boolean to include WAV header in the PCM data
+        ///     - `decodingOptions`: Decoding configuration
+        ///     - `includeBase64Data`: Boolean to include base64 encoded string representation of the audio data
+        ///     - `computeChecksum`: Boolean to compute and include CRC32 checksum of the PCM data
+        AsyncFunction("extractAudioData") { (options: [String: Any], promise: Promise) in
+            guard let fileUri = options["fileUri"] as? String,
+                  let url = URL(string: fileUri) else {
+                promise.reject("INVALID_ARGUMENTS", "Invalid file URI provided")
+                return
+            }
+
+            // Get time or byte range options
+            let startTimeMs = options["startTimeMs"] as? Double
+            let endTimeMs = options["endTimeMs"] as? Double
+            let position = options["position"] as? Int
+            let length = options["length"] as? Int
+            let includeWavHeader = options["includeWavHeader"] as? Bool ?? false
+
+            // Validate that we have either time range or byte range, but not both and not neither
+            let hasTimeRange = startTimeMs != nil && endTimeMs != nil
+            let hasByteRange = position != nil && length != nil
+
+            guard hasTimeRange || hasByteRange else {
+                promise.reject("INVALID_ARGUMENTS", "Must specify either time range (startTimeMs, endTimeMs) or byte range (position, length)")
+                return
+            }
+
+            guard !(hasTimeRange && hasByteRange) else {
+                promise.reject("INVALID_ARGUMENTS", "Cannot specify both time range and byte range")
+                return
+            }
+
+            do {
+                let audioFile = try AVAudioFile(forReading: url)
+                let format = audioFile.processingFormat
+                let sampleRate = format.sampleRate
+                let channels = Int(format.channelCount)
+                let bitDepth = audioFile.fileFormat.settings[AVLinearPCMBitDepthKey] as? Int ?? 16
+
+                // Calculate frame positions
+                let startFrame: AVAudioFramePosition
+                let endFrame: AVAudioFramePosition
+
+                if hasTimeRange {
+                    startFrame = AVAudioFramePosition(startTimeMs! * sampleRate / 1000.0)
+                    endFrame = AVAudioFramePosition(endTimeMs! * sampleRate / 1000.0)
+                } else {
+                    // Convert byte position to frame position
+                    let bytesPerFrame = Int64(channels * (bitDepth / 8))
+                    startFrame = AVAudioFramePosition(position!) / bytesPerFrame
+                    endFrame = startFrame + (AVAudioFramePosition(length!) / bytesPerFrame)
+                }
+
+                // Validate frame range
+                guard startFrame >= 0 && endFrame <= audioFile.length && startFrame < endFrame else {
+                    promise.reject("INVALID_RANGE", "Invalid range specified")
+                    return
+                }
+
+                let frameCount = AVAudioFrameCount(endFrame - startFrame)
+                
+                // Create decoding config that includes normalization preference
+                var decodingOptions = options["decodingOptions"] as? [String: Any] ?? [:]
+                let includeNormalizedData = options["includeNormalizedData"] as? Bool ?? false
+                
+                // Pass both options separately - normalizeAudio from decodingOptions, and includeNormalizedData as is
+                let decodingConfig = DecodingConfig.fromDictionary(decodingOptions)
+                
+                let (pcmData, normalizedData, base64Data) = try extractRawAudioData(
+                    from: url,
+                    startFrame: startFrame,
+                    frameCount: frameCount,
+                    format: format,
+                    decodingConfig: decodingConfig,
+                    includeNormalizedData: includeNormalizedData,
+                    includeBase64Data: options["includeBase64Data"] as? Bool ?? false
+                )
+
+                var resultDict: [String: Any] = [:]
+                
+                if includeWavHeader {
+                    // Create WAV header and prepend it to the PCM data
+                    let wavData = createWavHeader(
+                        pcmData: pcmData,
+                        sampleRate: Int(sampleRate),
+                        channels: channels,
+                        bitDepth: bitDepth
+                    )
+                    resultDict["pcmData"] = wavData
+                    resultDict["hasWavHeader"] = true
+                } else {
+                    resultDict["pcmData"] = pcmData
+                    resultDict["hasWavHeader"] = false
+                }
+                
+                // Add the rest of the data
+                resultDict["sampleRate"] = Int(sampleRate)
+                resultDict["channels"] = channels
+                resultDict["bitDepth"] = bitDepth
+                resultDict["durationMs"] = Int(Double(frameCount) * 1000.0 / sampleRate)
+                resultDict["format"] = "pcm_\(bitDepth)bit"
+                resultDict["samples"] = Int(frameCount) * channels
+                
+                // Add normalized data if requested, regardless of normalization setting
+                if includeNormalizedData {
+                    resultDict["normalizedData"] = normalizedData
+                }
+                
+                // Add checksum if requested
+                if options["computeChecksum"] as? Bool == true {
+                    let checksum = calculateCRC32(data: pcmData)
+                    resultDict["checksum"] = Int(checksum)
+                    
+                    Logger.debug("Computed CRC32 checksum: \(checksum)")
+                }
+                
+                if let includeBase64Data = options["includeBase64Data"] as? Bool, includeBase64Data {
+                    resultDict["base64Data"] = base64Data
+                }
+                
+                promise.resolve(resultDict)
+
+            } catch {
+                promise.reject("PROCESSING_ERROR", "Failed to process audio file: \(error.localizedDescription)")
+            }
+        }
     }
     
     func audioStreamManager(_ manager: AudioStreamManager, didReceiveInterruption info: [String: Any]) {
@@ -582,7 +661,12 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
             "spectralBandwidth": options["spectralBandwidth"] as? Bool ?? false,
             "chromagram": options["chromagram"] as? Bool ?? false,
             "tempo": options["tempo"] as? Bool ?? false,
-            "hnr": options["hnr"] as? Bool ?? false
+            "hnr": options["hnr"] as? Bool ?? false,
+            "melSpectrogram": options["melSpectrogram"] as? Bool ?? false,
+            "spectralContrast": options["spectralContrast"] as? Bool ?? false,
+            "tonnetz": options["tonnetz"] as? Bool ?? false,
+            "pitch": options["pitch"] as? Bool ?? false,
+            "crc32": options["crc32"] as? Bool ?? false
         ]
     }
     

package/ios/FFT.swift

@@ -0,0 +1,62 @@
+//
+//  FFT.swift
+//  Pods
+//
+//  Created by Arthur Breton on 20/2/2025.
+//
+
+import Accelerate
+
+class FFT {
+    private let length: Int
+    private var setup: vDSP_DFT_Setup?
+    
+    init(_ length: Int) {
+        self.length = length
+        self.setup = vDSP_DFT_zop_CreateSetup(
+            nil,
+            vDSP_Length(length),
+            vDSP_DFT_Direction.FORWARD
+        )
+    }
+    
+    deinit {
+        if let setup = setup {
+            vDSP_DFT_DestroySetup(setup)
+        }
+    }
+    
+    func realForward(_ data: inout [Float]) {
+        var realIn = data
+        var imagIn = [Float](repeating: 0.0, count: length)
+        var realOut = [Float](repeating: 0.0, count: length)
+        var imagOut = [Float](repeating: 0.0, count: length)
+        
+        // Perform FFT
+        vDSP_DFT_Execute(setup!,
+                        &realIn,
+                        &imagIn,
+                        &realOut,
+                        &imagOut)
+        
+        // Ensure data array has enough space for both real and imaginary parts
+        if data.count < 2 * length {
+            data.append(contentsOf: [Float](repeating: 0.0, count: 2 * length - data.count))
+        }
+        
+        // Combine real and imaginary parts
+        for i in 0..<length {
+            let j = i * 2
+            data[j] = realOut[i]
+            data[j + 1] = imagOut[i]
+        }
+    }
+    
+    func processSegment(_ segment: [Float]) -> [Float] {
+        var fftData = segment.count < length ?
+            segment + [Float](repeating: 0, count: length - segment.count) :
+            Array(segment.prefix(length))
+        realForward(&fftData)
+        return fftData
+    }
+}

package/ios/Features.swift

@@ -21,6 +21,11 @@ public struct Features {
     var chromagram: [Float]?
     var tempo: Float?
     var hnr: Float?
+    var melSpectrogram: [Float]?
+    var spectralContrast: [Float]?
+    var tonnetz: [Float]?
+    var pitch: Float?
+    var crc32: UInt32?
     
     init(
         energy: Float = 0,
@@ -35,7 +40,12 @@ public struct Features {
         spectralBandwidth: Float? = nil,
         chromagram: [Float]? = nil,
         tempo: Float? = nil,
-        hnr: Float? = nil
+        hnr: Float? = nil,
+        melSpectrogram: [Float]? = nil,
+        spectralContrast: [Float]? = nil,
+        tonnetz: [Float]? = nil,
+        pitch: Float? = nil,
+        crc32: UInt32? = nil
     ) {
         self.energy = energy
         self.mfcc = mfcc
@@ -50,12 +60,17 @@ public struct Features {
         self.chromagram = chromagram
         self.tempo = tempo
         self.hnr = hnr
+        self.melSpectrogram = melSpectrogram
+        self.spectralContrast = spectralContrast
+        self.tonnetz = tonnetz
+        self.pitch = pitch
+        self.crc32 = crc32
     }
 }
 
 extension Features {
     func toDictionary() -> [String: Any] {
-        return [
+        var dict: [String: Any] = [
             "energy": energy,
             "mfcc": mfcc,
             "rms": rms,
@@ -68,7 +83,13 @@ extension Features {
             "spectralBandwidth": spectralBandwidth ?? 0,
             "chromagram": chromagram ?? [],
             "tempo": tempo ?? 0,
-            "hnr": hnr ?? 0
+            "hnr": hnr ?? 0,
+            "melSpectrogram": melSpectrogram ?? [],
+            "spectralContrast": spectralContrast ?? [],
+            "tonnetz": tonnetz ?? [],
+            "pitch": pitch ?? 0,
+            "crc32": crc32 ?? 0
         ]
+        return dict
     }
 }

package/ios/RecordingSettings.swift

@@ -88,9 +88,7 @@ struct RecordingSettings {
     var showNotification: Bool = false
     var enableProcessing: Bool = false
     
-    // Analysis settings
-    var pointsPerSecond: Int? = 1000
-    var algorithm: String? = "rms"
+    // Remove pointsPerSecond and algorithm
     var featureOptions: [String: Bool]? = ["rms": true, "zcr": true]
     
     // iOS-specific configuration
@@ -105,10 +103,12 @@ struct RecordingSettings {
     
     let autoResumeAfterInterruption: Bool
     
-    // Make these optional with nil default values
     var outputDirectory: String? = nil
     var filename: String? = nil
     
+    // Update default to 100ms
+    var segmentDurationMs: Int = 100  // Default 100ms segments
+    
     static func fromDictionary(_ dict: [String: Any]) -> Result<RecordingSettings, Error> {
         // Extract compression settings
         let compression = dict["compression"] as? [String: Any]
@@ -148,11 +148,11 @@ struct RecordingSettings {
         settings.showNotification = dict["showNotification"] as? Bool ?? false
         settings.enableProcessing = dict["enableProcessing"] as? Bool ?? false
         
-        // Parse analysis settings
-        settings.pointsPerSecond = dict["pointsPerSecond"] as? Int
-        settings.algorithm = dict["algorithm"] as? String
         settings.featureOptions = dict["features"] as? [String: Bool]
         
+        // Update segmentDurationMs parsing
+        settings.segmentDurationMs = dict["segmentDurationMs"] as? Int ?? 100
+        
         // Parse iOS-specific config
         if let iosDict = dict["ios"] as? [String: Any],
            let audioSessionDict = iosDict["audioSession"] as? [String: Any] {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siteed/expo-audio-stream",
-  "version": "1.17.0",
+  "version": "2.0.1",
   "description": "stream audio crossplatform",
   "license": "MIT",
   "main": "build/index.js",
@@ -105,6 +105,7 @@
   },
   "dependencies": {
     "@siteed/design-system": "^0.35.1",
+    "crc-32": "^1.2.2",
     "expo-modules-core": "~2.1.4"
   }
 }

package/plugin/build/index.js

@@ -48,7 +48,12 @@ const withRecordingPermission = (config, props) => {
         if (options.iosBackgroundModes?.useAudio === true &&
             enableBackgroundAudio === true &&
             !existingBackgroundModes.includes('audio')) {
-            existingBackgroundModes.push('audio');
+            // Don't automatically add 'audio' background mode as it's only for playback
+            // existingBackgroundModes.push('audio')
+            // Instead, ensure processing mode is used for background recording
+            if (options.iosBackgroundModes?.useProcessing !== true) {
+                console.warn(`${LOG_PREFIX} Warning: Background audio recording requires 'processing' background mode. Please enable 'useProcessing' in iosBackgroundModes.`);
+            }
         }
         if (options.iosBackgroundModes?.useVoIP === true &&
             enablePhoneStateHandling === true) {