mozilla-central/third_party/rust/winapi/src/um/sapi51.rs

Source code

Revision control

Copy as Markdown

Other Tools

// 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;
}