/**************************************************************************** * sapi.idl * * This is the interface definition file for the Microsoft Speech API * Version 5.0. * * Copyright (c) Microsoft Corporation. All rights reserved. *****************************************************************************/ //--- Compiler Directive ---------------------------------------------------- cpp_quote("#pragma warning(disable:4201) // Allow nameless structs/unions") //--- Includes -------------------------------------------------------------- import "oaidl.idl"; import "ocidl.idl"; //--- Locally scoped define for LANGID #ifndef LANGID #define LANGID WORD #endif //--- Link with sapi.lib cpp_quote("#pragma comment(lib, \"sapi.lib\")") //--- Forward and External Declarations ------------------------------------- cpp_quote("#if 0") // Ignore our definition in the .H file typedef [restricted, hidden] struct WAVEFORMATEX { WORD wFormatTag; /* format type */ WORD nChannels; /* number of channels (i.e. mono, stereo...) */ DWORD nSamplesPerSec; /* sample rate */ DWORD nAvgBytesPerSec; /* for buffer estimation */ WORD nBlockAlign; /* block size of data */ WORD wBitsPerSample; /* Number of bits per sample of mono data */ WORD cbSize; /* The count in bytes of the size of extra information (after cbSize) */ } WAVEFORMATEX; cpp_quote("#else") cpp_quote("#include ") cpp_quote("#endif") //--- Notifications interface ISpNotifySource; interface ISpNotifySink; interface ISpNotifyTranslator; //--- Object tokens interface ISpDataKey; interface ISpObjectTokenCategory; interface ISpObjectToken; interface IEnumSpObjectTokens; interface ISpObjectWithToken; //--- Resource management interface ISpResourceManager; //--- Speech specific events interface ISpEventSource; interface ISpEventSink; //--- Audio streams interface ISpStreamFormat; interface ISpStream; interface ISpStreamFormatConverter; interface ISpAudio; interface ISpMMSysAudio; interface ISpTranscript; //--- TTS interface interface ISpVoice; //--- SR interfaces interface ISpRecoResult; interface ISpRecoContext; interface ISpRecognizer; interface ISpProperties; //--- Lexicon interfaces interface ISpLexicon; //--- Phone Converter interface ISpPhoneConverter; //--- Phrase interface interface ISpPhrase; // //--- Constants ------------------------------------------------------------- // //--- DataKey locations typedef [hidden] enum SPDATAKEYLOCATION { SPDKL_DefaultLocation = 0, SPDKL_CurrentUser = 1, SPDKL_LocalMachine = 2, SPDKL_CurrentConfig = 5 } SPDATAKEYLOCATION; //--- TokenUI constants cpp_quote("#define SPDUI_EngineProperties L\"EngineProperties\"") cpp_quote("#define SPDUI_AddRemoveWord L\"AddRemoveWord\"") cpp_quote("#define SPDUI_UserTraining L\"UserTraining\"") cpp_quote("#define SPDUI_MicTraining L\"MicTraining\"") cpp_quote("#define SPDUI_RecoProfileProperties L\"RecoProfileProperties\"") cpp_quote("#define SPDUI_AudioProperties L\"AudioProperties\"") cpp_quote("#define SPDUI_AudioVolume L\"AudioVolume\"") //--- Data formats - these are used by the CSpStreamFormat class in sphelper.h typedef [hidden] enum SPSTREAMFORMAT { SPSF_Default = -1, SPSF_NoAssignedFormat = 0, // Similar to GUID_NULL SPSF_Text, SPSF_NonStandardFormat, // Non-SAPI 5.1 standard format with no WAVEFORMATEX description SPSF_ExtendedAudioFormat, // Non-SAPI 5.1 standard format but has WAVEFORMATEX description // Standard PCM wave formats SPSF_8kHz8BitMono, SPSF_8kHz8BitStereo, SPSF_8kHz16BitMono, SPSF_8kHz16BitStereo, SPSF_11kHz8BitMono, SPSF_11kHz8BitStereo, SPSF_11kHz16BitMono, SPSF_11kHz16BitStereo, SPSF_12kHz8BitMono, SPSF_12kHz8BitStereo, SPSF_12kHz16BitMono, SPSF_12kHz16BitStereo, SPSF_16kHz8BitMono, SPSF_16kHz8BitStereo, SPSF_16kHz16BitMono, SPSF_16kHz16BitStereo, SPSF_22kHz8BitMono, SPSF_22kHz8BitStereo, SPSF_22kHz16BitMono, SPSF_22kHz16BitStereo, SPSF_24kHz8BitMono, SPSF_24kHz8BitStereo, SPSF_24kHz16BitMono, SPSF_24kHz16BitStereo, SPSF_32kHz8BitMono, SPSF_32kHz8BitStereo, SPSF_32kHz16BitMono, SPSF_32kHz16BitStereo, SPSF_44kHz8BitMono, SPSF_44kHz8BitStereo, SPSF_44kHz16BitMono, SPSF_44kHz16BitStereo, SPSF_48kHz8BitMono, SPSF_48kHz8BitStereo, SPSF_48kHz16BitMono, SPSF_48kHz16BitStereo, // TrueSpeech format SPSF_TrueSpeech_8kHz1BitMono, // A-Law formats SPSF_CCITT_ALaw_8kHzMono, SPSF_CCITT_ALaw_8kHzStereo, SPSF_CCITT_ALaw_11kHzMono, SPSF_CCITT_ALaw_11kHzStereo, SPSF_CCITT_ALaw_22kHzMono, SPSF_CCITT_ALaw_22kHzStereo, SPSF_CCITT_ALaw_44kHzMono, SPSF_CCITT_ALaw_44kHzStereo, // u-Law formats SPSF_CCITT_uLaw_8kHzMono, SPSF_CCITT_uLaw_8kHzStereo, SPSF_CCITT_uLaw_11kHzMono, SPSF_CCITT_uLaw_11kHzStereo, SPSF_CCITT_uLaw_22kHzMono, SPSF_CCITT_uLaw_22kHzStereo, SPSF_CCITT_uLaw_44kHzMono, SPSF_CCITT_uLaw_44kHzStereo, // ADPCM formats SPSF_ADPCM_8kHzMono, SPSF_ADPCM_8kHzStereo, SPSF_ADPCM_11kHzMono, SPSF_ADPCM_11kHzStereo, SPSF_ADPCM_22kHzMono, SPSF_ADPCM_22kHzStereo, SPSF_ADPCM_44kHzMono, SPSF_ADPCM_44kHzStereo, // GSM 6.10 formats SPSF_GSM610_8kHzMono, SPSF_GSM610_11kHzMono, SPSF_GSM610_22kHzMono, SPSF_GSM610_44kHzMono, SPSF_NUM_FORMATS } SPSTREAMFORMAT; cpp_quote("EXTERN_C const GUID SPDFID_Text;") cpp_quote("EXTERN_C const GUID SPDFID_WaveFormatEx;") //--- Root of registry entries for speech use cpp_quote("#define SPREG_USER_ROOT L\"HKEY_CURRENT_USER\\\\SOFTWARE\\\\Microsoft\\\\Speech\"") cpp_quote("#define SPREG_LOCAL_MACHINE_ROOT L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\"") //--- Categories for speech resource management cpp_quote("#define SPCAT_AUDIOOUT L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AudioOutput\"") cpp_quote("#define SPCAT_AUDIOIN L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AudioInput\"") cpp_quote("#define SPCAT_VOICES L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\Voices\"") cpp_quote("#define SPCAT_RECOGNIZERS L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\Recognizers\"") cpp_quote("#define SPCAT_APPLEXICONS L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AppLexicons\"") cpp_quote("#define SPCAT_PHONECONVERTERS L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\PhoneConverters\"") cpp_quote("#define SPCAT_RECOPROFILES L\"HKEY_CURRENT_USER\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\RecoProfiles\"") //--- Specific token ids of interest cpp_quote("#define SPMMSYS_AUDIO_IN_TOKEN_ID L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AudioInput\\\\TokenEnums\\\\MMAudioIn\\\\\"") cpp_quote("#define SPMMSYS_AUDIO_OUT_TOKEN_ID L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AudioOutput\\\\TokenEnums\\\\MMAudioOut\\\\\"") cpp_quote("#define SPCURRENT_USER_LEXICON_TOKEN_ID L\"HKEY_CURRENT_USER\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\CurrentUserLexicon\"") //--- Standard token values cpp_quote("#define SPTOKENVALUE_CLSID L\"CLSID\"") cpp_quote("#define SPTOKENKEY_FILES L\"Files\"") cpp_quote("#define SPTOKENKEY_UI L\"UI\"") cpp_quote("#define SPTOKENKEY_ATTRIBUTES L\"Attributes\"") //--- Standard voice category values cpp_quote("#define SPVOICECATEGORY_TTSRATE L\"DefaultTTSRate\"") //--- Standard SR Engine properties cpp_quote("#define SPPROP_RESOURCE_USAGE L\"ResourceUsage\"") cpp_quote("#define SPPROP_HIGH_CONFIDENCE_THRESHOLD L\"HighConfidenceThreshold\"") cpp_quote("#define SPPROP_NORMAL_CONFIDENCE_THRESHOLD L\"NormalConfidenceThreshold\"") cpp_quote("#define SPPROP_LOW_CONFIDENCE_THRESHOLD L\"LowConfidenceThreshold\"") cpp_quote("#define SPPROP_RESPONSE_SPEED L\"ResponseSpeed\"") cpp_quote("#define SPPROP_COMPLEX_RESPONSE_SPEED L\"ComplexResponseSpeed\"") cpp_quote("#define SPPROP_ADAPTATION_ON L\"AdaptationOn\"") //--- Standard SAPI Recognition Topics cpp_quote("#define SPTOPIC_SPELLING L\"Spelling\"") // CFG Wildcard token cpp_quote("#define SPWILDCARD L\"...\"") // CFG Dication token cpp_quote("#define SPDICTATION L\"*\"") cpp_quote("#define SPINFDICTATION L\"*+\"") // CFG confidence scores const signed char SP_LOW_CONFIDENCE = -1; const signed char SP_NORMAL_CONFIDENCE = 0; const signed char SP_HIGH_CONFIDENCE = +1; // CFG default weight const float DEFAULT_WEIGHT = 1.0; // Lexicon word and pronunciation limits const ULONG SP_MAX_WORD_LENGTH = 128; const ULONG SP_MAX_PRON_LENGTH = 384; // //--- Interface definitions ------------------------------------------------- // //--- ISpNotifyCallback ----------------------------------------------------- cpp_quote("#if defined(__cplusplus)") cpp_quote("interface ISpNotifyCallback") cpp_quote("{") cpp_quote("virtual HRESULT STDMETHODCALLTYPE NotifyCallback(") cpp_quote(" WPARAM wParam,") cpp_quote(" LPARAM lParam) = 0;") cpp_quote("};") cpp_quote("#else") typedef void * ISpNotifyCallback; cpp_quote("#endif") cpp_quote("#if 0") typedef void * SPNOTIFYCALLBACK; cpp_quote("#else") cpp_quote("typedef void __stdcall SPNOTIFYCALLBACK(WPARAM wParam, LPARAM lParam);") cpp_quote("#endif") //--- ISpNotifySource ------------------------------------------------------- [ object, uuid(5EFF4AEF-8487-11D2-961C-00C04F8EE628), helpstring("ISpNotifySource Interface"), pointer_default(unique), restricted ] interface ISpNotifySource : IUnknown { HRESULT SetNotifySink([in] ISpNotifySink * pNotifySink); [local] HRESULT SetNotifyWindowMessage( [in] HWND hWnd, [in] UINT Msg, [in] WPARAM wParam, [in] LPARAM lParam); [local] HRESULT SetNotifyCallbackFunction( [in] SPNOTIFYCALLBACK * pfnCallback, [in] WPARAM wParam, [in] LPARAM lParam); [local] HRESULT SetNotifyCallbackInterface( [in] ISpNotifyCallback * pSpCallback, [in] WPARAM wParam, [in] LPARAM lParam); [local] HRESULT SetNotifyWin32Event(void); [local] HRESULT WaitForNotifyEvent([in] DWORD dwMilliseconds); [local] HANDLE GetNotifyEventHandle(); } //--- ISpNotifySink --------------------------------------------------------- [ object, uuid(259684DC-37C3-11D2-9603-00C04F8EE628), helpstring("ISpNotifySink Interface"), pointer_default(unique), restricted ] interface ISpNotifySink : IUnknown { HRESULT Notify(void); } //--- ISpNotifyTranslator --------------------------------------------------- [ object, uuid(ACA16614-5D3D-11D2-960E-00C04F8EE628), helpstring("ISpNotifyTranslator Interface"), pointer_default(unique), local, restricted ] interface ISpNotifyTranslator : ISpNotifySink { HRESULT InitWindowMessage( [in] HWND hWnd, [in] UINT Msg, [in] WPARAM wParam, [in] LPARAM lParam); HRESULT InitCallback( [in] SPNOTIFYCALLBACK * pfnCallback, [in] WPARAM wParam, [in] LPARAM lParam); HRESULT InitSpNotifyCallback( [in] ISpNotifyCallback * pSpCallback, [in] WPARAM wParam, [in] LPARAM lParam); HRESULT InitWin32Event( HANDLE hEvent, BOOL fCloseHandleOnRelease); HRESULT Wait([in] DWORD dwMilliseconds); HANDLE GetEventHandle(); } //--- ISpDataKey ------------------------------------------------------------ [ object, uuid(14056581-E16C-11D2-BB90-00C04F8EE6C0), helpstring("ISpDataKey Interface"), pointer_default(unique), restricted ] interface ISpDataKey : IUnknown { HRESULT SetData( const WCHAR * pszValueName, ULONG cbData, const BYTE * pData); HRESULT GetData( const WCHAR * pszValueName, ULONG * pcbData, BYTE * pData); HRESULT SetStringValue( const WCHAR * pszValueName, const WCHAR * pszValue ); HRESULT GetStringValue( const WCHAR * pszValueName, WCHAR ** ppszValue); HRESULT SetDWORD(const WCHAR * pszValueName, DWORD dwValue ); HRESULT GetDWORD(const WCHAR * pszValueName, DWORD *pdwValue ); HRESULT OpenKey(const WCHAR * pszSubKeyName, ISpDataKey ** ppSubKey); HRESULT CreateKey(const WCHAR * pszSubKey, ISpDataKey ** ppSubKey); HRESULT DeleteKey(const WCHAR * pszSubKey); HRESULT DeleteValue(const WCHAR * pszValueName); HRESULT EnumKeys(ULONG Index, WCHAR ** ppszSubKeyName); HRESULT EnumValues(ULONG Index, WCHAR ** ppszValueName); }; //--- ISpRegDataKey --------------------------------------------------------- [ object, uuid(92A66E2B-C830-4149-83DF-6FC2BA1E7A5B), helpstring("ISpRegDataKey"), pointer_default(unique), restricted ] interface ISpRegDataKey : ISpDataKey { [local] HRESULT SetKey([in] HKEY hkey, [in] BOOL fReadOnly); } //--- ISpObjectTokenCategory ------------------------------------------------ [ object, uuid(2D3D3845-39AF-4850-BBF9-40B49780011D), helpstring("ISpObjectTokenCategory"), pointer_default(unique), restricted ] interface ISpObjectTokenCategory : ISpDataKey { HRESULT SetId([in] const WCHAR * pszCategoryId, BOOL fCreateIfNotExist); HRESULT GetId([out] WCHAR ** ppszCoMemCategoryId); HRESULT GetDataKey(SPDATAKEYLOCATION spdkl, ISpDataKey ** ppDataKey); HRESULT EnumTokens( [in, string] const WCHAR * pzsReqAttribs, [in, string] const WCHAR * pszOptAttribs, [out] IEnumSpObjectTokens ** ppEnum); HRESULT SetDefaultTokenId([in] const WCHAR * pszTokenId); HRESULT GetDefaultTokenId([out] WCHAR ** ppszCoMemTokenId); }; //--- ISpObjectToken -------------------------------------------------------- [ object, uuid(14056589-E16C-11D2-BB90-00C04F8EE6C0), helpstring("ISpObjectToken Interface"), pointer_default(unique), restricted ] interface ISpObjectToken : ISpDataKey { HRESULT SetId(const WCHAR * pszCategoryId, const WCHAR * pszTokenId, BOOL fCreateIfNotExist); HRESULT GetId(WCHAR ** ppszCoMemTokenId); HRESULT GetCategory(ISpObjectTokenCategory ** ppTokenCategory); HRESULT CreateInstance( [in] IUnknown * pUnkOuter, [in] DWORD dwClsContext, [in] REFIID riid, [out, iid_is(riid)] void ** ppvObject); HRESULT GetStorageFileName( [in] REFCLSID clsidCaller, [in] const WCHAR * pszValueName, [in] const WCHAR * pszFileNameSpecifier, [in] ULONG nFolder, // Same as SHGetFolderPath -- If non-zero, must set CSIDL_FLAG_CREATE [out] WCHAR ** ppszFilePath); HRESULT RemoveStorageFileName( [in] REFCLSID clsidCaller, [in] const WCHAR * pszKeyName, [in] BOOL fDeleteFile); HRESULT Remove(const CLSID * pclsidCaller); [local] HRESULT IsUISupported( [in] const WCHAR * pszTypeOfUI, [in] void * pvExtraData, [in] ULONG cbExtraData, [in] IUnknown * punkObject, [out] BOOL *pfSupported); [local] HRESULT DisplayUI( [in] HWND hwndParent, [in] const WCHAR * pszTitle, [in] const WCHAR * pszTypeOfUI, [in] void * pvExtraData, [in] ULONG cbExtraData, [in] IUnknown * punkObject); HRESULT MatchesAttributes( [in] const WCHAR * pszAttributes, [out] BOOL *pfMatches); }; [ object, uuid(B8AAB0CF-346F-49D8-9499-C8B03F161D51), helpstring("ISpObjectTokenInit Interface"), pointer_default(unique), restricted ] interface ISpObjectTokenInit : ISpObjectToken { HRESULT InitFromDataKey( [in] const WCHAR * pszCategoryId, [in] const WCHAR * pszTokenId, [in] ISpDataKey * pDataKey); }; //--- IEnumSpObjectTokens --------------------------------------------------- // This interface is used to enumerate speech object tokens [ object, uuid(06B64F9E-7FDA-11D2-B4F2-00C04F797396), helpstring("IEnumSpObjectTokens Interface"), pointer_default(unique), restricted ] interface IEnumSpObjectTokens : IUnknown { HRESULT Next([in] ULONG celt, [out, size_is(celt), length_is(*pceltFetched)] ISpObjectToken ** pelt, [out] ULONG *pceltFetched); HRESULT Skip([in] ULONG celt); HRESULT Reset(void); HRESULT Clone([out] IEnumSpObjectTokens **ppEnum); HRESULT Item([in] ULONG Index, [out] ISpObjectToken ** ppToken); HRESULT GetCount([out] ULONG* pCount); }; //--- ISpObjectWithToken ---------------------------------------------------- [ object, uuid(5B559F40-E952-11D2-BB91-00C04F8EE6C0), helpstring("ISpObjectWithToken Interface"), pointer_default(unique), restricted ] interface ISpObjectWithToken : IUnknown { HRESULT SetObjectToken(ISpObjectToken * pToken); HRESULT GetObjectToken(ISpObjectToken ** ppToken); }; //--- ISpResourceManager ---------------------------------------------------- [ object, uuid(93384E18-5014-43D5-ADBB-A78E055926BD), helpstring("ISpResourceManager Interface"), pointer_default(unique), restricted ] #ifdef _WIN32_WCE interface ISpResourceManager : IUnknown //IServiceProvider #else interface ISpResourceManager : IServiceProvider #endif // _WIN32_WCE { HRESULT SetObject( [in] REFGUID guidServiceId, [in] IUnknown *pUnkObject); HRESULT GetObject( [in] REFGUID guidServiceId, [in] REFCLSID ObjectCLSID, [in] REFIID ObjectIID, [in] BOOL fReleaseWhenLastExternalRefReleased, [out, iid_is(ObjectIID)] void** ppObject); }; //--- ISpEventSource -------------------------------------------------------- typedef [hidden] enum SPEVENTLPARAMTYPE { SPET_LPARAM_IS_UNDEFINED = 0, SPET_LPARAM_IS_TOKEN, SPET_LPARAM_IS_OBJECT, SPET_LPARAM_IS_POINTER, SPET_LPARAM_IS_STRING, } SPEVENTLPARAMTYPE; typedef [hidden] enum SPEVENTENUM { SPEI_UNDEFINED = 0, //--- TTS engine SPEI_START_INPUT_STREAM = 1, SPEI_END_INPUT_STREAM = 2, SPEI_VOICE_CHANGE = 3, // LPARAM_IS_TOKEN SPEI_TTS_BOOKMARK = 4, // LPARAM_IS_STRING SPEI_WORD_BOUNDARY = 5, SPEI_PHONEME = 6, SPEI_SENTENCE_BOUNDARY = 7, SPEI_VISEME = 8, SPEI_TTS_AUDIO_LEVEL = 9, // wParam contains current output audio level //--- Engine vendors use these reserved bits SPEI_TTS_PRIVATE = 15, SPEI_MIN_TTS = 1, SPEI_MAX_TTS = 15, //--- Speech Recognition SPEI_END_SR_STREAM = 34, // LPARAM contains HRESULT, WPARAM contains flags (SPESF_xxx) SPEI_SOUND_START = 35, SPEI_SOUND_END = 36, SPEI_PHRASE_START = 37, SPEI_RECOGNITION = 38, SPEI_HYPOTHESIS = 39, SPEI_SR_BOOKMARK = 40, SPEI_PROPERTY_NUM_CHANGE = 41, // LPARAM points to a string, WPARAM is the attrib value SPEI_PROPERTY_STRING_CHANGE= 42, // LPARAM pointer to buffer. Two concatinated null terminated strings. SPEI_FALSE_RECOGNITION = 43, // apparent speech with no valid recognition SPEI_INTERFERENCE = 44, // LPARAM is any combination of SPINTERFERENCE flags SPEI_REQUEST_UI = 45, // LPARAM is string. SPEI_RECO_STATE_CHANGE = 46, // wParam contains new reco state SPEI_ADAPTATION = 47, // we are now ready to accept the adaptation buffer SPEI_START_SR_STREAM = 48, SPEI_RECO_OTHER_CONTEXT = 49, // Phrase finished and recognized, but for other context SPEI_SR_AUDIO_LEVEL = 50, // wParam contains current input audio level //--- Engine vendors use these reserved bits SPEI_SR_PRIVATE = 52, SPEI_MIN_SR = 34, SPEI_MAX_SR = 52, SPEI_RESERVED1 = 30, // do not use SPEI_RESERVED2 = 33, // do not use SPEI_RESERVED3 = 63 // do not use } SPEVENTENUM; cpp_quote("#define SPFEI_FLAGCHECK ( (1ui64 << SPEI_RESERVED1) | (1ui64 << SPEI_RESERVED2) )") cpp_quote("#define SPFEI_ALL_TTS_EVENTS (0x000000000000FFFEui64 | SPFEI_FLAGCHECK)") cpp_quote("#define SPFEI_ALL_SR_EVENTS (0x001FFFFC00000000ui64 | SPFEI_FLAGCHECK)") cpp_quote("#define SPFEI_ALL_EVENTS 0xEFFFFFFFFFFFFFFFui64") // The SPFEI macro converts an SPEVENTENUM event value into a 64-bit value. // Multiple values can then be OR-ed together and passed to SetInterest. cpp_quote("#define SPFEI(SPEI_ord) ((1ui64 << SPEI_ord) | SPFEI_FLAGCHECK)") // SPEVENT is defined 2 ways, because the current version of MIDL does not allow enumerations // to be used as bit fields. So we define eEventId and elParamType as int bitfields for MIDL // and redefine them as their appropriate enumerations for C++ cpp_quote("#if 0") typedef [restricted, hidden] struct SPEVENT { WORD eEventId; //SPEVENTENUM WORD elParamType; //SPEVENTLPARAMTYPE ULONG ulStreamNum; // Input stream number this event is associated with ULONGLONG ullAudioStreamOffset; WPARAM wParam; LPARAM lParam; } SPEVENT; typedef [restricted, hidden] struct SPSERIALIZEDEVENT { WORD eEventId; //SPEVENTENUM WORD elParamType; //SPEVENTLPARAMTYPE ULONG ulStreamNum; // Input stream number this event is associated with ULONGLONG ullAudioStreamOffset; ULONG SerializedwParam; LONG SerializedlParam; } SPSERIALIZEDEVENT; typedef [restricted, hidden] struct SPSERIALIZEDEVENT64 { WORD eEventId; //SPEVENTENUM WORD elParamType; //SPEVENTLPARAMTYPE ULONG ulStreamNum; // Input stream number this event is associated with ULONGLONG ullAudioStreamOffset; ULONGLONG SerializedwParam; LONGLONG SerializedlParam; } SPSERIALIZEDEVENT64; cpp_quote("#else") cpp_quote("typedef struct SPEVENT") cpp_quote("{") cpp_quote(" SPEVENTENUM eEventId : 16;") cpp_quote(" SPEVENTLPARAMTYPE elParamType : 16;") cpp_quote(" ULONG ulStreamNum;") cpp_quote(" ULONGLONG ullAudioStreamOffset;") cpp_quote(" WPARAM wParam;") cpp_quote(" LPARAM lParam;") cpp_quote("} SPEVENT;") cpp_quote("typedef struct SPSERIALIZEDEVENT") cpp_quote("{") cpp_quote(" SPEVENTENUM eEventId : 16;") cpp_quote(" SPEVENTLPARAMTYPE elParamType : 16;") cpp_quote(" ULONG ulStreamNum;") cpp_quote(" ULONGLONG ullAudioStreamOffset;") cpp_quote(" ULONG SerializedwParam;") cpp_quote(" LONG SerializedlParam;") cpp_quote("} SPSERIALIZEDEVENT;") cpp_quote("typedef struct SPSERIALIZEDEVENT64") cpp_quote("{") cpp_quote(" SPEVENTENUM eEventId : 16;") cpp_quote(" SPEVENTLPARAMTYPE elParamType : 16;") cpp_quote(" ULONG ulStreamNum;") cpp_quote(" ULONGLONG ullAudioStreamOffset;") cpp_quote(" ULONGLONG SerializedwParam;") cpp_quote(" LONGLONG SerializedlParam;") cpp_quote("} SPSERIALIZEDEVENT64;") cpp_quote("#endif") //--- Types of interference typedef [hidden] enum SPINTERFERENCE { SPINTERFERENCE_NONE = 0, SPINTERFERENCE_NOISE, SPINTERFERENCE_NOSIGNAL, SPINTERFERENCE_TOOLOUD, SPINTERFERENCE_TOOQUIET, SPINTERFERENCE_TOOFAST, SPINTERFERENCE_TOOSLOW } SPINTERFERENCE; //--- Flags for END_SR_STREAM event (in WPARAM) typedef [hidden] enum SPENDSRSTREAMFLAGS { SPESF_NONE = 0, SPESF_STREAM_RELEASED = (1 << 0) } SPENDSRSTREAMFLAGS; //--- Viseme features typedef [hidden] enum SPVFEATURE { SPVFEATURE_STRESSED = (1L << 0), SPVFEATURE_EMPHASIS = (1L << 1) } SPVFEATURE; //--- Viseme event groups typedef [hidden] enum SPVISEMES { // English examples //------------------ SP_VISEME_0 = 0, // Silence SP_VISEME_1, // AE, AX, AH SP_VISEME_2, // AA SP_VISEME_3, // AO SP_VISEME_4, // EY, EH, UH SP_VISEME_5, // ER SP_VISEME_6, // y, IY, IH, IX SP_VISEME_7, // w, UW SP_VISEME_8, // OW SP_VISEME_9, // AW SP_VISEME_10, // OY SP_VISEME_11, // AY SP_VISEME_12, // h SP_VISEME_13, // r SP_VISEME_14, // l SP_VISEME_15, // s, z SP_VISEME_16, // SH, CH, JH, ZH SP_VISEME_17, // TH, DH SP_VISEME_18, // f, v SP_VISEME_19, // d, t, n SP_VISEME_20, // k, g, NG SP_VISEME_21, // p, b, m } SPVISEMES; typedef [restricted, hidden] struct SPEVENTSOURCEINFO { ULONGLONG ullEventInterest; ULONGLONG ullQueuedInterest; ULONG ulCount; } SPEVENTSOURCEINFO; [ object, uuid(BE7A9CCE-5F9E-11D2-960F-00C04F8EE628), helpstring("ISpEventSource Interface"), pointer_default(unique), local, restricted ] interface ISpEventSource : ISpNotifySource { // It is neccessary to use the SPFEI macro to convert the // SPEVENTENUM values into ULONGULONG values. HRESULT SetInterest( [in] ULONGLONG ullEventInterest, [in] ULONGLONG ullQueuedInterest); HRESULT GetEvents( [in] ULONG ulCount, [out, size_is(ulCount)] SPEVENT* pEventArray, [out] ULONG *pulFetched); HRESULT GetInfo([out] SPEVENTSOURCEINFO * pInfo); }; //--- ISpEventSink --------------------------------------------------------- [ object, uuid(BE7A9CC9-5F9E-11D2-960F-00C04F8EE628), helpstring("ISpEventSink Interface"), pointer_default(unique), local, restricted ] interface ISpEventSink : IUnknown { HRESULT AddEvents([in] const SPEVENT* pEventArray, [in] ULONG ulCount); HRESULT GetEventInterest([out] ULONGLONG * pullEventInterest); }; //--- ISpStreamFormat ------------------------------------------------------- [ object, uuid(BED530BE-2606-4F4D-A1C0-54C5CDA5566F), helpstring("ISpStreamFormat Interface"), pointer_default(unique), restricted ] interface ISpStreamFormat : IStream { HRESULT GetFormat(GUID * pguidFormatId, WAVEFORMATEX ** ppCoMemWaveFormatEx); } typedef [hidden] enum SPFILEMODE { SPFM_OPEN_READONLY, // Open existing file, read-only SPFM_OPEN_READWRITE, // (Not supported for wav files) Open existing file, read-write SPFM_CREATE, // (Not supported for wav files) Open file if exists, else create if does not exist (opens read-write) SPFM_CREATE_ALWAYS, // Create file even if file exists. Destroys old file. SPFM_NUM_MODES // Used for limit checking } SPFILEMODE; //--- ISpStream ------------------------------------------------------------- [ object, uuid(12E3CCA9-7518-44C5-A5E7-BA5A79CB929E), helpstring("ISpStream Interface"), pointer_default(unique), restricted ] interface ISpStream : ISpStreamFormat { HRESULT SetBaseStream(IStream * pStream, REFGUID rguidFormat, const WAVEFORMATEX * pWaveFormatEx); HRESULT GetBaseStream(IStream ** ppStream); HRESULT BindToFile(const WCHAR * pszFileName, SPFILEMODE eMode, const GUID * pFormatId, const WAVEFORMATEX * pWaveFormatEx, ULONGLONG ullEventInterest); HRESULT Close(); } //--- ISpStreamFormatConverter ---------------------------------------------- [ object, uuid(678A932C-EA71-4446-9B41-78FDA6280A29), helpstring("ISpStreamFormatConverter Interface"), pointer_default(unique), restricted ] interface ISpStreamFormatConverter : ISpStreamFormat { HRESULT SetBaseStream( [in] ISpStreamFormat * pStream, [in] BOOL fSetFormatToBaseStreamFormat, // If true, then format of format converter stream [in] BOOL fWriteToBaseStream ); // will be set to same format as bass stream // (set up as a pass-through). If pStream == NULL // and this is set to TRUE, then format of stream is reset HRESULT GetBaseStream([out] ISpStreamFormat **ppStream); HRESULT SetFormat([in] REFGUID rguidFormatIdOfConvertedStream, [in] const WAVEFORMATEX * pWaveFormatExOfConvertedStream); // Note: GetFormat method of ISpStreamFormat returns the format of the converted stream. HRESULT ResetSeekPosition(); HRESULT ScaleConvertedToBaseOffset( [in] ULONGLONG ullOffsetConvertedStream, [out] ULONGLONG * pullOffsetBaseStream); HRESULT ScaleBaseToConvertedOffset( [in] ULONGLONG ullOffsetBaseStream, [out] ULONGLONG * pullOffsetConvertedStream); }; //--- ISpAudio -------------------------------------------------------------- typedef [hidden] enum _SPAUDIOSTATE { SPAS_CLOSED, SPAS_STOP, SPAS_PAUSE, SPAS_RUN } SPAUDIOSTATE; typedef [restricted, hidden] struct SPAUDIOSTATUS { long cbFreeBuffSpace; ULONG cbNonBlockingIO; SPAUDIOSTATE State; ULONGLONG CurSeekPos; ULONGLONG CurDevicePos; DWORD dwReserved1; DWORD dwReserved2; } SPAUDIOSTATUS; typedef [restricted, hidden] struct SPAUDIOBUFFERINFO { ULONG ulMsMinNotification; ULONG ulMsBufferSize; ULONG ulMsEventBias; } SPAUDIOBUFFERINFO; [ object, uuid(C05C768F-FAE8-4EC2-8E07-338321C12452), helpstring("ISpAudio Interface"), pointer_default(unique), local, restricted ] interface ISpAudio : ISpStreamFormat { HRESULT SetState([in] SPAUDIOSTATE NewState, [in]ULONGLONG ullReserved ); HRESULT SetFormat([in] REFGUID rguidFmtId, [in] const WAVEFORMATEX * pWaveFormatEx); HRESULT GetStatus([out] SPAUDIOSTATUS * pStatus); HRESULT SetBufferInfo([in] const SPAUDIOBUFFERINFO * pBuffInfo); HRESULT GetBufferInfo([out] SPAUDIOBUFFERINFO * pBuffInfo); HRESULT GetDefaultFormat([out] GUID * pFormatId, [out] WAVEFORMATEX ** ppCoMemWaveFormatEx); HANDLE EventHandle(); HRESULT GetVolumeLevel([out] ULONG *pLevel); HRESULT SetVolumeLevel([in] ULONG Level); HRESULT GetBufferNotifySize([out] ULONG *pcbSize); HRESULT SetBufferNotifySize([in] ULONG cbSize); }; //--- ISpMMSysAudio --------------------------------------------------------- [ object, uuid(15806F6E-1D70-4B48-98E6-3B1A007509AB), helpstring("ISpMMSysAudio Interface"), pointer_default(unique), local, restricted ] interface ISpMMSysAudio : ISpAudio { HRESULT GetDeviceId([out] UINT * puDeviceId); HRESULT SetDeviceId([in] UINT uDeviceId); HRESULT GetMMHandle(void ** pHandle); HRESULT GetLineId([out] UINT *puLineId); HRESULT SetLineId([in] UINT uLineId); }; //--- ISpTranscript --------------------------------------------------------- [ object, uuid(10F63BCE-201A-11D3-AC70-00C04F8EE6C0), helpstring("ISpTranscript Interface"), pointer_default(unique), restricted ] interface ISpTranscript : IUnknown { HRESULT GetTranscript([out, string] WCHAR ** ppszTranscript); HRESULT AppendTranscript([in, string] const WCHAR * pszTranscript); }; //--- Structures used by ISpPhrase interface -------------------------------- typedef [hidden] enum SPDISPLYATTRIBUTES { SPAF_ONE_TRAILING_SPACE = 0x02, SPAF_TWO_TRAILING_SPACES = 0x04, SPAF_CONSUME_LEADING_SPACES = 0x08, SPAF_ALL = 0x0F } SPDISPLAYATTRIBUTES; typedef unsigned short SPPHONEID; typedef [restricted, hidden] struct SPPHRASEELEMENT { ULONG ulAudioTimeOffset; ULONG ulAudioSizeTime; // In 100ns units ULONG ulAudioStreamOffset; ULONG ulAudioSizeBytes; ULONG ulRetainedStreamOffset; ULONG ulRetainedSizeBytes; const WCHAR * pszDisplayText; const WCHAR * pszLexicalForm; const SPPHONEID * pszPronunciation; BYTE bDisplayAttributes; signed char RequiredConfidence; signed char ActualConfidence; BYTE Reserved; float SREngineConfidence; } SPPHRASEELEMENT; typedef [restricted, hidden] struct SPPHRASERULE SPPHRASERULE; [hidden] struct SPPHRASERULE { const WCHAR * pszName; ULONG ulId; ULONG ulFirstElement; ULONG ulCountOfElements; const SPPHRASERULE * pNextSibling; const SPPHRASERULE * pFirstChild; float SREngineConfidence; signed char Confidence; }; typedef [restricted, hidden] struct SPPHRASEPROPERTY SPPHRASEPROPERTY; [hidden] struct SPPHRASEPROPERTY { const WCHAR * pszName; ULONG ulId; const WCHAR * pszValue; VARIANT vValue; // Will be VT_BOOL, VT_I4, VT_R4, VT_R8, or VT_BYREF (only for dynamic grammars) ULONG ulFirstElement; ULONG ulCountOfElements; const SPPHRASEPROPERTY* pNextSibling; const SPPHRASEPROPERTY* pFirstChild; float SREngineConfidence; signed char Confidence; }; typedef [restricted, hidden] struct SPPHRASEREPLACEMENT { BYTE bDisplayAttributes; const WCHAR * pszReplacementText; ULONG ulFirstElement; ULONG ulCountOfElements; } SPPHRASEREPLACEMENT; typedef [restricted, hidden] struct SPPHRASE { ULONG cbSize; // Size of structure LANGID LangID; WORD wReserved; ULONGLONG ullGrammarID; ULONGLONG ftStartTime; ULONGLONG ullAudioStreamPosition; ULONG ulAudioSizeBytes; ULONG ulRetainedSizeBytes; ULONG ulAudioSizeTime; // In 100ns units SPPHRASERULE Rule; const SPPHRASEPROPERTY* pProperties; const SPPHRASEELEMENT * pElements; ULONG cReplacements; const SPPHRASEREPLACEMENT * pReplacements; GUID SREngineID; ULONG ulSREnginePrivateDataSize; const BYTE * pSREnginePrivateData; } SPPHRASE; //--- Serialized phrase typedef [restricted, hidden] struct SPSERIALIZEDPHRASE { ULONG ulSerializedSize; // Size of structure in bytes } SPSERIALIZEDPHRASE; typedef [hidden] enum SPVALUETYPE { SPDF_PROPERTY = 0x00000001, SPDF_REPLACEMENT = 0x00000002, SPDF_RULE = 0x00000004, SPDF_DISPLAYTEXT = 0x00000008, SPDF_LEXICALFORM = 0x00000010, SPDF_PRONUNCIATION = 0x00000020, SPDF_AUDIO = 0x00000040, SPDF_ALTERNATES = 0x00000080, SPDF_ALL = 0x000000FF } SPVALUETYPE; // Binary grammar public declaration typedef [hidden] struct SPBINARYGRAMMAR { ULONG ulTotalSerializedSize; } SPBINARYGRAMMAR; // Possible arguments for methods that take phrase element start and count typedef [hidden] enum SPPHRASERNG { SPPR_ALL_ELEMENTS = -1 } SPPHRASERNG; cpp_quote("#define SP_GETWHOLEPHRASE SPPR_ALL_ELEMENTS") cpp_quote("#define SPRR_ALL_ELEMENTS SPPR_ALL_ELEMENTS") cpp_quote("#if 0") typedef void * SPSTATEHANDLE; cpp_quote("#else") cpp_quote("DECLARE_HANDLE(SPSTATEHANDLE);") cpp_quote("#endif") typedef [hidden] enum SPRECOEVENTFLAGS { SPREF_AutoPause = (1 << 0), SPREF_Emulated = (1 << 1) } SPRECOEVENTFLAGS; //--- ISpLexicon ------------------------------------------------------------ typedef [hidden] enum SPPARTOFSPEECH { //--- SAPI5 public POS category values (bits 28-31) SPPS_NotOverriden = -1, SPPS_Unknown = 0, SPPS_Noun = 0x1000, SPPS_Verb = 0x2000, SPPS_Modifier = 0x3000, SPPS_Function = 0x4000, SPPS_Interjection = 0x5000 } SPPARTOFSPEECH; typedef [hidden] enum SPLEXICONTYPE { eLEXTYPE_USER = (1L << 0), eLEXTYPE_APP = (1L << 1), eLEXTYPE_RESERVED1 = (1L << 2), eLEXTYPE_RESERVED2 = (1L << 3), eLEXTYPE_RESERVED3 = (1L << 4), eLEXTYPE_RESERVED4 = (1L << 5), eLEXTYPE_RESERVED5 = (1L << 6), eLEXTYPE_RESERVED6 = (1L << 7), eLEXTYPE_RESERVED7 = (1L << 8), eLEXTYPE_RESERVED8 = (1L << 9), eLEXTYPE_RESERVED9 = (1L << 10), eLEXTYPE_RESERVED10 = (1L << 11), eLEXTYPE_PRIVATE1 = (1L << 12), eLEXTYPE_PRIVATE2 = (1L << 13), eLEXTYPE_PRIVATE3 = (1L << 14), eLEXTYPE_PRIVATE4 = (1L << 15), eLEXTYPE_PRIVATE5 = (1L << 16), eLEXTYPE_PRIVATE6 = (1L << 17), eLEXTYPE_PRIVATE7 = (1L << 18), eLEXTYPE_PRIVATE8 = (1L << 19), eLEXTYPE_PRIVATE9 = (1L << 20), eLEXTYPE_PRIVATE10 = (1L << 21), eLEXTYPE_PRIVATE11 = (1L << 22), eLEXTYPE_PRIVATE12 = (1L << 23), eLEXTYPE_PRIVATE13 = (1L << 24), eLEXTYPE_PRIVATE14 = (1L << 25), eLEXTYPE_PRIVATE15 = (1L << 26), eLEXTYPE_PRIVATE16 = (1L << 27), eLEXTYPE_PRIVATE17 = (1L << 28), eLEXTYPE_PRIVATE18 = (1L << 29), eLEXTYPE_PRIVATE19 = (1L << 30), eLEXTYPE_PRIVATE20 = (1L << 31), } SPLEXICONTYPE; typedef [hidden] enum SPWORDTYPE { eWORDTYPE_ADDED = (1L << 0), eWORDTYPE_DELETED = (1L << 1) } SPWORDTYPE; typedef [restricted, hidden] struct SPWORDPRONUNCIATION { struct SPWORDPRONUNCIATION * pNextWordPronunciation; SPLEXICONTYPE eLexiconType; LANGID LangID; WORD wReserved; SPPARTOFSPEECH ePartOfSpeech; SPPHONEID szPronunciation[1]; } SPWORDPRONUNCIATION; typedef [restricted, hidden] struct SPWORDPRONUNCIATIONLIST { ULONG ulSize; BYTE * pvBuffer; SPWORDPRONUNCIATION * pFirstWordPronunciation; } SPWORDPRONUNCIATIONLIST; typedef [restricted, hidden] struct SPWORD { struct SPWORD * pNextWord; LANGID LangID; WORD wReserved; SPWORDTYPE eWordType; WCHAR * pszWord; SPWORDPRONUNCIATION * pFirstWordPronunciation; } SPWORD; typedef [restricted, hidden] struct SPWORDLIST { ULONG ulSize; BYTE * pvBuffer; SPWORD * pFirstWord; } SPWORDLIST; [ object, uuid(DA41A7C2-5383-4DB2-916B-6C1719E3DB58), helpstring("ISpLexicon Interface"), pointer_default(unique), restricted ] interface ISpLexicon : IUnknown { HRESULT GetPronunciations( [in] const WCHAR * pszWord, [in] LANGID LangID, [in] DWORD dwFlags, [in, out] SPWORDPRONUNCIATIONLIST * pWordPronunciationList ); HRESULT AddPronunciation( [in] const WCHAR * pszWord, [in] LANGID LangID, [in] SPPARTOFSPEECH ePartOfSpeech, [in] const SPPHONEID * pszPronunciation ); HRESULT RemovePronunciation( [in] const WCHAR * pszWord, [in] LANGID LangID, [in] SPPARTOFSPEECH ePartOfSpeech, [in] const SPPHONEID * pszPronunciation ); HRESULT GetGeneration(DWORD *pdwGeneration); HRESULT GetGenerationChange( [in] DWORD dwFlags, [in, out] DWORD *pdwGeneration, [in, out] SPWORDLIST * pWordList ); HRESULT GetWords( [in] DWORD dwFlags, [in, out] DWORD *pdwGeneration, [in, out] DWORD * pdwCookie, [in, out] SPWORDLIST *pWordList ); }; [ object, uuid(8565572F-C094-41CC-B56E-10BD9C3FF044), helpstring("ISpContainerLexicon Interface"), pointer_default(unique), restricted ] interface ISpContainerLexicon : ISpLexicon { HRESULT AddLexicon([in] ISpLexicon *pAddLexicon, [in] DWORD dwFlags); }; //--- ISpPhoneConverter ----------------------------------------------------- [ object, uuid(8445C581-0CAC-4A38-ABFE-9B2CE2826455), helpstring("ISpPhoneConverter Interface"), pointer_default(unique), restricted ] interface ISpPhoneConverter : ISpObjectWithToken { HRESULT PhoneToId([in] const WCHAR * pszPhone, [out] SPPHONEID * pId); HRESULT IdToPhone([in] const SPPHONEID * pId, [out] WCHAR * pszPhone); }; //--- ISpVoice -------------------------------------------------------------- // These structures maintain the absolute state of the voice relative to // the voice's baseline XML state. typedef [restricted, hidden] struct SPVPITCH { long MiddleAdj; long RangeAdj; } SPVPITCH; typedef [hidden] enum SPVACTIONS { SPVA_Speak = 0, SPVA_Silence, SPVA_Pronounce, SPVA_Bookmark, SPVA_SpellOut, SPVA_Section, SPVA_ParseUnknownTag } SPVACTIONS; typedef [restricted, hidden] struct SPVCONTEXT { LPCWSTR pCategory; LPCWSTR pBefore; LPCWSTR pAfter; } SPVCONTEXT; typedef [restricted, hidden] struct SPVSTATE { //--- Action SPVACTIONS eAction; //--- Running state values LANGID LangID; WORD wReserved; long EmphAdj; long RateAdj; ULONG Volume; SPVPITCH PitchAdj; ULONG SilenceMSecs; SPPHONEID* pPhoneIds; // NULL terminated array of phone ids SPPARTOFSPEECH ePartOfSpeech; SPVCONTEXT Context; } SPVSTATE; typedef [hidden] enum SPRUNSTATE { SPRS_DONE = (1L << 0), // The voice is done rendering all queued phrases SPRS_IS_SPEAKING = (1L << 1) // The SpVoice currently has the audio queue claimed } SPRUNSTATE; typedef [hidden] enum SPVLIMITS { SPMIN_VOLUME = 0, SPMAX_VOLUME = 100, SPMIN_RATE = -10, SPMAX_RATE = 10 } SPVLIMITS; typedef [hidden] enum SPVPRIORITY { SPVPRI_NORMAL = 0, SPVPRI_ALERT = (1L << 0), SPVPRI_OVER = (1L << 1) } SPVPRIORITY; typedef [restricted, hidden] struct SPVOICESTATUS { ULONG ulCurrentStream; // Current stream being rendered ULONG ulLastStreamQueued; // Number of the last stream queued HRESULT hrLastResult; // Result of last speak DWORD dwRunningState; // SPRUNSTATE ULONG ulInputWordPos; // Input position of current word being rendered ULONG ulInputWordLen; // Length of current word being rendered ULONG ulInputSentPos; // Input position of current sentence being rendered ULONG ulInputSentLen; // Length of current sentence being rendered LONG lBookmarkId; // Current bookmark converted to a long integer SPPHONEID PhonemeId; // Current phoneme id SPVISEMES VisemeId; // Current viseme DWORD dwReserved1; // Reserved for future expansion DWORD dwReserved2; // Reserved for future expansion } SPVOICESTATUS; typedef [hidden] enum SPEAKFLAGS { //--- SpVoice flags SPF_DEFAULT = 0, // Synchronous, no purge, xml auto detect SPF_ASYNC = (1L << 0), // Asynchronous call SPF_PURGEBEFORESPEAK = (1L << 1), // Purge current data prior to speaking this SPF_IS_FILENAME = (1L << 2), // The string passed to Speak() is a file name SPF_IS_XML = (1L << 3), // The input text will be parsed for XML markup SPF_IS_NOT_XML = (1L << 4), // The input text will not be parsed for XML markup SPF_PERSIST_XML = (1L << 5), // Persists XML global state changes //--- Normalizer flags SPF_NLP_SPEAK_PUNC = (1L << 6), // The normalization processor should speak the punctuation //--- Masks SPF_NLP_MASK = (SPF_NLP_SPEAK_PUNC), SPF_VOICE_MASK = (SPF_ASYNC|SPF_PURGEBEFORESPEAK|SPF_IS_FILENAME|SPF_IS_XML|SPF_IS_NOT_XML|SPF_NLP_MASK|SPF_PERSIST_XML), SPF_UNUSED_FLAGS = ~(SPF_VOICE_MASK) } SPEAKFLAGS; [ object, uuid(6C44DF74-72B9-4992-A1EC-EF996E0422D4), helpstring("ISpVoice Interface"), pointer_default(unique), restricted ] interface ISpVoice : ISpEventSource { HRESULT SetOutput( [in] IUnknown * pUnkOutput, [in]BOOL fAllowFormatChanges ); HRESULT GetOutputObjectToken( [out] ISpObjectToken ** ppObjectToken ); HRESULT GetOutputStream( [out] ISpStreamFormat ** ppStream ); HRESULT Pause( void ); HRESULT Resume( void ); HRESULT SetVoice([in] ISpObjectToken *pToken); HRESULT GetVoice([out] ISpObjectToken **ppToken); HRESULT Speak( [in, string] const WCHAR* pwcs, [in] DWORD dwFlags, [out] ULONG * pulStreamNumber); HRESULT SpeakStream( [in] IStream* pStream, // If not ISpStreamFormat supported then SPDFID_Text assumed [in] DWORD dwFlags, [out] ULONG * pulStreamNumber); HRESULT GetStatus( [out] SPVOICESTATUS *pStatus, [out, string] WCHAR ** ppszLastBookmark); HRESULT Skip( [in,string]WCHAR* pItemType, [in]long lNumItems, [out]ULONG* pulNumSkipped ); HRESULT SetPriority([in] SPVPRIORITY ePriority ); HRESULT GetPriority([out] SPVPRIORITY* pePriority ); HRESULT SetAlertBoundary( [in] SPEVENTENUM eBoundary ); HRESULT GetAlertBoundary( [out] SPEVENTENUM* peBoundary ); HRESULT SetRate([in] long RateAdjust ); HRESULT GetRate([out] long* pRateAdjust); HRESULT SetVolume([in] USHORT usVolume); HRESULT GetVolume([out] USHORT* pusVolume); HRESULT WaitUntilDone([in] ULONG msTimeout); HRESULT SetSyncSpeakTimeout([in] ULONG msTimeout); HRESULT GetSyncSpeakTimeout([out] ULONG * pmsTimeout); [local] HANDLE SpeakCompleteEvent(); [local] HRESULT IsUISupported( [in] const WCHAR * pszTypeOfUI, [in] void * pvExtraData, [in] ULONG cbExtraData, [out] BOOL *pfSupported); [local] HRESULT DisplayUI( [in] HWND hwndParent, [in] const WCHAR * pszTitle, [in] const WCHAR * pszTypeOfUI, [in] void * pvExtraData, [in] ULONG cbExtraData); }; //--- ISpPhrase interface --------------------------------------------------- [ object, uuid(1A5C0354-B621-4b5a-8791-D306ED379E53), local, helpstring("ISpPhrase Interface"), pointer_default(unique), restricted ] interface ISpPhrase : IUnknown { HRESULT GetPhrase([out] SPPHRASE ** ppCoMemPhrase); HRESULT GetSerializedPhrase([out] SPSERIALIZEDPHRASE ** ppCoMemPhrase); HRESULT GetText([in] ULONG ulStart, [in] ULONG ulCount, [in] BOOL fUseTextReplacements, [out] WCHAR ** ppszCoMemText, [out] BYTE * pbDisplayAttributes); HRESULT Discard([in] DWORD dwValueTypes); }; [ object, uuid(8FCEBC98-4E49-4067-9C6C-D86A0E092E3D), local, helpstring("ISpPhraseAlt Interface"), pointer_default(unique), restricted ] interface ISpPhraseAlt : ISpPhrase { HRESULT GetAltInfo(ISpPhrase **ppParent, ULONG *pulStartElementInParent, ULONG *pcElementsInParent, ULONG *pcElementsInAlt); HRESULT Commit(); }; //--- ISpRecoResult --------------------------------------------------------- typedef [restricted, hidden] struct SPRECORESULTTIMES { FILETIME ftStreamTime; // GetSystemTimeAsFileTime() at start of result // UTC time as number of 100-nanosecond intervals // since January 1, 1601 ULONGLONG ullLength; // length in 100ns units DWORD dwTickCount; // GetTickCount() at start of result // milliseconds that have elapsed since the // system was started. ULONGLONG ullStart; // 100ns units since start of stream } SPRECORESULTTIMES; typedef [hidden] struct SPSERIALIZEDRESULT { ULONG ulSerializedSize; // Count in bytes (including this ULONG) of the entire phrase } SPSERIALIZEDRESULT; [ object, uuid(20B053BE-E235-43cd-9A2A-8D17A48B7842), helpstring("ISpRecoResult Interface"), pointer_default(unique), local, restricted ] interface ISpRecoResult : ISpPhrase { HRESULT GetResultTimes([out] SPRECORESULTTIMES *pTimes); HRESULT GetAlternates( [in] ULONG ulStartElement, [in] ULONG cElements, [in] ULONG ulRequestCount, [out] ISpPhraseAlt **ppPhrases, [out] ULONG *pcPhrasesReturned); HRESULT GetAudio( [in] ULONG ulStartElement, [in] ULONG cElements, [out] ISpStreamFormat **ppStream); HRESULT SpeakAudio( [in] ULONG ulStartElement, [in] ULONG cElements, [in] DWORD dwFlags, [out] ULONG * pulStreamNumber); HRESULT Serialize([out] SPSERIALIZEDRESULT ** ppCoMemSerializedResult); HRESULT ScaleAudio([in] const GUID * pAudioFormatId, [in] const WAVEFORMATEX *pWaveFormatEx); HRESULT GetRecoContext([out] ISpRecoContext ** ppRecoContext); }; typedef [hidden] struct tagSPTEXTSELECTIONINFO { ULONG ulStartActiveOffset; ULONG cchActiveChars; ULONG ulStartSelection; ULONG cchSelection; } SPTEXTSELECTIONINFO; typedef [hidden] enum SPWORDPRONOUNCEABLE { SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE = 0, SPWP_UNKNOWN_WORD_PRONOUNCEABLE = 1, SPWP_KNOWN_WORD_PRONOUNCEABLE = 2 } SPWORDPRONOUNCEABLE; typedef [hidden] enum SPGRAMMARSTATE { SPGS_DISABLED = 0, SPGS_ENABLED = 1, SPGS_EXCLUSIVE = 3 } SPGRAMMARSTATE; typedef [hidden] enum SPCONTEXTSTATE { SPCS_DISABLED = 0, SPCS_ENABLED = 1, } SPCONTEXTSTATE; typedef [hidden] enum SPRULESTATE { SPRS_INACTIVE = 0, SPRS_ACTIVE = 1, SPRS_ACTIVE_WITH_AUTO_PAUSE = 3 } SPRULESTATE; const ULONGLONG SP_STREAMPOS_ASAP = 0; const ULONGLONG SP_STREAMPOS_REALTIME = -1; // Special transition types used only by AddRuleTransition cpp_quote("#define SPRULETRANS_TEXTBUFFER (SPSTATEHANDLE)(-1)") cpp_quote("#define SPRULETRANS_WILDCARD (SPSTATEHANDLE)(-2)") cpp_quote("#define SPRULETRANS_DICTATION (SPSTATEHANDLE)(-3)") typedef [hidden] enum SPGRAMMARWORDTYPE { SPWT_DISPLAY, SPWT_LEXICAL, SPWT_PRONUNCIATION } SPGRAMMARWORDTYPE; typedef [hidden] struct tagSPPROPERTYINFO { const WCHAR * pszName; ULONG ulId; const WCHAR * pszValue; VARIANT vValue; // Must be VT_BOOL, VT_I4, VT_R4, VT_R8, or VT_BYREF (only for dynamic grammars) } SPPROPERTYINFO; typedef [hidden] enum SPCFGRULEATTRIBUTES { SPRAF_TopLevel = (1 << 0), SPRAF_Active = (1 << 1), SPRAF_Export = (1 << 2), SPRAF_Import = (1 << 3), SPRAF_Interpreter = (1 << 4), SPRAF_Dynamic = (1 << 5), // The following flag is only valid at run-time as part of a rule state and // is not valid to pass as part of a rule definition. SPRAF_AutoPause = (1 << 16) } SPCFGRULEATTRIBUTES; [ object, uuid(8137828F-591A-4A42-BE58-49EA7EBAAC68), helpstring("ISpGrammarBuilder Interface"), pointer_default(unique), restricted, local ] interface ISpGrammarBuilder : IUnknown { HRESULT ResetGrammar([in] LANGID NewLanguage); HRESULT GetRule([in] const WCHAR * pszRuleName, [in] DWORD dwRuleId, [in] DWORD dwAttributes, [in] BOOL fCreateIfNotExist, [out] SPSTATEHANDLE * phInitialState); HRESULT ClearRule(SPSTATEHANDLE hState); HRESULT CreateNewState( SPSTATEHANDLE hState, SPSTATEHANDLE * phState); HRESULT AddWordTransition( SPSTATEHANDLE hFromState, SPSTATEHANDLE hToState, const WCHAR * psz, // If NULL then epsilon const WCHAR * pszSeparators, // If NULL then psz points to a single word, else specifies valid separator characters SPGRAMMARWORDTYPE eWordType, float Weight, const SPPROPERTYINFO * pPropInfo); HRESULT AddRuleTransition( SPSTATEHANDLE hFromState, SPSTATEHANDLE hToState, SPSTATEHANDLE hRule, // Must be the initial state of the rule float Weight, const SPPROPERTYINFO * pPropInfo); HRESULT AddResource([in] SPSTATEHANDLE hRuleState, // Any state handle in a rule is OK [in] const WCHAR * pszResourceName, [in] const WCHAR * pszResourceValue); HRESULT Commit(DWORD dwReserved); }; // --- Options for Load methods on ISpRecoGrammar typedef [hidden] enum SPLOADOPTIONS { SPLO_STATIC = 0, SPLO_DYNAMIC = 1 } SPLOADOPTIONS; //--- ISpRecoGrammar ------------------------------------------------------- [ object, uuid(2177DB29-7F45-47D0-8554-067E91C80502), helpstring("ISpRecoGrammar Interface"), pointer_default(unique), restricted, local ] interface ISpRecoGrammar : ISpGrammarBuilder { HRESULT GetGrammarId([out] ULONGLONG * pullGrammarId); HRESULT GetRecoContext([out] ISpRecoContext **ppRecoCtxt); // Command and control interfaces HRESULT LoadCmdFromFile([in, string] const WCHAR * pszFileName, [in] SPLOADOPTIONS Options); HRESULT LoadCmdFromObject([in] REFCLSID rcid, [in, string] const WCHAR * pszGrammarName, [in] SPLOADOPTIONS Options); HRESULT LoadCmdFromResource([in] HMODULE hModule, [in, string] const WCHAR * pszResourceName, [in, string] const WCHAR * pszResourceType, [in] WORD wLanguage, [in] SPLOADOPTIONS Options); HRESULT LoadCmdFromMemory([in] const SPBINARYGRAMMAR * pGrammar, [in] SPLOADOPTIONS Options); HRESULT LoadCmdFromProprietaryGrammar( [in] REFGUID rguidParam, [in, string] const WCHAR * pszStringParam, [in] const void * pvDataPrarm, [in] ULONG cbDataSize, [in] SPLOADOPTIONS Options); HRESULT SetRuleState([in, string] const WCHAR * pszName, void * pReserved, [in] SPRULESTATE NewState); HRESULT SetRuleIdState([in] ULONG ulRuleId, [in] SPRULESTATE NewState); // Dictation / statistical language model HRESULT LoadDictation([in, string] const WCHAR * pszTopicName, [in] SPLOADOPTIONS Options); HRESULT UnloadDictation(); HRESULT SetDictationState([in] SPRULESTATE NewState); // Word sequence buffer HRESULT SetWordSequenceData([in] const WCHAR * pText, [in] ULONG cchText, [in] const SPTEXTSELECTIONINFO * pInfo); HRESULT SetTextSelection([in] const SPTEXTSELECTIONINFO * pInfo); HRESULT IsPronounceable([in, string] const WCHAR * pszWord, [out] SPWORDPRONOUNCEABLE *pWordPronounceable); HRESULT SetGrammarState([in] SPGRAMMARSTATE eGrammarState); HRESULT SaveCmd([in] IStream * pStream, [out, optional] WCHAR ** ppszCoMemErrorText); HRESULT GetGrammarState([out] SPGRAMMARSTATE * peGrammarState); }; //--- ISpRecoContext -------------------------------------------------------- typedef [restricted, hidden] struct SPRECOCONTEXTSTATUS { SPINTERFERENCE eInterference; WCHAR szRequestTypeOfUI[255]; // If first byte null, there is no UI request DWORD dwReserved1; DWORD dwReserved2; } SPRECOCONTEXTSTATUS; typedef [hidden] enum SPBOOKMARKOPTIONS { SPBO_NONE = 0, SPBO_PAUSE = 1 } SPBOOKMARKOPTIONS; typedef [hidden] enum SPAUDIOOPTIONS { SPAO_NONE = 0, SPAO_RETAIN_AUDIO = (1 << 0) } SPAUDIOOPTIONS; [ object, uuid(F740A62F-7C15-489E-8234-940A33D9272D), helpstring("ISpRecoContext Interface"), pointer_default(unique), local, restricted ] interface ISpRecoContext : ISpEventSource { HRESULT GetRecognizer([out] ISpRecognizer ** ppRecognizer); HRESULT CreateGrammar([in] ULONGLONG ullGrammarId, [out] ISpRecoGrammar ** ppGrammar); HRESULT GetStatus([out] SPRECOCONTEXTSTATUS *pStatus); HRESULT GetMaxAlternates([in] ULONG * pcAlternates); HRESULT SetMaxAlternates([in] ULONG cAlternates); HRESULT SetAudioOptions([in] SPAUDIOOPTIONS Options, [in] const GUID *pAudioFormatId, [in] const WAVEFORMATEX *pWaveFormatEx); HRESULT GetAudioOptions([in] SPAUDIOOPTIONS * pOptions, [out] GUID *pAudioFormatId, [out] WAVEFORMATEX **ppCoMemWFEX); HRESULT DeserializeResult( [in] const SPSERIALIZEDRESULT * pSerializedResult, [out] ISpRecoResult **ppResult); HRESULT Bookmark([in] SPBOOKMARKOPTIONS Options, [in] ULONGLONG ullStreamPosition, [in] LPARAM lparamEvent); HRESULT SetAdaptationData([in, string] const WCHAR *pAdaptationData, [in] const ULONG cch); HRESULT Pause( DWORD dwReserved ); HRESULT Resume( DWORD dwReserved ); HRESULT SetVoice([in] ISpVoice *pVoice, [in] BOOL fAllowFormatChanges); HRESULT GetVoice([out] ISpVoice **ppVoice); HRESULT SetVoicePurgeEvent([in] ULONGLONG ullEventInterest); HRESULT GetVoicePurgeEvent([out] ULONGLONG *pullEventInterest); HRESULT SetContextState([in] SPCONTEXTSTATE eContextState); HRESULT GetContextState([in] SPCONTEXTSTATE * peContextState); }; //--- ISpProperties ------------------------------------------------------------ [ object, uuid(5B4FB971-B115-4DE1-AD97-E482E3BF6EE4), helpstring("ISpProperties Interface"), pointer_default(unique), local, restricted ] interface ISpProperties : IUnknown { HRESULT SetPropertyNum( [in]const WCHAR* pName, [in]LONG lValue ); HRESULT GetPropertyNum( [in]const WCHAR* pName, [out]LONG* plValue ); HRESULT SetPropertyString( [in]const WCHAR* pName, [in]const WCHAR* pValue ); HRESULT GetPropertyString( [in]const WCHAR* pName, [out]WCHAR** ppCoMemValue ); }; const ULONG SP_MAX_LANGIDS = 20; // Engine can support up to 20 languages at once //--- ISpRecognizer --------------------------------------------------------- typedef [restricted, hidden] struct SPRECOGNIZERSTATUS { SPAUDIOSTATUS AudioStatus; ULONGLONG ullRecognitionStreamPos; ULONG ulStreamNumber; ULONG ulNumActive; CLSID clsidEngine; ULONG cLangIDs; LANGID aLangID[SP_MAX_LANGIDS]; DWORD dwReserved1; DWORD dwReserved2; } SPRECOGNIZERSTATUS; typedef [hidden] enum SPWAVEFORMATTYPE { SPWF_INPUT, // WAVEFORMATEX of audio input source SPWF_SRENGINE // WAVEFORMATEX of the audio received by the SR engine } SPSTREAMFORMATTYPE; typedef [hidden] enum SPRECOSTATE { SPRST_INACTIVE, // Audio deactivated SPRST_ACTIVE, // Audio running only if one or more rules are active SPRST_ACTIVE_ALWAYS, // Audio running regardless of rule state SPRST_INACTIVE_WITH_PURGE, // State will be set to inactive, but all active audio purged SPRST_NUM_STATES } SPRECOSTATE; [ object, uuid(C2B5F241-DAA0-4507-9E16-5A1EAA2B7A5C), helpstring("ISpRecognizer Interface"), pointer_default(unique), restricted ] interface ISpRecognizer : ISpProperties { HRESULT SetRecognizer([in] ISpObjectToken * pRecognizer); HRESULT GetRecognizer([out] ISpObjectToken **ppRecognizer); HRESULT SetInput([in] IUnknown * pUnkInput, [in] BOOL fAllowFormatChanges); HRESULT GetInputObjectToken( [out] ISpObjectToken ** ppToken); HRESULT GetInputStream( [out] ISpStreamFormat ** ppStream); HRESULT CreateRecoContext([out] ISpRecoContext ** ppNewCtxt); HRESULT GetRecoProfile([out] ISpObjectToken **ppToken); HRESULT SetRecoProfile([in] ISpObjectToken *pToken); HRESULT IsSharedInstance(void); HRESULT GetRecoState([out] SPRECOSTATE *pState); HRESULT SetRecoState([in] SPRECOSTATE NewState); HRESULT GetStatus([out] SPRECOGNIZERSTATUS * pStatus); HRESULT GetFormat([in] SPSTREAMFORMATTYPE WaveFormatType, [out] GUID *pFormatId, [out] WAVEFORMATEX **ppCoMemWFEX); [local] HRESULT IsUISupported( [in] const WCHAR * pszTypeOfUI, [in] void * pvExtraData, [in] ULONG cbExtraData, [out] BOOL *pfSupported); [local] HRESULT DisplayUI( [in] HWND hwndParent, [in] const WCHAR * pszTitle, [in] const WCHAR * pszTypeOfUI, [in] void * pvExtraData, [in] ULONG cbExtraData); HRESULT EmulateRecognition([in] ISpPhrase *pPhrase); }; // //=== CoClass definitions ===================================================== // [ helpstring("Microsoft Speech Object Library"), uuid(C866CA3A-32F7-11D2-9602-00C04F8EE628), version(5.1) ] library SpeechLib { importlib("stdole32.tlb"); importlib("stdole2.tlb"); #include "sapiaut.idl" //--- SpNotifyTranslator ------------------------------------------------ [ uuid(E2AE5372-5D40-11D2-960E-00C04F8EE628), helpstring("SpNotify"), restricted, hidden ] coclass SpNotifyTranslator { interface ISpNotifyTranslator; } //--- SpObjectTokenCategory --------------------------------------------- [ uuid(A910187F-0C7A-45AC-92CC-59EDAFB77B53), helpstring("SpObjectTokenCategory Class"), ] coclass SpObjectTokenCategory { [default] interface ISpeechObjectTokenCategory; interface ISpObjectTokenCategory; } //--- SpObjectToken --------------------------------------------- [ uuid(EF411752-3736-4CB4-9C8C-8EF4CCB58EFE), helpstring("SpObjectToken Class") ] coclass SpObjectToken { [default] interface ISpeechObjectToken; interface ISpObjectToken; } //--- SpResourceManager ------------------------------------------------- [ uuid(96749373-3391-11D2-9EE3-00C04F797396), helpstring("SpResourceManger"), restricted, hidden ] coclass SpResourceManager { [default] interface ISpResourceManager; }; //--- SpStreamFormatConverter ------------------------------------------- [ uuid(7013943A-E2EC-11D2-A086-00C04F8EF9B5), helpstring("FormatConverter Class"), restricted, hidden ] coclass SpStreamFormatConverter { [default] interface ISpStreamFormatConverter; }; //--- SpMMAudioEnum ----------------------------------------------------- [ uuid(AB1890A0-E91F-11D2-BB91-00C04F8EE6C0), helpstring("SpMMAudioEnum Class"), restricted, hidden ] coclass SpMMAudioEnum { interface IEnumSpObjectTokens; }; //--- SpMMAudioIn ------------------------------------------------------- [ uuid(CF3D2E50-53F2-11D2-960C-00C04F8EE628), helpstring("SpMMAudioIn Class") ] coclass SpMMAudioIn { [default] interface ISpeechMMSysAudio; interface ISpEventSource; interface ISpEventSink; interface ISpObjectWithToken; interface ISpMMSysAudio; }; //--- SpMMAudioOut ------------------------------------------------------ [ uuid(A8C680EB-3D32-11D2-9EE7-00C04F797396), helpstring("SpMMAudioOut Class") ] coclass SpMMAudioOut { [default] interface ISpeechMMSysAudio; interface ISpEventSource; interface ISpEventSink; interface ISpObjectWithToken; interface ISpMMSysAudio; }; //--- SpRecPlayAudio ------------------------------------------------- [ uuid(FEE225FC-7AFD-45E9-95D0-5A318079D911), helpstring("SpRecPlayAudio Class"), restricted, hidden ] coclass SpRecPlayAudio { interface ISpObjectWithToken; interface ISpAudio; }; //--- SpStream ---------------------------------------------------------- [ uuid(715D9C59-4442-11D2-9605-00C04F8EE628), helpstring("SpStream Class"), restricted, hidden ] coclass SpStream { interface ISpStream; }; //--- SpVoice ----------------------------------------------------------- [ uuid(96749377-3391-11D2-9EE3-00C04F797396), helpstring("SpVoice Class") ] coclass SpVoice { [default] interface ISpeechVoice; interface ISpVoice; [default, source] dispinterface _ISpeechVoiceEvents; }; //--- SpSharedRecoContext ----------------------------------------------- [ uuid(47206204-5ECA-11D2-960F-00C04F8EE628), helpstring("SpSharedRecoContext Class") ] coclass SpSharedRecoContext { [default] interface ISpeechRecoContext; interface ISpRecoContext; [default, source] dispinterface _ISpeechRecoContextEvents; }; //--- SpInprocRecognizer ------------------------------------------------ [ uuid(41B89B6B-9399-11D2-9623-00C04F8EE628), helpstring("SpInprocRecognizer Class") ] coclass SpInprocRecognizer { [default] interface ISpeechRecognizer; interface ISpRecognizer; }; //--- SpSharedRecognizer ---------------------------------------------- [ uuid(3BEE4890-4FE9-4A37-8C1E-5E7E12791C1F), helpstring("SpSharedRecognizer Class") ] coclass SpSharedRecognizer { [default] interface ISpeechRecognizer; interface ISpRecognizer; }; //--- SpLexicon ---------------------------------------------------------- [ uuid(0655E396-25D0-11D3-9C26-00C04F8EF87C), helpstring("SpLexicon Class") ] coclass SpLexicon { [default] interface ISpeechLexicon; interface ISpLexicon; }; //--- SpUnCompressedLexicon --------------------------------------------------- [ uuid(C9E37C15-DF92-4727-85D6-72E5EEB6995A), helpstring("SpUnCompressedLexicon Class") ] coclass SpUnCompressedLexicon { [default] interface ISpeechLexicon; interface ISpLexicon; interface ISpObjectWithToken; }; //--- SpCompressedLexicon --------------------------------------------------- [ uuid(90903716-2F42-11D3-9C26-00C04F8EF87C), helpstring("SpCompressedLexicon Class"), restricted, hidden ] coclass SpCompressedLexicon { [default] interface ISpLexicon; interface ISpObjectWithToken; }; //--- SpPhoneConverter ------------------------------------------------ [ uuid(9185F743-1143-4C28-86B5-BFF14F20E5C8), helpstring("SpPhoneConverter Class") ] coclass SpPhoneConverter { [default] interface ISpeechPhoneConverter; interface ISpPhoneConverter; }; //--- SpNullPhoneConverter ------------------------------------------------ [ uuid(455F24E9-7396-4A16-9715-7C0FDBE3EFE3), helpstring("SpNullPhoneConverter Class"), restricted, hidden ] coclass SpNullPhoneConverter { [default] interface ISpPhoneConverter; }; #ifdef SAPI_AUTOMATION //--- SpTextSelectionInformation ------------------------------------------------ [ uuid(0F92030A-CBFD-4AB8-A164-FF5985547FF6), helpstring("SpTextSelectionInformation Class"), ] coclass SpTextSelectionInformation { [default] interface ISpeechTextSelectionInformation; }; //--- SpPhraseInfoBuilder ------------------------------------------------ [ uuid(C23FC28D-C55F-4720-8B32-91F73C2BD5D1), helpstring("SpPhraseInfoBuilder Class"), ] coclass SpPhraseInfoBuilder { [default] interface ISpeechPhraseInfoBuilder; }; //--- SpAudioFormat ------------------------------------------------ [ uuid(9EF96870-E160-4792-820D-48CF0649E4EC), helpstring("SpAudioFormat Class"), ] coclass SpAudioFormat { [default] interface ISpeechAudioFormat; }; //--- SpWaveFormatEx ------------------------------------------------ [ uuid(C79A574C-63BE-44b9-801F-283F87F898BE), helpstring("SpWaveFormatEx Class"), ] coclass SpWaveFormatEx { [default] interface ISpeechWaveFormatEx; }; //--- SpInProcRecoContext ----------------------------------------------- [ uuid(73AD6842-ACE0-45E8-A4DD-8795881A2C2A), helpstring("SpInProcRecoContext Class") ] coclass SpInProcRecoContext { [default] interface ISpeechRecoContext; interface ISpRecoContext; [default, source] dispinterface _ISpeechRecoContextEvents; }; //--- SpCustomStream ------------------------------------------------ [ uuid(8DBEF13F-1948-4aa8-8CF0-048EEBED95D8), helpstring("SpCustomStream Class"), ] coclass SpCustomStream { [default] interface ISpeechCustomStream; interface ISpStream; }; //--- SpFileStream ------------------------------------------------ [ uuid(947812B3-2AE1-4644-BA86-9E90DED7EC91), helpstring("SpFileStream Class"), ] coclass SpFileStream { [default] interface ISpeechFileStream; interface ISpStream; }; //--- SpMemoryStream ------------------------------------------------ [ uuid(5FB7EF7D-DFF4-468a-B6B7-2FCBD188F994), helpstring("SpMemoryStream Class"), ] coclass SpMemoryStream { [default] interface ISpeechMemoryStream; interface ISpStream; }; #endif // SAPI_AUTOMATION }