@siteed/expo-audio-studio 2.9.0 → 2.10.1

package/ios/ExpoAudioStudioTests/AudioTestHelpers.swift

@@ -0,0 +1,130 @@
+import Foundation
+import AVFoundation
+import Accelerate
+
+extension AVAudioPCMBuffer {
+    
+    /// Convert buffer to Data
+    func toData() -> Data {
+        let audioFormat = self.format
+        let channelCount = Int(audioFormat.channelCount)
+        let frameLength = Int(self.frameLength)
+        
+        var data = Data()
+        
+        if let floatData = self.floatChannelData {
+            // Convert float samples to 16-bit PCM
+            for frame in 0..<frameLength {
+                for channel in 0..<channelCount {
+                    let sample = floatData[channel][frame]
+                    let int16Sample = Int16(max(-32768, min(32767, sample * 32767)))
+                    data.append(contentsOf: withUnsafeBytes(of: int16Sample) { Array($0) })
+                }
+            }
+        } else if let int16Data = self.int16ChannelData {
+            // Already 16-bit, just copy
+            for frame in 0..<frameLength {
+                for channel in 0..<channelCount {
+                    let sample = int16Data[channel][frame]
+                    data.append(contentsOf: withUnsafeBytes(of: sample) { Array($0) })
+                }
+            }
+        }
+        
+        return data
+    }
+    
+    /// Calculate RMS (Root Mean Square) of the buffer
+    func rms() -> Float {
+        guard let channelData = self.floatChannelData else { return 0 }
+        
+        let channelCount = Int(self.format.channelCount)
+        let frameLength = Int(self.frameLength)
+        
+        var sum: Float = 0
+        var sampleCount = 0
+        
+        for channel in 0..<channelCount {
+            for frame in 0..<frameLength {
+                let sample = channelData[channel][frame]
+                sum += sample * sample
+                sampleCount += 1
+            }
+        }
+        
+        return sqrt(sum / Float(sampleCount))
+    }
+    
+    /// Calculate energy of the buffer
+    func energy() -> Float {
+        guard let channelData = self.floatChannelData else { return 0 }
+        
+        let channelCount = Int(self.format.channelCount)
+        let frameLength = Int(self.frameLength)
+        
+        var sum: Float = 0
+        
+        for channel in 0..<channelCount {
+            for frame in 0..<frameLength {
+                let sample = channelData[channel][frame]
+                sum += sample * sample
+            }
+        }
+        
+        return sum
+    }
+}
+
+extension Data {
+    
+    /// Convert PCM data to float array
+    func toFloatArray(bitDepth: Int = 16) -> [Float] {
+        var floats = [Float]()
+        
+        switch bitDepth {
+        case 16:
+            let samples = self.withUnsafeBytes { $0.bindMemory(to: Int16.self) }
+            for sample in samples {
+                floats.append(Float(sample) / Float(Int16.max))
+            }
+        case 32:
+            let samples = self.withUnsafeBytes { $0.bindMemory(to: Int32.self) }
+            for sample in samples {
+                floats.append(Float(sample) / Float(Int32.max))
+            }
+        default:
+            break
+        }
+        
+        return floats
+    }
+    
+    /// Calculate RMS from PCM data
+    func rms(bitDepth: Int = 16) -> Float {
+        let floats = toFloatArray(bitDepth: bitDepth)
+        guard !floats.isEmpty else { return 0 }
+        
+        let sum = floats.reduce(0) { $0 + $1 * $1 }
+        return sqrt(sum / Float(floats.count))
+    }
+    
+    /// Calculate energy from PCM data
+    func energy(bitDepth: Int = 16) -> Float {
+        let floats = toFloatArray(bitDepth: bitDepth)
+        return floats.reduce(0) { $0 + $1 * $1 }
+    }
+}
+
+// Test assertion helpers
+extension XCTestCase {
+    
+    /// Assert two float values are approximately equal
+    func XCTAssertApproximatelyEqual(_ value1: Float, _ value2: Float, tolerance: Float = 0.0001, _ message: String = "", file: StaticString = #file, line: UInt = #line) {
+        XCTAssertLessThanOrEqual(abs(value1 - value2), tolerance, message, file: file, line: line)
+    }
+    
+    /// Assert two double values are approximately equal
+    func XCTAssertApproximatelyEqual(_ value1: Double, _ value2: Double, tolerance: Double = 0.0001, _ message: String = "", file: StaticString = #file, line: UInt = #line) {
+        XCTAssertLessThanOrEqual(abs(value1 - value2), tolerance, message, file: file, line: line)
+    }
+} 

package/ios/ExpoAudioStudioTests/Info.plist

@@ -0,0 +1,22 @@
+<?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>CFBundleDevelopmentRegion</key>
+    <string>$(DEVELOPMENT_LANGUAGE)</string>
+    <key>CFBundleExecutable</key>
+    <string>$(EXECUTABLE_NAME)</string>
+    <key>CFBundleIdentifier</key>
+    <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>$(PRODUCT_NAME)</string>
+    <key>CFBundlePackageType</key>
+    <string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+</dict>
+</plist> 

package/ios/ExpoAudioStudioTests/SimpleAudioTest.swift

@@ -0,0 +1,98 @@
+import XCTest
+import AVFoundation
+
+class SimpleAudioTest: XCTestCase {
+    
+    func testCreateWAVHeader() {
+        // Test creating a basic WAV header
+        let sampleRate = 44100
+        let channels = 2
+        let bitsPerSample = 16
+        let dataSize = 1024
+        
+        // Calculate expected values
+        let byteRate = sampleRate * channels * (bitsPerSample / 8)
+        let blockAlign = channels * (bitsPerSample / 8)
+        
+        // Create header data manually (44 bytes)
+        var header = Data()
+        
+        // RIFF chunk
+        header.append("RIFF".data(using: .ascii)!)
+        var fileSize = UInt32(dataSize + 36).littleEndian
+        header.append(Data(bytes: &fileSize, count: 4))
+        header.append("WAVE".data(using: .ascii)!)
+        
+        // fmt chunk
+        header.append("fmt ".data(using: .ascii)!)
+        var fmtSize = UInt32(16).littleEndian
+        header.append(Data(bytes: &fmtSize, count: 4))
+        var audioFormat = UInt16(1).littleEndian // PCM
+        header.append(Data(bytes: &audioFormat, count: 2))
+        var numChannels = UInt16(channels).littleEndian
+        header.append(Data(bytes: &numChannels, count: 2))
+        var sampleRateValue = UInt32(sampleRate).littleEndian
+        header.append(Data(bytes: &sampleRateValue, count: 4))
+        var byteRateValue = UInt32(byteRate).littleEndian
+        header.append(Data(bytes: &byteRateValue, count: 4))
+        var blockAlignValue = UInt16(blockAlign).littleEndian
+        header.append(Data(bytes: &blockAlignValue, count: 2))
+        var bitsPerSampleValue = UInt16(bitsPerSample).littleEndian
+        header.append(Data(bytes: &bitsPerSampleValue, count: 2))
+        
+        // data chunk
+        header.append("data".data(using: .ascii)!)
+        var dataSizeValue = UInt32(dataSize).littleEndian
+        header.append(Data(bytes: &dataSizeValue, count: 4))
+        
+        // Verify header size
+        XCTAssertEqual(header.count, 44, "WAV header should be 44 bytes")
+        
+        // Verify RIFF header
+        let riffHeader = String(data: header[0..<4], encoding: .ascii)
+        XCTAssertEqual(riffHeader, "RIFF")
+        
+        // Verify WAVE format
+        let waveFormat = String(data: header[8..<12], encoding: .ascii)
+        XCTAssertEqual(waveFormat, "WAVE")
+        
+        print("✅ Basic WAV header test passed!")
+    }
+    
+    func testSimpleAudioBuffer() {
+        // Test creating a simple audio buffer
+        let sampleRate = 44100.0
+        let duration = 0.1 // 100ms
+        let frequency = 440.0 // A4 note
+        
+        let frameCount = Int(sampleRate * duration)
+        let format = AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 1)!
+        
+        guard let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: AVAudioFrameCount(frameCount)) else {
+            XCTFail("Failed to create audio buffer")
+            return
+        }
+        
+        buffer.frameLength = AVAudioFrameCount(frameCount)
+        
+        // Generate a simple sine wave
+        let channelData = buffer.floatChannelData![0]
+        for frame in 0..<frameCount {
+            let phase = 2.0 * Double.pi * frequency * Double(frame) / sampleRate
+            channelData[frame] = Float(sin(phase) * 0.5)
+        }
+        
+        // Verify buffer properties
+        XCTAssertEqual(buffer.frameLength, AVAudioFrameCount(frameCount))
+        XCTAssertEqual(buffer.format.sampleRate, sampleRate)
+        XCTAssertEqual(buffer.format.channelCount, 1)
+        
+        // Verify we have audio data
+        let firstSample = channelData[0]
+        let lastSample = channelData[frameCount - 1]
+        XCTAssertNotEqual(firstSample, 0.0, accuracy: 0.001)
+        XCTAssertNotEqual(lastSample, firstSample, accuracy: 0.001)
+        
+        print("✅ Simple audio buffer test passed!")
+    }
+} 

package/ios/ExpoAudioStudioTests/TestAudioGenerator.swift

@@ -0,0 +1,75 @@
+import Foundation
+import AVFoundation
+import Accelerate
+
+class TestAudioGenerator {
+    
+    /// Generate a sine wave tone
+    static func generateTone(frequency: Double, duration: TimeInterval, sampleRate: Double = 44100) -> AVAudioPCMBuffer? {
+        let frameCount = AVAudioFrameCount(duration * sampleRate)
+        
+        guard let buffer = AVAudioPCMBuffer(pcmFormat: AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 1)!, frameCapacity: frameCount) else {
+            return nil
+        }
+        
+        buffer.frameLength = frameCount
+        
+        let channelData = buffer.floatChannelData![0]
+        let angleIncrement = 2.0 * .pi * frequency / sampleRate
+        
+        for frame in 0..<Int(frameCount) {
+            channelData[frame] = Float(sin(Double(frame) * angleIncrement))
+        }
+        
+        return buffer
+    }
+    
+    /// Generate white noise
+    static func generateWhiteNoise(duration: TimeInterval, sampleRate: Double = 44100) -> AVAudioPCMBuffer? {
+        let frameCount = AVAudioFrameCount(duration * sampleRate)
+        
+        guard let buffer = AVAudioPCMBuffer(pcmFormat: AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 1)!, frameCapacity: frameCount) else {
+            return nil
+        }
+        
+        buffer.frameLength = frameCount
+        
+        let channelData = buffer.floatChannelData![0]
+        
+        for frame in 0..<Int(frameCount) {
+            channelData[frame] = Float.random(in: -1...1)
+        }
+        
+        return buffer
+    }
+    
+    /// Load test asset from bundle
+    static func loadTestAsset(named name: String) -> AVAudioFile? {
+        guard let url = Bundle(for: TestAudioGenerator.self).url(forResource: name, withExtension: "wav") else {
+            return nil
+        }
+        
+        return try? AVAudioFile(forReading: url)
+    }
+    
+    /// Convert AVAudioPCMBuffer to Data
+    static func bufferToData(_ buffer: AVAudioPCMBuffer) -> Data? {
+        guard let channelData = buffer.floatChannelData else { return nil }
+        
+        let channelCount = Int(buffer.format.channelCount)
+        let frameLength = Int(buffer.frameLength)
+        let bytesPerFrame = 2 * channelCount // 16-bit audio
+        
+        var data = Data(capacity: frameLength * bytesPerFrame)
+        
+        for frame in 0..<frameLength {
+            for channel in 0..<channelCount {
+                let sample = channelData[channel][frame]
+                let int16Sample = Int16(max(-32768, min(32767, sample * 32767)))
+                data.append(contentsOf: withUnsafeBytes(of: int16Sample) { Array($0) })
+            }
+        }
+        
+        return data
+    }
+} 

package/ios/RecordingSettings.swift

@@ -17,6 +17,22 @@ struct IOSNotificationConfig {
     var categoryIdentifier: String?
 }
 
+struct OutputSettings {
+    struct PrimaryOutput {
+        var enabled: Bool = true
+        var format: String = "wav"  // Currently only "wav" is supported
+    }
+    
+    struct CompressedOutput {
+        var enabled: Bool = false
+        var format: String = "aac"  // "aac" or "opus" (opus falls back to aac on iOS)
+        var bitrate: Int = 128000
+    }
+    
+    var primary: PrimaryOutput = PrimaryOutput()
+    var compressed: CompressedOutput = CompressedOutput()
+}
+
 struct CompressedRecordingInfo {
     var compressedFileUri: String
     var mimeType: String
@@ -97,9 +113,8 @@ struct RecordingSettings {
     // Notification configuration
     var notification: NotificationConfig?
     
-    let enableCompressedOutput: Bool
-    let compressedFormat: String // "aac" or "opus"
-    let compressedBitRate: Int
+    // Output configuration
+    var output: OutputSettings = OutputSettings()
     
     let autoResumeAfterInterruption: Bool
     
@@ -111,40 +126,52 @@ struct RecordingSettings {
     
     // Add these new properties
     var deviceId: String?
-    var deviceDisconnectionBehavior: String?
+    var deviceDisconnectionBehavior: DeviceDisconnectionBehavior = .FALLBACK
+    var bufferDurationSeconds: Double?
     
     static func fromDictionary(_ dict: [String: Any]) -> Result<RecordingSettings, Error> {
-        // Extract compression settings
-        let compression = dict["compression"] as? [String: Any]
-        let enableCompressedOutput = compression?["enabled"] as? Bool ?? false
-        let compressedFormat = (compression?["format"] as? String)?.lowercased() ?? "opus"
-        let compressedBitRate = compression?["bitrate"] as? Int ?? 24000
+        // Parse output configuration
+        var outputSettings = OutputSettings()
         
-        // Validate compression settings if enabled
-        if enableCompressedOutput {
-            // Validate format and bitrate
-            if case .failure(let error) = CompressedRecordingInfo.validate(
-                format: compressedFormat,
-                bitrate: compressedBitRate
-            ) {
-                return .failure(error)
+        if let outputDict = dict["output"] as? [String: Any] {
+            // Parse primary output settings
+            if let primaryDict = outputDict["primary"] as? [String: Any] {
+                outputSettings.primary.enabled = primaryDict["enabled"] as? Bool ?? true
+                outputSettings.primary.format = primaryDict["format"] as? String ?? "wav"
+            }
+            
+            // Parse compressed output settings
+            if let compressedDict = outputDict["compressed"] as? [String: Any] {
+                outputSettings.compressed.enabled = compressedDict["enabled"] as? Bool ?? false
+                let format = (compressedDict["format"] as? String)?.lowercased() ?? "aac"
+                outputSettings.compressed.format = format
+                outputSettings.compressed.bitrate = compressedDict["bitrate"] as? Int ?? 128000
+                
+                // Validate compression settings if enabled
+                if outputSettings.compressed.enabled {
+                    if case .failure(let error) = CompressedRecordingInfo.validate(
+                        format: format,
+                        bitrate: outputSettings.compressed.bitrate
+                    ) {
+                        return .failure(error)
+                    }
+                }
             }
         }
         
         // Add extraction of new properties
         let deviceId = dict["deviceId"] as? String
-        let deviceDisconnectionBehavior = dict["deviceDisconnectionBehavior"] as? String
+        let deviceDisconnectionBehaviorStr = dict["deviceDisconnectionBehavior"] as? String
         
         // Create settings
         var settings = RecordingSettings(
             sampleRate: dict["sampleRate"] as? Double ?? 44100.0,
             desiredSampleRate: dict["desiredSampleRate"] as? Double ?? 44100.0,
-            enableCompressedOutput: enableCompressedOutput,
-            compressedFormat: compressedFormat,
-            compressedBitRate: compressedBitRate,
             autoResumeAfterInterruption: dict["autoResumeAfterInterruption"] as? Bool ?? false
         )
         
+        settings.output = outputSettings
+        
         // Parse core settings
         settings.numberOfChannels = dict["channels"] as? Int ?? 1
         settings.bitDepth = dict["bitDepth"] as? Int ?? 16
@@ -270,7 +297,11 @@ struct RecordingSettings {
         
         // Set new properties
         settings.deviceId = deviceId
-        settings.deviceDisconnectionBehavior = deviceDisconnectionBehavior
+        settings.deviceDisconnectionBehavior = DeviceDisconnectionBehavior(rawValue: deviceDisconnectionBehaviorStr ?? "fallback") ?? .FALLBACK
+        
+        if let bufferDuration = dict["bufferDurationSeconds"] as? Double {
+            settings.bufferDurationSeconds = bufferDuration
+        }
         
         return .success(settings)
     }

package/ios/tests/integration/buffer_duration_test.swift

@@ -0,0 +1,185 @@
+#!/usr/bin/env swift
+
+import Foundation
+import AVFoundation
+
+// Integration test for Buffer Duration feature
+// This tests the ACTUAL behavior of AVAudioEngine with different buffer sizes
+
+print("🧪 Buffer Duration Integration Test")
+print("===================================\n")
+
+class BufferDurationTest {
+    let audioEngine = AVAudioEngine()
+    var results: [(name: String, passed: Bool, message: String)] = []
+    
+    func runAllTests() {
+        testDefaultBufferSize()
+        testCustomBufferSizes()
+        testBufferSizeLimits()
+        printResults()
+    }
+    
+    func testDefaultBufferSize() {
+        print("Test 1: Default Buffer Size (1024 frames requested)")
+        print("-------------------------------------------------")
+        
+        let inputNode = audioEngine.inputNode
+        let expectation = DispatchSemaphore(value: 0)
+        var receivedFrames: AVAudioFrameCount = 0
+        
+        inputNode.installTap(onBus: 0, bufferSize: 1024, format: inputNode.inputFormat(forBus: 0)) { buffer, _ in
+            receivedFrames = buffer.frameLength
+            expectation.signal()
+        }
+        
+        audioEngine.prepare()
+        do {
+            try audioEngine.start()
+            _ = expectation.wait(timeout: .now() + 2)
+            audioEngine.stop()
+        } catch {
+            print("Error: \(error)")
+        }
+        
+        inputNode.removeTap(onBus: 0)
+        
+        // iOS enforces minimum of ~4800 frames
+        let passed = receivedFrames >= 4800
+        results.append((
+            name: "Default Buffer Size",
+            passed: passed,
+            message: "Requested: 1024, Received: \(receivedFrames) frames (iOS minimum: ~4800)"
+        ))
+        
+        print("✓ Requested: 1024 frames")
+        print("✓ Received: \(receivedFrames) frames")
+        print("✓ iOS enforces minimum buffer size\n")
+    }
+    
+    func testCustomBufferSizes() {
+        print("Test 2: Custom Buffer Sizes")
+        print("---------------------------")
+        
+        let inputNode = audioEngine.inputNode
+        let sampleRate = inputNode.inputFormat(forBus: 0).sampleRate
+        
+        let testCases: [(duration: Double, name: String)] = [
+            (0.01, "10ms"),
+            (0.05, "50ms"),
+            (0.1, "100ms"),
+            (0.2, "200ms"),
+            (0.5, "500ms")
+        ]
+        
+        for testCase in testCases {
+            let requestedFrames = AVAudioFrameCount(testCase.duration * sampleRate)
+            let expectation = DispatchSemaphore(value: 0)
+            var receivedFrames: AVAudioFrameCount = 0
+            
+            inputNode.removeTap(onBus: 0)
+            inputNode.installTap(onBus: 0, bufferSize: requestedFrames, format: inputNode.inputFormat(forBus: 0)) { buffer, _ in
+                receivedFrames = buffer.frameLength
+                expectation.signal()
+            }
+            
+            do {
+                try audioEngine.start()
+                _ = expectation.wait(timeout: .now() + 2)
+                audioEngine.stop()
+            } catch {
+                print("Error: \(error)")
+            }
+            
+            let expectedFrames: AVAudioFrameCount = requestedFrames < 4800 ? 4800 : requestedFrames
+            let tolerance: AVAudioFrameCount = expectedFrames > 10000 ? AVAudioFrameCount(Double(expectedFrames) * 0.2) : 100
+            let passed = abs(Int32(receivedFrames) - Int32(expectedFrames)) <= Int32(tolerance)
+            
+            results.append((
+                name: "Buffer \(testCase.name)",
+                passed: passed,
+                message: "Requested: \(requestedFrames), Expected: \(expectedFrames), Received: \(receivedFrames)"
+            ))
+            
+            print("  \(testCase.name): Requested \(requestedFrames) → Received \(receivedFrames) frames")
+        }
+        
+        inputNode.removeTap(onBus: 0)
+        print()
+    }
+    
+    func testBufferSizeLimits() {
+        print("Test 3: Buffer Size Limits")
+        print("--------------------------")
+        
+        let inputNode = audioEngine.inputNode
+        
+        let extremeCases: [(size: AVAudioFrameCount, name: String)] = [
+            (100, "Very small (100 frames)"),
+            (50000, "Very large (50000 frames)")
+        ]
+        
+        for testCase in extremeCases {
+            let expectation = DispatchSemaphore(value: 0)
+            var receivedFrames: AVAudioFrameCount = 0
+            
+            inputNode.removeTap(onBus: 0)
+            inputNode.installTap(onBus: 0, bufferSize: testCase.size, format: inputNode.inputFormat(forBus: 0)) { buffer, _ in
+                receivedFrames = buffer.frameLength
+                expectation.signal()
+            }
+            
+            do {
+                try audioEngine.start()
+                _ = expectation.wait(timeout: .now() + 2)
+                audioEngine.stop()
+            } catch {
+                print("Error: \(error)")
+            }
+            
+            let passed = receivedFrames >= 4800 && receivedFrames <= 50000
+            results.append((
+                name: testCase.name,
+                passed: passed,
+                message: "Requested: \(testCase.size), Received: \(receivedFrames)"
+            ))
+            
+            print("  \(testCase.name): \(testCase.size) → \(receivedFrames) frames")
+        }
+        
+        inputNode.removeTap(onBus: 0)
+        print()
+    }
+    
+    func printResults() {
+        print("📊 Test Results")
+        print("===============")
+        
+        let passed = results.filter { $0.passed }.count
+        let total = results.count
+        
+        for result in results {
+            let status = result.passed ? "✅" : "❌"
+            print("\(status) \(result.name)")
+            print("   \(result.message)")
+        }
+        
+        print("\nSummary: \(passed)/\(total) tests passed")
+        
+        if passed == total {
+            print("🎉 All tests passed!")
+        } else {
+            print("⚠️  Some tests failed")
+        }
+        
+        print("\n📝 Key Findings:")
+        print("- iOS AVAudioEngine enforces a minimum buffer size of ~4800 frames")
+        print("- Requests below 4800 frames are ignored")
+        print("- Larger buffer sizes generally work as requested")
+        print("- Buffer accumulation is needed for small buffer durations")
+    }
+}
+
+// Run the test
+let test = BufferDurationTest()
+test.runAllTests()