Reference

Application
  └─ OwnaudioNet / AudioMixer / sources / effects   [your unchanged C# code]
       └─ AudioEngineWrapper                          [lock-free, non-blocking bridge]
            └─ Native Rust engine                     [ownaudio-ffi + ownaudio-core]
                 └─ Audio hardware                    [WASAPI / CoreAudio / ALSA · ASIO optional]

source.StateChanged += (_, e) =>
{
    if (e.NewState == AudioState.EndOfStream)
        Console.WriteLine("Track finished.");
};

AudioState.Stopped      // Not playing, position at 0
AudioState.Playing      // Actively reading and outputting audio
AudioState.Paused       // Paused, resumes from current position
AudioState.EndOfStream  // Reached end (Loop = false)
AudioState.Error        // Fatal error in source

ClockMode.Realtime       // Non-blocking — dropouts produce silence (live playback)
ClockMode.Offline        // Blocking — waits for data (deterministic file rendering)
ClockMode.NetworkServer  // Broadcasts clock to LAN clients
ClockMode.NetworkClient  // Follows a remote server clock

EngineStatus.Idle               // Initialized, not started
EngineStatus.Running            // Processing audio
EngineStatus.DeviceDisconnected // Device unplugged (monitoring for reconnect)
EngineStatus.Error              // Fatal engine error

EngineHostType.None       // Auto-select (recommended default)
EngineHostType.ASIO       // ASIO — Windows, ultra-low latency
EngineHostType.COREAUDIO  // macOS Core Audio
EngineHostType.ALSA       // Linux ALSA
EngineHostType.WDMKS      // Windows kernel streaming
EngineHostType.JACK       // JACK server — Linux and macOS
EngineHostType.WASAPI     // Windows Audio Session API
EngineHostType.AAUDIO     // Android 8.0+
EngineHostType.OPENSL     // Older Android and embedded
EngineHostType.WEBAUDIO   // Browsers, via Web Audio

protected override async Task OnInitializedAsync()
{
    var config = OwnaudioNet.CreateDefaultConfig();
    config.EnableInput = false;

    if (OperatingSystem.IsWindows())
        config.HostType = EngineHostType.WASAPI;

    await OwnaudioNet.InitializeAsync(config);
    OwnaudioNet.Start();

    _mixer = new AudioMixer(OwnaudioNet.Engine!.UnderlyingEngine, bufferSizeInFrames: 1024);
    _mixer.Start();
}

public async Task DisposeAsync()
{
    _mixer?.Stop();
    _mixer?.Dispose();

    await OwnaudioNet.ShutdownAsync();
}

float[]? buffer = OwnaudioNet.Receive(out int sampleCount);
if (buffer != null)
{
    try
    {
        // process buffer[0..sampleCount-1] ...
    }
    finally
    {
        OwnaudioNet.ReturnInputBuffer(buffer); // MUST always be called
    }
}

// Poll at ~10 Hz — do not poll faster than the audio buffer interval
_vuTimer = new Timer(_ =>
{
    float leftDb  = 20f * MathF.Log10(Math.Max(_mixer.LeftPeak,  1e-6f));
    float rightDb = 20f * MathF.Log10(Math.Max(_mixer.RightPeak, 1e-6f));

    LeftDb  = Math.Max(leftDb,  -60f); // clamp to -60 dBFS floor
    RightDb = Math.Max(rightDb, -60f);

    // Per-track stereo levels
    var (l, r) = source.OutputLevels;
}, null, 0, 100);

private double _lastEnginePos;
private double _lastEnginePosAt;
private readonly Stopwatch _watch = Stopwatch.StartNew();

// Update at ~30 Hz (33 ms timer)
private void OnPositionTimer()
{
    double enginePos = _mixer.MasterClock.CurrentTimestamp;
    double nowSec    = _watch.Elapsed.TotalSeconds;

    if (enginePos != _lastEnginePos)
    {
        _lastEnginePos   = enginePos;
        _lastEnginePosAt = nowSec;
    }

    // Interpolate between engine callbacks for smooth UI
    double displayPos = _lastEnginePos + (nowSec - _lastEnginePosAt);
    CurrentPositionSeconds = displayPos;
}

// Or use ISynchronizable for sample-accurate per-source position
if (source is ISynchronizable sync)
{
    int    sampleRate = OwnaudioNet.Engine!.Config.SampleRate;
    double posSeconds = sync.SamplePosition / (double)sampleRate;
}

AudioConstants.MaxAudioSources  // 25  — maximum simultaneous sources per mixer
AudioConstants.MinTempo         // 0.8 — minimum tempo multiplier (80% speed)
AudioConstants.MaxTempo         // 1.2 — maximum tempo multiplier (120% speed)

using Ownaudio.Core;
using Ownaudio.Decoders;

// Format is sniffed from the content; 0 means "leave it as the source has it"
using var decoder = AudioDecoderFactory.Create("audio.aac", targetSampleRate: 48000, targetChannels: 2);

// Anything the Symphonia backend cannot open throws AudioException