#include "../../Audacity.h" // for USE_* macros

#include "VSTEffect.h"

#include "../../widgets/ProgressDialog.h"

#if 0

#if defined(BUILDING_AUDACITY)

#include "../../PlatformCompatibility.h"

// Make the main function private

#else

#define USE_VST 1

#endif

#endif

#if USE_VST

#include <limits.h>

#include <stdio.h>

#include <wx/setup.h> // for wxUSE_* macros

#include <wx/dynlib.h>

#include <wx/app.h>

#include <wx/defs.h>

#include <wx/buffer.h>

#include <wx/busyinfo.h>

#include <wx/button.h>

#include <wx/combobox.h>

#include <wx/file.h>

#include <wx/filename.h>

#include <wx/imaglist.h>

#include <wx/listctrl.h>

#include <wx/log.h>

#include <wx/module.h>

#include <wx/process.h>

#include <wx/recguard.h>

#include <wx/sizer.h>

#include <wx/slider.h>

#include <wx/scrolwin.h>

#include <wx/sstream.h>

#include <wx/statbox.h>

#include <wx/stattext.h>

#include <wx/timer.h>

#include <wx/tokenzr.h>

#include <wx/utils.h>

#if defined(__WXMSW__)

#include <shlwapi.h>

#pragma comment(lib, "shlwapi")

#else

#include <dlfcn.h>

#endif

#include "../../FileNames.h"

#include "../../PlatformCompatibility.h"

#include "../../ShuttleGui.h"

#include "../../effects/Effect.h"

#include "../../widgets/valnum.h"

#include "../../widgets/AudacityMessageBox.h"

#include "../../widgets/NumericTextCtrl.h"

#include "../../xml/XMLFileReader.h"

#if wxUSE_ACCESSIBILITY

#include "../../widgets/WindowAccessible.h"

#endif

#include "audacity/ConfigInterface.h"

#include <cstring>

#if defined(__WXOSX__)

#include "VSTControlOSX.h"

#elif defined(__WXMSW__)

#include "VSTControlMSW.h"

#elif defined(__WXGTK__)

#include "VSTControlGTK.h"

#endif

static float reinterpretAsFloat(uint32_t x)

}

static uint32_t reinterpretAsUint32(float f)

}

DECLARE_MODULE_ENTRY(AudacityModule)

}

DECLARE_BUILTIN_MODULE(VSTBuiltin);

class VSTSubEntry final : public wxModule

{

bool OnInit()

};

void OnExit() {};

DECLARE_DYNAMIC_CLASS(VSTSubEntry)

};

IMPLEMENT_DYNAMIC_CLASS(VSTSubEntry, wxModule);

#define OUTPUTKEY wxT("<VSTLOADCHK>-")

enum InfoKeys

};

class VSTSubProcess final : public wxProcess,

};

VSTEffectsModule::VSTEffectsModule(const wxString *path)

}

VSTEffectsModule::~VSTEffectsModule()

{

mPath = wxEmptyString;

}

PluginPath VSTEffectsModule::GetPath()

{

return mPath;

}

ComponentInterfaceSymbol VSTEffectsModule::GetSymbol()

{

return XO("VST Effects");

}

VendorSymbol VSTEffectsModule::GetVendor()

{

return XO("The Audacity Team");

}

wxString VSTEffectsModule::GetVersion()

{

// This "may" be different if this were to be maintained as a separate DLL

return AUDACITY_VERSION_STRING;

}

TranslatableString VSTEffectsModule::GetDescription()

{

return XO("Adds the ability to use VST effects in Audacity.");

}

bool VSTEffectsModule::Initialize()

{

// Nothing to do here

return true;

}

void VSTEffectsModule::Terminate()

{

// Nothing to do here

return;

}

EffectFamilySymbol VSTEffectsModule::GetOptionalFamilySymbol()

{

#if USE_VST

return VSTPLUGINTYPE;

#else

return {};

#endif

}

const FileExtensions &VSTEffectsModule::GetFileExtensions()

{

static FileExtensions result{{ _T("vst") }};

return result;

}

FilePath VSTEffectsModule::InstallPath()

{

// Not yet ready for VST drag-and-drop...

// return FileNames::PlugInDir();

return {};

}

bool VSTEffectsModule::AutoRegisterPlugins(PluginManagerInterface & WXUNUSED(pm))

{

// We don't auto-register

return true;

}

PluginPaths VSTEffectsModule::FindPluginPaths(PluginManagerInterface & pm)

{

FilePaths pathList;

FilePaths files;

// Check for the VST_PATH environment variable

wxString vstpath = wxString::FromUTF8(getenv("VST_PATH"));

if (!vstpath.empty())

{

wxStringTokenizer tok(vstpath, wxPATH_SEP);

while (tok.HasMoreTokens())

{

pathList.push_back(tok.GetNextToken());

}

}

#if defined(__WXMAC__)

#define VSTPATH wxT("/Library/Audio/Plug-Ins/VST")

// Look in ~/Library/Audio/Plug-Ins/VST and /Library/Audio/Plug-Ins/VST

pathList.push_back(wxGetHomeDir() + wxFILE_SEP_PATH + VSTPATH);

pathList.push_back(VSTPATH);

// Recursively search all paths for Info.plist files. This will identify all

// bundles.

pm.FindFilesInPathList(wxT("Info.plist"), pathList, files, true);

// Remove the 'Contents/Info.plist' portion of the names

for (size_t i = 0; i < files.size(); i++)

{

files[i] = wxPathOnly(wxPathOnly(files[i]));

if (!files[i].EndsWith(wxT(".vst")))

{

files.erase( files.begin() + i-- );

}

}

#elif defined(__WXMSW__)

TCHAR dpath[MAX_PATH];

TCHAR tpath[MAX_PATH];

DWORD len;

// Try HKEY_CURRENT_USER registry key first

len = WXSIZEOF(tpath);

if (SHRegGetUSValue(wxT("Software\\VST"),

wxT("VSTPluginsPath"),

NULL,

tpath,

&len,

FALSE,

NULL,

0) == ERROR_SUCCESS)

{

tpath[len] = 0;

dpath[0] = 0;

ExpandEnvironmentStrings(tpath, dpath, WXSIZEOF(dpath));

pathList.push_back(dpath);

}

// Then try HKEY_LOCAL_MACHINE registry key

len = WXSIZEOF(tpath);

if (SHRegGetUSValue(wxT("Software\\VST"),

wxT("VSTPluginsPath"),

NULL,

tpath,

&len,

TRUE,

NULL,

0) == ERROR_SUCCESS)

{

tpath[len] = 0;

dpath[0] = 0;

ExpandEnvironmentStrings(tpath, dpath, WXSIZEOF(dpath));

pathList.push_back(dpath);

}

// Add the default path last

dpath[0] = 0;

ExpandEnvironmentStrings(wxT("%ProgramFiles%\\Steinberg\\VSTPlugins"),

dpath,

WXSIZEOF(dpath));

pathList.push_back(dpath);

// Recursively scan for all DLLs

pm.FindFilesInPathList(wxT("*.dll"), pathList, files, true);

#else

// Nothing specified in the VST_PATH environment variable...provide defaults

if (vstpath.empty())

{

// We add this "non-default" one

pathList.push_back(wxT(LIBDIR) wxT("/vst"));

// These are the defaults used by other hosts

pathList.push_back(wxT("/usr/lib/vst"));

pathList.push_back(wxT("/usr/local/lib/vst"));

pathList.push_back(wxGetHomeDir() + wxFILE_SEP_PATH + wxT(".vst"));

}

// Recursively scan for all shared objects

pm.FindFilesInPathList(wxT("*.so"), pathList, files, true);

#endif

return { files.begin(), files.end() };

}

unsigned VSTEffectsModule::DiscoverPluginsAtPath(

const PluginPath & path, TranslatableString &errMsg,

const RegistrationCallback &callback)

{

bool error = false;

unsigned nFound = 0;

errMsg = {};

// TODO: Fix this for external usage

const auto &cmdpath = PlatformCompatibility::GetExecutablePath();

wxString effectIDs = wxT("0;");

wxStringTokenizer effectTzr(effectIDs, wxT(";"));

Optional<ProgressDialog> progress{};

size_t idCnt = 0;

size_t idNdx = 0;

bool cont = true;

while (effectTzr.HasMoreTokens() && cont)

{

wxString effectID = effectTzr.GetNextToken();

wxString cmd;

cmd.Printf(wxT("\"%s\" %s \"%s;%s\""), cmdpath, VSTCMDKEY, path, effectID);

VSTSubProcess proc;

try

{

int flags = wxEXEC_SYNC | wxEXEC_NODISABLE;

#if defined(__WXMSW__)

flags += wxEXEC_NOHIDE;

#endif

wxExecute(cmd, flags, &proc);

}

catch (...)

{

wxLogMessage(wxT("VST plugin registration failed for %s\n"), path);

error = true;

}

wxString output;

wxStringOutputStream ss(&output);

proc.GetInputStream()->Read(ss);

int keycount = 0;

bool haveBegin = false;

wxStringTokenizer tzr(output, wxT("\n"));

while (tzr.HasMoreTokens())

{

wxString line = tzr.GetNextToken();

// Our output may follow any output the plugin may have written.

if (!line.StartsWith(OUTPUTKEY))

{

continue;

}

long key;

if (!line.Mid(wxStrlen(OUTPUTKEY)).BeforeFirst(wxT('=')).ToLong(&key))

{

continue;

}

wxString val = line.AfterFirst(wxT('=')).BeforeFirst(wxT('\r'));

switch (key)

{

case kKeySubIDs:

effectIDs = val;

effectTzr.Reinit(effectIDs);

idCnt = effectTzr.CountTokens();

if (idCnt > 3)

{

progress.emplace( XO("Scanning Shell VST"),

XO("Registering %d of %d: %-64.64s")

.Format( 0, idCnt, proc.GetSymbol().Translation())

/*

);

progress->Show();

}

break;

case kKeyBegin:

haveBegin = true;

keycount++;

break;

case kKeyName:

proc.mName = val;

keycount++;

break;

case kKeyPath:

proc.mPath = val;

keycount++;

break;

case kKeyVendor:

proc.mVendor = val;

keycount++;

break;

case kKeyVersion:

proc.mVersion = val;

keycount++;

break;

case kKeyDescription:

proc.mDescription = Verbatim( val );

keycount++;

break;

case kKeyEffectType:

long type;

val.ToLong(&type);

proc.mType = (EffectType) type;

keycount++;

break;

case kKeyInteractive:

proc.mInteractive = val == wxT("1");

keycount++;

break;

case kKeyAutomatable:

proc.mAutomatable = val == wxT("1");

keycount++;

break;

case kKeyEnd:

{

if (!haveBegin || ++keycount != kKeyEnd)

{

keycount = 0;

haveBegin = false;

continue;

}

bool skip = false;

if (progress)

{

idNdx++;

auto result = progress->Update((int)idNdx, (int)idCnt,

XO("Registering %d of %d: %-64.64s")

.Format( idNdx, idCnt, proc.GetSymbol().Translation() ));

cont = (result == ProgressResult::Success);

}

if (!skip && cont)

{

if (callback)

callback( this, &proc );

++nFound;

}

}

break;

default:

keycount = 0;

haveBegin = false;

break;

}

}

}

if (error)

errMsg = XO("Could not load the library");

return nFound;

}

bool VSTEffectsModule::IsPluginValid(const PluginPath & path, bool bFast)

{

if( bFast )

return true;

wxString realPath = path.BeforeFirst(wxT(';'));

return wxFileName::FileExists(realPath) || wxFileName::DirExists(realPath);

}

ComponentInterface *VSTEffectsModule::CreateInstance(const PluginPath & path)

{

// Acquires a resource for the application.

// For us, the ID is simply the path to the effect

// Safety of this depends on complementary calls to DeleteInstance on the module manager side.

return safenew VSTEffect(path);

}

void VSTEffectsModule::DeleteInstance(ComponentInterface *instance)

{

std::unique_ptr < VSTEffect > {

dynamic_cast<VSTEffect *>(instance)

};

}

void VSTEffectsModule::Check(const wxChar *path)

{

VSTEffect effect(path);

if (effect.SetHost(NULL))

{

auto effectIDs = effect.GetEffectIDs();

wxString out;

if (effectIDs.size() > 0)

{

wxString subids;

for (size_t i = 0, cnt = effectIDs.size(); i < cnt; i++)

{

subids += wxString::Format(wxT("%d;"), effectIDs[i]);

}

out = wxString::Format(wxT("%s%d=%s\n"), OUTPUTKEY, kKeySubIDs, subids.RemoveLast());

}

else

{

out += wxString::Format(wxT("%s%d=%s\n"), OUTPUTKEY, kKeyBegin, wxEmptyString);

out += wxString::Format(wxT("%s%d=%s\n"), OUTPUTKEY, kKeyPath, effect.GetPath());

out += wxString::Format(wxT("%s%d=%s\n"), OUTPUTKEY, kKeyName, effect.GetSymbol().Internal());

out += wxString::Format(wxT("%s%d=%s\n"), OUTPUTKEY, kKeyVendor,

effect.GetVendor().Internal());

out += wxString::Format(wxT("%s%d=%s\n"), OUTPUTKEY, kKeyVersion, effect.GetVersion());

out += wxString::Format(wxT("%s%d=%s\n"), OUTPUTKEY, kKeyDescription, effect.GetDescription().Translation());

out += wxString::Format(wxT("%s%d=%d\n"), OUTPUTKEY, kKeyEffectType, effect.GetType());

out += wxString::Format(wxT("%s%d=%d\n"), OUTPUTKEY, kKeyInteractive, effect.IsInteractive());

out += wxString::Format(wxT("%s%d=%d\n"), OUTPUTKEY, kKeyAutomatable, effect.SupportsAutomation());

out += wxString::Format(wxT("%s%d=%s\n"), OUTPUTKEY, kKeyEnd, wxEmptyString);

}

// We want to output info in one chunk to prevent output

// from the effect intermixing with the info

const wxCharBuffer buf = out.ToUTF8();

fwrite(buf, 1, strlen(buf), stdout);

fflush(stdout);

}

}

class VSTEffectOptionsDialog final : public wxDialogWrapper

{

VSTEffectOptionsDialog(wxWindow * parent, EffectHostInterface *host);

virtual ~VSTEffectOptionsDialog();

void PopulateOrExchange(ShuttleGui & S);

void OnOk(wxCommandEvent & evt);

EffectHostInterface *mHost;

int mBufferSize;

bool mUseLatency;

bool mUseGUI;

DECLARE_EVENT_TABLE()

};

BEGIN_EVENT_TABLE(VSTEffectOptionsDialog, wxDialogWrapper)

EVT_BUTTON(wxID_OK, VSTEffectOptionsDialog::OnOk)

END_EVENT_TABLE()

VSTEffectOptionsDialog::VSTEffectOptionsDialog(wxWindow * parent, EffectHostInterface *host)

}

VSTEffectOptionsDialog::~VSTEffectOptionsDialog()

{

}

void VSTEffectOptionsDialog::PopulateOrExchange(ShuttleGui & S)

{

S.SetBorder(5);

S.StartHorizontalLay(wxEXPAND, 1);

{

S.StartVerticalLay(false);

{

S.StartStatic(XO("Buffer Size"));

{

S.AddVariableText( XO(

"reduce processing time."),

false, 0, 650);

S.StartHorizontalLay(wxALIGN_LEFT);

{

wxTextCtrl *t;

t = S.Validator<IntegerValidator<int>>(

&mBufferSize, NumValidatorStyle::DEFAULT, 8, 1048576 * 1)

.MinSize( { 100, -1 } )

.TieNumericTextBox(XXO("&Buffer Size (8 to 1048576 samples):"),

mBufferSize,

12);

}

S.EndHorizontalLay();

}

S.EndStatic();

S.StartStatic(XO("Latency Compensation"));

{

S.AddVariableText( XO(

"not work for all VST effects."),

false, 0, 650);

S.StartHorizontalLay(wxALIGN_LEFT);

{

S.TieCheckBox(XXO("Enable &compensation"),

mUseLatency);

}

S.EndHorizontalLay();

}

S.EndStatic();

S.StartStatic(XO("Graphical Mode"));

{

S.AddVariableText( XO(

" Reopen the effect for this to take effect."),

false, 0, 650);

S.TieCheckBox(XXO("Enable &graphical interface"),

mUseGUI);

}

S.EndStatic();

}

S.EndVerticalLay();

}

S.EndHorizontalLay();

S.AddStandardButtons();

Layout();

Fit();

Center();

}

void VSTEffectOptionsDialog::OnOk(wxCommandEvent & WXUNUSED(evt))

{

if (!Validate())

{

return;

}

ShuttleGui S(this, eIsGettingFromDialog);

PopulateOrExchange(S);

mHost->SetSharedConfig(wxT("Options"), wxT("BufferSize"), mBufferSize);

mHost->SetSharedConfig(wxT("Options"), wxT("UseLatency"), mUseLatency);

mHost->SetSharedConfig(wxT("Options"), wxT("UseGUI"), mUseGUI);

EndModal(wxID_OK);

}

class VSTEffectTimer final : public wxTimer

};

{

ID_Duration = 20000,

ID_Sliders = 21000,

};

DEFINE_LOCAL_EVENT_TYPE(EVT_SIZEWINDOW);

DEFINE_LOCAL_EVENT_TYPE(EVT_UPDATEDISPLAY);

BEGIN_EVENT_TABLE(VSTEffect, wxEvtHandler)

EVT_COMMAND_RANGE(ID_Sliders, ID_Sliders + 999, wxEVT_COMMAND_SLIDER_UPDATED, VSTEffect::OnSlider)

// Events from the audioMaster callback

EVT_COMMAND(wxID_ANY, EVT_SIZEWINDOW, VSTEffect::OnSizeWindow)

END_EVENT_TABLE()

intptr_t VSTEffect::mCurrentEffectID;

typedef AEffect *(*vstPluginMain)(audioMasterCallback audioMaster);

intptr_t VSTEffect::AudioMaster(AEffect * effect,

int32_t opcode,

int32_t index,

intptr_t value,

void * ptr,

float opt)

{

VSTEffect *vst = (effect ? (VSTEffect *) effect->ptr2 : NULL);

// Handles operations during initialization...before VSTEffect has had a

// chance to set its instance pointer.

switch (opcode)

{

case audioMasterVersion:

return (intptr_t) 2400;

case audioMasterCurrentId:

return mCurrentEffectID;

case audioMasterGetVendorString:

strcpy((char *) ptr, "Audacity Team"); // Do not translate, max 64 + 1 for null terminator

return 1;

case audioMasterGetProductString:

strcpy((char *) ptr, "Audacity"); // Do not translate, max 64 + 1 for null terminator

return 1;

case audioMasterGetVendorVersion:

return (intptr_t) (AUDACITY_VERSION << 24 |

AUDACITY_RELEASE << 16 |

AUDACITY_REVISION << 8 |

AUDACITY_MODLEVEL);

// Some (older) effects depend on an effIdle call when requested. An

// example is the Antress Modern plugins which uses the call to update

// the editors display when the program (preset) changes.

case audioMasterNeedIdle:

if (vst)

{

vst->NeedIdle();

return 1;

}

return 0;

// We would normally get this if the effect editor is dipslayed and something "major"

// has changed (like a program change) instead of multiple automation calls.

// Since we don't do anything with the parameters while the editor is displayed,

// there's no need for us to do anything.

case audioMasterUpdateDisplay:

if (vst)

{