1 // Licensed under the Apache License, Version 2.0
2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
4 // All files in the project carrying such notice may not be copied, modified, or distributed
5 // except according to those terms.
6 use ctypes::{c_char, c_float, c_long, c_void};
7 use shared::guiddef::{CLSID, GUID, IID, REFGUID};
8 use shared::minwindef::{BOOL, BYTE, DWORD, ULONG, USHORT, WORD};
9 use shared::mmreg::WAVEFORMATEX;
10 use shared::windef::HWND;
11 use um::oaidl::VARIANT;
12 use um::objidlbase::IStream;
13 use um::sapi::*;
14 use um::unknwnbase::{IUnknown, IUnknownVtbl};
15 use um::winnt::{HANDLE, HRESULT, LONG, LPCWSTR, LPWSTR, PVOID, ULONGLONG, WCHAR};
16 pub const SPRECOEXTENSION: &'static str = "RecoExtension";
17 pub const SPALTERNATESCLSID: &'static str = "AlternatesCLSID";
18 RIDL!{#[uuid(0xf8e690f0, 0x39cb, 0x4843, 0xb8, 0xd7, 0xc8, 0x46, 0x96, 0xe1, 0x11, 0x9d)]
19 interface ISpTokenUI(ISpTokenUIVtbl): IUnknown(IUnknownVtbl) {
20     fn IsUISupported(
21         pszTypeOfUI: LPCWSTR,
22         pvExtraData: *mut c_void,
23         cbExtraData: ULONG,
24         punkObject: *mut IUnknown,
25         pfSupported: *mut BOOL,
26     ) -> HRESULT,
27     fn DisplayUI(
28         hwndParent: HWND,
29         pszTitle: LPCWSTR,
30         pszTypeOfUI: LPCWSTR,
31         pvExtraData: *mut c_void,
32         cbExtraData: ULONG,
33         pToken: *mut ISpObjectToken,
34         punkObject: *mut IUnknown,
35     ) -> HRESULT,
36 }}
37 RIDL!{#[uuid(0x06b64f9f, 0x7fda, 0x11d2, 0xb4, 0xf2, 0x00, 0xc0, 0x4f, 0x79, 0x73, 0x96)]
38 interface ISpObjectTokenEnumBuilder(ISpObjectTokenEnumBuilderVtbl):
39     IEnumSpObjectTokens(IEnumSpObjectTokensVtbl) {
40     fn SetAttribs(
41         pszReqAttribs: LPCWSTR,
42         pszOptAttribs: LPCWSTR,
43     ) -> HRESULT,
44     fn AddTokens(
45         cTokens: ULONG,
46         pToken: *mut *mut ISpObjectToken,
47     ) -> HRESULT,
48     fn AddTokensFromDataKey(
49         pDataKey: *mut ISpDataKey,
50         pszSubKey: LPCWSTR,
51         pszCategoryId: LPCWSTR,
52     ) -> HRESULT,
53     fn AddTokensFromTokenEnum(
54         pTokenEnum: *mut IEnumSpObjectTokens,
55     ) -> HRESULT,
56     fn Sort(
57         pszTokenIdToListFirst: LPCWSTR,
58     ) -> HRESULT,
59 }}
60 DECLARE_HANDLE!{SPWORDHANDLE, SPWORDHANDLE__}
61 DECLARE_HANDLE!{SPRULEHANDLE, SPRULEHANDLE__}
62 DECLARE_HANDLE!{SPGRAMMARHANDLE, SPGRAMMARHANDLE__}
63 DECLARE_HANDLE!{SPRECOCONTEXTHANDLE, SPRECOCONTEXTHANDLE__}
64 DECLARE_HANDLE!{SPPHRASERULEHANDLE, SPPHRASERULEHANDLE__}
65 DECLARE_HANDLE!{SPPHRASEPROPERTYHANDLE, SPPHRASEPROPERTYHANDLE__}
66 DECLARE_HANDLE!{SPTRANSITIONID, SPTRANSITIONID__}
67 RIDL!{#[uuid(0xf4711347, 0xe608, 0x11d2, 0xa0, 0x86, 0x00, 0xc0, 0x4f, 0x8e, 0xf9, 0xb5)]
68 interface ISpErrorLog(ISpErrorLogVtbl): IUnknown(IUnknownVtbl) {
69     fn AddError(
70         lLineNumber: c_long,
71         hr: HRESULT,
72         pszDescription: LPCWSTR,
73         pszHelpFile: LPCWSTR,
74         dwHelpContext: DWORD,
75     ) -> HRESULT,
76 }}
77 RIDL!{#[uuid(0xb1e29d58, 0xa675, 0x11d2, 0x83, 0x02, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)]
78 interface ISpGrammarCompiler(ISpGrammarCompilerVtbl): IUnknown(IUnknownVtbl) {
79     fn CompileStream(
80         pSource: *mut IStream,
81         pDest: *mut IStream,
82         pHeader: *mut IStream,
83         pReserved: *mut IUnknown,
84         pErrorLog: *mut ISpErrorLog,
85         dwFlags: DWORD,
86     ) -> HRESULT,
87 }}
88 RIDL!{#[uuid(0x3ddca27c, 0x665c, 0x4786, 0x9f, 0x97, 0x8c, 0x90, 0xc3, 0x48, 0x8b, 0x61)]
89 interface ISpGramCompBackend(ISpGramCompBackendVtbl): ISpGrammarBuilder(ISpGrammarBuilderVtbl) {
90     fn SetSaveObjects(
91         pStream: *mut IStream,
92         pErrorLog: *mut ISpErrorLog,
93     ) -> HRESULT,
94     fn InitFromBinaryGrammar(
95         pBinaryData: *const SPBINARYGRAMMAR,
96     ) -> HRESULT,
97 }}
98 RIDL!{#[uuid(0x12d7360f, 0xa1c9, 0x11d3, 0xbc, 0x90, 0x00, 0xc0, 0x4f, 0x72, 0xdf, 0x9f)]
99 interface ISpITNProcessor(ISpITNProcessorVtbl): IUnknown(IUnknownVtbl) {
100     fn LoadITNGrammar(
101         pszCLSID: LPWSTR,
102     ) -> HRESULT,
103     fn ITNPhrase(
104         pPhrase: *mut ISpPhraseBuilder,
105     ) -> HRESULT,
106 }}
107 RIDL!{#[uuid(0x88a3342a, 0x0bed, 0x4834, 0x92, 0x2b, 0x88, 0xd4, 0x31, 0x73, 0x16, 0x2f)]
108 interface ISpPhraseBuilder(ISpPhraseBuilderVtbl): ISpPhrase(ISpPhraseVtbl) {
109     fn InitFromPhrase(
110         pPhrase: *const SPPHRASE,
111     ) -> HRESULT,
112     fn InitFromSerializedPhrase(
113         pPhrase: *const SPSERIALIZEDPHRASE,
114     ) -> HRESULT,
115     fn AddElements(
116         cElements: ULONG,
117         pElement: *const SPPHRASEELEMENT,
118     ) -> HRESULT,
119     fn AddRules(
120         hParent: SPPHRASERULEHANDLE,
121         pRule: *const SPPHRASERULE,
122         phNewRule: *mut SPPHRASERULEHANDLE,
123     ) -> HRESULT,
124     fn AddProperties(
125         hParent: SPPHRASEPROPERTYHANDLE,
126         pProperty: *const SPPHRASEPROPERTY,
127         phNewProperty: *mut SPPHRASEPROPERTYHANDLE,
128     ) -> HRESULT,
129     fn AddReplacements(
130         cReplacements: ULONG,
131         pReplacements: *const SPPHRASEREPLACEMENT,
132     ) -> HRESULT,
133 }}
134 pub type ISpTask = *mut c_void;
135 pub type ISpThreadTask = *mut c_void;
136 RIDL!{#[uuid(0xa6be4d73, 0x4403, 0x4358, 0xb2, 0x2d, 0x03, 0x46, 0xe2, 0x3b, 0x17, 0x64)]
137 interface ISpThreadControl(ISpThreadControlVtbl): ISpNotifySink(ISpNotifySinkVtbl) {
138     fn StartThread(
139         dwFlags: DWORD,
140         phwnd: *mut HWND,
141     ) -> HRESULT,
142     fn WaitForThreadDone(
143         fForceStop: BOOL,
144         phrThreadResult: *mut HRESULT,
145         msTimeOut: ULONG,
146     ) -> HRESULT,
147     fn TerminateThread() -> HRESULT,
148     fn ThreadHandle() -> HANDLE,
149     fn ThreadId() -> DWORD,
150     fn NotifyEvent() -> HANDLE,
151     fn WindowHandle() -> HWND,
152     fn ThreadCompleteEvent() -> HANDLE,
153     fn ExitThreadEvent() -> HANDLE,
154 }}
155 STRUCT!{struct SPTMTHREADINFO {
156     lPoolSize: c_long,
157     lPriority: c_long,
158     ulConcurrencyLimit: ULONG,
159     ulMaxQuickAllocThreads: ULONG,
160 }}
161 RIDL!{#[uuid(0x2baeef81, 0x2ca3, 0x4331, 0x98, 0xf3, 0x26, 0xec, 0x5a, 0xbe, 0xfb, 0x03)]
162 interface ISpTaskManager(ISpTaskManagerVtbl): IUnknown(IUnknownVtbl) {
163     fn SetThreadPoolInfo(
164         pPoolInfo: *const SPTMTHREADINFO,
165     ) -> HRESULT,
166     fn GetThreadPoolInfo(
167         pPoolInfo: *mut SPTMTHREADINFO,
168     ) -> HRESULT,
169     fn QueueTask(
170         pTask: *mut ISpTask,
171         pvTaskData: *mut c_void,
172         hCompEvent: HANDLE,
173         pdwGroupId: *mut DWORD,
174         pTaskID: *mut DWORD,
175     ) -> HRESULT,
176     fn CreateReoccurringTask(
177         pTask: *mut ISpTask,
178         pvTaskData: *mut c_void,
179         hCompEvent: HANDLE,
180         ppTaskCtrl: *mut *mut ISpNotifySink,
181     ) -> HRESULT,
182     fn CreateThreadControl(
183         pTask: *mut ISpThreadTask,
184         pvTaskData: *mut c_void,
185         nPriority: c_long,
186         ppTaskCtrl: *mut *mut ISpThreadControl,
187     ) -> HRESULT,
188     fn TerminateTask(
189         dwGroupId: DWORD,
190         ulWaitPeriod: ULONG,
191     ) -> HRESULT,
192 }}
193 ENUM!{enum SPVSKIPTYPE {
194     SPVST_SENTENCE = 1 << 0,
195 }}
196 ENUM!{enum SPVESACTIONS {
197     SPVES_CONTINUE = 0,
198     SPVES_ABORT = 1 << 0,
199     SPVES_SKIP = 1 << 1,
200     SPVES_RATE = 1 << 2,
201     SPVES_VOLUME = 1 << 3,
202 }}
203 RIDL!{#[uuid(0x9880499b, 0xcce9, 0x11d2, 0xb5, 0x03, 0x00, 0xc0, 0x4f, 0x79, 0x73, 0x96)]
204 interface ISpTTSEngineSite(ISpTTSEngineSiteVtbl): ISpEventSink(ISpEventSinkVtbl) {
205     fn GetActions() -> DWORD,
206     fn Write(
207         pBuff: *const c_void,
208         cb: ULONG,
209         pcbWritten: *mut ULONG,
210     ) -> HRESULT,
211     fn GetRate(
212         pRateAdjust: *mut c_long,
213     ) -> HRESULT,
214     fn GetVolume(pusVolume: *mut USHORT,
215     ) -> HRESULT,
216     fn GetSkipInfo(
217         peType: *mut SPVSKIPTYPE,
218         plNumItems: *mut c_long,
219     ) -> HRESULT,
220     fn CompleteSkip(
221         ulNumSkipped: c_long,
222     ) -> HRESULT,
223 }}
224 STRUCT!{struct SPVTEXTFRAG {
225     pNext: *mut SPVTEXTFRAG,
226     State: SPVSTATE,
227     pTextStart: LPCWSTR,
228     ulTextLen: ULONG,
229     ulTextSrcOffset: ULONG,
230 }}
231 RIDL!{#[uuid(0xa74d7c8e, 0x4cc5, 0x4f2f, 0xa6, 0xeb, 0x80, 0x4d, 0xee, 0x18, 0x50, 0x0e)]
232 interface ISpTTSEngine(ISpTTSEngineVtbl): IUnknown(IUnknownVtbl) {
233     fn Speak(
234         dwSpeakFlags: DWORD,
235         rguidFormatId: REFGUID,
236         pWaveFormatEx: *const WAVEFORMATEX,
237         pTextFragList: *const SPVTEXTFRAG,
238         pOutputSite: *mut ISpTTSEngineSite,
239     ) -> HRESULT,
240     fn GetOutputFormat(
241         pTargetFmtId: *const GUID,
242         pTargetWaveFormatEx: *const WAVEFORMATEX,
243         pOutputFormatId: *mut GUID,
244         ppCoMemOutputWaveFormatEx: *mut WAVEFORMATEX,
245     ) -> HRESULT,
246 }}
247 STRUCT!{struct SPWORDENTRY {
248     hWord: SPWORDHANDLE,
249     LangID: WORD,
250     pszDisplayText: *mut WCHAR,
251     pszLexicalForm: *mut WCHAR,
252     aPhoneId: *mut SPPHONEID,
253     pvClientContext: *mut c_void,
254 }}
255 STRUCT!{struct SPRULEENTRY {
256     hRule: SPRULEHANDLE,
257     hInitialState: SPSTATEHANDLE,
258     Attributes: DWORD,
259     pvClientRuleContext: *mut c_void,
260     pvClientGrammarContext: *mut c_void,
261 }}
262 ENUM!{enum SPTRANSITIONTYPE {
263     SPTRANSEPSILON = 0,
264     SPTRANSWORD,
265     SPTRANSRULE,
266     SPTRANSTEXTBUF,
267     SPTRANSWILDCARD,
268     SPTRANSDICTATION,
269 }}
270 STRUCT!{struct SPTRANSITIONENTRY_u_s1 {
271     hRuleInitialState: SPSTATEHANDLE,
272     hRule: SPRULEHANDLE,
273     pvClientRuleContext: *mut c_void,
274 }}
275 STRUCT!{struct SPTRANSITIONENTRY_u_s2 {
276     hWord: SPWORDHANDLE,
277     pvClientWordContext: *mut c_void,
278 }}
279 UNION!{union SPTRANSITIONENTRY_u {
280     [usize; 3],
281     s1 s1_mut: SPTRANSITIONENTRY_u_s1,
282     s2 s2_mut: SPTRANSITIONENTRY_u_s2,
283     pvGrammarCookie pvGrammarCookie_mut: *mut c_void,
284 }}
285 STRUCT!{struct SPTRANSITIONENTRY {
286     ID: SPTRANSITIONID,
287     hNextState: SPSTATEHANDLE,
288     Type: BYTE,
289     RequiredConfidence: c_char,
290     fHasProperty: DWORD,
291     Weight: c_float,
292     u: SPTRANSITIONENTRY_u,
293 }}
294 STRUCT!{struct SPTRANSITIONPROPERTY {
295     pszName: LPCWSTR,
296     ulId: ULONG,
297     pszValue: LPCWSTR,
298     vValue: VARIANT,
299 }}
300 STRUCT!{struct SPSTATEINFO {
301     cAllocatedEntries: ULONG,
302     pTransitions: *mut SPTRANSITIONENTRY,
303     cEpsilons: ULONG,
304     cRules: ULONG,
305     cWords: ULONG,
306     cSpecialTransitions: ULONG,
307 }}
308 STRUCT!{struct SPPATHENTRY {
309     hTransition: SPTRANSITIONID,
310     elem: SPPHRASEELEMENT,
311 }}
312 RIDL!{#[uuid(0x6a6ffad8, 0x78b6, 0x473d, 0xb8, 0x44, 0x98, 0x15, 0x2e, 0x4f, 0xb1, 0x6b)]
313 interface ISpCFGInterpreterSite(ISpCFGInterpreterSiteVtbl): IUnknown(IUnknownVtbl) {
314     fn AddTextReplacement(
315         pReplace: *mut SPPHRASEREPLACEMENT,
316     ) -> HRESULT,
317     fn AddProperty(
318         pProperty: *const SPPHRASEPROPERTY,
319     ) -> HRESULT,
320     fn GetResourceValue(
321         pszResourceName: LPCWSTR,
322         ppCoMemResource: *mut LPWSTR,
323     ) -> HRESULT,
324 }}
325 RIDL!{#[uuid(0xf3d3f926, 0x11fc, 0x11d3, 0xbb, 0x97, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)]
326 interface ISpCFGInterpreter(ISpCFGInterpreterVtbl): IUnknown(IUnknownVtbl) {
327     fn InitGrammar(
328         pszGrammarName: LPCWSTR,
329         pvGrammarData: *mut *const c_void,
330     ) -> HRESULT,
331     fn Interpret(
332         pPhrase: *mut ISpPhraseBuilder,
333         ulFirstElement: *const ULONG,
334         ulCountOfElements: *const ULONG,
335         pSite: *mut ISpCFGInterpreterSite,
336     ) -> HRESULT,
337 }}
338 ENUM!{enum SPCFGNOTIFY {
339     SPCFGN_ADD,
340     SPCFGN_REMOVE,
341     SPCFGN_INVALIDATE,
342     SPCFGN_ACTIVATE,
343     SPCFGN_DEACTIVATE,
344 }}
345 ENUM!{enum SPRESULTTYPE {
346     SPRT_CFG = 0,
347     SPRT_SLM = 1,
348     SPRT_PROPRIETARY = 2,
349     SPRT_FALSE_RECOGNITION = 1 << 2,
350 }}
351 STRUCT!{struct SPPHRASEALT {
352     pPhrase: *mut ISpPhraseBuilder,
353     ulStartElementInParent: ULONG,
354     cElementsInParent: ULONG,
355     cElementsInAlternate: ULONG,
356     pvAltExtra: *mut c_void,
357     cbAltExtra: ULONG,
358 }}
359 STRUCT!{struct SPRECORESULTINFO {
360     cbSize: ULONG,
361     eResultType: SPRESULTTYPE,
362     fHypothesis: BOOL,
363     fProprietaryAutoPause: BOOL,
364     ullStreamPosStart: ULONGLONG,
365     ullStreamPosEnd: ULONGLONG,
366     hGrammar: SPGRAMMARHANDLE,
367     ulSizeEngineData: ULONG,
368     pvEngineData: *mut c_void,
369     pPhrase: *mut ISpPhraseBuilder,
370     aPhraseAlts: *mut SPPHRASEALT,
371     ulNumAlts: ULONG,
372 }}
373 ENUM!{enum SPWORDINFOOPT {
374     SPWIO_NONE = 0,
375     SPWIO_WANT_TEXT = 1,
376 }}
377 ENUM!{enum SPRULEINFOOPT {
378     SPRIO_NONE = 0,
379 }}
380 STRUCT!{struct SPPARSEINFO {
381     cbSize: ULONG,
382     hRule: SPRULEHANDLE,
383     ullAudioStreamPosition: ULONGLONG,
384     ulAudioSize: ULONG,
385     cTransitions: ULONG,
386     pPath: *mut SPPATHENTRY,
387     SREngineID: GUID,
388     ulSREnginePrivateDataSize: ULONG,
389     pSREnginePrivateData: *const BYTE,
390     fHypothesis: BOOL,
391 }}
392 RIDL!{#[uuid(0x3b414aec, 0x720c, 0x4883, 0xb9, 0xef, 0x17, 0x8c, 0xd3, 0x94, 0xfb, 0x3a)]
393 interface ISpSREngineSite(ISpSREngineSiteVtbl): IUnknown(IUnknownVtbl) {
394     fn Read(
395         pv: *mut c_void,
396         cb: ULONG,
397         pcbRead: *mut ULONG,
398     ) -> HRESULT,
399     fn DataAvailable(
400         pcb: *mut ULONG,
401     ) -> HRESULT,
402     fn SetBufferNotifySize(
403         cbSize: ULONG,
404     ) -> HRESULT,
405     fn ParseFromTransitions(
406         pParseInfo: *const SPPARSEINFO,
407         ppNewPhrase: *mut *mut ISpPhraseBuilder,
408     ) -> HRESULT,
409     fn Recognition(
410         pResultInfo: *const SPRECORESULTINFO,
411     ) -> HRESULT,
412     fn AddEvent(
413         pEvent: *const SPEVENT,
414         hSAPIRecoContext: SPRECOCONTEXTHANDLE,
415     ) -> HRESULT,
416     fn Synchronize(
417         ullProcessedThruPos: ULONGLONG,
418     ) -> HRESULT,
419     fn GetWordInfo(
420         pWordEntry: *mut SPWORDENTRY,
421         Options: SPWORDINFOOPT,
422     ) -> HRESULT,
423     fn SetWordClientContext(
424         hWord: SPWORDHANDLE,
425         pvClientContext: *mut c_void,
426     ) -> HRESULT,
427     fn GetRuleInfo(
428         pRuleEntry: *mut SPRULEENTRY,
429         Options: SPRULEINFOOPT,
430     ) -> HRESULT,
431     fn SetRuleClientContext(
432         hRule: SPRULEHANDLE,
433         pvClientContext: *mut c_void,
434     ) -> HRESULT,
435     fn GetStateInfo(
436         hState: SPSTATEHANDLE,
437         pStateInfo: *mut SPSTATEINFO,
438     ) -> HRESULT,
439     fn GetResource(
440         hRule: SPRULEHANDLE,
441         pszResourceName: LPCWSTR,
442         ppCoMemResource: *mut LPWSTR,
443     ) -> HRESULT,
444     fn GetTransitionProperty(
445         ID: SPTRANSITIONID,
446         ppCoMemProperty: *mut *mut SPTRANSITIONPROPERTY,
447     ) -> HRESULT,
448     fn IsAlternate(
449         hRule: SPRULEHANDLE,
450         hAltRule: SPRULEHANDLE,
451     ) -> HRESULT,
452     fn GetMaxAlternates(
453         hRule: SPRULEHANDLE,
454         pulNumAlts: *mut ULONG,
455     ) -> HRESULT,
456     fn GetContextMaxAlternates(
457         hContext: SPRECOCONTEXTHANDLE,
458         pulNumAlts: *mut ULONG,
459     ) -> HRESULT,
460     fn UpdateRecoPos(
461         ullCurrentRecoPos: ULONGLONG,
462     ) -> HRESULT,
463 }}
464 ENUM!{enum SPPROPSRC {
465     SPPROPSRC_RECO_INST,
466     SPPROPSRC_RECO_CTX,
467     SPPROPSRC_RECO_GRAMMAR,
468 }}
469 RIDL!{#[uuid(0x2f472991, 0x854b, 0x4465, 0xb6, 0x13, 0xfb, 0xaf, 0xb3, 0xad, 0x8e, 0xd8)]
470 interface ISpSREngine(ISpSREngineVtbl): IUnknown(IUnknownVtbl) {
471     fn SetSite(
472         pSite: *mut ISpSREngineSite,
473     ) -> HRESULT,
474     fn GetInputAudioFormat(
475         pguidSourceFormatId: *const GUID,
476         pSourceWaveFormatEx: *const WAVEFORMATEX,
477         pguidDesiredFormatId: *mut GUID,
478         ppCoMemDesiredWaveFormatEx: *mut WAVEFORMATEX,
479     ) -> HRESULT,
480     fn RecognizeStream(
481         rguidFmtId: REFGUID,
482         pWaveFormatEx: *const WAVEFORMATEX,
483         hRequestSync: HANDLE,
484         hDataAvailable: HANDLE,
485         hExit: HANDLE,
486         fNewAudioStream: BOOL,
487         fRealTimeAudio: BOOL,
488         pAudioObjectToken: *mut ISpObjectToken,
489     ) -> HRESULT,
490     fn SetRecoProfile(
491         pProfile: *mut ISpObjectToken,
492     ) -> HRESULT,
493     fn OnCreateGrammar(
494         pvEngineRecoContext: *mut c_void,
495         hSAPIGrammar: SPGRAMMARHANDLE,
496         ppvEngineGrammarContext: *mut *mut c_void,
497     ) -> HRESULT,
498     fn OnDeleteGrammar(
499         pvEngineGrammar: *mut c_void,
500     ) -> HRESULT,
501     fn LoadProprietaryGrammar(
502         pvEngineGrammar: *mut c_void,
503         rguidParam: REFGUID,
504         pszStringParam: LPCWSTR,
505         pvDataParam: *const c_void,
506         ulDataSize: ULONG,
507         Options: SPLOADOPTIONS,
508     ) -> HRESULT,
509     fn UnloadProprietaryGrammar(
510         pvEngineGrammar: *mut c_void,
511     ) -> HRESULT,
512     fn SetProprietaryRuleState(
513         pvEngineGrammar: *mut c_void,
514         pszName: LPCWSTR,
515         pReserved: *mut c_void,
516         NewState: SPRULESTATE,
517         pcRulesChanged: *mut ULONG,
518     ) -> HRESULT,
519     fn SetProprietaryRuleIdState(
520         pvEngineGrammar: *mut c_void,
521         dwRuleId: DWORD,
522         NewState: SPRULESTATE,
523     ) -> HRESULT,
524     fn LoadSLM(
525         pvEngineGrammar: *mut c_void,
526         pszTopicName: LPCWSTR,
527     ) -> HRESULT,
528     fn UnloadSLM(
529         pvEngineGrammar: *mut c_void,
530     ) -> HRESULT,
531     fn SetSLMState(
532         pvEngineGrammar: *mut c_void,
533         NewState: SPRULESTATE,
534     ) -> HRESULT,
535     fn SetWordSequenceData(
536         pvEngineGrammar: *mut c_void,
537         pText: *const WCHAR,
538         cchText: ULONG,
539         pInfo: *const SPTEXTSELECTIONINFO,
540     ) -> HRESULT,
541     fn SetTextSelection(
542         pvEngineGrammar: *mut c_void,
543         pInfo: *const SPTEXTSELECTIONINFO,
544     ) -> HRESULT,
545     fn IsPronounceable(
546         pvEngineGrammar: *mut c_void,
547         pszWord: LPCWSTR,
548         pWordPronounceable: *mut SPWORDPRONOUNCEABLE,
549     ) -> HRESULT,
550     fn OnCreateRecoContext(
551         hSAPIRecoContext: SPRECOCONTEXTHANDLE,
552         ppvEngineContext: *mut *mut c_void,
553     ) -> HRESULT,
554     fn OnDeleteRecoContext(
555         pvEngineContext: *mut c_void,
556     ) -> HRESULT,
557     fn OnPrivateCall(
558         pvEngineContext: *mut c_void,
559         pCallFrame: PVOID,
560         ulCallFrameSize: ULONG,
561     ) -> HRESULT,
562     fn SetAdaptationData(
563         pvEngineContext: *mut c_void,
564         pAdaptationData: *const WCHAR,
565         cch: ULONG,
566     ) -> HRESULT,
567     fn SetPropertyNum(
568         eSrc: SPPROPSRC,
569         pvSrcObj: *mut c_void,
570         pName: *const WCHAR,
571         lValue: LONG,
572     ) -> HRESULT,
573     fn GetPropertyNum(
574         eSrc: SPPROPSRC,
575         pvSrcObj: *mut c_void,
576         pName: *const WCHAR,
577         lValue: *mut LONG,
578     ) -> HRESULT,
579     fn SetPropertyString(
580         eSrc: SPPROPSRC,
581         pvSrcObj: *mut c_void,
582         pName: LPCWSTR,
583         pValue: LPCWSTR,
584     ) -> HRESULT,
585     fn GetPropertyString(
586         eSrc: SPPROPSRC,
587         pvSrcObj: *mut c_void,
588         pName: LPCWSTR,
589         ppCoMemValue: *mut LPWSTR,
590     ) -> HRESULT,
591     fn SetGrammarState(
592         pvEngineGrammar: *mut c_void,
593         eGrammarState: SPGRAMMARSTATE,
594     ) -> HRESULT,
595     fn WordNotify(
596         Action: SPCFGNOTIFY,
597         cWords: ULONG,
598         pWords: *const SPWORDENTRY,
599     ) -> HRESULT,
600     fn RuleNotify(
601         Action: SPCFGNOTIFY,
602         cRules: ULONG,
603         pRules: *const SPRULEENTRY,
604     ) -> HRESULT,
605     fn PrivateCallEx(
606         pvEngineContext: *mut c_void,
607         pInCallFrame: *const c_void,
608         ulInCallFrameSize: ULONG,
609         ppvCoMemResponse: *mut *mut c_void,
610         pulResponseSize: *mut ULONG,
611     ) -> HRESULT,
612     fn SetContextState(
613         pvEngineContext: *mut c_void,
614         eContextState: SPCONTEXTSTATE,
615     ) -> HRESULT,
616 }}
617 STRUCT!{struct SPPHRASEALTREQUEST {
618     ulStartElement: ULONG,
619     cElements: ULONG,
620     ulRequestAltCount: ULONG,
621     pvResultExtra: *mut c_void,
622     cbResultExtra: ULONG,
623     pPhrase: *mut ISpPhrase,
624     pRecoContext: *mut ISpRecoContext,
625 }}
626 RIDL!{#[uuid(0x8e7c791e, 0x4467, 0x11d3, 0x97, 0x23, 0x00, 0xc0, 0x4f, 0x72, 0xdb, 0x08)]
627 interface _ISpPrivateEngineCall(_ISpPrivateEngineCallVtbl): IUnknown(IUnknownVtbl) {
628     fn CallEngine(
629         pCallFrame: *mut c_void,
630         ulCallFrameSize: ULONG,
631     ) -> HRESULT,
632     fn CallEngineEx(
633         pInFrame: *const c_void,
634         ulInFrameSize: ULONG,
635         ppCoMemOutFrame: *mut *mut c_void,
636         pulOutFrameSize: *mut ULONG,
637     ) -> HRESULT,
638 }}
639 extern {
640     pub static LIBID_SpeechDDKLib: IID;
641     pub static CLSID_SpDataKey: CLSID;
642 }
643 RIDL!{#[uuid(0xd9f6ee60, 0x58c9, 0x458b, 0x88, 0xe1, 0x2f, 0x90, 0x8f, 0xd7, 0xf8, 0x7c)]
644 class SpDataKey;}
645 extern {
646     pub static CLSID_SpObjectTokenEnum: CLSID;
647     pub static CLSID_SpPhraseBuilder: CLSID;
648     pub static CLSID_SpITNProcessor: CLSID;
649     pub static CLSID_SpGrammarCompiler: CLSID;
650     pub static CLSID_SpGramCompBackend: CLSID;
651 }
652