@siteed/expo-audio-studio 2.18.6 → 3.0.0

package/ios/RecordingSettings.swift

@@ -1,308 +0,0 @@
-// RecordingSettings.swift
-
-import AVFoundation
-
-struct NotificationAction {
-    var title: String
-    var identifier: String
-}
-
-struct IOSAudioSessionConfig {
-    var category: AVAudioSession.Category
-    var mode: AVAudioSession.Mode
-    var categoryOptions: AVAudioSession.CategoryOptions
-}
-
-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
-    var bitrate: Int
-    var format: String
-    var size: Int64 = 0  // Add size with default value
-    
-    static func validate(format: String, bitrate: Int) -> Result<(String, Int), Error> {
-        // Validate format
-        guard ["aac", "opus"].contains(format.lowercased()) else {
-            return .failure(RecordingError.unsupportedFormat(format))
-        }
-        
-        // Adjust bitrate based on format
-        let adjustedBitrate: Int
-        if format.lowercased() == "aac" {
-            // Standard AAC bitrates (bps)
-            let standardAACBitrates = [32000, 48000, 64000, 96000, 128000, 160000, 192000, 256000, 320000]
-            adjustedBitrate = standardAACBitrates.min(by: { abs($0 - bitrate) < abs($1 - bitrate) }) ?? 128000
-        } else {
-            // For Opus, allow lower bitrates (especially good for voice)
-            // Typical Opus voice bitrates: 8-24 kbps, music: 32-128 kbps
-            adjustedBitrate = min(max(bitrate, 8000), 320000)
-        }
-        
-        return .success((format, adjustedBitrate))
-    }
-}
-
-struct NotificationConfig {
-    var title: String?
-    var text: String?
-    var icon: String?
-    var ios: IOSNotificationConfig?
-}
-
-struct IOSConfig {
-    var audioSession: IOSAudioSessionConfig?
-}
-
-enum RecordingError: Error {
-    case unsupportedFormat(String)
-    case invalidBitrate(Int)
-    case invalidOutputDirectory(String)
-    
-    var localizedDescription: String {
-        switch self {
-        case .unsupportedFormat(let format):
-            return "Unsupported compression format: \(format). iOS only supports AAC."
-        case .invalidBitrate(let bitrate):
-            return "Invalid bitrate: \(bitrate). Must be between 8000 and 960000 bps."
-        case .invalidOutputDirectory(let directory):
-            return "Invalid output directory: \(directory). Directory does not exist, is not a directory, or is not writable."
-        }
-    }
-}
-
-struct RecordingSettings {
-    // Core recording settings
-    var sampleRate: Double
-    var desiredSampleRate: Double
-    var numberOfChannels: Int = 1
-    var bitDepth: Int = 16
-    var interval: Int?
-    var intervalAnalysis: Int?
-    
-    // Feature flags
-    var keepAwake: Bool = true
-    var showNotification: Bool = false
-    var enableProcessing: Bool = false
-    
-    // Remove pointsPerSecond and algorithm
-    var featureOptions: [String: Bool]? = ["rms": true, "zcr": true]
-    
-    // iOS-specific configuration
-    var ios: IOSConfig?
-    
-    // Notification configuration
-    var notification: NotificationConfig?
-    
-    // Output configuration
-    var output: OutputSettings = OutputSettings()
-    
-    let autoResumeAfterInterruption: Bool
-    
-    var outputDirectory: String? = nil
-    var filename: String? = nil
-    
-    // Update default to 100ms
-    var segmentDurationMs: Int = 100  // Default 100ms segments
-    
-    // Add these new properties
-    var deviceId: String?
-    var deviceDisconnectionBehavior: DeviceDisconnectionBehavior = .FALLBACK
-    var bufferDurationSeconds: Double?
-    
-    static func fromDictionary(_ dict: [String: Any]) -> Result<RecordingSettings, Error> {
-        // Parse output configuration
-        var outputSettings = OutputSettings()
-        
-        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 deviceDisconnectionBehaviorStr = dict["deviceDisconnectionBehavior"] as? String
-        
-        // Create settings
-        var settings = RecordingSettings(
-            sampleRate: dict["sampleRate"] as? Double ?? 44100.0,
-            desiredSampleRate: dict["desiredSampleRate"] as? Double ?? 44100.0,
-            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
-        settings.interval = dict["interval"] as? Int
-        settings.intervalAnalysis = dict["intervalAnalysis"] as? Int
-        
-        // Parse feature flags
-        settings.keepAwake = dict["keepAwake"] as? Bool ?? true
-        settings.showNotification = dict["showNotification"] as? Bool ?? false
-        settings.enableProcessing = dict["enableProcessing"] as? Bool ?? false
-        
-        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] {
-            
-            // Map category
-            let category: AVAudioSession.Category
-            if let categoryStr = audioSessionDict["category"] as? String {
-                switch categoryStr {
-                    case "Ambient": category = .ambient
-                    case "SoloAmbient": category = .soloAmbient
-                    case "Playback": category = .playback
-                    case "Record": category = .record
-                    case "PlayAndRecord": category = .playAndRecord
-                    case "MultiRoute": category = .multiRoute
-                    default: category = .record
-                }
-            } else {
-                category = .record
-            }
-            
-            // Map mode
-            let mode: AVAudioSession.Mode
-            if let modeStr = audioSessionDict["mode"] as? String {
-                switch modeStr {
-                    case "Default": mode = .default
-                    case "VoiceChat": mode = .voiceChat
-                    case "VideoChat": mode = .videoChat
-                    case "GameChat": mode = .gameChat
-                    case "VideoRecording": mode = .videoRecording
-                    case "Measurement": mode = .measurement
-                    case "MoviePlayback": mode = .moviePlayback
-                    case "SpokenAudio": mode = .spokenAudio
-                    default: mode = .default
-                }
-            } else {
-                mode = .default
-            }
-            
-            // Map category options
-            var categoryOptions: AVAudioSession.CategoryOptions = []
-            if let optionsArray = audioSessionDict["categoryOptions"] as? [String] {
-                for option in optionsArray {
-                    switch option {
-                        case "MixWithOthers": categoryOptions.insert(.mixWithOthers)
-                        case "DuckOthers": categoryOptions.insert(.duckOthers)
-                        case "InterruptSpokenAudioAndMixWithOthers": categoryOptions.insert(.interruptSpokenAudioAndMixWithOthers)
-                        case "AllowBluetooth": categoryOptions.insert(.allowBluetooth)
-                        case "AllowBluetoothA2DP": categoryOptions.insert(.allowBluetoothA2DP)
-                        case "AllowAirPlay": categoryOptions.insert(.allowAirPlay)
-                        case "DefaultToSpeaker": categoryOptions.insert(.defaultToSpeaker)
-                        default: break
-                    }
-                }
-            }
-            
-            settings.ios = IOSConfig(audioSession: IOSAudioSessionConfig(
-                category: category,
-                mode: mode,
-                categoryOptions: categoryOptions
-            ))
-        }
-        
-        // Parse notification config
-        if let notificationDict = dict["notification"] as? [String: Any] {
-            var notificationConfig = NotificationConfig()
-            notificationConfig.title = notificationDict["title"] as? String
-            notificationConfig.text = notificationDict["text"] as? String
-            notificationConfig.icon = notificationDict["icon"] as? String
-            
-            // Parse iOS-specific notification config
-            if let iosNotificationDict = notificationDict["ios"] as? [String: Any] {
-                notificationConfig.ios = IOSNotificationConfig(
-                    categoryIdentifier: iosNotificationDict["categoryIdentifier"] as? String
-                )
-            }
-            
-            settings.notification = notificationConfig
-        }
-        
-        // Parse output settings (they remain nil if not provided)
-        if let directory = dict["outputDirectory"] as? String {
-            // Only validate if a custom directory is provided
-            let fileManager = FileManager.default
-            var isDirectory: ObjCBool = false
-            
-            // Clean up the directory path by removing file:// protocol if present
-            let cleanDirectory = directory.replacingOccurrences(of: "file://", with: "")
-                .trimmingCharacters(in: CharacterSet(charactersIn: "/"))
-                .replacingOccurrences(of: "//", with: "/")
-            
-            if !fileManager.fileExists(atPath: cleanDirectory, isDirectory: &isDirectory) {
-                return .failure(RecordingError.invalidOutputDirectory("Directory does not exist: \(cleanDirectory)"))
-            }
-            
-            if !isDirectory.boolValue {
-                return .failure(RecordingError.invalidOutputDirectory("Path is not a directory: \(cleanDirectory)"))
-            }
-            
-            if !fileManager.isWritableFile(atPath: cleanDirectory) {
-                return .failure(RecordingError.invalidOutputDirectory("Directory is not writable: \(cleanDirectory)"))
-            }
-            
-            settings.outputDirectory = cleanDirectory
-        }
-        
-        settings.filename = dict["filename"] as? String
-        
-        // Set new properties
-        settings.deviceId = deviceId
-        settings.deviceDisconnectionBehavior = DeviceDisconnectionBehavior(rawValue: deviceDisconnectionBehaviorStr ?? "fallback") ?? .FALLBACK
-        
-        if let bufferDuration = dict["bufferDurationSeconds"] as? Double {
-            settings.bufferDurationSeconds = bufferDuration
-        }
-        
-        return .success(settings)
-    }
-}

package/ios/WaveformExtractor.swift

@@ -1,105 +0,0 @@
-// WaveformExtractor.swift
-
-import Accelerate
-import AVFoundation
-
-/// This class is responsible for extracting waveform data from an audio file.
-public class WaveformExtractor {
-    public private(set) var audioFile: AVAudioFile?
-    private var result: (Any) -> Void
-    private var reject: (String, String) -> Void
-    private var waveformData = Array<Float>()
-    private var progress: Float = 0.0
-    private var channelCount: Int = 1
-    private var currentProgress: Float = 0.0
-    private let extractionQueue = DispatchQueue(label: "WaveformExtractor", attributes: .concurrent)
-    private var _abortWaveformExtraction: Bool = false
-
-    /// Indicates whether the waveform extraction process should be aborted.
-    public var abortWaveformExtraction: Bool {
-        get { _abortWaveformExtraction }
-        set { _abortWaveformExtraction = newValue }
-    }
-
-    /// Initializes the waveform extractor with an audio file URL, resolve, and reject callbacks.
-    ///
-    /// - Parameters:
-    ///   - url: The URL of the audio file to be read.
-    ///   - resolve: The callback to be called on successful extraction.
-    ///   - reject: The callback to be called on extraction failure.
-    public init(url: URL, resolve: @escaping (Any) -> Void, reject: @escaping (String, String) -> Void) throws {
-        self.audioFile = try AVAudioFile(forReading: url)
-        self.result = resolve
-        self.reject = reject
-    }
-
-    deinit {
-        audioFile = nil
-    }
-
-    /// Extracts the waveform data from the audio file.
-    ///
-    /// - Parameters:
-    ///   - numberOfSamples: The number of samples to extract for the waveform.
-    ///   - offset: The offset to start reading from.
-    ///   - length: The length of the audio to read.
-    /// - Returns: A 2D array of floats where each sub-array represents waveform data for a specific channel.
-    public func extractWaveform(numberOfSamples: Int?, offset: Int? = 0, length: UInt? = nil) -> [[Float]]? {
-        guard let audioFile = audioFile else { return nil }
-        
-        let numberOfSamples = max(1, numberOfSamples ?? 100)
-        let totalFrameCount = AVAudioFrameCount(audioFile.length)
-        var framesPerBuffer = totalFrameCount / AVAudioFrameCount(numberOfSamples)
-        
-        guard let rmsBuffer = AVAudioPCMBuffer(pcmFormat: audioFile.processingFormat, frameCapacity: AVAudioFrameCount(framesPerBuffer)) else { return nil }
-        
-        channelCount = Int(audioFile.processingFormat.channelCount)
-        var data = Array(repeating: [Float](repeating: 0, count: numberOfSamples), count: channelCount)
-        
-        var startFrame: AVAudioFramePosition = offset == nil ? audioFile.framePosition : Int64(offset! * Int(framesPerBuffer))
-        var end = numberOfSamples
-        if let length = length {
-            end = Int(length)
-        }
-        
-        for i in 0..<end {
-            if abortWaveformExtraction {
-                audioFile.framePosition = startFrame
-                abortWaveformExtraction = false
-                return nil
-            }
-            
-            do {
-                audioFile.framePosition = startFrame
-                try audioFile.read(into: rmsBuffer, frameCount: framesPerBuffer)
-            } catch {
-                reject("AUDIO_READ_ERROR", "Couldn't read into buffer")
-                return nil
-            }
-            
-            guard let floatData = rmsBuffer.floatChannelData else { return nil }
-            
-            for channel in 0..<channelCount {
-                var rms: Float = 0.0
-                vDSP_rmsqv(floatData[channel], 1, &rms, vDSP_Length(rmsBuffer.frameLength))
-                data[channel][i] = rms
-            }
-            
-            currentProgress += 1
-            progress = currentProgress / Float(numberOfSamples)
-            
-            startFrame += AVAudioFramePosition(framesPerBuffer)
-            if startFrame + AVAudioFramePosition(framesPerBuffer) > AVAudioFramePosition(totalFrameCount) {
-                framesPerBuffer = totalFrameCount - AVAudioFrameCount(startFrame)
-                if framesPerBuffer <= 0 { break }
-            }
-        }
-        
-        return data
-    }
-
-    /// Cancels the waveform extraction process.
-    public func cancel() {
-        abortWaveformExtraction = true
-    }
-}

package/ios/tests/README.md

@@ -1,41 +0,0 @@
-# iOS Audio Format Tests
-
-This directory contains test scripts for validating audio format support on iOS/macOS.
-
-## Opus Support Test
-
-The `opus_support_test_macos.swift` script verifies that while `kAudioFormatOpus` is defined in the iOS SDK, AVAudioRecorder cannot actually encode Opus audio.
-
-### Running the Test
-
-```bash
-# On macOS (for quick validation)
-swift opus_support_test_macos.swift
-
-# On iOS device/simulator (requires Xcode)
-# Copy the test to an iOS project and run it
-```
-
-### Test Results
-
-- ✅ `kAudioFormatOpus` constant exists (value: 1869641075)
-- ✅ AVAudioRecorder accepts Opus settings without errors
-- ❌ Recording produces 0-byte files (no actual encoding)
-- ✅ AAC format works correctly as fallback
-
-### Why This Matters
-
-This test proves that expo-audio-studio's automatic fallback from Opus to AAC on iOS is necessary and correct. Despite the SDK defining the Opus format constant, the actual encoding functionality is not implemented in AVAudioRecorder.
-
-## Format Verification
-
-To verify actual file formats:
-
-```bash
-# Check file type
-file recording.m4a  # Should show: ISO Media, MP4 Base Media
-file recording.aac  # Should show: ADTS, AAC
-
-# Get detailed info (requires mediainfo)
-mediainfo recording.m4a
-```

package/ios/tests/integration/buffer_and_fallback_test.swift

@@ -1,178 +0,0 @@
-#!/usr/bin/env swift
-
-import Foundation
-import AVFoundation
-
-// Integration test for validating buffer size calculation and fallback behavior fixes
-// Tests issues #246 and #247
-
-print("🧪 Buffer Size Calculation and Fallback Integration Test")
-print("======================================================\n")
-
-class BufferAndFallbackTest {
-    let audioEngine = AVAudioEngine()
-    var results: [(name: String, passed: Bool, message: String)] = []
-    var emissionCount = 0
-    var lastEmissionData: Data?
-    
-    func runAllTests() {
-        testBufferSizeCalculation()
-        testFallbackWithoutDuplication()
-        printResults()
-    }
-    
-    func testBufferSizeCalculation() {
-        print("Test 1: Buffer Size Calculation with Target Sample Rate")
-        print("-------------------------------------------------------")
-        print("Testing that buffer size is calculated based on target sample rate, not hardware rate")
-        
-        let inputNode = audioEngine.inputNode
-        let hardwareFormat = inputNode.inputFormat(forBus: 0)
-        let hardwareSampleRate = hardwareFormat.sampleRate
-        
-        print("Hardware sample rate: \(hardwareSampleRate) Hz")
-        
-        // Test case: 0.02 seconds at 16000 Hz should request 320 frames
-        let targetSampleRate: Double = 16000
-        let bufferDuration: Double = 0.02
-        let expectedRequestedFrames = AVAudioFrameCount(bufferDuration * targetSampleRate)
-        
-        print("Target sample rate: \(targetSampleRate) Hz")
-        print("Buffer duration: \(bufferDuration) seconds")
-        print("Expected requested frames: \(expectedRequestedFrames)")
-        
-        // Since iOS enforces minimum ~4800 frames, we expect either 4800 or our requested size
-        let _ : AVAudioFrameCount = max(4800, expectedRequestedFrames)
-        
-        let expectation = DispatchSemaphore(value: 0)
-        var receivedFrames: AVAudioFrameCount = 0
-        
-        inputNode.installTap(onBus: 0, bufferSize: expectedRequestedFrames, format: hardwareFormat) { 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)
-        
-        // The key test: verify that we calculated based on target rate (320 frames), not hardware rate
-        let wouldHaveBeenWithHardwareRate = AVAudioFrameCount(bufferDuration * hardwareSampleRate)
-        let usedTargetRate = expectedRequestedFrames == 320
-        
-        results.append((
-            name: "Buffer Size Calculation",
-            passed: usedTargetRate,
-            message: "Used target rate: \(usedTargetRate), Requested: \(expectedRequestedFrames) frames (would be \(wouldHaveBeenWithHardwareRate) with hardware rate)"
-        ))
-        
-        print("✓ Requested frames: \(expectedRequestedFrames) (calculated from target rate)")
-        print("✓ Would have been: \(wouldHaveBeenWithHardwareRate) frames (if using hardware rate)")
-        print("✓ Actually received: \(receivedFrames) frames (iOS minimum enforced)\n")
-    }
-    
-    func testFallbackWithoutDuplication() {
-        print("Test 2: Fallback Without Data Duplication")
-        print("-----------------------------------------")
-        print("Simulating device fallback scenario to ensure no duplicate emissions")
-        
-        // Reset counters
-        emissionCount = 0
-        lastEmissionData = nil
-        
-        let inputNode = audioEngine.inputNode
-        let format = inputNode.inputFormat(forBus: 0)
-        
-        // Simulate a tap that counts emissions
-        var bufferCount = 0
-        let expectation = DispatchSemaphore(value: 0)
-        
-        inputNode.installTap(onBus: 0, bufferSize: 1024, format: format) { [weak self] buffer, _ in
-            guard let self = self else { return }
-            
-            bufferCount += 1
-            
-            // Simulate emission logic
-            let audioData = buffer.audioBufferList.pointee.mBuffers
-            if let bufferData = audioData.mData {
-                let data = Data(bytes: bufferData, count: Int(audioData.mDataByteSize))
-                
-                // Check if this is the same data as last emission
-                if let lastData = self.lastEmissionData, lastData == data {
-                    print("⚠️  Detected duplicate emission!")
-                }
-                
-                self.lastEmissionData = data
-                self.emissionCount += 1
-            }
-            
-            if bufferCount >= 10 {
-                expectation.signal()
-            }
-        }
-        
-        audioEngine.prepare()
-        do {
-            try audioEngine.start()
-            _ = expectation.wait(timeout: .now() + 3)
-            audioEngine.stop()
-        } catch {
-            print("Error: \(error)")
-        }
-        
-        inputNode.removeTap(onBus: 0)
-        
-        // With the fix, emission count should equal buffer count (no duplicates)
-        let noDuplicates = emissionCount == bufferCount
-        
-        results.append((
-            name: "Fallback No Duplication",
-            passed: noDuplicates,
-            message: "Buffers: \(bufferCount), Emissions: \(emissionCount), No duplicates: \(noDuplicates)"
-        ))
-        
-        print("✓ Processed \(bufferCount) buffers")
-        print("✓ Emitted \(emissionCount) times")
-        print("✓ No duplicate emissions: \(noDuplicates)\n")
-    }
-    
-    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!")
-            print("\n✅ Issue #247 (Buffer Size Calculation) - FIXED")
-            print("✅ Issue #246 (Duplicate Emissions) - Validation Ready")
-        } else {
-            print("⚠️  Some tests failed")
-        }
-        
-        print("\n📝 Key Validations:")
-        print("- Buffer size is now calculated using target sample rate")
-        print("- iOS minimum buffer size (~4800 frames) is properly handled")
-        print("- Fallback behavior ready for duplicate emission testing")
-    }
-}
-
-// Run the test
-let test = BufferAndFallbackTest()
-test.runAllTests()