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
  31 #include "wine/debug.h"
  32
  33 #include "sapi_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(sapi);
  36
  37 struct speech_voice
  38 {
  39     ISpeechVoice ISpeechVoice_iface;
  40     ISpVoice ISpVoice_iface;
  41     IConnectionPointContainer IConnectionPointContainer_iface;
  42     LONG ref;
  43 };
  44
  45 static inline struct speech_voice *impl_from_ISpeechVoice(ISpeechVoice *iface)
  46 {
  47     return CONTAINING_RECORD(iface, struct speech_voice, ISpeechVoice_iface);
  48 }
  49
  50 static inline struct speech_voice *impl_from_ISpVoice(ISpVoice *iface)
  51 {
  52     return CONTAINING_RECORD(iface, struct speech_voice, ISpVoice_iface);
  53 }
  54
  55 static inline struct speech_voice *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
  56 {
  57     return CONTAINING_RECORD(iface, struct speech_voice, IConnectionPointContainer_iface);
  58 }
  59
  60 /* ISpeechVoice interface */
  61 static HRESULT WINAPI speech_voice_QueryInterface(ISpeechVoice *iface, REFIID iid, void **obj)
  62 {
  63     struct speech_voice *This = impl_from_ISpeechVoice(iface);
  64
  65     TRACE("(%p, %s %p).\n", iface, debugstr_guid(iid), obj);
  66
  67     if (IsEqualIID(iid, &IID_IUnknown) ||
  68         IsEqualIID(iid, &IID_IDispatch) ||
  69         IsEqualIID(iid, &IID_ISpeechVoice))
  70         *obj = &This->ISpeechVoice_iface;
  71     else if (IsEqualIID(iid, &IID_ISpVoice))
  72         *obj = &This->ISpVoice_iface;
  73     else if (IsEqualIID(iid, &IID_IConnectionPointContainer))
  74         *obj = &This->IConnectionPointContainer_iface;
  75     else
  76     {
  77         *obj = NULL;
  78         FIXME("interface %s not implemented.\n", debugstr_guid(iid));
  79         return E_NOINTERFACE;
  80     }
  81
  82     IUnknown_AddRef((IUnknown *)*obj);
  83     return S_OK;
  84 }
  85
  86 static ULONG WINAPI speech_voice_AddRef(ISpeechVoice *iface)
  87 {
  88     struct speech_voice *This = impl_from_ISpeechVoice(iface);
  89     ULONG ref = InterlockedIncrement(&This->ref);
  90
  91     TRACE("(%p): ref=%u.\n", iface, ref);
  92
  93     return ref;
  94 }
  95
  96 static ULONG WINAPI speech_voice_Release(ISpeechVoice *iface)
  97 {
  98     struct speech_voice *This = impl_from_ISpeechVoice(iface);
  99     ULONG ref = InterlockedDecrement(&This->ref);
 100
 101     TRACE("(%p): ref=%u.\n", iface, ref);
 102
 103     if (!ref)
 104     {
 105         heap_free(This);
 106     }
 107
 108     return ref;
 109 }
 110
 111 static HRESULT WINAPI speech_voice_GetTypeInfoCount(ISpeechVoice *iface, UINT *info)
 112 {
 113     FIXME("(%p, %p): stub.\n", iface, info);
 114
 115     return E_NOTIMPL;
 116 }
 117
 118 static HRESULT WINAPI speech_voice_GetTypeInfo(ISpeechVoice *iface, UINT info, LCID lcid,
 119                                                ITypeInfo **type_info)
 120 {
 121     FIXME("(%p, %u, %u, %p): stub.\n", iface, info, lcid, type_info);
 122
 123     return E_NOTIMPL;
 124 }
 125
 126 static HRESULT WINAPI speech_voice_GetIDsOfNames(ISpeechVoice *iface, REFIID riid, LPOLESTR *names,
 127                                                  UINT count, LCID lcid, DISPID *dispid)
 128 {
 129     FIXME("(%p, %s, %p, %u, %u, %p): stub.\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
 130
 131     return E_NOTIMPL;
 132 }
 133
 134 static HRESULT WINAPI speech_voice_Invoke(ISpeechVoice *iface, DISPID dispid, REFIID riid, LCID lcid,
 135                                           WORD flags, DISPPARAMS *params, VARIANT *result,
 136                                           EXCEPINFO *excepinfo, UINT *argerr)
 137 {
 138     FIXME("(%p, %d, %s, %#x, %#x, %p, %p, %p, %p): stub.\n", iface, dispid, debugstr_guid(riid),
 139           lcid, flags, params, result, excepinfo, argerr);
 140
 141     return E_NOTIMPL;
 142 }
 143
 144 static HRESULT WINAPI speech_voice_get_Status(ISpeechVoice *iface, ISpeechVoiceStatus **status)
 145 {
 146     FIXME("(%p, %p): stub.\n", iface, status);
 147
 148     return E_NOTIMPL;
 149 }
 150
 151 static HRESULT WINAPI speech_voice_get_Voice(ISpeechVoice *iface, ISpeechObjectToken **voice)
 152 {
 153     FIXME("(%p, %p): stub.\n", iface, voice);
 154
 155     return E_NOTIMPL;
 156 }
 157
 158 static HRESULT WINAPI speech_voice_putref_Voice(ISpeechVoice *iface, ISpeechObjectToken *voice)
 159 {
 160     FIXME("(%p, %p): stub.\n", iface, voice);
 161
 162     return E_NOTIMPL;
 163 }
 164
 165 static HRESULT WINAPI speech_voice_get_AudioOutput(ISpeechVoice *iface, ISpeechObjectToken **output)
 166 {
 167     FIXME("(%p, %p): stub.\n", iface, output);
 168
 169     return E_NOTIMPL;
 170 }
 171
 172 static HRESULT WINAPI speech_voice_putref_AudioOutput(ISpeechVoice *iface, ISpeechObjectToken *output)
 173 {
 174     FIXME("(%p, %p): stub.\n", iface, output);
 175
 176     return E_NOTIMPL;
 177 }
 178
 179 static HRESULT WINAPI speech_voice_get_AudioOutputStream(ISpeechVoice *iface, ISpeechBaseStream **output)
 180 {
 181     FIXME("(%p, %p): stub.\n", iface, output);
 182
 183     return E_NOTIMPL;
 184 }
 185
 186 static HRESULT WINAPI speech_voice_putref_AudioOutputStream(ISpeechVoice *iface, ISpeechBaseStream *output)
 187 {
 188     FIXME("(%p, %p): stub.\n", iface, output);
 189
 190     return E_NOTIMPL;
 191 }
 192
 193 static HRESULT WINAPI speech_voice_get_Rate(ISpeechVoice *iface, LONG *rate)
 194 {
 195     FIXME("(%p, %p): stub.\n", iface, rate);
 196
 197     return E_NOTIMPL;
 198 }
 199
 200 static HRESULT WINAPI speech_voice_put_Rate(ISpeechVoice *iface, LONG rate)
 201 {
 202     FIXME("(%p, %d): stub.\n", iface, rate);
 203
 204     return E_NOTIMPL;
 205 }
 206
 207 static HRESULT WINAPI speech_voice_get_Volume(ISpeechVoice *iface, LONG *volume)
 208 {
 209     FIXME("(%p, %p): stub.\n", iface, volume);
 210
 211     return E_NOTIMPL;
 212 }
 213
 214 static HRESULT WINAPI speech_voice_put_Volume(ISpeechVoice *iface, LONG volume)
 215 {
 216     FIXME("(%p, %d): stub.\n", iface, volume);
 217
 218     return E_NOTIMPL;
 219 }
 220
 221 static HRESULT WINAPI speech_voice_put_AllowAudioOutputFormatChangesOnNextSet(ISpeechVoice *iface,
 222                                                                               VARIANT_BOOL allow)
 223 {
 224     FIXME("(%p, %d): stub.\n", iface, allow);
 225
 226     return E_NOTIMPL;
 227 }
 228
 229 static HRESULT WINAPI speech_voice_get_AllowAudioOutputFormatChangesOnNextSet(ISpeechVoice *iface, VARIANT_BOOL *allow)
 230 {
 231     FIXME("(%p, %p): stub.\n", iface, allow);
 232
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI speech_voice_get_EventInterests(ISpeechVoice *iface, SpeechVoiceEvents *flags)
 237 {
 238     FIXME("(%p, %p): stub.\n", iface, flags);
 239
 240     return E_NOTIMPL;
 241 }
 242
 243 static HRESULT WINAPI speech_voice_put_EventInterests(ISpeechVoice *iface, SpeechVoiceEvents flags)
 244 {
 245     FIXME("(%p, %#x): stub.\n", iface, flags);
 246
 247     return E_NOTIMPL;
 248 }
 249
 250 static HRESULT WINAPI speech_voice_put_Priority(ISpeechVoice *iface, SpeechVoicePriority priority)
 251 {
 252     FIXME("(%p, %d): stub.\n", iface, priority);
 253
 254     return E_NOTIMPL;
 255 }
 256
 257 static HRESULT WINAPI speech_voice_get_Priority(ISpeechVoice *iface, SpeechVoicePriority *priority)
 258 {
 259     FIXME("(%p, %p): stub.\n", iface, priority);
 260
 261     return E_NOTIMPL;
 262 }
 263
 264 static HRESULT WINAPI speech_voice_put_AlertBoundary(ISpeechVoice *iface, SpeechVoiceEvents boundary)
 265 {
 266     FIXME("(%p, %#x): stub.\n", iface, boundary);
 267
 268     return E_NOTIMPL;
 269 }
 270
 271 static HRESULT WINAPI speech_voice_get_AlertBoundary(ISpeechVoice *iface, SpeechVoiceEvents *boundary)
 272 {
 273     FIXME("(%p, %p): stub.\n", iface, boundary);
 274
 275     return E_NOTIMPL;
 276 }
 277
 278 static HRESULT WINAPI speech_voice_put_SynchronousSpeakTimeout(ISpeechVoice *iface, LONG timeout)
 279 {
 280     FIXME("(%p, %d): stub.\n", iface, timeout);
 281
 282     return E_NOTIMPL;
 283 }
 284
 285 static HRESULT WINAPI speech_voice_get_SynchronousSpeakTimeout(ISpeechVoice *iface, LONG *timeout)
 286 {
 287     FIXME("(%p, %p): stub.\n", iface, timeout);
 288
 289     return E_NOTIMPL;
 290 }
 291
 292 static HRESULT WINAPI speech_voice_Speak(ISpeechVoice *iface, BSTR text, SpeechVoiceSpeakFlags flags, LONG *number)
 293 {
 294     FIXME("(%p, %s, %#x, %p): stub.\n", iface, debugstr_w(text), flags, number);
 295
 296     return E_NOTIMPL;
 297 }
 298
 299 static HRESULT WINAPI speech_voice_SpeakStream(ISpeechVoice *iface, ISpeechBaseStream *stream,
 300                                                SpeechVoiceSpeakFlags flags, LONG *number)
 301 {
 302     FIXME("(%p, %p, %#x, %p): stub.\n", iface, stream, flags, number);
 303
 304     return E_NOTIMPL;
 305 }
 306
 307 static HRESULT WINAPI speech_voice_Pause(ISpeechVoice *iface)
 308 {
 309     FIXME("(%p): stub.\n", iface);
 310
 311     return E_NOTIMPL;
 312 }
 313
 314 static HRESULT WINAPI speech_voice_Resume(ISpeechVoice *iface)
 315 {
 316     FIXME("(%p): stub.\n", iface);
 317
 318     return E_NOTIMPL;
 319 }
 320
 321 static HRESULT WINAPI speech_voice_Skip(ISpeechVoice *iface, const BSTR type, LONG items, LONG *skipped)
 322 {
 323     FIXME("(%p, %s, %d, %p): stub.\n", iface, debugstr_w(type), items, skipped);
 324
 325     return E_NOTIMPL;
 326 }
 327
 328 static HRESULT WINAPI speech_voice_GetVoices(ISpeechVoice *iface, BSTR required, BSTR optional,
 329                                              ISpeechObjectTokens **tokens)
 330 {
 331     FIXME("(%p, %s, %s, %p): stub.\n", iface, debugstr_w(required), debugstr_w(optional), tokens);
 332
 333     return E_NOTIMPL;
 334 }
 335
 336 static HRESULT WINAPI speech_voice_GetAudioOutputs(ISpeechVoice *iface, BSTR required, BSTR optional,
 337                                                    ISpeechObjectTokens **tokens)
 338 {
 339     FIXME("(%p, %s, %s, %p): stub.\n", iface, debugstr_w(required), debugstr_w(optional), tokens);
 340
 341     return E_NOTIMPL;
 342 }
 343
 344 static HRESULT WINAPI speech_voice_WaitUntilDone(ISpeechVoice *iface, LONG timeout, VARIANT_BOOL *done)
 345 {
 346     FIXME("(%p, %d, %p): stub.\n", iface, timeout, done);
 347
 348     return E_NOTIMPL;
 349 }
 350
 351 static HRESULT WINAPI speech_voice_SpeakCompleteEvent(ISpeechVoice *iface, LONG *handle)
 352 {
 353     FIXME("(%p, %p): stub.\n", iface, handle);
 354
 355     return E_NOTIMPL;
 356 }
 357
 358 static HRESULT WINAPI speech_voice_IsUISupported(ISpeechVoice *iface, const BSTR typeui, const VARIANT *data,
 359                                                  VARIANT_BOOL *supported)
 360 {
 361     FIXME("(%p, %s, %p, %p): stub.\n", iface, debugstr_w(typeui), data, supported);
 362
 363     return E_NOTIMPL;
 364 }
 365
 366 static HRESULT WINAPI speech_voice_DisplayUI(ISpeechVoice *iface, LONG hwnd, BSTR title,
 367                                              const BSTR typeui, const VARIANT *data)
 368 {
 369     FIXME("(%p, %d, %s, %s, %p): stub.\n", iface, hwnd, debugstr_w(title), debugstr_w(typeui), data);
 370
 371     return E_NOTIMPL;
 372 }
 373
 374 static const ISpeechVoiceVtbl speech_voice_vtbl =
 375 {
 376     speech_voice_QueryInterface,
 377     speech_voice_AddRef,
 378     speech_voice_Release,
 379     speech_voice_GetTypeInfoCount,
 380     speech_voice_GetTypeInfo,
 381     speech_voice_GetIDsOfNames,
 382     speech_voice_Invoke,
 383     speech_voice_get_Status,
 384     speech_voice_get_Voice,
 385     speech_voice_putref_Voice,
 386     speech_voice_get_AudioOutput,
 387     speech_voice_putref_AudioOutput,
 388     speech_voice_get_AudioOutputStream,
 389     speech_voice_putref_AudioOutputStream,
 390     speech_voice_get_Rate,
 391     speech_voice_put_Rate,
 392     speech_voice_get_Volume,
 393     speech_voice_put_Volume,
 394     speech_voice_put_AllowAudioOutputFormatChangesOnNextSet,
 395     speech_voice_get_AllowAudioOutputFormatChangesOnNextSet,
 396     speech_voice_get_EventInterests,
 397     speech_voice_put_EventInterests,
 398     speech_voice_put_Priority,
 399     speech_voice_get_Priority,
 400     speech_voice_put_AlertBoundary,
 401     speech_voice_get_AlertBoundary,
 402     speech_voice_put_SynchronousSpeakTimeout,
 403     speech_voice_get_SynchronousSpeakTimeout,
 404     speech_voice_Speak,
 405     speech_voice_SpeakStream,
 406     speech_voice_Pause,
 407     speech_voice_Resume,
 408     speech_voice_Skip,
 409     speech_voice_GetVoices,
 410     speech_voice_GetAudioOutputs,
 411     speech_voice_WaitUntilDone,
 412     speech_voice_SpeakCompleteEvent,
 413     speech_voice_IsUISupported,
 414     speech_voice_DisplayUI,
 415 };
 416
 417 /* ISpVoice interface */
 418 static HRESULT WINAPI spvoice_QueryInterface(ISpVoice *iface, REFIID iid, void **obj)
 419 {
 420     struct speech_voice *This = impl_from_ISpVoice(iface);
 421
 422     TRACE("(%p, %s %p).\n", iface, debugstr_guid(iid), obj);
 423
 424     return ISpeechVoice_QueryInterface(&This->ISpeechVoice_iface, iid, obj);
 425 }
 426
 427 static ULONG WINAPI spvoice_AddRef(ISpVoice *iface)
 428 {
 429     struct speech_voice *This = impl_from_ISpVoice(iface);
 430
 431     TRACE("(%p).\n", iface);
 432
 433     return ISpeechVoice_AddRef(&This->ISpeechVoice_iface);
 434 }
 435
 436 static ULONG WINAPI spvoice_Release(ISpVoice *iface)
 437 {
 438     struct speech_voice *This = impl_from_ISpVoice(iface);
 439
 440     TRACE("(%p).\n", iface);
 441
 442     return ISpeechVoice_Release(&This->ISpeechVoice_iface);
 443 }
 444
 445 static HRESULT WINAPI spvoice_SetNotifySink(ISpVoice *iface, ISpNotifySink *sink)
 446 {
 447     FIXME("(%p, %p): stub.\n", iface, sink);
 448
 449     return E_NOTIMPL;
 450 }
 451
 452 static HRESULT WINAPI spvoice_SetNotifyWindowMessage(ISpVoice *iface, HWND hwnd, UINT msg,
 453                                                      WPARAM wparam, LPARAM lparam)
 454 {
 455     FIXME("(%p, %p, %u, %lx, %lx): stub.\n", iface, hwnd, msg, wparam, lparam);
 456
 457     return E_NOTIMPL;
 458 }
 459
 460 static HRESULT WINAPI spvoice_SetNotifyCallbackFunction(ISpVoice *iface, SPNOTIFYCALLBACK *callback,
 461                                                         WPARAM wparam, LPARAM lparam)
 462 {
 463     FIXME("(%p, %p, %lx, %lx): stub.\n", iface, callback, wparam, lparam);
 464
 465     return E_NOTIMPL;
 466 }
 467
 468 static HRESULT WINAPI spvoice_SetNotifyCallbackInterface(ISpVoice *iface, ISpNotifyCallback *callback,
 469                                                          WPARAM wparam, LPARAM lparam)
 470 {
 471     FIXME("(%p, %p, %lx, %lx): stub.\n", iface, callback, wparam, lparam);
 472
 473     return E_NOTIMPL;
 474 }
 475
 476 static HRESULT WINAPI spvoice_SetNotifyWin32Event(ISpVoice *iface)
 477 {
 478     FIXME("(%p): stub.\n", iface);
 479
 480     return E_NOTIMPL;
 481 }
 482
 483 static HRESULT WINAPI spvoice_WaitForNotifyEvent(ISpVoice *iface, DWORD milliseconds)
 484 {
 485     FIXME("(%p, %d): stub.\n", iface, milliseconds);
 486
 487     return E_NOTIMPL;
 488 }
 489
 490 static HANDLE WINAPI spvoice_GetNotifyEventHandle(ISpVoice *iface)
 491 {
 492     FIXME("(%p): stub.\n", iface);
 493
 494     return NULL;
 495 }
 496
 497 static HRESULT WINAPI spvoice_SetInterest(ISpVoice *iface, ULONGLONG event, ULONGLONG queued)
 498 {
 499     FIXME("(%p, %s, %s): stub.\n", iface, wine_dbgstr_longlong(event), wine_dbgstr_longlong(queued));
 500
 501     return E_NOTIMPL;
 502 }
 503
 504 static HRESULT WINAPI spvoice_GetEvents(ISpVoice *iface, ULONG count, SPEVENT *array, ULONG *fetched)
 505 {
 506     FIXME("(%p, %u, %p, %p): stub.\n", iface, count, array, fetched);
 507
 508     return E_NOTIMPL;
 509 }
 510
 511 static HRESULT WINAPI spvoice_GetInfo(ISpVoice *iface, SPEVENTSOURCEINFO *info)
 512 {
 513     FIXME("(%p, %p): stub.\n", iface, info);
 514
 515     return E_NOTIMPL;
 516 }
 517
 518 static HRESULT WINAPI spvoice_SetOutput(ISpVoice *iface, IUnknown *unk, BOOL changes)
 519 {
 520     FIXME("(%p, %p, %d: stub.\n)", iface, unk, changes);
 521
 522     return E_NOTIMPL;
 523 }
 524
 525 static HRESULT WINAPI spvoice_GetOutputObjectToken(ISpVoice *iface, ISpObjectToken **token)
 526 {
 527     FIXME("(%p, %p): stub.\n", iface, token);
 528
 529     return E_NOTIMPL;
 530 }
 531
 532 static HRESULT WINAPI spvoice_GetOutputStream(ISpVoice *iface, ISpStreamFormat **stream)
 533 {
 534     FIXME("(%p, %p): stub.\n", iface, stream);
 535
 536     return E_NOTIMPL;
 537 }
 538
 539 static HRESULT WINAPI spvoice_Pause(ISpVoice *iface)
 540 {
 541     FIXME("(%p): stub.\n", iface);
 542
 543     return E_NOTIMPL;
 544 }
 545
 546 static HRESULT WINAPI spvoice_Resume(ISpVoice *iface)
 547 {
 548     FIXME("(%p): stub.\n", iface);
 549
 550     return E_NOTIMPL;
 551 }
 552
 553 static HRESULT WINAPI spvoice_SetVoice(ISpVoice *iface, ISpObjectToken *token)
 554 {
 555     FIXME("(%p, %p): stub.\n", iface, token);
 556
 557     return E_NOTIMPL;
 558 }
 559
 560 static HRESULT WINAPI spvoice_GetVoice(ISpVoice *iface, ISpObjectToken **token)
 561 {
 562     FIXME("(%p, %p): stub.\n", iface, token);
 563
 564     return E_NOTIMPL;
 565 }
 566
 567 static HRESULT WINAPI spvoice_Speak(ISpVoice *iface, const WCHAR *contents, DWORD flags, ULONG *number)
 568 {
 569     FIXME("(%p, %p, %#x, %p): stub.\n", iface, contents, flags, number);
 570
 571     return E_NOTIMPL;
 572 }
 573
 574 static HRESULT WINAPI spvoice_SpeakStream(ISpVoice *iface, IStream *stream, DWORD flags, ULONG *number)
 575 {
 576     FIXME("(%p, %p, %#x, %p): stub.\n", iface, stream, flags, number);
 577
 578     return E_NOTIMPL;
 579 }
 580
 581 static HRESULT WINAPI spvoice_GetStatus(ISpVoice *iface, SPVOICESTATUS *status, WCHAR **bookmark)
 582 {
 583     FIXME("(%p, %p, %p): stub.\n", iface, status, bookmark);
 584
 585     return E_NOTIMPL;
 586 }
 587
 588 static HRESULT WINAPI spvoice_Skip(ISpVoice *iface, const WCHAR *type, LONG items, ULONG *skipped)
 589 {
 590     FIXME("(%p, %s, %d, %p): stub.\n", iface, debugstr_w(type), items, skipped);
 591
 592     return E_NOTIMPL;
 593 }
 594
 595 static HRESULT WINAPI spvoice_SetPriority(ISpVoice *iface, SPVPRIORITY priority)
 596 {
 597     FIXME("(%p, %d): stub.\n", iface, priority);
 598
 599     return E_NOTIMPL;
 600 }
 601
 602 static HRESULT WINAPI spvoice_GetPriority(ISpVoice *iface, SPVPRIORITY *priority)
 603 {
 604     FIXME("(%p, %p): stub.\n", iface, priority);
 605
 606     return E_NOTIMPL;
 607 }
 608
 609 static HRESULT WINAPI spvoice_SetAlertBoundary(ISpVoice *iface, SPEVENTENUM boundary)
 610 {
 611     FIXME("(%p, %d): stub.\n", iface, boundary);
 612
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI spvoice_GetAlertBoundary(ISpVoice *iface, SPEVENTENUM *boundary)
 617 {
 618     FIXME("(%p, %p): stub.\n", iface, boundary);
 619
 620     return E_NOTIMPL;
 621 }
 622
 623 static HRESULT WINAPI spvoice_SetRate(ISpVoice *iface, LONG adjust)
 624 {
 625     FIXME("(%p, %d): stub.\n", iface, adjust);
 626
 627     return E_NOTIMPL;
 628 }
 629
 630 static HRESULT WINAPI spvoice_GetRate(ISpVoice *iface, LONG *adjust)
 631 {
 632     FIXME("(%p, %p): stub.\n", iface, adjust);
 633
 634     return E_NOTIMPL;
 635 }
 636
 637 static HRESULT WINAPI spvoice_SetVolume(ISpVoice *iface, USHORT volume)
 638 {
 639     FIXME("(%p, %d): stub.\n", iface, volume);
 640
 641     return E_NOTIMPL;
 642 }
 643
 644 static HRESULT WINAPI spvoice_GetVolume(ISpVoice *iface, USHORT *volume)
 645 {
 646     FIXME("(%p, %p): stub.\n", iface, volume);
 647
 648     return E_NOTIMPL;
 649 }
 650
 651 static HRESULT WINAPI spvoice_WaitUntilDone(ISpVoice *iface, ULONG timeout)
 652 {
 653     FIXME("(%p, %d): stub.\n", iface, timeout);
 654
 655     return E_NOTIMPL;
 656 }
 657
 658 static HRESULT WINAPI spvoice_SetSyncSpeakTimeout(ISpVoice *iface, ULONG timeout)
 659 {
 660     FIXME("(%p, %d): stub.\n", iface, timeout);
 661
 662     return E_NOTIMPL;
 663 }
 664
 665 static HRESULT WINAPI spvoice_GetSyncSpeakTimeout(ISpVoice *iface, ULONG *timeout)
 666 {
 667     FIXME("(%p, %p): stub.\n", iface, timeout);
 668
 669     return E_NOTIMPL;
 670 }
 671
 672 static HANDLE WINAPI spvoice_SpeakCompleteEvent(ISpVoice *iface)
 673 {
 674     FIXME("(%p): stub.\n", iface);
 675
 676     return NULL;
 677 }
 678
 679 static HRESULT WINAPI spvoice_IsUISupported(ISpVoice *iface, const WCHAR *type, void *extra,
 680                                             ULONG count, BOOL *supported)
 681 {
 682     FIXME("(%p, %p, %p, %d, %p): stub.\n", iface, type, extra, count, supported);
 683
 684     return E_NOTIMPL;
 685 }
 686
 687 static HRESULT WINAPI spvoice_DisplayUI(ISpVoice *iface, HWND parent, const WCHAR *title,
 688                                         const WCHAR *type, void *extra, ULONG count)
 689 {
 690     FIXME("(%p, %p, %p, %p, %p, %d): stub.\n", iface, parent, title, type, extra, count);
 691
 692     return E_NOTIMPL;
 693 }
 694
 695 static const ISpVoiceVtbl spvoice_vtbl =
 696 {
 697     spvoice_QueryInterface,
 698     spvoice_AddRef,
 699     spvoice_Release,
 700     spvoice_SetNotifySink,
 701     spvoice_SetNotifyWindowMessage,
 702     spvoice_SetNotifyCallbackFunction,
 703     spvoice_SetNotifyCallbackInterface,
 704     spvoice_SetNotifyWin32Event,
 705     spvoice_WaitForNotifyEvent,
 706     spvoice_GetNotifyEventHandle,
 707     spvoice_SetInterest,
 708     spvoice_GetEvents,
 709     spvoice_GetInfo,
 710     spvoice_SetOutput,
 711     spvoice_GetOutputObjectToken,
 712     spvoice_GetOutputStream,
 713     spvoice_Pause,
 714     spvoice_Resume,
 715     spvoice_SetVoice,
 716     spvoice_GetVoice,
 717     spvoice_Speak,
 718     spvoice_SpeakStream,
 719     spvoice_GetStatus,
 720     spvoice_Skip,
 721     spvoice_SetPriority,
 722     spvoice_GetPriority,
 723     spvoice_SetAlertBoundary,
 724     spvoice_GetAlertBoundary,
 725     spvoice_SetRate,
 726     spvoice_GetRate,
 727     spvoice_SetVolume,
 728     spvoice_GetVolume,
 729     spvoice_WaitUntilDone,
 730     spvoice_SetSyncSpeakTimeout,
 731     spvoice_GetSyncSpeakTimeout,
 732     spvoice_SpeakCompleteEvent,
 733     spvoice_IsUISupported,
 734     spvoice_DisplayUI
 735 };
 736
 737 /* IConnectionPointContainer interface */
 738 static HRESULT WINAPI container_QueryInterface(IConnectionPointContainer *iface, REFIID iid, void **obj)
 739 {
 740     struct speech_voice *This = impl_from_IConnectionPointContainer(iface);
 741
 742     TRACE("(%p, %s %p).\n", iface, debugstr_guid(iid), obj);
 743
 744     return ISpeechVoice_QueryInterface(&This->ISpeechVoice_iface, iid, obj);
 745 }
 746
 747 static ULONG WINAPI container_AddRef(IConnectionPointContainer *iface)
 748 {
 749     struct speech_voice *This = impl_from_IConnectionPointContainer(iface);
 750
 751     TRACE("(%p).\n", iface);
 752
 753     return ISpeechVoice_AddRef(&This->ISpeechVoice_iface);
 754 }
 755
 756 static ULONG WINAPI container_Release(IConnectionPointContainer *iface)
 757 {
 758     struct speech_voice *This = impl_from_IConnectionPointContainer(iface);
 759
 760     TRACE("(%p).\n", iface);
 761
 762     return ISpeechVoice_Release(&This->ISpeechVoice_iface);
 763 }
 764
 765 static HRESULT WINAPI container_EnumConnectionPoints(IConnectionPointContainer *iface,
 766                                                      IEnumConnectionPoints **enum_cp)
 767 {
 768     FIXME("(%p, %p): stub.\n", iface, enum_cp);
 769
 770     return E_NOTIMPL;
 771 }
 772
 773 static HRESULT WINAPI container_FindConnectionPoint(IConnectionPointContainer *iface, REFIID riid,
 774                                                     IConnectionPoint **cp)
 775 {
 776     FIXME("(%p, %s, %p): stub.\n", iface, debugstr_guid(riid), cp);
 777
 778     return E_NOTIMPL;
 779 }
 780
 781 const static IConnectionPointContainerVtbl container_vtbl =
 782 {
 783     container_QueryInterface,
 784     container_AddRef,
 785     container_Release,
 786     container_EnumConnectionPoints,
 787     container_FindConnectionPoint
 788 };
 789
 790 HRESULT speech_voice_create(IUnknown *outer, REFIID iid, void **obj)
 791 {
 792     struct speech_voice *This = heap_alloc(sizeof(*This));
 793     HRESULT hr;
 794
 795     if (!This) return E_OUTOFMEMORY;
 796     This->ISpeechVoice_iface.lpVtbl = &speech_voice_vtbl;
 797     This->ISpVoice_iface.lpVtbl = &spvoice_vtbl;
 798     This->IConnectionPointContainer_iface.lpVtbl = &container_vtbl;
 799     This->ref = 1;
 800
 801     hr = ISpeechVoice_QueryInterface(&This->ISpeechVoice_iface, iid, obj);
 802
 803     ISpeechVoice_Release(&This->ISpeechVoice_iface);
 804     return hr;
 805 }