Using VST2 to feed NAudio output into StereoTool VST

[AlanGitMan]

Also previously posted on the NAudio Github forum and the StereoTool forum.

Does anyone have a working c# example of piping through NAudio output audio to StereoTool via VST?

This is a hobby project - not a commercial one; I'm making my own priivate "radio" intranet station. After a learning curve, I have a working NAudio player which schedules and plays audio files perfectly. I now need to take the output from that application and feed it into StereoTool which does volume levelling and various other processing. StereoTool supports VST.

https://www.thimeo.com/stereo-tool/

I am running on Windows 10.0 using Visual Studio 2022 (community edition) and (in accordance with the VST.NET2 instructions) have set the target environment to be NET6.0. My project uses Winforms (with .net) template. CPU type is set to "x64;x86" in the project file XML.

So, as this is all new to me, I asked CoPilot to find me code that would give me a simple-as-possible working example of this and the code it found/suggested is down below. My issue is that - even having installed NAudio and VST.NET2 using Nuget I am seeing errors which make me think that perhaps this code is old and out of date but it's equally possible that I am doing something utterly stoopid!

For example in the line

public class HostCommandStub : IVstHostCommandStub

I get the error: "The type or namespace name 'IVstHostCommandStub' could not be found (are you missing a using directive or an assembly reference?)

All the documentation says that the definition for IVstHostCommandStub is in the VST libraries I am using - as in

using Jacobi.Vst.Core;
using Jacobi.Vst.Host;

I get the same error for the line

public IVstPluginContext PluginContext { get; set; }

Here is the complete code that I got suggested - no idea where Co-Pilot got it from!

 using System;
using NAudio.Wave;
using Jacobi.Vst.Core;
using Jacobi.Vst.Host.Interop;


public class HostCommandStub : IVstHostCommandStub
{
    public IVstPluginContext PluginContext { get; set; }

    public bool BeginEdit(int index) => false;
    public VstCanDoResult CanDo(string cando) => VstCanDoResult.Unknown;
    public bool CloseFileSelector(VstFileSelect fileSelect) => false;
    public bool EndEdit(int index) => false;
    public VstAutomationStates GetAutomationState() => VstAutomationStates.Off;
    public int GetBlockSize() => 1024;
    public string GetDirectory() => string.Empty;
    public int GetInputLatency() => 0;
    public VstHostLanguage GetLanguage() => VstHostLanguage.NotSupported;
    public int GetOutputLatency() => 0;
    public VstProcessLevels GetProcessLevel() => VstProcessLevels.Unknown;
    public string GetProductString() => "VST.NET";
    public float GetSampleRate() => 44100f;
    public VstTimeInfo GetTimeInfo(VstTimeInfoFlags filterFlags) => null;
    public string GetVendorString() => "VendorString";
    public int GetVendorVersion() => 2400;
    public bool IoChanged() => false;
    public bool OpenFileSelector(VstFileSelect fileSelect) => false;
    public bool ProcessEvents(VstEvent[] events) => false;
    public bool SizeWindow(int width, int height) => false;
    public bool UpdateDisplay() => true;
}


using System;
using NAudio.Wave;
using Jacobi.Vst.Core;
using Jacobi.Vst.Host.Interop;

namespace AudioApp
{
    class Program
    {
        static void Main(string[] args)
        {
            // Initialize the audio engine
            using (var waveOut = new WaveOutEvent())
            {
                // Create the host command stub
                var hostCommandStub = new HostCommandStub();

                // Load the VST plugin
                var vstPluginContext = VstPluginContext.Create("path_to_stereotool_vst.dll", hostCommandStub);

                // Create a wave provider from your existing audio source
                var audioFileReader = new AudioFileReader("path_to_your_audio_file.wav");

                // Create a VST wave provider
                var vstWaveProvider = new VstWaveProvider(vstPluginContext, audioFileReader);

                // Set the wave provider to the output device
                waveOut.Init(vstWaveProvider);

                // Play the audio
                waveOut.Play();

                Console.WriteLine("Press any key to exit...");
                Console.ReadKey();
            }
        }
    }

    public class VstWaveProvider : IWaveProvider
    {
        private readonly VstPluginContext vstPluginContext;
        private readonly IWaveProvider sourceProvider;

        public VstWaveProvider(VstPluginContext vstPluginContext, IWaveProvider sourceProvider)
        {
            this.vstPluginContext = vstPluginContext;
            this.sourceProvider = sourceProvider;
        }

        public WaveFormat WaveFormat => sourceProvider.WaveFormat;

        public int Read(byte[] buffer, int offset, int count)
        {
            // Read audio data from the source provider
            int bytesRead = sourceProvider.Read(buffer, offset, count);

            // Process the audio through the VST plugin
            vstPluginContext.PluginCommandStub.ProcessReplacing(buffer, offset, bytesRead);

            return bytesRead;
        }
    }
}

Thanks in advance for any assistance with this.

Alan T
Cornwall UK.

[obiwanjacobi]

Does anyone have a working c# example of piping through NAudio output audio to StereoTool via VST?

No, probably not ;-)

So let me get this right. You have an NAudio audio source that you want to pipe through StereoTool and StereoTool can behave as a VST plugin. Is that correct?

NAudio (in) => VST.NET Host => StereoTool VST plugin => NAudio (out)

I see that StereoTool support the VST2 plugin standard which is what VST.NET does - we do not support VST3 yet :-(.

I would suggest you take a look at the Host sample: https://github.com/obiwanjacobi/vst.net/tree/master/Source/Samples
It demonstrates how to load a plugin and how to talk to it. It is not a working host with audio scheduling etc. - you have to do that yourself.

Roughly you would have to:

• Convert your NAudio buffers (sample values) to a [1.0, -1.0] value range - that is what VST uses.
• Pass the audio to the StereoTool vst plugin and receive their output (this is VST.NET)
• Convert back to whatever you're using in NAudio
• And output that to some target to hear it.

A VST host will manage the one VST plugin, which makes it easier. It will tell the plugin what the sample rate is and how big the buffers are, how many audio channels (stereo I presume, so 2) etc. The host implements the IVstHostCommandStub interface to handle anything the plugin has to say to the host. A lot of stuff can be 'ignored'/not implemented (probably) but you'll have to experiment. A VST plugin will publish what services it expects from the host (the Host sample will display those) - you'll have to implement those. You'll need at least sending and receiving audio buffers (GenerateNoise in Host sample).

Start with loading the StereoTool in the Host sample app and examine (debug) the code to see what happens.
Check back here if you have additional question as you understand more of how this all works.

Good luck!

[AlanGitMan]

Thanks Mark - I will look at the host source and see what I can make from that - yes, I expect I will be back with more questions :-)
The C# code I have written so far already does all the scheduling, database interfacing and NAUdio side of things, so I think I already have a more or less complete host-side - it's just this output-side processing that I need to get through now.

Thanks again.
Alan T.