Audio Sources

source.Play();
source.Pause();
source.Stop();
source.Seek(double positionInSeconds);  // returns bool
source.RouteToChannels(params int[] channels); // fluent helper
source.Dispose();

var source = new FileSource(
    filePath: "track.mp3",
    bufferSizeInFrames: 8192,   // internal circular buffer (default: 8192)
    targetSampleRate: 48000,    // auto-resampling; 0 = use file's rate
    targetChannels: 2           // auto-channel conversion; 0 = use file's channels
);

// Direct set — mirrored onto the native track right away
source.Tempo      = 1.1f;   // 10% faster  (range: 0.8 – 1.2)
source.PitchShift = 2.0f;   // 2 semitones up  (range: -12.0 – +12.0)

// Same thing, named for slider call sites
source.SetTempoSmooth(1.1f);
source.SetPitchSmooth(2.0f);

// Clock-synced tracks: call this once the slider settled, it reseeks away the drift
source.SetTempoSynced(1.1f);

// A waveform for a 2000 pixel wide display — one decoder pass, one 2000-float array
float[] peaks = source.GetPeaks(2000);

// Raw samples, whole file or a slice of it
float[] all   = source.GetFloatAudioData(TimeSpan.Zero);
float[] chunk = source.GetFloatAudioData(TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(10));

// Same slice as bytes, in the file's own sample format
byte[] bytes = source.GetByteAudioData(TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(10));

int sr = OwnaudioNet.Engine!.Config.SampleRate;
int ch = OwnaudioNet.Engine!.Config.Channels;

var source = new FileSource("backing.mp3",
    bufferSizeInFrames: 4096,
    targetSampleRate: sr,
    targetChannels: ch);

source.Volume      = 0.8f;
source.Pan         = -0.3f;                // slightly left
source.Tempo       = GlobalTempo / 100f;  // e.g. 100 → 1.0f
source.PitchShift  = 0;
source.StartOffset = 0.0;

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

mixer.AddSource(source);

// Static sample
float[] samples = LoadSamplesFromFile("click.wav");
var click = new SampleSource(samples, OwnaudioNet.CreateDefaultConfig());
mixer.AddSource(click);
click.Play();

// Dynamic — submit samples in real time
var synth = new SampleSource(bufferSizeInFrames: 2048, OwnaudioNet.CreateDefaultConfig());
synth.AllowDynamicUpdate = true;

// Submit new samples as they are generated
synth.SubmitSamples(newSamples); // ReadOnlySpan<float>
synth.Clear();                   // flush buffer

var lane = new GroupSource(
    sampleRate: 48000,        // every clip decodes to this — must be the mixer's rate
    channels: 2,              // every clip decodes to this width
    memoryMaxSeconds: 30.0    // files up to this long load into memory, longer ones stream
);

// Loads the file and places it at 0 s / 12.5 s on the lane's content timeline
SourceClip verse  = lane.AddClip("verse.wav", 0.0);
SourceClip chorus = lane.AddClip("chorus.wav", 12.5);

// Move it — heard from the next render block, playing or not
chorus.StartSeconds = 16.0;

// Take it off and release its audio
lane.RemoveClip(verse);

int sr = OwnaudioNet.Engine!.Config.SampleRate;
int ch = OwnaudioNet.Engine!.Config.Channels;

var lane = new GroupSource(sr, ch);
await Task.Run(() =>
{
    lane.AddClip("intro.wav",  0.0);
    lane.AddClip("verse.wav",  8.0);
    lane.AddClip("outro.wav", 40.0);
});

var fx = new SourceWithEffects(lane);
fx.AddEffect(new ReverbEffect());   // the tail rings on over every clip edge

fx.Volume = 0.8f;
fx.Tempo  = 1.05f;

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

mixer.AddSource(fx);
fx.Play();

var source = new StreamingSource(
    render: MyGenerator,                    // AudioRenderCallback
    config: OwnaudioNet.CreateDefaultConfig()
);

public delegate void AudioRenderCallback(
    Span<float> buffer,    // interleaved destination, exactly frameCount × Config.Channels long
    int frameCount,        // frames to produce
    long framePosition     // absolute frame index of the first requested frame
);

var synth = new StreamingSource(RenderSynth, config);

// Live from a keyboard: trade CPU for latency
synth.LookAheadSeconds = 0.02;          // ~20 ms

// Long backing pad, nobody plays it: let the pump idle
synth.LookAheadSeconds = 0.25;

double now = synth.LookAheadSeconds;    // what it actually settled on

var config = OwnaudioNet.CreateDefaultConfig();
float frequency = 440f;   // live-adjustable from the UI thread

void RenderSine(Span<float> buffer, int frameCount, long framePosition)
{
    int ch = config.Channels;
    double step = 2.0 * Math.PI * frequency / config.SampleRate;

    for (int f = 0; f < frameCount; f++)
    {
        // phase comes from the absolute position — a seek stays in phase
        float sample = (float)Math.Sin((framePosition + f) * step) * 0.2f;
        for (int c = 0; c < ch; c++)
            buffer[f * ch + c] = sample;
    }
}

var tone = new StreamingSource(RenderSine, config);
tone.Volume = 0.8f;
mixer.AddSource(tone);
tone.Play();

frequency = 880f;   // takes effect within LookAheadSeconds, no restart needed

// Enable input in AudioConfig first
var config = OwnaudioNet.CreateDefaultConfig();
config.EnableInput = true;
await OwnaudioNet.InitializeAsync(config);
OwnaudioNet.Start();

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

var mic = new InputSource(OwnaudioNet.Engine!, bufferSizeInFrames: 8192);
mixer.AddSource(mic);
mic.Play();

// Monitor input peak levels
var (leftLevel, rightLevel) = mic.GetInputLevels();

var source   = new FileSource("vocal.wav");
var trackFx  = new SourceWithEffects(source);

// Build effect chain
trackFx.AddEffect(new CompressorEffect { Threshold = -12f, Ratio = 4f });
trackFx.AddEffect(new ReverbEffect { RoomSize = 0.4f, Mix = 0.2f });
trackFx.AddEffect(new EqualizerEffect());

// Add the wrapper to the mixer — NOT the raw source
mixer.AddSource(trackFx);

// Manage the chain
trackFx.RemoveEffect(effect);   // returns bool
trackFx.ClearEffects();
int count           = trackFx.EffectCount;
IEffectProcessor[] fx = trackFx.GetEffects();

// Open a 4-channel output — the 4 bus channels drive physical channels 0–3 in order
var config = new AudioConfig
{
    Channels = 4
};

// Route music to channels 0+1, metronome to channels 2+3
var music     = new FileSource("music.mp3");
var metronome = new FileSource("click.wav");

music.OutputChannelMapping     = new[] { 0, 1 };
metronome.OutputChannelMapping = new[] { 2, 3 };

// Fluent style
music.RouteToChannels(0, 1);
metronome.RouteToChannels(2, 3);

mixer.AddSource(music);
mixer.AddSource(metronome);

// Stereo file loaded as mono — decoder sums L+R to a single channel
var source = new FileSource("stereo.wav", targetChannels: 1);
// source.Config.Channels == 1

source.OutputChannelMapping = new[] { 0 }; // route the mono signal to output channel 0
mixer.AddSource(source);

// Mono file loaded as stereo — decoder duplicates the signal to both channels
var source = new FileSource("mono.wav", targetChannels: 2);
// source.Config.Channels == 2

source.RouteToChannels(2, 3); // spread to output channels 2+3
mixer.AddSource(source);

var click = new FileSource("click.wav", targetChannels: 1);

// bus 0 ← nothing, bus 1 ← nothing, bus 2 ← src 0, bus 3 ← src 0
click.OutputRoute = new OutputRoute(new[] { -1, -1, 0, 0 });

// Fluent, with a per-destination gain — the drummer's cue at half level
click.RouteTo(new[] { -1, -1, 0, 0 }, new[] { 1f, 1f, 0.5f, 0.5f });

mixer.AddSource(click);

var song = new FileSource("song.flac");
song.DecodeChannels = 2;                        // stereo chain on an 8-channel bus
song.OutputRoute    = new OutputRoute(new[] { 0, 1, -1, -1, -1, -1, -1, -1 });

mixer.AddSource(song);                          // set it before adding, it is read on attach

var vocal = new InputSource(OwnaudioNet.Engine!);
vocal.CaptureChannels = new[] { 4 };          // mono, off physical input 5

var guitar = new InputSource(OwnaudioNet.Engine!);
guitar.CaptureChannels = new[] { 0, 1 };      // stereo, off inputs 1+2

mixer.AddSource(vocal);
mixer.AddSource(guitar);

// How many inputs are really there? Ask the engine, not the config.
int available = OwnaudioNet.Engine!.ActualInputChannels;