public Plugin(string pluginPath)
{
bufferSize = Settings.GetInstance().BufferSize;
sampleRate = Settings.GetInstance().SampleRate;
_isMuted = false;
HostCommandStub hcs = new HostCommandStub();
_ctx = VstPluginContext.Create(pluginPath, hcs);
_name = _ctx.PluginCommandStub.GetEffectName();
_id = _name.GetHashCode() + DateTime.Now.Second;
inMgr = new VstAudioBufferManager(_ctx.PluginInfo.AudioInputCount, bufferSize);
outMgr = new VstAudioBufferManager(_ctx.PluginInfo.AudioOutputCount, bufferSize);
inputBuffer = inMgr.ToArray();
outputBuffer = outMgr.ToArray();
_ctx.PluginCommandStub.SetBlockSize(bufferSize);
_ctx.PluginCommandStub.SetSampleRate(sampleRate);
pluginForm = new PluginWindow(_ctx);
_ctx.PluginCommandStub.MainsChanged(true);
_ctx.PluginCommandStub.StartProcess();
}
private void UpdateBlockSize(int blockSize)
{
BlockSize = blockSize;
int inputCount = pluginContext.PluginInfo.AudioInputCount;
int outputCount = pluginContext.PluginInfo.AudioOutputCount;
var inputMgr = new VstAudioBufferManager(inputCount, blockSize);
var outputMgr = new VstAudioBufferManager(outputCount, blockSize);
pluginContext.PluginCommandStub.SetBlockSize(blockSize);
pluginContext.PluginCommandStub.SetSampleRate(WaveFormat.SampleRate);
pluginContext.PluginCommandStub.SetProcessPrecision(VstProcessPrecision.Process32);
inputBuffers = inputMgr.ToArray();
outputBuffers = outputMgr.ToArray();
input = new float[WaveFormat.Channels * blockSize];
output = new float[WaveFormat.Channels * blockSize];
}
static void Method(VstPluginContext PluginContext, int bytesWritten, byte[] destBuffer)
{
int inputCount = PluginContext.PluginInfo.AudioInputCount;
int outputCount = PluginContext.PluginInfo.AudioOutputCount;
int blockSize = bytesWritten;
VstAudioBufferManager inputMgr = new VstAudioBufferManager(inputCount, blockSize);
VstAudioBufferManager outputMgr = new VstAudioBufferManager(outputCount, blockSize);
foreach (VstAudioBuffer buffer in inputMgr.ToArray())
{
for (int i = 0; i < blockSize; i++)
{
buffer[i] = (float)destBuffer[i] / 128.0f - 1.0f;
}
}
PluginContext.PluginCommandStub.SetBlockSize(blockSize);
PluginContext.PluginCommandStub.SetSampleRate(44.8f);
PluginContext.PluginCommandStub.StartProcess();
PluginContext.PluginCommandStub.ProcessReplacing(inputMgr.ToArray(), outputMgr.ToArray());
PluginContext.PluginCommandStub.StopProcess();
foreach (VstAudioBuffer buffer in outputMgr.ToArray())
{
for (int i = 0; i < blockSize; i++)
{
destBuffer[i] = Convert.ToByte(((float)buffer[i] + 1.0f) * 128.0f);
}
}
inputMgr.ClearBuffer(inputMgr.ToArray()[0]);
inputMgr.ClearBuffer(inputMgr.ToArray()[1]);
inputMgr.Dispose();
outputMgr.ClearBuffer(outputMgr.ToArray()[0]);
outputMgr.ClearBuffer(outputMgr.ToArray()[1]);
outputMgr.Dispose();
}
private void GenerateNoiseBtn_Click(object sender, EventArgs e)
{
// plugin does not support processing audio
if (( PluginContext.PluginInfo.Flags & VstPluginFlags.CanReplacing ) == 0)
{
MessageBox.Show(this, "This plugin does not process any audio.", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
int inputCount = PluginContext.PluginInfo.AudioInputCount;
int outputCount = PluginContext.PluginInfo.AudioOutputCount;
int blockSize = 1024;
// wrap these in using statements to automatically call Dispose and cleanup the unmanaged memory.
using (VstAudioBufferManager inputMgr = new VstAudioBufferManager(inputCount, blockSize))
{
using (VstAudioBufferManager outputMgr = new VstAudioBufferManager(outputCount, blockSize))
{
foreach (VstAudioBuffer buffer in inputMgr.ToArray())
{
Random rnd = new Random((int)DateTime.Now.Ticks);
for (int i = 0; i < blockSize; i++)
{
// generate a value between -1.0 and 1.0
buffer[i] = (float)((rnd.NextDouble() * 2.0) - 1.0);
}
}
PluginContext.PluginCommandStub.SetBlockSize(blockSize);
PluginContext.PluginCommandStub.SetSampleRate(44100f);
VstAudioBuffer[] inputBuffers = inputMgr.ToArray();
VstAudioBuffer[] outputBuffers = outputMgr.ToArray();
PluginContext.PluginCommandStub.MainsChanged(true);
PluginContext.PluginCommandStub.StartProcess();
PluginContext.PluginCommandStub.ProcessReplacing(inputBuffers, outputBuffers);
PluginContext.PluginCommandStub.StopProcess();
PluginContext.PluginCommandStub.MainsChanged(false);
for (int i = 0; i < inputBuffers.Length && i < outputBuffers.Length; i++)
{
for (int j = 0; j < blockSize; j++)
{
if (inputBuffers[i][j] != outputBuffers[i][j])
{
if (outputBuffers[i][j] != 0.0)
{
MessageBox.Show(this, "The plugin has processed the audio.", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
}
}
}
MessageBox.Show(this, "The plugin has passed the audio unchanged to its outputs.", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
private void UpdateBlockSize(int blockSize)
{
BlockSize = blockSize;
int outputCount = pluginContext.PluginInfo.AudioOutputCount;
VstAudioBufferManager outputMgr = new VstAudioBufferManager(outputCount, blockSize);
pluginContext.PluginCommandStub.SetSampleRate(44800f);
pluginContext.PluginCommandStub.SetBlockSize(blockSize);
inputBuffers = new VstAudioBuffer[0];
outputBuffers = outputMgr.ToArray();
output = new float[2 * blockSize];
}
/// <summary>
/// we need to reflect the end of time in bars, or what-ever loop points are set.
/// </summary>
/// <param name="blockSize"></param>
private void UpdateBlockSize(int blockSize)
{
VstAudioBufferManager ii = null, io = null, ei = null, eo = null;
BlockSize = blockSize;
ii = new VstAudioBufferManager(instrument.PluginInfo.AudioInputCount, blockSize);
io = new VstAudioBufferManager(instrument.PluginInfo.AudioOutputCount, blockSize);
if (effect!=null)
{
ei = new VstAudioBufferManager(effect.PluginInfo.AudioInputCount, blockSize);
eo = new VstAudioBufferManager(effect.PluginInfo.AudioOutputCount, blockSize);
}
UpdateBlock(instrument,blockSize);
if (effect!=null) UpdateBlock(effect,blockSize);
insI = ii.ToArray();
insO = io.ToArray();
effI = ei.ToArray();
effO = eo.ToArray();
input = new float[WaveFormat.Channels * blockSize];
output = new float[WaveFormat.Channels * blockSize];
}
public override int Read(float[] buffer, int offset, int samplesRequested)
{
int sampleCount = samplesRequested / 2;
plugin.SetBlockSize(sampleCount);
plugin.SetSampleRate(WaveFormat.SampleRate);
plugin.SetProcessPrecision(VstProcessPrecision.Process32);
using (VstAudioBufferManager inputMgr = new VstAudioBufferManager(info.AudioInputCount, samplesRequested))
using (VstAudioBufferManager outputMgr = new VstAudioBufferManager(info.AudioOutputCount, samplesRequested))
{
{
vstBufIn = inputMgr.ToArray();
vstBufOut = outputMgr.ToArray();
plugin.StartProcess();
plugin.ProcessReplacing(vstBufIn,vstBufOut);
plugin.StopProcess();
int i = 0, j = 0;
while (j < samplesRequested/2)
{
buffer[i++] = vstBufOut[0][j];
buffer[i++] = vstBufOut[1][j++];
}
}
}
Debug.Print("Requested: {0}, Returned: {1}, Offset: {2}",samplesRequested,vstBufOut[0].SampleCount,offset);
return samplesRequested;
}
public int Readx2x(float[] destBuffer, int position, int bytesRequested)
{
Debug.Print("VST Read Operation!!! {0}, {1}",position,bytesRequested);
int inputCount = PluginContext.PluginInfo.AudioInputCount;
int outputCount = PluginContext.PluginInfo.AudioOutputCount;
PluginContext.PluginCommandStub.SetBlockSize(bytesRequested);
PluginContext.PluginCommandStub.SetSampleRate(WaveFormat.SampleRate);
PluginContext.PluginCommandStub.SetProcessPrecision(VstProcessPrecision.Process32);
using (VstAudioBufferManager inputMgr = new VstAudioBufferManager(inputCount, bytesRequested))
using (VstAudioBufferManager outputMgr = new VstAudioBufferManager(outputCount, bytesRequested))
{
// if (IsProcessReplacing)
foreach (VstAudioBuffer buffer in inputMgr.ToArray())
for (int i = 0; i < bytesRequested; i++)
buffer[i] = destBuffer[i];
PluginContext.PluginCommandStub.ProcessReplacing(inputMgr.ToArray(), outputMgr.ToArray());
foreach (VstAudioBuffer buffer in outputMgr.ToArray())
for (int i = 0; i < bytesRequested; i++)
{
destBuffer[i] = (byte)buffer[i];
Debug.Print("index: {i}, data: {0}",i,buffer[i]);
}
lastPosition += bytesRequested;
position += bytesRequested;
return bytesRequested;
// The Original
// ---------------------------------------
// foreach (VstAudioBuffer buffer in outputMgr.ToArray())
// for (int i = 0; i < blockSize; i++)
// {
// destBuffer[i] = Convert.ToByte(((float)buffer[i] + 1.0f) * 128.0f);
// }
// Jakobi's Process
// ---------------------------------------
// for (int i = 0; i < inputBuffers.Length && i < outputBuffers.Length; i++)
// for (int j = 0; j < blockSize; j++)
// if (inputBuffers[i][j] != outputBuffers[i][j])
// if (outputBuffers[i][j] != 0.0)
// {
// MessageBox.Show(this, "The plugin has processed the audio.", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
// return;
// }
// Continued Forum Post Code:
// ---------------------------------------
// inputMgr.ClearBuffer(inputMgr.ToArray()[0]);
// inputMgr.ClearBuffer(inputMgr.ToArray()[1]);
// inputMgr.Dispose();
// outputMgr.ClearBuffer(outputMgr.ToArray()[0]);
// outputMgr.ClearBuffer(outputMgr.ToArray()[1]);
// outputMgr.Dispose();
}
}
protected void Load(string filename)
{
if (File.Exists(filename))
{
PluginContext = OpenPlugin(filename);
if(PluginContext == null) return;
SetOutputCount(PluginContext.PluginInfo.AudioOutputCount);
PluginContext.PluginCommandStub.MainsChanged(true);
PluginContext.PluginCommandStub.SetSampleRate(WaveFormat.SampleRate);
PluginContext.PluginCommandStub.SetBlockSize(AudioService.Engine.Settings.BufferSize);
FIsSynth = PluginContext.PluginInfo.Flags.HasFlag(VstPluginFlags.IsSynth);
PluginContext.PluginCommandStub.StartProcess();
FInputCount = PluginContext.PluginInfo.AudioInputCount;
FOutputCount = PluginContext.PluginInfo.AudioOutputCount;
FInputMgr = new VstAudioBufferManager(FInputCount, AudioService.Engine.Settings.BufferSize);
FOutputMgr = new VstAudioBufferManager(FOutputCount, AudioService.Engine.Settings.BufferSize);
FInputBuffers = FInputMgr.ToArray();
FOutputBuffers = FOutputMgr.ToArray();
// plugin does not support processing audio
if ((PluginContext.PluginInfo.Flags & VstPluginFlags.CanReplacing) == 0)
{
MessageBox.Show("This plugin does not process any audio.");
return;
}
FCanEvents = PluginContext.PluginCommandStub.CanDo("receiveVstMidiEvent") == VstCanDoResult.Yes;
InfoForm = new PluginInfoForm();
InfoForm.PluginContext = PluginContext;
InfoForm.DataToForm();
InfoForm.Dock = DockStyle.Fill;
GetPluginInfo();
GetProgramNames();
if (PluginChanged != null)
PluginChanged();
FDoProcess = true;
}
}
protected void ManageBuffers(int count)
{
if(FInputMgr.BufferSize != count)
{
FInputMgr.Dispose();
FOutputMgr.Dispose();
FInputMgr = new VstAudioBufferManager(FInputCount, count);
FOutputMgr = new VstAudioBufferManager(FOutputCount, count);
FInputBuffers = FInputMgr.ToArray();
FOutputBuffers = FOutputMgr.ToArray();
}
}
private void InitBuffer(int inputCount, int outputCount, int blockSize, int sampleRate)
{
VstAudioBufferManager inputMgr = new VstAudioBufferManager(inputCount, blockSize);
VstAudioBufferManager outputMgr = new VstAudioBufferManager(outputCount, blockSize);
this.vstInputBuffers = inputMgr.ToArray();
this.vstOutputBuffers = outputMgr.ToArray();
this.PluginContext.PluginCommandStub.SetBlockSize(blockSize);
this.PluginContext.PluginCommandStub.SetSampleRate((float)sampleRate);
this.PluginContext.PluginCommandStub.SetProcessPrecision(VstProcessPrecision.Process32);
this.lastProcessedBufferRight = new float[BlockSize];
this.lastProcessedBufferLeft = new float[BlockSize];
}
private void GenerateNoiseBtn_Click(object sender, EventArgs e)
{
// plugin does not support processing audio
if ((PluginContext.PluginInfo.Flags & VstPluginFlags.CanReplacing) == 0)
{
MessageBox.Show(this, "This plugin does not process any audio.", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
int inputCount = PluginContext.PluginInfo.AudioInputCount;
int outputCount = PluginContext.PluginInfo.AudioOutputCount;
const int blockSize = 1024;
// wrap these in using statements to automatically call Dispose and cleanup the unmanaged memory.
using (var inputMgr = new VstAudioBufferManager(inputCount, blockSize))
{
using (var outputMgr = new VstAudioBufferManager(outputCount, blockSize))
{
foreach (VstAudioBuffer buffer in inputMgr.ToArray())
{
try {
var rnd = new Random((int)DateTime.Now.Ticks);
for (int i = 0; i < blockSize; i++)
{
// generate a value between -1.0 and 1.0
buffer[i] = (float)((rnd.NextDouble() * 2.0) - 1.0);
}
} catch (OverflowException oe) {
System.Diagnostics.Debug.WriteLine(oe);
}
}
PluginContext.PluginCommandStub.SetBlockSize(blockSize);
PluginContext.PluginCommandStub.SetSampleRate(44100f);
VstAudioBuffer[] inputBuffers = inputMgr.ToArray();
VstAudioBuffer[] outputBuffers = outputMgr.ToArray();
PluginContext.PluginCommandStub.MainsChanged(true);
PluginContext.PluginCommandStub.StartProcess();
PluginContext.PluginCommandStub.ProcessReplacing(inputBuffers, outputBuffers);
PluginContext.PluginCommandStub.StopProcess();
PluginContext.PluginCommandStub.MainsChanged(false);
for (int i = 0; i < inputBuffers.Length && i < outputBuffers.Length; i++)
{
for (int j = 0; j < blockSize; j++)
{
if (inputBuffers[i][j] != outputBuffers[i][j])
{
if (outputBuffers[i][j] != 0.0)
{
MessageBox.Show(this, "The plugin has processed the audio.", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
}
}
}
MessageBox.Show(this, "The plugin has passed the audio unchanged to its outputs.", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
public VSTStream(int sampleRate, int channels, int blockSize, List<IVstPluginCommandStub> plugins, string waveFilePath)
: base(sampleRate, channels)
{
this.plugins = plugins;
this.sampleRate = sampleRate;
this.channels = channels;
this.blockSize = blockSize;
this.waveFilePath = waveFilePath;
plugins[0].SetBlockSize(blockSize);
plugins[0].SetSampleRate((float)sampleRate);
plugins[0].SetProcessPrecision(VstProcessPrecision.Process32);
vstBufManIn = new VstAudioBufferManager(channels, blockSize);
vstBufManOut = new VstAudioBufferManager(channels, blockSize);
vstBufIn = vstBufManIn.ToArray();
vstBufOut = vstBufManOut.ToArray();
// 4 bytes per sample (32 bit)
naudioBuf = new byte[blockSize * channels * 4];
wavStream = new WaveChannel32(new WaveFileReader(waveFilePath));
wavStream.Volume = 1f;
}
void UpdateBlockSize( NAudioVST naudiovst, VstPlugin plugin, AudioProcess parent)
{
VstAudioBufferManager io = new VstAudioBufferManager(plugin.PluginInfo.AudioOutputCount, BlockSize);
UpdateBlock(naudiovst,plugin);
binput = parent.boutput;
boutput = io.ToArray();
}
void UpdateBlockSize( NAudioVST naudiovst, VstPlugin plugin )
{
VstAudioBufferManager ii = null, io = null;
ii = new VstAudioBufferManager(plugin.PluginInfo.AudioInputCount, BlockSize);
io = new VstAudioBufferManager(plugin.PluginInfo.AudioOutputCount, BlockSize);
UpdateBlock(naudiovst,plugin);
binput = ii.ToArray();
boutput = io.ToArray();
}
