Remove old unused vst3sdk folder/files

Signed-off-by: falkTX <falktx@falktx.com>

source/includes/vst3sdk/JUCE_README.md

@@ -1,6 +0,0 @@
-This list details modifications made to the VST3 SDK in order to facilitate
-inclusion in JUCE.
-
-- `#warning` directives were removed from fstring.cpp, as these cannot be
-  silenced with a `pragma GCC diagnostic ignored "-Wcpp"` when building with
-  g++.

source/includes/vst3sdk/LICENSE.txt

@@ -1,41 +0,0 @@
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-This license applies only to files referencing this license,
-for other files of the Software Development Kit the respective embedded license text
-is applicable. The license can be found at: www.steinberg.net/sdklicenses_vst3
-
-This Software Development Kit is licensed under the terms of the Steinberg VST3 License,
-or alternatively under the terms of the General Public License (GPL) Version 3.
-You may use the Software Development Kit according to either of these licenses as it is
-most appropriate for your project on a case-by-case basis (commercial or not).
-
-a) Proprietary Steinberg VST3 License
-The Software Development Kit may not be distributed in parts or its entirety
-without prior written agreement by Steinberg Media Technologies GmbH.
-The SDK must not be used to re-engineer or manipulate any technology used
-in any Steinberg or Third-party application or software module,
-unless permitted by law.
-Neither the name of the Steinberg Media Technologies GmbH nor the names of its
-contributors may be used to endorse or promote products derived from this
-software without specific prior written permission.
-Before publishing a software under the proprietary license, you need to obtain a copy
-of the License Agreement signed by Steinberg Media Technologies GmbH.
-The Steinberg VST SDK License Agreement can be found at:
-www.steinberg.net/en/company/developers.html
-
-THE SDK IS PROVIDED BY STEINBERG MEDIA TECHNOLOGIES GMBH "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-IN NO EVENT SHALL STEINBERG MEDIA TECHNOLOGIES GMBH BE LIABLE FOR ANY DIRECT,
-INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
-OF THE POSSIBILITY OF SUCH DAMAGE.
-
-b) General Public License (GPL) Version 3
-Details of these licenses can be found at: www.gnu.org/licenses/gpl-3.0.html
-//----------------------------------------------------------------------------------

source/includes/vst3sdk/README.md

@@ -1,10 +0,0 @@
-# Welcome to VST 3 SDK Interfaces
-
-Here are located all VST interfaces definitions (including VST Component/Controller, UI, Test).
-
-## License & Usage guidelines
-
-More details are found at [www.steinberg.net/sdklicenses_vst3](http://www.steinberg.net/sdklicenses_vst3)
-
-----
-Return to [VST 3 SDK](https://github.com/steinbergmedia/vst3sdk)

source/includes/vst3sdk/base/LICENSE.txt

@@ -1,27 +0,0 @@
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------

source/includes/vst3sdk/base/README.md

@@ -1,9 +0,0 @@
-# Welcome to VST SDK 3 base
-
-Here you can find some helper classes useful for developing VST3 Plug-Ins.
-
-## License & Usage guidelines
-More details are found at [www.steinberg.net/sdklicenses_vst3](http://www.steinberg.net/sdklicenses_vst3)
-
-----
-Return to [VST 3 SDK](https://github.com/steinbergmedia/vst3sdk)

source/includes/vst3sdk/base/source/baseiids.cpp

@@ -1,52 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/source/baseidds.cpp
-// Created by  : Steinberg, 01/2008
-// Description : Basic Interface
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/base/istringresult.h"
-#include "pluginterfaces/base/ipersistent.h"
-
-
-namespace Steinberg {
-
-DEF_CLASS_IID (IString)
-DEF_CLASS_IID (IStringResult)
-
-DEF_CLASS_IID (IPersistent)
-DEF_CLASS_IID (IAttributes)
-DEF_CLASS_IID (IAttributes2)
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/base/source/classfactoryhelpers.h

@@ -1,87 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/source/classfactoryhelpers.h
-// Created by  : Steinberg, 03/2017
-// Description : Class factory
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-//------------------------------------------------------------------------------
-// Helper Macros. Not intended for direct use.
-// Use:
-//	META_CLASS(className),
-//	META_CLASS_IFACE(className,Interface),
-//	META_CLASS_SINGLE(className,Interface)
-// instead.
-//------------------------------------------------------------------------------
-#define META_CREATE_FUNC(funcName) static FUnknown* funcName ()
-
-#define CLASS_CREATE_FUNC(className)                                               \
-	namespace Meta {                                                               \
-	META_CREATE_FUNC (make##className) { return (NEW className)->unknownCast (); } \
-	}
-
-#define SINGLE_CREATE_FUNC(className)                                                     \
-	namespace Meta {                                                                      \
-	META_CREATE_FUNC (make##className) { return className::instance ()->unknownCast (); } \
-	}
-
-#define _META_CLASS(className)                                                         \
-	namespace Meta {                                                                   \
-	static Steinberg::MetaClass meta##className ((#className), Meta::make##className); \
-	}
-
-#define _META_CLASS_IFACE(className, Interface)                                                  \
-	namespace Meta {                                                                             \
-	static Steinberg::MetaClass meta##Interface##className ((#className), Meta::make##className, \
-	                                                        Interface##_iid);                    \
-	}
-
-/** TODO
- */
-#define META_CLASS(className)     \
-	CLASS_CREATE_FUNC (className) \
-	_META_CLASS (className)
-
-/** TODO
- */
-#define META_CLASS_IFACE(className, Interface) \
-	CLASS_CREATE_FUNC (className)              \
-	_META_CLASS_IFACE (className, Interface)
-
-/** TODO
- */
-#define META_CLASS_SINGLE(className, Interface) \
-	SINGLE_CREATE_FUNC (className)              \
-	_META_CLASS_IFACE (className, Interface)

source/includes/vst3sdk/base/source/fbuffer.cpp

@@ -1,643 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/source/fbuffer.cpp
-// Created by  : Steinberg, 2008
-// Description : 
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "base/source/fbuffer.h"
-#include "base/source/fstring.h"
-#include <cstdlib>
-
-namespace Steinberg {
-
-//-------------------------------------------------------------------------------------
-Buffer::Buffer () 
-: buffer (nullptr)
-, memSize (0)
-, fillSize (0)
-, delta (defaultDelta)
-{}
-
-//-------------------------------------------------------------------------------------
-Buffer::Buffer (uint32 s, uint8 initVal)
-: buffer (nullptr)
-, memSize (s)
-, fillSize (0)
-, delta (defaultDelta)
-{
- 	if (memSize == 0)
-		return;		
-	buffer = (int8*)::malloc (memSize);
-	if (buffer)
-		memset (buffer, initVal, memSize);
-	else
-		memSize = 0;
-}
-
-//-------------------------------------------------------------------------------------
-Buffer::Buffer (uint32 s)
-: buffer (nullptr)
-, memSize (s)
-, fillSize (0)
-, delta (defaultDelta)
-{
- 	if (memSize == 0)
-		return;		
- 	buffer = (int8*)::malloc (memSize);
-	if (!buffer)
-		memSize = 0;
-}
-
-//-------------------------------------------------------------------------------------
-Buffer::Buffer (const void* b , uint32 s) 
-: buffer (nullptr)
-, memSize (s)
-, fillSize (s)
-, delta (defaultDelta)
-{
- 	if (memSize == 0)
-		return;
- 	buffer = (int8*)::malloc (memSize);
- 	if (buffer)
-		memcpy (buffer, b, memSize);
-	else
-	{
-		memSize = 0;
-		fillSize = 0;
-	}
-}
-
-//-------------------------------------------------------------------------------------
-Buffer::Buffer (const Buffer& bufferR)
-: buffer (nullptr)
-, memSize (bufferR.memSize)
-, fillSize (bufferR.fillSize)
-, delta (bufferR.delta)
-{
- 	if (memSize == 0)
-		return;
-
- 	buffer = (int8*)::malloc (memSize);
- 	if (buffer)
-		memcpy (buffer, bufferR.buffer, memSize);
-	else
-		memSize = 0;
-}
-
-//-------------------------------------------------------------------------------------
-Buffer::~Buffer ()
-{
- 	if (buffer)
-		::free (buffer);
- 	buffer = nullptr;
-}
-
-//-------------------------------------------------------------------------------------
-void Buffer::operator = (const Buffer& b2)
-{
- 	if (&b2 != this) 
-	{
-		setSize (b2.memSize);		
-		if (b2.memSize > 0 && buffer)
-			memcpy (buffer, b2.buffer, b2.memSize);
-		fillSize = b2.fillSize;
-		delta = b2.delta;
- 	}
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::operator == (const Buffer& b2)const
-{
-	if (&b2 == this)
-		return true;
-	if (b2.getSize () != getSize ())
-		return false;
-	return memcmp (this->int8Ptr (), b2.int8Ptr (), getSize ()) == 0 ? true : false;		
-}
-
-//-------------------------------------------------------------------------------------
-uint32 Buffer::get (void* b, uint32 size)
-{
-	uint32 maxGet = memSize - fillSize;
-	if (size > maxGet)
-		size = maxGet;
-	if (size > 0)
-		memcpy (b, buffer + fillSize, size);
-	fillSize += size;
-	return size;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::put (char16 c)
-{
-	return put ((const void*)&c, sizeof (c));
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::put (uint8 byte)
-{
-	if (grow (fillSize + 1) == false)
-		return false;
- 	
-  	buffer [fillSize++] = byte;
-  	return true;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::put (char c)
-{
-	if (grow (fillSize + 1) == false)
-		return false;
- 	
-  	buffer [fillSize++] = c;
-  	return true;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::put (const void* toPut, uint32 s)
-{
-	if (!toPut)
-		return false;
-
-	if (grow (fillSize + s) == false)
-		return false;
-
-	memcpy (buffer + fillSize, toPut, s);
-	fillSize += s;
-	return true;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::put (const String& str)
-{ 
-	return put ((const void*)str.text () , (str.length () + 1) * sizeof (tchar)); 
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::appendString8 (const char8* s)
-{
-	if (!s)
-		return false;
-
-	uint32 len = (uint32) strlen (s);
-	return put (s, len);
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::appendString16 (const char16* s)
-{
-	if (!s)
-		return false;
-	ConstString str (s);
-	uint32 len = (uint32) str.length () * sizeof (char16);
-	return put (s, len);
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::prependString8 (const char8* s)
-{
-	if (!s)
-		return false;
-
-	uint32 len = (uint32) strlen (s);
-	if (len > 0)
-	{
-		shiftStart (len);
-		memcpy (buffer, s, len);
-		return true;
-	}
-	return false;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::prependString16 (const char16* s)
-{
-	if (!s)
-		return false;
-
-	ConstString str (s);
-	uint32 len = (uint32) str.length () * sizeof (char16);
-	
-	if (len > 0)
-	{
-		shiftStart (len);
-		memcpy (buffer, s, len);
-		return true;
-	}
-	return false;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::prependString8 (char8 c)
-{
-	shiftStart (sizeof (char));
-	char* b = (char*)buffer;
-	b [0] = c;
-	return true;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::prependString16 (char16 c)
-{
-	shiftStart (sizeof (char16));
-	char16* b = (char16*)buffer;
-	b [0] = c;
-	return true;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::copy (uint32 from, uint32 to, uint32 bytes)
-{
-	if (from + bytes > memSize || bytes == 0)
-		return false;
-	
-	if (to + bytes > memSize)
-		setSize (to + bytes);
-	
-	if (from + bytes > to && from < to)
-	{              // overlap
-		Buffer tmp (buffer + from, bytes);
-		memcpy (buffer + to, tmp, bytes);
-	}
-	else	
-		memcpy (buffer + to, buffer + from, bytes);
-	return true;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::makeHexString (String& result)
-{
-	unsigned char* data = uint8Ptr ();
-	uint32 bytes = getSize ();
-
-	if (data == nullptr || bytes == 0)
-		return false;
-
-	char8* stringBuffer = (char8*)malloc ((bytes * 2) + 1);
-	if (!stringBuffer)
-		return false;
-
-	int32 count = 0;
-	while (bytes > 0)
-	{
-		unsigned char t1 = ((*data) >> 4) & 0x0F;
-		unsigned char t2 = (*data) & 0x0F;
-		if (t1 < 10)
-			t1 += '0';
-		else
-			t1 = t1 - 10 + 'A';
-		if (t2 < 10)
-			t2 += '0';
-		else
-			t2 = t2 - 10 + 'A';
-		
-		stringBuffer [count++] = t1;
-		stringBuffer [count++] = t2;
-		data++;
-		bytes--;
-	}
-	stringBuffer [count] = 0;
-
-	result.take ((void*)stringBuffer, false);
-	return true;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::fromHexString (const char8* string)
-{
-	flush ();
-	if (string == nullptr)
-		return false;
-
-	int32 len = strlen8 (string);
-	if (len == 0 || ((len & 1) == 1)/*odd number*/ )
-		return false;
-
-	setSize (len / 2);
-	unsigned char* data = uint8Ptr ();
-
-	bool upper = true;
-	int32 count = 0;
-	while (count < len)
-	{
-		char c = string [count];
-
-		unsigned char d = 0;
-		if (c >= '0' && c <= '9')		d += c - '0';
-		else if (c >= 'A' && c <= 'F')	d += c - 'A' + 10;
-		else if (c >= 'a' && c <= 'f')	d += c - 'a' + 10;
-		else return false; // no hex string
-
-		if (upper)
-			data [count >> 1] = static_cast<unsigned char> (d << 4);
-		else
-			data [count >> 1] += d;
-
-		upper = !upper;
-		count++;
-	}
-	setFillSize (len / 2);
-	return true;
-}
-
-//------------------------------------------------------------------------
-void Buffer::set (uint8 value)
-{
-	if (buffer)
-		memset (buffer, value, memSize);
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::setFillSize (uint32 c)
-{
-	if (c <= memSize)
-	{
-		fillSize = c;
-		return true;	
-	}
-	return false;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::truncateToFillSize ()
-{
-	if (fillSize < memSize)
-		setSize (fillSize);
-	
-	return true;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::grow (uint32 newSize)
-{
-	if (newSize > memSize)
-	{
-		if (delta == 0)
-			delta = defaultDelta;
-		uint32 s = ((newSize + delta - 1) / delta) * delta;
-		return setSize (s);
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-void Buffer::shiftAt (uint32 position, int32 amount)
-{
-	if (amount > 0)
-	{
-		if (grow (fillSize + amount))
-		{
-			if (position < fillSize)
-				memmove (buffer + amount + position, buffer + position, fillSize - position);
-			
-			fillSize += amount;
-		}
-	}	
-	else if (amount < 0 && fillSize > 0)
-	{
-		uint32 toRemove = -amount;
-	
-		if (toRemove < fillSize)
-		{
-			if (position < fillSize)
-				memmove (buffer + position, buffer + toRemove + position, fillSize - position - toRemove);
-			fillSize -= toRemove;
-		}
-	}
-}
-
-//-------------------------------------------------------------------------------------
-void Buffer::move (int32 amount, uint8 initVal)
-{
-	if (memSize == 0)
-		return;
-
-	if (amount > 0)
-	{
-		if ((uint32)amount < memSize)
-		{
-			memmove (buffer + amount, buffer, memSize - amount);
-			memset (buffer, initVal, amount);
-		}
-		else
-			memset (buffer, initVal, memSize);
-	}
-	else
-	{	
-		uint32 toRemove = -amount;
-		if (toRemove < memSize)
-		{
-			memmove (buffer, buffer + toRemove, memSize - toRemove);
-			memset (buffer + memSize - toRemove, initVal, toRemove);	
-		}
-		else
-			memset (buffer, initVal, memSize);	
-	}
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::setSize (uint32 newSize)
-{
-	if (memSize != newSize)
-	{
- 		if (buffer)
-		{
-			if (newSize > 0)
-			{
-				int8* newBuffer = (int8*) ::realloc (buffer, newSize);
-				if (newBuffer == nullptr)
-				{
-					newBuffer = (int8*)::malloc (newSize);
-					if (newBuffer)
-					{
-						uint32 tmp = newSize;
-						if (tmp > memSize)
-							tmp = memSize;
-						memcpy (newBuffer, buffer, tmp);
-						::free (buffer);
-						buffer = newBuffer;
-					}
-					else
-					{
-						::free (buffer);
-						buffer = nullptr;
-					}
-				}
-				else
-					buffer = newBuffer;
-			}
-			else
-			{
-				::free (buffer);
-				buffer = nullptr;
-			}
-		}
-		else
-			buffer = (int8*)::malloc (newSize);
-
-		if (newSize > 0 && !buffer)
-			memSize = 0;
-		else
-			memSize = newSize;
-		if (fillSize > memSize)
-			fillSize = memSize;
-	}
-
-	return (newSize > 0) == (buffer != nullptr);
-}
-
-//-------------------------------------------------------------------------------------
-void Buffer::fillup (uint8 value)
-{
-	if (getFree () > 0)
-		memset (buffer + fillSize, value, getFree ());
-}
-
-//-------------------------------------------------------------------------------------
-int8* Buffer::operator + (uint32 i)
-{
-	if (i < memSize)
-		return buffer + i;
-	else
-	{
-		static int8 eof;
-		eof = 0;
-		return &eof;
-	}
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::swap (int16 swapSize)
-{
-	return swap (buffer, memSize, swapSize);
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::swap (void* buffer, uint32 bufferSize, int16 swapSize)
-{
-	if (swapSize != kSwap16 && swapSize != kSwap32 && swapSize != kSwap64)
-		return false;
-	
-	if (swapSize == kSwap16)
-	{
-		for (uint32 count = 0 ; count < bufferSize ; count += 2)
-		{
-			SWAP_16 ( * (((int16*)buffer) + count) );
-		}
-	}
-	else if (swapSize == kSwap32)
-	{
-		for (uint32 count = 0 ; count < bufferSize ; count += 4) 
-		{
-			SWAP_32 ( * (((int32*)buffer) + count) );
-		}
-	}
-	else if (swapSize == kSwap64)
-	{
-		for (uint32 count = 0 ; count < bufferSize ; count += 8) 
-		{
-			SWAP_64 ( * (((int64*)buffer) + count) );
-		}
-	}
-
-	return true;
-}
-
-//-------------------------------------------------------------------------------------
-void Buffer::take (Buffer& from)
-{
-	setSize (0);
-	memSize = from.memSize;
-	fillSize = from.fillSize;	
-	buffer = from.buffer;
-	from.buffer = nullptr;
-	from.memSize = 0;
-	from.fillSize = 0;
-}
-
-//-------------------------------------------------------------------------------------
-int8* Buffer::pass ()
-{
-	int8* res = buffer;
-	buffer = nullptr;
-	memSize = 0;
-	fillSize = 0;
-	return res;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::toWideString (int32 sourceCodePage)
-{
-	if (getFillSize () > 0)
-	{
-		if (str8 () [getFillSize () - 1] != 0) // multiByteToWideString only works with 0-terminated strings
-			endString8 ();
-
-		Buffer dest (getFillSize () * sizeof (char16));
-		int32 result = String::multiByteToWideString (dest.str16 (), buffer, dest.getFree () / sizeof (char16), sourceCodePage);
-		if (result > 0)
-		{
-			dest.setFillSize ((result - 1) * sizeof (char16));
-			take (dest);
-			return true;
-		}
-		return false;
-	}
-	return true;
-}
-
-//-------------------------------------------------------------------------------------
-bool Buffer::toMultibyteString (int32 destCodePage)
-{
-	if (getFillSize () > 0)
-	{
-		int32 textLength = getFillSize () / sizeof (char16); // wideStringToMultiByte only works with 0-terminated strings
-		if (str16 () [textLength - 1] != 0)
-			endString16 ();
-
-		Buffer dest (getFillSize ());
-		int32 result = String::wideStringToMultiByte (dest.str8 (), str16 (), dest.getFree (), destCodePage);
-		if (result > 0)
-		{
-			dest.setFillSize (result - 1);
-			take (dest);
-			return true;
-		}
-		return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/base/source/fbuffer.h

@@ -1,306 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/source/fbuffer.h
-// Created by  : Steinberg, 2008
-// Description : 
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/ftypes.h"
-#include <cstring> 
-
-namespace Steinberg {
-class String;
-
-//------------------------------------------------------------------------
-/** Buffer.
-@ingroup adt
-
-A Buffer is an object-oriented wrapper for a piece of memory.
-It adds several utility functions, e.g. for managing the size of the Buffer,
-appending or prepending values or strings to it.
-Internally it uses the standard memory functions malloc(), free(), etc. */
-//------------------------------------------------------------------------
-class Buffer
-{
-public:
-//---------------------------------------------------------------------
-	
-	/**	Default constructor, allocates no memory at all.
-	*/
-	Buffer ();
-
-	/**	Constructor - creates a new Buffer with a given size and copies contents from optional memory pointer.
-	\param[in] b : optional memory pointer with the size of at least the given size
-	\param[in] size : the size of the new Buffer to be allocated, in bytes.
-	*/
-	Buffer (const void* b, uint32 size);
-
-	/**	Constructor - creates a new Buffer with a given size and fills it all with a given value.
-	\param[in] size : the size of the new Buffer to be allocated, in bytes.
-	\param[in] initVal : the initial value the Buffer will be completely filled with
-	*/
-	Buffer (uint32 size, uint8 initVal);
-
-	/**	Constructor - creates a new Buffer with a given size.
-	\param[in] size : the size of the new Buffer to be allocated, in bytes.
-	*/
-	Buffer (uint32 size);
-
-	/**	Copy constructor - creates a new Buffer from a given Buffer.
-	\param[in] buff : the Buffer from which all memory will be copied to the new one
-	*/
-	Buffer (const Buffer& buff);
-
-	/**	Destructor - deallocates the internal memory.
-	*/
-	virtual ~Buffer ();
-	
-	/**	Assignment operator - copies contents from a given Buffer and increases the size if necessary.
-	\param[in] buff : the Buffer from which all memory will be copied
-	*/
-	void operator = (const Buffer& buff);
-	
-	/**	Comparison operator - copies contents from a given Buffer and increases the size if necessary.
-	\param[in] buff : the Buffer to be compared to
-	\return true, if the given Buffer's content is equal to this one, else false
-	*/
-	bool operator == (const Buffer& buff)const;
-
-	uint32 getSize () const {return memSize;}		///< \return the actual size of the Buffer's memory, in bytes.
-
-	/**	Sets a new size for this Buffer, keeping as much content as possible.
-	\param[in] newSize : the new size for the Buffer, in bytes, newSize maybe zero
-	\return true, if the new size could be adapted, else false
-	*/
-	bool setSize (uint32 newSize);
-
-	/**	Increases the Buffer to the next block, block size given by delta.
-	\param[in] memSize : the new minimum size of the Buffer, newSize maybe zero
-	\return true, if the Buffer could be grown successfully, else false
-	*/
-	bool grow (uint32 memSize);
-	bool setMaxSize (uint32 size) {return grow (size);}	///< see \ref grow()
-
-	void fillup (uint8 initVal = 0);				///< set from fillSize to end
-	uint32 getFillSize ()const {return fillSize;}	///< \return the actual fill size
-	bool setFillSize (uint32 c);					///< sets a new fill size, does not change any memory
-	inline void flush () {setFillSize (0);}			///< sets fill size to zero
-	bool truncateToFillSize ();						///< \return always true, truncates the size of the Buffer to the actual fill size
-
-	bool isFull () const { return (fillSize == memSize); }	///< \return true, if all memory is filled up, else false
-	uint32 getFree () const { return (memSize - fillSize); }///< \return remaining memory
-
-	inline void shiftStart (int32 amount) {return shiftAt (0, amount);} ///< moves all memory by given amount, grows the Buffer if necessary
-	void shiftAt (uint32 position, int32 amount);						///< moves memory starting at the given position
-	void move (int32 amount, uint8 initVal = 0);						///< shifts memory at start without growing the buffer, so data is lost and initialized with init val
-
-	bool copy (uint32 from, uint32 to, uint32 bytes);	///< copies a number of bytes from one position to another, the size may be adapted
-	uint32 get (void* b, uint32 size);					///< copy to buffer from fillSize, and shift fillSize
-
-	void setDelta (uint32 d) {delta = d;}				///< define the block size by which the Buffer grows, see \ref grow()
-
-	bool put (uint8);							///< append value at end, grows Buffer if necessary 
-	bool put (char16 c);                        ///< append value at end, grows Buffer if necessary
-	bool put (char c);							///< append value at end, grows Buffer if necessary
-	bool put (const void* , uint32 size);		///< append bytes from a given buffer, grows Buffer if necessary
-	bool put (void* , uint32 size);				///< append bytes from a given buffer, grows Buffer if necessary
-	bool put (uint8* , uint32 size);			///< append bytes from a given buffer, grows Buffer if necessary
-	bool put (char8* , uint32 size);			///< append bytes from a given buffer, grows Buffer if necessary
-	bool put (const uint8* , uint32 size);		///< append bytes from a given buffer, grows Buffer if necessary
-	bool put (const char8* , uint32 size);		///< append bytes from a given buffer, grows Buffer if necessary
-	bool put (const String&);					///< append String at end, grows Buffer if necessary
-
-	void set (uint8 value);		///< fills complete Buffer with given value
-	
-	// strings ----------------
-	bool appendString (const tchar* s);
-	bool appendString (tchar* s);
-	bool appendString (tchar c)                   { return put (c); }
-
-	bool appendString8 (const char8* s);	
-	bool appendString16 (const char16* s);
-
-	bool appendString8 (char8* s)                 { return appendString8 ((const char8*)s); }
-	bool appendString8 (unsigned char* s)		  { return appendString8 ((const char8*)s); }         
-	bool appendString8 (const unsigned char* s)   { return appendString8 ((const char8*)s); }
-
-	bool appendString8 (char8 c)                  { return put ((uint8)c); }
-	bool appendString8 (unsigned char c)          { return put (c); }
-	bool appendString16 (char16 c)                { return put (c); }
-	bool appendString16 (char16* s)               { return appendString16 ((const char16*)s); }
-
-	bool prependString (const tchar* s);   
-	bool prependString (tchar* s);   
-	bool prependString (tchar c);                
-
-	bool prependString8 (const char8* s);           
-	bool prependString16 (const char16* s);
-
-	bool prependString8 (char8 c);
-	bool prependString8 (unsigned char c)         { return prependString8 ((char8)c); }
-	bool prependString8 (char8* s)                { return prependString8 ((const char8*)s); }
-	bool prependString8 (unsigned char* s)        { return prependString8((const char8*)s); }           
-	bool prependString8 (const unsigned char* s)  { return prependString8 ((const char8*)s); } 
-	bool prependString16 (char16 c);
-	bool prependString16 (char16* s)              { return prependString16 ((const char16*)s); }
-
-	bool operator+= (const char* s)               { return appendString8 (s); }
-	bool operator+= (char c)                      { return appendString8 (c); }
-	bool operator+= (const char16* s)             { return appendString16 (s); }
-	bool operator+= (char16 c)                    { return appendString16 (c); }
-
-	bool operator= (const char* s)                { flush (); return appendString8 (s); }
-	bool operator= (const char16* s)              { flush (); return appendString16 (s); }
-	bool operator= (char8 c)                      { flush (); return appendString8 (c); }
-	bool operator= (char16 c)                     { flush (); return appendString16 (c); }
-
-	void endString () {put (tchar (0));}
-	void endString8 () {put (char8 (0));}
-	void endString16 () {put (char16 (0));}
-
-	bool makeHexString (String& result);
-	bool fromHexString (const char8* string);
-
-	// conversion
-	operator void* () const { return (void*)buffer; }				///< conversion
-	inline tchar*   str ()   const {return (tchar*)buffer;}			///< conversion
-	inline char8*   str8 ()   const {return (char8*)buffer;}		///< conversion
-	inline char16*  str16 ()   const {return (char16*)buffer;}		///< conversion
-	inline int8*   int8Ptr ()   const {return (int8*)buffer;}		///< conversion
-	inline uint8*  uint8Ptr ()  const {return (uint8*)buffer; }		///< conversion
-	inline int16*  int16Ptr ()  const {return (int16*)buffer; }		///< conversion
-    inline uint16* uint16Ptr () const {return (uint16*)buffer; }	///< conversion
-	inline int32*  int32Ptr ()  const {return (int32*)buffer; }		///< conversion
-	inline uint32* uint32Ptr () const {return (uint32*)buffer; }	///< conversion
-	inline float*  floatPtr ()  const {return (float*)buffer; }		///< conversion
-	inline double* doublePtr () const {return (double*)buffer; }	///< conversion
-	inline char16*  wcharPtr ()  const {return (char16*)buffer;}	///< conversion
-
-	int8* operator + (uint32 i);	///< \return the internal Buffer's address plus the given offset i, zero if offset is out of range
-	
-	int32 operator ! ()  { return buffer == nullptr; }
-	
-	enum swapSize 
-	{
-		kSwap16 = 2,
-		kSwap32 = 4,
-		kSwap64 = 8
-	};
-	bool swap (int16 swapSize);											///< swap all bytes of this Buffer by the given swapSize
-	static bool swap (void* buffer, uint32 bufferSize, int16 swapSize);	///< utility, swap given number of bytes in given buffer by the given swapSize
-
-	void take (Buffer& from);	///< takes another Buffer's memory, frees the current Buffer's memory
-	int8* pass ();				///< pass the current Buffer's memory
-
-	/**	Converts a Buffer's content to UTF-16 from a given multi-byte code page, Buffer must contain char8 of given encoding.
-		\param[in] sourceCodePage : the actual code page of the Buffer's content
-		\return true, if the conversion was successful, else false
-	*/
-	virtual bool toWideString (int32 sourceCodePage); // Buffer contains char8 of given encoding -> utf16
-
-	/**	Converts a Buffer's content from UTF-16 to a given multi-byte code page, Buffer must contain UTF-16 encoded characters.
-		\param[in] destCodePage : the desired code page to convert the Buffer's content to
-		\return true, if the conversion was successful, else false
-	*/
-	virtual bool toMultibyteString (int32 destCodePage); // Buffer contains utf16 -> char8 of given encoding
-
-//------------------------------------------------------------------------
-protected:
-	static const uint32 defaultDelta = 0x1000; // 0x1000
-	
-	int8* buffer;
-	uint32 memSize;
-	uint32 fillSize;
-	uint32 delta;
-};
-
-inline bool Buffer::put (void* p, uint32 count)     { return put ((const void*)p , count ); }
-inline bool Buffer::put (uint8 * p, uint32 count)   { return put ((const void*)p , count ); }
-inline bool Buffer::put (char8* p, uint32 count)    { return put ((const void*)p , count ); }
-inline bool Buffer::put (const uint8* p, uint32 count) { return put ((const void*)p , count ); }
-inline bool Buffer::put (const char8* p, uint32 count) { return put ((const void*)p , count ); }
-
-//------------------------------------------------------------------------
-inline bool Buffer::appendString (const tchar* s)
-{
-#ifdef UNICODE
-	return appendString16 (s);
-#else
-	return appendString8 (s);
-#endif
-}
-
-//------------------------------------------------------------------------
-inline bool Buffer::appendString (tchar* s)
-{
-#ifdef UNICODE
-	return appendString16 (s);
-#else
-	return appendString8 (s);
-#endif
-}
-
-//------------------------------------------------------------------------
-inline bool Buffer::prependString (const tchar* s)
-{
-#ifdef UNICODE
-	return prependString16 (s);
-#else
-	return prependString8 (s);
-#endif
-}
-
-//------------------------------------------------------------------------
-inline bool Buffer::prependString (tchar* s)
-{
-#ifdef UNICODE
-	return prependString16 (s);
-#else
-	return prependString8 (s);
-#endif
-}
-
-//------------------------------------------------------------------------
-inline bool Buffer::prependString (tchar c)
-{
-#ifdef UNICODE
-	return prependString16 (c);
-#else
-	return prependString8 (c);
-#endif
-}
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/base/source/fdebug.cpp

@@ -1,319 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/source/fdebug.cpp
-// Created by  : Steinberg, 1995
-// Description : There are 2 levels of debugging messages:
-//	             DEVELOPMENT               During development
-//	             RELEASE                   Program is shipping.
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistributions of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this
-//     software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "base/source/fdebug.h"
-
-#if SMTG_OS_WINDOWS
-#include <windows.h>
-
-bool AmIBeingDebugged ()
-{
-	return IsDebuggerPresent ();
-}
-#endif
-
-#if SMTG_OS_LINUX
-#include <signal.h>
-#include <sys/types.h>
-#include <unistd.h>
-//--------------------------------------------------------------------------
-bool AmIBeingDebugged ()
-{
-	// TODO: check if GDB or LLDB is attached
-	return true;
-}
-#endif
-
-#if SMTG_OS_MACOS
-
-#include <stdbool.h>
-#include <sys/sysctl.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-//------------------------------------------------------------------------
-// from Technical Q&A QA1361 (http://developer.apple.com/qa/qa2004/qa1361.html)
-//------------------------------------------------------------------------
-bool AmIBeingDebugged ()
-// Returns true if the current process is being debugged (either
-// running under the debugger or has a debugger attached post facto).
-{
-	int mib[4];
-	struct kinfo_proc info;
-	size_t size;
-
-	// Initialize the flags so that, if sysctl fails for some bizarre
-	// reason, we get a predictable result.
-
-	info.kp_proc.p_flag = 0;
-
-	// Initialize mib, which tells sysctl the info we want, in this case
-	// we're looking for information about a specific process ID.
-
-	mib[0] = CTL_KERN;
-	mib[1] = KERN_PROC;
-	mib[2] = KERN_PROC_PID;
-	mib[3] = getpid ();
-
-	// Call sysctl.
-
-	size = sizeof (info);
-	sysctl (mib, sizeof (mib) / sizeof (*mib), &info, &size, NULL, 0);
-
-	// We're being debugged if the P_TRACED flag is set.
-	return ((info.kp_proc.p_flag & P_TRACED) != 0);
-}
-
-#endif // SMTG_OS_MACOS
-
-#if DEVELOPMENT
-
-#include <cassert>
-#include <cstdarg>
-#include <cstdio>
-
-#if SMTG_OS_WINDOWS
-#ifndef _WIN32_WINNT
-#define _WIN32_WINNT 0x0400
-#endif
-#if _MSC_VER
-#include <intrin.h>
-#endif
-#define vsnprintf _vsnprintf
-#define snprintf _snprintf
-
-#elif SMTG_OS_MACOS
-#include <errno.h>
-#include <mach/mach_init.h>
-#include <mach/mach_time.h>
-#include <new>
-#include <signal.h>
-
-#define THREAD_ALLOC_WATCH 0 // check allocations on specific threads
-
-#if THREAD_ALLOC_WATCH
-mach_port_t watchThreadID = 0;
-#endif
-
-#endif
-
-AssertionHandler gAssertionHandler = nullptr;
-AssertionHandler gPreAssertionHook = nullptr;
-DebugPrintLogger gDebugPrintLogger = nullptr;
-
-//--------------------------------------------------------------------------
-static const int kDebugPrintfBufferSize = 10000;
-static bool neverDebugger = false; // so I can switch it off in the debugger...
-
-//--------------------------------------------------------------------------
-static void printDebugString (const char* string)
-{
-	if (!string)
-		return;
-
-	if (gDebugPrintLogger)
-	{
-		gDebugPrintLogger (string);
-	}
-	else
-	{
-#if SMTG_OS_MACOS || defined(__MINGW32__)
-		fprintf (stderr, "%s", string);
-#elif SMTG_OS_WINDOWS
-		OutputDebugStringA (string);
-#endif
-	}
-}
-
-//--------------------------------------------------------------------------
-//	printf style debugging output
-//--------------------------------------------------------------------------
-void FDebugPrint (const char* format, ...)
-{
-	char string[kDebugPrintfBufferSize];
-	va_list marker;
-	va_start (marker, format);
-	vsnprintf (string, kDebugPrintfBufferSize, format, marker);
-
-	printDebugString (string);
-}
-
-//--------------------------------------------------------------------------
-//	printf style debugging output
-//--------------------------------------------------------------------------
-void FDebugBreak (const char* format, ...)
-{
-	char string[kDebugPrintfBufferSize];
-	va_list marker;
-	va_start (marker, format);
-	vsnprintf (string, kDebugPrintfBufferSize, format, marker);
-
-	printDebugString (string);
-
-	// The Pre-assertion hook is always called, even if we're not running in the debugger,
-	// so that we can log asserts without displaying them
-	if (gPreAssertionHook)
-	{
-		gPreAssertionHook (string);
-	}
-
-	if (neverDebugger)
-		return;
-	if (AmIBeingDebugged ())
-	{
-		// do not crash if no debugger present
-		// If there  is an assertion handler defined then let this override the UI
-		// and tell us whether we want to break into the debugger
-		bool breakIntoDebugger = true;
-		if (gAssertionHandler && gAssertionHandler (string) == false)
-		{
-			breakIntoDebugger = false;
-		}
-
-		if (breakIntoDebugger)
-		{
-#if SMTG_OS_WINDOWS	&& _MSC_VER
-			__debugbreak (); // intrinsic version of DebugBreak()
-#elif SMTG_OS_MACOS && __arm64__
-			raise (SIGSTOP);
-
-#elif __ppc64__ || __ppc__ || __arm__
-			kill (getpid (), SIGINT);
-#elif __i386__ || __x86_64__
-			{
-				__asm__ volatile ("int3");
-			}
-#endif
-		}
-	}
-}
-
-//--------------------------------------------------------------------------
-void FPrintLastError (const char* file, int line)
-{
-#if SMTG_OS_WINDOWS
-	LPVOID lpMessageBuffer;
-	FormatMessageA (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, nullptr,
-	                GetLastError (), MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
-	                (LPSTR)&lpMessageBuffer, 0, nullptr);
-	FDebugPrint ("%s(%d) : %s\n", file, line, lpMessageBuffer);
-	LocalFree (lpMessageBuffer);
-#endif
-
-#if SMTG_OS_MACOS
-#if !__MACH__
-	extern int errno;
-#endif
-	FDebugPrint ("%s(%d) : Errno %d\n", file, line, errno);
-#endif
-}
-
-#if SMTG_OS_MACOS
-
-//------------------------------------------------------------------------
-void* operator new (size_t size, int, const char* file, int line)
-{
-#if THREAD_ALLOC_WATCH
-	mach_port_t threadID = mach_thread_self ();
-	if (watchThreadID == threadID)
-	{
-		FDebugPrint ("Watched Thread Allocation : %s (Line:%d)\n", file ? file : "Unknown", line);
-	}
-#endif
-	try
-	{
-		return ::operator new (size);
-	}
-	catch (std::bad_alloc exception)
-	{
-		FDebugPrint ("bad_alloc exception : %s (Line:%d)", file ? file : "Unknown", line);
-	}
-	return (void*)-1;
-}
-
-//------------------------------------------------------------------------
-void* operator new[] (size_t size, int, const char* file, int line)
-{
-#if THREAD_ALLOC_WATCH
-	mach_port_t threadID = mach_thread_self ();
-	if (watchThreadID == threadID)
-	{
-		FDebugPrint ("Watched Thread Allocation : %s (Line:%d)\n", file ? file : "Unknown", line);
-	}
-#endif
-	try
-	{
-		return ::operator new[] (size);
-	}
-	catch (std::bad_alloc exception)
-	{
-		FDebugPrint ("bad_alloc exception : %s (Line:%d)", file ? file : "Unknown", line);
-	}
-	return (void*)-1;
-}
-
-//------------------------------------------------------------------------
-void operator delete (void* p, int, const char* file, int line)
-{
-	::operator delete (p);
-}
-
-//------------------------------------------------------------------------
-void operator delete[] (void* p, int, const char* file, int line)
-{
-	::operator delete[] (p);
-}
-
-#endif // SMTG_OS_MACOS
-
-#endif // DEVELOPMENT
-
-static bool smtg_unit_testing_active = false; // ugly hack to unit testing ...
-
-//------------------------------------------------------------------------
-bool isSmtgUnitTesting ()
-{
-	return smtg_unit_testing_active;
-}
-
-//------------------------------------------------------------------------
-void setSmtgUnitTesting ()
-{
-	smtg_unit_testing_active = true;
-}

source/includes/vst3sdk/base/source/fdebug.h

@@ -1,241 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/source/fdebug.h
-// Created by  : Steinberg, 1995
-// Description : There are 2 levels of debugging messages:
-//	             DEVELOPMENT               During development
-//	             RELEASE                   Program is shipping.
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-/** @file base/source/fdebug.h
-	Debugging tools.
-
-	There are 2 levels of debugging messages:
-	- DEVELOPMENT
-	  - During development
-	- RELEASE
-	  - Program is shipping.
-*/
-//-----------------------------------------------------------------------------
-#pragma once
-
-#include "pluginterfaces/base/ftypes.h"
-#include <cstring>
-
-#if SMTG_OS_MACOS
-#include <new>
-#endif
-
-/** Returns true if a debugger is attached. */
-bool AmIBeingDebugged ();
-
-//-----------------------------------------------------------------------------
-// development / release
-//-----------------------------------------------------------------------------
-#if !defined (DEVELOPMENT) && !defined (RELEASE) 
-	#ifdef _DEBUG
-		#define DEVELOPMENT 1
-	#elif defined (NDEBUG)
-		#define RELEASE 1
-	#else
-		#error DEVELOPMENT, RELEASE, _DEBUG, or NDEBUG  must be defined!
-	#endif
-#endif
-
-//-----------------------------------------------------------------------------
-#if SMTG_OS_WINDOWS
-
-/** Disable compiler warning:
- * C4291: "No matching operator delete found; memory will not be freed if initialization throws an
- * exception. A placement new is used for which there is no placement delete." */
-#if DEVELOPMENT && defined(_MSC_VER)
-#pragma warning(disable : 4291)
-#pragma warning(disable : 4985)
-#endif
-
-#endif // SMTG_OS_WINDOWS
-
-#if DEVELOPMENT
-//-----------------------------------------------------------------------------
-/** If "f" is not true and a debugger is present, send an error string to the debugger for display
-   and cause a breakpoint exception to occur in the current process. SMTG_ASSERT is removed
-   completely in RELEASE configuration. So do not pass methods calls to this macro that are expected
-   to exist in the RELEASE build (for method calls that need to be present in a RELEASE build, use
-   the VERIFY macros instead)*/
-#define SMTG_ASSERT(f) \
-	if (!(f))          \
-		FDebugBreak ("%s(%d) : Assert failed: %s\n", __FILE__, __LINE__, #f);
-
-/** Send "comment" string to the debugger for display. */
-#define SMTG_WARNING(comment) FDebugPrint ("%s(%d) : %s\n", __FILE__, __LINE__, comment);
-
-/** Send the last error string to the debugger for display. */
-#define SMTG_PRINTSYSERROR FPrintLastError (__FILE__, __LINE__);
-
-/** If a debugger is present, send string "s" to the debugger for display and
-    cause a breakpoint exception to occur in the current process. */
-#define SMTG_DEBUGSTR(s) FDebugBreak (s);
-
-/** Use VERIFY for calling methods "f" having a bool result (expecting them to return 'true')
-     The call of "f" is not removed in RELEASE builds, only the result verification. eg: SMTG_VERIFY
-   (isValid ()) */
-#define SMTG_VERIFY(f) SMTG_ASSERT (f)
-
-/** Use VERIFY_IS for calling methods "f" and expect a certain result "r".
-    The call of "f" is not removed in RELEASE builds, only the result verification. eg:
-   SMTG_VERIFY_IS (callMethod (), kResultOK) */
-#define SMTG_VERIFY_IS(f, r) \
-	if ((f) != (r))          \
-		FDebugBreak ("%s(%d) : Assert failed: %s\n", __FILE__, __LINE__, #f);
-
-/** Use VERIFY_NOT for calling methods "f" and expect the result to be anything else but "r".
-     The call of "f" is not removed in RELEASE builds, only the result verification. eg:
-   SMTG_VERIFY_NOT (callMethod (), kResultError) */
-#define SMTG_VERIFY_NOT(f, r) \
-	if ((f) == (r))           \
-		FDebugBreak ("%s(%d) : Assert failed: %s\n", __FILE__, __LINE__, #f);
-
-/** @name Shortcut macros for sending strings to the debugger for display.
-	First parameter is always the format string (printf like).
-*/
-
-///@{
-#define SMTG_DBPRT0(a) FDebugPrint (a);
-#define SMTG_DBPRT1(a, b) FDebugPrint (a, b);
-#define SMTG_DBPRT2(a, b, c) FDebugPrint (a, b, c);
-#define SMTG_DBPRT3(a, b, c, d) FDebugPrint (a, b, c, d);
-#define SMTG_DBPRT4(a, b, c, d, e) FDebugPrint (a, b, c, d, e);
-#define SMTG_DBPRT5(a, b, c, d, e, f) FDebugPrint (a, b, c, d, e, f);
-///@}
-
-/** @name Helper functions for the above defined macros.
-
-    You shouldn't use them directly (if you do so, don't forget "#if DEVELOPMENT")!
-    It is recommended to use the macros instead.
-*/
-///@{
-void FDebugPrint (const char* format, ...);
-void FDebugBreak (const char* format, ...);
-void FPrintLastError (const char* file, int line);
-///@}
-
-/** @name Provide a custom assertion handler and debug print handler, eg
-        so that we can provide an assert with a custom dialog, or redirect
-        the debug output to a file or stream.
-*/
-///@{
-using AssertionHandler = bool (*) (const char* message);
-extern AssertionHandler gAssertionHandler;
-extern AssertionHandler gPreAssertionHook;
-using DebugPrintLogger = void (*) (const char* message);
-extern DebugPrintLogger gDebugPrintLogger;
-///@}
-
-/** Definition of memory allocation macros:
-    Use "NEW" to allocate storage for individual objects.
-    Use "NEWVEC" to allocate storage for an array of objects. */
-#if SMTG_OS_MACOS
-void* operator new (size_t, int, const char*, int);
-void* operator new[] (size_t, int, const char*, int);
-void operator delete (void* p, int, const char* file, int line);
-void operator delete[] (void* p, int, const char* file, int line);
-#ifndef NEW
-#define NEW new (1, __FILE__, __LINE__)
-#define NEWVEC new (1, __FILE__, __LINE__)
-#endif
-
-#define DEBUG_NEW DEBUG_NEW_LEAKS
-
-#elif SMTG_OS_WINDOWS && defined(_MSC_VER)
-#ifndef NEW
-void* operator new (size_t, int, const char*, int);
-#define NEW new (1, __FILE__, __LINE__)
-#define NEWVEC new (1, __FILE__, __LINE__)
-#endif
-
-#else
-#ifndef NEW
-#define NEW new
-#define NEWVEC new
-#endif
-#endif
-
-#else
-/** if DEVELOPMENT is not set, these macros will do nothing. */
-#define SMTG_ASSERT(f)
-#define SMTG_WARNING(s)
-#define SMTG_PRINTSYSERROR
-#define SMTG_DEBUGSTR(s)
-#define SMTG_VERIFY(f) f;
-#define SMTG_VERIFY_IS(f, r) f;
-#define SMTG_VERIFY_NOT(f, r) f;
-
-#define SMTG_DBPRT0(a)
-#define SMTG_DBPRT1(a, b)
-#define SMTG_DBPRT2(a, b, c)
-#define SMTG_DBPRT3(a, b, c, d)
-#define SMTG_DBPRT4(a, b, c, d, e)
-#define SMTG_DBPRT5(a, b, c, d, e, f)
-
-#ifndef NEW
-#define NEW new
-#define NEWVEC new
-
-#endif
-#endif
-
-// replace #if SMTG_CPPUNIT_TESTING
-bool isSmtgUnitTesting ();
-void setSmtgUnitTesting ();
-
-#if !SMTG_RENAME_ASSERT
-#if SMTG_OS_WINDOWS
-#undef ASSERT
-#endif
-
-#define ASSERT				SMTG_ASSERT
-#define WARNING				SMTG_WARNING
-#define DEBUGSTR			SMTG_DEBUGSTR
-#define VERIFY				SMTG_VERIFY
-#define VERIFY_IS			SMTG_VERIFY_IS
-#define VERIFY_NOT			SMTG_VERIFY_NOT
-#define PRINTSYSERROR		SMTG_PRINTSYSERROR
-
-#define DBPRT0				SMTG_DBPRT0
-#define DBPRT1				SMTG_DBPRT1
-#define DBPRT2				SMTG_DBPRT2
-#define DBPRT3				SMTG_DBPRT3
-#define DBPRT4				SMTG_DBPRT4
-#define DBPRT5				SMTG_DBPRT5
-#endif

source/includes/vst3sdk/base/source/fobject.cpp

@@ -1,184 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/source/fobject.cpp
-// Created by  : Steinberg, 2008
-// Description : Basic Object implementing FUnknown
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "base/source/fobject.h"
-#include "base/thread/include/flock.h"
-
-#include <vector>
-
-namespace Steinberg {
-
-IUpdateHandler* FObject::gUpdateHandler = nullptr;
-
-//------------------------------------------------------------------------
-const FUID FObject::iid;
-
-//------------------------------------------------------------------------
-struct FObjectIIDInitializer
-{
-	// the object iid is always generated so that different components
-	// only can cast to their own objects
-	// this initializer must be after the definition of FObject::iid, otherwise
-	//  the default constructor of FUID will clear the generated iid
-	FObjectIIDInitializer () 
-	{ 
-		const_cast<FUID&> (FObject::iid).generate (); 
-	}
-} gFObjectIidInitializer;
-
-//------------------------------------------------------------------------
-uint32 PLUGIN_API FObject::addRef ()  
-{                                      
-	return FUnknownPrivate::atomicAdd (refCount, 1);
-}                                             
-
-//------------------------------------------------------------------------
-uint32 PLUGIN_API FObject::release () 
-{
-	if (FUnknownPrivate::atomicAdd (refCount, -1) == 0)
-	{
-		refCount = -1000;
-		delete this;
-		return 0;
-	}                                   
-	return refCount;                 
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API FObject::queryInterface (const TUID _iid, void** obj)
-{
-	QUERY_INTERFACE (_iid, obj, FUnknown::iid, FUnknown)             
-	QUERY_INTERFACE (_iid, obj, IDependent::iid, IDependent)             
-	QUERY_INTERFACE (_iid, obj, FObject::iid, FObject)             
-	*obj = nullptr;
-	return kNoInterface; 
-}
-
-//------------------------------------------------------------------------
-void FObject::addDependent (IDependent* dep)
-{
-	if (gUpdateHandler)
-		gUpdateHandler->addDependent (unknownCast (), dep);
-}
-
-//------------------------------------------------------------------------
-void FObject::removeDependent (IDependent* dep)
-{
-	if (gUpdateHandler)
-		gUpdateHandler->removeDependent (unknownCast (), dep);
-}
-
-//------------------------------------------------------------------------
-void FObject::changed (int32 msg)
-{
-	if (gUpdateHandler)
-		gUpdateHandler->triggerUpdates (unknownCast (), msg);
-	else
-		updateDone (msg);
-}
-
-//------------------------------------------------------------------------
-void FObject::deferUpdate (int32 msg)
-{
-	if (gUpdateHandler)
-		gUpdateHandler->deferUpdates (unknownCast (), msg);
-	else
-		updateDone (msg);
-}
-
-//------------------------------------------------------------------------
-/** Automatic creation and destruction of singleton instances. */
-//------------------------------------------------------------------------
-namespace Singleton 
-{
-	using ObjectVector = std::vector<FObject**>;
-	ObjectVector* singletonInstances = nullptr;
-	bool singletonsTerminated = false;
-	Steinberg::Base::Thread::FLock* singletonsLock;
-
-	bool isTerminated () {return singletonsTerminated;}
-
-	void lockRegister ()
-	{
-		if (!singletonsLock) // assume first call not from multiple threads
-			singletonsLock = NEW Steinberg::Base::Thread::FLock;
-		singletonsLock->lock ();
-	}
-	void unlockRegister () 
-	{ 
-		singletonsLock->unlock ();
-	}
-
-	void registerInstance (FObject** o)
-	{
-		SMTG_ASSERT (singletonsTerminated == false)
-		if (singletonsTerminated == false)
-		{
-			if (singletonInstances == nullptr)
-				singletonInstances = NEW std::vector<FObject**>;
-			singletonInstances->push_back (o);
-		}
-	}
-
-	struct Deleter
-	{
-		~Deleter ()
-		{
-			singletonsTerminated = true;
-			if (singletonInstances)
-			{
-				for (ObjectVector::iterator it = singletonInstances->begin (),
-											end = singletonInstances->end ();
-					 it != end; ++it)
-				{
-					FObject** obj = (*it);
-					(*obj)->release ();
-					*obj = nullptr;
-					obj = nullptr;
-				}
-
-				delete singletonInstances;
-				singletonInstances = nullptr;
-			}
-			delete singletonsLock;
-			singletonsLock = nullptr;
-		}
-	} deleter;
-}
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/base/source/fobject.h

@@ -1,516 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/source/fobject.h
-// Created by  : Steinberg, 2008
-// Description : Basic Object implementing FUnknown
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-/** @file base/source/fobject.h
-	Basic Object implementing FUnknown. */
-//------------------------------------------------------------------------
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/base/iupdatehandler.h"
-#include "base/source/fdebug.h" // use of NEW
-
-namespace Steinberg {
-
-//----------------------------------
-
-using FClassID = FIDString;
-
-//------------------------------------------------------------------------
-// Basic FObject - implements FUnknown + IDependent
-//------------------------------------------------------------------------
-/** Implements FUnknown and IDependent.
-
-FObject is a polymorphic class that implements IDependent (of SKI module) and therefore derived from
-FUnknown, which is the most abstract base class of all.
-
-All COM-like virtual methods of FUnknown such as queryInterface(), addRef(), release() are
-implemented here. On top of that, dependency-related methods are implemented too.
-
-Pointer casting is done via the template methods FCast, either FObject to FObject or FUnknown to
-FObject.
-
-FObject supports a new singleton concept, therefore these objects are deleted automatically upon
-program termination.
-
-- Runtime type information: An object can be queried at runtime, of what class it is. To do this
-correctly, every class must override some methods. This is simplified by using the OBJ_METHODS
-macros
-
-@see
-    - FUnknown
-    - IDependent
-    - IUpdateHandler
-*/
-//------------------------------------------------------------------------
-class FObject : public IDependent
-{
-public:
-	//------------------------------------------------------------------------
-	FObject () : refCount (1) {}											///< default constructor...
-	FObject (const FObject&) : refCount (1) {}								///< overloaded constructor...
-	virtual ~FObject () {}													///< destructor...
-	FObject& operator = (const FObject&) { return *this; }					///< overloads operator "=" as the reference assignment
-
-	// OBJECT_METHODS
-	static inline FClassID getFClassID () {return "FObject";}				///< return Class ID as an ASCII string (statically)
-	virtual FClassID isA () const {return FObject::getFClassID ();}			///< a local alternative to getFClassID ()
-	virtual bool isA (FClassID s) const {return isTypeOf (s, false);}		///< evaluates if the passed ID is of the FObject type
-	virtual bool isTypeOf (FClassID s, bool /*askBaseClass*/ = true) const {return classIDsEqual (s, FObject::getFClassID ());}
-																			///< evaluates if the passed ID is of the FObject type
-	int32 getRefCount () {return refCount;}									///< returns the current interface reference count
-	FUnknown* unknownCast () {return this;}									///< get FUnknown interface from object
-
-	// FUnknown
-	tresult PLUGIN_API queryInterface (const TUID _iid, void** obj) SMTG_OVERRIDE; ///< please refer to FUnknown::queryInterface ()
-	uint32 PLUGIN_API addRef () SMTG_OVERRIDE;						///< please refer to FUnknown::addref ()
-	uint32 PLUGIN_API release () SMTG_OVERRIDE;						///< please refer to FUnknown::release ()
-
-	// IDependent
-	void PLUGIN_API update (FUnknown* /*changedUnknown*/, int32 /*message*/) SMTG_OVERRIDE {}
-																			///< empty virtual method that should be overridden by derived classes for data updates upon changes	
-	// IDependency
-	virtual void addDependent (IDependent* dep);							///< adds dependency to the object
-	virtual void removeDependent (IDependent* dep);							///< removes dependency from the object
-	virtual void changed (int32 msg = kChanged);							///< Inform all dependents, that the object has changed.
-	virtual void deferUpdate (int32 msg = kChanged);						///< Similar to triggerUpdates, except only delivered in idle (usefull in collecting updates).
-	virtual void updateDone (int32 /* msg */) {}							///< empty virtual method that should be overridden by derived classes
-	virtual bool isEqualInstance (FUnknown* d) {return this == d;}
-	
-	static void setUpdateHandler (IUpdateHandler* handler) {gUpdateHandler = handler;}	///< set method for the local attribute
-	static IUpdateHandler* getUpdateHandler () {return gUpdateHandler;}					///< get method for the local attribute 
-
-	// static helper functions
-	static inline bool classIDsEqual (FClassID ci1, FClassID ci2);			///< compares (evaluates) 2 class IDs
-	static inline FObject* unknownToObject (FUnknown* unknown);				///< pointer conversion from FUnknown to FObject
-
-	/** Special UID that is used to cast an FUnknown pointer to a FObject */
-	static const FUID iid;
-
-//------------------------------------------------------------------------
-protected:
-	int32 refCount;															///< COM-model local reference count
-
-	static IUpdateHandler* gUpdateHandler;
-};
-
-
-//------------------------------------------------------------------------
-// conversion from FUnknown to FObject
-//------------------------------------------------------------------------
-inline FObject* FObject::unknownToObject (FUnknown* unknown)
-{
-	FObject* object = nullptr;
-	if (unknown) 
-	{
-		unknown->queryInterface (FObject::iid, (void**)&object);
-		if (object)
-			object->release (); // queryInterface has added ref		
-	}
-	return object;
-}
-
-//------------------------------------------------------------------------
-inline bool FObject::classIDsEqual (FClassID ci1, FClassID ci2)
-{
-	return (ci1 && ci2) ? (strcmp (ci1, ci2) == 0) : false;
-}
-
-//-----------------------------------------------------------------------
-/** FCast overload 1 - FObject to FObject */
-//-----------------------------------------------------------------------
-template <class C>
-inline C* FCast (const FObject* object)
-{
-	if (object && object->isTypeOf (C::getFClassID (), true))
-		return (C*) object;
-	return 0;
-}
-
-//-----------------------------------------------------------------------
-/** FCast overload 2 - FUnknown to FObject */
-//-----------------------------------------------------------------------
-template <class C>
-inline C* FCast (FUnknown* unknown)
-{
-	FObject* object = FObject::unknownToObject (unknown);
-	return FCast<C> (object);
-}
-
-//-----------------------------------------------------------------------
-/** FUCast - casting from FUnknown to Interface */
-//-----------------------------------------------------------------------
-template <class C>
-inline C* FUCast (FObject* object)
-{
-	return FUnknownPtr<C> (object ? object->unknownCast () : nullptr);
-}
-
-template <class C>
-inline C* FUCast (FUnknown* object)
-{
-	return FUnknownPtr<C> (object);
-}
-
-//------------------------------------------------------------------------
-/** @name Convenience methods that call release or delete respectively
-	on a pointer if it is non-zero, and then set the pointer to zero.
-	Note: you should prefer using IPtr or OPtr instead of these methods
-	whenever possible. 
-	<b>Examples:</b>
-	@code
-	~Foo ()
-	{
-		// instead of ...
-		if (somePointer)
-		{
-			somePointer->release ();
-			somePointer = 0;
-		}
-		// ... just being lazy I write
-		SafeRelease (somePointer)
-	}
-	@endcode
-*/
-///@{
-//-----------------------------------------------------------------------
-template <class I>
-inline void SafeRelease (I *& ptr) 
-{ 
-	if (ptr) 
-	{
-		ptr->release (); 
-		ptr = 0;
-	}
-}
-
-//-----------------------------------------------------------------------
-template <class I>
-inline void SafeRelease (IPtr<I> & ptr) 
-{ 
-	ptr = 0;
-}
-
-
-//-----------------------------------------------------------------------
-template <class T>
-inline void SafeDelete (T *& ptr)
-{
-	if (ptr) 
-	{
-		delete ptr;
-		ptr = 0;
-	}
-}
-///@}
-
-//-----------------------------------------------------------------------
-template <class T>
-inline void AssignShared (T*& dest, T* newPtr)
-{
-	if (dest == newPtr)
-		return;
-	
-	if (dest) 
-		dest->release (); 
-	dest = newPtr; 
-	if (dest) 
-		dest->addRef ();
-}
-
-//-----------------------------------------------------------------------
-template <class T>
-inline void AssignSharedDependent (IDependent* _this, T*& dest, T* newPtr)
-{
-	if (dest == newPtr)
-		return;
-
-	if (dest)
-		dest->removeDependent (_this);
-	AssignShared (dest, newPtr);
-	if (dest)
-		dest->addDependent (_this);
-}
-
-//-----------------------------------------------------------------------
-template <class T>
-inline void AssignSharedDependent (IDependent* _this, IPtr<T>& dest, T* newPtr)
-{
-	if (dest == newPtr)
-		return;
-
-	if (dest)
-		dest->removeDependent (_this);
-	dest = newPtr;
-	if (dest)
-		dest->addDependent (_this);
-}
-	
-//-----------------------------------------------------------------------
-template <class T>
-inline void SafeReleaseDependent (IDependent* _this, T*& dest)
-{
-	if (dest)
-		dest->removeDependent (_this);
-	SafeRelease (dest);
-}
-	
-//-----------------------------------------------------------------------
-template <class T>
-inline void SafeReleaseDependent (IDependent* _this, IPtr<T>& dest)
-{
-	if (dest)
-		dest->removeDependent (_this);
-	SafeRelease (dest);
-}
-
-
-//------------------------------------------------------------------------
-/** Automatic creation and destruction of singleton instances. */
-namespace Singleton {
-	/** registers an instance (type FObject) */
-	void registerInstance (FObject** o);
-
-	/** Returns true when singleton instances were already released. */
-	bool isTerminated ();
-
-	/** lock and unlock the singleton registration for multi-threading safety */
-	void lockRegister ();
-	void unlockRegister ();
-}
-
-//------------------------------------------------------------------------
-} // namespace Steinberg
-
-//-----------------------------------------------------------------------
-#define SINGLETON(ClassName)	\
-	static ClassName* instance (bool create = true) \
-	{ \
-		static Steinberg::FObject* inst = nullptr; \
-		if (inst == nullptr && create && Steinberg::Singleton::isTerminated () == false) \
-		{	\
-			Steinberg::Singleton::lockRegister (); \
-			if (inst == nullptr) \
-			{ \
-				inst = NEW ClassName; \
-				Steinberg::Singleton::registerInstance (&inst); \
-			} \
-			Steinberg::Singleton::unlockRegister (); \
-		}	\
-		return (ClassName*)inst; \
-	}
-
-//-----------------------------------------------------------------------
-#define OBJ_METHODS(className, baseClass)								\
-	static inline Steinberg::FClassID getFClassID () {return (#className);}		\
-	virtual Steinberg::FClassID isA () const SMTG_OVERRIDE {return className::getFClassID ();}	\
-	virtual bool isA (Steinberg::FClassID s) const SMTG_OVERRIDE {return isTypeOf (s, false);}	\
-	virtual bool isTypeOf (Steinberg::FClassID s, bool askBaseClass = true) const SMTG_OVERRIDE	\
-    {  return (classIDsEqual (s, #className) ? true : (askBaseClass ? baseClass::isTypeOf (s, true) : false)); } 
-
-//------------------------------------------------------------------------
-/** Delegate refcount functions to BaseClass.
-	BaseClase must implement ref counting. 
-*/
-//------------------------------------------------------------------------
-#define REFCOUNT_METHODS(BaseClass) \
-virtual Steinberg::uint32 PLUGIN_API addRef ()SMTG_OVERRIDE{ return BaseClass::addRef (); } \
-virtual Steinberg::uint32 PLUGIN_API release ()SMTG_OVERRIDE{ return BaseClass::release (); }
-
-//------------------------------------------------------------------------
-/** @name Macros to implement FUnknown::queryInterface ().
-
-	<b>Examples:</b>
-	@code
-	class Foo : public FObject, public IFoo2, public IFoo3 
-	{
-	    ...
-		DEFINE_INTERFACES
-	        DEF_INTERFACE (IFoo2)
-	        DEF_INTERFACE (IFoo3)
-	    END_DEFINE_INTERFACES (FObject)
-	    REFCOUNT_METHODS(FObject)
-	    // Implement IFoo2 interface ...
-	    // Implement IFoo3 interface ...
-	    ...
-	};
-	@endcode	
-*/
-///@{
-//------------------------------------------------------------------------
-/** Start defining interfaces. */
-//------------------------------------------------------------------------
-#define DEFINE_INTERFACES \
-Steinberg::tresult PLUGIN_API queryInterface (const Steinberg::TUID iid, void** obj) SMTG_OVERRIDE \
-{
-
-//------------------------------------------------------------------------
-/** Add a interfaces. */
-//------------------------------------------------------------------------
-#define DEF_INTERFACE(InterfaceName) \
-	QUERY_INTERFACE (iid, obj, InterfaceName::iid, InterfaceName)
-
-//------------------------------------------------------------------------
-/** End defining interfaces. */
-//------------------------------------------------------------------------
-#define END_DEFINE_INTERFACES(BaseClass) \
-	return BaseClass::queryInterface (iid, obj); \
-}
-///@}
-
-//------------------------------------------------------------------------
-/** @name Convenient macros to implement Steinberg::FUnknown::queryInterface ().
-	<b>Examples:</b>
-	@code
-	class Foo : public FObject, public IFoo2, public IFoo3 
-	{
-	    ...
-	    DEF_INTERFACES_2(IFoo2,IFoo3,FObject)
-	    REFCOUNT_METHODS(FObject)
-	    ...
-	};
-	@endcode
-*/
-///@{
-//------------------------------------------------------------------------
-#define DEF_INTERFACES_1(InterfaceName,BaseClass) \
-DEFINE_INTERFACES \
-DEF_INTERFACE (InterfaceName) \
-END_DEFINE_INTERFACES (BaseClass)
-
-//------------------------------------------------------------------------
-#define DEF_INTERFACES_2(InterfaceName1,InterfaceName2,BaseClass) \
-DEFINE_INTERFACES \
-DEF_INTERFACE (InterfaceName1) \
-DEF_INTERFACE (InterfaceName2) \
-END_DEFINE_INTERFACES (BaseClass)
-
-//------------------------------------------------------------------------
-#define DEF_INTERFACES_3(InterfaceName1,InterfaceName2,InterfaceName3,BaseClass) \
-DEFINE_INTERFACES \
-DEF_INTERFACE (InterfaceName1) \
-DEF_INTERFACE (InterfaceName2) \
-DEF_INTERFACE (InterfaceName3) \
-END_DEFINE_INTERFACES (BaseClass)
-
-//------------------------------------------------------------------------
-#define DEF_INTERFACES_4(InterfaceName1,InterfaceName2,InterfaceName3,InterfaceName4,BaseClass) \
-	DEFINE_INTERFACES \
-	DEF_INTERFACE (InterfaceName1) \
-	DEF_INTERFACE (InterfaceName2) \
-	DEF_INTERFACE (InterfaceName3) \
-	DEF_INTERFACE (InterfaceName4) \
-	END_DEFINE_INTERFACES (BaseClass)
-///@}
-
-//------------------------------------------------------------------------
-/** @name Convenient macros to implement Steinberg::FUnknown methods.
-	<b>Examples:</b>
-	@code
-	class Foo : public FObject, public IFoo2, public IFoo3 
-	{
-	    ...
-	    FUNKNOWN_METHODS2(IFoo2,IFoo3,FObject)
-	    ...
-	};
-	@endcode
-*/
-///@{
-#define FUNKNOWN_METHODS(InterfaceName,BaseClass) \
-DEF_INTERFACES_1(InterfaceName,BaseClass) \
-REFCOUNT_METHODS(BaseClass)
-
-#define FUNKNOWN_METHODS2(InterfaceName1,InterfaceName2,BaseClass) \
-DEF_INTERFACES_2(InterfaceName1,InterfaceName2,BaseClass) \
-REFCOUNT_METHODS(BaseClass)
-
-#define FUNKNOWN_METHODS3(InterfaceName1,InterfaceName2,InterfaceName3,BaseClass) \
-DEF_INTERFACES_3(InterfaceName1,InterfaceName2,InterfaceName3,BaseClass) \
-REFCOUNT_METHODS(BaseClass)
-
-#define FUNKNOWN_METHODS4(InterfaceName1,InterfaceName2,InterfaceName3,InterfaceName4,BaseClass) \
-DEF_INTERFACES_4(InterfaceName1,InterfaceName2,InterfaceName3,InterfaceName4,BaseClass) \
-REFCOUNT_METHODS(BaseClass)
-///@}
-
-
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-#if COM_COMPATIBLE
-//------------------------------------------------------------------------
-/** @name Macros to implement IUnknown interfaces with FObject.
-	<b>Examples:</b>
-	@code
-	class MyEnumFormat : public FObject, IEnumFORMATETC
-	{
-	    ...
-		COM_UNKNOWN_METHODS (IEnumFORMATETC, IUnknown)
-	    ...
-	};
-	@endcode
-*/
-///@{
-//------------------------------------------------------------------------
-#define IUNKNOWN_REFCOUNT_METHODS(BaseClass) \
-STDMETHOD_ (ULONG, AddRef) (void) {return BaseClass::addRef ();} \
-STDMETHOD_ (ULONG, Release) (void) {return BaseClass::release ();}
-
-//------------------------------------------------------------------------
-#define COM_QUERY_INTERFACE(iid, obj, InterfaceName)     \
-if (riid == __uuidof(InterfaceName))                     \
-{                                                        \
-	addRef ();                                           \
-	*obj = (InterfaceName*)this;                         \
-	return kResultOk;                                    \
-}
-
-//------------------------------------------------------------------------
-#define COM_OBJECT_QUERY_INTERFACE(InterfaceName,BaseClass)        \
-STDMETHOD (QueryInterface) (REFIID riid, void** object)            \
-{                                                                  \
-	COM_QUERY_INTERFACE (riid, object, InterfaceName)              \
-	return BaseClass::queryInterface ((FIDString)&riid, object);   \
-}
-
-//------------------------------------------------------------------------
-#define COM_UNKNOWN_METHODS(InterfaceName,BaseClass) \
-COM_OBJECT_QUERY_INTERFACE(InterfaceName,BaseClass) \
-IUNKNOWN_REFCOUNT_METHODS(BaseClass)
-///@}
-
-#endif // COM_COMPATIBLE

source/includes/vst3sdk/base/source/fstreamer.cpp

@@ -1,726 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/source/fstreamer.cpp
-// Created by  : Steinberg, 15.12.2005
-// Description : Extract of typed stream i/o methods from FStream
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "fstreamer.h"
-
-#include "base/source/fstring.h"
-#include "base/source/fbuffer.h"
-#include "pluginterfaces/base/ibstream.h"
-
-#ifndef UNICODE
-#include "pluginterfaces/base/futils.h"
-#endif
-
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-// IBStreamer
-//------------------------------------------------------------------------
-IBStreamer::IBStreamer (IBStream* stream, int16 _byteOrder)
-: FStreamer (_byteOrder)
-, stream (stream)
-{}
-
-//------------------------------------------------------------------------
-TSize IBStreamer::readRaw (void* buffer, TSize size)
-{
-	int32 numBytesRead = 0;
-	stream->read (buffer, (int32)size, &numBytesRead);
-	return numBytesRead;
-}
-
-//------------------------------------------------------------------------
-TSize IBStreamer::writeRaw (const void* buffer, TSize size)
-{
-	int32 numBytesWritten = 0;
-	stream->write ((void*)buffer, (int32)size, &numBytesWritten);
-	return numBytesWritten;
-}
-
-//------------------------------------------------------------------------
-int64 IBStreamer::seek (int64 pos, FSeekMode mode)
-{
-	int64 result = -1;
-	stream->seek (pos, mode, &result);
-	return result;
-}
-
-//------------------------------------------------------------------------
-int64 IBStreamer::tell ()
-{
-	int64 pos = 0;
-	stream->tell (&pos);
-	return pos;
-}
-
-//------------------------------------------------------------------------
-// FStreamSizeHolder Implementation
-//------------------------------------------------------------------------
-FStreamSizeHolder::FStreamSizeHolder (FStreamer &s)
-: stream (s), sizePos (-1)
-{}
-
-//------------------------------------------------------------------------
-void FStreamSizeHolder::beginWrite ()
-{
-	sizePos = stream.tell ();
-	stream.writeInt32 (0L);
-}
-
-//------------------------------------------------------------------------
-int32 FStreamSizeHolder::endWrite ()
-{
-	if (sizePos < 0)
-		return 0;
-	
-	int64 currentPos = stream.tell ();
-
-	stream.seek (sizePos, kSeekSet);
-	int32 size = int32 (currentPos - sizePos - sizeof (int32));
-	stream.writeInt32 (size);
-	
-	stream.seek (currentPos, kSeekSet);
-	return size;
-}
-
-//------------------------------------------------------------------------
-int32 FStreamSizeHolder::beginRead ()
-{
-	sizePos = stream.tell ();
-	int32 size = 0;
-	stream.readInt32 (size);
-	sizePos += size + sizeof (int32);
-	return size;
-}
-
-//------------------------------------------------------------------------
-void FStreamSizeHolder::endRead ()
-{
-	if (sizePos >= 0)
-		stream.seek (sizePos, kSeekSet);
-}
-
-//------------------------------------------------------------------------
-// FStreamer
-//------------------------------------------------------------------------
-FStreamer::FStreamer (int16 _byteOrder)
-: byteOrder (_byteOrder)
-{}
-
-// int8 / char -----------------------------------------------------------
-//------------------------------------------------------------------------
-bool FStreamer::writeChar8 (char8 c)
-{
-	return writeRaw ((void*)&c, sizeof (char8)) == sizeof (char8);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readChar8 (char8& c)
-{
-	return readRaw ((void*)&c, sizeof (char8)) == sizeof (char8);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeUChar8 (unsigned char c)
-{
-	return writeRaw ((void*)&c, sizeof (unsigned char)) == sizeof (unsigned char);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readUChar8 (unsigned char& c)
-{
-	return readRaw ((void*)&c, sizeof (unsigned char)) == sizeof (unsigned char);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeChar16 (char16 c)
-{
-	if (BYTEORDER != byteOrder)
-		SWAP_16 (c);
-	return writeRaw ((void*)&c, sizeof (char16)) == sizeof (char16);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readChar16 (char16& c)
-{
-	if (readRaw ((void*)&c, sizeof (char16)) == sizeof (char16))
-	{
-		if (BYTEORDER != byteOrder)
-			SWAP_16 (c);
-		return true;
-	}
-	c = 0;
-	return false;
-}
-
-// int16 -----------------------------------------------------------------
-//------------------------------------------------------------------------
-bool FStreamer::writeInt16 (int16 i)
-{
-	if (BYTEORDER != byteOrder)
-		SWAP_16 (i);
-	return writeRaw ((void*)&i, sizeof (int16)) == sizeof (int16);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readInt16 (int16& i)
-{
-	if (readRaw ((void*)&i, sizeof (int16)) == sizeof (int16))
-	{
-		if (BYTEORDER != byteOrder)
-			SWAP_16 (i);
-		return true;
-	}
-	i = 0;
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeInt16Array (const int16* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!writeInt16 (array[i]))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readInt16Array (int16* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!readInt16 (array[i]))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeInt16u (uint16 i)
-{
-	if (BYTEORDER != byteOrder)
-		SWAP_16 (i);
-	return writeRaw ((void*)&i, sizeof (uint16)) == sizeof (uint16);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readInt16u (uint16& i)
-{
-	if (readRaw ((void*)&i, sizeof (uint16)) == sizeof (uint16))
-	{
-		if (BYTEORDER != byteOrder)
-			SWAP_16 (i);
-		return true;
-	}
-	i = 0;
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeInt16uArray (const uint16* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!writeInt16u (array[i]))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readInt16uArray (uint16* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!readInt16u (array[i]))
-			return false;
-	}
-	return true;
-}
-
-// int32 -----------------------------------------------------------------
-//------------------------------------------------------------------------
-bool FStreamer::writeInt32 (int32 i)
-{
-	if (BYTEORDER != byteOrder)
-		SWAP_32 (i);
-	return writeRaw ((void*)&i, sizeof (int32)) == sizeof (int32);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readInt32 (int32& i)
-{
-	if (readRaw ((void*)&i, sizeof (int32)) == sizeof (int32))
-	{
-		if (BYTEORDER != byteOrder)
-			SWAP_32 (i);
-		return true;
-	}
-	i = 0;
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeInt32Array (const int32* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!writeInt32 (array[i]))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readInt32Array (int32* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!readInt32 (array[i]))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeInt32u (uint32 i)
-{
-	if (BYTEORDER != byteOrder)
-		SWAP_32 (i);
-	return writeRaw ((void*)&i, sizeof (uint32)) == sizeof (uint32);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readInt32u (uint32& i)
-{
-	if (readRaw ((void*)&i, sizeof (uint32)) == sizeof (uint32))
-	{
-		if (BYTEORDER != byteOrder)
-			SWAP_32 (i);
-		return true;
-	}
-	i = 0;
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeInt32uArray (const uint32* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!writeInt32u (array[i]))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readInt32uArray (uint32* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!readInt32u (array[i]))
-			return false;
-	}
-	return true;
-}
-
-// int64 -----------------------------------------------------------------
-//------------------------------------------------------------------------
-bool FStreamer::writeInt64 (int64 i)
-{
-	if (BYTEORDER != byteOrder)
-		SWAP_64 (i);
-	return writeRaw ((void*)&i, sizeof (int64)) == sizeof (int64);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readInt64 (int64& i)
-{
-	if (readRaw ((void*)&i, sizeof (int64)) == sizeof (int64))
-	{
-		if (BYTEORDER != byteOrder)
-			SWAP_64 (i);
-		return true;
-	}
-	i = 0;
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeInt64Array (const int64* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!writeInt64 (array[i]))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readInt64Array (int64* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!readInt64 (array[i]))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeInt64u (uint64 i)
-{
-	if (BYTEORDER != byteOrder)
-		SWAP_64 (i);
-	return writeRaw ((void*)&i, sizeof (uint64)) == sizeof (uint64);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readInt64u (uint64& i)
-{
-	if (readRaw ((void*)&i, sizeof (uint64)) == sizeof (uint64))
-	{
-		if (BYTEORDER != byteOrder)
-			SWAP_64 (i);
-		return true;
-	}
-	i = 0;
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeInt64uArray (const uint64* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!writeInt64u (array[i]))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readInt64uArray (uint64* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!readInt64u (array[i]))
-			return false;
-	}
-	return true;
-}
-
-// float / double --------------------------------------------------------
-//------------------------------------------------------------------------
-bool FStreamer::writeFloat (float f)
-{
-	if (BYTEORDER != byteOrder)
-		SWAP_32 (f);
-	return writeRaw ((void*)&f, sizeof (float)) == sizeof (float);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readFloat (float& f)
-{
-	if (readRaw ((void*)&f, sizeof (float)) == sizeof (float))
-	{
-		if (BYTEORDER != byteOrder)
-			SWAP_32 (f);
-		return true;
-	}
-	f = 0.f;
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeFloatArray (const float* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!writeFloat (array[i]))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readFloatArray (float* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!readFloat (array[i]))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeDouble (double d)
-{
-	if (BYTEORDER != byteOrder)
-		SWAP_64 (d);
-	return writeRaw ((void*)&d, sizeof (double)) == sizeof (double);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readDouble (double& d)
-{
-	if (readRaw ((void*)&d, sizeof (double)) == sizeof (double))
-	{
-		if (BYTEORDER != byteOrder)
-			SWAP_64 (d);
-		return true;
-	}
-	d = 0.0;
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeDoubleArray (const double* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!writeDouble (array[i]))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readDoubleArray (double* array, int32 count)
-{
-	for (int32 i = 0; i < count; i++)
-	{
-		if (!readDouble (array[i]))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::readBool (bool& b)
-{
-	int16 v = 0;
-	bool res = readInt16 (v);
-	b = (v != 0);
-	return res;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeBool (bool b)
-{
-	return writeInt16 ((int16)b);
-}
-
-//------------------------------------------------------------------------
-TSize FStreamer::writeString8 (const char8* ptr, bool terminate)
-{
-	TSize size = strlen (ptr);
-	if (terminate) // write \0
-		size++;
-
-	return writeRaw ((void*)ptr, size);
-}
-
-//------------------------------------------------------------------------
-TSize FStreamer::readString8 (char8* ptr, TSize size)
-{
-	TSize i = 0;
-	char8 c = 0;
-	while (i < size)
-	{
-		if (readRaw ((void*)&c, sizeof (char)) != sizeof (char))
-			break;
-		ptr[i] = c;
-		i++;
-		if (c == '\n' || c == '\0')
-			break;
-	}
-	if (c == '\n' && ptr[i - 2] == '\r')
-		ptr[i - 2] = 0;
-	if (i < size)
-		ptr[i] = 0;
-	else
-		ptr[size - 1] = 0;
-
-	return strlen (ptr);
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeStringUtf8 (const tchar* ptr)
-{
-	bool isUtf8 = false;
-
-	String str (ptr);
-	if (str.isAsciiString () == false) 
-	{
-		str.toMultiByte (kCP_Utf8);
-		isUtf8 = true;
-	}
-	else
-	{
-		str.toMultiByte ();
-	}
-
-	if (isUtf8) 
-		if (writeRaw (kBomUtf8, kBomUtf8Length) != kBomUtf8Length)
-			return false;
-
-	TSize size = str.length () + 1;
-	if (writeRaw (str.text8 (), size) != size)
-		return false;
-
-	return true;
-}
-
-//------------------------------------------------------------------------
-int32 FStreamer::readStringUtf8 (tchar* ptr, int32 nChars)
-{
-	char8 c = 0;
-
-	ptr [0] = 0;
-
-	Buffer tmp;
-	tmp.setDelta (1024);
-
-	while (true)
-	{
-		if (readRaw ((void*)&c, sizeof (char)) != sizeof (char))
-			break;
-		tmp.put (c);
-		if (c == '\0')
-			break;
-	}
-
-	char8* source = tmp.int8Ptr ();
-	uint32 codePage = kCP_Default; // for legacy take default page if no utf8 bom is present...
-	if (tmp.getFillSize () > 2)
-	{
-		if (memcmp (source, kBomUtf8, kBomUtf8Length) == 0)
-		{
-			codePage = kCP_Utf8;
-			source += 3;
-		}
-	}
-
-	if (tmp.getFillSize () > 1)
-	{
-#ifdef UNICODE
-		ConstString::multiByteToWideString (ptr, source, nChars, codePage);
-#else
-		if (codePage == kCP_Utf8)
-		{
-			Buffer wideBuffer (tmp.getFillSize () * 3);
-			ConstString::multiByteToWideString (wideBuffer.wcharPtr (), source, wideBuffer.getSize () / 2, kCP_Utf8);
-			ConstString::wideStringToMultiByte (ptr, wideBuffer.wcharPtr (), nChars);		
-		}
-		else
-		{
-			memcpy (ptr, source, Min<TSize> (nChars, tmp.getFillSize ()));
-		}
-#endif
-	}
-
-	ptr[nChars - 1] = 0;
-	return ConstString (ptr).length ();
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::writeStr8 (const char8* s)
-{
-	int32 length = (s) ? (int32) strlen (s) + 1 : 0;
-	if (!writeInt32 (length))
-		return false;
-
-	if (length > 0)
-		return writeRaw (s, sizeof (char8) * length) == static_cast<TSize>(sizeof (char8) * length);
-
-	return true;
-}
-
-//------------------------------------------------------------------------
-int32 FStreamer::getStr8Size (const char8* s) 
-{
-	return sizeof (int32) + (int32)strlen (s) + 1;
-}
-
-//------------------------------------------------------------------------
-char8* FStreamer::readStr8 ()
-{
-	int32 length;
-	if (!readInt32 (length))
-		return nullptr;
-	
-	// check corruption
-	if (length > 262144)
-		return nullptr;
-
-	char8* s = (length > 0) ? NEWVEC char8[length] : nullptr;
-	if (s)
-		readRaw (s, length * sizeof (char8));
-	return s;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::skip (uint32 bytes)
-{
-    int8 tmp;
-	while (bytes-- > 0) 
-	{
-		if (readInt8 (tmp) == false)
-			return false;	
-    }
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FStreamer::pad (uint32 bytes)
-{
-    while (bytes-- > 0) 
-	{
-		if (writeInt8 (0) == false)
-			return false;	
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/base/source/fstreamer.h

@@ -1,242 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/source/fstreamer.h
-// Created by  : Steinberg, 12/2005
-// Description : Extract of typed stream i/o methods from FStream
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-enum FSeekMode
-{
-	kSeekSet,
-	kSeekCurrent,
-	kSeekEnd
-};
-
-//------------------------------------------------------------------------
-// FStreamer
-//------------------------------------------------------------------------
-/** Byteorder-aware base class for typed stream i/o. */
-//------------------------------------------------------------------------
-class FStreamer
-{
-public:
-//------------------------------------------------------------------------
-	FStreamer (int16 byteOrder = BYTEORDER);
-	virtual ~FStreamer () {}
-
-	/** @name Implementing class must override. */
-	///@{
-	virtual TSize readRaw (void*, TSize) = 0;          ///< Read one buffer of size.
-	virtual TSize writeRaw (const void*, TSize) = 0;   ///< Write one buffer of size.
-	virtual int64 seek (int64, FSeekMode) = 0;         ///< Set file position for stream.
-	virtual int64 tell () = 0;                         ///< Return current file position.
-	///@}
-
-	/** @name Streams are byteOrder aware. */
-	///@{
-	inline void setByteOrder (int32 e) { byteOrder = (int16)e; }
-	inline int32 getByteOrder () const { return byteOrder; }
-	///@}
-
-	/** @name read and write int8 and char. */
-	///@{
-	bool writeChar8 (char8); 
-	bool readChar8 (char8&);                         
-	bool writeUChar8 (unsigned char);   
-	bool readUChar8 (unsigned char&);
-	bool writeChar16 (char16 c); 
-	bool readChar16 (char16& c); 
-
-	bool writeInt8 (int8 c){return writeChar8 (c);}   
-	bool readInt8 (int8& c){return readChar8 (c);}
-	bool writeInt8u (uint8 c){return writeUChar8 (c);}   
-	bool readInt8u (uint8& c){return readUChar8 (c);}
-	///@}
-
-	/** @name read and write int16. */
-	///@{
-	bool writeInt16 (int16);
-	bool readInt16 (int16&);
-	bool writeInt16Array (const int16* array, int32 count);  
-	bool readInt16Array (int16* array, int32 count);  
-	bool writeInt16u (uint16);
-	bool readInt16u (uint16&);
-	bool writeInt16uArray (const uint16* array, int32 count);  
-	bool readInt16uArray (uint16* array, int32 count);  
-	///@}
-
-	/** @name read and write int32. */
-	///@{
-	bool writeInt32 (int32);  
-	bool readInt32 (int32&);  
-	bool writeInt32Array (const int32* array, int32 count);  
-	bool readInt32Array (int32* array, int32 count);  
-	bool writeInt32u (uint32);
-	bool readInt32u (uint32&); 
-	bool writeInt32uArray (const uint32* array, int32 count);  
-	bool readInt32uArray (uint32* array, int32 count);  
-	///@}
-
-	/** @name read and write int64. */
-	///@{
-	bool writeInt64 (int64);
-	bool readInt64 (int64&);
-	bool writeInt64Array (const int64* array, int32 count);  
-	bool readInt64Array (int64* array, int32 count);  
-	bool writeInt64u (uint64);
-	bool readInt64u (uint64&);
-	bool writeInt64uArray (const uint64* array, int32 count);  
-	bool readInt64uArray (uint64* array, int32 count);  
-	///@}
-
-	/** @name read and write float and float array. */
-	///@{
-	bool writeFloat (float);
-	bool readFloat (float&);
-	bool writeFloatArray (const float* array, int32 count);  
-	bool readFloatArray (float* array, int32 count);  
-	///@}
-
-	/** @name read and write double and double array. */
-	///@{
-	bool writeDouble (double);                         
-	bool readDouble (double&);                         
-	bool writeDoubleArray (const double* array, int32 count);  
-	bool readDoubleArray (double* array, int32 count);  
-	///@}
-
-	/** @name read and write Boolean. */
-	///@{
-	bool writeBool (bool);                                   ///< Write one boolean
-	bool readBool (bool&);                                   ///< Read one bool.
-	///@}
-
-	/** @name read and write Strings. */
-	///@{
-	TSize writeString8 (const char8* ptr, bool terminate = false); ///< a direct output function writing only one string (ascii 8bit)
-	TSize readString8 (char8* ptr, TSize size);				///< a direct input function reading only one string (ascii) (ended by a \n or \0 or eof)
-	
-	bool writeStr8 (const char8* ptr);				       ///< write a string length (strlen) and string itself
-	char8* readStr8 ();									   ///< read a string length and string text (The return string must be deleted when use is finished)
-
-	static int32 getStr8Size (const char8* ptr);	       ///< returns the size of a saved string
-
-	bool writeStringUtf8 (const tchar* ptr);               ///< always terminated, converts to utf8 if non ascii characters are in string
-	int32 readStringUtf8 (tchar* ptr, int32 maxSize);      ///< read a UTF8 string
-	///@}
-
-	bool skip (uint32 bytes);
-	bool pad (uint32 bytes);
-
-
-//------------------------------------------------------------------------
-protected:
-	int16 byteOrder;
-};
-
-
-//------------------------------------------------------------------------
-/** FStreamSizeHolder Declaration
-	remembers size of stream chunk for backward compatibility.
-	
-	<b>Example:</b>
-	@code
-	externalize (a)
-	{
-		FStreamSizeHolder sizeHolder;
-		sizeHolder.beginWrite ();	// sets start mark, writes dummy size
-		a << ....
-		sizeHolder.endWrite ();		// jumps to start mark, updates size, jumps back here
-	}
-
-	internalize (a)
-	{
-		FStreamSizeHolder sizeHolder;
-		sizeHolder.beginRead ();	// reads size, mark
-		a >> ....
-		sizeHolder.endRead ();		// jumps forward if new version has larger size
-	}
-	@endcode
-*/
-//------------------------------------------------------------------------
-class FStreamSizeHolder
-{
-public:
-	FStreamSizeHolder (FStreamer &s);
-
-	void beginWrite ();	///< remembers position and writes 0
-	int32 endWrite ();	///< writes and returns size (since the start marker)
-	int32 beginRead ();	///< returns size
-	void endRead ();	///< jump to end of chunk
-
-protected:
-	FStreamer &stream;
-	int64 sizePos;
-};
-
-class IBStream;
-
-//------------------------------------------------------------------------
-// IBStreamer
-//------------------------------------------------------------------------
-/** Wrapper class for typed reading/writing from or to IBStream. 
-	Can be used framework-independent in plug-ins. */
-//------------------------------------------------------------------------
-class IBStreamer: public FStreamer
-{
-public:
-//------------------------------------------------------------------------
-	/** Constructor for a given IBSTream and a byteOrder. */
-	IBStreamer (IBStream* stream, int16 byteOrder = BYTEORDER);
-
-	IBStream* getStream () { return stream; }	///< Returns the associated IBStream.
-
-	// FStreamer overrides:					
-	TSize readRaw (void*, TSize) SMTG_OVERRIDE;				///< Read one buffer of size.
-	TSize writeRaw (const void*, TSize) SMTG_OVERRIDE;		///< Write one buffer of size.
-	int64 seek (int64, FSeekMode) SMTG_OVERRIDE;			///< Set file position for stream.
-	int64 tell () SMTG_OVERRIDE;							///< Return current file position.
-//------------------------------------------------------------------------
-protected:
-	IBStream* stream;
-};
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/base/source/fstring.h

@@ -1,748 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/source/fstring.h
-// Created by  : Steinberg, 2008
-// Description : String class
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/ftypes.h"
-#include "pluginterfaces/base/fstrdefs.h"
-#include "pluginterfaces/base/istringresult.h"
-#include "pluginterfaces/base/ipersistent.h"
-
-#include "base/source/fobject.h"
-
-#include <cstdarg>
-
-namespace Steinberg {
-
-class FVariant;
-class String;
-
-#ifdef UNICODE
-static const bool kWideStringDefault = true;
-#else
-static const bool kWideStringDefault = false;
-#endif
-
-static const uint16 kBomUtf16 = 0xFEFF;					///< UTF16 Byte Order Mark
-static const char8* const kBomUtf8 = "\xEF\xBB\xBF";	///< UTF8 Byte Order Mark
-static const int32 kBomUtf8Length = 3;
-
-
-enum MBCodePage
-{
-	kCP_ANSI = 0,			///< Default ANSI codepage.
-	kCP_MAC_ROMAN = 2,		///< Default Mac codepage.
-
-	kCP_ANSI_WEL = 1252,	///< West European Latin Encoding.
-	kCP_MAC_CEE = 10029,	///< Mac Central European Encoding.
-	kCP_Utf8 = 65001,		///< UTF8 Encoding.
-	kCP_ShiftJIS = 932,		///< Shifted Japan Industrial Standard Encoding.
-	kCP_US_ASCII = 20127,	///< US-ASCII (7-bit).
-
-	kCP_Default = kCP_ANSI	///< Default ANSI codepage.
-};
-
-enum UnicodeNormalization
-{
-	kUnicodeNormC,	///< Unicode normalization Form C, canonical composition. 
-	kUnicodeNormD,	///< Unicode normalization Form D, canonical decomposition. 
-	kUnicodeNormKC,	///< Unicode normalization form KC, compatibility composition. 
-	kUnicodeNormKD 	///< Unicode normalization form KD, compatibility decomposition. 
-};
-
-//------------------------------------------------------------------------
-// Helper functions to create hash codes from string data.
-//------------------------------------------------------------------------
-extern uint32 hashString8 (const char8* s, uint32 m);
-extern uint32 hashString16 (const char16* s, uint32 m);
-inline uint32 hashString (const tchar* s, uint32 m)
-{
-#ifdef UNICODE
-	return hashString16 (s, m);
-#else
-	return hashString8 (s, m);
-#endif
-}
-
-
-//-----------------------------------------------------------------------------
-/** Invariant String. 
-@ingroup adt
-
-A base class which provides methods to work with its
-member string. Neither of the operations allows modifying the member string and 
-that is why all operation are declared as const. 
-
-There are operations for access, comparison, find, numbers and conversion.
-
-Almost all operations exist in three versions for char8, char16 and the 
-polymorphic type tchar. The type tchar can either be char8 or char16 depending
-on whether UNICODE is activated or not.*/
-//-----------------------------------------------------------------------------
-class ConstString
-{
-public:
-//-----------------------------------------------------------------------------
-	ConstString (const char8* str, int32 length = -1);	///< Assign from string of type char8 (length=-1: all)
-	ConstString (const char16* str, int32 length = -1);	///< Assign from string of type char16 (length=-1: all)
-	ConstString (const ConstString& str, int32 offset = 0, int32 length = -1); ///< Copy constructor (length=-1: all).
-	ConstString (const FVariant& var);	///< Assign a string from FVariant
-	ConstString ();
-	virtual ~ConstString () {}			///< Destructor.
-
-	// access -----------------------------------------------------------------
-	virtual int32 length () const {return static_cast<int32> (len);}	///< Return length of string
-	inline bool isEmpty () const {return buffer == nullptr || len == 0;}		///< Return true if string is empty
-
-	operator const char8* () const {return text8 ();} 							///< Returns pointer to string of type char8 (no modification allowed)
-	operator const char16* () const {return text16 ();}							///< Returns pointer to string of type char16(no modification allowed)
-	inline tchar operator[] (short idx) const {return getChar (static_cast<uint32> (idx));} ///< Returns character at 'idx'
-	inline tchar operator[] (long idx) const {return getChar (static_cast<uint32> (idx));}
-	inline tchar operator[] (int idx) const {return getChar (static_cast<uint32> (idx));}
-	inline tchar operator[] (unsigned short idx) const {return getChar (idx);}
-	inline tchar operator[] (unsigned long idx) const {return getChar (static_cast<uint32> (idx));}
-	inline tchar operator[] (unsigned int idx) const {return getChar (idx);}
-
-	inline virtual const char8* text8 () const;		///< Returns pointer to string of type char8
-	inline virtual const char16* text16 () const;	///< Returns pointer to string of type char16
-	inline virtual const tchar* text () const;		///< Returns pointer to string of type tchar
-	inline virtual const void* ptr () const {return buffer;}	///< Returns pointer to string of type void
-
-	inline virtual char8 getChar8 (uint32 index) const;		///< Returns character of type char16 at 'index'
-	inline virtual char16 getChar16 (uint32 index) const;	///< Returns character of type char8 at 'index'
-	inline tchar getChar (uint32 index) const;				///< Returns character of type tchar at 'index'
-	inline tchar getCharAt (uint32 index) const;			///< Returns character of type tchar at 'index', no conversion!
-
-	bool testChar8 (uint32 index, char8 c) const;			///< Returns true if character is equal at position 'index'
-	bool testChar16 (uint32 index, char16 c) const;
-	inline bool testChar (uint32 index, char8 c) const {return testChar8 (index, c);}
-	inline bool testChar (uint32 index, char16 c) const {return testChar16 (index, c);}
-
-	bool extract (String& result, uint32 idx, int32 n = -1) const;		///< Get n characters long substring starting at index (n=-1: until end)
-	int32 copyTo8 (char8* str, uint32 idx = 0, int32 n = -1) const;
-	int32 copyTo16 (char16* str, uint32 idx = 0, int32 n = -1) const;
-	int32 copyTo (tchar* str, uint32 idx = 0, int32 n = -1) const;
-	void copyTo (IStringResult* result) const;							///< Copies whole member string
-	void copyTo (IString& string) const;							    ///< Copies whole member string
-
-	inline uint32 hash (uint32 tsize) const 
-	{
-		return isWide ? hashString16 (buffer16, tsize) : hashString8 (buffer8, tsize) ;  
-	}
-	//-------------------------------------------------------------------------
-
-	// compare ----------------------------------------------------------------
-	enum CompareMode
-	{
-		kCaseSensitive,		///< Comparison is done with regard to character's case
-		kCaseInsensitive	///< Comparison is done without regard to character's case
-	};
-
-	int32 compareAt (uint32 index, const ConstString& str, int32 n = -1, CompareMode m = kCaseSensitive) const; 				///< Compare n characters of str with n characters of this starting at index (return: see above)
-	int32 compare (const ConstString& str, int32 n, CompareMode m = kCaseSensitive) const;										///< Compare n characters of str with n characters of this (return: see above)
-	int32 compare (const ConstString& str, CompareMode m = kCaseSensitive) const;												///< Compare all characters of str with this (return: see above)
-
-	int32 naturalCompare (const ConstString& str, CompareMode mode = kCaseSensitive) const;
-
-	bool startsWith (const ConstString& str, CompareMode m = kCaseSensitive) const;												///< Check if this starts with str
-	bool endsWith (const ConstString& str, CompareMode m = kCaseSensitive) const;												///< Check if this ends with str
-	bool contains (const ConstString& str, CompareMode m = kCaseSensitive) const;												///< Check if this contains str											
-
-	// static methods
-	static bool isCharSpace (char8 character);	   ///< Returns true if character is a space
-	static bool isCharSpace (char16 character);    ///< @copydoc isCharSpace(const char8)
-	static bool isCharAlpha (char8 character);	   ///< Returns true if character is an alphabetic character
-	static bool isCharAlpha (char16 character);    ///< @copydoc isCharAlpha(const char8)
-	static bool isCharAlphaNum (char8 character);  ///< Returns true if character is an alphanumeric character
-	static bool isCharAlphaNum (char16 character); ///< @copydoc isCharAlphaNum(const char8)
-	static bool isCharDigit (char8 character);	   ///< Returns true if character is a number
-	static bool isCharDigit (char16 character);    ///< @copydoc isCharDigit(const char8)
-	static bool isCharAscii (char8 character);     ///< Returns true if character is in ASCII range
-	static bool isCharAscii (char16 character);    ///< Returns true if character is in ASCII range
-	static bool isCharUpper (char8 character);
-	static bool isCharUpper (char16 character);
-	static bool isCharLower (char8 character);
-	static bool isCharLower (char16 character);
-	//-------------------------------------------------------------------------
-
-	/** @name Find first occurrence of n characters of str in this (n=-1: all) ending at endIndex (endIndex = -1: all)*/
-	///@{
-	inline int32 findFirst (const ConstString& str, int32 n = -1, CompareMode m = kCaseSensitive, int32 endIndex = -1) const {return findNext (0, str, n, m, endIndex);}
-	inline int32 findFirst (char8 c, CompareMode m = kCaseSensitive, int32 endIndex = -1) const {return findNext (0, c, m, endIndex);}
-	inline int32 findFirst (char16 c, CompareMode m = kCaseSensitive, int32 endIndex = -1) const {return findNext (0, c, m, endIndex);}
-	///@}
-	/** @name Find next occurrence of n characters of str starting at startIndex in this (n=-1: all) ending at endIndex (endIndex = -1: all)*/
-	///@{
-	int32 findNext (int32 startIndex, const ConstString& str, int32 n = -1, CompareMode = kCaseSensitive, int32 endIndex = -1) const;
-	int32 findNext (int32 startIndex, char8 c, CompareMode = kCaseSensitive, int32 endIndex = -1) const;
-	int32 findNext (int32 startIndex, char16 c, CompareMode = kCaseSensitive, int32 endIndex = -1) const;
-	///@}
-	/** @name Find previous occurrence of n characters of str starting at startIndex in this (n=-1: all) */
-	///@{
-	int32 findPrev (int32 startIndex, const ConstString& str, int32 n = -1, CompareMode = kCaseSensitive) const;
-	int32 findPrev (int32 startIndex, char8 c, CompareMode = kCaseSensitive) const;
-	int32 findPrev (int32 startIndex, char16 c, CompareMode = kCaseSensitive) const;
-	///@}
-	
-	inline int32 findLast (const ConstString& str, int32 n = -1, CompareMode m = kCaseSensitive) const {return findPrev (-1, str, n, m);}	///< Find last occurrence of n characters of str in this (n=-1: all)
-	inline int32 findLast (char8 c, CompareMode m = kCaseSensitive) const {return findPrev (-1, c, m);}
-	inline int32 findLast (char16 c, CompareMode m = kCaseSensitive) const {return findPrev (-1, c, m);}
-
-	int32 countOccurences (char8 c, uint32 startIndex, CompareMode = kCaseSensitive) const; ///< Counts occurences of c within this starting at index
-	int32 countOccurences (char16 c, uint32 startIndex, CompareMode = kCaseSensitive) const;
-	int32 getFirstDifferent (const ConstString& str, CompareMode = kCaseSensitive) const;	///< Returns position of first different character
-	//-------------------------------------------------------------------------
-
-	// numbers ----------------------------------------------------------------
-	bool isDigit (uint32 index) const;	///< Returns true if character at position is a digit
-	bool scanFloat (double& value, uint32 offset = 0, bool scanToEnd = true) const;		///< Converts string to double value starting at offset
-	bool scanInt64 (int64& value, uint32 offset = 0, bool scanToEnd = true) const;		///< Converts string to int64 value starting at offset
-	bool scanUInt64 (uint64& value, uint32 offset = 0, bool scanToEnd = true) const;	///< Converts string to uint64 value starting at offset
-	bool scanInt32 (int32& value, uint32 offset = 0, bool scanToEnd = true) const;		///< Converts string to int32 value starting at offset
-	bool scanUInt32 (uint32& value, uint32 offset = 0, bool scanToEnd = true) const;	///< Converts string to uint32 value starting at offset
-	bool scanHex (uint8& value, uint32 offset = 0, bool scanToEnd = true) const;		///< Converts string to hex/uint8 value starting at offset
-
-	int32 getTrailingNumberIndex (uint32 width = 0) const;	///< Returns start index of trailing number
-	int64 getTrailingNumber (int64 fallback = 0) const;		///< Returns result of scanInt64 or the fallback
-	int64 getNumber () const;								///< Returns result of scanInt64
-
-	// static methods
-	static bool scanInt64_8 (const char8* text, int64& value, bool scanToEnd = true);	///< Converts string of type char8 to int64 value
-	static bool scanInt64_16 (const char16* text, int64& value, bool scanToEnd = true);	///< Converts string of type char16 to int64 value
-	static bool scanInt64 (const tchar* text, int64& value, bool scanToEnd = true);		///< Converts string of type tchar to int64 value
-
-	static bool scanUInt64_8 (const char8* text, uint64& value, bool scanToEnd = true);		///< Converts string of type char8 to uint64 value
-	static bool scanUInt64_16 (const char16* text, uint64& value, bool scanToEnd = true);	///< Converts string of type char16 to uint64 value
-	static bool scanUInt64 (const tchar* text, uint64& value, bool scanToEnd = true);		///< Converts string of type tchar to uint64 value
-
-	static bool scanInt32_8 (const char8* text, int32& value, bool scanToEnd = true);		///< Converts string of type char8 to int32 value
-	static bool scanInt32_16 (const char16* text, int32& value, bool scanToEnd = true);		///< Converts string of type char16 to int32 value
-	static bool scanInt32 (const tchar* text, int32& value, bool scanToEnd = true);			///< Converts string of type tchar to int32 value
-
-	static bool scanUInt32_8 (const char8* text, uint32& value, bool scanToEnd = true);		///< Converts string of type char8 to int32 value
-	static bool scanUInt32_16 (const char16* text, uint32& value, bool scanToEnd = true);		///< Converts string of type char16 to int32 value
-	static bool scanUInt32 (const tchar* text, uint32& value, bool scanToEnd = true);			///< Converts string of type tchar to int32 value
-
-	static bool scanHex_8 (const char8* text, uint8& value, bool scanToEnd = true);		///< Converts string of type char8 to hex/unit8 value
-	static bool scanHex_16 (const char16* text, uint8& value, bool scanToEnd = true);	///< Converts string of type char16 to hex/unit8 value
-	static bool scanHex (const tchar* text, uint8& value, bool scanToEnd = true);		///< Converts string of type tchar to hex/unit8 value
-	//-------------------------------------------------------------------------
-
-	// conversion -------------------------------------------------------------
-	void toVariant (FVariant& var) const;
-
-	static char8 toLower (char8 c);		///< Converts to lower case
-	static char8 toUpper (char8 c);		///< Converts to upper case
-	static char16 toLower (char16 c);
-	static char16 toUpper (char16 c);
-
-	static int32 multiByteToWideString (char16* dest, const char8* source, int32 wcharCount, uint32 sourceCodePage = kCP_Default);	///< If dest is zero, this returns the maximum number of bytes needed to convert source
-	static int32 wideStringToMultiByte (char8* dest, const char16* source, int32 char8Count, uint32 destCodePage = kCP_Default);	///< If dest is zero, this returns the maximum number of bytes needed to convert source
-
-	bool isWideString () const {return isWide != 0;}	///< Returns true if string is wide
-	bool isAsciiString () const; 						///< Checks if all characters in string are in ascii range
-
-	bool isNormalized (UnicodeNormalization = kUnicodeNormC); ///< On PC only kUnicodeNormC is working
-
-#if SMTG_OS_MACOS
-	virtual void* toCFStringRef (uint32 encoding = 0xFFFF, bool mutableCFString = false) const;	///< CFString conversion
-#endif
-//-------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-protected:
-
-	union 
-	{
-		void* buffer;
-		char8* buffer8;
-		char16* buffer16;
-	};
-	uint32 len : 30;
-	uint32 isWide : 1;
-};
-
-//-----------------------------------------------------------------------------
-/** String.
-@ingroup adt
-
-Extends class ConstString by operations which allow modifications. 
-
-\see ConstString */
-//-----------------------------------------------------------------------------
-class String : public ConstString
-{
-public:
-	
-//-----------------------------------------------------------------------------
-	String ();
-	String (const char8* str, MBCodePage codepage, int32 n = -1, bool isTerminated = true);							///< assign n characters of str and convert to wide string by using the specified codepage
-	String (const char8* str, int32 n = -1, bool isTerminated = true);	///< assign n characters of str (-1: all)
-	String (const char16* str, int32 n = -1, bool isTerminated = true);	///< assign n characters of str (-1: all)
-	String (const String& str, int32 n = -1);							///< assign n characters of str (-1: all)
-	String (const ConstString& str, int32 n = -1);		///< assign n characters of str (-1: all)
-	String (const FVariant& var);						///< assign from FVariant
-	String (IString* str);						///< assign from IString
-	~String ();
-
-#if SMTG_CPP11_STDLIBSUPPORT
-	String (String&& str);
-	String& operator= (String&& str);
-#endif
-
-	// access------------------------------------------------------------------
-	void updateLength (); ///< Call this when the string is truncated outside (not recommended though)
-	const char8* text8 () const SMTG_OVERRIDE;
-	const char16* text16 () const SMTG_OVERRIDE;
-	char8 getChar8 (uint32 index) const SMTG_OVERRIDE;
-	char16 getChar16 (uint32 index) const SMTG_OVERRIDE;
-
-	bool setChar8 (uint32 index, char8 c);
-	bool setChar16 (uint32 index, char16 c);
-	inline bool setChar (uint32 index, char8 c) {return setChar8 (index, c);}
-	inline bool setChar (uint32 index, char16 c) {return setChar16 (index, c);}
-	//-------------------------------------------------------------------------
-
-	// assignment--------------------------------------------------------------
-	String& operator= (const char8* str) {return assign (str);}	///< Assign from a string of type char8
-	String& operator= (const char16* str) {return assign (str);}
-	String& operator= (const ConstString& str) {return assign (str);}
-	String& operator= (const String& str) {return assign (str);}
-	String& operator= (char8 c) {return assign (c);}
-	String& operator= (char16 c) {return assign (c);}
-
-	String& assign (const ConstString& str, int32 n = -1);			///< Assign n characters of str (-1: all)
-	String& assign (const char8* str, int32 n = -1, bool isTerminated = true);			///< Assign n characters of str (-1: all)
-	String& assign (const char16* str, int32 n = -1, bool isTerminated = true);			///< Assign n characters of str (-1: all)
-	String& assign (char8 c, int32 n = 1);
-	String& assign (char16 c, int32 n = 1);
-	//-------------------------------------------------------------------------
-
-	// concat------------------------------------------------------------------
-	String& append (const ConstString& str, int32 n = -1);		///< Append n characters of str to this (n=-1: all)
-	String& append (const char8* str, int32 n = -1);			///< Append n characters of str to this (n=-1: all)
-	String& append (const char16* str, int32 n = -1);			///< Append n characters of str to this (n=-1: all)
-	String& append (const char8 c, int32 n = 1);                ///< Append char c n times
-	String& append (const char16 c, int32 n = 1);               ///< Append char c n times
-
-	String& insertAt (uint32 idx, const ConstString& str, int32 n = -1);	///< Insert n characters of str at position idx (n=-1: all)
-	String& insertAt (uint32 idx, const char8* str, int32 n = -1);	///< Insert n characters of str at position idx (n=-1: all)
-	String& insertAt (uint32 idx, const char16* str, int32 n = -1);	///< Insert n characters of str at position idx (n=-1: all)
-	String& insertAt (uint32 idx, char8 c) {char8 str[] = {c, 0}; return insertAt (idx, str, 1);} 
-	String& insertAt (uint32 idx, char16 c) {char16 str[] = {c, 0}; return insertAt (idx, str, 1);}
-
-	String& operator+= (const String& str) {return append (str);}
-	String& operator+= (const ConstString& str) {return append (str);}
-	String& operator+= (const char8* str) {return append (str);}
-	String& operator+= (const char16* str) {return append (str);}
-	String& operator+= (const char8 c) {return append (c);}
-	String& operator+= (const char16 c) {return append (c);}
-	//-------------------------------------------------------------------------
-
-	// replace-----------------------------------------------------------------
-	String& replace (uint32 idx, int32 n1, const ConstString& str, int32 n2 = -1);		///< Replace n1 characters of this (starting at idx) with n2 characters of str (n1,n2=-1: until end)
-	String& replace (uint32 idx, int32 n1, const char8* str, int32 n2 = -1);			///< Replace n1 characters of this (starting at idx) with n2 characters of str (n1,n2=-1: until end)
-	String& replace (uint32 idx, int32 n1, const char16* str, int32 n2 = -1);			///< Replace n1 characters of this (starting at idx) with n2 characters of str (n1,n2=-1: until end)
-
-	int32 replace (const char8* toReplace, const char8* toReplaceWith, bool all = false, CompareMode m = kCaseSensitive);			///< Replace find string with replace string - returns number of replacements
-	int32 replace (const char16* toReplace, const char16* toReplaceWith, bool all = false, CompareMode m = kCaseSensitive);		///< Replace find string with replace string - returns number of replacements
-
-	bool replaceChars8 (const char8* toReplace, char8 toReplaceBy); ///< Returns true when any replacement was done
-	bool replaceChars16 (const char16* toReplace, char16 toReplaceBy);
-	inline bool replaceChars8 (char8 toReplace, char8 toReplaceBy)  {char8 str[] = {toReplace, 0}; return replaceChars8 (str, toReplaceBy);}
-	inline bool replaceChars16 (char16 toReplace, char16 toReplaceBy)  {char16 str[] = {toReplace, 0}; return replaceChars16 (str, toReplaceBy);}
-	inline bool replaceChars (char8 toReplace, char8 toReplaceBy) {return replaceChars8 (toReplace, toReplaceBy);}
-	inline bool replaceChars (char16 toReplace, char16 toReplaceBy) {return replaceChars16 (toReplace, toReplaceBy);}
-	inline bool replaceChars (const char8* toReplace, char8 toReplaceBy) {return replaceChars8 (toReplace, toReplaceBy);}
-	inline bool replaceChars (const char16* toReplace, char16 toReplaceBy) {return replaceChars16 (toReplace, toReplaceBy);}
-	//-------------------------------------------------------------------------
-
-	// remove------------------------------------------------------------------
-	String& remove (uint32 index = 0, int32 n = -1);		///< Remove n characters from string starting at index (n=-1: until end)
-	enum CharGroup {kSpace, kNotAlphaNum, kNotAlpha};
-	bool trim (CharGroup mode = kSpace);					///< Trim lead/trail.
-	void removeChars (CharGroup mode = kSpace);				///< Removes all of group.
-	bool removeChars8 (const char8* which);					///< Remove all occurrences of each char in 'which'
-	bool removeChars16 (const char16* which);				///< Remove all occurrences of each char in 'which'
-	inline bool removeChars8 (const char8 which) {char8 str[] = {which, 0}; return removeChars8 (str); }     
-	inline bool removeChars16 (const char16 which) {char16 str[] = {which, 0}; return removeChars16 (str); }                
-	inline bool removeChars (const char8* which) {return removeChars8 (which);}
-	inline bool removeChars (const char16* which) {return removeChars16 (which);}
-	inline bool removeChars (const char8 which) {return removeChars8 (which);}
-	inline bool removeChars (const char16 which) {return removeChars16 (which);}
-	bool removeSubString (const ConstString& subString, bool allOccurences = true);
-	//-------------------------------------------------------------------------
-
-	// print-------------------------------------------------------------------
-	String& printf (const char8* format, ...);					///< Print formatted data into string
-	String& printf (const char16* format, ...);					///< Print formatted data into string
-	String& vprintf (const char8* format, va_list args);
-	String& vprintf (const char16* format, va_list args);
-	//-------------------------------------------------------------------------
-
-	// numbers-----------------------------------------------------------------
-	String& printInt64 (int64 value);
-	String& printFloat (double value);
-	/** Increment the trailing number if present else start with minNumber, width specifies the string width format (width 2 for number 3 is 03),
-		applyOnlyFormat set to true will only format the string to the given width without incrementing the founded trailing number */
-	bool incrementTrailingNumber (uint32 width = 2, tchar separator = STR (' '), uint32 minNumber = 1, bool applyOnlyFormat = false);
-	//-------------------------------------------------------------------------
-
-	// conversion--------------------------------------------------------------
-	bool fromVariant (const FVariant& var);		///< Assigns string from FVariant
-	void toVariant (FVariant& var) const;
-	bool fromAttributes (IAttributes* a, IAttrID attrID);	///< Assigns string from FAttributes
-	bool toAttributes (IAttributes* a, IAttrID attrID);
-
-	void swapContent (String& s); 								///< Swaps ownership of the strings pointed to
-	void take (String& str);      								///< Take ownership of the string of 'str'
-	void take (void* _buffer, bool wide);      					///< Take ownership of buffer
-	void* pass ();
-	void passToVariant (FVariant& var);							///< Pass ownership of buffer to Variant - sets Variant ownership
-
-	void toLower (uint32 index);								///< Lower case the character.
-	void toLower ();											///< Lower case the string.
-	void toUpper (uint32 index);								///< Upper case the character.
-	void toUpper ();											///< Upper case the string.
-
-	unsigned char* toPascalString (unsigned char* buf);			///< Pascal string conversion
-	const String& fromPascalString (const unsigned char* buf);	///< Pascal string conversion
-
-	bool toWideString (uint32 sourceCodePage = kCP_Default);	///< Converts to wide string according to sourceCodePage
-	bool toMultiByte (uint32 destCodePage = kCP_Default);
-
-	void fromUTF8 (const char8* utf8String);				///< Assigns from UTF8 string
-	bool normalize (UnicodeNormalization = kUnicodeNormC);	///< On PC only kUnicodeNormC is working
-
-#if SMTG_OS_MACOS
-	virtual bool fromCFStringRef (const void*, uint32 encoding = 0xFFFF);	///< CFString conversion
-#endif
-	//-------------------------------------------------------------------------
-
-	//-----------------------------------------------------------------------------
-protected:
-	bool resize (uint32 newSize, bool wide, bool fill = false);
-
-private:
-	void tryFreeBuffer ();
-	bool checkToMultiByte (uint32 destCodePage = kCP_Default) const; // to remove debug code from inline - const_cast inside!!!
-};
-
-// String concatenation functions.
-inline String operator+ (const ConstString& s1, const ConstString& s2) {return String (s1).append (s2);}
-inline String operator+ (const ConstString& s1, const char8* s2) {return String (s1).append (s2);}
-inline String operator+ (const ConstString& s1, const char16* s2) {return String (s1).append (s2);}
-inline String operator+ (const char8* s1, const ConstString& s2) {return String (s1).append (s2);}
-inline String operator+ (const char16* s1, const ConstString& s2) {return String (s1).append (s2);}
-inline String operator+ (const ConstString& s1, const String& s2) {return String (s1).append (s2);}
-inline String operator+ (const String& s1, const ConstString& s2) {return String (s1).append (s2);}
-inline String operator+ (const String& s1, const String& s2) {return String (s1).append (s2);}
-inline String operator+ (const String& s1, const char8* s2) {return String (s1).append (s2);}
-inline String operator+ (const String& s1, const char16* s2) {return String (s1).append (s2);}
-inline String operator+ (const char8* s1, const String& s2) {return String (s1).append (s2);}
-inline String operator+ (const char16* s1, const String& s2) {return String (s1).append (s2);}
-
-//-----------------------------------------------------------------------------
-// ConstString
-//-----------------------------------------------------------------------------
-inline const tchar* ConstString::text () const
-{
-#ifdef UNICODE
-	return text16 ();
-#else
-	return text8 ();
-#endif
-}
-
-//-----------------------------------------------------------------------------
-inline const char8* ConstString::text8 () const
-{
-	return (!isWide && buffer8) ? buffer8: kEmptyString8;
-}
-
-//-----------------------------------------------------------------------------
-inline const char16* ConstString::text16 () const
-{
-	return (isWide && buffer16) ? buffer16 : kEmptyString16;
-}
-
-//-----------------------------------------------------------------------------
-inline char8 ConstString::getChar8 (uint32 index) const
-{
-	if (index < len && buffer8 && !isWide)
-		return buffer8[index];
-	return 0;
-}
-
-//-----------------------------------------------------------------------------
-inline char16 ConstString::getChar16 (uint32 index) const
-{
-	if (index < len && buffer16 && isWide)
-		return buffer16[index];
-	return 0;
-}
-
-//-----------------------------------------------------------------------------
-inline tchar ConstString::getChar (uint32 index) const
-{
-#ifdef UNICODE
-	return getChar16 (index);
-#else
-	return getChar8 (index);
-#endif
-}
-
-//-----------------------------------------------------------------------------
-inline tchar ConstString::getCharAt (uint32 index) const
-{
-#ifdef UNICODE
-	if (isWide)
-		return getChar16 (index);
-#endif
-
-	return static_cast<tchar> (getChar8 (index));
-}
-
-//-----------------------------------------------------------------------------
-inline int64 ConstString::getNumber () const
-{
-	int64 tmp = 0;
-	scanInt64 (tmp);
-	return tmp;
-}
-
-//-----------------------------------------------------------------------------
-inline bool ConstString::scanInt32_8 (const char8* text, int32& value, bool scanToEnd)
-{
-	int64 tmp;
-	if (scanInt64_8 (text, tmp, scanToEnd))
-	{
-		value = (int32)tmp;
-		return true;
-	}
-	return false;
-}
-
-//-----------------------------------------------------------------------------
-inline bool ConstString::scanInt32_16 (const char16* text, int32& value, bool scanToEnd)
-{
-	int64 tmp;
-	if (scanInt64_16 (text, tmp, scanToEnd))
-	{
-		value = (int32)tmp;
-		return true;
-	}
-	return false;
-}
-
-//-----------------------------------------------------------------------------
-inline bool ConstString::scanInt32 (const tchar* text, int32& value, bool scanToEnd)
-{
-	int64 tmp;
-	if (scanInt64 (text, tmp, scanToEnd))
-	{
-		value = (int32)tmp;
-		return true;
-	}
-	return false;
-}
-
-//-----------------------------------------------------------------------------
-inline bool ConstString::scanUInt32_8 (const char8* text, uint32& value, bool scanToEnd)
-{
-	uint64 tmp;
-	if (scanUInt64_8 (text, tmp, scanToEnd))
-	{
-		value = (uint32)tmp;
-		return true;
-	}
-	return false;
-}
-
-//-----------------------------------------------------------------------------
-inline bool ConstString::scanUInt32_16 (const char16* text, uint32& value, bool scanToEnd)
-{
-	uint64 tmp;
-	if (scanUInt64_16 (text, tmp, scanToEnd))
-	{
-		value = (uint32)tmp;
-		return true;
-	}
-	return false;
-}
-
-//-----------------------------------------------------------------------------
-inline bool ConstString::scanUInt32 (const tchar* text, uint32& value, bool scanToEnd)
-{
-	uint64 tmp;
-	if (scanUInt64 (text, tmp, scanToEnd))
-	{
-		value = (uint32)tmp;
-		return true;
-	}
-	return false;
-}
-
-//-----------------------------------------------------------------------------
-inline const char8* String::text8 () const
-{
-	if (isWide && !isEmpty ())
-		checkToMultiByte (); // this should be avoided, since it can lead to information loss
-
-	return ConstString::text8 ();
-}
-
-//-----------------------------------------------------------------------------
-inline const char16* String::text16 () const
-{
-	if (!isWide && !isEmpty ())
-	{
-		const_cast<String&> (*this).toWideString ();
-	}
-	return ConstString::text16 ();
-}
-
-//-----------------------------------------------------------------------------
-inline char8 String::getChar8 (uint32 index) const
-{
-	if (isWide && !isEmpty ())
-		checkToMultiByte (); // this should be avoided, since it can lead to information loss
-
-	return ConstString::getChar8 (index);
-}
-
-//-----------------------------------------------------------------------------
-inline char16 String::getChar16 (uint32 index) const
-{
-	if (!isWide && !isEmpty ())
-	{
-		const_cast<String&> (*this).toWideString ();
-	}
-	return ConstString::getChar16 (index);
-}
-
-//-----------------------------------------------------------------------------
-
-
-inline bool operator<  (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) < 0) ? true : false;}
-inline bool operator<= (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) <= 0) ? true : false;}
-inline bool operator>  (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) > 0) ? true : false;}
-inline bool operator>= (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) >= 0) ? true : false;}
-inline bool operator== (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) == 0) ? true : false;}
-inline bool operator!= (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) != 0) ? true : false;}
-
-inline bool operator<  (const ConstString& s1, const char8* s2) {return (s1.compare (s2) < 0) ? true : false;}
-inline bool operator<= (const ConstString& s1, const char8* s2) {return (s1.compare (s2) <= 0) ? true : false;}
-inline bool operator>  (const ConstString& s1, const char8* s2) {return (s1.compare (s2) > 0) ? true : false;}
-inline bool operator>= (const ConstString& s1, const char8* s2) {return (s1.compare (s2) >= 0) ? true : false;}
-inline bool operator== (const ConstString& s1, const char8* s2) {return (s1.compare (s2) == 0) ? true : false;}
-inline bool operator!= (const ConstString& s1, const char8* s2) {return (s1.compare (s2) != 0) ? true : false;}
-inline bool operator<  (const char8* s1, const ConstString& s2) {return (s2.compare (s1) > 0) ? true : false;}
-inline bool operator<= (const char8* s1, const ConstString& s2) {return (s2.compare (s1) >= 0) ? true : false;}
-inline bool operator>  (const char8* s1, const ConstString& s2) {return (s2.compare (s1) < 0) ? true : false;}
-inline bool operator>= (const char8* s1, const ConstString& s2) {return (s2.compare (s1) <= 0) ? true : false;}
-inline bool operator== (const char8* s1, const ConstString& s2) {return (s2.compare (s1) == 0) ? true : false;}
-inline bool operator!= (const char8* s1, const ConstString& s2) {return (s2.compare (s1) != 0) ? true : false;}
-
-inline bool operator<  (const ConstString& s1, const char16* s2) {return (s1.compare (s2) < 0) ? true : false;}
-inline bool operator<= (const ConstString& s1, const char16* s2) {return (s1.compare (s2) <= 0) ? true : false;}
-inline bool operator>  (const ConstString& s1, const char16* s2) {return (s1.compare (s2) > 0) ? true : false;}
-inline bool operator>= (const ConstString& s1, const char16* s2) {return (s1.compare (s2) >= 0) ? true : false;}
-inline bool operator== (const ConstString& s1, const char16* s2) {return (s1.compare (s2) == 0) ? true : false;}
-inline bool operator!= (const ConstString& s1, const char16* s2) {return (s1.compare (s2) != 0) ? true : false;}
-inline bool operator<  (const char16* s1, const ConstString& s2) {return (s2.compare (s1) > 0) ? true : false;}
-inline bool operator<= (const char16* s1, const ConstString& s2) {return (s2.compare (s1) >= 0) ? true : false;}
-inline bool operator>  (const char16* s1, const ConstString& s2) {return (s2.compare (s1) < 0) ? true : false;}
-inline bool operator>= (const char16* s1, const ConstString& s2) {return (s2.compare (s1) <= 0) ? true : false;}
-inline bool operator== (const char16* s1, const ConstString& s2) {return (s2.compare (s1) == 0) ? true : false;}
-inline bool operator!= (const char16* s1, const ConstString& s2) {return (s2.compare (s1) != 0) ? true : false;}
-
-// The following functions will only work with European Numbers!
-// (e.g. Arabic, Tibetan, and Khmer digits are not supported)
-extern int32 strnatcmp8 (const char8* s1, const char8* s2, bool caseSensitive = true);
-extern int32 strnatcmp16 (const char16* s1, const char16* s2, bool caseSensitive = true);
-inline int32 strnatcmp (const tchar* s1, const tchar* s2, bool caseSensitive = true)
-{
-#ifdef UNICODE
-	return strnatcmp16 (s1, s2, caseSensitive);
-#else
-	return strnatcmp8 (s1, s2, caseSensitive);
-#endif
-}
-
-//-----------------------------------------------------------------------------
-/** StringObject implements IStringResult and IString methods.
-    It can therefore be exchanged with other Steinberg objects using one or both of these
-interfaces.
-
-\see String, ConstString
-*/
-//-----------------------------------------------------------------------------
-class StringObject : public FObject, public String, public IStringResult, public IString
-{
-public:
-//-----------------------------------------------------------------------------
-	StringObject () {}										
-	StringObject (const char16* str, int32 n = -1, bool isTerminated = true) : String (str, n, isTerminated) {}
-	StringObject (const char8* str, int32 n = -1, bool isTerminated = true) : String (str, n, isTerminated) {}
-	StringObject (const StringObject& str, int32 n = -1) : String (str, n) {}		
-	StringObject (const String& str, int32 n = -1) : String (str, n) {}		
-	StringObject (const FVariant& var) : String (var) {}		
-
-	using String::operator=;
-
-	// IStringResult ----------------------------------------------------------
-	void PLUGIN_API setText (const char8* text) SMTG_OVERRIDE;
-	//-------------------------------------------------------------------------
-
-	// IString-----------------------------------------------------------------
-	void PLUGIN_API setText8 (const char8* text) SMTG_OVERRIDE;
-	void PLUGIN_API setText16 (const char16* text) SMTG_OVERRIDE;
-
-	const char8* PLUGIN_API getText8 () SMTG_OVERRIDE;
-	const char16* PLUGIN_API getText16 () SMTG_OVERRIDE;
-
-	void PLUGIN_API take (void* s, bool _isWide) SMTG_OVERRIDE;
-	bool PLUGIN_API isWideString () const SMTG_OVERRIDE;
-	//-------------------------------------------------------------------------
-
-	OBJ_METHODS (StringObject, FObject)
-	FUNKNOWN_METHODS2 (IStringResult, IString, FObject)
-};
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/base/source/updatehandler.cpp

@@ -1,733 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/source/updatehandler.cpp
-// Created by  : Steinberg, 2008
-// Description :
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "base/source/updatehandler.h"
-#include "base/source/classfactoryhelpers.h"
-#include "base/source/fstring.h"
-
-#if SMTG_CPP11_STDLIBSUPPORT
-#include <unordered_map>
-#else
-#include <map>
-#endif
-#include <deque>
-#include <vector>
-#include <algorithm>
-
-#define NON_EXISTING_DEPENDENCY_CHECK 0 // not yet
-#define CLASS_NAME_TRACKED DEVELOPMENT
-
-using Steinberg::Base::Thread::FGuard;
-
-namespace Steinberg {
-
-DEF_CLASS_IID (IUpdateManager)
-bool UpdateHandler::lockUpdates = false;
-
-namespace Update {
-const uint32 kHashSize = (1 << 8); // must be power of 2 (16 bytes * 256 == 4096)
-const uint32 kMapSize = 1024 * 10;
-
-//------------------------------------------------------------------------
-inline uint32 hashPointer (void* p)
-{
-	return (uint32)((uint64 (p) >> 12) & (kHashSize - 1));
-}
-
-//------------------------------------------------------------------------
-inline IPtr<FUnknown> getUnknownBase (FUnknown* unknown)
-{
-	FUnknown* result = nullptr;
-	if (unknown)
-		unknown->queryInterface (FUnknown::iid, (void**)&result);
-
-	return owned (result);
-}
-
-#if CLASS_NAME_TRACKED
-//------------------------------------------------------------------------
-struct Dependency
-{
-	Dependency (FUnknown* o, IDependent* d)
-	: obj (o), dep (d), objClass (nullptr), depClass (nullptr)
-	{
-	}
-
-	inline bool operator== (const Dependency& d) const { return obj == d.obj; }
-	inline bool operator!= (const Dependency& d) const { return obj != d.obj; }
-	inline bool operator< (const Dependency& d) const { return obj < d.obj; }
-	inline bool operator> (const Dependency& d) const { return obj > d.obj; }
-	FUnknown* obj;
-	IDependent* dep;
-
-	FClassID objClass;
-	FClassID depClass;
-};
-#endif
-
-//------------------------------------------------------------------------
-struct DeferedChange
-{
-	DeferedChange (FUnknown* o, int32 m = 0) : obj (o), msg (m) {}
-	~DeferedChange () {}
-	DeferedChange (const DeferedChange& r) : obj (r.obj), msg (r.msg) {}
-	inline bool operator== (const DeferedChange& d) const { return obj == d.obj; }
-	inline bool operator!= (const DeferedChange& d) const { return obj != d.obj; }
-	FUnknown* obj;
-	int32 msg;
-};
-
-//------------------------------------------------------------------------
-struct UpdateData
-{
-	UpdateData (FUnknown* o, IDependent** d, uint32 c)
-	: obj (o), dependents (d), count (c)
-	{
-	}
-	FUnknown* obj;
-	IDependent** dependents;
-	uint32 count;
-	bool operator== (const UpdateData& d) const
-	{
-		return d.obj == obj && d.dependents == dependents;
-	}
-};
-
-//------------------------------------------------------------------------
-using DeferedChangeList = std::deque<DeferedChange>;
-using DeferedChangeListIterConst = DeferedChangeList::const_iterator;
-using DeferedChangeListIter = DeferedChangeList::iterator;
-
-using UpdateDataList = std::deque<UpdateData>;
-using UpdateDataListIterConst = UpdateDataList::const_iterator;
-
-#if CLASS_NAME_TRACKED
-using DependentList = std::vector<Dependency>;
-#else
-typedef std::vector<IDependent*> DependentList;
-#endif
-using DependentListIter = DependentList::iterator;
-using DependentListIterConst = DependentList::const_iterator;
-
-#if SMTG_CPP11_STDLIBSUPPORT
-using DependentMap = std::unordered_map<const FUnknown*, DependentList>;
-#else
-typedef std::map<const FUnknown*, DependentList> DependentMap;
-#endif
-using DependentMapIter = DependentMap::iterator;
-using DependentMapIterConst = DependentMap::const_iterator;
-
-struct Table
-{
-	DependentMap depMap[kHashSize];
-	DeferedChangeList defered;
-	UpdateDataList updateData;
-};
-
-//------------------------------------------------------------------------
-void updateDone (FUnknown* unknown, int32 message)
-{
-	if (message != IDependent::kDestroyed)
-	{
-		FObject* obj = FObject::unknownToObject (unknown);
-		if (obj)
-			obj->updateDone (message);
-	}
-}
-} // namespace Update
-
-//------------------------------------------------------------------------
-static int32 countEntries (Update::DependentMap& map)
-{
-	int32 total = 0;
-	Update::DependentMapIterConst iterMap = map.begin ();
-	while (iterMap != map.end ())
-	{
-		const Update::DependentList& list = iterMap->second;
-		Update::DependentListIterConst iterList = list.begin ();
-		while (iterList != list.end ())
-		{
-			total++;
-			++iterList;
-		}
-		++iterMap;
-	}
-	return total;
-}
-
-//------------------------------------------------------------------------
-UpdateHandler::UpdateHandler ()
-{
-	table = NEW Update::Table;
-	if (FObject::getUpdateHandler () == nullptr)
-		FObject::setUpdateHandler (this);
-}
-
-//------------------------------------------------------------------------
-UpdateHandler::~UpdateHandler ()
-{
-	if (FObject::getUpdateHandler () == this)
-		FObject::setUpdateHandler (nullptr);
-	delete table;
-	table = nullptr;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API UpdateHandler::addDependent (FUnknown* u, IDependent* _dependent)
-{
-	IPtr<FUnknown> unknown = Update::getUnknownBase (u);
-	if (!unknown || !_dependent)
-		return kResultFalse;
-
-	FGuard guard (lock);
-
-#if CLASS_NAME_TRACKED
-	Update::Dependency dependent (unknown, _dependent);
-
-	FObject* obj = FObject::unknownToObject (unknown);
-	if (obj)
-		dependent.objClass = obj->isA ();
-	obj = FObject::unknownToObject (_dependent);
-	if (obj)
-		dependent.depClass = obj->isA ();
-#else
-	IDependent* dependent = _dependent;
-#endif
-
-	Update::DependentMap& map = table->depMap[Update::hashPointer (unknown)];
-	Update::DependentMapIter it = map.find (unknown);
-	if (it == map.end ())
-	{
-		Update::DependentList list;
-		list.push_back (dependent);
-		map[unknown] = list;
-	}
-	else
-	{
-		(*it).second.push_back (dependent);
-	}
-
-	return kResultTrue;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API UpdateHandler::removeDependent (FUnknown* u, IDependent* dependent)
-{
-	IPtr<FUnknown> unknown = Update::getUnknownBase (u);
-	if (unknown == nullptr && dependent == nullptr)
-		return kResultFalse;
-
-	FGuard guard (lock);
-
-	Update::UpdateDataListIterConst iter = table->updateData.begin ();
-	while (iter != table->updateData.end ())
-	{
-		if ((*iter).obj == unknown || unknown == nullptr)
-		{
-			for (uint32 count = 0; count < (*iter).count; count++)
-			{
-				if ((*iter).dependents[count] == dependent)
-					(*iter).dependents[count] = nullptr;
-			}
-		}
-		++iter;
-	}
-	// Remove all objects for the given dependent
-	if (unknown == nullptr)
-	{
-		for (uint32 j = 0; j < Update::kHashSize; j++)
-		{
-			Update::DependentMap& map = table->depMap[j];
-			Update::DependentMapIter iterMap = map.begin ();
-			while (iterMap != map.end ())
-			{
-				Update::DependentList& list = (*iterMap).second;
-				Update::DependentListIter iterList = list.begin ();
-				bool listIsEmpty = false;
-				
-				while (iterList != list.end ())
-				{
-#if CLASS_NAME_TRACKED
-					if ((*iterList).dep == dependent)
-#else
-					if ((*iterList) == dependent)
-#endif
-					{
-						if (list.size () == 1u)
-						{
-							listIsEmpty = true;
-							break;
-						}
-						else
-							iterList = list.erase (iterList);
-					}
-					else
-					{
-						++iterList;
-					}
-				}
-				
-				if (listIsEmpty)
-					iterMap = map.erase (iterMap);
-				else
-					++iterMap;
-			}
-		}
-	}
-	else
-	{
-		bool mustFlush = true;
-
-		Update::DependentMap& map = table->depMap[Update::hashPointer (unknown)];
-		Update::DependentMapIter iterList = map.find (unknown);
-
-#if NON_EXISTING_DEPENDENCY_CHECK
-		SMTG_ASSERT (iterList != map.end () && "ERROR: Trying to remove a non existing dependency!")
-#endif
-		if (iterList != map.end ())
-		{
-			if (dependent == nullptr) // Remove all dependents of object
-			{
-				map.erase (iterList);
-			}
-			else // Remove one dependent
-			{
-				int32 eraseCount = 0;
-				Update::DependentList& dependentlist = (*iterList).second;
-				Update::DependentListIter iterDependentlist = dependentlist.begin ();
-				while (iterDependentlist != dependentlist.end ())
-				{
-#if CLASS_NAME_TRACKED
-					if ((*iterDependentlist).dep == dependent)
-#else
-					if ((*iterDependentlist) == dependent)
-#endif
-					{
-						iterDependentlist = dependentlist.erase (iterDependentlist);
-						eraseCount++;
-						if (dependentlist.empty ())
-						{
-							map.erase (iterList);
-							break;
-						}
-					}
-					else
-					{
-						++iterDependentlist;
-						mustFlush = false;
-					}
-				}
-			}
-		}
-		if (mustFlush)
-			cancelUpdates (unknown);
-	}
-
-	return kResultTrue;
-}
-
-//------------------------------------------------------------------------
-tresult UpdateHandler::doTriggerUpdates (FUnknown* u, int32 message, bool suppressUpdateDone)
-{
-	if (lockUpdates)
-		return kResultFalse;
-	IPtr<FUnknown> unknown = Update::getUnknownBase (u);
-	if (!unknown)
-		return kResultFalse;
-
-	// to avoid crashes due to stack overflow, we reduce the amount of memory reserved for the
-	// dependents
-	IDependent* smallDependents[Update::kMapSize / 10]; // 8kB for x64
-	IDependent** dependents = smallDependents;
-	int32 maxDependents = Update::kMapSize / 10;
-	int32 count = 0;
-
-	{
-		FGuard guard (lock); // scope for lock
-
-		Update::DependentMap& map = table->depMap[Update::hashPointer (unknown)];
-		Update::DependentMapIterConst iterList = map.find (unknown);
-		if (iterList != map.end ())
-		{
-			const Update::DependentList& dependentlist = (*iterList).second;
-			Update::DependentListIterConst iterDependentlist = dependentlist.begin ();
-			while (iterDependentlist != dependentlist.end ())
-			{
-#if CLASS_NAME_TRACKED
-				dependents[count] = (*iterDependentlist).dep;
-#else
-				dependents[count] = *iterDependentlist;
-#endif
-				count++;
-
-				if (count >= maxDependents)
-				{
-					if (dependents == smallDependents)
-					{
-						dependents = NEW IDependent*[Update::kMapSize];
-						memcpy (dependents, smallDependents, count * sizeof (dependents[0]));
-						maxDependents = Update::kMapSize;
-					}
-					else
-					{
-						SMTG_WARNING ("Dependency overflow")
-						break;
-					}
-				}
-				++iterDependentlist;
-			}
-		}
-
-		// push update data on the stack
-		if (count > 0)
-		{
-			Update::UpdateData data (unknown, dependents, count);
-			table->updateData.push_back (data);
-		}
-	} // end scope
-
-	int32 i = 0;
-	while (i < count)
-	{
-		if (dependents[i])
-			dependents[i]->update (unknown, message);
-		i++;
-	}
-
-	if (dependents != smallDependents)
-		delete[] dependents;
-
-	// remove update data from the stack
-	if (count > 0)
-	{
-		FGuard guard (lock);
-
-		table->updateData.pop_back ();
-	}
-
-	// send update done message
-	if (suppressUpdateDone == false)
-		Update::updateDone (unknown, message);
-
-	return count > 0 ? kResultTrue : kResultFalse; // Object was found and has been updated
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API UpdateHandler::triggerUpdates (FUnknown* u, int32 message)
-{
-	return doTriggerUpdates (u, message, false);
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API UpdateHandler::deferUpdates (FUnknown* u, int32 message)
-{
-	IPtr<FUnknown> unknown = Update::getUnknownBase (u);
-	if (!unknown)
-		return kResultFalse;
-
-	FGuard guard (lock);
-
-	Update::DependentMap& map = table->depMap[Update::hashPointer (unknown)];
-	Update::DependentMapIterConst iterList = map.find (unknown);
-
-	bool hasDependency = (iterList != map.end ());
-	if (hasDependency == false)
-	{
-		Update::updateDone (unknown, message);
-		return kResultTrue;
-	}
-
-	bool found = false;
-	Update::DeferedChangeListIterConst iter = table->defered.begin ();
-	while (iter != table->defered.end ())
-	{
-		if ((*iter).obj == unknown && (*iter).msg == message)
-		{
-			found = true;
-			break;
-		}
-		++iter;
-	}
-
-	if (!found)
-	{
-		Update::DeferedChange change (unknown, message);
-		table->defered.push_back (change);
-	}
-
-	return kResultTrue;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API UpdateHandler::triggerDeferedUpdates (FUnknown* unknown)
-{
-	Update::DeferedChangeList deferedAgain;
-	if (!unknown)
-	{
-		while (table->defered.empty () == false)
-		{
-			// Remove first from queue
-			lock.lock ();
-
-			FUnknown* obj = table->defered.front ().obj;
-			int32 msg = table->defered.front ().msg;
-			table->defered.pop_front ();
-
-			// check if this object is currently being updated. in this case, defer update again...
-			bool canSignal = true;
-			Update::UpdateDataListIterConst iter = table->updateData.begin ();
-			while (iter != table->updateData.end ())
-			{
-				if ((*iter).obj == obj)
-				{
-					canSignal = false;
-					break;
-				}
-				++iter;
-			}
-			lock.unlock ();
-
-			if (canSignal)
-			{
-				triggerUpdates (obj, msg);
-			}
-			else
-			{
-				Update::DeferedChange change (obj, msg);
-				deferedAgain.push_back (change);
-			}
-		}
-	}
-	else
-	{
-		IPtr<FUnknown> object = Update::getUnknownBase (unknown);
-		Update::DeferedChange tmp (object);
-
-		while (true)
-		{
-			lock.lock ();
-			Update::DeferedChangeListIter it =
-			    std::find (table->defered.begin (), table->defered.end (), tmp);
-			if (it == table->defered.end ())
-			{
-				lock.unlock ();
-				return kResultTrue;
-			}
-
-			if ((*it).obj != nullptr)
-			{
-				int32 msg = (*it).msg;
-				table->defered.erase (it);
-
-				// check if this object is currently being updated. in this case, defer update
-				// again...
-				bool canSignal = true;
-				Update::UpdateDataListIterConst iter = table->updateData.begin ();
-				while (iter != table->updateData.end ())
-				{
-					if ((*iter).obj == object)
-					{
-						canSignal = false;
-						break;
-					}
-					++iter;
-				}
-				lock.unlock ();
-
-				if (canSignal)
-				{
-					triggerUpdates (object, msg);
-				}
-				else
-				{
-					Update::DeferedChange change (object, msg);
-					deferedAgain.push_back (change);
-				}
-			}
-		}
-	}
-
-	if (deferedAgain.empty () == false)
-	{
-		FGuard guard (lock);
-
-		Update::DeferedChangeListIterConst iter = deferedAgain.begin ();
-		while (iter != deferedAgain.end ())
-		{
-			table->defered.push_back (*iter);
-			++iter;
-		}
-	}
-
-	return kResultTrue;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API UpdateHandler::cancelUpdates (FUnknown* u)
-{
-	IPtr<FUnknown> unknown = Update::getUnknownBase (u);
-	if (!unknown)
-		return kResultFalse;
-
-	FGuard guard (lock);
-
-	Update::DeferedChange change (unknown, 0);
-	while (true)
-	{
-		auto iter = std::find (table->defered.begin (), table->defered.end (), change);
-		if (iter != table->defered.end ())
-			table->defered.erase (iter);
-		else
-			break;
-	}
-
-	return kResultTrue;
-}
-
-//------------------------------------------------------------------------
-size_t UpdateHandler::countDependencies (FUnknown* object)
-{
-	FGuard guard (lock);
-	uint32 res = 0;
-
-	IPtr<FUnknown> unknown = Update::getUnknownBase (object);
-	if (unknown)
-	{
-		Update::DependentMap& map = table->depMap[Update::hashPointer (unknown)];
-		Update::DependentMapIter iterList = map.find (unknown);
-		if (iterList != map.end ())
-			return iterList->second.size ();
-	}
-	else
-	{
-		for (uint32 j = 0; j < Update::kHashSize; j++)
-		{
-			Update::DependentMap& map = table->depMap[j];
-			res += countEntries (map);
-		}
-	}
-	return res;
-}
-
-#if DEVELOPMENT
-//------------------------------------------------------------------------
-bool UpdateHandler::checkDeferred (FUnknown* object)
-{
-	IPtr<FUnknown> unknown = Update::getUnknownBase (object);
-
-	FGuard guard (lock);
-
-	Update::DeferedChange tmp (unknown);
-	Update::DeferedChangeListIterConst it =
-	    std::find (table->defered.begin (), table->defered.end (), tmp);
-	if (it != table->defered.end ())
-		return true;
-
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool UpdateHandler::hasDependencies (FUnknown* u)
-{
-	IPtr<FUnknown> unknown = Update::getUnknownBase (u);
-	if (!unknown)
-		return false;
-
-	FGuard guard (lock);
-
-	Update::DependentMap& map = table->depMap[Update::hashPointer (unknown)];
-	Update::DependentMapIterConst iterList = map.find (unknown);
-	bool hasDependency = (iterList != map.end ());
-
-	return hasDependency;
-}
-
-//------------------------------------------------------------------------
-void UpdateHandler::printForObject (FObject* obj) const
-{
-	IPtr<FUnknown> unknown = Update::getUnknownBase (obj);
-	if (!unknown)
-		return;
-
-	FUnknownPtr<IDependent> dep (obj);
-
-	bool header = false;
-
-	Update::DependentMap& map = table->depMap[Update::hashPointer (unknown)];
-	Update::DependentMapIterConst iterList = map.begin ();
-	while (iterList != map.end ())
-	{
-		const Update::DependentList& dependentlist = (*iterList).second;
-		Update::DependentListIterConst iterDependentlist = dependentlist.begin ();
-		while (iterDependentlist != dependentlist.end ())
-		{
-#if CLASS_NAME_TRACKED
-			if ((*iterList).first == unknown || (*iterDependentlist).dep == dep.getInterface ())
-			{
-				if (!header)
-				{
-					FDebugPrint ("Dependencies for object %8" FORMAT_INT64A " %s\n", (uint64)obj,
-					             obj->isA ());
-					header = true;
-				}
-				FDebugPrint ("%s %8" FORMAT_INT64A "\n <- %s %8" FORMAT_INT64A "\n",
-				             (*iterDependentlist).depClass, (uint64) (*iterDependentlist).dep,
-				             (*iterDependentlist).objClass, (uint64) ((*iterList).first));
-			}
-#else
-			if ((*iterList).first == unknown || (*iterDependentlist) == dep.getInterface ())
-			{
-				if (!header)
-				{
-					FDebugPrint ("Dependencies for object %8" FORMAT_INT64A " %s\n", (uint64)obj,
-					             obj->isA ());
-					header = true;
-				}
-				FDebugPrint ("%8" FORMAT_INT64A "\n <- %8" FORMAT_INT64A "\n",
-				             (uint64) (*iterDependentlist), (uint64) ((*iterList).first));
-			}
-#endif
-			++iterDependentlist;
-		}
-
-		++iterList;
-	}
-}
-#endif
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/base/source/updatehandler.h

@@ -1,139 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/source/updatehandler.h
-// Created by  : Steinberg, 2008
-// Description :
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "base/source/fobject.h"
-#include "base/thread/include/flock.h"
-#include "pluginterfaces/base/iupdatehandler.h"
-
-namespace Steinberg {
-
-/// @cond ignore
-namespace Update { struct Table; }
-/// @endcond
-
-//------------------------------------------------------------------------
-/** Handle Send and Cancel pending message for a given object*/
-//------------------------------------------------------------------------
-class IUpdateManager : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** cancel pending messages send by \param object or by any if object is 0 */
-	virtual tresult PLUGIN_API cancelUpdates (FUnknown* object) = 0;
-	/** send pending messages send by \param object or by any if object is 0 */
-	virtual tresult PLUGIN_API triggerDeferedUpdates (FUnknown* object = nullptr) = 0;
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IUpdateManager, 0x030B780C, 0xD6E6418D, 0x8CE00BC2, 0x09C834D4)
-
-//------------------------------------------------------------------------------
-/**
-UpdateHandler implements IUpdateManager and IUpdateHandler to handle dependencies
-between objects to store and forward messages to dependent objects.
-
-This implementation is thread save, so objects can send message, add or remove
-dependents from different threads.
-Do do so it uses mutex, so be aware of locking.
-*/
-//------------------------------------------------------------------------------
-class UpdateHandler : public FObject, public IUpdateHandler, public IUpdateManager
-{
-public:
-//------------------------------------------------------------------------------
-	UpdateHandler ();
-	~UpdateHandler ();
-
-	using FObject::addDependent;
-	using FObject::removeDependent;
-	using FObject::deferUpdate;
-
-	// IUpdateHandler
-	/** register \param dependent to get messages from \param object */
-	tresult PLUGIN_API addDependent (FUnknown* object, IDependent* dependent) SMTG_OVERRIDE;
-	/** unregister \param dependent to get no messages from \param object */
-	tresult PLUGIN_API removeDependent (FUnknown* object,
-	                                            IDependent* dependent) SMTG_OVERRIDE;
-	/** send \param message to all dependents of \param object immediately */
-	tresult PLUGIN_API triggerUpdates (FUnknown* object, int32 message) SMTG_OVERRIDE;
-	/** send \param message to all dependents of \param object when idle */
-	tresult PLUGIN_API deferUpdates (FUnknown* object, int32 message) SMTG_OVERRIDE;
-
-	// IUpdateManager
-	/** cancel pending messages send by \param object or by any if object is 0 */
-	tresult PLUGIN_API cancelUpdates (FUnknown* object) SMTG_OVERRIDE;
-	/** send pending messages send by \param object or by any if object is 0 */
-	tresult PLUGIN_API triggerDeferedUpdates (FUnknown* object = nullptr) SMTG_OVERRIDE;
-
-	/// @cond ignore
-	// obsolete functions kept for compatibility
-	void checkUpdates (FObject* object = nullptr) { triggerDeferedUpdates (object->unknownCast ()); }
-	void flushUpdates (FObject* object) { cancelUpdates (object->unknownCast ()); }
-	void deferUpdate (FObject* object, int32 message)
-	{
-		deferUpdates (object->unknownCast (), message);
-	}
-	void signalChange (FObject* object, int32 message, bool suppressUpdateDone = false)
-	{
-		doTriggerUpdates (object->unknownCast (), message, suppressUpdateDone);
-	}
-#if DEVELOPMENT
-	bool checkDeferred (FUnknown* object);
-	bool hasDependencies (FUnknown* object);
-	void printForObject (FObject* object) const;
-#endif
-	/// @endcond
-	size_t countDependencies (FUnknown* object = nullptr);
-	
-	OBJ_METHODS (UpdateHandler, FObject)
-	FUNKNOWN_METHODS2 (IUpdateHandler, IUpdateManager, FObject)
-	SINGLETON (UpdateHandler)
-//------------------------------------------------------------------------------
-private:
-	tresult doTriggerUpdates (FUnknown* object, int32 message, bool suppressUpdateDone);
-
-	Steinberg::Base::Thread::FLock lock;
-	Update::Table* table = nullptr;
-	friend struct LockUpdateDependencies;
-	static bool lockUpdates;
-};
-
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/base/thread/include/flock.h

@@ -1,183 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/thread/include/flock.h
-// Created by  : Steinberg, 1995
-// Description : locks
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------------
-/** @file base/thread/include/flock.h
-    Locks. */
-/** @defgroup baseLocks Locks */
-//----------------------------------------------------------------------------------
-#pragma once
-
-#include "base/source/fobject.h"
-#include "pluginterfaces/base/ftypes.h"
-
-#if SMTG_PTHREADS
-#include <pthread.h>
-
-#elif SMTG_OS_WINDOWS
-struct CRITSECT							// CRITICAL_SECTION
-{
-	void* DebugInfo;					// PRTL_CRITICAL_SECTION_DEBUG DebugInfo;
-	Steinberg::int32 LockCount;			// LONG LockCount;
-	Steinberg::int32 RecursionCount;	// LONG RecursionCount;
-	void* OwningThread;					// HANDLE OwningThread
-	void* LockSemaphore;				// HANDLE LockSemaphore
-	Steinberg::int32 SpinCount;			// ULONG_PTR SpinCount
-};
-#endif
-
-namespace Steinberg {
-namespace Base {
-namespace Thread {
-
-//------------------------------------------------------------------------
-/** Lock interface declaration.
-@ingroup baseLocks	*/
-//------------------------------------------------------------------------
-struct ILock
-{
-//------------------------------------------------------------------------
-	virtual ~ILock () {}
-
-	/** Enables lock. */
-	virtual void lock () = 0;
-
-	/** Disables lock. */
-	virtual void unlock () = 0;
-
-	/** Tries to disable lock. */
-	virtual bool trylock () = 0;
-//------------------------------------------------------------------------
-};
-
-//------------------------------------------------------------------------
-/**	FLock declaration.
-@ingroup baseLocks	*/
-//------------------------------------------------------------------------
-class FLock : public ILock
-{
-public:
-//------------------------------------------------------------------------
-
-	/** Lock constructor.
-	 *  @param name lock name
-	 */
-	FLock (const char8* name = "FLock");
-
-	/** Lock destructor. */
-	~FLock ();
-
-	//-- ILock -----------------------------------------------------------
-	void lock () SMTG_OVERRIDE;
-	void unlock () SMTG_OVERRIDE;
-	bool trylock () SMTG_OVERRIDE;
-
-//------------------------------------------------------------------------
-protected:
-#if SMTG_PTHREADS
-	pthread_mutex_t mutex; ///< Mutex object
-
-#elif SMTG_OS_WINDOWS
-	CRITSECT section; ///< Critical section object
-#endif
-};
-
-//------------------------------------------------------------------------
-/**	FLockObj declaration. Reference counted lock
-@ingroup baseLocks	*/
-//------------------------------------------------------------------------
-class FLockObject : public FObject, public FLock
-{
-public:
-	OBJ_METHODS (FLockObject, FObject)
-};
-
-//------------------------------------------------------------------------
-/**	FGuard - automatic object for locks.
-@ingroup baseLocks	*/
-//------------------------------------------------------------------------
-class FGuard
-{
-public:
-//------------------------------------------------------------------------
-
-	/** FGuard constructor.
-	 *  @param _lock guard this lock
-	 */
-	FGuard (ILock& _lock) : lock (_lock) { lock.lock (); }
-
-	/** FGuard destructor. */
-	~FGuard () { lock.unlock (); }
-
-//------------------------------------------------------------------------
-private:
-	ILock& lock; ///< guarded lock
-};
-
-//------------------------------------------------------------------------
-/**	Conditional Guard - Locks only if valid lock is passed.
-@ingroup baseLocks	*/
-//------------------------------------------------------------------------
-class FConditionalGuard
-{
-public:
-//------------------------------------------------------------------------
-
-	/** FConditionGuard constructor.
-	 *  @param _lock guard this lock
-	 */
-	FConditionalGuard (FLock* _lock) : lock (_lock)
-	{
-		if (lock)
-			lock->lock ();
-	}
-
-	/** FConditionGuard destructor. */
-	~FConditionalGuard ()
-	{
-		if (lock)
-			lock->unlock ();
-	}
-
-//------------------------------------------------------------------------
-private:
-	FLock* lock; ///< guarded lock
-};
-
-} // Thread
-} // Base
-} // Steinberg

source/includes/vst3sdk/base/thread/source/flock.cpp

@@ -1,146 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : SDK Base
-// Version     : 1.0
-//
-// Category    : Helpers
-// Filename    : base/thread/source/flock.cpp
-// Created by  : Steinberg, 1995
-// Description : Locks
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#define DEBUG_LOCK 0
-
-#include "base/thread/include/flock.h"
-#include "base/source/fdebug.h"
-
-//------------------------------------------------------------------------
-#if SMTG_OS_WINDOWS
-//------------------------------------------------------------------------
-#ifndef WINVER
-#define WINVER 0x0500
-#endif
-#ifndef _WIN32_WINNT
-#define _WIN32_WINNT WINVER
-#endif
-
-#include <windows.h>
-#include <objbase.h>
-#define INIT_CS(cs) \
-	InitializeCriticalSection ((LPCRITICAL_SECTION)&cs);
-
-#endif // SMTG_OS_WINDOWS
-
-namespace Steinberg {
-namespace Base {
-namespace Thread {
-
-
-//------------------------------------------------------------------------
-//	FLock implementation
-//------------------------------------------------------------------------
-FLock::FLock (const char8* /*name*/)
-{
-#if SMTG_PTHREADS
-	pthread_mutexattr_t mutexAttr;
-	pthread_mutexattr_init (&mutexAttr);
-	pthread_mutexattr_settype (&mutexAttr, PTHREAD_MUTEX_RECURSIVE);
-	if (pthread_mutex_init (&mutex, &mutexAttr) != 0)
-		{SMTG_WARNING("mutex_init failed")}
-	pthread_mutexattr_destroy (&mutexAttr);
-
-#elif SMTG_OS_WINDOWS
-	INIT_CS (section)
-#else
-#warning implement FLock!
-#endif
-}
-
-//------------------------------------------------------------------------
-FLock::~FLock ()
-{
-#if SMTG_PTHREADS
-	pthread_mutex_destroy (&mutex);
-
-#elif SMTG_OS_WINDOWS
-	DeleteCriticalSection ((LPCRITICAL_SECTION)&section);
-		
-#endif
-}
-
-//------------------------------------------------------------------------
-void FLock::lock ()
-{
-#if DEBUG_LOCK
-	FDebugPrint ("FLock::lock () %x\n", this);
-#endif
-
-#if SMTG_PTHREADS
-	pthread_mutex_lock (&mutex);
-
-#elif SMTG_OS_WINDOWS
-	EnterCriticalSection ((LPCRITICAL_SECTION)&section);
-
-#endif
-}
-
-//------------------------------------------------------------------------
-void FLock::unlock ()
-{
-#if DEBUG_LOCK
-	FDebugPrint ("FLock::unlock () %x\n", this);
-#endif
-	
-#if SMTG_PTHREADS
-	pthread_mutex_unlock (&mutex);
-
-#elif SMTG_OS_WINDOWS
-	LeaveCriticalSection ((LPCRITICAL_SECTION)&section);
-
-#endif 
-}
-
-//------------------------------------------------------------------------
-bool FLock::trylock ()
-{
-#if SMTG_PTHREADS
-	return pthread_mutex_trylock (&mutex) == 0;
-
-#elif SMTG_OS_WINDOWS
-	return TryEnterCriticalSection ((LPCRITICAL_SECTION)&section) != 0 ? true : false;
-
-#else
-	return false;
-#endif 
-}
-
-} // Thread
-} // Base
-} // Steinberg
-

source/includes/vst3sdk/pluginterfaces/LICENSE.txt

@@ -1,41 +0,0 @@
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-This license applies only to files referencing this license,
-for other files of the Software Development Kit the respective embedded license text
-is applicable. The license can be found at: www.steinberg.net/sdklicenses_vst3
-
-This Software Development Kit is licensed under the terms of the Steinberg VST3 License,
-or alternatively under the terms of the General Public License (GPL) Version 3.
-You may use the Software Development Kit according to either of these licenses as it is
-most appropriate for your project on a case-by-case basis (commercial or not).
-
-a) Proprietary Steinberg VST3 License
-The Software Development Kit may not be distributed in parts or its entirety
-without prior written agreement by Steinberg Media Technologies GmbH.
-The SDK must not be used to re-engineer or manipulate any technology used
-in any Steinberg or Third-party application or software module,
-unless permitted by law.
-Neither the name of the Steinberg Media Technologies GmbH nor the names of its
-contributors may be used to endorse or promote products derived from this
-software without specific prior written permission.
-Before publishing a software under the proprietary license, you need to obtain a copy
-of the License Agreement signed by Steinberg Media Technologies GmbH.
-The Steinberg VST SDK License Agreement can be found at:
-www.steinberg.net/en/company/developers.html
-
-THE SDK IS PROVIDED BY STEINBERG MEDIA TECHNOLOGIES GMBH "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-IN NO EVENT SHALL STEINBERG MEDIA TECHNOLOGIES GMBH BE LIABLE FOR ANY DIRECT,
-INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
-OF THE POSSIBILITY OF SUCH DAMAGE.
-
-b) General Public License (GPL) Version 3
-Details of these licenses can be found at: www.gnu.org/licenses/gpl-3.0.html
-//----------------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/README.md

@@ -1,10 +0,0 @@
-# Welcome to VST 3 SDK Interfaces
-
-Here are located all VST interfaces definitions (including VST Component/Controller, UI, Test).
-
-## License & Usage guidelines
-
-More details are found at [www.steinberg.net/sdklicenses_vst3](http://www.steinberg.net/sdklicenses_vst3)
-
-----
-Return to [VST 3 SDK](https://github.com/steinbergmedia/vst3sdk)

source/includes/vst3sdk/pluginterfaces/base/conststringtable.cpp

@@ -1,106 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/conststringtable.cpp
-// Created by  : Steinberg, 09/2007
-// Description : constant unicode string table
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#include "conststringtable.h"
-#include <cstring>
-#include <map>
-
-namespace Steinberg {
-
-static std::map<const char8*, char16*>* stringMap;
-static std::map<const char8, char16>* charMap;
-
-static char16* generateUTF16 (const char8* str);
-
-//----------------------------------------------------------------------------
-ConstStringTable* ConstStringTable::instance ()
-{
-	static ConstStringTable stringTable;
-	return &stringTable;
-}
-
-//----------------------------------------------------------------------------
-const char16* ConstStringTable::getString (const char8* str) const
-{
-	std::map<const char8*, char16*>::iterator iter = stringMap->find (str);
-	if (iter != stringMap->end ())
-		return iter->second;
-	char16* uStr = generateUTF16 (str);
-	stringMap->insert (std::make_pair (str, uStr));
-	return uStr;
-}
-
-//----------------------------------------------------------------------------
-const char16 ConstStringTable::getString (const char8 str) const
-{
-	std::map<const char8, char16>::iterator iter = charMap->find (str);
-	if (iter != charMap->end ())
-		return iter->second;
-	char16 uStr = 0;
-#if BYTEORDER == kBigEndian
-	char8* puStr = (char8*)&uStr;
-	puStr[1] = str;
-#else
-	uStr = str;
-#endif
-	charMap->insert (std::make_pair (str, uStr));
-	return uStr;
-}
-
-//----------------------------------------------------------------------------
-ConstStringTable::ConstStringTable ()
-{
-	stringMap = new std::map<const char8*, char16*>;
-	charMap = new std::map<const char8, char16>;
-}
-
-//----------------------------------------------------------------------------
-ConstStringTable::~ConstStringTable ()
-{
-	// free out allocated strings
-	{
-		std::map<const char8*, char16*>::iterator iter = stringMap->begin ();
-		while (iter != stringMap->end ())
-		{
-			delete[] iter->second;
-			iter++;
-		}
-	} // delete iterator on map before deleting the map
-
-	delete stringMap;
-	delete charMap;
-}
-
-//----------------------------------------------------------------------------
-char16* generateUTF16 (const char8* str)
-{
-	int32 len = (int32)strlen (str);
-	char16* result = new char16[len + 1];
-	for (int32 i = 0; i < len; i++)
-	{
-#if BYTEORDER == kBigEndian
-		char8* pChr = (char8*)&result[i];
-		pChr[0] = 0;
-		pChr[1] = str[i];
-#else
-		result[i] = str[i];
-#endif
-	}
-	result[len] = 0;
-	return result;
-}
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/base/conststringtable.h

@@ -1,44 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/conststringtable.h
-// Created by  : Steinberg, 09/2007
-// Description : constant unicode string table
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "ftypes.h"
-
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-/**	Constant unicode string table.
-Used for conversion from ASCII string literals to char16.
-*/
-class ConstStringTable
-{
-public:
-	static ConstStringTable* instance ();
-
-	/** Returns a char16 string of a ASCII string literal*/
-	const char16* getString (const char8* str) const;
-	/** Returns a char16 character of a ASCII character */
-	const char16 getString (const char8 str) const;
-
-protected:
-	ConstStringTable ();
-	~ConstStringTable ();
-};
-
-//------------------------------------------------------------------------
-} // namespace Steinberg
-

source/includes/vst3sdk/pluginterfaces/base/coreiids.cpp

@@ -1,40 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interface IID definitions
-// Filename    : pluginterfaces/base/coreiids.cpp
-// Created by  : Steinberg, 01/2004
-// Description : Basic Interface
-//
-//------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution.
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//------------------------------------------------------------------------
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/base/ibstream.h"
-#include "pluginterfaces/base/icloneable.h"
-#include "pluginterfaces/base/ipluginbase.h"
-#include "pluginterfaces/base/iupdatehandler.h"
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-DEF_CLASS_IID (IPluginBase)
-DEF_CLASS_IID (IPluginFactory)
-DEF_CLASS_IID (IPluginFactory2)
-DEF_CLASS_IID (IPluginFactory3)
-
-DEF_CLASS_IID (FUnknown)
-
-DEF_CLASS_IID (ICloneable)
-
-DEF_CLASS_IID (IDependent)
-DEF_CLASS_IID (IUpdateHandler)
-
-DEF_CLASS_IID (IBStream)
-DEF_CLASS_IID (ISizeableStream)
-
-//------------------------------------------------------------------------
-} // Steinberg

source/includes/vst3sdk/pluginterfaces/base/falignpop.h

@@ -1,25 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/falignpop.h
-// Created by  : Steinberg, 01/2004
-// Description : Restore alignment settings
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-//---------------------------------------------------------------------------------------------------
-#if SMTG_OS_MACOS
-	#pragma pack(pop)
-#elif defined __BORLANDC__
-	#pragma -a-
-#elif SMTG_OS_WINDOWS
-	#pragma pack(pop)
-#endif
-//---------------------------------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/base/falignpush.h

@@ -1,36 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/falignpush.h
-// Created by  : Steinberg, 01/2004
-// Description : Set alignment settings
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------------------------
-#if SMTG_OS_MACOS
-	#pragma GCC diagnostic ignored "-Wunknown-warning-option"
-	#pragma GCC diagnostic ignored "-Wpragma-pack"
-	#if SMTG_PLATFORM_64
-		#pragma pack(push, 16)
-	#else
-		#pragma pack(push, 1)
-	#endif
-#elif defined __BORLANDC__
-	#pragma -a8
-#elif SMTG_OS_WINDOWS
-	#pragma pack(push)
-	#if SMTG_PLATFORM_64
-		#pragma pack(16)
-	#else
-		#pragma pack(8)
-	#endif
-#endif
-//----------------------------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/base/fplatform.h

@@ -1,258 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/fplatform.h
-// Created by  : Steinberg, 01/2004
-// Description : Detect platform and set define
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#define kLittleEndian	0
-#define kBigEndian		1
-
-#undef PLUGIN_API
-
-#if !defined (__INTEL_CXX11_MODE__)
-#define SMTG_INTEL_CXX11_MODE 0
-#else
-#define SMTG_INTEL_CXX11_MODE __INTEL_CXX11_MODE__
-#endif
-
-#if !defined (__INTEL_COMPILER)
-#define SMTG_INTEL_COMPILER 0
-#else
-#define SMTG_INTEL_COMPILER __INTEL_COMPILER
-#endif
-
-//-----------------------------------------------------------------------------
-// WIN32 AND WIN64 (WINDOWS)
-//-----------------------------------------------------------------------------
-#if defined (_WIN32)
-	//-----------------------------------------------------------------------------
-	// ARM32 AND ARM64 (WINDOWS)
-	#if (defined(_M_ARM64) || defined(_M_ARM))
-		#define SMTG_OS_WINDOWS_ARM	1
-	#endif
-
-	#define SMTG_OS_LINUX	0
-	#define SMTG_OS_MACOS	0
-	#define SMTG_OS_WINDOWS	1
-	#define SMTG_OS_IOS		0
-	#define SMTG_OS_OSX		0
-
-	#define SMTG_CPU_X86	_M_IX86
-	#define SMTG_CPU_X86_64	_M_AMD64
-	#define SMTG_CPU_ARM	(_M_ARM && !_M_ARM64)
-	#define SMTG_CPU_ARM_64	_M_ARM64
-
-	#define BYTEORDER kLittleEndian
-	
-	#define COM_COMPATIBLE	1
-	#define PLUGIN_API __stdcall
-	#define SMTG_PTHREADS	0
-
-	#define SMTG_EXPORT_SYMBOL __declspec (dllexport)
-
-	#ifndef _CRT_SECURE_NO_WARNINGS
-		#define _CRT_SECURE_NO_WARNINGS
-	#endif
-
-	#ifdef _MSC_VER
-		#pragma warning (disable : 4244) // Conversion from 'type1' to 'type2', possible loss of data.
-		#pragma warning (disable : 4250) // Inheritance via dominance is allowed
-		#pragma warning (disable : 4996) // deprecated functions
-
-		#pragma warning (3 : 4189) // local variable is initialized but not referenced
-		#pragma warning (3 : 4238) // nonstandard extension used : class rvalue used as lvalue
-	#endif
-
-	#if defined (_WIN64) || defined (_M_ARM64)
-		#define SMTG_PLATFORM_64 1
-	#else
-		#define SMTG_PLATFORM_64 0
-	#endif
-
-	#ifndef WIN32
-		#define WIN32	1
-	#endif
-
-	#ifdef __cplusplus
-		#define SMTG_CPP11	__cplusplus >= 201103L || _MSC_VER > 1600 || SMTG_INTEL_CXX11_MODE
-		#define SMTG_CPP11_STDLIBSUPPORT SMTG_CPP11
-		#define SMTG_HAS_NOEXCEPT _MSC_VER >= 1900 || (SMTG_INTEL_CXX11_MODE && SMTG_INTEL_COMPILER >= 1300)
-	#endif
-
-	#define SMTG_DEPRECATED_ATTRIBUTE(message) __declspec (deprecated ("Is Deprecated: " message))
-//-----------------------------------------------------------------------------
-// LINUX
-//-----------------------------------------------------------------------------
-#elif __gnu_linux__ || __linux__
-	#define SMTG_OS_LINUX	1
-	#define SMTG_OS_MACOS	0
-	#define SMTG_OS_WINDOWS	0
-	#define SMTG_OS_IOS		0
-	#define SMTG_OS_OSX		0
-
-	#define SMTG_CPU_X86	__i386__
-	#define SMTG_CPU_X86_64	__x86_64__
-	#define SMTG_CPU_ARM	__arm__
-	#define SMTG_CPU_ARM_64	__aarch64__
-
-	#include <endian.h>
-	#if __BYTE_ORDER == __LITTLE_ENDIAN
-		#define BYTEORDER kLittleEndian
-	#else
-		#define BYTEORDER kBigEndian
-	#endif
-
-	#define COM_COMPATIBLE	0
-	#define PLUGIN_API
-	#define SMTG_PTHREADS	1
-
-	#define SMTG_EXPORT_SYMBOL __attribute__ ((visibility ("default")))
-
-	#if __LP64__
-		#define SMTG_PLATFORM_64 1
-	#else
-		#define SMTG_PLATFORM_64 0
-	#endif
-	#ifdef __cplusplus
-		#include <cstddef>
-		#define SMTG_CPP11 (__cplusplus >= 201103L)
-		#ifndef SMTG_CPP11
-			#error unsupported compiler
-		#endif
-		#if defined(__GNUG__) && __GNUG__ < 8
-			#define SMTG_CPP11_STDLIBSUPPORT 0
-		#else
-			#define SMTG_CPP11_STDLIBSUPPORT 1
-		#endif
-		#define SMTG_HAS_NOEXCEPT 1
-	#endif
-//-----------------------------------------------------------------------------
-// Mac and iOS
-//-----------------------------------------------------------------------------
-#elif __APPLE__
-	#include <TargetConditionals.h>
-	#define SMTG_OS_LINUX	0
-	#define SMTG_OS_MACOS	1
-	#define SMTG_OS_WINDOWS	0
-	#define SMTG_OS_IOS		TARGET_OS_IPHONE
-	#define SMTG_OS_OSX		TARGET_OS_MAC && !TARGET_OS_IPHONE
-
-	#define SMTG_CPU_X86	TARGET_CPU_X86
-	#define SMTG_CPU_X86_64	TARGET_CPU_X86_64
-	#define SMTG_CPU_ARM	TARGET_CPU_ARM
-	#define SMTG_CPU_ARM_64	TARGET_CPU_ARM64
-
-	#if !SMTG_OS_IOS
-		#ifndef __CF_USE_FRAMEWORK_INCLUDES__
-			#define __CF_USE_FRAMEWORK_INCLUDES__
-		#endif
-		#ifndef TARGET_API_MAC_CARBON
-			#define TARGET_API_MAC_CARBON 1
-		#endif
-	#endif
-	#if __LP64__
-		#define SMTG_PLATFORM_64 1
-	#else
-		#define SMTG_PLATFORM_64 0
-	#endif
-	#if defined (__BIG_ENDIAN__)
-		#define BYTEORDER kBigEndian
-	#else
-		#define BYTEORDER kLittleEndian
-	#endif
-
-	#define COM_COMPATIBLE	0
-	#define PLUGIN_API
-	#define SMTG_PTHREADS	1
-
-	#define SMTG_EXPORT_SYMBOL __attribute__ ((visibility ("default")))
-
-	#if !defined(__PLIST__) && !defined(SMTG_DISABLE_DEFAULT_DIAGNOSTICS)
-		#ifdef __clang__
-			#pragma GCC diagnostic ignored "-Wswitch-enum"
-			#pragma GCC diagnostic ignored "-Wparentheses"
-			#pragma GCC diagnostic ignored "-Wuninitialized"
-			#if __clang_major__ >= 3
-				#pragma GCC diagnostic ignored "-Wtautological-compare"
-				#pragma GCC diagnostic ignored "-Wunused-value"
-				#if __clang_major__ >= 4 || __clang_minor__ >= 1
-					#pragma GCC diagnostic ignored "-Wswitch"
-					#pragma GCC diagnostic ignored "-Wcomment"
-				#endif
-				#if __clang_major__ >= 5
-					#pragma GCC diagnostic ignored "-Wunsequenced"
-					#if __clang_minor__ >= 1
-						#pragma GCC diagnostic ignored "-Wunused-const-variable"
-					#endif
-				#endif
-			#endif
-		#endif
-	#endif
-	#ifdef __cplusplus
-		#include <cstddef>
-		#define SMTG_CPP11 (__cplusplus >= 201103L || SMTG_INTEL_CXX11_MODE)
-		#if defined (_LIBCPP_VERSION) && SMTG_CPP11
-			#define SMTG_CPP11_STDLIBSUPPORT 1
-			#define SMTG_HAS_NOEXCEPT 1
-		#else
-			#define SMTG_CPP11_STDLIBSUPPORT 0
-			#define SMTG_HAS_NOEXCEPT 0
-		#endif
-	#endif
-#else
-	#pragma error unknown platform
-#endif
-
-//-----------------------------------------------------------------------------
-#if !SMTG_RENAME_ASSERT
-#undef WINDOWS
-#undef MAC
-#undef PTHREADS
-#undef PLATFORM_64
-
-#if SMTG_OS_WINDOWS
-#define WINDOWS			SMTG_OS_WINDOWS
-#endif
-#if SMTG_OS_MACOS
-#define MAC				SMTG_OS_MACOS
-#endif
-#define PLATFORM_64		SMTG_PLATFORM_64
-#define PTHREADS		SMTG_PTHREADS
-#endif
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-#if SMTG_CPP11
-#define SMTG_OVERRIDE override
-#define SMTG_CONSTEXPR constexpr
-#else
-#define SMTG_OVERRIDE
-#define SMTG_CONSTEXPR
-#endif
-#if SMTG_HAS_NOEXCEPT
-#define SMTG_NOEXCEPT noexcept
-#else
-#define SMTG_NOEXCEPT
-#endif
-
-//-----------------------------------------------------------------------------
-// Deprecation setting
-//-----------------------------------------------------------------------------
-#ifndef SMTG_DEPRECATED_ATTRIBUTE
-#define SMTG_DEPRECATED_ATTRIBUTE(msg)
-#endif
-
-#define SMTG_DEPRECATED_MSG(msg) SMTG_DEPRECATED_ATTRIBUTE(msg)
-//-----------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/base/fstrdefs.h

@@ -1,289 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/fstrdefs.h
-// Created by  : Steinberg, 01/2004
-// Description : Definitions for handling strings (Unicode / ASCII / Platforms)
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "ftypes.h"
-
-//----------------------------------------------------------------------------
-/** string methods defines unicode / ASCII */
-//----------------------------------------------------------------------------
-
-// 16 bit string operations
-#if SMTG_CPP11	// if c++11 unicode string literals
-	#define SMTG_CPP11_CAT_PRIVATE_DONT_USE(a,b)			a ## b
-	#if SMTG_OS_WINDOWS
-		#define STR16(x) SMTG_CPP11_CAT_PRIVATE_DONT_USE(L,x)
-	#else
-		#define STR16(x) SMTG_CPP11_CAT_PRIVATE_DONT_USE(u,x)
-	#endif
-#else
-	#include "conststringtable.h"
-	#define STR16(x) Steinberg::ConstStringTable::instance ()->getString (x)
-#endif
-
-#ifdef UNICODE
-	#define STR(x) STR16(x)
-	#define tStrBufferSize(buffer) (sizeof(buffer)/sizeof(Steinberg::tchar))
-
-#else
-	#define STR(x) x
-	#define tStrBufferSize(buffer) (sizeof(buffer))
-#endif
-
-#define str8BufferSize(buffer) (sizeof(buffer)/sizeof(Steinberg::char8))
-#define str16BufferSize(buffer) (sizeof(buffer)/sizeof(Steinberg::char16))
-
-#if SMTG_OS_WINDOWS
-#define FORMAT_INT64A "I64d"
-#define FORMAT_UINT64A "I64u"
-
-#elif SMTG_OS_MACOS || SMTG_OS_LINUX
-#define FORMAT_INT64A  "lld"
-#define FORMAT_UINT64A "llu"
-#define stricmp		strcasecmp
-#define strnicmp	strncasecmp
-#endif
-
-#ifdef UNICODE
-#define FORMAT_INT64W STR(FORMAT_INT64A)
-#define FORMAT_UINT64W STR(FORMAT_UINT64A)
-
-#define FORMAT_INT64 FORMAT_INT64W
-#define FORMAT_UINT64 FORMAT_UINT64W
-#else
-#define FORMAT_INT64 FORMAT_INT64A
-#define FORMAT_UINT64 FORMAT_UINT64A
-#endif
-
-
-//----------------------------------------------------------------------------
-// newline
-//----------------------------------------------------------------------------
-#if SMTG_OS_WINDOWS
-#define ENDLINE_A   "\r\n"
-#define ENDLINE_W   STR ("\r\n")
-#elif SMTG_OS_MACOS
-#define ENDLINE_A   "\r"
-#define ENDLINE_W   STR ("\r")
-#elif SMTG_OS_LINUX
-#define ENDLINE_A   "\n"
-#define ENDLINE_W   STR ("\n")
-#endif
-
-#ifdef UNICODE
-#define ENDLINE ENDLINE_W
-#else
-#define ENDLINE ENDLINE_A
-#endif
-
-#if SMTG_OS_WINDOWS && !defined(__GNUC__) && defined(_MSC_VER) && (_MSC_VER < 1900)
-#define stricmp _stricmp
-#define strnicmp _strnicmp
-#define snprintf _snprintf
-#endif
-
-namespace Steinberg {
-
-//----------------------------------------------------------------------------
-static const tchar kEmptyString[] = { 0 };
-static const char8 kEmptyString8[] = { 0 };
-static const char16 kEmptyString16[] = { 0 };
-
-#ifdef UNICODE
-static const tchar kInfiniteSymbol[] = { 0x221E, 0 };
-#else
-static const tchar* const kInfiniteSymbol = STR ("oo");
-#endif
-
-//----------------------------------------------------------------------------
-template <class T>
-inline int32 _tstrlen (const T* wcs)
-{
-	const T* eos = wcs;
-
-	while (*eos++)
-		;
-
-	return (int32) (eos - wcs - 1);
-}
-
-inline int32 tstrlen (const tchar* str) {return _tstrlen (str);}
-inline int32 strlen8 (const char8* str) {return _tstrlen (str);}
-inline int32 strlen16 (const char16* str) {return _tstrlen (str);}
-
-//----------------------------------------------------------------------------
-template <class T>
-inline int32 _tstrcmp (const T* src, const T* dst)
-{
-	while (*src == *dst && *dst)
-	{
-		src++;
-		dst++;
-	}
-
-	if (*src == 0 && *dst == 0)
-		return 0;
-	else if (*src == 0)
-		return -1;
-	else if (*dst == 0)
-		return 1;
-	else
-		return (int32) (*src - *dst);
-}
-
-inline int32 tstrcmp (const tchar* src, const tchar* dst) {return _tstrcmp (src, dst);}
-inline int32 strcmp8 (const char8* src, const char8* dst) {return _tstrcmp (src, dst);}
-inline int32 strcmp16 (const char16* src, const char16* dst) {return _tstrcmp (src, dst);}
-
-template <typename T>
-inline int32 strcmpT (const T* first, const T* last);
-
-template <>
-inline int32 strcmpT<char8> (const char8* first, const char8* last) { return _tstrcmp (first, last); }
-
-template <>
-inline int32 strcmpT<char16> (const char16* first, const char16* last) { return _tstrcmp (first, last); }
-
-//----------------------------------------------------------------------------
-template <class T>
-inline int32 _tstrncmp (const T* first, const T* last, uint32 count)
-{
-	if (count == 0)
-		return 0;
-
-	while (--count && *first && *first == *last)
-	{
-		first++;
-		last++;
-	}
-
-	if (*first == 0 && *last == 0)
-		return 0;
-	else if (*first == 0)
-		return -1;
-	else if (*last == 0)
-		return 1;
-	else
-		return (int32) (*first - *last);
-}
-
-inline int32 tstrncmp (const tchar* first, const tchar* last, uint32 count) {return _tstrncmp (first, last, count);}
-inline int32 strncmp8 (const char8* first, const char8* last, uint32 count) {return _tstrncmp (first, last, count);}
-inline int32 strncmp16 (const char16* first, const char16* last, uint32 count) {return _tstrncmp (first, last, count);}
-
-template <typename T>
-inline int32 strncmpT (const T* first, const T* last, uint32 count);
-
-template <>
-inline int32 strncmpT<char8> (const char8* first, const char8* last, uint32 count) { return _tstrncmp (first, last, count); }
-
-template <>
-inline int32 strncmpT<char16> (const char16* first, const char16* last, uint32 count) {return _tstrncmp (first, last, count); }
-
-//----------------------------------------------------------------------------
-template <class T>
-inline T* _tstrcpy (T* dst, const T* src)
-{
-	T* cp = dst;
-	while ((*cp++ = *src++) != 0) // copy string
-		;
-	return dst;
-}
-inline tchar* tstrcpy (tchar* dst, const tchar* src) {return _tstrcpy (dst, src);}
-inline char8* strcpy8 (char8* dst, const char8* src) {return _tstrcpy (dst, src);}
-inline char16* strcpy16 (char16* dst, const char16* src) {return _tstrcpy (dst, src);}
-
-//----------------------------------------------------------------------------
-template <class T>
-inline T* _tstrncpy (T* dest, const T* source, uint32 count)
-{
-	T* start = dest;
-	while (count && (*dest++ = *source++) != 0) // copy string
-		count--;
-
-	if (count) // pad out with zeros
-	{
-		while (--count)
-			*dest++ = 0;
-	}
-	return start;
-}
-
-inline tchar* tstrncpy (tchar* dest, const tchar* source, uint32 count) {return _tstrncpy (dest, source, count);}
-inline char8* strncpy8 (char8* dest, const char8* source, uint32 count) {return _tstrncpy (dest, source, count);}
-inline char16* strncpy16 (char16* dest, const char16* source, uint32 count) {return _tstrncpy (dest, source, count);}
-
-//----------------------------------------------------------------------------
-template <class T>
-inline T* _tstrcat (T* dst, const T* src)
-{
-	T* cp = dst;
-
-	while (*cp)
-		cp++; // find end of dst
-
-	while ((*cp++ = *src++) != 0) // Copy src to end of dst
-		;
-
-	return dst;
-}
-
-inline tchar* tstrcat (tchar* dst, const tchar* src) {return _tstrcat (dst, src); }
-inline char8* strcat8 (char8* dst, const char8* src) {return _tstrcat (dst, src); }
-inline char16* strcat16 (char16* dst, const char16* src) {return _tstrcat (dst, src); }
-
-//----------------------------------------------------------------------------
-inline void str8ToStr16 (char16* dst, const char8* src, int32 n = -1)
-{
-	int32 i = 0;
-	for (;;)
-	{
-		if (i == n)
-		{
-			dst[i] = 0;
-			return;
-		}
-
-#if BYTEORDER == kBigEndian
-		char8* pChr = (char8*)&dst[i];
-		pChr[0] = 0;
-		pChr[1] = src[i];
-#else
-		dst[i] = static_cast<char16> (src[i]);
-#endif
-		if (src[i] == 0)
-			break;
-		i++;
-	}
-
-	while (n > i)
-	{
-		dst[i] = 0;
-		i++;
-	}
-}
-
-//------------------------------------------------------------------------
-inline bool FIDStringsEqual (FIDString id1, FIDString id2)
-{
-	return (id1 && id2) ? (strcmp8 (id1, id2) == 0) : false;
-}
-
-static const uint32 kPrintfBufferSize = 4096;
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/base/ftypes.h

@@ -1,194 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/ftypes.h
-// Created by  : Steinberg, 01/2004
-// Description : Basic data types
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "fplatform.h"
-
-//#define UNICODE_OFF 	// disable / enable unicode
-
-#ifdef UNICODE_OFF
-	#ifdef UNICODE
-	#undef UNICODE
-	#endif
-#else
-	#define UNICODE 1
-#endif
-
-#ifdef UNICODE
-#define _UNICODE 1
-#endif
-
-namespace Steinberg
-{
-//-----------------------------------------------------------------
-// Integral Types
-	typedef char int8;
-	typedef unsigned char uint8;
-	typedef unsigned char uchar;
-
-	typedef short int16;
-	typedef unsigned short uint16;
-
-#if SMTG_OS_WINDOWS && !defined(__GNUC__)
-	typedef long int32;
-	typedef unsigned long uint32;
-#else
-	typedef int int32;
-	typedef unsigned int uint32;
-#endif
-
-	static const int32 kMaxLong = 0x7fffffff;
-	static const int32 kMinLong = (-0x7fffffff - 1);
-	static const int32 kMaxInt32 = kMaxLong;
-	static const int32 kMinInt32 = kMinLong;
-	static const uint32 kMaxInt32u = 0xffffffff;
-
-#if SMTG_OS_WINDOWS && !defined(__GNUC__)
-	typedef __int64 int64;
-	typedef unsigned __int64 uint64;
-	static const int64 kMaxInt64 = 9223372036854775807i64;
-	static const int64 kMinInt64 = (-9223372036854775807i64 - 1);
-#else
-	typedef long long int64;
-	typedef unsigned long long uint64;
-	static const int64 kMaxInt64 = 0x7fffffffffffffffLL;
-	static const int64 kMinInt64 = (-0x7fffffffffffffffLL-1);
-#endif
-	static const uint64 kMaxInt64u = uint64 (0xffffffff) | (uint64 (0xffffffff) << 32);
-
-//-----------------------------------------------------------------
-// other Semantic Types
-	typedef int64 TSize;   // byte (or other) sizes
-	typedef int32 tresult; // result code
-//-----------------------------------------------------------------
-	static const float kMaxFloat = 3.40282346638528860E38;
-	static const double kMaxDouble = 1.7976931348623158E308;
-
-#if SMTG_PLATFORM_64
-	typedef uint64 TPtrInt;
-#else
-	typedef uint32 TPtrInt;
-#endif
-
-//------------------------------------------------------------------
-// Boolean
-	typedef uint8 TBool;
-
-//------------------------------------------------------------------
-// Char / Strings
-	typedef char char8;
-#ifdef _NATIVE_WCHAR_T_DEFINED
-	typedef __wchar_t char16;
-#elif defined(__MINGW32__)
-	typedef wchar_t char16;
-#elif SMTG_CPP11
-	typedef char16_t char16;
-#else
-	typedef int16 char16;
-#endif
-
-#ifdef UNICODE
-	typedef char16 tchar;
-#else
-	typedef char8 tchar;
-#endif
-
-	typedef const char8* CStringA;
-	typedef const char16* CStringW;
-	typedef const tchar* CString;
-	inline bool strEmpty (const tchar* str) { return (!str || *str == 0); }
-	inline bool str8Empty (const char8* str) { return (!str || *str == 0); }
-	inline bool str16Empty (const char16* str) { return (!str || *str == 0); }
-
-	typedef const char8* FIDString; // identifier as string (used for attributes, messages)
-
-	const FIDString kPlatformStringWin = "WIN";
-	const FIDString kPlatformStringMac = "MAC";
-	const FIDString kPlatformStringIOS = "IOS";
-	const FIDString kPlatformStringLinux = "Linux";
-#if SMTG_OS_WINDOWS
-	const FIDString kPlatformString = kPlatformStringWin;
-#elif SMTG_OS_IOS
-	const FIDString kPlatformString = kPlatformStringIOS;
-#elif SMTG_OS_MACOS
-	const FIDString kPlatformString = kPlatformStringMac;
-#elif SMTG_OS_LINUX
-	const FIDString kPlatformString = kPlatformStringLinux;
-#endif
-
-//------------------------------------------------------------------------
-/** Coordinates	*/
-	typedef int32 UCoord;
-	static const UCoord kMaxCoord = ((UCoord)0x7FFFFFFF);
-	static const UCoord kMinCoord = ((UCoord)-0x7FFFFFFF);
-}	// namespace Steinberg
-
-
-//----------------------------------------------------------------------------
-/** Byte-order Conversion Macros 
-*/
-#define SWAP_32(l) { \
-	unsigned char* p = (unsigned char*)& (l); \
-	unsigned char t; \
-	t = p[0]; p[0] = p[3]; p[3] = t; t = p[1]; p[1] = p[2]; p[2] = t; }
-
-#define SWAP_16(w) { \
-	unsigned char* p = (unsigned char*)& (w); \
-	unsigned char t; \
-	t = p[0]; p[0] = p[1]; p[1] = t; }
-
-#define SWAP_64(i) { \
-	unsigned char* p = (unsigned char*)& (i); \
-	unsigned char t; \
-	t = p[0]; p[0] = p[7]; p[7] = t; t = p[1]; p[1] = p[6]; p[6] = t; \
-	t = p[2]; p[2] = p[5]; p[5] = t; t = p[3]; p[3] = p[4]; p[4] = t;}
-
-namespace Steinberg
-{
-	static inline void FSwap (int8&) {}
-	static inline void FSwap (uint8&) {}
-	static inline void FSwap (int16& i16) { SWAP_16 (i16) }
-	static inline void FSwap (uint16& i16) { SWAP_16 (i16) }
-	static inline void FSwap (int32& i32) { SWAP_32 (i32) }
-	static inline void FSwap (uint32& i32) { SWAP_32 (i32) }
-	static inline void FSwap (int64& i64) { SWAP_64 (i64) }
-	static inline void FSwap (uint64& i64) { SWAP_64 (i64) }
-}
-
-// always inline macros (only when RELEASE is 1)
-//----------------------------------------------------------------------------
-#if RELEASE
-    #if SMTG_OS_MACOS || SMTG_OS_LINUX || defined(__MINGW32__)
-		#define SMTG_ALWAYS_INLINE	__inline__ __attribute__((__always_inline__))
-		#define SMTG_NEVER_INLINE __attribute__((noinline))
-	#elif SMTG_OS_WINDOWS
-		#define SMTG_ALWAYS_INLINE	__forceinline
-		#define SMTG_NEVER_INLINE __declspec(noinline)
-	#endif
-#endif
-
-#ifndef SMTG_ALWAYS_INLINE
-	#define SMTG_ALWAYS_INLINE	inline
-#endif
-#ifndef SMTG_NEVER_INLINE
-	#define SMTG_NEVER_INLINE
-#endif
-
-#ifndef SMTG_CPP11_STDLIBSUPPORT
-// Enable this for old compilers
-// #define nullptr NULL
-#endif

source/includes/vst3sdk/pluginterfaces/base/funknown.cpp

@@ -1,492 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/funknown.cpp
-// Created by  : Steinberg, 01/2004
-// Description : Basic Interface
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#include "funknown.h"
-
-#include "fstrdefs.h"
-
-#include <cstdio>
-
-#if SMTG_OS_WINDOWS
-#include <objbase.h>
-#endif
-
-#if SMTG_OS_MACOS
-#include <CoreFoundation/CoreFoundation.h>
-
-#if !defined (SMTG_USE_STDATOMIC_H)
-#if defined(MAC_OS_X_VERSION_10_11) && defined(MAC_OS_X_VERSION_MIN_REQUIRED)
-#define SMTG_USE_STDATOMIC_H (MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_11)
-#else
-#define SMTG_USE_STDATOMIC_H 0
-#endif
-#endif // !defined (SMTG_USE_STDATOMIC_H)
-
-#if !SMTG_USE_STDATOMIC_H
-#include <libkern/OSAtomic.h>
-#if defined(__GNUC__) && (__GNUC__ >= 4) && !__LP64__
-// on 32 bit Mac OS X we can safely ignore the format warnings as sizeof(int) == sizeof(long)
-#pragma GCC diagnostic ignored "-Wformat"
-#endif 
-#endif // !SMTG_USE_STDATOMIC_H
-#endif // SMTG_OS_MACOS
-
-#if SMTG_OS_LINUX
-#if !defined (SMTG_USE_STDATOMIC_H)
-#if defined (__ANDROID__) || defined(_LIBCPP_VERSION)
-#define SMTG_USE_STDATOMIC_H 1
-#else
-#include <ext/atomicity.h>
-#endif
-#endif // !defined (SMTG_USE_STDATOMIC_H)
-#include <stdlib.h>
-#endif
-
-#if defined (SMTG_USE_STDATOMIC_H) && SMTG_USE_STDATOMIC_H 
-#include <stdatomic.h>
-#endif
-
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-#if COM_COMPATIBLE
-#if SMTG_OS_WINDOWS
-#define GuidStruct GUID
-#else
-struct GuidStruct
-{
-	uint32 Data1;
-	uint16 Data2;
-	uint16 Data3;
-	uint8 Data4[8];
-};
-#endif
-#endif
-
-static void toString8 (char8* string, const char* data, int32 i1, int32 i2);
-static void fromString8 (const char8* string, char* data, int32 i1, int32 i2);
-static uint32 makeLong (uint8 b1, uint8 b2, uint8 b3, uint8 b4);
-
-//------------------------------------------------------------------------
-//  FUnknownPrivate
-//------------------------------------------------------------------------
-namespace FUnknownPrivate {
-//------------------------------------------------------------------------
-int32 PLUGIN_API atomicAdd (int32& var, int32 d)
-{
-#if SMTG_USE_STDATOMIC_H
-	return atomic_fetch_add (reinterpret_cast<atomic_int_least32_t*> (&var), d) + d;
-#else
-#if SMTG_OS_WINDOWS
-#ifdef __MINGW32__
-	return InterlockedExchangeAdd (reinterpret_cast<long volatile*>(&var), d) + d;
-#else
-	return InterlockedExchangeAdd ((LONG*)&var, d) + d;
-#endif
-#elif SMTG_OS_MACOS
-	return OSAtomicAdd32Barrier (d, (int32_t*)&var);
-#elif defined(__ANDROID__)
-	return atomic_fetch_add ((atomic_int*)&var, d) + d;
-#elif SMTG_OS_LINUX
-	__gnu_cxx::__atomic_add (&var, d);
-	return var;
-#else
-#warning implement me!
-	var += d;
-	return var;
-#endif
-#endif
-}
-} // FUnknownPrivate
-
-//------------------------------------------------------------------------
-//	FUID implementation
-//------------------------------------------------------------------------
-
-FUID::FUID ()
-{
-	memset (data, 0, sizeof (TUID));
-}
-
-//------------------------------------------------------------------------
-FUID::FUID (uint32 l1, uint32 l2, uint32 l3, uint32 l4)
-{
-	from4Int (l1, l2, l3, l4);
-}
-
-//------------------------------------------------------------------------
-FUID::FUID (const FUID& f)
-{
-	memcpy (data, f.data, sizeof (TUID));
-}
-
-//------------------------------------------------------------------------
-#if SMTG_CPP11_STDLIBSUPPORT
-FUID::FUID (FUID&& other)
-{
-	memcpy (data, other.data, sizeof (TUID));
-}
-
-FUID& FUID::operator= (FUID&& other)
-{
-	memcpy (data, other.data, sizeof (TUID));
-	return *this;
-}
-#endif
-
-//------------------------------------------------------------------------
-bool FUID::generate ()
-{
-#if SMTG_OS_WINDOWS
-#if defined(_M_ARM64) || defined(_M_ARM)
-	//#warning implement me!
-	return false;
-#else
-	GUID guid;
-	HRESULT hr = CoCreateGuid (&guid);
-	switch (hr)
-	{
-		case RPC_S_OK: memcpy (data, (char*)&guid, sizeof (TUID)); return true;
-
-		case (HRESULT)RPC_S_UUID_LOCAL_ONLY:
-		default: return false;
-	}
-#endif
-
-#elif SMTG_OS_MACOS
-	CFUUIDRef uuid = CFUUIDCreate (kCFAllocatorDefault);
-	if (uuid)
-	{
-		CFUUIDBytes bytes = CFUUIDGetUUIDBytes (uuid);
-		memcpy (data, (char*)&bytes, sizeof (TUID));
-		CFRelease (uuid);
-		return true;
-	}
-	return false;
-
-#elif SMTG_OS_LINUX
-	srand ((size_t)this);
-	for (int32 i = 0; i < 16; i++)
-		data[i] = static_cast<unsigned char>(rand ());
-	return true;
-#else
-#warning implement me!
-	return false;
-#endif
-}
-
-//------------------------------------------------------------------------
-bool FUID::isValid () const
-{
-	TUID nulluid = {0};
-
-	return memcmp (data, nulluid, sizeof (TUID)) != 0;
-}
-
-//------------------------------------------------------------------------
-FUID& FUID::operator= (const FUID& f)
-{
-	memcpy (data, f.data, sizeof (TUID));
-	return *this;
-}
-
-//------------------------------------------------------------------------
-void FUID::from4Int (uint32 l1, uint32 l2, uint32 l3, uint32 l4)
-{
-#if COM_COMPATIBLE
-	data [0]  = (char)((l1 & 0x000000FF)      );
-	data [1]  = (char)((l1 & 0x0000FF00) >>  8);
-	data [2]  = (char)((l1 & 0x00FF0000) >> 16);
-	data [3]  = (char)((l1 & 0xFF000000) >> 24);
-	data [4]  = (char)((l2 & 0x00FF0000) >> 16);
-	data [5]  = (char)((l2 & 0xFF000000) >> 24);
-	data [6]  = (char)((l2 & 0x000000FF)      );
-	data [7]  = (char)((l2 & 0x0000FF00) >>  8);
-	data [8]  = (char)((l3 & 0xFF000000) >> 24);
-	data [9]  = (char)((l3 & 0x00FF0000) >> 16);
-	data [10] = (char)((l3 & 0x0000FF00) >>  8);
-	data [11] = (char)((l3 & 0x000000FF)      );
-	data [12] = (char)((l4 & 0xFF000000) >> 24);
-	data [13] = (char)((l4 & 0x00FF0000) >> 16);
-	data [14] = (char)((l4 & 0x0000FF00) >>  8);
-	data [15] = (char)((l4 & 0x000000FF)      );
-#else
-	data [0]  = (char)((l1 & 0xFF000000) >> 24);
-	data [1]  = (char)((l1 & 0x00FF0000) >> 16);
-	data [2]  = (char)((l1 & 0x0000FF00) >>  8);
-	data [3]  = (char)((l1 & 0x000000FF)      );
-	data [4]  = (char)((l2 & 0xFF000000) >> 24);
-	data [5]  = (char)((l2 & 0x00FF0000) >> 16);
-	data [6]  = (char)((l2 & 0x0000FF00) >>  8);
-	data [7]  = (char)((l2 & 0x000000FF)      );
-	data [8]  = (char)((l3 & 0xFF000000) >> 24);
-	data [9]  = (char)((l3 & 0x00FF0000) >> 16);
-	data [10] = (char)((l3 & 0x0000FF00) >>  8);
-	data [11] = (char)((l3 & 0x000000FF)      );
-	data [12] = (char)((l4 & 0xFF000000) >> 24);
-	data [13] = (char)((l4 & 0x00FF0000) >> 16);
-	data [14] = (char)((l4 & 0x0000FF00) >>  8);
-	data [15] = (char)((l4 & 0x000000FF)      );
-#endif
-}
-
-//------------------------------------------------------------------------
-void FUID::to4Int (uint32& d1, uint32& d2, uint32& d3, uint32& d4) const
-{
-	d1 = getLong1 ();
-	d2 = getLong2 ();
-	d3 = getLong3 ();
-	d4 = getLong4 ();
-}
-
-//------------------------------------------------------------------------
-uint32 FUID::getLong1 () const
-{
-#if COM_COMPATIBLE
-	return makeLong (data[3], data[2], data[1], data[0]);
-#else
-	return makeLong (data[0], data[1], data[2], data[3]);
-#endif
-}
-
-//------------------------------------------------------------------------
-uint32 FUID::getLong2 () const
-{
-#if COM_COMPATIBLE
-	return makeLong (data[5], data[4], data[7], data[6]);
-#else
-	return makeLong (data[4], data[5], data[6], data[7]);
-#endif
-}
-
-//------------------------------------------------------------------------
-uint32 FUID::getLong3 () const
-{
-#if COM_COMPATIBLE
-	return makeLong (data[8], data[9], data[10], data[11]);
-#else
-	return makeLong (data[8], data[9], data[10], data[11]);
-#endif
-}
-
-//------------------------------------------------------------------------
-uint32 FUID::getLong4 () const
-{
-#if COM_COMPATIBLE
-	return makeLong (data[12], data[13], data[14], data[15]);
-#else
-	return makeLong (data[12], data[13], data[14], data[15]);
-#endif
-}
-
-//------------------------------------------------------------------------
-void FUID::toString (char8* string) const
-{
-	if (!string)
-		return;
-
-#if COM_COMPATIBLE
-	auto* g = (GuidStruct*)data;
-
-	char8 s[17];
-	Steinberg::toString8 (s, data, 8, 16);
-
-	sprintf (string, "%08X%04X%04X%s", g->Data1, g->Data2, g->Data3, s);
-#else
-	Steinberg::toString8 (string, data, 0, 16);
-#endif
-}
-
-//------------------------------------------------------------------------
-bool FUID::fromString (const char8* string)
-{
-	if (!string || !*string)
-		return false;
-	if (strlen (string) != 32)
-		return false;
-
-#if COM_COMPATIBLE
-	GuidStruct g;
-	char s[33];
-
-	strcpy (s, string);
-	s[8] = 0;
-	sscanf (s, "%x", &g.Data1);
-	strcpy (s, string + 8);
-	s[4] = 0;
-	sscanf (s, "%hx", &g.Data2);
-	strcpy (s, string + 12);
-	s[4] = 0;
-	sscanf (s, "%hx", &g.Data3);
-
-	memcpy (data, &g, 8);
-	Steinberg::fromString8 (string + 16, data, 8, 16);
-#else
-	Steinberg::fromString8 (string, data, 0, 16);
-#endif
-
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool FUID::fromRegistryString (const char8* string)
-{
-	if (!string || !*string)
-		return false;
-	if (strlen (string) != 38)
-		return false;
-
-// e.g. {c200e360-38c5-11ce-ae62-08002b2b79ef}
-
-#if COM_COMPATIBLE
-	GuidStruct g;
-	char8 s[10];
-
-	strncpy (s, string + 1, 8);
-	s[8] = 0;
-	sscanf (s, "%x", &g.Data1);
-	strncpy (s, string + 10, 4);
-	s[4] = 0;
-	sscanf (s, "%hx", &g.Data2);
-	strncpy (s, string + 15, 4);
-	s[4] = 0;
-	sscanf (s, "%hx", &g.Data3);
-	memcpy (data, &g, 8);
-
-	Steinberg::fromString8 (string + 20, data, 8, 10);
-	Steinberg::fromString8 (string + 25, data, 10, 16);
-#else
-	Steinberg::fromString8 (string + 1, data, 0, 4);
-	Steinberg::fromString8 (string + 10, data, 4, 6);
-	Steinberg::fromString8 (string + 15, data, 6, 8);
-	Steinberg::fromString8 (string + 20, data, 8, 10);
-	Steinberg::fromString8 (string + 25, data, 10, 16);
-#endif
-
-	return true;
-}
-
-//------------------------------------------------------------------------
-void FUID::toRegistryString (char8* string) const
-{
-// e.g. {c200e360-38c5-11ce-ae62-08002b2b79ef}
-
-#if COM_COMPATIBLE
-	auto* g = (GuidStruct*)data;
-
-	char8 s1[5];
-	Steinberg::toString8 (s1, data, 8, 10);
-
-	char8 s2[13];
-	Steinberg::toString8 (s2, data, 10, 16);
-
-	sprintf (string, "{%08X-%04X-%04X-%s-%s}", g->Data1, g->Data2, g->Data3, s1, s2);
-#else
-	char8 s1[9];
-	Steinberg::toString8 (s1, data, 0, 4);
-	char8 s2[5];
-	Steinberg::toString8 (s2, data, 4, 6);
-	char8 s3[5];
-	Steinberg::toString8 (s3, data, 6, 8);
-	char8 s4[5];
-	Steinberg::toString8 (s4, data, 8, 10);
-	char8 s5[13];
-	Steinberg::toString8 (s5, data, 10, 16);
-
-	sprintf (string, "{%s-%s-%s-%s-%s}", s1, s2, s3, s4, s5);
-#endif
-}
-
-//------------------------------------------------------------------------
-void FUID::print (char8* string, int32 style) const
-{
-	if (!string) // no string: debug output
-	{
-		char8 str[128];
-		print (str, style);
-
-#if SMTG_OS_WINDOWS
-		OutputDebugStringA (str);
-		OutputDebugStringA ("\n");
-#else
-		fprintf (stdout, "%s\n", str);
-#endif
-		return;
-	}
-
-	uint32 l1, l2, l3, l4;
-	to4Int (l1, l2, l3, l4);
-
-	switch (style)
-	{
-		case kINLINE_UID:
-			sprintf (string, "INLINE_UID (0x%08X, 0x%08X, 0x%08X, 0x%08X)", l1, l2, l3, l4);
-			break;
-
-		case kDECLARE_UID:
-			sprintf (string, "DECLARE_UID (0x%08X, 0x%08X, 0x%08X, 0x%08X)", l1, l2, l3, l4);
-			break;
-
-		case kFUID:
-			sprintf (string, "FUID (0x%08X, 0x%08X, 0x%08X, 0x%08X)", l1, l2, l3, l4);
-			break;
-
-		case kCLASS_UID:
-		default:
-			sprintf (string, "DECLARE_CLASS_IID (Interface, 0x%08X, 0x%08X, 0x%08X, 0x%08X)", l1,
-			         l2, l3, l4);
-			break;
-	}
-}
-
-//------------------------------------------------------------------------
-//  helpers
-//------------------------------------------------------------------------
-static uint32 makeLong (uint8 b1, uint8 b2, uint8 b3, uint8 b4)
-{
-	return (uint32 (b1) << 24) | (uint32 (b2) << 16) | (uint32 (b3) << 8) | uint32 (b4);
-}
-
-//------------------------------------------------------------------------
-static void toString8 (char8* string, const char* data, int32 i1, int32 i2)
-{
-	*string = 0;
-	for (int32 i = i1; i < i2; i++)
-	{
-		char8 s[3];
-		sprintf (s, "%02X", (uint8)data[i]);
-		strcat (string, s);
-	}
-}
-
-//------------------------------------------------------------------------
-static void fromString8 (const char8* string, char* data, int32 i1, int32 i2)
-{
-	for (int32 i = i1; i < i2; i++)
-	{
-		char8 s[3];
-		s[0] = *string++;
-		s[1] = *string++;
-		s[2] = 0;
-
-		int32 d = 0;
-		sscanf (s, "%2x", &d);
-		data[i] = (char)d;
-	}
-}
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/base/funknown.h

@@ -1,550 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/funknown.h
-// Created by  : Steinberg, 01/2004
-// Description : Basic Interface
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/fplatform.h"
-#include "pluginterfaces/base/ftypes.h"
-#include "pluginterfaces/base/smartpointer.h"
-#include <cstring>
-
-#if SMTG_CPP11_STDLIBSUPPORT
-#include <type_traits>
-#endif
-
-//------------------------------------------------------------------------
-/*! \defgroup pluginBase Basic Interfaces
-*/
-
-//------------------------------------------------------------------------
-//  Unique Identifier macros
-//------------------------------------------------------------------------
-
-#if COM_COMPATIBLE
-#define INLINE_UID(l1, l2, l3, l4) \
-{ \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l1) & 0x000000FF)      ), (::Steinberg::int8)(((::Steinberg::uint32)(l1) & 0x0000FF00) >>  8), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l1) & 0x00FF0000) >> 16), (::Steinberg::int8)(((::Steinberg::uint32)(l1) & 0xFF000000) >> 24), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l2) & 0x00FF0000) >> 16), (::Steinberg::int8)(((::Steinberg::uint32)(l2) & 0xFF000000) >> 24), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l2) & 0x000000FF)      ), (::Steinberg::int8)(((::Steinberg::uint32)(l2) & 0x0000FF00) >>  8), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l3) & 0xFF000000) >> 24), (::Steinberg::int8)(((::Steinberg::uint32)(l3) & 0x00FF0000) >> 16), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l3) & 0x0000FF00) >>  8), (::Steinberg::int8)(((::Steinberg::uint32)(l3) & 0x000000FF)      ), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l4) & 0xFF000000) >> 24), (::Steinberg::int8)(((::Steinberg::uint32)(l4) & 0x00FF0000) >> 16), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l4) & 0x0000FF00) >>  8), (::Steinberg::int8)(((::Steinberg::uint32)(l4) & 0x000000FF)      )  \
-}
-#else
-#define INLINE_UID(l1, l2, l3, l4) \
-{ \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l1) & 0xFF000000) >> 24), (::Steinberg::int8)(((::Steinberg::uint32)(l1) & 0x00FF0000) >> 16), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l1) & 0x0000FF00) >>  8), (::Steinberg::int8)(((::Steinberg::uint32)(l1) & 0x000000FF)      ), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l2) & 0xFF000000) >> 24), (::Steinberg::int8)(((::Steinberg::uint32)(l2) & 0x00FF0000) >> 16), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l2) & 0x0000FF00) >>  8), (::Steinberg::int8)(((::Steinberg::uint32)(l2) & 0x000000FF)      ), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l3) & 0xFF000000) >> 24), (::Steinberg::int8)(((::Steinberg::uint32)(l3) & 0x00FF0000) >> 16), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l3) & 0x0000FF00) >>  8), (::Steinberg::int8)(((::Steinberg::uint32)(l3) & 0x000000FF)      ), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l4) & 0xFF000000) >> 24), (::Steinberg::int8)(((::Steinberg::uint32)(l4) & 0x00FF0000) >> 16), \
-	(::Steinberg::int8)(((::Steinberg::uint32)(l4) & 0x0000FF00) >>  8), (::Steinberg::int8)(((::Steinberg::uint32)(l4) & 0x000000FF)      )  \
-}
-#endif
-
-//------------------------------------------------------------------------
-#define DECLARE_UID(name, l1, l2, l3, l4) ::Steinberg::TUID name = INLINE_UID (l1, l2, l3, l4);
-
-//------------------------------------------------------------------------
-#define EXTERN_UID(name) extern const ::Steinberg::TUID name;
-
-#ifdef INIT_CLASS_IID
-#define DECLARE_CLASS_IID(ClassName, l1, l2, l3, l4)                              \
-	static const ::Steinberg::TUID ClassName##_iid = INLINE_UID (l1, l2, l3, l4); \
-	\
-const ::Steinberg::FUID ClassName::iid (ClassName##_iid);
-#else
-#define DECLARE_CLASS_IID(ClassName, l1, l2, l3, l4) \
-	static const ::Steinberg::TUID ClassName##_iid = INLINE_UID (l1, l2, l3, l4);
-#endif
-
-#define DEF_CLASS_IID(ClassName) const ::Steinberg::FUID ClassName::iid (ClassName##_iid);
-
-#define INLINE_UID_OF(ClassName) ClassName##_iid
-
-#define INLINE_UID_FROM_FUID(x) \
-	INLINE_UID (x.getLong1 (), x.getLong2 (), x.getLong3 (), x.getLong4 ())
-
-//------------------------------------------------------------------------
-//  FUnknown implementation macros
-//------------------------------------------------------------------------
-
-#define DECLARE_FUNKNOWN_METHODS                                                                      \
-public:	                                                                                              \
-	virtual ::Steinberg::tresult PLUGIN_API queryInterface (const ::Steinberg::TUID _iid, void** obj) SMTG_OVERRIDE; \
-	virtual ::Steinberg::uint32 PLUGIN_API addRef () SMTG_OVERRIDE;                                   \
-	virtual ::Steinberg::uint32 PLUGIN_API release () SMTG_OVERRIDE;                                  \
-protected :                                                                                           \
-	::Steinberg::int32 __funknownRefCount;                                                            \
-public:
-
-//------------------------------------------------------------------------
-
-#define DELEGATE_REFCOUNT(ClassName)											        \
-public:																			        \
-	virtual ::Steinberg::uint32 PLUGIN_API addRef () SMTG_OVERRIDE { return ClassName::addRef ();  } \
-	virtual ::Steinberg::uint32 PLUGIN_API release () SMTG_OVERRIDE { return ClassName::release (); }
-
-//------------------------------------------------------------------------
-#define IMPLEMENT_REFCOUNT(ClassName)                                          \
-::Steinberg::uint32 PLUGIN_API ClassName::addRef ()                            \
-{                                                                              \
-	return ::Steinberg::FUnknownPrivate::atomicAdd (__funknownRefCount, 1);    \
-}                                                                              \
-::Steinberg::uint32 PLUGIN_API ClassName::release ()                           \
-{                                                                              \
-	if (::Steinberg::FUnknownPrivate::atomicAdd (__funknownRefCount, -1) == 0) \
-	{                                                                          \
-		delete this;                                                           \
-		return 0;                                                              \
-	}                                                                          \
-	return __funknownRefCount;                                                 \
-}
-
-//------------------------------------------------------------------------
-#define FUNKNOWN_CTOR	{ __funknownRefCount = 1; }
-#if SMTG_FUNKNOWN_DTOR_ASSERT
-#include <cassert>
-#define FUNKNOWN_DTOR { assert (__funknownRefCount == 0); }
-#else
-#define FUNKNOWN_DTOR
-#endif
-
-//------------------------------------------------------------------------
-#define QUERY_INTERFACE(iid, obj, InterfaceIID, InterfaceName)  \
-if (::Steinberg::FUnknownPrivate::iidEqual (iid, InterfaceIID)) \
-{                                                               \
-	addRef ();                                                  \
-	*obj = static_cast< InterfaceName* >(this);                 \
-	return ::Steinberg::kResultOk;                              \
-}
-
-//------------------------------------------------------------------------
-#define IMPLEMENT_QUERYINTERFACE(ClassName, InterfaceName, ClassIID)                                \
-::Steinberg::tresult PLUGIN_API ClassName::queryInterface (const ::Steinberg::TUID _iid, void** obj)\
-{                                                                                                   \
-	QUERY_INTERFACE (_iid, obj, ::Steinberg::FUnknown::iid, InterfaceName)                          \
-	QUERY_INTERFACE (_iid, obj, ClassIID, InterfaceName)                                            \
-	*obj = nullptr;                                                                                 \
-	return ::Steinberg::kNoInterface;                                                               \
-}
-
-//------------------------------------------------------------------------
-#define IMPLEMENT_FUNKNOWN_METHODS(ClassName,InterfaceName,ClassIID) \
-	IMPLEMENT_REFCOUNT (ClassName)                                   \
-	IMPLEMENT_QUERYINTERFACE (ClassName, InterfaceName, ClassIID)
-
-//------------------------------------------------------------------------
-//  Result Codes
-//------------------------------------------------------------------------
-
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-#if COM_COMPATIBLE
-#if SMTG_OS_WINDOWS
-enum
-{
-	kNoInterface		= static_cast<tresult>(0x80004002L),	// E_NOINTERFACE
-	kResultOk			= static_cast<tresult>(0x00000000L),	// S_OK
-	kResultTrue			= kResultOk,
-	kResultFalse		= static_cast<tresult>(0x00000001L),	// S_FALSE
-	kInvalidArgument	= static_cast<tresult>(0x80070057L),	// E_INVALIDARG
-	kNotImplemented		= static_cast<tresult>(0x80004001L),	// E_NOTIMPL
-	kInternalError		= static_cast<tresult>(0x80004005L),	// E_FAIL
-	kNotInitialized		= static_cast<tresult>(0x8000FFFFL),	// E_UNEXPECTED
-	kOutOfMemory		= static_cast<tresult>(0x8007000EL)		// E_OUTOFMEMORY
-};
-#else
-enum
-{
-	kNoInterface		= static_cast<tresult>(0x80000004L),	// E_NOINTERFACE
-	kResultOk			= static_cast<tresult>(0x00000000L),	// S_OK
-	kResultTrue			= kResultOk,
-	kResultFalse		= static_cast<tresult>(0x00000001L),	// S_FALSE
-	kInvalidArgument	= static_cast<tresult>(0x80000003L),	// E_INVALIDARG
-	kNotImplemented		= static_cast<tresult>(0x80000001L),	// E_NOTIMPL
-	kInternalError		= static_cast<tresult>(0x80000008L),	// E_FAIL
-	kNotInitialized		= static_cast<tresult>(0x8000FFFFL),	// E_UNEXPECTED
-	kOutOfMemory		= static_cast<tresult>(0x80000002L)		// E_OUTOFMEMORY
-};
-#endif
-#else
-enum
-{
-	kNoInterface = -1,
-	kResultOk,
-	kResultTrue = kResultOk,
-	kResultFalse,
-	kInvalidArgument,
-	kNotImplemented,
-	kInternalError,
-	kNotInitialized,
-	kOutOfMemory
-};
-#endif
-
-//------------------------------------------------------------------------
-typedef int64 LARGE_INT; // obsolete
-
-//------------------------------------------------------------------------
-//	FUID class declaration
-//------------------------------------------------------------------------
-typedef int8 TUID[16]; ///< plain UID type
-
-//------------------------------------------------------------------------
-/* FUnknown private */
-namespace FUnknownPrivate {
-SMTG_ALWAYS_INLINE bool iidEqual (const void* iid1, const void* iid2)
-{
-	const uint64* p1 = reinterpret_cast<const uint64*> (iid1);
-	const uint64* p2 = reinterpret_cast<const uint64*> (iid2);
-	return p1[0] == p2[0] && p1[1] == p2[1];
-}
-
-int32 PLUGIN_API atomicAdd (int32& value, int32 amount);
-}
-
-//------------------------------------------------------------------------
-/** Handling 16 Byte Globally Unique Identifiers.
-\ingroup pluginBase
-
-Each interface declares its identifier as static member inside the interface
-namespace (e.g. FUnknown::iid).
-*/
-class FUID
-{
-public:
-//------------------------------------------------------------------------
-	FUID ();
-	FUID (uint32 l1, uint32 l2, uint32 l3, uint32 l4);
-	FUID (const FUID&);
-	virtual ~FUID () {}
-
-#if SMTG_CPP11_STDLIBSUPPORT
-	FUID (FUID&& other);
-	FUID& operator= (FUID&& other);
-#endif
-
-	/** Generates a new Unique Identifier (UID).
-	    Will return true for success. If the return value is false, either no
-	    UID is generated or the UID is not guaranteed to be unique worldwide. */
-	bool generate ();
-
-	/** Checks if the UID data is valid.
-	    The default constructor initializes the memory with zeros. */
-	bool isValid () const;
-
-	FUID& operator = (const FUID& f);
-	bool operator == (const FUID& f) const { return ::Steinberg::FUnknownPrivate::iidEqual (data, f.data); }
-	bool operator < (const FUID& f) const { return memcmp (data, f.data, sizeof (TUID)) < 0; }
-	bool operator != (const FUID& f) const   { return !::Steinberg::FUnknownPrivate::iidEqual (data, f.data); }
-
-	uint32 getLong1 () const;
-	uint32 getLong2 () const;
-	uint32 getLong3 () const;
-	uint32 getLong4 () const;
-
-	void from4Int (uint32 d1, uint32 d2, uint32 d3, uint32 d4);
-	void to4Int (uint32& d1, uint32& d2, uint32& d3, uint32& d4) const;
-
-	typedef char8 String[33];
-
-	/** Converts UID to a string.
-		The string will be 32 characters long, representing the hexadecimal values
-		of each data byte (e.g. "9127BE30160E4BB69966670AA6087880"). 
-		
-		Typical use-case is:
-		\code{.cpp}
-		char8[33] strUID = {0};
-		FUID uid;
-		if (uid.generate ())
-			uid.toString (strUID);
-		\endcode
-		*/
-	void toString (char8* string) const;
-
-	/** Sets the UID data from a string.
-	    The string has to be 32 characters long, where each character-pair is
-	    the ASCII-encoded hexadecimal value of the corresponding data byte. */
-	bool fromString (const char8* string);
-
-	/** Converts UID to a string in Microsoft(R) OLE format.
-	(e.g. "{c200e360-38c5-11ce-ae62-08002b2b79ef}") */
-	void toRegistryString (char8* string) const;
-
-	/** Sets the UID data from a string in Microsoft(R) OLE format. */
-	bool fromRegistryString (const char8* string);
-
-	enum UIDPrintStyle
-	{
-		kINLINE_UID,  ///< "INLINE_UID (0x00000000, 0x00000000, 0x00000000, 0x00000000)"
-		kDECLARE_UID, ///< "DECLARE_UID (0x00000000, 0x00000000, 0x00000000, 0x00000000)"
-		kFUID,        ///< "FUID (0x00000000, 0x00000000, 0x00000000, 0x00000000)"
-		kCLASS_UID    ///< "DECLARE_CLASS_IID (Interface, 0x00000000, 0x00000000, 0x00000000, 0x00000000)"
-	};
-	/** Prints the UID to a string (or debug output if string is NULL).
-	    \param string is the output string if not NULL.
-	    \param style can be chosen from the FUID::UIDPrintStyle enumeration. */
-	void print (char8* string = nullptr, int32 style = kINLINE_UID) const;
-
-	template <size_t N>
-	inline explicit FUID (const int8 (&uid)[N])
-	{
-#if SMTG_CPP11_STDLIBSUPPORT
-		static_assert (N == sizeof (TUID), "only TUID allowed");
-#endif
-		memcpy (data, uid, sizeof (TUID));
-	}
-	inline void toTUID (TUID result) const { memcpy (result, data, sizeof (TUID)); }
-	inline operator const TUID& () const { return data; }
-	inline const TUID& toTUID () const { return data; }
-
-	static FUID fromTUID (const TUID uid)
-	{
-		FUID res;
-		if (uid)
-			memcpy (res.data, uid, sizeof (TUID));
-		return res;
-	}
-
-//------------------------------------------------------------------------
-protected:
-	TUID data;
-};
-
-#if SMTG_CPP11_STDLIBSUPPORT
-template <typename T>
-inline bool operator== (const FUID& f1, T f2)
-{
-	static_assert (
-	    std::is_same<typename std::remove_cv<T>::type, FUID>::value,
-	    "Do not compare a FUID with a TUID directly. Either convert the TUID to a FUID and compare them or use FUnknownPrivate::iidEqual");
-	return f1.operator== (f2);
-}
-#endif
-
-//------------------------------------------------------------------------
-// FUnknown
-//------------------------------------------------------------------------
-/**	The basic interface of all interfaces.
-\ingroup pluginBase
-
-- The FUnknown::queryInterface method is used to retrieve pointers to other
-  interfaces of the object.
-- FUnknown::addRef and FUnknown::release manage the lifetime of the object.
-  If no more references exist, the object is destroyed in memory.
-
-Interfaces are identified by 16 byte Globally Unique Identifiers.
-The SDK provides a class called FUID for this purpose.
-
-\ref howtoClass
-*/
-class FUnknown
-{
-public:
-
-//------------------------------------------------------------------------
-	/** Query for a pointer to the specified interface.
-	Returns kResultOk on success or kNoInterface if the object does not implement the interface.
-	The object has to call addRef when returning an interface.
-	\param _iid : (in) 16 Byte interface identifier (-> FUID)
-	\param obj : (out) On return, *obj points to the requested interface */
-	virtual tresult PLUGIN_API queryInterface (const TUID _iid, void** obj) = 0;
-
-	/** Adds a reference and returns the new reference count.
-	\par Remarks:
-	    The initial reference count after creating an object is 1. */
-	virtual uint32 PLUGIN_API addRef () = 0;
-
-	/** Releases a reference and returns the new reference count.
-	If the reference count reaches zero, the object will be destroyed in memory. */
-	virtual uint32 PLUGIN_API release () = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-//------------------------------------------------------------------------
-};
-
-
-DECLARE_CLASS_IID (FUnknown, 0x00000000, 0x00000000, 0xC0000000, 0x00000046)
-
-//------------------------------------------------------------------------
-// FUnknownPtr
-//------------------------------------------------------------------------
-/** FUnknownPtr - automatic interface conversion and smart pointer in one.
-    This template class can be used for interface conversion like this:
- \code{.cpp}
-IPtr<IPath> path = owned (FHostCreate (IPath, hostClasses));
-FUnknownPtr<IPath2> path2 (path); // does a query interface for IPath2
-if (path2)
-    ...
- \endcode
-*/
-template <class I>
-class FUnknownPtr : public IPtr<I>
-{
-public:
-//------------------------------------------------------------------------
-	inline FUnknownPtr (FUnknown* unknown); // query interface
-	inline FUnknownPtr (const FUnknownPtr& p) : IPtr<I> (p) {}
-	inline FUnknownPtr () {}
-
-	inline FUnknownPtr& operator= (const FUnknownPtr& p)
-	{
-		IPtr<I>::operator= (p);
-		return *this;
-	}
-	inline I* operator= (FUnknown* unknown);
-	inline I* getInterface () { return this->ptr; }
-
-#if SMTG_CPP11_STDLIBSUPPORT
-	inline FUnknownPtr (FUnknownPtr&& p) SMTG_NOEXCEPT : IPtr<I> (std::move (p)) {}
-	inline FUnknownPtr& operator= (FUnknownPtr&& p) SMTG_NOEXCEPT
-	{
-		IPtr<I>::operator= (std::move (p));
-		return *this;
-	}
-#endif
-};
-
-#if SMTG_CPP11_STDLIBSUPPORT
-
-//------------------------------------------------------------------------
-namespace FUnknownPrivate {
-
-template <typename T>
-struct Void : std::false_type
-{
-	using Type = void;
-};
-
-template <typename T>
-using VoidT = typename Void<T>::Type;
-
-//------------------------------------------------------------------------
-/**
- *  This type trait detects if a class has an @c iid member variable. It is used to detect if
- *  the FUID and DECLARE_CLASS_IID method or the SKI::UID method is used.
- */
-template <typename T, typename U = void>
-struct HasIIDType : std::false_type
-{
-};
-
-//------------------------------------------------------------------------
-template <typename T>
-struct HasIIDType<T, FUnknownPrivate::VoidT<typename T::IID>> : std::true_type
-{
-};
-
-//------------------------------------------------------------------------
-} // FUnknownPrivate
-
-//------------------------------------------------------------------------
-/** @return the TUID for a SKI interface which uses the SKI::UID method. */
-template <typename T,
-          typename std::enable_if<FUnknownPrivate::HasIIDType<T>::value>::type* = nullptr>
-const TUID& getTUID ()
-{
-	return T::IID::toTUID ();
-}
-
-//------------------------------------------------------------------------
-/** @return the TUID for a SKI interface which uses the FUID and DECLARE_CLASS_IID method. */
-template <typename T,
-          typename std::enable_if<!FUnknownPrivate::HasIIDType<T>::value>::type* = nullptr>
-const TUID& getTUID ()
-{
-	return T::iid.toTUID ();
-}
-
-#else // SMTG_CPP11_STDLIBSUPPORT
-
-template<typename T>
-const TUID& getTUID ()
-{
-	return T::iid.toTUID ();
-}
-
-#endif // SMTG_CPP11_STDLIBSUPPORT
-
-//------------------------------------------------------------------------
-template <class I>
-inline FUnknownPtr<I>::FUnknownPtr (FUnknown* unknown)
-{
-	if (unknown && unknown->queryInterface (getTUID<I> (), (void**)&this->ptr) != kResultOk)
-		this->ptr = 0;
-}
-
-//------------------------------------------------------------------------
-template <class I>
-inline I* FUnknownPtr<I>::operator= (FUnknown* unknown)
-{
-	I* newPtr = 0;
-	if (unknown && unknown->queryInterface (getTUID<I> (), (void**)&newPtr) == kResultOk)
-	{
-		OPtr<I> rel (newPtr);
-		return IPtr<I>::operator= (newPtr);
-	}
-
-	return IPtr<I>::operator= (0);
-}
-
-//------------------------------------------------------------------------
-// FReleaser (obsolete)
-//------------------------------------------------------------------------
-/** Release an interface using automatic object (obsolete).
-This class is obsolete and is only kept for compatibility.
-The replacement for FReleaser is OPtr.
-
-Usage example with FReleaser:
-\code{.cpp}
-void someFunction ()
-{
-    IPath* path = pathCreateMethod ();
-    FReleaser releaser (path);
-    .... do something with path...
-    .... path not used anymore, releaser will destroy it when leaving function scope
-}
-\endcode
-Usage example with OPtr:
-\code{.cpp}
-void someFunction ()
-{
-    OPtr<IPath> path = pathCreateMethod ();
-    .... do something with path...
-    .... path not used anymore, OPtr will destroy it when leaving function scope
-}
-\endcode
-*/
-struct FReleaser
-{
-	FReleaser (FUnknown* u) : u (u) {}
-	~FReleaser ()
-	{
-		if (u)
-			u->release ();
-	}
-	FUnknown* u;
-};
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/base/futils.h

@@ -1,98 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/futils.h
-// Created by  : Steinberg, 01/2004
-// Description : Basic utilities
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/ftypes.h"
-
-namespace Steinberg {
-//----------------------------------------------------------------------------
-// min/max/etc. template functions
-template <class T>
-inline const T& Min (const T& a, const T& b)
-{
-	return b < a ? b : a;
-}
-
-template <class T>
-inline const T& Max (const T& a, const T& b)
-{
-	return a < b ? b : a;
-}
-
-template <class T>
-inline T Abs (const T& value)
-{
-	return (value >= (T)0) ? value : -value;
-}
-
-template <class T>
-inline T Sign (const T& value)
-{
-	return (value == (T)0) ? 0 : ((value >= (T)0) ? 1 : -1);
-}
-
-template <class T>
-inline T Bound (T minval, T maxval, T x)
-{
-	if (x < minval)
-		return minval;
-	else if (x > maxval)
-		return maxval;
-	return x;
-}
-
-template <class T>
-void Swap (T& t1, T& t2)
-{
-	T tmp = t1;
-	t1 = t2;
-	t2 = tmp;
-}
-
-template <class T>
-bool IsApproximateEqual (T t1, T t2, T epsilon)
-{
-	if (t1 == t2)
-		return true;
-	T diff = t1 - t2;
-	if (diff < 0.0)
-		diff = -diff;
-	if (diff < epsilon)
-		return true;
-	return false;
-}
-
-template <class T>
-inline T ToNormalized (const T& value, const int32 numSteps)
-{
-	return value / T (numSteps);
-}
-
-template <class T>
-inline int32 FromNormalized (const T& norm, const int32 numSteps)
-{
-	return Min<int32> (numSteps, int32 (norm * (numSteps + 1)));
-}
-
-// Four character constant
-#ifndef CCONST
-#define CCONST(a, b, c, d) \
-	 ((((int32) (a)) << 24) | (((int32) (b)) << 16) | (((int32) (c)) << 8) | (((int32) (d)) << 0))
-#endif
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/base/fvariant.h

@@ -1,297 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/fvariant.h
-// Created by  : Steinberg, 01/2004
-// Description : Basic Interface
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/fstrdefs.h"
-#include "pluginterfaces/base/funknown.h"
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-
-class FUnknown;
-
-//------------------------------------------------------------------------
-//  FVariant struct declaration
-//------------------------------------------------------------------------
-/** A Value of variable type.
- \ingroup pluginBase
- */
-class FVariant
-{
-//------------------------------------------------------------------------
-public:
-	enum
-	{
-		kEmpty = 0,
-		kInteger = 1 << 0,
-		kFloat = 1 << 1,
-		kString8 = 1 << 2,
-		kObject = 1 << 3,
-		kOwner = 1 << 4,
-		kString16 = 1 << 5
-	};
-
-//------------------------------------------------------------------------
-	// ctors
-	inline FVariant () { memset (this, 0, sizeof (FVariant)); }
-	inline FVariant (const FVariant& variant);
-
-	inline FVariant (bool b) : type (kInteger), intValue (b) {}
-	inline FVariant (uint32 v) : type (kInteger), intValue (v) {}
-	inline FVariant (int64 v) : type (kInteger), intValue (v) {}
-	inline FVariant (double v) : type (kFloat), floatValue (v) {}
-	inline FVariant (const char8* str) : type (kString8), string8 (str) {}
-	inline FVariant (const char16* str) : type (kString16), string16 (str) {}
-	inline FVariant (FUnknown* obj, bool owner = false) : type (kObject), object (obj)
-	{
-		setOwner (owner);
-	}
-	inline ~FVariant () { empty (); }
-
-//------------------------------------------------------------------------
-	inline FVariant& operator= (const FVariant& variant);
-
-	inline void set (bool b)
-	{
-		setInt (b);
-	}
-
-	inline void set (uint32 v)
-	{
-		setInt (v);
-	}
-
-	inline void set (int64 v)
-	{
-		setInt (v);
-	}
-
-	inline void set (double v)
-	{
-		setFloat (v);
-	}
-
-	inline void set (const char8* c)
-	{
-		setString8 (c);
-	}
-
-	inline void set (const char16* c)
-	{
-		setString16 (c);
-	}
-
-	inline void setInt (int64 v)
-	{
-		empty ();
-		type = kInteger;
-		intValue = v;
-	}
-
-	inline void setFloat (double v)
-	{
-		empty ();
-		type = kFloat;
-		floatValue = v;
-	}
-	inline void setString8 (const char8* v)
-	{
-		empty ();
-		type = kString8;
-		string8 = v;
-	}
-	inline void setString16 (const char16* v)
-	{
-		empty ();
-		type = kString16;
-		string16 = v;
-	}
-
-	inline void setObject (FUnknown* obj)
-	{
-		empty ();
-		type = kObject;
-		object = obj;
-	}
-
-	template <typename T>
-	inline T get () const;
-
-	inline int64 getInt () const { return (type & kInteger) ? intValue : 0; }
-	inline double getFloat () const { return (type & kFloat) ? floatValue : 0.; }
-	inline double getNumber () const
-	{
-		return (type & kInteger) ? static_cast<double> (intValue) : (type & kFloat) ? floatValue :
-																					  0.;
-	}
-	inline const char8* getString8 () const { return (type & kString8) ? string8 : nullptr; }
-	inline const char16* getString16 () const { return (type & kString16) ? string16 : nullptr; }
-
-	inline FUnknown* getObject () const { return (type & kObject) ? object : nullptr; }
-
-	inline uint16 getType () const { return static_cast<uint16> (type & ~(kOwner)); }
-	inline bool isEmpty () const { return getType () == kEmpty; }
-	inline bool isOwner () const { return (type & kOwner) != 0; }
-	inline bool isString () const { return (type & (kString8 | kString16)) != 0; }
-	inline void setOwner (bool state)
-	{
-		if (state)
-			type |= kOwner;
-		else
-			type &= ~kOwner;
-	}
-
-	void empty ();
-//------------------------------------------------------------------------
-	uint16 type;
-	union
-	{
-		int64 intValue;
-		double floatValue;
-		const char8* string8;
-		const char16* string16;
-		FUnknown* object;
-	};
-};
-
-//------------------------------------------------------------------------
-inline bool operator== (const FVariant& v1, const FVariant& v2)
-{
-#if SMTG_PLATFORM_64
-	return v1.type == v2.type && v1.intValue == v2.intValue;
-#else
-	if (v1.type != v2.type)
-		return false;
-	if (v1.type & (FVariant::kString8 | FVariant::kString16 | FVariant::kObject))
-		return v1.string8 == v2.string8; // pointer type comparisons
-	return v1.intValue == v2.intValue; // intValue & double comparison
-
-#endif
-}
-
-template <>
-inline bool FVariant::get<bool> () const
-{
-	return getInt () != 0;
-}
-
-template <>
-inline uint32 FVariant::get<uint32> () const
-{
-	return static_cast<uint32> (getInt ());
-}
-
-template <>
-inline int32 FVariant::get<int32> () const
-{
-	return static_cast<int32> (getInt ());
-}
-
-template <>
-inline int64 FVariant::get<int64> () const
-{
-	return static_cast<int64> (getInt ());
-}
-
-template <>
-inline float FVariant::get<float> () const
-{
-	return static_cast<float> (getFloat ());
-}
-
-template <>
-inline double FVariant::get<double> () const
-{
-	return getFloat ();
-}
-
-template <>
-inline const char8* FVariant::get<const char8*> () const
-{
-	return getString8 ();
-}
-
-template <>
-inline const char16* FVariant::get<const char16*> () const
-{
-	return getString16 ();
-}
-
-template <>
-inline FUnknown* FVariant::get<FUnknown*> () const
-{
-	return getObject ();
-}
-
-//------------------------------------------------------------------------
-inline bool operator!= (const FVariant& v1, const FVariant& v2) { return !(v1 == v2); }
-
-//------------------------------------------------------------------------
-inline FVariant::FVariant (const FVariant& variant) : type (kEmpty) { *this = variant; }
-
-//------------------------------------------------------------------------
-inline void FVariant::empty ()
-{
-	if (type & kOwner)
-	{
-		if ((type & kString8) && string8)
-			delete[] string8;
-		else if ((type & kString16) && string16)
-			delete[] string16;
-
-		else if ((type & kObject) && object)
-			object->release ();
-	}
-	memset (this, 0, sizeof (FVariant));
-}
-
-//------------------------------------------------------------------------
-inline FVariant& FVariant::operator= (const FVariant& variant)
-{
-	empty ();
-
-	type = variant.type;
-
-	if ((type & kString8) && variant.string8)
-	{
-		string8 = new char8[strlen (variant.string8) + 1];
-		strcpy (const_cast<char8*> (string8), variant.string8);
-		type |= kOwner;
-	}
-	else if ((type & kString16) && variant.string16)
-	{
-		auto len = static_cast<size_t> (strlen16 (variant.string16));
-		string16 = new char16[len + 1];
-		char16* tmp = const_cast<char16*> (string16);
-		memcpy (tmp, variant.string16, len * sizeof (char16));
-		tmp[len] = 0;
-		type |= kOwner;
-	}
-	else if ((type & kObject) && variant.object)
-	{
-		object = variant.object;
-		object->addRef ();
-		type |= kOwner;
-	}
-	else
-		intValue = variant.intValue; // copy memory
-
-	return *this;
-}
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/base/ibstream.h

@@ -1,87 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/ibstream.h
-// Created by  : Steinberg, 01/2004
-// Description : Interface for reading/writing streams
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "funknown.h"
-
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-/** Base class for streams.
-\ingroup pluginBase
-- read/write binary data from/to stream
-- get/set stream read-write position (read and write position is the same)
-*/
-class IBStream: public FUnknown
-{
-public:
-	enum IStreamSeekMode
-	{
-		kIBSeekSet = 0, ///< set absolute seek position
-		kIBSeekCur,     ///< set seek position relative to current position
-		kIBSeekEnd      ///< set seek position relative to stream end
-	};
-
-//------------------------------------------------------------------------
-	/** Reads binary data from stream.
-	\param buffer : destination buffer
-	\param numBytes : amount of bytes to be read
-	\param numBytesRead : result - how many bytes have been read from stream (set to 0 if this is of no interest) */
-	virtual tresult PLUGIN_API read (void* buffer, int32 numBytes, int32* numBytesRead = nullptr) = 0;
-	
-	/** Writes binary data to stream.
-	\param buffer : source buffer
-	\param numBytes : amount of bytes to write
-	\param numBytesWritten : result - how many bytes have been written to stream (set to 0 if this is of no interest) */
-	virtual tresult PLUGIN_API write (void* buffer, int32 numBytes, int32* numBytesWritten = nullptr) = 0;
-	
-	/** Sets stream read-write position. 
-	\param pos : new stream position (dependent on mode)
-	\param mode : value of enum IStreamSeekMode
-	\param result : new seek position (set to 0 if this is of no interest) */
-	virtual tresult PLUGIN_API seek (int64 pos, int32 mode, int64* result = nullptr) = 0;
-	
-	/** Gets current stream read-write position. 
-	\param pos : is assigned the current position if function succeeds */
-	virtual tresult PLUGIN_API tell (int64* pos) = 0;
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IBStream, 0xC3BF6EA2, 0x30994752, 0x9B6BF990, 0x1EE33E9B)
-
-//------------------------------------------------------------------------
-/** Stream with a size. 
-\ingroup pluginBase
-[extends IBStream] when stream type supports it (like file and memory stream)
-*/
-class ISizeableStream: public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Return the stream size */
-	virtual tresult PLUGIN_API getStreamSize (int64& size) = 0;
-	/** Set the steam size. File streams can only be resized if they are write enabled. */
-	virtual tresult PLUGIN_API setStreamSize (int64 size) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-DECLARE_CLASS_IID (ISizeableStream, 0x04F9549E, 0xE02F4E6E, 0x87E86A87, 0x47F4E17F)
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/base/icloneable.h

@@ -1,41 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/icloneable.h
-// Created by  : Steinberg, 11/2007
-// Description : Interface for object copies
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "funknown.h"
-
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-/**  Interface allowing an object to be copied.
-- [plug & host imp] 
-- [released: N4.12]
-*/
-class ICloneable : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Create exact copy of the object */
-	virtual FUnknown* PLUGIN_API clone () = 0;
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (ICloneable, 0xD45406B9, 0x3A2D4443, 0x9DAD9BA9, 0x85A1454B)
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/base/ipersistent.h

@@ -1,160 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/ipersistent.h
-// Created by  : Steinberg, 09/2004
-// Description : Plug-In Storage Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-
-namespace Steinberg {
-
-class FVariant;
-class IAttributes;
-//------------------------------------------------------------------------
-/**  Persistent Object Interface. 
-[plug imp] \n
-This interface is used to store/restore attributes of an object.
-An IPlugController can implement this interface to handle presets.
-The gui-xml for a preset control looks like this:
-\code
-....
-<view name="PresetView" data="Preset"/>
-....
-<template name="PresetView">
-	<view name="preset control" size="0, 0, 100, 20"/>
-	<switch name="store preset" size="125,0,80,20" style="push|immediate" title="Store"  />
-	<switch name="remove preset" size="220,0,80,20" style="push|immediate" title="Delete"  />
-</template>
-\endcode
-The tag data="Preset" tells the host to create a preset controller that handles the 
-3 values named "preset control",  "store preset", and "remove preset".
-*/
-class IPersistent: public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** The class ID must be a 16 bytes unique id that is used to create the object. 
-	This ID is also used to identify the preset list when used with presets. */
-	virtual tresult PLUGIN_API getClassID (char8* uid) = 0;
-	/** Store all members/data in the passed IAttributes. */
-	virtual tresult PLUGIN_API saveAttributes (IAttributes* ) = 0;
-	/** Restore all members/data from the passed IAttributes. */
-	virtual tresult PLUGIN_API loadAttributes (IAttributes* ) = 0;
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IPersistent, 0xBA1A4637, 0x3C9F46D0, 0xA65DBA0E, 0xB85DA829)
-
-
-typedef FIDString IAttrID;
-//------------------------------------------------------------------------
-/**  Object Data Archive Interface. 
-- [host imp]
-
-- store data/objects/binary/subattributes in the archive
-- read stored data from the archive
-
-All data stored to the archive are identified by a string (IAttrID), which must be unique on each
-IAttribute level.
-
-The basic set/get methods make use of the FVariant class defined in 'funknown.h'.
-For a more convenient usage of this interface, you should use the functions defined
-in namespace PAttributes (public.sdk/source/common/pattributes.h+cpp) !! 
-
-\ingroup frameworkHostClasses
-*/
-class IAttributes: public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/*! \name Methods to write attributes
-	******************************************************************************************************** */
-	//@{
-	/** Store any data in the archive. It is even possible to store sub-attributes by creating
-	    a new IAttributes instance via the IHostClasses interface and pass it to the parent in the
-		FVariant. In this case the archive must take the ownership of the newly created object, which
-		is true for all objects that have been created only for storing. You tell the archive to take
-		ownership by adding the FVariant::kOwner flag to the FVariant::type member (data.type |= FVariant::kOwner).
-		When using the PAttributes functions, this is done through a function parameter.*/
-	virtual tresult PLUGIN_API set (IAttrID attrID, const FVariant& data) = 0;
-
-	/** Store a list of data in the archive. Please note that the type of data is not mixable! So
-	    you can only store a list of integers or a list of doubles/strings/etc. You can also store a list
-		of subattributes or other objects that implement the IPersistent interface.*/	
-	virtual tresult PLUGIN_API queue (IAttrID listID, const FVariant& data) = 0;  
-
-	/** Store binary data in the archive. Parameter 'copyBytes' specifies if the passed data should be copied.
-	    The archive cannot take the ownership of binary data. Either it just references a buffer in order
-		to write it to a file (copyBytes = false) or it copies the data to its own buffers (copyBytes = true).
-		When binary data should be stored in the default pool for example, you must always copy it!*/	
-	virtual tresult PLUGIN_API setBinaryData (IAttrID attrID, void* data, uint32 bytes, bool copyBytes) = 0;
-	//@}
-
-	/*! \name Methods to read attributes 
-	******************************************************************************************************** */
-	//@{
-	/** Get data previously stored to the archive. */
-	virtual tresult PLUGIN_API get (IAttrID attrID, FVariant& data) = 0;
-
-	/** Get list of data previously stored to the archive. As long as there are queue members the method
-	    will return kResultTrue. When the queue is empty, the methods returns kResultFalse. All lists except from
-		object lists can be reset which means that the items can be read once again. \see IAttributes::resetQueue */	
-	virtual tresult PLUGIN_API unqueue (IAttrID listID, FVariant& data) = 0; 
-
-	/** Get the amount of items in a queue. */
-	virtual int32 PLUGIN_API getQueueItemCount (IAttrID) = 0;
-	
-	/** Reset a queue. If you need to restart reading a queue, you have to reset it. You can reset a queue at any time.*/
-	virtual tresult PLUGIN_API resetQueue (IAttrID attrID) = 0;
-	
-	/** Reset all queues in the archive.*/
-	virtual tresult PLUGIN_API resetAllQueues () = 0;
-
-	/** Read binary data from the archive. The data is copied into the passed buffer. The size of that buffer
-	    must fit the size of data stored in the archive which can be queried via IAttributes::getBinaryDataSize  */	
-	virtual tresult PLUGIN_API getBinaryData (IAttrID attrID, void* data, uint32 bytes) = 0;
-	/** Get the size in bytes of binary data in the archive. */	
-	virtual uint32 PLUGIN_API getBinaryDataSize (IAttrID attrID) = 0;
-	//@}
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IAttributes, 0xFA1E32F9, 0xCA6D46F5, 0xA982F956, 0xB1191B58)
-
-//------------------------------------------------------------------------
-/**  Extended access to Attributes; supports Attribute retrieval via iteration. 
-- [host imp]
-- [released] C7/N6
-
-\ingroup frameworkHostClasses
-*/
-class IAttributes2 : public IAttributes
-{
-public:
-	/** Returns the number of existing attributes. */
-	virtual int32 PLUGIN_API countAttributes () const = 0;
-	/** Returns the attribute's ID for the given index. */
-	virtual IAttrID PLUGIN_API getAttributeID (int32 index) const = 0;
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IAttributes2, 0x1382126A, 0xFECA4871, 0x97D52A45, 0xB042AE99)
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/base/ipluginbase.h

@@ -1,425 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/ipluginbase.h
-// Created by  : Steinberg, 01/2004
-// Description : Basic Plug-in Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "funknown.h"
-#include "fstrdefs.h"
-
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-/**  Basic interface to a plug-in component: IPluginBase
-\ingroup pluginBase
-- [plug imp]
-- initialize/terminate the plug-in component
-
-The host uses this interface to initialize and to terminate the plug-in component.
-The context that is passed to the initialize method contains any interface to the
-host that the plug-in will need to work. These interfaces can vary from category to category.
-A list of supported host context interfaces should be included in the documentation
-of a specific category. 
-*/
-class IPluginBase: public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** The host passes a number of interfaces as context to initialize the plug-in class.
-		@note Extensive memory allocations etc. should be performed in this method rather than in the class' constructor!
-		If the method does NOT return kResultOk, the object is released immediately. In this case terminate is not called! */
-	virtual tresult PLUGIN_API initialize (FUnknown* context) = 0;
-
-	/** This function is called before the plug-in is unloaded and can be used for
-	    cleanups. You have to release all references to any host application interfaces. */
-	virtual tresult PLUGIN_API terminate () = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IPluginBase, 0x22888DDB, 0x156E45AE, 0x8358B348, 0x08190625)
-
-
-//------------------------------------------------------------------------
-/** Basic Information about the class factory of the plug-in.
-\ingroup pluginBase
-*/
-struct PFactoryInfo
-{
-//------------------------------------------------------------------------
-	enum FactoryFlags
-	{
-		kNoFlags					= 0,		///< Nothing
-		kClassesDiscardable			= 1 << 0,	///< The number of exported classes can change each time the Module is loaded. If this flag is set, the host does not cache class information. This leads to a longer startup time because the host always has to load the Module to get the current class information.
-		kLicenseCheck				= 1 << 1,	///< Class IDs of components are interpreted as Syncrosoft-License (LICENCE_UID). Loaded in a Steinberg host, the module will not be loaded when the license is not valid
-		kComponentNonDiscardable	= 1 << 3,	///< Component will not be unloaded until process exit
-		kUnicode                    = 1 << 4    ///< Components have entirely unicode encoded strings. (True for VST 3 plug-ins so far)
-	};
-
-	enum
-	{
-		kURLSize = 256,
-		kEmailSize = 128,
-		kNameSize = 64
-	};
-
-//------------------------------------------------------------------------
-	char8 vendor[kNameSize];		///< e.g. "Steinberg Media Technologies"
-	char8 url[kURLSize];			///< e.g. "http://www.steinberg.de"
-	char8 email[kEmailSize];		///< e.g. "info@steinberg.de"
-	int32 flags;				///< (see above)
-//------------------------------------------------------------------------
-	PFactoryInfo (const char8* _vendor, const char8* _url, const char8* _email, int32 _flags)
-	{
-		strncpy8 (vendor, _vendor, kNameSize);
-		strncpy8 (url, _url, kURLSize);
-		strncpy8 (email, _email, kEmailSize);
-		flags = _flags;
-#ifdef UNICODE
-		flags |= kUnicode;
-#endif
-	}
-#if SMTG_CPP11
-	constexpr PFactoryInfo () : vendor (), url (), email (), flags () {}
-#else
-	PFactoryInfo () { memset (this, 0, sizeof (PFactoryInfo)); }
-#endif
-};
-
-//------------------------------------------------------------------------
-/**  Basic Information about a class provided by the plug-in.
-\ingroup pluginBase
-*/
-struct PClassInfo
-{
-//------------------------------------------------------------------------
-	enum ClassCardinality
-	{
-		kManyInstances = 0x7FFFFFFF
-	};
-
-	enum
-	{
-		kCategorySize = 32,
-		kNameSize = 64
-	};
-//------------------------------------------------------------------------
-	TUID cid;                       ///< Class ID 16 Byte class GUID
-	int32 cardinality;              ///< cardinality of the class, set to kManyInstances (see \ref ClassCardinality)
-	char8 category[kCategorySize];  ///< class category, host uses this to categorize interfaces
-	char8 name[kNameSize];          ///< class name, visible to the user
-//------------------------------------------------------------------------
-
-	PClassInfo (const TUID _cid, int32 _cardinality, const char8* _category, const char8* _name)
-	{
-		memset (this, 0, sizeof (PClassInfo));
-		memcpy (cid, _cid, sizeof (TUID));
-		if (_category)
-			strncpy8 (category, _category, kCategorySize);
-		if (_name)
-			strncpy8 (name, _name, kNameSize);
-		cardinality = _cardinality;
-	}
-#if SMTG_CPP11
-	constexpr PClassInfo () : cid (), cardinality (), category (), name () {}
-#else
-	PClassInfo () { memset (this, 0, sizeof (PClassInfo)); }
-#endif
-};
-
-//------------------------------------------------------------------------
-//  IPluginFactory interface declaration
-//------------------------------------------------------------------------
-/**	Class factory that any plug-in defines for creating class instances: IPluginFactory
-\ingroup pluginBase
-- [plug imp]
-
-From the host's point of view a plug-in module is a factory which can create
-a certain kind of object(s). The interface IPluginFactory provides methods
-to get information about the classes exported by the plug-in and a
-mechanism to create instances of these classes (that usually define the IPluginBase interface).
-
-<b> An implementation is provided in public.sdk/source/common/pluginfactory.cpp </b>
-\see GetPluginFactory
-*/
-class IPluginFactory : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Fill a PFactoryInfo structure with information about the plug-in vendor. */
-	virtual tresult PLUGIN_API getFactoryInfo (PFactoryInfo* info) = 0;
-
-	/** Returns the number of exported classes by this factory.
-	If you are using the CPluginFactory implementation provided by the SDK, it returns the number of classes you registered with CPluginFactory::registerClass. */
-	virtual int32 PLUGIN_API countClasses () = 0;
-
-	/** Fill a PClassInfo structure with information about the class at the specified index. */
-	virtual tresult PLUGIN_API getClassInfo (int32 index, PClassInfo* info) = 0;
-
-	/** Create a new class instance. */
-	virtual tresult PLUGIN_API createInstance (FIDString cid, FIDString _iid, void** obj) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IPluginFactory, 0x7A4D811C, 0x52114A1F, 0xAED9D2EE, 0x0B43BF9F)
-
-
-//------------------------------------------------------------------------
-/**  Version 2 of Basic Information about a class provided by the plug-in.
-\ingroup pluginBase
-*/
-struct PClassInfo2
-{
-//------------------------------------------------------------------------
-	TUID cid;									///< Class ID 16 Byte class GUID
-	int32 cardinality;							///< cardinality of the class, set to kManyInstances (see \ref PClassInfo::ClassCardinality)
-	char8 category[PClassInfo::kCategorySize];	///< class category, host uses this to categorize interfaces
-	char8 name[PClassInfo::kNameSize];			///< class name, visible to the user
-
-	enum {
-		kVendorSize = 64,
-		kVersionSize = 64,
-		kSubCategoriesSize = 128
-	};
-
-	uint32 classFlags;				///< flags used for a specific category, must be defined where category is defined
-	char8 subCategories[kSubCategoriesSize];	///< module specific subcategories, can be more than one, logically added by the \c OR operator
-	char8 vendor[kVendorSize];		///< overwrite vendor information from factory info
-	char8 version[kVersionSize];	///< Version string (e.g. "1.0.0.512" with Major.Minor.Subversion.Build)
-	char8 sdkVersion[kVersionSize];	///< SDK version used to build this class (e.g. "VST 3.0")
-
-//------------------------------------------------------------------------
-
-	PClassInfo2 (const TUID _cid, int32 _cardinality, const char8* _category, const char8* _name,
-		int32 _classFlags, const char8* _subCategories, const char8* _vendor, const char8* _version,
-		const char8* _sdkVersion)
-	{
-		memset (this, 0, sizeof (PClassInfo2));
-		memcpy (cid, _cid, sizeof (TUID));
-		cardinality = _cardinality;
-		if (_category)
-			strncpy8 (category, _category, PClassInfo::kCategorySize);
-		if (_name)
-			strncpy8 (name, _name, PClassInfo::kNameSize);
-		classFlags = static_cast<uint32> (_classFlags);
-		if (_subCategories)
-			strncpy8 (subCategories, _subCategories, kSubCategoriesSize);
-		if (_vendor)
-			strncpy8 (vendor, _vendor, kVendorSize);
-		if (_version)
-			strncpy8 (version, _version, kVersionSize);
-		if (_sdkVersion)
-			strncpy8 (sdkVersion, _sdkVersion, kVersionSize);
-	}
-#if SMTG_CPP11
-	constexpr PClassInfo2 ()
-	: cid ()
-	, cardinality ()
-	, category ()
-	, name ()
-	, classFlags ()
-	, subCategories ()
-	, vendor ()
-	, version ()
-	, sdkVersion ()
-	{
-	}
-#else
-	PClassInfo2 () { memset (this, 0, sizeof (PClassInfo2)); }
-#endif
-};
-
-//------------------------------------------------------------------------
-//  IPluginFactory2 interface declaration
-//------------------------------------------------------------------------
-/**	Version 2 of class factory supporting PClassInfo2: IPluginFactory2
-\ingroup pluginBase
-\copydoc IPluginFactory
-*/
-class IPluginFactory2 : public IPluginFactory
-{
-public:
-//------------------------------------------------------------------------
-	/** Returns the class info (version 2) for a given index. */
-	virtual tresult PLUGIN_API getClassInfo2 (int32 index, PClassInfo2* info) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-DECLARE_CLASS_IID (IPluginFactory2, 0x0007B650, 0xF24B4C0B, 0xA464EDB9, 0xF00B2ABB)
-
-
-//------------------------------------------------------------------------
-/** Unicode Version of Basic Information about a class provided by the plug-in
-*/
-struct PClassInfoW
-{
-//------------------------------------------------------------------------
-	TUID cid;							///< see \ref PClassInfo
-	int32 cardinality;					///< see \ref PClassInfo
-	char8 category[PClassInfo::kCategorySize];	///< see \ref PClassInfo
-	char16 name[PClassInfo::kNameSize];	///< see \ref PClassInfo
-
-	enum {
-		kVendorSize = 64,
-		kVersionSize = 64,
-		kSubCategoriesSize = 128
-	};
-
-	uint32 classFlags;					///< flags used for a specific category, must be defined where category is defined
-	char8 subCategories[kSubCategoriesSize];///< module specific subcategories, can be more than one, logically added by the \c OR operator
-	char16 vendor[kVendorSize];			///< overwrite vendor information from factory info
-	char16 version[kVersionSize];		///< Version string (e.g. "1.0.0.512" with Major.Minor.Subversion.Build)
-	char16 sdkVersion[kVersionSize];	///< SDK version used to build this class (e.g. "VST 3.0")
-
-//------------------------------------------------------------------------
-	PClassInfoW (const TUID _cid, int32 _cardinality, const char8* _category, const char16* _name,
-		int32 _classFlags, const char8* _subCategories, const char16* _vendor, const char16* _version,
-		const char16* _sdkVersion)
-	{
-		memset (this, 0, sizeof (PClassInfoW));
-		memcpy (cid, _cid, sizeof (TUID));
-		cardinality = _cardinality;
-		if (_category)
-			strncpy8 (category, _category, PClassInfo::kCategorySize);
-		if (_name)
-			strncpy16 (name, _name, PClassInfo::kNameSize);
-		classFlags = static_cast<uint32> (_classFlags);
-		if (_subCategories)
-			strncpy8 (subCategories, _subCategories, kSubCategoriesSize);
-		if (_vendor)
-			strncpy16 (vendor, _vendor, kVendorSize);
-		if (_version)
-			strncpy16 (version, _version, kVersionSize);
-		if (_sdkVersion)
-			strncpy16 (sdkVersion, _sdkVersion, kVersionSize);
-	}
-#if SMTG_CPP11
-	constexpr PClassInfoW ()
-	: cid ()
-	, cardinality ()
-	, category ()
-	, name ()
-	, classFlags ()
-	, subCategories ()
-	, vendor ()
-	, version ()
-	, sdkVersion ()
-	{
-	}
-#else
-	PClassInfoW () { memset (this, 0, sizeof (PClassInfoW)); }
-#endif
-
-	void fromAscii (const PClassInfo2& ci2)
-	{
-		memcpy (cid, ci2.cid, sizeof (TUID));
-		cardinality = ci2.cardinality;
-		strncpy8 (category, ci2.category, PClassInfo::kCategorySize);
-		str8ToStr16 (name, ci2.name, PClassInfo::kNameSize);
-		classFlags = ci2.classFlags;
-		strncpy8 (subCategories, ci2.subCategories, kSubCategoriesSize);
-
-		str8ToStr16 (vendor, ci2.vendor, kVendorSize);
-		str8ToStr16 (version, ci2.version, kVersionSize);
-		str8ToStr16 (sdkVersion, ci2.sdkVersion, kVersionSize);
-	}
-};
-
-//------------------------------------------------------------------------
-//  IPluginFactory3 interface declaration
-//------------------------------------------------------------------------
-/**	Version 3 of class factory supporting PClassInfoW: IPluginFactory3
-\ingroup pluginBase
-\copydoc IPluginFactory
-*/
-class IPluginFactory3 : public IPluginFactory2
-{
-public:
-//------------------------------------------------------------------------
-	/** Returns the unicode class info for a given index. */
-	virtual tresult PLUGIN_API getClassInfoUnicode (int32 index, PClassInfoW* info) = 0;
-
-	/** Receives information about host*/
-	virtual tresult PLUGIN_API setHostContext (FUnknown* context) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-DECLARE_CLASS_IID (IPluginFactory3, 0x4555A2AB, 0xC1234E57, 0x9B122910, 0x36878931)
-//------------------------------------------------------------------------
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#define LICENCE_UID(l1, l2, l3, l4) \
-{ \
-	(int8)((l1 & 0xFF000000) >> 24), (int8)((l1 & 0x00FF0000) >> 16), \
-	(int8)((l1 & 0x0000FF00) >>  8), (int8)((l1 & 0x000000FF)      ), \
-	(int8)((l2 & 0xFF000000) >> 24), (int8)((l2 & 0x00FF0000) >> 16), \
-	(int8)((l2 & 0x0000FF00) >>  8), (int8)((l2 & 0x000000FF)      ), \
-	(int8)((l3 & 0xFF000000) >> 24), (int8)((l3 & 0x00FF0000) >> 16), \
-	(int8)((l3 & 0x0000FF00) >>  8), (int8)((l3 & 0x000000FF)      ), \
-	(int8)((l4 & 0xFF000000) >> 24), (int8)((l4 & 0x00FF0000) >> 16), \
-	(int8)((l4 & 0x0000FF00) >>  8), (int8)((l4 & 0x000000FF)      )  \
-}
-
-//------------------------------------------------------------------------
-// GetPluginFactory
-//------------------------------------------------------------------------
-/**  Plug-in entry point.
-\ingroup pluginBase
-Any plug-in must define and export this function. \n
-A typical implementation of GetPluginFactory looks like this
-\code{.cpp}
-SMTG_EXPORT_SYMBOL IPluginFactory* PLUGIN_API GetPluginFactory ()
-{
-	if (!gPluginFactory)
-	{
-		static PFactoryInfo factoryInfo =
-		{
-			"My Company Name",
-			"http://www.mywebpage.com",
-			"mailto:myemail@address.com",
-			PFactoryInfo::kNoFlags
-		};
-
-		gPluginFactory = new CPluginFactory (factoryInfo);
-
-		static PClassInfo componentClass =
-		{
-			INLINE_UID (0x00000000, 0x00000000, 0x00000000, 0x00000000), // replace by a valid uid
-			1,
-			"Service",    // category
-			"Name"
-		};
-
-		gPluginFactory->registerClass (&componentClass, MyComponentClass::newInstance);
-	}
-	else
-		gPluginFactory->addRef ();
-
-	return gPluginFactory;
-}
-\endcode
-\see \ref loadPlugin
-*/
-extern "C"
-{
-	SMTG_EXPORT_SYMBOL Steinberg::IPluginFactory* PLUGIN_API GetPluginFactory ();
-	typedef Steinberg::IPluginFactory* (PLUGIN_API *GetFactoryProc) ();
-}

source/includes/vst3sdk/pluginterfaces/base/istringresult.h

@@ -1,80 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/istringresult.h
-// Created by  : Steinberg, 01/2005
-// Description : Strings Interface
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-/** Interface to return an ascii string of variable size. 
-    In order to manage memory allocation and deallocation properly, 
-	this interface is used to transfer a string as result parameter of
-	a method requires a string of unknown size. 
-- [host imp] or [plug imp]
-- [released: SX 4]
-*/
-class IStringResult : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	virtual void PLUGIN_API setText (const char8* text) = 0;    
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IStringResult, 0x550798BC, 0x872049DB, 0x84920A15, 0x3B50B7A8)
-
-
-//------------------------------------------------------------------------
-/** Interface to a string of variable size and encoding. 
-- [host imp] or [plug imp]
-- [released: ] 
-*/
-class IString : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Assign ASCII string */
-	virtual void PLUGIN_API setText8 (const char8* text) = 0;    
-	/** Assign unicode string */
-	virtual void PLUGIN_API setText16 (const char16* text) = 0;
-
-	/** Return ASCII string. If the string is unicode so far, it will be converted.
-	    So you need to be careful, because the conversion can result in data loss. 
-		It is save though to call getText8 if isWideString() returns false */
-	virtual const char8* PLUGIN_API getText8 () = 0;   
-	/** Return unicode string. If the string is ASCII so far, it will be converted. */
-	virtual const char16* PLUGIN_API getText16 () = 0;    
-
-	/** !Do not use this method! Early implementations take the given pointer as 
-	     internal string and this will cause problems because 'free' will be used to delete the passed memory.
-		 Later implementations will redirect 'take' to setText8 and setText16 */
-	virtual void PLUGIN_API take (void* s, bool isWide) = 0;
-
-	/** Returns true if the string is in unicode format, returns false if the string is ASCII */
-	virtual bool PLUGIN_API isWideString () const = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IString, 0xF99DB7A3, 0x0FC14821, 0x800B0CF9, 0x8E348EDF)
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/base/iupdatehandler.h

@@ -1,98 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : Steinberg Module Architecture SDK
-//
-// Category    : Basic Host Service Interfaces
-// Filename    : pluginterfaces/base/iupdatehandler.h
-// Created by  : Steinberg, 01/2004
-// Description : Update handling
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-
-namespace Steinberg {
-
-class IDependent;
-
-//------------------------------------------------------------------------
-/** Host implements dependency handling for plugins.
-- [host imp]
-- [get this interface from IHostClasses]
-- [released N3.1]
-
-- Install/Remove change notifications
-- Trigger updates when an object has changed
-
-Can be used between host-objects and the Plug-In or 
-inside the Plug-In to handle internal updates!
-
-\see IDependent
-\ingroup frameworkHostClasses
-*/
-class IUpdateHandler: public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Install update notification for given object. It is essential to
-	    remove all dependencies again using 'removeDependent'! Dependencies
-		are not removed automatically when the 'object' is released! 
-	\param object : interface to object that sends change notifications 
-	\param dependent : interface through which the update is passed */
-	virtual tresult PLUGIN_API addDependent (FUnknown* object, IDependent* dependent) = 0;
-	
-	/** Remove a previously installed dependency.*/
-	virtual tresult PLUGIN_API removeDependent (FUnknown* object, IDependent* dependent) = 0;
-
-	/** Inform all dependents, that object has changed. 
-	\param object is the object that has changed
-	\param message is a value of enum IDependent::ChangeMessage, usually  IDependent::kChanged - can be
-	                 a private message as well (only known to sender and dependent)*/
-	virtual	tresult PLUGIN_API triggerUpdates (FUnknown* object, int32 message) = 0;
-
-	/** Same as triggerUpdates, but delivered in idle (usefull to collect updates).*/
-	virtual	tresult PLUGIN_API deferUpdates (FUnknown* object, int32 message) = 0;
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IUpdateHandler, 0xF5246D56, 0x86544d60, 0xB026AFB5, 0x7B697B37)
-
-//------------------------------------------------------------------------
-/**  A dependent will get notified about changes of a model.
-[plug imp]
-- notify changes of a model
-
-\see IUpdateHandler
-\ingroup frameworkHostClasses
-*/
-class IDependent: public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Inform the dependent, that the passed FUnknown has changed. */
-	virtual void PLUGIN_API update (FUnknown* changedUnknown, int32 message) = 0;
-
-	enum ChangeMessage 
-	{
-		kWillChange,
-		kChanged,
-		kDestroyed,
-		kWillDestroy,
-
-		kStdChangeMessageLast = kWillDestroy
-	};
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IDependent, 0xF52B7AAE, 0xDE72416d, 0x8AF18ACE, 0x9DD7BD5E)
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/base/smartpointer.h

@@ -1,384 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/smartpointer.h
-// Created by  : Steinberg, 01/2004
-// Description : Basic Interface
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/fplatform.h"
-#if SMTG_CPP11_STDLIBSUPPORT
-#include <utility>
-#endif
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-// IPtr
-//------------------------------------------------------------------------
-/**	IPtr - Smart pointer template class.
- \ingroup pluginBase
-
- - can be used as an I* pointer
- - handles refCount of the interface
- - Usage example:
- \code
-IPtr<IPath> path (sharedPath);
-if (path)
-	path->ascend ();
- \endcode
- */
-template <class I>
-class IPtr
-{
-public:
-//------------------------------------------------------------------------
-	inline IPtr (I* ptr, bool addRef = true);
-	inline IPtr (const IPtr&);
-
-	template <class T>
-	inline IPtr (const IPtr<T>& other) : ptr (other.get ())
-	{
-		if (ptr)
-			ptr->addRef ();
-	}
-
-	inline IPtr ();
-	inline ~IPtr ();
-
-	inline I* operator= (I* ptr);
-
-	inline IPtr& operator= (const IPtr& other);
-
-	template <class T>
-	inline IPtr& operator= (const IPtr<T>& other)
-	{
-		operator= (other.get ());
-		return *this;
-	}
-
-	inline operator I* () const { return ptr; } // act as I*
-	inline I* operator-> () const { return ptr; } // act as I*
-
-	inline I* get () const { return ptr; }
-
-#if SMTG_CPP11_STDLIBSUPPORT
-	inline IPtr (IPtr<I>&& movePtr) SMTG_NOEXCEPT : ptr (movePtr.take ()) { }
-	
-	template <typename T>
-	inline IPtr (IPtr<T>&& movePtr) SMTG_NOEXCEPT : ptr (movePtr.take ()) {  }
-
-	inline IPtr& operator= (IPtr<I>&& movePtr) SMTG_NOEXCEPT
-	{
-		if (ptr)
-			ptr->release ();
-
-		ptr = movePtr.take ();
-		return *this;
-	}
-	
-	template <typename T>
-	inline IPtr& operator= (IPtr<T>&& movePtr) 
-	{
-		if (ptr)
-			ptr->release ();
-		
-		ptr = movePtr.take ();
-		return *this;
-	}
-#endif
-
-	inline void reset (I* obj = nullptr) 
-	{
-		if (ptr)
-			ptr->release();
-		ptr = obj;
-	}
-
-	I* take () SMTG_NOEXCEPT 
-	{
-		I* out = ptr; 
-		ptr = nullptr; 
-		return out;
-	}
-
-	template <typename T>
-	static IPtr<T> adopt (T* obj) SMTG_NOEXCEPT { return IPtr<T> (obj, false); }
-
-//------------------------------------------------------------------------
-protected:
-	I* ptr;
-};
-
-//------------------------------------------------------------------------
-template <class I>
-inline IPtr<I>::IPtr (I* _ptr, bool addRef) : ptr (_ptr)
-{
-	if (ptr && addRef)
-		ptr->addRef ();
-}
-
-//------------------------------------------------------------------------
-template <class I>
-inline IPtr<I>::IPtr (const IPtr<I>& other) : ptr (other.ptr)
-{
-	if (ptr)
-		ptr->addRef ();
-}
-
-//------------------------------------------------------------------------
-template <class I>
-inline IPtr<I>::IPtr () : ptr (0)
-{
-}
-
-//------------------------------------------------------------------------
-template <class I>
-inline IPtr<I>::~IPtr ()
-{
-	if (ptr) 
-	{
-		ptr->release ();
-		ptr = nullptr;  //TODO_CORE: how much does this cost? is this something hiding for us?
-	}
-}
-
-//------------------------------------------------------------------------
-template <class I>
-inline I* IPtr<I>::operator= (I* _ptr)
-{
-	if (_ptr != ptr)
-	{
-		if (ptr)
-			ptr->release ();
-		ptr = _ptr;
-		if (ptr)
-			ptr->addRef ();
-	}
-	return ptr;
-}
-
-//------------------------------------------------------------------------
-template <class I>
-inline IPtr<I>& IPtr<I>::operator= (const IPtr<I>& _ptr)
-{
-	operator= (_ptr.ptr);
-	return *this;
-}
-
-//------------------------------------------------------------------------
-/** OPtr - "owning" smart pointer used for newly created FObjects.
- \ingroup pluginBase
-
- FUnknown implementations are supposed to have a refCount of 1 right after creation.
- So using an IPtr on newly created objects would lead to a leak.
- Instead the OPtr can be used in this case. \n
- Example:
- \code
- OPtr<IPath> path = FHostCreate (IPath, hostClasses);
- // no release is needed...
- \endcode
- The assignment operator takes ownership of a new object and releases the old.
- So its safe to write:
- \code
- OPtr<IPath> path = FHostCreate (IPath, hostClasses);
- path = FHostCreate (IPath, hostClasses);
- path = 0;
- \endcode
- This is the difference to using an IPtr with addRef=false.
- \code
- // DONT DO THIS:
- IPtr<IPath> path (FHostCreate (IPath, hostClasses), false);
- path = FHostCreate (IPath, hostClasses);
- path = 0;
- \endcode
- This will lead to a leak!
- */
-template <class I>
-class OPtr : public IPtr<I>
-{
-public:
-//------------------------------------------------------------------------
-	inline OPtr (I* p) : IPtr<I> (p, false) {}
-	inline OPtr (const IPtr<I>& p) : IPtr<I> (p) {}
-	inline OPtr (const OPtr<I>& p) : IPtr<I> (p) {}
-	inline OPtr () {}
-	inline I* operator= (I* _ptr)
-	{
-		if (_ptr != this->ptr)
-		{
-			if (this->ptr)
-				this->ptr->release ();
-			this->ptr = _ptr;
-		}
-		return this->ptr;
-	}
-};
-
-//------------------------------------------------------------------------
-/** Assigning newly created object to an IPtr.
- Example:
- \code
- IPtr<IPath> path = owned (FHostCreate (IPath, hostClasses));
- \endcode
- which is a slightly shorter form of writing:
- \code
- IPtr<IPath> path = OPtr<IPath> (FHostCreate (IPath, hostClasses));
- \endcode
- */
-template <class I>
-IPtr<I> owned (I* p)
-{
-	return IPtr<I> (p, false);
-}
-
-/** Assigning shared object to an IPtr.
- Example:
- \code
- IPtr<IPath> path = shared (iface.getXY ());
- \endcode
- */
-template <class I>
-IPtr<I> shared (I* p)
-{
-	return IPtr<I> (p, true);
-}
-
-#if SMTG_CPP11_STDLIBSUPPORT
-//------------------------------------------------------------------------
-// Ownership functionality
-//------------------------------------------------------------------------
-namespace SKI {
-namespace Detail {
-struct Adopt;
-} // Detail
-
-/** Strong typedef for shared reference counted objects. 
-  *	Use SKI::adopt to unwrap the provided object.
-  * @tparam T Referenced counted type.
-  */
-template <typename T>
-class Shared
-{
-	friend struct Detail::Adopt;
-	T* obj = nullptr;
-};
-
-/** Strong typedef for transferring the ownership of reference counted objects. 
-  *	Use SKI::adopt to unwrap the provided object. 
-  * After calling adopt the reference in this object is null.
-  * @tparam T Referenced counted type.
-  */
-template <typename T>
-class Owned
-{
-	friend struct Detail::Adopt;
-	T* obj = nullptr;
-};
-
-/** Strong typedef for using reference counted objects. 
-  *	Use SKI::adopt to unwrap the provided object. 
-  * After calling adopt the reference in this object is null.
-  * @tparam T Referenced counted type.
-  */
-template <typename T>
-class Used
-{
-	friend struct Detail::Adopt;
-	T* obj = nullptr;
-};
-	
-namespace Detail {
-
-struct Adopt 
-{
-	template <typename T>
-	static IPtr<T> adopt (Shared<T>& ref) 
-	{ 
-		using Steinberg::shared;
-		return shared (ref.obj); 
-	}
-
-	template <typename T>
-	static IPtr<T> adopt (Owned<T>& ref) 
-	{ 
-		using Steinberg::owned;
-		IPtr<T> out = owned (ref.obj);
-		ref.obj = nullptr;
-		return out;
-	}
-
-	template <typename T>
-	static T* adopt (Used<T>& ref)
-	{
-		return ref.obj;
-	}
-
-	template <template <typename> class OwnerType, typename T>
-	static OwnerType<T> toOwnerType (T* obj) 
-	{ 
-		OwnerType<T> out;
-		out.obj = obj;
-		return out; 
-	}
-};
-
-} // Detail
-
-/** Common function to adopt referenced counted object. 
-  *	@tparam T			Referenced counted type.
-  * @param ref			The reference to be adopted in a smart pointer.
-  */
-template <typename T>
-IPtr<T> adopt (Shared<T>& ref) { return Detail::Adopt::adopt (ref); }
-
-template <typename T>
-IPtr<T> adopt (Shared<T>&& ref) { return Detail::Adopt::adopt (ref); }
-
-/** Common function to adopt referenced counted object. 
-  *	@tparam T			Referenced counted type.
-  * @param ref			The reference to be adopted in a smart pointer.
-  */
-template <typename T>
-IPtr<T> adopt (Owned<T>& ref) { return Detail::Adopt::adopt (ref); }
-
-template <typename T>
-IPtr<T> adopt (Owned<T>&& ref) { return Detail::Adopt::adopt (ref); }
-
-/** Common function to adopt referenced counted object. 
-  *	@tparam T			Referenced counted type.
-  * @param ref			The reference to be adopted in a smart pointer.
-  */
-template <typename T>
-T* adopt (Used<T>& ref) { return Detail::Adopt::adopt (ref); }
-
-template <typename T>
-T* adopt (Used<T>&& ref) { return Detail::Adopt::adopt (ref); }
-
-/** Common function to wrap owned instances. */
-template <typename T>
-Owned<T> toOwned (T* obj) { return Detail::Adopt::toOwnerType<Owned> (obj); }
-
-/** Common function to wrap shared instances. */
-template <typename T>
-Shared<T> toShared (T* obj) { return Detail::Adopt::toOwnerType<Shared> (obj); }
-
-/** Common function to wrap used instances. */
-template <typename T>
-Used<T> toUsed (T* obj) { return Detail::Adopt::toOwnerType<Used> (obj); }
-
-//------------------------------------------------------------------------
-} // SKI
-#endif
-} // Steinberg

source/includes/vst3sdk/pluginterfaces/base/typesizecheck.h

@@ -1,55 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK Core Interfaces
-// Filename    : pluginterfaces/base/typesizecheck.h
-// Created by  : Steinberg, 08/2018
-// Description : Compile time type size check macro
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses.
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/fplatform.h"
-
-#if SMTG_CPP11
-#define SMTG_TYPE_STATIC_CHECK(Operator, Type, Platform64Size, MacOS32Size, Win32Size,             \
-                               Linux32Size)                                                        \
-	namespace {                                                                                    \
-	template <typename Type, size_t w, size_t x, size_t y, size_t z>                               \
-	struct Operator##Check##Type                                                                   \
-	{                                                                                              \
-		constexpr Operator##Check##Type ()                                                         \
-		{                                                                                          \
-			static_assert (Operator (Type) ==                                                      \
-			                   (SMTG_PLATFORM_64 ? w : SMTG_OS_MACOS ? x : SMTG_OS_LINUX ? z : y), \
-			               "Struct " #Operator " error: " #Type);                                     \
-		}                                                                                          \
-	};                                                                                             \
-	static constexpr Operator##Check##Type<Type, Platform64Size, MacOS32Size, Win32Size,           \
-	                                       Linux32Size>                                            \
-	    instance##Operator##Type;                                                                  \
-	}
-
-/** Check the size of a structure depending on compilation platform
- *	Used to check that structure sizes don't change between SDK releases.
- */
-#define SMTG_TYPE_SIZE_CHECK(Type, Platform64Size, MacOS32Size, Win32Size, Linux32Size) \
-	SMTG_TYPE_STATIC_CHECK (sizeof, Type, Platform64Size, MacOS32Size, Win32Size, Linux32Size)
-
-/** Check the alignment of a structure depending on compilation platform
- *	Used to check that structure alignments don't change between SDK releases.
- */
-#define SMTG_TYPE_ALIGN_CHECK(Type, Platform64Size, MacOS32Size, Win32Size, Linux32Size) \
-	SMTG_TYPE_STATIC_CHECK (alignof, Type, Platform64Size, MacOS32Size, Win32Size, Linux32Size)
-
-#else
-// need static_assert
-#define SMTG_TYPE_SIZE_CHECK(Type, Platform64Size, MacOS32Size, Win32Size, Linux32Size)
-#endif

source/includes/vst3sdk/pluginterfaces/base/ustring.cpp

@@ -1,275 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : Helpers
-// Filename    : pluginterfaces/base/ustring.cpp
-// Created by  : Steinberg, 12/2005
-// Description : UTF-16 String class
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#include "ustring.h"
-
-#if SMTG_OS_WINDOWS
-#include <cstdio>
-
-#ifdef _MSC_VER
-#pragma warning (disable : 4996) // deprecated functions
-#endif
-
-#elif SMTG_OS_MACOS
-#include <CoreFoundation/CoreFoundation.h>
-
-#elif SMTG_OS_LINUX
-#include <cstring>
-#include <string>
-#include <codecvt>
-#include <sstream>
-#include <locale>
-
-#include <wctype.h>
-#include <wchar.h>
-
-#endif
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-#if SMTG_OS_LINUX
-
-//------------------------------------------------------------------------
-namespace {
-
-using Converter = std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>;
-
-//------------------------------------------------------------------------
-Converter& converter ()
-{
-	static Converter instance;
-	return instance;
-}
-
-//------------------------------------------------------------------------
-} // anonymous
-
-//------------------------------------------------------------------------
-#endif // SMTG_OS_LINUX
-
-//------------------------------------------------------------------------
-/** Copy strings of different character width. */
-//------------------------------------------------------------------------
-template <class TDstChar, class TSrcChar>
-void StringCopy (TDstChar* dst, int32 dstSize, const TSrcChar* src, int32 srcSize = -1)
-{
-	int32 count = dstSize;
-	if (srcSize >= 0 && srcSize < dstSize)
-		count = srcSize;
-	for (int32 i = 0; i < count; i++)
-	{
-		dst[i] = (TDstChar)src[i];
-		if (src[i] == 0)
-			break;
-	}
-	dst[dstSize - 1] = 0;
-}
-
-//------------------------------------------------------------------------
-/** Find length of null-terminated string, i.e. StringLength (L"ABC\0") => 3 */
-//------------------------------------------------------------------------
-template <class TSrcChar>
-int32 StringLength (const TSrcChar* src, int32 srcSize = -1)
-{
-	if (srcSize == 0)
-		return 0;
-	int32 length = 0;
-	while (src[length])
-	{
-		length++;
-		if (srcSize > 0 && length >= srcSize)
-			break;
-	}
-	return length;
-}
-
-//------------------------------------------------------------------------
-// UString
-//------------------------------------------------------------------------
-int32 UString::getLength () const
-{
-	return StringLength<char16> (thisBuffer, thisSize);
-}
-
-//------------------------------------------------------------------------
-UString& UString::assign (const char16* src, int32 srcSize)
-{
-	StringCopy<char16, char16> (thisBuffer, thisSize, src, srcSize);
-	return *this;
-}
-
-//------------------------------------------------------------------------
-UString& UString::append (const char16* src, int32 srcSize)
-{
-	int32 length = getLength ();
-	StringCopy<char16, char16> (thisBuffer + length, thisSize - length, src, srcSize);
-	return *this;
-}
-
-//------------------------------------------------------------------------
-const UString& UString::copyTo (char16* dst, int32 dstSize) const
-{
-	StringCopy<char16, char16> (dst, dstSize, thisBuffer, thisSize);
-	return *this;
-}
-
-//------------------------------------------------------------------------
-UString& UString::fromAscii (const char* src, int32 srcSize)
-{
-	StringCopy<char16, char> (thisBuffer, thisSize, src, srcSize);
-	return *this;
-}
-
-//------------------------------------------------------------------------
-const UString& UString::toAscii (char* dst, int32 dstSize) const
-{
-	StringCopy<char, char16> (dst, dstSize, thisBuffer, thisSize);
-	return *this;
-}
-
-//------------------------------------------------------------------------
-bool UString::scanFloat (double& value) const
-{
-#if SMTG_OS_WINDOWS
-	return swscanf ((const wchar_t*)thisBuffer, L"%lf", &value) != -1;
-
-#elif TARGET_API_MAC_CARBON
-	CFStringRef cfStr = CFStringCreateWithBytes (0, (const UInt8 *)thisBuffer, getLength () * 2, kCFStringEncodingUTF16, false);
-	if (cfStr)
-	{
-		value = CFStringGetDoubleValue (cfStr);
-		CFRelease (cfStr);
-		return true;
-	}
-	return false;
-
-#elif SMTG_OS_LINUX
-	auto str = converter ().to_bytes (thisBuffer);
-	return sscanf (str.data (), "%lf", &value) == 1;
-
-#else
-#warning Implement me
-	// implement me!
-	return false;
-#endif
-}
-
-//------------------------------------------------------------------------
-bool UString::printFloat (double value, int32 precision)
-{
-#if SMTG_OS_WINDOWS
-	return swprintf ((wchar_t*)thisBuffer, L"%.*lf", precision, value) != -1;
-#elif SMTG_OS_MACOS
-	bool result = false;
-	CFStringRef cfStr = CFStringCreateWithFormat (0, 0, CFSTR("%.*lf"), precision, value);
-	if (cfStr)
-	{
-		memset (thisBuffer, 0, thisSize);
-		CFRange range = {0, CFStringGetLength (cfStr)};
-		CFStringGetBytes (cfStr, range, kCFStringEncodingUTF16, 0, false, (UInt8*)thisBuffer, thisSize, 0);
-		CFRelease (cfStr);
-		return true;
-	}
-	return result;
-#elif SMTG_OS_LINUX
-	auto utf8Buffer = reinterpret_cast<char*> (thisBuffer);
-	auto len = snprintf (utf8Buffer, thisSize, "%.*lf", precision, value);
-	if (len > 0)
-	{
-		auto utf16Buffer = reinterpret_cast<char16*> (thisBuffer);
-		utf16Buffer[len] = 0;
-		while (--len >= 0)
-		{
-			utf16Buffer[len] = utf8Buffer[len];
-		}
-		return true;
-	}
-	return false;
-#else
-#warning Implement me
-	// implement me!
-	return false;
-#endif
-}
-
-//------------------------------------------------------------------------
-bool UString::scanInt (int64& value) const
-{
-#if SMTG_OS_WINDOWS
-	return swscanf ((const wchar_t*)thisBuffer, L"%I64d", &value) != -1;
-
-#elif SMTG_OS_MACOS
-	CFStringRef cfStr = CFStringCreateWithBytes (0, (const UInt8 *)thisBuffer, getLength () * 2, kCFStringEncodingUTF16, false);
-	if (cfStr)
-	{
-		value = CFStringGetIntValue (cfStr);
-		CFRelease (cfStr);
-		return true;
-	}
-	return false;
-
-#elif SMTG_OS_LINUX
-	auto str = converter ().to_bytes (thisBuffer);
-	return sscanf (str.data (), "%lld", &value) == 1;
-
-#else
-#warning Implement me
-	// implement me!
-	return false;
-#endif
-}
-
-//------------------------------------------------------------------------
-bool UString::printInt (int64 value)
-{
-#if SMTG_OS_WINDOWS
-	return swprintf ((wchar_t*)thisBuffer, L"%I64d", value) != -1;
-
-#elif SMTG_OS_MACOS
-	CFStringRef cfStr = CFStringCreateWithFormat (0, 0, CFSTR("%lld"), value);
-	if (cfStr)
-	{
-		memset (thisBuffer, 0, thisSize);
-		CFRange range = {0, CFStringGetLength (cfStr)};
-		CFStringGetBytes (cfStr, range, kCFStringEncodingUTF16, 0, false, (UInt8*)thisBuffer, thisSize, 0);
-		CFRelease (cfStr);
-		return true;
-	}
-	return false;
-#elif SMTG_OS_LINUX
-	auto utf8Buffer = reinterpret_cast<char*> (thisBuffer);
-	auto len = snprintf (utf8Buffer, thisSize, "%lld", value);
-	if (len > 0)
-	{
-		auto utf16Buffer = reinterpret_cast<char16*> (thisBuffer);
-		utf16Buffer[len] = 0;
-		while (--len >= 0)
-		{
-			utf16Buffer[len] = utf8Buffer[len];
-		}
-		return true;
-	}
-	return false;
-
-#else
-#warning Implement me
-	// implement me!
-	return false;
-#endif
-}
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/base/ustring.h

@@ -1,116 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : Helpers
-// Filename    : pluginterfaces/base/ustring.h
-// Created by  : Steinberg, 12/2005
-// Description : UTF-16 String class
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "ftypes.h"
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-/** UTF-16 string class without buffer management.
- Note: that some characters are encoded in 2 UTF16 code units (surrogate pair),
- this means that getLength returns the number of code unit, not the count of character! */
-class UString
-{
-public:
-//------------------------------------------------------------------------
-	/** Construct from UTF-16 string, size is in code unit (count of char16) */
-	UString (char16* buffer, int32 size) : thisBuffer (buffer), thisSize (size) {}
-
-	/** returns buffer size */
-	int32 getSize () const { return thisSize; }
-	
-	/** cast to char16* */
-	operator const char16* () const { return thisBuffer; }
-
-	/** Returns length of string (in code unit). Note this is not the count of character! */
-	int32 getLength () const;
-
-	/** Copy from UTF-16 buffer (srcSize is in code unit (count of char16)). */
-	UString& assign (const char16* src, int32 srcSize = -1);
-
-	/** Append UTF-16 buffer (srcSize is in code unit (count of char16)). */
-	UString& append (const char16* src, int32 srcSize = -1);
-
-	/** Copy to UTF-16 buffer (dstSize is in code unit (count of char16)). */
-	const UString& copyTo (char16* dst, int32 dstSize) const;
-
-	/** Copy from ASCII string (srcSize is in code unit (count of char16)). */
-	UString& fromAscii (const char* src, int32 srcSize = -1);
-	UString& assign (const char* src, int32 srcSize = -1) { return fromAscii (src, srcSize); }
-
-	/** Copy to ASCII string. */
-	const UString& toAscii (char* dst, int32 dstSize) const;
-
-	/** Scan integer from string. */
-	bool scanInt (int64& value) const;
-
-	/** Print integer to string. */
-	bool printInt (int64 value);
-
-	/** Scan float from string. */
-	bool scanFloat (double& value) const;
-
-	/** Print float to string. */
-	bool printFloat (double value, int32 precision = 4);
-//------------------------------------------------------------------------
-protected:
-	char16* thisBuffer;
-	int32 thisSize; ///< size in code unit (not in byte!)
-};
-
-//------------------------------------------------------------------------
-/** UTF-16 string with fixed buffer size.
- */
-template <int32 maxSize>
-class UStringBuffer : public UString
-{
-public:
-//------------------------------------------------------------------------
-	UStringBuffer () : UString (data, maxSize) { data[0] = 0; }
-
-	/** Construct from UTF-16 string. */
-	UStringBuffer (const char16* src, int32 srcSize = -1) : UString (data, maxSize)
-	{
-		data[0] = 0;
-		if (src)
-			assign (src, srcSize);
-	}
-
-	/** Construct from ASCII string. */
-	UStringBuffer (const char* src, int32 srcSize = -1) : UString (data, maxSize)
-	{
-		data[0] = 0;
-		if (src)
-			fromAscii (src, srcSize);
-	}
-//------------------------------------------------------------------------
-protected:
-	char16 data[maxSize];
-};
-
-//------------------------------------------------------------------------
-typedef UStringBuffer<128> UString128; ///< 128 character UTF-16 string
-typedef UStringBuffer<256> UString256; ///< 256 character UTF-16 string
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#define USTRING(asciiString) Steinberg::UString256 (asciiString)
-#define USTRINGSIZE(var) (sizeof (var) / sizeof (Steinberg::char16))
-
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/gui/iplugview.h

@@ -1,283 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK GUI Interfaces
-// Filename    : pluginterfaces/gui/iplugview.h
-// Created by  : Steinberg, 12/2007
-// Description : Plug-in User Interface
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses.
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/base/typesizecheck.h"
-
-namespace Steinberg {
-
-class IPlugFrame;
-
-//------------------------------------------------------------------------
-/*! \defgroup pluginGUI Graphical User Interface
-*/
-
-//------------------------------------------------------------------------
-/**  Graphical rectangle structure. Used with IPlugView.
-\ingroup pluginGUI
-*/
-struct ViewRect
-{
-	ViewRect (int32 l = 0, int32 t = 0, int32 r = 0, int32 b = 0)
-	: left (l), top (t), right (r), bottom (b)
-	{
-	}
-
-	int32 left;
-	int32 top;
-	int32 right;
-	int32 bottom;
-
-	//--- ---------------------------------------------------------------------
-	int32 getWidth () const { return right - left; }
-	int32 getHeight () const { return bottom - top; }
-};
-
-SMTG_TYPE_SIZE_CHECK (ViewRect, 16, 16, 16, 16)
-
-//------------------------------------------------------------------------
-/**  \defgroup platformUIType Platform UI Types
-\ingroup pluginGUI
-List of Platform UI types for IPlugView. This list is used to match the GUI-System between
-the host and a plug-in in case that an OS provides multiple GUI-APIs.
-*/
-/*@{*/
-/** The parent parameter in IPlugView::attached() is a HWND handle.
- *	You should attach a child window to it. */
-const FIDString kPlatformTypeHWND = "HWND"; ///< HWND handle. (Microsoft Windows)
-
-/** The parent parameter in IPlugView::attached() is a WindowRef.
- *	You should attach a HIViewRef to the content view of the window. */
-const FIDString kPlatformTypeHIView = "HIView"; ///< HIViewRef. (Mac OS X)
-
-/** The parent parameter in IPlugView::attached() is a NSView pointer.
- * You should attach a NSView to it. */
-const FIDString kPlatformTypeNSView = "NSView"; ///< NSView pointer. (Mac OS X)
-
-/** The parent parameter in IPlugView::attached() is a UIView pointer.
- * You should attach an UIView to it. */
-const FIDString kPlatformTypeUIView = "UIView"; ///< UIView pointer. (iOS)
-
-/** The parent parameter in IPlugView::attached() is a X11 Window supporting XEmbed.
- * You should attach a Window to it that supports the XEmbed extension.
- * See https://standards.freedesktop.org/xembed-spec/xembed-spec-latest.html */
-const FIDString kPlatformTypeX11EmbedWindowID = "X11EmbedWindowID"; ///< X11 Window ID. (X11)
-
-/*@}*/
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-/**  Plug-in definition of a view.
-\ingroup pluginGUI vstIPlug vst300
-- [plug imp]
-- [released: 3.0.0]
-
-\par Sizing of a view
-Usually, the size of a plug-in view is fixed. But both the host and the plug-in can cause
-a view to be resized:
-\n
-- \b Host: If IPlugView::canResize () returns kResultTrue the host will set up the window
-  so that the user can resize it. While the user resizes the window,
-  IPlugView::checkSizeConstraint () is called, allowing the plug-in to change the size to a valid
-  a valid supported rectangle size. The host then resizes the window to this rect and has to call IPlugView::onSize ().
-\n
-\n
-- \b Plug-in: The plug-in can call IPlugFrame::resizeView () and cause the host to resize the
-  window.\n\n
-  Afterwards, in the same callstack, the host has to call IPlugView::onSize () if a resize is needed (size was changed).
-  Note that if the host calls IPlugView::getSize () before calling IPlugView::onSize () (if needed),
-  it will get the current (old) size not the wanted one!!\n
-  Here the calling sequence:\n
-    - plug-in->host: IPlugFrame::resizeView (newSize)
-	- host->plug-in (optional): IPlugView::getSize () returns the currentSize (not the newSize!)
-	- host->plug-in: if newSize is different from the current size: IPlugView::onSize (newSize)
-    - host->plug-in (optional): IPlugView::getSize () returns the newSize
-\n
-<b>Please only resize the platform representation of the view when IPlugView::onSize () is
-called.</b>
-
-\par Keyboard handling
-The plug-in view receives keyboard events from the host. A view implementation must not handle
-keyboard events by the means of platform callbacks, but let the host pass them to the view. The host
-depends on a proper return value when IPlugView::onKeyDown is called, otherwise the plug-in view may
-cause a malfunction of the host's key command handling.
-
-\see IPlugFrame, \ref platformUIType
-*/
-class IPlugView : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Is Platform UI Type supported
-	    \param type : IDString of \ref platformUIType */
-	virtual tresult PLUGIN_API isPlatformTypeSupported (FIDString type) = 0;
-
-	/** The parent window of the view has been created, the (platform) representation of the view
-		should now be created as well.
-	    Note that the parent is owned by the caller and you are not allowed to alter it in any way
-		other than adding your own views.
-	    Note that in this call the plug-in could call a IPlugFrame::resizeView ()!
-	    \param parent : platform handle of the parent window or view
-	    \param type : \ref platformUIType which should be created */
-	virtual tresult PLUGIN_API attached (void* parent, FIDString type) = 0;
-
-	/** The parent window of the view is about to be destroyed.
-	    You have to remove all your own views from the parent window or view. */
-	virtual tresult PLUGIN_API removed () = 0;
-
-	/** Handling of mouse wheel. */
-	virtual tresult PLUGIN_API onWheel (float distance) = 0;
-
-	/** Handling of keyboard events : Key Down.
-	    \param key : unicode code of key
-	    \param keyCode : virtual keycode for non ascii keys - see \ref VirtualKeyCodes in keycodes.h
-	    \param modifiers : any combination of modifiers - see \ref KeyModifier in keycodes.h
-	    \return kResultTrue if the key is handled, otherwise kResultFalse. \n
-	            <b> Please note that kResultTrue must only be returned if the key has really been
-	   handled. </b> Otherwise key command handling of the host might be blocked! */
-	virtual tresult PLUGIN_API onKeyDown (char16 key, int16 keyCode, int16 modifiers) = 0;
-
-	/** Handling of keyboard events : Key Up.
-	    \param key : unicode code of key
-	    \param keyCode : virtual keycode for non ascii keys - see \ref VirtualKeyCodes in keycodes.h
-	    \param modifiers : any combination of KeyModifier - see \ref KeyModifier in keycodes.h
-	    \return kResultTrue if the key is handled, otherwise return kResultFalse. */
-	virtual tresult PLUGIN_API onKeyUp (char16 key, int16 keyCode, int16 modifiers) = 0;
-
-	/** Returns the size of the platform representation of the view. */
-	virtual tresult PLUGIN_API getSize (ViewRect* size) = 0;
-
-	/** Resizes the platform representation of the view to the given rect. Note that if the plug-in
-	 *	requests a resize (IPlugFrame::resizeView ()) onSize has to be called afterward. */
-	virtual tresult PLUGIN_API onSize (ViewRect* newSize) = 0;
-
-	/** Focus changed message. */
-	virtual tresult PLUGIN_API onFocus (TBool state) = 0;
-
-	/** Sets IPlugFrame object to allow the plug-in to inform the host about resizing. */
-	virtual tresult PLUGIN_API setFrame (IPlugFrame* frame) = 0;
-
-	/** Is view sizable by user. */
-	virtual tresult PLUGIN_API canResize () = 0;
-
-	/** On live resize this is called to check if the view can be resized to the given rect, if not
-	 *	adjust the rect to the allowed size. */
-	virtual tresult PLUGIN_API checkSizeConstraint (ViewRect* rect) = 0;
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IPlugView, 0x5BC32507, 0xD06049EA, 0xA6151B52, 0x2B755B29)
-
-//------------------------------------------------------------------------
-/** Callback interface passed to IPlugView.
-\ingroup pluginGUI vstIHost vst300
-- [host imp]
-- [released: 3.0.0]
-- [mandatory]
-
-Enables a plug-in to resize the view and cause the host to resize the window.
-*/
-class IPlugFrame : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Called to inform the host about the resize of a given view.
-	 *	Afterwards the host has to call IPlugView::onSize (). */
-	virtual tresult PLUGIN_API resizeView (IPlugView* view, ViewRect* newSize) = 0;
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IPlugFrame, 0x367FAF01, 0xAFA94693, 0x8D4DA2A0, 0xED0882A3)
-
-#if SMTG_OS_LINUX
-//------------------------------------------------------------------------
-namespace Linux {
-
-using TimerInterval = uint64;
-using FileDescriptor = int;
-
-//------------------------------------------------------------------------
-/** Linux event handler interface
-\ingroup pluginGUI vst368
-- [plug imp]
-- [released: 3.6.8]
-\see IRunLoop
-*/
-class IEventHandler : public FUnknown
-{
-public:
-	virtual void PLUGIN_API onFDIsSet (FileDescriptor fd) = 0;
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-DECLARE_CLASS_IID (IEventHandler, 0x561E65C9, 0x13A0496F, 0x813A2C35, 0x654D7983)
-
-//------------------------------------------------------------------------
-/** Linux timer handler interface
-\ingroup pluginGUI vst368
-- [plug imp]
-- [released: 3.6.8]
-\see IRunLoop
-*/
-class ITimerHandler : public FUnknown
-{
-public:
-	virtual void PLUGIN_API onTimer () = 0;
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-DECLARE_CLASS_IID (ITimerHandler, 0x10BDD94F, 0x41424774, 0x821FAD8F, 0xECA72CA9)
-
-//------------------------------------------------------------------------
-/** Linux host run loop interface
-\ingroup pluginGUI vst368
-- [host imp]
-- [extends IPlugFrame]
-- [released: 3.6.8]
-
-On Linux the host has to provide this interface to the plug-in as there's no global event run loop
-defined as on other platforms.
-
-A plug-in can register an event handler for a file descriptor. The host has to call the event
-handler when the file descriptor is marked readable.
-
-A plug-in also can register a timer which will be called repeatedly until it is unregistered.
-*/
-class IRunLoop : public FUnknown
-{
-public:
-	virtual tresult PLUGIN_API registerEventHandler (IEventHandler* handler, FileDescriptor fd) = 0;
-	virtual tresult PLUGIN_API unregisterEventHandler (IEventHandler* handler) = 0;
-
-	virtual tresult PLUGIN_API registerTimer (ITimerHandler* handler,
-											  TimerInterval milliseconds) = 0;
-	virtual tresult PLUGIN_API unregisterTimer (ITimerHandler* handler) = 0;
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-DECLARE_CLASS_IID (IRunLoop, 0x18C35366, 0x97764F1A, 0x9C5B8385, 0x7A871389)
-
-//------------------------------------------------------------------------
-} // namespace Linux
-
-#endif
-
-//------------------------------------------------------------------------
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/gui/iplugviewcontentscalesupport.h

@@ -1,67 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : SDK GUI Interfaces
-// Filename    : pluginterfaces/gui/iplugviewcontentscalesupport.h
-// Created by  : Steinberg, 06/2016
-// Description : Plug-in User Interface Scaling
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-/** Plug-in view content scale support
-\ingroup pluginGUI vstIPlug vst366
-- [plug impl]
-- [extends IPlugView]
-- [released: 3.6.6]
-- [optional]
-
-This interface communicates the content scale factor from the host to the plug-in view on
-systems where plug-ins cannot get this information directly like Microsoft Windows.
-
-The host calls setContentScaleFactor directly after the plug-in view is attached and when the scale
-factor changes (system change or window moved to another screen with different scaling settings).
-The host could call setContentScaleFactor in a different context, for example: scaling the
-plug-in editor for better readability.
-When a plug-in handles this (by returning kResultTrue), it needs to scale the width and height of
-its view by the scale factor and inform the host via a IPlugFrame::resizeView(), the host will then
-call IPlugView::onSize().
-
-Note that the host is allowed to call setContentScaleFactor() at any time the IPlugView is valid.
- */
-class IPlugViewContentScaleSupport : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	typedef float ScaleFactor;
-
-	virtual tresult PLUGIN_API setContentScaleFactor (ScaleFactor factor) = 0;
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IPlugViewContentScaleSupport, 0x65ED9690, 0x8AC44525, 0x8AADEF7A, 0x72EA703F)
-
-//------------------------------------------------------------------------
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstattributes.h

@@ -1,150 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstattributes.h
-// Created by  : Steinberg, 05/2006
-// Description : VST Attribute Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Attribute list used in IMessage and IStreamAttributes: Vst::IAttributeList
-\ingroup vstIHost vst300
-- [host imp]
-- [released: 3.0.0]
-- [mandatory]
-
-An attribute list associates values with a key (id: some predefined keys can be found in \ref
-presetAttributes).
-*/
-class IAttributeList : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	typedef const char* AttrID;
-
-	/** Sets integer value. */
-	virtual tresult PLUGIN_API setInt (AttrID id, int64 value) = 0;
-
-	/** Gets integer value. */
-	virtual tresult PLUGIN_API getInt (AttrID id, int64& value) = 0;
-
-	/** Sets float value. */
-	virtual tresult PLUGIN_API setFloat (AttrID id, double value) = 0;
-
-	/** Gets float value. */
-	virtual tresult PLUGIN_API getFloat (AttrID id, double& value) = 0;
-
-	/** Sets string value (UTF16) (should be null-terminated!). */
-	virtual tresult PLUGIN_API setString (AttrID id, const TChar* string) = 0;
-
-	/** Gets string value (UTF16). Note that Size is in Byte, not the string Length!
-		Do not forget to multiply the length by sizeof (TChar)! */
-	virtual tresult PLUGIN_API getString (AttrID id, TChar* string, uint32 sizeInBytes) = 0;
-
-	/** Sets binary data. */
-	virtual tresult PLUGIN_API setBinary (AttrID id, const void* data, uint32 sizeInBytes) = 0;
-
-	/** Gets binary data. */
-	virtual tresult PLUGIN_API getBinary (AttrID id, const void*& data, uint32& sizeInBytes) = 0;
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IAttributeList, 0x1E5F0AEB, 0xCC7F4533, 0xA2544011, 0x38AD5EE4)
-
-//------------------------------------------------------------------------
-/** Meta attributes of a stream: Vst::IStreamAttributes
-\ingroup vstIHost vst360
-- [host imp]
-- [extends IBStream]
-- [released: 3.6.0]
-- [optional]
-
-Interface to access preset meta information from stream, used, for example, in setState in order to inform the plug-in about
-the current context in which the preset loading occurs (Project context or Preset load (see \ref StateType))
-or used to get the full file path of the loaded preset (if available).
-
-\code{.cpp}
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/ustring.h"
-#include "pluginterfaces/vst/vstpresetkeys.h"
-...
-
-tresult PLUGIN_API MyPlugin::setState (IBStream* state)
-{
-	FUnknownPtr<IStreamAttributes> stream (state);
-	if (stream)
-	{
-		IAttributeList* list = stream->getAttributes ();
-		if (list)
-		{
-			// get the current type (project/Default..) of this state
-			String128 string;
-			if (list->getString (PresetAttributes::kStateType, string, 128 * sizeof (TChar)) == kResultTrue)
-			{
-				UString128 tmp (string);
-				char ascii[128];
-				tmp.toAscii (ascii, 128);
-				if (!strncmp (ascii, StateType::kProject, strlen (StateType::kProject)))
-				{
-					// we are in project loading context...
-				}
-			}
-
-			// get the full file path of this state
-			TChar fullPath[1024];
-			if (list->getString (PresetAttributes::kFilePathStringType, fullPath, 1024 * sizeof (TChar)) == kResultTrue)
-			{
-				// here we have the full path ...
-			}
-		}
-	}
-
-	//...read the state here.....
-	return kResultTrue;
-}
-\endcode
-*/
-class IStreamAttributes : public FUnknown
-{
-public:
-	//------------------------------------------------------------------------
-	/** Gets filename (without file extension) of the stream. */
-	virtual tresult PLUGIN_API getFileName (String128 name) = 0;
-
-	/** Gets meta information list. */
-	virtual IAttributeList* PLUGIN_API getAttributes () = 0;
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IStreamAttributes, 0xD6CE2FFC, 0xEFAF4B8C, 0x9E74F1BB, 0x12DA44B4)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstaudioprocessor.h

@@ -1,429 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstaudioprocessor.h
-// Created by  : Steinberg, 10/2005
-// Description : VST Audio Processing Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "ivstcomponent.h"
-#include "vstspeaker.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-/** Class Category Name for Audio Processor Component */
-//------------------------------------------------------------------------
-#ifndef kVstAudioEffectClass
-#define kVstAudioEffectClass "Audio Module Class"
-#endif
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-class IEventList;
-class IParameterChanges;
-struct ProcessContext;
-
-//------------------------------------------------------------------------
-/** Component Types used as subCategories in PClassInfo2 */
-namespace PlugType
-{
-/**
-\defgroup plugType Plug-in Type used for subCategories */
-/*@{*/
-//------------------------------------------------------------------------
-const CString kFxAnalyzer			= "Fx|Analyzer";	///< Scope, FFT-Display, Loudness Processing...
-const CString kFxDelay				= "Fx|Delay";		///< Delay, Multi-tap Delay, Ping-Pong Delay...
-const CString kFxDistortion			= "Fx|Distortion";	///< Amp Simulator, Sub-Harmonic, SoftClipper...
-const CString kFxDynamics			= "Fx|Dynamics";	///< Compressor, Expander, Gate, Limiter, Maximizer, Tape Simulator, EnvelopeShaper...
-const CString kFxEQ					= "Fx|EQ";			///< Equalization, Graphical EQ...
-const CString kFxFilter				= "Fx|Filter";		///< WahWah, ToneBooster, Specific Filter,...
-const CString kFx					= "Fx";				///< others type (not categorized)
-const CString kFxInstrument			= "Fx|Instrument";	///< Fx which could be loaded as Instrument too
-const CString kFxInstrumentExternal	= "Fx|Instrument|External";	///< Fx which could be loaded as Instrument too and is external (wrapped Hardware)
-const CString kFxSpatial			= "Fx|Spatial";		///< MonoToStereo, StereoEnhancer,...
-const CString kFxGenerator			= "Fx|Generator";	///< Tone Generator, Noise Generator...
-const CString kFxMastering			= "Fx|Mastering";	///< Dither, Noise Shaping,...
-const CString kFxModulation			= "Fx|Modulation";	///< Phaser, Flanger, Chorus, Tremolo, Vibrato, AutoPan, Rotary, Cloner...
-const CString kFxPitchShift			= "Fx|Pitch Shift";	///< Pitch Processing, Pitch Correction, Vocal Tuning...
-const CString kFxRestoration		= "Fx|Restoration";	///< Denoiser, Declicker,...
-const CString kFxReverb				= "Fx|Reverb";		///< Reverberation, Room Simulation, Convolution Reverb...
-const CString kFxSurround			= "Fx|Surround";	///< dedicated to surround processing: LFE Splitter, Bass Manager...
-const CString kFxTools				= "Fx|Tools";		///< Volume, Mixer, Tuner...
-const CString kFxNetwork			= "Fx|Network";		///< using Network
-
-const CString kInstrument			= "Instrument";			///< Effect used as instrument (sound generator), not as insert
-const CString kInstrumentDrum		= "Instrument|Drum";	///< Instrument for Drum sounds
-const CString kInstrumentExternal	= "Instrument|External";///< External Instrument (wrapped Hardware)
-const CString kInstrumentPiano		= "Instrument|Piano";	///< Instrument for Piano sounds
-const CString kInstrumentSampler	= "Instrument|Sampler";	///< Instrument based on Samples
-const CString kInstrumentSynth		= "Instrument|Synth";	///< Instrument based on Synthesis
-const CString kInstrumentSynthSampler = "Instrument|Synth|Sampler";	///< Instrument based on Synthesis and Samples
-
-const CString kSpatial				= "Spatial";		///< used for SurroundPanner
-const CString kSpatialFx			= "Spatial|Fx";		///< used for SurroundPanner and as insert effect
-const CString kOnlyRealTime			= "OnlyRT";			///< indicates that it supports only realtime process call, no processing faster than realtime
-const CString kOnlyOfflineProcess	= "OnlyOfflineProcess";	///< used for plug-in offline processing  (will not work as normal insert plug-in)
-const CString kOnlyARA				= "OnlyARA";		///< used for plug-ins that require ARA to operate (will not work as normal insert plug-in)
-
-const CString kNoOfflineProcess		= "NoOfflineProcess";	///< will be NOT used for plug-in offline processing (will work as normal insert plug-in)
-const CString kUpDownMix			= "Up-Downmix";		///< used for Mixconverter/Up-Mixer/Down-Mixer
-const CString kAnalyzer			    = "Analyzer";	    ///< Meter, Scope, FFT-Display, not selectable as insert plug-in
-const CString kAmbisonics			= "Ambisonics";		///< used for Ambisonics channel (FX or Panner/Mixconverter/Up-Mixer/Down-Mixer when combined with other category)
-
-const CString kMono					= "Mono";			///< used for Mono only plug-in [optional]
-const CString kStereo				= "Stereo";			///< used for Stereo only plug-in [optional]
-const CString kSurround				= "Surround";		///< used for Surround only plug-in [optional]
-
-//------------------------------------------------------------------------
-/*@}*/
-}
-
-//------------------------------------------------------------------------
-/** Component Flags used as classFlags in PClassInfo2 */
-enum ComponentFlags
-{
-//------------------------------------------------------------------------
-	kDistributable			= 1 << 0,	///< Component can be run on remote computer
-	kSimpleModeSupported	= 1 << 1	///< Component supports simple IO mode (or works in simple mode anyway) see \ref vst3IoMode
-//------------------------------------------------------------------------
-};
-
-//------------------------------------------------------------------------
-/** Symbolic sample size.
-\see ProcessSetup, ProcessData
-*/
-enum SymbolicSampleSizes
-{
-	kSample32,		///< 32-bit precision
-	kSample64		///< 64-bit precision
-};
-
-//------------------------------------------------------------------------
-/** Processing mode informs the plug-in about the context and at which frequency the process call is called.
-VST3 defines 3 modes:
-- kRealtime: each process call is called at a realtime frequency (defined by [numSamples of ProcessData] / samplerate).
-             The plug-in should always try to process as fast as possible in order to let enough time slice to other plug-ins.
-- kPrefetch: each process call could be called at a variable frequency (jitter, slower / faster than realtime),
-             the plug-in should process at the same quality level than realtime, plug-in must not slow down to realtime
-			 (e.g. disk streaming)!
-			 The host should avoid to process in kPrefetch mode such sampler based plug-in.
-- kOffline:  each process call could be faster than realtime or slower, higher quality than realtime could be used.
-             plug-ins using disk streaming should be sure that they have enough time in the process call for streaming,
-			 if needed by slowing down to realtime or slower.
-.
-Note about Process Modes switching:
-	- Switching between kRealtime and kPrefetch process modes are done in realtime thread without need of calling
-	 IAudioProcessor::setupProcessing, the plug-in should check in process call the member processMode of ProcessData
-	 in order to know in which mode it is processed.
-	- Switching between kRealtime (or kPrefetch) and kOffline requires that the host calls IAudioProcessor::setupProcessing
-	 in order to inform the plug-in about this mode change.
-	.
-\see ProcessSetup, ProcessData
-*/
-enum ProcessModes
-{
-	kRealtime,		///< realtime processing
-	kPrefetch,		///< prefetch processing
-	kOffline		///< offline processing
-};
-
-//------------------------------------------------------------------------
-/** kNoTail
- *
- * to be returned by getTailSamples when no tail is wanted
- \see IAudioProcessor::getTailSamples
-*/
-static const uint32 kNoTail = 0;
-
-//------------------------------------------------------------------------
-/** kInfiniteTail
- *
- * to be returned by getTailSamples when infinite tail is wanted
- \see IAudioProcessor::getTailSamples
- */
-static const uint32 kInfiniteTail = kMaxInt32u;
-
-//------------------------------------------------------------------------
-/** Audio processing setup.
-\see IAudioProcessor::setupProcessing
-*/
-struct ProcessSetup
-{
-//------------------------------------------------------------------------
-	int32 processMode;			///< \ref ProcessModes
-	int32 symbolicSampleSize;	///< \ref SymbolicSampleSizes
-	int32 maxSamplesPerBlock;	///< maximum number of samples per audio block
-	SampleRate sampleRate;		///< sample rate
-//------------------------------------------------------------------------
-};
-
-//------------------------------------------------------------------------
-/** Processing buffers of an audio bus.
-This structure contains the processing buffer for each channel of an audio bus.
-- The number of channels (numChannels) must always match the current bus arrangement.
-  It could be set to value '0' when the host wants to flush the parameters (when the plug-in is not processed).
-- The size of the channel buffer array must always match the number of channels. So the host
-  must always supply an array for the channel buffers, regardless if the
-  bus is active or not. However, if an audio bus is currently inactive, the actual sample
-  buffer addresses are safe to be null.
-- The silence flag is set when every sample of the according buffer has the value '0'. It is
-  intended to be used as help for optimizations allowing a plug-in to reduce processing activities.
-  But even if this flag is set for a channel, the channel buffers must still point to valid memory!
-  This flag is optional. A host is free to support it or not.
-.
-\see ProcessData
-*/
-struct AudioBusBuffers
-{
-	AudioBusBuffers () : numChannels (0), silenceFlags (0), channelBuffers64 (nullptr) {}
-
-//------------------------------------------------------------------------
-	int32 numChannels;		///< number of audio channels in bus
-	uint64 silenceFlags;	///< Bitset of silence state per channel
-	union
-	{
-		Sample32** channelBuffers32;	///< sample buffers to process with 32-bit precision
-		Sample64** channelBuffers64;	///< sample buffers to process with 64-bit precision
-	};
-//------------------------------------------------------------------------
-};
-
-//------------------------------------------------------------------------
-/** Any data needed in audio processing.
-	The host prepares AudioBusBuffers for each input/output bus,
-	regardless of the bus activation state. Bus buffer indices always match
-	with bus indices used in IComponent::getBusInfo of media type kAudio.
-\see AudioBusBuffers, IParameterChanges, IEventList, ProcessContext, IProcessContextRequirements
-*/
-struct ProcessData
-{
-	ProcessData ()
-	: processMode (0)
-	, symbolicSampleSize (kSample32)
-	, numSamples (0)
-	, numInputs (0)
-	, numOutputs (0)
-	, inputs (nullptr)
-	, outputs (nullptr)
-	, inputParameterChanges (nullptr)
-	, outputParameterChanges (nullptr)
-	, inputEvents (nullptr)
-	, outputEvents (nullptr)
-	, processContext (nullptr)
-	{
-	}
-
-//------------------------------------------------------------------------
-	int32 processMode;			///< processing mode - value of \ref ProcessModes
-	int32 symbolicSampleSize;   ///< sample size - value of \ref SymbolicSampleSizes
-	int32 numSamples;			///< number of samples to process
-	int32 numInputs;			///< number of audio input busses
-	int32 numOutputs;			///< number of audio output busses
-	AudioBusBuffers* inputs;	///< buffers of input busses
-	AudioBusBuffers* outputs;	///< buffers of output busses
-
-	IParameterChanges* inputParameterChanges;	///< incoming parameter changes for this block
-	IParameterChanges* outputParameterChanges;	///< outgoing parameter changes for this block (optional)
-	IEventList* inputEvents;				///< incoming events for this block (optional)
-	IEventList* outputEvents;				///< outgoing events for this block (optional)
-	ProcessContext* processContext;			///< processing context (optional, but most welcome)
-//------------------------------------------------------------------------
-};
-
-//------------------------------------------------------------------------
-/** Audio processing interface: Vst::IAudioProcessor
-\ingroup vstIPlug vst300
-- [plug imp]
-- [extends IComponent]
-- [released: 3.0.0]
-- [mandatory]
-
-This interface must always be supported by audio processing plug-ins.
-*/
-class IAudioProcessor : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Try to set (host => plug-in) a wanted arrangement for inputs and outputs.
-	   The host should always deliver the same number of input and output busses than the plug-in
-	   needs (see \ref IComponent::getBusCount). The plug-in has 3 possibilities to react on this
-	   setBusArrangements call:\n
-	   1. The plug-in accepts these arrangements, then it should modify, if needed, its busses to match 
-	     these new arrangements (later on asked by the host with IComponent::getBusInfo () or
-	     IAudioProcessor::getBusArrangement ()) and then should return kResultTrue.\n
-	   2. The plug-in does not accept or support these requested arrangements for all
-	     inputs/outputs or just for some or only one bus, but the plug-in can try to adapt its current
-	     arrangements according to the requested ones (requested arrangements for kMain busses should be
-		 handled with more priority than the ones for kAux busses), then it should modify its busses arrangements
-		 and should return kResultFalse.\n
-	   3. Same than the point 2 above the plug-in does not support these requested arrangements 
-	     but the plug-in cannot find corresponding arrangements, the plug-in could keep its current arrangement
-		 or fall back to a default arrangement by modifying its busses arrangements and should return kResultFalse.\n
-		\param inputs pointer to an array of /ref SpeakerArrangement
-		\param numIns number of /ref SpeakerArrangement in inputs array
-		\param outputs pointer to an array of /ref SpeakerArrangement
-		\param numOuts number of /ref SpeakerArrangement in outputs array 
-		Returns kResultTrue when Arrangements is supported and is the current one, else returns kResultFalse. */
-	virtual tresult PLUGIN_API setBusArrangements (SpeakerArrangement* inputs, int32 numIns,
-												   SpeakerArrangement* outputs, int32 numOuts) = 0;
-
-	/** Gets the bus arrangement for a given direction (input/output) and index.
-		Note: IComponent::getBusInfo () and IAudioProcessor::getBusArrangement () should be always return the same 
-		information about the busses arrangements. */
-	virtual tresult PLUGIN_API getBusArrangement (BusDirection dir, int32 index, SpeakerArrangement& arr) = 0;
-
-	/** Asks if a given sample size is supported see \ref SymbolicSampleSizes. */
-	virtual tresult PLUGIN_API canProcessSampleSize (int32 symbolicSampleSize) = 0;
-
-	/** Gets the current Latency in samples.
-		The returned value defines the group delay or the latency of the plug-in. For example, if the plug-in internally needs
-		to look in advance (like compressors) 512 samples then this plug-in should report 512 as latency.
-		If during the use of the plug-in this latency change, the plug-in has to inform the host by
-		using IComponentHandler::restartComponent (kLatencyChanged), this could lead to audio playback interruption
-		because the host has to recompute its internal mixer delay compensation.
-		Note that for player live recording this latency should be zero or small. */
-	virtual uint32 PLUGIN_API getLatencySamples () = 0;
-
-	/** Called in disable state (setActive not called with true) before setProcessing is called and processing will begin. */
-	virtual tresult PLUGIN_API setupProcessing (ProcessSetup& setup) = 0;
-
-	/** Informs the plug-in about the processing state. This will be called before any process calls
-	   start with true and after with false.
-	   Note that setProcessing (false) may be called after setProcessing (true) without any process
-	   calls.
-	   Note this function could be called in the UI or in Processing Thread, thats why the plug-in
-	   should only light operation (no memory allocation or big setup reconfiguration), 
-	   this could be used to reset some buffers (like Delay line or Reverb).
-	   The host has to be sure that it is called only when the plug-in is enable (setActive (true)
-	   was called). */
-	virtual tresult PLUGIN_API setProcessing (TBool state) = 0;
-
-	/** The Process call, where all information (parameter changes, event, audio buffer) are passed. */
-	virtual tresult PLUGIN_API process (ProcessData& data) = 0;
-
-	/** Gets tail size in samples. For example, if the plug-in is a Reverb plug-in and it knows that
-		the maximum length of the Reverb is 2sec, then it has to return in getTailSamples() 
-		(in VST2 it was getGetTailSize ()): 2*sampleRate.
-		This information could be used by host for offline processing, process optimization and 
-		downmix (avoiding signal cut (clicks)).
-		It should return:
-		 - kNoTail when no tail
-		 - x * sampleRate when x Sec tail.
-		 - kInfiniteTail when infinite tail. */
-	virtual uint32 PLUGIN_API getTailSamples () = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IAudioProcessor, 0x42043F99, 0xB7DA453C, 0xA569E79D, 0x9AAEC33D)
-
-//------------------------------------------------------------------------
-/** Extended IAudioProcessor interface for a component: Vst::IAudioPresentationLatency
-\ingroup vstIPlug vst310
-- [plug imp]
-- [extends IAudioProcessor]
-- [released: 3.1.0]
-- [optional]
-
-Inform the plug-in about how long from the moment of generation/acquiring (from file or from Input)
-it will take for its input to arrive, and how long it will take for its output to be presented (to output or to speaker).
-
-Note for Input Presentation Latency: when reading from file, the first plug-in will have an input presentation latency set to zero.
-When monitoring audio input from an audio device, the initial input latency is the input latency of the audio device itself.
-
-Note for Output Presentation Latency: when writing to a file, the last plug-in will have an output presentation latency set to zero.
-When the output of this plug-in is connected to an audio device, the initial output latency is the output
-latency of the audio device itself.
-
-A value of zero either means no latency or an unknown latency.
-
-Each plug-in adding a latency (returning a none zero value for IAudioProcessor::getLatencySamples) will modify the input 
-presentation latency of the next plug-ins in the mixer routing graph and will modify the output presentation latency 
-of the previous plug-ins.
-
-\n
-\image html "iaudiopresentationlatency_usage.png"
-\n
-\see IAudioProcessor
-\see IComponent
-*/
-class IAudioPresentationLatency : public FUnknown
-{
-public:
-	//------------------------------------------------------------------------
-	/** Informs the plug-in about the Audio Presentation Latency in samples for a given direction (kInput/kOutput) and bus index. */
-	virtual tresult PLUGIN_API setAudioPresentationLatencySamples (BusDirection dir, int32 busIndex, uint32 latencyInSamples) = 0;
-
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IAudioPresentationLatency, 0x309ECE78, 0xEB7D4fae, 0x8B2225D9, 0x09FD08B6)
-
-//------------------------------------------------------------------------
-/** Extended IAudioProcessor interface for a component: Vst::IProcessContextRequirements
- \ingroup vstIPlug vst370
- - [plug imp]
- - [extends IAudioProcessor]
- - [released: 3.7.0]
- - [mandatory]
- 
-To get accurate process context information (Vst::ProcessContext), it is now required to implement this interface and
-return the desired bit mask of flags which your audio effect needs. If you do not implement this
-interface, you may not get any information at all of the process function.
-
-The host asks for this information once between initialize and setActive. It cannot be changed afterwards.
-
-This gives the host the opportunity to better optimize the audio process graph when it knows which
-plug-ins need which information.
-
-Plug-Ins built with an earlier SDK version (< 3.7) will still get the old information, but the information
-may not be as accurate as when using this interface.
-*/
-class IProcessContextRequirements : public FUnknown
-{
-public:
-	enum Flags
-	{
-		kNeedSystemTime				= 1 <<  0, // kSystemTimeValid
-		kNeedContinousTimeSamples	= 1 <<  1, // kContTimeValid
-		kNeedProjectTimeMusic		= 1 <<  2, // kProjectTimeMusicValid
-		kNeedBarPositionMusic		= 1 <<  3, // kBarPositionValid
-		kNeedCycleMusic				= 1 <<  4, // kCycleValid
-		kNeedSamplesToNextClock		= 1 <<  5, // kClockValid
-		kNeedTempo					= 1 <<  6, // kTempoValid
-		kNeedTimeSignature			= 1 <<  7, // kTimeSigValid
-		kNeedChord					= 1 <<  8, // kChordValid
-		kNeedFrameRate				= 1 <<  9, // kSmpteValid
-		kNeedTransportState			= 1 << 10, // kPlaying, kCycleActive, kRecording
-	};
-	virtual uint32 PLUGIN_API getProcessContextRequirements () = 0;
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IProcessContextRequirements, 0x2A654303, 0xEF764E3D, 0x95B5FE83, 0x730EF6D0)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstautomationstate.h

@@ -1,67 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstautomationstate.h
-// Created by  : Steinberg, 02/2015
-// Description : VST Automation State Interface
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Extended plug-in interface IEditController: Vst::IAutomationState
-\ingroup vstIPlug vst365
-- [plug imp]
-- [extends IEditController]
-- [released: 3.6.5]
-- [optional]
-
-Hosts can inform the plug-in about its current automation state (Read/Write/Nothing).
-*/
-class IAutomationState : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	enum AutomationStates
-	{
-		kNoAutomation = 0,		///< Not Read and not Write
-		kReadState = 1 << 0,	///< Read state
-		kWriteState = 1 << 1,	///< Write state
-
-		kReadWriteState = kReadState | kWriteState, ///< Read and Write enable
-	};
-
-	/** Sets the current Automation state. */
-	virtual tresult PLUGIN_API setAutomationState (int32 state) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IAutomationState, 0xB4E8287F, 0x1BB346AA, 0x83A46667, 0x68937BAB)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstchannelcontextinfo.h

@@ -1,238 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstchannelcontextinfo.h
-// Created by  : Steinberg, 02/2014
-// Description : VST Channel Context Info Interface
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/vst/vsttypes.h"
-#include "pluginterfaces/vst/ivstattributes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-/** For Channel Context Info Interface */
-namespace ChannelContext {
-
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-/** Channel context interface: Vst::IInfoListener
-\ingroup vstIHost vst365
-- [plug imp]
-- [extends IEditController]
-- [released: 3.6.5]
-- [optional]
-
-Allows the host to inform the plug-in about the context in which the plug-in is instantiated,
-mainly channel based info (color, name, index,...). Index can be defined inside a namespace 
-(for example, index start from 1 to N for Type Input/Output Channel (Index namespace) and index 
-start from 1 to M for Type Audio Channel).\n
-As soon as the plug-in provides this IInfoListener interface, the host will call setChannelContextInfos 
-for each change occurring to this channel (new name, new color, new indexation,...)
-
-\section IChannelContextExample Example
-
-\code{.cpp}
-//------------------------------------------------------------------------
-tresult PLUGIN_API MyPlugin::setChannelContextInfos (IAttributeList* list)
-{
-	if (list)
-	{
-		// optional we can ask for the Channel Name Length
-		int64 length;
-		if (list->getInt (ChannelContext::kChannelNameLengthKey, length) == kResultTrue)
-		{
-			...
-		}
-		
-		// get the Channel Name where we, as plug-in, are instantiated
-		String128 name;
-		if (list->getString (ChannelContext::kChannelNameKey, name, sizeof (name)) == kResultTrue)
-		{
-			...
-		}
-
-		// get the Channel UID
-		if (list->getString (ChannelContext::kChannelUIDKey, name, sizeof (name)) == kResultTrue)
-		{
-			...
-		}
-		
-		// get Channel Index
-		int64 index;
-		if (list->getInt (ChannelContext::kChannelIndexKey, index) == kResultTrue)
-		{
-			...
-		}
-		
-		// get the Channel Color
-		int64 color;
-		if (list->getInt (ChannelContext::kChannelColorKey, color) == kResultTrue)
-		{
-			uint32 channelColor = (uint32)color;
-			String str;
-			str.printf ("%x%x%x%x", ChannelContext::GetAlpha (channelColor),
-			ChannelContext::GetRed (channelColor),
-			ChannelContext::GetGreen (channelColor),
-			ChannelContext::GetBlue (channelColor));
-			String128 string128;
-			Steinberg::UString (string128, 128).fromAscii (str);
-			...
-		}
-
-		// get Channel Index Namespace Order of the current used index namespace
-		if (list->getInt (ChannelContext::kChannelIndexNamespaceOrderKey, index) == kResultTrue)
-		{
-			...
-		}
-	
-		// get the channel Index Namespace Length
-		if (list->getInt (ChannelContext::kChannelIndexNamespaceLengthKey, length) == kResultTrue)
-		{
-			...
-		}
-		
-		// get the channel Index Namespace
-		String128 namespaceName;
-		if (list->getString (ChannelContext::kChannelIndexNamespaceKey, namespaceName, sizeof (namespaceName)) == kResultTrue)
-		{
-			...
-		}
-
-		// get plug-in Channel Location
-		int64 location;
-		if (list->getInt (ChannelContext::kChannelPluginLocationKey, location) == kResultTrue)
-		{
-			String128 string128;
-			switch (location)
-			{
-				case ChannelContext::kPreVolumeFader:
-					Steinberg::UString (string128, 128).fromAscii ("PreVolFader");
-				break;
-				case ChannelContext::kPostVolumeFader:
-					Steinberg::UString (string128, 128).fromAscii ("PostVolFader");
-				break;
-				case ChannelContext::kUsedAsPanner:
-					Steinberg::UString (string128, 128).fromAscii ("UsedAsPanner");
-				break;
-				default: Steinberg::UString (string128, 128).fromAscii ("unknown!");
-				break;
-			}
-		}
-		
-		// do not forget to call addRef () if you want to keep this list
-	}
-}
-\endcode 
-*/
-class IInfoListener : public FUnknown
-{
-public:
-	/** Receive the channel context infos from host. */
-	virtual tresult PLUGIN_API setChannelContextInfos (IAttributeList* list) = 0;
-
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IInfoListener, 0x0F194781, 0x8D984ADA, 0xBBA0C1EF, 0xC011D8D0)
-
-
-//------------------------------------------------------------------------
-/** Values used for kChannelPluginLocationKey */
-enum ChannelPluginLocation
-{
-	kPreVolumeFader = 0,
-	kPostVolumeFader,
-	kUsedAsPanner
-};
-
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-// Colors
-//------------------------------------------------------------------------
-/** \defgroup vst3typedef VST 3 Data Types */
-/*@{*/
-//------------------------------------------------------------------------
-/** ARGB (Alpha-Red-Green-Blue) */
-typedef uint32 ColorSpec;
-typedef uint8 ColorComponent;
-/*@}*/
-
-/** Returns the Blue part of the given ColorSpec */
-inline ColorComponent GetBlue (ColorSpec cs)	{return (ColorComponent)(cs & 0x000000FF); }
-/** Returns the Green part of the given ColorSpec */
-inline ColorComponent GetGreen (ColorSpec cs)	{return (ColorComponent)((cs >> 8) & 0x000000FF); }
-/** Returns the Red part of the given ColorSpec */
-inline ColorComponent GetRed (ColorSpec cs)		{return (ColorComponent)((cs >> 16) & 0x000000FF); }
-/** Returns the Alpha part of the given ColorSpec */
-inline ColorComponent GetAlpha (ColorSpec cs)	{return (ColorComponent)((cs >> 24) & 0x000000FF); }
-
-//------------------------------------------------------------------------
-/** Keys used as AttrID (Attribute ID) in the return IAttributeList of
- * IInfoListener::setChannelContextInfos  */
-//------------------------------------------------------------------------
-/** string (TChar) [optional]: unique id string used to identify a channel */
-const CString kChannelUIDKey = "channel uid";
-
-/** integer (int64) [optional]: number of characters in kChannelUIDKey */
-const CString kChannelUIDLengthKey = "channel uid length";
-
-/** string (TChar) [optional]: name of the channel like displayed in the mixer */
-const CString kChannelNameKey = "channel name";
-
-/** integer (int64) [optional]: number of characters in kChannelNameKey */
-const CString kChannelNameLengthKey = "channel name length";
-
-/** color (ColorSpec) [optional]: used color for the channel in mixer or track */
-const CString kChannelColorKey = "channel color";
-
-/** integer (int64) [optional]: index of the channel in a channel index namespace, start with 1 not * 0! */
-const CString kChannelIndexKey = "channel index";
-
-/** integer (int64) [optional]: define the order of the current used index namespace, start with 1 not 0!
-	For example:
-	index namespace is "Input"   -> order 1,
-	index namespace is "Channel" -> order 2,
-	index namespace is "Output"  -> order 3 */
-const CString kChannelIndexNamespaceOrderKey = "channel index namespace order";
-
-/** string (TChar) [optional]: name of the channel index namespace for example "Input", "Output", "Channel", ... */
-const CString kChannelIndexNamespaceKey = "channel index namespace";
-
-/** integer (int64) [optional]: number of characters in kChannelIndexNamespaceKey */
-const CString kChannelIndexNamespaceLengthKey =	"channel index namespace length";
-
-/** PNG image representation as binary [optional] */
-const CString kChannelImageKey = "channel image"; 
-
-/** integer (int64) [optional]: routing position of the plug-in in the channel (see ChannelPluginLocation) */
-const CString kChannelPluginLocationKey = "channel plugin location";
-
-//------------------------------------------------------------------------
-} // namespace ChannelContext
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstcomponent.h

@@ -1,205 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstcomponent.h
-// Created by  : Steinberg, 04/2005
-// Description : Basic VST Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/ipluginbase.h"
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-namespace Steinberg {
-class IBStream;
-
-//------------------------------------------------------------------------
-/** All VST specific interfaces are located in Vst namespace */
-namespace Vst {
-
-/** Standard value for PFactoryInfo::flags */
-const int32 kDefaultFactoryFlags = PFactoryInfo::kUnicode; 
-
-#define BEGIN_FACTORY_DEF(vendor,url,email) using namespace Steinberg; \
-	SMTG_EXPORT_SYMBOL IPluginFactory* PLUGIN_API GetPluginFactory () {	\
-	if (!gPluginFactory) \
-	{ \
-		static PFactoryInfo factoryInfo (vendor, url, email, Vst::kDefaultFactoryFlags); \
-		gPluginFactory = new CPluginFactory (factoryInfo);
-
-//------------------------------------------------------------------------
-/** \defgroup vstBus VST busses
-Bus Description
-
-A bus can be understood as a "collection of data channels" belonging together.
-It describes a data input or a data output of the plug-in.
-A VST component can define any desired number of busses.
-Dynamic usage of busses is handled in the host by activating and deactivating busses.
-All busses are initially inactive.
-The component has to define the maximum number of supported busses and it has to
-define which of them have to be activated by default after instantiation of the plug-in (This is
-only a wish, the host is allow to not follow it, and only activate the first bus for example).
-A host that can handle multiple busses, allows the user to activate busses which are initially all inactive.
-The kMain busses have to place before any others kAux busses.
-
-See also: IComponent::getBusInfo, IComponent::activateBus
-*/
-/*@{*/
-
-//------------------------------------------------------------------------
-/** Bus media types */
-enum MediaTypes
-{
-	kAudio = 0,		///< audio
-	kEvent,			///< events
-	kNumMediaTypes
-};
-
-//------------------------------------------------------------------------
-/** Bus directions */
-enum BusDirections
-{
-	kInput = 0,		///< input bus
-	kOutput			///< output bus
-};
-
-//------------------------------------------------------------------------
-/** Bus types */
-enum BusTypes
-{
-	kMain = 0,		///< main bus
-	kAux			///< auxiliary bus (sidechain)
-};
-
-//------------------------------------------------------------------------
-/** BusInfo:
-This is the structure used with getBusInfo, informing the host about what is a specific given bus.
-\n See also: Steinberg::Vst::IComponent::getBusInfo
-*/
-struct BusInfo
-{
-	MediaType mediaType;	///< Media type - has to be a value of \ref MediaTypes
-	BusDirection direction; ///< input or output \ref BusDirections
-	int32 channelCount;		///< number of channels (if used then need to be recheck after \ref
-							/// IAudioProcessor::setBusArrangements is called).
-							/// For a bus of type MediaTypes::kEvent the channelCount corresponds
-							/// to the number of supported MIDI channels by this bus
-	String128 name;			///< name of the bus
-	BusType busType;		///< main or aux - has to be a value of \ref BusTypes
-	uint32 flags;			///< flags - a combination of \ref BusFlags
-	enum BusFlags
-	{
-		/** The bus should be activated by the host per default on instantiation (activateBus call is requested).
- 		 	By default a bus is inactive. */
-		kDefaultActive = 1 << 0,
-		/** The bus does not contain ordinary audio data, but data used for control changes at sample rate.
- 			The data is in the same format as the audio data [-1..1].
- 			A host has to prevent unintended routing to speakers to prevent damage.
-		 	Only valid for audio media type busses.
-		 	[released: 3.7.0] */
-		kIsControlVoltage = 1 << 1
-	};
-};
-
-/*@}*/
-
-//------------------------------------------------------------------------
-/** I/O modes */
-enum IoModes
-{
-	kSimple = 0,		///< 1:1 Input / Output. Only used for Instruments. See \ref vst3IoMode
-	kAdvanced,			///< n:m Input / Output. Only used for Instruments.
-	kOfflineProcessing	///< plug-in used in an offline processing context
-};
-
-//------------------------------------------------------------------------
-/** Routing Information:
-When the plug-in supports multiple I/O busses, a host may want to know how the busses are related. The
-relation of an event-input-channel to an audio-output-bus in particular is of interest to the host
-(in order to relate MIDI-tracks to audio-channels)
-\n See also: IComponent::getRoutingInfo, \ref vst3Routing
-*/
-struct RoutingInfo
-{
-	MediaType mediaType;	///< media type see \ref MediaTypes
-	int32 busIndex;			///< bus index
-	int32 channel;			///< channel (-1 for all channels)
-};
-
-//------------------------------------------------------------------------
-// IComponent Interface
-//------------------------------------------------------------------------
-/** Component base interface: Vst::IComponent
-\ingroup vstIPlug vst300
-- [plug imp]
-- [released: 3.0.0]
-- [mandatory]
-
-This is the basic interface for a VST component and must always be supported.
-It contains the common parts of any kind of processing class. The parts that
-are specific to a media type are defined in a separate interface. An implementation
-component must provide both the specific interface and IComponent.
-\see IPluginBase
-*/
-class IComponent : public IPluginBase
-{
-public:
-//------------------------------------------------------------------------
-	/** Called before initializing the component to get information about the controller class. */
-	virtual tresult PLUGIN_API getControllerClassId (TUID classId) = 0;
-
-	/** Called before 'initialize' to set the component usage (optional). See \ref IoModes */
-	virtual tresult PLUGIN_API setIoMode (IoMode mode) = 0;
-
-	/** Called after the plug-in is initialized. See \ref MediaTypes, BusDirections */
-	virtual int32 PLUGIN_API getBusCount (MediaType type, BusDirection dir) = 0;
-
-	/** Called after the plug-in is initialized. See \ref MediaTypes, BusDirections */
-	virtual tresult PLUGIN_API getBusInfo (MediaType type, BusDirection dir, int32 index, BusInfo& bus /*out*/) = 0;
-
-	/** Retrieves routing information (to be implemented when more than one regular input or output bus exists).
-	    The inInfo always refers to an input bus while the returned outInfo must refer to an output bus! */
-	virtual tresult PLUGIN_API getRoutingInfo (RoutingInfo& inInfo, RoutingInfo& outInfo /*out*/) = 0;
-
-	/** Called upon (de-)activating a bus in the host application. The plug-in should only processed
-	   an activated bus, the host could provide less see \ref AudioBusBuffers in the process call
-	   (see \ref IAudioProcessor::process) if last busses are not activated. An already activated bus 
-	   does not need to be reactivated after a IAudioProcessor::setBusArrangements call. */
-	virtual tresult PLUGIN_API activateBus (MediaType type, BusDirection dir, int32 index,
-	                                        TBool state) = 0;
-
-	/** Activates / deactivates the component. */
-	virtual tresult PLUGIN_API setActive (TBool state) = 0;
-
-	/** Sets complete state of component. */
-	virtual tresult PLUGIN_API setState (IBStream* state) = 0;
-
-	/** Retrieves complete state of component. */
-	virtual tresult PLUGIN_API getState (IBStream* state) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IComponent, 0xE831FF31, 0xF2D54301, 0x928EBBEE, 0x25697802)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstcontextmenu.h

@@ -1,219 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstcontextmenu.h
-// Created by  : Steinberg, 10/2010
-// Description : VST Context Menu Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-namespace Steinberg {
-class IPlugView;
-
-namespace Vst {
-class IContextMenu;
-
-//------------------------------------------------------------------------
-/** Extended host callback interface Vst::IComponentHandler3 for an edit controller. 
-\ingroup vstIHost vst350
-- [host imp]
-- [extends IComponentHandler]
-- [released: 3.5.0]
-- [optional]
-
-A plug-in can ask the host to create a context menu for a given exported parameter ID or a generic context menu.\n
-
-The host may pre-fill this context menu with specific items regarding the parameter ID like "Show automation for parameter",
-"MIDI learn" etc...\n
-
-The plug-in can use the context menu in two ways :
-- add its own items to the menu via the IContextMenu interface and call IContextMenu::popup(..) to create the pop-up. See the \ref IContextMenuExample.
-- extract the host menu items and add them to a context menu created by the plug-in.
-
-\b Note: You can and should use this even if you do not add your own items to the menu as this is considered to be a big user value.
-
-\sa IContextMenu
-\sa IContextMenuTarget
-
-\section IContextMenuExample Examples
-- For example, Cubase adds its owned entries in the context menu opened with right-click on an exported parameter when the plug-in uses createContextMenu.
-\image html "contextmenuexample.png"
-\n
-- Adding plug-in specific items to the context menu:
-
-\code{.cpp}
-//------------------------------------------------------------------------
-class PluginContextMenuTarget : public IContextMenuTarget, public FObject
-{
-public:
-	PluginContextMenuTarget () {}
-
-	virtual tresult PLUGIN_API executeMenuItem (int32 tag)
-	{
-		// this will be called if the user has executed one of the menu items of the plug-in.
-		// It will not be called for items of the host.
-		switch (tag)
-		{
-			case 1: break;
-			case 2: break;
-		}
-		return kResultTrue;
-	}
-
-	OBJ_METHODS(PluginContextMenuTarget, FObject)
-	DEFINE_INTERFACES
-		DEF_INTERFACE (IContextMenuTarget)
-	END_DEFINE_INTERFACES (FObject)
-	REFCOUNT_METHODS(FObject)
-};
-
-// The following is the code to create the context menu
-void popupContextMenu (IComponentHandler* componentHandler, IPlugView* view, const ParamID* paramID, UCoord x, UCoord y)
-{
-	if (componentHandler == 0 || view == 0)
-		return;
-	FUnknownPtr<IComponentHandler3> handler (componentHandler);
-	if (handler == 0)
-		return;
-	IContextMenu* menu = handler->createContextMenu (view, paramID);
-	if (menu)
-	{
-		// here you can add your entries (optional)
-		PluginContextMenuTarget* target = new PluginContextMenuTarget ();
-		
-		IContextMenu::Item item = {0};
-		UString128 ("My Item 1").copyTo (item.name, 128);
-		item.tag = 1;
-		menu->addItem (item, target);
-
-		UString128 ("My Item 2").copyTo (item.name, 128);
-		item.tag = 2;
-		menu->addItem (item, target);
-		target->release ();
-		//--end of adding new entries
-		
-		// here the the context menu will be pop-up (and it waits a user interaction)
-		menu->popup (x, y);
-		menu->release ();
-	}
-}
-\endcode
-*/
-class IComponentHandler3 : public FUnknown
-{
-public:
-	/** Creates a host context menu for a plug-in:
-		- If paramID is zero, the host may create a generic context menu.
-		- The IPlugView object must be valid.
-		- The return IContextMenu object needs to be released afterwards by the plug-in.
-	*/
-	virtual IContextMenu* PLUGIN_API createContextMenu (IPlugView* plugView, const ParamID* paramID) = 0;
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IComponentHandler3, 0x69F11617, 0xD26B400D, 0xA4B6B964, 0x7B6EBBAB)
-	
-//------------------------------------------------------------------------
-/** Context Menu Item Target interface: Vst::IContextMenuTarget
-\ingroup vstIHost vstIPlug vst350
-- [host imp]
-- [plug imp]
-- [released: 3.5.0]
-- [optional]
-
-A receiver of a menu item should implement this interface, which will be called after the user has selected
-this menu item.
-
-\see IComponentHandler3 for more information.
-*/
-class IContextMenuTarget : public FUnknown
-{
-public:
-	/** Called when an menu item was executed. */
-	virtual tresult PLUGIN_API executeMenuItem (int32 tag) = 0;
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IContextMenuTarget, 0x3CDF2E75, 0x85D34144, 0xBF86D36B, 0xD7C4894D)
-
-//------------------------------------------------------------------------
-/** IContextMenuItem is an entry element of the context menu. */
-struct IContextMenuItem
-{
-	String128 name;									///< Name of the item
-	int32 tag;										///< Identifier tag of the item
-	int32 flags;									///< Flags of the item
-
-	enum Flags {
-		kIsSeparator	= 1 << 0,					///< Item is a separator
-		kIsDisabled		= 1 << 1,					///< Item is disabled
-		kIsChecked		= 1 << 2,					///< Item is checked
-		kIsGroupStart	= 1 << 3 | kIsDisabled,		///< Item is a group start (like sub folder)
-		kIsGroupEnd		= 1 << 4 | kIsSeparator,	///< Item is a group end
-	};
-};
-//------------------------------------------------------------------------
-/** Context Menu interface: Vst::IContextMenu
-\ingroup vstIHost vst350
-- [host imp]
-- [create with IComponentHandler3::createContextMenu(..)]
-- [released: 3.5.0]
-- [optional]
-
-A context menu is composed of Item (entry). A Item is defined by a name, a tag, a flag
-and a associated target (called when this item will be selected/executed). 
-With IContextMenu the plug-in can retrieve a Item, add a Item, remove a Item and pop-up the menu.
-
-\see IComponentHandler3 for more information.
-*/
-class IContextMenu : public FUnknown
-{
-public:
-	typedef IContextMenuItem Item;
-	
-	/** Gets the number of menu items. */
-	virtual int32 PLUGIN_API getItemCount () = 0;
-
-	/** Gets a menu item and its target (target could be not assigned). */
-	virtual tresult PLUGIN_API getItem (int32 index, Item& item /*out*/, IContextMenuTarget** target /*out*/) = 0;
-
-	/** Adds a menu item and its target. */
-	virtual tresult PLUGIN_API addItem (const Item& item, IContextMenuTarget* target) = 0;
-
-	/** Removes a menu item. */
-	virtual tresult PLUGIN_API removeItem (const Item& item, IContextMenuTarget* target) = 0;
-
-	/** Pop-ups the menu. Coordinates are relative to the top-left position of the plug-ins view. */
-	virtual tresult PLUGIN_API popup (UCoord x, UCoord y) = 0;
-
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IContextMenu, 0x2E93C863, 0x0C9C4588, 0x97DBECF5, 0xAD17817D)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivsteditcontroller.h

@@ -1,615 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivsteditcontroller.h
-// Created by  : Steinberg, 09/2005
-// Description : VST Edit Controller Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/ipluginbase.h"
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-/** Class Category Name for Controller Component */
-//------------------------------------------------------------------------
-#ifndef kVstComponentControllerClass
-#define kVstComponentControllerClass "Component Controller Class"
-#endif
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-class IPlugView;
-class IBStream;
-
-//------------------------------------------------------------------------
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Controller Parameter Info.
- *	A parameter info describes a parameter of the controller.
- *	The id must always be the same for a parameter as this uniquely identifies the parameter.
- */
-struct ParameterInfo
-{
-//------------------------------------------------------------------------
-	ParamID id;				///< unique identifier of this parameter (named tag too)
-	String128 title;		///< parameter title (e.g. "Volume")
-	String128 shortTitle;	///< parameter shortTitle (e.g. "Vol")
-	String128 units;		///< parameter unit (e.g. "dB")
-	int32 stepCount;		///< number of discrete steps (0: continuous, 1: toggle, discrete value otherwise 
-							///< (corresponding to max - min, for example: 127 for a min = 0 and a max = 127) - see \ref vst3ParameterIntro)
-	ParamValue defaultNormalizedValue;	///< default normalized value [0,1] (in case of discrete value: defaultNormalizedValue = defDiscreteValue / stepCount)
-	UnitID unitId;			///< id of unit this parameter belongs to (see \ref vst3Units)
-
-	int32 flags;			///< ParameterFlags (see below)
-	enum ParameterFlags
-	{
-		kNoFlags		 = 0,		///< no flags wanted
-		kCanAutomate	 = 1 << 0,	///< parameter can be automated
-		kIsReadOnly		 = 1 << 1,	///< parameter cannot be changed from outside the plug-in (implies that kCanAutomate is NOT set)
-		kIsWrapAround	 = 1 << 2,	///< attempts to set the parameter value out of the limits will result in a wrap around [SDK 3.0.2]
-		kIsList			 = 1 << 3,	///< parameter should be displayed as list in generic editor or automation editing [SDK 3.1.0]
-		kIsHidden		 = 1 << 4,	///< parameter should be NOT displayed and cannot be changed from outside the plug-in 
-									///< (implies that kCanAutomate is NOT set and kIsReadOnly is set) [SDK 3.7.0]
-
-		kIsProgramChange = 1 << 15,	///< parameter is a program change (unitId gives info about associated unit 
-									///< - see \ref vst3ProgramLists)
-		kIsBypass		 = 1 << 16	///< special bypass parameter (only one allowed): plug-in can handle bypass
-									///< (highly recommended to export a bypass parameter for effect plug-in)
-	};
-//------------------------------------------------------------------------
-};
-
-//------------------------------------------------------------------------
-/** View Types used for IEditController::createView */
-//------------------------------------------------------------------------
-namespace ViewType {
-const CString kEditor = "editor";
-}
-
-//------------------------------------------------------------------------
-/** Flags used for IComponentHandler::restartComponent */
-enum RestartFlags
-{
-	/** The Component should be reloaded
-	 *	The host has to unload completely the plug-in (controller/processor) and reload it. 
-	 *	[SDK 3.0.0] */
-	kReloadComponent			= 1 << 0,
-
-	/** Input / Output Bus configuration has changed
-	 *	The plug-in informs the host that either the bus configuration or the bus count has changed.
-	 *  The host has to deactivate the plug-in, asks the plug-in for its wanted new bus configurations,
-	 *  adapts its processing graph and reactivate the plug-in.
-	 *	[SDK 3.0.0] */
-	kIoChanged					= 1 << 1,
-
-	/** Multiple parameter values have changed  (as result of a program change for example)
-	 *	The host invalidates all caches of parameter values and asks the edit controller for the current values.
-	 *	[SDK 3.0.0] */
-	kParamValuesChanged			= 1 << 2,
-
-	/** Latency has changed
-	 *  The plug informs the host that its latency has changed, getLatencySamples should return the new latency after setActive (true) was called
-	 *  The host has to deactivate and reactivate the plug-in, then afterwards the host could ask for the current latency (getLatencySamples)
-	 *	see IAudioProcessor::getLatencySamples
-	 *	[SDK 3.0.0] */
-	kLatencyChanged				= 1 << 3,
-
-	/** Parameter titles, default values or flags (ParameterFlags) have changed
-	 *	The host invalidates all caches of parameter infos and asks the edit controller for the current infos.
-	 *	[SDK 3.0.0] */
-	kParamTitlesChanged			= 1 << 4,
-
-	/** MIDI Controllers and/or Program Changes Assignments have changed
-	 *	The plug-in informs the host that its MIDI-CC mapping has changed (for example after a MIDI learn or new loaded preset) 
-	 *  or if the stepCount or UnitID of a ProgramChange parameter has changed.
-	 *  The host has to rebuild the MIDI-CC => parameter mapping (getMidiControllerAssignment)
-	 *  and reread program changes parameters (stepCount and associated unitID)
-	 *	[SDK 3.0.1] */
-	kMidiCCAssignmentChanged	= 1 << 5,
-	
-	/** Note Expression has changed (info, count, PhysicalUIMapping, ...)
-	 *  Either the note expression type info, the count of note expressions or the physical UI mapping has changed.
-	 *	The host invalidates all caches of note expression infos and asks the edit controller for the current ones.
-	 *  See INoteExpressionController, NoteExpressionTypeInfo and INoteExpressionPhysicalUIMapping
-	 *	[SDK 3.5.0] */
-	kNoteExpressionChanged		= 1 << 6,
-	
-	/** Input / Output bus titles have changed
-	 *	The host invalidates all caches of bus titles and asks the edit controller for the current titles.
-	 *	[SDK 3.5.0] */
-	kIoTitlesChanged			= 1 << 7,
-	
-	/** Prefetch support has changed
-	 *	The plug-in informs the host that its PrefetchSupport has changed
-	 *  The host has to deactivate the plug-in, calls IPrefetchableSupport::getPrefetchableSupport and reactivate the plug-in
-	 *	see IPrefetchableSupport
-	 *	[SDK 3.6.1] */
-	kPrefetchableSupportChanged = 1 << 8,
-
-	/** RoutingInfo has changed
-	 *	The plug-in informs the host that its internal routing (relation of an event-input-channel to an audio-output-bus) has changed
-	 *  The host ask the plug-in for the new routing with IComponent::getRoutingInfo, \ref vst3Routing
-	 *	see IComponent
-	 *	[SDK 3.6.6] */
-	kRoutingInfoChanged			= 1 << 9
-};
-
-//------------------------------------------------------------------------
-/** Host callback interface for an edit controller: Vst::IComponentHandler
-\ingroup vstIHost vst300
-- [host imp]
-- [released: 3.0.0]
-- [mandatory]
-
-Allow transfer of parameter editing to component (processor) via host and support automation.
-Cause the host to react on configuration changes (restartComponent).
-
-\see \ref IEditController
-*/
-class IComponentHandler : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** To be called before calling a performEdit (e.g. on mouse-click-down event).
-	This must be called in the UI-Thread context!  */
-	virtual tresult PLUGIN_API beginEdit (ParamID id) = 0;
-
-	/** Called between beginEdit and endEdit to inform the handler that a given parameter has a new
-	 * value. This must be called in the UI-Thread context! */
-	virtual tresult PLUGIN_API performEdit (ParamID id, ParamValue valueNormalized) = 0;
-
-	/** To be called after calling a performEdit (e.g. on mouse-click-up event).
-	This must be called in the UI-Thread context! */
-	virtual tresult PLUGIN_API endEdit (ParamID id) = 0;
-
-	/** Instructs host to restart the component. This must be called in the UI-Thread context!
-	\param flags is a combination of RestartFlags */
-	virtual tresult PLUGIN_API restartComponent (int32 flags) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IComponentHandler, 0x93A0BEA3, 0x0BD045DB, 0x8E890B0C, 0xC1E46AC6)
-
-//------------------------------------------------------------------------
-/** Extended host callback interface for an edit controller: Vst::IComponentHandler2
-\ingroup vstIHost vst310
-- [host imp]
-- [extends IComponentHandler]
-- [released: 3.1.0]
-- [optional]
-
-One part handles:
-- Setting dirty state of the plug-in
-- Requesting the host to open the editor
-
-The other part handles parameter group editing from the plug-in UI. It wraps a set of \ref IComponentHandler::beginEdit /
-\ref Steinberg::Vst::IComponentHandler::performEdit / \ref Steinberg::Vst::IComponentHandler::endEdit functions (see \ref IComponentHandler)
-which should use the same timestamp in the host when writing automation.
-This allows for better synchronizing of multiple parameter changes at once.
-
-\section IComponentHandler2Example Examples of different use cases
-
-\code{.cpp}
-//--------------------------------------
-// we are in the editcontroller...
-// in case of multiple switch buttons (with associated ParamID 1 and 3)
-// on mouse down :
-hostHandler2->startGroupEdit ();
-hostHandler->beginEdit (1);
-hostHandler->beginEdit (3);
-hostHandler->performEdit (1, 1.0);
-hostHandler->performEdit (3, 0.0); // the opposite of paramID 1 for example
-....
-// on mouse up :
-hostHandler->endEdit (1);
-hostHandler->endEdit (3);
-hostHandler2->finishGroupEdit ();
-....
-....
-//--------------------------------------
-// in case of multiple faders (with associated ParamID 1 and 3)
-// on mouse down :
-hostHandler2->startGroupEdit ();
-hostHandler->beginEdit (1);
-hostHandler->beginEdit (3);
-hostHandler2->finishGroupEdit ();
-....
-// on mouse move :
-hostHandler2->startGroupEdit ();
-hostHandler->performEdit (1, x); // x the wanted value
-hostHandler->performEdit (3, x);
-hostHandler2->finishGroupEdit ();
-....
-// on mouse up :
-hostHandler2->startGroupEdit ();
-hostHandler->endEdit (1);
-hostHandler->endEdit (3);
-hostHandler2->finishGroupEdit ();
-\endcode
-\see \ref IComponentHandler, \ref IEditController
-*/
-class IComponentHandler2 : public FUnknown
-{
-public:
-	//------------------------------------------------------------------------
-	/** Tells host that the plug-in is dirty (something besides parameters has changed since last save),
-	if true the host should apply a save before quitting. */
-	virtual tresult PLUGIN_API setDirty (TBool state) = 0;
-
-	/** Tells host that it should open the plug-in editor the next time it's possible.
-	You should use this instead of showing an alert and blocking the program flow (especially on loading projects). */
-	virtual tresult PLUGIN_API requestOpenEditor (FIDString name = ViewType::kEditor) = 0;
-
-	//------------------------------------------------------------------------
-	/** Starts the group editing (call before a \ref IComponentHandler::beginEdit),
-	the host will keep the current timestamp at this call and will use it for all \ref IComponentHandler::beginEdit
-	/ \ref IComponentHandler::performEdit / \ref IComponentHandler::endEdit calls until a \ref finishGroupEdit (). */
-	virtual tresult PLUGIN_API startGroupEdit () = 0;
-
-	/** Finishes the group editing started by a \ref startGroupEdit (call after a \ref IComponentHandler::endEdit). */
-	virtual tresult PLUGIN_API finishGroupEdit () = 0;
-
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IComponentHandler2, 0xF040B4B3, 0xA36045EC, 0xABCDC045, 0xB4D5A2CC)
-
-//------------------------------------------------------------------------
-/** Extended host callback interface for an edit controller: Vst::IComponentHandlerBusActivation
-\ingroup vstIHost vst368
-- [host imp]
-- [extends IComponentHandler]
-- [released: 3.6.8]
-- [optional]
-
-Allows the plug-in to request the host to activate or deactivate a specific bus. 
-If the host accepts this request, it will call later on \ref IComponent::activateBus. 
-This is particularly useful for instruments with more than 1 outputs, where the user could request
-from the plug-in UI a given output bus activation.
-
-\code{.cpp}
-	// somewhere in your code when you need to inform the host to enable a specific Bus.
-	FUnknownPtr<IComponentHandlerBusActivation> busActivation (componentHandler);
-	if (busActivation)
-	{
-		// here we want to activate our audio input sidechain (the 2cd input bus: index 1)
-		busActivation->requestBusActivation (kAudio, kInput, 1, true);
-	}
-\endcode
-\see \ref IComponentHandler
-*/
-class IComponentHandlerBusActivation : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** request the host to activate or deactivate a specific bus. */
-	virtual tresult PLUGIN_API requestBusActivation (MediaType type, BusDirection dir, int32 index,
-	                                                 TBool state) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IComponentHandlerBusActivation, 0x067D02C1, 0x5B4E274D, 0xA92D90FD, 0x6EAF7240)
-
-//------------------------------------------------------------------------
-/** Extended host callback interface for an edit controller: Vst::IProgress
-\ingroup vstIHost vst370
-- [host imp]
-- [extends IComponentHandler]
-- [released: 3.7.0]
-- [optional]
-
-Allows the plug-in to request the host to create a progress for some specific tasks which take
-some time. The host can visualize the progress as read-only UI elements. For example,
-after loading a project where a plug-in needs to load extra
-data (e.g. samples) in a background thread, this enables the host to get and visualize the current status of the loading
-progress and to inform the user when the loading is finished.
-Note: During the progress, the host can unload the plug-in at any time. Make sure that the plug-in 
-supports this use case.
-
-\section IProgressExample Example
-
-\code{.cpp}
-//--------------------------------------
-// we are in the editcontroller:
-// as member: IProgress::ID mProgressID;
-
-FUnknownPtr<IProgress> progress (componentHandler);
-if (progress)
-	progress->start (IProgress::ProgressType::UIBackgroundTask, STR ("Load Samples..."), mProgressID);
-
-// ...
-myProgressValue += incProgressStep;
-FUnknownPtr<IProgress> progress (componentHandler);
-if (progress)
-	progress->update (mProgressID, myProgressValue);
-
-// ...
-FUnknownPtr<IProgress> progress (componentHandler);
-if (progress)
-	progress->finish (mProgressID);
-\endcode
-
-\see \ref IComponentHandler
-*/
-class IProgress : public FUnknown
-{
-public:
-	//------------------------------------------------------------------------
-	enum ProgressType : uint32
-	{
-		AsyncStateRestoration = 0,	///< plug-in state is restored async (in a background Thread)
-		UIBackgroundTask			///< a plug-in task triggered by a UI action 
-	};
-
-	using ID = uint64;
-
-	/** Start a new progress of a given type and optional Description. outID is as ID created by the
-	 * host to identify this newly created progress (for update and finish method) */
-	virtual tresult PLUGIN_API start (ProgressType type, const tchar* optionalDescription,
-	                                  ID& outID) = 0;
-	/** Update the progress value (normValue between [0, 1]) associated to the given id */
-	virtual tresult PLUGIN_API update (ID id, ParamValue normValue) = 0;
-	/** Finish the progress associated to the given id */
-	virtual tresult PLUGIN_API finish (ID id) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IProgress, 0x00C9DC5B, 0x9D904254, 0x91A388C8, 0xB4E91B69)
-
-//------------------------------------------------------------------------
-/** Edit controller component interface: Vst::IEditController
-\ingroup vstIPlug vst300
-- [plug imp]
-- [released: 3.0.0]
-- [mandatory]
-
-The controller part of an effect or instrument with parameter handling (export, definition, conversion...).
-\see \ref IComponent::getControllerClassId, \ref IMidiMapping
-*/
-class IEditController : public IPluginBase
-{
-public:
-//------------------------------------------------------------------------
-	/** Receives the component state. */
-	virtual tresult PLUGIN_API setComponentState (IBStream* state) = 0;
-
-	/** Sets the controller state. */
-	virtual tresult PLUGIN_API setState (IBStream* state) = 0;
-
-	/** Gets the controller state. */
-	virtual tresult PLUGIN_API getState (IBStream* state) = 0;
-
-	// parameters -------------------------
-	/** Returns the number of parameters exported. */
-	virtual int32 PLUGIN_API getParameterCount () = 0;
-	/** Gets for a given index the parameter information. */
-	virtual tresult PLUGIN_API getParameterInfo (int32 paramIndex, ParameterInfo& info /*out*/) = 0;
-
-	/** Gets for a given paramID and normalized value its associated string representation. */
-	virtual tresult PLUGIN_API getParamStringByValue (ParamID id, ParamValue valueNormalized /*in*/, String128 string /*out*/) = 0;
-	/** Gets for a given paramID and string its normalized value. */
-	virtual tresult PLUGIN_API getParamValueByString (ParamID id, TChar* string /*in*/, ParamValue& valueNormalized /*out*/) = 0;
-
-	/** Returns for a given paramID and a normalized value its plain representation
-		(for example -6 for -6dB - see \ref vst3AutomationIntro). */
-	virtual ParamValue PLUGIN_API normalizedParamToPlain (ParamID id, ParamValue valueNormalized) = 0;
-	/** Returns for a given paramID and a plain value its normalized value. (see \ref vst3AutomationIntro) */
-	virtual ParamValue PLUGIN_API plainParamToNormalized (ParamID id, ParamValue plainValue) = 0;
-
-	/** Returns the normalized value of the parameter associated to the paramID. */
-	virtual ParamValue PLUGIN_API getParamNormalized (ParamID id) = 0;
-	/** Sets the normalized value to the parameter associated to the paramID. The controller must never
-	    pass this value-change back to the host via the IComponentHandler. It should update the according
-		GUI element(s) only!*/
-	virtual tresult PLUGIN_API setParamNormalized (ParamID id, ParamValue value) = 0;
-
-	// handler ----------------------------
-	/** Gets from host a handler which allows the Plugin-in to communicate with the host.
-		Note: This is mandatory if the host is using the IEditController! */
-	virtual tresult PLUGIN_API setComponentHandler (IComponentHandler* handler) = 0;
-
-	// view -------------------------------
-	/** Creates the editor view of the plug-in, currently only "editor" is supported, see \ref ViewType.
-		The life time of the editor view will never exceed the life time of this controller instance. */
-	virtual IPlugView* PLUGIN_API createView (FIDString name) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IEditController, 0xDCD7BBE3, 0x7742448D, 0xA874AACC, 0x979C759E)
-
-//------------------------------------------------------------------------
-/** Knob Mode */
-enum KnobModes
-{
-	kCircularMode = 0,		///< Circular with jump to clicked position
-	kRelativCircularMode,	///< Circular without jump to clicked position
-	kLinearMode				///< Linear: depending on vertical movement
-};
-
-//------------------------------------------------------------------------
-/** \defgroup vst3typedef VST 3 Data Types */
-/*@{*/
-//------------------------------------------------------------------------
-/** Knob Mode Type */
-typedef int32 KnobMode;	
-/*@}*/
-
-//------------------------------------------------------------------------
-/** Edit controller component interface extension: Vst::IEditController2
-\ingroup vstIPlug vst310
-- [plug imp]
-- [extends IEditController]
-- [released: 3.1.0]
-- [optional]
-
-Extension to allow the host to inform the plug-in about the host Knob Mode,
-and to open the plug-in about box or help documentation.
-
-\see \ref IEditController, \ref EditController
-*/
-class IEditController2 : public FUnknown
-{
-public:
-	/** Host could set the Knob Mode for the plug-in. Return kResultFalse means not supported mode. \see KnobModes. */
-	virtual tresult PLUGIN_API setKnobMode (KnobMode mode) = 0;
-
-	/** Host could ask to open the plug-in help (could be: opening a PDF document or link to a web page).
-	    The host could call it with onlyCheck set to true for testing support of open Help. 
-		Return kResultFalse means not supported function. */
-	virtual tresult PLUGIN_API openHelp (TBool onlyCheck) = 0;
-
-	/** Host could ask to open the plug-in about box.
-	    The host could call it with onlyCheck set to true for testing support of open AboutBox. 
-		Return kResultFalse means not supported function. */
-	virtual tresult PLUGIN_API openAboutBox (TBool onlyCheck) = 0;
-
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IEditController2, 0x7F4EFE59, 0xF3204967, 0xAC27A3AE, 0xAFB63038)
-
-//------------------------------------------------------------------------
-/** MIDI Mapping interface: Vst::IMidiMapping
-\ingroup vstIPlug vst301
-- [plug imp]
-- [extends IEditController]
-- [released: 3.0.1]
-- [optional]
-
-MIDI controllers are not transmitted directly to a VST component. MIDI as hardware protocol has
-restrictions that can be avoided in software. Controller data in particular come along with unclear
-and often ignored semantics. On top of this they can interfere with regular parameter automation and
-the host is unaware of what happens in the plug-in when passing MIDI controllers directly.
-
-So any functionality that is to be controlled by MIDI controllers must be exported as regular parameter.
-The host will transform incoming MIDI controller data using this interface and transmit them as regular
-parameter change. This allows the host to automate them in the same way as other parameters.
-CtrlNumber can be a typical MIDI controller value extended to some others values like pitchbend or
-aftertouch (see \ref ControllerNumbers).
-If the mapping has changed, the plug-in must call IComponentHandler::restartComponent (kMidiCCAssignmentChanged)
-to inform the host about this change.
-
-\section IMidiMappingExample Example
-
-\code{.cpp}
-//--------------------------------------
-// in myeditcontroller.h
-class MyEditController: public EditControllerEx1, public IMidiMapping
-{
-	//...
-	//---IMidiMapping---------------------------
-	tresult PLUGIN_API getMidiControllerAssignment (int32 busIndex, int16 channel, CtrlNumber midiControllerNumber, ParamID& id) SMTG_OVERRIDE;
-	//---Interface---------
-	OBJ_METHODS (MyEditController, EditControllerEx1)
-	DEFINE_INTERFACES
-		DEF_INTERFACE (IMidiMapping)
-	END_DEFINE_INTERFACES (MyEditController)
-	REFCOUNT_METHODS (MyEditController)
-};
-
-//--------------------------------------
-// in myeditcontroller.cpp
-tresult PLUGIN_API MyEditController::getMidiControllerAssignment (int32 busIndex, int16 midiChannel, CtrlNumber midiControllerNumber, ParamID& tag)
-{
-	// for my first Event bus and for MIDI channel 0 and for MIDI CC Volume only
-	if (busIndex == 0 && midiChannel == 0 && midiControllerNumber == kCtrlVolume)
-	{
-		tag = kGainId;
-		return kResultTrue;
-	}
-	return kResultFalse;
-}
-\endcode
-
-*/
-class IMidiMapping : public FUnknown
-{
-public:
-	/** Gets an (preferred) associated ParamID for a given Input Event Bus index, channel and MIDI Controller.
-	*	@param[in] busIndex - index of Input Event Bus
-	*	@param[in] channel - channel of the bus
-	*   @param[in] midiControllerNumber - see \ref ControllerNumbers for expected values (could be bigger than 127)
-	*	@param[in] id - return the associated ParamID to the given midiControllerNumber
-	*/
-	virtual tresult PLUGIN_API getMidiControllerAssignment (int32 busIndex, int16 channel,
-															CtrlNumber midiControllerNumber, ParamID& id/*out*/) = 0;
-
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IMidiMapping, 0xDF0FF9F7, 0x49B74669, 0xB63AB732, 0x7ADBF5E5)
-
-//------------------------------------------------------------------------
-/** Parameter Editing from host: Vst::IEditControllerHostEditing
-\ingroup vstIPlug vst350
-- [plug imp]
-- [extends IEditController]
-- [released: 3.5.0]
-- [optional]
-
-If this interface is implemented by the edit controller, and when performing edits from outside
-the plug-in (host / remote) of a not automatable and not read-only, and not hidden flagged parameter (kind of helper parameter),
-the host will start with a beginEditFromHost before calling setParamNormalized and end with an endEditFromHost.
-Here the sequence that the host will call:
-
-\section IEditControllerExample Example
-
-\code{.cpp}
-//------------------------------------------------------------------------
-plugEditController->beginEditFromHost (id);
-plugEditController->setParamNormalized (id, value);
-plugEditController->setParamNormalized (id, value + 0.1);
-// ...
-plugEditController->endEditFromHost (id);
-\endcode
-
-\see \ref IEditController 
-*/
-class IEditControllerHostEditing : public FUnknown
-{
-public:
-	/** Called before a setParamNormalized sequence, a endEditFromHost will be call at the end of the editing action. */
-	virtual tresult PLUGIN_API beginEditFromHost (ParamID paramID) = 0;
-
-	/** Called after a beginEditFromHost and a sequence of setParamNormalized. */
-	virtual tresult PLUGIN_API endEditFromHost (ParamID paramID) = 0;
-
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IEditControllerHostEditing, 0xC1271208, 0x70594098, 0xB9DD34B3, 0x6BB0195E)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstevents.h

@@ -1,221 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstevents.h
-// Created by  : Steinberg, 11/2005
-// Description : VST Events Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/vst/ivstprocesscontext.h"
-#include "pluginterfaces/vst/ivstnoteexpression.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Reserved note identifier (noteId) range for a plug-in. Guaranteed not used by the host. */
-enum NoteIDUserRange
-{
-	kNoteIDUserRangeLowerBound = -10000, 
-	kNoteIDUserRangeUpperBound = -1000,
-};
-
-//------------------------------------------------------------------------
-/** Note-on event specific data. Used in \ref Event (union)
-\ingroup vstEventGrp
-Pitch uses the twelve-tone equal temperament tuning (12-TET).
- */
-struct NoteOnEvent
-{
-	int16 channel;		///< channel index in event bus
-	int16 pitch;		///< range [0, 127] = [C-2, G8] with A3=440Hz (12-TET: twelve-tone equal temperament)
-	float tuning;		///< 1.f = +1 cent, -1.f = -1 cent
-	float velocity;		///< range [0.0, 1.0]
-	int32 length;		///< in sample frames (optional, Note Off has to follow in any case!)
-	int32 noteId;		///< note identifier (if not available then -1)
-};
-
-//------------------------------------------------------------------------
-/** Note-off event specific data. Used in \ref Event (union)
-\ingroup vstEventGrp 
-*/
-struct NoteOffEvent
-{
-	int16 channel;		///< channel index in event bus
-	int16 pitch;		///< range [0, 127] = [C-2, G8] with A3=440Hz (12-TET)
-	float velocity;		///< range [0.0, 1.0]
-	int32 noteId;		///< associated noteOn identifier (if not available then -1)
-	float tuning;		///< 1.f = +1 cent, -1.f = -1 cent
-};
-
-//------------------------------------------------------------------------
-/** Data event specific data. Used in \ref Event (union)
-\ingroup vstEventGrp 
-*/
-struct DataEvent
-{
-	uint32 size;		///< size in bytes of the data block bytes
-	uint32 type;		///< type of this data block (see \ref DataTypes)
-	const uint8* bytes;	///< pointer to the data block
-
-	/** Value for DataEvent::type */
-	enum DataTypes
-	{
-		kMidiSysEx = 0	///< for MIDI system exclusive message
-	};
-};
-
-//------------------------------------------------------------------------
-/** PolyPressure event specific data. Used in \ref Event (union)
-\ingroup vstEventGrp
-*/
-struct PolyPressureEvent
-{
-	int16 channel;		///< channel index in event bus
-	int16 pitch;		///< range [0, 127] = [C-2, G8] with A3=440Hz
-	float pressure;		///< range [0.0, 1.0]
-	int32 noteId;		///< event should be applied to the noteId (if not -1)
-};
-
-//------------------------------------------------------------------------
-/** Chord event specific data. Used in \ref Event (union)
-\ingroup vstEventGrp 
-*/
-struct ChordEvent
-{
-	int16 root;			///< range [0, 127] = [C-2, G8] with A3=440Hz
-	int16 bassNote;		///< range [0, 127] = [C-2, G8] with A3=440Hz
-	int16 mask;			///< root is bit 0
-	uint16 textLen;		///< the number of characters (TChar) between the beginning of text and the terminating
-						///< null character (without including the terminating null character itself)
-	const TChar* text;	///< UTF-16, null terminated Hosts Chord Name
-};
-
-//------------------------------------------------------------------------
-/** Scale event specific data. Used in \ref Event (union)
-\ingroup vstEventGrp 
-*/
-struct ScaleEvent
-{
-	int16 root;			///< range [0, 127] = root Note/Transpose Factor
-	int16 mask;			///< Bit 0 =  C,  Bit 1 = C#, ... (0x5ab5 = Major Scale)
-	uint16 textLen;		///< the number of characters (TChar) between the beginning of text and the terminating
-						///< null character (without including the terminating null character itself)
-	const TChar* text;	///< UTF-16, null terminated, Hosts Scale Name
-};
-
-//------------------------------------------------------------------------
-/** Legacy MIDI CC Out event specific data. Used in \ref Event (union)
-\ingroup vstEventGrp
-- [released: 3.6.12]
-
-This kind of event is reserved for generating MIDI CC as output event for kEvent Bus during the process call.
- */
-struct LegacyMIDICCOutEvent
-{
-	uint8 controlNumber;///< see enum ControllerNumbers [0, 255]
-	int8 channel;		///< channel index in event bus [0, 15]
-	int8 value;			///< value of Controller [0, 127]
-	int8 value2;		///< [0, 127] used for pitch bend (kPitchBend) and polyPressure (kCtrlPolyPressure)
-};
-
-//------------------------------------------------------------------------
-/** Event 
-\ingroup vstEventGrp
-Structure representing a single Event of different types associated to a specific event (\ref kEvent) bus.
-*/
-struct Event
-{
-	int32 busIndex;				///< event bus index
-	int32 sampleOffset;			///< sample frames related to the current block start sample position
-	TQuarterNotes ppqPosition;	///< position in project
-	uint16 flags;				///< combination of \ref EventFlags
-
-	/** Event Flags - used for Event::flags */
-	enum EventFlags
-	{
-		kIsLive = 1 << 0,			///< indicates that the event is played live (directly from keyboard)
-
-		kUserReserved1 = 1 << 14,	///< reserved for user (for internal use)
-		kUserReserved2 = 1 << 15	///< reserved for user (for internal use)
-	};
-
-	/**  Event Types - used for Event::type */
-	enum EventTypes
-	{
-		kNoteOnEvent       = 0,			///< is \ref NoteOnEvent
-		kNoteOffEvent      = 1,			///< is \ref NoteOffEvent
-		kDataEvent         = 2,			///< is \ref DataEvent
-		kPolyPressureEvent = 3,			///< is \ref PolyPressureEvent
-		kNoteExpressionValueEvent = 4,	///< is \ref NoteExpressionValueEvent
-		kNoteExpressionTextEvent  = 5,	///< is \ref NoteExpressionTextEvent
-		kChordEvent        = 6,			///< is \ref ChordEvent
-		kScaleEvent        = 7,			///< is \ref ScaleEvent
-		kLegacyMIDICCOutEvent = 65535	///< is \ref LegacyMIDICCOutEvent
-	};
-
-	uint16 type;				///< a value from \ref EventTypes
-	union
-	{
-		NoteOnEvent noteOn;								///< type == kNoteOnEvent
-		NoteOffEvent noteOff;							///< type == kNoteOffEvent
-		DataEvent data;									///< type == kDataEvent
-		PolyPressureEvent polyPressure;					///< type == kPolyPressureEvent
-		NoteExpressionValueEvent noteExpressionValue;	///< type == kNoteExpressionValueEvent
-		NoteExpressionTextEvent noteExpressionText;		///< type == kNoteExpressionTextEvent
-		ChordEvent chord;								///< type == kChordEvent
-		ScaleEvent scale;								///< type == kScaleEvent
-		LegacyMIDICCOutEvent midiCCOut;					///< type == kLegacyMIDICCOutEvent
-	};
-};
-
-//------------------------------------------------------------------------
-/** List of events to process: Vst::IEventList
-\ingroup vstIHost vst300
-- [host imp]
-- [released: 3.0.0]
-- [mandatory]
-
-\see ProcessData, Event
-*/
-class IEventList : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Returns the count of events. */
-	virtual int32 PLUGIN_API getEventCount () = 0;
-
-	/** Gets parameter by index. */
-	virtual tresult PLUGIN_API getEvent (int32 index, Event& e /*out*/) = 0;
-
-	/** Adds a new event. */
-	virtual tresult PLUGIN_API addEvent (Event& e /*in*/) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IEventList, 0x3A2C4214, 0x346349FE, 0xB2C4F397, 0xB9695A44)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivsthostapplication.h

@@ -1,163 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivsthostapplication.h
-// Created by  : Steinberg, 04/2006
-// Description : VST Host Interface
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/vst/ivstmessage.h"
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Basic host callback interface: Vst::IHostApplication
-\ingroup vstIHost vst300
-- [host imp]
-- [passed as 'context' in to IPluginBase::initialize () ]
-- [released: 3.0.0]
-- [mandatory]
-
-Basic VST host application interface.
-*/
-class IHostApplication : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Gets host application name. */
-	virtual tresult PLUGIN_API getName (String128 name) = 0;
-
-	/** Creates host object (e.g. Vst::IMessage). */
-	virtual tresult PLUGIN_API createInstance (TUID cid, TUID _iid, void** obj) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IHostApplication, 0x58E595CC, 0xDB2D4969, 0x8B6AAF8C, 0x36A664E5)
-
-//------------------------------------------------------------------------
-/** Helper to allocate a message */
-inline IMessage* allocateMessage (IHostApplication* host)
-{
-	TUID iid;
-	IMessage::iid.toTUID (iid);
-	IMessage* m = nullptr;
-	if (host->createInstance (iid, iid, (void**)&m) == kResultOk)
-		return m;
-	return nullptr;
-}
-
-//------------------------------------------------------------------------
-/** VST 3 to VST 2 Wrapper interface: Vst::IVst3ToVst2Wrapper
-\ingroup vstIHost vst310
-- [host imp]
-- [passed as 'context' to IPluginBase::initialize () ]
-- [released: 3.1.0]
-- [mandatory]
-
-Informs the plug-in that a VST 3 to VST 2 wrapper is used between the plug-in and the real host.
-Implemented by the VST 2 Wrapper.
-*/
-class IVst3ToVst2Wrapper : public FUnknown
-{
-public:
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IVst3ToVst2Wrapper, 0x29633AEC, 0x1D1C47E2, 0xBB85B97B, 0xD36EAC61)
-
-//------------------------------------------------------------------------
-/** VST 3 to AU Wrapper interface: Vst::IVst3ToAUWrapper
-\ingroup vstIHost vst310
-- [host imp]
-- [passed as 'context' to IPluginBase::initialize () ]
-- [released: 3.1.0]
-- [mandatory]
-
-Informs the plug-in that a VST 3 to AU wrapper is used between the plug-in and the real host.
-Implemented by the AU Wrapper.
-*/
-class IVst3ToAUWrapper : public FUnknown
-{
-public:
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IVst3ToAUWrapper, 0xA3B8C6C5, 0xC0954688, 0xB0916F0B, 0xB697AA44)
-
-//------------------------------------------------------------------------
-/** VST 3 to AAX Wrapper interface: Vst::IVst3ToAAXWrapper
-\ingroup vstIHost vst368
-- [host imp]
-- [passed as 'context' to IPluginBase::initialize () ]
-- [released: 3.6.8]
-- [mandatory]
-
-Informs the plug-in that a VST 3 to AAX wrapper is used between the plug-in and the real host.
-Implemented by the AAX Wrapper.
-*/
-class IVst3ToAAXWrapper : public FUnknown
-{
-public:
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-DECLARE_CLASS_IID (IVst3ToAAXWrapper, 0x6D319DC6, 0x60C56242, 0xB32C951B, 0x93BEF4C6)
-
-//------------------------------------------------------------------------
-/** Wrapper MPE Support interface: Vst::IVst3WrapperMPESupport
-\ingroup vstIHost vst3612
-- [host imp]
-- [passed as 'context' to IPluginBase::initialize () ]
-- [released: 3.6.12]
-- [optional]
-
-Implemented on wrappers that support MPE to Note Expression translation.
-
-By default, MPE input processing is enabled, the masterChannel will be zero, the memberBeginChannel
-will be one and the memberEndChannel will be 14.
-
-As MPE is a subset of the VST3 Note Expression feature, mapping from the three MPE expressions is
-handled via the INoteExpressionPhysicalUIMapping interface.
-*/
-class IVst3WrapperMPESupport : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** enable or disable MPE processing
-	 *	@param state true to enable, false to disable MPE processing
-	 *	@return kResultTrue on success */
-	virtual tresult PLUGIN_API enableMPEInputProcessing (TBool state) = 0;
-	/** setup the MPE processing
-	 *	@param masterChannel MPE master channel (zero based)
-	 *	@param memberBeginChannel MPE member begin channel (zero based)
-	 *	@param memberEndChannel MPE member end channel (zero based)
-	 *	@return kResultTrue on success */
-	virtual tresult PLUGIN_API setMPEInputDeviceSettings (int32 masterChannel,
-	                                                      int32 memberBeginChannel,
-	                                                      int32 memberEndChannel) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IVst3WrapperMPESupport, 0x44149067, 0x42CF4BF9, 0x8800B750, 0xF7359FE3)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/vst/ivstinterappaudio.h

@@ -1,142 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstinterappaudio.h
-// Created by  : Steinberg, 08/2013
-// Description : VST InterAppAudio Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-struct ViewRect;
-namespace Vst {
-struct Event;
-class IInterAppAudioPresetManager;
-
-//------------------------------------------------------------------------
-/** Inter-App Audio host Interface.
-\ingroup vstIHost vst360
-- [host imp]
-- [passed as 'context' to IPluginBase::initialize () ]
-- [released: 3.6.0]
-- [optional]
-
-Implemented by the InterAppAudio Wrapper.
-*/
-class IInterAppAudioHost : public FUnknown
-{
-public:
-	/** get the size of the screen
-	 *	@param size size of the screen
-	 *	@param scale scale of the screen
-	 *	@return kResultTrue on success
-	 */
-	virtual tresult PLUGIN_API getScreenSize (ViewRect* size, float* scale) = 0;
-
-	/** get status of connection
-	 *	@return kResultTrue if an Inter-App Audio connection is established
-	 */
-	virtual tresult PLUGIN_API connectedToHost () = 0;
-
-	/** switch to the host.
-	 *	@return kResultTrue on success
-	 */
-	virtual tresult PLUGIN_API switchToHost () = 0;
-
-	/** send a remote control event to the host
-	 *	@param event event type, see AudioUnitRemoteControlEvent in the iOS SDK documentation for possible types
-	 *	@return kResultTrue on success
-	 */
-	virtual tresult PLUGIN_API sendRemoteControlEvent (uint32 event) = 0;
-
-	/** ask for the host icon.
-	 *	@param icon pointer to a CGImageRef
-	 *	@return kResultTrue on success
-	 */
-	virtual tresult PLUGIN_API getHostIcon (void** icon) = 0;
-
-	/** schedule an event from the user interface thread
-	 *	@param event the event to schedule
-	 *	@return kResultTrue on success
-	 */
-	virtual tresult PLUGIN_API scheduleEventFromUI (Event& event) = 0;
-
-	/** get the preset manager
-	 *	@param cid class ID to use by the preset manager
-	 *	@return the preset manager. Needs to be released by called.
-	 */
-	virtual IInterAppAudioPresetManager* PLUGIN_API createPresetManager (const TUID& cid) = 0;
-
-	/** show the settings view
-	 *	currently includes MIDI settings and Tempo setting
-	 *	@return kResultTrue on success
-	 */
-	virtual tresult PLUGIN_API showSettingsView () = 0;
-
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IInterAppAudioHost, 0x0CE5743D, 0x68DF415E, 0xAE285BD4, 0xE2CDC8FD)
-
-//------------------------------------------------------------------------
-/** Extended plug-in interface IEditController for Inter-App Audio connection state change notifications
-\ingroup vstIPlug vst360
-- [plug imp]
-- [extends IEditController]
-- [released: 3.6.0]
-*/
-class IInterAppAudioConnectionNotification : public FUnknown
-{
-public:
-	/** called when the Inter-App Audio connection state changes
-	 *	@param newState true if an Inter-App Audio connection is established, otherwise false
-	*/
-	virtual void PLUGIN_API onInterAppAudioConnectionStateChange (TBool newState) = 0;
-
-	//------------------------------------------------------------------------	
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IInterAppAudioConnectionNotification, 0x6020C72D, 0x5FC24AA1, 0xB0950DB5, 0xD7D6D5CF)
-
-//------------------------------------------------------------------------
-/** Extended plug-in interface IEditController for Inter-App Audio Preset Management
-\ingroup vstIPlug vst360
-- [plug imp]
-- [extends IEditController]
-- [released: 3.6.0]
-*/
-class IInterAppAudioPresetManager : public FUnknown
-{
-public:
-	/** Open the Preset Browser in order to load a preset */
-	virtual tresult PLUGIN_API runLoadPresetBrowser () = 0;
-	/** Open the Preset Browser in order to save a preset */
-	virtual tresult PLUGIN_API runSavePresetBrowser () = 0;
-	/** Load the next available preset */
-	virtual tresult PLUGIN_API loadNextPreset () = 0;
-	/** Load the previous available preset */
-	virtual tresult PLUGIN_API loadPreviousPreset () = 0;
-
-	//------------------------------------------------------------------------	
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IInterAppAudioPresetManager, 0xADE6FCC4, 0x46C94E1D, 0xB3B49A80, 0xC93FEFDD)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/vst/ivstmessage.h

@@ -1,97 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstmessage.h
-// Created by  : Steinberg, 04/2005
-// Description : VST Message Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/vst/ivstattributes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Private plug-in message: Vst::IMessage
-\ingroup vstIHost vst300
-- [host imp]
-- [create via IHostApplication::createInstance]
-- [released: 3.0.0]
-- [mandatory]
-
-Messages are sent from a VST controller component to a VST editor component and vice versa.
-\see IAttributeList, IConnectionPoint, \ref vst3Communication
-*/
-class IMessage : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Returns the message ID (for example "TextMessage"). */
-	virtual FIDString PLUGIN_API getMessageID () = 0;
-
-	/** Sets a message ID (for example "TextMessage"). */
-	virtual void PLUGIN_API setMessageID (FIDString id /*in*/) = 0;
-
-	/** Returns the attribute list associated to the message. */
-	virtual IAttributeList* PLUGIN_API getAttributes () = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IMessage, 0x936F033B, 0xC6C047DB, 0xBB0882F8, 0x13C1E613)
-
-//------------------------------------------------------------------------
-/** Connect a component with another one: Vst::IConnectionPoint
-\ingroup vstIPlug vst300
-- [plug imp]
-- [host imp]
-- [released: 3.0.0]
-- [mandatory]
-
-This interface is used for the communication of separate components.
-Note that some hosts will place a proxy object between the components so that they are not directly connected.
-
-\see \ref vst3Communication
-*/
-class IConnectionPoint : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Connects this instance with another connection point. */
-	virtual tresult PLUGIN_API connect (IConnectionPoint* other) = 0;
-
-	/** Disconnects a given connection point from this. */
-	virtual tresult PLUGIN_API disconnect (IConnectionPoint* other) = 0;
-
-	/** Called when a message has been sent from the connection point to this. */
-	virtual tresult PLUGIN_API notify (IMessage* message) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IConnectionPoint, 0x70A4156F, 0x6E6E4026, 0x989148BF, 0xAA60D8D1)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstmidicontrollers.h

@@ -1,118 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstmidicontrollers.h
-// Created by  : Steinberg, 02/2006
-// Description : VST MIDI Controller Enumeration
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Controller Numbers (MIDI) */
-enum ControllerNumbers
-{
-	kCtrlBankSelectMSB	=	0,	///< Bank Select MSB
-	kCtrlModWheel		=	1,	///< Modulation Wheel
-	kCtrlBreath			=	2,	///< Breath controller
-
-	kCtrlFoot			=	4,	///< Foot Controller
-	kCtrlPortaTime		=	5,	///< Portamento Time
-	kCtrlDataEntryMSB	=	6,	///< Data Entry MSB
-	kCtrlVolume			=	7,	///< Channel Volume (formerly Main Volume)
-	kCtrlBalance		=	8,	///< Balance
-
-	kCtrlPan			=	10,	///< Pan
-	kCtrlExpression		=	11,	///< Expression
-	kCtrlEffect1		=	12,	///< Effect Control 1
-	kCtrlEffect2		=	13,	///< Effect Control 2
-
-	//---General Purpose Controllers #1 to #4---
-	kCtrlGPC1			=	16,	///< General Purpose Controller #1
-	kCtrlGPC2			=	17,	///< General Purpose Controller #2
-	kCtrlGPC3			=	18,	///< General Purpose Controller #3
-	kCtrlGPC4			=	19,	///< General Purpose Controller #4
-
-	kCtrlBankSelectLSB	=	32,	///< Bank Select LSB
-
-	kCtrlDataEntryLSB	=	38,	///< Data Entry LSB
-
-	kCtrlSustainOnOff	=	64,	///< Damper Pedal On/Off (Sustain)
-	kCtrlPortaOnOff		=	65,	///< Portamento On/Off
-	kCtrlSustenutoOnOff	=	66,	///< Sustenuto On/Off
-	kCtrlSoftPedalOnOff	=	67,	///< Soft Pedal On/Off
-	kCtrlLegatoFootSwOnOff=	68,	///< Legato Footswitch On/Off
-	kCtrlHold2OnOff		=	69,	///< Hold 2 On/Off
-
-	//---Sound Controllers #1 to #10---
-	kCtrlSoundVariation	=	70, ///< Sound Variation
-	kCtrlFilterCutoff	=	71,	///< Filter Cutoff (Timbre/Harmonic Intensity)
-	kCtrlReleaseTime	=	72,	///< Release Time
-	kCtrlAttackTime		=	73,	///< Attack Time
-	kCtrlFilterResonance=	74,	///< Filter Resonance (Brightness)
-	kCtrlDecayTime		=	75,	///< Decay Time
-	kCtrlVibratoRate	=	76,	///< Vibrato Rate
-	kCtrlVibratoDepth	=	77,	///< Vibrato Depth
-	kCtrlVibratoDelay	=	78,	///< Vibrato Delay
-	kCtrlSoundCtrler10	=	79, ///< undefined
-
-	//---General Purpose Controllers #5 to #8---
-	kCtrlGPC5			=	80,	///< General Purpose Controller #5
-	kCtrlGPC6			=	81,	///< General Purpose Controller #6
-	kCtrlGPC7			=	82,	///< General Purpose Controller #7
-	kCtrlGPC8			=	83,	///< General Purpose Controller #8
-
-	kCtrlPortaControl	=	84,	///< Portamento Control
-
-	//---Effect Controllers---
-	kCtrlEff1Depth		=	91,	///< Effect 1 Depth (Reverb Send Level)
-	kCtrlEff2Depth		=	92,	///< Effect 2 Depth (Tremolo Level)
-	kCtrlEff3Depth		=	93,	///< Effect 3 Depth (Chorus Send Level)
-	kCtrlEff4Depth		=	94,	///< Effect 4 Depth (Delay/Variation/Detune Level)
-	kCtrlEff5Depth		=	95,	///< Effect 5 Depth (Phaser Level)
-
-	kCtrlDataIncrement	=	96,	///< Data Increment (+1)
-	kCtrlDataDecrement	=	97,	///< Data Decrement (-1)
-	kCtrlNRPNSelectLSB 	=	98, ///< NRPN Select LSB
-	kCtrlNRPNSelectMSB	=	99, ///< NRPN Select MSB
-	kCtrlRPNSelectLSB	=	100, ///< RPN Select LSB
-	kCtrlRPNSelectMSB	=	101, ///< RPN Select MSB
-
-	//---Other Channel Mode Messages---
-	kCtrlAllSoundsOff	=	120, ///< All Sounds Off
-	kCtrlResetAllCtrlers =	121, ///< Reset All Controllers
-	kCtrlLocalCtrlOnOff	=	122, ///< Local Control On/Off
-	kCtrlAllNotesOff	=	123, ///< All Notes Off
-	kCtrlOmniModeOff	=	124, ///< Omni Mode Off + All Notes Off
-	kCtrlOmniModeOn		=	125, ///< Omni Mode On  + All Notes Off
-	kCtrlPolyModeOnOff	=	126, ///< Poly Mode On/Off + All Sounds Off
-	kCtrlPolyModeOn		=	127, ///< Poly Mode On
-
-	//---Extra--------------------------
-	kAfterTouch = 128,			///< After Touch (associated to Channel Pressure)
-	kPitchBend  = 129,			///< Pitch Bend Change
-
-	kCountCtrlNumber,			///< Count of Controller Number
-
-	//---Extra for kLegacyMIDICCOutEvent-
-	kCtrlProgramChange = 130,	///< Program Change (use LegacyMIDICCOutEvent.value only)
-	kCtrlPolyPressure  = 131,	///< Polyphonic Key Pressure (use LegacyMIDICCOutEvent.value for pitch and
-								/// LegacyMIDICCOutEvent.value2 for pressure)
-	kCtrlQuarterFrame  = 132	///< Quarter Frame ((use LegacyMIDICCOutEvent.value only)
-};
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/vst/ivstmidilearn.h

@@ -1,106 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstmidilearn.h
-// Created by  : Steinberg, 11/2018
-// Description : VST MIDI Learn
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses.
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** MIDI Learn interface: Vst::IMidiLearn
-\ingroup vstIPlug vst3612
-- [plug imp]
-- [extends IEditController]
-- [released: 3.6.12]
-- [optional]
-
-If this interface is implemented by the edit controller, the host will call this method whenever
-there is live MIDI-CC input for the plug-in. This way, the plug-in can change its MIDI-CC parameter
-mapping and inform the host via the IComponentHandler::restartComponent with the
-kMidiCCAssignmentChanged flag.
-Use this if you want to implement custom MIDI-Learn functionality in your plug-in.
-
-\code{.cpp}
-//------------------------------------------------
-// in MyController class declaration
-class MyController : public Vst::EditController, public Vst::IMidiLearn
-{
-	// ...
-	//--- IMidiLearn ---------------------------------
-	tresult PLUGIN_API onLiveMIDIControllerInput (int32 busIndex, int16 channel,
-												  CtrlNumber midiCC) SMTG_OVERRIDE;
-	// ...
-
-	OBJ_METHODS (MyController, Vst::EditController)
-	DEFINE_INTERFACES
-		// ...
-		DEF_INTERFACE (Vst::IMidiLearn)
-	END_DEFINE_INTERFACES (Vst::EditController)
-	//...
-}
-
-//------------------------------------------------
-// in mycontroller.cpp
-#include "pluginterfaces/vst/ivstmidilearn.h
-
-namespace Steinberg {
-	namespace Vst {
-		DEF_CLASS_IID (IMidiLearn)
-	}
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API MyController::onLiveMIDIControllerInput (int32 busIndex, 
-							int16 channel, CtrlNumber midiCC)
-{
-	// if we are not in doMIDILearn (triggered by a UI button for example) 
-	// or wrong channel then return
-	if (!doMIDILearn || busIndex != 0 || channel != 0 || midiLearnParamID == InvalidParamID)
-		return kResultFalse;
-
-	// adapt our internal MIDICC -> parameterID mapping
-	midiCCMapping[midiCC] = midiLearnParamID;
-
-	// new mapping then inform the host that our MIDI assignment has changed
-	if (auto componentHandler = getComponentHandler ())
-	{
-		componentHandler->restartComponent (kMidiCCAssignmentChanged);
-	}
-	return kResultTrue;
-}
-\endcode
-*/
-class IMidiLearn : public FUnknown
-{
-public:
-	/** Called on live input MIDI-CC change associated to a given bus index and MIDI channel */
-	virtual tresult PLUGIN_API onLiveMIDIControllerInput (int32 busIndex, int16 channel,
-													      CtrlNumber midiCC) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IMidiLearn, 0x6B2449CC, 0x419740B5, 0xAB3C79DA, 0xC5FE5C86)
-
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/vst/ivstnoteexpression.h

@@ -1,255 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstnoteexpression.h
-// Created by  : Steinberg, 10/2010
-// Description : VST Note Expression Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** \defgroup vst3typedef VST 3 Data Types */
-/*@{*/
-//------------------------------------------------------------------------
-/** Note Expression Types */
-typedef uint32 NoteExpressionTypeID;
-/** Note Expression Value */
-typedef double NoteExpressionValue;
-/*@}*/
-
-//------------------------------------------------------------------------
-/** NoteExpressionTypeIDs describes the type of the note expression.
-VST predefines some types like volume, pan, tuning by defining their ranges and curves.
-Used by NoteExpressionEvent::typeId and NoteExpressionTypeID::typeId
-\see NoteExpressionTypeInfo
-*/
-enum NoteExpressionTypeIDs : uint32
-{
-	kVolumeTypeID = 0,		///< Volume, plain range [0 = -oo , 0.25 = 0dB, 0.5 = +6dB, 1 = +12dB]: plain = 20 * log (4 * norm)
-	kPanTypeID,				///< Panning (L-R), plain range [0 = left, 0.5 = center, 1 = right]
-	kTuningTypeID,			///< Tuning, plain range [0 = -120.0 (ten octaves down), 0.5 none, 1 = +120.0 (ten octaves up)]
-							///< plain = 240 * (norm - 0.5) and norm = plain / 240 + 0.5
-							///< oneOctave is 12.0 / 240.0; oneHalfTune = 1.0 / 240.0;
-	kVibratoTypeID,			///< Vibrato
-	kExpressionTypeID,		///< Expression
-	kBrightnessTypeID,		///< Brightness
-	kTextTypeID,			///< See NoteExpressionTextEvent
-	kPhonemeTypeID,			///< TODO:
-
-	kCustomStart = 100000,	///< start of custom note expression type ids
-	kCustomEnd   = 200000,  ///< end of custom note expression type ids
-	
-	kInvalidTypeID = 0xFFFFFFFF	///< indicates an invalid note expression type
-};
-
-//------------------------------------------------------------------------
-/** Description of a Note Expression Type
-This structure is part of the NoteExpressionTypeInfo structure, it describes for given NoteExpressionTypeID its default value
-(for example 0.5 for a kTuningTypeID (kIsBipolar: centered)), its minimum and maximum (for predefined NoteExpressionTypeID the full range is predefined too)
-and a stepCount when the given NoteExpressionTypeID is limited to discrete values (like on/off state).
-\see NoteExpressionTypeInfo
-*/
-struct NoteExpressionValueDescription
-{
-	NoteExpressionValue defaultValue;	///< default normalized value [0,1]
-	NoteExpressionValue minimum;		///< minimum normalized value [0,1]
-	NoteExpressionValue maximum;		///< maximum normalized value [0,1]
-	int32 stepCount;					///< number of discrete steps (0: continuous, 1: toggle, discrete value otherwise - see \ref vst3ParameterIntro)
-};
-
-#if SMTG_OS_WINDOWS && !SMTG_PLATFORM_64
-#include "pluginterfaces/vst/vstpshpack4.h"
-#endif
-//------------------------------------------------------------------------
-/** Note Expression Value event. Used in \ref Event (union)
-A note expression event affects one single playing note (referring its noteId).
-This kind of event is send from host to the plug-in like other events (NoteOnEvent, NoteOffEvent,...) in \ref ProcessData during the process call.
-Note expression events for a specific noteId can only occur after a NoteOnEvent. The host must take care that the event list (\ref IEventList) is properly sorted.
-Expression events are always absolute normalized values [0.0, 1.0].
-The predefined types have a predefined mapping of the normalized values (see \ref NoteExpressionTypeIDs)
-\sa INoteExpressionController
-*/
-struct NoteExpressionValueEvent
-{
-	NoteExpressionTypeID typeId;	///< see \ref NoteExpressionTypeID
-	int32 noteId;					///< associated note identifier to apply the change
-
-	NoteExpressionValue value;		///< normalized value [0.0, 1.0].
-};
-
-//------------------------------------------------------------------------
-/** Note Expression Text event. Used in Event (union)
-A Expression event affects one single playing note. \sa INoteExpressionController
-
-\see NoteExpressionTypeInfo
-*/
-struct NoteExpressionTextEvent
-{
-	NoteExpressionTypeID typeId;	///< see \ref NoteExpressionTypeID (kTextTypeID or kPhoneticTypeID)
-	int32 noteId;					///< associated note identifier to apply the change
-
-	uint32 textLen;					///< the number of characters (TChar) between the beginning of text and the terminating
-									///< null character (without including the terminating null character itself)
-
-	const TChar* text;				///< UTF-16, null terminated
-};
-
-#if SMTG_OS_WINDOWS && !SMTG_PLATFORM_64
-#include "pluginterfaces/base/falignpop.h"
-#endif
-
-//------------------------------------------------------------------------
-/** NoteExpressionTypeInfo is the structure describing a note expression supported by the plug-in.
-This structure is used by the method \ref INoteExpressionController::getNoteExpressionInfo.
-\see INoteExpressionController
-*/
-struct NoteExpressionTypeInfo
-{
-	NoteExpressionTypeID typeId;			///< unique identifier of this note Expression type
-	String128 title;						///< note Expression type title (e.g. "Volume")
-	String128 shortTitle;					///< note Expression type short title (e.g. "Vol")
-	String128 units;						///< note Expression type unit (e.g. "dB")
-	int32 unitId;							///< id of unit this NoteExpression belongs to (see \ref vst3Units), in order to sort the note expression, it is possible to use unitId like for parameters. -1 means no unit used.
-	NoteExpressionValueDescription valueDesc;	///< value description see \ref NoteExpressionValueDescription
-	ParamID associatedParameterId;			///< optional associated parameter ID (for mapping from note expression to global (using the parameter automation for example) and back). Only used when kAssociatedParameterIDValid is set in flags.
-
-	int32 flags;							///< NoteExpressionTypeFlags (see below)
-	enum NoteExpressionTypeFlags
-	{
-		kIsBipolar		= 1 << 0,			///< event is bipolar (centered), otherwise unipolar
-		kIsOneShot		= 1 << 1,			///< event occurs only one time for its associated note (at begin of the noteOn)
-		kIsAbsolute		= 1 << 2,			///< This note expression will apply an absolute change to the sound (not relative (offset))
-		kAssociatedParameterIDValid	= 1 << 3,///< indicates that the associatedParameterID is valid and could be used
-	};
-};
-
-//------------------------------------------------------------------------
-/** Extended plug-in interface IEditController for note expression event support: Vst::INoteExpressionController
-\ingroup vstIPlug vst350
-- [plug imp]
-- [extends IEditController]
-- [released: 3.5.0]
-- [optional]
-
-With this plug-in interface, the host can retrieve all necessary note expression information supported by the plug-in.
-Note expression information (\ref NoteExpressionTypeInfo) are specific for given channel and event bus.
-
-Note that there is only one NoteExpressionTypeID per given channel of an event bus.
-
-The method getNoteExpressionStringByValue allows conversion from a normalized value to a string representation
-and the getNoteExpressionValueByString method from a string to a normalized value.
-
-When the note expression state changes (for example when switching presets) the plug-in needs
-to inform the host about it via \ref IComponentHandler::restartComponent (kNoteExpressionChanged).
-*/
-class INoteExpressionController : public FUnknown
-{
-public:
-	/** Returns number of supported note change types for event bus index and channel. */
-	virtual int32 PLUGIN_API getNoteExpressionCount (int32 busIndex, int16 channel) = 0;
-
-	/** Returns note change type info. */
-	virtual tresult PLUGIN_API getNoteExpressionInfo (int32 busIndex, int16 channel, int32 noteExpressionIndex, NoteExpressionTypeInfo& info /*out*/) = 0;
-
-	/** Gets a user readable representation of the normalized note change value. */
-	virtual tresult PLUGIN_API getNoteExpressionStringByValue (int32 busIndex, int16 channel, NoteExpressionTypeID id, NoteExpressionValue valueNormalized /*in*/, String128 string /*out*/) = 0;
-
-	/** Converts the user readable representation to the normalized note change value. */
-	virtual tresult PLUGIN_API getNoteExpressionValueByString (int32 busIndex, int16 channel, NoteExpressionTypeID id, const TChar* string /*in*/, NoteExpressionValue& valueNormalized /*out*/) = 0;
-
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (INoteExpressionController, 0xB7F8F859, 0x41234872, 0x91169581, 0x4F3721A3)
-
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-/** KeyswitchTypeIDs describes the type of a key switch
-\see KeyswitchInfo
-*/
-enum KeyswitchTypeIDs : uint32
-{
-	kNoteOnKeyswitchTypeID = 0,	///< press before noteOn is played
-	kOnTheFlyKeyswitchTypeID,	///< press while noteOn is played
-	kOnReleaseKeyswitchTypeID,	///< press before entering release
-	kKeyRangeTypeID				///< key should be maintained pressed for playing
-};
-
-typedef uint32 KeyswitchTypeID;
-
-//------------------------------------------------------------------------
-/** KeyswitchInfo is the structure describing a key switch
-This structure is used by the method \ref IKeyswitchController::getKeyswitchInfo.
-\see IKeyswitchController
-*/
-struct KeyswitchInfo
-{
-	KeyswitchTypeID typeId;		///< see KeyswitchTypeID
-	String128 title;			///< name of key switch (e.g. "Accentuation")
-	String128 shortTitle;		///< short title (e.g. "Acc")
-
-	int32 keyswitchMin;			///< associated main key switch min (value between [0, 127])
-	int32 keyswitchMax;			///< associated main key switch max (value between [0, 127])
-	int32 keyRemapped;			/** optional remapped key switch (default -1), the plug-in could provide one remapped
-								key for a key switch (allowing better location on the keyboard of the key switches) */
-
-	int32 unitId;				///< id of unit this key switch belongs to (see \ref vst3Units), -1 means no unit used.
-
-	int32 flags;				///< not yet used (set to 0)
-};
-
-//------------------------------------------------------------------------
-/** Extended plug-in interface IEditController for key switches support: Vst::IKeyswitchController
-\ingroup vstIPlug vst350
-- [plug imp]
-- [extends IEditController]
-- [released: 3.5.0]
-- [optional]
-
-When a (instrument) plug-in supports such interface, the host could get from the plug-in the current set
-of used key switches (megatrig/articulation) for a given channel of a event bus and then automatically use them (like in Cubase 6) to
-create VST Expression Map (allowing to associated symbol to a given articulation / key switch).
-*/
-class IKeyswitchController : public FUnknown
-{
-public:
-	/** Returns number of supported key switches for event bus index and channel. */
-	virtual int32 PLUGIN_API getKeyswitchCount (int32 busIndex, int16 channel) = 0;
-
-	/** Returns key switch info. */
-	virtual tresult PLUGIN_API getKeyswitchInfo (int32 busIndex, int16 channel, int32 keySwitchIndex, KeyswitchInfo& info /*out*/) = 0;
-
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IKeyswitchController, 0x1F2F76D3, 0xBFFB4B96, 0xB99527A5, 0x5EBCCEF4)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstparameterchanges.h

@@ -1,145 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstparameterchanges.h
-// Created by  : Steinberg, 09/2005
-// Description : VST Parameter Change Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//----------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-//----------------------------------------------------------------------
-/** Queue of changes for a specific parameter: Vst::IParamValueQueue
-\ingroup vstIHost vst300
-- [host imp]
-- [released: 3.0.0]
-- [mandatory]
-
-The change queue can be interpreted as segment of an automation curve. For each
-processing block, a segment with the size of the block is transmitted to the processor.
-The curve is expressed as sampling points of a linear approximation of
-the original automation curve. If the original already is a linear curve, it can
-be transmitted precisely. A non-linear curve has to be converted to a linear
-approximation by the host. Every point of the value queue defines a linear
-section of the curve as a straight line from the previous point of a block to
-the new one. So the plug-in can calculate the value of the curve for any sample
-position in the block.
-
-<b>Implicit Points:</b> \n
-In each processing block, the section of the curve for each parameter is transmitted.
-In order to reduce the amount of points, the point at block position 0 can be omitted.
-- If the curve has a slope of 0 over a period of multiple blocks, only one point is
-transmitted for the block where the constant curve section starts. The queue for the following
-blocks will be empty as long as the curve slope is 0.
-- If the curve has a constant slope other than 0 over the period of several blocks, only
-the value for the last sample of the block is transmitted. In this case, the last valid point
-is at block position -1. The processor can calculate the value for each sample in the block
-by using a linear interpolation:
-
-\code{.cpp}
-//------------------------------------------------------------------------
-double x1 = -1; // position of last point related to current buffer
-double y1 = currentParameterValue; // last transmitted value
-
-int32 pointTime = 0;
-ParamValue pointValue = 0;
-IParamValueQueue::getPoint (0, pointTime, pointValue);
-
-double x2 = pointTime;
-double y2 = pointValue;
-
-double slope = (y2 - y1) / (x2 - x1);
-double offset = y1 - (slope * x1);
-
-double curveValue = (slope * bufferTime) + offset; // bufferTime is any position in buffer
-\endcode
-
-\b Jumps:
-\n
-A jump in the automation curve has to be transmitted as two points: one with the
-old value and one with the new value at the next sample position.
-
-\image html "automation.jpg"
-
-See \ref IParameterChanges, \ref ProcessData
-*/
-class IParamValueQueue : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Returns its associated ID. */
-	virtual ParamID PLUGIN_API getParameterId () = 0;
-
-	/** Returns count of points in the queue. */
-	virtual int32 PLUGIN_API getPointCount () = 0;
-
-	/** Gets the value and offset at a given index. */
-	virtual tresult PLUGIN_API getPoint (int32 index, int32& sampleOffset /*out*/, ParamValue& value /*out*/) = 0;
-
-	/** Adds a new value at the end of the queue, its index is returned. */
-	virtual tresult PLUGIN_API addPoint (int32 sampleOffset, ParamValue value, int32& index /*out*/) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IParamValueQueue, 0x01263A18, 0xED074F6F, 0x98C9D356, 0x4686F9BA)
-
-//----------------------------------------------------------------------
-/** All parameter changes of a processing block: Vst::IParameterChanges
-\ingroup vstIHost vst300
-- [host imp]
-- [released: 3.0.0]
-- [mandatory]
-
-This interface is used to transmit any changes to be applied to parameters
-in the current processing block. A change can be caused by GUI interaction as
-well as automation. They are transmitted as a list of queues (\ref IParamValueQueue)
-containing only queues for parameters that actually did change.
-See \ref IParamValueQueue, \ref ProcessData
-*/
-class IParameterChanges : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Returns count of Parameter changes in the list. */
-	virtual int32 PLUGIN_API getParameterCount () = 0;
-
-	/** Returns the queue at a given index. */
-	virtual IParamValueQueue* PLUGIN_API getParameterData (int32 index) = 0;
-
-	/** Adds a new parameter queue with a given ID at the end of the list,
-	returns it and its index in the parameter changes list. */
-	virtual IParamValueQueue* PLUGIN_API addParameterData (const Vst::ParamID& id, int32& index /*out*/) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IParameterChanges, 0xA4779663, 0x0BB64A56, 0xB44384A8, 0x466FEB9D)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstparameterfunctionname.h

@@ -1,143 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstparameterfunctionname.h
-// Created by  : Steinberg, 03/2020
-// Description : VST Parameter Function Name Interface
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-namespace FunctionNameType {
-//--------------------------------------------------------------------
-	const CString kCompGainReduction			= "Comp:GainReduction"; /**  */
-	const CString kCompGainReductionMax			= "Comp:GainReductionMax";
-	const CString kCompGainReductionPeakHold	= "Comp:GainReductionPeakHold";
-	const CString kCompResetGainReductionMax	= "Comp:ResetGainReductionMax";
-
-    const CString kLowLatencyMode = "LowLatencyMode"; /** Useful for live situation where low
-														 latency is required:
-														 0 means LowLatency disable,
-														 1 means LowLatency enable */
-    const CString kDryWetMix = "DryWetMix"; /** Allowing to mix the original (Dry) Signal with the processed one (Wet):
-											0.0 means Dry Signal only,
-											0.5 means 50% Dry Signal + 50% Wet Signal,
-											1.0 means Wet Signal only */
-    const CString kRandomize = "Randomize"; /**	Allow to assign some randomized values to some
-                                               parameters in a controlled way*/
-
-} // FunctionNameType
-
-//------------------------------------------------------------------------
-/** Edit controller component interface extension: Vst::IParameterFunctionName
-\ingroup vstIPlug vst370
-- [plug imp]
-- [extends IEditController]
-- [released: 3.7.0]
-- [optional]
-
-This interface allows the host to get a parameter associated to a specific meaning (a functionName) for a given unit.
-The host can use this information, for example, for drawing a Gain Reduction meter in its own UI.
-In order to get the plain value of this parameter, the host should use the IEditController::normalizedParamToPlain.
-The host can automatically map parameters to dedicated UI controls, such as the wet-dry mix knob or Randomize button.
-
-\section IParameterFunctionNameExample Example
-
-\code{.cpp}
-//------------------------------------------------------------------------
-// here an example of how a VST3 plug-in could support this IParameterFunctionName interface.
-// we need to define somewhere the iids:
-
-in MyController class declaration
-class MyController : public Vst::EditController, public Vst::IParameterFunctionName
-{
-	...
-	tresult PLUGIN_API getParameterIDFromFunctionName (UnitID unitID, FIDString functionName,
-													Vst::ParamID& paramID) override;
-	...
-
-	OBJ_METHODS (MyController, Vst::EditController)
-	DEFINE_INTERFACES
-		...
-		DEF_INTERFACE (Vst::IParameterFunctionName)
-	END_DEFINE_INTERFACES (Vst::EditController)
-	...
-}
-
-#include "ivstparameterfunctionname.h"
-namespace Steinberg {
-	namespace Vst {
-		DEF_CLASS_IID (IParameterFunctionName)
-	}
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API MyController::getParameterIDFromFunctionName (UnitID unitID, FIDString functionName,
-                                                                 Vst::ParamID& paramID)
-{
-	using namespace Vst;
-
-	paramID = kNoParamId;
-
-	if (unitID == kRootUnitId && FIDStringsEqual (functionName, kCompGainReduction))
-		paramID = kMyGainReductionId;
-
-	return (paramID != kNoParamId) ? kResultOk : kResultFalse;
-}
-
-//--- a host implementation example: --------------------
-...
-FUnknownPtr<Vst::IParameterFunctionName> functionName (mEditController->getIEditController ());
-if (functionName)
-{
-	Vst::ParamID paramID;
-	if (functionName->getParameterIDFromFunctionName (Vst::FunctionNameType::kCompGainReduction, paramID) == kResultTrue)
-	{
-		// paramID could be cached for performance issue
-		ParamValue norm = mEditController->getIEditController ()->getParamNormalized (paramID);
-		ParamValue plain = mEditController->getIEditController ()->normalizedParamToPlain (paramID, norm);
-		// plain is something like -6 (-6dB)
-	}
-}
-\endcode
-*/
-class IParameterFunctionName : public FUnknown
-{
-public:
-	//------------------------------------------------------------------------
-	/** Gets for the given unitID the associated paramID to a function Name.
-		Returns kResultFalse when no found parameter (paramID is set to kNoParamId in this case). */
-	virtual tresult PLUGIN_API getParameterIDFromFunctionName (UnitID unitID, FIDString functionName, ParamID& paramID) = 0;
-
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IParameterFunctionName, 0x6D21E1DC, 0x91199D4B, 0xA2A02FEF, 0x6C1AE55C)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstphysicalui.h

@@ -1,169 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstphysicalui.h
-// Created by  : Steinberg, 06/2018
-// Description : VST Physical User Interface support
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses.
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/vst/ivstnoteexpression.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** \defgroup vst3typedef VST 3 Data Types */
-/*@{*/
-//------------------------------------------------------------------------
-/** Physical UI Type */
-typedef uint32 PhysicalUITypeID;
-/*@}*/
-
-//------------------------------------------------------------------------
-/** PhysicalUITypeIDs describes the type of Physical UI (PUI) which could be associated to a note
-expression.
-\see PhysicalUIMap
-*/
-enum PhysicalUITypeIDs
-{
-	/** absolute X position when touching keys of PUIs. Range [0=left, 0.5=middle, 1=right] */
-	kPUIXMovement = 0,
-	/** absolute Y position when touching keys of PUIs. Range [0=bottom/near, 0.5=center, 1=top/far] */
-	kPUIYMovement,
-	/** pressing a key down on keys of PUIs. Range [0=No Pressure, 1=Full Pressure] */
-	kPUIPressure,
-
-	kPUITypeCount, ///< count of current defined PUIs
-
-	kInvalidPUITypeID = 0xFFFFFFFF ///< indicates an invalid or not initialized PUI type
-};
-
-//------------------------------------------------------------------------
-/** PhysicalUIMap describes a mapping of a noteExpression Type to a Physical UI Type.
-It is used in PhysicalUIMapList.
-\see PhysicalUIMapList 
-*/
-struct PhysicalUIMap
-{
-	/** This represents the physical UI. /see PhysicalUITypeIDs, this is set by the caller of
-	 * getPhysicalUIMapping */
-	PhysicalUITypeID physicalUITypeID;
-
-	/** This represents the associated noteExpression TypeID to the given physicalUITypeID. This
-	 * will be filled by the plug-in in the call getPhysicalUIMapping, set it to kInvalidTypeID if
-	 * no Note Expression is associated to the given PUI. */
-	NoteExpressionTypeID noteExpressionTypeID;
-};
-
-//------------------------------------------------------------------------
-/** PhysicalUIMapList describes a list of PhysicalUIMap
-\see INoteExpressionPhysicalUIMapping
-*/
-struct PhysicalUIMapList
-{
-	/** Count of entries in the map array, set by the caller of getPhysicalUIMapping. */
-	uint32 count;
-
-	/** Pointer to a list of PhysicalUIMap containing count entries. */
-	PhysicalUIMap* map;
-};
-
-//------------------------------------------------------------------------
-/** Extended plug-in interface IEditController for note expression event support: Vst::INoteExpressionPhysicalUIMapping
-\ingroup vstIPlug vst3611
-- [plug imp]
-- [extends IEditController]
-- [released: 3.6.11]
-- [optional]
-
-With this plug-in interface, the host can retrieve the preferred physical mapping associated to note
-expression supported by the plug-in.
-When the mapping changes (for example when switching presets) the plug-in needs
-to inform the host about it via \ref IComponentHandler::restartComponent (kNoteExpressionChanged).
-
-\section INoteExpressionPhysicalUIMappingExample Example
-
-\code{.cpp}
-//------------------------------------------------------------------------
-// here an example of how a VST3 plug-in could support this INoteExpressionPhysicalUIMapping interface.
-// we need to define somewhere the iids:
-
-//in MyController class declaration
-class MyController : public Vst::EditController, public Vst::INoteExpressionPhysicalUIMapping
-{
-	// ...
-	//--- INoteExpressionPhysicalUIMapping ---------------------------------
-	tresult PLUGIN_API getPhysicalUIMapping (int32 busIndex, int16 channel, PhysicalUIMapList& list) SMTG_OVERRIDE;
-	// ...
-
-	OBJ_METHODS (MyController, Vst::EditController)
-	DEFINE_INTERFACES
-		// ...
-		DEF_INTERFACE (Vst::INoteExpressionPhysicalUIMapping)
-	END_DEFINE_INTERFACES (Vst::EditController)
-	//...
-}
-
-// In mycontroller.cpp
-#include "pluginterfaces/vst/ivstnoteexpression.h"
-
-namespace Steinberg {
-	namespace Vst {
-		DEF_CLASS_IID (INoteExpressionPhysicalUIMapping)
-	}
-}
-//------------------------------------------------------------------------
-tresult PLUGIN_API MyController::getPhysicalUIMapping (int32 busIndex, int16 channel, PhysicalUIMapList& list)
-{
-	if (busIndex == 0 && channel == 0)
-	{
-		for (uint32 i = 0; i < list.count; ++i)
-		{
-			NoteExpressionTypeID type = kInvalidTypeID;
-			if (kPUIXMovement == list.map[i].physicalUITypeID)
-				list.map[i].noteExpressionTypeID = kCustomStart + 1;
-			else if (kPUIYMovement == list.map[i].physicalUITypeID)
-				list.map[i].noteExpressionTypeID = kCustomStart + 2;
-		}
-		return kResultTrue;
-	}
-	return kResultFalse;
-}
-\endcode
-*/
-class INoteExpressionPhysicalUIMapping : public FUnknown
-{
-public:
-	/** Fills the list of mapped [physical UI (in) - note expression (out)] for a given bus index
-	 * and channel. */
-	virtual tresult PLUGIN_API getPhysicalUIMapping (int32 busIndex, int16 channel,
-	                                                 PhysicalUIMapList& list) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (INoteExpressionPhysicalUIMapping, 0xB03078FF, 0x94D24AC8, 0x90CCD303, 0xD4133324)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstpluginterfacesupport.h

@@ -1,67 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstpluginterfacesupport.h
-// Created by  : Steinberg, 11/2018
-// Description : VST Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-//------------------------------------------------------------------------
-/** Host callback interface for an edit controller: Vst::IPlugInterfaceSupport
-\ingroup vstIHost vst3612
-- [host imp]
-- [released: 3.6.12]
-- [optional]
-
-Allows a plug-in to ask the host if a given plug-in interface is supported/used by the host.
-It is implemented by the hostContext given when the component is initialized.
-
-\section IPlugInterfaceSupportExample Example
-
-\code{.cpp}
-//------------------------------------------------------------------------
-tresult PLUGIN_API MyPluginController::initialize (FUnknown* context)
-{
-	// ...
-	FUnknownPtr<IPlugInterfaceSupport> plugInterfaceSupport (context);
-	if (plugInterfaceSupport)
-	{
-		if (plugInterfaceSupport->isPlugInterfaceSupported (IMidiMapping::iid) == kResultTrue)
-			// IMidiMapping is used by the host
-	}
-	// ...
-}
-\endcode
-\see IPluginBase
-*/
-class IPlugInterfaceSupport : public FUnknown
-{
-public:
-	/** Returns kResultTrue if the associated interface to the given _iid is supported/used by the host. */
-	virtual tresult PLUGIN_API isPlugInterfaceSupported (const TUID _iid) = 0;
-	
- //------------------------------------------------------------------------
- static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IPlugInterfaceSupport, 0x4FB58B9E, 0x9EAA4E0F, 0xAB361C1C, 0xCCB56FEA)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/pluginterfaces/vst/ivstplugview.h

@@ -1,62 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstplugview.h
-// Created by  : Steinberg, 01/2009
-// Description : Plug-in User Interface Extension
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-//------------------------------------------------------------------------
-// IParameterFinder Interface
-//------------------------------------------------------------------------
-/** Extension for IPlugView to find view parameters (lookup value under mouse support): Vst::IParameterFinder
-\ingroup pluginGUI vst302
-- [plug imp]
-- [extends IPlugView]
-- [released: 3.0.2]
-- [optional]
-
-It is highly recommended to implement this interface.
-A host can implement important functionality when a plug-in supports this interface.
-
-For example, all Steinberg hosts require this interface in order to support the "AI Knob".
-*/
-class IParameterFinder: public FUnknown
-{
-public:
-	//------------------------------------------------------------------------
-	/** Find out which parameter in plug-in view is at given position (relative to plug-in view). */
-	virtual tresult PLUGIN_API findParameter (int32 xPos, int32 yPos, ParamID& resultTag /*out*/) = 0;
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IParameterFinder, 0x0F618302, 0x215D4587, 0xA512073C, 0x77B9D383)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstprefetchablesupport.h

@@ -1,99 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstprefetchablesupport.h
-// Created by  : Steinberg, 02/2015
-// Description : VST Prefetchable Support Interface
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/vst/vsttypes.h"
-#include "pluginterfaces/vst/ivstattributes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-// ------------------------------------------------------------------------
-/** \defgroup vst3typedef VST 3 Data Types */
-/*@{*/
-//------------------------------------------------------------------------
-/** Prefetchable Support Type */
-typedef uint32 PrefetchableSupport;
-/*@}*/
-
-/** Prefetchable Support Enum */
-enum ePrefetchableSupport
-{
-	kIsNeverPrefetchable = 0,	///< every instance of the plug does not support prefetch processing
-	kIsYetPrefetchable,			///< in the current state the plug support prefetch processing
-	kIsNotYetPrefetchable,		///< in the current state the plug does not support prefetch processing
-	kNumPrefetchableSupport
-};
-
-//------------------------------------------------------------------------
-// IPrefetchableSupport Interface
-//------------------------------------------------------------------------
-/** Indicates that the plug-in could or not support Prefetch (dynamically): Vst::IPrefetchableSupport
-\ingroup vstIPlug vst365
-- [plug imp]
-- [extends IComponent]
-- [released: 3.6.5]
-- [optional]
-
-The plug-in should implement this interface if it needs to dynamically change between prefetchable or not.
-By default (without implementing this interface) the host decides in which mode the plug-in is processed.
-For more info about the prefetch processing mode check the ProcessModes::kPrefetch documentation.
-
-\section IPrefetchableSupportExample Example
-
-\code{.cpp}
-//------------------------------------------------------------------------
-tresult PLUGIN_API myPlug::getPrefetchableSupport (PrefetchableSupport& prefetchable)
-{
-	prefetchable = kIsNeverPrefetchable;
-
-	switch (myPrefetchableMode)
-	{
-		case 0: prefetchable = kIsNeverPrefetchable; break;
-		case 1: prefetchable = kIsYetPrefetchable; break;
-		case 2: prefetchable = kIsNotYetPrefetchable; break;
-	}
-	return kResultOk;
-}
-\endcode
-*/
-class IPrefetchableSupport : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** retrieve the current prefetch support. Use IComponentHandler::restartComponent
-	   (kPrefetchableSupportChanged) to inform the host that this support has changed. */
-	virtual tresult PLUGIN_API getPrefetchableSupport (PrefetchableSupport& prefetchable /*out*/) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IPrefetchableSupport, 0x8AE54FDA, 0xE93046B9, 0xA28555BC, 0xDC98E21E)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstprocesscontext.h

@@ -1,153 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstprocesscontext.h
-// Created by  : Steinberg, 10/2005
-// Description : VST Processing Context Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-//------------------------------------------------------------------------
-/** Frame Rate 
-A frame rate describes the number of image (frame) displayed per second.
-Some examples:
-	- 23.976 fps     is framesPerSecond: 24 and flags: kPullDownRate
-	- 24 fps         is framesPerSecond: 24 and flags: 0
-	- 25 fps         is framesPerSecond: 25 and flags: 0
-	- 29.97 drop fps is framesPerSecond: 30 and flags: kDropRate|kPullDownRate
-	- 29.97 fps      is framesPerSecond: 30 and flags: kPullDownRate
-	- 30 fps         is framesPerSecond: 30 and flags: 0
-	- 30 drop fps    is framesPerSecond: 30 and flags: kDropRate
-	- 50 fps         is framesPerSecond: 50 and flags: 0
-	- 59.94 fps	     is framesPerSecond: 60 and flags: kPullDownRate
-	- 60 fps         is framesPerSecond: 60 and flags: 0
-*/
-struct FrameRate
-{
-//------------------------------------------------------------------------
-	enum FrameRateFlags
-	{
-		kPullDownRate = 1 << 0,
-		kDropRate     = 1 << 1
-	};
-
-	uint32 framesPerSecond;		///< frame rate
-	uint32 flags;				///< flags #FrameRateFlags
-//------------------------------------------------------------------------
-};
-
-//------------------------------------------------------------------------
-/** Description of a chord.
-A chord is described with a key note, a root note and the
-\copydoc chordMask
-\see ProcessContext
-*/
-struct Chord
-{
-//------------------------------------------------------------------------
-	uint8 keyNote;		///< key note in chord
-	uint8 rootNote;		///< lowest note in chord
-
-	/** Bitmask of a chord. \n
-	    1st bit set: minor second; 2nd bit set: major second, and so on. \n
-		There is \b no bit for the keynote (root of the chord) because it is inherently always present. \n
-		Examples:
-		- XXXX 0000 0100 1000 (= 0x0048) -> major chord
-		- XXXX 0000 0100 0100 (= 0x0044) -> minor chord
-		- XXXX 0010 0100 0100 (= 0x0244) -> minor chord with minor seventh */
-	int16 chordMask;
-
-	enum Masks {
-		kChordMask = 0x0FFF,	///< mask for chordMask
-		kReservedMask = 0xF000	///< reserved for future use
-	};
-//------------------------------------------------------------------------
-};
-
-//------------------------------------------------------------------------
-/** Audio processing context.
-For each processing block the host provides timing information and musical parameters that can
-change over time. For a host that supports jumps (like cycle) it is possible to split up a
-processing block into multiple parts in order to provide a correct project time inside of every
-block, but this behavior is not mandatory. Since the timing will be correct at the beginning of the
-next block again, a host that is dependent on a fixed processing block size can choose to neglect
-this problem.
-\see IAudioProcessor, ProcessData
-*/
-struct ProcessContext
-{
-//------------------------------------------------------------------------
-	/** Transport state & other flags */
-	enum StatesAndFlags
-	{
-		kPlaying          = 1 << 1,		///< currently playing
-		kCycleActive      = 1 << 2,		///< cycle is active
-		kRecording        = 1 << 3,		///< currently recording
-
-		kSystemTimeValid  = 1 << 8,		///< systemTime contains valid information
-		kContTimeValid    = 1 << 17,	///< continousTimeSamples contains valid information
-
-		kProjectTimeMusicValid = 1 << 9,///< projectTimeMusic contains valid information
-		kBarPositionValid = 1 << 11,	///< barPositionMusic contains valid information
-		kCycleValid       = 1 << 12,	///< cycleStartMusic and barPositionMusic contain valid information
-
-		kTempoValid       = 1 << 10,	///< tempo contains valid information
-		kTimeSigValid     = 1 << 13,	///< timeSigNumerator and timeSigDenominator contain valid information
-		kChordValid       = 1 << 18,	///< chord contains valid information
-
-		kSmpteValid       = 1 << 14,	///< smpteOffset and frameRate contain valid information
-		kClockValid       = 1 << 15		///< samplesToNextClock valid
-	};
-
-	uint32 state;					///< a combination of the values from \ref StatesAndFlags
-
-	double sampleRate;				///< current sample rate					(always valid)
-	TSamples projectTimeSamples;	///< project time in samples				(always valid)
-
-	int64 systemTime;				///< system time in nanoseconds					(optional)
-	TSamples continousTimeSamples;	///< project time, without loop					(optional)
-
-	TQuarterNotes projectTimeMusic;	///< musical position in quarter notes (1.0 equals 1 quarter note) (optional)
-	TQuarterNotes barPositionMusic;	///< last bar start position, in quarter notes	(optional)
-	TQuarterNotes cycleStartMusic;	///< cycle start in quarter notes				(optional)
-	TQuarterNotes cycleEndMusic;	///< cycle end in quarter notes					(optional)
-
-	double tempo;					///< tempo in BPM (Beats Per Minute)			(optional)
-	int32 timeSigNumerator;			///< time signature numerator (e.g. 3 for 3/4)	(optional)
-	int32 timeSigDenominator;		///< time signature denominator (e.g. 4 for 3/4) (optional)
-
-	Chord chord;					///< musical info								(optional)
-
-	int32 smpteOffsetSubframes;		///< SMPTE (sync) offset in subframes (1/80 of frame) (optional)
-	FrameRate frameRate;			///< frame rate									(optional)
-
-	int32 samplesToNextClock;		///< MIDI Clock Resolution (24 Per Quarter Note), can be negative (nearest) (optional)
-//------------------------------------------------------------------------
-};
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivstrepresentation.h

@@ -1,364 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstrepresentation.h
-// Created by  : Steinberg, 08/2010
-// Description : VST Representation Interface
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-class IBStream;
-
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** RepresentationInfo is the structure describing a representation
-This structure is used in the function \see IXmlRepresentationController::getXmlRepresentationStream.
-\see IXmlRepresentationController 
-*/
-struct RepresentationInfo
-{
-	RepresentationInfo ()
-	{
-		memset (vendor, 0, kNameSize);
-		memset (name, 0, kNameSize);
-		memset (version, 0, kNameSize);
-		memset (host, 0, kNameSize); 
-	}
-	
-	RepresentationInfo (char8* _vendor, char8* _name = nullptr, char8* _version = nullptr, char8* _host = nullptr)
-	{
-		memset (vendor, 0, kNameSize);
-		if (_vendor)
-			strcpy (vendor,	_vendor);
-		memset (name, 0, kNameSize);
-		if (_name)
-			strcpy (name, _name);
-		memset (version, 0, kNameSize);
-		if (_version)
-			strcpy (version, _version);
-		memset (host, 0, kNameSize);
-		if (_host)
-			strcpy (host, _host);
-	}
-
-	enum
-	{
-		kNameSize = 64
-	};
-	char8 vendor[kNameSize];	///< Vendor name of the associated representation (remote) (eg. "Yamaha").
-	char8 name[kNameSize];		///< Representation (remote) Name (eg. "O2").
-	char8 version[kNameSize];	///< Version of this "Remote" (eg. "1.0").
-	char8 host[kNameSize];		///< Optional: used if the representation is for a given host only (eg. "Nuendo").
-};
-
-
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-/** Extended plug-in interface IEditController for a component: Vst::IXmlRepresentationController
-\ingroup vstIPlug vst350
-- [plug imp]
-- [extends IEditController]
-- [released: 3.5.0]
-- [optional]
-
-A representation based on XML is a way to export, structure, and group plug-ins parameters for a specific remote (hardware or software rack (such as quick controls)).
-\n
-It allows to describe each parameter more precisely (what is the best matching to a knob, different title lengths matching limited remote display,...).\n See an \ref Example.
- \n\n
-- A representation is composed of pages (this means that to see all exported parameters, the user has to navigate through the pages).
-- A page is composed of cells (for example 8 cells per page).
-- A cell is composed of layers (for example a cell could have a knob, a display, and a button, which means 3 layers).
-- A layer is associated to a plug-in parameter using the ParameterID as identifier:
-	- it could be a knob with a display for title and/or value, this display uses the same parameterId, but it could an another one.
-	- switch
-	- link which allows to jump directly to a subpage (another page) 
-	- more... See Vst::LayerType
-.
-
-\n
-This representation is implemented as XML text following the Document Type Definition (DTD): http://dtd.steinberg.net/VST-Remote-1.1.dtd
-
-\section Example
-Here an example of what should be passed in the stream of getXmlRepresentationStream:
-
-\code
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE vstXML PUBLIC "-//Steinberg//DTD VST Remote 1.1//EN" "http://dtd.steinberg.net/VST-Remote-1.1.dtd">
-<vstXML version="1.0">
-	<plugin classID="341FC5898AAA46A7A506BC0799E882AE" name="Chorus" vendor="Steinberg Media Technologies" />
-	<originator>My name</originator>
-	<date>2010-12-31</date>
-	<comment>This is an example for 4 Cells per Page for the Remote named ProductRemote 
-	         from company HardwareCompany.</comment>
-
-	<!-- ===================================== -->
-	<representation name="ProductRemote" vendor="HardwareCompany" version="1.0">
-		<page name="Root">
-			<cell>
-				<layer type="knob" parameterID="0">
-					<titleDisplay>
-						<name>Mix dry/wet</name>
-						<name>Mix</name>
-					</titleDisplay>
-				</layer>
-			</cell>
-			<cell>
-				<layer type="display"></layer>
-			</cell>
-			<cell>
-				<layer type="knob" parameterID="3">
-					<titleDisplay>
-						<name>Delay</name>
-						<name>Dly</name>
-					</titleDisplay>
-				</layer>
-			</cell>
-			<cell>
-				<layer type="knob" parameterID="15">
-					<titleDisplay>
-						<name>Spatial</name>
-						<name>Spat</name>
-					</titleDisplay>
-				</layer>
-			</cell>
-		</page>
-		<page name="Page 2">
-			<cell>
-				<layer type="LED" ledStyle="spread" parameterID="2">
-					<titleDisplay>
-						<name>Width +</name>
-						<name>Widt</name>
-					</titleDisplay>
-				</layer>
-				<!--this is the switch for shape A/B-->
-				<layer type="switch" switchStyle="pushIncLooped" parameterID="4"></layer>
-			</cell>
-			<cell>
-				<layer type="display"></layer>
-			</cell>
-			<cell>
-				<layer type="LED" ledStyle="singleDot" parameterID="17">
-					<titleDisplay>
-						<name>Sync Note +</name>
-						<name>Note</name>
-					</titleDisplay>
-				</layer>
-				<!--this is the switch for sync to tempo on /off-->
-				<layer type="switch" switchStyle="pushIncLooped" parameterID="16"></layer>
-			</cell>
-			<cell>
-				<layer type="knob" parameterID="1">
-					<titleDisplay>
-						<name>Rate</name>
-					</titleDisplay>
-				</layer>
-			</cell>
-		</page>
-	</representation>
-</vstXML>
-\endcode
-*/
-class IXmlRepresentationController : public FUnknown
-{
-public:
-	/** Retrieves a stream containing a XmlRepresentation for a wanted representation info */
-	virtual tresult PLUGIN_API getXmlRepresentationStream (RepresentationInfo& info /*in*/,
-	                                                       IBStream* stream /*out*/) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IXmlRepresentationController, 0xA81A0471, 0x48C34DC4, 0xAC30C9E1, 0x3C8393D5)
-
-//------------------------------------------------------------------------
-/** Defines for XML representation Tags and Attributes */
-
-#define ROOTXML_TAG			"vstXML"
-
-#define COMMENT_TAG			"comment"
-#define CELL_TAG			"cell"
-#define CELLGROUP_TAG		"cellGroup"
-#define CELLGROUPTEMPLATE_TAG	"cellGroupTemplate"
-#define CURVE_TAG			"curve"
-#define CURVETEMPLATE_TAG	"curveTemplate"
-#define DATE_TAG			"date"
-#define LAYER_TAG			"layer"
-#define NAME_TAG			"name"
-#define ORIGINATOR_TAG		"originator"
-#define PAGE_TAG			"page"
-#define PAGETEMPLATE_TAG	"pageTemplate"
-#define PLUGIN_TAG			"plugin"
-#define VALUE_TAG			"value"
-#define VALUEDISPLAY_TAG	"valueDisplay"
-#define VALUELIST_TAG		"valueList"
-#define REPRESENTATION_TAG	"representation"
-#define SEGMENT_TAG			"segment"
-#define SEGMENTLIST_TAG		"segmentList"
-#define TITLEDISPLAY_TAG	"titleDisplay"
-
-#define ATTR_CATEGORY		"category"
-#define ATTR_CLASSID		"classID"
-#define ATTR_ENDPOINT		"endPoint"
-#define ATTR_INDEX			"index"
-#define ATTR_FLAGS			"flags"
-#define ATTR_FUNCTION		"function"
-#define ATTR_HOST			"host"
-#define ATTR_LEDSTYLE		"ledStyle"
-#define ATTR_LENGTH			"length"
-#define ATTR_LINKEDTO		"linkedTo"
-#define ATTR_NAME			"name"
-#define ATTR_ORDER			"order"
-#define ATTR_PAGE			"page"
-#define ATTR_PARAMID		"parameterID"
-#define ATTR_STARTPOINT		"startPoint"
-#define ATTR_STYLE			"style"
-#define ATTR_SWITCHSTYLE	"switchStyle"
-#define ATTR_TEMPLATE		"template"
-#define ATTR_TURNSPERFULLRANGE	"turnsPerFullRange"
-#define ATTR_TYPE			"type"
-#define ATTR_UNITID			"unitID"
-#define ATTR_VARIABLES		"variables"
-#define ATTR_VENDOR			"vendor"
-#define ATTR_VERSION		"version"
-
-//------------------------------------------------------------------------
-/** Defines some predefined Representation Remote Names */
-#define GENERIC 				"Generic"
-#define GENERIC_4_CELLS			"Generic 4 Cells"
-#define GENERIC_8_CELLS			"Generic 8 Cells"
-#define GENERIC_12_CELLS		"Generic 12 Cells"
-#define GENERIC_24_CELLS		"Generic 24 Cells"
-#define GENERIC_N_CELLS			"Generic %d Cells"
-#define QUICK_CONTROL_8_CELLS	"Quick Controls 8 Cells"
-
-//------------------------------------------------------------------------
-/** Layer Types used in a VST XML Representation */ 
-namespace LayerType
-{
-	enum 
-	{
-		kKnob = 0, 		///< a knob (encoder or not)
-		kPressedKnob,  	///< a knob which is used by pressing and turning
-		kSwitchKnob,	///< knob could be pressed to simulate a switch
-		kSwitch,		///< a "on/off" button
-		kLED,			///< LED like VU-meter or display around a knob
-		kLink,			///< indicates that this layer is a folder linked to an another INode (page)
-		kDisplay,		///< only for text display (not really a control)
-		kFader,			///< a fader
-		kEndOfLayerType
-	};
-
-	/** FIDString variant of the LayerType */
-	static const FIDString layerTypeFIDString[] = {
-		"knob"
-		,"pressedKnob"
-		,"switchKnob"
-		,"switch"
-		,"LED"
-		,"link"
-		,"display"
-		,"fader"
-		,nullptr
-	};
-};
-
-//------------------------------------------------------------------------
-/** Curve Types used in a VST XML Representation */ 
-namespace CurveType
-{
-	const CString kSegment		= "segment";	///<
-	const CString kValueList	= "valueList";	///<
-};
-
-//------------------------------------------------------------------------
-/** Attributes used to defined a Layer in a VST XML Representation */ 
-namespace Attributes
-{
-	const CString kStyle		= ATTR_STYLE;			///< string attribute : See AttributesStyle for available string value
-	const CString kLEDStyle		= ATTR_LEDSTYLE;		///< string attribute : See AttributesStyle for available string value
-	const CString kSwitchStyle	= ATTR_SWITCHSTYLE;		///< string attribute : See AttributesStyle for available string value
-	const CString kKnobTurnsPerFullRange = ATTR_TURNSPERFULLRANGE;	///< float attribute
-	const CString kFunction		= ATTR_FUNCTION;		///< string attribute : See AttributesFunction for available string value
-	const CString kFlags		= ATTR_FLAGS;			///< string attribute : See AttributesFlags for available string value
-};
-
-//------------------------------------------------------------------------
-/** Attributes Function used to defined the function of a Layer in a VST XML Representation */ 
-namespace AttributesFunction
-{
-	/// Global Style
-	const CString kPanPosCenterXFunc		= "PanPosCenterX";		///< Gravity point X-axis (L-R) (for stereo: middle between left and right)
-	const CString kPanPosCenterYFunc		= "PanPosCenterY";		///< Gravity point Y-axis (Front-Rear)
-	const CString kPanPosFrontLeftXFunc		= "PanPosFrontLeftX";	///< Left channel Position in X-axis
-	const CString kPanPosFrontLeftYFunc		= "PanPosFrontLeftY";	///< Left channel Position in Y-axis
-	const CString kPanPosFrontRightXFunc	= "PanPosFrontRightX";	///< Right channel Position in X-axis
-	const CString kPanPosFrontRightYFunc	= "PanPosFrontRightY";	///< Right channel Position in Y-axis
-	const CString kPanRotationFunc			= "PanRotation";		///< Rotation around the Center (gravity point)
-	const CString kPanLawFunc				= "PanLaw";				///< Panning Law
-	const CString kPanMirrorModeFunc		= "PanMirrorMode";		///< Panning Mirror Mode
-	const CString kPanLfeGainFunc			= "PanLfeGain";			///< Panning LFE Gain
-	const CString kGainReductionFunc		= "GainReduction";		///< Gain Reduction for compressor
-	const CString kSoloFunc					= "Solo";				///< Solo
-	const CString kMuteFunc					= "Mute";				///< Mute
-	const CString kVolumeFunc				= "Volume";				///< Volume
-};
-
-//------------------------------------------------------------------------
-/** Attributes Style associated a specific Layer Type in a VST XML Representation */ 
-namespace AttributesStyle
-{
-	/// Global Style
-	const CString kInverseStyle			= "inverse";	///< the associated layer should use the inverse value of parameter (1 - x).
-
-	/// LED Style
-	const CString kLEDWrapLeftStyle		= "wrapLeft";	///< |======>----- (the default one if not specified)
-	const CString kLEDWrapRightStyle	= "wrapRight";	///< -------<====|
-	const CString kLEDSpreadStyle		= "spread";		///< ---<==|==>---
-	const CString kLEDBoostCutStyle		= "boostCut";	///< ------|===>--
-	const CString kLEDSingleDotStyle	= "singleDot";	///< --------|----
-
-	/// Switch Style
-	const CString kSwitchPushStyle		= "push";		///< Apply only when pressed, unpressed will reset the value to min.
-	const CString kSwitchPushIncLoopedStyle	= "pushIncLooped";	///< Push will increment the value. When the max is reached it will restart with min.
-																///< The default one if not specified (with 2 states values it is a OnOff switch).
-	const CString kSwitchPushDecLoopedStyle	= "pushDecLooped";	///< Push will decrement the value. When the min is reached it will restart with max.
-	const CString kSwitchPushIncStyle	= "pushInc";	///< Increment after each press (delta depends of the curve).
-	const CString kSwitchPushDecStyle	= "pushDec";	///< Decrement after each press (delta depends of the curve).
-	const CString kSwitchLatchStyle		= "latch";		///< Each push-release will change the value between min and max. 
-														///< A timeout between push and release could be used to simulate a push style (if timeout is reached).
-};
-
-//------------------------------------------------------------------------
-/** Attributes Flags defining a Layer in a VST XML Representation */ 
-namespace AttributesFlags
-{
-	const CString kHideableFlag			= "hideable";	///< the associated layer marked as hideable allows a remote to hide or make it not usable a parameter when the associated value is inactive 
-};
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/ivsttestplugprovider.h

@@ -1,109 +0,0 @@
-//-----------------------------------------------------------------------------
-// Flags       : clang-format SMTGSequencer
-// Project     : VST SDK
-//
-// Category    : Validator
-// Filename    : public.sdk/source/vst/testsuite/iplugprovider.h
-// Created by  : Steinberg, 04/2005
-// Description : VST Test Suite
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2020, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistributions of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this
-//     software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/istringresult.h"
-#include "pluginterfaces/vst/ivstcomponent.h"
-#include "pluginterfaces/vst/ivsteditcontroller.h"
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Test Helper.
- * \ingroup TestClass
- *
- *	This class provides access to the component and the controller of a plug-in when running a unit
- *	test (see ITest).
- * 	You get this interface as the context argument in the ITestFactory::createTests method.
- */
-//------------------------------------------------------------------------
-class ITestPlugProvider : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** get the component of the plug-in.
-	 *
-	 * The reference count of the component is increased in this function and you need to call
-	 * releasePlugIn when done with the component.
-	 */
-	virtual IComponent* PLUGIN_API getComponent () = 0;
-	/** get the controller of the plug-in.
-	 *
-	 * The reference count of the controller is increased in this function and you need to call
-	 * releasePlugIn when done with the controller.
-	 */
-	virtual IEditController* PLUGIN_API getController () = 0;
-	/** release the component and/or controller */
-	virtual tresult PLUGIN_API releasePlugIn (IComponent* component,
-	                                          IEditController* controller) = 0;
-	/** get the sub categories of the plug-in */
-	virtual tresult PLUGIN_API getSubCategories (IStringResult& result) const = 0;
-	/** get the component UID of the plug-in */
-	virtual tresult PLUGIN_API getComponentUID (FUID& uid) const = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (ITestPlugProvider, 0x86BE70EE, 0x4E99430F, 0x978F1E6E, 0xD68FB5BA)
-
-//------------------------------------------------------------------------
-/** Test Helper extension.
- * \ingroup TestClass
- */
-class ITestPlugProvider2 : public ITestPlugProvider
-{
-public:
-	/** get the plugin factory.
-	 *
-	 * The reference count of the returned factory object is not increased when calling this
-	 * function.
-	 */
-	virtual IPluginFactory* PLUGIN_API getPluginFactory () = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (ITestPlugProvider2, 0xC7C75364, 0x7B8343AC, 0xA4495B0A, 0x3E5A46C7)
-
-//------------------------------------------------------------------------
-} // Vst
-} // Steinberg

source/includes/vst3sdk/pluginterfaces/vst/ivstunits.h

@@ -1,271 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/ivstunits.h
-// Created by  : Steinberg, 2005
-// Description : VST Units Interfaces
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/funknown.h"
-#include "pluginterfaces/vst/vsttypes.h"
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpush.h"
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-class IBStream;
-//------------------------------------------------------------------------
-namespace Vst {
-//------------------------------------------------------------------------
-/** Special UnitIDs for UnitInfo */
-static const UnitID kRootUnitId	= 0;        ///< identifier for the top level unit (root)
-static const UnitID kNoParentUnitId = -1;	///< used for the root unit which does not have a parent.
-
-//------------------------------------------------------------------------
-/** Special ProgramListIDs for UnitInfo */
-static const ProgramListID kNoProgramListId = -1;	///< no programs are used in the unit.
-
-//------------------------------------------------------------------------
-/** Basic Unit Description.
-\see IUnitInfo
-*/
-struct UnitInfo
-{
-	UnitID id;						///< unit identifier
-	UnitID parentUnitId;			///< identifier of parent unit (kNoParentUnitId: does not apply, this unit is the root)
-	String128 name;					///< name, optional for the root component, required otherwise
-	ProgramListID programListId;	///< id of program list used in unit (kNoProgramListId = no programs used in this unit)
-};
-
-//------------------------------------------------------------------------
-/** Basic Program List Description.
-\see IUnitInfo
-*/
-struct ProgramListInfo
-{
-	ProgramListID id;				///< program list identifier
-	String128 name;					///< name of program list
-	int32 programCount;				///< number of programs in this list
-};
-
-//------------------------------------------------------------------------
-/** Special programIndex value for IUnitHandler::notifyProgramListChange */
-static const int32 kAllProgramInvalid =	-1;		///< all program information is invalid
-
-//------------------------------------------------------------------------
-/** Host callback for unit support: Vst::IUnitHandler
-\ingroup vstIHost vst300
-- [host imp]
-- [extends IComponentHandler]
-- [released: 3.0.0]
-- [optional]
-
-Host callback interface, used with IUnitInfo.
-Retrieve via queryInterface from IComponentHandler.
-
-\see \ref vst3Units, IUnitInfo
-*/
-class IUnitHandler : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Notify host when a module is selected in plug-in GUI. */
-	virtual tresult PLUGIN_API notifyUnitSelection (UnitID unitId) = 0;
-
-	/** Tell host that the plug-in controller changed a program list (rename, load, PitchName changes).
-	    \param listId is the specified program list ID to inform.
-		\param programIndex : when kAllProgramInvalid, all program information is invalid, otherwise only the program of given index. */
-	virtual tresult PLUGIN_API notifyProgramListChange (ProgramListID listId, int32 programIndex) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IUnitHandler, 0x4B5147F8, 0x4654486B, 0x8DAB30BA, 0x163A3C56)
-
-//------------------------------------------------------------------------
-/** Host callback for extended unit support: Vst::IUnitHandler2
-\ingroup vstIHost vst365
-- [host imp]
-- [extends IUnitHandler]
-- [released: 3.6.5]
-- [optional]
-
-Host callback interface, used with IUnitInfo.
-Retrieve via queryInterface from IComponentHandler.
-
-The plug-in has the possibility to inform the host with notifyUnitByBusChange that something has
-changed in the bus - unit assignment, the host then has to recall IUnitInfo::getUnitByBus in order
-to get the new relations between busses and unit.
-
-\see \ref vst3Units, IUnitHandler
-*/
-class IUnitHandler2 : public FUnknown
-{
-public:
-	//------------------------------------------------------------------------
-	/** Tell host that assignment Unit-Bus defined by IUnitInfo::getUnitByBus has changed. */
-	virtual tresult PLUGIN_API notifyUnitByBusChange () = 0;
-
-	//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IUnitHandler2, 0xF89F8CDF, 0x699E4BA5, 0x96AAC9A4, 0x81452B01)
-
-//------------------------------------------------------------------------
-/** Edit controller extension to describe the plug-in structure: Vst::IUnitInfo
-\ingroup vstIPlug vst300
-- [plug imp]
-- [extends IEditController]
-- [released: 3.0.0]
-- [optional]
-
-IUnitInfo describes the internal structure of the plug-in.
-- The root unit is the component itself, so getUnitCount must return 1 at least.
-- The root unit id has to be 0 (kRootUnitId).
-- Each unit can reference one program list - this reference must not change.
-- Each unit, using a program list, references one program of the list.
-
-\see \ref vst3Units, IUnitHandler
-*/
-class IUnitInfo : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Returns the flat count of units. */
-	virtual int32 PLUGIN_API getUnitCount () = 0;
-
-	/** Gets UnitInfo for a given index in the flat list of unit. */
-	virtual tresult PLUGIN_API getUnitInfo (int32 unitIndex, UnitInfo& info /*out*/) = 0;
-
-	/** Component intern program structure. */
-	/** Gets the count of Program List. */
-	virtual int32 PLUGIN_API getProgramListCount () = 0;
-
-	/** Gets for a given index the Program List Info. */
-	virtual tresult PLUGIN_API getProgramListInfo (int32 listIndex, ProgramListInfo& info /*out*/) = 0;
-
-	/** Gets for a given program list ID and program index its program name. */
-	virtual tresult PLUGIN_API getProgramName (ProgramListID listId, int32 programIndex, String128 name /*out*/) = 0;
-
-	/** Gets for a given program list ID, program index and attributeId the associated attribute value. */
-	virtual tresult PLUGIN_API getProgramInfo (ProgramListID listId, int32 programIndex,
-		CString attributeId /*in*/, String128 attributeValue /*out*/) = 0;
-
-	/** Returns kResultTrue if the given program index of a given program list ID supports PitchNames. */
-	virtual tresult PLUGIN_API hasProgramPitchNames (ProgramListID listId, int32 programIndex) = 0;
-
-	/** Gets the PitchName for a given program list ID, program index and pitch.
-		If PitchNames are changed the plug-in should inform the host with IUnitHandler::notifyProgramListChange. */
-	virtual tresult PLUGIN_API getProgramPitchName (ProgramListID listId, int32 programIndex,
-		int16 midiPitch, String128 name /*out*/) = 0;
-
-	// units selection --------------------
-	/** Gets the current selected unit. */
-	virtual UnitID PLUGIN_API getSelectedUnit () = 0;
-
-	/** Sets a new selected unit. */
-	virtual tresult PLUGIN_API selectUnit (UnitID unitId) = 0;
-
-	/** Gets the according unit if there is an unambiguous relation between a channel or a bus and a unit.
-	    This method mainly is intended to find out which unit is related to a given MIDI input channel. */
-	virtual tresult PLUGIN_API getUnitByBus (MediaType type, BusDirection dir, int32 busIndex,
-		int32 channel, UnitID& unitId /*out*/) = 0;
-
-	/** Receives a preset data stream.
-	    - If the component supports program list data (IProgramListData), the destination of the data
-		  stream is the program specified by list-Id and program index (first and second parameter)
-		- If the component supports unit data (IUnitData), the destination is the unit specified by the first
-		  parameter - in this case parameter programIndex is < 0). */
-	virtual tresult PLUGIN_API setUnitProgramData (int32 listOrUnitId, int32 programIndex, IBStream* data) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IUnitInfo, 0x3D4BD6B5, 0x913A4FD2, 0xA886E768, 0xA5EB92C1)
-
-//------------------------------------------------------------------------
-/** Component extension to access program list data: Vst::IProgramListData
-\ingroup vstIPlug vst300
-- [plug imp]
-- [extends IComponent]
-- [released: 3.0.0]
-- [optional]
-
-A component can support program list data via this interface or/and
-unit preset data (IUnitData).
-
-\see IUnitData, \ref vst3MultitimbralPrograms
-*/
-class IProgramListData : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Returns kResultTrue if the given Program List ID supports Program Data. */
-	virtual tresult PLUGIN_API programDataSupported (ProgramListID listId) = 0;
-
-	/** Gets for a given program list ID and program index the program Data. */
-	virtual tresult PLUGIN_API getProgramData (ProgramListID listId, int32 programIndex, IBStream* data) = 0;
-
-	/** Sets for a given program list ID and program index a program Data. */
-	virtual tresult PLUGIN_API setProgramData (ProgramListID listId, int32 programIndex, IBStream* data) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IProgramListData, 0x8683B01F, 0x7B354F70, 0xA2651DEC, 0x353AF4FF)
-
-//------------------------------------------------------------------------
-/** Component extension to access unit data: Vst::IUnitData
-\ingroup vstIPlug vst300
-- [plug imp]
-- [extends IComponent]
-- [released: 3.0.0]
-- [optional]
-
-A component can support unit preset data via this interface or
-program list data (IProgramListData).
-
-\see \ref vst3ProgramLists
-*/
-class IUnitData : public FUnknown
-{
-public:
-//------------------------------------------------------------------------
-	/** Returns kResultTrue if the specified unit supports export and import of preset data. */
-	virtual tresult PLUGIN_API unitDataSupported (UnitID unitID) = 0;
-
-	/** Gets the preset data for the specified unit. */
-	virtual tresult PLUGIN_API getUnitData (UnitID unitId, IBStream* data) = 0;
-
-	/** Sets the preset data for the specified unit. */
-	virtual tresult PLUGIN_API setUnitData (UnitID unitId, IBStream* data) = 0;
-
-//------------------------------------------------------------------------
-	static const FUID iid;
-};
-
-DECLARE_CLASS_IID (IUnitData, 0x6C389611, 0xD391455D, 0xB870B833, 0x94A0EFDD)
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg
-
-//------------------------------------------------------------------------
-#include "pluginterfaces/base/falignpop.h"
-//------------------------------------------------------------------------

source/includes/vst3sdk/pluginterfaces/vst/vstpshpack4.h

@@ -1,30 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/vstpshpack4.h
-// Created by  : Steinberg, 05/2010
-// Description : This file turns 4 Bytes packing of structures on. The file 
-//               pluginterfaces/base/falignpop.h is the complement to this file.
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-//----------------------------------------------------------------------------------------------
-#if defined __BORLANDC__ 
-	#pragma -a4 
-#else
-	#if (_MSC_VER >= 800 && !defined(_M_I86)) || defined(_PUSHPOP_SUPPORTED)
-		#pragma warning(disable:4103)
-	#endif
-
-	#pragma pack(push)
-	#pragma pack(4)
-#endif

source/includes/vst3sdk/pluginterfaces/vst/vsttypes.h

@@ -1,105 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Interfaces
-// Filename    : pluginterfaces/vst/vsttypes.h
-// Created by  : Steinberg, 12/2005
-// Description : Common Defines
-//
-//-----------------------------------------------------------------------------
-// This file is part of a Steinberg SDK. It is subject to the license terms
-// in the LICENSE file found in the top-level directory of this distribution
-// and at www.steinberg.net/sdklicenses. 
-// No part of the SDK, including this file, may be copied, modified, propagated,
-// or distributed except according to the terms contained in the LICENSE file.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/fstrdefs.h"
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-//------------------------------------------------------------------------
-/** VST3 SDK Version */
-#ifndef kVstVersionString
-#define kVstVersionString	"VST 3.7.2"	///< SDK version for PClassInfo2
-#endif
-
-#define kVstVersionMajor	3
-#define kVstVersionMinor	7
-#define kVstVersionSub		2
-
-#define VST_VERSION ((kVstVersionMajor << 16) | (kVstVersionMinor << 8) | kVstVersionSub)
-
-// Versions History which allows to write such code:
-// #if VST_VERSION >= VST_3_6_5_VERSION
-#define VST_3_7_2_VERSION	0x030702
-#define VST_3_7_1_VERSION	0x030701
-#define VST_3_7_0_VERSION	0x030700
-#define VST_3_6_14_VERSION	0x03060E
-#define VST_3_6_13_VERSION	0x03060D
-#define VST_3_6_12_VERSION	0x03060C
-#define VST_3_6_11_VERSION	0x03060B
-#define VST_3_6_10_VERSION	0x03060A
-#define VST_3_6_9_VERSION	0x030609
-#define VST_3_6_8_VERSION	0x030608
-#define VST_3_6_7_VERSION	0x030607
-#define VST_3_6_6_VERSION	0x030606
-#define VST_3_6_5_VERSION	0x030605
-#define VST_3_6_0_VERSION	0x030600
-#define VST_3_5_0_VERSION	0x030500
-#define VST_3_1_0_VERSION	0x030100
-#define VST_3_0_0_VERSION	0x030000
-
-//------------------------------------------------------------------------
-/** \defgroup vst3typedef VST 3 Data Types */
-/*@{*/
-//------------------------------------------------------------------------
-// String Types
-//------------------------------------------------------------------------
-typedef char16 TChar;			///< UTF-16 character
-typedef TChar String128[128];	///< 128 character UTF-16 string
-typedef const char8* CString;	///< C-String
-
-//------------------------------------------------------------------------
-// General
-//------------------------------------------------------------------------
-typedef int32 MediaType;		///< media type (audio/event)
-typedef int32 BusDirection;		///< bus direction (in/out)
-typedef int32 BusType;			///< bus type (main/aux)
-typedef int32 IoMode;			///< I/O mode (see \ref vst3IoMode)
-typedef int32 UnitID;			///< unit identifier
-typedef double ParamValue;		///< parameter value type
-typedef uint32 ParamID;			///< parameter identifier
-typedef int32 ProgramListID;	///< program list identifier
-typedef int16 CtrlNumber;		///< MIDI controller number (see \ref ControllerNumbers for allowed values)
-
-typedef double TQuarterNotes;	///< time expressed in quarter notes
-typedef int64 TSamples;			///< time expressed in audio samples
-
-typedef uint32 ColorSpec;		///< color defining by 4 component ARGB value (Alpha/Red/Green/Blue)
-
-//------------------------------------------------------------------------
-static const ParamID kNoParamId = 0xffffffff;	///< default for uninitialized parameter ID
-// static const ParamID kNoParamId = std::numeric_limits<ParamID>::max ();
-
-//------------------------------------------------------------------------
-// Audio Types
-//------------------------------------------------------------------------
-typedef float Sample32;				///< 32-bit precision audio sample
-typedef double Sample64;			///< 64-bit precision audio sample
-typedef double SampleRate;			///< sample rate
-
-//------------------------------------------------------------------------
-// Speaker Arrangements Types
-//------------------------------------------------------------------------
-typedef uint64 SpeakerArrangement;	///< Bitset of speakers
-typedef uint64 Speaker;	            ///< Bit for one speaker
-
-/*@}*/
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/LICENSE.txt

@@ -1,27 +0,0 @@
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------

source/includes/vst3sdk/public.sdk/README.md

@@ -1,18 +0,0 @@
-# Welcome to VST 3 SDK public_sdk
-
-Here are located:
-
-- helper classes implementing VST3 Interfaces
-- samples of VST3 Hosting and VST3 Plug-Ins
-- AAX Wrapper
-- AU Wrapper
-- AUv3 Wrapper
-- VST2 Wrapper
-- InterAppAudio
-
-## License & Usage guidelines
-
-More details are found at [VST 3 SDK public_sdk License](https://forums.steinberg.net/t/vst-3-sdk-public-sdk-license/695592)
-
-----
-Return to [VST 3 SDK](https://github.com/steinbergmedia/vst3sdk)

source/includes/vst3sdk/public.sdk/source/common/memorystream.cpp

@@ -1,319 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : Common Classes
-// Filename    : public.sdk/source/common/memorystream.cpp
-// Created by  : Steinberg, 03/2008
-// Description : IBStream Implementation for memory blocks
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "memorystream.h"
-#include "pluginterfaces/base/futils.h"
-#include <stdlib.h>
-
-namespace Steinberg {
-
-//-----------------------------------------------------------------------------
-IMPLEMENT_FUNKNOWN_METHODS (MemoryStream, IBStream, IBStream::iid)
-static const TSize kMemGrowAmount = 4096;
-
-//-----------------------------------------------------------------------------
-MemoryStream::MemoryStream (void* data, TSize length)
-: memory ((char*)data)
-, memorySize (length)
-, size (length)
-, cursor (0)
-, ownMemory (false)
-, allocationError (false)
-{ 
-	FUNKNOWN_CTOR 
-}
-
-//-----------------------------------------------------------------------------
-MemoryStream::MemoryStream ()
-: memory (nullptr)
-, memorySize (0)
-, size (0)
-, cursor (0)
-, ownMemory (true)
-, allocationError (false)
-{
-	FUNKNOWN_CTOR
-}
-
-//-----------------------------------------------------------------------------
-MemoryStream::~MemoryStream () 
-{ 
-	if (ownMemory && memory)
-		::free (memory);
-
-	FUNKNOWN_DTOR 
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API MemoryStream::read (void* data, int32 numBytes, int32* numBytesRead)
-{
-	if (memory == nullptr)
-	{
-		if (allocationError)
-			return kOutOfMemory;
-		numBytes = 0;
-	}
-	else
-	{		
-		// Does read exceed size ?
-		if (cursor + numBytes > size)
-		{
-			int32 maxBytes = int32 (size - cursor);
-
-			// Has length become zero or negative ?
-			if (maxBytes <= 0) 
-			{
-				cursor = size;
-				numBytes = 0;
-			}
-			else
-				numBytes = maxBytes;
-		}
-		
-		if (numBytes)
-		{
-			memcpy (data, &memory[cursor], static_cast<size_t> (numBytes));
-			cursor += numBytes;
-		}
-	}
-
-	if (numBytesRead)
-		*numBytesRead = numBytes;
-
-	return kResultTrue;
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API MemoryStream::write (void* buffer, int32 numBytes, int32* numBytesWritten)
-{
-	if (allocationError)
-		return kOutOfMemory;
-	if (buffer == nullptr)
-		return kInvalidArgument;
-
-	// Does write exceed size ?
-	TSize requiredSize = cursor + numBytes;
-	if (requiredSize > size) 
-	{		
-		if (requiredSize > memorySize)
-			setSize (requiredSize);
-		else
-			size = requiredSize;
-	}
-	
-	// Copy data
-	if (memory && cursor >= 0 && numBytes > 0)
-	{
-		memcpy (&memory[cursor], buffer, static_cast<size_t> (numBytes));
-		// Update cursor
-		cursor += numBytes;
-	}
-	else
-		numBytes = 0;
-
-	if (numBytesWritten)
-		*numBytesWritten = numBytes;
-
-	return kResultTrue;
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API MemoryStream::seek (int64 pos, int32 mode, int64* result)
-{
-	switch (mode) 
-	{
-		case kIBSeekSet:
-			cursor = pos;
-			break;
-		case kIBSeekCur:
-			cursor = cursor + pos;
-			break;
-		case kIBSeekEnd:
-			cursor = size + pos;
-			break;
-	}
-
-	if (ownMemory == false)
-		if (cursor > memorySize)
-			cursor = memorySize;
-
-	if (result)
-		*result = cursor;
-
-	return kResultTrue;
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API MemoryStream::tell  (int64* pos)
-{
-	if (!pos)
-		return kInvalidArgument;
-
-	*pos = cursor;
-	return kResultTrue;
-}
-
-//------------------------------------------------------------------------
-TSize MemoryStream::getSize () const
-{
-	return size;
-}
-
-//------------------------------------------------------------------------
-void MemoryStream::setSize (TSize s)
-{
-	if (s <= 0)
-	{
-		if (ownMemory && memory)
-			free (memory);
-
-		memory = nullptr;
-		memorySize = 0;
-		size = 0;
-		cursor = 0;
-		return;
-	}
-
-	TSize newMemorySize = (((Max (memorySize, s) - 1) / kMemGrowAmount) + 1) * kMemGrowAmount;
-	if (newMemorySize == memorySize)
-	{
-		size = s;
-		return;
-	}
-
-	if (memory && ownMemory == false)
-	{
-		allocationError = true;
-		return;	
-	}
-
-	ownMemory = true;
-	char* newMemory = nullptr;
-
-	if (memory)
-	{
-		newMemory = (char*)realloc (memory, (size_t)newMemorySize);
-		if (newMemory == nullptr && newMemorySize > 0)
-		{
-			newMemory = (char*)malloc ((size_t)newMemorySize);
-			if (newMemory)
-			{
-				memcpy (newMemory, memory, (size_t)Min (newMemorySize, memorySize));           
-				free (memory);
-			}		
-		}
-	}
-	else
-		newMemory = (char*)malloc ((size_t)newMemorySize);
-
-	if (newMemory == nullptr)
-	{
-		if (newMemorySize > 0)
-			allocationError = true;
-
-		memory = nullptr;
-		memorySize = 0;
-		size = 0;
-		cursor = 0;
-	}
-	else
-	{
-		memory = newMemory;
-		memorySize = newMemorySize;
-		size = s;
-	}
-}
-
-//------------------------------------------------------------------------
-char* MemoryStream::getData () const
-{
-	return memory;
-}
-
-//------------------------------------------------------------------------
-char* MemoryStream::detachData ()
-{
-	if (ownMemory)
-	{
-		char* result = memory;
-		memory = nullptr;
-		memorySize = 0;
-		size = 0;
-		cursor = 0;
-		return result;
-	}
-	return nullptr;
-}
-
-//------------------------------------------------------------------------
-bool MemoryStream::truncate ()
-{
-	if (ownMemory == false)
-		return false;
-
-	if (memorySize == size)
-		return true;
-
-	memorySize = size;
-	
-	if (memorySize == 0)
-	{
-		if (memory)
-		{
-			free (memory);
-			memory = nullptr;
-		}
-	}
-	else
-	{
-		if (memory)
-		{
-			char* newMemory = (char*)realloc (memory, (size_t)memorySize);
-			if (newMemory)
-				memory = newMemory;
-		}
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool MemoryStream::truncateToCursor ()
-{
-	size = cursor;
-	return truncate ();
-}
-
-} // namespace

source/includes/vst3sdk/public.sdk/source/common/memorystream.h

@@ -1,79 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : Common Classes
-// Filename    : public.sdk/source/common/memorystream.h
-// Created by  : Steinberg, 03/2008
-// Description : IBStream Implementation for memory blocks
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/ibstream.h"
-
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-/** Memory based Stream for IBStream implementation (using malloc).
-\ingroup sdkBase
-*/
-class MemoryStream : public IBStream
-{
-public:
-	//------------------------------------------------------------------------
-	MemoryStream ();
-	MemoryStream (void* memory, TSize memorySize); 	///< reuse a given memory without getting ownership
-	virtual ~MemoryStream ();
-
-	//---IBStream---------------------------------------
-	tresult PLUGIN_API read  (void* buffer, int32 numBytes, int32* numBytesRead) SMTG_OVERRIDE;
-	tresult PLUGIN_API write (void* buffer, int32 numBytes, int32* numBytesWritten) SMTG_OVERRIDE;
-	tresult PLUGIN_API seek  (int64 pos, int32 mode, int64* result) SMTG_OVERRIDE;
-	tresult PLUGIN_API tell  (int64* pos) SMTG_OVERRIDE;
-
-	TSize getSize () const;		///< returns the current memory size
-	void setSize (TSize size);	///< set the memory size, a realloc will occur if memory already used
-	char* getData () const;		///< returns the memory pointer
-	char* detachData ();	///< returns the memory pointer and give up ownership
-	bool truncate ();		///< realloc to the current use memory size if needed
-	bool truncateToCursor ();	///< truncate memory at current cursor position
-
-	//------------------------------------------------------------------------
-	DECLARE_FUNKNOWN_METHODS
-protected:
-	char* memory;				// memory block
-	TSize memorySize;			// size of the memory block
-	TSize size;					// size of the stream
-	int64 cursor;				// stream pointer
-	bool ownMemory;				// stream has allocated memory itself
-	bool allocationError;       // stream invalid
-};
-
-} // namespace

source/includes/vst3sdk/public.sdk/source/common/pluginview.cpp

@@ -1,99 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : Common Base Classes
-// Filename    : public.sdk/source/common/pluginview.cpp
-// Created by  : Steinberg, 01/2004
-// Description : Plug-In View Implementation
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "pluginview.h"
-
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-//  CPluginView implementation
-//------------------------------------------------------------------------
-CPluginView::CPluginView (const ViewRect* _rect)
-: rect (0, 0, 0, 0)
-{
-	if (_rect)
-		rect = *_rect;
-}
-
-//------------------------------------------------------------------------
-CPluginView::~CPluginView ()
-{
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API CPluginView::isPlatformTypeSupported (FIDString /*type*/)
-{
-	return kNotImplemented;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API CPluginView::attached (void* parent, FIDString /*type*/)
-{
-	systemWindow = parent;
-
-	attachedToParent ();
-	return kResultOk;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API CPluginView::removed ()
-{
-	systemWindow = nullptr;
-
-	removedFromParent ();
-	return kResultOk;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API CPluginView::onSize (ViewRect* newSize)
-{
-	if (newSize)
-		rect = *newSize;
-	return kResultTrue;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API CPluginView::getSize (ViewRect* size)
-{
-	if (size)
-	{
-		*size = rect;
-		return kResultTrue;
-	}
-	return kInvalidArgument;
-}
-
-} // end of namespace

source/includes/vst3sdk/public.sdk/source/common/pluginview.h

@@ -1,115 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : SDK Core
-//
-// Category    : Common Base Classes
-// Filename    : public.sdk/source/common/pluginview.h
-// Created by  : Steinberg, 01/2004
-// Description : Plug-In View Implementation
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/gui/iplugview.h"
-#include "base/source/fobject.h"
-
-namespace Steinberg {
-
-//------------------------------------------------------------------------
-/** Plug-In view default implementation.
-\ingroup sdkBase
-Can be used as base class for an IPlugView implementation.
-*/
-class CPluginView : public FObject, public IPlugView
-{
-public:
-//------------------------------------------------------------------------
-	CPluginView (const ViewRect* rect = nullptr);
-	virtual ~CPluginView ();
-
-	/** Returns its current frame rectangle. */
-	const ViewRect& getRect () const { return rect; }
-
-	/** Sets a new frame rectangle. */
-	void setRect (const ViewRect& r) { rect = r; }
-
-	/** Checks if this view is attached to its parent view. */
-	bool isAttached () const { return systemWindow != nullptr; }
-
-	/** Calls when this view will be attached to its parent view. */
-	virtual void attachedToParent () {}
-
-	/** Calls when this view will be removed from its parent view. */
-	virtual void removedFromParent () {}
-
-	//---from IPlugView-------
-	tresult PLUGIN_API isPlatformTypeSupported (FIDString type) SMTG_OVERRIDE;
-	tresult PLUGIN_API attached (void* parent, FIDString type) SMTG_OVERRIDE;
-	tresult PLUGIN_API removed () SMTG_OVERRIDE;
-
-	tresult PLUGIN_API onWheel (float /*distance*/) SMTG_OVERRIDE { return kResultFalse; }
-	tresult PLUGIN_API onKeyDown (char16 /*key*/, int16 /*keyMsg*/,
-	                              int16 /*modifiers*/) SMTG_OVERRIDE
-	{
-		return kResultFalse;
-	}
-	tresult PLUGIN_API onKeyUp (char16 /*key*/, int16 /*keyMsg*/, int16 /*modifiers*/) SMTG_OVERRIDE
-	{
-		return kResultFalse;
-	}
-	tresult PLUGIN_API getSize (ViewRect* size) SMTG_OVERRIDE;
-	tresult PLUGIN_API onSize (ViewRect* newSize) SMTG_OVERRIDE;
-
-	tresult PLUGIN_API onFocus (TBool /*state*/) SMTG_OVERRIDE { return kResultFalse; }
-	tresult PLUGIN_API setFrame (IPlugFrame* frame) SMTG_OVERRIDE
-	{
-		plugFrame = frame;
-		return kResultTrue;
-	}
-
-	tresult PLUGIN_API canResize () SMTG_OVERRIDE { return kResultFalse; }
-	tresult PLUGIN_API checkSizeConstraint (ViewRect* /*rect*/) SMTG_OVERRIDE
-	{
-		return kResultFalse;
-	}
-
-	//---Interface------
-	OBJ_METHODS (CPluginView, FObject)
-	DEFINE_INTERFACES
-		DEF_INTERFACE (IPlugView)
-	END_DEFINE_INTERFACES (FObject)
-	REFCOUNT_METHODS (FObject)
-//------------------------------------------------------------------------
-protected:
-	ViewRect rect;
-	void* systemWindow {nullptr};
-	IPlugFrame* plugFrame {nullptr};
-};
-
-} // namespace

source/includes/vst3sdk/public.sdk/source/vst/hosting/hostclasses.cpp

@@ -1,329 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/hosting/hostclasses.cpp
-// Created by  : Steinberg, 03/05/2008.
-// Description : VST 3 hostclasses, example implementations for IHostApplication, IAttributeList and IMessage
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "hostclasses.h"
-
-#include <algorithm>
-
-namespace Steinberg {
-namespace Vst {
-
-//-----------------------------------------------------------------------------
-HostApplication::HostApplication ()
-{
-	FUNKNOWN_CTOR
-
-	mPlugInterfaceSupport = owned (NEW PlugInterfaceSupport);
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API HostApplication::getName (String128 name)
-{
-	String str ("My VST3 HostApplication");
-	str.copyTo16 (name, 0, 127);
-	return kResultTrue;
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API HostApplication::createInstance (TUID cid, TUID _iid, void** obj)
-{
-	FUID classID (FUID::fromTUID (cid));
-	FUID interfaceID (FUID::fromTUID (_iid));
-	if (classID == IMessage::iid && interfaceID == IMessage::iid)
-	{
-		*obj = new HostMessage;
-		return kResultTrue;
-	}
-	else if (classID == IAttributeList::iid && interfaceID == IAttributeList::iid)
-	{
-		*obj = new HostAttributeList;
-		return kResultTrue;
-	}
-	*obj = nullptr;
-	return kResultFalse;
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API HostApplication::queryInterface (const char* _iid, void** obj)
-{
-	QUERY_INTERFACE (_iid, obj, FUnknown::iid, IHostApplication)
-	QUERY_INTERFACE (_iid, obj, IHostApplication::iid, IHostApplication)
-
-	if (mPlugInterfaceSupport && mPlugInterfaceSupport->queryInterface (iid, obj) == kResultTrue)
-		return kResultOk;
-
-	*obj = nullptr;
-	return kResultFalse;
-}
-
-//-----------------------------------------------------------------------------
-uint32 PLUGIN_API HostApplication::addRef ()
-{
-	return 1;
-}
-
-//-----------------------------------------------------------------------------
-uint32 PLUGIN_API HostApplication::release ()
-{
-	return 1;
-}
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-IMPLEMENT_FUNKNOWN_METHODS (HostMessage, IMessage, IMessage::iid)
-//-----------------------------------------------------------------------------
-HostMessage::HostMessage () : messageId (nullptr), attributeList (nullptr)
-{
-	FUNKNOWN_CTOR
-}
-
-//-----------------------------------------------------------------------------
-HostMessage::~HostMessage ()
-{
-	setMessageID (nullptr);
-	if (attributeList)
-		attributeList->release ();
-	FUNKNOWN_DTOR
-}
-
-//-----------------------------------------------------------------------------
-const char* PLUGIN_API HostMessage::getMessageID ()
-{
-	return messageId;
-}
-
-//-----------------------------------------------------------------------------
-void PLUGIN_API HostMessage::setMessageID (const char* mid)
-{
-	if (messageId)
-		delete[] messageId;
-	messageId = nullptr;
-	if (mid)
-	{
-		size_t len = strlen (mid) + 1;
-		messageId = new char[len];
-		strcpy (messageId, mid);
-	}
-}
-
-//-----------------------------------------------------------------------------
-IAttributeList* PLUGIN_API HostMessage::getAttributes ()
-{
-	if (!attributeList)
-		attributeList = new HostAttributeList;
-	return attributeList;
-}
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-class HostAttribute
-{
-public:
-	enum Type
-	{
-		kInteger,
-		kFloat,
-		kString,
-		kBinary
-	};
-
-	HostAttribute (int64 value) : size (0), type (kInteger) { v.intValue = value; }
-	HostAttribute (double value) : size (0), type (kFloat) { v.floatValue = value; }
-	/** size is in code unit (count of TChar) */
-	HostAttribute (const TChar* value, uint32 sizeInCodeUnit) : size (sizeInCodeUnit), type (kString)
-	{
-		v.stringValue = new TChar[sizeInCodeUnit];
-		memcpy (v.stringValue, value, sizeInCodeUnit * sizeof (TChar));
-	}
-	HostAttribute (const void* value, uint32 sizeInBytes) : size (sizeInBytes), type (kBinary)
-	{
-		v.binaryValue = new char[sizeInBytes];
-		memcpy (v.binaryValue, value, sizeInBytes);
-	}
-	~HostAttribute ()
-	{
-		if (size)
-			delete[] v.binaryValue;
-	}
-
-	int64 intValue () const { return v.intValue; }
-	double floatValue () const { return v.floatValue; }
-	/** sizeInCodeUnit is in code unit (count of TChar) */
-	const TChar* stringValue (uint32& sizeInCodeUnit)
-	{
-		sizeInCodeUnit = size;
-		return v.stringValue;
-	}
-	const void* binaryValue (uint32& sizeInBytes)
-	{
-		sizeInBytes = size;
-		return v.binaryValue;
-	}
-
-	Type getType () const { return type; }
-
-protected:
-	union v
-	{
-		int64 intValue;
-		double floatValue;
-		TChar* stringValue;
-		char* binaryValue;
-	} v;
-	uint32 size;
-	Type type;
-};
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-IMPLEMENT_FUNKNOWN_METHODS (HostAttributeList, IAttributeList, IAttributeList::iid)
-//-----------------------------------------------------------------------------
-HostAttributeList::HostAttributeList ()
-{
-	FUNKNOWN_CTOR
-}
-
-//-----------------------------------------------------------------------------
-HostAttributeList::~HostAttributeList ()
-{
-	auto it = list.rbegin ();
-	while (it != list.rend ())
-	{
-		delete it->second;
-		it++;
-	}
-	FUNKNOWN_DTOR
-}
-
-//-----------------------------------------------------------------------------
-void HostAttributeList::removeAttrID (AttrID aid)
-{
-	auto it = list.find (aid);
-	if (it != list.end ())
-	{
-		delete it->second;
-		list.erase (it);
-	}
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API HostAttributeList::setInt (AttrID aid, int64 value)
-{
-	removeAttrID (aid);
-	list[aid] = new HostAttribute (value);
-	return kResultTrue;
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API HostAttributeList::getInt (AttrID aid, int64& value)
-{
-	auto it = list.find (aid);
-	if (it != list.end () && it->second)
-	{
-		value = it->second->intValue ();
-		return kResultTrue;
-	}
-	return kResultFalse;
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API HostAttributeList::setFloat (AttrID aid, double value)
-{
-	removeAttrID (aid);
-	list[aid] = new HostAttribute (value);
-	return kResultTrue;
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API HostAttributeList::getFloat (AttrID aid, double& value)
-{
-	auto it = list.find (aid);
-	if (it != list.end () && it->second)
-	{
-		value = it->second->floatValue ();
-		return kResultTrue;
-	}
-	return kResultFalse;
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API HostAttributeList::setString (AttrID aid, const TChar* string)
-{
-	removeAttrID (aid);
-	// + 1 for the null-terminate
-	list[aid] = new HostAttribute (string, String (string).length () + 1);
-	return kResultTrue;
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API HostAttributeList::getString (AttrID aid, TChar* string, uint32 sizeInBytes)
-{
-	auto it = list.find (aid);
-	if (it != list.end () && it->second)
-	{
-		uint32 sizeInCodeUnit = 0;
-		const TChar* _string = it->second->stringValue (sizeInCodeUnit);
-		memcpy (string, _string, std::min<uint32> (sizeInCodeUnit * sizeof (TChar), sizeInBytes));
-		return kResultTrue;
-	}
-	return kResultFalse;
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API HostAttributeList::setBinary (AttrID aid, const void* data, uint32 sizeInBytes)
-{
-	removeAttrID (aid);
-	list[aid] = new HostAttribute (data, sizeInBytes);
-	return kResultTrue;
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API HostAttributeList::getBinary (AttrID aid, const void*& data, uint32& sizeInBytes)
-{
-	auto it = list.find (aid);
-	if (it != list.end () && it->second)
-	{
-		data = it->second->binaryValue (sizeInBytes);
-		return kResultTrue;
-	}
-	sizeInBytes = 0;
-	return kResultFalse;
-}
-}
-} // namespace

source/includes/vst3sdk/public.sdk/source/vst/hosting/hostclasses.h

@@ -1,117 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/hosting/hostclasses.h
-// Created by  : Steinberg, 03/05/2008.
-// Description : VST 3 hostclasses, example implementations for IHostApplication, IAttributeList and IMessage
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "public.sdk/source/vst/hosting/pluginterfacesupport.h"
-#include "base/source/fstring.h"
-#include "pluginterfaces/vst/ivsthostapplication.h"
-#include <map>
-
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Implementation's example of IHostApplication.
-\ingroup hostingBase
-*/
-class HostApplication : public IHostApplication
-{
-public:
-	HostApplication ();
-	virtual ~HostApplication () { FUNKNOWN_DTOR }
-
-	//--- IHostApplication ---------------
-	tresult PLUGIN_API getName (String128 name) SMTG_OVERRIDE;
-	tresult PLUGIN_API createInstance (TUID cid, TUID _iid, void** obj) SMTG_OVERRIDE;
-
-	DECLARE_FUNKNOWN_METHODS
-
-	PlugInterfaceSupport* getPlugInterfaceSupport () const { return mPlugInterfaceSupport; }
-
-protected:
-	IPtr<PlugInterfaceSupport> mPlugInterfaceSupport;
-};
-
-class HostAttribute;
-//------------------------------------------------------------------------
-/** Implementation's example of IAttributeList.
-\ingroup hostingBase
-*/
-class HostAttributeList : public IAttributeList
-{
-public:
-	HostAttributeList ();
-	virtual ~HostAttributeList ();
-
-	tresult PLUGIN_API setInt (AttrID aid, int64 value) SMTG_OVERRIDE;
-	tresult PLUGIN_API getInt (AttrID aid, int64& value) SMTG_OVERRIDE;
-	tresult PLUGIN_API setFloat (AttrID aid, double value) SMTG_OVERRIDE;
-	tresult PLUGIN_API getFloat (AttrID aid, double& value) SMTG_OVERRIDE;
-	tresult PLUGIN_API setString (AttrID aid, const TChar* string) SMTG_OVERRIDE;
-	tresult PLUGIN_API getString (AttrID aid, TChar* string, uint32 sizeInBytes) SMTG_OVERRIDE;
-	tresult PLUGIN_API setBinary (AttrID aid, const void* data, uint32 sizeInBytes) SMTG_OVERRIDE;
-	tresult PLUGIN_API getBinary (AttrID aid, const void*& data, uint32& sizeInBytes) SMTG_OVERRIDE;
-
-	DECLARE_FUNKNOWN_METHODS
-protected:
-	void removeAttrID (AttrID aid);
-	std::map<String, HostAttribute*> list;
-};
-
-//------------------------------------------------------------------------
-/** Implementation's example of IMessage.
-\ingroup hostingBase
-*/
-class HostMessage : public IMessage
-{
-public:
-	HostMessage ();
-	virtual ~HostMessage ();
-
-	const char* PLUGIN_API getMessageID () SMTG_OVERRIDE;
-	void PLUGIN_API setMessageID (const char* messageID) SMTG_OVERRIDE;
-	IAttributeList* PLUGIN_API getAttributes () SMTG_OVERRIDE;
-
-	DECLARE_FUNKNOWN_METHODS
-protected:
-	char* messageId;
-	HostAttributeList* attributeList;
-};
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/source/vst/hosting/pluginterfacesupport.cpp

@@ -1,125 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/hosting/pluginterfacesupport.cpp
-// Created by  : Steinberg, 11/2018.
-// Description : VST 3 hostclasses, example implementations for IPlugInterfaceSupport
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "pluginterfacesupport.h"
-
-#include "pluginterfaces/vst/ivstaudioprocessor.h"
-#include "pluginterfaces/vst/ivsteditcontroller.h"
-#include "pluginterfaces/vst/ivstunits.h"
-#include "pluginterfaces/vst/ivstmessage.h"
-
-#include <algorithm>
-
-namespace Steinberg {
-namespace Vst {
-
-//-----------------------------------------------------------------------------
-PlugInterfaceSupport::PlugInterfaceSupport ()
-{
-	// add minimum set
-
-	//---VST 3.0.0--------------------------------
-	addPlugInterfaceSupported (IComponent::iid);
-	addPlugInterfaceSupported (IAudioProcessor::iid);
-	addPlugInterfaceSupported (IEditController::iid);
-	addPlugInterfaceSupported (IConnectionPoint::iid);
-
-	addPlugInterfaceSupported (IUnitInfo::iid);
-	addPlugInterfaceSupported (IUnitData::iid);
-	addPlugInterfaceSupported (IProgramListData::iid);
-
-	//---VST 3.0.1--------------------------------
-	addPlugInterfaceSupported (IMidiMapping::iid);
-
-	//---VST 3.1----------------------------------
-	addPlugInterfaceSupported (IEditController2::iid);
-
-	/*
-	//---VST 3.0.2--------------------------------
-	addPlugInterfaceSupported (IParameterFinder::iid);
-
-	//---VST 3.1----------------------------------
-	addPlugInterfaceSupported (IAudioPresentationLatency::iid);
-
-	//---VST 3.5----------------------------------
-	addPlugInterfaceSupported (IKeyswitchController::iid);
-	addPlugInterfaceSupported (IContextMenuTarget::iid);
-	addPlugInterfaceSupported (IEditControllerHostEditing::iid);
-	addPlugInterfaceSupported (IXmlRepresentationController::iid);
-	addPlugInterfaceSupported (INoteExpressionController::iid);
-
-	//---VST 3.6.5--------------------------------
-	addPlugInterfaceSupported (ChannelContext::IInfoListener::iid);
-	addPlugInterfaceSupported (IPrefetchableSupport::iid);
-	addPlugInterfaceSupported (IAutomationState::iid);
-
-	//---VST 3.6.11--------------------------------
-	addPlugInterfaceSupported (INoteExpressionPhysicalUIMapping::iid);
-
-	//---VST 3.6.12--------------------------------
-	addPlugInterfaceSupported (IMidiLearn::iid);
-
-	//---VST 3.7-----------------------------------
-	addPlugInterfaceSupported (IProcessContextRequirements::iid);
-	addPlugInterfaceSupported (IParameterFunctionName::iid);
-	addPlugInterfaceSupported (IProgress::iid);
-	*/
-}
-
-//-----------------------------------------------------------------------------
-tresult PLUGIN_API PlugInterfaceSupport::isPlugInterfaceSupported (const TUID _iid)
-{
-	auto uid = FUID::fromTUID (_iid);
-	if (std::find (mFUIDArray.begin (), mFUIDArray.end (), uid) != mFUIDArray.end ())
-		return kResultTrue;
-	return kResultFalse;
-}
-
-//-----------------------------------------------------------------------------
-void PlugInterfaceSupport::addPlugInterfaceSupported (const TUID _iid)
-{
-	mFUIDArray.push_back (FUID::fromTUID (_iid));
-}
-
-//-----------------------------------------------------------------------------
-bool PlugInterfaceSupport::removePlugInterfaceSupported (const TUID _iid)
-{
-	return std::remove (mFUIDArray.begin (), mFUIDArray.end (), FUID::fromTUID (_iid)) !=
-	       mFUIDArray.end ();
-}
-
-}
-} // namespace

source/includes/vst3sdk/public.sdk/source/vst/hosting/pluginterfacesupport.h

@@ -1,74 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/hosting/pluginterfacesupport.h
-// Created by  : Steinberg, 11/20018.
-// Description : VST 3 hostclasses, example implementations for IPlugInterfaceSupport
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/vst/ivstpluginterfacesupport.h"
-
-#include <vector>
-#include "base/source/fobject.h"
-
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Implementation's example of IPlugInterfaceSupport.
-\ingroup hostingBase
-*/
-class PlugInterfaceSupport : public FObject, public IPlugInterfaceSupport
-{
-public:
-	PlugInterfaceSupport ();
-
-	//--- IPlugInterfaceSupport ---------
-	tresult PLUGIN_API isPlugInterfaceSupported (const TUID _iid) SMTG_OVERRIDE;
-
-	void addPlugInterfaceSupported (const TUID _iid);
-	bool removePlugInterfaceSupported (const TUID _iid);
-
-	OBJ_METHODS (PlugInterfaceSupport, FObject)
-	REFCOUNT_METHODS (FObject)
-	DEFINE_INTERFACES
-		DEF_INTERFACE (IPlugInterfaceSupport)
-	END_DEFINE_INTERFACES (FObject)
-
-private:
-	std::vector<FUID> mFUIDArray;
-};
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/source/vst/vstbus.cpp

@@ -1,98 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/vstbus.cpp
-// Created by  : Steinberg, 03/2008
-// Description : VST Bus Implementation
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "vstbus.h"
-
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-// Bus Implementation
-//------------------------------------------------------------------------
-Bus::Bus (const TChar* _name, BusType _busType, int32 _flags)
-: name (_name), busType (_busType), flags (_flags), active (false)
-{
-}
-
-//------------------------------------------------------------------------
-bool Bus::getInfo (BusInfo& info)
-{
-	name.copyTo16 (info.name, 0, str16BufferSize (info.name) - 1);
-	info.busType = busType;
-	info.flags = flags;
-	return true;
-}
-
-//------------------------------------------------------------------------
-// EventBus Implementation
-//------------------------------------------------------------------------
-EventBus::EventBus (const TChar* name, BusType busType, int32 flags, int32 channelCount)
-: Bus (name, busType, flags), channelCount (channelCount)
-{
-}
-
-//------------------------------------------------------------------------
-bool EventBus::getInfo (BusInfo& info)
-{
-	info.channelCount = channelCount;
-	return Bus::getInfo (info);
-}
-
-//------------------------------------------------------------------------
-// AudioBus Implementation
-//------------------------------------------------------------------------
-AudioBus::AudioBus (const TChar* name, BusType busType, int32 flags, SpeakerArrangement arr)
-: Bus (name, busType, flags), speakerArr (arr)
-{
-}
-
-//------------------------------------------------------------------------
-bool AudioBus::getInfo (BusInfo& info)
-{
-	info.channelCount = SpeakerArr::getChannelCount (speakerArr);
-	return Bus::getInfo (info);
-}
-
-//------------------------------------------------------------------------
-// BusList Implementation
-//------------------------------------------------------------------------
-BusList::BusList (MediaType type, BusDirection dir) : type (type), direction (dir)
-{
-}
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/source/vst/vstbus.h

@@ -1,164 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/vstbus.h
-// Created by  : Steinberg, 03/2008
-// Description : VST Bus Implementation
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "base/source/fobject.h"
-#include "base/source/fstring.h"
-#include "pluginterfaces/vst/ivstcomponent.h"
-#include "pluginterfaces/vst/ivstaudioprocessor.h"
-
-#include <vector>
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Basic Bus object.
-\ingroup vstClasses 
-*/
-class Bus: public FObject
-{
-public:
-//------------------------------------------------------------------------
-	/** Constructor. */
-	Bus (const TChar* name, BusType busType, int32 flags);
-
-	/** Returns true if the bus is active. */
-	TBool isActive () const { return active; }
-
-	/** Activates the bus. */
-	void setActive (TBool state) { active = state; }
-
-	/** Sets a new name for this bus. */
-	void setName (String newName) { name = newName; }
-
-	/** Sets a new busType for this bus. */
-	void setBusType (BusType newBusType) { busType = newBusType; }
-
-	/** Sets a new flags for this bus. */
-	void setFlags (uint32 newFlags) { flags = newFlags; }
-
-	/** Gets the BusInfo of this bus. */
-	virtual bool getInfo (BusInfo&);
-
-	OBJ_METHODS (Vst::Bus, FObject)
-//------------------------------------------------------------------------
-protected:
-	String name;				///< name
-	BusType busType;			///< kMain or kAux, see \ref BusTypes
-	int32 flags;				///< flags, see \ref BusInfo::BusFlags
-	TBool active;				///< activation state
-};
-
-//------------------------------------------------------------------------
-/** Description of an Event Bus.
-\ingroup vstClasses
-*/
-class EventBus: public Bus
-{
-public:
-//------------------------------------------------------------------------
-	/** Constructor of an EventBus. */
-	EventBus (const TChar* name, BusType busType, int32 flags, int32 channelCount);
-
-	//---from Bus-------
-	/** Gets the BusInfo associated to this Event bus. */
-	bool getInfo (BusInfo& info) SMTG_OVERRIDE;
-
-	OBJ_METHODS (Vst::EventBus, Vst::Bus);
-
-//------------------------------------------------------------------------
-protected:
-	int32 channelCount;
-};
-
-//------------------------------------------------------------------------
-/** Description of an Audio Bus.
-\ingroup vstClasses 
-*/
-class AudioBus: public Bus
-{
-public:
-//------------------------------------------------------------------------
-	AudioBus (const TChar* name, BusType busType, int32 flags, SpeakerArrangement arr);
-
-	/** Gets the speaker arrangement defining this Audio bus. */
-	SpeakerArrangement getArrangement () const { return speakerArr; }
-
-	/** Sets the speaker arrangement defining this Audio bus. */
-	void setArrangement (const SpeakerArrangement& arr) { speakerArr = arr; }
-
-	//---from Bus---------------------
-	/** Gets the BusInfo associated to this Audio bus. */
-	bool getInfo (BusInfo& info) SMTG_OVERRIDE;
-
-	OBJ_METHODS (Vst::AudioBus, Vst::Bus)
-
-//------------------------------------------------------------------------
-protected:
-	SpeakerArrangement speakerArr;
-};
-
-//------------------------------------------------------------------------
-/** List of Busses.
-\ingroup vstClasses 
-*/
-class BusList: public FObject, public std::vector<IPtr<Vst::Bus> >
-{
-public:
-//------------------------------------------------------------------------
-	/** Constructor. */
-	BusList (MediaType type, BusDirection dir);
-
-	/** Returns the BusList Type. See \ref MediaType */
-	MediaType getType () const { return type; }
-
-	/** Returns the BusList direction. See \ref BusDirection */
-	BusDirection getDirection () const { return direction; }
-
-	OBJ_METHODS (Vst::BusList, FObject);
-
-//------------------------------------------------------------------------
-protected:
-	MediaType type;
-	BusDirection direction;
-};
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/source/vst/vstcomponent.cpp

@@ -1,216 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/vstcomponent.cpp
-// Created by  : Steinberg, 04/2005
-// Description : Basic VST Plug-in Implementation
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "vstcomponent.h"
-
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-// Component Implementation
-//------------------------------------------------------------------------
-Component::Component ()
-: audioInputs (kAudio, kInput)
-, audioOutputs (kAudio, kOutput)
-, eventInputs (kEvent, kInput)
-, eventOutputs (kEvent, kOutput)
-{
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API Component::initialize (FUnknown* context)
-{
-	return ComponentBase::initialize (context);
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API Component::terminate ()
-{
-	// remove all busses
-	removeAllBusses ();
-
-	return ComponentBase::terminate ();
-}
-
-//------------------------------------------------------------------------
-BusList* Component::getBusList (MediaType type, BusDirection dir)
-{
-	if (type == kAudio)
-		return dir == kInput ? &audioInputs : &audioOutputs;
-	else if (type == kEvent)
-		return dir == kInput ? &eventInputs : &eventOutputs;
-	return nullptr;
-}
-
-//------------------------------------------------------------------------
-tresult Component::removeAudioBusses ()
-{
-	audioInputs.clear ();
-	audioOutputs.clear ();
-
-	return kResultOk;
-}
-
-//------------------------------------------------------------------------
-tresult Component::removeEventBusses ()
-{
-	eventInputs.clear ();
-	eventOutputs.clear ();
-
-	return kResultOk;
-}
-
-//------------------------------------------------------------------------
-tresult Component::removeAllBusses ()
-{
-	removeAudioBusses ();
-	removeEventBusses ();
-
-	return kResultOk;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API Component::getControllerClassId (TUID classID)
-{
-	if (controllerClass.isValid ())
-	{
-		controllerClass.toTUID (classID);
-		return kResultTrue;
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API Component::setIoMode (IoMode /*mode*/)
-{
-	return kNotImplemented;
-}
-
-//------------------------------------------------------------------------
-int32 PLUGIN_API Component::getBusCount (MediaType type, BusDirection dir)
-{
-	BusList* busList = getBusList (type, dir);
-	return busList ? static_cast<int32> (busList->size ()) : 0;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API Component::getBusInfo (MediaType type, BusDirection dir, int32 index,
-                                          BusInfo& info)
-{
-	if (index < 0)
-		return kInvalidArgument;
-	BusList* busList = getBusList (type, dir);
-	if (busList == nullptr)
-		return kInvalidArgument;
-	if (index >= static_cast<int32> (busList->size ()))
-		return kInvalidArgument;
-
-	Bus* bus = busList->at (index);
-	info.mediaType = type;
-	info.direction = dir;
-	if (bus->getInfo (info))
-		return kResultTrue;
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API Component::getRoutingInfo (RoutingInfo& /*inInfo*/, RoutingInfo& /*outInfo*/)
-{
-	return kNotImplemented;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API Component::activateBus (MediaType type, BusDirection dir, int32 index,
-                                           TBool state)
-{
-	if (index < 0)
-		return kInvalidArgument;
-	BusList* busList = getBusList (type, dir);
-	if (busList == nullptr)
-		return kInvalidArgument;
-	if (index >= static_cast<int32> (busList->size ()))
-		return kInvalidArgument;
-
-	Bus* bus = busList->at (index);
-	bus->setActive (state);
-	return kResultTrue;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API Component::setActive (TBool /*state*/)
-{
-	return kResultOk;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API Component::setState (IBStream* /*state*/)
-{
-	return kNotImplemented;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API Component::getState (IBStream* /*state*/)
-{
-	return kNotImplemented;
-}
-
-//------------------------------------------------------------------------
-tresult Component::renameBus (MediaType type, BusDirection dir, int32 index,
-                              const String128 newName)
-{
-	if (index < 0)
-		return kInvalidArgument;
-	BusList* busList = getBusList (type, dir);
-	if (busList == nullptr)
-		return kInvalidArgument;
-	if (index >= static_cast<int32> (busList->size ()))
-		return kInvalidArgument;
-
-	Bus* bus = busList->at (index);
-	bus->setName (newName);
-	return kResultTrue;
-}
-
-//------------------------------------------------------------------------
-// Helpers Implementation
-//------------------------------------------------------------------------
-tresult getSpeakerChannelIndex (SpeakerArrangement arrangement, uint64 speaker, int32& channel)
-{
-	channel = SpeakerArr::getSpeakerIndex (speaker, arrangement);
-	return (channel < 0) == true ? kResultFalse : kResultTrue;
-}
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/source/vst/vstcomponent.h

@@ -1,117 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/vstcomponent.h
-// Created by  : Steinberg, 04/2005
-// Description : Basic VST Plug-in Implementation
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "public.sdk/source/vst/vstcomponentbase.h"
-#include "public.sdk/source/vst/vstbus.h"
-#include "pluginterfaces/vst/ivstcomponent.h"
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Default implementation for a VST 3 Component.
-\ingroup vstClasses
-Can be used as base class for a VST 3 component implementation.
-*/
-class Component : public ComponentBase, public IComponent
-{
-public:
-//------------------------------------------------------------------------
-	/** Constructor */
-	Component ();
-
-	//---Internal Methods-------
-	/** Sets the controller Class ID associated to its component. */
-	void setControllerClass (const FUID& cid) { controllerClass = cid; }
-
-	/** Removes all Audio Busses. */
-	tresult removeAudioBusses ();
-
-	/** Removes all Event Busses. */
-	tresult removeEventBusses ();
-
-	/** Renames a specific bus. Do not forget to inform the host about this (see \ref
-	 * IComponentHandler::restartComponent (kIoTitlesChanged)). */
-	tresult renameBus (MediaType type, BusDirection dir, int32 index, const String128 newName);
-
-	//---from IComponent--------
-	tresult PLUGIN_API getControllerClassId (TUID classID) SMTG_OVERRIDE;
-	tresult PLUGIN_API setIoMode (IoMode mode) SMTG_OVERRIDE;
-	int32 PLUGIN_API getBusCount (MediaType type, BusDirection dir) SMTG_OVERRIDE;
-	tresult PLUGIN_API getBusInfo (MediaType type, BusDirection dir, int32 index, BusInfo& info) SMTG_OVERRIDE;
-	tresult PLUGIN_API getRoutingInfo (RoutingInfo& inInfo, RoutingInfo& outInfo) SMTG_OVERRIDE;
-	tresult PLUGIN_API activateBus (MediaType type, BusDirection dir, int32 index, TBool state) SMTG_OVERRIDE;
-	tresult PLUGIN_API setActive (TBool state) SMTG_OVERRIDE;
-	tresult PLUGIN_API setState (IBStream* state) SMTG_OVERRIDE;
-	tresult PLUGIN_API getState (IBStream* state) SMTG_OVERRIDE;
-
-	//---from ComponentBase------
-	tresult PLUGIN_API initialize (FUnknown* context) SMTG_OVERRIDE;
-	tresult PLUGIN_API terminate () SMTG_OVERRIDE;
-
-	//---Interface---------
-	OBJ_METHODS (Component, ComponentBase)
-	DEFINE_INTERFACES
-		DEF_INTERFACE (IComponent)
-	END_DEFINE_INTERFACES (ComponentBase)
-	REFCOUNT_METHODS (ComponentBase)
-
-//------------------------------------------------------------------------
-protected:
-	FUID controllerClass;
-	BusList audioInputs;
-	BusList audioOutputs;
-	BusList eventInputs;
-	BusList eventOutputs;
-
-	BusList* getBusList (MediaType type, BusDirection dir);
-	tresult removeAllBusses ();
-};
-
-//------------------------------------------------------------------------
-// some Helper functions....
-//------------------------------------------------------------------------
-
-/** Gets the channel index of a given speaker in a arrangement, returns kResultFalse if speaker not
- * part of the arrangement else returns kResultTrue. */
-tresult getSpeakerChannelIndex (SpeakerArrangement arrangement, uint64 speaker, int32& channel);
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/source/vst/vstcomponentbase.cpp

@@ -1,180 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/vstcomponentbase.cpp
-// Created by  : Steinberg, 05/2005
-// Description : Base class for VST Component and Edit Controller
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "vstcomponentbase.h"
-#include "base/source/fstring.h"
-
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-// ComponentBase Implementation
-//------------------------------------------------------------------------
-ComponentBase::ComponentBase ()
-{
-}
-
-//------------------------------------------------------------------------
-ComponentBase::~ComponentBase ()
-{
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API ComponentBase::initialize (FUnknown* context)
-{
-	// check if already initialized
-	if (hostContext)
-		return kResultFalse;
-
-	hostContext = context;
-
-	return kResultOk;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API ComponentBase::terminate ()
-{
-	// release host interfaces
-	hostContext = nullptr;
-
-	// in case host did not disconnect us,
-	// release peer now
-	if (peerConnection)
-	{
-		peerConnection->disconnect (this);
-		peerConnection = nullptr;
-	}
-
-	return kResultOk;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API ComponentBase::connect (IConnectionPoint* other)
-{
-	if (!other)
-		return kInvalidArgument;
-
-	// check if already connected
-	if (peerConnection)
-		return kResultFalse;
-
-	peerConnection = other;
-	return kResultOk;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API ComponentBase::disconnect (IConnectionPoint* other)
-{
-	if (peerConnection && other == peerConnection)
-	{
-		peerConnection = nullptr;
-		return kResultOk;
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API ComponentBase::notify (IMessage* message)
-{
-	if (!message)
-		return kInvalidArgument;
-
-	if (FIDStringsEqual (message->getMessageID (), "TextMessage"))
-	{
-		TChar string[256] = {0};
-		if (message->getAttributes ()->getString ("Text", string, sizeof (string)) == kResultOk)
-		{
-			String tmp (string);
-			tmp.toMultiByte (kCP_Utf8);
-			return receiveText (tmp.text8 ());
-		}
-	}
-
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-IMessage* ComponentBase::allocateMessage () const
-{
-	FUnknownPtr<IHostApplication> hostApp (hostContext);
-	if (hostApp)
-		return Vst::allocateMessage (hostApp);
-	return nullptr;
-}
-
-//------------------------------------------------------------------------
-tresult ComponentBase::sendMessage (IMessage* message) const
-{
-	if (message != nullptr && getPeer () != nullptr)
-		return getPeer ()->notify (message);
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult ComponentBase::sendTextMessage (const char8* text) const
-{
-	if (auto msg = owned (allocateMessage ()))
-	{
-		msg->setMessageID ("TextMessage");
-		String tmp (text, kCP_Utf8);
-		if (tmp.length () >= 256)
-			tmp.remove (255);
-		msg->getAttributes ()->setString ("Text", tmp.text16 ());
-		return sendMessage (msg);
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult ComponentBase::sendMessageID (const char* messageID) const
-{
-	if (auto msg = owned (allocateMessage ()))
-	{
-		msg->setMessageID (messageID);
-		return sendMessage (msg);
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult ComponentBase::receiveText (const char8* /*text*/)
-{
-	return kResultOk;
-}
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/source/vst/vstcomponentbase.h

@@ -1,110 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/vstcomponentbase.h
-// Created by  : Steinberg, 05/2005
-// Description : Base class for Component and Edit Controller
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/base/ipluginbase.h"
-#include "pluginterfaces/vst/ivstmessage.h"
-#include "pluginterfaces/vst/ivsthostapplication.h"
-#include "base/source/fobject.h"
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Base class for VST 3 Component and Edit Controller.
-\ingroup vstClasses 
-*/
-class ComponentBase: public FObject,
-					 public IPluginBase,
-	                 public IConnectionPoint
-{
-public:
-//------------------------------------------------------------------------
-	ComponentBase ();
-	~ComponentBase () override;
-
-	//--- Internal Methods------
-	/** Returns the hostContext (set by the host during initialize call). */
-	FUnknown* getHostContext () const { return hostContext; }
-
-	/** Returns the peer for the messaging communication (you can only use IConnectionPoint::notify
-	 * for communicate between peers, do not try to cast peerConnection. */
-	IConnectionPoint* getPeer () const { return peerConnection; }
-
-	/** Allocates a message instance (do not forget to release it). */
-	IMessage* allocateMessage () const;
-
-	/** Sends the given message to the peer. */
-	tresult sendMessage (IMessage* message) const;
-
-	/** Sends a simple text message to the peer (max 255 characters).
-	Text is interpreted as UTF-8.	 */
-	tresult sendTextMessage (const char8* text) const;
-
-	/** Sends a message with a given ID without any other payload. */
-	tresult sendMessageID (const char8* messageID) const;
-
-	/** Receives a simple text message from the peer (max 255 characters). Text is UTF-8 encoded. */
-	virtual tresult receiveText (const char8* text);
-
-	//---from IPluginBase------
-	tresult PLUGIN_API initialize (FUnknown* context) SMTG_OVERRIDE;
-	tresult PLUGIN_API terminate () SMTG_OVERRIDE;
-
-	//---from IConnectionPoint-----------
-	tresult PLUGIN_API connect (IConnectionPoint* other) SMTG_OVERRIDE;
-	tresult PLUGIN_API disconnect (IConnectionPoint* other) SMTG_OVERRIDE;
-	tresult PLUGIN_API notify (IMessage* message) SMTG_OVERRIDE;
-
-	//---Interface------
-	OBJ_METHODS (ComponentBase, FObject)
-	DEFINE_INTERFACES
-		DEF_INTERFACE (IPluginBase)
-		DEF_INTERFACE (IConnectionPoint)
-	END_DEFINE_INTERFACES (FObject)
-	REFCOUNT_METHODS (FObject)
-
-//------------------------------------------------------------------------
-protected:
-	IPtr<FUnknown> hostContext;
-	IPtr<IConnectionPoint> peerConnection;
-};
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/source/vst/vsteditcontroller.cpp

@@ -1,723 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/vsteditcontroller.cpp
-// Created by  : Steinberg, 04/2005
-// Description : VST Edit Controller Implementation
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "public.sdk/source/vst/vsteditcontroller.h"
-#include "base/source/updatehandler.h"
-#include "pluginterfaces/base/ustring.h"
-
-#include <cstdio>
-
-namespace Steinberg {
-namespace Vst {
-
-KnobMode EditController::hostKnobMode = kCircularMode;
-
-//------------------------------------------------------------------------
-// EditController Implementation
-//------------------------------------------------------------------------
-EditController::EditController () : componentHandler (nullptr), componentHandler2 (nullptr)
-{
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditController::initialize (FUnknown* context)
-{
-	return ComponentBase::initialize (context);
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditController::terminate ()
-{
-	parameters.removeAll ();
-
-	if (componentHandler)
-	{
-		componentHandler->release ();
-		componentHandler = nullptr;
-	}
-
-	if (componentHandler2)
-	{
-		componentHandler2->release ();
-		componentHandler2 = nullptr;
-	}
-
-	return ComponentBase::terminate ();
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditController::setComponentState (IBStream* /*state*/)
-{
-	return kNotImplemented;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditController::setState (IBStream* /*state*/)
-{
-	return kNotImplemented;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditController::getState (IBStream* /*state*/)
-{
-	return kNotImplemented;
-}
-
-//------------------------------------------------------------------------
-int32 PLUGIN_API EditController::getParameterCount ()
-{
-	return parameters.getParameterCount ();
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditController::getParameterInfo (int32 paramIndex, ParameterInfo& info)
-{
-	if (Parameter* parameter = parameters.getParameterByIndex (paramIndex))
-	{
-		info = parameter->getInfo ();
-		return kResultTrue;
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditController::getParamStringByValue (ParamID tag, ParamValue valueNormalized,
-                                                          String128 string)
-{
-	if (Parameter* parameter = getParameterObject (tag))
-	{
-		parameter->toString (valueNormalized, string);
-		return kResultTrue;
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditController::getParamValueByString (ParamID tag, TChar* string,
-                                                          ParamValue& valueNormalized)
-{
-	if (Parameter* parameter = getParameterObject (tag))
-	{
-		if (parameter->fromString (string, valueNormalized))
-		{
-			return kResultTrue;
-		}
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-ParamValue PLUGIN_API EditController::normalizedParamToPlain (ParamID tag,
-                                                              ParamValue valueNormalized)
-{
-	if (Parameter* parameter = getParameterObject (tag))
-	{
-		return parameter->toPlain (valueNormalized);
-	}
-	return valueNormalized;
-}
-
-//------------------------------------------------------------------------
-ParamValue PLUGIN_API EditController::plainParamToNormalized (ParamID tag, ParamValue plainValue)
-{
-	if (Parameter* parameter = getParameterObject (tag))
-	{
-		return parameter->toNormalized (plainValue);
-	}
-	return plainValue;
-}
-
-//------------------------------------------------------------------------
-ParamValue PLUGIN_API EditController::getParamNormalized (ParamID tag)
-{
-	if (Parameter* parameter = getParameterObject (tag))
-	{
-		return parameter->getNormalized ();
-	}
-	return 0.;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditController::setParamNormalized (ParamID tag, ParamValue value)
-{
-	if (Parameter* parameter = getParameterObject (tag))
-	{
-		parameter->setNormalized (value);
-		return kResultTrue;
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditController::setComponentHandler (IComponentHandler* newHandler)
-{
-	if (componentHandler == newHandler)
-	{
-		return kResultTrue;
-	}
-
-	if (componentHandler)
-	{
-		componentHandler->release ();
-	}
-
-	componentHandler = newHandler;
-	if (componentHandler)
-	{
-		componentHandler->addRef ();
-	}
-
-	// try to get the extended version
-	if (componentHandler2)
-	{
-		componentHandler2->release ();
-		componentHandler2 = nullptr;
-	}
-
-	if (newHandler)
-	{
-		newHandler->queryInterface (IComponentHandler2::iid, (void**)&componentHandler2);
-	}
-	return kResultTrue;
-}
-
-//------------------------------------------------------------------------
-tresult EditController::beginEdit (ParamID tag)
-{
-	if (componentHandler)
-	{
-		return componentHandler->beginEdit (tag);
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult EditController::performEdit (ParamID tag, ParamValue valueNormalized)
-{
-	if (componentHandler)
-	{
-		return componentHandler->performEdit (tag, valueNormalized);
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult EditController::endEdit (ParamID tag)
-{
-	if (componentHandler)
-	{
-		return componentHandler->endEdit (tag);
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult EditController::startGroupEdit ()
-{
-	if (componentHandler2)
-	{
-		return componentHandler2->startGroupEdit ();
-	}
-	return kNotImplemented;
-}
-
-//------------------------------------------------------------------------
-tresult EditController::finishGroupEdit ()
-{
-	if (componentHandler2)
-	{
-		return componentHandler2->finishGroupEdit ();
-	}
-	return kNotImplemented;
-}
-
-//------------------------------------------------------------------------
-tresult EditController::getParameterInfoByTag (ParamID tag, ParameterInfo& info)
-{
-	if (Parameter* parameter = getParameterObject (tag))
-	{
-		info = parameter->getInfo ();
-		return kResultTrue;
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult EditController::setDirty (TBool state)
-{
-	if (componentHandler2)
-	{
-		return componentHandler2->setDirty (state);
-	}
-	return kNotImplemented;
-}
-
-//------------------------------------------------------------------------
-tresult EditController::requestOpenEditor (FIDString name)
-{
-	if (componentHandler2)
-	{
-		return componentHandler2->requestOpenEditor (name);
-	}
-	return kNotImplemented;
-}
-
-#ifndef NO_PLUGUI
-//------------------------------------------------------------------------
-// EditorView Implementation
-//------------------------------------------------------------------------
-EditorView::EditorView (EditController* _controller, ViewRect* size)
-: CPluginView (size), controller (_controller)
-{
-	if (controller)
-	{
-		controller->addRef ();
-	}
-}
-
-//------------------------------------------------------------------------
-EditorView::~EditorView ()
-{
-	if (controller)
-	{
-		controller->editorDestroyed (this);
-		controller->release ();
-	}
-}
-
-//------------------------------------------------------------------------
-void EditorView::attachedToParent ()
-{
-	if (controller)
-	{
-		controller->editorAttached (this);
-	}
-}
-
-//------------------------------------------------------------------------
-void EditorView::removedFromParent ()
-{
-	if (controller)
-	{
-		controller->editorRemoved (this);
-	}
-}
-#endif // NO_PLUGUI
-
-//------------------------------------------------------------------------
-// EditControllerEx1 implementation
-//------------------------------------------------------------------------
-EditControllerEx1::EditControllerEx1 () : selectedUnit (kRootUnitId)
-{
-	UpdateHandler::instance ();
-}
-
-//------------------------------------------------------------------------
-EditControllerEx1::~EditControllerEx1 ()
-{
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditControllerEx1::terminate ()
-{
-	units.clear ();
-
-	for (const auto& programList : programLists)
-	{
-		if (programList)
-			programList->removeDependent (this);
-	}
-	programLists.clear ();
-	programIndexMap.clear ();
-
-	return EditController::terminate ();
-}
-
-//------------------------------------------------------------------------
-bool EditControllerEx1::addUnit (Unit* unit)
-{
-	units.emplace_back (unit, false);
-	return true;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditControllerEx1::getUnitInfo (int32 unitIndex, UnitInfo& info /*out*/)
-{
-	if (Unit* unit = units.at (unitIndex))
-	{
-		info = unit->getInfo ();
-		return kResultTrue;
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult EditControllerEx1::notifyUnitSelection ()
-{
-	tresult result = kResultFalse;
-	FUnknownPtr<IUnitHandler> unitHandler (componentHandler);
-	if (unitHandler)
-		result = unitHandler->notifyUnitSelection (selectedUnit);
-	return result;
-}
-
-//------------------------------------------------------------------------
-bool EditControllerEx1::addProgramList (ProgramList* list)
-{
-	programIndexMap[list->getID ()] = programLists.size ();
-	programLists.emplace_back (list, false);
-	list->addDependent (this);
-	return true;
-}
-
-//------------------------------------------------------------------------
-ProgramList* EditControllerEx1::getProgramList (ProgramListID listId) const
-{
-	auto it = programIndexMap.find (listId);
-	return it == programIndexMap.end () ? nullptr : programLists[it->second];
-}
-
-//------------------------------------------------------------------------
-tresult EditControllerEx1::notifyProgramListChange (ProgramListID listId, int32 programIndex)
-{
-	tresult result = kResultFalse;
-	FUnknownPtr<IUnitHandler> unitHandler (componentHandler);
-	if (unitHandler)
-		result = unitHandler->notifyProgramListChange (listId, programIndex);
-	return result;
-}
-
-//------------------------------------------------------------------------
-int32 PLUGIN_API EditControllerEx1::getProgramListCount ()
-{
-	return static_cast<int32> (programLists.size ());
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditControllerEx1::getProgramListInfo (int32 listIndex,
-                                                          ProgramListInfo& info /*out*/)
-{
-	if (listIndex < 0 || listIndex >= static_cast<int32> (programLists.size ()))
-		return kResultFalse;
-	info = programLists[listIndex]->getInfo ();
-	return kResultTrue;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditControllerEx1::getProgramName (ProgramListID listId, int32 programIndex,
-                                                      String128 name /*out*/)
-{
-	ProgramIndexMap::const_iterator it = programIndexMap.find (listId);
-	if (it != programIndexMap.end ())
-	{
-		return programLists[it->second]->getProgramName (programIndex, name);
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult EditControllerEx1::setProgramName (ProgramListID listId, int32 programIndex,
-                                           const String128 name /*in*/)
-{
-	ProgramIndexMap::const_iterator it = programIndexMap.find (listId);
-	if (it != programIndexMap.end ())
-	{
-		return programLists[it->second]->setProgramName (programIndex, name);
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditControllerEx1::getProgramInfo (ProgramListID listId, int32 programIndex,
-                                                      CString attributeId /*in*/,
-                                                      String128 attributeValue /*out*/)
-{
-	ProgramIndexMap::const_iterator it = programIndexMap.find (listId);
-	if (it != programIndexMap.end ())
-	{
-		return programLists[it->second]->getProgramInfo (programIndex, attributeId, attributeValue);
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditControllerEx1::hasProgramPitchNames (ProgramListID listId,
-                                                            int32 programIndex)
-{
-	ProgramIndexMap::const_iterator it = programIndexMap.find (listId);
-	if (it != programIndexMap.end ())
-	{
-		return programLists[it->second]->hasPitchNames (programIndex);
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API EditControllerEx1::getProgramPitchName (ProgramListID listId, int32 programIndex,
-                                                           int16 midiPitch, String128 name /*out*/)
-{
-	ProgramIndexMap::const_iterator it = programIndexMap.find (listId);
-	if (it != programIndexMap.end ())
-	{
-		return programLists[it->second]->getPitchName (programIndex, midiPitch, name);
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-void PLUGIN_API EditControllerEx1::update (FUnknown* changedUnknown, int32 /*message*/)
-{
-	auto* programList = FCast<ProgramList> (changedUnknown);
-	if (programList)
-	{
-		FUnknownPtr<IUnitHandler> unitHandler (componentHandler);
-		if (unitHandler)
-			unitHandler->notifyProgramListChange (programList->getID (), kAllProgramInvalid);
-	}
-}
-
-//------------------------------------------------------------------------
-// Unit implementation
-//------------------------------------------------------------------------
-Unit::Unit ()
-{
-	memset (&info, 0, sizeof (UnitInfo));
-}
-
-//------------------------------------------------------------------------
-Unit::Unit (const String128 name, UnitID unitId, UnitID parentUnitId, ProgramListID programListId)
-{
-	setName (name);
-	info.id = unitId;
-	info.parentUnitId = parentUnitId;
-	info.programListId = programListId;
-}
-
-//------------------------------------------------------------------------
-Unit::Unit (const UnitInfo& info) : info (info)
-{
-}
-
-//------------------------------------------------------------------------
-void Unit::setName (const String128 newName)
-{
-	UString128 (newName).copyTo (info.name, 128);
-}
-
-//------------------------------------------------------------------------
-// ProgramList implementation
-//------------------------------------------------------------------------
-ProgramList::ProgramList (const String128 name, ProgramListID listId, UnitID unitId)
-: unitId (unitId), parameter (nullptr)
-{
-	UString128 (name).copyTo (info.name, 128);
-	info.id = listId;
-	info.programCount = 0;
-}
-
-//------------------------------------------------------------------------
-ProgramList::ProgramList (const ProgramList& programList)
-: info (programList.info)
-, unitId (programList.unitId)
-, programNames (programList.programNames)
-, parameter (nullptr)
-{
-}
-
-//------------------------------------------------------------------------
-int32 ProgramList::addProgram (const String128 name)
-{
-	++info.programCount;
-	programNames.emplace_back (name);
-	programInfos.emplace_back ();
-	return static_cast<int32> (programNames.size ()) - 1;
-}
-
-//------------------------------------------------------------------------
-bool ProgramList::setProgramInfo (int32 programIndex, CString attributeId, const String128 value)
-{
-	if (programIndex >= 0 && programIndex < static_cast<int32> (programNames.size ()))
-	{
-		programInfos.at (programIndex).insert (std::make_pair (attributeId, value));
-		return true;
-	}
-	return false;
-}
-
-//------------------------------------------------------------------------
-tresult ProgramList::getProgramInfo (int32 programIndex, CString attributeId,
-                                     String128 value /*out*/)
-{
-	if (programIndex >= 0 && programIndex < static_cast<int32> (programNames.size ()))
-	{
-		StringMap::const_iterator it = programInfos[programIndex].find (attributeId);
-		if (it != programInfos[programIndex].end ())
-		{
-			if (!it->second.isEmpty ())
-			{
-				it->second.copyTo16 (value, 0, 128);
-				return kResultTrue;
-			}
-		}
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult ProgramList::getProgramName (int32 programIndex, String128 name /*out*/)
-{
-	if (programIndex >= 0 && programIndex < static_cast<int32> (programNames.size ()))
-	{
-		programNames.at (programIndex).copyTo16 (name, 0, 128);
-		return kResultTrue;
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult ProgramList::setProgramName (int32 programIndex, const String128 name /*in*/)
-{
-	if (programIndex >= 0 && programIndex < static_cast<int32> (programNames.size ()))
-	{
-		programNames.at (programIndex) = name;
-		if (parameter)
-		{
-			static_cast<StringListParameter*> (parameter)->replaceString (programIndex, name);
-		}
-		return kResultTrue;
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-Parameter* ProgramList::getParameter ()
-{
-	if (parameter == nullptr)
-	{
-		auto* listParameter = new StringListParameter (
-			info.name, info.id, nullptr,
-			ParameterInfo::kCanAutomate | ParameterInfo::kIsList | ParameterInfo::kIsProgramChange,
-			unitId);
-		for (const auto& programName : programNames)
-		{
-			listParameter->appendString (programName);
-		}
-		parameter = listParameter;
-	}
-	return parameter;
-}
-
-//------------------------------------------------------------------------
-// ProgramListWithPitchNames implementation
-//-----------------------------------------------------------------------------
-ProgramListWithPitchNames::ProgramListWithPitchNames (const String128 name, ProgramListID listId,
-                                                      UnitID unitId)
-: ProgramList (name, listId, unitId)
-{
-}
-
-//-----------------------------------------------------------------------------
-int32 ProgramListWithPitchNames::addProgram (const String128 name)
-{
-	int32 index = ProgramList::addProgram (name);
-	if (index >= 0)
-		pitchNames.emplace_back ();
-	return index;
-}
-
-//-----------------------------------------------------------------------------
-bool ProgramListWithPitchNames::setPitchName (int32 programIndex, int16 pitch,
-                                              const String128 pitchName)
-{
-	if (programIndex < 0 || programIndex >= getCount ())
-		return false;
-
-	bool nameChanged = true;
-	std::pair<PitchNameMap::iterator, bool> res =
-	    pitchNames[programIndex].insert (std::make_pair (pitch, pitchName));
-	if (!res.second)
-	{
-		if (res.first->second == pitchName)
-			nameChanged = false;
-		else
-			res.first->second = pitchName;
-	}
-
-	if (nameChanged)
-		changed ();
-	return true;
-}
-
-//-----------------------------------------------------------------------------
-bool ProgramListWithPitchNames::removePitchName (int32 programIndex, int16 pitch)
-{
-	bool result = false;
-	if (programIndex >= 0 && programIndex < getCount ())
-	{
-		result = pitchNames.at (programIndex).erase (pitch) != 0;
-	}
-	if (result)
-		changed ();
-	return result;
-}
-
-//-----------------------------------------------------------------------------
-tresult ProgramListWithPitchNames::hasPitchNames (int32 programIndex)
-{
-	if (programIndex >= 0 && programIndex < getCount ())
-		return (pitchNames.at (programIndex).empty () == true) ? kResultFalse : kResultTrue;
-	return kResultFalse;
-}
-
-//-----------------------------------------------------------------------------
-tresult ProgramListWithPitchNames::getPitchName (int32 programIndex, int16 midiPitch,
-                                                 String128 name /*out*/)
-{
-	if (programIndex >= 0 && programIndex < getCount ())
-	{
-		PitchNameMap::const_iterator it = pitchNames[programIndex].find (midiPitch);
-		if (it != pitchNames[programIndex].end ())
-		{
-			it->second.copyTo16 (name, 0, 128);
-			return kResultTrue;
-		}
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/source/vst/vsteditcontroller.h

@@ -1,374 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/vsteditcontroller.h
-// Created by  : Steinberg, 04/2005
-// Description : VST Edit Controller Implementation
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "public.sdk/source/vst/vstcomponentbase.h"
-#include "public.sdk/source/vst/vstparameters.h"
-#include "public.sdk/source/common/pluginview.h"
-#include "base/source/fstring.h"
-
-#include "pluginterfaces/vst/ivsteditcontroller.h"
-#include "pluginterfaces/vst/ivstunits.h"
-
-#include <vector>
-#include <map>
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-class EditorView;
-
-//------------------------------------------------------------------------
-/** Default implementation for a VST 3 edit controller.
-\ingroup vstClasses
-Can be used as base class for a specific controller implementation
-*/
-class EditController : public ComponentBase, public IEditController, public IEditController2
-{
-public:
-//------------------------------------------------------------------------
-	EditController ();
-
-	//---from IEditController-------
-	tresult PLUGIN_API setComponentState (IBStream* state) SMTG_OVERRIDE;
-	tresult PLUGIN_API setState (IBStream* state) SMTG_OVERRIDE;
-	tresult PLUGIN_API getState (IBStream* state) SMTG_OVERRIDE;
-	int32 PLUGIN_API getParameterCount () SMTG_OVERRIDE;
-	tresult PLUGIN_API getParameterInfo (int32 paramIndex, ParameterInfo& info) SMTG_OVERRIDE;
-	tresult PLUGIN_API getParamStringByValue (ParamID tag, ParamValue valueNormalized, String128 string) SMTG_OVERRIDE;
-	tresult PLUGIN_API getParamValueByString (ParamID tag, TChar* string, ParamValue& valueNormalized) SMTG_OVERRIDE;
-	ParamValue PLUGIN_API normalizedParamToPlain (ParamID tag, ParamValue valueNormalized) SMTG_OVERRIDE;
-	ParamValue PLUGIN_API plainParamToNormalized (ParamID tag, ParamValue plainValue) SMTG_OVERRIDE;
-	ParamValue PLUGIN_API getParamNormalized (ParamID tag) SMTG_OVERRIDE;
-	tresult PLUGIN_API setParamNormalized (ParamID tag, ParamValue value) SMTG_OVERRIDE;
-	tresult PLUGIN_API setComponentHandler (IComponentHandler* handler) SMTG_OVERRIDE;
-	IPlugView* PLUGIN_API createView (FIDString /*name*/) SMTG_OVERRIDE {return nullptr;}
-
-	//---from IEditController2-------
-	tresult PLUGIN_API setKnobMode (KnobMode mode) SMTG_OVERRIDE { hostKnobMode = mode; return kResultTrue; }
-	tresult PLUGIN_API openHelp (TBool /*onlyCheck*/) SMTG_OVERRIDE {return kResultFalse;}
-	tresult PLUGIN_API openAboutBox (TBool /*onlyCheck*/) SMTG_OVERRIDE {return kResultFalse;}
-
-	//---from ComponentBase---------
-	tresult PLUGIN_API initialize (FUnknown* context) SMTG_OVERRIDE;
-	tresult PLUGIN_API terminate () SMTG_OVERRIDE;
-
-	//---Internal Methods-------
-	virtual tresult beginEdit (ParamID tag);	///< to be called before a serie of performEdit
-	virtual tresult performEdit (ParamID tag, ParamValue valueNormalized); ///< will inform the host about the value change
-	virtual tresult endEdit (ParamID tag);		///< to be called after a serie of performEdit
-	virtual tresult startGroupEdit ();			///< calls IComponentHandler2::startGroupEdit() if host supports it
-	virtual tresult finishGroupEdit ();			///< calls IComponentHandler2::finishGroupEdit() if host supports it
-
-	virtual void editorDestroyed (EditorView* /*editor*/) {}	///< called from EditorView if it was destroyed
-	virtual void editorAttached (EditorView* /*editor*/) {}		///< called from EditorView if it was attached to a parent
-	virtual void editorRemoved (EditorView* /*editor*/) {}		///< called from EditorView if it was removed from a parent
-
-	static KnobMode getHostKnobMode () { return hostKnobMode; }	///< return host knob mode
-
-	/** Gets for a given tag the parameter object. */
-	virtual Parameter* getParameterObject (ParamID tag) { return parameters.getParameter (tag); }
-
-	/** Gets for a given tag the parameter information. */
-	virtual tresult getParameterInfoByTag (ParamID tag, ParameterInfo& info);
-
-	/** Calls IComponentHandler2::setDirty (state) if host supports it. */
-	virtual tresult setDirty (TBool state);
-
-	/** Calls IComponentHandler2::requestOpenEditor (name) if host supports it. */
-	virtual tresult requestOpenEditor (FIDString name = ViewType::kEditor);
-
-	//---Accessor Methods-------
-	IComponentHandler* getComponentHandler () const { return componentHandler; }
-
-	//---Interface---------
-	OBJ_METHODS (EditController, ComponentBase)
-	DEFINE_INTERFACES
-		DEF_INTERFACE (IEditController)
-		DEF_INTERFACE (IEditController2)
-	END_DEFINE_INTERFACES (ComponentBase)
-	REFCOUNT_METHODS (ComponentBase)
-//------------------------------------------------------------------------
-protected:
-	IComponentHandler* componentHandler;
-	IComponentHandler2* componentHandler2;
-
-	ParameterContainer parameters;
-
-	static KnobMode hostKnobMode;
-};
-
-//------------------------------------------------------------------------
-/** View related to an edit controller.
-\ingroup vstClasses
-*/
-class EditorView : public CPluginView
-{
-public:
-//------------------------------------------------------------------------
-	EditorView (EditController* controller, ViewRect* size = nullptr);
-	~EditorView () override;
-
-	/** Gets its controller part. */
-	EditController* getController () const { return controller; }
-
-	//---from CPluginView-------------
-	void attachedToParent () SMTG_OVERRIDE;
-	void removedFromParent () SMTG_OVERRIDE;
-
-//------------------------------------------------------------------------
-protected:
-	EditController* controller;
-};
-
-//------------------------------------------------------------------------
-/** Unit element.
-\ingroup vstClasses 
-*/
-class Unit : public FObject
-{
-public:
-//------------------------------------------------------------------------
-	Unit (const String128 name, UnitID unitId, UnitID parentUnitId = kRootUnitId,
-	      ProgramListID programListId = kNoProgramListId);
-	Unit (const UnitInfo& unit);
-
-	/** Returns its info. */
-	const UnitInfo& getInfo () const { return info; }
-
-	/** Returns its Unit ID. */
-	UnitID getID () const { return info.id; }
-
-	/** Sets a new Unit ID. */
-	void setID (UnitID newID) { info.id = newID; }
-
-	/** Returns its Unit Name. */
-	const TChar* getName () const { return info.name; }
-
-	/** Sets a new Unit Name. */
-	void setName (const String128 newName);
-
-	/** Returns its ProgramList ID. */
-	ProgramListID getProgramListID () const { return info.programListId; }
-
-	/** Sets a new ProgramList ID. */
-	void setProgramListID (ProgramListID newID) { info.programListId = newID; }
-
-	OBJ_METHODS (Unit, FObject)
-//------------------------------------------------------------------------
-protected:
-	Unit ();
-	UnitInfo info;
-};
-
-//------------------------------------------------------------------------
-/** ProgramList element.
-\ingroup vstClasses 
-*/
-class ProgramList : public FObject
-{
-public:
-//------------------------------------------------------------------------
-	ProgramList (const String128 name, ProgramListID listId, UnitID unitId);
-	ProgramList (const ProgramList& programList);
-
-	const ProgramListInfo& getInfo () const { return info; }
-	ProgramListID getID () const { return info.id; }
-	const TChar* getName () const { return info.name; }
-	int32 getCount () const { return info.programCount; }
-
-	virtual tresult getProgramName (int32 programIndex, String128 name /*out*/);
-	virtual tresult setProgramName (int32 programIndex, const String128 name /*in*/);
-	virtual tresult getProgramInfo (int32 programIndex, CString attributeId,
-	                                String128 value /*out*/);
-	virtual tresult hasPitchNames (int32 programIndex)
-	{
-		(void)programIndex;
-		return kResultFalse;
-	}
-	virtual tresult getPitchName (int32 programIndex, int16 midiPitch, String128 name /*out*/)
-	{
-		(void)programIndex;
-		(void)midiPitch;
-		(void)name;
-		return kResultFalse;
-	}
-
-	/** Adds a program to the end of the list. returns the index of the program. */
-	virtual int32 addProgram (const String128 name);
-
-	/** Sets a program attribute value. */
-	virtual bool setProgramInfo (int32 programIndex, CString attributeId, const String128 value);
-
-	/** Creates and returns the program parameter. */
-	virtual Parameter* getParameter ();
-
-	OBJ_METHODS (ProgramList, FObject)
-//------------------------------------------------------------------------
-protected:
-	using StringMap = std::map<String, String>;
-	using StringVector = std::vector<String>;
-	using ProgramInfoVector = std::vector<StringMap>;
-	ProgramListInfo info;
-	UnitID unitId;
-	StringVector programNames;
-	ProgramInfoVector programInfos;
-	Parameter* parameter;
-};
-
-//------------------------------------------------------------------------
-/** ProgramListWithPitchNames element.
-\ingroup vstClasses
-*/
-class ProgramListWithPitchNames : public ProgramList
-{
-public:
-	ProgramListWithPitchNames (const String128 name, ProgramListID listId, UnitID unitId);
-
-	/** Sets a name for the given program index and a given pitch. */
-	bool setPitchName (int32 programIndex, int16 pitch, const String128 pitchName);
-
-	/** Removes the PitchName entry for the given program index and a given pitch. Returns true if
-	 * it was found and removed. */
-	bool removePitchName (int32 programIndex, int16 pitch);
-
-	//---from ProgramList---------
-	int32 addProgram (const String128 name) SMTG_OVERRIDE;
-	tresult hasPitchNames (int32 programIndex) SMTG_OVERRIDE;
-	tresult getPitchName (int32 programIndex, int16 midiPitch,
-	                      String128 name /*out*/) SMTG_OVERRIDE;
-
-	OBJ_METHODS (ProgramListWithPitchNames, ProgramList)
-protected:
-	using PitchNameMap = std::map<int16, String>;
-	using PitchNamesVector = std::vector<PitchNameMap>;
-	PitchNamesVector pitchNames;
-};
-
-//------------------------------------------------------------------------
-/** Advanced implementation (support IUnitInfo) for a VST 3 edit controller.
-\ingroup vstClasses
-- [extends EditController]
-*/
-class EditControllerEx1 : public EditController, public IUnitInfo
-{
-public:
-	EditControllerEx1 ();
-	~EditControllerEx1 () override;
-
-	//---from ComponentBase---------
-	tresult PLUGIN_API terminate () SMTG_OVERRIDE;
-
-	/** Adds a given unit. */
-	bool addUnit (Unit* unit);
-
-	/** Adds a given program list. */
-	bool addProgramList (ProgramList* list);
-
-	/** Returns the ProgramList associated to a given listId. */
-	ProgramList* getProgramList (ProgramListID listId) const;
-
-	/** Notifies the host about program list changes. */
-	tresult notifyProgramListChange (ProgramListID listId, int32 programIndex = kAllProgramInvalid);
-
-	//---from IUnitInfo------------------
-	int32 PLUGIN_API getUnitCount () SMTG_OVERRIDE { return static_cast<int32> (units.size ()); }
-	tresult PLUGIN_API getUnitInfo (int32 unitIndex, UnitInfo& info /*out*/) SMTG_OVERRIDE;
-
-	int32 PLUGIN_API getProgramListCount () SMTG_OVERRIDE;
-	tresult PLUGIN_API getProgramListInfo (int32 listIndex,
-	                                       ProgramListInfo& info /*out*/) SMTG_OVERRIDE;
-	tresult PLUGIN_API getProgramName (ProgramListID listId, int32 programIndex,
-	                                   String128 name /*out*/) SMTG_OVERRIDE;
-	tresult PLUGIN_API getProgramInfo (ProgramListID listId, int32 programIndex,
-	                                   CString attributeId /*in*/,
-	                                   String128 attributeValue /*out*/) SMTG_OVERRIDE;
-
-	tresult PLUGIN_API hasProgramPitchNames (ProgramListID listId,
-	                                         int32 programIndex) SMTG_OVERRIDE;
-	tresult PLUGIN_API getProgramPitchName (ProgramListID listId, int32 programIndex,
-	                                        int16 midiPitch, String128 name /*out*/) SMTG_OVERRIDE;
-
-	virtual tresult setProgramName (ProgramListID listId, int32 programIndex,
-	                                const String128 name /*in*/);
-
-	// units selection --------------------
-	UnitID PLUGIN_API getSelectedUnit () SMTG_OVERRIDE { return selectedUnit; }
-	tresult PLUGIN_API selectUnit (UnitID unitId) SMTG_OVERRIDE
-	{
-		selectedUnit = unitId;
-		return kResultTrue;
-	}
-
-	tresult PLUGIN_API getUnitByBus (MediaType /*type*/, BusDirection /*dir*/, int32 /*busIndex*/,
-	                                 int32 /*channel*/, UnitID& /*unitId*/ /*out*/) SMTG_OVERRIDE
-	{
-		return kResultFalse;
-	}
-	tresult PLUGIN_API setUnitProgramData (int32 /*listOrUnitId*/, int32 /*programIndex*/,
-	                                       IBStream* /*data*/) SMTG_OVERRIDE
-	{
-		return kResultFalse;
-	}
-
-	/** Notifies the host about the selected Unit. */
-	virtual tresult notifyUnitSelection ();
-
-	//---from IDependent------------------
-	void PLUGIN_API update (FUnknown* changedUnknown, int32 message) SMTG_OVERRIDE;
-
-	//---Interface---------
-	OBJ_METHODS (EditControllerEx1, EditController)
-	DEFINE_INTERFACES
-		DEF_INTERFACE (IUnitInfo)
-	END_DEFINE_INTERFACES (EditController)
-	REFCOUNT_METHODS (EditController)
-
-protected:
-	using ProgramListVector = std::vector<IPtr<ProgramList>>;
-	using ProgramIndexMap = std::map<ProgramListID, ProgramListVector::size_type>;
-	using UnitVector = std::vector<IPtr<Unit>>;
-	UnitVector units;
-	ProgramListVector programLists;
-	ProgramIndexMap programIndexMap;
-	UnitID selectedUnit;
-};
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/source/vst/vstinitiids.cpp

@@ -1,143 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/vstinitiids.cpp
-// Created by  : Steinberg, 10/2009
-// Description : Interface symbols file
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "pluginterfaces/base/funknown.h"
-
-#include "pluginterfaces/vst/ivstaudioprocessor.h"
-#include "pluginterfaces/vst/ivstautomationstate.h"
-#include "pluginterfaces/vst/ivstchannelcontextinfo.h"
-#include "pluginterfaces/vst/ivstcontextmenu.h"
-#include "pluginterfaces/vst/ivsteditcontroller.h"
-#include "pluginterfaces/vst/ivstevents.h"
-#include "pluginterfaces/vst/ivsthostapplication.h"
-#include "pluginterfaces/vst/ivstinterappaudio.h"
-#include "pluginterfaces/vst/ivstmessage.h"
-#include "pluginterfaces/vst/ivstmidilearn.h"
-#include "pluginterfaces/vst/ivstparameterchanges.h"
-#include "pluginterfaces/vst/ivstparameterfunctionname.h"
-#include "pluginterfaces/vst/ivstphysicalui.h"
-#include "pluginterfaces/vst/ivstpluginterfacesupport.h"
-#include "pluginterfaces/vst/ivstplugview.h"
-#include "pluginterfaces/vst/ivstprefetchablesupport.h"
-#include "pluginterfaces/vst/ivstrepresentation.h"
-#include "pluginterfaces/vst/ivsttestplugprovider.h"
-#include "pluginterfaces/vst/ivstunits.h"
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//----VST 3.0--------------------------------
-DEF_CLASS_IID (IComponent)
-DEF_CLASS_IID (IAudioProcessor)
-DEF_CLASS_IID (IUnitData)
-DEF_CLASS_IID (IProgramListData)
-
-DEF_CLASS_IID (IEditController)
-DEF_CLASS_IID (IUnitInfo)
-
-DEF_CLASS_IID (IConnectionPoint)
-
-DEF_CLASS_IID (IComponentHandler)
-DEF_CLASS_IID (IUnitHandler)
-
-DEF_CLASS_IID (IParamValueQueue)
-DEF_CLASS_IID (IParameterChanges)
-
-DEF_CLASS_IID (IEventList)
-DEF_CLASS_IID (IMessage)
-
-DEF_CLASS_IID (IHostApplication)
-DEF_CLASS_IID (IAttributeList)
-
-//----VST 3.0.1--------------------------------
-DEF_CLASS_IID (IMidiMapping)
-
-//----VST 3.0.2--------------------------------
-DEF_CLASS_IID (IParameterFinder)
-
-//----VST 3.1----------------------------------
-DEF_CLASS_IID (IComponentHandler2)
-DEF_CLASS_IID (IEditController2)
-DEF_CLASS_IID (IAudioPresentationLatency)
-DEF_CLASS_IID (IVst3ToVst2Wrapper)
-DEF_CLASS_IID (IVst3ToAUWrapper)
-
-//----VST 3.5----------------------------------
-DEF_CLASS_IID (INoteExpressionController)
-DEF_CLASS_IID (IKeyswitchController)
-DEF_CLASS_IID (IContextMenuTarget)
-DEF_CLASS_IID (IContextMenu)
-DEF_CLASS_IID (IComponentHandler3)
-DEF_CLASS_IID (IEditControllerHostEditing)
-DEF_CLASS_IID (IXmlRepresentationController)
-
-//----VST 3.6----------------------------------
-DEF_CLASS_IID (IInterAppAudioHost)
-DEF_CLASS_IID (IInterAppAudioConnectionNotification)
-DEF_CLASS_IID (IInterAppAudioPresetManager)
-DEF_CLASS_IID (IStreamAttributes)
-
-//----VST 3.6.5--------------------------------
-DEF_CLASS_IID (ChannelContext::IInfoListener)
-DEF_CLASS_IID (IPrefetchableSupport)
-DEF_CLASS_IID (IUnitHandler2)
-DEF_CLASS_IID (IAutomationState)
-
-//----VST 3.6.8--------------------------------
-DEF_CLASS_IID (IComponentHandlerBusActivation)
-DEF_CLASS_IID (IVst3ToAAXWrapper)
-
-//----VST 3.6.11--------------------------------
-DEF_CLASS_IID (INoteExpressionPhysicalUIMapping)
-
-//----VST 3.6.12--------------------------------
-DEF_CLASS_IID (IMidiLearn)
-DEF_CLASS_IID (IPlugInterfaceSupport)
-DEF_CLASS_IID (IVst3WrapperMPESupport)
-
-//----VST 3.6.13--------------------------------
-DEF_CLASS_IID (ITestPlugProvider)
-
-//----VST 3.7-----------------------------------
-DEF_CLASS_IID (IParameterFunctionName)
-DEF_CLASS_IID (IProcessContextRequirements)
-DEF_CLASS_IID (IProgress)
-DEF_CLASS_IID (ITestPlugProvider2)
-
-//------------------------------------------------------------------------
-} // Vst
-} // Steinberg

source/includes/vst3sdk/public.sdk/source/vst/vstparameters.cpp

@@ -1,448 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/vstparameters.cpp
-// Created by  : Steinberg, 03/2008
-// Description : VST Parameter Implementation
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "vstparameters.h"
-#include "pluginterfaces/base/futils.h"
-#include "pluginterfaces/base/ustring.h"
-#include <cstdlib>
-
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-// Parameter Implementation
-//------------------------------------------------------------------------
-Parameter::Parameter () : valueNormalized (0.), precision (4)
-{
-	info = {};
-}
-
-//------------------------------------------------------------------------
-Parameter::Parameter (const ParameterInfo& info)
-: info (info), valueNormalized (info.defaultNormalizedValue), precision (4)
-{
-}
-
-//------------------------------------------------------------------------
-Parameter::Parameter (const TChar* title, ParamID tag, const TChar* units,
-                      ParamValue defaultValueNormalized, int32 stepCount, int32 flags,
-                      UnitID unitID, const TChar* shortTitle)
-: precision (4)
-{
-	info = {};
-
-	UString (info.title, str16BufferSize (String128)).assign (title);
-	if (units)
-		UString (info.units, str16BufferSize (String128)).assign (units);
-	if (shortTitle)
-		UString (info.shortTitle, str16BufferSize (String128)).assign (shortTitle);
-
-	info.stepCount = stepCount;
-	info.defaultNormalizedValue = valueNormalized = defaultValueNormalized;
-	info.flags = flags;
-	info.id = tag;
-	info.unitId = unitID;
-}
-
-//------------------------------------------------------------------------
-Parameter::~Parameter ()
-{
-}
-
-//------------------------------------------------------------------------
-bool Parameter::setNormalized (ParamValue normValue)
-{
-	if (normValue > 1.0)
-	{
-		normValue = 1.0;
-	}
-	else if (normValue < 0.)
-	{
-		normValue = 0.;
-	}
-
-	if (normValue != valueNormalized)
-	{
-		valueNormalized = normValue;
-		changed ();
-		return true;
-	}
-	return false;
-}
-
-//------------------------------------------------------------------------
-void Parameter::toString (ParamValue normValue, String128 string) const
-{
-	UString wrapper (string, str16BufferSize (String128));
-	if (info.stepCount == 1)
-	{
-		if (normValue > 0.5)
-		{
-			wrapper.assign (STR16 ("On"));
-		}
-		else
-		{
-			wrapper.assign (STR16 ("Off"));
-		}
-	}
-	else
-	{
-		if (!wrapper.printFloat (normValue, precision))
-			string[0] = 0;
-	}
-}
-
-//------------------------------------------------------------------------
-bool Parameter::fromString (const TChar* string, ParamValue& normValue) const
-{
-	UString wrapper (const_cast<TChar*> (string), tstrlen (string));
-	return wrapper.scanFloat (normValue);
-}
-
-//------------------------------------------------------------------------
-ParamValue Parameter::toPlain (ParamValue normValue) const
-{
-	return normValue;
-}
-
-//------------------------------------------------------------------------
-ParamValue Parameter::toNormalized (ParamValue plainValue) const
-{
-	return plainValue;
-}
-
-//------------------------------------------------------------------------
-// RangeParameter Implementation
-//------------------------------------------------------------------------
-RangeParameter::RangeParameter () : minPlain (0), maxPlain (1)
-{
-}
-
-//------------------------------------------------------------------------
-RangeParameter::RangeParameter (const ParameterInfo& paramInfo, ParamValue min, ParamValue max)
-: Parameter (paramInfo), minPlain (min), maxPlain (max)
-{
-}
-
-//------------------------------------------------------------------------
-RangeParameter::RangeParameter (const TChar* title, ParamID tag, const TChar* units,
-                                ParamValue minPlain, ParamValue maxPlain,
-                                ParamValue defaultValuePlain, int32 stepCount, int32 flags,
-                                UnitID unitID, const TChar* shortTitle)
-: minPlain (minPlain), maxPlain (maxPlain)
-{
-	UString (info.title, str16BufferSize (String128)).assign (title);
-	if (units)
-		UString (info.units, str16BufferSize (String128)).assign (units);
-	if (shortTitle)
-		UString (info.shortTitle, str16BufferSize (String128)).assign (shortTitle);
-
-	info.stepCount = stepCount;
-	info.defaultNormalizedValue = valueNormalized = toNormalized (defaultValuePlain);
-	info.flags = flags;
-	info.id = tag;
-	info.unitId = unitID;
-}
-
-//------------------------------------------------------------------------
-void RangeParameter::toString (ParamValue _valueNormalized, String128 string) const
-{
-	if (info.stepCount > 1)
-	{
-		UString wrapper (string, str16BufferSize (String128));
-		int64 plain = static_cast<int64> (toPlain (_valueNormalized));
-		if (!wrapper.printInt (plain))
-			string[0] = 0;
-	}
-	else
-	{
-		Parameter::toString (toPlain (_valueNormalized), string);
-	}
-}
-
-//------------------------------------------------------------------------
-bool RangeParameter::fromString (const TChar* string, ParamValue& _valueNormalized) const
-{
-	UString wrapper (const_cast<TChar*> (string), tstrlen (string));
-	if (info.stepCount > 1)
-	{
-		int64 plainValue;
-		if (wrapper.scanInt (plainValue))
-		{
-			_valueNormalized = toNormalized ((ParamValue)plainValue);
-			return true;
-		}
-		return false;
-	}
-	if (wrapper.scanFloat (_valueNormalized))
-	{
-		if (_valueNormalized < getMin ())
-			_valueNormalized = getMin ();
-		else if (_valueNormalized > getMax ())
-			_valueNormalized = getMax ();
-		_valueNormalized = toNormalized (_valueNormalized);
-		return true;
-	}
-	return false;
-}
-
-//------------------------------------------------------------------------
-ParamValue RangeParameter::toPlain (ParamValue _valueNormalized) const
-{
-	if (info.stepCount > 1)
-		return FromNormalized<ParamValue> (_valueNormalized, info.stepCount) + getMin ();
-	return _valueNormalized * (getMax () - getMin ()) + getMin ();
-}
-
-//------------------------------------------------------------------------
-ParamValue RangeParameter::toNormalized (ParamValue plainValue) const
-{
-	if (info.stepCount > 1)
-		return ToNormalized <ParamValue>(plainValue - getMin (), info.stepCount);
-	return (plainValue - getMin ()) / (getMax () - getMin ());
-}
-
-//------------------------------------------------------------------------
-// StringListParameter Implementation
-//------------------------------------------------------------------------
-StringListParameter::StringListParameter (const ParameterInfo& paramInfo) : Parameter (paramInfo)
-{
-}
-
-//------------------------------------------------------------------------
-StringListParameter::StringListParameter (const TChar* title, ParamID tag, const TChar* units,
-                                          int32 flags, UnitID unitID, const TChar* shortTitle)
-{
-	UString (info.title, str16BufferSize (String128)).assign (title);
-	if (units)
-		UString (info.units, str16BufferSize (String128)).assign (units);
-	if (shortTitle)
-		UString (info.shortTitle, str16BufferSize (String128)).assign (shortTitle);
-
-	info.stepCount = -1;
-	info.defaultNormalizedValue = 0;
-	info.flags = flags;
-	info.id = tag;
-	info.unitId = unitID;
-}
-
-//------------------------------------------------------------------------
-StringListParameter::~StringListParameter ()
-{
-	for (auto& string : strings)
-		std::free (string);
-}
-
-//------------------------------------------------------------------------
-void StringListParameter::appendString (const String128 string)
-{
-	int32 length = strlen16 (string);
-	TChar* buffer = (TChar*)std::malloc ((length + 1) * sizeof (TChar));
-	if (!buffer)
-		return;
-
-	memcpy (buffer, string, length * sizeof (TChar));
-	buffer[length] = 0;
-	strings.push_back (buffer);
-	info.stepCount++;
-}
-
-//------------------------------------------------------------------------
-bool StringListParameter::replaceString (int32 index, const String128 string)
-{
-	TChar* str = strings.at (index);
-	if (!str)
-		return false;
-
-	int32 length = strlen16 (string);
-	TChar* buffer = (TChar*)malloc ((length + 1) * sizeof (TChar));
-	if (!buffer)
-		return false;
-
-	memcpy (buffer, string, length * sizeof (TChar));
-	buffer[length] = 0;
-	strings[index] = buffer;
-	std::free (str);
-	return true;
-}
-
-//------------------------------------------------------------------------
-void StringListParameter::toString (ParamValue _valueNormalized, String128 string) const
-{
-	int32 index = (int32)toPlain (_valueNormalized);
-	if (const TChar* valueString = strings.at (index))
-	{
-		UString (string, str16BufferSize (String128)).assign (valueString);
-	}
-	else
-		string[0] = 0;
-}
-
-//------------------------------------------------------------------------
-bool StringListParameter::fromString (const TChar* string, ParamValue& _valueNormalized) const
-{
-	int32 index = 0;
-	for (auto it = strings.begin (), end = strings.end (); it != end; ++it, ++index)
-	{
-		if (strcmp16 (*it, string) == 0)
-		{
-			_valueNormalized = toNormalized ((ParamValue)index);
-			return true;
-		}
-	}
-	return false;
-}
-
-//------------------------------------------------------------------------
-ParamValue StringListParameter::toPlain (ParamValue _valueNormalized) const
-{
-	if (info.stepCount <= 0)
-		return 0;
-	return FromNormalized<ParamValue> (_valueNormalized, info.stepCount);
-}
-
-//------------------------------------------------------------------------
-ParamValue StringListParameter::toNormalized (ParamValue plainValue) const
-{
-	if (info.stepCount <= 0)
-		return 0;
-	return ToNormalized<ParamValue> (plainValue, info.stepCount);
-}
-
-//------------------------------------------------------------------------
-// ParameterContainer Implementation
-//------------------------------------------------------------------------
-ParameterContainer::ParameterContainer () : params (nullptr)
-{
-}
-
-//------------------------------------------------------------------------
-ParameterContainer::~ParameterContainer ()
-{
-	if (params)
-		delete params;
-}
-
-//------------------------------------------------------------------------
-void ParameterContainer::init (int32 initialSize, int32 /*resizeDelta*/)
-{
-	if (!params)
-	{
-		params = new ParameterPtrVector;
-		if (initialSize > 0)
-			params->reserve (initialSize);
-	}
-}
-
-//------------------------------------------------------------------------
-Parameter* ParameterContainer::addParameter (Parameter* p)
-{
-	if (!params)
-		init ();
-	id2index[p->getInfo ().id] = params->size ();
-	params->push_back (IPtr<Parameter> (p, false));
-	return p;
-}
-
-//------------------------------------------------------------------------
-Parameter* ParameterContainer::addParameter (const ParameterInfo& info)
-{
-	if (!params)
-		init ();
-	auto* p = new Parameter (info);
-	if (addParameter (p))
-		return p;
-	p->release ();
-	return nullptr;
-}
-
-//------------------------------------------------------------------------
-Parameter* ParameterContainer::getParameter (ParamID tag) const
-{
-	if (params)
-	{
-		auto it = id2index.find (tag);
-		if (it != id2index.end ())
-			return params->at (it->second);
-	}
-	return nullptr;
-}
-
-//------------------------------------------------------------------------
-bool ParameterContainer::removeParameter (ParamID tag)
-{
-	if (!params)
-		return false;
-	
-	IndexMap::const_iterator it = id2index.find (tag);
-	if (it != id2index.end ())
-	{
-		params->erase (params->begin () + it->second);
-		id2index.erase (it);
-	}
-	return false;
-}
-
-//------------------------------------------------------------------------
-Parameter* ParameterContainer::addParameter (const TChar* title, const TChar* units,
-                                             int32 stepCount, ParamValue defaultNormalizedValue,
-                                             int32 flags, int32 tag, UnitID unitID, const TChar* shortTitle)
-{
-	if (!title)
-	{
-		return nullptr;
-	}
-
-	ParameterInfo info = {};
-
-	UString (info.title, str16BufferSize (String128)).assign (title);
-	if (units)
-		UString (info.units, str16BufferSize (String128)).assign (units);
-	if (shortTitle)
-		UString (info.shortTitle, str16BufferSize (String128)).assign (shortTitle);
-
-	info.stepCount = stepCount;
-	info.defaultNormalizedValue = defaultNormalizedValue;
-	info.flags = flags;
-	info.id = (tag >= 0) ? tag : getParameterCount ();
-	info.unitId = unitID;
-
-	return addParameter (info);
-}
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/source/vst/vstparameters.h

@@ -1,240 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/vstparameters.h
-// Created by  : Steinberg, 03/2008
-// Description : VST Parameter Implementation
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "base/source/fobject.h"
-#include "pluginterfaces/vst/ivsteditcontroller.h"
-#include "pluginterfaces/vst/ivstunits.h"
-
-#include <map>
-#include <vector>
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-/** Description of a Parameter.
-\ingroup vstClasses
-*/
-class Parameter : public FObject
-{
-public:
-//------------------------------------------------------------------------
-	Parameter ();
-	Parameter (const ParameterInfo&);
-	Parameter (const TChar* title, ParamID tag, const TChar* units = nullptr,
-	           ParamValue defaultValueNormalized = 0., int32 stepCount = 0,
-	           int32 flags = ParameterInfo::kCanAutomate, UnitID unitID = kRootUnitId,
-               const TChar* shortTitle = nullptr);
-	~Parameter () override;
-
-	/** Returns its read only info. */
-	virtual const ParameterInfo& getInfo () const { return info; }
-
-	/** Returns its writable info. */
-	virtual ParameterInfo& getInfo () { return info; }
-
-	/** Sets its associated UnitId. */
-	virtual void setUnitID (UnitID id) { info.unitId = id; }
-	/** Gets its associated UnitId. */
-	virtual UnitID getUnitID () { return info.unitId; }
-
-	/** Gets its normalized value [0.0, 1.0]. */
-	ParamValue getNormalized () const { return valueNormalized; }
-	/** Sets its normalized value [0.0, 1.0]. */
-	virtual bool setNormalized (ParamValue v);
-
-	/** Converts a normalized value to a string. */
-	virtual void toString (ParamValue valueNormalized, String128 string) const;
-	/** Converts a string to a normalized value. */
-	virtual bool fromString (const TChar* string, ParamValue& valueNormalized) const;
-
-	/** Converts a normalized value to plain value (e.g. 0.5 to 10000.0Hz). */
-	virtual ParamValue toPlain (ParamValue valueNormalized) const;
-	/** Converts a plain value to a normalized value (e.g. 10000 to 0.5). */
-	virtual ParamValue toNormalized (ParamValue plainValue) const;
-
-	/** Gets the current precision (used for string representation of float). */
-	virtual int32 getPrecision () const { return precision; }
-	/** Sets the precision for string representation of float value (for example 4.34 with 2 as
-	 * precision). */
-	virtual void setPrecision (int32 val) { precision = val; }
-
-	OBJ_METHODS (Parameter, FObject)
-//------------------------------------------------------------------------
-protected:
-	ParameterInfo info;
-	ParamValue valueNormalized;
-	int32 precision;
-};
-
-//------------------------------------------------------------------------
-/** Description of a RangeParameter.
-\ingroup vstClasses 
-*/
-class RangeParameter : public Parameter
-{
-public:
-//------------------------------------------------------------------------
-	RangeParameter (const ParameterInfo& paramInfo, ParamValue min, ParamValue max);
-	RangeParameter (const TChar* title, ParamID tag, const TChar* units = nullptr,
-	                ParamValue minPlain = 0., ParamValue maxPlain = 1.,
-	                ParamValue defaultValuePlain = 0., int32 stepCount = 0,
-	                int32 flags = ParameterInfo::kCanAutomate, UnitID unitID = kRootUnitId,
-                    const TChar* shortTitle = nullptr);
-
-	/** Gets the minimum plain value, same as toPlain (0). */
-	virtual ParamValue getMin () const { return minPlain; }
-	/** Sets the minimum plain value. */
-	virtual void setMin (ParamValue value) { minPlain = value; }
-	/** Gets the maximum plain value, same as toPlain (1). */
-	virtual ParamValue getMax () const { return maxPlain; }
-	/** Sets the maximum plain value. */
-	virtual void setMax (ParamValue value) { maxPlain = value; }
-
-	/** Converts a normalized value to a string. */
-	void toString (ParamValue _valueNormalized, String128 string) const SMTG_OVERRIDE;
-	/** Converts a string to a normalized value. */
-	bool fromString (const TChar* string, ParamValue& _valueNormalized) const SMTG_OVERRIDE;
-
-	/** Converts a normalized value to plain value (e.g. 0.5 to 10000.0Hz). */
-	ParamValue toPlain (ParamValue _valueNormalized) const SMTG_OVERRIDE;
-	/** Converts a plain value to a normalized value (e.g. 10000 to 0.5). */
-	ParamValue toNormalized (ParamValue plainValue) const SMTG_OVERRIDE;
-
-	OBJ_METHODS (RangeParameter, Parameter)
-//------------------------------------------------------------------------
-protected:
-	RangeParameter ();
-
-	ParamValue minPlain;
-	ParamValue maxPlain;
-};
-
-//------------------------------------------------------------------------
-/** Description of a StringListParameter.
-\ingroup vstClasses
-*/
-class StringListParameter : public Parameter
-{
-public:
-//------------------------------------------------------------------------
-	StringListParameter (const ParameterInfo& paramInfo);
-	StringListParameter (const TChar* title, ParamID tag, const TChar* units = nullptr,
-	                     int32 flags = ParameterInfo::kCanAutomate | ParameterInfo::kIsList,
-	                     UnitID unitID = kRootUnitId, const TChar* shortTitle= nullptr);
-	~StringListParameter () override;
-
-	/** Appends a string and increases the stepCount. */
-	virtual void appendString (const String128 string);
-	/** Replaces the string at index. Index must be between 0 and stepCount+1 */
-	virtual bool replaceString (int32 index, const String128 string);
-
-	/** Converts a normalized value to a string. */
-	void toString (ParamValue _valueNormalized, String128 string) const SMTG_OVERRIDE;
-	/** Converts a string to a normalized value. */
-	bool fromString (const TChar* string, ParamValue& _valueNormalized) const SMTG_OVERRIDE;
-
-	/** Converts a normalized value to plain value (e.g. 0.5 to 10000.0Hz). */
-	ParamValue toPlain (ParamValue _valueNormalized) const SMTG_OVERRIDE;
-	/** Converts a plain value to a normalized value (e.g. 10000 to 0.5). */
-	ParamValue toNormalized (ParamValue plainValue) const SMTG_OVERRIDE;
-
-	OBJ_METHODS (StringListParameter, Parameter)
-//------------------------------------------------------------------------
-protected:
-	using StringVector = std::vector<TChar*>;
-	StringVector strings;
-};
-
-//------------------------------------------------------------------------
-/** Collection of parameters.
-\ingroup vstClasses
-*/
-class ParameterContainer
-{
-public:
-//------------------------------------------------------------------------
-	ParameterContainer ();
-	~ParameterContainer ();
-
-	/** Init param array. */
-	void init (int32 initialSize = 10, int32 resizeDelta = 100);
-
-	/** Creates and adds a new parameter from a ParameterInfo. */
-	Parameter* addParameter (const ParameterInfo& info);
-
-	/** Creates and adds a new parameter with given properties. */
-	Parameter* addParameter (const TChar* title, const TChar* units = nullptr, int32 stepCount = 0,
-	                         ParamValue defaultValueNormalized = 0.,
-	                         int32 flags = ParameterInfo::kCanAutomate, int32 tag = -1,
-	                         UnitID unitID = kRootUnitId, const TChar* shortTitle = nullptr);
-
-	/** Adds a given parameter. */
-	Parameter* addParameter (Parameter* p);
-
-	/** Returns the count of parameters. */
-	int32 getParameterCount () const { return params ? static_cast<int32> (params->size ()) : 0; }
-
-	/** Gets parameter by index. */
-	Parameter* getParameterByIndex (int32 index) const { return params ? params->at (index) : nullptr; }
-
-	/** Removes all parameters. */
-	void removeAll ()
-	{
-		if (params)
-			params->clear ();
-		id2index.clear ();
-	}
-
-	/** Gets parameter by ID. */
-	Parameter* getParameter (ParamID tag) const;
-
-	/** Remove a specific parameter by ID. */
-	bool removeParameter (ParamID tag);
-	//------------------------------------------------------------------------
-protected:
-	using ParameterPtrVector = std::vector<IPtr<Parameter>>;
-	using IndexMap = std::map<ParamID, ParameterPtrVector::size_type>;
-	ParameterPtrVector* params;
-	IndexMap id2index;
-};
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/source/vst/vstpresetfile.cpp

@@ -1,935 +0,0 @@
-//------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/vstpresetfile.cpp
-// Created by  : Steinberg, 03/2006
-// Description : VST 3 Preset File Format
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#include "vstpresetfile.h"
-
-#include <algorithm>
-
-
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-// Preset Chunk IDs
-//------------------------------------------------------------------------
-static const ChunkID commonChunks[kNumPresetChunks] = {
-	{'V', 'S', 'T', '3'},	// kHeader
-	{'C', 'o', 'm', 'p'},	// kComponentState
-	{'C', 'o', 'n', 't'},	// kControllerState
-	{'P', 'r', 'o', 'g'},	// kProgramData
-	{'I', 'n', 'f', 'o'},	// kMetaInfo
-	{'L', 'i', 's', 't'}	// kChunkList
-};
-
-//------------------------------------------------------------------------
-// Preset Header: header id + version + class id + list offset
-static const int32 kFormatVersion = 1;
-static const int32 kClassIDSize = 32; // ASCII-encoded FUID
-static const int32 kHeaderSize = sizeof (ChunkID) + sizeof (int32) + kClassIDSize + sizeof (TSize);
-static const int32 kListOffsetPos = kHeaderSize - sizeof (TSize);
-
-//------------------------------------------------------------------------
-const ChunkID& getChunkID (ChunkType type)
-{
-	return commonChunks[type];
-}
-
-#ifdef verify
-#undef verify
-#endif
-
-//------------------------------------------------------------------------
-inline bool verify (tresult result)
-{
-	return result == kResultOk || result == kNotImplemented;
-}
-
-//------------------------------------------------------------------------
-bool copyStream (IBStream* inStream, IBStream* outStream)
-{
-	if (!inStream || !outStream)
-		return false;
-
-	int8 buffer[8192];
-	int32 read = 0;
-	int32 written = 0;
-	while (inStream->read (buffer, 8192, &read) == kResultTrue && read > 0)
-	{
-		if (outStream->write (buffer, read, &written) != kResultTrue)
-		{
-			return false;
-		}
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-// PresetFile
-//------------------------------------------------------------------------
-bool PresetFile::savePreset (IBStream* stream, const FUID& classID, IComponent* component,
-                             IEditController* editController, const char* xmlBuffer, int32 xmlSize)
-{
-	PresetFile pf (stream);
-	pf.setClassID (classID);
-	if (!pf.writeHeader ())
-		return false;
-
-	if (!pf.storeComponentState (component))
-		return false;
-
-	if (editController && !pf.storeControllerState (editController))
-		return false;
-
-	if (xmlBuffer && !pf.writeMetaInfo (xmlBuffer, xmlSize))
-		return false;
-
-	return pf.writeChunkList ();
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::savePreset (IBStream* stream, const FUID& classID, IBStream* componentStream,
-                             IBStream* editStream, const char* xmlBuffer, int32 xmlSize)
-{
-	PresetFile pf (stream);
-	pf.setClassID (classID);
-	if (!pf.writeHeader ())
-		return false;
-
-	if (!pf.storeComponentState (componentStream))
-		return false;
-
-	if (editStream && !pf.storeControllerState (editStream))
-		return false;
-
-	if (xmlBuffer && !pf.writeMetaInfo (xmlBuffer, xmlSize))
-		return false;
-
-	return pf.writeChunkList ();
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::loadPreset (IBStream* stream, const FUID& classID, IComponent* component,
-                             IEditController* editController, std::vector<FUID>* otherClassIDArray)
-{
-	PresetFile pf (stream);
-	if (!pf.readChunkList ())
-		return false;
-
-	if (pf.getClassID () != classID)
-	{
-		if (otherClassIDArray)
-		{
-			// continue to load only if found in supported ID else abort load
-			if (std::find (otherClassIDArray->begin (), otherClassIDArray->end (),
-			               pf.getClassID ()) == otherClassIDArray->end ())
-				return false;
-		}
-		else
-			return false;
-	}
-
-	if (!pf.restoreComponentState (component))
-		return false;
-
-	if (editController)
-	{
-		// assign component state to controller
-		if (!pf.restoreComponentState (editController))
-			return false;
-
-		// restore controller-only state (if present)
-		if (pf.contains (kControllerState) && !pf.restoreControllerState (editController))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-PresetFile::PresetFile (IBStream* stream) : stream (stream), entryCount (0)
-{
-	memset (entries, 0, sizeof (entries));
-
-	if (stream)
-		stream->addRef ();
-}
-
-//------------------------------------------------------------------------
-PresetFile::~PresetFile ()
-{
-	if (stream)
-		stream->release ();
-}
-
-//------------------------------------------------------------------------
-const PresetFile::Entry* PresetFile::getEntry (ChunkType which) const
-{
-	const ChunkID& id = getChunkID (which);
-	for (int32 i = 0; i < entryCount; i++)
-		if (isEqualID (entries[i].id, id))
-			return &entries[i];
-	return nullptr;
-}
-
-//------------------------------------------------------------------------
-const PresetFile::Entry* PresetFile::getLastEntry () const
-{
-	return entryCount > 0 ? &entries[entryCount - 1] : nullptr;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::readID (ChunkID id)
-{
-	int32 numBytesRead = 0;
-	stream->read (id, sizeof (ChunkID), &numBytesRead);
-	return numBytesRead == sizeof (ChunkID);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::writeID (const ChunkID id)
-{
-	int32 numBytesWritten = 0;
-	stream->write ((void*)id, sizeof (ChunkID), &numBytesWritten);
-	return numBytesWritten == sizeof (ChunkID);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::readEqualID (const ChunkID id)
-{
-	ChunkID temp = {0};
-	return readID (temp) && isEqualID (temp, id);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::readSize (TSize& size)
-{
-	int32 numBytesRead = 0;
-	stream->read (&size, sizeof (TSize), &numBytesRead);
-#if BYTEORDER == kBigEndian
-	SWAP_64 (size)
-#endif
-	return numBytesRead == sizeof (TSize);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::writeSize (TSize size)
-{
-#if BYTEORDER == kBigEndian
-	SWAP_64 (size)
-#endif
-	int32 numBytesWritten = 0;
-	stream->write (&size, sizeof (TSize), &numBytesWritten);
-	return numBytesWritten == sizeof (TSize);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::readInt32 (int32& value)
-{
-	int32 numBytesRead = 0;
-	stream->read (&value, sizeof (int32), &numBytesRead);
-#if BYTEORDER == kBigEndian
-	SWAP_32 (value)
-#endif
-	return numBytesRead == sizeof (int32);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::writeInt32 (int32 value)
-{
-#if BYTEORDER == kBigEndian
-	SWAP_32 (value)
-#endif
-	int32 numBytesWritten = 0;
-	stream->write (&value, sizeof (int32), &numBytesWritten);
-	return numBytesWritten == sizeof (int32);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::seekTo (TSize offset)
-{
-	int64 result = -1;
-	stream->seek (offset, IBStream::kIBSeekSet, &result);
-	return result == offset;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::readChunkList ()
-{
-	seekTo (0);
-	entryCount = 0;
-
-	char8 classString[kClassIDSize + 1] = {0};
-
-	// Read header
-	int32 version = 0;
-	TSize listOffset = 0;
-	if (!(readEqualID (getChunkID (kHeader)) && readInt32 (version) &&
-	      verify (stream->read (classString, kClassIDSize)) && readSize (listOffset) &&
-	      listOffset > 0 && seekTo (listOffset)))
-		return false;
-
-	classID.fromString (classString);
-
-	// Read list
-	int32 count = 0;
-	if (!readEqualID (getChunkID (kChunkList)))
-		return false;
-	if (!readInt32 (count))
-		return false;
-
-	if (count > kMaxEntries)
-		count = kMaxEntries;
-
-	for (int32 i = 0; i < count; i++)
-	{
-		Entry& e = entries[i];
-		if (!(readID (e.id) && readSize (e.offset) && readSize (e.size)))
-			break;
-
-		entryCount++;
-	}
-
-	return entryCount > 0;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::writeHeader ()
-{
-	// header id + version + class id + list offset (unknown yet)
-
-	char8 classString[kClassIDSize + 1] = {0};
-	classID.toString (classString);
-
-	return seekTo (0) && writeID (getChunkID (kHeader)) && writeInt32 (kFormatVersion) &&
-	       verify (stream->write (classString, kClassIDSize)) && writeSize (0);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::writeChunkList ()
-{
-	// Update list offset
-	TSize pos = 0;
-	stream->tell (&pos);
-	if (!(seekTo (kListOffsetPos) && writeSize (pos) && seekTo (pos)))
-		return false;
-
-	// Write list
-	if (!writeID (getChunkID (kChunkList)))
-		return false;
-	if (!writeInt32 (entryCount))
-		return false;
-
-	for (int32 i = 0; i < entryCount; i++)
-	{
-		Entry& e = entries[i];
-		if (!(writeID (e.id) && writeSize (e.offset) && writeSize (e.size)))
-			return false;
-	}
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::beginChunk (Entry& e, ChunkType which)
-{
-	if (entryCount >= kMaxEntries)
-		return false;
-
-	const ChunkID& id = getChunkID (which);
-	memcpy (e.id, &id, sizeof (ChunkID));
-	stream->tell (&e.offset);
-	e.size = 0;
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::endChunk (Entry& e)
-{
-	if (entryCount >= kMaxEntries)
-		return false;
-
-	TSize pos = 0;
-	stream->tell (&pos);
-	e.size = pos - e.offset;
-	entries[entryCount++] = e;
-	return true;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::readMetaInfo (char* xmlBuffer, int32& size)
-{
-	bool result = false;
-	const Entry* e = getEntry (kMetaInfo);
-	if (e)
-	{
-		if (xmlBuffer)
-		{
-			result = seekTo (e->offset) && verify (stream->read (xmlBuffer, size, &size));
-		}
-		else
-		{
-			size = (int32)e->size;
-			result = size > 0;
-		}
-	}
-	return result;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::writeMetaInfo (const char* xmlBuffer, int32 size, bool forceWriting)
-{
-	if (contains (kMetaInfo)) // already exists!
-	{
-		if (!forceWriting)
-			return false;
-	}
-	if (!prepareMetaInfoUpdate ())
-		return false;
-
-	if (size == -1)
-		size = (int32)strlen (xmlBuffer);
-
-	Entry e = {};
-	return beginChunk (e, kMetaInfo) && verify (stream->write ((void*)xmlBuffer, size)) &&
-	       endChunk (e);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::prepareMetaInfoUpdate ()
-{
-	TSize writePos = 0;
-	const Entry* e = getEntry (kMetaInfo);
-	if (e)
-	{
-		// meta info must be the last entry!
-		if (e != getLastEntry ())
-			return false;
-
-		writePos = e->offset;
-		entryCount--;
-	}
-	else
-	{
-		// entries must be sorted ascending by offset!
-		e = getLastEntry ();
-		writePos = e ? e->offset + e->size : kHeaderSize;
-	}
-
-	return seekTo (writePos);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::writeChunk (const void* data, int32 size, ChunkType which)
-{
-	if (contains (which)) // already exists!
-		return false;
-
-	Entry e = {};
-	return beginChunk (e, which) && verify (stream->write ((void*)data, size)) && endChunk (e);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::seekToComponentState ()
-{
-	const Entry* e = getEntry (kComponentState);
-	return e && seekTo (e->offset);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::storeComponentState (IComponent* component)
-{
-	if (contains (kComponentState)) // already exists!
-		return false;
-
-	Entry e = {};
-	return beginChunk (e, kComponentState) && verify (component->getState (stream)) && endChunk (e);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::storeComponentState (IBStream* componentStream)
-{
-	if (contains (kComponentState)) // already exists!
-		return false;
-
-	Entry e = {};
-	return beginChunk (e, kComponentState) && copyStream (componentStream, stream) && endChunk (e);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::restoreComponentState (IComponent* component)
-{
-	const Entry* e = getEntry (kComponentState);
-	if (e)
-	{
-		auto* readOnlyBStream = new ReadOnlyBStream (stream, e->offset, e->size);
-		FReleaser readOnlyBStreamReleaser (readOnlyBStream);
-		return verify (component->setState (readOnlyBStream));
-	}
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::restoreComponentState (IEditController* editController)
-{
-	const Entry* e = getEntry (kComponentState);
-	if (e)
-	{
-		auto* readOnlyBStream = new ReadOnlyBStream (stream, e->offset, e->size);
-		FReleaser readOnlyBStreamReleaser (readOnlyBStream);
-		return verify (editController->setComponentState (readOnlyBStream));
-	}
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::seekToControllerState ()
-{
-	const Entry* e = getEntry (kControllerState);
-	return e && seekTo (e->offset);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::storeControllerState (IEditController* editController)
-{
-	if (contains (kControllerState)) // already exists!
-		return false;
-
-	Entry e = {};
-	return beginChunk (e, kControllerState) && verify (editController->getState (stream)) &&
-	       endChunk (e);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::storeControllerState (IBStream* editStream)
-{
-	if (contains (kControllerState)) // already exists!
-		return false;
-
-	Entry e = {};
-	return beginChunk (e, kControllerState) && copyStream (editStream, stream) && endChunk (e);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::restoreControllerState (IEditController* editController)
-{
-	const Entry* e = getEntry (kControllerState);
-	if (e)
-	{
-		auto* readOnlyBStream = new ReadOnlyBStream (stream, e->offset, e->size);
-		FReleaser readOnlyBStreamReleaser (readOnlyBStream);
-		return verify (editController->setState (readOnlyBStream));
-	}
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::storeProgramData (IBStream* inStream, ProgramListID listID)
-{
-	if (contains (kProgramData)) // already exists!
-		return false;
-
-	writeHeader ();
-
-	Entry e = {};
-	if (beginChunk (e, kProgramData))
-	{
-		if (writeInt32 (listID))
-		{
-			if (!copyStream (inStream, stream))
-				return false;
-
-			return endChunk (e);
-		}
-	}
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::storeProgramData (IProgramListData* programListData, ProgramListID listID,
-                                   int32 programIndex)
-{
-	if (contains (kProgramData)) // already exists!
-		return false;
-
-	writeHeader ();
-
-	Entry e = {};
-	return beginChunk (e, kProgramData) && writeInt32 (listID) &&
-	       verify (programListData->getProgramData (listID, programIndex, stream)) && endChunk (e);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::restoreProgramData (IProgramListData* programListData,
-                                     ProgramListID* programListID, int32 programIndex)
-{
-	const Entry* e = getEntry (kProgramData);
-	ProgramListID savedProgramListID = -1;
-	if (e && seekTo (e->offset))
-	{
-		if (readInt32 (savedProgramListID))
-		{
-			if (programListID && *programListID != savedProgramListID)
-				return false;
-
-			int32 alreadyRead = sizeof (int32);
-			auto* readOnlyBStream =
-			    new ReadOnlyBStream (stream, e->offset + alreadyRead, e->size - alreadyRead);
-			FReleaser readOnlyBStreamReleaser (readOnlyBStream);
-			return programListData && verify (programListData->setProgramData (
-			                              savedProgramListID, programIndex, readOnlyBStream));
-		}
-	}
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::storeProgramData (IUnitData* unitData, UnitID unitID)
-{
-	if (contains (kProgramData)) // already exists!
-		return false;
-
-	writeHeader ();
-
-	Entry e = {};
-	return beginChunk (e, kProgramData) && writeInt32 (unitID) &&
-	       verify (unitData->getUnitData (unitID, stream)) && endChunk (e);
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::restoreProgramData (IUnitData* unitData, UnitID* unitId)
-{
-	const Entry* e = getEntry (kProgramData);
-	UnitID savedUnitID = -1;
-	if (e && seekTo (e->offset))
-	{
-		if (readInt32 (savedUnitID))
-		{
-			if (unitId && *unitId != savedUnitID)
-				return false;
-
-			int32 alreadyRead = sizeof (int32);
-			auto* readOnlyBStream =
-			    new ReadOnlyBStream (stream, e->offset + alreadyRead, e->size - alreadyRead);
-			FReleaser readOnlyStreamReleaser (readOnlyBStream);
-			return (unitData && verify (unitData->setUnitData (savedUnitID, readOnlyBStream)));
-		}
-	}
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::restoreProgramData (IUnitInfo* unitInfo, int32 unitProgramListID,
-                                     int32 programIndex)
-{
-	const Entry* e = getEntry (kProgramData);
-	int32 savedProgramListID = -1;
-	if (e && seekTo (e->offset))
-	{
-		if (readInt32 (savedProgramListID))
-		{
-			if (unitProgramListID != savedProgramListID)
-				return false;
-
-			int32 alreadyRead = sizeof (int32);
-			auto* readOnlyBStream =
-			    new ReadOnlyBStream (stream, e->offset + alreadyRead, e->size - alreadyRead);
-			FReleaser readOnlyStreamReleaser (readOnlyBStream);
-			return (unitInfo && unitInfo->setUnitProgramData (unitProgramListID, programIndex,
-			                                                  readOnlyBStream));
-		}
-	}
-	return false;
-}
-
-//------------------------------------------------------------------------
-bool PresetFile::getUnitProgramListID (int32& unitProgramListID)
-{
-	const Entry* e = getEntry (kProgramData);
-	if (e && seekTo (e->offset))
-	{
-		if (readInt32 (unitProgramListID))
-		{
-			return true;
-		}
-	}
-	return false;
-}
-
-//------------------------------------------------------------------------
-// FileStream implementation
-//------------------------------------------------------------------------
-IBStream* FileStream::open (const char* filename, const char* mode)
-{
-	FILE* file = fopen (filename, mode);
-	return file ? new FileStream (file) : nullptr;
-}
-
-//------------------------------------------------------------------------
-FileStream::FileStream (FILE* file)
-: file (file) {FUNKNOWN_CTOR}
-
-//------------------------------------------------------------------------
-FileStream::~FileStream ()
-{
-	fclose (file);
-	FUNKNOWN_DTOR
-}
-
-//------------------------------------------------------------------------
-IMPLEMENT_FUNKNOWN_METHODS (FileStream, IBStream, IBStream::iid)
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API FileStream::read (void* buffer, int32 numBytes, int32* numBytesRead)
-{
-	size_t result = fread (buffer, 1, static_cast<size_t> (numBytes), file);
-	if (numBytesRead)
-		*numBytesRead = (int32)result;
-	return static_cast<int32> (result) == numBytes ? kResultOk : kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API FileStream::write (void* buffer, int32 numBytes, int32* numBytesWritten)
-{
-	size_t result = fwrite (buffer, 1, static_cast<size_t> (numBytes), file);
-	if (numBytesWritten)
-		*numBytesWritten = (int32)result;
-	return static_cast<int32> (result) == numBytes ? kResultOk : kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API FileStream::seek (int64 pos, int32 mode, int64* result)
-{
-	if (fseek (file, (int32)pos, mode) == 0)
-	{
-		if (result)
-			*result = ftell (file);
-		return kResultOk;
-	}
-	return kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API FileStream::tell (int64* pos)
-{
-	if (pos)
-		*pos = ftell (file);
-	return kResultOk;
-}
-
-//------------------------------------------------------------------------
-// ReadOnlyBStream implementation
-//------------------------------------------------------------------------
-IMPLEMENT_REFCOUNT (ReadOnlyBStream)
-
-//------------------------------------------------------------------------
-ReadOnlyBStream::ReadOnlyBStream (IBStream* sourceStream, TSize sourceOffset, TSize sectionSize)
-: sourceStream (sourceStream)
-, sourceOffset (sourceOffset)
-, sectionSize (sectionSize)
-, seekPosition (0)
-{
-	FUNKNOWN_CTOR
-	if (sourceStream)
-		sourceStream->addRef ();
-}
-
-//------------------------------------------------------------------------
-ReadOnlyBStream::~ReadOnlyBStream ()
-{
-	if (sourceStream)
-		sourceStream->release ();
-
-	FUNKNOWN_DTOR
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API ReadOnlyBStream::queryInterface (const TUID _iid, void** obj)
-{
-	return sourceStream ? sourceStream->queryInterface (_iid, obj) : kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API ReadOnlyBStream::read (void* buffer, int32 numBytes, int32* numBytesRead)
-{
-	if (numBytesRead)
-		*numBytesRead = 0;
-
-	if (!sourceStream)
-		return kNotInitialized;
-
-	int32 maxBytesToRead = (int32) (sectionSize - seekPosition);
-	if (numBytes > maxBytesToRead)
-		numBytes = maxBytesToRead;
-	if (numBytes <= 0)
-		return kResultOk;
-
-	tresult result = sourceStream->seek (sourceOffset + seekPosition, kIBSeekSet);
-	if (result != kResultOk)
-		return result;
-
-	int32 numRead = 0;
-	result = sourceStream->read (buffer, numBytes, &numRead);
-
-	if (numRead > 0)
-		seekPosition += numRead;
-	if (numBytesRead)
-		*numBytesRead = numRead;
-
-	return result;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API ReadOnlyBStream::write (void* /*buffer*/, int32 /*numBytes*/,
-                                           int32* numBytesWritten)
-{
-	if (numBytesWritten)
-		*numBytesWritten = 0;
-
-	return kNotImplemented;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API ReadOnlyBStream::seek (int64 pos, int32 mode, int64* result)
-{
-	switch (mode)
-	{
-		case kIBSeekSet: seekPosition = pos; break;
-
-		case kIBSeekCur: seekPosition += pos; break;
-
-		case kIBSeekEnd: seekPosition = sectionSize + pos; break;
-	}
-
-	if (seekPosition < 0)
-		seekPosition = 0;
-	if (seekPosition > sectionSize)
-		seekPosition = sectionSize;
-
-	if (result)
-		*result = seekPosition;
-	return kResultOk;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API ReadOnlyBStream::tell (int64* pos)
-{
-	if (pos)
-		*pos = seekPosition;
-	return kResultOk;
-}
-
-//------------------------------------------------------------------------
-// BufferStream implementation
-//------------------------------------------------------------------------
-IMPLEMENT_FUNKNOWN_METHODS (BufferStream, IBStream, IBStream::iid)
-
-//------------------------------------------------------------------------
-BufferStream::BufferStream () {FUNKNOWN_CTOR}
-
-//------------------------------------------------------------------------
-BufferStream::~BufferStream () {FUNKNOWN_DTOR}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API BufferStream::read (void* buffer, int32 numBytes, int32* numBytesRead)
-{
-	uint32 size = mBuffer.get (buffer, static_cast<uint32> (numBytes));
-	if (numBytesRead)
-		*numBytesRead = static_cast<int32> (size);
-
-	return kResultTrue;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API BufferStream::write (void* buffer, int32 numBytes, int32* numBytesWritten)
-{
-	bool res = mBuffer.put (buffer, static_cast<uint32> (numBytes));
-	if (numBytesWritten)
-		*numBytesWritten = res ? numBytes : 0;
-
-	return res ? kResultTrue : kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API BufferStream::seek (int64 pos, int32 mode, int64* result)
-{
-	bool res = false;
-	switch (mode)
-	{
-		//--- -----------------
-		case IBStream::kIBSeekSet:
-		{
-			int64 tmp = pos;
-			if (tmp < 0)
-				tmp = 0;
-			res = mBuffer.setFillSize (static_cast<uint32> (tmp));
-		}
-		break;
-
-		//--- -----------------
-		case IBStream::kIBSeekCur:
-		{
-			int64 tmp = mBuffer.getFillSize () + pos;
-			if (tmp < 0)
-				tmp = 0;
-			res = mBuffer.setFillSize (static_cast<uint32> (tmp));
-		}
-		break;
-
-		//--- -----------------
-		case IBStream::kIBSeekEnd:
-		{
-			int64 tmp = mBuffer.getSize () - pos;
-			if (tmp < 0)
-				tmp = 0;
-			res = mBuffer.setFillSize (static_cast<uint32> (tmp));
-		}
-		break;
-	}
-	if (res && result)
-		*result = mBuffer.getFillSize ();
-
-	return res ? kResultTrue : kResultFalse;
-}
-
-//------------------------------------------------------------------------
-tresult PLUGIN_API BufferStream::tell (int64* pos)
-{
-	if (pos)
-		*pos = mBuffer.getFillSize ();
-	return pos ? kResultTrue : kResultFalse;
-}
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg

source/includes/vst3sdk/public.sdk/source/vst/vstpresetfile.h

@@ -1,306 +0,0 @@
-//-----------------------------------------------------------------------------
-// Project     : VST SDK
-//
-// Category    : Helpers
-// Filename    : public.sdk/source/vst/vstpresetfile.h
-// Created by  : Steinberg, 03/2006
-// Description : VST 3 Preset File Format
-//
-//-----------------------------------------------------------------------------
-// LICENSE
-// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
-//-----------------------------------------------------------------------------
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-// 
-//   * Redistributions of source code must retain the above copyright notice, 
-//     this list of conditions and the following disclaimer.
-//   * Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation 
-//     and/or other materials provided with the distribution.
-//   * Neither the name of the Steinberg Media Technologies nor the names of its
-//     contributors may be used to endorse or promote products derived from this 
-//     software without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include "pluginterfaces/vst/ivstcomponent.h"
-#include "pluginterfaces/vst/ivsteditcontroller.h"
-#include "pluginterfaces/vst/ivstunits.h"
-
-#include "pluginterfaces/base/ibstream.h"
-#include "base/source/fbuffer.h"
-
-#include <cstdio>
-#include <vector>
-
-//------------------------------------------------------------------------
-/* 
-	VST 3 Preset File Format Definition
-   ===================================
-
-0   +---------------------------+
-    | HEADER                    |
-    | header id ('VST3')        |       4 Bytes
-    | version                   |       4 Bytes (int32)
-    | ASCII-encoded class id    |       32 Bytes 
- +--| offset to chunk list      |       8 Bytes (int64)
- |  +---------------------------+
- |  | DATA AREA                 |<-+
- |  | data of chunks 1..n       |  |
- |  ...                       ...  |
- |  |                           |  |
- +->+---------------------------+  |
-    | CHUNK LIST                |  |
-    | list id ('List')          |  |    4 Bytes
-    | entry count               |  |    4 Bytes (int32)
-    +---------------------------+  |
-    |  1..n                     |  |
-    |  +----------------------+ |  |
-    |  | chunk id             | |  |    4 Bytes
-    |  | offset to chunk data |----+    8 Bytes (int64)
-    |  | size of chunk data   | |       8 Bytes (int64)
-    |  +----------------------+ |
-EOF +---------------------------+
-*/
-
-//------------------------------------------------------------------------
-namespace Steinberg {
-namespace Vst {
-
-//------------------------------------------------------------------------
-using ChunkID = char[4];
-
-//------------------------------------------------------------------------
-enum ChunkType
-{
-	kHeader,
-	kComponentState,
-	kControllerState,
-	kProgramData,
-	kMetaInfo,
-	kChunkList,
-	kNumPresetChunks
-};
-
-//------------------------------------------------------------------------
-extern const ChunkID& getChunkID (ChunkType type);
-
-//------------------------------------------------------------------------
-inline bool isEqualID (const ChunkID id1, const ChunkID id2)
-{
-	return memcmp (id1, id2, sizeof (ChunkID)) == 0;
-}
-
-//------------------------------------------------------------------------
-/** Handler for a VST 3 Preset File.
-\ingroup vstClasses
-\see \ref presetformat
-*/
-class PresetFile
-{
-public:
-//------------------------------------------------------------------------
-	PresetFile (IBStream* stream); ///< Constructor of Preset file based on a stream
-	virtual ~PresetFile ();
-
-	/** Internal structure used for chunk handling */
-	struct Entry
-	{
-		ChunkID id;
-		TSize offset;
-		TSize size;
-	};
-
-	IBStream* getStream () { return stream; }			///< Returns the associated stream.
-
-	const FUID& getClassID () const { return classID; }	///< Returns the associated classID (component ID: Processor part (not the controller!)).
-	void setClassID (const FUID& uid) { classID = uid; }///< Sets the associated classID (component ID: Processor part (not the controller!)).
-
-	const Entry* getEntry (ChunkType which) const;		///< Returns an entry for a given chunk type.
-	const Entry* getLastEntry () const;					///< Returns the last available entry.
-	int32 getEntryCount () const { return entryCount; }	///< Returns the number of total entries in the current stream.
-	const Entry& at (int32 index) const { return entries[index]; }	///< Returns the entry at a given position.
-	bool contains (ChunkType which) const { return getEntry (which) != nullptr; }	///< Checks if a given chunk type exist in the stream.
-
-	bool readChunkList ();		///< Reads and build the chunk list (including the header chunk).
-	bool writeHeader ();		///< Writes into the stream the main header.
-	bool writeChunkList ();		///< Writes into the stream the chunk list (should be at the end).
-
-	/** Reads the meta XML info and its size, the size could be retrieved by passing zero as xmlBuffer. */
-	bool readMetaInfo (char* xmlBuffer, int32& size);
-
-	/** Writes the meta XML info, -1 means null-terminated, forceWriting to true will force to rewrite the XML Info when the chunk already exists. */
-	bool writeMetaInfo (const char* xmlBuffer, int32 size = -1, bool forceWriting = false); 
-	bool prepareMetaInfoUpdate ();	///< checks if meta info chunk is the last one and jump to correct position.
-
-	/** Writes a given data of a given size as "which" chunk type. */
-	bool writeChunk (const void* data, int32 size, ChunkType which = kComponentState);
-
-	//-------------------------------------------------------------
-	// for storing and restoring the whole plug-in state (component and controller states)
-	bool seekToComponentState ();							///< Seeks to the begin of the Component State.
-	bool storeComponentState (IComponent* component);		///< Stores the component state (only one time).
-	bool storeComponentState (IBStream* componentStream);	///< Stores the component state from stream (only one time).
-	bool restoreComponentState (IComponent* component);		///< Restores the component state.
-
-	bool seekToControllerState ();							///< Seeks to the begin of the Controller State.
-	bool storeControllerState (IEditController* editController);///< Stores the controller state (only one time).
-	bool storeControllerState (IBStream* editStream);			///< Stores the controller state from stream (only one time).
-	bool restoreControllerState (IEditController* editController);///< Restores the controller state.
-
-	bool restoreComponentState (IEditController* editController);///< Restores the component state and apply it to the controller.
-
-	//--- ----------------------------------------------------------
-	/** Store program data or unit data from stream (including the header chunk).
-	 \param inStream 
-	 \param listID could be ProgramListID or UnitID. */
-	bool storeProgramData (IBStream* inStream, ProgramListID listID);
-
-	//---when plug-in uses IProgramListData-----------------------
-	/** Stores a IProgramListData with a given identifier and index (including the header chunk). */
-	bool storeProgramData (IProgramListData* programListData, ProgramListID programListID,
-	                       int32 programIndex);
-	/** Restores a IProgramListData with a given identifier and index. */
-	bool restoreProgramData (IProgramListData* programListData, ProgramListID* programListID = nullptr,
-	                         int32 programIndex = 0);
-
-	//---when plug-in uses IUnitData------------------------------
-	/** Stores a IUnitData with a given unitID (including the header chunk). */
-	bool storeProgramData (IUnitData* unitData, UnitID unitID);
-	/** Restores a IUnitData with a given unitID (optional). */
-	bool restoreProgramData (IUnitData* unitData, UnitID* unitID = nullptr);
-
-	//--- ----------------------------------------------------------
-	/** for keeping the controller part in sync concerning preset data stream, unitProgramListID
-	 * could be ProgramListID or UnitID. */
-	bool restoreProgramData (IUnitInfo* unitInfo, int32 unitProgramListID, int32 programIndex = -1);
-
-	/** Gets the unitProgramListID saved in the kProgramData chunk (if available). */
-	bool getUnitProgramListID (int32& unitProgramListID);
-
-	//--- ---------------------------------------------------------------------
-	/** Shortcut helper to create preset from component/controller state. classID is the FUID of the
-	 * component (processor) part. */
-	static bool savePreset (IBStream* stream, const FUID& classID, IComponent* component,
-	                        IEditController* editController = nullptr,
-	                        const char* xmlBuffer = nullptr, int32 xmlSize = -1);
-	static bool savePreset (IBStream* stream, const FUID& classID, IBStream* componentStream,
-	                        IBStream* editStream = nullptr, const char* xmlBuffer = nullptr,
-	                        int32 xmlSize = -1);
-
-	/** Shortcut helper to load preset with component/controller state. classID is the FUID of the
-	 * component (processor) part. */
-	static bool loadPreset (IBStream* stream, const FUID& classID, IComponent* component,
-	                        IEditController* editController = nullptr,
-	                        std::vector<FUID>* otherClassIDArray = nullptr);
-//------------------------------------------------------------------------
-protected:
-	bool readID (ChunkID id);
-	bool writeID (const ChunkID id);
-	bool readEqualID (const ChunkID id);
-	bool readSize (TSize& size);
-	bool writeSize (TSize size);
-	bool readInt32 (int32& value);
-	bool writeInt32 (int32 value);
-	bool seekTo (TSize offset);
-	bool beginChunk (Entry& e, ChunkType which);
-	bool endChunk (Entry& e);
-
-	IBStream* stream;
-	FUID classID;		///< classID is the FUID of the component (processor) part
-	enum { kMaxEntries = 128 };
-	Entry entries[kMaxEntries];
-	int32 entryCount;
-};
-
-//------------------------------------------------------------------------
-/** Stream implementation for a file using stdio. 
-*/
-class FileStream: public IBStream
-{
-public:
-//------------------------------------------------------------------------
-	static IBStream* open (const char* filename, const char* mode);	///< open a stream using stdio function
-
-	//---from FUnknown------------------
-	DECLARE_FUNKNOWN_METHODS
-
-	//---from IBStream------------------
-	tresult PLUGIN_API read (void* buffer, int32 numBytes, int32* numBytesRead = nullptr) SMTG_OVERRIDE;
-	tresult PLUGIN_API write (void* buffer, int32 numBytes, int32* numBytesWritten = nullptr) SMTG_OVERRIDE;
-	tresult PLUGIN_API seek (int64 pos, int32 mode, int64* result = nullptr) SMTG_OVERRIDE;
-	tresult PLUGIN_API tell (int64* pos) SMTG_OVERRIDE;
-
-//------------------------------------------------------------------------
-protected:
-	FileStream (FILE* file);
-	virtual ~FileStream ();
-
-	FILE* file;
-};
-
-//------------------------------------------------------------------------
-/** Stream representing a Read-Only subsection of its source stream.
-*/
-class ReadOnlyBStream: public IBStream
-{
-public:
-//------------------------------------------------------------------------
-	 ReadOnlyBStream (IBStream* sourceStream, TSize sourceOffset, TSize sectionSize);
-	 virtual ~ReadOnlyBStream ();
-	 
-	 //---from FUnknown------------------
-	 DECLARE_FUNKNOWN_METHODS
-
-	 //---from IBStream------------------
-	 tresult PLUGIN_API read (void* buffer, int32 numBytes, int32* numBytesRead = nullptr) SMTG_OVERRIDE;
-	 tresult PLUGIN_API write (void* buffer, int32 numBytes, int32* numBytesWritten = nullptr) SMTG_OVERRIDE;
-	 tresult PLUGIN_API seek (int64 pos, int32 mode, int64* result = nullptr) SMTG_OVERRIDE;
-	 tresult PLUGIN_API tell (int64* pos) SMTG_OVERRIDE;
-
-//------------------------------------------------------------------------
-protected:
-	 IBStream* sourceStream;
-	 TSize sourceOffset;
-	 TSize sectionSize;
-	 TSize seekPosition;
-};
-
-//------------------------------------------------------------------------
-/** Stream implementation for a memory buffer. 
-*/
-class BufferStream : public IBStream
-{
-public:
-	BufferStream ();
-	virtual ~BufferStream ();
-
-	//---from FUnknown------------------
-	DECLARE_FUNKNOWN_METHODS
-
-	//---from IBStream------------------
-	tresult PLUGIN_API read (void* buffer, int32 numBytes, int32* numBytesRead = nullptr) SMTG_OVERRIDE;
-	tresult PLUGIN_API write (void* buffer, int32 numBytes, int32* numBytesWritten = nullptr) SMTG_OVERRIDE;
-	tresult PLUGIN_API seek (int64 pos, int32 mode, int64* result = nullptr) SMTG_OVERRIDE;
-	tresult PLUGIN_API tell (int64* pos) SMTG_OVERRIDE;
-
-protected:
-	Buffer mBuffer;
-};
-
-//------------------------------------------------------------------------
-} // namespace Vst
-} // namespace Steinberg