Firmware.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 <stdio.h>
#include <string.h>

#include "WDL/sha.h"
#include "WDL/wdlendian.h"
#include "WDL/wdltypes.h"

namespace TG101 {

VoiceBankTbl Firmware::mVoiceBankTbl;
VoiceBank Firmware::mProgramChangeTbl[kNumVoiceBanks];
VoiceCommon Firmware::mVoiceMem[kNumVoices];
DrumBank Firmware::mDrumKitTbl;
DrumKit Firmware::mDrumKits[kNumDrumKits];
SampleSetTbl Firmware::mSampleSetTbl;
SampleSet Firmware::mSampleSets[kNumSampleSets];
DrumSound Firmware::mDrumSounds[kNumDrumSounds];

unsigned short Firmware::mPitchTbl[1200];
unsigned char Firmware::mVolumeTbl[128];
unsigned char Firmware::mVelocityTbl[8][128];
unsigned char Firmware::mPortaTimeTbl[128];
unsigned char Firmware::mPitchEGRateTbl[64];

unsigned char Firmware::mReverbTimeTbl[64];
unsigned short Firmware::mReverbFeedbackTbl[256];
unsigned short Firmware::mReverbGainTbl[256];

char Firmware::mDrumKitName[kNumDrumKitNames][8];
char Firmware::mReverbTypeName[kNumReverbTypes][8];

// XK731C0 (v1.10)
const unsigned char Firmware::mHash[WDL_SHA1SIZE] =
{
	0x48, 0x31, 0x03, 0xA2, 0xFF, 0xC6, 0x3A, 0x90, 0xA2, 0x08,
	0x6C, 0x59, 0x7B, 0xAA, 0x2B, 0x27, 0x45, 0xC3, 0xA1, 0xC2
};

// 1000 Hz sine wave
const DrumSound Firmware::mTestSignal =
{
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

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

	bool status = mStatus;

	if (!status)
	{
		WDL_HeapBuf buf;

		const void* const ptr = Firmware::ReadFile(filename, hash, &buf, GetSize());
		status = !!ptr;

		if (status)
		{
			ExtractData((const unsigned char*)ptr);
			mStatus = status;
		}
	}

	if (mutex) mutex->Leave();

	return status;
}

void* Firmware::ReadFile(const char* const filename, const void* const hash, WDL_HeapBuf* const buf, const int size)
{
	assert(buf->GetSize() == 0);

	void* ptr = NULL;

	FILE* const fp = fopen(filename, "rb");
	if (!fp) return ptr;

	if (!fseek(fp, 0, SEEK_END) && ftell(fp) == size && !fseek(fp, 0, SEEK_SET))
	{
		ptr = buf->Resize(size);
		if (ptr && (int)fread(ptr, 1, size, fp) != size) ptr = NULL;
	}

	fclose(fp);

	if (ptr && hash)
	{
		WDL_SHA1 digest;
		digest.add(ptr, size);

		unsigned char result[WDL_SHA1SIZE];
		digest.result(result);

		ptr = memcmp(result, hash, WDL_SHA1SIZE) ? NULL : ptr;
	}

	if (!ptr) buf->Resize(0);

	return ptr;
}

void Firmware::ExtractData(const unsigned char* const buf)
{
	memcpy(&mVoiceBankTbl, &buf[0x14C90], sizeof(VoiceBankTbl));

	memcpy(&mProgramChangeTbl[kVoiceBankInternal + 1], &buf[0x14D10], sizeof(VoiceBank));
	memcpy(&mProgramChangeTbl[kVoiceBankGeneralMidi + 1], &buf[0x10000], (kNumVoiceBanks - 1) * sizeof(VoiceBank));

	memcpy(&mVoiceMem, &buf[0x10410], kNumVoices * sizeof(VoiceCommon));

	memcpy(&mDrumKitTbl, &buf[0x14C10], sizeof(DrumBank));
	memcpy(&mDrumKits, &buf[0x18B9E], kNumDrumKits * sizeof(DrumKit));

	memcpy(&mSampleSetTbl, &buf[0x1841A], sizeof(SampleSetTbl));
	memcpy(&mSampleSets, &buf[0x176A2], kNumSampleSets * sizeof(SampleSet));

	memcpy(&mDrumSounds, &buf[0x18532], kNumDrumSounds * sizeof(DrumSound));

	const unsigned char* ptr = &buf[0x14E2C];

	for (int i = 0; i < 1200; ++i)
	{
		unsigned short word;
		memcpy(&word, ptr, 2);

		mPitchTbl[i] = WDL_bswap16_if_le(word);
		ptr += 2;
	}

	memcpy(mVolumeTbl, &buf[0x1578C], sizeof(mVolumeTbl));
	memcpy(mVelocityTbl, &buf[0x1580C], sizeof(mVelocityTbl));
	memcpy(mPortaTimeTbl, &buf[0x1640C], sizeof(mPortaTimeTbl));
	memcpy(mPitchEGRateTbl, &buf[0x164A8], sizeof(mPitchEGRateTbl));

	memcpy(mReverbTimeTbl, &buf[0x17160], 60);
	memset(&mReverbTimeTbl[60], mReverbTimeTbl[59], 4);

	ptr = &buf[0x171A8];

	for (int i = 0; i < 256; ++i)
	{
		unsigned short word;
		memcpy(&word, ptr, 2);

		mReverbFeedbackTbl[i] = WDL_bswap16_if_le(word);
		ptr += 2;
	}

	ptr = &buf[0x173D0];

	for (int i = 0; i < 256; ++i)
	{
		unsigned short word;
		memcpy(&word, ptr, 2);

		mReverbGainTbl[i] = WDL_bswap16_if_le(word);
		ptr += 2;
	}

	static const unsigned char ofs[kNumDrumKitNames] =
	{
		0,  // kDrumKitStandard
		8,  // kDrumKitRoom
		16, // kDrumKitPower
		24, // kDrumKitElectronic
		32, // kDrumKitAnalog
		48, // kDrumKitBrush
		56, // kDrumKitOrchestra
		72, // kDrumKitClavinova
		80, // kDrumKitRX
		88, // kDrumKitCM64
		40, // kDrumKitJazz
		64  // -
	};

	ptr = &buf[0x16A80];

	for (int i = 0; i < kNumDrumKitNames; ++i)
	{
		memcpy(mDrumKitName[i], &ptr[ofs[i]], 8);
	}

	ptr = &buf[0x167D8];

	for (int i = 0; i < kNumReverbTypes; ++i)
	{
		char* const name = mReverbTypeName[i];

		memcpy(name, ptr, 8);
		name[7] = ' ';

		ptr += 8;
	}
}

void Firmware::GetSampleSet(const SampleSet* sampleSet[2], int waveNo) const
{
	assert(GetStatus() == true);

	assert(waveNo >= 0 && waveNo < kNumWaveNo);
	waveNo = (unsigned int)waveNo < (unsigned int)kNumWaveNo ? waveNo : kWaveNoSine;

	for (int i = 0; i < 2; ++i)
	{
		int idx = mSampleSetTbl.GetSampleSetIdx(waveNo++);

		assert((idx >= 0 && idx < kNumSampleSets) || idx == kEndOfSampleSets);
		idx = wdl_min(idx, kNumSampleSets);

		sampleSet[i] = &mSampleSets[idx];
	}
}

const SampleSet* Firmware::FindSampleSet(const int waveNo, const int note) const
{
	assert(GetStatus() == true);
	assert(note >= 0 && note <= 127);

	const SampleSet* sampleSet[2];
	GetSampleSet(sampleSet, waveNo);

	assert(sampleSet[0] < &mSampleSets[kNumSampleSets]);
	if (sampleSet[0]->GetNoteLimitLow() > note) return NULL;

	while (sampleSet[0] < sampleSet[1] && sampleSet[0]->GetNoteLimitHigh() < note)
	{
		sampleSet[0]++;

		#ifndef NDEBUG
		if (sampleSet[0] < sampleSet[1])
		{
			assert(sampleSet[0] < &mSampleSets[kNumSampleSets]);
		}
		#endif
	}

	return sampleSet[0] < sampleSet[1] ? sampleSet[0] : NULL;
}

const char* Firmware::LookupDrumKitName(EDrumKitIdx idx, const int prog) const
{
	assert(GetStatus() == true);
	assert(idx >= 0 && idx < kNumDrumKits);

	static const int jazz = kNumDrumKits;
	idx = prog == 32 ? jazz : idx;

	static const unsigned int noName = kNumDrumKitNames - 1;
	idx = wdl_min((unsigned int)idx, noName);

	return mDrumKitName[(unsigned int)idx];
}

char* Firmware::GetDrumKitName(char buf[9], const EDrumKitIdx idx, const int prog) const
{
	memcpy(buf, LookupDrumKitName(idx, prog), 8);
	return RightTrim(buf, 8);
}

char* Firmware::GetReverbTypeName(char buf[8], const EReverbType type) const
{
	memcpy(buf, LookupReverbTypeName(type), 8);
	return RightTrim(buf, 7);
}

} // namespace TG101