SoundFlow .NET Audio Framework

The PortMidi backend supports advanced MIDI synchronization via the ConfigureSync method on the backend instance.

Master Mode

Act as a master clock source. You must provide a renderer (typically a Composition.Renderer) to link the MIDI clock, Start, Stop, and Continue messages to the transport of your composition.

Slave Mode

Synchronize the SoundFlow transport to an external device. This supports:

• MIDI Clock: Includes automatic BPM detection.
• MIDI Time Code (MTC): For frame-accurate sync with video or professional equipment.

Parameters for ConfigureSync:

• mode: SyncMode.Master or SyncMode.Slave.
• source: The sync source (not used in Master mode).
• inputDeviceInfo: The input device for Slave mode.
• outputDeviceInfo: The output device for Master mode.
• renderer: The transport renderer to synchronize.

// Example: Master Mode configuration
midiBackend.ConfigureSync(
    mode: SyncMode.Master,
    source: SyncSource.Internal,
    inputDeviceInfo: null,
    outputDeviceInfo: syncOutputDevice,
    renderer: composition.Renderer
);

For processing existing audio files or data streams without a real-time graph, use the NoiseSuppressor component. It works with any ISoundDataProvider.

There are two ways to process data:

1. ProcessAll(): Returns the entire processed signal as a float[]. Best for smaller files.
2. ProcessChunks(): Processes the source in chunks. This is the recommended method for large files to avoid high memory usage. You can subscribe to the OnAudioChunkProcessed event to handle each processed ReadOnlyMemory<float> chunk (e.g., encoding it to a file).

using SoundFlow.Extensions.WebRtc.Apm.Components;

// ... setup sourceForOffline ...

// Process chunk-by-chunk for large files
using var offlineSuppressor = new NoiseSuppressor(sourceForOffline, 48000, 1, NoiseSuppressionLevel.VeryHigh); 

offlineSuppressor.OnAudioChunkProcessed += (chunk) =>
{
    // 'chunk' is ReadOnlyMemory<float>
    encoder.Encode(chunk.ToArray()); 
};

offlineSuppressor.ProcessChunks(); // Blocks until completion

To enable support for a wide range of audio formats (such as MP3, AAC, OGG, Opus, FLAC, etc.), you must register the FFmpegCodecFactory with your AudioEngine instance during initialization. Once registered, the engine will automatically use FFmpeg to decode or encode supported file types without requiring changes to your existing playback or recording logic.

using SoundFlow.Abstracts;
using SoundFlow.Backends.MiniAudio;
using SoundFlow.Codecs.FFMpeg; // 1. Import the FFmpeg codec namespace
using SoundFlow.Components;
using SoundFlow.Providers;
using SoundFlow.Structs;

// 2. Initialize the Audio Engine.
using var engine = new MiniAudioEngine();

// 3. Register the FFmpeg Codec Factory.
// This single line enables support for all FFmpeg formats.
engine.RegisterCodecFactory(new FFmpegCodecFactory());

// From here, the usage is standard SoundFlow.
// The engine will now automatically use FFmpeg when it encounters an MP3 file.

// Initialize a playback device.
using var device = engine.InitializePlaybackDevice(null, AudioFormat.DvdHq);

// Create a SoundPlayer with a StreamDataProvider for an MP3 file.
var player = new SoundPlayer(engine, device.Format,
    new StreamDataProvider(engine, File.OpenRead("path/to/your/audio.mp3")));

// Add the player to the device's MasterMixer.
device.MasterMixer.AddComponent(player);

// Start playback.
device.Start();
player.Play();

Console.WriteLine("Playing MP3 file using FFmpeg... Press any key to stop.");
Console.ReadKey();

// Clean up.
player.Stop();
device.Stop();