Core Ownaudio.Core API Reference

public interface IAudioEngine
{
    // Properties
    int FramesPerBuffer { get; }
    
    // Lifecycle Methods
    int Initialize(AudioConfig config);
    int Start();
    int Stop();
    int OwnAudioEngineActivate();
    int OwnAudioEngineStopped();
    
    // Audio I/O
    void Send(Span<float> samples);
    int Receives(out float[] samples);
    IntPtr GetStream();
    
    // Device Management
    List<AudioDeviceInfo> GetOutputDevices();
    List<AudioDeviceInfo> GetInputDevices();
    int SetOutputDeviceByName(string deviceName);
    int SetOutputDeviceByIndex(int deviceIndex);
    int SetInputDeviceByName(string deviceName);
    int SetInputDeviceByIndex(int deviceIndex);
    
    // Events
    event EventHandler<AudioDeviceChangedEventArgs> OutputDeviceChanged;
    event EventHandler<AudioDeviceChangedEventArgs> InputDeviceChanged;
    event EventHandler<AudioDeviceStateChangedEventArgs> DeviceStateChanged;
}

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

// Start the engine
engine.Start();

// Send audio samples
float[] samples = GenerateAudio();
engine.Send(samples.AsSpan());

// Stop the engine
engine.Stop();

public interface IAudioDecoder : IDisposable
{
    AudioStreamInfo StreamInfo { get; }
    
    AudioDecoderResult DecodeNextFrame();
    bool TrySeek(TimeSpan position, out string error);
    AudioDecoderResult DecodeAllFrames(TimeSpan position);
}

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

// Get stream info
var info = decoder.StreamInfo;
Console.WriteLine($"Duration: {info.Duration}");

// Decode frames
while (true)
{
    var result = decoder.DecodeNextFrame();
    if (result.IsEOF) break;
    
    // Process frame
    ProcessAudioFrame(result.Frame);
}

// Seek to position
if (decoder.TrySeek(TimeSpan.FromSeconds(30), out string error))
{
    Console.WriteLine("Seeked to 30 seconds");
}

// 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
};
using var engine3 = AudioEngineFactory.Create(config);

// Platform info
string platform = AudioEngineFactory.GetPlatformInfo();
Console.WriteLine($"Platform: {platform}"); // e.g., "Windows-WASAPI"

// From file path (auto-detect format)
using var decoder1 = AudioDecoderFactory.Create(
    "music.mp3",
    targetSampleRate: 48000,
    targetChannels: 2
);

// From stream with explicit format
using var stream = File.OpenRead("audio.wav");
using var decoder2 = AudioDecoderFactory.Create(
    stream,
    AudioFormat.Wav,
    targetSampleRate: 48000,
    targetChannels: 2
);

// Use predefined config
var config1 = AudioConfig.Default;

// Custom configuration
var config2 = new AudioConfig
{
    SampleRate = 44100,
    Channels = 1,           // Mono
    BufferSize = 256,       // Low latency
    EnableInput = true,
    EnableOutput = true
};

// Validate configuration
if (config2.Validate())
{
    Console.WriteLine("Configuration is valid");
}

using var engine = AudioEngineFactory.CreateDefault();
engine.Initialize(AudioConfig.Default);

// List output devices
var devices = engine.GetOutputDevices();
foreach (var device in devices)
{
    Console.WriteLine($"Device: {device.Name}");
    Console.WriteLine($"  ID: {device.DeviceId}");
    Console.WriteLine($"  Default: {device.IsDefault}");
    Console.WriteLine($"  State: {device.State}");
}

[Flags]
public enum AudioDeviceState
{
    Active      = 0x00000001,  // Device is active and available
    Disabled    = 0x00000002,  // Device is disabled
    NotPresent  = 0x00000004,  // Device is not present
    Unplugged   = 0x00000008,  // Device is unplugged
    All         = 0x0000000F   // All device states
}

public enum AudioFormat
{
    Unknown,  // Unknown format
    Wav,      // WAV format (PCM, IEEE Float, ADPCM)
    Mp3,      // MP3 format (MPEG-1/2/2.5 Layer III)
    Flac      // FLAC format (Free Lossless Audio Codec)
}