public static VSTController LoadVST(string VSTPath, IntPtr hWnd)
{
GeneralVST = new VSTController();
var hcs = new HostCommandStub();
try
{
GeneralVST.PluginContext = VstPluginContext.Create(VSTPath, hcs);
GeneralVST.PluginContext.PluginCommandStub.Open();
//pluginContext.PluginCommandStub.SetProgram(0);
GeneralVST.PluginContext.PluginCommandStub.EditorOpen(hWnd);
GeneralVST.PluginContext.PluginCommandStub.MainsChanged(true);
vstStream = new VSTStream();
vstStream.ProcessCalled += GeneralVST.Stream_ProcessCalled;
vstStream.pluginContext = GeneralVST.PluginContext;
vstStream.SetWaveFormat(44100, 2);
Mixer32.AddInputStream(vstStream);
return(GeneralVST);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return(null);
}
//private void OutPluginInfo(VstPluginContext ctx)
//{
// Debug.Print("Plugin: " + ctx.PluginCommandStub.GetEffectName() + " "
// + ctx.PluginCommandStub.GetProductString()
// + "Version: " + ctx.PluginCommandStub.GetVendorVersion().ToString() + "\n"
// + "***********************************************************************\n");
//}
public VstPluginContext OpenPlugin(string pluginPath)
{
try
{
HostCommandStub hostCmdStub = new HostCommandStub();
hostCmdStub.PluginCalled += new EventHandler <PluginCalledEventArgs>(HostCmdStub_PluginCalled);
VstPluginContext ctx = VstPluginContext.Create(pluginPath, hostCmdStub);
// add custom data to the context
ctx.Set("PluginPath", pluginPath);
ctx.Set("HostCmdStub", hostCmdStub);
// actually open the plugin itself
ctx.PluginCommandStub.Open();
Plugin plugin = new Plugin(ctx.PluginInfo.PluginID, ctx.PluginCommandStub.GetProductString(), ctx,
GetParameters(ctx));
Plugins.Add(ctx.PluginInfo.PluginID, plugin);
Debug.Print("Plugin: " + pluginPath + " Loaded");
return(ctx);
}
catch (Exception e)
{
Debug.Print(e.Message);
}
return(null);
}
public static VST LoadVst(string vstPath, IntPtr hWnd)
{
DisposeVst();
_generalVst = new VST();
var hcs = new HostCommandStub {
Directory = System.IO.Path.GetDirectoryName(vstPath)
};
try
{
_generalVst.pluginContext = VstPluginContext.Create(vstPath, hcs);
_generalVst.pluginContext.PluginCommandStub.Open();
_generalVst.pluginContext.PluginCommandStub.SetProgram(13000);
_generalVst.pluginContext.PluginCommandStub.EditorOpen(hWnd);
_generalVst.pluginContext.PluginCommandStub.MainsChanged(true);
_vstStream = new VSTStream();
_vstStream.ProcessCalled += _generalVst.Stream_ProcessCalled;
_vstStream.pluginContext = _generalVst.pluginContext;
_vstStream.SetWaveFormat(44100, 2);
_mixer32.AddInputStream(_vstStream);
return(_generalVst);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
return(null);
}
private void HostCmdStub_PluginCalled(object sender, PluginCalledEventArgs e)
{
HostCommandStub hostCmdStub = (HostCommandStub)sender;
if (hostCmdStub.PluginContext.PluginInfo != null)
{
Debug.WriteLine("Plugin " + hostCmdStub.PluginContext.PluginInfo.PluginID + " called:" + e.Message);
}
else
{
Debug.WriteLine("The loading Plugin called:" + e.Message);
}
}
private void HostCmdStub_PluginCalled(object sender, PluginCalledEventArgs e)
{
HostCommandStub hostCmdStub = (HostCommandStub)sender;
// can be null when called from inside the plugin main entry point.
if (hostCmdStub.PluginContext.PluginInfo != null)
{
Debug.WriteLine("Plugin " + hostCmdStub.PluginContext.PluginInfo.PluginID + " called:" + e.Message);
}
else
{
Debug.WriteLine("The loading Plugin called:" + e.Message);
}
}
/// <summary>
/// Called to dispose of this host instance.
/// </summary>
public void Dispose()
{
if (_intfMgr != null)
{
_intfMgr.Dispose();
_intfMgr = null;
}
if (HostCommandStub != null)
{
HostCommandStub.Dispose();
HostCommandStub = null;
}
Plugin = null;
}
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 VstPluginContext OpenPlugin(string pluginPath)
{
try
{
HostCommandStub hostCmdStub = new HostCommandStub();
hostCmdStub.PluginCalled += new EventHandler <PluginCalledEventArgs>(HostCmdStub_PluginCalled);
VstPluginContext ctx = VstPluginContext.Create(pluginPath, hostCmdStub);
ctx.Set("PluginPath", pluginPath);
ctx.Set("HostCmdStub", hostCmdStub);
ctx.PluginCommandStub.Open();
return(ctx);
}
catch (Exception) { }
return(null);
}
public static VST LoadVST(string VSTPath, int sampleRate, int channels)
{
DisposeVST();
GeneralVST = new VST();
HostCommandStub hcs = new HostCommandStub();
hcs.Directory = System.IO.Path.GetDirectoryName(VSTPath);
try
{
GeneralVST.PluginContext = VstPluginContext.Create(VSTPath, hcs);
// add custom data to the context
GeneralVST.PluginContext.Set("PluginPath", VSTPath);
GeneralVST.PluginContext.Set("HostCmdStub", hcs);
// actually open the plugin itself
GeneralVST.PluginContext.PluginCommandStub.Open();
// Method arguments used to contain the following to allow
// opening the vst plugin editor - not supported in this commanline processor
// public static VST LoadVST(string VSTPath, IntPtr hWnd)
// GeneralVST.pluginContext.PluginCommandStub.EditorOpen(hWnd);
GeneralVST.PluginContext.PluginCommandStub.MainsChanged(true);
vstStream = new VSTStream();
vstStream.pluginContext = GeneralVST.PluginContext;
vstStream.SetWaveFormat(sampleRate, channels);
Mixer32.AddInputStream(vstStream);
return(GeneralVST);
}
catch (Exception ex)
{
Console.Out.WriteLine("Could not load VST! ({0})", ex.Message);
}
return(null);
}
public static int SetUpPlugin(
CallParameters parameters,
System.Threading.CancellationToken cancellationToken
)
{
var cancellationTaskSource = new CancellationTokenSource();
Task.Run(() =>
{
cancellationToken.WaitHandle.WaitOne();
form.Close();
}, cancellationTaskSource.Token);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
string pluginPath = parameters.VstPluginPath;
var hostCmdStub = new HostCommandStub();
var ctx = VstPluginContext.Create(pluginPath, hostCmdStub);
ctx.PluginCommandStub.Open();
// add custom data to the context
ctx.Set("PluginPath", pluginPath);
ctx.Set("HostCmdStub", hostCmdStub);
ctx.PluginCommandStub.MainsChanged(true);
form = new InvisibleForm(ctx);
Application.Run(form);
ctx.PluginCommandStub.MainsChanged(false);
if (cancellationToken.IsCancellationRequested)
{
// Был затребован выход из программы
ctx.PluginCommandStub.Close();
cancellationTaskSource.Cancel();
return(ReturnCodeOffset + 1);
}
byte[] vstSaveState = null;
float[] vstParameters = null;
if (!parameters.FxbFileAsParams)
{
vstSaveState = ctx.PluginCommandStub.GetChunk(true);
}
else
{
var vstParametersList = new List <float>();
var paramCount = ctx.PluginInfo.ParameterCount;
for (int i = 0; i < paramCount; i++)
{
vstParametersList.Add(ctx.PluginCommandStub.GetParameter(i));
}
vstParameters = vstParametersList.ToArray();
}
// VST навм больше не нужен, закрываем
ctx.PluginCommandStub.Close();
if (cancellationToken.IsCancellationRequested)
{
// Был затребован выход из программы
cancellationTaskSource.Cancel();
return(ReturnCodeOffset + 1);
}
int result;
switch (parameters.FxbFileFormat.ToLowerInvariant())
{
case "fxb":
result = SaveStateAsFxb(parameters.FxbFile, vstSaveState, vstParameters,
!parameters.FxbFileAsParams,
(uint)ctx.PluginInfo.PluginID, (uint)ctx.PluginInfo.PluginVersion);
break;
case "fxp":
result = SaveStateAsFxp(parameters.FxbFile, vstSaveState, vstParameters,
!parameters.FxbFileAsParams,
(uint)ctx.PluginInfo.PluginID, (uint)ctx.PluginInfo.PluginVersion);
break;
default:
Console.Error.WriteLine("Save state format {0} does not supported", parameters.FxbFileFormat);
cancellationTaskSource.Cancel();
return(ReturnCodeOffset + 2);
}
Console.WriteLine(
"VST plugin settings saved to {0} (file format {1}; file subformat: {2})",
parameters.FxbFile,
parameters.FxbFileFormat,
(parameters.FxbFileFormat.ToLowerInvariant() == "fxb")
? "bank param with " + (parameters.FxbFileAsParams ? "preset param" : "preset opaque")
: (parameters.FxbFileAsParams ? "preset param" : "preset opaque")
);
cancellationTaskSource.Cancel();
return((result > 0) ? ReturnCodeOffset + result : 0);
}
public static int ProcessWaveFile(
CallParameters parameters,
System.Threading.CancellationToken cancellationToken
)
{
string pluginPath = parameters.VstPluginPath;
if (!System.IO.File.Exists(parameters.FxbFile))
{
Console.Error.WriteLine("Can not find Bank/Preset file {0}", parameters.FxbFile);
return(ReturnCodeOffset + 0);
}
if (!System.IO.File.Exists(pluginPath))
{
Console.Error.WriteLine("Can not find VST-plugin file {0}", pluginPath);
return(ReturnCodeOffset + 1);
}
if (parameters.InputWavFile == null)
{
Console.Error.WriteLine("InputWavFile param is missing");
return(ReturnCodeOffset + 2);
}
if (!System.IO.File.Exists(parameters.InputWavFile))
{
Console.Error.WriteLine("Can not find wave file {0}", parameters.InputWavFile);
return(ReturnCodeOffset + 3);
}
if (parameters.OutputWavFile == null)
{
Console.Error.WriteLine("OutputWavFile param is missing");
return(ReturnCodeOffset + 4);
}
var hostCmdStub = new HostCommandStub();
var vstPlugin = VstPluginContext.Create(pluginPath, hostCmdStub);
vstPlugin.PluginCommandStub.Open();
// add custom data to the context
vstPlugin.Set("PluginPath", pluginPath);
vstPlugin.Set("HostCmdStub", hostCmdStub);
#region Draw VST Plugin Information
// plugin product
Console.WriteLine("{0,-20}\t{1}", "Plugin Name", vstPlugin.PluginCommandStub.GetEffectName());
Console.WriteLine("{0,-20}\t{1}", "Product", vstPlugin.PluginCommandStub.GetProductString());
Console.WriteLine("{0,-20}\t{1}", "Vendor", vstPlugin.PluginCommandStub.GetVendorString());
Console.WriteLine("{0,-20}\t{1}", "Vendor Version",
vstPlugin.PluginCommandStub.GetVendorVersion().ToString());
Console.WriteLine("{0,-20}\t{1}", "Vst Support", vstPlugin.PluginCommandStub.GetVstVersion().ToString());
Console.WriteLine("{0,-20}\t{1}", "Plugin Category", vstPlugin.PluginCommandStub.GetCategory().ToString());
// plugin info
Console.WriteLine("{0,-20}\t{1}", "Flags", vstPlugin.PluginInfo.Flags.ToString());
Console.WriteLine("{0,-20}\t{1}", "Plugin ID", vstPlugin.PluginInfo.PluginID.ToString());
Console.WriteLine("{0,-20}\t{1}", "Plugin Version", vstPlugin.PluginInfo.PluginVersion.ToString());
#endregion
{
var t = vstPlugin.PluginCommandStub.CanDo(VstCanDoHelper.ToString(VstPluginCanDo.Offline));
if (t == VstCanDoResult.No)
{
Console.Error.WriteLine("This VST Plugin does not support offline convertation");
return(ReturnCodeOffset + 6);
}
if (!vstPlugin.PluginInfo.Flags.HasFlag(VstPluginFlags.CanReplacing) &&
!vstPlugin.PluginInfo.Flags.HasFlag(VstPluginFlags.CanDoubleReplacing))
{
Console.Error.WriteLine("This VST Plugin does not replacing samples");
return(ReturnCodeOffset + 7);
}
}
vstPlugin.PluginCommandStub.MainsChanged(true);
int result = FxbReader.ReadFileIntoPluginStub(
parameters.FxbFile,
(uint)vstPlugin.PluginInfo.PluginID,
(uint)vstPlugin.PluginInfo.PluginVersion,
parameters.IgnorePluginVersion,
vstPlugin.PluginCommandStub
);
vstPlugin.PluginCommandStub.MainsChanged(false);
if (result != 0)
{
vstPlugin.PluginCommandStub.Close();
return(result);
}
if (cancellationToken.IsCancellationRequested)
{
// Был затребован выход из программы
vstPlugin.PluginCommandStub.Close();
return(ReturnCodeOffset + 5);
}
result = ProcessFile(parameters.InputWavFile, parameters.OutputWavFile, vstPlugin, cancellationToken);
vstPlugin.PluginCommandStub.Close();
return(result);
}
public bool ProcessOffline(String waveInputFilePath, String waveOutputFilePath, String pluginPath, String fxpFilePath = null, float volume = 1.0f)
{
var wavFileReader = new WaveFileReader(waveInputFilePath);
// reuse if batch processing
bool doUpdateVstPlugin = false;
if (_pluginPath != null)
{
if (_pluginPath.Equals(pluginPath))
{
// plugin has not changed
}
else
{
// plugin has changed!
doUpdateVstPlugin = true;
}
}
else
{
_pluginPath = pluginPath;
doUpdateVstPlugin = true;
}
if (doUpdateVstPlugin)
{
var hcs = new HostCommandStub();
hcs.Directory = Path.GetDirectoryName(pluginPath);
vst = new VST();
try
{
vst.PluginContext = VstPluginContext.Create(pluginPath, hcs);
if (vst.PluginContext == null)
{
Console.Out.WriteLine("Could not open up the plugin specified by {0}!", pluginPath);
return(false);
}
// plugin does not support processing audio
if ((vst.PluginContext.PluginInfo.Flags & VstPluginFlags.CanReplacing) == 0)
{
Console.Out.WriteLine("This plugin does not process any audio.");
return(false);
}
// check if the plugin supports offline proccesing
if (vst.PluginContext.PluginCommandStub.CanDo(VstCanDoHelper.ToString(VstPluginCanDo.Offline)) == VstCanDoResult.No)
{
Console.Out.WriteLine("This plugin does not support offline processing.");
Console.Out.WriteLine("Try use realtime (-play) instead!");
return(false);
}
// add custom data to the context
vst.PluginContext.Set("PluginPath", pluginPath);
vst.PluginContext.Set("HostCmdStub", hcs);
// actually open the plugin itself
vst.PluginContext.PluginCommandStub.Open();
Console.Out.WriteLine("Enabling the audio output on the VST!");
vst.PluginContext.PluginCommandStub.MainsChanged(true);
// setup the VSTStream
vstStream = new VSTStream();
vstStream.ProcessCalled += vst_ProcessCalled;
vstStream.PlayingStarted += vst_PlayingStarted;
vstStream.PlayingStopped += vst_PlayingStopped;
vstStream.pluginContext = vst.PluginContext;
vstStream.SetWaveFormat(wavFileReader.WaveFormat.SampleRate, wavFileReader.WaveFormat.Channels);
} catch (Exception ex) {
Console.Out.WriteLine("Could not load VST! ({0})", ex.Message);
return(false);
}
}
if (File.Exists(fxpFilePath))
{
vst.LoadFXP(fxpFilePath);
}
else
{
Console.Out.WriteLine("Could not find preset file (fxp|fxb) ({0})", fxpFilePath);
}
// each float is 4 bytes
var buffer = new byte[512 * 4];
using (var ms = new MemoryStream())
{
vstStream.SetInputWave(waveInputFilePath, volume);
vstStream.DoProcess = true;
// wait a little while
Thread.Sleep(1000);
// keep on reading until it stops playing.
while (!stoppedPlaying)
{
int read = vstStream.Read(buffer, 0, buffer.Length);
if (read <= 0)
{
break;
}
ms.Write(buffer, 0, read);
}
// save
using (WaveStream ws = new RawSourceWaveStream(ms, vstStream.WaveFormat))
{
ws.Position = 0;
WaveFileWriter.CreateWaveFile(waveOutputFilePath, ws);
}
}
// reset the input wave file
vstStream.DoProcess = false;
vstStream.DisposeInputWave();
// reset if calling this method multiple times
stoppedPlaying = false;
return(true);
}
public static VST LoadVST(string VSTPath, IntPtr hWnd)
{
DisposeVST();
GeneralVST = new VST();
HostCommandStub hcs = new HostCommandStub();
hcs.Directory = System.IO.Path.GetDirectoryName(VSTPath);
try
{
GeneralVST.pluginContext = VstPluginContext.Create(VSTPath, hcs);
GeneralVST.pluginContext.PluginCommandStub.Open();
//pluginContext.PluginCommandStub.SetProgram(0);
GeneralVST.pluginContext.PluginCommandStub.EditorOpen(hWnd);
GeneralVST.pluginContext.PluginCommandStub.MainsChanged(true);
vstStream = new VSTStream();
vstStream.ProcessCalled += new EventHandler<VSTStreamEventArgs>(GeneralVST.Stream_ProcessCalled);
vstStream.pluginContext = GeneralVST.pluginContext;
vstStream.SetWaveFormat(44100, 2);
Mixer32.AddInputStream(vstStream);
return GeneralVST;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return null;
}