void pdsp::ClockedPhazor::onReset(const int &n, const float &inc, float* &triggerBuffer, const int &bufferSize){
phase-=1.0f;
if(triggerBuffer==nullptr){
triggerBuffer = getOutputBufferToFill(output_trig);
ofx_Aeq_Zero(triggerBuffer, bufferSize);
}
triggerBuffer[n] = 1.0f; //inter sample trigger value
}
//-------------------------ALIGNED ALLOCATION------------------------------------------
void ofx_allocate_aligned(float* &toAllocate, int len){
int check=0;
#ifdef _MSC_VER
toAllocate = reinterpret_cast<float*>(_aligned_malloc(len*sizeof(float), OFX_SIMD_ALIGNMENT_NUM));
if(toAllocate ==NULL) {
check = -1;
}
#else
check = posix_memalign(reinterpret_cast<void**>(&toAllocate), OFX_SIMD_ALIGNMENT_NUM, len*sizeof(float));
#endif
if(check!=0){
toAllocate = nullptr;
}else{
ofx_Aeq_Zero(toAllocate, len);
}
};
void pdsp::TriggerControl::process (int bufferSize) noexcept {
if(nextTrigger.load() == 0.0f){
setOutputToZero(output);
}else{
float* outputBuffer = getOutputBufferToFill(output);
ofx_Aeq_Zero(outputBuffer, bufferSize);
outputBuffer[0] = nextTrigger.load();
nextTrigger.store(0.0f);
}
}
void pdsp::GateSequencer::process (int bufferSize) noexcept {
meter_ticks++;
//if( messageBuffer!=nullptr ){
if( ( messageBuffer->empty() ) ){
setOutputToZero(output_trig);
}else{
float* trigBuffer = getOutputBufferToFill( output_trig );
ofx_Aeq_Zero(trigBuffer, bufferSize); //clean buffer
int imax = messageBuffer->size();
for( int i=0; i<imax; ++i){
ControlMessage &msg = messageBuffer->messages[i];
if(msg.value <=0.0f){
trigBuffer[ msg.sample * getOversampleLevel() ] = pdspTriggerOff;
gateState = false;
}else{
if(!singleTrigger || (singleTrigger && !gateState) ){
//normal trigger or first trigger with legato
trigBuffer[ msg.sample * getOversampleLevel() ] = msg.value;
meter_ticks = 0;
}else{
//legato triggers
trigBuffer[ msg.sample * getOversampleLevel() ] = - msg.value;
}
gateState = true;
meter_value = msg.value;
}
}
}
//}else{
// setOutputToZero(output_trig);
//}
}
void ofxPDSPWrapper::process(int bufferSize) noexcept {
ofx_Aeq_Zero( buffer, bufferLength);
for(int i=0; i<(int)inputs.size(); i++){
int inputState;
const float* inputBuffer = processInput(inputs[i], inputState);
switch(inputState){
case pdsp::Changed: case pdsp::Unchanged:
for(int n=0; n<bufferSize; ++n){
buffer[n*maxChannels + i] = inputBuffer[0];
}
break;
case pdsp::AudioRate:
for(int n=0; n<bufferSize; ++n){
buffer[n*maxChannels + i] = inputBuffer[n];
}
break;
}
}
audioProcess( buffer, bufferSize, maxChannels );
for(int i=0; i<(int)outputs.size(); i++){
float* outputBuffer = getOutputBufferToFill( outputs[i] );
for(int n=0; n<bufferSize; ++n){
outputBuffer[n] = buffer[n*maxChannels + i];
}
}
setOutputToZero(dummyOut);
}
void pdsp::TriggerGeiger::process (int bufferSize) noexcept {
if(counter < bufferSize){
int distanceSamples = (processAndGetSingleValue( in_distance_ms, 0 ) * sampleRateMult );
int jitterSamples = (processAndGetSingleValue( in_jitter_ms, 0 ) * sampleRateMult );
float* outputBuffer = getOutputBufferToFill(output_trig);
ofx_Aeq_Zero(outputBuffer, bufferSize);
for(int n=0; n<bufferSize; ++n){
if(counter==0){
outputBuffer[n] = 1.0f; //set trigger pulse
counter = distanceSamples + randomUnipolarInt(jitterSamples);
}
counter--;
}
}else{
counter -= bufferSize;
setOutputToZero(output_trig);
}
}
