/**************************************************************************** * 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; }; }