dlls/sapi/tts.c

   1 /*
   2  * Speech API (SAPI) text-to-speech implementation.
   3  *
   4  * Copyright 2019 Jactry Zeng for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "objbase.h"
  28
  29 #include "sapiddk.h"
  30 #include "sperror.h"
  31
  32 #include "wine/debug.h"
  33
  34 #include "sapi_private.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(sapi);
  37
  38 struct speech_voice
  39 {
  40     ISpeechVoice ISpeechVoice_iface;
  41     ISpVoice ISpVoice_iface;
  42     IConnectionPointContainer IConnectionPointContainer_iface;
  43     LONG ref;
  44
  45     ISpStreamFormat *output;
  46     ISpObjectToken *engine_token;
  47     ISpTTSEngine *engine;
  48     LONG cur_stream_num;
  49     DWORD actions;
  50     USHORT volume;
  51     LONG rate;
  52     struct async_queue queue;
  53     CRITICAL_SECTION cs;
  54 };
  55
  56 static inline struct speech_voice *impl_from_ISpeechVoice(ISpeechVoice *iface)
  57 {
  58     return CONTAINING_RECORD(iface, struct speech_voice, ISpeechVoice_iface);
  59 }
  60
  61 static inline struct speech_voice *impl_from_ISpVoice(ISpVoice *iface)
  62 {
  63     return CONTAINING_RECORD(iface, struct speech_voice, ISpVoice_iface);
  64 }
  65
  66 static inline struct speech_voice *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
  67 {
  68     return CONTAINING_RECORD(iface, struct speech_voice, IConnectionPointContainer_iface);
  69 }
  70
  71 struct tts_engine_site
  72 {
  73     ISpTTSEngineSite ISpTTSEngineSite_iface;
  74     LONG ref;
  75
  76     struct speech_voice *voice;
  77     ULONG stream_num;
  78 };
  79
  80 static inline struct tts_engine_site *impl_from_ISpTTSEngineSite(ISpTTSEngineSite *iface)
  81 {
  82     return CONTAINING_RECORD(iface, struct tts_engine_site, ISpTTSEngineSite_iface);
  83 }
  84
  85 static HRESULT create_token_category(const WCHAR *cat_id, ISpObjectTokenCategory **cat)
  86 {
  87     HRESULT hr;
  88     if (FAILED(hr = CoCreateInstance(&CLSID_SpObjectTokenCategory, NULL, CLSCTX_INPROC_SERVER,
  89                                      &IID_ISpObjectTokenCategory, (void **)cat)))
  90         return hr;
  91     return ISpObjectTokenCategory_SetId(*cat, cat_id, FALSE);
  92 }
  93
  94 static HRESULT create_default_token(const WCHAR *cat_id, ISpObjectToken **token)
  95 {
  96     ISpObjectTokenCategory *cat;
  97     WCHAR *default_token_id = NULL;
  98     HRESULT hr;
  99
 100     TRACE("(%s, %p).\n", debugstr_w(cat_id), token);
 101
 102     if (FAILED(hr = create_token_category(cat_id, &cat)))
 103         return hr;
 104
 105     hr = ISpObjectTokenCategory_GetDefaultTokenId(cat, &default_token_id);
 106     ISpObjectTokenCategory_Release(cat);
 107     if (FAILED(hr))
 108         return hr;
 109
 110     if (FAILED(hr = CoCreateInstance(&CLSID_SpObjectToken, NULL, CLSCTX_INPROC_SERVER,
 111                                      &IID_ISpObjectToken, (void **)token)))
 112         goto done;
 113
 114     if (FAILED(hr = ISpObjectToken_SetId(*token, NULL, default_token_id, FALSE)))
 115     {
 116         ISpObjectToken_Release(*token);
 117         *token = NULL;
 118     }
 119
 120 done:
 121     CoTaskMemFree(default_token_id);
 122     return hr;
 123 }
 124
 125 /* ISpeechVoice interface */
 126 static HRESULT WINAPI speech_voice_QueryInterface(ISpeechVoice *iface, REFIID iid, void **obj)
 127 {
 128     struct speech_voice *This = impl_from_ISpeechVoice(iface);
 129
 130     TRACE("(%p, %s %p).\n", iface, debugstr_guid(iid), obj);
 131
 132     if (IsEqualIID(iid, &IID_IUnknown) ||
 133         IsEqualIID(iid, &IID_IDispatch) ||
 134         IsEqualIID(iid, &IID_ISpeechVoice))
 135         *obj = &This->ISpeechVoice_iface;
 136     else if (IsEqualIID(iid, &IID_ISpVoice))
 137         *obj = &This->ISpVoice_iface;
 138     else if (IsEqualIID(iid, &IID_IConnectionPointContainer))
 139         *obj = &This->IConnectionPointContainer_iface;
 140     else
 141     {
 142         *obj = NULL;
 143         FIXME("interface %s not implemented.\n", debugstr_guid(iid));
 144         return E_NOINTERFACE;
 145     }
 146
 147     IUnknown_AddRef((IUnknown *)*obj);
 148     return S_OK;
 149 }
 150
 151 static ULONG WINAPI speech_voice_AddRef(ISpeechVoice *iface)
 152 {
 153     struct speech_voice *This = impl_from_ISpeechVoice(iface);
 154     ULONG ref = InterlockedIncrement(&This->ref);
 155
 156     TRACE("(%p): ref=%lu.\n", iface, ref);
 157
 158     return ref;
 159 }
 160
 161 static ULONG WINAPI speech_voice_Release(ISpeechVoice *iface)
 162 {
 163     struct speech_voice *This = impl_from_ISpeechVoice(iface);
 164     ULONG ref = InterlockedDecrement(&This->ref);
 165
 166     TRACE("(%p): ref=%lu.\n", iface, ref);
 167
 168     if (!ref)
 169     {
 170         async_cancel_queue(&This->queue);
 171         if (This->output) ISpStreamFormat_Release(This->output);
 172         if (This->engine_token) ISpObjectToken_Release(This->engine_token);
 173         if (This->engine) ISpTTSEngine_Release(This->engine);
 174         DeleteCriticalSection(&This->cs);
 175
 176         free(This);
 177     }
 178
 179     return ref;
 180 }
 181
 182 static HRESULT WINAPI speech_voice_GetTypeInfoCount(ISpeechVoice *iface, UINT *count)
 183 {
 184     TRACE("(%p, %p).\n", iface, count);
 185     *count = 1;
 186     return S_OK;
 187 }
 188
 189 static HRESULT WINAPI speech_voice_GetTypeInfo(ISpeechVoice *iface, UINT index, LCID lcid,
 190                                                ITypeInfo **type_info)
 191 {
 192     TRACE("(%p, %u, %#lx, %p).\n", iface, index, lcid, type_info);
 193     if (index != 0) return DISP_E_BADINDEX;
 194     return get_typeinfo(ISpeechVoice_tid, type_info);
 195 }
 196
 197 static HRESULT WINAPI speech_voice_GetIDsOfNames(ISpeechVoice *iface, REFIID riid, LPOLESTR *names,
 198                                                  UINT count, LCID lcid, DISPID *dispids)
 199 {
 200     ITypeInfo *typeinfo;
 201     HRESULT hr;
 202
 203     TRACE("(%p, %s, %p, %u, %#lx, %p).\n", iface, debugstr_guid(riid), names, count, lcid, dispids);
 204
 205     if (FAILED(hr = get_typeinfo(ISpeechVoice_tid, &typeinfo)))
 206         return hr;
 207     hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, dispids);
 208     ITypeInfo_Release(typeinfo);
 209     return hr;
 210 }
 211
 212 static HRESULT WINAPI speech_voice_Invoke(ISpeechVoice *iface, DISPID dispid, REFIID riid, LCID lcid,
 213                                           WORD flags, DISPPARAMS *params, VARIANT *result,
 214                                           EXCEPINFO *excepinfo, UINT *argerr)
 215 {
 216     ITypeInfo *typeinfo;
 217     HRESULT hr;
 218
 219     TRACE("(%p, %ld, %s, %#lx, %#x, %p, %p, %p, %p).\n", iface, dispid, debugstr_guid(riid),
 220           lcid, flags, params, result, excepinfo, argerr);
 221
 222     if (FAILED(hr = get_typeinfo(ISpeechVoice_tid, &typeinfo)))
 223         return hr;
 224     hr = ITypeInfo_Invoke(typeinfo, iface, dispid, flags, params, result, excepinfo, argerr);
 225     ITypeInfo_Release(typeinfo);
 226     return hr;
 227 }
 228
 229 static HRESULT WINAPI speech_voice_get_Status(ISpeechVoice *iface, ISpeechVoiceStatus **status)
 230 {
 231     FIXME("(%p, %p): stub.\n", iface, status);
 232
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI speech_voice_get_Voice(ISpeechVoice *iface, ISpeechObjectToken **voice)
 237 {
 238     struct speech_voice *This = impl_from_ISpeechVoice(iface);
 239     ISpObjectToken *token;
 240     HRESULT hr;
 241
 242     TRACE("(%p, %p).\n", iface, voice);
 243
 244     if (!voice) return E_POINTER;
 245     if (FAILED(hr = ISpVoice_GetVoice(&This->ISpVoice_iface, &token)))
 246         return hr;
 247     hr = ISpObjectToken_QueryInterface(token, &IID_ISpeechObjectToken, (void **)voice);
 248     ISpObjectToken_Release(token);
 249     return hr;
 250 }
 251
 252 static HRESULT WINAPI speech_voice_putref_Voice(ISpeechVoice *iface, ISpeechObjectToken *voice)
 253 {
 254     struct speech_voice *This = impl_from_ISpeechVoice(iface);
 255     ISpObjectToken *token;
 256     HRESULT hr;
 257
 258     TRACE("(%p, %p).\n", iface, voice);
 259
 260     if (!voice) return E_INVALIDARG;
 261     if (FAILED(hr = ISpeechObjectToken_QueryInterface(voice, &IID_ISpObjectToken, (void **)&token)))
 262         return hr;
 263     hr = ISpVoice_SetVoice(&This->ISpVoice_iface, token);
 264     ISpObjectToken_Release(token);
 265     return hr;
 266 }
 267
 268 static HRESULT WINAPI speech_voice_get_AudioOutput(ISpeechVoice *iface, ISpeechObjectToken **output)
 269 {
 270     FIXME("(%p, %p): stub.\n", iface, output);
 271
 272     return E_NOTIMPL;
 273 }
 274
 275 static HRESULT WINAPI speech_voice_putref_AudioOutput(ISpeechVoice *iface, ISpeechObjectToken *output)
 276 {
 277     FIXME("(%p, %p): stub.\n", iface, output);
 278
 279     return E_NOTIMPL;
 280 }
 281
 282 static HRESULT WINAPI speech_voice_get_AudioOutputStream(ISpeechVoice *iface, ISpeechBaseStream **output)
 283 {
 284     FIXME("(%p, %p): stub.\n", iface, output);
 285
 286     return E_NOTIMPL;
 287 }
 288
 289 static HRESULT WINAPI speech_voice_putref_AudioOutputStream(ISpeechVoice *iface, ISpeechBaseStream *output)
 290 {
 291     FIXME("(%p, %p): stub.\n", iface, output);
 292
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI speech_voice_get_Rate(ISpeechVoice *iface, LONG *rate)
 297 {
 298     FIXME("(%p, %p): stub.\n", iface, rate);
 299
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI speech_voice_put_Rate(ISpeechVoice *iface, LONG rate)
 304 {
 305     FIXME("(%p, %ld): stub.\n", iface, rate);
 306
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI speech_voice_get_Volume(ISpeechVoice *iface, LONG *volume)
 311 {
 312     struct speech_voice *This = impl_from_ISpeechVoice(iface);
 313     USHORT res = 0;
 314     HRESULT hr;
 315
 316     TRACE("(%p, %p).\n", iface, volume);
 317
 318     if (!volume) return E_POINTER;
 319     hr = ISpVoice_GetVolume(&This->ISpVoice_iface, &res);
 320     *volume = res;
 321     return hr;
 322 }
 323
 324 static HRESULT WINAPI speech_voice_put_Volume(ISpeechVoice *iface, LONG volume)
 325 {
 326     struct speech_voice *This = impl_from_ISpeechVoice(iface);
 327
 328     TRACE("(%p, %ld).\n", iface, volume);
 329
 330     return ISpVoice_SetVolume(&This->ISpVoice_iface, (USHORT)volume);
 331 }
 332
 333 static HRESULT WINAPI speech_voice_put_AllowAudioOutputFormatChangesOnNextSet(ISpeechVoice *iface,
 334                                                                               VARIANT_BOOL allow)
 335 {
 336     FIXME("(%p, %d): stub.\n", iface, allow);
 337
 338     return E_NOTIMPL;
 339 }
 340
 341 static HRESULT WINAPI speech_voice_get_AllowAudioOutputFormatChangesOnNextSet(ISpeechVoice *iface, VARIANT_BOOL *allow)
 342 {
 343     FIXME("(%p, %p): stub.\n", iface, allow);
 344
 345     return E_NOTIMPL;
 346 }
 347
 348 static HRESULT WINAPI speech_voice_get_EventInterests(ISpeechVoice *iface, SpeechVoiceEvents *flags)
 349 {
 350     FIXME("(%p, %p): stub.\n", iface, flags);
 351
 352     return E_NOTIMPL;
 353 }
 354
 355 static HRESULT WINAPI speech_voice_put_EventInterests(ISpeechVoice *iface, SpeechVoiceEvents flags)
 356 {
 357     FIXME("(%p, %#x): stub.\n", iface, flags);
 358
 359     return E_NOTIMPL;
 360 }
 361
 362 static HRESULT WINAPI speech_voice_put_Priority(ISpeechVoice *iface, SpeechVoicePriority priority)
 363 {
 364     FIXME("(%p, %d): stub.\n", iface, priority);
 365
 366     return E_NOTIMPL;
 367 }
 368
 369 static HRESULT WINAPI speech_voice_get_Priority(ISpeechVoice *iface, SpeechVoicePriority *priority)
 370 {
 371     FIXME("(%p, %p): stub.\n", iface, priority);
 372
 373     return E_NOTIMPL;
 374 }
 375
 376 static HRESULT WINAPI speech_voice_put_AlertBoundary(ISpeechVoice *iface, SpeechVoiceEvents boundary)
 377 {
 378     FIXME("(%p, %#x): stub.\n", iface, boundary);
 379
 380     return E_NOTIMPL;
 381 }
 382
 383 static HRESULT WINAPI speech_voice_get_AlertBoundary(ISpeechVoice *iface, SpeechVoiceEvents *boundary)
 384 {
 385     FIXME("(%p, %p): stub.\n", iface, boundary);
 386
 387     return E_NOTIMPL;
 388 }
 389
 390 static HRESULT WINAPI speech_voice_put_SynchronousSpeakTimeout(ISpeechVoice *iface, LONG timeout)
 391 {
 392     FIXME("(%p, %ld): stub.\n", iface, timeout);
 393
 394     return E_NOTIMPL;
 395 }
 396
 397 static HRESULT WINAPI speech_voice_get_SynchronousSpeakTimeout(ISpeechVoice *iface, LONG *timeout)
 398 {
 399     FIXME("(%p, %p): stub.\n", iface, timeout);
 400
 401     return E_NOTIMPL;
 402 }
 403
 404 static HRESULT WINAPI speech_voice_Speak(ISpeechVoice *iface, BSTR text, SpeechVoiceSpeakFlags flags, LONG *number)
 405 {
 406     struct speech_voice *This = impl_from_ISpeechVoice(iface);
 407
 408     TRACE("(%p, %s, %#x, %p).\n", iface, debugstr_w(text), flags, number);
 409
 410     return ISpVoice_Speak(&This->ISpVoice_iface, text, flags, (ULONG *)number);
 411 }
 412
 413 static HRESULT WINAPI speech_voice_SpeakStream(ISpeechVoice *iface, ISpeechBaseStream *stream,
 414                                                SpeechVoiceSpeakFlags flags, LONG *number)
 415 {
 416     FIXME("(%p, %p, %#x, %p): stub.\n", iface, stream, flags, number);
 417
 418     return E_NOTIMPL;
 419 }
 420
 421 static HRESULT WINAPI speech_voice_Pause(ISpeechVoice *iface)
 422 {
 423     FIXME("(%p): stub.\n", iface);
 424
 425     return E_NOTIMPL;
 426 }
 427
 428 static HRESULT WINAPI speech_voice_Resume(ISpeechVoice *iface)
 429 {
 430     FIXME("(%p): stub.\n", iface);
 431
 432     return E_NOTIMPL;
 433 }
 434
 435 static HRESULT WINAPI speech_voice_Skip(ISpeechVoice *iface, const BSTR type, LONG items, LONG *skipped)
 436 {
 437     FIXME("(%p, %s, %ld, %p): stub.\n", iface, debugstr_w(type), items, skipped);
 438
 439     return E_NOTIMPL;
 440 }
 441
 442 static HRESULT WINAPI speech_voice_GetVoices(ISpeechVoice *iface, BSTR required, BSTR optional,
 443                                              ISpeechObjectTokens **tokens)
 444 {
 445
 446     ISpObjectTokenCategory *cat;
 447     IEnumSpObjectTokens *token_enum;
 448     HRESULT hr;
 449
 450     TRACE("(%p, %s, %s, %p).\n", iface, debugstr_w(required), debugstr_w(optional), tokens);
 451
 452     if (!tokens) return E_POINTER;
 453
 454     if (FAILED(hr = create_token_category(SPCAT_VOICES, &cat)))
 455         return hr;
 456
 457     if (SUCCEEDED(hr = ISpObjectTokenCategory_EnumTokens(cat, required, optional, &token_enum)))
 458     {
 459         hr = IEnumSpObjectTokens_QueryInterface(token_enum, &IID_ISpeechObjectTokens, (void **)tokens);
 460         IEnumSpObjectTokens_Release(token_enum);
 461     }
 462
 463     ISpObjectTokenCategory_Release(cat);
 464     return hr;
 465 }
 466
 467 static HRESULT WINAPI speech_voice_GetAudioOutputs(ISpeechVoice *iface, BSTR required, BSTR optional,
 468                                                    ISpeechObjectTokens **tokens)
 469 {
 470     FIXME("(%p, %s, %s, %p): stub.\n", iface, debugstr_w(required), debugstr_w(optional), tokens);
 471
 472     return E_NOTIMPL;
 473 }
 474
 475 static HRESULT WINAPI speech_voice_WaitUntilDone(ISpeechVoice *iface, LONG timeout, VARIANT_BOOL *done)
 476 {
 477     FIXME("(%p, %ld, %p): stub.\n", iface, timeout, done);
 478
 479     return E_NOTIMPL;
 480 }
 481
 482 static HRESULT WINAPI speech_voice_SpeakCompleteEvent(ISpeechVoice *iface, LONG *handle)
 483 {
 484     FIXME("(%p, %p): stub.\n", iface, handle);
 485
 486     return E_NOTIMPL;
 487 }
 488
 489 static HRESULT WINAPI speech_voice_IsUISupported(ISpeechVoice *iface, const BSTR typeui, const VARIANT *data,
 490                                                  VARIANT_BOOL *supported)
 491 {
 492     FIXME("(%p, %s, %p, %p): stub.\n", iface, debugstr_w(typeui), data, supported);
 493
 494     return E_NOTIMPL;
 495 }
 496
 497 static HRESULT WINAPI speech_voice_DisplayUI(ISpeechVoice *iface, LONG hwnd, BSTR title,
 498                                              const BSTR typeui, const VARIANT *data)
 499 {
 500     FIXME("(%p, %ld, %s, %s, %p): stub.\n", iface, hwnd, debugstr_w(title), debugstr_w(typeui), data);
 501
 502     return E_NOTIMPL;
 503 }
 504
 505 static const ISpeechVoiceVtbl speech_voice_vtbl =
 506 {
 507     speech_voice_QueryInterface,
 508     speech_voice_AddRef,
 509     speech_voice_Release,
 510     speech_voice_GetTypeInfoCount,
 511     speech_voice_GetTypeInfo,
 512     speech_voice_GetIDsOfNames,
 513     speech_voice_Invoke,
 514     speech_voice_get_Status,
 515     speech_voice_get_Voice,
 516     speech_voice_putref_Voice,
 517     speech_voice_get_AudioOutput,
 518     speech_voice_putref_AudioOutput,
 519     speech_voice_get_AudioOutputStream,
 520     speech_voice_putref_AudioOutputStream,
 521     speech_voice_get_Rate,
 522     speech_voice_put_Rate,
 523     speech_voice_get_Volume,
 524     speech_voice_put_Volume,
 525     speech_voice_put_AllowAudioOutputFormatChangesOnNextSet,
 526     speech_voice_get_AllowAudioOutputFormatChangesOnNextSet,
 527     speech_voice_get_EventInterests,
 528     speech_voice_put_EventInterests,
 529     speech_voice_put_Priority,
 530     speech_voice_get_Priority,
 531     speech_voice_put_AlertBoundary,
 532     speech_voice_get_AlertBoundary,
 533     speech_voice_put_SynchronousSpeakTimeout,
 534     speech_voice_get_SynchronousSpeakTimeout,
 535     speech_voice_Speak,
 536     speech_voice_SpeakStream,
 537     speech_voice_Pause,
 538     speech_voice_Resume,
 539     speech_voice_Skip,
 540     speech_voice_GetVoices,
 541     speech_voice_GetAudioOutputs,
 542     speech_voice_WaitUntilDone,
 543     speech_voice_SpeakCompleteEvent,
 544     speech_voice_IsUISupported,
 545     speech_voice_DisplayUI,
 546 };
 547
 548 /* ISpVoice interface */
 549 static HRESULT WINAPI spvoice_QueryInterface(ISpVoice *iface, REFIID iid, void **obj)
 550 {
 551     struct speech_voice *This = impl_from_ISpVoice(iface);
 552
 553     TRACE("(%p, %s %p).\n", iface, debugstr_guid(iid), obj);
 554
 555     return ISpeechVoice_QueryInterface(&This->ISpeechVoice_iface, iid, obj);
 556 }
 557
 558 static ULONG WINAPI spvoice_AddRef(ISpVoice *iface)
 559 {
 560     struct speech_voice *This = impl_from_ISpVoice(iface);
 561
 562     TRACE("(%p).\n", iface);
 563
 564     return ISpeechVoice_AddRef(&This->ISpeechVoice_iface);
 565 }
 566
 567 static ULONG WINAPI spvoice_Release(ISpVoice *iface)
 568 {
 569     struct speech_voice *This = impl_from_ISpVoice(iface);
 570
 571     TRACE("(%p).\n", iface);
 572
 573     return ISpeechVoice_Release(&This->ISpeechVoice_iface);
 574 }
 575
 576 static HRESULT WINAPI spvoice_SetNotifySink(ISpVoice *iface, ISpNotifySink *sink)
 577 {
 578     FIXME("(%p, %p): stub.\n", iface, sink);
 579
 580     return E_NOTIMPL;
 581 }
 582
 583 static HRESULT WINAPI spvoice_SetNotifyWindowMessage(ISpVoice *iface, HWND hwnd, UINT msg,
 584                                                      WPARAM wparam, LPARAM lparam)
 585 {
 586     FIXME("(%p, %p, %u, %Ix, %Ix): stub.\n", iface, hwnd, msg, wparam, lparam);
 587
 588     return E_NOTIMPL;
 589 }
 590
 591 static HRESULT WINAPI spvoice_SetNotifyCallbackFunction(ISpVoice *iface, SPNOTIFYCALLBACK *callback,
 592                                                         WPARAM wparam, LPARAM lparam)
 593 {
 594     FIXME("(%p, %p, %Ix, %Ix): stub.\n", iface, callback, wparam, lparam);
 595
 596     return E_NOTIMPL;
 597 }
 598
 599 static HRESULT WINAPI spvoice_SetNotifyCallbackInterface(ISpVoice *iface, ISpNotifyCallback *callback,
 600                                                          WPARAM wparam, LPARAM lparam)
 601 {
 602     FIXME("(%p, %p, %Ix, %Ix): stub.\n", iface, callback, wparam, lparam);
 603
 604     return E_NOTIMPL;
 605 }
 606
 607 static HRESULT WINAPI spvoice_SetNotifyWin32Event(ISpVoice *iface)
 608 {
 609     FIXME("(%p): stub.\n", iface);
 610
 611     return E_NOTIMPL;
 612 }
 613
 614 static HRESULT WINAPI spvoice_WaitForNotifyEvent(ISpVoice *iface, DWORD milliseconds)
 615 {
 616     FIXME("(%p, %ld): stub.\n", iface, milliseconds);
 617
 618     return E_NOTIMPL;
 619 }
 620
 621 static HANDLE WINAPI spvoice_GetNotifyEventHandle(ISpVoice *iface)
 622 {
 623     FIXME("(%p): stub.\n", iface);
 624
 625     return NULL;
 626 }
 627
 628 static HRESULT WINAPI spvoice_SetInterest(ISpVoice *iface, ULONGLONG event, ULONGLONG queued)
 629 {
 630     FIXME("(%p, %s, %s): stub.\n", iface, wine_dbgstr_longlong(event), wine_dbgstr_longlong(queued));
 631
 632     return E_NOTIMPL;
 633 }
 634
 635 static HRESULT WINAPI spvoice_GetEvents(ISpVoice *iface, ULONG count, SPEVENT *array, ULONG *fetched)
 636 {
 637     FIXME("(%p, %lu, %p, %p): stub.\n", iface, count, array, fetched);
 638
 639     return E_NOTIMPL;
 640 }
 641
 642 static HRESULT WINAPI spvoice_GetInfo(ISpVoice *iface, SPEVENTSOURCEINFO *info)
 643 {
 644     FIXME("(%p, %p): stub.\n", iface, info);
 645
 646     return E_NOTIMPL;
 647 }
 648
 649 static HRESULT WINAPI spvoice_SetOutput(ISpVoice *iface, IUnknown *unk, BOOL allow_format_changes)
 650 {
 651     struct speech_voice *This = impl_from_ISpVoice(iface);
 652     ISpStreamFormat *stream = NULL;
 653     ISpObjectToken *token = NULL;
 654     HRESULT hr;
 655
 656     TRACE("(%p, %p, %d).\n", iface, unk, allow_format_changes);
 657
 658     if (!allow_format_changes)
 659         FIXME("ignoring allow_format_changes = FALSE.\n");
 660
 661     if (FAILED(hr = async_start_queue(&This->queue)))
 662         return hr;
 663
 664     if (!unk)
 665     {
 666         /* TODO: Create the default SpAudioOut token here once SpMMAudioEnum is implemented. */
 667         if (FAILED(hr = CoCreateInstance(&CLSID_SpMMAudioOut, NULL, CLSCTX_INPROC_SERVER,
 668                                          &IID_ISpStreamFormat, (void **)&stream)))
 669             return hr;
 670     }
 671     else
 672     {
 673         if (FAILED(IUnknown_QueryInterface(unk, &IID_ISpStreamFormat, (void **)&stream)))
 674         {
 675             if (FAILED(IUnknown_QueryInterface(unk, &IID_ISpObjectToken, (void **)&token)))
 676                 return E_INVALIDARG;
 677         }
 678     }
 679
 680     if (!stream)
 681     {
 682         hr = ISpObjectToken_CreateInstance(token, NULL, CLSCTX_ALL, &IID_ISpStreamFormat, (void **)&stream);
 683         ISpObjectToken_Release(token);
 684         if (FAILED(hr))
 685             return hr;
 686     }
 687
 688     EnterCriticalSection(&This->cs);
 689
 690     if (This->output)
 691         ISpStreamFormat_Release(This->output);
 692     This->output = stream;
 693
 694     LeaveCriticalSection(&This->cs);
 695
 696     return S_OK;
 697 }
 698
 699 static HRESULT WINAPI spvoice_GetOutputObjectToken(ISpVoice *iface, ISpObjectToken **token)
 700 {
 701     FIXME("(%p, %p): stub.\n", iface, token);
 702
 703     return E_NOTIMPL;
 704 }
 705
 706 static HRESULT WINAPI spvoice_GetOutputStream(ISpVoice *iface, ISpStreamFormat **stream)
 707 {
 708     FIXME("(%p, %p): stub.\n", iface, stream);
 709
 710     return E_NOTIMPL;
 711 }
 712
 713 static HRESULT WINAPI spvoice_Pause(ISpVoice *iface)
 714 {
 715     FIXME("(%p): stub.\n", iface);
 716
 717     return E_NOTIMPL;
 718 }
 719
 720 static HRESULT WINAPI spvoice_Resume(ISpVoice *iface)
 721 {
 722     FIXME("(%p): stub.\n", iface);
 723
 724     return E_NOTIMPL;
 725 }
 726
 727 static HRESULT WINAPI spvoice_SetVoice(ISpVoice *iface, ISpObjectToken *token)
 728 {
 729     struct speech_voice *This = impl_from_ISpVoice(iface);
 730     WCHAR *id = NULL, *old_id = NULL;
 731     HRESULT hr;
 732
 733     TRACE("(%p, %p).\n", iface, token);
 734
 735     if (!token)
 736     {
 737         if (FAILED(hr = create_default_token(SPCAT_VOICES, &token)))
 738             return hr;
 739     }
 740     else
 741         ISpObjectToken_AddRef(token);
 742
 743     EnterCriticalSection(&This->cs);
 744
 745     if (This->engine_token &&
 746         SUCCEEDED(ISpObjectToken_GetId(token, &id)) &&
 747         SUCCEEDED(ISpObjectToken_GetId(This->engine_token, &old_id)) &&
 748         !wcscmp(id, old_id))
 749     {
 750         ISpObjectToken_Release(token);
 751         goto done;
 752     }
 753
 754     if (This->engine_token)
 755         ISpObjectToken_Release(This->engine_token);
 756     This->engine_token = token;
 757
 758     if (This->engine)
 759     {
 760         ISpTTSEngine_Release(This->engine);
 761         This->engine = NULL;
 762     }
 763
 764 done:
 765     LeaveCriticalSection(&This->cs);
 766     CoTaskMemFree(id);
 767     CoTaskMemFree(old_id);
 768     return S_OK;
 769 }
 770
 771 static HRESULT WINAPI spvoice_GetVoice(ISpVoice *iface, ISpObjectToken **token)
 772 {
 773     struct speech_voice *This = impl_from_ISpVoice(iface);
 774
 775     TRACE("(%p, %p).\n", iface, token);
 776
 777     if (!token)
 778         return E_POINTER;
 779
 780     EnterCriticalSection(&This->cs);
 781
 782     if (!This->engine_token)
 783     {
 784         LeaveCriticalSection(&This->cs);
 785         return create_default_token(SPCAT_VOICES, token);
 786     }
 787
 788     ISpObjectToken_AddRef(This->engine_token);
 789     *token = This->engine_token;
 790
 791     LeaveCriticalSection(&This->cs);
 792
 793     return S_OK;
 794 }
 795
 796 struct async_result
 797 {
 798     HANDLE done;
 799     HRESULT hr;
 800 };
 801
 802 struct speak_task
 803 {
 804     struct async_task task;
 805     struct async_result *result;
 806
 807     struct speech_voice *voice;
 808     ISpTTSEngine *engine;
 809     SPVTEXTFRAG *frag_list;
 810     ISpTTSEngineSite *site;
 811     DWORD flags;
 812 };
 813
 814 static HRESULT set_output_format(ISpStreamFormat *output, ISpTTSEngine *engine, GUID *fmtid, WAVEFORMATEX **wfx)
 815 {
 816     GUID output_fmtid;
 817     WAVEFORMATEX *output_wfx = NULL;
 818     ISpAudio *audio = NULL;
 819     HRESULT hr;
 820
 821     if (FAILED(hr = ISpStreamFormat_GetFormat(output, &output_fmtid, &output_wfx)))
 822         return hr;
 823     if (FAILED(hr = ISpTTSEngine_GetOutputFormat(engine, &output_fmtid, output_wfx, fmtid, wfx)))
 824         goto done;
 825     if (!IsEqualGUID(fmtid, &SPDFID_WaveFormatEx))
 826     {
 827         hr = E_INVALIDARG;
 828         goto done;
 829     }
 830
 831     if (memcmp(output_wfx, *wfx, sizeof(WAVEFORMATEX)) ||
 832         memcmp(output_wfx + 1, *wfx + 1, output_wfx->cbSize))
 833     {
 834         if (FAILED(hr = ISpStreamFormat_QueryInterface(output, &IID_ISpAudio, (void **)&audio)) ||
 835             FAILED(hr = ISpAudio_SetFormat(audio, &SPDFID_WaveFormatEx, *wfx)))
 836             goto done;
 837     }
 838
 839 done:
 840     CoTaskMemFree(output_wfx);
 841     if (audio) ISpAudio_Release(audio);
 842     return hr;
 843 }
 844
 845 static void speak_proc(struct async_task *task)
 846 {
 847     struct speak_task *speak_task = (struct speak_task *)task;
 848     struct speech_voice *This = speak_task->voice;
 849     GUID fmtid;
 850     WAVEFORMATEX *wfx = NULL;
 851     ISpAudio *audio = NULL;
 852     HRESULT hr;
 853
 854     TRACE("(%p).\n", task);
 855
 856     EnterCriticalSection(&This->cs);
 857
 858     if (This->actions & SPVES_ABORT)
 859     {
 860         LeaveCriticalSection(&This->cs);
 861         hr = S_OK;
 862         goto done;
 863     }
 864
 865     if (FAILED(hr = set_output_format(This->output, This->engine, &fmtid, &wfx)))
 866     {
 867         LeaveCriticalSection(&This->cs);
 868         ERR("failed setting output format: %#lx.\n", hr);
 869         goto done;
 870     }
 871
 872     if (SUCCEEDED(ISpStreamFormat_QueryInterface(This->output, &IID_ISpAudio, (void **)&audio)))
 873         ISpAudio_SetState(audio, SPAS_RUN, 0);
 874
 875     This->actions = SPVES_RATE | SPVES_VOLUME;
 876
 877     LeaveCriticalSection(&This->cs);
 878
 879     hr = ISpTTSEngine_Speak(speak_task->engine, speak_task->flags, &fmtid, wfx, speak_task->frag_list, speak_task->site);
 880     if (SUCCEEDED(hr))
 881     {
 882         ISpStreamFormat_Commit(This->output, STGC_DEFAULT);
 883         if (audio)
 884             WaitForSingleObject(ISpAudio_EventHandle(audio), INFINITE);
 885     }
 886     else
 887         WARN("ISpTTSEngine_Speak failed: %#lx.\n", hr);
 888
 889 done:
 890     if (audio)
 891     {
 892         ISpAudio_SetState(audio, SPAS_CLOSED, 0);
 893         ISpAudio_Release(audio);
 894     }
 895     CoTaskMemFree(wfx);
 896     ISpTTSEngine_Release(speak_task->engine);
 897     free(speak_task->frag_list);
 898     ISpTTSEngineSite_Release(speak_task->site);
 899
 900     if (speak_task->result)
 901     {
 902         speak_task->result->hr = hr;
 903         SetEvent(speak_task->result->done);
 904     }
 905 }
 906
 907 static HRESULT ttsenginesite_create(struct speech_voice *voice, ULONG stream_num, ISpTTSEngineSite **site);
 908
 909 static HRESULT WINAPI spvoice_Speak(ISpVoice *iface, const WCHAR *contents, DWORD flags, ULONG *stream_num_out)
 910 {
 911     struct speech_voice *This = impl_from_ISpVoice(iface);
 912     ISpTTSEngineSite *site = NULL;
 913     ISpTTSEngine *engine = NULL;
 914     SPVTEXTFRAG *frag;
 915     struct speak_task *speak_task = NULL;
 916     struct async_result *result = NULL;
 917     size_t contents_len, contents_size;
 918     ULONG stream_num;
 919     HRESULT hr;
 920
 921     TRACE("(%p, %p, %#lx, %p).\n", iface, contents, flags, stream_num_out);
 922
 923     flags &= ~SPF_IS_NOT_XML;
 924     if (flags & ~(SPF_ASYNC | SPF_PURGEBEFORESPEAK | SPF_NLP_SPEAK_PUNC))
 925     {
 926         FIXME("flags %#lx not implemented.\n", flags & ~(SPF_ASYNC | SPF_PURGEBEFORESPEAK | SPF_NLP_SPEAK_PUNC));
 927         return E_NOTIMPL;
 928     }
 929
 930     if (flags & SPF_PURGEBEFORESPEAK)
 931     {
 932         ISpAudio *audio;
 933
 934         EnterCriticalSection(&This->cs);
 935
 936         This->actions = SPVES_ABORT;
 937         if (This->output && SUCCEEDED(ISpStreamFormat_QueryInterface(This->output, &IID_ISpAudio, (void **)&audio)))
 938         {
 939             ISpAudio_SetState(audio, SPAS_CLOSED, 0);
 940             ISpAudio_Release(audio);
 941         }
 942
 943         LeaveCriticalSection(&This->cs);
 944
 945         async_empty_queue(&This->queue);
 946
 947         EnterCriticalSection(&This->cs);
 948         This->actions = SPVES_CONTINUE;
 949         LeaveCriticalSection(&This->cs);
 950
 951         if (!contents || !*contents)
 952             return S_OK;
 953     }
 954     else if (!contents)
 955         return E_POINTER;
 956
 957     contents_len = wcslen(contents);
 958     contents_size = sizeof(WCHAR) * (contents_len + 1);
 959
 960     if (!This->output)
 961     {
 962         /* Create a new output stream with the default output. */
 963         if (FAILED(hr = ISpVoice_SetOutput(iface, NULL, TRUE)))
 964             return hr;
 965     }
 966
 967     EnterCriticalSection(&This->cs);
 968
 969     if (!This->engine_token)
 970     {
 971         /* Set the engine token to default. */
 972         if (FAILED(hr = ISpVoice_SetVoice(iface, NULL)))
 973         {
 974             LeaveCriticalSection(&This->cs);
 975             return hr;
 976         }
 977     }
 978     if (!This->engine &&
 979         FAILED(hr = ISpObjectToken_CreateInstance(This->engine_token, NULL, CLSCTX_ALL, &IID_ISpTTSEngine, (void **)&This->engine)))
 980     {
 981         LeaveCriticalSection(&This->cs);
 982         ERR("Failed to create engine: %#lx.\n", hr);
 983         return hr;
 984     }
 985     engine = This->engine;
 986     ISpTTSEngine_AddRef(engine);
 987
 988     LeaveCriticalSection(&This->cs);
 989
 990     if (!(frag = malloc(sizeof(*frag) + contents_size)))
 991         return E_OUTOFMEMORY;
 992     memset(frag, 0, sizeof(*frag));
 993     memcpy(frag + 1, contents, contents_size);
 994     frag->State.eAction = SPVA_Speak;
 995     frag->State.Volume  = 100;
 996     frag->pTextStart    = (WCHAR *)(frag + 1);
 997     frag->ulTextLen     = contents_len;
 998     frag->ulTextSrcOffset = 0;
 999
1000     stream_num = InterlockedIncrement(&This->cur_stream_num);
1001     if (FAILED(hr = ttsenginesite_create(This, stream_num, &site)))
1002     {
1003         FIXME("Failed to create ttsenginesite: %#lx.\n", hr);
1004         goto fail;
1005     }
1006
1007     speak_task = malloc(sizeof(*speak_task));
1008
1009     speak_task->task.proc = speak_proc;
1010     speak_task->result    = NULL;
1011     speak_task->voice     = This;
1012     speak_task->engine    = engine;
1013     speak_task->frag_list = frag;
1014     speak_task->site      = site;
1015     speak_task->flags     = flags & SPF_NLP_SPEAK_PUNC;
1016
1017     if (!(flags & SPF_ASYNC))
1018     {
1019         if (!(result = malloc(sizeof(*result))))
1020         {
1021             hr = E_OUTOFMEMORY;
1022             goto fail;
1023         }
1024         result->hr = E_FAIL;
1025         result->done = CreateEventW(NULL, FALSE, FALSE, NULL);
1026         speak_task->result = result;
1027     }
1028
1029     if (FAILED(hr = async_queue_task(&This->queue, (struct async_task *)speak_task)))
1030     {
1031         WARN("Failed to queue task: %#lx.\n", hr);
1032         goto fail;
1033     }
1034
1035     if (stream_num_out)
1036         *stream_num_out = stream_num;
1037
1038     if (flags & SPF_ASYNC)
1039         return S_OK;
1040     else
1041     {
1042         WaitForSingleObject(result->done, INFINITE);
1043         hr = result->hr;
1044         CloseHandle(result->done);
1045         free(result);
1046         return hr;
1047     }
1048
1049 fail:
1050     if (site) ISpTTSEngineSite_Release(site);
1051     if (engine) ISpTTSEngine_Release(engine);
1052     free(frag);
1053     free(speak_task);
1054     if (result)
1055     {
1056         CloseHandle(result->done);
1057         free(result);
1058     }
1059     return hr;
1060 }
1061
1062 static HRESULT WINAPI spvoice_SpeakStream(ISpVoice *iface, IStream *stream, DWORD flags, ULONG *number)
1063 {
1064     FIXME("(%p, %p, %#lx, %p): stub.\n", iface, stream, flags, number);
1065
1066     return E_NOTIMPL;
1067 }
1068
1069 static HRESULT WINAPI spvoice_GetStatus(ISpVoice *iface, SPVOICESTATUS *status, WCHAR **bookmark)
1070 {
1071     static unsigned int once;
1072
1073     if (!once++)
1074         FIXME("(%p, %p, %p): stub.\n", iface, status, bookmark);
1075     else
1076         WARN("(%p, %p, %p): stub.\n", iface, status, bookmark);
1077
1078     return E_NOTIMPL;
1079 }
1080
1081 static HRESULT WINAPI spvoice_Skip(ISpVoice *iface, const WCHAR *type, LONG items, ULONG *skipped)
1082 {
1083     FIXME("(%p, %s, %ld, %p): stub.\n", iface, debugstr_w(type), items, skipped);
1084
1085     return E_NOTIMPL;
1086 }
1087
1088 static HRESULT WINAPI spvoice_SetPriority(ISpVoice *iface, SPVPRIORITY priority)
1089 {
1090     FIXME("(%p, %d): stub.\n", iface, priority);
1091
1092     return E_NOTIMPL;
1093 }
1094
1095 static HRESULT WINAPI spvoice_GetPriority(ISpVoice *iface, SPVPRIORITY *priority)
1096 {
1097     FIXME("(%p, %p): stub.\n", iface, priority);
1098
1099     return E_NOTIMPL;
1100 }
1101
1102 static HRESULT WINAPI spvoice_SetAlertBoundary(ISpVoice *iface, SPEVENTENUM boundary)
1103 {
1104     FIXME("(%p, %d): stub.\n", iface, boundary);
1105
1106     return E_NOTIMPL;
1107 }
1108
1109 static HRESULT WINAPI spvoice_GetAlertBoundary(ISpVoice *iface, SPEVENTENUM *boundary)
1110 {
1111     FIXME("(%p, %p): stub.\n", iface, boundary);
1112
1113     return E_NOTIMPL;
1114 }
1115
1116 static HRESULT WINAPI spvoice_SetRate(ISpVoice *iface, LONG rate)
1117 {
1118     struct speech_voice *This = impl_from_ISpVoice(iface);
1119
1120     TRACE("(%p, %ld).\n", iface, rate);
1121
1122     EnterCriticalSection(&This->cs);
1123     This->rate = rate;
1124     This->actions |= SPVES_RATE;
1125     LeaveCriticalSection(&This->cs);
1126
1127     return S_OK;
1128 }
1129
1130 static HRESULT WINAPI spvoice_GetRate(ISpVoice *iface, LONG *rate)
1131 {
1132     struct speech_voice *This = impl_from_ISpVoice(iface);
1133
1134     TRACE("(%p, %p).\n", iface, rate);
1135
1136     EnterCriticalSection(&This->cs);
1137     *rate = This->rate;
1138     LeaveCriticalSection(&This->cs);
1139
1140     return S_OK;
1141 }
1142
1143 static HRESULT WINAPI spvoice_SetVolume(ISpVoice *iface, USHORT volume)
1144 {
1145     struct speech_voice *This = impl_from_ISpVoice(iface);
1146
1147     TRACE("(%p, %d).\n", iface, volume);
1148
1149     if (volume > 100)
1150         return E_INVALIDARG;
1151
1152     EnterCriticalSection(&This->cs);
1153     This->volume = volume;
1154     This->actions |= SPVES_VOLUME;
1155     LeaveCriticalSection(&This->cs);
1156
1157     return S_OK;
1158 }
1159
1160 static HRESULT WINAPI spvoice_GetVolume(ISpVoice *iface, USHORT *volume)
1161 {
1162     struct speech_voice *This = impl_from_ISpVoice(iface);
1163
1164     TRACE("(%p, %p).\n", iface, volume);
1165
1166     EnterCriticalSection(&This->cs);
1167     *volume = This->volume;
1168     LeaveCriticalSection(&This->cs);
1169
1170     return S_OK;
1171 }
1172
1173 static HRESULT WINAPI spvoice_WaitUntilDone(ISpVoice *iface, ULONG timeout)
1174 {
1175     struct speech_voice *This = impl_from_ISpVoice(iface);
1176     HRESULT hr;
1177
1178     TRACE("(%p, %ld).\n", iface, timeout);
1179
1180     hr = async_wait_queue_empty(&This->queue, timeout);
1181
1182     if (hr == WAIT_OBJECT_0) return S_OK;
1183     else if (hr == WAIT_TIMEOUT) return S_FALSE;
1184     return hr;
1185 }
1186
1187 static HRESULT WINAPI spvoice_SetSyncSpeakTimeout(ISpVoice *iface, ULONG timeout)
1188 {
1189     FIXME("(%p, %ld): stub.\n", iface, timeout);
1190
1191     return E_NOTIMPL;
1192 }
1193
1194 static HRESULT WINAPI spvoice_GetSyncSpeakTimeout(ISpVoice *iface, ULONG *timeout)
1195 {
1196     FIXME("(%p, %p): stub.\n", iface, timeout);
1197
1198     return E_NOTIMPL;
1199 }
1200
1201 static HANDLE WINAPI spvoice_SpeakCompleteEvent(ISpVoice *iface)
1202 {
1203     FIXME("(%p): stub.\n", iface);
1204
1205     return NULL;
1206 }
1207
1208 static HRESULT WINAPI spvoice_IsUISupported(ISpVoice *iface, const WCHAR *type, void *extra,
1209                                             ULONG count, BOOL *supported)
1210 {
1211     FIXME("(%p, %p, %p, %ld, %p): stub.\n", iface, type, extra, count, supported);
1212
1213     return E_NOTIMPL;
1214 }
1215
1216 static HRESULT WINAPI spvoice_DisplayUI(ISpVoice *iface, HWND parent, const WCHAR *title,
1217                                         const WCHAR *type, void *extra, ULONG count)
1218 {
1219     FIXME("(%p, %p, %p, %p, %p, %ld): stub.\n", iface, parent, title, type, extra, count);
1220
1221     return E_NOTIMPL;
1222 }
1223
1224 static const ISpVoiceVtbl spvoice_vtbl =
1225 {
1226     spvoice_QueryInterface,
1227     spvoice_AddRef,
1228     spvoice_Release,
1229     spvoice_SetNotifySink,
1230     spvoice_SetNotifyWindowMessage,
1231     spvoice_SetNotifyCallbackFunction,
1232     spvoice_SetNotifyCallbackInterface,
1233     spvoice_SetNotifyWin32Event,
1234     spvoice_WaitForNotifyEvent,
1235     spvoice_GetNotifyEventHandle,
1236     spvoice_SetInterest,
1237     spvoice_GetEvents,
1238     spvoice_GetInfo,
1239     spvoice_SetOutput,
1240     spvoice_GetOutputObjectToken,
1241     spvoice_GetOutputStream,
1242     spvoice_Pause,
1243     spvoice_Resume,
1244     spvoice_SetVoice,
1245     spvoice_GetVoice,
1246     spvoice_Speak,
1247     spvoice_SpeakStream,
1248     spvoice_GetStatus,
1249     spvoice_Skip,
1250     spvoice_SetPriority,
1251     spvoice_GetPriority,
1252     spvoice_SetAlertBoundary,
1253     spvoice_GetAlertBoundary,
1254     spvoice_SetRate,
1255     spvoice_GetRate,
1256     spvoice_SetVolume,
1257     spvoice_GetVolume,
1258     spvoice_WaitUntilDone,
1259     spvoice_SetSyncSpeakTimeout,
1260     spvoice_GetSyncSpeakTimeout,
1261     spvoice_SpeakCompleteEvent,
1262     spvoice_IsUISupported,
1263     spvoice_DisplayUI
1264 };
1265
1266 /* ISpTTSEngineSite interface */
1267 static HRESULT WINAPI ttsenginesite_QueryInterface(ISpTTSEngineSite *iface, REFIID iid, void **obj)
1268 {
1269     struct tts_engine_site *This = impl_from_ISpTTSEngineSite(iface);
1270
1271     TRACE("(%p, %s %p).\n", iface, debugstr_guid(iid), obj);
1272
1273     if (IsEqualIID(iid, &IID_IUnknown) ||
1274         IsEqualIID(iid, &IID_ISpTTSEngineSite))
1275         *obj = &This->ISpTTSEngineSite_iface;
1276     else
1277     {
1278         *obj = NULL;
1279         FIXME("interface %s not implemented.\n", debugstr_guid(iid));
1280         return E_NOINTERFACE;
1281     }
1282
1283     IUnknown_AddRef((IUnknown *)*obj);
1284     return S_OK;
1285 }
1286
1287 static ULONG WINAPI ttsenginesite_AddRef(ISpTTSEngineSite *iface)
1288 {
1289     struct tts_engine_site *This = impl_from_ISpTTSEngineSite(iface);
1290     ULONG ref = InterlockedIncrement(&This->ref);
1291
1292     TRACE("(%p): ref=%lu.\n", iface, ref);
1293
1294     return ref;
1295 }
1296
1297 static ULONG WINAPI ttsenginesite_Release(ISpTTSEngineSite *iface)
1298 {
1299     struct tts_engine_site *This = impl_from_ISpTTSEngineSite(iface);
1300
1301     ULONG ref = InterlockedDecrement(&This->ref);
1302
1303     TRACE("(%p): ref=%lu.\n", iface, ref);
1304
1305     if (!ref)
1306     {
1307         if (This->voice)
1308             ISpeechVoice_Release(&This->voice->ISpeechVoice_iface);
1309         free(This);
1310     }
1311
1312     return ref;
1313 }
1314
1315 static HRESULT WINAPI ttsenginesite_AddEvents(ISpTTSEngineSite *iface, const SPEVENT *events, ULONG count)
1316 {
1317     FIXME("(%p, %p, %ld): stub.\n", iface, events, count);
1318
1319     return S_OK;
1320 }
1321
1322 static HRESULT WINAPI ttsenginesite_GetEventInterest(ISpTTSEngineSite *iface, ULONGLONG *interest)
1323 {
1324     FIXME("(%p, %p): stub.\n", iface, interest);
1325
1326     return E_NOTIMPL;
1327 }
1328
1329 static DWORD WINAPI ttsenginesite_GetActions(ISpTTSEngineSite *iface)
1330 {
1331     struct tts_engine_site *This = impl_from_ISpTTSEngineSite(iface);
1332     DWORD actions;
1333
1334     TRACE("(%p).\n", iface);
1335
1336     EnterCriticalSection(&This->voice->cs);
1337     actions = This->voice->actions;
1338     LeaveCriticalSection(&This->voice->cs);
1339
1340     return actions;
1341 }
1342
1343 static HRESULT WINAPI ttsenginesite_Write(ISpTTSEngineSite *iface, const void *buf, ULONG cb, ULONG *cb_written)
1344 {
1345     struct tts_engine_site *This = impl_from_ISpTTSEngineSite(iface);
1346
1347     TRACE("(%p, %p, %ld, %p).\n", iface, buf, cb, cb_written);
1348
1349     if (!This->voice->output)
1350         return SPERR_UNINITIALIZED;
1351
1352     return ISpStreamFormat_Write(This->voice->output, buf, cb, cb_written);
1353 }
1354
1355 static HRESULT WINAPI ttsenginesite_GetRate(ISpTTSEngineSite *iface, LONG *rate)
1356 {
1357     struct tts_engine_site *This = impl_from_ISpTTSEngineSite(iface);
1358
1359     TRACE("(%p, %p).\n", iface, rate);
1360
1361     EnterCriticalSection(&This->voice->cs);
1362     *rate = This->voice->rate;
1363     This->voice->actions &= ~SPVES_RATE;
1364     LeaveCriticalSection(&This->voice->cs);
1365
1366     return S_OK;
1367 }
1368
1369 static HRESULT WINAPI ttsenginesite_GetVolume(ISpTTSEngineSite *iface, USHORT *volume)
1370 {
1371     struct tts_engine_site *This = impl_from_ISpTTSEngineSite(iface);
1372
1373     TRACE("(%p, %p).\n", iface, volume);
1374
1375     EnterCriticalSection(&This->voice->cs);
1376     *volume = This->voice->volume;
1377     This->voice->actions &= ~SPVES_VOLUME;
1378     LeaveCriticalSection(&This->voice->cs);
1379
1380     return S_OK;
1381 }
1382
1383 static HRESULT WINAPI ttsenginesite_GetSkipInfo(ISpTTSEngineSite *iface, SPVSKIPTYPE *type, LONG *skip_count)
1384 {
1385     FIXME("(%p, %p, %p): stub.\n", iface, type, skip_count);
1386
1387     return E_NOTIMPL;
1388 }
1389
1390 static HRESULT WINAPI ttsenginesite_CompleteSkip(ISpTTSEngineSite *iface, LONG num_skipped)
1391 {
1392     FIXME("(%p, %ld): stub.\n", iface, num_skipped);
1393
1394     return E_NOTIMPL;
1395 }
1396
1397 const static ISpTTSEngineSiteVtbl ttsenginesite_vtbl =
1398 {
1399     ttsenginesite_QueryInterface,
1400     ttsenginesite_AddRef,
1401     ttsenginesite_Release,
1402     ttsenginesite_AddEvents,
1403     ttsenginesite_GetEventInterest,
1404     ttsenginesite_GetActions,
1405     ttsenginesite_Write,
1406     ttsenginesite_GetRate,
1407     ttsenginesite_GetVolume,
1408     ttsenginesite_GetSkipInfo,
1409     ttsenginesite_CompleteSkip
1410 };
1411
1412 static HRESULT ttsenginesite_create(struct speech_voice *voice, ULONG stream_num, ISpTTSEngineSite **site)
1413 {
1414     struct tts_engine_site *This = malloc(sizeof(*This));
1415
1416     if (!This) return E_OUTOFMEMORY;
1417
1418     This->ISpTTSEngineSite_iface.lpVtbl = &ttsenginesite_vtbl;
1419
1420     This->ref = 1;
1421     This->voice = voice;
1422     This->stream_num = stream_num;
1423
1424     ISpeechVoice_AddRef(&This->voice->ISpeechVoice_iface);
1425
1426     *site = &This->ISpTTSEngineSite_iface;
1427
1428     return S_OK;
1429 }
1430
1431 /* IConnectionPointContainer interface */
1432 static HRESULT WINAPI container_QueryInterface(IConnectionPointContainer *iface, REFIID iid, void **obj)
1433 {
1434     struct speech_voice *This = impl_from_IConnectionPointContainer(iface);
1435
1436     TRACE("(%p, %s %p).\n", iface, debugstr_guid(iid), obj);
1437
1438     return ISpeechVoice_QueryInterface(&This->ISpeechVoice_iface, iid, obj);
1439 }
1440
1441 static ULONG WINAPI container_AddRef(IConnectionPointContainer *iface)
1442 {
1443     struct speech_voice *This = impl_from_IConnectionPointContainer(iface);
1444
1445     TRACE("(%p).\n", iface);
1446
1447     return ISpeechVoice_AddRef(&This->ISpeechVoice_iface);
1448 }
1449
1450 static ULONG WINAPI container_Release(IConnectionPointContainer *iface)
1451 {
1452     struct speech_voice *This = impl_from_IConnectionPointContainer(iface);
1453
1454     TRACE("(%p).\n", iface);
1455
1456     return ISpeechVoice_Release(&This->ISpeechVoice_iface);
1457 }
1458
1459 static HRESULT WINAPI container_EnumConnectionPoints(IConnectionPointContainer *iface,
1460                                                      IEnumConnectionPoints **enum_cp)
1461 {
1462     FIXME("(%p, %p): stub.\n", iface, enum_cp);
1463
1464     return E_NOTIMPL;
1465 }
1466
1467 static HRESULT WINAPI container_FindConnectionPoint(IConnectionPointContainer *iface, REFIID riid,
1468                                                     IConnectionPoint **cp)
1469 {
1470     FIXME("(%p, %s, %p): stub.\n", iface, debugstr_guid(riid), cp);
1471
1472     return E_NOTIMPL;
1473 }
1474
1475 const static IConnectionPointContainerVtbl container_vtbl =
1476 {
1477     container_QueryInterface,
1478     container_AddRef,
1479     container_Release,
1480     container_EnumConnectionPoints,
1481     container_FindConnectionPoint
1482 };
1483
1484 HRESULT speech_voice_create(IUnknown *outer, REFIID iid, void **obj)
1485 {
1486     struct speech_voice *This = malloc(sizeof(*This));
1487     HRESULT hr;
1488
1489     if (!This) return E_OUTOFMEMORY;
1490     This->ISpeechVoice_iface.lpVtbl = &speech_voice_vtbl;
1491     This->ISpVoice_iface.lpVtbl = &spvoice_vtbl;
1492     This->IConnectionPointContainer_iface.lpVtbl = &container_vtbl;
1493     This->ref = 1;
1494
1495     This->output = NULL;
1496     This->engine_token = NULL;
1497     This->engine = NULL;
1498     This->cur_stream_num = 0;
1499     This->actions = SPVES_CONTINUE;
1500     This->volume = 100;
1501     This->rate = 0;
1502     memset(&This->queue, 0, sizeof(This->queue));
1503
1504     InitializeCriticalSection(&This->cs);
1505
1506     hr = ISpeechVoice_QueryInterface(&This->ISpeechVoice_iface, iid, obj);
1507
1508     ISpeechVoice_Release(&This->ISpeechVoice_iface);
1509     return hr;
1510 }