Пример #1
0
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);
}
Пример #2
0
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);
}
Пример #3
0
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);
}