ADSR now properly releases when the Gate is closed during any phase other than Sustain.

Vexatos · Vexatos · commit 8a55fb269adb · 2016-05-07T19:49:34.000+02:00
diff --git a/src/main/java/pl/asie/computronics/util/sound/AudioUtil.java b/src/main/java/pl/asie/computronics/util/sound/AudioUtil.java
@@ -38,6 +38,9 @@ public double getValue(AudioState process, State state) {
 		Closed {
 			@Override
 			public double getValue(AudioState process, State state) {
+				if(state.envelope != null && state.envelope.phase != null) {
+					return Open.getValue(process, state);
+				}
 				return 0;
 			}
 		};
@@ -87,25 +90,24 @@ public double getModifiedValue(AudioState process, State state, double value) {
 			if(mstate.gate == Gate.Closed) {
 				return value;
 			}
-			Wave modulator = mstate.wave;
 			return value * (1 + mstate.gate.getValue(process, mstate));
 		}
 	}
 
 	public static class ADSR {
 
-		private int attackDuration;
-		private int decayDuration;
+		private double attackDuration;
+		private double decayDuration;
 		private float attenuation;
-		private int releaseDuration;
+		private double releaseDuration;
 		private Phase phase = Phase.Attack;
-		private int progress;
+		private double progress = 0;
 
 		public ADSR(int attackDuration, int decayDuration, float attenuation, int releaseDuration) {
-			this.attackDuration = Math.min(attackDuration * Config.SOUND_SAMPLE_RATE / 1000, 1);
-			this.decayDuration = Math.min(decayDuration * Config.SOUND_SAMPLE_RATE / 1000, 1);
-			this.attenuation = attenuation;
-			this.releaseDuration = Math.min(releaseDuration * Config.SOUND_SAMPLE_RATE / 1000, 1);
+			this.attenuation = Math.min(Math.max(attenuation, 0), 1);
+			this.attackDuration = 1000D / (double) (Math.max(attackDuration, 1) * Config.SOUND_SAMPLE_RATE);
+			this.decayDuration = ((this.attenuation - 1D) * 1000D) / (double) (Math.max(decayDuration, 1) * Config.SOUND_SAMPLE_RATE);
+			this.releaseDuration = (-this.attenuation * 1000D) / (double) (Math.max(releaseDuration, 1) * Config.SOUND_SAMPLE_RATE);
 		}
 
 		public double getModifiedValue(State state, double value) {
@@ -114,41 +116,39 @@ public double getModifiedValue(State state, double value) {
 			}
 			if(state.gate == Gate.Closed && phase != Phase.Release) {
 				phase = Phase.Release;
-				progress = 0;
 			}
+			value = value * progress;
 			switch(phase) {
 				case Attack: {
-					value = value * (progress / attackDuration);
-					if(++progress >= attackDuration) {
-						nextPhase(state);
+					// value = value * (progress / (double) attackDuration);
+					if((progress += attackDuration) >= 1) {
+						progress = 1;
+						nextPhase();
 					}
-					return value;
+					break;
 				}
 				case Decay: {
-					value = value * (((attenuation - 1) * (progress / decayDuration)) + 1);
-					if(++progress >= decayDuration) {
-						nextPhase(state);
+					// value = value * (1 + ((attenuation - 1) * (progress / (double) decayDuration)));
+					if((progress += decayDuration) <= attenuation) {
+						progress = attenuation;
+						nextPhase();
 					}
-					return value;
-				}
-				case Sustain: {
-					return value * attenuation;
+					break;
 				}
 				case Release: {
-					value = value * (((-attenuation) * (progress / releaseDuration)) + attenuation);
-					if(++progress >= releaseDuration) {
+					// value = value * (attenuation * (1 - (progress / (double) releaseDuration)));
+					if((progress += releaseDuration) <= 0) {
 						phase = null;
 						progress = 0;
 					}
-					return value;
+					break;
 				}
 			}
 			return value;
 		}
 
-		private void nextPhase(State state) {
+		private void nextPhase() {
 			phase = phase.next();
-			progress = 0;
 		}
 
 		private enum Phase {
