falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4671 Commits
16 Branches
361MB
Tree: 6fa44324dd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6fa44324dd'
${ noResults }
Carla/source/includes/vst3sdk/public.sdk/source/vst/vst2wrapper/vst2wrapper.h

336 lines
14KB
Raw Blame History 

  1. //------------------------------------------------------------------------

  2. // Project     : VST SDK

  3. //

  4. // Category    : Helpers

  5. // Filename    : public.sdk/source/vst/vst2wrapper/vst2wrapper.h

  6. // Created by  : Steinberg, 01/2009

  7. // Description : VST 3 -> VST 2 Wrapper

  8. //

  9. //-----------------------------------------------------------------------------

  10. // LICENSE

  11. // (c) 2017, Steinberg Media Technologies GmbH, All Rights Reserved

  12. //-----------------------------------------------------------------------------

  13. // Redistribution and use in source and binary forms, with or without modification,

  14. // are permitted provided that the following conditions are met:

  15. // 

  16. //   * Redistributions of source code must retain the above copyright notice, 

  17. //     this list of conditions and the following disclaimer.

  18. //   * Redistributions in binary form must reproduce the above copyright notice,

  19. //     this list of conditions and the following disclaimer in the documentation 

  20. //     and/or other materials provided with the distribution.

  21. //   * Neither the name of the Steinberg Media Technologies nor the names of its

  22. //     contributors may be used to endorse or promote products derived from this 

  23. //     software without specific prior written permission.

  24. // 

  25. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

  26. // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 

  27. // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 

  28. // IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 

  29. // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 

  30. // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 

  31. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 

  32. // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 

  33. // OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED

  34. // OF THE POSSIBILITY OF SUCH DAMAGE.

  35. //-----------------------------------------------------------------------------

  36. 

  37. /**

  38. **************************************

  39. \page vst2xwrapper VST 2.x Wrapper

  40. ***************************

  41. \section VST2Introduction Introduction

  42. ***************************

  43. The VST 3 SDK comes with a helper class which wraps one VST 3 Audio Processor and Edit Controller to

  44. a VST 2.x Plug-in.

  45. \n\n

  46. ***************************

  47. \section VST2howdoesitwork How does it work ?

  48. ***************************

  49. You just need to add public.sdk/source/vst/vst2wrapper/vst2wrapper.sdk.cpp to your project and add

  50. the following code somewhere in your sources:

  51. \code

  52. 

  53. #include "public.sdk/source/vst/vst2wrapper/vst2wrapper.h"

  54. 

  55. //------------------------------------------------------------------------

  56. ::AudioEffect* createEffectInstance (audioMasterCallback audioMaster)

  57. {

  58. 	return Steinberg::Vst::Vst2Wrapper::create (GetPluginFactory (), kAudioProcessorCID, kVst2UniqueID, audioMaster);

  59. }

  60. 

  61. \endcode

  62.  */

  63. /// \cond ignore

  64. 

  65. #pragma once

  66. 

  67. #include "pluginterfaces/base/ftypes.h"

  68. #include "pluginterfaces/vst/ivstaudioprocessor.h"

  69. #include "pluginterfaces/vst/ivsteditcontroller.h"

  70. #include "pluginterfaces/vst/ivsthostapplication.h"

  71. #include "pluginterfaces/vst/ivstprocesscontext.h"

  72. #include "pluginterfaces/vst/ivstunits.h"

  73. 

  74. #include "public.sdk/source/common/memorystream.h"

  75. #include "public.sdk/source/vst/hosting/eventlist.h"

  76. #include "public.sdk/source/vst/hosting/parameterchanges.h"

  77. #include "public.sdk/source/vst/hosting/processdata.h"

  78. #include "public.sdk/source/vst2.x/audioeffectx.h"

  79. 

  80. #include "base/source/fstring.h"

  81. #include "base/source/timer.h"

  82. 

  83. #include <map>

  84. #include <vector>

  85. 

  86. //------------------------------------------------------------------------

  87. namespace Steinberg {

  88. namespace Vst {

  89. 

  90. class Vst2MidiEventQueue;

  91. 

  92. //-------------------------------------------------------------------------------------------------------

  93. class Vst2Wrapper : public ::AudioEffectX,

  94.                     public IHostApplication,

  95.                     public IComponentHandler,

  96.                     public IUnitHandler,

  97.                     public ITimerCallback,

  98.                     public IVst3ToVst2Wrapper

  99. {

  100. public:

  101. 	//--- -------------------------------------------------------------------------------------------------

  102. 	// static creation method

  103. 	static AudioEffect* create (IPluginFactory* factory, const TUID vst3ComponentID,

  104. 	                            VstInt32 vst2ID, audioMasterCallback audioMaster);

  105. 

  106. 	Vst2Wrapper (IAudioProcessor* processor, IEditController* controller,

  107. 	             audioMasterCallback audioMaster, const TUID vst3ComponentID, VstInt32 vst2ID,

  108. 	             IPluginFactory* factory = 0);

  109. 	~Vst2Wrapper ();

  110. 

  111. 	bool init ();

  112. 

  113. 	// AudioEffectX overrides -----------------------------------------------

  114. 	virtual void suspend () SMTG_OVERRIDE; // Called when Plug-in is switched to off

  115. 	virtual void resume () SMTG_OVERRIDE; // Called when Plug-in is switched to on

  116. 	virtual VstInt32 startProcess () SMTG_OVERRIDE;

  117. 	virtual VstInt32 stopProcess () SMTG_OVERRIDE;

  118. 

  119. 	virtual void setSampleRate (float newSamplerate)

  120. 	    SMTG_OVERRIDE; // Called when the sample rate changes (always in a suspend state)

  121. 	virtual void setBlockSize (VstInt32 newBlockSize)

  122. 	    SMTG_OVERRIDE; // Called when the maximum block size changes

  123. 	// (always in a suspend state). Note that the

  124. 	// sampleFrames in Process Calls could be

  125. 	// smaller than this block size, but NOT bigger.

  126. 

  127. 	virtual float getParameter (VstInt32 index) SMTG_OVERRIDE;

  128. 	virtual void setParameter (VstInt32 index, float value) SMTG_OVERRIDE;

  129. 

  130. 	virtual void setProgram (VstInt32 program) SMTG_OVERRIDE;

  131. 	virtual void setProgramName (char* name) SMTG_OVERRIDE;

  132. 	virtual void getProgramName (char* name) SMTG_OVERRIDE;

  133. 	virtual bool getProgramNameIndexed (VstInt32 category, VstInt32 index,

  134. 	                                    char* text) SMTG_OVERRIDE;

  135. 

  136. 	virtual void getParameterLabel (VstInt32 index, char* label) SMTG_OVERRIDE;

  137. 	virtual void getParameterDisplay (VstInt32 index, char* text) SMTG_OVERRIDE;

  138. 	virtual void getParameterName (VstInt32 index, char* text) SMTG_OVERRIDE;

  139. 	virtual bool canParameterBeAutomated (VstInt32 index) SMTG_OVERRIDE;

  140. 	virtual bool string2parameter (VstInt32 index, char* text) SMTG_OVERRIDE;

  141. 	virtual bool getParameterProperties (VstInt32 index, VstParameterProperties* p) SMTG_OVERRIDE;

  142. 

  143. 	virtual VstInt32 getChunk (void** data, bool isPreset = false) SMTG_OVERRIDE;

  144. 	virtual VstInt32 setChunk (void* data, VstInt32 byteSize, bool isPreset = false) SMTG_OVERRIDE;

  145. 

  146. 	virtual bool getInputProperties (VstInt32 index, VstPinProperties* properties) SMTG_OVERRIDE;

  147. 	virtual bool getOutputProperties (VstInt32 index, VstPinProperties* properties) SMTG_OVERRIDE;

  148. 	virtual bool setSpeakerArrangement (VstSpeakerArrangement* pluginInput,

  149. 	                                    VstSpeakerArrangement* pluginOutput) SMTG_OVERRIDE;

  150. 	virtual bool getSpeakerArrangement (VstSpeakerArrangement** pluginInput,

  151. 	                                    VstSpeakerArrangement** pluginOutput) SMTG_OVERRIDE;

  152. 	virtual bool setBypass (bool onOff) SMTG_OVERRIDE;

  153. 

  154. 	virtual bool setProcessPrecision (VstInt32 precision) SMTG_OVERRIDE;

  155. 	virtual VstInt32 getNumMidiInputChannels () SMTG_OVERRIDE;

  156. 	virtual VstInt32 getNumMidiOutputChannels () SMTG_OVERRIDE;

  157. 	virtual VstInt32 getGetTailSize () SMTG_OVERRIDE;

  158. 	virtual bool getEffectName (char* name) SMTG_OVERRIDE;

  159. 	virtual bool getVendorString (char* text) SMTG_OVERRIDE;

  160. 	virtual VstInt32 getVendorVersion () SMTG_OVERRIDE;

  161. 	virtual VstIntPtr vendorSpecific (VstInt32 lArg, VstIntPtr lArg2, void* ptrArg,

  162. 	                                  float floatArg) SMTG_OVERRIDE;

  163. 	virtual VstPlugCategory getPlugCategory () SMTG_OVERRIDE;

  164. 	virtual VstInt32 canDo (char* text) SMTG_OVERRIDE;

  165. 

  166. 	virtual VstInt32 getMidiProgramName (VstInt32 channel,

  167. 	                                     MidiProgramName* midiProgramName) SMTG_OVERRIDE;

  168. 	virtual VstInt32 getCurrentMidiProgram (VstInt32 channel,

  169. 	                                        MidiProgramName* currentProgram) SMTG_OVERRIDE;

  170. 	virtual VstInt32 getMidiProgramCategory (VstInt32 channel,

  171. 	                                         MidiProgramCategory* category) SMTG_OVERRIDE;

  172. 	virtual bool hasMidiProgramsChanged (VstInt32 channel) SMTG_OVERRIDE;

  173. 	virtual bool getMidiKeyName (VstInt32 channel, MidiKeyName* keyName) SMTG_OVERRIDE;

  174. 

  175. 	// finally process...

  176. 	virtual void processReplacing (float** inputs, float** outputs,

  177. 	                               VstInt32 sampleFrames) SMTG_OVERRIDE;

  178. 	virtual void processDoubleReplacing (double** inputs, double** outputs,

  179. 	                                     VstInt32 sampleFrames) SMTG_OVERRIDE;

  180. 	virtual VstInt32 processEvents (VstEvents* events) SMTG_OVERRIDE;

  181. 

  182. 	// VST 3 Interfaces  ------------------------------------------------------

  183. 	// FUnknown

  184. 	virtual tresult PLUGIN_API queryInterface (const char* iid, void** obj) SMTG_OVERRIDE;

  185. 	virtual uint32 PLUGIN_API addRef () SMTG_OVERRIDE { return 1; }

  186. 	virtual uint32 PLUGIN_API release () SMTG_OVERRIDE { return 1; }

  187. 

  188. 	// IHostApplication

  189. 	virtual tresult PLUGIN_API getName (String128 name) SMTG_OVERRIDE;

  190. 	virtual tresult PLUGIN_API createInstance (TUID cid, TUID iid, void** obj) SMTG_OVERRIDE;

  191. 

  192. 	// IComponentHandler

  193. 	virtual tresult PLUGIN_API beginEdit (ParamID tag) SMTG_OVERRIDE;

  194. 	virtual tresult PLUGIN_API performEdit (ParamID tag, ParamValue valueNormalized) SMTG_OVERRIDE;

  195. 	virtual tresult PLUGIN_API endEdit (ParamID tag) SMTG_OVERRIDE;

  196. 	virtual tresult PLUGIN_API restartComponent (int32 flags) SMTG_OVERRIDE;

  197. 

  198. 	// IUnitHandler

  199. 	virtual tresult PLUGIN_API notifyUnitSelection (UnitID unitId) SMTG_OVERRIDE;

  200. 	virtual tresult PLUGIN_API notifyProgramListChange (ProgramListID listId,

  201. 	                                                    int32 programIndex) SMTG_OVERRIDE;

  202. 

  203. 	void setVendorName (char* name);

  204. 	void setEffectName (char* name);

  205. 	void setEffectVersion (char* version);

  206. 	void setSubCategories (char* string);

  207. 

  208. 	// ITimer

  209. 	virtual void onTimer (Timer* timer) SMTG_OVERRIDE;

  210. 

  211. //-------------------------------------------------------------------------------------------------------

  212. protected:

  213. 	void setupBuses ();

  214. 	void setupParameters ();

  215. 	void initMidiCtrlerAssignment ();

  216. 	void getUnitPath (UnitID unitID, String& path);

  217. 

  218. 	int32 countMainBusChannels (BusDirection dir, uint64& mainBusBitset);

  219. 

  220. 	template <class T>

  221. 	void setProcessingBuffers (T** inputs, T** outputs);

  222. 	void setupProcessTimeInfo ();

  223. 	void doProcess (VstInt32 sampleFrames);

  224. 	void setEventPPQPositions ();

  225. 	void processOutputEvents ();

  226. 	void processMidiEvent (VstMidiEvent* midiEvent, int32 bus);

  227. 

  228. 	/**	Returns the last param change from guiTransfer queue. */

  229. 	bool getLastParamChange (ParamID id, ParamValue& value);

  230. 

  231. 	bool setupProcessing (int32 processModeOverwrite = -1);

  232. 	void addParameterChange (ParamID id, ParamValue value, int32 sampleOffset);

  233. 

  234. 	bool getProgramListAndUnit (int32 midiChannel, UnitID& unitId, ProgramListID& programListId);

  235. 	bool getProgramListInfoByProgramListID (ProgramListID programListId, ProgramListInfo& info);

  236. 	int32 lookupProgramCategory (int32 midiChannel, String128 instrumentAttribute);

  237. 	bool setupMidiProgram (int32 midiChannel, ProgramListID programListId,

  238. 	                       MidiProgramName& midiProgramName);

  239. 

  240. 	bool getPinProperties (BusDirection dir, VstInt32 pinIndex, VstPinProperties* properties);

  241. 	bool pinIndexToBusChannel (BusDirection dir, VstInt32 pinIndex, int32& busIndex,

  242. 	                           int32& busChannel);

  243. 	static VstInt32 vst3ToVst2SpeakerArr (SpeakerArrangement vst3Arr);

  244. 	static SpeakerArrangement vst2ToVst3SpeakerArr (VstInt32 vst2Arr);

  245. 	static VstInt32 vst3ToVst2Speaker (Speaker vst3Speaker);

  246. 	static void setupVst2Arrangement (VstSpeakerArrangement*& vst2arr,

  247. 	                                  Vst::SpeakerArrangement vst3Arrangement);

  248. 

  249. 	struct ProgramCategory

  250. 	{

  251. 		MidiProgramCategory vst2Category;

  252. 		String128 vst3InstrumentAttribute;

  253. 	};

  254. 	std::vector<std::vector<ProgramCategory>> mProgramCategories;

  255. 	void setupProgramCategories ();

  256. 	static uint32 makeCategoriesRecursive (std::vector<ProgramCategory>& channelCategories,

  257. 	                                       String128 vst3Category);

  258. 

  259. 	static const int32 kMaxProgramChangeParameters = 16;

  260. 	ParamID mProgramChangeParameterIDs[kMaxProgramChangeParameters]; // for each midi channel

  261. 	int32 mProgramChangeParameterIdxs[kMaxProgramChangeParameters]; // for each midi channel

  262. 

  263. 	VstSpeakerArrangement* mVst2InputArrangement;

  264. 	VstSpeakerArrangement* mVst2OutputArrangement;

  265. 

  266. 	FUID mVst3EffectClassID;

  267. 

  268. 	// vst3 data

  269. 	IAudioProcessor* mProcessor;

  270. 	IComponent* mComponent;

  271. 	IEditController* mController;

  272. 	IUnitInfo* mUnitInfo;

  273. 	IMidiMapping* mMidiMapping;

  274. 

  275. 	bool componentInitialized;

  276. 	bool controllerInitialized;

  277. 	bool componentsConnected;

  278. 	bool processing;

  279. 	bool hasEventInputBuses;

  280. 	bool hasEventOutputBuses;

  281. 

  282. 	int32 mVst3SampleSize;

  283. 	int32 mVst3processMode;

  284. 

  285. 	char mName[PClassInfo::kNameSize];

  286. 	char mVendor[PFactoryInfo::kNameSize];

  287. 	char mSubCategories[PClassInfo2::kSubCategoriesSize];

  288. 	int32 mVersion;

  289. 

  290. 	struct ParamMapEntry

  291. 	{

  292. 		ParamID vst3ID;

  293. 		int32 vst3Index;

  294. 	};

  295. 

  296. 	std::vector<ParamMapEntry> mParameterMap;

  297. 	std::map<ParamID, int32> mParamIndexMap;

  298. 	ParamID mBypassParameterID;

  299. 	ParamID mProgramParameterID;

  300. 	int32 mProgramParameterIdx;

  301. 

  302. 	HostProcessData mProcessData;

  303. 	ProcessContext mProcessContext;

  304. 	ParameterChanges mInputChanges;

  305. 	ParameterChanges mOutputChanges;

  306. 	EventList* mInputEvents;

  307. 	EventList* mOutputEvents;

  308. 	Vst2MidiEventQueue* mVst2OutputEvents;

  309. 	uint64 mMainAudioInputBuses;

  310. 	uint64 mMainAudioOutputBuses;

  311. 

  312. 	ParameterChangeTransfer mInputTransfer;

  313. 	ParameterChangeTransfer mOutputTransfer;

  314. 	ParameterChangeTransfer mGuiTransfer;

  315. 

  316. 	MemoryStream mChunk;

  317. 

  318. 	Timer* mTimer;

  319. 	IPluginFactory* mFactory;

  320. 

  321. 	enum

  322. 	{

  323. 		kMaxMidiMappingBusses = 4

  324. 	};

  325. 	int32* mMidiCCMapping[kMaxMidiMappingBusses][16];

  326. };

  327. 

  328. //------------------------------------------------------------------------

  329. } // namespace Vst

  330. } // namespace Steinberg

  331. 

  332. /** Must be implemented externally. */

  333. extern ::AudioEffect* createEffectInstance (audioMasterCallback audioMaster);

  334. 

  335. /// \endcond