Ownaudio Framework

https://modernmube.github.io/OwnAudioSharp/
Admin
Ownaudio is a professional cross-platform audio framework for .NET with a native C++ engine,...
Tokens:59,382
Snippets:484
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Synchronized Installation Audio Setup

Source: https://modernmube.github.io/OwnAudioSharp/documents/networksync.html

Sets up a central server for an installation and then configures multiple synchronized clients for different display zones. Each zone runs on a separate device.

```csharp
// Central Control Room (Server)
await OwnaudioNet.StartNetworkSyncServerAsync();
var soundtrack = new FileSource("installation-audio.wav");
mixer.AddSource(soundtrack);

// Multiple Display Zones (Clients)
// Zone 1, 2, 3, 4...
for (int zone = 1; zone <= 10; zone++)
{
    // Each zone runs on separate device
    await OwnaudioNet.StartNetworkSyncClientAsync();
    var zoneTrack = new FileSource("installation-audio.wav");
    mixer.AddSource(zoneTrack);
}

// Synchronized audio-visual experience across entire installation

```

--------------------------------

### Server Setup - Basic

Source: https://modernmube.github.io/OwnAudioSharp/documents/networksync.html

Initializes the audio system and starts the network sync server. Automatically broadcasts transport commands like Play, Pause, and Seek to connected clients. Requires the same audio files to be present on all devices.

```csharp
using OwnaudioNET;

// Initialize audio system
await OwnaudioNet.InitializeAsync();
OwnaudioNet.Start();

// Start as network sync server
await OwnaudioNet.StartNetworkSyncServerAsync(
    port: 9876,
    useLocalTimeOnly: true);  // No internet required!

// Get mixer and add tracks
var mixer = OwnaudioNet.GetAudioMixer();
var track = new FileSource("song.mp3");
track.AttachToClock(mixer.MasterClock);
mixer.AddSource(track);

// All commands are automatically broadcast to clients
track.Play();   // All clients start playing
track.Pause();  // All clients pause
track.Seek(30); // All clients seek to 30 seconds

// Monitor connected clients
var status = OwnaudioNet.GetNetworkSyncStatus();
Console.WriteLine($"Connected clients: {status.ClientCount}");
```

--------------------------------

### Basic Usage Example

Source: https://modernmube.github.io/OwnAudioSharp/documents/api-core.html

A quick example demonstrating the basic usage of Ownaudio.Core for loading and playing an audio file.

```APIDOC
## Basic Usage Example

### Description
This example shows how to initialize the audio engine, load an audio file using a decoder, and play it back.

### Method
N/A (Illustrative Code)

### Endpoint
N/A

### Request Body
N/A

### Request Example
```csharp
using Ownaudio.Core;
using Ownaudio.Decoders;

// Create and initialize engine
using var engine = AudioEngineFactory.CreateDefault();

// Start the engine
engine.Start();

// Load and decode audio file
using var decoder = AudioDecoderFactory.Create(
    "music.mp3",
    targetSampleRate: 48000,
    targetChannels: 2
);

// Read and play audio
var buffer = new byte[4096 * 2 * sizeof(float)];
while (true)
{
    var result = decoder.ReadFrames(buffer);
    if (result.IsEOF) break;
    
    if (result.FramesRead > 0)
    {
        int bytesRead = result.FramesRead * 2 * sizeof(float);
        var samples = System.Runtime.InteropServices.MemoryMarshal
            .Cast(buffer.AsSpan(0, bytesRead));
        engine.Send(samples);
    }
}

// Stop the engine
engine.Stop();
```

### Response
N/A
```

--------------------------------

### Complete OwnaudioNET Application Example

Source: https://modernmube.github.io/OwnAudioSharp/documents/examples.html

This C# code provides a full example of initializing OwnaudioNET, configuring an audio mixer with effects, loading multiple audio files, synchronizing their playback, and managing resources. It demonstrates real-time effects processing and proper shutdown procedures. Ensure media files are in a 'media' subdirectory.

```csharp
using Ownaudio.Core;
using OwnaudioNET.Core;
using OwnaudioNET.Effects;
using OwnaudioNET.Mixing;
using OwnaudioNET.Sources;
using System.Reflection;

namespace OwnaudioNET.Test;

public class TestProgram
{
    public static void Main(string[] args)
    {
        AudioMixer? mixer = null;
        FileSource? fileSource0 = null;
        FileSource? fileSource1 = null;
        FileSource? fileSource2 = null;
        FileSource? fileSource3 = null;

        try
        {
            AudioConfig config = new AudioConfig()
            {
                SampleRate = 48000,
                Channels = 2,
                BufferSize = 512
            };
            
            OwnaudioNet.Initialize(config);
            OwnaudioNet.Start();

            var Engine = OwnaudioNet.Engine!.UnderlyingEngine;
            mixer = new AudioMixer(Engine, bufferSizeInFrames: 512);
            mixer.MasterVolume = 0.8f;

            var _equalizer = new Equalizer30BandEffect();
            var _compressor = new CompressorEffect(CompressorPreset.Vintage);
            
            mixer.AddMasterEffect(_equalizer);
            mixer.AddMasterEffect(_compressor);
            mixer.AddMasterEffect(new DynamicAmpEffect(DynamicAmpPreset.Live));
            
            _equalizer.Enabled = false;
            _compressor.Enabled = false;

            string? exeDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            int targetSampleRate = OwnaudioNet.Engine!.Config.SampleRate;
            int targetChannels = OwnaudioNet.Engine!.Config.Channels;

            fileSource0 = new FileSource(Path.Combine(exeDirectory, "media", "drums.wav"), 8192, targetSampleRate, targetChannels);
            fileSource1 = new FileSource(Path.Combine(exeDirectory, "media", "bass.wav"), 8192, targetSampleRate, targetChannels);
            fileSource2 = new FileSource(Path.Combine(exeDirectory, "media", "other.wav"), 8192, targetSampleRate, targetChannels);
            fileSource3 = new FileSource(Path.Combine(exeDirectory, "media", "vocals.wav"), 8192, targetSampleRate, targetChannels);

            mixer.AddSource(fileSource0);
            mixer.AddSource(fileSource1);
            mixer.AddSource(fileSource2);
            mixer.AddSource(fileSource3);

            var syncGroup = mixer.CreateSyncGroup("Demo", fileSource0, fileSource1, fileSource2, fileSource3);
            mixer.Start();
            mixer.StartSyncGroup("Demo");

            DateTime startTime = DateTime.Now;

            while (fileSource0.State == SourceState.Playing)
            {
                Thread.Sleep(100);
                
                double position = fileSource0.Position;
                double duration = fileSource0.Duration;
                
                if (position > 30 && position < 35)
                {
                    _equalizer.Enabled = true;
                    _compressor.Enabled = true;
                }
            }

            mixer.Stop();
            mixer.StopSyncGroup("Demo");
            mixer.Dispose();

            fileSource0.Dispose();
            fileSource1.Dispose();
            fileSource2.Dispose();
            fileSource3.Dispose();

            OwnaudioNet.Stop();
            OwnaudioNet.Shutdown();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"ERROR: {ex.Message}");
            
            fileSource0?.Dispose();
            fileSource1?.Dispose();
            fileSource2?.Dispose();
            fileSource3?.Dispose();
            mixer?.Dispose();
            OwnaudioNet.Shutdown();
            
            Environment.Exit(1);
        }
    }
}
```

--------------------------------

### Multi-Room Audio System Example

Source: https://modernmube.github.io/OwnAudioSharp/documents/networksync.html

Demonstrates a real-world use case for setting up a multi-room audio system using OwnaudioSharp.

```APIDOC
## Real-World Use Cases: Multi-Room Audio System

### Description
Set up a synchronized multi-room audio system where one room acts as the server and others as clients.

### Method
POST (for starting server/clients)

### Endpoint
`/system/multirrom/setup` (Conceptual)

### Request Example
```csharp
// Living Room (Server - Main Control)
await OwnaudioNet.StartNetworkSyncServerAsync();
var livingRoomTrack = new FileSource("party-mix.mp3");
mixer.AddSource(livingRoomTrack);
livingRoomTrack.Play();

// Kitchen (Client)
await OwnaudioNet.StartNetworkSyncClientAsync();
var kitchenTrack = new FileSource("party-mix.mp3");
mixer.AddSource(kitchenTrack);
// Automatically follows living room

// Bedroom (Client)
await OwnaudioNet.StartNetworkSyncClientAsync();
var bedroomTrack = new FileSource("party-mix.mp3");
mixer.AddSource(bedroomTrack);
// Automatically follows living room

// Perfect synchronization throughout your home!
```

### Response
#### Success Response (200)
Indicates successful setup of the multi-room audio system.

#### Response Example
```json
{
  "message": "Multi-room audio system configured successfully."
}
```
```

--------------------------------

### Simple File Playback with AudioEngine

Source: https://modernmube.github.io/OwnAudioSharp/documents/architecture.html

Initialize the audio engine, start it, and play a single audio file. Ensure asynchronous initialization is handled.

```csharp
var engine = AudioEngineFactory.CreateDefault();
await Task.Run(() => engine.Initialize(new AudioConfig()));
engine.Start();

var source = new FileSource("music.mp3", engine);
source.Play();
```

--------------------------------

### Connect Client to Server

Source: https://modernmube.github.io/OwnAudioSharp/documents/networksync.html

Demonstrates various methods for starting a network sync client, including auto-discovery, manual IP, and hostname resolution.

```csharp
// Option 1: Auto-discovery (recommended)
await OwnaudioNet.StartNetworkSyncClientAsync(
    serverAddress: null,             // Auto-discover server
    port: 9876,
    allowOfflinePlayback: true);

// Option 2: Manual IP address
await OwnaudioNet.StartNetworkSyncClientAsync(
    serverAddress: "192.168.1.100",  // Specific server IP
    port: 9876,
    allowOfflinePlayback: true);

// Option 3: Hostname
await OwnaudioNet.StartNetworkSyncClientAsync(
    serverAddress: "audio-server.local",
    port: 9876,
    allowOfflinePlayback: true);
```

--------------------------------

### Basic Audio Playback Example

Source: https://modernmube.github.io/OwnAudioSharp/documents/api-core.html

This example demonstrates the basic usage of Ownaudio.Core for loading and playing an MP3 audio file. Ensure the audio file is accessible and the necessary decoders are available.

```csharp
using Ownaudio.Core;
using Ownaudio.Decoders;

// Create and initialize engine
using var engine = AudioEngineFactory.CreateDefault();

// Start the engine
engine.Start();

// Load and decode audio file
using var decoder = AudioDecoderFactory.Create(
    "music.mp3",
    targetSampleRate: 48000,
    targetChannels: 2
);

// Read and play audio
var buffer = new byte[4096 * 2 * sizeof(float)];
while (true)
{
    var result = decoder.ReadFrames(buffer);
    if (result.IsEOF) break;
    
    if (result.FramesRead > 0)
    {
        int bytesRead = result.FramesRead * 2 * sizeof(float);
        var samples = System.Runtime.InteropServices.MemoryMarshal
            .Cast(buffer.AsSpan(0, bytesRead));
        engine.Send(samples);
    }
}

// Stop the engine
engine.Stop();
```

--------------------------------

### Implement Audio Source Usage

Source: https://modernmube.github.io/OwnAudioSharp/documents/architecture.html

Example of creating a file-based audio source and configuring its playback properties.

```csharp
var fileSource = new FileSource("music.mp3", engine);
fileSource.Volume = 0.8f;
fileSource.Tempo = 1.2f;  // 120% speed
fileSource.Play();
```

--------------------------------

### Client Setup - Basic

Source: https://modernmube.github.io/OwnAudioSharp/documents/networksync.html

Initializes the audio system and connects to a network sync server. Clients automatically follow server commands for playback, pause, and seek. Ensure the same audio files are used on both server and client.

```csharp
using OwnaudioNET;

// Initialize audio system
await OwnaudioNet.InitializeAsync();
OwnaudioNet.Start();

// Connect to server (auto-discovery or manual IP)
await OwnaudioNet.StartNetworkSyncClientAsync(
    serverAddress: "192.168.1.100",  // Or null for auto-discovery
    port: 9876,
    allowOfflinePlayback: true);     // Continue if disconnected

// Add SAME tracks as server
var mixer = OwnaudioNet.GetAudioMixer();
var track = new FileSource("song.mp3");  // Same file as server!
track.AttachToClock(mixer.MasterClock);
mixer.AddSource(track);

// Client automatically follows server commands
// No manual control needed!

// Monitor connection state
OwnaudioNet.NetworkSyncConnectionChanged += (sender, e) =>
{
    Console.WriteLine($"Connection: {e.NewState}");
    
    if (e.NewState == ConnectionState.Synced)
        Console.WriteLine("✅ Synchronized with server!");
    else if (e.NewState == ConnectionState.Disconnected)
        Console.WriteLine("⚠️ Disconnected - playing standalone");
};
```

--------------------------------

### Zero-Allocation Decoder Usage Example

Source: https://modernmube.github.io/OwnAudioSharp/documents/api-core.html

This example demonstrates efficient audio decoding using a reusable buffer for zero-allocation frame reading. It shows how to get stream information and process decoded audio samples.

```csharp
// Create decoder
using var decoder = AudioDecoderFactory.Create(
    "music.mp3",
    targetSampleRate: 48000,
    targetChannels: 2
);

var info = decoder.StreamInfo;
Console.WriteLine($"Duration: {info.Duration}");
Console.WriteLine($"Sample Rate: {info.SampleRate} Hz");
Console.WriteLine($"Channels: {info.Channels}");

// Create reusable buffer
int bufferSize = 4096 * info.Channels * sizeof(float);
var buffer = new byte[bufferSize];

// Decode frames efficiently
while (true)
{
    var result = decoder.ReadFrames(buffer);
    if (result.IsEOF) break;
    
    if (result.FramesRead > 0)
    {
        int bytesRead = result.FramesRead * info.Channels * sizeof(float);
        var samples = System.Runtime.InteropServices.MemoryMarshal
            .Cast(buffer.AsSpan(0, bytesRead));
        
        // Process audio samples
        ProcessAudio(samples);
    }
}
```

--------------------------------

### Start Network Sync Server

Source: https://modernmube.github.io/OwnAudioSharp/documents/networksync.html

Initializes the OwnaudioNet synchronization server. This should be called on the main device that will control audio playback.

```csharp
await OwnaudioNet.StartNetworkSyncServerAsync();
```

--------------------------------

### Install OwnAudioSharp Core API via NuGet Package Manager

Source: https://modernmube.github.io/OwnAudioSharp/documents/quickstart.html

Use this command in the Package Manager Console to install the Core API for Ownaudio.

```csharp
Install-Package OwnAudioSharpCopy
```

--------------------------------

### Studio Collaboration Setup

Source: https://modernmube.github.io/OwnAudioSharp/documents/networksync.html

Configures a producer's workstation as a server and musicians' headphones as clients for synchronized audio playback during collaborative music production.

```csharp
// Producer's Workstation (Server)
await OwnaudioNet.StartNetworkSyncServerAsync();
var projectMix = new FileSource("project-mix.wav");
mixer.AddSource(projectMix);

// Musicians' Headphones (Clients)
// Guitarist
await OwnaudioNet.StartNetworkSyncClientAsync();
var guitaristMix = new FileSource("project-mix.wav");
mixer.AddSource(guitaristMix);

// Vocalist
await OwnaudioNet.StartNetworkSyncClientAsync();
var vocalistMix = new FileSource("project-mix.wav");
mixer.AddSource(vocalistMix);

// Everyone hears exactly the same thing at the same time
// Perfect for recording sessions and rehearsals

```

--------------------------------

### Install OwnAudioSharp Core API via .NET CLI

Source: https://modernmube.github.io/OwnAudioSharp/documents/quickstart.html

Use this command in the .NET CLI to add the Core API package for Ownaudio.

```bash
dotnet add package OwnAudioSharpCopy
```

--------------------------------

### Mobile Party Mode Setup

Source: https://modernmube.github.io/OwnAudioSharp/documents/networksync.html

Sets up a main phone/tablet as a server and other devices as clients for synchronized audio playback over WiFi. Uses auto-discovery and allows offline playback.

```csharp
// Main Phone/Tablet (Server)
await OwnaudioNet.StartNetworkSyncServerAsync();

// Other Phones/Tablets (Clients)
await OwnaudioNet.StartNetworkSyncClientAsync(
    serverAddress: null,  // Auto-discovery on WiFi
    allowOfflinePlayback: true);

// All devices play in perfect sync over WiFi
// Great for parties, outdoor events, etc.

```

--------------------------------

### Create Native Audio Engine (Default)

Source: https://modernmube.github.io/OwnAudioSharp/documents/quickstart.html

Instantiates the default native audio engine, which is GC-free for glitch-free audio. Ensure the engine is initialized and started before use.

```csharp
using Ownaudio.Core;

// Create NATIVE audio engine (DEFAULT - GC-free!)
using var engine = AudioEngineFactory.CreateDefault();
// Or explicitly: AudioEngineFactory.CreateNative();

// Native engine runs outside GC - no audio glitches!
engine.Initialize(AudioConfig.Default);
engine.Start();Copy
```

--------------------------------

### Start Network Sync Client

Source: https://modernmube.github.io/OwnAudioSharp/documents/networksync.html

Initializes the OwnaudioNet synchronization client. This connects to a server to receive synchronized audio streams. Multiple clients can connect to a single server.

```csharp
await OwnaudioNet.StartNetworkSyncClientAsync();
```

--------------------------------

### Start Network Sync Client with Offline Playback

Source: https://modernmube.github.io/OwnAudioSharp/documents/networksync.html

Initializes the OwnaudioNet synchronization client, allowing it to continue playback even if the server disconnects. Useful for backup systems.

```csharp
await OwnaudioNet.StartNetworkSyncClientAsync(
    allowOfflinePlayback: true);

```

--------------------------------

### UI Application Playback with Async Methods

Source: https://modernmube.github.io/OwnAudioSharp/documents/quickstart.html

Provides an example of asynchronous initialization and shutdown for UI applications (WPF, MAUI, Avalonia) to prevent UI thread blocking. Usage is shown within a ViewModel and a UI event handler.

```csharp
using OwnaudioNET;
using OwnaudioNET.Sources;

public class AudioPlayerViewModel
{
    private AudioMixer? _mixer;
    private FileSource? _source;

    // Initialize asynchronously (UI remains responsive!)
    public async Task InitializeAsync()
    {
        // ✅ Async initialization prevents UI freezing
        await OwnaudioNet.InitializeAsync();

        _mixer = new AudioMixer(OwnaudioNet.Engine);
        _mixer.Start();
    }

    // Play audio file
    public void Play(string filePath)
    {
        _source?.Dispose();
        _source = new FileSource(filePath);

        _mixer?.AddSource(_source);
        _source.Play();
    }

    // Stop playback
    public void Stop()
    {
        _source?.Stop();
    }

    // Shutdown asynchronously (UI remains responsive!)
    public async Task ShutdownAsync()
    {
        _source?.Dispose();

        _mixer?.Stop();
        _mixer?.Dispose();

        // ✅ Async shutdown prevents UI freezing
        await OwnaudioNet.ShutdownAsync();
    }
}

// Usage in UI event handler (e.g., WPF Button Click)
private async void InitButton_Click(object sender, RoutedEventArgs e)
{
    InitButton.IsEnabled = false;
    StatusText.Text = "Initializing audio...";

    try
    {
        await _audioPlayer.InitializeAsync(); // UI stays responsive!
        StatusText.Text = "Audio system ready!";
        PlayButton.IsEnabled = true;
    }
    catch (Exception ex)
    {
        StatusText.Text = $"Error: {ex.Message}";
    }
    finally
    {
        InitButton.IsEnabled = true;
    }
}
```

--------------------------------

### Start the Audio Engine

Source: https://modernmube.github.io/OwnAudioSharp/documents/examples.html

Activates the audio engine's real-time processing thread, preparing it to accept audio sources and begin playback. Checks the running status of the engine.

```csharp
OwnaudioNet.Start();

Console.WriteLine($"Engine running: {OwnaudioNet.IsRunning}");
```

--------------------------------

### Server Configuration - Custom Port

Source: https://modernmube.github.io/OwnAudioSharp/documents/networksync.html

Starts the network sync server with a custom UDP port. The server broadcasts at 100Hz with a 10ms interval. `useLocalTimeOnly` ensures operation without an internet connection.

```csharp
// Start server with custom port
await OwnaudioNet.StartNetworkSyncServerAsync(
    port: 9876,                  // UDP port (default: 9876)
    useLocalTimeOnly: true);     // Use local time sync only

// Server is now broadcasting at 100Hz (10ms interval)
```

--------------------------------

### Custom Audio Configuration

Source: https://modernmube.github.io/OwnAudioSharp/documents/quickstart.html

Creates an audio engine with a custom configuration, allowing for specific sample rates, channel counts, buffer sizes, and enabling/disabling input/output. The engine must be initialized and started with the custom configuration.

```csharp
// Create custom audio configuration
var config = new AudioConfig
{
    SampleRate = 44100,
    Channels = 2,
    BufferSize = 256,        // Low latency
    EnableOutput = true,
    EnableInput = false
};

// Create engine with custom config
using var engine = AudioEngineFactory.Create(config);
engine.Initialize(config);
engine.Start();

// Use the engine...
engine.Stop();Copy
```

--------------------------------

### Initialize and Analyze Audio with AudioAnalyzer

Source: https://modernmube.github.io/OwnAudioSharp/documents/matchering.html

Demonstrates how to create an instance of the AudioAnalyzer and perform spectral analysis on an audio file. Ensure the 'OwnaudioNET.Features.Matchering' namespace is included.

```csharp
using OwnaudioNET.Features.Matchering;

// Create analyzer instance
var analyzer = new AudioAnalyzer();

// Analyze audio file
AudioSpectrum spectrum = analyzer.AnalyzeAudioFile("input.wav");
```

--------------------------------

### Full VST3 Integration

Source: https://modernmube.github.io/OwnAudioSharp/documents/effects.html

Demonstrates a complete workflow including engine initialization, plugin loading, audio source configuration, and playback management.

```csharp
using OwnaudioNET;
using OwnaudioNET.Effects.VST;
using OwnaudioNET.Sources;

// Initialize audio engine
OwnaudioNET.Initialize();

var config = new AudioConfig
{
    SampleRate = 48000,
    Channels = 2,
    BufferSize = 512
};

// Load VST3 plugin
var vstHost = new VST3PluginHost("/Library/Audio/Plug-Ins/VST3/FabFilter Pro-Q 3.vst3");
Console.WriteLine($"Loaded: {vstHost.Name} by {vstHost.Vendor} v{vstHost.Version}");
Console.WriteLine($"Type: {(vstHost.IsEffect ? "Effect" : "")} {(vstHost.IsInstrument ? "Instrument" : "")}");

// Open plugin editor for user control
if (vstHost.HasEditor)
{
    vstHost.OpenEditor("EQ Plugin");
}

// Create processor and initialize with audio config
var vstProcessor = vstHost.GetProcessor();
vstProcessor.Initialize(config);
vstProcessor.Mix = 0.8f; // 80% wet, 20% dry

// Create audio source and wrap with effects capability
var fileSource = new FileSource("input.wav");
var audioSource = new SourceWithEffects(fileSource);
audioSource.AddEffect(vstProcessor);

// Add to mixer
var mixer = new Mixer(config);
mixer.AddSource(audioSource);

// Optionally add as master effect
// mixer.AddMasterEffect(vstProcessor);

// Play audio with VST processing
mixer.Start();

// Adjust parameters during playback
vstHost.SetParameter(0, 0.5); // Adjust first parameter

// Clean up
mixer.Stop();
vstHost.CloseEditor();
vstHost.Dispose();
OwnaudioNET.Shutdown();
```

--------------------------------

### Initialize Managed Audio Engine

Source: https://modernmube.github.io/OwnAudioSharp/index.html

Demonstrates creating a managed audio engine, including platform-specific implementations.

```csharp
// Create MANAGED audio engine (OPTIONAL - pure C#)
// Note: Managed engines may experience GC-related glitches
using var engine = AudioEngineFactory.CreateManaged();

// Or create platform-specific managed engine:
#if WINDOWS
    using var engine = new WasapiEngine();
#elif LINUX
    using var engine = new PulseAudioEngine();
#elif MACOS
    using var engine = new CoreAudioEngine();
#endif

// Rest of the code is the same
var config = new AudioConfig { SampleRate = 48000, Channels = 2 };
engine.Initialize(config);
engine.Start();

using var decoder = AudioDecoderFactory.Create("music.mp3",
    targetSampleRate: 48000,
    targetChannels: 2);

// Use the new, efficient zero-allocation pattern
var buffer = new byte[config.BufferSize * config.Channels * sizeof(float)];
while (true)
{
    var result = decoder.ReadFrames(buffer);
    if (result.IsEOF) break;

    var samples = System.Runtime.InteropServices.MemoryMarshal.Cast(buffer.AsSpan(0, result.FramesRead * config.Channels * sizeof(float)));
    engine.Send(samples);
}

engine.Stop();
```

--------------------------------

### Get and Set Parameters

Source: https://modernmube.github.io/OwnAudioSharp/documents/effects.html

Retrieves all available parameters or modifies specific values using normalized 0.0-1.0 ranges.

```csharp
// Get all parameters
var parameters = host.GetParameters();
foreach (var param in parameters)
{
    Console.WriteLine($"{param.Name}: {param.CurrentValue:F3} [{param.MinValue}-{param.MaxValue}]");
}

// Set parameter by ID (normalized 0.0-1.0)
host.SetParameter(0, 0.75);

// Get current value
double value = host.GetParameter(0);
Console.WriteLine($"Parameter 0 value: {value:F3}");
```

--------------------------------

### Initialize Native Audio Engine

Source: https://modernmube.github.io/OwnAudioSharp/index.html

Demonstrates creating a GC-free native audio engine and streaming decoded audio frames.

```csharp
// Create NATIVE audio engine (DEFAULT - GC-free!)
using var engine = AudioEngineFactory.CreateDefault();
// Or explicitly request native engine:
// using var engine = AudioEngineFactory.CreateNative();

// Configure and start the engine
var config = new AudioConfig
{
    SampleRate = 48000,
    Channels = 2,
    BufferSize = 512
};
engine.Initialize(config);
engine.Start();

// Create decoder for audio file
using var decoder = AudioDecoderFactory.Create("music.mp3",
    targetSampleRate: 48000,
    targetChannels: 2);

// Decode and send audio frames
// Use the new, efficient zero-allocation pattern
var buffer = new byte[config.BufferSize * config.Channels * sizeof(float)];
while (true)
{
    var result = decoder.ReadFrames(buffer);
    if (result.IsEOF) break;

    var samples = System.Runtime.InteropServices.MemoryMarshal.Cast(buffer.AsSpan(0, result.FramesRead * config.Channels * sizeof(float)));
    engine.Send(samples);
}

engine.Stop();
```

--------------------------------

### Preset Processing

Source: https://modernmube.github.io/OwnAudioSharp/documents/matchering.html

Examples of using presets for audio processing, including single file and batch processing, as well as retrieving available presets.

```APIDOC
## Preset Processing Example

### Description
Demonstrates how to process audio files using predefined or custom presets.

### Method
`AudioAnalyzer.ProcessWithEnhancedPreset`
`AudioAnalyzer.BatchProcessWithEnhancedPreset`
`AudioAnalyzer.GetAvailablePresets`

### Parameters
#### ProcessWithEnhancedPreset
- **sourceFile** (string) - Required - Path to the input audio file.
- **outputFile** (string) - Required - Path for the processed output audio file.
- **system** (PlaybackSystem) - Required - The target playback system (e.g., Headphones, ClubPA).
- **eqOnlyMode** (bool) - Optional - If true, only EQ adjustments are applied; otherwise, dynamics are also processed.
- **tempDirectory** (string) - Optional - Directory for temporary files.

#### BatchProcessWithEnhancedPreset
- **sourceFiles** (string[]) - Required - An array of paths to input audio files.
- **baseSampleFile** (string) - Required - A reference audio file for comparison.
- **outputDirectory** (string) - Required - Directory where processed files will be saved.
- **system** (PlaybackSystem) - Required - The target playback system.
- **fileNameSuffix** (string) - Optional - Suffix to append to the output filenames.

### Request Example
```csharp
var analyzer = new AudioAnalyzer();

// Process with specific preset
analyzer.ProcessWithEnhancedPreset(
    sourceFile: "input.wav",
    outputFile: "output.wav",
    system: PlaybackSystem.Headphones,
    eqOnlyMode: true  // Apply only EQ, no dynamics
);

// Batch process multiple files
analyzer.BatchProcessWithEnhancedPreset(
    sourceFiles: new[] { "song1.wav", "song2.wav", "song3.wav" },
    baseSampleFile: "reference.flac",
    outputDirectory: @"C:\Output",
    system: PlaybackSystem.ClubPA,
    fileNameSuffix: "_club"
);

// Get all available presets
var presets = AudioAnalyzer.GetAvailablePresets();
foreach (var preset in presets)
{
    Console.WriteLine($"{preset.Key}: {preset.Value.Name}");
}
```

### Response
#### Success Response (200)
Processing status and completion messages.

#### Response Example
Console output indicating processing progress and completion.
```

--------------------------------

### Initialize and Apply Factory Preset

Source: https://modernmube.github.io/OwnAudioSharp/documents/effects.html

Demonstrates how to initialize the SmartMaster effect and apply a predefined speaker preset.

```csharp
using OwnaudioNET.Effects.SmartMaster;

// Initialize SmartMaster
var smartMaster = new SmartMasterEffect();
smartMaster.Initialize(engine.Config);

// Option 1: Use factory preset
smartMaster.LoadSpeakerPreset(SpeakerType.HiFi);
smartMaster.Enabled = true;

// Apply to mixer output
mixer.AddMasterEffect(smartMaster);
```

--------------------------------

### Basic Playback in Console Applications

Source: https://modernmube.github.io/OwnAudioSharp/documents/quickstart.html

Demonstrates synchronous initialization and playback for console applications. Ensure to call `Shutdown()` when finished.

```csharp
using OwnaudioNET;
using OwnaudioNET.Sources;

// Initialize OwnaudioNET (synchronous - OK for console apps)
OwnaudioNet.Initialize();

// Create file source
var source = new FileSource("music.mp3");

// Create mixer and add source
var mixer = new AudioMixer(OwnaudioNet.Engine);
mixer.AddSource(source);
mixer.Start();

// Play the source
source.Play();

// Wait for playback to finish
while (!source.IsEndOfStream)
{
    Thread.Sleep(100);
}

// Clean up
mixer.Stop();
mixer.Dispose();
source.Dispose();
OwnaudioNet.Shutdown();
```

--------------------------------

### Triple-Model Averaging Pipeline

Source: https://modernmube.github.io/OwnAudioSharp/documents/vocalremover.html

Demonstrates setting up a 3-model averaging pipeline using `MultiModelExtensions.CreateTriplePipeline`. This example also shows how to access intermediate per-model outputs from the result.

```csharp
using var separator = MultiModelExtensions.CreateTriplePipeline(
    model1: InternalModel.Best,
    model2: InternalModel.Default,
    model3: InternalModel.Karaoke,
    outputDirectory: "output_triple"
);

separator.Initialize();
var result = separator.Separate("song.flac");

// Final averaged outputs
Console.WriteLine($"Vocals:       {result.VocalsPath}");
Console.WriteLine($"Instrumental: {result.InstrumentalPath}");

// Intermediate per-model outputs (saved because the helper enables it)
foreach (var kv in result.IntermediatePaths)
    Console.WriteLine($"  {kv.Key}: {kv.Value}");
```

--------------------------------

### Initialize and Manage Audio Devices

Source: https://modernmube.github.io/OwnAudioSharp/documents/architecture.html

Demonstrates the lifecycle of an audio engine, including initialization, playback control, and device selection. Note that Initialize, Send, and Stop are blocking operations and must not be called on the UI thread.

```csharp
IAudioEngine engine = AudioEngineFactory.CreateDefault();

// Initialize device (50-5000ms - DO NOT call on UI thread!)
engine.Initialize(config);

// Start playback
engine.Start();

// Send audio samples (10-50ms - BLOCKING!)
engine.Send(samples);

// Stop playback (up to 2000ms - BLOCKING!)
engine.Stop();

// Device management
List<AudioDeviceInfo> outputs = engine.GetOutputDevices();
engine.SetOutputDeviceByName("Speakers");
engine.OutputDeviceChanged += OnDeviceChanged;
```

--------------------------------

### Load and Use VST3 Plugin

Source: https://modernmube.github.io/OwnAudioSharp/documents/effects.html

Initializes a VST3 plugin host and retrieves a processor for the audio engine. Ensure the plugin path is valid and dispose of the host after use.

```csharp
using OwnaudioNET.Effects.VST;

// Load a VST3 plugin
var host = new VST3PluginHost("/path/to/plugin.vst3");

Console.WriteLine($"Loaded: {host.Name} by {host.Vendor}");
Console.WriteLine($"Parameters: {host.ParameterCount}");
Console.WriteLine($"Has Editor: {host.HasEditor}");

// Get processor for audio engine
var processor = host.GetProcessor();
processor.Initialize(audioConfig);

// Add to audio source
audioSource.AddEffect(processor);

// Clean up when done
host.Dispose();
```

--------------------------------

### Configure Mixer and Master Clock Synchronization

Source: https://modernmube.github.io/OwnAudioSharp/documents/examples.html

Adds audio sources to the mixer and attaches them to the Master Clock for sample-accurate synchronization. Sets start offsets and initiates playback.

```csharp
mixer.AddSource(fileSource0);
mixer.AddSource(fileSource1);
mixer.AddSource(fileSource2);
mixer.AddSource(fileSource3);

// Attach all sources to Master Clock for sample-accurate sync
fileSource0.AttachToClock(mixer.MasterClock);
fileSource1.AttachToClock(mixer.MasterClock);
fileSource2.AttachToClock(mixer.MasterClock);
fileSource3.AttachToClock(mixer.MasterClock);

// Optional: Set timeline positions (all start at 0.0 by default)
fileSource0.StartOffset = 0.0;  // Drums start immediately
fileSource1.StartOffset = 0.0;  // Bass starts immediately
fileSource2.StartOffset = 0.0;  // Other starts immediately
fileSource3.StartOffset = 0.0;  // Vocals start immediately

// Start mixer
mixer.Start();

// Start all sources for playback
fileSource0.Play();
fileSource1.Play();
fileSource2.Play();
fileSource3.Play();

// All attached sources now play in perfect sync
```

--------------------------------

### Process Audio with Presets

Source: https://modernmube.github.io/OwnAudioSharp/documents/matchering.html

Demonstrates how to process single or batch audio files using predefined playback system presets.

```csharp
var analyzer = new AudioAnalyzer();

// Process with specific preset
analyzer.ProcessWithEnhancedPreset(
    sourceFile: "input.wav",
    outputFile: "output.wav",
    system: PlaybackSystem.Headphones,
    eqOnlyMode: true  // Apply only EQ, no dynamics
);

// Batch process multiple files
analyzer.BatchProcessWithEnhancedPreset(
    sourceFiles: new[] { "song1.wav", "song2.wav", "song3.wav" },
    baseSampleFile: "reference.flac",
    outputDirectory: @"C:\Output",
    system: PlaybackSystem.ClubPA,
    fileNameSuffix: "_club"
);

// Get all available presets
var presets = AudioAnalyzer.GetAvailablePresets();
foreach (var preset in presets)
{
    Console.WriteLine($"{preset.Key}: {preset.Value.Name}");
}
```

--------------------------------

### Create and Use InputSource

Source: https://modernmube.github.io/OwnAudioSharp/documents/api-net.html

Initializes OwnaudioNET and creates an InputSource for real-time audio input. Requires the engine to be running.

```csharp
// Initialize OwnaudioNET (engine must be running)
OwnaudioNet.Initialize();

// Create input source
var input = new InputSource(
    engine: OwnaudioNet.Engine,
    bufferSizeInFrames: 8192  // Optional, default is 8192
);

// Add to mixer and start
mixer.AddSource(input);
input.Play();
```

--------------------------------

### Basic Audio Playback

Source: https://modernmube.github.io/OwnAudioSharp/documents/quickstart.html

Decodes an audio file and plays it using the default audio engine. Ensure the audio file exists and the engine is properly initialized and started.

```csharp
using Ownaudio.Core;
using Ownaudio.Decoders;

// Create audio engine with default settings (48kHz, stereo, 512 frames)
using var engine = AudioEngineFactory.CreateDefault();

// Initialize and start the engine
engine.Initialize(AudioConfig.Default);
engine.Start();

// Create decoder for audio file
using var decoder = AudioDecoderFactory.Create(
    "music.mp3",
    targetSampleRate: 48000,
    targetChannels: 2
);

// Decode and play frames
while (true)
{
    var result = decoder.DecodeNextFrame();
    if (result.IsEOF) break;
    
    // Send samples to engine (zero-allocation)
    engine.Send(result.Frame.Samples);
}

// Stop the engine
engine.Stop();Copy
```

--------------------------------

### Integrate VST3 Plugins

Source: https://modernmube.github.io/OwnAudioSharp/documents/architecture.html

Shows how to load and initialize a VST3 effect processor and apply it to an audio source within the mixer.

```csharp
var mixer = new AudioMixer(engine);
var source = new FileSource("guitar.wav", engine);

// Load VST3 effect
var vstEffect = new VST3EffectProcessor("C:\\VST3\\Distortion.vst3");
vstEffect.Initialize(source.Config);

var sourceWithVST = new SourceWithEffects(source);
sourceWithVST.AddEffect(vstEffect);

mixer.AddSource(sourceWithVST);
mixer.Start();
```

--------------------------------

### Initialize Audio Engine with Custom Configuration

Source: https://modernmube.github.io/OwnAudioSharp/documents/examples.html

Configure and initialize the audio engine with specific sample rate, channel count, and buffer size. The engine automatically selects the appropriate native audio API for the platform. Displays initialization status and configuration parameters.

```csharp
using Ownaudio.Core;
using OwnaudioNET.Core;

AudioConfig config = new AudioConfig()
{
    SampleRate = 48000,
    Channels = 2,
    BufferSize = 512
};

OwnaudioNet.Initialize(config);

Console.WriteLine($"Initialized: {OwnaudioNet.IsInitialized}");
Console.WriteLine($"Version: {OwnaudioNet.Version}");
Console.WriteLine($"Sample Rate: {OwnaudioNet.Engine?.Config.SampleRate} Hz");
Console.WriteLine($"Channels: {OwnaudioNet.Engine?.Config.Channels}");
Console.WriteLine($"Buffer Size: {OwnaudioNet.Engine?.FramesPerBuffer} frames");
```

--------------------------------

### Synchronize Sources with Master Clock

Source: https://modernmube.github.io/OwnAudioSharp/documents/api-net.html

Attaches multiple audio sources to the Master Clock for sample-accurate playback and timeline control. Sources must be explicitly started after being added to the mixer.

```csharp
// Create sources
var drums = new FileSource("drums.wav");
var bass = new FileSource("bass.wav");
var guitar = new FileSource("guitar.wav");

// Add to mixer
mixer.AddSource(drums);
mixer.AddSource(bass);
mixer.AddSource(guitar);

// Attach sources to Master Clock
drums.AttachToClock(mixer.MasterClock);
bass.AttachToClock(mixer.MasterClock);
guitar.AttachToClock(mixer.MasterClock);

// Optional: Set start offsets (timeline positioning)
drums.StartOffset = 0.0;    // Starts at 0 seconds
bass.StartOffset = 0.0;     // Starts at 0 seconds
guitar.StartOffset = 2.0;   // Starts at 2 seconds (delayed)

// Start mixer
mixer.Start();

// Start all sources for playback (IMPORTANT!)
drums.Play();
bass.Play();
guitar.Play();

// All attached sources now play in perfect sync with Master Clock

// Timeline control
mixer.MasterClock.SeekTo(10.0);  // Seek all tracks to 10 seconds

// Get current timeline position
double currentTime = mixer.MasterClock.CurrentTimestamp;
long samplePosition = mixer.MasterClock.CurrentSamplePosition;

// Rendering modes
mixer.MasterClock.Mode = ClockMode.Realtime;  // Default: dropout → silence + event
mixer.MasterClock.Mode = ClockMode.Offline;   // Offline: blocking, deterministic
```

--------------------------------

### Initialize OwnaudioNET API

Source: https://modernmube.github.io/OwnAudioSharp/index.html

Demonstrates asynchronous initialization and high-level audio mixing with effects for UI applications.

```csharp
// Initialize OwnaudioNET (async for UI apps!)
await OwnaudioNet.InitializeAsync();

// Create file source
var source = new FileSource("music.mp3");

// Create mixer and add source
var mixer = new AudioMixer(OwnaudioNet.Engine);
mixer.AddSource(source);
mixer.Start();

// Play the source
source.Play();

// Apply professional effects
var reverb = new ReverbEffect { Mix = 0.3f, RoomSize = 0.7f };
var compressor = new CompressorEffect(threshold: 0.5f, ratio: 4.0f, sampleRate: 48000f);
var sourceWithEffects = new SourceWithEffects(source, reverb, compressor);

// Control playback
source.Volume = 0.8f;
source.Seek(30.0); // seconds
```

--------------------------------

### Recording Audio Input

Source: https://modernmube.github.io/OwnAudioSharp/documents/quickstart.html

Configures the audio engine to enable input and then receives audio samples from the input device. The received samples can then be processed. Ensure the engine is initialized and started with input enabled.

```csharp
// Enable input in configuration
var config = new AudioConfig
{
    SampleRate = 48000,
    Channels = 2,
    BufferSize = 512,
    EnableInput = true,
    EnableOutput = false
};

using var engine = AudioEngineFactory.Create(config);
engine.Initialize(config);
engine.Start();

// Receive audio samples from input
var buffer = new float[config.BufferSize * config.Channels];
int samplesReceived = engine.Receives(out buffer);

if (samplesReceived > 0)
{
    // Process received audio samples
    ProcessAudioInput(buffer, samplesReceived);
}

engine.Stop();Copy
```

--------------------------------

### Synchronized Playback with Master Clock

Source: https://modernmube.github.io/OwnAudioSharp/documents/quickstart.html

Utilizes the Master Clock API (v2.1.0+) for sample-accurate synchronization of multiple audio sources. Allows setting start offsets and controlling playback position via the clock.

```csharp
var drums = new FileSource("drums.wav");
var bass = new FileSource("bass.wav");
var guitar = new FileSource("guitar.wav");

mixer.AddSource(drums);
mixer.AddSource(bass);
mixer.AddSource(guitar);

// Attach sources to Master Clock for sample-accurate sync
drums.AttachToClock(mixer.MasterClock);
bass.AttachToClock(mixer.MasterClock);
guitar.AttachToClock(mixer.MasterClock);

// Optional: Set start offsets on timeline
guitar.StartOffset = 2.0;  // Guitar starts 2 seconds later

// Start mixer
mixer.Start();

// Start all sources for playback
drums.Play();
bass.Play();
guitar.Play();

// All sources now play in perfect sync with Master Clock

// Timeline control
mixer.MasterClock.SeekTo(10.0);  // Seek all tracks to 10 seconds
```

--------------------------------

### Create and Use SampleSource

Source: https://modernmube.github.io/OwnAudioSharp/documents/api-net.html

Generates or loads audio samples and creates a SampleSource. Supports dynamic updates by submitting new samples.

```csharp
// Generate or load samples
float[] samples = GenerateAudioSamples();

// Create source from existing samples
var config = new AudioConfig
{
    SampleRate = 48000,
    Channels = 2
};
var source = new SampleSource(samples, config);

// OR create empty source for dynamic updates
var dynamicSource = new SampleSource(
    bufferSizeInFrames: 48000,  // 1 second buffer
    config: config
);

// Update samples dynamically
float[] newSamples = GenerateNewSamples();
dynamicSource.SubmitSamples(newSamples);

// Playback control
source.Play();
source.Loop = true;
```

--------------------------------

### Create Audio Separation Services using Factory Methods

Source: https://modernmube.github.io/OwnAudioSharp/documents/vocalremover.html

Utilize convenient factory methods for quick service creation. Services can be created with internal models, custom model files, or custom output directories.

```csharp
using OwnaudioNET.Features.Vocalremover;

// Create service with internal model
var service1 = AudioSeparationExtensions.CreateDefaultService(InternalModel.Best);

// Create service with custom model file
var service2 = AudioSeparationExtensions.CreateDefaultService("path/to/model.onnx");

// Create service with custom output directory
var service3 = AudioSeparationExtensions.CreatetService(
    InternalModel.Karaoke,
    @"C:\Output\Karaoke"
);

// Create service with custom model and output
var service4 = AudioSeparationExtensions.CreatetService(
    "custom_model.onnx",
    @"C:\Output\Custom"
);
```

--------------------------------

### Initialize RealTimeChordDetector

Source: https://modernmube.github.io/OwnAudioSharp/documents/chorddetect.html

Provides real-time chord detection with stability tracking for continuous audio analysis.

```csharp
public class RealTimeChordDetector
{
    public RealTimeChordDetector(
        int bufferSize = 5,
        DetectionMode mode = DetectionMode.Optimized);
    
    public (string chord, float stability) ProcessNotes(List<Note> newNotes);
}
```

--------------------------------

### Create Audio Engines with AudioEngineFactory

Source: https://modernmube.github.io/OwnAudioSharp/documents/api-core.html

Use these methods to instantiate audio engines with either default, latency-specific, or custom configurations.

```csharp
// Default configuration
using var engine1 = AudioEngineFactory.CreateDefault();

// Low latency
using var engine2 = AudioEngineFactory.CreateLowLatency();

// Custom configuration
var config = new AudioConfig
{
    SampleRate = 44100,
    Channels = 2,
    BufferSize = 256,
    EnableInput = true
};
using var engine3 = AudioEngineFactory.Create(config);
```

--------------------------------

### Record Audio Output

Source: https://modernmube.github.io/OwnAudioSharp/documents/quickstart.html

Initializes the audio engine and manages recording sessions to a file.

```csharp
var config = new AudioConfig
{
    SampleRate = 48000,
    Channels = 2,
    BufferSize = 512
};

OwnaudioNet.Initialize(config);

var mixer = new AudioMixer(OwnaudioNet.Engine);
mixer.Start();

// Start recording output to file
mixer.StartRecording("output.wav");

// ... play sources ...

// Stop recording
mixer.StopRecording();
```

--------------------------------

### Perform Multi-Track DAW-Style Mixing

Source: https://modernmube.github.io/OwnAudioSharp/documents/architecture.html

Demonstrates loading multiple audio sources, applying per-source effects, configuring a master effect chain, and synchronizing playback using a master clock.

```csharp
var engine = AudioEngineFactory.CreateDefault();
var mixer = new AudioMixer(engine);

// Load tracks
var drums = new FileSource("drums.wav", engine);
var bass = new FileSource("bass.wav", engine);
var vocals = new FileSource("vocals.wav", engine);

// Add effects to vocals
var vocalsWithFX = new SourceWithEffects(vocals);
vocalsWithFX.AddEffect(new ReverbEffect(roomSize: 0.7f));
vocalsWithFX.AddEffect(new DelayEffect(200f, 0.3f));

// Add to mixer
mixer.AddSource(drums);
mixer.AddSource(bass);
mixer.AddSource(vocalsWithFX);

// Master chain
mixer.AddMasterEffect(new Equalizer30BandEffect());
mixer.AddMasterEffect(new CompressorEffect(threshold: -10f));
mixer.AddMasterEffect(new LimiterEffect(ceiling: 0.95f));

// Start mixer
mixer.Start();

// Synchronized playback - Method 1: Master Clock (Recommended)
drums.AttachToClock(mixer.MasterClock);
bass.AttachToClock(mixer.MasterClock);
vocalsWithFX.AttachToClock(mixer.MasterClock);

drums.Play();
bass.Play();
vocalsWithFX.Play();

// OR Method 2: Sync Groups (Legacy, still supported)
// mixer.CreateSyncGroup("multitrack", drums, bass, vocalsWithFX);
// mixer.StartSyncGroup("multitrack");

// Recording
mixer.StartRecording("final_mix.wav");
```

--------------------------------

### Configure ASIO with Native Hardware Channel Selection

Source: https://modernmube.github.io/OwnAudioSharp/documents/api-core.html

Creates an ASIO audio engine configured for stereo output, using native ASIO channel selectors for routing. This method is efficient for ASIO-compatible hardware.

```csharp
// ASIO with native hardware channel selection
var asioConfig = new AudioConfig
{
    HostType = EngineHostType.ASIO,
    Channels = 2,
    OutputChannelSelectors = new[] { 4, 5 }  // native ASIO channel selectors
};
using var asioEngine = AudioEngineFactory.Create(asioConfig);
```

--------------------------------

### Enable GPU Acceleration

Source: https://modernmube.github.io/OwnAudioSharp/documents/vocalremover.html

Demonstrates automatic GPU detection during initialization. Processing speed is significantly faster on GPU compared to CPU.

```csharp
// Automatic GPU detection during initialization
service.Initialize();

// Console output will show:
// "CUDA execution provider enabled." (if GPU available)
// OR
// "Using CPU execution provider." (fallback)

// Processing speed comparison:
// CPU: ~2-5x real-time (depends on CPU cores)
// GPU (CUDA): ~10-30x real-time (depends on GPU model)
```

--------------------------------

### Execute Auto-Calibration Workflow

Source: https://modernmube.github.io/OwnAudioSharp/documents/effects.html

Shows the process for running an auto-calibration measurement, monitoring progress, and saving the resulting configuration.

```csharp
// Option 2: Run auto-calibration (requires measurement microphone)
// Place microphone at primary listening position
await smartMaster.StartMeasurementAsync();

// Monitor progress
var status = smartMaster.GetMeasurementStatus();
Console.WriteLine($"Progress: {status.Progress * 100:F0}%");
Console.WriteLine($"Step: {status.CurrentStep}");

// Save calibrated settings
smartMaster.Save("my_listening_room");

// Load later
smartMaster.Load("my_listening_room");
```
Tokens:
Raw