Some different tweaks

Author: 8bitbubsy

src/ft2_audio.c

@@ -28,8 +28,7 @@
 static int32_t smpShiftValue;
 static uint32_t oldAudioFreq, tickTimeLenInt, randSeed = INITIAL_DITHER_SEED;
 static uint64_t tickTimeLenFrac;
-static float fSqrtPanningTable[256+1];
-static double dAudioNormalizeMul, dPrngStateL, dPrngStateR;
+static float fSqrtPanningTable[256+1], fAudioNormalizeMul, fPrngStateL, fPrngStateR;
 static voice_t voice[MAX_CHANNELS * 2];
 
 // globalized
@@ -103,11 +102,11 @@ void setAudioAmp(int16_t amp, int16_t masterVol, bool bitDepth32Flag)
 	amp = CLAMP(amp, 1, 32);
 	masterVol = CLAMP(masterVol, 0, 256);
 
-	double dAmp = (amp * masterVol) / (32.0 * 256.0);
+	float fAmp = (amp * masterVol) / (32.0f * 256.0f);
 	if (!bitDepth32Flag)
-		dAmp *= 32768.0;
+		fAmp *= 32768.0f;
 
-	dAudioNormalizeMul = dAmp;
+	fAudioNormalizeMul = fAmp;
 }
 
 void decreaseMasterVol(void)
@@ -194,17 +193,15 @@ void audioSetInterpolationType(uint8_t interpolationType)
 	// set sinc LUT pointers
 	if (config.interpolation == INTERPOLATION_SINC8)
 	{
-		fSinc_1 = fSinc8_1;
-		fSinc_2 = fSinc8_2;
-		fSinc_3 = fSinc8_3;
+		for (int32_t i = 0; i < SINC_KERNELS; i++)
+			fSinc[i] = fSinc8[i];
 
 		audio.sincInterpolation = true;
 	}
 	else if (config.interpolation == INTERPOLATION_SINC16)
 	{
-		fSinc_1 = fSinc16_1;
-		fSinc_2 = fSinc16_2;
-		fSinc_3 = fSinc16_3;
+		for (int32_t i = 0; i < SINC_KERNELS; i++)
+			fSinc[i] = fSinc16[i];
 
 		audio.sincInterpolation = true;
 	}
@@ -381,19 +378,16 @@ void updateVoices(void)
 
 		if (status & CF_UPDATE_PERIOD)
 		{
-			const double dVoiceHz = dPeriod2Hz(ch->finalPeriod);
+			v->delta = period2VoiceDelta(ch->finalPeriod);
 
-			// set voice delta
-			v->delta = (int64_t)((dVoiceHz * audio.dHz2MixDeltaMul) + 0.5); // Hz -> fixed-point delta (rounded)
 			if (audio.sincInterpolation)
 			{
-				// decide which sinc LUT to use according to the resampling ratio
 				if (v->delta <= sincRatio1)
-					v->fSincLUT = fSinc_1;
+					v->fSincLUT = fSinc[0];
 				else if (v->delta <= sincRatio2)
-					v->fSincLUT = fSinc_2;
+					v->fSincLUT = fSinc[1];
 				else
-					v->fSincLUT = fSinc_3;
+					v->fSincLUT = fSinc[2];
 			}
 		}
 
@@ -405,7 +399,7 @@ void updateVoices(void)
 void resetAudioDither(void)
 {
 	randSeed = INITIAL_DITHER_SEED;
-	dPrngStateL = dPrngStateR = 0.0;
+	fPrngStateL = fPrngStateR = 0.0f;
 }
 
 static inline int32_t random32(void)
@@ -420,26 +414,26 @@ static inline int32_t random32(void)
 static void sendSamples16BitStereo(void *stream, uint32_t sampleBlockLength)
 {
 	int32_t out32;
-	double dOut, dPrng;
+	float fOut, fPrng;
 
 	int16_t *streamPtr16 = (int16_t *)stream;
 	for (uint32_t i = 0; i < sampleBlockLength; i++)
 	{
 		// left channel - 1-bit triangular dithering
-		dPrng = random32() * (1.0 / (UINT32_MAX+1.0)); // -0.5 .. 0.5
-		dOut = (double)audio.fMixBufferL[i] * dAudioNormalizeMul;
-		dOut = (dOut + dPrng) - dPrngStateL;
-		dPrngStateL = dPrng;
-		out32 = (int32_t)dOut;
+		fPrng = (float)random32() * (1.0f / (UINT32_MAX+1.0f)); // -0.5f .. 0.5f
+		fOut = audio.fMixBufferL[i] * fAudioNormalizeMul;
+		fOut = (fOut + fPrng) - fPrngStateL;
+		fPrngStateL = fPrng;
+		out32 = (int32_t)fOut;
 		CLAMP16(out32);
 		*streamPtr16++ = (int16_t)out32;
 
 		// right channel - 1-bit triangular dithering
-		dPrng = random32() * (1.0 / (UINT32_MAX+1.0)); // -0.5 .. 0.5
-		dOut = (double)audio.fMixBufferR[i] * dAudioNormalizeMul;
-		dOut = (dOut + dPrng) - dPrngStateR;
-		dPrngStateR = dPrng;
-		out32 = (int32_t)dOut;
+		fPrng = (float)random32() * (1.0f / (UINT32_MAX+1.0f)); // -0.5f .. 0.5f
+		fOut = audio.fMixBufferR[i] * fAudioNormalizeMul;
+		fOut = (fOut + fPrng) - fPrngStateR;
+		fPrngStateR = fPrng;
+		out32 = (int32_t)fOut;
 		CLAMP16(out32);
 		*streamPtr16++ = (int16_t)out32;
 
@@ -450,20 +444,20 @@ static void sendSamples16BitStereo(void *stream, uint32_t sampleBlockLength)
 
 static void sendSamples32BitFloatStereo(void *stream, uint32_t sampleBlockLength)
 {
-	double dOut;
+	float fOut;
 
 	float *fStreamPtr32 = (float *)stream;
 	for (uint32_t i = 0; i < sampleBlockLength; i++)
 	{
 		// left channel
-		dOut = (double)audio.fMixBufferL[i] * dAudioNormalizeMul;
-		dOut = CLAMP(dOut, -1.0, 1.0);
-		*fStreamPtr32++ = (float)dOut;
+		fOut = audio.fMixBufferL[i] * fAudioNormalizeMul;
+		fOut = CLAMP(fOut, -1.0f, 1.0f);
+		*fStreamPtr32++ = fOut;
 
 		// right channel
-		dOut = (double)audio.fMixBufferR[i] * dAudioNormalizeMul;
-		dOut = CLAMP(dOut, -1.0, 1.0);
-		*fStreamPtr32++ = (float)dOut;
+		fOut = audio.fMixBufferR[i] * fAudioNormalizeMul;
+		fOut = CLAMP(fOut, -1.0f, 1.0f);
+		*fStreamPtr32++ = fOut;
 
 		// clear what we read from the mixing buffer
 		audio.fMixBufferL[i] = audio.fMixBufferR[i] = 0.0f;

src/ft2_audio.h

@@ -50,7 +50,6 @@ typedef struct audio_t
 	uint64_t tickTime64, tickTime64Frac;
 
 	float *fMixBufferL, *fMixBufferR, fQuickVolRampSamplesMul, fSamplesPerTickIntMul;
-	double dHz2MixDeltaMul;
 
 	SDL_AudioDeviceID dev;
 	uint32_t wantFreq, haveFreq, wantSamples, haveSamples;

src/ft2_main.c

@@ -278,6 +278,8 @@ static void initializeVars(void)
 	memset(&chSync, 0, sizeof (chSync));
 	memset(&song, 0, sizeof (song));
 
+	calcMiscReplayerVars();
+
 	// used for scopes and sampling position line (sampler screen)
 	for (int32_t i = 0; i < MAX_CHANNELS; i++)
 	{
@@ -317,7 +319,6 @@ static void initializeVars(void)
 	editor.diskOpReadOnOpen = true;
 
 	audio.linearPeriodsFlag = true;
-	calcReplayerLogTab();
 
 #ifdef HAS_MIDI
 	midi.enable = true;

src/ft2_replayer.c

@@ -30,6 +30,8 @@
 #include "mixer/ft2_cubic_spline.h"
 #include "mixer/ft2_windowed_sinc.h"
 
+static uint64_t logTab[4*12*16], scopeLogTab[4*12*16], scopeDrawLogTab[4*12*16];
+static uint64_t amigaPeriodDiv, scopeAmigaPeriodDiv, scopeDrawAmigaPeriodDiv;
 static double dLogTab[4*12*16], dExp2MulTab[32];
 static bool bxxOverflow;
 static note_t nilPatternLine[MAX_CHANNELS];
@@ -232,34 +234,92 @@ int16_t getRealUsedSamples(int16_t smpNum)
 	return i+1;
 }
 
-double dLinearPeriod2Hz(int32_t period)
+double dPeriod2Hz(uint32_t period)
 {
 	period &= 0xFFFF; // just in case (actual period range is 0..65535)
 
 	if (period == 0)
 		return 0.0; // in FT2, a period of 0 results in 0Hz
 
-	const uint32_t invPeriod = ((12 * 192 * 4) - period) & 0xFFFF; // mask needed for FT2 period overflow quirk
+	if (audio.linearPeriodsFlag)
+	{
+		const uint32_t invPeriod = ((12 * 192 * 4) - period) & 0xFFFF; // mask needed for FT2 period overflow quirk
 
-	const uint32_t quotient  = invPeriod / (12 * 16 * 4);
-	const uint32_t remainder = invPeriod % (12 * 16 * 4);
+		const uint32_t quotient  = invPeriod / (12 * 16 * 4);
+		const uint32_t remainder = invPeriod % (12 * 16 * 4);
 
-	return dLogTab[remainder] * dExp2MulTab[(14-quotient) & 31]; // x = y >> ((14-quotient) & 31);
+		return dLogTab[remainder] * dExp2MulTab[(14-quotient) & 31]; // x = y >> ((14-quotient) & 31);
+	}
+	else
+	{
+		return (8363.0 * 1712.0) / (int32_t)period;
+	}
 }
 
-double dAmigaPeriod2Hz(int32_t period)
+uint64_t period2VoiceDelta(uint32_t period)
 {
 	period &= 0xFFFF; // just in case (actual period range is 0..65535)
 
 	if (period == 0)
-		return 0.0; // in FT2, a period of 0 results in 0Hz
+		return 0; // in FT2, a period of 0 results in 0Hz
+
+	if (audio.linearPeriodsFlag)
+	{
+		const uint32_t invPeriod = ((12 * 192 * 4) - period) & 0xFFFF; // mask needed for FT2 period overflow quirk
+
+		const uint32_t quotient  = invPeriod / (12 * 16 * 4);
+		const uint32_t remainder = invPeriod % (12 * 16 * 4);
+
+		return logTab[remainder] >> ((14-quotient) & 31);
+	}
+	else
+	{
+		return amigaPeriodDiv / period;
+	}
+}
+
+uint64_t period2ScopeDelta(uint32_t period)
+{
+	period &= 0xFFFF; // just in case (actual period range is 0..65535)
+
+	if (period == 0)
+		return 0; // in FT2, a period of 0 results in 0Hz
+
+	if (audio.linearPeriodsFlag)
+	{
+		const uint32_t invPeriod = ((12 * 192 * 4) - period) & 0xFFFF; // mask needed for FT2 period overflow quirk
+
+		const uint32_t quotient  = invPeriod / (12 * 16 * 4);
+		const uint32_t remainder = invPeriod % (12 * 16 * 4);
 
-	return (8363.0 * 1712.0) / period;
+		return scopeLogTab[remainder] >> ((14-quotient) & 31);
+	}
+	else
+	{
+		return scopeAmigaPeriodDiv / period;
+	}
 }
 
-double dPeriod2Hz(int32_t period)
+uint64_t period2ScopeDrawDelta(uint32_t period)
 {
-	return audio.linearPeriodsFlag ? dLinearPeriod2Hz(period) : dAmigaPeriod2Hz(period);
+	period &= 0xFFFF; // just in case (actual period range is 0..65535)
+
+	if (period == 0)
+		return 0; // in FT2, a period of 0 results in 0Hz
+
+	if (audio.linearPeriodsFlag)
+	{
+		const uint32_t invPeriod = ((12 * 192 * 4) - period) & 0xFFFF; // mask needed for FT2 period overflow quirk
+
+		const uint32_t quotient  = invPeriod / (12 * 16 * 4);
+		const uint32_t remainder = invPeriod % (12 * 16 * 4);
+
+		return scopeDrawLogTab[remainder] >> ((14-quotient) & 31);
+	}
+	else
+	{
+		return scopeDrawAmigaPeriodDiv / period;
+	}
 }
 
 // returns *exact* FT2 C-4 voice rate (depending on finetune, relativeNote and linear/Amiga period mode)
@@ -386,22 +446,18 @@ void keyOff(channel_t *ch)
 	}
 }
 
-void calcReplayerLogTab(void) // for linear period -> hz calculation
-{
-	for (int32_t i = 0; i < 32; i++)
-		dExp2MulTab[i] = 1.0 / exp2(i); // 1/(2^i)
-
-	for (int32_t i = 0; i < 4*12*16; i++)
-		dLogTab[i] = (8363.0 * 256.0) * exp2(i / (4.0 * 12.0 * 16.0));
-}
-
 void calcReplayerVars(int32_t audioFreq)
 {
 	assert(audioFreq > 0);
 	if (audioFreq <= 0)
 		return;
 
-	audio.dHz2MixDeltaMul = (double)MIXER_FRAC_SCALE / audioFreq;
+	const double logTabMul = (UINT32_MAX+1.0) / audioFreq;
+	for (int32_t i = 0; i < 4*12*16; i++)
+		logTab[i] = (uint64_t)round(dLogTab[i] * logTabMul);
+
+	amigaPeriodDiv = (uint64_t)round((MIXER_FRAC_SCALE * (1712.0*8363.0)) / audioFreq);
+
 	audio.quickVolRampSamples = (uint32_t)round(audioFreq / (1000.0 / FT2_QUICK_VOLRAMP_MILLISECONDS));
 	audio.fQuickVolRampSamplesMul = (float)(1.0 / audio.quickVolRampSamples);
 
@@ -2807,6 +2863,22 @@ void closeReplayer(void)
 	freeWindowedSincTables();
 }
 
+void calcMiscReplayerVars(void)
+{
+	for (int32_t i = 0; i < 32; i++)
+		dExp2MulTab[i] = 1.0 / exp2(i); // 1/(2^i)
+
+	for (int32_t i = 0; i < 4*12*16; i++)
+	{
+		dLogTab[i] = (8363.0 * 256.0) * exp2(i / (4.0 * 12.0 * 16.0));
+		scopeLogTab[i] = (uint64_t)round(dLogTab[i] * (SCOPE_FRAC_SCALE / SCOPE_HZ));
+		scopeDrawLogTab[i] = (uint64_t)round(dLogTab[i] * (SCOPE_FRAC_SCALE / (C4_FREQ/2.0)));
+	}
+
+	scopeAmigaPeriodDiv = (uint64_t)round((SCOPE_FRAC_SCALE * (1712.0*8363.0)) / SCOPE_HZ);
+	scopeDrawAmigaPeriodDiv = (uint64_t)round((SCOPE_FRAC_SCALE * (1712.0*8363.0)) / (C4_FREQ/2.0));
+}
+
 bool setupReplayer(void)
 {
 	for (int32_t i = 0; i < MAX_PATTERNS; i++)

src/ft2_replayer.h

@@ -288,11 +288,11 @@ void fixInstrAndSampleNames(int16_t insNum);
 
 void calcReplayerVars(int32_t rate);
 void setSampleC4Hz(sample_t *s, double dC4Hz);
-void calcReplayerLogTab(void); // for linear period -> hz calculation
 
-double dLinearPeriod2Hz(int32_t period);
-double dAmigaPeriod2Hz(int32_t period);
-double dPeriod2Hz(int32_t period);
+double dPeriod2Hz(uint32_t period);
+uint64_t period2VoiceDelta(uint32_t period);
+uint64_t period2ScopeDelta(uint32_t period);
+uint64_t period2ScopeDrawDelta(uint32_t period);
 
 int32_t getPianoKey(int32_t period, int8_t finetune, int8_t relativeNote); // for piano in Instr. Ed.
 void triggerNote(uint8_t note, uint8_t efx, uint8_t efxData, channel_t *ch);
@@ -305,6 +305,7 @@ void freeSample(int16_t insNum, int16_t smpNum);
 
 void freeAllPatterns(void);
 void updateChanNums(void);
+void calcMiscReplayerVars(void);
 bool setupReplayer(void);
 void closeReplayer(void);
 void resetMusic(void);