Crate voirs_spatial 

VoiRS Spatial Audio System

This crate provides 3D spatial audio processing capabilities including HRTF (Head-Related Transfer Function) processing, binaural audio rendering, 3D position tracking, room acoustics simulation, and AR/VR integration.

Features

Core Spatial Audio

• 3D Audio Positioning: Accurate spatial audio placement using Position3D
• HRTF Processing: Head-Related Transfer Function for realistic spatial cues
• Binaural Rendering: Real-time binaural audio synthesis with up to 32 sources
• Room Acoustics: Ray-traced room simulation with material properties
• Distance Modeling: Natural distance attenuation with air absorption

Advanced Features

• Higher-Order Ambisonics: 1st-3rd order ambisonics encoding/decoding
• VR/AR Integration: Platform support for Oculus, SteamVR, ARKit, ARCore, WMR
• Multi-user Environments: Shared spatial audio experiences with networking
• Neural Spatial Audio: AI-powered HRTF personalization and synthesis
• Gesture Control: Hand and body gesture-based audio interaction

Platform Support

• Gaming: Unity, Unreal Engine integration via C API
• Console: PlayStation, Xbox, Nintendo Switch optimization
• Mobile: iOS and Android with power management
• Web: WebXR browser-based immersive audio

Performance Characteristics

Real-time Performance Targets

• VR/AR Latency: <20ms motion-to-sound latency
• Gaming Latency: <30ms for interactive applications
• General Use: <50ms for non-critical applications
• CPU Usage: <25% for real-time spatial processing
• Source Count: Supports 32+ simultaneous spatial sources

Quality Metrics

• Localization Accuracy: 95%+ correct front/back discrimination
• Distance Accuracy: 90%+ accurate distance perception
• Elevation Accuracy: 85%+ accurate elevation perception
• Naturalness: MOS 4.2+ for spatial audio quality

Optimization Features

• SIMD Acceleration: AVX2/AVX512/NEON optimizations for spatial math
• GPU Support: CUDA/Metal acceleration for convolution and neural processing
• Memory Pools: Efficient buffer reuse and cache optimization
• Adaptive Quality: Dynamic quality scaling based on system load

Quick Start Examples

Simple 3D Positioning

use voirs_spatial::{Position3D, SpatialConfig};

// Create spatial audio configuration
let config = SpatialConfig::default();
println!("Sample rate: {} Hz", config.sample_rate);
println!("Buffer size: {} samples", config.buffer_size);

// Position sound source to the right
let position = Position3D::new(2.0, 0.0, 0.0);
let distance = position.distance_to(&Position3D::new(0.0, 0.0, 0.0));
println!("Source distance: {:.2}m", distance);

Binaural Rendering with Multiple Sources

use std::sync::Arc;
use voirs_spatial::{BinauralConfig, HrtfDatabase, Position3D, SourceType};

// Create binaural renderer configuration
let config = BinauralConfig {
    sample_rate: 48000,
    buffer_size: 512,
    hrir_length: 200,
    max_sources: 8,
    use_gpu: false,
    crossfade_duration: 0.05,
    quality_level: 0.8,
    enable_distance_modeling: true,
    enable_air_absorption: true,
    near_field_distance: 0.2,
    far_field_distance: 10.0,
    optimize_for_latency: true,
};

// Create HRTF database
let hrtf_db = HrtfDatabase::load_default().await.expect("Failed to load HRTF database");
println!("HRTF database created with default settings");

// Define source positions
let front = Position3D::new(0.0, 2.0, 0.0);
let left = Position3D::new(-1.5, 1.0, 0.0);
println!("Configured binaural renderer with {} max sources", config.max_sources);

Higher-Order Ambisonics

use scirs2_core::ndarray::Array1;
use voirs_spatial::{AmbisonicsEncoder, AmbisonicsDecoder, Position3D, NormalizationScheme,
                    ChannelOrdering, SpeakerConfiguration};

// Create encoder and decoder
let encoder = AmbisonicsEncoder::new(2, NormalizationScheme::N3D, ChannelOrdering::ACN);
let decoder = AmbisonicsDecoder::for_speaker_config(2, SpeakerConfiguration::Stereo)?;

// Encode mono audio to ambisonics
let audio = Array1::from_vec(vec![0.0; 1000]);
let position = Position3D::new(1.0, 1.0, 0.0);
let encoded = encoder.encode_mono(&audio, &position)?;

// Decode to stereo
let stereo = decoder.decode(&encoded)?;
println!("Decoded to {} channels", stereo.shape()[0]);

Feature Flags

Enable optional features in your Cargo.toml:

[dependencies]
voirs-spatial = { version = "0.1.0-alpha.2", features = ["steamvr", "webxr"] }

Available features:

• gpu - GPU acceleration support (CUDA/Metal)
• cuda - CUDA-specific GPU acceleration
• metal - Metal GPU acceleration for macOS/iOS
• steamvr - SteamVR/OpenVR platform integration
• webxr - WebXR browser integration
• windows_mr - Windows Mixed Reality support
• arcore - Android ARCore integration
• arkit - iOS ARKit integration
• all_platforms - Enable all VR/AR platforms

Performance Tips

For Real-time Applications

1. Use smaller buffer sizes (256-512 samples) for lower latency
2. Enable SIMD optimizations (automatic on supported platforms)
3. Limit simultaneous sources based on target platform (8-16 for mobile, 32+ for desktop)
4. Use adaptive quality settings for variable system load

For High-Quality Rendering

1. Use larger buffer sizes (1024-2048 samples) for better frequency resolution
2. Enable GPU acceleration for convolution-heavy workloads
3. Use higher-order ambisonics (2nd-3rd order) for better spatial resolution
4. Enable full room acoustics simulation with ray tracing

Memory Optimization

1. Reuse audio buffers with MemoryManager buffer pools
2. Enable HRTF caching for frequently-used positions
3. Use distance-based culling for far-away sources
4. Adjust cache policies based on available memory

Architecture

The spatial audio system follows a modular pipeline architecture:

Input Audio → Position3D → HRTF/Ambisonics → Room Acoustics → Binaural Output
                   ↓              ↓                  ↓
             Head Tracking   Distance Model   Reflection/Reverb

Each module can be used independently or combined for complete spatial audio processing.

Safety and Compliance

• Memory Safety: 100% safe Rust with #![deny(unsafe_code)]
• Thread Safety: Lock-free algorithms for real-time processing
• Error Handling: Comprehensive error types with recovery suggestions
• SciRS2 Integration: Uses SciRS2-Core for scientific computing abstractions

Re-exports

pub use ambisonics::channel_count;

pub use ambisonics::AmbisonicsDecoder;

pub use ambisonics::AmbisonicsEncoder;

pub use ambisonics::AmbisonicsOrder;

pub use ambisonics::AmbisonicsProcessor;

pub use ambisonics::ChannelOrdering;

pub use ambisonics::NormalizationScheme;

pub use ambisonics::SpeakerConfiguration;

pub use ambisonics::SphericalCoordinate;

pub use ambisonics::SphericalHarmonics;

pub use automotive::AcousticTreatment;

pub use automotive::AdaptiveVolumeConfig;

pub use automotive::AudioZone;

pub use automotive::DashboardSide;

pub use automotive::DriverProtectionConfig;

pub use automotive::EmergencyAlertType;

pub use automotive::EmergencyAudioConfig;

pub use automotive::EngineNoiseCompensation;

pub use automotive::EngineType;

pub use automotive::ExternalAwarenessConfig;

pub use automotive::ExternalConditions;

pub use automotive::FrequencyBand;

pub use automotive::FrequencyWeighting;

pub use automotive::GearPosition;

pub use automotive::HearingCharacteristics;

pub use automotive::HvacConfig;

pub use automotive::HvacState;

pub use automotive::InteriorMaterials;

pub use automotive::LegalComplianceConfig;

pub use automotive::MaterialType;

pub use automotive::NoiseCompensationConfig;

pub use automotive::PassengerActivity;

pub use automotive::PassengerConfig;

pub use automotive::PassengerInfo;

pub use automotive::PassengerPreferences;

pub use automotive::PrecipitationType;

pub use automotive::ResourceUsage;

pub use automotive::RoadNoiseCompensation;

pub use automotive::SafetyConfig;

pub use automotive::SeatPosition;

pub use automotive::SpatialPreferences;

pub use automotive::SpeakerCharacteristics;

pub use automotive::SpeakerMounting;

pub use automotive::SpeakerType;

pub use automotive::SurfaceType;

pub use automotive::TimeLimits;

pub use automotive::TireNoiseModel;

pub use automotive::TireType;

pub use automotive::VehicleAcousticConfig;

pub use automotive::VehicleAudioConfig;

pub use automotive::VehicleAudioConfigBuilder;

pub use automotive::VehicleAudioMetrics;

pub use automotive::VehicleAudioProcessor;

pub use automotive::VehicleSide;

pub use automotive::VehicleSpeaker;

pub use automotive::VehicleSpeakerConfig;

pub use automotive::VehicleState;

pub use automotive::VehicleType;

pub use automotive::VentPosition;

pub use automotive::WindNoiseCompensation;

pub use automotive::WindowConfig;

pub use automotive::WindowState;

pub use automotive::WindowTinting;

pub use automotive::ZoneAudioSource;

pub use beamforming::AdaptationConfig;

pub use beamforming::BeamPattern;

pub use beamforming::BeamformerWeights;

pub use beamforming::BeamformingAlgorithm;

pub use beamforming::BeamformingConfig;

pub use beamforming::BeamformingProcessor;

pub use beamforming::DoaResult;

pub use beamforming::SpatialSmoothingConfig;

pub use binaural::BinauralConfig;

pub use binaural::BinauralMetrics;

pub use binaural::BinauralRenderer;

pub use binaural::SourceType;

pub use compression::AdaptiveParams;

pub use compression::CompressedFrame;

pub use compression::CompressionCodec;

pub use compression::CompressionQuality;

pub use compression::CompressionStats;

pub use compression::PerceptualParams;

pub use compression::SourceClustering;

pub use compression::SpatialCompressionConfig;

pub use compression::SpatialCompressor;

pub use compression::SpatialMetadata;

pub use compression::SpatialParams;

pub use compression::TemporalMasking;

pub use config::SpatialConfig;

pub use config::SpatialConfigBuilder;

pub use core::SpatialProcessor;

pub use core::SpatialProcessorBuilder;

pub use gaming::console;

pub use gaming::AttenuationCurve;

pub use gaming::AttenuationSettings;

pub use gaming::AudioCategory;

pub use gaming::GameAudioSource;

pub use gaming::GameEngine;

pub use gaming::GamingAudioManager;

pub use gaming::GamingConfig;

pub use gaming::GamingMetrics;

pub use gestures::AudioAction;

pub use gestures::GestureBuilder;

pub use gestures::GestureConfidence;

pub use gestures::GestureConfig;

pub use gestures::GestureController;

pub use gestures::GestureData;

pub use gestures::GestureDirection;

pub use gestures::GestureEvent;

pub use gestures::GestureEventType;

pub use gestures::GestureRecognitionMethod;

pub use gestures::GestureType;

pub use gestures::Hand;

pub use gpu::GpuAmbisonics;

pub use gpu::GpuConfig;

pub use gpu::GpuConvolution;

pub use gpu::GpuDevice;

pub use gpu::GpuResourceManager;

pub use gpu::GpuSpatialMath;

pub use haptic::AudioHapticMapping;

pub use haptic::DistanceAttenuation;

pub use haptic::HapticAccessibilitySettings;

pub use haptic::HapticAudioConfig;

pub use haptic::HapticAudioProcessor;

pub use haptic::HapticCapabilities;

pub use haptic::HapticComfortSettings;

pub use haptic::HapticDevice;

pub use haptic::HapticEffectType;

pub use haptic::HapticElement;

pub use haptic::HapticMetrics;

pub use haptic::HapticPattern;

pub use haptic::PatternStyle;

pub use hrtf::ai_personalization::AdaptationStrategy;

pub use hrtf::ai_personalization::AiHrtfPersonalizer;

pub use hrtf::ai_personalization::AnthropometricMeasurements;

pub use hrtf::ai_personalization::HrtfModifications;

pub use hrtf::ai_personalization::PerceptualFeedback;

pub use hrtf::ai_personalization::PersonalizationConfig;

pub use hrtf::ai_personalization::PersonalizationMetadata;

pub use hrtf::ai_personalization::PersonalizedHrtf;

pub use hrtf::ai_personalization::TrainingResults;

pub use hrtf::HrtfDatabase;

pub use hrtf::HrtfProcessor;

pub use memory::cache_optimization;

pub use memory::Array2Pool;

pub use memory::BufferPool;

pub use memory::CacheManager;

pub use memory::CachePolicy;

pub use memory::MemoryConfig;

pub use memory::MemoryManager;

pub use memory::MemoryStatistics;

pub use mobile::android;

pub use mobile::ios;

pub use mobile::MobileConfig;

pub use mobile::MobileDevice;

pub use mobile::MobileMetrics;

pub use mobile::MobileOptimizer;

pub use mobile::MobilePlatform;

pub use mobile::PowerState;

pub use mobile::QualityPreset;

pub use multiuser::AccessibilitySettings;

pub use multiuser::AcousticSettings;

pub use multiuser::AudioEffect;

pub use multiuser::AudioEffectsProcessor;

pub use multiuser::AudioQualityMetrics;

pub use multiuser::AudioSourceType;

pub use multiuser::BandwidthSettings;

pub use multiuser::CodecState;

pub use multiuser::CodecTiming;

pub use multiuser::CompensationMethod;

pub use multiuser::ConnectionStatus;

pub use multiuser::DirectionalPattern;

pub use multiuser::DisconnectReason;

pub use multiuser::InterpolationMethod;

pub use multiuser::LatencyCompensator;

pub use multiuser::LowBandwidthMode;

pub use multiuser::MicrophoneSettings;

pub use multiuser::MixerConfig;

pub use multiuser::MultiUserAttenuationCurve;

pub use multiuser::MultiUserAudioProcessor;

pub use multiuser::MultiUserAudioSource;

pub use multiuser::MultiUserConfig;

pub use multiuser::MultiUserConfigBuilder;

pub use multiuser::MultiUserEnvironment;

pub use multiuser::MultiUserEvent;

pub use multiuser::MultiUserMetrics;

pub use multiuser::MultiUserUser;

pub use multiuser::NetworkEventType;

pub use multiuser::NetworkStats;

pub use multiuser::OptimizationLevel;

pub use multiuser::Permission;

pub use multiuser::PermissionSystem;

pub use multiuser::PositionInterpolator;

pub use multiuser::PositionSnapshot;

pub use multiuser::RoomId;

pub use multiuser::SourceAccessControl;

pub use multiuser::SourceId;

pub use multiuser::SourceProcessingState;

pub use multiuser::SourceQualitySettings;

pub use multiuser::SourceVisibility;

pub use multiuser::SpatialAudioMixer;

pub use multiuser::SpatialProperties;

pub use multiuser::SpatialZone;

pub use multiuser::SynchronizationManager;

pub use multiuser::SynchronizedClock;

pub use multiuser::UserId;

pub use multiuser::UserRole;

pub use multiuser::VadAlgorithm;

pub use multiuser::VadState;

pub use multiuser::VadThresholds;

pub use multiuser::VoiceActivityDetector;

pub use multiuser::ZoneAudioProperties;

pub use multiuser::ZoneBounds;

pub use multiuser::ZoneType;

pub use neural::AdaptiveQualityController;

pub use neural::AugmentationConfig;

pub use neural::ConvolutionalModel;

pub use neural::FeedforwardModel;

pub use neural::LossFunction;

pub use neural::NeuralInputFeatures;

pub use neural::NeuralModel;

pub use neural::NeuralModelType;

pub use neural::NeuralPerformanceMetrics;

pub use neural::NeuralSpatialConfig;

pub use neural::NeuralSpatialConfigBuilder;

pub use neural::NeuralSpatialOutput;

pub use neural::NeuralSpatialProcessor;

pub use neural::NeuralTrainer;

pub use neural::NeuralTrainingResults;

pub use neural::OptimizerType;

pub use neural::RealtimeConstraints;

pub use neural::TrainingConfig;

pub use neural::TransformerModel;

pub use performance::PerformanceConfig;

pub use performance::PerformanceMetrics;

pub use performance::PerformanceReport;

pub use performance::PerformanceSummary;

pub use performance::PerformanceTargetResult;

pub use performance::PerformanceTestSuite;

pub use performance::ResourceMonitor;

pub use performance::ResourceStatistics;

pub use performance_targets::LatencyMeasurements;

pub use performance_targets::PerformanceTargetReport;

pub use performance_targets::PerformanceTargetValidator;

pub use performance_targets::PerformanceTargets;

pub use performance_targets::PerformanceValidationResult;

pub use performance_targets::QualityMeasurements;

pub use performance_targets::QualityTargets;

pub use performance_targets::RealtimeTargets;

pub use performance_targets::ResourceMeasurements;

pub use performance_targets::ResourceTargets;

pub use performance_targets::ResourceUsageStats;

pub use performance_targets::ScalabilityMeasurements;

pub use performance_targets::ScalabilityTargets;

pub use performance_targets::TargetCategory;

pub use performance_targets::TargetComparison;

pub use platforms::ARCorePlatform;

pub use platforms::ARKitPlatform;

pub use platforms::DeviceInfo;

pub use platforms::EyeData;

pub use platforms::EyeTrackingData;

pub use platforms::GenericPlatform;

pub use platforms::HandData;

pub use platforms::HandGesture;

pub use platforms::HandTrackingData;

pub use platforms::OculusPlatform;

pub use platforms::PlatformCapabilities;

pub use platforms::PlatformFactory;

pub use platforms::PlatformIntegration;

pub use platforms::PlatformTrackingData;

pub use platforms::PoseData;

pub use platforms::TrackingConfig;

pub use platforms::TrackingQuality;

pub use platforms::TrackingState;

pub use platforms::WMRPlatform;

pub use plugins::PluginCapabilities;

pub use plugins::PluginConfig;

pub use plugins::PluginManager;

pub use plugins::PluginParameter;

pub use plugins::PluginParameters;

pub use plugins::PluginState;

pub use plugins::ProcessingChain;

pub use plugins::ProcessingContext;

pub use plugins::ReverbPlugin;

pub use plugins::SpatialPlugin;

pub use position::advanced_prediction::AdaptationPhase;

pub use position::advanced_prediction::AdvancedPredictiveTracker;

pub use position::advanced_prediction::ModelSelectionStrategy;

pub use position::advanced_prediction::MotionPattern;

pub use position::advanced_prediction::MotionPatternType;

pub use position::advanced_prediction::PatternRecognitionConfig;

pub use position::advanced_prediction::PredictedPosition;

pub use position::advanced_prediction::PredictionMetrics;

pub use position::advanced_prediction::PredictionModelType;

pub use position::advanced_prediction::PredictiveTrackingConfig;

pub use position::Box3D;

pub use position::CalibrationData;

pub use position::ComfortSettings;

pub use position::DopplerProcessor;

pub use position::DynamicSource;

pub use position::DynamicSourceManager;

pub use position::HeadTracker;

pub use position::Listener;

pub use position::ListenerMovementSystem;

pub use position::MotionPredictor;

pub use position::MotionSnapshot;

pub use position::MovementConstraints;

pub use position::MovementMetrics;

pub use position::NavigationMode;

pub use position::OcclusionDetector;

pub use position::OcclusionMaterial;

pub use position::OcclusionMethod;

pub use position::OcclusionResult;

pub use position::PlatformData;

pub use position::PlatformType;

pub use position::SoundSource;

pub use position::SpatialSourceManager;

pub use power::DeviceType;

pub use power::PowerConfig;

pub use power::PowerMetrics;

pub use power::PowerOptimizer;

pub use power::PowerProfile;

pub use power::PowerStrategy;

pub use room::adaptive_acoustics::AdaptationAction;

pub use room::adaptive_acoustics::AdaptationController;

pub use room::adaptive_acoustics::AdaptationMetrics;

pub use room::adaptive_acoustics::AdaptationTrigger;

pub use room::adaptive_acoustics::AdaptiveAcousticEnvironment;

pub use room::adaptive_acoustics::AdaptiveAcousticsConfig;

pub use room::adaptive_acoustics::EnvironmentSensors;

pub use room::adaptive_acoustics::EnvironmentSnapshot;

pub use room::adaptive_acoustics::EnvironmentType;

pub use room::adaptive_acoustics::SensorConfig;

pub use room::adaptive_acoustics::UserFeedback;

pub use room::ConnectionAcousticProperties;

pub use room::ConnectionState;

pub use room::ConnectionType;

pub use room::GlobalAcousticConfig;

pub use room::MultiRoomEnvironment;

pub use room::Room;

pub use room::RoomAcoustics;

pub use room::RoomConnection;

pub use room::RoomSimulator;

pub use smart_speakers::ArrayMetrics;

pub use smart_speakers::ArrayTopology;

pub use smart_speakers::AudioFormat;

pub use smart_speakers::AudioRoute;

pub use smart_speakers::AudioRouter;

pub use smart_speakers::AudioSource;

pub use smart_speakers::AudioSpecs;

pub use smart_speakers::CalibrationEngine;

pub use smart_speakers::CalibrationMethod;

pub use smart_speakers::CalibrationResults;

pub use smart_speakers::CalibrationStatus;

pub use smart_speakers::ClockSource;

pub use smart_speakers::CompressionConfig;

pub use smart_speakers::DeviceFilter;

pub use smart_speakers::DirectivityPattern;

pub use smart_speakers::DiscoveryProtocol;

pub use smart_speakers::DiscoveryService;

pub use smart_speakers::DspFeature;

pub use smart_speakers::EQFilter;

pub use smart_speakers::FilterType;

pub use smart_speakers::LimitingConfig;

pub use smart_speakers::MixSettings;

pub use smart_speakers::NetworkConfig;

pub use smart_speakers::NetworkInfo;

pub use smart_speakers::NetworkProtocol;

pub use smart_speakers::ProcessingConfig;

pub use smart_speakers::ProcessingStep;

pub use smart_speakers::RoomCorrection;

pub use smart_speakers::SmartSpeaker;

pub use smart_speakers::SpeakerArrayConfig;

pub use smart_speakers::SpeakerArrayConfigBuilder;

pub use smart_speakers::SpeakerArrayManager;

pub use smart_speakers::SpeakerCapabilities;

pub use smart_speakers::SyncConfig;

pub use technical_testing::create_standard_technical_configs;

pub use technical_testing::LatencyAnalysis;

pub use technical_testing::MemoryConstraints;

pub use technical_testing::PlatformAnalysis;

pub use technical_testing::PlatformTestResult;

pub use technical_testing::StabilityAnalysis;

pub use technical_testing::StressTestParams;

pub use technical_testing::TechnicalSuccessCriteria;

pub use technical_testing::TechnicalTestConfig;

pub use technical_testing::TechnicalTestParameters;

pub use technical_testing::TechnicalTestReport;

pub use technical_testing::TechnicalTestResult;

pub use technical_testing::TechnicalTestSuite;

pub use technical_testing::TechnicalTestType;

pub use technical_testing::TestOutcome;

pub use telepresence::AcousticEchoSettings;

pub use telepresence::AcousticMatchingSettings;

pub use telepresence::AcousticProperties;

pub use telepresence::AdaptiveQualitySettings;

pub use telepresence::AirAbsorptionSettings;

pub use telepresence::AnonymizationMethod;

pub use telepresence::AnonymizationSettings;

pub use telepresence::AudioCodec;

pub use telepresence::AudioDeviceConfig;

pub use telepresence::AudioEnhancementSettings;

pub use telepresence::AudioFormat as TelepresenceAudioFormat;

pub use telepresence::AudioMetadata;

pub use telepresence::AudioPresenceSettings;

pub use telepresence::AudioQualityPreferences;

pub use telepresence::AudioQualitySettings;

pub use telepresence::BandwidthConstraints;

pub use telepresence::BandwidthExtensionSettings;

pub use telepresence::CodecPreferences;

pub use telepresence::CompressionSettings;

pub use telepresence::ConsentManagementSettings;

pub use telepresence::CrossRoomSettings;

pub use telepresence::DataCollectionSettings;

pub use telepresence::DistanceModelingSettings;

pub use telepresence::DopplerEffectsSettings;

pub use telepresence::EchoCancellationSettings;

pub use telepresence::EnvironmentalAwarenessSettings;

pub use telepresence::EqualizationSettings;

pub use telepresence::HeadTrackingSettings;

pub use telepresence::HrtfPersonalizationSettings;

pub use telepresence::NetworkSettings;

pub use telepresence::NoiseSuppressionSettings;

pub use telepresence::Orientation;

pub use telepresence::PresenceIndicatorSettings;

pub use telepresence::PrivacySettings;

pub use telepresence::QualityLevel;

pub use telepresence::QualitySettings;

pub use telepresence::ReceivedAudio;

pub use telepresence::RoomSimulationSettings;

pub use telepresence::SessionJoinResult;

pub use telepresence::SessionState;

pub use telepresence::SessionStatistics;

pub use telepresence::SpatialTelepresenceSettings;

pub use telepresence::TelepresenceAudioSettings;

pub use telepresence::TelepresenceConfig;

pub use telepresence::TelepresenceProcessor;

pub use telepresence::TelepresenceSession;

pub use telepresence::TrackingPredictionSettings;

pub use telepresence::UserConfig;

pub use telepresence::VadSettings;

pub use telepresence::Velocity;

pub use telepresence::VirtualRoomParameters;

pub use telepresence::VisualPresenceSettings;

pub use telepresence::VoiceProcessingSettings;

pub use telepresence::VoiceSpatializationSettings;

pub use types::AudioChannel;

pub use types::BinauraAudio;

pub use types::Position3D;

pub use types::SIMDSpatialOps;

pub use types::SpatialEffect;

pub use types::SpatialRequest;

pub use types::SpatialResult;

pub use validation::create_standard_test_configs;

pub use validation::create_test_subjects;

pub use validation::AccuracyMetrics;

pub use validation::AudioExpertise;

pub use validation::ExperienceLevel;

pub use validation::Gender;

pub use validation::HearingAbility;

pub use validation::PerceptualTestSuite;

pub use validation::PopulationAnalysis;

pub use validation::ResponseData;

pub use validation::StimulusData;

pub use validation::SubjectiveRatings;

pub use validation::SuccessCriteria;

pub use validation::TestParameters;

pub use validation::TestStatistics;

pub use validation::TestSubject;

pub use validation::ValidationReport;

pub use validation::ValidationTestConfig;

pub use validation::ValidationTestResult;

pub use validation::ValidationTestType;

pub use visual_audio::AnimationParams;

pub use visual_audio::AnimationType;

pub use visual_audio::AudioVisualMapping;

pub use visual_audio::ColorRGBA;

pub use visual_audio::ColorScheme;

pub use visual_audio::ColorSchemeType;

pub use visual_audio::DirectionZone;

pub use visual_audio::DirectionalCueMapping;

pub use visual_audio::EasingFunction;

pub use visual_audio::EventTriggerMapping;

pub use visual_audio::FrequencyVisualMapping;

pub use visual_audio::OnsetTrigger;

pub use visual_audio::RhythmTrigger;

pub use visual_audio::ScalingCurve;

pub use visual_audio::ShapeType;

pub use visual_audio::SilenceTrigger;

pub use visual_audio::SpectralTrigger;

pub use visual_audio::VisualAccessibilitySettings;

pub use visual_audio::VisualAudioConfig;

pub use visual_audio::VisualAudioMetrics;

pub use visual_audio::VisualAudioProcessor;

pub use visual_audio::VisualDisplay;

pub use visual_audio::VisualDisplayCapabilities;

pub use visual_audio::VisualDistanceAttenuation;

pub use visual_audio::VisualEffect;

pub use visual_audio::VisualElement;

pub use visual_audio::VisualElementType;

pub use visual_audio::VisualPerformanceSettings;

pub use visual_audio::VisualResourceUsage;

pub use visual_audio::VisualSyncSettings;

pub use webxr::utils as webxr_utils;

pub use webxr::BrowserType;

pub use webxr::WebXRCapabilities;

pub use webxr::WebXRConfig;

pub use webxr::WebXRMetrics;

pub use webxr::WebXRPose;

pub use webxr::WebXRProcessor;

pub use webxr::WebXRSessionType;

pub use webxr::WebXRSourceType;

pub use wfs::ArrayGeometry;

pub use wfs::PreEmphasisConfig;

pub use wfs::WfsArrayBuilder;

pub use wfs::WfsConfig;

pub use wfs::WfsDrivingFunction;

pub use wfs::WfsProcessor;

pub use wfs::WfsSource;

pub use wfs::WfsSourceType;

Modules

ambisonics

Ambisonics Spatial Audio System

automotive

Automotive Spatial Audio System

backends

ONNX and other inference backends for spatial audio Backend implementations for spatial audio processing.

beamforming

Beamforming implementation for directional audio capture and playback

binaural

Real-time binaural audio rendering system

compression

Spatial Audio Compression for efficient transmission and storage

config

Configuration for spatial audio processing

core

Core spatial audio processing functionality

gaming

Gaming Engine Integration for VoiRS Spatial Audio

gestures

Gesture Control System for Spatial Audio

gpu

GPU Acceleration for Spatial Audio Processing

haptic

Haptic Integration for Spatial Audio

hrtf

HRTF (Head-Related Transfer Function) processing for spatial audio

memory

Memory Management and Cache Optimization Module

mobile

Mobile Platform Optimizations for VoiRS Spatial Audio

multiuser

Multi-user Spatial Audio System

neural

Neural Spatial Audio System

performance

Performance Testing and Validation for Spatial Audio

performance_targets

Performance Target Validation System

platforms

VR/AR Platform Integration Module

plugins

Plugin System for VoiRS Spatial Audio

position

Position tracking and listener/source management

power

Power Consumption Optimization for VoiRS Spatial Audio

prelude

Prelude module for convenient imports

public_spaces

Public Spaces Spatial Audio System

realtime

Real-time Audio Processing Module

room

Room acoustics simulation and reverberation processing

smart_speakers

Smart Speaker Arrays for Multi-Speaker Spatial Audio

technical_testing

Comprehensive Technical Testing Suite

telepresence

High-Fidelity Spatial Telepresence System

types

Core types for spatial audio processing

utils

Utility functions for spatial audio processing

validation

Perceptual Validation Testing Suite

visual_audio

Visual Audio Integration for Spatial Audio

webxr

WebXR Integration for VoiRS Spatial Audio

wfs

Wave Field Synthesis (WFS) implementation for advanced spatial audio reproduction

Structs

ErrorContext

Error context for additional debugging information

Enums

AudioBufferIssue

Audio buffer issue types

AudioError

Audio-specific errors

ConfigError

Configuration-specific errors

Error

Error types for spatial audio processing

ErrorCode

Error codes for programmatic error handling

GpuError

GPU-specific errors

HrtfError

HRTF-specific errors

MemoryError

Memory-specific errors

PlatformError

Platform-specific errors

PositionError

Position-specific errors

ProcessingError

Processing-specific errors

RoomError

Room acoustics errors

ValidationError

Validation-specific errors

Type Aliases

Result

Result type for spatial audio operations