Nick Payne
105 lines
2.8 KiB
Swift
105 lines
2.8 KiB
Swift
import CoreAudio
|
|
import Foundation
|
|
|
|
public class AudioBuffer {
|
|
private var buffer: [UInt8]
|
|
private var writeIndex: Int = 0
|
|
private var readIndex: Int = 0
|
|
private var availableBytes: Int = 0
|
|
private let maxBufferSize: Int
|
|
|
|
// Pre-calculated values for efficiency
|
|
private let bytesPerChunk: Int
|
|
private let chunkDuration: Double
|
|
|
|
public init(format: AudioStreamBasicDescription, chunkDuration: Double = 0.2) {
|
|
|
|
// Pre-calculate chunk parameters
|
|
let bytesPerFrame = Int(format.mBytesPerFrame)
|
|
let samplesPerChunk = Int(format.mSampleRate * chunkDuration)
|
|
self.bytesPerChunk = samplesPerChunk * bytesPerFrame
|
|
self.chunkDuration = Double(samplesPerChunk) / format.mSampleRate
|
|
|
|
// Calculate max buffer size to hold ~10 seconds of audio, way more than the maximum we allow
|
|
let bytesPerSecond = Int(format.mSampleRate) * bytesPerFrame
|
|
self.maxBufferSize = bytesPerSecond * 10
|
|
|
|
// Pre-allocate ring buffer
|
|
self.buffer = Array(repeating: 0, count: maxBufferSize)
|
|
}
|
|
|
|
public func append(_ data: Data) {
|
|
guard availableBytes + data.count <= maxBufferSize else {
|
|
Logger.error("Audio buffer overflow", context: [
|
|
"requested": String(data.count),
|
|
"available": String(maxBufferSize - availableBytes)
|
|
])
|
|
return
|
|
}
|
|
|
|
// Simple, clean, fast enough
|
|
for byte in data {
|
|
buffer[writeIndex] = byte
|
|
writeIndex = (writeIndex + 1) % maxBufferSize
|
|
}
|
|
|
|
availableBytes += data.count
|
|
}
|
|
|
|
public func processChunks() -> [AudioPacket] {
|
|
var packets: [AudioPacket] = []
|
|
|
|
while let packet = nextChunk() {
|
|
packets.append(packet)
|
|
}
|
|
|
|
return packets
|
|
}
|
|
|
|
public func flushRemaining() -> AudioPacket? {
|
|
guard availableBytes > 0 else { return nil }
|
|
|
|
// Create Data from remaining bytes
|
|
var remainingData = Data(capacity: availableBytes)
|
|
for _ in 0..<availableBytes {
|
|
remainingData.append(buffer[readIndex])
|
|
readIndex = (readIndex + 1) % maxBufferSize
|
|
}
|
|
|
|
availableBytes = 0
|
|
|
|
let packet = AudioPacket(
|
|
timestamp: Date(),
|
|
duration: 0.0, // Unknown duration for final chunk
|
|
peakAmplitude: 0.0,
|
|
rawAudioData: remainingData
|
|
)
|
|
|
|
return packet
|
|
}
|
|
|
|
private func nextChunk() -> AudioPacket? {
|
|
// Check if we have enough data for a complete chunk
|
|
guard availableBytes >= bytesPerChunk else { return nil }
|
|
|
|
// Extract chunk data - bounds-checked but still efficient
|
|
var chunkData = Data(capacity: bytesPerChunk)
|
|
|
|
for _ in 0..<bytesPerChunk {
|
|
chunkData.append(buffer[readIndex])
|
|
readIndex = (readIndex + 1) % maxBufferSize
|
|
}
|
|
|
|
availableBytes -= bytesPerChunk
|
|
|
|
let packet = AudioPacket(
|
|
timestamp: Date(),
|
|
duration: chunkDuration,
|
|
peakAmplitude: 0.0, // No analysis in raw mode
|
|
rawAudioData: chunkData
|
|
)
|
|
|
|
return packet
|
|
}
|
|
}
|