Example #1
0
        public static void DisposeVST()
        {
            if (Mixer32 != null) Mixer32.RemoveInputStream(vstStream);

            if (vstStream != null) vstStream.Dispose();
            vstStream = null;

            if (GeneralVST != null) GeneralVST.Dispose();
            GeneralVST = null;
        }
        public static void DisposeVST()
        {
            if (Mixer32 != null)
            {
                Mixer32.RemoveInputStream(vstStream);
            }

            if (vstStream != null)
            {
                vstStream.Dispose();
            }
            vstStream = null;

            if (GeneralVST != null)
            {
                GeneralVST.Dispose();
            }
            GeneralVST = 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);
        }
		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;
		}
        public bool ProcessOffline(String waveInputFilePath, String waveOutputFilePath, String pluginPath, String fxpFilePath=null, float volume=1.0f)
        {
            WaveFileReader 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) {
                HostCommandStub hcs = new HostCommandStub();
                hcs.Directory = System.IO.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 += new EventHandler<VSTStreamEventArgs>(vst_ProcessCalled);
                    vstStream.PlayingStarted += new EventHandler(vst_PlayingStarted);
                    vstStream.PlayingStopped += new EventHandler(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
            byte[] buffer = new byte[512*4];
            using (MemoryStream 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;
        }
Example #6
0
        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;
        }