API Documentation

AudioBloomCore

VisualizationData

public struct VisualizationData: Sendable, Equatable {
    public let values: [Float]
    public let isSignificantEvent: Bool
    public let timestamp: Date
}

AudioBridge.PerformanceMetrics

public struct PerformanceMetrics: Sendable {
    public var framesPerSecond: Double
    public var eventsPerMinute: Double
    public var averageLatency: Double
    public var errorRate: Double
    public var averageProcessingTime: Double
    public var conversionEfficiency: Double
}

Key Components

• Audio configuration management
• Visualization preferences
• Performance tuning
• State persistence

AudioDataPublisher

public protocol AudioDataPublisher {
    func publishAudioData(_ data: AudioData)
    func subscribe(_ subscriber: AudioDataSubscriber)
    func unsubscribe(_ subscriber: AudioDataSubscriber)
}

Features

• Real-time audio data distribution
• Subscriber management
• Data transformation
• Error handling

AudioProcessor

AudioFeatureExtractor

public protocol AudioFeatureExtractor {
    func extractFeatures(from buffer: AudioBuffer) -> AudioFeatures
    var configuration: FeatureExtractionConfig { get set }
}

Capabilities

• Frequency analysis
• Amplitude detection
• Pattern recognition
• Real-time processing

AudioBufferManager

public protocol AudioBufferManager {
    func prepareBuffer(size: Int) -> AudioBuffer
    func processBuffer(_ buffer: AudioBuffer)
    func releaseBuffer(_ buffer: AudioBuffer)
}

Features

• Buffer allocation
• Memory management
• Processing queue
• Resource optimization

Visualizer

VisualizationRenderer

public protocol VisualizationRenderer {
    func render(audioFeatures: AudioFeatures)
    func updateRenderState(_ state: RenderState)
    var configuration: RenderConfiguration { get set }
}

Capabilities

• Metal shader management
• Frame rendering
• State handling
• Performance optimization

VisualizationController

public protocol VisualizationController {
    func updateVisualization(with features: AudioFeatures)
    func switchEffect(to effect: VisualizationEffect)
    func configureEffect(_ effect: VisualizationEffect, parameters: EffectParameters)
}

Features

• Effect management
• Transition handling
• Parameter control
• State coordination

Data Types

AudioData

public struct AudioData: Sendable {
    public let samples: [Float]
    public let levels: (left: Float, right: Float)
    public let sampleRate: Double
    public let timestamp: Date
    public var frequencyData: [Float]
}

AudioFeatures

public struct AudioFeatures {
    let frequencies: [Float]
    let amplitudes: [Float]
    let tempo: Float
    let timestamp: TimeInterval
}

VisualizationEffect

public struct VisualizationEffect {
    let type: EffectType
    var parameters: EffectParameters
    var state: EffectState
}

Error Handling

AudioBridge.AudioBridgeError

public enum AudioBridgeError: Error, CustomStringConvertible, Sendable {
    case connectionFailed
    case dataConversionFailed
    case processingFailed
}

VisualizationError

public enum VisualizationError: Error {
    case shaderCompilationFailed
    case renderingFailed
    case invalidEffectState
    case resourceLimit
}

Performance Guidelines

Audio Processing

• Buffer size recommendations
• Processing thread management
• Memory usage optimization
• Error recovery strategies

Visualization

• Frame rate targets
• Metal resource management
• State transition handling
• Memory constraints

Best Practices

Implementation Guidelines

• Error handling patterns
• Resource management
• State synchronization
• Performance optimization

Threading Considerations

• Main thread usage
• Background processing
• Synchronization methods
• Thread safety with Sendable conformance
• Actor-based concurrency
• Proper lock usage

Modular Design

• Clear separation of concerns
• Single responsibility principle
• Clean import hierarchies
• Minimal cross-component dependencies
• Well-defined public interfaces

Version Compatibility

Current Version

• Swift 6 compatibility
• macOS 15+ support
• Metal API requirements
• Minimum system specifications

Future Considerations

• API evolution
• Backward compatibility
• Deprecation policies
• Migration strategies