diff options
Diffstat (limited to '')
| -rw-r--r-- | third_party/rust/winapi-0.2.8/src/sapi.rs | 2431 |
1 files changed, 2431 insertions, 0 deletions
diff --git a/third_party/rust/winapi-0.2.8/src/sapi.rs b/third_party/rust/winapi-0.2.8/src/sapi.rs new file mode 100644 index 0000000000..ac6ca11e7c --- /dev/null +++ b/third_party/rust/winapi-0.2.8/src/sapi.rs @@ -0,0 +1,2431 @@ +// 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 +} +); |