Программа-синтезатор

struct KEY
{
    UINT press; //клавиша нажата (активна)
    BYTE midi_key_press;    //была нажата миди клавиша
    BYTE key_unpress;   //была отпущена клавиша на клавиатуре
    double decrement;
    double Ampl;
 
    double t;   //время(в условных единицах) сигнала
    double A,D,S,R; //блок констант ADSR (Attack-Decay-Sustain-Release)
    double A_add;   //скорость увеличения A (атака)
 
//  double sawSource;
    double sawSource1;
    double sawSource2;
    
    double filter1 ;
    double filter2 ;
    double filter3 ;
 
    double fRez1;
    double fRez2;
    double fRez3;
 
    double ss1;
    double ss2;
    double ss3;
 
    double pianoamp;
    int     frameCount;
    double resonance;
    double polarity;
    
    double pianostr1;
    double pianostr2;
    double pianostr3;
 
    void ResetFilter()
    {
        sawSource1=0;
        sawSource2=0;
        
        filter1=0;
        filter2=0;
        filter3=0;
        fRez1 = rezMax;
        fRez2 = rezMax;
        fRez3 = rezMax;
        ss1=0;
        ss2=0;
        ss3=0;
 
    }
 
    void SetPianoRand()
    {
        pianostr1 = rand() / 16384.0 - 1.0;
        pianostr2 = rand() / 16384.0 - 1.0;
        pianostr3 = rand() / 16384.0 - 1.0;
 
    }
 
    KEY() 
    { 
        press=0; 
        key_unpress=TRUE;
 
        decrement=0; Ampl=0; t=0; A=D=S=R=0; A_add=0; 
        
        pianoamp=1.0; frameCount=0; resonance=1.0; polarity=1.0;
 
        SetPianoRand();
        
        
        midi_key_press=0; 
 
        ResetFilter();
 
 
    }
 
} Keys[128];
 
double Piano(int keyN, double Ampl, double freq, double t, double phase);

int sl1, sl2, sl3, sl4, sl5, sl6;
int slm2, slm3, slm4, slm5, slm6;
int slvolume;
 
 
const garm_c=50;
double randarray[garm_c];// =    {3, 7, 17, 22, 23, 27, 29, 37, 43, 47}; // якобы случайные числа
double randarray_amplitude[garm_c];// = { 1, 0.7, 0.5, 0.9, 0.1, 0, 1, 0.9, 0.9, 0.8}; 
 
//double randarray2[garm_c] =    {1, 3, 7, 17, 22, 23, 27, 29, 37, 43, 47}; // 
//double randarray_amplitude2[garm_c] = { 1, 0.7, 0.5, 0.9, 0.1, 0, 1, 0.9, 0.9, 0.8}; 
 
 
//функция Piano используется для генерации звука
 
//сигнал в соответствии с эквалайзером в графическом интерфейсе программы
//Ampl амплитуда
//freq базовая частота сигнала
//flag_one число используемых и вычисленных гармоник
 
//freq_actual записывается последняя вычисленная частота
//если flag_one==1, значит была использована только одна гармоника,
//а остальные слайдеры опущены вниз
double Piano(int keyN,double Ampl, double freq, double t, double phase, int & flag_one, double & freq_actual)
{
    double static tmp1,tmp2;
 
    flag_one=0;
 
    //if (sl1 && !g_mainwindow->m_check_saw3) {flag_one++;freq_actual=freq;}    //base frequency
    if (sl1) {flag_one++;freq_actual=freq;} //base frequency
    //if (sl2) {flag_one++;freq_actual=freq*2;}
    if (sl2) {flag_one++;freq_actual=freq;}
    
    //if (sl3) {flag_one++;freq_actual=freq*3;}
    if (sl3) {flag_one++;freq_actual=freq;}
 
    if (sl4) {flag_one++;freq_actual=freq;}
    
    //if (sl5) {flag_one++;freq_actual=freq*5;}
    if (sl5) {flag_one++;freq_actual=freq*garmonic_5;}
    
    //if (sl6) {flag_one++;freq_actual=freq*6;}
    if (sl6) {flag_one++; freq_actual=freq*garmonic_6;}
 
    if (slm2) {flag_one++;freq_actual=freq/2;}
    if (slm3) {flag_one++;freq_actual=freq/3;}
    if (slm4) {flag_one++;freq_actual=freq/4;}
    if (slm5) {flag_one++;freq_actual=freq/5;}
    if (slm6) {flag_one++;freq_actual=freq/6;}
 
    double k=0; //итоговая вычисленная сумма 
 
    double limit=20500; //ограничение частоты
 
    //амплитуда сигнала
    double AMP=Ampl;
 
    //***^^^*** связано с амплитудной модуляцией
    AMP+=
        g_modulation_amplitude_value//глубина модуляции
        *sin(g_modulation_t);
 
    double f;   //частота отдельной синусоиды
    //freq базовая синусоида
 
    //если поднят первый слайдер (базовая гармоника)
    if (sl1) {
 
        if (g_mainwindow->m_check_saw3)
        {
            double dt=1 + cCircleSlider_detune->GetValue()/5000.0;
            //double dt=1 + 1.0/pow(2, cCircleSlider_detune->GetValue()/10.0);
 
 
            double myconst = (myMax - myMin) / SAMPLE_RATE;
 
            //Keys[keyN].sawSource1 += freq * 0.000032 * dt;
            //Keys[keyN].sawSource2 += freq * 0.000032 / dt;
            
            //Keys[keyN].sawSource1 += freq * myconst * dt;
            //Keys[keyN].sawSource2 += freq * myconst / dt;
 
            //int fmodulation_f = 50; // частота частотной модуляции
            //int fmodulation_d = 50; // глубина частотной модуляции
 
            double fmodulation_f = cCircleSlider_6->GetValue(); // частота частотной модуляции
            double fmodulation_d = cCircleSlider_7->GetValue(); // глубина частотной модуляции
 
            double fmodulation = 1 + (1 - pow(1.001, fmodulation_d)) * sin(t * pow(1.015, fmodulation_f));
            
            Keys[keyN].sawSource1 += freq * myconst * dt * fmodulation;
            Keys[keyN].sawSource2 += freq * myconst / dt * fmodulation;
            
            //Keys[keyN].sawSource1 += freq * myconst * dt;
            //Keys[keyN].sawSource2 += freq * myconst / dt;
 
            //8jul2020
            //if(Keys[keyN].sawSource1 >= myMax) Keys[keyN].sawSource1 = myMin - myMax + Keys[keyN].sawSource1;
            //if(Keys[keyN].sawSource2 >= myMax) Keys[keyN].sawSource2 = myMin - myMax + Keys[keyN].sawSource2;
            
            if(Keys[keyN].sawSource1 >= myMax){
                tmp1 = Keys[keyN].sawSource1 - myMax;
                Keys[keyN].sawSource1 = myMin;
            }
            if(Keys[keyN].sawSource2 >= myMax){
                tmp2 = Keys[keyN].sawSource2 - myMax;
                Keys[keyN].sawSource2 = myMin;
            }
 
            
            //if(Keys[keyN].sawSource1 >= myMax) Keys[keyN].sawSource1 = myMin;
            //if(Keys[keyN].sawSource2 >= myMax) Keys[keyN].sawSource2 = myMin;
            
            double sawSource = Keys[keyN].sawSource1 + Keys[keyN].sawSource2+ tmp1 + tmp2;
 
            if (g_mainwindow->m_check_filter1 == 0)
            {
                Keys[keyN].filter1=sawSource;
            }
 
            else
            {
                filterSpeed = //500 * (cCircleSlider_filterspeed->GetValue()+1);
 
                //pow(2, 9 + cCircleSlider_filterspeed -> GetValue() / 15.0);
                pow(2, 9 + cCircleSlider_filterspeed -> GetValue() / 10.0);
 
                Keys[keyN].fRez1 -= (Keys[keyN].fRez1 - rezMin) / filterSpeed;
                //Keys[keyN].ss1 += (sawSource - Keys[keyN].filter1) / pow(2, rezMax - Keys[keyN].fRez1 + 4);
                Keys[keyN].ss1 += (sawSource - Keys[keyN].filter1) / pow(4, 6 - Keys[keyN].fRez1);
 
                //Keys[keyN].ss1 /= 1.02;
                Keys[keyN].ss1 /= 1.01;
                Keys[keyN].filter1 += Keys[keyN].ss1;
            }
                
                        
            k += Keys[keyN].filter1 * sl1/100.0; // базовый звук
            
    
            //k *= sl1 / 100.0;
        }
        else
        {
            f=freq; 
            
            if (f<limit) k+=sl1/100.0*sin(f*t);
        }
        
    }
 
    //если поднят второй слайдер 
    if (sl2) 
    {
        //f=2*freq; 
        
        f=freq; 
        //floor
        //double val=floor(sin(f*t)+0.1);
        double val=sin(f*t);
        double fix=cCircleSlider_sqr->GetValue()/100.0;
        //double fix=0;
 
        if (val>=fix) val=1;
        if (val<-fix) val=-1;
        
 
        if (f<limit) k+=sl2/100.0*val; 
    }
 
    if (sl3) 
    {
        
        ///f=3*freq; 
        ////if (f<limit) k+=sl3/100.0*sin(f*t); 
 
        bool randgarmony = true; // разрешение выполнять функцию ниже
        if(randgarmony == true)
        {
 
            //double out = 0.4 * sin(freq * t); //base freq
            double out = 0;
 
            for(int i = 0; i < garm_c; i ++) 
            {
                //out += 0.1/(i+1) * sin(freq * randarray[i] * t);
                if (randarray[i])
                {
                    double f=freq * i;
                    if (f<limit)
                    {
                        out += randarray_amplitude[i] * sin(f*t);
                    }
                }
            }
 
             // дальше уже знакомый код фильтра, только на вход подаём переменную out
            filterSpeed = pow(2, 9 + cCircleSlider_filterspeed -> GetValue() / 10.0);
            
            Keys[keyN].fRez2 -= (Keys[keyN].fRez2 - rezMin) / filterSpeed;
        
            /*if ( (Keys[keyN].fRez2-rezMin)<0.5)
            {
                Keys[keyN].ResetFilter();
            }*/
 
            
            Keys[keyN].ss2 += (out - Keys[keyN].filter2) / pow(4, 6 - Keys[keyN].fRez2);
            //Keys[keyN].ss1 /= 1.02;
            Keys[keyN].ss2 /= 1.01 ;
            Keys[keyN].filter2 += Keys[keyN].ss2;
 
            global_fRez2=Keys[keyN].fRez2;
            global_ss2=Keys[keyN].ss2;
            global_filter2=Keys[keyN].filter2;
 
 
            double filterSpeed3 = pow(2, 9 + cCircleSlider_filterspeed2 -> GetValue() / 10.0);
            
            Keys[keyN].fRez3 -= (Keys[keyN].fRez3 - rezMin) / filterSpeed3;
            Keys[keyN].ss3 += (out - Keys[keyN].filter3) / pow(4, 6 - Keys[keyN].fRez3);
            Keys[keyN].ss3 /= 1.01 ;
            Keys[keyN].filter3 += Keys[keyN].ss3;
 
 
            
            int filter_on=g_mainwindow->m_check_filter2;
            if (filter_on)
            {
                //k += Keys[keyN].filter2 * sl3 * 0.01; // добавляем результат в общий поток
                k += 0.5*(Keys[keyN].filter2 + Keys[keyN].filter3)* sl3 * 0.01; // добавляем результат в общий поток
            }
            else
            {
                k += out * sl3 * 0.01;
            }
 
        }
 
    
    
    }
 
    //if (sl4) { f=4*freq; if (f<limit) k+=sl4/100.0*sin(f*t); }
////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
//вот тут пианино 
////////////////////////////////////////////////////////////////////////////////////////////////
        //если поднят слайдер N4. если нет, код не выполняется
    if (sl4) 
        {
 
        double str1 = pow(piano_detune, Keys[keyN].pianostr1);
        double str2 = pow(piano_detune, Keys[keyN].pianostr2);
        double str3 = pow(piano_detune, Keys[keyN].pianostr3);
    
        double freq1 = freq / 64;
        
        if(sin(Keys[keyN].frameCount / camerton * freq1) * Keys[keyN].polarity < 0){
        
            Keys[keyN].polarity = -Keys[keyN].polarity;
            Keys[keyN].resonance = 1.0;
            
        }
        
        Keys[keyN].pianoamp /= fadeOut;
        Keys[keyN].resonance /= 1.01;
        
        double fm = 50.0 * sin( Keys[keyN].frameCount / camerton * freq1 * floor(12 / freq1)) * Keys[keyN].resonance;
        
        double fm1 = 50.0 * sin( Keys[keyN].frameCount / camerton * freq1 * floor(12 / freq1) * str1) * Keys[keyN].resonance;
        double fm2 = 50.0 * sin( Keys[keyN].frameCount / camerton * freq1 * floor(12 / freq1) * str2) * Keys[keyN].resonance;
        double fm3 = 50.0 * sin( Keys[keyN].frameCount / camerton * freq1 * floor(12 / freq1) * str3) * Keys[keyN].resonance;
        
        double garmony = (Keys[keyN].frameCount + fm1) / camerton * freq1;
        double k1 = Keys[keyN].pianoamp * (sin(garmony) + sin(garmony * 2.0));
        
        garmony = (Keys[keyN].frameCount + fm2) / camerton * freq1;
        k1 += Keys[keyN].pianoamp * (sin(garmony) + sin(garmony * 2.0));
        
        garmony = (Keys[keyN].frameCount + fm3) / camerton * freq1;
        k1 += Keys[keyN].pianoamp * (sin(garmony) + sin(garmony * 2.0));
        
        k += k1 * sl4 / 100;
        
        Keys[keyN].frameCount ++;
 
    }
    
    //if (sl5) { f=5*freq; if (f<limit) k+=sl5/100.0*sin(f*t); }
    if (sl5) { f=garmonic_5*freq; if (f<limit) k+=sl5/100.0*sin(f*t); }
 
    //if (sl6) { f=6*freq; if (f<limit) k+=sl6/100.0*sin(f*t); }
    if (sl6) { f=garmonic_6*freq; if (f<limit) k+=sl6/100.0*sin(f*t); }
 
 
    //в два и более раза меньшие гармоники
    if(slm2) k+=slm2/100.0*sin(freq/2*t);
    if(slm3) k+=slm3/100.0*sin(freq/3*t);
    if(slm4) k+=slm4/100.0*sin(freq/4*t);
    if(slm5) k+=slm5/100.0*sin(freq/5*t);
    if(slm6) k+=slm6/100.0*sin(freq/6*t);
 
    //***^^^*** свяазано с модуляцией
    if (g_modulation_amplitude_value)
    {
        return k *  (slvolume/100.0) * AMP  ;
    }
    else
    {
        return k *  (slvolume/100.0);
    }
}