| // Copyright © 2015, Connor Hilarides |
| // Licensed under the MIT License <LICENSE.md> |
| //! Mappings for the contents of sapi.h |
| ENUM!{enum SPDATAKEYLOCATION { |
| SPDKL_DefaultLocation = 0, |
| SPDKL_CurrentUser = 1, |
| SPDKL_LocalMachine = 2, |
| SPDKL_CurrentConfig = 5, |
| }} |
| pub const SPDUI_EngineProperties: &'static str = "EngineProperties"; |
| pub const SPDUI_AddRemoveWord: &'static str = "AddRemoveWord"; |
| pub const SPDUI_UserTraining: &'static str = "UserTraining"; |
| pub const SPDUI_MicTraining: &'static str = "MicTraining"; |
| pub const SPDUI_RecoProfileProperties: &'static str = "RecoProfileProperties"; |
| pub const SPDUI_AudioProperties: &'static str = "AudioProperties"; |
| pub const SPDUI_AudioVolume: &'static str = "AudioVolume"; |
| pub const SPDUI_UserEnrollment: &'static str = "UserEnrollment"; |
| pub const SPDUI_ShareData: &'static str = "ShareData"; |
| pub const SPDUI_Tutorial: &'static str = "Tutorial"; |
| ENUM!{enum SPSTREAMFORMAT { |
| SPSF_Default = -1i32 as u32, |
| SPSF_NoAssignedFormat = 0, |
| SPSF_Text = 1, |
| SPSF_NonStandardFormat = 2, |
| SPSF_ExtendedAudioFormat = 3, |
| SPSF_8kHz8BitMono = 4, |
| SPSF_8kHz8BitStereo = 5, |
| SPSF_8kHz16BitMono = 6, |
| SPSF_8kHz16BitStereo = 7, |
| SPSF_11kHz8BitMono = 8, |
| SPSF_11kHz8BitStereo = 9, |
| SPSF_11kHz16BitMono = 10, |
| SPSF_11kHz16BitStereo = 11, |
| SPSF_12kHz8BitMono = 12, |
| SPSF_12kHz8BitStereo = 13, |
| SPSF_12kHz16BitMono = 14, |
| SPSF_12kHz16BitStereo = 15, |
| SPSF_16kHz8BitMono = 16, |
| SPSF_16kHz8BitStereo = 17, |
| SPSF_16kHz16BitMono = 18, |
| SPSF_16kHz16BitStereo = 19, |
| SPSF_22kHz8BitMono = 20, |
| SPSF_22kHz8BitStereo = 21, |
| SPSF_22kHz16BitMono = 22, |
| SPSF_22kHz16BitStereo = 23, |
| SPSF_24kHz8BitMono = 24, |
| SPSF_24kHz8BitStereo = 25, |
| SPSF_24kHz16BitMono = 26, |
| SPSF_24kHz16BitStereo = 27, |
| SPSF_32kHz8BitMono = 28, |
| SPSF_32kHz8BitStereo = 29, |
| SPSF_32kHz16BitMono = 30, |
| SPSF_32kHz16BitStereo = 31, |
| SPSF_44kHz8BitMono = 32, |
| SPSF_44kHz8BitStereo = 33, |
| SPSF_44kHz16BitMono = 34, |
| SPSF_44kHz16BitStereo = 35, |
| SPSF_48kHz8BitMono = 36, |
| SPSF_48kHz8BitStereo = 37, |
| SPSF_48kHz16BitMono = 38, |
| SPSF_48kHz16BitStereo = 39, |
| SPSF_TrueSpeech_8kHz1BitMono = 40, |
| SPSF_CCITT_ALaw_8kHzMono = 41, |
| SPSF_CCITT_ALaw_8kHzStereo = 42, |
| SPSF_CCITT_ALaw_11kHzMono = 43, |
| SPSF_CCITT_ALaw_11kHzStereo = 44, |
| SPSF_CCITT_ALaw_22kHzMono = 45, |
| SPSF_CCITT_ALaw_22kHzStereo = 46, |
| SPSF_CCITT_ALaw_44kHzMono = 47, |
| SPSF_CCITT_ALaw_44kHzStereo = 48, |
| SPSF_CCITT_uLaw_8kHzMono = 49, |
| SPSF_CCITT_uLaw_8kHzStereo = 50, |
| SPSF_CCITT_uLaw_11kHzMono = 51, |
| SPSF_CCITT_uLaw_11kHzStereo = 52, |
| SPSF_CCITT_uLaw_22kHzMono = 53, |
| SPSF_CCITT_uLaw_22kHzStereo = 54, |
| SPSF_CCITT_uLaw_44kHzMono = 55, |
| SPSF_CCITT_uLaw_44kHzStereo = 56, |
| SPSF_ADPCM_8kHzMono = 57, |
| SPSF_ADPCM_8kHzStereo = 58, |
| SPSF_ADPCM_11kHzMono = 59, |
| SPSF_ADPCM_11kHzStereo = 60, |
| SPSF_ADPCM_22kHzMono = 61, |
| SPSF_ADPCM_22kHzStereo = 62, |
| SPSF_ADPCM_44kHzMono = 63, |
| SPSF_ADPCM_44kHzStereo = 64, |
| SPSF_GSM610_8kHzMono = 65, |
| SPSF_GSM610_11kHzMono = 66, |
| SPSF_GSM610_22kHzMono = 67, |
| SPSF_GSM610_44kHzMono = 68, |
| SPSF_NUM_FORMATS = 69, |
| }} |
| pub const SPREG_USER_ROOT: &'static str = "HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech"; |
| pub const SPREG_LOCAL_MACHINE_ROOT: &'static str = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech"; |
| pub const SPCAT_AUDIOOUT: &'static str = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioOutput"; |
| pub const SPCAT_AUDIOIN: &'static str = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioInput"; |
| pub const SPCAT_VOICES: &'static str = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\Voices"; |
| pub const SPCAT_RECOGNIZERS: &'static str = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\Recognizers"; |
| pub const SPCAT_APPLEXICONS: &'static str = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AppLexicons"; |
| pub const SPCAT_PHONECONVERTERS: &'static str = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\PhoneConverters"; |
| pub const SPCAT_TEXTNORMALIZERS: &'static str = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\TextNormalizers"; |
| pub const SPCAT_RECOPROFILES: &'static str = "HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech\\RecoProfiles"; |
| pub const SPMMSYS_AUDIO_IN_TOKEN_ID: &'static str = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioInput\\TokenEnums\\MMAudioIn\\"; |
| pub const SPMMSYS_AUDIO_OUT_TOKEN_ID: &'static str = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioOutput\\TokenEnums\\MMAudioOut\\"; |
| pub const SPCURRENT_USER_LEXICON_TOKEN_ID: &'static str = "HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech\\CurrentUserLexicon"; |
| pub const SPCURRENT_USER_SHORTCUT_TOKEN_ID: &'static str = "HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech\\CurrentUserShortcut"; |
| pub const SPTOKENVALUE_CLSID: &'static str = "CLSID"; |
| pub const SPTOKENKEY_FILES: &'static str = "Files"; |
| pub const SPTOKENKEY_UI: &'static str = "UI"; |
| pub const SPTOKENKEY_ATTRIBUTES: &'static str = "Attributes"; |
| pub const SPTOKENKEY_RETAINEDAUDIO: &'static str = "SecondsPerRetainedAudioEvent"; |
| pub const SPTOKENKEY_AUDIO_LATENCY_WARNING: &'static str = "LatencyWarningThreshold"; |
| pub const SPTOKENKEY_AUDIO_LATENCY_TRUNCATE: &'static str = "LatencyTruncateThreshold"; |
| pub const SPTOKENKEY_AUDIO_LATENCY_UPDATE_INTERVAL: &'static str = "LatencyUpdateInterval"; |
| pub const SPVOICECATEGORY_TTSRATE: &'static str = "DefaultTTSRate"; |
| pub const SPPROP_RESOURCE_USAGE: &'static str = "ResourceUsage"; |
| pub const SPPROP_HIGH_CONFIDENCE_THRESHOLD: &'static str = "HighConfidenceThreshold"; |
| pub const SPPROP_NORMAL_CONFIDENCE_THRESHOLD: &'static str = "NormalConfidenceThreshold"; |
| pub const SPPROP_LOW_CONFIDENCE_THRESHOLD: &'static str = "LowConfidenceThreshold"; |
| pub const SPPROP_RESPONSE_SPEED: &'static str = "ResponseSpeed"; |
| pub const SPPROP_COMPLEX_RESPONSE_SPEED: &'static str = "ComplexResponseSpeed"; |
| pub const SPPROP_ADAPTATION_ON: &'static str = "AdaptationOn"; |
| pub const SPPROP_PERSISTED_BACKGROUND_ADAPTATION: &'static str = "PersistedBackgroundAdaptation"; |
| pub const SPPROP_PERSISTED_LANGUAGE_MODEL_ADAPTATION: &'static str = "PersistedLanguageModelAdaptation"; |
| pub const SPPROP_UX_IS_LISTENING: &'static str = "UXIsListening"; |
| pub const SPTOPIC_SPELLING: &'static str = "Spelling"; |
| pub const SPWILDCARD: &'static str = "..."; |
| pub const SPDICTATION: &'static str = "*"; |
| pub const SPINFDICTATION: &'static str = "*+"; |
| pub const SPREG_SAFE_USER_TOKENS: &'static str = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\UserTokens"; |
| pub const SP_LOW_CONFIDENCE: i32 = -1; |
| pub const SP_NORMAL_CONFIDENCE: i32 = 0; |
| pub const SP_HIGH_CONFIDENCE: i32 = 1; |
| pub const DEFAULT_WEIGHT: i32 = 1; |
| pub const SP_MAX_WORD_LENGTH: i32 = 128; |
| pub const SP_MAX_PRON_LENGTH: i32 = 384; |
| pub const SP_EMULATE_RESULT: i32 = 0x40000000; |
| RIDL!( |
| interface ISpNotifyCallback(ISpNotifyCallbackVtbl) { |
| fn NotifyCallback(&mut self, wParam: ::WPARAM, lParam: ::LPARAM) -> ::HRESULT |
| } |
| ); |
| pub type SPNOTIFYCALLBACK = unsafe extern "system" fn(wParam: ::WPARAM, lParam: ::LPARAM); |
| RIDL!( |
| interface ISpNotifySource(ISpNotifySourceVtbl): IUnknown(IUnknownVtbl) { |
| fn SetNotifySink(&mut self, pNotifySink: *mut ISpNotifySink) -> ::HRESULT, |
| fn SetNotifyWindowMessage( |
| &mut self, hWnd: ::HWND, Msg: ::UINT, wParam: ::WPARAM, lParam: ::LPARAM |
| ) -> ::HRESULT, |
| fn SetNotifyCallbackFunction( |
| &mut self, pfnCallback: SPNOTIFYCALLBACK, wParam: ::WPARAM, lParam: ::LPARAM |
| ) -> ::HRESULT, |
| fn SetNotifyCallbackInterface( |
| &mut self, pSpCallback: *mut ISpNotifyCallback, wParam: ::WPARAM, lParam: ::LPARAM |
| ) -> ::HRESULT, |
| fn SetNotifyWin32Event(&mut self) -> ::HRESULT, |
| fn WaitForNotifyEvent(&mut self, dwMilliseconds: ::DWORD) -> ::HRESULT, |
| fn GetNotifyEventHandle(&mut self) -> ::HANDLE |
| } |
| ); |
| RIDL!( |
| interface ISpNotifySink(ISpNotifySinkVtbl): IUnknown(IUnknownVtbl) { |
| fn Notify(&mut self) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpNotifyTranslator(ISpNotifyTranslatorVtbl): ISpNotifySink(ISpNotifySinkVtbl) { |
| fn InitWindowMessage( |
| &mut self, hWnd: ::HWND, Msg: ::UINT, wParam: ::WPARAM, lParam: ::LPARAM |
| ) -> ::HRESULT, |
| fn InitCallback( |
| &mut self, pfnCallback: SPNOTIFYCALLBACK, wParam: ::WPARAM, lParam: ::LPARAM |
| ) -> ::HRESULT, |
| fn InitSpNotifyCallback( |
| &mut self, pSpCallback: *mut ISpNotifyCallback, wParam: ::WPARAM, lParam: ::LPARAM |
| ) -> ::HRESULT, |
| fn InitWin32Event(&mut self, hEvent: ::HANDLE, fCloseHandleOnRelease: ::BOOL) -> ::HRESULT, |
| fn Wait(&mut self, dwMilliseconds: ::DWORD) -> ::HRESULT, |
| fn GetEventHandle(&mut self) -> ::HANDLE |
| } |
| ); |
| RIDL!( |
| interface ISpDataKey(ISpDataKeyVtbl): IUnknown(IUnknownVtbl) { |
| fn SetData( |
| &mut self, pszValueName: ::LPCWSTR, cbData: ::ULONG, pData: *const ::BYTE |
| ) -> ::HRESULT, |
| fn GetData( |
| &mut self, pszValueName: ::LPCWSTR, pcbData: *mut ::ULONG, pData: *mut ::BYTE |
| ) -> ::HRESULT, |
| fn SetStringValue(&mut self, pszValueName: ::LPCWSTR, pszValue: ::LPCWSTR) -> ::HRESULT, |
| fn GetStringValue(&mut self, pszValueName: ::LPCWSTR, ppszValue: *mut ::LPWSTR) -> ::HRESULT, |
| fn SetDWORD(&mut self, pszValueName: ::LPCWSTR, dwValue: ::DWORD) -> ::HRESULT, |
| fn GetDWORD(&mut self, pszValueName: ::LPCWSTR, pdwValue: *mut ::DWORD) -> ::HRESULT, |
| fn OpenKey(&mut self, pszSubKeyName: ::LPCWSTR, ppSubKey: *mut *mut ISpDataKey) -> ::HRESULT, |
| fn CreateKey(&mut self, pszSubKey: ::LPCWSTR, ppSubKey: *mut *mut ISpDataKey) -> ::HRESULT, |
| fn DeleteKey(&mut self, pszSubKey: ::LPCWSTR) -> ::HRESULT, |
| fn DeleteValue(&mut self, pszValueName: ::LPCWSTR) -> ::HRESULT, |
| fn EnumKeys(&mut self, Index: ::ULONG, ppszSubKeyName: *mut ::LPWSTR) -> ::HRESULT, |
| fn EnumValues(&mut self, Index: ::ULONG, ppszValueName: *mut ::LPWSTR) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpRegDataKey(ISpRegDataKeyVtbl): ISpDataKey(ISpDataKeyVtbl) { |
| fn SetKey(&mut self, hkey: ::HKEY, fReadOnly: ::BOOL) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpObjectTokenCategory(ISpObjectTokenCategoryVtbl): ISpDataKey(ISpDataKeyVtbl) { |
| fn SetId(&mut self, pszCategoryId: ::LPCWSTR, fCreateIfNotExist: ::BOOL) -> ::HRESULT, |
| fn GetId(&mut self, ppszCoMemCategoryId: *mut ::LPWSTR) -> ::HRESULT, |
| fn GetDataKey( |
| &mut self, spdkl: SPDATAKEYLOCATION, pppDataKey: *mut *mut ISpDataKey |
| ) -> ::HRESULT, |
| fn EnumTokens( |
| &mut self, pzsReqAttribs: ::LPCWSTR, pszOptAttribs: ::LPCWSTR, |
| ppEnum: *mut *mut IEnumSpObjectTokens |
| ) -> ::HRESULT, |
| fn SetDefaultTokenId(&mut self, pszTokenId: ::LPCWSTR) -> ::HRESULT, |
| fn GetDefaultTokenId(&mut self, ppszCoMemTokenId: *mut ::LPWSTR) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpObjectToken(ISpObjectTokenVtbl): ISpDataKey(ISpDataKeyVtbl) { |
| fn SetId( |
| &mut self, pszCategoryId: ::LPCWSTR, pszTokenId: ::LPCWSTR, fCreateIfNotExist: ::BOOL |
| ) -> ::HRESULT, |
| fn GetId(&mut self, ppszCoMemTokenId: *mut ::LPWSTR) -> ::HRESULT, |
| fn GetCategory(&mut self, ppTokenCategory: *mut *mut ISpObjectTokenCategory) -> ::HRESULT, |
| fn CreateInstance( |
| &mut self, pUnkOuter: *mut ::IUnknown, dwClsContext: ::DWORD, riid: ::REFIID, |
| ppvObject: *mut *mut ::c_void |
| ) -> ::HRESULT, |
| fn GetStorageFileName( |
| &mut self, clsidCaller: ::REFCLSID, pszValueName: ::LPCWSTR, |
| pszFileNameSpecifier: ::LPCWSTR, nFolder: ::ULONG, ppszFilePath: *mut ::LPWSTR |
| ) -> ::HRESULT, |
| fn RemoveStorageFileName(&mut self, pszKeyName: ::LPCWSTR, fDeleteFile: ::BOOL) -> ::HRESULT, |
| fn Remove(&mut self, pclsidCaller: *const ::CLSID) -> ::HRESULT, |
| fn IsUISupported( |
| &mut self, pszTypeOfUI: ::LPCWSTR, pvExtraData: *mut ::c_void, cbExtraData: ::ULONG, |
| punkObject: *mut ::IUnknown, pfSupported: *mut ::BOOL |
| ) -> ::HRESULT, |
| fn DisplayUI( |
| &mut self, hwndParent: ::HWND, pszTitle: ::LPCWSTR, pszTypeOfUI: ::LPCWSTR, |
| pvExtraData: *mut ::c_void, cbExtraData: ::ULONG, punkObject: *mut ::IUnknown |
| ) -> ::HRESULT, |
| fn MatchesAttributes(&mut self, pszAttributes: ::LPCWSTR, pfMatches: *mut ::BOOL) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpObjectTokenInit(ISpObjectTokenInitVtbl): ISpObjectToken(ISpObjectTokenVtbl) { |
| fn InitFromDataKey( |
| &mut self, pszCategoryId: ::LPCWSTR, pszTokenId: ::LPCWSTR, pDataKey: *mut ISpDataKey |
| ) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface IEnumSpObjectTokens(IEnumSpObjectTokensVtbl): IUnknown(IUnknownVtbl) { |
| fn Next( |
| &mut self, celt: ::ULONG, pelt: *mut *mut ISpObjectToken, pceltFetched: *mut ::ULONG |
| ) -> ::HRESULT, |
| fn Skip(&mut self, celt: ::ULONG) -> ::HRESULT, |
| fn Reset(&mut self) -> ::HRESULT, |
| fn Clone(&mut self, ppEnum: *mut *mut IEnumSpObjectTokens) -> ::HRESULT, |
| fn Item(&mut self, Index: ::ULONG, ppToken: *mut *mut ISpObjectToken) -> ::HRESULT, |
| fn GetCount(&mut self, pCount: *mut ::ULONG) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpObjectWithToken(ISpObjectWithTokenVtbl): IUnknown(IUnknownVtbl) { |
| fn SetObjectToken(&mut self, pToken: *mut ISpObjectToken) -> ::HRESULT, |
| fn GetObjectToken(&mut self, ppToken: *mut *mut ISpObjectToken) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpResourceManager(ISpResourceManagerVtbl): IServiceProvider(IServiceProviderVtbl) { |
| fn SetObject(&mut self, guidServiceId: ::REFGUID, pUnkObject: *mut ::IUnknown) -> ::HRESULT, |
| fn GetObject( |
| &mut self, guidServiceId: ::REFGUID, ObjectCLSID: ::REFCLSID, ObjectIID: ::REFIID, |
| fReleaseWhenLastExternalRefReleased: ::BOOL, ppObject: *mut *mut ::c_void |
| ) -> ::HRESULT |
| } |
| ); |
| ENUM!{enum SPEVENTLPARAMTYPE { |
| SPET_LPARAM_IS_UNDEFINED = 0, |
| SPET_LPARAM_IS_TOKEN, |
| SPET_LPARAM_IS_OBJECT, |
| SPET_LPARAM_IS_POINTER, |
| SPET_LPARAM_IS_STRING, |
| }} |
| ENUM!{enum SPEVENTENUM { |
| SPEI_UNDEFINED = 0, |
| SPEI_START_INPUT_STREAM = 1, |
| SPEI_END_INPUT_STREAM = 2, |
| SPEI_VOICE_CHANGE = 3, |
| SPEI_TTS_BOOKMARK = 4, |
| SPEI_WORD_BOUNDARY = 5, |
| SPEI_PHONEME = 6, |
| SPEI_SENTENCE_BOUNDARY = 7, |
| SPEI_VISEME = 8, |
| SPEI_TTS_AUDIO_LEVEL = 9, |
| SPEI_TTS_PRIVATE = 15, |
| SPEI_END_SR_STREAM = 34, |
| 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, |
| SPEI_PROPERTY_STRING_CHANGE = 42, |
| SPEI_FALSE_RECOGNITION = 43, |
| SPEI_INTERFERENCE = 44, |
| SPEI_REQUEST_UI = 45, |
| SPEI_RECO_STATE_CHANGE = 46, |
| SPEI_ADAPTATION = 47, |
| SPEI_START_SR_STREAM = 48, |
| SPEI_RECO_OTHER_CONTEXT = 49, |
| SPEI_SR_AUDIO_LEVEL = 50, |
| SPEI_SR_RETAINEDAUDIO = 51, |
| SPEI_SR_PRIVATE = 52, |
| SPEI_ACTIVE_CATEGORY_CHANGED = 53, |
| SPEI_RESERVED5 = 54, |
| SPEI_RESERVED6 = 55, |
| SPEI_RESERVED1 = 30, |
| SPEI_RESERVED2 = 33, |
| SPEI_RESERVED3 = 63, |
| }} |
| pub const SPEI_MIN_TTS: SPEVENTENUM = SPEI_START_INPUT_STREAM; |
| pub const SPEI_MAX_TTS: SPEVENTENUM = SPEI_TTS_PRIVATE; |
| pub const SPEI_MIN_SR: SPEVENTENUM = SPEI_END_SR_STREAM; |
| pub const SPEI_MAX_SR: SPEVENTENUM = SPEI_RESERVED6; |
| pub const SPFEI_FLAGCHECK: u64 = (1 << SPEI_RESERVED1.0 as u64) | (1 << SPEI_RESERVED2.0 as u64); |
| pub const SPFEI_ALL_TTS_EVENTS: u64 = 0x000000000000FFFE | SPFEI_FLAGCHECK; |
| pub const SPFEI_ALL_SR_EVENTS: u64 = 0x003FFFFC00000000 | SPFEI_FLAGCHECK; |
| pub const SPFEI_ALL_EVENTS: u64 = 0xEFFFFFFFFFFFFFFF; |
| #[inline] |
| pub fn SPFEI(SPEI_ord: u64) -> u64 { |
| (1 << SPEI_ord) | SPFEI_FLAGCHECK |
| } |
| STRUCT!{struct SPEVENT { |
| eEventId: ::WORD, |
| elParamType: ::WORD, |
| ulStreamNum: ::ULONG, |
| ullAudioStreamOffset: ::ULONGLONG, |
| wParam: ::WPARAM, |
| lParam: ::LPARAM, |
| }} |
| STRUCT!{struct SPSERIALIZEDEVENT { |
| eEventId: ::WORD, |
| elParamType: ::WORD, |
| ulStreamNum: ::ULONG, |
| ullAudioStreamOffset: ::ULONGLONG, |
| SerializedwParam: ::ULONG, |
| SerializedlParam: ::LONG, |
| }} |
| STRUCT!{struct SPSERIALIZEDEVENT64 { |
| eEventId: ::WORD, |
| elParamType: ::WORD, |
| ulStreamNum: ::ULONG, |
| ullAudioStreamOffset: ::ULONGLONG, |
| SerializedwParam: ::ULONGLONG, |
| SerializedlParam: ::LONGLONG, |
| }} |
| STRUCT!{struct SPEVENTEX { |
| eEventId: ::WORD, |
| elParamType: ::WORD, |
| ulStreamNum: ::ULONG, |
| ullAudioStreamOffset: ::ULONGLONG, |
| wParam: ::WPARAM, |
| lParam: ::LPARAM, |
| ullAudioTimeOffset: ::ULONGLONG, |
| }} |
| ENUM!{enum SPINTERFERENCE { |
| SPINTERFERENCE_NONE = 0, |
| SPINTERFERENCE_NOISE = 1, |
| SPINTERFERENCE_NOSIGNAL = 2, |
| SPINTERFERENCE_TOOLOUD = 3, |
| SPINTERFERENCE_TOOQUIET = 4, |
| SPINTERFERENCE_TOOFAST = 5, |
| SPINTERFERENCE_TOOSLOW = 6, |
| SPINTERFERENCE_LATENCY_WARNING = 7, |
| SPINTERFERENCE_LATENCY_TRUNCATE_BEGIN = 8, |
| SPINTERFERENCE_LATENCY_TRUNCATE_END = 9, |
| }} |
| FLAGS!{enum SPENDSRSTREAMFLAGS { |
| SPESF_NONE = 0, |
| SPESF_STREAM_RELEASED = 1 << 0, |
| SPESF_EMULATED = 1 << 1, |
| }} |
| FLAGS!{enum SPVFEATURE { |
| SPVFEATURE_STRESSED = 1 << 0, |
| SPVFEATURE_EMPHASIS = 1 << 1, |
| }} |
| ENUM!{enum SPVISEMES { |
| SP_VISEME_0 = 0, |
| SP_VISEME_1, |
| SP_VISEME_2, |
| SP_VISEME_3, |
| SP_VISEME_4, |
| SP_VISEME_5, |
| SP_VISEME_6, |
| SP_VISEME_7, |
| SP_VISEME_8, |
| SP_VISEME_9, |
| SP_VISEME_10, |
| SP_VISEME_11, |
| SP_VISEME_12, |
| SP_VISEME_13, |
| SP_VISEME_14, |
| SP_VISEME_15, |
| SP_VISEME_16, |
| SP_VISEME_17, |
| SP_VISEME_18, |
| SP_VISEME_19, |
| SP_VISEME_20, |
| SP_VISEME_21, |
| }} |
| STRUCT!{struct SPEVENTSOURCEINFO { |
| ullEventInterest: ::ULONGLONG, |
| ullQueuedInterest: ::ULONGLONG, |
| ulCount: ::ULONG, |
| }} |
| RIDL!( |
| interface ISpEventSource(ISpEventSourceVtbl): ISpNotifySource(ISpNotifySourceVtbl) { |
| fn SetInterest( |
| &mut self, ullEventInterest: ::ULONGLONG, ullQueuedInterest: ::ULONGLONG |
| ) -> ::HRESULT, |
| fn GetEvents( |
| &mut self, ulCount: ::ULONG, pEventArray: *mut SPEVENT, pulFetched: *mut ::ULONG |
| ) -> ::HRESULT, |
| fn GetInfo(&mut self, pInfo: *mut SPEVENTSOURCEINFO) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpEventSource2(ISpEventSource2Vtbl): ISpEventSource(ISpEventSourceVtbl) { |
| fn GetEventsEx( |
| &mut self, ulCount: ::ULONG, pEventArray: *mut SPEVENTEX, pulFetched: *mut ::ULONG |
| ) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpEventSink(ISpEventSinkVtbl): IUnknown(IUnknownVtbl) { |
| fn AddEvents(&mut self, pEventArray: *const SPEVENT, ulCount: ::ULONG) -> ::HRESULT, |
| fn GetEventInterest(&mut self, pullEventInterest: *mut ::ULONGLONG) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpStreamFormat(ISpStreamFormatVtbl): IStream(IStreamVtbl) { |
| fn GetFormat( |
| &mut self, pguidFormatId: *mut ::GUID, ppCoMemWaveFormatEx: *mut *mut ::WAVEFORMATEX |
| ) -> ::HRESULT |
| } |
| ); |
| ENUM!{enum SPFILEMODE { |
| SPFM_OPEN_READONLY = 0, |
| SPFM_OPEN_READWRITE = 1, |
| SPFM_CREATE = 2, |
| SPFM_CREATE_ALWAYS = 3, |
| SPFM_NUM_MODES = 4, |
| }} |
| RIDL!( |
| interface ISpStream(ISpStreamVtbl): ISpStreamFormat(ISpStreamFormatVtbl) { |
| fn SetBaseStream( |
| &mut self, pStream: *mut ::IStream, rguidFormat: ::REFGUID, |
| pWaveFormatEx: *const ::WAVEFORMATEX |
| ) -> ::HRESULT, |
| fn GetBaseStream(&mut self, ppStream: *mut *mut ::IStream) -> ::HRESULT, |
| fn BindToFile( |
| &mut self, pszFileName: ::LPCWSTR, eMode: SPFILEMODE, pFormatId: *const ::GUID, |
| pWaveFormatEx: *const ::WAVEFORMATEX, ullEventInterest: ::ULONGLONG |
| ) -> ::HRESULT, |
| fn Close(&mut self) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpStreamFormatConverter(ISpStreamFormatConverterVtbl) |
| : ISpStreamFormat(ISpStreamFormatVtbl) { |
| fn SetBaseStream( |
| &mut self, pStream: *mut ISpStreamFormat, fSetFormatToBaseStreamFormat: ::BOOL, |
| fWriteToBaseStream: ::BOOL |
| ) -> ::HRESULT, |
| fn GetBaseStream(&mut self, ppStream: *mut *mut ISpStreamFormat) -> ::HRESULT, |
| fn SetFormat( |
| &mut self, rguidFormatIdOfConvertedStream: ::REFGUID, |
| pWaveFormatExOfConvertedStream: *const ::WAVEFORMATEX |
| ) -> ::HRESULT, |
| fn ResetSeekPosition(&mut self) -> ::HRESULT, |
| fn ScaleConvertedToBaseOffset( |
| &mut self, ullOffsetConvertedStream: ::ULONGLONG, pullOffsetBaseStream: *mut ::ULONGLONG |
| ) -> ::HRESULT, |
| fn ScaleBaseToConvertedOffset( |
| &mut self, ullOffsetBaseStream: ::ULONGLONG, pullOffsetConvertedStream: *mut ::ULONGLONG |
| ) -> ::HRESULT |
| } |
| ); |
| ENUM!{enum SPAUDIOSTATE { |
| SPAS_CLOSED = 0, |
| SPAS_STOP = 1, |
| SPAS_PAUSE = 2, |
| SPAS_RUN = 3, |
| }} |
| STRUCT!{struct SPAUDIOSTATUS { |
| cbFreeBuffSpace: ::LONG, |
| cbNonBlockingIO: ::ULONG, |
| State: SPAUDIOSTATE, |
| CurSeekPos: ::ULONGLONG, |
| CurDevicePos: ::ULONGLONG, |
| dwAudioLevel: ::DWORD, |
| dwReserved2: ::DWORD, |
| }} |
| STRUCT!{struct SPAUDIOBUFFERINFO { |
| ulMsMinNotification: ::ULONG, |
| ulMsBufferSize: ::ULONG, |
| ulMsEventBias: ::ULONG, |
| }} |
| RIDL!( |
| interface ISpAudio(ISpAudioVtbl): ISpStreamFormat(ISpStreamFormatVtbl) { |
| fn SetState(&mut self, NewState: SPAUDIOSTATE, ullReserved: ::ULONGLONG) -> ::HRESULT, |
| fn SetFormat( |
| &mut self, rguidFmtId: ::REFGUID, pWaveFormatEx: *const ::WAVEFORMATEX |
| ) -> ::HRESULT, |
| fn GetStatus(&mut self, pStatus: *mut SPAUDIOSTATUS) -> ::HRESULT, |
| fn SetBufferInfo(&mut self, pBuffInfo: *const SPAUDIOBUFFERINFO) -> ::HRESULT, |
| fn GetBufferInfo(&mut self, pBuffInfo: *mut SPAUDIOBUFFERINFO) -> ::HRESULT, |
| fn GetDefaultFormat( |
| &mut self, pFormatId: *mut ::GUID, ppCoMemWaveFormatEx: *mut *mut ::WAVEFORMATEX |
| ) -> ::HRESULT, |
| fn EventHandle(&mut self) -> ::HANDLE, |
| fn GetVolumeLevel(&mut self, pLevel: *mut ::ULONG) -> ::HRESULT, |
| fn SetVolumeLevel(&mut self, Level: ::ULONG) -> ::HRESULT, |
| fn GetBufferNotifySize(&mut self, pcbSize: *mut ::ULONG) -> ::HRESULT, |
| fn SetBufferNotifySize(&mut self, cbSize: ::ULONG) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpMMSysAudio(ISpMMSysAudioVtbl): ISpAudio(ISpAudioVtbl) { |
| fn GetDeviceId(&mut self, puDeviceId: *mut ::UINT) -> ::HRESULT, |
| fn SetDeviceId(&mut self, uDeviceId: ::UINT) -> ::HRESULT, |
| fn GetMMHandle(&mut self, pHandle: *mut *mut ::c_void) -> ::HRESULT, |
| fn GetLineId(&mut self, puLineId: *mut ::UINT) -> ::HRESULT, |
| fn SetLineId(&mut self, uLineId: ::UINT) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpTranscript(ISpTranscriptVtbl): IUnknown(IUnknownVtbl) { |
| fn GetTranscript(&mut self, ppszTranscript: *mut ::LPWSTR) -> ::HRESULT, |
| fn AppendTranscript(&mut self, pszTranscript: ::LPCWSTR) -> ::HRESULT |
| } |
| ); |
| FLAGS!{enum SPDISPLYATTRIBUTES { |
| SPAF_ONE_TRAILING_SPACE = 0x2, |
| SPAF_TWO_TRAILING_SPACES = 0x4, |
| SPAF_CONSUME_LEADING_SPACES = 0x8, |
| SPAF_BUFFER_POSITION = 0x10, |
| SPAF_ALL = 0x1f, |
| SPAF_USER_SPECIFIED = 0x80, |
| }} |
| pub type SPPHONEID = ::WCHAR; |
| pub type PSPPHONEID = ::LPWSTR; |
| pub type PCSPPHONEID = ::LPCWSTR; |
| STRUCT!{struct SPPHRASEELEMENT { |
| ulAudioTimeOffset: ::ULONG, |
| ulAudioSizeTime: ::ULONG, |
| ulAudioStreamOffset: ::ULONG, |
| ulAudioSizeBytes: ::ULONG, |
| ulRetainedStreamOffset: ::ULONG, |
| ulRetainedSizeBytes: ::ULONG, |
| pszDisplayText: ::LPCWSTR, |
| pszLexicalForm: ::LPCWSTR, |
| pszPronunciation: *const SPPHONEID, |
| bDisplayAttributes: ::BYTE, |
| RequiredConfidence: ::c_char, |
| ActualConfidence: ::c_char, |
| Reserved: ::BYTE, |
| SREngineConfidence: ::c_float, |
| }} |
| STRUCT!{struct SPPHRASERULE { |
| pszName: ::LPCWSTR, |
| ulId: ::ULONG, |
| ulFirstElement: ::ULONG, |
| ulCountOfElements: ::ULONG, |
| pNextSibling: *const SPPHRASERULE, |
| pFirstChild: *const SPPHRASERULE, |
| SREngineConfidence: ::c_float, |
| Confidence: ::c_char, |
| }} |
| ENUM!{enum SPPHRASEPROPERTYUNIONTYPE { |
| SPPPUT_UNUSED = 0, |
| SPPPUT_ARRAY_INDEX, |
| }} |
| STRUCT!{struct SPPHRASEPROPERTY { |
| pszName: ::LPCWSTR, |
| bType: ::BYTE, |
| bReserved: ::BYTE, |
| usArrayIndex: u16, |
| pszValue: ::LPCWSTR, |
| vValue: ::VARIANT, |
| ulFirstElement: ::ULONG, |
| ulCountOfElements: ::ULONG, |
| pNextSibling: *const SPPHRASEPROPERTY, |
| pFirstChild: *const SPPHRASEPROPERTY, |
| SREngineConfidence: ::c_float, |
| Confidence: ::c_char, |
| }} |
| UNION!(SPPHRASEPROPERTY, bType, ulId, ulId_mut, ::ULONG); |
| STRUCT!{struct SPPHRASEREPLACEMENT { |
| bDisplayAttributes: ::BYTE, |
| pszReplacementText: ::LPCWSTR, |
| ulFirstElement: ::ULONG, |
| ulCountOfElements: ::ULONG, |
| }} |
| STRUCT!{struct SPSEMANTICERRORINFO { |
| ulLineNumber: ::ULONG, |
| pszScriptLine: ::LPWSTR, |
| pszSource: ::LPWSTR, |
| pszDescription: ::LPWSTR, |
| hrResultCode: ::HRESULT, |
| }} |
| ENUM!{enum SPSEMANTICFORMAT { |
| SPSMF_SAPI_PROPERTIES = 0, |
| SPSMF_SRGS_SEMANTICINTERPRETATION_MS = 1, |
| SPSMF_SRGS_SAPIPROPERTIES = 2, |
| SPSMF_UPS = 4, |
| SPSMF_SRGS_SEMANTICINTERPRETATION_W3C = 8, |
| }} |
| STRUCT!{struct SPPHRASE_50 { |
| cbSize: ::ULONG, |
| LangID: ::WORD, |
| wHomophoneGroupId: ::WORD, |
| ullGrammarID: ::ULONGLONG, |
| ftStartTime: ::ULONGLONG, |
| ullAudioStreamPosition: ::ULONGLONG, |
| ulAudioSizeBytes: ::ULONG, |
| ulRetainedSizeBytes: ::ULONG, |
| ulAudioSizeTime: ::ULONG, |
| Rule: ::SPPHRASERULE, |
| pProperties: *const ::SPPHRASEPROPERTY, |
| pElements: *const ::SPPHRASEELEMENT, |
| cReplacements: ::ULONG, |
| pReplacements: *const ::SPPHRASEREPLACEMENT, |
| SREngineID: ::GUID, |
| ulSREnginePrivateDataSize: ::ULONG, |
| pSREnginePrivateData: *const ::BYTE, |
| }} |
| STRUCT!{struct SPPHRASE_53 { |
| cbSize: ::ULONG, |
| LangID: ::WORD, |
| wHomophoneGroupId: ::WORD, |
| ullGrammarID: ::ULONGLONG, |
| ftStartTime: ::ULONGLONG, |
| ullAudioStreamPosition: ::ULONGLONG, |
| ulAudioSizeBytes: ::ULONG, |
| ulRetainedSizeBytes: ::ULONG, |
| ulAudioSizeTime: ::ULONG, |
| Rule: ::SPPHRASERULE, |
| pProperties: *const ::SPPHRASEPROPERTY, |
| pElements: *const ::SPPHRASEELEMENT, |
| cReplacements: ::ULONG, |
| pReplacements: *const ::SPPHRASEREPLACEMENT, |
| SREngineID: ::GUID, |
| ulSREnginePrivateDataSize: ::ULONG, |
| pSREnginePrivateData: *const ::BYTE, |
| pSML: ::LPWSTR, |
| pSemanticErrorInfo: *mut SPSEMANTICERRORINFO, |
| }} |
| STRUCT!{struct SPPHRASE { |
| cbSize: ::ULONG, |
| LangID: ::WORD, |
| wHomophoneGroupId: ::WORD, |
| ullGrammarID: ::ULONGLONG, |
| ftStartTime: ::ULONGLONG, |
| ullAudioStreamPosition: ::ULONGLONG, |
| ulAudioSizeBytes: ::ULONG, |
| ulRetainedSizeBytes: ::ULONG, |
| ulAudioSizeTime: ::ULONG, |
| Rule: ::SPPHRASERULE, |
| pProperties: *const ::SPPHRASEPROPERTY, |
| pElements: *const ::SPPHRASEELEMENT, |
| cReplacements: ::ULONG, |
| pReplacements: *const ::SPPHRASEREPLACEMENT, |
| SREngineID: ::GUID, |
| ulSREnginePrivateDataSize: ::ULONG, |
| pSREnginePrivateData: *const ::BYTE, |
| pSML: ::LPWSTR, |
| pSemanticErrorInfo: *mut SPSEMANTICERRORINFO, |
| SemanticTagFormat: SPSEMANTICFORMAT, |
| }} |
| STRUCT!{struct SPSERIALIZEDPHRASE { |
| ulSerializedSize: ::ULONG, |
| }} |
| STRUCT!{struct SPRULE { |
| pszRuleName: ::LPCWSTR, |
| ulRuleId: ::ULONG, |
| dwAttributes: ::DWORD, |
| }} |
| FLAGS!{enum SPVALUETYPE { |
| SPDF_PROPERTY = 0x1, |
| SPDF_REPLACEMENT = 0x2, |
| SPDF_RULE = 0x4, |
| SPDF_DISPLAYTEXT = 0x8, |
| SPDF_LEXICALFORM = 0x10, |
| SPDF_PRONUNCIATION = 0x20, |
| SPDF_AUDIO = 0x40, |
| SPDF_ALTERNATES = 0x80, |
| SPDF_ALL = 0xff, |
| }} |
| STRUCT!{struct SPBINARYGRAMMAR { |
| ulTotalSerializedSize: ::ULONG, |
| }} |
| ENUM!{enum SPPHRASERNG { |
| SPPR_ALL_ELEMENTS = -1i32 as u32, |
| }} |
| pub const SP_GETWHOLEPHRASE: SPPHRASERNG = SPPR_ALL_ELEMENTS; |
| pub const SPRR_ALL_ELEMENTS: SPPHRASERNG = SPPR_ALL_ELEMENTS; |
| DECLARE_HANDLE!(SPSTATEHANDLE, SPSTATEHANDLE__); |
| FLAGS!{enum SPRECOEVENTFLAGS { |
| SPREF_AutoPause = 1 << 0, |
| SPREF_Emulated = 1 << 1, |
| SPREF_SMLTimeout = 1 << 2, |
| SPREF_ExtendableParse = 1 << 3, |
| SPREF_ReSent = 1 << 4, |
| SPREF_Hypothesis = 1 << 5, |
| SPREF_FalseRecognition = 1 << 6, |
| }} |
| ENUM!{enum SPPARTOFSPEECH { |
| SPPS_NotOverriden = -1i32 as u32, |
| SPPS_Unknown = 0, |
| SPPS_Noun = 0x1000, |
| SPPS_Verb = 0x2000, |
| SPPS_Modifier = 0x3000, |
| SPPS_Function = 0x4000, |
| SPPS_Interjection = 0x5000, |
| SPPS_Noncontent = 0x6000, |
| SPPS_LMA = 0x7000, |
| SPPS_SuppressWord = 0xf000, |
| }} |
| FLAGS!{enum SPLEXICONTYPE { |
| eLEXTYPE_USER = 1 << 0, |
| eLEXTYPE_APP = 1 << 1, |
| eLEXTYPE_VENDORLEXICON = 1 << 2, |
| eLEXTYPE_LETTERTOSOUND = 1 << 3, |
| eLEXTYPE_MORPHOLOGY = 1 << 4, |
| eLEXTYPE_RESERVED4 = 1 << 5, |
| eLEXTYPE_USER_SHORTCUT = 1 << 6, |
| eLEXTYPE_RESERVED6 = 1 << 7, |
| eLEXTYPE_RESERVED7 = 1 << 8, |
| eLEXTYPE_RESERVED8 = 1 << 9, |
| eLEXTYPE_RESERVED9 = 1 << 10, |
| eLEXTYPE_RESERVED10 = 1 << 11, |
| eLEXTYPE_PRIVATE1 = 1 << 12, |
| eLEXTYPE_PRIVATE2 = 1 << 13, |
| eLEXTYPE_PRIVATE3 = 1 << 14, |
| eLEXTYPE_PRIVATE4 = 1 << 15, |
| eLEXTYPE_PRIVATE5 = 1 << 16, |
| eLEXTYPE_PRIVATE6 = 1 << 17, |
| eLEXTYPE_PRIVATE7 = 1 << 18, |
| eLEXTYPE_PRIVATE8 = 1 << 19, |
| eLEXTYPE_PRIVATE9 = 1 << 20, |
| eLEXTYPE_PRIVATE10 = 1 << 21, |
| eLEXTYPE_PRIVATE11 = 1 << 22, |
| eLEXTYPE_PRIVATE12 = 1 << 23, |
| eLEXTYPE_PRIVATE13 = 1 << 24, |
| eLEXTYPE_PRIVATE14 = 1 << 25, |
| eLEXTYPE_PRIVATE15 = 1 << 26, |
| eLEXTYPE_PRIVATE16 = 1 << 27, |
| eLEXTYPE_PRIVATE17 = 1 << 28, |
| eLEXTYPE_PRIVATE18 = 1 << 29, |
| eLEXTYPE_PRIVATE19 = 1 << 30, |
| eLEXTYPE_PRIVATE20 = 1 << 31, |
| }} |
| FLAGS!{enum SPWORDTYPE { |
| eWORDTYPE_ADDED = 1 << 0, |
| eWORDTYPE_DELETED = 1 << 1, |
| }} |
| FLAGS!{enum SPPRONUNCIATIONFLAGS { |
| ePRONFLAG_USED = 1 << 0, |
| }} |
| STRUCT!{struct SPWORDPRONUNCIATION { |
| pNextWordPronunciation: *mut SPWORDPRONUNCIATION, |
| eLexiconType: SPLEXICONTYPE, |
| LangID: ::WORD, |
| wPronunciationFlags: ::WORD, |
| ePartOfSpeech: SPPARTOFSPEECH, |
| szPronunciation: [SPPHONEID; 1], |
| }} |
| STRUCT!{struct SPWORDPRONUNCIATIONLIST { |
| ulSize: ::ULONG, |
| pvBuffer: *mut ::BYTE, |
| pFirstWordPronunciation: *mut SPWORDPRONUNCIATION, |
| }} |
| STRUCT!{struct SPWORD { |
| pNextWord: *mut SPWORD, |
| LangID: ::WORD, |
| wReserved: ::WORD, |
| eWordType: SPWORDTYPE, |
| pszWord: ::LPWSTR, |
| pFirstWordPronunciation: *mut SPWORDPRONUNCIATION, |
| }} |
| STRUCT!{struct SPWORDLIST { |
| ulSize: ::ULONG, |
| pvBuffer: *mut ::BYTE, |
| pFirstWord: *mut SPWORD, |
| }} |
| RIDL!( |
| interface ISpLexicon(ISpLexiconVtbl): IUnknown(IUnknownVtbl) { |
| fn GetPronunciations( |
| &mut self, pszWord: ::LPCWSTR, LangID: ::WORD, dwFlags: ::DWORD, |
| pWordPronunciationList: *mut SPWORDPRONUNCIATIONLIST |
| ) -> ::HRESULT, |
| fn AddPronunciation( |
| &mut self, pszWord: ::LPCWSTR, LangID: ::WORD, ePartOfSpeech: SPPARTOFSPEECH, |
| pszPronunciation: PCSPPHONEID |
| ) -> ::HRESULT, |
| fn RemovePronunciation( |
| &mut self, pszWord: ::LPCWSTR, LangID: ::WORD, ePartOfSpeech: SPPARTOFSPEECH, |
| pszPronunciation: PCSPPHONEID |
| ) -> ::HRESULT, |
| fn GetGeneration(&mut self, pdwGeneration: *mut ::DWORD) -> ::HRESULT, |
| fn GetGenerationChange( |
| &mut self, dwFlags: ::DWORD, pdwGeneration: *mut ::DWORD, pWordList: *mut SPWORDLIST |
| ) -> ::HRESULT, |
| fn GetWords( |
| &mut self, dwFlags: ::DWORD, pdwGeneration: *mut ::DWORD, pdwCookie: *mut ::DWORD, |
| pWordList: *mut SPWORDLIST |
| ) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpContainerLexicon(ISpContainerLexiconVtbl): ISpLexicon(ISpLexiconVtbl) { |
| fn AddLexicon(&mut self, pAddLexicon: *mut ISpLexicon, dwFlags: ::DWORD) -> ::HRESULT |
| } |
| ); |
| ENUM!{enum SPSHORTCUTTYPE { |
| SPSHT_NotOverriden = -1i32 as u32, |
| SPSHT_Unknown = 0, |
| SPSHT_EMAIL = 0x1000, |
| SPSHT_OTHER = 0x2000, |
| SPPS_RESERVED1 = 0x3000, |
| SPPS_RESERVED2 = 0x4000, |
| SPPS_RESERVED3 = 0x5000, |
| SPPS_RESERVED4 = 0xf000, |
| }} |
| STRUCT!{struct SPSHORTCUTPAIR { |
| pNextSHORTCUTPAIR: *mut SPSHORTCUTPAIR, |
| LangID: ::WORD, |
| shType: SPSHORTCUTTYPE, |
| pszDisplay: ::LPWSTR, |
| pszSpoken: ::LPWSTR, |
| }} |
| STRUCT!{struct SPSHORTCUTPAIRLIST { |
| ulSize: ::ULONG, |
| pvBuffer: *mut ::BYTE, |
| pFirstShortcutPair: *mut SPSHORTCUTPAIR, |
| }} |
| RIDL!( |
| interface ISpShortcut(ISpShortcutVtbl): IUnknown(IUnknownVtbl) { |
| fn AddShortcut( |
| &mut self, pszDisplay: ::LPCWSTR, LangID: ::WORD, pszSpoken: ::LPCWSTR, |
| shType: SPSHORTCUTTYPE |
| ) -> ::HRESULT, |
| fn RemoveShortcut( |
| &mut self, pszDisplay: ::LPCWSTR, LangID: ::WORD, pszSpoken: ::LPCWSTR, |
| shType: SPSHORTCUTTYPE |
| ) -> ::HRESULT, |
| fn GetShortcuts( |
| &mut self, LangId: ::WORD, pShortcutpairList: *mut SPSHORTCUTPAIRLIST |
| ) -> ::HRESULT, |
| fn GetGeneration(&mut self, pdwGeneration: *mut ::DWORD) -> ::HRESULT, |
| fn GetWordsFromGenerationChange( |
| &mut self, pdwGeneration: *mut ::DWORD, pWordList: *mut SPWORDLIST |
| ) -> ::HRESULT, |
| fn GetWords( |
| &mut self, pdwGeneration: *mut ::DWORD, pdwCookie: *mut ::DWORD, pWordList: *mut SPWORDLIST |
| ) -> ::HRESULT, |
| fn GetShortcutsForGeneration( |
| &mut self, pdwGeneration: *mut ::DWORD, pdwCookie: *mut ::DWORD, |
| pShortcutpairList: *mut SPSHORTCUTPAIRLIST |
| ) -> ::HRESULT, |
| fn GetGenerationChange( |
| &mut self, pdwGeneration: *mut ::DWORD, pShortcutpairList: *mut SPSHORTCUTPAIRLIST |
| ) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpPhoneConverter(ISpPhoneConverterVtbl): ISpObjectWithToken(ISpObjectWithTokenVtbl) { |
| fn PhoneToId(&mut self, pszPhone: ::LPCWSTR, pId: *mut SPPHONEID) -> ::HRESULT, |
| fn IdToPhone(&mut self, pId: PCSPPHONEID, pszPhone: *mut ::WCHAR) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpPhoneticAlphabetConverter(ISpPhoneticAlphabetConverterVtbl): IUnknown(IUnknownVtbl) { |
| fn GetLangId(&mut self, pLangID: *mut ::WORD) -> ::HRESULT, |
| fn SetLangId(&mut self, LangID: *mut ::WORD) -> ::HRESULT, |
| fn SAPI2UPS( |
| &mut self, pszSAPIId: *const SPPHONEID, pszUPSId: *mut SPPHONEID, cMaxLength: ::DWORD |
| ) -> ::HRESULT, |
| fn UPS2SAPI( |
| &mut self, pszUPSId: *const SPPHONEID, pszSAPIId: *mut SPPHONEID, cMaxLength: ::DWORD |
| ) -> ::HRESULT, |
| fn GetMaxConvertLength( |
| &mut self, cSrcLength: ::DWORD, bSAPI2UPS: ::BOOL, pcMaxDestLength: *mut ::DWORD |
| ) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpPhoneticAlphabetSelection(ISpPhoneticAlphabetSelectionVtbl): IUnknown(IUnknownVtbl) { |
| fn IsAlphabetUPS(&mut self, pfIsUPS: *mut ::BOOL) -> ::HRESULT, |
| fn SetAlphabetToUPS(&mut self, fForceUPS: ::BOOL) -> ::HRESULT |
| } |
| ); |
| STRUCT!{struct SPVPITCH { |
| MiddleAdj: ::c_long, |
| RangeAdj: ::c_long, |
| }} |
| ENUM!{enum SPVACTIONS { |
| SPVA_Speak = 0, |
| SPVA_Silence, |
| SPVA_Pronounce, |
| SPVA_Bookmark, |
| SPVA_SpellOut, |
| SPVA_Section, |
| SPVA_ParseUnknownTag, |
| }} |
| STRUCT!{struct SPVCONTEXT { |
| pCategory: ::LPCWSTR, |
| pBefore: ::LPCWSTR, |
| pAfter: ::LPCWSTR, |
| }} |
| STRUCT!{struct SPVSTATE { |
| eAction: SPVACTIONS, |
| LangID: ::WORD, |
| wReserved: ::WORD, |
| EmphAdj: ::c_long, |
| RateAdj: ::c_long, |
| Volume: ::ULONG, |
| PitchAdj: SPVPITCH, |
| SilenceMSecs: ::ULONG, |
| pPhoneIds: *mut SPPHONEID, |
| ePartOfSpeech: SPPARTOFSPEECH, |
| Context: SPVCONTEXT, |
| }} |
| ENUM!{enum SPRUNSTATE { |
| SPRS_DONE = 1 << 0, |
| SPRS_IS_SPEAKING = 1 << 1, |
| }} |
| ENUM!{enum SPVLIMITS { |
| SPMIN_VOLUME = 0, |
| SPMAX_VOLUME = 100, |
| SPMIN_RATE = -10i32 as u32, |
| SPMAX_RATE = 10, |
| }} |
| ENUM!{enum SPVPRIORITY { |
| SPVPRI_NORMAL = 0, |
| SPVPRI_ALERT = 1 << 0, |
| SPVPRI_OVER = 1 << 1, |
| }} |
| STRUCT!{struct SPVOICESTATUS { |
| ulCurrentStream: ::ULONG, |
| ulLastStreamQueued: ::ULONG, |
| hrLastResult: ::HRESULT, |
| dwRunningState: ::DWORD, |
| ulInputWordPos: ::ULONG, |
| ulInputWordLen: ::ULONG, |
| ulInputSentPos: ::ULONG, |
| ulInputSentLen: ::ULONG, |
| lBookmarkId: ::LONG, |
| PhonemeId: SPPHONEID, |
| VisemeId: SPVISEMES, |
| dwReserved1: ::DWORD, |
| dwReserved2: ::DWORD, |
| }} |
| FLAGS!{enum SPEAKFLAGS { |
| SPF_DEFAULT = 0, |
| SPF_ASYNC = 1 << 0, |
| SPF_PURGEBEFORESPEAK = 1 << 1, |
| SPF_IS_FILENAME = 1 << 2, |
| SPF_IS_XML = 1 << 3, |
| SPF_IS_NOT_XML = 1 << 4, |
| SPF_PERSIST_XML = 1 << 5, |
| SPF_NLP_SPEAK_PUNC = 1 << 6, |
| SPF_PARSE_SAPI = 1 << 7, |
| SPF_PARSE_SSML = 1 << 8, |
| }} |
| pub const SPF_PARSE_AUTODETECT: SPEAKFLAGS = SPF_DEFAULT; |
| pub const SPF_NLP_MASK: SPEAKFLAGS = SPF_NLP_SPEAK_PUNC; |
| pub const SPF_PARSE_MASK: i32 = SPF_PARSE_SAPI.0 as i32 | SPF_PARSE_SSML.0 as i32; |
| pub const SPF_VOICE_MASK: i32 = |
| SPF_ASYNC.0 as i32 | SPF_PURGEBEFORESPEAK.0 as i32 | SPF_IS_FILENAME.0 as i32 | SPF_IS_XML.0 as i32 | |
| SPF_IS_NOT_XML.0 as i32 | SPF_NLP_MASK.0 as i32 | SPF_PERSIST_XML.0 as i32 | SPF_PARSE_MASK; |
| pub const SPF_UNUSED_FLAGS: i32 = !SPF_VOICE_MASK; |
| RIDL!( |
| interface ISpVoice(ISpVoiceVtbl): ISpEventSource(ISpEventSourceVtbl) { |
| fn SetOutput(&mut self, pUnkOutput: *mut ::IUnknown, fAllowFormatChanges: ::BOOL) -> ::HRESULT, |
| fn GetOutputObjectToken(&mut self, ppObjectToken: *mut *mut ISpObjectToken) -> ::HRESULT, |
| fn GetOutputStream(&mut self, ppStream: *mut *mut ISpStreamFormat) -> ::HRESULT, |
| fn Pause(&mut self) -> ::HRESULT, |
| fn Resume(&mut self) -> ::HRESULT, |
| fn SetVoice(&mut self, pToken: *mut ISpObjectToken) -> ::HRESULT, |
| fn GetVoice(&mut self, ppToken: *mut *mut ISpObjectToken) -> ::HRESULT, |
| fn Speak( |
| &mut self, pwcs: ::LPCWSTR, dwFlags: ::DWORD, pulStreamNumber: *mut ::ULONG |
| ) -> ::HRESULT, |
| fn SpeakStream( |
| &mut self, pStream: *mut ::IStream, dwFlags: ::DWORD, pulStreamNumber: *mut ::ULONG |
| ) -> ::HRESULT, |
| fn GetStatus( |
| &mut self, pStatus: *mut SPVOICESTATUS, ppszLastBookmark: *mut ::LPWSTR |
| ) -> ::HRESULT, |
| fn Skip( |
| &mut self, pItemType: ::LPCWSTR, lNumItems: ::c_long, pulNumSkipped: *mut ::ULONG |
| ) -> ::HRESULT, |
| fn SetPriority(&mut self, ePriority: SPVPRIORITY) -> ::HRESULT, |
| fn GetPriority(&mut self, pePriority: *mut SPVPRIORITY) -> ::HRESULT, |
| fn SetAlertBoundary(&mut self, eBoundary: SPEVENTENUM) -> ::HRESULT, |
| fn GetAlertBoundary(&mut self, peBoundary: *mut SPEVENTENUM) -> ::HRESULT, |
| fn SetRate(&mut self, RateAdjust: ::c_long) -> ::HRESULT, |
| fn GetRate(&mut self, pRateAdjust: *mut ::c_long) -> ::HRESULT, |
| fn SetVolume(&mut self, usVolume: ::USHORT) -> ::HRESULT, |
| fn GetVolume(&mut self, pusVolume: *mut ::USHORT) -> ::HRESULT, |
| fn WaitUntilDone(&mut self, msTimeout: ::ULONG) -> ::HRESULT, |
| fn SetSyncSpeakTimeout(&mut self, msTimeout: ::ULONG) -> ::HRESULT, |
| fn GetSyncSpeakTimeout(&mut self, pmsTimeout: *mut ::ULONG) -> ::HRESULT, |
| fn SpeakCompleteEvent(&mut self) -> ::HANDLE, |
| fn IsUISupported( |
| &mut self, pszTypeOfUI: ::LPCWSTR, pvExtraData: *mut ::c_void, cbExtraData: ::ULONG, |
| pfSupported: *mut ::BOOL |
| ) -> ::HRESULT, |
| fn DisplayUI( |
| &mut self, hwndParent: ::HWND, pszTitle: ::LPCWSTR, pszTypeOfUI: ::LPCWSTR, |
| pvExtraData: *mut ::c_void, cbExtraData: ::ULONG |
| ) -> ::HRESULT |
| } |
| ); |
| DEFINE_GUID!( |
| UuidOfISpVoice, |
| 0x6C44DF74, 0x72B9, 0x4992, 0xA1, 0xEC, 0xEF, 0x99, 0x6E, 0x04, 0x22, 0xD4 |
| ); |
| RIDL!( |
| interface ISpPhrase(ISpPhraseVtbl): IUnknown(IUnknownVtbl) { |
| fn GetPhrase(&mut self, ppCoMemPhrase: *mut *mut SPPHRASE) -> ::HRESULT, |
| fn GetSerializedPhrase(&mut self, ppCoMemPhrase: *mut *mut SPSERIALIZEDPHRASE) -> ::HRESULT, |
| fn GetText( |
| &mut self, ulStart: ::ULONG, ulCount: ::ULONG, fUseTextReplacements: ::BOOL, |
| ppszCoMemText: *mut ::LPWSTR, pbDisplayAttributes: *mut ::BYTE |
| ) -> ::HRESULT, |
| fn Discard(&mut self, dwValueTypes: ::DWORD) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpPhraseAlt(ISpPhraseAltVtbl): ISpPhrase(ISpPhraseVtbl) { |
| fn GetAltInfo( |
| &mut self, pParent: *mut *mut ISpPhrase, pulStartElementInParent: *mut ::ULONG, |
| pcElementsInParent: *mut ::ULONG, pcElementsInAlt: *mut ::ULONG |
| ) -> ::HRESULT, |
| fn Commit(&mut self) -> ::HRESULT |
| } |
| ); |
| ENUM!{enum SPXMLRESULTOPTIONS { |
| SPXRO_SML = 0, |
| SPXRO_Alternates_SML = 1, |
| }} |
| RIDL!( |
| interface ISpPhrase2(ISpPhrase2Vtbl): ISpPhrase(ISpPhraseVtbl) { |
| fn GetXMLResult( |
| &mut self, ppszCoMemXMLResult: *mut ::LPWSTR, Options: SPXMLRESULTOPTIONS |
| ) -> ::HRESULT, |
| fn GetXMLErrorInfo(&mut self, pSemanticErrorInfo: *mut SPSEMANTICERRORINFO) -> ::HRESULT, |
| fn GetAudio( |
| &mut self, ulStartElement: ::ULONG, cElements: ::ULONG, ppStream: *mut *mut ISpStreamFormat |
| ) -> ::HRESULT |
| } |
| ); |
| STRUCT!{struct SPRECORESULTTIMES { |
| ftStreamTime: ::FILETIME, |
| ullLength: ::ULONGLONG, |
| dwTickCount: ::DWORD, |
| ullStart: ::ULONGLONG, |
| }} |
| STRUCT!{struct SPSERIALIZEDRESULT { |
| ulSerializedSize: ::ULONG, |
| }} |
| RIDL!( |
| interface ISpRecoResult(ISpRecoResultVtbl): ISpPhrase(ISpPhraseVtbl) { |
| fn GetResultTimes(&mut self, pTimes: *mut SPRECORESULTTIMES) -> ::HRESULT, |
| fn GetAlternates( |
| &mut self, ulStartElement: ::ULONG, cElements: ::ULONG, ulRequestCount: ::ULONG, |
| ppPhrases: *mut *mut ISpPhraseAlt, pcPhrasesReturned: *mut ::ULONG |
| ) -> ::HRESULT, |
| fn GetAudio( |
| &mut self, ulStartElement: ::ULONG, cElements: ::ULONG, ppStream: *mut *mut ISpStreamFormat |
| ) -> ::HRESULT, |
| fn SpeakAudio( |
| &mut self, ulStartElement: ::ULONG, cElements: ::ULONG, dwFlags: ::DWORD, |
| pulStreamNumber: *mut ::ULONG |
| ) -> ::HRESULT, |
| fn Serialize(&mut self, ppCoMemSerializedResult: *mut *mut SPSERIALIZEDRESULT) -> ::HRESULT, |
| fn ScaleAudio( |
| &mut self, pAudioFormatId: *const ::GUID, pWaveFormatEx: *const ::WAVEFORMATEX |
| ) -> ::HRESULT, |
| fn GetRecoContext(&mut self, ppRecoContext: *mut *mut ISpRecoContext) -> ::HRESULT |
| } |
| ); |
| FLAGS!{enum SPCOMMITFLAGS { |
| SPCF_NONE = 0, |
| SPCF_ADD_TO_USER_LEXICON = 1 << 0, |
| SPCF_DEFINITE_CORRECTION = 1 << 1, |
| }} |
| RIDL!( |
| interface ISpRecoResult2(ISpRecoResult2Vtbl): ISpRecoResult(ISpRecoResultVtbl) { |
| fn CommitAlternate( |
| &mut self, pPhraseAlt: *mut ISpPhraseAlt, ppNewResult: *mut *mut ISpRecoResult |
| ) -> ::HRESULT, |
| fn CommitText( |
| &mut self, ulStartElement: ::ULONG, cElements: ::ULONG, pszCorrectedData: ::LPCWSTR, |
| eCommitFlags: ::DWORD |
| ) -> ::HRESULT, |
| fn SetTextFeedback(&mut self, pszFeedback: ::LPCWSTR, fSuccessful: ::BOOL) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpXMLRecoResult(ISpXMLRecoResultVtbl): ISpRecoResult(ISpRecoResultVtbl) { |
| fn GetXMLResult( |
| &mut self, ppszCoMemXMLResult: *mut ::LPWSTR, Options: SPXMLRESULTOPTIONS |
| ) -> ::HRESULT, |
| fn GetXMLErrorInfo(&mut self, pSemanticErrorInfo: *mut SPSEMANTICERRORINFO) -> ::HRESULT |
| } |
| ); |
| STRUCT!{struct SPTEXTSELECTIONINFO { |
| ulStartActiveOffset: ::ULONG, |
| cchActiveChars: ::ULONG, |
| ulStartSelection: ::ULONG, |
| cchSelection: ::ULONG, |
| }} |
| ENUM!{enum SPWORDPRONOUNCEABLE { |
| SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE = 0, |
| SPWP_UNKNOWN_WORD_PRONOUNCEABLE = 1, |
| SPWP_KNOWN_WORD_PRONOUNCEABLE = 2, |
| }} |
| ENUM!{enum SPGRAMMARSTATE { |
| SPGS_DISABLED = 0, |
| SPGS_ENABLED = 1, |
| SPGS_EXCLUSIVE = 3, |
| }} |
| ENUM!{enum SPCONTEXTSTATE { |
| SPCS_DISABLED = 0, |
| SPCS_ENABLED = 1, |
| }} |
| ENUM!{enum SPRULESTATE { |
| SPRS_INACTIVE = 0, |
| SPRS_ACTIVE = 1, |
| SPRS_ACTIVE_WITH_AUTO_PAUSE = 3, |
| SPRS_ACTIVE_USER_DELIMITED = 4, |
| }} |
| pub const SP_STREAMPOS_ASAP: ::INT = 0; |
| pub const SP_STREAMPOS_REALTIME: ::INT = -1; |
| pub const SPRULETRANS_TEXTBUFFER: SPSTATEHANDLE = -1isize as SPSTATEHANDLE; |
| pub const SPRULETRANS_WILDCARD: SPSTATEHANDLE = -2isize as SPSTATEHANDLE; |
| pub const SPRULETRANS_DICTATION: SPSTATEHANDLE = -3isize as SPSTATEHANDLE; |
| ENUM!{enum SPGRAMMARWORDTYPE { |
| SPWT_DISPLAY = 0, |
| SPWT_LEXICAL = 1, |
| SPWT_PRONUNCIATION = 2, |
| SPWT_LEXICAL_NO_SPECIAL_CHARS = 3, |
| }} |
| STRUCT!{struct SPPROPERTYINFO { |
| pszName: ::LPCWSTR, |
| ulId: ::ULONG, |
| pszValue: ::LPCWSTR, |
| vValue: ::VARIANT, |
| }} |
| FLAGS!{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, |
| SPRAF_Root = 1 << 6, |
| SPRAF_AutoPause = 1 << 16, |
| SPRAF_UserDelimited = 1 << 17, |
| }} |
| RIDL!( |
| interface ISpGrammarBuilder(ISpGrammarBuilderVtbl): IUnknown(IUnknownVtbl) { |
| fn ResetGrammar(&mut self, NewLanguage: ::WORD) -> ::HRESULT, |
| fn GetRule( |
| &mut self, pszRuleName: ::LPCWSTR, dwRuleId: ::DWORD, dwAttributes: ::DWORD, |
| fCreateIfNotExist: ::BOOL, phInitialState: *mut SPSTATEHANDLE |
| ) -> ::HRESULT, |
| fn ClearRule(&mut self, hState: SPSTATEHANDLE) -> ::HRESULT, |
| fn CreateNewState(&mut self, hState: SPSTATEHANDLE, phState: *mut SPSTATEHANDLE) -> ::HRESULT, |
| fn AddWordTransition( |
| &mut self, hFromState: SPSTATEHANDLE, hToState: SPSTATEHANDLE, psz: ::LPCWSTR, |
| pszSeparators: ::LPCWSTR, eWordType: SPGRAMMARWORDTYPE, Weight: ::c_float, |
| pPropInfo: *const SPPROPERTYINFO |
| ) -> ::HRESULT, |
| fn AddRuleTransition( |
| &mut self, hFromState: SPSTATEHANDLE, hToState: SPSTATEHANDLE, hRule: SPSTATEHANDLE, |
| Weight: ::c_float, pPropInfo: *const SPPROPERTYINFO |
| ) -> ::HRESULT, |
| fn AddResource( |
| &mut self, hRuleState: SPSTATEHANDLE, pszResourceName: ::LPCWSTR, |
| pszResourceValue: ::LPCWSTR |
| ) -> ::HRESULT, |
| fn Commit(&mut self, dwReserved: ::DWORD) -> ::HRESULT |
| } |
| ); |
| ENUM!{enum SPLOADOPTIONS { |
| SPLO_STATIC = 0, |
| SPLO_DYNAMIC = 1, |
| }} |
| RIDL!( |
| interface ISpRecoGrammar(ISpRecoGrammarVtbl): ISpGrammarBuilder(ISpGrammarBuilderVtbl) { |
| fn GetGrammarId(&mut self, pullGrammarId: *mut ::ULONGLONG) -> ::HRESULT, |
| fn GetRecoContext(&mut self, ppRecoCtxt: *mut *mut ISpRecoContext) -> ::HRESULT, |
| fn LoadCmdFromFile(&mut self, pszFileName: ::LPCWSTR, Options: SPLOADOPTIONS) -> ::HRESULT, |
| fn LoadCmdFromObject( |
| &mut self, rcid: ::REFCLSID, pszGrammarName: ::LPCWSTR, Options: SPLOADOPTIONS |
| ) -> ::HRESULT, |
| fn LoadCmdFromResource( |
| &mut self, hModule: ::HMODULE, pszResourceName: ::LPCWSTR, pszResourceType: ::LPCWSTR, |
| wLanguage: ::WORD, Options: SPLOADOPTIONS |
| ) -> ::HRESULT, |
| fn LoadCmdFromMemory( |
| &mut self, pGrammar: *const SPBINARYGRAMMAR, Options: SPLOADOPTIONS |
| ) -> ::HRESULT, |
| fn LoadCmdFromProprietaryGrammar( |
| &mut self, rguidParam: ::REFGUID, pszStringParam: ::LPCWSTR, pvDataPrarm: *const ::c_void, |
| cbDataSize: ::ULONG, Options: SPLOADOPTIONS |
| ) -> ::HRESULT, |
| fn SetRuleState( |
| &mut self, pszName: ::LPCWSTR, pReserved: *mut ::c_void, NewState: SPRULESTATE |
| ) -> ::HRESULT, |
| fn SetRuleIdState(&mut self, ulRuleId: ::ULONG, NewState: SPRULESTATE) -> ::HRESULT, |
| fn LoadDictation(&mut self, pszTopicName: ::LPCWSTR, Options: SPLOADOPTIONS) -> ::HRESULT, |
| fn UnloadDictation(&mut self) -> ::HRESULT, |
| fn SetDictationState(&mut self, NewState: SPRULESTATE) -> ::HRESULT, |
| fn SetWordSequenceData( |
| &mut self, pText: *const ::WCHAR, cchText: ::ULONG, pInfo: *const SPTEXTSELECTIONINFO |
| ) -> ::HRESULT, |
| fn SetTextSelection(&mut self, pInfo: *const SPTEXTSELECTIONINFO) -> ::HRESULT, |
| fn IsPronounceable( |
| &mut self, pszWord: ::LPCWSTR, pWordPronounceable: *mut SPWORDPRONOUNCEABLE |
| ) -> ::HRESULT, |
| fn SetGrammarState(&mut self, eGrammarState: SPGRAMMARSTATE) -> ::HRESULT, |
| fn SaveCmd(&mut self, pStream: *mut ::IStream, ppszCoMemErrorText: *mut ::LPWSTR) -> ::HRESULT, |
| fn GetGrammarState(&mut self, peGrammarState: *mut SPGRAMMARSTATE) -> ::HRESULT |
| } |
| ); |
| ENUM!{enum SPMATCHINGMODE { |
| AllWords = 0, |
| Subsequence = 1, |
| OrderedSubset = 3, |
| SubsequenceContentRequired = 5, |
| OrderedSubsetContentRequired = 7, |
| }} |
| ENUM!{enum PHONETICALPHABET { |
| PA_Ipa = 0, |
| PA_Ups = 1, |
| PA_Sapi = 2, |
| }} |
| RIDL!( |
| interface ISpGrammarBuilder2(ISpGrammarBuilder2Vtbl): IUnknown(IUnknownVtbl) { |
| fn AddTextSubset( |
| &mut self, hFromState: SPSTATEHANDLE, hToState: SPSTATEHANDLE, psz: ::LPCWSTR, |
| eMatchMode: SPMATCHINGMODE |
| ) -> ::HRESULT, |
| fn SetPhoneticAlphabet(&mut self, phoneticALphabet: PHONETICALPHABET) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpRecoGrammar2(ISpRecoGrammar2Vtbl): IUnknown(IUnknownVtbl) { |
| fn GetRules(&mut self, ppCoMemRules: *mut *mut SPRULE, puNumRules: *mut ::UINT) -> ::HRESULT, |
| fn LoadCmdFromFile2( |
| &mut self, pszFileName: ::LPCWSTR, Options: SPLOADOPTIONS, pszSharingUri: ::LPCWSTR, |
| pszBaseUri: ::LPCWSTR |
| ) -> ::HRESULT, |
| fn LoadCmdFromMemory2( |
| &mut self, pGrammar: *const SPBINARYGRAMMAR, Options: SPLOADOPTIONS, |
| pszSharingUri: ::LPCWSTR, pszBaseUri: ::LPCWSTR |
| ) -> ::HRESULT, |
| fn SetRulePriority( |
| &mut self, pszRuleName: ::LPCWSTR, ulRuleId: ::ULONG, nRulePriority: ::c_int |
| ) -> ::HRESULT, |
| fn SetRuleWeight( |
| &mut self, pszRuleName: ::LPCWSTR, ulRuleId: ::ULONG, flWeight: ::c_float |
| ) -> ::HRESULT, |
| fn SetDictationWeight(&mut self, flWeight: ::c_float) -> ::HRESULT, |
| fn SetGrammarLoader(&mut self, pLoader: *mut ISpeechResourceLoader) -> ::HRESULT, |
| fn SetSMLSecurityManager( |
| &mut self, pSMLSecurityManager: *mut ::IInternetSecurityManager |
| ) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpeechResourceLoader(ISpeechResourceLoaderVtbl): IDispatch(IDispatchVtbl) { |
| fn LoadResource( |
| &mut self, bstrResourceUri: ::BSTR, fAlwaysReload: ::VARIANT_BOOL, |
| pStream: *mut *mut ::IUnknown, pbstrMIMEType: *mut ::BSTR, pfModified: *mut ::VARIANT_BOOL, |
| pbstrRedirectUrl: *mut ::BSTR |
| ) -> ::HRESULT, |
| fn GetLocalCopy( |
| &mut self, bstrResourceUri: ::BSTR, pbstrLocalPath: *mut ::BSTR, |
| pbstrMIMEType: *mut ::BSTR, pbstrRedirectUrl: *mut ::BSTR |
| ) -> ::HRESULT, |
| fn ReleaseLocalCopy(&mut self, pbstrLocalPath: ::BSTR) -> ::HRESULT |
| } |
| ); |
| STRUCT!{nodebug struct SPRECOCONTEXTSTATUS { |
| eInterference: SPINTERFERENCE, |
| szRequestTypeOfUI: [::WCHAR; 255], |
| dwReserved1: ::DWORD, |
| dwReserved2: ::DWORD, |
| }} |
| FLAGS!{enum SPBOOKMARKOPTIONS { |
| SPBO_NONE = 0, |
| SPBO_PAUSE = 1 << 0, |
| SPBO_AHEAD = 1 << 1, |
| SPBO_TIME_UNITS = 1 << 2, |
| }} |
| FLAGS!{enum SPAUDIOOPTIONS { |
| SPAO_NONE = 0, |
| SPAO_RETAIN_AUDIO = 1 << 0, |
| }} |
| RIDL!( |
| interface ISpRecoContext(ISpRecoContextVtbl): ISpEventSource(ISpEventSourceVtbl) { |
| fn GetRecognizer(&mut self, ppRecognizer: *mut *mut ISpRecognizer) -> ::HRESULT, |
| fn CreateGrammer( |
| &mut self, ullGrammarId: ::ULONGLONG, ppGrammar: *mut *mut ISpRecoGrammar |
| ) -> ::HRESULT, |
| fn GetStatus(&mut self, pState: *mut SPRECOCONTEXTSTATUS) -> ::HRESULT, |
| fn GetMaxAlternates(&mut self, pcAlternates: *mut ::ULONG) -> ::HRESULT, |
| fn SetMaxAlternates(&mut self, cAlternates: ::ULONG) -> ::HRESULT, |
| fn SetAudioOptions( |
| &mut self, Options: SPAUDIOOPTIONS, pAudioFormatId: *const ::GUID, |
| pWaveFormatEx: *const ::WAVEFORMATEX |
| ) -> ::HRESULT, |
| fn GetAudioOptions( |
| &mut self, pOptions: *mut SPAUDIOOPTIONS, pAudioFormatId: *mut ::GUID, |
| ppCoMemWFEX: *mut *mut ::WAVEFORMATEX |
| ) -> ::HRESULT, |
| fn DeserializeResult( |
| &mut self, pSerializedResult: *const SPSERIALIZEDRESULT, ppResult: *mut *mut ISpRecoResult |
| ) -> ::HRESULT, |
| fn Bookmark( |
| &mut self, Options: SPBOOKMARKOPTIONS, ullStreamPosition: ::ULONGLONG, |
| lparamEvent: ::LPARAM |
| ) -> ::HRESULT, |
| fn SetAdaptionData(&mut self, pAdaptionData: ::LPCWSTR, cch: ::ULONG) -> ::HRESULT, |
| fn Pause(&mut self, dwReserved: ::DWORD) -> ::HRESULT, |
| fn Resume(&mut self, dwReserved: ::DWORD) -> ::HRESULT, |
| fn SetVoice(&mut self, pVoice: *mut ISpVoice, fAllowFormatChanges: ::BOOL) -> ::HRESULT, |
| fn GetVoice(&mut self, ppVoice: *mut *mut ISpVoice) -> ::HRESULT, |
| fn SetVoicePurgeEvent(&mut self, ullEventIntereset: ::ULONGLONG) -> ::HRESULT, |
| fn GetVoicePurgeEvent(&mut self, pullEventIntereset: *mut ::ULONGLONG) -> ::HRESULT, |
| fn SetContextState(&mut self, eContextState: SPCONTEXTSTATE) -> ::HRESULT, |
| fn GetContextState(&mut self, peContextState: *mut SPCONTEXTSTATE) -> ::HRESULT |
| } |
| ); |
| FLAGS!{enum SPGRAMMAROPTIONS { |
| SPGO_SAPI = 0x1, |
| SPGO_SRGS = 0x2, |
| SPGO_UPS = 0x4, |
| SPGO_SRGS_MS_SCRIPT = 0x8, |
| SPGO_SRGS_W3C_SCRIPT = 0x100, |
| SPGO_SRGS_STG_SCRIPT = 0x200, |
| SPGO_SRGS_SCRIPT = |
| SPGO_SRGS.0 | SPGO_SRGS_MS_SCRIPT.0 | SPGO_SRGS_W3C_SCRIPT.0 | |
| SPGO_SRGS_STG_SCRIPT.0, |
| SPGO_FILE = 0x10, |
| SPGO_HTTP = 0x20, |
| SPGO_RES = 0x40, |
| SPGO_OBJECT = 0x80, |
| SPGO_DEFAULT = 0x3fb, |
| SPGO_ALL = 0x3ff, |
| }} |
| FLAGS!{enum SPADAPTATIONSETTINGS { |
| SPADS_Default = 0, |
| SPADS_CurrentRecognizer = 0x1, |
| SPADS_RecoProfile = 0x2, |
| SPADS_Immediate = 0x4, |
| SPADS_Reset = 0x8, |
| SPADS_HighVolumeDataSource = 0x10, |
| }} |
| ENUM!{enum SPADAPTATIONRELEVANCE { |
| SPAR_Unknown = 0, |
| SPAR_Low = 1, |
| SPAR_Medium = 2, |
| SPAR_High = 3, |
| }} |
| RIDL!( |
| interface ISpRecoContext2(ISpRecoContext2Vtbl): IUnknown(IUnknownVtbl) { |
| fn SetGrammarOptions(&mut self, eGrammarOptions: ::DWORD) -> ::HRESULT, |
| fn GetGrammarOptions(&mut self, peGrammarOptions: *mut ::DWORD) -> ::HRESULT, |
| fn SetAdaptationData2( |
| &mut self, pAdaptationData: ::LPCWSTR, cch: ::ULONG, pTopicName: ::LPCWSTR, |
| eAdaptationSettings: ::DWORD, eRelevance: SPADAPTATIONRELEVANCE |
| ) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpProperties(ISpPropertiesVtbl): IUnknown(IUnknownVtbl) { |
| fn SetPropertyNum(&mut self, pName: ::LPCWSTR, lValue: ::LONG) -> ::HRESULT, |
| fn GetPropertyNum(&mut self, pName: ::LPCWSTR, plValue: *mut ::LONG) -> ::HRESULT, |
| fn SetPropertyString(&mut self, pName: ::LPCWSTR, pValue: ::LPCWSTR) -> ::HRESULT, |
| fn GetPropertyString(&mut self, pName: ::LPCWSTR, ppCoMemValue: *mut ::LPWSTR) -> ::HRESULT |
| } |
| ); |
| STRUCT!{struct SPRECOGNIZERSTATUS { |
| AudioStatus: SPAUDIOSTATUS, |
| ullRecognitionStreamPos: ::ULONGLONG, |
| ulStreamNumber: ::ULONG, |
| ulNumActive: ::ULONG, |
| clsidEngine: ::CLSID, |
| cLangIDs: ::ULONG, |
| aLangID: [::WORD; 20], |
| ullRecognitionStreamTime: ::ULONGLONG, |
| }} |
| ENUM!{enum SPWAVEFORMATTYPE { |
| SPWF_INPUT = 0, |
| SPWF_SRENGINE = 1, |
| }} |
| pub type SPSTREAMFORMATTYPE = SPWAVEFORMATTYPE; |
| ENUM!{enum SPRECOSTATE { |
| SPRST_INACTIVE = 0, |
| SPRST_ACTIVE = 1, |
| SPRST_ACTIVE_ALWAYS = 2, |
| SPRST_INACTIVE_WITH_PURGE = 3, |
| SPRST_NUM_STATES = 4, |
| }} |
| RIDL!( |
| interface ISpRecognizer(ISpRecognizerVtbl): ISpProperties(ISpPropertiesVtbl) { |
| fn SetRecognizer(&mut self, pRecognizer: *mut ISpObjectToken) -> ::HRESULT, |
| fn GetRecognizer(&mut self, ppRecognizer: *mut *mut ISpObjectToken) -> ::HRESULT, |
| fn SetInput(&mut self, pUnkInput: *mut ::IUnknown, fAllowFormatChanges: ::BOOL) -> ::HRESULT, |
| fn GetInputObjectToken(&mut self, ppToken: *mut *mut ISpObjectToken) -> ::HRESULT, |
| fn GetInputStream(&mut self, ppStream: *mut *mut ISpStreamFormat) -> ::HRESULT, |
| fn CreateRecoContext(&mut self, ppNewCtxt: *mut *mut ISpRecoContext) -> ::HRESULT, |
| fn GetRecoProfile(&mut self, ppToken: *mut *mut ISpObjectToken) -> ::HRESULT, |
| fn SetRecoProfile(&mut self, pToken: *mut ISpObjectToken) -> ::HRESULT, |
| fn IsSharedInstance(&mut self) -> ::HRESULT, |
| fn GetRecoState(&mut self, pState: *mut SPRECOSTATE) -> ::HRESULT, |
| fn SetRecoState(&mut self, NewState: SPRECOSTATE) -> ::HRESULT, |
| fn GetStatus(&mut self, pStatus: *mut SPRECOGNIZERSTATUS) -> ::HRESULT, |
| fn GetFormat( |
| &mut self, WaveFormatType: SPSTREAMFORMATTYPE, pFormatId: *mut ::GUID, |
| ppCoMemWFEX: *mut ::WAVEFORMATEX |
| ) -> ::HRESULT, |
| fn IsUISupported( |
| &mut self, pszTypeOfUI: ::LPCWSTR, pvExtraData: *mut ::c_void, cbExtraData: ::ULONG, |
| pfSupported: *mut ::BOOL |
| ) -> ::HRESULT, |
| fn DisplayUI( |
| &mut self, hwndParent: ::HWND, pszTitle: ::LPCWSTR, pszTypeOfUI: ::LPCWSTR, |
| pvExtraData: *mut ::c_void, cbExtraData: ::ULONG |
| ) -> ::HRESULT, |
| fn EmulateRecognition(&mut self, pPhrase: *mut ISpPhrase) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpSerializeState(ISpSerializeStateVtbl): IUnknown(IUnknownVtbl) { |
| fn GetSerializedState( |
| &mut self, ppbData: *mut *mut ::BYTE, pulSize: *mut ::ULONG, dwReserved: ::DWORD |
| ) -> ::HRESULT, |
| fn SetSerializedState( |
| &mut self, pbData: *mut ::BYTE, ulSize: ::ULONG, dwReserved: ::DWORD |
| ) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpRecognizer2(ISpRecognizer2Vtbl): IUnknown(IUnknownVtbl) { |
| fn EmulateRecognitionEx( |
| &mut self, pPhrase: *mut ISpPhrase, dwCompareFlags: ::DWORD |
| ) -> ::HRESULT, |
| fn SetTrainingState( |
| &mut self, fDoingTraining: ::BOOL, fAdaptFromTrainingData: ::BOOL |
| ) -> ::HRESULT, |
| fn ResetAcousticModelAdaptation(&mut self) -> ::HRESULT |
| } |
| ); |
| ENUM!{enum SPCATEGORYTYPE { |
| SPCT_COMMAND = 0, |
| SPCT_DICTATION, |
| SPCT_SLEEP, |
| SPCT_SUB_COMMAND, |
| SPCT_SUB_DICTATION, |
| }} |
| RIDL!( |
| interface ISpRecoCategory(ISpRecoCategoryVtbl): IUnknown(IUnknownVtbl) { |
| fn GetType(&mut self, peCategoryType: *mut SPCATEGORYTYPE) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpRecognizer3(ISpRecognizer3Vtbl): IUnknown(IUnknownVtbl) { |
| fn GetCategory( |
| &mut self, categoryType: SPCATEGORYTYPE, ppCategory: *mut *mut ISpRecoCategory |
| ) -> ::HRESULT, |
| fn SetActiveCategory(&mut self, pCategory: *mut ISpRecoCategory) -> ::HRESULT, |
| fn GetActiveCategory(&mut self, ppCategory: *mut *mut ISpRecoCategory) -> ::HRESULT |
| } |
| ); |
| STRUCT!{struct SPNORMALIZATIONLIST { |
| ulSize: ::ULONG, |
| ppszzNormalizedList: *mut *mut ::WCHAR, |
| }} |
| RIDL!( |
| interface ISpEnginePronunciation(ISpEnginePronunciationVtbl): IUnknown(IUnknownVtbl) { |
| fn Normalize( |
| &mut self, pszWord: ::LPCWSTR, pszLeftContext: ::LPCWSTR, pszRightContext: ::LPCWSTR, |
| LangID: ::WORD, pNormalizationList: *mut SPNORMALIZATIONLIST |
| ) -> ::HRESULT, |
| fn GetPronunciations( |
| &mut self, pszWord: ::LPCWSTR, pszLeftContext: ::LPCWSTR, pszRightContext: ::LPCWSTR, |
| LangID: ::WORD, pEnginePronunciationList: *mut SPWORDPRONUNCIATIONLIST |
| ) -> ::HRESULT |
| } |
| ); |
| STRUCT!{struct SPDISPLAYTOKEN { |
| pszLexical: *const ::WCHAR, |
| pszDisplay: *const ::WCHAR, |
| bDisplayAttributes: ::BYTE, |
| }} |
| STRUCT!{struct SPDISPLAYPHRASE { |
| ulNumTokens: ::ULONG, |
| pTokens: *mut SPDISPLAYTOKEN, |
| }} |
| RIDL!( |
| interface ISpDisplayAlternates(ISpDisplayAlternatesVtbl): IUnknown(IUnknownVtbl) { |
| fn GetDisplayAlternates( |
| &mut self, pPhrase: *const SPDISPLAYPHRASE, cRequestCount: ::ULONG, |
| ppCoMemPhrases: *mut *mut SPDISPLAYPHRASE, pcPhrasesReturned: *mut ::ULONG |
| ) -> ::HRESULT, |
| fn SetFullStopTrailSpace(&mut self, ulTrailSpace: ::ULONG) -> ::HRESULT |
| } |
| ); |
| pub type SpeechLanguageId = ::c_long; |
| ENUM!{enum DISPID_SpeechDataKey { |
| DISPID_SDKSetBinaryValue = 1, |
| DISPID_SDKGetBinaryValue, |
| DISPID_SDKSetStringValue, |
| DISPID_SDKGetStringValue, |
| DISPID_SDKSetLongValue, |
| DISPID_SDKGetlongValue, |
| DISPID_SDKOpenKey, |
| DISPID_SDKCreateKey, |
| DISPID_SDKDeleteKey, |
| DISPID_SDKDeleteValue, |
| DISPID_SDKEnumKeys, |
| DISPID_SDKEnumValues, |
| }} |
| ENUM!{enum DISPID_SpeechObjectToken { |
| DISPID_SOTId = 1, |
| DISPID_SOTDataKey, |
| DISPID_SOTCategory, |
| DISPID_SOTGetDescription, |
| DISPID_SOTSetId, |
| DISPID_SOTGetAttribute, |
| DISPID_SOTCreateInstance, |
| DISPID_SOTRemove, |
| DISPID_SOTGetStorageFileName, |
| DISPID_SOTRemoveStorageFileName, |
| DISPID_SOTIsUISupported, |
| DISPID_SOTDisplayUI, |
| DISPID_SOTMatchesAttributes, |
| }} |
| ENUM!{enum SpeechDataKeyLocation { |
| SDKLDefaultLocation = SPDKL_DefaultLocation.0, |
| SDKLCurrentUser = SPDKL_CurrentUser.0, |
| SDKLLocalMachine = SPDKL_LocalMachine.0, |
| SDKLCurrentConfig = SPDKL_CurrentConfig.0, |
| }} |
| ENUM!{enum SpeechTokenContext { |
| STCInprocServer = ::CLSCTX_INPROC_SERVER, |
| STCInprocHandler = ::CLSCTX_INPROC_HANDLER, |
| STCLocalServer = ::CLSCTX_LOCAL_SERVER, |
| STCRemoteServer = ::CLSCTX_REMOTE_SERVER, |
| STCAll = ::CLSCTX_INPROC_SERVER | ::CLSCTX_INPROC_HANDLER | |
| ::CLSCTX_LOCAL_SERVER | ::CLSCTX_REMOTE_SERVER, |
| }} |
| ENUM!{enum SpeechTokenShellFolder { |
| STSF_AppData = 0x1a, |
| STSF_LocalAppData = 0x1c, |
| STSF_CommonAppData = 0x23, |
| STSF_FlagCreate = 0x8000, |
| }} |
| ENUM!{enum DISPID_SpeechObjectTokens { |
| DISPID_SOTsCount = 1, |
| DISPID_SOTsItem = ::DISPID_VALUE as u32, |
| DISPID_SOTs_NewEnum = ::DISPID_NEWENUM as u32, |
| }} |
| ENUM!{enum DISPID_SpeechObjectTokenCategory { |
| DISPID_SOTCId = 1, |
| DISPID_SOTCDefault, |
| DISPID_SOTCSetId, |
| DISPID_SOTCGetDataKey, |
| DISPID_SOTCEnumerateTokens, |
| }} |
| ENUM!{enum SpeechAudioFormatType { |
| SAFTDefault = -1i32 as u32, |
| SAFTNoAssignedFormat = 0, |
| SAFTText = 1, |
| SAFTNonStandardFormat = 2, |
| SAFTExtendedAudioFormat = 3, |
| SAFT8kHz8BitMono = 4, |
| SAFT8kHz8BitStereo = 5, |
| SAFT8kHz16BitMono = 6, |
| SAFT8kHz16BitStereo = 7, |
| SAFT11kHz8BitMono = 8, |
| SAFT11kHz8BitStereo = 9, |
| SAFT11kHz16BitMono = 10, |
| SAFT11kHz16BitStereo = 11, |
| SAFT12kHz8BitMono = 12, |
| SAFT12kHz8BitStereo = 13, |
| SAFT12kHz16BitMono = 14, |
| SAFT12kHz16BitStereo = 15, |
| SAFT16kHz8BitMono = 16, |
| SAFT16kHz8BitStereo = 17, |
| SAFT16kHz16BitMono = 18, |
| SAFT16kHz16BitStereo = 19, |
| SAFT22kHz8BitMono = 20, |
| SAFT22kHz8BitStereo = 21, |
| SAFT22kHz16BitMono = 22, |
| SAFT22kHz16BitStereo = 23, |
| SAFT24kHz8BitMono = 24, |
| SAFT24kHz8BitStereo = 25, |
| SAFT24kHz16BitMono = 26, |
| SAFT24kHz16BitStereo = 27, |
| SAFT32kHz8BitMono = 28, |
| SAFT32kHz8BitStereo = 29, |
| SAFT32kHz16BitMono = 30, |
| SAFT32kHz16BitStereo = 31, |
| SAFT44kHz8BitMono = 32, |
| SAFT44kHz8BitStereo = 33, |
| SAFT44kHz16BitMono = 34, |
| SAFT44kHz16BitStereo = 35, |
| SAFT48kHz8BitMono = 36, |
| SAFT48kHz8BitStereo = 37, |
| SAFT48kHz16BitMono = 38, |
| SAFT48kHz16BitStereo = 39, |
| SAFTTrueSpeech_8kHz1BitMono = 40, |
| SAFTCCITT_ALaw_8kHzMono = 41, |
| SAFTCCITT_ALaw_8kHzStereo = 42, |
| SAFTCCITT_ALaw_11kHzMono = 43, |
| SAFTCCITT_ALaw_11kHzStereo = 44, |
| SAFTCCITT_ALaw_22kHzMono = 45, |
| SAFTCCITT_ALaw_22kHzStereo = 46, |
| SAFTCCITT_ALaw_44kHzMono = 47, |
| SAFTCCITT_ALaw_44kHzStereo = 48, |
| SAFTCCITT_uLaw_8kHzMono = 49, |
| SAFTCCITT_uLaw_8kHzStereo = 50, |
| SAFTCCITT_uLaw_11kHzMono = 51, |
| SAFTCCITT_uLaw_11kHzStereo = 52, |
| SAFTCCITT_uLaw_22kHzMono = 53, |
| SAFTCCITT_uLaw_22kHzStereo = 54, |
| SAFTCCITT_uLaw_44kHzMono = 55, |
| SAFTCCITT_uLaw_44kHzStereo = 56, |
| SAFTADPCM_8kHzMono = 57, |
| SAFTADPCM_8kHzStereo = 58, |
| SAFTADPCM_11kHzMono = 59, |
| SAFTADPCM_11kHzStereo = 60, |
| SAFTADPCM_22kHzMono = 61, |
| SAFTADPCM_22kHzStereo = 62, |
| SAFTADPCM_44kHzMono = 63, |
| SAFTADPCM_44kHzStereo = 64, |
| SAFTGSM610_8kHzMono = 65, |
| SAFTGSM610_11kHzMono = 66, |
| SAFTGSM610_22kHzMono = 67, |
| SAFTGSM610_44kHzMono = 68, |
| }} |
| ENUM!{enum DISPID_SpeechAudioFormat { |
| DISPID_SAFType = 1, |
| DISPID_SAFGuid, |
| DISPID_SAFGetWaveFormatEx, |
| DISPID_SAFSetWaveFormatEx, |
| }} |
| ENUM!{enum DISPID_SpeechBaseStream { |
| DISPID_SBSFormat = 1, |
| DISPID_SBSRead, |
| DISPID_SBSWrite, |
| DISPID_SBSSeek, |
| }} |
| ENUM!{enum SpeechStreamSeekPositionType { |
| SSSPTRelativeToStart = ::STREAM_SEEK_SET.0, |
| SSSPTRelativeToCurrentPosition = ::STREAM_SEEK_CUR.0, |
| SSSPTRelativeToEnd = ::STREAM_SEEK_END.0, |
| }} |
| ENUM!{enum DISPID_SpeechAudio { |
| DISPID_SAStatus = 200, |
| DISPID_SABufferInfo, |
| DISPID_SADefaultFormat, |
| DISPID_SAVolume, |
| DISPID_SABufferNotifySize, |
| DISPID_SAEventHandle, |
| DISPID_SASetState, |
| }} |
| ENUM!{enum SpeechAudioState { |
| SASClosed = SPAS_CLOSED.0, |
| SASStop = SPAS_STOP.0, |
| SASPause = SPAS_PAUSE.0, |
| SASRun = SPAS_RUN.0, |
| }} |
| ENUM!{enum DISPID_SpeechMMSysAudio { |
| DISPID_SMSADeviceId = 300, |
| DISPID_SMSALineId, |
| DISPID_SMSAMMHandle, |
| }} |
| ENUM!{enum DISPID_SpeechFileStream { |
| DISPID_SFSOpen = 100, |
| DISPID_SFSClose, |
| }} |
| ENUM!{enum SpeechStreamFileMode { |
| SSFMOpenForRead = SPFM_OPEN_READONLY.0, |
| SSFMOpenReadWrite = SPFM_OPEN_READWRITE.0, |
| SSFMCreate = SPFM_CREATE.0, |
| SSFMCreateForWrite = SPFM_CREATE_ALWAYS.0, |
| }} |
| ENUM!{enum DISPID_SpeechCustomStream { |
| DISPID_SCSBaseStream = 100, |
| }} |
| ENUM!{enum DISPID_SpeechMemoryStream { |
| DISPID_SMSSetData = 100, |
| DISPID_SMSGetData, |
| }} |
| ENUM!{enum DISPID_SpeechAudioStatus { |
| DISPID_SASFreeBufferSpace = 1, |
| DISPID_SASNonBlockingIO, |
| DISPID_SASState, |
| DISPID_SASCurrentSeekPosition, |
| DISPID_SASCurrentDevicePosition, |
| }} |
| ENUM!{enum DISPID_SpeechAudioBufferInfo { |
| DISPID_SABIMinNotification = 1, |
| DISPID_SABIBufferSize, |
| DISPID_SABIEventBias, |
| }} |
| ENUM!{enum DISPID_SpeechWaveFormatEx { |
| DISPID_SWFEFormatTag = 1, |
| DISPID_SWFEChannels, |
| DISPID_SWFESamplesPerSec, |
| DISPID_SWFEAvgBytesPerSec, |
| DISPID_SWFEBlockAlign, |
| DISPID_SWFEBitsPerSample, |
| DISPID_SWFEExtraData, |
| }} |
| ENUM!{enum DISPID_SpeechVoice { |
| DISPID_SVStatus = 1, |
| DISPID_SVVoice, |
| DISPID_SVAudioOutput, |
| DISPID_SVAudioOutputStream, |
| DISPID_SVRate, |
| DISPID_SVVolume, |
| DISPID_SVAllowAudioOuputFormatChangesOnNextSet, |
| DISPID_SVEventInterests, |
| DISPID_SVPriority, |
| DISPID_SVAlertBoundary, |
| DISPID_SVSyncronousSpeakTimeout, |
| DISPID_SVSpeak, |
| DISPID_SVSpeakStream, |
| DISPID_SVPause, |
| DISPID_SVResume, |
| DISPID_SVSkip, |
| DISPID_SVGetVoices, |
| DISPID_SVGetAudioOutputs, |
| DISPID_SVWaitUntilDone, |
| DISPID_SVSpeakCompleteEvent, |
| DISPID_SVIsUISupported, |
| DISPID_SVDisplayUI, |
| }} |
| ENUM!{enum SpeechVoicePriority { |
| SVPNormal = SPVPRI_NORMAL.0, |
| SVPAlert = SPVPRI_ALERT.0, |
| SVPOver = SPVPRI_OVER.0, |
| }} |
| FLAGS!{enum SpeechVoiceSpeakFlags { |
| SVSFDefault = SPF_DEFAULT.0, |
| SVSFlagsAsync = SPF_ASYNC.0, |
| SVSFPurgeBeforeSpeak = SPF_PURGEBEFORESPEAK.0, |
| SVSFIsFilename = SPF_IS_FILENAME.0, |
| SVSFIsXML = SPF_IS_XML.0, |
| SVSFIsNotXML = SPF_IS_NOT_XML.0, |
| SVSFPersistXML = SPF_PERSIST_XML.0, |
| SVSFNLPSpeakPunc = SPF_NLP_SPEAK_PUNC.0, |
| SVSFParseSapi = SPF_PARSE_SAPI.0, |
| SVSFParseSsml = SPF_PARSE_SSML.0, |
| SVSFParseMask = SPF_PARSE_MASK as u32, |
| SVSFVoiceMask = SPF_VOICE_MASK as u32, |
| SVSFUnusedFlags = SPF_UNUSED_FLAGS as u32, |
| }} |
| pub const SVSFParseAutodetect: SpeechVoiceSpeakFlags = SVSFDefault; |
| pub const SVSFNLPMask: SpeechVoiceSpeakFlags = SVSFNLPSpeakPunc; |
| FLAGS!{enum SpeechVoiceEvents { |
| SVEStartInputStream = 1 << 1, |
| SVEEndInputStream = 1 << 2, |
| SVEVoiceChange = 1 << 3, |
| SVEBookmark = 1 << 4, |
| SVEWordBoundary = 1 << 5, |
| SVEPhoneme = 1 << 6, |
| SVESentenceBoundary = 1 << 7, |
| SVEViseme = 1 << 8, |
| SVEAudioLevel = 1 << 9, |
| SVEPrivate = 1 << 15, |
| SVEAllEvents = 0x83fe, |
| }} |
| ENUM!{enum DISPID_SpeechVoiceStatus { |
| DISPID_SVSCurrentStreamNumber = 1, |
| DISPID_SVSLastStreamNumberQueued, |
| DISPID_SVSLastResult, |
| DISPID_SVSRunningState, |
| DISPID_SVSInputWordPosition, |
| DISPID_SVSInputWordLength, |
| DISPID_SVSInputSentencePosition, |
| DISPID_SVSInputSentenceLength, |
| DISPID_SVSLastBookmark, |
| DISPID_SVSLastBookmarkId, |
| DISPID_SVSPhonemeId, |
| DISPID_SVSVisemeId, |
| }} |
| ENUM!{enum SpeechRunState { |
| SRSEDone = SPRS_DONE.0, |
| SRSEIsSpeaking = SPRS_IS_SPEAKING.0, |
| }} |
| ENUM!{enum SpeechVisemeType { |
| SVP_0 = 0, |
| SVP_1, |
| SVP_2, |
| SVP_3, |
| SVP_4, |
| SVP_5, |
| SVP_6, |
| SVP_7, |
| SVP_8, |
| SVP_9, |
| SVP_10, |
| SVP_11, |
| SVP_12, |
| SVP_13, |
| SVP_14, |
| SVP_15, |
| SVP_16, |
| SVP_17, |
| SVP_18, |
| SVP_19, |
| SVP_20, |
| SVP_21, |
| }} |
| ENUM!{enum SpeechVisemeFeature { |
| SVF_None = 0, |
| SVF_Stressed = SPVFEATURE_STRESSED.0, |
| SVF_Emphasis = SPVFEATURE_EMPHASIS.0, |
| }} |
| ENUM!{enum DISPID_SpeechVoiceEvent { |
| DISPID_SVEStreamStart = 1, |
| DISPID_SVEStreamEnd, |
| DISPID_SVEVoiceChange, |
| DISPID_SVEBookmark, |
| DISPID_SVEWord, |
| DISPID_SVEPhoneme, |
| DISPID_SVESentenceBoundary, |
| DISPID_SVEViseme, |
| DISPID_SVEAudioLevel, |
| DISPID_SVEEnginePrivate, |
| }} |
| ENUM!{enum DISPID_SpeechRecognizer { |
| DISPID_SRRecognizer = 1, |
| DISPID_SRAllowAudioInputFormatChangesOnNextSet, |
| DISPID_SRAudioInput, |
| DISPID_SRAudioInputStream, |
| DISPID_SRIsShared, |
| DISPID_SRState, |
| DISPID_SRStatus, |
| DISPID_SRProfile, |
| DISPID_SREmulateRecognition, |
| DISPID_SRCreateRecoContext, |
| DISPID_SRGetFormat, |
| DISPID_SRSetPropertyNumber, |
| DISPID_SRGetPropertyNumber, |
| DISPID_SRSetPropertyString, |
| DISPID_SRGetPropertyString, |
| DISPID_SRIsUISupported, |
| DISPID_SRDisplayUI, |
| DISPID_SRGetRecognizers, |
| DISPID_SVGetAudioInputs, |
| DISPID_SVGetProfiles, |
| }} |
| ENUM!{enum SpeechRecognizerState { |
| SRSInactive = SPRST_INACTIVE.0, |
| SRSActive = SPRST_ACTIVE.0, |
| SRSActiveAlways = SPRST_ACTIVE_ALWAYS.0, |
| SRSInactiveWithPurge = SPRST_INACTIVE_WITH_PURGE.0, |
| }} |
| ENUM!{enum SpeechDisplayAttributes { |
| SDA_No_Trailing_Space = 0, |
| SDA_One_Trailing_Space = SPAF_ONE_TRAILING_SPACE.0, |
| SDA_Two_Trailing_Spaces = SPAF_TWO_TRAILING_SPACES.0, |
| SDA_Consume_Leading_Spaces = SPAF_CONSUME_LEADING_SPACES.0, |
| }} |
| ENUM!{enum SpeechFormatType { |
| SFTInput = SPWF_INPUT.0, |
| SFTSREngine = SPWF_SRENGINE.0, |
| }} |
| FLAGS!{enum SpeechEmulationCompareFlags { |
| SECFIgnoreCase = 0x1, |
| SECFIgnoreKanaType = 0x10000, |
| SECFIgnoreWidth = 0x20000, |
| SECFNoSpecialChars = 0x20000000, |
| SECFEmulateResult = 0x40000000, |
| SECFDefault = SECFIgnoreCase.0 | SECFIgnoreKanaType.0 | SECFIgnoreWidth.0, |
| }} |
| ENUM!{enum DISPID_SpeechRecognizerStatus { |
| DISPID_SRSAudioStatus = 1, |
| DISPID_SRSCurrentStreamPosition, |
| DISPID_SRSCurrentStreamNumber, |
| DISPID_SRSNumberOfActiveRules, |
| DISPID_SRSClsidEngine, |
| DISPID_SRSSupportedLanguages, |
| }} |
| ENUM!{enum DISPID_SpeechRecoContext { |
| DISPID_SRCRecognizer = 1, |
| DISPID_SRCAudioInInterferenceStatus, |
| DISPID_SRCRequestedUIType, |
| DISPID_SRCVoice, |
| DISPID_SRAllowVoiceFormatMatchingOnNextSet, |
| DISPID_SRCVoicePurgeEvent, |
| DISPID_SRCEventInterests, |
| DISPID_SRCCmdMaxAlternates, |
| DISPID_SRCState, |
| DISPID_SRCRetainedAudio, |
| DISPID_SRCRetainedAudioFormat, |
| DISPID_SRCPause, |
| DISPID_SRCResume, |
| DISPID_SRCCreateGrammar, |
| DISPID_SRCCreateResultFromMemory, |
| DISPID_SRCBookmark, |
| DISPID_SRCSetAdaptationData, |
| }} |
| ENUM!{enum SpeechRetainedAudioOptions { |
| SRAONone = SPAO_NONE.0, |
| SRAORetainAudio = SPAO_RETAIN_AUDIO.0, |
| }} |
| ENUM!{enum SpeechBookmarkOptions { |
| SBONone = SPBO_NONE.0, |
| SBOPause = SPBO_PAUSE.0, |
| }} |
| ENUM!{enum SpeechInterference { |
| SINone = SPINTERFERENCE_NONE.0, |
| SINoise = SPINTERFERENCE_NOISE.0, |
| SINoSignal = SPINTERFERENCE_NOSIGNAL.0, |
| SITooLoud = SPINTERFERENCE_TOOLOUD.0, |
| SITooQuiet = SPINTERFERENCE_TOOQUIET.0, |
| SITooFast = SPINTERFERENCE_TOOFAST.0, |
| SITooSlow = SPINTERFERENCE_TOOSLOW.0, |
| }} |
| FLAGS!{enum SpeechRecoEvents { |
| SREStreamEnd = 1 << 0, |
| SRESoundStart = 1 << 1, |
| SRESoundEnd = 1 << 2, |
| SREPhraseStart = 1 << 3, |
| SRERecognition = 1 << 4, |
| SREHypothesis = 1 << 5, |
| SREBookmark = 1 << 6, |
| SREPropertyNumChange = 1 << 7, |
| SREPropertyStringChange = 1 << 8, |
| SREFalseRecognition = 1 << 9, |
| SREInterference = 1 << 10, |
| SRERequestUI = 1 << 11, |
| SREStateChange = 1 << 12, |
| SREAdaptation = 1 << 13, |
| SREStreamStart = 1 << 14, |
| SRERecoOtherContext = 1 << 15, |
| SREAudioLevel = 1 << 16, |
| SREPrivate = 1 << 18, |
| SREAllEvents = 0x5ffff, |
| }} |
| ENUM!{enum SpeechRecoContextState { |
| SRCS_Disabled = SPCS_DISABLED.0, |
| SRCS_Enabled = SPCS_ENABLED.0, |
| }} |
| ENUM!{enum DISPIDSPRG { |
| DISPID_SRGId = 1, |
| DISPID_SRGRecoContext, |
| DISPID_SRGState, |
| DISPID_SRGRules, |
| DISPID_SRGReset, |
| DISPID_SRGCommit, |
| DISPID_SRGCmdLoadFromFile, |
| DISPID_SRGCmdLoadFromObject, |
| DISPID_SRGCmdLoadFromResource, |
| DISPID_SRGCmdLoadFromMemory, |
| DISPID_SRGCmdLoadFromProprietaryGrammar, |
| DISPID_SRGCmdSetRuleState, |
| DISPID_SRGCmdSetRuleIdState, |
| DISPID_SRGDictationLoad, |
| DISPID_SRGDictationUnload, |
| DISPID_SRGDictationSetState, |
| DISPID_SRGSetWordSequenceData, |
| DISPID_SRGSetTextSelection, |
| DISPID_SRGIsPronounceable, |
| }} |
| ENUM!{enum SpeechLoadOption { |
| SLOStatic = SPLO_STATIC.0, |
| SLODynamic = SPLO_DYNAMIC.0, |
| }} |
| ENUM!{enum SpeechWordPronounceable { |
| SWPUnknownWordUnpronounceable = SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE.0, |
| SWPUnknownWordPronounceable = SPWP_UNKNOWN_WORD_PRONOUNCEABLE.0, |
| SWPKnownWordPronounceable = SPWP_KNOWN_WORD_PRONOUNCEABLE.0, |
| }} |
| ENUM!{enum SpeechGrammarState { |
| SGSEnabled = SPGS_ENABLED.0, |
| SGSDisabled = SPGS_DISABLED.0, |
| SGSExclusive = SPGS_EXCLUSIVE.0, |
| }} |
| ENUM!{enum SpeechRuleState { |
| SGDSInactive = SPRS_INACTIVE.0, |
| SGDSActive = SPRS_ACTIVE.0, |
| SGDSActiveWithAutoPause = SPRS_ACTIVE_WITH_AUTO_PAUSE.0, |
| SGDSActiveUserDelimited = SPRS_ACTIVE_USER_DELIMITED.0, |
| }} |
| ENUM!{enum SpeechRuleAttributes { |
| SRATopLevel = SPRAF_TopLevel.0, |
| SRADefaultToActive = SPRAF_Active.0, |
| SRAExport = SPRAF_Export.0, |
| SRAImport = SPRAF_Import.0, |
| SRAInterpreter = SPRAF_Interpreter.0, |
| SRADynamic = SPRAF_Dynamic.0, |
| SRARoot = SPRAF_Root.0, |
| }} |
| ENUM!{enum SpeechGrammarWordType { |
| SGDisplay = SPWT_DISPLAY.0, |
| SGLexical = SPWT_LEXICAL.0, |
| SGPronounciation = SPWT_PRONUNCIATION.0, |
| SGLexicalNoSpecialChars = SPWT_LEXICAL_NO_SPECIAL_CHARS.0, |
| }} |
| ENUM!{enum DISPID_SpeechRecoContextEvents { |
| DISPID_SRCEStartStream = 1, |
| DISPID_SRCEEndStream, |
| DISPID_SRCEBookmark, |
| DISPID_SRCESoundStart, |
| DISPID_SRCESoundEnd, |
| DISPID_SRCEPhraseStart, |
| DISPID_SRCERecognition, |
| DISPID_SRCEHypothesis, |
| DISPID_SRCEPropertyNumberChange, |
| DISPID_SRCEPropertyStringChange, |
| DISPID_SRCEFalseRecognition, |
| DISPID_SRCEInterference, |
| DISPID_SRCERequestUI, |
| DISPID_SRCERecognizerStateChange, |
| DISPID_SRCEAdaptation, |
| DISPID_SRCERecognitionForOtherContext, |
| DISPID_SRCEAudioLevel, |
| DISPID_SRCEEnginePrivate, |
| }} |
| ENUM!{enum SpeechRecognitionType { |
| SRTStandard = 0, |
| SRTAutopause = SPREF_AutoPause.0, |
| SRTEmulated = SPREF_Emulated.0, |
| SRTSMLTimeout = SPREF_SMLTimeout.0, |
| SRTExtendableParse = SPREF_ExtendableParse.0, |
| SRTReSent = SPREF_ReSent.0, |
| }} |
| ENUM!{enum DISPID_SpeechGrammarRule { |
| DISPID_SGRAttributes = 1, |
| DISPID_SGRInitialState, |
| DISPID_SGRName, |
| DISPID_SGRId, |
| DISPID_SGRClear, |
| DISPID_SGRAddResource, |
| DISPID_SGRAddState, |
| }} |
| ENUM!{enum DISPID_SpeechGrammarRules { |
| DISPID_SGRsCount = 1, |
| DISPID_SGRsDynamic, |
| DISPID_SGRsAdd, |
| DISPID_SGRsCommit, |
| DISPID_SGRsCommitAndSave, |
| DISPID_SGRsFindRule, |
| DISPID_SGRsItem = ::DISPID_VALUE as u32, |
| DISPID_SGRs_NewEnum = ::DISPID_NEWENUM as u32, |
| }} |
| ENUM!{enum DISPID_SpeechGrammarRuleState { |
| DISPID_SGRSRule = 1, |
| DISPID_SGRSTransitions, |
| DISPID_SGRSAddWordTransition, |
| DISPID_SGRSAddRuleTransition, |
| DISPID_SGRSAddSpecialTransition, |
| }} |
| ENUM!{enum SpeechSpecialTransitionType { |
| SSTTWildcard = 1, |
| SSTTDictation, |
| SSTTTextBuffer, |
| }} |
| ENUM!{enum DISPID_SpeechGrammarRuleStateTransitions { |
| DISPID_SGRSTsCount = 1, |
| DISPID_SGRSTsItem = ::DISPID_VALUE as u32, |
| DISPID_SGRSTs_NewEnum = ::DISPID_NEWENUM as u32, |
| }} |
| ENUM!{enum DISPID_SpeechGrammarRuleStateTransition { |
| DISPID_SGRSTType = 1, |
| DISPID_SGRSTText, |
| DISPID_SGRSTRule, |
| DISPID_SGRSTWeight, |
| DISPID_SGRSTPropertyName, |
| DISPID_SGRSTPropertyId, |
| DISPID_SGRSTPropertyValue, |
| DISPID_SGRSTNextState, |
| }} |
| ENUM!{enum SpeechGrammarRuleStateTransitionType { |
| SGRSTTEpsilon = 0, |
| SGRSTTWord, |
| SGRSTTRule, |
| SGRSTTDictation, |
| SGRSTTWildcard, |
| SGRSTTTextBuffer, |
| }} |
| ENUM!{enum DISPIDSPTSI { |
| DISPIDSPTSI_ActiveOffset = 1, |
| DISPIDSPTSI_ActiveLength, |
| DISPIDSPTSI_SelectionOffset, |
| DISPIDSPTSI_SelectionLength, |
| }} |
| ENUM!{enum DISPID_SpeechRecoResult { |
| DISPID_SRRRecoContext = 1, |
| DISPID_SRRTimes, |
| DISPID_SRRAudioFormat, |
| DISPID_SRRPhraseInfo, |
| DISPID_SRRAlternates, |
| DISPID_SRRAudio, |
| DISPID_SRRSpeakAudio, |
| DISPID_SRRSaveToMemory, |
| DISPID_SRRDiscardResultInfo, |
| }} |
| ENUM!{enum SpeechDiscardType { |
| SDTProperty = SPDF_PROPERTY.0, |
| SDTReplacement = SPDF_REPLACEMENT.0, |
| SDTRule = SPDF_RULE.0, |
| SDTDisplayText = SPDF_DISPLAYTEXT.0, |
| SDTLexicalForm = SPDF_LEXICALFORM.0, |
| SDTPronunciation = SPDF_PRONUNCIATION.0, |
| SDTAudio = SPDF_AUDIO.0, |
| SDTAlternates = SPDF_ALTERNATES.0, |
| SDTAll = SPDF_ALL.0, |
| }} |
| ENUM!{enum DISPID_SpeechXMLRecoResult { |
| DISPID_SRRGetXMLResult, |
| DISPID_SRRGetXMLErrorInfo, |
| }} |
| ENUM!{enum DISPID_SpeechRecoResult2 { |
| DISPID_SRRSetTextFeedback, |
| }} |
| ENUM!{enum DISPID_SpeechPhraseBuilder { |
| DISPID_SPPBRestorePhraseFromMemory = 1, |
| }} |
| ENUM!{enum DISPID_SpeechRecoResultTimes { |
| DISPID_SRRTStreamTime = 1, |
| DISPID_SRRTLength, |
| DISPID_SRRTTickCount, |
| DISPID_SRRTOffsetFromStart, |
| }} |
| ENUM!{enum DISPID_SpeechPhraseAlternate { |
| DISPID_SPARecoResult = 1, |
| DISPID_SPAStartElementInResult, |
| DISPID_SPANumberOfElementsInResult, |
| DISPID_SPAPhraseInfo, |
| DISPID_SPACommit, |
| }} |
| ENUM!{enum DISPID_SpeechPhraseAlternates { |
| DISPID_SPAsCount = 1, |
| DISPID_SPAsItem = ::DISPID_VALUE as u32, |
| DISPID_SPAs_NewEnum = ::DISPID_NEWENUM as u32, |
| }} |
| ENUM!{enum DISPID_SpeechPhraseInfo { |
| DISPID_SPILanguageId = 1, |
| DISPID_SPIGrammarId, |
| DISPID_SPIStartTime, |
| DISPID_SPIAudioStreamPosition, |
| DISPID_SPIAudioSizeBytes, |
| DISPID_SPIRetainedSizeBytes, |
| DISPID_SPIAudioSizeTime, |
| DISPID_SPIRule, |
| DISPID_SPIProperties, |
| DISPID_SPIElements, |
| DISPID_SPIReplacements, |
| DISPID_SPIEngineId, |
| DISPID_SPIEnginePrivateData, |
| DISPID_SPISaveToMemory, |
| DISPID_SPIGetText, |
| DISPID_SPIGetDisplayAttributes, |
| }} |
| ENUM!{enum DISPID_SpeechPhraseElement { |
| DISPID_SPEAudioTimeOffset = 1, |
| DISPID_SPEAudioSizeTime, |
| DISPID_SPEAudioStreamOffset, |
| DISPID_SPEAudioSizeBytes, |
| DISPID_SPERetainedStreamOffset, |
| DISPID_SPERetainedSizeBytes, |
| DISPID_SPEDisplayText, |
| DISPID_SPELexicalForm, |
| DISPID_SPEPronunciation, |
| DISPID_SPEDisplayAttributes, |
| DISPID_SPERequiredConfidence, |
| DISPID_SPEActualConfidence, |
| DISPID_SPEEngineConfidence, |
| }} |
| ENUM!{enum SpeechEngineConfidence { |
| SECLowConfidence = -1i32 as u32, |
| SECNormalConfidence = 0, |
| SECHighConfidence = 1, |
| }} |
| ENUM!{enum DISPID_SpeechPhraseElements { |
| DISPID_SPEsCount = 1, |
| DISPID_SPEsItem = ::DISPID_VALUE as u32, |
| DISPID_SPEs_NewEnum = ::DISPID_NEWENUM as u32, |
| }} |
| ENUM!{enum DISPID_SpeechPhraseReplacement { |
| DISPID_SPRDisplayAttributes = 1, |
| DISPID_SPRText, |
| DISPID_SPRFirstElement, |
| DISPID_SPRNumberOfElements, |
| }} |
| ENUM!{enum DISPID_SpeechPhraseReplacements { |
| DISPID_SPRsCount = 1, |
| DISPID_SPRsItem = ::DISPID_VALUE as u32, |
| DISPID_SPRs_NewEnum = ::DISPID_NEWENUM as u32, |
| }} |
| ENUM!{enum DISPID_SpeechPhraseProperty { |
| DISPID_SPPName = 1, |
| DISPID_SPPId, |
| DISPID_SPPValue, |
| DISPID_SPPFirstElement, |
| DISPID_SPPNumberOfElements, |
| DISPID_SPPEngineConfidence, |
| DISPID_SPPConfidence, |
| DISPID_SPPParent, |
| DISPID_SPPChildren, |
| }} |
| ENUM!{enum DISPID_SpeechPhraseProperties { |
| DISPID_SPPsCount = 1, |
| DISPID_SPPsItem = ::DISPID_VALUE as u32, |
| DISPID_SPPs_NewEnum = ::DISPID_NEWENUM as u32, |
| }} |
| ENUM!{enum DISPID_SpeechPhraseRule { |
| DISPID_SPRuleName = 1, |
| DISPID_SPRuleId, |
| DISPID_SPRuleFirstElement, |
| DISPID_SPRuleNumberOfElements, |
| DISPID_SPRuleParent, |
| DISPID_SPRuleChildren, |
| DISPID_SPRuleConfidence, |
| DISPID_SPRuleEngineConfidence, |
| }} |
| ENUM!{enum DISPID_SpeechPhraseRules { |
| DISPID_SPRulesCount = 1, |
| DISPID_SPRulesItem = ::DISPID_VALUE as u32, |
| DISPID_SPRules_NewEnum = ::DISPID_NEWENUM as u32, |
| }} |
| ENUM!{enum DISPID_SpeechLexicon { |
| DISPID_SLGenerationId = 1, |
| DISPID_SLGetWords, |
| DISPID_SLAddPronunciation, |
| DISPID_SLAddPronunciationByPhoneIds, |
| DISPID_SLRemovePronunciation, |
| DISPID_SLRemovePronunciationByPhoneIds, |
| DISPID_SLGetPronunciations, |
| DISPID_SLGetGenerationChange, |
| }} |
| ENUM!{enum SpeechLexiconType { |
| SLTUser = eLEXTYPE_USER.0, |
| SLTApp = eLEXTYPE_APP.0, |
| }} |
| ENUM!{enum SpeechPartOfSpeech { |
| SPSNotOverriden = SPPS_NotOverriden.0, |
| SPSUnknown = SPPS_Unknown.0, |
| SPSNoun = SPPS_Noun.0, |
| SPSVerb = SPPS_Verb.0, |
| SPSModifier = SPPS_Modifier.0, |
| SPSFunction = SPPS_Function.0, |
| SPSInterjection = SPPS_Interjection.0, |
| SPSLMA = SPPS_LMA.0, |
| SPSSuppressWord = SPPS_SuppressWord.0, |
| }} |
| ENUM!{enum DISPID_SpeechLexiconWords { |
| DISPID_SLWsCount = 1, |
| DISPID_SLWsItem = ::DISPID_VALUE as u32, |
| DISPID_SLWs_NewEnum = ::DISPID_NEWENUM as u32, |
| }} |
| ENUM!{enum SpeechWordType { |
| SWTAdded = eWORDTYPE_ADDED.0, |
| SWTDeleted = eWORDTYPE_DELETED.0, |
| }} |
| ENUM!{enum DISPID_SpeechLexiconWord { |
| DISPID_SLWLangId = 1, |
| DISPID_SLWType, |
| DISPID_SLWWord, |
| DISPID_SLWPronunciations, |
| }} |
| ENUM!{enum DISPID_SpeechLexiconProns { |
| DISPID_SLPsCount = 1, |
| DISPID_SLPsItem = ::DISPID_VALUE as u32, |
| DISPID_SLPs_NewEnum = ::DISPID_NEWENUM as u32, |
| }} |
| ENUM!{enum DISPID_SpeechLexiconPronunciation { |
| DISPID_SLPType = 1, |
| DISPID_SLPLangId, |
| DISPID_SLPPartOfSpeech, |
| DISPID_SLPPhoneIds, |
| DISPID_SLPSymbolic, |
| }} |
| ENUM!{enum DISPID_SpeechPhoneConverter { |
| DISPID_SPCLangId = 1, |
| DISPID_SPCPhoneToId, |
| DISPID_SPCIdToPhone, |
| }} |
| RIDL!( |
| interface ISpeechDataKey(ISpeechDataKeyVtbl): IDispatch(IDispatchVtbl) { |
| fn SetBinaryValue(&mut self, ValueName: ::BSTR, Value: ::VARIANT) -> ::HRESULT, |
| fn GetBinaryValue(&mut self, ValueName: ::BSTR, Value: *mut ::VARIANT) -> ::HRESULT, |
| fn SetStringValue(&mut self, ValueName: ::BSTR, Value: ::BSTR) -> ::HRESULT, |
| fn GetStringValue(&mut self, ValueName: ::BSTR, Value: *mut ::BSTR) -> ::HRESULT, |
| fn SetLongValue(&mut self, ValueName: ::BSTR, Value: ::c_long) -> ::HRESULT, |
| fn GetLongValue(&mut self, ValueName: ::BSTR, Value: *mut ::c_long) -> ::HRESULT, |
| fn OpenKey(&mut self, SubKeyName: ::BSTR, SubKey: *mut *mut ISpeechDataKey) -> ::HRESULT, |
| fn CreateKey(&mut self, SubKeyName: ::BSTR, SubKey: *mut *mut ISpeechDataKey) -> ::HRESULT, |
| fn DeleteKey(&mut self, SubKeyName: ::BSTR) -> ::HRESULT, |
| fn DeleteValue(&mut self, ValueName: ::BSTR) -> ::HRESULT, |
| fn EnumKeys(&mut self, Index: ::c_long, SubKeyName: *mut ::BSTR) -> ::HRESULT, |
| fn EnumValues(&mut self, Index: ::c_long, ValueName: *mut ::BSTR) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpeechObjectToken(ISpeechObjectTokenVtbl): IDispatch(IDispatchVtbl) { |
| fn get_Id(&mut self, ObjectId: *mut ::BSTR) -> ::HRESULT, |
| fn get_DataKey(&mut self, DataKey: *mut *mut ISpeechDataKey) -> ::HRESULT, |
| fn get_Category(&mut self, Category: *mut *mut ISpeechObjectTokenCategory) -> ::HRESULT, |
| fn GetDescription(&mut self, Locale: ::c_long, Description: *mut ::BSTR) -> ::HRESULT, |
| fn SetId( |
| &mut self, Id: ::BSTR, CategoryId: ::BSTR, CreateIfNotExist: ::VARIANT_BOOL |
| ) -> ::HRESULT, |
| fn GetAttribute(&mut self, AttributeName: ::BSTR, AttributeValue: *mut ::BSTR) -> ::HRESULT, |
| fn CreateInstance( |
| &mut self, pUnkOuter: *mut ::IUnknown, ClsContext: SpeechTokenContext, |
| Object: *mut *mut ::IUnknown |
| ) -> ::HRESULT, |
| fn Remove(&mut self, ObjectStorageCLSID: ::BSTR) -> ::HRESULT, |
| fn GetStorageFileName( |
| &mut self, ObjectStorageCLSID: ::BSTR, KeyName: ::BSTR, FileName: ::BSTR, Folder: ::BSTR, |
| FilePath: *mut ::BSTR |
| ) -> ::HRESULT, |
| fn RemoveStorageFileName( |
| &mut self, ObjectStorageCLSID: ::BSTR, KeyName: ::BSTR, DeleteFile: ::VARIANT_BOOL |
| ) -> ::HRESULT, |
| fn IsUISupported( |
| &mut self, TypeOfUI: ::BSTR, ExtraData: *const ::VARIANT, Object: *mut ::IUnknown, |
| Supported: *mut ::VARIANT_BOOL |
| ) -> ::HRESULT, |
| fn DisplayUI( |
| &mut self, hWnd: ::c_long, Title: ::BSTR, TypeOfUI: ::BSTR, ExtraData: *const ::VARIANT, |
| Object: *mut ::IUnknown |
| ) -> ::HRESULT, |
| fn MatchesAttributes(&mut self, Attributes: ::BSTR, Matches: *mut ::VARIANT_BOOL) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpeechObjectTokens(ISpeechObjectTokensVtbl): IDispatch(IDispatchVtbl) { |
| fn get_Count(&mut self, Count: *mut ::c_long) -> ::HRESULT, |
| fn Item(&mut self, Index: ::c_long, Token: *mut *mut ISpeechObjectToken) -> ::HRESULT, |
| fn get__NewEnum(&mut self, ppEnumVARIANT: *mut *mut ::IUnknown) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpeechObjectTokenCategory(ISpeechObjectTokenCategoryVtbl): IDispatch(IDispatchVtbl) { |
| fn get_Id(&mut self, Id: *mut ::BSTR) -> ::HRESULT, |
| fn put_Default(&mut self, TokenId: ::BSTR) -> ::HRESULT, |
| fn get_Default(&mut self, TokenId: *mut ::BSTR) -> ::HRESULT, |
| fn SetId(&mut self, Id: ::BSTR, CreateIfNotExist: ::VARIANT_BOOL) -> ::HRESULT, |
| fn GetDataKey( |
| &mut self, Location: SpeechDataKeyLocation, DataKey: *mut *mut ISpeechDataKey |
| ) -> ::HRESULT, |
| fn EnumerateTokens( |
| &mut self, RequiredAttributes: ::BSTR, OptionalAttributes: ::BSTR, |
| Tokens: *mut *mut ISpeechObjectTokens |
| ) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpeechAudioBufferInfo(ISpeechAudioBufferInfoVtbl): IDispatch(IDispatchVtbl) { |
| fn get_MinNotification(&mut self, MinNotification: *mut ::c_long) -> ::HRESULT, |
| fn put_MinNotification(&mut self, MinNotification: ::c_long) -> ::HRESULT, |
| fn get_BufferSize(&mut self, BufferSize: *mut ::c_long) -> ::HRESULT, |
| fn put_BufferSize(&mut self, BufferSize: ::c_long) -> ::HRESULT, |
| fn get_EventBias(&mut self, EventBias: *mut ::c_long) -> ::HRESULT, |
| fn put_EventBias(&mut self, EventBias: ::c_long) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpeechAudioStatus(ISpeechAudioStatusVtbl): IDispatch(IDispatchVtbl) { |
| fn get_FreeBufferSpace(&mut self, FreeBufferSpace: *mut ::c_long) -> ::HRESULT, |
| fn get_NonBlockingIO(&mut self, NonBlockingIO: *mut ::c_long) -> ::HRESULT, |
| fn get_State(&mut self, State: *mut SpeechAudioState) -> ::HRESULT, |
| fn get_CurrentSeekPosition(&mut self, CurrentSeekPosition: *mut ::VARIANT) -> ::HRESULT, |
| fn get_CurrentDevicePosition(&mut self, CurrentDevicePosition: *mut ::VARIANT) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpeechAudioFormat(ISpeechAudioFormatVtbl): IDispatch(IDispatchVtbl) { |
| fn get_Type(&mut self, AudioFormat: *mut SpeechAudioFormatType) -> ::HRESULT, |
| fn put_Type(&mut self, AudioFormat: SpeechAudioFormatType) -> ::HRESULT, |
| fn get_Guid(&mut self, Guid: *mut ::BSTR) -> ::HRESULT, |
| fn put_Guid(&mut self, Guid: ::BSTR) -> ::HRESULT, |
| fn GetWaveFormatEx(&mut self, SpeechWaveFormatEx: *mut *mut ISpeechWaveFormatEx) -> ::HRESULT, |
| fn SetWaveFormatEx(&mut self, SpeechWaveFormatEx: *mut ISpeechWaveFormatEx) -> ::HRESULT |
| } |
| ); |
| RIDL!( |
| interface ISpeechWaveFormatEx(ISpeechWaveFormatExVtbl): IDispatch(IDispatchVtbl) { |
| fn get_FormatTag(&mut self, FormatTag: *mut ::c_short) -> ::HRESULT, |
| fn put_FormatTag(&mut self, FormatTag: ::c_short) -> ::HRESULT, |
| fn get_Channels(&mut self, Channels: *mut ::c_short) -> ::HRESULT, |
| fn put_Channels(&mut self, Channels: ::c_short) -> ::HRESULT, |
| fn get_SamplesPerSec(&mut self, SamplesPerSec: *mut ::c_long) -> ::HRESULT, |
| fn put_SamplesPerSec(&mut self, SamplesPerSec: ::c_long) -> ::HRESULT, |
| fn get_AvgBytesPerSec(&mut self, AvgBytesPerSec: *mut ::c_long) -> ::HRESULT, |
| fn put_AvgBytesPerSec(&mut self, AvgBytesPerSec: ::c_long) -> ::HRESULT, |
| fn get_BlockAlign(&mut self, BlockAlign: *mut ::c_short) -> ::HRESULT, |
| fn put_BlockAlign(&mut self, BlockAlign: ::c_short) -> ::HRESULT, |
| fn get_BitsPerSample(&mut self, BitsPerSample: *mut ::c_short) -> ::HRESULT, |
| fn put_BitsPerSample(&mut self, BitsPerSample: ::c_short) -> ::HRESULT, |
| fn get_ExtraData(&mut self, ExtraData: *mut ::VARIANT) -> ::HRESULT, |
| fn put_ExtraData(&mut self, ExtraData: ::VARIANT) -> ::HRESULT |
| } |
| ); |
