dlls/dmsynth/synthsink.c

   1 /*
   2  * IDirectMusicSynthSink Implementation
   3  *
   4  * Copyright (C) 2003-2004 Rok Mandeljc
   5  * Copyright (C) 2012 Christian Costa
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "dmsynth_private.h"
  23 #include "initguid.h"
  24 #include "uuids.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(dmsynth);
  27
  28 #define BUFFER_SUBDIVISIONS 100
  29
  30 struct synth_sink
  31 {
  32     IDirectMusicSynthSink IDirectMusicSynthSink_iface;
  33     IKsControl IKsControl_iface;
  34     IReferenceClock IReferenceClock_iface;
  35     LONG ref;
  36
  37     IReferenceClock *master_clock;
  38     IDirectMusicSynth *synth;   /* No reference hold! */
  39     IDirectSound *dsound;
  40     IDirectSoundBuffer *dsound_buffer;
  41
  42     BOOL active;
  43     REFERENCE_TIME activate_time;
  44
  45     CRITICAL_SECTION cs;
  46     REFERENCE_TIME latency_time;
  47
  48     DWORD written; /* number of bytes written out */
  49     HANDLE stop_event;
  50     HANDLE render_thread;
  51 };
  52
  53 static inline struct synth_sink *impl_from_IDirectMusicSynthSink(IDirectMusicSynthSink *iface)
  54 {
  55     return CONTAINING_RECORD(iface, struct synth_sink, IDirectMusicSynthSink_iface);
  56 }
  57
  58 static void synth_sink_get_format(struct synth_sink *This, WAVEFORMATEX *format)
  59 {
  60     DWORD size = sizeof(*format);
  61     HRESULT hr;
  62
  63     format->wFormatTag = WAVE_FORMAT_PCM;
  64     format->nChannels = 2;
  65     format->wBitsPerSample = 16;
  66     format->nSamplesPerSec = 22050;
  67     format->nBlockAlign = format->nChannels * format->wBitsPerSample / 8;
  68     format->nAvgBytesPerSec = format->nSamplesPerSec * format->nBlockAlign;
  69
  70     if (This->synth)
  71     {
  72         if (FAILED(hr = IDirectMusicSynth_GetFormat(This->synth, format, &size)))
  73             WARN("Failed to get synth buffer format, hr %#lx\n", hr);
  74     }
  75 }
  76
  77 static HRESULT synth_sink_write_data(struct synth_sink *sink, IDirectSoundBuffer *buffer,
  78         DSBCAPS *caps, WAVEFORMATEX *format, const void *data, DWORD size)
  79 {
  80     DWORD write_end, size1, size2, current_pos;
  81     void *data1, *data2;
  82     HRESULT hr;
  83
  84     TRACE("sink %p, data %p, size %#lx\n", sink, data, size);
  85
  86     current_pos = sink->written % caps->dwBufferBytes;
  87
  88     if (sink->written)
  89     {
  90         DWORD play_pos, write_pos;
  91
  92         if (FAILED(hr = IDirectSoundBuffer_GetCurrentPosition(buffer, &play_pos, &write_pos))) return hr;
  93
  94         if (current_pos - play_pos <= write_pos - play_pos)
  95         {
  96             ERR("Underrun detected, sink %p, play pos %#lx, write pos %#lx, current pos %#lx!\n",
  97                     buffer, play_pos, write_pos, current_pos);
  98             current_pos = write_pos;
  99         }
 100
 101         write_end = (current_pos + size) % caps->dwBufferBytes;
 102         if (write_end - current_pos >= play_pos - current_pos) return S_FALSE;
 103     }
 104
 105     if (FAILED(hr = IDirectSoundBuffer_Lock(buffer, current_pos, size,
 106             &data1, &size1, &data2, &size2, 0)))
 107     {
 108         ERR("IDirectSoundBuffer_Lock failed, hr %#lx\n", hr);
 109         return hr;
 110     }
 111
 112     if (!data)
 113     {
 114         memset(data1, format->wBitsPerSample == 8 ? 128 : 0, size1);
 115         memset(data2, format->wBitsPerSample == 8 ? 128 : 0, size2);
 116     }
 117     else
 118     {
 119         memcpy(data1, data, size1);
 120         data = (char *)data + size1;
 121         memcpy(data2, data, size2);
 122     }
 123
 124     if (FAILED(hr = IDirectSoundBuffer_Unlock(buffer, data1, size1, data2, size2)))
 125     {
 126         ERR("IDirectSoundBuffer_Unlock failed, hr %#lx\n", hr);
 127         return hr;
 128     }
 129
 130     sink->written += size;
 131     TRACE("Written size %#lx, total %#lx\n", size, sink->written);
 132     return S_OK;
 133 }
 134
 135 static HRESULT synth_sink_wait_play_end(struct synth_sink *sink, IDirectSoundBuffer *buffer,
 136         DSBCAPS *caps, WAVEFORMATEX *format, HANDLE buffer_event)
 137 {
 138     DWORD current_pos, start_pos, play_pos, written, played = 0;
 139     HRESULT hr;
 140
 141     if (FAILED(hr = IDirectSoundBuffer_GetCurrentPosition(buffer, &start_pos, NULL)))
 142     {
 143         ERR("IDirectSoundBuffer_GetCurrentPosition failed, hr %#lx\n", hr);
 144         return hr;
 145     }
 146
 147     current_pos = sink->written % caps->dwBufferBytes;
 148     written = current_pos - start_pos + (current_pos < start_pos ? caps->dwBufferBytes : 0);
 149     if (FAILED(hr = synth_sink_write_data(sink, buffer, caps, format, NULL, caps->dwBufferBytes / 2))) return hr;
 150
 151     for (;;)
 152     {
 153         DWORD ret;
 154
 155         if (FAILED(hr = IDirectSoundBuffer_GetCurrentPosition(buffer, &play_pos, NULL)))
 156         {
 157             ERR("IDirectSoundBuffer_GetCurrentPosition failed, hr %#lx\n", hr);
 158             return hr;
 159         }
 160
 161         played += play_pos - start_pos + (play_pos < start_pos ? caps->dwBufferBytes : 0);
 162         if (played >= written) break;
 163
 164         TRACE("Waiting for EOS, start_pos %#lx, play_pos %#lx, written %#lx, played %#lx\n",
 165                 start_pos, play_pos, written, played);
 166         if ((ret = WaitForMultipleObjects(1, &buffer_event, FALSE, INFINITE)))
 167         {
 168             ERR("WaitForMultipleObjects returned %#lx\n", ret);
 169             break;
 170         }
 171
 172         start_pos = play_pos;
 173     }
 174
 175     return S_OK;
 176 }
 177
 178 static HRESULT synth_sink_render_data(struct synth_sink *sink, IDirectMusicSynth *synth,
 179         IDirectSoundBuffer *buffer, WAVEFORMATEX *format, short *samples, DWORD samples_size)
 180 {
 181     REFERENCE_TIME sample_time;
 182     HRESULT hr;
 183
 184     if (FAILED(hr = IDirectMusicSynth_Render(synth, samples, samples_size / format->nBlockAlign,
 185             sink->written / format->nBlockAlign)))
 186         ERR("Failed to render synthesizer samples, hr %#lx\n", hr);
 187
 188     if (FAILED(hr = IDirectMusicSynthSink_SampleToRefTime(&sink->IDirectMusicSynthSink_iface,
 189             (sink->written + samples_size) / format->nBlockAlign, &sample_time)))
 190         ERR("Failed to convert sample position to time, hr %#lx\n", hr);
 191
 192     EnterCriticalSection(&sink->cs);
 193     sink->latency_time = sample_time;
 194     LeaveCriticalSection(&sink->cs);
 195
 196     return hr;
 197 }
 198
 199 struct render_thread_params
 200 {
 201     struct synth_sink *sink;
 202     IDirectMusicSynth *synth;
 203     IDirectSoundBuffer *buffer;
 204     HANDLE started_event;
 205 };
 206
 207 static DWORD CALLBACK synth_sink_render_thread(void *args)
 208 {
 209     struct render_thread_params *params = args;
 210     DSBCAPS caps = {.dwSize = sizeof(DSBCAPS)};
 211     IDirectSoundBuffer *buffer = params->buffer;
 212     IDirectMusicSynth *synth = params->synth;
 213     struct synth_sink *sink = params->sink;
 214     IDirectSoundNotify *notify;
 215     WAVEFORMATEX format;
 216     HANDLE buffer_event;
 217     DWORD samples_size;
 218     short *samples;
 219     HRESULT hr;
 220
 221     TRACE("Starting thread, args %p\n", args);
 222     SetThreadDescription(GetCurrentThread(), L"wine_dmsynth_sink");
 223
 224     if (FAILED(hr = IDirectSoundBuffer_Stop(buffer)))
 225         ERR("Failed to stop sound buffer, hr %#lx.\n", hr);
 226
 227     if (!(buffer_event = CreateEventW(NULL, FALSE, FALSE, NULL)))
 228         ERR("Failed to create buffer event, error %lu\n", GetLastError());
 229     else if (FAILED(hr = IDirectSoundBuffer_GetCaps(buffer, &caps)))
 230         ERR("Failed to query sound buffer caps, hr %#lx.\n", hr);
 231     else if (FAILED(hr = IDirectSoundBuffer_GetFormat(buffer, &format, sizeof(format), NULL)))
 232         ERR("Failed to query sound buffer format, hr %#lx.\n", hr);
 233     else if (FAILED(hr = IDirectSoundBuffer_QueryInterface(buffer, &IID_IDirectSoundNotify,
 234                 (void **)&notify)))
 235         ERR("Failed to query IDirectSoundNotify iface, hr %#lx.\n", hr);
 236     else
 237     {
 238         DSBPOSITIONNOTIFY positions[BUFFER_SUBDIVISIONS] = {{.dwOffset = 0, .hEventNotify = buffer_event}};
 239         int i;
 240
 241         for (i = 1; i < ARRAY_SIZE(positions); ++i)
 242         {
 243             positions[i] = positions[i - 1];
 244             positions[i].dwOffset += caps.dwBufferBytes / ARRAY_SIZE(positions);
 245         }
 246
 247         if (FAILED(hr = IDirectSoundNotify_SetNotificationPositions(notify,
 248                 ARRAY_SIZE(positions), positions)))
 249             ERR("Failed to set notification positions, hr %#lx\n", hr);
 250
 251         IDirectSoundNotify_Release(notify);
 252     }
 253
 254     samples_size = caps.dwBufferBytes / BUFFER_SUBDIVISIONS;
 255     if (!(samples = malloc(samples_size)))
 256     {
 257         ERR("Failed to allocate memory for samples\n");
 258         goto done;
 259     }
 260
 261     if (FAILED(hr = synth_sink_render_data(sink, synth, buffer, &format, samples, samples_size)))
 262         ERR("Failed to render initial buffer data, hr %#lx.\n", hr);
 263     if (FAILED(hr = IDirectSoundBuffer_Play(buffer, 0, 0, DSBPLAY_LOOPING)))
 264         ERR("Failed to start sound buffer, hr %#lx.\n", hr);
 265     SetEvent(params->started_event);
 266
 267     while (SUCCEEDED(hr) && SUCCEEDED(hr = synth_sink_write_data(sink, buffer,
 268             &caps, &format, samples, samples_size)))
 269     {
 270         HANDLE handles[] = {sink->stop_event, buffer_event};
 271         DWORD ret;
 272
 273         if (hr == S_OK) /* if successfully written, render more data */
 274             hr = synth_sink_render_data(sink, synth, buffer, &format, samples, samples_size);
 275
 276         if (!(ret = WaitForMultipleObjects(ARRAY_SIZE(handles), handles, FALSE, INFINITE))
 277                 || ret >= ARRAY_SIZE(handles))
 278         {
 279             ERR("WaitForMultipleObjects returned %lu\n", ret);
 280             hr = HRESULT_FROM_WIN32(ret);
 281             break;
 282         }
 283     }
 284
 285     if (FAILED(hr))
 286     {
 287         ERR("Thread unexpected termination, hr %#lx\n", hr);
 288         return hr;
 289     }
 290
 291     synth_sink_wait_play_end(sink, buffer, &caps, &format, buffer_event);
 292     free(samples);
 293
 294 done:
 295     IDirectSoundBuffer_Release(buffer);
 296     IDirectMusicSynth_Release(synth);
 297     CloseHandle(buffer_event);
 298
 299     return 0;
 300 }
 301
 302 static HRESULT synth_sink_activate(struct synth_sink *This)
 303 {
 304     IDirectMusicSynthSink *iface = &This->IDirectMusicSynthSink_iface;
 305     DSBUFFERDESC desc = {.dwSize = sizeof(DSBUFFERDESC)};
 306     struct render_thread_params params;
 307     WAVEFORMATEX format;
 308     HRESULT hr;
 309
 310     if (!This->synth) return DMUS_E_SYNTHNOTCONFIGURED;
 311     if (!This->dsound) return DMUS_E_DSOUND_NOT_SET;
 312     if (!This->master_clock) return DMUS_E_NO_MASTER_CLOCK;
 313     if (This->active) return DMUS_E_SYNTHACTIVE;
 314
 315     if (FAILED(hr = IReferenceClock_GetTime(This->master_clock, &This->activate_time))) return hr;
 316     This->latency_time = This->activate_time;
 317
 318     if ((params.buffer = This->dsound_buffer))
 319         IDirectMusicBuffer_AddRef(params.buffer);
 320     else
 321     {
 322         synth_sink_get_format(This, &format);
 323         desc.lpwfxFormat = &format;
 324         desc.dwBufferBytes = format.nAvgBytesPerSec;
 325         if (FAILED(hr = IDirectMusicSynthSink_GetDesiredBufferSize(iface, &desc.dwBufferBytes)))
 326             ERR("Failed to get desired buffer size, hr %#lx\n", hr);
 327
 328         desc.dwFlags = DSBCAPS_GLOBALFOCUS | DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_CTRLPOSITIONNOTIFY;
 329         if (FAILED(hr = IDirectSound8_CreateSoundBuffer(This->dsound, &desc, &params.buffer, NULL)))
 330         {
 331             ERR("Failed to create sound buffer, hr %#lx.\n", hr);
 332             return hr;
 333         }
 334     }
 335
 336     params.sink = This;
 337     params.synth = This->synth;
 338     IDirectMusicSynth_AddRef(This->synth);
 339
 340     if (!(params.started_event = CreateEventW(NULL, FALSE, FALSE, NULL))
 341             || !(This->render_thread = CreateThread(NULL, 0, synth_sink_render_thread, &params, 0, NULL)))
 342     {
 343         ERR("Failed to create render thread, error %lu\n", GetLastError());
 344         hr = HRESULT_FROM_WIN32(GetLastError());
 345         IDirectSoundBuffer_Release(params.buffer);
 346         IDirectMusicSynth_Release(params.synth);
 347         CloseHandle(params.started_event);
 348         return hr;
 349     }
 350
 351     WaitForSingleObject(params.started_event, INFINITE);
 352     CloseHandle(params.started_event);
 353     This->active = TRUE;
 354     return S_OK;
 355 }
 356
 357 static HRESULT synth_sink_deactivate(struct synth_sink *This)
 358 {
 359     if (!This->active) return S_OK;
 360
 361     SetEvent(This->stop_event);
 362     WaitForSingleObject(This->render_thread, INFINITE);
 363     This->render_thread = NULL;
 364     This->active = FALSE;
 365
 366     return S_OK;
 367 }
 368
 369 static HRESULT WINAPI synth_sink_QueryInterface(IDirectMusicSynthSink *iface,
 370         REFIID riid, void **ret_iface)
 371 {
 372     struct synth_sink *This = impl_from_IDirectMusicSynthSink(iface);
 373
 374     TRACE("(%p)->(%s, %p)\n", iface, debugstr_dmguid(riid), ret_iface);
 375
 376     if (IsEqualIID (riid, &IID_IUnknown) ||
 377         IsEqualIID (riid, &IID_IDirectMusicSynthSink))
 378     {
 379         IUnknown_AddRef(iface);
 380         *ret_iface = iface;
 381         return S_OK;
 382     }
 383     else if (IsEqualIID(riid, &IID_IKsControl))
 384     {
 385         IUnknown_AddRef(iface);
 386         *ret_iface = &This->IKsControl_iface;
 387         return S_OK;
 388     }
 389
 390     *ret_iface = NULL;
 391
 392     WARN("(%p)->(%s, %p): not found\n", iface, debugstr_dmguid(riid), ret_iface);
 393
 394     return E_NOINTERFACE;
 395 }
 396
 397 static ULONG WINAPI synth_sink_AddRef(IDirectMusicSynthSink *iface)
 398 {
 399     struct synth_sink *This = impl_from_IDirectMusicSynthSink(iface);
 400     ULONG ref = InterlockedIncrement(&This->ref);
 401
 402     TRACE("(%p): new ref = %lu\n", This, ref);
 403
 404     return ref;
 405 }
 406
 407 static ULONG WINAPI synth_sink_Release(IDirectMusicSynthSink *iface)
 408 {
 409     struct synth_sink *This = impl_from_IDirectMusicSynthSink(iface);
 410     ULONG ref = InterlockedDecrement(&This->ref);
 411
 412     TRACE("(%p): new ref = %lu\n", This, ref);
 413
 414     if (!ref) {
 415         if (This->active)
 416             IDirectMusicSynthSink_Activate(iface, FALSE);
 417         if (This->master_clock)
 418             IReferenceClock_Release(This->master_clock);
 419
 420         This->cs.DebugInfo->Spare[0] = 0;
 421         DeleteCriticalSection(&This->cs);
 422         CloseHandle(This->stop_event);
 423
 424         free(This);
 425     }
 426
 427     return ref;
 428 }
 429
 430 static HRESULT WINAPI synth_sink_Init(IDirectMusicSynthSink *iface,
 431         IDirectMusicSynth *synth)
 432 {
 433     struct synth_sink *This = impl_from_IDirectMusicSynthSink(iface);
 434
 435     TRACE("(%p)->(%p)\n", This, synth);
 436
 437     /* Not holding a reference to avoid circular dependencies.
 438        The synth will release the sink during the synth's destruction. */
 439     This->synth = synth;
 440
 441     return S_OK;
 442 }
 443
 444 static HRESULT WINAPI synth_sink_SetMasterClock(IDirectMusicSynthSink *iface,
 445         IReferenceClock *clock)
 446 {
 447     struct synth_sink *This = impl_from_IDirectMusicSynthSink(iface);
 448
 449     TRACE("(%p)->(%p)\n", This, clock);
 450
 451     if (!clock)
 452         return E_POINTER;
 453
 454     if (This->master_clock) IReferenceClock_Release(This->master_clock);
 455     IReferenceClock_AddRef(clock);
 456     This->master_clock = clock;
 457
 458     return S_OK;
 459 }
 460
 461 static HRESULT WINAPI synth_sink_GetLatencyClock(IDirectMusicSynthSink *iface,
 462         IReferenceClock **clock)
 463 {
 464     struct synth_sink *This = impl_from_IDirectMusicSynthSink(iface);
 465
 466     TRACE("(%p)->(%p)\n", iface, clock);
 467
 468     if (!clock)
 469         return E_POINTER;
 470
 471     *clock = &This->IReferenceClock_iface;
 472     IReferenceClock_AddRef(*clock);
 473
 474     return S_OK;
 475 }
 476
 477 static HRESULT WINAPI synth_sink_Activate(IDirectMusicSynthSink *iface,
 478         BOOL enable)
 479 {
 480     struct synth_sink *This = impl_from_IDirectMusicSynthSink(iface);
 481
 482     FIXME("(%p)->(%d): semi-stub\n", This, enable);
 483
 484     return enable ? synth_sink_activate(This) : synth_sink_deactivate(This);
 485 }
 486
 487 static HRESULT WINAPI synth_sink_SampleToRefTime(IDirectMusicSynthSink *iface,
 488         LONGLONG sample_time, REFERENCE_TIME *ref_time)
 489 {
 490     struct synth_sink *This = impl_from_IDirectMusicSynthSink(iface);
 491     WAVEFORMATEX format;
 492
 493     TRACE("(%p)->(%I64d, %p)\n", This, sample_time, ref_time);
 494
 495     if (!ref_time) return E_POINTER;
 496
 497     synth_sink_get_format(This, &format);
 498     *ref_time = This->activate_time + ((sample_time * 10000) / format.nSamplesPerSec) * 1000;
 499
 500     return S_OK;
 501 }
 502
 503 static HRESULT WINAPI synth_sink_RefTimeToSample(IDirectMusicSynthSink *iface,
 504         REFERENCE_TIME ref_time, LONGLONG *sample_time)
 505 {
 506     struct synth_sink *This = impl_from_IDirectMusicSynthSink(iface);
 507     WAVEFORMATEX format;
 508
 509     TRACE("(%p)->(%I64d, %p)\n", This, ref_time, sample_time);
 510
 511     if (!sample_time) return E_POINTER;
 512
 513     synth_sink_get_format(This, &format);
 514     ref_time -= This->activate_time;
 515     *sample_time = ((ref_time / 1000) * format.nSamplesPerSec) / 10000;
 516
 517     return S_OK;
 518 }
 519
 520 static HRESULT WINAPI synth_sink_SetDirectSound(IDirectMusicSynthSink *iface,
 521         IDirectSound *dsound, IDirectSoundBuffer *dsound_buffer)
 522 {
 523     struct synth_sink *This = impl_from_IDirectMusicSynthSink(iface);
 524
 525     TRACE("(%p)->(%p, %p)\n", This, dsound, dsound_buffer);
 526
 527     if (This->active) return DMUS_E_SYNTHACTIVE;
 528
 529     if (This->dsound) IDirectSound_Release(This->dsound);
 530     This->dsound = NULL;
 531     if (This->dsound_buffer) IDirectSoundBuffer_Release(This->dsound_buffer);
 532     This->dsound_buffer = NULL;
 533     if (!dsound) return S_OK;
 534
 535     if (!This->synth) return DMUS_E_SYNTHNOTCONFIGURED;
 536     if ((This->dsound = dsound)) IDirectSound_AddRef(This->dsound);
 537     if ((This->dsound_buffer = dsound_buffer)) IDirectSoundBuffer_AddRef(This->dsound_buffer);
 538
 539     return S_OK;
 540 }
 541
 542 static HRESULT WINAPI synth_sink_GetDesiredBufferSize(IDirectMusicSynthSink *iface,
 543         DWORD *size)
 544 {
 545     struct synth_sink *This = impl_from_IDirectMusicSynthSink(iface);
 546     WAVEFORMATEX format;
 547     DWORD fmtsize = sizeof(format);
 548
 549     TRACE("(%p, %p)\n", This, size);
 550
 551     if (!size)
 552         return E_POINTER;
 553     if (!This->synth)
 554         return DMUS_E_SYNTHNOTCONFIGURED;
 555
 556     if (FAILED(IDirectMusicSynth_GetFormat(This->synth, &format, &fmtsize)))
 557         return E_UNEXPECTED;
 558     *size = format.nSamplesPerSec * format.nChannels * 4;
 559
 560     return S_OK;
 561 }
 562
 563 static const IDirectMusicSynthSinkVtbl synth_sink_vtbl =
 564 {
 565         synth_sink_QueryInterface,
 566         synth_sink_AddRef,
 567         synth_sink_Release,
 568         synth_sink_Init,
 569         synth_sink_SetMasterClock,
 570         synth_sink_GetLatencyClock,
 571         synth_sink_Activate,
 572         synth_sink_SampleToRefTime,
 573         synth_sink_RefTimeToSample,
 574         synth_sink_SetDirectSound,
 575         synth_sink_GetDesiredBufferSize,
 576 };
 577
 578 static inline struct synth_sink *impl_from_IKsControl(IKsControl *iface)
 579 {
 580     return CONTAINING_RECORD(iface, struct synth_sink, IKsControl_iface);
 581 }
 582
 583 static HRESULT WINAPI synth_sink_control_QueryInterface(IKsControl* iface, REFIID riid, LPVOID *ppobj)
 584 {
 585     struct synth_sink *This = impl_from_IKsControl(iface);
 586
 587     return synth_sink_QueryInterface(&This->IDirectMusicSynthSink_iface, riid, ppobj);
 588 }
 589
 590 static ULONG WINAPI synth_sink_control_AddRef(IKsControl* iface)
 591 {
 592     struct synth_sink *This = impl_from_IKsControl(iface);
 593
 594     return synth_sink_AddRef(&This->IDirectMusicSynthSink_iface);
 595 }
 596
 597 static ULONG WINAPI synth_sink_control_Release(IKsControl* iface)
 598 {
 599     struct synth_sink *This = impl_from_IKsControl(iface);
 600
 601     return synth_sink_Release(&This->IDirectMusicSynthSink_iface);
 602 }
 603
 604 static HRESULT WINAPI synth_sink_control_KsProperty(IKsControl* iface, PKSPROPERTY Property,
 605         ULONG PropertyLength, LPVOID PropertyData, ULONG DataLength, ULONG* BytesReturned)
 606 {
 607     TRACE("(%p, %p, %lu, %p, %lu, %p)\n", iface, Property, PropertyLength, PropertyData, DataLength, BytesReturned);
 608
 609     TRACE("Property = %s - %lu - %lu\n", debugstr_guid(&Property->Set), Property->Id, Property->Flags);
 610
 611     if (Property->Flags != KSPROPERTY_TYPE_GET)
 612     {
 613         FIXME("Property flags %lu not yet supported\n", Property->Flags);
 614         return S_FALSE;
 615     }
 616
 617     if (DataLength <  sizeof(DWORD))
 618         return E_NOT_SUFFICIENT_BUFFER;
 619
 620     if (IsEqualGUID(&Property->Set, &GUID_DMUS_PROP_SinkUsesDSound))
 621     {
 622         *(DWORD*)PropertyData = TRUE;
 623         *BytesReturned = sizeof(DWORD);
 624     }
 625     else
 626     {
 627         FIXME("Unknown property %s\n", debugstr_guid(&Property->Set));
 628         *(DWORD*)PropertyData = FALSE;
 629         *BytesReturned = sizeof(DWORD);
 630     }
 631
 632     return S_OK;
 633 }
 634
 635 static HRESULT WINAPI synth_sink_control_KsMethod(IKsControl* iface, PKSMETHOD Method,
 636         ULONG MethodLength, LPVOID MethodData, ULONG DataLength, ULONG* BytesReturned)
 637 {
 638     FIXME("(%p, %p, %lu, %p, %lu, %p): stub\n", iface, Method, MethodLength, MethodData, DataLength, BytesReturned);
 639
 640     return E_NOTIMPL;
 641 }
 642
 643 static HRESULT WINAPI synth_sink_control_KsEvent(IKsControl* iface, PKSEVENT Event,
 644         ULONG EventLength, LPVOID EventData, ULONG DataLength, ULONG* BytesReturned)
 645 {
 646     FIXME("(%p, %p, %lu, %p, %lu, %p): stub\n", iface, Event, EventLength, EventData, DataLength, BytesReturned);
 647
 648     return E_NOTIMPL;
 649 }
 650
 651
 652 static const IKsControlVtbl synth_sink_control =
 653 {
 654     synth_sink_control_QueryInterface,
 655     synth_sink_control_AddRef,
 656     synth_sink_control_Release,
 657     synth_sink_control_KsProperty,
 658     synth_sink_control_KsMethod,
 659     synth_sink_control_KsEvent,
 660 };
 661
 662 static inline struct synth_sink *impl_from_IReferenceClock(IReferenceClock *iface)
 663 {
 664     return CONTAINING_RECORD(iface, struct synth_sink, IReferenceClock_iface);
 665 }
 666
 667 static HRESULT WINAPI latency_clock_QueryInterface(IReferenceClock *iface, REFIID iid, void **out)
 668 {
 669     TRACE("(%p, %s, %p)\n", iface, debugstr_dmguid(iid), out);
 670
 671     if (IsEqualIID(iid, &IID_IUnknown)
 672             || IsEqualIID(iid, &IID_IReferenceClock))
 673     {
 674         IUnknown_AddRef(iface);
 675         *out = iface;
 676         return S_OK;
 677     }
 678
 679     FIXME("no interface for %s\n", debugstr_dmguid(iid));
 680     *out = NULL;
 681     return E_NOINTERFACE;
 682 }
 683
 684 static ULONG WINAPI latency_clock_AddRef(IReferenceClock *iface)
 685 {
 686     struct synth_sink *This = impl_from_IReferenceClock(iface);
 687     return IDirectMusicSynthSink_AddRef(&This->IDirectMusicSynthSink_iface);
 688 }
 689
 690 static ULONG WINAPI latency_clock_Release(IReferenceClock *iface)
 691 {
 692     struct synth_sink *This = impl_from_IReferenceClock(iface);
 693     return IDirectMusicSynthSink_Release(&This->IDirectMusicSynthSink_iface);
 694 }
 695
 696 static HRESULT WINAPI latency_clock_GetTime(IReferenceClock *iface, REFERENCE_TIME *time)
 697 {
 698     struct synth_sink *This = impl_from_IReferenceClock(iface);
 699
 700     TRACE("(%p, %p)\n", iface, time);
 701
 702     if (!time) return E_INVALIDARG;
 703     if (!This->active) return E_FAIL;
 704
 705     EnterCriticalSection(&This->cs);
 706     *time = This->latency_time;
 707     LeaveCriticalSection(&This->cs);
 708
 709     return S_OK;
 710 }
 711
 712 static HRESULT WINAPI latency_clock_AdviseTime(IReferenceClock *iface, REFERENCE_TIME base,
 713         REFERENCE_TIME offset, HEVENT event, DWORD_PTR *cookie)
 714 {
 715     FIXME("(%p, %I64d, %I64d, %#Ix, %p): stub\n", iface, base, offset, event, cookie);
 716     return E_NOTIMPL;
 717 }
 718
 719 static HRESULT WINAPI latency_clock_AdvisePeriodic(IReferenceClock *iface, REFERENCE_TIME start,
 720         REFERENCE_TIME period, HSEMAPHORE semaphore, DWORD_PTR *cookie)
 721 {
 722     FIXME("(%p, %I64d, %I64d, %#Ix, %p): stub\n", iface, start, period, semaphore, cookie);
 723     return E_NOTIMPL;
 724 }
 725
 726 static HRESULT WINAPI latency_clock_Unadvise(IReferenceClock *iface, DWORD_PTR cookie)
 727 {
 728     FIXME("(%p, %#Ix): stub\n", iface, cookie);
 729     return E_NOTIMPL;
 730 }
 731
 732 static const IReferenceClockVtbl latency_clock_vtbl =
 733 {
 734     latency_clock_QueryInterface,
 735     latency_clock_AddRef,
 736     latency_clock_Release,
 737     latency_clock_GetTime,
 738     latency_clock_AdviseTime,
 739     latency_clock_AdvisePeriodic,
 740     latency_clock_Unadvise,
 741 };
 742
 743 HRESULT synth_sink_create(IUnknown **ret_iface)
 744 {
 745     struct synth_sink *obj;
 746
 747     TRACE("(%p)\n", ret_iface);
 748
 749     *ret_iface = NULL;
 750     if (!(obj = calloc(1, sizeof(*obj)))) return E_OUTOFMEMORY;
 751     obj->IDirectMusicSynthSink_iface.lpVtbl = &synth_sink_vtbl;
 752     obj->IKsControl_iface.lpVtbl = &synth_sink_control;
 753     obj->IReferenceClock_iface.lpVtbl = &latency_clock_vtbl;
 754     obj->ref = 1;
 755
 756     obj->stop_event = CreateEventW(NULL, FALSE, FALSE, NULL);
 757     InitializeCriticalSection(&obj->cs);
 758     obj->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": cs");
 759
 760     TRACE("Created DirectMusicSynthSink %p\n", obj);
 761     *ret_iface = (IUnknown *)&obj->IDirectMusicSynthSink_iface;
 762     return S_OK;
 763 }