smiw_phaser

#include "Talkthrough.h"
#include <math.h>

//--------------------------------------------------------------------------//
// Function:    Process_Data()                                              //
//                                                                          //
// Description: This function is called from inside the SPORT0 ISR every    //
//              time a complete audio frame has been received. The new      //
//              input samples can be found in the variables iChannel0LeftIn,//
//              iChannel0RightIn, iChannel1LeftIn and iChannel1RightIn      //
//              respectively. The processed data should be stored in        //
//              iChannel0LeftOut, iChannel0RightOut, iChannel1LeftOut,      //
//              iChannel1RightOut, iChannel2LeftOut and iChannel2RightOut   //
//              respectively.                                               //
//--------------------------------------------------------------------------//

//**************************************************//
//                                                  //
//                      PHASER                      //
//                                                  //
//=====================SETTINGS=====================//
//                                                  //
// Współczynnik sprzężenia zwrotnego 0..1           //
#define FEEDBACK 0.6f                               //
// Dolna częstotliwość zakresu opóźnianego.            //
#define F_MIN 440.0f                                //
// Górna częstotliwość zakresu opóźnianego.           //
#define F_MAX 1100.0f                               //
// Współczynnik szybkość zmiany opóźnienia 0..1.  //
#define RATE 0.5f                                   //
// Częstotliwość próbkowania sygnału.              //
#define FS 44100.0f                                 //
//                                                  //
//==================================================//

// !!! Do piszącego spr -> coś naściemniać z https://en.wikipedia.org/wiki/Phaser_(effect)

#define PI 3.14f

// Minimalna wartość współczynnika opóźniającego.
#define D_MIN (F_MIN / FS / 2.0)
// Maksymalna wartość współczynnkia opóźniającego.
#define D_MAX (F_MAX / FS / 2.0)
// Współczynnik ikrementacji fazy sygnału LFO (Low-frequency Oscillation).
#define LFO_INC (2.0 * PI * RATE / FS)
// Wpółczynnik udziału próbki przetworzonej w sumie sygnału wyjściowego 0..1.
#define DEPTH 1.0f

#define BUFF_SIZE 98200

float lfoPhase = 0;
float delay1 = 0;

int zm1 = 0;
int AllpassDelay[6] = { 0 };
int buffRaw[BUFF_SIZE] = { 0 };
int buffPost[BUFF_SIZE] = { 0 };
int ite = 0;

// Filtr wszechprzepustowy wprowadzający opóźnienie.
// Opóźnienie sygnału (fazy sygnału) zmienne wraz ze zmianą zmiennej delay1.
// W zależności od wartości opóźnienia wpływa również na amplitudę sygnału [Wykres 1 i 2].
int AllpassDelayUpdate(int id, int inSamp) {
    int y1;
    y1 = (int)((float)inSamp * -1.0 * delay1) + AllpassDelay[id];
    AllpassDelay[id] = (int)((float)(y1 * delay1)) + inSamp;
    return y1;
}

// Ustawienie opóźnienia dla filtra, normalizacja wartości.
void setDelay(float d) {
    delay1 = (1.0f - d) / (1.0f + d);
}

void Process_Data(void)
{
    int sampleLeft = iChannel0LeftIn << 8;
    int sampleRight = iChannel0RightIn << 8;
    int sample = (sampleLeft + sampleRight) / 2;

    //student's code here

    buffRaw[ite] = sample;

    // !!! Do piszącego spr -> coś naściemniać z https://en.wikipedia.org/wiki/Low-frequency_oscillation
    // Wyznaczenie zmiennego opóźnienia dla filtru. Zmienne opóźnienie dzięki LFO(Low-frequency oscillation).
    float d = D_MIN + (D_MAX - D_MIN) * ((sin(lfoPhase) + 1.0f) / 2.0f);

    // Ikrementacja fazy współczynnika dla LFO.
    lfoPhase += LFO_INC;

    if (lfoPhase >= PI * 2.0f) {
        lfoPhase -= PI * 2.0f;
    }

    // Ustawianie opóźnienia dla filtów wszechprzepustowych.
    setDelay(d);

    // Sześć szeregowo połączonych filtów wszechprzepustowych.
    int y2;
    y2 = AllpassDelayUpdate(0,
        AllpassDelayUpdate(1,
            AllpassDelayUpdate(2,
                AllpassDelayUpdate(3,
                    AllpassDelayUpdate(4,
                        AllpassDelayUpdate(5,
                        (sample + (int)((float)zm1 * FEEDBACK)) // Suma bierzącej próbki i poprzedniej.
                        )
                    )
                )
            )
        )
    );

    zm1 = y2;
    // Próbka wyjściowa jako suma oryginalnej i przetowrzonej.
    sample = (sample + (int)((float)y2 * DEPTH)) / 2;

    buffPost[ite] = sample;
    ++ite;
    ite %= BUFF_SIZE;

    //post-processing
    sample = sample >> 8;
    iChannel0LeftOut = sample;
    iChannel0RightOut = sample;
}