WaveTbl.cpp

// Copyright (C) 2022-2025 Theo Niessink <theo@taletn.com> 
// This work is free. You can redistribute it and/or modify it under the
// terms of the Do What The Fuck You Want To Public License, Version 2,
// as published by Sam Hocevar. See http://www.wtfpl.net/ for more details.

#include "Firmware.h"
#include "WaveTbl.h"

#include <math.h>
#include "WDL/sha.h"

#ifndef NDEBUG
	#include <stdio.h>
#endif

namespace TG101 {

WDL_HeapBuf WaveTbl::mDataBuf;
WDL_PtrList_DeleteOnDestroy<WaveTbl::ResampleCache> WaveTbl::mResampleCache;

// (9.4 MHz)/224
const double WaveTbl::mNativeSampleRate = 41964.285714285714;

// XK992A0
const unsigned char WaveTbl::mHash[WDL_SHA1SIZE] =
{
	0x32, 0xEC, 0x77, 0xA4, 0x6F, 0x4D, 0x00, 0x55, 0x38, 0xC7,
	0x35, 0xF5, 0x6A, 0xD4, 0x8F, 0xA7, 0x24, 0x3C, 0x63, 0xBE
};

const unsigned short WaveTbl::mFixLoopTbl[kFixLoopTblSize] =
{
	11,  // High Agogo
	16,  // Analog Bass Drum
	17,  // Click Noise
	29,  // Cowbell
	30,  // Mute Hi Conga
	32,  // Claves
	35,  // Mute Cuica
	36,  // Open Cuica
	37,  // Short Guiro
	38,  // Tambourine
	51,  // Metronome Click
	52,  // Short Whistle
	54,  // Cabasa
	55,  // Maracas
	69,  // Taiko-Drum Low
	185, // Open Hi-Hat
	186, // Pedal Hi-Hat
	209, // Stick
	211, // Acoustic Bass Drum
	219, // Bass Drum 1
	220, // Side Stick
	224, // Low-Mid Tom
	226, // Chinese Cymbal
	264, // Open Triangle
	265, // Taiko-Drum High
	270, // Room Mid Tom 1
	271, // Room Hi Tom 1
	280, // Closed Hi-Hat
	281, // Room Mid Tom 1
	282, // Elec SD
	284, // Elec Low Tom 2
	294, // Analog OHH
	301, // MONDO Kick
	304, // Analog Claves
	305, // Castanets
	308, // Concert BD
	320, // Analog Snare Drum
	337, // Open Hi-Hat
	338, // Acoustic Bass Drum
	345, // BD-light
	348, // BD-normal
	349, // RIMSHOT
	351, // HH-pedal
	354, // HH-closed-normal
	356, // TOM-2
	357, // E.TOM 3
	360, // Bass Drum 1
	361, // Bass Drum 1
	366, // Acoustic Bass Drum
	373, // Bass Drum 1
	374, // Acoustic Bass Drum
	375, // Bass Drum 1
	388, // Bass Drum 1
	395, // Cowbell
	396, // Cabasa
	397, // Closed Hi Hat
	404, // Open Hi-Hat
	414, // Mute Hi Conga
	430, // Claves
	443, // Electric Snare
	444, // Electric Snare
	447, // Acoustic H Tom
	449, // Claves
	511  // Scratch Push
};

// 4-point interpolation
static const int kNumExtraPoints = 3;

static int IntSampleRate(const double sampleRate)
{
	assert(sampleRate > 0.0);
	return (int)(sampleRate + 0.5);
}

static double SampleRatio(const double sampleRate, const double nativeSampleRate)
{
	assert(sampleRate > 0.0);
	return sampleRate / nativeSampleRate;
}

static int SampleLength(const int end, const double ratio)
{
	return (int)ceil((double)end * ratio) + kNumExtraPoints;
}

WaveTbl::WaveTbl():
	mDataPtr(NULL),
	mSamplePtr(NULL),
	mSampleRate(mNativeSampleRate)
{
	mResampler.SetMode(false, 0, true);
}

float WaveTbl::GetSample(const float* const buf, const double pos)
{
	const int i = (int)pos;
	const float x = (float)(pos - (double)i);

	// 4-point
	const float y0 = buf[i];
	const float y1 = buf[i + 1];
	const float y2 = buf[i + 2];
	const float y3 = buf[i + 3];

	// Catmull-Rom cubic spline
	const float a0 = (y1 - y2) * 3.0f + (y3 - y0);
	const float a1 = y2 * 4.0f - y1 * 5.0f + (y0 + y0) - y3;
	const float a2 = y2 - y0;

	return ((a0 * x + a1) * x + a2) * x * 0.5f + y1;
}

bool WaveTbl::LoadFile(const char* const filename, const void* const hash, WDL_Mutex* const mutex)
{
	if (mutex) mutex->Enter();

	mDataPtr = (unsigned char*)mDataBuf.Get();
	bool status = !!mDataPtr;

	if (!status)
	{
		unsigned char* const ptr = (unsigned char*)Firmware::ReadFile(filename, hash, &mDataBuf, GetSize());
		status = !!ptr;

		if (status)
		{
			FixLoopAddress(ptr);
			mDataPtr = ptr;
		}
	}

	if (mutex) mutex->Leave();

	return status;
}

void WaveTbl::FixLoopAddress(unsigned char* const dataPtr)
{
	for (int i = 0; i < kFixLoopTblSize; ++i)
	{
		const int idx = mFixLoopTbl[i];
		unsigned char* const ptr = &dataPtr[idx * sizeof(WaveTblHeader)];

		unsigned short end;
		memcpy(&end, &ptr[5], 2);

		end = -(short)WDL_bswap16_if_le(end);

		// Disable loop by setting loop point to end.
		const unsigned short loop = WDL_bswap16_if_le(end);
		memcpy(&ptr[3], &loop, 2);
	}
}

bool WaveTbl::Resample(const double sampleRate, WDL_Mutex* const mutex)
{
	if (mutex) mutex->Enter();

	bool status = FindSampleRate(sampleRate);
	if (!status) status = AddSampleRate(sampleRate);

	if (mutex) mutex->Leave();

	return status;
}

bool WaveTbl::FindSampleRate(const double sampleRate)
{
	const ResampleCache* const* const cache = mResampleCache.GetList();
	const int n = mResampleCache.GetSize();

	const int sr = IntSampleRate(sampleRate);
	bool found = false;

	for (int i = 0; i < n; ++i)
	{
		found = cache[i]->mSampleRate == sr;
		if (!found) continue;

		mSamplePtr = cache[i]->mSamplePtr;
		mSampleRate = sampleRate;
		break;
	}

	return found;
}

bool WaveTbl::AddSampleRate(const double sampleRate)
{
	if (!GetStatus()) return false;

	ResampleCache* const cache = new WDL_NEW ResampleCache;
	if (!cache) return false;

	const int sr = IntSampleRate(sampleRate);
	cache->mSampleRate = sr;

	float** const ptr = cache->mSamplePtr;

	const int size = GetSampleBufSize(ptr, sampleRate);
	float* buf = cache->mSampleBuf.Resize(size);

	if (!(buf && mResampleCache.Add(cache)))
	{
		delete cache;
		return false;
	}

	mSamplePtr = ptr;
	mSampleRate = sampleRate;

	const bool resample = IntSampleRate(mNativeSampleRate) != sr;

	if (resample)
	{
		mResampler.SetRates(mNativeSampleRate, sampleRate);
	}

	for (int i = 0; i < kNumWaves; ++i)
	{
		const UINT_PTR len = (UINT_PTR)ptr[i];
		if (!len) continue;

		ptr[i] = buf;

		const size_t n = RenderWave(buf, GetHeader(i), resample, sampleRate);
		assert(n <= len);

		const size_t m = len - n;
		if (m) memset(buf + n, 0, m * sizeof(float));

		buf += len;
	}

	for (int i = 0; i < kNumWaves; ++i)
	{
		if (ptr[i]) continue;

		const WaveTblHeader* header = GetHeader(i);
		assert(header->IsNull() == false);

		for (int j = 0; j < i; ++j)
		{
			if (header->IsEquivalent(GetHeader(j)))
			{
				ptr[i] = ptr[j];
				break;
			}
		}
	}

	return true;
}

int WaveTbl::GetSampleBufSize(float** const samplePtr, const double sampleRate)
{
	INT_PTR* const ptr = (INT_PTR*)samplePtr;

	for (int i = 0; i < kNumWaves; ++i)
	{
		ptr[i] = -1;
	}

	// 1000 Hz sine wave
	const WaveTblHeader* const testSignal = GetHeader(0);
	assert(testSignal->IsNull() == false);

	const double ratio = SampleRatio(sampleRate, mNativeSampleRate);
	int size = 0;

	for (int i = 0; i < kNumWaves; ++i)
	{
		if (ptr[i] >= 0) continue;
		const WaveTblHeader* const header = GetHeader(i);

		if (header->IsNull())
		{
			memcpy((WaveTblHeader*)header, testSignal, sizeof(WaveTblHeader));

			ptr[i] = 0;
			continue;
		}

		for (int j = i + 1; j < kNumWaves; ++j)
		{
			if (ptr[j] >= 0) continue;
			if (header->IsEquivalent(GetHeader(j))) ptr[j] = 0;
		}

		const int end = header->GetEndAddress();
		const int len = SampleLength(end, ratio);

		ptr[i] = len;
		size += len;
	}

	return size;
}

int WaveTbl::RenderWave(float* const buf, const WaveTblHeader* const header, const bool resample, const double sampleRate)
{
	const int format = header->GetSampleFormat();
	const int addr = header->GetStartAddress();
	const int loop = header->GetLoopAddress();
	const int end = header->GetEndAddress();

	assert(format == kSampleFormat12Bit);
	assert(addr >= 0x1800 && addr + ((end - 1)/2)*3 + 4 < GetSize());

	const int maxAddr = GetSize() - (0x1800 + 4);

	if (!(format == kSampleFormat12Bit && (unsigned int)(addr - 0x1800) < (unsigned int)(maxAddr - (((end - 1) >> 1) * 3))))
	{
		return 0;
	}

	const unsigned char* const src = GetDataPtr(addr);
	const int len = resample ? ResampleWave(buf, src, loop, end, sampleRate) : ConvertWave(buf, src, loop, end);

	return len;
}

int WaveTbl::ResampleWave(float* const buf, const unsigned char* const src, int loop, const int end, const double sampleRate)
{
	mResampler.Reset();

	const double ratio = SampleRatio(sampleRate, mNativeSampleRate);
	const int len = SampleLength(end, ratio);

	loop = WaveTblHeader::IsLoopable(loop, end) ? loop : end;

	static const int resampleLen = 32; 
	WDL_ResampleSample resampleBuf[sizeof(WDL_ResampleSample) == sizeof(float) ? 1 : resampleLen];

	// Add extra interpolation data points (1 before, 2 after actual data).
	buf[0] = 0.0f;

	for (int i = 1, j = 0;;)
	{
		int out = len - i;
		out = wdl_min(out, resampleLen);

		WDL_ResampleSample* resamplePtr;
		const int in = mResampler.ResamplePrepare(out, 1, &resamplePtr);

		static const WDL_ResampleSample scale = (WDL_ResampleSample)-4.6566128730773926e-10; // -(2^(-31))

		for (int k = 0; k < in; ++k)
		{
			const int decode = j < end ? DecodeSample12Bit(src, j, j) : 0;
			resamplePtr[k] = (WDL_ResampleSample)decode * scale;

			j = ++j < end ? j : loop;
		}

		float* const dest = &buf[i];

		resamplePtr = sizeof(WDL_ResampleSample) == sizeof(float) ? (WDL_ResampleSample*)dest : resampleBuf;
		out = mResampler.ResampleOut(resamplePtr, in, out, 1);

		if (sizeof(WDL_ResampleSample) != sizeof(float))
		{
			for (int k = 0; k < out; ++k)
			{
				dest[k] = (float)resamplePtr[k];
			}
		}

		i += out;
		if (i >= len) break;
	}

	return len;
}

int WaveTbl::ConvertWave(float* buf, const unsigned char* const src, const int loop, const int end)
{
	// Add 1 extra interpolation data point before actual data.
	*buf++ = 0.0f;

	static const float scale = -4.65661287e-10f; // -(2^(-31))

	const int even = end & ~1;
	int i;

	for (i = 0; i < even; i += 2)
	{
		int decode[2];
		DecodeSample12Bit(decode, src, i);

		buf[i] = (float)decode[0] * scale;
		buf[i + 1] = (float)decode[1] * scale;
	}

	if (end & 1)
	{
		const int decode = DecodeSample12Bit(src, i, 0);
		buf[i++] = (float)decode * scale;
	}

	// Add 2 extra data points after actual data.
	static const int extra = kNumExtraPoints - 1;

	if (WaveTblHeader::IsLoopable(loop, end))
	{
		assert(loop + extra <= end);
		memcpy(&buf[i], &buf[loop], extra * sizeof(float));
	}
	else
	{
		memset(&buf[i], 0, extra * sizeof(float));
	}

	return /* len = */ end + kNumExtraPoints;
}

/* int WaveTbl::DecodeSample8Bit(const unsigned char* const src, const int pos)
{
	assert(pos >= 0);
	return src[(unsigned int)pos] << 24;
}

int WaveTbl::DecodeSample16Bit(const unsigned char* const src, const int pos)
{
	assert(pos >= 0);

	unsigned short word;
	memcpy(&word, &src[(unsigned int)pos << 1], 2);

	return WDL_bswap16_if_le(word);
} */

void WaveTbl::DecodeSample12Bit(int* const dest, const unsigned char* const src, const int pos)
{
	assert(pos >= 0);

	unsigned int word;
	memcpy(&word, &src[((unsigned int)pos >> 1) * 3], 4);

	word = WDL_bswap32_if_le(word);

	dest[0] = word & 0xFFF00000;
	dest[1] = ((word << 16) & 0xFF000000) | ((word << 4) & 0x00F00000);
}

int WaveTbl::DecodeSample12Bit(const unsigned char* const src, const int pos, const int odd)
{
	int dest[2];
	DecodeSample12Bit(dest, src, pos);

	return dest[odd & 1];
}

#ifndef NDEBUG

void WaveTbl::DumpSampleBuf(const char* filename, double sampleRate)
{
	if (sampleRate == 0.0)
	{
		assert(IsResampled() == true);
		sampleRate = mSampleRate;
	}

	const int sr = IntSampleRate(sampleRate);

	const ResampleCache* const* const cache = mResampleCache.GetList();
	const int n = mResampleCache.GetSize();

	const float* buf;
	int size = 0;

	for (int i = 0; i < n; ++i)
	{
		if (cache[i]->mSampleRate != sr) continue;

		buf = cache[i]->mSampleBuf.GetFast();
		size = cache[i]->mSampleBuf.GetSize();
		break;
	}

	FILE* const fp = fopen(filename, "wb");

	if (fp)
	{
		if (size) fwrite(buf, sizeof(float), size, fp);
		fclose(fp);
	}
}

#endif // NDEBUG

} // namespace TG101