/****************************************************************************
* sapiddk.idl
*
* This is the interface definition file for the Microsoft Speech API DLL's
* Version 5.0.
*
* It contains definitions for the DDI layer between SAPI.DLL and both
* TTS and SR engines.
*
* Copyright (c) Microsoft Corporation. All rights reserved.
*****************************************************************************/
//--- Includes --------------------------------------------------------------
import "oaidl.idl";
import "ocidl.idl";
import "sapi.idl";
//--- Locally scoped define for LANGID
#ifndef LANGID
#define LANGID WORD
#endif
//--- ITN Processor
interface ISpITNProcessor;
//--- Grammar compiler and dynamic manipulation
interface ISpErrorLog;
interface ISpGrammarCompiler;
interface ISpGramCompBackend;
//--- Phrase builder
interface ISpPhraseBuilder;
//--- Token String Key Names
cpp_quote("#define SPRECOEXTENSION L\"RecoExtension\"")
cpp_quote("#define SPALTERNATESCLSID L\"AlternatesCLSID\"")
//--- ISpTokenUI -----------------------------------------------------------
[
object,
uuid(F8E690F0-39CB-4843-B8D7-C84696E1119D),
helpstring("ISpTokenUI Interface"),
pointer_default(unique),
restricted
]
interface ISpTokenUI : IUnknown
{
[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] ISpObjectToken * pToken,
[in] IUnknown * punkObject);
};
//--- ISpObjectTokenEnumBuilder ---------------------------------------------
[
object,
uuid(06B64F9F-7FDA-11d2-B4F2-00C04F797396),
helpstring("ISpObjectTokensEnumBuilder Interface"),
pointer_default(unique),
restricted
]
interface ISpObjectTokenEnumBuilder : IEnumSpObjectTokens
{
HRESULT SetAttribs(const WCHAR * pszReqAttribs, const WCHAR * pszOptAttribs);
HRESULT AddTokens(ULONG cTokens, ISpObjectToken ** pToken);
HRESULT AddTokensFromDataKey(ISpDataKey * pDataKey, const WCHAR * pszSubKey, const WCHAR * pszCategoryId);
HRESULT AddTokensFromTokenEnum(IEnumSpObjectTokens * pTokenEnum);
HRESULT Sort(const WCHAR * pszTokenIdToListFirst);
};
//--- Handles for SR grammars and results
cpp_quote("#if 0")
typedef void * SPWORDHANDLE;
typedef void * SPRULEHANDLE;
typedef void * SPGRAMMARHANDLE;
typedef void * SPRECOCONTEXTHANDLE;
typedef void * SPPHRASERULEHANDLE;
typedef void * SPPHRASEPROPERTYHANDLE;
typedef void * SPTRANSITIONID;
cpp_quote("#else")
cpp_quote("DECLARE_HANDLE(SPWORDHANDLE);")
cpp_quote("DECLARE_HANDLE(SPRULEHANDLE);")
cpp_quote("DECLARE_HANDLE(SPGRAMMARHANDLE);")
cpp_quote("DECLARE_HANDLE(SPRECOCONTEXTHANDLE);")
cpp_quote("DECLARE_HANDLE(SPPHRASERULEHANDLE);")
cpp_quote("DECLARE_HANDLE(SPPHRASEPROPERTYHANDLE);")
cpp_quote("DECLARE_HANDLE(SPTRANSITIONID);")
cpp_quote("#endif")
//--- ISpErrorLog -----------------------------------------------------------
// This interface is used to log error information.
[
object,
uuid(F4711347-E608-11d2-A086-00C04F8EF9B5),
helpstring("ISpErrorLog Interface"),
pointer_default(unique),
restricted
]
interface ISpErrorLog : IUnknown
{
HRESULT AddError(
const long lLineNumber,
HRESULT hr,
const WCHAR * pszDescription,
const WCHAR * pszHelpFile,
DWORD dwHelpContext);
};
//--- ISpGrammarCompiler ----------------------------------------------------
[
object,
uuid(B1E29D58-A675-11D2-8302-00C04F8EE6C0),
helpstring("ISpGrammarCompiler Interface"),
pointer_default(unique),
restricted
]
interface ISpGrammarCompiler : IUnknown
{
HRESULT CompileStream(
IStream * pSource,
IStream * pDest,
IStream * pHeader,
IUnknown * pReserved,
ISpErrorLog * pErrorLog,
[in] DWORD dwFlags);
};
[
object,
uuid(3DDCA27C-665C-4786-9F97-8C90C3488B61),
helpstring("ISpGramCompBackend Interface"),
pointer_default(unique),
restricted
]
interface ISpGramCompBackend : ISpGrammarBuilder
{
HRESULT SetSaveObjects(IStream * pStream, ISpErrorLog * pErrorLog);
HRESULT InitFromBinaryGrammar(const SPBINARYGRAMMAR * pBinaryData);
};
//--- ISpITNProcessor ----------------------------------------------------------
[
object,
uuid(12D7360F-A1C9-11d3-BC90-00C04F72DF9F),
helpstring("ISpITNProcessor Interface"),
pointer_default(unique),
local,
restricted
]
interface ISpITNProcessor : IUnknown
{
HRESULT LoadITNGrammar(WCHAR *pszCLSID);
HRESULT ITNPhrase(ISpPhraseBuilder *pPhrase);
};
[
object,
uuid(88A3342A-0BED-4834-922B-88D43173162F),
local,
helpstring("ISpPhraseBuilder Interface"),
pointer_default(unique),
restricted
]
interface ISpPhraseBuilder : ISpPhrase
{
HRESULT InitFromPhrase(const SPPHRASE * pPhrase);
HRESULT InitFromSerializedPhrase(const SPSERIALIZEDPHRASE * pPhrase);
HRESULT AddElements(ULONG cElements, const SPPHRASEELEMENT *pElement);
HRESULT AddRules(const SPPHRASERULEHANDLE hParent, const SPPHRASERULE * pRule, SPPHRASERULEHANDLE * phNewRule);
HRESULT AddProperties(const SPPHRASEPROPERTYHANDLE hParent, const SPPHRASEPROPERTY * pProperty, SPPHRASEPROPERTYHANDLE * phNewProperty);
HRESULT AddReplacements(ULONG cReplacements, const SPPHRASEREPLACEMENT * pReplacements);
};
//--- ISpTask ---------------------------------------------------------------
cpp_quote("#if defined(__cplusplus)")
cpp_quote("interface ISpTask")
cpp_quote("{")
cpp_quote("virtual HRESULT STDMETHODCALLTYPE Execute(")
cpp_quote(" void *pvTaskData,")
cpp_quote(" volatile const BOOL* pfContinueProcessing) = 0;")
cpp_quote("};")
cpp_quote("#else")
typedef void * ISpTask;
cpp_quote("#endif")
//--- ISpThreadTask ---------------------------------------------------------
cpp_quote("#if defined(__cplusplus)")
cpp_quote("interface ISpThreadTask")
cpp_quote("{")
cpp_quote("virtual HRESULT STDMETHODCALLTYPE InitThread(")
cpp_quote(" void * pvTaskData,")
cpp_quote(" HWND hwnd) = 0;")
cpp_quote("virtual HRESULT STDMETHODCALLTYPE ThreadProc(")
cpp_quote(" void *pvTaskData,")
cpp_quote(" HANDLE hExitThreadEvent,")
cpp_quote(" HANDLE hNotifyEvent,")
cpp_quote(" HWND hwndWorker,")
cpp_quote(" volatile const BOOL * pfContinueProcessing) = 0;")
cpp_quote("virtual LRESULT STDMETHODCALLTYPE WindowMessage(")
cpp_quote(" void *pvTaskData,")
cpp_quote(" HWND hWnd,")
cpp_quote(" UINT Msg,")
cpp_quote(" WPARAM wParam,")
cpp_quote(" LPARAM lParam) = 0;")
cpp_quote("};")
cpp_quote("#else")
typedef void * ISpThreadTask;
cpp_quote("#endif")
//--- ISpThreadControl ------------------------------------------------------
[
object,
uuid(A6BE4D73-4403-4358-B22D-0346E23B1764),
helpstring("ISpThreadControl Interface"),
pointer_default(unique),
local,
restricted
]
interface ISpThreadControl : ISpNotifySink
{
HRESULT StartThread(DWORD dwFlags, HWND * phwnd);
HRESULT WaitForThreadDone(
BOOL fForceStop,
HRESULT * phrThreadResult,
ULONG msTimeOut);
HRESULT TerminateThread(void);
HANDLE ThreadHandle(void);
DWORD ThreadId(void);
HANDLE NotifyEvent(void);
HWND WindowHandle(void);
HANDLE ThreadCompleteEvent(void);
HANDLE ExitThreadEvent(void);
};
//--- ISpTaskManager --------------------------------------------------------
// This interface is used to implement a task managment service provider
// to optimize thread usage.
typedef [restricted] struct SPTMTHREADINFO
{
long lPoolSize; // Number of threads in pool (-1 default)
long lPriority; // Priority of threads in pool
ULONG ulConcurrencyLimit; // Number of threads allowed to concurrently execute (0 default)
ULONG ulMaxQuickAllocThreads; // Maximum number of dedicated threads retained
} SPTMTHREADINFO;
[
local,
uuid(2BAEEF81-2CA3-4331-98F3-26EC5ABEFB03),
helpstring("ISpTaskManager Interface"),
pointer_default(unique),
restricted
]
interface ISpTaskManager : IUnknown
{
HRESULT SetThreadPoolInfo([in] const SPTMTHREADINFO* pPoolInfo);
HRESULT GetThreadPoolInfo([out] SPTMTHREADINFO* pPoolInfo);
HRESULT QueueTask(
[in] ISpTask* pTask,
[in] void* pvTaskData,
[in] HANDLE hCompEvent,
[in, out] DWORD* pdwGroupId,
[out] DWORD* pTaskID);
HRESULT CreateReoccurringTask(
[in] ISpTask* pTask,
[in] void* pvTaskData,
[in] HANDLE hCompEvent,
[out] ISpNotifySink** ppTaskCtrl);
HRESULT CreateThreadControl(
[in] ISpThreadTask* pTask,
[in] void* pvTaskData,
[in] long nPriority,
[out] ISpThreadControl** ppTaskCtrl);
HRESULT TerminateTask([in] DWORD dwTaskId, [in] ULONG ulWaitPeriod);
HRESULT TerminateTaskGroup([in] DWORD dwGroupId, [in] ULONG ulWaitPeriod);
};
//--- ISpTTSEngineSite ------------------------------------------------------
typedef enum SPVSKIPTYPE
{
SPVST_SENTENCE = (1L << 0) // Skip sentences
} SPVSKIPTYPE;
typedef enum SPVESACTIONS
{
SPVES_CONTINUE = 0,
SPVES_ABORT = ( 1L << 0 ),
SPVES_SKIP = ( 1L << 1 ),
SPVES_RATE = ( 1L << 2 ),
SPVES_VOLUME = ( 1L << 3 )
} SPVESACTIONS;
[
object,
local,
uuid(9880499B-CCE9-11d2-B503-00C04F797396),
helpstring("ISpTTSEngineSite Interface"),
pointer_default(unique)
]
interface ISpTTSEngineSite : ISpEventSink
{
DWORD GetActions( void );
HRESULT Write( [in]const void* pBuff, [in]ULONG cb, [out]ULONG *pcbWritten );
HRESULT GetRate( [out]long* pRateAdjust );
HRESULT GetVolume( [out]USHORT* pusVolume );
HRESULT GetSkipInfo( [out]SPVSKIPTYPE* peType, [out]long* plNumItems );
HRESULT CompleteSkip( [in]long ulNumSkipped );
};
//--- ISpTTSEngine ----------------------------------------------------------
typedef struct SPVTEXTFRAG
{
struct SPVTEXTFRAG* pNext; // Next text fragment in list, NULL == end of list
SPVSTATE State; // Current XML attribute state
LPCWSTR pTextStart;
ULONG ulTextLen;
ULONG ulTextSrcOffset; // Original source position of the fragment text
} SPVTEXTFRAG;
[
object,
local,
uuid(A74D7C8E-4CC5-4f2f-A6EB-804DEE18500E),
helpstring("ISpTTSEngine Interface"),
pointer_default(unique)
]
interface ISpTTSEngine : IUnknown
{
HRESULT Speak( [in]DWORD dwSpeakFlags,
[in]REFGUID rguidFormatId, [in]const WAVEFORMATEX * pWaveFormatEx,
[in]const SPVTEXTFRAG* pTextFragList, [in]ISpTTSEngineSite* pOutputSite );
HRESULT GetOutputFormat( [in] const GUID * pTargetFmtId, [in] const WAVEFORMATEX * pTargetWaveFormatEx,
[out] GUID * pOutputFormatId, [out] WAVEFORMATEX ** ppCoMemOutputWaveFormatEx);
};
//--- SR Engine data structures ----------------------------------------
typedef [restricted] struct SPWORDENTRY
{
SPWORDHANDLE hWord;
LANGID LangID;
WCHAR * pszDisplayText;
WCHAR * pszLexicalForm;
SPPHONEID * aPhoneId;
void * pvClientContext;
} SPWORDENTRY;
typedef [restricted] struct SPRULEENTRY
{
SPRULEHANDLE hRule;
SPSTATEHANDLE hInitialState;
DWORD Attributes; // SPCFGRULEATTRIBUTES
void * pvClientRuleContext;
void * pvClientGrammarContext;
} SPRULEENTRY;
typedef enum SPTRANSITIONTYPE
{
SPTRANSEPSILON,
SPTRANSWORD,
SPTRANSRULE,
SPTRANSTEXTBUF,
SPTRANSWILDCARD,
SPTRANSDICTATION
} SPTRANSITIONTYPE;
typedef [restricted] struct SPTRANSITIONENTRY
{
SPTRANSITIONID ID;
SPSTATEHANDLE hNextState;
BYTE Type; // SPTRANSITIONTYPE
char RequiredConfidence;
struct
{
DWORD fHasProperty; // Boolean type
};
float Weight;
union
{
struct
{
SPSTATEHANDLE hRuleInitialState; // Only if Type == SPTRANSRULE
SPRULEHANDLE hRule;
void * pvClientRuleContext;
};
struct
{
SPWORDHANDLE hWord; // Only if Type == SPTRANSWORD
void * pvClientWordContext;
};
struct
{
void * pvGrammarCookie; // Only if Type == SPTRANSTEXTBUF or SPTRANSWILDCARD or SPTRANSDICTATION
};
};
} SPTRANSITIONENTRY;
typedef [restricted] struct SPTRANSITIONPROPERTY
{
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)
} SPTRANSITIONPROPERTY;
typedef [restricted] struct SPSTATEINFO
{
ULONG cAllocatedEntries;
SPTRANSITIONENTRY * pTransitions;
ULONG cEpsilons;
ULONG cRules;
ULONG cWords;
ULONG cSpecialTransitions;
} SPSTATEINFO;
typedef [restricted] struct SPPATHENTRY
{
SPTRANSITIONID hTransition;
SPPHRASEELEMENT elem;
} SPPATHENTRY;
//--- ISpCFGInterpreterSite -------------------------------------------------
[
object,
uuid(6A6FFAD8-78B6-473d-B844-98152E4FB16B),
helpstring("ISpCFGInterpreterSite Interface"),
pointer_default(unique),
local,
restricted
]
interface ISpCFGInterpreterSite : IUnknown
{
HRESULT AddTextReplacement([in] SPPHRASEREPLACEMENT * pReplace);
HRESULT AddProperty([in] const SPPHRASEPROPERTY *pProperty);
HRESULT GetResourceValue(
[in] const WCHAR *pszResourceName,
[out] WCHAR ** ppCoMemResource);
};
//--- ISpCFGInterpreter -----------------------------------------------------
[
object,
uuid(F3D3F926-11FC-11d3-BB97-00C04F8EE6C0),
helpstring("ISpCFGInterpreter Interface"),
pointer_default(unique),
local,
restricted
]
interface ISpCFGInterpreter : IUnknown
{
HRESULT InitGrammar(
[in] const WCHAR * pszGrammarName,
[in] const void ** pvGrammarData);
HRESULT Interpret(
[in] ISpPhraseBuilder * pPhrase,
[in] const ULONG ulFirstElement,
[in] const ULONG ulCountOfElements,
[in] ISpCFGInterpreterSite * pSite);
};
typedef enum SPCFGNOTIFY
{
SPCFGN_ADD,
SPCFGN_REMOVE,
SPCFGN_INVALIDATE,
SPCFGN_ACTIVATE,
SPCFGN_DEACTIVATE
} SPCFGNOTIFY;
//--- ISpSREngineSite -------------------------------------------------------
typedef enum SPRESULTTYPE
{
SPRT_CFG = 0,
SPRT_SLM = 1,
SPRT_PROPRIETARY = 2,
SPRT_FALSE_RECOGNITION = ( 1L << 2 ) // Flag used to indicate a false recognition
} SPRESULTTYPE;
typedef struct tagSPPHRASEALT
{
ISpPhraseBuilder * pPhrase;
ULONG ulStartElementInParent;
ULONG cElementsInParent;
ULONG cElementsInAlternate;
void * pvAltExtra;
ULONG cbAltExtra;
} SPPHRASEALT;
// Result structure passed from engine to SAPI
typedef struct SPRECORESULTINFO
{
ULONG cbSize; // Total size of this structure
SPRESULTTYPE eResultType; // Type of result object (CFG, SLM, or Proprietary)
BOOL fHypothesis; // If true then this recognition is a hypothesis
BOOL fProprietaryAutoPause;// This field is only used for SPERT_PROPRIETARY grammars. If true, recognition will pause.
ULONGLONG ullStreamPosStart; // Start and end stream positions of recognition
ULONGLONG ullStreamPosEnd;
SPGRAMMARHANDLE hGrammar; // Required for SPERT_SLM and SPERT_PROPRIETARY else NULL
ULONG ulSizeEngineData; // Size of pvEngineData
void * pvEngineData; // Extra engine specific data
ISpPhraseBuilder* pPhrase; // Pointer to phrase object
SPPHRASEALT* aPhraseAlts; // Alternates array
ULONG ulNumAlts; // Number of alternates in the array
} SPRECORESULTINFO;
typedef enum SPWORDINFOOPT
{
SPWIO_NONE = 0,
SPWIO_WANT_TEXT = 1
} SPWORDINFOOPT;
typedef enum SPRULEINFOOPT
{
SPRIO_NONE = 0,
} SPRULEINFOOPT;
typedef struct SPPARSEINFO
{
ULONG cbSize;
SPRULEHANDLE hRule;
ULONGLONG ullAudioStreamPosition;
ULONG ulAudioSize;
ULONG cTransitions;
SPPATHENTRY * pPath;
GUID SREngineID;
ULONG ulSREnginePrivateDataSize;
const BYTE * pSREnginePrivateData;
BOOL fHypothesis;
} SPPARSEINFO;
[
object,
uuid(3B414AEC-720C-4883-B9EF-178CD394FB3A),
helpstring("ISpSREngineSite Interface"),
pointer_default(unique),
local
]
interface ISpSREngineSite : IUnknown
{
HRESULT Read([in] void * pv, [in] ULONG cb, [out] ULONG * pcbRead);
HRESULT DataAvailable(ULONG * pcb);
HRESULT SetBufferNotifySize([in] ULONG cbSize);
HRESULT ParseFromTransitions([in] const SPPARSEINFO * pParseInfo,
[out] ISpPhraseBuilder ** ppNewPhrase);
HRESULT Recognition([in] const SPRECORESULTINFO * pResultInfo);
HRESULT AddEvent([in] const SPEVENT* pEvent, [in] SPRECOCONTEXTHANDLE hSAPIRecoContext);
HRESULT Synchronize([in] ULONGLONG ullProcessedThruPos);
HRESULT GetWordInfo([in, out] SPWORDENTRY * pWordEntry, [in] SPWORDINFOOPT Options); // Caller must fill in hWord. if fWantWordText then caller must CoTaskMemFree the pszWord.
HRESULT SetWordClientContext(SPWORDHANDLE hWord, void * pvClientContext);
HRESULT GetRuleInfo([in, out] SPRULEENTRY * pRuleEntry, [in] SPRULEINFOOPT Options); // Caller must fill in hRule.SPRULEHANDLE hRule, BOOL * pfActive, BOOL *pfAutoPause, SPSTATEHANDLE * phInitialState, void ** ppvClientContext);
HRESULT SetRuleClientContext(SPRULEHANDLE hRule, void * pvClientContext);
HRESULT GetStateInfo(SPSTATEHANDLE hState, SPSTATEINFO * pStateInfo);
HRESULT GetResource( [in] SPRULEHANDLE hRule, [in] const WCHAR *pszResourceName, [out] WCHAR ** ppCoMemResource );
HRESULT GetTransitionProperty([in] SPTRANSITIONID ID, [out] SPTRANSITIONPROPERTY **ppCoMemProperty);
HRESULT IsAlternate( [in]SPRULEHANDLE hRule, [in]SPRULEHANDLE hAltRule );
HRESULT GetMaxAlternates( [in]SPRULEHANDLE hRule, [out]ULONG* pulNumAlts );
HRESULT GetContextMaxAlternates( [in] SPRECOCONTEXTHANDLE hContext, [out] ULONG * pulNumAlts);
HRESULT UpdateRecoPos([in] ULONGLONG ullCurrentRecoPos);
};
//--- ISpSREngine -----------------------------------------------------------
typedef enum SPPROPSRC
{
SPPROPSRC_RECO_INST,
SPPROPSRC_RECO_CTX,
SPPROPSRC_RECO_GRAMMAR
} SPPROPSRC;
[
object,
uuid(2F472991-854B-4465-B613-FBAFB3AD8ED8),
helpstring("ISpSREngine Interface"),
pointer_default(unique),
local
]
interface ISpSREngine : IUnknown
{
HRESULT SetSite([in] ISpSREngineSite *pSite);
HRESULT GetInputAudioFormat(
[in] const GUID * pguidSourceFormatId,
[in] const WAVEFORMATEX * pSourceWaveFormatEx,
[out] GUID * pguidDesiredFormatId,
[out] WAVEFORMATEX ** ppCoMemDesiredWaveFormatEx);
HRESULT RecognizeStream([in] REFGUID rguidFmtId, [in] const WAVEFORMATEX * pWaveFormatEx,
[in] HANDLE hRequestSync, [in] HANDLE hDataAvailable,
[in] HANDLE hExit, [in] BOOL fNewAudioStream, [in] BOOL fRealTimeAudio,
[in] ISpObjectToken * pAudioObjectToken);
HRESULT SetRecoProfile(ISpObjectToken * pProfile);
HRESULT OnCreateGrammar([in] void * pvEngineRecoContext,
[in] SPGRAMMARHANDLE hSAPIGrammar,
[out] void ** ppvEngineGrammarContext);
HRESULT OnDeleteGrammar([in] void * pvEngineGrammar);
HRESULT LoadProprietaryGrammar(
[in] void * pvEngineGrammar,
[in] REFGUID rguidParam,
[in, string] const WCHAR * pszStringParam,
[in] const void * pvDataParam,
[in] ULONG ulDataSize,
[in] SPLOADOPTIONS Options); // Note for SAPI 5.0 this is always SPLO_NONE
HRESULT UnloadProprietaryGrammar([in] void * pvEngineGrammar);
HRESULT SetProprietaryRuleState([in] void * pvEngineGrammar,
[in, string] const WCHAR * pszName,
[in] void * pReserved,
[in] SPRULESTATE NewState,
[out] ULONG * pcRulesChanged);
HRESULT SetProprietaryRuleIdState([in] void * pvEngineGrammar,
[in] DWORD dwRuleId,
[in] SPRULESTATE NewState);
HRESULT LoadSLM([in] void * pvEngineGrammar, [in, string] const WCHAR * pszTopicName);
HRESULT UnloadSLM([in] void * pvEngineGrammar);
HRESULT SetSLMState([in] void * pvEngineGrammar, [in] SPRULESTATE NewState);
HRESULT SetWordSequenceData([in] void * pvEngineGrammar, [in] const WCHAR * pText, [in] ULONG cchText, [in] const SPTEXTSELECTIONINFO * pInfo);
HRESULT SetTextSelection([in] void * pvEngineGrammar, [in] const SPTEXTSELECTIONINFO * pInfo);
HRESULT IsPronounceable([in] void * pvEngineGrammar, [in, string] const WCHAR * pszWord, [out] SPWORDPRONOUNCEABLE *pWordPronounceable);
HRESULT OnCreateRecoContext(
[in] SPRECOCONTEXTHANDLE hSAPIRecoContext,
[out] void ** ppvEngineContext);
HRESULT OnDeleteRecoContext([in] void * pvEngineContext);
HRESULT PrivateCall([in] void * pvEngineContext, [in, out] PVOID pCallFrame, [in] ULONG ulCallFrameSize);
HRESULT SetAdaptationData([in] void * pvEngineContext, const WCHAR *pAdaptationData, const ULONG cch);
HRESULT SetPropertyNum( [in]SPPROPSRC eSrc, [in]void* pvSrcObj,
[in]const WCHAR* pName, [in]LONG lValue );
HRESULT GetPropertyNum( [in]SPPROPSRC eSrc, [in]void* pvSrcObj,
[in]const WCHAR* pName, [out]LONG* lValue );
HRESULT SetPropertyString( [in]SPPROPSRC eSrc, [in]void* pvSrcObj,
[in]const WCHAR* pName, [in]const WCHAR* pValue );
HRESULT GetPropertyString( [in]SPPROPSRC eSrc, [in]void* pvSrcObj,
[in]const WCHAR* pName, [out]WCHAR** ppCoMemValue );
HRESULT SetGrammarState([in] void * pvEngineGrammar, [in] SPGRAMMARSTATE eGrammarState);
HRESULT WordNotify(SPCFGNOTIFY Action, ULONG cWords, const SPWORDENTRY * pWords);
HRESULT RuleNotify(SPCFGNOTIFY Action, ULONG cRules, const SPRULEENTRY * pRules);
HRESULT PrivateCallEx([in] void * pvEngineContext, [in] const void * pInCallFrame, [in] ULONG ulInCallFrameSize,
[out] void ** ppvCoMemResponse, [out] ULONG * pulResponseSize);
HRESULT SetContextState([in] void * pvEngineContext, [in] SPCONTEXTSTATE eContextState);
};
//--- ISpSRAlternates
typedef struct tagSPPHRASEALTREQUEST
{
ULONG ulStartElement;
ULONG cElements;
ULONG ulRequestAltCount;
void * pvResultExtra;
ULONG cbResultExtra;
ISpPhrase * pPhrase;
ISpRecoContext * pRecoContext;
} SPPHRASEALTREQUEST;
[
object,
uuid(FECE8294-2BE1-408f-8E68-2DE377092F0E),
helpstring("ISpSRAlternates Interface"),
pointer_default(unique),
local
]
interface ISpSRAlternates : IUnknown
{
HRESULT GetAlternates([in] SPPHRASEALTREQUEST * pAltRequest,
[out] SPPHRASEALT **ppAlts,
[out] ULONG *pcAlts);
HRESULT Commit([in] SPPHRASEALTREQUEST * pAltRequest,
[in] SPPHRASEALT * pAlt,
[out] void **ppvResultExtra,
[out] ULONG *pcbResultExtra);
}
// Interface used by engine specific recoctxt extension object to call into engine
[
object,
uuid(8E7C791E-4467-11d3-9723-00C04F72DB08),
helpstring("_ISpPrivateEngineCall Interface"),
pointer_default(unique),
local
]
interface _ISpPrivateEngineCall : IUnknown
{
HRESULT CallEngine([in, out] void * pCallFrame, [in] ULONG ulCallFrameSize);
HRESULT CallEngineEx([in] const void * pInFrame, [in] ULONG ulInFrameSize,
[out] void ** ppCoMemOutFrame, [out] ULONG * pulOutFrameSize);
}
//
//--- CoClass definitions ---------------------------------------------------
//
[
helpstring("Microsoft Speech Object DDK Library"),
uuid(9903F14C-12CE-4c99-9986-2EE3D7D588A8),
version(5.0)
]
library SpeechDDKLib
{
importlib("stdole32.tlb");
importlib("stdole2.tlb");
//--- SpDataKey ---------------------------------------------------------
[
uuid(D9F6EE60-58C9-458b-88E1-2F908FD7F87C),
helpstring("Data Key")
]
coclass SpDataKey
{
interface ISpRegDataKey;
[default] interface ISpDataKey;
}
//--- SpObjectTokenEnum --------------------------------------------------
[
uuid(3918D75F-0ACB-41f2-B733-92AA15BCECF6),
helpstring("Object Token Enumerator")
]
coclass SpObjectTokenEnum
{
interface ISpObjectTokenEnumBuilder;
[default] interface IEnumSpObjectTokens;
}
//--- SpPhraseBuilder ---------------------------------------------------
[
uuid(777B6BBD-2FF2-11d3-88FE-00C04F8EF9B5),
helpstring("Phrase Builder Class")
]
coclass SpPhraseBuilder
{
[default] interface ISpPhraseBuilder;
}
//--- SpITNProcessor ----------------------------------------------------
[
uuid(12D73610-A1C9-11d3-BC90-00C04F72DF9F),
helpstring("SpITNProcessor Class"),
restricted
]
coclass SpITNProcessor
{
[default] interface ISpITNProcessor;
};
//--- SpGrammarCompiler ---------------------------------------------
[
uuid(B1E29D59-A675-11D2-8302-00C04F8EE6C0),
helpstring("Microsoft Speech Grammar Compiler")
]
coclass SpGrammarCompiler
{
[default] interface ISpGrammarCompiler;
};
//--- SpGramCompBackend ---------------------------------------------
[
uuid(DA93E903-C843-11D2-A084-00C04F8EF9B5),
helpstring("Grammar Class"),
restricted
]
coclass SpGramCompBackend
{
[default] interface ISpGramCompBackend;
};
}