Alex Harker
647 lines
19 KiB
C++
647 lines
19 KiB
C++
|
|
#include "FrameLib_DSP.h"
|
|
|
|
// Constructor / Destructor
|
|
|
|
FrameLib_DSP::FrameLib_DSP(ObjectType type, FrameLib_Context context, FrameLib_Proxy *proxy, FrameLib_Parameters::Info *info, unsigned long nIns, unsigned long nOuts, unsigned long nAudioChans)
|
|
: FrameLib_Block(type, context, proxy), mSamplingRate(44100.0), mMaxBlockSize(4096), mParameters(context, proxy, info), mProcessingQueue(context), mNext(nullptr), mNoLiveInputs(true), mInUpdate(false)
|
|
{
|
|
// Set IO
|
|
|
|
setIO(nIns, nOuts, nAudioChans);
|
|
}
|
|
|
|
// Destructor
|
|
|
|
FrameLib_DSP::~FrameLib_DSP()
|
|
{
|
|
// Free output
|
|
|
|
freeOutputMemory();
|
|
|
|
// Delete fixed inputs
|
|
|
|
for (auto ins = mInputs.begin(); ins != mInputs.end(); ins++)
|
|
delete[] ins->mFixedInput;
|
|
}
|
|
|
|
// Set Fixed Input
|
|
|
|
void FrameLib_DSP::setFixedInput(unsigned long idx, const double *input, unsigned long size)
|
|
{
|
|
// This is not threadsafe with the processing thread and should not be called concurrently...
|
|
|
|
mInputs[idx].mSize = 0;
|
|
|
|
if (mInputs[idx].mFixedInput)
|
|
delete[] mInputs[idx].mFixedInput;
|
|
|
|
mInputs[idx].mFixedInput = new double[size];
|
|
|
|
if (mInputs[idx].mFixedInput)
|
|
{
|
|
copyVector(mInputs[idx].mFixedInput, input, size);
|
|
mInputs[idx].mSize = size;
|
|
}
|
|
}
|
|
|
|
const double *FrameLib_DSP::getFixedInput(unsigned long idx, unsigned long *size)
|
|
{
|
|
*size = mInputs[idx].mSize;
|
|
return mInputs[idx].mFixedInput;
|
|
}
|
|
|
|
// Audio Processing
|
|
|
|
// Block updates for objects with audio IO
|
|
|
|
void FrameLib_DSP::blockUpdate(const double * const *ins, double **outs, unsigned long blockSize)
|
|
{
|
|
// Update block time and process the block
|
|
|
|
mBlockStartTime = mBlockEndTime;
|
|
mBlockEndTime += blockSize;
|
|
blockProcess(ins, outs, blockSize);
|
|
|
|
// If the object is handling audio updates (but is not an output object) then notify
|
|
|
|
if (requiresAudioNotification())
|
|
dependencyNotify(false, true);
|
|
}
|
|
|
|
// Reset
|
|
|
|
void FrameLib_DSP::reset(double samplingRate, unsigned long maxBlockSize)
|
|
{
|
|
// Store sample rate / max block size and call object specific reset
|
|
|
|
mSamplingRate = samplingRate > 0 ? samplingRate : 44100.0;
|
|
mMaxBlockSize = maxBlockSize;
|
|
|
|
LocalQueue(this, &FrameLib_DSP::reset);
|
|
|
|
mProcessingQueue->reset();
|
|
}
|
|
|
|
void FrameLib_DSP::reset(LocalQueue *queue)
|
|
{
|
|
bool prevNoLiveInputs = mNoLiveInputs;
|
|
|
|
// Object specific reset
|
|
|
|
objectReset();
|
|
|
|
// Reset dependency counts
|
|
|
|
mUpdatingInputs = false;
|
|
mInputCount = 0;
|
|
mOutputMemoryCount = 0;
|
|
mDependencyCount = ((requiresAudioNotification()) ? 1 : 0);
|
|
|
|
for (auto it = mInputDependencies.begin(); it != mInputDependencies.end(); it++)
|
|
if (!(*it)->mNoLiveInputs)
|
|
mDependencyCount++;
|
|
|
|
mNoLiveInputs = mDependencyCount == 0;
|
|
|
|
// Remove info about the processing queue
|
|
|
|
mNext = nullptr;
|
|
|
|
// Reset output
|
|
|
|
freeOutputMemory();
|
|
mOutputDone = false;
|
|
|
|
// Reset times (Note that the first sample is 1 so that we can start the frames *before* this with non-negative values)
|
|
|
|
mFrameTime = 0.0;
|
|
mInputTime = mNoLiveInputs ? FrameLib_TimeFormat::largest() : FrameLib_TimeFormat(1.0);
|
|
mValidTime = mNoLiveInputs ? FrameLib_TimeFormat::largest() : FrameLib_TimeFormat(1.0);
|
|
mBlockStartTime = 1.0;
|
|
mBlockEndTime = 1.0;
|
|
|
|
// Update output dependencies for changes in live input status
|
|
|
|
if (mNoLiveInputs != prevNoLiveInputs)
|
|
for (auto it = mOutputDependencies.begin(); it != mOutputDependencies.end(); it++)
|
|
queue->add(*it);
|
|
}
|
|
|
|
// Setup and IO Modes
|
|
|
|
void FrameLib_DSP::setIO(unsigned long nIns, unsigned long nOuts, unsigned long nAudioChans)
|
|
{
|
|
// Free output memory
|
|
|
|
freeOutputMemory();
|
|
|
|
// Call the base class to store new sizes
|
|
|
|
FrameLib_Block::setIO(nIns, nOuts, nAudioChans);
|
|
|
|
// Resize inputs and outputs
|
|
|
|
mInputs.resize(getNumIns());
|
|
mOutputs.resize(getNumOuts());
|
|
|
|
// Reset for audio
|
|
|
|
FrameLib_DSP::reset(mSamplingRate, mMaxBlockSize);
|
|
}
|
|
|
|
// Call this from your constructor only (unsafe elsewhere)
|
|
|
|
void FrameLib_DSP::setInputMode(unsigned long idx, bool update, bool trigger, bool switchable, FrameType type)
|
|
{
|
|
mInputs[idx].mUpdate = update;
|
|
mInputs[idx].mTrigger = trigger;
|
|
mInputs[idx].mSwitchable = switchable;
|
|
mInputs[idx].mType = type;
|
|
}
|
|
|
|
// Call this from your constructor only (unsafe elsewhere)
|
|
|
|
void FrameLib_DSP::setParameterInput(unsigned long idx)
|
|
{
|
|
setInputMode(idx, true, false, false, kFrameTagged);
|
|
mInputs[idx].mParameters = true;
|
|
}
|
|
|
|
// Call this from your constructor only (unsafe elsewhere)
|
|
|
|
void FrameLib_DSP::addParameterInput()
|
|
{
|
|
unsigned long nIns = getNumIns();
|
|
unsigned long nOuts = getNumOuts();
|
|
unsigned long nAudioChans = getNumAudioChans();
|
|
|
|
setIO(nIns + 1, nOuts, nAudioChans);
|
|
setParameterInput(nIns);
|
|
}
|
|
|
|
// Call this from your constructor only (unsafe elsewhere)
|
|
|
|
void FrameLib_DSP::setOutputType(unsigned long idx, FrameType type)
|
|
{
|
|
mOutputs[idx].mType = type;
|
|
mOutputs[idx].mCurrentType = type != kFrameAny ? type : kFrameNormal;
|
|
mOutputs[idx].mRequestedType = mOutputs[idx].mCurrentType;
|
|
}
|
|
|
|
// You should only call this from your process method (it is unsafe anywhere else)
|
|
|
|
void FrameLib_DSP::setCurrentOutputType(unsigned long idx, FrameType type)
|
|
{
|
|
mOutputs[idx].mRequestedType = type;
|
|
}
|
|
|
|
// You should only call this from your update method
|
|
|
|
void FrameLib_DSP::updateTrigger(unsigned long idx, bool trigger)
|
|
{
|
|
// Update trigger only if switchable and we are in the update method
|
|
|
|
mInputs[idx].mTrigger = mInputs[idx].mSwitchable && mInUpdate ? trigger : mInputs[idx].mTrigger;
|
|
}
|
|
|
|
// Output Allocation
|
|
|
|
bool FrameLib_DSP::allocateOutputs()
|
|
{
|
|
size_t allocationSize = 0;
|
|
|
|
for (auto outs = mOutputs.begin(); outs != mOutputs.end(); outs++)
|
|
{
|
|
// Update type
|
|
|
|
if (outs->mRequestedType != outs->mCurrentType)
|
|
{
|
|
if (outs->mType == kFrameAny)
|
|
outs->mCurrentType = outs->mRequestedType;
|
|
else
|
|
outs->mRequestedSize = 0;
|
|
}
|
|
|
|
// Calculate allocation size, including necessary alignment padding and assuming success
|
|
|
|
size_t unalignedSize = outs->mCurrentType == kFrameNormal ? outs->mRequestedSize * sizeof(double) : Serial::inPlaceSize(outs->mRequestedSize);
|
|
size_t alignedSize = FrameLib_LocalAllocator::alignSize(unalignedSize);
|
|
|
|
outs->mCurrentSize = outs->mRequestedSize;
|
|
outs->mPointerOffset = allocationSize;
|
|
|
|
allocationSize += alignedSize;
|
|
}
|
|
|
|
// Free then allocate memory
|
|
|
|
freeOutputMemory();
|
|
BytePointer pointer = alloc<Byte>(allocationSize);
|
|
|
|
if (pointer)
|
|
{
|
|
// Store pointers and create tagged outputs
|
|
|
|
for (auto outs = mOutputs.begin(); outs != mOutputs.end(); outs++)
|
|
{
|
|
outs->mMemory = pointer + outs->mPointerOffset;
|
|
|
|
if (outs->mCurrentType == kFrameTagged)
|
|
Serial::newInPlace(outs->mMemory, outs->mCurrentSize);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Reset outputs on failure or zero size
|
|
|
|
for (auto outs = mOutputs.begin(); outs != mOutputs.end(); outs++)
|
|
{
|
|
outs->mMemory = nullptr;
|
|
outs->mCurrentSize = 0;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Get Inputs and Outputs
|
|
|
|
const double *FrameLib_DSP::getInput(unsigned long idx, unsigned long *size) const
|
|
{
|
|
if (mInputs[idx].mObject)
|
|
return mInputs[idx].mObject->getOutput(mInputs[idx].mIndex, size);
|
|
|
|
*size = mInputs[idx].mSize;
|
|
return mInputs[idx].mFixedInput;
|
|
}
|
|
|
|
const FrameLib_Parameters::Serial *FrameLib_DSP::getInput(unsigned long idx) const
|
|
{
|
|
if (mInputs[idx].mObject)
|
|
return mInputs[idx].mObject->getOutput(mInputs[idx].mIndex);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
double *FrameLib_DSP::getOutput(unsigned long idx, unsigned long *size) const
|
|
{
|
|
if (mOutputs[0].mMemory && mOutputs[idx].mCurrentType == kFrameNormal)
|
|
{
|
|
*size = mOutputs[idx].mCurrentSize;
|
|
return (double *) mOutputs[idx].mMemory;
|
|
}
|
|
|
|
*size = 0;
|
|
return nullptr;
|
|
}
|
|
|
|
FrameLib_Parameters::Serial *FrameLib_DSP::getOutput(unsigned long idx) const
|
|
{
|
|
if (mOutputs[0].mMemory && mOutputs[idx].mCurrentType == kFrameTagged)
|
|
return (Serial *) mOutputs[idx].mMemory;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
// Convience methods for copying and zeroing
|
|
|
|
void FrameLib_DSP::prepareCopyInputToOutput(unsigned long inIdx, unsigned long outIdx)
|
|
{
|
|
FrameType requestType = mInputs[inIdx].getCurrentType();
|
|
|
|
unsigned long size = 0;
|
|
|
|
setCurrentOutputType(outIdx, requestType);
|
|
|
|
if (requestType == kFrameNormal)
|
|
getInput(inIdx, &size);
|
|
else
|
|
size = getInput(inIdx)->size();
|
|
|
|
requestOutputSize(outIdx, size);
|
|
}
|
|
|
|
void FrameLib_DSP::copyInputToOutput(unsigned long inIdx, unsigned long outIdx)
|
|
{
|
|
if (mOutputs[outIdx].mCurrentType == kFrameNormal)
|
|
{
|
|
unsigned long inSize, outSize;
|
|
|
|
const double *input = getInput(inIdx, &inSize);
|
|
double *output = getOutput(outIdx, &outSize);
|
|
|
|
copyVector(output, input, std::min(inSize, outSize));
|
|
}
|
|
else
|
|
{
|
|
FrameLib_Parameters::Serial *output = getOutput(outIdx);
|
|
if (output)
|
|
output->write(getInput(inIdx));
|
|
}
|
|
}
|
|
|
|
// Dependency Notification
|
|
|
|
inline void FrameLib_DSP::dependencyNotify(bool releaseMemory, bool fromInput)
|
|
{
|
|
if (mProcessingQueue->isTimedOut())
|
|
return;
|
|
|
|
assert(((mDependencyCount > 0) || (mUpdatingInputs && (mInputCount > 0))) && "Dependency count is already zero");
|
|
|
|
if (releaseMemory)
|
|
releaseOutputMemory();
|
|
|
|
// If ready add to queue
|
|
|
|
if (fromInput && mUpdatingInputs)
|
|
{
|
|
if (--mInputCount == 0)
|
|
mProcessingQueue->add(this);
|
|
}
|
|
else if (--mDependencyCount == 0 && !mUpdatingInputs)
|
|
mProcessingQueue->add(this);
|
|
|
|
// N.B. For multithreading re-entrancy needs to be avoided by increasing the dependency count before adding to the queue (with matching notification)
|
|
}
|
|
|
|
// For updating the correct input count
|
|
|
|
void FrameLib_DSP::incrementInputDependency()
|
|
{
|
|
if (mUpdatingInputs)
|
|
mInputCount++;
|
|
else
|
|
mDependencyCount++;
|
|
}
|
|
|
|
// Main code to control time flow (called when all input/output dependencies are ready)
|
|
|
|
void FrameLib_DSP::dependenciesReady()
|
|
{
|
|
|
|
#ifndef NDEBUG
|
|
FrameLib_TimeFormat prevInputTime = mInputTime;
|
|
#endif
|
|
|
|
mDependencyCount++;
|
|
|
|
bool timeUpdated = false;
|
|
bool callUpdate = false;
|
|
|
|
// Check for inputs at the current frame time that update (update parameters if requested)
|
|
|
|
for (auto ins = mInputs.begin(); ins != mInputs.end(); ins++)
|
|
{
|
|
if (ins->mObject && ins->mUpdate && mInputTime == ins->mObject->mFrameTime)
|
|
{
|
|
callUpdate = true;
|
|
if (ins->mParameters)
|
|
mParameters.set(ins->mObject->getOutput(ins->mIndex));
|
|
}
|
|
}
|
|
|
|
// Custom Update
|
|
|
|
if (callUpdate)
|
|
{
|
|
mInUpdate = true;
|
|
update();
|
|
mInUpdate = false;
|
|
}
|
|
|
|
if (getType() == kScheduler)
|
|
{
|
|
// Find the input time (the min valid time of all inputs)
|
|
|
|
mInputTime = FrameLib_TimeFormat::largest();
|
|
|
|
for (auto ins = mInputs.begin(); ins != mInputs.end(); ins++)
|
|
if (ins->mObject && ins->mObject->mValidTime < mInputTime)
|
|
mInputTime = ins->mObject->mValidTime;
|
|
|
|
// Schedule
|
|
|
|
bool upToDate = (mValidTime >= mBlockEndTime) || mUpdatingInputs;
|
|
SchedulerInfo scheduleInfo = schedule(mOutputDone && !upToDate, upToDate);
|
|
|
|
// Check if time has been updated (limiting to positive advances only), and if so set output times
|
|
|
|
if ((timeUpdated = !upToDate && scheduleInfo.mTimeAdvance.greaterThanZero()))
|
|
{
|
|
if (scheduleInfo.mNewFrame || mOutputDone)
|
|
{
|
|
resetOutputDependencyCount();
|
|
mFrameTime = mValidTime;
|
|
}
|
|
|
|
mValidTime += scheduleInfo.mTimeAdvance;
|
|
mOutputDone = scheduleInfo.mOutputDone;
|
|
}
|
|
|
|
// Revise the input time to take account of the end of the current frame (in order that we don't free anything we might still need)
|
|
|
|
if (mValidTime < mInputTime)
|
|
mInputTime = mValidTime;
|
|
}
|
|
else
|
|
{
|
|
// Find the valid till time (the min valid time of connected inputs that can trigger) and input time (the min valid time of all inputs)
|
|
// Check for inputs at the current time that trigger (N.B. this is done after any update)
|
|
|
|
FrameLib_TimeFormat prevValidTime = mValidTime;
|
|
bool trigger = false;
|
|
mInputTime = FrameLib_TimeFormat::largest();
|
|
mValidTime = FrameLib_TimeFormat::largest();
|
|
|
|
for (auto ins = mInputs.begin(); ins != mInputs.end(); ins++)
|
|
{
|
|
if (ins->mObject && (ins->mTrigger || ins->mSwitchable) && ins->mObject->mValidTime < mValidTime)
|
|
mValidTime = ins->mObject->mValidTime;
|
|
if (ins->mObject && ins->mObject->mValidTime < mInputTime)
|
|
mInputTime = ins->mObject->mValidTime;
|
|
trigger |= (ins->mObject && ins->mTrigger && prevValidTime == ins->mObject->mFrameTime);
|
|
}
|
|
|
|
// If triggered update the frame time, process and release the inputs if we only have one dependency
|
|
|
|
if (trigger)
|
|
{
|
|
mFrameTime = prevValidTime;
|
|
process();
|
|
resetOutputDependencyCount();
|
|
if (mInputDependencies.size() == 1)
|
|
(*mInputDependencies.begin())->releaseOutputMemory();
|
|
}
|
|
|
|
// Check for the frame times updating and if so check for completion of the frame
|
|
|
|
if (mValidTime != prevValidTime)
|
|
{
|
|
timeUpdated = true;
|
|
mOutputDone = true;
|
|
|
|
for (auto ins = mInputs.begin(); ins != mInputs.end(); ins++)
|
|
{
|
|
if (ins->mObject && ((ins->mTrigger && !ins->mSwitchable) || (!ins->mObject->mOutputDone && ins->mSwitchable)) && (mValidTime == ins->mObject->mValidTime))
|
|
{
|
|
if ((mOutputDone = ins->mObject->mOutputDone))
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check for host alignment for objects requiring audio notification (treating the audio notification as a time dependency)
|
|
|
|
bool hostAligned = requiresAudioNotification() && mInputTime >= mBlockEndTime;
|
|
|
|
if (hostAligned)
|
|
mInputTime = mBlockEndTime;
|
|
|
|
// Check if we have reached the end of time or need to just update inputs
|
|
|
|
bool endOfTime = mInputTime == FrameLib_TimeFormat::largest();
|
|
bool prevUpdatingInputs = mUpdatingInputs;
|
|
mUpdatingInputs = mInputTime < mValidTime;
|
|
|
|
// Increment the input dependency for the audio update if necessary (must be after we know if we are updating inputs only)
|
|
|
|
if (hostAligned)
|
|
incrementInputDependency();
|
|
|
|
// Update dependency count for outputs and updating input state starting
|
|
|
|
mDependencyCount += ((timeUpdated ? getNumOuputDependencies() : 0)) + ((mUpdatingInputs > prevUpdatingInputs) ? 1 : 0);
|
|
|
|
// Notify input dependencies that can be released as they are up to date (releasing memory where relevant for objects with more than one input dependency)
|
|
|
|
if (!endOfTime)
|
|
{
|
|
// Inputs cannot move beyond the end of time...
|
|
|
|
for (auto it = mInputDependencies.begin(); it != mInputDependencies.end(); it++)
|
|
{
|
|
if (mInputTime == (*it)->mValidTime)
|
|
{
|
|
incrementInputDependency();
|
|
(*it)->dependencyNotify((getType() == kScheduler || mInputDependencies.size() != 1) && (*it)->mOutputDone, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
// If time has updated then notify output dependencies (of updates to their inputs)
|
|
|
|
if (timeUpdated)
|
|
for (auto it = mOutputDependencies.begin(); it != mOutputDependencies.end(); it++)
|
|
(*it)->dependencyNotify(false, true);
|
|
|
|
// See if the updating input status has expired (must be done after resolving all other dependencies)
|
|
|
|
if (mUpdatingInputs < prevUpdatingInputs)
|
|
dependencyNotify(false, false);
|
|
|
|
// Allow self-triggering if we haven't reached the end of time
|
|
|
|
if (!endOfTime)
|
|
dependencyNotify(false, false);
|
|
|
|
// Debug
|
|
|
|
if (requiresAudioNotification())
|
|
assert(prevInputTime >= mBlockStartTime && prevInputTime < mBlockEndTime && "Out of sync with host");
|
|
assert(mInputTime > prevInputTime && "Failed to move time forward");
|
|
assert(mInputTime <= mValidTime && "Inputs are ahead of output");
|
|
assert(mFrameTime <= mInputTime && "Output is ahead of input dependencies");
|
|
}
|
|
|
|
void FrameLib_DSP::resetOutputDependencyCount()
|
|
{
|
|
mOutputMemoryCount = getNumOuputDependencies();
|
|
}
|
|
|
|
// Manage Output Memory
|
|
|
|
inline void FrameLib_DSP::freeOutputMemory()
|
|
{
|
|
if (getNumOuts() && mOutputs[0].mMemory)
|
|
{
|
|
// Call the destructor for any serial outputs
|
|
|
|
for (auto outs = mOutputs.begin(); outs != mOutputs.end(); outs++)
|
|
if (outs->mCurrentType == kFrameTagged)
|
|
((Serial *)outs->mMemory)->Serial::~Serial();
|
|
|
|
// Then deallocate (will also set to nullptr)
|
|
|
|
dealloc(mOutputs[0].mMemory);
|
|
}
|
|
}
|
|
|
|
inline void FrameLib_DSP::releaseOutputMemory()
|
|
{
|
|
if (--mOutputMemoryCount == 0)
|
|
freeOutputMemory();
|
|
}
|
|
|
|
// Connection Updating
|
|
|
|
void FrameLib_DSP::connectionUpdate(Queue *queue)
|
|
{
|
|
std::vector<FrameLib_DSP *>::iterator it;
|
|
|
|
// Clear dependencies
|
|
|
|
mInputDependencies.clear();
|
|
mOutputDependencies.clear();
|
|
|
|
// Build the input list
|
|
|
|
mInputs.resize(getNumIns() + getNumOrderingConnections());
|
|
|
|
for (unsigned long i = 0; i < getNumIns() + getNumOrderingConnections(); i++)
|
|
{
|
|
// Make sure that ordering inputs are set correctly
|
|
|
|
if (i >= getNumIns())
|
|
setInputMode(i, false, false, false);
|
|
|
|
// Add the DSP object connection details to the input
|
|
|
|
Connection connection = i < getNumIns() ? getConnectionInternal(i) : getOrderingConnectionInternal(i - getNumIns());
|
|
|
|
mInputs[i].mObject = dynamic_cast<FrameLib_DSP *>(connection.mObject);
|
|
mInputs[i].mIndex = mInputs[i].mObject ? connection.mIndex : 0;
|
|
|
|
// Build the input dependency list
|
|
|
|
if (mInputs[i].mObject)
|
|
addUniqueItem(mInputDependencies, mInputs[i].mObject);
|
|
}
|
|
|
|
// Build the output dependency list
|
|
|
|
addOutputDependencies(mOutputDependencies);
|
|
}
|
|
|
|
void FrameLib_DSP::autoOrderingConnections()
|
|
{
|
|
if (supportsOrderingConnections())
|
|
LocalQueue(this, &FrameLib_DSP::autoOrderingConnections);
|
|
}
|
|
|
|
void FrameLib_DSP::autoOrderingConnections(LocalQueue *queue)
|
|
{
|
|
if (supportsOrderingConnections() && queue->getFirst())
|
|
addOrderingConnection(Connection(queue->getFirst(), 0));
|
|
|
|
for (auto it = mOutputDependencies.begin(); it != mOutputDependencies.end(); it++)
|
|
queue->add(*it);
|
|
}
|
|
|
|
void FrameLib_DSP::clearAutoOrderingConnections()
|
|
{
|
|
callConnectionUpdate();
|
|
}
|