Diff: main.cpp

Revision:

1:f3350a372732

Parent:

0:b2f7400596ce

Child:

2:5454dee210ed

--- a/main.cpp	Thu Nov 09 21:24:50 2017 +0000
+++ b/main.cpp	Thu Nov 09 22:40:50 2017 +0000
@@ -34,22 +34,117 @@
 #define outMono DAC0
 
 #define numKeys 88
-
+#define PI M_PI
 
 //possible constants
 int carrierIncrements[numKeys];
+const int attackLimit = (0x1 << 16) - 1;
+const int fixed2Pi = (int) ((2.0 * PI) * (0x1 << 16));
+
 
 //non-constants
+//Most of these will be recalculated or reset on every input cycle of the main
+//  loop, as appropriate
 int FMmult;
 int Volume;
+int modVol;
+int modAmpI;
+int carAmpS;
 bool keysPressed[numKeys];
 int carrierPhases[numKeys];
 int modulatorPhases[numKeys];
 short envelopeStatesC[numKeys];
 short envelopeStatesM[numKeys];
 int envelopeAmpsC[numKeys];
-int envleopeAmpsM[numKeys];
+int envelopeAmpsM[numKeys];
+
+int modA;
+int modD;
+int modS;
+int modR;
+int carA;
+int carD;
+int carS;
+int carR;
+
+int fastSin(const int phase){
+    return 0;
+}
 
+void synthesize(){
+    carAmpS = 0;
+    for(int i = 0; i < numKeys; ++i){
+        if(keysPressed[i]){
+            if(envelopeStatesC[i] < 2)
+                envelopeStatesC[i] = 4;
+            if(envelopeStatesM[i] < 2)
+                envelopeStatesM[i] = 4;
+            
+            if(envelopeStatesC[i] == 4){
+                envelopeAmpsC[i] += carA;
+                if(envelopeAmpsC[i] >= attackLimit){
+                    envelopeAmpsC[i] = attackLimit;
+                    envelopeStatesC[i] = 3;
+                }
+            }
+            
+            if(envelopeStatesM[i] == 4){
+                envelopeAmpsM[i] += modA;
+                if(envelopeAmpsM[i] >= attackLimit){
+                    envelopeAmpsM[i] = attackLimit;
+                    envelopeStatesM[i] = 3;
+                }
+            }
+            
+            if(envelopeStatesC[i] == 3){
+                envelopeAmpsC[i] += carD;
+                if(envelopeAmpsC[i] <= carS){
+                    envelopeAmpsC[i] = carS;
+                    envelopeStatesC[i] = 2;
+                }
+            }
+
+            if(envelopeStatesM[i] == 3){
+                envelopeAmpsM[i] += modD;
+                if(envelopeAmpsM[i] <= modS){
+                    envelopeAmpsM[i] = modS;
+                    envelopeStatesM[i] = 2;
+                }
+            }
+        }else{
+            if(envelopeStatesC[i] > 1)
+                envelopeStatesC[i] = 1;
+            if(envelopeStatesM[i] > 1)
+                envelopeStatesM[i] = 1;
+                
+            if(envelopeStatesC[i] == 1){
+                if(envelopeAmpsC[i] <= 0){
+                    envelopeStatesC[i] = 0;
+                    envelopeAmpsC[i] = 0;
+                }else{
+                    envelopeAmpsC[i] -= carR;
+                }
+            }
+            if(envelopeStatesM[i] == 1){
+                if(envelopeAmpsM[i] <= 0){
+                    envelopeStatesM[i] = 0;
+                    envelopeAmpsM[i] = 0;
+                }else{
+                    envelopeAmpsM[i] -= modR;
+                }
+            }            
+        }
+        
+        if(envelopeAmpsC[i] > 0){
+            modulatorPhases[i] += (Fmult * carrierIncrements[i]) >> 16;
+            modAmpI = fastSin((((modulatorPhases[i] * envelopeAmpsM[i]) >> 16)
+                * modVol) >> 16);
+            carrierPhases[i] += ((carrierIncrements[i] + modAmpI) * fixed2pi) >> 16;
+            carAmps += (fastSin(carrierPhases[i]) * envelopeAmpsC[i]) >> 16;
+        }
+    }
+    outMono.write_u16(((carAmps / numKeys) * Volume) >> 16);
+}
 
 
 int main() {