bool SpectrumAnalyzer::processAudioBuffer( sampleFrame* _buf, const fpp_t _frames )
{
if( !isEnabled() || !isRunning () )
{
return false;
}
if( !m_saControls.isViewVisible() )
{
return true;
}
fpp_t f = 0;
if( _frames > FFT_BUFFER_SIZE )
{
m_framesFilledUp = 0;
f = _frames - FFT_BUFFER_SIZE;
}
const int cm = m_saControls.m_channelMode.value();
switch( cm )
{
case MergeChannels:
for( ; f < _frames; ++f )
{
m_buffer[m_framesFilledUp] =
( _buf[f][0] + _buf[f][1] ) * 0.5;
++m_framesFilledUp;
}
break;
case LeftChannel:
for( ; f < _frames; ++f )
{
m_buffer[m_framesFilledUp] = _buf[f][0];
++m_framesFilledUp;
}
break;
case RightChannel:
for( ; f < _frames; ++f )
{
m_buffer[m_framesFilledUp] = _buf[f][1];
++m_framesFilledUp;
}
break;
}
if( m_framesFilledUp < FFT_BUFFER_SIZE )
{
return isRunning();
}
// hanming( m_buffer, FFT_BUFFER_SIZE, HAMMING );
const sample_rate_t sr = Engine::mixer()->processingSampleRate();
const int LOWEST_FREQ = 0;
const int HIGHEST_FREQ = sr / 2;
fftwf_execute( m_fftPlan );
absspec( m_specBuf, m_absSpecBuf, FFT_BUFFER_SIZE+1 );
if( m_saControls.m_linearSpec.value() )
{
compressbands( m_absSpecBuf, m_bands, FFT_BUFFER_SIZE+1,
MAX_BANDS,
(int)(LOWEST_FREQ*(FFT_BUFFER_SIZE+1)/(float)(sr/2)),
(int)(HIGHEST_FREQ*(FFT_BUFFER_SIZE+1)/(float)(sr/2)));
m_energy = maximum( m_bands, MAX_BANDS ) / maximum( m_buffer, FFT_BUFFER_SIZE );
}
else
{
calc13octaveband31( m_absSpecBuf, m_bands, FFT_BUFFER_SIZE+1, sr/2.0 );
m_energy = signalpower( m_buffer, FFT_BUFFER_SIZE ) / maximum( m_buffer, FFT_BUFFER_SIZE );
}
m_framesFilledUp = 0;
checkGate( 1 );
return isRunning();
}
bool EqEffect::processAudioBuffer( sampleFrame *buf, const fpp_t frames )
{
// setup sample exact controls
float hpRes = m_eqControls.m_hpResModel.value();
float lowShelfRes = m_eqControls.m_lowShelfResModel.value();
float para1Bw = m_eqControls.m_para1BwModel.value();
float para2Bw = m_eqControls.m_para2BwModel.value();
float para3Bw = m_eqControls.m_para3BwModel.value();
float para4Bw = m_eqControls.m_para4BwModel.value();
float highShelfRes = m_eqControls.m_highShelfResModel.value();
float lpRes = m_eqControls.m_lpResModel.value();
float hpFreq = m_eqControls.m_hpFeqModel.value();
float lowShelfFreq = m_eqControls.m_lowShelfFreqModel.value();
float para1Freq = m_eqControls.m_para1FreqModel.value();
float para2Freq = m_eqControls.m_para2FreqModel.value();
float para3Freq = m_eqControls.m_para3FreqModel.value();
float para4Freq = m_eqControls.m_para4FreqModel.value();
float highShelfFreq = m_eqControls.m_highShelfFreqModel.value();
float lpFreq = m_eqControls.m_lpFreqModel.value();
ValueBuffer *hpResBuffer = m_eqControls.m_hpResModel.valueBuffer();
ValueBuffer *lowShelfResBuffer = m_eqControls.m_lowShelfResModel.valueBuffer();
ValueBuffer *para1BwBuffer = m_eqControls.m_para1BwModel.valueBuffer();
ValueBuffer *para2BwBuffer = m_eqControls.m_para2BwModel.valueBuffer();
ValueBuffer *para3BwBuffer = m_eqControls.m_para3BwModel.valueBuffer();
ValueBuffer *para4BwBuffer = m_eqControls.m_para4BwModel.valueBuffer();
ValueBuffer *highShelfResBuffer = m_eqControls.m_highShelfResModel.valueBuffer();
ValueBuffer *lpResBuffer = m_eqControls.m_lpResModel.valueBuffer();
ValueBuffer *hpFreqBuffer = m_eqControls.m_hpFeqModel.valueBuffer();
ValueBuffer *lowShelfFreqBuffer = m_eqControls.m_lowShelfFreqModel.valueBuffer();
ValueBuffer *para1FreqBuffer = m_eqControls.m_para1FreqModel.valueBuffer();
ValueBuffer *para2FreqBuffer = m_eqControls.m_para2FreqModel.valueBuffer();
ValueBuffer *para3FreqBuffer = m_eqControls.m_para3FreqModel.valueBuffer();
ValueBuffer *para4FreqBuffer = m_eqControls.m_para4FreqModel.valueBuffer();
ValueBuffer *highShelfFreqBuffer = m_eqControls.m_highShelfFreqModel.valueBuffer();
ValueBuffer *lpFreqBuffer = m_eqControls.m_lpFreqModel.valueBuffer();
int hpResInc = hpResBuffer ? 1 : 0;
int lowShelfResInc = lowShelfResBuffer ? 1 : 0;
int para1BwInc = para1BwBuffer ? 1 : 0;
int para2BwInc = para2BwBuffer ? 1 : 0;
int para3BwInc = para3BwBuffer ? 1 : 0;
int para4BwInc = para4BwBuffer ? 1 : 0;
int highShelfResInc = highShelfResBuffer ? 1 : 0;
int lpResInc = lpResBuffer ? 1 : 0;
int hpFreqInc = hpFreqBuffer ? 1 : 0;
int lowShelfFreqInc = lowShelfFreqBuffer ? 1 : 0;
int para1FreqInc = para1FreqBuffer ? 1 : 0;
int para2FreqInc = para2FreqBuffer ? 1 : 0;
int para3FreqInc = para3FreqBuffer ? 1 : 0;
int para4FreqInc = para4FreqBuffer ? 1 : 0;
int highShelfFreqInc = highShelfFreqBuffer ? 1 : 0;
int lpFreqInc = lpFreqBuffer ? 1 : 0;
float *hpResPtr = hpResBuffer ? &( hpResBuffer->values()[ 0 ] ) : &hpRes;
float *lowShelfResPtr = lowShelfResBuffer ? &( lowShelfResBuffer->values()[ 0 ] ) : &lowShelfRes;
float *para1BwPtr = para1BwBuffer ? &( para1BwBuffer->values()[ 0 ] ) : ¶1Bw;
float *para2BwPtr = para2BwBuffer ? &( para2BwBuffer->values()[ 0 ] ) : ¶2Bw;
float *para3BwPtr = para3BwBuffer ? &( para3BwBuffer->values()[ 0 ] ) : ¶3Bw;
float *para4BwPtr = para4BwBuffer ? &( para4BwBuffer->values()[ 0 ] ) : ¶4Bw;
float *highShelfResPtr = highShelfResBuffer ? &( highShelfResBuffer->values()[ 0 ] ) : &highShelfRes;
float *lpResPtr = lpResBuffer ? &( lpResBuffer->values()[ 0 ] ) : &lpRes;
float *hpFreqPtr = hpFreqBuffer ? &( hpFreqBuffer->values()[ 0 ] ) : &hpFreq;
float *lowShelfFreqPtr = lowShelfFreqBuffer ? &( lowShelfFreqBuffer->values()[ 0 ] ) : &lowShelfFreq;
float *para1FreqPtr = para1FreqBuffer ? &(para1FreqBuffer->values()[ 0 ] ) : ¶1Freq;
float *para2FreqPtr = para2FreqBuffer ? &(para2FreqBuffer->values()[ 0 ] ) : ¶2Freq;
float *para3FreqPtr = para3FreqBuffer ? &(para3FreqBuffer->values()[ 0 ] ) : ¶3Freq;
float *para4FreqPtr = para4FreqBuffer ? &(para4FreqBuffer->values()[ 0 ] ) : ¶4Freq;
float *hightShelfFreqPtr = highShelfFreqBuffer ? &(highShelfFreqBuffer->values()[ 0 ] ) : &highShelfFreq;
float *lpFreqPtr = lpFreqBuffer ? &(lpFreqBuffer ->values()[ 0 ] ) : &lpFreq;
bool hpActive = m_eqControls.m_hpActiveModel.value();
bool hp24Active = m_eqControls.m_hp24Model.value();
bool hp48Active = m_eqControls.m_hp48Model.value();
bool lowShelfActive = m_eqControls.m_lowShelfActiveModel.value();
bool para1Active = m_eqControls.m_para1ActiveModel.value();
bool para2Active = m_eqControls.m_para2ActiveModel.value();
bool para3Active = m_eqControls.m_para3ActiveModel.value();
bool para4Active = m_eqControls.m_para4ActiveModel.value();
bool highShelfActive = m_eqControls.m_highShelfActiveModel.value();
bool lpActive = m_eqControls.m_lpActiveModel.value();
bool lp24Active = m_eqControls.m_lp24Model.value();
bool lp48Active = m_eqControls.m_lp48Model.value();
float lowShelfGain = m_eqControls.m_lowShelfGainModel.value();
float para1Gain = m_eqControls.m_para1GainModel.value();
float para2Gain = m_eqControls.m_para2GainModel.value();
float para3Gain = m_eqControls.m_para3GainModel.value();
float para4Gain = m_eqControls.m_para4GainModel.value();
float highShelfGain = m_eqControls.m_highShelfGainModel.value();
if( !isEnabled() || !isRunning () )
{
return( false );
}
if( m_eqControls.m_outGainModel.isValueChanged() )
{
m_outGain = dbfsToAmp(m_eqControls.m_outGainModel.value());
}
if( m_eqControls.m_inGainModel.isValueChanged() )
{
m_inGain = dbfsToAmp(m_eqControls.m_inGainModel.value());
}
m_eqControls.m_inProgress = true;
double outSum = 0.0;
for( fpp_t f = 0; f < frames; ++f )
{
outSum += buf[f][0]*buf[f][0] + buf[f][1]*buf[f][1];
}
const float outGain = m_outGain;
const int sampleRate = Engine::mixer()->processingSampleRate();
sampleFrame m_inPeak = { 0, 0 };
if(m_eqControls.m_analyseInModel.value( true ) && outSum > 0 )
{
m_eqControls.m_inFftBands.analyze( buf, frames );
}
else
{
m_eqControls.m_inFftBands.clear();
}
gain( buf, frames, m_inGain, &m_inPeak );
m_eqControls.m_inPeakL = m_eqControls.m_inPeakL < m_inPeak[0] ? m_inPeak[0] : m_eqControls.m_inPeakL;
m_eqControls.m_inPeakR = m_eqControls.m_inPeakR < m_inPeak[1] ? m_inPeak[1] : m_eqControls.m_inPeakR;
for( fpp_t f = 0; f < frames; f++)
{
if( hpActive )
{
m_hp12.setParameters( sampleRate, *hpFreqPtr, *hpResPtr, 1 );
buf[f][0] = m_hp12.update( buf[f][0], 0 );
buf[f][1] = m_hp12.update( buf[f][1], 1 );
if( hp24Active || hp48Active )
{
m_hp24.setParameters( sampleRate, *hpFreqPtr, *hpResPtr, 1 );
buf[f][0] = m_hp24.update( buf[f][0], 0 );
buf[f][1] = m_hp24.update( buf[f][1], 1 );
}
if( hp48Active )
{
m_hp480.setParameters( sampleRate, *hpFreqPtr, *hpResPtr, 1 );
buf[f][0] = m_hp480.update( buf[f][0], 0 );
buf[f][1] = m_hp480.update( buf[f][1], 1 );
m_hp481.setParameters( sampleRate, *hpFreqPtr, *hpResPtr, 1 );
buf[f][0] = m_hp481.update( buf[f][0], 0 );
buf[f][1] = m_hp481.update( buf[f][1], 1 );
}
}
if( lowShelfActive )
{
m_lowShelf.setParameters( sampleRate, *lowShelfFreqPtr, *lowShelfResPtr, lowShelfGain );
buf[f][0] = m_lowShelf.update( buf[f][0], 0 );
buf[f][1] = m_lowShelf.update( buf[f][1], 1 );
}
if( para1Active )
{
m_para1.setParameters( sampleRate, *para1FreqPtr, *para1BwPtr, para1Gain );
buf[f][0] = m_para1.update( buf[f][0], 0 );
buf[f][1] = m_para1.update( buf[f][1], 1 );
}
if( para2Active )
{
m_para2.setParameters( sampleRate, *para2FreqPtr, *para2BwPtr, para2Gain );
buf[f][0] = m_para2.update( buf[f][0], 0 );
buf[f][1] = m_para2.update( buf[f][1], 1 );
}
if( para3Active )
{
m_para3.setParameters( sampleRate, *para3FreqPtr, *para3BwPtr, para3Gain );
buf[f][0] = m_para3.update( buf[f][0], 0 );
buf[f][1] = m_para3.update( buf[f][1], 1 );
}
if( para4Active )
{
m_para4.setParameters( sampleRate, *para4FreqPtr, *para4BwPtr, para4Gain );
buf[f][0] = m_para4.update( buf[f][0], 0 );
buf[f][1] = m_para4.update( buf[f][1], 1 );
}
if( highShelfActive )
{
m_highShelf.setParameters( sampleRate, *hightShelfFreqPtr, *highShelfResPtr, highShelfGain );
buf[f][0] = m_highShelf.update( buf[f][0], 0 );
buf[f][1] = m_highShelf.update( buf[f][1], 1 );
}
if( lpActive ){
m_lp12.setParameters( sampleRate, *lpFreqPtr, *lpResPtr, 1 );
buf[f][0] = m_lp12.update( buf[f][0], 0 );
buf[f][1] = m_lp12.update( buf[f][1], 1 );
if( lp24Active || lp48Active )
{
m_lp24.setParameters( sampleRate, *lpFreqPtr, *lpResPtr, 1 );
buf[f][0] = m_lp24.update( buf[f][0], 0 );
buf[f][1] = m_lp24.update( buf[f][1], 1 );
}
if( lp48Active )
{
m_lp480.setParameters( sampleRate, *lpFreqPtr, *lpResPtr, 1 );
buf[f][0] = m_lp480.update( buf[f][0], 0 );
buf[f][1] = m_lp480.update( buf[f][1], 1 );
m_lp481.setParameters( sampleRate, *lpFreqPtr, *lpResPtr, 1 );
buf[f][0] = m_lp481.update( buf[f][0], 0 );
buf[f][1] = m_lp481.update( buf[f][1], 1 );
}
}
//increment pointers if needed
hpResPtr += hpResInc;
lowShelfResPtr += lowShelfResInc;
para1BwPtr += para1BwInc;
para2BwPtr += para2BwInc;
para3BwPtr += para3BwInc;
para4BwPtr += para4BwInc;
highShelfResPtr += highShelfResInc;
lpResPtr += lpResInc;
hpFreqPtr += hpFreqInc;
lowShelfFreqPtr += lowShelfFreqInc;
para1FreqPtr += para1FreqInc;
para2FreqPtr += para2FreqInc;
para3FreqPtr += para3FreqInc;
para4FreqPtr += para4FreqInc;
hightShelfFreqPtr += highShelfFreqInc;
lpFreqPtr += lpFreqInc;
}
sampleFrame outPeak = { 0, 0 };
gain( buf, frames, outGain, &outPeak );
m_eqControls.m_outPeakL = m_eqControls.m_outPeakL < outPeak[0] ? outPeak[0] : m_eqControls.m_outPeakL;
m_eqControls.m_outPeakR = m_eqControls.m_outPeakR < outPeak[1] ? outPeak[1] : m_eqControls.m_outPeakR;
checkGate( outSum / frames );
if(m_eqControls.m_analyseOutModel.value( true ) && outSum > 0 )
{
m_eqControls.m_outFftBands.analyze( buf, frames );
setBandPeaks( &m_eqControls.m_outFftBands , ( int )( sampleRate ) );
}
else
{
m_eqControls.m_outFftBands.clear();
}
m_eqControls.m_inProgress = false;
return isRunning();
}
bool DualFilterEffect::processAudioBuffer( sampleFrame* buf, const fpp_t frames )
{
if( !isEnabled() || !isRunning () )
{
return( false );
}
double outSum = 0.0;
const float d = dryLevel();
const float w = wetLevel();
if( m_dfControls.m_filter1Model.isValueChanged() || m_filter1changed )
{
m_filter1->setFilterType( m_dfControls.m_filter1Model.value() );
m_filter1changed = true;
}
if( m_dfControls.m_filter2Model.isValueChanged() || m_filter2changed )
{
m_filter2->setFilterType( m_dfControls.m_filter2Model.value() );
m_filter2changed = true;
}
float cut1 = m_dfControls.m_cut1Model.value();
float res1 = m_dfControls.m_res1Model.value();
float gain1 = m_dfControls.m_gain1Model.value();
float cut2 = m_dfControls.m_cut2Model.value();
float res2 = m_dfControls.m_res2Model.value();
float gain2 = m_dfControls.m_gain2Model.value();
float mix = m_dfControls.m_mixModel.value();
ValueBuffer *cut1Buffer = m_dfControls.m_cut1Model.valueBuffer();
ValueBuffer *res1Buffer = m_dfControls.m_res1Model.valueBuffer();
ValueBuffer *gain1Buffer = m_dfControls.m_gain1Model.valueBuffer();
ValueBuffer *cut2Buffer = m_dfControls.m_cut2Model.valueBuffer();
ValueBuffer *res2Buffer = m_dfControls.m_res2Model.valueBuffer();
ValueBuffer *gain2Buffer = m_dfControls.m_gain2Model.valueBuffer();
ValueBuffer *mixBuffer = m_dfControls.m_mixModel.valueBuffer();
int cut1Inc = cut1Buffer ? 1 : 0;
int res1Inc = res1Buffer ? 1 : 0;
int gain1Inc = gain1Buffer ? 1 : 0;
int cut2Inc = cut2Buffer ? 1 : 0;
int res2Inc = res2Buffer ? 1 : 0;
int gain2Inc = gain2Buffer ? 1 : 0;
int mixInc = mixBuffer ? 1 : 0;
float *cut1Ptr = cut1Buffer ? &( cut1Buffer->values()[ 0 ] ) : &cut1;
float *res1Ptr = res1Buffer ? &( res1Buffer->values()[ 0 ] ) : &res1;
float *gain1Ptr = gain1Buffer ? &( gain1Buffer->values()[ 0 ] ) : &gain1;
float *cut2Ptr = cut2Buffer ? &( cut2Buffer->values()[ 0 ] ) : &cut2;
float *res2Ptr = res2Buffer ? &( res2Buffer->values()[ 0 ] ) : &res2;
float *gain2Ptr = gain2Buffer ? &( gain2Buffer->values()[ 0 ] ) : &gain2;
float *mixPtr = mixBuffer ? &( mixBuffer->values()[ 0 ] ) : &mix;
const bool enabled1 = m_dfControls.m_enabled1Model.value();
const bool enabled2 = m_dfControls.m_enabled2Model.value();
// buffer processing loop
for( fpp_t f = 0; f < frames; ++f )
{
// get mix amounts for wet signals of both filters
const float mix2 = ( ( *mixPtr + 1.0f ) * 0.5f );
const float mix1 = 1.0f - mix2;
const float gain1 = *gain1Ptr * 0.01f;
const float gain2 = *gain2Ptr * 0.01f;
sample_t s[2] = { 0.0f, 0.0f }; // mix
sample_t s1[2] = { buf[f][0], buf[f][1] }; // filter 1
sample_t s2[2] = { buf[f][0], buf[f][1] }; // filter 2
// update filter 1
if( enabled1 )
{
//update filter 1 params here
// recalculate only when necessary: either cut/res is changed, or the changed-flag is set (filter type or samplerate changed)
if( ( ( *cut1Ptr != m_currentCut1 ||
*res1Ptr != m_currentRes1 ) ) || m_filter1changed )
{
m_filter1->calcFilterCoeffs( *cut1Ptr, *res1Ptr );
m_filter1changed = false;
m_currentCut1 = *cut1Ptr;
m_currentRes1 = *res1Ptr;
}
s1[0] = m_filter1->update( s1[0], 0 );
s1[1] = m_filter1->update( s1[1], 1 );
// apply gain
s1[0] *= gain1;
s1[1] *= gain1;
// apply mix
s[0] += ( s1[0] * mix1 );
s[1] += ( s1[1] * mix1 );
}
// update filter 2
if( enabled2 )
{
//update filter 2 params here
if( ( ( *cut2Ptr != m_currentCut2 ||
*res2Ptr != m_currentRes2 ) ) || m_filter2changed )
{
m_filter2->calcFilterCoeffs( *cut2Ptr, *res2Ptr );
m_filter2changed = false;
m_currentCut2 = *cut2Ptr;
m_currentRes2 = *res2Ptr;
}
s2[0] = m_filter2->update( s2[0], 0 );
s2[1] = m_filter2->update( s2[1], 1 );
//apply gain
s2[0] *= gain2;
s2[1] *= gain2;
// apply mix
s[0] += ( s2[0] * mix2 );
s[1] += ( s2[1] * mix2 );
}
outSum += buf[f][0]*buf[f][0] + buf[f][1]*buf[f][1];
// do another mix with dry signal
buf[f][0] = d * buf[f][0] + w * s[0];
buf[f][1] = d * buf[f][1] + w * s[1];
//increment pointers
cut1Ptr += cut1Inc;
res1Ptr += res1Inc;
gain1Ptr += gain1Inc;
cut2Ptr += cut2Inc;
res2Ptr += res2Inc;
gain2Ptr += gain2Inc;
mixPtr += mixInc;
}
checkGate( outSum / frames );
return isRunning();
}
bool DelayEffect::processAudioBuffer( sampleFrame* buf, const fpp_t frames )
{
if( !isEnabled() || !isRunning () )
{
return( false );
}
double outSum = 0.0;
const float sr = Engine::mixer()->processingSampleRate();
const float d = dryLevel();
const float w = wetLevel();
sample_t dryS[2];
float lPeak = 0.0;
float rPeak = 0.0;
float length = m_delayControls.m_delayTimeModel.value();
float amplitude = m_delayControls.m_lfoAmountModel.value() * sr;
float lfoTime = 1.0 / m_delayControls.m_lfoTimeModel.value();
float feedback = m_delayControls.m_feedbackModel.value();
ValueBuffer *lengthBuffer = m_delayControls.m_delayTimeModel.valueBuffer();
ValueBuffer *feedbackBuffer = m_delayControls.m_feedbackModel.valueBuffer();
ValueBuffer *lfoTimeBuffer = m_delayControls.m_lfoTimeModel.valueBuffer();
ValueBuffer *lfoAmountBuffer = m_delayControls.m_lfoAmountModel.valueBuffer();
int lengthInc = lengthBuffer ? 1 : 0;
int amplitudeInc = lfoAmountBuffer ? 1 : 0;
int lfoTimeInc = lfoTimeBuffer ? 1 : 0;
int feedbackInc = feedbackBuffer ? 1 : 0;
float *lengthPtr = lengthBuffer ? &( lengthBuffer->values()[ 0 ] ) : &length;
float *amplitudePtr = lfoAmountBuffer ? &( lfoAmountBuffer->values()[ 0 ] ) : &litude;
float *lfoTimePtr = lfoTimeBuffer ? &( lfoTimeBuffer->values()[ 0 ] ) : &lfoTime;
float *feedbackPtr = feedbackBuffer ? &( feedbackBuffer->values()[ 0 ] ) : &feedback;
if( m_delayControls.m_outGainModel.isValueChanged() )
{
m_outGain = dbvToAmp( m_delayControls.m_outGainModel.value() );
}
int sampleLength;
for( fpp_t f = 0; f < frames; ++f )
{
dryS[0] = buf[f][0];
dryS[1] = buf[f][1];
m_delay->setFeedback( *feedbackPtr );
m_lfo->setFrequency( *lfoTimePtr );
sampleLength = *lengthPtr * Engine::mixer()->processingSampleRate();
m_currentLength = linearInterpolate( sampleLength, m_currentLength, 0.9999 );
m_delay->setLength( m_currentLength + ( *amplitudePtr * ( float )m_lfo->tick() ) );
m_delay->tick( buf[f] );
buf[f][0] *= m_outGain;
buf[f][1] *= m_outGain;
lPeak = buf[f][0] > lPeak ? buf[f][0] : lPeak;
rPeak = buf[f][1] > rPeak ? buf[f][1] : rPeak;
buf[f][0] = ( d * dryS[0] ) + ( w * buf[f][0] );
buf[f][1] = ( d * dryS[1] ) + ( w * buf[f][1] );
outSum += buf[f][0]*buf[f][0] + buf[f][1]*buf[f][1];
lengthPtr += lengthInc;
amplitudePtr += amplitudeInc;
lfoTimePtr += lfoTimeInc;
feedbackPtr += feedbackInc;
}
checkGate( outSum / frames );
m_delayControls.m_outPeakL = lPeak;
m_delayControls.m_outPeakR = rPeak;
return isRunning();
}
bool stereoEnhancerEffect::processAudioBuffer( sampleFrame * _buf,
const fpp_t _frames )
{
// This appears to be used for determining whether or not to continue processing
// audio with this effect
double out_sum = 0.0;
float width;
int frameIndex = 0;
if( !isEnabled() || !isRunning() )
{
return( false );
}
const float d = dryLevel();
const float w = wetLevel();
for( fpp_t f = 0; f < _frames; ++f )
{
// copy samples into the delay buffer
m_delayBuffer[m_currFrame][0] = _buf[f][0];
m_delayBuffer[m_currFrame][1] = _buf[f][1];
// Get the width knob value from the Stereo Enhancer effect
width = m_seFX.wideCoeff();
// Calculate the correct sample frame for processing
frameIndex = m_currFrame - width;
if( frameIndex < 0 )
{
// e.g. difference = -10, frameIndex = DBS - 10
frameIndex += DEFAULT_BUFFER_SIZE;
}
//sample_t s[2] = { _buf[f][0], _buf[f][1] }; //Vanilla
sample_t s[2] = { _buf[f][0], m_delayBuffer[frameIndex][1] }; //Chocolate
m_seFX.nextSample( s[0], s[1] );
_buf[f][0] = d * _buf[f][0] + w * s[0];
_buf[f][1] = d * _buf[f][1] + w * s[1];
out_sum += _buf[f][0]*_buf[f][0] + _buf[f][1]*_buf[f][1];
// Update currFrame
m_currFrame += 1;
m_currFrame %= DEFAULT_BUFFER_SIZE;
}
checkGate( out_sum / _frames );
if( !isRunning() )
{
clearMyBuffer();
}
return( isRunning() );
}
bool LadspaEffect::processAudioBuffer( sampleFrame * _buf,
const fpp_t _frames )
{
m_pluginMutex.lock();
if( !isOkay() || dontRun() || !isRunning() || !isEnabled() )
{
m_pluginMutex.unlock();
return( false );
}
int frames = _frames;
sampleFrame * o_buf = NULL;
sampleFrame sBuf [_frames];
if( m_maxSampleRate < Engine::mixer()->processingSampleRate() )
{
o_buf = _buf;
_buf = &sBuf[0];
sampleDown( o_buf, _buf, m_maxSampleRate );
frames = _frames * m_maxSampleRate /
Engine::mixer()->processingSampleRate();
}
// Copy the LMMS audio buffer to the LADSPA input buffer and initialize
// the control ports.
ch_cnt_t channel = 0;
for( ch_cnt_t proc = 0; proc < processorCount(); ++proc )
{
for( int port = 0; port < m_portCount; ++port )
{
port_desc_t * pp = m_ports.at( proc ).at( port );
switch( pp->rate )
{
case CHANNEL_IN:
for( fpp_t frame = 0;
frame < frames; ++frame )
{
pp->buffer[frame] =
_buf[frame][channel];
}
++channel;
break;
case AUDIO_RATE_INPUT:
{
ValueBuffer * vb = pp->control->valueBuffer();
if( vb )
{
memcpy( pp->buffer, vb->values(), frames * sizeof(float) );
}
else
{
pp->value = static_cast<LADSPA_Data>(
pp->control->value() / pp->scale );
// This only supports control rate ports, so the audio rates are
// treated as though they were control rate by setting the
// port buffer to all the same value.
for( fpp_t frame = 0;
frame < frames; ++frame )
{
pp->buffer[frame] =
pp->value;
}
}
break;
}
case CONTROL_RATE_INPUT:
if( pp->control == NULL )
{
break;
}
pp->value = static_cast<LADSPA_Data>(
pp->control->value() / pp->scale );
pp->buffer[0] =
pp->value;
break;
case CHANNEL_OUT:
case AUDIO_RATE_OUTPUT:
case CONTROL_RATE_OUTPUT:
break;
default:
break;
}
}
}
// Process the buffers.
for( ch_cnt_t proc = 0; proc < processorCount(); ++proc )
{
(m_descriptor->run)( m_handles[proc], frames );
}
// Copy the LADSPA output buffers to the LMMS buffer.
double out_sum = 0.0;
channel = 0;
const float d = dryLevel();
const float w = wetLevel();
for( ch_cnt_t proc = 0; proc < processorCount(); ++proc )
{
for( int port = 0; port < m_portCount; ++port )
{
port_desc_t * pp = m_ports.at( proc ).at( port );
switch( pp->rate )
{
case CHANNEL_IN:
case AUDIO_RATE_INPUT:
case CONTROL_RATE_INPUT:
break;
case CHANNEL_OUT:
for( fpp_t frame = 0;
frame < frames; ++frame )
{
_buf[frame][channel] = d * _buf[frame][channel] + w * pp->buffer[frame];
out_sum += _buf[frame][channel] * _buf[frame][channel];
}
++channel;
break;
case AUDIO_RATE_OUTPUT:
case CONTROL_RATE_OUTPUT:
break;
default:
break;
}
}
}
if( o_buf != NULL )
{
sampleBack( _buf, o_buf, m_maxSampleRate );
}
checkGate( out_sum / frames );
bool is_running = isRunning();
m_pluginMutex.unlock();
return( is_running );
}
bool CrossoverEQEffect::processAudioBuffer( sampleFrame* buf, const fpp_t frames )
{
if( !isEnabled() || !isRunning () )
{
return( false );
}
// filters update
if( m_needsUpdate || m_controls.m_xover12.isValueChanged() )
{
m_lp1.setLowpass( m_controls.m_xover12.value() );
m_lp1.clearHistory();
m_hp2.setHighpass( m_controls.m_xover12.value() );
m_hp2.clearHistory();
}
if( m_needsUpdate || m_controls.m_xover23.isValueChanged() )
{
m_lp2.setLowpass( m_controls.m_xover23.value() );
m_lp2.clearHistory();
m_hp3.setHighpass( m_controls.m_xover23.value() );
m_hp3.clearHistory();
}
if( m_needsUpdate || m_controls.m_xover34.isValueChanged() )
{
m_lp3.setLowpass( m_controls.m_xover34.value() );
m_lp3.clearHistory();
m_hp4.setHighpass( m_controls.m_xover34.value() );
m_hp4.clearHistory();
}
// gain values update
if( m_needsUpdate || m_controls.m_gain1.isValueChanged() )
{
m_gain1 = dbvToAmp( m_controls.m_gain1.value() );
}
if( m_needsUpdate || m_controls.m_gain2.isValueChanged() )
{
m_gain2 = dbvToAmp( m_controls.m_gain2.value() );
}
if( m_needsUpdate || m_controls.m_gain3.isValueChanged() )
{
m_gain3 = dbvToAmp( m_controls.m_gain3.value() );
}
if( m_needsUpdate || m_controls.m_gain4.isValueChanged() )
{
m_gain4 = dbvToAmp( m_controls.m_gain4.value() );
}
// mute values update
const bool mute1 = m_controls.m_mute1.value();
const bool mute2 = m_controls.m_mute2.value();
const bool mute3 = m_controls.m_mute3.value();
const bool mute4 = m_controls.m_mute4.value();
m_needsUpdate = false;
memset( m_work, 0, sizeof( sampleFrame ) * frames );
// run temp bands
for( int f = 0; f < frames; ++f )
{
m_tmp1[f][0] = m_lp2.update( buf[f][0], 0 );
m_tmp1[f][1] = m_lp2.update( buf[f][1], 1 );
m_tmp2[f][0] = m_hp3.update( buf[f][0], 0 );
m_tmp2[f][1] = m_hp3.update( buf[f][1], 1 );
}
// run band 1
if( ! mute1 )
{
for( int f = 0; f < frames; ++f )
{
m_work[f][0] += m_lp1.update( m_tmp1[f][0], 0 ) * m_gain1;
m_work[f][1] += m_lp1.update( m_tmp1[f][1], 1 ) * m_gain1;
}
}
// run band 2
if( ! mute2 )
{
for( int f = 0; f < frames; ++f )
{
m_work[f][0] += m_hp2.update( m_tmp1[f][0], 0 ) * m_gain2;
m_work[f][1] += m_hp2.update( m_tmp1[f][1], 1 ) * m_gain2;
}
}
// run band 3
if( ! mute3 )
{
for( int f = 0; f < frames; ++f )
{
m_work[f][0] += m_lp3.update( m_tmp2[f][0], 0 ) * m_gain3;
m_work[f][1] += m_lp3.update( m_tmp2[f][1], 1 ) * m_gain3;
}
}
// run band 4
if( ! mute4 )
{
for( int f = 0; f < frames; ++f )
{
m_work[f][0] += m_hp4.update( m_tmp2[f][0], 0 ) * m_gain4;
m_work[f][1] += m_hp4.update( m_tmp2[f][1], 1 ) * m_gain4;
}
}
const float d = dryLevel();
const float w = wetLevel();
double outSum = 0.0;
for( int f = 0; f < frames; ++f )
{
outSum = buf[f][0] * buf[f][0] + buf[f][1] * buf[f][1];
buf[f][0] = d * buf[f][0] + w * m_work[f][0];
buf[f][1] = d * buf[f][1] + w * m_work[f][1];
}
checkGate( outSum );
return isRunning();
}
