#ifndef EFFETTI_H_
#define EFFETTI_H_

class EFFETTI : public  sequenze<double>
{

public:

// Costruttore
    EFFETTI(vector<double> vIn): sequenze<double>(vIn){};


// Distruttore
    ~EFFETTI(){ };




// Effetto delay
void delay(int D)
{
	int i, p = 0;

	vector<double> w(D,0.0);

	for(i = 0; i < sequenze<double>::x.size() ; i++)  {

		//y.push_back(delay_line(w,D,p, sequenze<double>::x[i]));

		y.push_back((delay_line_1(w,D,p, sequenze<double>::x[i]) + x[i])/2);

		//y.push_back(delay_line_2(w,D,p, sequenze<double>::x[i]));


	}


 }



// Effetto vibrato con interpolatore lineare
void vibrato_linear(int N, int D0, int D1, int fc)
{
	int i, wptr = 0;

	vector<double> A(N,0.0);

	for(i = 0; i < sequenze<double>::x.size() ; i++)  {

		y.push_back(linear_delayline_f(sequenze<double>::x[i], &wptr, A, N, sin(2*PI*i/fc), D0, D1));

	}

}


// Effetto vibrato con interpolatore all-pass
void vibrato_all(int N, int D0, int D1, int fc)
{
	int i, wptr = 0;

	vector<double> A(N,0.0);

	double app = 0;

	for(i = 0; i < sequenze<double>::x.size() ; i++)  {

		y.push_back(all_delayline_f(sequenze<double>::x[i], &wptr, A, N, sin(2*PI*i/fc), D0, D1, app));

		app = y[i];
	}

}


// Effetto vibrato con interpolatore di Lagrange
void vibrato_lagrange(int N, int D0, int D1, int fc)
{
	int i, wptr = 0;

	vector<double> A(N,0.0);

	for(i = 0; i < sequenze<double>::x.size() ; i++)  {

		y.push_back(lagrange_delayline_f(sequenze<double>::x[i], &wptr, A, N, sin(2*PI*i/fc), D0, D1));

	}

}


// Effetto flanger con interpolatore lineare
void flanging_linear(int N, int D0, int D1, int fc, double g)
{
	int i, wptr = 0;

	vector<double> A(N,0.0);

	for(i = 0; i < sequenze<double>::x.size() ; i++)  {

	  y.push_back(linear_delayline_f(sequenze<double>::x[i], &wptr, A, N, sin(2*PI*i/fc), D0, D1));

	}


    for(i = 0; i < y.size() ; i++) y[i] = (x[i] + g * y[i])/2;


}


// Effetto flanger con interpolatore all-pass
void flanging_all(int N, int D0, int D1, int fc, double g)
{
	int i, wptr = 0;

	vector<double> A(N,0.0);

	double app = 0;

	for(i = 0; i < sequenze<double>::x.size() ; i++)  {

	   y.push_back(all_delayline_f(sequenze<double>::x[i], &wptr, A, N, sin(2*PI*i/fc), D0, D1, app));

	   app = y[i];
	}


    for(i = 0; i < y.size() ; i++) y[i] = (x[i] + g * y[i])/2;


}


// Effetto flanger con interpolatore di Lagrange
void flanging_lagrange(int N, int D0, int D1, int fc, double g)
{
	int i, wptr = 0;

	vector<double> A(N,0.0);

	for(i = 0; i < sequenze<double>::x.size() ; i++)  {

	  y.push_back(lagrange_delayline_f(sequenze<double>::x[i], &wptr, A, N, sin(2*PI*i/fc), D0, D1));

	}


    for(i = 0; i < y.size() ; i++) y[i] = (x[i] + g * y[i])/2;


}


// Effetto chorus a due voci con interpolatore di Lagrange
void chorus_2_voci(int N1, int D01, int D11, int N2, int D02, int D12, int fc, double g1, double g2)
{
	int i, wptr = 0;

	vector<double> A1(N1,0.0), A2(N2,0.0);

	int wptr1 =0, wptr2 = 0;

	for(i = 0; i < sequenze<double>::x.size() ; i++)  {

	  y.push_back(lagrange_delayline_f(sequenze<double>::x[i], &wptr1, A1, N1, sin(2*PI*i/fc), D01, D11));

      y[i] = (g1*y[i] + g2*lagrange_delayline_f(sequenze<double>::x[i], &wptr2, A2, N2, sin(2*PI*i/fc), D02, D12))/2;

	}


}



// Effetto di pitch modulation
void pitch_modulation(int N, int D0, int D1)
{
	int i, wptr = 0;

	vector<double> A(N,0.0);

	for(i = 0; i < sequenze<double>::x.size() ; i++)  {

		y.push_back( (x[i], &wptr, A, N, i, D0, D1));

	}

}


// Selezione della sequenza con effetto
vector<double> get_y()
{

	return y;
}


// Selezione di un elemento della sequenza con effetto
double get_y_i(int i)
{

	return y[i];
}


// Linea di ritardo I versione
double delay_line(vector<double> &w, int D, double x)
 {
  int i;
  for(i=D; i>=1; i--) w[i] = w[i-1];

  w[0] = x;

  return w[D];
 }


// Linea di ritardo II versione
double delay_line_1(vector<double> &w, int D, int &p, double x)
{
 w[p] = x;

 p = (p + 1)%D;

 return w[p];
}


// Linea di ritardo III versione
double delay_line_2(vector<double> &w, int D, int &p, double x)
{
 double y = w[p];
 w[p++] = x;

 if(p>=D) p-=D;

 return y;
}


// Linea di ritardo con interpolazione di lagrange
double lagrange_delayline(vector<double> &w, int D, int &p, double x)
{
 w[p] = x;

p = (p + 1)%D;

int k,j; double prod=1.0,sum=0.0;

 for(k=1;k<=4;k++)
  {
   prod = w[(p + (k-1))%D];

       for(j=1;j<=4;j++)
	   {
		   if(j != k ) prod = prod*(double)(2-j)/(k-j);
	   }

   sum = sum + prod;
  }

 return sum;
}



// Linea di ritardo per il pitch modulation
double pitch_modulation(double x, int *wptr, vector<double> &D, int N, int i, int D0, int p)
{




long rpi = (D0 + (1 - p)*i)%N;

D[(*wptr)++] = x;

if((*wptr) >= N) { *wptr -= N; }

return D[rpi];
}



// Linea di ritardo frazionaria variabile con interpolatore lineare
double linear_delayline_f(double x, int *wptr, vector<double> &D, int N, double y_n, int D0, int D1)
{

double i_frac = (*wptr) + D0 + D1 * y_n;
D[(*wptr)++] = x;
long rpi = ((long) floor(i_frac))%N;
double a = i_frac  - (double) floor(i_frac);


double y = a * D[rpi]  + (1 - a) * D[rpi + 1];

if((*wptr) >= N) { *wptr -= N; }

return y;
}



// Linea di ritardo frazionaria variabile con interpolatore lineare (parametro md)

double linear_delayline_f_md(double x, int *wptr, vector<double> &D, int N, double y_n, int D0, double md)
{

double i_frac = ((*wptr) + D0*(1 + md*y_n)) ;

D[(*wptr)++] = x;

long rpi = ((long) floor(i_frac))%N;
double a = i_frac  - (double) floor(i_frac);


double y = a * D[rpi]  + (1 - a) * D[rpi + 1];

if((*wptr) >= N) { *wptr -= N; }

return y;
}




// Linea di ritardo frazionaria variabile con interpolatore all-pass

double all_delayline_f(double x, int *wptr, vector<double> &D, int N, double y_n, int D0, int D1, double y_p)
{



double i_frac = (*wptr) + D0 + D1 * y_n;

D[(*wptr)++] = x;

long rpi = ((long) floor(i_frac))%N;
double a = i_frac  - (double) floor(i_frac);


double y = (1-a) * D[rpi]  + D[rpi + 1] - (1 - a) * y_p;

if((*wptr) >= N) { *wptr -= N; }

return y;
}



// Linea di ritardo frazionaria variabile con interpolatore di Lagrange

double lagrange_delayline_f(double x, int *wptr, vector<double> &D, int N, double y_n, int D0, int D1)
{



double i_frac = (*wptr) + D0 + D1 * y_n;

D[(*wptr)++] = x;

long rpi = ((long) floor(i_frac))%N;

int k,j; double prod=1.0,sum=0.0;

 for(k=1;k<=4;k++)
  {
   prod = D[(rpi + (k-1))%N];

       for(j=1;j<=4;j++)
	   {
		   if(j != k ) prod = prod*(double)(2-j)/(k-j);
	   }

   sum = sum + prod;
  }

if((*wptr) >= N) { *wptr -= N; }

return sum;
}




double lagrange_delayline_f_md(double x, int *wptr, vector<double> &D, int N, double y_n, int D0, double md)
{



double i_frac = ((*wptr) + D0*(1 + md*y_n)) ;

D[(*wptr)++] = x;

long rpi = ((long) floor(i_frac))%N;

int k,j; double prod=1.0,sum=0.0;

 for(k=1;k<=4;k++)
  {
   prod = D[(rpi + (k-1))%N];

       for(j=1;j<=4;j++)
	   {
		   if(j != k ) prod = prod*(double)(2-j)/(k-j);
	   }

   sum = sum + prod;
  }

if((*wptr) >= N) { *wptr -= N; }

return sum;
}




private:

// Campi

//  Sequenza con effetto
    vector<double> y;



};

#endif //EFFETTI_H_


// Linea di ritardo frazionaria variabile con interpolazione di lagrange (versione con vector)

#ifndef EFFETTI_SINTESI_H_
#define EFFETTI_SINTESI_H_

class corda_lagrange
{
public:

corda_lagrange(int M)
{
    m = M;

    in = vector<double>(m+2,0.0);

    }



double var_lagrange(double x, double d)
   {
    double sum = 0, prod = 1;
    int k,j;

    int a = floor(m - d);


    for(k=1;k<3;k++)
    {

        prod = in[a + k];

         for(j=1;j<3;j++)
          {
            if( j != k)
              prod = prod * (2-j)/(k-j);

          }

      sum = sum + prod;
    }


   in.push_back(x);
   in.erase(in.begin());

   return sum;
}


private:
int m;
vector<double> in;

};



#endif EFFETTI_SINTESI_H_