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

Vexatos · Vexatos · commit 655c8fd8e7c1 · 2016-05-07T19:56:08.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 attackSpeed;
+		private double decaySpeed;
 		private float attenuation;
-		private int releaseDuration;
+		private double releaseSpeed;
 		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.attackSpeed = attackDuration > 0 ? 1000D / (double) (attackDuration * Config.SOUND_SAMPLE_RATE) : -1;
+			this.decaySpeed = decayDuration > 0 ? ((this.attenuation - 1D) * 1000D) / (double) (decayDuration * Config.SOUND_SAMPLE_RATE) : -1;
+			this.releaseSpeed = releaseDuration > 0 ? (-this.attenuation * 1000D) / (double) (releaseDuration * Config.SOUND_SAMPLE_RATE) : -1;
 		}
 
 		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 *= progress;
 			switch(phase) {
 				case Attack: {
-					value = value * (progress / attackDuration);
-					if(++progress >= attackDuration) {
-						nextPhase(state);
+					// value = value * (progress / (double) attackSpeed);
+					if(attackSpeed < 0 || (progress += attackSpeed) >= 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) decaySpeed)));
+					if(decaySpeed < 0 || (progress += decaySpeed) <= 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) releaseSpeed)));
+					if(releaseSpeed < 0 || (progress += releaseSpeed) <= 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 {
