DISTRHO
/
DISTRHO-Ports
mirror of https://github.com/DISTRHO/DISTRHO-Ports
1
0
Fork 0
Code Releases 5 Activity
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.
502 Commits
6 Branches
234MB
Tree: 381f58691e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '381f58691e'
${ noResults }
DISTRHO-Ports/libs/juce-current/patches/juce_vst_interface.patch

2992 lines
174KB
Raw Blame History 

  1. diff --git a/modules/juce_audio_plugin_client/VST/juce_VST_Wrapper.cpp b/modules/juce_audio_plugin_client/VST/juce_VST_Wrapper.cpp

  2. index 7f63093..5ff628b 100644

  3. --- a/modules/juce_audio_plugin_client/VST/juce_VST_Wrapper.cpp

  4. +++ b/modules/juce_audio_plugin_client/VST/juce_VST_Wrapper.cpp

  5. @@ -95,14 +95,7 @@

  6.  

  7.  namespace Vst2

  8.  {

  9. -// If the following files cannot be found then you are probably trying to build

  10. -// a VST2 plug-in or a VST2-compatible VST3 plug-in. To do this you must have a

  11. -// VST2 SDK in your header search paths or use the "VST (Legacy) SDK Folder"

  12. -// field in the Projucer. The VST2 SDK can be obtained from the

  13. -// vstsdk3610_11_06_2018_build_37 (or older) VST3 SDK or JUCE version 5.3.2. You

  14. -// also need a VST2 license from Steinberg to distribute VST2 plug-ins.

  15. -#include "pluginterfaces/vst2.x/aeffect.h"

  16. -#include "pluginterfaces/vst2.x/aeffectx.h"

  17. +#include "../../juce_audio_processors/format_types/juce_VSTInterface.h"

  18.  }

  19.  

  20.  JUCE_END_IGNORE_WARNINGS_MSVC

  21. @@ -124,7 +117,6 @@ using namespace juce;

  22.   #pragma pack (push, 8)

  23.  #endif

  24.  

  25. -#define JUCE_VSTINTERFACE_H_INCLUDED 1

  26.  #define JUCE_GUI_BASICS_INCLUDE_XHEADERS 1

  27.  

  28.  #include "../utility/juce_IncludeModuleHeaders.h"

  29. @@ -315,7 +307,7 @@ private:

  30.  

  31.  public:

  32.      //==============================================================================

  33. -    JuceVSTWrapper (Vst2::audioMasterCallback cb, AudioProcessor* af)

  34. +    JuceVSTWrapper (Vst2::VstHostCallback cb, AudioProcessor* af)

  35.         : hostCallback (cb),

  36.           processor (af)

  37.      {

  38. @@ -346,41 +338,41 @@ public:

  39.          juceParameters.update (*processor, false);

  40.  

  41.          memset (&vstEffect, 0, sizeof (vstEffect));

  42. -        vstEffect.magic = 0x56737450 /* 'VstP' */;

  43. -        vstEffect.dispatcher = (Vst2::AEffectDispatcherProc) dispatcherCB;

  44. -        vstEffect.process = nullptr;

  45. -        vstEffect.setParameter = (Vst2::AEffectSetParameterProc) setParameterCB;

  46. -        vstEffect.getParameter = (Vst2::AEffectGetParameterProc) getParameterCB;

  47. +        vstEffect.interfaceIdentifier = Vst2::juceVstInterfaceIdentifier;

  48. +        vstEffect.dispatchFunction = dispatcherCB;

  49. +        vstEffect.processAudioFunction = nullptr;

  50. +        vstEffect.setParameterValueFunction = setParameterCB;

  51. +        vstEffect.getParameterValueFunction = getParameterCB;

  52.          vstEffect.numPrograms = jmax (1, af->getNumPrograms());

  53. -        vstEffect.numParams = juceParameters.getNumParameters();

  54. -        vstEffect.numInputs = maxNumInChannels;

  55. -        vstEffect.numOutputs = maxNumOutChannels;

  56. -        vstEffect.initialDelay = processor->getLatencySamples();

  57. -        vstEffect.object = this;

  58. -        vstEffect.uniqueID = JucePlugin_VSTUniqueID;

  59. +        vstEffect.numParameters = juceParameters.getNumParameters();

  60. +        vstEffect.numInputChannels = maxNumInChannels;

  61. +        vstEffect.numOutputChannels = maxNumOutChannels;

  62. +        vstEffect.latency = processor->getLatencySamples();

  63. +        vstEffect.effectPointer = this;

  64. +        vstEffect.plugInIdentifier = JucePlugin_VSTUniqueID;

  65.  

  66.         #ifdef JucePlugin_VSTChunkStructureVersion

  67. -        vstEffect.version = JucePlugin_VSTChunkStructureVersion;

  68. +        vstEffect.plugInVersion = JucePlugin_VSTChunkStructureVersion;

  69.         #else

  70. -        vstEffect.version = JucePlugin_VersionCode;

  71. +        vstEffect.plugInVersion = JucePlugin_VersionCode;

  72.         #endif

  73.  

  74. -        vstEffect.processReplacing = (Vst2::AEffectProcessProc) processReplacingCB;

  75. -        vstEffect.processDoubleReplacing = (Vst2::AEffectProcessDoubleProc) processDoubleReplacingCB;

  76. +        vstEffect.processAudioInplaceFunction = processReplacingCB;

  77. +        vstEffect.processDoubleAudioInplaceFunction = processDoubleReplacingCB;

  78.  

  79. -        vstEffect.flags |= Vst2::effFlagsHasEditor;

  80. +        vstEffect.flags |= Vst2::vstEffectFlagHasEditor;

  81.  

  82. -        vstEffect.flags |= Vst2::effFlagsCanReplacing;

  83. +        vstEffect.flags |= Vst2::vstEffectFlagInplaceAudio;

  84.          if (processor->supportsDoublePrecisionProcessing())

  85. -            vstEffect.flags |= Vst2::effFlagsCanDoubleReplacing;

  86. +            vstEffect.flags |= Vst2::vstEffectFlagInplaceDoubleAudio;

  87.  

  88. -        vstEffect.flags |= Vst2::effFlagsProgramChunks;

  89. +        vstEffect.flags |= Vst2::vstEffectFlagDataInChunks;

  90.  

  91.         #if JucePlugin_IsSynth

  92. -        vstEffect.flags |= Vst2::effFlagsIsSynth;

  93. +        vstEffect.flags |= Vst2::vstEffectFlagIsSynth;

  94.         #else

  95.          if (processor->getTailLengthSeconds() == 0.0)

  96. -            vstEffect.flags |= Vst2::effFlagsNoSoundInStop;

  97. +            vstEffect.flags |= 512;

  98.         #endif

  99.  

  100.          activePlugins.add (this);

  101. @@ -424,7 +416,7 @@ public:

  102.          }

  103.      }

  104.  

  105. -    Vst2::AEffect* getAEffect() noexcept    { return &vstEffect; }

  106. +    Vst2::VstEffectInterface* getAEffect() noexcept    { return &vstEffect; }

  107.  

  108.      template <typename FloatType>

  109.      void internalProcessReplacing (FloatType** inputs, FloatType** outputs,

  110. @@ -563,7 +555,7 @@ public:

  111.  

  112.              // Send VST events to the host.

  113.              if (hostCallback != nullptr)

  114. -                hostCallback (&vstEffect, Vst2::audioMasterProcessEvents, 0, 0, outgoingEvents.events, 0);

  115. +                hostCallback (&vstEffect, Vst2::hostOpcodePreAudioProcessingEvents, 0, 0, outgoingEvents.events, 0);

  116.             #elif JUCE_DEBUG

  117.              /*  This assertion is caused when you've added some events to the

  118.                  midiMessages array in your processBlock() method, which usually means

  119. @@ -592,7 +584,7 @@ public:

  120.          internalProcessReplacing (inputs, outputs, sampleFrames, floatTempBuffers);

  121.      }

  122.  

  123. -    static void processReplacingCB (Vst2::AEffect* vstInterface, float** inputs, float** outputs, int32 sampleFrames)

  124. +    static void processReplacingCB (Vst2::VstEffectInterface* vstInterface, float** inputs, float** outputs, int32 sampleFrames)

  125.      {

  126.          getWrapper (vstInterface)->processReplacing (inputs, outputs, sampleFrames);

  127.      }

  128. @@ -603,7 +595,7 @@ public:

  129.          internalProcessReplacing (inputs, outputs, sampleFrames, doubleTempBuffers);

  130.      }

  131.  

  132. -    static void processDoubleReplacingCB (Vst2::AEffect* vstInterface, double** inputs, double** outputs, int32 sampleFrames)

  133. +    static void processDoubleReplacingCB (Vst2::VstEffectInterface* vstInterface, double** inputs, double** outputs, int32 sampleFrames)

  134.      {

  135.          getWrapper (vstInterface)->processDoubleReplacing (inputs, outputs, sampleFrames);

  136.      }

  137. @@ -615,7 +607,7 @@ public:

  138.          {

  139.              isProcessing = true;

  140.  

  141. -            auto numInAndOutChannels = static_cast<size_t> (vstEffect.numInputs + vstEffect.numOutputs);

  142. +            auto numInAndOutChannels = static_cast<size_t> (vstEffect.numInputChannels + vstEffect.numOutputChannels);

  143.              floatTempBuffers .channels.calloc (numInAndOutChannels);

  144.              doubleTempBuffers.channels.calloc (numInAndOutChannels);

  145.  

  146. @@ -634,16 +626,16 @@ public:

  147.              midiEvents.ensureSize (2048);

  148.              midiEvents.clear();

  149.  

  150. -            vstEffect.initialDelay = processor->getLatencySamples();

  151. +            vstEffect.latency = processor->getLatencySamples();

  152.  

  153.              /** If this plug-in is a synth or it can receive midi events we need to tell the

  154.                  host that we want midi. In the SDK this method is marked as deprecated, but

  155.                  some hosts rely on this behaviour.

  156.              */

  157. -            if (vstEffect.flags & Vst2::effFlagsIsSynth || JucePlugin_WantsMidiInput || JucePlugin_IsMidiEffect)

  158. +            if (vstEffect.flags & Vst2::vstEffectFlagIsSynth || JucePlugin_WantsMidiInput || JucePlugin_IsMidiEffect)

  159.              {

  160.                  if (hostCallback != nullptr)

  161. -                    hostCallback (&vstEffect, Vst2::audioMasterWantMidi, 0, 1, nullptr, 0);

  162. +                    hostCallback (&vstEffect, Vst2::hostOpcodePlugInWantsMidi, 0, 1, nullptr, 0);

  163.              }

  164.  

  165.              if (getHostType().isAbletonLive()

  166. @@ -657,7 +649,7 @@ public:

  167.                  hostCmd.commandSize = sizeof (int);

  168.                  hostCmd.flags = AbletonLiveHostSpecific::KCantBeSuspended;

  169.  

  170. -                hostCallback (&vstEffect, Vst2::audioMasterVendorSpecific, 0, 0, &hostCmd, 0.0f);

  171. +                hostCallback (&vstEffect, Vst2::hostOpcodeManufacturerSpecific, 0, 0, &hostCmd, 0.0f);

  172.              }

  173.  

  174.             #if JucePlugin_ProducesMidiOutput || JucePlugin_IsMidiEffect

  175. @@ -684,28 +676,28 @@ public:

  176.      //==============================================================================

  177.      bool getCurrentPosition (AudioPlayHead::CurrentPositionInfo& info) override

  178.      {

  179. -        const Vst2::VstTimeInfo* ti = nullptr;

  180. +        const Vst2::VstTimingInformation* ti = nullptr;

  181.  

  182.          if (hostCallback != nullptr)

  183.          {

  184. -            int32 flags = Vst2::kVstPpqPosValid  | Vst2::kVstTempoValid

  185. -                        | Vst2::kVstBarsValid    | Vst2::kVstCyclePosValid

  186. -                        | Vst2::kVstTimeSigValid | Vst2::kVstSmpteValid

  187. -                        | Vst2::kVstClockValid;

  188. +            int32 flags = Vst2::vstTimingInfoFlagMusicalPositionValid | Vst2::vstTimingInfoFlagTempoValid

  189. +                              | Vst2::vstTimingInfoFlagLastBarPositionValid | Vst2::vstTimingInfoFlagLoopPositionValid

  190. +                              | Vst2::vstTimingInfoFlagTimeSignatureValid | Vst2::vstTimingInfoFlagSmpteValid

  191. +                              | Vst2::vstTimingInfoFlagNearestClockValid;

  192.  

  193. -            auto result = hostCallback (&vstEffect, Vst2::audioMasterGetTime, 0, flags, nullptr, 0);

  194. -            ti = reinterpret_cast<Vst2::VstTimeInfo*> (result);

  195. +            auto result = hostCallback (&vstEffect, Vst2::hostOpcodeGetTimingInfo, 0, flags, nullptr, 0);

  196. +            ti = reinterpret_cast<Vst2::VstTimingInformation*> (result);

  197.          }

  198.  

  199.          if (ti == nullptr || ti->sampleRate <= 0)

  200.              return false;

  201.  

  202. -        info.bpm = (ti->flags & Vst2::kVstTempoValid) != 0 ? ti->tempo : 0.0;

  203. +        info.bpm = (ti->flags & Vst2::vstTimingInfoFlagTempoValid) != 0 ? ti->tempoBPM : 0.0;

  204.  

  205. -        if ((ti->flags & Vst2::kVstTimeSigValid) != 0)

  206. +        if ((ti->flags & Vst2::vstTimingInfoFlagTimeSignatureValid) != 0)

  207.          {

  208. -            info.timeSigNumerator   = ti->timeSigNumerator;

  209. -            info.timeSigDenominator = ti->timeSigDenominator;

  210. +            info.timeSigNumerator   = ti->timeSignatureNumerator;

  211. +            info.timeSigDenominator = ti->timeSignatureDenominator;

  212.          }

  213.          else

  214.          {

  215. @@ -713,34 +705,34 @@ public:

  216.              info.timeSigDenominator = 4;

  217.          }

  218.  

  219. -        info.timeInSamples = (int64) (ti->samplePos + 0.5);

  220. -        info.timeInSeconds = ti->samplePos / ti->sampleRate;

  221. -        info.ppqPosition = (ti->flags & Vst2::kVstPpqPosValid) != 0 ? ti->ppqPos : 0.0;

  222. -        info.ppqPositionOfLastBarStart = (ti->flags & Vst2::kVstBarsValid) != 0 ? ti->barStartPos : 0.0;

  223. +        info.timeInSamples = (int64) (ti->samplePosition + 0.5);

  224. +        info.timeInSeconds = ti->samplePosition / ti->sampleRate;

  225. +        info.ppqPosition = (ti->flags & Vst2::vstTimingInfoFlagMusicalPositionValid) != 0 ? ti->musicalPosition : 0.0;

  226. +        info.ppqPositionOfLastBarStart = (ti->flags & Vst2::vstTimingInfoFlagLastBarPositionValid) != 0 ? ti->lastBarPosition : 0.0;

  227.  

  228. -        if ((ti->flags & Vst2::kVstSmpteValid) != 0)

  229. +        if ((ti->flags & Vst2::vstTimingInfoFlagSmpteValid) != 0)

  230.          {

  231.              AudioPlayHead::FrameRateType rate = AudioPlayHead::fpsUnknown;

  232.              double fps = 1.0;

  233.  

  234. -            switch (ti->smpteFrameRate)

  235. +            switch (ti->smpteRate)

  236.              {

  237. -                case Vst2::kVstSmpte239fps:       rate = AudioPlayHead::fps23976;    fps = 24.0 * 1000.0 / 1001.0; break;

  238. -                case Vst2::kVstSmpte24fps:        rate = AudioPlayHead::fps24;       fps = 24.0;  break;

  239. -                case Vst2::kVstSmpte25fps:        rate = AudioPlayHead::fps25;       fps = 25.0;  break;

  240. -                case Vst2::kVstSmpte2997fps:      rate = AudioPlayHead::fps2997;     fps = 30.0 * 1000.0 / 1001.0; break;

  241. -                case Vst2::kVstSmpte30fps:        rate = AudioPlayHead::fps30;       fps = 30.0;  break;

  242. -                case Vst2::kVstSmpte2997dfps:     rate = AudioPlayHead::fps2997drop; fps = 30.0 * 1000.0 / 1001.0; break;

  243. -                case Vst2::kVstSmpte30dfps:       rate = AudioPlayHead::fps30drop;   fps = 30.0;  break;

  244. -

  245. -                case Vst2::kVstSmpteFilm16mm:

  246. -                case Vst2::kVstSmpteFilm35mm:     fps = 24.0; break;

  247. -

  248. -                case Vst2::kVstSmpte249fps:       fps = 25.0 * 1000.0 / 1001.0; break;

  249. -                case Vst2::kVstSmpte599fps:       fps = 60.0 * 1000.0 / 1001.0; break;

  250. -                case Vst2::kVstSmpte60fps:        fps = 60; break;

  251. -

  252. -                default:                          jassertfalse; // unknown frame-rate..

  253. +                case Vst2::vstSmpteRateFps239:       rate = AudioPlayHead::fps23976;    fps = 24.0 * 1000.0 / 1001.0; break;

  254. +                case Vst2::vstSmpteRateFps24:        rate = AudioPlayHead::fps24;       fps = 24.0;  break;

  255. +                case Vst2::vstSmpteRateFps25:        rate = AudioPlayHead::fps25;       fps = 25.0;  break;

  256. +                case Vst2::vstSmpteRateFps2997:      rate = AudioPlayHead::fps2997;     fps = 30.0 * 1000.0 / 1001.0; break;

  257. +                case Vst2::vstSmpteRateFps30:        rate = AudioPlayHead::fps30;       fps = 30.0;  break;

  258. +                case Vst2::vstSmpteRateFps2997drop:  rate = AudioPlayHead::fps2997drop; fps = 30.0 * 1000.0 / 1001.0; break;

  259. +                case Vst2::vstSmpteRateFps30drop:    rate = AudioPlayHead::fps30drop;   fps = 30.0;  break;

  260. +

  261. +                case Vst2::vstSmpteRate16mmFilm:

  262. +                case Vst2::vstSmpteRate35mmFilm:     fps = 24.0; break;

  263. +

  264. +                case Vst2::vstSmpteRateFps249:       fps = 25.0 * 1000.0 / 1001.0; break;

  265. +                case Vst2::vstSmpteRateFps599:       fps = 60.0 * 1000.0 / 1001.0; break;

  266. +                case Vst2::vstSmpteRateFps60:        fps = 60; break;

  267. +

  268. +                default:                       jassertfalse; // unknown frame-rate..

  269.              }

  270.  

  271.              info.frameRate = rate;

  272. @@ -752,14 +744,14 @@ public:

  273.              info.editOriginTime = 0;

  274.          }

  275.  

  276. -        info.isRecording = (ti->flags & Vst2::kVstTransportRecording) != 0;

  277. -        info.isPlaying   = (ti->flags & (Vst2::kVstTransportRecording | Vst2::kVstTransportPlaying)) != 0;

  278. -        info.isLooping   = (ti->flags & Vst2::kVstTransportCycleActive) != 0;

  279. +        info.isRecording = (ti->flags & Vst2::vstTimingInfoFlagCurrentlyRecording) != 0;

  280. +        info.isPlaying   = (ti->flags & (Vst2::vstTimingInfoFlagCurrentlyRecording | Vst2::vstTimingInfoFlagCurrentlyPlaying)) != 0;

  281. +        info.isLooping   = (ti->flags & Vst2::vstTimingInfoFlagLoopActive) != 0;

  282.  

  283. -        if ((ti->flags & Vst2::kVstCyclePosValid) != 0)

  284. +        if ((ti->flags & Vst2::vstTimingInfoFlagLoopPositionValid) != 0)

  285.          {

  286. -            info.ppqLoopStart = ti->cycleStartPos;

  287. -            info.ppqLoopEnd   = ti->cycleEndPos;

  288. +            info.ppqLoopStart = ti->loopStartPosition;

  289. +            info.ppqLoopEnd   = ti->loopEndPosition;

  290.          }

  291.          else

  292.          {

  293. @@ -779,7 +771,7 @@ public:

  294.          return 0.0f;

  295.      }

  296.  

  297. -    static float getParameterCB (Vst2::AEffect* vstInterface, int32 index)

  298. +    static float getParameterCB (Vst2::VstEffectInterface* vstInterface, int32 index)

  299.      {

  300.          return getWrapper (vstInterface)->getParameter (index);

  301.      }

  302. @@ -795,7 +787,7 @@ public:

  303.          }

  304.      }

  305.  

  306. -    static void setParameterCB (Vst2::AEffect* vstInterface, int32 index, float value)

  307. +    static void setParameterCB (Vst2::VstEffectInterface* vstInterface, int32 index, float value)

  308.      {

  309.          getWrapper (vstInterface)->setParameter (index, value);

  310.      }

  311. @@ -809,19 +801,19 @@ public:

  312.          }

  313.  

  314.          if (hostCallback != nullptr)

  315. -            hostCallback (&vstEffect, Vst2::audioMasterAutomate, index, 0, nullptr, newValue);

  316. +            hostCallback (&vstEffect, Vst2::hostOpcodeParameterChanged, index, 0, nullptr, newValue);

  317.      }

  318.  

  319.      void audioProcessorParameterChangeGestureBegin (AudioProcessor*, int index) override

  320.      {

  321.          if (hostCallback != nullptr)

  322. -            hostCallback (&vstEffect, Vst2::audioMasterBeginEdit, index, 0, nullptr, 0);

  323. +            hostCallback (&vstEffect, Vst2::hostOpcodeParameterChangeGestureBegin, index, 0, nullptr, 0);

  324.      }

  325.  

  326.      void audioProcessorParameterChangeGestureEnd (AudioProcessor*, int index) override

  327.      {

  328.          if (hostCallback != nullptr)

  329. -            hostCallback (&vstEffect, Vst2::audioMasterEndEdit, index, 0, nullptr, 0);

  330. +            hostCallback (&vstEffect, Vst2::hostOpcodeParameterChangeGestureEnd, index, 0, nullptr, 0);

  331.      }

  332.  

  333.      void parameterValueChanged (int, float newValue) override

  334. @@ -834,7 +826,7 @@ public:

  335.  

  336.      void audioProcessorChanged (AudioProcessor*) override

  337.      {

  338. -        vstEffect.initialDelay = processor->getLatencySamples();

  339. +        vstEffect.latency = processor->getLatencySamples();

  340.          triggerAsyncUpdate();

  341.      }

  342.  

  343. @@ -842,12 +834,12 @@ public:

  344.      {

  345.          if (hostCallback != nullptr)

  346.          {

  347. -            hostCallback (&vstEffect, Vst2::audioMasterUpdateDisplay, 0, 0, nullptr, 0);

  348. -            hostCallback (&vstEffect, Vst2::audioMasterIOChanged,     0, 0, nullptr, 0);

  349. +            hostCallback (&vstEffect, Vst2::hostOpcodeUpdateView, 0, 0, nullptr, 0);

  350. +            hostCallback (&vstEffect, Vst2::hostOpcodeIOModified,     0, 0, nullptr, 0);

  351.          }

  352.      }

  353.  

  354. -    bool getPinProperties (Vst2::VstPinProperties& properties, bool direction, int index) const

  355. +    bool getPinProperties (Vst2::VstPinInfo& properties, bool direction, int index) const

  356.      {

  357.          if (processor->isMidiEffect())

  358.              return false;

  359. @@ -856,9 +848,9 @@ public:

  360.  

  361.          // fill with default

  362.          properties.flags = 0;

  363. -        properties.label[0] = 0;

  364. -        properties.shortLabel[0] = 0;

  365. -        properties.arrangementType = Vst2::kSpeakerArrEmpty;

  366. +        properties.text[0] = 0;

  367. +        properties.shortText[0] = 0;

  368. +        properties.configurationType = Vst2::vstSpeakerConfigTypeEmpty;

  369.  

  370.          if ((channelIdx = processor->getOffsetInBusBufferForAbsoluteChannelIndex (direction, index, busIdx)) >= 0)

  371.          {

  372. @@ -866,8 +858,8 @@ public:

  373.              auto& channelSet = bus.getCurrentLayout();

  374.              auto channelType = channelSet.getTypeOfChannel (channelIdx);

  375.  

  376. -            properties.flags = Vst2::kVstPinIsActive | Vst2::kVstPinUseSpeaker;

  377. -            properties.arrangementType = SpeakerMappings::channelSetToVstArrangementType (channelSet);

  378. +            properties.flags = Vst2::vstPinInfoFlagIsActive | Vst2::vstPinInfoFlagValid;

  379. +            properties.configurationType = SpeakerMappings::channelSetToVstArrangementType (channelSet);

  380.              String label = bus.getName();

  381.  

  382.             #ifdef JucePlugin_PreferredChannelConfigurations

  383. @@ -877,8 +869,8 @@ public:

  384.                  label += " " + AudioChannelSet::getAbbreviatedChannelTypeName (channelType);

  385.             #endif

  386.  

  387. -            label.copyToUTF8 (properties.label, (size_t) (Vst2::kVstMaxLabelLen + 1));

  388. -            label.copyToUTF8 (properties.shortLabel, (size_t) (Vst2::kVstMaxShortLabelLen + 1));

  389. +            label.copyToUTF8 (properties.text, (size_t) (Vst2::vstMaxParameterOrPinLabelLength + 1));

  390. +            label.copyToUTF8 (properties.shortText, (size_t) (Vst2::vstMaxParameterOrPinShortLabelLength + 1));

  391.  

  392.              if (channelType == AudioChannelSet::left

  393.                  || channelType == AudioChannelSet::leftSurround

  394. @@ -888,7 +880,7 @@ public:

  395.                  || channelType == AudioChannelSet::topRearLeft

  396.                  || channelType == AudioChannelSet::leftSurroundRear

  397.                  || channelType == AudioChannelSet::wideLeft)

  398. -                properties.flags |= Vst2::kVstPinIsStereo;

  399. +                properties.flags |= Vst2::vstPinInfoFlagIsStereo;

  400.  

  401.              return true;

  402.          }

  403. @@ -921,27 +913,27 @@ public:

  404.              }

  405.          };

  406.  

  407. -        static AudioChannelSet vstArrangementTypeToChannelSet (const Vst2::VstSpeakerArrangement& arr)

  408. -        {

  409. -            if (arr.type == Vst2::kSpeakerArrEmpty)      return AudioChannelSet::disabled();

  410. -            if (arr.type == Vst2::kSpeakerArrMono)       return AudioChannelSet::mono();

  411. -            if (arr.type == Vst2::kSpeakerArrStereo)     return AudioChannelSet::stereo();

  412. -            if (arr.type == Vst2::kSpeakerArr30Cine)     return AudioChannelSet::createLCR();

  413. -            if (arr.type == Vst2::kSpeakerArr30Music)    return AudioChannelSet::createLRS();

  414. -            if (arr.type == Vst2::kSpeakerArr40Cine)     return AudioChannelSet::createLCRS();

  415. -            if (arr.type == Vst2::kSpeakerArr50)         return AudioChannelSet::create5point0();

  416. -            if (arr.type == Vst2::kSpeakerArr51)         return AudioChannelSet::create5point1();

  417. -            if (arr.type == Vst2::kSpeakerArr60Cine)     return AudioChannelSet::create6point0();

  418. -            if (arr.type == Vst2::kSpeakerArr61Cine)     return AudioChannelSet::create6point1();

  419. -            if (arr.type == Vst2::kSpeakerArr60Music)    return AudioChannelSet::create6point0Music();

  420. -            if (arr.type == Vst2::kSpeakerArr61Music)    return AudioChannelSet::create6point1Music();

  421. -            if (arr.type == Vst2::kSpeakerArr70Music)    return AudioChannelSet::create7point0();

  422. -            if (arr.type == Vst2::kSpeakerArr70Cine)     return AudioChannelSet::create7point0SDDS();

  423. -            if (arr.type == Vst2::kSpeakerArr71Music)    return AudioChannelSet::create7point1();

  424. -            if (arr.type == Vst2::kSpeakerArr71Cine)     return AudioChannelSet::create7point1SDDS();

  425. -            if (arr.type == Vst2::kSpeakerArr40Music)    return AudioChannelSet::quadraphonic();

  426. -

  427. -            for (auto* m = getMappings(); m->vst2 != Vst2::kSpeakerArrEmpty; ++m)

  428. +        static AudioChannelSet vstArrangementTypeToChannelSet (const Vst2::VstSpeakerConfiguration& arr)

  429. +        {

  430. +            if (arr.type == Vst2::vstSpeakerConfigTypeEmpty)          return AudioChannelSet::disabled();

  431. +            if (arr.type == Vst2::vstSpeakerConfigTypeMono)           return AudioChannelSet::mono();

  432. +            if (arr.type == Vst2::vstSpeakerConfigTypeLR)             return AudioChannelSet::stereo();

  433. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRC)            return AudioChannelSet::createLCR();

  434. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRS)            return AudioChannelSet::createLRS();

  435. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRCS)           return AudioChannelSet::createLCRS();

  436. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRCLsRs)        return AudioChannelSet::create5point0();

  437. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRCLfeLsRs)     return AudioChannelSet::create5point1();

  438. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRCLsRsCs)      return AudioChannelSet::create6point0();

  439. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRCLfeLsRsCs)   return AudioChannelSet::create6point1();

  440. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRLsRsSlSr)     return AudioChannelSet::create6point0Music();

  441. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRLfeLsRsSlSr)  return AudioChannelSet::create6point1Music();

  442. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRCLsRsSlSr)    return AudioChannelSet::create7point0();

  443. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRCLsRsLcRc)    return AudioChannelSet::create7point0SDDS();

  444. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRCLfeLsRsSlSr) return AudioChannelSet::create7point1();

  445. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRCLfeLsRsLcRc) return AudioChannelSet::create7point1SDDS();

  446. +            if (arr.type == Vst2::vstSpeakerConfigTypeLRLsRs)         return AudioChannelSet::quadraphonic();

  447. +

  448. +            for (auto* m = getMappings(); m->vst2 != Vst2::vstSpeakerConfigTypeEmpty; ++m)

  449.              {

  450.                  if (m->vst2 == arr.type)

  451.                  {

  452. @@ -954,51 +946,51 @@ public:

  453.                  }

  454.              }

  455.  

  456. -            return AudioChannelSet::discreteChannels (arr.numChannels);

  457. +            return AudioChannelSet::discreteChannels (arr.numberOfChannels);

  458.          }

  459.  

  460.          static int32 channelSetToVstArrangementType (AudioChannelSet channels)

  461.          {

  462. -            if (channels == AudioChannelSet::disabled())           return Vst2::kSpeakerArrEmpty;

  463. -            if (channels == AudioChannelSet::mono())               return Vst2::kSpeakerArrMono;

  464. -            if (channels == AudioChannelSet::stereo())             return Vst2::kSpeakerArrStereo;

  465. -            if (channels == AudioChannelSet::createLCR())          return Vst2::kSpeakerArr30Cine;

  466. -            if (channels == AudioChannelSet::createLRS())          return Vst2::kSpeakerArr30Music;

  467. -            if (channels == AudioChannelSet::createLCRS())         return Vst2::kSpeakerArr40Cine;

  468. -            if (channels == AudioChannelSet::create5point0())      return Vst2::kSpeakerArr50;

  469. -            if (channels == AudioChannelSet::create5point1())      return Vst2::kSpeakerArr51;

  470. -            if (channels == AudioChannelSet::create6point0())      return Vst2::kSpeakerArr60Cine;

  471. -            if (channels == AudioChannelSet::create6point1())      return Vst2::kSpeakerArr61Cine;

  472. -            if (channels == AudioChannelSet::create6point0Music()) return Vst2::kSpeakerArr60Music;

  473. -            if (channels == AudioChannelSet::create6point1Music()) return Vst2::kSpeakerArr61Music;

  474. -            if (channels == AudioChannelSet::create7point0())      return Vst2::kSpeakerArr70Music;

  475. -            if (channels == AudioChannelSet::create7point0SDDS())  return Vst2::kSpeakerArr70Cine;

  476. -            if (channels == AudioChannelSet::create7point1())      return Vst2::kSpeakerArr71Music;

  477. -            if (channels == AudioChannelSet::create7point1SDDS())  return Vst2::kSpeakerArr71Cine;

  478. -            if (channels == AudioChannelSet::quadraphonic())       return Vst2::kSpeakerArr40Music;

  479. +            if (channels == AudioChannelSet::disabled())           return Vst2::vstSpeakerConfigTypeEmpty;

  480. +            if (channels == AudioChannelSet::mono())               return Vst2::vstSpeakerConfigTypeMono;

  481. +            if (channels == AudioChannelSet::stereo())             return Vst2::vstSpeakerConfigTypeLR;

  482. +            if (channels == AudioChannelSet::createLCR())          return Vst2::vstSpeakerConfigTypeLRC;

  483. +            if (channels == AudioChannelSet::createLRS())          return Vst2::vstSpeakerConfigTypeLRS;

  484. +            if (channels == AudioChannelSet::createLCRS())         return Vst2::vstSpeakerConfigTypeLRCS;

  485. +            if (channels == AudioChannelSet::create5point0())      return Vst2::vstSpeakerConfigTypeLRCLsRs;

  486. +            if (channels == AudioChannelSet::create5point1())      return Vst2::vstSpeakerConfigTypeLRCLfeLsRs;

  487. +            if (channels == AudioChannelSet::create6point0())      return Vst2::vstSpeakerConfigTypeLRCLsRsCs;

  488. +            if (channels == AudioChannelSet::create6point1())      return Vst2::vstSpeakerConfigTypeLRCLfeLsRsCs;

  489. +            if (channels == AudioChannelSet::create6point0Music()) return Vst2::vstSpeakerConfigTypeLRLsRsSlSr;

  490. +            if (channels == AudioChannelSet::create6point1Music()) return Vst2::vstSpeakerConfigTypeLRLfeLsRsSlSr;

  491. +            if (channels == AudioChannelSet::create7point0())      return Vst2::vstSpeakerConfigTypeLRCLsRsSlSr;

  492. +            if (channels == AudioChannelSet::create7point0SDDS())  return Vst2::vstSpeakerConfigTypeLRCLsRsLcRc;

  493. +            if (channels == AudioChannelSet::create7point1())      return Vst2::vstSpeakerConfigTypeLRCLfeLsRsSlSr;

  494. +            if (channels == AudioChannelSet::create7point1SDDS())  return Vst2::vstSpeakerConfigTypeLRCLfeLsRsLcRc;

  495. +            if (channels == AudioChannelSet::quadraphonic())       return Vst2::vstSpeakerConfigTypeLRLsRs;

  496.  

  497.              if (channels == AudioChannelSet::disabled())

  498. -                return Vst2::kSpeakerArrEmpty;

  499. +                return Vst2::vstSpeakerConfigTypeEmpty;

  500.  

  501.              auto chans = channels.getChannelTypes();

  502.  

  503. -            for (auto* m = getMappings(); m->vst2 != Vst2::kSpeakerArrEmpty; ++m)

  504. +            for (auto* m = getMappings(); m->vst2 != Vst2::vstSpeakerConfigTypeEmpty; ++m)

  505.                  if (m->matches (chans))

  506.                      return m->vst2;

  507.  

  508. -            return Vst2::kSpeakerArrUserDefined;

  509. +            return Vst2::vstSpeakerConfigTypeUser;

  510.          }

  511.  

  512. -        static void channelSetToVstArrangement (const AudioChannelSet& channels, Vst2::VstSpeakerArrangement& result)

  513. +        static void channelSetToVstArrangement (const AudioChannelSet& channels, Vst2::VstSpeakerConfiguration& result)

  514.          {

  515.              result.type = channelSetToVstArrangementType (channels);

  516. -            result.numChannels = channels.size();

  517. +            result.numberOfChannels = channels.size();

  518.  

  519. -            for (int i = 0; i < result.numChannels; ++i)

  520. +            for (int i = 0; i < result.numberOfChannels; ++i)

  521.              {

  522.                  auto& speaker = result.speakers[i];

  523.  

  524. -                zeromem (&speaker, sizeof (Vst2::VstSpeakerProperties));

  525. +                zeromem (&speaker, sizeof (Vst2::VstIndividualSpeakerInfo));

  526.                  speaker.type = getSpeakerType (channels.getTypeOfChannel (i));

  527.              }

  528.          }

  529. @@ -1007,36 +999,36 @@ public:

  530.          {

  531.              static const Mapping mappings[] =

  532.              {

  533. -                { Vst2::kSpeakerArrMono,           { centre, unknown } },

  534. -                { Vst2::kSpeakerArrStereo,         { left, right, unknown } },

  535. -                { Vst2::kSpeakerArrStereoSurround, { leftSurround, rightSurround, unknown } },

  536. -                { Vst2::kSpeakerArrStereoCenter,   { leftCentre, rightCentre, unknown } },

  537. -                { Vst2::kSpeakerArrStereoSide,     { leftSurroundRear, rightSurroundRear, unknown } },

  538. -                { Vst2::kSpeakerArrStereoCLfe,     { centre, LFE, unknown } },

  539. -                { Vst2::kSpeakerArr30Cine,         { left, right, centre, unknown } },

  540. -                { Vst2::kSpeakerArr30Music,        { left, right, surround, unknown } },

  541. -                { Vst2::kSpeakerArr31Cine,         { left, right, centre, LFE, unknown } },

  542. -                { Vst2::kSpeakerArr31Music,        { left, right, LFE, surround, unknown } },

  543. -                { Vst2::kSpeakerArr40Cine,         { left, right, centre, surround, unknown } },

  544. -                { Vst2::kSpeakerArr40Music,        { left, right, leftSurround, rightSurround, unknown } },

  545. -                { Vst2::kSpeakerArr41Cine,         { left, right, centre, LFE, surround, unknown } },

  546. -                { Vst2::kSpeakerArr41Music,        { left, right, LFE, leftSurround, rightSurround, unknown } },

  547. -                { Vst2::kSpeakerArr50,             { left, right, centre, leftSurround, rightSurround, unknown } },

  548. -                { Vst2::kSpeakerArr51,             { left, right, centre, LFE, leftSurround, rightSurround, unknown } },

  549. -                { Vst2::kSpeakerArr60Cine,         { left, right, centre, leftSurround, rightSurround, surround, unknown } },

  550. -                { Vst2::kSpeakerArr60Music,        { left, right, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  551. -                { Vst2::kSpeakerArr61Cine,         { left, right, centre, LFE, leftSurround, rightSurround, surround, unknown } },

  552. -                { Vst2::kSpeakerArr61Music,        { left, right, LFE, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  553. -                { Vst2::kSpeakerArr70Cine,         { left, right, centre, leftSurround, rightSurround, topFrontLeft, topFrontRight, unknown } },

  554. -                { Vst2::kSpeakerArr70Music,        { left, right, centre, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  555. -                { Vst2::kSpeakerArr71Cine,         { left, right, centre, LFE, leftSurround, rightSurround, topFrontLeft, topFrontRight, unknown } },

  556. -                { Vst2::kSpeakerArr71Music,        { left, right, centre, LFE, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  557. -                { Vst2::kSpeakerArr80Cine,         { left, right, centre, leftSurround, rightSurround, topFrontLeft, topFrontRight, surround, unknown } },

  558. -                { Vst2::kSpeakerArr80Music,        { left, right, centre, leftSurround, rightSurround, surround, leftSurroundRear, rightSurroundRear, unknown } },

  559. -                { Vst2::kSpeakerArr81Cine,         { left, right, centre, LFE, leftSurround, rightSurround, topFrontLeft, topFrontRight, surround, unknown } },

  560. -                { Vst2::kSpeakerArr81Music,        { left, right, centre, LFE, leftSurround, rightSurround, surround, leftSurroundRear, rightSurroundRear, unknown } },

  561. -                { Vst2::kSpeakerArr102, { left, right, centre, LFE, leftSurround, rightSurround, topFrontLeft, topFrontCentre, topFrontRight, topRearLeft, topRearRight, LFE2, unknown } },

  562. -                { Vst2::kSpeakerArrEmpty,          { unknown } }

  563. +                { Vst2::vstSpeakerConfigTypeMono,                          { centre, unknown } },

  564. +                { Vst2::vstSpeakerConfigTypeLR,                            { left, right, unknown } },

  565. +                { Vst2::vstSpeakerConfigTypeLsRs,                          { leftSurround, rightSurround, unknown } },

  566. +                { Vst2::vstSpeakerConfigTypeLcRc,                          { leftCentre, rightCentre, unknown } },

  567. +                { Vst2::vstSpeakerConfigTypeSlSr,                          { leftSurroundRear, rightSurroundRear, unknown } },

  568. +                { Vst2::vstSpeakerConfigTypeCLfe,                          { centre, LFE, unknown } },

  569. +                { Vst2::vstSpeakerConfigTypeLRC,                           { left, right, centre, unknown } },

  570. +                { Vst2::vstSpeakerConfigTypeLRS,                           { left, right, surround, unknown } },

  571. +                { Vst2::vstSpeakerConfigTypeLRCLfe,                        { left, right, centre, LFE, unknown } },

  572. +                { Vst2::vstSpeakerConfigTypeLRLfeS,                        { left, right, LFE, surround, unknown } },

  573. +                { Vst2::vstSpeakerConfigTypeLRCS,                          { left, right, centre, surround, unknown } },

  574. +                { Vst2::vstSpeakerConfigTypeLRLsRs,                        { left, right, leftSurround, rightSurround, unknown } },

  575. +                { Vst2::vstSpeakerConfigTypeLRCLfeS,                       { left, right, centre, LFE, surround, unknown } },

  576. +                { Vst2::vstSpeakerConfigTypeLRLfeLsRs,                     { left, right, LFE, leftSurround, rightSurround, unknown } },

  577. +                { Vst2::vstSpeakerConfigTypeLRCLsRs,                       { left, right, centre, leftSurround, rightSurround, unknown } },

  578. +                { Vst2::vstSpeakerConfigTypeLRCLfeLsRs,                    { left, right, centre, LFE, leftSurround, rightSurround, unknown } },

  579. +                { Vst2::vstSpeakerConfigTypeLRCLsRsCs,                     { left, right, centre, leftSurround, rightSurround, surround, unknown } },

  580. +                { Vst2::vstSpeakerConfigTypeLRLsRsSlSr,                    { left, right, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  581. +                { Vst2::vstSpeakerConfigTypeLRCLfeLsRsCs,                  { left, right, centre, LFE, leftSurround, rightSurround, surround, unknown } },

  582. +                { Vst2::vstSpeakerConfigTypeLRLfeLsRsSlSr,                 { left, right, LFE, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  583. +                { Vst2::vstSpeakerConfigTypeLRCLsRsLcRc,                   { left, right, centre, leftSurround, rightSurround, topFrontLeft, topFrontRight, unknown } },

  584. +                { Vst2::vstSpeakerConfigTypeLRCLsRsSlSr,                   { left, right, centre, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  585. +                { Vst2::vstSpeakerConfigTypeLRCLfeLsRsLcRc,                { left, right, centre, LFE, leftSurround, rightSurround, topFrontLeft, topFrontRight, unknown } },

  586. +                { Vst2::vstSpeakerConfigTypeLRCLfeLsRsSlSr,                { left, right, centre, LFE, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  587. +                { Vst2::vstSpeakerConfigTypeLRCLsRsLcRcCs,                 { left, right, centre, leftSurround, rightSurround, topFrontLeft, topFrontRight, surround, unknown } },

  588. +                { Vst2::vstSpeakerConfigTypeLRCLsRsCsSlSr,                 { left, right, centre, leftSurround, rightSurround, surround, leftSurroundRear, rightSurroundRear, unknown } },

  589. +                { Vst2::vstSpeakerConfigTypeLRCLfeLsRsLcRcCs,              { left, right, centre, LFE, leftSurround, rightSurround, topFrontLeft, topFrontRight, surround, unknown } },

  590. +                { Vst2::vstSpeakerConfigTypeLRCLfeLsRsCsSlSr,              { left, right, centre, LFE, leftSurround, rightSurround, surround, leftSurroundRear, rightSurroundRear, unknown } },

  591. +                { Vst2::vstSpeakerConfigTypeLRCLfeLsRsTflTfcTfrTrlTrrLfe2, { left, right, centre, LFE, leftSurround, rightSurround, topFrontLeft, topFrontCentre, topFrontRight, topRearLeft, topRearRight, LFE2, unknown } },

  592. +                { Vst2::vstSpeakerConfigTypeEmpty,                         { unknown } }

  593.              };

  594.  

  595.              return mappings;

  596. @@ -1046,25 +1038,25 @@ public:

  597.          {

  598.              switch (type)

  599.              {

  600. -                case AudioChannelSet::left:              return Vst2::kSpeakerL;

  601. -                case AudioChannelSet::right:             return Vst2::kSpeakerR;

  602. -                case AudioChannelSet::centre:            return Vst2::kSpeakerC;

  603. -                case AudioChannelSet::LFE:               return Vst2::kSpeakerLfe;

  604. -                case AudioChannelSet::leftSurround:      return Vst2::kSpeakerLs;

  605. -                case AudioChannelSet::rightSurround:     return Vst2::kSpeakerRs;

  606. -                case AudioChannelSet::leftCentre:        return Vst2::kSpeakerLc;

  607. -                case AudioChannelSet::rightCentre:       return Vst2::kSpeakerRc;

  608. -                case AudioChannelSet::surround:          return Vst2::kSpeakerS;

  609. -                case AudioChannelSet::leftSurroundRear:  return Vst2::kSpeakerSl;

  610. -                case AudioChannelSet::rightSurroundRear: return Vst2::kSpeakerSr;

  611. -                case AudioChannelSet::topMiddle:         return Vst2::kSpeakerTm;

  612. -                case AudioChannelSet::topFrontLeft:      return Vst2::kSpeakerTfl;

  613. -                case AudioChannelSet::topFrontCentre:    return Vst2::kSpeakerTfc;

  614. -                case AudioChannelSet::topFrontRight:     return Vst2::kSpeakerTfr;

  615. -                case AudioChannelSet::topRearLeft:       return Vst2::kSpeakerTrl;

  616. -                case AudioChannelSet::topRearCentre:     return Vst2::kSpeakerTrc;

  617. -                case AudioChannelSet::topRearRight:      return Vst2::kSpeakerTrr;

  618. -                case AudioChannelSet::LFE2:              return Vst2::kSpeakerLfe2;

  619. +                case AudioChannelSet::left:              return Vst2::vstIndividualSpeakerTypeLeft;

  620. +                case AudioChannelSet::right:             return Vst2::vstIndividualSpeakerTypeRight;

  621. +                case AudioChannelSet::centre:            return Vst2::vstIndividualSpeakerTypeCentre;

  622. +                case AudioChannelSet::LFE:               return Vst2::vstIndividualSpeakerTypeLFE;

  623. +                case AudioChannelSet::leftSurround:      return Vst2::vstIndividualSpeakerTypeLeftSurround;

  624. +                case AudioChannelSet::rightSurround:     return Vst2::vstIndividualSpeakerTypeRightSurround;

  625. +                case AudioChannelSet::leftCentre:        return Vst2::vstIndividualSpeakerTypeLeftCentre;

  626. +                case AudioChannelSet::rightCentre:       return Vst2::vstIndividualSpeakerTypeRightCentre;

  627. +                case AudioChannelSet::surround:          return Vst2::vstIndividualSpeakerTypeSurround;

  628. +                case AudioChannelSet::leftSurroundRear:  return Vst2::vstIndividualSpeakerTypeLeftRearSurround;

  629. +                case AudioChannelSet::rightSurroundRear: return Vst2::vstIndividualSpeakerTypeRightRearSurround;

  630. +                case AudioChannelSet::topMiddle:         return Vst2::vstIndividualSpeakerTypeTopMiddle;

  631. +                case AudioChannelSet::topFrontLeft:      return Vst2::vstIndividualSpeakerTypeTopFrontLeft;

  632. +                case AudioChannelSet::topFrontCentre:    return Vst2::vstIndividualSpeakerTypeTopFrontCentre;

  633. +                case AudioChannelSet::topFrontRight:     return Vst2::vstIndividualSpeakerTypeTopFrontRight;

  634. +                case AudioChannelSet::topRearLeft:       return Vst2::vstIndividualSpeakerTypeTopRearLeft;

  635. +                case AudioChannelSet::topRearCentre:     return Vst2::vstIndividualSpeakerTypeTopRearCentre;

  636. +                case AudioChannelSet::topRearRight:      return Vst2::vstIndividualSpeakerTypeTopRearRight;

  637. +                case AudioChannelSet::LFE2:              return Vst2::vstIndividualSpeakerTypeLFE2;

  638.                  default: break;

  639.              }

  640.  

  641. @@ -1075,25 +1067,25 @@ public:

  642.          {

  643.              switch (type)

  644.              {

  645. -                case Vst2::kSpeakerL:       return AudioChannelSet::left;

  646. -                case Vst2::kSpeakerR:       return AudioChannelSet::right;

  647. -                case Vst2::kSpeakerC:       return AudioChannelSet::centre;

  648. -                case Vst2::kSpeakerLfe:     return AudioChannelSet::LFE;

  649. -                case Vst2::kSpeakerLs:      return AudioChannelSet::leftSurround;

  650. -                case Vst2::kSpeakerRs:      return AudioChannelSet::rightSurround;

  651. -                case Vst2::kSpeakerLc:      return AudioChannelSet::leftCentre;

  652. -                case Vst2::kSpeakerRc:      return AudioChannelSet::rightCentre;

  653. -                case Vst2::kSpeakerS:       return AudioChannelSet::surround;

  654. -                case Vst2::kSpeakerSl:      return AudioChannelSet::leftSurroundRear;

  655. -                case Vst2::kSpeakerSr:      return AudioChannelSet::rightSurroundRear;

  656. -                case Vst2::kSpeakerTm:      return AudioChannelSet::topMiddle;

  657. -                case Vst2::kSpeakerTfl:     return AudioChannelSet::topFrontLeft;

  658. -                case Vst2::kSpeakerTfc:     return AudioChannelSet::topFrontCentre;

  659. -                case Vst2::kSpeakerTfr:     return AudioChannelSet::topFrontRight;

  660. -                case Vst2::kSpeakerTrl:     return AudioChannelSet::topRearLeft;

  661. -                case Vst2::kSpeakerTrc:     return AudioChannelSet::topRearCentre;

  662. -                case Vst2::kSpeakerTrr:     return AudioChannelSet::topRearRight;

  663. -                case Vst2::kSpeakerLfe2:    return AudioChannelSet::LFE2;

  664. +                case Vst2::vstIndividualSpeakerTypeLeft:              return AudioChannelSet::left;

  665. +                case Vst2::vstIndividualSpeakerTypeRight:             return AudioChannelSet::right;

  666. +                case Vst2::vstIndividualSpeakerTypeCentre:            return AudioChannelSet::centre;

  667. +                case Vst2::vstIndividualSpeakerTypeLFE:               return AudioChannelSet::LFE;

  668. +                case Vst2::vstIndividualSpeakerTypeLeftSurround:      return AudioChannelSet::leftSurround;

  669. +                case Vst2::vstIndividualSpeakerTypeRightSurround:     return AudioChannelSet::rightSurround;

  670. +                case Vst2::vstIndividualSpeakerTypeLeftCentre:        return AudioChannelSet::leftCentre;

  671. +                case Vst2::vstIndividualSpeakerTypeRightCentre:       return AudioChannelSet::rightCentre;

  672. +                case Vst2::vstIndividualSpeakerTypeSurround:          return AudioChannelSet::surround;

  673. +                case Vst2::vstIndividualSpeakerTypeLeftRearSurround:  return AudioChannelSet::leftSurroundRear;

  674. +                case Vst2::vstIndividualSpeakerTypeRightRearSurround: return AudioChannelSet::rightSurroundRear;

  675. +                case Vst2::vstIndividualSpeakerTypeTopMiddle:         return AudioChannelSet::topMiddle;

  676. +                case Vst2::vstIndividualSpeakerTypeTopFrontLeft:      return AudioChannelSet::topFrontLeft;

  677. +                case Vst2::vstIndividualSpeakerTypeTopFrontCentre:    return AudioChannelSet::topFrontCentre;

  678. +                case Vst2::vstIndividualSpeakerTypeTopFrontRight:     return AudioChannelSet::topFrontRight;

  679. +                case Vst2::vstIndividualSpeakerTypeTopRearLeft:       return AudioChannelSet::topRearLeft;

  680. +                case Vst2::vstIndividualSpeakerTypeTopRearCentre:     return AudioChannelSet::topRearCentre;

  681. +                case Vst2::vstIndividualSpeakerTypeTopRearRight:      return AudioChannelSet::topRearRight;

  682. +                case Vst2::vstIndividualSpeakerTypeLFE2:              return AudioChannelSet::LFE2;

  683.                  default: break;

  684.              }

  685.  

  686. @@ -1127,15 +1119,15 @@ public:

  687.  

  688.      void setHasEditorFlag (bool shouldSetHasEditor)

  689.      {

  690. -        auto hasEditor = (vstEffect.flags & Vst2::effFlagsHasEditor) != 0;

  691. +        auto hasEditor = (vstEffect.flags & Vst2::vstEffectFlagHasEditor) != 0;

  692.  

  693.          if (shouldSetHasEditor == hasEditor)

  694.              return;

  695.  

  696.          if (shouldSetHasEditor)

  697. -            vstEffect.flags |= Vst2::effFlagsHasEditor;

  698. +            vstEffect.flags |= Vst2::vstEffectFlagHasEditor;

  699.          else

  700. -            vstEffect.flags &= ~Vst2::effFlagsHasEditor;

  701. +            vstEffect.flags &= ~Vst2::vstEffectFlagHasEditor;

  702.      }

  703.  

  704.      void createEditorComp()

  705. @@ -1202,59 +1194,59 @@ public:

  706.  

  707.          switch (opCode)

  708.          {

  709. -            case Vst2::effOpen:                     return handleOpen (args);

  710. -            case Vst2::effClose:                    return handleClose (args);

  711. -            case Vst2::effSetProgram:               return handleSetCurrentProgram (args);

  712. -            case Vst2::effGetProgram:               return handleGetCurrentProgram (args);

  713. -            case Vst2::effSetProgramName:           return handleSetCurrentProgramName (args);

  714. -            case Vst2::effGetProgramName:           return handleGetCurrentProgramName (args);

  715. -            case Vst2::effGetParamLabel:            return handleGetParameterLabel (args);

  716. -            case Vst2::effGetParamDisplay:          return handleGetParameterText (args);

  717. -            case Vst2::effGetParamName:             return handleGetParameterName (args);

  718. -            case Vst2::effSetSampleRate:            return handleSetSampleRate (args);

  719. -            case Vst2::effSetBlockSize:             return handleSetBlockSize (args);

  720. -            case Vst2::effMainsChanged:             return handleResumeSuspend (args);

  721. -            case Vst2::effEditGetRect:              return handleGetEditorBounds (args);

  722. -            case Vst2::effEditOpen:                 return handleOpenEditor (args);

  723. -            case Vst2::effEditClose:                return handleCloseEditor (args);

  724. -            case Vst2::effIdentify:                 return (pointer_sized_int) ByteOrder::bigEndianInt ("NvEf");

  725. -            case Vst2::effGetChunk:                 return handleGetData (args);

  726. -            case Vst2::effSetChunk:                 return handleSetData (args);

  727. -            case Vst2::effProcessEvents:            return handlePreAudioProcessingEvents (args);

  728. -            case Vst2::effCanBeAutomated:           return handleIsParameterAutomatable (args);

  729. -            case Vst2::effString2Parameter:         return handleParameterValueForText (args);

  730. -            case Vst2::effGetProgramNameIndexed:    return handleGetProgramName (args);

  731. -            case Vst2::effGetInputProperties:       return handleGetInputPinProperties (args);

  732. -            case Vst2::effGetOutputProperties:      return handleGetOutputPinProperties (args);

  733. -            case Vst2::effGetPlugCategory:          return handleGetPlugInCategory (args);

  734. -            case Vst2::effSetSpeakerArrangement:    return handleSetSpeakerConfiguration (args);

  735. -            case Vst2::effSetBypass:                return handleSetBypass (args);

  736. -            case Vst2::effGetEffectName:            return handleGetPlugInName (args);

  737. -            case Vst2::effGetProductString:         return handleGetPlugInName (args);

  738. -            case Vst2::effGetVendorString:          return handleGetManufacturerName (args);

  739. -            case Vst2::effGetVendorVersion:         return handleGetManufacturerVersion (args);

  740. -            case Vst2::effVendorSpecific:           return handleManufacturerSpecific (args);

  741. -            case Vst2::effCanDo:                    return handleCanPlugInDo (args);

  742. -            case Vst2::effGetTailSize:              return handleGetTailSize (args);

  743. -            case Vst2::effKeysRequired:             return handleKeyboardFocusRequired (args);

  744. -            case Vst2::effGetVstVersion:            return handleGetVstInterfaceVersion (args);

  745. -            case Vst2::effGetCurrentMidiProgram:    return handleGetCurrentMidiProgram (args);

  746. -            case Vst2::effGetSpeakerArrangement:    return handleGetSpeakerConfiguration (args);

  747. -            case Vst2::effSetTotalSampleToProcess:  return handleSetNumberOfSamplesToProcess (args);

  748. -            case Vst2::effSetProcessPrecision:      return handleSetSampleFloatType (args);

  749. -            case Vst2::effGetNumMidiInputChannels:  return handleGetNumMidiInputChannels();

  750. -            case Vst2::effGetNumMidiOutputChannels: return handleGetNumMidiOutputChannels();

  751. -            default:                                return 0;

  752. -        }

  753. -    }

  754. -

  755. -    static pointer_sized_int dispatcherCB (Vst2::AEffect* vstInterface, int32 opCode, int32 index,

  756. +            case Vst2::plugInOpcodeOpen:                        return handleOpen (args);

  757. +            case Vst2::plugInOpcodeClose:                       return handleClose (args);

  758. +            case Vst2::plugInOpcodeSetCurrentProgram:           return handleSetCurrentProgram (args);

  759. +            case Vst2::plugInOpcodeGetCurrentProgram:           return handleGetCurrentProgram (args);

  760. +            case Vst2::plugInOpcodeSetCurrentProgramName:       return handleSetCurrentProgramName (args);

  761. +            case Vst2::plugInOpcodeGetCurrentProgramName:       return handleGetCurrentProgramName (args);

  762. +            case Vst2::plugInOpcodeGetParameterLabel:           return handleGetParameterLabel (args);

  763. +            case Vst2::plugInOpcodeGetParameterText:            return handleGetParameterText (args);

  764. +            case Vst2::plugInOpcodeGetParameterName:            return handleGetParameterName (args);

  765. +            case Vst2::plugInOpcodeSetSampleRate:               return handleSetSampleRate (args);

  766. +            case Vst2::plugInOpcodeSetBlockSize:                return handleSetBlockSize (args);

  767. +            case Vst2::plugInOpcodeResumeSuspend:               return handleResumeSuspend (args);

  768. +            case Vst2::plugInOpcodeGetEditorBounds:             return handleGetEditorBounds (args);

  769. +            case Vst2::plugInOpcodeOpenEditor:                  return handleOpenEditor (args);

  770. +            case Vst2::plugInOpcodeCloseEditor:                 return handleCloseEditor (args);

  771. +            case Vst2::plugInOpcodeIdentify:                    return (pointer_sized_int) ByteOrder::bigEndianInt ("NvEf");

  772. +            case Vst2::plugInOpcodeGetData:                     return handleGetData (args);

  773. +            case Vst2::plugInOpcodeSetData:                     return handleSetData (args);

  774. +            case Vst2::plugInOpcodePreAudioProcessingEvents:    return handlePreAudioProcessingEvents (args);

  775. +            case Vst2::plugInOpcodeIsParameterAutomatable:      return handleIsParameterAutomatable (args);

  776. +            case Vst2::plugInOpcodeParameterValueForText:       return handleParameterValueForText (args);

  777. +            case Vst2::plugInOpcodeGetProgramName:              return handleGetProgramName (args);

  778. +            case Vst2::plugInOpcodeGetInputPinProperties:       return handleGetInputPinProperties (args);

  779. +            case Vst2::plugInOpcodeGetOutputPinProperties:      return handleGetOutputPinProperties (args);

  780. +            case Vst2::plugInOpcodeGetPlugInCategory:           return handleGetPlugInCategory (args);

  781. +            case Vst2::plugInOpcodeSetSpeakerConfiguration:     return handleSetSpeakerConfiguration (args);

  782. +            case Vst2::plugInOpcodeSetBypass:                   return handleSetBypass (args);

  783. +            case Vst2::plugInOpcodeGetPlugInName:               return handleGetPlugInName (args);

  784. +            case Vst2::plugInOpcodeGetManufacturerProductName:  return handleGetPlugInName (args);

  785. +            case Vst2::plugInOpcodeGetManufacturerName:         return handleGetManufacturerName (args);

  786. +            case Vst2::plugInOpcodeGetManufacturerVersion:      return handleGetManufacturerVersion (args);

  787. +            case Vst2::plugInOpcodeManufacturerSpecific:        return handleManufacturerSpecific (args);

  788. +            case Vst2::plugInOpcodeCanPlugInDo:                 return handleCanPlugInDo (args);

  789. +            case Vst2::plugInOpcodeGetTailSize:                 return handleGetTailSize (args);

  790. +            case Vst2::plugInOpcodeKeyboardFocusRequired:       return handleKeyboardFocusRequired (args);

  791. +            case Vst2::plugInOpcodeGetVstInterfaceVersion:      return handleGetVstInterfaceVersion (args);

  792. +            case Vst2::plugInOpcodeGetCurrentMidiProgram:       return handleGetCurrentMidiProgram (args);

  793. +            case Vst2::plugInOpcodeGetSpeakerArrangement:       return handleGetSpeakerConfiguration (args);

  794. +            case Vst2::plugInOpcodeSetNumberOfSamplesToProcess: return handleSetNumberOfSamplesToProcess (args);

  795. +            case Vst2::plugInOpcodeSetSampleFloatType:          return handleSetSampleFloatType (args);

  796. +            case Vst2::pluginOpcodeGetNumMidiInputChannels:     return handleGetNumMidiInputChannels();

  797. +            case Vst2::pluginOpcodeGetNumMidiOutputChannels:    return handleGetNumMidiOutputChannels();

  798. +            default:                                            return 0;

  799. +        }

  800. +    }

  801. +

  802. +    static pointer_sized_int dispatcherCB (Vst2::VstEffectInterface* vstInterface, int32 opCode, int32 index,

  803.                                             pointer_sized_int value, void* ptr, float opt)

  804.      {

  805.          auto* wrapper = getWrapper (vstInterface);

  806.          VstOpCodeArguments args = { index, value, ptr, opt };

  807.  

  808. -        if (opCode == Vst2::effClose)

  809. +        if (opCode == Vst2::plugInOpcodeClose)

  810.          {

  811.              wrapper->dispatcher (opCode, args);

  812.              delete wrapper;

  813. @@ -1302,18 +1294,18 @@ public:

  814.  

  815.          void paint (Graphics&) override {}

  816.  

  817. -        void getEditorBounds (Vst2::ERect& bounds)

  818. +        void getEditorBounds (Vst2::VstEditorBounds& bounds)

  819.          {

  820.              auto b = getSizeToContainChild();

  821.  

  822. -            bounds.top    = 0;

  823. -            bounds.left   = 0;

  824. -            bounds.bottom = (int16) b.getHeight();

  825. -            bounds.right  = (int16) b.getWidth();

  826. +            bounds.upper     = 0;

  827. +            bounds.leftmost  = 0;

  828. +            bounds.lower     = (int16) b.getHeight();

  829. +            bounds.rightmost = (int16) b.getWidth();

  830.  

  831.             #if JUCE_WINDOWS && JUCE_WIN_PER_MONITOR_DPI_AWARE

  832. -            bounds.bottom = (int16) roundToInt (bounds.bottom * wrapper.editorScaleFactor);

  833. -            bounds.right  = (int16) roundToInt (bounds.right  * wrapper.editorScaleFactor);

  834. +            bounds.lower      = (int16) roundToInt (bounds.lower * wrapper.editorScaleFactor);

  835. +            bounds.rightmost  = (int16) roundToInt (bounds.rightmost  * wrapper.editorScaleFactor);

  836.             #endif

  837.          }

  838.  

  839. @@ -1463,7 +1455,7 @@ public:

  840.  

  841.              if (auto host = wrapper.hostCallback)

  842.              {

  843. -                auto status = host (wrapper.getAEffect(), Vst2::audioMasterCanDo, 0, 0, const_cast<char*> ("sizeWindow"), 0);

  844. +                auto status = host (wrapper.getAEffect(), Vst2::hostOpcodeCanHostDo, 0, 0, const_cast<char*> ("sizeWindow"), 0);

  845.  

  846.                  if (status == (pointer_sized_int) 1 || getHostType().isAbletonLive())

  847.                  {

  848. @@ -1474,7 +1466,7 @@ public:

  849.  

  850.                      const ScopedValueSetter<bool> inSizeWindowSetter (isInSizeWindow, true);

  851.  

  852. -                    sizeWasSuccessful = (host (wrapper.getAEffect(), Vst2::audioMasterSizeWindow,

  853. +                    sizeWasSuccessful = (host (wrapper.getAEffect(), Vst2::hostOpcodeWindowSize,

  854.                                                 newWidth, newHeight, nullptr, 0) != 0);

  855.                  }

  856.              }

  857. @@ -1593,12 +1585,12 @@ public:

  858.  

  859.      //==============================================================================

  860.  private:

  861. -    static JuceVSTWrapper* getWrapper (Vst2::AEffect* v) noexcept  { return static_cast<JuceVSTWrapper*> (v->object); }

  862. +    static JuceVSTWrapper* getWrapper (Vst2::VstEffectInterface* v) noexcept  { return static_cast<JuceVSTWrapper*> (v->effectPointer); }

  863.  

  864.      bool isProcessLevelOffline()

  865.      {

  866.          return hostCallback != nullptr

  867. -                && (int32) hostCallback (&vstEffect, Vst2::audioMasterGetCurrentProcessLevel, 0, 0, nullptr, 0) == 4;

  868. +                && (int32) hostCallback (&vstEffect, Vst2::hostOpcodeGetCurrentAudioProcessingLevel, 0, 0, nullptr, 0) == 4;

  869.      }

  870.  

  871.      static inline int32 convertHexVersionToDecimal (const unsigned int hexVersion)

  872. @@ -1666,8 +1658,8 @@ private:

  873.          tmpBuffers.release();

  874.  

  875.          if (processor != nullptr)

  876. -            tmpBuffers.tempChannels.insertMultiple (0, nullptr, vstEffect.numInputs

  877. -                                                                 + vstEffect.numOutputs);

  878. +            tmpBuffers.tempChannels.insertMultiple (0, nullptr, vstEffect.numInputChannels

  879. +                                                                 + vstEffect.numOutputChannels);

  880.      }

  881.  

  882.      void deleteTempChannels()

  883. @@ -1827,7 +1819,7 @@ private:

  884.          if (editorComp != nullptr)

  885.          {

  886.              editorComp->getEditorBounds (editorBounds);

  887. -            *((Vst2::ERect**) args.ptr) = &editorBounds;

  888. +            *((Vst2::VstEditorBounds**) args.ptr) = &editorBounds;

  889.              return (pointer_sized_int) &editorBounds;

  890.          }

  891.  

  892. @@ -1917,7 +1909,7 @@ private:

  893.      pointer_sized_int handlePreAudioProcessingEvents (VstOpCodeArguments args)

  894.      {

  895.         #if JucePlugin_WantsMidiInput || JucePlugin_IsMidiEffect

  896. -        VSTMidiEventList::addEventsToMidiBuffer ((Vst2::VstEvents*) args.ptr, midiEvents);

  897. +        VSTMidiEventList::addEventsToMidiBuffer ((Vst2::VstEventBlock*) args.ptr, midiEvents);

  898.          return 1;

  899.         #else

  900.          ignoreUnused (args);

  901. @@ -1968,12 +1960,12 @@ private:

  902.  

  903.      pointer_sized_int handleGetInputPinProperties (VstOpCodeArguments args)

  904.      {

  905. -        return (processor != nullptr && getPinProperties (*(Vst2::VstPinProperties*) args.ptr, true, args.index)) ? 1 : 0;

  906. +        return (processor != nullptr && getPinProperties (*(Vst2::VstPinInfo*) args.ptr, true, args.index)) ? 1 : 0;

  907.      }

  908.  

  909.      pointer_sized_int handleGetOutputPinProperties (VstOpCodeArguments args)

  910.      {

  911. -        return (processor != nullptr && getPinProperties (*(Vst2::VstPinProperties*) args.ptr, false, args.index)) ? 1 : 0;

  912. +        return (processor != nullptr && getPinProperties (*(Vst2::VstPinInfo*) args.ptr, false, args.index)) ? 1 : 0;

  913.      }

  914.  

  915.      pointer_sized_int handleGetPlugInCategory (VstOpCodeArguments)

  916. @@ -1983,8 +1975,8 @@ private:

  917.  

  918.      pointer_sized_int handleSetSpeakerConfiguration (VstOpCodeArguments args)

  919.      {

  920. -        auto* pluginInput  = reinterpret_cast<Vst2::VstSpeakerArrangement*> (args.value);

  921. -        auto* pluginOutput = reinterpret_cast<Vst2::VstSpeakerArrangement*> (args.ptr);

  922. +        auto* pluginInput  = reinterpret_cast<Vst2::VstSpeakerConfiguration*> (args.value);

  923. +        auto* pluginOutput = reinterpret_cast<Vst2::VstSpeakerConfiguration*> (args.ptr);

  924.  

  925.          if (processor->isMidiEffect())

  926.              return 0;

  927. @@ -1995,29 +1987,29 @@ private:

  928.          if (pluginInput != nullptr && pluginInput->type >= 0)

  929.          {

  930.              // inconsistent request?

  931. -            if (SpeakerMappings::vstArrangementTypeToChannelSet (*pluginInput).size() != pluginInput->numChannels)

  932. +            if (SpeakerMappings::vstArrangementTypeToChannelSet (*pluginInput).size() != pluginInput->numberOfChannels)

  933.                  return 0;

  934.          }

  935.  

  936.          if (pluginOutput != nullptr && pluginOutput->type >= 0)

  937.          {

  938.              // inconsistent request?

  939. -            if (SpeakerMappings::vstArrangementTypeToChannelSet (*pluginOutput).size() != pluginOutput->numChannels)

  940. +            if (SpeakerMappings::vstArrangementTypeToChannelSet (*pluginOutput).size() != pluginOutput->numberOfChannels)

  941.                  return 0;

  942.          }

  943.  

  944. -        if (pluginInput != nullptr  && pluginInput->numChannels  > 0 && numIns  == 0)

  945. +        if (pluginInput != nullptr  && pluginInput->numberOfChannels  > 0 && numIns  == 0)

  946.              return 0;

  947.  

  948. -        if (pluginOutput != nullptr && pluginOutput->numChannels > 0 && numOuts == 0)

  949. +        if (pluginOutput != nullptr && pluginOutput->numberOfChannels > 0 && numOuts == 0)

  950.              return 0;

  951.  

  952.          auto layouts = processor->getBusesLayout();

  953.  

  954. -        if (pluginInput != nullptr && pluginInput-> numChannels >= 0 && numIns  > 0)

  955. +        if (pluginInput != nullptr && pluginInput-> numberOfChannels >= 0 && numIns  > 0)

  956.              layouts.getChannelSet (true,  0) = SpeakerMappings::vstArrangementTypeToChannelSet (*pluginInput);

  957.  

  958. -        if (pluginOutput != nullptr && pluginOutput->numChannels >= 0 && numOuts > 0)

  959. +        if (pluginOutput != nullptr && pluginOutput->numberOfChannels >= 0 && numOuts > 0)

  960.              layouts.getChannelSet (false, 0) = SpeakerMappings::vstArrangementTypeToChannelSet (*pluginOutput);

  961.  

  962.         #ifdef JucePlugin_PreferredChannelConfigurations

  963. @@ -2065,7 +2057,7 @@ private:

  964.               && args.value == JUCE_MULTICHAR_CONSTANT ('A', 'e', 'C', 's'))

  965.              return handleSetContentScaleFactor (args.opt);

  966.  

  967. -        if (args.index == Vst2::effGetParamDisplay)

  968. +        if (args.index == Vst2::plugInOpcodeGetParameterText)

  969.              return handleCockosGetParameterText (args.value, args.ptr, args.opt);

  970.  

  971.          if (auto callbackHandler = dynamic_cast<VSTCallbackHandler*> (processor))

  972. @@ -2160,7 +2152,7 @@ private:

  973.  

  974.      pointer_sized_int handleGetVstInterfaceVersion (VstOpCodeArguments)

  975.      {

  976. -        return kVstVersion;

  977. +        return Vst2::juceVstInterfaceVersion;

  978.      }

  979.  

  980.      pointer_sized_int handleGetCurrentMidiProgram (VstOpCodeArguments)

  981. @@ -2170,8 +2162,8 @@ private:

  982.  

  983.      pointer_sized_int handleGetSpeakerConfiguration (VstOpCodeArguments args)

  984.      {

  985. -        auto** pluginInput  = reinterpret_cast<Vst2::VstSpeakerArrangement**> (args.value);

  986. -        auto** pluginOutput = reinterpret_cast<Vst2::VstSpeakerArrangement**> (args.ptr);

  987. +        auto** pluginInput  = reinterpret_cast<Vst2::VstSpeakerConfiguration**> (args.value);

  988. +        auto** pluginOutput = reinterpret_cast<Vst2::VstSpeakerConfiguration**> (args.ptr);

  989.  

  990.          if (pluginHasSidechainsOrAuxs() || processor->isMidiEffect())

  991.              return false;

  992. @@ -2179,10 +2171,10 @@ private:

  993.          auto inputLayout  = processor->getChannelLayoutOfBus (true,  0);

  994.          auto outputLayout = processor->getChannelLayoutOfBus (false,  0);

  995.  

  996. -        auto speakerBaseSize = sizeof (Vst2::VstSpeakerArrangement) - (sizeof (Vst2::VstSpeakerProperties) * 8);

  997. +        auto speakerBaseSize = sizeof (Vst2::VstSpeakerConfiguration) - (sizeof (Vst2::VstIndividualSpeakerInfo) * 8);

  998.  

  999. -        cachedInArrangement .malloc (speakerBaseSize + (static_cast<std::size_t> (inputLayout. size()) * sizeof (Vst2::VstSpeakerArrangement)), 1);

  1000. -        cachedOutArrangement.malloc (speakerBaseSize + (static_cast<std::size_t> (outputLayout.size()) * sizeof (Vst2::VstSpeakerArrangement)), 1);

  1001. +        cachedInArrangement .malloc (speakerBaseSize + (static_cast<std::size_t> (inputLayout. size()) * sizeof (Vst2::VstSpeakerConfiguration)), 1);

  1002. +        cachedOutArrangement.malloc (speakerBaseSize + (static_cast<std::size_t> (outputLayout.size()) * sizeof (Vst2::VstSpeakerConfiguration)), 1);

  1003.  

  1004.          *pluginInput  = cachedInArrangement. getData();

  1005.          *pluginOutput = cachedOutArrangement.getData();

  1006. @@ -2204,7 +2196,7 @@ private:

  1007.          {

  1008.              if (processor != nullptr)

  1009.              {

  1010. -                processor->setProcessingPrecision ((args.value == Vst2::kVstProcessPrecision64

  1011. +                processor->setProcessingPrecision ((args.value == Vst2::vstProcessingSampleTypeDouble

  1012.                                                       && processor->supportsDoublePrecisionProcessing())

  1013.                                                           ? AudioProcessor::doublePrecision

  1014.                                                           : AudioProcessor::singlePrecision);

  1015. @@ -2286,16 +2278,16 @@ private:

  1016.      }

  1017.  

  1018.      //==============================================================================

  1019. -    Vst2::audioMasterCallback hostCallback;

  1020. +    Vst2::VstHostCallback hostCallback;

  1021.      AudioProcessor* processor = {};

  1022.      double sampleRate = 44100.0;

  1023.      int32 blockSize = 1024;

  1024. -    Vst2::AEffect vstEffect;

  1025. +    Vst2::VstEffectInterface vstEffect;

  1026.      CriticalSection stateInformationLock;

  1027.      juce::MemoryBlock chunkMemory;

  1028.      uint32 chunkMemoryTime = 0;

  1029.      std::unique_ptr<EditorCompWrapper> editorComp;

  1030. -    Vst2::ERect editorBounds;

  1031. +    Vst2::VstEditorBounds editorBounds;

  1032.      MidiBuffer midiEvents;

  1033.      VSTMidiEventList outgoingEvents;

  1034.  

  1035. @@ -2320,7 +2312,7 @@ private:

  1036.      VstTempBuffers<double> doubleTempBuffers;

  1037.      int maxNumInChannels = 0, maxNumOutChannels = 0;

  1038.  

  1039. -    HeapBlock<Vst2::VstSpeakerArrangement> cachedInArrangement, cachedOutArrangement;

  1040. +    HeapBlock<Vst2::VstSpeakerConfiguration> cachedInArrangement, cachedOutArrangement;

  1041.  

  1042.      ThreadLocalValue<bool> inParameterChangedCallback;

  1043.  

  1044. @@ -2332,7 +2324,7 @@ private:

  1045.  //==============================================================================

  1046.  namespace

  1047.  {

  1048. -    Vst2::AEffect* pluginEntryPoint (Vst2::audioMasterCallback audioMaster)

  1049. +    Vst2::VstEffectInterface* pluginEntryPoint (Vst2::VstHostCallback audioMaster)

  1050.      {

  1051.          JUCE_AUTORELEASEPOOL

  1052.          {

  1053. @@ -2340,7 +2332,7 @@ namespace

  1054.  

  1055.              try

  1056.              {

  1057. -                if (audioMaster (nullptr, Vst2::audioMasterVersion, 0, 0, nullptr, 0) != 0)

  1058. +                if (audioMaster (nullptr, Vst2::hostOpcodeVstVersion, 0, 0, nullptr, 0) != 0)

  1059.                  {

  1060.                     #if JUCE_LINUX

  1061.                      MessageManagerLock mmLock;

  1062. @@ -2377,8 +2369,8 @@ namespace

  1063.  // Mac startup code..

  1064.  #if JUCE_MAC

  1065.  

  1066. -    JUCE_EXPORTED_FUNCTION Vst2::AEffect* VSTPluginMain (Vst2::audioMasterCallback audioMaster);

  1067. -    JUCE_EXPORTED_FUNCTION Vst2::AEffect* VSTPluginMain (Vst2::audioMasterCallback audioMaster)

  1068. +    JUCE_EXPORTED_FUNCTION Vst2::VstEffectInterface* VSTPluginMain (Vst2::VstHostCallback audioMaster);

  1069. +    JUCE_EXPORTED_FUNCTION Vst2::VstEffectInterface* VSTPluginMain (Vst2::VstHostCallback audioMaster)

  1070.      {

  1071.          PluginHostType::jucePlugInClientCurrentWrapperType = AudioProcessor::wrapperType_VST;

  1072.  

  1073. @@ -2386,8 +2378,8 @@ namespace

  1074.          return pluginEntryPoint (audioMaster);

  1075.      }

  1076.  

  1077. -    JUCE_EXPORTED_FUNCTION Vst2::AEffect* main_macho (Vst2::audioMasterCallback audioMaster);

  1078. -    JUCE_EXPORTED_FUNCTION Vst2::AEffect* main_macho (Vst2::audioMasterCallback audioMaster)

  1079. +    JUCE_EXPORTED_FUNCTION Vst2::VstEffectInterface* main_macho (Vst2::VstHostCallback audioMaster);

  1080. +    JUCE_EXPORTED_FUNCTION Vst2::VstEffectInterface* main_macho (Vst2::VstHostCallback audioMaster)

  1081.      {

  1082.          PluginHostType::jucePlugInClientCurrentWrapperType = AudioProcessor::wrapperType_VST;

  1083.  

  1084. @@ -2399,8 +2391,8 @@ namespace

  1085.  // Linux startup code..

  1086.  #elif JUCE_LINUX

  1087.  

  1088. -    JUCE_EXPORTED_FUNCTION Vst2::AEffect* VSTPluginMain (Vst2::audioMasterCallback audioMaster);

  1089. -    JUCE_EXPORTED_FUNCTION Vst2::AEffect* VSTPluginMain (Vst2::audioMasterCallback audioMaster)

  1090. +    JUCE_EXPORTED_FUNCTION Vst2::VstEffectInterface* VSTPluginMain (Vst2::VstHostCallback audioMaster);

  1091. +    JUCE_EXPORTED_FUNCTION Vst2::VstEffectInterface* VSTPluginMain (Vst2::VstHostCallback audioMaster)

  1092.      {

  1093.          PluginHostType::jucePlugInClientCurrentWrapperType = AudioProcessor::wrapperType_VST;

  1094.  

  1095. @@ -2408,8 +2400,8 @@ namespace

  1096.          return pluginEntryPoint (audioMaster);

  1097.      }

  1098.  

  1099. -    JUCE_EXPORTED_FUNCTION Vst2::AEffect* main_plugin (Vst2::audioMasterCallback audioMaster) asm ("main");

  1100. -    JUCE_EXPORTED_FUNCTION Vst2::AEffect* main_plugin (Vst2::audioMasterCallback audioMaster)

  1101. +    JUCE_EXPORTED_FUNCTION Vst2::VstEffectInterface* main_plugin (Vst2::VstHostCallback audioMaster) asm ("main");

  1102. +    JUCE_EXPORTED_FUNCTION Vst2::VstEffectInterface* main_plugin (Vst2::VstHostCallback audioMaster)

  1103.      {

  1104.          PluginHostType::jucePlugInClientCurrentWrapperType = AudioProcessor::wrapperType_VST;

  1105.  

  1106. @@ -2424,7 +2416,7 @@ namespace

  1107.  // Win32 startup code..

  1108.  #else

  1109.  

  1110. -    extern "C" __declspec (dllexport) Vst2::AEffect* VSTPluginMain (Vst2::audioMasterCallback audioMaster)

  1111. +    extern "C" __declspec (dllexport) Vst2::VstEffectInterface* VSTPluginMain (Vst2::VstHostCallback audioMaster)

  1112.      {

  1113.          PluginHostType::jucePlugInClientCurrentWrapperType = AudioProcessor::wrapperType_VST;

  1114.  

  1115. @@ -2432,7 +2424,7 @@ namespace

  1116.      }

  1117.  

  1118.     #ifndef JUCE_64BIT // (can't compile this on win64, but it's not needed anyway with VST2.4)

  1119. -    extern "C" __declspec (dllexport) int main (Vst2::audioMasterCallback audioMaster)

  1120. +    extern "C" __declspec (dllexport) int main (Vst2::VstHostCallback audioMaster)

  1121.      {

  1122.          PluginHostType::jucePlugInClientCurrentWrapperType = AudioProcessor::wrapperType_VST;

  1123.  

  1124. diff --git a/modules/juce_audio_processors/format_types/juce_VSTCommon.h b/modules/juce_audio_processors/format_types/juce_VSTCommon.h

  1125. index 1eea8e3..10ea6e2 100644

  1126. --- a/modules/juce_audio_processors/format_types/juce_VSTCommon.h

  1127. +++ b/modules/juce_audio_processors/format_types/juce_VSTCommon.h

  1128. @@ -66,25 +66,25 @@ struct SpeakerMappings  : private AudioChannelSet // (inheritance only to give e

  1129.  

  1130.      static AudioChannelSet vstArrangementTypeToChannelSet (int32 arr, int fallbackNumChannels)

  1131.      {

  1132. -        if      (arr == Vst2::kSpeakerArrEmpty)        return AudioChannelSet::disabled();

  1133. -        else if (arr == Vst2::kSpeakerArrMono)         return AudioChannelSet::mono();

  1134. -        else if (arr == Vst2::kSpeakerArrStereo)       return AudioChannelSet::stereo();

  1135. -        else if (arr == Vst2::kSpeakerArr30Cine)       return AudioChannelSet::createLCR();

  1136. -        else if (arr == Vst2::kSpeakerArr30Music)      return AudioChannelSet::createLRS();

  1137. -        else if (arr == Vst2::kSpeakerArr40Cine)       return AudioChannelSet::createLCRS();

  1138. -        else if (arr == Vst2::kSpeakerArr50)           return AudioChannelSet::create5point0();

  1139. -        else if (arr == Vst2::kSpeakerArr51)           return AudioChannelSet::create5point1();

  1140. -        else if (arr == Vst2::kSpeakerArr60Cine)       return AudioChannelSet::create6point0();

  1141. -        else if (arr == Vst2::kSpeakerArr61Cine)       return AudioChannelSet::create6point1();

  1142. -        else if (arr == Vst2::kSpeakerArr60Music)      return AudioChannelSet::create6point0Music();

  1143. -        else if (arr == Vst2::kSpeakerArr61Music)      return AudioChannelSet::create6point1Music();

  1144. -        else if (arr == Vst2::kSpeakerArr70Music)      return AudioChannelSet::create7point0();

  1145. -        else if (arr == Vst2::kSpeakerArr70Cine)       return AudioChannelSet::create7point0SDDS();

  1146. -        else if (arr == Vst2::kSpeakerArr71Music)      return AudioChannelSet::create7point1();

  1147. -        else if (arr == Vst2::kSpeakerArr71Cine)       return AudioChannelSet::create7point1SDDS();

  1148. -        else if (arr == Vst2::kSpeakerArr40Music)      return AudioChannelSet::quadraphonic();

  1149. -

  1150. -        for (const Mapping* m = getMappings(); m->vst2 != Vst2::kSpeakerArrEmpty; ++m)

  1151. +        if      (arr == Vst2::vstSpeakerConfigTypeEmpty)          return AudioChannelSet::disabled();

  1152. +        else if (arr == Vst2::vstSpeakerConfigTypeMono)           return AudioChannelSet::mono();

  1153. +        else if (arr == Vst2::vstSpeakerConfigTypeLR)             return AudioChannelSet::stereo();

  1154. +        else if (arr == Vst2::vstSpeakerConfigTypeLRC)            return AudioChannelSet::createLCR();

  1155. +        else if (arr == Vst2::vstSpeakerConfigTypeLRS)            return AudioChannelSet::createLRS();

  1156. +        else if (arr == Vst2::vstSpeakerConfigTypeLRCS)           return AudioChannelSet::createLCRS();

  1157. +        else if (arr == Vst2::vstSpeakerConfigTypeLRCLsRs)        return AudioChannelSet::create5point0();

  1158. +        else if (arr == Vst2::vstSpeakerConfigTypeLRCLfeLsRs)     return AudioChannelSet::create5point1();

  1159. +        else if (arr == Vst2::vstSpeakerConfigTypeLRCLsRsCs)      return AudioChannelSet::create6point0();

  1160. +        else if (arr == Vst2::vstSpeakerConfigTypeLRCLfeLsRsCs)   return AudioChannelSet::create6point1();

  1161. +        else if (arr == Vst2::vstSpeakerConfigTypeLRLsRsSlSr)     return AudioChannelSet::create6point0Music();

  1162. +        else if (arr == Vst2::vstSpeakerConfigTypeLRLfeLsRsSlSr)  return AudioChannelSet::create6point1Music();

  1163. +        else if (arr == Vst2::vstSpeakerConfigTypeLRCLsRsSlSr)    return AudioChannelSet::create7point0();

  1164. +        else if (arr == Vst2::vstSpeakerConfigTypeLRCLsRsLcRc)    return AudioChannelSet::create7point0SDDS();

  1165. +        else if (arr == Vst2::vstSpeakerConfigTypeLRCLfeLsRsSlSr) return AudioChannelSet::create7point1();

  1166. +        else if (arr == Vst2::vstSpeakerConfigTypeLRCLfeLsRsLcRc) return AudioChannelSet::create7point1SDDS();

  1167. +        else if (arr == Vst2::vstSpeakerConfigTypeLRLsRs)         return AudioChannelSet::quadraphonic();

  1168. +

  1169. +        for (const Mapping* m = getMappings(); m->vst2 != Vst2::vstSpeakerConfigTypeEmpty; ++m)

  1170.          {

  1171.              if (m->vst2 == arr)

  1172.              {

  1173. @@ -100,41 +100,41 @@ struct SpeakerMappings  : private AudioChannelSet // (inheritance only to give e

  1174.          return AudioChannelSet::discreteChannels (fallbackNumChannels);

  1175.      }

  1176.  

  1177. -    static AudioChannelSet vstArrangementTypeToChannelSet (const Vst2::VstSpeakerArrangement& arr)

  1178. +    static AudioChannelSet vstArrangementTypeToChannelSet (const Vst2::VstSpeakerConfiguration& arr)

  1179.      {

  1180. -        return vstArrangementTypeToChannelSet (arr.type, arr.numChannels);

  1181. +        return vstArrangementTypeToChannelSet (arr.type, arr.numberOfChannels);

  1182.      }

  1183.  

  1184.      static int32 channelSetToVstArrangementType (AudioChannelSet channels)

  1185.      {

  1186. -        if      (channels == AudioChannelSet::disabled())           return Vst2::kSpeakerArrEmpty;

  1187. -        else if (channels == AudioChannelSet::mono())               return Vst2::kSpeakerArrMono;

  1188. -        else if (channels == AudioChannelSet::stereo())             return Vst2::kSpeakerArrStereo;

  1189. -        else if (channels == AudioChannelSet::createLCR())          return Vst2::kSpeakerArr30Cine;

  1190. -        else if (channels == AudioChannelSet::createLRS())          return Vst2::kSpeakerArr30Music;

  1191. -        else if (channels == AudioChannelSet::createLCRS())         return Vst2::kSpeakerArr40Cine;

  1192. -        else if (channels == AudioChannelSet::create5point0())      return Vst2::kSpeakerArr50;

  1193. -        else if (channels == AudioChannelSet::create5point1())      return Vst2::kSpeakerArr51;

  1194. -        else if (channels == AudioChannelSet::create6point0())      return Vst2::kSpeakerArr60Cine;

  1195. -        else if (channels == AudioChannelSet::create6point1())      return Vst2::kSpeakerArr61Cine;

  1196. -        else if (channels == AudioChannelSet::create6point0Music()) return Vst2::kSpeakerArr60Music;

  1197. -        else if (channels == AudioChannelSet::create6point1Music()) return Vst2::kSpeakerArr61Music;

  1198. -        else if (channels == AudioChannelSet::create7point0())      return Vst2::kSpeakerArr70Music;

  1199. -        else if (channels == AudioChannelSet::create7point0SDDS())  return Vst2::kSpeakerArr70Cine;

  1200. -        else if (channels == AudioChannelSet::create7point1())      return Vst2::kSpeakerArr71Music;

  1201. -        else if (channels == AudioChannelSet::create7point1SDDS())  return Vst2::kSpeakerArr71Cine;

  1202. -        else if (channels == AudioChannelSet::quadraphonic())       return Vst2::kSpeakerArr40Music;

  1203. +        if      (channels == AudioChannelSet::disabled())           return Vst2::vstSpeakerConfigTypeEmpty;

  1204. +        else if (channels == AudioChannelSet::mono())               return Vst2::vstSpeakerConfigTypeMono;

  1205. +        else if (channels == AudioChannelSet::stereo())             return Vst2::vstSpeakerConfigTypeLR;

  1206. +        else if (channels == AudioChannelSet::createLCR())          return Vst2::vstSpeakerConfigTypeLRC;

  1207. +        else if (channels == AudioChannelSet::createLRS())          return Vst2::vstSpeakerConfigTypeLRS;

  1208. +        else if (channels == AudioChannelSet::createLCRS())         return Vst2::vstSpeakerConfigTypeLRCS;

  1209. +        else if (channels == AudioChannelSet::create5point0())      return Vst2::vstSpeakerConfigTypeLRCLsRs;

  1210. +        else if (channels == AudioChannelSet::create5point1())      return Vst2::vstSpeakerConfigTypeLRCLfeLsRs;

  1211. +        else if (channels == AudioChannelSet::create6point0())      return Vst2::vstSpeakerConfigTypeLRCLsRsCs;

  1212. +        else if (channels == AudioChannelSet::create6point1())      return Vst2::vstSpeakerConfigTypeLRCLfeLsRsCs;

  1213. +        else if (channels == AudioChannelSet::create6point0Music()) return Vst2::vstSpeakerConfigTypeLRLsRsSlSr;

  1214. +        else if (channels == AudioChannelSet::create6point1Music()) return Vst2::vstSpeakerConfigTypeLRLfeLsRsSlSr;

  1215. +        else if (channels == AudioChannelSet::create7point0())      return Vst2::vstSpeakerConfigTypeLRCLsRsSlSr;

  1216. +        else if (channels == AudioChannelSet::create7point0SDDS())  return Vst2::vstSpeakerConfigTypeLRCLsRsLcRc;

  1217. +        else if (channels == AudioChannelSet::create7point1())      return Vst2::vstSpeakerConfigTypeLRCLfeLsRsSlSr;

  1218. +        else if (channels == AudioChannelSet::create7point1SDDS())  return Vst2::vstSpeakerConfigTypeLRCLfeLsRsLcRc;

  1219. +        else if (channels == AudioChannelSet::quadraphonic())       return Vst2::vstSpeakerConfigTypeLRLsRs;

  1220.  

  1221.          Array<AudioChannelSet::ChannelType> chans (channels.getChannelTypes());

  1222.  

  1223.          if (channels == AudioChannelSet::disabled())

  1224. -            return Vst2::kSpeakerArrEmpty;

  1225. +            return Vst2::vstSpeakerConfigTypeEmpty;

  1226.  

  1227. -        for (const Mapping* m = getMappings(); m->vst2 != Vst2::kSpeakerArrEmpty; ++m)

  1228. +        for (const Mapping* m = getMappings(); m->vst2 != Vst2::vstSpeakerConfigTypeEmpty; ++m)

  1229.              if (m->matches (chans))

  1230.                  return m->vst2;

  1231.  

  1232. -        return Vst2::kSpeakerArrUserDefined;

  1233. +        return Vst2::vstSpeakerConfigTypeUser;

  1234.      }

  1235.  

  1236.      /** Class to hold a speaker configuration */

  1237. @@ -142,7 +142,7 @@ struct SpeakerMappings  : private AudioChannelSet // (inheritance only to give e

  1238.      {

  1239.      public:

  1240.          VstSpeakerConfigurationHolder()                                            { clear(); }

  1241. -        VstSpeakerConfigurationHolder (const Vst2::VstSpeakerArrangement& vstConfig)   { operator= (vstConfig); }

  1242. +        VstSpeakerConfigurationHolder (const Vst2::VstSpeakerConfiguration& vstConfig)   { operator= (vstConfig); }

  1243.          VstSpeakerConfigurationHolder (const VstSpeakerConfigurationHolder& other) { operator= (other.get()); }

  1244.          VstSpeakerConfigurationHolder (VstSpeakerConfigurationHolder&& other)

  1245.              : storage (std::move (other.storage)) { other.clear(); }

  1246. @@ -150,29 +150,29 @@ struct SpeakerMappings  : private AudioChannelSet // (inheritance only to give e

  1247.          VstSpeakerConfigurationHolder (const AudioChannelSet& channels)

  1248.          {

  1249.              auto numberOfChannels = channels.size();

  1250. -            Vst2::VstSpeakerArrangement& dst = *allocate (numberOfChannels);

  1251. +            Vst2::VstSpeakerConfiguration& dst = *allocate (numberOfChannels);

  1252.  

  1253.              dst.type = channelSetToVstArrangementType (channels);

  1254. -            dst.numChannels = numberOfChannels;

  1255. +            dst.numberOfChannels = numberOfChannels;

  1256.  

  1257. -            for (int i = 0; i < dst.numChannels; ++i)

  1258. +            for (int i = 0; i < dst.numberOfChannels; ++i)

  1259.              {

  1260. -                Vst2::VstSpeakerProperties& speaker = dst.speakers[i];

  1261. +                Vst2::VstIndividualSpeakerInfo& speaker = dst.speakers[i];

  1262.  

  1263. -                zeromem (&speaker, sizeof (Vst2::VstSpeakerProperties));

  1264. +                zeromem (&speaker, sizeof (Vst2::VstIndividualSpeakerInfo));

  1265.                  speaker.type = getSpeakerType (channels.getTypeOfChannel (i));

  1266.              }

  1267.          }

  1268.  

  1269.          VstSpeakerConfigurationHolder& operator= (const VstSpeakerConfigurationHolder& vstConfig) { return operator=(vstConfig.get()); }

  1270. -        VstSpeakerConfigurationHolder& operator= (const Vst2::VstSpeakerArrangement& vstConfig)

  1271. +        VstSpeakerConfigurationHolder& operator= (const Vst2::VstSpeakerConfiguration& vstConfig)

  1272.          {

  1273. -            Vst2::VstSpeakerArrangement& dst = *allocate (vstConfig.numChannels);

  1274. +            Vst2::VstSpeakerConfiguration& dst = *allocate (vstConfig.numberOfChannels);

  1275.  

  1276.              dst.type             = vstConfig.type;

  1277. -            dst.numChannels      = vstConfig.numChannels;

  1278. +            dst.numberOfChannels = vstConfig.numberOfChannels;

  1279.  

  1280. -            for (int i = 0; i < dst.numChannels; ++i)

  1281. +            for (int i = 0; i < dst.numberOfChannels; ++i)

  1282.                  dst.speakers[i] = vstConfig.speakers[i];

  1283.  

  1284.              return *this;

  1285. @@ -186,17 +186,17 @@ struct SpeakerMappings  : private AudioChannelSet // (inheritance only to give e

  1286.              return *this;

  1287.          }

  1288.  

  1289. -        const Vst2::VstSpeakerArrangement& get() const { return *storage.get(); }

  1290. +        const Vst2::VstSpeakerConfiguration& get() const { return *storage.get(); }

  1291.  

  1292.      private:

  1293.          JUCE_LEAK_DETECTOR (VstSpeakerConfigurationHolder)

  1294.  

  1295. -        HeapBlock<Vst2::VstSpeakerArrangement> storage;

  1296. +        HeapBlock<Vst2::VstSpeakerConfiguration> storage;

  1297.  

  1298. -        Vst2::VstSpeakerArrangement* allocate (int numChannels)

  1299. +        Vst2::VstSpeakerConfiguration* allocate (int numChannels)

  1300.          {

  1301. -            auto arrangementSize = (size_t) (jmax (8, numChannels) - 8) * sizeof (Vst2::VstSpeakerProperties)

  1302. -                                    + sizeof (Vst2::VstSpeakerArrangement);

  1303. +            auto arrangementSize = (size_t) (jmax (8, numChannels) - 8) * sizeof (Vst2::VstIndividualSpeakerInfo)

  1304. +                                    + sizeof (Vst2::VstSpeakerConfiguration);

  1305.  

  1306.              storage.malloc (1, arrangementSize);

  1307.              return storage.get();

  1308. @@ -204,10 +204,10 @@ struct SpeakerMappings  : private AudioChannelSet // (inheritance only to give e

  1309.  

  1310.          void clear()

  1311.          {

  1312. -            Vst2::VstSpeakerArrangement& dst = *allocate (0);

  1313. +            Vst2::VstSpeakerConfiguration& dst = *allocate (0);

  1314.  

  1315. -            dst.type = Vst2::kSpeakerArrEmpty;

  1316. -            dst.numChannels = 0;

  1317. +            dst.type = Vst2::vstSpeakerConfigTypeEmpty;

  1318. +            dst.numberOfChannels = 0;

  1319.          }

  1320.      };

  1321.  

  1322. @@ -215,36 +215,36 @@ struct SpeakerMappings  : private AudioChannelSet // (inheritance only to give e

  1323.      {

  1324.          static const Mapping mappings[] =

  1325.          {

  1326. -            { Vst2::kSpeakerArrMono,           { centre, unknown } },

  1327. -            { Vst2::kSpeakerArrStereo,         { left, right, unknown } },

  1328. -            { Vst2::kSpeakerArrStereoSurround, { leftSurround, rightSurround, unknown } },

  1329. -            { Vst2::kSpeakerArrStereoCenter,   { leftCentre, rightCentre, unknown } },

  1330. -            { Vst2::kSpeakerArrStereoSide,     { leftSurroundRear, rightSurroundRear, unknown } },

  1331. -            { Vst2::kSpeakerArrStereoCLfe,     { centre, LFE, unknown } },

  1332. -            { Vst2::kSpeakerArr30Cine,         { left, right, centre, unknown } },

  1333. -            { Vst2::kSpeakerArr30Music,        { left, right, surround, unknown } },

  1334. -            { Vst2::kSpeakerArr31Cine,         { left, right, centre, LFE, unknown } },

  1335. -            { Vst2::kSpeakerArr31Music,        { left, right, LFE, surround, unknown } },

  1336. -            { Vst2::kSpeakerArr40Cine,         { left, right, centre, surround, unknown } },

  1337. -            { Vst2::kSpeakerArr40Music,        { left, right, leftSurround, rightSurround, unknown } },

  1338. -            { Vst2::kSpeakerArr41Cine,         { left, right, centre, LFE, surround, unknown } },

  1339. -            { Vst2::kSpeakerArr41Music,        { left, right, LFE, leftSurround, rightSurround, unknown } },

  1340. -            { Vst2::kSpeakerArr50,             { left, right, centre, leftSurround, rightSurround, unknown } },

  1341. -            { Vst2::kSpeakerArr51,             { left, right, centre, LFE, leftSurround, rightSurround, unknown } },

  1342. -            { Vst2::kSpeakerArr60Cine,         { left, right, centre, leftSurround, rightSurround, surround, unknown } },

  1343. -            { Vst2::kSpeakerArr60Music,        { left, right, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  1344. -            { Vst2::kSpeakerArr61Cine,         { left, right, centre, LFE, leftSurround, rightSurround, surround, unknown } },

  1345. -            { Vst2::kSpeakerArr61Music,        { left, right, LFE, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  1346. -            { Vst2::kSpeakerArr70Cine,         { left, right, centre, leftSurround, rightSurround, topFrontLeft, topFrontRight, unknown } },

  1347. -            { Vst2::kSpeakerArr70Music,        { left, right, centre, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  1348. -            { Vst2::kSpeakerArr71Cine,         { left, right, centre, LFE, leftSurround, rightSurround, topFrontLeft, topFrontRight, unknown } },

  1349. -            { Vst2::kSpeakerArr71Music,        { left, right, centre, LFE, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  1350. -            { Vst2::kSpeakerArr80Cine,         { left, right, centre, leftSurround, rightSurround, topFrontLeft, topFrontRight, surround, unknown } },

  1351. -            { Vst2::kSpeakerArr80Music,        { left, right, centre, leftSurround, rightSurround, surround, leftSurroundRear, rightSurroundRear, unknown } },

  1352. -            { Vst2::kSpeakerArr81Cine,  { left, right, centre, LFE, leftSurround, rightSurround, topFrontLeft, topFrontRight, surround, unknown } },

  1353. -            { Vst2::kSpeakerArr81Music, { left, right, centre, LFE, leftSurround, rightSurround, surround, leftSurroundRear, rightSurroundRear, unknown } },

  1354. -            { Vst2::kSpeakerArr102,     { left, right, centre, LFE, leftSurround, rightSurround, topFrontLeft, topFrontCentre, topFrontRight, topRearLeft, topRearRight, LFE2, unknown } },

  1355. -            { Vst2::kSpeakerArrEmpty,          { unknown } }

  1356. +            { Vst2::vstSpeakerConfigTypeMono,                          { centre, unknown } },

  1357. +            { Vst2::vstSpeakerConfigTypeLR,                            { left, right, unknown } },

  1358. +            { Vst2::vstSpeakerConfigTypeLsRs,                          { leftSurround, rightSurround, unknown } },

  1359. +            { Vst2::vstSpeakerConfigTypeLcRc,                          { leftCentre, rightCentre, unknown } },

  1360. +            { Vst2::vstSpeakerConfigTypeSlSr,                          { leftSurroundRear, rightSurroundRear, unknown } },

  1361. +            { Vst2::vstSpeakerConfigTypeCLfe,                          { centre, LFE, unknown } },

  1362. +            { Vst2::vstSpeakerConfigTypeLRC,                           { left, right, centre, unknown } },

  1363. +            { Vst2::vstSpeakerConfigTypeLRS,                           { left, right, surround, unknown } },

  1364. +            { Vst2::vstSpeakerConfigTypeLRCLfe,                        { left, right, centre, LFE, unknown } },

  1365. +            { Vst2::vstSpeakerConfigTypeLRLfeS,                        { left, right, LFE, surround, unknown } },

  1366. +            { Vst2::vstSpeakerConfigTypeLRCS,                          { left, right, centre, surround, unknown } },

  1367. +            { Vst2::vstSpeakerConfigTypeLRLsRs,                        { left, right, leftSurround, rightSurround, unknown } },

  1368. +            { Vst2::vstSpeakerConfigTypeLRCLfeS,                       { left, right, centre, LFE, surround, unknown } },

  1369. +            { Vst2::vstSpeakerConfigTypeLRLfeLsRs,                     { left, right, LFE, leftSurround, rightSurround, unknown } },

  1370. +            { Vst2::vstSpeakerConfigTypeLRCLsRs,                       { left, right, centre, leftSurround, rightSurround, unknown } },

  1371. +            { Vst2::vstSpeakerConfigTypeLRCLfeLsRs,                    { left, right, centre, LFE, leftSurround, rightSurround, unknown } },

  1372. +            { Vst2::vstSpeakerConfigTypeLRCLsRsCs,                     { left, right, centre, leftSurround, rightSurround, surround, unknown } },

  1373. +            { Vst2::vstSpeakerConfigTypeLRLsRsSlSr,                    { left, right, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  1374. +            { Vst2::vstSpeakerConfigTypeLRCLfeLsRsCs,                  { left, right, centre, LFE, leftSurround, rightSurround, surround, unknown } },

  1375. +            { Vst2::vstSpeakerConfigTypeLRLfeLsRsSlSr,                 { left, right, LFE, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  1376. +            { Vst2::vstSpeakerConfigTypeLRCLsRsLcRc,                   { left, right, centre, leftSurround, rightSurround, topFrontLeft, topFrontRight, unknown } },

  1377. +            { Vst2::vstSpeakerConfigTypeLRCLsRsSlSr,                   { left, right, centre, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  1378. +            { Vst2::vstSpeakerConfigTypeLRCLfeLsRsLcRc,                { left, right, centre, LFE, leftSurround, rightSurround, topFrontLeft, topFrontRight, unknown } },

  1379. +            { Vst2::vstSpeakerConfigTypeLRCLfeLsRsSlSr,                { left, right, centre, LFE, leftSurround, rightSurround, leftSurroundRear, rightSurroundRear, unknown } },

  1380. +            { Vst2::vstSpeakerConfigTypeLRCLsRsLcRcCs,                 { left, right, centre, leftSurround, rightSurround, topFrontLeft, topFrontRight, surround, unknown } },

  1381. +            { Vst2::vstSpeakerConfigTypeLRCLsRsCsSlSr,                 { left, right, centre, leftSurround, rightSurround, surround, leftSurroundRear, rightSurroundRear, unknown } },

  1382. +            { Vst2::vstSpeakerConfigTypeLRCLfeLsRsLcRcCs,              { left, right, centre, LFE, leftSurround, rightSurround, topFrontLeft, topFrontRight, surround, unknown } },

  1383. +            { Vst2::vstSpeakerConfigTypeLRCLfeLsRsCsSlSr,              { left, right, centre, LFE, leftSurround, rightSurround, surround, leftSurroundRear, rightSurroundRear, unknown } },

  1384. +            { Vst2::vstSpeakerConfigTypeLRCLfeLsRsTflTfcTfrTrlTrrLfe2, { left, right, centre, LFE, leftSurround, rightSurround, topFrontLeft, topFrontCentre, topFrontRight, topRearLeft, topRearRight, LFE2, unknown } },

  1385. +            { Vst2::vstSpeakerConfigTypeEmpty,                         { unknown } }

  1386.          };

  1387.  

  1388.          return mappings;

  1389. @@ -254,25 +254,25 @@ struct SpeakerMappings  : private AudioChannelSet // (inheritance only to give e

  1390.      {

  1391.          switch (type)

  1392.          {

  1393. -            case AudioChannelSet::left:              return Vst2::kSpeakerL;

  1394. -            case AudioChannelSet::right:             return Vst2::kSpeakerR;

  1395. -            case AudioChannelSet::centre:            return Vst2::kSpeakerC;

  1396. -            case AudioChannelSet::LFE:               return Vst2::kSpeakerLfe;

  1397. -            case AudioChannelSet::leftSurround:      return Vst2::kSpeakerLs;

  1398. -            case AudioChannelSet::rightSurround:     return Vst2::kSpeakerRs;

  1399. -            case AudioChannelSet::leftCentre:        return Vst2::kSpeakerLc;

  1400. -            case AudioChannelSet::rightCentre:       return Vst2::kSpeakerRc;

  1401. -            case AudioChannelSet::surround:          return Vst2::kSpeakerS;

  1402. -            case AudioChannelSet::leftSurroundRear:  return Vst2::kSpeakerSl;

  1403. -            case AudioChannelSet::rightSurroundRear: return Vst2::kSpeakerSr;

  1404. -            case AudioChannelSet::topMiddle:         return Vst2::kSpeakerTm;

  1405. -            case AudioChannelSet::topFrontLeft:      return Vst2::kSpeakerTfl;

  1406. -            case AudioChannelSet::topFrontCentre:    return Vst2::kSpeakerTfc;

  1407. -            case AudioChannelSet::topFrontRight:     return Vst2::kSpeakerTfr;

  1408. -            case AudioChannelSet::topRearLeft:       return Vst2::kSpeakerTrl;

  1409. -            case AudioChannelSet::topRearCentre:     return Vst2::kSpeakerTrc;

  1410. -            case AudioChannelSet::topRearRight:      return Vst2::kSpeakerTrr;

  1411. -            case AudioChannelSet::LFE2:              return Vst2::kSpeakerLfe2;

  1412. +            case AudioChannelSet::left:              return Vst2::vstIndividualSpeakerTypeLeft;

  1413. +            case AudioChannelSet::right:             return Vst2::vstIndividualSpeakerTypeRight;

  1414. +            case AudioChannelSet::centre:            return Vst2::vstIndividualSpeakerTypeCentre;

  1415. +            case AudioChannelSet::LFE:               return Vst2::vstIndividualSpeakerTypeLFE;

  1416. +            case AudioChannelSet::leftSurround:      return Vst2::vstIndividualSpeakerTypeLeftSurround;

  1417. +            case AudioChannelSet::rightSurround:     return Vst2::vstIndividualSpeakerTypeRightSurround;

  1418. +            case AudioChannelSet::leftCentre:        return Vst2::vstIndividualSpeakerTypeLeftCentre;

  1419. +            case AudioChannelSet::rightCentre:       return Vst2::vstIndividualSpeakerTypeRightCentre;

  1420. +            case AudioChannelSet::surround:          return Vst2::vstIndividualSpeakerTypeSurround;

  1421. +            case AudioChannelSet::leftSurroundRear:  return Vst2::vstIndividualSpeakerTypeLeftRearSurround;

  1422. +            case AudioChannelSet::rightSurroundRear: return Vst2::vstIndividualSpeakerTypeRightRearSurround;

  1423. +            case AudioChannelSet::topMiddle:         return Vst2::vstIndividualSpeakerTypeTopMiddle;

  1424. +            case AudioChannelSet::topFrontLeft:      return Vst2::vstIndividualSpeakerTypeTopFrontLeft;

  1425. +            case AudioChannelSet::topFrontCentre:    return Vst2::vstIndividualSpeakerTypeTopFrontCentre;

  1426. +            case AudioChannelSet::topFrontRight:     return Vst2::vstIndividualSpeakerTypeTopFrontRight;

  1427. +            case AudioChannelSet::topRearLeft:       return Vst2::vstIndividualSpeakerTypeTopRearLeft;

  1428. +            case AudioChannelSet::topRearCentre:     return Vst2::vstIndividualSpeakerTypeTopRearCentre;

  1429. +            case AudioChannelSet::topRearRight:      return Vst2::vstIndividualSpeakerTypeTopRearRight;

  1430. +            case AudioChannelSet::LFE2:              return Vst2::vstIndividualSpeakerTypeLFE2;

  1431.              default: break;

  1432.          }

  1433.  

  1434. @@ -283,25 +283,25 @@ struct SpeakerMappings  : private AudioChannelSet // (inheritance only to give e

  1435.      {

  1436.          switch (type)

  1437.          {

  1438. -            case Vst2::kSpeakerL:      return AudioChannelSet::left;

  1439. -            case Vst2::kSpeakerR:      return AudioChannelSet::right;

  1440. -            case Vst2::kSpeakerC:      return AudioChannelSet::centre;

  1441. -            case Vst2::kSpeakerLfe:    return AudioChannelSet::LFE;

  1442. -            case Vst2::kSpeakerLs:     return AudioChannelSet::leftSurround;

  1443. -            case Vst2::kSpeakerRs:     return AudioChannelSet::rightSurround;

  1444. -            case Vst2::kSpeakerLc:     return AudioChannelSet::leftCentre;

  1445. -            case Vst2::kSpeakerRc:     return AudioChannelSet::rightCentre;

  1446. -            case Vst2::kSpeakerS:      return AudioChannelSet::surround;

  1447. -            case Vst2::kSpeakerSl:     return AudioChannelSet::leftSurroundRear;

  1448. -            case Vst2::kSpeakerSr:     return AudioChannelSet::rightSurroundRear;

  1449. -            case Vst2::kSpeakerTm:     return AudioChannelSet::topMiddle;

  1450. -            case Vst2::kSpeakerTfl:    return AudioChannelSet::topFrontLeft;

  1451. -            case Vst2::kSpeakerTfc:    return AudioChannelSet::topFrontCentre;

  1452. -            case Vst2::kSpeakerTfr:    return AudioChannelSet::topFrontRight;

  1453. -            case Vst2::kSpeakerTrl:    return AudioChannelSet::topRearLeft;

  1454. -            case Vst2::kSpeakerTrc:    return AudioChannelSet::topRearCentre;

  1455. -            case Vst2::kSpeakerTrr:    return AudioChannelSet::topRearRight;

  1456. -            case Vst2::kSpeakerLfe2:   return AudioChannelSet::LFE2;

  1457. +            case Vst2::vstIndividualSpeakerTypeLeft:                 return AudioChannelSet::left;

  1458. +            case Vst2::vstIndividualSpeakerTypeRight:                return AudioChannelSet::right;

  1459. +            case Vst2::vstIndividualSpeakerTypeCentre:               return AudioChannelSet::centre;

  1460. +            case Vst2::vstIndividualSpeakerTypeLFE:                  return AudioChannelSet::LFE;

  1461. +            case Vst2::vstIndividualSpeakerTypeLeftSurround:         return AudioChannelSet::leftSurround;

  1462. +            case Vst2::vstIndividualSpeakerTypeRightSurround:        return AudioChannelSet::rightSurround;

  1463. +            case Vst2::vstIndividualSpeakerTypeLeftCentre:           return AudioChannelSet::leftCentre;

  1464. +            case Vst2::vstIndividualSpeakerTypeRightCentre:          return AudioChannelSet::rightCentre;

  1465. +            case Vst2::vstIndividualSpeakerTypeSurround:             return AudioChannelSet::surround;

  1466. +            case Vst2::vstIndividualSpeakerTypeLeftRearSurround:     return AudioChannelSet::leftSurroundRear;

  1467. +            case Vst2::vstIndividualSpeakerTypeRightRearSurround:    return AudioChannelSet::rightSurroundRear;

  1468. +            case Vst2::vstIndividualSpeakerTypeTopMiddle:            return AudioChannelSet::topMiddle;

  1469. +            case Vst2::vstIndividualSpeakerTypeTopFrontLeft:         return AudioChannelSet::topFrontLeft;

  1470. +            case Vst2::vstIndividualSpeakerTypeTopFrontCentre:       return AudioChannelSet::topFrontCentre;

  1471. +            case Vst2::vstIndividualSpeakerTypeTopFrontRight:        return AudioChannelSet::topFrontRight;

  1472. +            case Vst2::vstIndividualSpeakerTypeTopRearLeft:          return AudioChannelSet::topRearLeft;

  1473. +            case Vst2::vstIndividualSpeakerTypeTopRearCentre:        return AudioChannelSet::topRearCentre;

  1474. +            case Vst2::vstIndividualSpeakerTypeTopRearRight:         return AudioChannelSet::topRearRight;

  1475. +            case Vst2::vstIndividualSpeakerTypeLFE2:                 return AudioChannelSet::LFE2;

  1476.              default: break;

  1477.          }

  1478.  

  1479. diff --git a/modules/juce_audio_processors/format_types/juce_VSTMidiEventList.h b/modules/juce_audio_processors/format_types/juce_VSTMidiEventList.h

  1480. index 3b6d316..1543ad1 100644

  1481. --- a/modules/juce_audio_processors/format_types/juce_VSTMidiEventList.h

  1482. +++ b/modules/juce_audio_processors/format_types/juce_VSTMidiEventList.h

  1483. @@ -58,7 +58,7 @@ public:

  1484.          numEventsUsed = 0;

  1485.  

  1486.          if (events != nullptr)

  1487. -            events->numEvents = 0;

  1488. +            events->numberOfEvents = 0;

  1489.      }

  1490.  

  1491.      void addEvent (const void* const midiData, int numBytes, int frameOffset)

  1492. @@ -67,50 +67,50 @@ public:

  1493.  

  1494.          void* const ptr = (Vst2::VstMidiEvent*) (events->events [numEventsUsed]);

  1495.          auto* const e = (Vst2::VstMidiEvent*) ptr;

  1496. -        events->numEvents = ++numEventsUsed;

  1497. +        events->numberOfEvents = ++numEventsUsed;

  1498.  

  1499.          if (numBytes <= 4)

  1500.          {

  1501. -            if (e->type == Vst2::kVstSysExType)

  1502. +            if (e->type == Vst2::vstSysExEventType)

  1503.              {

  1504. -                delete[] (((Vst2::VstMidiSysexEvent*) ptr)->sysexDump);

  1505. -                e->type = Vst2::kVstMidiType;

  1506. -                e->byteSize = sizeof (Vst2::VstMidiEvent);

  1507. -                e->noteLength = 0;

  1508. -                e->noteOffset = 0;

  1509. -                e->detune = 0;

  1510. -                e->noteOffVelocity = 0;

  1511. +                delete[] (((Vst2::VstSysExEvent*) ptr)->sysExDump);

  1512. +                e->type = Vst2::vstMidiEventType;

  1513. +                e->size = sizeof (Vst2::VstMidiEvent);

  1514. +                e->noteSampleLength = 0;

  1515. +                e->noteSampleOffset = 0;

  1516. +                e->tuning = 0;

  1517. +                e->noteVelocityOff = 0;

  1518.              }

  1519.  

  1520. -            e->deltaFrames = frameOffset;

  1521. +            e->sampleOffset = frameOffset;

  1522.              memcpy (e->midiData, midiData, (size_t) numBytes);

  1523.          }

  1524.          else

  1525.          {

  1526. -            auto* const se = (Vst2::VstMidiSysexEvent*) ptr;

  1527. +            auto* const se = (Vst2::VstSysExEvent*) ptr;

  1528.  

  1529. -            if (se->type == Vst2::kVstSysExType)

  1530. -                delete[] se->sysexDump;

  1531. +            if (se->type == Vst2::vstSysExEventType)

  1532. +                delete[] se->sysExDump;

  1533.  

  1534. -            se->sysexDump = new char [(size_t) numBytes];

  1535. -            memcpy (se->sysexDump, midiData, (size_t) numBytes);

  1536. +            se->sysExDump = new char [(size_t) numBytes];

  1537. +            memcpy (se->sysExDump, midiData, (size_t) numBytes);

  1538.  

  1539. -            se->type = Vst2::kVstSysExType;

  1540. -            se->byteSize = sizeof (Vst2::VstMidiSysexEvent);

  1541. -            se->deltaFrames = frameOffset;

  1542. +            se->type = Vst2::vstSysExEventType;

  1543. +            se->size = sizeof (Vst2::VstSysExEvent);

  1544. +            se->offsetSamples = frameOffset;

  1545.              se->flags = 0;

  1546. -            se->dumpBytes = numBytes;

  1547. -            se->resvd1 = 0;

  1548. -            se->resvd2 = 0;

  1549. +            se->sysExDumpSize = numBytes;

  1550. +            se->future1 = 0;

  1551. +            se->future2 = 0;

  1552.          }

  1553.      }

  1554.  

  1555.      //==============================================================================

  1556.      // Handy method to pull the events out of an event buffer supplied by the host

  1557.      // or plugin.

  1558. -    static void addEventsToMidiBuffer (const Vst2::VstEvents* events, MidiBuffer& dest)

  1559. +    static void addEventsToMidiBuffer (const Vst2::VstEventBlock* events, MidiBuffer& dest)

  1560.      {

  1561. -        for (int i = 0; i < events->numEvents; ++i)

  1562. +        for (int i = 0; i < events->numberOfEvents; ++i)

  1563.          {

  1564.              const Vst2::VstEvent* const e = events->events[i];

  1565.  

  1566. @@ -118,17 +118,17 @@ public:

  1567.              {

  1568.                  const void* const ptr = events->events[i];

  1569.  

  1570. -                if (e->type == Vst2::kVstMidiType)

  1571. +                if (e->type == Vst2::vstMidiEventType)

  1572.                  {

  1573.                      dest.addEvent ((const juce::uint8*) ((const Vst2::VstMidiEvent*) ptr)->midiData,

  1574. -                                   4, e->deltaFrames);

  1575. +                                   4, e->sampleOffset);

  1576.                  }

  1577. -                else if (e->type == Vst2::kVstSysExType)

  1578. +                else if (e->type == Vst2::vstSysExEventType)

  1579.                  {

  1580. -                    const auto* se = (const Vst2::VstMidiSysexEvent*) ptr;

  1581. -                    dest.addEvent ((const juce::uint8*) se->sysexDump,

  1582. -                                   (int) se->dumpBytes,

  1583. -                                   e->deltaFrames);

  1584. +                    const auto* se = (const Vst2::VstSysExEvent*) ptr;

  1585. +                    dest.addEvent ((const juce::uint8*) se->sysExDump,

  1586. +                                   (int) se->sysExDumpSize,

  1587. +                                   e->sampleOffset);

  1588.                  }

  1589.              }

  1590.          }

  1591. @@ -169,25 +169,25 @@ public:

  1592.      }

  1593.  

  1594.      //==============================================================================

  1595. -    HeapBlock<Vst2::VstEvents> events;

  1596. +    HeapBlock<Vst2::VstEventBlock> events;

  1597.  

  1598.  private:

  1599.      int numEventsUsed, numEventsAllocated;

  1600.  

  1601.      static Vst2::VstEvent* allocateVSTEvent()

  1602.      {

  1603. -        auto e = (Vst2::VstEvent*) std::calloc (1, sizeof (Vst2::VstMidiEvent) > sizeof (Vst2::VstMidiSysexEvent) ? sizeof (Vst2::VstMidiEvent)

  1604. -                                                                                            : sizeof (Vst2::VstMidiSysexEvent));

  1605. -        e->type = Vst2::kVstMidiType;

  1606. -        e->byteSize = sizeof (Vst2::VstMidiEvent);

  1607. +        auto e = (Vst2::VstEvent*) std::calloc (1, sizeof (Vst2::VstMidiEvent) > sizeof (Vst2::VstSysExEvent) ? sizeof (Vst2::VstMidiEvent)

  1608. +                                                                                            : sizeof (Vst2::VstSysExEvent));

  1609. +        e->type = Vst2::vstMidiEventType;

  1610. +        e->size = sizeof (Vst2::VstMidiEvent);

  1611.          return e;

  1612.      }

  1613.  

  1614.      static void freeVSTEvent (Vst2::VstEvent* e)

  1615.      {

  1616. -        if (e->type == Vst2::kVstSysExType)

  1617. +        if (e->type == Vst2::vstSysExEventType)

  1618.          {

  1619. -            delete[] (reinterpret_cast<Vst2::VstMidiSysexEvent*> (e)->sysexDump);

  1620. +            delete[] (reinterpret_cast<Vst2::VstSysExEvent*> (e)->sysExDump);

  1621.          }

  1622.  

  1623.          std::free (e);

  1624. diff --git a/modules/juce_audio_processors/format_types/juce_VSTPluginFormat.cpp b/modules/juce_audio_processors/format_types/juce_VSTPluginFormat.cpp

  1625. index bdc935f..ce6b867 100644

  1626. --- a/modules/juce_audio_processors/format_types/juce_VSTPluginFormat.cpp

  1627. +++ b/modules/juce_audio_processors/format_types/juce_VSTPluginFormat.cpp

  1628. @@ -49,7 +49,6 @@

  1629.  #endif

  1630.  

  1631.  #define VST_FORCE_DEPRECATED 0

  1632. -#define JUCE_VSTINTERFACE_H_INCLUDED 1

  1633.  

  1634.  namespace Vst2

  1635.  {

  1636. @@ -58,8 +57,7 @@ namespace Vst2

  1637.  // paths or use the "VST (Legacy) SDK Folder" field in the Projucer. The VST2

  1638.  // SDK can be obtained from the vstsdk3610_11_06_2018_build_37 (or older) VST3

  1639.  // SDK or JUCE version 5.3.2.

  1640. -#include <pluginterfaces/vst2.x/aeffect.h>

  1641. -#include <pluginterfaces/vst2.x/aeffectx.h>

  1642. +#include "../../juce_audio_processors/format_types/juce_VSTInterface.h"

  1643.  }

  1644.  

  1645.  #include "juce_VSTCommon.h"

  1646. @@ -98,7 +96,7 @@ namespace Vst2

  1647.  #endif

  1648.  

  1649.  #ifndef JUCE_VST_WRAPPER_INVOKE_MAIN

  1650. -#define JUCE_VST_WRAPPER_INVOKE_MAIN  effect = module->moduleMain ((Vst2::audioMasterCallback) &audioMaster);

  1651. + #define JUCE_VST_WRAPPER_INVOKE_MAIN  effect = module->moduleMain (&audioMaster);

  1652.  #endif

  1653.  

  1654.  //==============================================================================

  1655. @@ -235,8 +233,8 @@ namespace

  1656.  }

  1657.  

  1658.  //==============================================================================

  1659. -typedef Vst2::AEffect* (VSTCALLBACK *MainCall) (Vst2::audioMasterCallback);

  1660. -static pointer_sized_int VSTCALLBACK audioMaster (Vst2::AEffect*, int32, int32, pointer_sized_int, void*, float);

  1661. +typedef Vst2::VstEffectInterface* (VSTINTERFACECALL *MainCall) (Vst2::VstHostCallback);

  1662. +static pointer_sized_int VSTINTERFACECALL audioMaster (Vst2::VstEffectInterface*, int32, int32, pointer_sized_int, void*, float);

  1663.  

  1664.  //==============================================================================

  1665.  // Change this to disable logging of various VST activities

  1666. @@ -706,9 +704,9 @@ struct ModuleHandle    : public ReferenceCountedObject

  1667.          module.close();

  1668.      }

  1669.  

  1670. -    void closeEffect (Vst2::AEffect* eff)

  1671. +    void closeEffect (Vst2::VstEffectInterface* eff)

  1672.      {

  1673. -        eff->dispatcher (eff, Vst2::effClose, 0, 0, nullptr, 0);

  1674. +        eff->dispatchFunction (eff, Vst2::plugInOpcodeClose, 0, 0, nullptr, 0);

  1675.      }

  1676.  

  1677.     #if JUCE_WINDOWS

  1678. @@ -832,9 +830,9 @@ struct ModuleHandle    : public ReferenceCountedObject

  1679.          }

  1680.      }

  1681.  

  1682. -    void closeEffect (Vst2::AEffect* eff)

  1683. +    void closeEffect (Vst2::VstEffectInterface* eff)

  1684.      {

  1685. -        eff->dispatcher (eff, Vst2::effClose, 0, 0, nullptr, 0);

  1686. +        eff->dispatchFunction (eff, Vst2::plugInOpcodeClose, 0, 0, nullptr, 0);

  1687.      }

  1688.  

  1689.    #endif

  1690. @@ -889,7 +887,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1691.              {

  1692.                  const ScopedLock sl (pluginInstance.lock);

  1693.  

  1694. -                return effect->getParameter (effect, getParameterIndex());

  1695. +                return effect->getParameterValueFunction (effect, getParameterIndex());

  1696.              }

  1697.  

  1698.              return 0.0f;

  1699. @@ -901,8 +899,8 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1700.              {

  1701.                  const ScopedLock sl (pluginInstance.lock);

  1702.  

  1703. -                if (effect->getParameter (effect, getParameterIndex()) != newValue)

  1704. -                    effect->setParameter (effect, getParameterIndex(), newValue);

  1705. +                if (effect->getParameterValueFunction (effect, getParameterIndex()) != newValue)

  1706. +                    effect->setParameterValueFunction (effect, getParameterIndex(), newValue);

  1707.              }

  1708.          }

  1709.  

  1710. @@ -935,7 +933,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1711.              if (valueType != nullptr || ! vstValueStrings.isEmpty())

  1712.                  return getText (getValue(), 1024);

  1713.  

  1714. -            return pluginInstance.getTextForOpcode (getParameterIndex(), Vst2::effGetParamDisplay);

  1715. +            return pluginInstance.getTextForOpcode (getParameterIndex(), Vst2::plugInOpcodeGetParameterText);

  1716.          }

  1717.  

  1718.          float getDefaultValue() const override

  1719. @@ -947,7 +945,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1720.          {

  1721.              if (name.isEmpty())

  1722.                  return pluginInstance.getTextForOpcode (getParameterIndex(),

  1723. -                                                        Vst2::effGetParamName);

  1724. +                                                        Vst2::plugInOpcodeGetParameterName);

  1725.  

  1726.              if (name.length() <= maximumStringLength)

  1727.                  return name;

  1728. @@ -967,7 +965,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1729.          String getLabel() const override

  1730.          {

  1731.              return label.isEmpty() ? pluginInstance.getTextForOpcode (getParameterIndex(),

  1732. -                                                                      Vst2::effGetParamLabel)

  1733. +                                                                      Vst2::plugInOpcodeGetParameterLabel)

  1734.                                     : label;

  1735.          }

  1736.  

  1737. @@ -1009,7 +1007,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1738.          const VSTXMLInfo::ValueType* const valueType;

  1739.      };

  1740.  

  1741. -    VSTPluginInstance (const ModuleHandle::Ptr& mh, const BusesProperties& ioConfig, Vst2::AEffect* effect,

  1742. +    VSTPluginInstance (const ModuleHandle::Ptr& mh, const BusesProperties& ioConfig, Vst2::VstEffectInterface* effect,

  1743.                         double sampleRateToUse, int blockSizeToUse)

  1744.          : AudioPluginInstance (ioConfig),

  1745.            vstEffect (effect),

  1746. @@ -1032,13 +1030,13 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1747.      {

  1748.          AudioProcessorParameterGroup newParameterTree;

  1749.  

  1750. -        for (int i = 0; i < vstEffect->numParams; ++i)

  1751. +        for (int i = 0; i < vstEffect->numParameters; ++i)

  1752.          {

  1753.              String paramName;

  1754.              Array<String> shortParamNames;

  1755.              float defaultValue = 0;

  1756.              String label;

  1757. -            bool isAutomatable = dispatch (Vst2::effCanBeAutomated, i, 0, nullptr, 0) != 0;

  1758. +            bool isAutomatable = dispatch (Vst2::plugInOpcodeIsParameterAutomatable, i, 0, nullptr, 0) != 0;

  1759.              bool isDiscrete = false;

  1760.              int numSteps = AudioProcessor::getDefaultNumParameterSteps();

  1761.              bool isBoolSwitch = false;

  1762. @@ -1106,7 +1104,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1763.  

  1764.      ~VSTPluginInstance() override

  1765.      {

  1766. -        if (vstEffect != nullptr && vstEffect->magic == 0x56737450 /* 'VstP' */)

  1767. +        if (vstEffect != nullptr && vstEffect->interfaceIdentifier == Vst2::juceVstInterfaceIdentifier)

  1768.          {

  1769.              struct VSTDeleter : public CallbackMessage

  1770.              {

  1771. @@ -1139,7 +1137,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1772.  

  1773.      void cleanup()

  1774.      {

  1775. -        if (vstEffect != nullptr && vstEffect->magic == 0x56737450 /* 'VstP' */)

  1776. +        if (vstEffect != nullptr && vstEffect->interfaceIdentifier == Vst2::juceVstInterfaceIdentifier)

  1777.          {

  1778.             #if JUCE_MAC

  1779.              if (vstModule->resFileId != 0)

  1780. @@ -1164,16 +1162,16 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1781.      {

  1782.          if (auto* newEffect = constructEffect (newModule))

  1783.          {

  1784. -            newEffect->resvd2 = 0;

  1785. +            newEffect->hostSpace2 = 0;

  1786.  

  1787. -            newEffect->dispatcher (newEffect, Vst2::effIdentify, 0, 0, nullptr, 0);

  1788. +            newEffect->dispatchFunction (newEffect, Vst2::plugInOpcodeIdentify, 0, 0, nullptr, 0);

  1789.  

  1790.              auto blockSize = jmax (32, initialBlockSize);

  1791.  

  1792. -            newEffect->dispatcher (newEffect, Vst2::effSetSampleRate, 0, 0, nullptr, static_cast<float> (initialSampleRate));

  1793. -            newEffect->dispatcher (newEffect, Vst2::effSetBlockSize,  0, blockSize, nullptr, 0);

  1794. +            newEffect->dispatchFunction (newEffect, Vst2::plugInOpcodeSetSampleRate, 0, 0, nullptr, static_cast<float> (initialSampleRate));

  1795. +            newEffect->dispatchFunction (newEffect, Vst2::plugInOpcodeSetBlockSize,  0, blockSize, nullptr, 0);

  1796.  

  1797. -            newEffect->dispatcher (newEffect, Vst2::effOpen, 0, 0, nullptr, 0);

  1798. +            newEffect->dispatchFunction (newEffect, Vst2::plugInOpcodeOpen, 0, 0, nullptr, 0);

  1799.              BusesProperties ioConfig = queryBusIO (newEffect);

  1800.  

  1801.              return new VSTPluginInstance (newModule, ioConfig, newEffect, initialSampleRate, blockSize);

  1802. @@ -1189,7 +1187,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1803.  

  1804.          {

  1805.              char buffer[512] = { 0 };

  1806. -            dispatch (Vst2::effGetEffectName, 0, 0, buffer, 0);

  1807. +            dispatch (Vst2::plugInOpcodeGetPlugInName, 0, 0, buffer, 0);

  1808.  

  1809.              desc.descriptiveName = String::createStringFromData (buffer, (int) sizeof (buffer)).trim();

  1810.  

  1811. @@ -1206,7 +1204,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1812.  

  1813.          {

  1814.              char buffer[512] = { 0 };

  1815. -            dispatch (Vst2::effGetVendorString, 0, 0, buffer, 0);

  1816. +            dispatch (Vst2::plugInOpcodeGetManufacturerName, 0, 0, buffer, 0);

  1817.              desc.manufacturerName = String::createStringFromData (buffer, (int) sizeof (buffer)).trim();

  1818.          }

  1819.  

  1820. @@ -1220,7 +1218,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1821.      {

  1822.          if (vstEffect != nullptr)

  1823.          {

  1824. -            vstEffect->resvd2 = (pointer_sized_int) (pointer_sized_int) this;

  1825. +            vstEffect->hostSpace2 = (pointer_sized_int) (pointer_sized_int) this;

  1826.              initialise (initialSampleRate, initialBlockSize);

  1827.              return true;

  1828.          }

  1829. @@ -1246,25 +1244,25 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1830.  

  1831.          setRateAndBufferSizeDetails (initialSampleRate, initialBlockSize);

  1832.  

  1833. -        dispatch (Vst2::effIdentify, 0, 0, nullptr, 0);

  1834. +        dispatch (Vst2::plugInOpcodeIdentify, 0, 0, nullptr, 0);

  1835.  

  1836.          if (getSampleRate() > 0)

  1837. -            dispatch (Vst2::effSetSampleRate, 0, 0, nullptr, (float) getSampleRate());

  1838. +            dispatch (Vst2::plugInOpcodeSetSampleRate, 0, 0, nullptr, (float) getSampleRate());

  1839.  

  1840.          if (getBlockSize() > 0)

  1841. -            dispatch (Vst2::effSetBlockSize, 0, jmax (32, getBlockSize()), nullptr, 0);

  1842. +            dispatch (Vst2::plugInOpcodeSetBlockSize, 0, jmax (32, getBlockSize()), nullptr, 0);

  1843.  

  1844. -        dispatch (Vst2::effOpen, 0, 0, nullptr, 0);

  1845. +        dispatch (Vst2::plugInOpcodeOpen, 0, 0, nullptr, 0);

  1846.  

  1847.          setRateAndBufferSizeDetails (getSampleRate(), getBlockSize());

  1848.  

  1849.          if (getNumPrograms() > 1)

  1850.              setCurrentProgram (0);

  1851.          else

  1852. -            dispatch (Vst2::effSetProgram, 0, 0, nullptr, 0);

  1853. +            dispatch (Vst2::plugInOpcodeSetCurrentProgram, 0, 0, nullptr, 0);

  1854.  

  1855. -        for (int i = vstEffect->numInputs;  --i >= 0;)  dispatch (Vst2::effConnectInput,  i, 1, nullptr, 0);

  1856. -        for (int i = vstEffect->numOutputs; --i >= 0;)  dispatch (Vst2::effConnectOutput, i, 1, nullptr, 0);

  1857. +        for (int i = vstEffect->numInputChannels;  --i >= 0;)  dispatch (Vst2::plugInOpcodeConnectInput,  i, 1, nullptr, 0);

  1858. +        for (int i = vstEffect->numOutputChannels; --i >= 0;)  dispatch (Vst2::plugInOpcodeConnectOutput, i, 1, nullptr, 0);

  1859.  

  1860.          if (getVstCategory() != Vst2::kPlugCategShell) // (workaround for Waves 5 plugins which crash during this call)

  1861.              updateStoredProgramNames();

  1862. @@ -1275,7 +1273,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1863.          usesCocoaNSView = ((unsigned int) pluginCanDo ("hasCockosViewAsConfig") & 0xffff0000ul) == 0xbeef0000ul;

  1864.         #endif

  1865.  

  1866. -        setLatencySamples (vstEffect->initialDelay);

  1867. +        setLatencySamples (vstEffect->latency);

  1868.      }

  1869.  

  1870.      void* getPlatformSpecificData() override    { return vstEffect; }

  1871. @@ -1286,7 +1284,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1872.          {

  1873.              char buffer[512] = { 0 };

  1874.  

  1875. -            if (dispatch (Vst2::effGetProductString, 0, 0, buffer, 0) != 0)

  1876. +            if (dispatch (Vst2::plugInOpcodeGetManufacturerProductName, 0, 0, buffer, 0) != 0)

  1877.              {

  1878.                  String productName = String::createStringFromData (buffer, (int) sizeof (buffer));

  1879.  

  1880. @@ -1300,7 +1298,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1881.  

  1882.      int getUID() const

  1883.      {

  1884. -        int uid = vstEffect != nullptr ? vstEffect->uniqueID : 0;

  1885. +        int uid = vstEffect != nullptr ? vstEffect->plugInIdentifier : 0;

  1886.  

  1887.          if (uid == 0)

  1888.              uid = vstModule->file.hashCode();

  1889. @@ -1313,10 +1311,10 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1890.          if (vstEffect == nullptr)

  1891.              return 0.0;

  1892.  

  1893. -        if ((vstEffect->flags & Vst2::effFlagsNoSoundInStop) != 0)

  1894. +        if ((vstEffect->flags & 512) != 0)

  1895.              return 0.0;

  1896.  

  1897. -        auto tailSize = dispatch (Vst2::effGetTailSize, 0, 0, nullptr, 0);

  1898. +        auto tailSize = dispatch (Vst2::plugInOpcodeGetTailSize, 0, 0, nullptr, 0);

  1899.          auto sampleRate = getSampleRate();

  1900.  

  1901.          // remain backward compatible with old JUCE plug-ins: anything larger

  1902. @@ -1336,11 +1334,11 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1903.      bool producesMidi() const override   { return pluginCanDo ("sendVstMidiEvent") > 0; }

  1904.      bool supportsMPE() const override    { return pluginCanDo ("MPE") > 0; }

  1905.  

  1906. -    Vst2::VstPlugCategory getVstCategory() const noexcept     { return (Vst2::VstPlugCategory) dispatch (Vst2::effGetPlugCategory, 0, 0, nullptr, 0); }

  1907. +    Vst2::VstPlugInCategory getVstCategory() const noexcept     { return (Vst2::VstPlugInCategory) dispatch (Vst2::plugInOpcodeGetPlugInCategory, 0, 0, nullptr, 0); }

  1908.  

  1909. -    bool isSynthPlugin() const  { return (vstEffect != nullptr && (vstEffect->flags & Vst2::effFlagsIsSynth) != 0); }

  1910. +    bool isSynthPlugin() const  { return (vstEffect != nullptr && (vstEffect->flags & Vst2::vstEffectFlagIsSynth) != 0); }

  1911.  

  1912. -    int pluginCanDo (const char* text) const  { return (int) dispatch (Vst2::effCanDo, 0, 0, (void*) text,  0); }

  1913. +    int pluginCanDo (const char* text) const  { return (int) dispatch (Vst2::plugInOpcodeCanPlugInDo, 0, 0, (void*) text,  0); }

  1914.  

  1915.      //==============================================================================

  1916.      void prepareToPlay (double rate, int samplesPerBlockExpected) override

  1917. @@ -1355,17 +1353,17 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1918.              SpeakerMappings::VstSpeakerConfigurationHolder inArr  (getChannelLayoutOfBus (true,  0));

  1919.              SpeakerMappings::VstSpeakerConfigurationHolder outArr (getChannelLayoutOfBus (false, 0));

  1920.  

  1921. -            dispatch (Vst2::effSetSpeakerArrangement, 0, (pointer_sized_int) &inArr.get(), (void*) &outArr.get(), 0.0f);

  1922. +            dispatch (Vst2::plugInOpcodeSetSpeakerConfiguration, 0, (pointer_sized_int) &inArr.get(), (void*) &outArr.get(), 0.0f);

  1923.          }

  1924.  

  1925. -        vstHostTime.tempo = 120.0;

  1926. -        vstHostTime.timeSigNumerator = 4;

  1927. -        vstHostTime.timeSigDenominator = 4;

  1928. +        vstHostTime.tempoBPM = 120.0;

  1929. +        vstHostTime.timeSignatureNumerator = 4;

  1930. +        vstHostTime.timeSignatureDenominator = 4;

  1931.          vstHostTime.sampleRate = rate;

  1932. -        vstHostTime.samplePos = 0;

  1933. -        vstHostTime.flags = Vst2::kVstNanosValid

  1934. -                              | Vst2::kVstAutomationWriting

  1935. -                              | Vst2::kVstAutomationReading;

  1936. +        vstHostTime.samplePosition = 0;

  1937. +        vstHostTime.flags = Vst2::vstTimingInfoFlagNanosecondsValid

  1938. +                              | Vst2::vstTimingInfoFlagAutomationWriteModeActive

  1939. +                              | Vst2::vstTimingInfoFlagAutomationReadModeActive;

  1940.  

  1941.          initialise (rate, samplesPerBlockExpected);

  1942.  

  1943. @@ -1380,18 +1378,18 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1944.  

  1945.              incomingMidi.clear();

  1946.  

  1947. -            dispatch (Vst2::effSetSampleRate, 0, 0, nullptr, (float) rate);

  1948. -            dispatch (Vst2::effSetBlockSize, 0, jmax (16, samplesPerBlockExpected), nullptr, 0);

  1949. +            dispatch (Vst2::plugInOpcodeSetSampleRate, 0, 0, nullptr, (float) rate);

  1950. +            dispatch (Vst2::plugInOpcodeSetBlockSize, 0, jmax (16, samplesPerBlockExpected), nullptr, 0);

  1951.  

  1952.              if (supportsDoublePrecisionProcessing())

  1953.              {

  1954. -                int32 vstPrecision = isUsingDoublePrecision() ? Vst2::kVstProcessPrecision64

  1955. -                                                              : Vst2::kVstProcessPrecision32;

  1956. +                int32 vstPrecision = isUsingDoublePrecision() ? Vst2::vstProcessingSampleTypeDouble

  1957. +                                                              : Vst2::vstProcessingSampleTypeFloat;

  1958.  

  1959. -                dispatch (Vst2::effSetProcessPrecision, 0, (pointer_sized_int) vstPrecision, nullptr, 0);

  1960. +                dispatch (Vst2::plugInOpcodeSetSampleFloatType, 0, (pointer_sized_int) vstPrecision, nullptr, 0);

  1961.              }

  1962.  

  1963. -            auto maxChannels = jmax (1, jmax (vstEffect->numInputs, vstEffect->numOutputs));

  1964. +            auto maxChannels = jmax (1, jmax (vstEffect->numInputChannels, vstEffect->numOutputChannels));

  1965.  

  1966.              tmpBufferFloat .setSize (maxChannels, samplesPerBlockExpected);

  1967.              tmpBufferDouble.setSize (maxChannels, samplesPerBlockExpected);

  1968. @@ -1399,7 +1397,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1969.              channelBufferFloat .calloc (static_cast<size_t> (maxChannels));

  1970.              channelBufferDouble.calloc (static_cast<size_t> (maxChannels));

  1971.  

  1972. -            outOfPlaceBuffer.setSize (jmax (1, vstEffect->numOutputs), samplesPerBlockExpected);

  1973. +            outOfPlaceBuffer.setSize (jmax (1, vstEffect->numOutputChannels), samplesPerBlockExpected);

  1974.  

  1975.              if (! isPowerOn)

  1976.                  setPower (true);

  1977. @@ -1415,9 +1413,9 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1978.                  }

  1979.              }

  1980.  

  1981. -            dispatch (Vst2::effStartProcess, 0, 0, nullptr, 0);

  1982. +            dispatch (Vst2::plugInOpcodeStartProcess, 0, 0, nullptr, 0);

  1983.  

  1984. -            setLatencySamples (vstEffect->initialDelay);

  1985. +            setLatencySamples (vstEffect->latency);

  1986.          }

  1987.      }

  1988.  

  1989. @@ -1425,7 +1423,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1990.      {

  1991.          if (initialised)

  1992.          {

  1993. -            dispatch (Vst2::effStopProcess, 0, 0, nullptr, 0);

  1994. +            dispatch (Vst2::plugInOpcodeStopProcess, 0, 0, nullptr, 0);

  1995.              setPower (false);

  1996.          }

  1997.  

  1998. @@ -1478,8 +1476,8 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  1999.      //==============================================================================

  2000.      bool supportsDoublePrecisionProcessing() const override

  2001.      {

  2002. -        return ((vstEffect->flags & Vst2::effFlagsCanReplacing) != 0

  2003. -             && (vstEffect->flags & Vst2::effFlagsCanDoubleReplacing) != 0);

  2004. +        return ((vstEffect->flags & Vst2::vstEffectFlagInplaceAudio) != 0

  2005. +             && (vstEffect->flags & Vst2::vstEffectFlagInplaceDoubleAudio) != 0);

  2006.      }

  2007.  

  2008.      AudioProcessorParameter* getBypassParameter() const override               { return vstSupportsBypass ? bypassParam.get() : nullptr; }

  2009. @@ -1497,15 +1495,15 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2010.          if (numInputBuses > 1 || numOutputBuses > 1)

  2011.              return (layouts == getBusesLayout());

  2012.  

  2013. -        return (layouts.getNumChannels (true,  0) <= vstEffect->numInputs

  2014. -             && layouts.getNumChannels (false, 0) <= vstEffect->numOutputs);

  2015. +        return (layouts.getNumChannels (true,  0) <= vstEffect->numInputChannels

  2016. +             && layouts.getNumChannels (false, 0) <= vstEffect->numOutputChannels);

  2017.      }

  2018.  

  2019.      //==============================================================================

  2020.     #if JUCE_IOS || JUCE_ANDROID

  2021.      bool hasEditor() const override                  { return false; }

  2022.     #else

  2023. -    bool hasEditor() const override                  { return vstEffect != nullptr && (vstEffect->flags & Vst2::effFlagsHasEditor) != 0; }

  2024. +    bool hasEditor() const override                  { return vstEffect != nullptr && (vstEffect->flags & Vst2::vstEffectFlagHasEditor) != 0; }

  2025.     #endif

  2026.  

  2027.      AudioProcessorEditor* createEditor() override;

  2028. @@ -1515,9 +1513,9 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2029.      {

  2030.          if (isValidChannel (index, true))

  2031.          {

  2032. -            Vst2::VstPinProperties pinProps;

  2033. -            if (dispatch (Vst2::effGetInputProperties, index, 0, &pinProps, 0.0f) != 0)

  2034. -                return String (pinProps.label, sizeof (pinProps.label));

  2035. +            Vst2::VstPinInfo pinProps;

  2036. +            if (dispatch (Vst2::plugInOpcodeGetInputPinProperties, index, 0, &pinProps, 0.0f) != 0)

  2037. +                return String (pinProps.text, sizeof (pinProps.text));

  2038.          }

  2039.  

  2040.          return {};

  2041. @@ -1528,9 +1526,9 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2042.          if (! isValidChannel (index, true))

  2043.              return false;

  2044.  

  2045. -        Vst2::VstPinProperties pinProps;

  2046. -        if (dispatch (Vst2::effGetInputProperties, index, 0, &pinProps, 0.0f) != 0)

  2047. -            return (pinProps.flags & Vst2::kVstPinIsStereo) != 0;

  2048. +        Vst2::VstPinInfo pinProps;

  2049. +        if (dispatch (Vst2::plugInOpcodeGetInputPinProperties, index, 0, &pinProps, 0.0f) != 0)

  2050. +            return (pinProps.flags & Vst2::vstPinInfoFlagIsStereo) != 0;

  2051.  

  2052.          return true;

  2053.      }

  2054. @@ -1539,9 +1537,9 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2055.      {

  2056.          if (isValidChannel (index, false))

  2057.          {

  2058. -            Vst2::VstPinProperties pinProps;

  2059. -            if (dispatch (Vst2::effGetOutputProperties, index, 0, &pinProps, 0.0f) != 0)

  2060. -                return String (pinProps.label, sizeof (pinProps.label));

  2061. +            Vst2::VstPinInfo pinProps;

  2062. +            if (dispatch (Vst2::plugInOpcodeGetOutputPinProperties, index, 0, &pinProps, 0.0f) != 0)

  2063. +                return String (pinProps.text, sizeof (pinProps.text));

  2064.          }

  2065.  

  2066.          return {};

  2067. @@ -1552,9 +1550,9 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2068.          if (! isValidChannel (index, false))

  2069.              return false;

  2070.  

  2071. -        Vst2::VstPinProperties pinProps;

  2072. -        if (dispatch (Vst2::effGetOutputProperties, index, 0, &pinProps, 0.0f) != 0)

  2073. -            return (pinProps.flags & Vst2::kVstPinIsStereo) != 0;

  2074. +        Vst2::VstPinInfo pinProps;

  2075. +        if (dispatch (Vst2::plugInOpcodeGetOutputPinProperties, index, 0, &pinProps, 0.0f) != 0)

  2076. +            return (pinProps.flags & Vst2::vstPinInfoFlagIsStereo) != 0;

  2077.  

  2078.          return true;

  2079.      }

  2080. @@ -1569,12 +1567,12 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2081.      int getNumPrograms() override          { return vstEffect != nullptr ? jmax (0, vstEffect->numPrograms) : 0; }

  2082.  

  2083.      // NB: some plugs return negative numbers from this function.

  2084. -    int getCurrentProgram() override       { return (int) dispatch (Vst2::effGetProgram, 0, 0, nullptr, 0); }

  2085. +    int getCurrentProgram() override       { return (int) dispatch (Vst2::plugInOpcodeGetCurrentProgram, 0, 0, 0, 0); }

  2086.  

  2087.      void setCurrentProgram (int newIndex) override

  2088.      {

  2089.          if (getNumPrograms() > 0 && newIndex != getCurrentProgram())

  2090. -            dispatch (Vst2::effSetProgram, 0, jlimit (0, getNumPrograms() - 1, newIndex), nullptr, 0);

  2091. +            dispatch (Vst2::plugInOpcodeSetCurrentProgram, 0, jlimit (0, getNumPrograms() - 1, newIndex), 0, 0);

  2092.      }

  2093.  

  2094.      const String getProgramName (int index) override

  2095. @@ -1588,7 +1586,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2096.              {

  2097.                  char nm[264] = { 0 };

  2098.  

  2099. -                if (dispatch (Vst2::effGetProgramNameIndexed, jlimit (0, getNumPrograms(), index), -1, nm, 0) != 0)

  2100. +                if (dispatch (Vst2::plugInOpcodeGetProgramName, jlimit (0, getNumPrograms(), index), -1, nm, 0) != 0)

  2101.                      return String::fromUTF8 (nm).trim();

  2102.              }

  2103.          }

  2104. @@ -1601,7 +1599,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2105.          if (index >= 0 && index == getCurrentProgram())

  2106.          {

  2107.              if (getNumPrograms() > 0 && newName != getCurrentProgramName())

  2108. -                dispatch (Vst2::effSetProgramName, 0, 0, (void*) newName.substring (0, 24).toRawUTF8(), 0.0f);

  2109. +                dispatch (Vst2::plugInOpcodeSetCurrentProgramName, 0, 0, (void*) newName.substring (0, 24).toRawUTF8(), 0.0f);

  2110.          }

  2111.          else

  2112.          {

  2113. @@ -1619,7 +1617,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2114.      //==============================================================================

  2115.      void timerCallback() override

  2116.      {

  2117. -        if (dispatch (Vst2::effIdle, 0, 0, nullptr, 0) == 0)

  2118. +        if (dispatch (Vst2::plugInOpcodeIdle, 0, 0, nullptr, 0) == 0)

  2119.              stopTimer();

  2120.      }

  2121.  

  2122. @@ -1633,7 +1631,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2123.      {

  2124.          switch (opcode)

  2125.          {

  2126. -            case Vst2::audioMasterAutomate:

  2127. +            case Vst2::hostOpcodeParameterChanged:

  2128.                  if (auto* param = getParameters()[index])

  2129.                      param->sendValueChangedMessageToListeners (opt);

  2130.                  else

  2131. @@ -1641,23 +1639,23 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2132.  

  2133.                  break;

  2134.  

  2135. -            case Vst2::audioMasterProcessEvents:            handleMidiFromPlugin ((const Vst2::VstEvents*) ptr); break;

  2136. -            case Vst2::audioMasterGetTime:                  return getVSTTime();

  2137. -            case Vst2::audioMasterIdle:                     handleIdle(); break;

  2138. -            case Vst2::audioMasterSizeWindow:               setWindowSize (index, (int) value); return 1;

  2139. -            case Vst2::audioMasterUpdateDisplay:            triggerAsyncUpdate(); break;

  2140. -            case Vst2::audioMasterIOChanged:                setLatencySamples (vstEffect->initialDelay); break;

  2141. -            case Vst2::audioMasterNeedIdle:                 startTimer (50); break;

  2142. +            case Vst2::hostOpcodePreAudioProcessingEvents:    handleMidiFromPlugin ((const Vst2::VstEventBlock*) ptr); break;

  2143. +            case Vst2::hostOpcodeGetTimingInfo:               return getVSTTime();

  2144. +            case Vst2::hostOpcodeIdle:                        handleIdle(); break;

  2145. +            case Vst2::hostOpcodeWindowSize:                  setWindowSize (index, (int) value); return 1;

  2146. +            case Vst2::hostOpcodeUpdateView:                  triggerAsyncUpdate(); break;

  2147. +            case Vst2::hostOpcodeIOModified:                  setLatencySamples (vstEffect->latency); break;

  2148. +            case Vst2::hostOpcodeNeedsIdle:                   startTimer (50); break;

  2149.  

  2150. -            case Vst2::audioMasterGetSampleRate:            return (pointer_sized_int) (getSampleRate() > 0 ? getSampleRate() : defaultVSTSampleRateValue);

  2151. -            case Vst2::audioMasterGetBlockSize:             return (pointer_sized_int) (getBlockSize() > 0  ? getBlockSize()  : defaultVSTBlockSizeValue);

  2152. -            case Vst2::audioMasterWantMidi:                 wantsMidiMessages = true; break;

  2153. -            case Vst2::audioMasterGetDirectory:             return getVstDirectory();

  2154. +            case Vst2::hostOpcodeGetSampleRate:               return (pointer_sized_int) (getSampleRate() > 0 ? getSampleRate() : defaultVSTSampleRateValue);

  2155. +            case Vst2::hostOpcodeGetBlockSize:                return (pointer_sized_int) (getBlockSize() > 0  ? getBlockSize()  : defaultVSTBlockSizeValue);

  2156. +            case Vst2::hostOpcodePlugInWantsMidi:             wantsMidiMessages = true; break;

  2157. +            case Vst2::hostOpcodeGetDirectory:                return getVstDirectory();

  2158.  

  2159. -            case Vst2::audioMasterTempoAt:                  return (pointer_sized_int) (extraFunctions != nullptr ? extraFunctions->getTempoAt ((int64) value) : 0);

  2160. -            case Vst2::audioMasterGetAutomationState:       return (pointer_sized_int) (extraFunctions != nullptr ? extraFunctions->getAutomationState() : 0);

  2161. +            case Vst2::hostOpcodeTempoAt:                     return (pointer_sized_int) (extraFunctions != nullptr ? extraFunctions->getTempoAt ((int64) value) : 0);

  2162. +            case Vst2::hostOpcodeGetAutomationState:          return (pointer_sized_int) (extraFunctions != nullptr ? extraFunctions->getAutomationState() : 0);

  2163.  

  2164. -            case Vst2::audioMasterBeginEdit:

  2165. +            case Vst2::hostOpcodeParameterChangeGestureBegin:

  2166.                  if (auto* param = getParameters()[index])

  2167.                      param->beginChangeGesture();

  2168.                  else

  2169. @@ -1665,7 +1663,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2170.  

  2171.                  break;

  2172.  

  2173. -            case Vst2::audioMasterEndEdit:

  2174. +            case Vst2::hostOpcodeParameterChangeGestureEnd:

  2175.                  if (auto* param = getParameters()[index])

  2176.                      param->endChangeGesture();

  2177.                  else

  2178. @@ -1673,28 +1671,28 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2179.  

  2180.                  break;

  2181.  

  2182. -            case Vst2::audioMasterPinConnected:             return isValidChannel (index, value == 0) ? 0 : 1; // (yes, 0 = true)

  2183. -            case Vst2::audioMasterGetCurrentProcessLevel:   return isNonRealtime() ? 4 : 0;

  2184. +            case Vst2::hostOpcodePinConnected:                   return isValidChannel (index, value == 0) ? 0 : 1; // (yes, 0 = true)

  2185. +            case Vst2::hostOpcodeGetCurrentAudioProcessingLevel: return isNonRealtime() ? 4 : 0;

  2186.  

  2187.              // none of these are handled (yet)...

  2188. -            case Vst2::audioMasterSetTime:

  2189. -            case Vst2::audioMasterGetParameterQuantization:

  2190. -            case Vst2::audioMasterGetInputLatency:

  2191. -            case Vst2::audioMasterGetOutputLatency:

  2192. -            case Vst2::audioMasterGetPreviousPlug:

  2193. -            case Vst2::audioMasterGetNextPlug:

  2194. -            case Vst2::audioMasterWillReplaceOrAccumulate:

  2195. -            case Vst2::audioMasterOfflineStart:

  2196. -            case Vst2::audioMasterOfflineRead:

  2197. -            case Vst2::audioMasterOfflineWrite:

  2198. -            case Vst2::audioMasterOfflineGetCurrentPass:

  2199. -            case Vst2::audioMasterOfflineGetCurrentMetaPass:

  2200. -            case Vst2::audioMasterGetOutputSpeakerArrangement:

  2201. -            case Vst2::audioMasterVendorSpecific:

  2202. -            case Vst2::audioMasterSetIcon:

  2203. -            case Vst2::audioMasterGetLanguage:

  2204. -            case Vst2::audioMasterOpenWindow:

  2205. -            case Vst2::audioMasterCloseWindow:

  2206. +            case Vst2::hostOpcodeSetTime:

  2207. +            case Vst2::hostOpcodeGetParameterInterval:

  2208. +            case Vst2::hostOpcodeGetInputLatency:

  2209. +            case Vst2::hostOpcodeGetOutputLatency:

  2210. +            case Vst2::hostOpcodeGetPreviousPlugIn:

  2211. +            case Vst2::hostOpcodeGetNextPlugIn:

  2212. +            case Vst2::hostOpcodeWillReplace:

  2213. +            case Vst2::hostOpcodeOfflineStart:

  2214. +            case Vst2::hostOpcodeOfflineReadSource:

  2215. +            case Vst2::hostOpcodeOfflineWrite:

  2216. +            case Vst2::hostOpcodeOfflineGetCurrentPass:

  2217. +            case Vst2::hostOpcodeOfflineGetCurrentMetaPass:

  2218. +            case Vst2::hostOpcodeGetOutputSpeakerConfiguration:

  2219. +            case Vst2::hostOpcodeManufacturerSpecific:

  2220. +            case Vst2::hostOpcodeSetIcon:

  2221. +            case Vst2::hostOpcodeGetLanguage:

  2222. +            case Vst2::hostOpcodeOpenEditorWindow:

  2223. +            case Vst2::hostOpcodeCloseEditorWindow:

  2224.                  break;

  2225.  

  2226.              default:

  2227. @@ -1709,19 +1707,19 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2228.      {

  2229.          switch (opcode)

  2230.          {

  2231. -            case Vst2::audioMasterCanDo:                        return handleCanDo ((const char*) ptr);

  2232. -            case Vst2::audioMasterVersion:                      return 2400;

  2233. -            case Vst2::audioMasterCurrentId:                    return shellUIDToCreate;

  2234. -            case Vst2::audioMasterGetNumAutomatableParameters:  return 0;

  2235. -            case Vst2::audioMasterGetAutomationState:           return 1;

  2236. -            case Vst2::audioMasterGetVendorVersion:             return 0x0101;

  2237. +            case Vst2::hostOpcodeCanHostDo:                         return handleCanDo ((const char*) ptr);

  2238. +            case Vst2::hostOpcodeVstVersion:                        return 2400;

  2239. +            case Vst2::hostOpcodeCurrentId:                         return shellUIDToCreate;

  2240. +            case Vst2::hostOpcodeGetNumberOfAutomatableParameters:  return 0;

  2241. +            case Vst2::hostOpcodeGetAutomationState:                return 1;

  2242. +            case Vst2::hostOpcodeGetManufacturerVersion:            return 0x0101;

  2243.  

  2244. -            case Vst2::audioMasterGetVendorString:

  2245. -            case Vst2::audioMasterGetProductString:             return getHostName ((char*) ptr);

  2246. +            case Vst2::hostOpcodeGetManufacturerName:

  2247. +            case Vst2::hostOpcodeGetProductName:                    return getHostName ((char*) ptr);

  2248.  

  2249. -            case Vst2::audioMasterGetSampleRate:                return (pointer_sized_int) defaultVSTSampleRateValue;

  2250. -            case Vst2::audioMasterGetBlockSize:                 return (pointer_sized_int) defaultVSTBlockSizeValue;

  2251. -            case Vst2::audioMasterSetOutputSampleRate:          return 0;

  2252. +            case Vst2::hostOpcodeGetSampleRate:                     return (pointer_sized_int) defaultVSTSampleRateValue;

  2253. +            case Vst2::hostOpcodeGetBlockSize:                      return (pointer_sized_int) defaultVSTBlockSizeValue;

  2254. +            case Vst2::hostOpcodeSetOutputSampleRate:               return 0;

  2255.  

  2256.              default:

  2257.                  DBG ("*** Unhandled VST Callback: " + String ((int) opcode));

  2258. @@ -1750,7 +1748,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2259.                      UseResFile (vstModule->resFileId);

  2260.                 #endif

  2261.  

  2262. -                result = vstEffect->dispatcher (vstEffect, opcode, index, value, ptr, opt);

  2263. +                result = vstEffect->dispatchFunction (vstEffect, opcode, index, value, ptr, opt);

  2264.  

  2265.                 #if JUCE_MAC

  2266.                  auto newResFile = CurResFile();

  2267. @@ -1956,14 +1954,14 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2268.          return true;

  2269.      }

  2270.  

  2271. -    bool usesChunks() const noexcept        { return vstEffect != nullptr && (vstEffect->flags & Vst2::effFlagsProgramChunks) != 0; }

  2272. +    bool usesChunks() const noexcept        { return vstEffect != nullptr && (vstEffect->flags & Vst2::vstEffectFlagDataInChunks) != 0; }

  2273.  

  2274.      bool getChunkData (MemoryBlock& mb, bool isPreset, int maxSizeMB) const

  2275.      {

  2276.          if (usesChunks())

  2277.          {

  2278.              void* data = nullptr;

  2279. -            auto bytes = (size_t) dispatch (Vst2::effGetChunk, isPreset ? 1 : 0, 0, &data, 0.0f);

  2280. +            auto bytes = (size_t) dispatch (Vst2::plugInOpcodeGetData, isPreset ? 1 : 0, 0, &data, 0.0f);

  2281.  

  2282.              if (data != nullptr && bytes <= (size_t) maxSizeMB * 1024 * 1024)

  2283.              {

  2284. @@ -1981,7 +1979,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2285.      {

  2286.          if (size > 0 && usesChunks())

  2287.          {

  2288. -            dispatch (Vst2::effSetChunk, isPreset ? 1 : 0, size, (void*) data, 0.0f);

  2289. +            dispatch (Vst2::plugInOpcodeSetData, isPreset ? 1 : 0, size, (void*) data, 0.0f);

  2290.  

  2291.              if (! isPreset)

  2292.                  updateStoredProgramNames();

  2293. @@ -1992,7 +1990,7 @@ struct VSTPluginInstance     : public AudioPluginInstance,

  2294.          return false;

  2295.      }

  2296.  

  2297. -    Vst2::AEffect* vstEffect;

  2298. +    Vst2::VstEffectInterface* vstEffect;

  2299.      ModuleHandle::Ptr vstModule;

  2300.  

  2301.      std::unique_ptr<VSTPluginFormat::ExtraFunctions> extraFunctions;

  2302. @@ -2015,7 +2013,7 @@ private:

  2303.              currentValue = (newValue != 0.0f);

  2304.  

  2305.              if (parent.vstSupportsBypass)

  2306. -                parent.dispatch (Vst2::effSetBypass, 0, currentValue ? 1 : 0, nullptr, 0.0f);

  2307. +                parent.dispatch (Vst2::plugInOpcodeSetBypass, 0, currentValue ? 1 : 0, nullptr, 0.0f);

  2308.          }

  2309.  

  2310.          float getValueForText (const String& text) const override

  2311. @@ -2061,7 +2059,7 @@ private:

  2312.      CriticalSection midiInLock;

  2313.      MidiBuffer incomingMidi;

  2314.      VSTMidiEventList midiEventsToSend;

  2315. -    Vst2::VstTimeInfo vstHostTime;

  2316. +    Vst2::VstTimingInformation vstHostTime;

  2317.  

  2318.      AudioBuffer<float> tmpBufferFloat;

  2319.      HeapBlock<float*> channelBufferFloat;

  2320. @@ -2098,7 +2096,7 @@ private:

  2321.          if (auto* app = JUCEApplicationBase::getInstance())

  2322.              hostName = app->getApplicationName();

  2323.  

  2324. -        hostName.copyToUTF8 (name, (size_t) jmin (Vst2::kVstMaxVendorStrLen, Vst2::kVstMaxProductStrLen) - 1);

  2325. +        hostName.copyToUTF8 (name, (size_t) jmin (Vst2::vstMaxManufacturerStringLength, Vst2::vstMaxPlugInNameStringLength) - 1);

  2326.          return 1;

  2327.      }

  2328.  

  2329. @@ -2124,7 +2122,7 @@ private:

  2330.  

  2331.             #if JUCE_MAC

  2332.              if (getActiveEditor() != nullptr)

  2333. -                dispatch (Vst2::effEditIdle, 0, 0, nullptr, 0);

  2334. +                dispatch (Vst2::plugInOpcodeEditorIdle, 0, 0, nullptr, 0);

  2335.             #endif

  2336.  

  2337.              Timer::callPendingTimersSynchronously();

  2338. @@ -2159,9 +2157,9 @@ private:

  2339.      }

  2340.  

  2341.      //==============================================================================

  2342. -    static Vst2::AEffect* constructEffect (const ModuleHandle::Ptr& module)

  2343. +    static Vst2::VstEffectInterface* constructEffect (const ModuleHandle::Ptr& module)

  2344.      {

  2345. -        Vst2::AEffect* effect = nullptr;

  2346. +        Vst2::VstEffectInterface* effect = nullptr;

  2347.          try

  2348.          {

  2349.              const IdleCallRecursionPreventer icrp;

  2350. @@ -2178,10 +2176,10 @@ private:

  2351.                  JUCE_VST_WRAPPER_INVOKE_MAIN

  2352.              }

  2353.  

  2354. -            if (effect != nullptr && effect->magic == 0x56737450 /* 'VstP' */)

  2355. +            if (effect != nullptr && effect->interfaceIdentifier == Vst2::juceVstInterfaceIdentifier)

  2356.              {

  2357. -                jassert (effect->resvd2 == 0);

  2358. -                jassert (effect->object != nullptr);

  2359. +                jassert (effect->hostSpace2 == 0);

  2360. +                jassert (effect->effectPointer != 0);

  2361.  

  2362.                  _fpreset(); // some dodgy plugs mess around with this

  2363.              }

  2364. @@ -2196,11 +2194,11 @@ private:

  2365.          return effect;

  2366.      }

  2367.  

  2368. -    static BusesProperties queryBusIO (Vst2::AEffect* effect)

  2369. +    static BusesProperties queryBusIO (Vst2::VstEffectInterface* effect)

  2370.      {

  2371.          BusesProperties returnValue;

  2372.  

  2373. -        if (effect->numInputs == 0 && effect->numOutputs == 0)

  2374. +        if (effect->numInputChannels == 0 && effect->numOutputChannels == 0)

  2375.              return returnValue;

  2376.  

  2377.          // Workaround for old broken JUCE plug-ins which would return an invalid

  2378. @@ -2211,14 +2209,14 @@ private:

  2379.          // plug-in is reporting.

  2380.          if (! pluginHasDefaultChannelLayouts (effect))

  2381.          {

  2382. -            SpeakerMappings::VstSpeakerConfigurationHolder canonicalIn  (AudioChannelSet::canonicalChannelSet (effect->numInputs));

  2383. -            SpeakerMappings::VstSpeakerConfigurationHolder canonicalOut (AudioChannelSet::canonicalChannelSet (effect->numOutputs));

  2384. +            SpeakerMappings::VstSpeakerConfigurationHolder canonicalIn  (AudioChannelSet::canonicalChannelSet (effect->numInputChannels));

  2385. +            SpeakerMappings::VstSpeakerConfigurationHolder canonicalOut (AudioChannelSet::canonicalChannelSet (effect->numOutputChannels));

  2386.  

  2387. -            effect->dispatcher (effect, Vst2::effSetSpeakerArrangement, 0,

  2388. +            effect->dispatchFunction (effect, Vst2::plugInOpcodeSetSpeakerConfiguration, 0,

  2389.                                        (pointer_sized_int) &canonicalIn.get(), (void*) &canonicalOut.get(), 0.0f);

  2390.          }

  2391.  

  2392. -        HeapBlock<Vst2::VstSpeakerArrangement> inArrBlock (1, true), outArrBlock (1, true);

  2393. +        HeapBlock<Vst2::VstSpeakerConfiguration> inArrBlock (1, true), outArrBlock (1, true);

  2394.  

  2395.          auto* inArr  = inArrBlock.get();

  2396.          auto* outArr = outArrBlock.get();

  2397. @@ -2229,35 +2227,35 @@ private:

  2398.          for (int dir = 0; dir < 2; ++dir)

  2399.          {

  2400.              const bool isInput = (dir == 0);

  2401. -            const int opcode = (isInput ? Vst2::effGetInputProperties : Vst2::effGetOutputProperties);

  2402. -            const int maxChannels = (isInput ? effect->numInputs : effect->numOutputs);

  2403. -            const Vst2::VstSpeakerArrangement* arr = (isInput ? inArr : outArr);

  2404. +            const int opcode = (isInput ? Vst2::plugInOpcodeGetInputPinProperties : Vst2::plugInOpcodeGetOutputPinProperties);

  2405. +            const int maxChannels = (isInput ? effect->numInputChannels : effect->numOutputChannels);

  2406. +            const Vst2::VstSpeakerConfiguration* arr = (isInput ? inArr : outArr);

  2407.              bool busAdded = false;

  2408.  

  2409. -            Vst2::VstPinProperties pinProps;

  2410. +            Vst2::VstPinInfo pinProps;

  2411.              AudioChannelSet layout;

  2412.  

  2413.              for (int ch = 0; ch < maxChannels; ch += layout.size())

  2414.              {

  2415. -                if (effect->dispatcher (effect, opcode, ch, 0, &pinProps, 0.0f) == 0)

  2416. +                if (effect->dispatchFunction (effect, opcode, ch, 0, &pinProps, 0.0f) == 0)

  2417.                      break;

  2418.  

  2419. -                if ((pinProps.flags & Vst2::kVstPinUseSpeaker) != 0)

  2420. +                if ((pinProps.flags & Vst2::vstPinInfoFlagValid) != 0)

  2421.                  {

  2422. -                    layout = SpeakerMappings::vstArrangementTypeToChannelSet (pinProps.arrangementType, 0);

  2423. +                    layout = SpeakerMappings::vstArrangementTypeToChannelSet (pinProps.configurationType, 0);

  2424.  

  2425.                      if (layout.isDisabled())

  2426.                          break;

  2427.                  }

  2428.                  else if (arr == nullptr)

  2429.                  {

  2430. -                    layout = ((pinProps.flags & Vst2::kVstPinIsStereo) != 0 ? AudioChannelSet::stereo() : AudioChannelSet::mono());

  2431. +                    layout = ((pinProps.flags & Vst2::vstPinInfoFlagIsStereo) != 0 ? AudioChannelSet::stereo() : AudioChannelSet::mono());

  2432.                  }

  2433.                  else

  2434.                      break;

  2435.  

  2436.                  busAdded = true;

  2437. -                returnValue.addBus (isInput, pinProps.label, layout, true);

  2438. +                returnValue.addBus (isInput, pinProps.text, layout, true);

  2439.              }

  2440.  

  2441.              // no buses?

  2442. @@ -2265,8 +2263,8 @@ private:

  2443.              {

  2444.                  String busName = (isInput ? "Input" : "Output");

  2445.  

  2446. -                if (effect->dispatcher (effect, opcode, 0, 0, &pinProps, 0.0f) != 0)

  2447. -                    busName = pinProps.label;

  2448. +                if (effect->dispatchFunction (effect, opcode, 0, 0, &pinProps, 0.0f) != 0)

  2449. +                    busName = pinProps.text;

  2450.  

  2451.                  if (arr != nullptr)

  2452.                      layout = SpeakerMappings::vstArrangementTypeToChannelSet (*arr);

  2453. @@ -2280,9 +2278,9 @@ private:

  2454.          return returnValue;

  2455.      }

  2456.  

  2457. -    static bool pluginHasDefaultChannelLayouts (Vst2::AEffect* effect)

  2458. +    static bool pluginHasDefaultChannelLayouts (Vst2::VstEffectInterface* effect)

  2459.      {

  2460. -        HeapBlock<Vst2::VstSpeakerArrangement> inArrBlock (1, true), outArrBlock (1, true);

  2461. +        HeapBlock<Vst2::VstSpeakerConfiguration> inArrBlock (1, true), outArrBlock (1, true);

  2462.  

  2463.          auto* inArr  = inArrBlock.get();

  2464.          auto* outArr = outArrBlock.get();

  2465. @@ -2293,40 +2291,40 @@ private:

  2466.          for (int dir = 0; dir < 2; ++dir)

  2467.          {

  2468.              const bool isInput = (dir == 0);

  2469. -            const int opcode = (isInput ? Vst2::effGetInputProperties : Vst2::effGetOutputProperties);

  2470. -            const int maxChannels = (isInput ? effect->numInputs : effect->numOutputs);

  2471. +            const int opcode = (isInput ? Vst2::plugInOpcodeGetInputPinProperties : Vst2::plugInOpcodeGetOutputPinProperties);

  2472. +            const int maxChannels = (isInput ? effect->numInputChannels : effect->numOutputChannels);

  2473.  

  2474.              int channels = 1;

  2475.  

  2476.              for (int ch = 0; ch < maxChannels; ch += channels)

  2477.              {

  2478. -                Vst2::VstPinProperties pinProps;

  2479. +                Vst2::VstPinInfo pinProps;

  2480.  

  2481. -                if (effect->dispatcher (effect, opcode, ch, 0, &pinProps, 0.0f) == 0)

  2482. +                if (effect->dispatchFunction (effect, opcode, ch, 0, &pinProps, 0.0f) == 0)

  2483.                      return false;

  2484.  

  2485. -                if ((pinProps.flags & Vst2::kVstPinUseSpeaker) != 0)

  2486. +                if ((pinProps.flags & Vst2::vstPinInfoFlagValid) != 0)

  2487.                      return true;

  2488.  

  2489. -                channels = (pinProps.flags & Vst2::kVstPinIsStereo) != 0 ? 2 : 1;

  2490. +                channels = (pinProps.flags & Vst2::vstPinInfoFlagIsStereo) != 0 ? 2 : 1;

  2491.              }

  2492.          }

  2493.  

  2494.          return false;

  2495.      }

  2496.  

  2497. -    static bool getSpeakerArrangementWrapper (Vst2::AEffect* effect,

  2498. -                                              Vst2::VstSpeakerArrangement* inArr,

  2499. -                                              Vst2::VstSpeakerArrangement* outArr)

  2500. +    static bool getSpeakerArrangementWrapper (Vst2::VstEffectInterface* effect,

  2501. +                                              Vst2::VstSpeakerConfiguration* inArr,

  2502. +                                              Vst2::VstSpeakerConfiguration* outArr)

  2503.      {

  2504.          // Workaround: unfortunately old JUCE VST-2 plug-ins had a bug and would crash if

  2505.          // you try to get the speaker arrangement when there are no input channels present.

  2506.          // Hopefully, one day (when there are no more old JUCE plug-ins around), we can

  2507.          // comment out the next two lines.

  2508. -        if (effect->numInputs == 0)

  2509. +        if (effect->numInputChannels == 0)

  2510.              return false;

  2511.  

  2512. -        return (effect->dispatcher (effect, Vst2::effGetSpeakerArrangement, 0,

  2513. +        return (effect->dispatchFunction (effect, Vst2::plugInOpcodeGetSpeakerArrangement, 0,

  2514.                                            reinterpret_cast<pointer_sized_int> (&inArr), &outArr, 0.0f) != 0);

  2515.      }

  2516.  

  2517. @@ -2360,56 +2358,56 @@ private:

  2518.                  if (currentPlayHead->getCurrentPosition (position))

  2519.                  {

  2520.  

  2521. -                    vstHostTime.samplePos          = (double) position.timeInSamples;

  2522. -                    vstHostTime.tempo              = position.bpm;

  2523. -                    vstHostTime.timeSigNumerator   = position.timeSigNumerator;

  2524. -                    vstHostTime.timeSigDenominator = position.timeSigDenominator;

  2525. -                    vstHostTime.ppqPos             = position.ppqPosition;

  2526. -                    vstHostTime.barStartPos        = position.ppqPositionOfLastBarStart;

  2527. -                    vstHostTime.flags |= Vst2::kVstTempoValid

  2528. -                                           | Vst2::kVstTimeSigValid

  2529. -                                           | Vst2::kVstPpqPosValid

  2530. -                                           | Vst2::kVstBarsValid;

  2531. +                    vstHostTime.samplePosition           = (double) position.timeInSamples;

  2532. +                    vstHostTime.tempoBPM                 = position.bpm;

  2533. +                    vstHostTime.timeSignatureNumerator   = position.timeSigNumerator;

  2534. +                    vstHostTime.timeSignatureDenominator = position.timeSigDenominator;

  2535. +                    vstHostTime.musicalPosition          = position.ppqPosition;

  2536. +                    vstHostTime.lastBarPosition          = position.ppqPositionOfLastBarStart;

  2537. +                    vstHostTime.flags |= Vst2::vstTimingInfoFlagTempoValid

  2538. +                                           | Vst2::vstTimingInfoFlagTimeSignatureValid

  2539. +                                           | Vst2::vstTimingInfoFlagMusicalPositionValid

  2540. +                                           | Vst2::vstTimingInfoFlagLastBarPositionValid;

  2541.  

  2542.                      int32 newTransportFlags = 0;

  2543. -                    if (position.isPlaying)     newTransportFlags |= Vst2::kVstTransportPlaying;

  2544. -                    if (position.isRecording)   newTransportFlags |= Vst2::kVstTransportRecording;

  2545. +                    if (position.isPlaying)     newTransportFlags |= Vst2::vstTimingInfoFlagCurrentlyPlaying;

  2546. +                    if (position.isRecording)   newTransportFlags |= Vst2::vstTimingInfoFlagCurrentlyRecording;

  2547.  

  2548. -                    if (newTransportFlags != (vstHostTime.flags & (Vst2::kVstTransportPlaying

  2549. -                                                                   | Vst2::kVstTransportRecording)))

  2550. -                        vstHostTime.flags = (vstHostTime.flags & ~(Vst2::kVstTransportPlaying | Vst2::kVstTransportRecording)) | newTransportFlags | Vst2::kVstTransportChanged;

  2551. +                    if (newTransportFlags != (vstHostTime.flags & (Vst2::vstTimingInfoFlagCurrentlyPlaying

  2552. +                                                                   | Vst2::vstTimingInfoFlagCurrentlyRecording)))

  2553. +                        vstHostTime.flags = (vstHostTime.flags & ~(Vst2::vstTimingInfoFlagCurrentlyPlaying | Vst2::vstTimingInfoFlagCurrentlyRecording)) | newTransportFlags | Vst2::vstTimingInfoFlagTransportChanged;

  2554.                      else

  2555. -                        vstHostTime.flags &= ~Vst2::kVstTransportChanged;

  2556. +                        vstHostTime.flags &= ~Vst2::vstTimingInfoFlagTransportChanged;

  2557.  

  2558.                      switch (position.frameRate)

  2559.                      {

  2560. -                        case AudioPlayHead::fps24:       setHostTimeFrameRate (Vst2::kVstSmpte24fps, 24.0, position.timeInSeconds); break;

  2561. -                        case AudioPlayHead::fps25:       setHostTimeFrameRate (Vst2::kVstSmpte25fps, 25.0, position.timeInSeconds); break;

  2562. -                        case AudioPlayHead::fps30:       setHostTimeFrameRate (Vst2::kVstSmpte30fps, 30.0, position.timeInSeconds); break;

  2563. -                        case AudioPlayHead::fps60:       setHostTimeFrameRate (Vst2::kVstSmpte60fps, 60.0, position.timeInSeconds); break;

  2564. -

  2565. -                        case AudioPlayHead::fps23976:    setHostTimeFrameRateDrop (Vst2::kVstSmpte239fps,      24.0, position.timeInSeconds); break;

  2566. -                        case AudioPlayHead::fps2997:     setHostTimeFrameRateDrop (Vst2::kVstSmpte2997fps,     30.0, position.timeInSeconds); break;

  2567. -                        case AudioPlayHead::fps2997drop: setHostTimeFrameRateDrop (Vst2::kVstSmpte2997dfps, 30.0, position.timeInSeconds); break;

  2568. -                        case AudioPlayHead::fps30drop:   setHostTimeFrameRateDrop (Vst2::kVstSmpte30dfps,   30.0, position.timeInSeconds); break;

  2569. -                        case AudioPlayHead::fps60drop:   setHostTimeFrameRateDrop (Vst2::kVstSmpte599fps,      60.0, position.timeInSeconds); break;

  2570. +                        case AudioPlayHead::fps24:       setHostTimeFrameRate (Vst2::vstSmpteRateFps24, 24.0, position.timeInSeconds); break;

  2571. +                        case AudioPlayHead::fps25:       setHostTimeFrameRate (Vst2::vstSmpteRateFps25, 25.0, position.timeInSeconds); break;

  2572. +                        case AudioPlayHead::fps30:       setHostTimeFrameRate (Vst2::vstSmpteRateFps30, 30.0, position.timeInSeconds); break;

  2573. +                        case AudioPlayHead::fps60:       setHostTimeFrameRate (Vst2::vstSmpteRateFps60, 60.0, position.timeInSeconds); break;

  2574. +

  2575. +                        case AudioPlayHead::fps23976:    setHostTimeFrameRateDrop (Vst2::vstSmpteRateFps239,      24.0, position.timeInSeconds); break;

  2576. +                        case AudioPlayHead::fps2997:     setHostTimeFrameRateDrop (Vst2::vstSmpteRateFps2997,     30.0, position.timeInSeconds); break;

  2577. +                        case AudioPlayHead::fps2997drop: setHostTimeFrameRateDrop (Vst2::vstSmpteRateFps2997drop, 30.0, position.timeInSeconds); break;

  2578. +                        case AudioPlayHead::fps30drop:   setHostTimeFrameRateDrop (Vst2::vstSmpteRateFps30drop,   30.0, position.timeInSeconds); break;

  2579. +                        case AudioPlayHead::fps60drop:   setHostTimeFrameRateDrop (Vst2::vstSmpteRateFps599,      60.0, position.timeInSeconds); break;

  2580.                          default: break;

  2581.                      }

  2582.  

  2583.                      if (position.isLooping)

  2584.                      {

  2585. -                        vstHostTime.cycleStartPos = position.ppqLoopStart;

  2586. -                        vstHostTime.cycleEndPos   = position.ppqLoopEnd;

  2587. -                        vstHostTime.flags |= (Vst2::kVstCyclePosValid | Vst2::kVstTransportCycleActive);

  2588. +                        vstHostTime.loopStartPosition = position.ppqLoopStart;

  2589. +                        vstHostTime.loopEndPosition   = position.ppqLoopEnd;

  2590. +                        vstHostTime.flags |= (Vst2::vstTimingInfoFlagLoopPositionValid | Vst2::vstTimingInfoFlagLoopActive);

  2591.                      }

  2592.                      else

  2593.                      {

  2594. -                        vstHostTime.flags &= ~(Vst2::kVstCyclePosValid | Vst2::kVstTransportCycleActive);

  2595. +                        vstHostTime.flags &= ~(Vst2::vstTimingInfoFlagLoopPositionValid | Vst2::vstTimingInfoFlagLoopActive);

  2596.                      }

  2597.                  }

  2598.              }

  2599.  

  2600. -            vstHostTime.nanoSeconds = getVSTHostTimeNanoseconds();

  2601. +            vstHostTime.systemTimeNanoseconds = getVSTHostTimeNanoseconds();

  2602.  

  2603.              if (wantsMidiMessages)

  2604.              {

  2605. @@ -2424,13 +2422,13 @@ private:

  2606.                      midiEventsToSend.addEvent (midiData, numBytesOfMidiData,

  2607.                                                 jlimit (0, numSamples - 1, samplePosition));

  2608.  

  2609. -                vstEffect->dispatcher (vstEffect, Vst2::effProcessEvents, 0, 0, midiEventsToSend.events, 0);

  2610. +                vstEffect->dispatchFunction (vstEffect, Vst2::plugInOpcodePreAudioProcessingEvents, 0, 0, midiEventsToSend.events, 0);

  2611.              }

  2612.  

  2613.              _clearfp();

  2614.  

  2615.              // always ensure that the buffer is at least as large as the maximum number of channels

  2616. -            auto maxChannels = jmax (vstEffect->numInputs, vstEffect->numOutputs);

  2617. +            auto maxChannels = jmax (vstEffect->numInputChannels, vstEffect->numOutputChannels);

  2618.              auto channels = channelBuffer.get();

  2619.  

  2620.              if (numChannels < maxChannels)

  2621. @@ -2469,35 +2467,35 @@ private:

  2622.      //==============================================================================

  2623.      inline void invokeProcessFunction (AudioBuffer<float>& buffer, int32 sampleFrames)

  2624.      {

  2625. -        if ((vstEffect->flags & Vst2::effFlagsCanReplacing) != 0)

  2626. +        if ((vstEffect->flags & Vst2::vstEffectFlagInplaceAudio) != 0)

  2627.          {

  2628. -            vstEffect->processReplacing (vstEffect, buffer.getArrayOfWritePointers(),

  2629. +            vstEffect->processAudioInplaceFunction (vstEffect, buffer.getArrayOfWritePointers(),

  2630.                                                      buffer.getArrayOfWritePointers(), sampleFrames);

  2631.          }

  2632.          else

  2633.          {

  2634. -            outOfPlaceBuffer.setSize (vstEffect->numOutputs, sampleFrames);

  2635. +            outOfPlaceBuffer.setSize (vstEffect->numOutputChannels, sampleFrames);

  2636.              outOfPlaceBuffer.clear();

  2637.  

  2638. -            vstEffect->process (vstEffect, buffer.getArrayOfWritePointers(),

  2639. -                                           outOfPlaceBuffer.getArrayOfWritePointers(), sampleFrames);

  2640. +            vstEffect->processAudioFunction (vstEffect, buffer.getArrayOfWritePointers(),

  2641. +                                             outOfPlaceBuffer.getArrayOfWritePointers(), sampleFrames);

  2642.  

  2643. -            for (int i = vstEffect->numOutputs; --i >= 0;)

  2644. +            for (int i = vstEffect->numOutputChannels; --i >= 0;)

  2645.                  buffer.copyFrom (i, 0, outOfPlaceBuffer.getReadPointer (i), sampleFrames);

  2646.          }

  2647.      }

  2648.  

  2649.      inline void invokeProcessFunction (AudioBuffer<double>& buffer, int32 sampleFrames)

  2650.      {

  2651. -        vstEffect->processDoubleReplacing (vstEffect, buffer.getArrayOfWritePointers(),

  2652. +        vstEffect->processDoubleAudioInplaceFunction (vstEffect, buffer.getArrayOfWritePointers(),

  2653.                                                        buffer.getArrayOfWritePointers(), sampleFrames);

  2654.      }

  2655.  

  2656.      //==============================================================================

  2657.      void setHostTimeFrameRate (long frameRateIndex, double frameRate, double currentTime) noexcept

  2658.      {

  2659. -        vstHostTime.flags |= Vst2::kVstSmpteValid;

  2660. -        vstHostTime.smpteFrameRate   = (int32) frameRateIndex;

  2661. +        vstHostTime.flags |= Vst2::vstTimingInfoFlagSmpteValid;

  2662. +        vstHostTime.smpteRate   = (int32) frameRateIndex;

  2663.          vstHostTime.smpteOffset = (int32) (currentTime * 80.0 * frameRate + 0.5);

  2664.      }

  2665.  

  2666. @@ -2528,7 +2526,7 @@ private:

  2667.          if (vstEffect == nullptr)

  2668.              return {};

  2669.  

  2670. -        jassert (index >= 0 && index < vstEffect->numParams);

  2671. +        jassert (index >= 0 && index < vstEffect->numParameters);

  2672.          char nm[256] = { 0 };

  2673.          dispatch (opcode, index, 0, nm, 0);

  2674.          return String::createStringFromData (nm, (int) sizeof (nm)).trim();

  2675. @@ -2542,7 +2540,7 @@ private:

  2676.          {

  2677.              {

  2678.                  char nm[256] = { 0 };

  2679. -                dispatch (Vst2::effGetProgramName, 0, 0, nm, 0);

  2680. +                dispatch (Vst2::plugInOpcodeGetCurrentProgramName, 0, 0, nm, 0);

  2681.                  progName = String::createStringFromData (nm, (int) sizeof (nm)).trim();

  2682.              }

  2683.  

  2684. @@ -2586,7 +2584,7 @@ private:

  2685.              char nm[256] = { 0 };

  2686.  

  2687.              // only do this if the plugin can't use indexed names..

  2688. -            if (dispatch (Vst2::effGetProgramNameIndexed, 0, -1, nm, 0) == 0)

  2689. +            if (dispatch (Vst2::plugInOpcodeGetProgramName, 0, -1, nm, 0) == 0)

  2690.              {

  2691.                  auto oldProgram = getCurrentProgram();

  2692.                  MemoryBlock oldSettings;

  2693. @@ -2604,7 +2602,7 @@ private:

  2694.          }

  2695.      }

  2696.  

  2697. -    void handleMidiFromPlugin (const Vst2::VstEvents* events)

  2698. +    void handleMidiFromPlugin (const Vst2::VstEventBlock* events)

  2699.      {

  2700.          if (events != nullptr)

  2701.          {

  2702. @@ -2651,11 +2649,11 @@ private:

  2703.      }

  2704.  

  2705.      //==============================================================================

  2706. -    int getVersionNumber() const noexcept   { return vstEffect != nullptr ? vstEffect->version : 0; }

  2707. +    int getVersionNumber() const noexcept   { return vstEffect != nullptr ? vstEffect->plugInVersion : 0; }

  2708.  

  2709.      String getVersion() const

  2710.      {

  2711. -        auto v = (unsigned int) dispatch (Vst2::effGetVendorVersion, 0, 0, nullptr, 0);

  2712. +        auto v = (unsigned int) dispatch (Vst2::plugInOpcodeGetManufacturerVersion, 0, 0, nullptr, 0);

  2713.  

  2714.          String s;

  2715.  

  2716. @@ -2728,7 +2726,7 @@ private:

  2717.  

  2718.      void setPower (const bool on)

  2719.      {

  2720. -        dispatch (Vst2::effMainsChanged, 0, on ? 1 : 0, nullptr, 0);

  2721. +        dispatch (Vst2::plugInOpcodeResumeSuspend, 0, on ? 1 : 0, nullptr, 0);

  2722.          isPowerOn = on;

  2723.      }

  2724.  

  2725. @@ -2797,11 +2795,11 @@ public:

  2726.  

  2727.          activeVSTWindows.add (this);

  2728.  

  2729. -        Vst2::ERect* rect = nullptr;

  2730. -        dispatch (Vst2::effEditGetRect, 0, 0, &rect, 0);

  2731. +        Vst2::VstEditorBounds* rect = nullptr;

  2732. +        dispatch (Vst2::plugInOpcodeGetEditorBounds, 0, 0, &rect, 0);

  2733.  

  2734.          if (rect != nullptr)

  2735. -            setSize (rect->right - rect->left, rect->bottom - rect->top);

  2736. +            setSize (rect->rightmost - rect->leftmost, rect->lower - rect->upper);

  2737.          else

  2738.              setSize (1, 1);

  2739.  

  2740. @@ -2952,11 +2950,11 @@ public:

  2741.          setScaleFactorAndDispatchMessage (newScaleFactor);

  2742.  

  2743.         #if JUCE_WINDOWS

  2744. -        Vst2::ERect* rect = nullptr;

  2745. -        dispatch (Vst2::effEditGetRect, 0, 0, &rect, 0);

  2746. +        Vst2::VstEditorBounds* rect = nullptr;

  2747. +        dispatch (Vst2::plugInOpcodeGetEditorBounds, 0, 0, &rect, 0);

  2748.  

  2749. -        if (! isWindowSizeCorrectForPlugin (roundToInt ((rect->right - rect->left) / nativeScaleFactor),

  2750. -                                            roundToInt ((rect->bottom - rect->top) / nativeScaleFactor)))

  2751. +        if (! isWindowSizeCorrectForPlugin (roundToInt ((rect->rightmost - rect->leftmost) / nativeScaleFactor),

  2752. +                                            roundToInt ((rect->lower - rect->upper) / nativeScaleFactor)))

  2753.              return;

  2754.         #endif

  2755.  

  2756. @@ -2971,7 +2969,7 @@ public:

  2757.          nativeScaleFactor = (float) newScaleFactor;

  2758.  

  2759.          if (pluginRespondsToDPIChanges)

  2760. -            dispatch (Vst2::effVendorSpecific,

  2761. +            dispatch (Vst2::plugInOpcodeManufacturerSpecific,

  2762.                        JUCE_MULTICHAR_CONSTANT ('P', 'r', 'e', 'S'),

  2763.                        JUCE_MULTICHAR_CONSTANT ('A', 'e', 'C', 's'),

  2764.                        nullptr, nativeScaleFactor);

  2765. @@ -3000,7 +2998,7 @@ public:

  2766.              if (! reentrantGuard)

  2767.              {

  2768.                  reentrantGuard = true;

  2769. -                plugin.dispatch (Vst2::effEditIdle, 0, 0, nullptr, 0);

  2770. +                plugin.dispatch (Vst2::plugInOpcodeEditorIdle, 0, 0, nullptr, 0);

  2771.                  reentrantGuard = false;

  2772.              }

  2773.  

  2774. @@ -3032,7 +3030,7 @@ public:

  2775.          activeVSTWindows.add (this);

  2776.  

  2777.         #if JUCE_MAC

  2778. -        dispatch (Vst2::effEditTop, 0, 0, nullptr, 0);

  2779. +        dispatch (Vst2::plugInOpcodeeffEditorTop, 0, 0, nullptr, 0);

  2780.         #endif

  2781.      }

  2782.  

  2783. @@ -3081,24 +3079,24 @@ private:

  2784.  

  2785.          isOpen = true;

  2786.  

  2787. -        Vst2::ERect* rect = nullptr;

  2788. -        dispatch (Vst2::effEditGetRect, 0, 0, &rect, 0);

  2789. -        dispatch (Vst2::effEditOpen, 0, 0, parentWindow, 0);

  2790. +        Vst2::VstEditorBounds* rect = nullptr;

  2791. +        dispatch (Vst2::plugInOpcodeGetEditorBounds, 0, 0, &rect, 0);

  2792. +        dispatch (Vst2::plugInOpcodeOpenEditor, 0, 0, parentWindow, 0);

  2793.  

  2794.          // do this before and after like in the steinberg example

  2795. -        dispatch (Vst2::effEditGetRect, 0, 0, &rect, 0);

  2796. -        dispatch (Vst2::effGetProgram, 0, 0, nullptr, 0); // also in steinberg code

  2797. +        dispatch (Vst2::plugInOpcodeGetEditorBounds, 0, 0, &rect, 0);

  2798. +        dispatch (Vst2::plugInOpcodeGetCurrentProgram, 0, 0, nullptr, 0); // also in steinberg code

  2799.  

  2800.          // Install keyboard hooks

  2801. -        pluginWantsKeys = (dispatch (Vst2::effKeysRequired, 0, 0, nullptr, 0) == 0);

  2802. +        pluginWantsKeys = (dispatch (Vst2::plugInOpcodeKeyboardFocusRequired, 0, 0, nullptr, 0) == 0);

  2803.  

  2804.          // double-check it's not too tiny

  2805.          int w = 250, h = 150;

  2806.  

  2807.          if (rect != nullptr)

  2808.          {

  2809. -            w = rect->right - rect->left;

  2810. -            h = rect->bottom - rect->top;

  2811. +            w = rect->rightmost - rect->leftmost;

  2812. +            h = rect->lower - rect->upper;

  2813.  

  2814.              if (w == 0 || h == 0)

  2815.              {

  2816. @@ -3136,15 +3134,15 @@ private:

  2817.              dpiDisabler.reset (new ScopedDPIAwarenessDisabler());

  2818.         #endif

  2819.  

  2820. -        Vst2::ERect* rect = nullptr;

  2821. -        dispatch (Vst2::effEditGetRect, 0, 0, &rect, 0);

  2822. +        Vst2::VstEditorBounds* rect = nullptr;

  2823. +        dispatch (Vst2::plugInOpcodeGetEditorBounds, 0, 0, &rect, 0);

  2824.  

  2825.         #if JUCE_WINDOWS && JUCE_WIN_PER_MONITOR_DPI_AWARE

  2826.          // some plug-ins are fussy about this

  2827.          dpiDisabler.reset (nullptr);

  2828.         #endif

  2829.  

  2830. -        dispatch (Vst2::effEditOpen, 0, 0, getWindowHandle(), 0);

  2831. +        dispatch (Vst2::plugInOpcodeOpenEditor, 0, 0, getWindowHandle(), 0);

  2832.  

  2833.         #if JUCE_WINDOWS && JUCE_WIN_PER_MONITOR_DPI_AWARE

  2834.          if (! pluginRespondsToDPIChanges)

  2835. @@ -3152,11 +3150,11 @@ private:

  2836.         #endif

  2837.  

  2838.          // do this before and after like in the steinberg example

  2839. -        dispatch (Vst2::effEditGetRect, 0, 0, &rect, 0);

  2840. -        dispatch (Vst2::effGetProgram, 0, 0, nullptr, 0); // also in steinberg code

  2841. +        dispatch (Vst2::plugInOpcodeGetEditorBounds, 0, 0, &rect, 0);

  2842. +        dispatch (Vst2::plugInOpcodeGetCurrentProgram, 0, 0, nullptr, 0); // also in steinberg code

  2843.  

  2844.          // Install keyboard hooks

  2845. -        pluginWantsKeys = (dispatch (Vst2::effKeysRequired, 0, 0, nullptr, 0) == 0);

  2846. +        pluginWantsKeys = (dispatch (Vst2::plugInOpcodeKeyboardFocusRequired, 0, 0, nullptr, 0) == 0);

  2847.  

  2848.         #if JUCE_WINDOWS

  2849.          originalWndProc = 0;

  2850. @@ -3191,8 +3189,8 @@ private:

  2851.  

  2852.          if (rect != nullptr)

  2853.          {

  2854. -            auto rw = rect->right - rect->left;

  2855. -            auto rh = rect->bottom - rect->top;

  2856. +            auto rw = rect->rightmost - rect->leftmost;

  2857. +            auto rh = rect->lower - rect->upper;

  2858.  

  2859.              if ((rw > 50 && rh > 50 && rw < 2000 && rh < 2000 && (! isWithin (w, rw, 2) || ! isWithin (h, rh, 2)))

  2860.                  || ((w == 0 && rw > 0) || (h == 0 && rh > 0)))

  2861. @@ -3223,8 +3221,8 @@ private:

  2862.  

  2863.          if (rect != nullptr)

  2864.          {

  2865. -            w = rect->right - rect->left;

  2866. -            h = rect->bottom - rect->top;

  2867. +            w = rect->rightmost - rect->leftmost;

  2868. +            h = rect->lower - rect->upper;

  2869.  

  2870.              if (w == 0 || h == 0)

  2871.              {

  2872. @@ -3266,7 +3264,7 @@ private:

  2873.  

  2874.              JUCE_VST_LOG ("Closing VST UI: " + plugin.getName());

  2875.              isOpen = false;

  2876. -            dispatch (Vst2::effEditClose, 0, 0, nullptr, 0);

  2877. +            dispatch (Vst2::plugInOpcodeCloseEditor, 0, 0, nullptr, 0);

  2878.              stopTimer();

  2879.  

  2880.             #if JUCE_WINDOWS

  2881. @@ -3312,11 +3310,11 @@ private:

  2882.         #if JUCE_WIN_PER_MONITOR_DPI_AWARE

  2883.          if (! pluginRespondsToDPIChanges)

  2884.          {

  2885. -            Vst2::ERect* rect = nullptr;

  2886. -            dispatch (Vst2::effEditGetRect, 0, 0, &rect, 0);

  2887. +            Vst2::VstEditorBounds* rect = nullptr;

  2888. +            dispatch (Vst2::plugInOpcodeGetEditorBounds, 0, 0, &rect, 0);

  2889.  

  2890. -            auto w = roundToInt ((rect->right - rect->left) / nativeScaleFactor);

  2891. -            auto h = roundToInt ((rect->bottom - rect->top) / nativeScaleFactor);

  2892. +            auto w = roundToInt ((rect->rightmost - rect->leftmost) / nativeScaleFactor);

  2893. +            auto h = roundToInt ((rect->lower - rect->upper) / nativeScaleFactor);

  2894.  

  2895.              if (! isWindowSizeCorrectForPlugin (w, h))

  2896.              {

  2897. @@ -3412,17 +3410,17 @@ private:

  2898.              if (owner.isOpen)

  2899.              {

  2900.                  owner.isOpen = false;

  2901. -                owner.dispatch (Vst2::effEditClose, 0, 0, 0, 0);

  2902. -                owner.dispatch (Vst2::effEditSleep, 0, 0, 0, 0);

  2903. +                owner.dispatch (Vst2::plugInOpcodeCloseEditor, 0, 0, 0, 0);

  2904. +                owner.dispatch (Vst2::plugInOpcodeSleepEditor, 0, 0, 0, 0);

  2905.              }

  2906.          }

  2907.  

  2908.          bool getEmbeddedViewSize (int& w, int& h) override

  2909.          {

  2910. -            Vst2::ERect* rect = nullptr;

  2911. -            owner.dispatch (Vst2::effEditGetRect, 0, 0, &rect, 0);

  2912. -            w = rect->right - rect->left;

  2913. -            h = rect->bottom - rect->top;

  2914. +            Vst2::VstEditorBounds* rect = nullptr;

  2915. +            owner.dispatch (Vst2::plugInOpcodeGetEditorBounds, 0, 0, &rect, 0);

  2916. +            w = rect->rightmost - rect->leftmost;

  2917. +            h = rect->lower - rect->upper;

  2918.              return true;

  2919.          }

  2920.  

  2921. @@ -3432,7 +3430,7 @@ private:

  2922.              {

  2923.                  alreadyInside = true;

  2924.                  getTopLevelComponent()->toFront (true);

  2925. -                owner.dispatch (Vst2::effEditMouse, x, y, 0, 0);

  2926. +                owner.dispatch (Vst2::plugInOpcodeGetMouse, x, y, 0, 0);

  2927.                  alreadyInside = false;

  2928.              }

  2929.              else

  2930. @@ -3446,13 +3444,13 @@ private:

  2931.              if (auto* peer = getPeer())

  2932.              {

  2933.                  auto pos = peer->globalToLocal (getScreenPosition());

  2934. -                Vst2::ERect r;

  2935. -                r.left   = (int16) pos.getX();

  2936. -                r.top    = (int16) pos.getY();

  2937. -                r.right  = (int16) (r.left + getWidth());

  2938. -                r.bottom = (int16) (r.top + getHeight());

  2939. +                Vst2::VstEditorBounds r;

  2940. +                r.leftmost  = (int16) pos.getX();

  2941. +                r.upper     = (int16) pos.getY();

  2942. +                r.rightmost = (int16) (r.leftmost + getWidth());

  2943. +                r.lower     = (int16) (r.upper + getHeight());

  2944.  

  2945. -                owner.dispatch (Vst2::effEditDraw, 0, 0, &r, 0);

  2946. +                owner.dispatch (Vst2::plugInOpcodeDrawEditor, 0, 0, &r, 0);

  2947.              }

  2948.          }

  2949.  

  2950. @@ -3501,10 +3499,10 @@ AudioProcessorEditor* VSTPluginInstance::createEditor()

  2951.  

  2952.  //==============================================================================

  2953.  // entry point for all callbacks from the plugin

  2954. -static pointer_sized_int VSTCALLBACK audioMaster (Vst2::AEffect* effect, int32 opcode, int32 index, pointer_sized_int value, void* ptr, float opt)

  2955. +static pointer_sized_int VSTINTERFACECALL audioMaster (Vst2::VstEffectInterface* effect, int32 opcode, int32 index, pointer_sized_int value, void* ptr, float opt)

  2956.  {

  2957.      if (effect != nullptr)

  2958. -        if (auto* instance = (VSTPluginInstance*) (effect->resvd2))

  2959. +        if (auto* instance = (VSTPluginInstance*) (effect->hostSpace2))

  2960.              return instance->handleCallback (opcode, index, value, ptr, opt);

  2961.  

  2962.      return VSTPluginInstance::handleGeneralCallback (opcode, index, value, ptr, opt);

  2963. @@ -3555,7 +3553,7 @@ void VSTPluginFormat::findAllTypesForFile (OwnedArray<PluginDescription>& result

  2964.          // Normal plugin...

  2965.          results.add (new PluginDescription (desc));

  2966.  

  2967. -        instance->dispatch (Vst2::effOpen, 0, 0, nullptr, 0);

  2968. +        instance->dispatch (Vst2::plugInOpcodeOpen, 0, 0, nullptr, 0);

  2969.      }

  2970.      else

  2971.      {

  2972. @@ -3563,7 +3561,7 @@ void VSTPluginFormat::findAllTypesForFile (OwnedArray<PluginDescription>& result

  2973.          for (;;)

  2974.          {

  2975.              char shellEffectName [256] = { 0 };

  2976. -            auto uid = (int) instance->dispatch (Vst2::effShellGetNextPlugin, 0, 0, shellEffectName, 0);

  2977. +            auto uid = (int) instance->dispatch (Vst2::plugInOpcodeNextPlugInUniqueID, 0, 0, shellEffectName, 0);

  2978.  

  2979.              if (uid == 0)

  2980.                  break;

  2981. @@ -3789,8 +3787,8 @@ void VSTPluginFormat::setExtraFunctions (AudioPluginInstance* plugin, ExtraFunct

  2982.  

  2983.  AudioPluginInstance* VSTPluginFormat::getPluginInstanceFromVstEffectInterface (void* aEffect)

  2984.  {

  2985. -    if (auto* vstAEffect = reinterpret_cast<Vst2::AEffect*> (aEffect))

  2986. -        if (auto* instanceVST = reinterpret_cast<VSTPluginInstance*> (vstAEffect->resvd2))

  2987. +    if (auto* vstAEffect = reinterpret_cast<Vst2::VstEffectInterface*> (aEffect))

  2988. +        if (auto* instanceVST = reinterpret_cast<VSTPluginInstance*> (vstAEffect->hostSpace2))

  2989.              return dynamic_cast<AudioPluginInstance*> (instanceVST);

  2990.  

  2991.      return nullptr;