computernewb/SAPIServer
6
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
SAPIServer/speech2/third_party/sapi5/idl/sapi.idl

2198 lines
70 KiB
Text
Raw Permalink Normal View History

add speech2 stuff
2024-07-17 21:38:27 -04:00
/****************************************************************************
* sapi.idl
*
* This is the interface definition file for the Microsoft Speech API
* Version 5.0.
*
* Copyright (c) Microsoft Corporation. All rights reserved.
*****************************************************************************/
//--- Compiler Directive ----------------------------------------------------
cpp_quote("#pragma warning(disable:4201) // Allow nameless structs/unions")
//--- Includes --------------------------------------------------------------
import "oaidl.idl";
import "ocidl.idl";
//--- Locally scoped define for LANGID
#ifndef LANGID
#define LANGID WORD
#endif
//--- Link with sapi.lib
cpp_quote("#pragma comment(lib, \"sapi.lib\")")
//--- Forward and External Declarations -------------------------------------
cpp_quote("#if 0") // Ignore our definition in the .H file
typedef [restricted, hidden] struct WAVEFORMATEX
{
WORD wFormatTag; /* format type */
WORD nChannels; /* number of channels (i.e. mono, stereo...) */
DWORD nSamplesPerSec; /* sample rate */
DWORD nAvgBytesPerSec; /* for buffer estimation */
WORD nBlockAlign; /* block size of data */
WORD wBitsPerSample; /* Number of bits per sample of mono data */
WORD cbSize; /* The count in bytes of the size of
extra information (after cbSize) */
} WAVEFORMATEX;
cpp_quote("#else")
cpp_quote("#include <mmsystem.h>")
cpp_quote("#endif")
//--- Notifications
interface ISpNotifySource;
interface ISpNotifySink;
interface ISpNotifyTranslator;
//--- Object tokens
interface ISpDataKey;
interface ISpObjectTokenCategory;
interface ISpObjectToken;
interface IEnumSpObjectTokens;
interface ISpObjectWithToken;
//--- Resource management
interface ISpResourceManager;
//--- Speech specific events
interface ISpEventSource;
interface ISpEventSink;
//--- Audio streams
interface ISpStreamFormat;
interface ISpStream;
interface ISpStreamFormatConverter;
interface ISpAudio;
interface ISpMMSysAudio;
interface ISpTranscript;
//--- TTS interface
interface ISpVoice;
//--- SR interfaces
interface ISpRecoResult;
interface ISpRecoContext;
interface ISpRecognizer;
interface ISpProperties;
//--- Lexicon interfaces
interface ISpLexicon;
//--- Phone Converter
interface ISpPhoneConverter;
//--- Phrase interface
interface ISpPhrase;
//
//--- Constants -------------------------------------------------------------
//
//--- DataKey locations
typedef [hidden] enum SPDATAKEYLOCATION
{
SPDKL_DefaultLocation = 0,
SPDKL_CurrentUser = 1,
SPDKL_LocalMachine = 2,
SPDKL_CurrentConfig = 5
} SPDATAKEYLOCATION;
//--- TokenUI constants
cpp_quote("#define SPDUI_EngineProperties L\"EngineProperties\"")
cpp_quote("#define SPDUI_AddRemoveWord L\"AddRemoveWord\"")
cpp_quote("#define SPDUI_UserTraining L\"UserTraining\"")
cpp_quote("#define SPDUI_MicTraining L\"MicTraining\"")
cpp_quote("#define SPDUI_RecoProfileProperties L\"RecoProfileProperties\"")
cpp_quote("#define SPDUI_AudioProperties L\"AudioProperties\"")
cpp_quote("#define SPDUI_AudioVolume L\"AudioVolume\"")
//--- Data formats - these are used by the CSpStreamFormat class in sphelper.h
typedef [hidden] enum SPSTREAMFORMAT
{
SPSF_Default = -1,
SPSF_NoAssignedFormat = 0, // Similar to GUID_NULL
SPSF_Text,
SPSF_NonStandardFormat, // Non-SAPI 5.1 standard format with no WAVEFORMATEX description
SPSF_ExtendedAudioFormat, // Non-SAPI 5.1 standard format but has WAVEFORMATEX description
// Standard PCM wave formats
SPSF_8kHz8BitMono,
SPSF_8kHz8BitStereo,
SPSF_8kHz16BitMono,
SPSF_8kHz16BitStereo,
SPSF_11kHz8BitMono,
SPSF_11kHz8BitStereo,
SPSF_11kHz16BitMono,
SPSF_11kHz16BitStereo,
SPSF_12kHz8BitMono,
SPSF_12kHz8BitStereo,
SPSF_12kHz16BitMono,
SPSF_12kHz16BitStereo,
SPSF_16kHz8BitMono,
SPSF_16kHz8BitStereo,
SPSF_16kHz16BitMono,
SPSF_16kHz16BitStereo,
SPSF_22kHz8BitMono,
SPSF_22kHz8BitStereo,
SPSF_22kHz16BitMono,
SPSF_22kHz16BitStereo,
SPSF_24kHz8BitMono,
SPSF_24kHz8BitStereo,
SPSF_24kHz16BitMono,
SPSF_24kHz16BitStereo,
SPSF_32kHz8BitMono,
SPSF_32kHz8BitStereo,
SPSF_32kHz16BitMono,
SPSF_32kHz16BitStereo,
SPSF_44kHz8BitMono,
SPSF_44kHz8BitStereo,
SPSF_44kHz16BitMono,
SPSF_44kHz16BitStereo,
SPSF_48kHz8BitMono,
SPSF_48kHz8BitStereo,
SPSF_48kHz16BitMono,
SPSF_48kHz16BitStereo,
// TrueSpeech format
SPSF_TrueSpeech_8kHz1BitMono,
// A-Law formats
SPSF_CCITT_ALaw_8kHzMono,
SPSF_CCITT_ALaw_8kHzStereo,
SPSF_CCITT_ALaw_11kHzMono,
SPSF_CCITT_ALaw_11kHzStereo,
SPSF_CCITT_ALaw_22kHzMono,
SPSF_CCITT_ALaw_22kHzStereo,
SPSF_CCITT_ALaw_44kHzMono,
SPSF_CCITT_ALaw_44kHzStereo,
// u-Law formats
SPSF_CCITT_uLaw_8kHzMono,
SPSF_CCITT_uLaw_8kHzStereo,
SPSF_CCITT_uLaw_11kHzMono,
SPSF_CCITT_uLaw_11kHzStereo,
SPSF_CCITT_uLaw_22kHzMono,
SPSF_CCITT_uLaw_22kHzStereo,
SPSF_CCITT_uLaw_44kHzMono,
SPSF_CCITT_uLaw_44kHzStereo,
// ADPCM formats
SPSF_ADPCM_8kHzMono,
SPSF_ADPCM_8kHzStereo,
SPSF_ADPCM_11kHzMono,
SPSF_ADPCM_11kHzStereo,
SPSF_ADPCM_22kHzMono,
SPSF_ADPCM_22kHzStereo,
SPSF_ADPCM_44kHzMono,
SPSF_ADPCM_44kHzStereo,
// GSM 6.10 formats
SPSF_GSM610_8kHzMono,
SPSF_GSM610_11kHzMono,
SPSF_GSM610_22kHzMono,
SPSF_GSM610_44kHzMono,
SPSF_NUM_FORMATS
} SPSTREAMFORMAT;
cpp_quote("EXTERN_C const GUID SPDFID_Text;")
cpp_quote("EXTERN_C const GUID SPDFID_WaveFormatEx;")
//--- Root of registry entries for speech use
cpp_quote("#define SPREG_USER_ROOT L\"HKEY_CURRENT_USER\\\\SOFTWARE\\\\Microsoft\\\\Speech\"")
cpp_quote("#define SPREG_LOCAL_MACHINE_ROOT L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\"")
//--- Categories for speech resource management
cpp_quote("#define SPCAT_AUDIOOUT L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AudioOutput\"")
cpp_quote("#define SPCAT_AUDIOIN L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AudioInput\"")
cpp_quote("#define SPCAT_VOICES L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\Voices\"")
cpp_quote("#define SPCAT_RECOGNIZERS L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\Recognizers\"")
cpp_quote("#define SPCAT_APPLEXICONS L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AppLexicons\"")
cpp_quote("#define SPCAT_PHONECONVERTERS L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\PhoneConverters\"")
cpp_quote("#define SPCAT_RECOPROFILES L\"HKEY_CURRENT_USER\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\RecoProfiles\"")
//--- Specific token ids of interest
cpp_quote("#define SPMMSYS_AUDIO_IN_TOKEN_ID L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AudioInput\\\\TokenEnums\\\\MMAudioIn\\\\\"")
cpp_quote("#define SPMMSYS_AUDIO_OUT_TOKEN_ID L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AudioOutput\\\\TokenEnums\\\\MMAudioOut\\\\\"")
cpp_quote("#define SPCURRENT_USER_LEXICON_TOKEN_ID L\"HKEY_CURRENT_USER\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\CurrentUserLexicon\"")
//--- Standard token values
cpp_quote("#define SPTOKENVALUE_CLSID L\"CLSID\"")
cpp_quote("#define SPTOKENKEY_FILES L\"Files\"")
cpp_quote("#define SPTOKENKEY_UI L\"UI\"")
cpp_quote("#define SPTOKENKEY_ATTRIBUTES L\"Attributes\"")
//--- Standard voice category values
cpp_quote("#define SPVOICECATEGORY_TTSRATE L\"DefaultTTSRate\"")
//--- Standard SR Engine properties
cpp_quote("#define SPPROP_RESOURCE_USAGE L\"ResourceUsage\"")
cpp_quote("#define SPPROP_HIGH_CONFIDENCE_THRESHOLD L\"HighConfidenceThreshold\"")
cpp_quote("#define SPPROP_NORMAL_CONFIDENCE_THRESHOLD L\"NormalConfidenceThreshold\"")
cpp_quote("#define SPPROP_LOW_CONFIDENCE_THRESHOLD L\"LowConfidenceThreshold\"")
cpp_quote("#define SPPROP_RESPONSE_SPEED L\"ResponseSpeed\"")
cpp_quote("#define SPPROP_COMPLEX_RESPONSE_SPEED L\"ComplexResponseSpeed\"")
cpp_quote("#define SPPROP_ADAPTATION_ON L\"AdaptationOn\"")
//--- Standard SAPI Recognition Topics
cpp_quote("#define SPTOPIC_SPELLING L\"Spelling\"")
// CFG Wildcard token
cpp_quote("#define SPWILDCARD L\"...\"")
// CFG Dication token
cpp_quote("#define SPDICTATION L\"*\"")
cpp_quote("#define SPINFDICTATION L\"*+\"")
// CFG confidence scores
const signed char SP_LOW_CONFIDENCE = -1;
const signed char SP_NORMAL_CONFIDENCE = 0;
const signed char SP_HIGH_CONFIDENCE = +1;
// CFG default weight
const float DEFAULT_WEIGHT = 1.0;
// Lexicon word and pronunciation limits
const ULONG SP_MAX_WORD_LENGTH = 128;
const ULONG SP_MAX_PRON_LENGTH = 384;
//
//--- Interface definitions -------------------------------------------------
//
//--- ISpNotifyCallback -----------------------------------------------------
cpp_quote("#if defined(__cplusplus)")
cpp_quote("interface ISpNotifyCallback")
cpp_quote("{")
cpp_quote("virtual HRESULT STDMETHODCALLTYPE NotifyCallback(")
cpp_quote(" WPARAM wParam,")
cpp_quote(" LPARAM lParam) = 0;")
cpp_quote("};")
cpp_quote("#else")
typedef void * ISpNotifyCallback;
cpp_quote("#endif")
cpp_quote("#if 0")
typedef void * SPNOTIFYCALLBACK;
cpp_quote("#else")
cpp_quote("typedef void __stdcall SPNOTIFYCALLBACK(WPARAM wParam, LPARAM lParam);")
cpp_quote("#endif")
//--- ISpNotifySource -------------------------------------------------------
[
object,
uuid(5EFF4AEF-8487-11D2-961C-00C04F8EE628),
helpstring("ISpNotifySource Interface"),
pointer_default(unique),
restricted
]
interface ISpNotifySource : IUnknown
{
HRESULT SetNotifySink([in] ISpNotifySink * pNotifySink);
[local] HRESULT SetNotifyWindowMessage(
[in] HWND hWnd,
[in] UINT Msg,
[in] WPARAM wParam,
[in] LPARAM lParam);
[local] HRESULT SetNotifyCallbackFunction(
[in] SPNOTIFYCALLBACK * pfnCallback,
[in] WPARAM wParam,
[in] LPARAM lParam);
[local] HRESULT SetNotifyCallbackInterface(
[in] ISpNotifyCallback * pSpCallback,
[in] WPARAM wParam,
[in] LPARAM lParam);
[local] HRESULT SetNotifyWin32Event(void);
[local] HRESULT WaitForNotifyEvent([in] DWORD dwMilliseconds);
[local] HANDLE GetNotifyEventHandle();
}
//--- ISpNotifySink ---------------------------------------------------------
[
object,
uuid(259684DC-37C3-11D2-9603-00C04F8EE628),
helpstring("ISpNotifySink Interface"),
pointer_default(unique),
restricted
]
interface ISpNotifySink : IUnknown
{
HRESULT Notify(void);
}
//--- ISpNotifyTranslator ---------------------------------------------------
[
object,
uuid(ACA16614-5D3D-11D2-960E-00C04F8EE628),
helpstring("ISpNotifyTranslator Interface"),
pointer_default(unique),
local,
restricted
]
interface ISpNotifyTranslator : ISpNotifySink
{
HRESULT InitWindowMessage(
[in] HWND hWnd,
[in] UINT Msg,
[in] WPARAM wParam,
[in] LPARAM lParam);
HRESULT InitCallback(
[in] SPNOTIFYCALLBACK * pfnCallback,
[in] WPARAM wParam,
[in] LPARAM lParam);
HRESULT InitSpNotifyCallback(
[in] ISpNotifyCallback * pSpCallback,
[in] WPARAM wParam,
[in] LPARAM lParam);
HRESULT InitWin32Event(
HANDLE hEvent,
BOOL fCloseHandleOnRelease);
HRESULT Wait([in] DWORD dwMilliseconds);
HANDLE GetEventHandle();
}
//--- ISpDataKey ------------------------------------------------------------
[
object,
uuid(14056581-E16C-11D2-BB90-00C04F8EE6C0),
helpstring("ISpDataKey Interface"),
pointer_default(unique),
restricted
]
interface ISpDataKey : IUnknown
{
HRESULT SetData( const WCHAR * pszValueName, ULONG cbData, const BYTE * pData);
HRESULT GetData( const WCHAR * pszValueName, ULONG * pcbData, BYTE * pData);
HRESULT SetStringValue( const WCHAR * pszValueName, const WCHAR * pszValue );
HRESULT GetStringValue( const WCHAR * pszValueName, WCHAR ** ppszValue);
HRESULT SetDWORD(const WCHAR * pszValueName, DWORD dwValue );
HRESULT GetDWORD(const WCHAR * pszValueName, DWORD *pdwValue );
HRESULT OpenKey(const WCHAR * pszSubKeyName, ISpDataKey ** ppSubKey);
HRESULT CreateKey(const WCHAR * pszSubKey, ISpDataKey ** ppSubKey);
HRESULT DeleteKey(const WCHAR * pszSubKey);
HRESULT DeleteValue(const WCHAR * pszValueName);
HRESULT EnumKeys(ULONG Index, WCHAR ** ppszSubKeyName);
HRESULT EnumValues(ULONG Index, WCHAR ** ppszValueName);
};
//--- ISpRegDataKey ---------------------------------------------------------
[
object,
uuid(92A66E2B-C830-4149-83DF-6FC2BA1E7A5B),
helpstring("ISpRegDataKey"),
pointer_default(unique),
restricted
]
interface ISpRegDataKey : ISpDataKey
{
[local] HRESULT SetKey([in] HKEY hkey, [in] BOOL fReadOnly);
}
//--- ISpObjectTokenCategory ------------------------------------------------
[
object,
uuid(2D3D3845-39AF-4850-BBF9-40B49780011D),
helpstring("ISpObjectTokenCategory"),
pointer_default(unique),
restricted
]
interface ISpObjectTokenCategory : ISpDataKey
{
HRESULT SetId([in] const WCHAR * pszCategoryId, BOOL fCreateIfNotExist);
HRESULT GetId([out] WCHAR ** ppszCoMemCategoryId);
HRESULT GetDataKey(SPDATAKEYLOCATION spdkl, ISpDataKey ** ppDataKey);
HRESULT EnumTokens(
[in, string] const WCHAR * pzsReqAttribs,
[in, string] const WCHAR * pszOptAttribs,
[out] IEnumSpObjectTokens ** ppEnum);
HRESULT SetDefaultTokenId([in] const WCHAR * pszTokenId);
HRESULT GetDefaultTokenId([out] WCHAR ** ppszCoMemTokenId);
};
//--- ISpObjectToken --------------------------------------------------------
[
object,
uuid(14056589-E16C-11D2-BB90-00C04F8EE6C0),
helpstring("ISpObjectToken Interface"),
pointer_default(unique),
restricted
]
interface ISpObjectToken : ISpDataKey
{
HRESULT SetId(const WCHAR * pszCategoryId, const WCHAR * pszTokenId, BOOL fCreateIfNotExist);
HRESULT GetId(WCHAR ** ppszCoMemTokenId);
HRESULT GetCategory(ISpObjectTokenCategory ** ppTokenCategory);
HRESULT CreateInstance(
[in] IUnknown * pUnkOuter,
[in] DWORD dwClsContext,
[in] REFIID riid,
[out, iid_is(riid)] void ** ppvObject);
HRESULT GetStorageFileName(
[in] REFCLSID clsidCaller,
[in] const WCHAR * pszValueName,
[in] const WCHAR * pszFileNameSpecifier,
[in] ULONG nFolder, // Same as SHGetFolderPath -- If non-zero, must set CSIDL_FLAG_CREATE
[out] WCHAR ** ppszFilePath);
HRESULT RemoveStorageFileName(
[in] REFCLSID clsidCaller,
[in] const WCHAR * pszKeyName,
[in] BOOL fDeleteFile);
HRESULT Remove(const CLSID * pclsidCaller);
[local] HRESULT IsUISupported(
[in] const WCHAR * pszTypeOfUI,
[in] void * pvExtraData,
[in] ULONG cbExtraData,
[in] IUnknown * punkObject,
[out] BOOL *pfSupported);
[local] HRESULT DisplayUI(
[in] HWND hwndParent,
[in] const WCHAR * pszTitle,
[in] const WCHAR * pszTypeOfUI,
[in] void * pvExtraData,
[in] ULONG cbExtraData,
[in] IUnknown * punkObject);
HRESULT MatchesAttributes(
[in] const WCHAR * pszAttributes,
[out] BOOL *pfMatches);
};
[
object,
uuid(B8AAB0CF-346F-49D8-9499-C8B03F161D51),
helpstring("ISpObjectTokenInit Interface"),
pointer_default(unique),
restricted
]
interface ISpObjectTokenInit : ISpObjectToken
{
HRESULT InitFromDataKey(
[in] const WCHAR * pszCategoryId,
[in] const WCHAR * pszTokenId,
[in] ISpDataKey * pDataKey);
};
//--- IEnumSpObjectTokens ---------------------------------------------------
// This interface is used to enumerate speech object tokens
[
object,
uuid(06B64F9E-7FDA-11D2-B4F2-00C04F797396),
helpstring("IEnumSpObjectTokens Interface"),
pointer_default(unique),
restricted
]
interface IEnumSpObjectTokens : IUnknown
{
HRESULT Next([in] ULONG celt,
[out, size_is(celt), length_is(*pceltFetched)] ISpObjectToken ** pelt,
[out] ULONG *pceltFetched);
HRESULT Skip([in] ULONG celt);
HRESULT Reset(void);
HRESULT Clone([out] IEnumSpObjectTokens **ppEnum);
HRESULT Item([in] ULONG Index, [out] ISpObjectToken ** ppToken);
HRESULT GetCount([out] ULONG* pCount);
};
//--- ISpObjectWithToken ----------------------------------------------------
[
object,
uuid(5B559F40-E952-11D2-BB91-00C04F8EE6C0),
helpstring("ISpObjectWithToken Interface"),
pointer_default(unique),
restricted
]
interface ISpObjectWithToken : IUnknown
{
HRESULT SetObjectToken(ISpObjectToken * pToken);
HRESULT GetObjectToken(ISpObjectToken ** ppToken);
};
//--- ISpResourceManager ----------------------------------------------------
[
object,
uuid(93384E18-5014-43D5-ADBB-A78E055926BD),
helpstring("ISpResourceManager Interface"),
pointer_default(unique),
restricted
]
#ifdef _WIN32_WCE
interface ISpResourceManager : IUnknown //IServiceProvider
#else
interface ISpResourceManager : IServiceProvider
#endif // _WIN32_WCE
{
HRESULT SetObject(
[in] REFGUID guidServiceId,
[in] IUnknown *pUnkObject);
HRESULT GetObject(
[in] REFGUID guidServiceId,
[in] REFCLSID ObjectCLSID,
[in] REFIID ObjectIID,
[in] BOOL fReleaseWhenLastExternalRefReleased,
[out, iid_is(ObjectIID)] void** ppObject);
};
//--- ISpEventSource --------------------------------------------------------
typedef [hidden] enum SPEVENTLPARAMTYPE
{
SPET_LPARAM_IS_UNDEFINED = 0,
SPET_LPARAM_IS_TOKEN,
SPET_LPARAM_IS_OBJECT,
SPET_LPARAM_IS_POINTER,
SPET_LPARAM_IS_STRING,
} SPEVENTLPARAMTYPE;
typedef [hidden] enum SPEVENTENUM
{
SPEI_UNDEFINED = 0,
//--- TTS engine
SPEI_START_INPUT_STREAM = 1,
SPEI_END_INPUT_STREAM = 2,
SPEI_VOICE_CHANGE = 3, // LPARAM_IS_TOKEN
SPEI_TTS_BOOKMARK = 4, // LPARAM_IS_STRING
SPEI_WORD_BOUNDARY = 5,
SPEI_PHONEME = 6,
SPEI_SENTENCE_BOUNDARY = 7,
SPEI_VISEME = 8,
SPEI_TTS_AUDIO_LEVEL = 9, // wParam contains current output audio level
//--- Engine vendors use these reserved bits
SPEI_TTS_PRIVATE = 15,
SPEI_MIN_TTS = 1,
SPEI_MAX_TTS = 15,
//--- Speech Recognition
SPEI_END_SR_STREAM = 34, // LPARAM contains HRESULT, WPARAM contains flags (SPESF_xxx)
SPEI_SOUND_START = 35,
SPEI_SOUND_END = 36,
SPEI_PHRASE_START = 37,
SPEI_RECOGNITION = 38,
SPEI_HYPOTHESIS = 39,
SPEI_SR_BOOKMARK = 40,
SPEI_PROPERTY_NUM_CHANGE = 41, // LPARAM points to a string, WPARAM is the attrib value
SPEI_PROPERTY_STRING_CHANGE= 42, // LPARAM pointer to buffer. Two concatinated null terminated strings.
SPEI_FALSE_RECOGNITION = 43, // apparent speech with no valid recognition
SPEI_INTERFERENCE = 44, // LPARAM is any combination of SPINTERFERENCE flags
SPEI_REQUEST_UI = 45, // LPARAM is string.
SPEI_RECO_STATE_CHANGE = 46, // wParam contains new reco state
SPEI_ADAPTATION = 47, // we are now ready to accept the adaptation buffer
SPEI_START_SR_STREAM = 48,
SPEI_RECO_OTHER_CONTEXT = 49, // Phrase finished and recognized, but for other context
SPEI_SR_AUDIO_LEVEL = 50, // wParam contains current input audio level
//--- Engine vendors use these reserved bits
SPEI_SR_PRIVATE = 52,
SPEI_MIN_SR = 34,
SPEI_MAX_SR = 52,
SPEI_RESERVED1 = 30, // do not use
SPEI_RESERVED2 = 33, // do not use
SPEI_RESERVED3 = 63 // do not use
} SPEVENTENUM;
cpp_quote("#define SPFEI_FLAGCHECK ( (1ui64 << SPEI_RESERVED1) | (1ui64 << SPEI_RESERVED2) )")
cpp_quote("#define SPFEI_ALL_TTS_EVENTS (0x000000000000FFFEui64 | SPFEI_FLAGCHECK)")
cpp_quote("#define SPFEI_ALL_SR_EVENTS (0x001FFFFC00000000ui64 | SPFEI_FLAGCHECK)")
cpp_quote("#define SPFEI_ALL_EVENTS 0xEFFFFFFFFFFFFFFFui64")
// The SPFEI macro converts an SPEVENTENUM event value into a 64-bit value.
// Multiple values can then be OR-ed together and passed to SetInterest.
cpp_quote("#define SPFEI(SPEI_ord) ((1ui64 << SPEI_ord) | SPFEI_FLAGCHECK)")
// SPEVENT is defined 2 ways, because the current version of MIDL does not allow enumerations
// to be used as bit fields. So we define eEventId and elParamType as int bitfields for MIDL
// and redefine them as their appropriate enumerations for C++
cpp_quote("#if 0")
typedef [restricted, hidden] struct SPEVENT
{
WORD eEventId; //SPEVENTENUM
WORD elParamType; //SPEVENTLPARAMTYPE
ULONG ulStreamNum; // Input stream number this event is associated with
ULONGLONG ullAudioStreamOffset;
WPARAM wParam;
LPARAM lParam;
} SPEVENT;
typedef [restricted, hidden] struct SPSERIALIZEDEVENT
{
WORD eEventId; //SPEVENTENUM
WORD elParamType; //SPEVENTLPARAMTYPE
ULONG ulStreamNum; // Input stream number this event is associated with
ULONGLONG ullAudioStreamOffset;
ULONG SerializedwParam;
LONG SerializedlParam;
} SPSERIALIZEDEVENT;
typedef [restricted, hidden] struct SPSERIALIZEDEVENT64
{
WORD eEventId; //SPEVENTENUM
WORD elParamType; //SPEVENTLPARAMTYPE
ULONG ulStreamNum; // Input stream number this event is associated with
ULONGLONG ullAudioStreamOffset;
ULONGLONG SerializedwParam;
LONGLONG SerializedlParam;
} SPSERIALIZEDEVENT64;
cpp_quote("#else")
cpp_quote("typedef struct SPEVENT")
cpp_quote("{")
cpp_quote(" SPEVENTENUM eEventId : 16;")
cpp_quote(" SPEVENTLPARAMTYPE elParamType : 16;")
cpp_quote(" ULONG ulStreamNum;")
cpp_quote(" ULONGLONG ullAudioStreamOffset;")
cpp_quote(" WPARAM wParam;")
cpp_quote(" LPARAM lParam;")
cpp_quote("} SPEVENT;")
cpp_quote("typedef struct SPSERIALIZEDEVENT")
cpp_quote("{")
cpp_quote(" SPEVENTENUM eEventId : 16;")
cpp_quote(" SPEVENTLPARAMTYPE elParamType : 16;")
cpp_quote(" ULONG ulStreamNum;")
cpp_quote(" ULONGLONG ullAudioStreamOffset;")
cpp_quote(" ULONG SerializedwParam;")
cpp_quote(" LONG SerializedlParam;")
cpp_quote("} SPSERIALIZEDEVENT;")
cpp_quote("typedef struct SPSERIALIZEDEVENT64")
cpp_quote("{")
cpp_quote(" SPEVENTENUM eEventId : 16;")
cpp_quote(" SPEVENTLPARAMTYPE elParamType : 16;")
cpp_quote(" ULONG ulStreamNum;")
cpp_quote(" ULONGLONG ullAudioStreamOffset;")
cpp_quote(" ULONGLONG SerializedwParam;")
cpp_quote(" LONGLONG SerializedlParam;")
cpp_quote("} SPSERIALIZEDEVENT64;")
cpp_quote("#endif")
//--- Types of interference
typedef [hidden] enum SPINTERFERENCE
{
SPINTERFERENCE_NONE = 0,
SPINTERFERENCE_NOISE,
SPINTERFERENCE_NOSIGNAL,
SPINTERFERENCE_TOOLOUD,
SPINTERFERENCE_TOOQUIET,
SPINTERFERENCE_TOOFAST,
SPINTERFERENCE_TOOSLOW
} SPINTERFERENCE;
//--- Flags for END_SR_STREAM event (in WPARAM)
typedef [hidden] enum SPENDSRSTREAMFLAGS
{
SPESF_NONE = 0,
SPESF_STREAM_RELEASED = (1 << 0)
} SPENDSRSTREAMFLAGS;
//--- Viseme features
typedef [hidden] enum SPVFEATURE
{
SPVFEATURE_STRESSED = (1L << 0),
SPVFEATURE_EMPHASIS = (1L << 1)
} SPVFEATURE;
//--- Viseme event groups
typedef [hidden] enum SPVISEMES
{
// English examples
//------------------
SP_VISEME_0 = 0, // Silence
SP_VISEME_1, // AE, AX, AH
SP_VISEME_2, // AA
SP_VISEME_3, // AO
SP_VISEME_4, // EY, EH, UH
SP_VISEME_5, // ER
SP_VISEME_6, // y, IY, IH, IX
SP_VISEME_7, // w, UW
SP_VISEME_8, // OW
SP_VISEME_9, // AW
SP_VISEME_10, // OY
SP_VISEME_11, // AY
SP_VISEME_12, // h
SP_VISEME_13, // r
SP_VISEME_14, // l
SP_VISEME_15, // s, z
SP_VISEME_16, // SH, CH, JH, ZH
SP_VISEME_17, // TH, DH
SP_VISEME_18, // f, v
SP_VISEME_19, // d, t, n
SP_VISEME_20, // k, g, NG
SP_VISEME_21, // p, b, m
} SPVISEMES;
typedef [restricted, hidden] struct SPEVENTSOURCEINFO
{
ULONGLONG ullEventInterest;
ULONGLONG ullQueuedInterest;
ULONG ulCount;
} SPEVENTSOURCEINFO;
[
object,
uuid(BE7A9CCE-5F9E-11D2-960F-00C04F8EE628),
helpstring("ISpEventSource Interface"),
pointer_default(unique),
local,
restricted
]
interface ISpEventSource : ISpNotifySource
{
// It is neccessary to use the SPFEI macro to convert the
// SPEVENTENUM values into ULONGULONG values.
HRESULT SetInterest(
[in] ULONGLONG ullEventInterest,
[in] ULONGLONG ullQueuedInterest);
HRESULT GetEvents(
[in] ULONG ulCount,
[out, size_is(ulCount)] SPEVENT* pEventArray,
[out] ULONG *pulFetched);
HRESULT GetInfo([out] SPEVENTSOURCEINFO * pInfo);
};
//--- ISpEventSink ---------------------------------------------------------
[
object,
uuid(BE7A9CC9-5F9E-11D2-960F-00C04F8EE628),
helpstring("ISpEventSink Interface"),
pointer_default(unique),
local,
restricted
]
interface ISpEventSink : IUnknown
{
HRESULT AddEvents([in] const SPEVENT* pEventArray, [in] ULONG ulCount);
HRESULT GetEventInterest([out] ULONGLONG * pullEventInterest);
};
//--- ISpStreamFormat -------------------------------------------------------
[
object,
uuid(BED530BE-2606-4F4D-A1C0-54C5CDA5566F),
helpstring("ISpStreamFormat Interface"),
pointer_default(unique),
restricted
]
interface ISpStreamFormat : IStream
{
HRESULT GetFormat(GUID * pguidFormatId, WAVEFORMATEX ** ppCoMemWaveFormatEx);
}
typedef [hidden] enum SPFILEMODE
{
SPFM_OPEN_READONLY, // Open existing file, read-only
SPFM_OPEN_READWRITE, // (Not supported for wav files) Open existing file, read-write
SPFM_CREATE, // (Not supported for wav files) Open file if exists, else create if does not exist (opens read-write)
SPFM_CREATE_ALWAYS, // Create file even if file exists. Destroys old file.
SPFM_NUM_MODES // Used for limit checking
} SPFILEMODE;
//--- ISpStream -------------------------------------------------------------
[
object,
uuid(12E3CCA9-7518-44C5-A5E7-BA5A79CB929E),
helpstring("ISpStream Interface"),
pointer_default(unique),
restricted
]
interface ISpStream : ISpStreamFormat
{
HRESULT SetBaseStream(IStream * pStream, REFGUID rguidFormat, const WAVEFORMATEX * pWaveFormatEx);
HRESULT GetBaseStream(IStream ** ppStream);
HRESULT BindToFile(const WCHAR * pszFileName, SPFILEMODE eMode,
const GUID * pFormatId, const WAVEFORMATEX * pWaveFormatEx,
ULONGLONG ullEventInterest);
HRESULT Close();
}
//--- ISpStreamFormatConverter ----------------------------------------------
[
object,
uuid(678A932C-EA71-4446-9B41-78FDA6280A29),
helpstring("ISpStreamFormatConverter Interface"),
pointer_default(unique),
restricted
]
interface ISpStreamFormatConverter : ISpStreamFormat
{
HRESULT SetBaseStream(
[in] ISpStreamFormat * pStream,
[in] BOOL fSetFormatToBaseStreamFormat, // If true, then format of format converter stream
[in] BOOL fWriteToBaseStream ); // will be set to same format as bass stream
// (set up as a pass-through). If pStream == NULL
// and this is set to TRUE, then format of stream is reset
HRESULT GetBaseStream([out] ISpStreamFormat **ppStream);
HRESULT SetFormat([in] REFGUID rguidFormatIdOfConvertedStream, [in] const WAVEFORMATEX * pWaveFormatExOfConvertedStream);
// Note: GetFormat method of ISpStreamFormat returns the format of the converted stream.
HRESULT ResetSeekPosition();
HRESULT ScaleConvertedToBaseOffset(
[in] ULONGLONG ullOffsetConvertedStream,
[out] ULONGLONG * pullOffsetBaseStream);
HRESULT ScaleBaseToConvertedOffset(
[in] ULONGLONG ullOffsetBaseStream,
[out] ULONGLONG * pullOffsetConvertedStream);
};
//--- ISpAudio --------------------------------------------------------------
typedef [hidden] enum _SPAUDIOSTATE
{
SPAS_CLOSED,
SPAS_STOP,
SPAS_PAUSE,
SPAS_RUN
} SPAUDIOSTATE;
typedef [restricted, hidden] struct SPAUDIOSTATUS
{
long cbFreeBuffSpace;
ULONG cbNonBlockingIO;
SPAUDIOSTATE State;
ULONGLONG CurSeekPos;
ULONGLONG CurDevicePos;
DWORD dwReserved1;
DWORD dwReserved2;
} SPAUDIOSTATUS;
typedef [restricted, hidden] struct SPAUDIOBUFFERINFO
{
ULONG ulMsMinNotification;
ULONG ulMsBufferSize;
ULONG ulMsEventBias;
} SPAUDIOBUFFERINFO;
[
object,
uuid(C05C768F-FAE8-4EC2-8E07-338321C12452),
helpstring("ISpAudio Interface"),
pointer_default(unique),
local,
restricted
]
interface ISpAudio : ISpStreamFormat
{
HRESULT SetState([in] SPAUDIOSTATE NewState, [in]ULONGLONG ullReserved );
HRESULT SetFormat([in] REFGUID rguidFmtId, [in] const WAVEFORMATEX * pWaveFormatEx);
HRESULT GetStatus([out] SPAUDIOSTATUS * pStatus);
HRESULT SetBufferInfo([in] const SPAUDIOBUFFERINFO * pBuffInfo);
HRESULT GetBufferInfo([out] SPAUDIOBUFFERINFO * pBuffInfo);
HRESULT GetDefaultFormat([out] GUID * pFormatId, [out] WAVEFORMATEX ** ppCoMemWaveFormatEx);
HANDLE EventHandle();
HRESULT GetVolumeLevel([out] ULONG *pLevel);
HRESULT SetVolumeLevel([in] ULONG Level);
HRESULT GetBufferNotifySize([out] ULONG *pcbSize);
HRESULT SetBufferNotifySize([in] ULONG cbSize);
};
//--- ISpMMSysAudio ---------------------------------------------------------
[
object,
uuid(15806F6E-1D70-4B48-98E6-3B1A007509AB),
helpstring("ISpMMSysAudio Interface"),
pointer_default(unique),
local,
restricted
]
interface ISpMMSysAudio : ISpAudio
{
HRESULT GetDeviceId([out] UINT * puDeviceId);
HRESULT SetDeviceId([in] UINT uDeviceId);
HRESULT GetMMHandle(void ** pHandle);
HRESULT GetLineId([out] UINT *puLineId);
HRESULT SetLineId([in] UINT uLineId);
};
//--- ISpTranscript ---------------------------------------------------------
[
object,
uuid(10F63BCE-201A-11D3-AC70-00C04F8EE6C0),
helpstring("ISpTranscript Interface"),
pointer_default(unique),
restricted
]
interface ISpTranscript : IUnknown
{
HRESULT GetTranscript([out, string] WCHAR ** ppszTranscript);
HRESULT AppendTranscript([in, string] const WCHAR * pszTranscript);
};
//--- Structures used by ISpPhrase interface --------------------------------
typedef [hidden] enum SPDISPLYATTRIBUTES
{
SPAF_ONE_TRAILING_SPACE = 0x02,
SPAF_TWO_TRAILING_SPACES = 0x04,
SPAF_CONSUME_LEADING_SPACES = 0x08,
SPAF_ALL = 0x0F
} SPDISPLAYATTRIBUTES;
typedef unsigned short SPPHONEID;
typedef [restricted, hidden] struct SPPHRASEELEMENT
{
ULONG ulAudioTimeOffset;
ULONG ulAudioSizeTime; // In 100ns units
ULONG ulAudioStreamOffset;
ULONG ulAudioSizeBytes;
ULONG ulRetainedStreamOffset;
ULONG ulRetainedSizeBytes;
const WCHAR * pszDisplayText;
const WCHAR * pszLexicalForm;
const SPPHONEID * pszPronunciation;
BYTE bDisplayAttributes;
signed char RequiredConfidence;
signed char ActualConfidence;
BYTE Reserved;
float SREngineConfidence;
} SPPHRASEELEMENT;
typedef [restricted, hidden] struct SPPHRASERULE SPPHRASERULE;
[hidden] struct SPPHRASERULE
{
const WCHAR * pszName;
ULONG ulId;
ULONG ulFirstElement;
ULONG ulCountOfElements;
const SPPHRASERULE * pNextSibling;
const SPPHRASERULE * pFirstChild;
float SREngineConfidence;
signed char Confidence;
};
typedef [restricted, hidden] struct SPPHRASEPROPERTY SPPHRASEPROPERTY;
[hidden] struct SPPHRASEPROPERTY
{
const WCHAR * pszName;
ULONG ulId;
const WCHAR * pszValue;
VARIANT vValue; // Will be VT_BOOL, VT_I4, VT_R4, VT_R8, or VT_BYREF (only for dynamic grammars)
ULONG ulFirstElement;
ULONG ulCountOfElements;
const SPPHRASEPROPERTY* pNextSibling;
const SPPHRASEPROPERTY* pFirstChild;
float SREngineConfidence;
signed char Confidence;
};
typedef [restricted, hidden] struct SPPHRASEREPLACEMENT
{
BYTE bDisplayAttributes;
const WCHAR * pszReplacementText;
ULONG ulFirstElement;
ULONG ulCountOfElements;
} SPPHRASEREPLACEMENT;
typedef [restricted, hidden] struct SPPHRASE
{
ULONG cbSize; // Size of structure
LANGID LangID;
WORD wReserved;
ULONGLONG ullGrammarID;
ULONGLONG ftStartTime;
ULONGLONG ullAudioStreamPosition;
ULONG ulAudioSizeBytes;
ULONG ulRetainedSizeBytes;
ULONG ulAudioSizeTime; // In 100ns units
SPPHRASERULE Rule;
const SPPHRASEPROPERTY* pProperties;
const SPPHRASEELEMENT * pElements;
ULONG cReplacements;
const SPPHRASEREPLACEMENT * pReplacements;
GUID SREngineID;
ULONG ulSREnginePrivateDataSize;
const BYTE * pSREnginePrivateData;
} SPPHRASE;
//--- Serialized phrase
typedef [restricted, hidden] struct SPSERIALIZEDPHRASE
{
ULONG ulSerializedSize; // Size of structure in bytes
} SPSERIALIZEDPHRASE;
typedef [hidden] enum SPVALUETYPE
{
SPDF_PROPERTY = 0x00000001,
SPDF_REPLACEMENT = 0x00000002,
SPDF_RULE = 0x00000004,
SPDF_DISPLAYTEXT = 0x00000008,
SPDF_LEXICALFORM = 0x00000010,
SPDF_PRONUNCIATION = 0x00000020,
SPDF_AUDIO = 0x00000040,
SPDF_ALTERNATES = 0x00000080,
SPDF_ALL = 0x000000FF
} SPVALUETYPE;
// Binary grammar public declaration
typedef [hidden] struct SPBINARYGRAMMAR
{
ULONG ulTotalSerializedSize;
} SPBINARYGRAMMAR;
// Possible arguments for methods that take phrase element start and count
typedef [hidden] enum SPPHRASERNG
{
SPPR_ALL_ELEMENTS = -1
} SPPHRASERNG;
cpp_quote("#define SP_GETWHOLEPHRASE SPPR_ALL_ELEMENTS")
cpp_quote("#define SPRR_ALL_ELEMENTS SPPR_ALL_ELEMENTS")
cpp_quote("#if 0")
typedef void * SPSTATEHANDLE;
cpp_quote("#else")
cpp_quote("DECLARE_HANDLE(SPSTATEHANDLE);")
cpp_quote("#endif")
typedef [hidden] enum SPRECOEVENTFLAGS
{
SPREF_AutoPause = (1 << 0),
SPREF_Emulated = (1 << 1)
} SPRECOEVENTFLAGS;
//--- ISpLexicon ------------------------------------------------------------
typedef [hidden] enum SPPARTOFSPEECH
{
//--- SAPI5 public POS category values (bits 28-31)
SPPS_NotOverriden = -1,
SPPS_Unknown = 0,
SPPS_Noun = 0x1000,
SPPS_Verb = 0x2000,
SPPS_Modifier = 0x3000,
SPPS_Function = 0x4000,
SPPS_Interjection = 0x5000
} SPPARTOFSPEECH;
typedef [hidden] enum SPLEXICONTYPE
{
eLEXTYPE_USER = (1L << 0),
eLEXTYPE_APP = (1L << 1),
eLEXTYPE_RESERVED1 = (1L << 2),
eLEXTYPE_RESERVED2 = (1L << 3),
eLEXTYPE_RESERVED3 = (1L << 4),
eLEXTYPE_RESERVED4 = (1L << 5),
eLEXTYPE_RESERVED5 = (1L << 6),
eLEXTYPE_RESERVED6 = (1L << 7),
eLEXTYPE_RESERVED7 = (1L << 8),
eLEXTYPE_RESERVED8 = (1L << 9),
eLEXTYPE_RESERVED9 = (1L << 10),
eLEXTYPE_RESERVED10 = (1L << 11),
eLEXTYPE_PRIVATE1 = (1L << 12),
eLEXTYPE_PRIVATE2 = (1L << 13),
eLEXTYPE_PRIVATE3 = (1L << 14),
eLEXTYPE_PRIVATE4 = (1L << 15),
eLEXTYPE_PRIVATE5 = (1L << 16),
eLEXTYPE_PRIVATE6 = (1L << 17),
eLEXTYPE_PRIVATE7 = (1L << 18),
eLEXTYPE_PRIVATE8 = (1L << 19),
eLEXTYPE_PRIVATE9 = (1L << 20),
eLEXTYPE_PRIVATE10 = (1L << 21),
eLEXTYPE_PRIVATE11 = (1L << 22),
eLEXTYPE_PRIVATE12 = (1L << 23),
eLEXTYPE_PRIVATE13 = (1L << 24),
eLEXTYPE_PRIVATE14 = (1L << 25),
eLEXTYPE_PRIVATE15 = (1L << 26),
eLEXTYPE_PRIVATE16 = (1L << 27),
eLEXTYPE_PRIVATE17 = (1L << 28),
eLEXTYPE_PRIVATE18 = (1L << 29),
eLEXTYPE_PRIVATE19 = (1L << 30),
eLEXTYPE_PRIVATE20 = (1L << 31),
} SPLEXICONTYPE;
typedef [hidden] enum SPWORDTYPE
{
eWORDTYPE_ADDED = (1L << 0),
eWORDTYPE_DELETED = (1L << 1)
} SPWORDTYPE;
typedef [restricted, hidden] struct SPWORDPRONUNCIATION
{
struct SPWORDPRONUNCIATION * pNextWordPronunciation;
SPLEXICONTYPE eLexiconType;
LANGID LangID;
WORD wReserved;
SPPARTOFSPEECH ePartOfSpeech;
SPPHONEID szPronunciation[1];
} SPWORDPRONUNCIATION;
typedef [restricted, hidden] struct SPWORDPRONUNCIATIONLIST
{
ULONG ulSize;
BYTE * pvBuffer;
SPWORDPRONUNCIATION * pFirstWordPronunciation;
} SPWORDPRONUNCIATIONLIST;
typedef [restricted, hidden] struct SPWORD
{
struct SPWORD * pNextWord;
LANGID LangID;
WORD wReserved;
SPWORDTYPE eWordType;
WCHAR * pszWord;
SPWORDPRONUNCIATION * pFirstWordPronunciation;
} SPWORD;
typedef [restricted, hidden] struct SPWORDLIST
{
ULONG ulSize;
BYTE * pvBuffer;
SPWORD * pFirstWord;
} SPWORDLIST;
[
object,
uuid(DA41A7C2-5383-4DB2-916B-6C1719E3DB58),
helpstring("ISpLexicon Interface"),
pointer_default(unique),
restricted
]
interface ISpLexicon : IUnknown
{
HRESULT GetPronunciations(
[in] const WCHAR * pszWord,
[in] LANGID LangID,
[in] DWORD dwFlags,
[in, out] SPWORDPRONUNCIATIONLIST * pWordPronunciationList
);
HRESULT AddPronunciation(
[in] const WCHAR * pszWord,
[in] LANGID LangID,
[in] SPPARTOFSPEECH ePartOfSpeech,
[in] const SPPHONEID * pszPronunciation
);
HRESULT RemovePronunciation(
[in] const WCHAR * pszWord,
[in] LANGID LangID,
[in] SPPARTOFSPEECH ePartOfSpeech,
[in] const SPPHONEID * pszPronunciation
);
HRESULT GetGeneration(DWORD *pdwGeneration);
HRESULT GetGenerationChange(
[in] DWORD dwFlags,
[in, out] DWORD *pdwGeneration,
[in, out] SPWORDLIST * pWordList
);
HRESULT GetWords(
[in] DWORD dwFlags,
[in, out] DWORD *pdwGeneration,
[in, out] DWORD * pdwCookie,
[in, out] SPWORDLIST *pWordList
);
};
[
object,
uuid(8565572F-C094-41CC-B56E-10BD9C3FF044),
helpstring("ISpContainerLexicon Interface"),
pointer_default(unique),
restricted
]
interface ISpContainerLexicon : ISpLexicon
{
HRESULT AddLexicon([in] ISpLexicon *pAddLexicon, [in] DWORD dwFlags);
};
//--- ISpPhoneConverter -----------------------------------------------------
[
object,
uuid(8445C581-0CAC-4A38-ABFE-9B2CE2826455),
helpstring("ISpPhoneConverter Interface"),
pointer_default(unique),
restricted
]
interface ISpPhoneConverter : ISpObjectWithToken
{
HRESULT PhoneToId([in] const WCHAR * pszPhone, [out] SPPHONEID * pId);
HRESULT IdToPhone([in] const SPPHONEID * pId, [out] WCHAR * pszPhone);
};
//--- ISpVoice --------------------------------------------------------------
// These structures maintain the absolute state of the voice relative to
// the voice's baseline XML state.
typedef [restricted, hidden] struct SPVPITCH
{
long MiddleAdj;
long RangeAdj;
} SPVPITCH;
typedef [hidden] enum SPVACTIONS
{
SPVA_Speak = 0,
SPVA_Silence,
SPVA_Pronounce,
SPVA_Bookmark,
SPVA_SpellOut,
SPVA_Section,
SPVA_ParseUnknownTag
} SPVACTIONS;
typedef [restricted, hidden] struct SPVCONTEXT
{
LPCWSTR pCategory;
LPCWSTR pBefore;
LPCWSTR pAfter;
} SPVCONTEXT;
typedef [restricted, hidden] struct SPVSTATE
{
//--- Action
SPVACTIONS eAction;
//--- Running state values
LANGID LangID;
WORD wReserved;
long EmphAdj;
long RateAdj;
ULONG Volume;
SPVPITCH PitchAdj;
ULONG SilenceMSecs;
SPPHONEID* pPhoneIds; // NULL terminated array of phone ids
SPPARTOFSPEECH ePartOfSpeech;
SPVCONTEXT Context;
} SPVSTATE;
typedef [hidden] enum SPRUNSTATE
{
SPRS_DONE = (1L << 0), // The voice is done rendering all queued phrases
SPRS_IS_SPEAKING = (1L << 1) // The SpVoice currently has the audio queue claimed
} SPRUNSTATE;
typedef [hidden] enum SPVLIMITS
{
SPMIN_VOLUME = 0,
SPMAX_VOLUME = 100,
SPMIN_RATE = -10,
SPMAX_RATE = 10
} SPVLIMITS;
typedef [hidden] enum SPVPRIORITY
{
SPVPRI_NORMAL = 0,
SPVPRI_ALERT = (1L << 0),
SPVPRI_OVER = (1L << 1)
} SPVPRIORITY;
typedef [restricted, hidden] struct SPVOICESTATUS
{
ULONG ulCurrentStream; // Current stream being rendered
ULONG ulLastStreamQueued; // Number of the last stream queued
HRESULT hrLastResult; // Result of last speak
DWORD dwRunningState; // SPRUNSTATE
ULONG ulInputWordPos; // Input position of current word being rendered
ULONG ulInputWordLen; // Length of current word being rendered
ULONG ulInputSentPos; // Input position of current sentence being rendered
ULONG ulInputSentLen; // Length of current sentence being rendered
LONG lBookmarkId; // Current bookmark converted to a long integer
SPPHONEID PhonemeId; // Current phoneme id
SPVISEMES VisemeId; // Current viseme
DWORD dwReserved1; // Reserved for future expansion
DWORD dwReserved2; // Reserved for future expansion
} SPVOICESTATUS;
typedef [hidden] enum SPEAKFLAGS
{
//--- SpVoice flags
SPF_DEFAULT = 0, // Synchronous, no purge, xml auto detect
SPF_ASYNC = (1L << 0), // Asynchronous call
SPF_PURGEBEFORESPEAK = (1L << 1), // Purge current data prior to speaking this
SPF_IS_FILENAME = (1L << 2), // The string passed to Speak() is a file name
SPF_IS_XML = (1L << 3), // The input text will be parsed for XML markup
SPF_IS_NOT_XML = (1L << 4), // The input text will not be parsed for XML markup
SPF_PERSIST_XML = (1L << 5), // Persists XML global state changes
//--- Normalizer flags
SPF_NLP_SPEAK_PUNC = (1L << 6), // The normalization processor should speak the punctuation
//--- Masks
SPF_NLP_MASK = (SPF_NLP_SPEAK_PUNC),
SPF_VOICE_MASK = (SPF_ASYNC|SPF_PURGEBEFORESPEAK|SPF_IS_FILENAME|SPF_IS_XML|SPF_IS_NOT_XML|SPF_NLP_MASK|SPF_PERSIST_XML),
SPF_UNUSED_FLAGS = ~(SPF_VOICE_MASK)
} SPEAKFLAGS;
[
object,
uuid(6C44DF74-72B9-4992-A1EC-EF996E0422D4),
helpstring("ISpVoice Interface"),
pointer_default(unique),
restricted
]
interface ISpVoice : ISpEventSource
{
HRESULT SetOutput( [in] IUnknown * pUnkOutput, [in]BOOL fAllowFormatChanges );
HRESULT GetOutputObjectToken( [out] ISpObjectToken ** ppObjectToken );
HRESULT GetOutputStream( [out] ISpStreamFormat ** ppStream );
HRESULT Pause( void );
HRESULT Resume( void );
HRESULT SetVoice([in] ISpObjectToken *pToken);
HRESULT GetVoice([out] ISpObjectToken **ppToken);
HRESULT Speak(
[in, string] const WCHAR* pwcs,
[in] DWORD dwFlags,
[out] ULONG * pulStreamNumber);
HRESULT SpeakStream(
[in] IStream* pStream, // If not ISpStreamFormat supported then SPDFID_Text assumed
[in] DWORD dwFlags,
[out] ULONG * pulStreamNumber);
HRESULT GetStatus(
[out] SPVOICESTATUS *pStatus,
[out, string] WCHAR ** ppszLastBookmark);
HRESULT Skip( [in,string]WCHAR* pItemType, [in]long lNumItems, [out]ULONG* pulNumSkipped );
HRESULT SetPriority([in] SPVPRIORITY ePriority );
HRESULT GetPriority([out] SPVPRIORITY* pePriority );
HRESULT SetAlertBoundary( [in] SPEVENTENUM eBoundary );
HRESULT GetAlertBoundary( [out] SPEVENTENUM* peBoundary );
HRESULT SetRate([in] long RateAdjust );
HRESULT GetRate([out] long* pRateAdjust);
HRESULT SetVolume([in] USHORT usVolume);
HRESULT GetVolume([out] USHORT* pusVolume);
HRESULT WaitUntilDone([in] ULONG msTimeout);
HRESULT SetSyncSpeakTimeout([in] ULONG msTimeout);
HRESULT GetSyncSpeakTimeout([out] ULONG * pmsTimeout);
[local] HANDLE SpeakCompleteEvent();
[local] HRESULT IsUISupported(
[in] const WCHAR * pszTypeOfUI,
[in] void * pvExtraData,
[in] ULONG cbExtraData,
[out] BOOL *pfSupported);
[local] HRESULT DisplayUI(
[in] HWND hwndParent,
[in] const WCHAR * pszTitle,
[in] const WCHAR * pszTypeOfUI,
[in] void * pvExtraData,
[in] ULONG cbExtraData);
};
//--- ISpPhrase interface ---------------------------------------------------
[
object,
uuid(1A5C0354-B621-4b5a-8791-D306ED379E53),
local,
helpstring("ISpPhrase Interface"),
pointer_default(unique),
restricted
]
interface ISpPhrase : IUnknown
{
HRESULT GetPhrase([out] SPPHRASE ** ppCoMemPhrase);
HRESULT GetSerializedPhrase([out] SPSERIALIZEDPHRASE ** ppCoMemPhrase);
HRESULT GetText([in] ULONG ulStart, [in] ULONG ulCount, [in] BOOL fUseTextReplacements,
[out] WCHAR ** ppszCoMemText, [out] BYTE * pbDisplayAttributes);
HRESULT Discard([in] DWORD dwValueTypes);
};
[
object,
uuid(8FCEBC98-4E49-4067-9C6C-D86A0E092E3D),
local,
helpstring("ISpPhraseAlt Interface"),
pointer_default(unique),
restricted
]
interface ISpPhraseAlt : ISpPhrase
{
HRESULT GetAltInfo(ISpPhrase **ppParent, ULONG *pulStartElementInParent, ULONG *pcElementsInParent,
ULONG *pcElementsInAlt);
HRESULT Commit();
};
//--- ISpRecoResult ---------------------------------------------------------
typedef [restricted, hidden] struct SPRECORESULTTIMES
{
FILETIME ftStreamTime; // GetSystemTimeAsFileTime() at start of result
// UTC time as number of 100-nanosecond intervals
// since January 1, 1601
ULONGLONG ullLength; // length in 100ns units
DWORD dwTickCount; // GetTickCount() at start of result
// milliseconds that have elapsed since the
// system was started.
ULONGLONG ullStart; // 100ns units since start of stream
} SPRECORESULTTIMES;
typedef [hidden] struct SPSERIALIZEDRESULT
{
ULONG ulSerializedSize; // Count in bytes (including this ULONG) of the entire phrase
} SPSERIALIZEDRESULT;
[
object,
uuid(20B053BE-E235-43cd-9A2A-8D17A48B7842),
helpstring("ISpRecoResult Interface"),
pointer_default(unique),
local,
restricted
]
interface ISpRecoResult : ISpPhrase
{
HRESULT GetResultTimes([out] SPRECORESULTTIMES *pTimes);
HRESULT GetAlternates(
[in] ULONG ulStartElement,
[in] ULONG cElements,
[in] ULONG ulRequestCount,
[out] ISpPhraseAlt **ppPhrases,
[out] ULONG *pcPhrasesReturned);
HRESULT GetAudio(
[in] ULONG ulStartElement,
[in] ULONG cElements,
[out] ISpStreamFormat **ppStream);
HRESULT SpeakAudio(
[in] ULONG ulStartElement,
[in] ULONG cElements,
[in] DWORD dwFlags,
[out] ULONG * pulStreamNumber);
HRESULT Serialize([out] SPSERIALIZEDRESULT ** ppCoMemSerializedResult);
HRESULT ScaleAudio([in] const GUID * pAudioFormatId, [in] const WAVEFORMATEX *pWaveFormatEx);
HRESULT GetRecoContext([out] ISpRecoContext ** ppRecoContext);
};
typedef [hidden] struct tagSPTEXTSELECTIONINFO
{
ULONG ulStartActiveOffset;
ULONG cchActiveChars;
ULONG ulStartSelection;
ULONG cchSelection;
} SPTEXTSELECTIONINFO;
typedef [hidden] enum SPWORDPRONOUNCEABLE
{
SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE = 0,
SPWP_UNKNOWN_WORD_PRONOUNCEABLE = 1,
SPWP_KNOWN_WORD_PRONOUNCEABLE = 2
} SPWORDPRONOUNCEABLE;
typedef [hidden] enum SPGRAMMARSTATE
{
SPGS_DISABLED = 0,
SPGS_ENABLED = 1,
SPGS_EXCLUSIVE = 3
} SPGRAMMARSTATE;
typedef [hidden] enum SPCONTEXTSTATE
{
SPCS_DISABLED = 0,
SPCS_ENABLED = 1,
} SPCONTEXTSTATE;
typedef [hidden] enum SPRULESTATE
{
SPRS_INACTIVE = 0,
SPRS_ACTIVE = 1,
SPRS_ACTIVE_WITH_AUTO_PAUSE = 3
} SPRULESTATE;
const ULONGLONG SP_STREAMPOS_ASAP = 0;
const ULONGLONG SP_STREAMPOS_REALTIME = -1;
// Special transition types used only by AddRuleTransition
cpp_quote("#define SPRULETRANS_TEXTBUFFER (SPSTATEHANDLE)(-1)")
cpp_quote("#define SPRULETRANS_WILDCARD (SPSTATEHANDLE)(-2)")
cpp_quote("#define SPRULETRANS_DICTATION (SPSTATEHANDLE)(-3)")
typedef [hidden] enum SPGRAMMARWORDTYPE
{
SPWT_DISPLAY,
SPWT_LEXICAL,
SPWT_PRONUNCIATION
} SPGRAMMARWORDTYPE;
typedef [hidden] struct tagSPPROPERTYINFO
{
const WCHAR * pszName;
ULONG ulId;
const WCHAR * pszValue;
VARIANT vValue; // Must be VT_BOOL, VT_I4, VT_R4, VT_R8, or VT_BYREF (only for dynamic grammars)
} SPPROPERTYINFO;
typedef [hidden] enum SPCFGRULEATTRIBUTES
{
SPRAF_TopLevel = (1 << 0),
SPRAF_Active = (1 << 1),
SPRAF_Export = (1 << 2),
SPRAF_Import = (1 << 3),
SPRAF_Interpreter = (1 << 4),
SPRAF_Dynamic = (1 << 5),
// The following flag is only valid at run-time as part of a rule state and
// is not valid to pass as part of a rule definition.
SPRAF_AutoPause = (1 << 16)
} SPCFGRULEATTRIBUTES;
[
object,
uuid(8137828F-591A-4A42-BE58-49EA7EBAAC68),
helpstring("ISpGrammarBuilder Interface"),
pointer_default(unique),
restricted,
local
]
interface ISpGrammarBuilder : IUnknown
{
HRESULT ResetGrammar([in] LANGID NewLanguage);
HRESULT GetRule([in] const WCHAR * pszRuleName,
[in] DWORD dwRuleId,
[in] DWORD dwAttributes,
[in] BOOL fCreateIfNotExist,
[out] SPSTATEHANDLE * phInitialState);
HRESULT ClearRule(SPSTATEHANDLE hState);
HRESULT CreateNewState(
SPSTATEHANDLE hState,
SPSTATEHANDLE * phState);
HRESULT AddWordTransition(
SPSTATEHANDLE hFromState,
SPSTATEHANDLE hToState,
const WCHAR * psz, // If NULL then epsilon
const WCHAR * pszSeparators, // If NULL then psz points to a single word, else specifies valid separator characters
SPGRAMMARWORDTYPE eWordType,
float Weight,
const SPPROPERTYINFO * pPropInfo);
HRESULT AddRuleTransition(
SPSTATEHANDLE hFromState,
SPSTATEHANDLE hToState,
SPSTATEHANDLE hRule, // Must be the initial state of the rule
float Weight,
const SPPROPERTYINFO * pPropInfo);
HRESULT AddResource([in] SPSTATEHANDLE hRuleState, // Any state handle in a rule is OK
[in] const WCHAR * pszResourceName,
[in] const WCHAR * pszResourceValue);
HRESULT Commit(DWORD dwReserved);
};
// --- Options for Load methods on ISpRecoGrammar
typedef [hidden] enum SPLOADOPTIONS
{
SPLO_STATIC = 0,
SPLO_DYNAMIC = 1
} SPLOADOPTIONS;
//--- ISpRecoGrammar -------------------------------------------------------
[
object,
uuid(2177DB29-7F45-47D0-8554-067E91C80502),
helpstring("ISpRecoGrammar Interface"),
pointer_default(unique),
restricted,
local
]
interface ISpRecoGrammar : ISpGrammarBuilder
{
HRESULT GetGrammarId([out] ULONGLONG * pullGrammarId);
HRESULT GetRecoContext([out] ISpRecoContext **ppRecoCtxt);
// Command and control interfaces
HRESULT LoadCmdFromFile([in, string] const WCHAR * pszFileName, [in] SPLOADOPTIONS Options);
HRESULT LoadCmdFromObject([in] REFCLSID rcid, [in, string] const WCHAR * pszGrammarName, [in] SPLOADOPTIONS Options);
HRESULT LoadCmdFromResource([in] HMODULE hModule,
[in, string] const WCHAR * pszResourceName,
[in, string] const WCHAR * pszResourceType,
[in] WORD wLanguage,
[in] SPLOADOPTIONS Options);
HRESULT LoadCmdFromMemory([in] const SPBINARYGRAMMAR * pGrammar, [in] SPLOADOPTIONS Options);
HRESULT LoadCmdFromProprietaryGrammar(
[in] REFGUID rguidParam,
[in, string] const WCHAR * pszStringParam,
[in] const void * pvDataPrarm,
[in] ULONG cbDataSize,
[in] SPLOADOPTIONS Options);
HRESULT SetRuleState([in, string] const WCHAR * pszName, void * pReserved,
[in] SPRULESTATE NewState);
HRESULT SetRuleIdState([in] ULONG ulRuleId, [in] SPRULESTATE NewState);
// Dictation / statistical language model
HRESULT LoadDictation([in, string] const WCHAR * pszTopicName, [in] SPLOADOPTIONS Options);
HRESULT UnloadDictation();
HRESULT SetDictationState([in] SPRULESTATE NewState);
// Word sequence buffer
HRESULT SetWordSequenceData([in] const WCHAR * pText, [in] ULONG cchText, [in] const SPTEXTSELECTIONINFO * pInfo);
HRESULT SetTextSelection([in] const SPTEXTSELECTIONINFO * pInfo);
HRESULT IsPronounceable([in, string] const WCHAR * pszWord, [out] SPWORDPRONOUNCEABLE *pWordPronounceable);
HRESULT SetGrammarState([in] SPGRAMMARSTATE eGrammarState);
HRESULT SaveCmd([in] IStream * pStream, [out, optional] WCHAR ** ppszCoMemErrorText);
HRESULT GetGrammarState([out] SPGRAMMARSTATE * peGrammarState);
};
//--- ISpRecoContext --------------------------------------------------------
typedef [restricted, hidden] struct SPRECOCONTEXTSTATUS
{
SPINTERFERENCE eInterference;
WCHAR szRequestTypeOfUI[255]; // If first byte null, there is no UI request
DWORD dwReserved1;
DWORD dwReserved2;
} SPRECOCONTEXTSTATUS;
typedef [hidden] enum SPBOOKMARKOPTIONS
{
SPBO_NONE = 0,
SPBO_PAUSE = 1
} SPBOOKMARKOPTIONS;
typedef [hidden] enum SPAUDIOOPTIONS
{
SPAO_NONE = 0,
SPAO_RETAIN_AUDIO = (1 << 0)
} SPAUDIOOPTIONS;
[
object,
uuid(F740A62F-7C15-489E-8234-940A33D9272D),
helpstring("ISpRecoContext Interface"),
pointer_default(unique),
local,
restricted
]
interface ISpRecoContext : ISpEventSource
{
HRESULT GetRecognizer([out] ISpRecognizer ** ppRecognizer);
HRESULT CreateGrammar([in] ULONGLONG ullGrammarId, [out] ISpRecoGrammar ** ppGrammar);
HRESULT GetStatus([out] SPRECOCONTEXTSTATUS *pStatus);
HRESULT GetMaxAlternates([in] ULONG * pcAlternates);
HRESULT SetMaxAlternates([in] ULONG cAlternates);
HRESULT SetAudioOptions([in] SPAUDIOOPTIONS Options, [in] const GUID *pAudioFormatId, [in] const WAVEFORMATEX *pWaveFormatEx);
HRESULT GetAudioOptions([in] SPAUDIOOPTIONS * pOptions, [out] GUID *pAudioFormatId, [out] WAVEFORMATEX **ppCoMemWFEX);
HRESULT DeserializeResult(
[in] const SPSERIALIZEDRESULT * pSerializedResult,
[out] ISpRecoResult **ppResult);
HRESULT Bookmark([in] SPBOOKMARKOPTIONS Options, [in] ULONGLONG ullStreamPosition, [in] LPARAM lparamEvent);
HRESULT SetAdaptationData([in, string] const WCHAR *pAdaptationData, [in] const ULONG cch);
HRESULT Pause( DWORD dwReserved );
HRESULT Resume( DWORD dwReserved );
HRESULT SetVoice([in] ISpVoice *pVoice, [in] BOOL fAllowFormatChanges);
HRESULT GetVoice([out] ISpVoice **ppVoice);
HRESULT SetVoicePurgeEvent([in] ULONGLONG ullEventInterest);
HRESULT GetVoicePurgeEvent([out] ULONGLONG *pullEventInterest);
HRESULT SetContextState([in] SPCONTEXTSTATE eContextState);
HRESULT GetContextState([in] SPCONTEXTSTATE * peContextState);
};
//--- ISpProperties ------------------------------------------------------------
[
object,
uuid(5B4FB971-B115-4DE1-AD97-E482E3BF6EE4),
helpstring("ISpProperties Interface"),
pointer_default(unique),
local,
restricted
]
interface ISpProperties : IUnknown
{
HRESULT SetPropertyNum( [in]const WCHAR* pName, [in]LONG lValue );
HRESULT GetPropertyNum( [in]const WCHAR* pName, [out]LONG* plValue );
HRESULT SetPropertyString( [in]const WCHAR* pName, [in]const WCHAR* pValue );
HRESULT GetPropertyString( [in]const WCHAR* pName, [out]WCHAR** ppCoMemValue );
};
const ULONG SP_MAX_LANGIDS = 20; // Engine can support up to 20 languages at once
//--- ISpRecognizer ---------------------------------------------------------
typedef [restricted, hidden] struct SPRECOGNIZERSTATUS
{
SPAUDIOSTATUS AudioStatus;
ULONGLONG ullRecognitionStreamPos;
ULONG ulStreamNumber;
ULONG ulNumActive;
CLSID clsidEngine;
ULONG cLangIDs;
LANGID aLangID[SP_MAX_LANGIDS];
DWORD dwReserved1;
DWORD dwReserved2;
} SPRECOGNIZERSTATUS;
typedef [hidden] enum SPWAVEFORMATTYPE
{
SPWF_INPUT, // WAVEFORMATEX of audio input source
SPWF_SRENGINE // WAVEFORMATEX of the audio received by the SR engine
} SPSTREAMFORMATTYPE;
typedef [hidden] enum SPRECOSTATE
{
SPRST_INACTIVE, // Audio deactivated
SPRST_ACTIVE, // Audio running only if one or more rules are active
SPRST_ACTIVE_ALWAYS, // Audio running regardless of rule state
SPRST_INACTIVE_WITH_PURGE, // State will be set to inactive, but all active audio purged
SPRST_NUM_STATES
} SPRECOSTATE;
[
object,
uuid(C2B5F241-DAA0-4507-9E16-5A1EAA2B7A5C),
helpstring("ISpRecognizer Interface"),
pointer_default(unique),
restricted
]
interface ISpRecognizer : ISpProperties
{
HRESULT SetRecognizer([in] ISpObjectToken * pRecognizer);
HRESULT GetRecognizer([out] ISpObjectToken **ppRecognizer);
HRESULT SetInput([in] IUnknown * pUnkInput, [in] BOOL fAllowFormatChanges);
HRESULT GetInputObjectToken( [out] ISpObjectToken ** ppToken);
HRESULT GetInputStream( [out] ISpStreamFormat ** ppStream);
HRESULT CreateRecoContext([out] ISpRecoContext ** ppNewCtxt);
HRESULT GetRecoProfile([out] ISpObjectToken **ppToken);
HRESULT SetRecoProfile([in] ISpObjectToken *pToken);
HRESULT IsSharedInstance(void);
HRESULT GetRecoState([out] SPRECOSTATE *pState);
HRESULT SetRecoState([in] SPRECOSTATE NewState);
HRESULT GetStatus([out] SPRECOGNIZERSTATUS * pStatus);
HRESULT GetFormat([in] SPSTREAMFORMATTYPE WaveFormatType, [out] GUID *pFormatId, [out] WAVEFORMATEX **ppCoMemWFEX);
[local] HRESULT IsUISupported(
[in] const WCHAR * pszTypeOfUI,
[in] void * pvExtraData,
[in] ULONG cbExtraData,
[out] BOOL *pfSupported);
[local] HRESULT DisplayUI(
[in] HWND hwndParent,
[in] const WCHAR * pszTitle,
[in] const WCHAR * pszTypeOfUI,
[in] void * pvExtraData,
[in] ULONG cbExtraData);
HRESULT EmulateRecognition([in] ISpPhrase *pPhrase);
};
//
//=== CoClass definitions =====================================================
//
[
helpstring("Microsoft Speech Object Library"),
uuid(C866CA3A-32F7-11D2-9602-00C04F8EE628),
version(5.1)
]
library SpeechLib
{
importlib("stdole32.tlb");
importlib("stdole2.tlb");
#include "sapiaut.idl"
//--- SpNotifyTranslator ------------------------------------------------
[
uuid(E2AE5372-5D40-11D2-960E-00C04F8EE628),
helpstring("SpNotify"),
restricted,
hidden
]
coclass SpNotifyTranslator
{
interface ISpNotifyTranslator;
}
//--- SpObjectTokenCategory ---------------------------------------------
[
uuid(A910187F-0C7A-45AC-92CC-59EDAFB77B53),
helpstring("SpObjectTokenCategory Class"),
]
coclass SpObjectTokenCategory
{
[default] interface ISpeechObjectTokenCategory;
interface ISpObjectTokenCategory;
}
//--- SpObjectToken ---------------------------------------------
[
uuid(EF411752-3736-4CB4-9C8C-8EF4CCB58EFE),
helpstring("SpObjectToken Class")
]
coclass SpObjectToken
{
[default] interface ISpeechObjectToken;
interface ISpObjectToken;
}
//--- SpResourceManager -------------------------------------------------
[
uuid(96749373-3391-11D2-9EE3-00C04F797396),
helpstring("SpResourceManger"),
restricted,
hidden
]
coclass SpResourceManager
{
[default] interface ISpResourceManager;
};
//--- SpStreamFormatConverter -------------------------------------------
[
uuid(7013943A-E2EC-11D2-A086-00C04F8EF9B5),
helpstring("FormatConverter Class"),
restricted,
hidden
]
coclass SpStreamFormatConverter
{
[default] interface ISpStreamFormatConverter;
};
//--- SpMMAudioEnum -----------------------------------------------------
[
uuid(AB1890A0-E91F-11D2-BB91-00C04F8EE6C0),
helpstring("SpMMAudioEnum Class"),
restricted,
hidden
]
coclass SpMMAudioEnum
{
interface IEnumSpObjectTokens;
};
//--- SpMMAudioIn -------------------------------------------------------
[
uuid(CF3D2E50-53F2-11D2-960C-00C04F8EE628),
helpstring("SpMMAudioIn Class")
]
coclass SpMMAudioIn
{
[default] interface ISpeechMMSysAudio;
interface ISpEventSource;
interface ISpEventSink;
interface ISpObjectWithToken;
interface ISpMMSysAudio;
};
//--- SpMMAudioOut ------------------------------------------------------
[
uuid(A8C680EB-3D32-11D2-9EE7-00C04F797396),
helpstring("SpMMAudioOut Class")
]
coclass SpMMAudioOut
{
[default] interface ISpeechMMSysAudio;
interface ISpEventSource;
interface ISpEventSink;
interface ISpObjectWithToken;
interface ISpMMSysAudio;
};
//--- SpRecPlayAudio -------------------------------------------------
[
uuid(FEE225FC-7AFD-45E9-95D0-5A318079D911),
helpstring("SpRecPlayAudio Class"),
restricted,
hidden
]
coclass SpRecPlayAudio
{
interface ISpObjectWithToken;
interface ISpAudio;
};
//--- SpStream ----------------------------------------------------------
[
uuid(715D9C59-4442-11D2-9605-00C04F8EE628),
helpstring("SpStream Class"),
restricted,
hidden
]
coclass SpStream
{
interface ISpStream;
};
//--- SpVoice -----------------------------------------------------------
[
uuid(96749377-3391-11D2-9EE3-00C04F797396),
helpstring("SpVoice Class")
]
coclass SpVoice
{
[default] interface ISpeechVoice;
interface ISpVoice;
[default, source] dispinterface _ISpeechVoiceEvents;
};
//--- SpSharedRecoContext -----------------------------------------------
[
uuid(47206204-5ECA-11D2-960F-00C04F8EE628),
helpstring("SpSharedRecoContext Class")
]
coclass SpSharedRecoContext
{
[default] interface ISpeechRecoContext;
interface ISpRecoContext;
[default, source] dispinterface _ISpeechRecoContextEvents;
};
//--- SpInprocRecognizer ------------------------------------------------
[
uuid(41B89B6B-9399-11D2-9623-00C04F8EE628),
helpstring("SpInprocRecognizer Class")
]
coclass SpInprocRecognizer
{
[default] interface ISpeechRecognizer;
interface ISpRecognizer;
};
//--- SpSharedRecognizer ----------------------------------------------
[
uuid(3BEE4890-4FE9-4A37-8C1E-5E7E12791C1F),
helpstring("SpSharedRecognizer Class")
]
coclass SpSharedRecognizer
{
[default] interface ISpeechRecognizer;
interface ISpRecognizer;
};
//--- SpLexicon ----------------------------------------------------------
[
uuid(0655E396-25D0-11D3-9C26-00C04F8EF87C),
helpstring("SpLexicon Class")
]
coclass SpLexicon
{
[default] interface ISpeechLexicon;
interface ISpLexicon;
};
//--- SpUnCompressedLexicon ---------------------------------------------------
[
uuid(C9E37C15-DF92-4727-85D6-72E5EEB6995A),
helpstring("SpUnCompressedLexicon Class")
]
coclass SpUnCompressedLexicon
{
[default] interface ISpeechLexicon;
interface ISpLexicon;
interface ISpObjectWithToken;
};
//--- SpCompressedLexicon ---------------------------------------------------
[
uuid(90903716-2F42-11D3-9C26-00C04F8EF87C),
helpstring("SpCompressedLexicon Class"),
restricted,
hidden
]
coclass SpCompressedLexicon
{
[default] interface ISpLexicon;
interface ISpObjectWithToken;
};
//--- SpPhoneConverter ------------------------------------------------
[
uuid(9185F743-1143-4C28-86B5-BFF14F20E5C8),
helpstring("SpPhoneConverter Class")
]
coclass SpPhoneConverter
{
[default] interface ISpeechPhoneConverter;
interface ISpPhoneConverter;
};
//--- SpNullPhoneConverter ------------------------------------------------
[
uuid(455F24E9-7396-4A16-9715-7C0FDBE3EFE3),
helpstring("SpNullPhoneConverter Class"),
restricted,
hidden
]
coclass SpNullPhoneConverter
{
[default] interface ISpPhoneConverter;
};
#ifdef SAPI_AUTOMATION
//--- SpTextSelectionInformation ------------------------------------------------
[
uuid(0F92030A-CBFD-4AB8-A164-FF5985547FF6),
helpstring("SpTextSelectionInformation Class"),
]
coclass SpTextSelectionInformation
{
[default] interface ISpeechTextSelectionInformation;
};
//--- SpPhraseInfoBuilder ------------------------------------------------
[
uuid(C23FC28D-C55F-4720-8B32-91F73C2BD5D1),
helpstring("SpPhraseInfoBuilder Class"),
]
coclass SpPhraseInfoBuilder
{
[default] interface ISpeechPhraseInfoBuilder;
};
//--- SpAudioFormat ------------------------------------------------
[
uuid(9EF96870-E160-4792-820D-48CF0649E4EC),
helpstring("SpAudioFormat Class"),
]
coclass SpAudioFormat
{
[default] interface ISpeechAudioFormat;
};
//--- SpWaveFormatEx ------------------------------------------------
[
uuid(C79A574C-63BE-44b9-801F-283F87F898BE),
helpstring("SpWaveFormatEx Class"),
]
coclass SpWaveFormatEx
{
[default] interface ISpeechWaveFormatEx;
};
//--- SpInProcRecoContext -----------------------------------------------
[
uuid(73AD6842-ACE0-45E8-A4DD-8795881A2C2A),
helpstring("SpInProcRecoContext Class")
]
coclass SpInProcRecoContext
{
[default] interface ISpeechRecoContext;
interface ISpRecoContext;
[default, source] dispinterface _ISpeechRecoContextEvents;
};
//--- SpCustomStream ------------------------------------------------
[
uuid(8DBEF13F-1948-4aa8-8CF0-048EEBED95D8),
helpstring("SpCustomStream Class"),
]
coclass SpCustomStream
{
[default] interface ISpeechCustomStream;
interface ISpStream;
};
//--- SpFileStream ------------------------------------------------
[
uuid(947812B3-2AE1-4644-BA86-9E90DED7EC91),
helpstring("SpFileStream Class"),
]
coclass SpFileStream
{
[default] interface ISpeechFileStream;
interface ISpStream;
};
//--- SpMemoryStream ------------------------------------------------
[
uuid(5FB7EF7D-DFF4-468a-B6B7-2FCBD188F994),
helpstring("SpMemoryStream Class"),
]
coclass SpMemoryStream
{
[default] interface ISpeechMemoryStream;
interface ISpStream;
};
#endif // SAPI_AUTOMATION
}
Reference in a new issue Copy permalink