void VSTEffect::Unload()
{
if (mAEffect) {
callDispatcher(effClose, 0, 0, NULL, 0.0);
}
if (mModule) {
#if defined(__WXMAC__)
if (mResource != -1) {
CFBundleCloseBundleResourceMap((CFBundleRef) mBundleRef, mResource);
mResource = -1;
}
if (mBundleRef != NULL) {
CFRelease((CFBundleRef) mBundleRef);
mBundleRef = NULL;
}
dlclose(mModule);
#else
delete (wxDynamicLibrary *) mModule;
#endif
mModule = NULL;
mAEffect = NULL;
}
}
void MaximBLE::processEvents()
{
if (isEventsSignaled) {
isEventsSignaled = false;
callDispatcher();
}
}
void MaximBLE::waitForEvent(void)
{
static LowPowerTimeout nextTimeout;
timestamp_t nextTimestamp;
bool_t pTimerRunning;
callDispatcher();
if (wsfOsReadyToSleep()) {
// setup an mbed timer for the next Wicentric timeout
nextTimestamp = (timestamp_t)WsfTimerNextExpiration(&pTimerRunning) * 1000;
if (pTimerRunning) {
nextTimeout.attach_us(timeoutCallback, nextTimestamp);
}
// go to sleep
if (hciDrvReadyToSleep()) {
// go to deep sleep
deepsleep();
hciDrvResume();
}
else {
sleep();
}
}
}
void VSTEffect::SetString(int opcode, const wxString & str, int index)
{
char buf[256];
strcpy(buf, str.Left(255).mb_str());
callDispatcher(opcode, index, 0, buf, 0.0);
}
wxString VSTEffect::GetString(int opcode, int index)
{
char buf[256];
buf[0] = '\0';
callDispatcher(opcode, index, 0, buf, 0.0);
return LAT1CTOWX(buf);
}
int edit()
{
if(m_effect)
{
// HIViewRef view;
// WindowRef win = (WindowRef) MacGetTopLevelWindowRef();
// HIViewFindByID(HIViewGetRoot(win), kHIViewWindowContentID, &view);
callDispatcher(effEditOpen, 0, 0, NULL, 0.0);
}
}
void BLE::waitForEvent()
{
static Timeout nextTimeout;
timestamp_t nextTimestamp;
bool_t pTimerRunning;
callDispatcher();
if (wsfOsReadyToSleep()) {
// setup an mbed timer for the next cordio timeout
nextTimestamp = (timestamp_t)(WsfTimerNextExpiration(&pTimerRunning) * WSF_MS_PER_TICK) * 1000;
if (pTimerRunning) {
nextTimeout.attach_us(timeoutCallback, nextTimestamp);
}
}
}
int load(std::string name)
{
int rval = -1;
vstPluginMain pluginMain = NULL;
CFStringRef path = NULL;
CFURLRef urlRef = NULL;
CFURLRef exeRef = NULL;
Boolean success;
// Start clean
m_bundle = NULL;
// Don't really know what this should be initialize to
m_resource = -1;
// Convert the path to a CFSTring
path = CFStringCreateWithCString(NULL, name.c_str(), kCFStringEncodingUTF8);
// Convert the path to a URL
urlRef = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
path,
kCFURLPOSIXPathStyle,
true);
if (urlRef == NULL) goto error;
// Create the bundle using the URL
m_bundle = CFBundleCreate(kCFAllocatorDefault, urlRef);
// Bail if the bundle wasn't created
if (m_bundle == NULL) goto error;
// Retrieve a reference to the executable
exeRef = CFBundleCopyExecutableURL(m_bundle);
if (exeRef == NULL) goto error;
// Convert back to path
UInt8 exePath[PATH_MAX];
if(!CFURLGetFileSystemRepresentation(exeRef, true, exePath, sizeof(exePath)))
goto error;
// Attempt to open it
m_module = dlopen((char *) exePath, RTLD_NOW | RTLD_LOCAL);
if (m_module == NULL) goto error;
// Try to locate the new plugin entry point
pluginMain = (vstPluginMain) dlsym(m_module, "VSTPluginMain");
// If not found, try finding the old entry point
if (pluginMain == NULL) {
pluginMain = (vstPluginMain) dlsym(m_module, "main_macho");
}
// Must not be a VST plugin
if (pluginMain == NULL) goto error;
// Open the resource map ... some plugins (like GRM Tools) need this.
m_resource = CFBundleOpenBundleResourceMap(m_bundle);
// Initialize the plugin
m_effect = pluginMain(audioMaster);
// Was it successful?
if(!m_effect) goto error;
m_effect->user = this;
//
callDispatcher(effOpen, 0, 0, NULL, 0.0);
// Ensure that it looks like a plugin and can deal with ProcessReplacing
// calls. Also exclude synths for now.
if(m_effect->magic == kEffectMagic &&
!(m_effect->flags & effFlagsIsSynth) &&
m_effect->flags & effFlagsCanReplacing)
{
// mVendor = GetString(effGetVendorString);
// mName = GetString(effGetEffectName);
// mInputs = mAEffect->numInputs;
// mOutputs = mAEffect->numOutputs;
// We could even go so far as to run a small test here.
rval = 0;
goto cleanup;
}
else
{
goto error;
}
error:
if(m_effect) { callDispatcher(effClose, 0, 0, NULL, 0.0); m_effect = NULL; }
if(m_resource != -1) { CFBundleCloseBundleResourceMap(m_bundle, m_resource); m_resource = -1; }
if(m_module) { dlclose(m_module); m_module = NULL; }
if(m_bundle) { CFRelease(m_bundle); m_bundle = NULL; }
if(pluginMain) { pluginMain = NULL; }
cleanup:
if(exeRef) { CFRelease(exeRef); exeRef = NULL; }
if(urlRef) { CFRelease(urlRef); urlRef = NULL; }
if(path) { CFRelease(path); path = NULL; }
return rval;
}
bool VSTEffect::Load()
{
vstPluginMain pluginMain;
bool success = false;
mModule = NULL;
mAEffect = NULL;
#if defined(__WXMAC__)
// Start clean
mBundleRef = NULL;
// Don't really know what this should be initialize to
mResource = -1;
// Convert the path to a CFSTring
wxMacCFStringHolder path(mPath);
// Convert the path to a URL
CFURLRef urlRef =
CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
path,
kCFURLPOSIXPathStyle,
true);
if (urlRef == NULL) {
return false;
}
// Create the bundle using the URL
CFBundleRef bundleRef = CFBundleCreate(kCFAllocatorDefault, urlRef);
// Done with the URL
CFRelease(urlRef);
// Bail if the bundle wasn't created
if (bundleRef == NULL) {
return false;
}
// Retrieve a reference to the executable
CFURLRef exeRef = CFBundleCopyExecutableURL(bundleRef);
if (exeRef == NULL) {
CFRelease(bundleRef);
return false;
}
// Convert back to path
UInt8 exePath[PATH_MAX];
success = CFURLGetFileSystemRepresentation(exeRef, true, exePath, sizeof(exePath));
// Done with the executable reference
CFRelease(exeRef);
// Bail if we couldn't resolve the executable path
if (success == FALSE) {
CFRelease(bundleRef);
return false;
}
// Attempt to open it
mModule = dlopen((char *) exePath, RTLD_NOW | RTLD_LOCAL);
if (mModule == NULL) {
CFRelease(bundleRef);
return false;
}
// Try to locate the new plugin entry point
pluginMain = (vstPluginMain) dlsym(mModule, "VSTPluginMain");
// If not found, try finding the old entry point
if (pluginMain == NULL) {
pluginMain = (vstPluginMain) dlsym(mModule, "main_macho");
}
// Must not be a VST plugin
if (pluginMain == NULL) {
dlclose(mModule);
mModule = NULL;
CFRelease(bundleRef);
return false;
}
// Need to keep the bundle reference around so we can map the
// resources.
mBundleRef = bundleRef;
// Open the resource map ... some plugins (like GRM Tools) need this.
mResource = (int) CFBundleOpenBundleResourceMap(bundleRef);
#else
{
wxLogNull nolog;
// Try to load the library
wxDynamicLibrary *lib = new wxDynamicLibrary(mPath);
if (!lib) {
return false;
}
// Bail if it wasn't successful
if (!lib->IsLoaded()) {
delete lib;
return false;
}
// Try to find the entry point, while suppressing error messages
pluginMain = (vstPluginMain) lib->GetSymbol(wxT("VSTPluginMain"));
if (pluginMain == NULL) {
pluginMain = (vstPluginMain) lib->GetSymbol(wxT("main"));
if (pluginMain == NULL) {
delete lib;
return false;
}
}
// Save the library reference
mModule = lib;
}
#endif
// Initialize the plugin
mAEffect = pluginMain(audioMaster);
// Was it successful?
if (mAEffect) {
//
mAEffect->user = this;
//
callDispatcher(effOpen, 0, 0, NULL, 0.0);
// Ensure that it looks like a plugin and can deal with ProcessReplacing
// calls. Also exclude synths for now.
if (mAEffect->magic == kEffectMagic &&
!(mAEffect->flags & effFlagsIsSynth) &&
mAEffect->flags & effFlagsCanReplacing) {
mVendor = GetString(effGetVendorString);
mName = GetString(effGetEffectName);
mInputs = mAEffect->numInputs;
mOutputs = mAEffect->numOutputs;
// We could even go so far as to run a small test here.
success = true;
}
}
if (!success) {
Unload();
}
return success;
}
bool VSTEffect::ProcessStereo(int count,
WaveTrack *left, WaveTrack *right,
sampleCount lstart, sampleCount rstart,
sampleCount len)
{
bool rc = true;
// Initialize time info
mTimeInfo.samplePos = 0.0;
mTimeInfo.sampleRate = left->GetRate();
mTimeInfo.flags |= kVstTransportPlaying;
// Turn the power on
callDispatcher(effMainsChanged, 0, 1, NULL, 0.0);
// Tell effect we're starting to process
callDispatcher(effStartProcess, 0, 0, NULL, 0.0);
// Actually perform the effect here
sampleCount originalLen = len;
sampleCount ls = lstart;
sampleCount rs = rstart;
while (len) {
int block = mBlockSize;
if (block > len) {
block = len;
}
left->Get((samplePtr)mInBuffer[0], floatSample, ls, block);
if (right) {
right->Get((samplePtr)mInBuffer[1], floatSample, rs, block);
}
callProcessReplacing(mInBuffer, mOutBuffer, block);
left->Set((samplePtr)mOutBuffer[0], floatSample, ls, block);
if (right) {
right->Set((samplePtr)mOutBuffer[1], floatSample, rs, block);
}
len -= block;
ls += block;
rs += block;
mTimeInfo.samplePos += ((double) block / mTimeInfo.sampleRate);
if (mInputs > 1) {
if (TrackGroupProgress(count, (ls - lstart) / (double)originalLen)) {
rc = false;
break;
}
}
else {
if (TrackProgress(count, (ls - lstart) / (double)originalLen)) {
rc = false;
break;
}
}
}
// Tell effect we're done
callDispatcher(effStopProcess, 0, 0, NULL, 0.0);
// Turn the power off
callDispatcher(effMainsChanged, 0, 0, NULL, 0.0);
// No longer playing
mTimeInfo.samplePos = 0.0;
mTimeInfo.sampleRate = 44100.0;
mTimeInfo.tempo = 120.0;
mTimeInfo.timeSigNumerator = 4;
mTimeInfo.timeSigDenominator = 4;
mTimeInfo.flags = kVstTempoValid | kVstNanosValid;
return rc;
}
bool VSTEffect::Process()
{
CopyInputTracks();
bool bGoodResult = true;
mInBuffer = NULL;
mOutBuffer = NULL;
TrackListIterator iter(mOutputTracks);
int count = 0;
bool clear = false;
WaveTrack *left = (WaveTrack *) iter.First();
while (left) {
WaveTrack *right;
sampleCount len;
sampleCount lstart;
sampleCount rstart;
GetSamples(left, &lstart, &len);
mChannels = 1;
right = NULL;
rstart = 0;
if (left->GetLinked() && mInputs > 1) {
right = (WaveTrack *) iter.Next();
GetSamples(right, &rstart, &len);
clear = false;
mChannels = 2;
}
if (mBlockSize == 0) {
mBlockSize = left->GetMaxBlockSize() * 2;
// Some VST effects (Antress Modern is an example), do not like
// overly large block sizes. Unfortunately, I have not found a
// way to determine if the effect has a maximum it will support,
// so just limit to small value for now. This will increase
// processing time and, it's a shame, because most plugins seem
// to be able to handle much larger sizes.
if (mBlockSize > 8192) { // The Antress limit
mBlockSize = 8192;
}
mInBuffer = new float *[mInputs];
for (int i = 0; i < mInputs; i++) {
mInBuffer[i] = new float[mBlockSize];
}
mOutBuffer = new float *[mOutputs];
for (int i = 0; i < mOutputs; i++) {
mOutBuffer[i] = new float[mBlockSize];
}
// Turn the power off
callDispatcher(effMainsChanged, 0, 0, NULL, 0.0);
// Set processing parameters
callDispatcher(effSetSampleRate, 0, 0, NULL, left->GetRate());
callDispatcher(effSetBlockSize, 0, mBlockSize, NULL, 0.0);
}
// Clear unused input buffers
if (!right && !clear) {
for (int i = 1; i < mInputs; i++) {
for (int j = 0; j < mBlockSize; j++) {
mInBuffer[i][j] = 0.0;
}
}
clear = true;
}
bGoodResult = ProcessStereo(count, left, right, lstart, rstart, len);
if (!bGoodResult) {
break;
}
left = (WaveTrack *) iter.Next();
count++;
}
if (mOutBuffer) {
for (int i = 0; i < mOutputs; i++) {
delete mOutBuffer[i];
}
delete [] mOutBuffer;
mOutBuffer = NULL;
}
if (mInBuffer) {
for (int i = 0; i < mInputs; i++) {
delete mInBuffer[i];
}
delete [] mInBuffer;
mInBuffer = NULL;
}
ReplaceProcessedTracks(bGoodResult);
return bGoodResult;
}
bool VSTEffect::ProcessStereo(int count,
WaveTrack *left, WaveTrack *right,
sampleCount lstart, sampleCount rstart,
sampleCount len)
{
bool rc = true;
sampleCount amountLeft = 0;
// Initialize time info
mTimeInfo.samplePos = 0.0;
mTimeInfo.sampleRate = left->GetRate();
mTimeInfo.flags |= kVstTransportPlaying;
// Turn the power on
callDispatcher(effMainsChanged, 0, 1, NULL, 0.0);
// Tell effect we're starting to process
callDispatcher(effStartProcess, 0, 0, NULL, 0.0);
// Actually perform the effect here
sampleCount originalLen = len;
sampleCount ls = lstart;
sampleCount rs = rstart;
sampleCount outls = lstart;
sampleCount outrs = rstart;
sampleCount outBufferCursor = 0;
float **outBufSegment = new float *[mOutputs];
while (len) {
int block = mBlockSize;
if (block > len) {
block = len;
}
left->Get((samplePtr)mInBuffer[0], floatSample, ls, block);
if (right) {
right->Get((samplePtr)mInBuffer[1], floatSample, rs, block);
}
for (int i = 0; i < mOutputs; i++)
outBufSegment[i] = mOutBuffer[i ] + outBufferCursor;
callProcessReplacing(mInBuffer, outBufSegment, block);
outBufferCursor += block;
//Process 2 audacity blockfiles per WaveTrack::Set independently of mBlockSize
//because it is extremely slow to do multiple Set()s per blockfile due to Undo History
//If we do more optimization we should probably align the Sets to blockfile boundries.
if (outBufferCursor >= mWTBlockSize) {
left->Set((samplePtr)mOutBuffer[0], floatSample, outls, mWTBlockSize);
if (right) {
right->Set((samplePtr)mOutBuffer[1], floatSample, outrs, mWTBlockSize);
}
if (outBufferCursor >= mWTBlockSize) {
//snake the buffer down
memmove(mOutBuffer[0], mOutBuffer[0] + mWTBlockSize, SAMPLE_SIZE(floatSample) * (outBufferCursor - mWTBlockSize));
memmove(mOutBuffer[1], mOutBuffer[1] + mWTBlockSize, SAMPLE_SIZE(floatSample) * (outBufferCursor - mWTBlockSize));
}
outBufferCursor -= mWTBlockSize;
outls += mWTBlockSize;
outrs += mWTBlockSize;
}
len -= block;
ls += block;
rs += block;
mTimeInfo.samplePos += ((double) block / mTimeInfo.sampleRate);
if (mInputs > 1) {
if (TrackGroupProgress(count, (ls - lstart) / (double)originalLen)) {
rc = false;
break;
}
}
else {
if (TrackProgress(count, (ls - lstart) / (double)originalLen)) {
rc = false;
break;
}
}
}
//finish taking the remainder.
if (outBufferCursor) {
left->Set((samplePtr)mOutBuffer[0], floatSample, outls, outBufferCursor);
if (right) {
right->Set((samplePtr)mOutBuffer[1], floatSample, outrs, outBufferCursor);
}
}
// Tell effect we're done
callDispatcher(effStopProcess, 0, 0, NULL, 0.0);
// Turn the power off
callDispatcher(effMainsChanged, 0, 0, NULL, 0.0);
// No longer playing
mTimeInfo.samplePos = 0.0;
mTimeInfo.sampleRate = 44100.0;
mTimeInfo.tempo = 120.0;
mTimeInfo.timeSigNumerator = 4;
mTimeInfo.timeSigDenominator = 4;
mTimeInfo.flags = kVstTempoValid | kVstNanosValid;
return rc;
}
ble_error_t MaximBLE::init(BLE::InstanceID_t instanceID, FunctionPointerWithContext<BLE::InitializationCompleteCallbackContext *> initCallback)
{
wsfHandlerId_t handlerId;
/* init OS subsystems */
WsfTimerInit(1);
WsfBufInit(sizeof(mainBufMem), mainBufMem, WSF_BUF_POOLS, mainPoolDesc);
WsfSecInit();
/* init stack */
handlerId = WsfOsSetNextHandler(HciHandler);
HciHandlerInit(handlerId);
handlerId = WsfOsSetNextHandler(DmHandler);
DmAdvInit();
DmScanInit();
DmConnInit();
DmConnSlaveInit();
DmSecInit();
DmHandlerInit(handlerId);
handlerId = WsfOsSetNextHandler(L2cSlaveHandler);
L2cSlaveHandlerInit(handlerId);
L2cInit();
L2cMasterInit();
L2cSlaveInit();
handlerId = WsfOsSetNextHandler(AttHandler);
AttHandlerInit(handlerId);
AttsInit();
AttsIndInit();
AttcInit();
handlerId = WsfOsSetNextHandler(SmpHandler);
SmpHandlerInit(handlerId);
SmpiInit();
SmprInit();
/* store handler ID */
maximHandlerId = WsfOsSetNextHandler(maximHandler);
/* init HCI */
#ifdef BLE_HCI_UART
hciDrvInit(BT_TX, BT_RST, BT_CLK);
#else
_irq.disable_irq();
_irq.rise(hciDrvIsr);
_irq.fall(NULL);
hciDrvInit(HCI_CSN, HCI_RST, HCI_IRQ);
#endif
/* Register for stack callbacks */
DmRegister(DmCback);
DmConnRegister(DM_CLIENT_ID_APP, DmCback);
AttConnRegister(AppServerConnCback);
/* Reset the device */
reset_complete = 0;
DmDevReset();
while (!reset_complete) {
callDispatcher();
}
initialized = true;
BLE::InitializationCompleteCallbackContext context = {
BLE::Instance(instanceID),
BLE_ERROR_NONE
};
initCallback.call(&context);
return BLE_ERROR_NONE;
}
void BLE::processEvents()
{
callDispatcher();
}
