| /** |
| * This file is part of the mingw-w64 runtime package. |
| * No warranty is given; refer to the file DISCLAIMER within this package. |
| */ |
| |
| #ifndef _SAPI_BLD_ |
| #define _SAPI_BLD_ 0x54 |
| #endif |
| |
| import "oaidl.idl"; |
| import "ocidl.idl"; |
| |
| cpp_quote("#ifndef _SAPI_VER") |
| cpp_quote("#error \"you have to include <sapi.h> header before this.\"") |
| cpp_quote("#endif") |
| |
| #ifndef LANGID |
| #define LANGID WORD |
| #endif |
| |
| cpp_quote("#if 0") |
| typedef [restricted, hidden] struct WAVEFORMATEX { |
| WORD wFormatTag; |
| WORD nChannels; |
| DWORD nSamplesPerSec; |
| DWORD nAvgBytesPerSec; |
| WORD nBlockAlign; |
| WORD wBitsPerSample; |
| WORD cbSize; |
| } WAVEFORMATEX; |
| cpp_quote("#endif") |
| |
| interface ISpNotifySource; |
| interface ISpNotifySink; |
| interface ISpNotifyTranslator; |
| interface ISpDataKey; |
| interface ISpObjectTokenCategory; |
| interface ISpObjectToken; |
| interface IEnumSpObjectTokens; |
| interface ISpObjectWithToken; |
| interface ISpResourceManager; |
| interface ISpEventSource; |
| interface ISpEventSink; |
| interface ISpStreamFormat; |
| interface ISpStream; |
| interface ISpStreamFormatConverter; |
| interface ISpAudio; |
| interface ISpMMSysAudio; |
| interface ISpTranscript; |
| interface ISpVoice; |
| interface ISpRecoResult; |
| interface ISpRecoContext; |
| interface ISpRecognizer; |
| interface ISpProperties; |
| interface ISpLexicon; |
| interface ISpPhoneConverter; |
| interface ISpPhrase; |
| #if _SAPI_BLD_ >= 0x53 |
| interface ISpRecoContext2; |
| interface ISpRecognizer2; |
| interface ISpShortcut; |
| interface ISpPhoneticAlphabetConverter; |
| interface ISpPhoneticAlphabetSelection; |
| interface ISpRecoGrammar2; |
| interface ISpeechResourceLoader; |
| #endif |
| #if _SAPI_BLD_ >= 0x54 |
| interface ISpRecognizer3; |
| #endif |
| |
| typedef [hidden] enum SPDATAKEYLOCATION { |
| SPDKL_DefaultLocation = 0, |
| SPDKL_CurrentUser = 1, |
| SPDKL_LocalMachine = 2, |
| SPDKL_CurrentConfig = 5 |
| } SPDATAKEYLOCATION; |
| |
| typedef [hidden] enum SPSTREAMFORMAT { |
| SPSF_Default = -1, |
| SPSF_NoAssignedFormat = 0, |
| SPSF_Text, |
| SPSF_NonStandardFormat, |
| SPSF_ExtendedAudioFormat, |
| SPSF_8kHz8BitMono, |
| SPSF_8kHz8BitStereo, |
| SPSF_8kHz16BitMono, |
| SPSF_8kHz16BitStereo, |
| SPSF_11kHz8BitMono, |
| SPSF_11kHz8BitStereo, |
| SPSF_11kHz16BitMono, |
| SPSF_11kHz16BitStereo, |
| SPSF_12kHz8BitMono, |
| SPSF_12kHz8BitStereo, |
| SPSF_12kHz16BitMono, |
| SPSF_12kHz16BitStereo, |
| SPSF_16kHz8BitMono, |
| SPSF_16kHz8BitStereo, |
| SPSF_16kHz16BitMono, |
| SPSF_16kHz16BitStereo, |
| SPSF_22kHz8BitMono, |
| SPSF_22kHz8BitStereo, |
| SPSF_22kHz16BitMono, |
| SPSF_22kHz16BitStereo, |
| SPSF_24kHz8BitMono, |
| SPSF_24kHz8BitStereo, |
| SPSF_24kHz16BitMono, |
| SPSF_24kHz16BitStereo, |
| SPSF_32kHz8BitMono, |
| SPSF_32kHz8BitStereo, |
| SPSF_32kHz16BitMono, |
| SPSF_32kHz16BitStereo, |
| SPSF_44kHz8BitMono, |
| SPSF_44kHz8BitStereo, |
| SPSF_44kHz16BitMono, |
| SPSF_44kHz16BitStereo, |
| SPSF_48kHz8BitMono, |
| SPSF_48kHz8BitStereo, |
| SPSF_48kHz16BitMono, |
| SPSF_48kHz16BitStereo, |
| SPSF_TrueSpeech_8kHz1BitMono, |
| SPSF_CCITT_ALaw_8kHzMono, |
| SPSF_CCITT_ALaw_8kHzStereo, |
| SPSF_CCITT_ALaw_11kHzMono, |
| SPSF_CCITT_ALaw_11kHzStereo, |
| SPSF_CCITT_ALaw_22kHzMono, |
| SPSF_CCITT_ALaw_22kHzStereo, |
| SPSF_CCITT_ALaw_44kHzMono, |
| SPSF_CCITT_ALaw_44kHzStereo, |
| SPSF_CCITT_uLaw_8kHzMono, |
| SPSF_CCITT_uLaw_8kHzStereo, |
| SPSF_CCITT_uLaw_11kHzMono, |
| SPSF_CCITT_uLaw_11kHzStereo, |
| SPSF_CCITT_uLaw_22kHzMono, |
| SPSF_CCITT_uLaw_22kHzStereo, |
| SPSF_CCITT_uLaw_44kHzMono, |
| SPSF_CCITT_uLaw_44kHzStereo, |
| SPSF_ADPCM_8kHzMono, |
| SPSF_ADPCM_8kHzStereo, |
| SPSF_ADPCM_11kHzMono, |
| SPSF_ADPCM_11kHzStereo, |
| SPSF_ADPCM_22kHzMono, |
| SPSF_ADPCM_22kHzStereo, |
| SPSF_ADPCM_44kHzMono, |
| SPSF_ADPCM_44kHzStereo, |
| SPSF_GSM610_8kHzMono, |
| SPSF_GSM610_11kHzMono, |
| SPSF_GSM610_22kHzMono, |
| SPSF_GSM610_44kHzMono, |
| SPSF_NUM_FORMATS |
| } SPSTREAMFORMAT; |
| |
| typedef [hidden] enum SPEVENTLPARAMTYPE { |
| SPET_LPARAM_IS_UNDEFINED = 0, |
| SPET_LPARAM_IS_TOKEN, |
| SPET_LPARAM_IS_OBJECT, |
| SPET_LPARAM_IS_POINTER, |
| SPET_LPARAM_IS_STRING |
| } SPEVENTLPARAMTYPE; |
| |
| typedef [hidden] enum SPEVENTENUM { |
| SPEI_UNDEFINED = 0, |
| 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, |
| #if _SAPI_BLD_ >= 0x53 |
| SPEI_SR_RETAINEDAUDIO = 51, |
| #endif |
| SPEI_SR_PRIVATE = 52, |
| #if _SAPI_BLD_ >= 0x53 |
| #if _SAPI_BLD_ >= 0x54 |
| SPEI_ACTIVE_CATEGORY_CHANGED = 53, |
| #else |
| SPEI_RESERVED4 = 53, |
| #endif |
| SPEI_RESERVED5 = 54, |
| SPEI_RESERVED6 = 55, |
| #endif |
| SPEI_MIN_SR = 34, |
| #if _SAPI_BLD_ >= 0x53 |
| SPEI_MAX_SR = 55, |
| #else |
| SPEI_MAX_SR = 52, |
| #endif |
| SPEI_RESERVED1 = 30, |
| SPEI_RESERVED2 = 33, |
| SPEI_RESERVED3 = 63 |
| } SPEVENTENUM; |
| |
| typedef [hidden] 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 |
| } SPINTERFERENCE; |
| |
| typedef [hidden] enum SPENDSRSTREAMFLAGS { |
| SPESF_NONE = 0, |
| SPESF_STREAM_RELEASED = 1 |
| #if _SAPI_BLD_ >= 0x53 |
| , SPESF_EMULATED = 2 |
| #endif |
| } SPENDSRSTREAMFLAGS; |
| |
| typedef [hidden] enum SPVFEATURE { |
| SPVFEATURE_STRESSED = 1, |
| SPVFEATURE_EMPHASIS = 2 |
| } SPVFEATURE; |
| |
| typedef [hidden] 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, |
| } SPVISEMES; |
| |
| typedef [hidden] enum SPFILEMODE { |
| SPFM_OPEN_READONLY, |
| SPFM_OPEN_READWRITE, |
| SPFM_CREATE, |
| SPFM_CREATE_ALWAYS, |
| SPFM_NUM_MODES |
| } SPFILEMODE; |
| |
| typedef [hidden] enum _SPAUDIOSTATE { |
| SPAS_CLOSED, |
| SPAS_STOP, |
| SPAS_PAUSE, |
| SPAS_RUN |
| } SPAUDIOSTATE; |
| |
| typedef [hidden] enum SPDISPLYATTRIBUTES { |
| SPAF_ONE_TRAILING_SPACE = 0x2, |
| SPAF_TWO_TRAILING_SPACES = 0x4, |
| SPAF_CONSUME_LEADING_SPACES = 0x8, |
| #if _SAPI_BLD_ >= 0x53 |
| SPAF_BUFFER_POSITION = 0x10, |
| SPAF_ALL = 0x1f, |
| SPAF_USER_SPECIFIED = 0x80 |
| #else |
| SPAF_ALL = 0x0f |
| #endif |
| } SPDISPLAYATTRIBUTES; |
| |
| typedef [hidden] enum SPPHRASEPROPERTYUNIONTYPE { |
| SPPPUT_UNUSED = 0, |
| SPPPUT_ARRAY_INDEX |
| } SPPHRASEPROPERTYUNIONTYPE; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| typedef enum SPSEMANTICFORMAT { |
| SPSMF_SAPI_PROPERTIES = 0, |
| SPSMF_SRGS_SEMANTICINTERPRETATION_MS = 1, |
| SPSMF_SRGS_SAPIPROPERTIES = 2, |
| SPSMF_UPS = 4, |
| SPSMF_SRGS_SEMANTICINTERPRETATION_W3C = 8 |
| } SPSEMANTICFORMAT; |
| #endif |
| |
| typedef [hidden] enum SPRECOEVENTFLAGS { |
| SPREF_AutoPause = 0x1, |
| SPREF_Emulated = 0x2 |
| #if _SAPI_BLD_ >= 0x53 |
| , SPREF_SMLTimeout = 0x4, |
| SPREF_ExtendableParse = 0x8, |
| SPREF_ReSent = 0x10, |
| SPREF_Hypothesis = 0x20, |
| SPREF_FalseRecognition = 0x40 |
| #endif |
| } SPRECOEVENTFLAGS; |
| |
| typedef [hidden] enum SPPARTOFSPEECH { |
| SPPS_NotOverriden = -1, |
| SPPS_Unknown = 0, |
| SPPS_Noun = 0x1000, |
| SPPS_Verb = 0x2000, |
| SPPS_Modifier = 0x3000, |
| SPPS_Function = 0x4000, |
| SPPS_Interjection = 0x5000 |
| #if _SAPI_BLD_ >= 0x53 |
| , SPPS_Noncontent = 0x6000, |
| SPPS_LMA = 0x7000, |
| SPPS_SuppressWord = 0xf000 |
| #endif |
| } SPPARTOFSPEECH; |
| |
| typedef [hidden] enum SPLEXICONTYPE { |
| eLEXTYPE_USER = 0x1, |
| eLEXTYPE_APP = 0x2, |
| eLEXTYPE_VENDORLEXICON = 0x4, |
| eLEXTYPE_LETTERTOSOUND = 0x8, |
| eLEXTYPE_MORPHOLOGY = 0x10, |
| eLEXTYPE_RESERVED4 = 0x20, |
| eLEXTYPE_USER_SHORTCUT = 0x40, |
| eLEXTYPE_RESERVED6 = 0x80, |
| eLEXTYPE_RESERVED7 = 0x100, |
| eLEXTYPE_RESERVED8 = 0x200, |
| eLEXTYPE_RESERVED9 = 0x400, |
| eLEXTYPE_RESERVED10 = 0x800, |
| eLEXTYPE_PRIVATE1 = 0x1000, |
| eLEXTYPE_PRIVATE2 = 0x2000, |
| eLEXTYPE_PRIVATE3 = 0x4000, |
| eLEXTYPE_PRIVATE4 = 0x8000, |
| eLEXTYPE_PRIVATE5 = 0x10000, |
| eLEXTYPE_PRIVATE6 = 0x20000, |
| eLEXTYPE_PRIVATE7 = 0x40000, |
| eLEXTYPE_PRIVATE8 = 0x80000, |
| eLEXTYPE_PRIVATE9 = 0x100000, |
| eLEXTYPE_PRIVATE10 = 0x200000, |
| eLEXTYPE_PRIVATE11 = 0x400000, |
| eLEXTYPE_PRIVATE12 = 0x800000, |
| eLEXTYPE_PRIVATE13 = 0x1000000, |
| eLEXTYPE_PRIVATE14 = 0x2000000, |
| eLEXTYPE_PRIVATE15 = 0x4000000, |
| eLEXTYPE_PRIVATE16 = 0x8000000, |
| eLEXTYPE_PRIVATE17 = 0x10000000, |
| eLEXTYPE_PRIVATE18 = 0x20000000, |
| eLEXTYPE_PRIVATE19 = 0x40000000, |
| eLEXTYPE_PRIVATE20 = 0x80000000u |
| } SPLEXICONTYPE; |
| |
| typedef [hidden] enum SPWORDTYPE { |
| eWORDTYPE_ADDED = 1, |
| eWORDTYPE_DELETED = 2 |
| } SPWORDTYPE; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| typedef [hidden] enum SPPRONUNCIATIONFLAGS { |
| ePRONFLAG_USED = 1 |
| } SPPRONUNCIATIONFLAGS; |
| |
| typedef [hidden] enum SPSHORTCUTTYPE { |
| SPSHT_NotOverriden = -1, |
| SPSHT_Unknown = 0, |
| SPSHT_EMAIL = 0x1000, |
| SPSHT_OTHER = 0x2000, |
| SPPS_RESERVED1 = 0x3000, |
| SPPS_RESERVED2 = 0x4000, |
| SPPS_RESERVED3 = 0x5000, |
| SPPS_RESERVED4 = 0xf000 |
| } SPSHORTCUTTYPE; |
| #endif |
| |
| typedef [hidden] 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 |
| } SPVALUETYPE; |
| |
| typedef [hidden] enum SPPHRASERNG { |
| SPPR_ALL_ELEMENTS = -1 |
| } SPPHRASERNG; |
| |
| typedef [hidden] enum SPVACTIONS { |
| SPVA_Speak = 0, |
| SPVA_Silence, |
| SPVA_Pronounce, |
| SPVA_Bookmark, |
| SPVA_SpellOut, |
| SPVA_Section, |
| SPVA_ParseUnknownTag |
| } SPVACTIONS; |
| |
| typedef [hidden] enum SPRUNSTATE { |
| SPRS_DONE = 1, |
| SPRS_IS_SPEAKING = 2 |
| } SPRUNSTATE; |
| |
| typedef [hidden] enum SPVLIMITS { |
| SPMIN_VOLUME = 0, |
| SPMAX_VOLUME = 100, |
| SPMIN_RATE = -10, |
| SPMAX_RATE = 10 |
| } SPVLIMITS; |
| |
| typedef [hidden] enum SPVPRIORITY { |
| SPVPRI_NORMAL = 0, |
| SPVPRI_ALERT = 1, |
| SPVPRI_OVER = 2 |
| } SPVPRIORITY; |
| |
| cpp_quote("EXTERN_C const GUID SPDFID_Text;") |
| cpp_quote("EXTERN_C const GUID SPDFID_WaveFormatEx;") |
| |
| cpp_quote("") |
| const signed char SP_LOW_CONFIDENCE = -1; |
| const signed char SP_NORMAL_CONFIDENCE = 0; |
| const signed char SP_HIGH_CONFIDENCE = +1; |
| const float DEFAULT_WEIGHT = 1; |
| const ULONG SP_MAX_WORD_LENGTH = 128; |
| const ULONG SP_MAX_PRON_LENGTH = 384; |
| #if _SAPI_BLD_ >= 0x53 |
| const ULONG SP_EMULATE_RESULT = 0x40000000; |
| #endif |
| |
| cpp_quote("") |
| cpp_quote("#ifdef __cplusplus") |
| cpp_quote("interface ISpNotifyCallback {") |
| cpp_quote(" virtual HRESULT STDMETHODCALLTYPE NotifyCallback(WPARAM wParam, LPARAM lParam) = 0;") |
| cpp_quote("};") |
| cpp_quote("#else") |
| typedef void *ISpNotifyCallback; |
| cpp_quote("#endif") |
| |
| cpp_quote("#if 0") |
| typedef void *SPNOTIFYCALLBACK; |
| cpp_quote("#else") |
| cpp_quote("typedef void __stdcall SPNOTIFYCALLBACK(WPARAM wParam, LPARAM lParam);") |
| cpp_quote("#endif") |
| |
| [object, uuid (5eff4aef-8487-11d2-961c-00c04f8ee628), pointer_default (unique), restricted] |
| interface ISpNotifySource : IUnknown { |
| HRESULT SetNotifySink ([in] ISpNotifySink *pNotifySink); |
| [local] HRESULT SetNotifyWindowMessage ([in] HWND hWnd,[in] UINT Msg,[in] WPARAM wParam,[in] LPARAM lParam); |
| [local] HRESULT SetNotifyCallbackFunction ([in] SPNOTIFYCALLBACK *pfnCallback,[in] WPARAM wParam,[in] LPARAM lParam); |
| [local] HRESULT SetNotifyCallbackInterface ([in] ISpNotifyCallback *pSpCallback,[in] WPARAM wParam,[in] LPARAM lParam); |
| [local] HRESULT SetNotifyWin32Event (void); |
| [local] HRESULT WaitForNotifyEvent ([in] DWORD dwMilliseconds); |
| [local] HANDLE GetNotifyEventHandle (); |
| } |
| |
| [object, uuid (259684dc-37c3-11d2-9603-00c04f8ee628), pointer_default (unique), restricted] |
| interface ISpNotifySink : IUnknown { |
| HRESULT Notify (void); |
| } |
| |
| [object, local, uuid (ACA16614-5d3d-11d2-960e-00c04f8ee628), pointer_default (unique), restricted] |
| interface ISpNotifyTranslator : ISpNotifySink { |
| HRESULT InitWindowMessage ([in] HWND hWnd,[in] UINT Msg,[in] WPARAM wParam,[in] LPARAM lParam); |
| HRESULT InitCallback ([in] SPNOTIFYCALLBACK *pfnCallback,[in] WPARAM wParam,[in] LPARAM lParam); |
| HRESULT InitSpNotifyCallback ([in] ISpNotifyCallback *pSpCallback,[in] WPARAM wParam,[in] LPARAM lParam); |
| HRESULT InitWin32Event ([in] HANDLE hEvent,[in] WINBOOL fCloseHandleOnRelease); |
| HRESULT Wait ([in] DWORD dwMilliseconds); |
| HANDLE GetEventHandle (); |
| } |
| |
| [object, local, uuid (14056581-E16C-11d2-BB90-00c04f8ee6c0), pointer_default (unique), restricted] |
| interface ISpDataKey : IUnknown { |
| HRESULT SetData ([in] LPCWSTR pszValueName,[in] ULONG cbData,[in] const BYTE *pData); |
| HRESULT GetData ([in] LPCWSTR pszValueName,[in] ULONG *pcbData,[out] BYTE *pData); |
| HRESULT SetStringValue ([in] LPCWSTR pszValueName,[in] LPCWSTR pszValue); |
| HRESULT GetStringValue ([in] LPCWSTR pszValueName,[out] LPWSTR *ppszValue); |
| HRESULT SetDWORD ([in] LPCWSTR pszValueName,[in] DWORD dwValue); |
| HRESULT GetDWORD ([in] LPCWSTR pszValueName,[out] DWORD *pdwValue); |
| HRESULT OpenKey ([in] LPCWSTR pszSubKeyName,[out] ISpDataKey **ppSubKey); |
| HRESULT CreateKey ([in] LPCWSTR pszSubKey,[out] ISpDataKey **ppSubKey); |
| HRESULT DeleteKey ([in] LPCWSTR pszSubKey); |
| HRESULT DeleteValue ([in] LPCWSTR pszValueName); |
| HRESULT EnumKeys ([in] ULONG Index,[out] LPWSTR *ppszSubKeyName); |
| HRESULT EnumValues ([in] ULONG Index,[out] LPWSTR *ppszValueName); |
| }; |
| |
| [object, uuid (5b559f40-E952-11d2-BB91-00c04f8ee6c0), pointer_default (unique), restricted] |
| interface ISpObjectWithToken : IUnknown { |
| HRESULT SetObjectToken ([in] ISpObjectToken *pToken); |
| HRESULT GetObjectToken ([out] ISpObjectToken **ppToken); |
| }; |
| |
| [object, local, uuid (06b64f9e-7fda-11d2-B4F2-00c04f797396), pointer_default (unique), restricted] |
| interface IEnumSpObjectTokens : IUnknown { |
| HRESULT Next ([in] ULONG celt,[out, size_is (celt), length_is (*pceltFetched)] ISpObjectToken **pelt,[out] ULONG *pceltFetched); |
| HRESULT Skip ([in] ULONG celt); |
| HRESULT Reset (void); |
| HRESULT Clone ([out] IEnumSpObjectTokens **ppEnum); |
| HRESULT Item ([in] ULONG Index,[out] ISpObjectToken **ppToken); |
| HRESULT GetCount ([out] ULONG *pCount); |
| }; |
| |
| [object, uuid (92a66e2b-C830-4149-83df-6fc2ba1e7a5b), pointer_default (unique), restricted] |
| interface ISpRegDataKey : ISpDataKey { |
| [local] HRESULT SetKey ([in] HKEY hkey,[in] WINBOOL fReadOnly); |
| } |
| |
| [object, local, uuid (2d3d3845-39af-4850-BBF9-40b49780011d), pointer_default (unique), restricted] |
| interface ISpObjectTokenCategory : ISpDataKey { |
| HRESULT SetId ([in] LPCWSTR pszCategoryId,[in] WINBOOL fCreateIfNotExist); |
| HRESULT GetId ([out] LPWSTR *ppszCoMemCategoryId); |
| HRESULT GetDataKey ([in] SPDATAKEYLOCATION spdkl,[out] ISpDataKey **ppDataKey); |
| HRESULT EnumTokens ([in, string] LPCWSTR pzsReqAttribs,[in, string] LPCWSTR pszOptAttribs,[out] IEnumSpObjectTokens **ppEnum); |
| HRESULT SetDefaultTokenId ([in] LPCWSTR pszTokenId); |
| HRESULT GetDefaultTokenId ([out] LPWSTR *ppszCoMemTokenId); |
| }; |
| |
| [object, local, uuid (14056589-E16C-11d2-BB90-00c04f8ee6c0), pointer_default (unique), restricted] |
| interface ISpObjectToken : ISpDataKey { |
| HRESULT SetId (LPCWSTR pszCategoryId,[in] LPCWSTR pszTokenId,[in] WINBOOL fCreateIfNotExist); |
| HRESULT GetId ([out] LPWSTR *ppszCoMemTokenId); |
| HRESULT GetCategory ([out] ISpObjectTokenCategory **ppTokenCategory); |
| HRESULT CreateInstance ([in] IUnknown *pUnkOuter,[in] DWORD dwClsContext,[in] REFIID riid,[out, iid_is (riid)] void **ppvObject); |
| HRESULT GetStorageFileName ([in] REFCLSID clsidCaller,[in] LPCWSTR pszValueName,[in, string] LPCWSTR pszFileNameSpecifier,[in] ULONG nFolder,[out] LPWSTR *ppszFilePath); |
| HRESULT RemoveStorageFileName ([in] REFCLSID clsidCaller,[in] LPCWSTR pszKeyName,[in] WINBOOL fDeleteFile); |
| HRESULT Remove (const CLSID *pclsidCaller); |
| [local] HRESULT IsUISupported ([in] LPCWSTR pszTypeOfUI,[in] void *pvExtraData,[in] ULONG cbExtraData,[in] IUnknown *punkObject,[out] WINBOOL *pfSupported); |
| [local] HRESULT DisplayUI ([in] HWND hwndParent,[in] LPCWSTR pszTitle,[in] LPCWSTR pszTypeOfUI,[in] void *pvExtraData,[in] ULONG cbExtraData,[in] IUnknown *punkObject); |
| HRESULT MatchesAttributes ([in] LPCWSTR pszAttributes,[out] WINBOOL *pfMatches); |
| }; |
| |
| [object, uuid (B8AAB0CF-346f-49d8-9499-C8B03F161D51), pointer_default (unique), restricted] |
| interface ISpObjectTokenInit : ISpObjectToken { |
| HRESULT InitFromDataKey ([in] LPCWSTR pszCategoryId,[in] LPCWSTR pszTokenId,[in] ISpDataKey *pDataKey); |
| }; |
| |
| [object, uuid (93384e18-5014-43d5-ADBB-A78E055926BD), pointer_default (unique), restricted] |
| interface ISpResourceManager : IServiceProvider |
| { |
| HRESULT SetObject ([in] REFGUID guidServiceId,[in] IUnknown *pUnkObject); |
| HRESULT GetObject ([in] REFGUID guidServiceId,[in] REFCLSID ObjectCLSID,[in] REFIID ObjectIID,[in] WINBOOL fReleaseWhenLastExternalRefReleased,[out, iid_is (ObjectIID)] void **ppObject); |
| }; |
| |
| cpp_quote("#if 0") |
| typedef [restricted, hidden] struct SPEVENT { |
| WORD eEventId; |
| WORD elParamType; |
| ULONG ulStreamNum; |
| ULONGLONG ullAudioStreamOffset; |
| WPARAM wParam; |
| LPARAM lParam; |
| } SPEVENT; |
| |
| typedef [restricted, hidden] struct SPSERIALIZEDEVENT { |
| WORD eEventId; |
| WORD elParamType; |
| ULONG ulStreamNum; |
| ULONGLONG ullAudioStreamOffset; |
| ULONG SerializedwParam; |
| LONG SerializedlParam; |
| } SPSERIALIZEDEVENT; |
| |
| typedef [restricted, hidden] struct SPSERIALIZEDEVENT64 { |
| WORD eEventId; |
| WORD elParamType; |
| ULONG ulStreamNum; |
| ULONGLONG ullAudioStreamOffset; |
| ULONGLONG SerializedwParam; |
| LONGLONG SerializedlParam; |
| } SPSERIALIZEDEVENT64; |
| cpp_quote("#else") |
| cpp_quote("typedef struct SPEVENT {") |
| cpp_quote(" SPEVENTENUM eEventId : 16;") |
| cpp_quote(" SPEVENTLPARAMTYPE elParamType : 16;") |
| cpp_quote(" ULONG ulStreamNum;") |
| cpp_quote(" ULONGLONG ullAudioStreamOffset;") |
| cpp_quote(" WPARAM wParam;") |
| cpp_quote(" LPARAM lParam;") |
| cpp_quote("} SPEVENT;") |
| cpp_quote("") |
| cpp_quote("typedef struct SPSERIALIZEDEVENT {") |
| cpp_quote(" SPEVENTENUM eEventId : 16;") |
| cpp_quote(" SPEVENTLPARAMTYPE elParamType : 16;") |
| cpp_quote(" ULONG ulStreamNum;") |
| cpp_quote(" ULONGLONG ullAudioStreamOffset;") |
| cpp_quote(" ULONG SerializedwParam;") |
| cpp_quote(" LONG SerializedlParam;") |
| cpp_quote("} SPSERIALIZEDEVENT;") |
| cpp_quote("") |
| cpp_quote("typedef struct SPSERIALIZEDEVENT64 {") |
| cpp_quote(" SPEVENTENUM eEventId : 16;") |
| cpp_quote(" SPEVENTLPARAMTYPE elParamType : 16;") |
| cpp_quote(" ULONG ulStreamNum;") |
| cpp_quote(" ULONGLONG ullAudioStreamOffset;") |
| cpp_quote(" ULONGLONG SerializedwParam;") |
| cpp_quote(" LONGLONG SerializedlParam;") |
| cpp_quote("} SPSERIALIZEDEVENT64;") |
| cpp_quote("#endif") |
| |
| #if _SAPI_BLD_ >= 0x53 |
| cpp_quote("#if 0") |
| typedef [restricted, hidden] struct SPEVENTEX { |
| WORD eEventId; |
| WORD elParamType; |
| ULONG ulStreamNum; |
| ULONGLONG ullAudioStreamOffset; |
| WPARAM wParam; |
| LPARAM lParam; |
| ULONGLONG ullAudioTimeOffset; |
| } SPEVENTEX; |
| cpp_quote("#else") |
| cpp_quote("typedef struct SPEVENTEX {") |
| cpp_quote(" SPEVENTENUM eEventId : 16;") |
| cpp_quote(" SPEVENTLPARAMTYPE elParamType : 16;") |
| cpp_quote(" ULONG ulStreamNum;") |
| cpp_quote(" ULONGLONG ullAudioStreamOffset;") |
| cpp_quote(" WPARAM wParam;") |
| cpp_quote(" LPARAM lParam;") |
| cpp_quote(" ULONGLONG ullAudioTimeOffset;") |
| cpp_quote("} SPEVENTEX;") |
| cpp_quote("#endif") |
| #endif |
| |
| typedef [restricted, hidden] struct SPEVENTSOURCEINFO { |
| ULONGLONG ullEventInterest; |
| ULONGLONG ullQueuedInterest; |
| ULONG ulCount; |
| } SPEVENTSOURCEINFO; |
| |
| [object, local, uuid (BE7A9CCE-5f9e-11d2-960f-00c04f8ee628), pointer_default (unique), restricted] |
| interface ISpEventSource : ISpNotifySource { |
| HRESULT SetInterest ([in] ULONGLONG ullEventInterest,[in] ULONGLONG ullQueuedInterest); |
| HRESULT GetEvents ([in] ULONG ulCount,[out, size_is (ulCount)] SPEVENT *pEventArray,[out] ULONG *pulFetched); |
| HRESULT GetInfo ([out] SPEVENTSOURCEINFO *pInfo); |
| }; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| [object, local, uuid (2373a435-6a4b-429e-A6AC-D4231A61975B), pointer_default (unique), restricted] |
| interface ISpEventSource2 : ISpEventSource { |
| HRESULT GetEventsEx ([in] ULONG ulCount,[out, size_is (ulCount)] SPEVENTEX *pEventArray,[out] ULONG *pulFetched); |
| }; |
| #endif |
| |
| [object, local, uuid (BE7A9CC9-5f9e-11d2-960f-00c04f8ee628), pointer_default (unique), restricted] |
| interface ISpEventSink : IUnknown { |
| HRESULT AddEvents ([in] const SPEVENT *pEventArray,[in] ULONG ulCount); |
| HRESULT GetEventInterest ([out] ULONGLONG *pullEventInterest); |
| }; |
| |
| [object, uuid (BED530BE-2606-4f4d-A1C0-54c5cda5566f), pointer_default (unique), restricted] |
| interface ISpStreamFormat : IStream { |
| HRESULT GetFormat ([in] GUID *pguidFormatId,[out] WAVEFORMATEX **ppCoMemWaveFormatEx); |
| } |
| |
| [object, local, uuid (12e3cca9-7518-44c5-A5E7-BA5A79CB929E), pointer_default (unique), restricted] |
| interface ISpStream : ISpStreamFormat { |
| HRESULT SetBaseStream ([in] IStream *pStream,[in] REFGUID rguidFormat,[in] const WAVEFORMATEX *pWaveFormatEx); |
| HRESULT GetBaseStream ([out] IStream **ppStream); |
| HRESULT BindToFile ([in] LPCWSTR pszFileName,[in] SPFILEMODE eMode,[in] const GUID *pFormatId, const WAVEFORMATEX *pWaveFormatEx,[in] ULONGLONG ullEventInterest); |
| HRESULT Close (); |
| } |
| |
| [object, uuid (678a932c-EA71-4446-9b41-78fda6280a29), pointer_default (unique), restricted] |
| interface ISpStreamFormatConverter : ISpStreamFormat { |
| HRESULT SetBaseStream ([in] ISpStreamFormat *pStream,[in] WINBOOL fSetFormatToBaseStreamFormat,[in] WINBOOL fWriteToBaseStream); |
| HRESULT GetBaseStream ([out] ISpStreamFormat **ppStream); |
| HRESULT SetFormat ([in] REFGUID rguidFormatIdOfConvertedStream,[in] const WAVEFORMATEX *pWaveFormatExOfConvertedStream); |
| HRESULT ResetSeekPosition (); |
| HRESULT ScaleConvertedToBaseOffset ([in] ULONGLONG ullOffsetConvertedStream,[out] ULONGLONG *pullOffsetBaseStream); |
| HRESULT ScaleBaseToConvertedOffset ([in] ULONGLONG ullOffsetBaseStream,[out] ULONGLONG *pullOffsetConvertedStream); |
| }; |
| |
| typedef [restricted, hidden] struct SPAUDIOSTATUS { |
| long cbFreeBuffSpace; |
| ULONG cbNonBlockingIO; |
| SPAUDIOSTATE State; |
| ULONGLONG CurSeekPos; |
| ULONGLONG CurDevicePos; |
| DWORD dwAudioLevel; |
| DWORD dwReserved2; |
| } SPAUDIOSTATUS; |
| |
| typedef [restricted, hidden] struct SPAUDIOBUFFERINFO { |
| ULONG ulMsMinNotification; |
| ULONG ulMsBufferSize; |
| ULONG ulMsEventBias; |
| } SPAUDIOBUFFERINFO; |
| |
| [object, local, uuid (C05C768F-FAE8-4ec2-8e07-338321c12452), pointer_default (unique), restricted] |
| interface ISpAudio : ISpStreamFormat { |
| HRESULT SetState ([in] SPAUDIOSTATE NewState,[in] ULONGLONG ullReserved); |
| HRESULT SetFormat ([in] REFGUID rguidFmtId,[in] const WAVEFORMATEX *pWaveFormatEx); |
| HRESULT GetStatus ([out] SPAUDIOSTATUS *pStatus); |
| HRESULT SetBufferInfo ([in] const SPAUDIOBUFFERINFO *pBuffInfo); |
| HRESULT GetBufferInfo ([out] SPAUDIOBUFFERINFO *pBuffInfo); |
| HRESULT GetDefaultFormat ([out] GUID *pFormatId,[out] WAVEFORMATEX **ppCoMemWaveFormatEx); |
| HANDLE EventHandle (); |
| HRESULT GetVolumeLevel ([out] ULONG *pLevel); |
| HRESULT SetVolumeLevel ([in] ULONG Level); |
| HRESULT GetBufferNotifySize ([out] ULONG *pcbSize); |
| HRESULT SetBufferNotifySize ([in] ULONG cbSize); |
| }; |
| |
| [object, local, uuid (15806f6e-1d70-4b48-98e6-3b1a007509ab), pointer_default (unique), restricted] |
| interface ISpMMSysAudio : ISpAudio { |
| HRESULT GetDeviceId ([out] UINT *puDeviceId); |
| HRESULT SetDeviceId ([in] UINT uDeviceId); |
| HRESULT GetMMHandle ([out] void **pHandle); |
| HRESULT GetLineId ([out] UINT *puLineId); |
| HRESULT SetLineId ([in] UINT uLineId); |
| }; |
| |
| [object, uuid (10f63bce-201a-11d3-AC70-00c04f8ee6c0), pointer_default (unique), restricted] |
| interface ISpTranscript : IUnknown { |
| HRESULT GetTranscript ([out, string] LPWSTR *ppszTranscript); |
| HRESULT AppendTranscript ([in, string] LPCWSTR pszTranscript); |
| }; |
| |
| typedef WCHAR SPPHONEID; |
| typedef LPWSTR PSPPHONEID; |
| typedef LPCWSTR PCSPPHONEID; |
| |
| typedef [restricted, hidden] struct SPPHRASEELEMENT { |
| ULONG ulAudioTimeOffset; |
| ULONG ulAudioSizeTime; |
| ULONG ulAudioStreamOffset; |
| ULONG ulAudioSizeBytes; |
| ULONG ulRetainedStreamOffset; |
| ULONG ulRetainedSizeBytes; |
| LPCWSTR pszDisplayText; |
| LPCWSTR pszLexicalForm; |
| const SPPHONEID *pszPronunciation; |
| BYTE bDisplayAttributes; |
| signed char RequiredConfidence; |
| signed char ActualConfidence; |
| BYTE Reserved; |
| float SREngineConfidence; |
| } SPPHRASEELEMENT; |
| |
| typedef [restricted, hidden] struct SPPHRASERULE SPPHRASERULE; |
| typedef [restricted, hidden] struct SPPHRASEPROPERTY SPPHRASEPROPERTY; |
| |
| struct SPPHRASERULE { |
| LPCWSTR pszName; |
| ULONG ulId; |
| ULONG ulFirstElement; |
| ULONG ulCountOfElements; |
| const SPPHRASERULE *pNextSibling; |
| const SPPHRASERULE *pFirstChild; |
| float SREngineConfidence; |
| signed char Confidence; |
| }; |
| |
| struct SPPHRASEPROPERTY { |
| LPCWSTR pszName; |
| union { |
| ULONG ulId; |
| struct { |
| byte bType; |
| byte bReserved; |
| unsigned short usArrayIndex; |
| }; |
| }; |
| LPCWSTR pszValue; |
| VARIANT vValue; |
| ULONG ulFirstElement; |
| ULONG ulCountOfElements; |
| const SPPHRASEPROPERTY *pNextSibling; |
| const SPPHRASEPROPERTY *pFirstChild; |
| float SREngineConfidence; |
| signed char Confidence; |
| }; |
| |
| typedef [restricted, hidden] struct SPPHRASEREPLACEMENT { |
| BYTE bDisplayAttributes; |
| LPCWSTR pszReplacementText; |
| ULONG ulFirstElement; |
| ULONG ulCountOfElements; |
| } SPPHRASEREPLACEMENT; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| typedef [restricted, hidden] struct SPSEMANTICERRORINFO { |
| ULONG ulLineNumber; |
| LPWSTR pszScriptLine; |
| LPWSTR pszSource; |
| LPWSTR pszDescription; |
| HRESULT hrResultCode; |
| } SPSEMANTICERRORINFO; |
| #endif |
| |
| #if _SAPI_BLD_ >= 0x53 |
| typedef [restricted, hidden] struct SPPHRASE_50 |
| #else |
| typedef [restricted, hidden] struct SPPHRASE |
| #endif |
| { |
| ULONG cbSize; |
| LANGID LangID; |
| WORD wHomophoneGroupId; |
| ULONGLONG ullGrammarID; |
| ULONGLONG ftStartTime; |
| ULONGLONG ullAudioStreamPosition; |
| ULONG ulAudioSizeBytes; |
| ULONG ulRetainedSizeBytes; |
| ULONG ulAudioSizeTime; |
| SPPHRASERULE Rule; |
| const SPPHRASEPROPERTY *pProperties; |
| const SPPHRASEELEMENT *pElements; |
| ULONG cReplacements; |
| const SPPHRASEREPLACEMENT *pReplacements; |
| GUID SREngineID; |
| ULONG ulSREnginePrivateDataSize; |
| const BYTE *pSREnginePrivateData; |
| } |
| #if _SAPI_BLD_ >= 0x53 |
| SPPHRASE_50; |
| #else |
| SPPHRASE; |
| #endif |
| |
| #if _SAPI_BLD_ >= 0x53 |
| cpp_quote("#define SP_SPPHRASESIZE_500 sizeof (SPPHRASE_50)") |
| |
| cpp_quote("#ifdef __cplusplus") |
| #if _SAPI_BLD_ > 0x53 |
| cpp_quote("typedef struct SPPHRASE_53 : public SPPHRASE_50 {") |
| #else |
| cpp_quote("typedef struct SPPHRASE : public SPPHRASE_50 {") |
| #endif |
| cpp_quote(" LPWSTR pSML;") |
| cpp_quote(" SPSEMANTICERRORINFO* pSemanticErrorInfo;") |
| #if _SAPI_BLD_ > 0x53 |
| cpp_quote("} SPPHRASE_53;") |
| #else |
| cpp_quote("} SPPHRASE;") |
| #endif |
| cpp_quote("#else") |
| #if _SAPI_BLD_ > 0x53 |
| typedef [restricted, hidden] struct SPPHRASE_53 |
| #else |
| typedef [restricted, hidden] struct SPPHRASE |
| #endif |
| { |
| ULONG cbSize; |
| LANGID LangID; |
| WORD wHomophoneGroupId; |
| ULONGLONG ullGrammarID; |
| ULONGLONG ftStartTime; |
| ULONGLONG ullAudioStreamPosition; |
| ULONG ulAudioSizeBytes; |
| ULONG ulRetainedSizeBytes; |
| ULONG ulAudioSizeTime; |
| SPPHRASERULE Rule; |
| const SPPHRASEPROPERTY *pProperties; |
| const SPPHRASEELEMENT *pElements; |
| ULONG cReplacements; |
| const SPPHRASEREPLACEMENT *pReplacements; |
| GUID SREngineID; |
| ULONG ulSREnginePrivateDataSize; |
| const BYTE *pSREnginePrivateData; |
| LPWSTR pSML; |
| SPSEMANTICERRORINFO *pSemanticErrorInfo; |
| } |
| #if _SAPI_BLD_ > 0x53 |
| SPPHRASE_53; |
| #else |
| SPPHRASE; |
| #endif |
| cpp_quote("#endif") |
| #endif |
| |
| #if _SAPI_BLD_ >= 0x54 |
| cpp_quote("#define SP_SPPHRASESIZE_530 sizeof (SPPHRASE_53)") |
| |
| cpp_quote("#ifdef __cplusplus") |
| cpp_quote("typedef struct SPPHRASE : public SPPHRASE_53 {") |
| cpp_quote(" SPSEMANTICFORMAT SemanticTagFormat;") |
| cpp_quote("} SPPHRASE;") |
| cpp_quote("#else") |
| typedef [restricted, hidden] struct SPPHRASE { |
| ULONG cbSize; |
| LANGID LangID; |
| WORD wHomophoneGroupId; |
| ULONGLONG ullGrammarID; |
| ULONGLONG ftStartTime; |
| ULONGLONG ullAudioStreamPosition; |
| ULONG ulAudioSizeBytes; |
| ULONG ulRetainedSizeBytes; |
| ULONG ulAudioSizeTime; |
| SPPHRASERULE Rule; |
| const SPPHRASEPROPERTY *pProperties; |
| const SPPHRASEELEMENT *pElements; |
| ULONG cReplacements; |
| const SPPHRASEREPLACEMENT *pReplacements; |
| GUID SREngineID; |
| ULONG ulSREnginePrivateDataSize; |
| const BYTE *pSREnginePrivateData; |
| LPWSTR pSML; |
| SPSEMANTICERRORINFO *pSemanticErrorInfo; |
| SPSEMANTICFORMAT SemanticTagFormat; |
| } SPPHRASE; |
| cpp_quote("#endif") |
| #endif |
| |
| typedef [restricted, hidden] struct SPSERIALIZEDPHRASE { |
| ULONG ulSerializedSize; |
| } SPSERIALIZEDPHRASE; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| typedef [restricted, hidden] struct SPRULE { |
| LPCWSTR pszRuleName; |
| ULONG ulRuleId; |
| DWORD dwAttributes; |
| } SPRULE; |
| #endif |
| |
| typedef [hidden] struct SPBINARYGRAMMAR { |
| ULONG ulTotalSerializedSize; |
| } SPBINARYGRAMMAR; |
| |
| cpp_quote("#if 0") |
| typedef void *SPSTATEHANDLE; |
| cpp_quote("#else") |
| cpp_quote("DECLARE_HANDLE(SPSTATEHANDLE);") |
| cpp_quote("#endif") |
| |
| typedef [restricted, hidden] struct SPWORDPRONUNCIATION { |
| struct SPWORDPRONUNCIATION *pNextWordPronunciation; |
| SPLEXICONTYPE eLexiconType; |
| LANGID LangID; |
| WORD wPronunciationFlags; |
| SPPARTOFSPEECH ePartOfSpeech; |
| SPPHONEID szPronunciation[1]; |
| } SPWORDPRONUNCIATION; |
| |
| typedef [restricted, hidden] struct SPWORDPRONUNCIATIONLIST { |
| ULONG ulSize; |
| BYTE *pvBuffer; |
| SPWORDPRONUNCIATION *pFirstWordPronunciation; |
| } SPWORDPRONUNCIATIONLIST; |
| |
| typedef [restricted, hidden] struct SPWORD { |
| struct SPWORD *pNextWord; |
| LANGID LangID; |
| WORD wReserved; |
| SPWORDTYPE eWordType; |
| LPWSTR pszWord; |
| SPWORDPRONUNCIATION *pFirstWordPronunciation; |
| } SPWORD; |
| |
| typedef [restricted, hidden] struct SPWORDLIST { |
| ULONG ulSize; |
| BYTE *pvBuffer; |
| SPWORD *pFirstWord; |
| } SPWORDLIST; |
| |
| [object, local, uuid (DA41A7C2-5383-4db2-916b-6c1719e3db58), pointer_default (unique), restricted] |
| interface ISpLexicon : IUnknown { |
| HRESULT GetPronunciations ([in] LPCWSTR pszWord,[in] LANGID LangID,[in] DWORD dwFlags,[in, out] SPWORDPRONUNCIATIONLIST *pWordPronunciationList); |
| HRESULT AddPronunciation ([in] LPCWSTR pszWord,[in] LANGID LangID,[in] SPPARTOFSPEECH ePartOfSpeech,[in] PCSPPHONEID pszPronunciation); |
| HRESULT RemovePronunciation ([in] LPCWSTR pszWord,[in] LANGID LangID,[in] SPPARTOFSPEECH ePartOfSpeech,[in] PCSPPHONEID pszPronunciation); |
| HRESULT GetGeneration ([out] DWORD *pdwGeneration); |
| HRESULT GetGenerationChange ([in] DWORD dwFlags,[in, out] DWORD *pdwGeneration,[in, out] SPWORDLIST *pWordList); |
| HRESULT GetWords ([in] DWORD dwFlags,[in, out] DWORD *pdwGeneration,[in, out] DWORD *pdwCookie,[in, out] SPWORDLIST *pWordList); |
| }; |
| |
| [object, uuid (8565572f-C094-41cc-B56E-10bd9c3ff044), pointer_default (unique), restricted] |
| interface ISpContainerLexicon : ISpLexicon { |
| HRESULT AddLexicon ([in] ISpLexicon *pAddLexicon,[in] DWORD dwFlags); |
| }; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| typedef [restricted, hidden] struct SPSHORTCUTPAIR { |
| struct SPSHORTCUTPAIR *pNextSHORTCUTPAIR; |
| LANGID LangID; |
| SPSHORTCUTTYPE shType; |
| LPWSTR pszDisplay; |
| LPWSTR pszSpoken; |
| } SPSHORTCUTPAIR; |
| |
| typedef [restricted, hidden] struct SPSHORTCUTPAIRLIST { |
| ULONG ulSize; |
| BYTE *pvBuffer; |
| SPSHORTCUTPAIR *pFirstShortcutPair; |
| } SPSHORTCUTPAIRLIST; |
| #endif |
| |
| #if _SAPI_BLD_ >= 0x53 |
| [object, uuid (3df681e2-EA56-11d9-8bde-F66BAD1E3F3A), pointer_default (unique), restricted] |
| interface ISpShortcut : IUnknown { |
| HRESULT AddShortcut ([in] LPCWSTR pszDisplay,[in] LANGID LangID,[in] LPCWSTR pszSpoken,[in] SPSHORTCUTTYPE shType); |
| HRESULT RemoveShortcut ([in] LPCWSTR pszDisplay,[in] LANGID LangID,[in] LPCWSTR pszSpoken,[in] SPSHORTCUTTYPE shType); |
| HRESULT GetShortcuts ([in] LANGID LangID,[in, out] SPSHORTCUTPAIRLIST *pShortcutpairList); |
| HRESULT GetGeneration ([out] DWORD *pdwGeneration); |
| HRESULT GetWordsFromGenerationChange ([in, out] DWORD *pdwGeneration,[in, out] SPWORDLIST *pWordList); |
| HRESULT GetWords ([in, out] DWORD *pdwGeneration,[in, out] DWORD *pdwCookie,[in, out] SPWORDLIST *pWordList); |
| HRESULT GetShortcutsForGeneration ([in, out] DWORD *pdwGeneration,[in, out] DWORD *pdwCookie,[in, out] SPSHORTCUTPAIRLIST *pShortcutpairList); |
| HRESULT GetGenerationChange ([in, out] DWORD *pdwGeneration,[in, out] SPSHORTCUTPAIRLIST *pShortcutpairList); |
| }; |
| #endif |
| |
| [object, uuid (8445c581-0cac-4a38-ABFE-9b2ce2826455), pointer_default (unique), restricted] |
| interface ISpPhoneConverter : ISpObjectWithToken { |
| HRESULT PhoneToId ([in] LPCWSTR pszPhone,[out] SPPHONEID *pId); |
| HRESULT IdToPhone ([in] PCSPPHONEID pId,[out] WCHAR *pszPhone); |
| }; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| [object, local, uuid (133adcd4-19b4-4020-9fdc-842e78253b17), pointer_default (unique), restricted] |
| interface ISpPhoneticAlphabetConverter : IUnknown { |
| HRESULT GetLangId ([out] LANGID *pLangID); |
| HRESULT SetLangId ([in] LANGID LangID); |
| HRESULT SAPI2UPS ([in] const SPPHONEID *pszSAPIId,[out] SPPHONEID *pszUPSId,[in] DWORD cMaxLength); |
| HRESULT UPS2SAPI ([in] const SPPHONEID *pszUPSId,[out] SPPHONEID *pszSAPIId,[in] DWORD cMaxLength); |
| HRESULT GetMaxConvertLength ([in] DWORD cSrcLength,[in] WINBOOL bSAPI2UPS,[out] DWORD *pcMaxDestLength); |
| }; |
| |
| [object, uuid (B2745EFD-42ce-48ca-81f1-A96E02538A90), pointer_default (unique), restricted] |
| interface ISpPhoneticAlphabetSelection : IUnknown { |
| HRESULT IsAlphabetUPS ([out] WINBOOL *pfIsUPS); |
| HRESULT SetAlphabetToUPS ([in] WINBOOL fForceUPS); |
| }; |
| #endif |
| |
| typedef [restricted, hidden] struct SPVPITCH { |
| long MiddleAdj; |
| long RangeAdj; |
| } SPVPITCH; |
| |
| typedef [restricted, hidden] struct SPVCONTEXT { |
| LPCWSTR pCategory; |
| LPCWSTR pBefore; |
| LPCWSTR pAfter; |
| } SPVCONTEXT; |
| |
| typedef [restricted, hidden] struct SPVSTATE { |
| SPVACTIONS eAction; |
| LANGID LangID; |
| WORD wReserved; |
| long EmphAdj; |
| long RateAdj; |
| ULONG Volume; |
| SPVPITCH PitchAdj; |
| ULONG SilenceMSecs; |
| SPPHONEID *pPhoneIds; |
| SPPARTOFSPEECH ePartOfSpeech; |
| SPVCONTEXT Context; |
| } SPVSTATE; |
| |
| typedef [restricted, hidden] struct SPVOICESTATUS { |
| ULONG ulCurrentStream; |
| ULONG ulLastStreamQueued; |
| HRESULT hrLastResult; |
| DWORD dwRunningState; |
| ULONG ulInputWordPos; |
| ULONG ulInputWordLen; |
| ULONG ulInputSentPos; |
| ULONG ulInputSentLen; |
| LONG lBookmarkId; |
| SPPHONEID PhonemeId; |
| SPVISEMES VisemeId; |
| DWORD dwReserved1; |
| DWORD dwReserved2; |
| } SPVOICESTATUS; |
| |
| typedef [hidden] enum SPEAKFLAGS { |
| SPF_DEFAULT = 0, |
| SPF_ASYNC = 1, |
| SPF_PURGEBEFORESPEAK = 2, |
| SPF_IS_FILENAME = 4, |
| SPF_IS_XML = 8, |
| SPF_IS_NOT_XML = 0x10, |
| SPF_PERSIST_XML = 0x20, |
| SPF_NLP_SPEAK_PUNC = 0x40, |
| #if _SAPI_BLD_ >= 0x53 |
| SPF_PARSE_SAPI = 0x80, |
| SPF_PARSE_SSML = 0x100, |
| SPF_PARSE_AUTODETECT = 0, |
| #endif |
| SPF_NLP_MASK = (SPF_NLP_SPEAK_PUNC), |
| #if _SAPI_BLD_ >= 0x53 |
| SPF_PARSE_MASK = (SPF_PARSE_SAPI | SPF_PARSE_SSML), |
| SPF_VOICE_MASK = (SPF_ASYNC | SPF_PURGEBEFORESPEAK | SPF_IS_FILENAME | SPF_IS_XML | SPF_IS_NOT_XML | SPF_NLP_MASK | SPF_PERSIST_XML | SPF_PARSE_MASK), |
| #else |
| SPF_VOICE_MASK = (SPF_ASYNC | SPF_PURGEBEFORESPEAK | SPF_IS_FILENAME | SPF_IS_XML | SPF_IS_NOT_XML | SPF_NLP_MASK | SPF_PERSIST_XML), |
| #endif |
| SPF_UNUSED_FLAGS = ~ (SPF_VOICE_MASK) |
| } SPEAKFLAGS; |
| |
| [object, local, uuid (6c44df74-72b9-4992-A1EC-EF996E0422D4), pointer_default (unique), restricted] |
| interface ISpVoice : ISpEventSource { |
| HRESULT SetOutput ([in] IUnknown *pUnkOutput,[in] WINBOOL fAllowFormatChanges); |
| HRESULT GetOutputObjectToken ([out] ISpObjectToken **ppObjectToken); |
| HRESULT GetOutputStream ([out] ISpStreamFormat **ppStream); |
| HRESULT Pause (void); |
| HRESULT Resume (void); |
| HRESULT SetVoice ([in] ISpObjectToken *pToken); |
| HRESULT GetVoice ([out] ISpObjectToken **ppToken); |
| HRESULT Speak ([in, string] LPCWSTR pwcs,[in] DWORD dwFlags,[out] ULONG *pulStreamNumber); |
| HRESULT SpeakStream ([in] IStream *pStream,[in] DWORD dwFlags,[out] ULONG *pulStreamNumber); |
| HRESULT GetStatus ([out] SPVOICESTATUS *pStatus,[out] LPWSTR *ppszLastBookmark); |
| HRESULT Skip ([in, string] LPCWSTR pItemType,[in] long lNumItems,[out] ULONG *pulNumSkipped); |
| HRESULT SetPriority ([in] SPVPRIORITY ePriority); |
| HRESULT GetPriority ([out] SPVPRIORITY *pePriority); |
| HRESULT SetAlertBoundary ([in] SPEVENTENUM eBoundary); |
| HRESULT GetAlertBoundary ([out] SPEVENTENUM *peBoundary); |
| HRESULT SetRate ([in] long RateAdjust); |
| HRESULT GetRate ([out] long *pRateAdjust); |
| HRESULT SetVolume ([in] USHORT usVolume); |
| HRESULT GetVolume ([out] USHORT *pusVolume); |
| HRESULT WaitUntilDone ([in] ULONG msTimeout); |
| HRESULT SetSyncSpeakTimeout ([in] ULONG msTimeout); |
| HRESULT GetSyncSpeakTimeout ([out] ULONG *pmsTimeout); |
| [local] HANDLE SpeakCompleteEvent (); |
| [local] HRESULT IsUISupported ([in] LPCWSTR pszTypeOfUI,[in] void *pvExtraData,[in] ULONG cbExtraData,[out] WINBOOL *pfSupported); |
| [local] HRESULT DisplayUI ([in] HWND hwndParent,[in] LPCWSTR pszTitle,[in] LPCWSTR pszTypeOfUI,[in] void *pvExtraData,[in] ULONG cbExtraData); |
| }; |
| |
| [object, local, uuid (1a5c0354-B621-4b5a-8791-D306ED379E53), pointer_default (unique), restricted] |
| interface ISpPhrase : IUnknown { |
| HRESULT GetPhrase ([out] SPPHRASE **ppCoMemPhrase); |
| HRESULT GetSerializedPhrase ([out] SPSERIALIZEDPHRASE **ppCoMemPhrase); |
| HRESULT GetText ([in] ULONG ulStart,[in] ULONG ulCount,[in] WINBOOL fUseTextReplacements,[out] LPWSTR *ppszCoMemText,[out, optional] BYTE *pbDisplayAttributes); |
| HRESULT Discard ([in] DWORD dwValueTypes); |
| }; |
| |
| [object, local, uuid (8fcebc98-4e49-4067-9c6c-D86A0E092E3D), pointer_default (unique), restricted] |
| interface ISpPhraseAlt : ISpPhrase { |
| HRESULT GetAltInfo ([out] ISpPhrase **ppParent,[out] ULONG *pulStartElementInParent,[out] ULONG *pcElementsInParent,[out] ULONG *pcElementsInAlt); |
| HRESULT Commit (); |
| }; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| typedef enum SPXMLRESULTOPTIONS { |
| SPXRO_SML = 0, |
| SPXRO_Alternates_SML = 1 |
| } SPXMLRESULTOPTIONS; |
| #endif |
| |
| #if _SAPI_BLD_ >= 0x53 |
| [object, local, uuid (F264DA52-E457-4696-B856-A737B717AF79), pointer_default (unique), restricted] |
| interface ISpPhrase2 : ISpPhrase { |
| HRESULT GetXMLResult ([out] LPWSTR *ppszCoMemXMLResult,[in] SPXMLRESULTOPTIONS Options); |
| HRESULT GetXMLErrorInfo ([out] SPSEMANTICERRORINFO *pSemanticErrorInfo); |
| HRESULT GetAudio ([in] ULONG ulStartElement,[in] ULONG cElements,[out] ISpStreamFormat **ppStream); |
| }; |
| #endif |
| |
| typedef [restricted, hidden] struct SPRECORESULTTIMES { |
| FILETIME ftStreamTime; |
| ULONGLONG ullLength; |
| DWORD dwTickCount; |
| ULONGLONG ullStart; |
| } SPRECORESULTTIMES; |
| |
| typedef [hidden] struct SPSERIALIZEDRESULT { |
| ULONG ulSerializedSize; |
| } SPSERIALIZEDRESULT; |
| |
| [object, local, uuid (20b053be-E235-43cd-9a2a-8d17a48b7842), pointer_default (unique), restricted] |
| interface ISpRecoResult : ISpPhrase { |
| HRESULT GetResultTimes ([out] SPRECORESULTTIMES *pTimes); |
| HRESULT GetAlternates ([in] ULONG ulStartElement,[in] ULONG cElements,[in] ULONG ulRequestCount,[out] ISpPhraseAlt **ppPhrases,[out] ULONG *pcPhrasesReturned); |
| HRESULT GetAudio ([in] ULONG ulStartElement,[in] ULONG cElements,[out] ISpStreamFormat **ppStream); |
| HRESULT SpeakAudio ([in] ULONG ulStartElement,[in] ULONG cElements,[in] DWORD dwFlags,[out] ULONG *pulStreamNumber); |
| HRESULT Serialize ([out] SPSERIALIZEDRESULT **ppCoMemSerializedResult); |
| HRESULT ScaleAudio ([in] const GUID *pAudioFormatId,[in] const WAVEFORMATEX *pWaveFormatEx); |
| HRESULT GetRecoContext ([out] ISpRecoContext **ppRecoContext); |
| }; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| typedef [hidden] enum SPCOMMITFLAGS { |
| SPCF_NONE = 0, |
| SPCF_ADD_TO_USER_LEXICON = (1 << 0), |
| SPCF_DEFINITE_CORRECTION = (1 << 1) |
| } SPCOMMITFLAGS; |
| #endif |
| |
| #if _SAPI_BLD_ >= 0x53 |
| [object, local, uuid (27cac6c4-88f2-41f2-8817-0c95e59f1e6e), pointer_default (unique), restricted] |
| interface ISpRecoResult2 : ISpRecoResult { |
| HRESULT CommitAlternate ([in] ISpPhraseAlt *pPhraseAlt,[out] ISpRecoResult **ppNewResult); |
| HRESULT CommitText ([in] ULONG ulStartElement,[in] ULONG cElements,[in] LPCWSTR pszCorrectedData,[in] DWORD eCommitFlags); |
| HRESULT SetTextFeedback ([in, string] LPCWSTR pszFeedback,[in] WINBOOL fSuccessful); |
| } |
| |
| [object, local, uuid (AE39362B-45a8-4074-9b9e-CCF49AA2D0B6), pointer_default (unique), restricted] |
| interface ISpXMLRecoResult : ISpRecoResult { |
| HRESULT GetXMLResult ([out] LPWSTR *ppszCoMemXMLResult,[in] SPXMLRESULTOPTIONS Options); |
| HRESULT GetXMLErrorInfo ([out] SPSEMANTICERRORINFO *pSemanticErrorInfo); |
| }; |
| #endif |
| |
| typedef [hidden] struct tagSPTEXTSELECTIONINFO { |
| ULONG ulStartActiveOffset; |
| ULONG cchActiveChars; |
| ULONG ulStartSelection; |
| ULONG cchSelection; |
| } SPTEXTSELECTIONINFO; |
| |
| typedef [hidden] enum SPWORDPRONOUNCEABLE { |
| SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE = 0, |
| SPWP_UNKNOWN_WORD_PRONOUNCEABLE = 1, |
| SPWP_KNOWN_WORD_PRONOUNCEABLE = 2 |
| } SPWORDPRONOUNCEABLE; |
| |
| typedef [hidden] enum SPGRAMMARSTATE { |
| SPGS_DISABLED = 0, |
| SPGS_ENABLED = 1, |
| SPGS_EXCLUSIVE = 3 |
| } SPGRAMMARSTATE; |
| |
| typedef [hidden] enum SPCONTEXTSTATE { |
| SPCS_DISABLED = 0, |
| SPCS_ENABLED = 1, |
| } SPCONTEXTSTATE; |
| |
| typedef [hidden] enum SPRULESTATE { |
| SPRS_INACTIVE = 0, |
| SPRS_ACTIVE = 1, |
| SPRS_ACTIVE_WITH_AUTO_PAUSE = 3 |
| #if _SAPI_BLD_ >= 0x53 |
| , SPRS_ACTIVE_USER_DELIMITED = 4 |
| #endif |
| } SPRULESTATE; |
| |
| const ULONGLONG SP_STREAMPOS_ASAP = 0; |
| const ULONGLONG SP_STREAMPOS_REALTIME = -1; |
| |
| cpp_quote("#define SPRULETRANS_TEXTBUFFER (SPSTATEHANDLE) (-1)") |
| cpp_quote("#define SPRULETRANS_WILDCARD (SPSTATEHANDLE) (-2)") |
| cpp_quote("#define SPRULETRANS_DICTATION (SPSTATEHANDLE) (-3)") |
| |
| typedef [hidden] enum SPGRAMMARWORDTYPE { |
| SPWT_DISPLAY, |
| SPWT_LEXICAL, |
| SPWT_PRONUNCIATION |
| #if _SAPI_BLD_ >= 0x53 |
| , SPWT_LEXICAL_NO_SPECIAL_CHARS |
| #endif |
| } SPGRAMMARWORDTYPE; |
| |
| typedef [hidden] struct tagSPPROPERTYINFO { |
| LPCWSTR pszName; |
| ULONG ulId; |
| LPCWSTR pszValue; |
| VARIANT vValue; |
| } SPPROPERTYINFO; |
| |
| typedef [hidden] enum SPCFGRULEATTRIBUTES { |
| SPRAF_TopLevel = 0x1, |
| SPRAF_Active = 0x2, |
| SPRAF_Export = 0x4, |
| SPRAF_Import = 0x8, |
| SPRAF_Interpreter = 0x10, |
| SPRAF_Dynamic = 0x20, |
| #if _SAPI_BLD_ >= 0x53 |
| SPRAF_Root = 0x40, |
| #endif |
| SPRAF_AutoPause = 0x10000 |
| #if _SAPI_BLD_ >= 0x53 |
| , SPRAF_UserDelimited = 0x20000 |
| #endif |
| } SPCFGRULEATTRIBUTES; |
| |
| [object, local, uuid (8137828f-591a-4a42-BE58-49ea7ebaac68), pointer_default (unique), restricted] |
| interface ISpGrammarBuilder : IUnknown { |
| HRESULT ResetGrammar ([in] LANGID NewLanguage); |
| HRESULT GetRule ([in] LPCWSTR pszRuleName,[in] DWORD dwRuleId,[in] DWORD dwAttributes,[in] WINBOOL fCreateIfNotExist,[out] SPSTATEHANDLE *phInitialState); |
| HRESULT ClearRule ([in] SPSTATEHANDLE hState); |
| HRESULT CreateNewState ([in] SPSTATEHANDLE hState,[out] SPSTATEHANDLE *phState); |
| HRESULT AddWordTransition ([in] SPSTATEHANDLE hFromState,[in] SPSTATEHANDLE hToState,[in] LPCWSTR psz,[in] LPCWSTR pszSeparators,[in] SPGRAMMARWORDTYPE eWordType,[in] float Weight,[in] const SPPROPERTYINFO *pPropInfo); |
| HRESULT AddRuleTransition ([in] SPSTATEHANDLE hFromState,[in] SPSTATEHANDLE hToState,[in] SPSTATEHANDLE hRule,[in] float Weight,[in] const SPPROPERTYINFO *pPropInfo); |
| HRESULT AddResource ([in] SPSTATEHANDLE hRuleState,[in] LPCWSTR pszResourceName,[in] LPCWSTR pszResourceValue); |
| HRESULT Commit ([in] DWORD dwReserved); |
| }; |
| |
| typedef [hidden] enum SPLOADOPTIONS { |
| SPLO_STATIC = 0, |
| SPLO_DYNAMIC = 1 |
| } SPLOADOPTIONS; |
| |
| [object, local, uuid (2177db29-7f45-47d0-8554-067e91c80502), pointer_default (unique), restricted] |
| interface ISpRecoGrammar : ISpGrammarBuilder { |
| HRESULT GetGrammarId ([out] ULONGLONG *pullGrammarId); |
| HRESULT GetRecoContext ([out] ISpRecoContext **ppRecoCtxt); |
| HRESULT LoadCmdFromFile ([in, string] LPCWSTR pszFileName,[in] SPLOADOPTIONS Options); |
| HRESULT LoadCmdFromObject ([in] REFCLSID rcid,[in, string] LPCWSTR pszGrammarName,[in] SPLOADOPTIONS Options); |
| HRESULT LoadCmdFromResource ([in] HMODULE hModule,[in, string] LPCWSTR pszResourceName,[in, string] LPCWSTR pszResourceType,[in] WORD wLanguage,[in] SPLOADOPTIONS Options); |
| HRESULT LoadCmdFromMemory ([in] const SPBINARYGRAMMAR *pGrammar,[in] SPLOADOPTIONS Options); |
| HRESULT LoadCmdFromProprietaryGrammar ([in] REFGUID rguidParam,[in, string] LPCWSTR pszStringParam,[in] const void *pvDataPrarm,[in] ULONG cbDataSize,[in] SPLOADOPTIONS Options); |
| HRESULT SetRuleState ([in, string] LPCWSTR pszName,[in] void *pReserved,[in] SPRULESTATE NewState); |
| HRESULT SetRuleIdState ([in] ULONG ulRuleId,[in] SPRULESTATE NewState); |
| HRESULT LoadDictation ([in, string] LPCWSTR pszTopicName,[in] SPLOADOPTIONS Options); |
| HRESULT UnloadDictation (); |
| HRESULT SetDictationState ([in] SPRULESTATE NewState); |
| HRESULT SetWordSequenceData ([in] const WCHAR *pText,[in] ULONG cchText,[in] const SPTEXTSELECTIONINFO *pInfo); |
| HRESULT SetTextSelection ([in] const SPTEXTSELECTIONINFO *pInfo); |
| HRESULT IsPronounceable ([in, string] LPCWSTR pszWord,[out] SPWORDPRONOUNCEABLE *pWordPronounceable); |
| HRESULT SetGrammarState ([in] SPGRAMMARSTATE eGrammarState); |
| HRESULT SaveCmd ([in] IStream *pStream,[out, optional] LPWSTR *ppszCoMemErrorText); |
| HRESULT GetGrammarState ([out] SPGRAMMARSTATE *peGrammarState); |
| }; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| typedef enum SPMATCHINGMODE { |
| AllWords = 0, |
| Subsequence = 1, |
| OrderedSubset = 3, |
| SubsequenceContentRequired = 5, |
| OrderedSubsetContentRequired = 7 |
| } SPMATCHINGMODE; |
| |
| typedef enum PHONETICALPHABET { |
| PA_Ipa = 0, |
| PA_Ups = 1, |
| PA_Sapi = 2, |
| } PHONETICALPHABET; |
| #endif |
| |
| #if _SAPI_BLD_ >= 0x53 |
| [object, local, uuid (8ab10026-20cc-4b20-8c22-A49C9BA78F60), pointer_default (unique), restricted] |
| interface ISpGrammarBuilder2 : IUnknown { |
| HRESULT AddTextSubset ([in] SPSTATEHANDLE hFromState,[in] SPSTATEHANDLE hToState,[in] LPCWSTR psz,[in] SPMATCHINGMODE eMatchMode); |
| HRESULT SetPhoneticAlphabet ([in] PHONETICALPHABET phoneticALphabet); |
| } |
| |
| cpp_quote("#define SPRP_NORMAL 0") |
| |
| [object, local, uuid (4b37bc9e-9ed6-44a3-93d3-18f022b79ec3), pointer_default (unique), restricted] |
| interface ISpRecoGrammar2 : IUnknown { |
| HRESULT GetRules ([out] SPRULE **ppCoMemRules,[out] UINT *puNumRules); |
| HRESULT LoadCmdFromFile2 ([in, string] LPCWSTR pszFileName,[in] SPLOADOPTIONS Options,[in, string] LPCWSTR pszSharingUri,[in, string] LPCWSTR pszBaseUri); |
| HRESULT LoadCmdFromMemory2 ([in] const SPBINARYGRAMMAR *pGrammar,[in] SPLOADOPTIONS Options,[in, string] LPCWSTR pszSharingUri,[in, string] LPCWSTR pszBaseUri); |
| HRESULT SetRulePriority ([in, string] LPCWSTR pszRuleName,[in] ULONG ulRuleId,[in] int nRulePriority); |
| HRESULT SetRuleWeight ([in, string] LPCWSTR pszRuleName,[in] ULONG ulRuleId,[in] float flWeight); |
| HRESULT SetDictationWeight ([in] float flWeight); |
| HRESULT SetGrammarLoader ([in] ISpeechResourceLoader *pLoader); |
| HRESULT SetSMLSecurityManager ([in] IInternetSecurityManager *pSMLSecurityManager); |
| } |
| |
| [object, local, uuid (B9AC5783-FCD0-4b21-B119-B4F8DA8FD2C3), pointer_default (unique), dual] |
| interface ISpeechResourceLoader : IDispatch { |
| [id (1)] HRESULT LoadResource ([in] BSTR bstrResourceUri,[in] VARIANT_BOOL fAlwaysReload,[out] IUnknown **pStream,[out] BSTR *pbstrMIMEType,[out] VARIANT_BOOL *pfModified,[out] BSTR *pbstrRedirectUrl); |
| [id (2)] HRESULT GetLocalCopy ([in] BSTR bstrResourceUri,[out] BSTR *pbstrLocalPath,[out] BSTR *pbstrMIMEType,[out] BSTR *pbstrRedirectUrl); |
| [id (3)] HRESULT ReleaseLocalCopy ([in] BSTR pbstrLocalPath); |
| } |
| #endif |
| |
| typedef [restricted, hidden] struct SPRECOCONTEXTSTATUS { |
| SPINTERFERENCE eInterference; |
| WCHAR szRequestTypeOfUI[255]; |
| DWORD dwReserved1; |
| DWORD dwReserved2; |
| } SPRECOCONTEXTSTATUS; |
| |
| typedef [hidden] enum SPBOOKMARKOPTIONS { |
| SPBO_NONE = 0, |
| SPBO_PAUSE = 0x1 |
| #if _SAPI_BLD_ >= 0x53 |
| , SPBO_AHEAD = 0x2, |
| SPBO_TIME_UNITS = 0x4 |
| #endif |
| } SPBOOKMARKOPTIONS; |
| |
| typedef [hidden] enum SPAUDIOOPTIONS { |
| SPAO_NONE = 0, |
| SPAO_RETAIN_AUDIO = 0x1 |
| } SPAUDIOOPTIONS; |
| |
| [object, local, uuid (F740A62F-7c15-489e-8234-940a33d9272d), pointer_default (unique), restricted] |
| interface ISpRecoContext : ISpEventSource { |
| HRESULT GetRecognizer ([out] ISpRecognizer **ppRecognizer); |
| HRESULT CreateGrammar ([in] ULONGLONG ullGrammarId,[out] ISpRecoGrammar **ppGrammar); |
| HRESULT GetStatus ([out] SPRECOCONTEXTSTATUS *pStatus); |
| HRESULT GetMaxAlternates ([in] ULONG *pcAlternates); |
| HRESULT SetMaxAlternates ([in] ULONG cAlternates); |
| HRESULT SetAudioOptions ([in] SPAUDIOOPTIONS Options,[in] const GUID *pAudioFormatId,[in] const WAVEFORMATEX *pWaveFormatEx); |
| HRESULT GetAudioOptions ([in] SPAUDIOOPTIONS *pOptions,[out] GUID *pAudioFormatId,[out] WAVEFORMATEX **ppCoMemWFEX); |
| HRESULT DeserializeResult ([in] const SPSERIALIZEDRESULT *pSerializedResult,[out] ISpRecoResult **ppResult); |
| HRESULT Bookmark ([in] SPBOOKMARKOPTIONS Options,[in] ULONGLONG ullStreamPosition,[in] LPARAM lparamEvent); |
| HRESULT SetAdaptationData ([in, string] LPCWSTR pAdaptationData,[in] const ULONG cch); |
| HRESULT Pause ([in] DWORD dwReserved); |
| HRESULT Resume ([in] DWORD dwReserved); |
| HRESULT SetVoice ([in] ISpVoice *pVoice,[in] WINBOOL fAllowFormatChanges); |
| HRESULT GetVoice ([out] ISpVoice **ppVoice); |
| HRESULT SetVoicePurgeEvent ([in] ULONGLONG ullEventInterest); |
| HRESULT GetVoicePurgeEvent ([out] ULONGLONG *pullEventInterest); |
| HRESULT SetContextState ([in] SPCONTEXTSTATE eContextState); |
| HRESULT GetContextState ([out] SPCONTEXTSTATE *peContextState); |
| }; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| typedef [hidden] enum SPGRAMMAROPTIONS { |
| SPGO_SAPI = 0x1, |
| SPGO_SRGS = 0x2, |
| SPGO_UPS = 0x4, |
| SPGO_SRGS_MS_SCRIPT = 0x8, |
| SPGO_FILE = 0x10, |
| SPGO_HTTP = 0x20, |
| SPGO_RES = 0x40, |
| SPGO_OBJECT = 0x80, |
| SPGO_SRGS_W3C_SCRIPT = 0x100, |
| SPGO_SRGS_STG_SCRIPT = 0x200, |
| |
| SPGO_SRGS_SCRIPT = SPGO_SRGS | SPGO_SRGS_MS_SCRIPT | SPGO_SRGS_W3C_SCRIPT | SPGO_SRGS_STG_SCRIPT, |
| SPGO_DEFAULT = 0x03fb, |
| SPGO_ALL = 0x03ff |
| } SPGRAMMAROPTIONS; |
| |
| typedef [hidden] enum SPADAPTATIONSETTINGS { |
| SPADS_Default = 0x0, |
| SPADS_CurrentRecognizer = 0x1, |
| SPADS_RecoProfile = 0x2, |
| SPADS_Immediate = 0x4, |
| SPADS_Reset = 0x8, |
| SPADS_HighVolumeDataSource = 0x10 |
| } SPADAPTATIONSETTINGS; |
| |
| typedef [hidden] enum SPADAPTATIONRELEVANCE { |
| SPAR_Unknown = 0, |
| SPAR_Low = 1, |
| SPAR_Medium = 2, |
| SPAR_High = 3 |
| } SPADAPTATIONRELEVANCE; |
| #endif |
| |
| #if _SAPI_BLD_ >= 0x53 |
| [object, local, uuid (BEAD311C-52ff-437f-9464-6b21054ca73d), pointer_default (unique), restricted] |
| interface ISpRecoContext2 : IUnknown { |
| HRESULT SetGrammarOptions ([in] DWORD eGrammarOptions); |
| HRESULT GetGrammarOptions ([out] DWORD *peGrammarOptions); |
| HRESULT SetAdaptationData2 ([in] LPCWSTR pAdaptationData,[in] const ULONG cch,[in] LPCWSTR pTopicName,[in] DWORD eAdaptationSettings,[in] SPADAPTATIONRELEVANCE eRelevance); |
| } |
| #endif |
| |
| [object, local, uuid (5b4fb971-B115-4de1-AD97-E482E3BF6EE4), pointer_default (unique), restricted] |
| interface ISpProperties : IUnknown { |
| HRESULT SetPropertyNum ([in] LPCWSTR pName,[in] LONG lValue); |
| HRESULT GetPropertyNum ([in] LPCWSTR pName,[out] LONG *plValue); |
| HRESULT SetPropertyString ([in] LPCWSTR pName,[in] LPCWSTR pValue); |
| HRESULT GetPropertyString ([in] LPCWSTR pName,[out, string] LPWSTR *ppCoMemValue); |
| }; |
| |
| const ULONG SP_MAX_LANGIDS = 20; |
| |
| typedef [restricted, hidden] struct SPRECOGNIZERSTATUS { |
| SPAUDIOSTATUS AudioStatus; |
| ULONGLONG ullRecognitionStreamPos; |
| ULONG ulStreamNumber; |
| ULONG ulNumActive; |
| CLSID clsidEngine; |
| ULONG cLangIDs; |
| LANGID aLangID[SP_MAX_LANGIDS]; |
| ULONGLONG ullRecognitionStreamTime; |
| } SPRECOGNIZERSTATUS; |
| |
| typedef [hidden] enum SPWAVEFORMATTYPE { |
| SPWF_INPUT, |
| SPWF_SRENGINE |
| } SPSTREAMFORMATTYPE; |
| |
| typedef [hidden] enum SPRECOSTATE { |
| SPRST_INACTIVE, |
| SPRST_ACTIVE, |
| SPRST_ACTIVE_ALWAYS, |
| SPRST_INACTIVE_WITH_PURGE, |
| SPRST_NUM_STATES |
| } SPRECOSTATE; |
| |
| #if _SAPI_BLD_ >= 0x54 |
| typedef enum SPCATEGORYTYPE { |
| SPCT_COMMAND, |
| SPCT_DICTATION, |
| SPCT_SLEEP, |
| SPCT_SUB_COMMAND, |
| SPCT_SUB_DICTATION |
| } SPCATEGORYTYPE; |
| #endif |
| |
| [object, local, uuid (C2B5F241-DAA0-4507-9e16-5a1eaa2b7a5c), pointer_default (unique), restricted] |
| interface ISpRecognizer : ISpProperties { |
| HRESULT SetRecognizer ([in] ISpObjectToken *pRecognizer); |
| HRESULT GetRecognizer ([out] ISpObjectToken **ppRecognizer); |
| HRESULT SetInput ([in] IUnknown *pUnkInput,[in] WINBOOL fAllowFormatChanges); |
| HRESULT GetInputObjectToken ([out] ISpObjectToken **ppToken); |
| HRESULT GetInputStream ([out] ISpStreamFormat **ppStream); |
| HRESULT CreateRecoContext ([out] ISpRecoContext **ppNewCtxt); |
| HRESULT GetRecoProfile ([out] ISpObjectToken **ppToken); |
| HRESULT SetRecoProfile ([in] ISpObjectToken *pToken); |
| HRESULT IsSharedInstance (void); |
| HRESULT GetRecoState ([out] SPRECOSTATE *pState); |
| HRESULT SetRecoState ([in] SPRECOSTATE NewState); |
| HRESULT GetStatus ([out] SPRECOGNIZERSTATUS *pStatus); |
| HRESULT GetFormat ([in] SPSTREAMFORMATTYPE WaveFormatType,[out] GUID *pFormatId,[out] WAVEFORMATEX **ppCoMemWFEX); |
| [local] HRESULT IsUISupported ([in] LPCWSTR pszTypeOfUI,[in] void *pvExtraData,[in] ULONG cbExtraData,[out] WINBOOL *pfSupported); |
| [local] HRESULT DisplayUI ([in] HWND hwndParent,[in] LPCWSTR pszTitle,[in] LPCWSTR pszTypeOfUI,[in] void *pvExtraData,[in] ULONG cbExtraData); |
| HRESULT EmulateRecognition ([in] ISpPhrase *pPhrase); |
| }; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| [object, uuid (21b501a0-0ec7-46c9-92c3-A2BC784C54B9), pointer_default (unique), restricted] |
| interface ISpSerializeState : IUnknown { |
| HRESULT GetSerializedState ([out] BYTE **ppbData,[out] ULONG *pulSize,[in] DWORD dwReserved); |
| HRESULT SetSerializedState ([in] BYTE *pbData,[in] ULONG ulSize,[in] DWORD dwReserved); |
| }; |
| |
| [object, local, uuid (8fc6d974-C81E-4098-93c5-0147f61ed4d3), pointer_default (unique), restricted] |
| interface ISpRecognizer2 : IUnknown { |
| HRESULT EmulateRecognitionEx ([in] ISpPhrase *pPhrase,[in] DWORD dwCompareFlags); |
| HRESULT SetTrainingState ([in] WINBOOL fDoingTraining,[in] WINBOOL fAdaptFromTrainingData); |
| HRESULT ResetAcousticModelAdaptation (); |
| } |
| |
| #if _SAPI_BLD_ >= 0x54 |
| [object, local, uuid (DA0CD0F9-14a2-4f09-8c2a-85cc48979345), pointer_default (unique), restricted] |
| interface ISpRecoCategory : IUnknown { |
| HRESULT GetType ([out] SPCATEGORYTYPE *peCategoryType); |
| } |
| |
| [object, local, uuid (DF1B943C-5838-4aa2-8706-D7CD5B333499), pointer_default (unique), restricted] |
| interface ISpRecognizer3 : IUnknown { |
| HRESULT GetCategory ([in] SPCATEGORYTYPE categoryType,[out] ISpRecoCategory **ppCategory); |
| HRESULT SetActiveCategory ([in] ISpRecoCategory *pCategory); |
| HRESULT GetActiveCategory ([out] ISpRecoCategory **ppCategory); |
| } |
| #endif |
| |
| typedef [restricted, hidden] struct SPNORMALIZATIONLIST { |
| ULONG ulSize; |
| WCHAR **ppszzNormalizedList; |
| } SPNORMALIZATIONLIST; |
| |
| [object, local, uuid (C360CE4B-76d1-4214-AD68-52657d5083da), pointer_default (unique), restricted] |
| interface ISpEnginePronunciation : IUnknown { |
| HRESULT Normalize ([in, string] LPCWSTR pszWord,[in, string] LPCWSTR pszLeftContext,[in, string] LPCWSTR pszRightContext,[in] LANGID LangID,[out] SPNORMALIZATIONLIST *pNormalizationList); |
| HRESULT GetPronunciations ([in, string] LPCWSTR pszWord,[in, string] LPCWSTR pszLeftContext,[in, string] LPCWSTR pszRightContext,[in] LANGID LangID,[in, out] SPWORDPRONUNCIATIONLIST *pEnginePronunciationList); |
| } |
| |
| typedef [restricted, hidden] struct SPDISPLAYTOKEN { |
| const WCHAR *pszLexical; |
| const WCHAR *pszDisplay; |
| BYTE bDisplayAttributes; |
| } SPDISPLAYTOKEN; |
| |
| typedef [restricted, hidden] struct SPDISPLAYPHRASE { |
| ULONG ulNumTokens; |
| SPDISPLAYTOKEN *pTokens; |
| } SPDISPLAYPHRASE; |
| |
| [object, local, uuid (C8D7C7E2-0dde-44b7-AFE3-B0C991FBEB5E), pointer_default (unique)] |
| interface ISpDisplayAlternates : IUnknown { |
| HRESULT GetDisplayAlternates ([in] const SPDISPLAYPHRASE *pPhrase,[in] ULONG cRequestCount,[out] SPDISPLAYPHRASE **ppCoMemPhrases,[out] ULONG *pcPhrasesReturned); |
| HRESULT SetFullStopTrailSpace ([in] ULONG ulTrailSpace); |
| } |
| #endif |
| |
| [uuid (C866CA3A-32f7-11d2-9602-00c04f8ee628), version (5.4)] |
| library SpeechLib { |
| importlib ("stdole32.tlb"); |
| importlib ("stdole2.tlb"); |
| |
| interface ISpeechDataKey; |
| interface ISpeechObjectToken; |
| interface ISpeechObjectTokens; |
| interface ISpeechObjectTokenCategory; |
| interface ISpeechAudioBufferInfo; |
| interface ISpeechAudioStatus; |
| interface ISpeechAudioFormat; |
| interface ISpeechWaveFormatEx; |
| interface ISpeechBaseStream; |
| interface ISpeechFileStream; |
| interface ISpeechMemoryStream; |
| interface ISpeechCustomStream; |
| interface ISpeechAudio; |
| interface ISpeechMMSysAudio; |
| interface ISpeechVoice; |
| interface ISpeechVoiceStatus; |
| dispinterface _ISpeechVoiceEvents; |
| interface ISpeechRecognizer; |
| interface ISpeechRecognizerStatus; |
| interface ISpeechRecoContext; |
| interface ISpeechRecoGrammar; |
| dispinterface _ISpeechRecoContextEvents; |
| interface ISpeechGrammarRule; |
| interface ISpeechGrammarRules; |
| interface ISpeechGrammarRuleState; |
| interface ISpeechGrammarRuleStateTransition; |
| interface ISpeechGrammarRuleStateTransitions; |
| interface ISpeechTextSelectionInformation; |
| interface ISpeechRecoResult; |
| #if _SAPI_BLD_ >= 0x53 |
| interface ISpeechRecoResult2; |
| #endif |
| interface ISpeechRecoResultTimes; |
| interface ISpeechPhraseAlternate; |
| interface ISpeechPhraseAlternates; |
| interface ISpeechPhraseInfo; |
| interface ISpeechPhraseElement; |
| interface ISpeechPhraseElements; |
| interface ISpeechPhraseReplacement; |
| interface ISpeechPhraseReplacements; |
| interface ISpeechPhraseProperty; |
| interface ISpeechPhraseProperties; |
| interface ISpeechPhraseRule; |
| interface ISpeechPhraseRules; |
| interface ISpeechLexicon; |
| interface ISpeechLexiconWords; |
| interface ISpeechLexiconWord; |
| interface ISpeechLexiconPronunciations; |
| interface ISpeechLexiconPronunciation; |
| |
| typedef long SpeechLanguageId; |
| cpp_quote("#define __SpeechStringConstants_MODULE_DEFINED__") |
| [uuid (E58442E4-0c80-402c-9559-867337a39765)] module SpeechStringConstants { |
| const BSTR SpeechRegistryUserRoot = L"HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech"; |
| const BSTR SpeechRegistryLocalMachineRoot = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech"; |
| const BSTR SpeechCategoryAudioOut = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioOutput"; |
| const BSTR SpeechCategoryAudioIn = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioInput"; |
| const BSTR SpeechCategoryVoices = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\Voices"; |
| const BSTR SpeechCategoryRecognizers = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\Recognizers"; |
| const BSTR SpeechCategoryAppLexicons = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AppLexicons"; |
| const BSTR SpeechCategoryPhoneConverters = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\PhoneConverters"; |
| const BSTR SpeechCategoryRecoProfiles = L"HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech\\RecoProfiles"; |
| const BSTR SpeechTokenIdUserLexicon = L"HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech\\CurrentUserLexicon"; |
| const BSTR SpeechTokenValueCLSID = L"CLSID"; |
| const BSTR SpeechTokenKeyFiles = L"Files"; |
| const BSTR SpeechTokenKeyUI = L"UI"; |
| const BSTR SpeechTokenKeyAttributes = L"Attributes"; |
| const BSTR SpeechVoiceCategoryTTSRate = L"DefaultTTSRate"; |
| const BSTR SpeechPropertyResourceUsage = L"ResourceUsage"; |
| const BSTR SpeechPropertyHighConfidenceThreshold = L"HighConfidenceThreshold"; |
| const BSTR SpeechPropertyNormalConfidenceThreshold = L"NormalConfidenceThreshold"; |
| const BSTR SpeechPropertyLowConfidenceThreshold = L"LowConfidenceThreshold"; |
| const BSTR SpeechPropertyResponseSpeed = L"ResponseSpeed"; |
| const BSTR SpeechPropertyComplexResponseSpeed = L"ComplexResponseSpeed"; |
| const BSTR SpeechPropertyAdaptationOn = L"AdaptationOn"; |
| const BSTR SpeechDictationTopicSpelling = L"Spelling"; |
| const BSTR SpeechGrammarTagWildcard = L"..."; |
| const BSTR SpeechGrammarTagDictation = L"*"; |
| const BSTR SpeechGrammarTagUnlimitedDictation = L"*+"; |
| const BSTR SpeechEngineProperties = L"EngineProperties"; |
| const BSTR SpeechAddRemoveWord = L"AddRemoveWord"; |
| const BSTR SpeechUserTraining = L"UserTraining"; |
| const BSTR SpeechMicTraining = L"MicTraining"; |
| const BSTR SpeechRecoProfileProperties = L"RecoProfileProperties"; |
| const BSTR SpeechAudioProperties = L"AudioProperties"; |
| const BSTR SpeechAudioVolume = L"AudioVolume"; |
| const BSTR SpeechVoiceSkipTypeSentence = L"Sentence"; |
| const BSTR SpeechAudioFormatGUIDWave = L"{C31ADBAE-527F-4ff5-A230-F62BB61FF70C}"; |
| const BSTR SpeechAudioFormatGUIDText = L"{7CEEF9F9-3D13-11d2-9EE7-00C04F797396}"; |
| }; |
| [uuid (F3E092B2-6bdc-410f-BCB2-4c5ed4424180)] module SpeechConstants { |
| const float Speech_Default_Weight = DEFAULT_WEIGHT; |
| const LONG Speech_Max_Word_Length = SP_MAX_WORD_LENGTH; |
| const LONG Speech_Max_Pron_Length = SP_MAX_PRON_LENGTH; |
| const LONG Speech_StreamPos_Asap = SP_STREAMPOS_ASAP; |
| const LONG Speech_StreamPos_RealTime = SP_STREAMPOS_REALTIME; |
| const LONG SpeechAllElements = SPPR_ALL_ELEMENTS; |
| }; |
| |
| typedef [hidden] 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 |
| } DISPID_SpeechDataKey; |
| |
| typedef [hidden] 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 |
| } DISPID_SpeechObjectToken; |
| |
| typedef enum SpeechDataKeyLocation { |
| SDKLDefaultLocation = SPDKL_DefaultLocation, |
| SDKLCurrentUser = SPDKL_CurrentUser, |
| SDKLLocalMachine = SPDKL_LocalMachine, |
| SDKLCurrentConfig = SPDKL_CurrentConfig |
| } SpeechDataKeyLocation; |
| |
| #define CLSCTXALL (CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER) |
| |
| typedef enum SpeechTokenContext { |
| STCInprocServer = CLSCTX_INPROC_SERVER, |
| STCInprocHandler = CLSCTX_INPROC_HANDLER, |
| STCLocalServer = CLSCTX_LOCAL_SERVER, |
| STCRemoteServer = CLSCTX_REMOTE_SERVER, |
| STCAll = CLSCTXALL |
| } SpeechTokenContext; |
| |
| typedef enum SpeechTokenShellFolder { |
| STSF_AppData = 0x001a, |
| STSF_LocalAppData = 0x001c, |
| STSF_CommonAppData = 0x0023, |
| STSF_FlagCreate = 0x8000 |
| } SpeechTokenShellFolder; |
| |
| typedef [hidden] enum DISPID_SpeechObjectTokens { |
| DISPID_SOTsCount = 1, |
| DISPID_SOTsItem = DISPID_VALUE, |
| DISPID_SOTs_NewEnum = DISPID_NEWENUM |
| } DISPID_SpeechObjectTokens; |
| |
| typedef [hidden] enum DISPID_SpeechObjectTokenCategory { |
| DISPID_SOTCId = 1, |
| DISPID_SOTCDefault, |
| DISPID_SOTCSetId, |
| DISPID_SOTCGetDataKey, |
| DISPID_SOTCEnumerateTokens, |
| } DISPID_SpeechObjectTokenCategory; |
| |
| [object, uuid (CE17C09B-4efa-44d5-A4C9-59d9585ab0cd), dual, pointer_default (unique)] |
| interface ISpeechDataKey : IDispatch { |
| [id (DISPID_SDKSetBinaryValue)] HRESULT SetBinaryValue ([in]const BSTR ValueName,[in]VARIANT Value); |
| [id (DISPID_SDKGetBinaryValue)] HRESULT GetBinaryValue ([in]const BSTR ValueName,[out, retval]VARIANT *Value); |
| [id (DISPID_SDKSetStringValue)] HRESULT SetStringValue ([in]const BSTR ValueName,[in]const BSTR Value); |
| [id (DISPID_SDKGetStringValue)] HRESULT GetStringValue ([in]const BSTR ValueName,[out, retval]BSTR *Value); |
| [id (DISPID_SDKSetLongValue)] HRESULT SetLongValue ([in]const BSTR ValueName,[in]long Value); |
| [id (DISPID_SDKGetlongValue)] HRESULT GetLongValue ([in]const BSTR ValueName,[out, retval]long *Value); |
| [id (DISPID_SDKOpenKey)] HRESULT OpenKey ([in]const BSTR SubKeyName,[out, retval]ISpeechDataKey **SubKey); |
| [id (DISPID_SDKCreateKey)] HRESULT CreateKey ([in]const BSTR SubKeyName,[out, retval]ISpeechDataKey **SubKey); |
| [id (DISPID_SDKDeleteKey)] HRESULT DeleteKey ([in]const BSTR SubKeyName); |
| [id (DISPID_SDKDeleteValue)] HRESULT DeleteValue ([in]const BSTR ValueName); |
| [id (DISPID_SDKEnumKeys)] HRESULT EnumKeys ([in]long Index,[out, retval]BSTR *SubKeyName); |
| [id (DISPID_SDKEnumValues)] HRESULT EnumValues ([in]long Index,[out, retval]BSTR *ValueName); |
| }; |
| |
| [object, uuid (C74A3ADC-B727-4500-A84A-B526721C8B8C), dual, pointer_default (unique)] |
| interface ISpeechObjectToken : IDispatch { |
| [propget, id (DISPID_SOTId)] HRESULT Id ([out, retval]BSTR *ObjectId); |
| [propget, id (DISPID_SOTDataKey), hidden] HRESULT DataKey ([out, retval]ISpeechDataKey **DataKey); |
| [propget, id (DISPID_SOTCategory)] HRESULT Category ([out, retval]ISpeechObjectTokenCategory **Category); |
| [id (DISPID_SOTGetDescription)] HRESULT GetDescription ([in, defaultvalue (0)]long Locale,[out, retval]BSTR *Description); |
| [hidden, id (DISPID_SOTSetId)] HRESULT SetId ([in] BSTR Id,[in, defaultvalue (L"")] BSTR CategoryID,[in, defaultvalue (0)]VARIANT_BOOL CreateIfNotExist); |
| [id (DISPID_SOTGetAttribute)] HRESULT GetAttribute ([in] BSTR AttributeName,[out, retval]BSTR *AttributeValue); |
| [id (DISPID_SOTCreateInstance)] HRESULT CreateInstance ([in, defaultvalue (NULL)] IUnknown *pUnkOuter,[in, defaultvalue (STCAll)] SpeechTokenContext ClsContext,[out, retval]IUnknown **Object); |
| [hidden, id (DISPID_SOTRemove)] HRESULT Remove ([in]BSTR ObjectStorageCLSID); |
| [hidden, id (DISPID_SOTGetStorageFileName)] HRESULT GetStorageFileName ([in]BSTR ObjectStorageCLSID,[in]BSTR KeyName,[in]BSTR FileName,[in]SpeechTokenShellFolder Folder,[out, retval]BSTR *FilePath); |
| [hidden, id (DISPID_SOTRemoveStorageFileName)] HRESULT RemoveStorageFileName ([in]BSTR ObjectStorageCLSID,[in]BSTR KeyName,[in]VARIANT_BOOL DeleteFile); |
| [hidden, id (DISPID_SOTIsUISupported)] HRESULT IsUISupported ([in]const BSTR TypeOfUI,[in, defaultvalue (NULL)]const VARIANT *ExtraData,[in, defaultvalue (NULL)]IUnknown *Object,[out, retval] VARIANT_BOOL *Supported); |
| [hidden, id (DISPID_SOTDisplayUI)] HRESULT DisplayUI ([in]long hWnd,[in]BSTR Title,[in]const BSTR TypeOfUI,[in, defaultvalue (NULL)]const VARIANT *ExtraData,[in, defaultvalue (NULL)]IUnknown *Object); |
| [id (DISPID_SOTMatchesAttributes)] HRESULT MatchesAttributes ([in]BSTR Attributes,[out, retval] VARIANT_BOOL *Matches); |
| }; |
| |
| [object, uuid (9285b776-2e7b-4bc0-B53E-580eb6fa967f), dual, pointer_default (unique)] |
| interface ISpeechObjectTokens : IDispatch { |
| [propget, id (DISPID_SOTsCount)] HRESULT Count ([out, retval] long *Count); |
| [id (DISPID_VALUE)] HRESULT Item ([in] long Index,[out, retval]ISpeechObjectToken **Token); |
| [propget, restricted, id (DISPID_NEWENUM)] HRESULT _NewEnum ([out, retval] IUnknown **ppEnumVARIANT); |
| }; |
| |
| [object, uuid (CA7EAC50-2d01-4145-86d4-5ae7d70f4469), dual, pointer_default (unique)] |
| interface ISpeechObjectTokenCategory : IDispatch { |
| [propget, id (DISPID_SOTCId)] HRESULT Id ([out, retval] BSTR *Id); |
| [propput, id (DISPID_SOTCDefault)] HRESULT Default ([in] const BSTR TokenId); |
| [propget, id (DISPID_SOTCDefault)] HRESULT Default ([out, retval] BSTR *TokenId); |
| [id (DISPID_SOTCSetId)] HRESULT SetId ([in] const BSTR Id,[in, defaultvalue (0)]VARIANT_BOOL CreateIfNotExist); |
| [hidden, id (DISPID_SOTCGetDataKey)] HRESULT GetDataKey ([in, defaultvalue (SDKLDefaultLocation)]SpeechDataKeyLocation Location,[out, retval]ISpeechDataKey **DataKey); |
| [id (DISPID_SOTCEnumerateTokens)] HRESULT EnumerateTokens ([in, defaultvalue (L"")]BSTR RequiredAttributes,[in, defaultvalue (L"")]BSTR OptionalAttributes,[out, retval]ISpeechObjectTokens **Tokens); |
| }; |
| |
| typedef enum SpeechAudioFormatType { |
| SAFTDefault = -1, |
| SAFTNoAssignedFormat = 0, |
| SAFTText, |
| SAFTNonStandardFormat, |
| SAFTExtendedAudioFormat, |
| SAFT8kHz8BitMono, |
| SAFT8kHz8BitStereo, |
| SAFT8kHz16BitMono, |
| SAFT8kHz16BitStereo, |
| SAFT11kHz8BitMono, |
| SAFT11kHz8BitStereo, |
| SAFT11kHz16BitMono, |
| SAFT11kHz16BitStereo, |
| SAFT12kHz8BitMono, |
| SAFT12kHz8BitStereo, |
| SAFT12kHz16BitMono, |
| SAFT12kHz16BitStereo, |
| SAFT16kHz8BitMono, |
| SAFT16kHz8BitStereo, |
| SAFT16kHz16BitMono, |
| SAFT16kHz16BitStereo, |
| SAFT22kHz8BitMono, |
| SAFT22kHz8BitStereo, |
| SAFT22kHz16BitMono, |
| SAFT22kHz16BitStereo, |
| SAFT24kHz8BitMono, |
| SAFT24kHz8BitStereo, |
| SAFT24kHz16BitMono, |
| SAFT24kHz16BitStereo, |
| SAFT32kHz8BitMono, |
| SAFT32kHz8BitStereo, |
| SAFT32kHz16BitMono, |
| SAFT32kHz16BitStereo, |
| SAFT44kHz8BitMono, |
| SAFT44kHz8BitStereo, |
| SAFT44kHz16BitMono, |
| SAFT44kHz16BitStereo, |
| SAFT48kHz8BitMono, |
| SAFT48kHz8BitStereo, |
| SAFT48kHz16BitMono, |
| SAFT48kHz16BitStereo, |
| SAFTTrueSpeech_8kHz1BitMono, |
| SAFTCCITT_ALaw_8kHzMono, |
| SAFTCCITT_ALaw_8kHzStereo, |
| SAFTCCITT_ALaw_11kHzMono, |
| SAFTCCITT_ALaw_11kHzStereo, |
| SAFTCCITT_ALaw_22kHzMono, |
| SAFTCCITT_ALaw_22kHzStereo, |
| SAFTCCITT_ALaw_44kHzMono, |
| SAFTCCITT_ALaw_44kHzStereo, |
| |
| SAFTCCITT_uLaw_8kHzMono, |
| SAFTCCITT_uLaw_8kHzStereo, |
| SAFTCCITT_uLaw_11kHzMono, |
| SAFTCCITT_uLaw_11kHzStereo, |
| SAFTCCITT_uLaw_22kHzMono, |
| SAFTCCITT_uLaw_22kHzStereo, |
| SAFTCCITT_uLaw_44kHzMono, |
| SAFTCCITT_uLaw_44kHzStereo, |
| |
| SAFTADPCM_8kHzMono, |
| SAFTADPCM_8kHzStereo, |
| SAFTADPCM_11kHzMono, |
| SAFTADPCM_11kHzStereo, |
| SAFTADPCM_22kHzMono, |
| SAFTADPCM_22kHzStereo, |
| SAFTADPCM_44kHzMono, |
| SAFTADPCM_44kHzStereo, |
| SAFTGSM610_8kHzMono, |
| SAFTGSM610_11kHzMono, |
| SAFTGSM610_22kHzMono, |
| SAFTGSM610_44kHzMono, |
| } SpeechAudioFormatType; |
| |
| typedef [hidden] enum DISPID_SpeechAudioFormat { |
| DISPID_SAFType = 1, |
| DISPID_SAFGuid, |
| DISPID_SAFGetWaveFormatEx, |
| DISPID_SAFSetWaveFormatEx |
| } DISPID_SpeechAudioFormat; |
| |
| typedef [hidden] enum DISPID_SpeechBaseStream { |
| DISPID_SBSFormat = 1, |
| DISPID_SBSRead, |
| DISPID_SBSWrite, |
| DISPID_SBSSeek |
| } DISPID_SpeechBaseStream; |
| |
| typedef enum SpeechStreamSeekPositionType { |
| SSSPTRelativeToStart = STREAM_SEEK_SET, |
| SSSPTRelativeToCurrentPosition = STREAM_SEEK_CUR, |
| SSSPTRelativeToEnd = STREAM_SEEK_END |
| } SpeechStreamSeekPositionType; |
| |
| typedef [hidden] enum DISPID_SpeechAudio { |
| DISPID_SAStatus = 200, |
| DISPID_SABufferInfo, |
| DISPID_SADefaultFormat, |
| DISPID_SAVolume, |
| DISPID_SABufferNotifySize, |
| DISPID_SAEventHandle, |
| DISPID_SASetState |
| } DISPID_SpeechAudio; |
| |
| typedef enum SpeechAudioState { |
| SASClosed = SPAS_CLOSED, |
| SASStop = SPAS_STOP, |
| SASPause = SPAS_PAUSE, |
| SASRun = SPAS_RUN |
| } SpeechAudioState; |
| |
| typedef [hidden] enum DISPID_SpeechMMSysAudio { |
| DISPID_SMSADeviceId = 300, |
| DISPID_SMSALineId, |
| DISPID_SMSAMMHandle |
| } DISPID_SpeechMMSysAudio; |
| |
| typedef [hidden] enum DISPID_SpeechFileStream { |
| DISPID_SFSOpen = 100, |
| DISPID_SFSClose |
| } DISPID_SpeechFileStream; |
| |
| typedef enum SpeechStreamFileMode { |
| SSFMOpenForRead = SPFM_OPEN_READONLY, |
| SSFMOpenReadWrite = SPFM_OPEN_READWRITE, |
| SSFMCreate = SPFM_CREATE, |
| SSFMCreateForWrite = SPFM_CREATE_ALWAYS, |
| } SpeechStreamFileMode; |
| |
| typedef [hidden] enum DISPID_SpeechCustomStream { |
| DISPID_SCSBaseStream = 100 |
| } DISPID_SpeechCustomStream; |
| |
| typedef [hidden] enum DISPID_SpeechMemoryStream { |
| DISPID_SMSSetData = 100, |
| DISPID_SMSGetData |
| } DISPID_SpeechMemoryStream; |
| |
| typedef [hidden] enum DISPID_SpeechAudioStatus { |
| DISPID_SASFreeBufferSpace = 1, |
| DISPID_SASNonBlockingIO, |
| DISPID_SASState, |
| DISPID_SASCurrentSeekPosition, |
| DISPID_SASCurrentDevicePosition |
| } DISPID_SpeechAudioStatus; |
| |
| typedef [hidden] enum DISPID_SpeechAudioBufferInfo { |
| DISPID_SABIMinNotification = 1, |
| DISPID_SABIBufferSize, |
| DISPID_SABIEventBias |
| } DISPID_SpeechAudioBufferInfo; |
| |
| typedef [hidden] enum DISPID_SpeechWaveFormatEx { |
| DISPID_SWFEFormatTag = 1, |
| DISPID_SWFEChannels, |
| DISPID_SWFESamplesPerSec, |
| DISPID_SWFEAvgBytesPerSec, |
| DISPID_SWFEBlockAlign, |
| DISPID_SWFEBitsPerSample, |
| DISPID_SWFEExtraData |
| } DISPID_SpeechWaveFormatEx; |
| |
| typedef [hidden] 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 |
| } DISPID_SpeechVoice; |
| |
| typedef enum SpeechVoicePriority { |
| SVPNormal = SPVPRI_NORMAL, |
| SVPAlert = SPVPRI_ALERT, |
| SVPOver = SPVPRI_OVER |
| } SpeechVoicePriority; |
| |
| typedef 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, |
| #if _SAPI_BLD_ >= 0x53 |
| SVSFParseSapi = SPF_PARSE_SAPI, |
| SVSFParseSsml = SPF_PARSE_SSML, |
| SVSFParseAutodetect = SPF_PARSE_AUTODETECT, |
| #endif |
| SVSFNLPMask = SPF_NLP_MASK, |
| #if _SAPI_BLD_ >= 0x53 |
| SVSFParseMask = SPF_PARSE_MASK, |
| #endif |
| SVSFVoiceMask = SPF_VOICE_MASK, |
| SVSFUnusedFlags = SPF_UNUSED_FLAGS, |
| } SpeechVoiceSpeakFlags; |
| |
| typedef enum SpeechVoiceEvents { |
| SVEStartInputStream = 0x2, |
| SVEEndInputStream = 0x4, |
| SVEVoiceChange = 0x8, |
| SVEBookmark = 0x10, |
| SVEWordBoundary = 0x20, |
| SVEPhoneme = 0x40, |
| SVESentenceBoundary = 0x80, |
| SVEViseme = 0x100, |
| SVEAudioLevel = 0x200, |
| SVEPrivate = 0x8000, |
| SVEAllEvents = 0x83fe |
| } SpeechVoiceEvents; |
| |
| typedef [hidden] 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 |
| } DISPID_SpeechVoiceStatus; |
| |
| typedef enum SpeechRunState { |
| SRSEDone = SPRS_DONE, |
| SRSEIsSpeaking = SPRS_IS_SPEAKING |
| } SpeechRunState; |
| |
| [object, uuid (E6E9C590-3e18-40e3-8299-061f98bde7c7), dual, pointer_default (unique)] |
| interface ISpeechAudioFormat : IDispatch { |
| [propget, id (DISPID_SAFType)] HRESULT Type ([out, retval]SpeechAudioFormatType *AudioFormat); |
| [propput, id (DISPID_SAFType)] HRESULT Type ([in]SpeechAudioFormatType AudioFormat); |
| [propget, hidden, id (DISPID_SAFGuid)] HRESULT Guid ([out, retval]BSTR *Guid); |
| [propput, hidden, id (DISPID_SAFGuid)] HRESULT Guid ([in]BSTR Guid); |
| [hidden, id (DISPID_SAFGetWaveFormatEx)] HRESULT GetWaveFormatEx ([out, retval]ISpeechWaveFormatEx **SpeechWaveFormatEx); |
| [hidden, id (DISPID_SAFSetWaveFormatEx)] HRESULT SetWaveFormatEx ([in]ISpeechWaveFormatEx *SpeechWaveFormatEx); |
| } |
| |
| [object, uuid (6450336f-7d49-4ced-8097-49d6dee37294), dual, pointer_default (unique)] |
| interface ISpeechBaseStream : IDispatch { |
| [propget, id (DISPID_SBSFormat)] HRESULT Format ([out, retval]ISpeechAudioFormat **AudioFormat); |
| [propputref, id (DISPID_SBSFormat)] HRESULT Format ([in]ISpeechAudioFormat *AudioFormat); |
| [id (DISPID_SBSRead)] HRESULT Read ([out]VARIANT *Buffer,[in]long NumberOfBytes,[out, retval]long *BytesRead); |
| [id (DISPID_SBSWrite)] HRESULT Write ([in]VARIANT Buffer,[out, retval]long *BytesWritten); |
| [id (DISPID_SBSSeek)] HRESULT Seek ([in]VARIANT Position,[in, defaultvalue (SSSPTRelativeToStart)]SpeechStreamSeekPositionType Origin,[out, retval]VARIANT *NewPosition); |
| }; |
| |
| [object, uuid (CFF8E175-019e-11d3-A08E-00c04f8ef9b5), dual, pointer_default (unique)] |
| interface ISpeechAudio : ISpeechBaseStream { |
| [propget, id (DISPID_SAStatus)] HRESULT Status ([out, retval]ISpeechAudioStatus **Status); |
| [propget, id (DISPID_SABufferInfo)] HRESULT BufferInfo ([out, retval]ISpeechAudioBufferInfo **BufferInfo); |
| [propget, id (DISPID_SADefaultFormat)] HRESULT DefaultFormat ([out, retval]ISpeechAudioFormat **StreamFormat); |
| [propget, id (DISPID_SAVolume)] HRESULT Volume ([out, retval]long *Volume); |
| [propput, id (DISPID_SAVolume)] HRESULT Volume ([in]long Volume); |
| [propget, id (DISPID_SABufferNotifySize)] HRESULT BufferNotifySize ([out, retval]long *BufferNotifySize); |
| [propput, id (DISPID_SABufferNotifySize)] HRESULT BufferNotifySize ([in]long BufferNotifySize); |
| [propget, hidden, id (DISPID_SAEventHandle)] HRESULT EventHandle ([out, retval]long *EventHandle); |
| [id (DISPID_SASetState), hidden] HRESULT SetState ([in] SpeechAudioState State); |
| }; |
| |
| [object, uuid (3c76af6d-1fd7-4831-81d1-3b71d5a13c44), dual, pointer_default (unique)] |
| interface ISpeechMMSysAudio : ISpeechAudio { |
| [propget, id (DISPID_SMSADeviceId)] HRESULT DeviceId ([out, retval] long *DeviceId); |
| [propput, id (DISPID_SMSADeviceId)] HRESULT DeviceId ([in] long DeviceId); |
| [propget, id (DISPID_SMSALineId)] HRESULT LineId ([out, retval] long *LineId); |
| [propput, id (DISPID_SMSALineId)] HRESULT LineId ([in] long LineId); |
| [propget, hidden, id (DISPID_SMSAMMHandle)] HRESULT MMHandle ([out, retval] long *Handle); |
| }; |
| |
| [object, uuid (AF67F125-AB39-4e93-B4A2-CC2E66E182A7), dual, pointer_default (unique)] |
| interface ISpeechFileStream : ISpeechBaseStream { |
| [id (DISPID_SFSOpen)] HRESULT Open ([in] BSTR FileName,[in, defaultvalue (SSFMOpenForRead)] SpeechStreamFileMode FileMode,[in, defaultvalue (0)]VARIANT_BOOL DoEvents); |
| [id (DISPID_SFSClose)] HRESULT Close (void); |
| }; |
| |
| [object, uuid (1a9e9f4f-104f-4db8-A115-EFD7FD0C97AE), dual, pointer_default (unique)] |
| interface ISpeechCustomStream : ISpeechBaseStream { |
| [propget, id (DISPID_SCSBaseStream)] HRESULT BaseStream ([out, retval] IUnknown **ppUnkStream); |
| [propputref, id (DISPID_SCSBaseStream)] HRESULT BaseStream ([in] IUnknown *pUnkStream); |
| }; |
| |
| [object, uuid (EEB14B68-808b-4abe-A5EA-B51DA7588008), dual, pointer_default (unique)] |
| interface ISpeechMemoryStream : ISpeechBaseStream { |
| [id (DISPID_SMSSetData)] HRESULT SetData ([in] VARIANT Data); |
| [id (DISPID_SMSGetData)] HRESULT GetData ([out, retval] VARIANT *pData); |
| }; |
| |
| [object, uuid (C62D9C91-7458-47f6-862d-1ef86fb0b278), dual, pointer_default (unique)] |
| interface ISpeechAudioStatus : IDispatch { |
| [propget, id (DISPID_SASFreeBufferSpace)] HRESULT FreeBufferSpace ([out, retval]long *FreeBufferSpace); |
| [propget, id (DISPID_SASNonBlockingIO)] HRESULT NonBlockingIO ([out, retval]long *NonBlockingIO); |
| [propget, id (DISPID_SASState)] HRESULT State ([out, retval] SpeechAudioState *State); |
| [propget, id (DISPID_SASCurrentSeekPosition)] HRESULT CurrentSeekPosition ([out, retval]VARIANT *CurrentSeekPosition); |
| [propget, id (DISPID_SASCurrentDevicePosition)] HRESULT CurrentDevicePosition ([out, retval]VARIANT *CurrentDevicePosition); |
| }; |
| |
| [object, uuid (11b103d8-1142-4edf-A093-82fb3915f8cc), dual, pointer_default (unique)] |
| interface ISpeechAudioBufferInfo : IDispatch { |
| [propget, id (DISPID_SABIMinNotification)] HRESULT MinNotification ([out, retval]long *MinNotification); |
| [propput, id (DISPID_SABIMinNotification)] HRESULT MinNotification ([in]long MinNotification); |
| [propget, id (DISPID_SABIBufferSize)] HRESULT BufferSize ([out, retval]long *BufferSize); |
| [propput, id (DISPID_SABIBufferSize)] HRESULT BufferSize ([in]long BufferSize); |
| [propget, id (DISPID_SABIEventBias)] HRESULT EventBias ([out, retval]long *EventBias); |
| [propput, id (DISPID_SABIEventBias)] HRESULT EventBias ([in]long EventBias); |
| } |
| |
| [object, uuid (7a1ef0d5-1581-4741-88e4-209a49f11a10), dual, pointer_default (unique)] |
| interface ISpeechWaveFormatEx : IDispatch { |
| [propget, id (DISPID_SWFEFormatTag)] HRESULT FormatTag ([out, retval]short *FormatTag); |
| [propput, id (DISPID_SWFEFormatTag)] HRESULT FormatTag ([in]short FormatTag); |
| [propget, id (DISPID_SWFEChannels)] HRESULT Channels ([out, retval]short *Channels); |
| [propput, id (DISPID_SWFEChannels)] HRESULT Channels ([in]short Channels); |
| [propget, id (DISPID_SWFESamplesPerSec)] HRESULT SamplesPerSec ([out, retval]long *SamplesPerSec); |
| [propput, id (DISPID_SWFESamplesPerSec)] HRESULT SamplesPerSec ([in]long SamplesPerSec); |
| [propget, id (DISPID_SWFEAvgBytesPerSec)] HRESULT AvgBytesPerSec ([out, retval]long *AvgBytesPerSec); |
| [propput, id (DISPID_SWFEAvgBytesPerSec)] HRESULT AvgBytesPerSec ([in]long AvgBytesPerSec); |
| [propget, id (DISPID_SWFEBlockAlign)] HRESULT BlockAlign ([out, retval]short *BlockAlign); |
| [propput, id (DISPID_SWFEBlockAlign)] HRESULT BlockAlign ([in]short BlockAlign); |
| [propget, id (DISPID_SWFEBitsPerSample)] HRESULT BitsPerSample ([out, retval]short *BitsPerSample); |
| [propput, id (DISPID_SWFEBitsPerSample)] HRESULT BitsPerSample ([in]short BitsPerSample); |
| [propget, id (DISPID_SWFEExtraData)] HRESULT ExtraData ([out, retval]VARIANT *ExtraData); |
| [propput, id (DISPID_SWFEExtraData)] HRESULT ExtraData ([in]VARIANT ExtraData); |
| } |
| |
| [object, uuid (269316d8-57bd-11d2-9eee-00c04f797396), dual, pointer_default (unique)] |
| interface ISpeechVoice : IDispatch { |
| [propget, id (DISPID_SVStatus)] HRESULT Status ([out, retval] ISpeechVoiceStatus **Status); |
| [propget, id (DISPID_SVVoice)] HRESULT Voice ([out, retval] ISpeechObjectToken **Voice); |
| [propputref, id (DISPID_SVVoice)] HRESULT Voice ([in]ISpeechObjectToken *Voice); |
| [propget, id (DISPID_SVAudioOutput)] HRESULT AudioOutput ([out, retval]ISpeechObjectToken **AudioOutput); |
| [propputref, id (DISPID_SVAudioOutput)] HRESULT AudioOutput ([in]ISpeechObjectToken *AudioOutput); |
| [propget, id (DISPID_SVAudioOutputStream)] HRESULT AudioOutputStream ([out, retval]ISpeechBaseStream **AudioOutputStream); |
| [propputref, id (DISPID_SVAudioOutputStream)] HRESULT AudioOutputStream ([in]ISpeechBaseStream *AudioOutputStream); |
| [propget, id (DISPID_SVRate)] HRESULT Rate ([out, retval] long *Rate); |
| [propput, id (DISPID_SVRate)] HRESULT Rate ([in] long Rate); |
| [propget, id (DISPID_SVVolume)] HRESULT Volume ([out, retval] long *Volume); |
| [propput, id (DISPID_SVVolume)] HRESULT Volume ([in] long Volume); |
| [propput, hidden, id (DISPID_SVAllowAudioOuputFormatChangesOnNextSet)] HRESULT AllowAudioOutputFormatChangesOnNextSet ([in] VARIANT_BOOL Allow); |
| [propget, hidden, id (DISPID_SVAllowAudioOuputFormatChangesOnNextSet)] HRESULT AllowAudioOutputFormatChangesOnNextSet ([out, retval] VARIANT_BOOL *Allow); |
| [propget, id (DISPID_SVEventInterests)] HRESULT EventInterests ([out, retval] SpeechVoiceEvents *EventInterestFlags); |
| [propput, id (DISPID_SVEventInterests)] HRESULT EventInterests ([in] SpeechVoiceEvents EventInterestFlags); |
| [propput, id (DISPID_SVPriority)] HRESULT Priority ([in] SpeechVoicePriority Priority); |
| [propget, id (DISPID_SVPriority)] HRESULT Priority ([out, retval] SpeechVoicePriority *Priority); |
| [propput, id (DISPID_SVAlertBoundary)] HRESULT AlertBoundary ([in] SpeechVoiceEvents Boundary); |
| [propget, id (DISPID_SVAlertBoundary)] HRESULT AlertBoundary ([out, retval] SpeechVoiceEvents *Boundary); |
| [propput, id (DISPID_SVSyncronousSpeakTimeout)] HRESULT SynchronousSpeakTimeout ([in] long msTimeout); |
| [propget, id (DISPID_SVSyncronousSpeakTimeout)] HRESULT SynchronousSpeakTimeout ([out, retval] long *msTimeout); |
| [id (DISPID_SVSpeak)] HRESULT Speak ([in] BSTR Text,[in, defaultvalue (SPF_DEFAULT)] SpeechVoiceSpeakFlags Flags,[out, retval]long *StreamNumber); |
| [id (DISPID_SVSpeakStream)] HRESULT SpeakStream ([in] ISpeechBaseStream *Stream,[in, defaultvalue (SPF_DEFAULT)] SpeechVoiceSpeakFlags Flags,[out, retval]long *StreamNumber); |
| [id (DISPID_SVPause)] HRESULT Pause (void); |
| [id (DISPID_SVResume)] HRESULT Resume (void); |
| [id (DISPID_SVSkip)] HRESULT Skip ([in]const BSTR Type,[in]long NumItems,[out, retval]long *NumSkipped); |
| [id (DISPID_SVGetVoices)] HRESULT GetVoices ([in, defaultvalue (L"")]BSTR RequiredAttributes,[in, defaultvalue (L"")]BSTR OptionalAttributes,[out, retval]ISpeechObjectTokens **ObjectTokens); |
| [id (DISPID_SVGetAudioOutputs)] HRESULT GetAudioOutputs ([in, defaultvalue (L"")]BSTR RequiredAttributes,[in, defaultvalue (L"")]BSTR OptionalAttributes,[out, retval]ISpeechObjectTokens **ObjectTokens); |
| [id (DISPID_SVWaitUntilDone)] HRESULT WaitUntilDone ([in]long msTimeout,[out, retval]VARIANT_BOOL *Done); |
| [hidden, id (DISPID_SVSpeakCompleteEvent)] HRESULT SpeakCompleteEvent ([out, retval]long *Handle); |
| [id (DISPID_SVIsUISupported)] HRESULT IsUISupported ([in]const BSTR TypeOfUI,[in, defaultvalue (NULL)]const VARIANT *ExtraData,[out, retval] VARIANT_BOOL *Supported); |
| [id (DISPID_SVDisplayUI)] HRESULT DisplayUI ([in]long hWndParent,[in]BSTR Title,[in]const BSTR TypeOfUI,[in, defaultvalue (NULL)]const VARIANT *ExtraData); |
| }; |
| |
| [object, uuid (8be47b07-57f6-11d2-9eee-00c04f797396), dual, pointer_default (unique)] |
| interface ISpeechVoiceStatus : IDispatch { |
| [propget, id (DISPID_SVSCurrentStreamNumber)] HRESULT CurrentStreamNumber ([out, retval] long *StreamNumber); |
| [propget, id (DISPID_SVSLastStreamNumberQueued)] HRESULT LastStreamNumberQueued ([out, retval] long *StreamNumber); |
| [propget, id (DISPID_SVSLastResult)] HRESULT LastHResult ([out, retval]long *HResult); |
| [propget, id (DISPID_SVSRunningState)] HRESULT RunningState ([out, retval] SpeechRunState *State); |
| [propget, id (DISPID_SVSInputWordPosition)] HRESULT InputWordPosition ([out, retval] long *Position); |
| [propget, id (DISPID_SVSInputWordLength)] HRESULT InputWordLength ([out, retval] long *Length); |
| [propget, id (DISPID_SVSInputSentencePosition)] HRESULT InputSentencePosition ([out, retval] long *Position); |
| [propget, id (DISPID_SVSInputSentenceLength)] HRESULT InputSentenceLength ([out, retval] long *Length); |
| [propget, id (DISPID_SVSLastBookmark)] HRESULT LastBookmark ([out, retval] BSTR *Bookmark); |
| [propget, id (DISPID_SVSLastBookmarkId), hidden] HRESULT LastBookmarkId ([out, retval] long *BookmarkId); |
| [propget, id (DISPID_SVSPhonemeId)] HRESULT PhonemeId ([out, retval] short *PhoneId); |
| [propget, id (DISPID_SVSVisemeId)] HRESULT VisemeId ([out, retval] short *VisemeId); |
| }; |
| |
| typedef 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, |
| } SpeechVisemeType; |
| |
| typedef enum SpeechVisemeFeature { |
| SVF_None = 0, |
| SVF_Stressed = SPVFEATURE_STRESSED, |
| SVF_Emphasis = SPVFEATURE_EMPHASIS |
| } SpeechVisemeFeature; |
| |
| typedef [hidden] enum DISPID_SpeechVoiceEvent { |
| DISPID_SVEStreamStart = 1, |
| DISPID_SVEStreamEnd, |
| DISPID_SVEVoiceChange, |
| DISPID_SVEBookmark, |
| DISPID_SVEWord, |
| DISPID_SVEPhoneme, |
| DISPID_SVESentenceBoundary, |
| DISPID_SVEViseme, |
| DISPID_SVEAudioLevel, |
| DISPID_SVEEnginePrivate |
| } DISPID_SpeechVoiceEvent; |
| |
| typedef [hidden] 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 |
| } DISPID_SpeechRecognizer; |
| |
| typedef enum SpeechRecognizerState { |
| SRSInactive = SPRST_INACTIVE, |
| SRSActive = SPRST_ACTIVE, |
| SRSActiveAlways = SPRST_ACTIVE_ALWAYS, |
| SRSInactiveWithPurge = SPRST_INACTIVE_WITH_PURGE, |
| } SpeechRecognizerState; |
| |
| typedef 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 |
| } SpeechDisplayAttributes; |
| |
| typedef enum SpeechFormatType { |
| SFTInput = SPWF_INPUT, |
| SFTSREngine = SPWF_SRENGINE |
| } SpeechFormatType; |
| |
| typedef [hidden] enum DISPID_SpeechRecognizerStatus { |
| DISPID_SRSAudioStatus = 1, |
| DISPID_SRSCurrentStreamPosition, |
| DISPID_SRSCurrentStreamNumber, |
| DISPID_SRSNumberOfActiveRules, |
| DISPID_SRSClsidEngine, |
| DISPID_SRSSupportedLanguages |
| } DISPID_SpeechRecognizerStatus; |
| |
| typedef [hidden] 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 |
| } DISPID_SpeechRecoContext; |
| |
| typedef enum SpeechRetainedAudioOptions { |
| SRAONone = SPAO_NONE, |
| SRAORetainAudio = SPAO_RETAIN_AUDIO |
| } SpeechRetainedAudioOptions; |
| |
| typedef enum SpeechBookmarkOptions { |
| SBONone = SPBO_NONE, |
| SBOPause = SPBO_PAUSE |
| } SpeechBookmarkOptions; |
| |
| typedef enum SpeechInterference { |
| SINone = SPINTERFERENCE_NONE, |
| SINoise = SPINTERFERENCE_NOISE, |
| SINoSignal = SPINTERFERENCE_NOSIGNAL, |
| SITooLoud = SPINTERFERENCE_TOOLOUD, |
| SITooQuiet = SPINTERFERENCE_TOOQUIET, |
| SITooFast = SPINTERFERENCE_TOOFAST, |
| SITooSlow = SPINTERFERENCE_TOOSLOW |
| } SpeechInterference; |
| |
| typedef enum SpeechRecoEvents { |
| SREStreamEnd = 0x1, |
| SRESoundStart = 0x2, |
| SRESoundEnd = 0x4, |
| SREPhraseStart = 0x8, |
| SRERecognition = 0x10, |
| SREHypothesis = 0x20, |
| SREBookmark = 0x40, |
| SREPropertyNumChange = 0x80, |
| SREPropertyStringChange = 0x100, |
| SREFalseRecognition = 0x200, |
| SREInterference = 0x400, |
| SRERequestUI = 0x800, |
| SREStateChange = 0x1000, |
| SREAdaptation = 0x2000, |
| SREStreamStart = 0x4000, |
| SRERecoOtherContext = 0x8000, |
| SREAudioLevel = 0x10000, |
| SREPrivate = 0x40000, |
| SREAllEvents = 0x5ffff |
| } SpeechRecoEvents; |
| |
| typedef enum SpeechRecoContextState { |
| SRCS_Disabled = SPCS_DISABLED, |
| SRCS_Enabled = SPCS_ENABLED |
| } SpeechRecoContextState; |
| |
| typedef [hidden] 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 |
| } DISPIDSPRG; |
| |
| typedef enum SpeechLoadOption { |
| SLOStatic = SPLO_STATIC, |
| SLODynamic = SPLO_DYNAMIC |
| } SpeechLoadOption; |
| |
| typedef enum SpeechWordPronounceable { |
| SWPUnknownWordUnpronounceable = SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE, |
| SWPUnknownWordPronounceable = SPWP_UNKNOWN_WORD_PRONOUNCEABLE, |
| SWPKnownWordPronounceable = SPWP_KNOWN_WORD_PRONOUNCEABLE |
| } SpeechWordPronounceable; |
| |
| typedef enum SpeechGrammarState { |
| SGSEnabled = SPGS_ENABLED, |
| SGSDisabled = SPGS_DISABLED, |
| SGSExclusive = SPGS_EXCLUSIVE, |
| } SpeechGrammarState; |
| |
| typedef enum SpeechRuleState { |
| SGDSInactive = SPRS_INACTIVE, |
| SGDSActive = SPRS_ACTIVE, |
| SGDSActiveWithAutoPause = SPRS_ACTIVE_WITH_AUTO_PAUSE, |
| #if _SAPI_BLD_ >= 0x053 |
| SGDSActiveUserDelimited = SPRS_ACTIVE_USER_DELIMITED |
| #endif |
| } SpeechRuleState; |
| |
| typedef enum SpeechRuleAttributes { |
| SRATopLevel = SPRAF_TopLevel, |
| SRADefaultToActive = SPRAF_Active, |
| SRAExport = SPRAF_Export, |
| SRAImport = SPRAF_Import, |
| SRAInterpreter = SPRAF_Interpreter, |
| SRADynamic = SPRAF_Dynamic, |
| #if _SAPI_BLD_ >= 0x053 |
| SRARoot = SPRAF_Root |
| #endif |
| } SpeechRuleAttributes; |
| |
| typedef enum SpeechGrammarWordType { |
| SGDisplay = SPWT_DISPLAY, |
| SGLexical = SPWT_LEXICAL, |
| SGPronounciation = SPWT_PRONUNCIATION, |
| #if _SAPI_BLD_ >= 0x053 |
| SGLexicalNoSpecialChars = SPWT_LEXICAL_NO_SPECIAL_CHARS |
| #endif |
| } SpeechGrammarWordType; |
| |
| typedef [hidden] 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 |
| } DISPID_SpeechRecoContextEvents; |
| |
| typedef enum SpeechRecognitionType { |
| SRTStandard = 0, |
| SRTAutopause = SPREF_AutoPause, |
| SRTEmulated = SPREF_Emulated |
| #if _SAPI_BLD_ >= 0x053 |
| , |
| SRTSMLTimeout = SPREF_SMLTimeout, |
| SRTExtendableParse = SPREF_ExtendableParse, |
| SRTReSent = SPREF_ReSent |
| #endif |
| } SpeechRecognitionType; |
| |
| typedef [hidden] enum DISPID_SpeechGrammarRule { |
| DISPID_SGRAttributes = 1, |
| DISPID_SGRInitialState, |
| DISPID_SGRName, |
| DISPID_SGRId, |
| DISPID_SGRClear, |
| DISPID_SGRAddResource, |
| DISPID_SGRAddState |
| } DISPID_SpeechGrammarRule; |
| |
| typedef [hidden] enum DISPID_SpeechGrammarRules { |
| DISPID_SGRsCount = 1, |
| DISPID_SGRsDynamic, |
| DISPID_SGRsAdd, |
| DISPID_SGRsCommit, |
| DISPID_SGRsCommitAndSave, |
| DISPID_SGRsFindRule, |
| DISPID_SGRsItem = DISPID_VALUE, |
| DISPID_SGRs_NewEnum = DISPID_NEWENUM |
| } DISPID_SpeechGrammarRules; |
| |
| typedef [hidden] enum DISPID_SpeechGrammarRuleState { |
| DISPID_SGRSRule = 1, |
| DISPID_SGRSTransitions, |
| DISPID_SGRSAddWordTransition, |
| DISPID_SGRSAddRuleTransition, |
| DISPID_SGRSAddSpecialTransition |
| } DISPID_SpeechGrammarRuleState; |
| |
| typedef enum SpeechSpecialTransitionType { |
| SSTTWildcard = 1, |
| SSTTDictation, |
| SSTTTextBuffer |
| } SpeechSpecialTransitionType; |
| |
| typedef [hidden] enum DISPID_SpeechGrammarRuleStateTransitions { |
| DISPID_SGRSTsCount = 1, |
| DISPID_SGRSTsItem = DISPID_VALUE, |
| DISPID_SGRSTs_NewEnum = DISPID_NEWENUM |
| } DISPID_SpeechGrammarRuleStateTransitions; |
| |
| typedef [hidden] enum DISPID_SpeechGrammarRuleStateTransition { |
| DISPID_SGRSTType = 1, |
| DISPID_SGRSTText, |
| DISPID_SGRSTRule, |
| DISPID_SGRSTWeight, |
| DISPID_SGRSTPropertyName, |
| DISPID_SGRSTPropertyId, |
| DISPID_SGRSTPropertyValue, |
| DISPID_SGRSTNextState |
| } DISPID_SpeechGrammarRuleStateTransition; |
| |
| typedef enum SpeechGrammarRuleStateTransitionType { |
| SGRSTTEpsilon = 0, |
| SGRSTTWord, |
| SGRSTTRule, |
| SGRSTTDictation, |
| SGRSTTWildcard, |
| SGRSTTTextBuffer |
| } SpeechGrammarRuleStateTransitionType; |
| |
| typedef [hidden] enum DISPIDSPTSI { |
| DISPIDSPTSI_ActiveOffset = 1, |
| DISPIDSPTSI_ActiveLength, |
| DISPIDSPTSI_SelectionOffset, |
| DISPIDSPTSI_SelectionLength |
| } DISPIDSPTSI; |
| |
| typedef [hidden] enum DISPID_SpeechRecoResult { |
| DISPID_SRRRecoContext = 1, |
| DISPID_SRRTimes, |
| DISPID_SRRAudioFormat, |
| DISPID_SRRPhraseInfo, |
| DISPID_SRRAlternates, |
| DISPID_SRRAudio, |
| DISPID_SRRSpeakAudio, |
| DISPID_SRRSaveToMemory, |
| DISPID_SRRDiscardResultInfo |
| } DISPID_SpeechRecoResult; |
| |
| typedef 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 |
| } SpeechDiscardType; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| typedef enum SpeechEmulationCompareFlags { |
| SECFIgnoreCase = 0x1, |
| SECFIgnoreKanaType = 0x10000, |
| SECFIgnoreWidth = 0x20000, |
| SECFNoSpecialChars = 0x20000000, |
| SECFEmulateResult = 0x40000000, |
| SECFDefault = SECFIgnoreCase | SECFIgnoreKanaType | SECFIgnoreWidth |
| } SpeechEmulationCompareFlags; |
| |
| typedef [hidden] enum DISPID_SpeechXMLRecoResult { |
| DISPID_SRRGetXMLResult = DISPID_SRRDiscardResultInfo + 1, |
| DISPID_SRRGetXMLErrorInfo = DISPID_SRRGetXMLResult + 1 |
| } DISPID_SpeechXMLRecoResult; |
| |
| typedef [hidden] enum DISPID_SpeechRecoResult2 { |
| DISPID_SRRSetTextFeedback = DISPID_SRRGetXMLErrorInfo + 1 |
| } DISPID_SpeechRecoResult2; |
| #endif |
| |
| typedef [hidden] enum DISPID_SpeechPhraseBuilder { |
| DISPID_SPPBRestorePhraseFromMemory = 1 |
| } DISPID_SpeechPhraseBuilder; |
| |
| typedef [hidden] enum DISPID_SpeechRecoResultTimes { |
| DISPID_SRRTStreamTime = 1, |
| DISPID_SRRTLength, |
| DISPID_SRRTTickCount, |
| DISPID_SRRTOffsetFromStart |
| } DISPID_SpeechRecoResultTimes; |
| |
| typedef [hidden] enum DISPID_SpeechPhraseAlternate { |
| DISPID_SPARecoResult = 1, |
| DISPID_SPAStartElementInResult, |
| DISPID_SPANumberOfElementsInResult, |
| DISPID_SPAPhraseInfo, |
| DISPID_SPACommit |
| } DISPID_SpeechPhraseAlternate; |
| |
| typedef [hidden] enum DISPID_SpeechPhraseAlternates { |
| DISPID_SPAsCount = 1, |
| DISPID_SPAsItem = DISPID_VALUE, |
| DISPID_SPAs_NewEnum = DISPID_NEWENUM |
| } DISPID_SpeechPhraseAlternates; |
| |
| typedef [hidden] 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 |
| } DISPID_SpeechPhraseInfo; |
| |
| typedef [hidden] 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 |
| } DISPID_SpeechPhraseElement; |
| |
| typedef enum SpeechEngineConfidence { |
| SECLowConfidence = -1, |
| SECNormalConfidence = 0, |
| SECHighConfidence = 1 |
| } SpeechEngineConfidence; |
| |
| typedef [hidden] enum DISPID_SpeechPhraseElements { |
| DISPID_SPEsCount = 1, |
| DISPID_SPEsItem = DISPID_VALUE, |
| DISPID_SPEs_NewEnum = DISPID_NEWENUM |
| } DISPID_SpeechPhraseElements; |
| |
| typedef [hidden] enum DISPID_SpeechPhraseReplacement { |
| DISPID_SPRDisplayAttributes = 1, |
| DISPID_SPRText, |
| DISPID_SPRFirstElement, |
| DISPID_SPRNumberOfElements |
| } DISPID_SpeechPhraseReplacement; |
| |
| typedef [hidden] enum DISPID_SpeechPhraseReplacements { |
| DISPID_SPRsCount = 1, |
| DISPID_SPRsItem = DISPID_VALUE, |
| DISPID_SPRs_NewEnum = DISPID_NEWENUM |
| } DISPID_SpeechPhraseReplacements; |
| |
| typedef [hidden] enum DISPID_SpeechPhraseProperty { |
| DISPID_SPPName = 1, |
| DISPID_SPPId, |
| DISPID_SPPValue, |
| DISPID_SPPFirstElement, |
| DISPID_SPPNumberOfElements, |
| DISPID_SPPEngineConfidence, |
| DISPID_SPPConfidence, |
| DISPID_SPPParent, |
| DISPID_SPPChildren |
| } DISPID_SpeechPhraseProperty; |
| |
| typedef [hidden] enum DISPID_SpeechPhraseProperties { |
| DISPID_SPPsCount = 1, |
| DISPID_SPPsItem = DISPID_VALUE, |
| DISPID_SPPs_NewEnum = DISPID_NEWENUM |
| } DISPID_SpeechPhraseProperties; |
| |
| typedef [hidden] enum DISPID_SpeechPhraseRule { |
| DISPID_SPRuleName = 1, |
| DISPID_SPRuleId, |
| DISPID_SPRuleFirstElement, |
| DISPID_SPRuleNumberOfElements, |
| DISPID_SPRuleParent, |
| DISPID_SPRuleChildren, |
| DISPID_SPRuleConfidence, |
| DISPID_SPRuleEngineConfidence |
| } DISPID_SpeechPhraseRule; |
| |
| typedef [hidden] enum DISPID_SpeechPhraseRules { |
| DISPID_SPRulesCount = 1, |
| DISPID_SPRulesItem = DISPID_VALUE, |
| DISPID_SPRules_NewEnum = DISPID_NEWENUM |
| } DISPID_SpeechPhraseRules; |
| |
| typedef [hidden] enum DISPID_SpeechLexicon { |
| DISPID_SLGenerationId = 1, |
| DISPID_SLGetWords, |
| DISPID_SLAddPronunciation, |
| DISPID_SLAddPronunciationByPhoneIds, |
| DISPID_SLRemovePronunciation, |
| DISPID_SLRemovePronunciationByPhoneIds, |
| DISPID_SLGetPronunciations, |
| DISPID_SLGetGenerationChange |
| } DISPID_SpeechLexicon; |
| |
| typedef enum SpeechLexiconType { |
| SLTUser = eLEXTYPE_USER, |
| SLTApp = eLEXTYPE_APP |
| } SpeechLexiconType; |
| |
| typedef enum SpeechPartOfSpeech { |
| SPSNotOverriden = SPPS_NotOverriden, |
| SPSUnknown = SPPS_Unknown, |
| SPSNoun = SPPS_Noun, |
| SPSVerb = SPPS_Verb, |
| SPSModifier = SPPS_Modifier, |
| SPSFunction = SPPS_Function, |
| SPSInterjection = SPPS_Interjection, |
| #if _SAPI_BLD_ >= 0x53 |
| SPSLMA = SPPS_LMA, |
| SPSSuppressWord = SPPS_SuppressWord |
| #endif |
| } SpeechPartOfSpeech; |
| |
| typedef [hidden] enum DISPID_SpeechLexiconWords { |
| DISPID_SLWsCount = 1, |
| DISPID_SLWsItem = DISPID_VALUE, |
| DISPID_SLWs_NewEnum = DISPID_NEWENUM |
| } DISPID_SpeechLexiconWords; |
| |
| typedef enum SpeechWordType { |
| SWTAdded = eWORDTYPE_ADDED, |
| SWTDeleted = eWORDTYPE_DELETED |
| } SpeechWordType; |
| |
| typedef [hidden] enum DISPID_SpeechLexiconWord { |
| DISPID_SLWLangId = 1, |
| DISPID_SLWType, |
| DISPID_SLWWord, |
| DISPID_SLWPronunciations |
| } DISPID_SpeechLexiconWord; |
| |
| typedef [hidden] enum DISPID_SpeechLexiconProns { |
| DISPID_SLPsCount = 1, |
| DISPID_SLPsItem = DISPID_VALUE, |
| DISPID_SLPs_NewEnum = DISPID_NEWENUM |
| } DISPID_SpeechLexiconProns; |
| |
| typedef [hidden] enum DISPID_SpeechLexiconPronunciation { |
| DISPID_SLPType = 1, |
| DISPID_SLPLangId, |
| DISPID_SLPPartOfSpeech, |
| DISPID_SLPPhoneIds, |
| DISPID_SLPSymbolic, |
| } DISPID_SpeechLexiconPronunciation; |
| |
| typedef [hidden] enum DISPID_SpeechPhoneConverter { |
| DISPID_SPCLangId = 1, |
| DISPID_SPCPhoneToId, |
| DISPID_SPCIdToPhone |
| } DISPID_SpeechPhoneConverter; |
| |
| [uuid (A372ACD1-3bef-4bbd-8ffb-CB3E2B416AF8)] |
| dispinterface _ISpeechVoiceEvents { |
| properties: |
| methods: |
| [id (DISPID_SVEStreamStart)] void StartStream ([in]long StreamNumber,[in]VARIANT StreamPosition); |
| [id (DISPID_SVEStreamEnd)] void EndStream ([in]long StreamNumber,[in]VARIANT StreamPosition); |
| [id (DISPID_SVEVoiceChange)] void VoiceChange ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]ISpeechObjectToken *VoiceObjectToken); |
| [id (DISPID_SVEBookmark)] void Bookmark ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]BSTR Bookmark,[in]long BookmarkId); |
| [id (DISPID_SVEWord)] void Word ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]long CharacterPosition,[in]long Length); |
| [id (DISPID_SVESentenceBoundary)] void Sentence ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]long CharacterPosition,[in]long Length); |
| [id (DISPID_SVEPhoneme)] void Phoneme ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]long Duration,[in]short NextPhoneId,[in]SpeechVisemeFeature Feature,[in]short CurrentPhoneId); |
| [id (DISPID_SVEViseme)] void Viseme ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]long Duration,[in]SpeechVisemeType NextVisemeId,[in]SpeechVisemeFeature Feature,[in]SpeechVisemeType CurrentVisemeId); |
| [id (DISPID_SVEAudioLevel)] void AudioLevel ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]long AudioLevel); |
| [id (DISPID_SVEEnginePrivate)] void EnginePrivate ([in]long StreamNumber,[in]long StreamPosition,[in]VARIANT EngineData); |
| }; |
| |
| [object, uuid (2d5f1c0c-BD75-4b08-9478-3b11fea2586c), dual, pointer_default (unique)] |
| interface ISpeechRecognizer : IDispatch { |
| [propputref, id (DISPID_SRRecognizer)] HRESULT Recognizer ([in]ISpeechObjectToken *Recognizer); |
| [propget, id (DISPID_SRRecognizer)] HRESULT Recognizer ([out, retval]ISpeechObjectToken **Recognizer); |
| [propput, hidden, id (DISPID_SRAllowAudioInputFormatChangesOnNextSet)] HRESULT AllowAudioInputFormatChangesOnNextSet ([in] VARIANT_BOOL Allow); |
| [propget, hidden, id (DISPID_SRAllowAudioInputFormatChangesOnNextSet)] HRESULT AllowAudioInputFormatChangesOnNextSet ([out, retval] VARIANT_BOOL *Allow); |
| [propputref, id (DISPID_SRAudioInput)] HRESULT AudioInput ([in, defaultvalue (0)]ISpeechObjectToken *AudioInput); |
| [propget, id (DISPID_SRAudioInput)] HRESULT AudioInput ([out, retval]ISpeechObjectToken **AudioInput); |
| [propputref, id (DISPID_SRAudioInputStream)] HRESULT AudioInputStream ([in, defaultvalue (0)]ISpeechBaseStream *AudioInputStream); |
| [propget, id (DISPID_SRAudioInputStream)] HRESULT AudioInputStream ([out, retval]ISpeechBaseStream **AudioInputStream); |
| [propget, id (DISPID_SRIsShared)] HRESULT IsShared ([out, retval]VARIANT_BOOL *Shared); |
| [propput, id (DISPID_SRState)] HRESULT State ([in] SpeechRecognizerState State); |
| [propget, id (DISPID_SRState)] HRESULT State ([out, retval] SpeechRecognizerState *State); |
| [propget, id (DISPID_SRStatus)] HRESULT Status ([out, retval]ISpeechRecognizerStatus **Status); |
| [propputref, id (DISPID_SRProfile)] HRESULT Profile ([in, defaultvalue (0)]ISpeechObjectToken *Profile); |
| [propget, id (DISPID_SRProfile)] HRESULT Profile ([out, retval]ISpeechObjectToken **Profile); |
| [id (DISPID_SREmulateRecognition)] HRESULT EmulateRecognition ([in]VARIANT TextElements,[in, defaultvalue (NULL)]VARIANT *ElementDisplayAttributes,[in, defaultvalue (0)]long LanguageId); |
| [id (DISPID_SRCreateRecoContext)] HRESULT CreateRecoContext ([out, retval]ISpeechRecoContext **NewContext); |
| [id (DISPID_SRGetFormat)] HRESULT GetFormat ([in] SpeechFormatType Type,[out, retval]ISpeechAudioFormat **Format); |
| [id (DISPID_SRSetPropertyNumber), hidden] HRESULT SetPropertyNumber ([in]const BSTR Name,[in]long Value,[out, retval]VARIANT_BOOL *Supported); |
| [id (DISPID_SRGetPropertyNumber), hidden] HRESULT GetPropertyNumber ([in]const BSTR Name,[in, out]long *Value,[out, retval]VARIANT_BOOL *Supported); |
| [id (DISPID_SRSetPropertyString), hidden] HRESULT SetPropertyString ([in]const BSTR Name,[in]const BSTR Value,[out, retval]VARIANT_BOOL *Supported); |
| [id (DISPID_SRGetPropertyString), hidden] HRESULT GetPropertyString ([in]const BSTR Name,[in, out]BSTR *Value,[out, retval]VARIANT_BOOL *Supported); |
| [id (DISPID_SRIsUISupported)] HRESULT IsUISupported ([in]const BSTR TypeOfUI,[in, defaultvalue (NULL)]const VARIANT *ExtraData,[out, retval] VARIANT_BOOL *Supported); |
| [id (DISPID_SRDisplayUI)] HRESULT DisplayUI ([in]long hWndParent,[in]BSTR Title,[in]const BSTR TypeOfUI,[in, defaultvalue (NULL)]const VARIANT *ExtraData); |
| [id (DISPID_SRGetRecognizers)] HRESULT GetRecognizers ([in, defaultvalue (L"")]BSTR RequiredAttributes,[in, defaultvalue (L"")]BSTR OptionalAttributes,[out, retval]ISpeechObjectTokens **ObjectTokens); |
| [id (DISPID_SVGetAudioInputs)] HRESULT GetAudioInputs ([in, defaultvalue (L"")]BSTR RequiredAttributes,[in, defaultvalue (L"")]BSTR OptionalAttributes,[out, retval]ISpeechObjectTokens **ObjectTokens); |
| [id (DISPID_SVGetProfiles)] HRESULT GetProfiles ([in, defaultvalue (L"")]BSTR RequiredAttributes,[in, defaultvalue (L"")]BSTR OptionalAttributes,[out, retval]ISpeechObjectTokens **ObjectTokens); |
| }; |
| |
| [object, uuid (BFF9E781-53ec-484e-BB8A-0e1b5551e35c), dual, pointer_default (unique)] |
| interface ISpeechRecognizerStatus : IDispatch { |
| [propget, id (DISPID_SRSAudioStatus)] HRESULT AudioStatus ([out, retval]ISpeechAudioStatus **AudioStatus); |
| [propget, id (DISPID_SRSCurrentStreamPosition)] HRESULT CurrentStreamPosition ([out, retval]VARIANT *pCurrentStreamPos); |
| [propget, id (DISPID_SRSCurrentStreamNumber)] HRESULT CurrentStreamNumber ([out, retval]long *StreamNumber); |
| [propget, id (DISPID_SRSNumberOfActiveRules)] HRESULT NumberOfActiveRules ([out, retval]long *NumberOfActiveRules); |
| [propget, id (DISPID_SRSClsidEngine)] HRESULT ClsidEngine ([out, retval]BSTR *ClsidEngine); |
| [propget, id (DISPID_SRSSupportedLanguages)] HRESULT SupportedLanguages ([out, retval]VARIANT *SupportedLanguages); |
| }; |
| |
| [object, uuid (580aa49d-7e1e-4809-B8E2-57da806104b8), dual, pointer_default (unique)] |
| interface ISpeechRecoContext : IDispatch { |
| [propget, id (DISPID_SRCRecognizer)] HRESULT Recognizer ([out, retval]ISpeechRecognizer **Recognizer); |
| [propget, id (DISPID_SRCAudioInInterferenceStatus)] HRESULT AudioInputInterferenceStatus ([out, retval]SpeechInterference *Interference); |
| [propget, id (DISPID_SRCRequestedUIType)] HRESULT RequestedUIType ([out, retval]BSTR *UIType); |
| [propputref, id (DISPID_SRCVoice)] HRESULT Voice ([in]ISpeechVoice *Voice); |
| [propget, id (DISPID_SRCVoice)] HRESULT Voice ([out, retval]ISpeechVoice **Voice); |
| [propput, hidden, id (DISPID_SRAllowVoiceFormatMatchingOnNextSet)] HRESULT AllowVoiceFormatMatchingOnNextSet ([in] VARIANT_BOOL Allow); |
| [propget, hidden, id (DISPID_SRAllowVoiceFormatMatchingOnNextSet)] HRESULT AllowVoiceFormatMatchingOnNextSet ([out, retval] VARIANT_BOOL *pAllow); |
| [propput, id (DISPID_SRCVoicePurgeEvent)] HRESULT VoicePurgeEvent ([in]SpeechRecoEvents EventInterest); |
| [propget, id (DISPID_SRCVoicePurgeEvent)] HRESULT VoicePurgeEvent ([out, retval]SpeechRecoEvents *EventInterest); |
| [propput, id (DISPID_SRCEventInterests)] HRESULT EventInterests ([in]SpeechRecoEvents EventInterest); |
| [propget, id (DISPID_SRCEventInterests)] HRESULT EventInterests ([out, retval]SpeechRecoEvents *EventInterest); |
| [propput, id (DISPID_SRCCmdMaxAlternates)] HRESULT CmdMaxAlternates ([in] long MaxAlternates); |
| [propget, id (DISPID_SRCCmdMaxAlternates)] HRESULT CmdMaxAlternates ([out, retval] long *MaxAlternates); |
| [propput, id (DISPID_SRCState)] HRESULT State ([in] SpeechRecoContextState State); |
| [propget, id (DISPID_SRCState)] HRESULT State ([out, retval] SpeechRecoContextState *State); |
| [propput, id (DISPID_SRCRetainedAudio)] HRESULT RetainedAudio ([in]SpeechRetainedAudioOptions Option); |
| [propget, id (DISPID_SRCRetainedAudio)] HRESULT RetainedAudio ([out, retval]SpeechRetainedAudioOptions *Option); |
| [propputref, id (DISPID_SRCRetainedAudioFormat)] HRESULT RetainedAudioFormat ([in] ISpeechAudioFormat *Format); |
| [propget, id (DISPID_SRCRetainedAudioFormat)] HRESULT RetainedAudioFormat ([out, retval] ISpeechAudioFormat **Format); |
| [id (DISPID_SRCPause)] HRESULT Pause (void); |
| [id (DISPID_SRCResume)] HRESULT Resume (void); |
| [id (DISPID_SRCCreateGrammar)] HRESULT CreateGrammar ([in, defaultvalue (0)]VARIANT GrammarId,[out, retval]ISpeechRecoGrammar **Grammar); |
| [id (DISPID_SRCCreateResultFromMemory)] HRESULT CreateResultFromMemory ([in]VARIANT *ResultBlock,[out, retval]ISpeechRecoResult **Result); |
| [id (DISPID_SRCBookmark)] HRESULT Bookmark ([in]SpeechBookmarkOptions Options,[in]VARIANT StreamPos,[in]VARIANT BookmarkId); |
| [id (DISPID_SRCSetAdaptationData)] HRESULT SetAdaptationData ([in]BSTR AdaptationString); |
| }; |
| |
| [object, uuid (B6D6F79F-2158-4e50-B5BC-9a9ccd852a09), dual, pointer_default (unique)] |
| interface ISpeechRecoGrammar : IDispatch { |
| [propget, id (DISPID_SRGId)] HRESULT Id ([out, retval]VARIANT *Id); |
| [propget, id (DISPID_SRGRecoContext)] HRESULT RecoContext ([out, retval] ISpeechRecoContext **RecoContext); |
| [propput, id (DISPID_SRGState)] HRESULT State ([in]SpeechGrammarState State); |
| [propget, id (DISPID_SRGState)] HRESULT State ([out, retval]SpeechGrammarState *State); |
| [propget, id (DISPID_SRGRules)] HRESULT Rules ([out, retval]ISpeechGrammarRules **Rules); |
| [id (DISPID_SRGReset)] HRESULT Reset ([in, defaultvalue (0)]SpeechLanguageId NewLanguage); |
| [id (DISPID_SRGCmdLoadFromFile)] HRESULT CmdLoadFromFile ([in]const BSTR FileName,[in, defaultvalue (SLOStatic)]SpeechLoadOption LoadOption); |
| [id (DISPID_SRGCmdLoadFromObject)] HRESULT CmdLoadFromObject ([in]const BSTR ClassId,[in]const BSTR GrammarName,[in, defaultvalue (SLOStatic)]SpeechLoadOption LoadOption); |
| [id (DISPID_SRGCmdLoadFromResource)] HRESULT CmdLoadFromResource ([in]long hModule,[in]VARIANT ResourceName,[in]VARIANT ResourceType,[in]SpeechLanguageId LanguageId,[in, defaultvalue (SLOStatic)]SpeechLoadOption LoadOption); |
| [id (DISPID_SRGCmdLoadFromMemory)] HRESULT CmdLoadFromMemory ([in] VARIANT GrammarData,[in, defaultvalue (SLOStatic)]SpeechLoadOption LoadOption); |
| [id (DISPID_SRGCmdLoadFromProprietaryGrammar)] HRESULT CmdLoadFromProprietaryGrammar ([in]const BSTR ProprietaryGuid,[in]const BSTR ProprietaryString,[in]VARIANT ProprietaryData,[in, defaultvalue (SLOStatic)]SpeechLoadOption LoadOption); |
| [id (DISPID_SRGCmdSetRuleState)] HRESULT CmdSetRuleState ([in]const BSTR Name,[in]SpeechRuleState State); |
| [id (DISPID_SRGCmdSetRuleIdState)] HRESULT CmdSetRuleIdState ([in]long RuleId,[in]SpeechRuleState State); |
| [id (DISPID_SRGDictationLoad)] HRESULT DictationLoad ([in, defaultvalue (L"")] const BSTR TopicName,[in, defaultvalue (SLOStatic)]SpeechLoadOption LoadOption); |
| [id (DISPID_SRGDictationUnload)] HRESULT DictationUnload (void); |
| [id (DISPID_SRGDictationSetState)] HRESULT DictationSetState ([in]SpeechRuleState State); |
| [id (DISPID_SRGSetWordSequenceData)] HRESULT SetWordSequenceData ([in]const BSTR Text,[in]long TextLength,[in]ISpeechTextSelectionInformation *Info); |
| [id (DISPID_SRGSetTextSelection)] HRESULT SetTextSelection ([in]ISpeechTextSelectionInformation *Info); |
| [id (DISPID_SRGIsPronounceable)] HRESULT IsPronounceable ([in]const BSTR Word,[out, retval]SpeechWordPronounceable *WordPronounceable); |
| }; |
| |
| [uuid (7b8fcb42-0e9d-4f00-A048-7b04d6179d3d)] |
| dispinterface _ISpeechRecoContextEvents { |
| properties: |
| methods: |
| [id (DISPID_SRCEStartStream)] void StartStream ([in]long StreamNumber,[in]VARIANT StreamPosition); |
| [id (DISPID_SRCEEndStream)] void EndStream ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]VARIANT_BOOL StreamReleased); |
| [id (DISPID_SRCEBookmark)] void Bookmark ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]VARIANT BookmarkId,[in]SpeechBookmarkOptions Options); |
| [id (DISPID_SRCESoundStart)] void SoundStart ([in]long StreamNumber,[in]VARIANT StreamPosition); |
| [id (DISPID_SRCESoundEnd)] void SoundEnd ([in]long StreamNumber,[in]VARIANT StreamPosition); |
| [id (DISPID_SRCEPhraseStart)] void PhraseStart ([in]long StreamNumber,[in]VARIANT StreamPosition); |
| [id (DISPID_SRCERecognition)] void Recognition ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]SpeechRecognitionType RecognitionType,[in]ISpeechRecoResult *Result); |
| [id (DISPID_SRCEHypothesis)] void Hypothesis ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]ISpeechRecoResult *Result); |
| [id (DISPID_SRCEPropertyNumberChange)] void PropertyNumberChange ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]BSTR PropertyName,[in]long NewNumberValue); |
| [id (DISPID_SRCEPropertyStringChange)] void PropertyStringChange ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]BSTR PropertyName,[in]BSTR NewStringValue); |
| [id (DISPID_SRCEFalseRecognition)] void FalseRecognition ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]ISpeechRecoResult *Result); |
| [id (DISPID_SRCEInterference)] void Interference ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]SpeechInterference Interference); |
| [id (DISPID_SRCERequestUI)] void RequestUI ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]BSTR UIType); |
| [id (DISPID_SRCERecognizerStateChange)] void RecognizerStateChange ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]SpeechRecognizerState NewState); |
| [id (DISPID_SRCEAdaptation)] void Adaptation ([in]long StreamNumber,[in]VARIANT StreamPosition); |
| [id (DISPID_SRCERecognitionForOtherContext)] void RecognitionForOtherContext ([in]long StreamNumber,[in]VARIANT StreamPosition); |
| [id (DISPID_SRCEAudioLevel)] void AudioLevel ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]long AudioLevel); |
| [id (DISPID_SRCEEnginePrivate)] void EnginePrivate ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]VARIANT EngineData); |
| }; |
| |
| [object, uuid (AFE719CF-5dd1-44f2-999c-7a399f1cfccc), dual, pointer_default (unique)] |
| interface ISpeechGrammarRule : IDispatch { |
| [propget, id (DISPID_SGRAttributes)] HRESULT Attributes ([out, retval] SpeechRuleAttributes *Attributes); |
| [propget, id (DISPID_SGRInitialState)] HRESULT InitialState ([out, retval] ISpeechGrammarRuleState **State); |
| [propget, id (DISPID_SGRName)] HRESULT Name ([out, retval] BSTR *Name); |
| [propget, id (DISPID_SGRId)] HRESULT Id ([out, retval] long *Id); |
| [id (DISPID_SGRClear)] HRESULT Clear (); |
| [id (DISPID_SGRAddResource)] HRESULT AddResource ([in]const BSTR ResourceName,[in]const BSTR ResourceValue); |
| [id (DISPID_SGRAddState)] HRESULT AddState ([out, retval] ISpeechGrammarRuleState **State); |
| }; |
| |
| [object, uuid (6ffa3b44-FC2D-40d1-8afc-32911c7f1ad1), dual, pointer_default (unique)] |
| interface ISpeechGrammarRules : IDispatch { |
| [propget, id (DISPID_SGRsCount)] HRESULT Count ([out, retval] long *Count); |
| [id (DISPID_SGRsFindRule)] HRESULT FindRule ([in]VARIANT RuleNameOrId,[out, retval]ISpeechGrammarRule **Rule); |
| [id (DISPID_SGRsItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechGrammarRule **Rule); |
| [propget, id (DISPID_SGRs_NewEnum), restricted] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT); |
| [propget, id (DISPID_SGRsDynamic)] HRESULT Dynamic ([out, retval] VARIANT_BOOL *Dynamic); |
| [id (DISPID_SGRsAdd)] HRESULT Add ([in] BSTR RuleName,[in] SpeechRuleAttributes Attributes,[in, defaultvalue (0)] long RuleId,[out, retval] ISpeechGrammarRule **Rule); |
| [id (DISPID_SGRsCommit)] HRESULT Commit (void); |
| [id (DISPID_SGRsCommitAndSave)] HRESULT CommitAndSave ([out] BSTR *ErrorText,[out, retval] VARIANT *SaveStream); |
| }; |
| |
| [object, uuid (D4286F2C-EE67-45ae-B928-28d695362eda), dual, pointer_default (unique)] |
| interface ISpeechGrammarRuleState : IDispatch { |
| [propget, id (DISPID_SGRSRule)] HRESULT Rule ([out, retval] ISpeechGrammarRule **Rule); |
| [propget, id (DISPID_SGRSTransitions)] HRESULT Transitions ([out, retval] ISpeechGrammarRuleStateTransitions **Transitions); |
| [id (DISPID_SGRSAddWordTransition)] HRESULT AddWordTransition ([in]ISpeechGrammarRuleState *DestState,[in]const BSTR Words, [in, defaultvalue (L" ")]const BSTR Separators, [in, defaultvalue (SGLexical)]SpeechGrammarWordType Type, [in, defaultvalue (L"")]const BSTR PropertyName, [in, defaultvalue (0)]long PropertyId, [in, defaultvalue (0)]VARIANT *PropertyValue, [in, defaultvalue (1)]float Weight); |
| [id (DISPID_SGRSAddRuleTransition)] HRESULT AddRuleTransition ([in]ISpeechGrammarRuleState *DestinationState,[in]ISpeechGrammarRule *Rule,[in, defaultvalue (L"")]const BSTR PropertyName,[in, defaultvalue (0)]long PropertyId,[in, defaultvalue (0)]VARIANT *PropertyValue,[in, defaultvalue (1)]float Weight); |
| [id (DISPID_SGRSAddSpecialTransition)] HRESULT AddSpecialTransition ([in]ISpeechGrammarRuleState *DestinationState,[in]SpeechSpecialTransitionType Type,[in, defaultvalue (L"")]const BSTR PropertyName,[in, defaultvalue (0)]long PropertyId,[in, defaultvalue (0)]VARIANT *PropertyValue,[in, defaultvalue (1)]float Weight); |
| }; |
| |
| [object, uuid (EABCE657-75bc-44a2-AA7F-C56476742963), dual, pointer_default (unique)] |
| interface ISpeechGrammarRuleStateTransitions : IDispatch { |
| [propget, id (DISPID_SGRSTsCount)] HRESULT Count ([out, retval] long *Count); |
| [id (DISPID_SGRSTsItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechGrammarRuleStateTransition **Transition); |
| [propget, restricted, id (DISPID_SGRSTs_NewEnum)] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT); |
| }; |
| |
| [object, uuid (CAFD1DB1-41d1-4a06-9863-E2E81DA17A9A), dual, pointer_default (unique)] |
| interface ISpeechGrammarRuleStateTransition : IDispatch { |
| [propget, id (DISPID_SGRSTType)] HRESULT Type ([out, retval] SpeechGrammarRuleStateTransitionType *Type); |
| [propget, id (DISPID_SGRSTText)] HRESULT Text ([out, retval] BSTR *Text); |
| [propget, id (DISPID_SGRSTRule)] HRESULT Rule ([out, retval] ISpeechGrammarRule **Rule); |
| [propget, id (DISPID_SGRSTWeight)] HRESULT Weight ([out, retval] VARIANT *Weight); |
| [propget, id (DISPID_SGRSTPropertyName)] HRESULT PropertyName ([out, retval] BSTR *PropertyName); |
| [propget, id (DISPID_SGRSTPropertyId)] HRESULT PropertyId ([out, retval] long *PropertyId); |
| [propget, id (DISPID_SGRSTPropertyValue)] HRESULT PropertyValue ([out, retval] VARIANT *PropertyValue); |
| [propget, id (DISPID_SGRSTNextState)] HRESULT NextState ([out, retval] ISpeechGrammarRuleState **NextState); |
| }; |
| |
| [object, uuid (3b9c7e7a-6eee-4ded-9092-11657279adbe), dual, pointer_default (unique)] |
| interface ISpeechTextSelectionInformation : IDispatch { |
| [propput, id (DISPIDSPTSI_ActiveOffset)] HRESULT ActiveOffset ([in]long ActiveOffset); |
| [propget, id (DISPIDSPTSI_ActiveOffset)] HRESULT ActiveOffset ([out, retval]long *ActiveOffset); |
| [propput, id (DISPIDSPTSI_ActiveLength)] HRESULT ActiveLength ([in]long ActiveLength); |
| [propget, id (DISPIDSPTSI_ActiveLength)] HRESULT ActiveLength ([out, retval]long *ActiveLength); |
| [propput, id (DISPIDSPTSI_SelectionOffset)] HRESULT SelectionOffset ([in]long SelectionOffset); |
| [propget, id (DISPIDSPTSI_SelectionOffset)] HRESULT SelectionOffset ([out, retval]long *SelectionOffset); |
| [propput, id (DISPIDSPTSI_SelectionLength)] HRESULT SelectionLength ([in]long SelectionLength); |
| [propget, id (DISPIDSPTSI_SelectionLength)] HRESULT SelectionLength ([out, retval]long *SelectionLength); |
| }; |
| |
| [object, uuid (ED2879CF-CED9-4ee6-A534-DE0191D5468D), dual, pointer_default (unique)] |
| interface ISpeechRecoResult : IDispatch { |
| [propget, id (DISPID_SRRRecoContext)] HRESULT RecoContext ([out, retval]ISpeechRecoContext **RecoContext); |
| [propget, id (DISPID_SRRTimes)] HRESULT Times ([out, retval]ISpeechRecoResultTimes **Times); |
| [propputref, id (DISPID_SRRAudioFormat)] HRESULT AudioFormat ([in]ISpeechAudioFormat *Format); |
| [propget, id (DISPID_SRRAudioFormat)] HRESULT AudioFormat ([out, retval]ISpeechAudioFormat **Format); |
| [propget, id (DISPID_SRRPhraseInfo)] HRESULT PhraseInfo ([out, retval]ISpeechPhraseInfo **PhraseInfo); |
| [id (DISPID_SRRAlternates)] HRESULT Alternates ([in] long RequestCount,[in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[out, retval] ISpeechPhraseAlternates **Alternates); |
| [id (DISPID_SRRAudio)] HRESULT Audio ([in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[out, retval] ISpeechMemoryStream **Stream); |
| [id (DISPID_SRRSpeakAudio)] HRESULT SpeakAudio ([in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[in, defaultvalue (SPF_DEFAULT)] SpeechVoiceSpeakFlags Flags,[out, retval]long *StreamNumber); |
| [id (DISPID_SRRSaveToMemory)] HRESULT SaveToMemory ([out, retval] VARIANT *ResultBlock); |
| [id (DISPID_SRRDiscardResultInfo)] HRESULT DiscardResultInfo ([in]SpeechDiscardType ValueTypes); |
| }; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| [object, uuid (AAEC54AF-8f85-4924-944d-B79D39D72E19), dual, pointer_default (unique)] |
| interface ISpeechXMLRecoResult : ISpeechRecoResult { |
| [id (DISPID_SRRGetXMLResult)] HRESULT GetXMLResult ([in] SPXMLRESULTOPTIONS Options,[out, retval] BSTR *pResult); |
| [id (DISPID_SRRGetXMLErrorInfo)] HRESULT GetXMLErrorInfo ([out] long *LineNumber,[out]BSTR *ScriptLine,[out]BSTR *Source,[out]BSTR *Description,[out]long *ResultCode,[out, retval]VARIANT_BOOL *IsError); |
| }; |
| |
| [object, uuid (8e0a246d-D3C8-45de-8657-04290c458c3c), dual, pointer_default (unique)] |
| interface ISpeechRecoResult2: ISpeechRecoResult { |
| [id (DISPID_SRRSetTextFeedback)] HRESULT SetTextFeedback ([in]BSTR Feedback,[in]VARIANT_BOOL WasSuccessful); |
| } |
| |
| [object, uuid (6d60eb64-ACED-40a6-BBF3-4e557f71dee2), dual, hidden, pointer_default (unique)] |
| interface ISpeechRecoResultDispatch : IDispatch { |
| [propget, id (DISPID_SRRRecoContext)] HRESULT RecoContext ([out, retval]ISpeechRecoContext **RecoContext); |
| [propget, id (DISPID_SRRTimes)] HRESULT Times ([out, retval]ISpeechRecoResultTimes **Times); |
| [propputref, id (DISPID_SRRAudioFormat)] HRESULT AudioFormat ([in]ISpeechAudioFormat *Format); |
| [propget, id (DISPID_SRRAudioFormat)] HRESULT AudioFormat ([out, retval]ISpeechAudioFormat **Format); |
| [propget, id (DISPID_SRRPhraseInfo)] HRESULT PhraseInfo ([out, retval]ISpeechPhraseInfo **PhraseInfo); |
| [id (DISPID_SRRAlternates)] HRESULT Alternates ([in] long RequestCount,[in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[out, retval] ISpeechPhraseAlternates **Alternates); |
| [id (DISPID_SRRAudio)] HRESULT Audio ([in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[out, retval] ISpeechMemoryStream **Stream); |
| [id (DISPID_SRRSpeakAudio)] HRESULT SpeakAudio ([in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[in, defaultvalue (SPF_DEFAULT)] SpeechVoiceSpeakFlags Flags,[out, retval]long *StreamNumber); |
| [id (DISPID_SRRSaveToMemory)] HRESULT SaveToMemory ([out, retval] VARIANT *ResultBlock); |
| [id (DISPID_SRRDiscardResultInfo)] HRESULT DiscardResultInfo ([in]SpeechDiscardType ValueTypes); |
| [id (DISPID_SRRGetXMLResult)] HRESULT GetXMLResult ([in] SPXMLRESULTOPTIONS Options,[out, retval] BSTR *pResult); |
| [id (DISPID_SRRGetXMLErrorInfo)] HRESULT GetXMLErrorInfo ([out] long *LineNumber,[out]BSTR *ScriptLine,[out]BSTR *Source,[out]BSTR *Description,[out]HRESULT *ResultCode,[out, retval]VARIANT_BOOL *IsError); |
| [id (DISPID_SRRSetTextFeedback)] HRESULT SetTextFeedback ([in] BSTR Feedback,[in] VARIANT_BOOL WasSuccessful); |
| }; |
| #endif |
| |
| [object, uuid (3b151836-DF3A-4e0a-846c-D2ADC9334333), dual, pointer_default (unique)] |
| interface ISpeechPhraseInfoBuilder : IDispatch { |
| [id (DISPID_SPPBRestorePhraseFromMemory)] HRESULT RestorePhraseFromMemory ([in] VARIANT *PhraseInMemory,[out, retval] ISpeechPhraseInfo **PhraseInfo); |
| }; |
| |
| [object, uuid (62b3b8fb-F6E7-41be-BDCB-056b1c29efc0), dual, pointer_default (unique)] |
| interface ISpeechRecoResultTimes : IDispatch { |
| [propget, id (DISPID_SRRTStreamTime)] HRESULT StreamTime ([out, retval]VARIANT *Time); |
| [propget, id (DISPID_SRRTLength)] HRESULT Length ([out, retval]VARIANT *Length); |
| [propget, id (DISPID_SRRTTickCount)] HRESULT TickCount ([out, retval]long *TickCount); |
| [propget, id (DISPID_SRRTOffsetFromStart)] HRESULT OffsetFromStart ([out, retval]VARIANT *OffsetFromStart); |
| }; |
| |
| [object, uuid (27864a2a-2b9f-4cb8-92d3-0d2722fd1e73), dual, pointer_default (unique)] |
| interface ISpeechPhraseAlternate : IDispatch { |
| [propget, id (DISPID_SPARecoResult)] HRESULT RecoResult ([out, retval]ISpeechRecoResult **RecoResult); |
| [propget, id (DISPID_SPAStartElementInResult)] HRESULT StartElementInResult ([out, retval]long *StartElement); |
| [propget, id (DISPID_SPANumberOfElementsInResult)] HRESULT NumberOfElementsInResult ([out, retval]long *NumberOfElements); |
| [propget, id (DISPID_SPAPhraseInfo)] HRESULT PhraseInfo ([out, retval]ISpeechPhraseInfo **PhraseInfo); |
| [id (DISPID_SPACommit)] HRESULT Commit (void); |
| }; |
| |
| [object, uuid (B238B6D5-F276-4c3d-A6C1-2974801c3cc2), dual, pointer_default (unique)] |
| interface ISpeechPhraseAlternates : IDispatch { |
| [propget, id (DISPID_SPAsCount)] HRESULT Count ([out, retval] long *Count); |
| [id (DISPID_SPAsItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechPhraseAlternate **PhraseAlternate); |
| [propget, restricted, id (DISPID_SPAs_NewEnum)] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT); |
| }; |
| |
| [object, uuid (961559cf-4e67-4662-8bf0-D93F1FCD61B3), dual, pointer_default (unique)] |
| interface ISpeechPhraseInfo : IDispatch { |
| [propget, id (DISPID_SPILanguageId)] HRESULT LanguageId ([out, retval]long *LanguageId); |
| [propget, id (DISPID_SPIGrammarId)] HRESULT GrammarId ([out, retval]VARIANT *GrammarId); |
| [propget, id (DISPID_SPIStartTime)] HRESULT StartTime ([out, retval]VARIANT *StartTime); |
| [propget, id (DISPID_SPIAudioStreamPosition)] HRESULT AudioStreamPosition ([out, retval]VARIANT *AudioStreamPosition); |
| [propget, id (DISPID_SPIAudioSizeBytes)] HRESULT AudioSizeBytes ([out, retval]long *pAudioSizeBytes); |
| [propget, id (DISPID_SPIRetainedSizeBytes)] HRESULT RetainedSizeBytes ([out, retval]long *RetainedSizeBytes); |
| [propget, id (DISPID_SPIAudioSizeTime)] HRESULT AudioSizeTime ([out, retval]long *AudioSizeTime); |
| [propget, id (DISPID_SPIRule)] HRESULT Rule ([out, retval]ISpeechPhraseRule **Rule); |
| [propget, id (DISPID_SPIProperties)] HRESULT Properties ([out, retval]ISpeechPhraseProperties **Properties); |
| [propget, id (DISPID_SPIElements)] HRESULT Elements ([out, retval]ISpeechPhraseElements **Elements); |
| [propget, id (DISPID_SPIReplacements)] HRESULT Replacements ([out, retval]ISpeechPhraseReplacements **Replacements); |
| [propget, id (DISPID_SPIEngineId)] HRESULT EngineId ([out, retval]BSTR *EngineIdGuid); |
| [propget, id (DISPID_SPIEnginePrivateData)] HRESULT EnginePrivateData ([out, retval]VARIANT *PrivateData); |
| [id (DISPID_SPISaveToMemory)] HRESULT SaveToMemory ([out, retval]VARIANT *PhraseBlock); |
| [id (DISPID_SPIGetText)] HRESULT GetText ([in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[in, defaultvalue (-1)] VARIANT_BOOL UseReplacements,[out, retval]BSTR *Text); |
| [id (DISPID_SPIGetDisplayAttributes)] HRESULT GetDisplayAttributes ([in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[in, defaultvalue (-1)] VARIANT_BOOL UseReplacements,[out, retval]SpeechDisplayAttributes *DisplayAttributes); |
| }; |
| |
| [object, uuid (E6176F96-E373-4801-B223-3b62c068c0b4), dual, pointer_default (unique)] |
| interface ISpeechPhraseElement : IDispatch { |
| [propget, id (DISPID_SPEAudioTimeOffset)] HRESULT AudioTimeOffset ([out, retval]long *AudioTimeOffset); |
| [propget, id (DISPID_SPEAudioSizeTime)] HRESULT AudioSizeTime ([out, retval]long *AudioSizeTime); |
| [propget, id (DISPID_SPEAudioStreamOffset)] HRESULT AudioStreamOffset ([out, retval]long *AudioStreamOffset); |
| [propget, id (DISPID_SPEAudioSizeBytes)] HRESULT AudioSizeBytes ([out, retval]long *AudioSizeBytes); |
| [propget, id (DISPID_SPERetainedStreamOffset)] HRESULT RetainedStreamOffset ([out, retval]long *RetainedStreamOffset); |
| [propget, id (DISPID_SPERetainedSizeBytes)] HRESULT RetainedSizeBytes ([out, retval]long *RetainedSizeBytes); |
| [propget, id (DISPID_SPEDisplayText)] HRESULT DisplayText ([out, retval]BSTR *DisplayText); |
| [propget, id (DISPID_SPELexicalForm)] HRESULT LexicalForm ([out, retval]BSTR *LexicalForm); |
| [propget, id (DISPID_SPEPronunciation)] HRESULT Pronunciation ([out, retval]VARIANT *Pronunciation); |
| [propget, id (DISPID_SPEDisplayAttributes)] HRESULT DisplayAttributes ([out, retval]SpeechDisplayAttributes *DisplayAttributes); |
| [propget, id (DISPID_SPERequiredConfidence)] HRESULT RequiredConfidence ([out, retval]SpeechEngineConfidence *RequiredConfidence); |
| [propget, id (DISPID_SPEActualConfidence)] HRESULT ActualConfidence ([out, retval]SpeechEngineConfidence *ActualConfidence); |
| [propget, id (DISPID_SPEEngineConfidence)] HRESULT EngineConfidence ([out, retval]float *EngineConfidence); |
| }; |
| |
| [object, uuid (0626b328-3478-467d-A0B3-D0853B93DDA3), dual, pointer_default (unique)] |
| interface ISpeechPhraseElements : IDispatch { |
| [propget, id (DISPID_SPEsCount)] HRESULT Count ([out, retval] long *Count); |
| [id (DISPID_SPEsItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechPhraseElement **Element); |
| [propget, restricted, id (DISPID_SPEs_NewEnum)] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT); |
| }; |
| |
| [object, uuid (2890a410-53a7-4fb5-94ec-06d4998e3d02), dual, pointer_default (unique)] |
| interface ISpeechPhraseReplacement : IDispatch { |
| [propget, id (DISPID_SPRDisplayAttributes)] HRESULT DisplayAttributes ([out, retval]SpeechDisplayAttributes *DisplayAttributes); |
| [propget, id (DISPID_SPRText)] HRESULT Text ([out, retval]BSTR *Text); |
| [propget, id (DISPID_SPRFirstElement)] HRESULT FirstElement ([out, retval]long *FirstElement); |
| [propget, id (DISPID_SPRNumberOfElements)] HRESULT NumberOfElements ([out, retval]long *NumberOfElements); |
| }; |
| |
| [object, uuid (38bc662f-2257-4525-959e-2069d2596c05), dual, pointer_default (unique)] |
| interface ISpeechPhraseReplacements : IDispatch { |
| [propget, id (DISPID_SPRsCount)] HRESULT Count ([out, retval] long *Count); |
| [id (DISPID_SPRsItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechPhraseReplacement **Reps); |
| [propget, restricted, id (DISPID_SPRs_NewEnum)] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT); |
| }; |
| |
| [object, uuid (CE563D48-961e-4732-A2E1-378a42b430be), dual, pointer_default (unique)] |
| interface ISpeechPhraseProperty : IDispatch { |
| [propget, id (DISPID_SPPName)] HRESULT Name ([out, retval]BSTR *Name); |
| [propget, id (DISPID_SPPId)] HRESULT Id ([out, retval]long *Id); |
| [propget, id (DISPID_SPPValue)] HRESULT Value ([out, retval]VARIANT *Value); |
| [propget, id (DISPID_SPPFirstElement)] HRESULT FirstElement ([out, retval]long *FirstElement); |
| [propget, id (DISPID_SPPNumberOfElements)] HRESULT NumberOfElements ([out, retval]long *NumberOfElements); |
| [propget, id (DISPID_SPPEngineConfidence)] HRESULT EngineConfidence ([out, retval]float *Confidence); |
| [propget, id (DISPID_SPPConfidence)] HRESULT Confidence ([out, retval]SpeechEngineConfidence *Confidence); |
| [propget, id (DISPID_SPPParent)] HRESULT Parent ([out, retval]ISpeechPhraseProperty **ParentProperty); |
| [propget, id (DISPID_SPPChildren)] HRESULT Children ([out, retval]ISpeechPhraseProperties **Children); |
| }; |
| |
| [object, uuid (08166b47-102e-4b23-A599-BDB98DBFD1F4), dual, pointer_default (unique)] |
| interface ISpeechPhraseProperties : IDispatch { |
| [propget, id (DISPID_SPPsCount)] HRESULT Count ([out, retval] long *Count); |
| [id (DISPID_SPPsItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechPhraseProperty **Property); |
| [propget, id (DISPID_SPPs_NewEnum), restricted] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT); |
| }; |
| |
| [object, uuid (A7BFE112-A4A0-48d9-B602-C313843F6964), dual, pointer_default (unique)] |
| interface ISpeechPhraseRule : IDispatch { |
| [propget, id (DISPID_SPRuleName)] HRESULT Name ([out, retval]BSTR *Name); |
| [propget, id (DISPID_SPRuleId)] HRESULT Id ([out, retval]long *Id); |
| [propget, id (DISPID_SPRuleFirstElement)] HRESULT FirstElement ([out, retval]long *FirstElement); |
| [propget, id (DISPID_SPRuleNumberOfElements)] HRESULT NumberOfElements ([out, retval]long *NumberOfElements); |
| [propget, id (DISPID_SPRuleParent)] HRESULT Parent ([out, retval]ISpeechPhraseRule **Parent); |
| [propget, id (DISPID_SPRuleChildren)] HRESULT Children ([out, retval]ISpeechPhraseRules **Children); |
| [propget, id (DISPID_SPRuleConfidence)] HRESULT Confidence ([out, retval]SpeechEngineConfidence *ActualConfidence); |
| [propget, id (DISPID_SPRuleEngineConfidence)] HRESULT EngineConfidence ([out, retval]float *EngineConfidence); |
| }; |
| |
| [object, uuid (9047d593-01dd-4b72-81a3-E4A0CA69F407), dual, pointer_default (unique)] |
| interface ISpeechPhraseRules : IDispatch { |
| [propget, id (DISPID_SPRulesCount)] HRESULT Count ([out, retval] long *Count); |
| [id (DISPID_SPRulesItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechPhraseRule **Rule); |
| [propget, restricted, id (DISPID_SPRules_NewEnum)] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT); |
| }; |
| |
| [object, uuid (8d199862-415e-47d5-AC4F-FAA608B424E6), dual, pointer_default (unique)] |
| interface ISpeechLexiconWords : IDispatch { |
| [id (DISPID_SLWsCount), propget] HRESULT Count ([out, retval] long *Count); |
| [id (DISPID_VALUE)] HRESULT Item ([in] long Index,[out, retval]ISpeechLexiconWord **Word); |
| [id (DISPID_NEWENUM), propget, restricted] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT); |
| }; |
| |
| [object, uuid (3da7627a-C7AE-4b23-8708-638c50362c25), dual, pointer_default (unique)] |
| interface ISpeechLexicon : IDispatch { |
| [id (DISPID_SLGenerationId), propget, hidden] HRESULT GenerationId ([out, retval]long *GenerationId); |
| [id (DISPID_SLGetWords)] HRESULT GetWords ([in, defaultvalue (eLEXTYPE_USER | eLEXTYPE_APP)]SpeechLexiconType Flags,[out, defaultvalue (NULL)]long *GenerationID,[out, retval]ISpeechLexiconWords **Words); |
| [id (DISPID_SLAddPronunciation)] HRESULT AddPronunciation ([in]BSTR bstrWord,[in]SpeechLanguageId LangId,[in, defaultvalue (SPSUnknown)]SpeechPartOfSpeech PartOfSpeech,[in, defaultvalue (L"")]BSTR bstrPronunciation); |
| [hidden, id (DISPID_SLAddPronunciationByPhoneIds)] HRESULT AddPronunciationByPhoneIds ([in]BSTR bstrWord,[in]SpeechLanguageId LangId,[in, defaultvalue (SPSUnknown)]SpeechPartOfSpeech PartOfSpeech,[in, defaultvalue (NULL)]VARIANT *PhoneIds); |
| [id (DISPID_SLRemovePronunciation)] HRESULT RemovePronunciation ([in]BSTR bstrWord,[in]SpeechLanguageId LangId,[in, defaultvalue (SPSUnknown)]SpeechPartOfSpeech PartOfSpeech,[in, defaultvalue (L"")]BSTR bstrPronunciation); |
| [id (DISPID_SLRemovePronunciationByPhoneIds), hidden] HRESULT RemovePronunciationByPhoneIds ([in]BSTR bstrWord,[in]SpeechLanguageId LangId,[in, defaultvalue (SPSUnknown)]SpeechPartOfSpeech PartOfSpeech,[in, defaultvalue (NULL)]VARIANT *PhoneIds); |
| [id (DISPID_SLGetPronunciations)] HRESULT GetPronunciations ([in]BSTR bstrWord,[in, defaultvalue (0)]SpeechLanguageId LangId,[in, defaultvalue (eLEXTYPE_USER | eLEXTYPE_APP)]SpeechLexiconType TypeFlags,[out, retval]ISpeechLexiconPronunciations **ppPronunciations); |
| [id (DISPID_SLGetGenerationChange), hidden] HRESULT GetGenerationChange ([in, out]long *GenerationID,[out, retval]ISpeechLexiconWords **ppWords); |
| }; |
| |
| [object, uuid (4e5b933c-C9BE-48ed-8842-1ee51bb1d4ff), dual, pointer_default (unique)] |
| interface ISpeechLexiconWord : IDispatch { |
| [id (DISPID_SLWLangId), propget] HRESULT LangId ([out, retval]SpeechLanguageId *LangId); |
| [id (DISPID_SLWType), propget] HRESULT Type ([out, retval]SpeechWordType *WordType); |
| [id (DISPID_SLWWord), propget] HRESULT Word ([out, retval]BSTR *Word); |
| [id (DISPID_SLWPronunciations), propget] HRESULT Pronunciations ([out, retval]ISpeechLexiconPronunciations **Pronunciations); |
| }; |
| |
| [object, uuid (72829128-5682-4704-A0D4-3e2bb6f2ead3), dual, pointer_default (unique)] |
| interface ISpeechLexiconPronunciations : IDispatch { |
| [id (DISPID_SLPsCount), propget] HRESULT Count ([out, retval] long *Count); |
| [id (DISPID_VALUE)] HRESULT Item ([in] long Index,[out, retval]ISpeechLexiconPronunciation **Pronunciation); |
| [id (DISPID_NEWENUM), propget, restricted] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT); |
| }; |
| |
| [object, uuid (95252c5d-9e43-4f4a-9899-48ee73352f9f), dual, pointer_default (unique)] |
| interface ISpeechLexiconPronunciation : IDispatch { |
| [id (DISPID_SLPType), propget] HRESULT Type ([out, retval]SpeechLexiconType *LexiconType); |
| [id (DISPID_SLPLangId), propget] HRESULT LangId ([out, retval]SpeechLanguageId *LangId); |
| [id (DISPID_SLPPartOfSpeech), propget] HRESULT PartOfSpeech ([out, retval]SpeechPartOfSpeech *PartOfSpeech); |
| [id (DISPID_SLPPhoneIds), propget] HRESULT PhoneIds ([out, retval]VARIANT *PhoneIds); |
| [id (DISPID_SLPSymbolic), propget] HRESULT Symbolic ([out, retval]BSTR *Symbolic); |
| }; |
| |
| [object, uuid (C3E4F353-433f-43d6-89a1-6a62a7054c3d), dual, pointer_default (unique)] |
| interface ISpeechPhoneConverter : IDispatch { |
| [propget, id (DISPID_SPCLangId)] HRESULT LanguageId ([out, retval]SpeechLanguageId *LanguageId); |
| [propput, id (DISPID_SPCLangId)] HRESULT LanguageId ([in]SpeechLanguageId LanguageId); |
| [id (DISPID_SPCPhoneToId)] HRESULT PhoneToId ([in]const BSTR Phonemes,[out, retval]VARIANT *IdArray); |
| [id (DISPID_SPCIdToPhone)] HRESULT IdToPhone ([in]const VARIANT IdArray,[out, retval]BSTR *Phonemes); |
| } |
| |
| [uuid (E2AE5372-5d40-11d2-960e-00c04f8ee628), hidden] |
| coclass SpNotifyTranslator { |
| interface ISpNotifyTranslator; |
| } |
| |
| [uuid (A910187F-0c7a-45ac-92cc-59edafb77b53)] |
| coclass SpObjectTokenCategory { |
| [default] interface ISpeechObjectTokenCategory; |
| interface ISpObjectTokenCategory; |
| } |
| |
| [uuid (EF411752-3736-4cb4-9c8c-8ef4ccb58efe)] |
| coclass SpObjectToken { |
| [default] interface ISpeechObjectToken; |
| interface ISpObjectToken; |
| } |
| |
| [uuid (96749373-3391-11d2-9ee3-00c04f797396), hidden] |
| coclass SpResourceManager { |
| [default] interface ISpResourceManager; |
| }; |
| |
| [uuid (7013943a-E2EC-11d2-A086-00c04f8ef9b5), hidden] |
| coclass SpStreamFormatConverter { |
| [default] interface ISpStreamFormatConverter; |
| }; |
| |
| [uuid (AB1890A0-E91F-11d2-BB91-00c04f8ee6c0), hidden] |
| coclass SpMMAudioEnum { |
| interface IEnumSpObjectTokens; |
| }; |
| |
| [uuid (CF3D2E50-53f2-11d2-960c-00c04f8ee628)] |
| coclass SpMMAudioIn { |
| [default] interface ISpeechMMSysAudio; |
| interface ISpEventSource; |
| interface ISpEventSink; |
| interface ISpObjectWithToken; |
| interface ISpMMSysAudio; |
| }; |
| |
| [uuid (A8C680EB-3d32-11d2-9ee7-00c04f797396)] |
| coclass SpMMAudioOut { |
| [default] interface ISpeechMMSysAudio; |
| interface ISpEventSource; |
| interface ISpEventSink; |
| interface ISpObjectWithToken; |
| interface ISpMMSysAudio; |
| }; |
| |
| [uuid (715d9c59-4442-11d2-9605-00c04f8ee628), hidden] |
| coclass SpStream { |
| interface ISpStream; |
| }; |
| |
| [uuid (96749377-3391-11d2-9ee3-00c04f797396)] |
| coclass SpVoice { |
| [default] interface ISpeechVoice; |
| interface ISpVoice; |
| #if _SAPI_BLD_ >= 0x53 |
| interface ISpPhoneticAlphabetSelection; |
| #endif |
| [default, source] dispinterface _ISpeechVoiceEvents; |
| }; |
| [uuid (47206204-5eca-11d2-960f-00c04f8ee628)] |
| coclass SpSharedRecoContext { |
| [default] interface ISpeechRecoContext; |
| interface ISpRecoContext; |
| #if _SAPI_BLD_ >= 0x53 |
| interface ISpRecoContext2; |
| interface ISpPhoneticAlphabetSelection; |
| #endif |
| [default, source] dispinterface _ISpeechRecoContextEvents; |
| }; |
| |
| [uuid (41b89b6b-9399-11d2-9623-00c04f8ee628)] |
| coclass SpInprocRecognizer { |
| [default] interface ISpeechRecognizer; |
| interface ISpRecognizer; |
| #if _SAPI_BLD_ >= 0x053 |
| interface ISpRecognizer2; |
| #if _SAPI_BLD_ >= 0x54 |
| interface ISpRecognizer3; |
| #endif |
| interface ISpSerializeState; |
| #endif |
| }; |
| |
| [uuid (3bee4890-4fe9-4a37-8c1e-5e7e12791c1f)] |
| coclass SpSharedRecognizer { |
| [default] interface ISpeechRecognizer; |
| interface ISpRecognizer; |
| #if _SAPI_BLD_ >= 0x53 |
| interface ISpRecognizer2; |
| #if _SAPI_BLD_ >= 0x054 |
| interface ISpRecognizer3; |
| #endif |
| interface ISpSerializeState; |
| #endif |
| }; |
| |
| [uuid (0655e396-25d0-11d3-9c26-00c04f8ef87c)] |
| coclass SpLexicon { |
| [default] interface ISpeechLexicon; |
| interface ISpLexicon; |
| #if _SAPI_BLD_ >= 0x53 |
| interface ISpPhoneticAlphabetSelection; |
| #endif |
| }; |
| |
| [uuid (C9E37C15-DF92-4727-85d6-72e5eeb6995a)] |
| coclass SpUnCompressedLexicon { |
| [default] interface ISpeechLexicon; |
| interface ISpLexicon; |
| interface ISpObjectWithToken; |
| #if _SAPI_BLD_ >= 0x53 |
| interface ISpPhoneticAlphabetSelection; |
| #endif |
| }; |
| |
| [uuid (90903716-2f42-11d3-9c26-00c04f8ef87c), hidden] |
| coclass SpCompressedLexicon { |
| [default] interface ISpLexicon; |
| interface ISpObjectWithToken; |
| }; |
| |
| #if _SAPI_BLD_ >= 0x053 |
| [uuid (0d722f1a-9fcf-4e62-96d8-6df8f01a26aa)] |
| coclass SpShortcut { |
| interface ISpShortcut; |
| interface ISpObjectWithToken; |
| }; |
| #endif |
| |
| [uuid (9185f743-1143-4c28-86b5-BFF14F20E5C8)] |
| coclass SpPhoneConverter { |
| [default] interface ISpeechPhoneConverter; |
| interface ISpPhoneConverter; |
| #if _SAPI_BLD_ >= 0x53 |
| interface ISpPhoneticAlphabetSelection; |
| #endif |
| }; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| [uuid (4f414126-DFE3-4629-99ee-797978317ead)] |
| coclass SpPhoneticAlphabetConverter { |
| interface ISpPhoneticAlphabetConverter; |
| }; |
| #endif |
| |
| [uuid (455f24e9-7396-4a16-9715-7c0fdbe3efe3), hidden] |
| coclass SpNullPhoneConverter { |
| [default] interface ISpPhoneConverter; |
| }; |
| |
| [uuid (0f92030a-CBFD-4ab8-A164-FF5985547FF6)] |
| coclass SpTextSelectionInformation { |
| [default] interface ISpeechTextSelectionInformation; |
| }; |
| |
| [uuid (C23FC28D-C55F-4720-8b32-91f73c2bd5d1)] |
| coclass SpPhraseInfoBuilder { |
| [default] interface ISpeechPhraseInfoBuilder; |
| }; |
| |
| [uuid (9ef96870-E160-4792-820d-48cf0649e4ec)] |
| coclass SpAudioFormat { |
| [default] interface ISpeechAudioFormat; |
| }; |
| |
| [uuid (C79A574C-63be-44b9-801f-283f87f898be)] |
| coclass SpWaveFormatEx { |
| [default] interface ISpeechWaveFormatEx; |
| }; |
| |
| [uuid (73ad6842-ACE0-45e8-A4DD-8795881a2c2a)] |
| coclass SpInProcRecoContext { |
| [default] interface ISpeechRecoContext; |
| interface ISpRecoContext; |
| #if _SAPI_BLD_ >= 0x53 |
| interface ISpRecoContext2; |
| interface ISpPhoneticAlphabetSelection; |
| #endif |
| [default, source] dispinterface _ISpeechRecoContextEvents; |
| }; |
| |
| [uuid (8dbef13f-1948-4aa8-8cf0-048eebed95d8)] |
| coclass SpCustomStream { |
| [default] interface ISpeechCustomStream; |
| interface ISpStream; |
| }; |
| |
| [uuid (947812b3-2ae1-4644-BA86-9e90ded7ec91)] |
| coclass SpFileStream { |
| [default] interface ISpeechFileStream; |
| interface ISpStream; |
| }; |
| |
| [uuid (5fb7ef7d-DFF4-468a-B6B7-2fcbd188f994)] |
| coclass SpMemoryStream { |
| [default] interface ISpeechMemoryStream; |
| interface ISpStream; |
| }; |
| |
| #if _SAPI_BLD_ >= 0x53 |
| interface ISpXMLRecoResult; |
| interface ISpRecoGrammar2; |
| interface ISpeechResourceLoader; |
| #endif |
| } |