bool CADSREnvelope::Generate()
{
// ADSR
// A - Attack
if (m_time <= m_attack)
{
m_level = m_time / m_attack * m_sustain;
}
// R - Release
else if ((m_duration - m_release) < m_time)
{
m_level = (1 - (m_time - (m_duration - m_release)) / m_release) * m_sustain;
}
// D - Decay
else if (m_time > m_attack && m_time <= m_attack + m_decay)
{
m_level = (m_level - 1) * ((m_time - (m_duration - m_decay)) / m_decay) + 1;
}
// S - Sustain
else
{
m_level = m_sustain;
}
// update the time
m_time += GetSamplePeriod();
return m_duration > m_time;
}
bool CSubtractiveInstrument::Generate()
{
if (mWaveform == Sawtooth)
{
mSawtooth.Generate();
}
else if (mWaveform == Triangle)
{
mTriangle.Generate();
}
else if (mWaveform == Square)
{
mSquare.Generate();
}
auto valid = mSubtractiveAmplitudeFilter.Generate();
// Read the component's sample and make it our resulting frame.
m_frame[0] = mSubtractiveAmplitudeFilter.Frame(0);
m_frame[1] = mSubtractiveAmplitudeFilter.Frame(1);
// Update time
mTime += GetSamplePeriod();
// We return true until the time reaches the duration.
return valid;
}
bool CSineWave::Generate()
{
m_frame[0] = m_amp * sin(m_phase * 2 * PI);
m_frame[1] = m_frame[0];
m_phase += m_freq * GetSamplePeriod();
return true;
}
bool CSubtractiveAmplitudeFilter::Generate()
{
auto amplitudeFactor = mEnvelope->GetEnvelopeLevel();
m_frame[0] = amplitudeFactor * mSource->Frame(0);
m_frame[1] = amplitudeFactor * mSource->Frame(1);
mTime += GetSamplePeriod();
return mTime < mDuration;
}
bool CWaveInstrumentB::Generate()
{
m_durationInTime = m_duration * (1/(m_bpmMaster/60));
bool valid = m_ar.Generate();
m_frame[0] = m_ar.Frame(0);
m_frame[1] = m_ar.Frame(1);
m_time += GetSamplePeriod();
return valid;
}
void CRingModulationEffect::Process(double * const &frame)
{
// determine the second waveform
double sample = sin(m_phase);
// modify the input
for (unsigned int i = 0; i < GetChannels(); i++)
{
frame[i]*= sample;
}
// increment the phase
m_phase+= 2 * M_PI * m_frequency * GetSamplePeriod();
}
bool CAR::Generate(){
m_source->Generate(); //run generate for source--sinewave
//write in frames--by checking time
//if less than attach time then take in account attack
if (m_time < m_attack){
m_frame[0] = m_source->Frame(0)*m_time/m_attack;
m_frame[1] = m_source->Frame(1)*m_time/m_attack;
m_amplitude_factor = 1;
}
/*else if (m_time < (m_attack)+.25){
//if during first .5s then increase volume x6 and slowly decay until at normal amplitude (factor *1)
//comment test5
m_amplitude_factor = 1.5;
for (double i = 0.0; i < .25; i +=.01){
m_frame[0] = m_source->Frame(0)*m_amplitude_factor;
m_frame[1] = m_source->Frame(1)*m_amplitude_factor;
m_amplitude_factor -= .06;
}
}*/
//if during normal time treat like normal--mroe than attack but less than total duration -release
else if (m_time < (m_time-m_release))
{
m_amplitude_factor = 1.0;
m_frame[0] = m_source->Frame(0);
m_frame[1] = m_source->Frame(1);
}
//else during release time
else
{
m_frame[0] = m_source->Frame(0) * (m_duration - m_time) / m_release;
m_frame[1] = m_source->Frame(1) * (m_duration - m_time) / m_release;
}
// Update time
m_time += GetSamplePeriod();
// We return true until the time reaches the duration.
return m_time < m_duration;
}
bool CSubtractiveADSREnvelope::Generate()
{
if (mTime <= mAttack) // attack
{
mEnvelopeLevel = mTime / mAttack * mSustainLevel;
}
else if (mTime > mDuration - mRelease) // release
{
mEnvelopeLevel = (1 - (mTime - (mDuration - mRelease)) / mRelease) * mSustainLevel;
}
else if (mTime > mAttack && mTime <= mAttack + mDecay) // decay
{
mEnvelopeLevel = (mSustainLevel - 1) * ((mTime - (mDuration - mDecay)) / mDecay) + 1;
}
else // sustain
{
mEnvelopeLevel = mSustainLevel;
}
mTime += GetSamplePeriod();
return mTime < mDuration;
}
bool CPianoEnvelope::Generate()
{
double decay = GetSamplePeriod()/4;
if(m_sustain)
{
m_duration = 30;
decay = GetSamplePeriod()/50;
m_pedalPressed = true;
}
else if(!m_sustain && m_pedalPressed == true)
{
m_time = m_duration - 0.3;
m_pedalPressed = false;
}
//
// Part 1: Determine the current gain. This depends
// on what time period we are in.
//
double gain = 1;
if(m_duration > 0.00)
{
if(m_time < m_attack)
{
// m_time/m_attack goes from 0 to 1 in the period
gain = m_time / m_attack;
}
else if(m_time > (m_duration - m_release) && m_time < m_duration)
{
double releaseStart = m_duration - m_release;
// (m_time - releaseStart) / (m_duration - releaseStart) goes
// from 0 to 1 in the release period. Subtract from 1 to make
// it go from 1 to 0
gain = 1 - (m_time - releaseStart) / (m_duration - releaseStart);
}
else if(m_time > 1.0 && m_time < m_duration)
{
if(tmpgain >= 0)
gain = tmpgain-decay;
else
gain = tmpgain+decay;
}
}
if(m_time >= m_duration)
{
// If we are done, set the audio to silence and
// return false.
m_frame[0] = m_frame[1] = 0;
return false;
}
tmpgain = gain;
//
// Part 2: Generate the output from the input multiplied
// by the gain.
//
if(m_source != NULL)
{
m_frame[0] = m_source->Frame(0) * gain;
m_frame[1] = m_source->Frame(1) * gain;
}
//
// Part 3: Update the time.
//
m_time += GetSamplePeriod();
return true;
}
