diff --git a/cmake/cpack/deploy_mac.cmake.in b/cmake/cpack/deploy_mac.cmake.in index 6ef9054f6..6d5af1ee5 100644 --- a/cmake/cpack/deploy_mac.cmake.in +++ b/cmake/cpack/deploy_mac.cmake.in @@ -11,6 +11,12 @@ execute_process (COMMAND mkdir ${CPACK_TEMPORARY_INSTALL_DIRECTORY}/SDRangel.app execute_process (COMMAND pwd) execute_process (COMMAND cp sdrangel ${CPACK_TEMPORARY_INSTALL_DIRECTORY}/SDRangel.app/Contents/MacOS/SDRangel) +# The Denoiser launches the VST3 scanner beside the app executable. +if(EXISTS "@CMAKE_BINARY_DIR@/sdrangel-vst3-scan") + file(COPY "@CMAKE_BINARY_DIR@/sdrangel-vst3-scan" + DESTINATION "${CPACK_TEMPORARY_INSTALL_DIRECTORY}/SDRangel.app/Contents/MacOS") +endif() + # Add RPATHS to libraries so macdeployqt can find out and copy all dependencies message ("Adding RPATHs to executables and libraries") diff --git a/plugins/feature/demodanalyzer/demodanalyzer.cpp b/plugins/feature/demodanalyzer/demodanalyzer.cpp index f94a717ed..5b95dc95e 100644 --- a/plugins/feature/demodanalyzer/demodanalyzer.cpp +++ b/plugins/feature/demodanalyzer/demodanalyzer.cpp @@ -207,12 +207,21 @@ bool DemodAnalyzer::handleMessage(const Message& cmd) else if (MsgSelectChannel::match(cmd)) { MsgSelectChannel& cfg = (MsgSelectChannel&) cmd; - ChannelAPI *selectedChannel = cfg.getChannel(); + QObject *selectedChannel = cfg.getChannel(); + if (!selectedChannel) { + return true; + } qDebug("DemodAnalyzer::handleMessage: MsgSelectChannel: %p %s", selectedChannel, qPrintable(selectedChannel->objectName())); setChannel(selectedChannel); - MainCore::MsgChannelDemodQuery *msg = MainCore::MsgChannelDemodQuery::create(); - selectedChannel->getInputMessageQueue()->push(msg); + if (m_selectedChannel == selectedChannel) + { + if (auto *channel = qobject_cast(selectedChannel)) { + channel->getInputMessageQueue()->push(MainCore::MsgChannelDemodQuery::create()); + } else if (auto *feature = qobject_cast(selectedChannel)) { + feature->getInputMessageQueue()->push(MainCore::MsgChannelDemodQuery::create()); + } + } return true; } @@ -221,32 +230,17 @@ bool DemodAnalyzer::handleMessage(const Message& cmd) qDebug() << "DemodAnalyzer::handleMessage: MainCore::MsgChannelDemodReport"; MainCore::MsgChannelDemodReport& report = (MainCore::MsgChannelDemodReport&) cmd; - if (report.getChannelAPI() == m_selectedChannel) - { - m_sampleRate = report.getSampleRate(); - m_scopeVis.setLiveRate(m_sampleRate); - - if (m_running) { - m_worker->applySampleRate(m_sampleRate); - } - - DSPSignalNotification *msg = new DSPSignalNotification(0, m_sampleRate); - m_spectrumVis.getInputMessageQueue()->push(msg); - - if (m_dataPipe) - { - DataFifo *fifo = qobject_cast(m_dataPipe->m_element); - - if (fifo) { - fifo->setSize(2*m_sampleRate); - } - } + if (report.getChannelAPI() == m_selectedChannel) { + applyReportedSampleRate(report.getSampleRate()); + } - if (getMessageQueueToGUI()) - { - MsgReportSampleRate *msg = MsgReportSampleRate::create(m_sampleRate); - getMessageQueueToGUI()->push(msg); - } + return true; + } + else if (MainCore::MsgFeatureDemodReport::match(cmd)) + { + const auto& report = static_cast(cmd); + if (report.getFeature() == m_selectedChannel) { + applyReportedSampleRate(report.getSampleRate()); } return true; @@ -257,6 +251,35 @@ bool DemodAnalyzer::handleMessage(const Message& cmd) } } +void DemodAnalyzer::applyReportedSampleRate(int sampleRate) +{ + if (sampleRate <= 0) { + return; + } + + m_sampleRate = sampleRate; + m_scopeVis.setLiveRate(m_sampleRate); + + if (m_running) { + m_worker->applySampleRate(m_sampleRate); + } + + m_spectrumVis.getInputMessageQueue()->push(new DSPSignalNotification(0, m_sampleRate)); + + if (m_dataPipe) + { + DataFifo *fifo = qobject_cast(m_dataPipe->m_element); + + if (fifo) { + fifo->setSize(2*m_sampleRate); + } + } + + if (getMessageQueueToGUI()) { + getMessageQueueToGUI()->push(MsgReportSampleRate::create(m_sampleRate)); + } +} + QByteArray DemodAnalyzer::serialize() const { return m_settings.serialize(); @@ -331,7 +354,7 @@ void DemodAnalyzer::getAvailableChannelsReport() } -void DemodAnalyzer::setChannel(ChannelAPI *selectedChannel) +void DemodAnalyzer::setChannel(QObject *selectedChannel) { if ((selectedChannel == m_selectedChannel) || (m_availableChannels.indexOfObject(selectedChannel) == -1)) { return; @@ -342,7 +365,7 @@ void DemodAnalyzer::setChannel(ChannelAPI *selectedChannel) if (m_selectedChannel) { ObjectPipe *pipe = mainCore->getDataPipes().unregisterProducerToConsumer(m_selectedChannel, this, "demod"); - DataFifo *fifo = qobject_cast(pipe->m_element); + DataFifo *fifo = pipe ? qobject_cast(pipe->m_element) : nullptr; if ((fifo) && m_running) { diff --git a/plugins/feature/demodanalyzer/demodanalyzer.h b/plugins/feature/demodanalyzer/demodanalyzer.h index c241c992d..209b0a5fd 100644 --- a/plugins/feature/demodanalyzer/demodanalyzer.h +++ b/plugins/feature/demodanalyzer/demodanalyzer.h @@ -118,15 +118,15 @@ public: MESSAGE_CLASS_DECLARATION public: - ChannelAPI *getChannel() { return m_channel; } - static MsgSelectChannel* create(ChannelAPI *channel) { + QObject *getChannel() { return m_channel; } + static MsgSelectChannel* create(QObject *channel) { return new MsgSelectChannel(channel); } protected: - ChannelAPI *m_channel; + QObject *m_channel; - MsgSelectChannel(ChannelAPI *channel) : + MsgSelectChannel(QObject *channel) : Message(), m_channel(channel) { } @@ -209,7 +209,7 @@ private: ScopeVis m_scopeVis; AvailableChannelOrFeatureList m_availableChannels; AvailableChannelOrFeatureHandler m_availableChannelOrFeatureHandler; - ChannelAPI *m_selectedChannel; + QObject *m_selectedChannel; ObjectPipe *m_dataPipe; int m_sampleRate; @@ -220,7 +220,8 @@ private: void stop(); void applySettings(const DemodAnalyzerSettings& settings, const QList& settingsKeys, bool force = false); void notifyUpdate(const QStringList& renameFrom, const QStringList& renameTo); - void setChannel(ChannelAPI *selectedChannel); + void setChannel(QObject *selectedChannel); + void applyReportedSampleRate(int sampleRate); void webapiReverseSendSettings(const QList& featureSettingsKeys, const DemodAnalyzerSettings& settings, bool force); private slots: diff --git a/plugins/feature/demodanalyzer/demodanalyzergui.cpp b/plugins/feature/demodanalyzer/demodanalyzergui.cpp index a7fe64ae4..267cd64e5 100644 --- a/plugins/feature/demodanalyzer/demodanalyzergui.cpp +++ b/plugins/feature/demodanalyzer/demodanalyzergui.cpp @@ -316,7 +316,7 @@ void DemodAnalyzerGUI::on_channels_currentIndexChanged(int index) { if ((index >= 0) && (index < m_availableChannels.size())) { - m_selectedChannel = qobject_cast(m_availableChannels[index].m_object); + m_selectedChannel = m_availableChannels[index].m_object; DemodAnalyzer::MsgSelectChannel *msg = DemodAnalyzer::MsgSelectChannel::create(m_selectedChannel); m_demodAnalyzer->getInputMessageQueue()->push(msg); } diff --git a/plugins/feature/demodanalyzer/demodanalyzergui.h b/plugins/feature/demodanalyzer/demodanalyzergui.h index 90c345e00..64cf9fb3b 100644 --- a/plugins/feature/demodanalyzer/demodanalyzergui.h +++ b/plugins/feature/demodanalyzer/demodanalyzergui.h @@ -70,7 +70,7 @@ private: ScopeVis* m_scopeVis; MessageQueue m_inputMessageQueue; AvailableChannelOrFeatureList m_availableChannels; - ChannelAPI *m_selectedChannel; + QObject *m_selectedChannel; MovingAverageUtil m_channelPowerAvg; explicit DemodAnalyzerGUI(PluginAPI* pluginAPI, FeatureUISet *featureUISet, Feature *feature, QWidget* parent = nullptr); diff --git a/plugins/feature/demodanalyzer/demodanalyzersettings.cpp b/plugins/feature/demodanalyzer/demodanalyzersettings.cpp index 452cc7eef..9b179aa08 100644 --- a/plugins/feature/demodanalyzer/demodanalyzersettings.cpp +++ b/plugins/feature/demodanalyzer/demodanalyzersettings.cpp @@ -49,6 +49,7 @@ const QStringList DemodAnalyzerSettings::m_channelURIs = { QStringLiteral("sdrangel.channel.wfmdemod"), QStringLiteral("sdrangel.channeltx.modwfm"), QStringLiteral("sdrangel.channel.wdsprx"), + QStringLiteral("sdrangel.feature.denoiser"), }; DemodAnalyzerSettings::DemodAnalyzerSettings() : diff --git a/plugins/feature/demodanalyzer/readme.md b/plugins/feature/demodanalyzer/readme.md index 22d040346..c24bfbcb1 100644 --- a/plugins/feature/demodanalyzer/readme.md +++ b/plugins/feature/demodanalyzer/readme.md @@ -3,6 +3,7 @@

Introduction

This plugin can be used to analyze the real demodulated signal from some Rx channel plugins. It can also be used to view the modulating signal of some Tx channel plugins. +It can also display filtered audio from some feature plugins. Rx plugins are: @@ -32,6 +33,10 @@ Tx plugins are: - SSB modulator - WFM modulator +Features are: + + - Denoiser feature +

General interface

![Demod Analyzer plugin GUI](../../../doc/img/DemodAnalyzer_plugin.png) @@ -58,7 +63,7 @@ This button starts or stops the plugin

A.3: Channel selection

-Use this combo to select which channel to use for display. Channel is selected upon change. If channel is not changed or there is only one in the list you have to use the (re)apply button (A.4) to effectively connect the channel to the analyzer. +Use this combo to select which channel or feature to use for display. The source is selected upon change. If the selection is not changed or there is only one in the list, use the (re)apply button (A.4) to connect it to the analyzer.

A.4: (Re)apply channel selection

diff --git a/plugins/feature/denoiser/CMakeLists.txt b/plugins/feature/denoiser/CMakeLists.txt index e8cb69faa..b9a88a7f4 100644 --- a/plugins/feature/denoiser/CMakeLists.txt +++ b/plugins/feature/denoiser/CMakeLists.txt @@ -1,11 +1,20 @@ project(denoiser) +if(APPLE) + find_library(VST3_COREFOUNDATION_FRAMEWORK CoreFoundation) + if(NOT VST3_COREFOUNDATION_FRAMEWORK) + message(FATAL_ERROR "CoreFoundation is required for VST3 support on macOS") + endif() +endif() + set(denoiser_SOURCES denoiser.cpp denoisersettings.cpp denoiserplugin.cpp denoiserworker.cpp denoiserwebapiadapter.cpp + nvidiaaudioeffects.cpp + vst3effect.cpp ) set(denoiser_HEADERS @@ -14,6 +23,8 @@ set(denoiser_HEADERS denoiserplugin.h denoiserworker.h denoiserwebapiadapter.h + nvidiaaudioeffects.h + vst3effect.h ) include_directories( @@ -56,6 +67,8 @@ endif() target_link_libraries(${TARGET_NAME} PRIVATE Qt::Core + ${CMAKE_DL_LIBS} + ${VST3_COREFOUNDATION_FRAMEWORK} ${TARGET_LIB} sdrbase ${TARGET_LIB_GUI} @@ -64,6 +77,22 @@ target_link_libraries(${TARGET_NAME} PRIVATE install(TARGETS ${TARGET_NAME} DESTINATION ${INSTALL_FOLDER}) +if(NOT SERVER_MODE) + add_executable(sdrangel-vst3-scan vst3scan.cpp vst3effect.cpp) + target_link_libraries(sdrangel-vst3-scan PRIVATE Qt::Core ${CMAKE_DL_LIBS} ${VST3_COREFOUNDATION_FRAMEWORK}) + if(WIN32) + set(VST3_SCAN_RUNTIME_DIR "${SDRANGEL_BINARY_BIN_DIR}") + else() + set(VST3_SCAN_RUNTIME_DIR "${CMAKE_BINARY_DIR}") + endif() + set_target_properties(sdrangel-vst3-scan PROPERTIES + RUNTIME_OUTPUT_DIRECTORY "${VST3_SCAN_RUNTIME_DIR}" + RUNTIME_OUTPUT_DIRECTORY_DEBUG "${VST3_SCAN_RUNTIME_DIR}" + RUNTIME_OUTPUT_DIRECTORY_RELEASE "${VST3_SCAN_RUNTIME_DIR}" + RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO "${VST3_SCAN_RUNTIME_DIR}") + install(TARGETS sdrangel-vst3-scan DESTINATION ${INSTALL_BIN_DIR}) +endif() + # Install debug symbols if (WIN32) install(FILES $ CONFIGURATIONS Debug RelWithDebInfo DESTINATION ${INSTALL_FOLDER} ) diff --git a/plugins/feature/denoiser/denoiser.cpp b/plugins/feature/denoiser/denoiser.cpp index af2baa8f3..a6eb426a9 100644 --- a/plugins/feature/denoiser/denoiser.cpp +++ b/plugins/feature/denoiser/denoiser.cpp @@ -19,6 +19,8 @@ #include #include #include +#include +#include #include "SWGFeatureSettings.h" #include "SWGFeatureActions.h" @@ -31,6 +33,7 @@ #include "maincore.h" #include "denoiserworker.h" +#include "vst3effect.h" #include "denoiser.h" MESSAGE_CLASS_DEFINITION(Denoiser::MsgConfigureDenoiser, Message) @@ -39,6 +42,37 @@ MESSAGE_CLASS_DEFINITION(Denoiser::MsgReportChannels, Message) MESSAGE_CLASS_DEFINITION(Denoiser::MsgSelectChannel, Message) MESSAGE_CLASS_DEFINITION(Denoiser::MsgReportSampleRate, Message) +namespace { + +QString vst3ParametersJson(const QMap& values) +{ + QJsonObject object; + + for (auto it = values.cbegin(); it != values.cend(); ++it) { + object.insert(QString::number(it.key()), it.value()); + } + + return QString::fromUtf8(QJsonDocument(object).toJson(QJsonDocument::Compact)); +} + +QMap parseVst3Parameters(const QString& json) +{ + QMap values; + const QJsonObject object = QJsonDocument::fromJson(json.toUtf8()).object(); + + for (auto it = object.begin(); it != object.end(); ++it) + { + bool validId = false; + const quint32 id = it.key().toUInt(&validId); + const double value = it.value().toDouble(-1.0); + if (validId && value >= 0.0 && value <= 1.0) values.insert(id, value); + } + + return values; +} + +} + const char* const Denoiser::m_featureIdURI = "sdrangel.feature.denoiser"; const char* const Denoiser::m_featureId = "Denoiser"; @@ -49,7 +83,8 @@ Denoiser::Denoiser(WebAPIAdapterInterface *webAPIAdapterInterface) : m_worker(nullptr), m_availableChannelOrFeatureHandler(DenoiserSettings::m_channelURIs), m_selectedChannel(nullptr), - m_dataPipe(nullptr) + m_dataPipe(nullptr), + m_sampleRate(0) { qDebug("Denoiser::Denoiser: webAPIAdapterInterface: %p", webAPIAdapterInterface); setObjectName(m_featureId); @@ -101,6 +136,8 @@ void Denoiser::start() return; } + useDefaultSampleRate(); + qDebug("Denoiser::start"); m_thread = new QThread(); m_worker = new DenoiserWorker(); @@ -126,6 +163,7 @@ void Denoiser::start() ); m_worker->setMessageQueueToFeature(getInputMessageQueue()); + m_worker->setDemodProducer(this); m_worker->startWork(); setState(StRunning); m_thread->start(); @@ -152,6 +190,7 @@ void Denoiser::start() m_running = true; + configureVst3(); } void Denoiser::stop() @@ -164,6 +203,8 @@ void Denoiser::stop() qDebug("Denoiser::stop"); m_running = false; + m_worker->setVst3Effect(nullptr); + m_vst3Effect.reset(); if (m_dataPipe) { @@ -189,7 +230,7 @@ double Denoiser::getMagSqAvg() const bool Denoiser::handleMessage(const Message& cmd) { - if (MsgConfigureDenoiser::match(cmd)) + if (MsgConfigureDenoiser::match(cmd)) { MsgConfigureDenoiser& cfg = (MsgConfigureDenoiser&) cmd; qDebug() << "Denoiser::handleMessage: MsgConfigureDenoiser"; @@ -197,6 +238,32 @@ bool Denoiser::handleMessage(const Message& cmd) return true; } + else if (DenoiserWorker::MsgReportNvidiaStatus::match(cmd)) + { + const auto& report = static_cast(cmd); + if (m_running && m_settings.m_enableDenoiser && + m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_Nvidia) + { + if (report.getError().isEmpty()) { + m_state = StRunning; + } else { + m_errorMessage = report.getError(); + m_state = StError; + } + } + return true; + } + else if (DenoiserWorker::MsgReportVst3Status::match(cmd)) + { + const auto& report = static_cast(cmd); + if (m_running && m_settings.m_enableDenoiser && + m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_Vst3) + { + m_errorMessage = report.getError(); + m_state = StError; + } + return true; + } else if (MsgStartStop::match(cmd)) { MsgStartStop& cfg = (MsgStartStop&) cmd; @@ -213,42 +280,40 @@ bool Denoiser::handleMessage(const Message& cmd) else if (MsgSelectChannel::match(cmd)) { MsgSelectChannel& cfg = (MsgSelectChannel&) cmd; - ChannelAPI *selectedChannel = cfg.getChannel(); + QObject *selectedChannel = cfg.getChannel(); + if (!selectedChannel) { + return true; + } qDebug("Denoiser::handleMessage: MsgSelectChannel: %p %s", selectedChannel, qPrintable(selectedChannel->objectName())); setChannel(selectedChannel); - MainCore::MsgChannelDemodQuery *msg = MainCore::MsgChannelDemodQuery::create(); - selectedChannel->getInputMessageQueue()->push(msg); + if (m_selectedChannel == selectedChannel) { + querySelectedSource(); + } return true; } + else if (MainCore::MsgChannelDemodQuery::match(cmd)) + { + reportDemodSampleRate(); + return true; + } else if (MainCore::MsgChannelDemodReport::match(cmd)) { qDebug() << "Denoiser::handleMessage: MainCore::MsgChannelDemodReport"; MainCore::MsgChannelDemodReport& report = (MainCore::MsgChannelDemodReport&) cmd; - if (report.getChannelAPI() == m_selectedChannel) - { - m_sampleRate = report.getSampleRate(); - - if (m_running) { - m_worker->applySampleRate(m_sampleRate); - } - - if (m_dataPipe) - { - DataFifo *fifo = qobject_cast(m_dataPipe->m_element); - - if (fifo) { - fifo->setSize(2*m_sampleRate); - } - } + if (report.getChannelAPI() == m_selectedChannel) { + applyReportedSampleRate(report.getSampleRate()); + } - if (getMessageQueueToGUI()) - { - MsgReportSampleRate *msg = MsgReportSampleRate::create(m_sampleRate); - getMessageQueueToGUI()->push(msg); - } + return true; + } + else if (MainCore::MsgFeatureDemodReport::match(cmd)) + { + const auto& report = static_cast(cmd); + if (report.getFeature() == m_selectedChannel) { + applyReportedSampleRate(report.getSampleRate()); } return true; @@ -303,24 +368,189 @@ void Denoiser::applySettings(const DenoiserSettings& settings, const QListsetParameter(it.key(), it.value()); + } + } + } +} + +QVector Denoiser::vst3Parameters() const +{ + return m_vst3Effect ? m_vst3Effect->parameters() : QVector(); +} + +bool Denoiser::hasVst3Effect() const +{ + return m_vst3Effect != nullptr; +} + +QString Denoiser::vst3ParameterText(quint32 id, double value) const +{ + return m_vst3Effect ? m_vst3Effect->parameterText(id, value) : QString::number(value, 'f', 3); +} + +void Denoiser::configureVst3() +{ + if (!m_worker) { + return; + } + m_worker->setVst3Effect(nullptr); + m_vst3Effect.reset(); + if (!m_running || !m_settings.m_enableDenoiser || + m_settings.m_denoiserType != DenoiserSettings::DenoiserType::DenoiserType_Vst3) + { + return; + } + if (m_sampleRate <= 0) { + return; + } + if (m_settings.m_vst3ModulePath.isEmpty() || m_settings.m_vst3ClassId.size() != 16) + { + m_errorMessage = QStringLiteral("Select a VST3 audio effect"); + m_state = StError; + return; + } + auto effect = std::make_unique(); + QString error; + if (!effect->open(m_settings.m_vst3ModulePath, m_settings.m_vst3ClassId, m_sampleRate, 2, error, m_settings.m_vst3State)) + { + m_errorMessage = QStringLiteral("VST3: %1. Audio is passing through.").arg(error); + m_state = StError; + qWarning() << m_errorMessage; + return; + } + for (auto it = m_settings.m_vst3Parameters.cbegin(); it != m_settings.m_vst3Parameters.cend(); ++it) { + effect->setParameter(it.key(), it.value()); + } + m_worker->setVst3Effect(effect.get()); + m_vst3Effect = std::move(effect); + if (m_state == StError) { + m_state = StRunning; + } +} + +void Denoiser::useDefaultSampleRate() +{ + if (!m_selectedChannel || m_sampleRate > 0) { + return; + } + + m_sampleRate = 48000; + + if (m_dataPipe) + { + DataFifo *fifo = qobject_cast(m_dataPipe->m_element); + if (fifo) { + fifo->setSize(2 * m_sampleRate); + } + } + + if (getMessageQueueToGUI()) { + getMessageQueueToGUI()->push(MsgReportSampleRate::create(m_sampleRate)); + } + reportDemodSampleRate(); +} + +void Denoiser::applyReportedSampleRate(int sampleRate) +{ + if (sampleRate <= 0) return; + + const bool sampleRateChanged = m_sampleRate != sampleRate; + m_sampleRate = sampleRate; + + if (m_running && (sampleRateChanged || !m_vst3Effect || + m_settings.m_denoiserType != DenoiserSettings::DenoiserType::DenoiserType_Vst3)) + { + m_worker->applySampleRate(m_sampleRate); + configureVst3(); + if (sampleRateChanged && m_state == StError && + m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_Nvidia) + { + m_state = StRunning; + } + } + + if (m_dataPipe) + { + DataFifo *fifo = qobject_cast(m_dataPipe->m_element); + if (fifo) fifo->setSize(2 * m_sampleRate); + } + + if (getMessageQueueToGUI()) { + getMessageQueueToGUI()->push(MsgReportSampleRate::create(m_sampleRate)); + } + if (sampleRateChanged) reportDemodSampleRate(); +} + +void Denoiser::reportDemodSampleRate() +{ + QList pipes; + MainCore::instance()->getMessagePipes().getMessagePipes(this, "reportdemod", pipes); + + for (const auto& pipe : pipes) + { + MessageQueue *queue = qobject_cast(pipe->m_element); + if (queue) { + queue->push(MainCore::MsgFeatureDemodReport::create(this, m_sampleRate)); + } + } } void Denoiser::channelsOrFeaturesChanged(const QStringList& renameFrom, const QStringList& renameTo) { - m_availableChannels = m_availableChannelOrFeatureHandler.getAvailableChannelOrFeatureList(); + m_availableChannels.clear(); + for (const auto& source : m_availableChannelOrFeatureHandler.getAvailableChannelOrFeatureList()) { + if (source.m_object != this) { + m_availableChannels.append(source); + } + } + + for (int i = 0; i < renameFrom.size() && i < renameTo.size(); ++i) + { + if (m_settings.m_selectedSource == renameFrom.at(i)) { + m_settings.m_selectedSource = renameTo.at(i); + } + } + + if (!m_settings.m_selectedSource.isEmpty()) { + restoreSelectedSource(); + } notifyUpdate(renameFrom, renameTo); } -void Denoiser::notifyUpdate(const QStringList& renameFrom, const QStringList& renameTo) +void Denoiser::notifyUpdate(const QStringList& renameFrom, const QStringList& renameTo, bool autoSelect) { if (getMessageQueueToGUI()) { - MsgReportChannels *msg = MsgReportChannels::create(renameFrom, renameTo); + MsgReportChannels *msg = MsgReportChannels::create(renameFrom, renameTo, m_selectedChannel, autoSelect); msg->getAvailableChannels() = m_availableChannels; getMessageQueueToGUI()->push(msg); } @@ -332,18 +562,86 @@ void Denoiser::getAvailableChannelsReport() } -void Denoiser::setChannel(ChannelAPI *selectedChannel) +void Denoiser::querySelectedSource() { - if ((selectedChannel == m_selectedChannel) || (m_availableChannels.indexOfObject(selectedChannel) == -1)) { + if (auto *channel = qobject_cast(m_selectedChannel)) { + channel->getInputMessageQueue()->push(MainCore::MsgChannelDemodQuery::create()); + } else if (auto *feature = qobject_cast(m_selectedChannel)) { + feature->getInputMessageQueue()->push(MainCore::MsgChannelDemodQuery::create()); + } +} + +void Denoiser::restoreSelectedSource() +{ + if (m_settings.m_selectedSource.isEmpty()) + { + setChannel(nullptr); return; } + const int index = m_availableChannels.indexOfLongId(m_settings.m_selectedSource); + if (index < 0) + { + setChannel(nullptr, true); + return; + } + + QObject *source = m_availableChannels.at(index).m_object; + if (source != m_selectedChannel) + { + setChannel(source); + if (source == m_selectedChannel) + { + querySelectedSource(); + } + else + { + const int currentIndex = m_availableChannels.indexOfObject(m_selectedChannel); + m_settings.m_selectedSource = currentIndex >= 0 ? m_availableChannels.at(currentIndex).getLongId() : QString(); + } + } +} + +void Denoiser::setChannel(QObject *selectedChannel, bool preserveSavedSource) +{ + if (selectedChannel == m_selectedChannel) { + return; + } + + const int selectedIndex = selectedChannel ? m_availableChannels.indexOfObject(selectedChannel) : -1; + if (selectedChannel && selectedIndex < 0) { + return; + } + + QObject *upstream = selectedChannel; + while (auto *denoiser = qobject_cast(upstream)) + { + if (denoiser == this) + { + qWarning() << "Denoiser: rejecting a cyclic denoiser connection"; + notifyUpdate(QStringList{}, QStringList{}, false); + return; + } + upstream = denoiser->m_selectedChannel; + } + + m_sampleRate = 0; + if (m_running) + { + m_worker->setVst3Effect(nullptr); + m_vst3Effect.reset(); + m_worker->applySampleRate(0); + } + if (getMessageQueueToGUI()) { + getMessageQueueToGUI()->push(MsgReportSampleRate::create(0)); + } + MainCore *mainCore = MainCore::instance(); if (m_selectedChannel) { ObjectPipe *pipe = mainCore->getDataPipes().unregisterProducerToConsumer(m_selectedChannel, this, "demod"); - DataFifo *fifo = qobject_cast(pipe->m_element); + DataFifo *fifo = pipe ? qobject_cast(pipe->m_element) : nullptr; if ((fifo) && m_running) { @@ -363,6 +661,17 @@ void Denoiser::setChannel(ChannelAPI *selectedChannel) } } + m_dataPipe = nullptr; + m_selectedChannel = nullptr; + + if (!selectedChannel) + { + if (!preserveSavedSource) { + m_settings.m_selectedSource.clear(); + } + return; + } + m_dataPipe = mainCore->getDataPipes().registerProducerToConsumer(selectedChannel, this, "demod"); connect(m_dataPipe, SIGNAL(toBeDeleted(int, QObject*)), this, SLOT(handleDataPipeToBeDeleted(int, QObject*))); DataFifo *fifo = qobject_cast(m_dataPipe->m_element); @@ -397,6 +706,13 @@ void Denoiser::setChannel(ChannelAPI *selectedChannel) } m_selectedChannel = selectedChannel; + m_settings.m_selectedSource = m_availableChannels.at(selectedIndex).getLongId(); + useDefaultSampleRate(); + if (m_running) + { + m_worker->applySampleRate(m_sampleRate); + configureVst3(); + } } int Denoiser::webapiRun(bool run, @@ -452,6 +768,12 @@ void Denoiser::webapiFormatFeatureSettings( { response.getDenoiserSettings()->setDenoiserType(static_cast(settings.m_denoiserType)); response.getDenoiserSettings()->setEnableDenoiser(settings.m_enableDenoiser ? 1 : 0); + response.getDenoiserSettings()->setNvidiaIntensity(settings.m_nvidiaIntensity); + response.getDenoiserSettings()->setNvidiaVad(settings.m_nvidiaVad ? 1 : 0); + *response.getDenoiserSettings()->getVst3ModulePath() = settings.m_vst3ModulePath; + *response.getDenoiserSettings()->getVst3ClassId() = QString::fromLatin1(settings.m_vst3ClassId.toHex()); + *response.getDenoiserSettings()->getVst3Parameters() = vst3ParametersJson(settings.m_vst3Parameters); + *response.getDenoiserSettings()->getVst3State() = QString::fromLatin1(settings.m_vst3State.toBase64()); response.getDenoiserSettings()->setAudioMute(settings.m_audioMute ? 1 : 0); response.getDenoiserSettings()->setVolumeTenths(settings.m_volumeTenths); if (response.getDenoiserSettings()->getAudioDeviceName()) { @@ -506,12 +828,34 @@ void Denoiser::webapiUpdateFeatureSettings( const QStringList& featureSettingsKeys, SWGSDRangel::SWGFeatureSettings& response) { - if (featureSettingsKeys.contains("denoiserType")) { - settings.m_denoiserType = static_cast(response.getDenoiserSettings()->getDenoiserType()); + if (featureSettingsKeys.contains("denoiserType")) + { + const int type = response.getDenoiserSettings()->getDenoiserType(); + if (type >= 0 && type <= 3) { + settings.m_denoiserType = static_cast(type); + } } if (featureSettingsKeys.contains("enableDenoiser")) { settings.m_enableDenoiser = response.getDenoiserSettings()->getEnableDenoiser() != 0; } + if (featureSettingsKeys.contains("nvidiaIntensity")) { + settings.m_nvidiaIntensity = qBound(0, response.getDenoiserSettings()->getNvidiaIntensity(), 100); + } + if (featureSettingsKeys.contains("nvidiaVad")) { + settings.m_nvidiaVad = response.getDenoiserSettings()->getNvidiaVad() != 0; + } + if (featureSettingsKeys.contains("vst3ModulePath") && response.getDenoiserSettings()->getVst3ModulePath()) { + settings.m_vst3ModulePath = *response.getDenoiserSettings()->getVst3ModulePath(); + } + if (featureSettingsKeys.contains("vst3ClassId") && response.getDenoiserSettings()->getVst3ClassId()) { + settings.m_vst3ClassId = QByteArray::fromHex(response.getDenoiserSettings()->getVst3ClassId()->toLatin1()); + } + if (featureSettingsKeys.contains("vst3Parameters") && response.getDenoiserSettings()->getVst3Parameters()) { + settings.m_vst3Parameters = parseVst3Parameters(*response.getDenoiserSettings()->getVst3Parameters()); + } + if (featureSettingsKeys.contains("vst3State") && response.getDenoiserSettings()->getVst3State()) { + settings.m_vst3State = QByteArray::fromBase64(response.getDenoiserSettings()->getVst3State()->toLatin1()); + } if (featureSettingsKeys.contains("audioMute")) { settings.m_audioMute = response.getDenoiserSettings()->getAudioMute() != 0; } @@ -585,6 +929,24 @@ void Denoiser::webapiReverseSendSettings(const QList& featureSettingsKe if (featureSettingsKeys.contains("enableDenoiser") || force) { swgDenoiserSettings->setEnableDenoiser(settings.m_enableDenoiser ? 1 : 0); } + if (featureSettingsKeys.contains("nvidiaIntensity") || force) { + swgDenoiserSettings->setNvidiaIntensity(settings.m_nvidiaIntensity); + } + if (featureSettingsKeys.contains("nvidiaVad") || force) { + swgDenoiserSettings->setNvidiaVad(settings.m_nvidiaVad ? 1 : 0); + } + if (featureSettingsKeys.contains("vst3ModulePath") || force) { + swgDenoiserSettings->setVst3ModulePath(new QString(settings.m_vst3ModulePath)); + } + if (featureSettingsKeys.contains("vst3ClassId") || force) { + swgDenoiserSettings->setVst3ClassId(new QString(QString::fromLatin1(settings.m_vst3ClassId.toHex()))); + } + if (featureSettingsKeys.contains("vst3Parameters") || force) { + swgDenoiserSettings->setVst3Parameters(new QString(vst3ParametersJson(settings.m_vst3Parameters))); + } + if (featureSettingsKeys.contains("vst3State") || force) { + swgDenoiserSettings->setVst3State(new QString(QString::fromLatin1(settings.m_vst3State.toBase64()))); + } if (featureSettingsKeys.contains("audioMute") || force) { swgDenoiserSettings->setAudioMute(settings.m_audioMute ? 1 : 0); } @@ -680,6 +1042,17 @@ void Denoiser::handleDataPipeToBeDeleted(int reason, QObject *object) } m_selectedChannel = nullptr; + m_dataPipe = nullptr; + m_sampleRate = 0; + if (m_running) + { + m_worker->setVst3Effect(nullptr); + m_vst3Effect.reset(); + m_worker->applySampleRate(0); + } + if (getMessageQueueToGUI()) { + getMessageQueueToGUI()->push(MsgReportSampleRate::create(0)); + } } } diff --git a/plugins/feature/denoiser/denoiser.h b/plugins/feature/denoiser/denoiser.h index 63153233d..7c9f2de47 100644 --- a/plugins/feature/denoiser/denoiser.h +++ b/plugins/feature/denoiser/denoiser.h @@ -21,15 +21,18 @@ #include #include #include +#include #include "feature/feature.h" #include "util/message.h" #include "availablechannelorfeaturehandler.h" #include "denoisersettings.h" +#include "vst3effect.h" class WebAPIAdapterInterface; class DenoiserWorker; +class Vst3Effect; class QNetworkAccessManager; class QNetworkReply; class QThread; @@ -94,20 +97,28 @@ public: AvailableChannelOrFeatureList& getAvailableChannels() { return m_availableChannels; } const QStringList& getRenameFrom() const { return m_renameFrom; } const QStringList& getRenameTo() const { return m_renameTo; } + QObject *getSelectedChannel() const { return m_selectedChannel; } + bool getAutoSelect() const { return m_autoSelect; } - static MsgReportChannels* create(const QStringList& renameFrom, const QStringList& renameTo) { - return new MsgReportChannels(renameFrom, renameTo); + static MsgReportChannels* create(const QStringList& renameFrom, const QStringList& renameTo, + QObject *selectedChannel, bool autoSelect) { + return new MsgReportChannels(renameFrom, renameTo, selectedChannel, autoSelect); } private: AvailableChannelOrFeatureList m_availableChannels; QStringList m_renameFrom; QStringList m_renameTo; + QObject *m_selectedChannel; + bool m_autoSelect; - MsgReportChannels(const QStringList& renameFrom, const QStringList& renameTo) : + MsgReportChannels(const QStringList& renameFrom, const QStringList& renameTo, + QObject *selectedChannel, bool autoSelect) : Message(), m_renameFrom(renameFrom), - m_renameTo(renameTo) + m_renameTo(renameTo), + m_selectedChannel(selectedChannel), + m_autoSelect(autoSelect) {} }; @@ -115,15 +126,15 @@ public: MESSAGE_CLASS_DECLARATION public: - ChannelAPI *getChannel() { return m_channel; } - static MsgSelectChannel* create(ChannelAPI *channel) { + QObject *getChannel() { return m_channel; } + static MsgSelectChannel* create(QObject *channel) { return new MsgSelectChannel(channel); } protected: - ChannelAPI *m_channel; + QObject *m_channel; - MsgSelectChannel(ChannelAPI *channel) : + MsgSelectChannel(QObject *channel) : Message(), m_channel(channel) { } @@ -191,6 +202,9 @@ public: void getAvailableChannelsReport(); void setLevelMeter(QObject *levelMeter) { m_levelMeter = levelMeter; } + QVector vst3Parameters() const; + bool hasVst3Effect() const; + QString vst3ParameterText(quint32 id, double value) const; static const char* const m_featureIdURI; static const char* const m_featureId; @@ -201,9 +215,10 @@ private: bool m_running; DenoiserWorker *m_worker; DenoiserSettings m_settings; + std::unique_ptr m_vst3Effect; AvailableChannelOrFeatureList m_availableChannels; AvailableChannelOrFeatureHandler m_availableChannelOrFeatureHandler; - ChannelAPI *m_selectedChannel; + QObject *m_selectedChannel; ObjectPipe *m_dataPipe; int m_sampleRate; QObject *m_levelMeter = nullptr; @@ -214,8 +229,14 @@ private: void start(); void stop(); void applySettings(const DenoiserSettings& settings, const QList& settingsKeys, bool force = false); - void notifyUpdate(const QStringList& renameFrom, const QStringList& renameTo); - void setChannel(ChannelAPI *selectedChannel); + void configureVst3(); + void useDefaultSampleRate(); + void applyReportedSampleRate(int sampleRate); + void reportDemodSampleRate(); + void notifyUpdate(const QStringList& renameFrom, const QStringList& renameTo, bool autoSelect = true); + void querySelectedSource(); + void restoreSelectedSource(); + void setChannel(QObject *selectedChannel, bool preserveSavedSource = false); void webapiReverseSendSettings(const QList& featureSettingsKeys, const DenoiserSettings& settings, bool force); private slots: diff --git a/plugins/feature/denoiser/denoisergui.cpp b/plugins/feature/denoiser/denoisergui.cpp index 505bb5783..a0b65894f 100644 --- a/plugins/feature/denoiser/denoisergui.cpp +++ b/plugins/feature/denoiser/denoisergui.cpp @@ -17,6 +17,22 @@ #include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include "feature/featureuiset.h" #include "gui/basicfeaturesettingsdialog.h" @@ -47,6 +63,7 @@ void DenoiserGUI::resetToDefaults() { m_settings.resetToDefaults(); displaySettings(); + updateChannelList(true); applySettings(true); } @@ -61,6 +78,7 @@ bool DenoiserGUI::deserialize(const QByteArray& data) { m_feature->setWorkspaceIndex(m_settings.m_workspaceIndex); displaySettings(); + updateChannelList(true); applySettings(true); return true; } @@ -84,9 +102,18 @@ bool DenoiserGUI::handleMessage(const Message& message) m_settings.applySettings(cfg.getSettingsKeys(), cfg.getSettings()); } + const auto requestedType = m_settings.m_denoiserType; blockApplySettings(true); displaySettings(); blockApplySettings(false); + if (cfg.getForce() || cfg.getSettingsKeys().contains("selectedSource")) { + updateChannelList(true); + } + if (m_settings.m_denoiserType != requestedType) + { + m_settingsKeys.append("denoiserType"); + applySettings(); + } return true; } @@ -95,7 +122,14 @@ bool DenoiserGUI::handleMessage(const Message& message) qDebug("DenoiserGUI::handleMessage: Denoiser::MsgReportChannels"); Denoiser::MsgReportChannels& report = (Denoiser::MsgReportChannels&) message; m_availableChannels = report.getAvailableChannels(); - updateChannelList(); + m_selectedChannel = report.getSelectedChannel(); + for (int i = 0; i < report.getRenameFrom().size() && i < report.getRenameTo().size(); ++i) + { + if (m_settings.m_selectedSource == report.getRenameFrom().at(i)) { + m_settings.m_selectedSource = report.getRenameTo().at(i); + } + } + updateChannelList(report.getAutoSelect()); return true; } @@ -142,7 +176,7 @@ DenoiserGUI::DenoiserGUI(PluginAPI* pluginAPI, FeatureUISet *featureUISet, Featu ui(new Ui::DenoiserGUI), m_pluginAPI(pluginAPI), m_featureUISet(featureUISet), - m_sampleRate(48000), + m_sampleRate(0), m_doApplySettings(true), m_selectedChannel(nullptr) { @@ -151,6 +185,14 @@ DenoiserGUI::DenoiserGUI(PluginAPI* pluginAPI, FeatureUISet *featureUISet, Featu m_helpURL = "plugins/feature/denoiser/readme.md"; RollupContents *rollupContents = getRollupContents(); ui->setupUi(rollupContents); + using DenoiserType = DenoiserSettings::DenoiserType; + ui->denoiserType->setItemData(0, static_cast(DenoiserType::DenoiserType_None)); + ui->denoiserType->setItemData(1, static_cast(DenoiserType::DenoiserType_RNnoise)); + ui->denoiserType->setItemData(2, static_cast(DenoiserType::DenoiserType_Nvidia)); + ui->denoiserType->setItemData(3, static_cast(DenoiserType::DenoiserType_Vst3)); +#if !defined(Q_OS_WIN) && !defined(Q_OS_LINUX) + ui->denoiserType->removeItem(static_cast(DenoiserSettings::DenoiserType::DenoiserType_Nvidia)); +#endif rollupContents->arrangeRollups(); connect(rollupContents, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool))); @@ -183,6 +225,14 @@ DenoiserGUI::DenoiserGUI(PluginAPI* pluginAPI, FeatureUISet *featureUISet, Featu DenoiserGUI::~DenoiserGUI() { + if (m_vst3ScanProcess) + { + QProcess *process = m_vst3ScanProcess; + m_vst3ScanProcess = nullptr; + QObject::disconnect(process, nullptr, this, nullptr); + process->kill(); + process->waitForFinished(1000); + } delete ui; } @@ -206,7 +256,18 @@ void DenoiserGUI::displaySettings() ui->record->setChecked(m_settings.m_recordToFile); ui->fileNameText->setText(m_settings.m_fileRecordName); ui->showFileDialog->setEnabled(!m_settings.m_recordToFile); - ui->denoiserType->setCurrentIndex(static_cast(m_settings.m_denoiserType)); + int typeIndex = ui->denoiserType->findData(static_cast(m_settings.m_denoiserType)); + if (typeIndex < 0) + { + m_settings.m_denoiserType = DenoiserSettings::DenoiserType::DenoiserType_RNnoise; + typeIndex = ui->denoiserType->findData(static_cast(m_settings.m_denoiserType)); + } + ui->denoiserType->setCurrentIndex(typeIndex); + updateControls(); + displayVst3Selection(); + ui->nvidiaIntensity->setValue(m_settings.m_nvidiaIntensity); + ui->nvidiaIntensityText->setText(QStringLiteral("%1%").arg(m_settings.m_nvidiaIntensity)); + ui->nvidiaVad->setChecked(m_settings.m_nvidiaVad); ui->enable->setChecked(m_settings.m_enableDenoiser); ui->audioMute->setChecked(m_settings.m_audioMute); ui->volume->setValue(m_settings.m_volumeTenths); @@ -218,36 +279,56 @@ void DenoiserGUI::displaySettings() void DenoiserGUI::displaySampleRate(int sampleRate) { + if (sampleRate <= 0) + { + ui->sinkSampleRateText->setText(tr("-- kS/s")); + ui->sinkSampleRateText->setToolTip(tr("Waiting for the selected channel's sample rate")); + return; + } QString s = QString::number(sampleRate/1000.0, 'f', 1); ui->sinkSampleRateText->setText(tr("%1 kS/s").arg(s)); + ui->sinkSampleRateText->setToolTip(QString()); } -void DenoiserGUI::updateChannelList() +void DenoiserGUI::updateChannelList(bool autoSelect) { - ui->channels->blockSignals(true); - ui->channels->clear(); - - AvailableChannelOrFeatureList::const_iterator it = m_availableChannels.begin(); - int selectedItem = -1; - - for (int i = 0; it != m_availableChannels.end(); ++it, i++) { - ui->channels->addItem(it->getLongId()); + const QSignalBlocker blocker(ui->channels); + ui->channels->clear(); - if (it->m_object == m_selectedChannel) { - selectedItem = i; + for (const auto& source : m_availableChannels) { + ui->channels->addItem(source.getLongId()); } - } - ui->channels->blockSignals(false); - - if (m_availableChannels.size() > 0) - { - if (selectedItem >= 0) { - ui->channels->setCurrentIndex(selectedItem); - } else { - ui->channels->setCurrentIndex(0); + int selectedItem = -1; + if (autoSelect) + { + if (!m_settings.m_selectedSource.isEmpty()) + { + selectedItem = m_availableChannels.indexOfLongId(m_settings.m_selectedSource); + } + else + { + selectedItem = m_availableChannels.indexOfObject(m_selectedChannel); + if (selectedItem < 0 && !m_availableChannels.isEmpty()) { + selectedItem = 0; + } + } } + else + { + selectedItem = m_availableChannels.indexOfObject(m_selectedChannel); + if (selectedItem < 0) { + m_settings.m_selectedSource.clear(); + } + } + ui->channels->setCurrentIndex(selectedItem); + } + + // Adding the first item selects it while signals are blocked. Send the + // selection explicitly so the feature registers its data and rate pipes. + if (ui->channels->currentIndex() >= 0) { + on_channels_currentIndexChanged(ui->channels->currentIndex()); } } @@ -296,6 +377,9 @@ void DenoiserGUI::on_startStop_toggled(bool checked) { if (m_doApplySettings) { + if (checked && !m_vst3ScanAttempted) { + scanVst3Plugins({}, true); + } Denoiser::MsgStartStop *message = Denoiser::MsgStartStop::create(checked); m_denoiser->getInputMessageQueue()->push(message); @@ -309,7 +393,8 @@ void DenoiserGUI::on_channels_currentIndexChanged(int index) { if ((index >= 0) && (index < m_availableChannels.size())) { - m_selectedChannel = qobject_cast(m_availableChannels[index].m_object); + m_selectedChannel = m_availableChannels[index].m_object; + m_settings.m_selectedSource = m_availableChannels[index].getLongId(); Denoiser::MsgSelectChannel *msg = Denoiser::MsgSelectChannel::create(m_selectedChannel); m_denoiser->getInputMessageQueue()->push(msg); } @@ -360,11 +445,381 @@ void DenoiserGUI::on_showFileDialog_clicked(bool checked) void DenoiserGUI::on_denoiserType_currentIndexChanged(int index) { - m_settings.m_denoiserType = static_cast(index); + if (index < 0) { + return; + } + m_settings.m_denoiserType = static_cast(ui->denoiserType->itemData(index).toInt()); + if (m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_Vst3 && !m_vst3ScanAttempted) { + scanVst3Plugins({}, true); + } + updateControls(); m_settingsKeys.append("denoiserType"); applySettings(); } +void DenoiserGUI::updateControls() +{ + RollupContents *rollups = getRollupContents(); + const int previousContentHeight = rollups->arrangeRollups(); + const bool showNvidia = m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_Nvidia; + ui->nvidiaIntensityLabel->setVisible(showNvidia); + ui->nvidiaIntensity->setVisible(showNvidia); + ui->nvidiaIntensityText->setVisible(showNvidia); + ui->nvidiaVad->setVisible(showNvidia); + + const bool showVst3 = m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_Vst3; + ui->vst3Plugin->setVisible(showVst3); + ui->vst3Refresh->setVisible(showVst3); + ui->vst3Browse->setVisible(showVst3); + ui->vst3Parameters->setVisible(showVst3); + ui->settingsContainer->layout()->invalidate(); + ui->settingsContainer->layout()->activate(); + const int contentHeight = rollups->arrangeRollups(); + layout()->activate(); + sizeToContents(); + + if (isVisible() && !isMaximized()) { + resize(qMax(width(), minimumWidth()), qMax(height() + contentHeight - previousContentHeight, minimumHeight())); + } +} + +void DenoiserGUI::displayVst3Selection() +{ + const QSignalBlocker blocker(ui->vst3Plugin); + ui->vst3Plugin->clear(); + int selected = -1; + for (const Vst3PluginInfo& plugin : m_vst3Plugins) + { + const int index = ui->vst3Plugin->count(); + ui->vst3Plugin->addItem(plugin.name); + ui->vst3Plugin->setItemData(index, plugin.modulePath, Qt::ToolTipRole); + if (plugin.modulePath == m_settings.m_vst3ModulePath && plugin.classId == m_settings.m_vst3ClassId) { + selected = index; + } + } + if (selected < 0 && !m_settings.m_vst3ModulePath.isEmpty()) + { + selected = ui->vst3Plugin->count(); + ui->vst3Plugin->addItem(QFileInfo(m_settings.m_vst3ModulePath).fileName() + tr(" (saved)")); + ui->vst3Plugin->setItemData(selected, m_settings.m_vst3ModulePath, Qt::ToolTipRole); + } + if (selected >= 0) { + ui->vst3Plugin->setCurrentIndex(selected); + } else { + ui->vst3Plugin->setCurrentIndex(-1); + } +} + +void DenoiserGUI::scanVst3Plugins(const QStringList& paths, bool automatic) +{ + if (m_vst3ScanProcess) { + return; + } + if (paths.isEmpty()) { + m_vst3ScanAttempted = true; + } + auto *process = new QProcess(this); + m_vst3ScanProcess = process; + ui->vst3Refresh->setText(tr("Scanning...")); + ui->vst3Refresh->setToolTip(QString()); + ui->vst3Refresh->setEnabled(false); + ui->vst3Browse->setEnabled(false); + const QString scanner = QDir(QCoreApplication::applicationDirPath()).filePath( +#ifdef Q_OS_WIN + QStringLiteral("sdrangel-vst3-scan.exe") +#else + QStringLiteral("sdrangel-vst3-scan") +#endif + ); + process->setProgram(scanner); + process->setArguments(paths); + connect(process, qOverload(&QProcess::finished), this, + [this, process, automatic](int exitCode, QProcess::ExitStatus status) { + if (m_vst3ScanProcess != process) return; + const QJsonDocument document = QJsonDocument::fromJson(process->readAllStandardOutput()); + if (status != QProcess::NormalExit || exitCode != 0 || !document.isArray()) + { + const QString error = tr("The VST3 scanner failed. A plugin may have crashed during discovery."); + if (automatic) { + ui->vst3Refresh->setToolTip(error); + } else { + QMessageBox::warning(this, tr("VST3 scan"), error); + } + displayVst3Selection(); + } + else + { + for (const QJsonValue& value : document.array()) + { + const QJsonObject object = value.toObject(); + Vst3PluginInfo plugin; + plugin.modulePath = object.value(QStringLiteral("path")).toString(); + plugin.classId = QByteArray::fromHex(object.value(QStringLiteral("id")).toString().toLatin1()); + plugin.name = object.value(QStringLiteral("name")).toString(); + if (plugin.modulePath.isEmpty() || plugin.classId.size() != 16) continue; + bool duplicate = false; + for (const Vst3PluginInfo& known : m_vst3Plugins) + { + if (known.modulePath == plugin.modulePath && known.classId == plugin.classId) + { + duplicate = true; + break; + } + } + if (!duplicate) { + m_vst3Plugins.append(plugin); + } + } + displayVst3Selection(); + if (m_vst3Plugins.isEmpty()) + { + const QString message = tr("No VST3 audio effects were found."); + if (automatic) { + ui->vst3Refresh->setToolTip(message); + } else { + QMessageBox::information(this, tr("VST3 effects"), message); + } + } + } + ui->vst3Refresh->setText(tr("Scan")); + ui->vst3Refresh->setEnabled(true); + ui->vst3Browse->setEnabled(true); + m_vst3ScanProcess = nullptr; + process->deleteLater(); + }); + connect(process, &QProcess::errorOccurred, this, [this, process, automatic](QProcess::ProcessError error) { + if (error != QProcess::FailedToStart || m_vst3ScanProcess != process) { + return; + } + const QString message = tr("Could not launch the VST3 scanner: %1").arg(process->errorString()); + if (automatic) { + ui->vst3Refresh->setToolTip(message); + } else { + QMessageBox::warning(this, tr("VST3 scan"), message); + } + displayVst3Selection(); + ui->vst3Refresh->setText(tr("Scan")); + ui->vst3Refresh->setEnabled(true); + ui->vst3Browse->setEnabled(true); + m_vst3ScanProcess = nullptr; + process->deleteLater(); + }); + process->start(); + QPointer guarded(process); + QTimer::singleShot(300000, this, [guarded]() { + if (guarded && guarded->state() != QProcess::NotRunning) guarded->kill(); + }); +} + +void DenoiserGUI::on_vst3Plugin_currentIndexChanged(int index) +{ + if (index < 0 || index >= m_vst3Plugins.size()) { + return; + } + const Vst3PluginInfo& plugin = m_vst3Plugins[index]; + m_settings.m_vst3ModulePath = plugin.modulePath; + m_settings.m_vst3ClassId = plugin.classId; + m_settings.m_vst3Parameters.clear(); + m_settings.m_vst3State.clear(); + m_settingsKeys.append("vst3ModulePath"); + m_settingsKeys.append("vst3ClassId"); + m_settingsKeys.append("vst3Parameters"); + m_settingsKeys.append("vst3State"); + applySettings(); +} + +void DenoiserGUI::on_vst3Refresh_clicked() +{ + m_vst3Plugins.clear(); + scanVst3Plugins(); +} + +void DenoiserGUI::on_vst3Browse_clicked() +{ +#ifdef Q_OS_WIN + const QString path = QFileDialog::getOpenFileName(this, tr("Select VST3 effect"), QString(), tr("VST3 effects (*.vst3)")); +#else + const QString path = QFileDialog::getExistingDirectory(this, tr("Select VST3 bundle")); +#endif + if (!path.isEmpty()) { + scanVst3Plugins({path}); + } +} + +void DenoiserGUI::on_vst3Parameters_clicked() +{ + if (m_settings.m_vst3ModulePath.isEmpty() || m_settings.m_vst3ClassId.size() != 16) + { + QMessageBox::information(this, tr("VST3 parameters"), + tr("Select a VST3 effect from the list first.")); + return; + } + + // Keep the editor instance independent of the audio worker. Audio format or + // channel changes can then recreate the processing instance safely. + auto parameterEffect = std::make_unique(); + QString error; + if (!parameterEffect->open(m_settings.m_vst3ModulePath, m_settings.m_vst3ClassId, + m_sampleRate > 0 ? m_sampleRate : 48000, 2, error, m_settings.m_vst3State)) + { + QMessageBox::warning(this, tr("VST3 parameters"), + tr("Could not load the selected VST3 effect: %1").arg(error)); + return; + } + for (auto it = m_settings.m_vst3Parameters.cbegin(); it != m_settings.m_vst3Parameters.cend(); ++it) { + parameterEffect->setParameter(it.key(), it.value()); + } + parameterEffect->setParameterEditCallback([this](quint32 id, double value) { + if (m_settings.m_vst3Parameters.value(id, -1.0) == value) { + return; + } + m_settings.m_vst3Parameters.insert(id, value); + m_settingsKeys.append("vst3Parameters"); + applySettings(); + }); + + QDialog dialog(this); + dialog.setWindowTitle(tr("VST3 parameters")); + auto *outer = new QVBoxLayout(&dialog); + if (!m_denoiser->hasVst3Effect()) + { + auto *notice = new QLabel(tr("Live processing was unavailable when this dialog opened. Changes are saved and applied when the effect loads."), &dialog); + notice->setWordWrap(true); + outer->addWidget(notice); + } + QString editorError; + auto *nativeScroll = new QScrollArea(&dialog); + nativeScroll->setWidgetResizable(false); + if (QWidget *editor = parameterEffect->createEditorWidget(nativeScroll->viewport(), editorError)) + { + nativeScroll->setWidget(editor); + outer->addWidget(nativeScroll); + if (QScreen *screen = dialog.screen()) + { + const QRect available = screen->availableGeometry(); + dialog.resize(qMin(editor->width() + 36, available.width() - 80), + qMin(editor->height() + 64, available.height() - 80)); + } + else + { + dialog.adjustSize(); + } + dialog.exec(); + saveVst3State(*parameterEffect); + return; + } + delete nativeScroll; + + const QVector parameters = parameterEffect->parameters(); + bool hasEditableParameter = false; + for (const Vst3ParameterInfo& parameter : parameters) + { + if (!parameter.readOnly && !parameter.hidden) + { + hasEditableParameter = true; + break; + } + } + if (!hasEditableParameter) + { + QMessageBox::information(this, tr("VST3 parameters"), + tr("This VST3 effect has no available editor or editable parameters. %1").arg(editorError)); + return; + } + dialog.resize(440, 500); + auto *scroll = new QScrollArea(&dialog); + scroll->setWidgetResizable(true); + outer->addWidget(scroll); + auto *content = new QWidget(scroll); + auto *layout = new QVBoxLayout(content); + for (const Vst3ParameterInfo& parameter : parameters) + { + if (parameter.readOnly || parameter.hidden) { + continue; + } + auto *row = new QWidget(content); + auto *rowLayout = new QHBoxLayout(row); + auto *name = new QLabel(parameter.name, row); + name->setMinimumWidth(130); + auto *slider = new QSlider(Qt::Horizontal, row); + const int maximum = parameter.steps > 0 ? qMin(parameter.steps, 10000) : 1000; + slider->setRange(0, maximum); + const double value = m_settings.m_vst3Parameters.value(parameter.id, parameter.currentValue); + slider->setValue(qRound(value * maximum)); + auto *valueLabel = new QLabel(parameterEffect->parameterText(parameter.id, value), row); + valueLabel->setMinimumWidth(70); + valueLabel->setMaximumWidth(120); + rowLayout->addWidget(name); + rowLayout->addWidget(slider, 1); + rowLayout->addWidget(valueLabel); + layout->addWidget(row); + connect(slider, &QSlider::valueChanged, &dialog, [this, parameter, maximum, valueLabel, effect = parameterEffect.get()](int raw) { + const double normalized = static_cast(raw) / maximum; + effect->setParameter(parameter.id, normalized); + valueLabel->setText(effect->parameterText(parameter.id, normalized)); + m_settings.m_vst3Parameters.insert(parameter.id, normalized); + m_settingsKeys.append("vst3Parameters"); + applySettings(); + }); + } + layout->addStretch(); + scroll->setWidget(content); + dialog.exec(); + saveVst3State(*parameterEffect); +} + +void DenoiserGUI::saveVst3State(Vst3Effect& effect) +{ + QString error; + const QByteArray state = effect.state(error); + if (state.isEmpty()) + { + qWarning() << "DenoiserGUI::saveVst3State:" << error; + return; + } + + // Editor changes such as presets may bypass performEdit, so refresh the saved + // parameter values. Otherwise they would override the state when it is restored. + bool parametersChanged = false; + for (auto it = m_settings.m_vst3Parameters.begin(); it != m_settings.m_vst3Parameters.end(); ++it) + { + const double value = effect.parameterValue(it.key()); + if (value >= 0.0 && value != it.value()) + { + it.value() = value; + parametersChanged = true; + } + } + + if (state == m_settings.m_vst3State && !parametersChanged) { + return; + } + m_settings.m_vst3State = state; + m_settingsKeys.append("vst3State"); + if (parametersChanged) { + m_settingsKeys.append("vst3Parameters"); + } + applySettings(); +} + +void DenoiserGUI::on_nvidiaIntensity_valueChanged(int value) +{ + ui->nvidiaIntensityText->setText(QStringLiteral("%1%").arg(value)); + if (ui->nvidiaIntensity->isSliderDown() || m_settings.m_nvidiaIntensity == value) { + return; + } + m_settings.m_nvidiaIntensity = value; + m_settingsKeys.append("nvidiaIntensity"); + applySettings(); +} + +void DenoiserGUI::on_nvidiaVad_toggled(bool checked) +{ + m_settings.m_nvidiaVad = checked; + m_settingsKeys.append("nvidiaVad"); + applySettings(); +} + void DenoiserGUI::on_enable_toggled(bool checked) { m_settings.m_enableDenoiser = checked; @@ -415,6 +870,9 @@ void DenoiserGUI::tick() void DenoiserGUI::updateFeatureState() { updateStartStopButton(ui->startStop); + if (m_denoiser->getState() == Feature::StRunning && !m_vst3ScanAttempted) { + scanVst3Plugins({}, true); + } } void DenoiserGUI::displayNRenabled() @@ -445,6 +903,15 @@ void DenoiserGUI::makeUIConnections() QObject::connect(ui->record, &ButtonSwitch::toggled, this, &DenoiserGUI::on_record_toggled); QObject::connect(ui->showFileDialog, &QPushButton::clicked, this, &DenoiserGUI::on_showFileDialog_clicked); QObject::connect(ui->denoiserType, qOverload(&QComboBox::currentIndexChanged), this, &DenoiserGUI::on_denoiserType_currentIndexChanged); + QObject::connect(ui->nvidiaIntensity, &QSlider::valueChanged, this, &DenoiserGUI::on_nvidiaIntensity_valueChanged); + QObject::connect(ui->nvidiaIntensity, &QSlider::sliderReleased, this, [this]() { + on_nvidiaIntensity_valueChanged(ui->nvidiaIntensity->value()); + }); + QObject::connect(ui->nvidiaVad, &QCheckBox::toggled, this, &DenoiserGUI::on_nvidiaVad_toggled); + QObject::connect(ui->vst3Plugin, qOverload(&QComboBox::currentIndexChanged), this, &DenoiserGUI::on_vst3Plugin_currentIndexChanged); + QObject::connect(ui->vst3Refresh, &QPushButton::clicked, this, &DenoiserGUI::on_vst3Refresh_clicked); + QObject::connect(ui->vst3Browse, &QPushButton::clicked, this, &DenoiserGUI::on_vst3Browse_clicked); + QObject::connect(ui->vst3Parameters, &QPushButton::clicked, this, &DenoiserGUI::on_vst3Parameters_clicked); QObject::connect(ui->enable, &ButtonSwitch::toggled, this, &DenoiserGUI::on_enable_toggled); QObject::connect(ui->audioMute, &ButtonSwitch::toggled, this, &DenoiserGUI::on_audioMute_toggled); QObject::connect(ui->volume, &QDial::valueChanged, this, &DenoiserGUI::on_volume_valueChanged); diff --git a/plugins/feature/denoiser/denoisergui.h b/plugins/feature/denoiser/denoisergui.h index 7e3fa589e..c76eec283 100644 --- a/plugins/feature/denoiser/denoisergui.h +++ b/plugins/feature/denoiser/denoisergui.h @@ -27,11 +27,13 @@ #include "settings/rollupstate.h" #include "denoisersettings.h" +#include "vst3effect.h" class PluginAPI; class FeatureUISet; class Denoiser; class Feature; +class QProcess; namespace Ui { class DenoiserGUI; @@ -65,8 +67,11 @@ private: Denoiser* m_denoiser; MessageQueue m_inputMessageQueue; AvailableChannelOrFeatureList m_availableChannels; - ChannelAPI *m_selectedChannel; + QObject *m_selectedChannel; MovingAverageUtil m_channelPowerAvg; + QVector m_vst3Plugins; + QProcess *m_vst3ScanProcess = nullptr; + bool m_vst3ScanAttempted = false; explicit DenoiserGUI(PluginAPI* pluginAPI, FeatureUISet *featureUISet, Feature *feature, QWidget* parent = nullptr); virtual ~DenoiserGUI(); @@ -76,7 +81,11 @@ private: void displaySettings(); void displaySampleRate(int sampleRate); void displayNRenabled(); - void updateChannelList(); + void updateControls(); + void displayVst3Selection(); + void saveVst3State(Vst3Effect& effect); + void scanVst3Plugins(const QStringList& paths = {}, bool automatic = false); + void updateChannelList(bool autoSelect); bool handleMessage(const Message& message); void makeUIConnections(); @@ -90,6 +99,12 @@ private slots: void on_record_toggled(bool checked); void on_showFileDialog_clicked(bool checked); void on_denoiserType_currentIndexChanged(int index); + void on_nvidiaIntensity_valueChanged(int value); + void on_nvidiaVad_toggled(bool checked); + void on_vst3Plugin_currentIndexChanged(int index); + void on_vst3Refresh_clicked(); + void on_vst3Browse_clicked(); + void on_vst3Parameters_clicked(); void on_enable_toggled(bool checked); void on_audioMute_toggled(bool checked); void on_volume_valueChanged(int value); diff --git a/plugins/feature/denoiser/denoisergui.ui b/plugins/feature/denoiser/denoisergui.ui index b9e716f9b..ffe4eb921 100644 --- a/plugins/feature/denoiser/denoisergui.ui +++ b/plugins/feature/denoiser/denoisergui.ui @@ -93,8 +93,11 @@ + + Audio source channel or feature + - Chan + Source @@ -137,14 +140,14 @@ 00000.0 kS/s - Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + Qt::AlignmentFlag::AlignRight|Qt::AlignmentFlag::AlignTrailing|Qt::AlignmentFlag::AlignVCenter - Qt::Horizontal + Qt::Orientation::Horizontal @@ -166,13 +169,13 @@ Channel power - Qt::LeftToRight + Qt::LayoutDirection::LeftToRight -100.0 dB - Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + Qt::AlignmentFlag::AlignRight|Qt::AlignmentFlag::AlignTrailing|Qt::AlignmentFlag::AlignVCenter @@ -201,6 +204,16 @@ RNnoise + + + NVIDIA Noise Removal + + + + + VST3 Effect + + @@ -227,7 +240,7 @@ - Qt::Horizontal + Qt::Orientation::Horizontal @@ -257,10 +270,125 @@ + + + + 0 + + + 0 + + + 0 + + + 0 + + + + + Strength + + + + + + + Noise removal strength: lower values preserve more weak speech + + + 100 + + + 100 + + + Qt::Orientation::Horizontal + + + + + + + 100% + + + + + + + Voice activity detection: may suppress weak or misclassified speech + + + VAD + + + + + + + + + 0 + + + 0 + + + 0 + + + 0 + + + + + + 0 + 0 + + + + Selected VST3 audio effect + + + + + + + Scan installed VST3 effects + + + Scan + + + + + + + Select a VST3 module outside standard plugin folders + + + ... + + + + + + + Edit the effect's parameters + + + Params + + + + + - Qt::Horizontal + Qt::Orientation::Horizontal @@ -310,7 +438,7 @@ 1.0 - Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + Qt::AlignmentFlag::AlignRight|Qt::AlignmentFlag::AlignTrailing|Qt::AlignmentFlag::AlignVCenter @@ -338,7 +466,7 @@ - Qt::Horizontal + Qt::Orientation::Horizontal @@ -402,7 +530,7 @@ ... - Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter + Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignVCenter @@ -412,17 +540,17 @@ - - ButtonSwitch - QToolButton -
gui/buttonswitch.h
-
RollupContents QWidget
gui/rollupcontents.h
1
+ + ButtonSwitch + QToolButton +
gui/buttonswitch.h
+
LevelMeterVU QWidget diff --git a/plugins/feature/denoiser/denoisersettings.cpp b/plugins/feature/denoiser/denoisersettings.cpp index e695554f6..bee017736 100644 --- a/plugins/feature/denoiser/denoisersettings.cpp +++ b/plugins/feature/denoiser/denoisersettings.cpp @@ -20,6 +20,9 @@ #include "audio/audiodevicemanager.h" #include "denoisersettings.h" +#include +#include +#include const QStringList DenoiserSettings::m_channelURIs = { QStringLiteral("sdrangel.channel.amdemod"), @@ -31,6 +34,7 @@ const QStringList DenoiserSettings::m_channelURIs = { QStringLiteral("sdrangel.channel.ssbdemod"), QStringLiteral("sdrangel.channel.wfmdemod"), QStringLiteral("sdrangel.channel.wdsprx"), + QStringLiteral("sdrangel.feature.denoiser"), }; DenoiserSettings::DenoiserSettings() : @@ -42,10 +46,17 @@ DenoiserSettings::DenoiserSettings() : void DenoiserSettings::resetToDefaults() { m_denoiserType = DenoiserType::DenoiserType_RNnoise; + m_selectedSource.clear(); m_title = "Denoiser"; m_enableDenoiser = true; m_audioMute = false; m_volumeTenths = 10; + m_nvidiaIntensity = 100; + m_nvidiaVad = false; + m_vst3ModulePath.clear(); + m_vst3ClassId.clear(); + m_vst3Parameters.clear(); + m_vst3State.clear(); m_audioDeviceName = AudioDeviceManager::m_defaultDeviceName; m_rgbColor = 0xffd700; // gold m_useReverseAPI = false; @@ -84,6 +95,17 @@ QByteArray DenoiserSettings::serialize() const s.writeString(15, m_audioDeviceName); s.writeBool(16, m_enableDenoiser); s.writeS32(17, m_volumeTenths); + s.writeS32(18, m_nvidiaIntensity); + s.writeBool(19, m_nvidiaVad); + s.writeString(20, m_vst3ModulePath); + s.writeBlob(21, m_vst3ClassId); + QJsonObject parameters; + for (auto it = m_vst3Parameters.cbegin(); it != m_vst3Parameters.cend(); ++it) { + parameters.insert(QString::number(it.key()), it.value()); + } + s.writeBlob(22, QJsonDocument(parameters).toJson(QJsonDocument::Compact)); + s.writeString(23, m_selectedSource); + s.writeBlob(24, m_vst3State); return s.final(); } @@ -105,7 +127,7 @@ bool DenoiserSettings::deserialize(const QByteArray& data) uint32_t utmp; d.readS32(1, &itmp, 1); - m_denoiserType = static_cast(itmp); + m_denoiserType = static_cast(itmp >= 0 && itmp <= 3 ? itmp : 1); d.readString(2, &m_title, "Denoiser"); d.readU32(3, &m_rgbColor, 0xffd700); // gold d.readBool(4, &m_useReverseAPI, false); @@ -137,6 +159,26 @@ bool DenoiserSettings::deserialize(const QByteArray& data) d.readString(15, &m_audioDeviceName, AudioDeviceManager::m_defaultDeviceName); d.readBool(16, &m_enableDenoiser, true); d.readS32(17, &m_volumeTenths, 10); + d.readS32(18, &m_nvidiaIntensity, 100); + m_nvidiaIntensity = qBound(0, m_nvidiaIntensity, 100); + d.readBool(19, &m_nvidiaVad, false); + d.readString(20, &m_vst3ModulePath, ""); + d.readBlob(21, &m_vst3ClassId); + bytetmp.clear(); + d.readBlob(22, &bytetmp); + m_vst3Parameters.clear(); + const QJsonObject parameters = QJsonDocument::fromJson(bytetmp).object(); + for (auto it = parameters.begin(); it != parameters.end(); ++it) + { + bool validId = false; + const quint32 id = it.key().toUInt(&validId); + const double value = it.value().toDouble(-1.0); + if (validId && value >= 0.0 && value <= 1.0) { + m_vst3Parameters.insert(id, value); + } + } + d.readString(23, &m_selectedSource, ""); + d.readBlob(24, &m_vst3State); return true; } @@ -149,6 +191,9 @@ bool DenoiserSettings::deserialize(const QByteArray& data) void DenoiserSettings::applySettings(const QStringList& settingsKeys, const DenoiserSettings& settings) { + if (settingsKeys.contains("selectedSource")) { + m_selectedSource = settings.m_selectedSource; + } if (settingsKeys.contains("denoiserType")) { m_denoiserType = settings.m_denoiserType; } @@ -161,6 +206,24 @@ void DenoiserSettings::applySettings(const QStringList& settingsKeys, const Deno if (settingsKeys.contains("volumeTenths")) { m_volumeTenths = settings.m_volumeTenths; } + if (settingsKeys.contains("nvidiaIntensity")) { + m_nvidiaIntensity = qBound(0, settings.m_nvidiaIntensity, 100); + } + if (settingsKeys.contains("nvidiaVad")) { + m_nvidiaVad = settings.m_nvidiaVad; + } + if (settingsKeys.contains("vst3ModulePath")) { + m_vst3ModulePath = settings.m_vst3ModulePath; + } + if (settingsKeys.contains("vst3ClassId")) { + m_vst3ClassId = settings.m_vst3ClassId; + } + if (settingsKeys.contains("vst3Parameters")) { + m_vst3Parameters = settings.m_vst3Parameters; + } + if (settingsKeys.contains("vst3State")) { + m_vst3State = settings.m_vst3State; + } if (settingsKeys.contains("audioDeviceName")) { m_audioDeviceName = settings.m_audioDeviceName; } @@ -200,6 +263,9 @@ QString DenoiserSettings::getDebugString(const QStringList& settingsKeys, bool f { QString debugString; + if (settingsKeys.contains("selectedSource") || force) { + debugString += QString("Selected source: %1 ").arg(m_selectedSource); + } if (settingsKeys.contains("denoiserType") || force) { debugString += QString("DenoiserType: %1 ").arg(static_cast(m_denoiserType)); } @@ -212,6 +278,21 @@ QString DenoiserSettings::getDebugString(const QStringList& settingsKeys, bool f if (settingsKeys.contains("volumeTenths") || force) { debugString += QString("Volume : %1 ").arg(m_volumeTenths/10.0); } + if (settingsKeys.contains("nvidiaIntensity") || force) { + debugString += QString("NVIDIA intensity: %1%% ").arg(m_nvidiaIntensity); + } + if (settingsKeys.contains("nvidiaVad") || force) { + debugString += QString("NVIDIA VAD: %1 ").arg(m_nvidiaVad ? "true" : "false"); + } + if (settingsKeys.contains("vst3ModulePath") || force) { + debugString += QString("VST3 module: %1 ").arg(m_vst3ModulePath); + } + if (settingsKeys.contains("vst3ClassId") || force) { + debugString += QString("VST3 class: %1 ").arg(QString::fromLatin1(m_vst3ClassId.toHex())); + } + if (settingsKeys.contains("vst3State") || force) { + debugString += QString("VST3 state: %1 bytes ").arg(m_vst3State.size()); + } if (settingsKeys.contains("audioDeviceName") || force) { debugString += QString("Audio Device Name: %1 ").arg(m_audioDeviceName); } diff --git a/plugins/feature/denoiser/denoisersettings.h b/plugins/feature/denoiser/denoisersettings.h index e75a26728..93511522e 100644 --- a/plugins/feature/denoiser/denoisersettings.h +++ b/plugins/feature/denoiser/denoisersettings.h @@ -20,6 +20,7 @@ #include #include #include +#include class Serializable; @@ -29,12 +30,21 @@ struct DenoiserSettings { DenoiserType_None = 0, DenoiserType_RNnoise = 1, + DenoiserType_Nvidia = 2, + DenoiserType_Vst3 = 3, }; DenoiserType m_denoiserType; + QString m_selectedSource; bool m_enableDenoiser; bool m_audioMute; int m_volumeTenths; + int m_nvidiaIntensity; + bool m_nvidiaVad; + QString m_vst3ModulePath; + QByteArray m_vst3ClassId; + QMap m_vst3Parameters; + QByteArray m_vst3State; //!< Opaque plugin state from Vst3Effect::state() QString m_audioDeviceName; QString m_title; quint32 m_rgbColor; diff --git a/plugins/feature/denoiser/denoiserworker.cpp b/plugins/feature/denoiser/denoiserworker.cpp index 2b70fce7f..3010e7fad 100644 --- a/plugins/feature/denoiser/denoiserworker.cpp +++ b/plugins/feature/denoiser/denoiserworker.cpp @@ -18,28 +18,44 @@ #include "dsp/wavfilerecord.h" #include "audio/audiodevicemanager.h" #include "dsp/dspengine.h" +#include "pipes/datapipes.h" +#include "maincore.h" #include "rnnoise.h" +#include +#include #include "denoiserworker.h" +#include "vst3effect.h" const int DenoiserWorker::m_levelNbSamples = 480; // 10 ms at 48 kHz MESSAGE_CLASS_DEFINITION(DenoiserWorker::MsgConfigureDenoiserWorker, Message) MESSAGE_CLASS_DEFINITION(DenoiserWorker::MsgConnectFifo, Message) +MESSAGE_CLASS_DEFINITION(DenoiserWorker::MsgReportNvidiaStatus, Message) +MESSAGE_CLASS_DEFINITION(DenoiserWorker::MsgReportVst3Status, Message) DenoiserWorker::DenoiserWorker(QObject *parent) : QObject(parent), m_dataFifo(nullptr), + m_demodProducer(nullptr), m_sinkSampleRate(0), m_msgQueueToFeature(nullptr), m_magsq(0.0), - m_sampleBufferSize(0), m_channelPowerAvg(), m_wavFileRecord(nullptr), m_recordSilenceNbSamples(0), m_recordSilenceCount(0), m_nbBytes(0), - m_rnnoiseFill(0) + m_rnnoiseFill(0), + m_nvidiaFill(0), + m_nvidiaInitAttempted(false), + m_nvidiaReady(false), + m_nvidiaResetPending(false), + m_nvidiaStatusReported(false), + m_nvidiaGeneration(0), + m_vst3Effect(nullptr), + m_vst3Fill(0), + m_vst3FailureReported(false) { m_audioBuffer.resize(4800); m_audioBufferFill = 0; @@ -53,6 +69,7 @@ DenoiserWorker::~DenoiserWorker() m_inputMessageQueue.clear(); DSPEngine::instance()->getAudioDeviceManager()->removeAudioSink(getAudioFifo()); rnnoise_destroy(m_rnnoiseState); + m_nvidiaDenoiser.shutdown(); } void DenoiserWorker::reset() @@ -106,24 +123,56 @@ void DenoiserWorker::feedPart( m_nbBytes = nbBytes; int countSamples = (end - begin) / nbBytes; - if (countSamples > m_sampleBufferSize) - { - m_sampleBuffer.resize(countSamples); - m_sampleBufferSize = countSamples; - } + m_sampleBuffer.clear(); + m_sampleBuffer.reserve(countSamples); for (int i = 0; i < countSamples; i++) { processSample(dataType, begin, i); } + flushAudio(); + if (m_settings.m_recordToFile && m_wavFileRecord) { for (const auto& sample : m_sampleBuffer) { writeSampleToFile(sample); } + } + + m_sampleBuffer.clear(); +} + +void DenoiserWorker::flushAudio() +{ + if (m_audioBufferFill == 0) return; + + if (m_demodProducer) + { + QList pipes; + MainCore::instance()->getDataPipes().getDataPipes(m_demodProducer, "demod", pipes); + const auto *data = reinterpret_cast(m_audioBuffer.data()); + const unsigned int byteCount = static_cast(m_audioBufferFill * sizeof(AudioSample)); + + for (const auto& pipe : pipes) + { + DataFifo *fifo = qobject_cast(pipe->m_element); + if (fifo) { + fifo->write(data, byteCount, DataFifo::DataTypeCI16); + } + } + } + + if (m_settings.m_audioMute) { + std::fill_n(m_audioBuffer.begin(), m_audioBufferFill, AudioSample{0, 0}); + } - m_sampleBuffer.clear(); + const std::size_t written = m_audioFifo.write(reinterpret_cast(m_audioBuffer.data()), m_audioBufferFill); + if (written != m_audioBufferFill) + { + qDebug("DenoiserWorker::flushAudio: %lu/%lu audio samples written", written, m_audioBufferFill); + m_audioFifo.clear(); } + m_audioBufferFill = 0; } void DenoiserWorker::writeSampleToFile(const Sample& sample) @@ -271,8 +320,12 @@ void DenoiserWorker::applySettings(const DenoiserSettings& settings, const QStri // TODO: handle sample rate change } - if (settingsKeys.contains("enableDenoiser") || settingsKeys.contains("denoiserType") || force) { + if (settingsKeys.contains("enableDenoiser") || settingsKeys.contains("denoiserType") || + settingsKeys.contains("nvidiaIntensity") || + settingsKeys.contains("nvidiaVad") || force) + { m_rnnoiseFill = 0; + resetNvidia(); } if (force) { @@ -280,12 +333,35 @@ void DenoiserWorker::applySettings(const DenoiserSettings& settings, const QStri } else { m_settings.applySettings(settingsKeys, settings); } + if (force || settingsKeys.contains("denoiserType") || settingsKeys.contains("vst3ModulePath") || + settingsKeys.contains("vst3ClassId") || settingsKeys.contains("enableDenoiser")) + { + m_vst3Fill = 0; + m_vst3FailureReported = false; + } + + // applySettings runs on the worker thread. Release the CUDA effect as soon as + // this backend is no longer in use, even if no more NVIDIA samples arrive. + if (m_nvidiaResetPending && (!m_settings.m_enableDenoiser || + m_settings.m_denoiserType != DenoiserSettings::DenoiserType::DenoiserType_Nvidia)) + { + m_nvidiaDenoiser.shutdown(); + m_nvidiaResetPending = false; + } } void DenoiserWorker::applySampleRate(int sampleRate) { QMutexLocker mutexLocker(&m_mutex); + + if (m_sinkSampleRate == sampleRate) { + return; + } + m_sinkSampleRate = sampleRate; + resetNvidia(); + m_vst3Fill = 0; + m_vst3FailureReported = false; if (m_wavFileRecord) { @@ -297,8 +373,82 @@ void DenoiserWorker::applySampleRate(int sampleRate) } } +void DenoiserWorker::setVst3Effect(Vst3Effect *effect) +{ + QMutexLocker mutexLocker(&m_mutex); + m_vst3Effect = effect; + m_vst3Fill = 0; + m_vst3FailureReported = false; +} + +void DenoiserWorker::resetNvidia() +{ + // Caller holds m_mutex. The model itself is released on the worker thread. + m_nvidiaFill = 0; + m_nvidiaInitAttempted = false; + m_nvidiaReady = false; + m_nvidiaResetPending = true; + m_nvidiaStatusReported = false; + ++m_nvidiaGeneration; +} + +void DenoiserWorker::prepareNvidia() +{ + int sampleRate; + float intensity; + bool vad; + quint32 generation; + + { + QMutexLocker mutexLocker(&m_mutex); + + if (m_nvidiaInitAttempted || !m_settings.m_enableDenoiser || + m_settings.m_denoiserType != DenoiserSettings::DenoiserType::DenoiserType_Nvidia) { + return; + } + + if (m_nvidiaResetPending) + { + m_nvidiaDenoiser.shutdown(); + m_nvidiaResetPending = false; + } + + m_nvidiaInitAttempted = true; + sampleRate = m_sinkSampleRate; + intensity = qBound(0, m_settings.m_nvidiaIntensity, 100) / 100.0f; + vad = m_settings.m_nvidiaVad; + generation = m_nvidiaGeneration; + } + + // Loading the model can take seconds. Do it without m_mutex so the feature + // thread is not blocked by applySampleRate() or setVst3Effect() meanwhile. + // m_nvidiaDenoiser is only used on this thread, as NVIDIA requires. + QString error; + bool ready = false; + + if (sampleRate != 48000) { + error = QStringLiteral("NVIDIA Noise Removal requires 48 kHz input; got %1 Hz.").arg(sampleRate); + } else { + ready = m_nvidiaDenoiser.initialize(error, intensity, vad); + } + + QMutexLocker mutexLocker(&m_mutex); + + if (generation != m_nvidiaGeneration) { + return; // Settings or rate changed while loading; reset and retry on the next data. + } + + m_nvidiaReady = ready; + + if (!ready) { + reportNvidiaError(error + QStringLiteral(" Audio is passing through.")); + } +} + void DenoiserWorker::handleData() { + prepareNvidia(); + QMutexLocker mutexLocker(&m_mutex); while ((m_dataFifo->fill() > 0) && (m_inputMessageQueue.size() == 0)) @@ -347,11 +497,14 @@ void DenoiserWorker::processSample( m_magsq = re*re; m_channelPowerAvg(m_magsq); - if ((!m_settings.m_enableDenoiser || m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_None) && !m_settings.m_audioMute) { + if (!m_settings.m_enableDenoiser || m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_None) { processI16DenoiserNone(samplefp); - } - else if ((m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_RNnoise) && !m_settings.m_audioMute) { + } else if (m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_RNnoise) { processI16DenoiserRNNoise(samplefp); + } else if (m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_Nvidia) { + processNvidiaSample(samplefp); + } else if (m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_Vst3) { + processVst3Sample(samplefp, samplefp); } } break; @@ -366,11 +519,14 @@ void DenoiserWorker::processSample( m_magsq = re*re + im*im; m_channelPowerAvg(m_magsq); - if ((!m_settings.m_enableDenoiser || m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_None) && !m_settings.m_audioMute) { + if (!m_settings.m_enableDenoiser || m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_None) { processCI16DenoiserNone(samplefpRe, samplefpIm); - } - else if ((m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_RNnoise) && !m_settings.m_audioMute) { + } else if (m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_RNnoise) { processCI16DenoiserRNNoise(samplefpRe, samplefpIm); + } else if (m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_Nvidia) { + processNvidiaSample((samplefpRe + samplefpIm) / 2.0); + } else if (m_settings.m_denoiserType == DenoiserSettings::DenoiserType::DenoiserType_Vst3) { + processVst3Sample(samplefpRe, samplefpIm); } } break; @@ -389,15 +545,7 @@ void DenoiserWorker::processI16DenoiserNone(const double& samplefp) if (m_audioBufferFill >= m_audioBuffer.size()) { - std::size_t res = m_audioFifo.write((const quint8*)&m_audioBuffer[0], m_audioBufferFill); - - if (res != m_audioBufferFill) - { - qDebug("DenoiserWorker::processSample: %lu/%lu audio samples written", res, m_audioBufferFill); - m_audioFifo.clear(); - } - - m_audioBufferFill = 0; + flushAudio(); } } @@ -428,15 +576,7 @@ void DenoiserWorker::processI16DenoiserRNNoise(const double& samplefp) if (m_audioBufferFill >= m_audioBuffer.size()) { - std::size_t res = m_audioFifo.write((const quint8*)&m_audioBuffer[0], m_audioBufferFill); - - if (res != m_audioBufferFill) - { - qDebug("DenoiserWorker::processSample: %lu/%lu audio samples written", res, m_audioBufferFill); - m_audioFifo.clear(); - } - - m_audioBufferFill = 0; + flushAudio(); } } @@ -444,6 +584,124 @@ void DenoiserWorker::processI16DenoiserRNNoise(const double& samplefp) } } +void DenoiserWorker::processNvidiaSample(const double& samplefp) +{ + if (m_nvidiaResetPending) + { + m_nvidiaDenoiser.shutdown(); + m_nvidiaResetPending = false; + } + + // NvAFX_Run uses mono, normalized floating point audio in 10 ms frames. + m_nvidiaIn[m_nvidiaFill++] = static_cast(std::max(-1.0, std::min(1.0, samplefp / 32768.0))); + + if (m_nvidiaFill < m_nvidiaFrameSize) { + return; + } + + // The model is loaded by prepareNvidia() outside m_mutex; pass through until it is ready. + bool processed = false; + + if (m_nvidiaReady) + { + QString error; + processed = m_nvidiaDenoiser.process(m_nvidiaIn, m_nvidiaOut, error); + + if (!processed) + { + m_nvidiaReady = false; + reportNvidiaError(error + QStringLiteral(" Audio is passing through.")); + } + } + + if (processed && !m_nvidiaStatusReported) + { + if (m_msgQueueToFeature) { + m_msgQueueToFeature->push(MsgReportNvidiaStatus::create(QString())); + } + m_nvidiaStatusReported = true; + } + + for (int j = 0; j < m_nvidiaFrameSize; ++j) + { + const double normalized = processed && std::isfinite(m_nvidiaOut[j]) ? m_nvidiaOut[j] : m_nvidiaIn[j]; + const double sample = std::max(-32768.0, std::min(32767.0, normalized * 32768.0)); + const int16_t audioSample = static_cast(sample); + + if (m_channelPowerAvg.asDouble() > 1e-4) { + m_sampleBuffer.push_back(Sample(static_cast(audioSample) * (SDR_RX_SAMP_SZ == 24 ? 256 : 1), 0)); + } + + m_audioBuffer[m_audioBufferFill].l = audioSample; + m_audioBuffer[m_audioBufferFill].r = audioSample; + ++m_audioBufferFill; + + if (m_audioBufferFill >= m_audioBuffer.size()) + { + flushAudio(); + } + } + + m_nvidiaFill = 0; +} + +void DenoiserWorker::reportNvidiaError(const QString& error) +{ + qWarning() << "DenoiserWorker:" << error; + m_nvidiaStatusReported = false; + if (m_msgQueueToFeature) { + m_msgQueueToFeature->push(MsgReportNvidiaStatus::create(error)); + } +} + +void DenoiserWorker::processVst3Sample(double left, double right) +{ + const int i = m_vst3Fill++; + m_vst3Input[0][i] = static_cast(std::max(-1.0, std::min(1.0, left / 32768.0))); + m_vst3Input[1][i] = static_cast(std::max(-1.0, std::min(1.0, right / 32768.0))); + if (m_vst3Fill != m_vst3BlockSize) { + return; + } + + bool processed = false; + if (m_vst3Effect) + { + QString error; + processed = m_vst3Effect->process(m_vst3Input[0], m_vst3Input[1], + m_vst3Output[0], m_vst3Output[1], m_vst3BlockSize, error); + if (!processed && !m_vst3FailureReported) + { + qWarning() << "DenoiserWorker:" << error; + if (m_msgQueueToFeature) + { + m_msgQueueToFeature->push(MsgReportVst3Status::create( + QStringLiteral("VST3: %1. Audio is passing through.").arg(error))); + } + m_vst3FailureReported = true; + } + } + for (int j = 0; j < m_vst3BlockSize; ++j) + { + const float l = processed && std::isfinite(m_vst3Output[0][j]) ? m_vst3Output[0][j] : m_vst3Input[0][j]; + const float r = processed && std::isfinite(m_vst3Output[1][j]) ? m_vst3Output[1][j] : m_vst3Input[1][j]; + const int16_t leftSample = static_cast(std::max(-32768.0f, std::min(32767.0f, l * 32768.0f))); + const int16_t rightSample = static_cast(std::max(-32768.0f, std::min(32767.0f, r * 32768.0f))); + if (m_channelPowerAvg.asDouble() > 1e-4) + { + const int scale = SDR_RX_SAMP_SZ == 24 ? 256 : 1; + m_sampleBuffer.push_back(Sample(static_cast(leftSample) * scale, + static_cast(rightSample) * scale)); + } + m_audioBuffer[m_audioBufferFill].l = leftSample; + m_audioBuffer[m_audioBufferFill].r = rightSample; + if (++m_audioBufferFill >= m_audioBuffer.size()) + { + flushAudio(); + } + } + m_vst3Fill = 0; +} + void DenoiserWorker::processCI16DenoiserNone(const double& samplefpRe, const double& samplefpIm) { if (m_channelPowerAvg.asDouble() > 1e-4) { // -40 dB threshold @@ -456,15 +714,7 @@ void DenoiserWorker::processCI16DenoiserNone(const double& samplefpRe, const dou if (m_audioBufferFill >= m_audioBuffer.size()) { - std::size_t res = m_audioFifo.write((const quint8*)&m_audioBuffer[0], m_audioBufferFill); - - if (res != m_audioBufferFill) - { - qDebug("DenoiserWorker::processSample: %lu/%lu audio samples written", res, m_audioBufferFill); - m_audioFifo.clear(); - } - - m_audioBufferFill = 0; + flushAudio(); } } @@ -497,15 +747,7 @@ void DenoiserWorker::processCI16DenoiserRNNoise(const double& samplefpRe, const if (m_audioBufferFill >= m_audioBuffer.size()) { - std::size_t res = m_audioFifo.write((const quint8*)&m_audioBuffer[0], m_audioBufferFill); - - if (res != m_audioBufferFill) - { - qDebug("DenoiserWorker::processSample: %lu/%lu audio samples written", res, m_audioBufferFill); - m_audioFifo.clear(); - } - - m_audioBufferFill = 0; + flushAudio(); } } diff --git a/plugins/feature/denoiser/denoiserworker.h b/plugins/feature/denoiser/denoiserworker.h index 40a658799..a744df559 100644 --- a/plugins/feature/denoiser/denoiserworker.h +++ b/plugins/feature/denoiser/denoiserworker.h @@ -30,8 +30,10 @@ #include "audio/audiofifo.h" #include "denoisersettings.h" +#include "nvidiaaudioeffects.h" class WavFileRecord; +class Vst3Effect; struct DenoiseState; class DenoiserWorker : public QObject { @@ -77,6 +79,33 @@ public: { } }; + class MsgReportNvidiaStatus : public Message { + MESSAGE_CLASS_DECLARATION + public: + const QString& getError() const { return m_error; } + static MsgReportNvidiaStatus* create(const QString& error) { + return new MsgReportNvidiaStatus(error); + } + private: + QString m_error; + explicit MsgReportNvidiaStatus(const QString& error) : Message(), m_error(error) {} + }; + + class MsgReportVst3Status : public Message { + MESSAGE_CLASS_DECLARATION + public: + const QString& getError() const { return m_error; } + static MsgReportVst3Status* create(const QString& error) { + return new MsgReportVst3Status(error); + } + private: + QString m_error; + explicit MsgReportVst3Status(const QString& error) : + Message(), + m_error(error) + {} + }; + explicit DenoiserWorker(QObject *parent = nullptr); ~DenoiserWorker() override; void reset(); @@ -84,8 +113,10 @@ public: void stopWork(); MessageQueue *getInputMessageQueue() { return &m_inputMessageQueue; } void setMessageQueueToFeature(MessageQueue *messageQueue) { m_msgQueueToFeature = messageQueue; } + void setDemodProducer(QObject *producer) { m_demodProducer = producer; } void applySampleRate(int sampleRate); void applySettings(const DenoiserSettings& settings, const QStringList& settingsKeys, bool force = false); + void setVst3Effect(Vst3Effect *effect); double getMagSq() const { return m_magsq; } double getMagSqAvg() const { return (double) m_channelPowerAvg; } void getLevels(qreal& rmsLevel, qreal& peakLevel, int& numSamples) const @@ -105,14 +136,17 @@ signals: void levelChanged(qreal rmsLevel, qreal peakLevel, int numSamples); private: + static constexpr int m_nvidiaFrameSize = 480; + static constexpr int m_vst3BlockSize = 512; + DataFifo *m_dataFifo; + QObject *m_demodProducer; int m_sinkSampleRate; MessageQueue m_inputMessageQueue; //!< Queue for asynchronous inbound communication MessageQueue *m_msgQueueToFeature; //!< Queue to report channel change to main feature object DenoiserSettings m_settings; double m_magsq; SampleVector m_sampleBuffer; - int m_sampleBufferSize; MovingAverageUtil m_channelPowerAvg; WavFileRecord* m_wavFileRecord; int m_recordSilenceNbSamples; @@ -126,6 +160,22 @@ private: float m_rnnoiseOut[480]; int m_rnnoiseFill; + NvidiaAudioEffects m_nvidiaDenoiser; + alignas(64) float m_nvidiaIn[m_nvidiaFrameSize]; + alignas(64) float m_nvidiaOut[m_nvidiaFrameSize]; + int m_nvidiaFill; + bool m_nvidiaInitAttempted; + bool m_nvidiaReady; + bool m_nvidiaResetPending; + bool m_nvidiaStatusReported; + quint32 m_nvidiaGeneration; //!< Incremented on any change that invalidates a model load + + Vst3Effect *m_vst3Effect; + float m_vst3Input[2][m_vst3BlockSize]; + float m_vst3Output[2][m_vst3BlockSize]; + int m_vst3Fill; + bool m_vst3FailureReported; + quint32 m_levelCalcCount = 0; qreal m_rmsLevel; qreal m_peakLevelOut; @@ -145,6 +195,7 @@ private: bool handleMessage(const Message& cmd); void writeSampleToFile(const Sample& sample); + void flushAudio(); void processSample( DataFifo::DataType dataType, const QByteArray::const_iterator& begin, @@ -154,6 +205,11 @@ private: void processI16DenoiserRNNoise(const double& samplefp); void processCI16DenoiserNone(const double& samplefpRe, const double& samplefpIm); void processCI16DenoiserRNNoise(const double& samplefpRe, const double& samplefpIm); + void processNvidiaSample(const double& samplefp); + void processVst3Sample(double left, double right); + void reportNvidiaError(const QString& error); + void resetNvidia(); + void prepareNvidia(); void calculateLevel(const Real& sample); private slots: diff --git a/plugins/feature/denoiser/nvidiaaudioeffects.cpp b/plugins/feature/denoiser/nvidiaaudioeffects.cpp new file mode 100644 index 000000000..52962f6d2 --- /dev/null +++ b/plugins/feature/denoiser/nvidiaaudioeffects.cpp @@ -0,0 +1,302 @@ +/////////////////////////////////////////////////////////////////////////////////// +// Copyright (C) 2026 Jon Beniston, M7RCE // +// Some code by AI // +// // +// This program is free software; you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation as version 3 of the License, or // +// (at your option) any later version. // +// // +// This program is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License V3 for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with this program. If not, see . // +/////////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include +#include + +#ifdef Q_OS_WIN +#define WIN32_LEAN_AND_MEAN +#ifndef NOMINMAX +#define NOMINMAX +#endif +#include +#endif + +#include "nvidiaaudioeffects.h" + +#if defined(Q_OS_WIN) || defined(Q_OS_LINUX) +struct NvidiaAudioEffects::Impl +{ + using CreateEffect = int (*)(const char *, void **); + using DestroyEffect = int (*)(void *); + using SetString = int (*)(void *, const char *, const char *); + using SetU32 = int (*)(void *, const char *, unsigned int); + using SetFloat = int (*)(void *, const char *, float); + using GetU32 = int (*)(void *, const char *, unsigned int *); + using Load = int (*)(void *); + using Run = int (*)(void *, const float **, float **, unsigned int, unsigned int); + + QLibrary library; + void *effect = nullptr; + QByteArray modelPath; + Qt::HANDLE threadId = nullptr; + DestroyEffect destroyEffect = nullptr; + Run run = nullptr; +}; +#else +struct NvidiaAudioEffects::Impl {}; +#endif + +NvidiaAudioEffects::NvidiaAudioEffects() : + m_impl(nullptr) +{ +} + +NvidiaAudioEffects::~NvidiaAudioEffects() +{ + shutdown(); +} + +bool NvidiaAudioEffects::initialize(QString& error, float intensityRatio, bool enableVad) +{ + shutdown(); +#if defined(Q_OS_WIN) || defined(Q_OS_LINUX) + QString sdkDir = qEnvironmentVariable("NVAFX_SDK_DIR"); + +#ifdef Q_OS_WIN + if (sdkDir.isEmpty()) { + sdkDir = QDir(qEnvironmentVariable("ProgramFiles")).filePath("NVIDIA Corporation/NVIDIA Audio Effects SDK"); + } + + const QString libraryPath = QDir(sdkDir).filePath("NVAudioEffects.dll"); + const QString modelPath = QDir(sdkDir).filePath("models/denoiser_48k.trtpkg"); +#else + if (sdkDir.isEmpty()) { + sdkDir = qEnvironmentVariable("AFX_SDK_ROOT"); + } + if (sdkDir.isEmpty()) { + error = QStringLiteral("Set NVAFX_SDK_DIR to the Linux Audio Effects SDK root"); + return false; + } + + const QString libraryPath = QDir(sdkDir).filePath("nvafx/lib/libnv_audiofx.so"); + QString modelPath = qEnvironmentVariable("NVAFX_MODEL_PATH"); + if (modelPath.isEmpty()) + { + // Packages contain GPU-specific models. Pick one only if unambiguous. + QStringList models; + for (const QString& feature : {QStringLiteral("denoiser"), QStringLiteral("nvafxdenoiser")}) + { + const QDir modelDir(QDir(sdkDir).filePath(QStringLiteral("features/%1/models").arg(feature))); + for (const QString& gpuDir : modelDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot)) + { + const QString path = modelDir.filePath(gpuDir + QStringLiteral("/denoiser_48k.trtpkg")); + if (QFileInfo(path).isFile()) { + models.append(path); + } + } + } + if (models.size() == 1) { + modelPath = models.first(); + } else { + error = QStringLiteral("Set NVAFX_MODEL_PATH to this GPU's denoiser_48k.trtpkg (found %1 models)").arg(models.size()); + return false; + } + } +#endif + + if (!QFileInfo(libraryPath).isFile() || !QFileInfo(modelPath).isFile()) + { + error = QStringLiteral("NVIDIA Audio Effects library or 48 kHz model was not found: %1, %2").arg(libraryPath, modelPath); + return false; + } + + m_impl = new Impl; + m_impl->modelPath = QFile::encodeName(QDir::toNativeSeparators(modelPath)); + m_impl->library.setFileName(QFileInfo(libraryPath).absoluteFilePath()); +#ifdef Q_OS_WIN + // QLibrary's ordinary load cannot find this SDK's adjacent DLL dependencies. + // Load once with the SDK directory in the dependency search path, then let + // QLibrary acquire and own its own reference to the already loaded DLL. + HMODULE bootstrap = LoadLibraryExW(reinterpret_cast(QDir::toNativeSeparators(libraryPath).utf16()), + nullptr, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS); + if (!bootstrap) + { + error = QStringLiteral("Could not load NVIDIA Audio Effects DLL (Windows error %1)").arg(GetLastError()); + shutdown(); + return false; + } +#endif + const bool loaded = m_impl->library.load(); +#ifdef Q_OS_WIN + FreeLibrary(bootstrap); +#endif + if (!loaded) + { + error = QStringLiteral("Could not load NVIDIA Audio Effects library: %1").arg(m_impl->library.errorString()); + shutdown(); + return false; + } + + m_impl->threadId = QThread::currentThreadId(); + const auto resolve = [this](const char *name) { return m_impl->library.resolve(name); }; + const auto createEffect = reinterpret_cast(resolve("NvAFX_CreateEffect")); + m_impl->destroyEffect = reinterpret_cast(resolve("NvAFX_DestroyEffect")); + const auto setString = reinterpret_cast(resolve("NvAFX_SetString")); + const auto setU32 = reinterpret_cast(resolve("NvAFX_SetU32")); + const auto setFloat = reinterpret_cast(resolve("NvAFX_SetFloat")); + const auto getU32 = reinterpret_cast(resolve("NvAFX_GetU32")); + const auto load = reinterpret_cast(resolve("NvAFX_Load")); + m_impl->run = reinterpret_cast(resolve("NvAFX_Run")); + + if (!createEffect || !m_impl->destroyEffect || !setString || !setU32 || !setFloat || !getU32 || !load || !m_impl->run) + { + error = QStringLiteral("NVIDIA Audio Effects library is missing required functions"); + shutdown(); + return false; + } + + int status = createEffect("denoiser", &m_impl->effect); + + if (status == 0) { + status = setU32(m_impl->effect, "input_sample_rate", 48000); + } + if (status == 0) { + status = setFloat(m_impl->effect, "intensity_ratio", qBound(0.0f, intensityRatio, 1.0f)); + } + if (status == 0) { + status = setU32(m_impl->effect, "enable_vad", enableVad ? 1U : 0U); + } + +#ifdef Q_OS_LINUX + if (status == 0) { + status = setU32(m_impl->effect, "num_streams", 1); + } + if (status == 0) { + status = setU32(m_impl->effect, "num_samples_per_input_frame", 480); + } +#endif + + if (status == 0) { + status = setString(m_impl->effect, "model_path", m_impl->modelPath.constData()); + } + + if (status == 0) { + status = load(m_impl->effect); + } + + unsigned int frameSize = 0; + unsigned int outputFrameSize = 0; + unsigned int inputChannels = 0; + unsigned int outputChannels = 0; + unsigned int outputSampleRate = 0; + +#ifdef Q_OS_LINUX + const char *inputFrameSelector = "num_samples_per_input_frame"; + const char *outputFrameSelector = "num_samples_per_output_frame"; +#else + const char *inputFrameSelector = "num_input_samples_per_frame"; + const char *outputFrameSelector = "num_output_samples_per_frame"; +#endif + + if (status == 0) { + status = getU32(m_impl->effect, inputFrameSelector, &frameSize); + } + + if (status == 0) { + status = getU32(m_impl->effect, outputFrameSelector, &outputFrameSize); + } + + if (status == 0) { + status = getU32(m_impl->effect, "num_input_channels", &inputChannels); + } + + if (status == 0) { + status = getU32(m_impl->effect, "num_output_channels", &outputChannels); + } + + if (status == 0) { + status = getU32(m_impl->effect, "output_sample_rate", &outputSampleRate); + } + + if (status != 0 || frameSize != 480 || outputFrameSize != 480 || inputChannels != 1 || outputChannels != 1 || outputSampleRate != 48000) + { + error = QStringLiteral("NVIDIA denoiser initialization failed (status %1, frames %2/%3, channels %4/%5, output rate %6)") + .arg(status).arg(frameSize).arg(outputFrameSize).arg(inputChannels).arg(outputChannels).arg(outputSampleRate); + shutdown(); + return false; + } + + return true; +#else + error = QStringLiteral("NVIDIA Audio Effects is available only on Windows and Linux"); + return false; +#endif +} + +void NvidiaAudioEffects::shutdown() +{ + if (!m_impl) { + return; + } +#if defined(Q_OS_WIN) || defined(Q_OS_LINUX) + if (m_impl->effect && m_impl->destroyEffect) { + m_impl->destroyEffect(m_impl->effect); + } + if (m_impl->library.isLoaded()) { + m_impl->library.unload(); + } +#endif + delete m_impl; + m_impl = nullptr; +} + +bool NvidiaAudioEffects::process(const float *input, float *output, QString& error) +{ +#if defined(Q_OS_WIN) || defined(Q_OS_LINUX) + if (!m_impl || !m_impl->effect) { + error = QStringLiteral("NVIDIA denoiser is not initialized"); + return false; + } + + if (QThread::currentThreadId() != m_impl->threadId) { + error = QStringLiteral("NVIDIA denoiser was called from a different thread than it was initialized on"); + return false; + } + + // Keep the caller's input intact for failure passthrough. + std::memcpy(output, input, 480 * sizeof(float)); +#ifdef Q_OS_WIN + // The installed Windows runtime processes the buffer in place, as in OBS. + const float *inputs[] = {output}; +#else + const float *inputs[] = {input}; +#endif + float *outputs[] = {output}; + const int status = m_impl->run(m_impl->effect, inputs, outputs, 480, 1); + + if (status != 0) + { + error = QStringLiteral("NVIDIA denoiser processing failed (status %1)").arg(status); + shutdown(); + return false; + } + + return true; +#else + Q_UNUSED(input) + Q_UNUSED(output) + error = QStringLiteral("NVIDIA Audio Effects is available only on Windows and Linux"); + return false; +#endif +} diff --git a/plugins/feature/denoiser/nvidiaaudioeffects.h b/plugins/feature/denoiser/nvidiaaudioeffects.h new file mode 100644 index 000000000..36bfb94dc --- /dev/null +++ b/plugins/feature/denoiser/nvidiaaudioeffects.h @@ -0,0 +1,41 @@ +/////////////////////////////////////////////////////////////////////////////////// +// Copyright (C) 2026 Jon Beniston, M7RCE // +// Some code by AI // +// // +// This program is free software; you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation as version 3 of the License, or // +// (at your option) any later version. // +// // +// This program is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License V3 for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with this program. If not, see . // +/////////////////////////////////////////////////////////////////////////////////// + +#ifndef INCLUDE_FEATURE_DENOISER_NVIDIAAUDIOEFFECTS_H_ +#define INCLUDE_FEATURE_DENOISER_NVIDIAAUDIOEFFECTS_H_ + +#include + +// Loads the user-installed NVIDIA Audio Effects redistributable at runtime. +// No NVIDIA headers or binaries are required. +class NvidiaAudioEffects +{ +public: + NvidiaAudioEffects(); + ~NvidiaAudioEffects(); + + bool initialize(QString& error, float intensityRatio, bool enableVad); + void shutdown(); + bool process(const float *input, float *output, QString& error); + +private: + struct Impl; + Impl *m_impl; +}; + +#endif diff --git a/plugins/feature/denoiser/readme.md b/plugins/feature/denoiser/readme.md index 11dc9cc79..77a2d0a4f 100644 --- a/plugins/feature/denoiser/readme.md +++ b/plugins/feature/denoiser/readme.md @@ -1,19 +1,27 @@ -

Demoiser

+

Denoiser

Introduction

-This audio denoiser plugin can be used to reduce or remove noise from audio. For now it only implements the RNNoise noise reduction (more details next) +This feature can process demodulated audio with RNNoise, NVIDIA Noise Removal, +or an installed VST3 audio effect, such as a [denoiser](https://github.com/werman/noise-suppression-for-voice) +or [EQ](https://www.manda-audio.com/products.php). -It connects to the "demod" stream of Rx channels similarly to the Demod analyzer plugin. Hence it covers: +It connects to the "demod" stream of RX channels or features similarly to the Demod Analyzer plugin. +It also outputs its processed stereo audio on a "demod" stream, so another Denoiser or Demod Analyzer can use it as an input. + +Supported sources include: - AM demodulator - Broadcast FM demodulator + - DAB demodulator + - DSD demodulator - NFM demodulator - SSB demodulator - WFM demodulator - WDSP plugin (multimode) + - Another Denoiser feature -The following noise reduction schemes are covered. It can be selected via the (6) combo box: +The processing mode is selected with the (6) combo box:

RNNoise

@@ -23,6 +31,49 @@ The noise reduction is based on a mix of DSP functions and a recursive neural ne You will find all the details about RNnoise here: https://jmvalin.ca/demo/rnnoise/ +

NVIDIA Noise Removal

+ +On Windows, this option uses the NVIDIA Audio Effects SDK redistributable installed separately from NVIDIA Broadcast. +Install the redistributable for your RTX GPU from [NVIDIA's Broadcast SDK resources](https://www.nvidia.com/en-us/geforce/broadcasting/broadcast-sdk/resources/). +The feature looks in `NVAFX_SDK_DIR` if set, otherwise in `%ProgramFiles%\NVIDIA Corporation\NVIDIA Audio Effects SDK`. +SDRangel does not include NVIDIA binaries or models. + +On Linux, install the [NVIDIA Audio Effects SDK core and Denoiser feature package](https://docs.nvidia.com/maxine/afx/latest/LinuxAFXSDK/InstallTheAFXSDK.html). +Set `NVAFX_SDK_DIR` to the extracted SDK root (or use `AFX_SDK_ROOT`). Put the SDK's `nvafx/lib`, +Denoiser feature `lib`, and `external/cuda/lib` directories on `LD_LIBRARY_PATH` before starting SDRangel. +The feature selects `features/denoiser/models/sm_*/denoiser_48k.trtpkg` automatically when exactly one GPU-specific model is installed; otherwise set `NVAFX_MODEL_PATH` to the model for your GPU. +NVIDIA officially supports the Linux SDK for its listed server GPUs; consumer GeForce cards are outside that support list. + +NVIDIA Noise Removal is not available on macOS. + +Set the demodulated audio stream to 48 kS/s. The SDK's 48 kHz speech denoiser receives mono audio; stereo input is mixed to mono. +If the SDK, model, or supported GPU is unavailable, the feature passes audio through and reports the reason in the feature's error status and SDRangel log. +NVIDIA's model is trained for speech, so tones, music, and weak radio signals may be suppressed. + +When NVIDIA Noise Removal is selected, **Strength** controls the intensity ratio from 0% (passthrough) to 100% (strongest suppression). +If weak speech is being removed, try 30–50% and adjust by ear. **VAD** enables voice activity detection, which can mute frames classified as non-speech; leave it off when receiving weak or distorted voices. +Changes to these controls reload the NVIDIA model briefly. Neither setting can guarantee preservation of speech that the model classifies as noise. + +

VST3 Audio Effects

+ +Select **VST3 Effect** to scan automatically for effects in the standard VST3 folders on Windows, Linux, or macOS. +Denoiser also scans when the feature starts; use **Scan** to refresh the list after installing a plugin. +On macOS the folders include the user, system, and network Audio/Plug-ins/VST3 folders, plus the app's Contents/VST3 folder. +The scanner runs in a separate process so a plugin that fails during discovery cannot crash SDRangel. +The **...** button lets you select a module outside those folders. +Select an effect from the list and start the feature. +**Params** opens the effect's own editor when available, or a slider dialog for its editable parameters. +Changes to exposed parameters are saved with the Denoiser settings. +When **Params** is closed, the effect's complete state (including editor settings and presets that are not exposed as parameters) is also saved, and the running effect is reloaded with it. +The effect runs at the selected channel's sample rate when reported, and otherwise assumes 48 kS/s. + +The host accepts effects with one main mono or stereo audio input and output. +Effects that require other layouts or host services may report an error; in that case audio passes through. +**Params** tries the native editor on Windows, macOS, and Linux when Qt uses X11. If the editor cannot attach, it uses the slider dialog. +Editor changes that a plugin does not expose as parameters are only heard once **Params** is closed. + +

Notes

+ Please note the following points: - Audio sample rate must be 48 kS/s (check 4) @@ -40,17 +91,17 @@ Please note the following points: This button starts or stops the plugin -

2: Channel selection

+

2: Source selection

-Use this combo to select which channel to use for display. Channel is selected at start time and upon change. You may use button (3) to force association with the channel if necessary. +Use this combo to select an Rx channel or Feature as the audio source. The selection takes effect at start time and upon change. You may use button (3) to force association with the source if necessary. -

3: (Re)apply channel selection

+

3: (Re)apply source selection

-Applies or re-applies channel association (2) so that the channel gets effectively (re)connected to the denoiser. Normally it should not be necessary to use it. +Applies or re-applies source association (2) so that the source gets effectively (re)connected to the denoiser. Normally it should not be necessary to use it.

4: Input sample rate

-This is the input audio stream sample rate and for RNNoise it should always be 48 kS/s +This is the input audio stream sample rate. RNNoise and NVIDIA Noise Removal require 48 kS/s.

5: Input power

@@ -62,10 +113,12 @@ Selects the noise reduction scheme - **None**: No noise reduction (passthrough) - **RNnoise**: RNNoise (see introduction) + - **NVIDIA Noise Removal**: NVIDIA Audio Effects SDK speech denoiser + - **VST3 Effect**: An installed VST3 audio effect

7: Noise reduction enable

-Enable or disable noise reduction. When disabled it just passes audio through +Enable or disable noise reduction or VST3 effect. When disabled it just passes audio through.

8: Audio mute and device selection

diff --git a/plugins/feature/denoiser/vst3/LICENSE.txt b/plugins/feature/denoiser/vst3/LICENSE.txt new file mode 100644 index 000000000..075933e45 --- /dev/null +++ b/plugins/feature/denoiser/vst3/LICENSE.txt @@ -0,0 +1,27 @@ +//----------------------------------------------------------------------------- +// LICENSE +// (c) 2025, 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. +//----------------------------------------------------------------------------- diff --git a/plugins/feature/denoiser/vst3/vst3_c_api.h b/plugins/feature/denoiser/vst3/vst3_c_api.h new file mode 100644 index 000000000..19e15c4d7 --- /dev/null +++ b/plugins/feature/denoiser/vst3/vst3_c_api.h @@ -0,0 +1,3777 @@ +/*----------------------------------------------------------------------------- + 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. +-----------------------------------------------------------------------------*/ + +/* This file is the autogenerated C API of the VST3 SDK */ + +#pragma once + +#include + +#if _WIN32 +#define SMTG_STDMETHODCALLTYPE __stdcall +#define SMTG_COM_COMPATIBLE 1 +#else +#define SMTG_STDMETHODCALLTYPE +#define SMTG_COM_COMPATIBLE 0 +#endif + +#ifndef __cplusplus +typedef int16_t char16_t; +#endif + +#if SMTG_COM_COMPATIBLE +#define SMTG_INLINE_UID(l1, l2, l3, l4) \ +{ \ + (Steinberg_int8)(((Steinberg_uint32)(l1) & 0x000000FF) ), (Steinberg_int8)(((Steinberg_uint32)(l1) & 0x0000FF00) >> 8), \ + (Steinberg_int8)(((Steinberg_uint32)(l1) & 0x00FF0000) >> 16), (Steinberg_int8)(((Steinberg_uint32)(l1) & 0xFF000000) >> 24), \ + (Steinberg_int8)(((Steinberg_uint32)(l2) & 0x00FF0000) >> 16), (Steinberg_int8)(((Steinberg_uint32)(l2) & 0xFF000000) >> 24), \ + (Steinberg_int8)(((Steinberg_uint32)(l2) & 0x000000FF) ), (Steinberg_int8)(((Steinberg_uint32)(l2) & 0x0000FF00) >> 8), \ + (Steinberg_int8)(((Steinberg_uint32)(l3) & 0xFF000000) >> 24), (Steinberg_int8)(((Steinberg_uint32)(l3) & 0x00FF0000) >> 16), \ + (Steinberg_int8)(((Steinberg_uint32)(l3) & 0x0000FF00) >> 8), (Steinberg_int8)(((Steinberg_uint32)(l3) & 0x000000FF) ), \ + (Steinberg_int8)(((Steinberg_uint32)(l4) & 0xFF000000) >> 24), (Steinberg_int8)(((Steinberg_uint32)(l4) & 0x00FF0000) >> 16), \ + (Steinberg_int8)(((Steinberg_uint32)(l4) & 0x0000FF00) >> 8), (Steinberg_int8)(((Steinberg_uint32)(l4) & 0x000000FF) ) \ +} +#else +#define SMTG_INLINE_UID(l1, l2, l3, l4) \ +{ \ + (Steinberg_int8)(((Steinberg_uint32)(l1) & 0xFF000000) >> 24), (Steinberg_int8)(((Steinberg_uint32)(l1) & 0x00FF0000) >> 16), \ + (Steinberg_int8)(((Steinberg_uint32)(l1) & 0x0000FF00) >> 8), (Steinberg_int8)(((Steinberg_uint32)(l1) & 0x000000FF) ), \ + (Steinberg_int8)(((Steinberg_uint32)(l2) & 0xFF000000) >> 24), (Steinberg_int8)(((Steinberg_uint32)(l2) & 0x00FF0000) >> 16), \ + (Steinberg_int8)(((Steinberg_uint32)(l2) & 0x0000FF00) >> 8), (Steinberg_int8)(((Steinberg_uint32)(l2) & 0x000000FF) ), \ + (Steinberg_int8)(((Steinberg_uint32)(l3) & 0xFF000000) >> 24), (Steinberg_int8)(((Steinberg_uint32)(l3) & 0x00FF0000) >> 16), \ + (Steinberg_int8)(((Steinberg_uint32)(l3) & 0x0000FF00) >> 8), (Steinberg_int8)(((Steinberg_uint32)(l3) & 0x000000FF) ), \ + (Steinberg_int8)(((Steinberg_uint32)(l4) & 0xFF000000) >> 24), (Steinberg_int8)(((Steinberg_uint32)(l4) & 0x00FF0000) >> 16), \ + (Steinberg_int8)(((Steinberg_uint32)(l4) & 0x0000FF00) >> 8), (Steinberg_int8)(((Steinberg_uint32)(l4) & 0x000000FF) ) \ +} +#endif + +/*---------------------------------------------------------------------------------------------------------------------- +----- Typedefs --------------------------------------------------------------------------------------------------------- +----------------------------------------------------------------------------------------------------------------------*/ + +typedef char Steinberg_int8; +typedef uint8_t Steinberg_uint8; +typedef unsigned char Steinberg_uchar; +typedef int16_t Steinberg_int16; +typedef uint16_t Steinberg_uint16; +typedef int32_t Steinberg_int32; +typedef uint32_t Steinberg_uint32; +typedef int64_t Steinberg_int64; +typedef uint64_t Steinberg_uint64; +typedef Steinberg_int64 Steinberg_TSize; +typedef Steinberg_int32 Steinberg_tresult; +typedef Steinberg_uint64 Steinberg_TPtrInt; +typedef Steinberg_uint8 Steinberg_TBool; +typedef char Steinberg_char8; +typedef char16_t Steinberg_char16; +typedef Steinberg_char16 Steinberg_tchar; +typedef const Steinberg_char8* Steinberg_CStringA; +typedef const Steinberg_char16* Steinberg_CStringW; +typedef const Steinberg_tchar* Steinberg_CString; +typedef const Steinberg_char8* Steinberg_FIDString; +typedef Steinberg_int32 Steinberg_UCoord; +typedef Steinberg_int64 Steinberg_LARGE_INT; +typedef char Steinberg_TUID[16]; +typedef Steinberg_uint64 Steinberg_Linux_TimerInterval; +typedef int Steinberg_Linux_FileDescriptor; +typedef Steinberg_char16 Steinberg_Vst_TChar; +typedef Steinberg_Vst_TChar Steinberg_Vst_String128[128]; +typedef const Steinberg_char8* Steinberg_Vst_CString; +typedef Steinberg_int32 Steinberg_Vst_MediaType; +typedef Steinberg_int32 Steinberg_Vst_BusDirection; +typedef Steinberg_int32 Steinberg_Vst_BusType; +typedef Steinberg_int32 Steinberg_Vst_IoMode; +typedef Steinberg_int32 Steinberg_Vst_UnitID; +typedef double Steinberg_Vst_ParamValue; +typedef Steinberg_uint32 Steinberg_Vst_ParamID; +typedef Steinberg_int32 Steinberg_Vst_ProgramListID; +typedef Steinberg_int16 Steinberg_Vst_CtrlNumber; +typedef double Steinberg_Vst_TQuarterNotes; +typedef Steinberg_int64 Steinberg_Vst_TSamples; +typedef Steinberg_uint32 Steinberg_Vst_ColorSpec; +typedef float Steinberg_Vst_Sample32; +typedef double Steinberg_Vst_Sample64; +typedef double Steinberg_Vst_SampleRate; +typedef Steinberg_uint64 Steinberg_Vst_SpeakerArrangement; +typedef Steinberg_uint64 Steinberg_Vst_Speaker; +typedef Steinberg_uint32 Steinberg_Vst_NoteExpressionTypeID; +typedef double Steinberg_Vst_NoteExpressionValue; +typedef Steinberg_uint32 Steinberg_Vst_KeyswitchTypeID; +typedef Steinberg_uint32 Steinberg_Vst_PhysicalUITypeID; +typedef Steinberg_int32 Steinberg_Vst_KnobMode; +typedef Steinberg_uint32 Steinberg_Vst_ChannelContext_ColorSpec; +typedef Steinberg_uint8 Steinberg_Vst_ChannelContext_ColorComponent; +typedef Steinberg_uint32 Steinberg_Vst_PrefetchableSupport; +typedef Steinberg_uint32 Steinberg_Vst_DataExchangeQueueID; +typedef Steinberg_uint32 Steinberg_Vst_DataExchangeBlockID; +typedef Steinberg_uint32 Steinberg_Vst_DataExchangeUserContextID; +typedef Steinberg_uint8 Steinberg_Vst_MidiGroup; +typedef Steinberg_uint8 Steinberg_Vst_MidiChannel; +typedef Steinberg_int32 Steinberg_Vst_BusIndex; + + +/*---------------------------------------------------------------------------------------------------------------------- +----- Interface forward declarations ----------------------------------------------------------------------------------- +----------------------------------------------------------------------------------------------------------------------*/ + +struct Steinberg_FUnknown; +struct Steinberg_IPlugViewContentScaleSupport; +struct Steinberg_IPlugView; +struct Steinberg_IPlugFrame; +struct Steinberg_Linux_IEventHandler; +struct Steinberg_Linux_ITimerHandler; +struct Steinberg_Linux_IRunLoop; +struct Steinberg_IBStream; +struct Steinberg_ISizeableStream; +struct Steinberg_Vst_INoteExpressionController; +struct Steinberg_Vst_IKeyswitchController; +struct Steinberg_Vst_INoteExpressionPhysicalUIMapping; +struct Steinberg_IPluginBase; +struct Steinberg_IPluginFactory; +struct Steinberg_IPluginFactory2; +struct Steinberg_IPluginFactory3; +struct Steinberg_Vst_IComponent; +struct Steinberg_Vst_IAttributeList; +struct Steinberg_Vst_IStreamAttributes; +struct Steinberg_Vst_IRemapParamID; +struct Steinberg_Vst_IComponentHandler; +struct Steinberg_Vst_IComponentHandler2; +struct Steinberg_Vst_IComponentHandlerBusActivation; +struct Steinberg_Vst_IProgress; +struct Steinberg_Vst_IEditController; +struct Steinberg_Vst_IEditController2; +struct Steinberg_Vst_IMidiMapping; +struct Steinberg_Vst_IEditControllerHostEditing; +struct Steinberg_Vst_IComponentHandlerSystemTime; +struct Steinberg_Vst_IEventList; +struct Steinberg_Vst_IMessage; +struct Steinberg_Vst_IConnectionPoint; +struct Steinberg_Vst_IXmlRepresentationController; +struct Steinberg_Vst_IComponentHandler3; +struct Steinberg_Vst_IContextMenuTarget; +struct Steinberg_Vst_IContextMenu; +struct Steinberg_Vst_IMidiLearn; +struct Steinberg_Vst_ChannelContext_IInfoListener; +struct Steinberg_Vst_IPrefetchableSupport; +struct Steinberg_Vst_IDataExchangeHandler; +struct Steinberg_Vst_IDataExchangeReceiver; +struct Steinberg_Vst_IAutomationState; +struct Steinberg_Vst_IInterAppAudioHost; +struct Steinberg_Vst_IInterAppAudioConnectionNotification; +struct Steinberg_Vst_IInterAppAudioPresetManager; +struct Steinberg_Vst_IAudioProcessor; +struct Steinberg_Vst_IAudioPresentationLatency; +struct Steinberg_Vst_IProcessContextRequirements; +struct Steinberg_Vst_IMidiMapping2; +struct Steinberg_Vst_IMidiLearn2; +struct Steinberg_Vst_IHostApplication; +struct Steinberg_Vst_IVst3ToVst2Wrapper; +struct Steinberg_Vst_IVst3ToAUWrapper; +struct Steinberg_Vst_IVst3ToAAXWrapper; +struct Steinberg_Vst_IVst3WrapperMPESupport; +struct Steinberg_Vst_IParameterFinder; +struct Steinberg_Vst_NoteOnOrchestralArticulation_IInfo; +struct Steinberg_Vst_ITransportControl; +struct Steinberg_Vst_IUnitHandler; +struct Steinberg_Vst_IUnitHandler2; +struct Steinberg_Vst_IUnitInfo; +struct Steinberg_Vst_IProgramListData; +struct Steinberg_Vst_IUnitData; +struct Steinberg_Vst_IPlugInterfaceSupport; +struct Steinberg_Vst_IParameterFunctionName; +struct Steinberg_Vst_IParamValueQueue; +struct Steinberg_Vst_IParameterChanges; + + +/*---------------------------------------------------------------------------------------------------------------------- +----- Struct forward declarations -------------------------------------------------------------------------------------- +----------------------------------------------------------------------------------------------------------------------*/ + +struct Steinberg_ViewRect; +struct Steinberg_Vst_NoteExpressionValueDescription; +struct Steinberg_Vst_NoteExpressionValueEvent; +struct Steinberg_Vst_NoteExpressionIntValueEvent; +struct Steinberg_Vst_NoteExpressionTextEvent; +struct Steinberg_Vst_NoteExpressionTypeInfo; +struct Steinberg_Vst_KeyswitchInfo; +struct Steinberg_Vst_PhysicalUIMap; +struct Steinberg_Vst_PhysicalUIMapList; +struct Steinberg_PFactoryInfo; +struct Steinberg_PClassInfo; +struct Steinberg_PClassInfo2; +struct Steinberg_PClassInfoW; +struct Steinberg_Vst_BusInfo; +struct Steinberg_Vst_RoutingInfo; +struct Steinberg_Vst_ParameterInfo; +struct Steinberg_Vst_FrameRate; +struct Steinberg_Vst_Chord; +struct Steinberg_Vst_ProcessContext; +struct Steinberg_Vst_NoteOnEvent; +struct Steinberg_Vst_NoteOffEvent; +struct Steinberg_Vst_DataEvent; +struct Steinberg_Vst_PolyPressureEvent; +struct Steinberg_Vst_ChordEvent; +struct Steinberg_Vst_ScaleEvent; +struct Steinberg_Vst_LegacyMIDICCOutEvent; +struct Steinberg_Vst_Event; +struct Steinberg_Vst_RepresentationInfo; +struct Steinberg_Vst_IContextMenuItem; +struct Steinberg_Vst_DataExchangeBlock; +struct Steinberg_Vst_ProcessSetup; +struct Steinberg_Vst_AudioBusBuffers; +struct Steinberg_Vst_ProcessData; +struct Steinberg_Vst_Midi2Controller; +struct Steinberg_Vst_Midi2ControllerParamIDAssignment; +struct Steinberg_Vst_Midi2ControllerParamIDAssignmentList; +struct Steinberg_Vst_Midi1ControllerParamIDAssignment; +struct Steinberg_Vst_Midi1ControllerParamIDAssignmentList; +struct Steinberg_Vst_NoteOnOrchestralArticulation_Variations; +struct Steinberg_Vst_NoteOnOrchestralArticulation_ClassificationVariations; +struct Steinberg_Vst_TransportPosition; +struct Steinberg_Vst_UnitInfo; +struct Steinberg_Vst_ProgramListInfo; + + +/*---------------------------------------------------------------------------------------------------------------------- +----- Result value definitions ----------------------------------------------------------------------------------------- +----------------------------------------------------------------------------------------------------------------------*/ + +#if SMTG_COM_COMPATIBLE +static const Steinberg_tresult Steinberg_kNoInterface = 0x80004002L; +static const Steinberg_tresult Steinberg_kResultOk = 0x00000000L; +static const Steinberg_tresult Steinberg_kResultTrue = 0x00000000L; +static const Steinberg_tresult Steinberg_kResultFalse = 0x00000001L; +static const Steinberg_tresult Steinberg_kInvalidArgument = 0x80070057L; +static const Steinberg_tresult Steinberg_kNotImplemented = 0x80004001L; +static const Steinberg_tresult Steinberg_kInternalError = 0x80004005L; +static const Steinberg_tresult Steinberg_kNotInitialized = 0x8000FFFFL; +static const Steinberg_tresult Steinberg_kOutOfMemory = 0x8007000EL; + +#else +static const Steinberg_tresult Steinberg_kNoInterface = -1; +static const Steinberg_tresult Steinberg_kResultOk = 0; +static const Steinberg_tresult Steinberg_kResultTrue = 0; +static const Steinberg_tresult Steinberg_kResultFalse = 1; +static const Steinberg_tresult Steinberg_kInvalidArgument = 2; +static const Steinberg_tresult Steinberg_kNotImplemented = 3; +static const Steinberg_tresult Steinberg_kInternalError = 4; +static const Steinberg_tresult Steinberg_kNotInitialized = 5; +static const Steinberg_tresult Steinberg_kOutOfMemory = 6; +#endif + + +/*---------------------------------------------------------------------------------------------------------------------- +----- Interface typedefs ----------------------------------------------------------------------------------------------- +----------------------------------------------------------------------------------------------------------------------*/ + +typedef float Steinberg_IPlugViewContentScaleSupport_ScaleFactor; +typedef const char* Steinberg_Vst_IAttributeList_AttrID; +typedef Steinberg_uint64 Steinberg_Vst_IProgress_ID; +typedef struct Steinberg_Vst_IContextMenuItem Steinberg_Vst_IContextMenu_Item; + + +/*---------------------------------------------------------------------------------------------------------------------- +----- Enums ------------------------------------------------------------------------------------------------------------ +----------------------------------------------------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/ibstream.h", line 32 */ + +typedef enum +{ + Steinberg_IBStream_IStreamSeekMode_kIBSeekSet = 0, + Steinberg_IBStream_IStreamSeekMode_kIBSeekCur, + Steinberg_IBStream_IStreamSeekMode_kIBSeekEnd +} Steinberg_IBStream_IStreamSeekMode; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteexpression.h", line 45 */ + +typedef enum +{ + Steinberg_Vst_NoteExpressionTypeIDs_kVolumeTypeID = 0, + Steinberg_Vst_NoteExpressionTypeIDs_kPanTypeID, + Steinberg_Vst_NoteExpressionTypeIDs_kTuningTypeID, + Steinberg_Vst_NoteExpressionTypeIDs_kVibratoTypeID, + Steinberg_Vst_NoteExpressionTypeIDs_kExpressionTypeID, + Steinberg_Vst_NoteExpressionTypeIDs_kBrightnessTypeID, + Steinberg_Vst_NoteExpressionTypeIDs_kTextTypeID, + Steinberg_Vst_NoteExpressionTypeIDs_kPhonemeTypeID, + Steinberg_Vst_NoteExpressionTypeIDs_kCustomStart = 100000, + Steinberg_Vst_NoteExpressionTypeIDs_kCustomEnd = 200000, + Steinberg_Vst_NoteExpressionTypeIDs_kMidi2AssignablePerNoteControllerStart = 201000, + Steinberg_Vst_NoteExpressionTypeIDs_kMidi2AssignablePerNoteControllerEnd = 201255, + Steinberg_Vst_NoteExpressionTypeIDs_kMidi2RegisteredPerNoteControllerStart = 202000, + Steinberg_Vst_NoteExpressionTypeIDs_kMidi2RegisteredPerNoteControllerPlayingPosition = Steinberg_Vst_NoteExpressionTypeIDs_kMidi2RegisteredPerNoteControllerStart + 0x0C, + Steinberg_Vst_NoteExpressionTypeIDs_kMidi2RegisteredPerNoteControllerEnd = 202255, + Steinberg_Vst_NoteExpressionTypeIDs_kMidi2NoteOnAttributeStart = 203000, + Steinberg_Vst_NoteExpressionTypeIDs_kMidi2NoteOnOrchestralArticulationStart = Steinberg_Vst_NoteExpressionTypeIDs_kMidi2NoteOnAttributeStart + 0x10, + Steinberg_Vst_NoteExpressionTypeIDs_kMidi2NoteOnOrchestralArticulationEnd = Steinberg_Vst_NoteExpressionTypeIDs_kMidi2NoteOnAttributeStart + 0x1F, + Steinberg_Vst_NoteExpressionTypeIDs_kMidi2NoteOnAttributeEnd = 203255, + Steinberg_Vst_NoteExpressionTypeIDs_kMidi2NoteOffAttributeStart = 204000, + Steinberg_Vst_NoteExpressionTypeIDs_kMidi2NoteOffOrchestralArticulation = Steinberg_Vst_NoteExpressionTypeIDs_kMidi2NoteOffAttributeStart + 0x10, + Steinberg_Vst_NoteExpressionTypeIDs_kMidi2NoteOffAttributeEnd = 204255, + Steinberg_Vst_NoteExpressionTypeIDs_kInvalidTypeID = 0xFFFFFFFF +} Steinberg_Vst_NoteExpressionTypeIDs; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteexpression.h", line 182 */ + +typedef enum +{ + Steinberg_Vst_NoteExpressionTypeInfo_NoteExpressionTypeFlags_kIsBipolar = 1 << 0, + Steinberg_Vst_NoteExpressionTypeInfo_NoteExpressionTypeFlags_kIsOneShot = 1 << 1, + Steinberg_Vst_NoteExpressionTypeInfo_NoteExpressionTypeFlags_kIsAbsolute = 1 << 2, + Steinberg_Vst_NoteExpressionTypeInfo_NoteExpressionTypeFlags_kAssociatedParameterIDValid = 1 << 3 +} Steinberg_Vst_NoteExpressionTypeInfo_NoteExpressionTypeFlags; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteexpression.h", line 249 */ + +typedef enum +{ + Steinberg_Vst_KeyswitchTypeIDs_kNoteOnKeyswitchTypeID = 0, + Steinberg_Vst_KeyswitchTypeIDs_kOnTheFlyKeyswitchTypeID, + Steinberg_Vst_KeyswitchTypeIDs_kOnReleaseKeyswitchTypeID, + Steinberg_Vst_KeyswitchTypeIDs_kKeyRangeTypeID +} Steinberg_Vst_KeyswitchTypeIDs; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstphysicalui.h", line 41 */ + +typedef enum +{ + Steinberg_Vst_PhysicalUITypeIDs_kPUIXMovement = 0, + Steinberg_Vst_PhysicalUITypeIDs_kPUIYMovement, + Steinberg_Vst_PhysicalUITypeIDs_kPUIPressure, + Steinberg_Vst_PhysicalUITypeIDs_kPUITypeCount, + Steinberg_Vst_PhysicalUITypeIDs_kInvalidPUITypeID = 0xFFFFFFFF +} Steinberg_Vst_PhysicalUITypeIDs; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/ipluginbase.h", line 65 */ + +typedef enum +{ + Steinberg_PFactoryInfo_FactoryFlags_kNoFlags = 0, + Steinberg_PFactoryInfo_FactoryFlags_kClassesDiscardable = 1 << 0, + Steinberg_PFactoryInfo_FactoryFlags_kLicenseCheck = 1 << 1, + Steinberg_PFactoryInfo_FactoryFlags_kComponentNonDiscardable = 1 << 3, + Steinberg_PFactoryInfo_FactoryFlags_kUnicode = 1 << 4 +} Steinberg_PFactoryInfo_FactoryFlags; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/ipluginbase.h", line 127 */ + +typedef enum +{ + Steinberg_PClassInfo_ClassCardinality_kManyInstances = 0x7FFFFFFF +} Steinberg_PClassInfo_ClassCardinality; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstcomponent.h", line 65 */ + +typedef enum +{ + Steinberg_Vst_MediaTypes_kAudio = 0, + Steinberg_Vst_MediaTypes_kEvent, + Steinberg_Vst_MediaTypes_kNumMediaTypes +} Steinberg_Vst_MediaTypes; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstcomponent.h", line 74 */ + +typedef enum +{ + Steinberg_Vst_BusDirections_kInput = 0, + Steinberg_Vst_BusDirections_kOutput +} Steinberg_Vst_BusDirections; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstcomponent.h", line 82 */ + +typedef enum +{ + Steinberg_Vst_BusTypes_kMain = 0, + Steinberg_Vst_BusTypes_kAux +} Steinberg_Vst_BusTypes; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstcomponent.h", line 104 */ + +typedef enum +{ + Steinberg_Vst_BusInfo_BusFlags_kDefaultActive = 1 << 0, + Steinberg_Vst_BusInfo_BusFlags_kIsControlVoltage = 1 << 1 +} Steinberg_Vst_BusInfo_BusFlags; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstcomponent.h", line 122 */ + +typedef enum +{ + Steinberg_Vst_IoModes_kSimple = 0, + Steinberg_Vst_IoModes_kAdvanced, + Steinberg_Vst_IoModes_kOfflineProcessing +} Steinberg_Vst_IoModes; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 67 */ + +typedef enum +{ + Steinberg_Vst_ParameterInfo_ParameterFlags_kNoFlags = 0, + Steinberg_Vst_ParameterInfo_ParameterFlags_kCanAutomate = 1 << 0, + Steinberg_Vst_ParameterInfo_ParameterFlags_kIsReadOnly = 1 << 1, + Steinberg_Vst_ParameterInfo_ParameterFlags_kIsWrapAround = 1 << 2, + Steinberg_Vst_ParameterInfo_ParameterFlags_kIsList = 1 << 3, + Steinberg_Vst_ParameterInfo_ParameterFlags_kIsHidden = 1 << 4, + Steinberg_Vst_ParameterInfo_ParameterFlags_kIsProgramChange = 1 << 15, + Steinberg_Vst_ParameterInfo_ParameterFlags_kIsBypass = 1 << 16 +} Steinberg_Vst_ParameterInfo_ParameterFlags; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 116 */ + +typedef enum +{ + Steinberg_Vst_RestartFlags_kReloadComponent = 1 << 0, + Steinberg_Vst_RestartFlags_kIoChanged = 1 << 1, + Steinberg_Vst_RestartFlags_kParamValuesChanged = 1 << 2, + Steinberg_Vst_RestartFlags_kLatencyChanged = 1 << 3, + Steinberg_Vst_RestartFlags_kParamTitlesChanged = 1 << 4, + Steinberg_Vst_RestartFlags_kMidiCCAssignmentChanged = 1 << 5, + Steinberg_Vst_RestartFlags_kNoteExpressionChanged = 1 << 6, + Steinberg_Vst_RestartFlags_kIoTitlesChanged = 1 << 7, + Steinberg_Vst_RestartFlags_kPrefetchableSupportChanged = 1 << 8, + Steinberg_Vst_RestartFlags_kRoutingInfoChanged = 1 << 9, + Steinberg_Vst_RestartFlags_kKeyswitchChanged = 1 << 10, + Steinberg_Vst_RestartFlags_kParamIDMappingChanged = 1 << 11 +} Steinberg_Vst_RestartFlags; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 426 */ + +typedef enum +{ + Steinberg_Vst_IProgress_ProgressType_AsyncStateRestoration = 0, + Steinberg_Vst_IProgress_ProgressType_UIBackgroundTask +} Steinberg_Vst_IProgress_ProgressType; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 555 */ + +typedef enum +{ + Steinberg_Vst_KnobModes_kCircularMode = 0, + Steinberg_Vst_KnobModes_kRelativCircularMode, + Steinberg_Vst_KnobModes_kLinearMode +} Steinberg_Vst_KnobModes; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstprocesscontext.h", line 47 */ + +typedef enum +{ + Steinberg_Vst_FrameRate_FrameRateFlags_kPullDownRate = 1 << 0, + Steinberg_Vst_FrameRate_FrameRateFlags_kDropRate = 1 << 1 +} Steinberg_Vst_FrameRate_FrameRateFlags; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstprocesscontext.h", line 79 */ + +typedef enum +{ + Steinberg_Vst_Chord_Masks_kChordMask = 0x0FFF, + Steinberg_Vst_Chord_Masks_kReservedMask = 0xF000 +} Steinberg_Vst_Chord_Masks; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstprocesscontext.h", line 100 */ + +typedef enum +{ + Steinberg_Vst_ProcessContext_StatesAndFlags_kPlaying = 1 << 1, + Steinberg_Vst_ProcessContext_StatesAndFlags_kCycleActive = 1 << 2, + Steinberg_Vst_ProcessContext_StatesAndFlags_kRecording = 1 << 3, + Steinberg_Vst_ProcessContext_StatesAndFlags_kSystemTimeValid = 1 << 8, + Steinberg_Vst_ProcessContext_StatesAndFlags_kContTimeValid = 1 << 17, + Steinberg_Vst_ProcessContext_StatesAndFlags_kProjectTimeMusicValid = 1 << 9, + Steinberg_Vst_ProcessContext_StatesAndFlags_kBarPositionValid = 1 << 11, + Steinberg_Vst_ProcessContext_StatesAndFlags_kCycleValid = 1 << 12, + Steinberg_Vst_ProcessContext_StatesAndFlags_kTempoValid = 1 << 10, + Steinberg_Vst_ProcessContext_StatesAndFlags_kTimeSigValid = 1 << 13, + Steinberg_Vst_ProcessContext_StatesAndFlags_kChordValid = 1 << 18, + Steinberg_Vst_ProcessContext_StatesAndFlags_kSmpteValid = 1 << 14, + Steinberg_Vst_ProcessContext_StatesAndFlags_kClockValid = 1 << 15 +} Steinberg_Vst_ProcessContext_StatesAndFlags; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstevents.h", line 32 */ + +typedef enum +{ + Steinberg_Vst_NoteIDUserRange_kNoteIDUserRangeLowerBound = -10000, + Steinberg_Vst_NoteIDUserRange_kNoteIDUserRangeUpperBound = -1000 +} Steinberg_Vst_NoteIDUserRange; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstevents.h", line 77 */ + +typedef enum +{ + Steinberg_Vst_DataEvent_DataTypes_kMidiSysEx = 0 +} Steinberg_Vst_DataEvent_DataTypes; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstevents.h", line 150 */ + +typedef enum +{ + Steinberg_Vst_Event_EventFlags_kIsLive = 1 << 0, + Steinberg_Vst_Event_EventFlags_kUserReserved1 = 1 << 14, + Steinberg_Vst_Event_EventFlags_kUserReserved2 = 1 << 15 +} Steinberg_Vst_Event_EventFlags; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstevents.h", line 159 */ + +typedef enum +{ + Steinberg_Vst_Event_EventTypes_kNoteOnEvent = 0, + Steinberg_Vst_Event_EventTypes_kNoteOffEvent = 1, + Steinberg_Vst_Event_EventTypes_kDataEvent = 2, + Steinberg_Vst_Event_EventTypes_kPolyPressureEvent = 3, + Steinberg_Vst_Event_EventTypes_kNoteExpressionValueEvent = 4, + Steinberg_Vst_Event_EventTypes_kNoteExpressionTextEvent = 5, + Steinberg_Vst_Event_EventTypes_kChordEvent = 6, + Steinberg_Vst_Event_EventTypes_kScaleEvent = 7, + Steinberg_Vst_Event_EventTypes_kNoteExpressionIntValueEvent = 8, + Steinberg_Vst_Event_EventTypes_kLegacyMIDICCOutEvent = 65535 +} Steinberg_Vst_Event_EventTypes; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstcontextmenu.h", line 174 */ + +typedef enum +{ + Steinberg_Vst_IContextMenuItem_Flags_kIsSeparator = 1 << 0, + Steinberg_Vst_IContextMenuItem_Flags_kIsDisabled = 1 << 1, + Steinberg_Vst_IContextMenuItem_Flags_kIsChecked = 1 << 2, + Steinberg_Vst_IContextMenuItem_Flags_kIsGroupStart = 1 << 3 | Steinberg_Vst_IContextMenuItem_Flags_kIsDisabled, + Steinberg_Vst_IContextMenuItem_Flags_kIsGroupEnd = 1 << 4 | Steinberg_Vst_IContextMenuItem_Flags_kIsSeparator +} Steinberg_Vst_IContextMenuItem_Flags; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstmidicontrollers.h", line 25 */ + +typedef enum +{ + Steinberg_Vst_ControllerNumbers_kCtrlBankSelectMSB = 0, + Steinberg_Vst_ControllerNumbers_kCtrlModWheel = 1, + Steinberg_Vst_ControllerNumbers_kCtrlBreath = 2, + Steinberg_Vst_ControllerNumbers_kCtrlFoot = 4, + Steinberg_Vst_ControllerNumbers_kCtrlPortaTime = 5, + Steinberg_Vst_ControllerNumbers_kCtrlDataEntryMSB = 6, + Steinberg_Vst_ControllerNumbers_kCtrlVolume = 7, + Steinberg_Vst_ControllerNumbers_kCtrlBalance = 8, + Steinberg_Vst_ControllerNumbers_kCtrlPan = 10, + Steinberg_Vst_ControllerNumbers_kCtrlExpression = 11, + Steinberg_Vst_ControllerNumbers_kCtrlEffect1 = 12, + Steinberg_Vst_ControllerNumbers_kCtrlEffect2 = 13, + Steinberg_Vst_ControllerNumbers_kCtrlGPC1 = 16, + Steinberg_Vst_ControllerNumbers_kCtrlGPC2 = 17, + Steinberg_Vst_ControllerNumbers_kCtrlGPC3 = 18, + Steinberg_Vst_ControllerNumbers_kCtrlGPC4 = 19, + Steinberg_Vst_ControllerNumbers_kCtrlBankSelectLSB = 32, + Steinberg_Vst_ControllerNumbers_kCtrlDataEntryLSB = 38, + Steinberg_Vst_ControllerNumbers_kCtrlSustainOnOff = 64, + Steinberg_Vst_ControllerNumbers_kCtrlPortaOnOff = 65, + Steinberg_Vst_ControllerNumbers_kCtrlSustenutoOnOff = 66, + Steinberg_Vst_ControllerNumbers_kCtrlSoftPedalOnOff = 67, + Steinberg_Vst_ControllerNumbers_kCtrlLegatoFootSwOnOff = 68, + Steinberg_Vst_ControllerNumbers_kCtrlHold2OnOff = 69, + Steinberg_Vst_ControllerNumbers_kCtrlSoundVariation = 70, + Steinberg_Vst_ControllerNumbers_kCtrlFilterCutoff = 71, + Steinberg_Vst_ControllerNumbers_kCtrlReleaseTime = 72, + Steinberg_Vst_ControllerNumbers_kCtrlAttackTime = 73, + Steinberg_Vst_ControllerNumbers_kCtrlFilterResonance = 74, + Steinberg_Vst_ControllerNumbers_kCtrlDecayTime = 75, + Steinberg_Vst_ControllerNumbers_kCtrlVibratoRate = 76, + Steinberg_Vst_ControllerNumbers_kCtrlVibratoDepth = 77, + Steinberg_Vst_ControllerNumbers_kCtrlVibratoDelay = 78, + Steinberg_Vst_ControllerNumbers_kCtrlSoundCtrler10 = 79, + Steinberg_Vst_ControllerNumbers_kCtrlGPC5 = 80, + Steinberg_Vst_ControllerNumbers_kCtrlGPC6 = 81, + Steinberg_Vst_ControllerNumbers_kCtrlGPC7 = 82, + Steinberg_Vst_ControllerNumbers_kCtrlGPC8 = 83, + Steinberg_Vst_ControllerNumbers_kCtrlPortaControl = 84, + Steinberg_Vst_ControllerNumbers_kCtrlEff1Depth = 91, + Steinberg_Vst_ControllerNumbers_kCtrlEff2Depth = 92, + Steinberg_Vst_ControllerNumbers_kCtrlEff3Depth = 93, + Steinberg_Vst_ControllerNumbers_kCtrlEff4Depth = 94, + Steinberg_Vst_ControllerNumbers_kCtrlEff5Depth = 95, + Steinberg_Vst_ControllerNumbers_kCtrlDataIncrement = 96, + Steinberg_Vst_ControllerNumbers_kCtrlDataDecrement = 97, + Steinberg_Vst_ControllerNumbers_kCtrlNRPNSelectLSB = 98, + Steinberg_Vst_ControllerNumbers_kCtrlNRPNSelectMSB = 99, + Steinberg_Vst_ControllerNumbers_kCtrlRPNSelectLSB = 100, + Steinberg_Vst_ControllerNumbers_kCtrlRPNSelectMSB = 101, + Steinberg_Vst_ControllerNumbers_kCtrlAllSoundsOff = 120, + Steinberg_Vst_ControllerNumbers_kCtrlResetAllCtrlers = 121, + Steinberg_Vst_ControllerNumbers_kCtrlLocalCtrlOnOff = 122, + Steinberg_Vst_ControllerNumbers_kCtrlAllNotesOff = 123, + Steinberg_Vst_ControllerNumbers_kCtrlOmniModeOff = 124, + Steinberg_Vst_ControllerNumbers_kCtrlOmniModeOn = 125, + Steinberg_Vst_ControllerNumbers_kCtrlPolyModeOnOff = 126, + Steinberg_Vst_ControllerNumbers_kCtrlPolyModeOn = 127, + Steinberg_Vst_ControllerNumbers_kAfterTouch = 128, + Steinberg_Vst_ControllerNumbers_kPitchBend = 129, + Steinberg_Vst_ControllerNumbers_kCountCtrlNumber, + Steinberg_Vst_ControllerNumbers_kCtrlProgramChange = 130, + Steinberg_Vst_ControllerNumbers_kCtrlPolyPressure = 131, + Steinberg_Vst_ControllerNumbers_kCtrlQuarterFrame = 132, + Steinberg_Vst_ControllerNumbers_kSystemSongSelect = 133, + Steinberg_Vst_ControllerNumbers_kSystemSongPointer = 134, + Steinberg_Vst_ControllerNumbers_kSystemCableSelect = 135, + Steinberg_Vst_ControllerNumbers_kSystemTuneRequest = 136, + Steinberg_Vst_ControllerNumbers_kSystemMidiClockStart = 137, + Steinberg_Vst_ControllerNumbers_kSystemMidiClockContinue = 138, + Steinberg_Vst_ControllerNumbers_kSystemMidiClockStop = 139, + Steinberg_Vst_ControllerNumbers_kSystemActiveSensing = 140 +} Steinberg_Vst_ControllerNumbers; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstchannelcontextinfo.h", line 170 */ + +typedef enum +{ + Steinberg_Vst_ChannelContext_ChannelPluginLocation_kPreVolumeFader = 0, + Steinberg_Vst_ChannelContext_ChannelPluginLocation_kPostVolumeFader, + Steinberg_Vst_ChannelContext_ChannelPluginLocation_kUsedAsPanner +} Steinberg_Vst_ChannelContext_ChannelPluginLocation; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstprefetchablesupport.h", line 38 */ + +typedef enum +{ + Steinberg_Vst_ePrefetchableSupport_kIsNeverPrefetchable = 0, + Steinberg_Vst_ePrefetchableSupport_kIsYetPrefetchable, + Steinberg_Vst_ePrefetchableSupport_kIsNotYetPrefetchable, + Steinberg_Vst_ePrefetchableSupport_kNumPrefetchableSupport +} Steinberg_Vst_ePrefetchableSupport; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstautomationstate.h", line 43 */ + +typedef enum +{ + Steinberg_Vst_IAutomationState_AutomationStates_kNoAutomation = 0, + Steinberg_Vst_IAutomationState_AutomationStates_kReadState = 1 << 0, + Steinberg_Vst_IAutomationState_AutomationStates_kWriteState = 1 << 1, + Steinberg_Vst_IAutomationState_AutomationStates_kReadWriteState = Steinberg_Vst_IAutomationState_AutomationStates_kReadState | Steinberg_Vst_IAutomationState_AutomationStates_kWriteState +} Steinberg_Vst_IAutomationState_AutomationStates; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstaudioprocessor.h", line 101 */ + +typedef enum +{ + Steinberg_Vst_ComponentFlags_kDistributable = 1 << 0, + Steinberg_Vst_ComponentFlags_kSimpleModeSupported = 1 << 1 +} Steinberg_Vst_ComponentFlags; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstaudioprocessor.h", line 113 */ + +typedef enum +{ + Steinberg_Vst_SymbolicSampleSizes_kSample32, + Steinberg_Vst_SymbolicSampleSizes_kSample64 +} Steinberg_Vst_SymbolicSampleSizes; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstaudioprocessor.h", line 147 */ + +typedef enum +{ + Steinberg_Vst_ProcessModes_kRealtime, + Steinberg_Vst_ProcessModes_kPrefetch, + Steinberg_Vst_ProcessModes_kOffline +} Steinberg_Vst_ProcessModes; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstaudioprocessor.h", line 440 */ + +typedef enum +{ + Steinberg_Vst_IProcessContextRequirements_Flags_kNeedSystemTime = 1 << 0, + Steinberg_Vst_IProcessContextRequirements_Flags_kNeedContinousTimeSamples = 1 << 1, + Steinberg_Vst_IProcessContextRequirements_Flags_kNeedProjectTimeMusic = 1 << 2, + Steinberg_Vst_IProcessContextRequirements_Flags_kNeedBarPositionMusic = 1 << 3, + Steinberg_Vst_IProcessContextRequirements_Flags_kNeedCycleMusic = 1 << 4, + Steinberg_Vst_IProcessContextRequirements_Flags_kNeedSamplesToNextClock = 1 << 5, + Steinberg_Vst_IProcessContextRequirements_Flags_kNeedTempo = 1 << 6, + Steinberg_Vst_IProcessContextRequirements_Flags_kNeedTimeSignature = 1 << 7, + Steinberg_Vst_IProcessContextRequirements_Flags_kNeedChord = 1 << 8, + Steinberg_Vst_IProcessContextRequirements_Flags_kNeedFrameRate = 1 << 9, + Steinberg_Vst_IProcessContextRequirements_Flags_kNeedTransportState = 1 << 10 +} Steinberg_Vst_IProcessContextRequirements_Flags; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteonorchestralarticulationinfo.h", line 70 */ + +typedef enum +{ + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kCoreSoundSustainAndStrikes = 0, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kStaccatosAndShorts = 1, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kSameNoteTrillsRepeats = 2, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kIntervallicTrills = 3, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kAdditionalColors = 4, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kPitchAndDynamicGestures = 5, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kScalesRunsAndArpeggios = 6, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kEffectsAndNoises = 7, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kReserved1 = 8, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kReserved2 = 9, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kCustomNoteOn1 = 10, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kCustomNoteOn2 = 11, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kCustomNoteOn3 = 12, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kCustomNoteOn4 = 13, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kCustomNoteOn5 = 14, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kCustomNoteOn6 = 15, + Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification_kReserved3 = 16 +} Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_Classification; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsttransportcontrol.h", line 32 */ + +typedef enum +{ + Steinberg_Vst_TransportPositionType_Samples, + Steinberg_Vst_TransportPositionType_QuarterNotes +} Steinberg_Vst_TransportPositionType; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsttransportcontrol.h", line 105 */ + +typedef enum +{ + Steinberg_Vst_ITransportControl_Action_Locate = 0, + Steinberg_Vst_ITransportControl_Action_PlaybackStart, + Steinberg_Vst_ITransportControl_Action_PlaybackStop, + Steinberg_Vst_ITransportControl_Action_LocateAndPlaybackStart, + Steinberg_Vst_ITransportControl_Action_PlaybackStopAndLocate, + Steinberg_Vst_ITransportControl_Action_RecordOnPlaybackStart, + Steinberg_Vst_ITransportControl_Action_LocateAndRecordOnPlaybackStart, + Steinberg_Vst_ITransportControl_Action_RecordOff, + Steinberg_Vst_ITransportControl_Action_RecordOffPlaybackStop, + Steinberg_Vst_ITransportControl_Action_RecordOffPlaybackStopAndLocate, + Steinberg_Vst_ITransportControl_Action_SetCycleStart, + Steinberg_Vst_ITransportControl_Action_SetCycleEnd, + Steinberg_Vst_ITransportControl_Action_CycleOn, + Steinberg_Vst_ITransportControl_Action_CycleOff +} Steinberg_Vst_ITransportControl_Action; + + +/*---------------------------------------------------------------------------------------------------------------------- +----- Variable declarations -------------------------------------------------------------------------------------------- +----------------------------------------------------------------------------------------------------------------------*/ + +static const Steinberg_int32 Steinberg_kMaxInt32 = INT32_MAX; +static const Steinberg_int32 Steinberg_kMinInt32 = INT32_MIN; +static const Steinberg_int32 Steinberg_kMaxLong = INT32_MAX; +static const Steinberg_int32 Steinberg_kMinLong = INT32_MIN; +static const Steinberg_uint32 Steinberg_kMaxInt32u = UINT32_MAX; +static const Steinberg_int64 Steinberg_kMaxInt64 = INT64_MAX; +static const Steinberg_int64 Steinberg_kMinInt64 = INT64_MIN; +static const Steinberg_uint64 Steinberg_kMaxInt64u = UINT64_MAX; +static const Steinberg_FIDString Steinberg_kPlatformStringWin = "WIN"; +static const Steinberg_FIDString Steinberg_kPlatformStringMac = "MAC"; +static const Steinberg_FIDString Steinberg_kPlatformStringIOS = "IOS"; +static const Steinberg_FIDString Steinberg_kPlatformStringLinux = "Linux"; +static const Steinberg_FIDString Steinberg_kPlatformString = "MAC"; +static const Steinberg_UCoord Steinberg_kMaxCoord = ((Steinberg_UCoord) 0x7FFFFFFF); +static const Steinberg_UCoord Steinberg_kMinCoord = ((Steinberg_UCoord) -0x7FFFFFFF); +static const Steinberg_FIDString Steinberg_kPlatformTypeHWND = "HWND"; +static const Steinberg_FIDString Steinberg_kPlatformTypeHIView = "HIView"; +static const Steinberg_FIDString Steinberg_kPlatformTypeNSView = "NSView"; +static const Steinberg_FIDString Steinberg_kPlatformTypeUIView = "UIView"; +static const Steinberg_FIDString Steinberg_kPlatformTypeX11EmbedWindowID = "X11EmbedWindowID"; +static const Steinberg_FIDString Steinberg_kPlatformTypeWaylandSurfaceID = "WaylandSurfaceID"; +static const Steinberg_uint32 Steinberg_kPrintfBufferSize = 4096; +static const Steinberg_Vst_ParamID Steinberg_Vst_kNoParamId = 0xFFFFFFFF; +static const Steinberg_Vst_ParamID Steinberg_Vst_kMinParamId = 0; +static const Steinberg_Vst_ParamID Steinberg_Vst_kMaxParamId = 0x7FFFFFFF; +static const Steinberg_int32 Steinberg_Vst_kStepCountContinuous = 0; +static const Steinberg_int32 Steinberg_Vst_kStepCountToggle = 1; +static const Steinberg_FIDString Steinberg_Vst_SDKVersionString = "VST 3.8.1"; +static const Steinberg_uint32 Steinberg_Vst_SDKVersionMajor = 3; +static const Steinberg_uint32 Steinberg_Vst_SDKVersionMinor = 8; +static const Steinberg_uint32 Steinberg_Vst_SDKVersionSub = 1; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion = ((3 << 16) | (8 << 8) | 1); +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_8_0 = 0x030800; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_14 = 0x03070E; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_13 = 0x03070D; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_12 = 0x03070C; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_11 = 0x03070B; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_10 = 0x03070A; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_9 = 0x030709; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_8 = 0x030708; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_7 = 0x030707; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_6 = 0x030706; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_5 = 0x030705; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_4 = 0x030704; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_3 = 0x030703; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_2 = 0x030702; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_1 = 0x030701; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_7_0 = 0x030700; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_6_14 = 0x03060E; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_6_13 = 0x03060D; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_6_12 = 0x03060C; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_6_11 = 0x03060B; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_6_10 = 0x03060A; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_6_9 = 0x030609; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_6_8 = 0x030608; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_6_7 = 0x030607; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_6_6 = 0x030606; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_6_5 = 0x030605; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_6_0 = 0x030600; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_5_0 = 0x030500; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_1_0 = 0x030100; +static const Steinberg_uint32 Steinberg_Vst_SDKVersion_3_0_0 = 0x030000; +static const Steinberg_int32 Steinberg_Vst_kDefaultFactoryFlags = 1 << 4; +static const Steinberg_Vst_CString Steinberg_Vst_PresetAttributes_kPlugInName = "PlugInName"; +static const Steinberg_Vst_CString Steinberg_Vst_PresetAttributes_kPlugInCategory = "PlugInCategory"; +static const Steinberg_Vst_CString Steinberg_Vst_PresetAttributes_kInstrument = "MusicalInstrument"; +static const Steinberg_Vst_CString Steinberg_Vst_PresetAttributes_kStyle = "MusicalStyle"; +static const Steinberg_Vst_CString Steinberg_Vst_PresetAttributes_kCharacter = "MusicalCharacter"; +static const Steinberg_Vst_CString Steinberg_Vst_PresetAttributes_kStateType = "StateType"; +static const Steinberg_Vst_CString Steinberg_Vst_PresetAttributes_kFilePathStringType = "FilePathString"; +static const Steinberg_Vst_CString Steinberg_Vst_PresetAttributes_kName = "Name"; +static const Steinberg_Vst_CString Steinberg_Vst_PresetAttributes_kFileName = "FileName"; +static const Steinberg_Vst_CString Steinberg_Vst_StateType_kProject = "Project"; +static const Steinberg_Vst_CString Steinberg_Vst_StateType_kDefault = "Default"; +static const Steinberg_Vst_CString Steinberg_Vst_StateType_kTrackPreset = "TrackPreset"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kAccordion = "Accordion"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kAccordionAccordion = "Accordion|Accordion"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kAccordionHarmonica = "Accordion|Harmonica"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kAccordionOther = "Accordion|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kBass = "Bass"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kBassABass = "Bass|A. Bass"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kBassEBass = "Bass|E. Bass"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kBassSynthBass = "Bass|Synth Bass"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kBassOther = "Bass|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kBrass = "Brass"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kBrassFrenchHorn = "Brass|French Horn"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kBrassTrumpet = "Brass|Trumpet"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kBrassTrombone = "Brass|Trombone"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kBrassTuba = "Brass|Tuba"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kBrassSection = "Brass|Section"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kBrassSynth = "Brass|Synth"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kBrassOther = "Brass|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kChromaticPerc = "Chromatic Perc"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kChromaticPercBell = "Chromatic Perc|Bell"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kChromaticPercMallett = "Chromatic Perc|Mallett"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kChromaticPercWood = "Chromatic Perc|Wood"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kChromaticPercPercussion = "Chromatic Perc|Percussion"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kChromaticPercTimpani = "Chromatic Perc|Timpani"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kChromaticPercOther = "Chromatic Perc|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kDrumPerc = "Drum&Perc"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kDrumPercDrumsetGM = "Drum&Perc|Drumset GM"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kDrumPercDrumset = "Drum&Perc|Drumset"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kDrumPercDrumMenues = "Drum&Perc|Drum Menues"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kDrumPercBeats = "Drum&Perc|Beats"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kDrumPercPercussion = "Drum&Perc|Percussion"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kDrumPercKickDrum = "Drum&Perc|Kick Drum"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kDrumPercSnareDrum = "Drum&Perc|Snare Drum"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kDrumPercToms = "Drum&Perc|Toms"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kDrumPercHiHats = "Drum&Perc|HiHats"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kDrumPercCymbals = "Drum&Perc|Cymbals"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kDrumPercOther = "Drum&Perc|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kEthnic = "Ethnic"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kEthnicAsian = "Ethnic|Asian"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kEthnicAfrican = "Ethnic|African"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kEthnicEuropean = "Ethnic|European"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kEthnicLatin = "Ethnic|Latin"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kEthnicAmerican = "Ethnic|American"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kEthnicAlien = "Ethnic|Alien"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kEthnicOther = "Ethnic|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kGuitar = "Guitar/Plucked"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kGuitarAGuitar = "Guitar/Plucked|A. Guitar"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kGuitarEGuitar = "Guitar/Plucked|E. Guitar"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kGuitarHarp = "Guitar/Plucked|Harp"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kGuitarEthnic = "Guitar/Plucked|Ethnic"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kGuitarOther = "Guitar/Plucked|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kKeyboard = "Keyboard"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kKeyboardClavi = "Keyboard|Clavi"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kKeyboardEPiano = "Keyboard|E. Piano"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kKeyboardHarpsichord = "Keyboard|Harpsichord"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kKeyboardOther = "Keyboard|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kMusicalFX = "Musical FX"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kMusicalFXHitsStabs = "Musical FX|Hits&Stabs"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kMusicalFXMotion = "Musical FX|Motion"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kMusicalFXSweeps = "Musical FX|Sweeps"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kMusicalFXBeepsBlips = "Musical FX|Beeps&Blips"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kMusicalFXScratches = "Musical FX|Scratches"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kMusicalFXOther = "Musical FX|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kOrgan = "Organ"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kOrganElectric = "Organ|Electric"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kOrganPipe = "Organ|Pipe"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kOrganOther = "Organ|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kPiano = "Piano"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kPianoAPiano = "Piano|A. Piano"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kPianoEGrand = "Piano|E. Grand"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kPianoOther = "Piano|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSoundFX = "Sound FX"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSoundFXNature = "Sound FX|Nature"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSoundFXMechanical = "Sound FX|Mechanical"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSoundFXSynthetic = "Sound FX|Synthetic"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSoundFXOther = "Sound FX|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kStrings = "Strings"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kStringsViolin = "Strings|Violin"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kStringsViola = "Strings|Viola"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kStringsCello = "Strings|Cello"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kStringsBass = "Strings|Bass"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kStringsSection = "Strings|Section"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kStringsSynth = "Strings|Synth"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kStringsOther = "Strings|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthLead = "Synth Lead"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthLeadAnalog = "Synth Lead|Analog"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthLeadDigital = "Synth Lead|Digital"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthLeadArpeggio = "Synth Lead|Arpeggio"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthLeadOther = "Synth Lead|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthPad = "Synth Pad"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthPadSynthChoir = "Synth Pad|Synth Choir"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthPadAnalog = "Synth Pad|Analog"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthPadDigital = "Synth Pad|Digital"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthPadMotion = "Synth Pad|Motion"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthPadOther = "Synth Pad|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthComp = "Synth Comp"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthCompAnalog = "Synth Comp|Analog"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthCompDigital = "Synth Comp|Digital"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kSynthCompOther = "Synth Comp|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kVocal = "Vocal"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kVocalLeadVocal = "Vocal|Lead Vocal"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kVocalAdlibs = "Vocal|Adlibs"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kVocalChoir = "Vocal|Choir"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kVocalSolo = "Vocal|Solo"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kVocalFX = "Vocal|FX"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kVocalSpoken = "Vocal|Spoken"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kVocalOther = "Vocal|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kWoodwinds = "Woodwinds"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kWoodwindsEthnic = "Woodwinds|Ethnic"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kWoodwindsFlute = "Woodwinds|Flute"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kWoodwindsOboe = "Woodwinds|Oboe"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kWoodwindsEnglHorn = "Woodwinds|Engl. Horn"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kWoodwindsClarinet = "Woodwinds|Clarinet"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kWoodwindsSaxophone = "Woodwinds|Saxophone"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kWoodwindsBassoon = "Woodwinds|Bassoon"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalInstrument_kWoodwindsOther = "Woodwinds|Other"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kAlternativeIndie = "Alternative/Indie"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kAlternativeIndieGothRock = "Alternative/Indie|Goth Rock"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kAlternativeIndieGrunge = "Alternative/Indie|Grunge"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kAlternativeIndieNewWave = "Alternative/Indie|New Wave"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kAlternativeIndiePunk = "Alternative/Indie|Punk"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kAlternativeIndieCollegeRock = "Alternative/Indie|College Rock"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kAlternativeIndieDarkWave = "Alternative/Indie|Dark Wave"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kAlternativeIndieHardcore = "Alternative/Indie|Hardcore"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kAmbientChillOut = "Ambient/ChillOut"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kAmbientChillOutNewAgeMeditation = "Ambient/ChillOut|New Age/Meditation"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kAmbientChillOutDarkAmbient = "Ambient/ChillOut|Dark Ambient"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kAmbientChillOutDowntempo = "Ambient/ChillOut|Downtempo"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kAmbientChillOutLounge = "Ambient/ChillOut|Lounge"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kBlues = "Blues"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kBluesAcousticBlues = "Blues|Acoustic Blues"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kBluesCountryBlues = "Blues|Country Blues"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kBluesElectricBlues = "Blues|Electric Blues"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kBluesChicagoBlues = "Blues|Chicago Blues"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kClassical = "Classical"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kClassicalBaroque = "Classical|Baroque"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kClassicalChamberMusic = "Classical|Chamber Music"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kClassicalMedieval = "Classical|Medieval"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kClassicalModernComposition = "Classical|Modern Composition"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kClassicalOpera = "Classical|Opera"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kClassicalGregorian = "Classical|Gregorian"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kClassicalRenaissance = "Classical|Renaissance"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kClassicalClassic = "Classical|Classic"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kClassicalRomantic = "Classical|Romantic"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kClassicalSoundtrack = "Classical|Soundtrack"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kCountry = "Country"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kCountryCountryWestern = "Country|Country/Western"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kCountryHonkyTonk = "Country|Honky Tonk"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kCountryUrbanCowboy = "Country|Urban Cowboy"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kCountryBluegrass = "Country|Bluegrass"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kCountryAmericana = "Country|Americana"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kCountrySquaredance = "Country|Squaredance"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kCountryNorthAmericanFolk = "Country|North American Folk"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDance = "Electronica/Dance"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDanceMinimal = "Electronica/Dance|Minimal"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDanceClassicHouse = "Electronica/Dance|Classic House"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDanceElektroHouse = "Electronica/Dance|Elektro House"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDanceFunkyHouse = "Electronica/Dance|Funky House"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDanceIndustrial = "Electronica/Dance|Industrial"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDanceElectronicBodyMusic = "Electronica/Dance|Electronic Body Music"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDanceTripHop = "Electronica/Dance|Trip Hop"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDanceTechno = "Electronica/Dance|Techno"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDanceDrumNBassJungle = "Electronica/Dance|Drum'n'Bass/Jungle"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDanceElektro = "Electronica/Dance|Elektro"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDanceTrance = "Electronica/Dance|Trance"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDanceDub = "Electronica/Dance|Dub"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kElectronicaDanceBigBeats = "Electronica/Dance|Big Beats"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kExperimental = "Experimental"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kExperimentalNewMusic = "Experimental|New Music"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kExperimentalFreeImprovisation = "Experimental|Free Improvisation"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kExperimentalElectronicArtMusic = "Experimental|Electronic Art Music"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kExperimentalNoise = "Experimental|Noise"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kJazz = "Jazz"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kJazzNewOrleansJazz = "Jazz|New Orleans Jazz"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kJazzTraditionalJazz = "Jazz|Traditional Jazz"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kJazzOldtimeJazzDixiland = "Jazz|Oldtime Jazz/Dixiland"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kJazzFusion = "Jazz|Fusion"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kJazzAvantgarde = "Jazz|Avantgarde"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kJazzLatinJazz = "Jazz|Latin Jazz"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kJazzFreeJazz = "Jazz|Free Jazz"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kJazzRagtime = "Jazz|Ragtime"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kPop = "Pop"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kPopBritpop = "Pop|Britpop"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kPopRock = "Pop|Pop/Rock"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kPopTeenPop = "Pop|Teen Pop"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kPopChartDance = "Pop|Chart Dance"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kPop80sPop = "Pop|80's Pop"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kPopDancehall = "Pop|Dancehall"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kPopDisco = "Pop|Disco"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetal = "Rock/Metal"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalBluesRock = "Rock/Metal|Blues Rock"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalClassicRock = "Rock/Metal|Classic Rock"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalHardRock = "Rock/Metal|Hard Rock"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalRockRoll = "Rock/Metal|Rock & Roll"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalSingerSongwriter = "Rock/Metal|Singer/Songwriter"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalHeavyMetal = "Rock/Metal|Heavy Metal"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalDeathBlackMetal = "Rock/Metal|Death/Black Metal"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalNuMetal = "Rock/Metal|NuMetal"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalReggae = "Rock/Metal|Reggae"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalBallad = "Rock/Metal|Ballad"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalAlternativeRock = "Rock/Metal|Alternative Rock"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalRockabilly = "Rock/Metal|Rockabilly"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalThrashMetal = "Rock/Metal|Thrash Metal"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kRockMetalProgressiveRock = "Rock/Metal|Progressive Rock"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kUrbanHipHopRB = "Urban (Hip-Hop / R&B)"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kUrbanHipHopRBClassic = "Urban (Hip-Hop / R&B)|Classic R&B"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kUrbanHipHopRBModern = "Urban (Hip-Hop / R&B)|Modern R&B"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kUrbanHipHopRBPop = "Urban (Hip-Hop / R&B)|R&B Pop"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kUrbanHipHopRBWestCoastHipHop = "Urban (Hip-Hop / R&B)|WestCoast Hip-Hop"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kUrbanHipHopRBEastCoastHipHop = "Urban (Hip-Hop / R&B)|EastCoast Hip-Hop"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kUrbanHipHopRBRapHipHop = "Urban (Hip-Hop / R&B)|Rap/Hip Hop"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kUrbanHipHopRBSoul = "Urban (Hip-Hop / R&B)|Soul"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kUrbanHipHopRBFunk = "Urban (Hip-Hop / R&B)|Funk"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kWorldEthnic = "World/Ethnic"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kWorldEthnicAfrica = "World/Ethnic|Africa"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kWorldEthnicAsia = "World/Ethnic|Asia"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kWorldEthnicCeltic = "World/Ethnic|Celtic"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kWorldEthnicEurope = "World/Ethnic|Europe"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kWorldEthnicKlezmer = "World/Ethnic|Klezmer"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kWorldEthnicScandinavia = "World/Ethnic|Scandinavia"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kWorldEthnicEasternEurope = "World/Ethnic|Eastern Europe"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kWorldEthnicIndiaOriental = "World/Ethnic|India/Oriental"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kWorldEthnicNorthAmerica = "World/Ethnic|North America"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kWorldEthnicSouthAmerica = "World/Ethnic|South America"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalStyle_kWorldEthnicAustralia = "World/Ethnic|Australia"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kMono = "Mono"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kPoly = "Poly"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kSplit = "Split"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kLayer = "Layer"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kGlide = "Glide"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kGlissando = "Glissando"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kMajor = "Major"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kMinor = "Minor"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kSingle = "Single"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kEnsemble = "Ensemble"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kAcoustic = "Acoustic"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kElectric = "Electric"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kAnalog = "Analog"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kDigital = "Digital"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kVintage = "Vintage"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kModern = "Modern"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kOld = "Old"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kNew = "New"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kClean = "Clean"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kDistorted = "Distorted"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kDry = "Dry"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kProcessed = "Processed"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kHarmonic = "Harmonic"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kDissonant = "Dissonant"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kClear = "Clear"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kNoisy = "Noisy"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kThin = "Thin"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kRich = "Rich"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kDark = "Dark"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kBright = "Bright"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kCold = "Cold"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kWarm = "Warm"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kMetallic = "Metallic"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kWooden = "Wooden"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kGlass = "Glass"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kPlastic = "Plastic"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kPercussive = "Percussive"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kSoft = "Soft"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kFast = "Fast"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kSlow = "Slow"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kShort = "Short"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kLong = "Long"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kAttack = "Attack"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kRelease = "Release"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kDecay = "Decay"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kSustain = "Sustain"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kFastAttack = "Fast Attack"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kSlowAttack = "Slow Attack"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kShortRelease = "Short Release"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kLongRelease = "Long Release"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kStatic = "Static"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kMoving = "Moving"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kLoop = "Loop"; +static const Steinberg_Vst_CString Steinberg_Vst_MusicalCharacter_kOneShot = "One Shot"; +static const Steinberg_Vst_CString Steinberg_Vst_ViewType_kEditor = "editor"; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerL = 1 << 0; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerR = 1 << 1; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerC = 1 << 2; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerLfe = 1 << 3; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerLs = 1 << 4; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerRs = 1 << 5; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerLc = 1 << 6; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerRc = 1 << 7; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerS = 1 << 8; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerCs = 1 << 8; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerSl = 1 << 9; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerSr = 1 << 10; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerTc = 1 << 11; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerTfl = 1 << 12; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerTfc = 1 << 13; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerTfr = 1 << 14; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerTrl = 1 << 15; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerTrc = 1 << 16; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerTrr = 1 << 17; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerLfe2 = 1 << 18; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerM = 1 << 19; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN0 = (Steinberg_Vst_Speaker) 1 << 20; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN1 = (Steinberg_Vst_Speaker) 1 << 21; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN2 = (Steinberg_Vst_Speaker) 1 << 22; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN3 = (Steinberg_Vst_Speaker) 1 << 23; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN4 = (Steinberg_Vst_Speaker) 1 << 38; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN5 = (Steinberg_Vst_Speaker) 1 << 39; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN6 = (Steinberg_Vst_Speaker) 1 << 40; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN7 = (Steinberg_Vst_Speaker) 1 << 41; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN8 = (Steinberg_Vst_Speaker) 1 << 42; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN9 = (Steinberg_Vst_Speaker) 1 << 43; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN10 = (Steinberg_Vst_Speaker) 1 << 44; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN11 = (Steinberg_Vst_Speaker) 1 << 45; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN12 = (Steinberg_Vst_Speaker) 1 << 46; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN13 = (Steinberg_Vst_Speaker) 1 << 47; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN14 = (Steinberg_Vst_Speaker) 1 << 48; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN15 = (Steinberg_Vst_Speaker) 1 << 49; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN16 = (Steinberg_Vst_Speaker) 1 << 50; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN17 = (Steinberg_Vst_Speaker) 1 << 51; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN18 = (Steinberg_Vst_Speaker) 1 << 52; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN19 = (Steinberg_Vst_Speaker) 1 << 53; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN20 = (Steinberg_Vst_Speaker) 1 << 54; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN21 = (Steinberg_Vst_Speaker) 1 << 55; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN22 = (Steinberg_Vst_Speaker) 1 << 56; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN23 = (Steinberg_Vst_Speaker) 1 << 57; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerACN24 = (Steinberg_Vst_Speaker) 1 << 58; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerTsl = (Steinberg_Vst_Speaker) 1 << 24; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerTsr = (Steinberg_Vst_Speaker) 1 << 25; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerLcs = (Steinberg_Vst_Speaker) 1 << 26; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerRcs = (Steinberg_Vst_Speaker) 1 << 27; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerBfl = (Steinberg_Vst_Speaker) 1 << 28; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerBfc = (Steinberg_Vst_Speaker) 1 << 29; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerBfr = (Steinberg_Vst_Speaker) 1 << 30; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerPl = (Steinberg_Vst_Speaker) 1 << 31; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerPr = (Steinberg_Vst_Speaker) 1 << 32; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerBsl = (Steinberg_Vst_Speaker) 1 << 33; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerBsr = (Steinberg_Vst_Speaker) 1 << 34; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerBrl = (Steinberg_Vst_Speaker) 1 << 35; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerBrc = (Steinberg_Vst_Speaker) 1 << 36; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerBrr = (Steinberg_Vst_Speaker) 1 << 37; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerLw = (Steinberg_Vst_Speaker) 1 << 59; +static const Steinberg_Vst_Speaker Steinberg_Vst_kSpeakerRw = (Steinberg_Vst_Speaker) 1 << 60; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kEmpty = 0; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kMono = 1 << 19; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kStereo = 1 << 0 | 1 << 1; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kStereoWide = (Steinberg_Vst_Speaker) 1 << 59 | (Steinberg_Vst_Speaker) 1 << 60; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kStereoSurround = 1 << 4 | 1 << 5; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kStereoCenter = 1 << 6 | 1 << 7; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kStereoSide = 1 << 9 | 1 << 10; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kStereoCLfe = 1 << 2 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kStereoTF = 1 << 12 | 1 << 14; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kStereoTS = (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kStereoTR = 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kStereoBF = (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 30; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kCineFront = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 6 | 1 << 7; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k30Cine = 1 << 0 | 1 << 1 | 1 << 2; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k31Cine = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k30Music = 1 << 0 | 1 << 1 | 1 << 8; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k31Music = 1 << 0 | 1 << 1 | 1 << 8 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k40Cine = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 8; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k41Cine = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 8 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k40Music = 1 << 0 | 1 << 1 | 1 << 4 | 1 << 5; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k41Music = 1 << 0 | 1 << 1 | 1 << 4 | 1 << 5 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k50 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k51 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k60Cine = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 8; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k61Cine = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 8 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k60Music = 1 << 0 | 1 << 1 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k61Music = 1 << 0 | 1 << 1 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k70Cine = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71Cine = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71CineFullFront = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k70Music = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71Music = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71CineFullRear = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | (Steinberg_Vst_Speaker) 1 << 26 | (Steinberg_Vst_Speaker) 1 << 27; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71CineSideFill = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71Proximity = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | (Steinberg_Vst_Speaker) 1 << 31 | (Steinberg_Vst_Speaker) 1 << 32; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k80Cine = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k81Cine = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k80Music = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 8 | 1 << 9 | 1 << 10; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k81Music = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 8 | 1 << 9 | 1 << 10 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k90Cine = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 9 | 1 << 10; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k91Cine = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 9 | 1 << 10 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k100Cine = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 9 | 1 << 10; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k101Cine = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 9 | 1 << 10 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kAmbi1stOrderACN = (Steinberg_Vst_Speaker) 1 << 20 | (Steinberg_Vst_Speaker) 1 << 21 | (Steinberg_Vst_Speaker) 1 << 22 | (Steinberg_Vst_Speaker) 1 << 23; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kAmbi2cdOrderACN = (Steinberg_Vst_Speaker) 1 << 20 | (Steinberg_Vst_Speaker) 1 << 21 | (Steinberg_Vst_Speaker) 1 << 22 | (Steinberg_Vst_Speaker) 1 << 23 | (Steinberg_Vst_Speaker) 1 << 38 | (Steinberg_Vst_Speaker) 1 << 39 | (Steinberg_Vst_Speaker) 1 << 40 | (Steinberg_Vst_Speaker) 1 << 41 | (Steinberg_Vst_Speaker) 1 << 42; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kAmbi3rdOrderACN = (Steinberg_Vst_Speaker) 1 << 20 | (Steinberg_Vst_Speaker) 1 << 21 | (Steinberg_Vst_Speaker) 1 << 22 | (Steinberg_Vst_Speaker) 1 << 23 | (Steinberg_Vst_Speaker) 1 << 38 | (Steinberg_Vst_Speaker) 1 << 39 | (Steinberg_Vst_Speaker) 1 << 40 | (Steinberg_Vst_Speaker) 1 << 41 | (Steinberg_Vst_Speaker) 1 << 42 | (Steinberg_Vst_Speaker) 1 << 43 | (Steinberg_Vst_Speaker) 1 << 44 | (Steinberg_Vst_Speaker) 1 << 45 | (Steinberg_Vst_Speaker) 1 << 46 | (Steinberg_Vst_Speaker) 1 << 47 | (Steinberg_Vst_Speaker) 1 << 48 | (Steinberg_Vst_Speaker) 1 << 49; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kAmbi4thOrderACN = (Steinberg_Vst_Speaker) 1 << 20 | (Steinberg_Vst_Speaker) 1 << 21 | (Steinberg_Vst_Speaker) 1 << 22 | (Steinberg_Vst_Speaker) 1 << 23 | (Steinberg_Vst_Speaker) 1 << 38 | (Steinberg_Vst_Speaker) 1 << 39 | (Steinberg_Vst_Speaker) 1 << 40 | (Steinberg_Vst_Speaker) 1 << 41 | (Steinberg_Vst_Speaker) 1 << 42 | (Steinberg_Vst_Speaker) 1 << 43 | (Steinberg_Vst_Speaker) 1 << 44 | (Steinberg_Vst_Speaker) 1 << 45 | (Steinberg_Vst_Speaker) 1 << 46 | (Steinberg_Vst_Speaker) 1 << 47 | (Steinberg_Vst_Speaker) 1 << 48 | (Steinberg_Vst_Speaker) 1 << 49 | (Steinberg_Vst_Speaker) 1 << 50 | (Steinberg_Vst_Speaker) 1 << 51 | (Steinberg_Vst_Speaker) 1 << 52 | (Steinberg_Vst_Speaker) 1 << 53 | (Steinberg_Vst_Speaker) 1 << 54 | (Steinberg_Vst_Speaker) 1 << 55 | (Steinberg_Vst_Speaker) 1 << 56 | (Steinberg_Vst_Speaker) 1 << 57 | (Steinberg_Vst_Speaker) 1 << 58; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kAmbi5thOrderACN = 0x000FFFFFFFFF; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kAmbi6thOrderACN = 0x0001FFFFFFFFFFFF; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_kAmbi7thOrderACN = 0xFFFFFFFFFFFFFFFF; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k80Cube = 1 << 0 | 1 << 1 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k40_4 = 1 << 0 | 1 << 1 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71CineTopCenter = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 8 | 1 << 11; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71CineCenterHigh = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 8 | 1 << 13; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k70CineFrontHigh = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k70MPEG3D = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k50_2 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71CineFrontHigh = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71MPEG3D = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k51_2 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k70CineSideHigh = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k50_2_TS = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71CineSideHigh = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k51_2_TS = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k81MPEG3D = 1 << 0 | 1 << 1 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 13 | 1 << 14 | (Steinberg_Vst_Speaker) 1 << 29; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k41_4_1 = 1 << 0 | 1 << 1 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 13 | 1 << 14 | (Steinberg_Vst_Speaker) 1 << 29; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k90 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k50_4 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k91 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k51_4 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k50_4_1 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 29; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k51_4_1 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 29 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k70_2 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71_2 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k91Atmos = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k70_2_TF = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71_2_TF = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k70_3 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 16; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k72_3 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 16 | 1 << 3 | 1 << 18; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k70_4 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71_4 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k111MPEG3D = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k70_6 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k71_6 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k90_4 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k91_4 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k90_6 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k91_6 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k90_4_W = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | (Steinberg_Vst_Speaker) 1 << 59 | (Steinberg_Vst_Speaker) 1 << 60 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k91_4_W = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | (Steinberg_Vst_Speaker) 1 << 59 | (Steinberg_Vst_Speaker) 1 << 60 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k90_6_W = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | (Steinberg_Vst_Speaker) 1 << 59 | (Steinberg_Vst_Speaker) 1 << 60 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k91_6_W = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | (Steinberg_Vst_Speaker) 1 << 59 | (Steinberg_Vst_Speaker) 1 << 60 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k100 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 11 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k50_5 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 11 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k101 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 11 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k101MPEG3D = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 11 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k51_5 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 11 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k102 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 18; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k52_5 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 18; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k110 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 11 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k50_6 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 11 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k111 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 11 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k51_6 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 11 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k122 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 18; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k72_5 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 18; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k130 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 11 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k131 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 11 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k140 = 1 << 0 | 1 << 1 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 30 | (Steinberg_Vst_Speaker) 1 << 35 | (Steinberg_Vst_Speaker) 1 << 37; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k60_4_4 = 1 << 0 | 1 << 1 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 30 | (Steinberg_Vst_Speaker) 1 << 35 | (Steinberg_Vst_Speaker) 1 << 37; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k220 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 9 | 1 << 10 | 1 << 11 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 16 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 29 | (Steinberg_Vst_Speaker) 1 << 30; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k100_9_3 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 9 | 1 << 10 | 1 << 11 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 16 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 29 | (Steinberg_Vst_Speaker) 1 << 30; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k222 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 9 | 1 << 10 | 1 << 11 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 16 | 1 << 17 | 1 << 18 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 29 | (Steinberg_Vst_Speaker) 1 << 30; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k102_9_3 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 9 | 1 << 10 | 1 << 11 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 16 | 1 << 17 | 1 << 18 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 29 | (Steinberg_Vst_Speaker) 1 << 30; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k50_5_3 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 29 | (Steinberg_Vst_Speaker) 1 << 30; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k51_5_3 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 29 | (Steinberg_Vst_Speaker) 1 << 30 | 1 << 3; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k50_2_2 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 30; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k50_4_2 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 30; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k70_4_2 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 9 | 1 << 10 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 30; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k50_5_Sony = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k40_2_2 = 1 << 2 | 1 << 9 | 1 << 10 | 1 << 8 | (Steinberg_Vst_Speaker) 1 << 24 | (Steinberg_Vst_Speaker) 1 << 25 | (Steinberg_Vst_Speaker) 1 << 33 | (Steinberg_Vst_Speaker) 1 << 34; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k40_4_2 = 1 << 0 | 1 << 1 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 30; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k50_3_2 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 13 | 1 << 14 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 30; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k30_5_2 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 12 | 1 << 13 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 30; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k40_4_4 = 1 << 0 | 1 << 1 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 30 | (Steinberg_Vst_Speaker) 1 << 35 | (Steinberg_Vst_Speaker) 1 << 37; +static const Steinberg_Vst_SpeakerArrangement Steinberg_Vst_SpeakerArr_k50_4_4 = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 4 | 1 << 5 | 1 << 12 | 1 << 14 | 1 << 15 | 1 << 17 | (Steinberg_Vst_Speaker) 1 << 28 | (Steinberg_Vst_Speaker) 1 << 30 | (Steinberg_Vst_Speaker) 1 << 35 | (Steinberg_Vst_Speaker) 1 << 37; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringEmpty = ""; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringMono = "Mono"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereo = "Stereo"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoWide = "Stereo (Lw Rw)"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoR = "Stereo (Ls Rs)"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoC = "Stereo (Lc Rc)"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoSide = "Stereo (Sl Sr)"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoCLfe = "Stereo (C LFE)"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoTF = "Stereo (Tfl Tfr)"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoTS = "Stereo (Tsl Tsr)"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoTR = "Stereo (Trl Trr)"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoBF = "Stereo (Bfl Bfr)"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringCineFront = "Cine Front"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString30Cine = "LRC"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString30Music = "LRS"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString31Cine = "LRC+LFE"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString31Music = "LRS+LFE"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString40Cine = "LRCS"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString40Music = "Quadro"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString41Cine = "LRCS+LFE"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString41Music = "Quadro+LFE"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50 = "5.0"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51 = "5.1"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString60Cine = "6.0 Cine"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString60Music = "6.0 Music"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString61Cine = "6.1 Cine"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString61Music = "6.1 Music"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70Cine = "7.0 SDDS"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70CineOld = "7.0 Cine (SDDS)"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70Music = "7.0"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70MusicOld = "7.0 Music (Dolby)"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71Cine = "7.1 SDDS"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71CineOld = "7.1 Cine (SDDS)"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71Music = "7.1"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71MusicOld = "7.1 Music (Dolby)"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71CineTopCenter = "7.1 Cine Top Center"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71CineCenterHigh = "7.1 Cine Center High"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71CineFullRear = "7.1 Cine Full Rear"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_2 = "5.1.2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_2 = "5.0.2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_2TopSide = "5.0.2 Top Side"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_2TopSide = "5.1.2 Top Side"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71Proximity = "7.1 Proximity"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString80Cine = "8.0 Cine"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString80Music = "8.0 Music"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString40_4 = "8.0 Cube"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString81Cine = "8.1 Cine"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString81Music = "8.1 Music"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString90Cine = "9.0 Cine"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString91Cine = "9.1 Cine"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString100Cine = "10.0 Cine"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString101Cine = "10.1 Cine"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString52_5 = "5.2.5"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString72_5 = "12.2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_4 = "5.0.4"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_4 = "5.1.4"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_4_1 = "5.0.4.1"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_4_1 = "5.1.4.1"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70_2 = "7.0.2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71_2 = "7.1.2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70_2_TF = "7.0.2 Top Front"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71_2_TF = "7.1.2 Top Front"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70_3 = "7.0.3"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString72_3 = "7.2.3"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70_4 = "7.0.4"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71_4 = "7.1.4"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70_6 = "7.0.6"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71_6 = "7.1.6"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString90_4 = "9.0.4 ITU"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString91_4 = "9.1.4 ITU"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString90_6 = "9.0.6 ITU"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString91_6 = "9.1.6 ITU"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString90_4_W = "9.0.4"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString91_4_W = "9.1.4"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString90_6_W = "9.0.6"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString91_6_W = "9.1.6"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_5 = "10.0 Auro-3D"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_5 = "10.1 Auro-3D"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_6 = "11.0 Auro-3D"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_6 = "11.1 Auro-3D"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString130 = "13.0 Auro-3D"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString131 = "13.1 Auro-3D"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString41_4_1 = "8.1 MPEG"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString60_4_4 = "14.0"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString220 = "22.0"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString222 = "22.2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_5_3 = "5.0.5.3"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_5_3 = "5.1.5.3"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_2_2 = "5.0.2.2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_4_2 = "5.0.4.2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70_4_2 = "7.0.4.2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_5_Sony = "5.0.5 Sony"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString40_2_2 = "4.0.3.2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString40_4_2 = "4.0.4.2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_3_2 = "5.0.3.2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString30_5_2 = "3.0.5.2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString40_4_4 = "4.0.4.4"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_4_4 = "5.0.4.4"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi1stOrder = "1OA"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi2cdOrder = "2OA"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi3rdOrder = "3OA"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi4thOrder = "4OA"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi5thOrder = "5OA"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi6thOrder = "6OA"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi7thOrder = "7OA"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringMonoS = "M"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoS = "L R"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoWideS = "Lw Rw"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoRS = "Ls Rs"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoCS = "Lc Rc"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoSS = "Sl Sr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoCLfeS = "C LFE"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoTFS = "Tfl Tfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoTSS = "Tsl Tsr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoTRS = "Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringStereoBFS = "Bfl Bfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringCineFrontS = "L R C Lc Rc"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString30CineS = "L R C"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString30MusicS = "L R S"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString31CineS = "L R C LFE"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString31MusicS = "L R LFE S"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString40CineS = "L R C S"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString40MusicS = "L R Ls Rs"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString41CineS = "L R C LFE S"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString41MusicS = "L R LFE Ls Rs"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50S = "L R C Ls Rs"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51S = "L R C LFE Ls Rs"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString60CineS = "L R C Ls Rs Cs"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString60MusicS = "L R Ls Rs Sl Sr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString61CineS = "L R C LFE Ls Rs Cs"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString61MusicS = "L R LFE Ls Rs Sl Sr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70CineS = "L R C Ls Rs Lc Rc"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70MusicS = "L R C Ls Rs Sl Sr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71CineS = "L R C LFE Ls Rs Lc Rc"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71MusicS = "L R C LFE Ls Rs Sl Sr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString80CineS = "L R C Ls Rs Lc Rc Cs"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString80MusicS = "L R C Ls Rs Cs Sl Sr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString81CineS = "L R C LFE Ls Rs Lc Rc Cs"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString81MusicS = "L R C LFE Ls Rs Cs Sl Sr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString40_4S = "L R Ls Rs Tfl Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71CineTopCenterS = "L R C LFE Ls Rs Cs Tc"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71CineCenterHighS = "L R C LFE Ls Rs Cs Tfc"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71CineFullRearS = "L R C LFE Ls Rs Lcs Rcs"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_2S = "L R C Ls Rs Tfl Tfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_2S = "L R C LFE Ls Rs Tfl Tfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_2TopSideS = "L R C Ls Rs Tsl Tsr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_2TopSideS = "L R C LFE Ls Rs Tsl Tsr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71ProximityS = "L R C LFE Ls Rs Pl Pr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString90CineS = "L R C Ls Rs Lc Rc Sl Sr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString91CineS = "L R C LFE Ls Rs Lc Rc Sl Sr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString100CineS = "L R C Ls Rs Lc Rc Cs Sl Sr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString101CineS = "L R C LFE Ls Rs Lc Rc Cs Sl Sr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_4S = "L R C Ls Rs Tfl Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_4S = "L R C LFE Ls Rs Tfl Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_4_1S = "L R C Ls Rs Tfl Tfr Trl Trr Bfc"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_4_1S = "L R C LFE Ls Rs Tfl Tfr Trl Trr Bfc"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70_2S = "L R C Ls Rs Sl Sr Tsl Tsr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71_2S = "L R C LFE Ls Rs Sl Sr Tsl Tsr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70_2_TFS = "L R C Ls Rs Sl Sr Tfl Tfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71_2_TFS = "L R C LFE Ls Rs Sl Sr Tfl Tfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70_3S = "L R C Ls Rs Sl Sr Tfl Tfr Trc"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString72_3S = "L R C LFE Ls Rs Sl Sr Tfl Tfr Trc LFE2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70_4S = "L R C Ls Rs Sl Sr Tfl Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71_4S = "L R C LFE Ls Rs Sl Sr Tfl Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70_6S = "L R C Ls Rs Sl Sr Tfl Tfr Trl Trr Tsl Tsr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString71_6S = "L R C LFE Ls Rs Sl Sr Tfl Tfr Trl Trr Tsl Tsr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString90_4S = "L R C Ls Rs Lc Rc Sl Sr Tfl Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString91_4S = "L R C LFE Ls Rs Lc Rc Sl Sr Tfl Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString90_6S = "L R C Ls Rs Lc Rc Sl Sr Tfl Tfr Trl Trr Tsl Tsr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString91_6S = "L R C LFE Ls Rs Lc Rc Sl Sr Tfl Tfr Trl Trr Tsl Tsr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString90_4_WS = "L R C Ls Rs Sl Sr Tfl Tfr Trl Trr Lw Rw"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString91_4_WS = "L R C LFE Ls Rs Sl Sr Tfl Tfr Trl Trr Lw Rw"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString90_6_WS = "L R C Ls Rs Sl Sr Tfl Tfr Trl Trr Tsl Tsr Lw Rw"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString91_6_WS = "L R C LFE Ls Rs Sl Sr Tfl Tfr Trl Trr Tsl Tsr Lw Rw"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_5S = "L R C Ls Rs Tc Tfl Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_5S = "L R C LFE Ls Rs Tc Tfl Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_5_SonyS = "L R C Ls Rs Tfl Tfc Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_6S = "L R C Ls Rs Tc Tfl Tfc Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_6S = "L R C LFE Ls Rs Tc Tfl Tfc Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString130S = "L R C Ls Rs Sl Sr Tc Tfl Tfc Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString131S = "L R C LFE Ls Rs Sl Sr Tc Tfl Tfc Tfr Trl Trr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString52_5S = "L R C LFE Ls Rs Tfl Tfc Tfr Trl Trr LFE2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString72_5S = "L R C LFE Ls Rs Lc Rc Tfl Tfc Tfr Trl Trr LFE2"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString41_4_1S = "L R LFE Ls Rs Tfl Tfc Tfr Bfc"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString30_5_2S = "L R C Tfl Tfc Tfr Trl Trr Bfl Bfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString40_2_2S = "C Sl Sr Cs Tfc Tsl Tsr Trc"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString40_4_2S = "L R Ls Rs Tfl Tfr Trl Trr Bfl Bfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString40_4_4S = "L R Ls Rs Tfl Tfr Trl Trr Bfl Bfr Brl Brr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_4_4S = "L R C Ls Rs Tfl Tfr Trl Trr Bfl Bfr Brl Brr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString60_4_4S = "L R Ls Rs Sl Sr Tfl Tfr Trl Trr Bfl Bfr Brl Brr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_5_3S = "L R C Ls Rs Tfl Tfc Tfr Trl Trr Bfl Bfc Bfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString51_5_3S = "L R C LFE Ls Rs Tfl Tfc Tfr Trl Trr Bfl Bfc Bfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_2_2S = "L R C Ls Rs Tsl Tsr Bfl Bfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_3_2S = "L R C Ls Rs Tfl Tfc Tfr Bfl Bfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString50_4_2S = "L R C Ls Rs Tfl Tfr Trl Trr Bfl Bfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString70_4_2S = "L R C Ls Rs Sl Sr Tfl Tfr Trl Trr Bfl Bfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_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"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kString220S = "L R C Ls Rs Lc Rc Cs Sl Sr Tc Tfl Tfc Tfr Trl Trc Trr Tsl Tsr Bfl Bfc Bfr"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi1stOrderS = "0 1 2 3"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi2cdOrderS = "0 1 2 3 4 5 6 7 8"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi3rdOrderS = "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi4thOrderS = "0..24"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi5thOrderS = "0..35"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi6thOrderS = "0..48"; +static const Steinberg_Vst_CString Steinberg_Vst_SpeakerArr_kStringAmbi7thOrderS = "0..63"; +static const Steinberg_Vst_CString Steinberg_Vst_CurveType_kSegment = "segment"; +static const Steinberg_Vst_CString Steinberg_Vst_CurveType_kValueList = "valueList"; +static const Steinberg_Vst_CString Steinberg_Vst_Attributes_kStyle = "style"; +static const Steinberg_Vst_CString Steinberg_Vst_Attributes_kLEDStyle = "ledStyle"; +static const Steinberg_Vst_CString Steinberg_Vst_Attributes_kSwitchStyle = "switchStyle"; +static const Steinberg_Vst_CString Steinberg_Vst_Attributes_kKnobTurnsPerFullRange = "turnsPerFullRange"; +static const Steinberg_Vst_CString Steinberg_Vst_Attributes_kFunction = "function"; +static const Steinberg_Vst_CString Steinberg_Vst_Attributes_kFlags = "flags"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kPanPosCenterXFunc = "PanPosCenterX"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kPanPosCenterYFunc = "PanPosCenterY"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kPanPosFrontLeftXFunc = "PanPosFrontLeftX"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kPanPosFrontLeftYFunc = "PanPosFrontLeftY"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kPanPosFrontRightXFunc = "PanPosFrontRightX"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kPanPosFrontRightYFunc = "PanPosFrontRightY"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kPanRotationFunc = "PanRotation"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kPanLawFunc = "PanLaw"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kPanMirrorModeFunc = "PanMirrorMode"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kPanLfeGainFunc = "PanLfeGain"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kGainReductionFunc = "GainReduction"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kSoloFunc = "Solo"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kMuteFunc = "Mute"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFunction_kVolumeFunc = "Volume"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesStyle_kInverseStyle = "inverse"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesStyle_kLEDWrapLeftStyle = "wrapLeft"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesStyle_kLEDWrapRightStyle = "wrapRight"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesStyle_kLEDSpreadStyle = "spread"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesStyle_kLEDBoostCutStyle = "boostCut"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesStyle_kLEDSingleDotStyle = "singleDot"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesStyle_kSwitchPushStyle = "push"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesStyle_kSwitchPushIncLoopedStyle = "pushIncLooped"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesStyle_kSwitchPushDecLoopedStyle = "pushDecLooped"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesStyle_kSwitchPushIncStyle = "pushInc"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesStyle_kSwitchPushDecStyle = "pushDec"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesStyle_kSwitchLatchStyle = "latch"; +static const Steinberg_Vst_CString Steinberg_Vst_AttributesFlags_kHideableFlag = "hideable"; +static const Steinberg_Vst_CString Steinberg_Vst_ChannelContext_kChannelUIDKey = "channel uid"; +static const Steinberg_Vst_CString Steinberg_Vst_ChannelContext_kChannelUIDLengthKey = "channel uid length"; +static const Steinberg_Vst_CString Steinberg_Vst_ChannelContext_kChannelRuntimeIDKey = "channel runtime id"; +static const Steinberg_Vst_CString Steinberg_Vst_ChannelContext_kChannelNameKey = "channel name"; +static const Steinberg_Vst_CString Steinberg_Vst_ChannelContext_kChannelNameLengthKey = "channel name length"; +static const Steinberg_Vst_CString Steinberg_Vst_ChannelContext_kChannelColorKey = "channel color"; +static const Steinberg_Vst_CString Steinberg_Vst_ChannelContext_kChannelIndexKey = "channel index"; +static const Steinberg_Vst_CString Steinberg_Vst_ChannelContext_kChannelIndexNamespaceOrderKey = "channel index namespace order"; +static const Steinberg_Vst_CString Steinberg_Vst_ChannelContext_kChannelIndexNamespaceKey = "channel index namespace"; +static const Steinberg_Vst_CString Steinberg_Vst_ChannelContext_kChannelIndexNamespaceLengthKey = "channel index namespace length"; +static const Steinberg_Vst_CString Steinberg_Vst_ChannelContext_kChannelImageKey = "channel image"; +static const Steinberg_Vst_CString Steinberg_Vst_ChannelContext_kChannelPluginLocationKey = "channel plugin location"; +static const Steinberg_Vst_DataExchangeQueueID Steinberg_Vst_InvalidDataExchangeQueueID = INT32_MAX; +static const Steinberg_Vst_DataExchangeBlockID Steinberg_Vst_InvalidDataExchangeBlockID = INT32_MAX; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFx = "Fx"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxAnalyzer = "Fx|Analyzer"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxBass = "Fx|Bass"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxChannelStrip = "Fx|Channel Strip"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxDelay = "Fx|Delay"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxDistortion = "Fx|Distortion"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxDrums = "Fx|Drums"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxDynamics = "Fx|Dynamics"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxEQ = "Fx|EQ"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxFilter = "Fx|Filter"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxGenerator = "Fx|Generator"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxGuitar = "Fx|Guitar"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxInstrument = "Fx|Instrument"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxInstrumentExternal = "Fx|Instrument|External"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxMastering = "Fx|Mastering"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxMicrophone = "Fx|Microphone"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxModulation = "Fx|Modulation"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxNetwork = "Fx|Network"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxPitchShift = "Fx|Pitch Shift"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxRestoration = "Fx|Restoration"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxReverb = "Fx|Reverb"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxSpatial = "Fx|Spatial"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxSurround = "Fx|Surround"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxTools = "Fx|Tools"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kFxVocals = "Fx|Vocals"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kInstrument = "Instrument"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kInstrumentDrum = "Instrument|Drum"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kInstrumentExternal = "Instrument|External"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kInstrumentPiano = "Instrument|Piano"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kInstrumentSampler = "Instrument|Sampler"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kInstrumentSynth = "Instrument|Synth"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kInstrumentSynthSampler = "Instrument|Synth|Sampler"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kAmbisonics = "Ambisonics"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kAnalyzer = "Analyzer"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kNoOfflineProcess = "NoOfflineProcess"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kOnlyARA = "OnlyARA"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kOnlyOfflineProcess = "OnlyOfflineProcess"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kOnlyRealTime = "OnlyRT"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kSpatial = "Spatial"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kSpatialFx = "Spatial|Fx"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kUpDownMix = "Up-Downmix"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kMono = "Mono"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kStereo = "Stereo"; +static const Steinberg_Vst_CString Steinberg_Vst_PlugType_kSurround = "Surround"; +static const Steinberg_uint32 Steinberg_Vst_kNoTail = 0; +static const Steinberg_uint32 Steinberg_Vst_kInfiniteTail = UINT32_MAX; +static const Steinberg_Vst_UnitID Steinberg_Vst_kRootUnitId = 0; +static const Steinberg_Vst_UnitID Steinberg_Vst_kNoParentUnitId = -1; +static const Steinberg_Vst_ProgramListID Steinberg_Vst_kNoProgramListId = -1; +static const Steinberg_int32 Steinberg_Vst_kAllProgramInvalid = -1; +static const Steinberg_Vst_CString Steinberg_Vst_FunctionNameType_kCompGainReduction = "Comp:GainReduction"; +static const Steinberg_Vst_CString Steinberg_Vst_FunctionNameType_kCompGainReductionMax = "Comp:GainReductionMax"; +static const Steinberg_Vst_CString Steinberg_Vst_FunctionNameType_kCompGainReductionPeakHold = "Comp:GainReductionPeakHold"; +static const Steinberg_Vst_CString Steinberg_Vst_FunctionNameType_kCompResetGainReductionMax = "Comp:ResetGainReductionMax"; +static const Steinberg_Vst_CString Steinberg_Vst_FunctionNameType_kLowLatencyMode = "LowLatencyMode"; +static const Steinberg_Vst_CString Steinberg_Vst_FunctionNameType_kDryWetMix = "DryWetMix"; +static const Steinberg_Vst_CString Steinberg_Vst_FunctionNameType_kRandomize = "Randomize"; +static const Steinberg_Vst_CString Steinberg_Vst_FunctionNameType_kRandomizeAroundCurrent = "RandomizeAroundCurrent"; +static const Steinberg_Vst_CString Steinberg_Vst_FunctionNameType_kPanPosCenterX = "PanPosCenterX"; +static const Steinberg_Vst_CString Steinberg_Vst_FunctionNameType_kPanPosCenterY = "PanPosCenterY"; +static const Steinberg_Vst_CString Steinberg_Vst_FunctionNameType_kPanPosCenterZ = "PanPosCenterZ"; + + +/*---------------------------------------------------------------------------------------------------------------------- +----- Structs ---------------------------------------------------------------------------------------------------------- +----------------------------------------------------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/gui/iplugview.h", line 34 */ + +struct Steinberg_ViewRect +{ + Steinberg_int32 left; + Steinberg_int32 top; + Steinberg_int32 right; + Steinberg_int32 bottom; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteexpression.h", line 102 */ + +struct Steinberg_Vst_NoteExpressionValueDescription +{ + Steinberg_Vst_NoteExpressionValue defaultValue; + Steinberg_Vst_NoteExpressionValue minimum; + Steinberg_Vst_NoteExpressionValue maximum; + Steinberg_int32 stepCount; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteexpression.h", line 123 */ + +struct Steinberg_Vst_NoteExpressionValueEvent +{ + Steinberg_Vst_NoteExpressionTypeID typeId; + Steinberg_int32 noteId; + Steinberg_Vst_NoteExpressionValue value; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteexpression.h", line 137 */ + +struct Steinberg_Vst_NoteExpressionIntValueEvent +{ + Steinberg_Vst_NoteExpressionTypeID typeId; + Steinberg_int32 noteId; + Steinberg_uint64 value; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteexpression.h", line 151 */ + +struct Steinberg_Vst_NoteExpressionTextEvent +{ + Steinberg_Vst_NoteExpressionTypeID typeId; + Steinberg_int32 noteId; + Steinberg_uint32 textLen; + const Steinberg_Vst_TChar* text; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteexpression.h", line 171 */ + +struct Steinberg_Vst_NoteExpressionTypeInfo +{ + Steinberg_Vst_NoteExpressionTypeID typeId; + Steinberg_Vst_String128 title; + Steinberg_Vst_String128 shortTitle; + Steinberg_Vst_String128 units; + Steinberg_int32 unitId; + struct Steinberg_Vst_NoteExpressionValueDescription valueDesc; + Steinberg_Vst_ParamID associatedParameterId; + Steinberg_int32 flags; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteexpression.h", line 265 */ + +struct Steinberg_Vst_KeyswitchInfo +{ + Steinberg_Vst_KeyswitchTypeID typeId; + Steinberg_Vst_String128 title; + Steinberg_Vst_String128 shortTitle; + Steinberg_int32 keyswitchMin; + Steinberg_int32 keyswitchMax; + Steinberg_int32 keyRemapped; + Steinberg_int32 unitId; + Steinberg_int32 flags; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstphysicalui.h", line 60 */ + +struct Steinberg_Vst_PhysicalUIMap +{ + Steinberg_Vst_PhysicalUITypeID physicalUITypeID; + Steinberg_Vst_NoteExpressionTypeID noteExpressionTypeID; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstphysicalui.h", line 76 */ + +struct Steinberg_Vst_PhysicalUIMapList +{ + Steinberg_uint32 count; + struct Steinberg_Vst_PhysicalUIMap* map; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/ipluginbase.h", line 62 */ + +struct Steinberg_PFactoryInfo +{ + Steinberg_char8 vendor[64]; + Steinberg_char8 url[256]; + Steinberg_char8 email[128]; + Steinberg_int32 flags; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/ipluginbase.h", line 124 */ + +struct Steinberg_PClassInfo +{ + Steinberg_TUID cid; + Steinberg_int32 cardinality; + Steinberg_char8 category[32]; + Steinberg_char8 name[64]; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/ipluginbase.h", line 222 */ + +struct Steinberg_PClassInfo2 +{ + Steinberg_TUID cid; + Steinberg_int32 cardinality; + Steinberg_char8 category[32]; + Steinberg_char8 name[64]; + Steinberg_uint32 classFlags; + Steinberg_char8 subCategories[128]; + Steinberg_char8 vendor[64]; + Steinberg_char8 version[64]; + Steinberg_char8 sdkVersion[64]; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/ipluginbase.h", line 337 */ + +struct Steinberg_PClassInfoW +{ + Steinberg_TUID cid; + Steinberg_int32 cardinality; + Steinberg_char8 category[32]; + Steinberg_char16 name[64]; + Steinberg_uint32 classFlags; + Steinberg_char8 subCategories[128]; + Steinberg_char16 vendor[64]; + Steinberg_char16 version[64]; + Steinberg_char16 sdkVersion[64]; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstcomponent.h", line 93 */ + +struct Steinberg_Vst_BusInfo +{ + Steinberg_Vst_MediaType mediaType; + Steinberg_Vst_BusDirection direction; + Steinberg_int32 channelCount; + Steinberg_Vst_String128 name; + Steinberg_Vst_BusType busType; + Steinberg_uint32 flags; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstcomponent.h", line 136 */ + +struct Steinberg_Vst_RoutingInfo +{ + Steinberg_Vst_MediaType mediaType; + Steinberg_int32 busIndex; + Steinberg_int32 channel; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 46 */ + +struct Steinberg_Vst_ParameterInfo +{ + Steinberg_Vst_ParamID id; + Steinberg_Vst_String128 title; + Steinberg_Vst_String128 shortTitle; + Steinberg_Vst_String128 units; + Steinberg_int32 stepCount; + Steinberg_Vst_ParamValue defaultNormalizedValue; + Steinberg_Vst_UnitID unitId; + Steinberg_int32 flags; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstprocesscontext.h", line 44 */ + +struct Steinberg_Vst_FrameRate +{ + Steinberg_uint32 framesPerSecond; + Steinberg_uint32 flags; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstprocesscontext.h", line 64 */ + +struct Steinberg_Vst_Chord +{ + Steinberg_uint8 keyNote; + Steinberg_uint8 rootNote; + Steinberg_int16 chordMask; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstprocesscontext.h", line 96 */ + +struct Steinberg_Vst_ProcessContext +{ + Steinberg_uint32 state; + double sampleRate; + Steinberg_Vst_TSamples projectTimeSamples; + Steinberg_int64 systemTime; + Steinberg_Vst_TSamples continousTimeSamples; + Steinberg_Vst_TQuarterNotes projectTimeMusic; + Steinberg_Vst_TQuarterNotes barPositionMusic; + Steinberg_Vst_TQuarterNotes cycleStartMusic; + Steinberg_Vst_TQuarterNotes cycleEndMusic; + double tempo; + Steinberg_int32 timeSigNumerator; + Steinberg_int32 timeSigDenominator; + struct Steinberg_Vst_Chord chord; + Steinberg_int32 smpteOffsetSubframes; + struct Steinberg_Vst_FrameRate frameRate; + Steinberg_int32 samplesToNextClock; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstevents.h", line 43 */ + +struct Steinberg_Vst_NoteOnEvent +{ + Steinberg_int16 channel; + Steinberg_int16 pitch; + float tuning; + float velocity; + Steinberg_int32 length; + Steinberg_int32 noteId; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstevents.h", line 57 */ + +struct Steinberg_Vst_NoteOffEvent +{ + Steinberg_int16 channel; + Steinberg_int16 pitch; + float velocity; + Steinberg_int32 noteId; + float tuning; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstevents.h", line 70 */ + +struct Steinberg_Vst_DataEvent +{ + Steinberg_uint32 size; + Steinberg_uint32 type; + const Steinberg_uint8* bytes; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstevents.h", line 87 */ + +struct Steinberg_Vst_PolyPressureEvent +{ + Steinberg_int16 channel; + Steinberg_int16 pitch; + float pressure; + Steinberg_int32 noteId; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstevents.h", line 99 */ + +struct Steinberg_Vst_ChordEvent +{ + Steinberg_int16 root; + Steinberg_int16 bassNote; + Steinberg_int16 mask; + Steinberg_uint16 textLen; + const Steinberg_Vst_TChar* text; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstevents.h", line 113 */ + +struct Steinberg_Vst_ScaleEvent +{ + Steinberg_int16 root; + Steinberg_int16 mask; + Steinberg_uint16 textLen; + const Steinberg_Vst_TChar* text; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstevents.h", line 129 */ + +struct Steinberg_Vst_LegacyMIDICCOutEvent +{ + Steinberg_uint8 controlNumber; + Steinberg_int8 channel; + Steinberg_int8 value; + Steinberg_int8 value2; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstevents.h", line 142 */ + +struct Steinberg_Vst_Event +{ + Steinberg_int32 busIndex; + Steinberg_int32 sampleOffset; + Steinberg_Vst_TQuarterNotes ppqPosition; + Steinberg_uint16 flags; + Steinberg_uint16 type; + union + { + struct Steinberg_Vst_NoteOnEvent Steinberg_Vst_Event_noteOn; + struct Steinberg_Vst_NoteOffEvent Steinberg_Vst_Event_noteOff; + struct Steinberg_Vst_DataEvent Steinberg_Vst_Event_data; + struct Steinberg_Vst_PolyPressureEvent Steinberg_Vst_Event_polyPressure; + struct Steinberg_Vst_NoteExpressionValueEvent Steinberg_Vst_Event_noteExpressionValue; + struct Steinberg_Vst_NoteExpressionTextEvent Steinberg_Vst_Event_noteExpressionText; + struct Steinberg_Vst_NoteExpressionIntValueEvent Steinberg_Vst_Event_noteExpressionIntValue; + struct Steinberg_Vst_ChordEvent Steinberg_Vst_Event_chord; + struct Steinberg_Vst_ScaleEvent Steinberg_Vst_Event_scale; + struct Steinberg_Vst_LegacyMIDICCOutEvent Steinberg_Vst_Event_midiCCOut; + }; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstrepresentation.h", line 37 */ + +struct Steinberg_Vst_RepresentationInfo +{ + Steinberg_char8 vendor[64]; + Steinberg_char8 name[64]; + Steinberg_char8 version[64]; + Steinberg_char8 host[64]; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstcontextmenu.h", line 168 */ + +struct Steinberg_Vst_IContextMenuItem +{ + Steinberg_Vst_String128 name; + Steinberg_int32 tag; + Steinberg_int32 flags; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstdataexchange.h", line 45 */ + +struct Steinberg_Vst_DataExchangeBlock +{ + void* data; + Steinberg_uint32 size; + Steinberg_Vst_DataExchangeBlockID blockID; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstaudioprocessor.h", line 174 */ + +struct Steinberg_Vst_ProcessSetup +{ + Steinberg_int32 processMode; + Steinberg_int32 symbolicSampleSize; + Steinberg_int32 maxSamplesPerBlock; + Steinberg_Vst_SampleRate sampleRate; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstaudioprocessor.h", line 202 */ + +struct Steinberg_Vst_AudioBusBuffers +{ + Steinberg_int32 numChannels; + Steinberg_uint64 silenceFlags; + union + { + Steinberg_Vst_Sample32** Steinberg_Vst_AudioBusBuffers_channelBuffers32; + Steinberg_Vst_Sample64** Steinberg_Vst_AudioBusBuffers_channelBuffers64; + }; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstaudioprocessor.h", line 224 */ + +struct Steinberg_Vst_ProcessData +{ + Steinberg_int32 processMode; + Steinberg_int32 symbolicSampleSize; + Steinberg_int32 numSamples; + Steinberg_int32 numInputs; + Steinberg_int32 numOutputs; + struct Steinberg_Vst_AudioBusBuffers* inputs; + struct Steinberg_Vst_AudioBusBuffers* outputs; + struct Steinberg_Vst_IParameterChanges* inputParameterChanges; + struct Steinberg_Vst_IParameterChanges* outputParameterChanges; + struct Steinberg_Vst_IEventList* inputEvents; + struct Steinberg_Vst_IEventList* outputEvents; + struct Steinberg_Vst_ProcessContext* processContext; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstmidimapping2.h", line 41 */ + +struct Steinberg_Vst_Midi2Controller +{ + Steinberg_uint8 byte1; + Steinberg_uint8 byte2; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstmidimapping2.h", line 81 */ + +struct Steinberg_Vst_Midi2ControllerParamIDAssignment +{ + Steinberg_Vst_ParamID pId; + Steinberg_Vst_BusIndex busIndex; + Steinberg_Vst_MidiChannel channel; + struct Steinberg_Vst_Midi2Controller controller; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstmidimapping2.h", line 90 */ + +struct Steinberg_Vst_Midi2ControllerParamIDAssignmentList +{ + Steinberg_uint32 count; + struct Steinberg_Vst_Midi2ControllerParamIDAssignment* map; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstmidimapping2.h", line 97 */ + +struct Steinberg_Vst_Midi1ControllerParamIDAssignment +{ + Steinberg_Vst_ParamID pId; + Steinberg_Vst_BusIndex busIndex; + Steinberg_Vst_MidiChannel channel; + Steinberg_Vst_CtrlNumber controller; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstmidimapping2.h", line 106 */ + +struct Steinberg_Vst_Midi1ControllerParamIDAssignmentList +{ + Steinberg_uint32 count; + struct Steinberg_Vst_Midi1ControllerParamIDAssignment* map; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteonorchestralarticulationinfo.h", line 33 */ + +struct Steinberg_Vst_NoteOnOrchestralArticulation_Variations +{ + Steinberg_uint8 variation[16]; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteonorchestralarticulationinfo.h", line 43 */ + +struct Steinberg_Vst_NoteOnOrchestralArticulation_ClassificationVariations +{ + struct Steinberg_Vst_NoteOnOrchestralArticulation_Variations classification[17]; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsttransportcontrol.h", line 51 */ + +struct Steinberg_Vst_TransportPosition +{ + Steinberg_Vst_TransportPositionType type; + union + { + Steinberg_Vst_TSamples Steinberg_Vst_TransportPosition_samples; + Steinberg_Vst_TQuarterNotes Steinberg_Vst_TransportPosition_quarterNotes; + }; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstunits.h", line 44 */ + +struct Steinberg_Vst_UnitInfo +{ + Steinberg_Vst_UnitID id; + Steinberg_Vst_UnitID parentUnitId; + Steinberg_Vst_String128 name; + Steinberg_Vst_ProgramListID programListId; +}; + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstunits.h", line 56 */ + +struct Steinberg_Vst_ProgramListInfo +{ + Steinberg_Vst_ProgramListID id; + Steinberg_Vst_String128 name; + Steinberg_int32 programCount; +}; + + +/*---------------------------------------------------------------------------------------------------------------------- +----- Interfaces ------------------------------------------------------------------------------------------------------- +----------------------------------------------------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/funknown.h", line 374 */ + +typedef struct Steinberg_FUnknownVtbl +{ + /* methods defined in "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + +} Steinberg_FUnknownVtbl; + +typedef struct Steinberg_FUnknown +{ + struct Steinberg_FUnknownVtbl* lpVtbl; +} Steinberg_FUnknown; + +static const Steinberg_TUID Steinberg_FUnknown_iid = SMTG_INLINE_UID (0x00000000, 0x00000000, 0xC0000000, 0x00000046); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/gui/iplugviewcontentscalesupport.h", line 57 */ + +typedef struct Steinberg_IPlugViewContentScaleSupportVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_IPlugViewContentScaleSupport": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setContentScaleFactor) (void* thisInterface, Steinberg_IPlugViewContentScaleSupport_ScaleFactor factor); + +} Steinberg_IPlugViewContentScaleSupportVtbl; + +typedef struct Steinberg_IPlugViewContentScaleSupport +{ + struct Steinberg_IPlugViewContentScaleSupportVtbl* lpVtbl; +} Steinberg_IPlugViewContentScaleSupport; + +static const Steinberg_TUID Steinberg_IPlugViewContentScaleSupport_iid = SMTG_INLINE_UID (0x65ED9690, 0x8AC44525, 0x8AADEF7A, 0x72EA703F); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/gui/iplugview.h", line 134 */ + +typedef struct Steinberg_IPlugViewVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_IPlugView": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* isPlatformTypeSupported) (void* thisInterface, Steinberg_FIDString type); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* attached) (void* thisInterface, void* parent, Steinberg_FIDString type); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* removed) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* onWheel) (void* thisInterface, float distance); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* onKeyDown) (void* thisInterface, Steinberg_char16 key, Steinberg_int16 keyCode, Steinberg_int16 modifiers); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* onKeyUp) (void* thisInterface, Steinberg_char16 key, Steinberg_int16 keyCode, Steinberg_int16 modifiers); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getSize) (void* thisInterface, struct Steinberg_ViewRect* size); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* onSize) (void* thisInterface, struct Steinberg_ViewRect* newSize); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* onFocus) (void* thisInterface, Steinberg_TBool state); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setFrame) (void* thisInterface, struct Steinberg_IPlugFrame* frame); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* canResize) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* checkSizeConstraint) (void* thisInterface, struct Steinberg_ViewRect* rect); + +} Steinberg_IPlugViewVtbl; + +typedef struct Steinberg_IPlugView +{ + struct Steinberg_IPlugViewVtbl* lpVtbl; +} Steinberg_IPlugView; + +static const Steinberg_TUID Steinberg_IPlugView_iid = SMTG_INLINE_UID (0x5BC32507, 0xD06049EA, 0xA6151B52, 0x2B755B29); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/gui/iplugview.h", line 208 */ + +typedef struct Steinberg_IPlugFrameVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_IPlugFrame": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* resizeView) (void* thisInterface, struct Steinberg_IPlugView* view, struct Steinberg_ViewRect* newSize); + +} Steinberg_IPlugFrameVtbl; + +typedef struct Steinberg_IPlugFrame +{ + struct Steinberg_IPlugFrameVtbl* lpVtbl; +} Steinberg_IPlugFrame; + +static const Steinberg_TUID Steinberg_IPlugFrame_iid = SMTG_INLINE_UID (0x367FAF01, 0xAFA94693, 0x8D4DA2A0, 0xED0882A3); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/gui/iplugview.h", line 234 */ + +typedef struct Steinberg_Linux_IEventHandlerVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Linux_IEventHandler": */ + void (SMTG_STDMETHODCALLTYPE* onFDIsSet) (void* thisInterface, Steinberg_Linux_FileDescriptor fd); + +} Steinberg_Linux_IEventHandlerVtbl; + +typedef struct Steinberg_Linux_IEventHandler +{ + struct Steinberg_Linux_IEventHandlerVtbl* lpVtbl; +} Steinberg_Linux_IEventHandler; + +static const Steinberg_TUID Steinberg_Linux_IEventHandler_iid = SMTG_INLINE_UID (0x561E65C9, 0x13A0496F, 0x813A2C35, 0x654D7983); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/gui/iplugview.h", line 250 */ + +typedef struct Steinberg_Linux_ITimerHandlerVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Linux_ITimerHandler": */ + void (SMTG_STDMETHODCALLTYPE* onTimer) (void* thisInterface); + +} Steinberg_Linux_ITimerHandlerVtbl; + +typedef struct Steinberg_Linux_ITimerHandler +{ + struct Steinberg_Linux_ITimerHandlerVtbl* lpVtbl; +} Steinberg_Linux_ITimerHandler; + +static const Steinberg_TUID Steinberg_Linux_ITimerHandler_iid = SMTG_INLINE_UID (0x10BDD94F, 0x41424774, 0x821FAD8F, 0xECA72CA9); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/gui/iplugview.h", line 278 */ + +typedef struct Steinberg_Linux_IRunLoopVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Linux_IRunLoop": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* registerEventHandler) (void* thisInterface, struct Steinberg_Linux_IEventHandler* handler, Steinberg_Linux_FileDescriptor fd); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* unregisterEventHandler) (void* thisInterface, struct Steinberg_Linux_IEventHandler* handler); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* registerTimer) (void* thisInterface, struct Steinberg_Linux_ITimerHandler* handler, Steinberg_Linux_TimerInterval milliseconds); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* unregisterTimer) (void* thisInterface, struct Steinberg_Linux_ITimerHandler* handler); + +} Steinberg_Linux_IRunLoopVtbl; + +typedef struct Steinberg_Linux_IRunLoop +{ + struct Steinberg_Linux_IRunLoopVtbl* lpVtbl; +} Steinberg_Linux_IRunLoop; + +static const Steinberg_TUID Steinberg_Linux_IRunLoop_iid = SMTG_INLINE_UID (0x18C35366, 0x97764F1A, 0x9C5B8385, 0x7A871389); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/ibstream.h", line 29 */ + +typedef struct Steinberg_IBStreamVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_IBStream": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* read) (void* thisInterface, void* buffer, Steinberg_int32 numBytes, Steinberg_int32* numBytesRead); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* write) (void* thisInterface, void* buffer, Steinberg_int32 numBytes, Steinberg_int32* numBytesWritten); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* seek) (void* thisInterface, Steinberg_int64 pos, Steinberg_int32 mode, Steinberg_int64* result); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* tell) (void* thisInterface, Steinberg_int64* pos); + +} Steinberg_IBStreamVtbl; + +typedef struct Steinberg_IBStream +{ + struct Steinberg_IBStreamVtbl* lpVtbl; +} Steinberg_IBStream; + +static const Steinberg_TUID Steinberg_IBStream_iid = SMTG_INLINE_UID (0xC3BF6EA2, 0x30994752, 0x9B6BF990, 0x1EE33E9B); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/ibstream.h", line 72 */ + +typedef struct Steinberg_ISizeableStreamVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_ISizeableStream": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getStreamSize) (void* thisInterface, Steinberg_int64* size); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setStreamSize) (void* thisInterface, Steinberg_int64 size); + +} Steinberg_ISizeableStreamVtbl; + +typedef struct Steinberg_ISizeableStream +{ + struct Steinberg_ISizeableStreamVtbl* lpVtbl; +} Steinberg_ISizeableStream; + +static const Steinberg_TUID Steinberg_ISizeableStream_iid = SMTG_INLINE_UID (0x04F9549E, 0xE02F4E6E, 0x87E86A87, 0x47F4E17F); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteexpression.h", line 212 */ + +typedef struct Steinberg_Vst_INoteExpressionControllerVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_INoteExpressionController": */ + Steinberg_int32 (SMTG_STDMETHODCALLTYPE* getNoteExpressionCount) (void* thisInterface, Steinberg_int32 busIndex, Steinberg_int16 channel); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getNoteExpressionInfo) (void* thisInterface, Steinberg_int32 busIndex, Steinberg_int16 channel, Steinberg_int32 noteExpressionIndex, struct Steinberg_Vst_NoteExpressionTypeInfo* info); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getNoteExpressionStringByValue) (void* thisInterface, Steinberg_int32 busIndex, Steinberg_int16 channel, Steinberg_Vst_NoteExpressionTypeID id, Steinberg_Vst_NoteExpressionValue valueNormalized, Steinberg_Vst_String128 string); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getNoteExpressionValueByString) (void* thisInterface, Steinberg_int32 busIndex, Steinberg_int16 channel, Steinberg_Vst_NoteExpressionTypeID id, const Steinberg_Vst_TChar* string, Steinberg_Vst_NoteExpressionValue* valueNormalized); + +} Steinberg_Vst_INoteExpressionControllerVtbl; + +typedef struct Steinberg_Vst_INoteExpressionController +{ + struct Steinberg_Vst_INoteExpressionControllerVtbl* lpVtbl; +} Steinberg_Vst_INoteExpressionController; + +static const Steinberg_TUID Steinberg_Vst_INoteExpressionController_iid = SMTG_INLINE_UID (0xB7F8F859, 0x41234872, 0x91169581, 0x4F3721A3); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteexpression.h", line 294 */ + +typedef struct Steinberg_Vst_IKeyswitchControllerVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IKeyswitchController": */ + Steinberg_int32 (SMTG_STDMETHODCALLTYPE* getKeyswitchCount) (void* thisInterface, Steinberg_int32 busIndex, Steinberg_int16 channel); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getKeyswitchInfo) (void* thisInterface, Steinberg_int32 busIndex, Steinberg_int16 channel, Steinberg_int32 keySwitchIndex, struct Steinberg_Vst_KeyswitchInfo* info); + +} Steinberg_Vst_IKeyswitchControllerVtbl; + +typedef struct Steinberg_Vst_IKeyswitchController +{ + struct Steinberg_Vst_IKeyswitchControllerVtbl* lpVtbl; +} Steinberg_Vst_IKeyswitchController; + +static const Steinberg_TUID Steinberg_Vst_IKeyswitchController_iid = SMTG_INLINE_UID (0x1F2F76D3, 0xBFFB4B96, 0xB99527A5, 0x5EBCCEF4); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstphysicalui.h", line 148 */ + +typedef struct Steinberg_Vst_INoteExpressionPhysicalUIMappingVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_INoteExpressionPhysicalUIMapping": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getPhysicalUIMapping) (void* thisInterface, Steinberg_int32 busIndex, Steinberg_int16 channel, struct Steinberg_Vst_PhysicalUIMapList* list); + +} Steinberg_Vst_INoteExpressionPhysicalUIMappingVtbl; + +typedef struct Steinberg_Vst_INoteExpressionPhysicalUIMapping +{ + struct Steinberg_Vst_INoteExpressionPhysicalUIMappingVtbl* lpVtbl; +} Steinberg_Vst_INoteExpressionPhysicalUIMapping; + +static const Steinberg_TUID Steinberg_Vst_INoteExpressionPhysicalUIMapping_iid = SMTG_INLINE_UID (0xB03078FF, 0x94D24AC8, 0x90CCD303, 0xD4133324); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/ipluginbase.h", line 36 */ + +typedef struct Steinberg_IPluginBaseVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_IPluginBase": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* initialize) (void* thisInterface, struct Steinberg_FUnknown* context); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* terminate) (void* thisInterface); + +} Steinberg_IPluginBaseVtbl; + +typedef struct Steinberg_IPluginBase +{ + struct Steinberg_IPluginBaseVtbl* lpVtbl; +} Steinberg_IPluginBase; + +static const Steinberg_TUID Steinberg_IPluginBase_iid = SMTG_INLINE_UID (0x22888DDB, 0x156E45AE, 0x8358B348, 0x08190625); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/ipluginbase.h", line 192 */ + +typedef struct Steinberg_IPluginFactoryVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_IPluginFactory": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getFactoryInfo) (void* thisInterface, struct Steinberg_PFactoryInfo* info); + Steinberg_int32 (SMTG_STDMETHODCALLTYPE* countClasses) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getClassInfo) (void* thisInterface, Steinberg_int32 index, struct Steinberg_PClassInfo* info); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* createInstance) (void* thisInterface, Steinberg_FIDString cid, Steinberg_FIDString iid, void** obj); + +} Steinberg_IPluginFactoryVtbl; + +typedef struct Steinberg_IPluginFactory +{ + struct Steinberg_IPluginFactoryVtbl* lpVtbl; +} Steinberg_IPluginFactory; + +static const Steinberg_TUID Steinberg_IPluginFactory_iid = SMTG_INLINE_UID (0x7A4D811C, 0x52114A1F, 0xAED9D2EE, 0x0B43BF9F); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/ipluginbase.h", line 321 */ + +typedef struct Steinberg_IPluginFactory2Vtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods derived from "Steinberg_IPluginFactory": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getFactoryInfo) (void* thisInterface, struct Steinberg_PFactoryInfo* info); + Steinberg_int32 (SMTG_STDMETHODCALLTYPE* countClasses) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getClassInfo) (void* thisInterface, Steinberg_int32 index, struct Steinberg_PClassInfo* info); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* createInstance) (void* thisInterface, Steinberg_FIDString cid, Steinberg_FIDString iid, void** obj); + + /* methods defined in "Steinberg_IPluginFactory2": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getClassInfo2) (void* thisInterface, Steinberg_int32 index, struct Steinberg_PClassInfo2* info); + +} Steinberg_IPluginFactory2Vtbl; + +typedef struct Steinberg_IPluginFactory2 +{ + struct Steinberg_IPluginFactory2Vtbl* lpVtbl; +} Steinberg_IPluginFactory2; + +static const Steinberg_TUID Steinberg_IPluginFactory2_iid = SMTG_INLINE_UID (0x0007B650, 0xF24B4C0B, 0xA464EDB9, 0xF00B2ABB); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/base/ipluginbase.h", line 447 */ + +typedef struct Steinberg_IPluginFactory3Vtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods derived from "Steinberg_IPluginFactory": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getFactoryInfo) (void* thisInterface, struct Steinberg_PFactoryInfo* info); + Steinberg_int32 (SMTG_STDMETHODCALLTYPE* countClasses) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getClassInfo) (void* thisInterface, Steinberg_int32 index, struct Steinberg_PClassInfo* info); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* createInstance) (void* thisInterface, Steinberg_FIDString cid, Steinberg_FIDString iid, void** obj); + + /* methods derived from "Steinberg_IPluginFactory2": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getClassInfo2) (void* thisInterface, Steinberg_int32 index, struct Steinberg_PClassInfo2* info); + + /* methods defined in "Steinberg_IPluginFactory3": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getClassInfoUnicode) (void* thisInterface, Steinberg_int32 index, struct Steinberg_PClassInfoW* info); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setHostContext) (void* thisInterface, struct Steinberg_FUnknown* context); + +} Steinberg_IPluginFactory3Vtbl; + +typedef struct Steinberg_IPluginFactory3 +{ + struct Steinberg_IPluginFactory3Vtbl* lpVtbl; +} Steinberg_IPluginFactory3; + +static const Steinberg_TUID Steinberg_IPluginFactory3_iid = SMTG_INLINE_UID (0x4555A2AB, 0xC1234E57, 0x9B122910, 0x36878931); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstcomponent.h", line 158 */ + +typedef struct Steinberg_Vst_IComponentVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods derived from "Steinberg_IPluginBase": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* initialize) (void* thisInterface, struct Steinberg_FUnknown* context); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* terminate) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IComponent": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getControllerClassId) (void* thisInterface, Steinberg_TUID classId); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setIoMode) (void* thisInterface, Steinberg_Vst_IoMode mode); + Steinberg_int32 (SMTG_STDMETHODCALLTYPE* getBusCount) (void* thisInterface, Steinberg_Vst_MediaType type, Steinberg_Vst_BusDirection dir); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getBusInfo) (void* thisInterface, Steinberg_Vst_MediaType type, Steinberg_Vst_BusDirection dir, Steinberg_int32 index, struct Steinberg_Vst_BusInfo* bus); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getRoutingInfo) (void* thisInterface, struct Steinberg_Vst_RoutingInfo* inInfo, struct Steinberg_Vst_RoutingInfo* outInfo); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* activateBus) (void* thisInterface, Steinberg_Vst_MediaType type, Steinberg_Vst_BusDirection dir, Steinberg_int32 index, Steinberg_TBool state); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setActive) (void* thisInterface, Steinberg_TBool state); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setState) (void* thisInterface, struct Steinberg_IBStream* state); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getState) (void* thisInterface, struct Steinberg_IBStream* state); + +} Steinberg_Vst_IComponentVtbl; + +typedef struct Steinberg_Vst_IComponent +{ + struct Steinberg_Vst_IComponentVtbl* lpVtbl; +} Steinberg_Vst_IComponent; + +static const Steinberg_TUID Steinberg_Vst_IComponent_iid = SMTG_INLINE_UID (0xE831FF31, 0xF2D54301, 0x928EBBEE, 0x25697802); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstattributes.h", line 40 */ + +typedef struct Steinberg_Vst_IAttributeListVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IAttributeList": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setInt) (void* thisInterface, Steinberg_Vst_IAttributeList_AttrID id, Steinberg_int64 value); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getInt) (void* thisInterface, Steinberg_Vst_IAttributeList_AttrID id, Steinberg_int64* value); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setFloat) (void* thisInterface, Steinberg_Vst_IAttributeList_AttrID id, double value); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getFloat) (void* thisInterface, Steinberg_Vst_IAttributeList_AttrID id, double* value); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setString) (void* thisInterface, Steinberg_Vst_IAttributeList_AttrID id, const Steinberg_Vst_TChar* string); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getString) (void* thisInterface, Steinberg_Vst_IAttributeList_AttrID id, Steinberg_Vst_TChar* string, Steinberg_uint32 sizeInBytes); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setBinary) (void* thisInterface, Steinberg_Vst_IAttributeList_AttrID id, const void* data, Steinberg_uint32 sizeInBytes); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getBinary) (void* thisInterface, Steinberg_Vst_IAttributeList_AttrID id, const void** data, Steinberg_uint32* sizeInBytes); + +} Steinberg_Vst_IAttributeListVtbl; + +typedef struct Steinberg_Vst_IAttributeList +{ + struct Steinberg_Vst_IAttributeListVtbl* lpVtbl; +} Steinberg_Vst_IAttributeList; + +static const Steinberg_TUID Steinberg_Vst_IAttributeList_iid = SMTG_INLINE_UID (0x1E5F0AEB, 0xCC7F4533, 0xA2544011, 0x38AD5EE4); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstattributes.h", line 135 */ + +typedef struct Steinberg_Vst_IStreamAttributesVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IStreamAttributes": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getFileName) (void* thisInterface, Steinberg_Vst_String128 name); + struct Steinberg_Vst_IAttributeList* (SMTG_STDMETHODCALLTYPE* getAttributes) (void* thisInterface); + +} Steinberg_Vst_IStreamAttributesVtbl; + +typedef struct Steinberg_Vst_IStreamAttributes +{ + struct Steinberg_Vst_IStreamAttributesVtbl* lpVtbl; +} Steinberg_Vst_IStreamAttributes; + +static const Steinberg_TUID Steinberg_Vst_IStreamAttributes_iid = SMTG_INLINE_UID (0xD6CE2FFC, 0xEFAF4B8C, 0x9E74F1BB, 0x12DA44B4); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstremapparamid.h", line 46 */ + +typedef struct Steinberg_Vst_IRemapParamIDVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IRemapParamID": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getCompatibleParamID) (void* thisInterface, const Steinberg_TUID pluginToReplaceUID, Steinberg_Vst_ParamID oldParamID, Steinberg_Vst_ParamID* newParamID); + +} Steinberg_Vst_IRemapParamIDVtbl; + +typedef struct Steinberg_Vst_IRemapParamID +{ + struct Steinberg_Vst_IRemapParamIDVtbl* lpVtbl; +} Steinberg_Vst_IRemapParamID; + +static const Steinberg_TUID Steinberg_Vst_IRemapParamID_iid = SMTG_INLINE_UID (0x2B88021E, 0x6286B646, 0xB49DF76A, 0x5663061C); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 217 */ + +typedef struct Steinberg_Vst_IComponentHandlerVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IComponentHandler": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* beginEdit) (void* thisInterface, Steinberg_Vst_ParamID id); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* performEdit) (void* thisInterface, Steinberg_Vst_ParamID id, Steinberg_Vst_ParamValue valueNormalized); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* endEdit) (void* thisInterface, Steinberg_Vst_ParamID id); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* restartComponent) (void* thisInterface, Steinberg_int32 flags); + +} Steinberg_Vst_IComponentHandlerVtbl; + +typedef struct Steinberg_Vst_IComponentHandler +{ + struct Steinberg_Vst_IComponentHandlerVtbl* lpVtbl; +} Steinberg_Vst_IComponentHandler; + +static const Steinberg_TUID Steinberg_Vst_IComponentHandler_iid = SMTG_INLINE_UID (0x93A0BEA3, 0x0BD045DB, 0x8E890B0C, 0xC1E46AC6); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 307 */ + +typedef struct Steinberg_Vst_IComponentHandler2Vtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IComponentHandler2": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setDirty) (void* thisInterface, Steinberg_TBool state); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* requestOpenEditor) (void* thisInterface, Steinberg_FIDString name); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* startGroupEdit) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* finishGroupEdit) (void* thisInterface); + +} Steinberg_Vst_IComponentHandler2Vtbl; + +typedef struct Steinberg_Vst_IComponentHandler2 +{ + struct Steinberg_Vst_IComponentHandler2Vtbl* lpVtbl; +} Steinberg_Vst_IComponentHandler2; + +static const Steinberg_TUID Steinberg_Vst_IComponentHandler2_iid = SMTG_INLINE_UID (0xF040B4B3, 0xA36045EC, 0xABCDC045, 0xB4D5A2CC); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 365 */ + +typedef struct Steinberg_Vst_IComponentHandlerBusActivationVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IComponentHandlerBusActivation": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* requestBusActivation) (void* thisInterface, Steinberg_Vst_MediaType type, Steinberg_Vst_BusDirection dir, Steinberg_int32 index, Steinberg_TBool state); + +} Steinberg_Vst_IComponentHandlerBusActivationVtbl; + +typedef struct Steinberg_Vst_IComponentHandlerBusActivation +{ + struct Steinberg_Vst_IComponentHandlerBusActivationVtbl* lpVtbl; +} Steinberg_Vst_IComponentHandlerBusActivation; + +static const Steinberg_TUID Steinberg_Vst_IComponentHandlerBusActivation_iid = SMTG_INLINE_UID (0x067D02C1, 0x5B4E274D, 0xA92D90FD, 0x6EAF7240); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 422 */ + +typedef struct Steinberg_Vst_IProgressVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IProgress": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* start) (void* thisInterface, Steinberg_Vst_IProgress_ProgressType type, const Steinberg_tchar* optionalDescription, Steinberg_Vst_IProgress_ID* outID); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* update) (void* thisInterface, Steinberg_Vst_IProgress_ID id, Steinberg_Vst_ParamValue normValue); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* finish) (void* thisInterface, Steinberg_Vst_IProgress_ID id); + +} Steinberg_Vst_IProgressVtbl; + +typedef struct Steinberg_Vst_IProgress +{ + struct Steinberg_Vst_IProgressVtbl* lpVtbl; +} Steinberg_Vst_IProgress; + +static const Steinberg_TUID Steinberg_Vst_IProgress_iid = SMTG_INLINE_UID (0x00C9DC5B, 0x9D904254, 0x91A388C8, 0xB4E91B69); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 468 */ + +typedef struct Steinberg_Vst_IEditControllerVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods derived from "Steinberg_IPluginBase": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* initialize) (void* thisInterface, struct Steinberg_FUnknown* context); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* terminate) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IEditController": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setComponentState) (void* thisInterface, struct Steinberg_IBStream* state); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setState) (void* thisInterface, struct Steinberg_IBStream* state); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getState) (void* thisInterface, struct Steinberg_IBStream* state); + Steinberg_int32 (SMTG_STDMETHODCALLTYPE* getParameterCount) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getParameterInfo) (void* thisInterface, Steinberg_int32 paramIndex, struct Steinberg_Vst_ParameterInfo* info); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getParamStringByValue) (void* thisInterface, Steinberg_Vst_ParamID id, Steinberg_Vst_ParamValue valueNormalized, Steinberg_Vst_String128 string); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getParamValueByString) (void* thisInterface, Steinberg_Vst_ParamID id, Steinberg_Vst_TChar* string, Steinberg_Vst_ParamValue* valueNormalized); + Steinberg_Vst_ParamValue (SMTG_STDMETHODCALLTYPE* normalizedParamToPlain) (void* thisInterface, Steinberg_Vst_ParamID id, Steinberg_Vst_ParamValue valueNormalized); + Steinberg_Vst_ParamValue (SMTG_STDMETHODCALLTYPE* plainParamToNormalized) (void* thisInterface, Steinberg_Vst_ParamID id, Steinberg_Vst_ParamValue plainValue); + Steinberg_Vst_ParamValue (SMTG_STDMETHODCALLTYPE* getParamNormalized) (void* thisInterface, Steinberg_Vst_ParamID id); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setParamNormalized) (void* thisInterface, Steinberg_Vst_ParamID id, Steinberg_Vst_ParamValue value); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setComponentHandler) (void* thisInterface, struct Steinberg_Vst_IComponentHandler* handler); + struct Steinberg_IPlugView* (SMTG_STDMETHODCALLTYPE* createView) (void* thisInterface, Steinberg_FIDString name); + +} Steinberg_Vst_IEditControllerVtbl; + +typedef struct Steinberg_Vst_IEditController +{ + struct Steinberg_Vst_IEditControllerVtbl* lpVtbl; +} Steinberg_Vst_IEditController; + +static const Steinberg_TUID Steinberg_Vst_IEditController_iid = SMTG_INLINE_UID (0xDCD7BBE3, 0x7742448D, 0xA874AACC, 0x979C759E); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 575 */ + +typedef struct Steinberg_Vst_IEditController2Vtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IEditController2": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setKnobMode) (void* thisInterface, Steinberg_Vst_KnobMode mode); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* openHelp) (void* thisInterface, Steinberg_TBool onlyCheck); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* openAboutBox) (void* thisInterface, Steinberg_TBool onlyCheck); + +} Steinberg_Vst_IEditController2Vtbl; + +typedef struct Steinberg_Vst_IEditController2 +{ + struct Steinberg_Vst_IEditController2Vtbl* lpVtbl; +} Steinberg_Vst_IEditController2; + +static const Steinberg_TUID Steinberg_Vst_IEditController2_iid = SMTG_INLINE_UID (0x7F4EFE59, 0xF3204967, 0xAC27A3AE, 0xAFB63038); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 659 */ + +typedef struct Steinberg_Vst_IMidiMappingVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IMidiMapping": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getMidiControllerAssignment) (void* thisInterface, Steinberg_int32 busIndex, Steinberg_int16 channel, Steinberg_Vst_CtrlNumber midiControllerNumber, Steinberg_Vst_ParamID* id); + +} Steinberg_Vst_IMidiMappingVtbl; + +typedef struct Steinberg_Vst_IMidiMapping +{ + struct Steinberg_Vst_IMidiMappingVtbl* lpVtbl; +} Steinberg_Vst_IMidiMapping; + +static const Steinberg_TUID Steinberg_Vst_IMidiMapping_iid = SMTG_INLINE_UID (0xDF0FF9F7, 0x49B74669, 0xB63AB732, 0x7ADBF5E5); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 708 */ + +typedef struct Steinberg_Vst_IEditControllerHostEditingVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IEditControllerHostEditing": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* beginEditFromHost) (void* thisInterface, Steinberg_Vst_ParamID paramID); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* endEditFromHost) (void* thisInterface, Steinberg_Vst_ParamID paramID); + +} Steinberg_Vst_IEditControllerHostEditingVtbl; + +typedef struct Steinberg_Vst_IEditControllerHostEditing +{ + struct Steinberg_Vst_IEditControllerHostEditingVtbl* lpVtbl; +} Steinberg_Vst_IEditControllerHostEditing; + +static const Steinberg_TUID Steinberg_Vst_IEditControllerHostEditing_iid = SMTG_INLINE_UID (0xC1271208, 0x70594098, 0xB9DD34B3, 0x6BB0195E); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsteditcontroller.h", line 735 */ + +typedef struct Steinberg_Vst_IComponentHandlerSystemTimeVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IComponentHandlerSystemTime": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getSystemTime) (void* thisInterface, Steinberg_int64* systemTime); + +} Steinberg_Vst_IComponentHandlerSystemTimeVtbl; + +typedef struct Steinberg_Vst_IComponentHandlerSystemTime +{ + struct Steinberg_Vst_IComponentHandlerSystemTimeVtbl* lpVtbl; +} Steinberg_Vst_IComponentHandlerSystemTime; + +static const Steinberg_TUID Steinberg_Vst_IComponentHandlerSystemTime_iid = SMTG_INLINE_UID (0xF9E53056, 0xD1554CD5, 0xB7695E1B, 0x7B0F7745); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstevents.h", line 198 */ + +typedef struct Steinberg_Vst_IEventListVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IEventList": */ + Steinberg_int32 (SMTG_STDMETHODCALLTYPE* getEventCount) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getEvent) (void* thisInterface, Steinberg_int32 index, struct Steinberg_Vst_Event* e); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* addEvent) (void* thisInterface, struct Steinberg_Vst_Event* e); + +} Steinberg_Vst_IEventListVtbl; + +typedef struct Steinberg_Vst_IEventList +{ + struct Steinberg_Vst_IEventListVtbl* lpVtbl; +} Steinberg_Vst_IEventList; + +static const Steinberg_TUID Steinberg_Vst_IEventList_iid = SMTG_INLINE_UID (0x3A2C4214, 0x346349FE, 0xB2C4F397, 0xB9695A44); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstmessage.h", line 40 */ + +typedef struct Steinberg_Vst_IMessageVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IMessage": */ + Steinberg_FIDString (SMTG_STDMETHODCALLTYPE* getMessageID) (void* thisInterface); + void (SMTG_STDMETHODCALLTYPE* setMessageID) (void* thisInterface, Steinberg_FIDString id); + struct Steinberg_Vst_IAttributeList* (SMTG_STDMETHODCALLTYPE* getAttributes) (void* thisInterface); + +} Steinberg_Vst_IMessageVtbl; + +typedef struct Steinberg_Vst_IMessage +{ + struct Steinberg_Vst_IMessageVtbl* lpVtbl; +} Steinberg_Vst_IMessage; + +static const Steinberg_TUID Steinberg_Vst_IMessage_iid = SMTG_INLINE_UID (0x936F033B, 0xC6C047DB, 0xBB0882F8, 0x13C1E613); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstmessage.h", line 73 */ + +typedef struct Steinberg_Vst_IConnectionPointVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IConnectionPoint": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* connect) (void* thisInterface, struct Steinberg_Vst_IConnectionPoint* other); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* disconnect) (void* thisInterface, struct Steinberg_Vst_IConnectionPoint* other); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* notify) (void* thisInterface, struct Steinberg_Vst_IMessage* message); + +} Steinberg_Vst_IConnectionPointVtbl; + +typedef struct Steinberg_Vst_IConnectionPoint +{ + struct Steinberg_Vst_IConnectionPointVtbl* lpVtbl; +} Steinberg_Vst_IConnectionPoint; + +static const Steinberg_TUID Steinberg_Vst_IConnectionPoint_iid = SMTG_INLINE_UID (0x70A4156F, 0x6E6E4026, 0x989148BF, 0xAA60D8D1); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstrepresentation.h", line 180 */ + +typedef struct Steinberg_Vst_IXmlRepresentationControllerVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IXmlRepresentationController": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getXmlRepresentationStream) (void* thisInterface, struct Steinberg_Vst_RepresentationInfo* info, struct Steinberg_IBStream* stream); + +} Steinberg_Vst_IXmlRepresentationControllerVtbl; + +typedef struct Steinberg_Vst_IXmlRepresentationController +{ + struct Steinberg_Vst_IXmlRepresentationControllerVtbl* lpVtbl; +} Steinberg_Vst_IXmlRepresentationController; + +static const Steinberg_TUID Steinberg_Vst_IXmlRepresentationController_iid = SMTG_INLINE_UID (0xA81A0471, 0x48C34DC4, 0xAC30C9E1, 0x3C8393D5); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstcontextmenu.h", line 124 */ + +typedef struct Steinberg_Vst_IComponentHandler3Vtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IComponentHandler3": */ + struct Steinberg_Vst_IContextMenu* (SMTG_STDMETHODCALLTYPE* createContextMenu) (void* thisInterface, struct Steinberg_IPlugView* plugView, const Steinberg_Vst_ParamID* paramID); + +} Steinberg_Vst_IComponentHandler3Vtbl; + +typedef struct Steinberg_Vst_IComponentHandler3 +{ + struct Steinberg_Vst_IComponentHandler3Vtbl* lpVtbl; +} Steinberg_Vst_IComponentHandler3; + +static const Steinberg_TUID Steinberg_Vst_IComponentHandler3_iid = SMTG_INLINE_UID (0x69F11617, 0xD26B400D, 0xA4B6B964, 0x7B6EBBAB); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstcontextmenu.h", line 154 */ + +typedef struct Steinberg_Vst_IContextMenuTargetVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IContextMenuTarget": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* executeMenuItem) (void* thisInterface, Steinberg_int32 tag); + +} Steinberg_Vst_IContextMenuTargetVtbl; + +typedef struct Steinberg_Vst_IContextMenuTarget +{ + struct Steinberg_Vst_IContextMenuTargetVtbl* lpVtbl; +} Steinberg_Vst_IContextMenuTarget; + +static const Steinberg_TUID Steinberg_Vst_IContextMenuTarget_iid = SMTG_INLINE_UID (0x3CDF2E75, 0x85D34144, 0xBF86D36B, 0xD7C4894D); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstcontextmenu.h", line 196 */ + +typedef struct Steinberg_Vst_IContextMenuVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IContextMenu": */ + Steinberg_int32 (SMTG_STDMETHODCALLTYPE* getItemCount) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getItem) (void* thisInterface, Steinberg_int32 index, Steinberg_Vst_IContextMenu_Item* item, struct Steinberg_Vst_IContextMenuTarget** target); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* addItem) (void* thisInterface, const Steinberg_Vst_IContextMenu_Item* item, struct Steinberg_Vst_IContextMenuTarget* target); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* removeItem) (void* thisInterface, const Steinberg_Vst_IContextMenu_Item* item, struct Steinberg_Vst_IContextMenuTarget* target); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* popup) (void* thisInterface, Steinberg_UCoord x, Steinberg_UCoord y); + +} Steinberg_Vst_IContextMenuVtbl; + +typedef struct Steinberg_Vst_IContextMenu +{ + struct Steinberg_Vst_IContextMenuVtbl* lpVtbl; +} Steinberg_Vst_IContextMenu; + +static const Steinberg_TUID Steinberg_Vst_IContextMenu_iid = SMTG_INLINE_UID (0x2E93C863, 0x0C9C4588, 0x97DBECF5, 0xAD17817D); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstmidilearn.h", line 90 */ + +typedef struct Steinberg_Vst_IMidiLearnVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IMidiLearn": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* onLiveMIDIControllerInput) (void* thisInterface, Steinberg_int32 busIndex, Steinberg_int16 channel, Steinberg_Vst_CtrlNumber midiCC); + +} Steinberg_Vst_IMidiLearnVtbl; + +typedef struct Steinberg_Vst_IMidiLearn +{ + struct Steinberg_Vst_IMidiLearnVtbl* lpVtbl; +} Steinberg_Vst_IMidiLearn; + +static const Steinberg_TUID Steinberg_Vst_IMidiLearn_iid = SMTG_INLINE_UID (0x6B2449CC, 0x419740B5, 0xAB3C79DA, 0xC5FE5C86); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstchannelcontextinfo.h", line 155 */ + +typedef struct Steinberg_Vst_ChannelContext_IInfoListenerVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_ChannelContext_IInfoListener": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setChannelContextInfos) (void* thisInterface, struct Steinberg_Vst_IAttributeList* list); + +} Steinberg_Vst_ChannelContext_IInfoListenerVtbl; + +typedef struct Steinberg_Vst_ChannelContext_IInfoListener +{ + struct Steinberg_Vst_ChannelContext_IInfoListenerVtbl* lpVtbl; +} Steinberg_Vst_ChannelContext_IInfoListener; + +static const Steinberg_TUID Steinberg_Vst_ChannelContext_IInfoListener_iid = SMTG_INLINE_UID (0x0F194781, 0x8D984ADA, 0xBBA0C1EF, 0xC011D8D0); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstprefetchablesupport.h", line 78 */ + +typedef struct Steinberg_Vst_IPrefetchableSupportVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IPrefetchableSupport": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getPrefetchableSupport) (void* thisInterface, Steinberg_Vst_PrefetchableSupport* prefetchable); + +} Steinberg_Vst_IPrefetchableSupportVtbl; + +typedef struct Steinberg_Vst_IPrefetchableSupport +{ + struct Steinberg_Vst_IPrefetchableSupportVtbl* lpVtbl; +} Steinberg_Vst_IPrefetchableSupport; + +static const Steinberg_TUID Steinberg_Vst_IPrefetchableSupport_iid = SMTG_INLINE_UID (0x8AE54FDA, 0xE93046B9, 0xA28555BC, 0xDC98E21E); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstdataexchange.h", line 96 */ + +typedef struct Steinberg_Vst_IDataExchangeHandlerVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IDataExchangeHandler": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* openQueue) (void* thisInterface, struct Steinberg_Vst_IAudioProcessor* processor, Steinberg_uint32 blockSize, Steinberg_uint32 numBlocks, Steinberg_uint32 alignment, Steinberg_Vst_DataExchangeUserContextID userContextID, Steinberg_Vst_DataExchangeQueueID* outID); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* closeQueue) (void* thisInterface, Steinberg_Vst_DataExchangeQueueID queueID); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* lockBlock) (void* thisInterface, Steinberg_Vst_DataExchangeQueueID queueId, struct Steinberg_Vst_DataExchangeBlock* block); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* freeBlock) (void* thisInterface, Steinberg_Vst_DataExchangeQueueID queueId, Steinberg_Vst_DataExchangeBlockID blockID, Steinberg_TBool sendToController); + +} Steinberg_Vst_IDataExchangeHandlerVtbl; + +typedef struct Steinberg_Vst_IDataExchangeHandler +{ + struct Steinberg_Vst_IDataExchangeHandlerVtbl* lpVtbl; +} Steinberg_Vst_IDataExchangeHandler; + +static const Steinberg_TUID Steinberg_Vst_IDataExchangeHandler_iid = SMTG_INLINE_UID (0x36D551BD, 0x6FF54F08, 0xB48E830D, 0x8BD5A03B); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstdataexchange.h", line 171 */ + +typedef struct Steinberg_Vst_IDataExchangeReceiverVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IDataExchangeReceiver": */ + void (SMTG_STDMETHODCALLTYPE* queueOpened) (void* thisInterface, Steinberg_Vst_DataExchangeUserContextID userContextID, Steinberg_uint32 blockSize, Steinberg_TBool* dispatchOnBackgroundThread); + void (SMTG_STDMETHODCALLTYPE* queueClosed) (void* thisInterface, Steinberg_Vst_DataExchangeUserContextID userContextID); + void (SMTG_STDMETHODCALLTYPE* onDataExchangeBlocksReceived) (void* thisInterface, Steinberg_Vst_DataExchangeUserContextID userContextID, Steinberg_uint32 numBlocks, struct Steinberg_Vst_DataExchangeBlock* blocks, Steinberg_TBool onBackgroundThread); + +} Steinberg_Vst_IDataExchangeReceiverVtbl; + +typedef struct Steinberg_Vst_IDataExchangeReceiver +{ + struct Steinberg_Vst_IDataExchangeReceiverVtbl* lpVtbl; +} Steinberg_Vst_IDataExchangeReceiver; + +static const Steinberg_TUID Steinberg_Vst_IDataExchangeReceiver_iid = SMTG_INLINE_UID (0x45A759DC, 0x84FA4907, 0xABCB6175, 0x2FC786B6); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstautomationstate.h", line 39 */ + +typedef struct Steinberg_Vst_IAutomationStateVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IAutomationState": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setAutomationState) (void* thisInterface, Steinberg_int32 state); + +} Steinberg_Vst_IAutomationStateVtbl; + +typedef struct Steinberg_Vst_IAutomationState +{ + struct Steinberg_Vst_IAutomationStateVtbl* lpVtbl; +} Steinberg_Vst_IAutomationState; + +static const Steinberg_TUID Steinberg_Vst_IAutomationState_iid = SMTG_INLINE_UID (0xB4E8287F, 0x1BB346AA, 0x83A46667, 0x68937BAB); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstinterappaudio.h", line 38 */ + +typedef struct Steinberg_Vst_IInterAppAudioHostVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IInterAppAudioHost": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getScreenSize) (void* thisInterface, struct Steinberg_ViewRect* size, float* scale); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* connectedToHost) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* switchToHost) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* sendRemoteControlEvent) (void* thisInterface, Steinberg_uint32 event); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getHostIcon) (void* thisInterface, void** icon); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* scheduleEventFromUI) (void* thisInterface, struct Steinberg_Vst_Event* event); + struct Steinberg_Vst_IInterAppAudioPresetManager* (SMTG_STDMETHODCALLTYPE* createPresetManager) (void* thisInterface, const Steinberg_TUID* cid); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* showSettingsView) (void* thisInterface); + +} Steinberg_Vst_IInterAppAudioHostVtbl; + +typedef struct Steinberg_Vst_IInterAppAudioHost +{ + struct Steinberg_Vst_IInterAppAudioHostVtbl* lpVtbl; +} Steinberg_Vst_IInterAppAudioHost; + +static const Steinberg_TUID Steinberg_Vst_IInterAppAudioHost_iid = SMTG_INLINE_UID (0x0CE5743D, 0x68DF415E, 0xAE285BD4, 0xE2CDC8FD); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstinterappaudio.h", line 101 */ + +typedef struct Steinberg_Vst_IInterAppAudioConnectionNotificationVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IInterAppAudioConnectionNotification": */ + void (SMTG_STDMETHODCALLTYPE* onInterAppAudioConnectionStateChange) (void* thisInterface, Steinberg_TBool newState); + +} Steinberg_Vst_IInterAppAudioConnectionNotificationVtbl; + +typedef struct Steinberg_Vst_IInterAppAudioConnectionNotification +{ + struct Steinberg_Vst_IInterAppAudioConnectionNotificationVtbl* lpVtbl; +} Steinberg_Vst_IInterAppAudioConnectionNotification; + +static const Steinberg_TUID Steinberg_Vst_IInterAppAudioConnectionNotification_iid = SMTG_INLINE_UID (0x6020C72D, 0x5FC24AA1, 0xB0950DB5, 0xD7D6D5CF); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstinterappaudio.h", line 122 */ + +typedef struct Steinberg_Vst_IInterAppAudioPresetManagerVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IInterAppAudioPresetManager": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* runLoadPresetBrowser) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* runSavePresetBrowser) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* loadNextPreset) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* loadPreviousPreset) (void* thisInterface); + +} Steinberg_Vst_IInterAppAudioPresetManagerVtbl; + +typedef struct Steinberg_Vst_IInterAppAudioPresetManager +{ + struct Steinberg_Vst_IInterAppAudioPresetManagerVtbl* lpVtbl; +} Steinberg_Vst_IInterAppAudioPresetManager; + +static const Steinberg_TUID Steinberg_Vst_IInterAppAudioPresetManager_iid = SMTG_INLINE_UID (0xADE6FCC4, 0x46C94E1D, 0xB3B49A80, 0xC93FEFDD); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstaudioprocessor.h", line 269 */ + +typedef struct Steinberg_Vst_IAudioProcessorVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IAudioProcessor": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setBusArrangements) (void* thisInterface, Steinberg_Vst_SpeakerArrangement* inputs, Steinberg_int32 numIns, Steinberg_Vst_SpeakerArrangement* outputs, Steinberg_int32 numOuts); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getBusArrangement) (void* thisInterface, Steinberg_Vst_BusDirection dir, Steinberg_int32 index, Steinberg_Vst_SpeakerArrangement* arr); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* canProcessSampleSize) (void* thisInterface, Steinberg_int32 symbolicSampleSize); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* getLatencySamples) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setupProcessing) (void* thisInterface, struct Steinberg_Vst_ProcessSetup* setup); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setProcessing) (void* thisInterface, Steinberg_TBool state); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* process) (void* thisInterface, struct Steinberg_Vst_ProcessData* data); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* getTailSamples) (void* thisInterface); + +} Steinberg_Vst_IAudioProcessorVtbl; + +typedef struct Steinberg_Vst_IAudioProcessor +{ + struct Steinberg_Vst_IAudioProcessorVtbl* lpVtbl; +} Steinberg_Vst_IAudioProcessor; + +static const Steinberg_TUID Steinberg_Vst_IAudioProcessor_iid = SMTG_INLINE_UID (0x42043F99, 0xB7DA453C, 0xA569E79D, 0x9AAEC33D); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstaudioprocessor.h", line 400 */ + +typedef struct Steinberg_Vst_IAudioPresentationLatencyVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IAudioPresentationLatency": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setAudioPresentationLatencySamples) (void* thisInterface, Steinberg_Vst_BusDirection dir, Steinberg_int32 busIndex, Steinberg_uint32 latencyInSamples); + +} Steinberg_Vst_IAudioPresentationLatencyVtbl; + +typedef struct Steinberg_Vst_IAudioPresentationLatency +{ + struct Steinberg_Vst_IAudioPresentationLatencyVtbl* lpVtbl; +} Steinberg_Vst_IAudioPresentationLatency; + +static const Steinberg_TUID Steinberg_Vst_IAudioPresentationLatency_iid = SMTG_INLINE_UID (0x309ECE78, 0xEB7D4fae, 0x8B2225D9, 0x09FD08B6); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstaudioprocessor.h", line 437 */ + +typedef struct Steinberg_Vst_IProcessContextRequirementsVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IProcessContextRequirements": */ + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* getProcessContextRequirements) (void* thisInterface); + +} Steinberg_Vst_IProcessContextRequirementsVtbl; + +typedef struct Steinberg_Vst_IProcessContextRequirements +{ + struct Steinberg_Vst_IProcessContextRequirementsVtbl* lpVtbl; +} Steinberg_Vst_IProcessContextRequirements; + +static const Steinberg_TUID Steinberg_Vst_IProcessContextRequirements_iid = SMTG_INLINE_UID (0x2A654303, 0xEF764E3D, 0x95B5FE83, 0x730EF6D0); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstmidimapping2.h", line 128 */ + +typedef struct Steinberg_Vst_IMidiMapping2Vtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IMidiMapping2": */ + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* getNumMidi2ControllerAssignments) (void* thisInterface, Steinberg_Vst_BusDirections direction); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getMidi2ControllerAssignments) (void* thisInterface, Steinberg_Vst_BusDirections direction, const struct Steinberg_Vst_Midi2ControllerParamIDAssignmentList* list); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* getNumMidi1ControllerAssignments) (void* thisInterface, Steinberg_Vst_BusDirections direction); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getMidi1ControllerAssignments) (void* thisInterface, Steinberg_Vst_BusDirections direction, const struct Steinberg_Vst_Midi1ControllerParamIDAssignmentList* list); + +} Steinberg_Vst_IMidiMapping2Vtbl; + +typedef struct Steinberg_Vst_IMidiMapping2 +{ + struct Steinberg_Vst_IMidiMapping2Vtbl* lpVtbl; +} Steinberg_Vst_IMidiMapping2; + +static const Steinberg_TUID Steinberg_Vst_IMidiMapping2_iid = SMTG_INLINE_UID (0x6DE14B88, 0x03F94F09, 0xA2552F0F, 0x9326593E); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstmidimapping2.h", line 188 */ + +typedef struct Steinberg_Vst_IMidiLearn2Vtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IMidiLearn2": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* onLiveMidi2ControllerInput) (void* thisInterface, Steinberg_Vst_BusIndex index, Steinberg_Vst_MidiChannel channel, struct Steinberg_Vst_Midi2Controller midiCC); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* onLiveMidi1ControllerInput) (void* thisInterface, Steinberg_Vst_BusIndex index, Steinberg_Vst_MidiChannel channel, Steinberg_Vst_CtrlNumber midiCC); + +} Steinberg_Vst_IMidiLearn2Vtbl; + +typedef struct Steinberg_Vst_IMidiLearn2 +{ + struct Steinberg_Vst_IMidiLearn2Vtbl* lpVtbl; +} Steinberg_Vst_IMidiLearn2; + +static const Steinberg_TUID Steinberg_Vst_IMidiLearn2_iid = SMTG_INLINE_UID (0xF07E498A, 0x78864327, 0x8B431CED, 0xA3C553FC); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsthostapplication.h", line 35 */ + +typedef struct Steinberg_Vst_IHostApplicationVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IHostApplication": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getName) (void* thisInterface, Steinberg_Vst_String128 name); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* createInstance) (void* thisInterface, Steinberg_TUID cid, Steinberg_TUID iid, void** obj); + +} Steinberg_Vst_IHostApplicationVtbl; + +typedef struct Steinberg_Vst_IHostApplication +{ + struct Steinberg_Vst_IHostApplicationVtbl* lpVtbl; +} Steinberg_Vst_IHostApplication; + +static const Steinberg_TUID Steinberg_Vst_IHostApplication_iid = SMTG_INLINE_UID (0x58E595CC, 0xDB2D4969, 0x8B6AAF8C, 0x36A664E5); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsthostapplication.h", line 76 */ + +typedef struct Steinberg_Vst_IVst3ToVst2WrapperVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + +} Steinberg_Vst_IVst3ToVst2WrapperVtbl; + +typedef struct Steinberg_Vst_IVst3ToVst2Wrapper +{ + struct Steinberg_Vst_IVst3ToVst2WrapperVtbl* lpVtbl; +} Steinberg_Vst_IVst3ToVst2Wrapper; + +static const Steinberg_TUID Steinberg_Vst_IVst3ToVst2Wrapper_iid = SMTG_INLINE_UID (0x29633AEC, 0x1D1C47E2, 0xBB85B97B, 0xD36EAC61); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsthostapplication.h", line 96 */ + +typedef struct Steinberg_Vst_IVst3ToAUWrapperVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + +} Steinberg_Vst_IVst3ToAUWrapperVtbl; + +typedef struct Steinberg_Vst_IVst3ToAUWrapper +{ + struct Steinberg_Vst_IVst3ToAUWrapperVtbl* lpVtbl; +} Steinberg_Vst_IVst3ToAUWrapper; + +static const Steinberg_TUID Steinberg_Vst_IVst3ToAUWrapper_iid = SMTG_INLINE_UID (0xA3B8C6C5, 0xC0954688, 0xB0916F0B, 0xB697AA44); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsthostapplication.h", line 116 */ + +typedef struct Steinberg_Vst_IVst3ToAAXWrapperVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + +} Steinberg_Vst_IVst3ToAAXWrapperVtbl; + +typedef struct Steinberg_Vst_IVst3ToAAXWrapper +{ + struct Steinberg_Vst_IVst3ToAAXWrapperVtbl* lpVtbl; +} Steinberg_Vst_IVst3ToAAXWrapper; + +static const Steinberg_TUID Steinberg_Vst_IVst3ToAAXWrapper_iid = SMTG_INLINE_UID (0x6D319DC6, 0x60C56242, 0xB32C951B, 0x93BEF4C6); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsthostapplication.h", line 140 */ + +typedef struct Steinberg_Vst_IVst3WrapperMPESupportVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IVst3WrapperMPESupport": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* enableMPEInputProcessing) (void* thisInterface, Steinberg_TBool state); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setMPEInputDeviceSettings) (void* thisInterface, Steinberg_int32 masterChannel, Steinberg_int32 memberBeginChannel, Steinberg_int32 memberEndChannel); + +} Steinberg_Vst_IVst3WrapperMPESupportVtbl; + +typedef struct Steinberg_Vst_IVst3WrapperMPESupport +{ + struct Steinberg_Vst_IVst3WrapperMPESupportVtbl* lpVtbl; +} Steinberg_Vst_IVst3WrapperMPESupport; + +static const Steinberg_TUID Steinberg_Vst_IVst3WrapperMPESupport_iid = SMTG_INLINE_UID (0x44149067, 0x42CF4BF9, 0x8800B750, 0xF7359FE3); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstplugview.h", line 44 */ + +typedef struct Steinberg_Vst_IParameterFinderVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IParameterFinder": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* findParameter) (void* thisInterface, Steinberg_int32 xPos, Steinberg_int32 yPos, Steinberg_Vst_ParamID* resultTag); + +} Steinberg_Vst_IParameterFinderVtbl; + +typedef struct Steinberg_Vst_IParameterFinder +{ + struct Steinberg_Vst_IParameterFinderVtbl* lpVtbl; +} Steinberg_Vst_IParameterFinder; + +static const Steinberg_TUID Steinberg_Vst_IParameterFinder_iid = SMTG_INLINE_UID (0x0F618302, 0x215D4587, 0xA512073C, 0x77B9D383); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstnoteonorchestralarticulationinfo.h", line 65 */ + +typedef struct Steinberg_Vst_NoteOnOrchestralArticulation_IInfoVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_NoteOnOrchestralArticulation_IInfo": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getVariationsInfo) (void* thisInterface, Steinberg_int32 busIndex, Steinberg_int16 channel, struct Steinberg_Vst_NoteOnOrchestralArticulation_ClassificationVariations* info); + +} Steinberg_Vst_NoteOnOrchestralArticulation_IInfoVtbl; + +typedef struct Steinberg_Vst_NoteOnOrchestralArticulation_IInfo +{ + struct Steinberg_Vst_NoteOnOrchestralArticulation_IInfoVtbl* lpVtbl; +} Steinberg_Vst_NoteOnOrchestralArticulation_IInfo; + +static const Steinberg_TUID Steinberg_Vst_NoteOnOrchestralArticulation_IInfo_iid = SMTG_INLINE_UID (0x7D34A9B4, 0x89CA45F4, 0x9284A9FD, 0x4DD9C906); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivsttransportcontrol.h", line 100 */ + +typedef struct Steinberg_Vst_ITransportControlVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_ITransportControl": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* requestAction) (void* thisInterface, Steinberg_int32 action, struct Steinberg_Vst_TransportPosition* position); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* isActionSupported) (void* thisInterface, Steinberg_int32 action); + +} Steinberg_Vst_ITransportControlVtbl; + +typedef struct Steinberg_Vst_ITransportControl +{ + struct Steinberg_Vst_ITransportControlVtbl* lpVtbl; +} Steinberg_Vst_ITransportControl; + +static const Steinberg_TUID Steinberg_Vst_ITransportControl_iid = SMTG_INLINE_UID (0xD752F52D, 0x004348A0, 0xB431B045, 0xF0DCA49C); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstunits.h", line 80 */ + +typedef struct Steinberg_Vst_IUnitHandlerVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IUnitHandler": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* notifyUnitSelection) (void* thisInterface, Steinberg_Vst_UnitID unitId); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* notifyProgramListChange) (void* thisInterface, Steinberg_Vst_ProgramListID listId, Steinberg_int32 programIndex); + +} Steinberg_Vst_IUnitHandlerVtbl; + +typedef struct Steinberg_Vst_IUnitHandler +{ + struct Steinberg_Vst_IUnitHandlerVtbl* lpVtbl; +} Steinberg_Vst_IUnitHandler; + +static const Steinberg_TUID Steinberg_Vst_IUnitHandler_iid = SMTG_INLINE_UID (0x4B5147F8, 0x4654486B, 0x8DAB30BA, 0x163A3C56); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstunits.h", line 121 */ + +typedef struct Steinberg_Vst_IUnitHandler2Vtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IUnitHandler2": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* notifyUnitByBusChange) (void* thisInterface); + +} Steinberg_Vst_IUnitHandler2Vtbl; + +typedef struct Steinberg_Vst_IUnitHandler2 +{ + struct Steinberg_Vst_IUnitHandler2Vtbl* lpVtbl; +} Steinberg_Vst_IUnitHandler2; + +static const Steinberg_TUID Steinberg_Vst_IUnitHandler2_iid = SMTG_INLINE_UID (0xF89F8CDF, 0x699E4BA5, 0x96AAC9A4, 0x81452B01); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstunits.h", line 151 */ + +typedef struct Steinberg_Vst_IUnitInfoVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IUnitInfo": */ + Steinberg_int32 (SMTG_STDMETHODCALLTYPE* getUnitCount) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getUnitInfo) (void* thisInterface, Steinberg_int32 unitIndex, struct Steinberg_Vst_UnitInfo* info); + Steinberg_int32 (SMTG_STDMETHODCALLTYPE* getProgramListCount) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getProgramListInfo) (void* thisInterface, Steinberg_int32 listIndex, struct Steinberg_Vst_ProgramListInfo* info); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getProgramName) (void* thisInterface, Steinberg_Vst_ProgramListID listId, Steinberg_int32 programIndex, Steinberg_Vst_String128 name); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getProgramInfo) (void* thisInterface, Steinberg_Vst_ProgramListID listId, Steinberg_int32 programIndex, Steinberg_Vst_CString attributeId, Steinberg_Vst_String128 attributeValue); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* hasProgramPitchNames) (void* thisInterface, Steinberg_Vst_ProgramListID listId, Steinberg_int32 programIndex); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getProgramPitchName) (void* thisInterface, Steinberg_Vst_ProgramListID listId, Steinberg_int32 programIndex, Steinberg_int16 midiPitch, Steinberg_Vst_String128 name); + Steinberg_Vst_UnitID (SMTG_STDMETHODCALLTYPE* getSelectedUnit) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* selectUnit) (void* thisInterface, Steinberg_Vst_UnitID unitId); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getUnitByBus) (void* thisInterface, Steinberg_Vst_MediaType type, Steinberg_Vst_BusDirection dir, Steinberg_int32 busIndex, Steinberg_int32 channel, Steinberg_Vst_UnitID* unitId); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setUnitProgramData) (void* thisInterface, Steinberg_int32 listOrUnitId, Steinberg_int32 programIndex, struct Steinberg_IBStream* data); + +} Steinberg_Vst_IUnitInfoVtbl; + +typedef struct Steinberg_Vst_IUnitInfo +{ + struct Steinberg_Vst_IUnitInfoVtbl* lpVtbl; +} Steinberg_Vst_IUnitInfo; + +static const Steinberg_TUID Steinberg_Vst_IUnitInfo_iid = SMTG_INLINE_UID (0x3D4BD6B5, 0x913A4FD2, 0xA886E768, 0xA5EB92C1); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstunits.h", line 242 */ + +typedef struct Steinberg_Vst_IProgramListDataVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IProgramListData": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* programDataSupported) (void* thisInterface, Steinberg_Vst_ProgramListID listId); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getProgramData) (void* thisInterface, Steinberg_Vst_ProgramListID listId, Steinberg_int32 programIndex, struct Steinberg_IBStream* data); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setProgramData) (void* thisInterface, Steinberg_Vst_ProgramListID listId, Steinberg_int32 programIndex, struct Steinberg_IBStream* data); + +} Steinberg_Vst_IProgramListDataVtbl; + +typedef struct Steinberg_Vst_IProgramListData +{ + struct Steinberg_Vst_IProgramListDataVtbl* lpVtbl; +} Steinberg_Vst_IProgramListData; + +static const Steinberg_TUID Steinberg_Vst_IProgramListData_iid = SMTG_INLINE_UID (0x8683B01F, 0x7B354F70, 0xA2651DEC, 0x353AF4FF); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstunits.h", line 279 */ + +typedef struct Steinberg_Vst_IUnitDataVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IUnitData": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* unitDataSupported) (void* thisInterface, Steinberg_Vst_UnitID unitID); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getUnitData) (void* thisInterface, Steinberg_Vst_UnitID unitId, struct Steinberg_IBStream* data); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* setUnitData) (void* thisInterface, Steinberg_Vst_UnitID unitId, struct Steinberg_IBStream* data); + +} Steinberg_Vst_IUnitDataVtbl; + +typedef struct Steinberg_Vst_IUnitData +{ + struct Steinberg_Vst_IUnitDataVtbl* lpVtbl; +} Steinberg_Vst_IUnitData; + +static const Steinberg_TUID Steinberg_Vst_IUnitData_iid = SMTG_INLINE_UID (0x6C389611, 0xD391455D, 0xB870B833, 0x94A0EFDD); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstpluginterfacesupport.h", line 53 */ + +typedef struct Steinberg_Vst_IPlugInterfaceSupportVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IPlugInterfaceSupport": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* isPlugInterfaceSupported) (void* thisInterface, const Steinberg_TUID iid); + +} Steinberg_Vst_IPlugInterfaceSupportVtbl; + +typedef struct Steinberg_Vst_IPlugInterfaceSupport +{ + struct Steinberg_Vst_IPlugInterfaceSupportVtbl* lpVtbl; +} Steinberg_Vst_IPlugInterfaceSupport; + +static const Steinberg_TUID Steinberg_Vst_IPlugInterfaceSupport_iid = SMTG_INLINE_UID (0x4FB58B9E, 0x9EAA4E0F, 0xAB361C1C, 0xCCB56FEA); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstparameterfunctionname.h", line 141 */ + +typedef struct Steinberg_Vst_IParameterFunctionNameVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IParameterFunctionName": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getParameterIDFromFunctionName) (void* thisInterface, Steinberg_Vst_UnitID unitID, Steinberg_FIDString functionName, Steinberg_Vst_ParamID* paramID); + +} Steinberg_Vst_IParameterFunctionNameVtbl; + +typedef struct Steinberg_Vst_IParameterFunctionName +{ + struct Steinberg_Vst_IParameterFunctionNameVtbl* lpVtbl; +} Steinberg_Vst_IParameterFunctionName; + +static const Steinberg_TUID Steinberg_Vst_IParameterFunctionName_iid = SMTG_INLINE_UID (0x6D21E1DC, 0x91199D4B, 0xA2A02FEF, 0x6C1AE55C); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstparameterchanges.h", line 84 */ + +typedef struct Steinberg_Vst_IParamValueQueueVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IParamValueQueue": */ + Steinberg_Vst_ParamID (SMTG_STDMETHODCALLTYPE* getParameterId) (void* thisInterface); + Steinberg_int32 (SMTG_STDMETHODCALLTYPE* getPointCount) (void* thisInterface); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* getPoint) (void* thisInterface, Steinberg_int32 index, Steinberg_int32* sampleOffset, Steinberg_Vst_ParamValue* value); + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* addPoint) (void* thisInterface, Steinberg_int32 sampleOffset, Steinberg_Vst_ParamValue value, Steinberg_int32* index); + +} Steinberg_Vst_IParamValueQueueVtbl; + +typedef struct Steinberg_Vst_IParamValueQueue +{ + struct Steinberg_Vst_IParamValueQueueVtbl* lpVtbl; +} Steinberg_Vst_IParamValueQueue; + +static const Steinberg_TUID Steinberg_Vst_IParamValueQueue_iid = SMTG_INLINE_UID (0x01263A18, 0xED074F6F, 0x98C9D356, 0x4686F9BA); + +/*---------------------------------------------------------------------------------------------------------------------- +Source: "pluginterfaces/vst/ivstparameterchanges.h", line 121 */ + +typedef struct Steinberg_Vst_IParameterChangesVtbl +{ + /* methods derived from "Steinberg_FUnknown": */ + Steinberg_tresult (SMTG_STDMETHODCALLTYPE* queryInterface) (void* thisInterface, const Steinberg_TUID iid, void** obj); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* addRef) (void* thisInterface); + Steinberg_uint32 (SMTG_STDMETHODCALLTYPE* release) (void* thisInterface); + + /* methods defined in "Steinberg_Vst_IParameterChanges": */ + Steinberg_int32 (SMTG_STDMETHODCALLTYPE* getParameterCount) (void* thisInterface); + struct Steinberg_Vst_IParamValueQueue* (SMTG_STDMETHODCALLTYPE* getParameterData) (void* thisInterface, Steinberg_int32 index); + struct Steinberg_Vst_IParamValueQueue* (SMTG_STDMETHODCALLTYPE* addParameterData) (void* thisInterface, const Steinberg_Vst_ParamID* id, Steinberg_int32* index); + +} Steinberg_Vst_IParameterChangesVtbl; + +typedef struct Steinberg_Vst_IParameterChanges +{ + struct Steinberg_Vst_IParameterChangesVtbl* lpVtbl; +} Steinberg_Vst_IParameterChanges; + +static const Steinberg_TUID Steinberg_Vst_IParameterChanges_iid = SMTG_INLINE_UID (0xA4779663, 0x0BB64A56, 0xB44384A8, 0x466FEB9D); + diff --git a/plugins/feature/denoiser/vst3effect.cpp b/plugins/feature/denoiser/vst3effect.cpp new file mode 100644 index 000000000..e5dc23e1f --- /dev/null +++ b/plugins/feature/denoiser/vst3effect.cpp @@ -0,0 +1,1415 @@ +/////////////////////////////////////////////////////////////////////////////////// +// Copyright (C) 2026 Jon Beniston, M7RCE // +// Some code by AI // +// // +// This program is free software; you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation as version 3 of the License, or // +// (at your option) any later version. // +// // +// This program is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License V3 for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with this program. If not, see . // +/////////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef QT_WIDGETS_LIB +#include +#include +#endif +#include +#include +#include +#include +#include +#ifdef Q_OS_LINUX +#include +#endif +#ifdef Q_OS_MAC +#include +#endif + +#include "vst3effect.h" +#include "vst3/vst3_c_api.h" + +namespace +{ +constexpr int kBlockSize = 512; + +#ifndef Q_OS_MAC +QString binaryPath(const QString &path) +{ + const QFileInfo info(path); + if (info.isFile()) + { + return info.absoluteFilePath(); + } + if (!info.isDir() || !path.endsWith(QLatin1String(".vst3"), Qt::CaseInsensitive)) + { + return {}; + } + const QDir bundle(path); + const QString name = info.fileName(); +#ifdef Q_OS_WIN +#if defined(Q_PROCESSOR_X86_64) + const QString arch = QStringLiteral("x86_64-win"); +#elif defined(Q_PROCESSOR_ARM_64) + const QString arch = QStringLiteral("arm64-win"); +#else + const QString arch = QStringLiteral("x86-win"); +#endif + const QString candidate = bundle.filePath(QStringLiteral("Contents/%1/%2").arg(arch, name)); +#elif defined(Q_OS_LINUX) +#if defined(Q_PROCESSOR_X86_64) + const QString arch = QStringLiteral("x86_64-linux"); +#else + const QString arch = QStringLiteral("%1-linux").arg(QSysInfo::currentCpuArchitecture()); +#endif + QString binaryName = name; + binaryName.chop(5); // Remove the .vst3 bundle extension. + const QString candidate = bundle.filePath(QStringLiteral("Contents/%1/%2.so").arg(arch, binaryName)); +#else + return {}; +#endif + if (QFileInfo::exists(candidate)) + { + return candidate; + } + return {}; +} +#endif + +struct Module +{ +#ifdef Q_OS_MAC + CFBundleRef bundle = nullptr; +#else + QLibrary library; +#endif + Steinberg_IPluginFactory *factory = nullptr; + using Exit = bool (*)(); + Exit exit = nullptr; + bool entered = false; +#ifdef Q_OS_LINUX + void *nativeHandle = nullptr; +#endif + + bool load(const QString &path, QString &error) + { +#ifdef Q_OS_MAC + const QFileInfo info(path); + if (!info.isDir() || !path.endsWith(QLatin1String(".vst3"), Qt::CaseInsensitive)) + { + error = QStringLiteral("VST3 bundle was not found in %1").arg(path); + return false; + } + const QByteArray utf8Path = info.absoluteFilePath().toUtf8(); + CFStringRef cfPath = + CFStringCreateWithCString(kCFAllocatorDefault, utf8Path.constData(), kCFStringEncodingUTF8); + if (!cfPath) + { + error = QStringLiteral("Invalid VST3 bundle path: %1").arg(path); + return false; + } + CFURLRef url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, cfPath, kCFURLPOSIXPathStyle, true); + CFRelease(cfPath); + if (!url) + { + error = QStringLiteral("Invalid VST3 bundle URL: %1").arg(path); + return false; + } + bundle = CFBundleCreate(kCFAllocatorDefault, url); + CFRelease(url); + if (!bundle || !CFBundleLoadExecutable(bundle)) + { + error = QStringLiteral("Could not load VST3 bundle: %1").arg(path); + close(); + return false; + } + auto entry = + reinterpret_cast(CFBundleGetFunctionPointerForName(bundle, CFSTR("bundleEntry"))); + exit = reinterpret_cast(CFBundleGetFunctionPointerForName(bundle, CFSTR("bundleExit"))); + if (!entry || !exit || !entry(bundle)) + { + error = QStringLiteral("VST3 bundleEntry failed or is missing"); + close(); + return false; + } + entered = true; + auto getFactory = reinterpret_cast( + CFBundleGetFunctionPointerForName(bundle, CFSTR("GetPluginFactory"))); +#else + const QString binary = binaryPath(path); + if (binary.isEmpty()) + { + error = QStringLiteral("VST3 binary was not found in %1").arg(path); + return false; + } + library.setFileName(binary); + if (!library.load()) + { + error = library.errorString(); + return false; + } +#ifdef Q_OS_WIN + auto entry = reinterpret_cast(library.resolve("InitDll")); + exit = reinterpret_cast(library.resolve("ExitDll")); + if (entry) + { + if (!entry()) + { + error = QStringLiteral("VST3 InitDll failed"); + close(); + return false; + } + entered = true; + } +#elif defined(Q_OS_LINUX) + auto entry = reinterpret_cast(library.resolve("ModuleEntry")); + exit = reinterpret_cast(library.resolve("ModuleExit")); + // VST3 requires the dlopen handle in ModuleEntry; QLibrary does not expose it. + nativeHandle = dlopen(binary.toLocal8Bit().constData(), RTLD_NOW | RTLD_LOCAL); + if (!entry || !exit || !nativeHandle || !entry(nativeHandle)) + { + error = QStringLiteral("VST3 ModuleEntry failed or is missing"); + close(); + return false; + } + entered = true; +#endif + auto getFactory = reinterpret_cast(library.resolve("GetPluginFactory")); +#endif + factory = getFactory ? getFactory() : nullptr; + if (!factory) + { + error = QStringLiteral("VST3 GetPluginFactory failed"); + close(); + return false; + } + return true; + } + + void close() + { + if (factory) + { + factory->lpVtbl->release(factory); + factory = nullptr; + } + if (exit && entered) + { + exit(); + } + exit = nullptr; + entered = false; +#ifdef Q_OS_LINUX + if (nativeHandle) + { + dlclose(nativeHandle); + nativeHandle = nullptr; + } +#endif +#ifdef Q_OS_MAC + if (bundle) + { + CFBundleUnloadExecutable(bundle); + CFRelease(bundle); + bundle = nullptr; + } +#else + if (library.isLoaded()) + { + library.unload(); + } +#endif + } + ~Module() + { + close(); + } +}; + +Steinberg_tresult SMTG_STDMETHODCALLTYPE hostQuery(void *self, const Steinberg_TUID iid, void **obj) +{ + if (!obj) + { + return Steinberg_kInvalidArgument; + } + if (std::memcmp(iid, Steinberg_FUnknown_iid, 16) == 0 || + std::memcmp(iid, Steinberg_Vst_IHostApplication_iid, 16) == 0) + { + *obj = self; + return Steinberg_kResultOk; + } + *obj = nullptr; + return Steinberg_kNoInterface; +} + +Steinberg_uint32 SMTG_STDMETHODCALLTYPE hostAddRef(void *) +{ + return 1; +} + +Steinberg_uint32 SMTG_STDMETHODCALLTYPE hostRelease(void *) +{ + return 1; +} + +Steinberg_tresult SMTG_STDMETHODCALLTYPE hostName(void *, Steinberg_Vst_String128 name) +{ + constexpr char16_t text[] = u"SDRangel"; + std::memset(name, 0, 128 * sizeof(Steinberg_Vst_TChar)); + std::memcpy(name, text, sizeof(text)); + return Steinberg_kResultOk; +} + +Steinberg_tresult SMTG_STDMETHODCALLTYPE hostCreate(void *, Steinberg_TUID, Steinberg_TUID, void **obj) +{ + if (obj) + { + *obj = nullptr; + } + return Steinberg_kNoInterface; +} +Steinberg_Vst_IHostApplicationVtbl hostVtbl = {hostQuery, hostAddRef, hostRelease, hostName, hostCreate}; +Steinberg_Vst_IHostApplication host = {&hostVtbl}; + +struct ComponentHandler +{ + Steinberg_Vst_IComponentHandler iface; + std::function queue; // Forwards editor edits to this instance's processor. + std::function onEdit; +}; + +Steinberg_tresult SMTG_STDMETHODCALLTYPE handlerQuery(void *self, const Steinberg_TUID iid, void **obj) +{ + if (!obj) + { + return Steinberg_kInvalidArgument; + } + if (std::memcmp(iid, Steinberg_FUnknown_iid, 16) == 0 || + std::memcmp(iid, Steinberg_Vst_IComponentHandler_iid, 16) == 0) + { + *obj = self; + return Steinberg_kResultOk; + } + *obj = nullptr; + return Steinberg_kNoInterface; +} +Steinberg_tresult SMTG_STDMETHODCALLTYPE handlerEdit(void *, Steinberg_Vst_ParamID) +{ + return Steinberg_kResultOk; +} +Steinberg_tresult SMTG_STDMETHODCALLTYPE handlerPerformEdit(void *self, Steinberg_Vst_ParamID id, + Steinberg_Vst_ParamValue value) +{ + auto *componentHandler = static_cast(self); + if (!std::isfinite(value) || value < 0.0 || value > 1.0) + { + return Steinberg_kInvalidArgument; + } + if (componentHandler->queue) + { + componentHandler->queue(id, value); + } + if (componentHandler->onEdit) + { + componentHandler->onEdit(id, value); + } + return Steinberg_kResultOk; +} +Steinberg_tresult SMTG_STDMETHODCALLTYPE handlerRestart(void *, Steinberg_int32) +{ + return Steinberg_kResultOk; +} +Steinberg_Vst_IComponentHandlerVtbl handlerVtbl = {handlerQuery, hostAddRef, hostRelease, handlerEdit, + handlerPerformEdit, handlerEdit, handlerRestart}; + +#ifdef QT_WIDGETS_LIB +struct EditorFrame +{ + Steinberg_IPlugFrame iface; + std::function resize; +}; + +Steinberg_tresult SMTG_STDMETHODCALLTYPE frameQuery(void *self, const Steinberg_TUID iid, void **obj) +{ + if (!obj) + { + return Steinberg_kInvalidArgument; + } + if (std::memcmp(iid, Steinberg_FUnknown_iid, 16) == 0 || std::memcmp(iid, Steinberg_IPlugFrame_iid, 16) == 0) + { + *obj = self; + return Steinberg_kResultOk; + } + *obj = nullptr; + return Steinberg_kNoInterface; +} + +Steinberg_tresult SMTG_STDMETHODCALLTYPE frameResize(void *self, Steinberg_IPlugView *view, Steinberg_ViewRect *size) +{ + auto *frame = static_cast(self); + return frame->resize ? frame->resize(view, size) : Steinberg_kResultFalse; +} + +Steinberg_IPlugFrameVtbl frameVtbl = {frameQuery, hostAddRef, hostRelease, frameResize}; +#endif + +bool ok(Steinberg_tresult status) +{ + return status == Steinberg_kResultOk; +} + +struct ParameterPoint +{ + Steinberg_Vst_IParamValueQueue iface; + Steinberg_Vst_ParamID id; + Steinberg_Vst_ParamValue value; +}; +struct ParameterChanges +{ + Steinberg_Vst_IParameterChanges iface; + ParameterPoint points[128]; + int count = 0; +}; +Steinberg_tresult SMTG_STDMETHODCALLTYPE pointQuery(void *self, const Steinberg_TUID iid, void **obj) +{ + if (!obj) + { + return Steinberg_kInvalidArgument; + } + if (std::memcmp(iid, Steinberg_FUnknown_iid, 16) == 0 || + std::memcmp(iid, Steinberg_Vst_IParamValueQueue_iid, 16) == 0) + { + *obj = self; + return Steinberg_kResultOk; + } + *obj = nullptr; + return Steinberg_kNoInterface; +} +Steinberg_Vst_ParamID SMTG_STDMETHODCALLTYPE paramId(void *self) +{ + return static_cast(self)->id; +} +Steinberg_int32 SMTG_STDMETHODCALLTYPE pointCount(void *) +{ + return 1; +} +Steinberg_tresult SMTG_STDMETHODCALLTYPE getPoint(void *self, Steinberg_int32 index, Steinberg_int32 *offset, + Steinberg_Vst_ParamValue *value) +{ + if (index != 0 || !offset || !value) + { + return Steinberg_kInvalidArgument; + } + *offset = 0; + *value = static_cast(self)->value; + return Steinberg_kResultOk; +} +Steinberg_tresult SMTG_STDMETHODCALLTYPE addPoint(void *, Steinberg_int32, Steinberg_Vst_ParamValue, Steinberg_int32 *) +{ + return Steinberg_kNotImplemented; +} +Steinberg_Vst_IParamValueQueueVtbl pointVtbl = {pointQuery, hostAddRef, hostRelease, paramId, + pointCount, getPoint, addPoint}; +Steinberg_tresult SMTG_STDMETHODCALLTYPE changesQuery(void *self, const Steinberg_TUID iid, void **obj) +{ + if (!obj) + { + return Steinberg_kInvalidArgument; + } + if (std::memcmp(iid, Steinberg_FUnknown_iid, 16) == 0 || + std::memcmp(iid, Steinberg_Vst_IParameterChanges_iid, 16) == 0) + { + *obj = self; + return Steinberg_kResultOk; + } + *obj = nullptr; + return Steinberg_kNoInterface; +} +Steinberg_int32 SMTG_STDMETHODCALLTYPE changeCount(void *self) +{ + return static_cast(self)->count; +} +Steinberg_Vst_IParamValueQueue *SMTG_STDMETHODCALLTYPE parameterData(void *self, Steinberg_int32 index) +{ + auto *changes = static_cast(self); + return index >= 0 && index < changes->count ? &changes->points[index].iface : nullptr; +} +Steinberg_Vst_IParamValueQueue *SMTG_STDMETHODCALLTYPE addParameterData(void *, const Steinberg_Vst_ParamID *, + Steinberg_int32 *) +{ + return nullptr; +} +Steinberg_Vst_IParameterChangesVtbl changesVtbl = {changesQuery, hostAddRef, hostRelease, + changeCount, parameterData, addParameterData}; + +// In-memory IBStream used to save and restore component and controller state. +struct MemoryStream +{ + Steinberg_IBStream iface; + QByteArray data; + qint64 position = 0; +}; + +Steinberg_tresult SMTG_STDMETHODCALLTYPE streamQuery(void *self, const Steinberg_TUID iid, void **obj) +{ + if (!obj) { + return Steinberg_kInvalidArgument; + } + if (std::memcmp(iid, Steinberg_FUnknown_iid, 16) == 0 || std::memcmp(iid, Steinberg_IBStream_iid, 16) == 0) + { + *obj = self; + return Steinberg_kResultOk; + } + *obj = nullptr; + return Steinberg_kNoInterface; +} + +Steinberg_tresult SMTG_STDMETHODCALLTYPE streamRead(void *self, void *buffer, Steinberg_int32 numBytes, + Steinberg_int32 *numBytesRead) +{ + auto *stream = static_cast(self); + if (!buffer || numBytes < 0) { + return Steinberg_kInvalidArgument; + } + const qint64 available = std::max(0, stream->data.size() - stream->position); + const Steinberg_int32 count = static_cast(std::min(numBytes, available)); + if (count > 0) + { + std::memcpy(buffer, stream->data.constData() + stream->position, count); + stream->position += count; + } + if (numBytesRead) { + *numBytesRead = count; + } + return Steinberg_kResultOk; +} + +Steinberg_tresult SMTG_STDMETHODCALLTYPE streamWrite(void *self, void *buffer, Steinberg_int32 numBytes, + Steinberg_int32 *numBytesWritten) +{ + auto *stream = static_cast(self); + const qint64 end = stream->position + numBytes; + if (!buffer || numBytes < 0 || end > 0x7fffffff) { + return Steinberg_kInvalidArgument; + } + if (end > stream->data.size()) { + stream->data.resize(static_cast(end)); + } + std::memcpy(stream->data.data() + stream->position, buffer, numBytes); + stream->position = end; + if (numBytesWritten) { + *numBytesWritten = numBytes; + } + return Steinberg_kResultOk; +} + +Steinberg_tresult SMTG_STDMETHODCALLTYPE streamSeek(void *self, Steinberg_int64 pos, Steinberg_int32 mode, + Steinberg_int64 *result) +{ + auto *stream = static_cast(self); + qint64 position = pos; + if (mode == Steinberg_IBStream_IStreamSeekMode_kIBSeekCur) { + position += stream->position; + } else if (mode == Steinberg_IBStream_IStreamSeekMode_kIBSeekEnd) { + position += stream->data.size(); + } else if (mode != Steinberg_IBStream_IStreamSeekMode_kIBSeekSet) { + return Steinberg_kInvalidArgument; + } + if (position < 0) { + return Steinberg_kInvalidArgument; + } + stream->position = position; + if (result) { + *result = position; + } + return Steinberg_kResultOk; +} + +Steinberg_tresult SMTG_STDMETHODCALLTYPE streamTell(void *self, Steinberg_int64 *pos) +{ + if (!pos) { + return Steinberg_kInvalidArgument; + } + *pos = static_cast(self)->position; + return Steinberg_kResultOk; +} + +Steinberg_IBStreamVtbl streamVtbl = {streamQuery, hostAddRef, hostRelease, streamRead, + streamWrite, streamSeek, streamTell}; + +MemoryStream makeStream(const QByteArray &data = QByteArray()) +{ + MemoryStream stream; + stream.iface.lpVtbl = &streamVtbl; + stream.data = data; + return stream; +} + +// Saved state container: magic, version, class ID, component state, controller state. +constexpr quint32 kStateMagic = 0x53565354; +constexpr quint32 kStateVersion = 1; +} // namespace + +struct Vst3Effect::Impl +{ + Module module; + QByteArray classId; + ComponentHandler handler = {{&handlerVtbl}, {}}; + std::function detachEditor; + Steinberg_Vst_IComponent *component = nullptr; + Steinberg_Vst_IAudioProcessor *processor = nullptr; + Steinberg_Vst_IEditController *controller = nullptr; + Steinberg_Vst_IConnectionPoint *componentConnection = nullptr; + Steinberg_Vst_IConnectionPoint *controllerConnection = nullptr; + bool componentConnected = false; + bool controllerConnected = false; + bool controllerInitialized = false; + QVector parameterInfos; + QMutex parameterMutex; + ParameterPoint pending[128] = {}; + int pendingCount = 0; + bool initialized = false; + bool active = false; + bool processing = false; + int inputChannels = 0; + int outputChannels = 0; + int sourceChannels = 0; + int inputBusCount = 0; + int outputBusCount = 0; + bool sample64 = false; + double sampleRate = 0.0; + Steinberg_Vst_TSamples processedSamples = 0; + double input64[2][kBlockSize] = {}; + double output64[2][kBlockSize] = {}; + float monoInput[kBlockSize] = {}; + + bool queueParameter(quint32 id, double value) + { + QMutexLocker lock(¶meterMutex); + for (int i = 0; i < pendingCount; ++i) + { + if (pending[i].id == id) + { + pending[i].value = value; + return true; + } + } + if (pendingCount >= 128) + { + return false; + } + pending[pendingCount].id = id; + pending[pendingCount].value = value; + ++pendingCount; + return true; + } + + void close() + { + if (detachEditor) + { + auto detach = std::move(detachEditor); + detach(); + } + if (processor && processing) + { + processor->lpVtbl->setProcessing(processor, 0); + } + processing = false; + if (component && active) + { + component->lpVtbl->setActive(component, 0); + } + active = false; + if (processor) + { + processor->lpVtbl->release(processor); + processor = nullptr; + } + if (controllerConnection && controllerConnected) + { + controllerConnection->lpVtbl->disconnect(controllerConnection, componentConnection); + } + if (componentConnection && componentConnected) + { + componentConnection->lpVtbl->disconnect(componentConnection, controllerConnection); + } + controllerConnected = false; + componentConnected = false; + if (controllerConnection) + { + controllerConnection->lpVtbl->release(controllerConnection); + controllerConnection = nullptr; + } + if (componentConnection) + { + componentConnection->lpVtbl->release(componentConnection); + componentConnection = nullptr; + } + if (controller) + { + controller->lpVtbl->setComponentHandler(controller, nullptr); + if (controllerInitialized) + { + controller->lpVtbl->terminate(controller); + } + controller->lpVtbl->release(controller); + controller = nullptr; + } + controllerInitialized = false; + parameterInfos.clear(); + pendingCount = 0; + if (component) + { + if (initialized) + { + component->lpVtbl->terminate(component); + } + component->lpVtbl->release(component); + component = nullptr; + } + initialized = false; + classId.clear(); + module.close(); + } + ~Impl() + { + close(); + } +}; + +#ifdef QT_WIDGETS_LIB +class Vst3Effect::EditorWidget : public QWidget +{ +public: + EditorWidget(Vst3Effect *effect, QWidget *parent) : QWidget(parent), m_effect(effect) + { + setAttribute(Qt::WA_NativeWindow); + setFocusPolicy(Qt::StrongFocus); + m_frame.iface.lpVtbl = &frameVtbl; + m_frame.resize = [this](Steinberg_IPlugView *view, Steinberg_ViewRect *size) + { + return resizeFromPlugin(view, size); + }; + } + + ~EditorWidget() override + { + detach(); + m_effect->m_impl->detachEditor = {}; + } + + bool attach(QString &error) + { + auto &impl = *m_effect->m_impl; + if (!impl.controller) + { + error = QStringLiteral("VST3 effect has no editor controller"); + return false; + } + + const char *platformType = nullptr; +#ifdef Q_OS_WIN + platformType = Steinberg_kPlatformTypeHWND; +#elif defined(Q_OS_MAC) + platformType = Steinberg_kPlatformTypeNSView; +#elif defined(Q_OS_LINUX) + if (QGuiApplication::platformName() == QLatin1String("xcb")) + { + platformType = Steinberg_kPlatformTypeX11EmbedWindowID; + } +#endif + if (!platformType) + { + error = QStringLiteral("No native VST3 editor window is available on this display"); + return false; + } + + m_view = impl.controller->lpVtbl->createView(impl.controller, Steinberg_Vst_ViewType_kEditor); + if (!m_view) + { + error = QStringLiteral("This VST3 effect has no custom editor"); + return false; + } + if (!ok(m_view->lpVtbl->isPlatformTypeSupported(m_view, platformType))) + { + error = QStringLiteral("This VST3 editor does not support the current window system"); + detach(); + return false; + } + + Steinberg_IPlugViewContentScaleSupport *scaleSupport = nullptr; + if (ok(m_view->lpVtbl->queryInterface(m_view, Steinberg_IPlugViewContentScaleSupport_iid, + reinterpret_cast(&scaleSupport))) && + scaleSupport) + { + scaleSupport->lpVtbl->setContentScaleFactor(scaleSupport, static_cast(devicePixelRatioF())); + scaleSupport->lpVtbl->release(scaleSupport); + } + + Steinberg_ViewRect size = {}; + if (!ok(m_view->lpVtbl->getSize(m_view, &size)) || size.right <= size.left || size.bottom <= size.top) + { + size = {0, 0, 640, 400}; + } + const qreal scale = nativeScale(); + setFixedSize(qMax(1, qRound((size.right - size.left) / scale)), + qMax(1, qRound((size.bottom - size.top) / scale))); + if (!ok(m_view->lpVtbl->setFrame(m_view, &m_frame.iface))) + { + error = QStringLiteral("VST3 editor rejected the host window frame"); + detach(); + return false; + } + + void *nativeParent = reinterpret_cast(static_cast(winId())); + m_attached = true; // attached() may request a resize before it returns. + if (!ok(m_view->lpVtbl->attached(m_view, nativeParent, platformType))) + { + error = QStringLiteral("VST3 editor could not attach to the host window"); + detach(); + return false; + } + impl.detachEditor = [this]() + { + detach(); + }; + return true; + } + +private: + qreal nativeScale() const + { +#ifdef Q_OS_MAC + return 1.0; // NSView coordinates are logical points. +#else + return devicePixelRatioF(); // HWND and X11 coordinates are physical pixels. +#endif + } + + Steinberg_tresult resizeFromPlugin(Steinberg_IPlugView *view, Steinberg_ViewRect *size) + { + if (!m_attached || view != m_view || !size || m_resizing || size->right <= size->left || + size->bottom <= size->top) + { + return Steinberg_kResultFalse; + } + m_resizing = true; + const qreal scale = nativeScale(); + setFixedSize(qMax(1, qRound((size->right - size->left) / scale)), + qMax(1, qRound((size->bottom - size->top) / scale))); + const Steinberg_tresult result = m_view->lpVtbl->onSize(m_view, size); + updateGeometry(); + m_resizing = false; + return result; + } + + void detach() + { + if (!m_view) + { + return; + } + Steinberg_IPlugView *view = m_view; + m_view = nullptr; + m_frame.resize = {}; + if (m_attached) + { + view->lpVtbl->removed(view); + } + m_attached = false; + view->lpVtbl->setFrame(view, nullptr); + view->lpVtbl->release(view); + } + + Vst3Effect *m_effect; + EditorFrame m_frame = {}; + Steinberg_IPlugView *m_view = nullptr; + bool m_attached = false; + bool m_resizing = false; +}; +#endif + +Vst3Effect::Vst3Effect() : m_impl(new Impl) +{ + Impl *impl = m_impl.get(); + m_impl->handler.queue = [impl](quint32 id, double value) + { + impl->queueParameter(id, value); + }; +} + +Vst3Effect::~Vst3Effect() +{ + close(); +} + +QStringList Vst3Effect::modulePaths(const QStringList &extraPaths) +{ + QStringList paths = extraPaths; + if (paths.isEmpty()) + { +#ifdef Q_OS_WIN + paths << QDir(qEnvironmentVariable("ProgramFiles")).filePath(QStringLiteral("Common Files/VST3")); + paths << QDir(qEnvironmentVariable("LOCALAPPDATA")).filePath(QStringLiteral("Programs/Common/VST3")); + paths << QDir(QCoreApplication::applicationDirPath()).filePath(QStringLiteral("VST3")); +#elif defined(Q_OS_LINUX) + paths << QDir::home().filePath(QStringLiteral(".vst3")) << QStringLiteral("/usr/lib/vst3") + << QStringLiteral("/usr/lib64/vst3") << QStringLiteral("/usr/local/lib/vst3") + << QStringLiteral("/usr/local/lib64/vst3"); + paths << QDir(QCoreApplication::applicationDirPath()).filePath(QStringLiteral("vst3")); +#elif defined(Q_OS_MAC) + paths << QDir::home().filePath(QStringLiteral("Library/Audio/Plug-ins/VST3")) + << QStringLiteral("/Library/Audio/Plug-ins/VST3") + << QStringLiteral("/Network/Library/Audio/Plug-ins/VST3"); + paths << QDir(QCoreApplication::applicationDirPath()).filePath(QStringLiteral("../VST3")); +#endif + } + QStringList modules; + std::function collect = [&](const QString &path) + { + const QFileInfo info(path); + if (!info.exists()) + { + return; + } + if (path.endsWith(QLatin1String(".vst3"), Qt::CaseInsensitive) && (info.isFile() || info.isDir())) + { + modules << info.absoluteFilePath(); + return; + } + if (!info.isDir() || info.isSymLink()) + { + return; + } + const QFileInfoList entries = QDir(path).entryInfoList(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot); + for (const QFileInfo &child : entries) + { + collect(child.absoluteFilePath()); + } + }; + for (const QString &path : paths) + { + collect(path); + } + modules.removeDuplicates(); + return modules; +} + +QVector Vst3Effect::discover(const QStringList &extraPaths) +{ + QVector result; + for (const QString &path : modulePaths(extraPaths)) + { + Module module; + QString error; + if (!module.load(path, error)) + { + continue; + } + const int count = module.factory->lpVtbl->countClasses(module.factory); + for (int i = 0; i < count; ++i) + { + Steinberg_PClassInfo info = {}; + if (!ok(module.factory->lpVtbl->getClassInfo(module.factory, i, &info))) + { + continue; + } + if (QByteArray(info.category, sizeof(info.category)).split('\0').first().trimmed() != "Audio Module Class") + { + continue; + } + Vst3PluginInfo plugin; + plugin.modulePath = path; + plugin.classId = QByteArray(info.cid, 16); + plugin.name = QString::fromUtf8(QByteArray(info.name, sizeof(info.name)).split('\0').first()); + result.append(plugin); + } + } + std::sort(result.begin(), result.end(), + [](const auto &a, const auto &b) + { + return a.name < b.name; + }); + return result; +} + +bool Vst3Effect::open(const QString &modulePath, const QByteArray &classId, int sampleRate, int sourceChannels, + QString &error, const QByteArray &state) +{ + close(); + if (classId.size() != 16 || sampleRate <= 0 || (sourceChannels != 1 && sourceChannels != 2)) + { + error = QStringLiteral("Invalid VST3 selection or audio format"); + return false; + } + auto &v = *m_impl; + if (!v.module.load(modulePath, error)) + { + return false; + } + if (!ok(v.module.factory->lpVtbl->createInstance(v.module.factory, classId.constData(), + Steinberg_Vst_IComponent_iid, + reinterpret_cast(&v.component))) || + !v.component) + { + error = QStringLiteral("VST3 effect component could not be created"); + close(); + return false; + } + if (!ok(v.component->lpVtbl->initialize(v.component, reinterpret_cast(&host)))) + { + error = QStringLiteral("VST3 effect initialization failed"); + close(); + return false; + } + v.initialized = true; + v.classId = classId; + if (!ok(v.component->lpVtbl->queryInterface(v.component, Steinberg_Vst_IAudioProcessor_iid, + reinterpret_cast(&v.processor))) || + !v.processor) + { + error = QStringLiteral("Selected VST3 class has no audio processor"); + close(); + return false; + } + const auto controllerQuery = v.component->lpVtbl->queryInterface(v.component, Steinberg_Vst_IEditController_iid, + reinterpret_cast(&v.controller)); + if (!ok(controllerQuery) || !v.controller) + { + Steinberg_TUID controllerId = {}; + const auto idStatus = v.component->lpVtbl->getControllerClassId(v.component, controllerId); + const auto createStatus = ok(idStatus) ? v.module.factory->lpVtbl->createInstance( + v.module.factory, controllerId, Steinberg_Vst_IEditController_iid, + reinterpret_cast(&v.controller)) + : idStatus; + if (ok(idStatus) && ok(createStatus) && v.controller) + { + const auto initStatus = + v.controller->lpVtbl->initialize(v.controller, reinterpret_cast(&host)); + if (ok(initStatus)) + { + v.controllerInitialized = true; + } + else + { + v.controller->lpVtbl->release(v.controller); + v.controller = nullptr; + } + } + } + if (v.controller) + { + v.controller->lpVtbl->setComponentHandler(v.controller, &v.handler.iface); + if (v.controllerInitialized) + { + v.component->lpVtbl->queryInterface(v.component, Steinberg_Vst_IConnectionPoint_iid, + reinterpret_cast(&v.componentConnection)); + v.controller->lpVtbl->queryInterface(v.controller, Steinberg_Vst_IConnectionPoint_iid, + reinterpret_cast(&v.controllerConnection)); + if (v.componentConnection && v.controllerConnection) + { + const auto status1 = + v.componentConnection->lpVtbl->connect(v.componentConnection, v.controllerConnection); + const auto status2 = + v.controllerConnection->lpVtbl->connect(v.controllerConnection, v.componentConnection); + v.componentConnected = ok(status1); + v.controllerConnected = ok(status2); + } + } + } + if (!state.isEmpty()) + { + // Restore before reading parameters, so they reflect the saved state. + QString stateError; + if (!setState(state, stateError)) { + qWarning("Vst3Effect::open: %s", qPrintable(stateError)); + } + } + if (v.controller) + { + const int count = std::max(0, std::min(4096, v.controller->lpVtbl->getParameterCount(v.controller))); + for (int i = 0; i < count; ++i) + { + Steinberg_Vst_ParameterInfo info = {}; + if (!ok(v.controller->lpVtbl->getParameterInfo(v.controller, i, &info))) + { + continue; + } + Vst3ParameterInfo parameter; + parameter.id = info.id; + parameter.name = + QString::fromUtf16(reinterpret_cast(info.title), 128).split(QChar(0)).first(); + parameter.defaultValue = info.defaultNormalizedValue; + const double current = v.controller->lpVtbl->getParamNormalized(v.controller, info.id); + parameter.currentValue = + std::isfinite(current) && current >= 0.0 && current <= 1.0 ? current : parameter.defaultValue; + parameter.steps = info.stepCount; + parameter.readOnly = (info.flags & Steinberg_Vst_ParameterInfo_ParameterFlags_kIsReadOnly) != 0; + parameter.hidden = (info.flags & Steinberg_Vst_ParameterInfo_ParameterFlags_kIsHidden) != 0; + v.parameterInfos.append(parameter); + } + } + v.inputBusCount = v.component->lpVtbl->getBusCount(v.component, Steinberg_Vst_MediaTypes_kAudio, + Steinberg_Vst_BusDirections_kInput); + v.outputBusCount = v.component->lpVtbl->getBusCount(v.component, Steinberg_Vst_MediaTypes_kAudio, + Steinberg_Vst_BusDirections_kOutput); + if (v.inputBusCount < 1 || v.inputBusCount > 16 || v.outputBusCount < 1 || v.outputBusCount > 16) + { + error = QStringLiteral("VST3 effect must have a main audio input and output bus"); + close(); + return false; + } + Steinberg_Vst_SpeakerArrangement arrangement = + sourceChannels == 1 ? Steinberg_Vst_SpeakerArr_kMono : Steinberg_Vst_SpeakerArr_kStereo; + v.processor->lpVtbl->setBusArrangements(v.processor, &arrangement, 1, &arrangement, 1); + Steinberg_Vst_BusInfo input = {}, output = {}; + if (!ok(v.component->lpVtbl->getBusInfo(v.component, Steinberg_Vst_MediaTypes_kAudio, + Steinberg_Vst_BusDirections_kInput, 0, &input)) || + !ok(v.component->lpVtbl->getBusInfo(v.component, Steinberg_Vst_MediaTypes_kAudio, + Steinberg_Vst_BusDirections_kOutput, 0, &output)) || + input.channelCount < 1 || input.channelCount > 2 || output.channelCount < 1 || output.channelCount > 2) + { + error = QStringLiteral("VST3 effect requires an unsupported bus layout"); + close(); + return false; + } + v.inputChannels = input.channelCount; + v.outputChannels = output.channelCount; + v.sourceChannels = sourceChannels; + v.sampleRate = sampleRate; + v.processedSamples = 0; + v.component->lpVtbl->activateBus(v.component, Steinberg_Vst_MediaTypes_kAudio, Steinberg_Vst_BusDirections_kInput, + 0, 1); + v.component->lpVtbl->activateBus(v.component, Steinberg_Vst_MediaTypes_kAudio, Steinberg_Vst_BusDirections_kOutput, + 0, 1); + for (int i = 1; i < v.inputBusCount; ++i) + { + v.component->lpVtbl->activateBus(v.component, Steinberg_Vst_MediaTypes_kAudio, + Steinberg_Vst_BusDirections_kInput, i, 0); + } + for (int i = 1; i < v.outputBusCount; ++i) + { + v.component->lpVtbl->activateBus(v.component, Steinberg_Vst_MediaTypes_kAudio, + Steinberg_Vst_BusDirections_kOutput, i, 0); + } + if (!ok(v.processor->lpVtbl->canProcessSampleSize(v.processor, Steinberg_Vst_SymbolicSampleSizes_kSample32))) + { + if (!ok(v.processor->lpVtbl->canProcessSampleSize(v.processor, Steinberg_Vst_SymbolicSampleSizes_kSample64))) + { + error = QStringLiteral("VST3 effect supports neither 32-bit nor 64-bit floating point audio"); + close(); + return false; + } + v.sample64 = true; + } + Steinberg_Vst_ProcessSetup setup = {Steinberg_Vst_ProcessModes_kRealtime, + v.sample64 ? Steinberg_Vst_SymbolicSampleSizes_kSample64 + : Steinberg_Vst_SymbolicSampleSizes_kSample32, + kBlockSize, static_cast(sampleRate)}; + if (!ok(v.processor->lpVtbl->setupProcessing(v.processor, &setup)) || + !ok(v.component->lpVtbl->setActive(v.component, 1))) + { + error = QStringLiteral("VST3 effect processing setup failed"); + close(); + return false; + } + v.active = true; + if (!ok(v.processor->lpVtbl->setProcessing(v.processor, 1))) + { + error = QStringLiteral("VST3 effect could not start processing"); + close(); + return false; + } + v.processing = true; + return true; +} + +bool Vst3Effect::process(const float *left, const float *right, float *outLeft, float *outRight, int count, + QString &error) +{ + auto &v = *m_impl; + if (!v.processing || count < 1 || count > kBlockSize) + { + error = QStringLiteral("VST3 effect is not ready"); + return false; + } + if (v.inputChannels == 1 && v.sourceChannels == 2 && right) + { + for (int i = 0; i < count; ++i) + { + v.monoInput[i] = 0.5f * (left[i] + right[i]); + } + } + const float *firstInput = v.inputChannels == 1 && v.sourceChannels == 2 && right ? v.monoInput : left; + float *in32[] = {const_cast(firstInput), const_cast(right ? right : left)}; + float *out32[] = {outLeft, outRight}; + double *in64[] = {v.input64[0], v.input64[1]}; + double *out64[] = {v.output64[0], v.output64[1]}; + if (v.sample64) + { + for (int i = 0; i < count; ++i) + { + v.input64[0][i] = firstInput[i]; + v.input64[1][i] = right ? right[i] : left[i]; + } + } + Steinberg_Vst_AudioBusBuffers inputs[16] = {}, outputs[16] = {}; + inputs[0].numChannels = v.inputChannels; + outputs[0].numChannels = v.outputChannels; + if (v.sample64) + { + inputs[0].Steinberg_Vst_AudioBusBuffers_channelBuffers64 = in64; + outputs[0].Steinberg_Vst_AudioBusBuffers_channelBuffers64 = out64; + } + else + { + inputs[0].Steinberg_Vst_AudioBusBuffers_channelBuffers32 = in32; + outputs[0].Steinberg_Vst_AudioBusBuffers_channelBuffers32 = out32; + } + Steinberg_Vst_ProcessData data = {}; + ParameterChanges changes = {}; + changes.iface.lpVtbl = &changesVtbl; + { + QMutexLocker lock(&v.parameterMutex); + changes.count = v.pendingCount; + for (int i = 0; i < changes.count; ++i) + { + changes.points[i] = v.pending[i]; + changes.points[i].iface.lpVtbl = &pointVtbl; + } + v.pendingCount = 0; + } + data.processMode = Steinberg_Vst_ProcessModes_kRealtime; + data.symbolicSampleSize = + v.sample64 ? Steinberg_Vst_SymbolicSampleSizes_kSample64 : Steinberg_Vst_SymbolicSampleSizes_kSample32; + data.numSamples = count; + data.numInputs = v.inputBusCount; + data.numOutputs = v.outputBusCount; + data.inputs = inputs; + data.outputs = outputs; + data.inputParameterChanges = &changes.iface; + Steinberg_Vst_ProcessContext context = {}; + context.state = Steinberg_Vst_ProcessContext_StatesAndFlags_kPlaying | + Steinberg_Vst_ProcessContext_StatesAndFlags_kContTimeValid; + context.sampleRate = v.sampleRate; + context.projectTimeSamples = v.processedSamples; + context.continousTimeSamples = v.processedSamples; + context.tempo = 120.0; + context.timeSigNumerator = 4; + context.timeSigDenominator = 4; + data.processContext = &context; + if (!ok(v.processor->lpVtbl->process(v.processor, &data))) + { + error = QStringLiteral("VST3 audio processing failed"); + return false; + } + v.processedSamples += count; + if (v.sample64) + { + for (int i = 0; i < count; ++i) + { + outLeft[i] = (outputs[0].silenceFlags & 1) ? 0.0f : static_cast(v.output64[0][i]); + outRight[i] = (outputs[0].silenceFlags & (v.outputChannels == 2 ? 2 : 1)) + ? 0.0f + : static_cast(v.output64[v.outputChannels == 2 ? 1 : 0][i]); + } + } + else + { + if (outputs[0].silenceFlags & 1) + { + std::fill(outLeft, outLeft + count, 0.0f); + } + if (v.outputChannels == 2) + { + if (outputs[0].silenceFlags & 2) + { + std::fill(outRight, outRight + count, 0.0f); + } + } + else + { + std::copy(outLeft, outLeft + count, outRight); + } + } + return true; +} + +void Vst3Effect::close() +{ + m_impl->close(); +} + +void Vst3Effect::setParameterEditCallback(std::function callback) +{ + m_impl->handler.onEdit = std::move(callback); +} + +#ifdef QT_WIDGETS_LIB +QWidget *Vst3Effect::createEditorWidget(QWidget *parent, QString &error) +{ + if (m_impl->detachEditor) + { + error = QStringLiteral("The VST3 editor is already open"); + return nullptr; + } + auto *widget = new EditorWidget(this, parent); + if (!widget->attach(error)) + { + delete widget; + return nullptr; + } + return widget; +} +#endif + +unsigned int Vst3Effect::latencySamples() const +{ + return m_impl->processor ? m_impl->processor->lpVtbl->getLatencySamples(m_impl->processor) : 0; +} + +QVector Vst3Effect::parameters() const +{ + return m_impl->parameterInfos; +} + +double Vst3Effect::parameterValue(quint32 id) const +{ + auto *controller = m_impl->controller; + const double value = controller ? controller->lpVtbl->getParamNormalized(controller, id) : -1.0; + return std::isfinite(value) && value >= 0.0 && value <= 1.0 ? value : -1.0; +} + +QByteArray Vst3Effect::state(QString &error) +{ + auto &v = *m_impl; + if (!v.component) + { + error = QStringLiteral("VST3 effect is not open"); + return QByteArray(); + } + bool pending = false; + { + QMutexLocker lock(&v.parameterMutex); + pending = v.pendingCount > 0; + } + if (pending && v.processing) + { + // Parameter changes reach the component only through process(), so deliver + // any queued edits with a silent block before asking it for its state. + float silence[2][kBlockSize] = {}; + float discard[2][kBlockSize]; + QString processError; + process(silence[0], silence[1], discard[0], discard[1], kBlockSize, processError); + } + MemoryStream componentState = makeStream(); + if (!ok(v.component->lpVtbl->getState(v.component, &componentState.iface))) + { + error = QStringLiteral("VST3 effect could not save its state"); + return QByteArray(); + } + MemoryStream controllerState = makeStream(); + if (v.controller && !ok(v.controller->lpVtbl->getState(v.controller, &controllerState.iface))) { + controllerState.data.clear(); // Controller state is optional. + } + QByteArray result; + QDataStream out(&result, QIODevice::WriteOnly); + out << kStateMagic << kStateVersion << v.classId << componentState.data << controllerState.data; + return result; +} + +bool Vst3Effect::setState(const QByteArray &state, QString &error) +{ + auto &v = *m_impl; + if (!v.component) + { + error = QStringLiteral("VST3 effect is not open"); + return false; + } + QDataStream in(state); + quint32 magic = 0, version = 0; + QByteArray classId, componentData, controllerData; + in >> magic >> version >> classId >> componentData >> controllerData; + if (in.status() != QDataStream::Ok || magic != kStateMagic || version != kStateVersion) + { + error = QStringLiteral("Saved VST3 state is invalid"); + return false; + } + if (classId != v.classId) + { + error = QStringLiteral("Saved VST3 state belongs to a different effect"); + return false; + } + MemoryStream componentState = makeStream(componentData); + if (!ok(v.component->lpVtbl->setState(v.component, &componentState.iface))) + { + error = QStringLiteral("VST3 effect rejected its saved state"); + return false; + } + if (v.controller) + { + // The host must mirror the component state into the controller. + MemoryStream mirroredState = makeStream(componentData); + v.controller->lpVtbl->setComponentState(v.controller, &mirroredState.iface); + if (!controllerData.isEmpty()) + { + MemoryStream controllerState = makeStream(controllerData); + v.controller->lpVtbl->setState(v.controller, &controllerState.iface); + } + } + return true; +} + +bool Vst3Effect::setParameter(quint32 id, double value) +{ + auto &v = *m_impl; + if (!v.controller || value < 0.0 || value > 1.0) + { + return false; + } + const auto parameter = std::find_if(v.parameterInfos.cbegin(), v.parameterInfos.cend(), + [id](const Vst3ParameterInfo &info) + { + return info.id == id && !info.readOnly; + }); + if (parameter == v.parameterInfos.cend()) + { + return false; + } + v.controller->lpVtbl->setParamNormalized(v.controller, id, value); + return v.queueParameter(id, value); +} + +QString Vst3Effect::parameterText(quint32 id, double value) const +{ + auto *controller = m_impl->controller; + if (controller) + { + Steinberg_Vst_String128 text = {}; + if (ok(controller->lpVtbl->getParamStringByValue(controller, id, value, text))) + { + const QString formatted = + QString::fromUtf16(reinterpret_cast(text), 128).split(QChar(0)).first(); + if (!formatted.isEmpty()) + { + return formatted; + } + } + } + return QString::number(value, 'f', 3); +} diff --git a/plugins/feature/denoiser/vst3effect.h b/plugins/feature/denoiser/vst3effect.h new file mode 100644 index 000000000..857292c64 --- /dev/null +++ b/plugins/feature/denoiser/vst3effect.h @@ -0,0 +1,87 @@ +/////////////////////////////////////////////////////////////////////////////////// +// Copyright (C) 2026 Jon Beniston, M7RCE // +// Some code by AI // +// // +// This program is free software; you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation as version 3 of the License, or // +// (at your option) any later version. // +// // +// This program is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License V3 for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with this program. If not, see . // +/////////////////////////////////////////////////////////////////////////////////// + +#ifndef INCLUDE_FEATURE_DENOISER_VST3EFFECT_H_ +#define INCLUDE_FEATURE_DENOISER_VST3EFFECT_H_ + +#include +#include +#include +#include +#include +#include +#include + +class QWidget; + +struct Vst3PluginInfo +{ + QString modulePath; + QByteArray classId; // The factory's 16-byte platform-specific class ID. + QString name; +}; + +struct Vst3ParameterInfo +{ + quint32 id; + QString name; + double defaultValue; + double currentValue; + int steps; + bool readOnly; + bool hidden; +}; + +// Owns one audio effect. Construct, configure and destroy on the feature thread; +// only process() is called by the audio worker while the instance is active. +class Vst3Effect +{ +public: + Vst3Effect(); + ~Vst3Effect(); + + static QVector discover(const QStringList& extraPaths = {}); + static QStringList modulePaths(const QStringList& extraPaths = {}); + // state is a blob from state(); it is ignored if it belongs to a different class. + bool open(const QString& modulePath, const QByteArray& classId, int sampleRate, + int sourceChannels, QString& error, const QByteArray& state = QByteArray()); + bool process(const float *left, const float *right, float *outLeft, float *outRight, + int count, QString& error); + void close(); + unsigned int latencySamples() const; + QVector parameters() const; + double parameterValue(quint32 id) const; + // Not safe while another thread calls process(); flushes queued parameter changes. + QByteArray state(QString& error); + bool setState(const QByteArray& state, QString& error); + bool setParameter(quint32 id, double value); + QString parameterText(quint32 id, double value) const; + void setParameterEditCallback(std::function callback); +#ifdef QT_WIDGETS_LIB + QWidget *createEditorWidget(QWidget *parent, QString& error); +#endif + +private: +#ifdef QT_WIDGETS_LIB + class EditorWidget; +#endif + struct Impl; + std::unique_ptr m_impl; +}; + +#endif diff --git a/plugins/feature/denoiser/vst3scan.cpp b/plugins/feature/denoiser/vst3scan.cpp new file mode 100644 index 000000000..1bbfa4c21 --- /dev/null +++ b/plugins/feature/denoiser/vst3scan.cpp @@ -0,0 +1,83 @@ +/////////////////////////////////////////////////////////////////////////////////// +// Copyright (C) 2026 Jon Beniston, M7RCE // +// Some code by AI // +// // +// This program is free software; you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation as version 3 of the License, or // +// (at your option) any later version. // +// // +// This program is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License V3 for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with this program. If not, see . // +/////////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include + +#include "vst3effect.h" + +int main(int argc, char **argv) +{ + QCoreApplication app(argc, argv); + QStringList paths = app.arguments().mid(1); + + const bool probe = !paths.isEmpty() && paths.first() == QStringLiteral("--probe"); + if (probe) { + paths.removeFirst(); + } + + QJsonArray plugins; + + if (probe) + { + for (const Vst3PluginInfo& plugin : Vst3Effect::discover(paths)) + { + QJsonObject object; + object.insert(QStringLiteral("path"), plugin.modulePath); + object.insert(QStringLiteral("id"), QString::fromLatin1(plugin.classId.toHex())); + object.insert(QStringLiteral("name"), plugin.name); + plugins.append(object); + + } + } + else + { + for (const QString& path : Vst3Effect::modulePaths(paths)) + { + QProcess child; + child.setProgram(app.applicationFilePath()); + child.setArguments({QStringLiteral("--probe"), path}); + child.start(); + if (!child.waitForStarted(5000)) { + continue; + } + if (!child.waitForFinished(60000)) + { + child.kill(); + child.waitForFinished(5000); + continue; + } + if (child.exitStatus() != QProcess::NormalExit || child.exitCode() != 0) + continue; + const QJsonDocument result = QJsonDocument::fromJson(child.readAllStandardOutput()); + if (!result.isArray()) { + continue; + } + for (const QJsonValue& value : result.array()) { + plugins.append(value); + } + } + } + const QByteArray json = QJsonDocument(plugins).toJson(QJsonDocument::Compact); + std::fwrite(json.constData(), 1, static_cast(json.size()), stdout); + return 0; +} diff --git a/sdrbase/maincore.cpp b/sdrbase/maincore.cpp index af5bba9bf..ea26fbe19 100644 --- a/sdrbase/maincore.cpp +++ b/sdrbase/maincore.cpp @@ -64,6 +64,7 @@ MESSAGE_CLASS_DEFINITION(MainCore::MsgDeleteFeature, Message) MESSAGE_CLASS_DEFINITION(MainCore::MsgChannelReport, Message) MESSAGE_CLASS_DEFINITION(MainCore::MsgChannelSettings, Message) MESSAGE_CLASS_DEFINITION(MainCore::MsgChannelDemodReport, Message) +MESSAGE_CLASS_DEFINITION(MainCore::MsgFeatureDemodReport, Message) MESSAGE_CLASS_DEFINITION(MainCore::MsgChannelDemodQuery, Message) MESSAGE_CLASS_DEFINITION(MainCore::MsgMoveDeviceUIToWorkspace, Message) MESSAGE_CLASS_DEFINITION(MainCore::MsgArrangeWorkspace, Message) diff --git a/sdrbase/maincore.h b/sdrbase/maincore.h index 9d459a0d5..767728fee 100644 --- a/sdrbase/maincore.h +++ b/sdrbase/maincore.h @@ -565,6 +565,28 @@ public: { } }; + class SDRBASE_API MsgFeatureDemodReport : public Message { + MESSAGE_CLASS_DECLARATION + + public: + const QObject *getFeature() const { return m_feature; } + int getSampleRate() const { return m_sampleRate; } + + static MsgFeatureDemodReport* create(const QObject *feature, int sampleRate) { + return new MsgFeatureDemodReport(feature, sampleRate); + } + + private: + const QObject *m_feature; + int m_sampleRate; + + MsgFeatureDemodReport(const QObject *feature, int sampleRate) : + Message(), + m_feature(feature), + m_sampleRate(sampleRate) + { } + }; + class SDRBASE_API MsgChannelSettings : public Message { MESSAGE_CLASS_DECLARATION diff --git a/sdrbase/resources/webapi/doc/swagger/include/Denoiser.yaml b/sdrbase/resources/webapi/doc/swagger/include/Denoiser.yaml index aaccaca88..a144cf351 100644 --- a/sdrbase/resources/webapi/doc/swagger/include/Denoiser.yaml +++ b/sdrbase/resources/webapi/doc/swagger/include/Denoiser.yaml @@ -9,6 +9,8 @@ DenoiserSettings: Denoiser type * 0 - none * 1 - RNnoise + * 2 - NVIDIA Noise Removal + * 3 - VST3 audio effect enableDenoiser: type: integer minimum: 0 @@ -17,6 +19,29 @@ DenoiserSettings: Enable denoiser * 1 - enable * 0 - disable + nvidiaIntensity: + type: integer + minimum: 0 + maximum: 100 + description: NVIDIA Noise Removal strength in percent + nvidiaVad: + type: integer + description: > + NVIDIA voice activity detection + * 1 - enable + * 0 - disable + vst3ModulePath: + type: string + description: Absolute path to the selected VST3 module or bundle + vst3ClassId: + type: string + description: 16-byte VST3 processor class ID encoded as hexadecimal + vst3Parameters: + type: string + description: JSON object mapping numeric VST3 parameter IDs to normalized values from 0 to 1 + vst3State: + type: string + description: Opaque VST3 component and controller state, base64 encoded volumeTenths: type: integer description: > diff --git a/swagger/sdrangel/api/swagger/include/Denoiser.yaml b/swagger/sdrangel/api/swagger/include/Denoiser.yaml index 1ac503b7f..d91c92915 100644 --- a/swagger/sdrangel/api/swagger/include/Denoiser.yaml +++ b/swagger/sdrangel/api/swagger/include/Denoiser.yaml @@ -9,6 +9,8 @@ DenoiserSettings: Denoiser type * 0 - none * 1 - RNnoise + * 2 - NVIDIA Noise Removal + * 3 - VST3 audio effect enableDenoiser: type: integer minimum: 0 @@ -17,6 +19,29 @@ DenoiserSettings: Enable denoiser * 1 - enable * 0 - disable + nvidiaIntensity: + type: integer + minimum: 0 + maximum: 100 + description: NVIDIA Noise Removal strength in percent + nvidiaVad: + type: integer + description: > + NVIDIA voice activity detection + * 1 - enable + * 0 - disable + vst3ModulePath: + type: string + description: Absolute path to the selected VST3 module or bundle + vst3ClassId: + type: string + description: 16-byte VST3 processor class ID encoded as hexadecimal + vst3Parameters: + type: string + description: JSON object mapping numeric VST3 parameter IDs to normalized values from 0 to 1 + vst3State: + type: string + description: Opaque VST3 component and controller state, base64 encoded volumeTenths: type: integer description: > diff --git a/swagger/sdrangel/code/qt5/client/SWGDenoiserSettings.cpp b/swagger/sdrangel/code/qt5/client/SWGDenoiserSettings.cpp index 0c154a9d2..15e1f6c12 100644 --- a/swagger/sdrangel/code/qt5/client/SWGDenoiserSettings.cpp +++ b/swagger/sdrangel/code/qt5/client/SWGDenoiserSettings.cpp @@ -32,6 +32,18 @@ SWGDenoiserSettings::SWGDenoiserSettings() { m_denoiser_type_isSet = false; enable_denoiser = 0; m_enable_denoiser_isSet = false; + nvidia_intensity = 0; + m_nvidia_intensity_isSet = false; + nvidia_vad = 0; + m_nvidia_vad_isSet = false; + vst3_module_path = nullptr; + m_vst3_module_path_isSet = false; + vst3_class_id = nullptr; + m_vst3_class_id_isSet = false; + vst3_parameters = nullptr; + m_vst3_parameters_isSet = false; + vst3_state = nullptr; + m_vst3_state_isSet = false; volume_tenths = 0; m_volume_tenths_isSet = false; audio_device_name = nullptr; @@ -70,6 +82,18 @@ SWGDenoiserSettings::init() { m_denoiser_type_isSet = false; enable_denoiser = 0; m_enable_denoiser_isSet = false; + nvidia_intensity = 0; + m_nvidia_intensity_isSet = false; + nvidia_vad = 0; + m_nvidia_vad_isSet = false; + vst3_module_path = new QString(""); + m_vst3_module_path_isSet = false; + vst3_class_id = new QString(""); + m_vst3_class_id_isSet = false; + vst3_parameters = new QString(""); + m_vst3_parameters_isSet = false; + vst3_state = new QString(""); + m_vst3_state_isSet = false; volume_tenths = 0; m_volume_tenths_isSet = false; audio_device_name = new QString(""); @@ -101,6 +125,11 @@ SWGDenoiserSettings::init() { void SWGDenoiserSettings::cleanup() { + if(vst3_module_path != nullptr) delete vst3_module_path; + if(vst3_class_id != nullptr) delete vst3_class_id; + if(vst3_parameters != nullptr) delete vst3_parameters; + if(vst3_state != nullptr) delete vst3_state; + if(audio_device_name != nullptr) { @@ -142,6 +171,14 @@ SWGDenoiserSettings::fromJsonObject(QJsonObject &pJson) { ::SWGSDRangel::setValue(&enable_denoiser, pJson["enableDenoiser"], "qint32", ""); + ::SWGSDRangel::setValue(&nvidia_intensity, pJson["nvidiaIntensity"], "qint32", ""); + + ::SWGSDRangel::setValue(&nvidia_vad, pJson["nvidiaVad"], "qint32", ""); + ::SWGSDRangel::setValue(&vst3_module_path, pJson["vst3ModulePath"], "QString", "QString"); + ::SWGSDRangel::setValue(&vst3_class_id, pJson["vst3ClassId"], "QString", "QString"); + ::SWGSDRangel::setValue(&vst3_parameters, pJson["vst3Parameters"], "QString", "QString"); + ::SWGSDRangel::setValue(&vst3_state, pJson["vst3State"], "QString", "QString"); + ::SWGSDRangel::setValue(&volume_tenths, pJson["volumeTenths"], "qint32", ""); ::SWGSDRangel::setValue(&audio_device_name, pJson["audioDeviceName"], "QString", "QString"); @@ -190,6 +227,24 @@ SWGDenoiserSettings::asJsonObject() { if(m_enable_denoiser_isSet){ obj->insert("enableDenoiser", QJsonValue(enable_denoiser)); } + if(m_nvidia_intensity_isSet){ + obj->insert("nvidiaIntensity", QJsonValue(nvidia_intensity)); + } + if(m_nvidia_vad_isSet){ + obj->insert("nvidiaVad", QJsonValue(nvidia_vad)); + } + if(vst3_module_path != nullptr && *vst3_module_path != QString("")){ + toJsonValue(QString("vst3ModulePath"), vst3_module_path, obj, QString("QString")); + } + if(vst3_class_id != nullptr && *vst3_class_id != QString("")){ + toJsonValue(QString("vst3ClassId"), vst3_class_id, obj, QString("QString")); + } + if(vst3_parameters != nullptr && *vst3_parameters != QString("")){ + toJsonValue(QString("vst3Parameters"), vst3_parameters, obj, QString("QString")); + } + if(vst3_state != nullptr && *vst3_state != QString("")){ + toJsonValue(QString("vst3State"), vst3_state, obj, QString("QString")); + } if(m_volume_tenths_isSet){ obj->insert("volumeTenths", QJsonValue(volume_tenths)); } @@ -253,6 +308,51 @@ SWGDenoiserSettings::setEnableDenoiser(qint32 enable_denoiser) { this->m_enable_denoiser_isSet = true; } +qint32 +SWGDenoiserSettings::getNvidiaIntensity() { + return nvidia_intensity; +} +void +SWGDenoiserSettings::setNvidiaIntensity(qint32 nvidia_intensity) { + this->nvidia_intensity = nvidia_intensity; + this->m_nvidia_intensity_isSet = true; +} + +qint32 +SWGDenoiserSettings::getNvidiaVad() { + return nvidia_vad; +} +void +SWGDenoiserSettings::setNvidiaVad(qint32 nvidia_vad) { + this->nvidia_vad = nvidia_vad; + this->m_nvidia_vad_isSet = true; +} + +QString* SWGDenoiserSettings::getVst3ModulePath() { return vst3_module_path; } +void SWGDenoiserSettings::setVst3ModulePath(QString* value) { + if (vst3_module_path != value) delete vst3_module_path; + vst3_module_path = value; + m_vst3_module_path_isSet = true; +} +QString* SWGDenoiserSettings::getVst3ClassId() { return vst3_class_id; } +void SWGDenoiserSettings::setVst3ClassId(QString* value) { + if (vst3_class_id != value) delete vst3_class_id; + vst3_class_id = value; + m_vst3_class_id_isSet = true; +} +QString* SWGDenoiserSettings::getVst3Parameters() { return vst3_parameters; } +void SWGDenoiserSettings::setVst3Parameters(QString* value) { + if (vst3_parameters != value) delete vst3_parameters; + vst3_parameters = value; + m_vst3_parameters_isSet = true; +} +QString* SWGDenoiserSettings::getVst3State() { return vst3_state; } +void SWGDenoiserSettings::setVst3State(QString* value) { + if (vst3_state != value) delete vst3_state; + vst3_state = value; + m_vst3_state_isSet = true; +} + qint32 SWGDenoiserSettings::getVolumeTenths() { return volume_tenths; @@ -394,6 +494,15 @@ SWGDenoiserSettings::isSet(){ if(m_enable_denoiser_isSet){ isObjectUpdated = true; break; } + if(m_nvidia_intensity_isSet){ + isObjectUpdated = true; break; + } + if(m_nvidia_vad_isSet){ + isObjectUpdated = true; break; + } + if(m_vst3_module_path_isSet || m_vst3_class_id_isSet || m_vst3_parameters_isSet || m_vst3_state_isSet){ + isObjectUpdated = true; break; + } if(m_volume_tenths_isSet){ isObjectUpdated = true; break; } @@ -437,4 +546,3 @@ SWGDenoiserSettings::isSet(){ return isObjectUpdated; } } - diff --git a/swagger/sdrangel/code/qt5/client/SWGDenoiserSettings.h b/swagger/sdrangel/code/qt5/client/SWGDenoiserSettings.h index 9fa837426..fbb4d7b5f 100644 --- a/swagger/sdrangel/code/qt5/client/SWGDenoiserSettings.h +++ b/swagger/sdrangel/code/qt5/client/SWGDenoiserSettings.h @@ -49,6 +49,22 @@ public: qint32 getEnableDenoiser(); void setEnableDenoiser(qint32 enable_denoiser); + qint32 getNvidiaIntensity(); + void setNvidiaIntensity(qint32 nvidia_intensity); + + qint32 getNvidiaVad(); + void setNvidiaVad(qint32 nvidia_vad); + + QString* getVst3ModulePath(); + void setVst3ModulePath(QString* vst3_module_path); + QString* getVst3ClassId(); + void setVst3ClassId(QString* vst3_class_id); + QString* getVst3Parameters(); + void setVst3Parameters(QString* vst3_parameters); + + QString* getVst3State(); + void setVst3State(QString* vst3_state); + qint32 getVolumeTenths(); void setVolumeTenths(qint32 volume_tenths); @@ -98,6 +114,22 @@ private: qint32 enable_denoiser; bool m_enable_denoiser_isSet; + qint32 nvidia_intensity; + bool m_nvidia_intensity_isSet; + + qint32 nvidia_vad; + bool m_nvidia_vad_isSet; + + QString* vst3_module_path; + bool m_vst3_module_path_isSet; + QString* vst3_class_id; + bool m_vst3_class_id_isSet; + QString* vst3_parameters; + bool m_vst3_parameters_isSet; + + QString* vst3_state; + bool m_vst3_state_isSet; + qint32 volume_tenths; bool m_volume_tenths_isSet;