private 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.Commands.Open();
return(ctx);
}
catch (Exception e)
{
MessageBox.Show(this, e.ToString(), Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return(null);
}
public void LoadPlugin(string pluginPath)
{
LoadedPluginContext = VstPluginContext.Create(pluginPath, this);
// update plugin info to loaded plugin
_hostCmdProxy.UpdatePluginInfo(LoadedPluginContext.PluginInfo);
}
public static VST LoadVST(string VSTPath, IntPtr hWnd)
{
DisposeVST();
GeneralVST = new VST();
var 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 += 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);
}
static void StartAudioOutput(string pluginPath, string waveFilePath)
{
try
{
var hostCmdStub = new HostCommandStub();
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();
var audioOut = new AudioOutput(
new List <IVstPluginCommandStub>()
{
ctx.PluginCommandStub
},
waveFilePath);
Thread.Sleep(100);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
}
}
public VstPluginContext CreateVstPluginContext(string pluginName)
{
VstPluginContext pluginContext = null;
string pluginPath = AvailablePlugins.First(x => x.Name == pluginName).DLLPath;
try
{
//VstHostCommandBase hostCmdStub = new VstHostCommandBase(this);
//hostCmdStub.PluginCalled += hostCmdStub_PluginCalled;
pluginContext = VstPluginContext.Create(pluginPath, this);
// add custom data to the context
pluginContext.Set("PluginPath", pluginName);
pluginContext.Set("HostCmdStub", this);
// actually open the plugin itself
pluginContext.PluginCommandStub.Open();
pluginContext.PluginCommandStub.SetBlockSize(mAsioBuffSize);
if (mAsio != null)
{
pluginContext.PluginCommandStub.SetSampleRate((float)mAsio.SampleRate);
}
pluginContext.PluginCommandStub.SetProcessPrecision(VstProcessPrecision.Process32);
}
catch (Exception e)
{
MessageBox.Show(e.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return(pluginContext);
}
//load from file
private VstPluginContext OpenPlugin(string pluginPath)
{
try
{
HostCommandStub hostCmdStub = new HostCommandStub();
hostCmdStub.PluginCalled += HostCmdStub_PluginCalled;
hostCmdStub.RaiseSave = SetNeedsSafe;
VstPluginContext ctx = VstPluginContext.Create(pluginPath, hostCmdStub);
var midiOutChannels = ctx.PluginCommandStub.GetNumberOfMidiOutputChannels();
//if(midiOutChannels > 0)
{
hostCmdStub.FProcessEventsAction = ReceiveEvents;
}
// add custom data to the context
ctx.Set("PluginPath", pluginPath);
ctx.Set("HostCmdStub", hostCmdStub);
// actually open the plugin itself
ctx.PluginCommandStub.Open();
return(ctx);
}
catch (Exception e)
{
MessageBox.Show(FOwnerWindow, e.ToString(), "VST Load", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return(null);
}
public void Create_InvalidPluginFile_ThrowsExpectedExceptionWithResourceString()
{
var hostCmdStub = new StubHostCommandStub();
var notaPluginFile = Assembly.GetExecutingAssembly().Location;
VstPluginContext.Create(notaPluginFile, hostCmdStub);
}
//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);
}
public void Create_InvalidPluginFile_ThrowsExpectedException()
{
var hostCmdStub = new StubHostCommandStub();
var notaPluginFile = Assembly.GetExecutingAssembly().Location;
Action target = () => VstPluginContext.Create(notaPluginFile, hostCmdStub);
target.Should().Throw <EntryPointNotFoundException>();
}
private 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();
ctx.PluginCommandStub.SetSampleRate(44100f);
ctx.PluginCommandStub.SetBlockSize(512);
ctx.PluginCommandStub.MainsChanged(true);
ctx.PluginCommandStub.StartProcess();
var sp = new VstSpeakerArrangement();
sp.Type = VstSpeakerArrangementType.SpeakerArrStereo;
VstSpeakerProperties[] f = new VstSpeakerProperties[2];
f[0] = new VstSpeakerProperties();
f[1] = new VstSpeakerProperties();
f[0].SpeakerType = VstSpeakerTypes.SpeakerL;
f[1].SpeakerType = VstSpeakerTypes.SpeakerR;
sp.Speakers = f;
var spin = new VstSpeakerArrangement();
spin.Type = VstSpeakerArrangementType.SpeakerArrEmpty;
VstSpeakerProperties[] f2 = new VstSpeakerProperties[0];
spin.Speakers = f2;
//ctx.PluginCommandStub.SetSpeakerArrangement(spin, sp);
return(ctx);
}
catch (Exception e)
{
MessageBox.Show(this, e.ToString(), Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return(null);
}
void CreateContext(string path)
{
if (context != null)
{
try{ context.PluginCommandStub.Close(); } catch {}
try{ context.Dispose(); } catch {}
try{ context = null; } catch {}
}
context = VstPluginContext.Create(path, Host.VstHost);
PluginCommandStub.SetSampleRate(Convert.ToSingle(Host.VstPlayer.Settings.Rate));
Set("PluginPath", PluginPath = path);
Set("HostCmdStub", Host.VstHost);
// if (context!=null) Open();
}
public VSTiInterface(string pluginPath)
{
HostCommandStub hostCmdStub = new HostCommandStub();
hostCmdStub.PluginCalled += new EventHandler <PluginCalledEventArgs>(HostCmdStub_PluginCalled);
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();
}
private VstPluginContext OpenPlugin(string pluginPath)
{
_host = new HostCommandStub();
var ctx = VstPluginContext.Create(pluginPath, _host);
ctx.Set("PluginPath", pluginPath);
ctx.Set("HostCmdStub", _host);
ctx.PluginCommandStub.SetSampleRate(1000 * _host.GetSampleRate());
ctx.PluginCommandStub.Open();
return(ctx);
}
public void OpenPlugin(string pluginPath, Jacobi.Vst.Core.Host.IVstHostCommandStub hostCmdStub)
{
try
{
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();
PluginContext = ctx;
// there is a question whether we should "turn on" the plugin here or later
// by "turn on" i mean do MainsChanged(true)
// a working Vst Host (see MidiVstTest, a copy from the microDRUM project)
// does the following:
//
// GeneralVST.pluginContext = VstPluginContext.Create(VSTPath, hcs);
// GeneralVST.pluginContext.PluginCommandStub.Open();
// GeneralVST.pluginContext.PluginCommandStub.EditorOpen(hWnd);
// GeneralVST.pluginContext.PluginCommandStub.MainsChanged(true);
// While a forum entry suggested the following:
// [plugin.Open()]
// plugin.MainsChanged(true) // turn on 'power' on plugin.
// plugin.StartProcess() // let the plugin know the audio engine has started
// PluginContext.PluginCommandStub.ProcessEvents(ve); // process events (like VstMidiEvent)
//
// while(audioEngineIsRunning)
// {
// plugin.ProcessReplacing(inputBuffers, outputBuffers) // letplugin process audio stream
// }
//
// plugin.StopProcess()
// plugin.MainsChanged(false)
//
// [plugin.Close()]
//doPluginOpen();
}
catch (Exception e)
{
throw new InvalidOperationException(e.ToString(), e.InnerException);
}
}
private static void LoadVstInternal(RemoteVstPlugin remoteVst, bool debug = false)
{
var hostCommandStub = new NewHostCommandStub(remoteVst.Logger);
hostCommandStub.PluginDll = Path.GetFileName(remoteVst.DllPath);
remoteVst.Logger.Debug($"{hostCommandStub.PluginDll}: Loading plugin");
var ctx = VstPluginContext.Create(remoteVst.DllPath, hostCommandStub);
ctx.Set("Plugin", remoteVst);
remoteVst.PluginContext = ctx;
ctx.Set("PluginPath", remoteVst.DllPath);
ctx.Set("HostCmdStub", hostCommandStub);
remoteVst.Logger.Debug($"{hostCommandStub.PluginDll}: Opening plugin");
ctx.PluginCommandStub.Open();
remoteVst.Logger.Debug($"{hostCommandStub.PluginDll}: Setting Sample Rate {SampleRate}");
ctx.PluginCommandStub.SetSampleRate(SampleRate);
remoteVst.Logger.Debug($"{hostCommandStub.PluginDll}: Setting Block Size {BlockSize}");
ctx.PluginCommandStub.SetBlockSize(BlockSize);
remoteVst.Logger.Debug($"{hostCommandStub.PluginDll}: Setting 32 bit precision");
ctx.PluginCommandStub.SetProcessPrecision(VstProcessPrecision.Process32);
remoteVst.Logger.Debug($"{hostCommandStub.PluginDll}: Activating output");
remoteVst.PluginContext.PluginCommandStub.MainsChanged(true);
remoteVst.Logger.Debug($"{hostCommandStub.PluginDll}: Start Processing");
ctx.PluginCommandStub.StartProcess();
remoteVst.IsLoaded = true;
}
public VstPluginInfo GetPluginInfo(IVstHostCommandProxy hostCmdProxy)
{
//
// get the path to the wrapped plugin from config
//
if (PluginConfiguration == null)
{
throw new InvalidOperationException("No plugin configuration found.");
}
var pluginPath = PluginConfiguration["PluginPath"];
Host.HostCommandStubAdapter hostCmdAdapter = new Host.HostCommandStubAdapter(hostCmdProxy);
_pluginCtx = VstPluginContext.Create(pluginPath, hostCmdAdapter);
return(_pluginCtx.PluginInfo);
}
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();
var 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);
}
private VstPluginContext LoadPlugin(string pluginPath)
{
try
{
HostCommandStub hostCommandStub = new HostCommandStub();
hostCommandStub.PluginCalled += new EventHandler <PluginCalledEventArgs>(hostCommandStub_PluginCalled);
VstPluginContext ctx = VstPluginContext.Create(pluginPath, hostCommandStub);
ctx.Set("PluginPath", pluginPath);
ctx.Set("HostCmdStub", hostCommandStub);
ctx.PluginCommandStub.Commands.Open();
selectVSTButton.Enabled = false;
loadVSTButton.Enabled = false;
return(ctx);
}
catch (Exception e)
{
MessageBox.Show(this, e.ToString(), Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return(null);
}
public VstPluginInfo GetPluginInfo(IVstHostCommandStub hostCmdStub)
{
//
// get the path to the wrapped plugin from config
//
if (PluginConfiguration == null)
{
throw new ApplicationException("No plugin configuration found.");
}
KeyValueConfigurationElement configElem = PluginConfiguration.AppSettings.Settings["PluginPath"];
if (configElem == null)
{
throw new ApplicationException("The 'PluginPath' configuration (app) setting was not found.");
}
Host.HostCommandStubAdapter hostCmdAdapter = new Host.HostCommandStubAdapter(hostCmdStub);
_pluginCtx = VstPluginContext.Create(configElem.Value, hostCmdAdapter);
return(_pluginCtx.PluginInfo);
}
public void OpenPlugin(string pluginPath, Jacobi.Vst.Core.Host.IVstHostCommandStub hostCmdStub)
{
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();
//doPluginOpen();
PluginContext = ctx;
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.ToString());
}
}
private VstPluginContext OpenPlugin(string pluginPath)
{
try
{
_host = new HostCommandStub();
var ctx = VstPluginContext.Create(pluginPath, _host);
ctx.Set("PluginPath", pluginPath);
ctx.Set("HostCmdStub", _host);
ctx.PluginCommandStub.SetSampleRate(1000 * _host.GetSampleRate());
ctx.PluginCommandStub.Open();
return(ctx);
}
catch (Exception e)
{
MessageBox.Show(e.Message + Environment.NewLine + e.StackTrace);
}
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);
}
private void addPath(string path)
{
Boolean saveSettings = false;
if (!Directory.Exists(path))
{
return;
}
// Recursive
foreach (var dir in new DirectoryInfo(path).GetDirectories())
{
addPath(dir.FullName);
}
foreach (FileInfo file in new DirectoryInfo(path).GetFiles())
{
if (file.Extension == ".dll")
{
if (mSettingsMgr.Settings.KnownVSTPluginDlls.Contains(file.FullName))
{
continue;
}
try
{
//VstHostCommandBase tmpHostCmdStub = new VstHostCommandBase(this);
using (VstPluginContext ctx = VstPluginContext.Create(file.FullName, this))
{
// add custom data to the context
ctx.Set("PluginPath", file.FullName);
ctx.Set("HostCmdStub", this);
VstInfo info = new VstInfo();
info.AudioInputCount = ctx.PluginInfo.AudioInputCount;
info.AudioOutputCount = ctx.PluginInfo.AudioOutputCount;
info.CanReceiveVstMidiEvent = ctx.PluginCommandStub.CanDo(VstCanDoHelper.ToString(VstPluginCanDo.ReceiveVstMidiEvent)) == VstCanDoResult.Yes;
info.Name = file.Name.Replace(".dll", string.Empty); // ctx.PluginCommandStub.GetEffectName();
info.DLLPath = file.FullName;
// Effect?
if (info.AudioInputCount > 0 && info.AudioOutputCount > 0)
{
mSettingsMgr.Settings.Effects.Add(info);
}
// VSTi?
if (info.CanReceiveVstMidiEvent)
{
mSettingsMgr.Settings.Instruments.Add(info);
}
if ((ctx.PluginInfo.Flags & VstPluginFlags.ProgramChunks) != VstPluginFlags.ProgramChunks)
{
MessageBox.Show(string.Format("{0} does not support chunks", info.Name));
}
}
}
catch
{
// Do nothing
}
// Files to exclude from future search
mSettingsMgr.Settings.KnownVSTPluginDlls.Add(file.FullName);
saveSettings = true;
}
}
if (saveSettings)
{
mSettingsMgr.SaveSettings();
}
}
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);
}
private VstPluginContextWrapper OpenPlugin(string pluginPath)
{
try
{
if (File.Exists(pluginPath))
{
HostCommandStub hostCmdStub = new HostCommandStub();
VstPluginContext ctx = VstPluginContext.Create(pluginPath, hostCmdStub);
if (ctx.PluginInfo.AudioInputCount != 2)
{
return(null);
}
if (ctx.PluginInfo.AudioOutputCount != 2)
{
return(null);
}
if ((ctx.PluginInfo.Flags & VstPluginFlags.CanReplacing) == 0)
{
return(null);
}
hostCmdStub.PluginCalled += (s, e) =>
{
HostCommandStub stub = (HostCommandStub)s;
// can be null when called from inside the plugin main entry point.
if (stub.PluginContext.PluginInfo != null)
{
//Debug.WriteLine("Plugin " + hostCmdStub.PluginContext.PluginInfo.PluginID + " called:" + e.Message);
}
else
{
//Debug.WriteLine("The loading Plugin called:" + e.Message);
}
};
// add custom data to the context
ctx.Set("PluginPath", pluginPath);
ctx.Set("HostCmdStub", hostCmdStub);
// actually open the plugin itself
ctx.PluginCommandStub.Open();
ctx.PluginCommandStub.SetSampleRate(Program.CurrentSamplingRate);
ctx.PluginCommandStub.MainsChanged(true);
ctx.PluginCommandStub.StartProcess();
initVECCSS();
return(new VstPluginContextWrapper(ctx));
}
}
catch (Exception ex)
{
if (ex.GetType() == typeof(Exception))
{
throw;
}
else if (ex.GetType() == typeof(SystemException))
{
throw;
}
//ignore
}
return(null);
}