Signed-off-by: Alistair Leslie-Hughes leslie_alistair@hotmail.com --- include/Makefile.in | 1 + include/sapi.idl | 2 + include/sapiaut.idl | 2007 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 2010 insertions(+) create mode 100644 include/sapiaut.idl
diff --git a/include/Makefile.in b/include/Makefile.in index 7832d64a0e..d4676f0fdd 100644 --- a/include/Makefile.in +++ b/include/Makefile.in @@ -574,6 +574,7 @@ SOURCES = \ rtutils.h \ sal.h \ sapi.idl \ + sapiaut.idl \ sapiddk.idl \ scarderr.h \ schannel.h \ diff --git a/include/sapi.idl b/include/sapi.idl index d6f904f29a..8e591bd3a0 100644 --- a/include/sapi.idl +++ b/include/sapi.idl @@ -1025,6 +1025,8 @@ library SpeechLib { importlib("stdole2.tlb");
+ #include "sapiaut.idl" + [ uuid(a910187f-0c7a-45ac-92cc-59edafb77b53), helpstring("SpObjectTokenCategory Class"), diff --git a/include/sapiaut.idl b/include/sapiaut.idl new file mode 100644 index 0000000000..41bd32030f --- /dev/null +++ b/include/sapiaut.idl @@ -0,0 +1,2007 @@ +/* + * Copyright (C) 2019 Alistair Leslie-Hughes + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ +#if 0 +#pragma makedep install +#endif + +import "oaidl.idl"; +import "ocidl.idl"; + +interface ISpeechAudioFormat; +interface ISpeechGrammarRule; +interface ISpeechGrammarRuleState; +interface ISpeechObjectTokens; +interface ISpeechPhraseProperties; +interface ISpeechPhraseRule; +interface ISpeechRecognizer; +interface ISpeechRecoContext; +interface ISpeechRecoGrammar; +interface ISpeechRecoResult; + +typedef long SpeechLanguageId; + +typedef enum SpeechLoadOption +{ + SLOStatic = SPLO_STATIC, + SLODynamic = SPLO_DYNAMIC +} SpeechLoadOption; + +typedef enum SpeechRuleState +{ + SGDSInactive = SPRS_INACTIVE, + SGDSActive = SPRS_ACTIVE, + SGDSActiveWithAutoPause = SPRS_ACTIVE_WITH_AUTO_PAUSE, + SGDSActiveUserDelimited = SPRS_ACTIVE_USER_DELIMITED +} SpeechRuleState; + +typedef enum SpeechTokenShellFolder +{ + STSF_AppData = 0x001a, + STSF_LocalAppData = 0x001c, + STSF_CommonAppData = 0x0023, + STSF_FlagCreate = 0x8000 +} SpeechTokenShellFolder; + +typedef enum SpeechEngineConfidence +{ + SECLowConfidence = -1, + SECNormalConfidence = 0, + SECHighConfidence = 1 +} SpeechEngineConfidence; + +typedef enum SpeechAudioState +{ + SASClosed = SPAS_CLOSED, + SASStop = SPAS_STOP, + SASPause = SPAS_PAUSE, + SASRun = SPAS_RUN +} SpeechAudioState; + +typedef enum SpeechRunState +{ + SRSEDone = SPRS_DONE, + SRSEIsSpeaking = SPRS_IS_SPEAKING +} SpeechRunState; + +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; + +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 enum SpeechGrammarState +{ + SGSEnabled = SPGS_ENABLED, + SGSDisabled = SPGS_DISABLED, + SGSExclusive = SPGS_EXCLUSIVE, +} SpeechGrammarState; + +typedef enum SpeechRuleAttributes +{ + SRATopLevel = SPRAF_TopLevel, + SRADefaultToActive = SPRAF_Active, + SRAExport = SPRAF_Export, + SRAImport = SPRAF_Import, + SRAInterpreter = SPRAF_Interpreter, + SRADynamic = SPRAF_Dynamic, + SRARoot = SPRAF_Root +} SpeechRuleAttributes; + +typedef enum SpeechWordPronounceable +{ + SWPUnknownWordUnpronounceable = SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE, + SWPUnknownWordPronounceable = SPWP_UNKNOWN_WORD_PRONOUNCEABLE, + SWPKnownWordPronounceable = SPWP_KNOWN_WORD_PRONOUNCEABLE +} SpeechWordPronounceable; + +typedef enum SpeechSpecialTransitionType +{ + SSTTWildcard = 1, + SSTTDictation, + SSTTTextBuffer +} SpeechSpecialTransitionType; + +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 [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 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 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 SpeechVoiceEvents +{ + SVEStartInputStream = (1L << 1), + SVEEndInputStream = (1L << 2), + SVEVoiceChange = (1L << 3), + SVEBookmark = (1L << 4), + SVEWordBoundary = (1L << 5), + SVEPhoneme = (1L << 6), + SVESentenceBoundary = (1L << 7), + SVEViseme = (1L << 8), + SVEAudioLevel = (1L << 9), + SVEPrivate = (1L << 15), + SVEAllEvents = 0x083FE +} SpeechVoiceEvents; + +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, + SVSFParseSapi = SPF_PARSE_SAPI, + SVSFParseSsml = SPF_PARSE_SSML, + SVSFParseAutodetect = SPF_PARSE_AUTODETECT, + SVSFNLPMask = SPF_NLP_MASK, + SVSFParseMask = SPF_PARSE_MASK, + SVSFVoiceMask = SPF_VOICE_MASK, + SVSFUnusedFlags = SPF_UNUSED_FLAGS, +} SpeechVoiceSpeakFlags; + +typedef enum SpeechGrammarWordType +{ + SGDisplay = SPWT_DISPLAY, + SGLexical = SPWT_LEXICAL, + SGPronounciation = SPWT_PRONUNCIATION, + SGLexicalNoSpecialChars = SPWT_LEXICAL_NO_SPECIAL_CHARS +} SpeechGrammarWordType; + +typedef enum SpeechRecoEvents +{ + SREStreamEnd = (1L << 0), + SRESoundStart = (1L << 1), + SRESoundEnd = (1L << 2), + SREPhraseStart = (1L << 3), + SRERecognition = (1L << 4), + SREHypothesis = (1L << 5), + SREBookmark = (1L << 6), + SREPropertyNumChange = (1L << 7), + SREPropertyStringChange = (1L << 8), + SREFalseRecognition = (1L << 9), + SREInterference = (1L << 10), + SRERequestUI = (1L << 11), + SREStateChange = (1L << 12), + SREAdaptation = (1L << 13), + SREStreamStart = (1L << 14), + SRERecoOtherContext = (1L << 15), + SREAudioLevel = (1L << 16), + SREPrivate = (1L << 18), + SREAllEvents = 0x5FFFF +} SpeechRecoEvents; + +typedef enum SpeechRecoContextState +{ + SRCS_Disabled = SPCS_DISABLED, + SRCS_Enabled = SPCS_ENABLED +} SpeechRecoContextState; + +typedef enum SpeechRetainedAudioOptions +{ + SRAONone = SPAO_NONE, + SRAORetainAudio = SPAO_RETAIN_AUDIO +} SpeechRetainedAudioOptions; + +typedef enum SpeechVoicePriority +{ + SVPNormal = SPVPRI_NORMAL, + SVPAlert = SPVPRI_ALERT, + SVPOver = SPVPRI_OVER +} SpeechVoicePriority; + +[ + object, + uuid(ce17c09b-4efa-44d5-a4c9-59d9585ab0cd), + dual, + pointer_default(unique) +] +interface ISpeechDataKey : IDispatch +{ + [id(DISPID_SDKSetBinaryValue)] + HRESULT SetBinaryValue([in] const BSTR name, [in] VARIANT value); + + [id(DISPID_SDKGetBinaryValue)] + HRESULT GetBinaryValue([in] const BSTR name, [out,retval] VARIANT *value); + + [id(DISPID_SDKSetStringValue)] + HRESULT SetStringValue([in] const BSTR name, [in]const BSTR value); + + [id(DISPID_SDKGetStringValue)] + HRESULT GetStringValue([in] const BSTR name, [out,retval] BSTR* value); + + [id(DISPID_SDKSetLongValue)] + HRESULT SetLongValue([in] const BSTR name, [in] long value); + + [id(DISPID_SDKGetlongValue)] + HRESULT GetLongValue([in] const BSTR name, [out,retval] long *value); + + [id(DISPID_SDKOpenKey)] + HRESULT OpenKey( [in] const BSTR name, [out,retval] ISpeechDataKey **key); + + [id(DISPID_SDKCreateKey)] + HRESULT CreateKey([in] const BSTR name, [out,retval] ISpeechDataKey **key); + + [id(DISPID_SDKDeleteKey)] + HRESULT DeleteKey([in] const BSTR name); + + [id(DISPID_SDKDeleteValue)] + HRESULT DeleteValue([in] const BSTR name); + + [id(DISPID_SDKEnumKeys)] + HRESULT EnumKeys([in] long index, [out,retval] BSTR *name); + + [id(DISPID_SDKEnumValues)] + HRESULT EnumValues([in] long Index, [out,retval] BSTR *value); +}; + +typedef enum SpeechDataKeyLocation +{ + SDKLDefaultLocation = 0, + SDKLCurrentUser = 1, + SDKLLocalMachine = 2, + SDKLCurrentConfig = 5 +} SpeechDataKeyLocation; + +typedef enum SpeechBookmarkOptions +{ + SBONone = SPBO_NONE, + SBOPause = SPBO_PAUSE +} SpeechBookmarkOptions; + +#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 [hidden] enum DISPID_SpeechObjectTokenCategory +{ + DISPID_SOTCId = 1, + DISPID_SOTCDefault, + DISPID_SOTCSetId, + DISPID_SOTCGetDataKey, + DISPID_SOTCEnumerateTokens, +} DISPID_SpeechObjectTokenCategory; + +[ + 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 token); + [propget, id(DISPID_SOTCDefault)] + HRESULT Default([out, retval] BSTR *token); + + [id(DISPID_SOTCSetId)] + HRESULT SetId([in] const BSTR id, [in, defaultvalue(0)] VARIANT_BOOL created); + + [hidden, id(DISPID_SOTCGetDataKey)] + HRESULT GetDataKey([in, defaultvalue(SDKLDefaultLocation)] SpeechDataKeyLocation location, + [out, retval] ISpeechDataKey **key); + + [id(DISPID_SOTCEnumerateTokens)] + HRESULT EnumerateTokens([in, defaultvalue("")] BSTR required, + [in, defaultvalue("")] BSTR optional, + [out, retval] ISpeechObjectTokens **tokens); +}; + +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; + +[ + object, + uuid(c74a3adc-b727-4500-a84a-b526721c8b8c), + dual, + pointer_default(unique) +] +interface ISpeechObjectToken : IDispatch +{ + [propget, id(DISPID_SOTId)] + HRESULT Id([out,retval] BSTR *object); + + [propget, id(DISPID_SOTDataKey), hidden] + HRESULT DataKey([out,retval] ISpeechDataKey **key); + + [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("")] BSTR category, [in, defaultvalue(0)] VARIANT_BOOL create); + + [id(DISPID_SOTGetAttribute)] + HRESULT GetAttribute([in] BSTR name, [out, retval] BSTR* value); + + [id(DISPID_SOTCreateInstance)] + HRESULT CreateInstance([in, defaultvalue(NULL)] IUnknown *outer, [in, defaultvalue(STCAll)] SpeechTokenContext spcontext, + [out, retval] IUnknown **object); + + [hidden, id(DISPID_SOTRemove)] + HRESULT Remove([in] BSTR clsid); + + [hidden, id(DISPID_SOTGetStorageFileName)] + HRESULT GetStorageFileName([in] BSTR clsid, [in] BSTR key, [in] BSTR name, [in] SpeechTokenShellFolder folder, + [out,retval] BSTR* path); + + [hidden, id(DISPID_SOTRemoveStorageFileName)] + HRESULT RemoveStorageFileName([in] BSTR clsid, [in]BSTR key, [in] VARIANT_BOOL delete); + + [hidden, id(DISPID_SOTIsUISupported)] + HRESULT IsUISupported( [in]const BSTR type, [in, defaultvalue(NULL)] const VARIANT *data, + [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 type, + [in, defaultvalue(NULL)] const VARIANT *data, + [in, defaultvalue(NULL)] IUnknown *object); + + [id(DISPID_SOTMatchesAttributes)] + HRESULT MatchesAttributes([in] BSTR attributes, [out,retval] VARIANT_BOOL *matches); +}; + +typedef [hidden] enum DISPID_SpeechObjectTokens +{ + DISPID_SOTsCount = 1, + DISPID_SOTsItem = DISPID_VALUE, + DISPID_SOTs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechObjectTokens; + +[ + 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 **ppenum); +}; + +typedef [hidden] enum DISPID_SpeechWaveFormatEx +{ + DISPID_SWFEFormatTag = 1, + DISPID_SWFEChannels, + DISPID_SWFESamplesPerSec, + DISPID_SWFEAvgBytesPerSec, + DISPID_SWFEBlockAlign, + DISPID_SWFEBitsPerSample, + DISPID_SWFEExtraData +} DISPID_SpeechWaveFormatEx; + +[ + object, + uuid(7a1ef0d5-1581-4741-88e4-209a49f11a10), + dual, + pointer_default(unique) +] +interface ISpeechWaveFormatEx : IDispatch +{ + [propget, id(DISPID_SWFEFormatTag)] + HRESULT FormatTag([out,retval] short *tag); + [propput, id(DISPID_SWFEFormatTag)] + HRESULT FormatTag([in] short tag); + + [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 * samples); + [propput, id(DISPID_SWFESamplesPerSec)] + HRESULT SamplesPerSec([in] long samples); + + [propget, id(DISPID_SWFEAvgBytesPerSec)] + HRESULT AvgBytesPerSec([out,retval] long *average); + [propput, id(DISPID_SWFEAvgBytesPerSec)] + HRESULT AvgBytesPerSec([in] long average); + + [propget, id(DISPID_SWFEBlockAlign)] + HRESULT BlockAlign([out,retval] short *alignment); + [propput, id(DISPID_SWFEBlockAlign)] + HRESULT BlockAlign([in] short alignment); + + [propget, id(DISPID_SWFEBitsPerSample)] + HRESULT BitsPerSample([out,retval] short *bits); + [propput, id(DISPID_SWFEBitsPerSample)] + HRESULT BitsPerSample([in] short bits); + + [propget, id(DISPID_SWFEExtraData)] + HRESULT ExtraData([out,retval] VARIANT *data); + [propput, id(DISPID_SWFEExtraData)] + HRESULT ExtraData([in] VARIANT data); +} + +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; + +[ + object, + uuid(e6e9c590-3e18-40e3-8299-061f98bde7c7), + dual, + pointer_default(unique) +] +interface ISpeechAudioFormat : IDispatch +{ + [propget, id(DISPID_SAFType)] + HRESULT Type([out,retval] SpeechAudioFormatType *format); + [propput, id(DISPID_SAFType)] + HRESULT Type([in] SpeechAudioFormatType format); + + [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 **speechwave); + + [hidden, id(DISPID_SAFSetWaveFormatEx)] + HRESULT SetWaveFormatEx([in] ISpeechWaveFormatEx *speechwave); +} + +typedef enum SpeechStreamSeekPositionType +{ + SSSPTRelativeToStart = STREAM_SEEK_SET, + SSSPTRelativeToCurrentPosition = STREAM_SEEK_CUR, + SSSPTRelativeToEnd = STREAM_SEEK_END +} SpeechStreamSeekPositionType; + +typedef [hidden] enum DISPID_SpeechBaseStream +{ + DISPID_SBSFormat = 1, + DISPID_SBSRead, + DISPID_SBSWrite, + DISPID_SBSSeek +} DISPID_SpeechBaseStream; + +[ + object, + uuid(6450336f-7d49-4ced-8097-49d6dee37294), + dual, + pointer_default(unique) +] +interface ISpeechBaseStream : IDispatch +{ + [propget, id(DISPID_SBSFormat)] + HRESULT Format([out,retval] ISpeechAudioFormat **format); + [propputref, id(DISPID_SBSFormat)] + HRESULT Format([in] ISpeechAudioFormat *format); + + [id(DISPID_SBSRead)] + HRESULT Read([out] VARIANT *buffer, [in] long written, [out,retval] long *read); + + [id(DISPID_SBSWrite)] + HRESULT Write([in] VARIANT buffer, [out,retval] long *written); + + [id(DISPID_SBSSeek)] + HRESULT Seek([in] VARIANT position, [in, defaultvalue(SSSPTRelativeToStart)] SpeechStreamSeekPositionType origin, + [out,retval] VARIANT *pos); +}; + +typedef [hidden] enum DISPID_SpeechAudioStatus +{ + DISPID_SASFreeBufferSpace = 1, + DISPID_SASNonBlockingIO, + DISPID_SASState, + DISPID_SASCurrentSeekPosition, + DISPID_SASCurrentDevicePosition +} DISPID_SpeechAudioStatus; + +[ + object, + uuid(c62d9c91-7458-47f6-862d-1ef86fb0b278), + dual, + pointer_default(unique) +] +interface ISpeechAudioStatus : IDispatch +{ + [propget, id(DISPID_SASFreeBufferSpace)] + HRESULT FreeBufferSpace([out,retval] long *space); + + [propget, id(DISPID_SASNonBlockingIO)] + HRESULT NonBlockingIO([out,retval] long *nonblocking); + + [propget, id(DISPID_SASState)] + HRESULT State([out, retval] SpeechAudioState *state); + + [propget, id(DISPID_SASCurrentSeekPosition)] + HRESULT CurrentSeekPosition([out,retval] VARIANT *position); + + [propget, id(DISPID_SASCurrentDevicePosition)] + HRESULT CurrentDevicePosition([out,retval] VARIANT *position); +}; + +typedef [hidden] enum DISPID_SpeechRecognizerStatus +{ + DISPID_SRSAudioStatus = 1, + DISPID_SRSCurrentStreamPosition, + DISPID_SRSCurrentStreamNumber, + DISPID_SRSNumberOfActiveRules, + DISPID_SRSClsidEngine, + DISPID_SRSSupportedLanguages +} DISPID_SpeechRecognizerStatus; + +[ + object, + uuid(bff9e781-53ec-484e-bb8a-0e1b5551e35c), + dual, + pointer_default(unique) +] +interface ISpeechRecognizerStatus : IDispatch +{ + [propget, id(DISPID_SRSAudioStatus)] + HRESULT AudioStatus([out,retval] ISpeechAudioStatus **audio); + + [propget, id(DISPID_SRSCurrentStreamPosition)] + HRESULT CurrentStreamPosition([out,retval] VARIANT *pos); + + [propget, id(DISPID_SRSCurrentStreamNumber)] + HRESULT CurrentStreamNumber([out,retval] long *number); + + [propget, id(DISPID_SRSNumberOfActiveRules)] + HRESULT NumberOfActiveRules([out,retval] long *rules); + + [propget, id(DISPID_SRSClsidEngine)] + HRESULT ClsidEngine([out,retval] BSTR *clsid); + + [propget, id(DISPID_SRSSupportedLanguages)] + HRESULT SupportedLanguages([out,retval] VARIANT *languages); +}; + +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; + +[ + object, + uuid(8be47b07-57f6-11d2-9eee-00c04f797396), + dual, + pointer_default(unique) +] +interface ISpeechVoiceStatus : IDispatch +{ + [propget, id(DISPID_SVSCurrentStreamNumber)] + HRESULT CurrentStreamNumber([out, retval] long *number); + + [propget, id(DISPID_SVSLastStreamNumberQueued)] + HRESULT LastStreamNumberQueued([out, retval] long *number); + + [propget, id(DISPID_SVSLastResult)] + HRESULT LastHResult([out, retval]long *result); + + [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 *bookmark); + + [propget, id(DISPID_SVSPhonemeId)] + HRESULT PhonemeId([out, retval] short *phone); + + [propget, id(DISPID_SVSVisemeId)] + HRESULT VisemeId([out, retval] short *id); +}; + +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; + +[ + 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 **output); + + [propputref, id(DISPID_SVAudioOutput)] + HRESULT AudioOutput([in] ISpeechObjectToken *output); + + [propget, id(DISPID_SVAudioOutputStream)] + HRESULT AudioOutputStream([out, retval] ISpeechBaseStream **output); + + [propputref, id(DISPID_SVAudioOutputStream)] + HRESULT AudioOutputStream([in] ISpeechBaseStream *output); + + [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 *flags); + + [propput, id(DISPID_SVEventInterests)] + HRESULT EventInterests([in] SpeechVoiceEvents flags); + + [propput, id(DISPID_SVPriority)] + HRESULT Priority([in] SpeechVoicePriority vpriority); + + [propget, id(DISPID_SVPriority)] + HRESULT Priority([out,retval] SpeechVoicePriority *vpriority); + + [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 timeout); + + [propget, id(DISPID_SVSyncronousSpeakTimeout)] + HRESULT SynchronousSpeakTimeout([out,retval] long *timeout); + + [id(DISPID_SVSpeak)] + HRESULT Speak([in] BSTR text, [in, defaultvalue(SPF_DEFAULT)] SpeechVoiceSpeakFlags flags, + [out, retval] long *number); + + [id(DISPID_SVSpeakStream)] + HRESULT SpeakStream([in] ISpeechBaseStream *stream, [in, defaultvalue(SPF_DEFAULT)] SpeechVoiceSpeakFlags flags, + [out, retval] long *number); + + [id(DISPID_SVPause)] + HRESULT Pause(void); + + [id(DISPID_SVResume)] + HRESULT Resume(void); + + [id(DISPID_SVSkip)] + HRESULT Skip([in] const BSTR type, [in] long items, [out,retval ]long *skipped); + + [id(DISPID_SVGetVoices)] + HRESULT GetVoices([in, defaultvalue("")] BSTR required, [in, defaultvalue("")] BSTR optional, + [out,retval] ISpeechObjectTokens **tokens); + + [id(DISPID_SVGetAudioOutputs)] + HRESULT GetAudioOutputs([in, defaultvalue("")] BSTR required, [in, defaultvalue("")] BSTR optional, + [out,retval] ISpeechObjectTokens **tokens); + + [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 typeui, [in, defaultvalue(NULL)] const VARIANT *data, + [out,retval] VARIANT_BOOL *supported); + + [id(DISPID_SVDisplayUI)] + HRESULT DisplayUI([in] long hwnd, [in] BSTR title, [in] const BSTR typeui, [in, defaultvalue(NULL)] const VARIANT *data); +}; + +typedef [hidden] enum DISPID_SpeechRecoResultTimes +{ + DISPID_SRRTStreamTime = 1, + DISPID_SRRTLength, + DISPID_SRRTTickCount, + DISPID_SRRTOffsetFromStart +} DISPID_SpeechRecoResultTimes; + +[ + object, + uuid(62b3b8fb-f6e7-41be-bdcb-056b1c29efc0), + dual, + pointer_default(unique) +] +interface ISpeechRecoResultTimes : IDispatch +{ + [propget, id(DISPID_SRRTStreamTime)] + HRESULT StreamTime([out,retval] VARIANT *streamtime); + + [propget, id(DISPID_SRRTLength)] + HRESULT Length([out,retval] VARIANT *length); + + [propget, id(DISPID_SRRTTickCount)] + HRESULT TickCount([out,retval] long *count); + + [propget, id(DISPID_SRRTOffsetFromStart)] + HRESULT OffsetFromStart([out,retval] VARIANT *offset); +}; + +typedef [hidden] enum DISPID_SpeechPhraseRules +{ + DISPID_SPRulesCount = 1, + DISPID_SPRulesItem = DISPID_VALUE, + DISPID_SPRules_NewEnum = DISPID_NEWENUM +} DISPID_SpeechPhraseRules; + +[ + 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 **obj); +}; + +typedef [hidden] enum DISPID_SpeechPhraseRule +{ + DISPID_SPRuleName = 1, + DISPID_SPRuleId, + DISPID_SPRuleFirstElement, + DISPID_SPRuleNumberOfElements, + DISPID_SPRuleParent, + DISPID_SPRuleChildren, + DISPID_SPRuleConfidence, + DISPID_SPRuleEngineConfidence +} DISPID_SpeechPhraseRule; + +[ + 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 *element); + + [propget, id(DISPID_SPRuleNumberOfElements)] + HRESULT NumberOfElements([out, retval] long *count); + + [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 *confidence); + + [propget, id(DISPID_SPRuleEngineConfidence)] + HRESULT EngineConfidence([out, retval] float *confidence); +}; + +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; + +[ + 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 *element); + + [propget, id(DISPID_SPPNumberOfElements)] + HRESULT NumberOfElements([out, retval] long *elements); + + [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 **parent); + + [propget, id(DISPID_SPPChildren)] + HRESULT Children( [out, retval] ISpeechPhraseProperties **children); +}; + +typedef [hidden] enum DISPID_SpeechPhraseProperties +{ + DISPID_SPPsCount = 1, + DISPID_SPPsItem = DISPID_VALUE, + DISPID_SPPs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechPhraseProperties; + +[ + 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 **obj); + + [propget, restricted, id(DISPID_SPPs_NewEnum)] + HRESULT _NewEnum([out, retval] IUnknown **obj); +}; + +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; + +[ + object, + uuid(e6176f96-e373-4801-b223-3b62c068c0b4), + dual, + pointer_default(unique) +] +interface ISpeechPhraseElement : IDispatch +{ + [propget, id(DISPID_SPEAudioTimeOffset)] + HRESULT AudioTimeOffset( [out, retval] long *offset); + + [propget, id(DISPID_SPEAudioSizeTime)] + HRESULT AudioSizeTime([out, retval] long *audiotime); + + [propget, id(DISPID_SPEAudioStreamOffset)] + HRESULT AudioStreamOffset([out, retval] long *offset); + + [propget, id(DISPID_SPEAudioSizeBytes)] + HRESULT AudioSizeBytes([out, retval]long *bytes); + + [propget, id(DISPID_SPERetainedStreamOffset)] + HRESULT RetainedStreamOffset([out, retval] long *offset); + + [propget, id(DISPID_SPERetainedSizeBytes)] + HRESULT RetainedSizeBytes([out, retval] long *retained); + + [propget, id(DISPID_SPEDisplayText)] + HRESULT DisplayText([out, retval] BSTR *display); + + [propget, id(DISPID_SPELexicalForm)] + HRESULT LexicalForm( [out, retval] BSTR *lexical); + + [propget, id(DISPID_SPEPronunciation)] + HRESULT Pronunciation([out, retval] VARIANT *pronunciation); + + [propget, id(DISPID_SPEDisplayAttributes)] + HRESULT DisplayAttributes([out, retval] SpeechDisplayAttributes *attributes); + + [propget, id(DISPID_SPERequiredConfidence)] + HRESULT RequiredConfidence([out, retval] SpeechEngineConfidence *confidence); + + [propget, id(DISPID_SPEActualConfidence)] + HRESULT ActualConfidence([out, retval] SpeechEngineConfidence *confidence); + + [propget, id(DISPID_SPEEngineConfidence)] + HRESULT EngineConfidence([out, retval] float *confidence); +}; + +typedef [hidden] enum DISPID_SpeechPhraseElements +{ + DISPID_SPEsCount = 1, + DISPID_SPEsItem = DISPID_VALUE, + DISPID_SPEs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechPhraseElements; + +[ + 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 **obj); +}; + +typedef [hidden] enum DISPID_SpeechPhraseReplacement +{ + DISPID_SPRDisplayAttributes = 1, + DISPID_SPRText, + DISPID_SPRFirstElement, + DISPID_SPRNumberOfElements +} DISPID_SpeechPhraseReplacement; + +[ + object, + uuid(2890a410-53a7-4fb5-94ec-06d4998e3d02), + dual, + pointer_default(unique) +] +interface ISpeechPhraseReplacement : IDispatch +{ + [propget, id(DISPID_SPRDisplayAttributes)] + HRESULT DisplayAttributes([out,retval] SpeechDisplayAttributes *attributes); + + [propget, id(DISPID_SPRText)] + HRESULT Text([out, retval] BSTR *text); + + [propget, id(DISPID_SPRFirstElement)] + HRESULT FirstElement([out, retval] long *element); + + [propget, id(DISPID_SPRNumberOfElements)] + HRESULT NumberOfElements([out, retval] long *elements); +}; + +typedef [hidden] enum DISPID_SpeechPhraseReplacements +{ + DISPID_SPRsCount = 1, + DISPID_SPRsItem = DISPID_VALUE, + DISPID_SPRs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechPhraseReplacements; + +[ + 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 **obj); +}; + +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; + +[ + object, + uuid(961559cf-4e67-4662-8bf0-d93f1fcd61b3), + dual, + pointer_default(unique) +] +interface ISpeechPhraseInfo : IDispatch +{ + [propget, id(DISPID_SPILanguageId)] + HRESULT LanguageId( [out, retval] long *language); + + [propget, id(DISPID_SPIGrammarId)] + HRESULT GrammarId([out, retval] VARIANT *grammar); + + [propget, id(DISPID_SPIStartTime)] + HRESULT StartTime([out, retval]VARIANT *start); + + [propget, id(DISPID_SPIAudioStreamPosition)] + HRESULT AudioStreamPosition([out, retval] VARIANT *position); + + [propget, id(DISPID_SPIAudioSizeBytes)] + HRESULT AudioSizeBytes([out, retval] long *bytes); + + [propget, id(DISPID_SPIRetainedSizeBytes)] + HRESULT RetainedSizeBytes([out, retval] long *bytes); + + [propget, id(DISPID_SPIAudioSizeTime)] + HRESULT AudioSizeTime([out, retval] long *audiotime); + + [propget, id(DISPID_SPIRule)] + HRESULT Rule([out, retval] ISpeechPhraseRule **rule); + + [propget, id(DISPID_SPIProperties)] + HRESULT Properties([out, retval] ISpeechPhraseProperties **props); + + [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 *engine); + + [propget, id(DISPID_SPIEnginePrivateData)] + HRESULT EnginePrivateData([out, retval] VARIANT *data); + + [id(DISPID_SPISaveToMemory)] + HRESULT SaveToMemory([out,retval] VARIANT *block); + + [id(DISPID_SPIGetText)] + HRESULT GetText([in, defaultvalue(0)] long start, + [in, defaultvalue(SPPR_ALL_ELEMENTS)] long elements, + [in, defaultvalue(-1)] VARIANT_BOOL replacements, [out,retval] BSTR *text); + + [id(DISPID_SPIGetDisplayAttributes)] + HRESULT GetDisplayAttributes([in, defaultvalue(0)] long start, + [in, defaultvalue(SPPR_ALL_ELEMENTS)] long elements, + [in, defaultvalue(-1)] VARIANT_BOOL replacements, + [out,retval] SpeechDisplayAttributes *attributes); +}; + +typedef [hidden] enum DISPID_SpeechPhraseAlternate +{ + DISPID_SPARecoResult = 1, + DISPID_SPAStartElementInResult, + DISPID_SPANumberOfElementsInResult, + DISPID_SPAPhraseInfo, + DISPID_SPACommit +} DISPID_SpeechPhraseAlternate; + +[ + object, + uuid(27864a2a-2b9f-4cb8-92d3-0d2722fd1e73), + dual, + pointer_default(unique) +] +interface ISpeechPhraseAlternate : IDispatch +{ + [propget, id(DISPID_SPARecoResult)] + HRESULT RecoResult( [out,retval] ISpeechRecoResult **result); + + [propget, id(DISPID_SPAStartElementInResult)] + HRESULT StartElementInResult([out,retval] long *element); + + [propget, id(DISPID_SPANumberOfElementsInResult)] + HRESULT NumberOfElementsInResult([out,retval] long *elements); + + [propget, id(DISPID_SPAPhraseInfo)] + HRESULT PhraseInfo( [out,retval] ISpeechPhraseInfo **PhraseInfo); + + [id(DISPID_SPACommit)] + HRESULT Commit(void); +}; + +typedef [hidden] enum DISPID_SpeechPhraseAlternates +{ + DISPID_SPAsCount = 1, + DISPID_SPAsItem = DISPID_VALUE, + DISPID_SPAs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechPhraseAlternates; + +[ + 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 **alternate); + + [propget, restricted, id(DISPID_SPAs_NewEnum)] + HRESULT _NewEnum([out, retval] IUnknown **obj); +}; + +typedef [hidden] enum DISPID_SpeechMemoryStream +{ + DISPID_SMSSetData = 100, + DISPID_SMSGetData +} DISPID_SpeechMemoryStream; + +[ + 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 *data); +}; + +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; + +[ + 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 **phrase); + + [id(DISPID_SRRAlternates)] + HRESULT Alternates( [in] long count, [in, defaultvalue(0)] long start, + [in, defaultvalue(SPPR_ALL_ELEMENTS)] long elements, + [out,retval] ISpeechPhraseAlternates **alternates); + + [id(DISPID_SRRAudio)] + HRESULT Audio([in, defaultvalue(0)] long start, + [in, defaultvalue(SPPR_ALL_ELEMENTS)] long elements, + [out,retval] ISpeechMemoryStream **stream); + + [id(DISPID_SRRSpeakAudio)] + HRESULT SpeakAudio([in, defaultvalue(0)] long start, + [in, defaultvalue(SPPR_ALL_ELEMENTS)] long elements, + [in, defaultvalue(SPF_DEFAULT)] SpeechVoiceSpeakFlags flags, + [out,retval] long *stream); + + [id(DISPID_SRRSaveToMemory)] + HRESULT SaveToMemory([out,retval] VARIANT *block); + + [id(DISPID_SRRDiscardResultInfo)] + HRESULT DiscardResultInfo([in] SpeechDiscardType types); +}; + +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_SpeechGrammarRuleStateTransitions +{ + DISPID_SGRSTsCount = 1, + DISPID_SGRSTsItem = DISPID_VALUE, + DISPID_SGRSTs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechGrammarRuleStateTransitions; + +typedef enum SpeechGrammarRuleStateTransitionType +{ + SGRSTTEpsilon = 0, + SGRSTTWord, + SGRSTTRule, + SGRSTTDictation, + SGRSTTWildcard, + SGRSTTTextBuffer +} SpeechGrammarRuleStateTransitionType; + +typedef [hidden] enum DISPID_SpeechGrammarRuleStateTransition +{ + DISPID_SGRSTType = 1, + DISPID_SGRSTText, + DISPID_SGRSTRule, + DISPID_SGRSTWeight, + DISPID_SGRSTPropertyName, + DISPID_SGRSTPropertyId, + DISPID_SGRSTPropertyValue, + DISPID_SGRSTNextState +} DISPID_SpeechGrammarRuleStateTransition; + +[ + 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 *name); + + [propget, id(DISPID_SGRSTPropertyId)] + HRESULT PropertyId([out, retval] long *id); + + [propget, id(DISPID_SGRSTPropertyValue)] + HRESULT PropertyValue([out, retval] VARIANT *value); + + [propget, id(DISPID_SGRSTNextState)] + HRESULT NextState([out, retval] ISpeechGrammarRuleState **state); +}; + +[ + 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 **enum_var); +}; + +typedef [hidden] enum DISPID_SpeechGrammarRuleState +{ + DISPID_SGRSRule = 1, + DISPID_SGRSTransitions, + DISPID_SGRSAddWordTransition, + DISPID_SGRSAddRuleTransition, + DISPID_SGRSAddSpecialTransition +} DISPID_SpeechGrammarRuleState; + +[ + 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 *state, [in] const BSTR Words, + [in, defaultvalue(" ")] const BSTR separators, [in, defaultvalue(SGLexical)] SpeechGrammarWordType type, + [in, defaultvalue("")] const BSTR name, [in, defaultvalue(0)] long id, + [in, defaultvalue(0)] VARIANT *value, [in, defaultvalue(1)] float weight); + + [id(DISPID_SGRSAddRuleTransition)] + HRESULT AddRuleTransition([in] ISpeechGrammarRuleState *state, [in] ISpeechGrammarRule *rule, + [in, defaultvalue("")] const BSTR name, [in, defaultvalue(0)] long id, + [in, defaultvalue(0)] VARIANT *value, [in, defaultvalue(1)] float weight); + + [id(DISPID_SGRSAddSpecialTransition)] + HRESULT AddSpecialTransition([in] ISpeechGrammarRuleState *state, [in] SpeechSpecialTransitionType type, + [in, defaultvalue("")] const BSTR name, [in, defaultvalue(0)] long id, + [in, defaultvalue(0)] VARIANT* value, [in, defaultvalue(1)] float weight); +}; + +[ + 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 name, [in] const BSTR value); + + [id(DISPID_SGRAddState)] + HRESULT AddState([out, retval] ISpeechGrammarRuleState **state); +}; + +typedef [hidden] enum DISPIDSPTSI +{ + DISPIDSPTSI_ActiveOffset = 1, + DISPIDSPTSI_ActiveLength, + DISPIDSPTSI_SelectionOffset, + DISPIDSPTSI_SelectionLength +} DISPIDSPTSI; + +[ + object, + uuid(3b9c7e7a-6eee-4ded-9092-11657279adbe), + dual, + pointer_default(unique) +] +interface ISpeechTextSelectionInformation : IDispatch +{ + [propput, id(DISPIDSPTSI_ActiveOffset)] + HRESULT ActiveOffset([in] long offset); + [propget, id(DISPIDSPTSI_ActiveOffset)] + HRESULT ActiveOffset([out, retval] long *offset); + + [propput, id(DISPIDSPTSI_ActiveLength)] + HRESULT ActiveLength([in] long length); + [propget, id(DISPIDSPTSI_ActiveLength)] + HRESULT ActiveLength([out, retval] long *length); + + [propput, id(DISPIDSPTSI_SelectionOffset)] + HRESULT SelectionOffset([in] long offset); + [propget, id(DISPIDSPTSI_SelectionOffset)] + HRESULT SelectionOffset([out, retval] long *offset); + + [propput, id(DISPIDSPTSI_SelectionLength)] + HRESULT SelectionLength([in] long length); + [propget, id(DISPIDSPTSI_SelectionLength)] + HRESULT SelectionLength([out, retval] long* length); +}; + +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; + +[ + 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 id, [out, retval] ISpeechGrammarRule **rule); + + [id(DISPID_SGRsItem)] + HRESULT Item([in] long index, [out, retval] ISpeechGrammarRule **rule); + + [id(DISPID_SGRs_NewEnum), propget, restricted] + HRESULT _NewEnum([out, retval] IUnknown **enum_var); + + [propget, id(DISPID_SGRsDynamic)] + HRESULT Dynamic([out, retval] VARIANT_BOOL *dynamic); + + [id(DISPID_SGRsAdd)] + HRESULT Add([in] BSTR name, [in] SpeechRuleAttributes attributes, + [in, defaultvalue(0)] long id, [out, retval] ISpeechGrammarRule **rule); + + [id(DISPID_SGRsCommit)] + HRESULT Commit(void); + + [id(DISPID_SGRsCommitAndSave)] + HRESULT CommitAndSave([out] BSTR *text, [out, retval] VARIANT *stream); +}; + +[ + 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 **context); + + [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 language); + + [id(DISPID_SRGCmdLoadFromFile)] + HRESULT CmdLoadFromFile([in] const BSTR filename, [in, defaultvalue(SLOStatic)] SpeechLoadOption option); + + [id(DISPID_SRGCmdLoadFromObject)] + HRESULT CmdLoadFromObject([in]const BSTR classid, [in] const BSTR grammarname, [in, defaultvalue(SLOStatic)] SpeechLoadOption option); + + [id(DISPID_SRGCmdLoadFromResource)] + HRESULT CmdLoadFromResource([in]long mod, [in] VARIANT name, [in] VARIANT yype, [in] SpeechLanguageId language, + [in, defaultvalue(SLOStatic)] SpeechLoadOption option); + + [id(DISPID_SRGCmdLoadFromMemory)] + HRESULT CmdLoadFromMemory([in] VARIANT data, [in, defaultvalue(SLOStatic)] SpeechLoadOption option); + + [id(DISPID_SRGCmdLoadFromProprietaryGrammar)] + HRESULT CmdLoadFromProprietaryGrammar([in] const BSTR guid, [in] const BSTR string, [in] VARIANT data, + [in, defaultvalue(SLOStatic)] SpeechLoadOption option); + + [id(DISPID_SRGCmdSetRuleState)] + HRESULT CmdSetRuleState([in] const BSTR name, [in] SpeechRuleState state); + + [id(DISPID_SRGCmdSetRuleIdState)] + HRESULT CmdSetRuleIdState([in] long rule, [in] SpeechRuleState State); + + [id(DISPID_SRGDictationLoad)] + HRESULT DictationLoad([in, defaultvalue("")] const BSTR topic, [in, defaultvalue(SLOStatic)] SpeechLoadOption option); + + [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 length, [in] ISpeechTextSelectionInformation *info); + + [id(DISPID_SRGSetTextSelection)] + HRESULT SetTextSelection([in] ISpeechTextSelectionInformation *info); + + [id(DISPID_SRGIsPronounceable)] + HRESULT IsPronounceable([in] const BSTR word, [out, retval] SpeechWordPronounceable *pronounceable); +}; + +[ + 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 *type ); + + [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 *allow); + + [propput, id(DISPID_SRCVoicePurgeEvent)] + HRESULT VoicePurgeEvent([in] SpeechRecoEvents interest); + [propget, id(DISPID_SRCVoicePurgeEvent)] + HRESULT VoicePurgeEvent([out,retval] SpeechRecoEvents *interest); + + [propput, id(DISPID_SRCEventInterests)] + HRESULT EventInterests([in] SpeechRecoEvents interest); + [propget, id(DISPID_SRCEventInterests)] + HRESULT EventInterests([out,retval] SpeechRecoEvents *interest); + + [propput, id(DISPID_SRCCmdMaxAlternates)] + HRESULT CmdMaxAlternates([in] long alternates); + [propget, id(DISPID_SRCCmdMaxAlternates)] + HRESULT CmdMaxAlternates([out,retval] long *alternates); + + [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 id, [out,retval] ISpeechRecoGrammar **grammar); + + [id(DISPID_SRCCreateResultFromMemory)] + HRESULT CreateResultFromMemory([in] VARIANT *block, [out,retval] ISpeechRecoResult **result); + + [id(DISPID_SRCBookmark)] + HRESULT Bookmark([in] SpeechBookmarkOptions options, [in] VARIANT pos, [in] VARIANT bookmark); + + [id(DISPID_SRCSetAdaptationData)] + HRESULT SetAdaptationData([in] BSTR adaptation); +}; + +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; + +[ + 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 *input); + [propget, id(DISPID_SRAudioInput)] + HRESULT AudioInput([out,retval] ISpeechObjectToken **input); + + [propputref, id(DISPID_SRAudioInputStream)] + HRESULT AudioInputStream([in,defaultvalue(0)] ISpeechBaseStream *input); + [propget, id(DISPID_SRAudioInputStream)] + HRESULT AudioInputStream([out,retval] ISpeechBaseStream **input); + + [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 **satus); + + [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 elements, [in, defaultvalue(NULL)] VARIANT *attributes, + [in, defaultvalue(0)] long id); + + [id(DISPID_SRCreateRecoContext)] + HRESULT CreateRecoContext([out,retval] ISpeechRecoContext **ncontext); + + [id(DISPID_SRGetFormat)] + HRESULT GetFormat([in] SpeechFormatType speechtype, [out,retval] ISpeechAudioFormat **audioformat); + + [hidden, id(DISPID_SRSetPropertyNumber)] + HRESULT SetPropertyNumber([in] const BSTR name, [in] long value, [out,retval] VARIANT_BOOL *supported); + + [hidden, id(DISPID_SRGetPropertyNumber)] + HRESULT GetPropertyNumber([in] const BSTR name, [in,out] long *value, [out,retval] VARIANT_BOOL *supported); + + [hidden, id(DISPID_SRSetPropertyString)] + HRESULT SetPropertyString([in] const BSTR name, [in] const BSTR value, [out,retval] VARIANT_BOOL *supported); + + [hidden, id(DISPID_SRGetPropertyString)] + HRESULT GetPropertyString([in] const BSTR name, [in,out] BSTR *value, [out,retval] VARIANT_BOOL *supported); + + [id(DISPID_SRIsUISupported)] + HRESULT IsUISupported([in] const BSTR type, [in, defaultvalue(NULL)] const VARIANT *data, + [out,retval] VARIANT_BOOL *supported); + + [id(DISPID_SRDisplayUI)] + HRESULT DisplayUI( [in] long hWnd, [in] BSTR title, [in] const BSTR type, [in, defaultvalue(NULL)] const VARIANT *data); + + [id(DISPID_SRGetRecognizers)] + HRESULT GetRecognizers([in, defaultvalue("")] BSTR required, [in, defaultvalue("")] BSTR optional, + [out,retval] ISpeechObjectTokens **tokens); + + [id(DISPID_SVGetAudioInputs)] + HRESULT GetAudioInputs([in, defaultvalue("")] BSTR required, [in, defaultvalue("")] BSTR optional, + [out,retval] ISpeechObjectTokens **tokens); + + [id(DISPID_SVGetProfiles)] + HRESULT GetProfiles([in, defaultvalue("")] BSTR required, [in, defaultvalue("")] BSTR optional, + [out,retval] ISpeechObjectTokens **tokens); + +};