summaryrefslogtreecommitdiff
path: root/vendor/winapi/src/um/sapi51.rs
diff options
context:
space:
mode:
authorValentin Popov <valentin@popov.link>2024-01-08 00:21:28 +0300
committerValentin Popov <valentin@popov.link>2024-01-08 00:21:28 +0300
commit1b6a04ca5504955c571d1c97504fb45ea0befee4 (patch)
tree7579f518b23313e8a9748a88ab6173d5e030b227 /vendor/winapi/src/um/sapi51.rs
parent5ecd8cf2cba827454317368b68571df0d13d7842 (diff)
downloadfparkan-1b6a04ca5504955c571d1c97504fb45ea0befee4.tar.xz
fparkan-1b6a04ca5504955c571d1c97504fb45ea0befee4.zip
Initial vendor packages
Signed-off-by: Valentin Popov <valentin@popov.link>
Diffstat (limited to 'vendor/winapi/src/um/sapi51.rs')
-rw-r--r--vendor/winapi/src/um/sapi51.rs3726
1 files changed, 3726 insertions, 0 deletions
diff --git a/vendor/winapi/src/um/sapi51.rs b/vendor/winapi/src/um/sapi51.rs
new file mode 100644
index 0000000..db1d464
--- /dev/null
+++ b/vendor/winapi/src/um/sapi51.rs
@@ -0,0 +1,3726 @@
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// All files in the project carrying such notice may not be copied, modified, or distributed
+// except according to those terms.
+//! SAPI 5.1 definitions
+use ctypes::{c_char, c_float, c_long, c_short, c_ushort, c_void};
+use shared::guiddef::{CLSID, GUID, IID, REFCLSID, REFGUID, REFIID};
+use shared::minwindef::{
+ BOOL, BYTE, DWORD, FILETIME, HKEY, HMODULE, LPARAM, UINT, ULONG, USHORT, WORD, WPARAM
+};
+use shared::mmreg::WAVEFORMATEX;
+use shared::rpcndr::byte;
+use shared::windef::HWND;
+use shared::wtypes::{BSTR, VARIANT_BOOL};
+use shared::wtypesbase::{
+ CLSCTX_INPROC_HANDLER, CLSCTX_INPROC_SERVER, CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER
+};
+use um::oaidl::{DISPID_NEWENUM, DISPID_VALUE, IDispatch, IDispatchVtbl, VARIANT};
+use um::objidlbase::{IStream, IStreamVtbl, STREAM_SEEK_CUR, STREAM_SEEK_END, STREAM_SEEK_SET};
+use um::servprov::{IServiceProvider, IServiceProviderVtbl};
+use um::unknwnbase::{IUnknown, IUnknownVtbl};
+use um::winnt::{HANDLE, HRESULT, LONG, LONGLONG, LPCWSTR, LPWSTR, ULONGLONG, WCHAR};
+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,
+}}
+extern {
+ pub static SPDFID_Text: GUID;
+ pub static SPDFID_WaveFormatEx: GUID;
+}
+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 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 SP_LOW_CONFIDENCE: c_char = -1;
+pub const SP_NORMAL_CONFIDENCE: c_char = 0;
+pub const SP_HIGH_CONFIDENCE: c_char = 1;
+pub const DEFAULT_WEIGHT: c_float = 1.0;
+pub const SP_MAX_WORD_LENGTH: ULONG = 128;
+pub const SP_MAX_PRON_LENGTH: ULONG = 384;
+RIDL!{#[uuid(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)]
+interface ISpNotifyCallback(ISpNotifyCallbackVtbl) {
+ fn NotifyCallback(
+ wParam: WPARAM,
+ lParam: LPARAM,
+ ) -> HRESULT,
+}}
+FN!{stdcall SPNOTIFYCALLBACK(
+ wParam: WPARAM,
+ lParam: LPARAM,
+) -> ()}
+RIDL!{#[uuid(0x5eff4aef, 0x8487, 0x11d2, 0x96, 0x1c, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0x28)]
+interface ISpNotifySource(ISpNotifySourceVtbl): IUnknown(IUnknownVtbl) {
+ fn SetNotifySink(
+ pNotifySink: *mut ISpNotifySink,
+ ) -> HRESULT,
+ fn SetNotifyWindowMessage(
+ hWnd: HWND,
+ Msg: UINT,
+ wParam: WPARAM,
+ lParam: LPARAM,
+ ) -> HRESULT,
+ fn SetNotifyCallbackFunction(
+ pfnCallback: SPNOTIFYCALLBACK,
+ wParam: WPARAM,
+ lParam: LPARAM,
+ ) -> HRESULT,
+ fn SetNotifyCallbackInterface(
+ pSpCallback: *mut ISpNotifyCallback,
+ wParam: WPARAM,
+ lParam: LPARAM,
+ ) -> HRESULT,
+ fn SetNotifyWin32Event() -> HRESULT,
+ fn WaitForNotifyEvent(
+ dwMilliseconds: DWORD,
+ ) -> HRESULT,
+ fn GetNotifyEventHandle() -> HANDLE,
+}}
+RIDL!{#[uuid(0x259684dc, 0x37c3, 0x11d2, 0x96, 0x03, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0x28)]
+interface ISpNotifySink(ISpNotifySinkVtbl): IUnknown(IUnknownVtbl) {
+ fn Notify() -> HRESULT,
+}}
+RIDL!{#[uuid(0xaca16614, 0x5d3d, 0x11d2, 0x96, 0x0e, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0x28)]
+interface ISpNotifyTranslator(ISpNotifyTranslatorVtbl): ISpNotifySink(ISpNotifySinkVtbl) {
+ fn InitWindowMessage(
+ hWnd: HWND,
+ Msg: UINT,
+ wParam: WPARAM,
+ lParam: LPARAM,
+ ) -> HRESULT,
+ fn InitCallback(
+ pfnCallback: SPNOTIFYCALLBACK,
+ wParam: WPARAM,
+ lParam: LPARAM,
+ ) -> HRESULT,
+ fn InitSpNotifyCallback(
+ pSpCallback: *mut ISpNotifyCallback,
+ wParam: WPARAM,
+ lParam: LPARAM,
+ ) -> HRESULT,
+ fn InitWin32Event(
+ hEvent: HANDLE,
+ fCloseHandleOnRelease: BOOL,
+ ) -> HRESULT,
+ fn Wait(
+ dwMilliseconds: DWORD,
+ ) -> HRESULT,
+ fn GetEventHandle() -> HANDLE,
+}}
+RIDL!{#[uuid(0x14056581, 0xe16c, 0x11d2, 0xbb, 0x90, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)]
+interface ISpDataKey(ISpDataKeyVtbl): IUnknown(IUnknownVtbl) {
+ fn SetData(
+ pszValueName: LPCWSTR,
+ cbData: ULONG,
+ pData: *const BYTE,
+ ) -> HRESULT,
+ fn GetData(
+ pszValueName: LPCWSTR,
+ pcbData: *mut ULONG,
+ pData: *mut BYTE,
+ ) -> HRESULT,
+ fn SetStringValue(
+ pszValueName: LPCWSTR,
+ pszValue: LPCWSTR,
+ ) -> HRESULT,
+ fn GetStringValue(
+ pszValueName: LPCWSTR,
+ ppszValue: *mut LPWSTR,
+ ) -> HRESULT,
+ fn SetDWORD(
+ pszValueName: LPCWSTR,
+ dwValue: DWORD,
+ ) -> HRESULT,
+ fn GetDWORD(
+ pszValueName: LPCWSTR,
+ pdwValue: *mut DWORD,
+ ) -> HRESULT,
+ fn OpenKey(
+ pszSubKeyName: LPCWSTR,
+ ppSubKey: *mut *mut ISpDataKey,
+ ) -> HRESULT,
+ fn CreateKey(
+ pszSubKey: LPCWSTR,
+ ppSubKey: *mut *mut ISpDataKey,
+ ) -> HRESULT,
+ fn DeleteKey(
+ pszSubKey: LPCWSTR,
+ ) -> HRESULT,
+ fn DeleteValue(
+ pszValueName: LPCWSTR,
+ ) -> HRESULT,
+ fn EnumKeys(
+ Index: ULONG,
+ ppszSubKeyName: *mut LPWSTR,
+ ) -> HRESULT,
+ fn EnumValues(
+ Index: ULONG,
+ ppszValueName: *mut LPWSTR,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x92a66e2b, 0xc830, 0x4149, 0x83, 0xdf, 0x6f, 0xc2, 0xba, 0x1e, 0x7a, 0x5b)]
+interface ISpRegDataKey(ISpRegDataKeyVtbl): ISpDataKey(ISpDataKeyVtbl) {
+ fn SetKey(
+ hkey: HKEY,
+ fReadOnly: BOOL,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x2d3d3845, 0x39af, 0x4850, 0xbb, 0xf9, 0x40, 0xb4, 0x97, 0x80, 0x01, 0x1d)]
+interface ISpObjectTokenCategory(ISpObjectTokenCategoryVtbl): ISpDataKey(ISpDataKeyVtbl) {
+ fn SetId(
+ pszCategoryId: LPCWSTR,
+ fCreateIfNotExist: BOOL,
+ ) -> HRESULT,
+ fn GetId(
+ ppszCoMemCategoryId: *mut LPWSTR,
+ ) -> HRESULT,
+ fn GetDataKey(
+ spdkl: SPDATAKEYLOCATION,
+ pppDataKey: *mut *mut ISpDataKey,
+ ) -> HRESULT,
+ fn EnumTokens(
+ pzsReqAttribs: LPCWSTR,
+ pszOptAttribs: LPCWSTR,
+ ppEnum: *mut *mut IEnumSpObjectTokens,
+ ) -> HRESULT,
+ fn SetDefaultTokenId(
+ pszTokenId: LPCWSTR,
+ ) -> HRESULT,
+ fn GetDefaultTokenId(
+ ppszCoMemTokenId: *mut LPWSTR,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x14056589, 0xe16c, 0x11d2, 0xbb, 0x90, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)]
+interface ISpObjectToken(ISpObjectTokenVtbl): ISpDataKey(ISpDataKeyVtbl) {
+ fn SetId(
+ pszCategoryId: LPCWSTR,
+ pszTokenId: LPCWSTR,
+ fCreateIfNotExist: BOOL,
+ ) -> HRESULT,
+ fn GetId(
+ ppszCoMemTokenId: *mut LPWSTR,
+ ) -> HRESULT,
+ fn GetCategory(
+ ppTokenCategory: *mut *mut ISpObjectTokenCategory,
+ ) -> HRESULT,
+ fn CreateInstance(
+ pUnkOuter: *mut IUnknown,
+ dwClsContext: DWORD,
+ riid: REFIID,
+ ppvObject: *mut *mut c_void,
+ ) -> HRESULT,
+ fn GetStorageFileName(
+ clsidCaller: REFCLSID,
+ pszValueName: LPCWSTR,
+ pszFileNameSpecifier: LPCWSTR,
+ nFolder: ULONG,
+ ppszFilePath: *mut LPWSTR,
+ ) -> HRESULT,
+ fn RemoveStorageFileName(
+ pszKeyName: LPCWSTR,
+ fDeleteFile: BOOL,
+ ) -> HRESULT,
+ fn Remove(
+ pclsidCaller: *const CLSID,
+ ) -> HRESULT,
+ fn IsUISupported(
+ pszTypeOfUI: LPCWSTR,
+ pvExtraData: *mut c_void,
+ cbExtraData: ULONG,
+ punkObject: *mut IUnknown,
+ pfSupported: *mut BOOL,
+ ) -> HRESULT,
+ fn DisplayUI(
+ hwndParent: HWND,
+ pszTitle: LPCWSTR,
+ pszTypeOfUI: LPCWSTR,
+ pvExtraData: *mut c_void,
+ cbExtraData: ULONG,
+ punkObject: *mut IUnknown,
+ ) -> HRESULT,
+ fn MatchesAttributes(
+ pszAttributes: LPCWSTR,
+ pfMatches: *mut BOOL,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xb8aab0cf, 0x346f, 0x49d8, 0x94, 0x99, 0xc8, 0xb0, 0x3f, 0x16, 0x1d, 0x51)]
+interface ISpObjectTokenInit(ISpObjectTokenInitVtbl): ISpObjectToken(ISpObjectTokenVtbl) {
+ fn InitFromDataKey(
+ pszCategoryId: LPCWSTR,
+ pszTokenId: LPCWSTR,
+ pDataKey: *mut ISpDataKey,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x06b64f9e, 0x7fda, 0x11d2, 0xb4, 0xf2, 0x00, 0xc0, 0x4f, 0x79, 0x73, 0x96)]
+interface IEnumSpObjectTokens(IEnumSpObjectTokensVtbl): IUnknown(IUnknownVtbl) {
+ fn Next(
+ celt: ULONG,
+ pelt: *mut *mut ISpObjectToken,
+ pceltFetched: *mut ULONG,
+ ) -> HRESULT,
+ fn Skip(
+ celt: ULONG,
+ ) -> HRESULT,
+ fn Reset() -> HRESULT,
+ fn Clone(
+ ppEnum: *mut *mut IEnumSpObjectTokens,
+ ) -> HRESULT,
+ fn Item(
+ Index: ULONG,
+ ppToken: *mut *mut ISpObjectToken,
+ ) -> HRESULT,
+ fn GetCount(
+ pCount: *mut ULONG,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x5b559f40, 0xe952, 0x11d2, 0xbb, 0x91, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)]
+interface ISpObjectWithToken(ISpObjectWithTokenVtbl): IUnknown(IUnknownVtbl) {
+ fn SetObjectToken(
+ pToken: *mut ISpObjectToken,
+ ) -> HRESULT,
+ fn GetObjectToken(
+ ppToken: *mut *mut ISpObjectToken,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x93384e18, 0x5014, 0x43d5, 0xad, 0xbb, 0xa7, 0x8e, 0x05, 0x59, 0x26, 0xbd)]
+interface ISpResourceManager(ISpResourceManagerVtbl): IServiceProvider(IServiceProviderVtbl) {
+ fn SetObject(
+ guidServiceId: REFGUID,
+ pUnkObject: *mut IUnknown,
+ ) -> HRESULT,
+ fn GetObject(
+ 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_MIN_TTS = 1,
+ SPEI_MAX_TTS = 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_PRIVATE = 52,
+ SPEI_MIN_SR = 34,
+ SPEI_MAX_SR = 52,
+ SPEI_RESERVED1 = 30,
+ SPEI_RESERVED2 = 33,
+ SPEI_RESERVED3 = 63,
+}}
+pub const SPFEI_FLAGCHECK: ULONGLONG = (1 << SPEI_RESERVED1) | (1 << SPEI_RESERVED2);
+pub const SPFEI_ALL_TTS_EVENTS: ULONGLONG = 0x000000000000FFFE | SPFEI_FLAGCHECK;
+pub const SPFEI_ALL_SR_EVENTS: ULONGLONG = 0x003FFFFC00000000 | SPFEI_FLAGCHECK;
+pub const SPFEI_ALL_EVENTS: ULONGLONG = 0xEFFFFFFFFFFFFFFF;
+#[inline]
+pub fn SPFEI(
+ SPEI_ord: SPEVENTENUM,
+ ) -> ULONGLONG {
+ (1 << SPEI_ord) | SPFEI_FLAGCHECK
+}
+STRUCT!{struct SPEVENT {
+ bitfields: DWORD,
+ ulStreamNum: ULONG,
+ ullAudioStreamOffset: ULONGLONG,
+ wParam: WPARAM,
+ lParam: LPARAM,
+}}
+BITFIELD!{SPEVENT bitfields: SPEVENTENUM [ eEventId set_eEventId[0..16], ]}
+BITFIELD!{SPEVENT bitfields: SPEVENTLPARAMTYPE [ elParamType set_elParamType[16..32], ]}
+STRUCT!{struct SPSERIALIZEDEVENT {
+ bitfields: DWORD,
+ ulStreamNum: ULONG,
+ ullAudioStreamOffset: ULONGLONG,
+ SerializedwParam: ULONG,
+ SerializedlParam: LONG,
+}}
+BITFIELD!{SPSERIALIZEDEVENT bitfields: SPEVENTENUM [ eEventId set_eEventId[0..16], ]}
+BITFIELD!{SPSERIALIZEDEVENT bitfields: SPEVENTLPARAMTYPE [ elParamType set_elParamType[16..32], ]}
+STRUCT!{struct SPSERIALIZEDEVENT64 {
+ bitfields: DWORD,
+ ulStreamNum: ULONG,
+ ullAudioStreamOffset: ULONGLONG,
+ SerializedwParam: ULONGLONG,
+ SerializedlParam: LONGLONG,
+}}
+BITFIELD!{SPSERIALIZEDEVENT64 bitfields: SPEVENTENUM [
+ eEventId set_eEventId[0..16],
+]}
+BITFIELD!{SPSERIALIZEDEVENT64 bitfields: SPEVENTLPARAMTYPE [
+ elParamType set_elParamType[16..32],
+]}
+ENUM!{enum SPINTERFERENCE {
+ SPINTERFERENCE_NONE = 0,
+ SPINTERFERENCE_NOISE,
+ SPINTERFERENCE_NOSIGNAL,
+ SPINTERFERENCE_TOOLOUD,
+ SPINTERFERENCE_TOOQUIET,
+ SPINTERFERENCE_TOOFAST,
+ SPINTERFERENCE_TOOSLOW,
+ SPINTERFERENCE_LATENCY_WARNING,
+ SPINTERFERENCE_LATENCY_TRUNCATE_BEGIN ,
+ SPINTERFERENCE_LATENCY_TRUNCATE_END,
+}}
+ENUM!{enum SPENDSRSTREAMFLAGS {
+ SPESF_NONE = 0,
+ SPESF_STREAM_RELEASED = 1 << 0,
+ SPESF_EMULATED = 1 << 1,
+}}
+ENUM!{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!{#[uuid(0xbe7a9cce, 0x5f9e, 0x11d2, 0x96, 0x0f, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0x28)]
+interface ISpEventSource(ISpEventSourceVtbl): ISpNotifySource(ISpNotifySourceVtbl) {
+ fn SetInterest(
+ ullEventInterest: ULONGLONG,
+ ullQueuedInterest: ULONGLONG,
+ ) -> HRESULT,
+ fn GetEvents(
+ ulCount: ULONG,
+ pEventArray: *mut SPEVENT,
+ pulFetched: *mut ULONG,
+ ) -> HRESULT,
+ fn GetInfo(
+ pInfo: *mut SPEVENTSOURCEINFO,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xbe7a9cc9, 0x5f9e, 0x11d2, 0x96, 0x0f, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0x28)]
+interface ISpEventSink(ISpEventSinkVtbl): IUnknown(IUnknownVtbl) {
+ fn AddEvents(
+ pEventArray: *const SPEVENT,
+ ulCount: ULONG,
+ ) -> HRESULT,
+ fn GetEventInterest(
+ pullEventInterest: *mut ULONGLONG,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xbed530be, 0x2606, 0x4f4d, 0xa1, 0xc0, 0x54, 0xc5, 0xcd, 0xa5, 0x56, 0x6f)]
+interface ISpStreamFormat(ISpStreamFormatVtbl): IStream(IStreamVtbl) {
+ fn GetFormat(
+ pguidFormatId: *mut GUID,
+ ppCoMemWaveFormatEx: *mut *mut WAVEFORMATEX,
+ ) -> HRESULT,
+}}
+ENUM!{enum SPFILEMODE {
+ SPFM_OPEN_READONLY,
+ SPFM_OPEN_READWRITE,
+ SPFM_CREATE,
+ SPFM_CREATE_ALWAYS,
+ SPFM_NUM_MODES,
+}}
+RIDL!{#[uuid(0x12e3cca9, 0x7518, 0x44c5, 0xa5, 0xe7, 0xba, 0x5a, 0x79, 0xcb, 0x92, 0x9e)]
+interface ISpStream(ISpStreamVtbl): ISpStreamFormat(ISpStreamFormatVtbl) {
+ fn SetBaseStream(
+ pStream: *mut IStream,
+ rguidFormat: REFGUID,
+ pWaveFormatEx: *const WAVEFORMATEX,
+ ) -> HRESULT,
+ fn GetBaseStream(
+ ppStream: *mut *mut IStream,
+ ) -> HRESULT,
+ fn BindToFile(
+ pszFileName: LPCWSTR,
+ eMode: SPFILEMODE,
+ pFormatId: *const GUID,
+ pWaveFormatEx: *const WAVEFORMATEX,
+ ullEventInterest: ULONGLONG,
+ ) -> HRESULT,
+ fn Close() -> HRESULT,
+}}
+RIDL!{#[uuid(0x678a932c, 0xea71, 0x4446, 0x9b, 0x41, 0x78, 0xfd, 0xa6, 0x28, 0x0a, 0x29)]
+interface ISpStreamFormatConverter(ISpStreamFormatConverterVtbl):
+ ISpStreamFormat(ISpStreamFormatVtbl) {
+ fn SetBaseStream(
+ pStream: *mut ISpStreamFormat,
+ fSetFormatToBaseStreamFormat: BOOL,
+ fWriteToBaseStream: BOOL,
+ ) -> HRESULT,
+ fn GetBaseStream(
+ ppStream: *mut *mut ISpStreamFormat,
+ ) -> HRESULT,
+ fn SetFormat(
+ rguidFormatIdOfConvertedStream: REFGUID,
+ pWaveFormatExOfConvertedStream: *const WAVEFORMATEX,
+ ) -> HRESULT,
+ fn ResetSeekPosition() -> HRESULT,
+ fn ScaleConvertedToBaseOffset(
+ ullOffsetConvertedStream: ULONGLONG,
+ pullOffsetBaseStream: *mut ULONGLONG,
+ ) -> HRESULT,
+ fn ScaleBaseToConvertedOffset(
+ ullOffsetBaseStream: ULONGLONG,
+ pullOffsetConvertedStream: *mut ULONGLONG,
+ ) -> HRESULT,
+}}
+ENUM!{enum SPAUDIOSTATE {
+ SPAS_CLOSED,
+ SPAS_STOP,
+ SPAS_PAUSE,
+ SPAS_RUN,
+}}
+STRUCT!{struct SPAUDIOSTATUS {
+ cbFreeBuffSpace: c_long,
+ cbNonBlockingIO: ULONG,
+ State: SPAUDIOSTATE,
+ CurSeekPos: ULONGLONG,
+ CurDevicePos: ULONGLONG,
+ dwAudioLevel: DWORD,
+ dwReserved2: DWORD,
+}}
+STRUCT!{struct SPAUDIOBUFFERINFO {
+ ulMsMinNotification: ULONG,
+ ulMsBufferSize: ULONG,
+ ulMsEventBias: ULONG,
+}}
+RIDL!{#[uuid(0xc05c768f, 0xfae8, 0x4ec2, 0x8e, 0x07, 0x33, 0x83, 0x21, 0xc1, 0x24, 0x52)]
+interface ISpAudio(ISpAudioVtbl): ISpStreamFormat(ISpStreamFormatVtbl) {
+ fn SetState(
+ NewState: SPAUDIOSTATE,
+ ullReserved: ULONGLONG,
+ ) -> HRESULT,
+ fn SetFormat(
+ rguidFmtId: REFGUID,
+ pWaveFormatEx: *const WAVEFORMATEX,
+ ) -> HRESULT,
+ fn GetStatus(
+ pStatus: *mut SPAUDIOSTATUS,
+ ) -> HRESULT,
+ fn SetBufferInfo(
+ pBuffInfo: *const SPAUDIOBUFFERINFO,
+ ) -> HRESULT,
+ fn GetBufferInfo(
+ pBuffInfo: *mut SPAUDIOBUFFERINFO,
+ ) -> HRESULT,
+ fn GetDefaultFormat(
+ pFormatId: *mut GUID,
+ ppCoMemWaveFormatEx: *mut *mut WAVEFORMATEX,
+ ) -> HRESULT,
+ fn EventHandle() -> HANDLE,
+ fn GetVolumeLevel(
+ pLevel: *mut ULONG,
+ ) -> HRESULT,
+ fn SetVolumeLevel(
+ Level: ULONG,
+ ) -> HRESULT,
+ fn GetBufferNotifySize(
+ pcbSize: *mut ULONG,
+ ) -> HRESULT,
+ fn SetBufferNotifySize(
+ cbSize: ULONG,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x15806f6e, 0x1d70, 0x4b48, 0x98, 0xe6, 0x3b, 0x1a, 0x00, 0x75, 0x09, 0xab)]
+interface ISpMMSysAudio(ISpMMSysAudioVtbl): ISpAudio(ISpAudioVtbl) {
+ fn GetDeviceId(
+ puDeviceId: *mut UINT,
+ ) -> HRESULT,
+ fn SetDeviceId(
+ uDeviceId: UINT,
+ ) -> HRESULT,
+ fn GetMMHandle(
+ pHandle: *mut *mut c_void,
+ ) -> HRESULT,
+ fn GetLineId(
+ puLineId: *mut UINT,
+ ) -> HRESULT,
+ fn SetLineId(
+ uLineId: UINT,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x10f63bce, 0x201a, 0x11d3, 0xac, 0x70, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)]
+interface ISpTranscript(ISpTranscriptVtbl): IUnknown(IUnknownVtbl) {
+ fn GetTranscript(
+ ppszTranscript: *mut LPWSTR,
+ ) -> HRESULT,
+ fn AppendTranscript(
+ pszTranscript: LPCWSTR,
+ ) -> HRESULT,
+}}
+ENUM!{enum SPDISPLAYATTRIBUTES {
+ SPAF_ONE_TRAILING_SPACE = 0x2,
+ SPAF_TWO_TRAILING_SPACES = 0x4,
+ SPAF_CONSUME_LEADING_SPACES = 0x8,
+ SPAF_ALL = 0xf,
+}}
+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_u_s {
+ bType: byte,
+ bReserved: byte,
+ usArrayIndex: c_ushort,
+}}
+UNION!{union SPPHRASEPROPERTY_u {
+ [u32; 1],
+ ulId ulId_mut: ULONG,
+ s s_mut: SPPHRASEPROPERTY_u_s,
+}}
+STRUCT!{struct SPPHRASEPROPERTY {
+ pszName: LPCWSTR,
+ u: SPPHRASEPROPERTY_u_s,
+ pszValue: LPCWSTR,
+ vValue: VARIANT,
+ ulFirstElement: ULONG,
+ ulCountOfElements: ULONG,
+ pNextSibling: *const SPPHRASEPROPERTY,
+ pFirstChild: *const SPPHRASEPROPERTY,
+ SREngineConfidence: c_float,
+ Confidence: c_char,
+}}
+STRUCT!{struct SPPHRASEREPLACEMENT {
+ bDisplayAttributes: BYTE,
+ pszReplacementText: LPCWSTR,
+ ulFirstElement: ULONG,
+ ulCountOfElements: ULONG,
+}}
+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,
+}}
+STRUCT!{struct SPSERIALIZEDPHRASE {
+ ulSerializedSize: ULONG,
+}}
+ENUM!{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__}
+ENUM!{enum SPRECOEVENTFLAGS {
+ SPREF_AutoPause = 1 << 0,
+ SPREF_Emulated = 1 << 1,
+}}
+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,
+}}
+ENUM!{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,
+}}
+ENUM!{enum SPWORDTYPE {
+ eWORDTYPE_ADDED = 1 << 0,
+ eWORDTYPE_DELETED = 1 << 1,
+}}
+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!{#[uuid(0xda41a7c2, 0x5383, 0x4db2, 0x91, 0x6b, 0x6c, 0x17, 0x19, 0xe3, 0xdb, 0x58)]
+interface ISpLexicon(ISpLexiconVtbl): IUnknown(IUnknownVtbl) {
+ fn GetPronunciations(
+ pszWord: LPCWSTR,
+ LangID: WORD,
+ dwFlags: DWORD,
+ pWordPronunciationList: *mut SPWORDPRONUNCIATIONLIST,
+ ) -> HRESULT,
+ fn AddPronunciation(
+ pszWord: LPCWSTR,
+ LangID: WORD,
+ ePartOfSpeech: SPPARTOFSPEECH,
+ pszPronunciation: PCSPPHONEID,
+ ) -> HRESULT,
+ fn RemovePronunciation(
+ pszWord: LPCWSTR,
+ LangID: WORD,
+ ePartOfSpeech: SPPARTOFSPEECH,
+ pszPronunciation: PCSPPHONEID,
+ ) -> HRESULT,
+ fn GetGeneration(
+ pdwGeneration: *mut DWORD,
+ ) -> HRESULT,
+ fn GetGenerationChange(
+ dwFlags: DWORD,
+ pdwGeneration: *mut DWORD,
+ pWordList: *mut SPWORDLIST,
+ ) -> HRESULT,
+ fn GetWords(
+ dwFlags: DWORD,
+ pdwGeneration: *mut DWORD,
+ pdwCookie: *mut DWORD,
+ pWordList: *mut SPWORDLIST,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x8565572f, 0xc094, 0x41cc, 0xb5, 0x6e, 0x10, 0xbd, 0x9c, 0x3f, 0xf0, 0x44)]
+interface ISpContainerLexicon(ISpContainerLexiconVtbl): ISpLexicon(ISpLexiconVtbl) {
+ fn AddLexicon(
+ pAddLexicon: *mut ISpLexicon,
+ dwFlags: DWORD,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x8445c581, 0x0cac, 0x4a38, 0xab, 0xfe, 0x9b, 0x2c, 0xe2, 0x82, 0x64, 0x55)]
+interface ISpPhoneConverter(ISpPhoneConverterVtbl): ISpObjectWithToken(ISpObjectWithTokenVtbl) {
+ fn PhoneToId(
+ pszPhone: LPCWSTR,
+ pId: *mut SPPHONEID,
+ ) -> HRESULT,
+ fn IdToPhone(
+ pId: PCSPPHONEID,
+ pszPhone: *mut WCHAR,
+ ) -> 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,
+}}
+ENUM!{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_NLP_MASK = SPF_NLP_SPEAK_PUNC,
+ SPF_VOICE_MASK = SPF_ASYNC | SPF_PURGEBEFORESPEAK
+ | SPF_IS_FILENAME | SPF_IS_XML | SPF_IS_NOT_XML
+ | SPF_NLP_MASK | SPF_PERSIST_XML,
+ SPF_UNUSED_FLAGS = !SPF_VOICE_MASK,
+}}
+RIDL!{#[uuid(0x6c44df74, 0x72b9, 0x4992, 0xa1, 0xec, 0xef, 0x99, 0x6e, 0x04, 0x22, 0xd4)]
+interface ISpVoice(ISpVoiceVtbl): ISpEventSource(ISpEventSourceVtbl) {
+ fn SetOutput(
+ pUnkOutput: *mut IUnknown,
+ fAllowFormatChanges: BOOL,
+ ) -> HRESULT,
+ fn GetOutputObjectToken(
+ ppObjectToken: *mut *mut ISpObjectToken,
+ ) -> HRESULT,
+ fn GetOutputStream(
+ ppStream: *mut *mut ISpStreamFormat,
+ ) -> HRESULT,
+ fn Pause() -> HRESULT,
+ fn Resume() -> HRESULT,
+ fn SetVoice(
+ pToken: *mut ISpObjectToken,
+ ) -> HRESULT,
+ fn GetVoice(
+ ppToken: *mut *mut ISpObjectToken,
+ ) -> HRESULT,
+ fn Speak(
+ pwcs: LPCWSTR,
+ dwFlags: DWORD,
+ pulStreamNumber: *mut ULONG,
+ ) -> HRESULT,
+ fn SpeakStream(
+ pStream: *mut IStream,
+ dwFlags: DWORD,
+ pulStreamNumber: *mut ULONG,
+ ) -> HRESULT,
+ fn GetStatus(
+ pStatus: *mut SPVOICESTATUS,
+ ppszLastBookmark: *mut LPWSTR,
+ ) -> HRESULT,
+ fn Skip(
+ pItemType: LPCWSTR,
+ lNumItems: c_long,
+ pulNumSkipped: *mut ULONG,
+ ) -> HRESULT,
+ fn SetPriority(
+ ePriority: SPVPRIORITY,
+ ) -> HRESULT,
+ fn GetPriority(
+ pePriority: *mut SPVPRIORITY,
+ ) -> HRESULT,
+ fn SetAlertBoundary(
+ eBoundary: SPEVENTENUM,
+ ) -> HRESULT,
+ fn GetAlertBoundary(
+ peBoundary: *mut SPEVENTENUM,
+ ) -> HRESULT,
+ fn SetRate(
+ RateAdjust: c_long,
+ ) -> HRESULT,
+ fn GetRate(
+ pRateAdjust: *mut c_long,
+ ) -> HRESULT,
+ fn SetVolume(
+ usVolume: USHORT,
+ ) -> HRESULT,
+ fn GetVolume(
+ pusVolume: *mut USHORT,
+ ) -> HRESULT,
+ fn WaitUntilDone(
+ msTimeout: ULONG,
+ ) -> HRESULT,
+ fn SetSyncSpeakTimeout(
+ msTimeout: ULONG,
+ ) -> HRESULT,
+ fn GetSyncSpeakTimeout(
+ pmsTimeout: *mut ULONG,
+ ) -> HRESULT,
+ fn SpeakCompleteEvent() -> HANDLE,
+ fn IsUISupported(
+ pszTypeOfUI: LPCWSTR,
+ pvExtraData: *mut c_void,
+ cbExtraData: ULONG,
+ pfSupported: *mut BOOL,
+ ) -> HRESULT,
+ fn DisplayUI(
+ hwndParent: HWND,
+ pszTitle: LPCWSTR,
+ pszTypeOfUI: LPCWSTR,
+ pvExtraData: *mut c_void,
+ cbExtraData: ULONG,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x1a5c0354, 0xb621, 0x4b5a, 0x87, 0x91, 0xd3, 0x06, 0xed, 0x37, 0x9e, 0x53)]
+interface ISpPhrase(ISpPhraseVtbl): IUnknown(IUnknownVtbl) {
+ fn GetPhrase(
+ ppCoMemPhrase: *mut *mut SPPHRASE,
+ ) -> HRESULT,
+ fn GetSerializedPhrase(
+ ppCoMemPhrase: *mut *mut SPSERIALIZEDPHRASE,
+ ) -> HRESULT,
+ fn GetText(
+ ulStart: ULONG,
+ ulCount: ULONG,
+ fUseTextReplacements: BOOL,
+ ppszCoMemText: *mut LPWSTR,
+ pbDisplayAttributes: *mut BYTE,
+ ) -> HRESULT,
+ fn Discard(
+ dwValueTypes: DWORD,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x8fcebc98, 0x4e49, 0x4067, 0x9c, 0x6c, 0xd8, 0x6a, 0x0e, 0x09, 0x2e, 0x3d)]
+interface ISpPhraseAlt(ISpPhraseAltVtbl): ISpPhrase(ISpPhraseVtbl) {
+ fn GetAltInfo(
+ pParent: *mut *mut ISpPhrase,
+ pulStartElementInParent: *mut ULONG,
+ pcElementsInParent: *mut ULONG,
+ pcElementsInAlt: *mut ULONG,
+ ) -> HRESULT,
+ fn Commit() -> HRESULT,
+}}
+STRUCT!{struct SPRECORESULTTIMES {
+ ftStreamTime: FILETIME,
+ ullLength: ULONGLONG,
+ dwTickCount: DWORD,
+ ullStart: ULONGLONG,
+}}
+STRUCT!{struct SPSERIALIZEDRESULT {
+ ulSerializedSize: ULONG,
+}}
+RIDL!{#[uuid(0x20b053be, 0xe235, 0x43cd, 0x9a, 0x2a, 0x8d, 0x17, 0xa4, 0x8b, 0x78, 0x42)]
+interface ISpRecoResult(ISpRecoResultVtbl): ISpPhrase(ISpPhraseVtbl) {
+ fn GetResultTimes(
+ pTimes: *mut SPRECORESULTTIMES,
+ ) -> HRESULT,
+ fn GetAlternates(
+ ulStartElement: ULONG,
+ cElements: ULONG,
+ ulRequestCount: ULONG,
+ ppPhrases: *mut *mut ISpPhraseAlt,
+ pcPhrasesReturned: *mut ULONG,
+ ) -> HRESULT,
+ fn GetAudio(
+ ulStartElement: ULONG,
+ cElements: ULONG,
+ ppStream: *mut *mut ISpStreamFormat,
+ ) -> HRESULT,
+ fn SpeakAudio(
+ ulStartElement: ULONG,
+ cElements: ULONG,
+ dwFlags: DWORD,
+ pulStreamNumber: *mut ULONG,
+ ) -> HRESULT,
+ fn Serialize(
+ ppCoMemSerializedResult: *mut *mut SPSERIALIZEDRESULT,
+ ) -> HRESULT,
+ fn ScaleAudio(
+ pAudioFormatId: *const GUID,
+ pWaveFormatEx: *const WAVEFORMATEX,
+ ) -> HRESULT,
+ fn GetRecoContext(
+ ppRecoContext: *mut *mut ISpRecoContext,
+ ) -> 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,
+}}
+pub const SP_STREAMPOS_ASAP: ULONGLONG = 0;
+pub const SP_STREAMPOS_REALTIME: ULONGLONG = -1i64 as u64;
+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,
+ SPWT_LEXICAL,
+ SPWT_PRONUNCIATION,
+ SPWT_LEXICAL_NO_SPECIAL_CHARS,
+}}
+STRUCT!{struct SPPROPERTYINFO {
+ pszName: LPCWSTR,
+ ulId: ULONG,
+ pszValue: LPCWSTR,
+ vValue: VARIANT,
+}}
+ENUM!{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_AutoPause = 1 << 16,
+}}
+RIDL!{#[uuid(0x8137828f, 0x591a, 0x4a42, 0xbe, 0x58, 0x49, 0xea, 0x7e, 0xba, 0xac, 0x68)]
+interface ISpGrammarBuilder(ISpGrammarBuilderVtbl): IUnknown(IUnknownVtbl) {
+ fn ResetGrammar(
+ NewLanguage: WORD,
+ ) -> HRESULT,
+ fn GetRule(
+ pszRuleName: LPCWSTR,
+ dwRuleId: DWORD,
+ dwAttributes: DWORD,
+ fCreateIfNotExist: BOOL,
+ phInitialState: *mut SPSTATEHANDLE,
+ ) -> HRESULT,
+ fn ClearRule(
+ hState: SPSTATEHANDLE,
+ ) -> HRESULT,
+ fn CreateNewState(
+ hState: SPSTATEHANDLE,
+ phState: *mut SPSTATEHANDLE,
+ ) -> HRESULT,
+ fn AddWordTransition(
+ hFromState: SPSTATEHANDLE,
+ hToState: SPSTATEHANDLE,
+ psz: LPCWSTR,
+ pszSeparators: LPCWSTR,
+ eWordType: SPGRAMMARWORDTYPE,
+ Weight: c_float,
+ pPropInfo: *const SPPROPERTYINFO,
+ ) -> HRESULT,
+ fn AddRuleTransition(
+ hFromState: SPSTATEHANDLE,
+ hToState: SPSTATEHANDLE,
+ hRule: SPSTATEHANDLE,
+ Weight: c_float,
+ pPropInfo: *const SPPROPERTYINFO,
+ ) -> HRESULT,
+ fn AddResource(
+ hRuleState: SPSTATEHANDLE,
+ pszResourceName: LPCWSTR,
+ pszResourceValue: LPCWSTR,
+ ) -> HRESULT,
+ fn Commit(
+ dwReserved: DWORD,
+ ) -> HRESULT,
+}}
+ENUM!{enum SPLOADOPTIONS {
+ SPLO_STATIC = 0,
+ SPLO_DYNAMIC = 1,
+}}
+RIDL!{#[uuid(0x2177db29, 0x7f45, 0x47d0, 0x85, 0x54, 0x06, 0x7e, 0x91, 0xc8, 0x05, 0x02)]
+interface ISpRecoGrammar(ISpRecoGrammarVtbl): ISpGrammarBuilder(ISpGrammarBuilderVtbl) {
+ fn GetGrammarId(
+ pullGrammarId: *mut ULONGLONG,
+ ) -> HRESULT,
+ fn GetRecoContext(
+ ppRecoCtxt: *mut *mut ISpRecoContext,
+ ) -> HRESULT,
+ fn LoadCmdFromFile(
+ pszFileName: LPCWSTR,
+ Options: SPLOADOPTIONS,
+ ) -> HRESULT,
+ fn LoadCmdFromObject(
+ rcid: REFCLSID,
+ pszGrammarName: LPCWSTR,
+ Options: SPLOADOPTIONS,
+ ) -> HRESULT,
+ fn LoadCmdFromResource(
+ hModule: HMODULE,
+ pszResourceName: LPCWSTR,
+ pszResourceType: LPCWSTR,
+ wLanguage: WORD,
+ Options: SPLOADOPTIONS,
+ ) -> HRESULT,
+ fn LoadCmdFromMemory(
+ pGrammar: *const SPBINARYGRAMMAR,
+ Options: SPLOADOPTIONS,
+ ) -> HRESULT,
+ fn LoadCmdFromProprietaryGrammar(
+ rguidParam: REFGUID,
+ pszStringParam: LPCWSTR,
+ pvDataPrarm: *const c_void,
+ cbDataSize: ULONG,
+ Options: SPLOADOPTIONS,
+ ) -> HRESULT,
+ fn SetRuleState(
+ pszName: LPCWSTR,
+ pReserved: *mut c_void,
+ NewState: SPRULESTATE,
+ ) -> HRESULT,
+ fn SetRuleIdState(
+ ulRuleId: ULONG,
+ NewState: SPRULESTATE,
+ ) -> HRESULT,
+ fn LoadDictation(
+ pszTopicName: LPCWSTR,
+ Options: SPLOADOPTIONS,
+ ) -> HRESULT,
+ fn UnloadDictation() -> HRESULT,
+ fn SetDictationState(
+ NewState: SPRULESTATE,
+ ) -> HRESULT,
+ fn SetWordSequenceData(
+ pText: *const WCHAR,
+ cchText: ULONG,
+ pInfo: *const SPTEXTSELECTIONINFO,
+ ) -> HRESULT,
+ fn SetTextSelection(
+ pInfo: *const SPTEXTSELECTIONINFO,
+ ) -> HRESULT,
+ fn IsPronounceable(
+ pszWord: LPCWSTR,
+ pWordPronounceable: *mut SPWORDPRONOUNCEABLE,
+ ) -> HRESULT,
+ fn SetGrammarState(
+ eGrammarState: SPGRAMMARSTATE,
+ ) -> HRESULT,
+ fn SaveCmd(
+ pStream: *mut IStream,
+ ppszCoMemErrorText: *mut LPWSTR,
+ ) -> HRESULT,
+ fn GetGrammarState(
+ peGrammarState: *mut SPGRAMMARSTATE,
+ ) -> HRESULT,
+}}
+STRUCT!{struct SPRECOCONTEXTSTATUS {
+ eInterference: SPINTERFERENCE,
+ szRequestTypeOfUI: [WCHAR; 255],
+ dwReserved1: DWORD,
+ dwReserved2: DWORD,
+}}
+ENUM!{enum SPBOOKMARKOPTIONS {
+ SPBO_NONE = 0,
+ SPBO_PAUSE = 1 << 0,
+}}
+ENUM!{enum SPAUDIOOPTIONS {
+ SPAO_NONE = 0,
+ SPAO_RETAIN_AUDIO = 1 << 0,
+}}
+RIDL!{#[uuid(0xf740a62f, 0x7c15, 0x489e, 0x82, 0x34, 0x94, 0x0a, 0x33, 0xd9, 0x27, 0x2d)]
+interface ISpRecoContext(ISpRecoContextVtbl): ISpEventSource(ISpEventSourceVtbl) {
+ fn GetRecognizer(
+ ppRecognizer: *mut *mut ISpRecognizer,
+ ) -> HRESULT,
+ fn CreateGrammer(
+ ullGrammarId: ULONGLONG,
+ ppGrammar: *mut *mut ISpRecoGrammar,
+ ) -> HRESULT,
+ fn GetStatus(
+ pState: *mut SPRECOCONTEXTSTATUS,
+ ) -> HRESULT,
+ fn GetMaxAlternates(
+ pcAlternates: *mut ULONG,
+ ) -> HRESULT,
+ fn SetMaxAlternates(
+ cAlternates: ULONG,
+ ) -> HRESULT,
+ fn SetAudioOptions(
+ Options: SPAUDIOOPTIONS,
+ pAudioFormatId: *const GUID,
+ pWaveFormatEx: *const WAVEFORMATEX,
+ ) -> HRESULT,
+ fn GetAudioOptions(
+ pOptions: *mut SPAUDIOOPTIONS,
+ pAudioFormatId: *mut GUID,
+ ppCoMemWFEX: *mut *mut WAVEFORMATEX,
+ ) -> HRESULT,
+ fn DeserializeResult(
+ pSerializedResult: *const SPSERIALIZEDRESULT,
+ ppResult: *mut *mut ISpRecoResult,
+ ) -> HRESULT,
+ fn Bookmark(
+ Options: SPBOOKMARKOPTIONS,
+ ullStreamPosition: ULONGLONG,
+ lparamEvent: LPARAM,
+ ) -> HRESULT,
+ fn SetAdaptionData(
+ pAdaptionData: LPCWSTR,
+ cch: ULONG,
+ ) -> HRESULT,
+ fn Pause(
+ dwReserved: DWORD,
+ ) -> HRESULT,
+ fn Resume(
+ dwReserved: DWORD,
+ ) -> HRESULT,
+ fn SetVoice(
+ pVoice: *mut ISpVoice,
+ fAllowFormatChanges: BOOL,
+ ) -> HRESULT,
+ fn GetVoice(
+ ppVoice: *mut *mut ISpVoice,
+ ) -> HRESULT,
+ fn SetVoicePurgeEvent(
+ ullEventIntereset: ULONGLONG,
+ ) -> HRESULT,
+ fn GetVoicePurgeEvent(
+ pullEventIntereset: *mut ULONGLONG,
+ ) -> HRESULT,
+ fn SetContextState(
+ eContextState: SPCONTEXTSTATE,
+ ) -> HRESULT,
+ fn GetContextState(
+ peContextState: *mut SPCONTEXTSTATE,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x5b4fb971, 0xb115, 0x4de1, 0xad, 0x97, 0xe4, 0x82, 0xe3, 0xbf, 0x6e, 0xe4)]
+interface ISpProperties(ISpPropertiesVtbl): IUnknown(IUnknownVtbl) {
+ fn SetPropertyNum(
+ pName: LPCWSTR,
+ lValue: LONG,
+ ) -> HRESULT,
+ fn GetPropertyNum(
+ pName: LPCWSTR,
+ plValue: *mut LONG,
+ ) -> HRESULT,
+ fn SetPropertyString(
+ pName: LPCWSTR,
+ pValue: LPCWSTR,
+ ) -> HRESULT,
+ fn GetPropertyString(
+ pName: LPCWSTR,
+ ppCoMemValue: *mut LPWSTR,
+ ) -> HRESULT,
+}}
+pub const SP_MAX_LANGIDS: usize = 20;
+STRUCT!{struct SPRECOGNIZERSTATUS {
+ AudioStatus: SPAUDIOSTATUS,
+ ullRecognitionStreamPos: ULONGLONG,
+ ulStreamNumber: ULONG,
+ ulNumActive: ULONG,
+ clsidEngine: CLSID,
+ cLangIDs: ULONG,
+ aLangID: [WORD; SP_MAX_LANGIDS],
+ ullRecognitionStreamTime: ULONGLONG,
+}}
+ENUM!{enum SPWAVEFORMATTYPE {
+ SPWF_INPUT,
+ SPWF_SRENGINE,
+}}
+pub type SPSTREAMFORMATTYPE = SPWAVEFORMATTYPE;
+ENUM!{enum SPRECOSTATE {
+ SPRST_INACTIVE,
+ SPRST_ACTIVE,
+ SPRST_ACTIVE_ALWAYS,
+ SPRST_INACTIVE_WITH_PURGE,
+ SPRST_NUM_STATES,
+}}
+RIDL!{#[uuid(0xc2b5f241, 0xdaa0, 0x4507, 0x9e, 0x16, 0x5a, 0x1e, 0xaa, 0x2b, 0x7a, 0x5c)]
+interface ISpRecognizer(ISpRecognizerVtbl): ISpProperties(ISpPropertiesVtbl) {
+ fn SetRecognizer(
+ pRecognizer: *mut ISpObjectToken,
+ ) -> HRESULT,
+ fn GetRecognizer(
+ ppRecognizer: *mut *mut ISpObjectToken,
+ ) -> HRESULT,
+ fn SetInput(
+ pUnkInput: *mut IUnknown,
+ fAllowFormatChanges: BOOL,
+ ) -> HRESULT,
+ fn GetInputObjectToken(
+ ppToken: *mut *mut ISpObjectToken,
+ ) -> HRESULT,
+ fn GetInputStream(
+ ppStream: *mut *mut ISpStreamFormat,
+ ) -> HRESULT,
+ fn CreateRecoContext(
+ ppNewCtxt: *mut *mut ISpRecoContext,
+ ) -> HRESULT,
+ fn GetRecoProfile(
+ ppToken: *mut *mut ISpObjectToken,
+ ) -> HRESULT,
+ fn SetRecoProfile(
+ pToken: *mut ISpObjectToken,
+ ) -> HRESULT,
+ fn IsSharedInstance() -> HRESULT,
+ fn GetRecoState(
+ pState: *mut SPRECOSTATE,
+ ) -> HRESULT,
+ fn SetRecoState(
+ NewState: SPRECOSTATE,
+ ) -> HRESULT,
+ fn GetStatus(
+ pStatus: *mut SPRECOGNIZERSTATUS,
+ ) -> HRESULT,
+ fn GetFormat(
+ WaveFormatType: SPSTREAMFORMATTYPE,
+ pFormatId: *mut GUID,
+ ppCoMemWFEX: *mut WAVEFORMATEX,
+ ) -> HRESULT,
+ fn IsUISupported(
+ pszTypeOfUI: LPCWSTR,
+ pvExtraData: *mut c_void,
+ cbExtraData: ULONG,
+ pfSupported: *mut BOOL,
+ ) -> HRESULT,
+ fn DisplayUI(
+ hwndParent: HWND,
+ pszTitle: LPCWSTR,
+ pszTypeOfUI: LPCWSTR,
+ pvExtraData: *mut c_void,
+ cbExtraData: ULONG,
+ ) -> HRESULT,
+ fn EmulateRecognition(
+ pPhrase: *mut ISpPhrase,
+ ) -> 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,
+ SDKLCurrentUser = SPDKL_CurrentUser,
+ SDKLLocalMachine = SPDKL_LocalMachine,
+ SDKLCurrentConfig = SPDKL_CurrentConfig,
+}}
+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,
+ SSSPTRelativeToCurrentPosition = STREAM_SEEK_CUR,
+ SSSPTRelativeToEnd = STREAM_SEEK_END,
+}}
+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,
+ SASStop = SPAS_STOP,
+ SASPause = SPAS_PAUSE,
+ SASRun = SPAS_RUN,
+}}
+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,
+ SSFMOpenReadWrite = SPFM_OPEN_READWRITE,
+ SSFMCreate = SPFM_CREATE,
+ SSFMCreateForWrite = SPFM_CREATE_ALWAYS,
+}}
+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,
+ SVPAlert = SPVPRI_ALERT,
+ SVPOver = SPVPRI_OVER,
+}}
+ENUM!{enum SpeechVoiceSpeakFlags {
+ SVSFDefault = SPF_DEFAULT,
+ SVSFlagsAsync = SPF_ASYNC,
+ SVSFPurgeBeforeSpeak = SPF_PURGEBEFORESPEAK,
+ SVSFIsFilename = SPF_IS_FILENAME,
+ SVSFIsXML = SPF_IS_XML,
+ SVSFIsNotXML = SPF_IS_NOT_XML,
+ SVSFPersistXML = SPF_PERSIST_XML,
+ SVSFNLPSpeakPunc = SPF_NLP_SPEAK_PUNC,
+ SVSFNLPMask = SPF_NLP_MASK,
+ SVSFVoiceMask = SPF_VOICE_MASK as u32,
+ SVSFUnusedFlags = SPF_UNUSED_FLAGS as u32,
+}}
+ENUM!{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,
+ SRSEIsSpeaking = SPRS_IS_SPEAKING,
+}}
+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,
+ SVF_Emphasis = SPVFEATURE_EMPHASIS,
+}}
+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,
+ SRSActive = SPRST_ACTIVE,
+ SRSActiveAlways = SPRST_ACTIVE_ALWAYS,
+ SRSInactiveWithPurge = SPRST_INACTIVE_WITH_PURGE,
+}}
+ENUM!{enum SpeechDisplayAttributes {
+ SDA_No_Trailing_Space = 0,
+ SDA_One_Trailing_Space = SPAF_ONE_TRAILING_SPACE,
+ SDA_Two_Trailing_Spaces = SPAF_TWO_TRAILING_SPACES,
+ SDA_Consume_Leading_Spaces = SPAF_CONSUME_LEADING_SPACES,
+}}
+ENUM!{enum SpeechFormatType {
+ SFTInput = SPWF_INPUT,
+ SFTSREngine = SPWF_SRENGINE,
+}}
+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,
+ SRAORetainAudio = SPAO_RETAIN_AUDIO,
+}}
+ENUM!{enum SpeechBookmarkOptions {
+ SBONone = SPBO_NONE,
+ SBOPause = SPBO_PAUSE,
+}}
+ENUM!{enum SpeechInterference {
+ SINone = SPINTERFERENCE_NONE,
+ SINoise = SPINTERFERENCE_NOISE,
+ SINoSignal = SPINTERFERENCE_NOSIGNAL,
+ SITooLoud = SPINTERFERENCE_TOOLOUD,
+ SITooQuiet = SPINTERFERENCE_TOOQUIET,
+ SITooFast = SPINTERFERENCE_TOOFAST,
+ SITooSlow = SPINTERFERENCE_TOOSLOW,
+}}
+ENUM!{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,
+ SRCS_Enabled = SPCS_ENABLED,
+}}
+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,
+ SLODynamic = SPLO_DYNAMIC,
+}}
+ENUM!{enum SpeechWordPronounceable {
+ SWPUnknownWordUnpronounceable = SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE,
+ SWPUnknownWordPronounceable = SPWP_UNKNOWN_WORD_PRONOUNCEABLE,
+ SWPKnownWordPronounceable = SPWP_KNOWN_WORD_PRONOUNCEABLE,
+}}
+ENUM!{enum SpeechGrammarState {
+ SGSEnabled = SPGS_ENABLED,
+ SGSDisabled = SPGS_DISABLED,
+ SGSExclusive = SPGS_EXCLUSIVE,
+}}
+ENUM!{enum SpeechRuleState {
+ SGDSInactive = SPRS_INACTIVE,
+ SGDSActive = SPRS_ACTIVE,
+ SGDSActiveWithAutoPause = SPRS_ACTIVE_WITH_AUTO_PAUSE,
+}}
+ENUM!{enum SpeechRuleAttributes {
+ SRATopLevel = SPRAF_TopLevel,
+ SRADefaultToActive = SPRAF_Active,
+ SRAExport = SPRAF_Export,
+ SRAImport = SPRAF_Import,
+ SRAInterpreter = SPRAF_Interpreter,
+ SRADynamic = SPRAF_Dynamic,
+}}
+ENUM!{enum SpeechGrammarWordType {
+ SGDisplay = SPWT_DISPLAY,
+ SGLexical = SPWT_LEXICAL,
+ SGPronounciation = SPWT_PRONUNCIATION,
+}}
+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,
+ SRTEmulated = SPREF_Emulated,
+}}
+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,
+ SDTReplacement = SPDF_REPLACEMENT,
+ SDTRule = SPDF_RULE,
+ SDTDisplayText = SPDF_DISPLAYTEXT,
+ SDTLexicalForm = SPDF_LEXICALFORM,
+ SDTPronunciation = SPDF_PRONUNCIATION,
+ SDTAudio = SPDF_AUDIO,
+ SDTAlternates = SPDF_ALTERNATES,
+ SDTAll = SPDF_ALL,
+}}
+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,
+ SLTApp = eLEXTYPE_APP,
+}}
+ENUM!{enum SpeechPartOfSpeech {
+ SPSNotOverriden = SPPS_NotOverriden,
+ SPSUnknown = SPPS_Unknown,
+ SPSNoun = SPPS_Noun,
+ SPSVerb = SPPS_Verb,
+ SPSModifier = SPPS_Modifier,
+ SPSFunction = SPPS_Function,
+ SPSInterjection = SPPS_Interjection,
+}}
+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,
+ SWTDeleted = eWORDTYPE_DELETED,
+}}
+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,
+}}
+extern {
+ pub static LIBID_SpeechLib: IID;
+}
+RIDL!{#[uuid(0xce17c09b, 0x4efa, 0x44d5, 0xa4, 0xc9, 0x59, 0xd9, 0x58, 0x5a, 0xb0, 0xcd)]
+interface ISpeechDataKey(ISpeechDataKeyVtbl): IDispatch(IDispatchVtbl) {
+ fn SetBinaryValue(
+ ValueName: BSTR,
+ Value: VARIANT,
+ ) -> HRESULT,
+ fn GetBinaryValue(
+ ValueName: BSTR,
+ Value: *mut VARIANT,
+ ) -> HRESULT,
+ fn SetStringValue(
+ ValueName: BSTR,
+ Value: BSTR,
+ ) -> HRESULT,
+ fn GetStringValue(
+ ValueName: BSTR,
+ Value: *mut BSTR,
+ ) -> HRESULT,
+ fn SetLongValue(
+ ValueName: BSTR,
+ Value: c_long,
+ ) -> HRESULT,
+ fn GetLongValue(
+ ValueName: BSTR,
+ Value: *mut c_long,
+ ) -> HRESULT,
+ fn OpenKey(
+ SubKeyName: BSTR,
+ SubKey: *mut *mut ISpeechDataKey,
+ ) -> HRESULT,
+ fn CreateKey(
+ SubKeyName: BSTR,
+ SubKey: *mut *mut ISpeechDataKey,
+ ) -> HRESULT,
+ fn DeleteKey(
+ SubKeyName: BSTR,
+ ) -> HRESULT,
+ fn DeleteValue(
+ ValueName: BSTR,
+ ) -> HRESULT,
+ fn EnumKeys(
+ Index: c_long,
+ SubKeyName: *mut BSTR,
+ ) -> HRESULT,
+ fn EnumValues(
+ Index: c_long,
+ ValueName: *mut BSTR,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xc74a3adc, 0xb727, 0x4500, 0xa8, 0x4a, 0xb5, 0x26, 0x72, 0x1c, 0x8b, 0x8c)]
+interface ISpeechObjectToken(ISpeechObjectTokenVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Id(
+ ObjectId: *mut BSTR,
+ ) -> HRESULT,
+ fn get_DataKey(
+ DataKey: *mut *mut ISpeechDataKey,
+ ) -> HRESULT,
+ fn get_Category(
+ Category: *mut *mut ISpeechObjectTokenCategory,
+ ) -> HRESULT,
+ fn GetDescription(
+ Locale: c_long,
+ Description: *mut BSTR,
+ ) -> HRESULT,
+ fn SetId(
+ Id: BSTR,
+ CategoryId: BSTR,
+ CreateIfNotExist: VARIANT_BOOL,
+ ) -> HRESULT,
+ fn GetAttribute(
+ AttributeName: BSTR,
+ AttributeValue: *mut BSTR,
+ ) -> HRESULT,
+ fn CreateInstance(
+ pUnkOuter: *mut IUnknown,
+ ClsContext: SpeechTokenContext,
+ Object: *mut *mut IUnknown,
+ ) -> HRESULT,
+ fn Remove(
+ ObjectStorageCLSID: BSTR,
+ ) -> HRESULT,
+ fn GetStorageFileName(
+ ObjectStorageCLSID: BSTR,
+ KeyName: BSTR,
+ FileName: BSTR,
+ Folder: BSTR,
+ FilePath: *mut BSTR,
+ ) -> HRESULT,
+ fn RemoveStorageFileName(
+ ObjectStorageCLSID: BSTR,
+ KeyName: BSTR,
+ DeleteFile: VARIANT_BOOL,
+ ) -> HRESULT,
+ fn IsUISupported(
+ TypeOfUI: BSTR,
+ ExtraData: *const VARIANT,
+ Object: *mut IUnknown,
+ Supported: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+ fn DisplayUI(
+ hWnd: c_long,
+ Title: BSTR,
+ TypeOfUI: BSTR,
+ ExtraData: *const VARIANT,
+ Object: *mut IUnknown,
+ ) -> HRESULT,
+ fn MatchesAttributes(
+ Attributes: BSTR,
+ Matches: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x9285b776, 0x2e7b, 0x4bc0, 0xb5, 0x3e, 0x58, 0x0e, 0xb6, 0xfa, 0x96, 0x7f)]
+interface ISpeechObjectTokens(ISpeechObjectTokensVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Count(
+ Count: *mut c_long,
+ ) -> HRESULT,
+ fn Item(
+ Index: c_long,
+ Token: *mut *mut ISpeechObjectToken,
+ ) -> HRESULT,
+ fn get__NewEnum(
+ ppEnumVARIANT: *mut *mut IUnknown,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xca7eac50, 0x2d01, 0x4145, 0x86, 0xd4, 0x5a, 0xe7, 0xd7, 0x0f, 0x44, 0x69)]
+interface ISpeechObjectTokenCategory(ISpeechObjectTokenCategoryVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Id(
+ Id: *mut BSTR,
+ ) -> HRESULT,
+ fn put_Default(
+ TokenId: BSTR,
+ ) -> HRESULT,
+ fn get_Default(
+ TokenId: *mut BSTR,
+ ) -> HRESULT,
+ fn SetId(
+ Id: BSTR,
+ CreateIfNotExist: VARIANT_BOOL,
+ ) -> HRESULT,
+ fn GetDataKey(
+ Location: SpeechDataKeyLocation,
+ DataKey: *mut *mut ISpeechDataKey,
+ ) -> HRESULT,
+ fn EnumerateTokens(
+ RequiredAttributes: BSTR,
+ OptionalAttributes: BSTR,
+ Tokens: *mut *mut ISpeechObjectTokens,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x11b103d8, 0x1142, 0x4edf, 0xa0, 0x93, 0x82, 0xfb, 0x39, 0x15, 0xf8, 0xcc)]
+interface ISpeechAudioBufferInfo(ISpeechAudioBufferInfoVtbl): IDispatch(IDispatchVtbl) {
+ fn get_MinNotification(
+ MinNotification: *mut c_long,
+ ) -> HRESULT,
+ fn put_MinNotification(
+ MinNotification: c_long,
+ ) -> HRESULT,
+ fn get_BufferSize(
+ BufferSize: *mut c_long,
+ ) -> HRESULT,
+ fn put_BufferSize(
+ BufferSize: c_long,
+ ) -> HRESULT,
+ fn get_EventBias(
+ EventBias: *mut c_long,
+ ) -> HRESULT,
+ fn put_EventBias(
+ EventBias: c_long,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xc62d9c91, 0x7458, 0x47f6, 0x86, 0x2d, 0x1e, 0xf8, 0x6f, 0xb0, 0xb2, 0x78)]
+interface ISpeechAudioStatus(ISpeechAudioStatusVtbl): IDispatch(IDispatchVtbl) {
+ fn get_FreeBufferSpace(
+ FreeBufferSpace: *mut c_long,
+ ) -> HRESULT,
+ fn get_NonBlockingIO(
+ NonBlockingIO: *mut c_long,
+ ) -> HRESULT,
+ fn get_State(
+ State: *mut SpeechAudioState,
+ ) -> HRESULT,
+ fn get_CurrentSeekPosition(
+ CurrentSeekPosition: *mut VARIANT,
+ ) -> HRESULT,
+ fn get_CurrentDevicePosition(
+ CurrentDevicePosition: *mut VARIANT,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xe6e9c590, 0x3e18, 0x40e3, 0x82, 0x99, 0x06, 0x1f, 0x98, 0xbd, 0xe7, 0xc7)]
+interface ISpeechAudioFormat(ISpeechAudioFormatVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Type(
+ AudioFormat: *mut SpeechAudioFormatType,
+ ) -> HRESULT,
+ fn put_Type(
+ AudioFormat: SpeechAudioFormatType,
+ ) -> HRESULT,
+ fn get_Guid(
+ Guid: *mut BSTR,
+ ) -> HRESULT,
+ fn put_Guid(
+ Guid: BSTR,
+ ) -> HRESULT,
+ fn GetWaveFormatEx(
+ SpeechWaveFormatEx: *mut *mut ISpeechWaveFormatEx,
+ ) -> HRESULT,
+ fn SetWaveFormatEx(
+ SpeechWaveFormatEx: *mut ISpeechWaveFormatEx,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x7a1ef0d5, 0x1581, 0x4741, 0x88, 0xe4, 0x20, 0x9a, 0x49, 0xf1, 0x1a, 0x10)]
+interface ISpeechWaveFormatEx(ISpeechWaveFormatExVtbl): IDispatch(IDispatchVtbl) {
+ fn get_FormatTag(
+ FormatTag: *mut c_short,
+ ) -> HRESULT,
+ fn put_FormatTag(
+ FormatTag: c_short,
+ ) -> HRESULT,
+ fn get_Channels(
+ Channels: *mut c_short,
+ ) -> HRESULT,
+ fn put_Channels(
+ Channels: c_short,
+ ) -> HRESULT,
+ fn get_SamplesPerSec(
+ SamplesPerSec: *mut c_long,
+ ) -> HRESULT,
+ fn put_SamplesPerSec(
+ SamplesPerSec: c_long,
+ ) -> HRESULT,
+ fn get_AvgBytesPerSec(
+ AvgBytesPerSec: *mut c_long,
+ ) -> HRESULT,
+ fn put_AvgBytesPerSec(
+ AvgBytesPerSec: c_long,
+ ) -> HRESULT,
+ fn get_BlockAlign(
+ BlockAlign: *mut c_short,
+ ) -> HRESULT,
+ fn put_BlockAlign(
+ BlockAlign: c_short,
+ ) -> HRESULT,
+ fn get_BitsPerSample(
+ BitsPerSample: *mut c_short,
+ ) -> HRESULT,
+ fn put_BitsPerSample(
+ BitsPerSample: c_short,
+ ) -> HRESULT,
+ fn get_ExtraData(
+ ExtraData: *mut VARIANT,
+ ) -> HRESULT,
+ fn put_ExtraData(
+ ExtraData: VARIANT,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x6450336f, 0x7d49, 0x4ced, 0x80, 0x97, 0x49, 0xd6, 0xde, 0xe3, 0x72, 0x94)]
+interface ISpeechBaseStream(ISpeechBaseStreamVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Format(
+ AudioFormat: *mut *mut ISpeechAudioFormat,
+ ) -> HRESULT,
+ fn putref_Format(
+ AudioFormat: *mut ISpeechAudioFormat,
+ ) -> HRESULT,
+ fn Read(
+ Buffer: *mut VARIANT,
+ NumberOfBytes: c_long,
+ BytesRead: *mut c_long,
+ ) -> HRESULT,
+ fn Write(
+ Buffer: VARIANT,
+ BytesWritten: *mut c_long,
+ ) -> HRESULT,
+ fn Seek(
+ Position: VARIANT,
+ Origin: SpeechStreamSeekPositionType,
+ NewPosition: *mut VARIANT,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xaf67f125, 0xab39, 0x4e93, 0xb4, 0xa2, 0xcc, 0x2e, 0x66, 0xe1, 0x82, 0xa7)]
+interface ISpeechFileStream(ISpeechFileStreamVtbl): ISpeechBaseStream(ISpeechBaseStreamVtbl) {
+ fn Open(
+ FileName: BSTR,
+ FileMode: SpeechStreamFileMode,
+ DoEvents: VARIANT_BOOL,
+ ) -> HRESULT,
+ fn Close() -> HRESULT,
+}}
+RIDL!{#[uuid(0xeeb14b68, 0x808b, 0x4abe, 0xa5, 0xea, 0xb5, 0x1d, 0xa7, 0x58, 0x80, 0x08)]
+interface ISpeechMemoryStream(ISpeechMemoryStreamVtbl): ISpeechBaseStream(ISpeechBaseStreamVtbl) {
+ fn SetData(
+ Data: VARIANT,
+ ) -> HRESULT,
+ fn GetData(
+ pData: *mut VARIANT,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x1a9e9f4f, 0x104f, 0x4db8, 0xa1, 0x15, 0xef, 0xd7, 0xfd, 0x0c, 0x97, 0xae)]
+interface ISpeechCustomStream(ISpeechCustomStreamVtbl): ISpeechBaseStream(ISpeechBaseStreamVtbl) {
+ fn get_BaseStream(
+ ppUnkStream: *mut *mut IUnknown,
+ ) -> HRESULT,
+ fn putref_BaseStream(
+ pUnkStream: *mut IUnknown,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xcff8e175, 0x019e, 0x11d3, 0xa0, 0x8e, 0x00, 0xc0, 0x4f, 0x8e, 0xf9, 0xb5)]
+interface ISpeechAudio(ISpeechAudioVtbl): ISpeechBaseStream(ISpeechBaseStreamVtbl) {
+ fn get_Status(
+ Status: *mut *mut ISpeechAudioStatus,
+ ) -> HRESULT,
+ fn get_BufferInfo(
+ BufferInfo: *mut *mut ISpeechAudioBufferInfo,
+ ) -> HRESULT,
+ fn get_DefaultFormat(
+ StreamFormat: *mut *mut ISpeechAudioFormat,
+ ) -> HRESULT,
+ fn get_Volume(
+ Volume: *mut c_long,
+ ) -> HRESULT,
+ fn put_Volume(
+ Volume: c_long,
+ ) -> HRESULT,
+ fn get_BufferNotifySize(
+ BufferNotifySize: *mut c_long,
+ ) -> HRESULT,
+ fn put_BufferNotifySize(
+ BufferNotifySize: c_long,
+ ) -> HRESULT,
+ fn get_EventHandle(
+ EventHandle: *mut c_long,
+ ) -> HRESULT,
+ fn SetState(
+ State: SpeechAudioState,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x3c76af6d, 0x1fd7, 0x4831, 0x81, 0xd1, 0x3b, 0x71, 0xd5, 0xa1, 0x3c, 0x44)]
+interface ISpeechMMSysAudio(ISpeechMMSysAudioVtbl): ISpeechAudio(ISpeechAudioVtbl) {
+ fn get_DeviceId(
+ DeviceId: *mut c_long,
+ ) -> HRESULT,
+ fn put_DeviceId(
+ DeviceId: c_long,
+ ) -> HRESULT,
+ fn get_LineId(
+ LineId: *mut c_long,
+ ) -> HRESULT,
+ fn put_LineId(
+ LineId: c_long,
+ ) -> HRESULT,
+ fn get_MMHandle(
+ Handle: *mut c_long,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x269316d8, 0x57bd, 0x11d2, 0x9e, 0xee, 0x00, 0xc0, 0x4f, 0x79, 0x73, 0x96)]
+interface ISpeechVoice(ISpeechVoiceVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Status(
+ Status: *mut *mut ISpeechVoiceStatus,
+ ) -> HRESULT,
+ fn get_Voice(
+ Voice: *mut *mut ISpeechObjectToken,
+ ) -> HRESULT,
+ fn putref_Voice(
+ Voice: *mut ISpeechObjectToken,
+ ) -> HRESULT,
+ fn get_AudioOutput(
+ AudioOutput: *mut *mut ISpeechObjectToken,
+ ) -> HRESULT,
+ fn putref_AudioOutput(
+ AudioOutput: *mut ISpeechObjectToken,
+ ) -> HRESULT,
+ fn get_AudioOutputStream(
+ AudioOutputStream: *mut *mut ISpeechBaseStream,
+ ) -> HRESULT,
+ fn putref_AudioOutputStream(
+ AudioOutputStream: *mut ISpeechBaseStream,
+ ) -> HRESULT,
+ fn get_Rate(
+ Rate: *mut c_long,
+ ) -> HRESULT,
+ fn put_Rate(
+ Rate: c_long,
+ ) -> HRESULT,
+ fn get_Volume(
+ Volume: *mut c_long,
+ ) -> HRESULT,
+ fn put_Volume(
+ Volume: c_long,
+ ) -> HRESULT,
+ fn put_AllowAudioOutputFormatChangesOnNextSet(
+ Allow: VARIANT_BOOL,
+ ) -> HRESULT,
+ fn get_AllowAudioOutputFormatChangesOnNextSet(
+ Allow: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+ fn get_EventInterests(
+ EventInterestFlags: *mut SpeechVoiceEvents,
+ ) -> HRESULT,
+ fn put_EventInterests(
+ EventInterestFlags: SpeechVoiceEvents,
+ ) -> HRESULT,
+ fn put_Priority(
+ Priority: SpeechVoicePriority,
+ ) -> HRESULT,
+ fn get_Priority(
+ Priority: *mut SpeechVoicePriority,
+ ) -> HRESULT,
+ fn put_AlertBoundary(
+ Boundary: SpeechVoiceEvents,
+ ) -> HRESULT,
+ fn get_AlertBoundary(
+ Boundary: *mut SpeechVoiceEvents,
+ ) -> HRESULT,
+ fn put_SynchronousSpeakTimeout(
+ msTimeout: c_long,
+ ) -> HRESULT,
+ fn get_SynchronousSpeakTimeout(
+ msTimeOut: *mut c_long,
+ ) -> HRESULT,
+ fn Speak(
+ Text: BSTR,
+ Flags: SpeechVoiceSpeakFlags,
+ StreamNumber: *mut c_long,
+ ) -> HRESULT,
+ fn SpeakStream(
+ Stream: *mut ISpeechBaseStream,
+ Flags: SpeechVoiceSpeakFlags,
+ StreamNumber: *mut c_long,
+ ) -> HRESULT,
+ fn Pause() -> HRESULT,
+ fn Resume() -> HRESULT,
+ fn Skip(
+ Type: BSTR,
+ NumItems: c_long,
+ NumSkipped: c_long,
+ ) -> HRESULT,
+ fn GetVoices(
+ RequiredAttributes: BSTR,
+ OptionalAttributes: BSTR,
+ ObjectTokens: *mut *mut ISpeechObjectTokens,
+ ) -> HRESULT,
+ fn GetAudioOutputs(
+ RequiredAttributes: BSTR,
+ OptionalAttributes: BSTR,
+ ObjectTokens: *mut *mut ISpeechObjectTokens,
+ ) -> HRESULT,
+ fn WaitUntilDone(
+ msTimeout: c_long,
+ Done: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+ fn SpeakCompleteEvent(
+ Handle: *mut c_long,
+ ) -> HRESULT,
+ fn IsUISupported(
+ TypeOfUI: BSTR,
+ ExtraData: *const VARIANT,
+ Supported: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+ fn DisplayUI(
+ hWndParent: c_long,
+ Title: BSTR,
+ TypeOfUI: BSTR,
+ ExtraData: *const VARIANT,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x8be47b07, 0x57f6, 0x11d2, 0x9e, 0xee, 0x00, 0xc0, 0x4f, 0x79, 0x73, 0x96)]
+interface ISpeechVoiceStatus(ISpeechVoiceStatusVtbl): IDispatch(IDispatchVtbl) {
+ fn get_CurrentStreamNumber(
+ StreamNumber: *mut c_long,
+ ) -> HRESULT,
+ fn get_LastStreamNumberQueued(
+ StreamNumber: *mut c_long,
+ ) -> HRESULT,
+ fn get_LastHResult(
+ HResult: *mut c_long,
+ ) -> HRESULT,
+ fn get_RunningState(
+ State: *mut SpeechRunState,
+ ) -> HRESULT,
+ fn get_InputWordPosition(
+ Position: *mut c_long,
+ ) -> HRESULT,
+ fn get_InputWordLength(
+ Length: *mut c_long,
+ ) -> HRESULT,
+ fn get_InputSentencePosition(
+ Position: *mut c_long,
+ ) -> HRESULT,
+ fn get_InputSentenceLength(
+ Length: *mut c_long,
+ ) -> HRESULT,
+ fn get_LastBookmark(
+ Bookmark: *mut BSTR,
+ ) -> HRESULT,
+ fn get_LastBookmarkId(
+ BookmarkId: *mut c_long,
+ ) -> HRESULT,
+ fn get_PhonemeId(
+ PhoneId: *mut c_short,
+ ) -> HRESULT,
+ fn get_VisemeId(
+ VisemeId: *mut c_short,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xa372acd1, 0x3bef, 0x4bbd, 0x8f, 0xfb, 0xcb, 0x3e, 0x2b, 0x41, 0x6a, 0xf8)]
+interface _ISpeechVoiceEvents(_ISpeechVoiceEventsVtbl): IDispatch(IDispatchVtbl) {}}
+RIDL!{#[uuid(0x2d5f1c0c, 0xbd75, 0x4b08, 0x94, 0x78, 0x3b, 0x11, 0xfe, 0xa2, 0x58, 0x6c)]
+interface ISpeechRecognizer(ISpeechRecognizerVtbl): IDispatch(IDispatchVtbl) {
+ fn putref_Recognizer(
+ Recognizer: *mut ISpeechObjectToken,
+ ) -> HRESULT,
+ fn get_Recognizer(
+ Recognizer: *mut *mut ISpeechObjectToken,
+ ) -> HRESULT,
+ fn put_AllowAudioInputFormatChangesOnNextSet(
+ Allow: VARIANT_BOOL,
+ ) -> HRESULT,
+ fn get_AllowAudioInputFormatChangesOnNextSet(
+ Allow: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+ fn putref_AudioInput(
+ AudioInput: *mut ISpeechObjectToken,
+ ) -> HRESULT,
+ fn get_AudioInput(
+ AudioInput: *mut *mut ISpeechObjectToken,
+ ) -> HRESULT,
+ fn putref_AudioInputStream(
+ AudioInputStream: *mut ISpeechBaseStream,
+ ) -> HRESULT,
+ fn get_AudioInputStream(
+ AudioInputStream: *mut *mut ISpeechBaseStream,
+ ) -> HRESULT,
+ fn get_IsShared(
+ Shared: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+ fn put_State(
+ State: SpeechRecognizerState,
+ ) -> HRESULT,
+ fn get_State(
+ State: *mut SpeechRecognizerState,
+ ) -> HRESULT,
+ fn get_Status(
+ Status: *mut *mut ISpeechRecognizerStatus,
+ ) -> HRESULT,
+ fn putref_Profile(
+ Profile: *mut ISpeechObjectToken,
+ ) -> HRESULT,
+ fn get_Profile(
+ Profile: *mut *mut ISpeechObjectToken,
+ ) -> HRESULT,
+ fn EmulateRecognition(
+ TextElements: VARIANT,
+ ElementDisplayAttributes: *mut VARIANT,
+ LanguageId: c_long,
+ ) -> HRESULT,
+ fn CreateRecoContext(
+ NewContext: *mut *mut ISpeechRecoContext,
+ ) -> HRESULT,
+ fn GetFormat(
+ Type: SpeechFormatType,
+ Format: *mut *mut ISpeechAudioFormat,
+ ) -> HRESULT,
+ fn SetPropertyNumber(
+ Name: BSTR,
+ Value: c_long,
+ Supported: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+ fn GetPropertyNumber(
+ Name: BSTR,
+ Value: *mut c_long,
+ Supported: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+ fn SetPropertyString(
+ Name: BSTR,
+ Value: BSTR,
+ Supported: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+ fn GetPropertyString(
+ Name: BSTR,
+ Value: *mut BSTR,
+ Supported: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+ fn IsUISupported(
+ TypeOfUI: BSTR,
+ ExtraData: *const VARIANT,
+ Supported: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+ fn DisplayUI(
+ hWndParent: c_long,
+ Title: BSTR,
+ TypeOfUI: BSTR,
+ ExtraData: *const VARIANT,
+ ) -> HRESULT,
+ fn GetRecognizers(
+ RequiredAttributes: BSTR,
+ OptionalAttributes: BSTR,
+ ObjectTokens: *mut *mut ISpeechObjectTokens,
+ ) -> HRESULT,
+ fn GetAudioInputs(
+ RequiredAttributes: BSTR,
+ OptionalAttributes: BSTR,
+ ObjectTokens: *mut *mut ISpeechObjectTokens,
+ ) -> HRESULT,
+ fn GetProfiles(
+ RequiredAttributes: BSTR,
+ OptionalAttributes: BSTR,
+ ObjectTokens: *mut *mut ISpeechObjectTokens,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xbff9e781, 0x53ec, 0x484e, 0xbb, 0x8a, 0x0e, 0x1b, 0x55, 0x51, 0xe3, 0x5c)]
+interface ISpeechRecognizerStatus(ISpeechRecognizerStatusVtbl): IDispatch(IDispatchVtbl) {
+ fn get_AudioStatus(
+ AudioStatus: *mut *mut ISpeechAudioStatus,
+ ) -> HRESULT,
+ fn get_CurrentStreamPosition(
+ pCurrentStreamPos: *mut VARIANT,
+ ) -> HRESULT,
+ fn get_CurrentStreamNumber(
+ StreamNumber: *mut c_long,
+ ) -> HRESULT,
+ fn get_NumberOfActiveRules(
+ NumberOfActiveRules: *mut c_long,
+ ) -> HRESULT,
+ fn get_ClsidEngine(
+ ClsidEngine: *mut BSTR,
+ ) -> HRESULT,
+ fn get_SupportedLanguages(
+ SupportedLanguages: *mut VARIANT,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x580aa49d, 0x7e1e, 0x4809, 0xb8, 0xe2, 0x57, 0xda, 0x80, 0x61, 0x04, 0xb8)]
+interface ISpeechRecoContext(ISpeechRecoContextVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Recognizer(
+ Recognizer: *mut *mut ISpeechRecognizer,
+ ) -> HRESULT,
+ fn get_AudioInputInterferenceStatus(
+ Interference: *mut SpeechInterference,
+ ) -> HRESULT,
+ fn get_RequestedUIType(
+ UIType: *mut BSTR,
+ ) -> HRESULT,
+ fn putref_Voice(
+ Voice: *mut ISpeechVoice,
+ ) -> HRESULT,
+ fn get_Voice(
+ Voice: *mut *mut ISpeechVoice,
+ ) -> HRESULT,
+ fn put_AllowVoiceFormatMatchingOnNextSet(
+ Allow: VARIANT_BOOL,
+ ) -> HRESULT,
+ fn get_AllowVoiceFormatMatchingOnNextSet(
+ Allow: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+ fn put_VoicePurgeEvent(
+ EventInterest: SpeechRecoEvents,
+ ) -> HRESULT,
+ fn get_VoicePurgeEvent(
+ EventInterest: *mut SpeechRecoEvents,
+ ) -> HRESULT,
+ fn put_EventInterests(
+ EventInterest: SpeechRecoEvents,
+ ) -> HRESULT,
+ fn get_EventInterests(
+ EventInterest: *mut SpeechRecoEvents,
+ ) -> HRESULT,
+ fn put_CmdMaxAlternates(
+ MaxAlternates: c_long,
+ ) -> HRESULT,
+ fn get_CmdMaxAlternates(
+ MaxAlternates: *mut c_long,
+ ) -> HRESULT,
+ fn put_State(
+ State: SpeechRecoContextState,
+ ) -> HRESULT,
+ fn get_State(
+ State: *mut SpeechRecoContextState,
+ ) -> HRESULT,
+ fn put_RetainedAudio(
+ Option: SpeechRetainedAudioOptions,
+ ) -> HRESULT,
+ fn get_RetainedAudio(
+ Option: *mut SpeechRetainedAudioOptions,
+ ) -> HRESULT,
+ fn putref_RetainedAudioFormat(
+ Format: *mut ISpeechAudioFormat,
+ ) -> HRESULT,
+ fn get_RetainedAudioFormat(
+ Format: *mut *mut ISpeechAudioFormat,
+ ) -> HRESULT,
+ fn Pause() -> HRESULT,
+ fn Resume() -> HRESULT,
+ fn CreateGrammar(
+ GrammarId: VARIANT,
+ Grammar: *mut *mut ISpeechRecoGrammar,
+ ) -> HRESULT,
+ fn CreateResultFromMemory(
+ ResultBlock: *mut VARIANT,
+ Result: *mut *mut ISpeechRecoResult,
+ ) -> HRESULT,
+ fn Bookmark(
+ Options: SpeechBookmarkOptions,
+ StreamPos: VARIANT,
+ BookmarkId: VARIANT,
+ ) -> HRESULT,
+ fn SetAdaptationData(
+ AdaptationString: BSTR,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xb6d6f79f, 0x2158, 0x4e50, 0xb5, 0xbc, 0x9a, 0x9c, 0xcd, 0x85, 0x2a, 0x09)]
+interface ISpeechRecoGrammar(ISpeechRecoGrammarVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Id(
+ Id: *mut VARIANT,
+ ) -> HRESULT,
+ fn get_RecoContext(
+ RecoContext: *mut *mut ISpeechRecoContext,
+ ) -> HRESULT,
+ fn put_State(
+ State: SpeechGrammarState,
+ ) -> HRESULT,
+ fn get_State(
+ State: *mut SpeechGrammarState,
+ ) -> HRESULT,
+ fn get_Rules(
+ Rules: *mut *mut ISpeechGrammarRules,
+ ) -> HRESULT,
+ fn Reset(
+ NewLanguage: SpeechLanguageId,
+ ) -> HRESULT,
+ fn CmdLoadFromFile(
+ FileName: BSTR,
+ LoadOption: SpeechLoadOption,
+ ) -> HRESULT,
+ fn CmdLoadFromObject(
+ ClassId: BSTR,
+ GrammarName: BSTR,
+ LoadOption: SpeechLoadOption,
+ ) -> HRESULT,
+ fn CmdLoadFromResource(
+ hModule: c_long,
+ ResourceName: VARIANT,
+ ResourceType: VARIANT,
+ LanguageId: SpeechLanguageId,
+ LoadOption: SpeechLoadOption,
+ ) -> HRESULT,
+ fn CmdLoadFromMemory(
+ GrammarData: VARIANT,
+ LoadOption: SpeechLoadOption,
+ ) -> HRESULT,
+ fn CmdLoadFromProprietaryGrammar(
+ ProprietaryGuid: BSTR,
+ PriorietaryString: BSTR,
+ ProprietaryData: VARIANT,
+ LoadOption: SpeechLoadOption,
+ ) -> HRESULT,
+ fn CmdSetRuleState(
+ Name: BSTR,
+ State: SpeechRuleState,
+ ) -> HRESULT,
+ fn CmdSetRuleIdState(
+ RuleId: c_long,
+ State: SpeechRuleState,
+ ) -> HRESULT,
+ fn DictationLoad(
+ TopicName: BSTR,
+ LoadOption: SpeechLoadOption,
+ ) -> HRESULT,
+ fn DictationUnload() -> HRESULT,
+ fn DictationSetState(
+ State: SpeechRuleState,
+ ) -> HRESULT,
+ fn SetWordSequenceData(
+ Text: BSTR,
+ TextLength: c_long,
+ Info: *mut ISpeechTextSelectionInformation,
+ ) -> HRESULT,
+ fn SetTextSelection(
+ Info: *mut ISpeechTextSelectionInformation,
+ ) -> HRESULT,
+ fn IsPronounceable(
+ Word: BSTR,
+ WordPronounceable: *mut SpeechWordPronounceable,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x7b8fcb42, 0x0e9d, 0x4f00, 0xa0, 0x48, 0x7b, 0x04, 0xd6, 0x17, 0x9d, 0x3d)]
+interface _ISpeechRecoContextEvents(_ISpeechRecoContextEventsVtbl): IDispatch(IDispatchVtbl) {}}
+RIDL!{#[uuid(0xafe719cf, 0x5dd1, 0x44f2, 0x99, 0x9c, 0x7a, 0x39, 0x9f, 0x1c, 0xfc, 0xcc)]
+interface ISpeechGrammarRule(ISpeechGrammarRuleVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Attributes(
+ Attributes: *mut SpeechRuleAttributes,
+ ) -> HRESULT,
+ fn get_InitialState(
+ State: *mut *mut ISpeechGrammarRuleState,
+ ) -> HRESULT,
+ fn get_Name(
+ Name: *mut BSTR,
+ ) -> HRESULT,
+ fn get_Id(
+ Id: *mut c_long,
+ ) -> HRESULT,
+ fn Clear() -> HRESULT,
+ fn AddResource(
+ ResourceName: BSTR,
+ ResourceValue: BSTR,
+ ) -> HRESULT,
+ fn AddState(
+ State: *mut *mut ISpeechGrammarRuleState,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x6ffa3b44, 0xfc2d, 0x40d1, 0x8a, 0xfc, 0x32, 0x91, 0x1c, 0x7f, 0x1a, 0xd1)]
+interface ISpeechGrammarRules(ISpeechGrammarRulesVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Count(
+ Count: *mut c_long,
+ ) -> HRESULT,
+ fn FindRule(
+ RuleNameOrId: VARIANT,
+ Rule: *mut *mut ISpeechGrammarRule,
+ ) -> HRESULT,
+ fn Item(
+ Index: c_long,
+ Rule: *mut *mut ISpeechGrammarRule,
+ ) -> HRESULT,
+ fn get__NewEnum(
+ EnumVARIANT: *mut *mut IUnknown,
+ ) -> HRESULT,
+ fn get_Dynamic(
+ Dynamic: *mut VARIANT_BOOL,
+ ) -> HRESULT,
+ fn Add(
+ RuleName: BSTR,
+ Attributes: SpeechRuleAttributes,
+ RuleId: c_long,
+ Rule: *mut *mut ISpeechGrammarRule,
+ ) -> HRESULT,
+ fn Commit() -> HRESULT,
+ fn CommitAndSave(
+ ErrorText: *mut BSTR,
+ SaveStream: *mut VARIANT,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xd4286f2c, 0xee67, 0x45ae, 0xb9, 0x28, 0x28, 0xd6, 0x95, 0x36, 0x2e, 0xda)]
+interface ISpeechGrammarRuleState(ISpeechGrammarRuleStateVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Rule(
+ Rule: *mut *mut ISpeechGrammarRule,
+ ) -> HRESULT,
+ fn get_Transitions(
+ Transitions: *mut *mut ISpeechGrammarRuleStateTransitions,
+ ) -> HRESULT,
+ fn AddWordTransition(
+ DestState: *mut ISpeechGrammarRuleState,
+ Words: BSTR,
+ Separators: BSTR,
+ Type: SpeechGrammarWordType,
+ PropertyName: BSTR,
+ PropertyId: c_long,
+ PropertyValue: *mut VARIANT,
+ Weight: c_float,
+ ) -> HRESULT,
+ fn AddRuleTransition(
+ DestinationState: *mut ISpeechGrammarRuleState,
+ Rule: *mut ISpeechGrammarRule,
+ PropertyName: BSTR,
+ PropertyId: c_long,
+ PropertyValue: *mut VARIANT,
+ Weight: c_float,
+ ) -> HRESULT,
+ fn AddSpecialTransition(
+ DestinationState: *mut ISpeechGrammarRuleState,
+ Type: SpeechSpecialTransitionType,
+ PropertyName: BSTR,
+ PropertyId: c_long,
+ PropertyValue: *mut VARIANT,
+ Weight: c_float,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xcafd1db1, 0x41d1, 0x4a06, 0x98, 0x63, 0xe2, 0xe8, 0x1d, 0xa1, 0x7a, 0x9a)]
+interface ISpeechGrammarRuleStateTransition(ISpeechGrammarRuleStateTransitionVtbl):
+ IDispatch(IDispatchVtbl) {
+ fn get_Type(
+ Type: *mut SpeechGrammarRuleStateTransitionType,
+ ) -> HRESULT,
+ fn get_Text(
+ Text: *mut BSTR,
+ ) -> HRESULT,
+ fn get_Rule(
+ Rule: *mut *mut ISpeechGrammarRule,
+ ) -> HRESULT,
+ fn get_Weight(
+ Weight: *mut VARIANT,
+ ) -> HRESULT,
+ fn get_PropertyName(
+ PropertyName: *mut BSTR,
+ ) -> HRESULT,
+ fn get_PropertyId(
+ PropertyId: *mut c_long,
+ ) -> HRESULT,
+ fn get_PropertyValue(
+ PropertyValue: *mut VARIANT,
+ ) -> HRESULT,
+ fn get_NextState(
+ NextState: *mut *mut ISpeechGrammarRuleState,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xeabce657, 0x75bc, 0x44a2, 0xaa, 0x7f, 0xc5, 0x64, 0x76, 0x74, 0x29, 0x63)]
+interface ISpeechGrammarRuleStateTransitions(ISpeechGrammarRuleStateTransitionsVtbl):
+ IDispatch(IDispatchVtbl) {
+ fn get_Count(
+ Count: *mut c_long,
+ ) -> HRESULT,
+ fn Item(
+ Index: c_long,
+ Transition: *mut *mut ISpeechGrammarRuleStateTransition,
+ ) -> HRESULT,
+ fn get__NewEnum(
+ EnumVARIANT: *mut *mut IUnknown,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x3b9c7e7a, 0x6eee, 0x4ded, 0x90, 0x92, 0x11, 0x65, 0x72, 0x79, 0xad, 0xbe)]
+interface ISpeechTextSelectionInformation(ISpeechTextSelectionInformationVtbl):
+ IDispatch(IDispatchVtbl) {
+ fn put_ActiveOffset(
+ ActiveOffset: c_long,
+ ) -> HRESULT,
+ fn get_ActiveOffset(
+ ActiveOffset: *mut c_long,
+ ) -> HRESULT,
+ fn put_ActiveLength(
+ ActiveLength: c_long,
+ ) -> HRESULT,
+ fn get_ActiveLength(
+ ActiveLength: *mut c_long,
+ ) -> HRESULT,
+ fn put_SelectionOffset(
+ SelectionOffset: c_long,
+ ) -> HRESULT,
+ fn get_SelectionOffset(
+ SelectionOffset: *mut c_long,
+ ) -> HRESULT,
+ fn put_SelectionLength(
+ SelectionLength: c_long,
+ ) -> HRESULT,
+ fn get_SelectionLength(
+ SelectionLength: *mut c_long,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xed2879cf, 0xced9, 0x4ee6, 0xa5, 0x34, 0xde, 0x01, 0x91, 0xd5, 0x46, 0x8d)]
+interface ISpeechRecoResult(ISpeechRecoResultVtbl): IDispatch(IDispatchVtbl) {
+ fn get_RecoContext(
+ RecoContext: *mut *mut ISpeechRecoContext,
+ ) -> HRESULT,
+ fn get_Times(
+ Times: *mut *mut ISpeechRecoResultTimes,
+ ) -> HRESULT,
+ fn putref_AudioFormat(
+ Format: *mut ISpeechAudioFormat,
+ ) -> HRESULT,
+ fn get_AudioFormat(
+ Format: *mut *mut ISpeechAudioFormat,
+ ) -> HRESULT,
+ fn get_PhraseInfo(
+ PhraseInfo: *mut *mut ISpeechPhraseInfo,
+ ) -> HRESULT,
+ fn Alternates(
+ RequestCount: c_long,
+ StartElement: c_long,
+ Elements: c_long,
+ Alternates: *mut *mut ISpeechPhraseAlternates,
+ ) -> HRESULT,
+ fn Audio(
+ StartElement: c_long,
+ Elements: c_long,
+ Stream: *mut *mut ISpeechMemoryStream,
+ ) -> HRESULT,
+ fn SpeakAudio(
+ StartElement: c_long,
+ Elements: c_long,
+ Flags: SpeechVoiceSpeakFlags,
+ StreamNumber: *mut c_long,
+ ) -> HRESULT,
+ fn SaveToMemory(
+ ResultBlock: *mut VARIANT,
+ ) -> HRESULT,
+ fn DiscardResultInfo(
+ ValueTypes: SpeechDiscardType,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x62b3b8fb, 0xf6e7, 0x41be, 0xbd, 0xcb, 0x05, 0x6b, 0x1c, 0x29, 0xef, 0xc0)]
+interface ISpeechRecoResultTimes(ISpeechRecoResultTimesVtbl): IDispatch(IDispatchVtbl) {
+ fn get_StreamTime(
+ Time: *mut VARIANT,
+ ) -> HRESULT,
+ fn get_Length(
+ Length: *mut VARIANT,
+ ) -> HRESULT,
+ fn get_TickCount(
+ TickCount: *mut c_long,
+ ) -> HRESULT,
+ fn get_OffsetFromStart(
+ OffsetFromStart: *mut VARIANT,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x27864a2a, 0x2b9f, 0x4cb8, 0x92, 0xd3, 0x0d, 0x27, 0x22, 0xfd, 0x1e, 0x73)]
+interface ISpeechPhraseAlternate(ISpeechPhraseAlternateVtbl): IDispatch(IDispatchVtbl) {
+ fn get_RecoResult(
+ RecoResult: *mut *mut ISpeechRecoResult,
+ ) -> HRESULT,
+ fn get_StartElementInResult(
+ StartElement: *mut c_long,
+ ) -> HRESULT,
+ fn get_NumberOfElementsInResult(
+ NumberOfElements: *mut c_long,
+ ) -> HRESULT,
+ fn get_PhraseInfo(
+ PhraseInfo: *mut *mut ISpeechPhraseInfo,
+ ) -> HRESULT,
+ fn Commit() -> HRESULT,
+}}
+RIDL!{#[uuid(0xb238b6d5, 0xf276, 0x4c3d, 0xa6, 0xc1, 0x29, 0x74, 0x80, 0x1c, 0x3c, 0xc2)]
+interface ISpeechPhraseAlternates(ISpeechPhraseAlternatesVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Count(
+ Count: *mut c_long,
+ ) -> HRESULT,
+ fn Item(
+ Index: c_long,
+ PhraseAlternate: *mut *mut ISpeechPhraseAlternate,
+ ) -> HRESULT,
+ fn get__NewEnum(
+ EnumVARIANT: *mut *mut IUnknown,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x961559cf, 0x4e67, 0x4662, 0x8b, 0xf0, 0xd9, 0x3f, 0x1f, 0xcd, 0x61, 0xb3)]
+interface ISpeechPhraseInfo(ISpeechPhraseInfoVtbl): IDispatch(IDispatchVtbl) {
+ fn get_LanguageId(
+ LanguageId: *mut c_long,
+ ) -> HRESULT,
+ fn get_GrammarId(
+ GrammarId: *mut VARIANT,
+ ) -> HRESULT,
+ fn get_StartTime(
+ StartTime: *mut VARIANT,
+ ) -> HRESULT,
+ fn get_AudioStreamPosition(
+ AudioStreamPosition: *mut VARIANT,
+ ) -> HRESULT,
+ fn get_AudioSizeBytes(
+ pAudioSizeBytes: *mut c_long,
+ ) -> HRESULT,
+ fn get_RetainedSizeBytes(
+ RetainedSizeBytes: *mut c_long,
+ ) -> HRESULT,
+ fn get_AudioSizeTime(
+ AudioSizeTime: *mut c_long,
+ ) -> HRESULT,
+ fn get_Rule(
+ Rule: *mut *mut ISpeechPhraseRule,
+ ) -> HRESULT,
+ fn get_Properties(
+ Properties: *mut *mut ISpeechPhraseProperties,
+ ) -> HRESULT,
+ fn get_Elements(
+ Elements: *mut *mut ISpeechPhraseElements,
+ ) -> HRESULT,
+ fn get_Replacements(
+ Replacements: *mut *mut ISpeechPhraseReplacements,
+ ) -> HRESULT,
+ fn get_EngineId(
+ EngineIdGuid: *mut BSTR,
+ ) -> HRESULT,
+ fn get_EnginePrivateData(
+ PrivateData: *mut VARIANT,
+ ) -> HRESULT,
+ fn SaveToMemory(
+ PhraseBlock: *mut VARIANT,
+ ) -> HRESULT,
+ fn GetText(
+ StartElement: c_long,
+ Elements: c_long,
+ UseReplacements: VARIANT_BOOL,
+ Text: *mut BSTR,
+ ) -> HRESULT,
+ fn GetDisplayAttributes(
+ StartElement: c_long,
+ Elements: c_long,
+ UseReplacements: VARIANT_BOOL,
+ DisplayAttributes: *mut SpeechDisplayAttributes,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xe6176f96, 0xe373, 0x4801, 0xb2, 0x23, 0x3b, 0x62, 0xc0, 0x68, 0xc0, 0xb4)]
+interface ISpeechPhraseElement(ISpeechPhraseElementVtbl): IDispatch(IDispatchVtbl) {
+ fn get_AudioTimeOffset(
+ AudioTimeOffset: *mut c_long,
+ ) -> HRESULT,
+ fn get_AudioSizeTime(
+ AudioSizeTime: *mut c_long,
+ ) -> HRESULT,
+ fn get_AudioStreamOffset(
+ AudioStreamOffset: *mut c_long,
+ ) -> HRESULT,
+ fn get_AudioSizeBytes(
+ AudioSizeBytes: *mut c_long,
+ ) -> HRESULT,
+ fn get_RetainedStreamOffset(
+ RetainedStreamOffset: *mut c_long,
+ ) -> HRESULT,
+ fn get_RetainedSizeBytes(
+ RetainedSizeBytes: *mut c_long,
+ ) -> HRESULT,
+ fn get_DisplayText(
+ DisplayText: *mut BSTR,
+ ) -> HRESULT,
+ fn get_LexicalForm(
+ LexicalForm: *mut BSTR,
+ ) -> HRESULT,
+ fn get_Pronunciation(
+ Pronunciation: *mut VARIANT,
+ ) -> HRESULT,
+ fn get_DisplayAttributes(
+ DisplayAttributes: *mut SpeechDisplayAttributes,
+ ) -> HRESULT,
+ fn get_RequiredConfidence(
+ RequiredConfidence: *mut SpeechEngineConfidence,
+ ) -> HRESULT,
+ fn get_ActualConfidence(
+ ActualConfidence: *mut SpeechEngineConfidence,
+ ) -> HRESULT,
+ fn get_EngineConfidence(
+ EngineConfident: *mut c_float,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x0626b328, 0x3478, 0x467d, 0xa0, 0xb3, 0xd0, 0x85, 0x3b, 0x93, 0xdd, 0xa3)]
+interface ISpeechPhraseElements(ISpeechPhraseElementsVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Count(
+ Count: *mut c_long,
+ ) -> HRESULT,
+ fn Item(
+ Index: c_long,
+ Element: *mut *mut ISpeechPhraseElement,
+ ) -> HRESULT,
+ fn get__NewEnum(
+ EnumVARIANT: *mut *mut IUnknown,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x2890a410, 0x53a7, 0x4fb5, 0x94, 0xec, 0x06, 0xd4, 0x99, 0x8e, 0x3d, 0x02)]
+interface ISpeechPhraseReplacement(ISpeechPhraseReplacementVtbl): IDispatch(IDispatchVtbl) {
+ fn get_DisplayAttributes(
+ DisplayAttributes: *mut SpeechDisplayAttributes,
+ ) -> HRESULT,
+ fn get_Text(
+ Text: *mut BSTR,
+ ) -> HRESULT,
+ fn get_FirstElement(
+ FirstElement: *mut c_long,
+ ) -> HRESULT,
+ fn get_NumberOfElements(
+ NumberOfElements: *mut c_long,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x38bc662f, 0x2257, 0x4525, 0x95, 0x9e, 0x20, 0x69, 0xd2, 0x59, 0x6c, 0x05)]
+interface ISpeechPhraseReplacements(ISpeechPhraseReplacementsVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Count(
+ Count: *mut c_long,
+ ) -> HRESULT,
+ fn Item(
+ Index: c_long,
+ Reps: *mut *mut ISpeechPhraseReplacement,
+ ) -> HRESULT,
+ fn get__NewEnum(
+ EnumVARIANT: *mut *mut IUnknown,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xce563d48, 0x961e, 0x4732, 0xa2, 0xe1, 0x37, 0x8a, 0x42, 0xb4, 0x30, 0xbe)]
+interface ISpeechPhraseProperty(ISpeechPhrasePropertyVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Name(
+ Name: *mut BSTR,
+ ) -> HRESULT,
+ fn get_Id(
+ Id: *mut c_long,
+ ) -> HRESULT,
+ fn get_Value(
+ Value: *mut VARIANT,
+ ) -> HRESULT,
+ fn get_FirstElement(
+ FirstElement: *mut c_long,
+ ) -> HRESULT,
+ fn get_NumberOfElements(
+ NumberOfElements: *mut c_long,
+ ) -> HRESULT,
+ fn get_EngineConfidence(
+ Confidence: *mut c_float,
+ ) -> HRESULT,
+ fn get_Confidence(
+ Confidence: *mut SpeechEngineConfidence,
+ ) -> HRESULT,
+ fn get_Parent(
+ ParentProperty: *mut *mut ISpeechPhraseProperty,
+ ) -> HRESULT,
+ fn get_Children(
+ Children: *mut *mut ISpeechPhraseProperties,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x08166b47, 0x102e, 0x4b23, 0xa5, 0x99, 0xbd, 0xb9, 0x8d, 0xbf, 0xd1, 0xf4)]
+interface ISpeechPhraseProperties(ISpeechPhrasePropertiesVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Count(
+ Count: *mut c_long,
+ ) -> HRESULT,
+ fn Item(
+ Index: c_long,
+ Property: *mut *mut ISpeechPhraseProperty,
+ ) -> HRESULT,
+ fn get__NewEnum(
+ EnumVARIANT: *mut *mut IUnknown,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xa7bfe112, 0xa4a0, 0x48d9, 0xb6, 0x02, 0xc3, 0x13, 0x84, 0x3f, 0x69, 0x64)]
+interface ISpeechPhraseRule(ISpeechPhraseRuleVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Name(
+ Name: *mut BSTR,
+ ) -> HRESULT,
+ fn get_Id(
+ Id: *mut c_long,
+ ) -> HRESULT,
+ fn get_FirstElement(
+ FirstElement: *mut c_long,
+ ) -> HRESULT,
+ fn get_NumberOfElements(
+ NumberOfElements: *mut c_long,
+ ) -> HRESULT,
+ fn get_Parent(
+ Parent: *mut *mut ISpeechPhraseRule,
+ ) -> HRESULT,
+ fn get_Children(
+ Children: *mut *mut ISpeechPhraseRules,
+ ) -> HRESULT,
+ fn get_Confidence(
+ ActualConfidence: *mut SpeechEngineConfidence,
+ ) -> HRESULT,
+ fn get_EngineConfidence(
+ Confidence: *mut c_float,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x9047d593, 0x01dd, 0x4b72, 0x81, 0xa3, 0xe4, 0xa0, 0xca, 0x69, 0xf4, 0x07)]
+interface ISpeechPhraseRules(ISpeechPhraseRulesVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Count(
+ Count: *mut c_long,
+ ) -> HRESULT,
+ fn Item(
+ Index: c_long,
+ Rule: *mut *mut ISpeechPhraseRule,
+ ) -> HRESULT,
+ fn get__NewEnum(
+ EnumVARIANT: *mut *mut IUnknown,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x3da7627a, 0xc7ae, 0x4b23, 0x87, 0x08, 0x63, 0x8c, 0x50, 0x36, 0x2c, 0x25)]
+interface ISpeechLexicon(ISpeechLexiconVtbl): IDispatch(IDispatchVtbl) {
+ fn get_GenerationId(
+ GenerationId: *mut c_long,
+ ) -> HRESULT,
+ fn GetWords(
+ Flags: SpeechLexiconType,
+ GenerationID: *mut c_long,
+ Words: *mut *mut ISpeechLexiconWords,
+ ) -> HRESULT,
+ fn AddPronunciation(
+ bstrWord: BSTR,
+ LangId: SpeechLanguageId,
+ PartOfSpeech: SpeechPartOfSpeech,
+ bstrPronunciation: BSTR,
+ ) -> HRESULT,
+ fn AddPronunciationByPhoneIds(
+ bstrWord: BSTR,
+ LangId: SpeechLanguageId,
+ PartOfSpeech: SpeechPartOfSpeech,
+ PhoneIds: *mut VARIANT,
+ ) -> HRESULT,
+ fn RemovePronunciation(
+ bstrWord: BSTR,
+ LangId: SpeechLanguageId,
+ PartOfSpeech: SpeechPartOfSpeech,
+ bstrPronunciation: BSTR,
+ ) -> HRESULT,
+ fn RemovePronunciationByPhoneIds(
+ bstrWord: BSTR,
+ LangId: SpeechLanguageId,
+ PartOfSpeech: SpeechPartOfSpeech,
+ PhoneIds: *mut VARIANT,
+ ) -> HRESULT,
+ fn GetPronunciations(
+ bstrWord: BSTR,
+ LangId: SpeechLanguageId,
+ TypeFlags: SpeechLexiconType,
+ ppPronunciations: *mut *mut ISpeechLexiconPronunciations,
+ ) -> HRESULT,
+ fn GetGenerationChange(
+ GenerationID: *mut c_long,
+ ppWords: *mut *mut ISpeechLexiconWords,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x8d199862, 0x415e, 0x47d5, 0xac, 0x4f, 0xfa, 0xa6, 0x08, 0xb4, 0x24, 0xe6)]
+interface ISpeechLexiconWords(ISpeechLexiconWordsVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Count(
+ Count: *mut c_long,
+ ) -> HRESULT,
+ fn Item(
+ Index: c_long,
+ Word: *mut *mut ISpeechLexiconWord,
+ ) -> HRESULT,
+ fn get__NewEnum(
+ EnumVARIANT: *mut *mut IUnknown,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x4e5b933c, 0xc9be, 0x48ed, 0x88, 0x42, 0x1e, 0xe5, 0x1b, 0xb1, 0xd4, 0xff)]
+interface ISpeechLexiconWord(ISpeechLexiconWordVtbl): IDispatch(IDispatchVtbl) {
+ fn get_LangId(
+ LangId: *mut SpeechLanguageId,
+ ) -> HRESULT,
+ fn get_Type(
+ WordType: *mut SpeechWordType,
+ ) -> HRESULT,
+ fn get_Word(
+ Word: *mut BSTR,
+ ) -> HRESULT,
+ fn get_Pronunciations(
+ Pronunciations: *mut *mut ISpeechLexiconPronunciations,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x72829128, 0x5682, 0x4704, 0xa0, 0xd4, 0x3e, 0x2b, 0xb6, 0xf2, 0xea, 0xd3)]
+interface ISpeechLexiconPronunciations(ISpeechLexiconPronunciationsVtbl):
+ IDispatch(IDispatchVtbl) {
+ fn get_Count(
+ Count: *mut c_long,
+ ) -> HRESULT,
+ fn Item(
+ Index: c_long,
+ Pronunciation: *mut *mut ISpeechLexiconPronunciation,
+ ) -> HRESULT,
+ fn get__NewEnum(
+ EnumVARIANT: *mut *mut IUnknown,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x95252c5d, 0x9e43, 0x4f4a, 0x98, 0x99, 0x48, 0xee, 0x73, 0x35, 0x2f, 0x9f)]
+interface ISpeechLexiconPronunciation(ISpeechLexiconPronunciationVtbl): IDispatch(IDispatchVtbl) {
+ fn get_Type(
+ LexiconType: *mut SpeechLexiconType,
+ ) -> HRESULT,
+ fn get_LangId(
+ LangId: *mut SpeechLanguageId,
+ ) -> HRESULT,
+ fn get_PartOfSpeech(
+ PartOfSpeech: *mut SpeechPartOfSpeech,
+ ) -> HRESULT,
+ fn get_PhoneIds(
+ PhoneIds: *mut VARIANT,
+ ) -> HRESULT,
+ fn get_Symbolic(
+ Symbolic: *mut BSTR,
+ ) -> HRESULT,
+}}
+pub const Speech_Default_Weight: c_float = DEFAULT_WEIGHT;
+pub const Speech_Max_Word_Length: LONG = SP_MAX_WORD_LENGTH as i32;
+pub const Speech_Max_Pron_Length: LONG = SP_MAX_PRON_LENGTH as i32;
+pub const Speech_StreamPos_Asap: LONG = SP_STREAMPOS_ASAP as i32;
+pub const Speech_StreamPos_RealTime: LONG = SP_STREAMPOS_REALTIME as i32;
+pub const SpeechAllElements: LONG = SPPR_ALL_ELEMENTS as i32;
+RIDL!{#[uuid(0x3b151836, 0xdf3a, 0x4e0a, 0x84, 0x6c, 0xd2, 0xad, 0xc9, 0x33, 0x43, 0x33)]
+interface ISpeechPhraseInfoBuilder(ISpeechPhraseInfoBuilderVtbl): IDispatch(IDispatchVtbl) {
+ fn RestorePhraseFromMemory(
+ PhraseInMemory: *mut VARIANT,
+ PhraseInfo: *mut *mut ISpeechPhraseInfo,
+ ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xc3e4f353, 0x433f, 0x43d6, 0x89, 0xa1, 0x6a, 0x62, 0xa7, 0x05, 0x4c, 0x3d)]
+interface ISpeechPhoneConverter(ISpeechPhoneConverterVtbl): IDispatch(IDispatchVtbl) {
+ fn get_LanguageId(
+ LanguageId: *mut SpeechLanguageId,
+ ) -> HRESULT,
+ fn put_LanguageId(
+ LanguageId: SpeechLanguageId,
+ ) -> HRESULT,
+ fn PhoneToId(
+ Phonemes: BSTR,
+ IdArray: *mut VARIANT,
+ ) -> HRESULT,
+ fn IdToPhone(
+ IdArray: VARIANT,
+ Phonemes: *mut BSTR,
+ ) -> HRESULT,
+}}
+extern {
+ pub static CLSID_SpNotifyTranslator: CLSID;
+ pub static CLSID_SpObjectTokenCategory: CLSID;
+ pub static CLSID_SpObjectToken: CLSID;
+ pub static CLSID_SpResourceManager: CLSID;
+ pub static CLSID_SpStreamFormatConverter: CLSID;
+ pub static CLSID_SpMMAudioEnum: CLSID;
+ pub static CLSID_SpMMAudioIn: CLSID;
+ pub static CLSID_SpMMAudioOut: CLSID;
+ pub static CLSID_SpStream: CLSID;
+ pub static CLSID_SpVoice: CLSID;
+ pub static CLSID_SpSharedRecoContext: CLSID;
+ pub static CLSID_SpInprocRecognizer: CLSID;
+ pub static CLSID_SpSharedRecognizer: CLSID;
+ pub static CLSID_SpLexicon: CLSID;
+ pub static CLSID_SpUnCompressedLexicon: CLSID;
+ pub static CLSID_SpCompressedLexicon: CLSID;
+ pub static CLSID_SpPhoneConverter: CLSID;
+ pub static CLSID_SpNullPhoneConverter: CLSID;
+ pub static CLSID_SpTextSelectionInformation: CLSID;
+ pub static CLSID_SpPhraseInfoBuilder: CLSID;
+ pub static CLSID_SpAudioFormat: CLSID;
+ pub static CLSID_SpWaveFormatEx: CLSID;
+ pub static CLSID_SpInProcRecoContext: CLSID;
+ pub static CLSID_SpCustomStream: CLSID;
+ pub static CLSID_SpFileStream: CLSID;
+ pub static CLSID_SpMemoryStream: CLSID;
+}
Copyright © 2024 Valentin A. Popov. All Rights Reverse Engineered.