// FluencyAPI.cpp
//
// C/C++ module for Fluency API
// Copyright (C) 2008 Fluency, Amsterdam

// see www.fluency.nl/api for documentation

#include <stdio.h>
#include "Windows.h"
#include "FluencyAPI.h"

// type definitions for API functions

typedef unsigned (WINAPI *fluencyGetVersionPROC)(void);
typedef void (WINAPI *fluencyAboutWindowPROC)(HWND Win);
typedef void (WINAPI *fluencyUnlockPROC)(char *Key, char *Extra);
typedef bool (WINAPI *fluencyInitializePROC)(void);
typedef bool (WINAPI *fluencyInitializeFromPROC)(char *TTSPath, char *UserPath);
typedef void (WINAPI *fluencyClosePROC)(void);
typedef unsigned (WINAPI *fluencyGetVoiceCountPROC)(void);
typedef unsigned (WINAPI *fluencyGetVoiceNamePROC)(unsigned Voice, char *Name, unsigned MaxLen);
typedef void *(WINAPI *fluencyCreateVoicePROC)(char *Name);
typedef void (WINAPI *fluencyDeleteVoicePROC)(void *Voice);
typedef void *(WINAPI *fluencyCreateChannelPROC)(void *Voice, unsigned SamplingRate, bool Stereo);
typedef void (WINAPI *fluencyDeleteChannelPROC)(void *Channel);
typedef void (WINAPI *fluencySetVoicePROC)(void *Channel, void *Voice);
typedef void (WINAPI *fluencySetTempoPROC)(void *Channel, int Tempo);
typedef void (WINAPI *fluencySetVolumePROC)(void *Channel, unsigned Volume);
typedef void (WINAPI *fluencySetBalancePROC)(void *Channel, int Balance);
typedef void (WINAPI *fluencySetInputTextPROC)(void *Channel, char *Text);
typedef bool (WINAPI *fluencyGetPhonePROC)(void *Channel, char **Phone, unsigned *Samples, void **Wav, unsigned *TextIndex, unsigned *WordLength);
typedef bool (WINAPI *fluencySpeakPROC)(void *Channel, void *Sync, unsigned User);
typedef void (WINAPI *fluencyStopSpeakingPROC)(void *Channel);
typedef void (WINAPI *fluencyPauseResumeSpeakingPROC)(void *Channel);
typedef void (WINAPI *fluencySpeakToFilePROC)(void *Channel, char *Filename, void *Sync, unsigned User);
typedef void (WINAPI *fluencyAbortSpeakToFilePROC)(void *Channel);
typedef void (WINAPI *fluencyScanTextPROC)(void *Channel, unsigned Sensitivity, void *Sync, unsigned User);
typedef void (WINAPI *fluencyAbortScanTextPROC)(void *Channel);
typedef unsigned (WINAPI *fluencyGetPreferredVoiceNamePROC)(char *Name, unsigned MaxLen);
typedef void (WINAPI *fluencySetPreferredVoiceNamePROC)(char *Name); 
typedef int (WINAPI *fluencyGetPreferredTempoPROC)(void);
typedef unsigned (WINAPI *fluencyGetPreferredVolumePROC)(void);
typedef int (WINAPI *fluencyGetPreferredBalancePROC)(void);
typedef void (WINAPI *fluencySetPreferredTempoPROC)(int Tempo);
typedef void (WINAPI *fluencySetPreferredVolumePROC)(unsigned Volume);
typedef void (WINAPI *fluencySetPreferredBalancePROC)(int Balance);
typedef unsigned (WINAPI *fluencyGetModePROC)(void);
typedef void (WINAPI *fluencySetModePROC)(unsigned Mode);
typedef bool (WINAPI *fluencyGetPunctuationModePROC)(void);
typedef void (WINAPI *fluencySetPunctuationModePROC)(bool Mode);
typedef void (WINAPI *fluencySaveSettingsPROC)(void);
typedef void (WINAPI *fluencyUpdateSettingsPROC)(void);
typedef unsigned (WINAPI *fluencyLookupWordPROC)(char *Word, char *Transcription, unsigned MaxLen);
typedef void (WINAPI *fluencyAddWordPROC)(char *Word, char *Transcription);
typedef unsigned (WINAPI *fluencyUserLexiconNextWordPROC)(char *Word, char *NextWord, unsigned MaxLen);
typedef unsigned (WINAPI *fluencyGetUserDataPathPROC)(char *Path, unsigned MaxLen);
  
// API function pointers

fluencyGetVersionPROC fluencyGetMajorVersionPTR = NULL;
fluencyGetVersionPROC fluencyGetMinorVersionPTR = NULL;
fluencyAboutWindowPROC fluencyAboutWindowPTR = NULL;
fluencyUnlockPROC fluencyUnlockPTR = NULL;
fluencyInitializePROC fluencyInitializePTR = NULL;
fluencyInitializeFromPROC fluencyInitializeFromPTR = NULL;
fluencyClosePROC fluencyClosePTR = NULL;
fluencyGetVoiceCountPROC fluencyGetVoiceCountPTR = NULL;
fluencyGetVoiceNamePROC fluencyGetVoiceNamePTR = NULL;
fluencyCreateVoicePROC fluencyCreateVoicePTR = NULL;
fluencyDeleteVoicePROC fluencyDeleteVoicePTR = NULL;
fluencyCreateChannelPROC fluencyCreateChannelPTR = NULL;
fluencyDeleteChannelPROC fluencyDeleteChannelPTR = NULL;
fluencySetVoicePROC fluencySetVoicePTR = NULL;
fluencySetTempoPROC fluencySetTempoPTR = NULL;
fluencySetVolumePROC fluencySetVolumePTR = NULL;
fluencySetBalancePROC fluencySetBalancePTR = NULL;
fluencySetInputTextPROC fluencySetInputTextPTR = NULL;
fluencyGetPhonePROC fluencyGetPhonePTR = NULL;
fluencySpeakPROC fluencySpeakPTR = NULL;
fluencyStopSpeakingPROC fluencyStopSpeakingPTR = NULL;
fluencyPauseResumeSpeakingPROC fluencyPauseResumeSpeakingPTR = NULL;
fluencySpeakToFilePROC fluencySpeakToFilePTR = NULL;
fluencyAbortSpeakToFilePROC fluencyAbortSpeakToFilePTR = NULL;
fluencyScanTextPROC fluencyScanTextPTR = NULL;
fluencyAbortScanTextPROC fluencyAbortScanTextPTR = NULL;
fluencyGetPreferredVoiceNamePROC fluencyGetPreferredVoiceNamePTR = NULL;
fluencySetPreferredVoiceNamePROC fluencySetPreferredVoiceNamePTR = NULL;
fluencyGetPreferredTempoPROC fluencyGetPreferredTempoPTR = NULL;
fluencyGetPreferredVolumePROC fluencyGetPreferredVolumePTR = NULL;
fluencyGetPreferredBalancePROC fluencyGetPreferredBalancePTR = NULL;
fluencySetPreferredTempoPROC fluencySetPreferredTempoPTR = NULL;
fluencySetPreferredVolumePROC fluencySetPreferredVolumePTR = NULL;
fluencySetPreferredBalancePROC fluencySetPreferredBalancePTR = NULL;
fluencySaveSettingsPROC fluencySaveSettingsPTR = NULL;
fluencyUpdateSettingsPROC fluencyUpdateSettingsPTR = NULL;
fluencyGetModePROC fluencyGetReadingModePTR = NULL;
fluencySetModePROC fluencySetReadingModePTR = NULL;
fluencyGetModePROC fluencyGetSpellOutModePTR = NULL;
fluencySetModePROC fluencySetSpellOutModePTR = NULL;
fluencyGetPunctuationModePROC fluencyGetPunctuationModePTR = NULL;
fluencySetPunctuationModePROC fluencySetPunctuationModePTR = NULL;
fluencyLookupWordPROC fluencyLookupWordPTR = NULL;
fluencyAddWordPROC fluencyAddWordPTR = NULL;
fluencyUserLexiconNextWordPROC fluencyUserLexiconNextWordPTR = NULL;
fluencyGetUserDataPathPROC fluencyGetUserDataPathPTR = NULL;

// load dll

HINSTANCE fluencyLoadDLL(char *TTSPath)
{

	HKEY Key;
	unsigned long MaxBytes = 250;
	char Path[250];
	HINSTANCE  hFluencyDLL;

	hFluencyDLL = 0;
	Path[0] = '\0';

	if (TTSPath == "") { // get path from registry
		RegOpenKey(HKEY_LOCAL_MACHINE, "Software\\Fluency\\TTS", &Key);
		RegQueryValueEx(Key, "Path", NULL, NULL, (LPBYTE)&Path, &MaxBytes);
		RegCloseKey(Key);
	}
	else {
		strcpy(Path, TTSPath);
	}

	if (Path != "") {
		strcat(Path,"\\FLUENCY.DLL");
		hFluencyDLL = LoadLibrary(Path);
		if (hFluencyDLL) {
			fluencyGetMajorVersionPTR = (fluencyGetVersionPROC)GetProcAddress(hFluencyDLL, "fluencyGetMajorVersion");
			fluencyGetMinorVersionPTR = (fluencyGetVersionPROC)GetProcAddress(hFluencyDLL, "fluencyGetMinorVersion");
			fluencyAboutWindowPTR = (fluencyAboutWindowPROC)GetProcAddress(hFluencyDLL, "fluencyAboutWindow");
			fluencyUnlockPTR = (fluencyUnlockPROC)GetProcAddress(hFluencyDLL, "fluencyUnlock");
			fluencyInitializePTR = (fluencyInitializePROC)GetProcAddress(hFluencyDLL, "fluencyInitialize");
			fluencyInitializeFromPTR = (fluencyInitializeFromPROC)GetProcAddress(hFluencyDLL, "fluencyInitializeFrom");
			fluencyClosePTR = (fluencyClosePROC)GetProcAddress(hFluencyDLL, "fluencyClose");
			fluencyGetVoiceCountPTR = (fluencyGetVoiceCountPROC)GetProcAddress(hFluencyDLL, "fluencyGetVoiceCount");
			fluencyGetVoiceNamePTR = (fluencyGetVoiceNamePROC)GetProcAddress(hFluencyDLL, "fluencyGetVoiceName");
			fluencyCreateVoicePTR = (fluencyCreateVoicePROC)GetProcAddress(hFluencyDLL, "fluencyCreateVoice");
			fluencyDeleteVoicePTR = (fluencyDeleteVoicePROC)GetProcAddress(hFluencyDLL, "fluencyDeleteVoice");
			fluencyCreateChannelPTR = (fluencyCreateChannelPROC)GetProcAddress(hFluencyDLL, "fluencyCreateChannel");
			fluencyDeleteChannelPTR = (fluencyDeleteChannelPROC)GetProcAddress(hFluencyDLL, "fluencyDeleteChannel");
			fluencySetVoicePTR = (fluencySetVoicePROC)GetProcAddress(hFluencyDLL, "fluencySetVoice");
			fluencySetTempoPTR = (fluencySetTempoPROC)GetProcAddress(hFluencyDLL, "fluencySetTempo");
			fluencySetVolumePTR = (fluencySetVolumePROC)GetProcAddress(hFluencyDLL, "fluencySetVolume");
			fluencySetBalancePTR = (fluencySetBalancePROC)GetProcAddress(hFluencyDLL, "fluencySetBalance");
			fluencySetInputTextPTR = (fluencySetInputTextPROC)GetProcAddress(hFluencyDLL, "fluencySetInputText");
			fluencyGetPhonePTR = (fluencyGetPhonePROC)GetProcAddress(hFluencyDLL, "fluencyGetPhone");
			fluencySpeakPTR = (fluencySpeakPROC)GetProcAddress(hFluencyDLL, "fluencySpeak");
			fluencyStopSpeakingPTR = (fluencyStopSpeakingPROC)GetProcAddress(hFluencyDLL, "fluencyStopSpeaking");
			fluencyPauseResumeSpeakingPTR = (fluencyPauseResumeSpeakingPROC)GetProcAddress(hFluencyDLL, "fluencyPauseResumeSpeaking");
			fluencySpeakToFilePTR = (fluencySpeakToFilePROC)GetProcAddress(hFluencyDLL, "fluencySpeakToFile");
			fluencyAbortSpeakToFilePTR = (fluencyAbortSpeakToFilePROC)GetProcAddress(hFluencyDLL, "fluencyAbortSpeakToFile");
			fluencyScanTextPTR = (fluencyScanTextPROC)GetProcAddress(hFluencyDLL, "fluencyScanText");
			fluencyAbortScanTextPTR = (fluencyAbortScanTextPROC)GetProcAddress(hFluencyDLL, "fluencyAbortScanText");
			fluencyGetPreferredVoiceNamePTR = (fluencyGetPreferredVoiceNamePROC)GetProcAddress(hFluencyDLL, "fluencyGetPreferredVoiceName");
			fluencySetPreferredVoiceNamePTR = (fluencySetPreferredVoiceNamePROC)GetProcAddress(hFluencyDLL, "fluencySetPreferredVoiceName");
			fluencyGetPreferredTempoPTR = (fluencyGetPreferredTempoPROC)GetProcAddress(hFluencyDLL, "fluencyGetPreferredTempo");
			fluencyGetPreferredVolumePTR = (fluencyGetPreferredVolumePROC)GetProcAddress(hFluencyDLL, "fluencyGetPreferredVolume");
			fluencyGetPreferredBalancePTR = (fluencyGetPreferredBalancePROC)GetProcAddress(hFluencyDLL, "fluencyGetPreferredBalance");
			fluencySetPreferredTempoPTR = (fluencySetPreferredTempoPROC)GetProcAddress(hFluencyDLL, "fluencySetPreferredTempo");
			fluencySetPreferredVolumePTR = (fluencySetPreferredVolumePROC)GetProcAddress(hFluencyDLL, "fluencySetPreferredVolume");
			fluencySetPreferredBalancePTR = (fluencySetPreferredBalancePROC)GetProcAddress(hFluencyDLL, "fluencySetPreferredBalance");
			fluencyGetReadingModePTR = (fluencyGetModePROC)GetProcAddress(hFluencyDLL, "fluencyGetReadingMode");
			fluencySetReadingModePTR = (fluencySetModePROC)GetProcAddress(hFluencyDLL, "fluencySetReadingMode");
			fluencyGetSpellOutModePTR = (fluencyGetModePROC)GetProcAddress(hFluencyDLL, "fluencyGetSpellOutMode");
			fluencySetSpellOutModePTR = (fluencySetModePROC)GetProcAddress(hFluencyDLL, "fluencySetSpellOutMode");
			fluencyGetPunctuationModePTR = (fluencyGetPunctuationModePROC)GetProcAddress(hFluencyDLL, "fluencyGetPunctuationMode");
			fluencySetPunctuationModePTR = (fluencySetPunctuationModePROC)GetProcAddress(hFluencyDLL, "fluencySetPunctuationMode");
			fluencySaveSettingsPTR = (fluencySaveSettingsPROC)GetProcAddress(hFluencyDLL, "fluencySaveSettings");
			fluencyUpdateSettingsPTR = (fluencyUpdateSettingsPROC)GetProcAddress(hFluencyDLL, "fluencyUpdateSettings");
			fluencyLookupWordPTR = (fluencyLookupWordPROC)GetProcAddress(hFluencyDLL, "fluencyLookupWord");
			fluencyAddWordPTR = (fluencyAddWordPROC)GetProcAddress(hFluencyDLL, "fluencyAddWord");
			fluencyUserLexiconNextWordPTR = (fluencyUserLexiconNextWordPROC)GetProcAddress(hFluencyDLL, "fluencyUserLexiconNextWord");
			fluencyGetUserDataPathPTR = (fluencyGetUserDataPathPROC)GetProcAddress(hFluencyDLL, "fluencyGetUserDataPath");
		}
	}
	return hFluencyDLL;
}


// implementation of API functions

unsigned fluencyGetMajorVersion(void)
{
	if (fluencyGetMajorVersionPTR) 
		return fluencyGetMajorVersionPTR(); 
	else 
		return 0;
}

unsigned fluencyGetMinorVersion(void)
{
	if (fluencyGetMinorVersionPTR) 
		return fluencyGetMinorVersionPTR(); 
	else 
		return 0;
}

void fluencyAboutWindow(HWND Win)
{
	if (fluencyAboutWindowPTR) fluencyAboutWindowPTR(Win);
}

void fluencyUnlock(char *Key, char *Extra)
{
	if (fluencyUnlockPTR) fluencyUnlockPTR(Key, Extra);
}

bool fluencyInitialize(void)
{
	if (fluencyInitializePTR) 
		return fluencyInitializePTR(); 
	else 
		return FALSE;
}


bool fluencyInitializeFrom(char *TTSPath, char *UserPath)
{
	if (fluencyInitializeFromPTR) 
		return fluencyInitializeFromPTR(TTSPath, UserPath); 
	else 
		return FALSE;
}

void fluencyClose(void)
{
	if (fluencyClosePTR) fluencyClosePTR();
}

unsigned fluencyGetVoiceCount(void)
{
	if (fluencyGetVoiceCountPTR) 
		return fluencyGetVoiceCountPTR(); 
	else 
		return 0;
}

unsigned fluencyGetVoiceName(unsigned VoiceIndex, char *Name, unsigned MaxLen)
{
	if (fluencyGetVoiceNamePTR) 
		return fluencyGetVoiceNamePTR(VoiceIndex, Name, MaxLen); 
	else {
		Name[0] = '\0';
		return 0;
	}
}

void *fluencyCreateVoice(char *Name)
{
	if (fluencyCreateVoicePTR) 
		return fluencyCreateVoicePTR(Name); 
	else 
		return NULL;
}

void fluencyDeleteVoice(void *Voice)
{
	if (fluencyDeleteVoicePTR) fluencyDeleteVoicePTR(Voice);
}

void *fluencyCreateChannel(void *Voice, unsigned SamplingRate, bool Stereo)
{
	if (fluencyCreateChannelPTR) 
		return fluencyCreateChannelPTR(Voice, SamplingRate, Stereo); 
	else 
		return NULL;
}

void fluencyDeleteChannel(void *Channel)
{
	if (fluencyDeleteChannelPTR) fluencyDeleteChannelPTR(Channel);
}

void fluencySetVoice(void *Channel, void *Voice)
{
	if (fluencySetVoicePTR) fluencySetVoicePTR(Channel, Voice);
}

void fluencySetTempo(void *Channel, int Tempo)
{
	if (fluencySetTempoPTR) fluencySetTempoPTR(Channel, Tempo);
}

void fluencySetVolume(void *Channel, unsigned Volume)
{
	if (fluencySetVolumePTR) fluencySetVolumePTR(Channel, Volume);
}

void fluencySetBalance(void *Channel, int Balance)
{
	if (fluencySetBalancePTR) fluencySetBalancePTR(Channel, Balance);
}

void fluencySetInputText(void *Channel, char *Text)
{
	if (fluencySetInputTextPTR) fluencySetInputTextPTR(Channel, Text);
}

bool fluencyGetPhone(void *Channel, char **Phone, unsigned *Samples, void **Wav, unsigned *TextIndex, unsigned *WordLength)
{
	if (fluencyGetPhonePTR) 
		return fluencyGetPhonePTR(Channel, Phone, Samples, Wav, TextIndex, WordLength); 
	else 
		return FALSE;
}


bool fluencySpeak(void *Channel, void *Sync, unsigned User)
{
	if (fluencySpeakPTR) 
		return fluencySpeakPTR(Channel, Sync, User); 
	else 
		return FALSE;
}

void fluencyStopSpeaking(void *Channel)
{
	if (fluencyStopSpeakingPTR) fluencyStopSpeakingPTR(Channel);
}

void fluencyPauseResumeSpeaking(void *Channel)
{
	if (fluencyPauseResumeSpeakingPTR) fluencyPauseResumeSpeakingPTR(Channel);
}

void fluencySpeakToFile(void *Channel, char *Filename, void *Sync, unsigned User)
{
	if (fluencySpeakToFilePTR) fluencySpeakToFilePTR(Channel, Filename, Sync, User);
}

void fluencyAbortSpeakToFile(void *Channel)
{
	if (fluencyAbortSpeakToFilePTR) fluencyAbortSpeakToFilePTR(Channel);
}

void fluencyScanText(void *Channel, unsigned Sensitivity, void *Sync, unsigned User)
{
	if (fluencyScanTextPTR) fluencyScanTextPTR(Channel, Sensitivity, Sync, User);
}

void fluencyAbortScanText(void *Channel)
{
	if (fluencyAbortScanTextPTR) fluencyAbortScanTextPTR(Channel);
}

unsigned fluencyGetPreferredVoiceName(char *Name, unsigned MaxLen)
{
	if (fluencyGetPreferredVoiceNamePTR) 
		return fluencyGetPreferredVoiceNamePTR(Name, MaxLen); 
	else 
		return 0;
}

void fluencySetPreferredVoiceName(char *Name) 
{
	if (fluencySetPreferredVoiceNamePTR) fluencySetPreferredVoiceNamePTR(Name);
}

int fluencyGetPreferredTempo(void)
{
	if (fluencyGetPreferredTempoPTR) 
		return fluencyGetPreferredTempoPTR(); 
	else 
		return 0;
}

unsigned fluencyGetPreferredVolume(void)
{
	if (fluencyGetPreferredVolumePTR) 
		return fluencyGetPreferredVolumePTR(); 
	else 
		return 0;
}

int fluencyGetPreferredBalance(void)
{
	if (fluencyGetPreferredBalancePTR) 
		return fluencyGetPreferredBalancePTR(); 
	else 
		return 0;
}

void fluencySetPreferredTempo(int Tempo)
{
	if (fluencySetPreferredTempoPTR) fluencySetPreferredTempoPTR(Tempo);
}

void fluencySetPreferredVolume(unsigned Volume)
{
	if (fluencySetPreferredVolumePTR) fluencySetPreferredVolumePTR(Volume);
}

void fluencySetPreferredBalance(int Balance)
{
	if (fluencySetPreferredBalancePTR) fluencySetPreferredBalancePTR(Balance);
}

unsigned fluencyGetReadingMode(void)
{
	if (fluencyGetReadingModePTR) 
		return fluencyGetReadingModePTR(); 
	else 
		return 0;
}

void fluencySetReadingMode(unsigned Mode)
{
	if (fluencySetReadingModePTR) fluencySetReadingModePTR(Mode);
}

unsigned fluencyGetSpellOutMode(void)
{
	if (fluencyGetSpellOutModePTR) 
		return fluencyGetSpellOutModePTR(); 
	else 
		return 0;
}

void fluencySetSpellOutMode(unsigned Mode)
{
	if (fluencySetSpellOutModePTR) fluencySetSpellOutModePTR(Mode);
}

bool fluencyGetPunctuationMode(void)
{
	if (fluencyGetPunctuationModePTR) 
		return fluencyGetPunctuationModePTR(); 
	else 
		return 0;
}

void fluencySetPunctuationMode(bool Mode)
{
	if (fluencySetPunctuationModePTR) fluencySetPunctuationModePTR(Mode);
}

void fluencySaveSettings(void)
{
	if (fluencySaveSettingsPTR) fluencySaveSettingsPTR();
}

void fluencyUpdateSettings(void)
{
	if (fluencyUpdateSettingsPTR) fluencyUpdateSettingsPTR();
}

unsigned fluencyLookupWord(char *Word, char *Transcription, unsigned MaxLen)
{
	if (fluencyLookupWordPTR) 
		return fluencyLookupWordPTR(Word, Transcription, MaxLen); 
	else 
		return 0;
}

void fluencyAddWord(char *Word, char *Transcription)
{
	if (fluencyAddWordPTR) fluencyAddWordPTR(Word, Transcription);
}

unsigned fluencyUserLexiconNextWord(char *Word, char *NextWord, unsigned MaxLen)
{
	if (fluencyUserLexiconNextWordPTR) 
		return fluencyUserLexiconNextWordPTR(Word, NextWord, MaxLen); 
	else 
		return 0;
}

unsigned fluencyGetUserDataPath(char *Path, unsigned MaxLen)
{
	if (fluencyGetUserDataPathPTR) 
		return fluencyGetUserDataPathPTR(Path, MaxLen); 
	else 
		return 0;
}