dlls/sapi/mmaudio.c

   1 /*
   2  * Speech API (SAPI) winmm audio implementation.
   3  *
   4  * Copyright 2023 Shaun Ren 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 enum flow_type { FLOW_IN, FLOW_OUT };
  39
  40 struct mmaudio
  41 {
  42     ISpEventSource ISpEventSource_iface;
  43     ISpEventSink ISpEventSink_iface;
  44     ISpObjectWithToken ISpObjectWithToken_iface;
  45     ISpMMSysAudio ISpMMSysAudio_iface;
  46     LONG ref;
  47
  48     enum flow_type flow;
  49     ISpObjectToken *token;
  50 };
  51
  52 static inline struct mmaudio *impl_from_ISpEventSource(ISpEventSource *iface)
  53 {
  54     return CONTAINING_RECORD(iface, struct mmaudio, ISpEventSource_iface);
  55 }
  56
  57 static inline struct mmaudio *impl_from_ISpEventSink(ISpEventSink *iface)
  58 {
  59     return CONTAINING_RECORD(iface, struct mmaudio, ISpEventSink_iface);
  60 }
  61
  62 static inline struct mmaudio *impl_from_ISpObjectWithToken(ISpObjectWithToken *iface)
  63 {
  64     return CONTAINING_RECORD(iface, struct mmaudio, ISpObjectWithToken_iface);
  65 }
  66
  67 static inline struct mmaudio *impl_from_ISpMMSysAudio(ISpMMSysAudio *iface)
  68 {
  69     return CONTAINING_RECORD(iface, struct mmaudio, ISpMMSysAudio_iface);
  70 }
  71
  72 static HRESULT WINAPI event_source_QueryInterface(ISpEventSource *iface, REFIID iid, void **obj)
  73 {
  74     struct mmaudio *This = impl_from_ISpEventSource(iface);
  75
  76     TRACE("(%p, %s, %p).\n", iface, debugstr_guid(iid), obj);
  77
  78     return ISpMMSysAudio_QueryInterface(&This->ISpMMSysAudio_iface, iid, obj);
  79 }
  80
  81 static ULONG WINAPI event_source_AddRef(ISpEventSource *iface)
  82 {
  83     struct mmaudio *This = impl_from_ISpEventSource(iface);
  84
  85     TRACE("(%p).\n", iface);
  86
  87     return ISpMMSysAudio_AddRef(&This->ISpMMSysAudio_iface);
  88 }
  89
  90 static ULONG WINAPI event_source_Release(ISpEventSource *iface)
  91 {
  92     struct mmaudio *This = impl_from_ISpEventSource(iface);
  93
  94     TRACE("(%p).\n", iface);
  95
  96     return ISpMMSysAudio_Release(&This->ISpMMSysAudio_iface);
  97 }
  98
  99 static HRESULT WINAPI event_source_SetNotifySink(ISpEventSource *iface, ISpNotifySink *sink)
 100 {
 101     FIXME("(%p, %p): stub.\n", iface, sink);
 102
 103     return E_NOTIMPL;
 104 }
 105
 106 static HRESULT WINAPI event_source_SetNotifyWindowMessage(ISpEventSource *iface, HWND hwnd,
 107                                                           UINT msg, WPARAM wparam, LPARAM lparam)
 108 {
 109     FIXME("(%p, %p, %u, %Ix, %Ix): stub.\n", iface, hwnd, msg, wparam, lparam);
 110
 111     return E_NOTIMPL;
 112 }
 113
 114 static HRESULT WINAPI event_source_SetNotifyCallbackFunction(ISpEventSource *iface, SPNOTIFYCALLBACK *callback,
 115                                                              WPARAM wparam, LPARAM lparam)
 116 {
 117     FIXME("(%p, %p, %Ix, %Ix): stub.\n", iface, callback, wparam, lparam);
 118
 119     return E_NOTIMPL;
 120 }
 121
 122 static HRESULT WINAPI event_source_SetNotifyCallbackInterface(ISpEventSource *iface, ISpNotifyCallback *callback,
 123                                                               WPARAM wparam, LPARAM lparam)
 124 {
 125     FIXME("(%p, %p, %Ix, %Ix): stub.\n", iface, callback, wparam, lparam);
 126
 127     return E_NOTIMPL;
 128 }
 129
 130 static HRESULT WINAPI event_source_SetNotifyWin32Event(ISpEventSource *iface)
 131 {
 132     FIXME("(%p): stub.\n", iface);
 133
 134     return E_NOTIMPL;
 135 }
 136
 137 static HRESULT WINAPI event_source_WaitForNotifyEvent(ISpEventSource *iface, DWORD milliseconds)
 138 {
 139     FIXME("(%p, %ld): stub.\n", iface, milliseconds);
 140
 141     return E_NOTIMPL;
 142 }
 143
 144 static HANDLE WINAPI event_source_GetNotifyEventHandle(ISpEventSource *iface)
 145 {
 146     FIXME("(%p): stub.\n", iface);
 147
 148     return NULL;
 149 }
 150
 151 static HRESULT WINAPI event_source_SetInterest(ISpEventSource *iface, ULONGLONG event, ULONGLONG queued)
 152 {
 153     FIXME("(%p, %s, %s): stub.\n", iface, wine_dbgstr_longlong(event), wine_dbgstr_longlong(queued));
 154
 155     return E_NOTIMPL;
 156 }
 157
 158 static HRESULT WINAPI event_source_GetEvents(ISpEventSource *iface, ULONG count, SPEVENT *array, ULONG *fetched)
 159 {
 160     FIXME("(%p, %lu, %p, %p): stub.\n", iface, count, array, fetched);
 161
 162     return E_NOTIMPL;
 163 }
 164
 165 static HRESULT WINAPI event_source_GetInfo(ISpEventSource *iface, SPEVENTSOURCEINFO *info)
 166 {
 167     FIXME("(%p, %p): stub.\n", iface, info);
 168
 169     return E_NOTIMPL;
 170 }
 171
 172 static const ISpEventSourceVtbl event_source_vtbl =
 173 {
 174     event_source_QueryInterface,
 175     event_source_AddRef,
 176     event_source_Release,
 177     event_source_SetNotifySink,
 178     event_source_SetNotifyWindowMessage,
 179     event_source_SetNotifyCallbackFunction,
 180     event_source_SetNotifyCallbackInterface,
 181     event_source_SetNotifyWin32Event,
 182     event_source_WaitForNotifyEvent,
 183     event_source_GetNotifyEventHandle,
 184     event_source_SetInterest,
 185     event_source_GetEvents,
 186     event_source_GetInfo
 187 };
 188
 189 static HRESULT WINAPI event_sink_QueryInterface(ISpEventSink *iface, REFIID iid, void **obj)
 190 {
 191     struct mmaudio *This = impl_from_ISpEventSink(iface);
 192
 193     TRACE("(%p, %s, %p).\n", iface, debugstr_guid(iid), obj);
 194
 195     return ISpMMSysAudio_QueryInterface(&This->ISpMMSysAudio_iface, iid, obj);
 196 }
 197
 198 static ULONG WINAPI event_sink_AddRef(ISpEventSink *iface)
 199 {
 200     struct mmaudio *This = impl_from_ISpEventSink(iface);
 201
 202     TRACE("(%p).\n", iface);
 203
 204     return ISpMMSysAudio_AddRef(&This->ISpMMSysAudio_iface);
 205 }
 206
 207 static ULONG WINAPI event_sink_Release(ISpEventSink *iface)
 208 {
 209     struct mmaudio *This = impl_from_ISpEventSink(iface);
 210
 211     TRACE("(%p).\n", iface);
 212
 213     return ISpMMSysAudio_Release(&This->ISpMMSysAudio_iface);
 214 }
 215
 216 static HRESULT WINAPI event_sink_AddEvents(ISpEventSink *iface, const SPEVENT *events, ULONG count)
 217 {
 218     FIXME("(%p, %p, %lu).\n", iface, events, count);
 219
 220     return E_NOTIMPL;
 221 }
 222
 223 static HRESULT WINAPI event_sink_GetEventInterest(ISpEventSink *iface, ULONGLONG *interest)
 224 {
 225     FIXME("(%p, %p).\n", iface, interest);
 226
 227     return E_NOTIMPL;
 228 }
 229
 230 static const ISpEventSinkVtbl event_sink_vtbl =
 231 {
 232     event_sink_QueryInterface,
 233     event_sink_AddRef,
 234     event_sink_Release,
 235     event_sink_AddEvents,
 236     event_sink_GetEventInterest
 237 };
 238
 239 static HRESULT WINAPI objwithtoken_QueryInterface(ISpObjectWithToken *iface, REFIID iid, void **obj)
 240 {
 241     struct mmaudio *This = impl_from_ISpObjectWithToken(iface);
 242
 243     TRACE("(%p, %s, %p).\n", iface, debugstr_guid(iid), obj);
 244
 245     return ISpMMSysAudio_QueryInterface(&This->ISpMMSysAudio_iface, iid, obj);
 246 }
 247
 248 static ULONG WINAPI objwithtoken_AddRef(ISpObjectWithToken *iface)
 249 {
 250     struct mmaudio *This = impl_from_ISpObjectWithToken(iface);
 251
 252     TRACE("(%p).\n", iface);
 253
 254     return ISpMMSysAudio_AddRef(&This->ISpMMSysAudio_iface);
 255 }
 256
 257 static ULONG WINAPI objwithtoken_Release(ISpObjectWithToken *iface)
 258 {
 259     struct mmaudio *This = impl_from_ISpObjectWithToken(iface);
 260
 261     TRACE("(%p).\n", iface);
 262
 263     return ISpMMSysAudio_Release(&This->ISpMMSysAudio_iface);
 264 }
 265
 266 static HRESULT WINAPI objwithtoken_SetObjectToken(ISpObjectWithToken *iface, ISpObjectToken *token)
 267 {
 268     struct mmaudio *This = impl_from_ISpObjectWithToken(iface);
 269
 270     FIXME("(%p, %p): semi-stub.\n", iface, token);
 271
 272     if (!token)
 273         return E_INVALIDARG;
 274     if (This->token)
 275         return SPERR_ALREADY_INITIALIZED;
 276
 277     This->token = token;
 278     return S_OK;
 279 }
 280
 281 static HRESULT WINAPI objwithtoken_GetObjectToken(ISpObjectWithToken *iface, ISpObjectToken **token)
 282 {
 283     struct mmaudio *This = impl_from_ISpObjectWithToken(iface);
 284
 285     TRACE("(%p, %p).\n", iface, token);
 286
 287     if (!token)
 288         return E_POINTER;
 289
 290     *token = This->token;
 291     if (*token)
 292     {
 293         ISpObjectToken_AddRef(*token);
 294         return S_OK;
 295     }
 296     else
 297         return S_FALSE;
 298 }
 299
 300 static const ISpObjectWithTokenVtbl objwithtoken_vtbl =
 301 {
 302     objwithtoken_QueryInterface,
 303     objwithtoken_AddRef,
 304     objwithtoken_Release,
 305     objwithtoken_SetObjectToken,
 306     objwithtoken_GetObjectToken
 307 };
 308
 309 static HRESULT WINAPI mmsysaudio_QueryInterface(ISpMMSysAudio *iface, REFIID iid, void **obj)
 310 {
 311     struct mmaudio *This = impl_from_ISpMMSysAudio(iface);
 312
 313     TRACE("(%p, %s, %p).\n", iface, debugstr_guid(iid), obj);
 314
 315     if (IsEqualIID(iid, &IID_IUnknown) ||
 316         IsEqualIID(iid, &IID_ISequentialStream) ||
 317         IsEqualIID(iid, &IID_IStream) ||
 318         IsEqualIID(iid, &IID_ISpStreamFormat) ||
 319         IsEqualIID(iid, &IID_ISpAudio) ||
 320         IsEqualIID(iid, &IID_ISpMMSysAudio))
 321         *obj = &This->ISpMMSysAudio_iface;
 322     else if (IsEqualIID(iid, &IID_ISpEventSource))
 323         *obj = &This->ISpEventSource_iface;
 324     else if (IsEqualIID(iid, &IID_ISpEventSink))
 325         *obj = &This->ISpEventSink_iface;
 326     else if (IsEqualIID(iid, &IID_ISpObjectWithToken))
 327         *obj = &This->ISpObjectWithToken_iface;
 328     else
 329     {
 330         *obj = NULL;
 331         FIXME("interface %s not implemented.\n", debugstr_guid(iid));
 332         return E_NOINTERFACE;
 333     }
 334
 335     IUnknown_AddRef((IUnknown *)*obj);
 336     return S_OK;
 337 }
 338
 339 static ULONG WINAPI mmsysaudio_AddRef(ISpMMSysAudio *iface)
 340 {
 341     struct mmaudio *This = impl_from_ISpMMSysAudio(iface);
 342     ULONG ref = InterlockedIncrement(&This->ref);
 343
 344     TRACE("(%p): ref=%lu\n", iface, ref);
 345
 346     return ref;
 347 }
 348
 349 static ULONG WINAPI mmsysaudio_Release(ISpMMSysAudio *iface)
 350 {
 351     struct mmaudio *This = impl_from_ISpMMSysAudio(iface);
 352     ULONG ref = InterlockedDecrement(&This->ref);
 353
 354     TRACE("(%p): ref=%lu\n", iface, ref);
 355
 356     if (!ref)
 357     {
 358         if (This->token) ISpObjectToken_Release(This->token);
 359
 360         heap_free(This);
 361     }
 362
 363     return ref;
 364 }
 365
 366 static HRESULT WINAPI mmsysaudio_Read(ISpMMSysAudio *iface, void *pv, ULONG cb, ULONG *cb_read)
 367 {
 368     FIXME("(%p, %p, %lu, %p): stub.\n", iface, pv, cb, cb_read);
 369
 370     return E_NOTIMPL;
 371 }
 372
 373 static HRESULT WINAPI mmsysaudio_Write(ISpMMSysAudio *iface, const void *pv, ULONG cb, ULONG *cb_written)
 374 {
 375     FIXME("(%p, %p, %lu, %p): stub.\n", iface, pv, cb, cb_written);
 376
 377     return E_NOTIMPL;
 378 }
 379
 380 static HRESULT WINAPI mmsysaudio_Seek(ISpMMSysAudio *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *new_pos)
 381 {
 382     FIXME("(%p, %s, %lu, %p): stub.\n", iface, wine_dbgstr_longlong(move.QuadPart), origin, new_pos);
 383
 384     return E_NOTIMPL;
 385 }
 386
 387 static HRESULT WINAPI mmsysaudio_SetSize(ISpMMSysAudio *iface, ULARGE_INTEGER new_size)
 388 {
 389     FIXME("(%p, %s): stub.\n", iface, wine_dbgstr_longlong(new_size.QuadPart));
 390
 391     return E_NOTIMPL;
 392 }
 393
 394 static HRESULT WINAPI mmsysaudio_CopyTo(ISpMMSysAudio *iface, IStream *stream, ULARGE_INTEGER cb,
 395                                         ULARGE_INTEGER *cb_read, ULARGE_INTEGER *cb_written)
 396 {
 397     FIXME("(%p, %p, %s, %p, %p): stub.\n", iface, stream, wine_dbgstr_longlong(cb.QuadPart), cb_read, cb_written);
 398
 399     return E_NOTIMPL;
 400 }
 401
 402 static HRESULT WINAPI mmsysaudio_Commit(ISpMMSysAudio *iface, DWORD flags)
 403 {
 404     FIXME("(%p, %#lx): stub.\n", iface, flags);
 405
 406     return E_NOTIMPL;
 407 }
 408
 409 static HRESULT WINAPI mmsysaudio_Revert(ISpMMSysAudio *iface)
 410 {
 411     FIXME("(%p).\n", iface);
 412
 413     return E_NOTIMPL;
 414 }
 415
 416 static HRESULT WINAPI mmsysaudio_LockRegion(ISpMMSysAudio *iface, ULARGE_INTEGER offset, ULARGE_INTEGER cb,
 417                                             DWORD lock_type)
 418 {
 419     FIXME("(%p, %s, %s, %#lx): stub.\n", iface, wine_dbgstr_longlong(offset.QuadPart),
 420           wine_dbgstr_longlong(cb.QuadPart), lock_type);
 421
 422     return E_NOTIMPL;
 423 }
 424
 425 static HRESULT WINAPI mmsysaudio_UnlockRegion(ISpMMSysAudio *iface, ULARGE_INTEGER offset, ULARGE_INTEGER cb,
 426                                               DWORD lock_type)
 427 {
 428     FIXME("(%p, %s, %s, %#lx): stub.\n", iface, wine_dbgstr_longlong(offset.QuadPart),
 429           wine_dbgstr_longlong(cb.QuadPart), lock_type);
 430
 431     return E_NOTIMPL;
 432 }
 433
 434 static HRESULT WINAPI mmsysaudio_Stat(ISpMMSysAudio *iface, STATSTG *statstg, DWORD flags)
 435 {
 436     FIXME("(%p, %p, %#lx): stub.\n", iface, statstg, flags);
 437
 438     return E_NOTIMPL;
 439 }
 440
 441 static HRESULT WINAPI mmsysaudio_Clone(ISpMMSysAudio *iface, IStream **stream)
 442 {
 443     FIXME("(%p, %p): stub.\n", iface, stream);
 444
 445     return E_NOTIMPL;
 446 }
 447
 448 static HRESULT WINAPI mmsysaudio_GetFormat(ISpMMSysAudio *iface, GUID *format, WAVEFORMATEX **wfx)
 449 {
 450     FIXME("(%p, %p, %p): stub.\n", iface, format, wfx);
 451
 452     return E_NOTIMPL;
 453 }
 454
 455 static HRESULT WINAPI mmsysaudio_SetState(ISpMMSysAudio *iface, SPAUDIOSTATE state, ULONGLONG reserved)
 456 {
 457     FIXME("(%p, %u, %s): stub.\n", iface, state, wine_dbgstr_longlong(reserved));
 458
 459     return E_NOTIMPL;
 460 }
 461
 462 static HRESULT WINAPI mmsysaudio_SetFormat(ISpMMSysAudio *iface, const GUID *guid, const WAVEFORMATEX *wfx)
 463 {
 464     FIXME("(%p, %s, %p): stub.\n", iface, debugstr_guid(guid), wfx);
 465
 466     return E_NOTIMPL;
 467 }
 468
 469 static HRESULT WINAPI mmsysaudio_GetStatus(ISpMMSysAudio *iface, SPAUDIOSTATUS *status)
 470 {
 471     FIXME("(%p, %p): stub.\n", iface, status);
 472
 473     return E_NOTIMPL;
 474 }
 475
 476 static HRESULT WINAPI mmsysaudio_SetBufferInfo(ISpMMSysAudio *iface, const SPAUDIOBUFFERINFO *info)
 477 {
 478     FIXME("(%p, %p): stub.\n", iface, info);
 479
 480     return E_NOTIMPL;
 481 }
 482
 483 static HRESULT WINAPI mmsysaudio_GetBufferInfo(ISpMMSysAudio *iface, SPAUDIOBUFFERINFO *info)
 484 {
 485     FIXME("(%p, %p): stub.\n", iface, info);
 486
 487     return E_NOTIMPL;
 488 }
 489
 490 static HRESULT WINAPI mmsysaudio_GetDefaultFormat(ISpMMSysAudio *iface, GUID *guid, WAVEFORMATEX **wfx)
 491 {
 492     FIXME("(%p, %p, %p): stub.\n", iface, guid, wfx);
 493
 494     return E_NOTIMPL;
 495 }
 496
 497 static HANDLE WINAPI mmsysaudio_EventHandle(ISpMMSysAudio *iface)
 498 {
 499     FIXME("(%p): stub.\n", iface);
 500
 501     return NULL;
 502 }
 503
 504 static HRESULT WINAPI mmsysaudio_GetVolumeLevel(ISpMMSysAudio *iface, ULONG *level)
 505 {
 506     FIXME("(%p, %p): stub.\n", iface, level);
 507
 508     return E_NOTIMPL;
 509 }
 510
 511 static HRESULT WINAPI mmsysaudio_SetVolumeLevel(ISpMMSysAudio *iface, ULONG level)
 512 {
 513     FIXME("(%p, %lu): stub.\n", iface, level);
 514
 515     return E_NOTIMPL;
 516 }
 517
 518 static HRESULT WINAPI mmsysaudio_GetBufferNotifySize(ISpMMSysAudio *iface, ULONG *size)
 519 {
 520     FIXME("(%p, %p): stub.\n", iface, size);
 521
 522     return E_NOTIMPL;
 523 }
 524
 525 static HRESULT WINAPI mmsysaudio_SetBufferNotifySize(ISpMMSysAudio *iface, ULONG size)
 526 {
 527     FIXME("(%p, %lu): stub.\n", iface, size);
 528
 529     return E_NOTIMPL;
 530 }
 531
 532 static HRESULT WINAPI mmsysaudio_GetDeviceId(ISpMMSysAudio *iface, UINT *id)
 533 {
 534     FIXME("(%p, %p): stub.\n", iface, id);
 535
 536     return E_NOTIMPL;
 537 }
 538
 539 static HRESULT WINAPI mmsysaudio_SetDeviceId(ISpMMSysAudio *iface, UINT id)
 540 {
 541     FIXME("(%p, %u): stub.\n", iface, id);
 542
 543     return E_NOTIMPL;
 544 }
 545
 546 static HRESULT WINAPI mmsysaudio_GetMMHandle(ISpMMSysAudio *iface, void **handle)
 547 {
 548     FIXME("(%p, %p): stub.\n", iface, handle);
 549
 550     return E_NOTIMPL;
 551 }
 552
 553 static HRESULT WINAPI mmsysaudio_GetLineId(ISpMMSysAudio *iface, UINT *id)
 554 {
 555     FIXME("(%p, %p): stub.\n", iface, id);
 556
 557     return E_NOTIMPL;
 558 }
 559
 560 static HRESULT WINAPI mmsysaudio_SetLineId(ISpMMSysAudio *iface, UINT id)
 561 {
 562     FIXME("(%p, %u): stub.\n", iface, id);
 563
 564     return E_NOTIMPL;
 565 }
 566
 567 static const ISpMMSysAudioVtbl mmsysaudio_vtbl =
 568 {
 569     mmsysaudio_QueryInterface,
 570     mmsysaudio_AddRef,
 571     mmsysaudio_Release,
 572     mmsysaudio_Read,
 573     mmsysaudio_Write,
 574     mmsysaudio_Seek,
 575     mmsysaudio_SetSize,
 576     mmsysaudio_CopyTo,
 577     mmsysaudio_Commit,
 578     mmsysaudio_Revert,
 579     mmsysaudio_LockRegion,
 580     mmsysaudio_UnlockRegion,
 581     mmsysaudio_Stat,
 582     mmsysaudio_Clone,
 583     mmsysaudio_GetFormat,
 584     mmsysaudio_SetState,
 585     mmsysaudio_SetFormat,
 586     mmsysaudio_GetStatus,
 587     mmsysaudio_SetBufferInfo,
 588     mmsysaudio_GetBufferInfo,
 589     mmsysaudio_GetDefaultFormat,
 590     mmsysaudio_EventHandle,
 591     mmsysaudio_GetVolumeLevel,
 592     mmsysaudio_SetVolumeLevel,
 593     mmsysaudio_GetBufferNotifySize,
 594     mmsysaudio_SetBufferNotifySize,
 595     mmsysaudio_GetDeviceId,
 596     mmsysaudio_SetDeviceId,
 597     mmsysaudio_GetMMHandle,
 598     mmsysaudio_GetLineId,
 599     mmsysaudio_SetLineId
 600 };
 601
 602 static HRESULT mmaudio_create(IUnknown *outer, REFIID iid, void **obj, enum flow_type flow)
 603 {
 604     struct mmaudio *This;
 605     HRESULT hr;
 606
 607     if (flow != FLOW_OUT)
 608     {
 609         FIXME("flow %d not implemented.\n", flow);
 610         return E_NOTIMPL;
 611     }
 612
 613     if (!(This = heap_alloc_zero(sizeof(*This))))
 614         return E_OUTOFMEMORY;
 615     This->ISpEventSource_iface.lpVtbl = &event_source_vtbl;
 616     This->ISpEventSink_iface.lpVtbl = &event_sink_vtbl;
 617     This->ISpObjectWithToken_iface.lpVtbl = &objwithtoken_vtbl;
 618     This->ISpMMSysAudio_iface.lpVtbl = &mmsysaudio_vtbl;
 619     This->ref = 1;
 620
 621     This->flow = flow;
 622     This->token = NULL;
 623
 624     hr = ISpMMSysAudio_QueryInterface(&This->ISpMMSysAudio_iface, iid, obj);
 625
 626     ISpMMSysAudio_Release(&This->ISpMMSysAudio_iface);
 627     return hr;
 628 }
 629
 630 HRESULT mmaudio_out_create(IUnknown *outer, REFIID iid, void **obj)
 631 {
 632     return mmaudio_create(outer, iid, obj, FLOW_OUT);
 633 }