@siteed/expo-audio-studio 2.8.6 → 2.10.0

package/ios/ExpoAudioStudioTests/AudioFormatUtilsTests.swift

@@ -0,0 +1,331 @@
+import XCTest
+import AVFoundation
+import Accelerate
+@testable import ExpoAudioStream
+
+class AudioFormatUtilsTests: XCTestCase {
+    
+    // MARK: - Bit Depth Conversion Tests
+    
+    func testConvertBitDepth_8to16() {
+        // Given
+        let input8bit: [UInt8] = [0, 64, 128, 192, 255]
+        let expected16bit: [Int16] = [-32768, -16384, 0, 16384, 32767]
+        
+        // When
+        let result = AudioFormatUtils.convertBitDepth(
+            data: Data(input8bit),
+            fromBitDepth: 8,
+            toBitDepth: 16
+        )
+        
+        // Then
+        let result16bit = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
+        XCTAssertEqual(result16bit, expected16bit)
+    }
+    
+    func testConvertBitDepth_16to8() {
+        // Given
+        let input16bit: [Int16] = [-32768, -16384, 0, 16384, 32767]
+        let expected8bit: [UInt8] = [0, 64, 128, 192, 255]
+        
+        // When
+        var data = Data()
+        input16bit.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
+        
+        let result = AudioFormatUtils.convertBitDepth(
+            data: data,
+            fromBitDepth: 16,
+            toBitDepth: 8
+        )
+        
+        // Then
+        let result8bit = Array(result)
+        XCTAssertEqual(result8bit, expected8bit)
+    }
+    
+    func testConvertBitDepth_16to32() {
+        // Given
+        let input16bit: [Int16] = [-32768, 0, 32767]
+        let expected32bit: [Int32] = [-2147483648, 0, 2147483647]
+        
+        // When
+        var data = Data()
+        input16bit.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
+        
+        let result = AudioFormatUtils.convertBitDepth(
+            data: data,
+            fromBitDepth: 16,
+            toBitDepth: 32
+        )
+        
+        // Then
+        let result32bit = result.withUnsafeBytes { Array($0.bindMemory(to: Int32.self)) }
+        XCTAssertEqual(result32bit, expected32bit)
+    }
+    
+    func testConvertBitDepth_32to16() {
+        // Given
+        let input32bit: [Int32] = [-2147483648, 0, 2147483647]
+        let expected16bit: [Int16] = [-32768, 0, 32767]
+        
+        // When
+        var data = Data()
+        input32bit.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
+        
+        let result = AudioFormatUtils.convertBitDepth(
+            data: data,
+            fromBitDepth: 32,
+            toBitDepth: 16
+        )
+        
+        // Then
+        let result16bit = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
+        XCTAssertEqual(result16bit, expected16bit)
+    }
+    
+    func testConvertBitDepth_sameDepth() {
+        // Given
+        let input: [Int16] = [100, 200, 300]
+        var data = Data()
+        input.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
+        
+        // When
+        let result = AudioFormatUtils.convertBitDepth(
+            data: data,
+            fromBitDepth: 16,
+            toBitDepth: 16
+        )
+        
+        // Then
+        XCTAssertEqual(result, data)
+    }
+    
+    // MARK: - Channel Conversion Tests
+    
+    func testConvertChannels_monoToStereo() {
+        // Given
+        let monoData: [Int16] = [100, 200, 300]
+        var data = Data()
+        monoData.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
+        
+        // When
+        let result = AudioFormatUtils.convertChannels(
+            data: data,
+            fromChannels: 1,
+            toChannels: 2,
+            bitDepth: 16
+        )
+        
+        // Then
+        let stereoData = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
+        let expected: [Int16] = [100, 100, 200, 200, 300, 300]
+        XCTAssertEqual(stereoData, expected)
+    }
+    
+    func testConvertChannels_stereoToMono() {
+        // Given
+        let stereoData: [Int16] = [100, 200, 300, 400, 500, 600]
+        var data = Data()
+        stereoData.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
+        
+        // When
+        let result = AudioFormatUtils.convertChannels(
+            data: data,
+            fromChannels: 2,
+            toChannels: 1,
+            bitDepth: 16
+        )
+        
+        // Then
+        let monoData = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
+        let expected: [Int16] = [150, 350, 550] // Average of pairs
+        XCTAssertEqual(monoData, expected)
+    }
+    
+    func testConvertChannels_sameChannels() {
+        // Given
+        let input: [Int16] = [100, 200, 300, 400]
+        var data = Data()
+        input.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
+        
+        // When
+        let result = AudioFormatUtils.convertChannels(
+            data: data,
+            fromChannels: 2,
+            toChannels: 2,
+            bitDepth: 16
+        )
+        
+        // Then
+        XCTAssertEqual(result, data)
+    }
+    
+    // MARK: - Audio Normalization Tests
+    
+    func testNormalizeAudio_quietAudio() {
+        // Given - Very quiet audio
+        let quietAudio: [Int16] = [10, -10, 20, -20, 30, -30]
+        var data = Data()
+        quietAudio.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
+        
+        // When
+        let result = AudioFormatUtils.normalizeAudio(
+            data: data,
+            bitDepth: 16,
+            targetLevel: 0.9
+        )
+        
+        // Then
+        let normalized = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
+        
+        // Check that audio was amplified
+        let maxOriginal = quietAudio.map { abs($0) }.max() ?? 0
+        let maxNormalized = normalized.map { abs($0) }.max() ?? 0
+        
+        XCTAssertGreaterThan(maxNormalized, maxOriginal)
+        
+        // Check that max is close to target
+        let targetMax = Int16(Float(Int16.max) * 0.9)
+        XCTAssertGreaterThan(maxNormalized, Int16(Float(targetMax) * 0.8))
+        XCTAssertLessThanOrEqual(maxNormalized, targetMax)
+    }
+    
+    func testNormalizeAudio_loudAudio() {
+        // Given - Already loud audio
+        let loudAudio: [Int16] = [30000, -30000, 25000, -25000]
+        var data = Data()
+        loudAudio.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
+        
+        // When
+        let result = AudioFormatUtils.normalizeAudio(
+            data: data,
+            bitDepth: 16,
+            targetLevel: 0.9
+        )
+        
+        // Then
+        let normalized = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
+        
+        // Check that audio was slightly reduced
+        let maxOriginal = loudAudio.map { abs($0) }.max() ?? 0
+        let maxNormalized = normalized.map { abs($0) }.max() ?? 0
+        
+        XCTAssertLessThanOrEqual(maxNormalized, maxOriginal)
+        
+        // Check that max is close to target
+        let targetMax = Int16(Float(Int16.max) * 0.9)
+        XCTAssertGreaterThan(maxNormalized, Int16(Float(targetMax) * 0.8))
+        XCTAssertLessThanOrEqual(maxNormalized, targetMax)
+    }
+    
+    func testNormalizeAudio_silentAudio() {
+        // Given - Silent audio
+        let silentAudio = [Int16](repeating: 0, count: 100)
+        var data = Data()
+        silentAudio.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
+        
+        // When
+        let result = AudioFormatUtils.normalizeAudio(
+            data: data,
+            bitDepth: 16,
+            targetLevel: 0.9
+        )
+        
+        // Then - Should remain silent
+        let normalized = result.withUnsafeBytes { Array($0.bindMemory(to: Int16.self)) }
+        XCTAssertTrue(normalized.allSatisfy { $0 == 0 })
+    }
+    
+    // MARK: - Sample Rate Conversion Tests
+    
+    func testResampleAudio_upsample() {
+        // Given
+        let originalSampleRate = 16000
+        let targetSampleRate = 44100
+        let duration = 0.1 // 100ms
+        let originalSamples = Int(Double(originalSampleRate) * duration)
+        
+        // Create a simple sine wave
+        var sineWave = [Int16]()
+        for i in 0..<originalSamples {
+            let value = sin(2.0 * .pi * 440.0 * Double(i) / Double(originalSampleRate))
+            sineWave.append(Int16(value * 10000))
+        }
+        
+        var data = Data()
+        sineWave.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
+        
+        // When
+        let result = AudioFormatUtils.resampleAudio(
+            data: data,
+            fromSampleRate: originalSampleRate,
+            toSampleRate: targetSampleRate,
+            channels: 1,
+            bitDepth: 16
+        )
+        
+        // Then
+        let expectedSamples = Int(Double(targetSampleRate) * duration)
+        let actualSamples = result.count / 2 // 16-bit = 2 bytes per sample
+        
+        // Allow some tolerance due to resampling
+        XCTAssertGreaterThan(actualSamples, Int(Double(expectedSamples) * 0.95))
+        XCTAssertLessThan(actualSamples, Int(Double(expectedSamples) * 1.05))
+    }
+    
+    func testResampleAudio_downsample() {
+        // Given
+        let originalSampleRate = 44100
+        let targetSampleRate = 16000
+        let duration = 0.1 // 100ms
+        let originalSamples = Int(Double(originalSampleRate) * duration)
+        
+        // Create a simple sine wave
+        var sineWave = [Int16]()
+        for i in 0..<originalSamples {
+            let value = sin(2.0 * .pi * 440.0 * Double(i) / Double(originalSampleRate))
+            sineWave.append(Int16(value * 10000))
+        }
+        
+        var data = Data()
+        sineWave.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
+        
+        // When
+        let result = AudioFormatUtils.resampleAudio(
+            data: data,
+            fromSampleRate: originalSampleRate,
+            toSampleRate: targetSampleRate,
+            channels: 1,
+            bitDepth: 16
+        )
+        
+        // Then
+        let expectedSamples = Int(Double(targetSampleRate) * duration)
+        let actualSamples = result.count / 2 // 16-bit = 2 bytes per sample
+        
+        // Allow some tolerance due to resampling
+        XCTAssertGreaterThan(actualSamples, Int(Double(expectedSamples) * 0.95))
+        XCTAssertLessThan(actualSamples, Int(Double(expectedSamples) * 1.05))
+    }
+    
+    func testResampleAudio_sameSampleRate() {
+        // Given
+        let sampleRate = 44100
+        let samples: [Int16] = [100, 200, 300, 400, 500]
+        var data = Data()
+        samples.forEach { data.append(contentsOf: withUnsafeBytes(of: $0) { Array($0) }) }
+        
+        // When
+        let result = AudioFormatUtils.resampleAudio(
+            data: data,
+            fromSampleRate: sampleRate,
+            toSampleRate: sampleRate,
+            channels: 1,
+            bitDepth: 16
+        )
+        
+        // Then - Should return same data
+        XCTAssertEqual(result, data)
+    }
+} 

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
+    }
+}