void RingmodNode::process() { multiplicationKernel(block_size, input_buffers[0], input_buffers[1], output_buffers[0]); }
void LateReflectionsNode::process() { if(werePropertiesModified(this, Lav_LATE_REFLECTIONS_T60, Lav_LATE_REFLECTIONS_DENSITY, Lav_LATE_REFLECTIONS_HF_T60, Lav_LATE_REFLECTIONS_LF_T60, Lav_LATE_REFLECTIONS_HF_REFERENCE, Lav_LATE_REFLECTIONS_LF_REFERENCE )) recompute(); if(werePropertiesModified(this, Lav_LATE_REFLECTIONS_AMPLITUDE_MODULATION_FREQUENCY)) amplitudeModulationFrequencyChanged(); if(werePropertiesModified(this, Lav_LATE_REFLECTIONS_DELAY_MODULATION_FREQUENCY)) delayModulationFrequencyChanged(); if(werePropertiesModified(this, Lav_LATE_REFLECTIONS_ALLPASS_ENABLED)) allpassEnabledChanged(); if(werePropertiesModified(this, Lav_LATE_REFLECTIONS_ALLPASS_MODULATION_FREQUENCY)) allpassModulationFrequencyChanged(); normalizeOscillators(); float amplitudeModulationDepth = getProperty(Lav_LATE_REFLECTIONS_AMPLITUDE_MODULATION_DEPTH).getFloatValue(); float delayModulationDepth = getProperty(Lav_LATE_REFLECTIONS_DELAY_MODULATION_DEPTH).getFloatValue(); float allpassMinFreq=getProperty(Lav_LATE_REFLECTIONS_ALLPASS_MINFREQ).getFloatValue(); float allpassMaxFreq = getProperty(Lav_LATE_REFLECTIONS_ALLPASS_MAXFREQ).getFloatValue(); float allpassQ=getProperty(Lav_LATE_REFLECTIONS_ALLPASS_Q).getFloatValue(); bool allpassEnabled = getProperty(Lav_LATE_REFLECTIONS_ALLPASS_ENABLED).getIntValue() == 1; float allpassDelta= (allpassMaxFreq-allpassMinFreq)/2.0f; //we move delta upward and delta downward of this point. //consequently, we therefore range from the min to the max. float allpassModulationStart =allpassMinFreq+allpassDelta; for(int i= 0; i < block_size; i++) { //We modulate the delay lines first. for(int modulating = 0; modulating < 16; modulating++) { float delay = delays[modulating]; delay =delay+delay*delayModulationDepth*delay_modulators[modulating]->tick(); delay = std::min(delay, 1.0f); fdn.setDelay(modulating, delay); } //Prepare the allpasses, if enabled. if(allpassEnabled) { for(int modulating =0; modulating < order; modulating++) { allpasses[modulating]->configure(Lav_BIQUAD_TYPE_ALLPASS, allpassModulationStart+allpassDelta*allpass_modulators[modulating]->tick(), 0.0, allpassQ); } } //If disabled, the modulators are advanced later. //Get the fdn's output. fdn.computeFrame(output_frame); for(int j= 0; j < order; j++) output_buffers[j][i] = output_frame[j]; for(int j=0; j < order; j++) { //Through the highshelf, then the lowshelf. output_frame[j] = midshelves[j]->tick(highshelves[j]->tick(gains[j]*output_frame[j])); //and maybe through the allpass if(allpassEnabled) output_frame[j] = allpasses[j]->tick(output_frame[j]); } //Gains are baked into the fdn matrix. //bring in the inputs. for(int j = 0; j < order; j++) next_input_frame[j] = input_buffers[j][i]; fdn.advance(next_input_frame, output_frame); } //appluy the amplitude modulation, if it's needed. if(amplitudeModulationDepth!=0.0f) { for(int output = 0; output < num_output_buffers; output++) { float* output_buffer=output_buffers[output]; SinOsc& osc= *amplitude_modulators[output]; //get A sine wave. osc.fillBuffer(block_size, amplitude_modulation_buffer); //Implement 1.0-amplitudeModulationDepth/2+amplitudeModulationDepth*oscillatorValue. scalarMultiplicationKernel(block_size, amplitudeModulationDepth, amplitude_modulation_buffer, amplitude_modulation_buffer); scalarAdditionKernel(block_size, 1.0f-amplitudeModulationDepth/2.0f, amplitude_modulation_buffer, amplitude_modulation_buffer); //Apply the modulation. multiplicationKernel(block_size, amplitude_modulation_buffer, output_buffer, output_buffer); } } //Advance modulators for anything we aren't modulating: //We do this so that the same parameters always produce the same reverb, even after transitioning through multiple presets. //Without the following, the modulators for different stages can get out of phase with each other. if(allpassEnabled == false) { for(int i=0; i < order; i++)allpass_modulators[i]->skipSamples(block_size); } if(amplitudeModulationDepth == 0.0f) { for(int i = 0; i < 16; i++) { amplitude_modulators[i]->skipSamples(block_size); } } //Apply the pan reduction: for(int i = 0; i < order; i++) { auto &line = *pan_reducers[i]; for(int j = 0; j < block_size; j++) { output_buffers[i][j] = line.tick(output_buffers[i][j]); } } }