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