CS 312 - Week 9.2 Class
CS 312 Audio Programming Winter 2020

void MainWindow::calcADSR_start_end_points()
{
    /*
        calculate sustain level from slider value
        lvlS = ui->verticalSlider_SL->value() * .01;

        calculate millisecond A D R times from slider value * 10
        msA = ui->verticalSlider_A->value() * 10;

        If you know ms duration there are 44100/1000 samples per millisecond
        calcualate attackInc = 1.0/(msA * kSamplesPerMs)


        calcualate decayInc = (1.0 - lvlS)/(msD * kSamplesPerMs)
        calcualate releasekInc = (lvlS - 0)/(msR * kSamplesPerMs)

        calculate start/end values for A D in samples
        sampStartA = 0;
        sampEndA =  msA * kSamplesPerMs
        sampStartD = end A + 1
        sampEndD = start D + number samples in D
        sampStartS = end D + 1
        NOTE: sampEndS is calculated elsewhere
            for plot it's totalPlotSamples - (A length + D length + R length)
            for sine callback its when key button is released.
        sampLenR = msR * kSamplesPerMs

*/
    // Useful for debugging
    qDebug() << "A start end" << sampStartA << " " << sampEndA;
    qDebug() << "D start end" << sampStartD << " " << sampEndD;
    qDebug() << "S start lvl" << sampStartS << " " << lvlS;
    qDebug() << "R start lvl" << sampLenR;
    // myqDebug() defined at top to display doubles with using scientific notation
    myqDebug() << "attackInc decayInc releaseInc" << attackInc << " " << decayInc << " " << releaseInc;
}

std::vector<MY_TYPE> MainWindow::stuffEnvelopeVector()
{
    calcADSR_start_end_points();

    // Calculate Slength as Slength = kEnvLength - ( sampEndD + sampLenR )

    MY_TYPE samp{0};
    int count{0};

    for ( uint32_t n = 0; n < kEnvLength; n++ )
    {
        // This what I did for attack state
        if ( count <= sampEndA )
        {
            samp += attackInc;
            if ( samp >= 1.0 )
            {
                samp = 1.0;
                adsrState = kDcyState;
            }
            venv.push_back( samp );
        }
        // Decay phase
        else if ( adsrState == kDcyState )
        {
            // decrement samp by decayInc
            // if samp < lvlS
            //    set samp = lvlS
            //    and set adsrState to kSusState
            // venv.push_back( samp );
        }
        // Sustain phase
        else if ( adsrState == kSusState )
        {
            // while Slength > 0
            // Slength--
            //    venv.push_back( samp );
            //    nd set adsrState to kRlsState
        }
        // Release
        else if ( adsrState == kRlsState )
        {
            // decrement samp by releaseInc
            // if samp < 0
            //    set samp = 0
            //    and set adsrState to kDcyState
            // venv.push_back( samp );
        }
        count++;
    }
    return venv;
}

void MainWindow::plotEnvelope()
{
    /*
        clear venv
        call stuffEnvelopeVector()
        create QVector<double> x and QVector<double> y using kEnvLength as size
        for loop to set x and y values from 0 < kEnvSize
            x are loop indices
            y are venv values
        customPlot stuff you've used before
            addGraph
            setData
            x axis setRange
            y axis setRange
            replot
        reset adsrState to kAtkState becuase it was changed in stuffEnvelopeVector()
      */
}

// Remember to change callback name in open_dac_stream()
int MainWindow::sineADSRCallback( void* outputBuffer, void* /*inputBuffer*/, unsigned int nBufferFrames,
                                  double /*streamTime*/, RtAudioStreamStatus status, void* /*userData*/ )
{
    //    if ( envAmp < 0 )
    //        return 0;

    if ( isNoteOver )
        return callbackReturnValue;

    MY_TYPE* buffer = static_cast<MY_TYPE*>( outputBuffer );
    if ( status )
        std::cout << "Stream underflow detected!" << std::endl;
    static MY_TYPE phz = 0;
    // //phase increment formula
    const MY_TYPE phzinc = k2PIT * freq;
    for ( uint32_t i = 0; i < nBufferFrames; i++ )
    {

        // implement state machine for calculating envAmp for each sample
        // Attack phase
        if ( adsrState == kAtkState )
        {
            // increment envAmp by attackInc
            // if envAmp >= 1.0
            //      set envAmp to 1.0
            //      and set adsrState to kDcyState
        }
        // Decay phase
        else if ( adsrState == kDcyState )
        {
            // decrement envAmp by decay
            // if envAmp < sustain level (lvlS)
            //      set envAmp to lvlS
            //      and set adsrState to kSusState
        }
        // Sustain phase
        else if ( adsrState == kSusState )
        {
            // set envAmp to lvlS
            //      check for isKeyUp
            //      if true set adsrState to kRlsState
        }
        // Release
        else if ( adsrState == kRlsState )
        {
            // set sampStartR to count
            // set sampEndR to sampStartR + sampLenR
            // decrement envAmp by releaseInc
            // if envAmp < 0
            //      set envAmp = 0
            //      and set isNoteOver to true
        }

        *buffer++ = sliderVolume * envAmp * sin( phz );

        phz += phzinc;
        if ( phz >= k2PI )
            phz -= k2PI;
        ++count;
    }
    rta.frameCounter += nBufferFrames;
    if ( rta.checkCount && ( rta.frameCounter >= rta.nFrames ) )
        return callbackReturnValue;

    QApplication::processEvents();

    // Usefull for debuging
    //    myqDebug() << count << " " << adsrState << " " << isKeyUp;
    return 0;
}