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(); }