smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-06 06:44:57 +01:00
Code Issues Projects Releases Wiki Activity

Import VST3 interface

Browse source
This commit is contained in:
Robin Gareus 2019-09-03 15:45:25 +02:00
parent 08b6d74078
commit 9c5f13f3fa
No known key found for this signature in database
GPG key ID: A090BCE02CF57F04
45 changed files with 8765 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

41
libs/vst3/LICENSE.txt Normal file
View file

@ -0,0 +1,41 @@
//-----------------------------------------------------------------------------
// LICENSE
// (c) 2019, 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
//----------------------------------------------------------------------------------

106
libs/vst3/pluginterfaces/base/conststringtable.cpp Normal file
View file

@ -0,0 +1,106 @@
//-----------------------------------------------------------------------------
// 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

45
libs/vst3/pluginterfaces/base/conststringtable.h Normal file
View file

@ -0,0 +1,45 @@
//-----------------------------------------------------------------------------
// 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

25
libs/vst3/pluginterfaces/base/falignpop.h Normal file
View file

@ -0,0 +1,25 @@
//-----------------------------------------------------------------------------
// 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
//---------------------------------------------------------------------------------------------------

38
libs/vst3/pluginterfaces/base/falignpush.h Normal file
View file

@ -0,0 +1,38 @@
//-----------------------------------------------------------------------------
// 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
#pragma GCC diagnostic default "-Wpragma-pack"
#pragma GCC diagnostic default "-Wunknown-warning-option"
#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
//----------------------------------------------------------------------------------------------

229
libs/vst3/pluginterfaces/base/fplatform.h Normal file
View file

@ -0,0 +1,229 @@
//-----------------------------------------------------------------------------
// 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 BYTEORDER kLittleEndian
#define COM_COMPATIBLE 1
#define PLUGIN_API __stdcall
#define SMTG_PTHREADS 0
#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif
#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
#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__
#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
#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
#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
#define SMTG_CPP11_STDLIBSUPPORT SMTG_CPP11
#define SMTG_HAS_NOEXCEPT SMTG_CPP11
#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
#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
#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
#else
#define SMTG_OVERRIDE
#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)
//-----------------------------------------------------------------------------

291
libs/vst3/pluginterfaces/base/fstrdefs.h Normal file
View file

@ -0,0 +1,291 @@
//-----------------------------------------------------------------------------
// 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

194
libs/vst3/pluginterfaces/base/ftypes.h Normal file
View file

@ -0,0 +1,194 @@
//-----------------------------------------------------------------------------
// 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
#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

477
libs/vst3/pluginterfaces/base/funknown.cpp Normal file
View file

@ -0,0 +1,477 @@
//-----------------------------------------------------------------------------
// 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 <stdio.h>
#if SMTG_OS_WINDOWS
#include <objbase.h>
#if defined(__MINGW32__)
/* UUID */
#include <string>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#endif
#endif
#if SMTG_OS_MACOS
#include <CoreFoundation/CoreFoundation.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
#if SMTG_OS_LINUX
#include <ext/atomicity.h>
/* UUID */
#include <string>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#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_OS_WINDOWS
return InterlockedExchangeAdd ((volatile long int*)&var, d) + d;
#elif SMTG_OS_MACOS
return OSAtomicAdd32Barrier (d, (int32_t*)&var);
#elif SMTG_OS_LINUX
__gnu_cxx::__atomic_add (&var, d);
return var;
#else
#warning implement me!
var += d;
return var;
#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;
#elif defined(__MINGW32__)
boost::uuids::uuid u = boost::uuids::random_generator()();
memcpy(data, (const void*)&u, 16);
return true;
#else
GUID guid;
HRESULT hr = CoCreateGuid (&guid);
switch (hr)
{
case RPC_S_OK: memcpy (data, (char*)&guid, sizeof (TUID)); return true;
case 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
boost::uuids::uuid u = boost::uuids::random_generator()();
memcpy(data, (const void*)&u, 16);
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
GuidStruct* 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
GuidStruct* 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

475
libs/vst3/pluginterfaces/base/funknown.h Normal file
View file

@ -0,0 +1,475 @@
//-----------------------------------------------------------------------------
// 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 <string.h>
//------------------------------------------------------------------------
/*! \defgroup pluginBase Basic Interfaces
*/
//------------------------------------------------------------------------
//------------------------------------------------------------------------
// Unique Identifier macros
//------------------------------------------------------------------------
#if COM_COMPATIBLE
#define INLINE_UID(l1, l2, l3, l4) \
{ \
(::Steinberg::int8)((l1 & 0x000000FF) ), (::Steinberg::int8)((l1 & 0x0000FF00) >> 8), \
(::Steinberg::int8)((l1 & 0x00FF0000) >> 16), (::Steinberg::int8)((l1 & 0xFF000000) >> 24), \
(::Steinberg::int8)((l2 & 0x00FF0000) >> 16), (::Steinberg::int8)((l2 & 0xFF000000) >> 24), \
(::Steinberg::int8)((l2 & 0x000000FF) ), (::Steinberg::int8)((l2 & 0x0000FF00) >> 8), \
(::Steinberg::int8)((l3 & 0xFF000000) >> 24), (::Steinberg::int8)((l3 & 0x00FF0000) >> 16), \
(::Steinberg::int8)((l3 & 0x0000FF00) >> 8), (::Steinberg::int8)((l3 & 0x000000FF) ), \
(::Steinberg::int8)((l4 & 0xFF000000) >> 24), (::Steinberg::int8)((l4 & 0x00FF0000) >> 16), \
(::Steinberg::int8)((l4 & 0x0000FF00) >> 8), (::Steinberg::int8)((l4 & 0x000000FF) ) \
}
#else
#define INLINE_UID(l1, l2, l3, l4) \
{ \
(::Steinberg::int8)((l1 & 0xFF000000) >> 24), (::Steinberg::int8)((l1 & 0x00FF0000) >> 16), \
(::Steinberg::int8)((l1 & 0x0000FF00) >> 8), (::Steinberg::int8)((l1 & 0x000000FF) ), \
(::Steinberg::int8)((l2 & 0xFF000000) >> 24), (::Steinberg::int8)((l2 & 0x00FF0000) >> 16), \
(::Steinberg::int8)((l2 & 0x0000FF00) >> 8), (::Steinberg::int8)((l2 & 0x000000FF) ), \
(::Steinberg::int8)((l3 & 0xFF000000) >> 24), (::Steinberg::int8)((l3 & 0x00FF0000) >> 16), \
(::Steinberg::int8)((l3 & 0x0000FF00) >> 8), (::Steinberg::int8)((l3 & 0x000000FF) ), \
(::Steinberg::int8)((l4 & 0xFF000000) >> 24), (::Steinberg::int8)((l4 & 0x00FF0000) >> 16), \
(::Steinberg::int8)((l4 & 0x0000FF00) >> 8), (::Steinberg::int8)((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; }
#define FUNKNOWN_DTOR
//------------------------------------------------------------------------
#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[64];
/** 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
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® OLE format.
(e.g. "{c200e360-38c5-11ce-ae62-08002b2b79ef}") */
void toRegistryString (char8* string) const;
/** Sets the UID data from a string in Microsoft® 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 return 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 return 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
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; }
};
//------------------------------------------------------------------------
template <class I>
inline FUnknownPtr<I>::FUnknownPtr (FUnknown* unknown)
{
if (unknown && unknown->queryInterface (I::iid, (void**)&this->ptr) != kResultOk)
this->ptr = 0;
}
//------------------------------------------------------------------------
template <class I>
inline I* FUnknownPtr<I>::operator= (FUnknown* unknown)
{
I* newPtr = 0;
if (unknown && unknown->queryInterface (I::iid, (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
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
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

89
libs/vst3/pluginterfaces/base/ibstream.h Normal file
View file

@ -0,0 +1,89 @@
//-----------------------------------------------------------------------------
// 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 = 0) = 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 = 0) = 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 = 0) = 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

436
libs/vst3/pluginterfaces/base/ipluginbase.h Normal file
View file

@ -0,0 +1,436 @@
//-----------------------------------------------------------------------------
// 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.
\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 won't 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.
\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 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.
\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.
\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
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"
{
Steinberg::IPluginFactory* PLUGIN_API GetPluginFactory ();
typedef Steinberg::IPluginFactory* (PLUGIN_API *GetFactoryProc) ();
}

80
libs/vst3/pluginterfaces/base/istringresult.h Normal file
View file

@ -0,0 +1,80 @@
//-----------------------------------------------------------------------------
// 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] \n
[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] \n
[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

386
libs/vst3/pluginterfaces/base/smartpointer.h Normal file
View file

@ -0,0 +1,386 @@
//-----------------------------------------------------------------------------
// 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)
{
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;
}
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); }
#endif
//------------------------------------------------------------------------
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

43
libs/vst3/pluginterfaces/base/typesizecheck.h Normal file
View file

@ -0,0 +1,43 @@
//-----------------------------------------------------------------------------
// 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
/** 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) \
namespace { \
template <typename Type, size_t w, size_t x, size_t y, size_t z> \
struct SizeCheck##Type \
{ \
constexpr SizeCheck##Type () \
{ \
static_assert (sizeof (Type) == (SMTG_PLATFORM_64 ? w : SMTG_OS_MACOS ? x : SMTG_OS_LINUX ? z : y), \
"Struct Size Error: " #Type); \
} \
}; \
static constexpr SizeCheck##Type<Type, Platform64Size, MacOS32Size, Win32Size, Linux32Size> instance##Type; \
}
#else
// need static_assert
#define SMTG_TYPE_SIZE_CHECK(Type, Platform64Size, MacOS32Size, Win32Size, Linux32Size)
#endif

286
libs/vst3/pluginterfaces/gui/iplugview.h Normal file
View file

@ -0,0 +1,286 @@
//-----------------------------------------------------------------------------
// 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 </b> : If IPlugView::canResize () returns kResultTrue the host will setup 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
rect. The host then resizes the window to this rect and has to call IPlugView::onSize ().
\n
\n
- <b> Plug-in </b> : The Plug-in can call IPlugFrame::resizeView () and cause the host to resize the
window.
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!!
Here the calling sequence:
* 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 {
#define TimerInterval uint64
#define 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

66
libs/vst3/pluginterfaces/gui/iplugviewcontentscalesupport.h Normal file
View file

@ -0,0 +1,66 @@
//-----------------------------------------------------------------------------
// 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]
- [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 view was 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 alive.
*/
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"
//------------------------------------------------------------------------

147
libs/vst3/pluginterfaces/vst/ivstattributes.h Normal file
View file

@ -0,0 +1,147 @@
//------------------------------------------------------------------------
// 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.
\ingroup vstIHost vst300
- [host imp]
- [released: 3.0.0]
- [mandatory]
An attribute list associates values with a key (id: some predefined keys could 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). */
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 size) = 0;
/** Sets binary data. */
virtual tresult PLUGIN_API setBinary (AttrID id, const void* data, uint32 size) = 0;
/** Gets binary data. */
virtual tresult PLUGIN_API getBinary (AttrID id, const void*& data, uint32& size) = 0;
//------------------------------------------------------------------------
static const FUID iid;
};
DECLARE_CLASS_IID (IAttributeList, 0x1E5F0AEB, 0xCC7F4533, 0xA2544011, 0x38AD5EE4)
//------------------------------------------------------------------------
/** Meta attributes of a stream.
\ingroup vstIHost vst360
- [host imp]
- [extends IBStream]
- [released: 3.6.0]
- [optional]
\code
...
#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
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 this 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). */
//------------------------------------------------------------------------
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"
//------------------------------------------------------------------------

355
libs/vst3/pluginterfaces/vst/ivstaudioprocessor.h Normal file
View file

@ -0,0 +1,355 @@
//------------------------------------------------------------------------
// 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 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 plugin
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 (0) {}
//------------------------------------------------------------------------
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 */
//------------------------------------------------------------------------
struct ProcessData
{
ProcessData ()
: processMode (0), symbolicSampleSize (kSample32), numSamples (0), numInputs (0)
, numOutputs (0), inputs (0), outputs (0), inputParameterChanges (0), outputParameterChanges (0)
, inputEvents (0), outputEvents (0), processContext (0) {}
//------------------------------------------------------------------------
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 buses
int32 numOutputs; ///< number of audio output buses
AudioBusBuffers* inputs; ///< buffers of input buses
AudioBusBuffers* outputs; ///< buffers of output buses
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.
\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 (from host) a predefined arrangement for inputs and outputs.
The host should always deliver the same number of input and output buses than the Plug-in needs
(see \ref IComponent::getBusCount).
The Plug-in returns kResultFalse if wanted arrangements are not supported.
If the Plug-in accepts these arrangements, it should modify its buses to match the new arrangements
(asked by the host with IComponent::getInfo () or IAudioProcessor::getBusArrangement ()) and then return kResultTrue.
If the Plug-in does not accept these arrangements, but can adapt its current arrangements (according to the wanted ones),
it should modify its buses arrangements and return 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::getInfo () and IAudioProcessor::getBusArrangement () should be always return the same
information about the buses 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 (not active) before 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.
In this call the Plug-in should do only light operation (no memory allocation or big setup reconfiguration),
this could be used to reset some buffers (like Delay line or Reverb). */
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.
\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 a Audio Device, then this initial input latency will be 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 a Audio Device then this initial output latency will be the output
latency of the Audio Device itself.
A value of zero means either 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)
//------------------------------------------------------------------------
} // namespace Vst
} // namespace Steinberg
//------------------------------------------------------------------------
#include "pluginterfaces/base/falignpop.h"
//------------------------------------------------------------------------

67
libs/vst3/pluginterfaces/vst/ivstautomationstate.h Normal file
View file

@ -0,0 +1,67 @@
//------------------------------------------------------------------------
// 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.
\ingroup vstIPlug vst365
- [plug imp]
- [extends IEditController]
- [released: 3.6.5]
- [optional]
Hosts could 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"
//------------------------------------------------------------------------

226
libs/vst3/pluginterfaces/vst/ivstchannelcontextinfo.h Normal file
View file

@ -0,0 +1,226 @@
//------------------------------------------------------------------------
// 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.
\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 could 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
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
typedef uint32 ColorSpec; ///< ARGB (Alpha-Red-Green-Blue)
typedef uint8 ColorComponent;
inline ColorComponent GetBlue (ColorSpec cs) {return (ColorComponent)(cs & 0x000000FF); }
inline ColorComponent GetGreen (ColorSpec cs) {return (ColorComponent)((cs >> 8) & 0x000000FF); }
inline ColorComponent GetRed (ColorSpec cs) {return (ColorComponent)((cs >> 16) & 0x000000FF); }
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"
//------------------------------------------------------------------------

186
libs/vst3/pluginterfaces/vst/ivstcomponent.h Normal file
View file

@ -0,0 +1,186 @@
//-----------------------------------------------------------------------------
// 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 "vsttypes.h"
//------------------------------------------------------------------------
#include "pluginterfaces/base/falignpush.h"
//------------------------------------------------------------------------
namespace Steinberg {
class IBStream;
//------------------------------------------------------------------------
/** All VST specific interfaces are located in Vst namespace */
//------------------------------------------------------------------------
namespace Vst {
const int32 kDefaultFactoryFlags = PFactoryInfo::kUnicode; ///< Standard value for PFactoryInfo::flags
#define BEGIN_FACTORY_DEF(vendor,url,email) using namespace Steinberg; \
EXPORT_FACTORY IPluginFactory* PLUGIN_API GetPluginFactory () { \
if (!gPluginFactory) \
{ static PFactoryInfo factoryInfo (vendor,url,email,Vst::kDefaultFactoryFlags); \
gPluginFactory = new CPluginFactory (factoryInfo);
//------------------------------------------------------------------------
/** \defgroup vstBus VST Buses
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 buses, but this number must \b never change.
Dynamic usage of buses is handled in the host by activating and deactivating buses.
The component has to define the maximum number of supported buses and it has to
define which of them are active by default. A host that can handle multiple buses,
allows the user to activate buses that were initially inactive.
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: 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
{
kDefaultActive = 1 << 0 ///< bus active per default
};
};
/*@}*/
//------------------------------------------------------------------------
/** 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 buses, a host may want to know how the buses 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
\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.
*/
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 buses are not activated */
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"
//------------------------------------------------------------------------

217
libs/vst3/pluginterfaces/vst/ivstcontextmenu.h Normal file
View file

@ -0,0 +1,217 @@
//------------------------------------------------------------------------
// 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 "vsttypes.h"
//------------------------------------------------------------------------
#include "pluginterfaces/base/falignpush.h"
//------------------------------------------------------------------------
namespace Steinberg {
class IPlugView;
namespace Vst {
class IContextMenu;
//------------------------------------------------------------------------
/** Extended Host callback interface 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 pop-up it. See the \ref IContextMenuExample.
- extract the host menu items and add them to its own created context menu
\b Note: You can and should use this even if you don't add your own items to the menu as this is considered to be a big user value.
\sa IContextMenu
\sa IContextMenuTarget
\section IContextMenuExample Example
Adding Plug-in specific items to the context menu
\code
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 won't 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.
\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.
*/
//------------------------------------------------------------------------
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.
\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.
*/
//------------------------------------------------------------------------
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"
//------------------------------------------------------------------------

434
libs/vst3/pluginterfaces/vst/ivsteditcontroller.h Normal file
View file

@ -0,0 +1,434 @@
//------------------------------------------------------------------------
// 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 "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. */
//------------------------------------------------------------------------
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 vst3UnitsIntro)
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 (implies that kCanAutomate is false)
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]
kIsProgramChange = 1 << 15, ///< parameter is a program change (unitId gives info about associated unit
///< - see \ref vst3UnitPrograms)
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
{
kReloadComponent = 1 << 0, ///< The Component should be reloaded [SDK 3.0.0]
kIoChanged = 1 << 1, ///< Input and/or Output Bus configuration has changed [SDK 3.0.0]
kParamValuesChanged = 1 << 2, ///< Multiple parameter values have changed
///< (as result of a program change for example) [SDK 3.0.0]
kLatencyChanged = 1 << 3, ///< Latency has changed (IAudioProcessor.getLatencySamples) [SDK 3.0.0]
kParamTitlesChanged = 1 << 4, ///< Parameter titles or default values or flags have changed [SDK 3.0.0]
kMidiCCAssignmentChanged = 1 << 5, ///< MIDI Controller Assignments have changed [SDK 3.0.1]
kNoteExpressionChanged = 1 << 6, ///< Note Expression has changed (info, count, PhysicalUIMapping, ...) [SDK 3.5.0]
kIoTitlesChanged = 1 << 7, ///< Input and/or Output bus titles have changed [SDK 3.5.0]
kPrefetchableSupportChanged = 1 << 8, ///< Prefetch support has changed (\see IPrefetchableSupport) [SDK 3.6.1]
kRoutingInfoChanged = 1 << 9 ///< RoutingInfo has changed (\see IComponent) [SDK 3.6.6]
};
//------------------------------------------------------------------------
/** Host callback interface for an edit controller.
\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 IEditController */
//------------------------------------------------------------------------
class IComponentHandler: public FUnknown
{
public:
//------------------------------------------------------------------------
/** To be called before calling a performEdit (e.g. on mouse-click-down event). */
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. */
virtual tresult PLUGIN_API performEdit (ParamID id, ParamValue valueNormalized) = 0;
/** To be called after calling a performEdit (e.g. on mouse-click-up event). */
virtual tresult PLUGIN_API endEdit (ParamID id) = 0;
/** Instructs host to restart the component. This should 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 IComponentHandler2 for an edit controller
\ingroup vstIHost vst310
- [host imp]
- [extends IComponentHandler]
- [released: 3.1.0]
- [optional]
One part handles:
- Setting dirty state of Plug-in
- requesting the host to open the editor
The other part handles parameter group editing from Plug-in UI. It wraps a set of \ref IComponentHandler::beginEdit /
\ref IComponentHandler::performEdit / \ref IComponentHandler::endEdit functions (see \ref IComponentHandler)
which should use the same timestamp in the host when writing automation.
This allows for better synchronizing multiple parameter changes at once.
\section IComponentHandler2Example Examples of different use cases
\code
//--------------------------------------
// 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 IComponentHandler
\see 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 IComponentHandlerBusActivation for an edit controller.
\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 it will call later on IComponent::activateBus (see \ref IComponent::activateBus).
Useful especially for Instrument with more than 1 outputs, where the user could request
from the Plug-in UI a given output bus activation.
\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)
//------------------------------------------------------------------------
/** Edit controller component interface.
\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 IComponent::getControllerClassId, 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 90 for 90db - 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. */
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
};
typedef int32 KnobMode; ///< Knob Mode
//------------------------------------------------------------------------
/** Edit controller component interface extension.
\ingroup vstIPlug vst310
- [plug imp]
- [extends IEditController]
- [released: 3.1.0]
- [optional]
Extension to inform the Plug-in about the host Knob Mode,
and to open the Plug-in about box or help documentation.
\see IEditController*/
//------------------------------------------------------------------------
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.
\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 normal
parameter change. This allows the host to automate them in the same way as other parameters.
CtrlNumber could be typical MIDI controller value extended to some others values like pitch bend or
after touch (see \ref ControllerNumbers).
If the mapping has changed, the Plug-in should call IComponentHandler::restartComponent (kMidiCCAssignmentChanged)
to inform the host about this change. */
//------------------------------------------------------------------------
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.
\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 flagged parameter (kind of helper parameter),
the host will start with a beginEditFromHost before calling setParamNormalized and end with an endEditFromHost.
Here the sequencing, the host will call:
- beginEditFromHost ()
- setParamNormalized ()
- setParamNormalized ()
- ...
- endEditFromHost ()
\see 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"
//------------------------------------------------------------------------

192
libs/vst3/pluginterfaces/vst/ivstevents.h Normal file
View file

@ -0,0 +1,192 @@
//------------------------------------------------------------------------
// 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 {
//------------------------------------------------------------------------
/** Note-on event specific data. Used in \ref Event (union)*/
struct NoteOnEvent
{
int16 channel; ///< channel index in event bus
int16 pitch; ///< range [0, 127] = [C-2, G8] with A3=440Hz
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)*/
struct NoteOffEvent
{
int16 channel; ///< channel index in event bus
int16 pitch; ///< range [0, 127] = [C-2, G8] with A3=440Hz
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)*/
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)*/
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)*/
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)*/
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)*/
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 */
//------------------------------------------------------------------------
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.
\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"
//------------------------------------------------------------------------

162
libs/vst3/pluginterfaces/vst/ivsthostapplication.h Normal file
View file

@ -0,0 +1,162 @@
//------------------------------------------------------------------------
// 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.
\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)
//------------------------------------------------------------------------
inline IMessage* allocateMessage (IHostApplication* host)
{
TUID iid;
IMessage::iid.toTUID (iid);
IMessage* m = 0;
if (host->createInstance (iid, iid, (void**)&m) == kResultOk)
return m;
return 0;
}
//------------------------------------------------------------------------
/** VST 3 to VST 2 Wrapper Interface.
\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.
\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.
\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
\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.
Per 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

144
libs/vst3/pluginterfaces/vst/ivstinterappaudio.h Normal file
View file

@ -0,0 +1,144 @@
//------------------------------------------------------------------------
// 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:
/** TODO */
virtual tresult PLUGIN_API runLoadPresetBrowser () = 0;
/** TODO */
virtual tresult PLUGIN_API runSavePresetBrowser () = 0;
/** TODO */
virtual tresult PLUGIN_API loadNextPreset () = 0;
/** TODO */
virtual tresult PLUGIN_API loadPreviousPreset () = 0;
//------------------------------------------------------------------------
static const FUID iid;
};
DECLARE_CLASS_IID (IInterAppAudioPresetManager, 0xADE6FCC4, 0x46C94E1D, 0xB3B49A80, 0xC93FEFDD)
//------------------------------------------------------------------------
} // namespace Vst
} // namespace Steinberg

96
libs/vst3/pluginterfaces/vst/ivstmessage.h Normal file
View file

@ -0,0 +1,96 @@
//------------------------------------------------------------------------
// 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.
\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.
\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"
//------------------------------------------------------------------------

118
libs/vst3/pluginterfaces/vst/ivstmidicontrollers.h Normal file
View file

@ -0,0 +1,118 @@
//------------------------------------------------------------------------
// 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
kCtrlEff3Depth = 93, ///< Effect 3 Depth (Chorus Send Level)
kCtrlEff4Depth = 94, ///< Effect 4 Depth (Delay/Variation Level)
kCtrlEff5Depth = 95, ///< Effect 5 Depth
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
kPitchBend = 129, ///< Pitch Bend
kCountCtrlNumber, ///< Count of Controller Number
//---Extra for kLegacyMIDICCOutEvent-
kCtrlProgramChange = 130, ///< Program Change (use LegacyMIDICCOutEvent.value only)
kCtrlPolyPressure = 131, ///< Poly Pressure (use LegacyMIDICCOutEvent.value for pitch and
/// LegacyMIDICCOutEvent.value2 for pressure)
kCtrlQuarterFrame = 132 ///< Quarter Frame ((use LegacyMIDICCOutEvent.value only)
};
//------------------------------------------------------------------------
} // namespace Vst
} // namespace Steinberg

57
libs/vst3/pluginterfaces/vst/ivstmidilearn.h Normal file
View file

@ -0,0 +1,57 @@
//------------------------------------------------------------------------
// 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.
\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 it's 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.
*/
//------------------------------------------------------------------------
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

257
libs/vst3/pluginterfaces/vst/ivstnoteexpression.h Normal file
View file

@ -0,0 +1,257 @@
//------------------------------------------------------------------------
// 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 "vsttypes.h"
//------------------------------------------------------------------------
#include "pluginterfaces/base/falignpush.h"
//------------------------------------------------------------------------
namespace Steinberg {
namespace Vst {
typedef uint32 NoteExpressionTypeID;
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
#if SMTG_CPP11
: uint32
#endif
{
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, ///< TODO:
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 vst3UnitsIntro), 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
\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
#if SMTG_CPP11
: uint32
#endif
{
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 vst3UnitsIntro), -1 means no unit used.
int32 flags; ///< not yet used (set to 0)
};
//------------------------------------------------------------------------
/** Extended Plug-in interface IEditController for key switches support
\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"
//------------------------------------------------------------------------

142
libs/vst3/pluginterfaces/vst/ivstparameterchanges.h Normal file
View file

@ -0,0 +1,142 @@
//------------------------------------------------------------------------
// 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 "vsttypes.h"
//------------------------------------------------------------------------
#include "pluginterfaces/base/falignpush.h"
//------------------------------------------------------------------------
//----------------------------------------------------------------------
namespace Steinberg {
namespace Vst {
//----------------------------------------------------------------------
/** Queue of changes for a specific parameter.
\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
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:</b> \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 IParameterChanges, 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.
\ingroup vstIHost vst300
- [host imp]
- [released: 3.0.0]
- [mandatory]
This interface is used to transmit any changes that shall 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 (IParamValueQueue)
containing only queues for parameters that actually did change.
\see IParamValueQueue, 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"
//------------------------------------------------------------------------

130
libs/vst3/pluginterfaces/vst/ivstphysicalui.h Normal file
View file

@ -0,0 +1,130 @@
//------------------------------------------------------------------------
// 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 {
//------------------------------------------------------------------------
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
\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
tresult PLUGIN_API myPlug::::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"
//------------------------------------------------------------------------

64
libs/vst3/pluginterfaces/vst/ivstpluginterfacesupport.h Normal file
View file

@ -0,0 +1,64 @@
//------------------------------------------------------------------------
// 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 "vsttypes.h"
//------------------------------------------------------------------------
namespace Steinberg {
namespace Vst {
//------------------------------------------------------------------------
/** Host callback interface for an edit controller.
\ingroup vstIHost vst3612
- [host imp]
- [released: 3.6.12]
- [optional]
Allow 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.
\code
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

62
libs/vst3/pluginterfaces/vst/ivstplugview.h Normal file
View file

@ -0,0 +1,62 @@
//------------------------------------------------------------------------
// 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 "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)
\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"
//------------------------------------------------------------------------

87
libs/vst3/pluginterfaces/vst/ivstprefetchablesupport.h Normal file
View file

@ -0,0 +1,87 @@
//------------------------------------------------------------------------
// 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 {
typedef uint32 PrefetchableSupport;
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).
\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 will decide in which mode the Plug-in will be process.
For more info about Prefetch processing mode check ProcessModes::kPrefetch documentation.
\section IPrefetchableSupportExample Example
\code
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"
//------------------------------------------------------------------------

142
libs/vst3/pluginterfaces/vst/ivstprocesscontext.h Normal file
View file

@ -0,0 +1,142 @@
//------------------------------------------------------------------------
// 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 "vsttypes.h"
//------------------------------------------------------------------------
#include "pluginterfaces/base/falignpush.h"
//------------------------------------------------------------------------
//------------------------------------------------------------------------
namespace Steinberg {
namespace Vst {
//------------------------------------------------------------------------
/** Frame Rate */
//------------------------------------------------------------------------
struct FrameRate
{
//------------------------------------------------------------------------
enum FrameRateFlags
{
kPullDownRate = 1 << 0, ///< for ex. HDTV: 23.976 fps with 24 as frame rate
kDropRate = 1 << 1 ///< for ex. 29.97 fps drop with 30 as frame rate
};
//------------------------------------------------------------------------
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.
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\n
- XXXX 0000 0100 0100 (= 0x0044) -> minor chord\n
- 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 behaviour
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)
TQuarterNotes barPositionMusic; ///< last bar start position, in quarter notes
TQuarterNotes cycleStartMusic; ///< cycle start in quarter notes
TQuarterNotes cycleEndMusic; ///< cycle end in quarter notes
double tempo; ///< tempo in BPM (Beats Per Minute)
int32 timeSigNumerator; ///< time signature numerator (e.g. 3 for 3/4)
int32 timeSigDenominator; ///< time signature denominator (e.g. 4 for 3/4)
Chord chord; ///< musical info
int32 smpteOffsetSubframes; ///< SMPTE (sync) offset in subframes (1/80 of frame)
FrameRate frameRate; ///< frame rate
int32 samplesToNextClock; ///< MIDI Clock Resolution (24 Per Quarter Note), can be negative (nearest)
//------------------------------------------------------------------------
};
//------------------------------------------------------------------------
} // namespace Vst
} // namespace Steinberg
//------------------------------------------------------------------------
#include "pluginterfaces/base/falignpop.h"
//------------------------------------------------------------------------

372
libs/vst3/pluginterfaces/vst/ivstrepresentation.h Normal file
View file

@ -0,0 +1,372 @@
//------------------------------------------------------------------------
// 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 = 0, char8* _version = 0, char8* _host = 0)
{
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.
\ingroup vstIPlug vst350
- [plug imp]
- [extends IEditController]
- [released: 3.5.0]
- [optional]
A Representation based on XML is a way to export and structure, group Plug-ins parameters for a specific remote (could be hardware or software rack (like quickcontrols)).
\n
It allows to describe more precisely each parameter (what is the best matching to a knob, different titles 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 are 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 (an 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"
,0
};
};
//------------------------------------------------------------------------
/** 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"
//------------------------------------------------------------------------

89
libs/vst3/pluginterfaces/vst/ivsttestplugprovider.h Normal file
View file

@ -0,0 +1,89 @@
//-----------------------------------------------------------------------------
// 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) 2019, 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)
//------------------------------------------------------------------------
} // Vst
} // Steinberg

269
libs/vst3/pluginterfaces/vst/ivstunits.h Normal file
View file

@ -0,0 +1,269 @@
//------------------------------------------------------------------------
// 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 "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 doesn't 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.
\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.
\ingroup vstIHost vst365
- [host imp]
- [extends IUnitHandler]
- [released: 3.6.5]
- [optional]
Host callback interface, used with IUnitInfo.
Retrieve via queryInterface from IComponentHandler.
\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.
\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.
\ingroup vstIPlug vst300
- [plug imp]
- [extends IComponent]
- [released: 3.0.0]
- [optional]
A component can either support program list data via this interface or
unit preset data (IUnitData), but not both!
\see \ref vst3UnitPrograms */
//------------------------------------------------------------------------
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.
\ingroup vstIPlug vst300
- [plug imp]
- [extends IComponent]
- [released: 3.0.0]
- [optional]
A component can either support unit preset data via this interface or
program list data (IProgramListData), but not both!
\see \ref vst3UnitPrograms */
//------------------------------------------------------------------------
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"
//------------------------------------------------------------------------

431
libs/vst3/pluginterfaces/vst/vstpresetkeys.h Normal file
View file

@ -0,0 +1,431 @@
//------------------------------------------------------------------------
// Project : VST SDK
//
// Category : Interfaces
// Filename : pluginterfaces/vst/vstpresetkeys.h
// Created by : Steinberg, 2006
// Description : VST Preset Keys
//
//-----------------------------------------------------------------------------
// 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 "vsttypes.h"
//------------------------------------------------------------------------
namespace Steinberg {
namespace Vst {
//------------------------------------------------------------------------
/** Predefined Preset Attributes */
//------------------------------------------------------------------------
namespace PresetAttributes
{
/**
\defgroup presetAttributes Predefined Preset Attributes*/
/*@{*/
const CString kPlugInName = "PlugInName"; ///< Plug-in name
const CString kPlugInCategory = "PlugInCategory"; ///< eg. "Fx|Dynamics", "Instrument", "Instrument|Synth"
const CString kInstrument = "MusicalInstrument";///< eg. instrument group (like 'Piano' or 'Piano|A. Piano')
const CString kStyle = "MusicalStyle"; ///< eg. 'Pop', 'Jazz', 'Classic'
const CString kCharacter = "MusicalCharacter"; ///< eg. instrument nature (like 'Soft' 'Dry' 'Acoustic')
const CString kStateType = "StateType"; ///< Type of the given state see \ref StateType : Project / Default Preset or Normal Preset
const CString kFilePathStringType = "FilePathString"; ///< Full file path string (if available) where the preset comes from (be sure to use a bigger string when asking for it (with 1024 characters))
const CString kName = "Name"; ///< name of the preset
const CString kFileName = "FileName"; ///< filename of the preset (including extension)
/*@}*/
};
//------------------------------------------------------------------------
/** Predefined StateType used for Key kStateType */
//------------------------------------------------------------------------
namespace StateType {
/**
\defgroup stateType Context of State Restoration */
/*@{*/
//------------------------------------------------------------------------
const CString kProject = "Project"; ///< the state is restored from a project loading or it is saved in a project
const CString kDefault = "Default"; ///< the state is restored from a preset (marked as default) or the host wants to store a default state of the plug-in
//------------------------------------------------------------------------
/*@}*/
}
//------------------------------------------------------------------------
/** Predefined Musical Instrument */
//------------------------------------------------------------------------
namespace MusicalInstrument
{
/**
\defgroup musicalInstrument Predefined Musical Instrument */
/*@{*/
const CString kAccordion = "Accordion";
const CString kAccordionAccordion = "Accordion|Accordion";
const CString kAccordionHarmonica = "Accordion|Harmonica";
const CString kAccordionOther = "Accordion|Other";
const CString kBass = "Bass";
const CString kBassABass = "Bass|A. Bass";
const CString kBassEBass = "Bass|E. Bass";
const CString kBassSynthBass = "Bass|Synth Bass";
const CString kBassOther = "Bass|Other";
const CString kBrass = "Brass";
const CString kBrassFrenchHorn = "Brass|French Horn";
const CString kBrassTrumpet = "Brass|Trumpet";
const CString kBrassTrombone = "Brass|Trombone";
const CString kBrassTuba = "Brass|Tuba";
const CString kBrassSection = "Brass|Section";
const CString kBrassSynth = "Brass|Synth";
const CString kBrassOther = "Brass|Other";
const CString kChromaticPerc = "Chromatic Perc";
const CString kChromaticPercBell = "Chromatic Perc|Bell";
const CString kChromaticPercMallett = "Chromatic Perc|Mallett";
const CString kChromaticPercWood = "Chromatic Perc|Wood";
const CString kChromaticPercPercussion = "Chromatic Perc|Percussion";
const CString kChromaticPercTimpani = "Chromatic Perc|Timpani";
const CString kChromaticPercOther = "Chromatic Perc|Other";
const CString kDrumPerc = "Drum&Perc";
const CString kDrumPercDrumsetGM = "Drum&Perc|Drumset GM";
const CString kDrumPercDrumset = "Drum&Perc|Drumset";
const CString kDrumPercDrumMenues = "Drum&Perc|Drum Menues";
const CString kDrumPercBeats = "Drum&Perc|Beats";
const CString kDrumPercPercussion = "Drum&Perc|Percussion";
const CString kDrumPercKickDrum = "Drum&Perc|Kick Drum";
const CString kDrumPercSnareDrum = "Drum&Perc|Snare Drum";
const CString kDrumPercToms = "Drum&Perc|Toms";
const CString kDrumPercHiHats = "Drum&Perc|HiHats";
const CString kDrumPercCymbals = "Drum&Perc|Cymbals";
const CString kDrumPercOther = "Drum&Perc|Other";
const CString kEthnic = "Ethnic";
const CString kEthnicAsian = "Ethnic|Asian";
const CString kEthnicAfrican = "Ethnic|African";
const CString kEthnicEuropean = "Ethnic|European";
const CString kEthnicLatin = "Ethnic|Latin";
const CString kEthnicAmerican = "Ethnic|American";
const CString kEthnicAlien = "Ethnic|Alien";
const CString kEthnicOther = "Ethnic|Other";
const CString kGuitar = "Guitar/Plucked";
const CString kGuitarAGuitar = "Guitar/Plucked|A. Guitar";
const CString kGuitarEGuitar = "Guitar/Plucked|E. Guitar";
const CString kGuitarHarp = "Guitar/Plucked|Harp";
const CString kGuitarEthnic = "Guitar/Plucked|Ethnic";
const CString kGuitarOther = "Guitar/Plucked|Other";
const CString kKeyboard = "Keyboard";
const CString kKeyboardClavi = "Keyboard|Clavi";
const CString kKeyboardEPiano = "Keyboard|E. Piano";
const CString kKeyboardHarpsichord = "Keyboard|Harpsichord";
const CString kKeyboardOther = "Keyboard|Other";
const CString kMusicalFX = "Musical FX";
const CString kMusicalFXHitsStabs = "Musical FX|Hits&Stabs";
const CString kMusicalFXMotion = "Musical FX|Motion";
const CString kMusicalFXSweeps = "Musical FX|Sweeps";
const CString kMusicalFXBeepsBlips = "Musical FX|Beeps&Blips";
const CString kMusicalFXScratches = "Musical FX|Scratches";
const CString kMusicalFXOther = "Musical FX|Other";
const CString kOrgan = "Organ";
const CString kOrganElectric = "Organ|Electric";
const CString kOrganPipe = "Organ|Pipe";
const CString kOrganOther = "Organ|Other";
const CString kPiano = "Piano";
const CString kPianoAPiano = "Piano|A. Piano";
const CString kPianoEGrand = "Piano|E. Grand";
const CString kPianoOther = "Piano|Other";
const CString kSoundFX = "Sound FX";
const CString kSoundFXNature = "Sound FX|Nature";
const CString kSoundFXMechanical = "Sound FX|Mechanical";
const CString kSoundFXSynthetic = "Sound FX|Synthetic";
const CString kSoundFXOther = "Sound FX|Other";
const CString kStrings = "Strings";
const CString kStringsViolin = "Strings|Violin";
const CString kStringsViola = "Strings|Viola";
const CString kStringsCello = "Strings|Cello";
const CString kStringsBass = "Strings|Bass";
const CString kStringsSection = "Strings|Section";
const CString kStringsSynth = "Strings|Synth";
const CString kStringsOther = "Strings|Other";
const CString kSynthLead = "Synth Lead";
const CString kSynthLeadAnalog = "Synth Lead|Analog";
const CString kSynthLeadDigital = "Synth Lead|Digital";
const CString kSynthLeadArpeggio = "Synth Lead|Arpeggio";
const CString kSynthLeadOther = "Synth Lead|Other";
const CString kSynthPad = "Synth Pad";
const CString kSynthPadSynthChoir = "Synth Pad|Synth Choir";
const CString kSynthPadAnalog = "Synth Pad|Analog";
const CString kSynthPadDigital = "Synth Pad|Digital";
const CString kSynthPadMotion = "Synth Pad|Motion";
const CString kSynthPadOther = "Synth Pad|Other";
const CString kSynthComp = "Synth Comp";
const CString kSynthCompAnalog = "Synth Comp|Analog";
const CString kSynthCompDigital = "Synth Comp|Digital";
const CString kSynthCompOther = "Synth Comp|Other";
const CString kVocal = "Vocal";
const CString kVocalLeadVocal = "Vocal|Lead Vocal";
const CString kVocalAdlibs = "Vocal|Adlibs";
const CString kVocalChoir = "Vocal|Choir";
const CString kVocalSolo = "Vocal|Solo";
const CString kVocalFX = "Vocal|FX";
const CString kVocalSpoken = "Vocal|Spoken";
const CString kVocalOther = "Vocal|Other";
const CString kWoodwinds = "Woodwinds";
const CString kWoodwindsEthnic = "Woodwinds|Ethnic";
const CString kWoodwindsFlute = "Woodwinds|Flute";
const CString kWoodwindsOboe = "Woodwinds|Oboe";
const CString kWoodwindsEnglHorn = "Woodwinds|Engl. Horn";
const CString kWoodwindsClarinet = "Woodwinds|Clarinet";
const CString kWoodwindsSaxophone = "Woodwinds|Saxophone";
const CString kWoodwindsBassoon = "Woodwinds|Bassoon";
const CString kWoodwindsOther = "Woodwinds|Other";
/*@}*/
};
//------------------------------------------------------------------------
/** Predefined Musical Style */
//------------------------------------------------------------------------
namespace MusicalStyle
{
/**
\defgroup musicalStyle Predefined Musical Style */
/*@{*/
const CString kAlternativeIndie = "Alternative/Indie";
const CString kAlternativeIndieGothRock = "Alternative/Indie|Goth Rock";
const CString kAlternativeIndieGrunge = "Alternative/Indie|Grunge";
const CString kAlternativeIndieNewWave = "Alternative/Indie|New Wave";
const CString kAlternativeIndiePunk = "Alternative/Indie|Punk";
const CString kAlternativeIndieCollegeRock = "Alternative/Indie|College Rock";
const CString kAlternativeIndieDarkWave = "Alternative/Indie|Dark Wave";
const CString kAlternativeIndieHardcore = "Alternative/Indie|Hardcore";
const CString kAmbientChillOut = "Ambient/ChillOut";
const CString kAmbientChillOutNewAgeMeditation = "Ambient/ChillOut|New Age/Meditation";
const CString kAmbientChillOutDarkAmbient = "Ambient/ChillOut|Dark Ambient";
const CString kAmbientChillOutDowntempo = "Ambient/ChillOut|Downtempo";
const CString kAmbientChillOutLounge = "Ambient/ChillOut|Lounge";
const CString kBlues = "Blues";
const CString kBluesAcousticBlues = "Blues|Acoustic Blues";
const CString kBluesCountryBlues = "Blues|Country Blues";
const CString kBluesElectricBlues = "Blues|Electric Blues";
const CString kBluesChicagoBlues = "Blues|Chicago Blues";
const CString kClassical = "Classical";
const CString kClassicalBaroque = "Classical|Baroque";
const CString kClassicalChamberMusic = "Classical|Chamber Music";
const CString kClassicalMedieval = "Classical|Medieval";
const CString kClassicalModernComposition = "Classical|Modern Composition";
const CString kClassicalOpera = "Classical|Opera";
const CString kClassicalGregorian = "Classical|Gregorian";
const CString kClassicalRenaissance = "Classical|Renaissance";
const CString kClassicalClassic = "Classical|Classic";
const CString kClassicalRomantic = "Classical|Romantic";
const CString kClassicalSoundtrack = "Classical|Soundtrack";
const CString kCountry = "Country";
const CString kCountryCountryWestern = "Country|Country/Western";
const CString kCountryHonkyTonk = "Country|Honky Tonk";
const CString kCountryUrbanCowboy = "Country|Urban Cowboy";
const CString kCountryBluegrass = "Country|Bluegrass";
const CString kCountryAmericana = "Country|Americana";
const CString kCountrySquaredance = "Country|Squaredance";
const CString kCountryNorthAmericanFolk = "Country|North American Folk";
const CString kElectronicaDance = "Electronica/Dance";
const CString kElectronicaDanceMinimal = "Electronica/Dance|Minimal";
const CString kElectronicaDanceClassicHouse = "Electronica/Dance|Classic House";
const CString kElectronicaDanceElektroHouse = "Electronica/Dance|Elektro House";
const CString kElectronicaDanceFunkyHouse = "Electronica/Dance|Funky House";
const CString kElectronicaDanceIndustrial = "Electronica/Dance|Industrial";
const CString kElectronicaDanceElectronicBodyMusic = "Electronica/Dance|Electronic Body Music";
const CString kElectronicaDanceTripHop = "Electronica/Dance|Trip Hop";
const CString kElectronicaDanceTechno = "Electronica/Dance|Techno";
const CString kElectronicaDanceDrumNBassJungle = "Electronica/Dance|Drum'n'Bass/Jungle";
const CString kElectronicaDanceElektro = "Electronica/Dance|Elektro";
const CString kElectronicaDanceTrance = "Electronica/Dance|Trance";
const CString kElectronicaDanceDub = "Electronica/Dance|Dub";
const CString kElectronicaDanceBigBeats = "Electronica/Dance|Big Beats";
const CString kExperimental = "Experimental";
const CString kExperimentalNewMusic = "Experimental|New Music";
const CString kExperimentalFreeImprovisation = "Experimental|Free Improvisation";
const CString kExperimentalElectronicArtMusic = "Experimental|Electronic Art Music";
const CString kExperimentalNoise = "Experimental|Noise";
const CString kJazz = "Jazz";
const CString kJazzNewOrleansJazz = "Jazz|New Orleans Jazz";
const CString kJazzTraditionalJazz = "Jazz|Traditional Jazz";
const CString kJazzOldtimeJazzDixiland = "Jazz|Oldtime Jazz/Dixiland";
const CString kJazzFusion = "Jazz|Fusion";
const CString kJazzAvantgarde = "Jazz|Avantgarde";
const CString kJazzLatinJazz = "Jazz|Latin Jazz";
const CString kJazzFreeJazz = "Jazz|Free Jazz";
const CString kJazzRagtime = "Jazz|Ragtime";
const CString kPop = "Pop";
const CString kPopBritpop = "Pop|Britpop";
const CString kPopRock = "Pop|Pop/Rock";
const CString kPopTeenPop = "Pop|Teen Pop";
const CString kPopChartDance = "Pop|Chart Dance";
const CString kPop80sPop = "Pop|80's Pop";
const CString kPopDancehall = "Pop|Dancehall";
const CString kPopDisco = "Pop|Disco";
const CString kRockMetal = "Rock/Metal";
const CString kRockMetalBluesRock = "Rock/Metal|Blues Rock";
const CString kRockMetalClassicRock = "Rock/Metal|Classic Rock";
const CString kRockMetalHardRock = "Rock/Metal|Hard Rock";
const CString kRockMetalRockRoll = "Rock/Metal|Rock &amp; Roll";
const CString kRockMetalSingerSongwriter = "Rock/Metal|Singer/Songwriter";
const CString kRockMetalHeavyMetal = "Rock/Metal|Heavy Metal";
const CString kRockMetalDeathBlackMetal = "Rock/Metal|Death/Black Metal";
const CString kRockMetalNuMetal = "Rock/Metal|NuMetal";
const CString kRockMetalReggae = "Rock/Metal|Reggae";
const CString kRockMetalBallad = "Rock/Metal|Ballad";
const CString kRockMetalAlternativeRock = "Rock/Metal|Alternative Rock";
const CString kRockMetalRockabilly = "Rock/Metal|Rockabilly";
const CString kRockMetalThrashMetal = "Rock/Metal|Thrash Metal";
const CString kRockMetalProgressiveRock = "Rock/Metal|Progressive Rock";
const CString kUrbanHipHopRB = "Urban (Hip-Hop / R&B)";
const CString kUrbanHipHopRBClassic = "Urban (Hip-Hop / R&B)|Classic R&B";
const CString kUrbanHipHopRBModern = "Urban (Hip-Hop / R&B)|Modern R&B";
const CString kUrbanHipHopRBPop = "Urban (Hip-Hop / R&B)|R&B Pop";
const CString kUrbanHipHopRBWestCoastHipHop = "Urban (Hip-Hop / R&B)|WestCoast Hip-Hop";
const CString kUrbanHipHopRBEastCoastHipHop = "Urban (Hip-Hop / R&B)|EastCoast Hip-Hop";
const CString kUrbanHipHopRBRapHipHop = "Urban (Hip-Hop / R&B)|Rap/Hip Hop";
const CString kUrbanHipHopRBSoul = "Urban (Hip-Hop / R&B)|Soul";
const CString kUrbanHipHopRBFunk = "Urban (Hip-Hop / R&B)|Funk";
const CString kWorldEthnic = "World/Ethnic";
const CString kWorldEthnicAfrica = "World/Ethnic|Africa";
const CString kWorldEthnicAsia = "World/Ethnic|Asia";
const CString kWorldEthnicCeltic = "World/Ethnic|Celtic";
const CString kWorldEthnicEurope = "World/Ethnic|Europe";
const CString kWorldEthnicKlezmer = "World/Ethnic|Klezmer";
const CString kWorldEthnicScandinavia = "World/Ethnic|Scandinavia";
const CString kWorldEthnicEasternEurope = "World/Ethnic|Eastern Europe";
const CString kWorldEthnicIndiaOriental = "World/Ethnic|India/Oriental";
const CString kWorldEthnicNorthAmerica = "World/Ethnic|North America";
const CString kWorldEthnicSouthAmerica = "World/Ethnic|South America";
const CString kWorldEthnicAustralia = "World/Ethnic|Australia";
/*@}*/
};
//------------------------------------------------------------------------
/** Predefined Musical Character */
//------------------------------------------------------------------------
namespace MusicalCharacter
{
/**
\defgroup musicalCharacter Predefined Musical Character */
/*@{*/
//----TYPE------------------------------------
const CString kMono = "Mono";
const CString kPoly = "Poly";
const CString kSplit = "Split";
const CString kLayer = "Layer";
const CString kGlide = "Glide";
const CString kGlissando = "Glissando";
const CString kMajor = "Major";
const CString kMinor = "Minor";
const CString kSingle = "Single";
const CString kEnsemble = "Ensemble";
const CString kAcoustic = "Acoustic";
const CString kElectric = "Electric";
const CString kAnalog = "Analog";
const CString kDigital = "Digital";
const CString kVintage = "Vintage";
const CString kModern = "Modern";
const CString kOld = "Old";
const CString kNew = "New";
//----TONE------------------------------------
const CString kClean = "Clean";
const CString kDistorted = "Distorted";
const CString kDry = "Dry";
const CString kProcessed = "Processed";
const CString kHarmonic = "Harmonic";
const CString kDissonant = "Dissonant";
const CString kClear = "Clear";
const CString kNoisy = "Noisy";
const CString kThin = "Thin";
const CString kRich = "Rich";
const CString kDark = "Dark";
const CString kBright = "Bright";
const CString kCold = "Cold";
const CString kWarm = "Warm";
const CString kMetallic = "Metallic";
const CString kWooden = "Wooden";
const CString kGlass = "Glass";
const CString kPlastic = "Plastic";
//----ENVELOPE------------------------------------
const CString kPercussive = "Percussive";
const CString kSoft = "Soft";
const CString kFast = "Fast";
const CString kSlow = "Slow";
const CString kShort = "Short";
const CString kLong = "Long";
const CString kAttack = "Attack";
const CString kRelease = "Release";
const CString kDecay = "Decay";
const CString kSustain = "Sustain";
const CString kFastAttack = "Fast Attack";
const CString kSlowAttack = "Slow Attack";
const CString kShortRelease = "Short Release";
const CString kLongRelease = "Long Release";
const CString kStatic = "Static";
const CString kMoving = "Moving";
const CString kLoop = "Loop";
const CString kOneShot = "One Shot";
/*@}*/
};
//------------------------------------------------------------------------
} // namespace Vst
} // namespace Steinberg

30
libs/vst3/pluginterfaces/vst/vstpshpack4.h Normal file
View file

@ -0,0 +1,30 @@
//------------------------------------------------------------------------
// 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

825
libs/vst3/pluginterfaces/vst/vstspeaker.h Normal file
View file

@ -0,0 +1,825 @@
//------------------------------------------------------------------------
// Project : VST SDK
//
// Category : Interfaces
// Filename : pluginterfaces/vst/vstspeaker.h
// Created by : Steinberg, 01/2018
// 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 "vsttypes.h"
//#include "pluginterfaces/base/ftype.h"
//------------------------------------------------------------------------
namespace Steinberg {
namespace Vst {
//------------------------------------------------------------------------
/** \defgroup speakerArrangements Speaker Arrangements
\image html "vst3_speaker_types.jpg"
\n
A SpeakerArrangement is a bitset combination of speakers. For example:
\code
const SpeakerArrangement kStereo = kSpeakerL | kSpeakerR; // => hex: 0x03 / binary: 0011.
\endcode*/
//------------------------------------------------------------------------
//------------------------------------------------------------------------
/** Speaker Definitions.
\ingroup speakerArrangements */
//------------------------------------------------------------------------
/**@{*/
const Speaker kSpeakerL = 1 << 0; ///< Left (L)
const Speaker kSpeakerR = 1 << 1; ///< Right (R)
const Speaker kSpeakerC = 1 << 2; ///< Center (C)
const Speaker kSpeakerLfe = 1 << 3; ///< Subbass (Lfe)
const Speaker kSpeakerLs = 1 << 4; ///< Left Surround (Ls)
const Speaker kSpeakerRs = 1 << 5; ///< Right Surround (Rs)
const Speaker kSpeakerLc = 1 << 6; ///< Left of Center (Lc) - Front Left Center
const Speaker kSpeakerRc = 1 << 7; ///< Right of Center (Rc) - Front Right Center
const Speaker kSpeakerS = 1 << 8; ///< Surround (S)
const Speaker kSpeakerCs = kSpeakerS; ///< Center of Surround (Cs) - Back Center - Surround (S)
const Speaker kSpeakerSl = 1 << 9; ///< Side Left (Sl)
const Speaker kSpeakerSr = 1 << 10; ///< Side Right (Sr)
const Speaker kSpeakerTc = 1 << 11; ///< Top Center Over-head, Top Middle (Tc)
const Speaker kSpeakerTfl = 1 << 12; ///< Top Front Left (Tfl)
const Speaker kSpeakerTfc = 1 << 13; ///< Top Front Center (Tfc)
const Speaker kSpeakerTfr = 1 << 14; ///< Top Front Right (Tfr)
const Speaker kSpeakerTrl = 1 << 15; ///< Top Rear/Back Left (Trl)
const Speaker kSpeakerTrc = 1 << 16; ///< Top Rear/Back Center (Trc)
const Speaker kSpeakerTrr = 1 << 17; ///< Top Rear/Back Right (Trr)
const Speaker kSpeakerLfe2 = 1 << 18; ///< Subbass 2 (Lfe2)
const Speaker kSpeakerM = 1 << 19; ///< Mono (M)
const Speaker kSpeakerACN0 = (Speaker)1 << 20; ///< Ambisonic ACN 0
const Speaker kSpeakerACN1 = (Speaker)1 << 21; ///< Ambisonic ACN 1
const Speaker kSpeakerACN2 = (Speaker)1 << 22; ///< Ambisonic ACN 2
const Speaker kSpeakerACN3 = (Speaker)1 << 23; ///< Ambisonic ACN 3
const Speaker kSpeakerACN4 = (Speaker)1 << 38; ///< Ambisonic ACN 4
const Speaker kSpeakerACN5 = (Speaker)1 << 39; ///< Ambisonic ACN 5
const Speaker kSpeakerACN6 = (Speaker)1 << 40; ///< Ambisonic ACN 6
const Speaker kSpeakerACN7 = (Speaker)1 << 41; ///< Ambisonic ACN 7
const Speaker kSpeakerACN8 = (Speaker)1 << 42; ///< Ambisonic ACN 8
const Speaker kSpeakerACN9 = (Speaker)1 << 43; ///< Ambisonic ACN 9
const Speaker kSpeakerACN10 = (Speaker)1 << 44; ///< Ambisonic ACN 10
const Speaker kSpeakerACN11 = (Speaker)1 << 45; ///< Ambisonic ACN 11
const Speaker kSpeakerACN12 = (Speaker)1 << 46; ///< Ambisonic ACN 12
const Speaker kSpeakerACN13 = (Speaker)1 << 47; ///< Ambisonic ACN 13
const Speaker kSpeakerACN14 = (Speaker)1 << 48; ///< Ambisonic ACN 14
const Speaker kSpeakerACN15 = (Speaker)1 << 49; ///< Ambisonic ACN 15
const Speaker kSpeakerTsl = 1 << 24; ///< Top Side Left (Tsl)
const Speaker kSpeakerTsr = 1 << 25; ///< Top Side Right (Tsr)
const Speaker kSpeakerLcs = 1 << 26; ///< Left of Center Surround (Lcs) - Back Left Center
const Speaker kSpeakerRcs = 1 << 27; ///< Right of Center Surround (Rcs) - Back Right Center
const Speaker kSpeakerBfl = 1 << 28; ///< Bottom Front Left (Bfl)
const Speaker kSpeakerBfc = 1 << 29; ///< Bottom Front Center (Bfc)
const Speaker kSpeakerBfr = 1 << 30; ///< Bottom Front Right (Bfr)
const Speaker kSpeakerPl = (Speaker)1 << 31; ///< Proximity Left (Pl)
const Speaker kSpeakerPr = (Speaker)1 << 32; ///< Proximity Right (Pr)
const Speaker kSpeakerBsl = (Speaker)1 << 33; ///< Bottom Side Left (Bsl)
const Speaker kSpeakerBsr = (Speaker)1 << 34; ///< Bottom Side Right (Bsr)
const Speaker kSpeakerBrl = (Speaker)1 << 35; ///< Bottom Rear Left (Brl)
const Speaker kSpeakerBrc = (Speaker)1 << 36; ///< Bottom Rear Center (Brc)
const Speaker kSpeakerBrr = (Speaker)1 << 37; ///< Bottom Rear Right (Brr)
//------------------------------------------------------------------------
/** @}*/
//------------------------------------------------------------------------
/** Speaker Arrangement Definitions (SpeakerArrangement)*/
//------------------------------------------------------------------------
namespace SpeakerArr
{
//------------------------------------------------------------------------
/** Speaker Arrangement Definitions.
\ingroup speakerArrangements */
/*@{*/
const SpeakerArrangement kEmpty = 0; ///< empty arrangement
const SpeakerArrangement kMono = kSpeakerM; ///< M
const SpeakerArrangement kStereo = kSpeakerL | kSpeakerR; ///< L R
const SpeakerArrangement kStereoSurround = kSpeakerLs | kSpeakerRs; ///< Ls Rs
const SpeakerArrangement kStereoCenter = kSpeakerLc | kSpeakerRc; ///< Lc Rc
const SpeakerArrangement kStereoSide = kSpeakerSl | kSpeakerSr; ///< Sl Sr
const SpeakerArrangement kStereoCLfe = kSpeakerC | kSpeakerLfe; ///< C Lfe
const SpeakerArrangement kStereoTF = kSpeakerTfl | kSpeakerTfr; ///< Tfl Tfr
const SpeakerArrangement kStereoTS = kSpeakerTsl | kSpeakerTsr; ///< Tsl Tsr
const SpeakerArrangement kStereoTR = kSpeakerTrl | kSpeakerTrr; ///< Trl Trr
const SpeakerArrangement kStereoBF = kSpeakerBfl | kSpeakerBfr; ///< Bfl Bfr
/** L R C */
const SpeakerArrangement k30Cine = kSpeakerL | kSpeakerR | kSpeakerC;
/** L R S */
const SpeakerArrangement k30Music = kSpeakerL | kSpeakerR | kSpeakerS;
/** L R C Lfe */
const SpeakerArrangement k31Cine = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe;
/** L R Lfe S */
const SpeakerArrangement k31Music = kSpeakerL | kSpeakerR | kSpeakerLfe | kSpeakerS;
/** L R C S (LCRS) */
const SpeakerArrangement k40Cine = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerS;
/** L R Ls Rs (Quadro) */
const SpeakerArrangement k40Music = kSpeakerL | kSpeakerR | kSpeakerLs | kSpeakerRs;
/** L R C Lfe S (LCRS+Lfe) */
const SpeakerArrangement k41Cine = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerS;
/** L R Lfe Ls Rs (Quadro+Lfe) */
const SpeakerArrangement k41Music = kSpeakerL | kSpeakerR | kSpeakerLfe | kSpeakerLs | kSpeakerRs;
/** L R C Ls Rs */
const SpeakerArrangement k50 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLs | kSpeakerRs;
/** L R C Lfe Ls Rs */
const SpeakerArrangement k51 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs;
/** L R C Ls Rs Cs */
const SpeakerArrangement k60Cine = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLs | kSpeakerRs | kSpeakerCs;
/** L R Ls Rs Sl Sr */
const SpeakerArrangement k60Music = kSpeakerL | kSpeakerR | kSpeakerLs | kSpeakerRs | kSpeakerSl | kSpeakerSr;
/** L R C Lfe Ls Rs Cs */
const SpeakerArrangement k61Cine = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerCs;
/** L R Lfe Ls Rs Sl Sr */
const SpeakerArrangement k61Music = kSpeakerL | kSpeakerR | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerSl | kSpeakerSr;
/** L R C Ls Rs Lc Rc */
const SpeakerArrangement k70Cine = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLs | kSpeakerRs | kSpeakerLc | kSpeakerRc;
/** L R C Ls Rs Sl Sr */
const SpeakerArrangement k70Music = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLs | kSpeakerRs | kSpeakerSl | kSpeakerSr;
/** L R C Lfe Ls Rs Lc Rc */
const SpeakerArrangement k71Cine = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerLc | kSpeakerRc;
const SpeakerArrangement k71CineFullFront= k71Cine;
/** L R C Lfe Ls Rs Lcs Rcs */
const SpeakerArrangement k71CineFullRear = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerLcs | kSpeakerRcs;
/** L R C Lfe Ls Rs Sl Sr */
const SpeakerArrangement k71Music = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerSl | kSpeakerSr;
const SpeakerArrangement k71CineSideFill = k71Music;
/** L R C Lfe Ls Rs Pl Pr */
const SpeakerArrangement k71Proximity = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerPl | kSpeakerPr;
/** L R C Ls Rs Lc Rc Cs */
const SpeakerArrangement k80Cine = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLs | kSpeakerRs | kSpeakerLc | kSpeakerRc | kSpeakerCs;
/** L R C Ls Rs Cs Sl Sr */
const SpeakerArrangement k80Music = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLs | kSpeakerRs | kSpeakerCs | kSpeakerSl | kSpeakerSr;
/** L R C Lfe Ls Rs Lc Rc Cs */
const SpeakerArrangement k81Cine = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerLc | kSpeakerRc | kSpeakerCs;
/** L R C Lfe Ls Rs Cs Sl Sr */
const SpeakerArrangement k81Music = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerCs | kSpeakerSl | kSpeakerSr;
/** First-Order with Ambisonic Channel Number (ACN) ordering and SN3D normalization */
const SpeakerArrangement kAmbi1stOrderACN = kSpeakerACN0 | kSpeakerACN1 | kSpeakerACN2 | kSpeakerACN3;
/** Second-Order with Ambisonic Channel Number (ACN) ordering and SN3D normalization */
const SpeakerArrangement kAmbi2cdOrderACN = kAmbi1stOrderACN | kSpeakerACN4 | kSpeakerACN5 | kSpeakerACN6 | kSpeakerACN7 | kSpeakerACN8;
/** Third-Order with Ambisonic Channel Number (ACN) ordering and SN3D normalization */
const SpeakerArrangement kAmbi3rdOrderACN = kAmbi2cdOrderACN | kSpeakerACN9 | kSpeakerACN10 | kSpeakerACN11 | kSpeakerACN12 | kSpeakerACN13 | kSpeakerACN14 | kSpeakerACN15;
/*-----------*/
/* 3D formats */
/*-----------*/
/** L R Ls Rs Tfl Tfr Trl Trr */
const SpeakerArrangement k80Cube = kSpeakerL | kSpeakerR | kSpeakerLs | kSpeakerRs | kSpeakerTfl| kSpeakerTfr| kSpeakerTrl | kSpeakerTrr;
/** L R C Lfe Ls Rs Cs Tc */
const SpeakerArrangement k71CineTopCenter = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerCs | kSpeakerTc;
/** L R C Lfe Ls Rs Cs Tfc */
const SpeakerArrangement k71CineCenterHigh = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerCs | kSpeakerTfc;
/** L R C Lfe Ls Rs Tfl Tfr */
const SpeakerArrangement k71CineFrontHigh = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerTfl | kSpeakerTfr;
const SpeakerArrangement k71MPEG3D = k71CineFrontHigh;
/** L R C Lfe Ls Rs Tsl Tsr */
const SpeakerArrangement k71CineSideHigh = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerTsl | kSpeakerTsr;
/** L R Lfe Ls Rs Tfl Tfc Tfr Bfc */
const SpeakerArrangement k81MPEG3D = kSpeakerL | kSpeakerR | kSpeakerLfe | kSpeakerLs | kSpeakerRs |
kSpeakerTfl | kSpeakerTfc | kSpeakerTfr | kSpeakerBfc;
/** L R C Ls Rs Tfl Tfr Trl Trr */
const SpeakerArrangement k90 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLs | kSpeakerRs |
kSpeakerTfl| kSpeakerTfr | kSpeakerTrl | kSpeakerTrr;
const SpeakerArrangement k50_4 = k90;
/** L R C Lfe Ls Rs Tfl Tfr Trl Trr */
const SpeakerArrangement k91 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs |
kSpeakerTfl| kSpeakerTfr | kSpeakerTrl | kSpeakerTrr;
const SpeakerArrangement k51_4 = k91;
/** L R C Lfe Ls Rs Sl Sr Tsl Tsr */
const SpeakerArrangement k71_2 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs |
kSpeakerRs | kSpeakerSl | kSpeakerSr | kSpeakerTsl | kSpeakerTsr;
const SpeakerArrangement k91Atmos = k71_2;
/** L R C Ls Rs Tc Tfl Tfr Trl Trr */
const SpeakerArrangement k100 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLs | kSpeakerRs |
kSpeakerTc | kSpeakerTfl | kSpeakerTfr | kSpeakerTrl | kSpeakerTrr;
/** L R C Lfe Ls Rs Tc Tfl Tfr Trl Trr */
const SpeakerArrangement k101 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs |
kSpeakerTc | kSpeakerTfl | kSpeakerTfr | kSpeakerTrl | kSpeakerTrr;
const SpeakerArrangement k101MPEG3D = k101;
/** L R C Lfe Ls Rs Tfl Tfc Tfr Trl Trr Lfe2 */
const SpeakerArrangement k102 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs |
kSpeakerTfl| kSpeakerTfc | kSpeakerTfr | kSpeakerTrl | kSpeakerTrr | kSpeakerLfe2;
/** L R C Ls Rs Tc Tfl Tfc Tfr Trl Trr */
const SpeakerArrangement k110 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLs | kSpeakerRs |
kSpeakerTc | kSpeakerTfl | kSpeakerTfc | kSpeakerTfr | kSpeakerTrl | kSpeakerTrr;
/** L R C Lfe Ls Rs Tc Tfl Tfc Tfr Trl Trr */
const SpeakerArrangement k111 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs |
kSpeakerTc | kSpeakerTfl | kSpeakerTfc | kSpeakerTfr | kSpeakerTrl | kSpeakerTrr;
/** L R C Ls Rs Sl Sr Tfl Tfr Trl Trr */
const SpeakerArrangement k70_4 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLs | kSpeakerRs | kSpeakerSl | kSpeakerSr |
kSpeakerTfl | kSpeakerTfr | kSpeakerTrl | kSpeakerTrr;
/** L R C Lfe Ls Rs Sl Sr Tfl Tfr Trl Trr */
const SpeakerArrangement k71_4 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerSl | kSpeakerSr |
kSpeakerTfl | kSpeakerTfr | kSpeakerTrl | kSpeakerTrr;
const SpeakerArrangement k111MPEG3D = k71_4;
/** L R C Lfe Ls Rs Lc Rc Tfl Tfc Tfr Trl Trr Lfe2 */
const SpeakerArrangement k122 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerLc | kSpeakerRc |
kSpeakerTfl| kSpeakerTfc | kSpeakerTfr | kSpeakerTrl | kSpeakerTrr | kSpeakerLfe2;
/** L R C Ls Rs Sl Sr Tc Tfl Tfc Tfr Trl Trr */
const SpeakerArrangement k130 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLs | kSpeakerRs | kSpeakerSl | kSpeakerSr |
kSpeakerTc | kSpeakerTfl | kSpeakerTfc | kSpeakerTfr | kSpeakerTrl | kSpeakerTrr;
/** L R C Lfe Ls Rs Sl Sr Tc Tfl Tfc Tfr Trl Trr */
const SpeakerArrangement k131 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerSl | kSpeakerSr |
kSpeakerTc | kSpeakerTfl | kSpeakerTfc | kSpeakerTfr | kSpeakerTrl | kSpeakerTrr;
/** L R Ls Rs Sl Sr Tfl Tfr Trl Trr Bfl Bfr Brl Brr */
const SpeakerArrangement k140 = kSpeakerL | kSpeakerR | kSpeakerLs | kSpeakerRs | kSpeakerSl | kSpeakerSr |
kSpeakerTfl | kSpeakerTfr | kSpeakerTrl | kSpeakerTrr |
kSpeakerBfl | kSpeakerBfr | kSpeakerBrl | kSpeakerBrr;
/** L R C Lfe Ls Rs Lc Rc Cs Sl Sr Tc Tfl Tfc Tfr Trl Trc Trr Lfe2 Tsl Tsr Bfl Bfc Bfr */
const SpeakerArrangement k222 = kSpeakerL | kSpeakerR | kSpeakerC | kSpeakerLfe | kSpeakerLs | kSpeakerRs | kSpeakerLc | kSpeakerRc | kSpeakerCs | kSpeakerSl | kSpeakerSr |
kSpeakerTc | kSpeakerTfl | kSpeakerTfc | kSpeakerTfr | kSpeakerTrl | kSpeakerTrc | kSpeakerTrr | kSpeakerLfe2 | kSpeakerTsl | kSpeakerTsr |
kSpeakerBfl| kSpeakerBfc | kSpeakerBfr;
//------------------------------------------------------------------------
/** Speaker Arrangement String Representation.
\ingroup speakerArrangements */
/*@{*/
const CString kStringEmpty = "";
const CString kStringMono = "Mono";
const CString kStringStereo = "Stereo";
const CString kStringStereoR = "Stereo (Ls Rs)";
const CString kStringStereoC = "Stereo (Lc Rc)";
const CString kStringStereoSide = "Stereo (Sl Sr)";
const CString kStringStereoCLfe = "Stereo (C LFE)";
const CString kStringStereoTF = "Stereo (Tfl Tfr)";
const CString kStringStereoTS = "Stereo (Tsl Tsr)";
const CString kStringStereoTR = "Stereo (Trl Trr)";
const CString kStringStereoBF = "Stereo (Bfl Bfr)";
const CString kString30Cine = "LRC";
const CString kString30Music = "LRS";
const CString kString31Cine = "LRC+LFE";
const CString kString31Music = "LRS+LFE";
const CString kString40Cine = "LRCS";
const CString kString40Music = "Quadro";
const CString kString41Cine = "LRCS+LFE";
const CString kString41Music = "Quadro+LFE";
const CString kString50 = "5.0";
const CString kString51 = "5.1";
const CString kString60Cine = "6.0 Cine";
const CString kString60Music = "6.0 Music";
const CString kString61Cine = "6.1 Cine";
const CString kString61Music = "6.1 Music";
const CString kString70Cine = "7.0 Cine (SDDS)";
const CString kString70Music = "7.0 Music (Dolby)";
const CString kString71Cine = "7.1 Cine (SDDS)";
const CString kString71Music = "7.1 Music (Dolby)";
const CString kString71CineTopCenter = "7.1 Cine Top Center";
const CString kString71CineCenterHigh = "7.1 Cine Center High";
const CString kString71CineFrontHigh = "7.1 Cine Front High";
const CString kString71CineSideHigh = "7.1 Cine Side High";
const CString kString71CineFullRear = "7.1 Cine Full Rear";
const CString kString71Proximity = "7.1 Proximity";
const CString kString80Cine = "8.0 Cine";
const CString kString80Music = "8.0 Music";
const CString kString80Cube = "8.0 Cube";
const CString kString81Cine = "8.1 Cine";
const CString kString81Music = "8.1 Music";
const CString kString102 = "10.2 Experimental";
const CString kString122 = "12.2";
const CString kString50_4 = "5.0.4";
const CString kString51_4 = "5.1.4";
const CString kString91Atmos = "9.1 Dolby Atmos";
const CString kString100 = "10.0 Auro-3D";
const CString kString101 = "10.1 Auro-3D";
const CString kString110 = "11.0 Auro-3D";
const CString kString111 = "11.1 Auro-3D";
const CString kString130 = "13.0 Auro-3D";
const CString kString131 = "13.1 Auro-3D";
const CString kString81MPEG = "8.1 MPEG";
const CString kString70_4 = "7.0.4";
const CString kString71_4 = "7.1.4";
const CString kString140 = "14.0";
const CString kString222 = "22.2";
const CString kStringAmbi1stOrder = "1st Order Ambisonics";
const CString kStringAmbi2cdOrder = "2nd Order Ambisonics";
const CString kStringAmbi3rdOrder = "3rd Order Ambisonics";
/*@}*/
//------------------------------------------------------------------------
/** Speaker Arrangement String Representation with Speakers Name.
\ingroup speakerArrangements */
/*@{*/
const CString kStringMonoS = "M";
const CString kStringStereoS = "L R";
const CString kStringStereoRS = "Ls Rs";
const CString kStringStereoCS = "Lc Rc";
const CString kStringStereoSS = "Sl Sr";
const CString kStringStereoCLfeS= "C LFE";
const CString kStringStereoTFS = "Tfl Tfr";
const CString kStringStereoTSS = "Tsl Tsr";
const CString kStringStereoTRS = "Trl Trr";
const CString kStringStereoBFS = "Bfl Bfr";
const CString kString30CineS = "L R C";
const CString kString30MusicS = "L R S";
const CString kString31CineS = "L R C LFE";
const CString kString31MusicS = "L R LFE S";
const CString kString40CineS = "L R C S";
const CString kString40MusicS = "L R Ls Rs";
const CString kString41CineS = "L R C LFE S";
const CString kString41MusicS = "L R LFE Ls Rs";
const CString kString50S = "L R C Ls Rs";
const CString kString51S = "L R C LFE Ls Rs";
const CString kString60CineS = "L R C Ls Rs Cs";
const CString kString60MusicS = "L R Ls Rs Sl Sr";
const CString kString61CineS = "L R C LFE Ls Rs Cs";
const CString kString61MusicS = "L R LFE Ls Rs Sl Sr";
const CString kString70CineS = "L R C Ls Rs Lc Rc";
const CString kString70MusicS = "L R C Ls Rs Sl Sr";
const CString kString71CineS = "L R C LFE Ls Rs Lc Rc";
const CString kString71MusicS = "L R C LFE Ls Rs Sl Sr";
const CString kString80CineS = "L R C Ls Rs Lc Rc Cs";
const CString kString80MusicS = "L R C Ls Rs Cs Sl Sr";
const CString kString81CineS = "L R C LFE Ls Rs Lc Rc Cs";
const CString kString81MusicS = "L R C LFE Ls Rs Cs Sl Sr";
const CString kString80CubeS = "L R Ls Rs Tfl Tfr Trl Trr";
const CString kString71CineTopCenterS = "L R C LFE Ls Rs Cs Tc";
const CString kString71CineCenterHighS = "L R C LFE Ls Rs Cs Tfc";
const CString kString71CineFrontHighS = "L R C LFE Ls Rs Tfl Tfl";
const CString kString71CineSideHighS = "L R C LFE Ls Rs Tsl Tsl";
const CString kString71CineFullRearS = "L R C LFE Ls Rs Lcs Rcs";
const CString kString71ProximityS = "L R C LFE Ls Rs Pl Pr";
const CString kString50_4S = "L R C Ls Rs Tfl Tfr Trl Trr";
const CString kString51_4S = "L R C LFE Ls Rs Tfl Tfr Trl Trr";
const CString kString91AtmosS = "L R C LFE Ls Rs Sl Sr Tsl Tsr";
const CString kString100S = "L R C Ls Rs Tc Tfl Tfr Trl Trr";
const CString kString101S = "L R C LFE Ls Rs Tc Tfl Tfr Trl Trr";
const CString kString110S = "L R C Ls Rs Tc Tfl Tfc Tfr Trl Trr";
const CString kString111S = "L R C LFE Ls Rs Tc Tfl Tfc Tfr Trl Trr";
const CString kStringk70_4S = "L R C Ls Rs Sl Sr Tfl Tfr Trl Trr";
const CString kStringk71_4S = "L R C LFE Ls Rs Sl Sr Tfl Tfr Trl Trr";
const CString kString130S = "L R C Ls Rs Sl Sr Tc Tfl Tfc Tfr Trl Trr";
const CString kString131S = "L R C LFE Ls Rs Sl Sr Tc Tfl Tfc Tfr Trl Trr";
const CString kString102S = "L R C LFE Ls Rs Tfl Tfc Tfr Trl Trr LFE2";
const CString kString122S = "L R C LFE Ls Rs Lc Rc Tfl Tfc Tfr Trl Trr LFE2";
const CString kString81MPEGS = "L R LFE Ls Rs Tfl Tfc Tfr Bfc";
const CString kString140S = "L R Ls Rs Sl Sr Tfl Tfr Trl Trr Bfl Bfr Brl Brr";
const CString kString222S = "L R C LFE Ls Rs Lc Rc Cs Sl Sr Tc Tfl Tfc Tfr Trl Trc Trr LFE2 Tsl Tsr Bfl Bfc Bfr";
const CString kStringAmbi1stOrderS = "0 1 2 3";
const CString kStringAmbi2cdOrderS = "0 1 2 3 4 5 6 7 8";
const CString kStringAmbi3rdOrderS = "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15";
/*@}*/
//------------------------------------------------------------------------
/** Returns number of channels used in speaker arrangement.
\ingroup speakerArrangements */
/*@{*/
inline int32 getChannelCount (SpeakerArrangement arr)
{
int32 count = 0;
while (arr)
{
if (arr & (SpeakerArrangement)1)
++count;
arr >>= 1;
}
return count;
}
//------------------------------------------------------------------------
/** Returns the index of a given speaker in a speaker arrangement (-1 if speaker is not part of the
* arrangement). */
inline int32 getSpeakerIndex (Speaker speaker, SpeakerArrangement arrangement)
{
// check if speaker is present in arrangement
if ((arrangement & speaker) == 0)
return -1;
int32 result = 0;
Speaker i = 1;
while (i < speaker)
{
if (arrangement & i)
result++;
i <<= 1;
}
return result;
}
//------------------------------------------------------------------------
/** Returns the speaker for a given index in a speaker arrangement (return 0 when out of range). */
inline Speaker getSpeaker (const SpeakerArrangement& arr, int32 index)
{
SpeakerArrangement arrTmp = arr;
int32 index2 = -1;
int32 pos = -1;
while (arrTmp)
{
if (arrTmp & 0x1)
index2++;
pos++;
if (index2 == index)
return (Speaker)1 << pos;
arrTmp = arrTmp >> 1;
}
return 0;
}
//------------------------------------------------------------------------
/** Returns true if arrSubSet is a subset speaker of arr (means each speaker of arrSubSet is
* included in arr). */
inline bool isSubsetOf (const SpeakerArrangement& arrSubSet, const SpeakerArrangement& arr)
{
return (arrSubSet == (arrSubSet & arr));
}
//------------------------------------------------------------------------
/** Returns true if arrangement is a Auro configuration. */
inline bool isAuro (const SpeakerArrangement& arr)
{
if (arr == k90 || arr == k91 || arr == k100 || arr == k101 || arr == k110 || arr == k111 ||
arr == k130 || arr == k131)
{
return true;
}
return false;
}
//------------------------------------------------------------------------
/** Returns true if arrangement is a Auro configuration. */
inline bool isAmbisonics (const SpeakerArrangement& arr)
{
if (arr == kAmbi1stOrderACN || arr == kAmbi2cdOrderACN || arr == kAmbi3rdOrderACN)
{
return true;
}
return false;
}
//------------------------------------------------------------------------
/** Returns the speaker arrangement associated to a string representation.
Returns kEmpty if no associated arrangement is known.
*/
inline SpeakerArrangement getSpeakerArrangementFromString (CString arrStr)
{
if (!strcmp8 (arrStr, kStringMono))
return kMono;
if (!strcmp8 (arrStr, kStringStereo))
return kStereo;
if (!strcmp8 (arrStr, kStringStereoR))
return kStereoSurround;
if (!strcmp8 (arrStr, kStringStereoC))
return kStereoCenter;
if (!strcmp8 (arrStr, kStringStereoSide))
return kStereoSide;
if (!strcmp8 (arrStr, kStringStereoCLfe))
return kStereoCLfe;
if (!strcmp8 (arrStr, kStringStereoTF))
return kStereoTF;
if (!strcmp8 (arrStr, kStringStereoTS))
return kStereoTS;
if (!strcmp8 (arrStr, kStringStereoTR))
return kStereoTR;
if (!strcmp8 (arrStr, kStringStereoBF))
return kStereoBF;
if (!strcmp8 (arrStr, kString30Cine))
return k30Cine;
if (!strcmp8 (arrStr, kString30Music))
return k30Music;
if (!strcmp8 (arrStr, kString31Cine))
return k31Cine;
if (!strcmp8 (arrStr, kString31Music))
return k31Music;
if (!strcmp8 (arrStr, kString40Cine))
return k40Cine;
if (!strcmp8 (arrStr, kString40Music))
return k40Music;
if (!strcmp8 (arrStr, kString41Cine))
return k41Cine;
if (!strcmp8 (arrStr, kString41Music))
return k41Music;
if (!strcmp8 (arrStr, kString50))
return k50;
if (!strcmp8 (arrStr, kString51))
return k51;
if (!strcmp8 (arrStr, kString60Cine))
return k60Cine;
if (!strcmp8 (arrStr, kString60Music))
return k60Music;
if (!strcmp8 (arrStr, kString61Cine))
return k61Cine;
if (!strcmp8 (arrStr, kString61Music))
return k61Music;
if (!strcmp8 (arrStr, kString70Cine))
return k70Cine;
if (!strcmp8 (arrStr, kString70Music))
return k70Music;
if (!strcmp8 (arrStr, kString71Cine))
return k71Cine;
if (!strcmp8 (arrStr, kString71Music))
return k71Music;
if (!strcmp8 (arrStr, kString71Proximity))
return k71Proximity;
if (!strcmp8 (arrStr, kString80Cine))
return k80Cine;
if (!strcmp8 (arrStr, kString80Music))
return k80Music;
if (!strcmp8 (arrStr, kString81Cine))
return k81Cine;
if (!strcmp8 (arrStr, kString81Music))
return k81Music;
if (!strcmp8 (arrStr, kString102))
return k102;
if (!strcmp8 (arrStr, kString122))
return k122;
if (!strcmp8 (arrStr, kString80Cube))
return k80Cube;
if (!strcmp8 (arrStr, kString71CineTopCenter))
return k71CineTopCenter;
if (!strcmp8 (arrStr, kString71CineCenterHigh))
return k71CineCenterHigh;
if (!strcmp8 (arrStr, kString71CineFrontHigh))
return k71CineFrontHigh;
if (!strcmp8 (arrStr, kString71CineSideHigh))
return k71CineSideHigh;
if (!strcmp8 (arrStr, kString71CineFullRear))
return k71CineFullRear;
if (!strcmp8 (arrStr, kString50_4))
return k50_4;
if (!strcmp8 (arrStr, kString51_4))
return k51_4;
if (!strcmp8 (arrStr, kString81MPEG))
return k81MPEG3D;
if (!strcmp8 (arrStr, kString91Atmos))
return k91Atmos;
if (!strcmp8 (arrStr, kString100))
return k100;
if (!strcmp8 (arrStr, kString101))
return k101;
if (!strcmp8 (arrStr, kString110))
return k110;
if (!strcmp8 (arrStr, kString111))
return k111;
if (!strcmp8 (arrStr, kString70_4))
return k70_4;
if (!strcmp8 (arrStr, kString71_4))
return k71_4;
if (!strcmp8 (arrStr, kString130))
return k130;
if (!strcmp8 (arrStr, kString131))
return k131;
if (!strcmp8 (arrStr, kString140))
return k140;
if (!strcmp8 (arrStr, kString222))
return k222;
if (!strcmp8 (arrStr, kStringAmbi1stOrder))
return kAmbi1stOrderACN;
if (!strcmp8 (arrStr, kStringAmbi2cdOrder))
return kAmbi2cdOrderACN;
if (!strcmp8 (arrStr, kStringAmbi3rdOrder))
return kAmbi3rdOrderACN;
return kEmpty;
}
//------------------------------------------------------------------------
/** Returns the string representation of a given speaker arrangement.
Returns kStringEmpty if arr is unknown.
*/
inline CString getSpeakerArrangementString (SpeakerArrangement arr, bool withSpeakersName)
{
switch (arr)
{
case kMono: return withSpeakersName ? kStringMonoS : kStringMono;
case kStereo: return withSpeakersName ? kStringStereoS : kStringStereo;
case kStereoSurround: return withSpeakersName ? kStringStereoRS : kStringStereoR;
case kStereoCenter: return withSpeakersName ? kStringStereoCS : kStringStereoC;
case kStereoSide: return withSpeakersName ? kStringStereoSS : kStringStereoSide;
case kStereoCLfe: return withSpeakersName ? kStringStereoCLfeS: kStringStereoCLfe;
case kStereoTF: return withSpeakersName ? kStringStereoTFS : kStringStereoTF;
case kStereoTS: return withSpeakersName ? kStringStereoTSS : kStringStereoTS;
case kStereoTR: return withSpeakersName ? kStringStereoTRS : kStringStereoTR;
case kStereoBF: return withSpeakersName ? kStringStereoBFS : kStringStereoBF;
case k30Cine: return withSpeakersName ? kString30CineS : kString30Cine;
case k30Music: return withSpeakersName ? kString30MusicS : kString30Music;
case k31Cine: return withSpeakersName ? kString31CineS : kString31Cine;
case k31Music: return withSpeakersName ? kString31MusicS : kString31Music;
case k40Cine: return withSpeakersName ? kString40CineS : kString40Cine;
case k40Music: return withSpeakersName ? kString40MusicS : kString40Music;
case k41Cine: return withSpeakersName ? kString41CineS : kString41Cine;
case k41Music: return withSpeakersName ? kString41MusicS : kString41Music;
case k50: return withSpeakersName ? kString50S : kString50;
case k51: return withSpeakersName ? kString51S : kString51;
case k60Cine: return withSpeakersName ? kString60CineS : kString60Cine;
case k60Music: return withSpeakersName ? kString60MusicS : kString60Music;
case k61Cine: return withSpeakersName ? kString61CineS : kString61Cine;
case k61Music: return withSpeakersName ? kString61MusicS : kString61Music;
case k70Cine: return withSpeakersName ? kString70CineS : kString70Cine;
case k70Music: return withSpeakersName ? kString70MusicS : kString70Music;
case k71Cine: return withSpeakersName ? kString71CineS : kString71Cine;
case k71Music: return withSpeakersName ? kString71MusicS : kString71Music;
case k71Proximity: return withSpeakersName ? kString71ProximityS : kString71Proximity;
case k80Cine: return withSpeakersName ? kString80CineS : kString80Cine;
case k80Music: return withSpeakersName ? kString80MusicS : kString80Music;
case k81Cine: return withSpeakersName ? kString81CineS : kString81Cine;
case k81Music: return withSpeakersName ? kString81MusicS : kString81Music;
case k81MPEG3D: return withSpeakersName ? kString81MPEGS : kString81MPEG;
case k102: return withSpeakersName ? kString102S : kString102;
case k122: return withSpeakersName ? kString122S : kString122;
case k80Cube: return withSpeakersName ? kString80CubeS : kString80Cube;
case k71CineTopCenter: return withSpeakersName ? kString71CineTopCenterS : kString71CineTopCenter;
case k71CineCenterHigh: return withSpeakersName ? kString71CineCenterHighS : kString71CineCenterHigh;
case k71CineFrontHigh: return withSpeakersName ? kString71CineFrontHighS : kString71CineFrontHigh;
case k71CineSideHigh: return withSpeakersName ? kString71CineSideHighS : kString71CineSideHigh;
case k71CineFullRear: return withSpeakersName ? kString71CineFullRearS : kString71CineFullRear;
case k91Atmos: return withSpeakersName ? kString91AtmosS : kString91Atmos;
case k100: return withSpeakersName ? kString100S : kString100;
case k101: return withSpeakersName ? kString101S : kString101;
case k110: return withSpeakersName ? kString110S : kString110;
case k111: return withSpeakersName ? kString111S : kString111;
case k50_4: return withSpeakersName ? kString50_4S : kString50_4;
case k51_4: return withSpeakersName ? kString51_4S : kString51_4;
case k70_4: return withSpeakersName ? kStringk70_4S : kString70_4;
case k71_4: return withSpeakersName ? kStringk71_4S : kString71_4;
case k130: return withSpeakersName ? kString130S : kString130;
case k131: return withSpeakersName ? kString131S : kString131;
case k140: return withSpeakersName ? kString140S : kString140;
case k222: return withSpeakersName ? kString222S : kString222;
break;
}
if (arr == kAmbi1stOrderACN)
return withSpeakersName ? kStringAmbi1stOrderS : kStringAmbi1stOrder;
if (arr == kAmbi2cdOrderACN)
return withSpeakersName ? kStringAmbi2cdOrderS : kStringAmbi2cdOrder;
if (arr == kAmbi3rdOrderACN)
return withSpeakersName ? kStringAmbi3rdOrderS : kStringAmbi3rdOrder;
return kStringEmpty;
}
//------------------------------------------------------------------------
/** Returns a CString representation of a given speaker in a given arrangement
*/
inline CString getSpeakerShortName (const SpeakerArrangement& arr, int32 index)
{
SpeakerArrangement arrTmp = arr;
bool found = false;
int32 index2 = -1;
int32 pos = -1;
while (arrTmp)
{
if (arrTmp & 0x1)
index2++;
pos++;
if (index2 == index)
{
found = true;
break;
}
arrTmp = arrTmp >> 1;
}
if (!found)
return "";
Speaker speaker = (Speaker)1 << pos;
if (speaker == kSpeakerL)
return "L";
if (speaker == kSpeakerR)
return "R";
if (speaker == kSpeakerC)
return "C";
if (speaker == kSpeakerLfe)
return "LFE";
if (speaker == kSpeakerLs)
return "Ls";
if (speaker == kSpeakerRs)
return "Rs";
if (speaker == kSpeakerLc)
return "Lc";
if (speaker == kSpeakerRc)
return "Rc";
if (speaker == kSpeakerS)
return "S";
if (speaker == kSpeakerSl)
return "Sl";
if (speaker == kSpeakerSr)
return "Sr";
if (speaker == kSpeakerTc)
return "Tc";
if (speaker == kSpeakerTfl)
return "Tfl";
if (speaker == kSpeakerTfc)
return "Tfc";
if (speaker == kSpeakerTfr)
return "Tfr";
if (speaker == kSpeakerTrl)
return "Trl";
if (speaker == kSpeakerTrc)
return "Trc";
if (speaker == kSpeakerTrr)
return "Trr";
if (speaker == kSpeakerLfe2)
return "LFE2";
if (speaker == kSpeakerM)
return "M";
if (speaker == kSpeakerACN0)
return "0";
if (speaker == kSpeakerACN1)
return "1";
if (speaker == kSpeakerACN2)
return "2";
if (speaker == kSpeakerACN3)
return "3";
if (speaker == kSpeakerACN4)
return "4";
if (speaker == kSpeakerACN5)
return "5";
if (speaker == kSpeakerACN6)
return "6";
if (speaker == kSpeakerACN7)
return "7";
if (speaker == kSpeakerACN8)
return "8";
if (speaker == kSpeakerACN9)
return "9";
if (speaker == kSpeakerACN10)
return "10";
if (speaker == kSpeakerACN11)
return "11";
if (speaker == kSpeakerACN12)
return "12";
if (speaker == kSpeakerACN13)
return "13";
if (speaker == kSpeakerACN14)
return "14";
if (speaker == kSpeakerACN15)
return "15";
if (speaker == kSpeakerTsl)
return "Tsl";
if (speaker == kSpeakerTsr)
return "Tsr";
if (speaker == kSpeakerLcs)
return "Lcs";
if (speaker == kSpeakerRcs)
return "Rcs";
if (speaker == kSpeakerBfl)
return "Bfl";
if (speaker == kSpeakerBfc)
return "Bfc";
if (speaker == kSpeakerBfr)
return "Bfr";
if (speaker == kSpeakerPl)
return "Pl";
if (speaker == kSpeakerPr)
return "Pr";
if (speaker == kSpeakerBsl)
return "Bsl";
if (speaker == kSpeakerBsr)
return "Bsr";
if (speaker == kSpeakerBrl)
return "Brl";
if (speaker == kSpeakerBrc)
return "Brc";
if (speaker == kSpeakerBrr)
return "Brr";
return "";
}
/*@}*/
//------------------------------------------------------------------------
} // namespace SpeakerArr
} // namespace Vst
} // namespace Steinberg

86
libs/vst3/pluginterfaces/vst/vsttypes.h Normal file
View file

@ -0,0 +1,86 @@
//------------------------------------------------------------------------
// 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 {
//------------------------------------------------------------------------
#ifndef kVstVersionString
#define kVstVersionString "VST 3.6.13" ///< SDK version for PClassInfo2
#endif
#define kVstVersionMajor 3
#define kVstVersionMinor 6
#define kVstVersionSub 13
// this allows to write things like: #if VST_VERSION >= 0x030500 // note that 3.10.0 is 0x030a00
#define VST_VERSION ((kVstVersionMajor << 16) | (kVstVersionMinor << 8) | kVstVersionSub)
//------------------------------------------------------------------------
/** \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

71
libs/vst3/vst3.h Normal file
View file

@ -0,0 +1,71 @@
/* VST3 interface
* This is a subset of https://github.com/steinbergmedia/vst3sdk/
* which should be sufficient to implement a VST3 plugin host.
*
* Compat check:
* g++ -std=c++98 -c -o /tmp/vst3.o -I libs/vst3/ libs/vst3/vst3.h
*
* GPLv3
*/
#ifndef _VST3_HEADERS_
#define _VST3_HEADERS_
#if defined(__clang__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wnon-virtual-dtor"
#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
#endif
#if (__cplusplus < 201103L)
# define nullptr 0
#endif
#include "pluginterfaces/base/ftypes.h"
#include "pluginterfaces/base/funknown.h"
#include "pluginterfaces/base/ipluginbase.h"
#include "pluginterfaces/base/ibstream.h"
#include "pluginterfaces/vst/ivstattributes.h"
#include "pluginterfaces/vst/ivstaudioprocessor.h"
#include "pluginterfaces/vst/ivstautomationstate.h"
#include "pluginterfaces/vst/ivstchannelcontextinfo.h"
#include "pluginterfaces/vst/ivstcomponent.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/ivstmidicontrollers.h"
//#include "pluginterfaces/vst/ivstmidilearn.h"
//#include "pluginterfaces/vst/ivstnoteexpression.h"
#include "pluginterfaces/vst/ivstparameterchanges.h"
//#include "pluginterfaces/vst/ivstphysicalui.h"
#include "pluginterfaces/vst/ivstpluginterfacesupport.h"
//#include "pluginterfaces/vst/ivstplugview.h"
//#include "pluginterfaces/vst/ivstprefetchablesupport.h"
#include "pluginterfaces/vst/ivstprocesscontext.h"
//#include "pluginterfaces/vst/ivstrepresentation.h"
//#include "pluginterfaces/vst/ivsttestplugprovider.h"
#include "pluginterfaces/vst/ivstunits.h"
//#include "pluginterfaces/vst/vstpresetkeys.h"
//#include "pluginterfaces/vst/vstpshpack4.h"
//#include "pluginterfaces/vst/vstspeaker.h"
#include "pluginterfaces/vst/vsttypes.h"
#include "pluginterfaces/gui/iplugview.h"
//#include "pluginterfaces/gui/iplugviewcontentscalesupport.h"
//#include "pluginterfaces/base/conststringtable.cpp"
//#include "pluginterfaces/base/funknown.cpp"
//
#if defined(__clang__)
# pragma clang diagnostic pop
#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
# pragma GCC diagnostic pop
#endif
#endif