void allpassmod_dsp64(t_allpassmod *x, t_object *dsp64, short *count, double samplerate, long maxvectorsize, long flags)
{
// cast objects
TTInputAudioPtr in_left_instance = TTInputAudioPtr(x->in_left.instance());
TTInputAudioPtr in_right_instance = TTInputAudioPtr(x->in_right.instance());
TTAudioObjectBasePtr allpass_instance = TTAudioObjectBasePtr(x->allpass.instance());
TTAudioSignalPtr signalIn_instance = TTAudioSignalPtr(x->signalIn.instance());
TTAudioSignalPtr signalOut_instance = TTAudioSignalPtr(x->signalOut.instance());
TTOutputAudioPtr out_left_instance = TTOutputAudioPtr(x->out_left.instance());
TTOutputAudioPtr out_right_instance = TTOutputAudioPtr(x->out_right.instance());
signalIn_instance->setNumChannels(2);
signalOut_instance->setNumChannels(2);
signalIn_instance->setVectorSizeWithInt((TTUInt16)maxvectorsize);
signalOut_instance->setVectorSizeWithInt((TTUInt16)maxvectorsize);
signalOut_instance->alloc();
allpass_instance->setAttributeValue(kTTSym_sampleRate, samplerate);
object_method(dsp64, gensym("dsp_add64"), x, allpassmod_perform64, 0, NULL);
in_left_instance->setupAudioSignals(maxvectorsize);
in_right_instance->setupAudioSignals(maxvectorsize);
out_left_instance->setupAudioSignals(maxvectorsize, samplerate);
out_right_instance->setupAudioSignals(maxvectorsize, samplerate);
}
void allpassmod_perform64(t_allpassmod *x, t_object *dsp64, double **ins, long numins, double **outs, long numouts, long sampleframes, long flags, void *userparam)
{
// cast objects
TTInputAudioPtr in_left_instance = TTInputAudioPtr(x->in_left.instance());
TTInputAudioPtr in_right_instance = TTInputAudioPtr(x->in_right.instance());
TTAudioObjectBasePtr allpass_instance = TTAudioObjectBasePtr(x->allpass.instance());
TTAudioSignalPtr signalIn_instance = TTAudioSignalPtr(x->signalIn.instance());
TTAudioSignalPtr signalOut_instance = TTAudioSignalPtr(x->signalOut.instance());
TTOutputAudioPtr out_left_instance = TTOutputAudioPtr(x->out_left.instance());
TTOutputAudioPtr out_right_instance = TTOutputAudioPtr(x->out_right.instance());
in_left_instance->process(ins[0], NULL, sampleframes);
in_right_instance->process(ins[1], NULL, sampleframes);
// need to compile a stereo signal out of the multiple mono signals
signalIn_instance->setVector(0, sampleframes, in_left_instance->getVector());
signalIn_instance->setVector(1, sampleframes, in_right_instance->getVector());
// actually process the audio
allpass_instance->process(signalIn_instance, signalOut_instance);
// we re-use the memory from ins[], which is safe because we set Z_NO_INPLACE in the object constructor
signalOut_instance->getVectorCopy(0, sampleframes, ins[0]);
signalOut_instance->getVectorCopy(1, sampleframes, ins[1]);
out_left_instance->process(ins[0], outs[0], sampleframes);
out_right_instance->process(ins[1], outs[1], sampleframes);
}
void TTInputAudio::process(TTSampleValue* anInputSampleVector, TTSampleValue* anOutputSampleVector, TTUInt16 aVectorSize)
{
// Store the input from the inlets
TTAudioSignalPtr(mSignalIn.instance())->setVector64Copy(0, aVectorSize, anInputSampleVector);
// Sum signal from j.send~ objects
for (mSignalCache.begin(); mSignalCache.end(); mSignalCache.next()) {
TTObject o = mSignalCache.current()[0];
TTAudioSignalPtr sentSignal = TTAudioSignalPtr(o.instance());
if (sentSignal)
*TTAudioSignalPtr(mSignalIn.instance()) += *sentSignal;
}
// if signal is bypassed or muted, send a zero signal to the algorithm
if (mBypass || mMute)
TTAudioSignal::copy(*TTAudioSignalPtr(mSignalZero.instance()), *TTAudioSignalPtr(mSignalOut.instance()));
// else copy in to out
else
TTAudioSignal::copy(*TTAudioSignalPtr(mSignalIn.instance()), *TTAudioSignalPtr(mSignalOut.instance()));
// clear the signal cache
mSignalCache.clear();
// Send the input on to the outlets for the algorithm, if desired
if (anOutputSampleVector)
TTAudioSignalPtr(mSignalOut.instance())->getVectorCopy(0, aVectorSize, anOutputSampleVector);
}
void TTOutputAudio::process(TTSampleValue* anInputSampleVector, TTSampleValue* anOutputSampleVector, TTUInt16 aVectorSize)
{
// Store the audio vector as a proper audio signal
TTAudioSignalPtr(mSignalIn)->setVector64Copy(0, aVectorSize, anInputSampleVector);
// if the output signal is muted
if (mMute)
TTAudioSignal::copy(*TTAudioSignalPtr(mSignalZero), *TTAudioSignalPtr(mSignalOut));
// if input signal exists
else if (mInputObject) {
// if input signal is bypassed : copy input (in Temp)
if (mInputObject->mBypass)
TTAudioSignal::copy(*TTAudioSignalPtr(mInputObject->mSignalIn), *TTAudioSignalPtr(mSignalTemp));
// otherwise mix input and output signals (in Temp)
else
TTAudioObjectBasePtr(mMixUnit)->process(TTAudioSignalPtr(mInputObject->mSignalOut), TTAudioSignalPtr(mSignalIn), TTAudioSignalPtr(mSignalTemp));
// then perform gain control (from Temp)
TTAudioObjectBasePtr(mGainUnit)->process(TTAudioSignalPtr(mSignalTemp), TTAudioSignalPtr(mSignalOut));
}
// otherwise just perform gain control
else
TTAudioObjectBasePtr(mGainUnit)->process(TTAudioSignalPtr(mSignalIn), TTAudioSignalPtr(mSignalOut));
// Send the input on to the outlets for the algorithm
TTAudioSignalPtr(mSignalOut)->getVectorCopy(0, aVectorSize, anOutputSampleVector);
}
// Perform Method 64 bit - just pass the whole vector straight through
// (the work is all done in the dsp 64 bit method)
void in_perform64(TTPtr self, t_object *dsp64, double **ins, long numins, double **outs, long numouts, long sampleframes, long flags, void *userparam)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTInputPtr anInput = (TTInputPtr)x->wrappedObject;
TTAudioSignalPtr sentSignal;
TTUInt16 vectorSize = 0;
if (anInput) {
// get signal vectorSize
anInput->mSignalIn->getAttributeValue(kTTSym_vectorSize, vectorSize);
// Store the input from the inlets
TTAudioSignalPtr(anInput->mSignalIn)->setVector64Copy(0, vectorSize, ins[0]);
// if signal is bypassed or muted : send a zero signal to the algorithm
if (anInput->mBypass || anInput->mMute)
TTAudioSignal::copy(*TTAudioSignalPtr(anInput->mSignalZero), *TTAudioSignalPtr(anInput->mSignalOut));
// else copy in to out and add remote signal
else {
TTAudioSignal::copy(*TTAudioSignalPtr(anInput->mSignalIn), *TTAudioSignalPtr(anInput->mSignalOut));
// sum signal from jcom.send~ objects
if (anInput->mSignalCache) {
for (anInput->mSignalCache->begin(); anInput->mSignalCache->end(); anInput->mSignalCache->next()) {
sentSignal = TTAudioSignalPtr((TTObjectBasePtr)anInput->mSignalCache->current()[0]);
if (sentSignal)
*TTAudioSignalPtr(anInput->mSignalOut) += *sentSignal;
}
}
}
// clear the signal cache
anInput->mSignalCache->clear();
// Send the input on to the outlets for the algorithm
TTAudioSignalPtr(anInput->mSignalOut)->getVectorCopy(0, vectorSize, outs[0]);
// metering
if (!anInput->mMute) {
TTUInt16 n = vectorSize;;
TTFloat32 currentvalue = 0;
TTFloat32 peakvalue = 0.0;
TTSampleValue* envelope = outs[0];
while (n--) {
if ((*envelope) < 0 ) // get the current sample's absolute value
currentvalue = -(*envelope);
else
currentvalue = *envelope;
if (currentvalue > peakvalue) // if it's a new peak amplitude...
peakvalue = currentvalue;
envelope++; // increment pointer in the vector
}
// set meter
EXTRA->meter = peakvalue;
// set peak
if (peakvalue > EXTRA->peak)
EXTRA->peak = peakvalue;
}
}
}
// Perform Method - just pass the whole vector straight through
// (the work is all done in the dsp method)
t_int *in_perform(t_int *w)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)(w[1]);
TTInputPtr anInput = (TTInputPtr)x->wrappedObject;
TTAudioSignalPtr sentSignal;
TTUInt16 vectorSize = 0;
if (anInput) {
// get signal vectorSize
anInput->mSignalIn->getAttributeValue(kTTSym_vectorSize, vectorSize);
// Store the input from the inlets
TTAudioSignalPtr(anInput->mSignalIn)->setVector(0, vectorSize, (TTFloat32*)w[2]);
// if signal is bypassed or muted : send a zero signal to the algorithm
if (anInput->mBypass || anInput->mMute)
TTAudioSignal::copy(*TTAudioSignalPtr(anInput->mSignalZero), *TTAudioSignalPtr(anInput->mSignalOut));
// else copy in to out
else
TTAudioSignal::copy(*TTAudioSignalPtr(anInput->mSignalIn), *TTAudioSignalPtr(anInput->mSignalOut));
// sum signal from jcom.send~ objects
if (anInput->mSignalCache) {
for (anInput->mSignalCache->begin(); anInput->mSignalCache->end(); anInput->mSignalCache->next()) {
sentSignal = TTAudioSignalPtr((TTObjectBasePtr)anInput->mSignalCache->current()[0]);
if (sentSignal)
*TTAudioSignalPtr(anInput->mSignalOut) += *sentSignal;
}
}
// clear the signal cache
anInput->mSignalCache->clear();
// Send the input on to the outlets for the algorithm
TTAudioSignalPtr(anInput->mSignalOut)->getVector(0, vectorSize, (TTFloat32*)w[3]);
// metering
if (!anInput->mMute) {
TTUInt16 n = vectorSize;
TTFloat32 currentvalue = 0;
TTFloat32 peakvalue = 0.0;
t_float* envelope = (t_float *)(w[3]);
while (n--) {
if ((*envelope) < 0 ) // get the current sample's absolute value
currentvalue = -(*envelope);
else
currentvalue = *envelope;
if (currentvalue > peakvalue) // if it's a new peak amplitude...
peakvalue = currentvalue;
envelope++; // increment pointer in the vector
}
// set meter
EXTRA->meter = peakvalue;
// set peak
if (peakvalue > EXTRA->peak)
EXTRA->peak = peakvalue;
}
}
return w + 4;
}
