Skip to main content

​
Overview

The TrackEngine class is an abstract base class that manages the audio processing chain for a track. It handles audio mixing, plugin processing, stereo imaging, metering, and clip playback. Each track has its own engine instance.

​
Namespace

Lumix.Tracks

​
Inheritance

public abstract class TrackEngine : IDisposable

​
Properties

​
Mixer
MixingSampleProvider
required
The mixing sample provider that combines multiple audio sources.
public MixingSampleProvider Mixer { get; protected set; }
​
PluginChainSampleProvider
PluginChainSampleProvider
required
The plugin chain processor that routes audio through VST and built-in effects/instruments.
public PluginChainSampleProvider PluginChainSampleProvider { get; protected set; }
​
StereoSampleProvider
StereoSampleProvider
required
Handles stereo gain, panning, and balance for the track.
public StereoSampleProvider StereoSampleProvider { get; protected set; }
​
TrackStateSampleProvider
TrackStateSampleProvider
required
Manages track state (mute, solo, etc.) and controls audio flow.
public TrackStateSampleProvider TrackStateSampleProvider { get; protected set; }
​
MeteringSampleProvider
MeteringSampleProvider
required
Monitors audio levels and provides volume metering data.
public MeteringSampleProvider MeteringSampleProvider { get; protected set; }
​
IsRecording
bool
required
Indicates whether the track is currently recording.
public bool IsRecording { get; protected set; }

​
Events

​
VolumeMeasured

Fired when the audio level is measured, providing real-time metering data. 
public abstract event EventHandler<StreamVolumeEventArgs> VolumeMeasured
Event Args: StreamVolumeEventArgs containing volume level information

​
Methods

​
GetTrackAudio

Returns the final processed audio output from the track. 
public ISampleProvider GetTrackAudio()
Returns: ISampleProvider - The track’s final sample provider (TrackStateSampleProvider) Example: 
var trackOutput = track.Engine.GetTrackAudio();
masterMixer.AddMixerInput(trackOutput);

​
Fire (AudioFileReader)

Triggers playback of an audio clip on this track. 
public abstract void Fire(AudioFileReader audioFile, float offset, float endOffset)
​
audioFile
AudioFileReader
required
The audio file to play.
​
offset
float
required
The start offset within the audio file (in seconds).
​
endOffset
float
required
The end offset within the audio file (in seconds).
Example: 
var audioReader = new AudioFileReader("drums.wav");
track.Engine.Fire(audioReader, offset: 0.5f, endOffset: 0.0f);

​
Fire (MidiFile)

Triggers playback of a MIDI clip on this track. 
public abstract void Fire(MidiFile midiFile, float offset, float endOffset)
​
midiFile
MidiFile
required
The MIDI file to play.
​
offset
float
required
The start offset within the MIDI file (in seconds).
​
endOffset
float
required
The end offset within the MIDI file (in seconds).
Example: 
var midiFile = MidiFile.Read("melody.mid");
midiTrack.Engine.Fire(midiFile, offset: 0.0f, endOffset: 0.0f);

​
StartRecording

Begins recording audio or MIDI data on this track. 
public abstract void StartRecording()
Example: 
if (track.RecordOnStart)
{
    track.Engine.StartRecording();
}

​
StopRecording

Stops recording and creates a clip with the recorded data. 
public abstract void StopRecording(Track destTrack)
​
destTrack
Track
required
The track where the recorded clip will be created.
Example: 
track.Engine.StopRecording(track);

​
StopSounds

Stops all currently playing sounds on this track. 
public abstract void StopSounds()
Example: 
// Called when timeline stops
foreach (var track in tracks)
{
    track.Engine.StopSounds();
}

​
Dispose

Releases resources used by the track engine. 
public void Dispose()

​
Audio Processing Chain

The typical signal flow through a TrackEngine is:
  1. Mixer - Combines multiple clip sources
  2. PluginChainSampleProvider - Processes through VST/built-in plugins
  3. StereoSampleProvider - Applies gain and panning
  4. MeteringSampleProvider - Measures audio levels
  5. TrackStateSampleProvider - Applies mute/solo state
  6. Output - Sent to master mixer or routing destination
[Clips] → [Mixer] → [Plugins] → [Stereo/Pan] → [Metering] → [Track State] → [Output]

​
Example Usage

// Creating a track engine (typically done internally by track constructors)
var audioTrackEngine = new AudioTrackEngine(outputDevice);

// Adding a plugin to the chain
var vstPlugin = new VstPlugin("path/to/plugin.dll");
var vstProcessor = new VstAudioProcessor(vstPlugin);
audioTrackEngine.PluginChainSampleProvider.AddPlugin(vstProcessor);

// Setting up volume metering
audioTrackEngine.VolumeMeasured += (sender, args) =>
{
    float leftChannel = args.MaxSampleValues[0];
    float rightChannel = args.MaxSampleValues[1];
    UpdateVolumeMeters(leftChannel, rightChannel);
};

// Firing a clip for playback
var audioFile = new AudioFileReader("vocal.wav");
audioTrackEngine.Fire(audioFile, offset: 0.0f, endOffset: 0.0f);

// Controlling stereo properties
audioTrackEngine.StereoSampleProvider.SetGain(0.8f); // 80% volume
audioTrackEngine.StereoSampleProvider.Pan = -0.5f;   // Pan left

// Getting final output
var trackOutput = audioTrackEngine.GetTrackAudio();

​
Derived Classes

  • AudioTrackEngine: Engine for audio tracks, handles audio file playback
  • MidiTrackEngine: Engine for MIDI tracks, handles MIDI playback and virtual instruments
  • GroupTrackEngine: Engine for group tracks, handles submixing

​
Notes

The TrackEngine manages its own audio processing chain. Sample providers are connected in a specific order to ensure proper audio flow.
Always call StopSounds() before disposing of the engine to prevent audio artifacts.

​
See Also

  • Track - Uses TrackEngine for audio processing
  • Clip - Clips trigger playback through the engine
  • MusicalTime - Used for timing clip playback

Build docs developers (and LLMs) love

Get started for freeTalk to us