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 "initguid.h"
  33
  34 #include "wine/debug.h"
  35
  36 #include "sapi_private.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(sapi);
  39
  40 DEFINE_GUID(SPDFID_Text, 0x7ceef9f9, 0x3d13, 0x11d2, 0x9e, 0xe7, 0x00, 0xc0, 0x4f, 0x79, 0x73, 0x96);
  41 DEFINE_GUID(SPDFID_WaveFormatEx, 0xc31adbae, 0x527f, 0x4ff5, 0xa2, 0x30, 0xf6, 0x2b, 0xb6, 0x1f, 0xf7, 0x0c);
  42
  43 enum flow_type { FLOW_IN, FLOW_OUT };
  44
  45 struct mmaudio
  46 {
  47     ISpEventSource ISpEventSource_iface;
  48     ISpEventSink ISpEventSink_iface;
  49     ISpObjectWithToken ISpObjectWithToken_iface;
  50     ISpMMSysAudio ISpMMSysAudio_iface;
  51     LONG ref;
  52
  53     enum flow_type flow;
  54     ISpObjectToken *token;
  55     UINT device_id;
  56     SPAUDIOSTATE state;
  57     WAVEFORMATEX *wfx;
  58     union
  59     {
  60         HWAVEIN in;
  61         HWAVEOUT out;
  62     } hwave;
  63     HANDLE event;
  64     struct async_queue queue;
  65     CRITICAL_SECTION cs;
  66
  67     size_t pending_buf_count;
  68     CRITICAL_SECTION pending_cs;
  69 };
  70
  71 static inline struct mmaudio *impl_from_ISpEventSource(ISpEventSource *iface)
  72 {
  73     return CONTAINING_RECORD(iface, struct mmaudio, ISpEventSource_iface);
  74 }
  75
  76 static inline struct mmaudio *impl_from_ISpEventSink(ISpEventSink *iface)
  77 {
  78     return CONTAINING_RECORD(iface, struct mmaudio, ISpEventSink_iface);
  79 }
  80
  81 static inline struct mmaudio *impl_from_ISpObjectWithToken(ISpObjectWithToken *iface)
  82 {
  83     return CONTAINING_RECORD(iface, struct mmaudio, ISpObjectWithToken_iface);
  84 }
  85
  86 static inline struct mmaudio *impl_from_ISpMMSysAudio(ISpMMSysAudio *iface)
  87 {
  88     return CONTAINING_RECORD(iface, struct mmaudio, ISpMMSysAudio_iface);
  89 }
  90
  91 static HRESULT WINAPI event_source_QueryInterface(ISpEventSource *iface, REFIID iid, void **obj)
  92 {
  93     struct mmaudio *This = impl_from_ISpEventSource(iface);
  94
  95     TRACE("(%p, %s, %p).\n", iface, debugstr_guid(iid), obj);
  96
  97     return ISpMMSysAudio_QueryInterface(&This->ISpMMSysAudio_iface, iid, obj);
  98 }
  99
 100 static ULONG WINAPI event_source_AddRef(ISpEventSource *iface)
 101 {
 102     struct mmaudio *This = impl_from_ISpEventSource(iface);
 103
 104     TRACE("(%p).\n", iface);
 105
 106     return ISpMMSysAudio_AddRef(&This->ISpMMSysAudio_iface);
 107 }
 108
 109 static ULONG WINAPI event_source_Release(ISpEventSource *iface)
 110 {
 111     struct mmaudio *This = impl_from_ISpEventSource(iface);
 112
 113     TRACE("(%p).\n", iface);
 114
 115     return ISpMMSysAudio_Release(&This->ISpMMSysAudio_iface);
 116 }
 117
 118 static HRESULT WINAPI event_source_SetNotifySink(ISpEventSource *iface, ISpNotifySink *sink)
 119 {
 120     FIXME("(%p, %p): stub.\n", iface, sink);
 121
 122     return E_NOTIMPL;
 123 }
 124
 125 static HRESULT WINAPI event_source_SetNotifyWindowMessage(ISpEventSource *iface, HWND hwnd,
 126                                                           UINT msg, WPARAM wparam, LPARAM lparam)
 127 {
 128     FIXME("(%p, %p, %u, %Ix, %Ix): stub.\n", iface, hwnd, msg, wparam, lparam);
 129
 130     return E_NOTIMPL;
 131 }
 132
 133 static HRESULT WINAPI event_source_SetNotifyCallbackFunction(ISpEventSource *iface, SPNOTIFYCALLBACK *callback,
 134                                                              WPARAM wparam, LPARAM lparam)
 135 {
 136     FIXME("(%p, %p, %Ix, %Ix): stub.\n", iface, callback, wparam, lparam);
 137
 138     return E_NOTIMPL;
 139 }
 140
 141 static HRESULT WINAPI event_source_SetNotifyCallbackInterface(ISpEventSource *iface, ISpNotifyCallback *callback,
 142                                                               WPARAM wparam, LPARAM lparam)
 143 {
 144     FIXME("(%p, %p, %Ix, %Ix): stub.\n", iface, callback, wparam, lparam);
 145
 146     return E_NOTIMPL;
 147 }
 148
 149 static HRESULT WINAPI event_source_SetNotifyWin32Event(ISpEventSource *iface)
 150 {
 151     FIXME("(%p): stub.\n", iface);
 152
 153     return E_NOTIMPL;
 154 }
 155
 156 static HRESULT WINAPI event_source_WaitForNotifyEvent(ISpEventSource *iface, DWORD milliseconds)
 157 {
 158     FIXME("(%p, %ld): stub.\n", iface, milliseconds);
 159
 160     return E_NOTIMPL;
 161 }
 162
 163 static HANDLE WINAPI event_source_GetNotifyEventHandle(ISpEventSource *iface)
 164 {
 165     FIXME("(%p): stub.\n", iface);
 166
 167     return NULL;
 168 }
 169
 170 static HRESULT WINAPI event_source_SetInterest(ISpEventSource *iface, ULONGLONG event, ULONGLONG queued)
 171 {
 172     FIXME("(%p, %s, %s): stub.\n", iface, wine_dbgstr_longlong(event), wine_dbgstr_longlong(queued));
 173
 174     return E_NOTIMPL;
 175 }
 176
 177 static HRESULT WINAPI event_source_GetEvents(ISpEventSource *iface, ULONG count, SPEVENT *array, ULONG *fetched)
 178 {
 179     FIXME("(%p, %lu, %p, %p): stub.\n", iface, count, array, fetched);
 180
 181     return E_NOTIMPL;
 182 }
 183
 184 static HRESULT WINAPI event_source_GetInfo(ISpEventSource *iface, SPEVENTSOURCEINFO *info)
 185 {
 186     FIXME("(%p, %p): stub.\n", iface, info);
 187
 188     return E_NOTIMPL;
 189 }
 190
 191 static const ISpEventSourceVtbl event_source_vtbl =
 192 {
 193     event_source_QueryInterface,
 194     event_source_AddRef,
 195     event_source_Release,
 196     event_source_SetNotifySink,
 197     event_source_SetNotifyWindowMessage,
 198     event_source_SetNotifyCallbackFunction,
 199     event_source_SetNotifyCallbackInterface,
 200     event_source_SetNotifyWin32Event,
 201     event_source_WaitForNotifyEvent,
 202     event_source_GetNotifyEventHandle,
 203     event_source_SetInterest,
 204     event_source_GetEvents,
 205     event_source_GetInfo
 206 };
 207
 208 static HRESULT WINAPI event_sink_QueryInterface(ISpEventSink *iface, REFIID iid, void **obj)
 209 {
 210     struct mmaudio *This = impl_from_ISpEventSink(iface);
 211
 212     TRACE("(%p, %s, %p).\n", iface, debugstr_guid(iid), obj);
 213
 214     return ISpMMSysAudio_QueryInterface(&This->ISpMMSysAudio_iface, iid, obj);
 215 }
 216
 217 static ULONG WINAPI event_sink_AddRef(ISpEventSink *iface)
 218 {
 219     struct mmaudio *This = impl_from_ISpEventSink(iface);
 220
 221     TRACE("(%p).\n", iface);
 222
 223     return ISpMMSysAudio_AddRef(&This->ISpMMSysAudio_iface);
 224 }
 225
 226 static ULONG WINAPI event_sink_Release(ISpEventSink *iface)
 227 {
 228     struct mmaudio *This = impl_from_ISpEventSink(iface);
 229
 230     TRACE("(%p).\n", iface);
 231
 232     return ISpMMSysAudio_Release(&This->ISpMMSysAudio_iface);
 233 }
 234
 235 static HRESULT WINAPI event_sink_AddEvents(ISpEventSink *iface, const SPEVENT *events, ULONG count)
 236 {
 237     FIXME("(%p, %p, %lu).\n", iface, events, count);
 238
 239     return E_NOTIMPL;
 240 }
 241
 242 static HRESULT WINAPI event_sink_GetEventInterest(ISpEventSink *iface, ULONGLONG *interest)
 243 {
 244     FIXME("(%p, %p).\n", iface, interest);
 245
 246     return E_NOTIMPL;
 247 }
 248
 249 static const ISpEventSinkVtbl event_sink_vtbl =
 250 {
 251     event_sink_QueryInterface,
 252     event_sink_AddRef,
 253     event_sink_Release,
 254     event_sink_AddEvents,
 255     event_sink_GetEventInterest
 256 };
 257
 258 static HRESULT WINAPI objwithtoken_QueryInterface(ISpObjectWithToken *iface, REFIID iid, void **obj)
 259 {
 260     struct mmaudio *This = impl_from_ISpObjectWithToken(iface);
 261
 262     TRACE("(%p, %s, %p).\n", iface, debugstr_guid(iid), obj);
 263
 264     return ISpMMSysAudio_QueryInterface(&This->ISpMMSysAudio_iface, iid, obj);
 265 }
 266
 267 static ULONG WINAPI objwithtoken_AddRef(ISpObjectWithToken *iface)
 268 {
 269     struct mmaudio *This = impl_from_ISpObjectWithToken(iface);
 270
 271     TRACE("(%p).\n", iface);
 272
 273     return ISpMMSysAudio_AddRef(&This->ISpMMSysAudio_iface);
 274 }
 275
 276 static ULONG WINAPI objwithtoken_Release(ISpObjectWithToken *iface)
 277 {
 278     struct mmaudio *This = impl_from_ISpObjectWithToken(iface);
 279
 280     TRACE("(%p).\n", iface);
 281
 282     return ISpMMSysAudio_Release(&This->ISpMMSysAudio_iface);
 283 }
 284
 285 static HRESULT WINAPI objwithtoken_SetObjectToken(ISpObjectWithToken *iface, ISpObjectToken *token)
 286 {
 287     struct mmaudio *This = impl_from_ISpObjectWithToken(iface);
 288
 289     FIXME("(%p, %p): semi-stub.\n", iface, token);
 290
 291     if (!token)
 292         return E_INVALIDARG;
 293     if (This->token)
 294         return SPERR_ALREADY_INITIALIZED;
 295
 296     This->token = token;
 297     return S_OK;
 298 }
 299
 300 static HRESULT WINAPI objwithtoken_GetObjectToken(ISpObjectWithToken *iface, ISpObjectToken **token)
 301 {
 302     struct mmaudio *This = impl_from_ISpObjectWithToken(iface);
 303
 304     TRACE("(%p, %p).\n", iface, token);
 305
 306     if (!token)
 307         return E_POINTER;
 308
 309     *token = This->token;
 310     if (*token)
 311     {
 312         ISpObjectToken_AddRef(*token);
 313         return S_OK;
 314     }
 315     else
 316         return S_FALSE;
 317 }
 318
 319 static const ISpObjectWithTokenVtbl objwithtoken_vtbl =
 320 {
 321     objwithtoken_QueryInterface,
 322     objwithtoken_AddRef,
 323     objwithtoken_Release,
 324     objwithtoken_SetObjectToken,
 325     objwithtoken_GetObjectToken
 326 };
 327
 328 static HRESULT WINAPI mmsysaudio_QueryInterface(ISpMMSysAudio *iface, REFIID iid, void **obj)
 329 {
 330     struct mmaudio *This = impl_from_ISpMMSysAudio(iface);
 331
 332     TRACE("(%p, %s, %p).\n", iface, debugstr_guid(iid), obj);
 333
 334     if (IsEqualIID(iid, &IID_IUnknown) ||
 335         IsEqualIID(iid, &IID_ISequentialStream) ||
 336         IsEqualIID(iid, &IID_IStream) ||
 337         IsEqualIID(iid, &IID_ISpStreamFormat) ||
 338         IsEqualIID(iid, &IID_ISpAudio) ||
 339         IsEqualIID(iid, &IID_ISpMMSysAudio))
 340         *obj = &This->ISpMMSysAudio_iface;
 341     else if (IsEqualIID(iid, &IID_ISpEventSource))
 342         *obj = &This->ISpEventSource_iface;
 343     else if (IsEqualIID(iid, &IID_ISpEventSink))
 344         *obj = &This->ISpEventSink_iface;
 345     else if (IsEqualIID(iid, &IID_ISpObjectWithToken))
 346         *obj = &This->ISpObjectWithToken_iface;
 347     else
 348     {
 349         *obj = NULL;
 350         FIXME("interface %s not implemented.\n", debugstr_guid(iid));
 351         return E_NOINTERFACE;
 352     }
 353
 354     IUnknown_AddRef((IUnknown *)*obj);
 355     return S_OK;
 356 }
 357
 358 static ULONG WINAPI mmsysaudio_AddRef(ISpMMSysAudio *iface)
 359 {
 360     struct mmaudio *This = impl_from_ISpMMSysAudio(iface);
 361     ULONG ref = InterlockedIncrement(&This->ref);
 362
 363     TRACE("(%p): ref=%lu\n", iface, ref);
 364
 365     return ref;
 366 }
 367
 368 static ULONG WINAPI mmsysaudio_Release(ISpMMSysAudio *iface)
 369 {
 370     struct mmaudio *This = impl_from_ISpMMSysAudio(iface);
 371     ULONG ref = InterlockedDecrement(&This->ref);
 372
 373     TRACE("(%p): ref=%lu\n", iface, ref);
 374
 375     if (!ref)
 376     {
 377         ISpMMSysAudio_SetState(iface, SPAS_CLOSED, 0);
 378
 379         async_wait_queue_empty(&This->queue, INFINITE);
 380         async_cancel_queue(&This->queue);
 381
 382         if (This->token) ISpObjectToken_Release(This->token);
 383         heap_free(This->wfx);
 384         CloseHandle(This->event);
 385         DeleteCriticalSection(&This->pending_cs);
 386         DeleteCriticalSection(&This->cs);
 387
 388         heap_free(This);
 389     }
 390
 391     return ref;
 392 }
 393
 394 static HRESULT WINAPI mmsysaudio_Read(ISpMMSysAudio *iface, void *pv, ULONG cb, ULONG *cb_read)
 395 {
 396     FIXME("(%p, %p, %lu, %p): stub.\n", iface, pv, cb, cb_read);
 397
 398     return E_NOTIMPL;
 399 }
 400
 401 static HRESULT WINAPI mmsysaudio_Write(ISpMMSysAudio *iface, const void *pv, ULONG cb, ULONG *cb_written)
 402 {
 403     FIXME("(%p, %p, %lu, %p): stub.\n", iface, pv, cb, cb_written);
 404
 405     return E_NOTIMPL;
 406 }
 407
 408 static HRESULT WINAPI mmsysaudio_Seek(ISpMMSysAudio *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *new_pos)
 409 {
 410     FIXME("(%p, %s, %lu, %p): stub.\n", iface, wine_dbgstr_longlong(move.QuadPart), origin, new_pos);
 411
 412     return E_NOTIMPL;
 413 }
 414
 415 static HRESULT WINAPI mmsysaudio_SetSize(ISpMMSysAudio *iface, ULARGE_INTEGER new_size)
 416 {
 417     FIXME("(%p, %s): stub.\n", iface, wine_dbgstr_longlong(new_size.QuadPart));
 418
 419     return E_NOTIMPL;
 420 }
 421
 422 static HRESULT WINAPI mmsysaudio_CopyTo(ISpMMSysAudio *iface, IStream *stream, ULARGE_INTEGER cb,
 423                                         ULARGE_INTEGER *cb_read, ULARGE_INTEGER *cb_written)
 424 {
 425     FIXME("(%p, %p, %s, %p, %p): stub.\n", iface, stream, wine_dbgstr_longlong(cb.QuadPart), cb_read, cb_written);
 426
 427     return E_NOTIMPL;
 428 }
 429
 430 static HRESULT WINAPI mmsysaudio_Commit(ISpMMSysAudio *iface, DWORD flags)
 431 {
 432     FIXME("(%p, %#lx): stub.\n", iface, flags);
 433
 434     return E_NOTIMPL;
 435 }
 436
 437 static HRESULT WINAPI mmsysaudio_Revert(ISpMMSysAudio *iface)
 438 {
 439     FIXME("(%p).\n", iface);
 440
 441     return E_NOTIMPL;
 442 }
 443
 444 static HRESULT WINAPI mmsysaudio_LockRegion(ISpMMSysAudio *iface, ULARGE_INTEGER offset, ULARGE_INTEGER cb,
 445                                             DWORD lock_type)
 446 {
 447     FIXME("(%p, %s, %s, %#lx): stub.\n", iface, wine_dbgstr_longlong(offset.QuadPart),
 448           wine_dbgstr_longlong(cb.QuadPart), lock_type);
 449
 450     return E_NOTIMPL;
 451 }
 452
 453 static HRESULT WINAPI mmsysaudio_UnlockRegion(ISpMMSysAudio *iface, ULARGE_INTEGER offset, ULARGE_INTEGER cb,
 454                                               DWORD lock_type)
 455 {
 456     FIXME("(%p, %s, %s, %#lx): stub.\n", iface, wine_dbgstr_longlong(offset.QuadPart),
 457           wine_dbgstr_longlong(cb.QuadPart), lock_type);
 458
 459     return E_NOTIMPL;
 460 }
 461
 462 static HRESULT WINAPI mmsysaudio_Stat(ISpMMSysAudio *iface, STATSTG *statstg, DWORD flags)
 463 {
 464     FIXME("(%p, %p, %#lx): stub.\n", iface, statstg, flags);
 465
 466     return E_NOTIMPL;
 467 }
 468
 469 static HRESULT WINAPI mmsysaudio_Clone(ISpMMSysAudio *iface, IStream **stream)
 470 {
 471     FIXME("(%p, %p): stub.\n", iface, stream);
 472
 473     return E_NOTIMPL;
 474 }
 475
 476 static HRESULT WINAPI mmsysaudio_GetFormat(ISpMMSysAudio *iface, GUID *format, WAVEFORMATEX **wfx)
 477 {
 478     struct mmaudio *This = impl_from_ISpMMSysAudio(iface);
 479
 480     TRACE("(%p, %p, %p).\n", iface, format, wfx);
 481
 482     if (!format || !wfx)
 483         return E_POINTER;
 484
 485     EnterCriticalSection(&This->cs);
 486
 487     if (!(*wfx = CoTaskMemAlloc(sizeof(WAVEFORMATEX) + This->wfx->cbSize)))
 488     {
 489         LeaveCriticalSection(&This->cs);
 490         return E_OUTOFMEMORY;
 491     }
 492     *format = SPDFID_WaveFormatEx;
 493     memcpy(*wfx, This->wfx, sizeof(WAVEFORMATEX) + This->wfx->cbSize);
 494
 495     LeaveCriticalSection(&This->cs);
 496
 497     return S_OK;
 498 }
 499
 500 struct free_buf_task
 501 {
 502     struct async_task task;
 503     struct mmaudio *audio;
 504     WAVEHDR *buf;
 505 };
 506
 507 static void free_out_buf_proc(struct async_task *task)
 508 {
 509     struct free_buf_task *fbt = (struct free_buf_task *)task;
 510     size_t buf_count;
 511
 512     TRACE("(%p).\n", task);
 513
 514     waveOutUnprepareHeader(fbt->audio->hwave.out, fbt->buf, sizeof(WAVEHDR));
 515     heap_free(fbt->buf);
 516
 517     EnterCriticalSection(&fbt->audio->pending_cs);
 518     buf_count = --fbt->audio->pending_buf_count;
 519     LeaveCriticalSection(&fbt->audio->pending_cs);
 520     if (!buf_count)
 521         SetEvent(fbt->audio->event);
 522     TRACE("pending_buf_count = %Iu.\n", buf_count);
 523 }
 524
 525 static void CALLBACK wave_out_proc(HWAVEOUT hwo, UINT msg, DWORD_PTR instance, DWORD_PTR param1, DWORD_PTR param2)
 526 {
 527     struct mmaudio *This = (struct mmaudio *)instance;
 528     struct free_buf_task *task;
 529
 530     TRACE("(%p, %#x, %08Ix, %08Ix, %08Ix).\n", hwo, msg, instance, param1, param2);
 531
 532     switch (msg)
 533     {
 534     case WOM_DONE:
 535         if (!(task = heap_alloc(sizeof(*task))))
 536         {
 537             ERR("failed to allocate free_buf_task.\n");
 538             break;
 539         }
 540         task->task.proc = free_out_buf_proc;
 541         task->audio = This;
 542         task->buf = (WAVEHDR *)param1;
 543         async_queue_task(&This->queue, (struct async_task *)task);
 544         break;
 545
 546     default:
 547         break;
 548     }
 549 }
 550
 551 static HRESULT WINAPI mmsysaudio_SetState(ISpMMSysAudio *iface, SPAUDIOSTATE state, ULONGLONG reserved)
 552 {
 553     struct mmaudio *This = impl_from_ISpMMSysAudio(iface);
 554     HRESULT hr = S_OK;
 555
 556     TRACE("(%p, %u, %s).\n", iface, state, wine_dbgstr_longlong(reserved));
 557
 558     if (state != SPAS_CLOSED && state != SPAS_RUN)
 559     {
 560         FIXME("state %#x not implemented.\n", state);
 561         return E_NOTIMPL;
 562     }
 563
 564     EnterCriticalSection(&This->cs);
 565
 566     if (This->state == state)
 567         goto done;
 568
 569     if (This->state == SPAS_CLOSED)
 570     {
 571         if (FAILED(hr = async_start_queue(&This->queue)))
 572         {
 573             ERR("Failed to start async queue: %#lx.\n", hr);
 574             goto done;
 575         }
 576
 577         if (waveOutOpen(&This->hwave.out, This->device_id, This->wfx, (DWORD_PTR)wave_out_proc,
 578                         (DWORD_PTR)This, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)
 579         {
 580             hr = SPERR_GENERIC_MMSYS_ERROR;
 581             goto done;
 582         }
 583     }
 584
 585     if (state == SPAS_CLOSED && This->state != SPAS_CLOSED)
 586     {
 587         waveOutReset(This->hwave.out);
 588         /* Wait until all buffers are freed. */
 589         WaitForSingleObject(This->event, INFINITE);
 590
 591         if (waveOutClose(This->hwave.out) != MMSYSERR_NOERROR)
 592         {
 593             hr = SPERR_GENERIC_MMSYS_ERROR;
 594             goto done;
 595         }
 596     }
 597
 598     This->state = state;
 599
 600 done:
 601     LeaveCriticalSection(&This->cs);
 602     return hr;
 603 }
 604
 605 static HRESULT WINAPI mmsysaudio_SetFormat(ISpMMSysAudio *iface, const GUID *guid, const WAVEFORMATEX *wfx)
 606 {
 607     struct mmaudio *This = impl_from_ISpMMSysAudio(iface);
 608     MMRESULT res;
 609     WAVEFORMATEX *new_wfx;
 610
 611     TRACE("(%p, %s, %p).\n", iface, debugstr_guid(guid), wfx);
 612
 613     if (!guid || !wfx || !IsEqualGUID(guid, &SPDFID_WaveFormatEx))
 614         return E_INVALIDARG;
 615
 616     EnterCriticalSection(&This->cs);
 617
 618     if (!memcmp(wfx, This->wfx, sizeof(*wfx)) && !memcmp(wfx + 1, This->wfx + 1, wfx->cbSize))
 619     {
 620         LeaveCriticalSection(&This->cs);
 621         return S_OK;
 622     }
 623
 624     if (This->state != SPAS_CLOSED)
 625     {
 626         LeaveCriticalSection(&This->cs);
 627         return SPERR_DEVICE_BUSY;
 628     }
 629
 630     /* Determine whether the device supports the requested format. */
 631     res = waveOutOpen(NULL, This->device_id, wfx, 0, 0, WAVE_FORMAT_QUERY);
 632     if (res != MMSYSERR_NOERROR)
 633     {
 634         LeaveCriticalSection(&This->cs);
 635         return res == WAVERR_BADFORMAT ? SPERR_UNSUPPORTED_FORMAT : SPERR_GENERIC_MMSYS_ERROR;
 636     }
 637
 638     if (!(new_wfx = heap_alloc(sizeof(*wfx) + wfx->cbSize)))
 639     {
 640         LeaveCriticalSection(&This->cs);
 641         return E_OUTOFMEMORY;
 642     }
 643     memcpy(new_wfx, wfx, sizeof(*wfx) + wfx->cbSize);
 644     heap_free(This->wfx);
 645     This->wfx = new_wfx;
 646
 647     LeaveCriticalSection(&This->cs);
 648
 649     return S_OK;
 650 }
 651
 652 static HRESULT WINAPI mmsysaudio_GetStatus(ISpMMSysAudio *iface, SPAUDIOSTATUS *status)
 653 {
 654     FIXME("(%p, %p): stub.\n", iface, status);
 655
 656     return E_NOTIMPL;
 657 }
 658
 659 static HRESULT WINAPI mmsysaudio_SetBufferInfo(ISpMMSysAudio *iface, const SPAUDIOBUFFERINFO *info)
 660 {
 661     FIXME("(%p, %p): stub.\n", iface, info);
 662
 663     return E_NOTIMPL;
 664 }
 665
 666 static HRESULT WINAPI mmsysaudio_GetBufferInfo(ISpMMSysAudio *iface, SPAUDIOBUFFERINFO *info)
 667 {
 668     FIXME("(%p, %p): stub.\n", iface, info);
 669
 670     return E_NOTIMPL;
 671 }
 672
 673 static HRESULT WINAPI mmsysaudio_GetDefaultFormat(ISpMMSysAudio *iface, GUID *guid, WAVEFORMATEX **wfx)
 674 {
 675     FIXME("(%p, %p, %p): stub.\n", iface, guid, wfx);
 676
 677     return E_NOTIMPL;
 678 }
 679
 680 static HANDLE WINAPI mmsysaudio_EventHandle(ISpMMSysAudio *iface)
 681 {
 682     FIXME("(%p): stub.\n", iface);
 683
 684     return NULL;
 685 }
 686
 687 static HRESULT WINAPI mmsysaudio_GetVolumeLevel(ISpMMSysAudio *iface, ULONG *level)
 688 {
 689     FIXME("(%p, %p): stub.\n", iface, level);
 690
 691     return E_NOTIMPL;
 692 }
 693
 694 static HRESULT WINAPI mmsysaudio_SetVolumeLevel(ISpMMSysAudio *iface, ULONG level)
 695 {
 696     FIXME("(%p, %lu): stub.\n", iface, level);
 697
 698     return E_NOTIMPL;
 699 }
 700
 701 static HRESULT WINAPI mmsysaudio_GetBufferNotifySize(ISpMMSysAudio *iface, ULONG *size)
 702 {
 703     FIXME("(%p, %p): stub.\n", iface, size);
 704
 705     return E_NOTIMPL;
 706 }
 707
 708 static HRESULT WINAPI mmsysaudio_SetBufferNotifySize(ISpMMSysAudio *iface, ULONG size)
 709 {
 710     FIXME("(%p, %lu): stub.\n", iface, size);
 711
 712     return E_NOTIMPL;
 713 }
 714
 715 static HRESULT WINAPI mmsysaudio_GetDeviceId(ISpMMSysAudio *iface, UINT *id)
 716 {
 717     struct mmaudio *This = impl_from_ISpMMSysAudio(iface);
 718
 719     TRACE("(%p, %p).\n", iface, id);
 720
 721     if (!id) return E_POINTER;
 722
 723     EnterCriticalSection(&This->cs);
 724     *id = This->device_id;
 725     LeaveCriticalSection(&This->cs);
 726
 727     return S_OK;
 728 }
 729
 730 static HRESULT WINAPI mmsysaudio_SetDeviceId(ISpMMSysAudio *iface, UINT id)
 731 {
 732     struct mmaudio *This = impl_from_ISpMMSysAudio(iface);
 733
 734     TRACE("(%p, %u).\n", iface, id);
 735
 736     if (id != WAVE_MAPPER && id >= waveOutGetNumDevs())
 737         return E_INVALIDARG;
 738
 739     EnterCriticalSection(&This->cs);
 740
 741     if (id == This->device_id)
 742     {
 743         LeaveCriticalSection(&This->cs);
 744         return S_OK;
 745     }
 746     if (This->state != SPAS_CLOSED)
 747     {
 748         LeaveCriticalSection(&This->cs);
 749         return SPERR_DEVICE_BUSY;
 750     }
 751     This->device_id = id;
 752
 753     LeaveCriticalSection(&This->cs);
 754
 755     return S_OK;
 756 }
 757
 758 static HRESULT WINAPI mmsysaudio_GetMMHandle(ISpMMSysAudio *iface, void **handle)
 759 {
 760     FIXME("(%p, %p): stub.\n", iface, handle);
 761
 762     return E_NOTIMPL;
 763 }
 764
 765 static HRESULT WINAPI mmsysaudio_GetLineId(ISpMMSysAudio *iface, UINT *id)
 766 {
 767     FIXME("(%p, %p): stub.\n", iface, id);
 768
 769     return E_NOTIMPL;
 770 }
 771
 772 static HRESULT WINAPI mmsysaudio_SetLineId(ISpMMSysAudio *iface, UINT id)
 773 {
 774     FIXME("(%p, %u): stub.\n", iface, id);
 775
 776     return E_NOTIMPL;
 777 }
 778
 779 static const ISpMMSysAudioVtbl mmsysaudio_vtbl =
 780 {
 781     mmsysaudio_QueryInterface,
 782     mmsysaudio_AddRef,
 783     mmsysaudio_Release,
 784     mmsysaudio_Read,
 785     mmsysaudio_Write,
 786     mmsysaudio_Seek,
 787     mmsysaudio_SetSize,
 788     mmsysaudio_CopyTo,
 789     mmsysaudio_Commit,
 790     mmsysaudio_Revert,
 791     mmsysaudio_LockRegion,
 792     mmsysaudio_UnlockRegion,
 793     mmsysaudio_Stat,
 794     mmsysaudio_Clone,
 795     mmsysaudio_GetFormat,
 796     mmsysaudio_SetState,
 797     mmsysaudio_SetFormat,
 798     mmsysaudio_GetStatus,
 799     mmsysaudio_SetBufferInfo,
 800     mmsysaudio_GetBufferInfo,
 801     mmsysaudio_GetDefaultFormat,
 802     mmsysaudio_EventHandle,
 803     mmsysaudio_GetVolumeLevel,
 804     mmsysaudio_SetVolumeLevel,
 805     mmsysaudio_GetBufferNotifySize,
 806     mmsysaudio_SetBufferNotifySize,
 807     mmsysaudio_GetDeviceId,
 808     mmsysaudio_SetDeviceId,
 809     mmsysaudio_GetMMHandle,
 810     mmsysaudio_GetLineId,
 811     mmsysaudio_SetLineId
 812 };
 813
 814 static HRESULT mmaudio_create(IUnknown *outer, REFIID iid, void **obj, enum flow_type flow)
 815 {
 816     struct mmaudio *This;
 817     HRESULT hr;
 818
 819     if (flow != FLOW_OUT)
 820     {
 821         FIXME("flow %d not implemented.\n", flow);
 822         return E_NOTIMPL;
 823     }
 824
 825     if (!(This = heap_alloc_zero(sizeof(*This))))
 826         return E_OUTOFMEMORY;
 827     This->ISpEventSource_iface.lpVtbl = &event_source_vtbl;
 828     This->ISpEventSink_iface.lpVtbl = &event_sink_vtbl;
 829     This->ISpObjectWithToken_iface.lpVtbl = &objwithtoken_vtbl;
 830     This->ISpMMSysAudio_iface.lpVtbl = &mmsysaudio_vtbl;
 831     This->ref = 1;
 832
 833     This->flow = flow;
 834     This->token = NULL;
 835     This->device_id = WAVE_MAPPER;
 836     This->state = SPAS_CLOSED;
 837
 838     if (!(This->wfx = heap_alloc(sizeof(*This->wfx))))
 839     {
 840         heap_free(This);
 841         return E_OUTOFMEMORY;
 842     }
 843     This->wfx->wFormatTag = WAVE_FORMAT_PCM;
 844     This->wfx->nChannels = 1;
 845     This->wfx->nSamplesPerSec = 22050;
 846     This->wfx->nAvgBytesPerSec = 22050 * 2;
 847     This->wfx->nBlockAlign = 2;
 848     This->wfx->wBitsPerSample = 16;
 849     This->wfx->cbSize = 0;
 850
 851     This->pending_buf_count = 0;
 852     This->event = CreateEventW(NULL, TRUE, TRUE, NULL);
 853
 854     InitializeCriticalSection(&This->cs);
 855     InitializeCriticalSection(&This->pending_cs);
 856
 857     hr = ISpMMSysAudio_QueryInterface(&This->ISpMMSysAudio_iface, iid, obj);
 858     ISpMMSysAudio_Release(&This->ISpMMSysAudio_iface);
 859     return hr;
 860 }
 861
 862 HRESULT mmaudio_out_create(IUnknown *outer, REFIID iid, void **obj)
 863 {
 864     return mmaudio_create(outer, iid, obj, FLOW_OUT);
 865 }