system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-11-05 18:01:34 +00:00
Code Issues Projects Releases Packages Wiki Activity
wine/include/sapiaut.idl
Andrey Gusev acd0eb3672 sapiaut.idl: Fix a typo. 
Signed-off-by: Andrey Gusev <andrey.goosev@gmail.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
2019-12-02 22:02:56 +01:00

2036 lines
61 KiB
Text
Raw Blame History

/*
* 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 type, [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 **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 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);
}
typedef enum SpeechStreamFileMode
{
SSFMOpenForRead = SPFM_OPEN_READONLY,
SSFMOpenReadWrite = SPFM_OPEN_READWRITE,
SSFMCreate = SPFM_CREATE,
SSFMCreateForWrite = SPFM_CREATE_ALWAYS,
} SpeechStreamFileMode;
typedef [hidden] enum DISPID_SpeechFileStream
{
DISPID_SFSOpen = 100,
DISPID_SFSClose
} DISPID_SpeechFileStream;
[
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 mode,
[in, defaultvalue(0)] VARIANT_BOOL events);
[id(DISPID_SFSClose)]
HRESULT Close(void);
};
Reference in a new issue View git blame Copy permalink