AudioMixer

// Wired straight at the engine: the rust session renders, a control tick mirrors state
var mixer = new AudioMixer(OwnaudioNet.Engine!.UnderlyingEngine, bufferSizeInFrames: 512);

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

var mixer = AudioMixer.Create(OwnaudioNet.Engine!, bufferSizeInFrames: 512);

// Add sources and effects as usual
mixer.AddSource(source1);
mixer.AddMasterEffect(new CompressorEffect());
await host.InitializeAudioAsync(sampleRate: 48000, maxBlockSize: 512);
mixer.AddMasterEffect(host.GetProcessor()); // VST3

mixer.Start();

mixer.Start();                      // begin audio processing
mixer.Pause();                      // hold the mix where it is
mixer.Stop();                       // stop every source, but they stay registered
mixer.Seek(double positionInSec);   // move the master clock and every file track with it
mixer.Dispose();                    // release all resources

// Add and immediately start — the mixer has to be running for the "start" half
mixer.Start();
mixer.AddSource(source);

// Add without starting — launch all at once for tight sync
mixer.AddSourcePrepared(vocals);
mixer.AddSourcePrepared(backing);
mixer.StartPreparedSources(startPosition: 0.0); // atomic start

// Remove
mixer.RemoveSource(source);          // by reference
mixer.RemoveSource(sourceGuid);      // by ID
mixer.ClearSources();                // remove + stop all

// Query
IAudioSource[] all = mixer.GetSources();

// Add effects in chain order
mixer.AddMasterEffect(new CompressorEffect { Ratio = 4f });
mixer.AddMasterEffect(new ReverbEffect { RoomSize = 0.5f, Mix = 0.2f });
mixer.AddMasterEffect(new LimiterEffect(sampleRate: 48000f));

// Manage
mixer.RemoveMasterEffect(effect);   // returns bool
mixer.ClearMasterEffects();
IEffectProcessor[] fx = mixer.GetMasterEffects();

mixer.StartRecording("session.wav"); // start capturing
// ... playback ...
mixer.StopRecording();               // finalize and close the WAV file

// Recording live input? Trim the capture delay so the take starts
// where you hit record, not a few ms late.
mixer.StartRecording("take.wav", compensateInputLatency: true);
// ...
mixer.StopRecording();
int trimmed = mixer.LastRecordingLatencyOffsetFrames; // frames dropped off the front

using OwnaudioNET.Mixing;

var source = new FileSource("song.flac");
source.Play();   // a source that isn't playing hands back silence, not audio

using (var wav = new WaveFileWriter("bounce.wav", source.Config))
{
    float[] buffer = new float[4096 * source.Config.Channels];

    while (!source.IsEndOfStream)
    {
        int frames = source.ReadSamples(buffer, 4096);
        if (frames <= 0) break;

        wav.WriteSamples(buffer.AsSpan(0, frames * source.Config.Channels));
    }
}   // header is finalized here — nothing plays the file before this

// Master chain owns the main pair only; 2–7 pass through untouched
mixer.MasterChannelScope = new[] { 0, 1 };

// SmartMasterEffect lives in OwnaudioNET.Effects.SmartMaster
mixer.AddMasterEffect(new SmartMasterEffect());   // limits 0+1, never the cue mix

// Back to the whole bus
mixer.MasterChannelScope = Array.Empty<int>();

// Update at ~10Hz (100ms timer)
_vuTimer = new Timer(_ =>
{
    // Master bus
    float leftDb  = 20f * MathF.Log10(Math.Max(mixer.LeftPeak,  1e-6f));
    float rightDb = 20f * MathF.Log10(Math.Max(mixer.RightPeak, 1e-6f));
    MasterLeftDb  = Math.Max(leftDb,  -60f);
    MasterRightDb = Math.Max(rightDb, -60f);

    // Per-track (if source is BaseAudioSource)
    var (l, r) = source.OutputLevels;
    TrackLeftDb = 20f * MathF.Log10(Math.Max(l, 1e-6f));
}, null, 0, 100);

// Poll on a UI timer — reading it costs a handful of atomics
var load = mixer.SessionLoad;               // null while the mixer does not own the device

if (load is { } l)
{
    CpuBar = l.AverageLoad;                 // 0.35 = a third of the block period
    if (l.HasOverrun)                       // PeakLoad >= 1.0, a block already ran over
        Log.Warning($"late block: {l}");    // ToString gives the whole picture in one line
}

mixer.ResetSessionLoad();                   // zero the tallies once playback has settled

mixer.PlaybackEnded += (_, _) =>
{
    // All tracks finished — update UI state
};

mixer.StreamFaulted += (_, e) =>
{
    if (e.Kind == AudioStreamFaultKind.DeviceNotAvailable)
        Console.WriteLine($"{e.Direction} device disappeared.");
};

// Underruns are counted by the engine, not the mixer
OwnaudioNet.Engine!.BufferUnderrun += (_, e) =>
{
    Console.WriteLine($"Underrun: {e.MissedFrames} frames at position {e.Position}");
};