vendor/winapi/src/um/sapiddk51.rs

   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 }