/*=========================================================================*/
/* */
/* eci.h */
/* */
/* Licensed Materials - Property of IBM */
/* (C) Copyright IBM Corp. 1998, 2002 All Rights Reserved. */
/* US Government Users Restricted Rights - Use, duplication or disclosure */
/* restricted by GSA ADP Schedule Contract with IBM Corp. */
/* */
/* The following IBM source code is provided to assist you in your */
/* development. You may use this code only in accordance with the */
/* IBM License Agreement. */
/* */
/* This copyright statement may not be removed. */
/* */
/*=========================================================================*/
#ifndef __ECI_H
#define __ECI_H
#ifndef MOTIF
typedef int Boolean;
#endif
#define ECITrue 1
#define ECIFalse 0
#ifndef ECIFNDECLARE
typedef signed long ECIint32;
#ifdef _MSC_VER
#ifdef _WIN32_WCE
typedef char ECIsystemChar;
#define ECIFNDECLARE __stdcall
#elif defined _WIN32
#include <tchar.h>
typedef _TCHAR ECIsystemChar;
#define ECIFNDECLARE __stdcall
#endif
#elif defined __TURBOC__
#ifdef __WIN32__
#include <tchar.h>
#define ECIFNDECLARE __stdcall
typedef _TCHAR ECIsystemChar;
#endif
#else
#define ECIFNDECLARE
typedef char ECIsystemChar;
#endif
#endif
#ifndef NULL_ECI_HAND
#define NULL_ECI_HAND 0
#endif
#define ECI_PRESET_VOICES 8
#define ECI_USER_DEFINED_VOICES 8
#define ECI_VOICE_NAME_LENGTH 30
#define ECI_NOERROR 0x00000000
#define ECI_SYSTEMERROR 0x00000001
#define ECI_MEMORYERROR 0x00000002
#define ECI_MODULELOADERROR 0x00000004
#define ECI_DELTAERROR 0x00000008
#define ECI_SYNTHERROR 0x00000010
#define ECI_DEVICEERROR 0x00000020
#define ECI_DICTERROR 0x00000040
#define ECI_PARAMETERERROR 0x00000080
#define ECI_SYNTHESIZINGERROR 0x00000100
#define ECI_DEVICEBUSY 0x00000200
#define ECI_SYNTHESISPAUSED 0x00000400
#define ECI_REENTRANTCALL 0x00000800
#define ECI_ROMANIZERERROR 0x00001000
#define ECI_SYNTHESIZING 0x00002000
#define eciPhonemeLength (4)
#ifdef __cplusplus
extern "C" {
#endif
typedef void* ECIHand;
typedef const void* ECIInputText;
enum ECIParam {
eciSynthMode,
eciInputType,
eciTextMode,
eciDictionary,
eciSampleRate = 5,
eciWantPhonemeIndices = 7,
eciRealWorldUnits,
eciLanguageDialect,
eciNumberMode,
eciWantWordIndex = 12,
eciNumDeviceBlocks,
eciSizeDeviceBlocks,
eciNumPrerollDeviceBlocks,
eciSizePrerollDeviceBlocks,
eciNumParams
};
enum ECIVoiceParam {
eciGender,
eciHeadSize,
eciPitchBaseline,
eciPitchFluctuation,
eciRoughness,
eciBreathiness,
eciSpeed,
eciVolume,
eciNumVoiceParams
};
enum ECIDictError {
DictNoError,
DictFileNotFound,
DictOutOfMemory,
DictInternalError,
DictNoEntry,
DictErrLookUpKey,
DictAccessError,
DictInvalidVolume
};
typedef void* ECIDictHand;
#define NULL_DICT_HAND 0
enum ECIDictVolume {
eciMainDict = 0,
eciRootDict = 1,
eciAbbvDict = 2,
eciMainDictExt = 3
};
enum ECILanguageDialect {
NODEFINEDCODESET = 0x00000000,
eciGeneralAmericanEnglish = 0x00010000,
eciBritishEnglish = 0x00010001,
eciCastilianSpanish = 0x00020000,
eciMexicanSpanish = 0x00020001,
eciStandardFrench = 0x00030000,
eciCanadianFrench = 0x00030001,
eciStandardGerman = 0x00040000,
eciStandardItalian = 0x00050000,
eciMandarinChinese = 0x00060000,
eciMandarinChineseGB = eciMandarinChinese,
eciMandarinChinesePinYin = 0x00060100,
eciMandarinChineseUCS = 0x00060800,
eciTaiwaneseMandarin = 0x00060001,
eciTaiwaneseMandarinBig5 = eciTaiwaneseMandarin,
eciTaiwaneseMandarinZhuYin = 0x00060101,
eciTaiwaneseMandarinPinYin = 0x00060201,
eciTaiwaneseMandarinUCS = 0x00060801,
eciBrazilianPortuguese = 0x00070000,
eciStandardJapanese = 0x00080000,
eciStandardJapaneseSJIS = eciStandardJapanese,
eciStandardJapaneseUCS = 0x00080800,
eciStandardFinnish = 0x00090000,
eciStandardKorean = 0x000A0000,
eciStandardKoreanUHC = eciStandardKorean,
eciStandardKoreanUCS = 0x000A0800,
eciStandardCantonese = 0x000B0000,
eciStandardCantoneseGB = eciStandardCantonese,
eciStandardCantoneseUCS = 0x000B0800,
eciHongKongCantonese = 0x000B0001,
eciHongKongCantoneseBig5 = eciHongKongCantonese,
eciHongKongCantoneseUCS = 0x000B0801,
eciStandardDutch = 0x000C0000,
eciStandardNorwegian = 0x000D0000,
eciStandardSwedish = 0x000E0000,
eciStandardDanish = 0x000F0000
};
enum ECIPartOfSpeech {
eciUndefinedPOS = 0,
eciFutsuuMeishi = 1,
eciKoyuuMeishi,
eciSahenMeishi,
eciMingCi
};
#if defined(WIN32)
#pragma pack(push, 1)
#elif defined(UNDER_CE) && (defined(MIPS) || defined(SH3))
#pragma pack(push, 4)
#endif
typedef struct {
union {
unsigned char sz[eciPhonemeLength+1];
unsigned short wsz[eciPhonemeLength+1];
} phoneme;
enum ECILanguageDialect eciLanguageDialect;
unsigned char mouthHeight;
unsigned char mouthWidth;
unsigned char mouthUpturn;
unsigned char jawOpen;
unsigned char teethUpperVisible;
unsigned char teethLowerVisible;
unsigned char tonguePosn;
unsigned char lipTension;
} ECIMouthData;
typedef struct ECIVoiceAttrib {
int eciSampleRate;
ECILanguageDialect languageID;
} ECIVoiceAttrib;
#if defined(WIN32) || ( defined(UNDER_CE) && (defined(MIPS) || defined(SH3)) )
#pragma pack(pop)
#endif
enum ECIMessage {
eciWaveformBuffer, eciPhonemeBuffer, eciIndexReply, eciPhonemeIndexReply, eciWordIndexReply
};
enum ECICallbackReturn {
eciDataNotProcessed, eciDataProcessed, eciDataAbort
};
typedef enum ECICallbackReturn (*ECICallback)(ECIHand hEngine, enum ECIMessage Msg, long lParam, void *pData);
#if defined(_WIN32) || defined(_Windows)
enum ECIDialogBox {
eciGeneralDB,
eciAboutDB,
eciVoicesDB,
eciReadingDB,
eciMainDictionaryDB,
eciRootDictionaryDB,
eciNumDialogBoxes
};
#endif
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
ECIHand ECIFNDECLARE eciNew(void);
ECIHand ECIFNDECLARE eciNewEx(enum ECILanguageDialect Value);
int ECIFNDECLARE eciGetAvailableLanguages(enum ECILanguageDialect *aLanguages, int *nLanguages);
ECIHand ECIFNDECLARE eciDelete(ECIHand hEngine);
Boolean ECIFNDECLARE eciReset(ECIHand hEngine);
Boolean ECIFNDECLARE eciIsBeingReentered(ECIHand hEngine);
void ECIFNDECLARE eciVersion(char *pBuffer);
int ECIFNDECLARE eciProgStatus(ECIHand hEngine);
void ECIFNDECLARE eciErrorMessage(ECIHand hEngine, void* buffer);
void ECIFNDECLARE eciClearErrors(ECIHand hEngine);
Boolean ECIFNDECLARE eciTestPhrase(ECIHand hEngine);
Boolean ECIFNDECLARE eciSpeakText(ECIInputText pText, Boolean bAnnotationsInTextPhrase);
Boolean ECIFNDECLARE eciSpeakTextEx(ECIInputText pText, Boolean bAnnotationsInTextPhrase, enum ECILanguageDialect Value);
int ECIFNDECLARE eciGetParam(ECIHand hEngine, enum ECIParam Param);
int ECIFNDECLARE eciSetParam(ECIHand hEngine, enum ECIParam Param, int iValue);
int ECIFNDECLARE eciGetDefaultParam(enum ECIParam parameter);
int ECIFNDECLARE eciSetDefaultParam(enum ECIParam parameter, int value);
Boolean ECIFNDECLARE eciCopyVoice(ECIHand hEngine, int iVoiceFrom, int iVoiceTo);
Boolean ECIFNDECLARE eciGetVoiceName(ECIHand hEngine, int iVoice, void *pBuffer);
Boolean ECIFNDECLARE eciSetVoiceName(ECIHand hEngine, int iVoice, const void *pBuffer);
int ECIFNDECLARE eciGetVoiceParam(ECIHand hEngine, int iVoice, enum ECIVoiceParam Param);
int ECIFNDECLARE eciSetVoiceParam(ECIHand hEngine, int iVoice,
enum ECIVoiceParam Param, int iValue);
Boolean ECIFNDECLARE eciAddText(ECIHand hEngine, ECIInputText pText);
Boolean ECIFNDECLARE eciInsertIndex(ECIHand hEngine, int iIndex);
Boolean ECIFNDECLARE eciSynthesize(ECIHand hEngine);
Boolean ECIFNDECLARE eciSynthesizeFile(ECIHand hEngine, const void *pFilename);
Boolean ECIFNDECLARE eciClearInput(ECIHand hEngine);
Boolean ECIFNDECLARE eciGeneratePhonemes(ECIHand hEngine, int iSize, void *pBuffer);
int ECIFNDECLARE eciGetIndex(ECIHand hEngine);
Boolean ECIFNDECLARE eciStop(ECIHand hEngine);
Boolean ECIFNDECLARE eciSpeaking(ECIHand hEngine);
Boolean ECIFNDECLARE eciSynchronize(ECIHand hEngine);
Boolean ECIFNDECLARE eciSetOutputBuffer(ECIHand hEngine, int iSize, short *psBuffer);
Boolean ECIFNDECLARE eciSetOutputFilename(ECIHand hEngine, const void *pFilename);
Boolean ECIFNDECLARE eciSetOutputDevice(ECIHand hEngine, int iDevNum);
Boolean ECIFNDECLARE eciPause(ECIHand hEngine, Boolean On);
void ECIFNDECLARE eciRegisterCallback(ECIHand hEngine, ECICallback Callback, void *pData);
ECIDictHand ECIFNDECLARE eciNewDict(ECIHand hEngine);
ECIDictHand ECIFNDECLARE eciGetDict(ECIHand hEngine);
enum ECIDictError ECIFNDECLARE eciSetDict(ECIHand hEngine, ECIDictHand hDict);
ECIDictHand ECIFNDECLARE eciDeleteDict(ECIHand hEngine, ECIDictHand hDict);
enum ECIDictError ECIFNDECLARE eciLoadDict(ECIHand hEngine, ECIDictHand hDict, enum ECIDictVolume DictVol, ECIInputText pFilename);
enum ECIDictError ECIFNDECLARE eciSaveDict(ECIHand hEngine, ECIDictHand hDict, enum ECIDictVolume DictVol, ECIInputText pFilename);
enum ECIDictError ECIFNDECLARE eciUpdateDict(ECIHand hEngine, ECIDictHand hDict,
enum ECIDictVolume DictVol, ECIInputText pKey, ECIInputText pTranslationValue);
enum ECIDictError ECIFNDECLARE eciDictFindFirst(ECIHand hEngine,
ECIDictHand hDict, enum ECIDictVolume DictVol,
ECIInputText *ppKey, ECIInputText *ppTranslationValue);
enum ECIDictError ECIFNDECLARE eciDictFindNext(ECIHand hEngine,
ECIDictHand hDict, enum ECIDictVolume DictVol,
ECIInputText *ppKey, ECIInputText *ppTranslationValue);
const char *ECIFNDECLARE eciDictLookup(ECIHand hEngine,
ECIDictHand hDict, enum ECIDictVolume DictVol,
ECIInputText pKey);
enum ECIDictError ECIFNDECLARE eciUpdateDictA(ECIHand hEngine,
ECIDictHand hDict, enum ECIDictVolume DictVol,
ECIInputText pKey, ECIInputText pTranslationValue, enum ECIPartOfSpeech PartOfSpeech);
enum ECIDictError ECIFNDECLARE eciDictFindFirstA(ECIHand hEngine,
ECIDictHand hDict, enum ECIDictVolume DictVol,
ECIInputText *ppKey, ECIInputText *ppTranslationValue, enum ECIPartOfSpeech *pPartOfSpeech);
enum ECIDictError ECIFNDECLARE eciDictFindNextA(ECIHand hEngine,
ECIDictHand hDict, enum ECIDictVolume DictVol,
ECIInputText *ppKey, ECIInputText *ppTranslationValue, enum ECIPartOfSpeech *pPartOfSpeech);
enum ECIDictError ECIFNDECLARE eciDictLookupA(ECIHand hEngine,
ECIDictHand hDict, enum ECIDictVolume DictVol,
ECIInputText pKey, ECIInputText *ppTranslationValue, enum ECIPartOfSpeech *pPartOfSpeech);
#define eciDictFindFirst(eciHandle, dictHandle, dictVolume, ppkey, pptranslation) \
eciDictFindFirst((eciHandle), (dictHandle), (dictVolume), (ECIInputText *) (ppkey), (ECIInputText *) (pptranslation))
#define eciDictFindNext(eciHandle, dictHandle, dictVolume, ppkey, pptranslation) \
eciDictFindNext((eciHandle), (dictHandle), (dictVolume), (ECIInputText *) (ppkey), (ECIInputText *) (pptranslation))
int ECIFNDECLARE eciRegisterVoice(ECIHand eciHand, int voiceNumber, void *vData, ECIVoiceAttrib *vAttrib);
int ECIFNDECLARE eciUnregisterVoice(ECIHand eciHand, int voiceNumber, ECIVoiceAttrib *vAttrib, void **vData);
#ifndef __ECIFILTER_H
#define __ECIFILTER_H
typedef void *ECIFilterHand;
#define NULL_FILTER_HAND 0
typedef enum ECIFilterError {
FilterNoError,
FilterFileNotFound,
FilterOutOfMemory,
FilterInternalError,
FilterAccessError
};
ECIFilterError ECIFNDECLARE eciDeactivateFilter(ECIHand eciHandle, ECIFilterHand pFilter);
ECIFilterHand ECIFNDECLARE eciNewFilter(ECIHand eciHandle, unsigned int filterNum = 0);
ECIFilterError ECIFNDECLARE eciActivateFilter(ECIHand eciHandle, ECIFilterHand whichFilterHand);
ECIFilterHand ECIFNDECLARE eciDeleteFilter(ECIHand eciHandle, ECIFilterHand whichFilterHand);
ECIFilterError ECIFNDECLARE eciUpdateFilter(ECIHand eciHandle, ECIFilterHand whichFilterHand,
ECIInputText key, ECIInputText translation);
ECIFilterError ECIFNDECLARE eciGetFilteredText(ECIHand eciHandle, ECIFilterHand whichFilterHand,
ECIInputText input, ECIInputText *filteredText);
#endif
#ifdef __cplusplus
}
#endif
#endif