* Take advantage of phase being in the range [0,1)

- Integrated from the integer phase code branch
* Add linearly-interpolated noise
- Uses IntegratedPolyBLEP for bandlimiting

Author: [email protected]

Diff for: Wave.cpp

@@ -27,14 +27,15 @@ WaveEvaluate const wave_evaluate[WAVE_COUNT] =
 	OscillatorTriangle,		// WAVE_TRIANGLE,
 	OscillatorNoise,		// WAVE_NOISE,
 	OscillatorNoiseHold,	// WAVE_NOISE_HOLD
-	OscillatorPoly4,		// WAVE_POLY4,
-	OscillatorPoly5,		// WAVE_POLY5,
-	OscillatorPeriod93,		// WAVE_PERIOD93,
-	OscillatorPoly9,		// WAVE_POLY9,
-	OscillatorPoly17,		// WAVE_POLY17,
-	OscillatorPulsePoly5,	// WAVE_PULSE_POLY5,
-	OscillatorPoly4Poly5,	// WAVE_POLY4_POLY5,
-	OscillatorPoly17Poly5,	// WAVE_POLY17_POLY5,
+	OscillatorNoiseSlope,	// WAVE_NOISE_SLOPE
+	OscillatorPoly,			// WAVE_POLY4,
+	OscillatorPoly,			// WAVE_POLY5,
+	OscillatorPoly,			// WAVE_PERIOD93,
+	OscillatorPoly,			// WAVE_POLY9,
+	OscillatorPoly,			// WAVE_POLY17,
+	OscillatorPoly,			// WAVE_PULSE_POLY5,
+	OscillatorPoly,			// WAVE_POLY4_POLY5,
+	OscillatorPoly,			// WAVE_POLY17_POLY5,
 };
 
 // names for wave types
@@ -46,6 +47,7 @@ char const * const wave_name[WAVE_COUNT] =
 	"Triangle",		// WAVE_TRIANGLE,
 	"Noise",		// WAVE_NOISE,
 	"Noise Hold",	// WAVE_NOISE_HOLD
+	"Noise Slope",	// WAVE_NOISE_SLOPE
 	"Poly4",		// WAVE_POLY4,
 	"Poly5",		// WAVE_POLY5,
 	"Period-93",	// WAVE_PERIOD93,
@@ -68,6 +70,7 @@ float const wave_adjust_frequency[WAVE_COUNT] =
 	1.0f,					// WAVE_TRIANGLE,
 	1.0f, 					// WAVE_NOISE,
 	1.0f,					// WAVE_NOISE_HOLD,
+	1.0f,					// WAVE_NOISE_SLOPE,
 	2.0f * 15.0f / 16.0f,	// WAVE_POLY4,
 	2.0f * 31.0f / 32.0f,	// WAVE_POLY5,
 	2.0f * 93.0f / 128.0f,	// WAVE_PERIOD93,
@@ -88,6 +91,7 @@ int const wave_loop_cycle[WAVE_COUNT] =
 	INT_MAX,					// WAVE_TRIANGLE,
 	INT_MAX,					// WAVE_NOISE,
 	ARRAY_SIZE(noise),			// WAVE_NOISE_HOLD
+	ARRAY_SIZE(noise),			// WAVE_NOISE_SLOPE
 	ARRAY_SIZE(poly4),			// WAVE_POLY4,
 	ARRAY_SIZE(poly5),			// WAVE_POLY5,
 	ARRAY_SIZE(period93),		// WAVE_PERIOD93,

Diff for: Wave.h

@@ -21,6 +21,7 @@ enum Wave
 	WAVE_TRIANGLE,
 	WAVE_NOISE,
 	WAVE_NOISE_HOLD,
+	WAVE_NOISE_SLOPE,
 
 	WAVE_POLY4,			// Atari POKEY AUDC 12
 	WAVE_POLY5,			// Atari TIA AUDC 7 or 9

Diff for: WaveHold.cpp

@@ -58,8 +58,65 @@ static float OscillatorHold(OscillatorConfig const &config, OscillatorState &sta
 	return value;
 }
 
+// shared data oscillator
+static float OscillatorLerp(OscillatorConfig const &config, OscillatorState &state, float data[], int cycle, float step)
+{
+	if (step > 0.5f * cycle)
+		return 0;
+
+	// current and next wavetable value
+	int const index0 = state.index;
+	float const value0 = data[index0];
+	int const index1 = state.index < cycle ? state.index + 1 : 0;
+	float const value1 = data[index1];
+	float value = value0 + (value1 - value0) * state.phase;
+
+#if ANTIALIAS == ANTIALIAS_POLYBLEP
+	if (use_antialias)
+	{
+		float w = Min(step * INTEGRATED_POLYBLEP_WIDTH, 8.0f);
+
+		int const back = FloorInt(state.phase - w);
+		int const ahead = FloorInt(state.phase + w);
+		int const count = ahead - back;
+		if (count > 0)
+		{
+			int i = index0 + back + cycle;
+			if (i >= cycle)
+				i -= cycle;
+			float const vn1 = data[i];
+			if (++i >= cycle)
+				i -= cycle;
+			float t = state.phase - back;
+			float v0 = data[i];
+			float s0 = v0 - vn1;
+			for (int c = 0; c < count; ++c)
+			{
+				if (++i >= cycle)
+					i -= cycle;
+				t -= 1.0f;
+				float const v1 = data[i];
+				float const s1 = v1 - v0;
+				if (s0 != s1)
+					value += IntegratedPolyBLEP(t, w, s1 - s0);
+				v0 = v1;
+				s0 = s1;
+			}
+		}
+	}
+#endif
+	return value;
+}
+
+
 // sample-and-hold noise
-extern float OscillatorNoiseHold(OscillatorConfig const &config, OscillatorState &state, float step)
+float OscillatorNoiseHold(OscillatorConfig const &config, OscillatorState &state, float step)
 {
 	return OscillatorHold(config, state, noise, ARRAY_SIZE(noise), step);
 }
+
+// linear interpolated noise
+float OscillatorNoiseSlope(OscillatorConfig const &config, OscillatorState &state, float step)
+{
+	return OscillatorLerp(config, state, noise, ARRAY_SIZE(noise), step);
+}

Diff for: WaveHold.h

@@ -8,3 +8,4 @@ extern void InitNoise();
 
 // sample-and-hold noise
 extern float OscillatorNoiseHold(OscillatorConfig const &config, OscillatorState &state, float step);
+extern float OscillatorNoiseSlope(OscillatorConfig const &config, OscillatorState &state, float step);

Diff for: WavePoly.cpp

@@ -24,6 +24,25 @@ char pulsepoly5[ARRAY_SIZE(poly5) * 2];
 char poly4poly5[ARRAY_SIZE(poly5) * ARRAY_SIZE(poly4)];
 char poly17poly5[ARRAY_SIZE(poly5) * ARRAY_SIZE(poly17)];
 
+static char const * const poly_data[WAVE_COUNT] =
+{
+	NULL,			// WAVE_SINE,
+	NULL,			// WAVE_PULSE,
+	NULL,			// WAVE_SAWTOOTH,
+	NULL,			// WAVE_TRIANGLE,
+	NULL,			// WAVE_NOISE,
+	NULL,			// WAVE_NOISE_HOLD,
+	NULL,			// WAVE_NOISE_SLOPE,
+	poly4,			// WAVE_POLY4,
+	poly5,			// WAVE_POLY5,
+	period93,		// WAVE_PERIOD93,
+	poly9,			// WAVE_POLY9,
+	poly17,			// WAVE_POLY17,
+	pulsepoly5,		// WAVE_PULSE_POLY5,
+	poly4poly5,		// WAVE_POLY4_POLY5,
+	poly17poly5,	// WAVE_POLY17_POLY5,
+};
+
 // generate polynomial table
 // from Atari800 pokey.c
 static void InitPoly(char aOut[], int aSize, int aTap, unsigned int aSeed, char aInvert)
@@ -104,13 +123,17 @@ void InitPoly()
 }
 
 // shared poly oscillator
-static float OscillatorPoly(OscillatorConfig const &config, OscillatorState &state, char poly[], int cycle, float step)
+float OscillatorPoly(OscillatorConfig const &config, OscillatorState &state, float step)
 {
+	// poly info for the wave type
+	int const cycle = wave_loop_cycle[config.wavetype];
 	if (step > 0.5f * cycle)
 		return 0;
 
 	// current wavetable value
+	char const * const poly = poly_data[config.wavetype];
 	float value = poly[state.index];
+
 #if ANTIALIAS == ANTIALIAS_POLYBLEP
 	if (use_antialias)
 	{
@@ -139,59 +162,6 @@ static float OscillatorPoly(OscillatorConfig const &config, OscillatorState &sta
 		}
 	}
 #endif
-	return value + value - 1.0f;
-}
-
-// poly4 oscillator
-// 4-bit linear feedback shift register noise
-float OscillatorPoly4(OscillatorConfig const &config, OscillatorState &state, float step)
-{
-	return OscillatorPoly(config, state, poly4, ARRAY_SIZE(poly4), step);
-}
-
-// poly5 oscillator
-// 5-bit linear feedback shift register noise
-float OscillatorPoly5(OscillatorConfig const &config, OscillatorState &state, float step)
-{
-	return OscillatorPoly(config, state, poly5, ARRAY_SIZE(poly5), step);
-}
-
-// period93 oscillator
-// 15-bit linear feedback shift register noise with variant tap position
-float OscillatorPeriod93(OscillatorConfig const &config, OscillatorState &state, float step)
-{
-	return OscillatorPoly(config, state, period93, ARRAY_SIZE(period93), step);
-}
 
-// poly9 oscillator
-// 9-bit linear feedback shift register noise
-float OscillatorPoly9(OscillatorConfig const &config, OscillatorState &state, float step)
-{
-	return OscillatorPoly(config, state, poly9, ARRAY_SIZE(poly9), step);
-}
-
-// poly17 oscillator
-// 17-bit linear feedback shift register noise
-float OscillatorPoly17(OscillatorConfig const &config, OscillatorState &state, float step)
-{
-	return OscillatorPoly(config, state, poly17, ARRAY_SIZE(poly17), step);
-}
-
-// pulse wave clocked by poly5
-// (what the Atari POKEY actually does with poly5)
-float OscillatorPulsePoly5(OscillatorConfig const &config, OscillatorState &state, float step)
-{
-	return OscillatorPoly(config, state, pulsepoly5, ARRAY_SIZE(pulsepoly5), step);
-}
-
-// poly4 clocked by poly5
-float OscillatorPoly4Poly5(OscillatorConfig const &config, OscillatorState &state, float step)
-{
-	return OscillatorPoly(config, state, poly4poly5, ARRAY_SIZE(poly4poly5), step);
-}
-
-// poly17 clocked by poly5
-float OscillatorPoly17Poly5(OscillatorConfig const &config, OscillatorState &state, float step)
-{
-	return OscillatorPoly(config, state, poly17poly5, ARRAY_SIZE(poly17poly5), step);
+	return value + value - 1.0f;
 }

Diff for: WavePoly.h

@@ -24,32 +24,5 @@ extern char poly17poly5[ARRAY_SIZE(poly5) * ARRAY_SIZE(poly17)];
 // initialize polynomial noise tables
 extern void InitPoly();
 
-// poly4 waveform
-// 4-bit linear feedback shift register noise
-extern float OscillatorPoly4(OscillatorConfig const &config, OscillatorState &state, float step);
-
-// poly5 waveform
-// 5-bit linear feedback shift register noise
-extern float OscillatorPoly5(OscillatorConfig const &config, OscillatorState &state, float step);
-
-// period-93 waveform
-// 15-bit linear feedback shift register noise with variant tap position
-extern float OscillatorPeriod93(OscillatorConfig const &config, OscillatorState &state, float step);
-
-// poly9 waveform
-// 9-bit linear feedback shift register noise
-extern float OscillatorPoly9(OscillatorConfig const &config, OscillatorState &state, float step);
-
-// poly17 waveform
-// 17-bit linear feedback shift register noise
-extern float OscillatorPoly17(OscillatorConfig const &config, OscillatorState &state, float step);
-
-// pulse wave clocked by poly5
-// (what the Atari POKEY actually does with poly5)
-extern float OscillatorPulsePoly5(OscillatorConfig const &config, OscillatorState &state, float step);
-
-// poly4 clocked by poly5
-extern float OscillatorPoly4Poly5(OscillatorConfig const &config, OscillatorState &state, float step);
-
-// poly17 clocked by poly5
-extern float OscillatorPoly17Poly5(OscillatorConfig const &config, OscillatorState &state, float step);
+// poly waveform
+extern float OscillatorPoly(OscillatorConfig const &config, OscillatorState &state, float step);

Diff for: WavePulse.cpp

@@ -19,7 +19,7 @@ Pulse Wave
 // - smoothed transition to reduce aliasing
 static __forceinline float GetPulseValue(float const phase, float const width)
 {
-	return phase - FloorInt(phase) < width ? 1.0f : -1.0f;
+	return phase < width ? 1.0f : -1.0f;
 }
 float OscillatorPulse(OscillatorConfig const &config, OscillatorState &state, float step)
 {
@@ -29,60 +29,68 @@ float OscillatorPulse(OscillatorConfig const &config, OscillatorState &state, fl
 		return -1.0f;
 	if (config.waveparam >= 1.0f)
 		return 1.0f;
-	float value = GetPulseValue(state.phase, config.waveparam);
+	float const phase = state.phase;
+	float value = GetPulseValue(phase, config.waveparam);
 #if ANTIALIAS == ANTIALIAS_POLYBLEP
 	if (use_antialias)
 	{
 		float const w = Min(step * POLYBLEP_WIDTH, 0.5f);
 
 		// nearest up edge
-		float const up_nearest = float(RoundInt(state.phase));
+		float const up_nearest = float(phase - 0.5f >= 0);
 
 		// nearest down edge
-		float const down_nearest = float(RoundInt(state.phase - config.waveparam)) + config.waveparam;
+		float const down_nearest = float(phase - 0.5f >= config.waveparam) - float(phase + 0.5f < config.waveparam) + config.waveparam;
 
 		if (config.sync_enable)
 		{
 			// short-circuit case
 			if (config.sync_phase < config.waveparam)
 				return 1.0f;
 
+			// shift sync phase into range
+			int const index = state.index;
+			float sync_phase = config.sync_phase - index;
+
 			// last up transition before sync
-			float const up_before_sync = float(CeilingInt(config.sync_phase) - 1);
+			float const up_before_sync = float(CeilingInt(sync_phase) - 1);
 
-			// handle discontinuity at zero phase
-			if (config.sync_phase > up_before_sync + config.waveparam)
-			{
-				// down edge before sync wrapped before zero
-				value -= PolyBLEP(state.phase - (up_before_sync + config.waveparam - config.sync_phase), w);
-				// up edge at 0
-				value += PolyBLEP(state.phase, w);
-			}
-			else
+			if (index == 0)
 			{
-				// up edge before sync wrapped before zero
-				value += PolyBLEP(state.phase - (up_before_sync - config.sync_phase), w);
+				// handle discontinuity at zero phase
+				if (sync_phase > up_before_sync + config.waveparam)
+				{
+					// down edge before sync wrapped before zero
+					value -= PolyBLEP(phase - (up_before_sync + config.waveparam - sync_phase), w);
+					// up edge at 0
+					value += PolyBLEP(phase, w);
+				}
+				else
+				{
+					// up edge before sync wrapped before zero
+					value += PolyBLEP(phase - (up_before_sync - sync_phase), w);
+				}
 			}
 
 			// handle nearest up transition if it's in range
-			if (up_nearest > 0 && up_nearest <= up_before_sync)
-				value += PolyBLEP(state.phase - up_nearest, w);
+			if (up_nearest > -index && up_nearest <= up_before_sync)
+				value += PolyBLEP(phase - up_nearest, w);
 
 			// handle nearest down transition if it's in range
-			if (down_nearest > 0 && down_nearest < config.sync_phase)
-				value -= PolyBLEP(state.phase - down_nearest, w);
+			if (down_nearest > -index && down_nearest < sync_phase)
+				value -= PolyBLEP(phase - down_nearest, w);
 
 			// handle discontinuity at sync phase
-			if (config.sync_phase > up_before_sync + config.waveparam)
+			if (sync_phase > up_before_sync + config.waveparam)
 			{
 				// up edge at config.sync_phase
-				value += PolyBLEP(state.phase - config.sync_phase, w);
+				value += PolyBLEP(phase - sync_phase, w);
 			}
 		}
 		else
 		{
-			value += PolyBLEP(state.phase - up_nearest, w);
-			value -= PolyBLEP(state.phase - down_nearest, w);
+			value += PolyBLEP(phase - up_nearest, w);
+			value -= PolyBLEP(phase - down_nearest, w);
 		}
 	}
 #endif