/// <summary>
/// Plays back the current sample buffer
/// </summary>
/// <param name="outChannels">Output buffers. Must not be null.</param>
public void PlayAudio(VstAudioBuffer[] outChannels)
{
if (IsPlaying)
{
_player.Play(outChannels[0], outChannels[1]);
}
}
private void AssertBufferHasValue(VstAudioBuffer buffer, float value)
{
for (int i = 0; i < buffer.SampleCount; i++)
{
buffer[i].Should().Be(value);
}
}
private void AssertBufferHasValue(VstAudioBuffer buffer, float value)
{
for (int i = 0; i < buffer.SampleCount; i++)
{
Assert.AreEqual(value, buffer[i]);
}
}
public override void Process(VstAudioBuffer[] inChannels, VstAudioBuffer[] outChannels)
{
// check to see if we need to output midi here
if (_plugin.MidiProcessor.SyncWithAudioProcessor)
{
_plugin.MidiProcessor.ProcessCurrentEvents();
}
if (_plugin.SampleManager.IsPlaying)
{
_plugin.SampleManager.PlayAudio(outChannels);
}
else
{
VstAudioBuffer input = inChannels[0];
VstAudioBuffer output = outChannels[0];
for (int index = 0; index < output.SampleCount; index++)
{
output[index] = input[index];
}
input = inChannels[1];
output = outChannels[1];
for (int index = 0; index < output.SampleCount; index++)
{
output[index] = input[index];
}
}
}
public override void Process(VstAudioBuffer[] inChannels, VstAudioBuffer[] outChannels)
{
if (_plugin.SampleManager.IsPlaying)
{
_plugin.SampleManager.PlayAudio(outChannels);
}
else // audio thru
{
VstAudioBuffer input = inChannels[0];
VstAudioBuffer output = outChannels[0];
for (int index = 0; index < output.SampleCount; index++)
{
output[index] = input[index];
}
input = inChannels[1];
output = outChannels[1];
for (int index = 0; index < output.SampleCount; index++)
{
output[index] = input[index];
}
}
if (_plugin.SampleManager.IsRecording)
{
_plugin.SampleManager.RecordAudio(inChannels);
}
}
// process a single audio channel
private void Process(VstAudioBuffer input, VstAudioBuffer output)
{
for (int i = 0; i < input.SampleCount; i++)
{
output[i] = Delay.ProcessSample(input[i]);
}
}
/// <summary>
/// Called by the host to allow the plugin to process audio samples.
/// </summary>
/// <param name="inChannels">Never null.</param>
/// <param name="outChannels">Never null.</param>
public override void Process(VstAudioBuffer[] inChannels, VstAudioBuffer[] outChannels)
{
// calling the base class transfers input samples to the output channels unchanged (bypass).
//base.Process(inChannels, outChannels);
if (_plugin._synth.IsPlaying)
{
_plugin._synth.SampleCount = outChannels[0].SampleCount;
_plugin._synth.PlayAudio(outChannels);
}
else // audio thru
{
VstAudioBuffer input = inChannels[0];
VstAudioBuffer output = outChannels[0];
for (int index = 0; index < output.SampleCount; index++)
{
output[index] = input[index];
}
input = inChannels[1];
output = outChannels[1];
for (int index = 0; index < output.SampleCount; index++)
{
output[index] = input[index];
}
}
_plugin.MidiProcessor.ProcessCurrentEvents();
}
/// <summary>
/// Perform audio processing on the specified <paramref name="inChannels"/>
/// and produce a delay effect on the <paramref name="outChannels"/>.
/// </summary>
/// <param name="inChannels">The audio input buffers.</param>
/// <param name="outChannels">The audio output buffers.</param>
public override void Process(VstAudioBuffer[] inChannels, VstAudioBuffer[] outChannels)
{
VstAudioBuffer audioChannel = outChannels[0];
for (int n = 0; n < audioChannel.SampleCount; n++)
{
audioChannel[n] = Delay.ProcessSample(inChannels[0][n]);
}
}
public static double AvgEnv(this VstAudioBuffer buffer)
{
double[] lvls = new double[buffer.SampleCount];
for (int i = 0; i < buffer.SampleCount; i++)
{
lvls[i] = Math.Abs(buffer[i]);
}
return(lvls.Average());
}
public override void Process(VstAudioBuffer[] inChannels, VstAudioBuffer[] outChannels)
{
var inChannel = inChannels[0];
var outChannel = outChannels[0];
for (var i = 0; i < inChannel.SampleCount; i++)
{
outChannel[i] = ProcessSample(inChannel[i]);
}
}
/// <summary>
/// Traite le signal en entrée pour y ajouter un délai
/// </summary>
public void Process(VstAudioBuffer[] inChannels, VstAudioBuffer[] outChannels)
{
// Récupération d'un canal en sortie
VstAudioBuffer audioChannel = outChannels[0];
// Pour chaque échantillon on fait le traitement
for (int n = 0; n < audioChannel.SampleCount; n++)
{
audioChannel[n] = Delay.ProcessSample(inChannels[0][n]);
}
}
public void Record(VstAudioBuffer left, VstAudioBuffer right)
{
for (int index = 0; index < left.SampleCount; index++)
{
Buffer.LeftSamples.Add(left[index]);
}
for (int index = 0; index < right.SampleCount; index++)
{
Buffer.RightSamples.Add(right[index]);
}
}
public override void Process(VstAudioBuffer[] inChannels, VstAudioBuffer[] outChannels)
{
if (_timeOut > 0)
{
_timeOut--;
return;
}
try
{
if (_blockSize != BlockSize || _sampleRate != SampleRate)
{
SetUp();
}
if (_out == null)
{
throw new SlooException("Process", "null output");
}
VstAudioBuffer input = inChannels[0];
VstAudioBuffer output = outChannels[0];
_out.NextBlock(++_blockNr);
for (int index = 0; index < output.SampleCount; index++)
{
output[index] = 0;
for (int c = 0; c < _out.Channels; c++)
{
output[index] += (float)_out[index, c];
}
}
for (int channel = 1; channel < outChannels.Length; channel++)
{
for (int index = 0; index < output.SampleCount; index++)
{
outChannels[channel][index] = output[index];
}
}
CurrentSample += (uint)this.BlockSize;
}
catch (Exception e)
{
var msg = new StringBuilder(e.Message);
msg.AppendLine(e.StackTrace);
msg.Append("INNER: ");
msg.AppendLine(e?.InnerException?.Message ?? "");
msg.AppendLine(e?.InnerException?.StackTrace ?? "");
LogLine(msg.ToString());
_timeOut = 50;
}
}
/// <inheritdoc />
/// <remarks>This method is used to push midi inputEvents to the host.</remarks>
public override void Process(VstAudioBuffer[] inChannels, VstAudioBuffer[] outChannels)
{
if (_hostProcessor == null)
{
_hostProcessor = _plugin.Host.GetInstance<IVstMidiProcessor>();
}
if (_midiProcessor != null && _hostProcessor != null &&
_midiProcessor.Events.Count > 0)
{
_hostProcessor.Process(_midiProcessor.Events);
_midiProcessor.Events.Clear();
}
// perform audio-through
base.Process(inChannels, outChannels);
}
/// <summary>
/// Méthode qui effectue le traitement
/// </summary>
/// <param name="inputs">Entrées</param>
/// <param name="outputs">Sorties</param>
public void Process(VstAudioBuffer[] inputs, VstAudioBuffer[] outputs)
{
// On affecte à nos variables de traitement la première entrée et la première sortie (canal mono 1)
VstAudioBuffer input = inputs[0];
VstAudioBuffer output = outputs[0];
// Pour chaque échantillon en entrée on recopie le signal en sortie.
for (int index = 0; index < output.SampleCount; index++)
{
output[index] = input[index];
}
// On effectue le même traitement avec la seconde entrée et la seconde sortie (canal mono 2)
input = inputs[1];
output = outputs[1];
for (int index = 0; index < output.SampleCount; index++)
{
output[index] = input[index];
}
}
public void Play(VstAudioBuffer left, VstAudioBuffer right)
{
if (IsFinished)
{
return;
}
int count = Math.Min(left.SampleCount, Buffer.LeftSamples.Count - _bufferIndex);
for (int index = 0; index < count; index++)
{
left[index] = Buffer.LeftSamples[_bufferIndex + index];
}
for (int index = 0; index < count; index++)
{
right[index] = Buffer.RightSamples[_bufferIndex + index];
}
_bufferIndex += left.SampleCount;
}
/// <summary>
/// Not implemented.
/// </summary>
/// <param name="inputs">Not used.</param>
/// <param name="outputs">Not used.</param>
/// <remarks>Method does nothing.</remarks>
public virtual void ProcessAcc(VstAudioBuffer[] inputs, VstAudioBuffer[] outputs)
{
// nop
}
public bool PlayAudio(VstAudioBuffer[] outChannels)
{
if (!_isPlaying || _lockPlay)
return false;
if (_sndFloatBufferListIndex==-1 || (int)_sndFloatBufferIndex >= _sndFloatBufferList[_sndFloatBufferListIndex].Length)
_isPlaying = false;
if (_isPlaying)
{
int n = 0;
int ll = outChannels[0].SampleCount;
lock (_sndFloatBufferList)
{
if ((int)_sndFloatBufferIndex < _sndFloatBufferList[_sndFloatBufferListIndex].Length)
{
float[] fBuff = new float[ll];
float[][] fBuffMore = null;
int l = _sndFloatBufferList[_sndFloatBufferListIndex].Length - (int)_sndFloatBufferIndex;
for (int i = 0; i < ll; i++)
{
if ((int)_sndFloatBufferIndex + i < _sndFloatBufferList[_sndFloatBufferListIndex].Length)
fBuff[i] = _sndFloatBufferList[_sndFloatBufferListIndex][(int)_sndFloatBufferIndex + i];
else
fBuff[i] = 0;
}
if (_currentNoteList.Count > 0)
{
lock (_currentNoteList)
{
int ii = 0;
fBuffMore = new float[_currentNoteList.Count][];
foreach (CurrentNote cNote in _currentNoteList)
{
if ((int)cNote._bufferIndex < _sndFloatBufferList[cNote._bufferListIndex].Length)
{
fBuffMore[ii] = new float[ll];
l = _sndFloatBufferList[cNote._bufferListIndex].Length - (int)cNote._bufferIndex;
for (int i = 0; i < ll; i++)
{
if ((int)cNote._bufferIndex + i < _sndFloatBufferList[cNote._bufferListIndex].Length)
fBuffMore[ii][i] = _sndFloatBufferList[cNote._bufferListIndex][(int)cNote._bufferIndex + i];
else
fBuffMore[ii][i] = 0;
}
cNote._bufferIndex += ll;
}
++ii;
}
}
}
for (n = 0; n < ll; n++)
{
if (_currentNoteList.Count > 0 && fBuffMore != null)
{
int nn = 0;
for (int i = 0; i < _currentNoteList.Count; i++)
{
if (fBuffMore[i] != null)
{
fBuff[n] += fBuffMore[i][n];
++nn;
}
}
if (nn > 0)
fBuff[n] = fBuff[n] / nn;
}
}
_pitchShifter.PitchShift(_pitchTune, ll, 1024, 4, 44100, fBuff);
for (n = 0; n < ll; n++)
{
outChannels[0][n] = (fBuff[n]*_currentVelocity);
outChannels[1][n] = outChannels[0][n];
}
}
_sndFloatBufferIndex += ll;
if (_currentNoteList.Count > 0)
{
_currentNoteToKeepList.Clear();
lock (_currentNoteList)
{
foreach (CurrentNote cNote in _currentNoteList)
{
if (cNote._bufferIndex < _sndFloatBufferList[cNote._bufferListIndex].Length)
_currentNoteToKeepList.Add(cNote);
}
if (_currentNoteToKeepList.Count < _currentNoteList.Count)
_currentNoteList = new List<CurrentNote>(_currentNoteToKeepList);
}
}
}
return true;
}
return false;
}
public void ProcessReplacing(VstAudioBuffer[] input, VstAudioBuffer[] outputs)
{
}
/// <summary>
/// plugin.PluginCommandStub.ProcessReplacing(inputs, outputs);
/// </summary>
/// <param name="plugin"></param>
/// <param name="inputs"></param>
/// <param name="outputs"></param>
VstAudioBuffer[] PluginPreProcess2(VstPlugin plugin, VstAudioBuffer[] inputs, VstAudioBuffer[] outputs)
{
plugin.PluginCommandStub.StartProcess();
plugin.PluginCommandStub.ProcessReplacing(inputs, outputs);
plugin.PluginCommandStub.StopProcess();
return outputs;
}
/// <summary>
/// Ignore nulll entries.
/// Convert output to 2 channel if necessary.
/// </summary>
/// <param name="plugin"></param>
/// <param name="inputs"></param>
/// <param name="outputs">VstAudioBuffer[2]</param>
VstAudioBuffer[] PluginProcess(VstPlugin plugin, VstAudioBuffer[] inputs, VstAudioBuffer[] outputs)
{
VstAudioBuffer[] newinputs = inputs.Length == 1 ? new VstAudioBuffer[] {
inputs[0],
inputs[0]
} : inputs;
return plugin == null ? newinputs : PluginPreProcess2(plugin, newinputs, outputs);
}
public void Play(VstAudioBuffer left, VstAudioBuffer right)
{
if (IsFinished)
{
return;
}
//Add effects per gridItem here (gain, panning)
//per effect waarschijnlijk class schrijven die de verschillende channels processed
//Hier is ook informatie nodig van de CurrentKit uit de kitmanager
int count = Math.Min(left.SampleCount, Buffer.LeftSamples.Count - _bufferIndex);
double gain_factor = Math.Pow(10.0, GridItem.Gain / 20.0);
float dividingfactor = 120;
double panfactorLeft = Math.Pow(10.0, (GridItem.Panning * dividingfactor) / 20.0);
double panfactorRight = Math.Pow(10.0, (GridItem.Panning * dividingfactor) / 20.0);
for (int index = 0; index < count; index++)
{
float signal = Buffer.LeftSamples[_bufferIndex + index];
//Add Gain
signal = signal * (float)gain_factor;
//Panning
//Optie 1
//ignal = signal - (GridItem.Panning / 2);
//Optie 2
//if (GridItem.Panning > 0) {
// if (GridItem.Panning == 1) {
// signal = signal * float.MinValue;
// } else {
// signal = signal * (float)panfactorLeft;
// }
//}
//pan a mono audio source into stereo
//x is a numpy array, angle is the angle in radiants
double angle = GridItem.Panning * 100;
signal = (float)(Math.Sqrt(2) / 2.0 * (Math.Cos(angle) + Math.Sin(angle)) * signal);
left[index] = signal;
}
for (int index = 0; index < count; index++)
{
float signal = Buffer.RightSamples[_bufferIndex + index];
//Add Gain
signal = signal * (float)gain_factor;
//Panning
//Optie 1
//signal = signal + (GridItem.Panning / 2);
//Optie 2
//if (GridItem.Panning < 0) {
// if (GridItem.Panning == -1) {
// signal = signal * float.MinValue;
// } else {
// signal = signal * (float)panfactorRight;
// }
//}
//Optie 3
double angle = GridItem.Panning * 100;
signal = (float)(Math.Sqrt(2) / 2.0 * (Math.Cos(angle) - Math.Sin(angle)) * signal);
right[index] = signal;
}
_bufferIndex += left.SampleCount;
}
/// <summary>
/// With midi info
/// </summary>
/// <param name="plugin"></param>
/// <param name="blockSize"></param>
/// <param name="inputs"></param>
/// <param name="outputs"></param>
VstAudioBuffer[] PluginPreProcess1(VstPlugin plugin, int blockSize, VstAudioBuffer[] inputs, VstAudioBuffer[] outputs)
{
if (HasMidi(plugin.Host.Parent))
VstMidiEnumerator.SendMidi2Plugin( plugin, plugin.Host.Parent, blockSize );
return PluginPreProcess2(plugin,inputs,outputs);
}
public void Play(VstAudioBuffer left, VstAudioBuffer right)
{
_bufferIndex = 0;
float clip;
//System.IO.File.AppendAllText(@"C:\Users\Kavun\School\SPRING 12\CSC498\VST\KevinMidi1\KevinMidi1\bin\Debug\debug.txt", "PreLoad\n" + "_bufferIndex: " + _bufferIndex + "\n" + "bufferOffset: " + bufferOffset + "\n" + "Synth samples: " + SynthBuffer.LeftSamples.Count + "\n" + "OutputBufferSize: " + left.SampleCount + "\n\n");
while (_bufferIndex + SynthBuffer.LeftSamples.Count < left.SampleCount)
{
for (int index = bufferOffset; index < SynthBuffer.LeftSamples.Count; index++)
{
clip = SynthBuffer.LeftSamples[index];
if (time < attackTime) // attack envelope
{
clip = time / attackTime * clip;
}
else if (shouldEnd) // forced release envelope
{
if (releaseIndex == 0)
{
clip = 0;
isOn = false;
}
else
{
clip = clip * releaseIndex / releaseTime;
releaseIndex--;
}
}
left[_bufferIndex] = clip;
right[_bufferIndex] = clip;
_bufferIndex++;
time++;
}
if (bufferOffset != 0)
bufferOffset = 0;
}
bufferOffset = left.SampleCount - _bufferIndex;
for (int index = 0; index < bufferOffset; index++)
{
clip = SynthBuffer.LeftSamples[index];
if (time < attackTime)
{
clip = time / attackTime * clip; // attack envelope
}
else if (shouldEnd) // forced release envelope
{
if (releaseIndex == 0)
{
clip = 0;
isOn = false;
}
else
{
clip = clip * releaseIndex / releaseTime;
releaseIndex--;
}
}
left[_bufferIndex] = clip;
right[_bufferIndex] = clip;
_bufferIndex++;
time++;
}
//System.IO.File.AppendAllText(@"C:\Users\Kavun\School\SPRING 12\CSC498\VST\KevinMidi1\KevinMidi1\bin\Debug\debug.txt", "PostLoad\n" + "_bufferIndex: " + _bufferIndex + "\n" + "bufferOffset: " + bufferOffset + "\n" + "Synth samples: " + SynthBuffer.LeftSamples.Count + "\n" + "OutputBufferSize: " + left.SampleCount + "\n\n");
}
public void Process(VstPlugin plugin, VstAudioBuffer[] insI, VstAudioBuffer[] insO)
{
plugin.PluginCommandStub.StartProcess();
plugin.PluginCommandStub.ProcessReplacing(insI, insO);
plugin.PluginCommandStub.StopProcess();
}
/// <summary>
/// Called by the host once every cycle to process incoming audio as well as output audio.
/// </summary>
/// <param name="inputs">An array with audio input buffers.</param>
/// <param name="outputs">An array with audio output buffers.</param>
/// <remarks>The implementation calls the <see cref="IVstPluginAudioProcessor"/> interface.</remarks>
public virtual void ProcessReplacing(VstAudioBuffer[] inputs, VstAudioBuffer[] outputs)
{
IVstPluginAudioProcessor audioProcessor = pluginCtx.Plugin.GetInstance<IVstPluginAudioProcessor>();
if (audioProcessor != null)
audioProcessor.Process(inputs, outputs);
}
public void Process(VstPlugin plugin, VstAudioBuffer[] inputs)
{
Process(plugin,inputs,boutput);
}
